Exemplo n.º 1
0
void mdss_dsi_error(struct mdss_dsi_ctrl_pdata *ctrl)
{

	/* disable dsi error interrupt */
	mdss_dsi_err_intr_ctrl(ctrl, DSI_INTR_ERROR_MASK, 0);

	/* DSI_ERR_INT_MASK0 */
	mdss_dsi_clk_status(ctrl);	/* Mask0, 0x10000000 */
	mdss_dsi_fifo_status(ctrl);	/* mask0, 0x133d00 */
	mdss_dsi_ack_err_status(ctrl);	/* mask0, 0x01f */
	mdss_dsi_timeout_status(ctrl);	/* mask0, 0x0e0 */
	mdss_dsi_status(ctrl);		/* mask0, 0xc0100 */
	mdss_dsi_dln0_phy_err(ctrl);	/* mask0, 0x3e00000 */

	dsi_send_events(ctrl, DSI_EV_MDP_BUSY_RELEASE);
#if defined(CONFIG_F_SKYDISP_EF63_SS)   //ejkim77_debug dump
#ifdef F_WA_WATCHDOG_DURING_BOOTUP
	if(ctrl->octa_blck_set && !ctrl->manufacture_id)
#endif	
	{
	       dumpreg();
		BUG_ON(1);
	}
#endif	
}
void mdss_dsi_fifo_status(struct mdss_dsi_ctrl_pdata *ctrl)
{
	u32 status;
	unsigned char *base;

	base = ctrl->ctrl_base;

	status = MIPI_INP(base + 0x000c);/* DSI_FIFO_STATUS */

	/* fifo underflow, overflow */
	if (status & 0xcccc4489) {
		MIPI_OUTP(base + 0x000c, status);
		pr_err("%s: status=%x\n", __func__, status);
		if (status & 0x0080)  /* CMD_DMA_FIFO_UNDERFLOW */
			dsi_send_events(ctrl, DSI_EV_MDP_FIFO_UNDERFLOW);
		
#if defined (CONFIG_FB_MSM_MIPI_SAMSUNG_OCTA_CMD_WQHD_PT_PANEL)
		if (status == 0x99991080) {
			dumpreg();
			mdp5_dump_regs();
			mdss_dsi_dump_power_clk(&ctrl->panel_data, 0);
			mdss_mdp_dump_power_clk();
			mdss_mdp_debug_bus();
			xlog_dump();
				panic("mdss_dsi_fifo err");
		}
#endif
	}
}
void mdss_dsi_cmd_mdp_busy(struct mdss_dsi_ctrl_pdata *ctrl)
{
	unsigned long flags;
	int need_wait = 0;
	static int busy_timeout_cnt;

	pr_debug("%s: start pid=%d\n",
				__func__, current->pid);
	spin_lock_irqsave(&ctrl->mdp_lock, flags);
	if (ctrl->mdp_busy == true)
		need_wait++;
#if defined (CONFIG_FB_MSM_MDSS_DSI_DBG)
	xlog(__func__,ctrl->ndx, ctrl->mdp_busy, 0, 0, 0, 0);
#endif
	spin_unlock_irqrestore(&ctrl->mdp_lock, flags);

	if (need_wait) {
		/* wait until DMA finishes the current job */
		pr_debug("%s: pending pid=%d\n",
				__func__, current->pid);

		if (!wait_for_completion_timeout(&ctrl->mdp_comp,\
	            msecs_to_jiffies(1000))) {

			pr_info("%s: wait_for_completion_timeout (count : %d)",
										 __func__, ++busy_timeout_cnt);
			/*WARN(1, "mdss_dsi_cmd_mdp_busy timeout");*/

#if defined (CONFIG_FB_MSM_MIPI_SAMSUNG_OCTA_CMD_WQHD_PT_PANEL)
			dumpreg();
			mdp5_dump_regs();
			mdss_dsi_dump_power_clk(&ctrl->panel_data, 0);
			mdss_mdp_dump_power_clk();
			mdss_mdp_debug_bus();
			xlog_dump();
#if 0
			pr_info("run recovery function instead of force panic\n");
			dsi_send_events(ctrl, DSI_EV_MDP_BUSY_RELEASE);
#else
			panic("mdss_dsi_cmd_mdp_busy timeout");
#endif
#endif
        }

	}
	pr_debug("%s: done pid=%d\n",
				__func__, current->pid);
}
Exemplo n.º 4
0
void
Ssyscall(ulong inst)
{
	int call;

	USED(inst);
	call = reg.r[REGRET];
	if(call < 0 || call > PWRITE || systab[call] == nil) {
		Bprint(bioout, "Bad system call\n");
		dumpreg();
	}
	if(trace)
		itrace("sysc\t%s", sysctab[call]);

	(*systab[call])();
	Bflush(bioout);
}
Exemplo n.º 5
0
void
Ssyscall(uint32_t)
{
	int call;

	call = reg.r[REGARG];
	if(call < 0 || call >= nelem(systab) || systab[call] == nil) {
		Bprint(bioout, "bad system call %d (%#ux)\n", call, call);
		dumpreg();
		Bflush(bioout);
		return;
	}

	if(trace)
		itrace("SWI\t%s", sysctab[call]);
	(*systab[call])();
	Bflush(bioout);
}
Exemplo n.º 6
0
int main( int argc, char **argv )
{
  char                 buffer[4096];
  int                  port;
  int                  rval;
  int                  sd;
  struct sockaddr_in   socketaddr;
  struct hostent       *hostaddr;
  struct protoent      *protocol;
  gdbwrap_t            *desc = NULL;
 
  if ( argc < 3 )
    {
      printf( "usage:  client  server port \n" );
      return (EINVAL); /* Invalid argument */
    }
  
  /* quick sanity check */
  
  port = atoi( argv[2] );
  
  if ( port < 1 || port > 65535 )
    {
      printf( "client: invalid port number\n" );
      return (EINVAL);
    }
  
  /*
   * Build our socket
   */
  
  protocol = getprotobyname( "tcp" );
  if ( !protocol )
    {
      perror( "getprotobyname()" );
      return (errno);
    }
  
  sd = socket( PF_INET, SOCK_STREAM, protocol->p_proto );
  if ( sd == -1 )
    {
      perror( "socket()" );
      return (errno);
    }
   /*
   * Setup info about the remote host
   */
  
  memset( &socketaddr, 0, sizeof(socketaddr) );
  
  socketaddr.sin_family = AF_INET;
  socketaddr.sin_port = htons( port );
  
  hostaddr = gethostbyname( argv[1] );
  if ( !hostaddr )
    {
      fprintf( stderr, "gethostbyname(): %s\n", hstrerror(h_errno) );
      return (h_errno);
    }
  
  /* copy address from hostaddr to socketaddr */
  
  memcpy( &socketaddr.sin_addr, hostaddr->h_addr, hostaddr->h_length );
  
  /*
   * Connect to the host
   */
  
  rval = connect( sd, (struct sockaddr *) &socketaddr, sizeof(socketaddr) );
  if ( rval == -1 )
    {
      perror( "connect()" );
      return (errno);
    }
  
  /* Now that we're connected, we can send and receive all we want.
   * I've decided to use this example as a means of simply grabbing
   * whatever banner the server sends us and sending it to stdout.
   */

  // 28 registers of 4 bytes for sh4
  desc = gdbwrap_init(sd,28,4);
  do
    {
      char * ret;

      ret = fgets(buffer, sizeof(buffer) - 1, stdin);
      assert(ret != NULL);
      
      if(!strncmp("hello", buffer,  5))
	  gdbwrap_hello(desc);
      else if(!strncmp("disconnect", buffer,  5))
	{
	  gdbwrap_bye(desc);
	  exit(0);
	}
      else if(!strncmp("why", buffer,  3))
	gdbwrap_reason_halted(desc);
/*       else if(!strncmp("test", buffer,  4)) */
/* 	gdbwrap_test(desc); */
      else if(!strncmp("gpr", buffer,  3))
	gdbwrap_readgenreg(desc);
      else if(!strncmp("cont", buffer,  4))
	gdbwrap_continue(desc);
      else if(!strncmp("dump", buffer,  4))
	dumpreg(desc);
      else if(!strncmp("stepi", buffer, 5))
	gdbwrap_stepi(desc);
      else if(!strncmp("signal", buffer, 5))
	gdbwrap_signal(desc, 0x1);
      else if(!strncmp("ship", buffer, 4))
	gdbwrap_shipallreg(desc);
      else if(!strncmp("cr0", buffer, 4))
	printf("Value: %s\n", gdbwrap_remotecmd(desc, "r cr0"));
      else if(!strncmp("mem", buffer, 3))
	{
	  char *c;
	  char u = 0xff;
	 // c = gdbwrap_writemem(desc, 0xb7fe49a0, &u, 0x1);
	  printf("Returned from memorycontent: %s\n", c);
	  fflush(stdout);
	}
/*       else if(!strncmp("own", buffer,  3)) */
/* 	{ */
/* 	  while (strncmp("quitown", buffer, 7)) */
/* 	    { */
/* 	      printf("\nCommand: "); */
/* 	      ret = gdbwrap_own_command(fgets(buffer, sizeof(buffer) - 1, stdin), */
/* 					desc); */
/* 	      printf("\n%s - size: %d", ret, strlen(ret)); */
/* 	    } */
/* 	} */
      else printf("not supported yet\n");
      
    } while (strncmp("bye", buffer, 3));
  
  close(sd);
  return (0);
}
Exemplo n.º 7
0
void
dollar(char *cp)
{
	cp = nextc(cp);
	switch(*cp) {
	default:
		Bprint(bioout, "?\n");
		break;

	case 'c':
	case 'C':
		stktrace(*cp);
		break;

	case 'b':
		dobplist();
		break;

	case 'r':
		dumpreg();
		break;

	case 'R':
		dumpreg();
		/* fall through */

	case 'f':
		dumpfreg();
		break;

	case 'F':
		dumpdreg();
		break;

	case 'q':
		exits(0);
		break;

	case 'Q':
		isum();
		segsum();
		break;

	case 't':
		cp++;
		switch(*cp) {
		default:
			Bprint(bioout, ":t[0sic]\n");
			break;
		case '\0':
			trace = 1;
			break;
		case '0':
			trace = 0;
			sysdbg = 0;
			calltree = 0;
			break;
		case 's':
			sysdbg = 1;
			break;
		case 'i':
			trace = 1;
			break;
		case 'c':
			calltree = 1;
			break;
		}
		break;

	case 'i':
		cp++;
		switch(*cp) {
		default:
			Bprint(bioout, "$i[isa]\n");
			break;
		case 'i':
			isum();
			break;
		case 's':
			segsum();
			break;
		case 'a':
			isum();
			segsum();
			iprofile();
			break;
		case 'p':
			iprofile();
			break;
		}
	}
}
static int mdss_dsi_cmd_dma_tx(struct mdss_dsi_ctrl_pdata *ctrl,
					struct dsi_buf *tp)
{
	int len, ret = 0;
	int domain = MDSS_IOMMU_DOMAIN_UNSECURE;
	char *bp;
	unsigned long size, addr;

#ifdef DEBUG_CMD
	int i;
	bp = tp->data;

