Something went wrong. Try again.
(I'm so sorry!) Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534// SPDX-License-Identifier: GPL-2.0+
#include <linux/array_size.h>#include <linux/bitmap.h>#include <linux/bits.h>#include <linux/clk.h>#include <linux/delay.h>#include <linux/device.h>#include <linux/devm-helpers.h>#include <linux/err.h>#include <linux/gpio/consumer.h>#include <linux/i2c.h>#include <linux/input.h>#include <linux/kernel.h>#include <linux/module.h>#include <linux/property.h>#include <linux/pwm.h>#include <linux/regmap.h>#include <linux/regulator/consumer.h>#include <linux/units.h>
/* * System control (LDO regulator) * * LDO voltage to register mapping is linear, but it is split in two parts: * 2.3V - 3.0V map to 0x08 - 0x0f; 3.1V - 3.8V map to 0x00 - 0x7 */
#define ISA1200_SCTRL 0x00#define ISA1200_LDO_VOLTAGE_BASE 0x08#define ISA1200_LDO_VOLTAGE_STEP 100000#define ISA1200_LDO_VOLTAGE_2V3 23#define ISA1200_LDO_VOLTAGE_3V1 31#define ISA1200_LDO_VOLTAGE_MIN 2300000#define ISA1200_LDO_VOLTAGE_MAX 3800000
/* * The output frequency is calculated with this formula: * * base clock frequency * fout = ----------------------------------------- * (128 - PWM_FREQ) * 2 * PLLDIV * PWM_PERIOD * * The base clock frequency is the clock frequency provided on the * clock input to the chip, divided by the value in HCTRL0 * * PWM_FREQ is configured in register HCTRL4, it is common to set this * to 0 to get only two variables to calculate. * * PLLDIV is configured in register HCTRL3 (bits 7..4, so 0..15) * PWM_PERIOD is configured in register HCTRL6 * Further the duty cycle can be configured in HCTRL5 */
/* * HCTRL0 configures clock or PWM input and selects the divider for * the clock input. */#define ISA1200_HCTRL0 0x30#define ISA1200_HCTRL0_HAP_ENABLE BIT(7)#define ISA1200_HCTRL0_PWM_GEN_MODE BIT(4)#define ISA1200_HCTRL0_PWM_INPUT_MODE BIT(3)#define ISA1200_HCTRL0_CLKDIV_128 128
/* * HCTRL1 configures the motor type and clock sourse */#define ISA1200_HCTRL1 0x31#define ISA1200_HCTRL1_EXT_CLOCK BIT(7)#define ISA1200_HCTRL1_DAC_INVERT BIT(6)#define ISA1200_HCTRL1_MODE(n) (((n) & 1) << 5)
/* HCTRL2 controls software reset of the chip */#define ISA1200_HCTRL2 0x32#define ISA1200_HCTRL2_SW_RESET BIT(0)
/* * HCTRL3 controls the PLL divisor * * Bits [0,1] are always set to 1 (we don't know what they are * used for) and bit 4 and upward control the PLL divisor. */#define ISA1200_HCTRL3 0x33#define ISA1200_HCTRL3_DEFAULT 0x03#define ISA1200_HCTRL3_PLLDIV(n) (((n) & 0xf) << 4)
/* HCTRL4 controls the PWM frequency of external channel */#define ISA1200_HCTRL4 0x34
/* HCTRL5 controls the PWM high duty cycle of internal channel */#define ISA1200_HCTRL5 0x35
/* HCTRL6 controls the PWM period of internal channel */#define ISA1200_HCTRL6 0x36#define ISA1200_HCTRL6_PERIOD_SCALE 100
/* The use for these registers is unknown but they exist */#define ISA1200_HCTRL7 0x37#define ISA1200_HCTRL8 0x38#define ISA1200_HCTRL9 0x39#define ISA1200_HCTRLA 0x3a#define ISA1200_HCTRLB 0x3b#define ISA1200_HCTRLC 0x3c#define ISA1200_HCTRLD 0x3d
#define ISA1200_EN_PINS_MAX 2
static const struct regulator_bulk_data isa1200_supplies[] = { { .supply = "vdd" }, { .supply = "vddp" },};
struct isa1200_config { u32 ldo_voltage; u32 mode; u32 clkdiv; u32 plldiv; u32 freq; u32 period; u32 duty;};
struct isa1200 { struct input_dev *input; struct regmap *map;
struct clk *clk; struct pwm_device *pwm; struct gpio_descs *enable_gpios; struct regulator_bulk_data *supplies;
struct work_struct play_work; struct isa1200_config config;
int level; bool suspended; bool active;};
static const struct regmap_config isa1200_regmap_config = { .reg_bits = 8, .val_bits = 8, .max_register = ISA1200_HCTRLD,};
static void isa1200_start(struct isa1200 *isa){ struct isa1200_config *config = &isa->config; struct device *dev = &isa->input->dev; struct pwm_state state; u8 hctrl0 = 0, hctrl1 = 0; DECLARE_BITMAP(values, ISA1200_EN_PINS_MAX); int err;
if (!isa->active) { err = regulator_bulk_enable(ARRAY_SIZE(isa1200_supplies), isa->supplies); if (err) { dev_err(dev, "failed to enable supplies (%d)\n", err); return; }
err = clk_prepare_enable(isa->clk); if (err) { dev_err(dev, "failed to enable clock (%d)\n", err); regulator_bulk_disable(ARRAY_SIZE(isa1200_supplies), isa->supplies); return; }
bitmap_fill(values, ISA1200_EN_PINS_MAX); gpiod_multi_set_value_cansleep(isa->enable_gpios, values);
usleep_range(200, 300); }
regmap_write(isa->map, ISA1200_SCTRL, config->ldo_voltage);
if (isa->clk) { hctrl0 = ISA1200_HCTRL0_PWM_GEN_MODE; hctrl1 = ISA1200_HCTRL1_EXT_CLOCK; }
if (isa->pwm) { hctrl0 = ISA1200_HCTRL0_PWM_INPUT_MODE; hctrl1 = 0; }
hctrl0 |= __ffs(config->clkdiv / ISA1200_HCTRL0_CLKDIV_128); hctrl1 |= ISA1200_HCTRL1_DAC_INVERT; hctrl1 |= ISA1200_HCTRL1_MODE(config->mode);
regmap_write(isa->map, ISA1200_HCTRL0, hctrl0); regmap_write(isa->map, ISA1200_HCTRL1, hctrl1);
/* Make sure to de-assert software reset */ regmap_write(isa->map, ISA1200_HCTRL2, 0x00);
/* PLL divisor */ regmap_write(isa->map, ISA1200_HCTRL3, ISA1200_HCTRL3_PLLDIV(config->plldiv) | ISA1200_HCTRL3_DEFAULT);
/* Frequency */ regmap_write(isa->map, ISA1200_HCTRL4, config->freq); /* Duty cycle */ regmap_write(isa->map, ISA1200_HCTRL5, config->period >> 1); /* Period */ regmap_write(isa->map, ISA1200_HCTRL6, config->period);
hctrl0 |= ISA1200_HCTRL0_HAP_ENABLE; regmap_write(isa->map, ISA1200_HCTRL0, hctrl0);
if (isa->clk) regmap_write(isa->map, ISA1200_HCTRL5, config->duty);
if (isa->pwm) { pwm_get_state(isa->pwm, &state); state.duty_cycle = config->duty; state.enabled = true; pwm_apply_might_sleep(isa->pwm, &state); }
isa->active = true;}
static void isa1200_stop(struct isa1200 *isa){ struct pwm_state state; DECLARE_BITMAP(values, ISA1200_EN_PINS_MAX);
if (!isa->active) return;
if (isa->pwm) { pwm_get_state(isa->pwm, &state); state.duty_cycle = 0; state.enabled = false; pwm_apply_might_sleep(isa->pwm, &state); }
regmap_write(isa->map, ISA1200_HCTRL0, 0x00);
bitmap_zero(values, ISA1200_EN_PINS_MAX); gpiod_multi_set_value_cansleep(isa->enable_gpios, values);
clk_disable_unprepare(isa->clk); regulator_bulk_disable(ARRAY_SIZE(isa1200_supplies), isa->supplies);
isa->active = false;}
static void isa1200_play_work(struct work_struct *work){ struct isa1200 *isa = container_of(work, struct isa1200, play_work);
if (!READ_ONCE(isa->suspended)) { if (isa->level) isa1200_start(isa); else isa1200_stop(isa); }}
static int isa1200_vibrator_play_effect(struct input_dev *input, void *data, struct ff_effect *effect){ struct isa1200 *isa = input_get_drvdata(input); int level;
/* * TODO: we currently only support rumble. * The ISA1200 can control two motors and some devices * also have two motors mounted. */ level = effect->u.rumble.strong_magnitude; if (!level) level = effect->u.rumble.weak_magnitude;
dev_dbg(&input->dev, "FF effect type %d level %d\n", effect->type, level);
if (isa->level != level) { isa->level = level; if (!READ_ONCE(isa->suspended)) schedule_work(&isa->play_work); }
return 0;}
static void isa1200_vibrator_close(struct input_dev *input){ struct isa1200 *isa = input_get_drvdata(input);
cancel_work_sync(&isa->play_work); isa1200_stop(isa); isa->level = 0;}
static int isa1200_of_probe(struct i2c_client *client){ struct isa1200 *isa = i2c_get_clientdata(client); struct isa1200_config *config = &isa->config; struct device *dev = &client->dev; struct fwnode_handle *ldo_node; int err;
isa->clk = devm_clk_get_optional(dev, NULL); if (IS_ERR(isa->clk)) return dev_err_probe(dev, PTR_ERR(isa->clk), "failed to get clock\n");
isa->pwm = devm_pwm_get(dev, NULL); if (IS_ERR(isa->pwm)) { err = PTR_ERR(isa->pwm); if (err == -ENODEV || err == -EINVAL) isa->pwm = NULL; else return dev_err_probe(dev, err, "getting PWM\n"); }
if (!isa->clk && !isa->pwm) return dev_err_probe(dev, -EINVAL, "clock or PWM are required, none were provided\n");
err = devm_regulator_bulk_get_const(dev, ARRAY_SIZE(isa1200_supplies), isa1200_supplies, &isa->supplies); if (err) return dev_err_probe(dev, err, "failed to get supplies\n");
isa->enable_gpios = devm_gpiod_get_array_optional(dev, "control", GPIOD_OUT_LOW); if (IS_ERR(isa->enable_gpios)) return dev_err_probe(dev, PTR_ERR(isa->enable_gpios), "failed to get enable gpios\n");
if (isa->enable_gpios && isa->enable_gpios->ndescs > ISA1200_EN_PINS_MAX) return dev_err_probe(dev, -EINVAL, "too many enable gpios\n");
ldo_node = device_get_named_child_node(dev, "ldo"); if (!ldo_node) return dev_err_probe(dev, -ENODEV, "failed to get embedded LDO node\n");
err = fwnode_property_read_u32(ldo_node, "regulator-min-microvolt", &config->ldo_voltage); fwnode_handle_put(ldo_node); if (err) return dev_err_probe(dev, err, "failed to get ldo voltage\n");
config->ldo_voltage = clamp(config->ldo_voltage, ISA1200_LDO_VOLTAGE_MIN, ISA1200_LDO_VOLTAGE_MAX);
config->ldo_voltage /= ISA1200_LDO_VOLTAGE_STEP; if (config->ldo_voltage < ISA1200_LDO_VOLTAGE_3V1) config->ldo_voltage = config->ldo_voltage - ISA1200_LDO_VOLTAGE_2V3 + ISA1200_LDO_VOLTAGE_BASE; else config->ldo_voltage -= ISA1200_LDO_VOLTAGE_3V1;
config->mode = 0; /* LRA_MODE */ device_property_read_u32(dev, "imagis,mode", &config->mode);
config->clkdiv = ISA1200_HCTRL0_CLKDIV_128; device_property_read_u32(dev, "imagis,clk-div", &config->clkdiv); if (!config->clkdiv) return dev_err_probe(dev, -EINVAL, "clk-div cannot be zero\n");
config->clkdiv = clamp(config->clkdiv, ISA1200_HCTRL0_CLKDIV_128, ISA1200_HCTRL0_CLKDIV_128 << 3);
err = device_property_read_u32(dev, "imagis,pll-div", &config->plldiv); if (err || !config->plldiv) config->plldiv = 1;
config->period = 0; config->freq = 0; config->duty = 0;
if (isa->clk) { err = device_property_read_u32(dev, "imagis,period-ns", &config->period); if (err) return dev_err_probe(dev, err, "failed to get period\n");
/* * TODO: The scale value is arbitrary, but it fits observations * quite well, and the exact conversion method is unknown. * The period property value returned above is the HCTRL6 * register value set by the vendor code, multiplied by 100. */ config->period /= ISA1200_HCTRL6_PERIOD_SCALE; config->duty = config->period >> 1; }
if (isa->pwm) { struct pwm_state state;
pwm_init_state(isa->pwm, &state);
if (!state.period) return dev_err_probe(dev, -EINVAL, "PWM period cannot be zero\n");
config->freq = div64_u64(NANO, state.period * config->clkdiv); config->duty = state.period >> 1;
err = pwm_apply_might_sleep(isa->pwm, &state); if (err) return dev_err_probe(dev, err, "failed to apply initial PWM state\n"); }
/* * TODO: If device is using a clock, this property should return the * value written to the HCTRL5 register by downstrem code. It likely * needs to be converted into a meaningful duty cycle value, though * unfortunately the exact conversion mechanism is unknown. If the * device uses PWM, this property will return the correct duty cycle * in nanoseconds. */ device_property_read_u32(dev, "imagis,duty-cycle-ns", &config->duty);
return 0;}
static int isa1200_probe(struct i2c_client *client){ struct isa1200 *isa; struct device *dev = &client->dev; int err;
isa = devm_kzalloc(dev, sizeof(*isa), GFP_KERNEL); if (!isa) return -ENOMEM;
isa->input = devm_input_allocate_device(dev); if (!isa->input) return -ENOMEM;
i2c_set_clientdata(client, isa);
err = isa1200_of_probe(client); if (err) return err;
isa->map = devm_regmap_init_i2c(client, &isa1200_regmap_config); if (IS_ERR(isa->map)) return dev_err_probe(dev, PTR_ERR(isa->map), "failed to initialize register map\n");
INIT_WORK(&isa->play_work, isa1200_play_work);
isa->input->name = "isa1200-haptic"; isa->input->id.bustype = BUS_I2C; isa->input->close = isa1200_vibrator_close;
isa->active = false;
input_set_drvdata(isa->input, isa);
/* TODO: this hardware can likely support more than rumble */ input_set_capability(isa->input, EV_FF, FF_RUMBLE);
err = input_ff_create_memless(isa->input, NULL, isa1200_vibrator_play_effect); if (err) return dev_err_probe(dev, err, "failed to create FF dev\n");
err = input_register_device(isa->input); if (err) return dev_err_probe(dev, err, "failed to register input dev\n");
return 0;}
static int isa1200_suspend(struct device *dev){ struct isa1200 *isa = dev_get_drvdata(dev);
guard(mutex)(&isa->input->mutex);
if (input_device_enabled(isa->input)) { WRITE_ONCE(isa->suspended, true); cancel_work_sync(&isa->play_work); isa1200_stop(isa); }
return 0;}
static int isa1200_resume(struct device *dev){ struct isa1200 *isa = dev_get_drvdata(dev);
guard(mutex)(&isa->input->mutex);
if (input_device_enabled(isa->input)) { WRITE_ONCE(isa->suspended, false); if (isa->level) schedule_work(&isa->play_work); }
return 0;}
static DEFINE_SIMPLE_DEV_PM_OPS(isa1200_pm_ops, isa1200_suspend, isa1200_resume);
static const struct of_device_id isa1200_of_match[] = { { .compatible = "imagis,isa1200" }, { /* sentinel */ }};MODULE_DEVICE_TABLE(of, isa1200_of_match);
static struct i2c_driver isa1200_i2c_driver = { .driver = { .name = "isa1200", .of_match_table = isa1200_of_match, .pm = pm_sleep_ptr(&isa1200_pm_ops), }, .probe = isa1200_probe,};module_i2c_driver(isa1200_i2c_driver);
MODULE_AUTHOR("Linus Walleij <linusw@kernel.org>");MODULE_AUTHOR("Svyatoslav Ryhel <clamor95@gmail.com>");MODULE_DESCRIPTION("Imagis ISA1200 haptic feedback unit");MODULE_LICENSE("GPL");