Esempio n. 1
0
//-------------------------------------------------------------------------------
// 설명: 프레임의 일부 영역을 특정 색으로 투명 영역을 지정
// 인수: a_fb : 화면에 출력할 프레임 버퍼
// 인수: a_color  : 투명하게 지정할 색상
int gx_set_frame_trans_color( frame_buffer_t *a_fb, color_t a_color)
{
    s3cfb_color_key_info_t  color_key_info;

    color_key_info.direction        = 0;
    switch( a_fb->colors)
    {
    case 16 :
        color_key_info.compkey_red      = a_color.red   >> 3;
        color_key_info.compkey_green    = a_color.green >> 2;
        color_key_info.compkey_blue     = a_color.blue  >> 3;
        break;
    default :
        color_key_info.compkey_red      = a_color.red;
        color_key_info.compkey_green    = a_color.green;
        color_key_info.compkey_blue     = a_color.blue;
        break;
    }

    if ( 0 > wait_v_sync( a_fb->fd) ){
        printf( "wait v sync error\n");
        return -1;
    }
    ioctl( a_fb->fd, _IOW( 'F', 304, s3cfb_color_key_info_t), &color_key_info); // Color Key Setup

    return gx_start_frame_trans( a_fb);
}
Esempio n. 2
0
unsigned short moduleHwDeinit(void) {
	unsigned int freq = 0;

	if(module_initialized == 1) {

		freq = FREQ38;

		/* Restore the lirc_rpi frequency to its default value */
		if(ioctl(module_fd, _IOW('i', 0x00000013, __u32), &freq) == -1) {
			logprintf(LOG_ERR, "could not restore default freq of the lirc_rpi module");
			exit(EXIT_FAILURE);
		} else {
			logprintf(LOG_DEBUG, "default freq of the lirc_rpi module set");
		}

		if(module_fd != 0) {
			close(module_fd);
			module_fd = 0;
		}

		logprintf(LOG_DEBUG, "deinitialized lirc_rpi module");
		module_initialized	= 0;
	}

	return EXIT_SUCCESS;
}
Esempio n. 3
0
unsigned short moduleHwInit(void) {
	unsigned int freq = 0;
	char *socket = NULL;

	if(settings_find_string("hw-socket", &socket) == 0) {
		module_socket = socket;
	}

	if(strcmp(module_socket, "/var/lirc/lircd") == 0) {
		logprintf(LOG_ERR, "refusing to connect to lircd socket");
		return EXIT_FAILURE;
	}

	if(module_initialized == 0) {
		if((module_fd = open(module_socket, O_RDWR)) < 0) {
			logprintf(LOG_ERR, "could not open %s", module_socket);
			return EXIT_FAILURE;
		} else {
			/* Only set the frequency once */
			if(module_setfreq == 0) {
				freq = FREQ433;
				/* Set the lirc_rpi frequency to 433.92Mhz */
				if(ioctl(module_fd, _IOW('i', 0x00000013, __u32), &freq) == -1) {
					logprintf(LOG_ERR, "could not set lirc_rpi send frequency");
					exit(EXIT_FAILURE);
				}
				module_setfreq = 1;
			}
			logprintf(LOG_DEBUG, "initialized lirc_rpi module");
			module_initialized = 1;
		}
	}
	return EXIT_SUCCESS;
}
Esempio n. 4
0
int
pcap_ex_immediate(pcap_t *pcap)
{
#ifdef _WIN32
    return pcap_setmintocopy(pcap, 1);
#elif defined BIOCIMMEDIATE
    int n = 1;
    return ioctl(pcap_fileno(pcap), BIOCIMMEDIATE, &n);
#else /* XXX On OSX Yosemite (10.10.3) BIOCIMMEDIATE is not defined) */
    int n = 1;
    return ioctl(pcap_fileno(pcap), _IOW('B',112, u_int), &n);
#endif
}
Esempio n. 5
0
int main()
{
    int ioctl_return;

    device_node = open(device_node_path, O_RDWR);

    if (device_node < 0) {
        printf("Could not open device node.\n");
        return EXIT_FAILURE;
    }

    // Perform read_1
    int read_command_1 = _IOR(DRIVER_TYPE, 1, userspace_data_read_1);
    ioctl_return = ioctl(device_node, read_command_1, &userspace_data_read_1);
    userspace_data_read_1[4] = '\0';
    printf("[%d] Performed ioctl\n", ioctl_return);
    printf("new userspace data: %s\n", userspace_data_read_1);

    // Perform read_2
    int read_command_2 = _IOR(DRIVER_TYPE, 1, userspace_data_read_2);
    ioctl_return = ioctl(device_node, read_command_2, &userspace_data_read_2);
    userspace_data_read_2[9] = '\0';
    printf("[%d] Performed ioctl\n", ioctl_return);
    printf("new userspace data: %s\n", userspace_data_read_2);

    // Perform write_1
    int write_command_1 = _IOW(DRIVER_TYPE, 1, userspace_data_send_1);
    ioctl_return = ioctl(device_node, write_command_1, &userspace_data_send_1);
    printf("[%d] Performed ioctl\n", ioctl_return);

    // Perform write_1
    int write_command_2 = _IOW(DRIVER_TYPE, 1, userspace_data_send_2);
    ioctl_return = ioctl(device_node, write_command_2, &userspace_data_send_2);
    printf("[%d] Performed ioctl\n", ioctl_return);

    close(device_node);
}
Esempio n. 6
0
void PIRInfraredLED::setDutyCycle(
  unsigned int dutyCycle)
{
//  if (dutyCycle > 100) dutyCycle = DEFAULT_DUTY_CYCLE;

#ifdef DEBUGGING
  std::cout << "Setting duty cycle to " << dutyCycle << std::endl;
#endif // DEBUGGING
  if (ioctl(fileDescriptor, _IOW('i', 0x15, __u32), &dutyCycle) == -1)
  {
    std::stringstream ss;
    ss << "Failed to set duty cycle percentage.\n";
    ss << "IR device returned error: " << strerror(errno) << "\n";
    throw PIRException(ss.str());
  }
}
Esempio n. 7
0
void PIRInfraredLED::setCarrierFrequency(
  unsigned int frequency)
{
//  if (!frequency) frequency = DEFAULT_FREQUENCY;

#ifdef DEBUGGING
  std::cout << "Setting frequency to " << frequency << std::endl;
#endif // DEBUGGING
  if (ioctl(fileDescriptor, _IOW('i', 0x13, __u32), &frequency) == -1)
  {
    std::stringstream ss;
    ss << "Failed to set carrier frequency.\n";
    ss << "IR device returned error: " << strerror(errno) << "\n";
    throw PIRException(ss.str());
  }
}
Esempio n. 8
0
int main(int argc, char *argv[])
{
  if(argc<3){
    e("missing arguments");
    return EXIT_FAILURE;
  }

  errno=0;
  int f=open("/dev/si0", O_RDWR);
  if(f==-1){
    e("open failed:%s",strerror(errno));
    return EXIT_FAILURE;
  }

  struct si_dma dma;
  struct si_dma_u32_fill *u32_fill=&dma.params.u32_fill;
  struct si_timeouts_info *t_info=&dma.t_info;
  dma.type=SI_DMA_TYPE_U32_FILL;
  dma.dir=SI_DMA_ON_DEVICE;
  //we don't really care here lets put one seconde!
  t_info->ring.n_max=1;
  t_info->ring.us=1000000;
  t_info->fence.n_max=1;
  t_info->fence.us=1000000;
  u32_fill->dst_addr=strtoul(argv[1],NULL,16);
  u32_fill->dws_n=strtoul(argv[2],NULL,16);
  u32_fill->constant=strtoul(argv[3],NULL,16);
  unsignedl req=_IOW('d',SI_DMA,dma);
  errno=0;
  int r=ioctl(f,req,&dma);
  switch(r){
  case -1:
    e("dma fill failed:%s",strerror(errno));
    return EXIT_FAILURE;
  case SI_RING_TIMEOUT:
    e("dma fill failed:ring timeout");
    return EXIT_FAILURE;
  case SI_FENCE_TIMEOUT:
    e("dma fill failed:fence timeout");
    return EXIT_FAILURE;
  }
  return EXIT_SUCCESS;
}
Esempio n. 9
0
    substream->no_mmap_ctrl = 1;
    return filp->f_op->ioctl(filp->f_dentry->d_inode, filp, cmd, arg);
}

