Changes in 4.9.212 xfs: Sanity check flags of Q_XQUOTARM call powerpc/archrandom: fix arch_get_random_seed_int() mt7601u: fix bbp version check in mt7601u_wait_bbp_ready drm/sti: do not remove the drm_bridge that was never added drm/virtio: fix bounds check in virtio_gpu_cmd_get_capset() ALSA: hda: fix unused variable warning IB/rxe: replace kvfree with vfree ALSA: usb-audio: update quirk for B&W PX to remove microphone staging: comedi: ni_mio_common: protect register write overflow pwm: lpss: Release runtime-pm reference from the driver's remove callback mlxsw: reg: QEEC: Add minimum shaper fields pcrypt: use format specifier in kobject_add exportfs: fix 'passing zero to ERR_PTR()' warning drm/dp_mst: Skip validating ports during destruction, just ref net: phy: Fix not to call phy_resume() if PHY is not attached pinctrl: sh-pfc: r8a7740: Add missing REF125CK pin to gether_gmii group pinctrl: sh-pfc: r8a7740: Add missing LCD0 marks to lcd0_data24_1 group pinctrl: sh-pfc: r8a7791: Remove bogus ctrl marks from qspi_data4_b group pinctrl: sh-pfc: r8a7791: Remove bogus marks from vin1_b_data18 group pinctrl: sh-pfc: sh73a0: Add missing TO pin to tpu4_to3 group pinctrl: sh-pfc: r8a7794: Remove bogus IPSR9 field pinctrl: sh-pfc: sh7734: Add missing IPSR11 field pinctrl: sh-pfc: sh7269: Add missing PCIOR0 field pinctrl: sh-pfc: sh7734: Remove bogus IPSR10 value Input: nomadik-ske-keypad - fix a loop timeout test clk: highbank: fix refcount leak in hb_clk_init() clk: qoriq: fix refcount leak in clockgen_init() clk: socfpga: fix refcount leak clk: samsung: exynos4: fix refcount leak in exynos4_get_xom() clk: imx6q: fix refcount leak in imx6q_clocks_init() clk: imx6sx: fix refcount leak in imx6sx_clocks_init() clk: imx7d: fix refcount leak in imx7d_clocks_init() clk: vf610: fix refcount leak in vf610_clocks_init() clk: armada-370: fix refcount leak in a370_clk_init() clk: kirkwood: fix refcount leak in kirkwood_clk_init() clk: armada-xp: fix refcount leak in axp_clk_init() clk: dove: fix refcount leak in dove_clk_init() IB/usnic: Fix out of bounds index check in query pkey RDMA/ocrdma: Fix out of bounds index check in query pkey RDMA/qedr: Fix out of bounds index check in query pkey arm64: dts: apq8016-sbc: Increase load on l11 for SDCARD drm/etnaviv: NULL vs IS_ERR() buf in etnaviv_core_dump() media: s5p-jpeg: Correct step and max values for V4L2_CID_JPEG_RESTART_INTERVAL crypto: tgr192 - fix unaligned memory access ASoC: imx-sgtl5000: put of nodes if finding codec fails IB/iser: Pass the correct number of entries for dma mapped SGL rtc: cmos: ignore bogus century byte clk: sunxi-ng: sun8i-a23: Enable PLL-MIPI LDOs when ungating it iwlwifi: mvm: fix A-MPDU reference assignment tty: ipwireless: Fix potential NULL pointer dereference crypto: crypto4xx - Fix wrong ppc4xx_trng_probe()/ppc4xx_trng_remove() arguments ARM: dts: lpc32xx: add required clocks property to keypad device node ARM: dts: lpc32xx: reparent keypad controller to SIC1 ARM: dts: lpc32xx: fix ARM PrimeCell LCD controller variant ARM: dts: lpc32xx: fix ARM PrimeCell LCD controller clocks property ARM: dts: lpc32xx: phy3250: fix SD card regulator voltage iwlwifi: mvm: fix RSS config command staging: most: cdev: add missing check for cdev_add failure rtc: ds1672: fix unintended sign extension thermal: mediatek: fix register index error net: phy: fixed_phy: Fix fixed_phy not checking GPIO rtc: 88pm860x: fix unintended sign extension rtc: 88pm80x: fix unintended sign extension rtc: pm8xxx: fix unintended sign extension fbdev: chipsfb: remove set but not used variable 'size' iw_cxgb4: use tos when importing the endpoint iw_cxgb4: use tos when finding ipv6 routes pinctrl: sh-pfc: emev2: Add missing pinmux functions pinctrl: sh-pfc: r8a7791: Fix scifb2_data_c pin group pinctrl: sh-pfc: r8a7792: Fix vin1_data18_b pin group pinctrl: sh-pfc: sh73a0: Fix fsic_spdif pin groups usb: phy: twl6030-usb: fix possible use-after-free on remove block: don't use bio->bi_vcnt to figure out segment number keys: Timestamp new keys vfio_pci: Enable memory accesses before calling pci_map_rom dmaengine: mv_xor: Use correct device for DMA API cdc-wdm: pass return value of recover_from_urb_loss regulator: pv88060: Fix array out-of-bounds access regulator: pv88080: Fix array out-of-bounds access regulator: pv88090: Fix array out-of-bounds access net: dsa: qca8k: Enable delay for RGMII_ID mode drm/nouveau/bios/ramcfg: fix missing parentheses when calculating RON drm/nouveau/pmu: don't print reply values if exec is false ASoC: qcom: Fix of-node refcount unbalance in apq8016_sbc_parse_of() fs/nfs: Fix nfs_parse_devname to not modify it's argument NFS: Fix a soft lockup in the delegation recovery code clocksource/drivers/sun5i: Fail gracefully when clock rate is unavailable clocksource/drivers/exynos_mct: Fix error path in timer resources initialization mmc: sdhci-brcmstb: handle mmc_of_parse() errors during probe ARM: 8847/1: pm: fix HYP/SVC mode mismatch when MCPM is used ARM: 8848/1: virt: Align GIC version check with arm64 counterpart regulator: wm831x-dcdc: Fix list of wm831x_dcdc_ilim from mA to uA nios2: ksyms: Add missing symbol exports scsi: megaraid_sas: reduce module load time drivers/rapidio/rio_cm.c: fix potential oops in riocm_ch_listen() xen, cpu_hotplug: Prevent an out of bounds access net: sh_eth: fix a missing check of of_get_phy_mode media: ivtv: update *pos correctly in ivtv_read_pos() media: cx18: update *pos correctly in cx18_read_pos() media: wl128x: Fix an error code in fm_download_firmware() media: cx23885: check allocation return regulator: tps65086: Fix tps65086_ldoa1_ranges for selector 0xB jfs: fix bogus variable self-initialization tipc: tipc clang warning m68k: mac: Fix VIA timer counter accesses ARM: OMAP2+: Fix potentially uninitialized return value for _setup_reset() media: davinci-isif: avoid uninitialized variable use media: tw5864: Fix possible NULL pointer dereference in tw5864_handle_frame spi: tegra114: clear packed bit for unpacked mode spi: tegra114: fix for unpacked mode transfers soc/fsl/qe: Fix an error code in qe_pin_request() spi: bcm2835aux: fix driver to not allow 65535 (=-1) cs-gpios ehea: Fix a copy-paste err in ehea_init_port_res scsi: qla2xxx: Unregister chrdev if module initialization fails ARM: pxa: ssp: Fix "WARNING: invalid free of devm_ allocated data" hwmon: (w83627hf) Use request_muxed_region for Super-IO accesses tipc: set sysctl_tipc_rmem and named_timeout right range powerpc: vdso: Make vdso32 installation conditional in vdso_install ARM: dts: ls1021: Fix SGMII PCS link remaining down after PHY disconnect media: ov2659: fix unbalanced mutex_lock/unlock 6lowpan: Off by one handling ->nexthdr dmaengine: axi-dmac: Don't check the number of frames for alignment ALSA: usb-audio: Handle the error from snd_usb_mixer_apply_create_quirk() packet: in recvmsg msg_name return at least sizeof sockaddr_ll ASoC: fix valid stream condition usb: gadget: fsl: fix link error against usb-gadget module IB/mlx5: Add missing XRC options to QP optional params mask iommu/vt-d: Make kernel parameter igfx_off work with vIOMMU net: ena: fix swapped parameters when calling ena_com_indirect_table_fill_entry net: ena: fix: Free napi resources when ena_up() fails net: ena: fix incorrect test of supported hash function net: ena: fix ena_com_fill_hash_function() implementation dmaengine: tegra210-adma: restore channel status l2tp: Fix possible NULL pointer dereference media: omap_vout: potential buffer overflow in vidioc_dqbuf() media: davinci/vpbe: array underflow in vpbe_enum_outputs() platform/x86: alienware-wmi: printing the wrong error code netfilter: ebtables: CONFIG_COMPAT: reject trailing data after last rule pwm: meson: Don't disable PWM when setting duty repeatedly ARM: riscpc: fix lack of keyboard interrupts after irq conversion kdb: do a sanity check on the cpu in kdb_per_cpu() backlight: lm3630a: Return 0 on success in update_status functions thermal: cpu_cooling: Actually trace CPU load in thermal_power_cpu_get_power dmaengine: tegra210-adma: Fix crash during probe spi: spi-fsl-spi: call spi_finalize_current_message() at the end crypto: ccp - fix AES CFB error exposed by new test vectors serial: stm32: fix transmit_chars when tx is stopped misc: sgi-xp: Properly initialize buf in xpc_get_rsvd_page_pa iommu: Use right function to get group for device signal/cifs: Fix cifs_put_tcp_session to call send_sig instead of force_sig inet: frags: call inet_frags_fini() after unregister_pernet_subsys() media: vivid: fix incorrect assignment operation when setting video mode powerpc/cacheinfo: add cacheinfo_teardown, cacheinfo_rebuild drm/msm/mdp5: Fix mdp5_cfg_init error return net: netem: fix backlog accounting for corrupted GSO frames net/af_iucv: always register net_device notifier ASoC: ti: davinci-mcasp: Fix slot mask settings when using multiple AXRs rtc: pcf8563: Clear event flags and disable interrupts before requesting irq drm/msm/a3xx: remove TPL1 regs from snapshot perf/ioctl: Add check for the sample_period value dmaengine: hsu: Revert "set HSU_CH_MTSR to memory width" clk: qcom: Fix -Wunused-const-variable iommu/amd: Make iommu_disable safer mfd: intel-lpss: Release IDA resources rxrpc: Fix uninitialized error code in rxrpc_send_data_packet() devres: allow const resource arguments RDMA/hns: Fixs hw access invalid dma memory error net: pasemi: fix an use-after-free in pasemi_mac_phy_init() scsi: libfc: fix null pointer dereference on a null lport libertas_tf: Use correct channel range in lbtf_geo_init qed: reduce maximum stack frame size usb: host: xhci-hub: fix extra endianness conversion mic: avoid statically declaring a 'struct device'. x86/kgbd: Use NMI_VECTOR not APIC_DM_NMI ALSA: aoa: onyx: always initialize register read value net/mlx5: Fix mlx5_ifc_query_lag_out_bits cifs: fix rmmod regression in cifs.ko caused by force_sig changes crypto: caam - free resources in case caam_rng registration failed ext4: set error return correctly when ext4_htree_store_dirent fails ASoC: es8328: Fix copy-paste error in es8328_right_line_controls ASoC: cs4349: Use PM ops 'cs4349_runtime_pm' ASoC: wm8737: Fix copy-paste error in wm8737_snd_controls signal: Allow cifs and drbd to receive their terminating signals ASoC: sun4i-i2s: RX and TX counter registers are swapped dmaengine: dw: platform: Switch to acpi_dma_controller_register() mac80211: minstrel_ht: fix per-group max throughput rate initialization mips: avoid explicit UB in assignment of mips_io_port_base ahci: Do not export local variable ahci_em_messages Partially revert "kfifo: fix kfifo_alloc() and kfifo_init()" hwmon: (lm75) Fix write operations for negative temperatures power: supply: Init device wakeup after device_add() x86, perf: Fix the dependency of the x86 insn decoder selftest staging: greybus: light: fix a couple double frees bcma: fix incorrect update of BCMA_CORE_PCI_MDIO_DATA iio: dac: ad5380: fix incorrect assignment to val ath9k: dynack: fix possible deadlock in ath_dynack_node_{de}init net: sonic: return NETDEV_TX_OK if failed to map buffer Btrfs: fix hang when loading existing inode cache off disk hwmon: (shtc1) fix shtc1 and shtw1 id mask net: sonic: replace dev_kfree_skb in sonic_send_packet net/rds: Fix 'ib_evt_handler_call' element in 'rds_ib_stat_names' iommu/amd: Wait for completion of IOTLB flush in attach_device net: hisilicon: Fix signedness bug in hix5hd2_dev_probe() net: broadcom/bcmsysport: Fix signedness in bcm_sysport_probe() net: stmmac: dwmac-meson8b: Fix signedness bug in probe of: mdio: Fix a signedness bug in of_phy_get_and_connect() net: ethernet: stmmac: Fix signedness bug in ipq806x_gmac_of_parse() nvme: retain split access workaround for capability reads net: stmmac: gmac4+: Not all Unicast addresses may be available mac80211: accept deauth frames in IBSS mode llc: fix another potential sk_buff leak in llc_ui_sendmsg() llc: fix sk_buff refcounting in llc_conn_state_process() net: stmmac: fix length of PTP clock's name string act_mirred: Fix mirred_init_module error handling drm/msm/dsi: Implement reset correctly dmaengine: imx-sdma: fix size check for sdma script_number net: netem: fix error path for corrupted GSO frames net: netem: correct the parent's backlog when corrupted packet was dropped net: qca_spi: Move reset_count to struct qcaspi afs: Fix large file support media: ov6650: Fix incorrect use of JPEG colorspace media: ov6650: Fix some format attributes not under control media: ov6650: Fix .get_fmt() V4L2_SUBDEV_FORMAT_TRY support MIPS: Loongson: Fix return value of loongson_hwmon_init net: neigh: use long type to store jiffies delta packet: fix data-race in fanout_flow_is_huge() dmaengine: ti: edma: fix missed failure handling drm/radeon: fix bad DMA from INTERRUPT_CNTL2 arm64: dts: juno: Fix UART frequency IB/iser: Fix dma_nents type definition m68k: Call timer_interrupt() with interrupts disabled net: ethtool: Add back transceiver type net: phy: Keep reporting transceiver type can, slip: Protect tty->disc_data in write_wakeup and close with RCU firestream: fix memory leaks net: cxgb3_main: Add CAP_NET_ADMIN check to CHELSIO_GET_MEM net, ip6_tunnel: fix namespaces move net, ip_tunnel: fix namespaces move net_sched: fix datalen for ematch tcp_bbr: improve arithmetic division in bbr_update_bw() net: usb: lan78xx: Add .ndo_features_check gtp: make sure only SOCK_DGRAM UDP sockets are accepted hwmon: (adt7475) Make volt2reg return same reg as reg2volt input hwmon: (core) Simplify sysfs attribute name allocation hwmon: Deal with errors from the thermal subsystem hwmon: (core) Fix double-free in __hwmon_device_register() hwmon: (core) Do not use device managed functions for memory allocations Input: keyspan-remote - fix control-message timeouts ARM: 8950/1: ftrace/recordmcount: filter relocation types mmc: tegra: fix SDR50 tuning override mmc: sdhci: fix minimum clock rate for v3 controller Input: sur40 - fix interface sanity checks Input: gtco - fix endpoint sanity check Input: aiptek - fix endpoint sanity check Input: pegasus_notetaker - fix endpoint sanity check Input: sun4i-ts - add a check for devm_thermal_zone_of_sensor_register hwmon: (nct7802) Fix voltage limits to wrong registers scsi: RDMA/isert: Fix a recently introduced regression related to logout tracing: xen: Ordered comparison of function pointers do_last(): fetch directory ->i_mode and ->i_uid before it's too late Documentation: Document arm64 kpti control arm64: kpti: Whitelist Cortex-A CPUs that don't implement the CSV3 field coresight: etb10: Do not call smp_processor_id from preemptible coresight: tmc-etf: Do not call smp_processor_id from preemptible libertas: Fix two buffer overflows at parsing bss descriptor bcache: silence static checker warning scsi: iscsi: Avoid potential deadlock in iscsi_if_rx func md: Avoid namespace collision with bitmap API bitmap: Add bitmap_alloc(), bitmap_zalloc() and bitmap_free() netfilter: ipset: use bitmap infrastructure completely net/x25: fix nonblocking connect Linux 4.9.212 Signed-off-by: Greg Kroah-Hartman <gregkh@google.com> Change-Id: I2e83a05c5f119a7467a4d6984045d45d0c06b764
1062 lines
27 KiB
C
1062 lines
27 KiB
C
/*
|
|
* Apple Onboard Audio driver for Onyx codec
|
|
*
|
|
* Copyright 2006 Johannes Berg <johannes@sipsolutions.net>
|
|
*
|
|
* GPL v2, can be found in COPYING.
|
|
*
|
|
*
|
|
* This is a driver for the pcm3052 codec chip (codenamed Onyx)
|
|
* that is present in newer Apple hardware (with digital output).
|
|
*
|
|
* The Onyx codec has the following connections (listed by the bit
|
|
* to be used in aoa_codec.connected):
|
|
* 0: analog output
|
|
* 1: digital output
|
|
* 2: line input
|
|
* 3: microphone input
|
|
* Note that even though I know of no machine that has for example
|
|
* the digital output connected but not the analog, I have handled
|
|
* all the different cases in the code so that this driver may serve
|
|
* as a good example of what to do.
|
|
*
|
|
* NOTE: This driver assumes that there's at most one chip to be
|
|
* used with one alsa card, in form of creating all kinds
|
|
* of mixer elements without regard for their existence.
|
|
* But snd-aoa assumes that there's at most one card, so
|
|
* this means you can only have one onyx on a system. This
|
|
* should probably be fixed by changing the assumption of
|
|
* having just a single card on a system, and making the
|
|
* 'card' pointer accessible to anyone who needs it instead
|
|
* of hiding it in the aoa_snd_* functions...
|
|
*
|
|
*/
|
|
#include <linux/delay.h>
|
|
#include <linux/module.h>
|
|
#include <linux/slab.h>
|
|
MODULE_AUTHOR("Johannes Berg <johannes@sipsolutions.net>");
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_DESCRIPTION("pcm3052 (onyx) codec driver for snd-aoa");
|
|
|
|
#include "onyx.h"
|
|
#include "../aoa.h"
|
|
#include "../soundbus/soundbus.h"
|
|
|
|
|
|
#define PFX "snd-aoa-codec-onyx: "
|
|
|
|
struct onyx {
|
|
/* cache registers 65 to 80, they are write-only! */
|
|
u8 cache[16];
|
|
struct i2c_client *i2c;
|
|
struct aoa_codec codec;
|
|
u32 initialised:1,
|
|
spdif_locked:1,
|
|
analog_locked:1,
|
|
original_mute:2;
|
|
int open_count;
|
|
struct codec_info *codec_info;
|
|
|
|
/* mutex serializes concurrent access to the device
|
|
* and this structure.
|
|
*/
|
|
struct mutex mutex;
|
|
};
|
|
#define codec_to_onyx(c) container_of(c, struct onyx, codec)
|
|
|
|
/* both return 0 if all ok, else on error */
|
|
static int onyx_read_register(struct onyx *onyx, u8 reg, u8 *value)
|
|
{
|
|
s32 v;
|
|
|
|
if (reg != ONYX_REG_CONTROL) {
|
|
*value = onyx->cache[reg-FIRSTREGISTER];
|
|
return 0;
|
|
}
|
|
v = i2c_smbus_read_byte_data(onyx->i2c, reg);
|
|
if (v < 0) {
|
|
*value = 0;
|
|
return -1;
|
|
}
|
|
*value = (u8)v;
|
|
onyx->cache[ONYX_REG_CONTROL-FIRSTREGISTER] = *value;
|
|
return 0;
|
|
}
|
|
|
|
static int onyx_write_register(struct onyx *onyx, u8 reg, u8 value)
|
|
{
|
|
int result;
|
|
|
|
result = i2c_smbus_write_byte_data(onyx->i2c, reg, value);
|
|
if (!result)
|
|
onyx->cache[reg-FIRSTREGISTER] = value;
|
|
return result;
|
|
}
|
|
|
|
/* alsa stuff */
|
|
|
|
static int onyx_dev_register(struct snd_device *dev)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static struct snd_device_ops ops = {
|
|
.dev_register = onyx_dev_register,
|
|
};
|
|
|
|
/* this is necessary because most alsa mixer programs
|
|
* can't properly handle the negative range */
|
|
#define VOLUME_RANGE_SHIFT 128
|
|
|
|
static int onyx_snd_vol_info(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_info *uinfo)
|
|
{
|
|
uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
|
|
uinfo->count = 2;
|
|
uinfo->value.integer.min = -128 + VOLUME_RANGE_SHIFT;
|
|
uinfo->value.integer.max = -1 + VOLUME_RANGE_SHIFT;
|
|
return 0;
|
|
}
|
|
|
|
static int onyx_snd_vol_get(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
struct onyx *onyx = snd_kcontrol_chip(kcontrol);
|
|
s8 l, r;
|
|
|
|
mutex_lock(&onyx->mutex);
|
|
onyx_read_register(onyx, ONYX_REG_DAC_ATTEN_LEFT, &l);
|
|
onyx_read_register(onyx, ONYX_REG_DAC_ATTEN_RIGHT, &r);
|
|
mutex_unlock(&onyx->mutex);
|
|
|
|
ucontrol->value.integer.value[0] = l + VOLUME_RANGE_SHIFT;
|
|
ucontrol->value.integer.value[1] = r + VOLUME_RANGE_SHIFT;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int onyx_snd_vol_put(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
struct onyx *onyx = snd_kcontrol_chip(kcontrol);
|
|
s8 l, r;
|
|
|
|
if (ucontrol->value.integer.value[0] < -128 + VOLUME_RANGE_SHIFT ||
|
|
ucontrol->value.integer.value[0] > -1 + VOLUME_RANGE_SHIFT)
|
|
return -EINVAL;
|
|
if (ucontrol->value.integer.value[1] < -128 + VOLUME_RANGE_SHIFT ||
|
|
ucontrol->value.integer.value[1] > -1 + VOLUME_RANGE_SHIFT)
|
|
return -EINVAL;
|
|
|
|
mutex_lock(&onyx->mutex);
|
|
onyx_read_register(onyx, ONYX_REG_DAC_ATTEN_LEFT, &l);
|
|
onyx_read_register(onyx, ONYX_REG_DAC_ATTEN_RIGHT, &r);
|
|
|
|
if (l + VOLUME_RANGE_SHIFT == ucontrol->value.integer.value[0] &&
|
|
r + VOLUME_RANGE_SHIFT == ucontrol->value.integer.value[1]) {
|
|
mutex_unlock(&onyx->mutex);
|
|
return 0;
|
|
}
|
|
|
|
onyx_write_register(onyx, ONYX_REG_DAC_ATTEN_LEFT,
|
|
ucontrol->value.integer.value[0]
|
|
- VOLUME_RANGE_SHIFT);
|
|
onyx_write_register(onyx, ONYX_REG_DAC_ATTEN_RIGHT,
|
|
ucontrol->value.integer.value[1]
|
|
- VOLUME_RANGE_SHIFT);
|
|
mutex_unlock(&onyx->mutex);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static struct snd_kcontrol_new volume_control = {
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
|
.name = "Master Playback Volume",
|
|
.access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
|
|
.info = onyx_snd_vol_info,
|
|
.get = onyx_snd_vol_get,
|
|
.put = onyx_snd_vol_put,
|
|
};
|
|
|
|
/* like above, this is necessary because a lot
|
|
* of alsa mixer programs don't handle ranges
|
|
* that don't start at 0 properly.
|
|
* even alsamixer is one of them... */
|
|
#define INPUTGAIN_RANGE_SHIFT (-3)
|
|
|
|
static int onyx_snd_inputgain_info(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_info *uinfo)
|
|
{
|
|
uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
|
|
uinfo->count = 1;
|
|
uinfo->value.integer.min = 3 + INPUTGAIN_RANGE_SHIFT;
|
|
uinfo->value.integer.max = 28 + INPUTGAIN_RANGE_SHIFT;
|
|
return 0;
|
|
}
|
|
|
|
static int onyx_snd_inputgain_get(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
struct onyx *onyx = snd_kcontrol_chip(kcontrol);
|
|
u8 ig;
|
|
|
|
mutex_lock(&onyx->mutex);
|
|
onyx_read_register(onyx, ONYX_REG_ADC_CONTROL, &ig);
|
|
mutex_unlock(&onyx->mutex);
|
|
|
|
ucontrol->value.integer.value[0] =
|
|
(ig & ONYX_ADC_PGA_GAIN_MASK) + INPUTGAIN_RANGE_SHIFT;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int onyx_snd_inputgain_put(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
struct onyx *onyx = snd_kcontrol_chip(kcontrol);
|
|
u8 v, n;
|
|
|
|
if (ucontrol->value.integer.value[0] < 3 + INPUTGAIN_RANGE_SHIFT ||
|
|
ucontrol->value.integer.value[0] > 28 + INPUTGAIN_RANGE_SHIFT)
|
|
return -EINVAL;
|
|
mutex_lock(&onyx->mutex);
|
|
onyx_read_register(onyx, ONYX_REG_ADC_CONTROL, &v);
|
|
n = v;
|
|
n &= ~ONYX_ADC_PGA_GAIN_MASK;
|
|
n |= (ucontrol->value.integer.value[0] - INPUTGAIN_RANGE_SHIFT)
|
|
& ONYX_ADC_PGA_GAIN_MASK;
|
|
onyx_write_register(onyx, ONYX_REG_ADC_CONTROL, n);
|
|
mutex_unlock(&onyx->mutex);
|
|
|
|
return n != v;
|
|
}
|
|
|
|
static struct snd_kcontrol_new inputgain_control = {
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
|
.name = "Master Capture Volume",
|
|
.access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
|
|
.info = onyx_snd_inputgain_info,
|
|
.get = onyx_snd_inputgain_get,
|
|
.put = onyx_snd_inputgain_put,
|
|
};
|
|
|
|
static int onyx_snd_capture_source_info(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_info *uinfo)
|
|
{
|
|
static const char * const texts[] = { "Line-In", "Microphone" };
|
|
|
|
return snd_ctl_enum_info(uinfo, 1, 2, texts);
|
|
}
|
|
|
|
static int onyx_snd_capture_source_get(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
struct onyx *onyx = snd_kcontrol_chip(kcontrol);
|
|
s8 v;
|
|
|
|
mutex_lock(&onyx->mutex);
|
|
onyx_read_register(onyx, ONYX_REG_ADC_CONTROL, &v);
|
|
mutex_unlock(&onyx->mutex);
|
|
|
|
ucontrol->value.enumerated.item[0] = !!(v&ONYX_ADC_INPUT_MIC);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void onyx_set_capture_source(struct onyx *onyx, int mic)
|
|
{
|
|
s8 v;
|
|
|
|
mutex_lock(&onyx->mutex);
|
|
onyx_read_register(onyx, ONYX_REG_ADC_CONTROL, &v);
|
|
v &= ~ONYX_ADC_INPUT_MIC;
|
|
if (mic)
|
|
v |= ONYX_ADC_INPUT_MIC;
|
|
onyx_write_register(onyx, ONYX_REG_ADC_CONTROL, v);
|
|
mutex_unlock(&onyx->mutex);
|
|
}
|
|
|
|
static int onyx_snd_capture_source_put(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
if (ucontrol->value.enumerated.item[0] > 1)
|
|
return -EINVAL;
|
|
onyx_set_capture_source(snd_kcontrol_chip(kcontrol),
|
|
ucontrol->value.enumerated.item[0]);
|
|
return 1;
|
|
}
|
|
|
|
static struct snd_kcontrol_new capture_source_control = {
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
|
/* If we name this 'Input Source', it properly shows up in
|
|
* alsamixer as a selection, * but it's shown under the
|
|
* 'Playback' category.
|
|
* If I name it 'Capture Source', it shows up in strange
|
|
* ways (two bools of which one can be selected at a
|
|
* time) but at least it's shown in the 'Capture'
|
|
* category.
|
|
* I was told that this was due to backward compatibility,
|
|
* but I don't understand then why the mangling is *not*
|
|
* done when I name it "Input Source".....
|
|
*/
|
|
.name = "Capture Source",
|
|
.access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
|
|
.info = onyx_snd_capture_source_info,
|
|
.get = onyx_snd_capture_source_get,
|
|
.put = onyx_snd_capture_source_put,
|
|
};
|
|
|
|
#define onyx_snd_mute_info snd_ctl_boolean_stereo_info
|
|
|
|
static int onyx_snd_mute_get(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
struct onyx *onyx = snd_kcontrol_chip(kcontrol);
|
|
u8 c;
|
|
|
|
mutex_lock(&onyx->mutex);
|
|
onyx_read_register(onyx, ONYX_REG_DAC_CONTROL, &c);
|
|
mutex_unlock(&onyx->mutex);
|
|
|
|
ucontrol->value.integer.value[0] = !(c & ONYX_MUTE_LEFT);
|
|
ucontrol->value.integer.value[1] = !(c & ONYX_MUTE_RIGHT);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int onyx_snd_mute_put(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
struct onyx *onyx = snd_kcontrol_chip(kcontrol);
|
|
u8 v = 0, c = 0;
|
|
int err = -EBUSY;
|
|
|
|
mutex_lock(&onyx->mutex);
|
|
if (onyx->analog_locked)
|
|
goto out_unlock;
|
|
|
|
onyx_read_register(onyx, ONYX_REG_DAC_CONTROL, &v);
|
|
c = v;
|
|
c &= ~(ONYX_MUTE_RIGHT | ONYX_MUTE_LEFT);
|
|
if (!ucontrol->value.integer.value[0])
|
|
c |= ONYX_MUTE_LEFT;
|
|
if (!ucontrol->value.integer.value[1])
|
|
c |= ONYX_MUTE_RIGHT;
|
|
err = onyx_write_register(onyx, ONYX_REG_DAC_CONTROL, c);
|
|
|
|
out_unlock:
|
|
mutex_unlock(&onyx->mutex);
|
|
|
|
return !err ? (v != c) : err;
|
|
}
|
|
|
|
static struct snd_kcontrol_new mute_control = {
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
|
.name = "Master Playback Switch",
|
|
.access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
|
|
.info = onyx_snd_mute_info,
|
|
.get = onyx_snd_mute_get,
|
|
.put = onyx_snd_mute_put,
|
|
};
|
|
|
|
|
|
#define onyx_snd_single_bit_info snd_ctl_boolean_mono_info
|
|
|
|
#define FLAG_POLARITY_INVERT 1
|
|
#define FLAG_SPDIFLOCK 2
|
|
|
|
static int onyx_snd_single_bit_get(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
struct onyx *onyx = snd_kcontrol_chip(kcontrol);
|
|
u8 c;
|
|
long int pv = kcontrol->private_value;
|
|
u8 polarity = (pv >> 16) & FLAG_POLARITY_INVERT;
|
|
u8 address = (pv >> 8) & 0xff;
|
|
u8 mask = pv & 0xff;
|
|
|
|
mutex_lock(&onyx->mutex);
|
|
onyx_read_register(onyx, address, &c);
|
|
mutex_unlock(&onyx->mutex);
|
|
|
|
ucontrol->value.integer.value[0] = !!(c & mask) ^ polarity;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int onyx_snd_single_bit_put(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
struct onyx *onyx = snd_kcontrol_chip(kcontrol);
|
|
u8 v = 0, c = 0;
|
|
int err;
|
|
long int pv = kcontrol->private_value;
|
|
u8 polarity = (pv >> 16) & FLAG_POLARITY_INVERT;
|
|
u8 spdiflock = (pv >> 16) & FLAG_SPDIFLOCK;
|
|
u8 address = (pv >> 8) & 0xff;
|
|
u8 mask = pv & 0xff;
|
|
|
|
mutex_lock(&onyx->mutex);
|
|
if (spdiflock && onyx->spdif_locked) {
|
|
/* even if alsamixer doesn't care.. */
|
|
err = -EBUSY;
|
|
goto out_unlock;
|
|
}
|
|
onyx_read_register(onyx, address, &v);
|
|
c = v;
|
|
c &= ~(mask);
|
|
if (!!ucontrol->value.integer.value[0] ^ polarity)
|
|
c |= mask;
|
|
err = onyx_write_register(onyx, address, c);
|
|
|
|
out_unlock:
|
|
mutex_unlock(&onyx->mutex);
|
|
|
|
return !err ? (v != c) : err;
|
|
}
|
|
|
|
#define SINGLE_BIT(n, type, description, address, mask, flags) \
|
|
static struct snd_kcontrol_new n##_control = { \
|
|
.iface = SNDRV_CTL_ELEM_IFACE_##type, \
|
|
.name = description, \
|
|
.access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
|
|
.info = onyx_snd_single_bit_info, \
|
|
.get = onyx_snd_single_bit_get, \
|
|
.put = onyx_snd_single_bit_put, \
|
|
.private_value = (flags << 16) | (address << 8) | mask \
|
|
}
|
|
|
|
SINGLE_BIT(spdif,
|
|
MIXER,
|
|
SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
|
|
ONYX_REG_DIG_INFO4,
|
|
ONYX_SPDIF_ENABLE,
|
|
FLAG_SPDIFLOCK);
|
|
SINGLE_BIT(ovr1,
|
|
MIXER,
|
|
"Oversampling Rate",
|
|
ONYX_REG_DAC_CONTROL,
|
|
ONYX_OVR1,
|
|
0);
|
|
SINGLE_BIT(flt0,
|
|
MIXER,
|
|
"Fast Digital Filter Rolloff",
|
|
ONYX_REG_DAC_FILTER,
|
|
ONYX_ROLLOFF_FAST,
|
|
FLAG_POLARITY_INVERT);
|
|
SINGLE_BIT(hpf,
|
|
MIXER,
|
|
"Highpass Filter",
|
|
ONYX_REG_ADC_HPF_BYPASS,
|
|
ONYX_HPF_DISABLE,
|
|
FLAG_POLARITY_INVERT);
|
|
SINGLE_BIT(dm12,
|
|
MIXER,
|
|
"Digital De-Emphasis",
|
|
ONYX_REG_DAC_DEEMPH,
|
|
ONYX_DIGDEEMPH_CTRL,
|
|
0);
|
|
|
|
static int onyx_spdif_info(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_info *uinfo)
|
|
{
|
|
uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
|
|
uinfo->count = 1;
|
|
return 0;
|
|
}
|
|
|
|
static int onyx_spdif_mask_get(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
/* datasheet page 30, all others are 0 */
|
|
ucontrol->value.iec958.status[0] = 0x3e;
|
|
ucontrol->value.iec958.status[1] = 0xff;
|
|
|
|
ucontrol->value.iec958.status[3] = 0x3f;
|
|
ucontrol->value.iec958.status[4] = 0x0f;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static struct snd_kcontrol_new onyx_spdif_mask = {
|
|
.access = SNDRV_CTL_ELEM_ACCESS_READ,
|
|
.iface = SNDRV_CTL_ELEM_IFACE_PCM,
|
|
.name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
|
|
.info = onyx_spdif_info,
|
|
.get = onyx_spdif_mask_get,
|
|
};
|
|
|
|
static int onyx_spdif_get(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
struct onyx *onyx = snd_kcontrol_chip(kcontrol);
|
|
u8 v;
|
|
|
|
mutex_lock(&onyx->mutex);
|
|
onyx_read_register(onyx, ONYX_REG_DIG_INFO1, &v);
|
|
ucontrol->value.iec958.status[0] = v & 0x3e;
|
|
|
|
onyx_read_register(onyx, ONYX_REG_DIG_INFO2, &v);
|
|
ucontrol->value.iec958.status[1] = v;
|
|
|
|
onyx_read_register(onyx, ONYX_REG_DIG_INFO3, &v);
|
|
ucontrol->value.iec958.status[3] = v & 0x3f;
|
|
|
|
onyx_read_register(onyx, ONYX_REG_DIG_INFO4, &v);
|
|
ucontrol->value.iec958.status[4] = v & 0x0f;
|
|
mutex_unlock(&onyx->mutex);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int onyx_spdif_put(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
struct onyx *onyx = snd_kcontrol_chip(kcontrol);
|
|
u8 v;
|
|
|
|
mutex_lock(&onyx->mutex);
|
|
onyx_read_register(onyx, ONYX_REG_DIG_INFO1, &v);
|
|
v = (v & ~0x3e) | (ucontrol->value.iec958.status[0] & 0x3e);
|
|
onyx_write_register(onyx, ONYX_REG_DIG_INFO1, v);
|
|
|
|
v = ucontrol->value.iec958.status[1];
|
|
onyx_write_register(onyx, ONYX_REG_DIG_INFO2, v);
|
|
|
|
onyx_read_register(onyx, ONYX_REG_DIG_INFO3, &v);
|
|
v = (v & ~0x3f) | (ucontrol->value.iec958.status[3] & 0x3f);
|
|
onyx_write_register(onyx, ONYX_REG_DIG_INFO3, v);
|
|
|
|
onyx_read_register(onyx, ONYX_REG_DIG_INFO4, &v);
|
|
v = (v & ~0x0f) | (ucontrol->value.iec958.status[4] & 0x0f);
|
|
onyx_write_register(onyx, ONYX_REG_DIG_INFO4, v);
|
|
mutex_unlock(&onyx->mutex);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static struct snd_kcontrol_new onyx_spdif_ctrl = {
|
|
.access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
|
|
.iface = SNDRV_CTL_ELEM_IFACE_PCM,
|
|
.name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
|
|
.info = onyx_spdif_info,
|
|
.get = onyx_spdif_get,
|
|
.put = onyx_spdif_put,
|
|
};
|
|
|
|
/* our registers */
|
|
|
|
static u8 register_map[] = {
|
|
ONYX_REG_DAC_ATTEN_LEFT,
|
|
ONYX_REG_DAC_ATTEN_RIGHT,
|
|
ONYX_REG_CONTROL,
|
|
ONYX_REG_DAC_CONTROL,
|
|
ONYX_REG_DAC_DEEMPH,
|
|
ONYX_REG_DAC_FILTER,
|
|
ONYX_REG_DAC_OUTPHASE,
|
|
ONYX_REG_ADC_CONTROL,
|
|
ONYX_REG_ADC_HPF_BYPASS,
|
|
ONYX_REG_DIG_INFO1,
|
|
ONYX_REG_DIG_INFO2,
|
|
ONYX_REG_DIG_INFO3,
|
|
ONYX_REG_DIG_INFO4
|
|
};
|
|
|
|
static u8 initial_values[ARRAY_SIZE(register_map)] = {
|
|
0x80, 0x80, /* muted */
|
|
ONYX_MRST | ONYX_SRST, /* but handled specially! */
|
|
ONYX_MUTE_LEFT | ONYX_MUTE_RIGHT,
|
|
0, /* no deemphasis */
|
|
ONYX_DAC_FILTER_ALWAYS,
|
|
ONYX_OUTPHASE_INVERTED,
|
|
(-1 /*dB*/ + 8) & 0xF, /* line in selected, -1 dB gain*/
|
|
ONYX_ADC_HPF_ALWAYS,
|
|
(1<<2), /* pcm audio */
|
|
2, /* category: pcm coder */
|
|
0, /* sampling frequency 44.1 kHz, clock accuracy level II */
|
|
1 /* 24 bit depth */
|
|
};
|
|
|
|
/* reset registers of chip, either to initial or to previous values */
|
|
static int onyx_register_init(struct onyx *onyx)
|
|
{
|
|
int i;
|
|
u8 val;
|
|
u8 regs[sizeof(initial_values)];
|
|
|
|
if (!onyx->initialised) {
|
|
memcpy(regs, initial_values, sizeof(initial_values));
|
|
if (onyx_read_register(onyx, ONYX_REG_CONTROL, &val))
|
|
return -1;
|
|
val &= ~ONYX_SILICONVERSION;
|
|
val |= initial_values[3];
|
|
regs[3] = val;
|
|
} else {
|
|
for (i=0; i<sizeof(register_map); i++)
|
|
regs[i] = onyx->cache[register_map[i]-FIRSTREGISTER];
|
|
}
|
|
|
|
for (i=0; i<sizeof(register_map); i++) {
|
|
if (onyx_write_register(onyx, register_map[i], regs[i]))
|
|
return -1;
|
|
}
|
|
onyx->initialised = 1;
|
|
return 0;
|
|
}
|
|
|
|
static struct transfer_info onyx_transfers[] = {
|
|
/* this is first so we can skip it if no input is present...
|
|
* No hardware exists with that, but it's here as an example
|
|
* of what to do :) */
|
|
{
|
|
/* analog input */
|
|
.formats = SNDRV_PCM_FMTBIT_S8 |
|
|
SNDRV_PCM_FMTBIT_S16_BE |
|
|
SNDRV_PCM_FMTBIT_S24_BE,
|
|
.rates = SNDRV_PCM_RATE_8000_96000,
|
|
.transfer_in = 1,
|
|
.must_be_clock_source = 0,
|
|
.tag = 0,
|
|
},
|
|
{
|
|
/* if analog and digital are currently off, anything should go,
|
|
* so this entry describes everything we can do... */
|
|
.formats = SNDRV_PCM_FMTBIT_S8 |
|
|
SNDRV_PCM_FMTBIT_S16_BE |
|
|
SNDRV_PCM_FMTBIT_S24_BE
|
|
#ifdef SNDRV_PCM_FMTBIT_COMPRESSED_16BE
|
|
| SNDRV_PCM_FMTBIT_COMPRESSED_16BE
|
|
#endif
|
|
,
|
|
.rates = SNDRV_PCM_RATE_8000_96000,
|
|
.tag = 0,
|
|
},
|
|
{
|
|
/* analog output */
|
|
.formats = SNDRV_PCM_FMTBIT_S8 |
|
|
SNDRV_PCM_FMTBIT_S16_BE |
|
|
SNDRV_PCM_FMTBIT_S24_BE,
|
|
.rates = SNDRV_PCM_RATE_8000_96000,
|
|
.transfer_in = 0,
|
|
.must_be_clock_source = 0,
|
|
.tag = 1,
|
|
},
|
|
{
|
|
/* digital pcm output, also possible for analog out */
|
|
.formats = SNDRV_PCM_FMTBIT_S8 |
|
|
SNDRV_PCM_FMTBIT_S16_BE |
|
|
SNDRV_PCM_FMTBIT_S24_BE,
|
|
.rates = SNDRV_PCM_RATE_32000 |
|
|
SNDRV_PCM_RATE_44100 |
|
|
SNDRV_PCM_RATE_48000,
|
|
.transfer_in = 0,
|
|
.must_be_clock_source = 0,
|
|
.tag = 2,
|
|
},
|
|
#ifdef SNDRV_PCM_FMTBIT_COMPRESSED_16BE
|
|
/* Once alsa gets supports for this kind of thing we can add it... */
|
|
{
|
|
/* digital compressed output */
|
|
.formats = SNDRV_PCM_FMTBIT_COMPRESSED_16BE,
|
|
.rates = SNDRV_PCM_RATE_32000 |
|
|
SNDRV_PCM_RATE_44100 |
|
|
SNDRV_PCM_RATE_48000,
|
|
.tag = 2,
|
|
},
|
|
#endif
|
|
{}
|
|
};
|
|
|
|
static int onyx_usable(struct codec_info_item *cii,
|
|
struct transfer_info *ti,
|
|
struct transfer_info *out)
|
|
{
|
|
u8 v;
|
|
struct onyx *onyx = cii->codec_data;
|
|
int spdif_enabled, analog_enabled;
|
|
|
|
mutex_lock(&onyx->mutex);
|
|
onyx_read_register(onyx, ONYX_REG_DIG_INFO4, &v);
|
|
spdif_enabled = !!(v & ONYX_SPDIF_ENABLE);
|
|
onyx_read_register(onyx, ONYX_REG_DAC_CONTROL, &v);
|
|
analog_enabled =
|
|
(v & (ONYX_MUTE_RIGHT|ONYX_MUTE_LEFT))
|
|
!= (ONYX_MUTE_RIGHT|ONYX_MUTE_LEFT);
|
|
mutex_unlock(&onyx->mutex);
|
|
|
|
switch (ti->tag) {
|
|
case 0: return 1;
|
|
case 1: return analog_enabled;
|
|
case 2: return spdif_enabled;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static int onyx_prepare(struct codec_info_item *cii,
|
|
struct bus_info *bi,
|
|
struct snd_pcm_substream *substream)
|
|
{
|
|
u8 v;
|
|
struct onyx *onyx = cii->codec_data;
|
|
int err = -EBUSY;
|
|
|
|
mutex_lock(&onyx->mutex);
|
|
|
|
#ifdef SNDRV_PCM_FMTBIT_COMPRESSED_16BE
|
|
if (substream->runtime->format == SNDRV_PCM_FMTBIT_COMPRESSED_16BE) {
|
|
/* mute and lock analog output */
|
|
onyx_read_register(onyx, ONYX_REG_DAC_CONTROL, &v);
|
|
if (onyx_write_register(onyx,
|
|
ONYX_REG_DAC_CONTROL,
|
|
v | ONYX_MUTE_RIGHT | ONYX_MUTE_LEFT))
|
|
goto out_unlock;
|
|
onyx->analog_locked = 1;
|
|
err = 0;
|
|
goto out_unlock;
|
|
}
|
|
#endif
|
|
switch (substream->runtime->rate) {
|
|
case 32000:
|
|
case 44100:
|
|
case 48000:
|
|
/* these rates are ok for all outputs */
|
|
/* FIXME: program spdif channel control bits here so that
|
|
* userspace doesn't have to if it only plays pcm! */
|
|
err = 0;
|
|
goto out_unlock;
|
|
default:
|
|
/* got some rate that the digital output can't do,
|
|
* so disable and lock it */
|
|
onyx_read_register(cii->codec_data, ONYX_REG_DIG_INFO4, &v);
|
|
if (onyx_write_register(onyx,
|
|
ONYX_REG_DIG_INFO4,
|
|
v & ~ONYX_SPDIF_ENABLE))
|
|
goto out_unlock;
|
|
onyx->spdif_locked = 1;
|
|
err = 0;
|
|
goto out_unlock;
|
|
}
|
|
|
|
out_unlock:
|
|
mutex_unlock(&onyx->mutex);
|
|
|
|
return err;
|
|
}
|
|
|
|
static int onyx_open(struct codec_info_item *cii,
|
|
struct snd_pcm_substream *substream)
|
|
{
|
|
struct onyx *onyx = cii->codec_data;
|
|
|
|
mutex_lock(&onyx->mutex);
|
|
onyx->open_count++;
|
|
mutex_unlock(&onyx->mutex);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int onyx_close(struct codec_info_item *cii,
|
|
struct snd_pcm_substream *substream)
|
|
{
|
|
struct onyx *onyx = cii->codec_data;
|
|
|
|
mutex_lock(&onyx->mutex);
|
|
onyx->open_count--;
|
|
if (!onyx->open_count)
|
|
onyx->spdif_locked = onyx->analog_locked = 0;
|
|
mutex_unlock(&onyx->mutex);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int onyx_switch_clock(struct codec_info_item *cii,
|
|
enum clock_switch what)
|
|
{
|
|
struct onyx *onyx = cii->codec_data;
|
|
|
|
mutex_lock(&onyx->mutex);
|
|
/* this *MUST* be more elaborate later... */
|
|
switch (what) {
|
|
case CLOCK_SWITCH_PREPARE_SLAVE:
|
|
onyx->codec.gpio->methods->all_amps_off(onyx->codec.gpio);
|
|
break;
|
|
case CLOCK_SWITCH_SLAVE:
|
|
onyx->codec.gpio->methods->all_amps_restore(onyx->codec.gpio);
|
|
break;
|
|
default: /* silence warning */
|
|
break;
|
|
}
|
|
mutex_unlock(&onyx->mutex);
|
|
|
|
return 0;
|
|
}
|
|
|
|
#ifdef CONFIG_PM
|
|
|
|
static int onyx_suspend(struct codec_info_item *cii, pm_message_t state)
|
|
{
|
|
struct onyx *onyx = cii->codec_data;
|
|
u8 v;
|
|
int err = -ENXIO;
|
|
|
|
mutex_lock(&onyx->mutex);
|
|
if (onyx_read_register(onyx, ONYX_REG_CONTROL, &v))
|
|
goto out_unlock;
|
|
onyx_write_register(onyx, ONYX_REG_CONTROL, v | ONYX_ADPSV | ONYX_DAPSV);
|
|
/* Apple does a sleep here but the datasheet says to do it on resume */
|
|
err = 0;
|
|
out_unlock:
|
|
mutex_unlock(&onyx->mutex);
|
|
|
|
return err;
|
|
}
|
|
|
|
static int onyx_resume(struct codec_info_item *cii)
|
|
{
|
|
struct onyx *onyx = cii->codec_data;
|
|
u8 v;
|
|
int err = -ENXIO;
|
|
|
|
mutex_lock(&onyx->mutex);
|
|
|
|
/* reset codec */
|
|
onyx->codec.gpio->methods->set_hw_reset(onyx->codec.gpio, 0);
|
|
msleep(1);
|
|
onyx->codec.gpio->methods->set_hw_reset(onyx->codec.gpio, 1);
|
|
msleep(1);
|
|
onyx->codec.gpio->methods->set_hw_reset(onyx->codec.gpio, 0);
|
|
msleep(1);
|
|
|
|
/* take codec out of suspend (if it still is after reset) */
|
|
if (onyx_read_register(onyx, ONYX_REG_CONTROL, &v))
|
|
goto out_unlock;
|
|
onyx_write_register(onyx, ONYX_REG_CONTROL, v & ~(ONYX_ADPSV | ONYX_DAPSV));
|
|
/* FIXME: should divide by sample rate, but 8k is the lowest we go */
|
|
msleep(2205000/8000);
|
|
/* reset all values */
|
|
onyx_register_init(onyx);
|
|
err = 0;
|
|
out_unlock:
|
|
mutex_unlock(&onyx->mutex);
|
|
|
|
return err;
|
|
}
|
|
|
|
#endif /* CONFIG_PM */
|
|
|
|
static struct codec_info onyx_codec_info = {
|
|
.transfers = onyx_transfers,
|
|
.sysclock_factor = 256,
|
|
.bus_factor = 64,
|
|
.owner = THIS_MODULE,
|
|
.usable = onyx_usable,
|
|
.prepare = onyx_prepare,
|
|
.open = onyx_open,
|
|
.close = onyx_close,
|
|
.switch_clock = onyx_switch_clock,
|
|
#ifdef CONFIG_PM
|
|
.suspend = onyx_suspend,
|
|
.resume = onyx_resume,
|
|
#endif
|
|
};
|
|
|
|
static int onyx_init_codec(struct aoa_codec *codec)
|
|
{
|
|
struct onyx *onyx = codec_to_onyx(codec);
|
|
struct snd_kcontrol *ctl;
|
|
struct codec_info *ci = &onyx_codec_info;
|
|
u8 v;
|
|
int err;
|
|
|
|
if (!onyx->codec.gpio || !onyx->codec.gpio->methods) {
|
|
printk(KERN_ERR PFX "gpios not assigned!!\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
onyx->codec.gpio->methods->set_hw_reset(onyx->codec.gpio, 0);
|
|
msleep(1);
|
|
onyx->codec.gpio->methods->set_hw_reset(onyx->codec.gpio, 1);
|
|
msleep(1);
|
|
onyx->codec.gpio->methods->set_hw_reset(onyx->codec.gpio, 0);
|
|
msleep(1);
|
|
|
|
if (onyx_register_init(onyx)) {
|
|
printk(KERN_ERR PFX "failed to initialise onyx registers\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
if (aoa_snd_device_new(SNDRV_DEV_CODEC, onyx, &ops)) {
|
|
printk(KERN_ERR PFX "failed to create onyx snd device!\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
/* nothing connected? what a joke! */
|
|
if ((onyx->codec.connected & 0xF) == 0)
|
|
return -ENOTCONN;
|
|
|
|
/* if no inputs are present... */
|
|
if ((onyx->codec.connected & 0xC) == 0) {
|
|
if (!onyx->codec_info)
|
|
onyx->codec_info = kmalloc(sizeof(struct codec_info), GFP_KERNEL);
|
|
if (!onyx->codec_info)
|
|
return -ENOMEM;
|
|
ci = onyx->codec_info;
|
|
*ci = onyx_codec_info;
|
|
ci->transfers++;
|
|
}
|
|
|
|
/* if no outputs are present... */
|
|
if ((onyx->codec.connected & 3) == 0) {
|
|
if (!onyx->codec_info)
|
|
onyx->codec_info = kmalloc(sizeof(struct codec_info), GFP_KERNEL);
|
|
if (!onyx->codec_info)
|
|
return -ENOMEM;
|
|
ci = onyx->codec_info;
|
|
/* this is fine as there have to be inputs
|
|
* if we end up in this part of the code */
|
|
*ci = onyx_codec_info;
|
|
ci->transfers[1].formats = 0;
|
|
}
|
|
|
|
if (onyx->codec.soundbus_dev->attach_codec(onyx->codec.soundbus_dev,
|
|
aoa_get_card(),
|
|
ci, onyx)) {
|
|
printk(KERN_ERR PFX "error creating onyx pcm\n");
|
|
return -ENODEV;
|
|
}
|
|
#define ADDCTL(n) \
|
|
do { \
|
|
ctl = snd_ctl_new1(&n, onyx); \
|
|
if (ctl) { \
|
|
ctl->id.device = \
|
|
onyx->codec.soundbus_dev->pcm->device; \
|
|
err = aoa_snd_ctl_add(ctl); \
|
|
if (err) \
|
|
goto error; \
|
|
} \
|
|
} while (0)
|
|
|
|
if (onyx->codec.soundbus_dev->pcm) {
|
|
/* give the user appropriate controls
|
|
* depending on what inputs are connected */
|
|
if ((onyx->codec.connected & 0xC) == 0xC)
|
|
ADDCTL(capture_source_control);
|
|
else if (onyx->codec.connected & 4)
|
|
onyx_set_capture_source(onyx, 0);
|
|
else
|
|
onyx_set_capture_source(onyx, 1);
|
|
if (onyx->codec.connected & 0xC)
|
|
ADDCTL(inputgain_control);
|
|
|
|
/* depending on what output is connected,
|
|
* give the user appropriate controls */
|
|
if (onyx->codec.connected & 1) {
|
|
ADDCTL(volume_control);
|
|
ADDCTL(mute_control);
|
|
ADDCTL(ovr1_control);
|
|
ADDCTL(flt0_control);
|
|
ADDCTL(hpf_control);
|
|
ADDCTL(dm12_control);
|
|
/* spdif control defaults to off */
|
|
}
|
|
if (onyx->codec.connected & 2) {
|
|
ADDCTL(onyx_spdif_mask);
|
|
ADDCTL(onyx_spdif_ctrl);
|
|
}
|
|
if ((onyx->codec.connected & 3) == 3)
|
|
ADDCTL(spdif_control);
|
|
/* if only S/PDIF is connected, enable it unconditionally */
|
|
if ((onyx->codec.connected & 3) == 2) {
|
|
onyx_read_register(onyx, ONYX_REG_DIG_INFO4, &v);
|
|
v |= ONYX_SPDIF_ENABLE;
|
|
onyx_write_register(onyx, ONYX_REG_DIG_INFO4, v);
|
|
}
|
|
}
|
|
#undef ADDCTL
|
|
printk(KERN_INFO PFX "attached to onyx codec via i2c\n");
|
|
|
|
return 0;
|
|
error:
|
|
onyx->codec.soundbus_dev->detach_codec(onyx->codec.soundbus_dev, onyx);
|
|
snd_device_free(aoa_get_card(), onyx);
|
|
return err;
|
|
}
|
|
|
|
static void onyx_exit_codec(struct aoa_codec *codec)
|
|
{
|
|
struct onyx *onyx = codec_to_onyx(codec);
|
|
|
|
if (!onyx->codec.soundbus_dev) {
|
|
printk(KERN_ERR PFX "onyx_exit_codec called without soundbus_dev!\n");
|
|
return;
|
|
}
|
|
onyx->codec.soundbus_dev->detach_codec(onyx->codec.soundbus_dev, onyx);
|
|
}
|
|
|
|
static int onyx_i2c_probe(struct i2c_client *client,
|
|
const struct i2c_device_id *id)
|
|
{
|
|
struct device_node *node = client->dev.of_node;
|
|
struct onyx *onyx;
|
|
u8 dummy;
|
|
|
|
onyx = kzalloc(sizeof(struct onyx), GFP_KERNEL);
|
|
|
|
if (!onyx)
|
|
return -ENOMEM;
|
|
|
|
mutex_init(&onyx->mutex);
|
|
onyx->i2c = client;
|
|
i2c_set_clientdata(client, onyx);
|
|
|
|
/* we try to read from register ONYX_REG_CONTROL
|
|
* to check if the codec is present */
|
|
if (onyx_read_register(onyx, ONYX_REG_CONTROL, &dummy) != 0) {
|
|
printk(KERN_ERR PFX "failed to read control register\n");
|
|
goto fail;
|
|
}
|
|
|
|
strlcpy(onyx->codec.name, "onyx", MAX_CODEC_NAME_LEN);
|
|
onyx->codec.owner = THIS_MODULE;
|
|
onyx->codec.init = onyx_init_codec;
|
|
onyx->codec.exit = onyx_exit_codec;
|
|
onyx->codec.node = of_node_get(node);
|
|
|
|
if (aoa_codec_register(&onyx->codec)) {
|
|
goto fail;
|
|
}
|
|
printk(KERN_DEBUG PFX "created and attached onyx instance\n");
|
|
return 0;
|
|
fail:
|
|
kfree(onyx);
|
|
return -ENODEV;
|
|
}
|
|
|
|
static int onyx_i2c_remove(struct i2c_client *client)
|
|
{
|
|
struct onyx *onyx = i2c_get_clientdata(client);
|
|
|
|
aoa_codec_unregister(&onyx->codec);
|
|
of_node_put(onyx->codec.node);
|
|
kfree(onyx->codec_info);
|
|
kfree(onyx);
|
|
return 0;
|
|
}
|
|
|
|
static const struct i2c_device_id onyx_i2c_id[] = {
|
|
{ "MAC,pcm3052", 0 },
|
|
{ }
|
|
};
|
|
MODULE_DEVICE_TABLE(i2c,onyx_i2c_id);
|
|
|
|
static struct i2c_driver onyx_driver = {
|
|
.driver = {
|
|
.name = "aoa_codec_onyx",
|
|
},
|
|
.probe = onyx_i2c_probe,
|
|
.remove = onyx_i2c_remove,
|
|
.id_table = onyx_i2c_id,
|
|
};
|
|
|
|
module_i2c_driver(onyx_driver);
|