/*
* Present frame and synchronize with the display to prevent tearing
* On DSI panels the sync function is used to handle FRAMEDONE IRQ
* On DPI panels the wait_for_vsync is used to handle VSYNC IRQ
* in: psDevInfo
*/
void OMAPLFBPresentSync(OMAPLFB_DEVINFO *psDevInfo,
OMAPLFB_FLIP_ITEM *psFlipItem)
{
struct fb_info *framebuffer = psDevInfo->psLINFBInfo;
struct omapfb_info *ofbi = FB2OFB(framebuffer);
struct omap_dss_device *display;
struct omapfb2_device *fbdev = ofbi->fbdev;
struct omap_dss_driver *driver;
struct omap_overlay_manager *manager;
int err = 1;
omapfb_lock(fbdev);
// [email protected] Backup the Display device for using later [START]
#if defined(CONFIG_MACH_LGE_OMAP3)
Prev_disp = display = fb2display(framebuffer);
#else
display = fb2display(framebuffer);
#endif
// [email protected] Backup the Display device for using later [END]
/* The framebuffer doesn't have a display attached, just bail out */
if (!display) {
omapfb_unlock(fbdev);
return;
}
driver = display->driver;
manager = display->manager;
if (driver && driver->sync &&
driver->get_update_mode(display) == OMAP_DSS_UPDATE_MANUAL) {
/* Wait first for the DSI bus to be released then update */
err = driver->sync(display);
OMAPLFBFlipNoLock(psDevInfo->psSwapChain,
(unsigned long)psFlipItem->sSysAddr->uiAddr);
} else if (manager && manager->wait_for_vsync) {
/*
* Update the video pipelines registers then wait until the
* frame is shown with a VSYNC
*/
OMAPLFBFlipNoLock(psDevInfo->psSwapChain,
(unsigned long)psFlipItem->sSysAddr->uiAddr);
err = manager->wait_for_vsync(manager);
}
if (err)
WARNING_PRINTK("Unable to sync with display %u!",
psDevInfo->uDeviceID);
omapfb_unlock(fbdev);
}
OMAPLFB_UPDATE_MODE OMAPLFBGetUpdateMode(OMAPLFB_DEVINFO *psDevInfo)
{
#if 0
struct omap_dss_device *psDSSDev = fb2display(psDevInfo->psLINFBInfo);
OMAP_DSS_DRIVER(psDSSDrv, psDSSDev);
enum omap_dss_update_mode eMode;
if (psDSSDrv == NULL || psDSSDrv->get_update_mode == NULL)
{
DEBUG_PRINTK((KERN_INFO DRIVER_PREFIX ": %s: Device %u: Can't get update mode\n", __FUNCTION__, psDevInfo->uiFBDevID));
return OMAPLFB_UPDATE_MODE_UNDEFINED;
}
eMode = psDSSDrv->get_update_mode(psDSSDev);
switch(eMode)
{
case OMAP_DSS_UPDATE_AUTO:
return OMAPLFB_UPDATE_MODE_AUTO;
case OMAP_DSS_UPDATE_MANUAL:
return OMAPLFB_UPDATE_MODE_MANUAL;
case OMAP_DSS_UPDATE_DISABLED:
return OMAPLFB_UPDATE_MODE_DISABLED;
default:
DEBUG_PRINTK((KERN_INFO DRIVER_PREFIX ": %s: Device %u: Unknown update mode (%d)\n", __FUNCTION__, psDevInfo->uiFBDevID, eMode));
break;
}
return OMAPLFB_UPDATE_MODE_UNDEFINED;
#endif
return OMAPLFB_UPDATE_MODE_AUTO;
}
/* Wait for VSync */
OMAPLFB_BOOL OMAPLFBWaitForVSync(OMAPLFB_DEVINFO *psDevInfo)
{
#if defined(PVR_OMAPLFB_DRM_FB)
struct drm_connector *psConnector;
for (psConnector = NULL;
(psConnector = omap_fbdev_get_next_connector(psDevInfo->psLINFBInfo, psConnector)) != NULL;)
{
(void) omap_encoder_wait_for_vsync(psConnector->encoder);
}
return OMAPLFB_TRUE;
#else /* defined(PVR_OMAPLFB_DRM_FB) */
#if FBDEV_PRESENT
struct omap_dss_device *psDSSDev = fb2display(psDevInfo->psLINFBInfo);
OMAP_DSS_MANAGER(psDSSMan, psDSSDev);
if (psDSSMan != NULL && WAIT_FOR_VSYNC(psDSSMan) != NULL)
{
int res = WAIT_FOR_VSYNC(psDSSMan)(psDSSMan);
if (res != 0)
{
DEBUG_PRINTK((KERN_WARNING DRIVER_PREFIX ": %s: Device %u: Wait for vsync failed (%d)\n", __FUNCTION__, psDevInfo->uiFBDevID, res));
return OMAPLFB_FALSE;
}
}
#endif
return OMAPLFB_TRUE;
#endif /* defined(PVR_OMAPLFB_DRM_FB) */
}
/*
* Wait for screen to update. If the screen is in manual or auto update
* mode, we can call this function to wait for the screen to update.
*/
OMAPLFB_BOOL OMAPLFBManualSync(OMAPLFB_DEVINFO *psDevInfo)
{
#if defined(PVR_OMAPLFB_DRM_FB)
struct drm_connector *psConnector;
for (psConnector = NULL;
(psConnector = omap_fbdev_get_next_connector(psDevInfo->psLINFBInfo, psConnector)) != NULL; )
{
/* Try manual sync first, then try wait for vsync */
if (omap_connector_sync(psConnector) != 0)
{
(void) omap_encoder_wait_for_vsync(psConnector->encoder);
}
}
return OMAPLFB_TRUE;
#else /* defined(PVR_OMAPLFB_DRM_FB) */
#if 0
struct omap_dss_device *psDSSDev = fb2display(psDevInfo->psLINFBInfo);
OMAP_DSS_DRIVER(psDSSDrv, psDSSDev);
if (psDSSDrv != NULL && psDSSDrv->sync != NULL)
{
int res = psDSSDrv->sync(psDSSDev);
if (res != 0)
{
printk(KERN_ERR DRIVER_PREFIX ": %s: Device %u: Sync failed (%d)\n", __FUNCTION__, psDevInfo->uiFBDevID, res);
return OMAPLFB_FALSE;
}
}
#endif
return OMAPLFB_TRUE;
#endif /* defined(PVR_OMAPLFB_DRM_FB) */
}
static int omapfb_get_update_mode(struct fb_info *fbi,
enum omapfb_update_mode *mode)
{
struct omapfb_info *ofbi = FB2OFB(fbi);
struct omapfb2_device *fbdev = ofbi->fbdev;
struct omap_display *display = fb2display(fbi);
enum omap_dss_update_mode m;
if (!display || !display->get_update_mode)
return -EINVAL;
omapfb_lock(fbdev);
m = display->get_update_mode(display);
omapfb_unlock(fbdev);
switch (m) {
case OMAP_DSS_UPDATE_DISABLED:
*mode = OMAPFB_UPDATE_DISABLED;
break;
case OMAP_DSS_UPDATE_AUTO:
*mode = OMAPFB_AUTO_UPDATE;
break;
case OMAP_DSS_UPDATE_MANUAL:
*mode = OMAPFB_MANUAL_UPDATE;
break;
default:
BUG();
}
return 0;
}
static int omapfb_set_update_mode(struct fb_info *fbi,
enum omapfb_update_mode mode)
{
struct omapfb_info *ofbi = FB2OFB(fbi);
struct omapfb2_device *fbdev = ofbi->fbdev;
struct omap_display *display = fb2display(fbi);
enum omap_dss_update_mode um;
int r;
if (!display || !display->set_update_mode)
return -EINVAL;
switch (mode) {
case OMAPFB_UPDATE_DISABLED:
um = OMAP_DSS_UPDATE_DISABLED;
break;
case OMAPFB_AUTO_UPDATE:
um = OMAP_DSS_UPDATE_AUTO;
break;
case OMAPFB_MANUAL_UPDATE:
um = OMAP_DSS_UPDATE_MANUAL;
break;
default:
return -EINVAL;
}
omapfb_lock(fbdev);
r = display->set_update_mode(display, um);
omapfb_unlock(fbdev);
return r;
}
static int omapfb_update_window(struct fb_info *fbi,
u32 x, u32 y, u32 w, u32 h)
{
struct omapfb_info *ofbi = FB2OFB(fbi);
struct omapfb2_device *fbdev = ofbi->fbdev;
struct omap_display *display = fb2display(fbi);
int dw, dh;
if (!display)
return 0;
if (w == 0 || h == 0)
return 0;
display->get_resolution(display, &dw, &dh);
if (x + w > dw || y + h > dh)
return -EINVAL;
omapfb_lock(fbdev);
display->update(display, x, y, w, h);
omapfb_unlock(fbdev);
return 0;
}
static int omapfb_set_update_mode(struct fb_info *fbi,
enum omapfb_update_mode mode)
{
struct omap_dss_device *display = fb2display(fbi);
enum omap_dss_update_mode um;
int r;
if (!display || !display->driver->set_update_mode)
return -EINVAL;
switch (mode) {
case OMAPFB_UPDATE_DISABLED:
um = OMAP_DSS_UPDATE_DISABLED;
break;
case OMAPFB_AUTO_UPDATE:
um = OMAP_DSS_UPDATE_AUTO;
break;
case OMAPFB_MANUAL_UPDATE:
um = OMAP_DSS_UPDATE_MANUAL;
break;
default:
return -EINVAL;
}
r = display->driver->set_update_mode(display, um);
return r;
}
static int omapfb_get_update_mode(struct fb_info *fbi,
enum omapfb_update_mode *mode)
{
struct omap_dss_device *display = fb2display(fbi);
enum omap_dss_update_mode m;
if (!display)
return -EINVAL;
if (!display->driver->get_update_mode) {
*mode = OMAPFB_AUTO_UPDATE;
return 0;
}
m = display->driver->get_update_mode(display);
switch (m) {
case OMAP_DSS_UPDATE_DISABLED:
*mode = OMAPFB_UPDATE_DISABLED;
break;
case OMAP_DSS_UPDATE_AUTO:
*mode = OMAPFB_AUTO_UPDATE;
break;
case OMAP_DSS_UPDATE_MANUAL:
*mode = OMAPFB_MANUAL_UPDATE;
break;
default:
BUG();
}
return 0;
}
static int omapfb_memory_read(struct fb_info *fbi,
struct omapfb_memory_read *mr)
{
struct omap_dss_device *display = fb2display(fbi);
void *buf;
int r;
if (!display || !display->driver->memory_read)
return -ENOENT;
if (!access_ok(VERIFY_WRITE, mr->buffer, mr->buffer_size))
return -EFAULT;
if (mr->w * mr->h * 3 > mr->buffer_size)
return -EINVAL;
buf = vmalloc(mr->buffer_size);
if (!buf) {
DBG("vmalloc failed\n");
return -ENOMEM;
}
r = display->driver->memory_read(display, buf, mr->buffer_size,
mr->x, mr->y, mr->w, mr->h);
if (r > 0) {
if (copy_to_user(mr->buffer, buf, mr->buffer_size))
r = -EFAULT;
}
vfree(buf);
return r;
}
OMAPLFB_BOOL OMAPLFBWaitForVSync(OMAPLFB_DEVINFO *psDevInfo)
{
#if 0
struct omap_dss_device *psDSSDev = fb2display(psDevInfo->psLINFBInfo);
OMAP_DSS_MANAGER(psDSSMan, psDSSDev);
if (psDSSMan != NULL && WAIT_FOR_VSYNC(psDSSMan) != NULL)
{
int res = WAIT_FOR_VSYNC(psDSSMan)(psDSSMan);
if (res != 0)
{
DEBUG_PRINTK((KERN_INFO DRIVER_PREFIX ": %s: Device %u: Wait for vsync failed (%d)\n", __FUNCTION__, psDevInfo->uiFBDevID, res));
return OMAPLFB_FALSE;
}
}
#endif
#if 0
struct vps_grpx_ctrl *gctrl;
int r;
gctrl = vps_grpx_get_ctrl(psDevInfo->uiFBDevID);
printk (" BVSYNC \n");
r = gctrl->wait_for_vsync(gctrl);
printk (" AVSYNC: %d\n", vsync_num++);
return OMAPLFB_TRUE;
#endif
// unsigned long timeout = msecs_to_jiffies(500);
#if FBDEV_PRESENT
int r;
void grpx_irq_wait_handler(void *data)
{
complete((struct completion *)data);
}
static int omapfb_setup_plane(struct fb_info *fbi, struct omapfb_plane_info *pi)
{
struct omapfb_info *ofbi = FB2OFB(fbi);
struct omapfb2_device *fbdev = ofbi->fbdev;
struct omap_display *display = fb2display(fbi);
struct omap_overlay *ovl;
int r = 0;
DBG("omapfb_setup_plane\n");
omapfb_lock(fbdev);
if (ofbi->num_overlays != 1) {
r = -EINVAL;
goto out;
}
/* XXX uses only the first overlay */
ovl = ofbi->overlays[0];
if (pi->enabled && !ofbi->region.size) {
/*
* This plane's memory was freed, can't enable it
* until it's reallocated.
*/
r = -EINVAL;
goto out;
}
if (pi->enabled) {
r = omapfb_setup_overlay(fbi, ovl, pi->pos_x, pi->pos_y,
pi->out_width, pi->out_height);
if (r)
goto out;
}
ovl->enable(ovl, pi->enabled);
if (ovl->manager)
ovl->manager->apply(ovl->manager);
if (display) {
int w, h;
if (display->sync)
display->sync(display);
display->get_resolution(display, &w, &h);
if (display->update)
display->update(display, 0, 0, w, h);
}
out:
omapfb_unlock(fbdev);
if (r)
dev_err(fbdev->dev, "setup_plane failed\n");
return r;
}
static int omapfb_setup_mem(struct fb_info *fbi, struct omapfb_mem_info *mi)
{
struct omapfb_info *ofbi = FB2OFB(fbi);
struct omapfb2_device *fbdev = ofbi->fbdev;
struct omap_dss_device *display = fb2display(fbi);
struct omapfb2_mem_region *rg;
int r = 0, i;
size_t size;
if (mi->type != OMAPFB_MEMTYPE_SDRAM)
return -EINVAL;
size = PAGE_ALIGN(mi->size);
if (display && display->driver->sync)
display->driver->sync(display);
rg = ofbi->region;
down_write_nested(&rg->lock, rg->id);
atomic_inc(&rg->lock_count);
if (rg->size == size && rg->type == mi->type)
goto out;
if (atomic_read(&rg->map_count)) {
r = -EBUSY;
goto out;
}
for (i = 0; i < fbdev->num_fbs; i++) {
struct omapfb_info *ofbi2 = FB2OFB(fbdev->fbs[i]);
int j;
if (ofbi2->region != rg)
continue;
for (j = 0; j < ofbi2->num_overlays; j++) {
struct omap_overlay *ovl;
ovl = ofbi2->overlays[j];
if (ovl->is_enabled(ovl)) {
r = -EBUSY;
goto out;
}
}
}
r = omapfb_realloc_fbmem(fbi, size, mi->type);
if (r) {
dev_err(fbdev->dev, "realloc fbmem failed\n");
goto out;
}
out:
atomic_dec(&rg->lock_count);
up_write(&rg->lock);
return r;
}
static int display_sync(struct omap_display_device *display)
{
/* TODO: Synchronize properly with multiple managers */
struct fb_info *framebuffer;
struct omap_dss_device *dss_device;
struct omap_dss_driver *driver;
struct omap_overlay_manager *manager;
int fb_idx;
int err = 1;
switch (display->id) {
case OMAP_DISPID_PRIMARY:
fb_idx = 0;
break;
case OMAP_DISPID_SECONDARY:
fb_idx = 1;
break;
case OMAP_DISPID_TERTIARY:
fb_idx = 2;
break;
case OMAP_DISPID_VIRTUAL:
case OMAP_DISPID_BADSTATE:
default:
ERR_PRINT("Unable to handle display %i", display->id);
BUG();
}
if (fb_idx < 0 || fb_idx >= num_registered_fb) {
ERR_PRINT("Framebuffer %i doesn't exist for display '%s'",
fb_idx, display->name);
return 1;
}
framebuffer = registered_fb[fb_idx];
dss_device = fb2display(framebuffer);
if (!dss_device) {
WRN_PRINT("No DSS device to sync with display '%s'!",
display->name);
return 1;
}
driver = dss_device->driver;
manager = dss_device->manager;
if (driver && driver->sync &&
driver->get_update_mode(dss_device) == OMAP_DSS_UPDATE_MANUAL)
err = driver->sync(dss_device);
else if (manager && manager->wait_for_vsync)
err = manager->wait_for_vsync(manager);
if (err)
WRN_PRINT("Unable to sync with display '%s'!", display->name);
return err;
}
static int omapfb_wait_for_vsync(struct fb_info *fbi)
{
wait_queue_t wqt;
unsigned long cnt, timeout = HZ/5;
int ret;
void *handle = NULL;
u32 mask = 0;
struct omapfb_info *ofbi = FB2OFB(fbi);
struct omap_display *display = fb2display(fbi);
mask = DISPC_IRQ_VSYNC | DISPC_IRQ_EVSYNC_EVEN |
DISPC_IRQ_EVSYNC_ODD;
handle = omap_dispc_register_isr(omapfb_isr, fbi, mask);
if (!handle)
return -EINVAL;
init_waitqueue_entry(&wqt, current);
cnt = ofbi->vsync_cnt;
ret = wait_event_interruptible_timeout(ofbi->vsync_wait,
cnt != ofbi->vsync_cnt, timeout);
/*
* If the GFX is on TV, then wait for another VSYNC
* to compensate for Interlaced scan
*/
if (display->type == OMAP_DISPLAY_TYPE_VENC) {
if (ret > 0) {
cnt = ofbi->vsync_cnt;
ret = wait_event_interruptible_timeout(
ofbi->vsync_wait,
cnt != ofbi->vsync_cnt,
timeout);
}
}
omap_dispc_unregister_isr(handle);
if (ret < 0)
return ret;
if (ret == 0)
return -ETIMEDOUT;
return 0;
}
static int omapfb_update_window_nolock(struct fb_info *fbi,
u32 x, u32 y, u32 w, u32 h)
{
struct omap_dss_device *display = fb2display(fbi);
u16 dw, dh;
if (!display)
return 0;
if (w == 0 || h == 0)
return 0;
display->driver->get_resolution(display, &dw, &dh);
if (x + w > dw || y + h > dh)
return -EINVAL;
return display->driver->update(display, x, y, w, h);
}
int omapfb_set_update_mode(struct fb_info *fbi,
enum omapfb_update_mode mode)
{
struct omap_dss_device *display = fb2display(fbi);
struct omapfb_info *ofbi = FB2OFB(fbi);
struct omapfb2_device *fbdev = ofbi->fbdev;
struct omapfb_display_data *d;
int r;
if (!display)
return -EINVAL;
if (mode != OMAPFB_AUTO_UPDATE && mode != OMAPFB_MANUAL_UPDATE)
return -EINVAL;
omapfb_lock(fbdev);
d = get_display_data(fbdev, display);
if (d->update_mode == mode) {
omapfb_unlock(fbdev);
return 0;
}
r = 0;
if (display->caps & OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE) {
if (mode == OMAPFB_AUTO_UPDATE)
omapfb_start_auto_update(fbdev, display);
else /* MANUAL_UPDATE */
omapfb_stop_auto_update(fbdev, display);
d->update_mode = mode;
} else { /* AUTO_UPDATE */
if (mode == OMAPFB_MANUAL_UPDATE)
r = -EINVAL;
}
omapfb_unlock(fbdev);
return r;
}
/*
* Synchronize with the display to prevent tearing
* On DSI panels the display->sync function is used to handle FRAMEDONE IRQ
* On DPI panels the display->wait_vsync is used to handle VSYNC IRQ
* in: psDevInfo
*/
void OMAPLFBPresentSync(OMAPLFB_DEVINFO *psDevInfo,
OMAPLFB_FLIP_ITEM *psFlipItem)
{
struct fb_info * framebuffer = psDevInfo->psLINFBInfo;
struct omapfb_info *ofbi = FB2OFB(framebuffer);
struct omapfb2_device *fbdev = ofbi->fbdev;
struct omap_dss_device *display;
int err = 1;
omapfb_lock(fbdev);
display = fb2display(framebuffer);
/* The framebuffer doesn't have a display attached, just bail out */
if (!display) {
omapfb_unlock(fbdev);
return;
}
if (display->sync &&
display->get_update_mode(display) == OMAP_DSS_UPDATE_MANUAL) {
/* Wait first for the DSI bus to be released then update */
err = display->sync(display);
OMAPLFBFlipNoLock(psDevInfo->psSwapChain,
(unsigned long)psFlipItem->sSysAddr->uiAddr);
} else if (display->wait_vsync) {
/*
* Update the video pipelines registers then wait until the
* frame is shown with a VSYNC
*/
OMAPLFBFlipNoLock(psDevInfo->psSwapChain,
(unsigned long)psFlipItem->sSysAddr->uiAddr);
err = display->wait_vsync(display);
}
if (err)
WARNING_PRINTK("Unable to sync with display %u!",
psDevInfo->uDeviceID);
omapfb_unlock(fbdev);
}
int omapfb_get_update_mode(struct fb_info *fbi,
enum omapfb_update_mode *mode)
{
struct omap_dss_device *display = fb2display(fbi);
struct omapfb_info *ofbi = FB2OFB(fbi);
struct omapfb2_device *fbdev = ofbi->fbdev;
struct omapfb_display_data *d;
if (!display)
return -EINVAL;
omapfb_lock(fbdev);
d = get_display_data(fbdev, display);
*mode = d->update_mode;
omapfb_unlock(fbdev);
return 0;
}
OMAPLFB_BOOL OMAPLFBSetUpdateMode(OMAPLFB_DEVINFO *psDevInfo, OMAPLFB_UPDATE_MODE eMode)
{
#if 0
struct omap_dss_device *psDSSDev = fb2display(psDevInfo->psLINFBInfo);
OMAP_DSS_DRIVER(psDSSDrv, psDSSDev);
enum omap_dss_update_mode eDSSMode;
int res;
if (psDSSDrv == NULL || psDSSDrv->set_update_mode == NULL)
{
DEBUG_PRINTK((KERN_INFO DRIVER_PREFIX ": %s: Device %u: Can't set update mode\n", __FUNCTION__, psDevInfo->uiFBDevID));
return OMAPLFB_FALSE;
}
switch(eMode)
{
case OMAPLFB_UPDATE_MODE_AUTO:
eDSSMode = OMAP_DSS_UPDATE_AUTO;
break;
case OMAPLFB_UPDATE_MODE_MANUAL:
eDSSMode = OMAP_DSS_UPDATE_MANUAL;
break;
case OMAPLFB_UPDATE_MODE_DISABLED:
eDSSMode = OMAP_DSS_UPDATE_DISABLED;
break;
default:
DEBUG_PRINTK((KERN_INFO DRIVER_PREFIX ": %s: Device %u: Unknown update mode (%d)\n", __FUNCTION__, psDevInfo->uiFBDevID, eMode));
return OMAPLFB_FALSE;
}
res = psDSSDrv->set_update_mode(psDSSDev, eDSSMode);
if (res != 0)
{
DEBUG_PRINTK((KERN_INFO DRIVER_PREFIX ": %s: Device %u: set_update_mode failed (%d)\n", __FUNCTION__, psDevInfo->uiFBDevID, res));
}
return (res == 0);
#endif
return 1;
}
int omapfb_ioctl(struct fb_info *fbi, unsigned int cmd, unsigned long arg)
{
struct omapfb_info *ofbi = FB2OFB(fbi);
struct omapfb2_device *fbdev = ofbi->fbdev;
struct omap_dss_device *display = fb2display(fbi);
union {
struct omapfb_update_window_old uwnd_o;
struct omapfb_update_window uwnd;
struct omapfb_plane_info plane_info;
struct omapfb_caps caps;
struct omapfb_mem_info mem_info;
struct omapfb_color_key color_key;
struct omapfb_ovl_colormode ovl_colormode;
enum omapfb_update_mode update_mode;
int test_num;
struct omapfb_memory_read memory_read;
struct omapfb_vram_info vram_info;
struct omapfb_tearsync_info tearsync_info;
struct omapfb_display_info display_info;
// Modified by prajuna 20110223 for color tuning {
#ifdef LGE_FW_TDMB
struct omapfb_ccs ccs_info;
#endif // LGE_FW_TDMB
// Modified by prajuna 20110223 for color tuning {
} p;
int r = 0;
switch (cmd) {
case OMAPFB_SYNC_GFX:
DBG("ioctl SYNC_GFX\n");
if (!display || !display->driver->sync) {
/* DSS1 never returns an error here, so we neither */
/*r = -EINVAL;*/
break;
}
r = display->driver->sync(display);
break;
case OMAPFB_UPDATE_WINDOW_OLD:
DBG("ioctl UPDATE_WINDOW_OLD\n");
if (!display || !display->driver->update) {
r = -EINVAL;
break;
}
if (copy_from_user(&p.uwnd_o,
(void __user *)arg,
sizeof(p.uwnd_o))) {
r = -EFAULT;
break;
}
r = omapfb_update_window_nolock(fbi, p.uwnd_o.x, p.uwnd_o.y,
p.uwnd_o.width, p.uwnd_o.height);
break;
case OMAPFB_UPDATE_WINDOW:
DBG("ioctl UPDATE_WINDOW\n");
if (!display || !display->driver->update) {
r = -EINVAL;
break;
}
if (copy_from_user(&p.uwnd, (void __user *)arg,
sizeof(p.uwnd))) {
r = -EFAULT;
break;
}
r = omapfb_update_window_nolock(fbi, p.uwnd.x, p.uwnd.y,
p.uwnd.width, p.uwnd.height);
break;
case OMAPFB_SETUP_PLANE:
DBG("ioctl SETUP_PLANE\n");
if (copy_from_user(&p.plane_info, (void __user *)arg,
sizeof(p.plane_info)))
r = -EFAULT;
else
r = omapfb_setup_plane(fbi, &p.plane_info);
break;
case OMAPFB_QUERY_PLANE:
DBG("ioctl QUERY_PLANE\n");
r = omapfb_query_plane(fbi, &p.plane_info);
if (r < 0)
break;
if (copy_to_user((void __user *)arg, &p.plane_info,
sizeof(p.plane_info)))
r = -EFAULT;
break;
case OMAPFB_SETUP_MEM:
DBG("ioctl SETUP_MEM\n");
if (copy_from_user(&p.mem_info, (void __user *)arg,
sizeof(p.mem_info)))
r = -EFAULT;
else
r = omapfb_setup_mem(fbi, &p.mem_info);
break;
case OMAPFB_QUERY_MEM:
DBG("ioctl QUERY_MEM\n");
r = omapfb_query_mem(fbi, &p.mem_info);
if (r < 0)
break;
if (copy_to_user((void __user *)arg, &p.mem_info,
sizeof(p.mem_info)))
r = -EFAULT;
break;
case OMAPFB_GET_CAPS:
DBG("ioctl GET_CAPS\n");
if (!display) {
r = -EINVAL;
break;
}
memset(&p.caps, 0, sizeof(p.caps));
if (display->caps & OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE)
p.caps.ctrl |= OMAPFB_CAPS_MANUAL_UPDATE;
if (display->caps & OMAP_DSS_DISPLAY_CAP_TEAR_ELIM)
p.caps.ctrl |= OMAPFB_CAPS_TEARSYNC;
if (copy_to_user((void __user *)arg, &p.caps, sizeof(p.caps)))
r = -EFAULT;
break;
case OMAPFB_GET_OVERLAY_COLORMODE:
DBG("ioctl GET_OVERLAY_COLORMODE\n");
if (copy_from_user(&p.ovl_colormode, (void __user *)arg,
sizeof(p.ovl_colormode))) {
r = -EFAULT;
break;
}
r = omapfb_get_ovl_colormode(fbdev, &p.ovl_colormode);
if (r < 0)
break;
if (copy_to_user((void __user *)arg, &p.ovl_colormode,
sizeof(p.ovl_colormode)))
r = -EFAULT;
break;
case OMAPFB_SET_UPDATE_MODE:
DBG("ioctl SET_UPDATE_MODE\n");
if (get_user(p.update_mode, (int __user *)arg))
r = -EFAULT;
else
r = omapfb_set_update_mode(fbi, p.update_mode);
break;
case OMAPFB_GET_UPDATE_MODE:
DBG("ioctl GET_UPDATE_MODE\n");
r = omapfb_get_update_mode(fbi, &p.update_mode);
if (r)
break;
if (put_user(p.update_mode,
(enum omapfb_update_mode __user *)arg))
r = -EFAULT;
break;
case OMAPFB_SET_COLOR_KEY:
DBG("ioctl SET_COLOR_KEY\n");
if (copy_from_user(&p.color_key, (void __user *)arg,
sizeof(p.color_key)))
r = -EFAULT;
else
r = omapfb_set_color_key(fbi, &p.color_key);
break;
case OMAPFB_GET_COLOR_KEY:
DBG("ioctl GET_COLOR_KEY\n");
r = omapfb_get_color_key(fbi, &p.color_key);
if (r)
break;
if (copy_to_user((void __user *)arg, &p.color_key,
sizeof(p.color_key)))
r = -EFAULT;
break;
case OMAPFB_WAITFORVSYNC:
DBG("ioctl WAITFORVSYNC\n");
if (!display) {
r = -EINVAL;
break;
}
r = display->manager->wait_for_vsync(display->manager);
break;
case OMAPFB_WAITFORGO:
DBG("ioctl WAITFORGO\n");
if (!display) {
r = -EINVAL;
break;
}
r = omapfb_wait_for_go(fbi);
break;
/* LCD and CTRL tests do the same thing for backward
* compatibility */
case OMAPFB_LCD_TEST:
DBG("ioctl LCD_TEST\n");
if (get_user(p.test_num, (int __user *)arg)) {
r = -EFAULT;
break;
}
if (!display || !display->driver->run_test) {
r = -EINVAL;
break;
}
r = display->driver->run_test(display, p.test_num);
break;
case OMAPFB_CTRL_TEST:
DBG("ioctl CTRL_TEST\n");
if (get_user(p.test_num, (int __user *)arg)) {
r = -EFAULT;
break;
}
if (!display || !display->driver->run_test) {
r = -EINVAL;
break;
}
r = display->driver->run_test(display, p.test_num);
break;
case OMAPFB_MEMORY_READ:
DBG("ioctl MEMORY_READ\n");
if (copy_from_user(&p.memory_read, (void __user *)arg,
sizeof(p.memory_read))) {
r = -EFAULT;
break;
}
r = omapfb_memory_read(fbi, &p.memory_read);
break;
case OMAPFB_GET_VRAM_INFO: {
unsigned long vram, free, largest;
DBG("ioctl GET_VRAM_INFO\n");
omap_vram_get_info(&vram, &free, &largest);
p.vram_info.total = vram;
p.vram_info.free = free;
p.vram_info.largest_free_block = largest;
if (copy_to_user((void __user *)arg, &p.vram_info,
sizeof(p.vram_info)))
r = -EFAULT;
break;
}
case OMAPFB_SET_TEARSYNC: {
DBG("ioctl SET_TEARSYNC\n");
if (copy_from_user(&p.tearsync_info, (void __user *)arg,
sizeof(p.tearsync_info))) {
r = -EFAULT;
break;
}
if (!display || !display->driver->enable_te) {
r = -ENODEV;
break;
}
r = display->driver->enable_te(display,
!!p.tearsync_info.enabled);
break;
}
case OMAPFB_GET_DISPLAY_INFO: {
u16 xres, yres;
DBG("ioctl GET_DISPLAY_INFO\n");
if (display == NULL) {
r = -ENODEV;
break;
}
display->driver->get_resolution(display, &xres, &yres);
p.display_info.xres = xres;
p.display_info.yres = yres;
p.display_info.width = 0;
p.display_info.height = 0;
if (copy_to_user((void __user *)arg, &p.display_info,
sizeof(p.display_info)))
r = -EFAULT;
break;
}
// Modified by prajuna 20110223 for color tuning {
#ifdef LGE_FW_TDMB
case OMAPFB_SET_CCS_MATRIX :
printk("OMAPFB_SET_CCS_MATRIX\n");
// Modified by prajuna 20110527 for avoidance of DMB + Call lock up issue(DV 2nd DMB FT)
//
{
if (display->state != OMAP_DSS_DISPLAY_ACTIVE)
{
DBG("OMAPFB_SET_CCS_MATRIX(For DMB color tuning) called, but do nothing\n");
r = -EFAULT;
break;
}
}
//
if (copy_from_user(&p.ccs_info, (void __user *)arg,
sizeof(p.ccs_info))) {
r = -EFAULT;
break;
}
if (!display || !display->set_ccs) {
r = -ENODEV;
break;
}
{
struct omap_ccs_matrix ccs_info;
ccs_info.ry = p.ccs_info.ccs[0];
ccs_info.rcr = p.ccs_info.ccs[1];
ccs_info.rcb = p.ccs_info.ccs[2];
ccs_info.gy = p.ccs_info.ccs[3];
ccs_info.gcr = p.ccs_info.ccs[4];
ccs_info.gcb = p.ccs_info.ccs[5];
ccs_info.by = p.ccs_info.ccs[6];
ccs_info.bcr = p.ccs_info.ccs[7];
ccs_info.bcb = p.ccs_info.ccs[8];
r = display->set_ccs(display, &ccs_info);
}
break;
#endif // LGE_FW_TDMB
// Modified by prajuna 20110223 for color tuning }
default:
dev_err(fbdev->dev, "Unknown ioctl 0x%x\n", cmd);
r = -EINVAL;
}
if (r < 0)
DBG("ioctl failed: %d\n", r);
return r;
}
static int omapfb_setup_mem(struct fb_info *fbi, struct omapfb_mem_info *mi)
{
struct omapfb_info *ofbi = FB2OFB(fbi);
struct omapfb2_device *fbdev = ofbi->fbdev;
struct omapfb2_mem_region *rg;
struct omap_display *display = fb2display(fbi);
int r, i;
size_t size;
if (mi->type > OMAPFB_MEMTYPE_MAX)
return -EINVAL;
size = PAGE_ALIGN(mi->size);
rg = &ofbi->region;
omapfb_lock(fbdev);
for (i = 0; i < ofbi->num_overlays; i++) {
if (ofbi->overlays[i]->info.enabled) {
r = -EBUSY;
goto out;
}
}
if (rg->size != size || rg->type != mi->type) {
struct fb_var_screeninfo new_var;
unsigned long old_size = rg->size;
if (display->sync)
display->sync(display);
r = omapfb_realloc_fbmem(fbdev, ofbi->id, size);
if (r)
goto out;
if (old_size != size) {
if (size) {
memcpy(&new_var, &fbi->var, sizeof(new_var));
r = check_fb_var(fbi, &new_var);
if (r < 0)
goto out;
memcpy(&fbi->var, &new_var, sizeof(fbi->var));
set_fb_fix(fbi);
} else {
/*
* Set these explicitly to indicate that the
* plane memory is dealloce'd, the other
* screen parameters in var / fix are invalid.
*/
fbi->fix.smem_start = 0;
fbi->fix.smem_len = 0;
}
}
}
r = 0;
out:
omapfb_unlock(fbdev);
return r;
}
int omapfb_ioctl(struct fb_info *fbi, unsigned int cmd, unsigned long arg)
{
struct omapfb_info *ofbi = FB2OFB(fbi);
struct omapfb2_device *fbdev = ofbi->fbdev;
struct omap_dss_device *display = fb2display(fbi);
union {
struct omapfb_update_window_old uwnd_o;
struct omapfb_update_window uwnd;
struct omapfb_plane_info plane_info;
struct omapfb_caps caps;
struct omapfb_mem_info mem_info;
struct omapfb_color_key color_key;
struct omapfb_ovl_colormode ovl_colormode;
enum omapfb_update_mode update_mode;
int test_num;
struct omapfb_memory_read memory_read;
struct omapfb_vram_info vram_info;
struct omapfb_tearsync_info tearsync_info;
struct omapfb_display_info display_info;
u32 crt;
} p;
int r = 0;
switch (cmd) {
case OMAPFB_SYNC_GFX:
DBG("ioctl SYNC_GFX\n");
if (!display || !display->driver->sync) {
/* DSS1 never returns an error here, so we neither */
/*r = -EINVAL;*/
break;
}
r = display->driver->sync(display);
break;
case OMAPFB_UPDATE_WINDOW_OLD:
DBG("ioctl UPDATE_WINDOW_OLD\n");
if (!display || !display->driver->update) {
r = -EINVAL;
break;
}
if (copy_from_user(&p.uwnd_o,
(void __user *)arg,
sizeof(p.uwnd_o))) {
r = -EFAULT;
break;
}
r = omapfb_update_window_nolock(fbi, p.uwnd_o.x, p.uwnd_o.y,
p.uwnd_o.width, p.uwnd_o.height);
break;
case OMAPFB_UPDATE_WINDOW:
DBG("ioctl UPDATE_WINDOW\n");
if (!display || !display->driver->update) {
r = -EINVAL;
break;
}
if (copy_from_user(&p.uwnd, (void __user *)arg,
sizeof(p.uwnd))) {
r = -EFAULT;
break;
}
r = omapfb_update_window_nolock(fbi, p.uwnd.x, p.uwnd.y,
p.uwnd.width, p.uwnd.height);
break;
case OMAPFB_SETUP_PLANE:
DBG("ioctl SETUP_PLANE\n");
if (copy_from_user(&p.plane_info, (void __user *)arg,
sizeof(p.plane_info)))
r = -EFAULT;
else
r = omapfb_setup_plane(fbi, &p.plane_info);
break;
case OMAPFB_QUERY_PLANE:
DBG("ioctl QUERY_PLANE\n");
r = omapfb_query_plane(fbi, &p.plane_info);
if (r < 0)
break;
if (copy_to_user((void __user *)arg, &p.plane_info,
sizeof(p.plane_info)))
r = -EFAULT;
break;
case OMAPFB_SETUP_MEM:
DBG("ioctl SETUP_MEM\n");
if (copy_from_user(&p.mem_info, (void __user *)arg,
sizeof(p.mem_info)))
r = -EFAULT;
else
r = omapfb_setup_mem(fbi, &p.mem_info);
break;
case OMAPFB_QUERY_MEM:
DBG("ioctl QUERY_MEM\n");
r = omapfb_query_mem(fbi, &p.mem_info);
if (r < 0)
break;
if (copy_to_user((void __user *)arg, &p.mem_info,
sizeof(p.mem_info)))
r = -EFAULT;
break;
case OMAPFB_GET_CAPS:
DBG("ioctl GET_CAPS\n");
if (!display) {
r = -EINVAL;
break;
}
memset(&p.caps, 0, sizeof(p.caps));
if (display->caps & OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE)
p.caps.ctrl |= OMAPFB_CAPS_MANUAL_UPDATE;
if (display->caps & OMAP_DSS_DISPLAY_CAP_TEAR_ELIM)
p.caps.ctrl |= OMAPFB_CAPS_TEARSYNC;
if (copy_to_user((void __user *)arg, &p.caps, sizeof(p.caps)))
r = -EFAULT;
break;
case OMAPFB_GET_OVERLAY_COLORMODE:
DBG("ioctl GET_OVERLAY_COLORMODE\n");
if (copy_from_user(&p.ovl_colormode, (void __user *)arg,
sizeof(p.ovl_colormode))) {
r = -EFAULT;
break;
}
r = omapfb_get_ovl_colormode(fbdev, &p.ovl_colormode);
if (r < 0)
break;
if (copy_to_user((void __user *)arg, &p.ovl_colormode,
sizeof(p.ovl_colormode)))
r = -EFAULT;
break;
case OMAPFB_SET_UPDATE_MODE:
DBG("ioctl SET_UPDATE_MODE\n");
if (get_user(p.update_mode, (int __user *)arg))
r = -EFAULT;
else
r = omapfb_set_update_mode(fbi, p.update_mode);
break;
case OMAPFB_GET_UPDATE_MODE:
DBG("ioctl GET_UPDATE_MODE\n");
r = omapfb_get_update_mode(fbi, &p.update_mode);
if (r)
break;
if (put_user(p.update_mode,
(enum omapfb_update_mode __user *)arg))
r = -EFAULT;
break;
case OMAPFB_SET_COLOR_KEY:
DBG("ioctl SET_COLOR_KEY\n");
if (copy_from_user(&p.color_key, (void __user *)arg,
sizeof(p.color_key)))
r = -EFAULT;
else
r = omapfb_set_color_key(fbi, &p.color_key);
break;
case OMAPFB_GET_COLOR_KEY:
DBG("ioctl GET_COLOR_KEY\n");
r = omapfb_get_color_key(fbi, &p.color_key);
if (r)
break;
if (copy_to_user((void __user *)arg, &p.color_key,
sizeof(p.color_key)))
r = -EFAULT;
break;
case FBIO_WAITFORVSYNC:
if (get_user(p.crt, (__u32 __user *)arg)) {
r = -EFAULT;
break;
}
if (p.crt != 0) {
r = -ENODEV;
break;
}
/* FALLTHROUGH */
case OMAPFB_WAITFORVSYNC:
DBG("ioctl WAITFORVSYNC\n");
if (!display) {
r = -EINVAL;
break;
}
r = display->manager->wait_for_vsync(display->manager);
break;
case OMAPFB_WAITFORGO:
DBG("ioctl WAITFORGO\n");
if (!display) {
r = -EINVAL;
break;
}
r = omapfb_wait_for_go(fbi);
break;
/* LCD and CTRL tests do the same thing for backward
* compatibility */
case OMAPFB_LCD_TEST:
DBG("ioctl LCD_TEST\n");
if (get_user(p.test_num, (int __user *)arg)) {
r = -EFAULT;
break;
}
if (!display || !display->driver->run_test) {
r = -EINVAL;
break;
}
r = display->driver->run_test(display, p.test_num);
break;
case OMAPFB_CTRL_TEST:
DBG("ioctl CTRL_TEST\n");
if (get_user(p.test_num, (int __user *)arg)) {
r = -EFAULT;
break;
}
if (!display || !display->driver->run_test) {
r = -EINVAL;
break;
}
r = display->driver->run_test(display, p.test_num);
break;
case OMAPFB_MEMORY_READ:
DBG("ioctl MEMORY_READ\n");
if (copy_from_user(&p.memory_read, (void __user *)arg,
sizeof(p.memory_read))) {
r = -EFAULT;
break;
}
r = omapfb_memory_read(fbi, &p.memory_read);
break;
case OMAPFB_GET_VRAM_INFO: {
unsigned long vram, free, largest;
DBG("ioctl GET_VRAM_INFO\n");
omap_vram_get_info(&vram, &free, &largest);
p.vram_info.total = vram;
p.vram_info.free = free;
p.vram_info.largest_free_block = largest;
if (copy_to_user((void __user *)arg, &p.vram_info,
sizeof(p.vram_info)))
r = -EFAULT;
break;
}
case OMAPFB_SET_TEARSYNC: {
DBG("ioctl SET_TEARSYNC\n");
if (copy_from_user(&p.tearsync_info, (void __user *)arg,
sizeof(p.tearsync_info))) {
r = -EFAULT;
break;
}
if (!display || !display->driver->enable_te) {
r = -ENODEV;
break;
}
r = display->driver->enable_te(display,
!!p.tearsync_info.enabled);
break;
}
case OMAPFB_GET_DISPLAY_INFO: {
u16 xres, yres;
u32 w, h;
DBG("ioctl GET_DISPLAY_INFO\n");
if (display == NULL) {
r = -ENODEV;
break;
}
display->driver->get_resolution(display, &xres, &yres);
p.display_info.xres = xres;
p.display_info.yres = yres;
omapdss_display_get_dimensions(display, &w, &h);
p.display_info.width = w;
p.display_info.height = h;
if (copy_to_user((void __user *)arg, &p.display_info,
sizeof(p.display_info)))
r = -EFAULT;
break;
case OMAPFB_ENABLEVSYNC:
if (get_user(p.crt, (__u32 __user *)arg)) {
r = -EFAULT;
break;
}
if (p.crt) {
fbdev->vsync_active = true;
wmb();
wake_up(&fbdev->vsync_wq);
} else {
/* this will cause work function to exit */
fbdev->vsync_active = false;
wmb();
}
break;
}
default:
dev_err(fbdev->dev, "Unknown ioctl 0x%x\n", cmd);
r = -EINVAL;
}
if (r < 0)
DBG("ioctl failed: %d\n", r);
return r;
}
int omapfb_ioctl(struct fb_info *fbi, unsigned int cmd, unsigned long arg)
{
struct omapfb_info *ofbi = FB2OFB(fbi);
struct omapfb2_device *fbdev = ofbi->fbdev;
struct omap_display *display = fb2display(fbi);
union {
struct omapfb_update_window_old uwnd_o;
struct omapfb_update_window uwnd;
struct omapfb_plane_info plane_info;
struct omapfb_caps caps;
struct omapfb_mem_info mem_info;
enum omapfb_update_mode update_mode;
int test_num;
} p;
int r = 0;
DBG("ioctl %x (%d)\n", cmd, cmd & 0xff);
switch (cmd) {
case OMAPFB_SYNC_GFX:
if (!display || !display->sync) {
/* DSS1 never returns an error here, so we neither */
/*r = -EINVAL;*/
break;
}
omapfb_lock(fbdev);
r = display->sync(display);
omapfb_unlock(fbdev);
break;
case OMAPFB_UPDATE_WINDOW_OLD:
if (!display || !display->update) {
r = -EINVAL;
break;
}
if (copy_from_user(&p.uwnd_o,
(void __user *)arg,
sizeof(p.uwnd_o))) {
r = -EFAULT;
break;
}
r = omapfb_update_window(fbi, p.uwnd_o.x, p.uwnd_o.y,
p.uwnd_o.width, p.uwnd_o.height);
break;
case OMAPFB_UPDATE_WINDOW:
if (!display || !display->update) {
r = -EINVAL;
break;
}
if (copy_from_user(&p.uwnd, (void __user *)arg,
sizeof(p.uwnd))) {
r = -EFAULT;
break;
}
r = omapfb_update_window(fbi, p.uwnd.x, p.uwnd.y,
p.uwnd.width, p.uwnd.height);
break;
case OMAPFB_SETUP_PLANE:
if (copy_from_user(&p.plane_info, (void __user *)arg,
sizeof(p.plane_info)))
r = -EFAULT;
else
r = omapfb_setup_plane(fbi, &p.plane_info);
break;
case OMAPFB_CROP_PLANE:
if (copy_from_user(&p.plane_info, (void __user *)arg,
sizeof(p.plane_info)))
r = -EFAULT;
else
r = omapfb_crop_plane(fbi, &p.plane_info);
break;
case OMAPFB_QUERY_PLANE:
r = omapfb_query_plane(fbi, &p.plane_info);
if (r < 0)
break;
if (copy_to_user((void __user *)arg, &p.plane_info,
sizeof(p.plane_info)))
r = -EFAULT;
break;
case OMAPFB_SETUP_MEM:
if (copy_from_user(&p.mem_info, (void __user *)arg,
sizeof(p.mem_info)))
r = -EFAULT;
else
r = omapfb_setup_mem(fbi, &p.mem_info);
break;
case OMAPFB_QUERY_MEM:
r = omapfb_query_mem(fbi, &p.mem_info);
if (r < 0)
break;
if (copy_to_user((void __user *)arg, &p.mem_info,
sizeof(p.mem_info)))
r = -EFAULT;
break;
case OMAPFB_GET_CAPS:
if (!display) {
r = -EINVAL;
break;
}
p.caps.ctrl = display->caps;
if (copy_to_user((void __user *)arg, &p.caps, sizeof(p.caps)))
r = -EFAULT;
break;
case OMAPFB_SET_UPDATE_MODE:
if (get_user(p.update_mode, (int __user *)arg))
r = -EFAULT;
else
r = omapfb_set_update_mode(fbi, p.update_mode);
break;
case OMAPFB_GET_UPDATE_MODE:
r = omapfb_get_update_mode(fbi, &p.update_mode);
if (r)
break;
if (put_user(p.update_mode,
(enum omapfb_update_mode __user *)arg))
r = -EFAULT;
break;
/* LCD and CTRL tests do the same thing for backward
* compatibility */
case OMAPFB_LCD_TEST:
if (get_user(p.test_num, (int __user *)arg)) {
r = -EFAULT;
break;
}
if (!display || !display->run_test) {
r = -EINVAL;
break;
}
r = display->run_test(display, p.test_num);
break;
case OMAPFB_CTRL_TEST:
if (get_user(p.test_num, (int __user *)arg)) {
r = -EFAULT;
break;
}
if (!display || !display->run_test) {
r = -EINVAL;
break;
}
r = display->run_test(display, p.test_num);
break;
case OMAPFB_WAIT_FOR_VSYNC:
return omapfb_wait_for_vsync(fbi);
break;
case OMAPFB_VRFB_ROTATE_CCW:
ofbi->rotation_type = OMAPFB_ROT_VRFB;
ofbi->rotation = FB_ROTATE_CCW;
set_fb_fix(fbi);
omapfb_apply_changes(fbi, 0);
break;
default:
DBG("ioctl unhandled\n");
r = -EINVAL;
}
return r;
}
/*
* Get display update mode.
* If the mode is AUTO, we can wait for VSync, if desired.
*/
OMAPLFB_UPDATE_MODE OMAPLFBGetUpdateMode(OMAPLFB_DEVINFO *psDevInfo)
{
#if defined(PVR_OMAPLFB_DRM_FB)
struct drm_connector *psConnector;
OMAPLFB_UPDATE_MODE eMode = OMAPLFB_UPDATE_MODE_UNDEFINED;
/*
* There may be multiple displays connected. If at least one
* display is manual update mode, report all screens as being
* in that mode.
*/
for (psConnector = NULL;
(psConnector = omap_fbdev_get_next_connector(psDevInfo->psLINFBInfo, psConnector)) != NULL;)
{
switch(omap_connector_get_update_mode(psConnector))
{
case OMAP_DSS_UPDATE_MANUAL:
eMode = OMAPLFB_UPDATE_MODE_MANUAL;
break;
case OMAP_DSS_UPDATE_DISABLED:
if (eMode == OMAPLFB_UPDATE_MODE_UNDEFINED)
{
eMode = OMAPLFB_UPDATE_MODE_DISABLED;
}
break;
case OMAP_DSS_UPDATE_AUTO:
/* Fall through to default case */
default:
/* Asssume auto update is possible */
if (eMode != OMAPLFB_UPDATE_MODE_MANUAL)
{
eMode = OMAPLFB_UPDATE_MODE_AUTO;
}
break;
}
}
return eMode;
#else /* defined(PVR_OMAPLFB_DRM_FB) */
#if LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0)
struct omap_dss_device *psDSSDev = fb2display(psDevInfo->psLINFBInfo);
OMAP_DSS_DRIVER(psDSSDrv, psDSSDev);
enum omap_dss_update_mode eMode;
if (psDSSDrv == NULL)
{
DEBUG_PRINTK((KERN_WARNING DRIVER_PREFIX ": %s: Device %u: No DSS device\n", __FUNCTION__, psDevInfo->uiFBDevID));
return OMAPLFB_UPDATE_MODE_UNDEFINED;
}
if (psDSSDrv->get_update_mode == NULL)
{
if (strcmp(psDSSDev->name, "hdmi") == 0)
{
return OMAPLFB_UPDATE_MODE_AUTO;
}
// DEBUG_PRINTK((KERN_WARNING DRIVER_PREFIX ": %s: Device %u: No get_update_mode function\n", __FUNCTION__, psDevInfo->uiFBDevID));
// return OMAPLFB_UPDATE_MODE_UNDEFINED;
return OMAPLFB_UPDATE_MODE_AUTO;
}
eMode = psDSSDrv->get_update_mode(psDSSDev);
if (!OMAPLFBValidateDSSUpdateMode(eMode))
{
DEBUG_PRINTK((KERN_WARNING DRIVER_PREFIX ": %s: Device %u: Unknown update mode (%d)\n", __FUNCTION__, psDevInfo->uiFBDevID, (int)eMode));
}
return OMAPLFBFromDSSUpdateMode(eMode);
#else
return OMAPLFB_UPDATE_MODE_AUTO;
#endif
#endif /* defined(PVR_OMAPLFB_DRM_FB) */
}
/* Flip display to given buffer */
void OMAPLFBFlip(OMAPLFB_DEVINFO *psDevInfo, OMAPLFB_BUFFER *psBuffer)
{
struct fb_var_screeninfo sFBVar;
int res;
OMAPLFB_CONSOLE_LOCK();
sFBVar = psDevInfo->psLINFBInfo->var;
sFBVar.xoffset = 0;
sFBVar.yoffset = psBuffer->ulYOffset;
#if defined(CONFIG_DSSCOMP)
/*
* If flipping to a NULL buffer, blank the screen to prevent
* warnings/errors from the display subsystem.
*/
if (psBuffer->sSysAddr.uiAddr == 0)
{
struct omap_dss_device *psDSSDev = fb2display(psDevInfo->psLINFBInfo);
OMAP_DSS_MANAGER(psDSSMan, psDSSDev);
if (psDSSMan != NULL && psDSSMan->blank != NULL)
{
res = psDSSMan->blank(psDSSMan, false);
if (res != 0)
{
DEBUG_PRINTK((KERN_WARNING DRIVER_PREFIX ": %s: Device %u: DSS manager blank call failed (Y Offset: %lu, Error: %d)\n", __FUNCTION__, psDevInfo->uiFBDevID, psBuffer->ulYOffset, res));
}
}
}
{
/*
* If using DSSCOMP, we need to use dsscomp queuing for normal
* framebuffer updates, so that previously used overlays get
* automatically disabled, and manager gets dirtied. We can
* do that because DSSCOMP takes ownership of all pipelines on
* a manager.
*/
struct fb_fix_screeninfo sFBFix = psDevInfo->psLINFBInfo->fix;
struct dsscomp_setup_dispc_data d =
{
.num_ovls = 1,
.num_mgrs = 1,
.mgrs[0].alpha_blending = 1,
.ovls[0] =
{
.cfg =
{
.win.w = sFBVar.xres,
.win.h = sFBVar.yres,
.crop.x = sFBVar.xoffset,
.crop.y = sFBVar.yoffset,
.crop.w = sFBVar.xres,
.crop.h = sFBVar.yres,
.width = sFBVar.xres_virtual,
.height = sFBVar.yres_virtual,
.stride = sFBFix.line_length,
.enabled = (psBuffer->sSysAddr.uiAddr != 0),
.global_alpha = 255,
},
},
};
/* do not map buffer into TILER1D as it is contiguous */
struct tiler_pa_info *pas[] = { NULL };
d.ovls[0].ba = (u32) psBuffer->sSysAddr.uiAddr;
omapfb_mode_to_dss_mode(&sFBVar, &d.ovls[0].cfg.color_mode);
res = dsscomp_gralloc_queue(&d, pas, true, NULL, NULL);
if (res != 0)
{
DEBUG_PRINTK((KERN_WARNING DRIVER_PREFIX ": %s: Device %u: dsscomp_gralloc_queue failed (Y Offset: %lu, Error: %d)\n", __FUNCTION__, psDevInfo->uiFBDevID, psBuffer->ulYOffset, res));
}
}
#else /* defined(CONFIG_DSSCOMP) */
{
unsigned long ulYResVirtual = psBuffer->ulYOffset + sFBVar.yres;
/*
* PVR_OMAPLFB_DONT_USE_FB_PAN_DISPLAY should be defined to
* work around flipping problems seen with the Taal LCDs on
* Blaze.
* The work around is safe to use with other types of screen
* on Blaze (e.g. HDMI) and on other platforms (e.g. Panda
* board).
*/
#if !defined(PVR_OMAPLFB_DONT_USE_FB_PAN_DISPLAY)
/*
* Attempt to change the virtual screen resolution if it is too
* small. Note that fb_set_var also pans the display.
*/
if (sFBVar.xres_virtual != sFBVar.xres || sFBVar.yres_virtual < ulYResVirtual)
#endif /* !defined(PVR_OMAPLFB_DONT_USE_FB_PAN_DISPLAY) */
{
sFBVar.xres_virtual = sFBVar.xres;
sFBVar.yres_virtual = ulYResVirtual;
sFBVar.activate = FB_ACTIVATE_NOW | FB_ACTIVATE_FORCE;
res = fb_set_var(psDevInfo->psLINFBInfo, &sFBVar);
if (res != 0)
{
printk(KERN_ERR DRIVER_PREFIX ": %s: Device %u: fb_set_var failed (Y Offset: %lu, Error: %d)\n", __FUNCTION__, psDevInfo->uiFBDevID, psBuffer->ulYOffset, res);
}
}
#if !defined(PVR_OMAPLFB_DONT_USE_FB_PAN_DISPLAY)
else
{
res = fb_pan_display(psDevInfo->psLINFBInfo, &sFBVar);
if (res != 0)
{
printk(KERN_ERR DRIVER_PREFIX ": %s: Device %u: fb_pan_display failed (Y Offset: %lu, Error: %d)\n", __FUNCTION__, psDevInfo->uiFBDevID, psBuffer->ulYOffset, res);
}
}
#endif /* !defined(PVR_OMAPLFB_DONT_USE_FB_PAN_DISPLAY) */
}
#endif /* defined(CONFIG_DSSCOMP) */
OMAPLFB_CONSOLE_UNLOCK();
}
static ssize_t store_size(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count)
{
struct fb_info *fbi = dev_get_drvdata(dev);
struct omapfb_info *ofbi = FB2OFB(fbi);
struct omapfb2_device *fbdev = ofbi->fbdev;
struct omap_dss_device *display = fb2display(fbi);
struct omapfb2_mem_region *rg;
unsigned long size;
int r;
int i;
r = kstrtoul(buf, 0, &size);
if (r)
return r;
size = PAGE_ALIGN(size);
if (!lock_fb_info(fbi))
return -ENODEV;
if (display && display->driver->sync)
display->driver->sync(display);
rg = ofbi->region;
down_write_nested(&rg->lock, rg->id);
atomic_inc(&rg->lock_count);
if (atomic_read(&rg->map_count)) {
r = -EBUSY;
goto out;
}
for (i = 0; i < fbdev->num_fbs; i++) {
struct omapfb_info *ofbi2 = FB2OFB(fbdev->fbs[i]);
int j;
if (ofbi2->region != rg)
continue;
for (j = 0; j < ofbi2->num_overlays; j++) {
struct omap_overlay *ovl;
ovl = ofbi2->overlays[j];
if (ovl->is_enabled(ovl)) {
r = -EBUSY;
goto out;
}
}
}
if (size != ofbi->region->size) {
r = omapfb_realloc_fbmem(fbi, size, ofbi->region->type);
if (r) {
dev_err(dev, "realloc fbmem failed\n");
goto out;
}
}
r = count;
out:
atomic_dec(&rg->lock_count);
up_write(&rg->lock);
unlock_fb_info(fbi);
return r;
}
int omapfb_ioctl(struct fb_info *fbi, unsigned int cmd, unsigned long arg)
{
struct omapfb_info *ofbi = FB2OFB(fbi);
struct omapfb2_device *fbdev = ofbi->fbdev;
struct omap_dss_device *display = fb2display(fbi);
union {
struct omapfb_update_window_old uwnd_o;
struct omapfb_update_window uwnd;
struct omapfb_plane_info plane_info;
struct omapfb_caps caps;
struct omapfb_mem_info mem_info;
struct omapfb_color_key color_key;
struct omapfb_ovl_colormode ovl_colormode;
enum omapfb_update_mode update_mode;
int test_num;
struct omapfb_memory_read memory_read;
} p;
int r = 0;
switch (cmd) {
case OMAPFB_SYNC_GFX:
DBG("ioctl SYNC_GFX\n");
if (!display || !display->sync) {
/* DSS1 never returns an error here, so we neither */
/*r = -EINVAL;*/
break;
}
r = display->sync(display);
break;
case OMAPFB_UPDATE_WINDOW_OLD:
DBG("ioctl UPDATE_WINDOW_OLD\n");
if (!display || !display->update) {
r = -EINVAL;
break;
}
if (copy_from_user(&p.uwnd_o,
(void __user *)arg,
sizeof(p.uwnd_o))) {
r = -EFAULT;
break;
}
r = omapfb_update_window(fbi, p.uwnd_o.x, p.uwnd_o.y,
p.uwnd_o.width, p.uwnd_o.height);
break;
case OMAPFB_UPDATE_WINDOW:
DBG("ioctl UPDATE_WINDOW\n");
if (!display || !display->update) {
r = -EINVAL;
break;
}
if (copy_from_user(&p.uwnd, (void __user *)arg,
sizeof(p.uwnd))) {
r = -EFAULT;
break;
}
r = omapfb_update_window(fbi, p.uwnd.x, p.uwnd.y,
p.uwnd.width, p.uwnd.height);
break;
case OMAPFB_SETUP_PLANE:
DBG("ioctl SETUP_PLANE\n");
if (copy_from_user(&p.plane_info, (void __user *)arg,
sizeof(p.plane_info)))
r = -EFAULT;
else
r = omapfb_setup_plane(fbi, &p.plane_info);
break;
case OMAPFB_QUERY_PLANE:
DBG("ioctl QUERY_PLANE\n");
r = omapfb_query_plane(fbi, &p.plane_info);
if (r < 0)
break;
if (copy_to_user((void __user *)arg, &p.plane_info,
sizeof(p.plane_info)))
r = -EFAULT;
break;
case OMAPFB_SETUP_MEM:
DBG("ioctl SETUP_MEM\n");
if (copy_from_user(&p.mem_info, (void __user *)arg,
sizeof(p.mem_info)))
r = -EFAULT;
else
r = omapfb_setup_mem(fbi, &p.mem_info);
break;
case OMAPFB_QUERY_MEM:
DBG("ioctl QUERY_MEM\n");
r = omapfb_query_mem(fbi, &p.mem_info);
if (r < 0)
break;
if (copy_to_user((void __user *)arg, &p.mem_info,
sizeof(p.mem_info)))
r = -EFAULT;
break;
case OMAPFB_GET_CAPS:
DBG("ioctl GET_CAPS\n");
if (!display) {
r = -EINVAL;
break;
}
memset(&p.caps, 0, sizeof(p.caps));
p.caps.ctrl = display->caps;
if (copy_to_user((void __user *)arg, &p.caps, sizeof(p.caps)))
r = -EFAULT;
break;
case OMAPFB_GET_OVERLAY_COLORMODE:
DBG("ioctl GET_OVERLAY_COLORMODE\n");
if (copy_from_user(&p.ovl_colormode, (void __user *)arg,
sizeof(p.ovl_colormode))) {
r = -EFAULT;
break;
}
r = omapfb_get_ovl_colormode(fbdev, &p.ovl_colormode);
if (r < 0)
break;
if (copy_to_user((void __user *)arg, &p.ovl_colormode,
sizeof(p.ovl_colormode)))
r = -EFAULT;
break;
case OMAPFB_SET_UPDATE_MODE:
DBG("ioctl SET_UPDATE_MODE\n");
if (get_user(p.update_mode, (int __user *)arg))
r = -EFAULT;
else
r = omapfb_set_update_mode(fbi, p.update_mode);
break;
case OMAPFB_GET_UPDATE_MODE:
DBG("ioctl GET_UPDATE_MODE\n");
r = omapfb_get_update_mode(fbi, &p.update_mode);
if (r)
break;
if (put_user(p.update_mode,
(enum omapfb_update_mode __user *)arg))
r = -EFAULT;
break;
case OMAPFB_SET_COLOR_KEY:
DBG("ioctl SET_COLOR_KEY\n");
if (copy_from_user(&p.color_key, (void __user *)arg,
sizeof(p.color_key)))
r = -EFAULT;
else
r = omapfb_set_color_key(fbi, &p.color_key);
break;
case OMAPFB_GET_COLOR_KEY:
DBG("ioctl GET_COLOR_KEY\n");
r = omapfb_get_color_key(fbi, &p.color_key);
if (r)
break;
if (copy_to_user((void __user *)arg, &p.color_key,
sizeof(p.color_key)))
r = -EFAULT;
break;
case OMAPFB_WAITFORVSYNC:
DBG("ioctl WAITFORVSYNC\n");
if (!display) {
r = -EINVAL;
break;
}
r = display->wait_vsync(display);
break;
case OMAPFB_WAITFORGO:
DBG("ioctl WAITFORGO\n");
if (!display) {
r = -EINVAL;
break;
}
r = omapfb_wait_for_go(fbi);
break;
/* LCD and CTRL tests do the same thing for backward
* compatibility */
case OMAPFB_LCD_TEST:
DBG("ioctl LCD_TEST\n");
if (get_user(p.test_num, (int __user *)arg)) {
r = -EFAULT;
break;
}
if (!display || !display->run_test) {
r = -EINVAL;
break;
}
r = display->run_test(display, p.test_num);
break;
case OMAPFB_CTRL_TEST:
DBG("ioctl CTRL_TEST\n");
if (get_user(p.test_num, (int __user *)arg)) {
r = -EFAULT;
break;
}
if (!display || !display->run_test) {
r = -EINVAL;
break;
}
r = display->run_test(display, p.test_num);
break;
case OMAPFB_MEMORY_READ:
DBG("ioctl MEMORY_READ\n");
if (copy_from_user(&p.memory_read, (void __user *)arg,
sizeof(p.memory_read))) {
r = -EFAULT;
break;
}
r = omapfb_memory_read(fbi, &p.memory_read);
break;
default:
dev_err(fbdev->dev, "Unknown ioctl 0x%x\n", cmd);
r = -EINVAL;
}
if (r < 0)
DBG("ioctl failed: %d\n", r);
return r;
}
int omapfb_ioctl(struct fb_info *fbi, unsigned int cmd, unsigned long arg)
{
struct omapfb_info *ofbi = FB2OFB(fbi);
struct omapfb2_device *fbdev = ofbi->fbdev;
struct omap_dss_device *display = fb2display(fbi);
union {
struct omapfb_update_window_old uwnd_o;
struct omapfb_update_window uwnd;
struct omapfb_plane_info plane_info;
struct omapfb_caps caps;
struct omapfb_mem_info mem_info;
struct omapfb_color_key color_key;
struct omapfb_ovl_colormode ovl_colormode;
enum omapfb_update_mode update_mode;
int test_num;
struct omapfb_memory_read memory_read;
struct omapfb_vram_info vram_info;
struct omapfb_tearsync_info tearsync_info;
struct omapfb_display_info display_info;
//--[[ LGE_UBIQUIX_MODIFIED_START : [email protected] [2011.08.07] - CAM color temp.
// LGE_DOM_UPDATE_S hyewon.eum 2010/10/01 {
struct omapfb_ccs ccs_info;
// LGE_DOM_UPDATE_S hyewon.eum 2010/10/01 }
//--]] LGE_UBIQUIX_MODIFIED_END : [email protected] [2011.08.07] - CAM color temp.
} p;
int r = 0;
switch (cmd) {
case OMAPFB_SYNC_GFX:
DBG("ioctl SYNC_GFX\n");
if (!display || !display->driver->sync) {
/* DSS1 never returns an error here, so we neither */
/*r = -EINVAL;*/
break;
}
r = display->driver->sync(display);
break;
case OMAPFB_UPDATE_WINDOW_OLD:
DBG("ioctl UPDATE_WINDOW_OLD\n");
if (!display || !display->driver->update) {
r = -EINVAL;
break;
}
if (copy_from_user(&p.uwnd_o,
(void __user *)arg,
sizeof(p.uwnd_o))) {
r = -EFAULT;
break;
}
r = omapfb_update_window_nolock(fbi, p.uwnd_o.x, p.uwnd_o.y,
p.uwnd_o.width, p.uwnd_o.height);
break;
case OMAPFB_UPDATE_WINDOW:
DBG("ioctl UPDATE_WINDOW\n");
if (!display || !display->driver->update) {
r = -EINVAL;
break;
}
if (copy_from_user(&p.uwnd, (void __user *)arg,
sizeof(p.uwnd))) {
r = -EFAULT;
break;
}
r = omapfb_update_window_nolock(fbi, p.uwnd.x, p.uwnd.y,
p.uwnd.width, p.uwnd.height);
break;
case OMAPFB_SETUP_PLANE:
DBG("ioctl SETUP_PLANE\n");
if (copy_from_user(&p.plane_info, (void __user *)arg,
sizeof(p.plane_info)))
r = -EFAULT;
else
r = omapfb_setup_plane(fbi, &p.plane_info);
break;
case OMAPFB_QUERY_PLANE:
DBG("ioctl QUERY_PLANE\n");
r = omapfb_query_plane(fbi, &p.plane_info);
if (r < 0)
break;
if (copy_to_user((void __user *)arg, &p.plane_info,
sizeof(p.plane_info)))
r = -EFAULT;
break;
case OMAPFB_SETUP_MEM:
DBG("ioctl SETUP_MEM\n");
if (copy_from_user(&p.mem_info, (void __user *)arg,
sizeof(p.mem_info)))
r = -EFAULT;
else
r = omapfb_setup_mem(fbi, &p.mem_info);
break;
case OMAPFB_QUERY_MEM:
DBG("ioctl QUERY_MEM\n");
r = omapfb_query_mem(fbi, &p.mem_info);
if (r < 0)
break;
if (copy_to_user((void __user *)arg, &p.mem_info,
sizeof(p.mem_info)))
r = -EFAULT;
break;
case OMAPFB_GET_CAPS:
DBG("ioctl GET_CAPS\n");
if (!display) {
r = -EINVAL;
break;
}
memset(&p.caps, 0, sizeof(p.caps));
if (display->caps & OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE)
p.caps.ctrl |= OMAPFB_CAPS_MANUAL_UPDATE;
if (display->caps & OMAP_DSS_DISPLAY_CAP_TEAR_ELIM)
p.caps.ctrl |= OMAPFB_CAPS_TEARSYNC;
if (copy_to_user((void __user *)arg, &p.caps, sizeof(p.caps)))
r = -EFAULT;
break;
case OMAPFB_GET_OVERLAY_COLORMODE:
DBG("ioctl GET_OVERLAY_COLORMODE\n");
if (copy_from_user(&p.ovl_colormode, (void __user *)arg,
sizeof(p.ovl_colormode))) {
r = -EFAULT;
break;
}
r = omapfb_get_ovl_colormode(fbdev, &p.ovl_colormode);
if (r < 0)
break;
if (copy_to_user((void __user *)arg, &p.ovl_colormode,
sizeof(p.ovl_colormode)))
r = -EFAULT;
break;
case OMAPFB_SET_UPDATE_MODE:
DBG("ioctl SET_UPDATE_MODE\n");
if (get_user(p.update_mode, (int __user *)arg))
r = -EFAULT;
else
r = omapfb_set_update_mode(fbi, p.update_mode);
break;
case OMAPFB_GET_UPDATE_MODE:
DBG("ioctl GET_UPDATE_MODE\n");
r = omapfb_get_update_mode(fbi, &p.update_mode);
if (r)
break;
if (put_user(p.update_mode,
(enum omapfb_update_mode __user *)arg))
r = -EFAULT;
break;
case OMAPFB_SET_COLOR_KEY:
DBG("ioctl SET_COLOR_KEY\n");
if (copy_from_user(&p.color_key, (void __user *)arg,
sizeof(p.color_key)))
r = -EFAULT;
else
r = omapfb_set_color_key(fbi, &p.color_key);
break;
case OMAPFB_GET_COLOR_KEY:
DBG("ioctl GET_COLOR_KEY\n");
r = omapfb_get_color_key(fbi, &p.color_key);
if (r)
break;
if (copy_to_user((void __user *)arg, &p.color_key,
sizeof(p.color_key)))
r = -EFAULT;
break;
case OMAPFB_WAITFORVSYNC:
DBG("ioctl WAITFORVSYNC\n");
if (!display) {
r = -EINVAL;
break;
}
r = display->manager->wait_for_vsync(display->manager);
break;
case OMAPFB_WAITFORGO:
DBG("ioctl WAITFORGO\n");
if (!display) {
r = -EINVAL;
break;
}
r = omapfb_wait_for_go(fbi);
break;
/* LCD and CTRL tests do the same thing for backward
* compatibility */
case OMAPFB_LCD_TEST:
DBG("ioctl LCD_TEST\n");
if (get_user(p.test_num, (int __user *)arg)) {
r = -EFAULT;
break;
}
if (!display || !display->driver->run_test) {
r = -EINVAL;
break;
}
r = display->driver->run_test(display, p.test_num);
break;
case OMAPFB_CTRL_TEST:
DBG("ioctl CTRL_TEST\n");
if (get_user(p.test_num, (int __user *)arg)) {
r = -EFAULT;
break;
}
if (!display || !display->driver->run_test) {
r = -EINVAL;
break;
}
r = display->driver->run_test(display, p.test_num);
break;
case OMAPFB_MEMORY_READ:
DBG("ioctl MEMORY_READ\n");
if (copy_from_user(&p.memory_read, (void __user *)arg,
sizeof(p.memory_read))) {
r = -EFAULT;
break;
}
r = omapfb_memory_read(fbi, &p.memory_read);
break;
case OMAPFB_GET_VRAM_INFO: {
unsigned long vram, free, largest;
DBG("ioctl GET_VRAM_INFO\n");
omap_vram_get_info(&vram, &free, &largest);
p.vram_info.total = vram;
p.vram_info.free = free;
p.vram_info.largest_free_block = largest;
if (copy_to_user((void __user *)arg, &p.vram_info,
sizeof(p.vram_info)))
r = -EFAULT;
break;
}
case OMAPFB_SET_TEARSYNC: {
DBG("ioctl SET_TEARSYNC\n");
if (copy_from_user(&p.tearsync_info, (void __user *)arg,
sizeof(p.tearsync_info))) {
r = -EFAULT;
break;
}
if (!display || !display->driver->enable_te) {
r = -ENODEV;
break;
}
r = display->driver->enable_te(display,
!!p.tearsync_info.enabled);
break;
}
case OMAPFB_GET_DISPLAY_INFO: {
u16 xres, yres;
DBG("ioctl GET_DISPLAY_INFO\n");
if (display == NULL) {
r = -ENODEV;
break;
}
display->driver->get_resolution(display, &xres, &yres);
p.display_info.xres = xres;
p.display_info.yres = yres;
p.display_info.width = 0;
p.display_info.height = 0;
if (copy_to_user((void __user *)arg, &p.display_info,
sizeof(p.display_info)))
r = -EFAULT;
break;
}
//--[[ LGE_UBIQUIX_MODIFIED_START : [email protected] [2011.08.07] - CAM color temp.
// LGE_DOM_UPDATE_S hyewon.eum 2010/10/01 {
case OMAPFB_SET_CCS_MATRIX :
printk("OMAPFB_SET_CCS_MATRIX\n");
if (copy_from_user(&p.ccs_info, (void __user *)arg,
sizeof(p.ccs_info))) {
r = -EFAULT;
break;
}
if (!cur_main_lcd_level) {
r = -EIO;
break;
}
#ifdef CONFIG_OMAP2_DSS_HDMI
if( is_hdmi_enabled() )
{
printk("====================================\n");
printk("DOING HDMI NOW..SKIP OMAPFB_SET_CCS_MATRIX\n");
printk("====================================\n");
r = -EIO;
break;
}
#endif
if (!display || !display->set_ccs) {
r = -ENODEV;
break;
}
{
struct omap_ccs_matrix ccs_info;
ccs_info.ry = p.ccs_info.ccs[0];
ccs_info.rcr = p.ccs_info.ccs[1];
ccs_info.rcb = p.ccs_info.ccs[2];
ccs_info.gy = p.ccs_info.ccs[3];
ccs_info.gcr = p.ccs_info.ccs[4];
ccs_info.gcb = p.ccs_info.ccs[5];
ccs_info.by = p.ccs_info.ccs[6];
ccs_info.bcr = p.ccs_info.ccs[7];
ccs_info.bcb = p.ccs_info.ccs[8];
r = display->set_ccs(display, &ccs_info);
}
break;
// LGE_DOM_UPDATE_S hyewon.eum 2010/10/01 }
//--]] LGE_UBIQUIX_MODIFIED_END : [email protected] [2011.08.07] - CAM color temp.
default:
dev_err(fbdev->dev, "Unknown ioctl 0x%x\n", cmd);
r = -EINVAL;
}
if (r < 0)
DBG("ioctl failed: %d\n", r);
return r;
}
/* Set display update mode */
OMAPLFB_BOOL OMAPLFBSetUpdateMode(OMAPLFB_DEVINFO *psDevInfo, OMAPLFB_UPDATE_MODE eMode)
{
#if defined(PVR_OMAPLFB_DRM_FB)
struct drm_connector *psConnector;
enum omap_dss_update_mode eDSSMode;
OMAPLFB_BOOL bSuccess = OMAPLFB_FALSE;
OMAPLFB_BOOL bFailure = OMAPLFB_FALSE;
if (!OMAPLFBValidateUpdateMode(eMode))
{
DEBUG_PRINTK((KERN_WARNING DRIVER_PREFIX ": %s: Device %u: Unknown update mode (%d)\n", __FUNCTION__, psDevInfo->uiFBDevID, (int)eMode));
return OMAPLFB_FALSE;
}
eDSSMode = OMAPLFBToDSSUpdateMode(eMode);
for (psConnector = NULL;
(psConnector = omap_fbdev_get_next_connector(psDevInfo->psLINFBInfo, psConnector)) != NULL;)
{
int iRes = omap_connector_set_update_mode(psConnector, eDSSMode);
OMAPLFB_BOOL bRes = (iRes == 0);
bSuccess |= bRes;
bFailure |= !bRes;
}
if (!bFailure)
{
if (!bSuccess)
{
DEBUG_PRINTK((KERN_WARNING DRIVER_PREFIX ": %s: Device %u: No screens\n", __FUNCTION__, psDevInfo->uiFBDevID));
}
return OMAPLFB_TRUE;
}
if (!bSuccess)
{
DEBUG_PRINTK((KERN_WARNING DRIVER_PREFIX ": %s: Device %u: Couldn't set %s for any screen\n", __FUNCTION__, psDevInfo->uiFBDevID, OMAPLFBUpdateModeToString(eMode)));
return OMAPLFB_FALSE;
}
if (eMode == OMAPLFB_UPDATE_MODE_AUTO)
{
DEBUG_PRINTK((KERN_WARNING DRIVER_PREFIX ": %s: Device %u: Couldn't set %s for all screens\n", __FUNCTION__, psDevInfo->uiFBDevID, OMAPLFBUpdateModeToString(eMode)));
return OMAPLFB_FALSE;
}
DEBUG_PRINTK((KERN_INFO DRIVER_PREFIX ": %s: Device %u: %s set for some screens\n", __FUNCTION__, psDevInfo->uiFBDevID, OMAPLFBUpdateModeToString(eMode)));
return OMAPLFB_TRUE;
#else /* defined(PVR_OMAPLFB_DRM_FB) */
#if LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0)
struct omap_dss_device *psDSSDev = fb2display(psDevInfo->psLINFBInfo);
OMAP_DSS_DRIVER(psDSSDrv, psDSSDev);
enum omap_dss_update_mode eDSSMode;
int res;
if (psDSSDrv == NULL || psDSSDrv->set_update_mode == NULL)
{
DEBUG_PRINTK((KERN_WARNING DRIVER_PREFIX ": %s: Device %u: Can't set update mode\n", __FUNCTION__, psDevInfo->uiFBDevID));
return OMAPLFB_FALSE;
}
if (!OMAPLFBValidateUpdateMode(eMode))
{
DEBUG_PRINTK((KERN_WARNING DRIVER_PREFIX ": %s: Device %u: Unknown update mode (%d)\n", __FUNCTION__, psDevInfo->uiFBDevID, (int)eMode));
return OMAPLFB_FALSE;
}
eDSSMode = OMAPLFBToDSSUpdateMode(eMode);
res = psDSSDrv->set_update_mode(psDSSDev, eDSSMode);
if (res != 0)
{
DEBUG_PRINTK((KERN_WARNING DRIVER_PREFIX ": %s: Device %u: set_update_mode (%s) failed (%d)\n", __FUNCTION__, psDevInfo->uiFBDevID, OMAPLFBDSSUpdateModeToString(eDSSMode), res));
}
return (res == 0);
#else
return 1;
#endif
#endif /* defined(PVR_OMAPLFB_DRM_FB) */
}