	pr_info("%s: ", __func__);
	for (i = 0; i < tp->len; i++)
		printk("%x ", *bp++);

	pr_info("\n");
#endif
	bp = tp->data;

	len = ALIGN(tp->len, 4);
	size = ALIGN(tp->len, SZ_4K);

	tp->dmap = dma_map_single(&dsi_dev, tp->data, size, DMA_TO_DEVICE);
	if (dma_mapping_error(&dsi_dev, tp->dmap)) {
		pr_err("%s: dmap mapp failed\n", __func__);
		return -ENOMEM;
	}

	if (is_mdss_iommu_attached()) {
		int ret = msm_iommu_map_contig_buffer(tp->dmap,
					mdss_get_iommu_domain(domain), 0,
					size, SZ_4K, 0, &(addr));
		if (IS_ERR_VALUE(ret)) {
			pr_err("unable to map dma memory to iommu(%d)\n", ret);
			return -ENOMEM;
		}
	} else {
		addr = tp->dmap;
	}

	INIT_COMPLETION(ctrl->dma_comp);

	if (ctrl->shared_pdata.broadcast_enable)
		if ((ctrl->ndx == DSI_CTRL_1)
		  && (left_ctrl_pdata != NULL)) {
			MIPI_OUTP(left_ctrl_pdata->ctrl_base + 0x048, addr);
			MIPI_OUTP(left_ctrl_pdata->ctrl_base + 0x04c, len);
		}