/*
 */
#define AP(x) snd_ioctl32_##x

enum {
    SNDRV_PCM_IOCTL_HW_REFINE32 = _IOWR('A', 0x10, struct sndrv_pcm_hw_params32),
    SNDRV_PCM_IOCTL_HW_PARAMS32 = _IOWR('A', 0x11, struct sndrv_pcm_hw_params32),
    SNDRV_PCM_IOCTL_SW_PARAMS32 = _IOWR('A', 0x13, struct sndrv_pcm_sw_params32),
    SNDRV_PCM_IOCTL_STATUS32 = _IOR('A', 0x20, struct sndrv_pcm_status32),
    SNDRV_PCM_IOCTL_DELAY32 = _IOR('A', 0x21, s32),
    SNDRV_PCM_IOCTL_CHANNEL_INFO32 = _IOR('A', 0x32, struct sndrv_pcm_channel_info32),
    SNDRV_PCM_IOCTL_REWIND32 = _IOW('A', 0x46, u32),
    SNDRV_PCM_IOCTL_FORWARD32 = _IOW('A', 0x49, u32),
    SNDRV_PCM_IOCTL_WRITEI_FRAMES32 = _IOW('A', 0x50, struct sndrv_xferi32),
    SNDRV_PCM_IOCTL_READI_FRAMES32 = _IOR('A', 0x51, struct sndrv_xferi32),
    SNDRV_PCM_IOCTL_WRITEN_FRAMES32 = _IOW('A', 0x52, struct sndrv_xfern32),
    SNDRV_PCM_IOCTL_READN_FRAMES32 = _IOR('A', 0x53, struct sndrv_xfern32),
    SNDRV_PCM_IOCTL_SYNC_PTR32 = _IOWR('A', 0x23, struct sndrv_pcm_sync_ptr32),

};

