vi-kernel/vvcam/native/flash_led/flash_led_sysfs.c

#include "flash_led_driver.h"
#include "flash_led_ioctl.h"

extern uint64_t touch_pin_int_num(struct flash_led_ctrl *pflash_led_dev);
extern uint64_t touch_pin_high_time_us(void);
extern uint64_t touch_pin_preiod_time_us(void);
extern uint64_t touch_pin_falling_int(void);
extern uint64_t touch_pin_rising_int(void);

static ssize_t flash_led_falling_int_show(struct device *dev,
			       struct device_attribute *attr, char *buf)
{
   	char buffer[100];
    printk("<0>""flash_led falling interrupt num: %d\n", touch_pin_falling_int());
	snprintf(buffer, sizeof(buffer), "falling num :%llu\n", touch_pin_falling_int());

	return strlcpy(buf, buffer, PAGE_SIZE);
}

static ssize_t flash_led_rising_int_show(struct device *dev,
			       struct device_attribute *attr, char *buf)
{
   	char buffer[100];

    printk("<0>""flash_led rising interrupt num: %d\n", touch_pin_rising_int());
	snprintf(buffer, sizeof(buffer), "rising interupt num :%llu\n", touch_pin_rising_int());

	return strlcpy(buf, buffer, PAGE_SIZE);
}

static ssize_t flash_led_info_show(struct device *dev,
			       struct device_attribute *attr, char *buf)
{
	struct platform_device *pdev = to_platform_device(dev);
	struct flash_led_driver_dev *pdriver_dev;
    struct flash_led_ctrl *pflash_led_dev;
    struct flash_led_dev *floodlight;
    struct flash_led_dev *projection;
   	char buffer[200];
    char name1[30] = {0};
    char name2[30] = {0};

    pdriver_dev = platform_get_drvdata(pdev);
	pflash_led_dev = (struct flash_led_ctrl*)pdriver_dev->private;

    floodlight = &pflash_led_dev->floodlight;
    projection = &pflash_led_dev->projection;

    if (floodlight->flash_led_func != NULL) {
        strcpy(name1, floodlight->flash_led_func->flash_led_name);
    }

    if (projection->flash_led_func != NULL) {
        strcpy(name2, projection->flash_led_func->flash_led_name);
    }

	snprintf(buffer, sizeof(buffer), "f_led_%s i2c is :%d, p_led_%s i2c is %d\n",
                                      name1,
                                      floodlight->i2c_bus,
                                      name2,
                                      projection->i2c_bus);

	return strlcpy(buf, buffer, PAGE_SIZE);
}

static ssize_t flash_led_int_show(struct device *dev,
			       struct device_attribute *attr, char *buf)
{
	struct platform_device *pdev = to_platform_device(dev);
	struct flash_led_driver_dev *pdriver_dev;
    struct flash_led_ctrl *pflash_led_dev;
    pdriver_dev = platform_get_drvdata(pdev);
	pflash_led_dev = (struct flash_led_ctrl*)pdriver_dev->private;

   	char buffer[100];

    printk("<0>""flash_led interrupt num: %d\n", touch_pin_int_num(pflash_led_dev));
	snprintf(buffer, sizeof(buffer), "interupt num :%llu\n", touch_pin_int_num(pflash_led_dev));

	return strlcpy(buf, buffer, PAGE_SIZE);
}

static ssize_t flash_led_pin_high_time_us_show(struct device *dev,
			       struct device_attribute *attr, char *buf)
{
   	char buffer[100];
	snprintf(buffer, sizeof(buffer), "h time us is :%llu\n", touch_pin_high_time_us());

	return strlcpy(buf, buffer, PAGE_SIZE);
}

static ssize_t flash_led_pin_period_us_show(struct device *dev,
			       struct device_attribute *attr, char *buf)
{
   	char buffer[100];
	snprintf(buffer, sizeof(buffer), "preiod us is :%llu\n", touch_pin_preiod_time_us());

	return strlcpy(buf, buffer, PAGE_SIZE);
}

int32_t flash_led_i2c_write(struct flash_led_dev *dev, uint32_t address, uint32_t data);
int32_t flash_led_i2c_read(struct flash_led_dev *dev, uint32_t address, uint32_t *pdata);

static ssize_t floodlight_led_reg_read_store(struct device *dev,
                   struct device_attribute *attr,
                   const char *buf,
                   size_t count)
{
    int ret = 0;
	struct platform_device *pdev = to_platform_device(dev);
	struct flash_led_driver_dev *pdriver_dev;
	struct flash_led_ctrl *pflash_led_dev;
    struct flash_led_dev *floodlight;
    unsigned long addr;
    uint32_t val;

    pdriver_dev = platform_get_drvdata(pdev);
	pflash_led_dev = (struct flash_led_ctrl*)pdriver_dev->private;
    floodlight = &pflash_led_dev->floodlight;

    if(floodlight->i2c_bus == UNDEFINED_IN_DTS) {
        return count;
    }

    ret = kstrtoul(buf, 16, &addr);
    if (ret < 0) {
        return ret;
    }

    ret = flash_led_i2c_read(floodlight, addr, &val);
    if (ret < 0) {
        return ret;
    }
    printk("read reg[0x%x]: 0x%x\n", addr, val);

	return count;
}

