// SPDX-License-Identifier: GPL-2.0
|
/*
|
* Copyright (c) 2019, Fuzhou Rockchip Electronics Co., Ltd.
|
*
|
* Rockchip rm310 driver for 4g modem
|
*/
|
|
#include <linux/module.h>
|
#include <linux/kernel.h>
|
#include <linux/kthread.h>
|
#include <linux/i2c.h>
|
#include <linux/irq.h>
|
#include <linux/gpio.h>
|
#include <linux/input.h>
|
#include <linux/platform_device.h>
|
#include <linux/fs.h>
|
#include <linux/uaccess.h>
|
#include <linux/miscdevice.h>
|
#include <linux/circ_buf.h>
|
#include <linux/miscdevice.h>
|
#include <linux/gpio.h>
|
#include <dt-bindings/gpio/gpio.h>
|
#include <linux/delay.h>
|
#include <linux/poll.h>
|
#include <linux/wait.h>
|
#include <linux/wakelock.h>
|
#include <linux/workqueue.h>
|
#include <linux/lte.h>
|
#include <linux/slab.h>
|
#include <linux/of.h>
|
#include <linux/of_device.h>
|
#include <linux/of_gpio.h>
|
|
#define LOG(x...) pr_info("[4g_modem]: " x)
|
|
static struct lte_data *gpdata;
|
static struct class *modem_class;
|
static int modem_status = 1;
|
|
static int modem_poweron_off(int on_off)
|
{
|
struct lte_data *pdata = gpdata;
|
|
if (pdata) {
|
if (on_off) {
|
LOG("%s: 4g modem power up.\n", __func__);
|
if (pdata->vbat_gpio) {
|
gpiod_direction_output(pdata->vbat_gpio, 1);
|
msleep(2000);
|
}
|
if (pdata->power_gpio) {
|
gpiod_direction_output(pdata->power_gpio, 0);
|
msleep(50);
|
gpiod_direction_output(pdata->power_gpio, 1);
|
msleep(400);
|
gpiod_direction_output(pdata->power_gpio, 0);
|
}
|
} else {
|
LOG("%s: 4g modem power down.\n", __func__);
|
if (pdata->power_gpio) {
|
gpiod_direction_output(pdata->power_gpio, 0);
|
msleep(100);
|
gpiod_direction_output(pdata->power_gpio, 1);
|
msleep(1000);
|
gpiod_direction_output(pdata->power_gpio, 0);
|
msleep(400);
|
}
|
if (pdata->vbat_gpio)
|
gpiod_direction_output(pdata->vbat_gpio, 0);
|
}
|
}
|
return 0;
|
}
|
|
static ssize_t modem_status_store(struct class *cls,
|
struct class_attribute *attr,
|
const char *buf, size_t count)
|
{
|
int new_state, ret;
|
|
ret = kstrtoint(buf, 10, &new_state);
|
if (ret) {
|
LOG("%s: kstrtoint error return %d\n", __func__, ret);
|
return ret;
|
}
|
if (new_state == modem_status)
|
return count;
|
if (new_state == 1) {
|
LOG("%s, c(%d), open modem.\n", __func__, new_state);
|
modem_poweron_off(1);
|
} else if (new_state == 0) {
|
LOG("%s, c(%d), close modem.\n", __func__, new_state);
|
modem_poweron_off(0);
|
} else {
|
LOG("%s, invalid parameter.\n", __func__);
|
}
|
modem_status = new_state;
|
return count;
|
}
|
|
static ssize_t modem_status_show(struct class *cls,
|
struct class_attribute *attr,
|
char *buf)
|
{
|
return sprintf(buf, "%d\n", modem_status);
|
}
|
|
static CLASS_ATTR_RW(modem_status);
|
|
static int modem_platdata_parse_dt(struct device *dev,
|
struct lte_data *data)
|
{
|
struct device_node *node = dev->of_node;
|
int ret;
|
|
if (!node)
|
return -ENODEV;
|
memset(data, 0, sizeof(*data));
|
LOG("%s: LTE modem power controlled by gpio.\n", __func__);
|
data->vbat_gpio = devm_gpiod_get_optional(dev, "4G,vbat",
|
GPIOD_OUT_HIGH);
|
if (IS_ERR(data->vbat_gpio)) {
|
ret = PTR_ERR(data->vbat_gpio);
|
dev_err(dev, "failed to request 4G,vbat GPIO: %d\n", ret);
|
return ret;
|
}
|
data->power_gpio = devm_gpiod_get_optional(dev, "4G,power",
|
GPIOD_OUT_HIGH);
|
if (IS_ERR(data->power_gpio)) {
|
ret = PTR_ERR(data->power_gpio);
|
dev_err(dev, "failed to request 4G,power GPIO: %d\n", ret);
|
return ret;
|
}
|
data->reset_gpio = devm_gpiod_get_optional(dev, "4G,reset",
|
GPIOD_OUT_LOW);
|
if (IS_ERR(data->reset_gpio)) {
|
ret = PTR_ERR(data->reset_gpio);
|
dev_err(dev, "failed to request 4G,reset GPIO: %d\n", ret);
|
return ret;
|
}
|
return 0;
|
}
|
|
static int modem_power_on_thread(void *data)
|
{
|
modem_poweron_off(1);
|
return 0;
|
}
|
|
static int lte_probe(struct platform_device *pdev)
|
{
|
struct lte_data *pdata;
|
struct task_struct *kthread;
|
int ret = -1;
|
|
pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
|
if (!pdata)
|
return -ENOMEM;
|
ret = modem_platdata_parse_dt(&pdev->dev, pdata);
|
if (ret < 0) {
|
LOG("%s: No lte platform data specified\n", __func__);
|
goto err;
|
}
|
gpdata = pdata;
|
pdata->dev = &pdev->dev;
|
|
if (pdata->reset_gpio)
|
gpiod_direction_output(pdata->reset_gpio, 0);
|
kthread = kthread_run(modem_power_on_thread, NULL,
|
"modem_power_on_thread");
|
if (IS_ERR(kthread)) {
|
LOG("%s: create modem_power_on_thread failed.\n", __func__);
|
ret = PTR_ERR(kthread);
|
goto err;
|
}
|
return 0;
|
err:
|
gpdata = NULL;
|
return ret;
|
}
|
|
static int lte_suspend(struct platform_device *pdev, pm_message_t state)
|
{
|
return 0;
|
}
|
|
static int lte_resume(struct platform_device *pdev)
|
{
|
return 0;
|
}
|
|
static int lte_remove(struct platform_device *pdev)
|
{
|
struct lte_data *pdata = gpdata;
|
|
if (pdata->power_gpio) {
|
msleep(100);
|
gpiod_direction_output(pdata->power_gpio, 1);
|
msleep(750);
|
gpiod_direction_output(pdata->power_gpio, 0);
|
}
|
if (pdata->vbat_gpio)
|
gpiod_direction_output(pdata->vbat_gpio, 0);
|
gpdata = NULL;
|
return 0;
|
}
|
|
static const struct of_device_id modem_platdata_of_match[] = {
|
{ .compatible = "4g-modem-platdata" },
|
{ }
|
};
|
MODULE_DEVICE_TABLE(of, modem_platdata_of_match);
|
|
static struct platform_driver rm310_driver = {
|
.probe = lte_probe,
|
.remove = lte_remove,
|
.suspend = lte_suspend,
|
.resume = lte_resume,
|
.driver = {
|
.name = "4g-modem-platdata",
|
.of_match_table = of_match_ptr(modem_platdata_of_match),
|
},
|
};
|
|
static int __init rm310_init(void)
|
{
|
int ret;
|
|
modem_class = class_create(THIS_MODULE, "rk_modem");
|
ret = class_create_file(modem_class, &class_attr_modem_status);
|
if (ret)
|
LOG("Fail to create class modem_status.\n");
|
return platform_driver_register(&rm310_driver);
|
}
|
|
static void __exit rm310_exit(void)
|
{
|
platform_driver_unregister(&rm310_driver);
|
}
|
|
late_initcall(rm310_init);
|
module_exit(rm310_exit);
|
|
MODULE_AUTHOR("xuxuehui <xxh@rock-chips.com>");
|
MODULE_AUTHOR("Alex Zhao <zzc@rock-chips.com>");
|
MODULE_DESCRIPTION("RM310 lte modem driver");
|
MODULE_LICENSE("GPL");
|
