| // SPDX-License-Identifier: GPL-2.0 |
| /* |
| * Copyright (C) 2021-2022 Linaro Ltd. |
| * Copyright (C) 2018-2020 The Linux Foundation |
| */ |
| |
| #include <linux/bits.h> |
| #include <linux/i2c.h> |
| #include <linux/kernel.h> |
| #include <linux/module.h> |
| #include <linux/mutex.h> |
| #include <linux/regmap.h> |
| #include <linux/usb/typec_dp.h> |
| #include <linux/usb/typec_mux.h> |
| |
| #define FSA4480_SWITCH_ENABLE 0x04 |
| #define FSA4480_SWITCH_SELECT 0x05 |
| #define FSA4480_SWITCH_STATUS1 0x07 |
| #define FSA4480_SLOW_L 0x08 |
| #define FSA4480_SLOW_R 0x09 |
| #define FSA4480_SLOW_MIC 0x0a |
| #define FSA4480_SLOW_SENSE 0x0b |
| #define FSA4480_SLOW_GND 0x0c |
| #define FSA4480_DELAY_L_R 0x0d |
| #define FSA4480_DELAY_L_MIC 0x0e |
| #define FSA4480_DELAY_L_SENSE 0x0f |
| #define FSA4480_DELAY_L_AGND 0x10 |
| #define FSA4480_FUNCTION_ENABLE 0x12 |
| #define FSA4480_RESET 0x1e |
| #define FSA4480_MAX_REGISTER 0x1f |
| |
| #define FSA4480_ENABLE_DEVICE BIT(7) |
| #define FSA4480_ENABLE_SBU GENMASK(6, 5) |
| #define FSA4480_ENABLE_USB GENMASK(4, 3) |
| #define FSA4480_ENABLE_SENSE BIT(2) |
| #define FSA4480_ENABLE_MIC BIT(1) |
| #define FSA4480_ENABLE_AGND BIT(0) |
| |
| #define FSA4480_SEL_SBU_REVERSE GENMASK(6, 5) |
| #define FSA4480_SEL_USB GENMASK(4, 3) |
| #define FSA4480_SEL_SENSE BIT(2) |
| #define FSA4480_SEL_MIC BIT(1) |
| #define FSA4480_SEL_AGND BIT(0) |
| |
| #define FSA4480_ENABLE_AUTO_JACK_DETECT BIT(0) |
| |
| struct fsa4480 { |
| struct i2c_client *client; |
| |
| /* used to serialize concurrent change requests */ |
| struct mutex lock; |
| |
| struct typec_switch_dev *sw; |
| struct typec_mux_dev *mux; |
| |
| struct regmap *regmap; |
| |
| enum typec_orientation orientation; |
| unsigned long mode; |
| unsigned int svid; |
| |
| u8 cur_enable; |
| bool swap_sbu_lanes; |
| }; |
| |
| static const struct regmap_config fsa4480_regmap_config = { |
| .reg_bits = 8, |
| .val_bits = 8, |
| .max_register = FSA4480_MAX_REGISTER, |
| /* Accesses only done under fsa4480->lock */ |
| .disable_locking = true, |
| }; |
| |
| static int fsa4480_set(struct fsa4480 *fsa) |
| { |
| bool reverse = (fsa->orientation == TYPEC_ORIENTATION_REVERSE); |
| u8 enable = FSA4480_ENABLE_DEVICE; |
| u8 sel = 0; |
| |
| if (fsa->swap_sbu_lanes) |
| reverse = !reverse; |
| |
| /* USB Mode */ |
| if (fsa->mode < TYPEC_STATE_MODAL || |
| (!fsa->svid && (fsa->mode == TYPEC_MODE_USB2 || |
| fsa->mode == TYPEC_MODE_USB3))) { |
| enable |= FSA4480_ENABLE_USB; |
| sel = FSA4480_SEL_USB; |
| } else if (fsa->svid) { |
| switch (fsa->mode) { |
| /* DP Only */ |
| case TYPEC_DP_STATE_C: |
| case TYPEC_DP_STATE_E: |
| enable |= FSA4480_ENABLE_SBU; |
| if (reverse) |
| sel = FSA4480_SEL_SBU_REVERSE; |
| break; |
| |
| /* DP + USB */ |
| case TYPEC_DP_STATE_D: |
| case TYPEC_DP_STATE_F: |
| enable |= FSA4480_ENABLE_USB | FSA4480_ENABLE_SBU; |
| sel = FSA4480_SEL_USB; |
| if (reverse) |
| sel |= FSA4480_SEL_SBU_REVERSE; |
| break; |
| |
| default: |
| return -EOPNOTSUPP; |
| } |
| } else if (fsa->mode == TYPEC_MODE_AUDIO) { |
| /* Audio Accessory Mode, setup to auto Jack Detection */ |
| enable |= FSA4480_ENABLE_USB | FSA4480_ENABLE_AGND; |
| } else |
| return -EOPNOTSUPP; |
| |
| if (fsa->cur_enable & FSA4480_ENABLE_SBU) { |
| /* Disable SBU output while re-configuring the switch */ |
| regmap_write(fsa->regmap, FSA4480_SWITCH_ENABLE, |
| fsa->cur_enable & ~FSA4480_ENABLE_SBU); |
| |
| /* 35us to allow the SBU switch to turn off */ |
| usleep_range(35, 1000); |
| } |
| |
| regmap_write(fsa->regmap, FSA4480_SWITCH_SELECT, sel); |
| regmap_write(fsa->regmap, FSA4480_SWITCH_ENABLE, enable); |
| |
| /* Start AUDIO JACK DETECTION to setup MIC, AGND & Sense muxes */ |
| if (enable & FSA4480_ENABLE_AGND) |
| regmap_write(fsa->regmap, FSA4480_FUNCTION_ENABLE, |
| FSA4480_ENABLE_AUTO_JACK_DETECT); |
| |
| if (enable & FSA4480_ENABLE_SBU) { |
| /* 15us to allow the SBU switch to turn on again */ |
| usleep_range(15, 1000); |
| } |
| |
| fsa->cur_enable = enable; |
| |
| return 0; |
| } |
| |
| static int fsa4480_switch_set(struct typec_switch_dev *sw, |
| enum typec_orientation orientation) |
| { |
| struct fsa4480 *fsa = typec_switch_get_drvdata(sw); |
| int ret = 0; |
| |
| mutex_lock(&fsa->lock); |
| |
| if (fsa->orientation != orientation) { |
| fsa->orientation = orientation; |
| |
| ret = fsa4480_set(fsa); |
| } |
| |
| mutex_unlock(&fsa->lock); |
| |
| return ret; |
| } |
| |
| static int fsa4480_mux_set(struct typec_mux_dev *mux, struct typec_mux_state *state) |
| { |
| struct fsa4480 *fsa = typec_mux_get_drvdata(mux); |
| int ret = 0; |
| |
| mutex_lock(&fsa->lock); |
| |
| if (fsa->mode != state->mode) { |
| fsa->mode = state->mode; |
| |
| if (state->alt) |
| fsa->svid = state->alt->svid; |
| else |
| fsa->svid = 0; // No SVID |
| |
| ret = fsa4480_set(fsa); |
| } |
| |
| mutex_unlock(&fsa->lock); |
| |
| return ret; |
| } |
| |
| enum { |
| NORMAL_LANE_MAPPING, |
| INVERT_LANE_MAPPING, |
| }; |
| |
| #define DATA_LANES_COUNT 2 |
| |
| static const int supported_data_lane_mapping[][DATA_LANES_COUNT] = { |
| [NORMAL_LANE_MAPPING] = { 0, 1 }, |
| [INVERT_LANE_MAPPING] = { 1, 0 }, |
| }; |
| |
| static int fsa4480_parse_data_lanes_mapping(struct fsa4480 *fsa) |
| { |
| struct fwnode_handle *ep; |
| u32 data_lanes[DATA_LANES_COUNT]; |
| int ret, i, j; |
| |
| ep = fwnode_graph_get_next_endpoint(dev_fwnode(&fsa->client->dev), NULL); |
| if (!ep) |
| return 0; |
| |
| ret = fwnode_property_read_u32_array(ep, "data-lanes", data_lanes, DATA_LANES_COUNT); |
| if (ret == -EINVAL) |
| /* Property isn't here, consider default mapping */ |
| goto out_done; |
| if (ret) { |
| dev_err(&fsa->client->dev, "invalid data-lanes property: %d\n", ret); |
| goto out_error; |
| } |
| |
| for (i = 0; i < ARRAY_SIZE(supported_data_lane_mapping); i++) { |
| for (j = 0; j < DATA_LANES_COUNT; j++) { |
| if (data_lanes[j] != supported_data_lane_mapping[i][j]) |
| break; |
| } |
| |
| if (j == DATA_LANES_COUNT) |
| break; |
| } |
| |
| switch (i) { |
| case NORMAL_LANE_MAPPING: |
| break; |
| case INVERT_LANE_MAPPING: |
| fsa->swap_sbu_lanes = true; |
| break; |
| default: |
| dev_err(&fsa->client->dev, "invalid data-lanes mapping\n"); |
| ret = -EINVAL; |
| goto out_error; |
| } |
| |
| out_done: |
| ret = 0; |
| |
| out_error: |
| fwnode_handle_put(ep); |
| |
| return ret; |
| } |
| |
| static int fsa4480_probe(struct i2c_client *client) |
| { |
| struct device *dev = &client->dev; |
| struct typec_switch_desc sw_desc = { }; |
| struct typec_mux_desc mux_desc = { }; |
| struct fsa4480 *fsa; |
| int ret; |
| |
| fsa = devm_kzalloc(dev, sizeof(*fsa), GFP_KERNEL); |
| if (!fsa) |
| return -ENOMEM; |
| |
| fsa->client = client; |
| mutex_init(&fsa->lock); |
| |
| ret = fsa4480_parse_data_lanes_mapping(fsa); |
| if (ret) |
| return ret; |
| |
| fsa->regmap = devm_regmap_init_i2c(client, &fsa4480_regmap_config); |
| if (IS_ERR(fsa->regmap)) |
| return dev_err_probe(dev, PTR_ERR(fsa->regmap), "failed to initialize regmap\n"); |
| |
| /* Safe mode */ |
| fsa->cur_enable = FSA4480_ENABLE_DEVICE | FSA4480_ENABLE_USB; |
| fsa->mode = TYPEC_STATE_SAFE; |
| fsa->orientation = TYPEC_ORIENTATION_NONE; |
| |
| /* set default settings */ |
| regmap_write(fsa->regmap, FSA4480_SLOW_L, 0x00); |
| regmap_write(fsa->regmap, FSA4480_SLOW_R, 0x00); |
| regmap_write(fsa->regmap, FSA4480_SLOW_MIC, 0x00); |
| regmap_write(fsa->regmap, FSA4480_SLOW_SENSE, 0x00); |
| regmap_write(fsa->regmap, FSA4480_SLOW_GND, 0x00); |
| regmap_write(fsa->regmap, FSA4480_DELAY_L_R, 0x00); |
| regmap_write(fsa->regmap, FSA4480_DELAY_L_MIC, 0x00); |
| regmap_write(fsa->regmap, FSA4480_DELAY_L_SENSE, 0x00); |
| regmap_write(fsa->regmap, FSA4480_DELAY_L_AGND, 0x09); |
| regmap_write(fsa->regmap, FSA4480_SWITCH_SELECT, FSA4480_SEL_USB); |
| regmap_write(fsa->regmap, FSA4480_SWITCH_ENABLE, fsa->cur_enable); |
| |
| sw_desc.drvdata = fsa; |
| sw_desc.fwnode = dev_fwnode(dev); |
| sw_desc.set = fsa4480_switch_set; |
| |
| fsa->sw = typec_switch_register(dev, &sw_desc); |
| if (IS_ERR(fsa->sw)) |
| return dev_err_probe(dev, PTR_ERR(fsa->sw), "failed to register typec switch\n"); |
| |
| mux_desc.drvdata = fsa; |
| mux_desc.fwnode = dev_fwnode(dev); |
| mux_desc.set = fsa4480_mux_set; |
| |
| fsa->mux = typec_mux_register(dev, &mux_desc); |
| if (IS_ERR(fsa->mux)) { |
| typec_switch_unregister(fsa->sw); |
| return dev_err_probe(dev, PTR_ERR(fsa->mux), "failed to register typec mux\n"); |
| } |
| |
| i2c_set_clientdata(client, fsa); |
| return 0; |
| } |
| |
| static void fsa4480_remove(struct i2c_client *client) |
| { |
| struct fsa4480 *fsa = i2c_get_clientdata(client); |
| |
| typec_mux_unregister(fsa->mux); |
| typec_switch_unregister(fsa->sw); |
| } |
| |
| static const struct i2c_device_id fsa4480_table[] = { |
| { "fsa4480" }, |
| { } |
| }; |
| MODULE_DEVICE_TABLE(i2c, fsa4480_table); |
| |
| static const struct of_device_id fsa4480_of_table[] = { |
| { .compatible = "fcs,fsa4480" }, |
| { } |
| }; |
| MODULE_DEVICE_TABLE(of, fsa4480_of_table); |
| |
| static struct i2c_driver fsa4480_driver = { |
| .driver = { |
| .name = "fsa4480", |
| .of_match_table = fsa4480_of_table, |
| }, |
| .probe = fsa4480_probe, |
| .remove = fsa4480_remove, |
| .id_table = fsa4480_table, |
| }; |
| module_i2c_driver(fsa4480_driver); |
| |
| MODULE_DESCRIPTION("ON Semiconductor FSA4480 driver"); |
| MODULE_LICENSE("GPL v2"); |