void show_args_for_debug()
{
int i, max_pnl;
if(ttm.set_pnl_num)
max_pnl = ttm.pnl_num;
else
max_pnl = PNL_NUM;
for(i=0;i<max_pnl;i++)
{
printf("ap %d (on pnl %d), ",get_ap(i), i);
printf("ap_read_evt: %d, ",get_evt(i));
printf("ap_display_fb: %d, ",get_fb(i));
printf("pnl_%d_read_evt: %d\n",i, get_pnl_evt(i));
}
printf("master panel : %d\n",ttm.pnl_arg);
printf("calibrate : %s\n",(ttm.calibrate)?"yes":"no");
printf("split mode : %s\n",(ttm.split)?"yes":"no");
if(ttm.arg.bind.set)
{
int j;
for (i = 0; i < ttm.bind_data.pnl_num; i++)
{
printf("bind panel %d : ", i);
for (j = 0; j < ttm.bind_data.pnl[i].ap_num; j++)
{
printf("%d ",ttm.bind_data.pnl[i].group[j]);
}
printf("\n");
}
}
}
void tm_calibrate()
{
int fd, i, max_pnl=PNL_NUM;
fb_data_t fb;
evt_data_t evt;
if(ttm.set_pnl_num)
max_pnl = ttm.pnl_num;
memset(&fb, 0, sizeof(fb_data_t));
memset(&evt, 0, sizeof(evt_data_t));
memcpy(fb.dev, default_fb, sizeof(default_fb));
memcpy(fb.pan, default_pan, sizeof(default_pan));
memcpy(evt.dev, default_evt, sizeof(default_evt));
if(system("mount -o remount -w /"))
fprintf(stderr, "file system may be readonly!!\n");
for (i = 0; i < max_pnl; i++)
{
fb.fb_id = get_fb(i);
fb.dev[FB_NUM_POS]= '0' + fb.fb_id;
fb.pan[PAN_NUM_POS]= '0' + fb.fb_id;
evt.num = get_pnl_evt(i);
if((evt.dev[EVT_NUM_POS] = evt.num/10))
{
evt.dev[EVT_NUM_POS] += '0';
evt.dev[EVT_NUM_POS+1] = '0' + evt.num%10;
}
else
evt.dev[EVT_NUM_POS] = '0' + evt.num;
printf("calibrate %d pan : %s\n",i,fb.pan);
printf("calibrate %d fb : %s\n",i,fb.dev);
printf("calibrate %d evt : %s\n",i,evt.dev);
if((fd=open(fb.pan, O_RDWR))>=0)
{
if (write(fd, "0,0", 3)<0) {
dbg_log("write pan error, pan : %s",fb.pan);
}
close(fd);
}
else
{
printf("open pan error\n");
}
ts_cal(&fb, evt.dev);
}
update_calibrate();
refresh_tm_test(&fb);
system("mount -o remount -r /");
}
int main(int argc, char **argv)
{
int nr_opts;
nr_opts = process_args(argc, argv);
if (argc - nr_opts == 0) {
/* no filename given -> invent one */
char my_hostname[100];
gethostname(my_hostname, 100);
if (strlen(file_ext) == 0)
strcpy(file_ext, STD_EXT);
sprintf(filename, "%s.%s.%d%s",
PROGNAME, my_hostname, (int)time(NULL), file_ext);
} else {
if (strlen(argv[nr_opts]) > FILENAME_LEN - strlen(RAW_EXT)
- strlen(file_ext)) {
fprintf(stderr, "Error: given filename too long\n");
exit(1);
}
strcpy(filename, argv[nr_opts]);
strcat(filename, file_ext);
}
strcpy(raw_filename, filename);
strcat(raw_filename, RAW_EXT);
strcpy(fb_filename, filename);
strcat(fb_filename, FB_EXT);
if (!opt_process_raw_input_only) {
get_fb();
if (opt_write_fb)
write_fb(fb_mem, fb_size);
convert_fb_to_raw();
INFO("Writing raw picture data to %s\n", raw_filename);
write_raw(raw_pic_mem, raw_pic_size);
}
if (opt_convert)
convert_raw_to_pic(filename, raw_filename, xres, yres);
if (opt_delete_raw)
if (unlink(raw_filename) == -1)
perror(raw_filename);
return 0;
}
void draw_crap(void)
{
const kgi_mmio_region_t *fb = get_fb(display->mode, NULL);
char *ptr;
const int offs = time(NULL);
const int width = display->mode->img[0].virt.x;
assert(fb);
/* assuming the whole framebuffer is mapped in the aperture */
for(ptr = (char *)fb->win.virt; ptr < (char *)fb->win.virt + fb->win.size; ++ptr)
*ptr = ((int)ptr + offs) % (width - 1) & 0xff;
}
void init_fb(fb_data_t* fb, int pnl)
{
int i;
memcpy(fb->dev, default_fb, sizeof(default_fb));
memcpy(fb->pan, default_pan, sizeof(default_pan));
for (i = 0; i < STR_NUM; i++)
memset(fb->str[i], 0, MAX_STR_LEN);
fb->fb_id = get_fb(pnl);
fb->dev[FB_NUM_POS]= '0' + fb->fb_id;
fb->pan[PAN_NUM_POS]= '0' + fb->fb_id;
}
int select_fb(int ap)
{
int fb = -1;
if(ttm.arg.bind.set)
{
fb = get_fb(select_bind_pnl(ap));
}
if(fb < 0)
{
if (ap == 6)
fb = PNL2_FB_NUM;
else if(ap == 4)
fb = PNL1_FB_NUM;
else
fb = PNL0_FB_NUM;
}
return fb;
}
kern_return_t kgi_get_fb_resource(trivfs_protid_t io_object, kgic_mapper_resource_info_result_t *fb)
{
if (!io_object)
return EOPNOTSUPP;
if (!(io_object->po->openmodes & O_READ))
return EBADF;
fprintf(stderr, "kgi_get_fb_resource()\n");
{
struct po_state *const state = io_object->po->hook;
/* first things first... */
if (state->status != KGI_STATUS_SET && state->status != KGI_STATUS_CHECKED)
return EPROTO;
{
int res_index;
const kgi_mmio_region_t *fb_res = get_fb(&state->mode, &res_index);
if (!fb_res)
return ENXIO;
memset(fb, 0, sizeof (*fb));
strncpy(fb->name, fb_res->name, sizeof (fb->name)); fb->name[sizeof (fb->name)-1] = 0;
fb->resource = res_index;
fb->image = -1;
fb->type = fb_res->type;
fb->protection = fb_res->prot;
fb->info.mmio.access = fb_res->access;
fb->info.mmio.align = fb_res->align;
fb->info.mmio.size = fb_res->size;
fb->info.mmio.window = fb_res->win.size;
}
}
return 0;
}
kern_return_t trivfs_S_io_map(
trivfs_protid_t io_object,
mach_port_t reply, mach_msg_type_name_t reply_type,
memory_object_t *rd_obj, mach_msg_type_name_t *rd_type,
memory_object_t *wr_obj, mach_msg_type_name_t *wr_type)
{
if (!io_object)
return EOPNOTSUPP;
fprintf(stderr, "trivfs_S_io_map()\n");
{
const int rd = io_object->po->openmodes | O_READ;
const int wr = io_object->po->openmodes | O_WRITE;
const vm_prot_t prot = (rd ? VM_PROT_READ : 0) | (wr ? VM_PROT_WRITE : 0);
struct po_state *const state = io_object->po->hook;
if(!prot)
return EBADF;
/* first things first... */
if (state->status != KGI_STATUS_SET)
return EPROTO;
/*
* Note: The requirement to have a mode set before calling this
* RPC, means that we can't actually get here without
* openmodes|O_WRITE; so strictly the handling of O_WRITE is
* not necessary. It *is* however theoretically possible --
* though strange -- to get here without O_READ; so we *do*
* need the handling of this.
*
* To keep things simple, we just use the standard openmodes
* handling (i.e. both O_READ and O_WRITE), even if strictly
* speaking it's overkill.
*/
switch (state->mmap_mode) {
case KGI_MMAP_NONE:
return EPROTO;
case KGI_MMAP_FB: {
const kgi_mmio_region_t *fb_res = get_fb(&state->mode, NULL);
if(!fb_res)
return ENXIO;
{
const memory_object_t fb_obj = get_fb_object(fb_res->win.phys, fb_res->win.size, prot);
*rd_obj = rd ? fb_obj : MACH_PORT_NULL;
*wr_obj = wr ? fb_obj : MACH_PORT_NULL;
/* if the port is used twice, make sure we have a second reference */
if (rd && wr)
mach_port_mod_refs(mach_task_self(), fb_obj, MACH_PORT_RIGHT_SEND, 1);
*rd_type = *wr_type = MACH_MSG_TYPE_MOVE_SEND;
}
} /* case KGI_MMAP_FB */
}
}
return 0;
}
