hi_vda.c

华为 HI3510 BOOTLOADER HIBOOT 源码包

				{
					err = HI_ERROR;
            				goto err_out;
            			}
					
			}
			else if(s32Norm == VIDEO_NORM_NTSC)
			{
				if(s32Master == VIDEO_MODE_MASTER)
				{
					Arg = VIDEO_MODE_601_NTSC_MASTER;
					VDA_Command(ENCODER_SET_NORM, &Arg);
					return(HI_OK);
				}
				else if(s32Master == VIDEO_MODE_SLAVER)
				{
					Arg = VIDEO_MODE_601_NTSC_SLAVER;
					VDA_Command(ENCODER_SET_NORM, &Arg);
					return(HI_OK);
				}
				else				
				{
					err = HI_ERROR;
            				goto err_out;
            			}
					
			}
			else
			{
				err = HI_ERROR;
            			goto err_out;
            		}
		}
		else
		{
			err = HI_ERROR;
            		goto err_out;
		}		
	}
#endif
	
	//printf("Updated client's address is 0x%x\n",(int)client);
	if (client == NULL) 
        {
	  err = HI_ERROR;
	  goto err_out;
	}
	
	memcpy(client, &client_template, sizeof(struct i2c_client));
	
	client->id = adv7171_i2c_id++;
	
		
	encoder = malloc(sizeof(struct adv7171));
	if (encoder == NULL) 
	{
	  goto err_out;
	}
	
	memset(encoder, 0, sizeof(struct adv7171));
	if(s32Norm == VIDEO_NORM_PAL)
	  encoder->norm = VIDEO_NORM_PAL;	
	else if(s32Norm == VIDEO_NORM_NTSC)
	  encoder->norm = VIDEO_NORM_NTSC;

	
	if(s32Ccir == VIDEO_MODE_CCIR656)
	  {
	    encoder->ccir = VIDEO_MODE_CCIR656;
	    encoder->master = VIDEO_MODE_MASTER;
	  }
	else if(s32Ccir == VIDEO_MODE_CCIR601)
	  {
	    encoder->ccir = VIDEO_MODE_CCIR601;
	    encoder->master = s32Master;
	  }
	
	encoder->input = 0;
	encoder->enable = 1;	
	
        client->data = encoder;


        if((s32Ccir == VIDEO_MODE_CCIR656)&&(s32Norm == VIDEO_NORM_PAL))
        {
          if (writeRegs(client, (UINT8 *)&init_656_PAL, sizeof(init_656_PAL)) != HI_OK)
          {
            err = HI_ERROR;
            goto err_out_free_encoder;
          }
	}
	else if((s32Ccir == VIDEO_MODE_CCIR656)&&(s32Norm == VIDEO_NORM_NTSC))
	{
          if (writeRegs(client, (UINT8 *)&init_656_NTSC, sizeof(init_656_NTSC)) != HI_OK)
          {
            err = HI_ERROR;
            goto err_out_free_encoder;
          }
	}
	else if((s32Ccir == VIDEO_MODE_CCIR601)&&(s32Norm == VIDEO_NORM_PAL))
	{
	  if(s32Master == VIDEO_MODE_MASTER)
	    {
	      init_601_PAL[15] |= VIDEO_MODE_MASTER;
	    }
	  else if(s32Master == VIDEO_MODE_SLAVER)
	    {
	      init_601_PAL[15] &= ~VIDEO_MODE_MASTER;
	    }
	    
	  if (writeRegs(client, (UINT8 *)&init_601_PAL, sizeof(init_601_PAL))  != HI_OK)
          {
            err = HI_ERROR;
            goto err_out_free_encoder;
          }
	}
	else if((s32Ccir == VIDEO_MODE_CCIR601)&&(s32Norm == VIDEO_NORM_NTSC))
	{
	  if(s32Master == VIDEO_MODE_MASTER)
	    {
	      init_601_NTSC[15] |= VIDEO_MODE_MASTER;
	    }
	  if(s32Master == VIDEO_MODE_SLAVER)
	    {
	      init_601_NTSC[15] &= ~VIDEO_MODE_MASTER;
	    }
	    
	  if (writeRegs(client, (UINT8 *)&init_601_NTSC, sizeof(init_601_NTSC))  != HI_OK)
          {
            err = HI_ERROR;
            goto err_out_free_encoder;
          }
	}
	
	if(s32Ccir == VIDEO_MODE_CCIR656)
	  {
	    i = writeReg(client, 0x07, TR0MODE_656 | TR0RST);
	    i = writeReg(client, 0x07, TR0MODE_656);
	  }
	else if(s32Ccir == VIDEO_MODE_CCIR601)
	  {
	    if(s32Master == VIDEO_MODE_MASTER)
	    {
	      i = writeReg(client, 0x07, TR0MODE_601 | TR0RST | VIDEO_MODE_MASTER);
	      i = writeReg(client, 0x07, TR0MODE_601 | VIDEO_MODE_MASTER);
	    }
	    else
	    {
	      i = writeReg(client, 0x07, TR0MODE_601 | TR0RST);
	      i = writeReg(client, 0x07, TR0MODE_601);
	    }
	  }
