My Pastes
Public Pastes
Layout Width
Share Pastebin
Guest
Public paste!

Untitled

By: a guest | Sep 8th, 2010 | Syntax: None | Size: 33.51 KB | Hits: 40 | Expires: Never
Download | Raw | Embed | Report abuse
Copy text to clipboard
  1. #include <linux/platform_device.h>
  2. #include <linux/module.h>
  3. #include <linux/fb.h>
  4. #include <linux/delay.h>
  5.  
  6. #include <linux/freezer.h>
  7. #include <linux/wait.h>
  8. #include <linux/wakelock.h>
  9. #include <linux/earlysuspend.h>
  10. #include <linux/msm_mdp.h>
  11. #include <linux/io.h>
  12. #include <linux/uaccess.h>
  13. #include <mach/msm_fb.h>
  14. #include <mach/board.h>
  15. #include <linux/workqueue.h>
  16. #include <linux/clk.h>
  17. #include <linux/debugfs.h>
  18. #include <linux/dma-mapping.h>
  19. #include <linux/android_pmem.h>
  20.  
  21. extern void start_drawing_late_resume(struct early_suspend *h);
  22. static void msmfb_resume_handler(struct early_suspend *h);
  23. static void msmfb_resume(struct work_struct *work);
  24.  
  25. #define MSMFB_DEBUG 1
  26. #ifdef CONFIG_FB_MSM_LOGO
  27. #define INIT_IMAGE_FILE "/logo.rle"
  28. extern int load_565rle_image(char *filename);
  29. #endif
  30.  
  31. #define PRINT_FPS 0
  32. #define PRINT_BLIT_TIME 0
  33.  
  34. #define SLEEPING 0x4
  35. #define UPDATING 0x3
  36. #define FULL_UPDATE_DONE 0x2
  37. #define WAKING 0x1
  38. #define AWAKE 0x0
  39.  
  40. #define NONE 0
  41. #define SUSPEND_RESUME 0x1
  42. #define FPS 0x2
  43. #define BLIT_TIME 0x4
  44. #define SHOW_UPDATES 0x8
  45.  
  46. #define DLOG(mask, fmt, args...) \
  47. do { \
  48.         if ((msmfb_debug_mask | SUSPEND_RESUME) & mask) \
  49.                 printk(KERN_INFO "msmfb: "fmt, ##args); \
  50. } while (0)
  51.  
  52. #define BITS_PER_PIXEL(info) (info->fb->var.bits_per_pixel)
  53. #define BYTES_PER_PIXEL(info) (info->fb->var.bits_per_pixel >> 3)
  54. static int msmfb_debug_mask;
  55. module_param_named(msmfb_debug_mask, msmfb_debug_mask, int,
  56.                    S_IRUGO | S_IWUSR | S_IWGRP);
  57.  
  58. struct mdp_device *mdp;
  59.  
  60. struct msmfb_info {
  61.         struct fb_info *fb;
  62.         struct msm_panel_data *panel;
  63.         int xres;
  64.         int yres;
  65.         unsigned output_format;
  66.         unsigned yoffset;
  67.         unsigned frame_requested;
  68.         unsigned frame_done;
  69.         int sleeping;
  70.         unsigned update_frame;
  71.         struct {
  72.                 int left;
  73.                 int top;
  74.                 int eright; /* exclusive */
  75.                 int ebottom; /* exclusive */
  76.         } update_info;
  77.         char *black;
  78.  
  79.         struct early_suspend earlier_suspend;
  80.         struct early_suspend early_suspend;
  81.         struct wake_lock idle_lock;
  82.         spinlock_t update_lock;
  83.         struct mutex panel_init_lock;
  84.         wait_queue_head_t frame_wq;
  85.         struct workqueue_struct *resume_workqueue;
  86.         struct work_struct resume_work;
  87.         struct work_struct msmfb_resume_work;
  88.         struct msmfb_callback dma_callback;
  89.         struct msmfb_callback vsync_callback;
  90.         struct hrtimer fake_vsync;
  91.         ktime_t vsync_request_time;
  92.         unsigned fb_resumed;
  93. };
  94.  
  95. #ifdef CONFIG_FB_MSM_OVERLAY
  96. #define USE_OVERLAY     1
  97. struct overlay_waitevent{
  98.         uint32_t waked_up;
  99.         wait_queue_head_t event_wait;
  100. };
  101. static struct overlay_waitevent overlay_event;
  102. DEFINE_MUTEX(overlay_event_lock);
  103. #endif
  104.  
  105. #if (defined(CONFIG_USB_FUNCTION_PROJECTOR) || defined(CONFIG_USB_ANDROID_PROJECTOR))
  106. static spinlock_t fb_data_lock = SPIN_LOCK_UNLOCKED;
  107. static struct msm_fb_info msm_fb_data;
  108. int msmfb_get_var(struct msm_fb_info *tmp)
  109. {
  110.         unsigned long flags;
  111.         spin_lock_irqsave(&fb_data_lock, flags);
  112.         memcpy(tmp, &msm_fb_data, sizeof(msm_fb_data));
  113.         spin_unlock_irqrestore(&fb_data_lock, flags);
  114.         return 0;
  115. }
  116.  
  117. /* projector need this, and very much */
  118. int msmfb_get_fb_area(void)
  119. {
  120.         int area;
  121.         unsigned long flags;
  122.         spin_lock_irqsave(&fb_data_lock, flags);
  123.         area = msm_fb_data.msmfb_area;
  124.         spin_unlock_irqrestore(&fb_data_lock, flags);
  125.         return area;
  126. }
  127.  
  128. static void msmfb_set_var(unsigned char *addr, int area)
  129. {
  130.         unsigned long flags;
  131.  
  132.         spin_lock_irqsave(&fb_data_lock, flags);
  133.         msm_fb_data.fb_addr = addr;
  134.         msm_fb_data.msmfb_area = area;
  135.         spin_unlock_irqrestore(&fb_data_lock, flags);
  136.  
  137. }
  138. #endif
  139.  
  140. static int msmfb_open(struct fb_info *info, int user)
  141. {
  142. printk(KERN_INFO "msmfb: 1");
  143.         return 0;
  144. }
  145.  
  146. static int msmfb_release(struct fb_info *info, int user)
  147. {
  148. printk(KERN_INFO "msmfb: 2");
  149.  
  150.         return 0;
  151. }
  152.  
  153. /* Called from dma interrupt handler, must not sleep */
  154. static void msmfb_handle_dma_interrupt(struct msmfb_callback *callback)
  155. {
  156.         unsigned long irq_flags;
  157.         struct msmfb_info *msmfb  = container_of(callback, struct msmfb_info,
  158.                                                dma_callback);
  159. #if PRINT_FPS
  160.         int64_t dt;
  161.         ktime_t now;
  162.         static int64_t frame_count;
  163.         static ktime_t last_sec;
  164. #endif
  165.  
  166.         spin_lock_irqsave(&msmfb->update_lock, irq_flags);
  167.         msmfb->frame_done = msmfb->frame_requested;
  168.         if (msmfb->sleeping == UPDATING &&
  169.             msmfb->frame_done == msmfb->update_frame) {
  170.                 DLOG(SUSPEND_RESUME, "full update completed\n");
  171.         printk(KERN_INFO "msmfb: 3");
  172.                 queue_work(msmfb->resume_workqueue, &msmfb->resume_work);
  173.         }
  174. #if PRINT_FPS
  175.         now = ktime_get();
  176.         dt = ktime_to_ns(ktime_sub(now, last_sec));
  177.         frame_count++;
  178.         if (dt > NSEC_PER_SEC) {
  179.                 int64_t fps = frame_count * NSEC_PER_SEC * 100;
  180.                 frame_count = 0;
  181.                 last_sec = ktime_get();
  182.                 do_div(fps, dt);
  183.                 DLOG(FPS, "fps * 100: %llu\n", fps);
  184.         }
  185. #endif
  186.         spin_unlock_irqrestore(&msmfb->update_lock, irq_flags);
  187.         wake_up(&msmfb->frame_wq);
  188. printk(KERN_INFO "msmfb: 4");
  189. }
  190.  
  191. static int msmfb_start_dma(struct msmfb_info *msmfb)
  192. {
  193.         uint32_t x, y, w, h;
  194.         unsigned addr;
  195.         unsigned long irq_flags;
  196.         uint32_t yoffset;
  197.         s64 time_since_request;
  198.         struct msm_panel_data *panel = msmfb->panel;
  199.  
  200.         spin_lock_irqsave(&msmfb->update_lock, irq_flags);
  201.         time_since_request = ktime_to_ns(ktime_sub(ktime_get(),
  202.                              msmfb->vsync_request_time));
  203.         if (time_since_request > 20 * NSEC_PER_MSEC) {
  204.                 uint32_t us;
  205.                 us = do_div(time_since_request, NSEC_PER_MSEC) / NSEC_PER_USEC;
  206.                 printk(KERN_WARNING "msmfb_start_dma %lld.%03u ms after vsync "
  207.                         "request\n", time_since_request, us);
  208. printk(KERN_INFO "msmfb: 5");
  209.         }
  210.         if (msmfb->frame_done == msmfb->frame_requested) {
  211.                 spin_unlock_irqrestore(&msmfb->update_lock, irq_flags);
  212. printk(KERN_INFO "msmfb: 6");
  213.                 return -1;
  214.         }
  215.         if (msmfb->sleeping == SLEEPING) {
  216.                 DLOG(SUSPEND_RESUME, "tried to start dma while asleep\n");
  217. printk(KERN_INFO "msmfb: 7");
  218.                 spin_unlock_irqrestore(&msmfb->update_lock, irq_flags);
  219.                 return -1;
  220.         }
  221.         x = msmfb->update_info.left;
  222.         y = msmfb->update_info.top;
  223.         w = msmfb->update_info.eright - x;
  224.         h = msmfb->update_info.ebottom - y;
  225.        
  226. #if defined(CONFIG_MACH_HTCLEO)
  227.         // For some reason we need to force a full-screen update to prevent
  228.         // the screen from mixing up (top +-100px missing, garbled data
  229.         // at the bottom +-100px). Maybe it has to do with the vsync we
  230.         // had to disable in mdp_lcdc?
  231.         x = 0; y = 0; w = msmfb->xres; h = msmfb->yres;
  232. printk(KERN_INFO "msmfb: 8");
  233. #endif
  234.  
  235.         yoffset = msmfb->yoffset;
  236.         msmfb->update_info.left = msmfb->xres + 1;
  237.         msmfb->update_info.top = msmfb->yres + 1;
  238.         msmfb->update_info.eright = 0;
  239.         msmfb->update_info.ebottom = 0;
  240.         if (unlikely(w > msmfb->xres || h > msmfb->yres ||
  241.                      w == 0 || h == 0)) {
  242.                 printk(KERN_INFO "invalid update: %d %d %d "
  243.                                 "%d\n", x, y, w, h);
  244.                 msmfb->frame_done = msmfb->frame_requested;
  245. printk(KERN_INFO "msmfb: 9");
  246.                 goto error;
  247.         }
  248.         spin_unlock_irqrestore(&msmfb->update_lock, irq_flags);
  249.  
  250.         addr = ((msmfb->xres * (yoffset + y) + x) * BYTES_PER_PIXEL(msmfb));
  251.         mdp->dma(mdp, addr + msmfb->fb->fix.smem_start,
  252.                  msmfb->xres * BYTES_PER_PIXEL(msmfb), w, h, x, y,
  253.                  &msmfb->dma_callback,
  254.                  panel->interface_type);
  255. printk(KERN_INFO "msmfb: 10");
  256.         return 0;
  257. error:
  258.         spin_unlock_irqrestore(&msmfb->update_lock, irq_flags);
  259.         /* some clients need to clear their vsync interrupt */
  260.         if (panel->clear_vsync)
  261.                 panel->clear_vsync(panel);
  262.         wake_up(&msmfb->frame_wq);
  263. printk(KERN_INFO "msmfb: 11");
  264.         return 0;
  265. }
  266.  
  267. /* Called from esync interrupt handler, must not sleep */
  268. static void msmfb_handle_vsync_interrupt(struct msmfb_callback *callback)
  269. {
  270.         struct msmfb_info *msmfb = container_of(callback, struct msmfb_info,
  271.                                                vsync_callback);
  272.         wake_unlock(&msmfb->idle_lock);
  273.         msmfb_start_dma(msmfb);
  274. printk(KERN_INFO "msmfb: 12");
  275. }
  276.  
  277. static enum hrtimer_restart msmfb_fake_vsync(struct hrtimer *timer)
  278. {
  279.         struct msmfb_info *msmfb  = container_of(timer, struct msmfb_info,
  280.                                                fake_vsync);
  281.         msmfb_start_dma(msmfb);
  282. printk(KERN_INFO "msmfb: 13");
  283.         return HRTIMER_NORESTART;
  284. }
  285.  
  286. static void msmfb_pan_update(struct fb_info *info, uint32_t left, uint32_t top,
  287.                              uint32_t eright, uint32_t ebottom,
  288.                              uint32_t yoffset, int pan_display)
  289. {
  290.         struct msmfb_info *msmfb = info->par;
  291.         struct msm_panel_data *panel = msmfb->panel;
  292.         unsigned long irq_flags;
  293.         int sleeping;
  294.         int retry = 1;
  295. #if PRINT_FPS
  296.         ktime_t t1, t2;
  297.         static uint64_t pans;
  298.         static uint64_t dt;
  299.         t1 = ktime_get();
  300. #endif
  301.  
  302.         DLOG(SHOW_UPDATES, "update %d %d %d %d %d %d\n",
  303.                 left, top, eright, ebottom, yoffset, pan_display);
  304. printk(KERN_INFO "msmfb: 14");
  305. #if !defined(CONFIG_MACH_HTCLEO)
  306.         // For some reason we need to remove it here, state is 1, we have to look later to this problem
  307.         if (msmfb->sleeping != AWAKE)
  308.                 DLOG(SUSPEND_RESUME, "pan_update in state(%d)\n", msmfb->sleeping);
  309. printk(KERN_INFO "msmfb: 15");
  310. #endif
  311.  
  312. #if (defined(CONFIG_USB_FUNCTION_PROJECTOR) || defined(CONFIG_USB_ANDROID_PROJECTOR))
  313.         /* Jay, 8/1/09' */
  314.         msmfb_set_var(msmfb->fb->screen_base, yoffset);
  315. #endif
  316.  
  317. restart:
  318.         spin_lock_irqsave(&msmfb->update_lock, irq_flags);
  319.  
  320.         /* if we are sleeping, on a pan_display wait 10ms (to throttle back
  321.          * drawing otherwise return */
  322.         if (msmfb->sleeping == SLEEPING) {
  323.                 DLOG(SUSPEND_RESUME, "drawing while asleep\n");
  324. printk(KERN_INFO "msmfb: 16");
  325.                 spin_unlock_irqrestore(&msmfb->update_lock, irq_flags);
  326.                 if (pan_display)
  327.                         wait_event_interruptible_timeout(msmfb->frame_wq,
  328.                                 msmfb->sleeping != SLEEPING, HZ/10);
  329.                 return;
  330.         }
  331.  
  332.         sleeping = msmfb->sleeping;
  333.         /* on a full update, if the last frame has not completed, wait for it */
  334.         if (pan_display && (msmfb->frame_requested != msmfb->frame_done ||
  335.                             sleeping == UPDATING)) {
  336.                 int ret;
  337.                 spin_unlock_irqrestore(&msmfb->update_lock, irq_flags);
  338.                 ret = wait_event_interruptible_timeout(msmfb->frame_wq,
  339.                         msmfb->frame_done == msmfb->frame_requested &&
  340.                         msmfb->sleeping != UPDATING, 5 * HZ);
  341.                 if (ret <= 0 && (msmfb->frame_requested != msmfb->frame_done ||
  342.                                  msmfb->sleeping == UPDATING)) {
  343. printk(KERN_INFO "msmfb: 17");
  344.                         if (retry && panel->request_vsync &&
  345.                             (sleeping == AWAKE)) {
  346.                                 wake_lock_timeout(&msmfb->idle_lock, HZ/4);
  347.                                 panel->request_vsync(panel,
  348.                                         &msmfb->vsync_callback);
  349.                                 retry = 0;
  350.                                 printk(KERN_WARNING "msmfb_pan_display timeout "
  351.                                         "rerequest vsync\n");
  352. printk(KERN_INFO "msmfb: 18");
  353.                         } else {
  354.                                 printk(KERN_WARNING "msmfb_pan_display timeout "
  355.                                         "waiting for frame start, %d %d\n",
  356.                                         msmfb->frame_requested,
  357.                                         msmfb->frame_done);
  358. printk(KERN_INFO "msmfb: 19");
  359.                                 return;
  360.                         }
  361.                 }
  362.                 goto restart;
  363.         }
  364.  
  365. #if PRINT_FPS
  366.         t2 = ktime_get();
  367.         if (pan_display) {
  368.                 uint64_t temp = ktime_to_ns(ktime_sub(t2, t1));
  369.                 do_div(temp, 1000);
  370.                 dt += temp;
  371.                 pans++;
  372.                 if (pans > 1000) {
  373.                         do_div(dt, pans);
  374.                         DLOG(FPS, "ave_wait_time: %lld\n", dt);
  375.                         dt = 0;
  376.                         pans = 0;
  377.                 }
  378.         }
  379. #endif
  380.  
  381.         msmfb->frame_requested++;
  382.         /* if necessary, update the y offset, if this is the
  383.          * first full update on resume, set the sleeping state */
  384.         if (pan_display) {
  385.                 msmfb->yoffset = yoffset;
  386.                 if (left == 0 && top == 0 && eright == info->var.xres &&
  387.                     ebottom == info->var.yres) {
  388.                         if (sleeping == WAKING) {
  389.                                 msmfb->update_frame = msmfb->frame_requested;
  390.                                 DLOG(SUSPEND_RESUME, "full update starting\n");
  391. printk(KERN_INFO "msmfb: 20");
  392.                                 msmfb->sleeping = UPDATING;
  393.                         }
  394.                 }
  395.         }
  396.  
  397.         /* set the update request */
  398.         if (left < msmfb->update_info.left)
  399.                 msmfb->update_info.left = left;
  400.         if (top < msmfb->update_info.top)
  401.                 msmfb->update_info.top = top;
  402.         if (eright > msmfb->update_info.eright)
  403.                 msmfb->update_info.eright = eright;
  404.         if (ebottom > msmfb->update_info.ebottom)
  405.                 msmfb->update_info.ebottom = ebottom;
  406.         DLOG(SHOW_UPDATES, "update queued %d %d %d %d %d\n",
  407.                 msmfb->update_info.left, msmfb->update_info.top,
  408.                 msmfb->update_info.eright, msmfb->update_info.ebottom,
  409.                 msmfb->yoffset);
  410.         spin_unlock_irqrestore(&msmfb->update_lock, irq_flags);
  411.  
  412.         /* if the panel is all the way on wait for vsync, otherwise sleep
  413.          * for 16 ms (long enough for the dma to panel) and then begin dma */
  414.         msmfb->vsync_request_time = ktime_get();
  415.         if (panel->request_vsync && (sleeping == AWAKE)) {
  416.                 wake_lock_timeout(&msmfb->idle_lock, HZ/4);
  417.                 panel->request_vsync(panel, &msmfb->vsync_callback);
  418. printk(KERN_INFO "msmfb: 21");
  419.         } else {
  420.                 if (!hrtimer_active(&msmfb->fake_vsync)) {
  421.                         hrtimer_start(&msmfb->fake_vsync,
  422.                                       ktime_set(0, NSEC_PER_SEC/60),
  423.                                       HRTIMER_MODE_REL);
  424. printk(KERN_INFO "msmfb: 22");
  425.                 }
  426.         }
  427. }
  428.  
  429. static void msmfb_update(struct fb_info *info, uint32_t left, uint32_t top,
  430.                          uint32_t eright, uint32_t ebottom)
  431. {
  432.         msmfb_pan_update(info, left, top, eright, ebottom, 0, 0);
  433. printk(KERN_INFO "msmfb: 23");
  434. }
  435.  
  436. static void power_on_panel(struct work_struct *work)
  437. {
  438.         struct msmfb_info *msmfb =
  439.                 container_of(work, struct msmfb_info, resume_work);
  440.         struct msm_panel_data *panel = msmfb->panel;
  441.         unsigned long irq_flags;
  442.         mutex_lock(&msmfb->panel_init_lock);
  443.         DLOG(SUSPEND_RESUME, "turning on panel\n");
  444. printk(KERN_INFO "msmfb: 24");
  445.  
  446.         if (msmfb->sleeping == UPDATING) {
  447.                 wake_lock_timeout(&msmfb->idle_lock, HZ);
  448.                 if (panel->unblank(panel)) {
  449.                         printk(KERN_INFO "msmfb: panel unblank failed,"
  450.                                "not starting drawing\n");
  451. printk(KERN_INFO "msmfb: 25");
  452.                         goto error;
  453.                 }
  454.                 wake_unlock(&msmfb->idle_lock);
  455.                 spin_lock_irqsave(&msmfb->update_lock, irq_flags);
  456.                 msmfb->sleeping = AWAKE;
  457.                 wake_up(&msmfb->frame_wq);
  458.                 spin_unlock_irqrestore(&msmfb->update_lock, irq_flags);
  459. printk(KERN_INFO "msmfb: 26");
  460.         }
  461. error:
  462.         mutex_unlock(&msmfb->panel_init_lock);
  463. printk(KERN_INFO "msmfb: 27");
  464. }
  465.  
  466. static BLOCKING_NOTIFIER_HEAD(display_chain_head);                              
  467. int register_display_notifier(struct notifier_block *nb)                  
  468. {                                                                                
  469.         return blocking_notifier_chain_register(&display_chain_head, nb);        
  470. }                                                                                
  471. static int display_notifier_callback(struct notifier_block *nfb,                
  472.                 unsigned long action,                      
  473.                 void *ignored)                              
  474. {                                                                                
  475.         struct msmfb_info *msm_fb = (struct msmfb_info *)ignored;
  476.        
  477.         switch (action) {
  478.         case NOTIFY_MSM_FB:
  479.                 printk(KERN_DEBUG "NOTIFY_MSM_FB\n");
  480.                 //msmfb_resume(&msm_fb->early_suspend);
  481. printk(KERN_INFO "msmfb: 28");
  482.                 break;
  483.         case NOTIFY_POWER:
  484.                 /* nothing to do */
  485. printk(KERN_INFO "msmfb: 29");
  486.                 break;
  487.         default:
  488.                 printk(KERN_ERR "%s: unknown action in 0x%lx\n",
  489.                                 __func__, action);
  490.                 return NOTIFY_BAD;
  491.         }
  492.         return NOTIFY_OK;
  493. }                                                                                
  494.  
  495. /* -------------------------------------------------------------------------- */
  496. #ifdef CONFIG_HAS_EARLYSUSPEND
  497. /* turn off the panel */
  498. static void msmfb_earlier_suspend(struct early_suspend *h)
  499. {
  500.         struct msmfb_info *msmfb = container_of(h, struct msmfb_info,
  501.                                                 earlier_suspend);
  502.         struct msm_panel_data *panel = msmfb->panel;
  503.         unsigned long irq_flags;
  504.  
  505.         mutex_lock(&msmfb->panel_init_lock);
  506.         msmfb->sleeping = SLEEPING;
  507.         wake_up(&msmfb->frame_wq);
  508.         spin_lock_irqsave(&msmfb->update_lock, irq_flags);
  509.         spin_unlock_irqrestore(&msmfb->update_lock, irq_flags);
  510.         wait_event_timeout(msmfb->frame_wq,
  511.                            msmfb->frame_requested == msmfb->frame_done, HZ/10);
  512. printk(KERN_INFO "msmfb: 30");
  513.  
  514. #ifndef CONFIG_MSM_MDP40
  515.         mdp->dma(mdp, virt_to_phys(msmfb->black), 0,
  516.                  msmfb->fb->var.xres, msmfb->fb->var.yres, 0, 0,
  517.                  NULL, panel->interface_type);
  518.         mdp->dma_wait(mdp, panel->interface_type);
  519. #endif
  520.         /* turn off the panel */
  521.         panel->blank(panel);
  522. printk(KERN_INFO "msmfb: 31");
  523. }
  524.  
  525. static void msmfb_suspend(struct early_suspend *h)
  526. {
  527.         struct msmfb_info *msmfb = container_of(h, struct msmfb_info,
  528.                                                 early_suspend);
  529.         struct msm_panel_data *panel = msmfb->panel;
  530.         /* suspend the panel */
  531. #ifdef CONFIG_FB_MSM_OVERLAY
  532.         /*check whether overlay done*/
  533.         wait_event_interruptible_timeout(
  534.                 overlay_event.event_wait,
  535.                 (overlay_event.waked_up == ~USE_OVERLAY),
  536.                 10*HZ);
  537.         pr_info("wait event : %X\n", overlay_event.waked_up);
  538. printk(KERN_INFO "msmfb: 31");
  539. #endif
  540.         panel->suspend(panel);
  541.         msmfb->fb_resumed = 0;
  542.         mutex_unlock(&msmfb->panel_init_lock);
  543. }
  544.  
  545. static void msmfb_resume_handler(struct early_suspend *h)
  546. {
  547.         struct msmfb_info *msmfb = container_of(h, struct msmfb_info,
  548.                                         early_suspend);
  549.         queue_work(msmfb->resume_workqueue, &msmfb->msmfb_resume_work);
  550.         wait_event_interruptible_timeout(msmfb->frame_wq, msmfb->fb_resumed==1,HZ/2);
  551. printk(KERN_INFO "msmfb: 32");
  552. }
  553.  
  554. static void msmfb_resume(struct work_struct *work)
  555. {
  556.         struct msmfb_info *msmfb =
  557.                 container_of(work, struct msmfb_info, msmfb_resume_work);
  558.         struct msm_panel_data *panel = msmfb->panel;
  559.         unsigned long irq_flags;
  560.  
  561.         if (panel->resume(panel)) {
  562.                 printk(KERN_INFO "msmfb: panel resume failed, not resuming "
  563.                        "fb\n");
  564. printk(KERN_INFO "msmfb: 33");
  565.                 return;
  566.         }
  567.         spin_lock_irqsave(&msmfb->update_lock, irq_flags);
  568.         msmfb->frame_requested = msmfb->frame_done = msmfb->update_frame = 0;
  569.         msmfb->sleeping = WAKING;
  570.         DLOG(SUSPEND_RESUME, "ready, waiting for full update\n");
  571. printk(KERN_INFO "msmfb: 34");
  572.         spin_unlock_irqrestore(&msmfb->update_lock, irq_flags);
  573.         start_drawing_late_resume(NULL);
  574.         msmfb->fb_resumed = 1;
  575.         wake_up(&msmfb->frame_wq);
  576. printk(KERN_INFO "msmfb: 35");
  577. }
  578. #endif
  579.  
  580. static int msmfb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
  581. {
  582.         u32 size;
  583.  
  584.         if ((var->xres != info->var.xres) ||
  585.             (var->yres != info->var.yres) ||
  586.             (var->xoffset != info->var.xoffset) ||
  587.             (mdp->check_output_format(mdp, var->bits_per_pixel)) ||
  588.             (var->grayscale != info->var.grayscale))
  589.                  return -EINVAL;
  590.  
  591.         size = var->xres_virtual * var->yres_virtual *
  592.                 (var->bits_per_pixel >> 3);
  593.         if (size > info->fix.smem_len)
  594.                 return -EINVAL;
  595.         return 0;
  596. }
  597.  
  598. static int msmfb_set_par(struct fb_info *info)
  599. {
  600.         struct fb_var_screeninfo *var = &info->var;
  601.         struct fb_fix_screeninfo *fix = &info->fix;
  602.  
  603.         /* we only support RGB ordering for now */
  604.         if (var->bits_per_pixel == 32 || var->bits_per_pixel == 24) {
  605.                 var->red.offset = 0;
  606.                 var->red.length = 8;
  607.                 var->green.offset = 8;
  608.                 var->green.length = 8;
  609.                 var->blue.offset = 16;
  610.                 var->blue.length = 8;
  611.         } else if (var->bits_per_pixel == 16) {
  612.                 var->red.offset = 11;
  613.                 var->red.length = 5;
  614.                 var->green.offset = 5;
  615.                 var->green.length = 6;
  616.                 var->blue.offset = 0;
  617.                 var->blue.length = 5;
  618.         } else
  619.                 return -1;
  620.         mdp->set_output_format(mdp, var->bits_per_pixel);
  621.         fix->line_length = var->xres * var->bits_per_pixel / 8;
  622.         return 0;
  623. }
  624.  
  625. int msmfb_pan_display(struct fb_var_screeninfo *var, struct fb_info *info)
  626. {
  627.         struct msmfb_info *msmfb = info->par;
  628.         struct msm_panel_data *panel = msmfb->panel;
  629.  
  630.         /* "UPDATE" */
  631.         if ((panel->caps & MSMFB_CAP_PARTIAL_UPDATES) &&
  632.             (var->reserved[0] == 0x54445055)) {
  633. #if 0
  634.                 printk(KERN_INFO "pan frame %d-%d, rect %d %d %d %d\n",
  635.                        msmfb->frame_requested, msmfb->frame_done,
  636.                        var->reserved[1] & 0xffff,
  637.                        var->reserved[1] >> 16, var->reserved[2] & 0xffff,
  638.                        var->reserved[2] >> 16);
  639. printk(KERN_INFO "msmfb: 36");
  640. #endif
  641.                 msmfb_pan_update(info, var->reserved[1] & 0xffff,
  642.                                  var->reserved[1] >> 16,
  643.                                  var->reserved[2] & 0xffff,
  644.                                  var->reserved[2] >> 16, var->yoffset, 1);
  645.         } else {
  646.                 msmfb_pan_update(info, 0, 0, info->var.xres, info->var.yres,
  647.                                  var->yoffset, 1);
  648.         }
  649.         return 0;
  650. }
  651.  
  652. static void msmfb_fillrect(struct fb_info *p, const struct fb_fillrect *rect)
  653. {
  654.         cfb_fillrect(p, rect);
  655. #if !defined(CONFIG_MACH_HTCLEO)       
  656.         msmfb_update(p, rect->dx, rect->dy, rect->dx + rect->width,
  657.                      rect->dy + rect->height);
  658. #endif
  659. }
  660.  
  661. static void msmfb_copyarea(struct fb_info *p, const struct fb_copyarea *area)
  662. {
  663.         cfb_copyarea(p, area);
  664. #if !defined(CONFIG_MACH_HTCLEO)       
  665.         msmfb_update(p, area->dx, area->dy, area->dx + area->width,
  666.                      area->dy + area->height);
  667. printk(KERN_INFO "msmfb: 37");
  668. #endif
  669. }
  670.  
  671. static void msmfb_imageblit(struct fb_info *p, const struct fb_image *image)
  672. {
  673.         cfb_imageblit(p, image);
  674. #if !defined(CONFIG_MACH_HTCLEO)       
  675.         msmfb_update(p, image->dx, image->dy, image->dx + image->width,
  676.                      image->dy + image->height);
  677. printk(KERN_INFO "msmfb: 38");
  678. #endif
  679. }
  680.  
  681.  
  682. static int msmfb_blit(struct fb_info *info,
  683.                       void __user *p)
  684. {
  685.         struct mdp_blit_req req;
  686.         struct mdp_blit_req_list req_list;
  687.         int i;
  688.         int ret;
  689.  
  690.         if (copy_from_user(&req_list, p, sizeof(req_list)))
  691.                 return -EFAULT;
  692.  
  693.         for (i = 0; i < req_list.count; i++) {
  694.                 struct mdp_blit_req_list *list =
  695.                         (struct mdp_blit_req_list *)p;
  696.                 if (copy_from_user(&req, &list->req[i], sizeof(req)))
  697.                         return -EFAULT;
  698.                 ret = mdp->blit(mdp, info, &req);
  699.                 if (ret)
  700.                         return ret;
  701.         }
  702.         return 0;
  703. }
  704. #ifdef CONFIG_FB_MSM_OVERLAY
  705. static int msmfb_overlay_get(struct fb_info *info, void __user *p)
  706. {
  707.         struct mdp_overlay req;
  708.         int ret;
  709.  
  710.         if (copy_from_user(&req, p, sizeof(req)))
  711.                 return -EFAULT;
  712.  
  713.         ret = mdp->overlay_get(mdp, info, &req);
  714.  
  715.         if (ret) {
  716.                 printk(KERN_ERR "%s: ioctl failed \n",
  717.                         __func__);
  718.                 return ret;
  719.         }
  720.         if (copy_to_user(p, &req, sizeof(req))) {
  721.                 printk(KERN_ERR "%s: copy2user failed \n",
  722.                         __func__);
  723.                 return -EFAULT;
  724.         }
  725.  
  726.         return 0;
  727. }
  728.  
  729. static int msmfb_overlay_set(struct fb_info *info, void __user *p)
  730. {
  731.         struct mdp_overlay req;
  732.         int ret;
  733.  
  734.         if (copy_from_user(&req, p, sizeof(req)))
  735.                 return -EFAULT;
  736.  
  737.         ret = mdp->overlay_set(mdp, info, &req);
  738.         if (ret) {
  739.                 printk(KERN_ERR "%s:ioctl failed \n",
  740.                         __func__);
  741.                 return ret;
  742.         }
  743.  
  744.         if (copy_to_user(p, &req, sizeof(req))) {
  745.                 printk(KERN_ERR "%s: copy2user failed \n",
  746.                         __func__);
  747.                 return -EFAULT;
  748.         }
  749.  
  750.         return 0;
  751. }
  752.  
  753. static int msmfb_overlay_unset(struct fb_info *info, unsigned long *argp)
  754. {
  755.         int     ret, ndx;
  756.  
  757.         ret = copy_from_user(&ndx, argp, sizeof(ndx));
  758.         if (ret) {
  759.                 printk(KERN_ERR "%s:msmfb_overlay_unset ioctl failed \n",
  760.                         __func__);
  761.                 return ret;
  762.         }
  763.  
  764.         return mdp->overlay_unset(mdp, info, ndx);
  765. }
  766.  
  767. static int msmfb_overlay_play(struct fb_info *info, unsigned long *argp)
  768. {
  769.         int     ret;
  770.         struct msmfb_overlay_data req;
  771.         struct file *p_src_file = 0;
  772.  
  773.         ret = copy_from_user(&req, argp, sizeof(req));
  774.         if (ret) {
  775.                 printk(KERN_ERR "%s:msmfb_overlay_play ioctl failed \n",
  776.                         __func__);
  777.                 return ret;
  778.         }
  779.  
  780.         ret = mdp->overlay_play(mdp, info, &req, &p_src_file);
  781.  
  782.         if (p_src_file)
  783.                 put_pmem_file(p_src_file);
  784.  
  785.         return ret;
  786. }
  787.  
  788. #endif
  789.  
  790.  
  791. DEFINE_MUTEX(mdp_ppp_lock);
  792.  
  793. static int msmfb_ioctl(struct fb_info *p, unsigned int cmd, unsigned long arg)
  794. {
  795.         void __user *argp = (void __user *)arg;
  796.         int ret;
  797. #if PRINT_BLIT_TIME
  798.         ktime_t t1, t2;
  799. #endif
  800.  
  801.         switch (cmd) {
  802.         case MSMFB_GRP_DISP:
  803.                 mdp->set_grp_disp(mdp, arg);
  804.                 break;
  805.         case MSMFB_BLIT:
  806. #if PRINT_BLIT_TIME
  807.                 t1 = ktime_get();
  808. #endif
  809.                 ret = msmfb_blit(p, argp);
  810.                 if (ret)
  811.                         return ret;
  812. #if PRINT_BLIT_TIME
  813.                 t2 = ktime_get();
  814.                 DLOG(BLIT_TIME, "total %lld\n",
  815.                        ktime_to_ns(t2) - ktime_to_ns(t1));
  816. #endif
  817.                 break;
  818. #ifdef CONFIG_FB_MSM_OVERLAY
  819.         case MSMFB_OVERLAY_GET:
  820.                 printk("CONFIG_FB_MSM_OVERLAY\n");
  821.                 //down(&mdp_ppp_lock);
  822.                 ret = msmfb_overlay_get(p, argp);
  823.                 //up(&mdp_ppp_lock);
  824.                 break;
  825.         case MSMFB_OVERLAY_SET:
  826.                 printk("MSMFB_OVERLAY_SET\n");
  827.                 //down(&mdp_ppp_lock);
  828.                 ret = msmfb_overlay_set(p, argp);
  829.                 mutex_lock(&overlay_event_lock);
  830.                 overlay_event.waked_up = USE_OVERLAY;
  831.                 mutex_unlock(&overlay_event_lock);
  832.                 //up(&mdp_ppp_lock);
  833.                 break;
  834.         case MSMFB_OVERLAY_UNSET:
  835.                 printk("MSMFB_OVERLAY_UNSET\n");
  836.                 //down(&mdp_ppp_lock);
  837.                 ret = msmfb_overlay_unset(p, argp);
  838.                 mutex_lock(&overlay_event_lock);
  839.                 overlay_event.waked_up = ~USE_OVERLAY;
  840.                 wake_up(&overlay_event.event_wait);
  841.                 mutex_unlock(&overlay_event_lock);
  842.                 //up(&mdp_ppp_lock);
  843.                 break;
  844.         case MSMFB_OVERLAY_PLAY:
  845.                 //down(&mdp_ppp_lock);
  846.                 ret = msmfb_overlay_play(p, argp);
  847.                 //up(&mdp_ppp_lock);
  848.                 break;
  849. #endif
  850.         default:
  851.                         printk(KERN_INFO "msmfb unknown ioctl: %d\n", cmd);
  852.                         return -EINVAL;
  853.         }
  854.         return 0;
  855. }
  856.  
  857. static struct fb_ops msmfb_ops = {
  858.         .owner = THIS_MODULE,
  859.         .fb_open = msmfb_open,
  860.         .fb_release = msmfb_release,
  861.         .fb_check_var = msmfb_check_var,
  862.         .fb_set_par = msmfb_set_par,
  863.         .fb_pan_display = msmfb_pan_display,
  864.         .fb_fillrect = msmfb_fillrect,
  865.         .fb_copyarea = msmfb_copyarea,
  866.         .fb_imageblit = msmfb_imageblit,
  867.         .fb_ioctl = msmfb_ioctl,
  868. };
  869.  
  870. static unsigned PP[16];
  871.  
  872.  
  873. #if MSMFB_DEBUG
  874. static ssize_t debug_open(struct inode *inode, struct file *file)
  875. {
  876.         file->private_data = inode->i_private;
  877.         return 0;
  878. }
  879.  
  880.  
  881. static ssize_t debug_read(struct file *file, char __user *buf, size_t count,
  882.                           loff_t *ppos)
  883. {
  884.         const int debug_bufmax = 4096;
  885.         static char buffer[4096];
  886.         int n = 0;
  887.         struct msmfb_info *msmfb = (struct msmfb_info *)file->private_data;
  888.         unsigned long irq_flags;
  889.  
  890.         spin_lock_irqsave(&msmfb->update_lock, irq_flags);
  891.         n = scnprintf(buffer, debug_bufmax, "yoffset %d\n", msmfb->yoffset);
  892.         n += scnprintf(buffer + n, debug_bufmax, "frame_requested %d\n",
  893.                        msmfb->frame_requested);
  894.         n += scnprintf(buffer + n, debug_bufmax, "frame_done %d\n",
  895.                        msmfb->frame_done);
  896.         n += scnprintf(buffer + n, debug_bufmax, "sleeping %d\n",
  897.                        msmfb->sleeping);
  898.         n += scnprintf(buffer + n, debug_bufmax, "update_frame %d\n",
  899.                        msmfb->update_frame);
  900.         spin_unlock_irqrestore(&msmfb->update_lock, irq_flags);
  901.         n++;
  902.         buffer[n] = 0;
  903.         return simple_read_from_buffer(buf, count, ppos, buffer, n);
  904. }
  905.  
  906. static struct file_operations debug_fops = {
  907.         .read = debug_read,
  908.         .open = debug_open,
  909. };
  910. #endif
  911.  
  912. #define BITS_PER_PIXEL 16
  913.  
  914. static void setup_fb_info(struct msmfb_info *msmfb)
  915. {
  916.         struct fb_info *fb_info = msmfb->fb;
  917.         int r;
  918.  
  919.         /* finish setting up the fb_info struct */
  920.         strncpy(fb_info->fix.id, "msmfb", 16);
  921.         fb_info->fix.ypanstep = 1;
  922.  
  923.         fb_info->fbops = &msmfb_ops;
  924.         fb_info->flags = FBINFO_DEFAULT;
  925.  
  926.         fb_info->fix.type = FB_TYPE_PACKED_PIXELS;
  927.         fb_info->fix.visual = FB_VISUAL_TRUECOLOR;
  928.         fb_info->fix.line_length = msmfb->xres * 2;
  929.  
  930.         fb_info->var.xres = msmfb->xres;
  931.         fb_info->var.yres = msmfb->yres;
  932.         fb_info->var.width = msmfb->panel->fb_data->width;
  933.         fb_info->var.height = msmfb->panel->fb_data->height;
  934.         fb_info->var.xres_virtual = msmfb->xres;
  935.         fb_info->var.yres_virtual = msmfb->yres * 2;
  936.         fb_info->var.bits_per_pixel = BITS_PER_PIXEL;
  937.         fb_info->var.accel_flags = 0;
  938.  
  939.         fb_info->var.yoffset = 0;
  940.  
  941.         if (msmfb->panel->caps & MSMFB_CAP_PARTIAL_UPDATES) {
  942.                 /* set the param in the fixed screen, so userspace can't
  943.                  * change it. This will be used to check for the
  944.                  * capability. */
  945.  
  946.                 /* FIX ME: every panel support partial update?
  947.                 fb_info->fix.reserved[0] = 0x5444;
  948.                 fb_info->fix.reserved[1] = 0x5055;
  949.                 */
  950.  
  951.                 /* This preloads the value so that if userspace doesn't
  952.                  * change it, it will be a full update */
  953.                 fb_info->var.reserved[0] = 0x54445055;
  954.                 fb_info->var.reserved[1] = 0;
  955.                 fb_info->var.reserved[2] = (uint16_t)msmfb->xres |
  956.                                            ((uint32_t)msmfb->yres << 16);
  957.         }
  958.  
  959.         fb_info->var.red.offset = 11;
  960.         fb_info->var.red.length = 5;
  961.         fb_info->var.red.msb_right = 0;
  962.         fb_info->var.green.offset = 5;
  963.         fb_info->var.green.length = 6;
  964.         fb_info->var.green.msb_right = 0;
  965.         fb_info->var.blue.offset = 0;
  966.         fb_info->var.blue.length = 5;
  967.         fb_info->var.blue.msb_right = 0;
  968.  
  969.         mdp->set_output_format(mdp, fb_info->var.bits_per_pixel);
  970.  
  971.         r = fb_alloc_cmap(&fb_info->cmap, 16, 0);
  972.         fb_info->pseudo_palette = PP;
  973.  
  974.         PP[0] = 0;
  975.         for (r = 1; r < 16; r++)
  976.                 PP[r] = 0xffffffff;
  977.  
  978.         /* Jay add, 7/1/09' */
  979. #if (defined(CONFIG_USB_FUNCTION_PROJECTOR) || defined(CONFIG_USB_ANDROID_PROJECTOR))
  980.         msm_fb_data.xres = msmfb->xres;
  981.         msm_fb_data.yres = msmfb->yres;
  982.         printk(KERN_INFO "setup_fb_info msmfb->xres %d, msmfb->yres %d\n",
  983.                                 msmfb->xres,msmfb->yres);
  984. #endif
  985. }
  986.  
  987. static int setup_fbmem(struct msmfb_info *msmfb, struct platform_device *pdev)
  988. {
  989.         struct fb_info *fb = msmfb->fb;
  990.         struct resource *resource;
  991.         unsigned long size = msmfb->xres * msmfb->yres *
  992.                 BYTES_PER_PIXEL(msmfb) * 2;
  993.         unsigned long resource_size;
  994.         unsigned char *fbram;
  995.  
  996.         /* board file might have attached a resource describing an fb */
  997.         resource = platform_get_resource(pdev, IORESOURCE_MEM, 0);
  998.         if (!resource)
  999.                 return -EINVAL;
  1000.         resource_size = resource->end - resource->start + 1;
  1001.  
  1002.         /* check the resource is large enough to fit the fb */
  1003.         if (resource_size < size) {
  1004.                 printk(KERN_ERR "msmfb: allocated resource is too small for "
  1005.                                 "fb\n");
  1006.                 return -ENOMEM;
  1007.         }
  1008.         fb->fix.smem_start = resource->start;
  1009.         fb->fix.smem_len = resource_size;
  1010.         fbram = ioremap(resource->start, resource_size);
  1011.         if (fbram == 0) {
  1012.                 printk(KERN_ERR "msmfb: cannot allocate fbram!\n");
  1013.                 return -ENOMEM;
  1014.         }
  1015.  
  1016.         fb->screen_base = fbram;
  1017.         return 0;
  1018. }
  1019.  
  1020. static int msmfb_probe(struct platform_device *pdev)
  1021. {
  1022.         struct fb_info *fb;
  1023.         struct msmfb_info *msmfb;
  1024.         struct msm_panel_data *panel = pdev->dev.platform_data;
  1025.         int ret;
  1026.  
  1027.         if (!panel) {
  1028.                 pr_err("msmfb_probe: no platform data\n");
  1029.                 return -EINVAL;
  1030.         }
  1031.         if (!panel->fb_data) {
  1032.                 pr_err("msmfb_probe: no fb_data\n");
  1033.                 return -EINVAL;
  1034.         }
  1035.  
  1036.         fb = framebuffer_alloc(sizeof(struct msmfb_info), &pdev->dev);
  1037.         if (!fb)
  1038.                 return -ENOMEM;
  1039.         msmfb = fb->par;
  1040.         msmfb->fb = fb;
  1041.         msmfb->panel = panel;
  1042.         msmfb->xres = panel->fb_data->xres;
  1043.         msmfb->yres = panel->fb_data->yres;
  1044.  
  1045.         ret = setup_fbmem(msmfb, pdev);
  1046.         if (ret)
  1047.                 goto error_setup_fbmem;
  1048.  
  1049. #if (defined(CONFIG_USB_FUNCTION_PROJECTOR) || defined(CONFIG_USB_ANDROID_PROJECTOR))
  1050.         /* Jay, 8/1/09' */
  1051.         msmfb_set_var(msmfb->fb->screen_base, 0);
  1052. #endif
  1053.  
  1054.         setup_fb_info(msmfb);
  1055.  
  1056.         spin_lock_init(&msmfb->update_lock);
  1057.         mutex_init(&msmfb->panel_init_lock);
  1058.         init_waitqueue_head(&msmfb->frame_wq);
  1059.         msmfb->resume_workqueue = create_rt_workqueue("panel_on");
  1060.         if (msmfb->resume_workqueue == NULL) {
  1061.                 printk(KERN_ERR "failed to create panel_on workqueue\n");
  1062.                 ret = -ENOMEM;
  1063.                 goto error_create_workqueue;
  1064.         }
  1065.         INIT_WORK(&msmfb->resume_work, power_on_panel);
  1066.         msmfb->black = kzalloc(msmfb->fb->var.bits_per_pixel*msmfb->xres,
  1067.                                GFP_KERNEL);
  1068.  
  1069.         wake_lock_init(&msmfb->idle_lock, WAKE_LOCK_IDLE, "msmfb_idle_lock");
  1070.  
  1071. #ifdef CONFIG_HAS_EARLYSUSPEND
  1072. printk(KERN_INFO "msmfb: 40");
  1073.         INIT_WORK(&msmfb->msmfb_resume_work, msmfb_resume);
  1074.         msmfb->early_suspend.suspend = msmfb_suspend;
  1075.         msmfb->early_suspend.resume = msmfb_resume_handler;
  1076.         msmfb->early_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB;
  1077.         register_early_suspend(&msmfb->early_suspend);
  1078.  
  1079.         msmfb->earlier_suspend.suspend = msmfb_earlier_suspend;
  1080.         msmfb->earlier_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN;
  1081.         register_early_suspend(&msmfb->earlier_suspend);
  1082. printk(KERN_INFO "msmfb: 41");
  1083. #endif
  1084.  
  1085. #if MSMFB_DEBUG
  1086.         debugfs_create_file("msm_fb", S_IFREG | S_IRUGO, NULL,
  1087.                             (void *)fb->par, &debug_fops);
  1088. #endif
  1089.  
  1090.         printk(KERN_INFO "msmfb_probe() installing %d x %d panel\n",
  1091.                msmfb->xres, msmfb->yres);
  1092.  
  1093.         msmfb->dma_callback.func = msmfb_handle_dma_interrupt;
  1094.         msmfb->vsync_callback.func = msmfb_handle_vsync_interrupt;
  1095.         hrtimer_init(&msmfb->fake_vsync, CLOCK_MONOTONIC,
  1096.                      HRTIMER_MODE_REL);
  1097.  
  1098.         msmfb->fake_vsync.function = msmfb_fake_vsync;
  1099.  
  1100.         ret = register_framebuffer(fb);
  1101.         if (ret)
  1102.                 goto error_register_framebuffer;
  1103.  
  1104.         msmfb->sleeping = WAKING;
  1105.  
  1106. #ifdef CONFIG_FB_MSM_OVERLAY
  1107.         /*init wait event*/
  1108.         init_waitqueue_head(&overlay_event.event_wait);
  1109.         /*init waked_up value*/
  1110.         overlay_event.waked_up = ~USE_OVERLAY;
  1111. printk(KERN_INFO "msmfb: 42");
  1112. #endif
  1113.  
  1114. #ifdef CONFIG_FB_MSM_LOGO
  1115.         if (!load_565rle_image(INIT_IMAGE_FILE)) {
  1116.                 /* Flip buffer */
  1117.                 msmfb->update_info.left = 0;
  1118.                 msmfb->update_info.top = 0;
  1119.                 msmfb->update_info.eright = info->var.xres;
  1120.                 msmfb->update_info.ebottom = info->var.yres;
  1121.                 msmfb_pan_update(info, 0, 0, fb->var.xres,
  1122.                                  fb->var.yres, 0, 1);
  1123.         }
  1124. #endif
  1125.         /* Jay, 29/12/08' */
  1126.         display_notifier(display_notifier_callback, NOTIFY_MSM_FB);
  1127.         return 0;
  1128.  
  1129. error_register_framebuffer:
  1130.         wake_lock_destroy(&msmfb->idle_lock);
  1131. printk(KERN_INFO "msmfb: 43");
  1132.         destroy_workqueue(msmfb->resume_workqueue);
  1133. error_create_workqueue:
  1134.         iounmap(fb->screen_base);
  1135. error_setup_fbmem:
  1136. printk(KERN_INFO "msmfb: 44");
  1137.         framebuffer_release(msmfb->fb);
  1138.         return ret;
  1139. }
  1140.  
  1141. static void msmfb_shutdown(struct platform_device *pdev)
  1142. {
  1143.         struct msm_panel_data *panel = pdev->dev.platform_data;
  1144.         struct fb_info *fb;
  1145.         struct msmfb_info *msmfb;
  1146.  
  1147.         printk(KERN_INFO "%s\n", __func__);
  1148.         fb = registered_fb[0];
  1149.         if (!fb) {
  1150.                 printk(KERN_ERR "fb0 unavailable.\n");
  1151.                 return;
  1152.         }
  1153.         msmfb = fb->par;
  1154.  
  1155.         mdp->dma(mdp, virt_to_phys(msmfb->black), 0,
  1156.                         msmfb->fb->var.xres, msmfb->fb->var.yres, 0, 0,
  1157.                         NULL, panel->interface_type);
  1158.  
  1159.         if (panel->blank)
  1160.                 panel->blank(panel);
  1161. printk(KERN_INFO "msmfb: 45");
  1162.  
  1163.         if (panel->shutdown)
  1164.                 panel->shutdown(panel);
  1165. printk(KERN_INFO "msmfb: 46");
  1166. }
  1167.  
  1168. static struct platform_driver msm_panel_driver = {
  1169.         /* need to write remove */
  1170.         .probe = msmfb_probe,
  1171.         .shutdown = msmfb_shutdown,
  1172.         .driver = {.name = "msm_panel"},
  1173. };
  1174.  
  1175.  
  1176. static int msmfb_add_mdp_device(struct device *dev,
  1177.                                 struct class_interface *class_intf)
  1178. {
  1179.         /* might need locking if mulitple mdp devices */
  1180.         if (mdp)
  1181.                 return 0;
  1182.         mdp = container_of(dev, struct mdp_device, dev);
  1183.         return platform_driver_register(&msm_panel_driver);
  1184. }
  1185.  
  1186. static void msmfb_remove_mdp_device(struct device *dev,
  1187.                                 struct class_interface *class_intf)
  1188. {
  1189.         /* might need locking if mulitple mdp devices */
  1190.         if (dev != &mdp->dev)
  1191.                 return;
  1192.         platform_driver_unregister(&msm_panel_driver);
  1193.         mdp = NULL;
  1194. printk(KERN_INFO "msmfb: 47");
  1195. }
  1196.  
  1197. static struct class_interface msm_fb_interface = {
  1198.         .add_dev = &msmfb_add_mdp_device,
  1199.         .remove_dev = &msmfb_remove_mdp_device,
  1200. };
  1201.  
  1202. static int __init msmfb_init(void)
  1203. {
  1204.         return register_mdp_client(&msm_fb_interface);
  1205. printk(KERN_INFO "msmfb: 48");
  1206. }
  1207.  
  1208. module_init(msmfb_init);
create new paste | create new version of this paste RAW Paste Data