OrgApache/incubator-nuttx
OrgApache
/
incubator-nuttx
mirror of https://github.com/apache/incubator-nuttx.git
1
0
Fork 0
Code Issues Releases Wiki Activity
incubator-nuttx/drivers/leds/lp503x.c

966 lines
29 KiB
C
Raw Blame History

/****************************************************************************
* drivers/leds/lp503x.c
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership. The
* ASF licenses this file to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <assert.h>
#include <errno.h>
#include <debug.h>
#include <nuttx/kmalloc.h>
#include <nuttx/signal.h>
#include <nuttx/i2c/i2c_master.h>
#include <nuttx/leds/lp503x.h>
#if defined(CONFIG_I2C) && defined(CONFIG_LP503X)
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
#ifdef CONFIG_DEBUG_LP503X
# define lp503x_err(x, ...) _err(x, ##__VA_ARGS__)
# define lp503x_info(x, ...) _info(x, ##__VA_ARGS__)
#else
# define lp503x_err(x, ...) uerr(x, ##__VA_ARGS__)
# define lp503x_info(x, ...) uinfo(x, ##__VA_ARGS__)
#endif
/****************************************************************************
* Private Type Definitions
****************************************************************************/
enum lp503x_state
{
LP503X_STATE_UNINIT = 0,
LP503X_STATE_RESET,
LP503X_STATE_CONFIGURED,
};
struct lp503x_dev_s
{
struct i2c_master_s *i2c;
uint8_t i2c_addr;
int i2c_freq;
int count;
/* device configuration/setup data */
struct lp503x_config_s *lp503x_config;
/* current state of the lp503x device */
enum lp503x_state state;
};
/* A set of default config parameters as set in LED driver Kconfig */
struct lp503x_config_s config_default =
{
#ifdef CONFIG_LP503X_LOG_MODE
.enable_log_mode = 1,
#else
.enable_log_mode = 0,
#endif
#ifdef CONFIG_LP503X_POWER_SAVE
.enable_power_save = 1,
#else
.enable_power_save = 0,
#endif
#ifdef CONFIG_LP503X_DITHER_MODE
.enable_pwm_dithering = 1,
#else
.enable_pwm_dithering = 0,
#endif
#ifdef CONFIG_LP503X_MAX_CURRENT
.set_max_current_35ma = 1,
#else
.set_max_current_35ma = 0,
#endif
#ifdef CONFIG_LP503X_GLOBAL_SHUTDOWN
.enable_all_led_shutdown = 1,
#else
.enable_all_led_shutdown = 0,
#endif
/* all leds will default to independent control, not bank control */
.led_mode[0] = LP503X_LED_BANK_MODE_DISABLED,
.led_mode[1] = LP503X_LED_BANK_MODE_DISABLED,
.led_mode[2] = LP503X_LED_BANK_MODE_DISABLED,
.led_mode[3] = LP503X_LED_BANK_MODE_DISABLED,
.led_mode[4] = LP503X_LED_BANK_MODE_DISABLED,
.led_mode[5] = LP503X_LED_BANK_MODE_DISABLED,
.led_mode[6] = LP503X_LED_BANK_MODE_DISABLED,
.led_mode[7] = LP503X_LED_BANK_MODE_DISABLED,
.led_mode[8] = LP503X_LED_BANK_MODE_DISABLED,
.led_mode[9] = LP503X_LED_BANK_MODE_DISABLED,
.led_mode[10] = LP503X_LED_BANK_MODE_DISABLED,
.led_mode[11] = LP503X_LED_BANK_MODE_DISABLED,
};
/****************************************************************************
* Private Function Prototypes
****************************************************************************/
static int lp503x_i2c_write_reg(struct lp503x_dev_s *priv,
uint8_t const reg_addr,
uint8_t const reg_val);
static int lp503x_i2c_read_reg(struct lp503x_dev_s *priv,
uint8_t const reg_addr,
uint8_t *regval);
static int lp503x_open(struct file *filep);
static int lp503x_close(struct file *filep);
static int lp503x_ioctl(struct file *filep, int cmd,
unsigned long arg);
#ifdef CONFIG_DEBUG_LP503X
static int lp503x_dump_registers(struct lp503x_dev_s *priv,
const char *msg);
#else
# define lp503x_dump_registers(priv, msg);
#endif
static int lp503x_reset(struct lp503x_dev_s *priv);
static int lp503x_enable(struct lp503x_dev_s *priv, bool enable);
static int lp503x_set_rgbbrightness(struct lp503x_dev_s *priv, int led,
int brightness);
static int lp503x_set_outcolour(struct lp503x_dev_s *priv, int led,
int colour);
static int lp503x_set_config(struct lp503x_dev_s *priv);
static int lp503x_set_bank_mode(struct lp503x_dev_s *priv);
static int lp503x_set_bank_colour(struct lp503x_dev_s *priv, char bank,
int brightness);
static int lp503x_set_bank_brightness(struct lp503x_dev_s *priv,
int brightness);
/****************************************************************************
* Private Data
****************************************************************************/
static const struct file_operations g_lp503x_fileops =
{
lp503x_open, /* open */
lp503x_close, /* close */
NULL, /* read */
NULL, /* write */
NULL, /* seek */
lp503x_ioctl, /* ioctl */
};
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: lp503x_dumpregs
*
* Description:
* Dump the contents of all lp503x registers
*
* Input Parameters:
* priv - A reference to the lp503x peripheral state
* msg - Message to print before the register data
*
* Returned Value:
* None
*
****************************************************************************/
#ifdef CONFIG_DEBUG_LP503X
static int lp503x_dump_registers(struct lp503x_dev_s *priv,
const char *msg)
{
uint8_t val1;
uint8_t val2;
uint8_t val3;
uint8_t val4;
int ret;
lp503x_info("lp503x Registers: %s\n", msg);
ret = lp503x_i2c_read_reg(priv, LP503X_DEVICE_CONFIG0, &val1);
ret = lp503x_i2c_read_reg(priv, LP503X_DEVICE_CONFIG1, &val2);
ret = lp503x_i2c_read_reg(priv, LP503X_LED_CONFIG0, &val3);
ret = lp503x_i2c_read_reg(priv, LP503X_LED_CONFIG1, &val4);
lp503x_info
("Dev Config0:\t%02x Dev Conf1:\t%02x \
LED Conf0:\t%02x: LED Conf1: \t %02x\n",
val1, val2, val3, val4);
ret = lp503x_i2c_read_reg(priv, LP503X_BANK_BRIGHTNESS, &val1);
ret = lp503x_i2c_read_reg(priv, LP503X_BANK_A_COLOUR, &val2);
ret = lp503x_i2c_read_reg(priv, LP503X_BANK_B_COLOUR, &val3);
ret = lp503x_i2c_read_reg(priv, LP503X_BANK_C_COLOUR, &val4);
lp503x_info
("Bank Bright:\t%02x BankA Col:\t%02x \
BankB Col:\t%02x: BankC Col:\t %02x\n",
val1, val2, val3, val4);
ret = lp503x_i2c_read_reg(priv, LP503X_LED0_BRIGHTNESS, &val1);
ret = lp503x_i2c_read_reg(priv, LP503X_LED1_BRIGHTNESS, &val2);
ret = lp503x_i2c_read_reg(priv, LP503X_LED2_BRIGHTNESS, &val3);
ret = lp503x_i2c_read_reg(priv, LP503X_LED3_BRIGHTNESS, &val4);
lp503x_info
("LED0 Bright:\t%02x LED1 Col:\t%02x \
LED2 Bright:\t%02x: LED3 Bright: %02x\n",
val1, val2, val3, val4);
ret = lp503x_i2c_read_reg(priv, LP503X_LED4_BRIGHTNESS, &val1);
ret = lp503x_i2c_read_reg(priv, LP503X_LED5_BRIGHTNESS, &val2);
ret = lp503x_i2c_read_reg(priv, LP503X_LED6_BRIGHTNESS, &val3);
ret = lp503x_i2c_read_reg(priv, LP503X_LED7_BRIGHTNESS, &val4);
lp503x_info
("LED4 Bright:\t%02x LED5 Bright:\t%02x \
LED6 Bright:\t%02x: LED7 Bright: %02x\n",
val1, val2, val3, val4);
ret = lp503x_i2c_read_reg(priv, LP503X_LED8_BRIGHTNESS, &val1);
ret = lp503x_i2c_read_reg(priv, LP503X_LED9_BRIGHTNESS, &val2);
ret = lp503x_i2c_read_reg(priv, LP503X_LED10_BRIGHTNESS, &val3);
ret = lp503x_i2c_read_reg(priv, LP503X_LED11_BRIGHTNESS, &val4);
lp503x_info
("LED8 Bright:\t%02x LED9 Bright:\t%02x \
LED10 Bright:\t%02x: LED11 Bright:%02x\n",
val1, val2, val3, val4);
ret = lp503x_i2c_read_reg(priv, LP503X_OUT0_COLOUR, &val1);
ret = lp503x_i2c_read_reg(priv, LP503X_OUT1_COLOUR, &val2);
ret = lp503x_i2c_read_reg(priv, LP503X_OUT2_COLOUR, &val3);
ret = lp503x_i2c_read_reg(priv, LP503X_OUT3_COLOUR, &val4);
lp503x_info
("Out0 Col:\t%02x Out1 Col:\t%02x \
Out2 Col:\t\t%02x Out3 Col:\t %02x\n",
val1, val2, val3, val4);
ret = lp503x_i2c_read_reg(priv, LP503X_OUT4_COLOUR, &val1);
ret = lp503x_i2c_read_reg(priv, LP503X_OUT5_COLOUR, &val2);
ret = lp503x_i2c_read_reg(priv, LP503X_OUT6_COLOUR, &val3);
ret = lp503x_i2c_read_reg(priv, LP503X_OUT7_COLOUR, &val4);
lp503x_info
("Out4 Col:\t%02x Out5 Col:\t%02x \
Out6 Col:\t\t%02x Out7 Col:\t %02x\n",
val1, val2, val3, val4);
ret = lp503x_i2c_read_reg(priv, LP503X_OUT8_COLOUR, &val1);
ret = lp503x_i2c_read_reg(priv, LP503X_OUT9_COLOUR, &val2);
ret = lp503x_i2c_read_reg(priv, LP503X_OUT10_COLOUR, &val3);
ret = lp503x_i2c_read_reg(priv, LP503X_OUT11_COLOUR, &val4);
lp503x_info
("Out8 Col:\t%02x Out9 Col:\t%02x \
Out10 Col:\t%02x Out11 Col:\t %02x\n",
val1, val2, val3, val4);
ret = lp503x_i2c_read_reg(priv, LP503X_OUT12_COLOUR, &val1);
ret = lp503x_i2c_read_reg(priv, LP503X_OUT13_COLOUR, &val2);
ret = lp503x_i2c_read_reg(priv, LP503X_OUT14_COLOUR, &val3);
ret = lp503x_i2c_read_reg(priv, LP503X_OUT15_COLOUR, &val4);
lp503x_info
("Out12 Col:\t%02x Out13 Col:\t%02x \
Out14 Col:\t%02x Out15 Col:\t %02x\n",
val1, val2, val3, val4);
ret = lp503x_i2c_read_reg(priv, LP503X_OUT16_COLOUR, &val1);
ret = lp503x_i2c_read_reg(priv, LP503X_OUT17_COLOUR, &val2);
ret = lp503x_i2c_read_reg(priv, LP503X_OUT18_COLOUR, &val3);
ret = lp503x_i2c_read_reg(priv, LP503X_OUT19_COLOUR, &val4);
lp503x_info
("Out16 Col:\t%02x Out17 Col:\t%02x \
Out18 Col:\t%02x Out19 Col:\t %02x\n",
val1, val2, val3, val4);
ret = lp503x_i2c_read_reg(priv, LP503X_OUT20_COLOUR, &val1);
ret = lp503x_i2c_read_reg(priv, LP503X_OUT21_COLOUR, &val2);
ret = lp503x_i2c_read_reg(priv, LP503X_OUT22_COLOUR, &val3);
ret = lp503x_i2c_read_reg(priv, LP503X_OUT23_COLOUR, &val4);
lp503x_info
("Out20 Col:\t%02x Out21 Col:\t%02x \
Out22 Col:\t%02x Out23 Col:\t %02x\n",
val1, val2, val3, val4);
ret = lp503x_i2c_read_reg(priv, LP503X_OUT24_COLOUR, &val1);
ret = lp503x_i2c_read_reg(priv, LP503X_OUT25_COLOUR, &val2);
ret = lp503x_i2c_read_reg(priv, LP503X_OUT26_COLOUR, &val3);
ret = lp503x_i2c_read_reg(priv, LP503X_OUT27_COLOUR, &val4);
lp503x_info
("Out24 Col:\t%02x Out25 Col:\t%02x \
Out26 Col:\t%02x Out27 Col:\t %02x\n",
val1, val2, val3, val4);
ret = lp503x_i2c_read_reg(priv, LP503X_OUT28_COLOUR, &val1);
ret = lp503x_i2c_read_reg(priv, LP503X_OUT29_COLOUR, &val2);
ret = lp503x_i2c_read_reg(priv, LP503X_OUT30_COLOUR, &val3);
ret = lp503x_i2c_read_reg(priv, LP503X_OUT31_COLOUR, &val4);
lp503x_info
("Out28 Col:\t%02x Out29 Col:\t%02x \
Out30 Col:\t%02x Out31 Col:\t %02x\n",
val1, val2, val3, val4);
ret = lp503x_i2c_read_reg(priv, LP503X_OUT32_COLOUR, &val1);
ret = lp503x_i2c_read_reg(priv, LP503X_OUT33_COLOUR, &val2);
ret = lp503x_i2c_read_reg(priv, LP503X_OUT34_COLOUR, &val3);
ret = lp503x_i2c_read_reg(priv, LP503X_OUT35_COLOUR, &val4);
lp503x_info
("Out28 Col:\t%02x Out29 Col:\t%02x \
Out30 Col:\t%02x Out31 Col:\t %02x\n",
val1, val2, val3, val4);
return ret;
}
#endif
/****************************************************************************
* Name: lp503x_i2c_write_reg
*
* Description:
* Write a single byte to one of the LP503X configuration registers.
*
****************************************************************************/
static int lp503x_i2c_write_reg(struct lp503x_dev_s *priv,
uint8_t const reg_addr,
uint8_t const reg_val)
{
struct i2c_config_s config;
int ret;
/* assemble the 2 byte message comprised of reg_addr and reg_val */
uint8_t const BUFFER_SIZE = 2;
uint8_t buffer[BUFFER_SIZE];
buffer[0] = reg_addr;
buffer[1] = reg_val;
/* Setup up the I2C configuration */
config.frequency = priv->i2c_freq;
config.address = priv->i2c_addr;
config.addrlen = 7;
/* Write the register address followed by the data (no RESTART) */
ledinfo("i2c addr: 0x%02X reg addr: 0x%02X value: 0x%02X\n",
priv->i2c_addr, buffer[0], buffer[1]);
ret = i2c_write(priv->i2c, &config, buffer, BUFFER_SIZE);
if (ret < 0)
{
lederr("ERROR: i2c_write returned error code %d\n", ret);
return ret;
}
return OK;
}
/****************************************************************************
* Name: lp503x_i2c_read_reg
*
* Description:
* Read a single byte from one of the LP503X configuration registers.
*
****************************************************************************/
static int lp503x_i2c_read_reg(struct lp503x_dev_s *priv,
uint8_t const reg_addr,
uint8_t *regval)
{
struct i2c_config_s config;
int ret;
/* Setup up the I2C configuration */
config.frequency = priv->i2c_freq;
config.address = priv->i2c_addr;
config.addrlen = 7;
/* Write the register address followed by the data (no RESTART) */
ret = i2c_write(priv->i2c, &config, &reg_addr, 1);
ret = i2c_read(priv->i2c, &config, regval, 1);
return ret;
}
/****************************************************************************
* Name: lp503x_open
*
* Description:
* This function is called whenever a LP503X device is opened.
*
****************************************************************************/
static int lp503x_open(struct file *filep)
{
struct inode *inode = filep->f_inode;
struct lp503x_dev_s *priv = inode->i_private;
int ret;
ledinfo("INFO: Opening, resetting and enabling the LP503X for business\n");
/* reset and enable the device */
/* means the device was possibly never regsitered? */
if (priv->state == LP503X_STATE_UNINIT)
{
return -ENODEV;
}
else if (priv->state == LP503X_STATE_RESET)
{
ret = lp503x_enable(priv, true);
if (ret != 0)
{
lederr("ERROR: unable to enable lp503x\n");
return -EIO;
}
else
{
/* use device defaults */
priv->lp503x_config = &config_default;
}
ret = lp503x_set_config(priv);
if (ret != 0)
{
lederr("ERROR: Unable to set device config: %d\n", ret);
return -EIO;
}
priv->state = LP503X_STATE_CONFIGURED;
}
lp503x_dump_registers(priv, "File Open");
return ret;
}
/****************************************************************************
* Name: lp503x_close
*
* Description:
* This function is called whenever a LP503X device is closed.
*
****************************************************************************/
static int lp503x_close(struct file *filep)
{
int ret;
struct inode *inode = filep->f_inode;
struct lp503x_dev_s *priv = inode->i_private;
ret = lp503x_enable(priv, false);
if (ret < 0)
{
lederr("ERROR: Could not disable LP503X\n");
}
return ret;
}
/****************************************************************************
* Name: lp503x_reset
*
* Description:
* Resets all registers to default values
*
****************************************************************************/
static int lp503x_reset(struct lp503x_dev_s *priv)
{
int ret;
ret = lp503x_i2c_write_reg(priv, LP503X_RESET, LP503X_RESET_ALL_REGISTERS);
if (ret != 0)
{
return -EIO;
}
else
{
priv->state = LP503X_STATE_RESET;
return OK;
}
}
/****************************************************************************
* Name: lp503x_enable
*
* Description:
* enables or disables the entire device
*
****************************************************************************/
static int lp503x_enable(struct lp503x_dev_s *priv, bool enable)
{
int ret;
if (enable)
{
ret = lp503x_i2c_write_reg(priv, LP503X_DEVICE_CONFIG0,
LP503X_CHIP_ENABLE);
ledinfo("INFO: LP503x enabled\n");
}
else
{
ret = lp503x_i2c_write_reg(priv, LP503X_DEVICE_CONFIG0,
LP503X_CHIP_DISABLE);
ledinfo("INFO: LP503x disabled\n");
}
return ret;
}
/****************************************************************************
* Name: lp503x_set_config
*
* Description:
* configures basic operation modes of the device
*
****************************************************************************/
static int lp503x_set_config(struct lp503x_dev_s *priv)
{
int ret;
uint8_t regval;
struct lp503x_config_s *config;
config = priv->lp503x_config;
ret = lp503x_i2c_read_reg(priv, LP503X_DEVICE_CONFIG1, &regval);
if (config->enable_log_mode)
{
regval |= LP503X_CONFIG1_LOG_SCALE;
}
else
{
regval &= ~LP503X_CONFIG1_LOG_SCALE;
}
if (config->enable_power_save)
{
regval |= LP503X_CONFIG1_PWRSAVE;
}
else
{
regval &= ~LP503X_CONFIG1_PWRSAVE;
}
if (config->enable_pwm_dithering)
{
regval |= LP503X_CONFIG1_DITHERING;
}
else
{
regval &= ~LP503X_CONFIG1_DITHERING;
}
if (config->set_max_current_35ma)
{
regval |= LP503X_CONFIG1_PWRSAVE;
}
else
{
regval &= ~LP503X_CONFIG1_PWRSAVE;
}
if (config->enable_all_led_shutdown)
{
regval |= LP503X_CONFIG1_GLOBAL_OFF;
}
else
{
regval &= ~LP503X_CONFIG1_GLOBAL_OFF;
}
ret = lp503x_i2c_write_reg(priv, LP503X_DEVICE_CONFIG1, regval);
return ret;
}
/****************************************************************************
* Name: lp503x_set_bank_brightness
*
* Description:
* sets banks to the required brightness
*
****************************************************************************/
static int lp503x_set_bank_brightness(struct lp503x_dev_s *priv,
int brightness)
{
if (brightness > MAX_BRIGHTNESS)
{
return -EINVAL;
}
else
{
return lp503x_i2c_write_reg(priv, LP503X_BANK_BRIGHTNESS, brightness);
}
}
/****************************************************************************
* Name: lp503x_set_bank_colour
*
* Description:
* sets bank A, B or C led to required coloiur (mix)
*
****************************************************************************/
static int lp503x_set_bank_colour(struct lp503x_dev_s *priv, char bank,
int brightness)
{
if (brightness > MAX_BRIGHTNESS)
{
return -EINVAL;
}
else
{
if (bank == 'A')
{
return lp503x_i2c_write_reg(priv, LP503X_BANK_A_COLOUR,
brightness);
}
else if (bank == 'B')
{
return lp503x_i2c_write_reg(priv, LP503X_BANK_B_COLOUR,
brightness);
}
else if (bank == 'C')
{
return lp503x_i2c_write_reg(priv, LP503X_BANK_C_COLOUR,
brightness);
}
else
{
return -EINVAL;
}
}
}
/****************************************************************************
* Name: lp503x_set_bank_mode
*
* Description:
* enables or disables bank mode for selected LED
*
****************************************************************************/
static int lp503x_set_bank_mode(struct lp503x_dev_s *priv)
{
int ret;
int count;
int regval;
struct lp503x_config_s *config;
config = priv->lp503x_config;
regval = 0;
for (count = 0; count < 8; count++)
{
if (config->led_mode[count] == LP503X_LED_BANK_MODE_ENABLED)
{
regval |= (LP503X_LED0_BANK_ENABLE << count);
}
else
{
regval &= ~(LP503X_LED0_BANK_ENABLE << count);
}
}
ret = lp503x_i2c_write_reg(priv, LP503X_LED_CONFIG0, regval);
for (count = 8; count < 12; count++)
{
if (config->led_mode[count] == LP503X_LED_BANK_MODE_ENABLED)
{
regval |= (LP503X_LED0_BANK_ENABLE << (count - 8));
}
else
{
regval &= ~(LP503X_LED0_BANK_ENABLE << (count - 8));
}
}
ret = lp503x_i2c_write_reg(priv, LP503X_LED_CONFIG1, regval);
return ret;
}
/****************************************************************************
* Name: lp503x_set_rgbled_colour
*
* Description:
* sets RGB led to chosen html colour
*
****************************************************************************/
static int lp503x_set_rgbled_colour(struct lp503x_dev_s *priv,
int led, int colour)
{
int ret;
int regaddr;
if ((led > MAX_RGB_LEDS) || (colour > MAX_RGB_COLOUR))
{
ret = -EINVAL;
}
else
{
regaddr = LP503X_OUT0_COLOUR + (3*led);
ret = lp503x_i2c_write_reg(priv, regaddr++, (colour >> 16) & 0xff);
ret = lp503x_i2c_write_reg(priv, regaddr++, (colour >> 8) & 0xff);
ret = lp503x_i2c_write_reg(priv, regaddr, (colour >> 0) & 0xff);
ledinfo("INFO: RGB LED %d set to RGB colour %06x\n", led, colour);
}
return ret;
}
/****************************************************************************
* Name: lp503x_set_outcolour
*
* Description:
* Sets OUT brightness ("colour" of individual LED outputs
*
****************************************************************************/
static int lp503x_set_outcolour(struct lp503x_dev_s *priv, int led,
int brightness)
{
int ret;
if ((led > MAX_LEDS) || (brightness > MAX_BRIGHTNESS))
{
ret = -EINVAL;
}
else
{
ret = lp503x_i2c_write_reg(priv, LP503X_OUT0_COLOUR + led, brightness);
ledinfo("INFO: individual LED %d set to brightness %d\n", led,
brightness);
}
return ret;
}
/****************************************************************************
* Name: lp503x_set_rgbbrightness
*
* Description:
* Sets brightness of all RGB LED
*
****************************************************************************/
static int lp503x_set_rgbbrightness(struct lp503x_dev_s *priv, int led,
int brightness)
{
int ret;
if ((led > MAX_RGB_LEDS) || (brightness > MAX_BRIGHTNESS))
{
ret = -EINVAL;
}
else
{
ret = lp503x_i2c_write_reg(priv, LP503X_LED0_BRIGHTNESS + led,
brightness);
ledinfo("INFO: LED %d set to brightness %d\n", led, brightness);
}
return ret;
}
/****************************************************************************
* Name: lp503x_ioctl
*
* Description:
* This function is called whenever an ioctl call to a LP503X is
* performed.
*
****************************************************************************/
static int lp503x_ioctl(struct file *filep, int cmd,
unsigned long arg)
{
struct inode *inode = filep->f_inode;
struct lp503x_dev_s *priv = inode->i_private;
struct lp503x_config_s *config;
int ret;
const struct ioctl_arg_s *lp503x_ioctl_args = (struct ioctl_arg_s *)arg;
config = priv->lp503x_config;
ret = OK;
ledinfo("cmd: %d arg: %ld\n", cmd, arg);
switch (cmd)
{
case PWMIOC_ENABLE: /* arg is true or false */
config->enable_all_led_shutdown = lp503x_ioctl_args->param;
ret = lp503x_set_config(priv);
break;
case PWMIOC_RESET: /* no args */
lp503x_reset(priv);
break;
case PWMIOC_ENABLE_LED_BANK_MODE: /* led(0..11), mode required */
ledinfo("INFO: setting LED %d mode to %" PRIx32 "\n",
lp503x_ioctl_args->lednum,
lp503x_ioctl_args->param);
config->led_mode[lp503x_ioctl_args->lednum] =
lp503x_ioctl_args->param;
lp503x_set_bank_mode(priv);
break;
case PWMIOC_SET_BANK_MIX_COLOUR:/* bank(A/B/C),level(0-255) */
ledinfo("INFO: setting bank %c to brightness %" PRIx32 "\n",
lp503x_ioctl_args->lednum, lp503x_ioctl_args->param);
ret = lp503x_set_bank_colour(priv, lp503x_ioctl_args->lednum,
lp503x_ioctl_args->param);
break;
case PWMIOC_SET_BANK_BRIGHTNESS:
ledinfo("INFO: setting bank brightness to %" PRIx32 "\n",
lp503x_ioctl_args->param);
lp503x_set_bank_brightness(priv, lp503x_ioctl_args->param);
break;
case PWMIOC_CONFIG: /* config is struct within priv */
ledinfo("INFO: setting device config to:\n");
ledinfo("\tlog mode = %d\n", config->enable_log_mode);
ledinfo("\tpower save = %d\n", config->enable_power_save);
ledinfo("\tpwm dithering = %d\n", config->enable_pwm_dithering);
ledinfo("\tmax current = %s\n", (config->set_max_current_35ma)
? "30mA" : "25.5mA");
ledinfo("\tall leds shutdown = %d\n",
config->enable_all_led_shutdown);
ret = lp503x_set_config(priv);
break;
case PWMIOC_SET_LED_COLOUR: /* led(0..35), Colour(0..255) */
ledinfo("INFO: set LED %d to colour/brightness %" PRIx32 "\n",
lp503x_ioctl_args->lednum, lp503x_ioctl_args->param);
ret = lp503x_set_outcolour(priv, lp503x_ioctl_args->lednum,
lp503x_ioctl_args->param);
break;
case PWMIOC_SET_RGB_BRIGHTNESS: /* led(0..11), level(0..255) */
ledinfo("INFO: requested brightness level %d for led %" PRIx32 "\n",
lp503x_ioctl_args->lednum, lp503x_ioctl_args->param);
ret = lp503x_set_rgbbrightness(priv, lp503x_ioctl_args->lednum,
lp503x_ioctl_args->param);
break;
case PWMIOC_SET_RGB_COLOUR: /* led(0..11) */
ledinfo("requested led %d to be RGB colour = %" PRIx32 "\n",
lp503x_ioctl_args->lednum, lp503x_ioctl_args->param);
ret = lp503x_set_rgbled_colour(priv, lp503x_ioctl_args->lednum,
lp503x_ioctl_args->param);
break;
default: /* The used ioctl command was invalid */
lederr("ERROR: Unrecognized cmd: %d\n", cmd);
ret = -ENOTTY;
break;
}
return ret;
}
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: lp503x_register
*
* Description:
* Register the LP503X device as 'devpath'
*
* Input Parameters:
* devpath - The full path to the driver to register. E.g., "/dev/leddrv0".
* i2c - An instance of the I2C interface to use to communicate
* with the LM92.
* lp503x_i2c_addr
* - The I2C address of the LP503X.
*
* Returned Value:
* Zero (OK) on success; a negated errno value on failure.
*
****************************************************************************/
int lp503x_register(const char *devpath, struct i2c_master_s *i2c,
uint8_t const lp503x_i2c_addr, int const i2c_frequency)
{
int ret;
/* Sanity check */
DEBUGASSERT(devpath != NULL && i2c != NULL);
/* Initialize the LP503X device structure */
struct lp503x_dev_s *priv =
(struct lp503x_dev_s *)kmm_malloc(sizeof(struct lp503x_dev_s));
if (priv == NULL)
{
lederr("ERROR: Failed to allocate instance of lp503x_dev_s\n");
return -ENOMEM;
}
priv->i2c = i2c;
priv->i2c_addr = lp503x_i2c_addr;
priv->i2c_freq = i2c_frequency;
priv->state = LP503X_STATE_UNINIT;
/* Register the character driver */
ret = register_driver(devpath, &g_lp503x_fileops, 0222, priv);
if (ret != OK)
{
lederr("ERROR: Failed to register driver: %d\n", ret);
kmm_free(priv);
return ret;
}
else
{
ret = lp503x_reset(priv);
if (ret != OK)
{
lederr("ERROR: failed to reset lp503x device\n");
return ret;
}
priv->state = LP503X_STATE_RESET;
}
return OK;
}
#endif /* CONFIG_I2C && CONFIG_I2C_LP503X */
Reference in New Issue View Git Blame Copy Permalink