static int __init cpufreq_interactive_init(void)
{
unsigned int i;
struct timer_list *t;
min_sample_time = DEFAULT_MIN_SAMPLE_TIME;
/* find nr_running addres */
nr_running_addr = (nr_running_type)kallsyms_lookup_name("nr_running");
if (!nr_running_addr)
return -1;
/* Initalize per-cpu timers */
for_each_possible_cpu(i) {
t = &per_cpu(cpu_timer, i);
init_timer_deferrable(t);
t->function = cpufreq_interactive_timer;
t->data = i;
}
/* Scale up is high priority */
up_wq = create_rt_workqueue("kinteractive_up");
down_wq = create_workqueue("knteractive_down");
INIT_WORK(&freq_scale_work, cpufreq_interactive_freq_change_time_work);
return cpufreq_register_governor(&cpufreq_gov_interactive);
}
static int __devinit cypress_ts_init(void)
{
//ZTE_SET_BIT_WLY_0518,BEGIN
cypress_wq = create_rt_workqueue("cypress_wq");
//ZTE_SET_BIT_WLY_0518,END
if (!cypress_wq)
return -ENOMEM;
return i2c_add_driver(&cypress_ts_driver);
}
static S3C_BOOL CreateVsyncWorkQueue(S3C_LCD_DEVINFO *psDevInfo)
{
psDevInfo->psWorkQueue = create_rt_workqueue("vsync_workqueue");
if (psDevInfo->psWorkQueue == IMG_NULL)
{
printk("fail to create vsync_handler workqueue\n");
return S3C_FALSE;
}
INIT_WORK(&psDevInfo->sWork, VsyncWorkqueueFunc);
mutex_init(&psDevInfo->sVsyncFlipItemMutex);
return S3C_TRUE;
}
/*
* row_init_queue() - Init scheduler data structures
* @q: requests queue
*
* Return pointer to struct row_data to be saved in elevator for
* this dispatch queue
*
*/
static void *row_init_queue(struct request_queue *q)
{
struct row_data *rdata;
int i;
rdata = kmalloc_node(sizeof(*rdata),
GFP_KERNEL | __GFP_ZERO, q->node);
if (!rdata)
return NULL;
for (i = 0; i < ROWQ_MAX_PRIO; i++) {
INIT_LIST_HEAD(&rdata->row_queues[i].fifo);
rdata->row_queues[i].disp_quantum = row_queues_def[i].quantum;
rdata->row_queues[i].rdata = rdata;
rdata->row_queues[i].prio = i;
rdata->row_queues[i].idle_data.begin_idling = false;
rdata->row_queues[i].idle_data.last_insert_time =
ktime_set(0, 0);
}
/*
* Currently idling is enabled only for READ queues. If we want to
* enable it for write queues also, note that idling frequency will
* be the same in both cases
*/
rdata->read_idle.idle_time = msecs_to_jiffies(ROW_IDLE_TIME_MSEC);
/* Maybe 0 on some platforms */
if (!rdata->read_idle.idle_time)
rdata->read_idle.idle_time = 1;
rdata->read_idle.freq = ROW_READ_FREQ_MSEC;
//Hack, or should I port entire workqueue...
rdata->read_idle.idle_workqueue = create_rt_workqueue( "row_idle_work" );
//alloc_workqueue("row_idle_work",
// WQ_MEM_RECLAIM | WQ_HIGHPRI, 0);
if (!rdata->read_idle.idle_workqueue)
panic("Failed to create idle workqueue\n");
INIT_DELAYED_WORK(&rdata->read_idle.idle_work, kick_queue);
rdata->curr_queue = ROWQ_PRIO_HIGH_READ;
rdata->dispatch_queue = q;
rdata->nr_reqs[READ] = rdata->nr_reqs[WRITE] = 0;
return rdata;
}
int stop_machine_create(void)
{
mutex_lock(&setup_lock);
if (refcount)
goto done;
stop_machine_wq = create_rt_workqueue("kstop");
if (!stop_machine_wq)
goto err_out;
stop_machine_work = alloc_percpu(struct work_struct);
if (!stop_machine_work)
goto err_out;
done:
refcount++;
mutex_unlock(&setup_lock);
return 0;
err_out:
if (stop_machine_wq)
destroy_workqueue(stop_machine_wq);
mutex_unlock(&setup_lock);
return -ENOMEM;
}
static int __init cpufreq_interactive_init(void)
{
unsigned int i;
struct timer_list *t;
min_sample_time = DEFAULT_MIN_SAMPLE_TIME;
/* Initalize per-cpu timers */
for_each_possible_cpu(i) {
t = &per_cpu(cpu_timer, i);
init_timer_deferrable(t);
t->function = cpufreq_interactive_timer;
t->data = i;
}
/* Scale up is high priority */
up_wq = create_rt_workqueue("kinteractive_up");
down_wq = create_workqueue("knteractive_down");
INIT_WORK(&freq_scale_work, cpufreq_interactive_freq_change_time_work);
pr_info("[imoseyon] interactive enter\n");
return cpufreq_register_governor(&cpufreq_gov_interactive);
}
static int __init stop_machine_init(void)
{
stop_machine_wq = create_rt_workqueue("kstop");
stop_machine_work = alloc_percpu(struct work_struct);
return 0;
}
static int __devinit nas_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct ts_nas *ts;
struct nas_platform_data *pdata = pdata = client->dev.platform_data;
struct input_dev *input_dev;
int err;
if (!pdata) {
dev_err(&client->dev, "platform data is required!\n");
return -EINVAL;
}
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
return -EIO;
ts = kzalloc(sizeof(struct ts_nas), GFP_KERNEL);
input_dev = input_allocate_device();
if (!ts || !input_dev) {
err = -ENOMEM;
goto err_free_mem;
}
ts->client = client;
ts->irq = client->irq;
ts->input = input_dev;
ts->status =0 ;// fjp add by 2010-9-30
ts->pendown = 0; // fjp add by 2010-10-06
ts->wq = create_rt_workqueue("nas_wq");
INIT_DELAYED_WORK(&ts->work, nas_work);
#ifdef CHECK_STATUS
ts->wq1 = create_rt_workqueue("nas_wq1");
INIT_DELAYED_WORK(&ts->work1, nas_status_check_work);
#endif
ts->model = pdata->model;
snprintf(ts->phys, sizeof(ts->phys),
"%s/input0", dev_name(&client->dev));
input_dev->name = "nas Touchscreen";
input_dev->phys = ts->phys;
input_dev->id.bustype = BUS_I2C;
ts->has_relative_report = 0;
input_dev->evbit[0] = BIT_MASK(EV_ABS)|BIT_MASK(EV_KEY)|BIT_MASK(EV_SYN);
input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
input_dev->keybit[BIT_WORD(BTN_2)] = BIT_MASK(BTN_2); //jaocbchen for dual
#if 0
input_set_abs_params(input_dev, ABS_X, 0, CONFIG_HANNSTAR_MAX_X, 0, 0);
input_set_abs_params(input_dev, ABS_Y, 0, CONFIG_HANNSTAR_MAX_Y, 0, 0);
input_set_abs_params(input_dev, ABS_PRESSURE, 0, 255, 0, 0);
input_set_abs_params(input_dev, ABS_TOOL_WIDTH, 0, 15, 0, 0);
input_set_abs_params(input_dev, ABS_HAT0X, 0, CONFIG_HANNSTAR_MAX_X, 0, 0);
input_set_abs_params(input_dev, ABS_HAT0Y, 0, CONFIG_HANNSTAR_MAX_Y, 0, 0);
input_set_abs_params(input_dev, ABS_MT_POSITION_X,0, CONFIG_HANNSTAR_MAX_X, 0, 0);
input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0, CONFIG_HANNSTAR_MAX_Y, 0, 0);
input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
input_set_abs_params(input_dev, ABS_MT_WIDTH_MAJOR, 0, 255, 0, 0);
input_set_abs_params(input_dev, ABS_MT_TRACKING_ID, 0, 10, 0, 0);
#else
input_set_abs_params(input_dev, ABS_X, 0, TOUCH_REPORT_X_MAX, 0, 0);
input_set_abs_params(input_dev, ABS_Y, 0, TOUCH_REPORT_Y_MAX, 0, 0);
input_set_abs_params(input_dev, ABS_PRESSURE, 0, 1, 0, 0);
input_set_abs_params(input_dev, ABS_HAT0X, 0, TOUCH_REPORT_X_MAX, 0, 0);
input_set_abs_params(input_dev, ABS_HAT0Y, 0, TOUCH_REPORT_Y_MAX, 0, 0);
input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0, TOUCH_REPORT_X_MAX, 0, 0);
input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0, TOUCH_REPORT_Y_MAX, 0, 0);
input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
input_set_abs_params(input_dev, ABS_MT_WIDTH_MAJOR, 0, 15, 0, 0);
#endif
if (pdata->init_platform_hw)
pdata->init_platform_hw();
if (!ts->irq) {
dev_dbg(&ts->client->dev, "no IRQ?\n");
return -ENODEV;
}else{
ts->irq = gpio_to_irq(ts->irq);
}
//miaozh modify
err = request_irq(ts->irq, nas_irq, GPIOEdgelFalling,
client->dev.driver->name, ts);
// err = request_irq(ts->irq, nas_irq, 0,
// client->dev.driver->name, ts);
if (err < 0) {
dev_err(&client->dev, "irq %d busy?\n", ts->irq);
goto err_free_mem;
}
if (err < 0)
goto err_free_irq;
#if 0
err = set_irq_type(ts->irq,IRQ_TYPE_LEVEL_LOW);
if (err < 0) {
dev_err(&client->dev, "irq %d busy?\n", ts->irq);
goto err_free_mem;
}
if (err < 0)
goto err_free_irq;
#endif
err = input_register_device(input_dev);
if (err)
goto err_free_irq;
i2c_set_clientdata(client, ts);
nas_check_firmwork(ts);
nas_tp_debug_ctl_entry = create_proc_entry("nas_tp_debug_ctl", 0644, NULL);
if (nas_tp_debug_ctl_entry) {
nas_tp_debug_ctl_entry->read_proc = NULL;
nas_tp_debug_ctl_entry->write_proc = nas_tp_debug_ctl;
}
#ifdef CONFIG_HAS_EARLYSUSPEND
register_early_suspend(&nastech_early_suspend);
#endif
#ifdef CHECK_STATUS
setup_timer(&ts->status_check_timer, nas_status_check_timer, (unsigned long)ts);
ts->status_check_timer.expires = jiffies + msecs_to_jiffies(1000);
add_timer(&ts->status_check_timer);
#endif
return 0;
err_free_irq:
nas_free_irq(ts);
if (pdata->exit_platform_hw)
pdata->exit_platform_hw();
err_free_mem:
input_free_device(input_dev);
kfree(ts);
return err;
}
static int watchdog_probe(struct platform_device *pdev)
{
watchdog_wq = create_rt_workqueue("pet_watchdog");
watchdog_start();
return 0;
}
int shrm_protocol_init(struct shrm_dev *shrm,
received_msg_handler common_rx_handler,
received_msg_handler audio_rx_handler)
{
int err;
shm_dev = shrm;
boot_state = BOOT_INIT;
dev_info(shrm->dev, "IPC_ISA BOOT_INIT\n");
rx_common_handler = common_rx_handler;
rx_audio_handler = audio_rx_handler;
atomic_set(&ac_sleep_disable_count, 0);
is_earlydrop = cpu_is_u8500ed();
if (is_earlydrop != 0x01) {
hrtimer_init(&timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
timer.function = callback;
}
hrtimer_init(&mod_stuck_timer_0, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
mod_stuck_timer_0.function = shm_mod_stuck_timeout;
hrtimer_init(&mod_stuck_timer_1, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
mod_stuck_timer_1.function = shm_mod_stuck_timeout;
hrtimer_init(&fifo_full_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
fifo_full_timer.function = shm_fifo_full_timeout;
shrm->shm_common_ch_wr_wq = create_singlethread_workqueue
("shm_common_channel_irq");
if (!shrm->shm_common_ch_wr_wq) {
dev_err(shrm->dev, "failed to create work queue\n");
return -ENOMEM;
}
shrm->shm_audio_ch_wr_wq = create_rt_workqueue
("shm_audio_channel_irq");
if (!shrm->shm_audio_ch_wr_wq) {
dev_err(shrm->dev, "failed to create work queue\n");
err = -ENOMEM;
goto free_wq1;
}
shrm->shm_ac_wake_wq = create_rt_workqueue("shm_ac_wake_req");
if (!shrm->shm_ac_wake_wq) {
dev_err(shrm->dev, "failed to create work queue\n");
err = -ENOMEM;
goto free_wq2;
}
shrm->shm_ca_wake_wq = create_rt_workqueue("shm_ca_wake_req");
if (!shrm->shm_ca_wake_wq) {
dev_err(shrm->dev, "failed to create work queue\n");
err = -ENOMEM;
goto free_wq3;
}
shrm->shm_ac_sleep_wq = create_singlethread_workqueue
("shm_ac_sleep_req");
if (!shrm->shm_ac_sleep_wq) {
dev_err(shrm->dev, "failed to create work queue\n");
err = -ENOMEM;
goto free_wq4;
}
shrm->shm_mod_stuck_wq = create_rt_workqueue("shm_mod_reset_req");
if (!shrm->shm_mod_stuck_wq) {
dev_err(shrm->dev, "failed to create work queue\n");
err = -ENOMEM;
goto free_wq5;
}
INIT_WORK(&shrm->send_ac_msg_pend_notify_0,
send_ac_msg_pend_notify_0_work);
INIT_WORK(&shrm->send_ac_msg_pend_notify_1,
send_ac_msg_pend_notify_1_work);
INIT_WORK(&shrm->shm_ca_wake_req, shm_ca_wake_req_work);
INIT_WORK(&shrm->shm_ca_sleep_req, shm_ca_sleep_req_work);
INIT_WORK(&shrm->shm_ac_sleep_req, shm_ac_sleep_req_work);
INIT_WORK(&shrm->shm_ac_wake_req, shm_ac_wake_req_work);
INIT_WORK(&shrm->shm_mod_reset_req, shm_mod_reset_work);
/* set tasklet data */
shm_ca_0_tasklet.data = (unsigned long)shrm;
shm_ca_1_tasklet.data = (unsigned long)shrm;
err = request_irq(IRQ_PRCMU_CA_SLEEP, shrm_prcmu_irq_handler,
IRQF_NO_SUSPEND, "ca-sleep", shrm);
if (err < 0) {
dev_err(shm_dev->dev, "Failed alloc IRQ_PRCMU_CA_SLEEP.\n");
goto free_wq6;
}
err = request_irq(IRQ_PRCMU_CA_WAKE, shrm_prcmu_irq_handler,
IRQF_NO_SUSPEND, "ca-wake", shrm);
if (err < 0) {
dev_err(shm_dev->dev, "Failed alloc IRQ_PRCMU_CA_WAKE.\n");
goto drop2;
}
err = request_irq(IRQ_PRCMU_MODEM_SW_RESET_REQ, shrm_prcmu_irq_handler,
IRQF_NO_SUSPEND, "modem-sw-reset-req", shrm);
if (err < 0) {
dev_err(shm_dev->dev,
"Failed alloc IRQ_PRCMU_MODEM_SW_RESET_REQ.\n");
goto drop1;
}
#ifdef CONFIG_U8500_SHRM_MODEM_SILENT_RESET
/* init netlink socket for user-space communication */
shrm_nl_sk = netlink_kernel_create(NULL, NETLINK_SHRM, 1,
shm_nl_receive, NULL, THIS_MODULE);
if (!shrm_nl_sk) {
dev_err(shm_dev->dev, "netlink socket creation failed\n");
goto drop;
}
#endif
return 0;
#ifdef CONFIG_U8500_SHRM_MODEM_SILENT_RESET
drop:
free_irq(IRQ_PRCMU_MODEM_SW_RESET_REQ, NULL);
#endif
drop1:
free_irq(IRQ_PRCMU_CA_WAKE, NULL);
drop2:
free_irq(IRQ_PRCMU_CA_SLEEP, NULL);
free_wq6:
destroy_workqueue(shrm->shm_mod_stuck_wq);
free_wq5:
destroy_workqueue(shrm->shm_ac_sleep_wq);
free_wq4:
destroy_workqueue(shrm->shm_ca_wake_wq);
free_wq3:
destroy_workqueue(shrm->shm_ac_wake_wq);
free_wq2:
destroy_workqueue(shrm->shm_audio_ch_wr_wq);
free_wq1:
destroy_workqueue(shrm->shm_common_ch_wr_wq);
return err;
}
