Merge remote-tracking branch 'kernel-2.6.32/develop' into develop-2.6.36

Conflicts:
	drivers/usb/gadget/f_mass_storage.c

diff --cc drivers/base/power/main.c
index 3bb0cd0b3ebe6399511119a4aa03393d8ad05f55,d2226210de414cabc7193ed3b219d3efcc3d1f66..bb322473210ee1f88158deb98b98d7aa4c8b3f0f
--- 1/drivers/base/power/main.c
--- 2/drivers/base/power/main.c
+++ b/drivers/base/power/main.c
@@@ -616,9 -461,9 +616,6 @@@ static void dpm_drv_timeout(unsigned lo
  
  #ifdef CONFIG_ARCH_RK29
        resume_console();
--      if (dev->power.status == DPM_RESUMING)
--              printk(KERN_EMERG "dpm resume stack:\n");
--      else
  #endif
        printk(KERN_EMERG "dpm suspend stack:\n");
        show_stack(tsk, NULL);
@@@ -641,34 -507,23 +638,28 @@@ static void dpm_resume(pm_message_t sta
  
        INIT_LIST_HEAD(&list);
        mutex_lock(&dpm_list_mtx);
 -      while (!list_empty(&dpm_list)) {
 -              struct device *dev = to_device(dpm_list.next);
 +      pm_transition = state;
  
 +      list_for_each_entry(dev, &dpm_list, power.entry) {
 +              if (dev->power.status < DPM_OFF)
 +                      continue;
 +
 +              INIT_COMPLETION(dev->power.completion);
 +              if (is_async(dev)) {
 +                      get_device(dev);
 +                      async_schedule(async_resume, dev);
 +              }
 +      }
 +
 +      while (!list_empty(&dpm_list)) {
 +              dev = to_device(dpm_list.next);
                get_device(dev);
 -              if (dev->power.status >= DPM_OFF) {
 +              if (dev->power.status >= DPM_OFF && !is_async(dev)) {
                        int error;
  
 -                      dev->power.status = DPM_RESUMING;
                        mutex_unlock(&dpm_list_mtx);
  
--#ifdef CONFIG_ARCH_RK29
--                      dpm_drv_wdset(dev);
 -#endif
 -                      error = device_resume(dev, state);
 -#ifdef CONFIG_ARCH_RK29
 -                      dpm_drv_wdclr(dev);
--#endif
 +                      error = device_resume(dev, state, false);
- #ifdef CONFIG_ARCH_RK29
-                       dpm_drv_wdclr(dev);
- #endif
  
                        mutex_lock(&dpm_list_mtx);
                        if (error)

diff --cc drivers/mmc/host/rk29_sdmmc.c
Simple merge

diff --cc drivers/usb/gadget/f_mass_storage.c
index 0bd01f79778b88a2bb64209426a69cbec7164793,bf793724cd5f2971844195fbb12b83eb899313e5..24c6bd8aa04f2c5e64d0d995ae8d008ec1d54e1b
--- 1/drivers/usb/gadget/f_mass_storage.c
--- 2/drivers/usb/gadget/f_mass_storage.c
+++ b/drivers/usb/gadget/f_mass_storage.c
@@@ -813,7 -844,7 +813,7 @@@ static int do_read(struct fsg_common *c
                 * max size for dwc_otg ctonroller is 64(max pkt sizt) * 1023(pkt)
                 * because of the DOEPTSIZ.PKTCNT has only 10 bits
                 */
--              if((fsg->cdev->gadget->speed != USB_SPEED_HIGH)&&(amount >0x8000))
++              if((common->gadget->speed != USB_SPEED_HIGH)&&(amount >0x8000))
                    amount = 0x8000;
  
                /* Wait for the next buffer to become available */
@@@ -993,7 -1014,7 +993,7 @@@ static int do_write(struct fsg_common *
                         * max size for dwc_otg ctonroller is 64(max pkt sizt) * 1023(pkt)
                         * because of the DOEPTSIZ.PKTCNT has only 10 bits
                         */
--                      if((fsg->cdev->gadget->speed != USB_SPEED_HIGH)&&(amount >0x8000))
++                      if((common->gadget->speed != USB_SPEED_HIGH)&&(amount >0x8000))
                            amount = 0x8000;
  
                        /* amount is always divisible by 512, hence by
@@@ -1983,23 -1851,149 +1983,153 @@@ static void deferred_restart(struct wor
        kernel_restart("loader");
  }
  static DECLARE_WORK(restart_work, deferred_restart);
+ 
+ typedef struct tagLoaderParam
+ {
+       int     tag;
+       int     length;
+       char    parameter[1];
+       int     crc;
+ } PARM_INFO;
+ #define PARM_TAG                      0x4D524150
+ #define MSC_EXT_DBG                   1
+ extern int  GetParamterInfo(char * pbuf , int len);
+ static int do_get_product_name(int ret ,char *buf)
+ {
+       char            tmp[32];
+       PARM_INFO       *pi;
+       char            *pp,*spp;
+       char            *tag = "MACHINE_MODEL:";
+       int             i;
+       #if MSC_EXT_DBG
+       char            tbuf[1024];
+       if( buf == NULL ) buf = tbuf;
+       #endif
+       i = GetParamterInfo( buf , 1024 );
+       pi = (PARM_INFO*)buf;
+       if( pi->tag != PARM_TAG ){
+ error_out:    
+               printk("paramter error,tag=0x%x\n" , pi->tag );
+               memset( buf , 0 , ret );
+               strcpy( buf , "UNKNOW" );
+               return ret;
+       }
+       if( pi->length+sizeof(PARM_INFO) > i ) {
+               GetParamterInfo( buf , pi->length+sizeof(PARM_INFO)  + 511 );
+       }
+       pp = strstr( pi->parameter , tag );
+       if( !pp ) goto error_out;
+       pp+= strlen(tag); // sizeof "MACHINE_MODEL:"
+       while( *pp == ' ' || *pp == '\t' ) {
+               if(pp - pi->parameter >= pi->length)
+                 break;        
+               pp++;
+       }
+       spp = pp;
+       while( *pp != 0x0d && *pp != 0x0a ) {
+               if(pp - pi->parameter >= pi->length)
+                 break;
+               pp++;
+       }
+       *pp = 0;
+       i = pp - spp;
+       if( i >= ret ) i = ret -1;
+       memcpy( tmp , spp , i );
+       memset( buf , 0 , ret );
+       memcpy( buf , tmp , i );
+       printk("%s%s\n" , tag , buf );
+       return ret;
+ }
+ 
+ static int do_get_versions( int ret ,char* buf )
+ {
+       /* get boot version and fireware version from cmdline
+       * bootver=2010-07-08#4.02 firmware_ver=1.0.0 // Firmware Ver:16.01.0000
+       * return format: 0x02 0x04 0x00 0x00 0x00 0x01 
+       * RK29: bootver=2011-07-18#2.05 firmware_ver=0.2.3 (==00.02.0003)
+       */
+ #define ASC_BCD0( c )  (((c-'0'))&0xf)
+ #define ASC_BCD1( c )  (((c-'0')<<4)&0xf0)
+ 
+       char *ver = buf;
+       char *p_l , *p_f;
+       
+       #if MSC_EXT_DBG
+       char            tbuf[1024];
+       if( ver == NULL ) ver = tbuf;
+       #endif
+       memset( ver , 0x00 , ret );
+       p_l = strstr( saved_command_line , "bootver=" );
+       if( !p_l ) {
+               return 0;
+       } 
+       p_f = strstr( p_l , "firmware_ver=" );
+       if( !p_f ) {
+               return 0;
+       } 
+       if( !(p_l = strnchr( p_l, p_f - p_l , '#'))  )
+               return 0;
+       p_l++;
+       p_f+=strlen("firmware_ver=");
+       if( p_l[1] == '.' ) {
+               ver[1] = ASC_BCD0(p_l[0]);
+               p_l+=2;
+       } else {
+               ver[1] = ASC_BCD1(p_l[0])|ASC_BCD0(p_l[1]);
+               p_l+=3;
+       }
+       ver[0] = ASC_BCD1(p_l[0])|ASC_BCD0(p_l[1]);
+       if( p_f[1] == '.' ) {
+               ver[5] = ASC_BCD0(p_f[0]);
+               p_f+=2;
+       } else {
+               ver[5] = ASC_BCD1(p_f[0])|ASC_BCD0(p_f[1]);
+               p_f+=3;
+       } 
+       if( p_f[1] == '.' ) {
+               ver[4] = ASC_BCD0(p_f[0]);
+               p_f+=2;
+       } else {
+               ver[4] = ASC_BCD1(p_f[0])|ASC_BCD0(p_f[1]);
+               p_f+=3;
+       } 
+       ver[2] = ASC_BCD0(p_f[0]);
+       p_f++;
+       if( p_f[0] != ' ' ){
+               ver[2] |= ASC_BCD1(p_f[0]);
+               p_f++;
+       }
+       // only support 2 byte version.
+       ver[3] = 0;
+ 
+       #if MSC_EXT_DBG
+       printk("VERSION:%02x %02x %02x %02x %02x %02x\n" , 
+               ver[0],ver[1],ver[2],ver[3],ver[4],ver[5]);
+       #endif
+ 
+ 
+       return ret;
+ }
  #endif
  
 -static int do_scsi_command(struct fsg_dev *fsg)
 +static int do_scsi_command(struct fsg_common *common)
  {
        struct fsg_buffhd       *bh;
        int                     rc;
        int                     reply = -EINVAL;
        int                     i;
        static char             unknown[16];
++#ifdef CONFIG_ARCH_RK29
++      struct fsg_common       *fsg = common;
++#endif
  
 -      dump_cdb(fsg);
 +      dump_cdb(common);
  
        /* Wait for the next buffer to become available for data or status */
 -      bh = fsg->next_buffhd_to_drain = fsg->next_buffhd_to_fill;
 +      bh = common->next_buffhd_to_fill;
 +      common->next_buffhd_to_drain = bh;
        while (bh->state != BUF_STATE_EMPTY) {
 -              rc = sleep_thread(fsg);
 +              rc = sleep_thread(common);
                if (rc)
                        return rc;
        }