/*
|
* drivers/leds/leds-sunxi.c - Allwinner RGB LED Driver
|
*
|
* Copyright (C) 2018 Allwinner Technology Limited. All rights reserved.
|
* Albert Yu <yuxyun@allwinnertech.com>
|
*
|
* 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/module.h>
|
#include <linux/delay.h>
|
#include <linux/leds.h>
|
#include <linux/io.h>
|
#include <linux/of.h>
|
#include <linux/slab.h>
|
#include <linux/pm.h>
|
#include <linux/clk.h>
|
#include <linux/dmaengine.h>
|
#include <linux/interrupt.h>
|
#include <linux/platform_device.h>
|
#include <linux/pinctrl/consumer.h>
|
#include <linux/dma-mapping.h>
|
#include <linux/dma/sunxi-dma.h>
|
#include <linux/debugfs.h>
|
#include <linux/uaccess.h>
|
#include <linux/delay.h>
|
#include <linux/regulator/consumer.h>
|
|
#include "leds-sunxi.h"
|
|
/* For debug */
|
#define LED_ERR(fmt, arg...) pr_err("%s()%d - "fmt, __func__, __LINE__, ##arg)
|
|
static u32 debug_mask = 1;
|
#define dprintk(level_mask, fmt, arg...) \
|
do { \
|
if (unlikely(debug_mask & level_mask)) \
|
pr_warn("%s()%d - "fmt, __func__, __LINE__, ##arg); \
|
} while (0)
|
|
static struct sunxi_led *sunxi_led;
|
|
static void sunxi_ledc_trans_data(struct sunxi_led *led);
|
|
void led_dump_reg(struct sunxi_led *led, u32 offset, u32 len)
|
{
|
u32 i;
|
u8 buf[64], cnt = 0;
|
|
for (i = 0; i < len; i = i + REG_INTERVAL) {
|
if (i%HEXADECIMAL == 0)
|
cnt += sprintf(buf + cnt, "0x%08x: ",
|
(u32)(led->res->start + offset + i));
|
|
cnt += sprintf(buf + cnt, "%08x ",
|
readl(led->iomem_reg_base + offset + i));
|
|
if (i%HEXADECIMAL == REG_CL) {
|
pr_warn("%s\n", buf);
|
cnt = 0;
|
}
|
}
|
}
|
|
static void sunxi_clk_get(struct sunxi_led *led)
|
{
|
struct device *dev = led->dev;
|
struct device_node *np = dev->of_node;
|
|
led->clk_ledc = of_clk_get(np, 0);
|
if (IS_ERR(led->clk_ledc))
|
LED_ERR("failed to get clk_ledc!\n");
|
|
led->clk_cpuapb = of_clk_get(np, 1);
|
if (IS_ERR(led->clk_cpuapb))
|
LED_ERR("failed to get clk_cpuapb!\n");
|
}
|
|
static void sunxi_clk_put(struct sunxi_led *led)
|
{
|
clk_put(led->clk_ledc);
|
clk_put(led->clk_cpuapb);
|
led->clk_ledc = NULL;
|
led->clk_cpuapb = NULL;
|
}
|
|
static void sunxi_clk_enable(struct sunxi_led *led)
|
{
|
clk_prepare_enable(led->clk_ledc);
|
}
|
|
static void sunxi_clk_disable(struct sunxi_led *led)
|
{
|
clk_disable_unprepare(led->clk_ledc);
|
}
|
|
static void sunxi_clk_init(struct sunxi_led *led)
|
{
|
sunxi_clk_get(led);
|
sunxi_clk_enable(led);
|
}
|
|
static void sunxi_clk_deinit(struct sunxi_led *led)
|
{
|
sunxi_clk_disable(led);
|
sunxi_clk_put(led);
|
}
|
|
static u32 sunxi_get_reg(int offset)
|
{
|
struct sunxi_led *led = sunxi_led;
|
u32 value = ioread32(((u8 *)led->iomem_reg_base) + offset);
|
|
return value;
|
}
|
|
static void sunxi_set_reg(int offset, u32 value)
|
{
|
struct sunxi_led *led = sunxi_led;
|
|
iowrite32(value, ((u8 *)led->iomem_reg_base) + offset);
|
}
|
|
static inline void sunxi_set_reset_ns(struct sunxi_led *led)
|
{
|
u32 n, reg_val;
|
u32 mask = 0x1FFF;
|
u32 min = SUNXI_RESET_TIME_MIN_NS;
|
u32 max = SUNXI_RESET_TIME_MAX_NS;
|
|
if (led->reset_ns < min || led->reset_ns > max) {
|
LED_ERR("invalid parameter, reset_ns should be %u-%u!\n",
|
min, max);
|
return;
|
}
|
|
n = (led->reset_ns - 42) / 42;
|
reg_val = sunxi_get_reg(LED_RESET_TIMING_CTRL_REG_OFFSET);
|
reg_val &= ~(mask << 16);
|
reg_val |= (n << 16);
|
sunxi_set_reg(LED_RESET_TIMING_CTRL_REG_OFFSET, reg_val);
|
}
|
|
static inline void sunxi_set_t1h_ns(struct sunxi_led *led)
|
{
|
u32 n, reg_val;
|
u32 mask = 0x3F;
|
u32 shift = 21;
|
u32 min = SUNXI_T1H_MIN_NS;
|
u32 max = SUNXI_T1H_MAX_NS;
|
|
if (led->t1h_ns < min || led->t1h_ns > max) {
|
LED_ERR("invalid parameter, t1h_ns should be %u-%u!\n",
|
min, max);
|
return;
|
}
|
|
n = (led->t1h_ns - 42) / 42;
|
reg_val = sunxi_get_reg(LED_T01_TIMING_CTRL_REG_OFFSET);
|
reg_val &= ~(mask << shift);
|
reg_val |= n << shift;
|
sunxi_set_reg(LED_T01_TIMING_CTRL_REG_OFFSET, reg_val);
|
}
|
|
static inline void sunxi_set_t1l_ns(struct sunxi_led *led)
|
{
|
u32 n, reg_val;
|
u32 mask = 0x1F;
|
u32 shift = 16;
|
u32 min = SUNXI_T1L_MIN_NS;
|
u32 max = SUNXI_T1L_MAX_NS;
|
|
if (led->t1l_ns < min || led->t1l_ns > max) {
|
LED_ERR("invalid parameter, t1l_ns should be %u-%u!\n",
|
min, max);
|
return;
|
}
|
|
n = (led->t1l_ns - 42) / 42;
|
reg_val = sunxi_get_reg(LED_T01_TIMING_CTRL_REG_OFFSET);
|
reg_val &= ~(mask << shift);
|
reg_val |= n << shift;
|
sunxi_set_reg(LED_T01_TIMING_CTRL_REG_OFFSET, reg_val);
|
}
|
|
static inline void sunxi_set_t0h_ns(struct sunxi_led *led)
|
{
|
u32 n, reg_val;
|
u32 mask = 0x1F;
|
u32 shift = 6;
|
u32 min = SUNXI_T0H_MIN_NS;
|
u32 max = SUNXI_T0H_MAX_NS;
|
|
if (led->t0h_ns < min || led->t0h_ns > max) {
|
LED_ERR("invalid parameter, t0h_ns should be %u-%u!\n",
|
min, max);
|
return;
|
}
|
|
n = (led->t0h_ns - 42) / 42;
|
reg_val = sunxi_get_reg(LED_T01_TIMING_CTRL_REG_OFFSET);
|
reg_val &= ~(mask << shift);
|
reg_val |= n << shift;
|
sunxi_set_reg(LED_T01_TIMING_CTRL_REG_OFFSET, reg_val);
|
}
|
|
static inline void sunxi_set_t0l_ns(struct sunxi_led *led)
|
{
|
u32 n, reg_val;
|
u32 min = SUNXI_T0L_MIN_NS;
|
u32 max = SUNXI_T0L_MAX_NS;
|
|
if (led->t0l_ns < min || led->t0l_ns > max) {
|
LED_ERR("invalid parameter, t0l_ns should be %u-%u!\n",
|
min, max);
|
return;
|
}
|
|
n = (led->t0l_ns - 42) / 42;
|
reg_val = sunxi_get_reg(LED_T01_TIMING_CTRL_REG_OFFSET);
|
reg_val &= ~0x3F;
|
reg_val |= n;
|
sunxi_set_reg(LED_T01_TIMING_CTRL_REG_OFFSET, reg_val);
|
}
|
|
static inline void sunxi_set_wait_time0_ns(struct sunxi_led *led)
|
{
|
u32 n, reg_val;
|
u32 min = SUNXI_WAIT_TIME0_MIN_NS;
|
u32 max = SUNXI_WAIT_TIME0_MAX_NS;
|
|
if (led->wait_time0_ns < min || led->wait_time0_ns > max) {
|
LED_ERR("invalid parameter, wait_time0_ns should be %u-%u!\n",
|
min, max);
|
return;
|
}
|
|
n = (led->wait_time0_ns - 42) / 42;
|
reg_val = (1 << 8) | n;
|
sunxi_set_reg(LEDC_WAIT_TIME0_CTRL_REG, reg_val);
|
}
|
|
static inline void sunxi_set_wait_time1_ns(struct sunxi_led *led)
|
{
|
unsigned long long tmp, max = SUNXI_WAIT_TIME1_MAX_NS;
|
u32 min = SUNXI_WAIT_TIME1_MIN_NS;
|
u32 n, reg_val;
|
|
if (led->wait_time1_ns < min || led->wait_time1_ns > max) {
|
LED_ERR("invalid parameter, wait_time1_ns should be %u-%llu!\n",
|
min, max);
|
return;
|
}
|
|
tmp = led->wait_time1_ns;
|
n = div_u64(tmp, 42);
|
n -= 1;
|
reg_val = (1 << 31) | n;
|
sunxi_set_reg(LEDC_WAIT_TIME1_CTRL_REG, reg_val);
|
}
|
|
static inline void sunxi_set_wait_data_time_ns(struct sunxi_led *led)
|
{
|
u32 min, max;
|
#ifndef SUNXI_FPGA_LEDC
|
u32 mask = 0x1FFF, shift = 16, reg_val = 0, n;
|
#endif
|
min = SUNXI_WAIT_DATA_TIME_MIN_NS;
|
#ifdef SUNXI_FPGA_LEDC
|
/*
|
* For FPGA platforms, it is easy to meet wait data timeout for
|
* the obvious latency of task which is because of less cpu cores
|
* and lower cpu frequency compared with IC platforms, so here we
|
* permit long enough time latency.
|
*/
|
max = SUNXI_WAIT_DATA_TIME_MAX_NS_FPGA;
|
#else /* SUNXI_FPGA_LEDC */
|
max = SUNXI_WAIT_DATA_TIME_MAX_NS_IC;
|
#endif /* SUNXI_FPGA_LEDC */
|
|
if (led->wait_data_time_ns < min || led->wait_data_time_ns > max) {
|
LED_ERR("invalid parameter, wait_data_time_ns should be %u-%u!\n",
|
min, max);
|
return;
|
}
|
|
#ifndef SUNXI_FPGA_LEDC
|
n = (led->wait_data_time_ns - 42) / 42;
|
reg_val &= ~(mask << shift);
|
reg_val |= (n << shift);
|
sunxi_set_reg(LEDC_DATA_FINISH_CNT_REG_OFFSET, reg_val);
|
#endif /* SUNXI_FPGA_LEDC */
|
}
|
|
static void sunxi_ledc_set_time(struct sunxi_led *led)
|
{
|
sunxi_set_reset_ns(led);
|
sunxi_set_t1h_ns(led);
|
sunxi_set_t1l_ns(led);
|
sunxi_set_t0h_ns(led);
|
sunxi_set_t0l_ns(led);
|
sunxi_set_wait_time0_ns(led);
|
sunxi_set_wait_time1_ns(led);
|
sunxi_set_wait_data_time_ns(led);
|
}
|
|
static void sunxi_ledc_set_length(struct sunxi_led *led)
|
{
|
u32 reg_val;
|
u32 length = led->length;
|
|
if (length == 0)
|
return;
|
|
if (length > led->led_count)
|
return;
|
|
reg_val = sunxi_get_reg(LEDC_CTRL_REG_OFFSET);
|
reg_val &= ~(0x1FFF << 16);
|
reg_val |= length << 16;
|
sunxi_set_reg(LEDC_CTRL_REG_OFFSET, reg_val);
|
|
reg_val = sunxi_get_reg(LED_RESET_TIMING_CTRL_REG_OFFSET);
|
reg_val &= ~0x3FF;
|
reg_val |= length - 1;
|
sunxi_set_reg(LED_RESET_TIMING_CTRL_REG_OFFSET, reg_val);
|
}
|
|
static void sunxi_ledc_set_output_mode(struct sunxi_led *led, const char *str)
|
{
|
u32 val;
|
u32 mask = 0x7;
|
u32 shift = 6;
|
u32 reg_val = sunxi_get_reg(LEDC_CTRL_REG_OFFSET);
|
if (str != NULL) {
|
if (!strncmp(str, "GRB", 3))
|
val = SUNXI_OUTPUT_GRB;
|
else if (!strncmp(str, "GBR", 3))
|
val = SUNXI_OUTPUT_GBR;
|
else if (!strncmp(str, "RGB", 3))
|
val = SUNXI_OUTPUT_RGB;
|
else if (!strncmp(str, "RBG", 3))
|
val = SUNXI_OUTPUT_RBG;
|
else if (!strncmp(str, "BGR", 3))
|
val = SUNXI_OUTPUT_BGR;
|
else if (!strncmp(str, "BRG", 3))
|
val = SUNXI_OUTPUT_BRG;
|
else
|
return;
|
} else {
|
val = led->output_mode.val;
|
}
|
|
reg_val &= ~(mask << shift);
|
reg_val |= val;
|
|
sunxi_set_reg(LEDC_CTRL_REG_OFFSET, reg_val);
|
|
if (strncmp(str, led->output_mode.str, 3))
|
memcpy(led->output_mode.str, str, 3);
|
|
if (val != led->output_mode.val)
|
led->output_mode.val = val;
|
}
|
|
static void sunxi_ledc_enable_irq(u32 mask)
|
{
|
u32 reg_val = 0;
|
|
reg_val |= mask;
|
sunxi_set_reg(LEDC_INT_CTRL_REG_OFFSET, reg_val);
|
}
|
|
static void sunxi_ledc_disable_irq(u32 mask)
|
{
|
u32 reg_val = 0;
|
|
reg_val = sunxi_get_reg(LEDC_INT_CTRL_REG_OFFSET);
|
reg_val &= ~mask;
|
sunxi_set_reg(LEDC_INT_CTRL_REG_OFFSET, reg_val);
|
}
|
|
static inline void sunxi_ledc_enable(struct sunxi_led *led)
|
{
|
u32 reg_val;
|
|
reg_val = sunxi_get_reg(LEDC_CTRL_REG_OFFSET);
|
reg_val |= 1;
|
sunxi_set_reg(LEDC_CTRL_REG_OFFSET, reg_val);
|
}
|
|
static inline void sunxi_ledc_reset(struct sunxi_led *led)
|
{
|
u32 reg_val = sunxi_get_reg(LEDC_CTRL_REG_OFFSET);
|
|
sunxi_ledc_disable_irq(LEDC_TRANS_FINISH_INT_EN | LEDC_FIFO_CPUREQ_INT_EN
|
| LEDC_WAITDATA_TIMEOUT_INT_EN | LEDC_FIFO_OVERFLOW_INT_EN
|
| LEDC_GLOBAL_INT_EN);
|
|
if (debug_mask & DEBUG_INFO2) {
|
dprintk(DEBUG_INFO2, "dump reg:\n");
|
led_dump_reg(led, 0, 0x30);
|
}
|
|
if (led->dma_chan)
|
dmaengine_terminate_all(led->dma_chan);
|
|
reg_val |= 1 << 1;
|
sunxi_set_reg(LEDC_CTRL_REG_OFFSET, reg_val);
|
}
|
|
#ifdef CONFIG_DEBUG_FS
|
static ssize_t reset_ns_write(struct file *filp, const char __user *buf,
|
size_t count, loff_t *offp)
|
{
|
int err;
|
char buffer[64];
|
u32 min, max;
|
unsigned long val;
|
struct sunxi_led *led = sunxi_led;
|
|
min = SUNXI_RESET_TIME_MIN_NS;
|
max = SUNXI_RESET_TIME_MAX_NS;
|
|
if (count >= sizeof(buffer))
|
goto err_out;
|
|
if (copy_from_user(buffer, buf, count))
|
goto err_out;
|
|
buffer[count] = '\0';
|
|
err = kstrtoul(buffer, 10, &val);
|
if (err)
|
goto err_out;
|
|
if (val < min || val > max)
|
goto err_out;
|
|
led->reset_ns = val;
|
sunxi_set_reset_ns(led);
|
|
*offp += count;
|
|
return count;
|
|
err_out:
|
LED_ERR("invalid parameter, reset_ns should be %u-%u!\n",
|
min, max);
|
|
return -EINVAL;
|
}
|
|
static ssize_t reset_ns_read(struct file *filp, char __user *buf,
|
size_t count, loff_t *offp)
|
{
|
int r;
|
char buffer[64];
|
struct sunxi_led *led = sunxi_led;
|
|
r = snprintf(buffer, 64, "%u\n", led->reset_ns);
|
|
return simple_read_from_buffer(buf, count, offp, buffer, r);
|
}
|
|
static const struct file_operations reset_ns_fops = {
|
.owner = THIS_MODULE,
|
.write = reset_ns_write,
|
.read = reset_ns_read,
|
};
|
|
static ssize_t t1h_ns_write(struct file *filp, const char __user *buf,
|
size_t count, loff_t *offp)
|
{
|
int err;
|
char buffer[64];
|
u32 min, max;
|
unsigned long val;
|
struct sunxi_led *led = sunxi_led;
|
|
min = SUNXI_T1H_MIN_NS;
|
max = SUNXI_T1H_MAX_NS;
|
|
if (count >= sizeof(buffer))
|
return -EINVAL;
|
|
if (copy_from_user(buffer, buf, count))
|
return -EFAULT;
|
|
buffer[count] = '\0';
|
|
err = kstrtoul(buffer, 10, &val);
|
if (err)
|
return -EINVAL;
|
|
if (val < min || val > max)
|
goto err_out;
|
|
led->t1h_ns = val;
|
|
sunxi_set_t1h_ns(led);
|
|
*offp += count;
|
|
return count;
|
|
err_out:
|
LED_ERR("invalid parameter, t1h_ns should be %u-%u!\n",
|
min, max);
|
|
return -EINVAL;
|
}
|
|
static ssize_t t1h_ns_read(struct file *filp, char __user *buf,
|
size_t count, loff_t *offp)
|
{
|
int r;
|
char buffer[64];
|
struct sunxi_led *led = sunxi_led;
|
|
r = snprintf(buffer, 64, "%u\n", led->t1h_ns);
|
|
return simple_read_from_buffer(buf, count, offp, buffer, r);
|
}
|
|
static const struct file_operations t1h_ns_fops = {
|
.owner = THIS_MODULE,
|
.write = t1h_ns_write,
|
.read = t1h_ns_read,
|
};
|
|
static ssize_t t1l_ns_write(struct file *filp, const char __user *buf,
|
size_t count, loff_t *offp)
|
{
|
int err;
|
char buffer[64];
|
u32 min, max;
|
unsigned long val;
|
struct sunxi_led *led = sunxi_led;
|
|
min = SUNXI_T1L_MIN_NS;
|
max = SUNXI_T1L_MAX_NS;
|
|
if (count >= sizeof(buffer))
|
goto err_out;
|
|
if (copy_from_user(buffer, buf, count))
|
goto err_out;
|
|
buffer[count] = '\0';
|
|
err = kstrtoul(buffer, 10, &val);
|
if (err)
|
goto err_out;
|
|
if (val < min || val > max)
|
goto err_out;
|
|
led->t1l_ns = val;
|
sunxi_set_t1l_ns(led);
|
|
*offp += count;
|
|
return count;
|
|
err_out:
|
LED_ERR("invalid parameter, t1l_ns should be %u-%u!\n",
|
min, max);
|
|
return -EINVAL;
|
}
|
|
static ssize_t t1l_ns_read(struct file *filp, char __user *buf,
|
size_t count, loff_t *offp)
|
{
|
int r;
|
char buffer[64];
|
struct sunxi_led *led = sunxi_led;
|
|
r = snprintf(buffer, 64, "%u\n", led->t1l_ns);
|
|
return simple_read_from_buffer(buf, count, offp, buffer, r);
|
}
|
|
static const struct file_operations t1l_ns_fops = {
|
.owner = THIS_MODULE,
|
.write = t1l_ns_write,
|
.read = t1l_ns_read,
|
};
|
|
static ssize_t t0h_ns_write(struct file *filp, const char __user *buf,
|
size_t count, loff_t *offp)
|
{
|
int err;
|
char buffer[64];
|
u32 min, max;
|
unsigned long val;
|
struct sunxi_led *led = sunxi_led;
|
|
min = SUNXI_T0H_MIN_NS;
|
max = SUNXI_T0H_MAX_NS;
|
|
if (count >= sizeof(buffer))
|
goto err_out;
|
|
if (copy_from_user(buffer, buf, count))
|
goto err_out;
|
|
buffer[count] = '\0';
|
|
err = kstrtoul(buffer, 10, &val);
|
if (err)
|
goto err_out;
|
|
if (val < min || val > max)
|
goto err_out;
|
|
led->t0h_ns = val;
|
sunxi_set_t0h_ns(led);
|
|
*offp += count;
|
|
return count;
|
|
err_out:
|
LED_ERR("invalid parameter, t0h_ns should be %u-%u!\n",
|
min, max);
|
|
return -EINVAL;
|
}
|
|
static ssize_t t0h_ns_read(struct file *filp, char __user *buf,
|
size_t count, loff_t *offp)
|
{
|
int r;
|
char buffer[64];
|
struct sunxi_led *led = sunxi_led;
|
|
r = snprintf(buffer, 64, "%u\n", led->t0h_ns);
|
|
return simple_read_from_buffer(buf, count, offp, buffer, r);
|
}
|
|
static const struct file_operations t0h_ns_fops = {
|
.owner = THIS_MODULE,
|
.write = t0h_ns_write,
|
.read = t0h_ns_read,
|
};
|
|
static ssize_t t0l_ns_write(struct file *filp, const char __user *buf,
|
size_t count, loff_t *offp)
|
{
|
int err;
|
char buffer[64];
|
u32 min, max;
|
unsigned long val;
|
struct sunxi_led *led = sunxi_led;
|
|
min = SUNXI_T0L_MIN_NS;
|
max = SUNXI_T0L_MAX_NS;
|
|
if (count >= sizeof(buffer))
|
goto err_out;
|
|
if (copy_from_user(buffer, buf, count))
|
goto err_out;
|
|
buffer[count] = '\0';
|
|
err = kstrtoul(buffer, 10, &val);
|
if (err)
|
goto err_out;
|
|
if (val < min || val > max)
|
goto err_out;
|
|
led->t0l_ns = val;
|
sunxi_set_t0l_ns(led);
|
|
*offp += count;
|
|
return count;
|
|
err_out:
|
LED_ERR("invalid parameter, t0l_ns should be %u-%u!\n",
|
min, max);
|
|
return -EINVAL;
|
}
|
|
static ssize_t t0l_ns_read(struct file *filp, char __user *buf,
|
size_t count, loff_t *offp)
|
{
|
int r;
|
char buffer[64];
|
struct sunxi_led *led = sunxi_led;
|
|
r = snprintf(buffer, 64, "%u\n", led->t0l_ns);
|
|
return simple_read_from_buffer(buf, count, offp, buffer, r);
|
}
|
|
static const struct file_operations t0l_ns_fops = {
|
.owner = THIS_MODULE,
|
.write = t0l_ns_write,
|
.read = t0l_ns_read,
|
};
|
|
static ssize_t wait_time0_ns_write(struct file *filp, const char __user *buf,
|
size_t count, loff_t *offp)
|
{
|
int err;
|
char buffer[64];
|
u32 min, max;
|
unsigned long val;
|
struct sunxi_led *led = sunxi_led;
|
|
min = SUNXI_WAIT_TIME0_MIN_NS;
|
max = SUNXI_WAIT_TIME0_MAX_NS;
|
|
if (count >= sizeof(buffer))
|
goto err_out;
|
|
if (copy_from_user(buffer, buf, count))
|
goto err_out;
|
|
buffer[count] = '\0';
|
|
err = kstrtoul(buffer, 10, &val);
|
if (err)
|
goto err_out;
|
|
if (val < min || val > max)
|
goto err_out;
|
|
led->wait_time0_ns = val;
|
sunxi_set_wait_time0_ns(led);
|
|
*offp += count;
|
|
return count;
|
|
err_out:
|
LED_ERR("invalid parameter, wait_time0_ns should be %u-%u!\n",
|
min, max);
|
|
return -EINVAL;
|
}
|
|
static ssize_t wait_time0_ns_read(struct file *filp, char __user *buf,
|
size_t count, loff_t *offp)
|
{
|
int r;
|
char buffer[64];
|
struct sunxi_led *led = sunxi_led;
|
|
r = snprintf(buffer, 64, "%u\n", led->wait_time0_ns);
|
|
return simple_read_from_buffer(buf, count, offp, buffer, r);
|
}
|
|
static const struct file_operations wait_time0_ns_fops = {
|
.owner = THIS_MODULE,
|
.write = wait_time0_ns_write,
|
.read = wait_time0_ns_read,
|
};
|
|
static ssize_t wait_time1_ns_write(struct file *filp, const char __user *buf,
|
size_t count, loff_t *offp)
|
{
|
int err;
|
char buffer[64];
|
u32 min;
|
unsigned long long max;
|
unsigned long long val;
|
struct sunxi_led *led = sunxi_led;
|
|
min = SUNXI_WAIT_TIME1_MIN_NS;
|
max = SUNXI_WAIT_TIME1_MAX_NS;
|
|
if (count >= sizeof(buffer))
|
goto err_out;
|
|
if (copy_from_user(buffer, buf, count))
|
goto err_out;
|
|
buffer[count] = '\0';
|
|
err = kstrtoull(buffer, 10, &val);
|
if (err)
|
goto err_out;
|
|
if (val < min || val > max)
|
goto err_out;
|
|
led->wait_time1_ns = val;
|
sunxi_set_wait_time1_ns(led);
|
|
*offp += count;
|
|
return count;
|
|
err_out:
|
LED_ERR("invalid parameter, wait_time1_ns should be %u-%lld!\n",
|
min, max);
|
|
return -EINVAL;
|
}
|
|
static ssize_t wait_time1_ns_read(struct file *filp, char __user *buf,
|
size_t count, loff_t *offp)
|
{
|
int r;
|
char buffer[64];
|
struct sunxi_led *led = sunxi_led;
|
|
r = snprintf(buffer, 64, "%lld\n", led->wait_time1_ns);
|
|
return simple_read_from_buffer(buf, count, offp, buffer, r);
|
}
|
|
static const struct file_operations wait_time1_ns_fops = {
|
.owner = THIS_MODULE,
|
.write = wait_time1_ns_write,
|
.read = wait_time1_ns_read,
|
};
|
|
static ssize_t wait_data_time_ns_write(struct file *filp,
|
const char __user *buf,
|
size_t count, loff_t *offp)
|
{
|
int err;
|
char buffer[64];
|
u32 min, max;
|
unsigned long val;
|
struct sunxi_led *led = sunxi_led;
|
|
min = SUNXI_WAIT_DATA_TIME_MIN_NS;
|
#ifdef SUNXI_FPGA_LEDC
|
max = SUNXI_WAIT_DATA_TIME_MAX_NS_FPGA;
|
#else
|
max = SUNXI_WAIT_DATA_TIME_MAX_NS_IC;
|
#endif
|
|
if (count >= sizeof(buffer))
|
goto err_out;
|
|
if (copy_from_user(buffer, buf, count))
|
goto err_out;
|
|
buffer[count] = '\0';
|
|
err = kstrtoul(buffer, 10, &val);
|
if (err)
|
goto err_out;
|
|
if (val < min || val > max)
|
goto err_out;
|
|
led->wait_data_time_ns = val;
|
sunxi_set_wait_data_time_ns(led);
|
|
*offp += count;
|
|
return count;
|
|
err_out:
|
LED_ERR("invalid parameter, wait_data_time_ns should be %u-%u!\n",
|
min, max);
|
|
return -EINVAL;
|
}
|
|
static ssize_t wait_data_time_ns_read(struct file *filp, char __user *buf,
|
size_t count, loff_t *offp)
|
{
|
int r;
|
char buffer[64];
|
struct sunxi_led *led = sunxi_led;
|
|
r = snprintf(buffer, 64, "%u\n", led->wait_data_time_ns);
|
|
return simple_read_from_buffer(buf, count, offp, buffer, r);
|
}
|
|
static const struct file_operations wait_data_time_ns_fops = {
|
.owner = THIS_MODULE,
|
.write = wait_data_time_ns_write,
|
.read = wait_data_time_ns_read,
|
};
|
|
static int data_show(struct seq_file *s, void *data)
|
{
|
int i;
|
struct sunxi_led *led = sunxi_led;
|
|
for (i = 0; i < led->led_count; i++) {
|
if (!(i % 4)) {
|
if (i + 4 <= led->led_count)
|
seq_printf(s, "%04d-%04d", i, i + 4);
|
else
|
seq_printf(s, "%04d-%04d", i, led->led_count);
|
}
|
seq_printf(s, " 0x%08x", led->data[i]);
|
if (((i % 4) == 3) || (i == led->led_count - 1))
|
seq_puts(s, "\n");
|
}
|
|
return 0;
|
}
|
|
static void sunxi_ledc_set_dma_mode(struct sunxi_led *led)
|
{
|
u32 reg_val = 0;
|
|
reg_val |= 1 << 5;
|
sunxi_set_reg(LEDC_DMA_CTRL_REG, reg_val);
|
|
sunxi_ledc_disable_irq(LEDC_FIFO_CPUREQ_INT_EN);
|
}
|
|
static void sunxi_ledc_set_cpu_mode(struct sunxi_led *led)
|
{
|
u32 reg_val = 0;
|
|
reg_val &= ~(1 << 5);
|
sunxi_set_reg(LEDC_DMA_CTRL_REG, reg_val);
|
|
sunxi_ledc_enable_irq(LEDC_FIFO_CPUREQ_INT_EN);
|
}
|
|
static int data_open(struct inode *inode, struct file *file)
|
{
|
return single_open(file, data_show, inode->i_private);
|
}
|
|
static const struct file_operations data_fops = {
|
.owner = THIS_MODULE,
|
.open = data_open,
|
.read = seq_read,
|
.llseek = seq_lseek,
|
.release = single_release,
|
};
|
|
static ssize_t output_mode_write(struct file *filp, const char __user *buf,
|
size_t count, loff_t *offp)
|
{
|
char buffer[64];
|
struct sunxi_led *led = sunxi_led;
|
|
if (count >= sizeof(buffer))
|
goto err_out;
|
|
if (copy_from_user(buffer, buf, count))
|
goto err_out;
|
|
buffer[count] = '\0';
|
|
sunxi_ledc_set_output_mode(led, buffer);
|
|
*offp += count;
|
|
return count;
|
|
err_out:
|
LED_ERR("invalid parameter!\n");
|
|
return -EINVAL;
|
}
|
|
static ssize_t output_mode_read(struct file *filp, char __user *buf,
|
size_t count, loff_t *offp)
|
{
|
int r;
|
char buffer[64];
|
struct sunxi_led *led = sunxi_led;
|
|
r = snprintf(buffer, 64, "%s\n", led->output_mode.str);
|
|
return simple_read_from_buffer(buf, count, offp, buffer, r);
|
}
|
|
static const struct file_operations output_mode_fops = {
|
.owner = THIS_MODULE,
|
.write = output_mode_write,
|
.read = output_mode_read,
|
};
|
|
static ssize_t hwversion_read(struct file *filp, char __user *buf,
|
size_t count, loff_t *offp)
|
{
|
int r;
|
char buffer[64];
|
u32 reg_val, major_ver, minor_ver;
|
|
reg_val = sunxi_get_reg(LEDC_VER_NUM_REG);
|
major_ver = reg_val >> 16;
|
minor_ver = reg_val & 0xF;
|
|
r = snprintf(buffer, 64, "r%up%u\n", major_ver, minor_ver);
|
|
return simple_read_from_buffer(buf, count, offp, buffer, r);
|
}
|
|
static const struct file_operations hwversion_fops = {
|
.owner = THIS_MODULE,
|
.read = hwversion_read,
|
};
|
|
static void sunxi_led_create_debugfs(struct sunxi_led *led)
|
{
|
struct dentry *debugfs_dir, *debugfs_file;
|
|
debugfs_dir = debugfs_create_dir("sunxi_leds", NULL);
|
if (IS_ERR_OR_NULL(debugfs_dir)) {
|
LED_ERR("debugfs_create_dir failed!\n");
|
return;
|
}
|
|
led->debugfs_dir = debugfs_dir;
|
|
debugfs_file = debugfs_create_file("reset_ns", 0660,
|
debugfs_dir, NULL, &reset_ns_fops);
|
if (!debugfs_file)
|
LED_ERR("debugfs_create_file for reset_ns failed!\n");
|
|
debugfs_file = debugfs_create_file("t1h_ns", 0660,
|
debugfs_dir, NULL, &t1h_ns_fops);
|
if (!debugfs_file)
|
LED_ERR("debugfs_create_file for t1h_ns failed!\n");
|
|
debugfs_file = debugfs_create_file("t1l_ns", 0660,
|
debugfs_dir, NULL, &t1l_ns_fops);
|
if (!debugfs_file)
|
LED_ERR("debugfs_create_file for t1l_ns failed!\n");
|
|
debugfs_file = debugfs_create_file("t0h_ns", 0660,
|
debugfs_dir, NULL, &t0h_ns_fops);
|
if (!debugfs_file)
|
LED_ERR("debugfs_create_file for t0h_ns failed!\n");
|
|
debugfs_file = debugfs_create_file("t0l_ns", 0660,
|
debugfs_dir, NULL, &t0l_ns_fops);
|
if (!debugfs_file)
|
LED_ERR("debugfs_create_file for t0l_ns failed!\n");
|
|
debugfs_file = debugfs_create_file("wait_time0_ns", 0660,
|
debugfs_dir, NULL, &wait_time0_ns_fops);
|
if (!debugfs_file)
|
LED_ERR("debugfs_create_file for wait_time0_ns failed!\n");
|
|
debugfs_file = debugfs_create_file("wait_time1_ns", 0660,
|
debugfs_dir, NULL, &wait_time1_ns_fops);
|
if (!debugfs_file)
|
LED_ERR("debugfs_create_file for wait_time1_ns failed!\n");
|
|
debugfs_file = debugfs_create_file("wait_data_time_ns", 0660,
|
debugfs_dir, NULL, &wait_data_time_ns_fops);
|
if (!debugfs_file)
|
LED_ERR("debugfs_create_file for wait_data_time_ns failed!\n");
|
|
debugfs_file = debugfs_create_file("data", 0440,
|
debugfs_dir, NULL, &data_fops);
|
if (!debugfs_file)
|
LED_ERR("debugfs_create_file for data failed!\n");
|
|
debugfs_file = debugfs_create_file("output_mode", 0660,
|
debugfs_dir, NULL, &output_mode_fops);
|
if (!debugfs_file)
|
LED_ERR("debugfs_create_file for output_mode failed!\n");
|
|
if (!debugfs_file)
|
LED_ERR("debugfs_create_file for trans_mode failed!\n");
|
|
debugfs_file = debugfs_create_file("hwversion", 0440,
|
debugfs_dir, NULL, &hwversion_fops);
|
if (!debugfs_file)
|
LED_ERR("debugfs_create_file for hwversion failed!\n");
|
}
|
|
static void sunxi_led_remove_debugfs(struct sunxi_led *led)
|
{
|
debugfs_remove_recursive(led->debugfs_dir);
|
}
|
#endif /* CONFIG_DEBUG_FS */
|
|
static void sunxi_ledc_dma_callback(void *param)
|
{
|
dprintk(DEBUG_INFO, "finish\n");
|
}
|
|
static void sunxi_ledc_trans_data(struct sunxi_led *led)
|
{
|
int i, err;
|
size_t size;
|
unsigned int slave_id;
|
unsigned long flags;
|
phys_addr_t dst_addr;
|
struct dma_slave_config slave_config;
|
struct device *dev = led->dev;
|
struct dma_async_tx_descriptor *dma_desc;
|
|
if (led->length <= SUNXI_LEDC_FIFO_DEPTH) {
|
dprintk(DEBUG_INFO, "cpu xfer\n");
|
led->start_time = current_kernel_time64();
|
sunxi_ledc_set_time(led);
|
sunxi_ledc_set_output_mode(led, led->output_mode.str);
|
sunxi_ledc_set_cpu_mode(led);
|
sunxi_ledc_set_length(led);
|
sunxi_ledc_enable_irq(LEDC_TRANS_FINISH_INT_EN
|
| LEDC_WAITDATA_TIMEOUT_INT_EN
|
| LEDC_FIFO_OVERFLOW_INT_EN
|
| LEDC_GLOBAL_INT_EN);
|
sunxi_ledc_enable(led);
|
|
for (i = 0; i < led->length; i++)
|
sunxi_set_reg(LEDC_DATA_REG_OFFSET, led->data[i]);
|
} else {
|
dprintk(DEBUG_INFO, "dma xfer\n");
|
size = led->length * 4;
|
led->src_dma = dma_map_single(dev, led->data,
|
size, DMA_TO_DEVICE);
|
|
dst_addr = led->res->start + LEDC_DATA_REG_OFFSET;
|
slave_id = sunxi_slave_id(DRQDST_LEDC, DRQSRC_SDRAM);
|
flags = DMA_PREP_INTERRUPT | DMA_CTRL_ACK;
|
|
slave_config.direction = DMA_MEM_TO_DEV;
|
slave_config.src_addr = led->src_dma;
|
slave_config.dst_addr = dst_addr;
|
slave_config.src_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
|
slave_config.dst_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
|
slave_config.src_maxburst = 4;
|
slave_config.dst_maxburst = 4;
|
slave_config.slave_id = slave_id;
|
err = dmaengine_slave_config(led->dma_chan, &slave_config);
|
if (err < 0) {
|
LED_ERR("dmaengine_slave_config failed!\n");
|
dma_unmap_single(dev, led->src_dma,
|
size, DMA_TO_DEVICE);
|
return;
|
}
|
|
dma_desc = dmaengine_prep_slave_single(led->dma_chan,
|
led->src_dma,
|
size,
|
DMA_MEM_TO_DEV,
|
flags);
|
if (!dma_desc) {
|
LED_ERR("dmaengine_prep_slave_single failed!\n");
|
dma_unmap_single(dev, led->src_dma,
|
size, DMA_TO_DEVICE);
|
return;
|
}
|
|
dma_desc->callback = sunxi_ledc_dma_callback;
|
|
dmaengine_submit(dma_desc);
|
dma_async_issue_pending(led->dma_chan);
|
|
led->start_time = current_kernel_time64();
|
sunxi_ledc_set_time(led);
|
sunxi_ledc_set_output_mode(led, led->output_mode.str);
|
sunxi_ledc_set_dma_mode(led);
|
sunxi_ledc_set_length(led);
|
sunxi_ledc_enable_irq(LEDC_TRANS_FINISH_INT_EN | LEDC_WAITDATA_TIMEOUT_INT_EN
|
| LEDC_FIFO_OVERFLOW_INT_EN | LEDC_GLOBAL_INT_EN);
|
sunxi_ledc_enable(led);
|
}
|
}
|
|
static inline void sunxi_ledc_clear_all_irq(void)
|
{
|
u32 reg_val = sunxi_get_reg(LEDC_INT_STS_REG_OFFSET);
|
|
reg_val &= ~0x1F;
|
sunxi_set_reg(LEDC_INT_STS_REG_OFFSET, reg_val);
|
}
|
|
static inline void sunxi_ledc_clear_irq(enum sunxi_ledc_irq_status_reg irq)
|
{
|
u32 reg_val = sunxi_get_reg(LEDC_INT_STS_REG_OFFSET);
|
|
reg_val &= ~irq;
|
sunxi_set_reg(LEDC_INT_STS_REG_OFFSET, reg_val);
|
}
|
|
static int sunxi_ledc_complete(struct sunxi_led *led)
|
{
|
unsigned long flags = 0;
|
unsigned long timeout = 0;
|
|
timeout = wait_event_timeout(led->wait, led->result, 5*HZ);
|
if (timeout == 0) {
|
LED_ERR("led xfer timeout\n");
|
return -ETIME;
|
} else if (led->result == RESULT_ERR) {
|
return -ECOMM;
|
}
|
|
dprintk(DEBUG_INFO, "xfer complete\n");
|
|
spin_lock_irqsave(&led->lock, flags);
|
led->result = 0;
|
spin_unlock_irqrestore(&led->lock, flags);
|
|
return 0;
|
}
|
|
|
static irqreturn_t sunxi_ledc_irq_handler(int irq, void *dev_id)
|
{
|
unsigned long flags;
|
long delta_time_ns;
|
u32 irq_status, max_ns;
|
struct sunxi_led *led = sunxi_led;
|
struct device *dev = led->dev;
|
struct timespec64 current_time;
|
|
spin_lock_irqsave(&led->lock, flags);
|
|
irq_status = sunxi_get_reg(LEDC_INT_STS_REG_OFFSET);
|
|
sunxi_ledc_clear_all_irq();
|
|
if (irq_status & LEDC_TRANS_FINISH_INT) {
|
if (led->dma_chan)
|
dma_unmap_single(dev,
|
led->src_dma, led->length * 4,
|
DMA_TO_DEVICE);
|
sunxi_ledc_reset(led);
|
led->length = 0;
|
led->result = RESULT_COMPLETE;
|
wake_up(&led->wait);
|
goto out;
|
}
|
|
if (irq_status & LEDC_WAITDATA_TIMEOUT_INT) {
|
current_time = current_kernel_time64();
|
delta_time_ns = current_time.tv_sec - led->start_time.tv_sec;
|
delta_time_ns *= 1000 * 1000 * 1000;
|
delta_time_ns += current_time.tv_nsec - led->start_time.tv_nsec;
|
|
max_ns = led->wait_data_time_ns;
|
|
if (delta_time_ns <= max_ns) {
|
spin_unlock_irqrestore(&led->lock, flags);
|
return IRQ_HANDLED;
|
}
|
|
if (led->dma_chan)
|
dmaengine_terminate_all(led->dma_chan);
|
|
sunxi_ledc_reset(led);
|
|
if (delta_time_ns <= max_ns * 2) {
|
sunxi_ledc_trans_data(led);
|
} else {
|
LED_ERR("wait time is more than %d ns,"
|
"going to reset ledc and drop this operation!\n",
|
max_ns);
|
led->result = RESULT_ERR;
|
wake_up(&led->wait);
|
led->length = 0;
|
}
|
|
goto out;
|
}
|
|
if (irq_status & LEDC_FIFO_OVERFLOW_INT) {
|
LED_ERR("there exists fifo overflow issue, irq_status=0x%x!\n",
|
irq_status);
|
sunxi_ledc_reset(led);
|
led->result = RESULT_ERR;
|
wake_up(&led->wait);
|
led->length = 0;
|
goto out;
|
}
|
|
out:
|
spin_unlock_irqrestore(&led->lock, flags);
|
return IRQ_HANDLED;
|
}
|
|
static int sunxi_ledc_irq_init(struct sunxi_led *led)
|
{
|
int err;
|
struct device *dev = led->dev;
|
unsigned long flags = 0;
|
const char *name = "ledcirq";
|
struct platform_device *pdev;
|
|
pdev = container_of(dev, struct platform_device, dev);
|
|
spin_lock_init(&led->lock);
|
|
led->irqnum = platform_get_irq(pdev, 0);
|
if (led->irqnum < 0)
|
LED_ERR("failed to get ledc irq!\n");
|
|
err = request_irq(led->irqnum, sunxi_ledc_irq_handler,
|
flags, name, dev);
|
if (err) {
|
LED_ERR("failed to install IRQ handler for irqnum %d\n",
|
led->irqnum);
|
return -EPERM;
|
}
|
|
return 0;
|
}
|
|
static void sunxi_ledc_irq_deinit(struct sunxi_led *led)
|
{
|
free_irq(led->irqnum, led->dev);
|
sunxi_ledc_disable_irq(LEDC_TRANS_FINISH_INT_EN | LEDC_FIFO_CPUREQ_INT_EN
|
| LEDC_WAITDATA_TIMEOUT_INT_EN | LEDC_FIFO_OVERFLOW_INT_EN
|
| LEDC_GLOBAL_INT_EN);
|
}
|
|
static void sunxi_ledc_pinctrl_init(struct sunxi_led *led)
|
{
|
struct device *dev = led->dev;
|
struct pinctrl *pinctrl = devm_pinctrl_get_select_default(dev);
|
|
led->pctrl = pinctrl;
|
if (IS_ERR(pinctrl))
|
LED_ERR("devm_pinctrl_get_select_default failed!\n");
|
}
|
|
static int led_regulator_request(struct sunxi_led *led)
|
{
|
struct regulator *regu = NULL;
|
|
/* Consider "n*" as nocare. Support "none", "nocare", "null", "" etc. */
|
if ((led->regulator_id[0] == 'n') || (led->regulator_id[0] == 0))
|
return 0;
|
|
regu = regulator_get(NULL, led->regulator_id);
|
if (IS_ERR(regu)) {
|
LED_ERR("get regulator %s failed!\n", led->regulator_id);
|
return -1;
|
}
|
led->regulator = regu;
|
|
return 0;
|
}
|
|
static int led_regulator_release(struct sunxi_led *led)
|
{
|
if (led->regulator == NULL)
|
return 0;
|
|
regulator_put(led->regulator);
|
led->regulator = NULL;
|
|
return 1;
|
}
|
|
static int sunxi_set_led_brightness(struct led_classdev *led_cdev,
|
enum led_brightness value)
|
{
|
unsigned long flags;
|
u32 r = 0, g = 0, b = 0, shift, old_data, new_data, length;
|
struct sunxi_led_info *pinfo;
|
struct sunxi_led_classdev_group *pcdev_group;
|
struct sunxi_led *led = sunxi_led;
|
unsigned long diff_time;
|
struct timeval start, end;
|
|
do_gettimeofday(&start);
|
pinfo = container_of(led_cdev, struct sunxi_led_info, cdev);
|
|
switch (pinfo->type) {
|
case LED_TYPE_G:
|
pcdev_group = container_of(pinfo,
|
struct sunxi_led_classdev_group, g);
|
g = value;
|
shift = 16;
|
break;
|
case LED_TYPE_R:
|
pcdev_group = container_of(pinfo,
|
struct sunxi_led_classdev_group, r);
|
r = value;
|
shift = 8;
|
break;
|
|
case LED_TYPE_B:
|
pcdev_group = container_of(pinfo,
|
struct sunxi_led_classdev_group, b);
|
b = value;
|
shift = 0;
|
break;
|
default:
|
LED_ERR("led not support %d type!\n",
|
pinfo->type);
|
return -EINVAL;
|
}
|
|
old_data = led->data[pcdev_group->led_num];
|
if (((old_data >> shift) & 0xFF) == value)
|
return 0;
|
|
if (pinfo->type != LED_TYPE_R)
|
r = pcdev_group->r.cdev.brightness;
|
if (pinfo->type != LED_TYPE_G)
|
g = pcdev_group->g.cdev.brightness;
|
if (pinfo->type != LED_TYPE_B)
|
b = pcdev_group->b.cdev.brightness;
|
|
/* LEDC treats input data as GRB by default */
|
new_data = (g << 16) | (r << 8) | b;
|
length = pcdev_group->led_num + 1;
|
|
spin_lock_irqsave(&led->lock, flags);
|
led->data[pcdev_group->led_num] = new_data;
|
led->length = length;
|
spin_unlock_irqrestore(&led->lock, flags);
|
|
sunxi_ledc_trans_data(led);
|
if (debug_mask & DEBUG_INFO2) {
|
dprintk(DEBUG_INFO2, "dump reg:\n");
|
led_dump_reg(led, 0, 0x30);
|
}
|
|
sunxi_ledc_complete(led);
|
|
do_gettimeofday(&end);
|
diff_time = 1000000 * (end.tv_sec - start.tv_sec) + end.tv_usec
|
- start.tv_usec;
|
if (debug_mask & DEBUG_INFO1)
|
pr_warn("num = %03u, time = %ld us\n", length, diff_time);
|
|
return 0;
|
}
|
|
static int sunxi_register_led_classdev(struct sunxi_led *led)
|
{
|
int i, err;
|
size_t size;
|
struct device *dev = led->dev;
|
struct led_classdev *pcdev;
|
|
if (!led->led_count)
|
led->led_count = SUNXI_DEFAULT_LED_COUNT;
|
|
size = sizeof(struct sunxi_led_classdev_group) * led->led_count;
|
led->pcdev_group = kzalloc(size, GFP_KERNEL);
|
if (!led->pcdev_group)
|
return -ENOMEM;
|
|
for (i = 0; i < led->led_count; i++) {
|
led->pcdev_group[i].r.type = LED_TYPE_R;
|
pcdev = &led->pcdev_group[i].r.cdev;
|
pcdev->name = kzalloc(16, GFP_KERNEL);
|
sprintf((char *)pcdev->name, "sunxi_led%dr", i);
|
pcdev->brightness = LED_OFF;
|
pcdev->brightness_set_blocking = sunxi_set_led_brightness;
|
pcdev->dev = dev;
|
err = led_classdev_register(dev, pcdev);
|
if (err < 0) {
|
LED_ERR("led_classdev_register %s failed!\n",
|
pcdev->name);
|
return err;
|
}
|
|
led->pcdev_group[i].g.type = LED_TYPE_G;
|
pcdev = &led->pcdev_group[i].g.cdev;
|
pcdev->name = kzalloc(16, GFP_KERNEL);
|
sprintf((char *)pcdev->name, "sunxi_led%dg", i);
|
pcdev->brightness = LED_OFF;
|
pcdev->brightness_set_blocking = sunxi_set_led_brightness;
|
pcdev->dev = dev;
|
err = led_classdev_register(dev, pcdev);
|
if (err < 0) {
|
LED_ERR("led_classdev_register %s failed!\n",
|
pcdev->name);
|
return err;
|
}
|
|
led->pcdev_group[i].b.type = LED_TYPE_B;
|
pcdev = &led->pcdev_group[i].b.cdev;
|
pcdev->name = kzalloc(16, GFP_KERNEL);
|
sprintf((char *)pcdev->name, "sunxi_led%db", i);
|
pcdev->brightness = LED_OFF;
|
pcdev->brightness_set_blocking = sunxi_set_led_brightness;
|
pcdev->dev = dev;
|
err = led_classdev_register(dev, pcdev);
|
if (err < 0) {
|
LED_ERR("led_classdev_register %s failed!\n",
|
pcdev->name);
|
return err;
|
}
|
|
led->pcdev_group[i].led_num = i;
|
}
|
|
size = sizeof(u32) * led->led_count;
|
led->data = kzalloc(size, GFP_KERNEL);
|
if (!led->data)
|
return -ENOMEM;
|
|
return 0;
|
}
|
|
static void sunxi_unregister_led_classdev(struct sunxi_led *led)
|
{
|
int i;
|
|
for (i = 0; i < led->led_count; i++) {
|
kfree(led->pcdev_group[i].b.cdev.name);
|
led->pcdev_group[i].b.cdev.name = NULL;
|
kfree(led->pcdev_group[i].g.cdev.name);
|
led->pcdev_group[i].g.cdev.name = NULL;
|
kfree(led->pcdev_group[i].r.cdev.name);
|
led->pcdev_group[i].r.cdev.name = NULL;
|
led_classdev_unregister(&led->pcdev_group[i].b.cdev);
|
led_classdev_unregister(&led->pcdev_group[i].g.cdev);
|
led_classdev_unregister(&led->pcdev_group[i].r.cdev);
|
}
|
kfree(led->data);
|
led->data = NULL;
|
|
|
kfree(led->pcdev_group);
|
led->pcdev_group = NULL;
|
}
|
|
static inline int sunxi_get_u32_of_property(const char *propname, int *val)
|
{
|
int err;
|
struct sunxi_led *led = sunxi_led;
|
struct device *dev = led->dev;
|
struct device_node *np = dev->of_node;
|
|
err = of_property_read_u32(np, propname, val);
|
if (err < 0)
|
LED_ERR("failed to get the value of propname %s!\n", propname);
|
|
return err;
|
}
|
|
static inline int sunxi_get_str_of_property(const char *propname,
|
const char **out_string)
|
{
|
int err;
|
struct sunxi_led *led = sunxi_led;
|
struct device *dev = led->dev;
|
struct device_node *np = dev->of_node;
|
|
err = of_property_read_string(np, propname, out_string);
|
if (err < 0)
|
LED_ERR("failed to get the string of propname %s!\n", propname);
|
|
return err;
|
}
|
|
static void sunxi_get_para_of_property(struct sunxi_led *led)
|
{
|
int err;
|
u32 val;
|
const char *str;
|
|
err = sunxi_get_u32_of_property("led_count", &val);
|
if (!err)
|
led->led_count = val;
|
|
memcpy(led->output_mode.str, "GRB", 3);
|
led->output_mode.val = SUNXI_OUTPUT_GRB;
|
err = sunxi_get_str_of_property("output_mode", &str);
|
if (!err)
|
if (!strncmp(str, "BRG", 3) ||
|
!strncmp(str, "GBR", 3) ||
|
!strncmp(str, "RGB", 3) ||
|
!strncmp(str, "RBG", 3) ||
|
!strncmp(str, "BGR", 3) ||
|
!strncmp(str, "BRG", 3))
|
memcpy(led->output_mode.str, str, 3);
|
|
err = sunxi_get_str_of_property("led_regulator", &str);
|
if (!err) {
|
if (strlen(str) >= sizeof(led->regulator_id))
|
LED_ERR("illegal regulator id\n");
|
else {
|
strcpy(led->regulator_id, str);
|
pr_info("led_regulator: %s\n", led->regulator_id);
|
}
|
}
|
|
err = sunxi_get_u32_of_property("reset_ns", &val);
|
if (!err)
|
led->reset_ns = val;
|
|
err = sunxi_get_u32_of_property("t1h_ns", &val);
|
if (!err)
|
led->t1h_ns = val;
|
|
err = sunxi_get_u32_of_property("t1l_ns", &val);
|
if (!err)
|
led->t1l_ns = val;
|
|
err = sunxi_get_u32_of_property("t0h_ns", &val);
|
if (!err)
|
led->t0h_ns = val;
|
|
err = sunxi_get_u32_of_property("t0l_ns", &val);
|
if (!err)
|
led->t0l_ns = val;
|
|
err = sunxi_get_u32_of_property("wait_time0_ns", &val);
|
if (!err)
|
led->wait_time0_ns = val;
|
|
err = sunxi_get_u32_of_property("wait_time1_ns", &val);
|
if (!err)
|
led->wait_time1_ns = val;
|
|
err = sunxi_get_u32_of_property("wait_data_time_ns", &val);
|
if (!err)
|
led->wait_data_time_ns = val;
|
}
|
void sunxi_led_set_all(struct sunxi_led *led, u8 channel,
|
enum led_brightness value)
|
{
|
u32 i;
|
struct led_classdev *led_cdev;
|
|
if (channel%3 == 0) {
|
for (i = 0; i < led->led_count; i++) {
|
led_cdev = &led->pcdev_group[i].r.cdev;
|
mutex_lock(&led_cdev->led_access);
|
sunxi_set_led_brightness(led_cdev, value);
|
mutex_unlock(&led_cdev->led_access);
|
}
|
} else if (channel%3 == 1) {
|
for (i = 0; i < led->led_count; i++) {
|
led_cdev = &led->pcdev_group[i].g.cdev;
|
mutex_lock(&led_cdev->led_access);
|
sunxi_set_led_brightness(led_cdev, value);
|
mutex_unlock(&led_cdev->led_access);
|
}
|
} else {
|
for (i = 0; i < led->led_count; i++) {
|
led_cdev = &led->pcdev_group[i].b.cdev;
|
mutex_lock(&led_cdev->led_access);
|
sunxi_set_led_brightness(led_cdev, value);
|
mutex_unlock(&led_cdev->led_access);
|
}
|
}
|
}
|
static ssize_t
|
led_show(struct class *class, struct class_attribute *attr, char *buf)
|
{
|
struct sunxi_led *led = sunxi_led;
|
|
sunxi_led_set_all(led, 0, 0);
|
sunxi_led_set_all(led, 1, 0);
|
sunxi_led_set_all(led, 2, 0);
|
|
sunxi_led_set_all(led, 0, 20);
|
msleep(500);
|
sunxi_led_set_all(led, 1, 20);
|
msleep(500);
|
sunxi_led_set_all(led, 2, 20);
|
msleep(500);
|
|
sunxi_led_set_all(led, 0, 0);
|
sunxi_led_set_all(led, 1, 0);
|
sunxi_led_set_all(led, 2, 0);
|
|
return 0;
|
}
|
|
static struct class_attribute led_class_attrs[] = {
|
__ATTR(light, 0644, led_show, NULL),
|
__ATTR_NULL,
|
};
|
|
static struct class led_class = {
|
.name = "led",
|
.owner = THIS_MODULE,
|
.class_attrs = led_class_attrs,
|
};
|
|
static int sunxi_led_probe(struct platform_device *pdev)
|
{
|
int err;
|
dma_cap_mask_t mask;
|
struct sunxi_led *led;
|
struct device *dev = &pdev->dev;
|
struct resource *mem_res = NULL;
|
int ret;
|
|
dprintk(DEBUG_INIT, "start\n");
|
|
led = kzalloc(sizeof(struct sunxi_led), GFP_KERNEL);
|
if (!led) {
|
LED_ERR("kzalloc failed\n");
|
ret = -ENOMEM;
|
}
|
|
sunxi_led = led;
|
|
platform_set_drvdata(pdev, led);
|
led->dev = dev;
|
|
mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
if (mem_res == NULL) {
|
LED_ERR("failed to get MEM res\n");
|
ret = -ENXIO;
|
goto emem;
|
}
|
|
if (!request_mem_region(mem_res->start, resource_size(mem_res),
|
mem_res->name)) {
|
LED_ERR("failed to request mem region\n");
|
ret = -EINVAL;
|
goto emem;
|
}
|
|
led->iomem_reg_base = ioremap(mem_res->start, resource_size(mem_res));
|
if (!led->iomem_reg_base) {
|
ret = -EIO;
|
goto eiomap;
|
}
|
led->res = mem_res;
|
|
led->output_mode.str = kzalloc(3, GFP_KERNEL);
|
if (!led->output_mode.str) {
|
LED_ERR("kzalloc failed\n");
|
ret = -ENOMEM;
|
goto ezalloc_str;
|
}
|
|
sunxi_get_para_of_property(led);
|
|
err = led_regulator_request(led);
|
if (err < 0) {
|
LED_ERR("request regulator failed!\n");
|
ret = err;
|
goto eregulator;
|
}
|
|
err = sunxi_register_led_classdev(led);
|
if (err) {
|
LED_ERR("failed to register led classdev\n");
|
ret = err;
|
goto eclassdev;
|
}
|
|
sunxi_ledc_set_time(led);
|
|
sunxi_clk_init(led);
|
init_waitqueue_head(&led->wait);
|
|
err = sunxi_ledc_irq_init(led);
|
if (err) {
|
LED_ERR("failed to init irq\n");
|
ret = err;
|
goto eirq;
|
}
|
|
sunxi_ledc_pinctrl_init(led);
|
|
dma_cap_zero(mask);
|
dma_cap_set(DMA_SLAVE, mask);
|
led->dma_chan = dma_request_channel(mask, NULL, NULL);
|
if (!led->dma_chan) {
|
LED_ERR("failed to get the DMA channel!\n");
|
ret = -EFAULT;
|
goto edma;
|
}
|
|
#ifdef CONFIG_DEBUG_FS
|
sunxi_led_create_debugfs(led);
|
#endif /* CONFIG_DEBUG_FS */
|
|
err = class_register(&led_class);
|
if (err < 0) {
|
LED_ERR("class_register err\n");
|
class_unregister(&led_class);
|
ret = -EFAULT;
|
goto eclass;
|
}
|
|
dprintk(DEBUG_INIT, "finish\n");
|
|
return 0;
|
|
eclass:
|
dma_release_channel(led->dma_chan);
|
led->dma_chan = NULL;
|
sunxi_led_remove_debugfs(led);
|
|
edma:
|
sunxi_ledc_irq_deinit(led);
|
|
eirq:
|
sunxi_unregister_led_classdev(led);
|
sunxi_clk_deinit(led);
|
|
eclassdev:
|
led_regulator_release(led);
|
|
eregulator:
|
kfree(led->output_mode.str);
|
|
ezalloc_str:
|
iounmap(led->iomem_reg_base);
|
led->iomem_reg_base = NULL;
|
|
eiomap:
|
release_mem_region(mem_res->start, resource_size(mem_res));
|
|
emem:
|
kfree(led);
|
|
return ret;
|
}
|
|
static int sunxi_led_remove(struct platform_device *pdev)
|
{
|
struct sunxi_led *led = platform_get_drvdata(pdev);
|
|
class_unregister(&led_class);
|
|
sunxi_led_remove_debugfs(led);
|
if (led->dma_chan) {
|
dma_release_channel(led->dma_chan);
|
led->dma_chan = NULL;
|
}
|
|
sunxi_ledc_irq_deinit(led);
|
|
sunxi_unregister_led_classdev(led);
|
sunxi_clk_deinit(led);
|
|
led_regulator_release(led);
|
|
kfree(led->output_mode.str);
|
led->output_mode.str = NULL;
|
|
iounmap(led->iomem_reg_base);
|
led->iomem_reg_base = NULL;
|
|
release_mem_region(led->res->start, resource_size(led->res));
|
|
kfree(led);
|
led = NULL;
|
|
dprintk(DEBUG_INIT, "finish\n");
|
return 0;
|
}
|
|
#ifdef CONFIG_PM
|
static int led_select_gpio_state(struct pinctrl *pctrl, char *name)
|
{
|
int ret = 0;
|
struct pinctrl_state *pctrl_state = NULL;
|
|
pctrl_state = pinctrl_lookup_state(pctrl, name);
|
if (IS_ERR(pctrl_state)) {
|
LED_ERR("pinctrl_lookup_state(%s) failed! return %p\n",
|
name, pctrl_state);
|
return -1;
|
}
|
|
ret = pinctrl_select_state(pctrl, pctrl_state);
|
if (ret < 0)
|
LED_ERR("pinctrl_select_state(%s) failed! return %d\n",
|
name, ret);
|
|
return ret;
|
}
|
|
static int led_regulator_enable(struct sunxi_led *led)
|
{
|
if (led->regulator == NULL)
|
return 0;
|
|
if (regulator_enable(led->regulator) != 0) {
|
LED_ERR("enable regulator %s failed!\n", led->regulator_id);
|
return -1;
|
}
|
return 0;
|
}
|
|
static int led_regulator_disable(struct sunxi_led *led)
|
{
|
if (led->regulator == NULL)
|
return 0;
|
|
if (regulator_disable(led->regulator) != 0) {
|
LED_ERR("enable regulator %s failed!\n", led->regulator_id);
|
return -1;
|
}
|
return 0;
|
}
|
|
static int sunxi_led_suspend_noirq(struct device *dev)
|
{
|
struct platform_device *pdev = to_platform_device(dev);
|
struct sunxi_led *led = platform_get_drvdata(pdev);
|
|
sunxi_clk_disable(led);
|
led_select_gpio_state(led->pctrl, PINCTRL_STATE_SLEEP);
|
led_regulator_disable(led);
|
|
dprintk(DEBUG_SUSPEND, "finish\n");
|
|
return 0;
|
}
|
|
static int sunxi_led_resume_noirq(struct device *dev)
|
{
|
struct platform_device *pdev = to_platform_device(dev);
|
struct sunxi_led *led = platform_get_drvdata(pdev);
|
|
led_regulator_enable(led);
|
led_select_gpio_state(led->pctrl, PINCTRL_STATE_DEFAULT);
|
sunxi_clk_enable(led);
|
|
dprintk(DEBUG_SUSPEND, "finish\n");
|
|
return 0;
|
}
|
|
static const struct dev_pm_ops sunxi_led_dev_pm_ops = {
|
.suspend_noirq = sunxi_led_suspend_noirq,
|
.resume_noirq = sunxi_led_resume_noirq,
|
};
|
|
#define SUNXI_LED_DEV_PM_OPS (&sunxi_led_dev_pm_ops)
|
#else
|
#define SUNXI_LED_DEV_PM_OPS NULL
|
#endif
|
|
static const struct of_device_id sunxi_led_dt_ids[] = {
|
{.compatible = "allwinner,sunxi-leds"},
|
{},
|
};
|
|
static struct platform_driver sunxi_led_driver = {
|
.probe = sunxi_led_probe,
|
.remove = sunxi_led_remove,
|
.driver = {
|
.name = "sunxi-leds",
|
.owner = THIS_MODULE,
|
.pm = SUNXI_LED_DEV_PM_OPS,
|
.of_match_table = sunxi_led_dt_ids,
|
},
|
};
|
|
module_platform_driver(sunxi_led_driver);
|
module_param_named(debug, debug_mask, int, 0664);
|
|
MODULE_AUTHOR("Albert Yu <yuxyun@allwinnertech.com>");
|
MODULE_DESCRIPTION("Allwinner LED driver");
|
MODULE_LICENSE("GPL v2");
|
