Gitiles
Code Review Sign In
LeafOS / LeafOS-Devices / android_kernel_samsung_gta4xl / 2f4f64cdfb599fa1369560865af3e52250416e15 / . / drivers / extcon / extcon-madera.c
blob: fc5efb7870dab8fe170098ab5902d6de486ea69b [file] [log] [blame]
/*
* extcon-madera.c - Extcon driver for Cirrus Logic Madera codecs
*
* Copyright 2015-2017 Cirrus Logic
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*/
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/device.h>
#include <linux/delay.h>
#include <linux/err.h>
#include <linux/extcon.h>
#include <linux/gpio.h>
#include <linux/input.h>
#include <linux/interrupt.h>
#include <linux/math64.h>
#include <linux/platform_device.h>
#include <linux/pm_runtime.h>
#include <linux/property.h>
#include <linux/regmap.h>
#include <linux/slab.h>
#include <linux/regulator/consumer.h>
#include <sound/soc.h>
#include <linux/extcon/extcon-madera.h>
#include <linux/extcon/extcon-madera-pdata.h>
#include <dt-bindings/extcon/extcon-madera.h>
#include <linux/mfd/madera/core.h>
#include <linux/mfd/madera/pdata.h>
#include <linux/mfd/madera/registers.h>
#define MADERA_MAX_MICD_RANGE 8
#define MADERA_MICD_CLAMP_MODE_JD1L 0x4
#define MADERA_MICD_CLAMP_MODE_JD1H 0x5
#define MADERA_MICD_CLAMP_MODE_JD1L_JD2L 0x8
#define MADERA_MICD_CLAMP_MODE_JD1L_JD2H 0x9
#define MADERA_MICD_CLAMP_MODE_JD1H_JD2H 0xb
#define MADERA_HPDET_MAX_OHM 10000
#define MADERA_HPDET_MAX_HOHM (MADERA_HPDET_MAX_OHM * 100)
#define MADERA_HP_SHORT_IMPEDANCE_MIN 4
#define MADERA_HPDET_DEBOUNCE_MS 500
#define MADERA_DEFAULT_MICD_TIMEOUT_MS 2000
#define MADERA_HPDONE_PROBE_INTERVAL_MS 20
#define MADERA_HPDONE_PROBE_COUNT 15
#define MADERA_MICROPHONE_MIN_OHM 1258
#define MADERA_MICROPHONE_MAX_OHM 30000
#define MADERA_MIC_MUTE 1
#define MADERA_MIC_UNMUTE 0
#define MADERA_HP_TUNING_INVALID -1
static const unsigned int madera_cable[] = {
EXTCON_MECHANICAL,
EXTCON_JACK_MICROPHONE,
EXTCON_JACK_HEADPHONE,
EXTCON_NONE,
};
static const struct madera_micd_config cs47l85_micd_default_modes[] = {
{ MADERA_ACCD_SENSE_MICDET2, 0, MADERA_ACCD_BIAS_SRC_MICBIAS1, 0, 0 },
{ MADERA_ACCD_SENSE_MICDET1, 0, MADERA_ACCD_BIAS_SRC_MICBIAS2, 1, 0 },
};
static const struct madera_micd_config madera_micd_default_modes[] = {
{ MADERA_MICD1_SENSE_MICDET1, MADERA_MICD1_GND_MICDET2,
MADERA_MICD_BIAS_SRC_MICBIAS1A, 0, MADERA_HPD_GND_HPOUTFB2 },
{ MADERA_MICD1_SENSE_MICDET2, MADERA_MICD1_GND_MICDET1,
MADERA_MICD_BIAS_SRC_MICBIAS1B, 1, MADERA_HPD_GND_HPOUTFB1 },
};
static const unsigned int madera_default_hpd_pins[4] = {
[0] = MADERA_HPD_OUT_OUT1L,
[1] = MADERA_HPD_SENSE_HPDET1,
[2] = MADERA_HPD_OUT_OUT1R,
[3] = MADERA_HPD_SENSE_HPDET1,
};
static struct madera_micd_range madera_micd_default_ranges[] = {
{ .max = 70, .key = KEY_MEDIA },
{ .max = 186, .key = KEY_VOICECOMMAND },
{ .max = 295, .key = KEY_VOLUMEUP },
{ .max = 681, .key = KEY_VOLUMEDOWN },
};
/* The number of levels in madera_micd_levels valid for button thresholds */
#define MADERA_NUM_MICD_BUTTON_LEVELS 64
/* ohms for each micd level */
static const int madera_micd_levels[] = {
3, 6, 8, 11, 13, 16, 18, 21, 23, 26, 28, 31, 34, 36, 39, 41, 44, 46,
49, 52, 54, 57, 60, 62, 65, 67, 70, 73, 75, 78, 81, 83, 89, 94, 100,
105, 111, 116, 122, 127, 139, 150, 161, 173, 186, 196, 209, 220, 245,
270, 295, 321, 348, 375, 402, 430, 489, 550, 614, 681, 752, 903, 1071,
1257, 30000,
};
/*
* HP calibration data
* See the datasheet for the meanings of the constants and their values
*/
struct madera_hpdet_calibration_data {
int min; /* ohms */
int max; /* ohms */
s64 C0; /* value * 1000000 */
s64 C1; /* value * 10000 */
s64 C2; /* not multiplied */
s64 C3; /* value * 1000000 */
s64 C4_x_C3; /* value * 1000000 */
s64 C5; /* value * 1000000 */
s64 dacval_adjust;
};
static const struct madera_hpdet_calibration_data cs47l15_hpdet_ranges[] = {
{},
{ 33, 123, 1000000, -4300, 7975, 69600000, 382800, 33350000,
500000},
{ 123, 1033, 9633000, -79500, 7300, 62900000, 283050, 33350000,
500000},
{ 1033, 10033, 100684000, -949400, 7300, 63200000, 284400, 33350000,
500000},
};
static const struct madera_hpdet_calibration_data cs47l85_hpdet_ranges[] = {
{ 4, 30, 1007000, -7200, 4003, 69300000, 381150, 250000, 500000},
{ 8, 100, 1007000, -7200, 7975, 69600000, 382800, 250000, 500000},
{ 100, 1000, 9696000, -79500, 7300, 62900000, 345950, 250000, 500000},
{ 1000, 10000, 100684000, -949400, 7300, 63200000, 347600, 250000, 500000},
};
static const struct madera_hpdet_calibration_data madera_hpdet_ranges[] = {
{ 4, 30, 1014000, -4300, 3950, 69300000, 381150, 700000, 500000},
{ 8, 100, 1014000, -8600, 7975, 69600000, 382800, 700000, 500000},
{ 100, 1000, 9744000, -79500, 7300, 62900000, 345950, 700000, 500000},
{ 1000, 10000, 101158000, -949400, 7300, 63200000, 347600, 700000, 500000},
};
static const struct madera_hpdet_calibration_data cs47l92_hpdet_ranges[] = {
{ 4, 30, 1007000, -7200, 4005, 69300000, 381150, 600000, 500000},
{ 8, 100, 1007000, -7200, 7975, 69600000, 382800, 600000, 500000},
{ 100, 1000, 9744000, -79500, 7300, 62900000, 345950, 600000, 500000},
{ 1000, 10000, 100684000, -949400, 7300, 63200000, 347600, 600000, 500000},
};
struct madera_hp_tuning {
int max_hohm;
const struct reg_sequence *patch;
int patch_len;
};
static const struct reg_sequence cs47l15_low_impedance_patch[] = {
{ 0x460, 0x0C00 },
{ 0x461, 0xCB59 },
{ 0x462, 0x0C00 },
{ 0x463, 0x6037 },
{ 0x464, 0x0C01 },
{ 0x465, 0x2D86 },
{ 0x466, 0x0801 },
{ 0x467, 0x264E },
{ 0x468, 0x0801 },
{ 0x469, 0x1E6D },
{ 0x46A, 0x0802 },
{ 0x46B, 0x199A },
{ 0x46C, 0x0802 },
{ 0x46D, 0x1220 },
{ 0x46E, 0x0802 },
{ 0x46F, 0x0E65 },
{ 0x470, 0x0806 },
{ 0x471, 0x0A31 },
{ 0x472, 0x080E },
{ 0x473, 0x040F },
{ 0x474, 0x080E },
{ 0x475, 0x0339 },
{ 0x476, 0x080E },
{ 0x477, 0x028F },
{ 0x478, 0x080E },
{ 0x479, 0x0209 },
{ 0x47A, 0x080E },
{ 0x47B, 0x00CF },
{ 0x47C, 0x080E },
{ 0x47D, 0x0001 },
{ 0x47E, 0x081F },
};
static const struct reg_sequence cs47l15_normal_impedance_patch[] = {
{ 0x460, 0x0C00 },
{ 0x461, 0xCB59 },
{ 0x462, 0x0C00 },
{ 0x463, 0xB53C },
{ 0x464, 0x0C01 },
{ 0x465, 0x4827 },
{ 0x466, 0x0801 },
{ 0x467, 0x3950 },
{ 0x468, 0x0801 },
{ 0x469, 0x264E },
{ 0x46A, 0x0802 },
{ 0x46B, 0x1E6D },
{ 0x46C, 0x0802 },
{ 0x46D, 0x199A },
{ 0x46E, 0x0802 },
{ 0x46F, 0x1456 },
{ 0x470, 0x0806 },
{ 0x471, 0x1220 },
{ 0x472, 0x080E },
{ 0x473, 0x040F },
{ 0x474, 0x080E },
{ 0x475, 0x0339 },
{ 0x476, 0x080E },
{ 0x477, 0x028F },
{ 0x478, 0x080E },
{ 0x479, 0x0209 },
{ 0x47A, 0x080E },
{ 0x47B, 0x00CF },
{ 0x47C, 0x080E },
{ 0x47D, 0x0001 },
{ 0x47E, 0x081F },
};
static const struct reg_sequence cs47l15_high_impedance_patch[] = {
{ 0x460, 0x0C00 },
{ 0x461, 0xCB59 },
{ 0x462, 0x0C00 },
{ 0x463, 0xB53C },
{ 0x464, 0x0C01 },
{ 0x465, 0x6037 },
{ 0x466, 0x0801 },
{ 0x467, 0x4827 },
{ 0x468, 0x0801 },
{ 0x469, 0x3950 },
{ 0x46A, 0x0802 },
{ 0x46B, 0x264E },
{ 0x46C, 0x0802 },
{ 0x46D, 0x1E6D },
{ 0x46E, 0x0802 },
{ 0x46F, 0x199A },
{ 0x470, 0x0806 },
{ 0x471, 0x1220 },
{ 0x472, 0x080E },
{ 0x473, 0x040F },
{ 0x474, 0x080E },
{ 0x475, 0x0339 },
{ 0x476, 0x080E },
{ 0x477, 0x028F },
{ 0x478, 0x080E },
{ 0x479, 0x0209 },
{ 0x47A, 0x080E },
{ 0x47B, 0x00CF },
{ 0x47C, 0x080E },
{ 0x47D, 0x0001 },
{ 0x47E, 0x081F },
};
static const struct madera_hp_tuning cs47l15_hp_tuning[] = {
{
1600,
cs47l15_low_impedance_patch,
ARRAY_SIZE(cs47l15_low_impedance_patch),
},
{
3200,
cs47l15_normal_impedance_patch,
ARRAY_SIZE(cs47l15_normal_impedance_patch),
},
{
MADERA_HPDET_MAX_HOHM,
cs47l15_high_impedance_patch,
ARRAY_SIZE(cs47l15_high_impedance_patch),
},
};
static const struct reg_sequence cs47l35_low_impedance_patch[] = {
{ 0x460, 0x0C40 },
{ 0x461, 0xCD1A },
{ 0x462, 0x0C40 },
{ 0x463, 0xB53B },
{ 0x464, 0x0C41 },
{ 0x465, 0x4826 },
{ 0x466, 0x0C41 },
{ 0x467, 0x2EDA },
{ 0x468, 0x0C41 },
{ 0x469, 0x203A },
{ 0x46A, 0x0841 },
{ 0x46B, 0x121F },
{ 0x46C, 0x0446 },
{ 0x46D, 0x0B6F },
{ 0x46E, 0x0446 },
{ 0x46F, 0x0818 },
{ 0x470, 0x04C6 },
{ 0x471, 0x05BB },
{ 0x472, 0x04C6 },
{ 0x473, 0x040F },
{ 0x474, 0x04CE },
{ 0x475, 0x0339 },
{ 0x476, 0x05DF },
{ 0x477, 0x028F },
{ 0x478, 0x05DF },
{ 0x479, 0x0209 },
{ 0x47A, 0x05DF },
{ 0x47B, 0x00CF },
{ 0x47C, 0x05DF },
{ 0x47D, 0x0001 },
{ 0x47E, 0x07FF },
};
static const struct reg_sequence cs47l35_normal_impedance_patch[] = {
{ 0x460, 0x0C40 },
{ 0x461, 0xCD1A },
{ 0x462, 0x0C40 },
{ 0x463, 0xB53B },
{ 0x464, 0x0C40 },
{ 0x465, 0x7503 },
{ 0x466, 0x0C40 },
{ 0x467, 0x4A41 },
{ 0x468, 0x0041 },
{ 0x469, 0x3491 },
{ 0x46A, 0x0841 },
{ 0x46B, 0x1F50 },
{ 0x46C, 0x0446 },
{ 0x46D, 0x14ED },
{ 0x46E, 0x0446 },
{ 0x46F, 0x1455 },
{ 0x470, 0x04C6 },
{ 0x471, 0x1220 },
{ 0x472, 0x04C6 },
{ 0x473, 0x040F },
{ 0x474, 0x04CE },
{ 0x475, 0x0339 },
{ 0x476, 0x05DF },
{ 0x477, 0x028F },
{ 0x478, 0x05DF },
{ 0x479, 0x0209 },
{ 0x47A, 0x05DF },
{ 0x47B, 0x00CF },
{ 0x47C, 0x05DF },
{ 0x47D, 0x0001 },
{ 0x47E, 0x07FF },
};
static const struct madera_hp_tuning cs47l35_hp_tuning[] = {
{
1300,
cs47l35_low_impedance_patch,
ARRAY_SIZE(cs47l35_low_impedance_patch),
},
{
MADERA_HPDET_MAX_HOHM,
cs47l35_normal_impedance_patch,
ARRAY_SIZE(cs47l35_normal_impedance_patch),
},
};
static const struct reg_sequence cs47l85_low_impedance_patch[] = {
{ 0x465, 0x4C6D },
{ 0x467, 0x3950 },
{ 0x469, 0x2D86 },
{ 0x46B, 0x1E6D },
{ 0x46D, 0x199A },
{ 0x46F, 0x1456 },
{ 0x483, 0x0826 },
};
static const struct reg_sequence cs47l85_normal_impedance_patch[] = {
{ 0x465, 0x8A43 },
{ 0x467, 0x7259 },
{ 0x469, 0x65EA },
{ 0x46B, 0x50F4 },
{ 0x46D, 0x41CD },
{ 0x46F, 0x199A },
{ 0x483, 0x0023 },
};
static const struct madera_hp_tuning cs47l85_hp_tuning[] = {
{
1300,
cs47l85_low_impedance_patch,
ARRAY_SIZE(cs47l85_low_impedance_patch),
},
{
MADERA_HPDET_MAX_HOHM,
cs47l85_normal_impedance_patch,
ARRAY_SIZE(cs47l85_normal_impedance_patch),
},
};
static const struct reg_sequence cs47l90_low_impedance_patch[] = {
{ 0x460, 0x0C21 },
{ 0x461, 0xB53C },
{ 0x462, 0x0C21 },
{ 0x463, 0xA186 },
{ 0x464, 0x0C21 },
{ 0x465, 0x8FF6 },
{ 0x466, 0x0C24 },
{ 0x467, 0x804E },
{ 0x468, 0x0C24 },
{ 0x469, 0x725A },
{ 0x46A, 0x0C24 },
{ 0x46B, 0x5AD5 },
{ 0x46C, 0x0C28 },
{ 0x46D, 0x50F4 },
{ 0x46E, 0x0C2C },
{ 0x46F, 0x4827 },
{ 0x470, 0x0C31 },
{ 0x471, 0x404E },
{ 0x472, 0x0020 },
{ 0x473, 0x3950 },
{ 0x474, 0x0028 },
{ 0x475, 0x3314 },
{ 0x476, 0x0030 },
{ 0x477, 0x2893 },
{ 0x478, 0x003F },
{ 0x479, 0x2429 },
{ 0x47A, 0x0830 },
{ 0x47B, 0x203A },
{ 0x47C, 0x0420 },
{ 0x47D, 0x1027 },
{ 0x47E, 0x0430 },
};
static const struct reg_sequence cs47l90_normal_impedance_patch[] = {
{ 0x460, 0x0C21 },
{ 0x461, 0xB53C },
{ 0x462, 0x0C25 },
{ 0x463, 0xA186 },
{ 0x464, 0x0C26 },
{ 0x465, 0x8FF6 },
{ 0x466, 0x0C28 },
{ 0x467, 0x804E },
{ 0x468, 0x0C30 },
{ 0x469, 0x725A },
{ 0x46A, 0x0C30 },
{ 0x46B, 0x65EA },
{ 0x46C, 0x0028 },
{ 0x46D, 0x5AD5 },
{ 0x46E, 0x0028 },
{ 0x46F, 0x50F4 },
{ 0x470, 0x0030 },
{ 0x471, 0x4827 },
{ 0x472, 0x0030 },
{ 0x473, 0x404E },
{ 0x474, 0x003F },
{ 0x475, 0x3950 },
{ 0x476, 0x0830 },
{ 0x477, 0x3314 },
{ 0x478, 0x0420 },
{ 0x479, 0x2D86 },
{ 0x47A, 0x0428 },
{ 0x47B, 0x2893 },
{ 0x47C, 0x0428 },
{ 0x47D, 0x203A },
{ 0x47E, 0x0428 },
};
static const struct reg_sequence cs47l90_high_impedance_patch[] = {
{ 0x460, 0x0C21 },
{ 0x461, 0xB53C },
{ 0x462, 0x0C26 },
{ 0x463, 0xA186 },
{ 0x464, 0x0C28 },
{ 0x465, 0x8FF6 },
{ 0x466, 0x0C2A },
{ 0x467, 0x804E },
{ 0x468, 0x0025 },
{ 0x469, 0x725A },
{ 0x46A, 0x0030 },
{ 0x46B, 0x65EA },
{ 0x46C, 0x0030 },
{ 0x46D, 0x5AD5 },
{ 0x46E, 0x003F },
{ 0x46F, 0x50F4 },
{ 0x470, 0x003F },
{ 0x471, 0x4827 },
{ 0x472, 0x0830 },
{ 0x473, 0x404E },
{ 0x474, 0x083F },
{ 0x475, 0x3950 },
{ 0x476, 0x0420 },
{ 0x477, 0x3314 },
{ 0x478, 0x0430 },
{ 0x479, 0x2D86 },
{ 0x47A, 0x0430 },
{ 0x47B, 0x2893 },
{ 0x47C, 0x0430 },
{ 0x47D, 0x203A },
{ 0x47E, 0x0430 },
};
static const struct madera_hp_tuning cs47l90_hp_tuning[] = {
{
1400,
cs47l90_low_impedance_patch,
ARRAY_SIZE(cs47l90_low_impedance_patch),
},
{ 2400,
cs47l90_normal_impedance_patch,
ARRAY_SIZE(cs47l90_normal_impedance_patch),
},
{ MADERA_HPDET_MAX_HOHM,
cs47l90_high_impedance_patch,
ARRAY_SIZE(cs47l90_high_impedance_patch),
},
};
static const struct reg_sequence cs47l92_low_impedance_patch[] = {
{ 0x460, 0x0C21 },
{ 0x461, 0xB53C },
{ 0x462, 0x0C21 },
{ 0x463, 0xA186 },
{ 0x464, 0x0C21 },
{ 0x465, 0x8FF6 },
{ 0x466, 0x0C21 },
{ 0x467, 0x804E },
{ 0x468, 0x0C21 },
{ 0x469, 0x725A },
{ 0x46A, 0x0C21 },
{ 0x46B, 0x5AD5 },
{ 0x46C, 0x0C21 },
{ 0x46D, 0x50F4 },
{ 0x46E, 0x0C21 },
{ 0x46F, 0x4827 },
{ 0x470, 0x0C21 },
{ 0x471, 0x404E },
{ 0x472, 0x0020 },
{ 0x473, 0x3950 },
{ 0x474, 0x0021 },
{ 0x475, 0x3314 },
{ 0x476, 0x0021 },
{ 0x477, 0x2893 },
{ 0x478, 0x0021 },
{ 0x479, 0x2429 },
{ 0x47A, 0x0821 },
{ 0x47B, 0x203A },
{ 0x47C, 0x0420 },
{ 0x47D, 0x1027 },
{ 0x47E, 0x0421 },
};
static const struct reg_sequence cs47l92_normal_impedance_patch[] = {
{ 0x460, 0x0C21 },
{ 0x461, 0xB53C },
{ 0x462, 0x0C21 },
{ 0x463, 0xA186 },
{ 0x464, 0x0C21 },
{ 0x465, 0x8FF6 },
{ 0x466, 0x0C21 },
{ 0x467, 0x804E },
{ 0x468, 0x0C21 },
{ 0x469, 0x725A },
{ 0x46A, 0x0C21 },
{ 0x46B, 0x65EA },
{ 0x46C, 0x0021 },
{ 0x46D, 0x5AD5 },
{ 0x46E, 0x0021 },
{ 0x46F, 0x50F4 },
{ 0x470, 0x0021 },
{ 0x471, 0x4827 },
{ 0x472, 0x0021 },
{ 0x473, 0x404E },
{ 0x474, 0x0021 },
{ 0x475, 0x3950 },
{ 0x476, 0x0821 },
{ 0x477, 0x3314 },
{ 0x478, 0x0420 },
{ 0x479, 0x2D86 },
{ 0x47A, 0x0421 },
{ 0x47B, 0x2893 },
{ 0x47C, 0x0421 },
{ 0x47D, 0x203A },
{ 0x47E, 0x0421 },
};
static const struct reg_sequence cs47l92_high_impedance_patch[] = {
{ 0x460, 0x0C21 },
{ 0x461, 0xB53C },
{ 0x462, 0x0C21 },
{ 0x463, 0xA186 },
{ 0x464, 0x0C21 },
{ 0x465, 0x8FF6 },
{ 0x466, 0x0021 },
{ 0x467, 0x804E },
{ 0x468, 0x0021 },
{ 0x469, 0x725A },
{ 0x46A, 0x0021 },
{ 0x46B, 0x65EA },
{ 0x46C, 0x0021 },
{ 0x46D, 0x5AD5 },
{ 0x46E, 0x0021 },
{ 0x46F, 0x50F4 },
{ 0x470, 0x0021 },
{ 0x471, 0x4827 },
{ 0x472, 0x0821 },
{ 0x473, 0x404E },
{ 0x474, 0x0821 },
{ 0x475, 0x3950 },
{ 0x476, 0x0420 },
{ 0x477, 0x3314 },
{ 0x478, 0x0421 },
{ 0x479, 0x2D86 },
{ 0x47A, 0x0421 },
{ 0x47B, 0x2893 },
{ 0x47C, 0x0421 },
{ 0x47D, 0x203A },
{ 0x47E, 0x0421 },
};
static const struct madera_hp_tuning cs47l92_hp_tuning[] = {
{
1400,
cs47l92_low_impedance_patch,
ARRAY_SIZE(cs47l92_low_impedance_patch),
},
{ 2400,
cs47l92_normal_impedance_patch,
ARRAY_SIZE(cs47l92_normal_impedance_patch),
},
{ MADERA_HPDET_MAX_HOHM,
cs47l92_high_impedance_patch,
ARRAY_SIZE(cs47l92_high_impedance_patch),
},
};
static ssize_t madera_extcon_show(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct platform_device *pdev = to_platform_device(dev);
struct madera_extcon *info = platform_get_drvdata(pdev);
return scnprintf(buf, PAGE_SIZE, "%d\n",
info->madera->hp_impedance_x100[0]);
}
static DEVICE_ATTR(hp1_impedance, 0444, madera_extcon_show, NULL);
static void madera_micd_manual_timeout(struct madera_extcon *info)
{
dev_dbg(info->madera->dev, "Manual MICD timed out\n");
info->mic_impedance = -EINVAL;
madera_jds_set_state(info, info->old_state);
complete(&info->manual_mic_completion);
}
static int madera_micd_manual_reading(struct madera_extcon *info, int val)
{
info->mic_impedance = val;
madera_jds_set_state(info, info->old_state);
complete(&info->manual_mic_completion);
return val;
}
static const struct madera_jd_state madera_micd_manual = {
.mode = MADERA_ACCDET_MODE_ADC,
.start = madera_micd_mic_start,
.reading = madera_micd_manual_reading,
.stop = madera_micd_mic_stop,
.timeout_ms = madera_micd_mic_timeout_ms,
.timeout = madera_micd_manual_timeout,
};
int madera_extcon_manual_mic_reading(struct madera_extcon *info)
{
mutex_lock(&info->lock);
info->old_state = info->state;
madera_jds_set_state(info, &madera_micd_manual);
mutex_unlock(&info->lock);
wait_for_completion(&info->manual_mic_completion);
return madera_hohm_to_ohm(info->mic_impedance);
}
EXPORT_SYMBOL_GPL(madera_extcon_manual_mic_reading);
static ssize_t madera_extcon_mic_show(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct platform_device *pdev = to_platform_device(dev);
struct madera_extcon *info = platform_get_drvdata(pdev);
int mic_impedance = madera_extcon_manual_mic_reading(info);
return scnprintf(buf, PAGE_SIZE, "%d\n", mic_impedance);
}
static DEVICE_ATTR(mic_impedance, S_IRUGO, madera_extcon_mic_show, NULL);
void madera_extcon_report(struct madera_extcon *info, int which, bool attached)
{
int ret;
dev_info(info->dev, "Extcon report: %d is %s\n",
which, attached ? "attached" : "removed");
ret = extcon_set_state_sync(info->edev, which, attached);
if (ret != 0)
dev_warn(info->dev, "Failed to report cable state: %d\n", ret);
if (IS_ENABLED(CONFIG_EXTCON_MADERA_INPUT_EVENT)) {
switch (which) {
case EXTCON_MECHANICAL:
input_report_switch(info->input,
SW_JACK_PHYSICAL_INSERT,
attached);
break;
case EXTCON_JACK_HEADPHONE:
input_report_switch(info->input,
SW_HEADPHONE_INSERT,
attached);
break;
case EXTCON_JACK_MICROPHONE:
input_report_switch(info->input,
SW_MICROPHONE_INSERT,
attached);
break;
default:
return;
}
input_sync(info->input);
}
}
EXPORT_SYMBOL_GPL(madera_extcon_report);
static
enum madera_accdet_mode madera_jds_get_mode(struct madera_extcon *info)
{
if (info->state)
return info->state->mode;
else
return MADERA_ACCDET_MODE_INVALID;
}
int madera_jds_set_state(struct madera_extcon *info,
const struct madera_jd_state *new_state)
{
int ret = 0;
if (new_state != info->state) {
if (info->state)
info->state->stop(info);
info->state = new_state;
if (info->state) {
ret = info->state->start(info);
if (ret < 0)
info->state = NULL;
}
}
return ret;
}
EXPORT_SYMBOL_GPL(madera_jds_set_state);
static void madera_jds_reading(struct madera_extcon *info, int val)
{
int ret;
ret = info->state->reading(info, val);
if (ret == -EAGAIN && info->state->restart)
info->state->restart(info);
}
static inline bool madera_jds_cancel_timeout(struct madera_extcon *info)
{
return cancel_delayed_work_sync(&info->state_timeout_work);
}
static void madera_jds_start_timeout(struct madera_extcon *info)
{
const struct madera_jd_state *state = info->state;
if (!state)
return;
if (state->timeout_ms && state->timeout) {
int ms = state->timeout_ms(info);
schedule_delayed_work(&info->state_timeout_work,
msecs_to_jiffies(ms));
}
}
static void madera_jds_timeout_work(struct work_struct *work)
{
struct madera_extcon *info =
container_of(work, struct madera_extcon,
state_timeout_work.work);
mutex_lock(&info->lock);
if (!info->state) {
dev_warn(info->dev, "Spurious timeout in idle state\n");
} else if (!info->state->timeout) {
dev_warn(info->dev, "Spurious timeout state.mode=%d\n",
info->state->mode);
} else {
info->state->timeout(info);
madera_jds_start_timeout(info);
}
mutex_unlock(&info->lock);
}
static void madera_extcon_hp_clamp(struct madera_extcon *info, bool clamp)
{
struct madera *madera = info->madera;
unsigned int mask, val = 0;
unsigned int edre_reg = 0, edre_val = 0;
unsigned int ep_sel = 0;
int ret;
snd_soc_dapm_mutex_lock(madera->dapm);
switch (madera->type) {
case CS47L15:
case CS47L35:
case CS47L92:
case CS47L93:
/*
* check whether audio is routed to EPOUT, do not disable OUT1
* in that case
*/
regmap_read(madera->regmap, MADERA_OUTPUT_ENABLES_1, &ep_sel);
ep_sel &= MADERA_EP_SEL_MASK;
break;
default:
break;
};
switch (madera->type) {
case CS47L35:
case CS47L85:
case WM1840:
edre_reg = MADERA_EDRE_MANUAL;
mask = MADERA_HP1L_SHRTO | MADERA_HP1L_FLWR | MADERA_HP1L_SHRTI;
if (clamp) {
val = MADERA_HP1L_SHRTO;
edre_val = MADERA_EDRE_OUT1L_MANUAL |
MADERA_EDRE_OUT1R_MANUAL;
} else {
val = MADERA_HP1L_FLWR | MADERA_HP1L_SHRTI;
edre_val = 0;
}
break;
default:
mask = MADERA_HPD_OVD_ENA_SEL_MASK;
if (clamp)
val = MADERA_HPD_OVD_ENA_SEL_MASK;
else
val = 0;
break;
}
madera->out_clamp[0] = clamp;
/* Keep the HP output stages disabled while doing the clamp */
if (clamp && !ep_sel) {
ret = regmap_update_bits(madera->regmap,
MADERA_OUTPUT_ENABLES_1,
(MADERA_OUT1L_ENA |
MADERA_OUT1R_ENA) <<
(2 * (info->pdata->output - 1)),
0);
if (ret)
dev_warn(info->dev,
"Failed to disable headphone outputs: %d\n",
ret);
}
if (edre_reg && !ep_sel) {
ret = regmap_update_bits(madera->regmap, edre_reg,
MADERA_EDRE_OUT1L_MANUAL_MASK |
MADERA_EDRE_OUT1R_MANUAL_MASK,
edre_val);
if (ret)
dev_warn(info->dev,
"Failed to set EDRE Manual: %d\n", ret);
}
dev_info(info->dev, "%s clamp mask=0x%x val=0x%x\n",
clamp ? "Setting" : "Clearing", mask, val);
switch (madera->type) {
case CS47L35:
case CS47L85:
case WM1840:
ret = regmap_update_bits(madera->regmap,
MADERA_HP_CTRL_1L, mask, val);
if (ret)
dev_warn(info->dev, "Failed to do clamp: %d\n", ret);
ret = regmap_update_bits(madera->regmap,
MADERA_HP_CTRL_1R, mask, val);
if (ret)
dev_warn(info->dev, "Failed to do clamp: %d\n", ret);
break;
default:
ret = regmap_update_bits(madera->regmap,
MADERA_HEADPHONE_DETECT_0,
MADERA_HPD_OVD_ENA_SEL_MASK,
val);
if (ret)
dev_warn(info->dev, "Failed to do clamp: %d\n", ret);
break;
}
/* Restore the desired state while not doing the clamp */
if (!clamp) {
madera->out_shorted[0] = (madera->hp_impedance_x100[0] <=
info->hpdet_short_x100);
if (!madera->out_shorted[0] && !ep_sel) {
ret = regmap_update_bits(madera->regmap,
MADERA_OUTPUT_ENABLES_1,
(MADERA_OUT1L_ENA |
MADERA_OUT1R_ENA) <<
(2 * (info->pdata->output - 1)),
madera->hp_ena);
if (ret)
dev_warn(info->dev,
"Failed to restore headphone outputs: %d\n",
ret);
}
}
snd_soc_dapm_mutex_unlock(madera->dapm);
}
static const char *madera_extcon_get_micbias_src(struct madera_extcon *info)
{
struct madera *madera = info->madera;
unsigned int bias = info->micd_modes[info->micd_mode].bias;
switch (madera->type) {
case CS47L15:
switch (bias) {
case 0:
case 1:
case 2:
return "MICBIAS1";
default:
return "MICVDD";
}
break;
case CS47L35:
case CS47L85:
case WM1840:
return NULL;
case CS47L90:
case CS47L91:
switch (bias) {
case 0:
case 1:
case 2:
case 3:
return "MICBIAS1";
case 4:
case 5:
case 6:
case 7:
return "MICBIAS2";
default:
return "MICVDD";
}
break;
case CS47L92:
case CS47L93:
switch (bias) {
case 0:
case 1:
case 2:
case 3:
return "MICBIAS1";
case 4:
case 5:
return "MICBIAS2";
default:
return "MICVDD";
}
break;
default:
return NULL;
}
}
static const char *madera_extcon_get_micbias(struct madera_extcon *info)
{
struct madera *madera = info->madera;
unsigned int bias = info->micd_modes[info->micd_mode].bias;
switch (madera->type) {
case CS47L15:
switch (bias) {
case 0:
return "MICBIAS1A";
case 1:
return "MICBIAS1B";
case 2:
return "MICBIAS1C";
default:
return "MICVDD";
}
case CS47L35:
switch (bias) {
case 1:
return "MICBIAS1A";
case 2:
return "MICBIAS1B";
case 3:
return "MICBIAS2A";
default:
return "MICVDD";
}
case CS47L85:
case WM1840:
switch (bias) {
case 1:
return "MICBIAS1";
case 2:
return "MICBIAS2";
case 3:
return "MICBIAS3";
case 4:
return "MICBIAS4";
default:
return "MICVDD";
}
case CS47L90:
case CS47L91:
switch (bias) {
case 0:
return "MICBIAS1A";
case 1:
return "MICBIAS1B";
case 2:
return "MICBIAS1C";
case 3:
return "MICBIAS1D";
case 4:
return "MICBIAS2A";
case 5:
return "MICBIAS2B";
case 6:
return "MICBIAS2C";
case 7:
return "MICBIAS2D";
default:
return "MICVDD";
}
case CS47L92:
case CS47L93:
switch (bias) {
case 0:
return "MICBIAS1A";
case 1:
return "MICBIAS1B";
case 2:
return "MICBIAS1C";
case 3:
return "MICBIAS1D";
case 4:
return "MICBIAS2A";
case 5:
return "MICBIAS2B";
default:
return "MICVDD";
}
default:
return NULL;
}
}
static void madera_extcon_enable_micbias_pin(struct madera_extcon *info,
const char *widget)
{
struct madera *madera = info->madera;
struct snd_soc_dapm_context *dapm = madera->dapm;
int ret;
ret = snd_soc_dapm_force_enable_pin(dapm, widget);
if (ret)
dev_warn(info->dev, "Failed to enable %s: %d\n", widget, ret);
snd_soc_dapm_sync(dapm);
dev_dbg(info->dev, "Enabled %s\n", widget);
}
static void madera_extcon_disable_micbias_pin(struct madera_extcon *info,
const char *widget)
{
struct madera *madera = info->madera;
struct snd_soc_dapm_context *dapm = madera->dapm;
int ret;
ret = snd_soc_dapm_disable_pin(dapm, widget);
if (ret)
dev_warn(info->dev, "Failed to enable %s: %d\n", widget, ret);
snd_soc_dapm_sync(dapm);
dev_dbg(info->dev, "Disabled %s\n", widget);
}
static void madera_extcon_set_micd_bias(struct madera_extcon *info, bool enable)
{
int old_bias = info->micd_bias.bias;
int new_bias = info->micd_modes[info->micd_mode].bias;
const char *widget;
info->micd_bias.bias = new_bias;
if ((new_bias == old_bias) && (info->micd_bias.enabled == enable))
return;
widget = madera_extcon_get_micbias_src(info);
WARN_ON(!widget);
if (info->micd_bias.enabled)
madera_extcon_disable_micbias_pin(info, widget);
if (enable)
madera_extcon_enable_micbias_pin(info, widget);
info->micd_bias.enabled = enable;
}
static void madera_extcon_enable_micbias(struct madera_extcon *info)
{
struct madera *madera = info->madera;
const char *widget = madera_extcon_get_micbias(info);
switch (madera->type) {
case CS47L35:
case CS47L85:
case WM1840:
break;
default:
madera_extcon_set_micd_bias(info, true);
break;
}
/*
* If forced we must manually control the pin state, otherwise
* the codec will manage this automatically
*/
if (info->pdata->micd_force_micbias)
madera_extcon_enable_micbias_pin(info, widget);
}
static void madera_extcon_disable_micbias(struct madera_extcon *info)
{
struct madera *madera = info->madera;
const char *widget = madera_extcon_get_micbias(info);
switch (madera->type) {
case CS47L35:
case CS47L85:
case WM1840:
break;
default:
madera_extcon_set_micd_bias(info, false);
break;
}
/*
* If forced we must manually control the pin state, otherwise
* the codec will manage this automatically
*/
if (info->pdata->micd_force_micbias)
madera_extcon_disable_micbias_pin(info, widget);
}
static void madera_extcon_set_mode(struct madera_extcon *info, int mode)
{
struct madera *madera = info->madera;
dev_info(info->dev,
"set mic_mode[%d] src=0x%x gnd=0x%x bias=0x%x gpio=%d hp_gnd=%d\n",
mode, info->micd_modes[mode].src, info->micd_modes[mode].gnd,
info->micd_modes[mode].bias, info->micd_modes[mode].gpio,
info->micd_modes[mode].hp_gnd);
if (info->micd_pol_gpio)
gpiod_set_value_cansleep(info->micd_pol_gpio,
info->micd_modes[mode].gpio);
switch (madera->type) {
case CS47L35:
case CS47L85:
case WM1840:
regmap_update_bits(madera->regmap,
MADERA_MIC_DETECT_1_CONTROL_1,
MADERA_MICD_BIAS_SRC_MASK,
info->micd_modes[mode].bias <<
MADERA_MICD_BIAS_SRC_SHIFT);
regmap_update_bits(madera->regmap,
MADERA_ACCESSORY_DETECT_MODE_1,
MADERA_ACCDET_SRC,
info->micd_modes[mode].src <<
MADERA_ACCDET_SRC_SHIFT);
break;
default:
regmap_update_bits(madera->regmap,
MADERA_MIC_DETECT_1_CONTROL_1,
MADERA_MICD_BIAS_SRC_MASK,
info->micd_modes[mode].bias <<
MADERA_MICD_BIAS_SRC_SHIFT);
regmap_update_bits(madera->regmap,
MADERA_MIC_DETECT_1_CONTROL_0,
MADERA_MICD1_SENSE_MASK,
info->micd_modes[mode].src <<
MADERA_MICD1_SENSE_SHIFT);
regmap_update_bits(madera->regmap,
MADERA_MIC_DETECT_1_CONTROL_0,
MADERA_MICD1_GND_MASK,
info->micd_modes[mode].gnd <<
MADERA_MICD1_GND_SHIFT);
regmap_update_bits(madera->regmap,
MADERA_HEADPHONE_DETECT_0,
MADERA_HPD_GND_SEL_MASK,
info->micd_modes[mode].gnd <<
MADERA_HPD_GND_SEL_SHIFT);
regmap_update_bits(madera->regmap,
MADERA_OUTPUT_PATH_CONFIG_1 +
(8 * (info->pdata->output - 1)),
MADERA_HP1_GND_SEL_MASK,
info->micd_modes[mode].hp_gnd <<
MADERA_HP1_GND_SEL_SHIFT);
break;
}
info->micd_mode = mode;
}
static void madera_extcon_next_mode(struct madera_extcon *info)
{
int old_mode = info->micd_mode;
int new_mode;
bool change_bias = false;
new_mode = (old_mode + 1) % info->num_micd_modes;
dev_dbg(info->dev, "change micd mode %d->%d (bias %d->%d)\n",
old_mode, new_mode,
info->micd_modes[old_mode].bias,
info->micd_modes[new_mode].bias);
if (info->micd_modes[old_mode].bias !=
info->micd_modes[new_mode].bias) {
change_bias = true;
madera_extcon_disable_micbias(info);
}
madera_extcon_set_mode(info, new_mode);
if (change_bias)
madera_extcon_enable_micbias(info);
}
static int madera_micd_adc_read(struct madera_extcon *info)
{
struct madera *madera = info->madera;
unsigned int val = 0;
int ret;
/* Must disable MICD before we read the ADCVAL */
ret = regmap_update_bits(madera->regmap, MADERA_MIC_DETECT_1_CONTROL_1,
MADERA_MICD_ENA, 0);
if (ret) {
dev_err(info->dev, "Failed to disable MICD: %d\n", ret);
return ret;
}
ret = regmap_read(madera->regmap, MADERA_MIC_DETECT_1_CONTROL_4, &val);
if (ret) {
dev_err(info->dev, "Failed to read MICDET_ADCVAL: %d\n", ret);
return ret;
}
dev_info(info->dev, "MICDET_ADCVAL: 0x%x\n", val);
val &= MADERA_MICDET_ADCVAL_MASK;
if (val < ARRAY_SIZE(madera_micd_levels))
val = madera_micd_levels[val];
else
val = INT_MAX;
return val;
}
static int madera_micd_read(struct madera_extcon *info)
{
struct madera *madera = info->madera;
unsigned int val = 0;
int ret, i;
for (i = 0; i < 10 && !(val & MADERA_MICD_LVL_0_TO_8); i++) {
ret = regmap_read(madera->regmap,
MADERA_MIC_DETECT_1_CONTROL_3, &val);
if (ret) {
dev_err(info->dev,
"Failed to read MICDET: %d\n", ret);
return ret;
}
dev_info(info->dev, "MICDET: 0x%x\n", val);
if (!(val & MADERA_MICD_VALID)) {
dev_warn(info->dev,
"Microphone detection state invalid\n");
return -EINVAL;
}
}
if (i == 10 && !(val & MADERA_MICD_LVL_0_TO_8)) {
dev_warn(info->dev, "Failed to get valid MICDET value\n");
return -EINVAL;
}
if (!(val & MADERA_MICD_STS)) {
val = INT_MAX;
} else if (!(val & MADERA_MICD_LVL_0_TO_7)) {
val = madera_micd_levels[ARRAY_SIZE(madera_micd_levels) - 1];
} else {
int lvl;
lvl = (val & MADERA_MICD_LVL_MASK) >> MADERA_MICD_LVL_SHIFT;
lvl = ffs(lvl) - 1;
if (lvl < info->num_micd_ranges) {
val = info->micd_ranges[lvl].max;
} else {
i = ARRAY_SIZE(madera_micd_levels) - 2;
val = madera_micd_levels[i];
}
}
return val;
}
static void madera_extcon_notify_micd(const struct madera_extcon *info,
bool present,
unsigned int impedance)
{
struct madera_micdet_notify_data data;
data.present = present;
data.impedance_x100 = madera_ohm_to_hohm(impedance);
data.out_num = info->pdata->output;
madera_call_notifiers(info->madera, MADERA_NOTIFY_MICDET, &data);
}
static int madera_hpdet_calc_calibration(const struct madera_extcon *info,
int dacval,
const struct madera_hpdet_trims *trims,
const struct madera_hpdet_calibration_data *calib)
{
int grad_x4 = trims->grad_x4;
int off_x4 = trims->off_x4;
s64 val = dacval;
s64 n;
val = (val * 1000000) + calib->dacval_adjust;
val = div64_s64(val, calib->C2);
n = div_s64(1000000000000LL, calib->C3 +
((calib->C4_x_C3 * grad_x4) / 4));
n = val - n;
if (n <= 0)
return MADERA_HPDET_MAX_HOHM;
val = calib->C0 + ((calib->C1 * off_x4) / 4);
val *= 1000000;
val = div_s64(val, n);
val -= calib->C5;
/* Round up and divide to get hundredths of an ohm */
val += 500000;
val = div_s64(val, 10000);
if (val < 0)
return 0;
else if (val > MADERA_HPDET_MAX_HOHM)
return MADERA_HPDET_MAX_HOHM;
return (int)val;
}
static int madera_hpdet_calibrate(struct madera_extcon *info,
unsigned int range, unsigned int *ohms_x100)
{
struct madera *madera = info->madera;
unsigned int dacval, dacval_down;
int ret;
ret = regmap_read(madera->regmap, MADERA_HEADPHONE_DETECT_3, &dacval);
if (ret) {
dev_err(info->dev, "Failed to read HP DACVAL: %d\n", ret);
return -EAGAIN;
}
dacval = (dacval >> MADERA_HP_DACVAL_SHIFT) & MADERA_HP_DACVAL_MASK;
switch (madera->type) {
case CS47L35:
case CS47L85:
case WM1840:
ret = regmap_read(madera->regmap, MADERA_HEADPHONE_DETECT_5,
&dacval_down);
if (ret) {
dev_err(info->dev,
"Failed to read HP DACVAL_down: %d\n", ret);
return -EAGAIN;
}
dacval_down = (dacval_down >> MADERA_HP_DACVAL_DOWN_SHIFT) &
MADERA_HP_DACVAL_DOWN_MASK;
dacval = (dacval + dacval_down) / 2;
break;
default:
break;
}
dev_dbg(info->dev,
"hpdet_d calib range %d dac %d\n", range, dacval);
*ohms_x100 = madera_hpdet_calc_calibration(info, dacval,
&info->hpdet_trims[range],
&info->hpdet_ranges[range]);
return 0;
}
static int madera_hpdet_read(struct madera_extcon *info)
{
struct madera *madera = info->madera;
unsigned int val, range, sense_pin, ohms_x100;
int ret;
bool is_jdx_micdetx_pin = false;
int hpdet_ext_res_x100;
ret = regmap_read(madera->regmap, MADERA_HEADPHONE_DETECT_2, &val);
if (ret) {
dev_err(info->dev, "Failed to read HPDET status: %d\n", ret);
return ret;
}
dev_info(info->dev, "HPDET read: 0x%x\n", val);
if (!(val & MADERA_HP_DONE_MASK)) {
dev_warn(info->dev, "HPDET did not complete: %x\n", val);
return -EAGAIN;
}
switch (madera->type) {
case CS47L35:
case CS47L85:
case WM1840:
break;
default:
regmap_read(madera->regmap, MADERA_HEADPHONE_DETECT_0,
&sense_pin);
sense_pin = (sense_pin & MADERA_HPD_SENSE_SEL_MASK) >>
MADERA_HPD_SENSE_SEL_SHIFT;
switch (sense_pin) {
case MADERA_HPD_SENSE_HPDET1:
case MADERA_HPD_SENSE_HPDET2:
is_jdx_micdetx_pin = false;
break;
default:
dev_dbg(info->dev, "is_jdx_micdetx_pin\n");
is_jdx_micdetx_pin = true;
}
break;
}
val &= MADERA_HP_LVL_MASK;
/* The value is in 0.5 ohm increments, get it in hundredths */
ohms_x100 = val * 50;
if (is_jdx_micdetx_pin)
goto done;
regmap_read(madera->regmap, MADERA_HEADPHONE_DETECT_1, &range);
range = (range & MADERA_HP_IMPEDANCE_RANGE_MASK) >>
MADERA_HP_IMPEDANCE_RANGE_SHIFT;
/* Skip up a range, or report? */
if (range < info->num_hpdet_ranges - 1 &&
((val / 2) >= info->hpdet_ranges[range].max)) {
range++;
dev_dbg(info->dev, "Moving to HPDET range %d-%d\n",
info->hpdet_ranges[range].min,
info->hpdet_ranges[range].max);
regmap_update_bits(madera->regmap,
MADERA_HEADPHONE_DETECT_1,
MADERA_HP_IMPEDANCE_RANGE_MASK,
range <<
MADERA_HP_IMPEDANCE_RANGE_SHIFT);
return -EAGAIN;
}
if (info->hpdet_trims) {
/* Perform calibration */
ret = madera_hpdet_calibrate(info, range, &ohms_x100);
if (ret)
return ret;
} else {
/* Use uncalibrated reading */
if (range && ((val / 2) < info->hpdet_ranges[range].min)) {
dev_dbg(info->dev,
"Reporting range boundary %d\n",
info->hpdet_ranges[range].min);
ohms_x100 =
madera_ohm_to_hohm(info->hpdet_ranges[range].min);
}
}
hpdet_ext_res_x100 = info->pdata->hpdet_ext_res_x100;
if (hpdet_ext_res_x100) {
if (hpdet_ext_res_x100 >= ohms_x100) {
dev_dbg(info->dev,
"External resistor (%d.%02d) >= measurement (%d.00)\n",
hpdet_ext_res_x100 / 100,
hpdet_ext_res_x100 % 100,
val);
ohms_x100 = 0; /* treat as a short */
} else {
dev_dbg(info->dev,
"Compensating for external %d.%02d ohm resistor\n",
hpdet_ext_res_x100 / 100,
hpdet_ext_res_x100 % 100);
ohms_x100 -= hpdet_ext_res_x100;
}
}
done:
dev_dbg(info->dev, "HP impedance %d.%02d ohms\n",
ohms_x100 / 100, ohms_x100 % 100);
return (int)ohms_x100;
}
static void madera_hs_mic_control(struct madera_extcon *info, int state)
{
struct madera *madera = info->madera;
unsigned int addr = MADERA_ADC_DIGITAL_VOLUME_1L;
unsigned int val, in_bit;
int ret;
if (!info->pdata->hs_mic)
return;
addr += (info->pdata->hs_mic - 1) * 4;
switch (state) {
case MADERA_MIC_MUTE:
dev_dbg(info->dev, "Mute headset mic: 0x%04x\n", addr);
snd_soc_dapm_mutex_lock(madera->dapm);
regmap_update_bits(madera->regmap,
addr,
MADERA_IN1L_MUTE_MASK,
MADERA_MIC_MUTE << MADERA_IN1L_MUTE_SHIFT);
madera->hs_mic_muted = true;
snd_soc_dapm_mutex_unlock(madera->dapm);
break;
case MADERA_MIC_UNMUTE:
dev_dbg(info->dev, "Unmute headset mic: 0x%04x\n", addr);
in_bit = 1 << ((info->pdata->hs_mic - 1) ^ 1);
snd_soc_dapm_mutex_lock(madera->dapm);
ret = regmap_read(madera->regmap, MADERA_INPUT_ENABLES, &val);
if (ret)
dev_err(info->dev,
"Failed to read input status: %d\n", ret);
madera->hs_mic_muted = false;
if (!ret && (in_bit & val))
regmap_update_bits(madera->regmap,
addr,
MADERA_IN1L_MUTE_MASK,
MADERA_MIC_UNMUTE <<
MADERA_IN1L_MUTE_SHIFT);
snd_soc_dapm_mutex_unlock(madera->dapm);
break;
default:
dev_err(info->dev,
"Unknown headset mic control state: %d\n", state);
return;
}
}
static int madera_tune_headphone(struct madera_extcon *info, int reading)
{
struct madera *madera = info->madera;
const struct madera_hp_tuning *tuning;
int n_tunings;
int i, ret;
switch (madera->type) {
case CS47L15:
tuning = cs47l15_hp_tuning;
n_tunings = ARRAY_SIZE(cs47l15_hp_tuning);
break;
case CS47L35:
tuning = cs47l35_hp_tuning;
n_tunings = ARRAY_SIZE(cs47l35_hp_tuning);
break;
case CS47L85:
case WM1840:
tuning = cs47l85_hp_tuning;
n_tunings = ARRAY_SIZE(cs47l85_hp_tuning);
break;
case CS47L90:
case CS47L91:
tuning = cs47l90_hp_tuning;
n_tunings = ARRAY_SIZE(cs47l90_hp_tuning);
break;
case CS47L92:
case CS47L93:
tuning = cs47l92_hp_tuning;
n_tunings = ARRAY_SIZE(cs47l92_hp_tuning);
break;
default:
return 0;
}
if (reading <= info->hpdet_short_x100) {
/* Headphones are always off here so just mark them */
dev_warn(info->dev, "Possible HP short, disabling\n");
return 0;
}
if (reading == MADERA_HP_Z_OPEN) {
if (info->hp_tuning_level == 1)
return 0;
dev_dbg(info->dev, "No jack: Setting tuning level 1\n");
info->hp_tuning_level = 1;
ret = regmap_multi_reg_write(madera->regmap,
tuning[1].patch,
tuning[1].patch_len);
return ret;
}
/*
* Check for tuning, we don't need to compare against the last
* tuning entry because we always select that if reading is not
* in range of the lower tunings
*/
for (i = 0; i < n_tunings - 1; ++i) {
if (reading <= tuning[i].max_hohm)
break;
}
if (info->hp_tuning_level != i) {
dev_dbg(info->dev, "New tuning level %d\n", i);
info->hp_tuning_level = i;
ret = regmap_multi_reg_write(madera->regmap,
tuning[i].patch,
tuning[i].patch_len);
if (ret) {
dev_err(info->dev,
"Failed to apply HP tuning %d\n", ret);
return ret;
}
}
return 0;
}
void madera_set_headphone_imp(struct madera_extcon *info, int ohms_x100)
{
struct madera *madera = info->madera;
struct madera_hpdet_notify_data data;
madera->hp_impedance_x100[0] = ohms_x100;
data.impedance_x100 = ohms_x100;
madera_call_notifiers(madera, MADERA_NOTIFY_HPDET, &data);
madera_tune_headphone(info, ohms_x100);
}
EXPORT_SYMBOL_GPL(madera_set_headphone_imp);
static void madera_hpdet_start_micd(struct madera_extcon *info)
{
struct madera *madera = info->madera;
regmap_update_bits(madera->regmap, MADERA_IRQ1_MASK_6,
MADERA_IM_MICDET1_EINT1_MASK,
MADERA_IM_MICDET1_EINT1);
regmap_update_bits(madera->regmap, MADERA_MIC_DETECT_1_CONTROL_0,
MADERA_MICD1_ADC_MODE_MASK,
MADERA_MICD1_ADC_MODE_MASK);
regmap_update_bits(madera->regmap, MADERA_MIC_DETECT_1_CONTROL_1,
MADERA_MICD_BIAS_STARTTIME_MASK |
MADERA_MICD_RATE_MASK |
MADERA_MICD_DBTIME_MASK |
MADERA_MICD_ENA, MADERA_MICD_ENA);
}
static void madera_hpdet_stop_micd(struct madera_extcon *info)
{
struct madera *madera = info->madera;
unsigned int start_time = 1, dbtime = 1, rate = 1;
if (info->pdata->micd_bias_start_time)
start_time = info->pdata->micd_bias_start_time;
if (info->pdata->micd_rate)
rate = info->pdata->micd_rate;
if (info->pdata->micd_dbtime)
dbtime = info->pdata->micd_dbtime;
regmap_update_bits(madera->regmap, MADERA_MIC_DETECT_1_CONTROL_1,
MADERA_MICD_BIAS_STARTTIME_MASK |
MADERA_MICD_RATE_MASK |
MADERA_MICD_DBTIME_MASK |
MADERA_MICD_ENA,
start_time << MADERA_MICD_BIAS_STARTTIME_SHIFT |
rate << MADERA_MICD_RATE_SHIFT |
dbtime << MADERA_MICD_DBTIME_SHIFT);
usleep_range(100, 400);
/* Clear any spurious IRQs that have happened */
regmap_write(madera->regmap, MADERA_IRQ1_STATUS_6,
MADERA_MICDET1_EINT1);
regmap_update_bits(madera->regmap, MADERA_IRQ1_MASK_6,
MADERA_IM_MICDET1_EINT1_MASK, 0);
}
int madera_hpdet_start(struct madera_extcon *info)
{
struct madera *madera = info->madera;
int ret;
unsigned int hpd_sense, hpd_clamp, val, hpd_gnd;
dev_dbg(info->dev, "Starting HPDET\n");
/* If we specified to assume a fixed impedance skip HPDET */
if (info->pdata->fixed_hpdet_imp_x100) {
madera_set_headphone_imp(info,
info->pdata->fixed_hpdet_imp_x100);
ret = -EEXIST;
goto skip;
}
/* Make sure we keep the device enabled during the measurement */
pm_runtime_get_sync(info->dev);
switch (madera->type) {
case CS47L35:
case CS47L85:
case WM1840:
madera_extcon_hp_clamp(info, true);
ret = regmap_update_bits(madera->regmap,
MADERA_ACCESSORY_DETECT_MODE_1,
MADERA_ACCDET_MODE_MASK,
info->state->mode);
if (ret) {
dev_err(info->dev,
"Failed to set HPDET mode (%d): %d\n",
info->state->mode,
ret);
goto err;
}
break;
default:
if (info->state->mode == MADERA_ACCDET_MODE_HPL) {
hpd_clamp = info->pdata->hpd_pins[0];
hpd_sense = info->pdata->hpd_pins[1];
} else {
hpd_clamp = info->pdata->hpd_pins[2];
hpd_sense = info->pdata->hpd_pins[3];
}
hpd_gnd = info->micd_modes[info->micd_mode].gnd;
val = (hpd_sense << MADERA_HPD_SENSE_SEL_SHIFT) |
(hpd_clamp << MADERA_HPD_OUT_SEL_SHIFT) |
(hpd_sense << MADERA_HPD_FRC_SEL_SHIFT) |
(hpd_gnd << MADERA_HPD_GND_SEL_SHIFT);
ret = regmap_update_bits(madera->regmap,
MADERA_MIC_DETECT_1_CONTROL_0,
MADERA_MICD1_GND_MASK,
hpd_gnd << MADERA_MICD1_GND_SHIFT);
if (ret) {
dev_err(madera->dev, "Failed to set MICD_GND: %d\n",
ret);
goto err;
}
ret = regmap_update_bits(madera->regmap,
MADERA_HEADPHONE_DETECT_0,
MADERA_HPD_GND_SEL_MASK |
MADERA_HPD_SENSE_SEL_MASK |
MADERA_HPD_FRC_SEL_MASK |
MADERA_HPD_OUT_SEL_MASK,
val);
if (ret) {
dev_err(info->dev,
"Failed to set HPDET sense: %d\n", ret);
goto err;
}
madera_extcon_hp_clamp(info, true);
madera_hpdet_start_micd(info);
break;
}
ret = regmap_update_bits(madera->regmap, MADERA_HEADPHONE_DETECT_1,
MADERA_HP_POLL, MADERA_HP_POLL);
if (ret) {
dev_err(info->dev, "Can't start HPDET measurement: %d\n", ret);
goto err;
}
return 0;
err:
madera_extcon_hp_clamp(info, false);
pm_runtime_put_autosuspend(info->dev);
skip:
return ret;
}
EXPORT_SYMBOL_GPL(madera_hpdet_start);
void madera_hpdet_restart(struct madera_extcon *info)
{
struct madera *madera = info->madera;
/* Reset back to starting range */
regmap_update_bits(madera->regmap, MADERA_MIC_DETECT_1_CONTROL_1,
MADERA_MICD_ENA_MASK, 0);
regmap_update_bits(madera->regmap, MADERA_HEADPHONE_DETECT_1,
MADERA_HP_IMPEDANCE_RANGE_MASK | MADERA_HP_POLL,
info->hpdet_init_range <<
MADERA_HP_IMPEDANCE_RANGE_SHIFT);
switch (madera->type) {
case CS47L35:
case CS47L85:
case WM1840:
break;
default:
regmap_update_bits(madera->regmap,
MADERA_MIC_DETECT_1_CONTROL_1,
MADERA_MICD_ENA_MASK, MADERA_MICD_ENA);
break;
}
regmap_update_bits(madera->regmap, MADERA_HEADPHONE_DETECT_1,
MADERA_HP_POLL, MADERA_HP_POLL);
}
EXPORT_SYMBOL_GPL(madera_hpdet_restart);
static int madera_hpdet_wait(struct madera_extcon *info)
{
struct madera *madera = info->madera;
unsigned int val;
int i, ret;
for (i = 0; i < MADERA_HPDONE_PROBE_COUNT; i++) {
ret = regmap_read(madera->regmap, MADERA_HEADPHONE_DETECT_2,
&val);
if (ret) {
dev_err(madera->dev, "Failed to read HPDET state: %d\n",
ret);
return ret;
}
if (val & MADERA_HP_DONE_MASK)
return 0;
msleep(MADERA_HPDONE_PROBE_INTERVAL_MS);
}
dev_err(madera->dev, "HPDET did not appear to complete\n");
return -ETIMEDOUT;
}
void madera_hpdet_stop(struct madera_extcon *info)
{
struct madera *madera = info->madera;
dev_dbg(info->dev, "Stopping HPDET\n");
/*
* If the jack was removed we abort this state.
* Ensure that the detect hardware has returned to idle
*/
madera_hpdet_wait(info);
/* Reset back to starting range */
madera_hpdet_stop_micd(info);
regmap_update_bits(madera->regmap, MADERA_HEADPHONE_DETECT_1,
MADERA_HP_IMPEDANCE_RANGE_MASK | MADERA_HP_POLL,
info->hpdet_init_range <<
MADERA_HP_IMPEDANCE_RANGE_SHIFT);
switch (madera->type) {
case CS47L35:
case CS47L85:
case WM1840:
/* Reset to default mode */
regmap_update_bits(madera->regmap,
MADERA_ACCESSORY_DETECT_MODE_1,
MADERA_ACCDET_MODE_MASK, 0);
break;
default:
break;
}
madera_extcon_hp_clamp(info, false);
pm_runtime_mark_last_busy(info->dev);
pm_runtime_put_autosuspend(info->dev);
}
EXPORT_SYMBOL_GPL(madera_hpdet_stop);
int madera_hpdet_reading(struct madera_extcon *info, int val)
{
dev_dbg(info->dev, "Reading HPDET %d\n", val);
if (val < 0)
return val;
madera_set_headphone_imp(info, val);
if (info->have_mic)
madera_extcon_report(info, EXTCON_JACK_MICROPHONE, true);
else
madera_extcon_report(info, EXTCON_JACK_HEADPHONE, true);
if (info->have_mic)
madera_jds_set_state(info, &madera_micd_button);
else
madera_jds_set_state(info, NULL);
return 0;
}
EXPORT_SYMBOL_GPL(madera_hpdet_reading);
static int madera_hpdet_moisture_start(struct madera_extcon *info)
{
struct madera *madera = info->madera;
unsigned int hpd_sense, hpd_gnd, val;
int ret;
dev_info(info->dev, "Start moisture det\n");
/* Make sure we keep the device enabled during the measurement */
pm_runtime_get_sync(info->dev);
ret = regmap_update_bits(madera->regmap, MADERA_HEADPHONE_DETECT_1,
MADERA_HP_RATE_MASK,
0x2 << MADERA_HP_RATE_SHIFT);
if (ret) {
dev_err(info->dev, "Failed to set HPDET rate: %d\n", ret);
goto err;
}
switch (madera->type) {
case CS47L35:
case CS47L85:
case WM1840:
ret = regmap_update_bits(madera->regmap,
MADERA_ACCESSORY_DETECT_MODE_1,
MADERA_ACCDET_MODE_MASK,
info->pdata->moisture_pin);
if (ret) {
dev_err(info->dev,
"Failed to set HPDET mode (%d): %d\n",
info->pdata->moisture_pin, ret);
goto err;
}
break;
default:
hpd_sense = info->pdata->moisture_pin;
hpd_gnd = info->micd_modes[info->micd_mode].gnd;
val = (hpd_sense << MADERA_HPD_SENSE_SEL_SHIFT) |
(hpd_sense << MADERA_HPD_FRC_SEL_SHIFT) |
(hpd_gnd << MADERA_HPD_GND_SEL_SHIFT);
ret = regmap_update_bits(madera->regmap,
MADERA_HEADPHONE_DETECT_0,
MADERA_HPD_GND_SEL_MASK |
MADERA_HPD_SENSE_SEL_MASK |
MADERA_HPD_FRC_SEL_MASK, val);
if (ret != 0) {
dev_err(info->dev, "Failed to set HPDET sense: %d\n",
ret);
goto err;
}
madera_hpdet_start_micd(info);
break;
}
ret = regmap_update_bits(madera->regmap,
MADERA_HEADPHONE_DETECT_1,
MADERA_HP_POLL, MADERA_HP_POLL);
if (ret != 0) {
dev_err(info->dev, "Can't start HPDET measurement: %d\n", ret);
goto err;
}
return ret;
err:
pm_runtime_put_autosuspend(info->dev);
return ret;
}
static void madera_hpdet_moisture_stop(struct madera_extcon *info)
{
struct madera *madera = info->madera;
/* Wait for any running detect to finish */
madera_hpdet_wait(info);
switch (madera->type) {
case CS47L35:
case CS47L85:
case WM1840:
regmap_update_bits(madera->regmap,
MADERA_ACCESSORY_DETECT_MODE_1,
MADERA_ACCDET_MODE_MASK, 0);
break;
default:
madera_hpdet_stop_micd(info);
break;
}
regmap_update_bits(madera->regmap, MADERA_HEADPHONE_DETECT_1,
MADERA_HP_IMPEDANCE_RANGE_MASK | MADERA_HP_POLL,
0);
regmap_update_bits(madera->regmap, MADERA_HEADPHONE_DETECT_1,
MADERA_HP_RATE_MASK, 0);
pm_runtime_mark_last_busy(info->dev);
pm_runtime_put_autosuspend(info->dev);
}
static int madera_hpdet_moisture_reading(struct madera_extcon *info, int val)
{
int debounce_lim = info->pdata->moisture_debounce;
unsigned int ohms;
if (val < 0)
return val;
ohms = madera_hohm_to_ohm(val); /* Extra precision not required. */
if (ohms < info->pdata->moisture_imp) {
madera_extcon_report(info, EXTCON_MECHANICAL, true);
if (info->pdata->micd_software_compare)
madera_jds_set_state(info, &madera_micd_adc_mic);
else
madera_jds_set_state(info, &madera_micd_microphone);
} else {
if (debounce_lim) {
if (++info->moisture_count < debounce_lim) {
dev_dbg(info->dev,
"Moisture software debounce: %u, %x\n",
info->moisture_count, ohms);
return -EAGAIN;
}
info->moisture_count = 0;
}
info->madera->moisture_detected = true;
dev_warn(info->dev,
"Jack detection due to moisture, ignoring\n");
madera_jds_set_state(info, NULL);
}
return 0;
}
int madera_micd_start(struct madera_extcon *info)
{
struct madera *madera = info->madera;
int ret;
unsigned int micd_mode;
/* Microphone detection can't use idle mode */
pm_runtime_get_sync(info->dev);
dev_info(info->dev, "Disabling MICD_OVD\n");
regmap_update_bits(madera->regmap,
MADERA_MICD_CLAMP_CONTROL,
MADERA_MICD_CLAMP_OVD_MASK, 0);
ret = regulator_enable(info->micvdd);
if (ret)
dev_err(info->dev, "Failed to enable MICVDD: %d\n", ret);
switch (madera->type) {
case CS47L35:
case CS47L85:
case WM1840:
regmap_update_bits(madera->regmap,
MADERA_ACCESSORY_DETECT_MODE_1,
MADERA_ACCDET_MODE_MASK, info->state->mode);
break;
default:
if (info->state->mode == MADERA_ACCDET_MODE_ADC)
micd_mode = MADERA_MICD1_ADC_MODE_MASK;
else
micd_mode = 0;
regmap_update_bits(madera->regmap,
MADERA_MIC_DETECT_1_CONTROL_0,
MADERA_MICD1_ADC_MODE_MASK, micd_mode);
break;
}
madera_extcon_enable_micbias(info);
regmap_update_bits(madera->regmap, MADERA_MIC_DETECT_1_CONTROL_1,
MADERA_MICD_ENA, MADERA_MICD_ENA);
return 0;
}
EXPORT_SYMBOL_GPL(madera_micd_start);
void madera_micd_stop(struct madera_extcon *info)
{
struct madera *madera = info->madera;
regmap_update_bits(madera->regmap, MADERA_MIC_DETECT_1_CONTROL_1,
MADERA_MICD_ENA, 0);
if (info->wait_for_buttons) {
/* ensure we cancel mute */
info->wait_for_buttons = false;
madera_hs_mic_control(info, MADERA_MIC_UNMUTE);
}
madera_extcon_disable_micbias(info);
switch (madera->type) {
case CS47L35:
case CS47L85:
case WM1840:
/* Reset to default mode */
regmap_update_bits(madera->regmap,
MADERA_ACCESSORY_DETECT_MODE_1,
MADERA_ACCDET_MODE_MASK, 0);
break;
default:
break;
}
regulator_disable(info->micvdd);
dev_info(info->dev, "Enabling MICD_OVD\n");
regmap_update_bits(madera->regmap, MADERA_MICD_CLAMP_CONTROL,
MADERA_MICD_CLAMP_OVD_MASK, MADERA_MICD_CLAMP_OVD);
pm_runtime_mark_last_busy(info->dev);
pm_runtime_put_autosuspend(info->dev);
}
EXPORT_SYMBOL_GPL(madera_micd_stop);
static void madera_micd_restart(struct madera_extcon *info)
{
struct madera *madera = info->madera;
regmap_update_bits(madera->regmap, MADERA_MIC_DETECT_1_CONTROL_1,
MADERA_MICD_ENA, 0);
regmap_update_bits(madera->regmap, MADERA_MIC_DETECT_1_CONTROL_1,
MADERA_MICD_ENA, MADERA_MICD_ENA);
}
int madera_micd_button_start(struct madera_extcon *info)
{
int ret;
info->wait_for_buttons = true;
ret = madera_micd_start(info);
if (ret != 0)
info->wait_for_buttons = false;
return ret;
}
EXPORT_SYMBOL_GPL(madera_micd_button_start);
static int madera_micd_button_debounce(struct madera_extcon *info, int val)
{
int debounce_lim = info->pdata->micd_manual_debounce;
if (debounce_lim) {
if (info->micd_debounce != val)
info->micd_count = 0;
info->micd_debounce = val;
info->micd_count++;
if (info->micd_count == debounce_lim) {
info->micd_count = 0;
if (val == info->micd_res_old)
return 0;
info->micd_res_old = val;
} else {
dev_dbg(info->dev, "Software debounce: %d,%x\n",
info->micd_count, val);
madera_micd_restart(info);
return -EAGAIN;
}
}
return 0;
}
static int madera_micd_button_process(struct madera_extcon *info, int val)
{
int i, key;
if (val < MADERA_MICROPHONE_MIN_OHM) {
dev_info(info->dev, "Mic button detected\n");
madera_hs_mic_control(info, MADERA_MIC_MUTE);
for (i = 0; i < info->num_micd_ranges; i++)
input_report_key(info->input,
info->micd_ranges[i].key, 0);
for (i = 0; i < info->num_micd_ranges; i++) {
if (val <= info->micd_ranges[i].max) {
key = info->micd_ranges[i].key;
dev_dbg(info->dev, "Key %d down\n", key);
input_report_key(info->input, key, 1);
input_sync(info->input);
break;
}
}
if (i == info->num_micd_ranges)
dev_warn(info->dev,
"Button level %u out of range\n", val);
} else {
dev_info(info->dev, "Mic button released\n");
madera_hs_mic_control(info, MADERA_MIC_UNMUTE);
for (i = 0; i < info->num_micd_ranges; i++)
input_report_key(info->input,
info->micd_ranges[i].key, 0);
input_sync(info->input);
}
return 0;
}
int madera_micd_button_reading(struct madera_extcon *info, int val)
{
int ret;
unsigned int ohms;
if (val < 0)
return val;
ohms = madera_hohm_to_ohm((unsigned int)val);
ret = madera_micd_button_debounce(info, ohms);
if (ret < 0)
return ret;
return madera_micd_button_process(info, ohms);
}
EXPORT_SYMBOL_GPL(madera_micd_button_reading);
int madera_micd_mic_start(struct madera_extcon *info)
{
int ret;
info->detecting = true;
ret = regulator_allow_bypass(info->micvdd, false);
if (ret)
dev_err(info->dev, "Failed to regulate MICVDD: %d\n", ret);
return madera_micd_start(info);
}
EXPORT_SYMBOL_GPL(madera_micd_mic_start);
void madera_micd_mic_stop(struct madera_extcon *info)
{
int ret;
madera_micd_stop(info);
ret = regulator_allow_bypass(info->micvdd, true);
if (ret)
dev_err(info->dev, "Failed to bypass MICVDD: %d\n", ret);
info->detecting = false;
}
EXPORT_SYMBOL_GPL(madera_micd_mic_stop);
int madera_micd_mic_reading(struct madera_extcon *info, int val)
{
unsigned int ohms;
if (val < 0)
return val;
ohms = madera_hohm_to_ohm((unsigned int)val);
/* Due to jack detect this should never happen */
if (ohms > MADERA_MICROPHONE_MAX_OHM) {
dev_warn(info->dev, "Detected open circuit\n");
info->have_mic = info->pdata->micd_open_circuit_declare;
goto done;
}
/* If we got a high impedence we should have a headset, report it. */
if (ohms >= MADERA_MICROPHONE_MIN_OHM) {
dev_dbg(info->dev, "Detected headset\n");
info->have_mic = true;
goto done;
}
/*
* If we detected a lower impedence during initial startup
* then we probably have the wrong polarity, flip it. Don't
* do this for the lowest impedences to speed up detection of
* plain headphones. If both polarities report a low
* impedence then give up and report headphones.
*/
if (ohms > info->micd_ranges[0].max &&
info->num_micd_modes > 1) {
if (info->jack_flips >= info->num_micd_modes * 10) {
dev_dbg(info->dev, "Detected HP/line\n");
goto done;
} else {
madera_extcon_next_mode(info);
info->jack_flips++;
return -EAGAIN;
}
}
/*
* If we're still detecting and we detect a short then we've
* got a headphone.
*/
dev_dbg(info->dev, "Headphone detected\n");
done:
pm_runtime_mark_last_busy(info->dev);
if (info->pdata->hpdet_channel)
madera_jds_set_state(info, &madera_hpdet_right);
else
madera_jds_set_state(info, &madera_hpdet_left);
madera_extcon_notify_micd(info, info->have_mic, ohms);
return 0;
}
EXPORT_SYMBOL_GPL(madera_micd_mic_reading);
int madera_micd_mic_timeout_ms(struct madera_extcon *info)
{
if (info->pdata->micd_timeout_ms)
return info->pdata->micd_timeout_ms;
else
return MADERA_DEFAULT_MICD_TIMEOUT_MS;
}
EXPORT_SYMBOL_GPL(madera_micd_mic_timeout_ms);
void madera_micd_mic_timeout(struct madera_extcon *info)
{
int ret;
dev_dbg(info->dev, "MICD timed out, reporting HP\n");
if (info->pdata->hpdet_channel)
ret = madera_jds_set_state(info, &madera_hpdet_right);
else
ret = madera_jds_set_state(info, &madera_hpdet_left);
if (ret < 0)
madera_extcon_report(info, EXTCON_JACK_MICROPHONE, false);
}
EXPORT_SYMBOL_GPL(madera_micd_mic_timeout);
static int madera_jack_present(struct madera_extcon *info,
unsigned int *jack_val)
{
struct madera *madera = info->madera;
unsigned int present, val;
int ret;
ret = regmap_read(madera->regmap, MADERA_IRQ1_RAW_STATUS_7, &val);
if (ret) {
dev_err(info->dev, "Failed to read jackdet status: %d\n", ret);
return ret;
}
dev_dbg(info->dev, "IRQ1_RAW_STATUS_7=0x%x\n", val);
if (info->pdata->jd_use_jd2) {
val &= MADERA_MICD_CLAMP_RISE_STS1;
present = 0;
} else if (info->pdata->jd_invert) {
val &= MADERA_JD1_FALL_STS1_MASK;
present = MADERA_JD1_FALL_STS1;
} else {
val &= MADERA_JD1_RISE_STS1_MASK;
present = MADERA_JD1_RISE_STS1;
}
dev_dbg(info->dev, "jackdet val=0x%x present=0x%x\n", val, present);
if (jack_val)
*jack_val = val;
if (val == present)
return 1;
else
return 0;
}
static irqreturn_t madera_hpdet_handler(int irq, void *data)
{
struct madera_extcon *info = data;
int ret;
dev_info(info->dev, "HPDET handler\n");
madera_jds_cancel_timeout(info);
mutex_lock(&info->lock);
switch (madera_jds_get_mode(info)) {
case MADERA_ACCDET_MODE_HPL:
case MADERA_ACCDET_MODE_HPR:
case MADERA_ACCDET_MODE_HPM:
/* Fall through to spurious if no jack present */
if (madera_jack_present(info, NULL) > 0)
break;
default:
dev_info(info->dev, "HPDET Status: %u\n",
madera_jds_get_mode(info));
madera_jds_start_timeout(info);
mutex_unlock(&info->lock);
return IRQ_NONE;
}
ret = madera_hpdet_read(info);
if (ret == -EAGAIN) {
dev_info(info->dev, "Repeat HPDET\n");
goto out;
}
madera_jds_reading(info, ret);
out:
madera_jds_start_timeout(info);
pm_runtime_mark_last_busy(info->dev);
mutex_unlock(&info->lock);
return IRQ_HANDLED;
}
static void madera_micd_handler(struct work_struct *work)
{
struct madera_extcon *info = container_of(work,
struct madera_extcon,
micd_detect_work.work);
enum madera_accdet_mode mode;
int ret;
dev_info(info->dev, "MICDET IRQ\n");
madera_jds_cancel_timeout(info);
mutex_lock(&info->lock);
/*
* Must check that we are in a micd state before accessing
* any codec registers
*/
mode = madera_jds_get_mode(info);
switch (mode) {
case MADERA_ACCDET_MODE_MIC:
case MADERA_ACCDET_MODE_ADC:
break;
default:
goto spurious;
}
if (madera_jack_present(info, NULL) <= 0)
goto spurious;
switch (mode) {
case MADERA_ACCDET_MODE_MIC:
ret = madera_micd_read(info);
break;
case MADERA_ACCDET_MODE_ADC:
ret = madera_micd_adc_read(info);
break;
default: /* we can't get here but compiler still warns */
ret = 0;
break;
}
if (ret == -EAGAIN) {
dev_info(info->dev, "Repeat MICDET\n");
goto out;
}
if (ret >= 0) {
dev_dbg(info->dev, "Mic impedance %d ohms\n", ret);
ret = madera_ohm_to_hohm((unsigned int)ret);
}
madera_jds_reading(info, ret);
out:
madera_jds_start_timeout(info);
pm_runtime_mark_last_busy(info->dev);
mutex_unlock(&info->lock);
return;
spurious:
dev_warn(info->dev, "Spurious MICDET IRQ\n");
madera_jds_start_timeout(info);
mutex_unlock(&info->lock);
}
static irqreturn_t madera_micdet(int irq, void *data)
{
struct madera_extcon *info = data;
int debounce = info->pdata->micd_detect_debounce_ms;
dev_dbg(info->dev, "micdet IRQ");
cancel_delayed_work_sync(&info->micd_detect_work);
mutex_lock(&info->lock);
if (!info->detecting)
debounce = 0;
mutex_unlock(&info->lock);
/*
* Defer to the workqueue to ensure serialization
* and prevent race conditions if an IRQ occurs while
* running the delayed work
*/
schedule_delayed_work(&info->micd_detect_work,
msecs_to_jiffies(debounce));
return IRQ_HANDLED;
}
const struct madera_jd_state madera_hpdet_left = {
.mode = MADERA_ACCDET_MODE_HPL,
.start = madera_hpdet_start,
.reading = madera_hpdet_reading,
.stop = madera_hpdet_stop,
};
EXPORT_SYMBOL_GPL(madera_hpdet_left);
const struct madera_jd_state madera_hpdet_right = {
.mode = MADERA_ACCDET_MODE_HPR,
.start = madera_hpdet_start,
.reading = madera_hpdet_reading,
.stop = madera_hpdet_stop,
};
EXPORT_SYMBOL_GPL(madera_hpdet_right);
const struct madera_jd_state madera_hpdet_moisture = {
.mode = MADERA_ACCDET_MODE_HPL, /* Just a dummy, set by moisture-pin */
.start = madera_hpdet_moisture_start,
.restart = madera_hpdet_restart,
.reading = madera_hpdet_moisture_reading,
.stop = madera_hpdet_moisture_stop,
};
EXPORT_SYMBOL_GPL(madera_hpdet_moisture);
const struct madera_jd_state madera_micd_button = {
.mode = MADERA_ACCDET_MODE_MIC,
.start = madera_micd_button_start,
.reading = madera_micd_button_reading,
.stop = madera_micd_stop,
};
EXPORT_SYMBOL_GPL(madera_micd_button);
const struct madera_jd_state madera_micd_adc_mic = {
.mode = MADERA_ACCDET_MODE_ADC,
.start = madera_micd_mic_start,
.restart = madera_micd_restart,
.reading = madera_micd_mic_reading,
.stop = madera_micd_mic_stop,
.timeout_ms = madera_micd_mic_timeout_ms,
.timeout = madera_micd_mic_timeout,
};
EXPORT_SYMBOL_GPL(madera_micd_adc_mic);
const struct madera_jd_state madera_micd_microphone = {
.mode = MADERA_ACCDET_MODE_MIC,
.start = madera_micd_mic_start,
.reading = madera_micd_mic_reading,
.stop = madera_micd_mic_stop,
.timeout_ms = madera_micd_mic_timeout_ms,
.timeout = madera_micd_mic_timeout,
};
EXPORT_SYMBOL_GPL(madera_micd_microphone);
static irqreturn_t madera_jackdet(int irq, void *data)
{
struct madera_extcon *info = data;
struct madera *madera = info->madera;
unsigned int val, mask;
bool cancelled_state;
int i, present;
dev_info(info->dev, "jackdet IRQ");
cancelled_state = madera_jds_cancel_timeout(info);
pm_runtime_get_sync(info->dev);
mutex_lock(&info->lock);
val = 0;
present = madera_jack_present(info, &val);
if (present < 0) {
dev_err(info->dev, "Failed to check jack status: %d\n",
present);
mutex_unlock(&info->lock);
pm_runtime_put_autosuspend(info->dev);
return IRQ_NONE;
}
if (val == info->last_jackdet) {
dev_dbg(info->dev, "Suppressing duplicate JACKDET\n");
if (cancelled_state)
madera_jds_start_timeout(info);
goto out;
}
info->last_jackdet = val;
mask = MADERA_MICD_CLAMP_DB | MADERA_JD1_DB;
if (info->pdata->jd_use_jd2)
mask |= MADERA_JD2_DB;
if (present) {
dev_dbg(info->dev, "Detected jack\n");
if (info->pdata->jd_wake_time)
__pm_wakeup_event(&info->detection_wake_lock,
info->pdata->jd_wake_time);
/*
* if we're doing moisture detect delay reporting an insert
* until we've decided that it's real
*/
if (!info->pdata->moisture_imp)
madera_extcon_report(info, EXTCON_MECHANICAL, true);
info->have_mic = false;
info->jack_flips = 0;
if (info->pdata->init_delay)
msleep(info->pdata->init_delay);
if (info->pdata->custom_jd)
madera_jds_set_state(info, info->pdata->custom_jd);
else if (info->pdata->moisture_imp)
madera_jds_set_state(info, &madera_hpdet_moisture);
else if (info->pdata->micd_software_compare)
madera_jds_set_state(info, &madera_micd_adc_mic);
else
madera_jds_set_state(info, &madera_micd_microphone);
madera_jds_start_timeout(info);
regmap_update_bits(madera->regmap, MADERA_INTERRUPT_DEBOUNCE_7,
mask, 0);
} else {
dev_dbg(info->dev, "Detected jack removal\n");
info->have_mic = false;
info->micd_res_old = 0;
info->micd_debounce = 0;
info->micd_count = 0;
info->moisture_count = 0;
madera_jds_set_state(info, NULL);
for (i = 0; i < info->num_micd_ranges; i++)
input_report_key(info->input,
info->micd_ranges[i].key, 0);
input_sync(info->input);
for (i = 0; i < ARRAY_SIZE(madera_cable) - 1; i++)
madera_extcon_report(info, madera_cable[i], false);
regmap_update_bits(madera->regmap, MADERA_INTERRUPT_DEBOUNCE_7,
mask, mask);
madera_set_headphone_imp(info, MADERA_HP_Z_OPEN);
madera_extcon_notify_micd(info, false, 0);
}
out:
mutex_unlock(&info->lock);
pm_runtime_mark_last_busy(info->dev);
pm_runtime_put_autosuspend(info->dev);
return IRQ_HANDLED;
}
/* Map a level onto a slot in the register bank */
static void madera_micd_set_level(struct madera *madera, int index,
unsigned int level)
{
int reg;
unsigned int mask;
reg = MADERA_MIC_DETECT_1_LEVEL_4 - (index / 2);
if (!(index % 2)) {
mask = 0x3f00;
level <<= 8;
} else {
mask = 0x3f;
}
/* Program the level itself */
regmap_update_bits(madera->regmap, reg, mask, level);
}
static void madera_extcon_of_get_micd_ranges(struct madera_extcon *info,
struct fwnode_handle *node,
struct madera_accdet_pdata *pdata)
{
struct madera_micd_range *micd_ranges;
u32 *values;
int nvalues, nranges, i, j;
int ret;
nvalues = fwnode_property_read_u32_array(node, "cirrus,micd-ranges",
NULL, 0);
if (nvalues < 0)
return;
values = kmalloc_array(nvalues, sizeof(u32), GFP_KERNEL);
if (!values)
return;
ret = fwnode_property_read_u32_array(node, "cirrus,micd-ranges",
values, nvalues);
if (ret < 0)
goto err;
nranges = nvalues / 2;
micd_ranges = devm_kcalloc(info->dev,
nranges,
sizeof(struct madera_micd_range),
GFP_KERNEL);
for (i = 0, j = 0; i < nranges; ++i) {
micd_ranges[i].max = values[j++];
micd_ranges[i].key = values[j++];
}
pdata->micd_ranges = micd_ranges;
pdata->num_micd_ranges = nranges;
err:
kfree(values);
}
static void madera_extcon_get_micd_configs(struct madera_extcon *info,
struct fwnode_handle *node)
{
struct madera_micd_config *micd_configs;
u32 *values;
int nvalues, nconfigs, i, j;
int ret;
nvalues = fwnode_property_read_u32_array(node,
"cirrus,micd-configs",
NULL, 0);
if (nvalues == -EINVAL) {
return; /* not found */
} else if ((nvalues < 0) || (nvalues % 5)) {
dev_warn(info->dev, "cirrus,micd-configs is malformed\n");
return;
}
values = kmalloc_array(nvalues, sizeof(u32), GFP_KERNEL);
if (!values)
return;
ret = fwnode_property_read_u32_array(node,
"cirrus,micd-configs",
values, nvalues);
if (ret < 0)
goto err;
nconfigs = nvalues / 5;
micd_configs = devm_kcalloc(info->dev,
nconfigs,
sizeof(struct madera_micd_config),
GFP_KERNEL);
if (!micd_configs)
goto err;
for (i = 0, j = 0; i < nconfigs; ++i) {
micd_configs[i].src = values[j++];
micd_configs[i].gnd = values[j++];
micd_configs[i].bias = values[j++];
micd_configs[i].gpio = values[j++];
micd_configs[i].hp_gnd = values[j++];
}
info->micd_modes = micd_configs;
info->num_micd_modes = nconfigs;
err:
kfree(values);
}
static void madera_extcon_get_hpd_pins(struct madera_extcon *info,
struct fwnode_handle *node,
struct madera_accdet_pdata *pdata)
{
int i, ret;
BUILD_BUG_ON(ARRAY_SIZE(pdata->hpd_pins) !=
ARRAY_SIZE(madera_default_hpd_pins));
memcpy(pdata->hpd_pins, madera_default_hpd_pins,
sizeof(pdata->hpd_pins));
ret = fwnode_property_read_u32_array(node,
"cirrus,hpd-pins",
pdata->hpd_pins,
ARRAY_SIZE(pdata->hpd_pins));
if (ret) {
if (ret != -EINVAL)
dev_warn(info->dev,
"Malformed cirrus,hpd-pins: %d\n", ret);
return;
}
/* supply defaults where requested */
for (i = 0; i < ARRAY_SIZE(pdata->hpd_pins); ++i)
if (pdata->hpd_pins[i] > 0xFFFF)
pdata->hpd_pins[i] = madera_default_hpd_pins[i];
}
static void madera_extcon_process_accdet_node(struct madera_extcon *info,
struct fwnode_handle *node)
{
struct madera *madera = info->madera;
struct madera_accdet_pdata *pdata;
u32 out_num;
int i, ret;
enum gpiod_flags gpio_status;
ret = fwnode_property_read_u32(node, "reg", &out_num);
if (ret < 0) {
dev_warn(info->dev,
"failed to read reg property (%d)\n",
ret);
return;
}
if (out_num == 0) {
dev_warn(info->dev, "accdet node illegal reg %u\n", out_num);
return;
}
dev_dbg(info->dev, "processing accdet reg=%u\n", out_num);
for (i = 0; i < ARRAY_SIZE(madera->pdata.accdet); i++)
if (!madera->pdata.accdet[i].enabled)
break;
if (i == ARRAY_SIZE(madera->pdata.accdet)) {
dev_warn(madera->dev, "Too many accdet nodes: %d\n", i + 1);
return;
}
pdata = &madera->pdata.accdet[i];
pdata->enabled = true; /* implied by presence of properties node */
pdata->output = out_num;
fwnode_property_read_u32(node, "cirrus,micd-detect-debounce-ms",
&pdata->micd_detect_debounce_ms);
fwnode_property_read_u32(node, "cirrus,micd-manual-debounce",
&pdata->micd_manual_debounce);
fwnode_property_read_u32(node, "cirrus,micd-bias-start-time",
&pdata->micd_bias_start_time);
fwnode_property_read_u32(node, "cirrus,micd-rate",
&pdata->micd_rate);
fwnode_property_read_u32(node, "cirrus,micd-dbtime",
&pdata->micd_dbtime);
fwnode_property_read_u32(node, "cirrus,micd-timeout-ms",
&pdata->micd_timeout_ms);
/* don't override any preset force_micbias enable */
if (fwnode_property_present(node, "cirrus,micd-force-micbias"))
pdata->micd_force_micbias = true;
pdata->micd_software_compare =
fwnode_property_present(node,
"cirrus,micd-software-compare");
pdata->micd_open_circuit_declare =
fwnode_property_present(node,
"cirrus,micd-open-circuit-declare");
pdata->jd_use_jd2 = fwnode_property_present(node,
"cirrus,jd-use-jd2");
pdata->jd_invert = fwnode_property_present(node,
"cirrus,jd-invert");
fwnode_property_read_u32(node, "cirrus,fixed-hpdet-imp",
&pdata->fixed_hpdet_imp_x100);
fwnode_property_read_u32(node, "cirrus,hpdet-short-circuit-imp",
&pdata->hpdet_short_circuit_imp);
fwnode_property_read_u32(node, "cirrus,hpdet-channel",
&pdata->hpdet_channel);
fwnode_property_read_u32(node, "cirrus,jd-wake-time",
&pdata->jd_wake_time);
fwnode_property_read_u32(node, "cirrus,micd-clamp-mode",
&pdata->micd_clamp_mode);
fwnode_property_read_u32(node, "cirrus,hpdet-ext-res",
&pdata->hpdet_ext_res_x100);
madera_extcon_get_hpd_pins(info, node, pdata);
madera_extcon_get_micd_configs(info, node);
madera_extcon_of_get_micd_ranges(info, node, pdata);
if (info->micd_modes[0].gpio)
gpio_status = GPIOD_OUT_HIGH;
else
gpio_status = GPIOD_OUT_LOW;
info->micd_pol_gpio = devm_fwnode_get_gpiod_from_child(info->dev,
"cirrus,micd-pol",
node,
gpio_status,
"cirrus,micd-pol");
if (IS_ERR(info->micd_pol_gpio)) {
if (PTR_ERR(info->micd_pol_gpio) != -ENOENT)
dev_warn(info->dev,
"Malformed cirrus,micd-pol-gpios ignored: %ld\n",
PTR_ERR(info->micd_pol_gpio));
info->micd_pol_gpio = NULL;
}
fwnode_property_read_u32(node, "cirrus,init-delay-ms",
&pdata->init_delay);
fwnode_property_read_u32(node, "cirrus,hs-mic", &pdata->hs_mic);
if (pdata->hs_mic > MADERA_MAX_INPUT)
pdata->hs_mic = 0;
/* Set sensible default for moisture-pin */
switch (madera->type) {
case CS47L35:
case CS47L85:
case WM1840:
break;
default:
pdata->moisture_pin = MADERA_HPD_SENSE_JD2;
break;
}
fwnode_property_read_u32(node, "cirrus,moisture-pin",
&pdata->moisture_pin);
fwnode_property_read_u32(node, "cirrus,moisture-imp",
&pdata->moisture_imp);
fwnode_property_read_u32(node, "cirrus,moisture-debounce",
&pdata->moisture_debounce);
}
static int madera_extcon_get_device_pdata(struct madera_extcon *info)
{
struct device_node *parent, *child;
struct madera *madera = info->madera;
/*
* a GPSW is not necessarily exclusive to a single accessory detect
* channel so is not in the subnodes
*/
device_property_read_u32_array(info->madera->dev, "cirrus,gpsw",
info->madera->pdata.gpsw,
ARRAY_SIZE(info->madera->pdata.gpsw));
parent = of_get_child_by_name(madera->dev->of_node, "cirrus,accdet");
if (!parent) {
dev_dbg(madera->dev, "No DT nodes\n");
return 0;
}
for_each_child_of_node(parent, child)
madera_extcon_process_accdet_node(info, &child->fwnode);
of_node_put(parent);
return 0;
}
#ifdef DEBUG
#define MADERA_EXTCON_PDATA_DUMP(x, f) \
dev_dbg(info->dev, "\t" #x ": " f "\n", pdata->x)
static void madera_extcon_dump_config(struct madera_extcon *info)
{
const struct madera_accdet_pdata *pdata;
int i, j;
dev_dbg(info->dev, "extcon pdata gpsw=[0x%x 0x%x]\n",
info->madera->pdata.gpsw[0], info->madera->pdata.gpsw[1]);
for (i = 0; i < ARRAY_SIZE(info->madera->pdata.accdet); ++i) {
pdata = &info->madera->pdata.accdet[i];
dev_dbg(info->dev, "extcon pdata OUT%u\n", pdata->output);
MADERA_EXTCON_PDATA_DUMP(enabled, "%u");
MADERA_EXTCON_PDATA_DUMP(jd_wake_time, "%d");
MADERA_EXTCON_PDATA_DUMP(jd_use_jd2, "%u");
MADERA_EXTCON_PDATA_DUMP(jd_invert, "%u");
MADERA_EXTCON_PDATA_DUMP(fixed_hpdet_imp_x100, "%d");
MADERA_EXTCON_PDATA_DUMP(hpdet_ext_res_x100, "%d");
MADERA_EXTCON_PDATA_DUMP(hpdet_short_circuit_imp, "%d");
MADERA_EXTCON_PDATA_DUMP(hpdet_channel, "%d");
MADERA_EXTCON_PDATA_DUMP(micd_detect_debounce_ms, "%d");
MADERA_EXTCON_PDATA_DUMP(hpdet_short_circuit_imp, "%d");
MADERA_EXTCON_PDATA_DUMP(hpdet_channel, "%d");
MADERA_EXTCON_PDATA_DUMP(micd_detect_debounce_ms, "%d");
MADERA_EXTCON_PDATA_DUMP(micd_manual_debounce, "%d");
MADERA_EXTCON_PDATA_DUMP(micd_bias_start_time, "%d");
MADERA_EXTCON_PDATA_DUMP(micd_rate, "%d");
MADERA_EXTCON_PDATA_DUMP(micd_dbtime, "%d");
MADERA_EXTCON_PDATA_DUMP(micd_timeout_ms, "%d");
MADERA_EXTCON_PDATA_DUMP(micd_clamp_mode, "%u");
MADERA_EXTCON_PDATA_DUMP(micd_force_micbias, "%u");
MADERA_EXTCON_PDATA_DUMP(micd_open_circuit_declare, "%u");
MADERA_EXTCON_PDATA_DUMP(micd_software_compare, "%u");
if (info->micd_pol_gpio)
dev_dbg(info->dev, "micd_pol_gpio: %d\n",
desc_to_gpio(info->micd_pol_gpio));
else
dev_dbg(info->dev, "micd_pol_gpio: unused\n");
dev_dbg(info->dev, "\tmicd_ranges {\n");
for (j = 0; j < info->num_micd_ranges; ++j)
dev_dbg(info->dev, "\t\tmax: %d key: %d\n",
info->micd_ranges[j].max,
info->micd_ranges[j].key);
dev_dbg(info->dev, "\t}\n");
dev_dbg(info->dev, "\tmicd_configs {\n");
for (j = 0; j < info->num_micd_modes; ++j)
dev_dbg(info->dev,
"\t\tsrc: 0x%x gnd: 0x%x bias: %u gpio: %u hp_gnd: %d\n",
info->micd_modes[j].src,
info->micd_modes[j].gnd,
info->micd_modes[j].bias,
info->micd_modes[j].gpio,
info->micd_modes[j].hp_gnd);
dev_dbg(info->dev, "\t}\n");
dev_dbg(info->dev, "\thpd_pins: %u %u %u %u\n",
pdata->hpd_pins[0], pdata->hpd_pins[1],
pdata->hpd_pins[2], pdata->hpd_pins[3]);
}
}
#else
static inline void madera_extcon_dump_config(struct madera_extcon *info)
{
}
#endif
/* See datasheet for a description of this calibration data */
static int madera_extcon_read_calibration(struct madera_extcon *info)
{
struct madera *madera = info->madera;
struct madera_hpdet_trims *trims;
int ret = -EIO;
unsigned int offset, gradient, interim_val;
unsigned int otp_hpdet_calib_1, otp_hpdet_calib_2;
switch (madera->type) {
case CS47L35:
otp_hpdet_calib_1 = CS47L35_OTP_HPDET_CAL_1;
otp_hpdet_calib_2 = CS47L35_OTP_HPDET_CAL_2;
break;
case CS47L85:
case WM1840:
otp_hpdet_calib_1 = CS47L85_OTP_HPDET_CAL_1;
otp_hpdet_calib_2 = CS47L85_OTP_HPDET_CAL_2;
break;
default:
otp_hpdet_calib_1 = MADERA_OTP_HPDET_CAL_1;
otp_hpdet_calib_2 = MADERA_OTP_HPDET_CAL_2;
break;
}
ret = regmap_read(madera->regmap_32bit, otp_hpdet_calib_1, &offset);
if (ret) {
dev_err(info->dev,
"Failed to read HP CALIB OFFSET value: %d\n", ret);
return ret;
}
ret = regmap_read(madera->regmap_32bit, otp_hpdet_calib_2, &gradient);
if (ret) {
dev_err(info->dev,
"Failed to read HP CALIB OFFSET value: %d\n", ret);
return ret;
}
if (((offset == 0) && (gradient == 0)) ||
((offset == 0xFFFFFFFF) && (gradient == 0xFFFFFFFF))) {
dev_warn(info->dev, "No HP trims\n");
return 0;
}
trims = devm_kcalloc(info->dev, 4,
sizeof(struct madera_hpdet_trims),
GFP_KERNEL);
if (!trims) {
dev_err(info->dev, "Failed to alloc hpdet trims\n");
return -ENOMEM;
}
interim_val = (offset & MADERA_OTP_HPDET_CALIB_OFFSET_00_MASK) >>
MADERA_OTP_HPDET_CALIB_OFFSET_00_SHIFT;
trims[0].off_x4 = 128 - interim_val;
interim_val = (gradient & MADERA_OTP_HPDET_GRADIENT_0X_MASK) >>
MADERA_OTP_HPDET_GRADIENT_0X_SHIFT;
trims[0].grad_x4 = 128 - interim_val;
interim_val = (offset & MADERA_OTP_HPDET_CALIB_OFFSET_01_MASK) >>
MADERA_OTP_HPDET_CALIB_OFFSET_01_SHIFT;
trims[1].off_x4 = 128 - interim_val;
trims[1].grad_x4 = trims[0].grad_x4;
interim_val = (offset & MADERA_OTP_HPDET_CALIB_OFFSET_10_MASK) >>
MADERA_OTP_HPDET_CALIB_OFFSET_10_SHIFT;
trims[2].off_x4 = 128 - interim_val;
interim_val = (gradient & MADERA_OTP_HPDET_GRADIENT_1X_MASK) >>
MADERA_OTP_HPDET_GRADIENT_1X_SHIFT;
trims[2].grad_x4 = 128 - interim_val;
interim_val = (offset & MADERA_OTP_HPDET_CALIB_OFFSET_11_MASK) >>
MADERA_OTP_HPDET_CALIB_OFFSET_11_SHIFT;
trims[3].off_x4 = 128 - interim_val;
trims[3].grad_x4 = trims[2].grad_x4;
info->hpdet_trims = trims;
dev_dbg(info->dev,
"trims_x_4: %u,%u %u,%u %u,%u %u,%u\n",
trims[0].off_x4, trims[0].grad_x4,
trims[1].off_x4, trims[1].grad_x4,
trims[2].off_x4, trims[2].grad_x4,
trims[3].off_x4, trims[3].grad_x4);
return 0;
}
static void madera_extcon_set_micd_clamp_mode(struct madera_extcon *info)
{
unsigned int clamp_ctrl_val;
/*
* If the user has supplied a micd_clamp_mode, assume they know
* what they are doing and just write it out
*/
if (info->pdata->micd_clamp_mode) {
clamp_ctrl_val = info->pdata->micd_clamp_mode;
} else if (info->pdata->jd_use_jd2) {
if (info->pdata->jd_invert)
clamp_ctrl_val = MADERA_MICD_CLAMP_MODE_JD1H_JD2H;
else
clamp_ctrl_val = MADERA_MICD_CLAMP_MODE_JD1L_JD2L;
} else {
if (info->pdata->jd_invert)
clamp_ctrl_val = MADERA_MICD_CLAMP_MODE_JD1H;
else
clamp_ctrl_val = MADERA_MICD_CLAMP_MODE_JD1L;
}
regmap_update_bits(info->madera->regmap,
MADERA_MICD_CLAMP_CONTROL,
MADERA_MICD_CLAMP_MODE_MASK,
clamp_ctrl_val);
regmap_update_bits(info->madera->regmap,
MADERA_INTERRUPT_DEBOUNCE_7,
MADERA_MICD_CLAMP_DB,
MADERA_MICD_CLAMP_DB);
}
static int madera_extcon_add_micd_levels(struct madera_extcon *info)
{
struct madera *madera = info->madera;
int i, j;
int ret = 0;
BUILD_BUG_ON(ARRAY_SIZE(madera_micd_levels) <
MADERA_NUM_MICD_BUTTON_LEVELS);
/* Disable all buttons by default */
regmap_update_bits(madera->regmap, MADERA_MIC_DETECT_1_CONTROL_2,
MADERA_MICD_LVL_SEL_MASK, 0x81);
/* Set up all the buttons the user specified */
for (i = 0; i < info->num_micd_ranges; i++) {
for (j = 0; j < MADERA_NUM_MICD_BUTTON_LEVELS; j++)
if (madera_micd_levels[j] >= info->micd_ranges[i].max)
break;
if (j == MADERA_NUM_MICD_BUTTON_LEVELS) {
dev_err(info->dev, "Unsupported MICD level %d\n",
info->micd_ranges[i].max);
ret = -EINVAL;
goto err_input;
}
dev_dbg(info->dev, "%d ohms for MICD threshold %d\n",
madera_micd_levels[j], i);
madera_micd_set_level(madera, i, j);
if (info->micd_ranges[i].key > 0)
input_set_capability(info->input, EV_KEY,
info->micd_ranges[i].key);
/* Enable reporting of that range */
regmap_update_bits(madera->regmap,
MADERA_MIC_DETECT_1_CONTROL_2,
1 << i, 1 << i);
}
/* Set all the remaining keys to a maximum */
for (; i < MADERA_MAX_MICD_RANGE; i++)
madera_micd_set_level(madera, i, 0x3f);
err_input:
return ret;
}
static int madera_extcon_init_micd_ranges(struct madera_extcon *info)
{
const struct madera_accdet_pdata *pdata = info->pdata;
struct madera_micd_range *ranges;
int i;
if (pdata->num_micd_ranges == 0) {
info->micd_ranges = madera_micd_default_ranges;
info->num_micd_ranges =
ARRAY_SIZE(madera_micd_default_ranges);
return 0;
}
if (pdata->num_micd_ranges > MADERA_MAX_MICD_RANGE) {
dev_err(info->dev, "Too many MICD ranges: %d\n",
pdata->num_micd_ranges);
return -EINVAL;
}
ranges = devm_kmalloc_array(info->dev,
pdata->num_micd_ranges,
sizeof(struct madera_micd_range),
GFP_KERNEL);
if (!ranges) {
dev_err(info->dev, "Failed to kalloc micd ranges\n");
return -ENOMEM;
}
memcpy(ranges, pdata->micd_ranges,
sizeof(struct madera_micd_range) * pdata->num_micd_ranges);
info->micd_ranges = ranges;
info->num_micd_ranges = pdata->num_micd_ranges;
for (i = 0; i < info->num_micd_ranges - 1; i++) {
if (info->micd_ranges[i].max > info->micd_ranges[i + 1].max) {
dev_err(info->dev, "MICD ranges must be sorted\n");
goto err_free;
}
}
return 0;
err_free:
devm_kfree(info->dev, ranges);
return -EINVAL;
}
static void madera_extcon_xlate_pdata(struct madera_accdet_pdata *pdata)
{
int i;
BUILD_BUG_ON(ARRAY_SIZE(pdata->hpd_pins) !=
ARRAY_SIZE(madera_default_hpd_pins));
/* translate from pdata format where 0=default and >0xFFFF means 0 */
for (i = 0; i < ARRAY_SIZE(pdata->hpd_pins); ++i) {
if (pdata->hpd_pins[i] == 0)
pdata->hpd_pins[i] = madera_default_hpd_pins[i];
else if (pdata->hpd_pins[i] > 0xFFFF)
pdata->hpd_pins[i] = 0;
}
}
static int madera_extcon_probe(struct platform_device *pdev)
{
struct madera *madera = dev_get_drvdata(pdev->dev.parent);
struct madera_accdet_pdata *pdata = &madera->pdata.accdet[0];
struct madera_extcon *info;
unsigned int debounce_val, analog_val;
int jack_irq_fall, jack_irq_rise;
int ret, mode, i, hpdet_short_measured;
/* quick exit if Madera irqchip driver hasn't completed probe */
if (!madera->irq_dev) {
dev_dbg(&pdev->dev, "irqchip driver not ready\n");
return -EPROBE_DEFER;
}
if (!madera->dapm || !madera->dapm->card)
return -EPROBE_DEFER;
info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
if (!info)
return -ENOMEM;
info->pdata = pdata;
info->madera = madera;
info->dev = &pdev->dev;
mutex_init(&info->lock);
init_completion(&info->manual_mic_completion);
wakeup_source_init(&info->detection_wake_lock, "madera-jack-detection");
INIT_DELAYED_WORK(&info->micd_detect_work, madera_micd_handler);
INIT_DELAYED_WORK(&info->state_timeout_work, madera_jds_timeout_work);
platform_set_drvdata(pdev, info);
switch (madera->type) {
case CS47L15:
info->hpdet_init_range = 1; /* range 0 not used on CS47L15 */
info->hpdet_ranges = cs47l15_hpdet_ranges;
info->num_hpdet_ranges = ARRAY_SIZE(cs47l15_hpdet_ranges);
info->micd_modes = madera_micd_default_modes;
info->num_micd_modes = ARRAY_SIZE(madera_micd_default_modes);
break;
case CS47L35:
pdata->micd_force_micbias = true;
info->hpdet_ranges = cs47l85_hpdet_ranges;
info->num_hpdet_ranges = ARRAY_SIZE(cs47l85_hpdet_ranges);
info->micd_modes = cs47l85_micd_default_modes;
info->num_micd_modes = ARRAY_SIZE(cs47l85_micd_default_modes);
break;
case CS47L85:
case WM1840:
info->hpdet_ranges = cs47l85_hpdet_ranges;
info->num_hpdet_ranges = ARRAY_SIZE(cs47l85_hpdet_ranges);
info->micd_modes = cs47l85_micd_default_modes;
info->num_micd_modes = ARRAY_SIZE(cs47l85_micd_default_modes);
break;
case CS47L92:
case CS47L93:
info->hpdet_ranges = cs47l92_hpdet_ranges;
info->num_hpdet_ranges = ARRAY_SIZE(cs47l92_hpdet_ranges);
info->micd_modes = madera_micd_default_modes;
info->num_micd_modes = ARRAY_SIZE(madera_micd_default_modes);
break;
default:
info->hpdet_ranges = madera_hpdet_ranges;
info->num_hpdet_ranges = ARRAY_SIZE(madera_hpdet_ranges);
info->micd_modes = madera_micd_default_modes;
info->num_micd_modes = ARRAY_SIZE(madera_micd_default_modes);
break;
}
if (dev_get_platdata(madera->dev)) {
madera_extcon_xlate_pdata(pdata);
if (pdata->num_micd_configs) {
info->micd_modes = pdata->micd_configs;
info->num_micd_modes = pdata->num_micd_configs;
}
if (info->micd_modes[0].gpio)
mode = GPIOF_OUT_INIT_HIGH;
else
mode = GPIOF_OUT_INIT_LOW;
ret = devm_gpio_request_one(&pdev->dev,
pdata->micd_pol_gpio,
mode,
"MICD polarity");
if (ret) {
dev_err(info->dev, "Failed to request GPIO%d: %d\n",
pdata->micd_pol_gpio, ret);
goto err_wakelock;
}
info->micd_pol_gpio = gpio_to_desc(pdata->micd_pol_gpio);
} else {
ret = madera_extcon_get_device_pdata(info);
if (ret < 0)
goto err_wakelock;
}
if (!pdata->enabled || pdata->output == 0) {
ret = -ENODEV; /* no accdet output configured */
goto err_wakelock;
}
info->hpdet_short_x100 =
madera_ohm_to_hohm(pdata->hpdet_short_circuit_imp);
/* Actual measured short is increased by external resistance */
hpdet_short_measured = pdata->hpdet_short_circuit_imp +
madera_hohm_to_ohm(pdata->hpdet_ext_res_x100);
if (hpdet_short_measured < MADERA_HP_SHORT_IMPEDANCE_MIN) {
/*
* increase comparison threshold to minimum we can measure
* taking into account that threshold does not include external
* resistance
*/
info->hpdet_short_x100 =
madera_ohm_to_hohm(MADERA_HP_SHORT_IMPEDANCE_MIN) -
pdata->hpdet_ext_res_x100;
dev_warn(info->dev,
"Increasing HP short circuit impedance from %d to %d\n",
pdata->hpdet_short_circuit_imp,
madera_hohm_to_ohm(info->hpdet_short_x100));
}
info->micvdd = devm_regulator_get(&pdev->dev, "MICVDD");
if (IS_ERR(info->micvdd)) {
ret = PTR_ERR(info->micvdd);
dev_err(info->dev, "Failed to get MICVDD: %d\n", ret);
goto err_wakelock;
}
if (pdata->jd_invert)
info->last_jackdet =
~(MADERA_MICD_CLAMP_RISE_STS1 | MADERA_JD1_FALL_STS1);
else
info->last_jackdet =
~(MADERA_MICD_CLAMP_RISE_STS1 | MADERA_JD1_RISE_STS1);
info->edev = devm_extcon_dev_allocate(&pdev->dev, madera_cable);
if (IS_ERR(info->edev)) {
dev_err(&pdev->dev, "failed to allocate extcon device\n");
ret = -ENOMEM;
goto err_wakelock;
}
ret = devm_extcon_dev_register(&pdev->dev, info->edev);
if (ret < 0) {
dev_err(info->dev, "extcon_dev_register() failed: %d\n", ret);
goto err_wakelock;
}
info->input = devm_input_allocate_device(&pdev->dev);
if (!info->input) {
dev_err(info->dev, "Can't allocate input dev\n");
ret = -ENOMEM;
goto err_register;
}
info->input->name = "Headset";
info->input->phys = "madera/extcon";
info->input->dev.parent = &pdev->dev;
if (madera->pdata.gpsw[0] > 0)
regmap_update_bits(madera->regmap,
MADERA_GP_SWITCH_1,
MADERA_SW1_MODE_MASK,
madera->pdata.gpsw[0] <<
MADERA_SW1_MODE_SHIFT);
switch (madera->type) {
case CS47L90:
case CS47L91:
case CS47L92:
case CS47L93:
if (madera->pdata.gpsw[1] > 0)
regmap_update_bits(madera->regmap,
MADERA_GP_SWITCH_1,
MADERA_SW2_MODE_MASK,
madera->pdata.gpsw[1] <<
MADERA_SW2_MODE_SHIFT);
break;
default:
break;
}
if (info->pdata->micd_bias_start_time)
regmap_update_bits(madera->regmap,
MADERA_MIC_DETECT_1_CONTROL_1,
MADERA_MICD_BIAS_STARTTIME_MASK,
info->pdata->micd_bias_start_time
<< MADERA_MICD_BIAS_STARTTIME_SHIFT);
if (info->pdata->micd_rate)
regmap_update_bits(madera->regmap,
MADERA_MIC_DETECT_1_CONTROL_1,
MADERA_MICD_RATE_MASK,
info->pdata->micd_rate
<< MADERA_MICD_RATE_SHIFT);
if (info->pdata->micd_dbtime)
regmap_update_bits(madera->regmap,
MADERA_MIC_DETECT_1_CONTROL_1,
MADERA_MICD_DBTIME_MASK,
info->pdata->micd_dbtime
<< MADERA_MICD_DBTIME_SHIFT);
ret = madera_extcon_init_micd_ranges(info);
if (ret)
goto err_input;
ret = madera_extcon_add_micd_levels(info);
if (ret)
goto err_input;
madera_extcon_set_micd_clamp_mode(info);
if ((info->num_micd_modes > 2) && !info->micd_pol_gpio)
dev_warn(info->dev, "Have >1 mic_configs but no pol_gpio\n");
madera_extcon_set_mode(info, 0);
/*
* Invalidate the tuning level so that the first detection
* will always apply a tuning
*/
info->hp_tuning_level = MADERA_HP_TUNING_INVALID;
pm_runtime_enable(&pdev->dev);
pm_runtime_idle(&pdev->dev);
pm_runtime_get_sync(&pdev->dev);
madera_extcon_read_calibration(info);
if (info->hpdet_trims) {
switch (madera->type) {
case CS47L35:
case CS47L85:
case WM1840:
/* set for accurate HP impedance detection */
regmap_update_bits(madera->regmap,
MADERA_ACCESSORY_DETECT_MODE_1,
MADERA_ACCDET_POLARITY_INV_ENA_MASK,
1 << MADERA_ACCDET_POLARITY_INV_ENA_SHIFT);
break;
default:
break;
}
} else {
switch (madera->type) {
case CS47L15:
pdata->hpdet_ext_res_x100 += 3300;
break;
default:
break;
}
}
/* Skip any HPDET ranges less than the external resistance */
for (i = info->hpdet_init_range; i < info->num_hpdet_ranges; ++i) {
if (madera_ohm_to_hohm(info->hpdet_ranges[i].max) >=
pdata->hpdet_ext_res_x100) {
info->hpdet_init_range = i;
break;
}
}
if (i == info->num_hpdet_ranges) {
dev_err(&pdev->dev,
"No possible range for external resistance %u.%02u\n",
pdata->hpdet_ext_res_x100 / 100,
pdata->hpdet_ext_res_x100 % 100);
goto err_input;
}
regmap_update_bits(madera->regmap, MADERA_HEADPHONE_DETECT_1,
MADERA_HP_IMPEDANCE_RANGE_MASK,
info->hpdet_init_range <<
MADERA_HP_IMPEDANCE_RANGE_SHIFT);
ret = madera_request_irq(madera, MADERA_IRQ_MICDET1,
"MICDET", madera_micdet, info);
if (ret) {
dev_err(&pdev->dev, "Failed to get MICDET IRQ: %d\n", ret);
goto err_input;
}
ret = madera_request_irq(madera, MADERA_IRQ_HPDET,
"HPDET", madera_hpdet_handler, info);
if (ret) {
dev_err(&pdev->dev, "Failed to get HPDET IRQ: %d\n", ret);
goto err_micdet;
}
if (info->pdata->jd_use_jd2) {
debounce_val = MADERA_JD1_DB | MADERA_JD2_DB;
analog_val = MADERA_JD1_ENA | MADERA_JD2_ENA;
jack_irq_rise = MADERA_IRQ_MICD_CLAMP_RISE;
jack_irq_fall = MADERA_IRQ_MICD_CLAMP_FALL;
} else {
debounce_val = MADERA_JD1_DB;
analog_val = MADERA_JD1_ENA;
jack_irq_rise = MADERA_IRQ_JD1_RISE;
jack_irq_fall = MADERA_IRQ_JD1_FALL;
}
regmap_update_bits(madera->regmap, MADERA_INTERRUPT_DEBOUNCE_7,
debounce_val, debounce_val);
regmap_update_bits(madera->regmap, MADERA_JACK_DETECT_ANALOGUE,
analog_val, analog_val);
ret = madera_request_irq(madera, jack_irq_rise,
"JACKDET rise", madera_jackdet, info);
if (ret) {
dev_err(&pdev->dev,
"Failed to get JACKDET rise IRQ: %d\n", ret);
goto err_hpdet;
}
ret = madera_set_irq_wake(madera, jack_irq_rise, 1);
if (ret) {
dev_err(&pdev->dev,
"Failed to set JD rise IRQ wake: %d\n", ret);
goto err_rise;
}
ret = madera_request_irq(madera, jack_irq_fall,
"JACKDET fall", madera_jackdet, info);
if (ret) {
dev_err(&pdev->dev, "Failed to get JD fall IRQ: %d\n", ret);
goto err_rise_wake;
}
ret = madera_set_irq_wake(madera, jack_irq_fall, 1);
if (ret) {
dev_err(&pdev->dev,
"Failed to set JD fall IRQ wake: %d\n", ret);
goto err_fall;
}
ret = regulator_allow_bypass(info->micvdd, true);
if (ret)
dev_warn(info->dev,
"Failed to set MICVDD to bypass: %d\n", ret);
pm_runtime_put(&pdev->dev);
if (IS_ENABLED(CONFIG_EXTCON_MADERA_INPUT_EVENT)) {
input_set_capability(info->input,
EV_SW,
SW_MICROPHONE_INSERT);
input_set_capability(info->input,
EV_SW,
SW_HEADPHONE_INSERT);
input_set_capability(info->input,
EV_SW,
SW_JACK_PHYSICAL_INSERT);
}
ret = input_register_device(info->input);
if (ret) {
dev_err(&pdev->dev, "Can't register input device: %d\n", ret);
goto err_fall_wake;
}
ret = device_create_file(&pdev->dev, &dev_attr_hp1_impedance);
if (ret)
dev_warn(&pdev->dev,
"Failed to create sysfs node for hp_impedance %d\n",
ret);
madera_extcon_dump_config(info);
ret = device_create_file(&pdev->dev, &dev_attr_mic_impedance);
if (ret)
dev_warn(&pdev->dev,
"Failed to create sysfs node for mic_impedance %d\n",
ret);
madera->extcon_info = info;
return 0;
err_fall_wake:
madera_set_irq_wake(madera, jack_irq_fall, 0);
err_fall:
madera_free_irq(madera, jack_irq_fall, info);
err_rise_wake:
madera_set_irq_wake(madera, jack_irq_rise, 0);
err_rise:
madera_free_irq(madera, jack_irq_rise, info);
err_hpdet:
madera_free_irq(madera, MADERA_IRQ_HPDET, info);
err_micdet:
madera_free_irq(madera, MADERA_IRQ_MICDET1, info);
err_input:
err_register:
pm_runtime_disable(&pdev->dev);
err_wakelock:
wakeup_source_trash(&info->detection_wake_lock);
return ret;
}
static int madera_extcon_remove(struct platform_device *pdev)
{
struct madera_extcon *info = platform_get_drvdata(pdev);
struct madera *madera = info->madera;
int jack_irq_rise, jack_irq_fall;
pm_runtime_disable(&pdev->dev);
madera->extcon_info = NULL;
regmap_update_bits(madera->regmap, MADERA_MICD_CLAMP_CONTROL,
MADERA_MICD_CLAMP_MODE_MASK, 0);
if (info->pdata->jd_use_jd2) {
jack_irq_rise = MADERA_IRQ_MICD_CLAMP_RISE;
jack_irq_fall = MADERA_IRQ_MICD_CLAMP_FALL;
} else {
jack_irq_rise = MADERA_IRQ_JD1_RISE;
jack_irq_fall = MADERA_IRQ_JD1_FALL;
}
madera_set_irq_wake(madera, jack_irq_rise, 0);
madera_set_irq_wake(madera, jack_irq_fall, 0);
madera_free_irq(madera, MADERA_IRQ_HPDET, info);
madera_free_irq(madera, MADERA_IRQ_MICDET1, info);
madera_free_irq(madera, jack_irq_rise, info);
madera_free_irq(madera, jack_irq_fall, info);
regmap_update_bits(madera->regmap, MADERA_JACK_DETECT_ANALOGUE,
MADERA_JD1_ENA | MADERA_JD2_ENA, 0);
device_remove_file(&pdev->dev, &dev_attr_hp1_impedance);
device_remove_file(&pdev->dev, &dev_attr_mic_impedance);
kfree(info->hpdet_trims);
wakeup_source_trash(&info->detection_wake_lock);
return 0;
}
static struct platform_driver madera_extcon_driver = {
.driver = {
.name = "madera-extcon",
.suppress_bind_attrs = true,
},
.probe = madera_extcon_probe,
.remove = madera_extcon_remove,
};
module_platform_driver(madera_extcon_driver);
MODULE_DESCRIPTION("Madera extcon driver");
MODULE_AUTHOR("Charles Keepax <ckeepax@opensource.wolfsonmicro.com>");
MODULE_AUTHOR("Richard Fitzgerald <rf@opensource.wolfsonmicro.com>");
MODULE_LICENSE("GPL v2");
MODULE_ALIAS("platform:extcon-madera");