static int __init alarm_dev_init(void)
{
int err;
int i;
err = misc_register(&alarm_device);
if (err)
return err;
alarm_init(&alarms[ANDROID_ALARM_RTC_WAKEUP].u.alrm,
ALARM_REALTIME, devalarm_alarmhandler);
hrtimer_init(&alarms[ANDROID_ALARM_RTC].u.hrt,
CLOCK_REALTIME, HRTIMER_MODE_ABS);
alarm_init(&alarms[ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP].u.alrm,
ALARM_BOOTTIME, devalarm_alarmhandler);
hrtimer_init(&alarms[ANDROID_ALARM_ELAPSED_REALTIME].u.hrt,
CLOCK_BOOTTIME, HRTIMER_MODE_ABS);
hrtimer_init(&alarms[ANDROID_ALARM_SYSTEMTIME].u.hrt,
CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
for (i = 0; i < ANDROID_ALARM_TYPE_COUNT; i++) {
alarms[i].type = i;
if (!is_wakeup(i))
alarms[i].u.hrt.function = devalarm_hrthandler;
}
wakeup_source_init(&alarm_wake_lock, "alarm");
return 0;
}
void
app_startup(void)
{
msg_init(FALSE);
iv_set_fatal_msg_handler(app_fatal);
iv_init();
g_thread_init(NULL);
crypto_init();
hostname_global_init();
dns_caching_global_init();
dns_caching_thread_init();
afinter_global_init();
child_manager_init();
alarm_init();
stats_init();
tzset();
log_msg_global_init();
log_tags_global_init();
log_source_global_init();
log_template_global_init();
value_pairs_global_init();
service_management_init();
scratch_buffers_allocator_init();
main_loop_thread_resource_init();
nondumpable_setlogger(nondumpable_allocator_logger);
secret_storage_init();
transport_factory_id_global_init();
}
static int tps65200_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct tps65200_i2c_client *data = &tps65200_i2c_module;
struct tps65200_platform_data *pdata =
client->dev.platform_data;
if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C) == 0) {
dev_dbg(&client->dev, "[TPS65200]:I2C fail\n");
return -EIO;
}
if (pdata->charger_check) {
tps65200_chager_check = 1;
pr_info("for battery driver 8x60.\n");
INIT_WORK(&tps65200_work, tps65200_work_func);
tps65200_wq = create_singlethread_workqueue("tps65200");
alarm_init(&tps65200_check_alarm,
ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP,
tps65200_check_alarm_handler);
}
data->address = client->addr;
data->client = client;
mutex_init(&data->xfer_lock);
tps65200_initial = 1;
pr_info("[TPS65200]: Driver registration done\n");
return 0;
}
/**
* alarm_timer_nsleep_restart - restartblock alarmtimer nsleep
* @restart: ptr to restart block
*
* Handles restarted clock_nanosleep calls
*/
static long __sched alarm_timer_nsleep_restart(struct restart_block *restart)
{
enum alarmtimer_type type = restart->nanosleep.clockid;
ktime_t exp;
struct timespec __user *rmtp;
struct alarm alarm;
int ret = 0;
exp.tv64 = restart->nanosleep.expires;
alarm_init(&alarm, type, alarmtimer_nsleep_wakeup);
if (alarmtimer_do_nsleep(&alarm, exp))
goto out;
if (freezing(current))
alarmtimer_freezerset(exp, type);
rmtp = restart->nanosleep.rmtp;
if (rmtp) {
ret = update_rmtp(exp, type, rmtp);
if (ret <= 0)
goto out;
}
/* The other values in restart are already filled in */
ret = -ERESTART_RESTARTBLOCK;
out:
return ret;
}
/*------------------------------------------------------------------------
*
* startup - Finish startup takes that cannot be run from the Null
* process and then create and resume the main process
*
*------------------------------------------------------------------------
*/
local process startup(void)
{
uint32 ipaddr; /* Computer's IP address */
char str[128]; /* String used to format output */
/* Initialize the Alarm System */
alarm_init();
/* Use DHCP to obtain an IP address and format it */
ipaddr = getlocalip();
if ((int32)ipaddr == SYSERR) {
kprintf("Cannot obtain an IP address\n");
} else {
/* Print the IP in dotted decimal and hex */
ipaddr = NetData.ipucast;
sprintf(str, "%d.%d.%d.%d",
(ipaddr>>24)&0xff, (ipaddr>>16)&0xff,
(ipaddr>>8)&0xff, ipaddr&0xff);
kprintf("Obtained IP address %s (0x%08x)\n", str,
ipaddr);
}
/* Create a process to execute function main() */
resume(create((void *)main, INITSTK, INITPRIO,
"Main process", 0, NULL));
/* Startup process exits at this point */
return OK;
}
int main(void) {
init();
alarm_init();
clock_init();
display_init();
sei();
for(;;) {
clock_update();
buttons_update();
handle_buttons();
handle_display();
handle_led();
buttons_age();
clock_ticked = false;
// Check display timeout
if (mode != mode_off || status != status_none || !clock_set) { // Need the main clock
set_sleep_mode(SLEEP_MODE_IDLE);
} else {
set_sleep_mode(SLEEP_MODE_PWR_SAVE);
}
sleep_enable();
sleep_cpu();
sleep_disable();
}
}
static int __devinit bcmpmu_rpc_probe(struct platform_device *pdev)
{
int ret = 0;
struct bcmpmu59xxx *bcmpmu = dev_get_drvdata(pdev->dev.parent);
struct bcmpmu59xxx_rpc_pdata *pdata;
struct bcmpmu_rpc *bcmpmu_rpc;
pdata = (struct bcmpmu59xxx_rpc_pdata *)
pdev->dev.platform_data;
BUG_ON(pdata == NULL);
pr_rpc(INIT, "%s, called\n", __func__);
bcmpmu_rpc = kzalloc(sizeof(struct bcmpmu_rpc), GFP_KERNEL);
if (bcmpmu_rpc == NULL) {
pr_rpc(INIT, "%s: failed to alloc mem.\n", __func__);
ret = -ENOMEM;
goto err;
}
bcmpmu_rpc->bcmpmu = bcmpmu;
bcmpmu_rpc->delay = pdata->delay;
bcmpmu_rpc->fw_delay = pdata->fw_delay;
bcmpmu_rpc->fw_cnt = pdata->fw_cnt;
bcmpmu_rpc->poll_time = pdata->poll_time;
bcmpmu_rpc->htem_poll_time = pdata->htem_poll_time;
bcmpmu_rpc->mod_tem = pdata->mod_tem;
bcmpmu_rpc->htem = pdata->htem;
bcmpmu->rpcinfo = bcmpmu_rpc;
#ifndef DEACTIVATE_RPC_REPORT_SLEEP
#ifdef CONFIG_WD_TAPPER
ret = wd_tapper_add_timeout_req(&bcmpmu_rpc->wd_node, "rpc",
TAPPER_DEFAULT_TIMEOUT);
if (ret) {
pr_rpc(ERROR, "failed to register with wd-tapper\n");
goto err1;
}
#else
alarm_init(&bcmpmu_rpc->alarm,
ALARM_REALTIME, bcmpmu_rpc_alarm_callback);
#endif /*CONFIG_WD_TAPPER*/
#endif
INIT_DELAYED_WORK(&bcmpmu_rpc->work, bcmpmu_rpc_work);
#ifdef CONFIG_DEBUG_FS
bcmpmu_rpc_dbg_init(bcmpmu_rpc);
#endif
schedule_delayed_work(&bcmpmu_rpc->work,
msecs_to_jiffies(bcmpmu_rpc->fw_delay));
err:
return ret;
#ifndef DEACTIVATE_RPC_REPORT_SLEEP
#ifdef CONFIG_WD_TAPPER
err1:
kfree(bcmpmu_rpc);
#endif /*CONFIG_WD_TAPPER*/
#endif
return ret;
}
void app_init(void)
{
app_mode = M_LOGO;
app_running = 0;
clock_init();
alarm_init();
logo_init();
}
static int __init suspend_autotest_init(void)
{
#if USE_ANDROID_ALARM
alarm_init(&alarm_dev, alarm_type, alarm_triggered);
#endif
platform_device_register(&suspend_autotest_device);
return platform_driver_register(&suspend_autotest_driver);
}
alarm_t *alarm_new(alarm_context_t *context, const char *name,
alarm_callback_t callback, void *data)
{
alarm_t *new_alarm;
new_alarm = lib_malloc(sizeof(alarm_t));
alarm_init(new_alarm, context, name, callback, data);
return new_alarm;
}
void upsdrv_updateinfo(void)
{
alarm_init();
/* poll status values values */
sec_poll(FLAG_POLL);
alarm_commit();
update_pseudovars();
dstate_dataok();
}
static void notification_trig_activate(struct led_classdev *led_cdev)
{
struct notification_trig_data *timer_data;
int rc;
timer_data = kzalloc(sizeof(struct notification_trig_data), GFP_KERNEL);
if (!timer_data)
return;
timer_data->brightness_on = led_get_brightness(led_cdev);
if (timer_data->brightness_on == LED_OFF)
timer_data->brightness_on = led_cdev->max_brightness;
led_cdev->trigger_data = timer_data;
init_timer(&timer_data->timer);
timer_data->timer.function = led_timer_function;
timer_data->timer.data = (unsigned long) led_cdev;
alarm_init(&timer_data->alarm, ANDROID_ALARM_RTC_WAKEUP,
led_rtc_timer_function);
wake_lock_init(&timer_data->wakelock, WAKE_LOCK_SUSPEND, "ledtrig_rtc_timer");
rc = device_create_file(led_cdev->dev, &dev_attr_delay_on);
if (rc)
goto err_out;
rc = device_create_file(led_cdev->dev, &dev_attr_delay_off);
if (rc)
goto err_out_delayon;
rc = device_create_file(led_cdev->dev, &dev_attr_blink_count);
if (rc)
goto err_attr_delay_off;
rc = device_create_file(led_cdev->dev, &dev_attr_off_duration);
if (rc)
goto err_attr_blink_count;
/* If there is hardware support for blinking, start one
* user friendly blink rate chosen by the driver.
*/
if (led_cdev->blink_set)
led_cdev->blink_set(led_cdev,
&timer_data->delay_on, &timer_data->delay_off);
return;
err_attr_blink_count:
device_remove_file(led_cdev->dev, &dev_attr_blink_count);
err_attr_delay_off:
device_remove_file(led_cdev->dev, &dev_attr_delay_off);
err_out_delayon:
device_remove_file(led_cdev->dev, &dev_attr_delay_on);
err_out:
led_cdev->trigger_data = NULL;
kfree(timer_data);
}
void testAlarmInitButNotStartHasZeroedHead(void) {
alarm_init();
// guarantee that there's no zero at the handler, so that we don't reset.
alarm_queue->head->e.handler = dummy_handler;
if(!assert_not_null(alarm_queue)) return;
event_t* head = relative_queue_head(alarm_queue);
if(!assert_equal_uint16(0, head->rank)) return;
}
int
main(int argc, char **argv)
{
freopen("/tmp/scylla.log", "a+", stderr);
if (argc<3 || argc>4)
{
printf("Usage: %s directory password [ssl-key]\n"
"\tRun Scylla (this here) from inetd.\n"
"\tScylla assumes that Charybdis feeds a file [with SSL].\n"
"\tScylla writes the file into the given directory.\n"
"\tMissing sub-directories are created as needed.\n"
"\tExisting files are renamed.\n", argv[0]);
return 1;
}
if (chdir(argv[1]))
ex("chdir");
sock = 0;
#ifndef NO_SSL
tino_ssl_server((argc>3 ? argv[3] : "/etc/scylla.pem"));
#endif
alarm_init(30,10);
if (sread_match(argv[2], 0))
ex("auth fail");
swrite("scylla " VERSION);
do
{
char *name;
name = sread();
if (!strcmp(name, "..") || !strncmp(name, "../", 3) ||
*name=='/' || strstr(name, "/../"))
ex("- illegal filename");
dofile(name);
free(name);
}
while (!sread_match("m", 0));
#ifndef NO_SSL
tino_ssl_close();
#endif
return 0;
}
/**
* alarm_timer_nsleep - alarmtimer nanosleep
* @which_clock: clockid
* @flags: determins abstime or relative
* @tsreq: requested sleep time (abs or rel)
* @rmtp: remaining sleep time saved
*
* Handles clock_nanosleep calls against _ALARM clockids
*/
static int alarm_timer_nsleep(const clockid_t which_clock, int flags,
struct timespec *tsreq, struct timespec __user *rmtp)
{
enum alarmtimer_type type = clock2alarm(which_clock);
struct alarm alarm;
ktime_t exp;
int ret = 0;
struct restart_block *restart;
if (!alarmtimer_get_rtcdev())
return -ENOTSUPP;
if (!capable(CAP_WAKE_ALARM))
return -EPERM;
alarm_init(&alarm, type, alarmtimer_nsleep_wakeup);
exp = timespec_to_ktime(*tsreq);
/* Convert (if necessary) to absolute time */
if (flags != TIMER_ABSTIME) {
ktime_t now = alarm_bases[type].gettime();
exp = ktime_add(now, exp);
}
if (alarmtimer_do_nsleep(&alarm, exp))
goto out;
if (freezing(current))
alarmtimer_freezerset(exp, type);
/* abs timers don't set remaining time or restart */
if (flags == TIMER_ABSTIME) {
ret = -ERESTARTNOHAND;
goto out;
}
if (rmtp) {
ret = update_rmtp(exp, type, rmtp);
if (ret <= 0)
goto out;
}
restart = ¤t_thread_info()->restart_block;
restart->fn = alarm_timer_nsleep_restart;
restart->nanosleep.clockid = type;
restart->nanosleep.expires = exp.tv64;
restart->nanosleep.rmtp = rmtp;
ret = -ERESTART_RESTARTBLOCK;
out:
return ret;
}
/*
* Initialization.
* Initializes reaper and idle threads, starts and initializes main thread.
* Also creates the scheduler and other data
*
*/
void minithread_system_initialize(proc_t mainproc, arg_t mainarg) {
//allocate room for schedule data (global)
schedule_data = (scheduler *) malloc(sizeof(scheduler));
if (schedule_data == NULL) {
exit(1); //OOM
}
schedule_data->cleanup_queue = queue_new();
schedule_data->multi_run_queue = multilevel_queue_new(num_levels);
reaper_sema = semaphore_create();
semaphore_initialize(reaper_sema, 0);
// create main thread
minithread_t* main_thread = minithread_fork(mainproc, mainarg);
// initialize idle thread
idle_thread = (minithread_t *) malloc(sizeof(minithread_t));
idle_thread->stacktop = NULL;
idle_thread->thread_id = -1;
//initialize alarm bookeeping data structure (priority queue)
alarm_init();
//remove from run queue and run it
schedule_data->running_thread = main_thread;
main_thread->status = RUNNING;
multilevel_queue_dequeue(schedule_data->multi_run_queue, 0, (void *) main_thread);
//reaper thread init
reaper_thread = minithread_create(reaper_queue_cleanup, NULL);
minithread_start(reaper_thread);
//Start clock
minithread_clock_init(clock_period, clock_handler);
//Initialize network
network_initialize(network_handler);
//START MAIN PROC
//minithread_switch also enables clock interrupts
minithread_switch(&idle_thread->stacktop, &main_thread->stacktop);
//always comes back here to idle in the kernel level (allows freeing resources)
while (1) {
minithread_t* next = next_runnable();
set_interrupt_level(DISABLED);
next->status = RUNNING;
schedule_data->running_thread = next;
minithread_switch(&idle_thread->stacktop, &next->stacktop);
}
}
static void timer_trig_activate(struct led_classdev *led_cdev)
{
struct timer_trig_data *timer_data;
int rc;
timer_data = kzalloc(sizeof(struct timer_trig_data), GFP_KERNEL);
if (!timer_data)
return;
timer_data->brightness_on = led_get_brightness(led_cdev);
if (timer_data->brightness_on == LED_OFF)
timer_data->brightness_on = led_cdev->max_brightness;;
led_cdev->trigger_data = timer_data;
init_timer(&timer_data->timer);
timer_data->timer.function = led_timer_function;
timer_data->timer.data = (unsigned long) led_cdev;
#if (CONFIG_RTC_LEDTRIG_TIMER==1)
alarm_init(&timer_data->alarm, ANDROID_ALARM_RTC_WAKEUP,
led_rtc_timer_function);
wake_lock_init(&timer_data->wakelock, WAKE_LOCK_SUSPEND, "ledtrig_rtc_timer");
#elif (CONFIG_RTC_LEDTRIG_TIMER==2)
hrtimer_init(&timer_data->hrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
timer_data->hrtimer.function = ledtrig_hrtimer_function;
msm_pm_request_wakeup(&timer_data->hrtimer);
#endif
#if 1 //0 // hanapark_DF22
rc = device_create_file(led_cdev->dev, &dev_attr_delay_on);
if (rc)
goto err_out;
rc = device_create_file(led_cdev->dev, &dev_attr_delay_off);
if (rc)
goto err_out_delayon;
#endif // hanapark_DF22
/* If there is hardware support for blinking, start one
* user friendly blink rate chosen by the driver.
*/
if (led_cdev->blink_set)
led_cdev->blink_set(led_cdev,
&timer_data->delay_on, &timer_data->delay_off);
return;
err_out_delayon:
device_remove_file(led_cdev->dev, &dev_attr_delay_on);
err_out:
led_cdev->trigger_data = NULL;
kfree(timer_data);
}
unsigned alarm(unsigned sec)
{
if (!bAlarmInit) alarm_init();
if (sec)
{
uTime = sec;
bAlarmRunning = TRUE;
}
else
bAlarmRunning = FALSE;
return 0;
}
long alarm(long sec)
{
if (_osmode == DOS_MODE) return 0L;
if (!bAlarmInit) alarm_init();
if (sec)
{
ulTime = sec;
bAlarmRunning = TRUE;
}
else
bAlarmRunning = FALSE;
return 0L;
}
static void init()
{
// OSCCAL = 71;
clock_prescale_set(CPU_DIV);
// power_twi_disable();
// power_usart0_disable();
// power_timer0_disable();
// power_timer1_disable();
// power_timer2_disable();
// power_adc_disable();
#if !UART_ENABLE
power_usart0_disable();
#endif
// Pull-up on unused pins
pinPullup(D0, PULLUP_ENABLE);
pinPullup(D1, PULLUP_ENABLE);
pinPullup(D3, PULLUP_ENABLE);
pinPullup(D4, PULLUP_ENABLE);
pinPullup(B7, PULLUP_ENABLE);
#if PIN_DEBUG != PIN_DEBUG_NONE
pinMode(PIN_DEBUG_PIN, OUTPUT);
#endif
// Pin change interrupt on USB power sense pin
PCICR |= _BV(PCIE0);
PCMSK0 |= _BV(PCINT6);
// Everything else
uart_init();
spi_init();
i2c_init();
watchconfig_init();
led_init();
buzzer_init();
battery_init();
ds3231_init();
buttons_init();
millis_init();
pwrmgr_init();
time_init();
alarm_init();
oled_init();
}
static int __init alarm_dev_init(void)
{
int err;
int i;
err = misc_register(&alarm_device);
if (err)
return err;
for (i = 0; i < ANDROID_ALARM_TYPE_COUNT; i++)
alarm_init(&alarms[i], i, alarm_triggered);
wake_lock_init(&alarm_wake_lock, WAKE_LOCK_SUSPEND, "alarm");
return 0;
}
/**
* alarm_timer_create - posix timer_create interface
* @new_timer: k_itimer pointer to manage
*
* Initializes the k_itimer structure.
*/
static int alarm_timer_create(struct k_itimer *new_timer)
{
enum alarmtimer_type type;
struct alarm_base *base;
if (!alarmtimer_get_rtcdev())
return -ENOTSUPP;
if (!capable(CAP_WAKE_ALARM))
return -EPERM;
type = clock2alarm(new_timer->it_clock);
base = &alarm_bases[type];
alarm_init(&new_timer->it.alarmtimer, type, alarm_handle_timer);
return 0;
}
void
app_startup(void)
{
#if ENABLE_THREADS
g_thread_init(NULL);
#endif
update_g_current_time();
msg_init(FALSE);
child_manager_init();
file_manager_init();
dns_cache_init();
alarm_init();
stats_init();
tzset();
log_msg_global_init();
log_tags_init();
}
static int __init alarm_dev_init(void)
{
int err;
int i;
err = misc_register(&alarm_device);
if (err)
return err;
for (i = 0; i < ANDROID_ALARM_TYPE_COUNT; i++)
{
alarm_init(&alarms[i], i, alarm_triggered);
//pr_debug("PM_DEBUG_MXP: alarm_init: type %d",i);
}
wake_lock_init(&alarm_wake_lock, WAKE_LOCK_SUSPEND, "alarm");
return 0;
}
int main(int argc, char *argv[])
{
srand(time(0));
log_init("httpsrv.log", 1);
log_set_level(LOG_LEVEL_DEBUG);
DEBUG("httpsrv has started.");
signal(SIGINT, sig_handler);
alarm_init();
if(net_create(&net, "8080"))
return -1;
connmgr_init(net);
while(1)
net_process(net, -1);
connmgr_close();
net_free(&net);
alarm_close();
log_close();
return 0;
}
void
app_startup(void)
{
main_thread_handle = g_thread_self();
msg_init(FALSE);
iv_init();
g_thread_init(NULL);
afinter_global_init();
child_manager_init();
dns_cache_init();
alarm_init();
stats_init();
tzset();
log_msg_global_init();
log_tags_init();
log_source_global_init();
log_template_global_init();
}
void
app_startup(void)
{
msg_init(FALSE);
iv_set_fatal_msg_handler(app_fatal);
iv_init();
g_thread_init(NULL);
hostname_global_init();
dns_cache_global_init();
dns_cache_thread_init();
afinter_global_init();
child_manager_init();
alarm_init();
stats_init();
tzset();
log_msg_global_init();
log_tags_global_init();
log_source_global_init();
log_template_global_init();
service_management_init();
}
/**
* \brief init scheduler
* \param[in] idle the initial idle thread
* \return 0 on success, or a negative error code otherwise
*
* This initializes the scheduler. The passed thread is the idle
* thread. It is added to the thread list automatically.
*/
int
sched_init(struct tcb* idle)
{
assert(idle);
for (size_t i = 0; i < ARRAY_NELEMS(g_current_thread); ++i) {
g_current_thread[i] = idle;
}
for (size_t i = 0; i < ARRAY_NELEMS(g_thread); ++i) {
list_init_head(g_thread + i);
}
alarm_init(&g_alarm, alarm_handler);
int res = timer_add_alarm(&g_alarm, sched_timeout());
if (res < 0) {
goto err_timer_add_alarm;
}
res = sched_add_thread(idle, 0);
if (res < 0) {
goto err_sched_add_thread;
}
return 0;
err_sched_add_thread:
timer_remove_alarm(&g_alarm);
err_timer_add_alarm:
for (size_t i = ARRAY_NELEMS(g_current_thread); i;) {
--i;
g_current_thread[i] = NULL;
}
return res;
}
int bln_control_register(struct led_classdev *pdev)
{
int ret;
bln_keypad_dev = pdev;
bln_suspended = bln_on = bln_ongoing = false;
pr_info("%s misc_register(%s)\n", __FUNCTION__, bln_device.name);
ret = misc_register(&bln_device);
if (ret) {
pr_err("%s misc_register(%s) fail\n", __FUNCTION__, bln_device.name);
return 1;
}
/* add the bln attributes */
if (sysfs_create_group(&bln_device.this_device->kobj, &bln_notification_group) < 0) {
pr_err("%s sysfs_create_group fail\n", __FUNCTION__);
pr_err("Failed to create sysfs group for device (%s)!\n", bln_device.name);
return 1;
}
register_early_suspend(&bln_suspend_data);
#ifdef USE_TOUCH_TIMEOUT
setup_timer(&bln_timer, bln_timer_callback, 0);
#endif
bln_blink_workqueue = create_singlethread_workqueue("bln_blink_work");
INIT_DELAYED_WORK(&bln_blink_work, bln_blink_queue_handler);
alarm_init(&bln_blink_alarm, ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP, bln_blink_alarm_handler);
wake_lock_init(&bln_blink_wakelock, WAKE_LOCK_SUSPEND, "bln_blink_wake");
return 0;
}
static int pm8058_led_probe(struct platform_device *pdev)
{
struct pm8058_led_platform_data *pdata;
struct pm8058_led_data *ldata;
int i, ret;
ret = -ENOMEM;
pdata = pdev->dev.platform_data;
if (pdata == NULL) {
LED_ERR_LOG("%s: platform data is NULL\n", __func__);
return -ENODEV;
}
if (!pdata->num_leds) {
LED_ERR_LOG("%s: LED num is 0\n", __func__);
return 0;
}
ldata = kzalloc(sizeof(struct pm8058_led_data)
* pdata->num_leds, GFP_KERNEL);
if (ldata == NULL) {
ret = -ENOMEM;
LED_ERR_LOG("%s: failed on allocate ldata\n", __func__);
goto err_exit;
}
dev_set_drvdata(&pdev->dev, ldata);
wake_lock_init(&pmic_led_wake_lock, WAKE_LOCK_SUSPEND, "pmic_led");
g_led_work_queue = create_workqueue("led");
if (!g_led_work_queue)
goto err_create_work_queue;
for (i = 0; i < 64; i++) {
duty_array[i] = pdata->duties[i];
duties[i] = pdata->duties[i];
}
for (i = 0; i < pdata->num_leds; i++) {
ldata[i].led_config = pdata->led_config + i;
ldata[i].ldev.name = pdata->led_config[i].name;
ldata[i].bank = pdata->led_config[i].bank;
ldata[i].flags = pdata->led_config[i].flags;
ldata[i].pwm_size = pdata->led_config[i].pwm_size;
ldata[i].clk = pdata->led_config[i].clk;
ldata[i].pre_div = pdata->led_config[i].pre_div;
ldata[i].pre_div_exp = pdata->led_config[i].pre_div_exp;
ldata[i].pwm_value = pdata->led_config[i].pwm_value;
ldata[i].period_us = pdata->led_config[i].period_us;
ldata[i].start_index = pdata->led_config[i].start_index;
ldata[i].duites_size = pdata->led_config[i].duites_size;
ldata[i].duty_time_ms = pdata->led_config[i].duty_time_ms;
ldata[i].lut_flag = pdata->led_config[i].lut_flag;
ldata[i].out_current = pdata->led_config[i].out_current;
switch (pdata->led_config[i].type) {
case PM8058_LED_CURRENT:
if (ldata[i].flags & PM8058_LED_BLINK_EN)
INIT_DELAYED_WORK(&ldata[i].led_delayed_work,
led_blink_do_work);
else
INIT_DELAYED_WORK(&ldata[i].led_delayed_work,
pwm_lut_delayed_fade_out);
ldata[i].pwm_led = pwm_request(ldata[i].bank,
ldata[i].ldev.name);
ldata[i].ldev.brightness_set =
pm8058_drvx_led_brightness_set;
break;
case PM8058_LED_RGB:
INIT_DELAYED_WORK(&ldata[i].led_delayed_work,
led_blink_do_work);
case PM8058_LED_PWM:
ldata[i].pwm_led = pwm_request(ldata[i].bank,
ldata[i].ldev.name);
ldata[i].ldev.brightness_set =
pm8058_pwm_led_brightness_set;
break;
case PM8058_LED_DRVX:
if (ldata[i].flags & PM8058_LED_BLINK_EN)
INIT_DELAYED_WORK(&ldata[i].led_delayed_work,
led_blink_do_work);
else
INIT_DELAYED_WORK(&ldata[i].led_delayed_work,
pwm_lut_delayed_fade_out);
ldata[i].pwm_led = pwm_request(ldata[i].bank,
ldata[i].ldev.name);
ldata[i].ldev.brightness_set =
pm8058_drvx_led_brightness_set;
break;
}
ret = led_classdev_register(&pdev->dev, &ldata[i].ldev);
if (ret < 0) {
LED_ERR_LOG("%s: failed on led_classdev_register [%s]\n",
__func__, ldata[i].ldev.name);
goto err_register_led_cdev;
}
if (ldata[i].flags & PM8058_LED_LTU_EN)
for_key_led_data = &ldata[i];
}
for (i = 0; i < pdata->num_leds; i++) {
if (pdata->led_config[i].type == PM8058_LED_RGB ||
ldata[i].flags & PM8058_LED_BLINK_EN) {
ret = device_create_file(ldata[i].ldev.dev,
&dev_attr_blink);
if (ret < 0) {
LED_ERR_LOG("%s: Failed to create attr blink"
" [%d]\n", __func__, i);
goto err_register_attr_blink;
}
}
}
for (i = 0; i < pdata->num_leds; i++) {
if (pdata->led_config[i].type == PM8058_LED_RGB ||
ldata[i].flags & PM8058_LED_BLINK_EN) {
ret = device_create_file(ldata[i].ldev.dev,
&dev_attr_off_timer);
if (ret < 0) {
LED_ERR_LOG("%s: Failed to create attr off timer"
" [%d]\n", __func__, i);
goto err_register_attr_off_timer;
}
INIT_WORK(&ldata[i].led_work, led_work_func);
alarm_init(&ldata[i].led_alarm,
ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP,
led_alarm_handler);
}
}
for (i = 0; i < pdata->num_leds; i++) {
if (ldata[i].bank < 3)
continue;
ret = device_create_file(ldata[i].ldev.dev, &dev_attr_currents);
if (ret < 0) {
LED_ERR_LOG("%s: Failed to create attr blink [%d]\n",
__func__, i);
goto err_register_attr_currents;
}
}
for (i = 0; i < pdata->num_leds; i++) {
if (pdata->led_config[i].type == PM8058_LED_DRVX)
ret = device_create_file(ldata[i].ldev.dev, &dev_attr_lut_coefficient);
if (ret < 0) {
LED_ERR_LOG("%s: Failed to create %d attr lut_coefficient\n", __func__, i);
goto err_register_attr_lut_coefficient;
}
}
for (i = 0; i < pdata->num_leds; i++) {
if (pdata->led_config[i].type == PM8058_LED_RGB)
ret = device_create_file(ldata[i].ldev.dev, &dev_attr_pwm_coefficient);
if (ret < 0) {
LED_ERR_LOG("%s: Failed to create %d attr pwm_coefficient\n", __func__, i);
goto err_register_attr_pwm_coefficient;
}
}
#ifdef CONFIG_TOUCHSCREEN_ATMEL_SWEEP2WAKE
if (!strcmp(pdata->led_config[2].name, "button-backlight")) {
sweep2wake_setleddev(&ldata[2].ldev);
printk(KERN_INFO "[sweep2wake]: set led device %s, bank %d\n", pdata->led_config[2].name, ldata[2].bank);
}
#endif
return 0;
err_register_attr_pwm_coefficient:
if (i > 0) {
for (i = i - 1; i >= 0; i--) {
if (pdata->led_config[i].type == PM8058_LED_RGB)
device_remove_file(ldata[i].ldev.dev, &dev_attr_pwm_coefficient);
}
}
i = pdata->num_leds;
err_register_attr_lut_coefficient:
if (i > 0) {
for (i = i - 1; i >= 0; i--) {
if (pdata->led_config[i].type == PM8058_LED_DRVX)
device_remove_file(ldata[i].ldev.dev, &dev_attr_lut_coefficient);
}
}
i = pdata->num_leds;
err_register_attr_currents:
for (i--; i >= 0; i--) {
if (ldata[i].bank < 3)
continue;
device_remove_file(ldata[i].ldev.dev, &dev_attr_currents);
}
i = pdata->num_leds;
err_register_attr_off_timer:
for (i--; i >= 0; i--) {
if (pdata->led_config[i].type == PM8058_LED_RGB ||
ldata[i].flags & PM8058_LED_BLINK_EN) {
device_remove_file(ldata[i].ldev.dev,
&dev_attr_off_timer);
}
}
i = pdata->num_leds;
err_register_attr_blink:
for (i--; i >= 0; i--) {
if (pdata->led_config[i].type == PM8058_LED_RGB ||
ldata[i].flags & PM8058_LED_BLINK_EN) {
device_remove_file(ldata[i].ldev.dev, &dev_attr_blink);
}
}
i = pdata->num_leds;
err_register_led_cdev:
for (i--; i >= 0; i--) {
switch (pdata->led_config[i].type) {
case PM8058_LED_RGB:
case PM8058_LED_PWM:
case PM8058_LED_DRVX:
pwm_free(ldata[i].pwm_led);
break;
}
led_classdev_unregister(&ldata[i].ldev);
}
destroy_workqueue(g_led_work_queue);
err_create_work_queue:
kfree(ldata);
err_exit:
wake_lock_destroy(&pmic_led_wake_lock);
return ret;
}
