| // SPDX-License-Identifier: GPL-2.0-or-later |
| /* |
| * Copyright (C) 2014, Samsung Electronics Co. Ltd. All Rights Reserved. |
| */ |
| |
| #include <linux/iio/iio.h> |
| #include <linux/interrupt.h> |
| #include <linux/io.h> |
| #include <linux/mfd/core.h> |
| #include <linux/module.h> |
| #include <linux/of.h> |
| #include <linux/of_gpio.h> |
| #include <linux/of_platform.h> |
| #include "ssp.h" |
| |
| #define SSP_WDT_TIME 10000 |
| #define SSP_LIMIT_RESET_CNT 20 |
| #define SSP_LIMIT_TIMEOUT_CNT 3 |
| |
| /* It is possible that it is max clk rate for version 1.0 of bootcode */ |
| #define SSP_BOOT_SPI_HZ 400000 |
| |
| /* |
| * These fields can look enigmatic but this structure is used mainly to flat |
| * some values and depends on command type. |
| */ |
| struct ssp_instruction { |
| __le32 a; |
| __le32 b; |
| u8 c; |
| } __attribute__((__packed__)); |
| |
| static const u8 ssp_magnitude_table[] = {110, 85, 171, 71, 203, 195, 0, 67, |
| 208, 56, 175, 244, 206, 213, 0, 92, 250, 0, 55, 48, 189, 252, 171, |
| 243, 13, 45, 250}; |
| |
| static const struct ssp_sensorhub_info ssp_rinato_info = { |
| .fw_name = "ssp_B2.fw", |
| .fw_crashed_name = "ssp_crashed.fw", |
| .fw_rev = 14052300, |
| .mag_table = ssp_magnitude_table, |
| .mag_length = ARRAY_SIZE(ssp_magnitude_table), |
| }; |
| |
| static const struct ssp_sensorhub_info ssp_thermostat_info = { |
| .fw_name = "thermostat_B2.fw", |
| .fw_crashed_name = "ssp_crashed.fw", |
| .fw_rev = 14080600, |
| .mag_table = ssp_magnitude_table, |
| .mag_length = ARRAY_SIZE(ssp_magnitude_table), |
| }; |
| |
| static const struct mfd_cell sensorhub_sensor_devs[] = { |
| { |
| .name = "ssp-accelerometer", |
| }, |
| { |
| .name = "ssp-gyroscope", |
| }, |
| }; |
| |
| static void ssp_toggle_mcu_reset_gpio(struct ssp_data *data) |
| { |
| gpio_set_value(data->mcu_reset_gpio, 0); |
| usleep_range(1000, 1200); |
| gpio_set_value(data->mcu_reset_gpio, 1); |
| msleep(50); |
| } |
| |
| static void ssp_sync_available_sensors(struct ssp_data *data) |
| { |
| int i, ret; |
| |
| for (i = 0; i < SSP_SENSOR_MAX; ++i) { |
| if (data->available_sensors & BIT(i)) { |
| ret = ssp_enable_sensor(data, i, data->delay_buf[i]); |
| if (ret < 0) { |
| dev_err(&data->spi->dev, |
| "Sync sensor nr: %d fail\n", i); |
| continue; |
| } |
| } |
| } |
| |
| ret = ssp_command(data, SSP_MSG2SSP_AP_MCU_SET_DUMPMODE, |
| data->mcu_dump_mode); |
| if (ret < 0) |
| dev_err(&data->spi->dev, |
| "SSP_MSG2SSP_AP_MCU_SET_DUMPMODE failed\n"); |
| } |
| |
| static void ssp_enable_mcu(struct ssp_data *data, bool enable) |
| { |
| dev_info(&data->spi->dev, "current shutdown = %d, old = %d\n", enable, |
| data->shut_down); |
| |
| if (enable && data->shut_down) { |
| data->shut_down = false; |
| enable_irq(data->spi->irq); |
| enable_irq_wake(data->spi->irq); |
| } else if (!enable && !data->shut_down) { |
| data->shut_down = true; |
| disable_irq(data->spi->irq); |
| disable_irq_wake(data->spi->irq); |
| } else { |
| dev_warn(&data->spi->dev, "current shutdown = %d, old = %d\n", |
| enable, data->shut_down); |
| } |
| } |
| |
| /* |
| * This function is the first one which communicates with the mcu so it is |
| * possible that the first attempt will fail |
| */ |
| static int ssp_check_fwbl(struct ssp_data *data) |
| { |
| int retries = 0; |
| |
| while (retries++ < 5) { |
| data->cur_firm_rev = ssp_get_firmware_rev(data); |
| if (data->cur_firm_rev == SSP_INVALID_REVISION || |
| data->cur_firm_rev == SSP_INVALID_REVISION2) { |
| dev_warn(&data->spi->dev, |
| "Invalid revision, trying %d time\n", retries); |
| } else { |
| break; |
| } |
| } |
| |
| if (data->cur_firm_rev == SSP_INVALID_REVISION || |
| data->cur_firm_rev == SSP_INVALID_REVISION2) { |
| dev_err(&data->spi->dev, "SSP_INVALID_REVISION\n"); |
| return SSP_FW_DL_STATE_NEED_TO_SCHEDULE; |
| } |
| |
| dev_info(&data->spi->dev, |
| "MCU Firm Rev : Old = %8u, New = %8u\n", |
| data->cur_firm_rev, |
| data->sensorhub_info->fw_rev); |
| |
| if (data->cur_firm_rev != data->sensorhub_info->fw_rev) |
| return SSP_FW_DL_STATE_NEED_TO_SCHEDULE; |
| |
| return SSP_FW_DL_STATE_NONE; |
| } |
| |
| static void ssp_reset_mcu(struct ssp_data *data) |
| { |
| ssp_enable_mcu(data, false); |
| ssp_clean_pending_list(data); |
| ssp_toggle_mcu_reset_gpio(data); |
| ssp_enable_mcu(data, true); |
| } |
| |
| static void ssp_wdt_work_func(struct work_struct *work) |
| { |
| struct ssp_data *data = container_of(work, struct ssp_data, work_wdt); |
| |
| dev_err(&data->spi->dev, "%s - Sensor state: 0x%x, RC: %u, CC: %u\n", |
| __func__, data->available_sensors, data->reset_cnt, |
| data->com_fail_cnt); |
| |
| ssp_reset_mcu(data); |
| data->com_fail_cnt = 0; |
| data->timeout_cnt = 0; |
| } |
| |
| static void ssp_wdt_timer_func(struct timer_list *t) |
| { |
| struct ssp_data *data = from_timer(data, t, wdt_timer); |
| |
| switch (data->fw_dl_state) { |
| case SSP_FW_DL_STATE_FAIL: |
| case SSP_FW_DL_STATE_DOWNLOADING: |
| case SSP_FW_DL_STATE_SYNC: |
| goto _mod; |
| } |
| |
| if (data->timeout_cnt > SSP_LIMIT_TIMEOUT_CNT || |
| data->com_fail_cnt > SSP_LIMIT_RESET_CNT) |
| queue_work(system_power_efficient_wq, &data->work_wdt); |
| _mod: |
| mod_timer(&data->wdt_timer, jiffies + msecs_to_jiffies(SSP_WDT_TIME)); |
| } |
| |
| static void ssp_enable_wdt_timer(struct ssp_data *data) |
| { |
| mod_timer(&data->wdt_timer, jiffies + msecs_to_jiffies(SSP_WDT_TIME)); |
| } |
| |
| static void ssp_disable_wdt_timer(struct ssp_data *data) |
| { |
| del_timer_sync(&data->wdt_timer); |
| cancel_work_sync(&data->work_wdt); |
| } |
| |
| /** |
| * ssp_get_sensor_delay() - gets sensor data acquisition period |
| * @data: sensorhub structure |
| * @type: SSP sensor type |
| * |
| * Returns acquisition period in ms |
| */ |
| u32 ssp_get_sensor_delay(struct ssp_data *data, enum ssp_sensor_type type) |
| { |
| return data->delay_buf[type]; |
| } |
| EXPORT_SYMBOL(ssp_get_sensor_delay); |
| |
| /** |
| * ssp_enable_sensor() - enables data acquisition for sensor |
| * @data: sensorhub structure |
| * @type: SSP sensor type |
| * @delay: delay in ms |
| * |
| * Returns 0 or negative value in case of error |
| */ |
| int ssp_enable_sensor(struct ssp_data *data, enum ssp_sensor_type type, |
| u32 delay) |
| { |
| int ret; |
| struct ssp_instruction to_send; |
| |
| to_send.a = cpu_to_le32(delay); |
| to_send.b = cpu_to_le32(data->batch_latency_buf[type]); |
| to_send.c = data->batch_opt_buf[type]; |
| |
| switch (data->check_status[type]) { |
| case SSP_INITIALIZATION_STATE: |
| /* do calibration step, now just enable */ |
| case SSP_ADD_SENSOR_STATE: |
| ret = ssp_send_instruction(data, |
| SSP_MSG2SSP_INST_BYPASS_SENSOR_ADD, |
| type, |
| (u8 *)&to_send, sizeof(to_send)); |
| if (ret < 0) { |
| dev_err(&data->spi->dev, "Enabling sensor failed\n"); |
| data->check_status[type] = SSP_NO_SENSOR_STATE; |
| goto derror; |
| } |
| |
| data->sensor_enable |= BIT(type); |
| data->check_status[type] = SSP_RUNNING_SENSOR_STATE; |
| break; |
| case SSP_RUNNING_SENSOR_STATE: |
| ret = ssp_send_instruction(data, |
| SSP_MSG2SSP_INST_CHANGE_DELAY, type, |
| (u8 *)&to_send, sizeof(to_send)); |
| if (ret < 0) { |
| dev_err(&data->spi->dev, |
| "Changing sensor delay failed\n"); |
| goto derror; |
| } |
| break; |
| default: |
| data->check_status[type] = SSP_ADD_SENSOR_STATE; |
| break; |
| } |
| |
| data->delay_buf[type] = delay; |
| |
| if (atomic_inc_return(&data->enable_refcount) == 1) |
| ssp_enable_wdt_timer(data); |
| |
| return 0; |
| |
| derror: |
| return ret; |
| } |
| EXPORT_SYMBOL(ssp_enable_sensor); |
| |
| /** |
| * ssp_change_delay() - changes data acquisition for sensor |
| * @data: sensorhub structure |
| * @type: SSP sensor type |
| * @delay: delay in ms |
| * |
| * Returns 0 or negative value in case of error |
| */ |
| int ssp_change_delay(struct ssp_data *data, enum ssp_sensor_type type, |
| u32 delay) |
| { |
| int ret; |
| struct ssp_instruction to_send; |
| |
| to_send.a = cpu_to_le32(delay); |
| to_send.b = cpu_to_le32(data->batch_latency_buf[type]); |
| to_send.c = data->batch_opt_buf[type]; |
| |
| ret = ssp_send_instruction(data, SSP_MSG2SSP_INST_CHANGE_DELAY, type, |
| (u8 *)&to_send, sizeof(to_send)); |
| if (ret < 0) { |
| dev_err(&data->spi->dev, "Changing sensor delay failed\n"); |
| return ret; |
| } |
| |
| data->delay_buf[type] = delay; |
| |
| return 0; |
| } |
| EXPORT_SYMBOL(ssp_change_delay); |
| |
| /** |
| * ssp_disable_sensor() - disables sensor |
| * |
| * @data: sensorhub structure |
| * @type: SSP sensor type |
| * |
| * Returns 0 or negative value in case of error |
| */ |
| int ssp_disable_sensor(struct ssp_data *data, enum ssp_sensor_type type) |
| { |
| int ret; |
| __le32 command; |
| |
| if (data->sensor_enable & BIT(type)) { |
| command = cpu_to_le32(data->delay_buf[type]); |
| |
| ret = ssp_send_instruction(data, |
| SSP_MSG2SSP_INST_BYPASS_SENSOR_RM, |
| type, (u8 *)&command, |
| sizeof(command)); |
| if (ret < 0) { |
| dev_err(&data->spi->dev, "Remove sensor fail\n"); |
| return ret; |
| } |
| |
| data->sensor_enable &= ~BIT(type); |
| } |
| |
| data->check_status[type] = SSP_ADD_SENSOR_STATE; |
| |
| if (atomic_dec_and_test(&data->enable_refcount)) |
| ssp_disable_wdt_timer(data); |
| |
| return 0; |
| } |
| EXPORT_SYMBOL(ssp_disable_sensor); |
| |
| static irqreturn_t ssp_irq_thread_fn(int irq, void *dev_id) |
| { |
| struct ssp_data *data = dev_id; |
| |
| /* |
| * This wrapper is done to preserve error path for ssp_irq_msg, also |
| * it is defined in different file. |
| */ |
| ssp_irq_msg(data); |
| |
| return IRQ_HANDLED; |
| } |
| |
| static int ssp_initialize_mcu(struct ssp_data *data) |
| { |
| int ret; |
| |
| ssp_clean_pending_list(data); |
| |
| ret = ssp_get_chipid(data); |
| if (ret != SSP_DEVICE_ID) { |
| dev_err(&data->spi->dev, "%s - MCU %s ret = %d\n", __func__, |
| ret < 0 ? "is not working" : "identification failed", |
| ret); |
| return ret < 0 ? ret : -ENODEV; |
| } |
| |
| dev_info(&data->spi->dev, "MCU device ID = %d\n", ret); |
| |
| /* |
| * needs clarification, for now do not want to export all transfer |
| * methods to sensors' drivers |
| */ |
| ret = ssp_set_magnetic_matrix(data); |
| if (ret < 0) { |
| dev_err(&data->spi->dev, |
| "%s - ssp_set_magnetic_matrix failed\n", __func__); |
| return ret; |
| } |
| |
| data->available_sensors = ssp_get_sensor_scanning_info(data); |
| if (data->available_sensors == 0) { |
| dev_err(&data->spi->dev, |
| "%s - ssp_get_sensor_scanning_info failed\n", __func__); |
| return -EIO; |
| } |
| |
| data->cur_firm_rev = ssp_get_firmware_rev(data); |
| dev_info(&data->spi->dev, "MCU Firm Rev : New = %8u\n", |
| data->cur_firm_rev); |
| |
| return ssp_command(data, SSP_MSG2SSP_AP_MCU_DUMP_CHECK, 0); |
| } |
| |
| /* |
| * sensorhub can request its reinitialization as some brutal and rare error |
| * handling. It can be requested from the MCU. |
| */ |
| static void ssp_refresh_task(struct work_struct *work) |
| { |
| struct ssp_data *data = container_of((struct delayed_work *)work, |
| struct ssp_data, work_refresh); |
| |
| dev_info(&data->spi->dev, "refreshing\n"); |
| |
| data->reset_cnt++; |
| |
| if (ssp_initialize_mcu(data) >= 0) { |
| ssp_sync_available_sensors(data); |
| if (data->last_ap_state != 0) |
| ssp_command(data, data->last_ap_state, 0); |
| |
| if (data->last_resume_state != 0) |
| ssp_command(data, data->last_resume_state, 0); |
| |
| data->timeout_cnt = 0; |
| data->com_fail_cnt = 0; |
| } |
| } |
| |
| int ssp_queue_ssp_refresh_task(struct ssp_data *data, unsigned int delay) |
| { |
| cancel_delayed_work_sync(&data->work_refresh); |
| |
| return queue_delayed_work(system_power_efficient_wq, |
| &data->work_refresh, |
| msecs_to_jiffies(delay)); |
| } |
| |
| #ifdef CONFIG_OF |
| static const struct of_device_id ssp_of_match[] = { |
| { |
| .compatible = "samsung,sensorhub-rinato", |
| .data = &ssp_rinato_info, |
| }, { |
| .compatible = "samsung,sensorhub-thermostat", |
| .data = &ssp_thermostat_info, |
| }, |
| {}, |
| }; |
| MODULE_DEVICE_TABLE(of, ssp_of_match); |
| |
| static struct ssp_data *ssp_parse_dt(struct device *dev) |
| { |
| int ret; |
| struct ssp_data *data; |
| struct device_node *node = dev->of_node; |
| const struct of_device_id *match; |
| |
| data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); |
| if (!data) |
| return NULL; |
| |
| data->mcu_ap_gpio = of_get_named_gpio(node, "mcu-ap-gpios", 0); |
| if (data->mcu_ap_gpio < 0) |
| return NULL; |
| |
| data->ap_mcu_gpio = of_get_named_gpio(node, "ap-mcu-gpios", 0); |
| if (data->ap_mcu_gpio < 0) |
| return NULL; |
| |
| data->mcu_reset_gpio = of_get_named_gpio(node, "mcu-reset-gpios", 0); |
| if (data->mcu_reset_gpio < 0) |
| return NULL; |
| |
| ret = devm_gpio_request_one(dev, data->ap_mcu_gpio, GPIOF_OUT_INIT_HIGH, |
| "ap-mcu-gpios"); |
| if (ret) |
| return NULL; |
| |
| ret = devm_gpio_request_one(dev, data->mcu_reset_gpio, |
| GPIOF_OUT_INIT_HIGH, "mcu-reset-gpios"); |
| if (ret) |
| return NULL; |
| |
| match = of_match_node(ssp_of_match, node); |
| if (!match) |
| return NULL; |
| |
| data->sensorhub_info = match->data; |
| |
| dev_set_drvdata(dev, data); |
| |
| return data; |
| } |
| #else |
| static struct ssp_data *ssp_parse_dt(struct device *pdev) |
| { |
| return NULL; |
| } |
| #endif |
| |
| /** |
| * ssp_register_consumer() - registers iio consumer in ssp framework |
| * |
| * @indio_dev: consumer iio device |
| * @type: ssp sensor type |
| */ |
| void ssp_register_consumer(struct iio_dev *indio_dev, enum ssp_sensor_type type) |
| { |
| struct ssp_data *data = dev_get_drvdata(indio_dev->dev.parent->parent); |
| |
| data->sensor_devs[type] = indio_dev; |
| } |
| EXPORT_SYMBOL(ssp_register_consumer); |
| |
| static int ssp_probe(struct spi_device *spi) |
| { |
| int ret, i; |
| struct ssp_data *data; |
| |
| data = ssp_parse_dt(&spi->dev); |
| if (!data) { |
| dev_err(&spi->dev, "Failed to find platform data\n"); |
| return -ENODEV; |
| } |
| |
| ret = mfd_add_devices(&spi->dev, -1, sensorhub_sensor_devs, |
| ARRAY_SIZE(sensorhub_sensor_devs), NULL, 0, NULL); |
| if (ret < 0) { |
| dev_err(&spi->dev, "mfd add devices fail\n"); |
| return ret; |
| } |
| |
| spi->mode = SPI_MODE_1; |
| ret = spi_setup(spi); |
| if (ret < 0) { |
| dev_err(&spi->dev, "Failed to setup spi\n"); |
| return ret; |
| } |
| |
| data->fw_dl_state = SSP_FW_DL_STATE_NONE; |
| data->spi = spi; |
| spi_set_drvdata(spi, data); |
| |
| mutex_init(&data->comm_lock); |
| |
| for (i = 0; i < SSP_SENSOR_MAX; ++i) { |
| data->delay_buf[i] = SSP_DEFAULT_POLLING_DELAY; |
| data->batch_latency_buf[i] = 0; |
| data->batch_opt_buf[i] = 0; |
| data->check_status[i] = SSP_INITIALIZATION_STATE; |
| } |
| |
| data->delay_buf[SSP_BIO_HRM_LIB] = 100; |
| |
| data->time_syncing = true; |
| |
| mutex_init(&data->pending_lock); |
| INIT_LIST_HEAD(&data->pending_list); |
| |
| atomic_set(&data->enable_refcount, 0); |
| |
| INIT_WORK(&data->work_wdt, ssp_wdt_work_func); |
| INIT_DELAYED_WORK(&data->work_refresh, ssp_refresh_task); |
| |
| timer_setup(&data->wdt_timer, ssp_wdt_timer_func, 0); |
| |
| ret = request_threaded_irq(data->spi->irq, NULL, |
| ssp_irq_thread_fn, |
| IRQF_TRIGGER_FALLING | IRQF_ONESHOT, |
| "SSP_Int", data); |
| if (ret < 0) { |
| dev_err(&spi->dev, "Irq request fail\n"); |
| goto err_setup_irq; |
| } |
| |
| /* Let's start with enabled one so irq balance could be ok */ |
| data->shut_down = false; |
| |
| /* just to avoid unbalanced irq set wake up */ |
| enable_irq_wake(data->spi->irq); |
| |
| data->fw_dl_state = ssp_check_fwbl(data); |
| if (data->fw_dl_state == SSP_FW_DL_STATE_NONE) { |
| ret = ssp_initialize_mcu(data); |
| if (ret < 0) { |
| dev_err(&spi->dev, "Initialize_mcu failed\n"); |
| goto err_read_reg; |
| } |
| } else { |
| dev_err(&spi->dev, "Firmware version not supported\n"); |
| ret = -EPERM; |
| goto err_read_reg; |
| } |
| |
| return 0; |
| |
| err_read_reg: |
| free_irq(data->spi->irq, data); |
| err_setup_irq: |
| mutex_destroy(&data->pending_lock); |
| mutex_destroy(&data->comm_lock); |
| |
| dev_err(&spi->dev, "Probe failed!\n"); |
| |
| return ret; |
| } |
| |
| static int ssp_remove(struct spi_device *spi) |
| { |
| struct ssp_data *data = spi_get_drvdata(spi); |
| |
| if (ssp_command(data, SSP_MSG2SSP_AP_STATUS_SHUTDOWN, 0) < 0) |
| dev_err(&data->spi->dev, |
| "SSP_MSG2SSP_AP_STATUS_SHUTDOWN failed\n"); |
| |
| ssp_enable_mcu(data, false); |
| ssp_disable_wdt_timer(data); |
| |
| ssp_clean_pending_list(data); |
| |
| free_irq(data->spi->irq, data); |
| |
| del_timer_sync(&data->wdt_timer); |
| cancel_work_sync(&data->work_wdt); |
| |
| mutex_destroy(&data->comm_lock); |
| mutex_destroy(&data->pending_lock); |
| |
| mfd_remove_devices(&spi->dev); |
| |
| return 0; |
| } |
| |
| #ifdef CONFIG_PM_SLEEP |
| static int ssp_suspend(struct device *dev) |
| { |
| int ret; |
| struct ssp_data *data = spi_get_drvdata(to_spi_device(dev)); |
| |
| data->last_resume_state = SSP_MSG2SSP_AP_STATUS_SUSPEND; |
| |
| if (atomic_read(&data->enable_refcount) > 0) |
| ssp_disable_wdt_timer(data); |
| |
| ret = ssp_command(data, SSP_MSG2SSP_AP_STATUS_SUSPEND, 0); |
| if (ret < 0) { |
| dev_err(&data->spi->dev, |
| "%s SSP_MSG2SSP_AP_STATUS_SUSPEND failed\n", __func__); |
| |
| ssp_enable_wdt_timer(data); |
| return ret; |
| } |
| |
| data->time_syncing = false; |
| disable_irq(data->spi->irq); |
| |
| return 0; |
| } |
| |
| static int ssp_resume(struct device *dev) |
| { |
| int ret; |
| struct ssp_data *data = spi_get_drvdata(to_spi_device(dev)); |
| |
| enable_irq(data->spi->irq); |
| |
| if (atomic_read(&data->enable_refcount) > 0) |
| ssp_enable_wdt_timer(data); |
| |
| ret = ssp_command(data, SSP_MSG2SSP_AP_STATUS_RESUME, 0); |
| if (ret < 0) { |
| dev_err(&data->spi->dev, |
| "%s SSP_MSG2SSP_AP_STATUS_RESUME failed\n", __func__); |
| ssp_disable_wdt_timer(data); |
| return ret; |
| } |
| |
| /* timesyncing is set by MCU */ |
| data->last_resume_state = SSP_MSG2SSP_AP_STATUS_RESUME; |
| |
| return 0; |
| } |
| #endif /* CONFIG_PM_SLEEP */ |
| |
| static const struct dev_pm_ops ssp_pm_ops = { |
| SET_SYSTEM_SLEEP_PM_OPS(ssp_suspend, ssp_resume) |
| }; |
| |
| static struct spi_driver ssp_driver = { |
| .probe = ssp_probe, |
| .remove = ssp_remove, |
| .driver = { |
| .pm = &ssp_pm_ops, |
| .of_match_table = of_match_ptr(ssp_of_match), |
| .name = "sensorhub" |
| }, |
| }; |
| |
| module_spi_driver(ssp_driver); |
| |
| MODULE_DESCRIPTION("ssp sensorhub driver"); |
| MODULE_AUTHOR("Samsung Electronics"); |
| MODULE_LICENSE("GPL"); |