static bool_t buzzer_pwm_register_buzzer(struct resource_t * res)
{
struct buzzer_pwm_data_t * rdat = (struct buzzer_pwm_data_t *)res->data;
struct buzzer_pwm_pdata_t * pdat;
struct buzzer_t * buzzer;
struct pwm_t * pwm;
char name[64];
pwm = search_pwm(rdat->pwm);
if(!pwm)
return FALSE;
pdat = malloc(sizeof(struct buzzer_pwm_pdata_t));
if(!pdat)
return FALSE;
buzzer = malloc(sizeof(struct buzzer_t));
if(!buzzer)
{
free(pdat);
return FALSE;
}
snprintf(name, sizeof(name), "%s.%d", res->name, res->id);
timer_init(&pdat->timer, buzzer_pwm_timer_function, buzzer);
pdat->beep = queue_alloc();
pdat->frequency = 0;
pdat->polarity = rdat->polarity;
pdat->pwm = pwm;
buzzer->name = strdup(name);
buzzer->init = buzzer_pwm_init;
buzzer->exit = buzzer_pwm_exit;
buzzer->set = buzzer_pwm_set,
buzzer->get = buzzer_pwm_get,
buzzer->beep = buzzer_pwm_beep,
buzzer->suspend = buzzer_pwm_suspend,
buzzer->resume = buzzer_pwm_resume,
buzzer->priv = pdat;
if(register_buzzer(buzzer))
return TRUE;
free(buzzer->priv);
free(buzzer->name);
free(buzzer);
return FALSE;
}
static struct device_t * buzzer_pwm_probe(struct driver_t * drv, struct dtnode_t * n)
{
struct buzzer_pwm_pdata_t * pdat;
struct pwm_t * pwm;
struct buzzer_t * buzzer;
struct device_t * dev;
if(!(pwm = search_pwm(dt_read_string(n, "pwm-name", NULL))))
return NULL;
pdat = malloc(sizeof(struct buzzer_pwm_pdata_t));
if(!pdat)
return NULL;
buzzer = malloc(sizeof(struct buzzer_t));
if(!buzzer)
{
free(pdat);
return NULL;
}
timer_init(&pdat->timer, buzzer_pwm_timer_function, buzzer);
pdat->queue = queue_alloc();
pdat->pwm = pwm;
pdat->polarity = dt_read_bool(n, "pwm-polarity", 0);
pdat->frequency = -1;
buzzer->name = alloc_device_name(dt_read_name(n), dt_read_id(n));
buzzer->set = buzzer_pwm_set;
buzzer->get = buzzer_pwm_get;
buzzer->beep = buzzer_pwm_beep;
buzzer->priv = pdat;
buzzer_pwm_set(buzzer, 0);
if(!register_buzzer(&dev, buzzer))
{
timer_cancel(&pdat->timer);
queue_free(pdat->queue, iter_queue_node);
free_device_name(buzzer->name);
free(buzzer->priv);
free(buzzer);
return NULL;
}
dev->driver = drv;
return dev;
}
static bool_t buzzer_gpio_register_buzzer(struct resource_t * res)
{
struct buzzer_gpio_data_t * rdat = (struct buzzer_gpio_data_t *)res->data;
struct buzzer_gpio_pdata_t * pdat;
struct buzzer_t * buzzer;
char name[64];
pdat = malloc(sizeof(struct buzzer_gpio_pdata_t));
if(!pdat)
return FALSE;
buzzer = malloc(sizeof(struct buzzer_t));
if(!buzzer)
{
free(pdat);
return FALSE;
}
snprintf(name, sizeof(name), "%s.%d", res->name, res->id);
timer_init(&pdat->timer, buzzer_gpio_timer_function, buzzer);
pdat->beep = queue_alloc();
pdat->frequency = 0;
pdat->gpio = rdat->gpio;
pdat->active_low = rdat->active_low;
buzzer->name = strdup(name);
buzzer->init = buzzer_gpio_init;
buzzer->exit = buzzer_gpio_exit;
buzzer->set = buzzer_gpio_set,
buzzer->get = buzzer_gpio_get,
buzzer->beep = buzzer_gpio_beep,
buzzer->suspend = buzzer_gpio_suspend,
buzzer->resume = buzzer_gpio_resume,
buzzer->priv = pdat;
if(register_buzzer(buzzer))
return TRUE;
free(buzzer->priv);
free(buzzer->name);
free(buzzer);
return FALSE;
}
static bool_t sandbox_buzzer_register_buzzer(struct resource_t * res)
{
struct sandbox_buzzer_data_t * rdat = (struct sandbox_buzzer_data_t *)res->data;
struct sandbox_buzzer_private_data_t * dat;
struct buzzer_t * buzzer;
char name[64];
dat = malloc(sizeof(struct sandbox_buzzer_private_data_t));
if(!dat)
return FALSE;
buzzer = malloc(sizeof(struct buzzer_t));
if(!buzzer)
{
free(dat);
return FALSE;
}
snprintf(name, sizeof(name), "%s.%d", res->name, res->id);
timer_init(&dat->timer, sandbox_buzzer_timer_function, buzzer);
dat->beep = queue_alloc();
dat->frequency = 0;
dat->path = strdup(rdat->path);
buzzer->name = strdup(name);
buzzer->init = sandbox_buzzer_init;
buzzer->exit = sandbox_buzzer_exit;
buzzer->set = sandbox_buzzer_set,
buzzer->get = sandbox_buzzer_get,
buzzer->beep = sandbox_buzzer_beep,
buzzer->suspend = sandbox_buzzer_suspend,
buzzer->resume = sandbox_buzzer_resume,
buzzer->priv = dat;
if(register_buzzer(buzzer))
return TRUE;
free(buzzer->priv);
free(buzzer->name);
free(buzzer);
return FALSE;
}
