void send_low_bit() {
//debug_print(DBG_INFO, "0 \n");
pwm_configure(pwm1, MESSAGE_DUTY_LOW, MESSAGE_PERIOD); // 0
pwm_configure(pwm2, MESSAGE_DUTY_LOW, MESSAGE_PERIOD);
pwm_configure(pwm3, MESSAGE_DUTY_LOW, MESSAGE_PERIOD);
pwm_configure(pwm4, MESSAGE_DUTY_LOW, MESSAGE_PERIOD);
pwm_enable(pwm1);
pwm_enable(pwm2);
pwm_enable(pwm3);
pwm_enable(pwm4);
mcu_delay(MESSAGE_SLEEP);
}
void send_high_bit() {
//debug_print(DBG_INFO, "1 \n");
pwm_configure(pwm1, MESSAGE_DUTY_HIGH, MESSAGE_PERIOD); // 1
pwm_configure(pwm2, MESSAGE_DUTY_HIGH, MESSAGE_PERIOD);
pwm_configure(pwm3, MESSAGE_DUTY_HIGH, MESSAGE_PERIOD);
pwm_configure(pwm4, MESSAGE_DUTY_HIGH, MESSAGE_PERIOD);
pwm_enable(pwm1);
pwm_enable(pwm2);
pwm_enable(pwm3);
pwm_enable(pwm4);
mcu_delay(MESSAGE_SLEEP);
}
void send_preamble_sequence(int preamble_duration) {
//debug_print(DBG_INFO, "Preamble\n");
pwm_configure(pwm1, PREAMBLE_DUTY, PREAMBLE_PERIOD);
pwm_configure(pwm2, PREAMBLE_DUTY, PREAMBLE_PERIOD);
pwm_configure(pwm3, PREAMBLE_DUTY, PREAMBLE_PERIOD);
pwm_configure(pwm4, PREAMBLE_DUTY, PREAMBLE_PERIOD);
pwm_enable(pwm1);
pwm_enable(pwm2);
pwm_enable(pwm3);
pwm_enable(pwm4);
mcu_delay(preamble_duration*PREAMBLE_SLEEP);
}
static void pm8058_pwm_led_brightness_set(struct led_classdev *led_cdev,
enum led_brightness brightness)
{
struct pm8058_led_data *ldata;
int enable = 0;
/* struct pwm_device* pwm_led; */
ldata = container_of(led_cdev, struct pm8058_led_data, ldev);
pwm_disable(ldata->pwm_led);
brightness = (brightness > LED_FULL) ? LED_FULL : brightness;
brightness = (brightness < LED_OFF) ? LED_OFF : brightness;
LED_INFO_LOG("%s: bank %d brightness %d\n", __func__,
ldata->bank, brightness);
enable = (brightness) ? 1 : 0;
if (strcmp(ldata->ldev.name, "charming-led") == 0)
charming_led_enable(enable);
if (brightness) {
pwm_config(ldata->pwm_led, 6400 *pwm_coefficient / 100, 6400);
#if 0
pwm_conf.pwm_size = ldata->pwm_size;
pwm_conf.clk = ldata->clk;
pwm_conf.pre_div = ldata->pre_div;
pwm_conf.pre_div_exp = ldata->pre_div_exp;
pwm_conf.pwm_value = ldata->pwm_value;
pwm_conf.bypass_lut = 1;
pwm_configure(ldata->pwm_led, &pwm_conf);
#endif
pwm_enable(ldata->pwm_led);
}
}
static void pm8058_pwm_led_brightness_set(struct led_classdev *led_cdev,
enum led_brightness brightness)
{
struct pm8058_led_data *ldata;
/* struct pwm_device* pwm_led; */
ldata = container_of(led_cdev, struct pm8058_led_data, ldev);
pwm_disable(ldata->pwm_led);
brightness = (brightness > LED_FULL) ? LED_FULL : brightness;
brightness = (brightness < LED_OFF) ? LED_OFF : brightness;
printk(KERN_INFO "%s: bank %d brightness %d +\n", __func__,
ldata->bank, brightness);
if (brightness) {
pwm_config(ldata->pwm_led, 64000, 64000);
#if 0
pwm_conf.pwm_size = ldata->pwm_size;
pwm_conf.clk = ldata->clk;
pwm_conf.pre_div = ldata->pre_div;
pwm_conf.pre_div_exp = ldata->pre_div_exp;
pwm_conf.pwm_value = ldata->pwm_value;
pwm_conf.bypass_lut = 1;
pwm_configure(ldata->pwm_led, &pwm_conf);
#endif
pwm_enable(ldata->pwm_led);
}
printk(KERN_INFO "%s: bank %d brightness %d -\n", __func__,
ldata->bank, brightness);
}
static void pwm_init(void)
{
int i;
for (i = 0; i < PWM_CH_COUNT; ++i) {
pwm_configure(pwm_channels[i].channel,
pwm_channels[i].flags & PWM_CONFIG_ACTIVE_LOW);
pwm_set_duty(i, 0);
}
}
static void shooter_3Dpanel_on(bool bLandscape)
{
struct pw8058_pwm_config pwm_conf;
int rc;
if (mipi_novatek_panel_data.mipi_send_cmds) {
mipi_novatek_panel_data.mipi_send_cmds(novatek_3vci_cmds, ARRAY_SIZE(novatek_3vci_cmds));
}
led_brightness_switch("lcd-backlight", 255);
if(system_rev >= 1) {
pwm_gpio_config.output_value = 1;
rc = pm8058_gpio_config(SHOOTER_3DLCM_PD, &pwm_gpio_config);
if (rc < 0)
pr_err("%s pmic gpio config gpio %d failed\n", __func__, SHOOTER_3DLCM_PD);
}
rc = pm8058_gpio_config(SHOOTER_3DCLK, &clk_gpio_config_on);
if (rc < 0)
pr_err("%s pmic gpio config gpio %d failed\n", __func__, SHOOTER_3DCLK);
pwm_disable(pwm_3d);
pwm_conf.pwm_size = 9;
pwm_conf.clk = PM_PWM_CLK_19P2MHZ;
pwm_conf.pre_div = PM_PWM_PREDIVIDE_3;
pwm_conf.pre_div_exp = 6;
pwm_conf.pwm_value = 255;
pwm_conf.bypass_lut = 1;
pwm_configure(pwm_3d, &pwm_conf);
pwm_enable(pwm_3d);
if(bLandscape) {
mdp_color_enhancement(mdp_sharp_barrier_on, ARRAY_SIZE(mdp_sharp_barrier_on));
gpio_set_value(SHOOTER_CTL_3D_1, 1);
gpio_set_value(SHOOTER_CTL_3D_2, 1);
gpio_set_value(SHOOTER_CTL_3D_3, 1);
gpio_set_value(SHOOTER_CTL_3D_4, 0);
} else {
mdp_color_enhancement(mdp_sharp_barrier_on, ARRAY_SIZE(mdp_sharp_barrier_on));
gpio_set_value(SHOOTER_CTL_3D_1, 1);
gpio_set_value(SHOOTER_CTL_3D_2, 1);
gpio_set_value(SHOOTER_CTL_3D_3, 0);
gpio_set_value(SHOOTER_CTL_3D_4, 1);
}
}
static void shooter_3Dpanel_on(bool bLandscape)
{
struct pm8058_pwm_period pwm_conf;
int rc;
led_brightness_switch("lcd-backlight", 255);
if (system_rev >= 1) {
pwm_gpio_config.output_value = 1;
rc = pm8xxx_gpio_config(PM8058_GPIO_PM_TO_SYS(SHOOTER_3DLCM_PD), &pwm_gpio_config);
if (rc < 0)
pr_err("%s pmic gpio config gpio %d failed\n", __func__, PM8058_GPIO_PM_TO_SYS(SHOOTER_3DLCM_PD));
}
rc = pm8xxx_gpio_config(PM8058_GPIO_PM_TO_SYS(SHOOTER_3DCLK), &clk_gpio_config_on);
if (rc < 0)
pr_err("%s pmic gpio config gpio %d failed\n", __func__, SHOOTER_3DCLK);
pwm_disable(pwm_3d);
pwm_conf.pwm_size = 9;
pwm_conf.clk = PM_PWM_CLK_19P2MHZ;
pwm_conf.pre_div = PM_PWM_PREDIVIDE_3;
pwm_conf.pre_div_exp = 6;
rc = pwm_configure(pwm_3d, &pwm_conf, 1, 255);
if (rc < 0)
pr_err("%s pmic configure %d\n", __func__, rc);
pwm_enable(pwm_3d);
if (bLandscape) {
mdp4_dsi_color_enhancement(mdp_sharp_barrier_on, ARRAY_SIZE(mdp_sharp_barrier_on));
gpio_set_value(SHOOTER_CTL_3D_1, 1);
gpio_set_value(SHOOTER_CTL_3D_2, 1);
gpio_set_value(SHOOTER_CTL_3D_3, 1);
gpio_set_value(SHOOTER_CTL_3D_4, 0);
} else {
mdp4_dsi_color_enhancement(mdp_sharp_barrier_on, ARRAY_SIZE(mdp_sharp_barrier_on));
gpio_set_value(SHOOTER_CTL_3D_1, 1);
gpio_set_value(SHOOTER_CTL_3D_2, 1);
gpio_set_value(SHOOTER_CTL_3D_3, 0);
gpio_set_value(SHOOTER_CTL_3D_4, 1);
}
}
static ssize_t pm8058_led_blink_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct led_classdev *led_cdev;
struct pm8058_led_data *ldata;
int id, mode;
int val;
int enable = 0;
#ifdef CONFIG_HTC_HEADSET_MISC
int *pduties;
#endif
/*struct timespec ts1, ts2;*/
val = -1;
sscanf(buf, "%u", &val);
if (val < 0 || val > 255)
return -EINVAL;
led_cdev = (struct led_classdev *) dev_get_drvdata(dev);
ldata = container_of(led_cdev, struct pm8058_led_data, ldev);
id = bank_to_id(ldata->bank);
mode = (id == PM_PWM_LED_KPD) ? PM_PWM_CONF_PWM1 :
PM_PWM_CONF_PWM1 + (ldata->bank - 4);
if (ldata->flags & PM8058_LED_BLINK_EN)
pm8058_pwm_config_led(ldata->pwm_led, id, mode,
ldata->out_current);
LED_INFO_LOG("%s: bank %d blink %d\n", __func__, ldata->bank, val);
enable = (val > 0) ? 1 : 0;
if (strcmp(ldata->ldev.name, "charming-led") == 0)
charming_led_enable(enable);
switch (val) {
case -1: /* stop flashing */
pwm_disable(ldata->pwm_led);
if (ldata->flags & PM8058_LED_BLINK_EN)
pm8058_pwm_config_led(ldata->pwm_led, id, mode, 0);
break;
case 0:
pwm_disable(ldata->pwm_led);
if (led_cdev->brightness) {
pwm_config(ldata->pwm_led, 6400 * pwm_coefficient / 100, 6400);
pwm_enable(ldata->pwm_led);
} else {
if (ldata->flags & PM8058_LED_BLINK_EN)
pm8058_pwm_config_led(ldata->pwm_led, id,
mode, 0);
}
break;
case 1:
pwm_disable(ldata->pwm_led);
pwm_config(ldata->pwm_led, 64000, 2000000);
pwm_enable(ldata->pwm_led);
break;
case 2:
cancel_delayed_work_sync(&ldata->led_delayed_work);
pwm_disable(ldata->pwm_led);
ldata->duty_time_ms = 64;
ldata->period_us = 2000000;
queue_delayed_work(g_led_work_queue, &ldata->led_delayed_work,
msecs_to_jiffies(310));
break;
case 3:
cancel_delayed_work_sync(&ldata->led_delayed_work);
pwm_disable(ldata->pwm_led);
ldata->duty_time_ms = 64;
ldata->period_us = 2000000;
queue_delayed_work(g_led_work_queue, &ldata->led_delayed_work,
msecs_to_jiffies(1000));
break;
case 4:
pwm_disable(ldata->pwm_led);
pwm_config(ldata->pwm_led, 1000000, 2000000);
#if 0
pwm_conf.pwm_size = 9;
pwm_conf.clk = PM_PWM_CLK_1KHZ;
pwm_conf.pre_div = PM_PWM_PREDIVIDE_2;
pwm_conf.pre_div_exp = 1;
pwm_conf.pwm_value = 512/2;
pwm_conf.bypass_lut = 1;
pwm_configure(ldata->pwm_led, &pwm_conf);
#endif
pwm_enable(ldata->pwm_led);
break;
case 5:
pwm_disable(ldata->pwm_led);
pwm_config(ldata->pwm_led, 100000, 200000);
pwm_enable(ldata->pwm_led);
break;
#ifdef CONFIG_HTC_HEADSET_MISC
case 6:
pm8058_pwm_config_led(ldata->pwm_led, id, mode,
ldata->out_current);
pduties = &duties[ldata->start_index];
pm8058_pwm_lut_config(ldata->pwm_led, ldata->period_us,
pduties, ldata->duty_time_ms,
ldata->start_index, ldata->duites_size,
0, 0, ldata->lut_flag);
pm8058_pwm_lut_enable(ldata->pwm_led, 0);
pm8058_pwm_lut_enable(ldata->pwm_led, 1);
break;
case 7:
pwm_disable(ldata->pwm_led);
pwm_config(ldata->pwm_led, 64000, 4000000);
pwm_enable(ldata->pwm_led);
break;
#endif
default:
LED_ERR_LOG(KERN_INFO "%s: bank %d not support blink %d\n", __func__, ldata->bank, val);
return -EINVAL;
}
return count;
}
static ssize_t pm8058_led_blink_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct led_classdev *led_cdev;
struct pm8058_led_data *ldata;
int id, mode;
int val;
/*struct timespec ts1, ts2;*/
val = -1;
sscanf(buf, "%u", &val);
if (val < 0 || val > 255)
return -EINVAL;
led_cdev = (struct led_classdev *) dev_get_drvdata(dev);
ldata = container_of(led_cdev, struct pm8058_led_data, ldev);
id = bank_to_id(ldata->bank);
mode = (id == PM_PWM_LED_KPD) ? PM_PWM_CONF_PWM1 :
PM_PWM_CONF_PWM1 + (ldata->bank - 4);
if (ldata->flags & PM8058_LED_BLINK_EN)
pm8058_pwm_config_led(ldata->pwm_led, id, mode,
ldata->out_current);
printk(KERN_INFO "%s: bank %d blink %d +\n", __func__, ldata->bank, val);
switch (val) {
case -1: /* stop flashing */
pwm_disable(ldata->pwm_led);
if (ldata->flags & PM8058_LED_BLINK_EN)
pm8058_pwm_config_led(ldata->pwm_led, id, mode, 0);
break;
case 0:
pwm_disable(ldata->pwm_led);
if (led_cdev->brightness) {
pwm_config(ldata->pwm_led, 64000, 64000);
pwm_enable(ldata->pwm_led);
} else {
if (ldata->flags & PM8058_LED_BLINK_EN)
pm8058_pwm_config_led(ldata->pwm_led, id,
mode, 0);
}
break;
case 1:
pwm_disable(ldata->pwm_led);
pwm_config(ldata->pwm_led, 64000, 2000000);
pwm_enable(ldata->pwm_led);
break;
case 2:
cancel_delayed_work_sync(&ldata->led_delayed_work);
pwm_disable(ldata->pwm_led);
ldata->duty_time_ms = 64;
ldata->period_us = 2000000;
queue_delayed_work(g_led_work_queue, &ldata->led_delayed_work,
msecs_to_jiffies(310));
break;
case 3:
cancel_delayed_work_sync(&ldata->led_delayed_work);
pwm_disable(ldata->pwm_led);
ldata->duty_time_ms = 64;
ldata->period_us = 2000000;
queue_delayed_work(g_led_work_queue, &ldata->led_delayed_work,
msecs_to_jiffies(1000));
break;
case 4:
pwm_disable(ldata->pwm_led);
pwm_config(ldata->pwm_led, 1000000, 2000000);
#if 0
pwm_conf.pwm_size = 9;
pwm_conf.clk = PM_PWM_CLK_1KHZ;
pwm_conf.pre_div = PM_PWM_PREDIVIDE_2;
pwm_conf.pre_div_exp = 1;
pwm_conf.pwm_value = 512/2;
pwm_conf.bypass_lut = 1;
pwm_configure(ldata->pwm_led, &pwm_conf);
#endif
pwm_enable(ldata->pwm_led);
break;
default:
printk(KERN_INFO "%s: bank %d blink %d -\n", __func__, ldata->bank, val);
return -EINVAL;
}
printk(KERN_INFO "%s: bank %d blink %d -\n", __func__, ldata->bank, val);
return count;
}
void mcu_main()
{
// by default, the edison has ID 0
int edisonID = 0;
// if we pass in an argument, use it for the edisonID
// please pass in an integer
//if (argc == 2) {
//edisonID = atoi(argv[1]);
//}
int temp;
while (1)
{
//int host_receive(unsigned char *buf, int length)
temp = host_receive((unsigned char *)host_message, BUFFER_LENGTH);
if (temp > 0)
{
debug_print(DBG_INFO, "Received a Message!\n");
host_send((unsigned char*)"hello mcu\n", 10);
preamble_length = host_message[0];
}
// Preamble - Signals the Receiver Message Incoming
send_preamble_sequence(preamble_length);
// Sending Edison Board ID # - 2 bits, MSB then LSB
switch (edisonID) {
case 0:
send_low_bit(); // Send lsb bit 0 = LOW
send_low_bit(); // Send msb bit 1 = LOW
break;
case 1:
send_high_bit(); // Send lsb bit 0 = HIGH
send_low_bit(); // Send msb bit 1 = LOW
break;
case 2:
send_low_bit(); // Send lsb bit 0 = LOW
send_high_bit(); // Send msb bit 1 =
break;
case 3:
send_high_bit(); // Send lsb bit 0 = HIGH
send_high_bit(); // Send msb bit 1 = HIGH
break;
default:
send_low_bit(); // Send lsb bit 0 = LOW
send_low_bit(); // Send msb bit 1 = LOW
}
// Sending Edison IR Emitter ID # - 2 bits, MSB then LSB
// pwm1 = 00 = short-long/short-long = 5-20/5-20
// pwm2 = 01 = short-long/long-short = 5-20/20-5
// pwm3 = 10 = long-short/short-long = 20-5/5-20
// pwm4 = 11 = long-short/long-short = 20-5/20-5
// First Bit
pwm_configure(pwm1, MESSAGE_DUTY_LOW, MESSAGE_PERIOD); // 0
pwm_configure(pwm2, MESSAGE_DUTY_LOW, MESSAGE_PERIOD); // 0
pwm_configure(pwm3, MESSAGE_DUTY_HIGH, MESSAGE_PERIOD); // 1
pwm_configure(pwm4, MESSAGE_DUTY_HIGH, MESSAGE_PERIOD); // 1
pwm_enable(pwm1);
pwm_enable(pwm2);
pwm_enable(pwm3);
pwm_enable(pwm4);
mcu_delay(MESSAGE_SLEEP);
// Second Bit
pwm_configure(pwm1, MESSAGE_DUTY_LOW, MESSAGE_PERIOD); // 0
pwm_configure(pwm2, MESSAGE_DUTY_HIGH, MESSAGE_PERIOD); // 1
pwm_configure(pwm3, MESSAGE_DUTY_LOW, MESSAGE_PERIOD); // 0
pwm_configure(pwm4, MESSAGE_DUTY_HIGH, MESSAGE_PERIOD); // 1
pwm_enable(pwm1);
pwm_enable(pwm2);
pwm_enable(pwm3);
pwm_enable(pwm4);
mcu_delay(MESSAGE_SLEEP);
}
}
int main(int argc, FAR char *argv[]) {
#else
int pwm_test_main(int argc, char *argv[]) {
#endif
struct device *dev;
struct pwm_app_info *info = NULL;
uint16_t count;
uint32_t ret = 0;
int i;
info = zalloc(sizeof(struct pwm_app_info));
if (!info) {
printf("pwm_test: App initialization failed!\n");
return EXIT_FAILURE;
}
default_params(info);
if (comm_parse(info, argc, argv)) {
print_usage();
goto err_free_info;
}
dev = device_open(DEVICE_TYPE_PWM_HW, 0);
if (!dev) {
printf("pwm_test: Open PWM controller driver failure!\n");
ret = EXIT_FAILURE;
goto err_free_info;
}
device_pwm_get_count(dev, &count);
if (info->index > count) {
printf("pwm_test: pwm%u > maximum supported number %u\n", info->index,
count);
print_usage();
ret = EXIT_FAILURE;
goto err_out;
}
if (!info->is_mode_test) {
ret = pwm_configure(dev, info, false);
if (ret) {
printf("pwm_test: Failed to enabled PWM%u \n", info->index);
goto err_out;
}
} else {
switch (info->mode_num) {
case PWM_PULSECOUNT_MODE:
if (info->param < 1) {
printf("pwm_test: mode 0 of -a must > 0\n");
print_usage();
ret = EXIT_FAILURE;
goto err_out;
}
info->secs = ((info->period/1000000000) * info->param) < 1 ? 1 :
(info->period/1000000000) * info->param;
ret = pwm_configure(dev, info, true);
if (ret) {
printf("pwm_test: mode 0, set generator(%u) in mode(%u) has "
"failed\n", info->index, info->mode_num);
goto err_out;
}
break;
case PWM_STOP_LEVEL_MODE:
ret = pwm_configure(dev, info, true);
if (ret) {
printf("pwm_test: mode1, set generator(%u) in mode(%u) has "
"failed\n", info->index, info->mode_num);
goto err_out;
}
break;
case PWM_SYNC_MODE:
/**
* This case will test all supported generstors to output waveform
* at sametime that have same period configuration.
*/
info->param = 1;
for (i = 0; i < count; i++) {
ret = device_pwm_activate(dev, i);
if (ret) {
printf("pwm_test: mode2, active generator(%d) return "
"error(%x)\n", i, ret);
break;
}
ret = device_pwm_config(dev, i, info->period /(2+i),
info->period);
if (ret) {
printf("pwm_test: mode2, config generator(%d) return "
"error(%x)\n", i, ret);
break;
}
ret = device_pwm_set_mode(dev, i, info->mode_num, &info->param);
if (ret) {
printf("pwm_test: mode 2, set generator(%d) of SELENB bit "
"return error(%x)\n", i, ret);
break;
}
}
if (ret) {
/**
* Make sure already activated pwm can be deactivated if has
* error.
*/
for (; i >= 0; i--) {
device_pwm_deactivate(dev, i);
}
goto err_out;
}
device_pwm_sync_output(dev, true);
break;
default:
print_usage();
ret = EXIT_FAILURE;
goto err_out;
}
}
dump_params(info);
printf("pwm_test: Enabled PWM%u for a duration of %u seconds\n",
info->index, info->secs);
sleep((unsigned int)info->secs);
if (info->is_mode_test && (info->mode_num == PWM_PULSECOUNT_MODE)) {
printf("pwm_test: test completed, callback interrupt value "
"= %u and error value = %u\n", val_int, val_err);
} else {
printf("pwm_test: test completed\n");
}
err_out:
device_close(dev);
err_free_info:
free(info);
return ret;
}