static ssize_t floodlight_led_reg_write_store(struct device *dev,
                   struct device_attribute *attr,
                   const char *buf,
                   size_t count)
{
    int ret = 0;
	struct platform_device *pdev = to_platform_device(dev);
	struct flash_led_driver_dev *pdriver_dev;
	struct flash_led_ctrl *pflash_led_dev;
    struct flash_led_dev *floodlight;
   	char buffer[100];
    unsigned long addr;
    uint32_t val;

    pdriver_dev = platform_get_drvdata(pdev);
	pflash_led_dev = (struct flash_led_ctrl*)pdriver_dev->private;
    floodlight = &pflash_led_dev->floodlight;

    if(floodlight->i2c_bus == UNDEFINED_IN_DTS) {
        return count;
    }

    ret = kstrtoul(buf, 16, &addr);
    if (ret < 0) {
        return ret;
    }

    val = addr & 0xff;
    addr = addr >> 8;

    ret = flash_led_i2c_write(floodlight, addr, val);
    if (ret < 0) {
        return ret;
    }

	printk("write reg[0x%x] 0x%x\n", addr, val);

	return count;
}

static ssize_t projection_led_reg_read_store(struct device *dev,
                   struct device_attribute *attr,
                   const char *buf,
                   size_t count)
{
    int ret = 0;
	struct platform_device *pdev = to_platform_device(dev);
	struct flash_led_driver_dev *pdriver_dev;
	struct flash_led_ctrl *pflash_led_dev;
    struct flash_led_dev *projection;
    unsigned long addr;
    uint32_t val;

    pdriver_dev = platform_get_drvdata(pdev);
	pflash_led_dev = (struct flash_led_ctrl*)pdriver_dev->private;
    projection = &pflash_led_dev->projection;

    if(projection->i2c_bus == UNDEFINED_IN_DTS) {
        return count;
    }

    ret = kstrtoul(buf, 16, &addr);
    if (ret < 0) {
        return ret;
    }

    ret = flash_led_i2c_read(projection, addr, &val);
    if (ret < 0) {
        return ret;
    }
    printk("read reg[0x%x]: 0x%x\n", addr, val);

	return count;
}

static ssize_t projection_led_reg_write_store(struct device *dev,
                   struct device_attribute *attr,
                   const char *buf,
                   size_t count)
{
    int ret = 0;
	struct platform_device *pdev = to_platform_device(dev);
	struct flash_led_driver_dev *pdriver_dev;
	struct flash_led_ctrl *pflash_led_dev;
    struct flash_led_dev *projection;
   	char buffer[100];
    unsigned long addr;
    uint32_t val;

    pdriver_dev = platform_get_drvdata(pdev);
	pflash_led_dev = (struct flash_led_ctrl*)pdriver_dev->private;
    projection = &pflash_led_dev->projection;

    if(projection->i2c_bus == UNDEFINED_IN_DTS) {
        return count;
    }

    ret = kstrtoul(buf, 16, &addr);
    if (ret < 0) {
        return ret;
    }

    val = addr & 0xff;
    addr = addr >> 8;

    ret = flash_led_i2c_write(projection, addr, val);
    if (ret < 0) {
        return ret;
    }

	printk("write reg[0x%x] 0x%x\n", addr, val);

	return count;
}

static ssize_t flash_led_enable_store(struct device *dev,
                   struct device_attribute *attr,
                   const char *buf,
                   size_t count)
{
    int ret = 0;
	struct platform_device *pdev = to_platform_device(dev);
	struct flash_led_driver_dev *pdriver_dev;
	struct flash_led_ctrl *pflash_led_dev;
   	char buffer[100];
    unsigned long en;

    pdriver_dev = platform_get_drvdata(pdev);
	pflash_led_dev = (struct flash_led_ctrl *)pdriver_dev->private;

    ret = kstrtoul(buf, 10, &en);
    if (ret < 0) {
        return ret;
    }

    pflash_led_dev->enable = en;

	return count;
}

static ssize_t flash_led_enable_show(struct device *dev,
                   struct device_attribute *attr, char *buf)
{
    int ret = 0;
	struct platform_device *pdev = to_platform_device(dev);
	struct flash_led_driver_dev *pdriver_dev;
	struct flash_led_ctrl *pflash_led_dev;
   	char buffer[100];
    unsigned long en;

    pdriver_dev = platform_get_drvdata(pdev);
	pflash_led_dev = (struct flash_led_ctrl *)pdriver_dev->private;
    snprintf(buffer, sizeof(buffer), "flash_led enable mask is 0x%x\n", pflash_led_dev->enable);

    return strlcpy(buf, buffer, PAGE_SIZE);
}

uint64_t get_us_time(void);