struct ioctl32_mapper pcm_mappers[] = {
    MAP_COMPAT(SNDRV_PCM_IOCTL_PVERSION),
    /* MAP_COMPAT(SNDRV_PCM_IOCTL_INFO), */
    { SNDRV_PCM_IOCTL_INFO, snd_pcm_info_ioctl32 },
    MAP_COMPAT(SNDRV_PCM_IOCTL_TSTAMP),
    { SNDRV_PCM_IOCTL_HW_REFINE32, AP(pcm_hw_refine) },
Esempio n. 10
0
int main(int argc, char *argv[])
{
  if(argc<5){
    e("missing arguments");
    return EXIT_FAILURE;
  }

  uint64_t fb_gpu_addr=strtoul(argv[1],NULL,16);
  uint64_t w=strtoul(argv[2],NULL,10);
  uint64_t h=strtoul(argv[3],NULL,10);
  uint64_t arg_pixel_fmt=strtoul(argv[4],NULL,10);
  uint8_t pixel_fmt=arg_pixel_fmt;

  errno=0; 
  int f=open("/dev/si0", O_RDWR);
  if(f==-1){
    e("open failed:%s",strerror(errno));
    return EXIT_FAILURE;
  }

  uint64_t sz=h*w*alga_pixel_fmts_sz[pixel_fmt];
 
  errno=0; 
  void *dma_buffer0=mmap(NULL,sz,PROT_READ|PROT_WRITE,MAP_SHARED,f,0);
  if(dma_buffer0==MAP_FAILED){
    e("unable to mmap a dma buffer0:%s",strerror(errno));
    return EXIT_FAILURE;
  }


  printf("dma_buffer0=%p\n",dma_buffer0);
 

  uint64_t *qw=dma_buffer0;
  uint64_t clr_qws=sz>>3;
  while(clr_qws--)
	*qw++=0x0000ff000000ff00;

  struct si_dma dma;
  struct si_dma_l2l *l2l=&dma.params.l2l;
  struct si_timeouts_info *t_info=&dma.t_info;
  dma.type=SI_DMA_TYPE_L2L;
  dma.dir=SI_DMA_TO_DEVICE;
  //we don't really care here lets put one seconde!
  t_info->ring.n_max=1;
  t_info->ring.us=1000000;
  t_info->fence.n_max=1;
  t_info->fence.us=1000000;
  l2l->src_addr=(uint64_t)dma_buffer0;
  l2l->dst_addr=fb_gpu_addr;
  l2l->sz=sz;
  unsignedl req=_IOW('d',SI_DMA,dma);
  errno=0;
  int r=ioctl(f,req,&dma);
  switch(r){
  case -1:
    e("dma l2l failed:%s",strerror(errno));
    return EXIT_FAILURE;
  case SI_RING_TIMEOUT:
    e("dma l2l failed:ring timeout");
    return EXIT_FAILURE;
  case SI_FENCE_TIMEOUT:
    e("dma l2l failed:fence timeout");
    return EXIT_FAILURE;
  }
  return EXIT_SUCCESS;
}