	MIPI_OUTP((ctrl->ctrl_base) + 0x048, addr);
	MIPI_OUTP((ctrl->ctrl_base) + 0x04c, len);
	wmb();

	if (ctrl->shared_pdata.broadcast_enable)
		if ((ctrl->ndx == DSI_CTRL_1)
		  && (left_ctrl_pdata != NULL)) {
			MIPI_OUTP(left_ctrl_pdata->ctrl_base + 0x090, 0x01);
		}

	MIPI_OUTP((ctrl->ctrl_base) + 0x090, 0x01);	/* trigger */
	wmb();

	ret = wait_for_completion_timeout(&ctrl->dma_comp,
				msecs_to_jiffies(DMA_TX_TIMEOUT));
	if (ret == 0) {
#if defined (CONFIG_FB_MSM_MDSS_DSI_DBG)
		dumpreg();
		mdp5_dump_regs();
		mdss_dsi_dump_power_clk(&ctrl->panel_data, 0);
		mdss_mdp_dump_power_clk();
		mdss_mdp_debug_bus();
		xlog_dump();
#endif
		pr_err("dma tx timeout!!\n");
		ret = -ETIMEDOUT;
	} else
		ret = tp->len;

	if (is_mdss_iommu_attached())
		msm_iommu_unmap_contig_buffer(addr,
			mdss_get_iommu_domain(domain), 0, size);

