daily pastebin goal
3%
SHARE
TWEET

6.1.1.B.1.10_6.1.1.B.1.75_diff

Thjap_dev Jan 9th, 2013 169 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. diff -ruN .a/arch/arm/configs/riogrande_kumquat_defconfig .b/arch/arm/configs/riogrande_kumquat_defconfig
  2. --- .a/arch/arm/configs/riogrande_kumquat_defconfig     2012-10-23 21:38:03.000000000 +0900
  3. +++ .b/arch/arm/configs/riogrande_kumquat_defconfig     2013-01-08 21:27:53.000000000 +0900
  4. @@ -1,6 +1,5 @@
  5.  CONFIG_EXPERIMENTAL=y
  6.  # CONFIG_LOCALVERSION_AUTO is not set
  7. -CONFIG_SWAP=y
  8.  CONFIG_SYSVIPC=y
  9.  CONFIG_BSD_PROCESS_ACCT=y
  10.  CONFIG_TASKSTATS=y
  11. @@ -351,6 +350,7 @@
  12.  CONFIG_ANDROID_RAM_CONSOLE=y
  13.  CONFIG_ANDROID_TIMED_GPIO=y
  14.  CONFIG_ANDROID_LOW_MEMORY_KILLER=y
  15. +CONFIG_ZRAM=y
  16.  CONFIG_CG2900=y
  17.  CONFIG_CG2900_CHIP=y
  18.  CONFIG_STLC2690_CHIP=y
  19. @@ -401,4 +401,3 @@
  20.  CONFIG_CRYPTO_DEV_UX500_HASH=y
  21.  CONFIG_CRC7=y
  22.  CONFIG_AVERAGE=y
  23. -CONFIG_ZRAM=y
  24. diff -ruN .a/arch/arm/configs/riogrande_lotus_defconfig .b/arch/arm/configs/riogrande_lotus_defconfig
  25. --- .a/arch/arm/configs/riogrande_lotus_defconfig       2012-10-23 21:38:03.000000000 +0900
  26. +++ .b/arch/arm/configs/riogrande_lotus_defconfig       2013-01-08 21:27:53.000000000 +0900
  27. @@ -1,6 +1,5 @@
  28.  CONFIG_EXPERIMENTAL=y
  29.  # CONFIG_LOCALVERSION_AUTO is not set
  30. -CONFIG_SWAP=y
  31.  CONFIG_SYSVIPC=y
  32.  CONFIG_BSD_PROCESS_ACCT=y
  33.  CONFIG_TASKSTATS=y
  34. @@ -353,6 +352,7 @@
  35.  CONFIG_ANDROID_RAM_CONSOLE=y
  36.  CONFIG_ANDROID_TIMED_GPIO=y
  37.  CONFIG_ANDROID_LOW_MEMORY_KILLER=y
  38. +CONFIG_ZRAM=y
  39.  CONFIG_CG2900=y
  40.  CONFIG_CG2900_CHIP=y
  41.  CONFIG_STLC2690_CHIP=y
  42. @@ -403,4 +403,3 @@
  43.  CONFIG_CRYPTO_DEV_UX500_HASH=y
  44.  CONFIG_CRC7=y
  45.  CONFIG_AVERAGE=y
  46. -CONFIG_ZRAM=y
  47. diff -ruN .a/arch/arm/configs/riogrande_pepper_defconfig .b/arch/arm/configs/riogrande_pepper_defconfig
  48. --- .a/arch/arm/configs/riogrande_pepper_defconfig      2012-10-23 21:38:03.000000000 +0900
  49. +++ .b/arch/arm/configs/riogrande_pepper_defconfig      2013-01-08 21:27:53.000000000 +0900
  50. @@ -1,6 +1,5 @@
  51.  CONFIG_EXPERIMENTAL=y
  52.  # CONFIG_LOCALVERSION_AUTO is not set
  53. -CONFIG_SWAP=y
  54.  CONFIG_SYSVIPC=y
  55.  CONFIG_BSD_PROCESS_ACCT=y
  56.  CONFIG_TASKSTATS=y
  57. @@ -353,6 +352,7 @@
  58.  CONFIG_ANDROID_RAM_CONSOLE=y
  59.  CONFIG_ANDROID_TIMED_GPIO=y
  60.  CONFIG_ANDROID_LOW_MEMORY_KILLER=y
  61. +CONFIG_ZRAM=y
  62.  CONFIG_CG2900=y
  63.  CONFIG_CG2900_CHIP=y
  64.  CONFIG_STLC2690_CHIP=y
  65. @@ -403,4 +403,3 @@
  66.  CONFIG_CRYPTO_DEV_UX500_HASH=y
  67.  CONFIG_CRC7=y
  68.  CONFIG_AVERAGE=y
  69. -CONFIG_ZRAM=y
  70. diff -ruN .a/drivers/misc/clonedev/clonedev.c .b/drivers/misc/clonedev/clonedev.c
  71. --- .a/drivers/misc/clonedev/clonedev.c 2012-10-23 21:38:05.000000000 +0900
  72. +++ .b/drivers/misc/clonedev/clonedev.c 2013-01-08 21:13:47.000000000 +0900
  73. @@ -48,6 +48,7 @@
  74.         struct compdev *src_compdev;
  75.         struct compdev *dst_compdev;
  76.         bool overlay_case;
  77. +       struct compdev_size src_size;
  78.         struct compdev_size dst_size;
  79.         struct compdev_rect crop_rect;
  80.         struct compdev_scene_info s_info;
  81. @@ -140,8 +141,7 @@
  82.         return req_id;
  83.  }
  84.  
  85. -static void clonedev_best_fit(struct compdev_rect *src_rect,
  86. -               struct compdev_rect *crop_rect,
  87. +static void clonedev_best_fit(struct compdev_rect *crop_rect,
  88.                 struct compdev_rect *dst_rect,
  89.                 enum   compdev_transform  transform)
  90.  {
  91. @@ -201,6 +201,45 @@
  92.                 dst_rect->y += (crop_rect->height - dst_h) >> 1;
  93.  }
  94.  
  95. +static void clonedev_rescale_destrect(struct compdev_rect *boundary,
  96. +               struct compdev_size *src_size,
  97. +               struct compdev_rect *dst_rect,
  98. +               enum compdev_transform transform)
  99. +{
  100. +       uint32_t q, r, src_width;
  101. +       uint32_t x, y, height, width;
  102. +
  103. +       if (transform == COMPDEV_TRANSFORM_ROT_0) {
  104. +               x = dst_rect->x;
  105. +               y = dst_rect->y;
  106. +               width = dst_rect->width;
  107. +               height = dst_rect->height;
  108. +               src_width = src_size->width;
  109. +       } else if (transform == COMPDEV_TRANSFORM_ROT_90_CW) {
  110. +               x = src_size->height - dst_rect->y - dst_rect->height;
  111. +               y = dst_rect->x;
  112. +               width = dst_rect->height;
  113. +               height = dst_rect->width;
  114. +               src_width = src_size->height;
  115. +       } else if (transform == COMPDEV_TRANSFORM_ROT_90_CCW) {
  116. +               x = dst_rect->y;
  117. +               y = src_size->width - dst_rect->x - dst_rect->width;
  118. +               width = dst_rect->height;
  119. +               height = dst_rect->width;
  120. +               src_width = src_size->height;
  121. +       }
  122. +
  123. +       q = (boundary->width << 6) / src_width;
  124. +       r = (boundary->width << 6) % src_width;
  125. +
  126. +       dst_rect->x      = (((boundary->x << 6) + ((q * x + r * x / src_width) +
  127. +                               (0x1 << 5))) >> 6) & ~0x1;
  128. +       dst_rect->y      = ((q * y + r * y / src_width) >> 6) + boundary->y;
  129. +       dst_rect->width  = (((q * width + r * width / src_width) +
  130. +                               (0x1 << 5)) >> 6) & ~0x1;
  131. +       dst_rect->height = (q * height + r * height / src_width) >> 6;
  132. +}
  133. +
  134.  static int clonedev_set_mode_locked(struct clonedev *cd,
  135.                 enum clonedev_mode mode)
  136.  {
  137. @@ -247,9 +286,18 @@
  138.  static void set_transform_and_dest_rect(struct clonedev *cd,
  139.                 struct compdev_img *img)
  140.  {
  141. -       /* Adjust destination rect */
  142. -       clonedev_best_fit(&img->src_rect,
  143. -                       &cd->crop_rect,
  144. +       struct compdev_rect temp_rect = {0};
  145. +       temp_rect.width = cd->src_size.width;
  146. +       temp_rect.height = cd->src_size.height;
  147. +
  148. +       /* First adjust src rect to crop_rect */
  149. +       clonedev_best_fit(&cd->crop_rect,
  150. +                       &temp_rect,
  151. +                       img->transform);
  152. +
  153. +       /* Now use temp_rect as the boundary */
  154. +       clonedev_rescale_destrect(&temp_rect,
  155. +                       &cd->src_size,
  156.                         &img->dst_rect,
  157.                         img->transform);
  158.  
  159. @@ -457,8 +505,12 @@
  160.                                 b2r2_req_id = ret;
  161.                 }
  162.  
  163. -               dst_img->img.dst_rect.x += cd->crop_rect.x;
  164. -               dst_img->img.dst_rect.y += cd->crop_rect.y;
  165. +               dst_img->img.dst_rect = cd->crop_rect;
  166. +               dst_img->img.src_rect.x = 0;
  167. +               dst_img->img.src_rect.y = 0;
  168. +               dst_img->img.src_rect.width = cd->crop_rect.width;
  169. +               dst_img->img.src_rect.height = cd->crop_rect.height;
  170. +
  171.                 compdev_post_single_buffer_asynch(cd->dst_compdev,
  172.                                 &dst_img->img, cd->blt_handle, b2r2_req_id);
  173.  
  174. @@ -718,6 +770,10 @@
  175.         if (ret < 0)
  176.                 goto fail_register_misc;
  177.  
  178. +       ret = compdev_get_size(cd->src_compdev, &cd->src_size);
  179. +       if (ret < 0)
  180. +               goto fail_register_misc;
  181. +
  182.         ret = compdev_get_size(cd->dst_compdev, &cd->dst_size);
  183.         if (ret < 0)
  184.                 goto fail_register_misc;
  185. diff -ruN .a/drivers/misc/hwmem/scatt_alloc.c .b/drivers/misc/hwmem/scatt_alloc.c
  186. --- .a/drivers/misc/hwmem/scatt_alloc.c 2012-10-23 21:38:05.000000000 +0900
  187. +++ .b/drivers/misc/hwmem/scatt_alloc.c 2013-01-08 21:13:47.000000000 +0900
  188. @@ -87,6 +87,9 @@
  189.  
  190.         struct alloc *alloc_l = (struct alloc *)alloc;
  191.  
  192. +       if (alloc == NULL)
  193. +               return;
  194. +
  195.         mutex_lock(&lock);
  196.  
  197.         /* Free all pages in the sglist */
  198. diff -ruN .a/drivers/mmc/host/mmci.c .b/drivers/mmc/host/mmci.c
  199. --- .a/drivers/mmc/host/mmci.c  2012-10-23 21:38:05.000000000 +0900
  200. +++ .b/drivers/mmc/host/mmci.c  2013-01-08 21:13:47.000000000 +0900
  201. @@ -911,6 +911,8 @@
  202.                 if (!data->stop) {
  203.                         mmci_request_end(host, data->mrq);
  204.                 } else {
  205. +                       /* Stop safety timer also before blk-rw stop */
  206. +                       del_timer(&host->req_expiry);
  207.                         mmci_start_command(host, data->stop, 0);
  208.                 }
  209.         }
  210. diff -ruN .a/drivers/modem/shrm/shrm_protocol.c .b/drivers/modem/shrm/shrm_protocol.c
  211. --- .a/drivers/modem/shrm/shrm_protocol.c       2012-10-23 21:38:05.000000000 +0900
  212. +++ .b/drivers/modem/shrm/shrm_protocol.c       2013-01-08 21:13:47.000000000 +0900
  213. @@ -479,7 +479,7 @@
  214.                 dev_err(shrm->dev, "Invalid boot state\n");
  215.         }
  216.         /* start timer here */
  217. -       hrtimer_start(&timer, ktime_set(0, 25*NSEC_PER_MSEC),
  218. +       hrtimer_start(&timer, ktime_set(0, 50*NSEC_PER_MSEC),
  219.                         HRTIMER_MODE_REL);
  220.         atomic_dec(&ac_sleep_disable_count);
  221.  
  222. @@ -517,7 +517,7 @@
  223.                 shrm_audio_tx_state = SHRM_IDLE;
  224.         }
  225.         /* start timer here */
  226. -       hrtimer_start(&timer, ktime_set(0, 25*NSEC_PER_MSEC),
  227. +       hrtimer_start(&timer, ktime_set(0, 50*NSEC_PER_MSEC),
  228.                         HRTIMER_MODE_REL);
  229.         atomic_dec(&ac_sleep_disable_count);
  230.         atomic_dec(&ac_msg_pend_1);
  231. diff -ruN .a/drivers/rmi4/rmi4_driver.c .b/drivers/rmi4/rmi4_driver.c
  232. --- .a/drivers/rmi4/rmi4_driver.c       2012-10-23 21:38:05.000000000 +0900
  233. +++ .b/drivers/rmi4/rmi4_driver.c       2013-01-08 21:13:47.000000000 +0900
  234. @@ -1640,7 +1640,7 @@
  235.         }
  236.  
  237.  exit:
  238. -       mutex_unlock(&ddata->pdt_lock);
  239. +       UNLOCK_PDT(ddata);
  240.         return err;
  241.  }
  242.  
  243. diff -ruN .a/drivers/rmi4/rmi4_spi_adaptor.c .b/drivers/rmi4/rmi4_spi_adaptor.c
  244. --- .a/drivers/rmi4/rmi4_spi_adaptor.c  2012-10-23 21:38:05.000000000 +0900
  245. +++ .b/drivers/rmi4/rmi4_spi_adaptor.c  2013-01-08 21:13:47.000000000 +0900
  246. @@ -256,7 +256,7 @@
  247.         }
  248.  
  249.         if (n_rx)
  250. -               rmi4_spi_adapter_dbg_dump(dev, txbuf, n_tx,
  251. +               rmi4_spi_adapter_dbg_dump(dev, rxbuf, n_rx,
  252.                                           "SPI received bytes:");
  253.  
  254.  error_exit:
  255. diff -ruN .a/drivers/usb/musb/ux500.c .b/drivers/usb/musb/ux500.c
  256. --- .a/drivers/usb/musb/ux500.c 2012-10-23 21:38:06.000000000 +0900
  257. +++ .b/drivers/usb/musb/ux500.c 2013-01-08 21:13:47.000000000 +0900
  258. @@ -449,18 +449,10 @@
  259.         u8              devctl;
  260.         unsigned long timeout = jiffies + msecs_to_jiffies(1000);
  261.         int ret = 1;
  262. -#ifdef CONFIG_USB_OTG_20
  263. -       int val = 0;
  264. -#endif
  265.         /* HDRC controls CPEN, but beware current surges during device
  266.          * connect.  They can trigger transient overcurrent conditions
  267.          * that must be ignored.
  268.          */
  269. -#ifdef CONFIG_USB_OTG_20
  270. -       val = musb_readb(musb->mregs, MUSB_MISC);
  271. -       val |= 0x1C;
  272. -       musb_writeb(musb->mregs, MUSB_MISC, val);
  273. -#endif
  274.         devctl = musb_readb(musb->mregs, MUSB_DEVCTL);
  275.  
  276.         if (is_on) {
  277. diff -ruN .a/drivers/video/av8100/av8100.c .b/drivers/video/av8100/av8100.c
  278. --- .a/drivers/video/av8100/av8100.c    2012-10-23 21:38:06.000000000 +0900
  279. +++ .b/drivers/video/av8100/av8100.c    2013-01-08 21:13:47.000000000 +0900
  280. @@ -31,6 +31,7 @@
  281.  #include <linux/regulator/consumer.h>
  282.  #include <linux/earlysuspend.h>
  283.  #include <linux/mfd/dbx500-prcmu.h>
  284. +#include <linux/spinlock.h>
  285.  
  286.  #include "av8100_regs.h"
  287.  #include <video/av8100.h>
  288. @@ -58,7 +59,10 @@
  289.  #define AV8100_POWERDOWN_TIMER_EVENT   0x200
  290.  #define AV8100_CHECK_HW_STATUS_EVENT   0x400
  291.  #define AV8100_POWER_CYCLE_EVENT       0x800
  292. -#define AV8100_EVENTS                  0xFFE
  293. +#define AV8100_EARLY_SUSPEND_EVENT     0x1000
  294. +#define AV8100_LATE_RESUME_EVENT       0x2000
  295. +#define AV8100_PUT_EVENT               0x4000
  296. +#define AV8100_EVENTS                  0x7FFE
  297.  #define CCI_MAX 50
  298.  #define AV8100_INTERNAL_REG_1 0x8488
  299.  /* Standby search time */
  300. @@ -70,8 +74,10 @@
  301.  #define AV8100_DISP_OFF_HDMI_OFF_TIME 2
  302.  #define ONI_READ_MAX 20
  303.  #define AV8100_SCAN_WHEN_DISPLAY_IS_POWERED_OFF false
  304. -#define UFLOW_CNT_MAX 15
  305. -#define UFLOW_TIME_MAX 1000
  306. +#define UFLOW_CNT_MAX 60
  307. +#define UFLOW_CNT_CHECK_HW 10
  308. +#define UFLOW_TIME_MIN 700
  309. +#define UFLOW_TIME_MAX 4000
  310.  
  311.  /* Command offsets */
  312.  #define AV8100_COMMAND_OFFSET          0x10
  313. @@ -142,15 +148,14 @@
  314.  #define AV8100_WAITTIME_50MS_MAX 55000
  315.  #define AV8100_WATTIME_100US 100
  316.  
  317. -static DEFINE_MUTEX(av8100_hw_mutex);
  318. -#define LOCK_AV8100_HW mutex_lock(&av8100_hw_mutex)
  319. -#define UNLOCK_AV8100_HW mutex_unlock(&av8100_hw_mutex)
  320. -static DEFINE_MUTEX(av8100_fwdl_mutex);
  321. -#define LOCK_AV8100_FWDL mutex_lock(&av8100_fwdl_mutex)
  322. -#define UNLOCK_AV8100_FWDL mutex_unlock(&av8100_fwdl_mutex)
  323. -static DEFINE_MUTEX(av8100_usrcnt_mutex);
  324. -#define LOCK_AV8100_USRCNT mutex_lock(&av8100_usrcnt_mutex)
  325. -#define UNLOCK_AV8100_USRCNT mutex_unlock(&av8100_usrcnt_mutex)
  326. +#define LOCK_AV8100_HW mutex_lock(&adev->hw_mutex)
  327. +#define UNLOCK_AV8100_HW mutex_unlock(&adev->hw_mutex)
  328. +#define LOCK_AV8100_FWDL mutex_lock(&adev->fwdl_mutex)
  329. +#define UNLOCK_AV8100_FWDL mutex_unlock(&adev->fwdl_mutex)
  330. +#define LOCK_AV8100_USRCNT mutex_lock(&adev->usrcnt_mutex)
  331. +#define UNLOCK_AV8100_USRCNT mutex_unlock(&adev->usrcnt_mutex)
  332. +#define LOCK_AV8100_CONF mutex_lock(&adev->conf_mutex)
  333. +#define UNLOCK_AV8100_CONF mutex_unlock(&adev->conf_mutex)
  334.  
  335.  enum av8100_timer_flag {
  336.         TIMER_UNSET,
  337. @@ -237,6 +242,7 @@
  338.         bool disp_on;
  339.         bool busy;
  340.         u8 hdcp_state;
  341. +       bool pwr_recover;
  342.  };
  343.  
  344.  /**
  345. @@ -302,6 +308,13 @@
  346.         u8                      chip_version;
  347.         struct early_suspend    early_suspend;
  348.         u32                     usr_cnt;
  349. +       bool                    usr_audio;
  350. +       bool                    usr_video;
  351. +       struct mutex            hw_mutex;
  352. +       struct mutex            fwdl_mutex;
  353. +       struct mutex            usrcnt_mutex;
  354. +       struct mutex            conf_mutex;
  355. +       spinlock_t              flag_lock;
  356.  };
  357.  
  358.  static const unsigned int waittime_retry[10] = {
  359. @@ -327,6 +340,9 @@
  360.  static const struct color_conversion_cmd *get_color_transform_cmd(
  361.                                 struct av8100_device *adev,
  362.                                 enum av8100_color_transform transform);
  363. +static void put_handle(struct av8100_device *adev);
  364. +static void early_suspend_handle(struct av8100_device *adev);
  365. +static void late_resume_handle(struct av8100_device *adev);
  366.  static int av8100_open(struct inode *inode, struct file *filp);
  367.  static int av8100_release(struct inode *inode, struct file *filp);
  368.  static long av8100_ioctl(struct file *file,
  369. @@ -573,6 +589,37 @@
  370.         return NULL;
  371.  }
  372.  
  373. +static void set_flag(struct av8100_device *adev, int av8100_flags)
  374. +{
  375. +       unsigned long flags;
  376. +
  377. +       spin_lock_irqsave(&adev->flag_lock, flags);
  378. +       adev->flag |= av8100_flags;
  379. +       spin_unlock_irqrestore(&adev->flag_lock, flags);
  380. +       wake_up_interruptible(&adev->event);
  381. +}
  382. +
  383. +static void clr_flag(struct av8100_device *adev, int av8100_flags)
  384. +{
  385. +       unsigned long flags;
  386. +
  387. +       spin_lock_irqsave(&adev->flag_lock, flags);
  388. +       adev->flag &= ~av8100_flags;
  389. +       spin_unlock_irqrestore(&adev->flag_lock, flags);
  390. +}
  391. +
  392. +static int get_flag(struct av8100_device *adev)
  393. +{
  394. +       unsigned long flags;
  395. +       int av8100_flags;
  396. +
  397. +       spin_lock_irqsave(&adev->flag_lock, flags);
  398. +       av8100_flags = adev->flag;
  399. +       spin_unlock_irqrestore(&adev->flag_lock, flags);
  400. +
  401. +       return av8100_flags;
  402. +}
  403. +
  404.  static void set_hrtimer(struct av8100_device *adev, enum av8100_timer_flag flag)
  405.  {
  406.         ktime_t time;
  407. @@ -634,15 +681,19 @@
  408.  
  409.         dev_dbg(dev, "%s\n", __func__);
  410.  
  411. -       adev->flag &= ~AV8100_EVENTS;
  412. +       clr_flag(adev, AV8100_EVENTS);
  413.         hrtimer_cancel(&adev->hrtimer);
  414.         adev->params.pre_suspend_power =
  415.                 (av8100_status_get().av8100_state > AV8100_OPMODE_SHUTDOWN);
  416.  
  417.         if (adev->params.pre_suspend_power) {
  418. -               ret = av8100_powerdown();
  419. -               if (ret)
  420. -                       dev_err(dev, "av8100_powerdown failed\n");
  421. +               if (adev->usr_audio) {
  422. +                       ret = -EBUSY;
  423. +               } else {
  424. +                       ret = av8100_powerdown();
  425. +                       if (ret)
  426. +                               dev_err(dev, "av8100_powerdown failed\n");
  427. +               }
  428.         }
  429.  
  430.         return ret;
  431. @@ -685,9 +736,15 @@
  432.  {
  433.         if (av8100_status_get().av8100_state <= AV8100_OPMODE_SHUTDOWN)
  434.                 return 0;
  435. -       dev_dbg(adev->dev, "%s\n", __func__);
  436. -       av8100_powerdown();
  437. -       set_hrtimer(adev, TIMER_POWERUP);
  438. +       dev_dbg(adev->dev, "%s %d\n", __func__, adev->usr_audio);
  439. +       if (!adev->usr_audio) {
  440. +               av8100_powerdown();
  441. +               set_hrtimer(adev, TIMER_POWERUP);
  442. +       } else {
  443. +               /* Simulate unplug in order to recover */
  444. +               clr_plug_status(adev, AV8100_HDMI_PLUGIN);
  445. +               adev->params.pwr_recover = true;
  446. +       }
  447.         return 0;
  448.  }
  449.  
  450. @@ -699,32 +756,31 @@
  451.  
  452.         switch (adev->timer_flag) {
  453.         case TIMER_1S:
  454. -               adev->flag |= AV8100_1S_TIMER_EVENT;
  455. +               set_flag(adev, AV8100_1S_TIMER_EVENT);
  456.                 break;
  457.         case TIMER_SCAN:
  458.         case TIMER_SCAN2:
  459. -               adev->flag |= AV8100_SCAN_TIMER_EVENT;
  460. +               set_flag(adev, AV8100_SCAN_TIMER_EVENT);
  461.                 break;
  462.         case TIMER_HPD:
  463. -               adev->flag |= AV8100_HPD_TIMER_EVENT;
  464. +               set_flag(adev, AV8100_HPD_TIMER_EVENT);
  465.                 break;
  466.         case TIMER_POWERSCAN:
  467. -               adev->flag |= AV8100_POWERSCAN_TIMER_EVENT;
  468. +               set_flag(adev, AV8100_POWERSCAN_TIMER_EVENT);
  469.                 break;
  470.         case TIMER_RESUME:
  471. -               adev->flag |= AV8100_RESUME_TIMER_EVENT;
  472. +               set_flag(adev, AV8100_RESUME_TIMER_EVENT);
  473.                 break;
  474.         case TIMER_POWERUP:
  475. -               adev->flag |= AV8100_POWERUP_TIMER_EVENT;
  476. +               set_flag(adev, AV8100_POWERUP_TIMER_EVENT);
  477.                 break;
  478.         case TIMER_POWERDOWN:
  479. -               adev->flag |= AV8100_POWERDOWN_TIMER_EVENT;
  480. +               set_flag(adev, AV8100_POWERDOWN_TIMER_EVENT);
  481.                 break;
  482.         default:
  483.                 return -EINVAL;
  484.                 break;
  485.         }
  486. -       wake_up_interruptible(&adev->event);
  487.  
  488.         return HRTIMER_NORESTART;
  489.  }
  490. @@ -762,7 +818,8 @@
  491.         if (adev->params.pulsing_5V == false)
  492.                 set_hrtimer(adev, TIMER_1S);
  493.  
  494. -       av8100_set_state(adev, AV8100_OPMODE_SCAN);
  495. +       if (av8100_status_get().av8100_state > AV8100_OPMODE_SCAN)
  496. +               av8100_set_state(adev, AV8100_OPMODE_SCAN);
  497.  }
  498.  
  499.  static int fix_cec(struct av8100_device *adev)
  500. @@ -829,7 +886,7 @@
  501.         struct av8100_platform_data *pdata = adev->dev->platform_data;
  502.  
  503.         adev->params.fw_loaded = false;
  504. -       adev->flag &= ~(AV8100_EVENTS | AV8100_INT_EVENT);
  505. +       clr_flag(adev, AV8100_EVENTS | AV8100_INT_EVENT);
  506.         if (fix_cec(adev))
  507.                 dev_err(adev->dev, "%s %d err\n", __func__, __LINE__);
  508.  
  509. @@ -922,8 +979,7 @@
  510.                                 AV8100_STANDBY_PENDING_INTERRUPT_BPDIG_LOW))
  511.                         goto av8100_1s_timer_event_handle_err;
  512.  
  513. -               adev->flag |= AV8100_FWDL_EVENT2;
  514. -               wake_up_interruptible(&adev->event);
  515. +               set_flag(adev, AV8100_FWDL_EVENT2);
  516.         } else {
  517.                 to_scan_mode_2(adev);
  518.         }
  519. @@ -947,6 +1003,8 @@
  520.  
  521.         dev_dbg(adev->dev, "Thpd\n");
  522.  
  523. +       hrtimer_cancel(&adev->hrtimer);
  524. +
  525.         /* Clear hpdi and cci interrupts */
  526.         if (av8100_reg_stby_pend_int_w(
  527.                         AV8100_STANDBY_PENDING_INTERRUPT_HPDI_HIGH,
  528. @@ -1006,9 +1064,12 @@
  529.                 set_plug_status(adev, AV8100_HDMI_PLUGIN);
  530.  
  531.         } else {
  532. -               av8100_powerdown();
  533. -               msleep(AV8100_WAITTIME_1MS);
  534. -               av8100_powerup();
  535. +               if (!adev->usr_audio) {
  536. +                       av8100_powerdown();
  537. +                       usleep_range(AV8100_WAITTIME_1MS,
  538. +                                               AV8100_WAITTIME_1MS_MAX);
  539. +                       av8100_powerup();
  540. +               }
  541.                 if (adev->params.pulsing_5V == false)
  542.                         set_hrtimer(adev, TIMER_1S);
  543.                 av8100_set_state(adev, AV8100_OPMODE_SCAN);
  544. @@ -1041,8 +1102,11 @@
  545.  {
  546.         dev_dbg(adev->dev, "Tpwrdown\n");
  547.  
  548. -       (void)av8100_powerdown();
  549. -       adev->params.busy = false;
  550. +       /* Power down only if suspended and audio is not a user. */
  551. +       if ((adev->params.suspended) && (!adev->usr_audio))
  552. +               (void)av8100_powerdown();
  553. +       else
  554. +               dev_dbg(adev->dev, "Tpwrdown no action\n");
  555.  }
  556.  
  557.  static int cci_handle(struct av8100_device *adev, u8 hpdi)
  558. @@ -1074,7 +1138,7 @@
  559.                 /* standby_mode, no scanning */
  560.                 av8100_set_state(adev, AV8100_OPMODE_STANDBY);
  561.  
  562. -               adev->flag &= ~AV8100_EVENTS;
  563. +               clr_flag(adev, AV8100_EVENTS);
  564.                 hrtimer_cancel(&adev->hrtimer);
  565.                 adev->params.count_cci = 0;
  566.  
  567. @@ -1147,9 +1211,8 @@
  568.                 } else {
  569.                         dev_dbg(adev->dev, "fwdld 0\n");
  570.  
  571. -                       adev->flag |= AV8100_FWDL_EVENT1;
  572. -                       adev->flag &= ~AV8100_FWDL_EVENT2;
  573. -                       wake_up_interruptible(&adev->event);
  574. +                       clr_flag(adev, AV8100_FWDL_EVENT2);
  575. +                       set_flag(adev, AV8100_FWDL_EVENT1);
  576.                 }
  577.         } else {
  578.                 dev_dbg(adev->dev, "HPDint hpds 0\n");
  579. @@ -1224,6 +1287,7 @@
  580.         static ktime_t earlier;
  581.         ktime_t diff;
  582.         u32 uflow_time;
  583. +       bool check_hw;
  584.  
  585.         dev_dbg(adev->dev, "uovbi %d\n", onuvb);
  586.  
  587. @@ -1232,6 +1296,7 @@
  588.                 earlier = ktime_get();
  589.  
  590.         uflow_cnt++;
  591. +       check_hw = (uflow_cnt % UFLOW_CNT_CHECK_HW) == 0;
  592.         if (uflow_cnt > UFLOW_CNT_MAX) {
  593.                 later = ktime_get();
  594.  
  595. @@ -1240,19 +1305,16 @@
  596.                 dev_dbg(adev->dev, "uovbi 0 time: %d ms", uflow_time);
  597.  
  598.                 /* Underflow error: force power cycle */
  599. -               if (uflow_time < UFLOW_TIME_MAX) {
  600. -                       adev->flag |= AV8100_POWER_CYCLE_EVENT;
  601. -                       wake_up_interruptible(&adev->event);
  602. -               }
  603. +               if ((uflow_time > UFLOW_TIME_MIN) &&
  604. +                                       (uflow_time < UFLOW_TIME_MAX))
  605. +                       set_flag(adev, AV8100_POWER_CYCLE_EVENT);
  606.                 uflow_cnt = 0;
  607.         }
  608.  
  609.         /* Trig check of hw status */
  610. -       if (!(adev->flag & AV8100_POWER_CYCLE_EVENT) &&
  611. -                               (adev->params.fw_loaded)) {
  612. -               adev->flag |= AV8100_CHECK_HW_STATUS_EVENT;
  613. -               wake_up_interruptible(&adev->event);
  614. -       }
  615. +       if (!(get_flag(adev) & AV8100_POWER_CYCLE_EVENT) &&
  616. +                               (adev->params.fw_loaded) && check_hw)
  617. +               set_flag(adev, AV8100_CHECK_HW_STATUS_EVENT);
  618.  
  619.         return 0;
  620.  }
  621. @@ -1270,6 +1332,9 @@
  622.         u8 cecrx = 0;
  623.         u8 cectx = 0;
  624.  
  625. +       if (av8100_status_get().av8100_state <= AV8100_OPMODE_SHUTDOWN)
  626. +               return 0;
  627. +
  628.         /* Get hpdi and cci */
  629.         if (av8100_reg_stby_pend_int_r(&hpdi, NULL, NULL, &cci, NULL))
  630.                 goto av8100_int_event_handle_err;
  631. @@ -1397,8 +1462,17 @@
  632.  
  633.         while (1) {
  634.                 wait_event_interruptible(adev->event, (adev->flag != 0));
  635. -               flags = adev->flag;
  636. -               adev->flag = 0;
  637. +               flags = get_flag(adev);
  638. +               clr_flag(adev, AV8100_EVENTS | AV8100_INT_EVENT);
  639. +
  640. +               if (flags & AV8100_EARLY_SUSPEND_EVENT)
  641. +                       (void)early_suspend_handle(adev);
  642. +
  643. +               if (flags & AV8100_LATE_RESUME_EVENT)
  644. +                       (void)late_resume_handle(adev);
  645. +
  646. +               if (flags & AV8100_PUT_EVENT)
  647. +                       put_handle(adev);
  648.  
  649.                 if (flags & AV8100_INT_EVENT) {
  650.                         cnt = 0;
  651. @@ -1455,8 +1529,7 @@
  652.         struct av8100_device *adev;
  653.  
  654.         adev = (struct av8100_device *) p;
  655. -       adev->flag |= AV8100_INT_EVENT;
  656. -       wake_up_interruptible(&adev->event);
  657. +       set_flag(adev, AV8100_INT_EVENT);
  658.  
  659.         return IRQ_HANDLED;
  660.  }
  661. @@ -1712,7 +1785,7 @@
  662.  
  663.         adev->params.hdcpm = AV8100_GENERAL_INTERRUPT_MASK_HDCPM_HIGH;
  664.         adev->params.cecm = AV8100_GENERAL_INTERRUPT_MASK_CECM_HIGH;
  665. -       adev->params.uovbm = AV8100_GENERAL_INTERRUPT_MASK_UOVBM_HIGH;
  666. +       adev->params.uovbm = AV8100_GENERAL_INTERRUPT_MASK_UOVBM_LOW;
  667.  
  668.         adev->params.powerdown_scan = AV8100_SCAN_WHEN_DISPLAY_IS_POWERED_OFF;
  669.  
  670. @@ -2760,7 +2833,73 @@
  671.         return 0;
  672.  }
  673.  
  674. -int av8100_hdmi_get(void)
  675. +static int av8100_powerscan(bool disp_user)
  676. +{
  677. +       struct av8100_device *adev;
  678. +       int ret = 0;
  679. +
  680. +       adev = devnr_to_adev(AV8100_DEVNR_DEFAULT);
  681. +       if (!adev) {
  682. +               ret = -EFAULT;
  683. +               goto av8100_powerscan_end;
  684. +       }
  685. +
  686. +       dev_dbg(adev->dev, "%s %d\n", __func__, disp_user);
  687. +
  688. +       if ((av8100_status_get().av8100_state < AV8100_OPMODE_STANDBY) ||
  689. +                                       (disp_user && !adev->params.disp_on))
  690. +               goto av8100_powerscan_end;
  691. +
  692. +       if (disp_user)
  693. +               adev->params.disp_on = false;
  694. +
  695. +       if (adev->params.powerdown_scan ||
  696. +                               (disp_user && !adev->params.suspended)) {
  697. +               if (av8100_status_get().av8100_state > AV8100_OPMODE_SCAN) {
  698. +                       dev_dbg(adev->dev, "set to scan mode\n");
  699. +                       av8100_disable_interrupt();
  700. +                       set_flag(adev, AV8100_SCAN_TIMER_EVENT);
  701. +               }
  702. +
  703. +               ret = av8100_5V_w(AV8100_DENC_OFF_TIME,
  704. +                       adev->params.hdmi_off_time, adev->params.on_time);
  705. +               set_hrtimer(adev, TIMER_POWERSCAN);
  706. +       } else if (disp_user && adev->params.suspended) {
  707. +               /* Allow for a final CEC to be sent before powerdown */
  708. +               av8100_disable_interrupt();
  709. +               clr_plug_status(adev, AV8100_HDMI_PLUGIN);
  710. +               set_hrtimer(adev, TIMER_POWERDOWN);
  711. +               adev->params.busy = true;
  712. +       } else {
  713. +               if (!adev->usr_audio)
  714. +                       ret = av8100_powerdown();
  715. +       }
  716. +av8100_powerscan_end:
  717. +       return ret;
  718. +}
  719. +
  720. +static void put_handle(struct av8100_device *adev)
  721. +{
  722. +       bool powerscan = false;
  723. +
  724. +       if ((adev->params.pwr_recover) && (!adev->usr_audio)) {
  725. +               adev->params.pwr_recover = false;
  726. +               av8100_powerdown();
  727. +               usleep_range(AV8100_WAITTIME_5MS,
  728. +                               AV8100_WAITTIME_5MS_MAX);
  729. +               av8100_powerup();
  730. +
  731. +               powerscan = true;
  732. +       } else if (adev->params.suspended) {
  733. +               powerscan = true;
  734. +       }
  735. +
  736. +       if (powerscan)
  737. +               if (av8100_powerscan(true))
  738. +                       dev_err(adev->dev, "av8100_powerscan failed\n");
  739. +}
  740. +
  741. +int av8100_hdmi_get(enum av8100_hdmi_user user)
  742.  {
  743.         struct av8100_device *adev;
  744.         int usr_cnt;
  745. @@ -2768,18 +2907,42 @@
  746.         adev = devnr_to_adev(AV8100_DEVNR_DEFAULT);
  747.         if (!adev)
  748.                 return  -EFAULT;
  749. +       if (adev->timer_flag == TIMER_POWERDOWN) {
  750. +               dev_dbg(adev->dev, "%s busy %d\n", __func__, user);
  751. +               return  -EBUSY;
  752. +       }
  753. +       if (adev->params.suspended && (user == AV8100_HDMI_USER_AUDIO)) {
  754. +               dev_dbg(adev->dev, "%s suspended %d\n", __func__, user);
  755. +               return -EPERM;
  756. +       }
  757.  
  758.         LOCK_AV8100_USRCNT;
  759. -       adev->usr_cnt++;
  760. +       switch (user) {
  761. +       case AV8100_HDMI_USER_AUDIO:
  762. +               if (!adev->usr_audio) {
  763. +                       adev->usr_cnt++;
  764. +                       adev->usr_audio = true;
  765. +               }
  766. +               break;
  767. +       case AV8100_HDMI_USER_VIDEO:
  768. +               if (!adev->usr_video) {
  769. +                       adev->usr_cnt++;
  770. +                       adev->usr_video = true;
  771. +               }
  772. +               break;
  773. +       default:
  774. +               break;
  775. +       }
  776.         usr_cnt = adev->usr_cnt;
  777.         UNLOCK_AV8100_USRCNT;
  778. -       dev_dbg(adev->dev, "%s %d\n", __func__, usr_cnt);
  779. +
  780. +       dev_dbg(adev->dev, "%s %d %d\n", __func__, usr_cnt, user);
  781.  
  782.         return usr_cnt;
  783.  }
  784.  EXPORT_SYMBOL(av8100_hdmi_get);
  785.  
  786. -int av8100_hdmi_put(void)
  787. +int av8100_hdmi_put(enum av8100_hdmi_user user)
  788.  {
  789.         struct av8100_device *adev;
  790.         int usr_cnt;
  791. @@ -2789,16 +2952,30 @@
  792.                 return -EFAULT;
  793.  
  794.         LOCK_AV8100_USRCNT;
  795. -       if (adev->usr_cnt)
  796. -               adev->usr_cnt--;
  797. +       switch (user) {
  798. +       case AV8100_HDMI_USER_AUDIO:
  799. +               if (adev->usr_audio) {
  800. +                       adev->usr_cnt--;
  801. +                       adev->usr_audio = false;
  802. +               }
  803. +               break;
  804. +       case AV8100_HDMI_USER_VIDEO:
  805. +               if (adev->usr_video) {
  806. +                       adev->usr_cnt--;
  807. +                       adev->usr_video = false;
  808. +               }
  809. +               break;
  810. +       default:
  811. +               break;
  812. +       }
  813.         usr_cnt = adev->usr_cnt;
  814. -       UNLOCK_AV8100_USRCNT;
  815.  
  816. -       dev_dbg(adev->dev, "%s %d\n", __func__, usr_cnt);
  817. +       dev_dbg(adev->dev, "%s %d %d\n", __func__, usr_cnt, user);
  818.  
  819.         if (usr_cnt == 0)
  820. -               if (av8100_powerscan(true))
  821. -                       dev_err(adev->dev, "av8100_powerscan failed\n");
  822. +               set_flag(adev, AV8100_PUT_EVENT);
  823. +
  824. +       UNLOCK_AV8100_USRCNT;
  825.  
  826.         return usr_cnt;
  827.  }
  828. @@ -2806,9 +2983,7 @@
  829.  
  830.  int av8100_hdmi_video_off(void)
  831.  {
  832. -       int ret;
  833.         struct av8100_device *adev;
  834. -       union av8100_configuration config;
  835.  
  836.         adev = devnr_to_adev(AV8100_DEVNR_DEFAULT);
  837.         if (!adev)
  838. @@ -2819,119 +2994,103 @@
  839.         if (av8100_status_get().av8100_state < AV8100_OPMODE_VIDEO)
  840.                 return 0;
  841.  
  842. -       /* Get current av8100 video input format */
  843. -       ret = av8100_conf_get(AV8100_COMMAND_VIDEO_INPUT_FORMAT,
  844. -               &config);
  845. -       if (ret) {
  846. -               dev_err(adev->dev, "%s:av8100_conf_get "
  847. -                       "AV8100_COMMAND_VIDEO_INPUT_FORMAT failed\n",
  848. -                       __func__);
  849. -               return -EFAULT;
  850. -       }
  851. +       /* Video is off: mask uovbi interrupts */
  852. +       if (av8100_reg_gen_int_mask_w(
  853. +                       AV8100_GENERAL_INTERRUPT_MASK_EOCM_LOW,
  854. +                       AV8100_GENERAL_INTERRUPT_MASK_VSIM_LOW,
  855. +                       AV8100_GENERAL_INTERRUPT_MASK_VSOM_LOW,
  856. +                       adev->params.cecm,
  857. +                       adev->params.hdcpm,
  858. +                       AV8100_GENERAL_INTERRUPT_MASK_UOVBM_LOW,
  859. +                       AV8100_GENERAL_INTERRUPT_MASK_TEM_LOW))
  860. +               dev_dbg(adev->dev, "av8100_reg_gen_int_mask_w err\n");
  861.  
  862. -       config.video_input_format.dsi_input_mode = AV8100_HDMI_DSI_OFF;
  863. +       av8100_set_state(adev, AV8100_OPMODE_IDLE);
  864.  
  865. -       ret = av8100_conf_prep(AV8100_COMMAND_VIDEO_INPUT_FORMAT,
  866. -               &config);
  867. -       if (ret) {
  868. -               dev_err(adev->dev, "%s:av8100_conf_prep "
  869. -                               "AV8100_COMMAND_VIDEO_INPUT_FORMAT failed\n",
  870. -                               __func__);
  871. -               return -EFAULT;
  872. -       }
  873. +       return 0;
  874. +}
  875. +EXPORT_SYMBOL(av8100_hdmi_video_off);
  876.  
  877. -       /* Video input */
  878. -       ret = av8100_conf_w(AV8100_COMMAND_VIDEO_INPUT_FORMAT,
  879. -               NULL, NULL, I2C_INTERFACE);
  880. -       if (ret) {
  881. -               dev_err(adev->dev, "%s:av8100_conf_w "
  882. -                               "AV8100_COMMAND_VIDEO_INPUT_FORMAT failed\n",
  883. -                               __func__);
  884. +int av8100_hdmi_video_on(void)
  885. +{
  886. +       struct av8100_device *adev;
  887. +
  888. +       adev = devnr_to_adev(AV8100_DEVNR_DEFAULT);
  889. +       if (!adev)
  890.                 return -EFAULT;
  891. -       }
  892.  
  893. -       av8100_set_state(adev, AV8100_OPMODE_IDLE);
  894. +       dev_dbg(adev->dev, "%s\n", __func__);
  895. +
  896. +       if (av8100_status_get().av8100_state < AV8100_OPMODE_IDLE)
  897. +               return 0;
  898. +
  899. +       /* Video is on: unmask uovbi interrupts */
  900. +       if (av8100_reg_gen_int_mask_w(
  901. +                       AV8100_GENERAL_INTERRUPT_MASK_EOCM_LOW,
  902. +                       AV8100_GENERAL_INTERRUPT_MASK_VSIM_LOW,
  903. +                       AV8100_GENERAL_INTERRUPT_MASK_VSOM_LOW,
  904. +                       adev->params.cecm,
  905. +                       adev->params.hdcpm,
  906. +                       AV8100_GENERAL_INTERRUPT_MASK_UOVBM_HIGH,
  907. +                       AV8100_GENERAL_INTERRUPT_MASK_TEM_LOW))
  908. +               dev_dbg(adev->dev, "av8100_reg_gen_int_mask_w err\n");
  909. +
  910. +       av8100_set_state(adev, AV8100_OPMODE_VIDEO);
  911.  
  912.         return 0;
  913.  }
  914. -EXPORT_SYMBOL(av8100_hdmi_video_off);
  915. +EXPORT_SYMBOL(av8100_hdmi_video_on);
  916.  
  917. -int av8100_powerwakeup(bool disp_user)
  918. +void av8100_conf_lock(void)
  919.  {
  920.         struct av8100_device *adev;
  921. -       int ret = 0;
  922.  
  923.         adev = devnr_to_adev(AV8100_DEVNR_DEFAULT);
  924.         if (!adev)
  925. -               return -EFAULT;
  926. +               return;
  927.  
  928. -       dev_dbg(adev->dev, "%s %d\n", __func__, disp_user);
  929. +       LOCK_AV8100_CONF;
  930. +}
  931. +EXPORT_SYMBOL(av8100_conf_lock);
  932.  
  933. -       if (adev->params.suspended) {
  934. -               dev_dbg(adev->dev, "suspended\n");
  935. -               goto av8100_powerwakeup_end;
  936. -       }
  937. +void av8100_conf_unlock(void)
  938. +{
  939. +       struct av8100_device *adev;
  940.  
  941. -       if (disp_user) {
  942. -               adev->params.disp_on = true;
  943. -               if (av8100_status_get().av8100_state < AV8100_OPMODE_STANDBY)
  944. -                       ret = av8100_powerup();
  945. -       } else {
  946. -               if (av8100_status_get().av8100_state > AV8100_OPMODE_SHUTDOWN)
  947. -                       av8100_powerdown();
  948. +       adev = devnr_to_adev(AV8100_DEVNR_DEFAULT);
  949. +       if (!adev)
  950. +               return;
  951.  
  952. -               set_hrtimer(adev, TIMER_POWERUP);
  953. -       }
  954. -av8100_powerwakeup_end:
  955. -       return ret;
  956. +       UNLOCK_AV8100_CONF;
  957.  }
  958. -EXPORT_SYMBOL(av8100_powerwakeup);
  959. +EXPORT_SYMBOL(av8100_conf_unlock);
  960.  
  961. -int av8100_powerscan(bool disp_user)
  962. +int av8100_powerwakeup(bool disp_user)
  963.  {
  964.         struct av8100_device *adev;
  965.         int ret = 0;
  966.  
  967.         adev = devnr_to_adev(AV8100_DEVNR_DEFAULT);
  968. -       if (!adev) {
  969. -               ret = -EFAULT;
  970. -               goto av8100_powerscan_end;
  971. -       }
  972. +       if (!adev)
  973. +               return -EFAULT;
  974.  
  975.         dev_dbg(adev->dev, "%s %d\n", __func__, disp_user);
  976.  
  977. -       if ((av8100_status_get().av8100_state < AV8100_OPMODE_STANDBY) ||
  978. -                                       (disp_user && !adev->params.disp_on))
  979. -               goto av8100_powerscan_end;
  980. +       if (adev->params.suspended) {
  981. +               dev_dbg(adev->dev, "suspended\n");
  982. +               goto av8100_powerwakeup_end;
  983. +       }
  984.  
  985.         if (disp_user)
  986. -               adev->params.disp_on = false;
  987. +               adev->params.disp_on = true;
  988.  
  989. -       if (adev->params.powerdown_scan ||
  990. -                               (disp_user && !adev->params.suspended)) {
  991. -               if (av8100_status_get().av8100_state > AV8100_OPMODE_SCAN) {
  992. -                       dev_dbg(adev->dev, "set to scan mode\n");
  993. -                       av8100_disable_interrupt();
  994. -                       adev->flag |= AV8100_SCAN_TIMER_EVENT;
  995. -                       wake_up_interruptible(&adev->event);
  996. -               }
  997. +       if (av8100_status_get().av8100_state < AV8100_OPMODE_STANDBY)
  998. +               ret = av8100_powerup();
  999.  
  1000. -               ret = av8100_5V_w(AV8100_DENC_OFF_TIME,
  1001. -                       adev->params.hdmi_off_time, adev->params.on_time);
  1002. -               set_hrtimer(adev, TIMER_POWERSCAN);
  1003. -       } else if (disp_user && adev->params.suspended) {
  1004. -               /* Allow for a final CEC to be sent before powerdown */
  1005. -               av8100_disable_interrupt();
  1006. -               clr_plug_status(adev, AV8100_HDMI_PLUGIN);
  1007. -               set_hrtimer(adev, TIMER_POWERDOWN);
  1008. -               adev->params.busy = true;
  1009. -       } else {
  1010. -               ret = av8100_powerdown();
  1011. -       }
  1012. -av8100_powerscan_end:
  1013. +av8100_powerwakeup_end:
  1014.         return ret;
  1015.  }
  1016. -EXPORT_SYMBOL(av8100_powerscan);
  1017. +EXPORT_SYMBOL(av8100_powerwakeup);
  1018.  
  1019.  int av8100_powerup(void)
  1020.  {
  1021. @@ -2980,7 +3139,7 @@
  1022.                 return -EFAULT;
  1023.  
  1024.         adev->params.busy = false;
  1025. -       adev->flag &= ~AV8100_EVENTS;
  1026. +       clr_flag(adev, AV8100_EVENTS | AV8100_INT_EVENT);
  1027.         adev->timer_flag = TIMER_UNSET;
  1028.         hrtimer_cancel(&adev->hrtimer);
  1029.         pdata = adev->dev->platform_data;
  1030. @@ -3026,6 +3185,8 @@
  1031.  
  1032.         gpio_set_value_cansleep(pdata->reset, 0);
  1033.  
  1034. +       adev->params.fw_loaded = false;
  1035. +
  1036.         /* Regulator disable */
  1037.         if ((adev->params.regulator_pwr) &&
  1038.                         (adev->params.regulator_requested)) {
  1039. @@ -3343,8 +3504,8 @@
  1040.  av8100_download_firmware_err2:
  1041.         UNLOCK_AV8100_FWDL;
  1042.  
  1043. -       adev->flag |= AV8100_SCAN_TIMER_EVENT;
  1044. -       wake_up_interruptible(&adev->event);
  1045. +       if (!adev->params.suspended)
  1046. +               set_flag(adev, AV8100_SCAN_TIMER_EVENT);
  1047.  
  1048.         return retval;
  1049.  }
  1050. @@ -3443,6 +3604,11 @@
  1051.  {
  1052.         int retval;
  1053.         u8 val;
  1054. +       struct av8100_device *adev;
  1055. +
  1056. +       adev = devnr_to_adev(AV8100_DEVNR_DEFAULT);
  1057. +       if (!adev)
  1058. +               return -EINVAL;
  1059.  
  1060.         if (av8100_status_get().av8100_state <= AV8100_OPMODE_SHUTDOWN)
  1061.                 return -EINVAL;
  1062. @@ -3556,6 +3722,11 @@
  1063.  {
  1064.         int retval;
  1065.         u8 val;
  1066. +       struct av8100_device *adev;
  1067. +
  1068. +       adev = devnr_to_adev(AV8100_DEVNR_DEFAULT);
  1069. +       if (!adev)
  1070. +               return -EINVAL;
  1071.  
  1072.         if (av8100_status_get().av8100_state <= AV8100_OPMODE_SHUTDOWN)
  1073.                 return -EINVAL;
  1074. @@ -3583,6 +3754,11 @@
  1075.  {
  1076.         int retval;
  1077.         u8 val;
  1078. +       struct av8100_device *adev;
  1079. +
  1080. +       adev = devnr_to_adev(AV8100_DEVNR_DEFAULT);
  1081. +       if (!adev)
  1082. +               return -EINVAL;
  1083.  
  1084.         if (av8100_status_get().av8100_state <= AV8100_OPMODE_SHUTDOWN)
  1085.                 return -EINVAL;
  1086. @@ -3611,6 +3787,11 @@
  1087.  {
  1088.         int retval;
  1089.         u8 val;
  1090. +       struct av8100_device *adev;
  1091. +
  1092. +       adev = devnr_to_adev(AV8100_DEVNR_DEFAULT);
  1093. +       if (!adev)
  1094. +               return -EINVAL;
  1095.  
  1096.         if (av8100_status_get().av8100_state <= AV8100_OPMODE_SHUTDOWN)
  1097.                 return -EINVAL;
  1098. @@ -3638,6 +3819,11 @@
  1099.  {
  1100.         int retval;
  1101.         u8 val;
  1102. +       struct av8100_device *adev;
  1103. +
  1104. +       adev = devnr_to_adev(AV8100_DEVNR_DEFAULT);
  1105. +       if (!adev)
  1106. +               return -EINVAL;
  1107.  
  1108.         if (av8100_status_get().av8100_state <= AV8100_OPMODE_SHUTDOWN)
  1109.                 return -EINVAL;
  1110. @@ -3665,6 +3851,11 @@
  1111.  {
  1112.         int retval;
  1113.         u8 val;
  1114. +       struct av8100_device *adev;
  1115. +
  1116. +       adev = devnr_to_adev(AV8100_DEVNR_DEFAULT);
  1117. +       if (!adev)
  1118. +               return -EINVAL;
  1119.  
  1120.         if (av8100_status_get().av8100_state <= AV8100_OPMODE_SHUTDOWN)
  1121.                 return -EINVAL;
  1122. @@ -3689,6 +3880,11 @@
  1123.  {
  1124.         int retval;
  1125.         u8 val;
  1126. +       struct av8100_device *adev;
  1127. +
  1128. +       adev = devnr_to_adev(AV8100_DEVNR_DEFAULT);
  1129. +       if (!adev)
  1130. +               return -EINVAL;
  1131.  
  1132.         if (av8100_status_get().av8100_state <= AV8100_OPMODE_SHUTDOWN)
  1133.                 return -EINVAL;
  1134. @@ -3743,6 +3939,11 @@
  1135.  {
  1136.         int retval;
  1137.         u8 val;
  1138. +       struct av8100_device *adev;
  1139. +
  1140. +       adev = devnr_to_adev(AV8100_DEVNR_DEFAULT);
  1141. +       if (!adev)
  1142. +               return -EINVAL;
  1143.  
  1144.         if (av8100_status_get().av8100_state <= AV8100_OPMODE_SHUTDOWN)
  1145.                 return -EINVAL;
  1146. @@ -3817,6 +4018,11 @@
  1147.  {
  1148.         int retval;
  1149.         u8 val;
  1150. +       struct av8100_device *adev;
  1151. +
  1152. +       adev = devnr_to_adev(AV8100_DEVNR_DEFAULT);
  1153. +       if (!adev)
  1154. +               return -EINVAL;
  1155.  
  1156.         if (av8100_status_get().av8100_state <= AV8100_OPMODE_SHUTDOWN)
  1157.                 return -EINVAL;
  1158. @@ -3847,6 +4053,11 @@
  1159.  {
  1160.         int retval;
  1161.         u8 val;
  1162. +       struct av8100_device *adev;
  1163. +
  1164. +       adev = devnr_to_adev(AV8100_DEVNR_DEFAULT);
  1165. +       if (!adev)
  1166. +               return -EINVAL;
  1167.  
  1168.         if (av8100_status_get().av8100_state <= AV8100_OPMODE_SHUTDOWN)
  1169.                 return -EINVAL;
  1170. @@ -3885,6 +4096,11 @@
  1171.  {
  1172.         int retval;
  1173.         u8 val;
  1174. +       struct av8100_device *adev;
  1175. +
  1176. +       adev = devnr_to_adev(AV8100_DEVNR_DEFAULT);
  1177. +       if (!adev)
  1178. +               return -EINVAL;
  1179.  
  1180.         if (av8100_status_get().av8100_state <= AV8100_OPMODE_SHUTDOWN)
  1181.                 return -EINVAL;
  1182. @@ -3926,6 +4142,11 @@
  1183.  {
  1184.         int retval;
  1185.         u8 val;
  1186. +       struct av8100_device *adev;
  1187. +
  1188. +       adev = devnr_to_adev(AV8100_DEVNR_DEFAULT);
  1189. +       if (!adev)
  1190. +               return -EINVAL;
  1191.  
  1192.         if (av8100_status_get().av8100_state <= AV8100_OPMODE_SHUTDOWN)
  1193.                 return -EINVAL;
  1194. @@ -3966,6 +4187,11 @@
  1195.  {
  1196.         int retval;
  1197.         u8 val;
  1198. +       struct av8100_device *adev;
  1199. +
  1200. +       adev = devnr_to_adev(AV8100_DEVNR_DEFAULT);
  1201. +       if (!adev)
  1202. +               return -EINVAL;
  1203.  
  1204.         if (av8100_status_get().av8100_state <= AV8100_OPMODE_SHUTDOWN)
  1205.                 return -EINVAL;
  1206. @@ -4005,6 +4231,11 @@
  1207.  {
  1208.         int retval;
  1209.         u8 val;
  1210. +       struct av8100_device *adev;
  1211. +
  1212. +       adev = devnr_to_adev(AV8100_DEVNR_DEFAULT);
  1213. +       if (!adev)
  1214. +               return -EINVAL;
  1215.  
  1216.         if (av8100_status_get().av8100_state <= AV8100_OPMODE_SHUTDOWN)
  1217.                 return -EINVAL;
  1218. @@ -4043,6 +4274,11 @@
  1219.  {
  1220.         int retval;
  1221.         u8 val;
  1222. +       struct av8100_device *adev;
  1223. +
  1224. +       adev = devnr_to_adev(AV8100_DEVNR_DEFAULT);
  1225. +       if (!adev)
  1226. +               return -EINVAL;
  1227.  
  1228.         if (av8100_status_get().av8100_state <= AV8100_OPMODE_SHUTDOWN)
  1229.                 return -EINVAL;
  1230. @@ -4071,6 +4307,11 @@
  1231.  {
  1232.         int retval;
  1233.         u8 val;
  1234. +       struct av8100_device *adev;
  1235. +
  1236. +       adev = devnr_to_adev(AV8100_DEVNR_DEFAULT);
  1237. +       if (!adev)
  1238. +               return -EINVAL;
  1239.  
  1240.         if (av8100_status_get().av8100_state <= AV8100_OPMODE_SHUTDOWN)
  1241.                 return -EINVAL;
  1242. @@ -4506,10 +4747,8 @@
  1243.                         cnt++;
  1244.                 }
  1245.                 dev_dbg(adev->dev, "first return cnt:%d\n", cnt);
  1246. -               if (cnt == cnt_max) {
  1247. -                       adev->flag |= AV8100_CHECK_HW_STATUS_EVENT;
  1248. -                       wake_up_interruptible(&adev->event);
  1249. -               }
  1250. +               if (cnt == cnt_max)
  1251. +                       set_flag(adev, AV8100_CHECK_HW_STATUS_EVENT);
  1252.  
  1253.                 if (retval) {
  1254.                         UNLOCK_AV8100_HW;
  1255. @@ -4596,10 +4835,9 @@
  1256.                 cnt++;
  1257.         }
  1258.         dev_dbg(adev->dev, "first return cnt:%d\n", cnt);
  1259. -       if (cnt == cnt_max) {
  1260. -               adev->flag |= AV8100_CHECK_HW_STATUS_EVENT;
  1261. -               wake_up_interruptible(&adev->event);
  1262. -       }
  1263. +       if (cnt == cnt_max)
  1264. +               set_flag(adev, AV8100_CHECK_HW_STATUS_EVENT);
  1265. +
  1266.         if (retval)
  1267.                 goto av8100_conf_w_raw_out;
  1268.  
  1269. @@ -4747,6 +4985,11 @@
  1270.         struct av8100_device *adev =
  1271.                 container_of(data, struct av8100_device, early_suspend);
  1272.  
  1273. +       set_flag(adev, AV8100_EARLY_SUSPEND_EVENT);
  1274. +}
  1275. +
  1276. +static void early_suspend_handle(struct av8100_device *adev)
  1277. +{
  1278.         if (!adev->params.disp_on)
  1279.                 (void)av8100_powerscan(false);
  1280.         adev->params.suspended = true;
  1281. @@ -4757,8 +5000,34 @@
  1282.         struct av8100_device *adev =
  1283.                 container_of(data, struct av8100_device, early_suspend);
  1284.  
  1285. +       set_flag(adev, AV8100_LATE_RESUME_EVENT);
  1286. +}
  1287. +
  1288. +static void late_resume_pd_cancel(struct av8100_device *adev)
  1289. +{
  1290. +       u8 hpds;
  1291. +
  1292. +       adev->params.busy = false;
  1293. +       adev->timer_flag = TIMER_UNSET;
  1294. +       if (av8100_status_get().av8100_state <= AV8100_OPMODE_SHUTDOWN)
  1295. +               return;
  1296. +
  1297. +       av8100_enable_interrupt();
  1298. +       if ((av8100_reg_stby_r(NULL, NULL, &hpds, NULL, NULL)) == 0)
  1299. +               if (hpds)
  1300. +                       set_plug_status(adev, AV8100_HDMI_PLUGIN);
  1301. +}
  1302. +
  1303. +static void late_resume_handle(struct av8100_device *adev)
  1304. +{
  1305.         adev->params.suspended = false;
  1306. -       (void)av8100_powerwakeup(false);
  1307. +       if (!adev->params.disp_on) {
  1308. +               if (adev->timer_flag == TIMER_POWERDOWN)
  1309. +                       late_resume_pd_cancel(adev);
  1310. +               clr_flag(adev, AV8100_EVENTS);
  1311. +               hrtimer_cancel(&adev->hrtimer);
  1312. +               (void)av8100_powerwakeup(false);
  1313. +       }
  1314.  }
  1315.  
  1316.  static int av8100_open(struct inode *inode, struct file *filp)
  1317. @@ -4805,6 +5074,13 @@
  1318.                 dev_info(dev, "av8100_params_init failed\n");
  1319.                 return -EFAULT;
  1320.         }
  1321. +
  1322. +       mutex_init(&adev->hw_mutex);
  1323. +       mutex_init(&adev->fwdl_mutex);
  1324. +       mutex_init(&adev->usrcnt_mutex);
  1325. +       mutex_init(&adev->conf_mutex);
  1326. +       spin_lock_init(&adev->flag_lock);
  1327. +
  1328.         return 0;
  1329.  }
  1330.  
  1331. diff -ruN .a/drivers/video/av8100/hdmi.c .b/drivers/video/av8100/hdmi.c
  1332. --- .a/drivers/video/av8100/hdmi.c      2012-10-23 21:38:06.000000000 +0900
  1333. +++ .b/drivers/video/av8100/hdmi.c      2013-01-08 21:13:47.000000000 +0900
  1334. @@ -409,6 +409,7 @@
  1335.  {
  1336.         union av8100_configuration config;
  1337.         struct av8100_status status;
  1338. +       int ret = 0;
  1339.  
  1340.         status = av8100_status_get();
  1341.         if (status.av8100_state < AV8100_OPMODE_STANDBY)
  1342. @@ -429,19 +430,24 @@
  1343.         config.infoframes_format.crc = crc;
  1344.         config.infoframes_format.length = data_len;
  1345.         memcpy(&config.infoframes_format.data, data, data_len);
  1346. +       av8100_conf_lock();
  1347.         if (av8100_conf_prep(AV8100_COMMAND_INFOFRAMES,
  1348.                 &config) != 0) {
  1349.                 dev_err(hdev->dev, "av8100_conf_prep FAIL\n");
  1350. -               return -EINVAL;
  1351. +               ret = -EINVAL;
  1352. +               goto infofrsend_end;
  1353.         }
  1354.  
  1355.         if (av8100_conf_w(AV8100_COMMAND_INFOFRAMES,
  1356.                 NULL, NULL, I2C_INTERFACE) != 0) {
  1357.                 dev_err(hdev->dev, "av8100_conf_w FAIL\n");
  1358. -               return -EINVAL;
  1359. +               ret = -EINVAL;
  1360. +               goto infofrsend_end;
  1361.         }
  1362.  
  1363. -       return 0;
  1364. +infofrsend_end:
  1365. +       av8100_conf_unlock();
  1366. +       return ret;
  1367.  }
  1368.  
  1369.  static int hdcpchkaesotp(struct hdmi_device *hdev, u8 *crc, u8 *progged)
  1370. @@ -696,6 +702,7 @@
  1371.  {
  1372.         union av8100_configuration config;
  1373.         struct av8100_status status;
  1374. +       int ret = 0;
  1375.  
  1376.         status = av8100_status_get();
  1377.         if (status.av8100_state < AV8100_OPMODE_STANDBY) {
  1378. @@ -720,19 +727,24 @@
  1379.         config.audio_input_format.audio_if_mode         = cfg->if_mode;
  1380.         config.audio_input_format.audio_mute            = cfg->mute;
  1381.  
  1382. +       av8100_conf_lock();
  1383.         if (av8100_conf_prep(AV8100_COMMAND_AUDIO_INPUT_FORMAT,
  1384.                 &config) != 0) {
  1385.                 dev_err(hdev->dev, "av8100_conf_prep FAIL\n");
  1386. -               return -EINVAL;
  1387. +               ret = -EINVAL;
  1388. +               goto audiocfg_end;
  1389.         }
  1390.  
  1391.         if (av8100_conf_w(AV8100_COMMAND_AUDIO_INPUT_FORMAT,
  1392.                 NULL, NULL, I2C_INTERFACE) != 0) {
  1393.                 dev_err(hdev->dev, "av8100_conf_w FAIL\n");
  1394. -               return -EINVAL;
  1395. +               ret = -EINVAL;
  1396. +               goto audiocfg_end;
  1397.         }
  1398.  
  1399. -       return 0;
  1400. +audiocfg_end:
  1401. +       av8100_conf_unlock();
  1402. +       return ret;
  1403.  }
  1404.  
  1405.  /* sysfs */
  1406. @@ -2162,15 +2174,19 @@
  1407.                 else
  1408.                         config.hdmi_format.hdmi_mode = AV8100_HDMI_ON;
  1409.  
  1410. +               av8100_conf_lock();
  1411.                 if (av8100_conf_prep(AV8100_COMMAND_HDMI, &config) != 0) {
  1412.                         dev_err(hdev->dev, "av8100_conf_prep FAIL\n");
  1413. +                       av8100_conf_unlock();
  1414.                         return -EINVAL;
  1415.                 }
  1416.                 if (av8100_conf_w(AV8100_COMMAND_HDMI, NULL, NULL,
  1417.                         I2C_INTERFACE) != 0) {
  1418.                         dev_err(hdev->dev, "av8100_conf_w FAIL\n");
  1419. +                       av8100_conf_unlock();
  1420.                         return -EINVAL;
  1421.                 }
  1422. +               av8100_conf_unlock();
  1423.                 }
  1424.                 break;
  1425.  
  1426. diff -ruN .a/drivers/video/mcde/display-av8100.c .b/drivers/video/mcde/display-av8100.c
  1427. --- .a/drivers/video/mcde/display-av8100.c      2012-10-23 21:38:06.000000000 +0900
  1428. +++ .b/drivers/video/mcde/display-av8100.c      2013-01-08 21:13:47.000000000 +0900
  1429. @@ -972,34 +972,48 @@
  1430.                 }
  1431.         }
  1432.  
  1433. +       av8100_conf_lock();
  1434. +
  1435.         /*
  1436.          * Don't look at dev->port->hdmi_sdtv_switch; it states only which
  1437.          * one should be started, not which one is currently working
  1438.          */
  1439. -       if (av8100_conf_get(AV8100_COMMAND_HDMI, &av8100_config))
  1440. -               return -EFAULT;
  1441. +       if (av8100_conf_get(AV8100_COMMAND_HDMI, &av8100_config)) {
  1442. +               ret = -EFAULT;
  1443. +               goto hdmi_set_video_mode_end;
  1444. +       }
  1445.         if (av8100_config.hdmi_format.hdmi_mode == AV8100_HDMI_ON) {
  1446.                 /* Set HDMI mode to OFF */
  1447.                 av8100_config.hdmi_format.hdmi_mode = AV8100_HDMI_OFF;
  1448.                 av8100_config.hdmi_format.dvi_format = AV8100_DVI_CTRL_CTL0;
  1449.                 av8100_config.hdmi_format.hdmi_format = AV8100_HDMI;
  1450. -               if (av8100_conf_prep(AV8100_COMMAND_HDMI, &av8100_config))
  1451. -                       return -EFAULT;
  1452. +               if (av8100_conf_prep(AV8100_COMMAND_HDMI, &av8100_config)) {
  1453. +                       ret = -EFAULT;
  1454. +                       goto hdmi_set_video_mode_end;
  1455. +               }
  1456.  
  1457.                 if (av8100_conf_w(AV8100_COMMAND_HDMI, NULL, NULL,
  1458. -                                                               I2C_INTERFACE))
  1459. -                       return -EFAULT;
  1460. +                                                       I2C_INTERFACE)) {
  1461. +                       ret = -EFAULT;
  1462. +                       goto hdmi_set_video_mode_end;
  1463. +               }
  1464. +       }
  1465. +       if (av8100_conf_get(AV8100_COMMAND_DENC, &av8100_config)) {
  1466. +               ret = -EFAULT;
  1467. +               goto hdmi_set_video_mode_end;
  1468.         }
  1469. -       if (av8100_conf_get(AV8100_COMMAND_DENC, &av8100_config))
  1470. -               return -EFAULT;
  1471.         if (av8100_config.denc_format.enable) {
  1472.                 /* Turn off DENC */
  1473.                 av8100_config.denc_format.enable = 0;
  1474. -               if (av8100_conf_prep(AV8100_COMMAND_DENC, &av8100_config))
  1475. -                       return -EFAULT;
  1476. +               if (av8100_conf_prep(AV8100_COMMAND_DENC, &av8100_config)) {
  1477. +                       ret = -EFAULT;
  1478. +                       goto hdmi_set_video_mode_end;
  1479. +               }
  1480.                 if (av8100_conf_w(AV8100_COMMAND_DENC, NULL, NULL,
  1481. -                                                               I2C_INTERFACE))
  1482. -                       return -EFAULT;
  1483. +                                                       I2C_INTERFACE)) {
  1484. +                       ret = -EFAULT;
  1485. +                       goto hdmi_set_video_mode_end;
  1486. +               }
  1487.         }
  1488.  
  1489.         /* Get current av8100 video output format */
  1490. @@ -1009,7 +1023,7 @@
  1491.                 dev_err(&dev->dev, "%s:av8100_conf_get "
  1492.                         "AV8100_COMMAND_VIDEO_OUTPUT_FORMAT failed\n",
  1493.                         __func__);
  1494. -               return ret;
  1495. +               goto hdmi_set_video_mode_end;
  1496.         }
  1497.  
  1498.         if (dev->port->hdmi_sdtv_switch == SDTV_SWITCH)
  1499. @@ -1033,7 +1047,7 @@
  1500.                 av8100_config.video_output_format.video_output_cea_vesa) {
  1501.                 dev_err(&dev->dev, "%s:video output format not found "
  1502.                         "\n", __func__);
  1503. -               return ret;
  1504. +               goto hdmi_set_video_mode_end;
  1505.         }
  1506.  
  1507.         ret = av8100_conf_prep(AV8100_COMMAND_VIDEO_OUTPUT_FORMAT,
  1508. @@ -1042,7 +1056,7 @@
  1509.                 dev_err(&dev->dev, "%s:av8100_conf_prep "
  1510.                         "AV8100_COMMAND_VIDEO_OUTPUT_FORMAT failed\n",
  1511.                         __func__);
  1512. -               return ret;
  1513. +               goto hdmi_set_video_mode_end;
  1514.         }
  1515.  
  1516.         /* Get current av8100 video input format */
  1517. @@ -1052,7 +1066,7 @@
  1518.                 dev_err(&dev->dev, "%s:av8100_conf_get "
  1519.                         "AV8100_COMMAND_VIDEO_INPUT_FORMAT failed\n",
  1520.                         __func__);
  1521. -               return ret;
  1522. +               goto hdmi_set_video_mode_end;
  1523.         }
  1524.  
  1525.         /* Set correct av8100 video input pixel format */
  1526. @@ -1107,7 +1121,7 @@
  1527.                 dev_err(&dev->dev, "%s:av8100_conf_prep "
  1528.                                 "AV8100_COMMAND_VIDEO_INPUT_FORMAT failed\n",
  1529.                                 __func__);
  1530. -               return ret;
  1531. +               goto hdmi_set_video_mode_end;
  1532.         }
  1533.  
  1534.         ret = av8100_conf_w(AV8100_COMMAND_VIDEO_INPUT_FORMAT,
  1535. @@ -1116,7 +1130,7 @@
  1536.                 dev_err(&dev->dev, "%s:av8100_conf_w "
  1537.                                 "AV8100_COMMAND_VIDEO_INPUT_FORMAT failed\n",
  1538.                                 __func__);
  1539. -               return ret;
  1540. +               goto hdmi_set_video_mode_end;
  1541.         }
  1542.  
  1543.         if (dev->port->hdmi_sdtv_switch == SDTV_SWITCH) {
  1544. @@ -1141,7 +1155,7 @@
  1545.                 dev_err(&dev->dev, "%s:av8100_configuration_prepare "
  1546.                         "AV8100_COMMAND_COLORSPACECONVERSION failed\n",
  1547.                         __func__);
  1548. -               return ret;
  1549. +               goto hdmi_set_video_mode_end;
  1550.         }
  1551.  
  1552.         ret = av8100_conf_w(
  1553. @@ -1151,7 +1165,7 @@
  1554.                 dev_err(&dev->dev, "%s:av8100_conf_w "
  1555.                         "AV8100_COMMAND_COLORSPACECONVERSION failed\n",
  1556.                         __func__);
  1557. -               return ret;
  1558. +               goto hdmi_set_video_mode_end;
  1559.         }
  1560.  
  1561.         /* Set video output format */
  1562. @@ -1159,7 +1173,7 @@
  1563.                 NULL, NULL, I2C_INTERFACE);
  1564.         if (ret) {
  1565.                 dev_err(&dev->dev, "av8100_conf_w failed\n");
  1566. -               return ret;
  1567. +               goto hdmi_set_video_mode_end;
  1568.         }
  1569.  
  1570.         /* Set audio input format */
  1571. @@ -1169,13 +1183,16 @@
  1572.                 dev_err(&dev->dev, "%s:av8100_conf_w "
  1573.                                 "AV8100_COMMAND_AUDIO_INPUT_FORMAT failed\n",
  1574.                         __func__);
  1575. -               return ret;
  1576. +               goto hdmi_set_video_mode_end;
  1577.         }
  1578.  
  1579.         dev->update_flags |= UPDATE_FLAG_VIDEO_MODE;
  1580.         dev->first_update = true;
  1581.  
  1582. -       return 0;
  1583. +hdmi_set_video_mode_end:
  1584. +       av8100_conf_unlock();
  1585. +
  1586. +       return ret;
  1587.  }
  1588.  
  1589.  static u16 rotate_byte_left(u8 c, int nr)
  1590. @@ -1264,10 +1281,13 @@
  1591.          * Only one of them should be enabled.
  1592.          * Note HDMI/DVI and DENC are always turned off in set_video_mode.
  1593.          */
  1594. +       av8100_conf_lock();
  1595.         switch (dev->port->hdmi_sdtv_switch) {
  1596.         case SDTV_SWITCH:
  1597. -               if (av8100_conf_get(AV8100_COMMAND_DENC, &av8100_config))
  1598. -                       return -EFAULT;
  1599. +               if (av8100_conf_get(AV8100_COMMAND_DENC, &av8100_config)) {
  1600. +                       ret = -EFAULT;
  1601. +                       goto hdmi_on_first_update_end;
  1602. +               }
  1603.                 av8100_config.denc_format.enable = 1;
  1604.                 if (dev->video_mode.yres == NATIVE_YRES_SDTV) {
  1605.                         av8100_config.denc_format.standard_selection =
  1606. @@ -1300,7 +1320,7 @@
  1607.         if (ret) {
  1608.                 dev_err(&dev->dev, "%s:av8100_conf_prep "
  1609.                         "AV8100_COMMAND_HDMI/DENC failed\n", __func__);
  1610. -               return ret;
  1611. +               goto hdmi_on_first_update_end;
  1612.         }
  1613.  
  1614.         if (dev->port->hdmi_sdtv_switch == SDTV_SWITCH)
  1615. @@ -1312,12 +1332,16 @@
  1616.         if (ret) {
  1617.                 dev_err(&dev->dev, "%s:av8100_conf_w "
  1618.                         "AV8100_COMMAND_HDMI/DENC failed\n", __func__);
  1619. -               return ret;
  1620. +               goto hdmi_on_first_update_end;
  1621.         }
  1622. -
  1623. +hdmi_on_first_update_end:
  1624. +       av8100_conf_unlock();
  1625.         return ret;
  1626.  }
  1627.  
  1628. +#define HDMI_GET_RETRY_TIME    500000
  1629. +#define HDMI_GET_RETRY_CNT_MAX 4
  1630. +
  1631.  static int hdmi_set_power_mode(struct mcde_display_device *ddev,
  1632.         enum mcde_display_power_mode power_mode)
  1633.  {
  1634. @@ -1327,6 +1351,9 @@
  1635.         /* OFF -> STANDBY */
  1636.         if (ddev->power_mode == MCDE_DISPLAY_PM_OFF &&
  1637.                                         power_mode != MCDE_DISPLAY_PM_OFF) {
  1638. +               int cnt;
  1639. +               int get_res;
  1640. +
  1641.                 /*
  1642.                  * the regulator for analog TV out is only enabled here,
  1643.                  * this means that one needs to switch to the OFF state
  1644. @@ -1341,9 +1368,21 @@
  1645.                 ddev->power_mode = MCDE_DISPLAY_PM_STANDBY;
  1646.  
  1647.                 /* Get HDMI resource */
  1648. -               av8100_hdmi_get();
  1649. +               for (cnt = 0; cnt < HDMI_GET_RETRY_CNT_MAX; cnt++) {
  1650. +                       get_res = av8100_hdmi_get(AV8100_HDMI_USER_VIDEO);
  1651. +                       if (get_res >= 0)
  1652. +                               break;
  1653. +                       else
  1654. +                               usleep_range(HDMI_GET_RETRY_TIME,
  1655. +                                               HDMI_GET_RETRY_TIME * 12 / 10);
  1656. +               }
  1657.  
  1658. -               hdmi_set_port_pixel_format(ddev);
  1659. +               if (get_res < 0)
  1660. +                       return -EFAULT;
  1661. +               else if (get_res > 1)
  1662. +                       av8100_hdmi_video_on();
  1663. +               else
  1664. +                       hdmi_set_port_pixel_format(ddev);
  1665.         }
  1666.         /* STANDBY -> ON */
  1667.         if (ddev->power_mode == MCDE_DISPLAY_PM_STANDBY &&
  1668. @@ -1364,8 +1403,8 @@
  1669.                 memset(&(ddev->video_mode), 0, sizeof(struct mcde_video_mode));
  1670.  
  1671.                 /* Put HDMI resource */
  1672. -               if (av8100_hdmi_put()) {
  1673. -                       /* Audio is still used; disable video */
  1674. +               if (av8100_hdmi_put(AV8100_HDMI_USER_VIDEO)) {
  1675. +                       /* Audio is still used */
  1676.                         av8100_hdmi_video_off();
  1677.                 }
  1678.  
  1679. diff -ruN .a/drivers/video/mcde/mcde_hw.c .b/drivers/video/mcde/mcde_hw.c
  1680. --- .a/drivers/video/mcde/mcde_hw.c     2012-10-23 21:38:06.000000000 +0900
  1681. +++ .b/drivers/video/mcde/mcde_hw.c     2013-01-08 21:13:47.000000000 +0900
  1682. @@ -3533,6 +3533,9 @@
  1683.  static int _mcde_chnl_enable(struct mcde_chnl_state *chnl)
  1684.  {
  1685.         dev_vdbg(&mcde_dev->dev, "%s\n", __func__);
  1686. +       if (!chnl)
  1687. +               return -EINVAL;
  1688. +
  1689.         chnl->enabled = true;
  1690.         chnl->first_frame_vsync_fix = true;
  1691.         return 0;
  1692. @@ -3676,7 +3679,7 @@
  1693.  {
  1694.         dev_vdbg(&mcde_dev->dev, "%s\n", __func__);
  1695.  
  1696. -       if (!chnl->reserved)
  1697. +       if (!chnl || !chnl->reserved)
  1698.                 return -EINVAL;
  1699.  
  1700.         chnl->power_mode = power_mode;
  1701. diff -ruN .a/include/video/av8100.h .b/include/video/av8100.h
  1702. --- .a/include/video/av8100.h   2012-10-23 21:38:06.000000000 +0900
  1703. +++ .b/include/video/av8100.h   2013-01-08 21:13:47.000000000 +0900
  1704. @@ -201,6 +201,11 @@
  1705.         AV8100_PATTERN_AUDIO_I2S_MEM
  1706.  };
  1707.  
  1708. +enum av8100_hdmi_user {
  1709. +       AV8100_HDMI_USER_AUDIO,
  1710. +       AV8100_HDMI_USER_VIDEO
  1711. +};
  1712. +
  1713.  struct av8100_video_input_format_cmd {
  1714.         enum av8100_dsi_mode            dsi_input_mode;
  1715.         enum av8100_pixel_format        input_pixel_format;
  1716. @@ -409,11 +414,13 @@
  1717.  
  1718.  int av8100_init(void);
  1719.  void av8100_exit(void);
  1720. -int av8100_hdmi_get(void);
  1721. -int av8100_hdmi_put(void);
  1722. +int av8100_hdmi_get(enum av8100_hdmi_user user);
  1723. +int av8100_hdmi_put(enum av8100_hdmi_user user);
  1724.  int av8100_hdmi_video_off(void);
  1725. +int av8100_hdmi_video_on(void);
  1726. +void av8100_conf_lock(void);
  1727. +void av8100_conf_unlock(void);
  1728.  int av8100_powerwakeup(bool from_scan_mode);
  1729. -int av8100_powerscan(bool to_scan_mode);
  1730.  int av8100_powerup(void);
  1731.  int av8100_powerdown(void);
  1732.  int av8100_disable_interrupt(void);
  1733. diff -ruN .a/kernel-build-sin.sh .b/kernel-build-sin.sh
  1734. --- .a/kernel-build-sin.sh      2012-10-23 21:38:06.000000000 +0900
  1735. +++ .b/kernel-build-sin.sh      1970-01-01 09:00:00.000000000 +0900
  1736. @@ -1,102 +0,0 @@
  1737. -#!/bin/bash
  1738. -
  1739. -die () {
  1740. -    echo >&2 "$@"
  1741. -    exit 1
  1742. -}
  1743. -
  1744. -PRODUCT_DEFCNFG=$1
  1745. -FSCONFIG=$2
  1746. -
  1747. -[ "$1" = "" ] && die "product{cdb/hayabusa/..} has to be specified as first argument"
  1748. -[ "$2" = "" ] && die "fsconfig.xml has to be specified as second argument"
  1749. -
  1750. -if [ ! -f "arch/arm/configs/${PRODUCT_DEFCNFG}" ]; then
  1751. -    # instead of specifying blue_cdb_defconfig, it could be 'cdb'
  1752. -    PRODUCT_DEFCNFG=riogrande_${PRODUCT_DEFCNFG}_defconfig
  1753. -fi
  1754. -
  1755. -if [ ! -f "arch/arm/configs/${PRODUCT_DEFCNFG}" ]; then
  1756. -    echo "Please use any of the following products:"
  1757. -    for line in $(ls arch/arm/configs/riogrande_*_defconfig);
  1758. -    do
  1759. -        NAME=$(basename $line)
  1760. -        echo " - $NAME"
  1761. -    done
  1762. -    exit 1
  1763. -fi
  1764. -
  1765. -if [ ! -f "$OUT/ramdisk.img" ]; then
  1766. -    echo "Missing ramdisk.img in $OUT"
  1767. -    exit 1
  1768. -fi
  1769. -
  1770. -echo "Using defconfig ${PRODUCT_DEFCNFG}"
  1771. -
  1772. -#---------------------------------------------------------------------
  1773. -# Check the actual number of CPUs on the machine and adjust the number
  1774. -#---------------------------------------------------------------------
  1775. -CPU_COUNT=`grep "^processor" /proc/cpuinfo | wc -l`
  1776. -if [ $? -eq 0 -a -n "$CPU_COUNT" ] ; then
  1777. -    JOBS=`expr $CPU_COUNT + 1`
  1778. -    echo Found $CPU_COUNT CPUs, building with $JOBS parallel jobs.
  1779. -else
  1780. -    JOBS=5
  1781. -    echo Unable to determine number of CPUs, defaulting to $JOBS parallel jobs.
  1782. -fi
  1783. -
  1784. -#------------------------------------------------------------
  1785. -# Need this to be able to build. Taken from kernel/Android.mk
  1786. -#------------------------------------------------------------
  1787. -export STERICSSON_WLAN_BUILT_IN=y
  1788. -
  1789. -if [ "$3" == "clean" ] ; then
  1790. -    echo 'Cleaning build...'
  1791. -    #-------------------
  1792. -    # Clean up the build
  1793. -    #-------------------
  1794. -    ARCH=arm CROSS_COMPILE=../prebuilt/linux-x86/toolchain/arm-eabi-4.4.3/bin/arm-eabi- make mrproper
  1795. -fi
  1796. -
  1797. -if [ ! -e ".config" ] ; then
  1798. -    echo 'No .config file, generating...'
  1799. -    #---------------------------
  1800. -    # kernel configuration setup
  1801. -    #---------------------------
  1802. -    ARCH=arm CROSS_COMPILE=../prebuilt/linux-x86/toolchain/arm-eabi-4.4.3/bin/arm-eabi- make $PRODUCT_DEFCNFG
  1803. -fi
  1804. -
  1805. -#------
  1806. -# Build
  1807. -#------
  1808. -ARCH=arm CROSS_COMPILE=../prebuilt/linux-x86/toolchain/arm-eabi-4.4.3/bin/arm-eabi- make -j$JOBS
  1809. -
  1810. -if [ $? -ne 0 ] ; then
  1811. -    echo "Build error - skip signing"
  1812. -    exit 1
  1813. -fi
  1814. -
  1815. -#------
  1816. -# Sign
  1817. -#------
  1818. -
  1819. -SIN_PATH=../vendor/semc/build/sin
  1820. -
  1821. -MKELFPY=$SIN_PATH/mkelf.py
  1822. -SEMCSC=$SIN_PATH/semcsc.py
  1823. -CSH=$SIN_PATH/create_sin_header
  1824. -
  1825. -# kernel.elf
  1826. -$MKELFPY -o kernel-unsigned.elf arch/arm/boot/zImage@0x00008000 \
  1827. -    $OUT/ramdisk.img@0x1000000,ramdisk $OUT/cmdline.txt@cmdline
  1828. -
  1829. -$SEMCSC -c $FSCONFIG -p Kernel -t internal -i kernel-unsigned.elf -o kernel.elf
  1830. -
  1831. -# kernel.si_
  1832. -$CSH Kernel $FSCONFIG kernel.si_
  1833. -cat kernel.elf >> kernel.si_
  1834. -
  1835. -# kernel.sin
  1836. -$SEMCSC -c $FSCONFIG -p Kernel -t external -i kernel.si_ -o kernel.sin
  1837. -
  1838. -echo "All done."
  1839. diff -ruN .a/net/compat-wireless/drivers/staging/cw1200/ap.c .b/net/compat-wireless/drivers/staging/cw1200/ap.c
  1840. --- .a/net/compat-wireless/drivers/staging/cw1200/ap.c  2012-10-23 21:38:07.000000000 +0900
  1841. +++ .b/net/compat-wireless/drivers/staging/cw1200/ap.c  2013-01-08 21:13:48.000000000 +0900
  1842. @@ -532,6 +532,17 @@
  1843.                                     MAX_BEACON_SKIP_TIME_MS ? 1 :
  1844.                                     priv->join_dtim_period, 0));
  1845.  
  1846. +                       if (sta && cw1200_is_ht(&priv->ht_info)) {
  1847. +                               if (priv->join_status == CW1200_JOIN_STATUS_STA &&
  1848. +                                   !priv->block_ack_enabled) {
  1849. +                                       ap_printk(KERN_DEBUG
  1850. +                                                 "[STA] Enabling Block ACK\n");
  1851. +                                       WARN_ON(wsm_set_block_ack_policy(priv,
  1852. +                                               priv->ba_tid_mask,
  1853. +                                               priv->ba_tid_mask));
  1854. +                                       priv->block_ack_enabled = true;
  1855. +                               }
  1856. +                       }
  1857.                         cw1200_set_pm(priv, &priv->powersave_mode);
  1858.                         if (priv->vif->p2p) {
  1859.                                 ap_printk(KERN_DEBUG
  1860. diff -ruN .a/net/compat-wireless/drivers/staging/cw1200/cw1200.h .b/net/compat-wireless/drivers/staging/cw1200/cw1200.h
  1861. --- .a/net/compat-wireless/drivers/staging/cw1200/cw1200.h      2012-10-23 21:38:07.000000000 +0900
  1862. +++ .b/net/compat-wireless/drivers/staging/cw1200/cw1200.h      2013-01-08 21:13:48.000000000 +0900
  1863. @@ -53,11 +53,6 @@
  1864.  
  1865.  #define CW1200_MAX_TID                 (8)
  1866.  
  1867. -#define CW1200_BLOCK_ACK_CNT           (30)
  1868. -#define CW1200_BLOCK_ACK_THLD          (800)
  1869. -#define CW1200_BLOCK_ACK_HIST          (3)
  1870. -#define CW1200_BLOCK_ACK_INTERVAL      (1 * HZ / CW1200_BLOCK_ACK_HIST)
  1871. -
  1872.  #define CW1200_JOIN_TIMEOUT            (1 * HZ)
  1873.  #define CW1200_AUTH_TIMEOUT            (5 * HZ)
  1874.  
  1875. @@ -172,15 +167,6 @@
  1876.         struct work_struct              update_filtering_work;
  1877.         struct work_struct              set_beacon_wakeup_period_work;
  1878.         u8                              ba_tid_mask;
  1879. -       int                             ba_acc;
  1880. -       int                             ba_cnt;
  1881. -       int                             ba_cnt_rx;
  1882. -       int                             ba_acc_rx;
  1883. -       int                             ba_hist;
  1884. -       struct timer_list               ba_timer;
  1885. -       spinlock_t                      ba_lock;
  1886. -       bool                            ba_ena;
  1887. -       struct work_struct              ba_work;
  1888.         struct cw1200_pm_state          pm_state;
  1889.         struct wsm_p2p_ps_modeinfo      p2p_ps_modeinfo;
  1890.         struct wsm_uapsd_info           uapsd_info;
  1891. @@ -306,6 +292,7 @@
  1892.         u8                      action_linkid;
  1893.  #endif
  1894.         atomic_t                hw_state;
  1895. +       bool                    block_ack_enabled;
  1896.  };
  1897.  
  1898.  struct cw1200_sta_priv {
  1899. diff -ruN .a/net/compat-wireless/drivers/staging/cw1200/debug.c .b/net/compat-wireless/drivers/staging/cw1200/debug.c
  1900. --- .a/net/compat-wireless/drivers/staging/cw1200/debug.c       2012-10-23 21:38:07.000000000 +0900
  1901. +++ .b/net/compat-wireless/drivers/staging/cw1200/debug.c       2013-01-08 21:13:48.000000000 +0900
  1902. @@ -112,20 +112,6 @@
  1903.         struct list_head *item;
  1904.         struct cw1200_common *priv = seq->private;
  1905.         struct cw1200_debug_priv *d = priv->debug;
  1906. -       int ba_cnt, ba_acc, ba_cnt_rx, ba_acc_rx, ba_avg = 0, ba_avg_rx = 0;
  1907. -       bool ba_ena;
  1908. -
  1909. -       spin_lock_bh(&priv->ba_lock);
  1910. -       ba_cnt = priv->debug->ba_cnt;
  1911. -       ba_acc = priv->debug->ba_acc;
  1912. -       ba_cnt_rx = priv->debug->ba_cnt_rx;
  1913. -       ba_acc_rx = priv->debug->ba_acc_rx;
  1914. -       ba_ena = priv->ba_ena;
  1915. -       if (ba_cnt)
  1916. -               ba_avg = ba_acc / ba_cnt;
  1917. -       if (ba_cnt_rx)
  1918. -               ba_avg_rx = ba_acc_rx / ba_cnt_rx;
  1919. -       spin_unlock_bh(&priv->ba_lock);
  1920.  
  1921.         seq_puts(seq,   "CW1200 Wireless LAN driver status\n");
  1922.         seq_printf(seq, "Hardware:   %d.%d\n",
  1923. @@ -238,11 +224,6 @@
  1924.                 ++i;
  1925.         spin_unlock_bh(&priv->tx_policy_cache.lock);
  1926.         seq_printf(seq, "RC in use:  %d\n", i);
  1927. -       seq_printf(seq, "BA stat:    %d, %d (%d)\n",
  1928. -               ba_cnt, ba_acc, ba_avg);
  1929. -       seq_printf(seq, "BA RX stat:    %d, %d (%d)\n",
  1930. -               ba_cnt_rx, ba_acc_rx, ba_avg_rx);
  1931. -       seq_printf(seq, "Block ACK:  %s\n", ba_ena ? "on" : "off");
  1932.  
  1933.         seq_puts(seq, "\n");
  1934.         for (i = 0; i < 4; ++i) {
  1935. diff -ruN .a/net/compat-wireless/drivers/staging/cw1200/debug.h .b/net/compat-wireless/drivers/staging/cw1200/debug.h
  1936. --- .a/net/compat-wireless/drivers/staging/cw1200/debug.h       2012-10-23 21:38:07.000000000 +0900
  1937. +++ .b/net/compat-wireless/drivers/staging/cw1200/debug.h       2013-01-08 21:13:48.000000000 +0900
  1938. @@ -45,10 +45,6 @@
  1939.         int tx_ttl;
  1940.         int tx_burst;
  1941.         int rx_burst;
  1942. -       int ba_cnt;
  1943. -       int ba_acc;
  1944. -       int ba_cnt_rx;
  1945. -       int ba_acc_rx;
  1946.  #ifdef CONFIG_CW1200_ITP
  1947.         struct cw1200_itp itp;
  1948.  #endif /* CONFIG_CW1200_ITP */
  1949. @@ -112,16 +108,6 @@
  1950.         ++priv->debug->rx_burst;
  1951.  }
  1952.  
  1953. -static inline void cw1200_debug_ba(struct cw1200_common *priv,
  1954. -                                  int ba_cnt, int ba_acc, int ba_cnt_rx,
  1955. -                                  int ba_acc_rx)
  1956. -{
  1957. -       priv->debug->ba_cnt = ba_cnt;
  1958. -       priv->debug->ba_acc = ba_acc;
  1959. -       priv->debug->ba_cnt_rx = ba_cnt_rx;
  1960. -       priv->debug->ba_acc_rx = ba_acc_rx;
  1961. -}
  1962. -
  1963.  int cw1200_print_fw_version(struct cw1200_common *priv, u8 *buf, size_t len);
  1964.  
  1965.  typedef enum {
  1966. @@ -202,11 +188,6 @@
  1967.  {
  1968.  }
  1969.  
  1970. -static inline void cw1200_debug_ba(struct cw1200_common *priv,
  1971. -                                  int ba_cnt, int ba_acc, int ba_cnt_rx, int ba_acc_rx)
  1972. -{
  1973. -}
  1974. -
  1975.  int cw1200_print_fw_version(struct cw1200_common *priv, u8 *buf, size_t len)
  1976.  {
  1977.  }
  1978. diff -ruN .a/net/compat-wireless/drivers/staging/cw1200/main.c .b/net/compat-wireless/drivers/staging/cw1200/main.c
  1979. --- .a/net/compat-wireless/drivers/staging/cw1200/main.c        2012-10-23 21:38:07.000000000 +0900
  1980. +++ .b/net/compat-wireless/drivers/staging/cw1200/main.c        2013-01-08 21:13:48.000000000 +0900
  1981. @@ -367,14 +367,9 @@
  1982.         INIT_WORK(&priv->update_filtering_work, cw1200_update_filtering_work);
  1983.         INIT_WORK(&priv->set_beacon_wakeup_period_work,
  1984.                 cw1200_set_beacon_wakeup_period_work);
  1985. -       INIT_WORK(&priv->ba_work, cw1200_ba_work);
  1986.         init_timer(&priv->mcast_timeout);
  1987.         priv->mcast_timeout.data = (unsigned long)priv;
  1988.         priv->mcast_timeout.function = cw1200_mcast_timeout;
  1989. -       spin_lock_init(&priv->ba_lock);
  1990. -       init_timer(&priv->ba_timer);
  1991. -       priv->ba_timer.data = (unsigned long)priv;
  1992. -       priv->ba_timer.function = cw1200_ba_timer;
  1993.         if (unlikely(cw1200_queue_stats_init(&priv->tx_queue_stats,
  1994.                         CW1200_LINK_ID_MAX,
  1995.                         cw1200_skb_dtor,
  1996. @@ -474,7 +469,6 @@
  1997.         ieee80211_unregister_hw(dev);
  1998.  
  1999.         del_timer_sync(&priv->mcast_timeout);
  2000. -       del_timer_sync(&priv->ba_timer);
  2001.  
  2002.         cw1200_debug_release(priv);
  2003.  
  2004. diff -ruN .a/net/compat-wireless/drivers/staging/cw1200/pm.c .b/net/compat-wireless/drivers/staging/cw1200/pm.c
  2005. --- .a/net/compat-wireless/drivers/staging/cw1200/pm.c  2012-10-23 21:38:07.000000000 +0900
  2006. +++ .b/net/compat-wireless/drivers/staging/cw1200/pm.c  2013-01-08 21:13:48.000000000 +0900
  2007. @@ -309,9 +309,6 @@
  2008.         if (ret)
  2009.                 goto revert5;
  2010.  
  2011. -       /* Cancel block ack stat timer */
  2012. -       del_timer_sync(&priv->ba_timer);
  2013. -
  2014.         /* Store suspend state */
  2015.         pm_state->suspend_state = state;
  2016.  
  2017. @@ -404,13 +401,6 @@
  2018.         cw1200_resume_work(priv, &priv->link_id_gc_work,
  2019.                         state->link_id_gc);
  2020.  
  2021. -       /* Restart block ack stat */
  2022. -       spin_lock_bh(&priv->ba_lock);
  2023. -       if (priv->ba_cnt)
  2024. -               mod_timer(&priv->ba_timer,
  2025. -                       jiffies + CW1200_BLOCK_ACK_INTERVAL);
  2026. -       spin_unlock_bh(&priv->ba_lock);
  2027. -
  2028.         /* Remove UDP port filter */
  2029.         wsm_set_udp_port_filter(priv, &cw1200_udp_port_filter_off);
  2030.  
  2031. diff -ruN .a/net/compat-wireless/drivers/staging/cw1200/sta.c .b/net/compat-wireless/drivers/staging/cw1200/sta.c
  2032. --- .a/net/compat-wireless/drivers/staging/cw1200/sta.c 2012-10-23 21:38:07.000000000 +0900
  2033. +++ .b/net/compat-wireless/drivers/staging/cw1200/sta.c 2013-01-08 21:13:48.000000000 +0900
  2034. @@ -101,6 +101,7 @@
  2035.         priv->cqm_link_loss_count = 60;
  2036.         priv->cqm_beacon_loss_count = 20;
  2037.  
  2038. +       priv->block_ack_enabled = false;
  2039.         /* Temporary configuration - beacon filter table */
  2040.         __cw1200_bf_configure(priv);
  2041.  
  2042. @@ -141,7 +142,6 @@
  2043.         cancel_delayed_work_sync(&priv->link_id_gc_work);
  2044.         flush_workqueue(priv->workqueue);
  2045.         del_timer_sync(&priv->mcast_timeout);
  2046. -       del_timer_sync(&priv->ba_timer);
  2047.  
  2048.         mutex_lock(&priv->conf_mutex);
  2049.         priv->mode = NL80211_IFTYPE_UNSPECIFIED;
  2050. @@ -1580,15 +1580,6 @@
  2051.                 WARN_ON(wsm_set_block_ack_policy(priv,
  2052.                         0, priv->ba_tid_mask));
  2053.  
  2054. -               spin_lock_bh(&priv->ba_lock);
  2055. -               priv->ba_ena = false;
  2056. -               priv->ba_cnt = 0;
  2057. -               priv->ba_acc = 0;
  2058. -               priv->ba_hist = 0;
  2059. -               priv->ba_cnt_rx = 0;
  2060. -               priv->ba_acc_rx = 0;
  2061. -               spin_unlock_bh(&priv->ba_lock);
  2062. -
  2063.                 mgmt_policy.protectedMgmtEnable = 0;
  2064.                 mgmt_policy.unprotectedMgmtFramesAllowed = 1;
  2065.                 mgmt_policy.encryptionForAuthFrame = 1;
  2066. @@ -1635,7 +1626,6 @@
  2067.         };
  2068.  
  2069.         cancel_delayed_work(&priv->join_timeout);
  2070. -       del_timer_sync(&priv->ba_timer);
  2071.         mutex_lock(&priv->conf_mutex);
  2072.         priv->join_pending = false;
  2073.         if (unlikely(atomic_read(&priv->scan.in_progress))) {
  2074. @@ -1678,6 +1668,7 @@
  2075.                 cw1200_update_listening(priv, priv->listening);
  2076.                 WARN_ON(wsm_set_block_ack_policy(priv,
  2077.                         0, priv->ba_tid_mask));
  2078. +               priv->block_ack_enabled = false;
  2079.                 priv->disable_beacon_filter = false;
  2080.                 cw1200_update_filtering(priv);
  2081.                 memset(&priv->association_mode, 0,
  2082. @@ -1780,72 +1771,6 @@
  2083.         return ret;
  2084.  }
  2085.  
  2086. -void cw1200_ba_work(struct work_struct *work)
  2087. -{
  2088. -       struct cw1200_common *priv =
  2089. -               container_of(work, struct cw1200_common, ba_work);
  2090. -       u8 tx_ba_tid_mask;
  2091. -
  2092. -       if (priv->join_status != CW1200_JOIN_STATUS_STA)
  2093. -               return;
  2094. -
  2095. -       spin_lock_bh(&priv->ba_lock);
  2096. -       tx_ba_tid_mask = priv->ba_ena ? priv->ba_tid_mask : 0;
  2097. -       spin_unlock_bh(&priv->ba_lock);
  2098. -
  2099. -       wsm_lock_tx(priv);
  2100. -
  2101. -       WARN_ON(wsm_set_block_ack_policy(priv,
  2102. -               tx_ba_tid_mask, priv->ba_tid_mask));
  2103. -
  2104. -       wsm_unlock_tx(priv);
  2105. -}
  2106. -
  2107. -void cw1200_ba_timer(unsigned long arg)
  2108. -{
  2109. -       bool ba_ena;
  2110. -       struct cw1200_common *priv =
  2111. -               (struct cw1200_common *)arg;
  2112. -
  2113. -       spin_lock_bh(&priv->ba_lock);
  2114. -       cw1200_debug_ba(priv, priv->ba_cnt, priv->ba_acc, priv->ba_cnt_rx, priv->ba_acc_rx);
  2115. -
  2116. -       if (atomic_read(&priv->scan.in_progress)) {
  2117. -               priv->ba_cnt = 0;
  2118. -               priv->ba_acc = 0;
  2119. -               priv->ba_cnt_rx = 0;
  2120. -               priv->ba_acc_rx = 0;
  2121. -               goto skip_statistic_update;
  2122. -       }
  2123. -
  2124. -       if (priv->ba_cnt >= CW1200_BLOCK_ACK_CNT &&
  2125. -               (priv->ba_acc / priv->ba_cnt >= CW1200_BLOCK_ACK_THLD ||
  2126. -               (priv->ba_cnt_rx >= CW1200_BLOCK_ACK_CNT &&
  2127. -               priv->ba_acc_rx / priv->ba_cnt_rx >= CW1200_BLOCK_ACK_THLD)))
  2128. -               ba_ena = true;
  2129. -       else
  2130. -               ba_ena = false;
  2131. -
  2132. -       priv->ba_cnt = 0;
  2133. -       priv->ba_acc = 0;
  2134. -       priv->ba_cnt_rx = 0;
  2135. -       priv->ba_acc_rx = 0;
  2136. -
  2137. -       if (ba_ena != priv->ba_ena) {
  2138. -               if (ba_ena || ++priv->ba_hist >= CW1200_BLOCK_ACK_HIST) {
  2139. -                       priv->ba_ena = ba_ena;
  2140. -                       priv->ba_hist = 0;
  2141. -                       sta_printk(KERN_DEBUG "[STA] %s block ACK:\n",
  2142. -                               ba_ena ? "enable" : "disable");
  2143. -                       queue_work(priv->workqueue, &priv->ba_work);
  2144. -               }
  2145. -       } else if (priv->ba_hist)
  2146. -               --priv->ba_hist;
  2147. -
  2148. -skip_statistic_update:
  2149. -       spin_unlock_bh(&priv->ba_lock);
  2150. -}
  2151. -
  2152.  const u8 *cw1200_get_ie(u8 *start, size_t len, u8 ie)
  2153.  {
  2154.         u8 *end, *pos;
  2155. diff -ruN .a/net/compat-wireless/drivers/staging/cw1200/sta.h .b/net/compat-wireless/drivers/staging/cw1200/sta.h
  2156. --- .a/net/compat-wireless/drivers/staging/cw1200/sta.h 2012-10-23 21:38:07.000000000 +0900
  2157. +++ .b/net/compat-wireless/drivers/staging/cw1200/sta.h 2013-01-08 21:13:48.000000000 +0900
  2158. @@ -92,8 +92,6 @@
  2159.  int cw1200_disable_listening(struct cw1200_common *priv);
  2160.  int cw1200_set_uapsd_param(struct cw1200_common *priv,
  2161.                                 const struct wsm_edca_params *arg);
  2162. -void cw1200_ba_work(struct work_struct *work);
  2163. -void cw1200_ba_timer(unsigned long arg);
  2164.  const u8 *cw1200_get_ie(u8 *start, size_t len, u8 ie);
  2165.  
  2166.  #endif
  2167. diff -ruN .a/net/compat-wireless/drivers/staging/cw1200/txrx.c .b/net/compat-wireless/drivers/staging/cw1200/txrx.c
  2168. --- .a/net/compat-wireless/drivers/staging/cw1200/txrx.c        2012-10-23 21:38:07.000000000 +0900
  2169. +++ .b/net/compat-wireless/drivers/staging/cw1200/txrx.c        2013-01-08 21:13:48.000000000 +0900
  2170. @@ -790,27 +790,6 @@
  2171.         return !was_buffered;
  2172.  }
  2173.  
  2174. -static void
  2175. -cw1200_tx_h_ba_stat(struct cw1200_common *priv,
  2176. -                   struct cw1200_txinfo *t)
  2177. -{
  2178. -       if (priv->join_status != CW1200_JOIN_STATUS_STA)
  2179. -               return;
  2180. -       if (!cw1200_is_ht(&priv->ht_info))
  2181. -               return;
  2182. -       if (!ieee80211_is_data(t->hdr->frame_control))
  2183. -               return;
  2184. -
  2185. -       spin_lock_bh(&priv->ba_lock);
  2186. -       priv->ba_acc += t->skb->len - t->hdrlen;
  2187. -       if (!(priv->ba_cnt_rx || priv->ba_cnt)) {
  2188. -               mod_timer(&priv->ba_timer,
  2189. -                       jiffies + CW1200_BLOCK_ACK_INTERVAL);
  2190. -       }
  2191. -       priv->ba_cnt++;
  2192. -       spin_unlock_bh(&priv->ba_lock);
  2193. -}
  2194. -
  2195.  static int
  2196.  cw1200_tx_h_skb_pad(struct cw1200_common *priv,
  2197.                     struct wsm_tx *wsm,
  2198. @@ -890,7 +869,6 @@
  2199.         rcu_read_lock();
  2200.         sta = rcu_dereference(t.tx_info->control.sta);
  2201.  
  2202. -       cw1200_tx_h_ba_stat(priv, &t);
  2203.         spin_lock_bh(&priv->ps_state_lock);
  2204.         {
  2205.                 tid_update = cw1200_tx_h_pm_state(priv, &t);
  2206. @@ -1154,25 +1132,6 @@
  2207.                 ieee80211_tx_status(priv->hw, skb);
  2208.  }
  2209.  
  2210. -static void
  2211. -cw1200_rx_h_ba_stat(struct cw1200_common *priv,
  2212. -                   size_t hdrlen, size_t skb_len )
  2213. -{
  2214. -       if (priv->join_status != CW1200_JOIN_STATUS_STA)
  2215. -               return;
  2216. -       if (!cw1200_is_ht(&priv->ht_info))
  2217. -               return;
  2218. -
  2219. -       spin_lock_bh(&priv->ba_lock);
  2220. -       priv->ba_acc_rx += skb_len - hdrlen;
  2221. -       if (!(priv->ba_cnt_rx || priv->ba_cnt)) {
  2222. -               mod_timer(&priv->ba_timer,
  2223. -                       jiffies + CW1200_BLOCK_ACK_INTERVAL);
  2224. -       }
  2225. -       priv->ba_cnt_rx++;
  2226. -       spin_unlock_bh(&priv->ba_lock);
  2227. -}
  2228. -
  2229.  void cw1200_rx_cb(struct cw1200_common *priv,
  2230.                   struct wsm_rx *arg,
  2231.                   struct sk_buff **skb_p)
  2232. @@ -1368,9 +1327,6 @@
  2233.         else
  2234.                 grace_period = 1 * HZ;
  2235.  
  2236. -       if (ieee80211_is_data(frame->frame_control))
  2237. -               cw1200_rx_h_ba_stat( priv, hdrlen, skb->len);
  2238. -
  2239.         cw1200_pm_stay_awake(&priv->pm_state, grace_period);
  2240.  
  2241.         if (unlikely(cw1200_itp_rxed(priv, skb)))
  2242. diff -ruN .a/sound/soc/codecs/av8100_audio.c .b/sound/soc/codecs/av8100_audio.c
  2243. --- .a/sound/soc/codecs/av8100_audio.c  2012-10-23 21:38:07.000000000 +0900
  2244. +++ .b/sound/soc/codecs/av8100_audio.c  2013-01-08 21:13:48.000000000 +0900
  2245. @@ -179,12 +179,14 @@
  2246.         config.hdmi_format.hdmi_mode = AV8100_HDMI_ON;
  2247.         config.hdmi_format.hdmi_format = AV8100_HDMI;
  2248.         config.hdmi_format.dvi_format = AV8100_DVI_CTRL_CTL0;
  2249. +       av8100_conf_lock();
  2250.         ret = av8100_conf_prep(AV8100_COMMAND_HDMI, &config);
  2251.         if (ret != 0) {
  2252.                 pr_err("%s: Setting hdmi_format failed "
  2253.                         "(av8100_conf_prep returned %d)!\n",
  2254.                         __func__,
  2255.                         ret);
  2256. +               av8100_conf_unlock();
  2257.                 return -EINVAL;
  2258.         }
  2259.         ret = av8100_conf_w(AV8100_COMMAND_HDMI,
  2260. @@ -196,9 +198,11 @@
  2261.                         "(av8100_conf_w returned %d)!\n",
  2262.                         __func__,
  2263.                         ret);
  2264. +               av8100_conf_unlock();
  2265.                 return -EINVAL;
  2266.         }
  2267.  
  2268. +       av8100_conf_unlock();
  2269.         return 0;
  2270.  }
  2271.  
  2272. @@ -258,12 +262,14 @@
  2273.  
  2274.         /* Send audio info-frame */
  2275.         pr_info("%s: Sending audio info-frame.", __func__);
  2276. +       av8100_conf_lock();
  2277.         ret = av8100_conf_prep(AV8100_COMMAND_INFOFRAMES, &config);
  2278.         if (ret != 0) {
  2279.                 pr_err("%s: Sending audio info-frame failed "
  2280.                         "(av8100_conf_prep returned %d)!\n",
  2281.                         __func__,
  2282.                         ret);
  2283. +               av8100_conf_unlock();
  2284.                 return -EINVAL;
  2285.         }
  2286.         ret = av8100_conf_w(AV8100_COMMAND_INFOFRAMES,
  2287. @@ -275,9 +281,11 @@
  2288.                         "(av8100_conf_w returned %d)!\n",
  2289.                         __func__,
  2290.                         ret);
  2291. +               av8100_conf_unlock();
  2292.                 return -EINVAL;
  2293.         }
  2294.  
  2295. +       av8100_conf_unlock();
  2296.         return 0;
  2297.  }
  2298.  
  2299. @@ -302,7 +310,8 @@
  2300.         pr_debug("%s: Enter.\n", __func__);
  2301.  
  2302.         /* Get HDMI resource */
  2303. -       av8100_hdmi_get();
  2304. +       if (av8100_hdmi_get(AV8100_HDMI_USER_AUDIO) < 0)
  2305. +               return -EBUSY;
  2306.  
  2307.         /* Startup AV8100 if it is not already started */
  2308.         ret = av8100_codec_powerup();
  2309. @@ -312,7 +321,7 @@
  2310.                         __func__,
  2311.                         ret);
  2312.                 /* Put HDMI resource */
  2313. -               av8100_hdmi_put();
  2314. +               av8100_hdmi_put(AV8100_HDMI_USER_AUDIO);
  2315.                 return -EINVAL;
  2316.         }
  2317.  
  2318. @@ -323,7 +332,7 @@
  2319.                                 struct snd_soc_dai *codec_dai)
  2320.  {
  2321.         /* Put HDMI resource */
  2322. -       av8100_hdmi_put();
  2323. +       av8100_hdmi_put(AV8100_HDMI_USER_AUDIO);
  2324.  
  2325.         pr_debug("%s: Enter.\n", __func__);
  2326.  }
  2327. @@ -367,12 +376,14 @@
  2328.         config.audio_input_format.audio_word_lg = AV8100_AUDIO_16BITS;
  2329.         config.audio_input_format.audio_format = AV8100_AUDIO_LPCM_MODE;
  2330.         config.audio_input_format.audio_mute = AV8100_AUDIO_MUTE_DISABLE;
  2331. +       av8100_conf_lock();
  2332.         ret = av8100_conf_prep(AV8100_COMMAND_AUDIO_INPUT_FORMAT, &config);
  2333.         if (ret != 0) {
  2334.                 pr_err("%s: Setting audio_input_format failed "
  2335.                         "(av8100_conf_prep returned %d)!\n",
  2336.                         __func__,
  2337.                         ret);
  2338. +               av8100_conf_unlock();
  2339.                 return -EINVAL;
  2340.         }
  2341.         ret = av8100_conf_w(AV8100_COMMAND_AUDIO_INPUT_FORMAT,
  2342. @@ -384,9 +395,11 @@
  2343.                         "(av8100_conf_w returned %d)!\n",
  2344.                         __func__,
  2345.                         ret);
  2346. -                       return -EINVAL;
  2347. +               av8100_conf_unlock();
  2348. +               return -EINVAL;
  2349.         }
  2350.  
  2351. +       av8100_conf_unlock();
  2352.         return 0;
  2353.  }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top