static ssize_t projection_enable_store(struct device *dev,
                   struct device_attribute *attr,
                   const char *buf,
                   size_t count)
{
    int ret = 0;
	struct platform_device *pdev = to_platform_device(dev);
	struct flash_led_driver_dev *pdriver_dev;
	struct flash_led_ctrl *pflash_led_dev;
    struct flash_led_dev *projection;
   	char buffer[100];
    unsigned long ch;

    pdriver_dev = platform_get_drvdata(pdev);
	pflash_led_dev = (struct flash_led_ctrl*)pdriver_dev->private;
    projection = &pflash_led_dev->projection;

    ret = kstrtoul(buf, 10, &ch);
    if (ret < 0) {
        return ret;
    }

    uint64_t us1 = get_us_time();

    if (projection->flash_led_func != NULL) {
        projection->flash_led_func->enable_channel(projection, ch);
    }
    uint64_t us2 = get_us_time();

    printk("used time %llu us\n", us2 - us1);

	return count;
}

static ssize_t floodlight_enable_store(struct device *dev,
                   struct device_attribute *attr,
                   const char *buf,
                   size_t count)
{
    int ret = 0;
	struct platform_device *pdev = to_platform_device(dev);
	struct flash_led_driver_dev *pdriver_dev;
	struct flash_led_ctrl *pflash_led_dev;
    struct flash_led_dev *floodlight;
    unsigned long ch;

    pdriver_dev = platform_get_drvdata(pdev);
	pflash_led_dev = (struct flash_led_ctrl*)pdriver_dev->private;
    floodlight = &pflash_led_dev->floodlight;

    ret = kstrtoul(buf, 10, &ch);
    if (ret < 0) {
        return ret;
    }

    uint64_t us1 = get_us_time();
    if (floodlight->flash_led_func != NULL) {
        floodlight->flash_led_func->enable_channel(floodlight, ch);
    }
    uint64_t us2 = get_us_time();

    printk("used time %llu us\n", us2 - us1);
	return count;
}

static DEVICE_ATTR_RO(flash_led_info);
static DEVICE_ATTR_RO(flash_led_int);
static DEVICE_ATTR_RO(flash_led_pin_high_time_us);
static DEVICE_ATTR_RO(flash_led_pin_period_us);
static DEVICE_ATTR_RO(flash_led_falling_int);
static DEVICE_ATTR_RO(flash_led_rising_int);
static DEVICE_ATTR_WO(projection_led_reg_write);
static DEVICE_ATTR_WO(projection_led_reg_read);
static DEVICE_ATTR_WO(floodlight_led_reg_write);
static DEVICE_ATTR_WO(floodlight_led_reg_read);
static DEVICE_ATTR_WO(projection_enable);
static DEVICE_ATTR_WO(floodlight_enable);
static DEVICE_ATTR_RW(flash_led_enable);

int flash_led_create_capabilities_sysfs(struct platform_device *pdev)
{
	device_create_file(&pdev->dev, &dev_attr_flash_led_info);
	device_create_file(&pdev->dev, &dev_attr_flash_led_int);
	device_create_file(&pdev->dev, &dev_attr_flash_led_pin_high_time_us);
	device_create_file(&pdev->dev, &dev_attr_flash_led_pin_period_us);
	device_create_file(&pdev->dev, &dev_attr_flash_led_falling_int);
	device_create_file(&pdev->dev, &dev_attr_flash_led_rising_int);
	device_create_file(&pdev->dev, &dev_attr_projection_led_reg_write);
	device_create_file(&pdev->dev, &dev_attr_projection_led_reg_read);
	device_create_file(&pdev->dev, &dev_attr_floodlight_led_reg_write);
	device_create_file(&pdev->dev, &dev_attr_floodlight_led_reg_read);
	device_create_file(&pdev->dev, &dev_attr_projection_enable);
	device_create_file(&pdev->dev, &dev_attr_floodlight_enable);
	device_create_file(&pdev->dev, &dev_attr_flash_led_enable);

	return 0;
}

int flash_led_remove_capabilities_sysfs(struct platform_device *pdev)
{
	device_remove_file(&pdev->dev, &dev_attr_flash_led_info);
	device_remove_file(&pdev->dev, &dev_attr_flash_led_int);
	device_remove_file(&pdev->dev, &dev_attr_flash_led_pin_high_time_us);
	device_remove_file(&pdev->dev, &dev_attr_flash_led_pin_period_us);
	device_remove_file(&pdev->dev, &dev_attr_flash_led_falling_int);
	device_remove_file(&pdev->dev, &dev_attr_flash_led_rising_int);
	device_remove_file(&pdev->dev, &dev_attr_projection_led_reg_write);
	device_remove_file(&pdev->dev, &dev_attr_projection_led_reg_read);
	device_remove_file(&pdev->dev, &dev_attr_floodlight_led_reg_write);
	device_remove_file(&pdev->dev, &dev_attr_floodlight_led_reg_read);
	device_remove_file(&pdev->dev, &dev_attr_projection_enable);
	device_remove_file(&pdev->dev, &dev_attr_floodlight_enable);
	device_remove_file(&pdev->dev, &dev_attr_flash_led_enable);

	return 0;
}