void pwm_init(void){
*AT91C_PMC_PCER |= (1<<AT91C_ID_PWMC);
*AT91C_PIOA_PDR |= PWM_MASK;
*AT91C_PIOA_BSR |= PWM_MASK;
#if ORIGINAL_FREQ
pwm_configure_clock(0x00000014);
#elif DOUBLED_FREQ
pwm_configure_clock(0x0000060F);
#endif
pwm_configure_channel(0, AT91C_PWMC_CPRE_MCKA, 0, 1);
pwm_configure_channel(1, AT91C_PWMC_CPRE_MCKA, 0, 1);
pwm_configure_channel(2, AT91C_PWMC_CPRE_MCKA, 0, 1);
pwm_configure_channel(3, AT91C_PWMC_CPRE_MCKA, 0, 1);
pwm_set_period(0, 4800);
pwm_set_period(1, 4800);
pwm_set_period(2, 4800);
pwm_set_period(3, 4800);
pwm_set_duty_cycle(0, 0);
pwm_set_duty_cycle(1, 0);
pwm_set_duty_cycle(2, 0);
pwm_set_duty_cycle(3, 0); //here must set 0 first, or the polarity will be wrong
pwm_enable_channel(0);
pwm_enable_channel(1);
pwm_enable_channel(2);
pwm_enable_channel(3);
pwm_set_duty_cycle(0, 2400);
pwm_set_duty_cycle(1, 2400);
pwm_set_duty_cycle(2, 2400);
pwm_set_duty_cycle(3, 2400);
}
int main()
{
DDRB |= _BV(PB3);
pwm_fast_init(2);
spi_master_init(USI_PORTA);
// Enable pullups on button inputs
PORTA |= 1 << B_DOWN;
PORTA |= 1 << B_UP;
uint8_t ton = 0x40;
uint8_t timer = 0;
pwm_set_period(0xFF);
pwm_set_on_b(ton);
while(1) {
if ((PINA & (1 << B_UP)) == 0) {
pwm_set_on_b(ton++);
}
if ((PINA & (1 << B_DOWN)) == 0) {
pwm_set_on_b(ton--);
}
if (timer++ == 1000 / LOOP_DELAY) {
spi_master_write(ton);
timer = 0;
}
_delay_ms(50);
}
}
void lcd_blt_set_pwm(int no, int level, int freq)
{
int clock = auto_pll_divisor(DEV_PWM,GET_FREQ, 0, 0);
int period, duty, scalar;
clock = clock / freq;
scalar = 0;
period = 2000;
while(period > 1023) {
scalar++;
period = clock / scalar;
}
duty = (period*level)/100;
duty = (duty)? (duty-1):0;
scalar = scalar-1;
period = period -1;
pwm_set_period(no,period);
pwm_set_duty(no,duty);
pwm_set_scalar(no,scalar);
if (g_pwm_setting.config)
pwm_set_control(no,(level)? 0x36:0x8);
else
pwm_set_control(no,(level)? 0x34:0x8);
pwm_set_gpio(no,level);
}
static bool test_pwm_get_set_period_before_init(void)
{
uint32_t period = 100;
return pwm_get_period(MIKROBUS_1, &period) == -1
&& pwm_set_period(MIKROBUS_1, period) == -1;
}
static int display_set_pwm(char *val, int on)
{
if (val == NULL) {
printf("error : can not get pwm parameter\n");
return -1;
}
lcd_blt_enable(g_pwm_setting.pwm_no, 0);
parse_pwm_params(NULL, val);
if ((g_display_vaild&PWMDEFMASK) == PWMDEFTP) {
lcd_blt_set_pwm(g_pwm_setting.pwm_no, g_pwm_setting.duty, g_pwm_setting.period);
} else {
// fan : may need to check PWM power ..
pwm_set_period(g_pwm_setting.pwm_no, g_pwm_setting.period-1);
pwm_set_duty(g_pwm_setting.pwm_no, g_pwm_setting.duty-1);
pwm_set_control(g_pwm_setting.pwm_no, (g_pwm_setting.duty-1)? 0x35:0x8);
pwm_set_gpio(g_pwm_setting.pwm_no, g_pwm_setting.duty-1);
pwm_set_scalar(g_pwm_setting.pwm_no, g_pwm_setting.scalar-1);
}
lcd_blt_enable(g_pwm_setting.pwm_no, on);
return 0;
}
/******************************************************************************
* FunctionName : user_light_set_duty
* Description : set pwm frequency
* Parameters : uint16 freq : 100hz typically
* Returns : NONE
*******************************************************************************/
void ICACHE_FLASH_ATTR
user_light_set_period(uint32 period)
{
if (period != light_param.pwm_period) {
pwm_set_period(period);
light_param.pwm_period = pwm_get_period();
}
}
/******************************************************************************
* FunctionName : user_light_set_duty
* Description : set pwm frequency
* Parameters : uint16 freq : 100hz typically
* Returns : NONE
*******************************************************************************/
void
user_light_set_period(uint32 period)
{
if (period != light_param.pwm_period) {
pwm_set_period(period);
light_param.pwm_period = pwm_get_period();
}
}
void lcd_blt_set_pwm(int no,unsigned int scalar,unsigned int period,unsigned int duty)
{
lcd_pwm_enable = 1;
lcd_blt_id = no;
#ifdef CONFIG_PWM_WMT
pwm_set_scalar(lcd_blt_id,scalar);
pwm_set_period(lcd_blt_id,period);
pwm_set_duty(lcd_blt_id,duty);
#endif
}
void servo_init()
{
int i;
for(i=0;i<sizeof(servo_pin)/sizeof(servo_pin[0]);i++)
{
pwm_stop(servo_pin[i][0], servo_pin[i][1]);
pwm_set_period(servo_pin[i][0], servo_pin[i][1], SERVO_STD_PERIOD);
pwm_set_polarity(servo_pin[i][0], servo_pin[i][1], 1);
pwm_set_duty_cycle(servo_pin[i][0], servo_pin[i][1], SERVO_ANGLE_TO_DUTY(0)); /* keep in the middle */
}
start_servo();
}
int main(void)
{
DDRB |= _BV(PB3);
DDRB |= _BV(PB0); // raw-pwm output
spi_master_init(USI_PORTA);
// Enable pullups on button inputs
PORTA |= 1 << B_DOWN;
PORTA |= 1 << B_UP;
uint16_t timer = 0;
pwm_fast_init(2);
pwm_set_period(0xFF);
pwm_set_on_b(ton);
DDRA |= _BV(PA0); // Force Data in (MISO) to 0
// prescaler: 6 = div/64; fADC = 125kHz; 1 clockcycle = 8uS; 1 conversion=104uS
adc_init(VREF_I2_56, 0x12, 6);
// Configure timer0
TCCR0A = 0x00;
TCCR0B = 0x01; // Enable counter without prescaling
OCR0A = 0xFF; // compare at 0xFF
TIMSK |= (1 << OCIE0A); // enable interrupt for compare0A
sei();
while(1) {
if (timer % 100 == 0) {
if ((PINA & (1 << B_UP)) == 0 && pwm_t < BPWM_MAX) {
pwm_t++;
}
if ((PINA & (1 << B_DOWN)) == 0 && pwm_t > BPWM_MIN) {
pwm_t--;
}
}
if (timer++ == 50000 / LOOP_DELAY) {
spi_master_write(pwm_t >> 8);
spi_master_write(pwm_t);
spi_master_write(ton);
spi_master_write((adc & 0xFF00) >> 8);
spi_master_write(adc & 0x00FF);
timer = 0;
}
_delay_us(LOOP_DELAY);
}
static int pwm_backlight_probe(struct platform_device *pdev)
{
struct platform_pwm_backlight_data *data = dev_get_platdata(&pdev->dev);
struct platform_pwm_backlight_data defdata;
struct backlight_properties props;
struct backlight_device *bl;
struct pwm_bl_data *pb;
int ret;
if (!data) {
ret = pwm_backlight_parse_dt(&pdev->dev, &defdata);
if (ret < 0) {
dev_err(&pdev->dev, "failed to find platform data\n");
return ret;
}
data = &defdata;
}
if (data->init) {
ret = data->init(&pdev->dev);
if (ret < 0)
return ret;
}
pb = devm_kzalloc(&pdev->dev, sizeof(*pb), GFP_KERNEL);
if (!pb) {
ret = -ENOMEM;
goto err_alloc;
}
if (data->levels) {
unsigned int i;
for (i = 0; i <= data->max_brightness; i++)
if (data->levels[i] > pb->scale)
pb->scale = data->levels[i];
pb->levels = data->levels;
} else
pb->scale = data->max_brightness;
pb->enable_gpio = data->enable_gpio;
pb->enable_gpio_flags = data->enable_gpio_flags;
pb->notify = data->notify;
pb->notify_after = data->notify_after;
pb->check_fb = data->check_fb;
pb->exit = data->exit;
pb->dev = &pdev->dev;
pb->enabled = false;
if (gpio_is_valid(pb->enable_gpio)) {
unsigned long flags;
if (pb->enable_gpio_flags & PWM_BACKLIGHT_GPIO_ACTIVE_LOW)
flags = GPIOF_OUT_INIT_HIGH;
else
flags = GPIOF_OUT_INIT_LOW;
ret = gpio_request_one(pb->enable_gpio, flags, "enable");
if (ret < 0) {
dev_err(&pdev->dev, "failed to request GPIO#%d: %d\n",
pb->enable_gpio, ret);
goto err_alloc;
}
}
pb->power_supply = devm_regulator_get(&pdev->dev, "power");
if (IS_ERR(pb->power_supply)) {
ret = PTR_ERR(pb->power_supply);
goto err_gpio;
}
pb->pwm = devm_pwm_get(&pdev->dev, NULL);
if (IS_ERR(pb->pwm)) {
dev_err(&pdev->dev, "unable to request PWM, trying legacy API\n");
pb->pwm = pwm_request(data->pwm_id, "pwm-backlight");
if (IS_ERR(pb->pwm)) {
dev_err(&pdev->dev, "unable to request legacy PWM\n");
ret = PTR_ERR(pb->pwm);
goto err_gpio;
}
}
dev_dbg(&pdev->dev, "got pwm for backlight\n");
/*
* The DT case will set the pwm_period_ns field to 0 and store the
* period, parsed from the DT, in the PWM device. For the non-DT case,
* set the period from platform data.
*/
if (data->pwm_period_ns > 0)
pwm_set_period(pb->pwm, data->pwm_period_ns);
pb->period = pwm_get_period(pb->pwm);
pb->lth_brightness = data->lth_brightness * (pb->period / pb->scale);
memset(&props, 0, sizeof(struct backlight_properties));
props.type = BACKLIGHT_RAW;
props.max_brightness = data->max_brightness;
bl = backlight_device_register("lcd-bl", &pdev->dev, pb,
&pwm_backlight_ops, &props);
if (IS_ERR(bl)) {
dev_err(&pdev->dev, "failed to register backlight\n");
ret = PTR_ERR(bl);
goto err_gpio;
}
if (data->dft_brightness > data->max_brightness) {
dev_warn(&pdev->dev,
"invalid default brightness level: %u, using %u\n",
data->dft_brightness, data->max_brightness);
data->dft_brightness = data->max_brightness;
}
bl->props.brightness = data->dft_brightness;
backlight_update_status(bl);
platform_set_drvdata(pdev, bl);
return 0;
err_gpio:
if (gpio_is_valid(pb->enable_gpio))
gpio_free(pb->enable_gpio);
err_alloc:
if (data->exit)
data->exit(&pdev->dev);
return ret;
}
static bool test_pwm_get_set_period_invalid_index(void)
{
uint32_t period = 100;
return pwm_set_period(3, period) == -1
&& pwm_get_period(3, &period) == -1;
}
static int pwm_backlight_probe(struct platform_device *pdev)
{
struct platform_pwm_backlight_data *data = pdev->dev.platform_data;
struct platform_pwm_backlight_data defdata;
struct backlight_properties props;
struct backlight_device *bl;
struct pwm_bl_data *pb;
unsigned int max;
int ret;
if (!data) {
ret = pwm_backlight_parse_dt(&pdev->dev, &defdata);
if (ret < 0) {
dev_err(&pdev->dev, "failed to find platform data\n");
return ret;
}
data = &defdata;
}
if (data->init) {
ret = data->init(&pdev->dev);
if (ret < 0)
return ret;
}
pb = devm_kzalloc(&pdev->dev, sizeof(*pb), GFP_KERNEL);
if (!pb) {
dev_err(&pdev->dev, "no memory for state\n");
ret = -ENOMEM;
goto err_alloc;
}
if (data->levels) {
max = data->levels[data->max_brightness];
pb->levels = data->levels;
} else
max = data->max_brightness;
pb->notify = data->notify;
pb->notify_after = data->notify_after;
pb->check_fb = data->check_fb;
pb->exit = data->exit;
pb->dev = &pdev->dev;
pb->pwm = devm_pwm_get(&pdev->dev, NULL);
if (IS_ERR(pb->pwm)) {
dev_err(&pdev->dev, "unable to request PWM, trying legacy API\n");
pb->pwm = pwm_request(data->pwm_id, "pwm-backlight");
if (IS_ERR(pb->pwm)) {
dev_err(&pdev->dev, "unable to request legacy PWM\n");
ret = PTR_ERR(pb->pwm);
goto err_alloc;
}
}
dev_dbg(&pdev->dev, "got pwm for backlight\n");
/*
* The DT case will set the pwm_period_ns field to 0 and store the
* period, parsed from the DT, in the PWM device. For the non-DT case,
* set the period from platform data.
*/
if (data->pwm_period_ns > 0)
pwm_set_period(pb->pwm, data->pwm_period_ns);
pb->period = pwm_get_period(pb->pwm);
pb->lth_brightness = data->lth_brightness * (pb->period / max);
memset(&props, 0, sizeof(struct backlight_properties));
props.type = BACKLIGHT_RAW;
props.max_brightness = data->max_brightness;
bl = backlight_device_register(dev_name(&pdev->dev), &pdev->dev, pb,
&pwm_backlight_ops, &props);
if (IS_ERR(bl)) {
dev_err(&pdev->dev, "failed to register backlight\n");
ret = PTR_ERR(bl);
goto err_alloc;
}
if (data->dft_brightness > data->max_brightness) {
dev_warn(&pdev->dev,
"invalid default brightness level: %u, using %u\n",
data->dft_brightness, data->max_brightness);
data->dft_brightness = data->max_brightness;
}
bl->props.brightness = data->dft_brightness;
backlight_update_status(bl);
platform_set_drvdata(pdev, bl);
return 0;
err_alloc:
if (data->exit)
data->exit(&pdev->dev);
return ret;
}
static int __init pwm_regulator_probe(struct platform_device *pdev)
{
struct pwm_platform_data *pdata = pdev->dev.platform_data;
struct pwm_regulator_board *pwm_pdev;
struct of_regulator_match *pwm_reg_matches = NULL;
struct regulator_init_data *reg_data;
struct regulator_config config = { };
const char *rail_name = NULL;
struct regulator_dev *pwm_rdev;
int ret, i = 0;
struct regulator *dc;
pwm_pdev = devm_kzalloc(&pdev->dev, sizeof(*pwm_pdev),
GFP_KERNEL);
pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata),
GFP_KERNEL);
if (pdev->dev.of_node)
pwm_pdev = pwm_regulator_parse_dt(pdev, &pwm_reg_matches);
if (!pwm_pdev) {
dev_err(&pdev->dev, "Platform data not found\n");
return -EINVAL;
}
if (!pwm_pdev->pwm_init_vol)
pdata->pwm_voltage = 1100000; /* default 1.1v*/
else
pdata->pwm_voltage = pwm_pdev->pwm_init_vol;
if (!pwm_pdev->pwm_max_vol)
pdata->max_uV = 1400000;
else
pdata->max_uV = pwm_pdev->pwm_max_vol;
if (!pwm_pdev->pwm_min_vol)
pdata->min_uV = 1000000;
else
pdata->min_uV = pwm_pdev->pwm_min_vol;
if (pwm_pdev->pwm_suspend_vol < pwm_pdev->pwm_min_vol)
pdata->suspend_voltage = pwm_pdev->pwm_min_vol;
else if (pwm_pdev->pwm_suspend_vol > pwm_pdev->pwm_max_vol)
pdata->suspend_voltage = pwm_pdev->pwm_max_vol;
else
pdata->suspend_voltage = pwm_pdev->pwm_suspend_vol;
pdata->pwm_voltage_map = pwm_pdev->pwm_voltage_map;
pdata->pwm_id = pwm_pdev->pwm_id;
pdata->coefficient = pwm_pdev->pwm_coefficient;
pdata->pwm_vol_map_count = pwm_pdev->pwm_vol_map_count;
pdata->pwm = devm_pwm_get(&pdev->dev, NULL);
if (IS_ERR(pdata->pwm)) {
dev_err(&pdev->dev, "unable to request PWM, trying legacy API\n");
pdata->pwm = pwm_request(pdata->pwm_id, "pwm-regulator");
if (IS_ERR(pdata->pwm)) {
dev_err(&pdev->dev, "unable to request legacy PWM\n");
ret = PTR_ERR(pdata->pwm);
goto err;
}
}
if (pdata->pwm_period_ns > 0)
pwm_set_period(pdata->pwm, pdata->pwm_period_ns);
pdata->period = pwm_get_period(pdata->pwm);
mutex_init(&pdata->mutex_pwm);
if (pwm_pdev) {
pdata->num_regulators = pwm_pdev->num_regulators;
pdata->rdev = kcalloc(pdata->num_regulators, sizeof(struct regulator_dev *), GFP_KERNEL);
if (!pdata->rdev) {
return -ENOMEM;
}
/* Instantiate the regulators */
for (i = 0; i < pdata->num_regulators; i++) {
reg_data = pwm_pdev->pwm_init_data[i];
if (!reg_data)
continue;
config.dev = &pdev->dev;
config.driver_data = pdata;
if (&pdev->dev.of_node)
config.of_node = pwm_pdev->of_node[i];
if (reg_data && reg_data->constraints.name)
rail_name = reg_data->constraints.name;
else
rail_name = regulators[i].name;
reg_data->supply_regulator = rail_name;
config.init_data = reg_data;
pwm_rdev = regulator_register(®ulators[i], &config);
if (IS_ERR(pwm_rdev)) {
printk("failed to register %d regulator\n", i);
goto err;
}
pdata->rdev[i] = pwm_rdev;
/*********set pwm vol by defult***********/
dc = regulator_get(NULL, rail_name);
regulator_set_voltage(dc, pdata->pwm_voltage, pdata->pwm_voltage);
regulator_put(dc);
/**************************************/
}
}
return 0;
err:
printk("%s:error\n", __func__);
return ret;
}