	return ret;
}
static int mipi_samsung_disp_on(struct platform_device *pdev)
{
	struct msm_fb_data_type *mfd;
	struct mipi_panel_info *mipi;
	static int boot_on;

#ifdef __DEBUG__
	static int test=0 ;
#endif

	mfd = platform_get_drvdata(pdev);
	if (unlikely(!mfd))
		return -ENODEV;
	if (unlikely(mfd->key != MFD_KEY))
		return -EINVAL;

	mipi = &mfd->panel_info.mipi;

#ifdef USE_READ_ID
	if (unlikely(!boot_on)) {
		msd.mpd->manufacture_id = mipi_samsung_manufacture_id(mfd);
		/*Display was initialized in bootloader,same settings
			are carried when splash is enabled*/
		}
#endif

#if defined(CONFIG_FB_MDP4_ENHANCE)
	is_negativeMode_on();
#endif

#ifdef __DEBUG__
	if(test==0)
        if(0)
	dumpreg(1);
		test++;
#endif		

	mipi_samsung_disp_send_cmd(mfd, PANEL_READY_TO_ON, false);

	if(!boot_on)
		boot_on = 1;
	else
		msleep(100);

#if defined(CONFIG_ESD_ERR_FG_RECOVERY)
	enable_irq(err_fg_gpio);
#endif

#ifndef CONFIG_MACH_CANE_EUR_3G
	pr_info("%s: DISP_BL_CONT_GPIO High\n", __func__);
	gpio_set_value(DISP_BL_CONT_GPIO, 1);
#endif	

#if !defined(CONFIG_HAS_EARLYSUSPEND)
	mipi_samsung_disp_send_cmd(mfd, PANEL_LATE_ON, false);
#endif

#if defined(CONFIG_MACH_CANE_EUR_3G)
	mfd->resume_state = MIPI_RESUME_STATE;
#endif

	return 0;
}