/*	i= I2C_Read(I2C_ADV7171,0x07); 
	printf("before write i= %x",i);
	I2C_Write(I2C_ADV7171, 0x07, i);
	i= I2C_Read(I2C_ADV7171,0x07); 
	printf("after write i= %x",i);*/
	//printf("readReg......\n");
	//i = readReg(client, 0x12);
	//printf("%s_attach: rev. %d at 0x%02x\n",client->name, i & 1, client->addr << 1);

	return(HI_OK);

err_out_free_encoder:
	printf("err_out_free_encoder\n");
	free(encoder);
err_out:
	printf("err_out\n");
	return HI_ERROR;
}



HI_RET VDA_Command(IN UINT32 u32Cmd, IN void *pArg)
{
	struct adv7171 *encoder = (struct adv7171 *)(client->data);
	
	if(client == NULL)
	{
		printx(("ADV7171 have not been initialized.\n"));
		return HI_ERROR;	
	}

	switch (u32Cmd) {

	case 0:
        break;

	case ENCODER_GET_CAPABILITIES:
	{
		struct video_encoder_capability *cap = pArg;

		cap->flags = VIDEO_ENCODER_PAL |
			     VIDEO_ENCODER_NTSC;
		cap->inputs = 2;
		cap->outputs = 1;
	}
		break;

	case ENCODER_SET_NORM:
	{
		int iarg = *(int *) pArg;

		//printf("%s_command: set s32Norm %d\n",client->name, iarg);

		switch (iarg) {

		case VIDEO_MODE_656_PAL:
			writeRegs(client, (UINT8 *)&init_656_PAL, sizeof(init_656_PAL));
			if (encoder->input == 0)
				writeReg(client, 0x02, 0x0a);
				//writeReg(client, 0x02, 0x0e);	// Enable genlock
			writeReg(client, 0x07, TR0MODE_656 | TR0RST);
			writeReg(client, 0x07, TR0MODE_656);
			break;
		
		case VIDEO_MODE_656_NTSC:
			writeRegs(client, (UINT8 *)&init_656_NTSC, sizeof(init_656_NTSC));
			if (encoder->input == 0)
				writeReg(client, 0x02, 0x0a);
				//writeReg(client, 0x02, 0x0e);	// Enable genlock
			writeReg(client, 0x07, TR0MODE_656 | TR0RST);
			writeReg(client, 0x07, TR0MODE_656);
			break;

		case VIDEO_MODE_601_PAL_MASTER:			
			init_601_PAL[15] |= VIDEO_MODE_MASTER;
			writeRegs(client, (UINT8 *)&init_601_PAL, sizeof(init_601_PAL));
			if (encoder->input == 0)
				writeReg(client, 0x02, 0x0a);
				//writeReg(client, 0x02, 0x0e);	// Enable genlock
			writeReg(client, 0x07, TR0MODE_601 | TR0RST | VIDEO_MODE_MASTER);
			writeReg(client, 0x07, TR0MODE_601 | VIDEO_MODE_MASTER);
			break;
			
			
	        case VIDEO_MODE_601_NTSC_MASTER:
	                init_601_NTSC[15] |= VIDEO_MODE_MASTER;			
			writeRegs(client, (UINT8 *)&init_601_NTSC, sizeof(init_601_NTSC));
			if (encoder->input == 0)
				writeReg(client, 0x02, 0x0a);
				//writeReg(client, 0x02, 0x0e);	// Enable genlock
			writeReg(client, 0x07, TR0MODE_601 | TR0RST | VIDEO_MODE_MASTER);
			writeReg(client, 0x07, TR0MODE_601 | VIDEO_MODE_MASTER);
			break;
			
	        case VIDEO_MODE_601_PAL_SLAVER:			
			init_601_PAL[15] &= ~VIDEO_MODE_MASTER;
			writeRegs(client, (UINT8 *)&init_601_PAL, sizeof(init_601_PAL));
			if (encoder->input == 0)
				writeReg(client, 0x02, 0x0a);
				//writeReg(client, 0x02, 0x0e);	// Enable genlock
			writeReg(client, 0x07, TR0MODE_601 | TR0RST);
			writeReg(client, 0x07, TR0MODE_601);
			break;
			
		case VIDEO_MODE_601_NTSC_SLAVER:
		        init_601_NTSC[15] &= ~VIDEO_MODE_MASTER;
		        writeRegs(client, (UINT8 *)&init_601_NTSC, sizeof(init_601_NTSC));
			if (encoder->input == 0)
				writeReg(client, 0x02, 0x0a);
				//writeReg(client, 0x02, 0x0e);	// Enable genlock
			writeReg(client, 0x07, TR0MODE_601 | TR0RST);
			writeReg(client, 0x07, TR0MODE_601);
			break;

		default:
			//printf("%s: illegal s32Norm: %d\n", client->name, iarg);
			return HI_ERROR;

		}
		//printf("%s: switched to %s\n", client->name, s32Norms[iarg]);
		encoder->norm = iarg;
	}
		break;

	case ENCODER_SET_INPUT:
	{
		int iarg = *(int *) pArg;

		/* RJ: *iarg = 0: input is from decoder
		 *iarg = 1: input is from ZR36060
		 *iarg = 2: color bar */

		//printf("%s_command: set input from %s\n", client->name,	iarg == 0 ? "decoder" : "ZR36060");

		switch (iarg) {

		case 0:
			writeReg(client, 0x01, 0x20);
			writeReg(client, 0x08, TR1CAPT);	/* TR1 */
			writeReg(client, 0x02, 0x0e);	// Enable genlock
			writeReg(client, 0x07, TR0MODE_656 | TR0RST);
			writeReg(client, 0x07, TR0MODE_656);
			//udelay(10);
			break;

		case 1:
			writeReg(client, 0x01, 0x00);
			writeReg(client, 0x08, TR1PLAY);	/* TR1 */
			writeReg(client, 0x02, 0x08);
			writeReg(client, 0x07, TR0MODE_656 | TR0RST);
			writeReg(client, 0x07, TR0MODE_656);
			//udelay(10);
			break;

		default:
			//printf("%s: illegal input: %d\n", client->name, iarg);
			return HI_ERROR;

		}
		//printf("%s: switched to %s\n", client->name, inputs[iarg]);
		encoder->input = iarg;
	}
		break;

	case ENCODER_SET_OUTPUT:
	{
		int *iarg = pArg;

		/* not much choice of outputs */
		if (*iarg != 0) {
			return HI_ERROR;
		}
	}
		break;

	case ENCODER_ENABLE_OUTPUT:
	{
		int *iarg = pArg;

		encoder->enable = !!*iarg;
	}
		break;

	default:
		return HI_ERROR;
	}

	return HI_OK;
}
/*End of file. */

#endif