void uci_open(uci_t * uci, engine_t * engine) {
char string[StringSize];
int event;
ASSERT(uci!=NULL);
ASSERT(engine!=NULL);
// init
uci->engine = engine;
uci->name = NULL;
my_string_set(&uci->name,"<empty>");
uci->author = NULL;
my_string_set(&uci->author,"<empty>");
uci->option_nb = 0;
uci->ready_nb = 0;
uci->searching = 0;
uci->pending_nb = 0;
uci->multipv_mode = false;
board_start(uci->board);
uci_clear(uci);
// send "uci" and wait for "uciok"
engine_send(uci->engine,"uci");
do {
engine_get(uci->engine,string,StringSize);
event = uci_parse(uci,string);
} while (!engine_eof(Engine) && (event & EVENT_UCI) == 0);
}
void quit() {
char string[StringSize];
my_log("POLYGLOT *** QUIT ***\n");
if (Init) {
stop_search();
engine_send(Engine,"quit");
// wait for the engine to quit
#ifndef _WIN32
while (true) {
engine_get(Engine,string,sizeof(string)); // HACK: calls exit() on receiving EOF
}
#else
Idle500msecs();//
while(peek_engine_get(Engine,string,StringSize))
Idle();
#endif
uci_close(Uci);
}
exit(EXIT_SUCCESS);
}
static void engine_step() {
char string[StringSize];
int event;
// parse UCI line
engine_get(Engine,string,StringSize);
event = uci_parse(Uci,string);
// react to events
if ((event & EVENT_READY) != 0) {
// the engine is now ready
if (!Uci->ready) {
Uci->ready = true;
if (XB->proto_ver >= 2) xboard_send(XBoard,"feature done=1");
}
if (!DelayPong && XB->ping >= 0) {
xboard_send(XBoard,"pong %d",XB->ping);
XB->ping = -1;
}
}
if ((event & EVENT_MOVE) != 0 && State->state == THINK) {
// the engine is playing a move
// MEGA HACK: estimate remaining time because XBoard won't send it!
my_timer_stop(State->timer);
XB->my_time -= my_timer_elapsed_real(State->timer);
XB->my_time += XB->inc;
if (XB->mps != 0 && (game_move_nb(Game) + 1) % XB->mps == 0) XB->my_time += XB->base;
if (XB->my_time < 0.0) XB->my_time = 0.0;
// play the engine move
comp_move(Uci->best_move);
}
if ((event & EVENT_PV) != 0) {
// the engine has sent a new PV
send_pv();
}
}
static int ioctl_engine_close(struct drm_device *dev, void *data,
struct drm_file *file)
{
struct dce_file_priv *priv = omap_drm_file_priv(file, dce_mapper_id);
struct drm_omap_dce_engine_close *arg = data;
uint32_t engine;
int ret;
ret = engine_get(priv, arg->eng_handle, &engine);
if (ret)
return ret;
engine_unregister(priv, arg->eng_handle);
return engine_close(priv, engine);
}
void uci_send_isready_sync(uci_t * uci) {
char string[StringSize];
int event;
ASSERT(uci_is_ok(uci));
// send "isready" and wait for "readyok"
uci_send_isready(uci);
do {
engine_get(uci->engine,string,StringSize);
event = uci_parse(uci,string);
} while (!engine_eof(Engine) && (event & EVENT_READY) == 0);
}
void uci_send_stop_sync(uci_t * uci) {
char string[StringSize];
int event;
ASSERT(uci_is_ok(uci));
ASSERT(uci->searching);
ASSERT(uci->pending_nb>=1);
// send "stop" and wait for "bestmove"
uci_send_stop(uci);
do {
engine_get(uci->engine,string,StringSize);
event = uci_parse(uci,string);
} while (!engine_eof(Engine) && (event & EVENT_STOP) == 0);
}
static bool engine_step() {
char string[StringSize];
int event;
engine_get(Engine,string,StringSize);
event = uci_parse(Uci,string);
if ((event & EVENT_MOVE) != 0) {
return false;
}
if ((event & EVENT_PV) != 0) {
LastMove = Uci->best_pv[0];
LastDepth = Uci->best_depth;
LastSelDepth = Uci->best_sel_depth;
LastScore = Uci->best_score;
LastTime = Uci->time;
LastNodeNb = Uci->node_nb;
line_copy(LastPV,Uci->best_pv);
if (LastMove != FirstMove) {
FirstMove = LastMove;
FirstDepth = LastDepth;
FirstSelDepth = LastSelDepth;
FirstScore = LastScore;
FirstTime = LastTime;
FirstNodeNb = LastNodeNb;
line_copy(FirstPV,LastPV);
}
}
return true;
}
static int ioctl_codec_create(struct drm_device *dev, void *data,
struct drm_file *file)
{
struct dce_file_priv *priv = omap_drm_file_priv(file, dce_mapper_id);
struct drm_omap_dce_codec_create *arg = data;
struct dce_rpc_codec_create_rsp *rsp;
int ret;
/* if we are not re-starting a syscall, send req */
if (!arg->token) {
struct dce_rpc_codec_create_req req = {
.hdr = MKHDR(CODEC_CREATE),
.codec_id = arg->codec_id,
};
strncpy(req.name, arg->name, sizeof(req.name));
ret = engine_get(priv, arg->eng_handle, &req.engine);
if (ret)
return ret;
ret = PTR_RET(get_paddr(priv, hdr(&req), &req.sparams, arg->sparams_bo));
if (ret)
goto rpsend_out;
ret = rpsend(priv, &arg->token, hdr(&req), sizeof(req));
rpsend_out:
if (ret)
return rpabort(hdr(&req), ret);
}
/* then wait for reply, which is interruptible */
ret = rpwait(priv, arg->token, hdr(&rsp), sizeof(*rsp));
if (ret)
return ret;
arg->codec_handle = codec_register(priv, rsp->codec, arg->codec_id);
if (!codec_valid(priv, arg->codec_handle)) {
codec_delete(priv, rsp->codec, arg->codec_id);
ret = -ENOMEM;
}
kfree(rsp);
return ret;
}
static int ioctl_codec_control(struct drm_device *dev, void *data,
struct drm_file *file)
{
struct dce_file_priv *priv = omap_drm_file_priv(file, dce_mapper_id);
struct drm_omap_dce_codec_control *arg = data;
struct dce_rpc_codec_control_rsp *rsp;
int ret;
/* if we are not re-starting a syscall, send req */
if (!arg->token) {
struct dce_rpc_codec_control_req req = {
.hdr = MKHDR(CODEC_CONTROL),
.cmd_id = arg->cmd_id,
};
ret = codec_get(priv, arg->codec_handle, &req.codec, &req.codec_id);
if (ret)
return ret;
ret = PTR_RET(get_paddr(priv, hdr(&req), &req.dparams, arg->dparams_bo));
if (ret)
goto rpsend_out;
ret = PTR_RET(get_paddr(priv, hdr(&req), &req.status, arg->status_bo));
if (ret)
goto rpsend_out;
ret = rpsend(priv, &arg->token, hdr(&req), sizeof(req));
rpsend_out:
if (ret)
return rpabort(hdr(&req), ret);
}
/* then wait for reply, which is interruptible */
ret = rpwait(priv, arg->token, hdr(&rsp), sizeof(*rsp));
if (ret)
return ret;
arg->result = rsp->result;
kfree(rsp);
return 0;
}
struct viddec3_in_args {
int32_t size; /* struct size */
int32_t num_bytes;
int32_t input_id;
};
struct videnc2_in_args {
int32_t size;
int32_t input_id;
int32_t control;
};
union xdm2_buf_size {
struct {
int32_t width;
int32_t height;
} tiled;
int32_t bytes;
};
struct xdm2_single_buf_desc {
uint32_t buf;
int16_t mem_type; /* XXX should be XDM_MEMTYPE_BO */
int16_t usage_mode;
union xdm2_buf_size buf_size;
int32_t accessMask;
};
struct xdm2_buf_desc {
int32_t num_bufs;
struct xdm2_single_buf_desc descs[16];
};
struct video2_buf_desc {
int32_t num_planes;
int32_t num_meta_planes;
int32_t data_layout;
struct xdm2_single_buf_desc plane_desc[3];
struct xdm2_single_buf_desc metadata_plane_desc[3];
/* rest of the struct isn't interesting to kernel.. if you are
* curious look at IVIDEO2_BufDesc in ivideo.h in codec-engine
*/
uint32_t data[30];
};
#define XDM_MEMTYPE_RAW 0
#define XDM_MEMTYPE_TILED8 1
#define XDM_MEMTYPE_TILED16 2
#define XDM_MEMTYPE_TILED32 3
#define XDM_MEMTYPE_TILEDPAGE 4
/* copy_from_user helper that also checks to avoid overrunning
* the 'to' buffer and advances dst ptr
*/
static inline int cfu(void **top, uint64_t from, int n, void *end)
{
void *to = *top;
int ret;
if ((to + n) >= end) {
DBG("dst buffer overflow!");
return -EFAULT;
}
ret = copy_from_user(to, (char __user *)(uintptr_t)from, n);
*top = to + n;
return ret;
}
static inline struct drm_gem_object * handle_single_buf_desc(
struct dce_file_priv *priv, struct dce_rpc_hdr *req,
uint32_t base_bo, struct xdm2_single_buf_desc *desc)
{
struct drm_gem_object *obj;
uint32_t flags;
int32_t offset;
/* maybe support remapping user ptrs later on.. */
if (desc->mem_type != XDM_MEMTYPE_BO &&
desc->mem_type != XDM_MEMTYPE_BO_OFFSET)
return ERR_PTR(-EINVAL);
if (desc->mem_type == XDM_MEMTYPE_BO_OFFSET) {
/* desc->buf is an offset to base_bo, which is descs[0].buf as
* passed to _process */
offset = desc->buf;
desc->buf = base_bo;
} else {
offset = -1;
}
obj = get_paddr(priv, req, &desc->buf, desc->buf);
if (IS_ERR(obj))
return obj;
if (offset != -1)
desc->buf += offset;
flags = omap_gem_flags(obj);
switch(flags & OMAP_BO_TILED) {
case OMAP_BO_TILED_8:
desc->mem_type = XDM_MEMTYPE_TILED8;
break;
case OMAP_BO_TILED_16:
desc->mem_type = XDM_MEMTYPE_TILED16;
break;
case OMAP_BO_TILED_32:
desc->mem_type = XDM_MEMTYPE_TILED32;
break;
default:
// XXX this is where it gets a bit messy.. some codecs
// might want to see XDM_MEMTYPE_RAW for bitstream buffers
desc->mem_type = XDM_MEMTYPE_TILEDPAGE;
break;
}
if (flags & OMAP_BO_TILED) {
uint16_t w, h;
omap_gem_tiled_size(obj, &w, &h);
desc->buf_size.tiled.width = w;
desc->buf_size.tiled.height = h;
}
// XXX not sure if the codecs care about usage_mode.. but we
// know if the buffer is cached or not so we could set DATASYNC
// bit if needed..
return obj;
}
static inline int handle_buf_desc(struct dce_file_priv *priv,
void **ptr, void *end, struct dce_rpc_hdr *req, uint64_t usr,
struct drm_gem_object **o1, struct drm_gem_object **o2, uint8_t *len)
{
struct xdm2_buf_desc *bufs = *ptr;
uint32_t base_bo;
int i, ret;
/* read num_bufs field: */
ret = cfu(ptr, usr, 4, end);
if (ret)
return ret;
/* read rest of structure: */
ret = cfu(ptr, usr+4, bufs->num_bufs * sizeof(bufs->descs[0]), end);
if (ret)
return ret;
*len = (4 + bufs->num_bufs * sizeof(bufs->descs[0])) / 4;
/* the bo used as a base for XDM_MEMTYPE_BO_OFFSET descriptors */
base_bo = bufs->descs[0].buf;
/* handle buffer mapping.. */
for (i = 0; i < bufs->num_bufs; i++) {
struct drm_gem_object *obj =
handle_single_buf_desc(priv, req, base_bo,
&bufs->descs[i]);
if (IS_ERR(obj)) {
return PTR_ERR(obj);
}
if (i == 0)
*o1 = obj;
if (o2 && (i == 1))
*o2 = obj;
}
return 0;
}
/*
* VIDDEC3_process VIDENC2_process
* VIDDEC3_InArgs *inArgs VIDENC2_InArgs *inArgs
* XDM2_BufDesc *outBufs XDM2_BufDesc *outBufs
* XDM2_BufDesc *inBufs VIDEO2_BufDesc *inBufs
*/
static inline int handle_videnc2(struct dce_file_priv *priv,
void **ptr, void *end, int32_t *input_id,
struct dce_rpc_codec_process_req *req,
struct drm_omap_dce_codec_process *arg)
{
WARN_ON(1); // XXX not implemented
// codec_lockbuf(priv, arg->codec_handle, in_args->input_id, y, uv);
return -EFAULT;
}
void search(const board_t * board, int depth_max, double time_max) {
char string[256];
ASSERT(board_is_ok(board));
ASSERT(depth_max>=1&&depth_max<DepthMax);
ASSERT(time_max>=0.0);
// engine
Depth = 0;
BestMove = MoveNone;
BestValue = 0;
line_clear(BestPV);
NodeNb = 0;
LeafNb = 0;
Time = 0.0;
Move = MoveNone;
MovePos = 0;
MoveNb = 0;
// init
uci_send_ucinewgame(Uci);
uci_send_isready_sync(Uci);
// position
if (!board_to_fen(board,string,256)) ASSERT(false);
engine_send(Engine,"position fen %s",string);
// search
engine_send_queue(Engine,"go");
engine_send_queue(Engine," movetime %.0f",time_max*1000.0);
engine_send_queue(Engine," depth %d",depth_max);
engine_send(Engine,""); // newline
// wait for feed-back
while (true) {
engine_get(Engine,string,256);
if (false) {
} else if (match(string,"bestmove * ponder *")) {
BestMove = move_from_can(Star[0],board);
ASSERT(BestMove!=MoveNone&&move_is_legal(BestMove,board));
break;
} else if (match(string,"bestmove *")) {
BestMove = move_from_can(Star[0],board);
ASSERT(BestMove!=MoveNone&&move_is_legal(BestMove,board));
break;
}
}
printf("\n");
}
static void engine_step() {
char string[StringSize];
int event;
// parse UCI line
engine_get(Engine,string,StringSize); //blocking read...
event = uci_parse(Uci,string);
// react to events
if ((event & EVENT_READY) != 0) {
#ifdef _WIN32
SetEvent(Engine_ready_ok);
#endif
if (!Uci->ready) {
Uci->ready = true;
if (XB->proto_ver >= 2) xboard_send(XBoard,"feature done=1");
}
if (!DelayPong && XB->ping >= 0) {
xboard_send(XBoard,"pong %d",XB->ping);
XB->ping = -1;
}
}
if ((event & EVENT_MOVE) != 0 && State->state == THINK) {
// the engine is playing a move
// MEGA HACK: estimate remaining time because XBoard won't send it!
my_timer_stop(State->timer);
XB->my_time -= my_timer_elapsed_real(State->timer);
XB->my_time += XB->inc;
if (XB->mps != 0 && (game_move_nb(Game) + 1) % XB->mps == 0) XB->my_time += XB->base;
if (XB->my_time < 0.0) XB->my_time = 0.0;
// play the engine move
comp_move(Uci->best_move);
}
if ((event & EVENT_PV) != 0) {
// the engine has sent a new PV
send_pv();
}
if ((event & EVENT_INFO) != 0){
if(!option_get_bool("InfoStrings"))
xboard_send(XBoard,"#%d %+d %.0f " S64_FORMAT " %s ",Uci->best_depth,Uci->best_score,Uci->time*100.0,Uci->node_nb,Uci->info_string);
else
xboard_send(XBoard,"%d %+d %.0f " S64_FORMAT " %s ",Uci->best_depth,Uci->best_score,Uci->time*100.0,Uci->node_nb,Uci->info_string);
}
if((event & (EVENT_DRAW|EVENT_RESIGN))!=0){
my_log("POYGLOT draw offer/resign from engine\n");
if(uci_option_exist(Uci,"UCI_DrawOffers")){
if(event & EVENT_DRAW)
xboard_send(XBoard,"offer draw");
else
xboard_send(XBoard,"resign");
}
}
return ;
}
