struct list_head upd_buf_free_list;
struct list_head upd_buf_collision_list;
struct update_data_list *cur_update;
- spinlock_t queue_lock;
+ struct mutex queue_mutex;
int trt_entries;
int temp_index;
u8 *temp_range_bounds;
struct delayed_work epdc_done_work;
struct workqueue_struct *epdc_submit_workqueue;
struct work_struct epdc_submit_work;
+ struct workqueue_struct *epdc_intr_workqueue;
+ struct work_struct epdc_intr_work;
bool waiting_for_wb;
bool waiting_for_lut;
bool waiting_for_lut15;
struct imx_epdc_fb_mode *epdc_modes = fb_data->pdata->epdc_mode;
int i;
int ret;
- unsigned long flags;
__u32 xoffset_old, yoffset_old;
/*
*/
mxc_epdc_fb_flush_updates(fb_data);
- spin_lock_irqsave(&fb_data->queue_lock, flags);
+ mutex_lock(&fb_data->queue_mutex);
/*
* Set all screeninfo except for xoffset/yoffset
* Subsequent call to pan_display will handle those.
fb_data->epdc_fb_var = *screeninfo;
fb_data->epdc_fb_var.xoffset = xoffset_old;
fb_data->epdc_fb_var.yoffset = yoffset_old;
- spin_unlock_irqrestore(&fb_data->queue_lock, flags);
+ mutex_unlock(&fb_data->queue_mutex);
mutex_lock(&fb_data->pxp_mutex);
{
struct mxc_epdc_fb_data *fb_data = info ?
(struct mxc_epdc_fb_data *)info:g_fb_data;
- unsigned long flags;
/* Store temp index. Used later when configuring updates. */
- spin_lock_irqsave(&fb_data->queue_lock, flags);
+ mutex_lock(&fb_data->queue_mutex);
fb_data->temp_index = mxc_epdc_fb_get_temp_index(fb_data, temperature);
- spin_unlock_irqrestore(&fb_data->queue_lock, flags);
+ mutex_unlock(&fb_data->queue_mutex);
return 0;
}
struct update_data_list *next_update, *temp_update;
struct update_desc_list *next_desc, *temp_desc;
struct update_marker_data *next_marker, *temp_marker;
- unsigned long flags;
struct mxc_epdc_fb_data *fb_data =
container_of(work, struct mxc_epdc_fb_data, epdc_submit_work);
struct update_data_list *upd_data_list = NULL;
int ret;
/* Protect access to buffer queues and to update HW */
- spin_lock_irqsave(&fb_data->queue_lock, flags);
+ mutex_lock(&fb_data->queue_mutex);
/*
* Are any of our collision updates able to go now?
*/
if (!upd_data_list &&
list_empty(&fb_data->upd_buf_free_list)) {
- spin_unlock_irqrestore(&fb_data->queue_lock, flags);
+ mutex_unlock(&fb_data->queue_mutex);
return;
}
}
/* Release buffer queues */
- spin_unlock_irqrestore(&fb_data->queue_lock, flags);
+ mutex_unlock(&fb_data->queue_mutex);
/* Is update list empty? */
if (!upd_data_list)
if (epdc_process_update(upd_data_list, fb_data)) {
dev_dbg(fb_data->dev, "PXP processing error.\n");
/* Protect access to buffer queues and to update HW */
- spin_lock_irqsave(&fb_data->queue_lock, flags);
+ mutex_lock(&fb_data->queue_mutex);
list_del_init(&upd_data_list->update_desc->list);
kfree(upd_data_list->update_desc);
upd_data_list->update_desc = NULL;
list_add_tail(&upd_data_list->list,
&fb_data->upd_buf_free_list);
/* Release buffer queues */
- spin_unlock_irqrestore(&fb_data->queue_lock, flags);
+ mutex_unlock(&fb_data->queue_mutex);
return;
}
&adj_update_region);
/* Protect access to buffer queues and to update HW */
- spin_lock_irqsave(&fb_data->queue_lock, flags);
+ mutex_lock(&fb_data->queue_mutex);
/*
* Is the working buffer idle?
fb_data->waiting_for_wb = true;
/* Leave spinlock while waiting for WB to complete */
- spin_unlock_irqrestore(&fb_data->queue_lock, flags);
+ mutex_unlock(&fb_data->queue_mutex);
wait_for_completion(&fb_data->update_res_free);
- spin_lock_irqsave(&fb_data->queue_lock, flags);
+ mutex_lock(&fb_data->queue_mutex);
}
/*
fb_data->waiting_for_lut = true;
/* Leave spinlock while waiting for LUT to free up */
- spin_unlock_irqrestore(&fb_data->queue_lock, flags);
+ mutex_unlock(&fb_data->queue_mutex);
wait_for_completion(&fb_data->update_res_free);
- spin_lock_irqsave(&fb_data->queue_lock, flags);
+ mutex_lock(&fb_data->queue_mutex);
}
ret = epdc_choose_next_lut(&upd_data_list->lut_num);
fb_data->waiting_for_lut15 = true;
/* Leave spinlock while waiting for LUT to free up */
- spin_unlock_irqrestore(&fb_data->queue_lock, flags);
+ mutex_unlock(&fb_data->queue_mutex);
wait_for_completion(&fb_data->lut15_free);
- spin_lock_irqsave(&fb_data->queue_lock, flags);
+ mutex_lock(&fb_data->queue_mutex);
epdc_choose_next_lut(&upd_data_list->lut_num);
} else if (ret) {
epdc_eof_intr(true);
/* Leave spinlock while waiting for EOF event */
- spin_unlock_irqrestore(&fb_data->queue_lock, flags);
+ mutex_unlock(&fb_data->queue_mutex);
ret = wait_for_completion_timeout(&fb_data->eof_event,
msecs_to_jiffies(1000));
if (!ret) {
epdc_eof_intr(false);
}
udelay(fb_data->eof_sync_period);
- spin_lock_irqsave(&fb_data->queue_lock, flags);
+ mutex_lock(&fb_data->queue_mutex);
}
false, 0);
/* Release buffer queues */
- spin_unlock_irqrestore(&fb_data->queue_lock, flags);
+ mutex_unlock(&fb_data->queue_mutex);
}
struct mxc_epdc_fb_data *fb_data = info ?
(struct mxc_epdc_fb_data *)info:g_fb_data;
struct update_data_list *upd_data_list = NULL;
- unsigned long flags;
struct mxcfb_rect *screen_upd_region; /* Region on screen to update */
int temp_index;
int ret;
}
}
- spin_lock_irqsave(&fb_data->queue_lock, flags);
+ mutex_lock(&fb_data->queue_mutex);
/*
* If we are waiting to go into suspend, or the FB is blanked,
(fb_data->blank != FB_BLANK_UNBLANK)) {
dev_dbg(fb_data->dev, "EPDC not active."
"Update request abort.\n");
- spin_unlock_irqrestore(&fb_data->queue_lock, flags);
+ mutex_unlock(&fb_data->queue_mutex);
return -EPERM;
}
* other updates. Block here until updates are flushed.
*/
if (upd_data->update_mode == UPDATE_MODE_FULL) {
- spin_unlock_irqrestore(&fb_data->queue_lock, flags);
+ mutex_unlock(&fb_data->queue_mutex);
mxc_epdc_fb_flush_updates(fb_data);
- spin_lock_irqsave(&fb_data->queue_lock, flags);
+ mutex_lock(&fb_data->queue_mutex);
}
/*
if (list_empty(&fb_data->upd_buf_free_list)) {
dev_err(fb_data->dev,
"No free intermediate buffers available.\n");
- spin_unlock_irqrestore(&fb_data->queue_lock, flags);
+ mutex_unlock(&fb_data->queue_mutex);
return -ENOMEM;
}
list_add(&upd_data_list->list,
&fb_data->upd_buf_free_list);
}
- spin_unlock_irqrestore(&fb_data->queue_lock, flags);
+ mutex_unlock(&fb_data->queue_mutex);
return -EPERM;
}
/* Initialize per-update marker list */
GFP_KERNEL);
if (!marker_data) {
dev_err(fb_data->dev, "No memory for marker!\n");
- spin_unlock_irqrestore(&fb_data->queue_lock, flags);
+ mutex_unlock(&fb_data->queue_mutex);
return -ENOMEM;
}
list_add_tail(&marker_data->upd_list,
if (fb_data->upd_scheme != UPDATE_SCHEME_SNAPSHOT) {
/* Queued update scheme processing */
- spin_unlock_irqrestore(&fb_data->queue_lock, flags);
+ mutex_unlock(&fb_data->queue_mutex);
/* Signal workqueue to handle new update */
queue_work(fb_data->epdc_submit_workqueue,
upd_data_list->update_desc = upd_desc;
list_del_init(&upd_desc->list);
- spin_unlock_irqrestore(&fb_data->queue_lock, flags);
+ mutex_unlock(&fb_data->queue_mutex);
/*
* Hold on to original screen update region, which we
NULL);
/* Grab lock for queue manipulation and update submission */
- spin_lock_irqsave(&fb_data->queue_lock, flags);
+ mutex_lock(&fb_data->queue_mutex);
/*
* Is the working buffer idle?
list_add_tail(&upd_data_list->list, &fb_data->upd_buf_queue);
/* Return and allow the update to be submitted by the ISR. */
- spin_unlock_irqrestore(&fb_data->queue_lock, flags);
+ mutex_unlock(&fb_data->queue_mutex);
return 0;
}
list_add_tail(&upd_data_list->list, &fb_data->upd_buf_queue);
/* Return and allow the update to be submitted by the ISR. */
- spin_unlock_irqrestore(&fb_data->queue_lock, flags);
+ mutex_unlock(&fb_data->queue_mutex);
return 0;
}
upd_desc->upd_data.waveform_mode,
upd_desc->upd_data.update_mode, false, 0);
- spin_unlock_irqrestore(&fb_data->queue_lock, flags);
+ mutex_unlock(&fb_data->queue_mutex);
return 0;
}
EXPORT_SYMBOL(mxc_epdc_fb_send_update);
(struct mxc_epdc_fb_data *)info:g_fb_data;
struct update_marker_data *next_marker;
struct update_marker_data *temp;
- unsigned long flags;
bool marker_found = false;
int ret = 0;
*/
/* Grab queue lock to protect access to marker list */
- spin_lock_irqsave(&fb_data->queue_lock, flags);
+ mutex_lock(&fb_data->queue_mutex);
list_for_each_entry_safe(next_marker, temp,
&fb_data->full_marker_list, full_list) {
}
}
- spin_unlock_irqrestore(&fb_data->queue_lock, flags);
+ mutex_unlock(&fb_data->queue_mutex);
/*
* If marker not found, it has either been signalled already
void mxc_epdc_fb_flush_updates(struct mxc_epdc_fb_data *fb_data)
{
- unsigned long flags;
int ret;
/* Grab queue lock to prevent any new updates from being submitted */
- spin_lock_irqsave(&fb_data->queue_lock, flags);
+ mutex_lock(&fb_data->queue_mutex);
/*
* 3 places to check for updates that are active or pending:
init_completion(&fb_data->updates_done);
fb_data->waiting_for_idle = true;
- spin_unlock_irqrestore(&fb_data->queue_lock, flags);
+ mutex_unlock(&fb_data->queue_mutex);
/* Wait for any currently active updates to complete */
ret = wait_for_completion_timeout(&fb_data->updates_done,
msecs_to_jiffies(5000));
dev_err(fb_data->dev,
"Flush updates timeout! ret = 0x%x\n", ret);
- spin_lock_irqsave(&fb_data->queue_lock, flags);
+ mutex_lock(&fb_data->queue_mutex);
fb_data->waiting_for_idle = false;
}
- spin_unlock_irqrestore(&fb_data->queue_lock, flags);
+ mutex_unlock(&fb_data->queue_mutex);
}
static int mxc_epdc_fb_blank(int blank, struct fb_info *info)
{
struct mxc_epdc_fb_data *fb_data = (struct mxc_epdc_fb_data *)info;
u_int y_bottom;
- unsigned long flags;
dev_dbg(info->device, "%s: var->yoffset %d, info->var.yoffset %d\n",
__func__, var->yoffset, info->var.yoffset);
if (y_bottom > info->var.yres_virtual)
return -EINVAL;
- spin_lock_irqsave(&fb_data->queue_lock, flags);
+ mutex_lock(&fb_data->queue_mutex);
fb_data->fb_offset = (var->yoffset * var->xres_virtual + var->xoffset)
* (var->bits_per_pixel) / 8;
else
info->var.vmode &= ~FB_VMODE_YWRAP;
- spin_unlock_irqrestore(&fb_data->queue_lock, flags);
+ mutex_unlock(&fb_data->queue_mutex);
return 0;
}
static irqreturn_t mxc_epdc_irq_handler(int irq, void *dev_id)
{
struct mxc_epdc_fb_data *fb_data = dev_id;
- struct update_data_list *collision_update;
- struct mxcfb_rect *next_upd_region;
- struct update_marker_data *next_marker;
- struct update_marker_data *temp;
- unsigned long flags;
- int temp_index;
- u32 temp_mask;
- u32 lut;
- bool ignore_collision = false;
- int i;
- bool wb_lut_done = false;
- bool free_update = true;
- int next_lut;
- u32 epdc_irq_stat, epdc_luts_active, epdc_wb_busy, epdc_luts_avail;
- u32 epdc_collision, epdc_colliding_luts, epdc_next_lut_15;
+ u32 ints_fired;
/*
* If we just completed one-time panel init, bypass
complete(&fb_data->eof_event);
}
+ /* Clear the interrupt mask for any interrupts signalled */
+ ints_fired = __raw_readl(EPDC_IRQ_MASK) & __raw_readl(EPDC_IRQ);
+ __raw_writel(ints_fired, EPDC_IRQ_MASK_CLEAR);
+
+ queue_work(fb_data->epdc_intr_workqueue,
+ &fb_data->epdc_intr_work);
+
+ return IRQ_HANDLED;
+}
+
+static void epdc_intr_work_func(struct work_struct *work)
+{
+ struct mxc_epdc_fb_data *fb_data =
+ container_of(work, struct mxc_epdc_fb_data, epdc_intr_work);
+ struct update_data_list *collision_update;
+ struct mxcfb_rect *next_upd_region;
+ struct update_marker_data *next_marker;
+ struct update_marker_data *temp;
+ int temp_index;
+ u32 temp_mask;
+ u32 lut;
+ bool ignore_collision = false;
+ int i;
+ bool wb_lut_done = false;
+ bool free_update = true;
+ int next_lut;
+ u32 epdc_irq_stat, epdc_luts_active, epdc_wb_busy, epdc_luts_avail;
+ u32 epdc_collision, epdc_colliding_luts, epdc_next_lut_15;
+
/* Capture EPDC status one time up front to prevent race conditions */
- epdc_irq_stat = __raw_readl(EPDC_IRQ);
epdc_luts_active = epdc_any_luts_active();
epdc_wb_busy = epdc_is_working_buffer_busy();
epdc_luts_avail = epdc_any_luts_available();
epdc_collision = epdc_is_collision();
epdc_colliding_luts = epdc_get_colliding_luts();
epdc_next_lut_15 = epdc_choose_next_lut(&next_lut);
+ epdc_irq_stat = __raw_readl(EPDC_IRQ);
/* Protect access to buffer queues and to update HW */
- spin_lock_irqsave(&fb_data->queue_lock, flags);
+ mutex_lock(&fb_data->queue_mutex);
/* Free any LUTs that have completed */
for (i = 0; i < EPDC_NUM_LUTS; i++) {
/* Is Working Buffer busy? */
if (epdc_wb_busy) {
/* Can't submit another update until WB is done */
- spin_unlock_irqrestore(&fb_data->queue_lock, flags);
- return IRQ_HANDLED;
+ mutex_unlock(&fb_data->queue_mutex);
+ return;
}
/*
&fb_data->epdc_submit_work);
/* Release buffer queues */
- spin_unlock_irqrestore(&fb_data->queue_lock, flags);
+ mutex_unlock(&fb_data->queue_mutex);
- return IRQ_HANDLED;
+ return;
}
/* Snapshot update scheme processing */
/* Check to see if any LUTs are free */
if (!epdc_luts_avail) {
dev_dbg(fb_data->dev, "No luts available.\n");
- spin_unlock_irqrestore(&fb_data->queue_lock, flags);
- return IRQ_HANDLED;
+ mutex_unlock(&fb_data->queue_mutex);
+ return;
}
/* Check to see if there is a valid LUT to use */
if (epdc_next_lut_15 && fb_data->tce_prevent) {
dev_dbg(fb_data->dev, "Must wait for LUT15\n");
- spin_unlock_irqrestore(&fb_data->queue_lock, flags);
- return IRQ_HANDLED;
+ mutex_unlock(&fb_data->queue_mutex);
+ return;
}
/*
dev_dbg(fb_data->dev, "No pending updates.\n");
/* No updates pending, so we are done */
- spin_unlock_irqrestore(&fb_data->queue_lock, flags);
- return IRQ_HANDLED;
+ mutex_unlock(&fb_data->queue_mutex);
+ return;
} else {
dev_dbg(fb_data->dev, "Found a pending update!\n");
false, 0);
/* Release buffer queues */
- spin_unlock_irqrestore(&fb_data->queue_lock, flags);
+ mutex_unlock(&fb_data->queue_mutex);
- return IRQ_HANDLED;
+ return;
}
static void draw_mode0(struct mxc_epdc_fb_data *fb_data)
for (i = 0; i < EPDC_NUM_LUTS; i++)
fb_data->lut_update_order[i] = 0;
+ INIT_DELAYED_WORK(&fb_data->epdc_done_work, epdc_done_work_func);
+ fb_data->epdc_submit_workqueue = alloc_workqueue("EPDC Submit", WQ_MEM_RECLAIM |
+ WQ_HIGHPRI | WQ_CPU_INTENSIVE, 0);
+ INIT_WORK(&fb_data->epdc_submit_work, epdc_submit_work_func);
+ fb_data->epdc_intr_workqueue = alloc_workqueue("EPDC Interrupt", WQ_MEM_RECLAIM |
+ WQ_HIGHPRI | WQ_CPU_INTENSIVE, 0);
+ INIT_WORK(&fb_data->epdc_intr_work, epdc_intr_work_func);
+
/* Retrieve EPDC IRQ num */
res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
if (res == NULL) {
goto out_dma_work_buf;
}
- INIT_DELAYED_WORK(&fb_data->epdc_done_work, epdc_done_work_func);
- fb_data->epdc_submit_workqueue = alloc_workqueue("submit", WQ_MEM_RECLAIM |
- WQ_HIGHPRI | WQ_CPU_INTENSIVE, 0);
- INIT_WORK(&fb_data->epdc_submit_work, epdc_submit_work_func);
-
info->fbdefio = &mxc_epdc_fb_defio;
#ifdef CONFIG_FB_MXC_EINK_AUTO_UPDATE_MODE
fb_deferred_io_init(info);
fb_data->cur_update = NULL;
- spin_lock_init(&fb_data->queue_lock);
-
+ mutex_init(&fb_data->queue_mutex);
mutex_init(&fb_data->pxp_mutex);
-
mutex_init(&fb_data->power_mutex);
/* PxP DMA interface */
projects / karo-tx-linux.git / commitdiff