static jresult_t cdc_start_data_xfer(uwh_cdc_dev_h dev_ctx, void *membuf,
juint32_t size, cdc_general_data_cb_t cb,
uwh_cdc_app_h app_ctx, void *app_priv, cdc_req_type type)
{
jresult_t rc = JENOMEM;
usbd_pipe_handle pipe;
cdc_cmd_priv_t *priv;
DECLARE_FNAME("cdc_start_data_xfer");
DBG_X(DHOST_CDC_GENERAL, ("%s: Entered\n", fname));
priv = cdc_init_request_priv(GENERAL_CDC_SC(dev_ctx), type, app_ctx,
app_priv);
if (!priv)
{
DBG_E(DHOST_CDC_GENERAL, ("%s: Failed to allocate private handle\n",
fname));
goto Error;
}
pipe = (type == SEND_DATA) ? priv->sc->bulk_pipe_out :
priv->sc->bulk_pipe_in;
priv->cdc_callback.data_cb = cb;
rc = cdc_xfer_data_pipe(priv, pipe, membuf, size);
Error:
if (rc)
{
DBG_E(DHOST_CDC_GENERAL, ("%s: Failed\n", fname));
if (priv)
cdc_uninit_request_priv(priv);
}
return rc;
}
static void wait_complition(player_ctx_t *ctx)
{
media_buffer_t *buf;
OMX_BUFFERHEADERTYPE *hdr;
OMX_ERRORTYPE err;
if (ctx->common.stop)
return; /* Force stop player by user */
buf = decode_get_free_video_buffer(ctx->common.demux_ctx);
if (!buf)
{
DBG_E("Unable to get free video buffer\n");
return;
}
hdr = (OMX_BUFFERHEADERTYPE *)buf->app_data;
hdr->pAppPrivate = buf;
hdr->nOffset = 0;
hdr->nFilledLen = 0;
hdr->nTimeStamp = to_omx_time(0);
hdr->nFlags = OMX_BUFFERFLAG_ENDOFFRAME | OMX_BUFFERFLAG_EOS | OMX_BUFFERFLAG_TIME_UNKNOWN;
err = OMX_EmptyThisBuffer(ilcore_get_handle(ctx->decoder), hdr);
if (err != OMX_ErrorNone)
{
DBG_E("OMX_EmptyThisBuffer failed. err=0x%08x\n", err);
return;
}
DBG_I("Waiting for end of stream\n");
while (!ctx->eos)
{
usleep(100000);
}
}
static void execute_job(void)
{
static int once = 0;
static jbool_t test_dpof = TEST_DPOF;
dps_job_info_t *jinfo;
sicd_object_t *obj;
juint_t i;
if (once)
{
once = 1;
return;
}
if (test_dpof)
{
execute_dpof_job();
return;
}
for (i=0; sample_image[i].image; i++)
;
jinfo = (dps_job_info_t*)jmalloc(i*sizeof(dps_job_info_t), M_ZERO);
if (!jinfo)
{
DBG_E(DSLAVE_DPS_API, ("execute_job: failed to allocate job info "
"array\n"));
return;
}
for (i=0; sample_image[i].image; i++)
{
obj = sicd_store_find_object(app_ctx.store_id, sample_image[i].id);
if (!obj)
{
DBG_E(DSLAVE_DPS_API, ("execute_job: could not find picture"
"object (%X) in store\n", sample_image[i].id));
return;
}
jinfo[i].file_id = obj->id;
if (TEST_DPS_CROPPING != DPS_CROPPING_OFF)
{
jinfo[i].cropping_area.left = TEST_DPS_CROPPING_LEFT;
jinfo[i].cropping_area.top = TEST_DPS_CROPPING_TOP;
jinfo[i].cropping_area.width = TEST_DPS_CROPPING_WIDTH;
jinfo[i].cropping_area.height = TEST_DPS_CROPPING_HEIGHT;
}
j_strlcpy(jinfo[i].file_name, sample_image[i].name,
DPS_FILENAME_SIZE + 1);
j_strlcpy(jinfo[i].date, DATE, DPS_DATE_SIZE + 1);
jinfo[i].copies = TEST_NUMBER_OF_COPIES;
}
dps_start_job(app_ctx.dpsh, &app_ctx.jconfig, jinfo, i);
jfree(jinfo);
}
ret_code_t ilcore_init_comp(ilcore_comp_h *h, OMX_CALLBACKTYPE *cb, char *name)
{
OMX_ERRORTYPE err;
ilcore_comp_ctx_t *ctx;
ctx = (ilcore_comp_ctx_t *)malloc(sizeof(ilcore_comp_ctx_t));
if (!ctx)
{
DBG_E("Memory allocation failed\n");
return L_FAILED;
}
memset(ctx, 0, sizeof(ilcore_comp_ctx_t));
slist_init(&ctx->event_list);
msleep_init(&ctx->event_sleep);
ctx->name = strdup(name);
if (!ctx->name)
{
DBG_E("strdup failed\n");
return L_FAILED;
}
err = OMX_GetHandle(&ctx->handle, name, ctx, cb);
if (err != OMX_ErrorNone)
{
DBG_E("OMX_GetHandle failed. err=%d\n", err);
return L_FAILED;
}
*h = ctx;
return L_OK;
}
jresult_t cdc_open_data_pipes(uwh_cdc_dev_h dev_ctx)
{
jresult_t rc = 0;
jcdc_dev_softc_t *sc = (jcdc_dev_softc_t *)dev_ctx;
DECLARE_FNAME("cdc_open_data_pipes");
DBG_V(DHOST_CDC_GENERAL, ("%s: Entered\n", fname));
/* Open bulk pipes */
rc = usbd_open_pipe(sc->d_iface, sc->bulk_ep_in,
USBD_EXCLUSIVE_USE, &sc->bulk_pipe_in);
if (rc)
{
DBG_E(DHOST_CDC_GENERAL, ("%s: Error opening bulk in pipe.\n",
fname));
return rc;
}
rc = usbd_open_pipe(sc->d_iface, sc->bulk_ep_out,
USBD_EXCLUSIVE_USE, &sc->bulk_pipe_out);
if (rc)
{
DBG_E(DHOST_CDC_GENERAL, ("%s: Error opening bulk out pipe.\n",
fname));
usbd_close_pipe(sc->bulk_pipe_in);
}
return rc;
}
ret_code_t ilcore_clean_tunnel(ilcore_tunnel_h h)
{
omx_tunnel_t *tunnel = (omx_tunnel_t *)h;
OMX_ERRORTYPE omx_err;
if (!tunnel || !tunnel->src_comp || !tunnel->dst_comp)
{
DBG_E("%s: Incorrect parameters\n", __FUNCTION__);
return L_FAILED;
}
ilcore_disable_port(tunnel->src_comp, tunnel->src_port, 0);
ilcore_disable_port(tunnel->dst_comp, tunnel->dst_port, 0);
omx_err = OMX_SetupTunnel(ilcore_get_handle(tunnel->src_comp), tunnel->src_port, NULL, 0);
if(omx_err != OMX_ErrorNone)
{
DBG_E("%s: could not unset tunnel on comp src %s port %d err = 0x%08x\n", __FUNCTION__,
ilcore_get_comp_name(tunnel->src_comp), tunnel->src_port, omx_err);
}
omx_err = OMX_SetupTunnel(ilcore_get_handle(tunnel->dst_comp), tunnel->dst_port, NULL, 0);
if(omx_err != OMX_ErrorNone)
{
DBG_E("%s: could not unset tunnel on comp dst %s port %d err = 0x%08x\n", __FUNCTION__,
ilcore_get_comp_name(tunnel->dst_comp), tunnel->dst_port, omx_err);
}
return L_OK;
}
ret_code_t ilcore_set_port_buffers_param(ilcore_comp_h h, int size, int count, int align)
{
OMX_ERRORTYPE err;
OMX_PARAM_PORTDEFINITIONTYPE param;
ilcore_comp_ctx_t *ctx = (ilcore_comp_ctx_t *)h;
OMX_INIT_STRUCT(param);
param.nPortIndex = IL_AUDIO_RENDER_IN_PORT;
err = OMX_GetParameter(ctx->handle, OMX_IndexParamPortDefinition, ¶m);
if (err != OMX_ErrorNone)
{
DBG_E("%s: OMX_IndexParamPortDefinition failed. err=0x%x\n", ctx->name, err);
return L_FAILED;
}
param.nBufferSize = size;
param.nBufferCountActual = count;
param.nBufferAlignment = align;
err = OMX_SetParameter(ctx->handle, OMX_IndexParamPortDefinition, ¶m);
if (err != OMX_ErrorNone)
{
DBG_E("%s: OMX_IndexParamPortDefinition failed. err=0x%x\n", ctx->name, err);
return L_FAILED;
}
return L_OK;
}
ret_code_t ilcore_flush_tunnel(ilcore_tunnel_h h)
{
OMX_ERRORTYPE omx_err;
omx_tunnel_t *tunnel = (omx_tunnel_t *)h;
if (!tunnel || !tunnel->src_comp || !tunnel->dst_comp)
{
DBG_E("%s: Incorrect parameters\n", __FUNCTION__);
return L_FAILED;
}
omx_err = OMX_SendCommand(ilcore_get_handle(tunnel->src_comp), OMX_CommandFlush, tunnel->src_port, NULL);
if(omx_err != OMX_ErrorNone && omx_err != OMX_ErrorSameState)
{
DBG_E("%s: Error flush port %d on component %s err = 0x%08x\n", __FUNCTION__, tunnel->src_port,
ilcore_get_comp_name(tunnel->src_comp), omx_err);
}
omx_err = OMX_SendCommand(ilcore_get_handle(tunnel->dst_comp), OMX_CommandFlush, tunnel->dst_port, NULL);
if(omx_err != OMX_ErrorNone && omx_err != OMX_ErrorSameState)
{
DBG_E("%s: Error flush port %d on component %s err = 0x%08x\n", __FUNCTION__, tunnel->dst_port,
ilcore_get_comp_name(tunnel->dst_comp), omx_err);
}
omx_core_comp_wait_command(tunnel->src_comp, OMX_CommandFlush, tunnel->src_port, 2000);
omx_core_comp_wait_command(tunnel->dst_comp, OMX_CommandFlush, tunnel->dst_port, 2000);
return L_OK;
}
static void dps_init_storage(void)
{
sicd_store_t *store;
sicd_object_t *obj;
jint_t i;
jresult_t rc;
store = sicd_store_get_first();
if (!store)
{
DBG_W(DSLAVE_DPS_API, ("dps_init_storage: could not find store "
"to place sample JPG in\n"));
return;
}
app_ctx.store_id = store->id;
/* Add our sample jpg objects for pictbridge sample tests */
for (i=0; sample_image[i].image; i++)
{
obj = jmalloc(sizeof(sicd_object_t), M_ZERO);
if (!obj)
{
DBG_E(DSLAVE_DPS_API, ("dps_init_storage: failed to allocate "
" sicd_object_t for sample image %u\n", i+1));
return;
}
sample_image[i].id = obj->id = sicd_get_new_obj_handle();
obj->info.storage_id = store->id;
obj->info.format = PTP_OBJ_FORMAT_IMG_JPEG;
obj->info.compressed_size = sample_image[i].image_size;
obj->info.thumb_format = PTP_OBJ_FORMAT_IMG_JPEG;
obj->info.thumb_compressed_size = sample_image[i].thumb_size;
obj->info.filename = ptp_string_atow(sample_image[i].name);
obj->data = (juint8_t*)jmalloc(obj->info.compressed_size, 0);
if (obj->data)
{
j_memcpy(obj->data, sample_image[i].image,
obj->info.compressed_size);
}
obj->sample_data = (juint8_t*)jmalloc(obj->info.thumb_compressed_size,
0);
if (obj->sample_data)
{
j_memcpy(obj->sample_data, sample_image[i].thumb,
obj->info.thumb_compressed_size);
}
rc = sicd_store_add_object(store->id, obj);
if (rc)
{
DBG_E(DSLAVE_DPS_API, ("dps_init_storage: failed on "
"sicd_store_add_object (%u)\n", rc));
sicd_free_object(NULL, obj);
}
}
}
ret_code_t ilcore_setup_tunnel(ilcore_tunnel_h h)
{
omx_tunnel_t *tunnel = (omx_tunnel_t *)h;
OMX_STATETYPE state;
OMX_ERRORTYPE omx_err;
if (!tunnel || !tunnel->src_comp || !tunnel->dst_comp)
{
DBG_E("%s: Incorrect parameters\n", __FUNCTION__);
return L_FAILED;
}
if (ilcore_get_state(tunnel->src_comp, &state) != L_OK)
return L_FAILED;
if (state == OMX_StateLoaded)
{
if (ilcore_set_state(tunnel->src_comp, OMX_StateIdle))
return L_FAILED;
}
if (ilcore_disable_port(tunnel->src_comp, tunnel->src_port, 0) != L_OK)
return L_FAILED;
if (ilcore_disable_port(tunnel->dst_comp, tunnel->dst_port, 0) != L_OK)
return L_FAILED;
omx_err = OMX_SetupTunnel(ilcore_get_handle(tunnel->src_comp), tunnel->src_port,
ilcore_get_handle(tunnel->dst_comp), tunnel->dst_port);
if(omx_err != OMX_ErrorNone)
{
DBG_E("%s: could not setup tunnel src %s port %d dst %s port %d err = 0x%08x\n", __FUNCTION__,
ilcore_get_comp_name(tunnel->src_comp), tunnel->src_port, ilcore_get_comp_name(tunnel->dst_comp),
tunnel->dst_port, omx_err);
return L_FAILED;
}
if (ilcore_enable_port(tunnel->src_comp, tunnel->src_port, 0) != L_OK)
return L_FAILED;
if (ilcore_enable_port(tunnel->dst_comp, tunnel->dst_port, 0) != L_OK)
return L_FAILED;
if (ilcore_get_state(tunnel->dst_comp, &state) != L_OK)
return L_FAILED;
omx_err = omx_core_comp_wait_command(tunnel->dst_comp, OMX_CommandPortEnable, tunnel->dst_port, 2000);
if(omx_err != OMX_ErrorNone)
return L_FAILED;
if (state == OMX_StateLoaded)
{
if (ilcore_set_state(tunnel->dst_comp, OMX_StateIdle))
return L_FAILED;
}
omx_err = omx_core_comp_wait_command(tunnel->src_comp, OMX_CommandPortEnable, tunnel->src_port, 2000);
if(omx_err != OMX_ErrorNone)
return L_FAILED;
return L_OK;
}
static jresult_t td243fc_rev2_attach(jdevice_t dev)
{
td243fc_rev2_softc_t *sc = (td243fc_rev2_softc_t *)j_device_get_softc(dev);
jbus_h bus = j_device_get_bus(dev);
jresult_t rc;
DBG_I(DSLAVE_DCD, ("DCD: Attaching controller: %s\n",
j_device_get_nameunit(dev)));
/* initializing device controller data */
sc->dev = dev;
/* Due to DMA limitation - it's operating not with transfer size but with
* "mega buffers" size we have to define all out requests as 64 bytes
* alligned for ep0*/
rc = jdma_alloc(TD243FC_EP0_MAX_PACKET_SIZE, 0, &sc->dma_buf.vaddr,
&sc->dma_buf.dma_addr, 0, &sc->dma_buf.cookie);
KASSERT(!rc, ("Can't alloc dma buffer for EP0 OUT\n"));
sc->dma_buf.buffer_size = TD243FC_EP0_MAX_PACKET_SIZE;
sc->mem_res = j_bus_alloc_resource(bus, SYS_RES_MEMORY, 0);
if (!sc->mem_res)
{
DBG_E(DSLAVE_DCD, ("DCD: Error allocating memory resource\n"));
rc = JEINVAL;
goto Error;
}
sc->irq_res = j_bus_alloc_resource(bus, SYS_RES_IRQ, 0);
if (!sc->irq_res)
{
DBG_E(DSLAVE_DCD, ("DCD: Error allocating interrupt resource\n"));
rc = JEINVAL;
goto Error;
}
sc->sc_lock = NULL;
jspinlock_init(&sc->sc_lock);
dcd_hw_init(sc);
rc = core_register_dcd(dev, &dcd_ops, &sc->core_ctx);
if (rc)
{
DBG_E(DSLAVE_DCD, ("DCD: register_dcd failed, rc=%d\n", rc));
goto Error;
}
DBG_V(DSLAVE_DCD, ("DCD: TD243 attached, controller revision=%.2x\n",
BFGET4(TD243FC_FCREV, READ4(TD243FC_HARDWARE_MODE_REG))));
return 0;
Error:
td243fc_rev2_detach(dev);
return rc;
}
static void mic_stream_select_cb(uwd_audio_app_h app_ctx,
uwd_audio_stream_h stream, uwd_audio_stream_alt_h stream_alt,
juint32_t samp_freq)
{
app_ctx_h app = (app_ctx_h)app_ctx;
uwd_audio_format_I_t *fmt;
jresult_t rc;
void *buf1, *buf2;
if (!stream_alt)
{
DBG_I(DSLAVE_AUDIO_APP, ("AUDIO_APP: Microphone stream disabled, "
"xfered=%d\n", app->mic.xfered));
return;
}
fmt = (uwd_audio_format_I_t *)stream_alt->format;
DBG_I(DSLAVE_AUDIO_APP, ("AUDIO_APP: Microphone stream enabled, "
"freq %d Hz %dbits %s\n", samp_freq, fmt->bit_resolution,
fmt->nr_channels == MONO ? "MONO":"STEREO"));
/* TODO audio data for all settings */
if (fmt->bit_resolution != 16 || fmt->nr_channels != STEREO ||
samp_freq != 22050)
{
DBG_E(DSLAVE_AUDIO_APP, ("AUDIO_APP: Audio settings not supported\n"));
return;
}
/* TODO configure hardware for selected audio settings */
app->mic.buf_len = audio_data_size/2;
app->mic.xfered = 0;
/* Use double buffering for stable streaming */
buf1 = &audio_data[0];
buf2 = &audio_data[app->mic.buf_len];
rc = uwd_audio_stream_write(app->fd_ctx, stream, buf1,
app->mic.buf_len, mic_complete, buf1);
if (rc)
goto Error;
rc = uwd_audio_stream_write(app->fd_ctx, stream, buf2,
app->mic.buf_len, mic_complete, buf2);
if (rc)
goto Error;
return;
Error:
DBG_E(DSLAVE_AUDIO_APP, ("AUDIO_APP: Microphone stream start failed, rc=%d"
"\n", rc));
}
static int init_sdl(video_player_h h)
{
player_ctx_t *ctx = (player_ctx_t *)h;
if (SDL_Init(SDL_INIT_EVERYTHING) < 0)
{
DBG_E("Unable SDL initialization\n");
return -1;
}
ctx->vp_rect.x = 0;
ctx->vp_rect.y = 0;
ctx->vp_rect.w = ctx->width;
ctx->vp_rect.h = ctx->height;
control_register_callback(ctx->common.ctrl_ctx, get_event_callback, ctx);
DBG_I("Create window. size %dx%d\n", ctx->width, ctx->height);
ctx->window = SDL_CreateWindow("SDL player", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, ctx->width,
ctx->height, SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE | SDL_WINDOW_OPENGL);
if (!ctx->window)
{
DBG_E("Unable create SDL window\n");
return -1;
}
/* Set "best" scale quality */
SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "2");
ctx->renderer = SDL_CreateRenderer(ctx->window, -1, SDL_RENDERER_ACCELERATED);
if (!ctx->renderer)
{
DBG_E("Unable to create renderer\n");
return -1;
}
SDL_SetRenderDrawColor(ctx->renderer, 0, 0, 0, 0xff);
ctx->texture = SDL_CreateTexture(ctx->renderer, SDL_PIXELFORMAT_ABGR8888, SDL_TEXTUREACCESS_STREAMING, ctx->width,
ctx->height);
if (!ctx->texture)
{
DBG_E("Unable to create texture\n");
return -1;
}
if (decode_setup_video_buffers(ctx->common.demux_ctx, VIDEO_BUFFERS, 1, 80 * 1024) != L_OK)
return L_FAILED;
ctx->common.first_pkt = 1;
msleep_init(&ctx->common.sched);
decode_start_read(ctx->common.demux_ctx);
return 0;
}
OMX_ERRORTYPE omx_core_comp_wait_command(ilcore_comp_h h, OMX_U32 command, OMX_U32 nData2, long timeout)
{
omx_event_t *event, cmp_event;
OMX_ERRORTYPE rc = OMX_ErrorNone;
ilcore_comp_ctx_t *ctx = (ilcore_comp_ctx_t *)h;
cmp_event.eEvent = OMX_EventCmdComplete;
cmp_event.nData1 = command;
cmp_event.nData2 = nData2;
while(1)
{
event = (omx_event_t *)slist_find_remove(ctx->event_list, find_func_cb, &cmp_event);
if (event)
{
if(event->eEvent == OMX_EventError && event->nData1 == (OMX_U32)OMX_ErrorSameState && event->nData2 == 1)
{
DBG_I("Component received event: same state\n");
rc = OMX_ErrorNone;
}
else if(event->eEvent == OMX_EventError)
{
rc = (OMX_ERRORTYPE)event->nData1;
DBG_E("Component received error: %d\n", rc);
}
else if(event->eEvent == OMX_EventCmdComplete && event->nData1 == command && event->nData2 == nData2)
{
DBG_I("Command %s completed\n", omx_cmd2str(command));
rc = OMX_ErrorNone;
}
else
{
DBG_E("Unknown event: %s\n", omx_event2str(event->eEvent));
rc = OMX_ErrorMax;
}
free(event);
return rc;
}
if (!timeout)
return OMX_ErrorMax;
if (msleep_wait(ctx->event_sleep, timeout) == MSLEEP_TIMEOUT)
{
DBG_E("Wait event timeout\n");
return OMX_ErrorMax;
}
}
return OMX_ErrorNone;
}
ret_code_t video_player_start(video_player_h *player_ctx, demux_ctx_h h, void *clock)
{
player_ctx_t *ctx;
ret_code_t rc = L_OK;
pthread_attr_t attr;
struct sched_param param;
ctx = (player_ctx_t *)malloc(sizeof(player_ctx_t));
if (!ctx)
{
DBG_E("Memory allocation failed\n");
return L_FAILED;
}
memset(ctx, 0, sizeof(player_ctx_t));
ctx->common.demux_ctx = h;
if (devode_get_video_size(h, &ctx->width, &ctx->height))
{
DBG_E("Can not get video size\n");
return L_FAILED;
}
if (decode_get_pixel_format(h, &ctx->pix_fmt))
{
DBG_E("Could not get frame pixel format\n");
return L_FAILED;
}
ctx->common.init = init_sdl;
ctx->common.uninit = uninit_sdl;
ctx->common.draw_frame = draw_frame_sdl;
ctx->common.pause = pause_toggle_sdl;
ctx->common.seek = seek_sdl;
ctx->common.schedule = schedule_sdl;
ctx->common.idle = idle_sdl;
/* Use default scheduler. Set SCHED_RR or SCHED_FIFO request root access */
pthread_attr_init(&attr);
param.sched_priority = 2;
pthread_attr_setschedparam(&attr, ¶m);
if (pthread_create(&ctx->common.task, &attr, player_main_routine, ctx))
{
DBG_E("Create thread falled\n");
rc = L_FAILED;
}
pthread_attr_destroy(&attr);
*player_ctx = ctx;
return rc;
}
OMX_ERRORTYPE omx_core_comp_wait_event(ilcore_comp_h h, OMX_EVENTTYPE eventType, long timeout)
{
omx_event_t *event;
OMX_ERRORTYPE rc = OMX_ErrorNone;
ilcore_comp_ctx_t *ctx = (ilcore_comp_ctx_t *)h;
while (1)
{
event = (omx_event_t *)slist_find_remove(ctx->event_list, search_event_cb, &eventType);
if (event)
{
if(event->eEvent == OMX_EventError && event->nData1 == (OMX_U32)OMX_ErrorSameState && event->nData2 == 1)
{
DBG_I("Component received event: same state\n");
rc = OMX_ErrorNone;
}
else if(event->eEvent == OMX_EventError)
{
rc = (OMX_ERRORTYPE)event->nData1;
DBG_E("Component received error: %d\n", rc);
}
else if(event->eEvent == eventType)
{
DBG_I("Got event: '%s', %d events remain in the queue\n", omx_event2str(event->eEvent),
slist_get_count(ctx->event_list));
rc = OMX_ErrorNone;
}
else
{
DBG_E("Unknown event\n");
rc = OMX_ErrorMax;
}
free(event);
return rc;
}
if (!timeout)
return OMX_ErrorMax;
if (msleep_wait(ctx->event_sleep, timeout) == MSLEEP_TIMEOUT)
{
DBG_E("Wait event timeout\n");
return OMX_ErrorMax;
}
}
return OMX_ErrorNone;
}
ret_code_t ilcore_add_comp_event(ilcore_comp_h h, OMX_EVENTTYPE eEvent, OMX_U32 nData1, OMX_U32 nData2)
{
omx_event_t *event;
ilcore_comp_ctx_t *ctx = (ilcore_comp_ctx_t *)h;
DBG_I("Add event: '%s' '%s' command: '%s' data: %d\n", ctx->name, omx_event2str(eEvent), omx_cmd2str(nData1),
nData2);
event = (omx_event_t *)malloc(sizeof(omx_event_t));
if (!event)
return OMX_ErrorInsufficientResources;
event->eEvent = eEvent;
event->nData1 = nData1;
event->nData2 = nData2;
omx_core_comp_remove(ctx, eEvent, nData1, nData2);
if (slist_add_tail(ctx->event_list, (list_node_t *)event))
{
free(event);
DBG_E("Function slist_add_tail failed\n");
return L_FAILED;
}
msleep_wakeup_broadcast(ctx->event_sleep);
return L_OK;
}
static void handle_setup(td243fc_rev2_softc_t *sc)
{
jresult_t rc;
/* HSU Addition */
/* Fix for the case where SETUP EP interrupt received before previous
OUT EP interrupt was handled. In this case we need to first handle
the OUT transaction. */
td243fc_rev2_ep_t *ep = &sc->ep[0];
request_t *req = ep->req;
if (req != NULL)
{
DBG_W(DSLAVE_DCD, ("DCD: handle_setup, ep0_out is pending\n"));
handle_ep0_out_req(sc);
/* Wait for Setup DMA initiated in handle_ep0_out_req by req_finish to
complete before processing the SETUP. */
jdelay_us(TD243FC_DMA_SETTLE_TIME);
}
/* HSU End */
DBG_V(DSLAVE_DCD, ("DCD: handle SETUP\n"));
CLEAR4(TD243FC_EPN_CONFIG_CONTROL_REG(0, 0), TD243FC_SETUP_RECV);
rc = core_handle_ep0(sc->core_ctx, sc->dma_buf.vaddr , SPEED_FULL);
if (rc)
{
DBG_E(DSLAVE_DCD, ("DCD: Setup request was handled rc = %d\n", rc));
dcd_stall_ep(sc->dev, NULL, 1);
prepare_setup_transfer(sc);
}
}
/**
* Function name: fatal_processing_error
* Description: Handles a fatal data processing error, including data pipes
* stalling.
* Parameters:
* @fd: (IN) FD context
*
* Return value: None
* Scope: Global
**/
void fatal_processing_error(fd_storage_t *fd)
{
DBG_E(DSLAVE_MS_USB, ("MASS: ******** Fatal processing error *********\n"));
core_stall_pipe(fd->core_ctx, fd->in_pipe, 1);
core_stall_pipe(fd->core_ctx, fd->out_pipe, 1);
clear_cmd_in_progress(fd);
}
static jresult_t calculate_ep_bufs(td243fc_rev2_softc_t *sc)
{
jint_t i;
juint16_t size = 0, free_size = GET_FREE_SIZE(sc);
juint16_t n;
/* calculate ep buffers */
for (i = 2; i < TD243FC_EP_NUM; i++)
size += sc->ep[i].global_max_packet;
DBG_V(DSLAVE_DCD, ("DCD: td243fc_resize_ep_buf need=%d, free=%d\n", size,
free_size));
n = free_size / size;
/* double-buffering */
if (n < 2)
{
DBG_E(DSLAVE_DCD, ("DCD: Not enough space in data memory for all "
"asked sizes free = %d, need = %d\n", free_size, size));
return JENOMEM;
}
/* even number */
n /= 2;
for (i = 2; i < TD243FC_EP_NUM; i++)
sc->ep[i].buf_size = n * sc->ep[i].global_max_packet;
return 0;
}
/**
* Function name: send_csw_callback
* Description: Completion callback, which is called at the completion of a
* command status wrapper (CSW) request (send_csw).
* Parameters:
* @request: (IN) Core request
*
* Return value: None
* Scope: Global
**/
void send_csw_callback(request_t *request)
{
fd_storage_t *fd = (fd_storage_t *)request->context;
request_status_t status = request->status;
DBG_V(DSLAVE_MS_USB, ("MASS: CSW sent %d out of %d.\n",
request->bytes_transferred, request->transfer_size));
/* Request is ready for next transfer */
request->status = REQUEST_READY;
if (status != REQUEST_COMPLETED ||
request->bytes_transferred != request->transfer_size)
{
DBG_W(DSLAVE_MS_USB, ("MASS: Error sending CSW. Stalling IN.\n"));
if (status != REQUEST_CANCELLED)
core_abort_pipe(fd->core_ctx, fd->in_pipe);
core_stall_pipe(fd->core_ctx, fd->in_pipe, 1);
}
else
{
jresult_t rc;
/* Get next Command (CBW) */
DBG_V(DSLAVE_MS_USB, ("MASS: Waiting for next CBW.\n"));
clear_cmd_in_progress(fd);
rc = post_read(fd, fd->cmd_request, USB_BULK_CB_WRAP_LEN,
cbw_read_complete, fd);
if (rc)
{
DBG_E(DSLAVE_MS_USB, ("Failed to post next CBW (%d)\n", rc));
}
}
}
static void config_complete(dps_appctx_t appctx,
dps_param_t result, dps_res_conf_t *printer_cfg)
{
int i;
dps_req_conf_t *cfg;
DECLARE_FNAME("config_complete");
DBG_X(DSLAVE_DPS_API, ("%s: entered\n", fname));
if (!result || !printer_cfg)
{
DBG_E(DSLAVE_DPS_API, ("%s: failed to parse printer configuration (%d)"
"\n", fname, result));
return;
}
DBG_I(DSLAVE_DPS_API, ("%s: result=%X\n", fname, result));
DBG_I(DSLAVE_DPS_API, ("%s: service_available=%X\n", fname,
printer_cfg->service_available));
cfg = &printer_cfg->conf;
DBG_I(DSLAVE_DPS_API, ("%s: version_count=%u\n", fname, cfg->versions_count));
for(i=0; i<cfg->versions_count; i++)
{
DBG_I(DSLAVE_DPS_API, ("%s: version=%d.%d\n", fname,
cfg->dps_version[i].major,
cfg->dps_version[i].minor));
}
DBG_I(DSLAVE_DPS_API, ("%s: vendor_name=%s\n", fname, cfg->vendor_name));
DBG_I(DSLAVE_DPS_API, ("%s: ven_spec_ver=%d.%d\n", fname,
cfg->vendor_specific_version.major,
cfg->vendor_specific_version.minor));
DBG_I(DSLAVE_DPS_API, ("%s: product_name=%s\n", fname, cfg->product_name));
DBG_I(DSLAVE_DPS_API, ("%s: serial_no=%s\n", fname, cfg->serial_no));
}
usbd_status usbd_get_string_desc(usbd_device_handle dev, juint8_t sindex,
jint16_t langid, usb_string_descriptor_t *sdesc, juint32_t *sizep)
{
usb_device_request_t req;
usbd_status err;
juint32_t actlen;
req.bmRequestType = UT_READ_DEVICE;
req.bRequest = UR_GET_DESCRIPTOR;
USETW2(req.wValue, UDESC_STRING, sindex);
USETW(req.wIndex, langid);
USETW(req.wLength, 2); /* only size byte first */
err = usbd_do_request_flags(dev, &req, (void *)sdesc, USBD_SHORT_XFER_OK,
&actlen, USBD_DEFAULT_TIMEOUT);
if (err)
return (err);
if (actlen < 2)
return (USBD_SHORT_XFER);
USETW(req.wLength, sdesc->bLength); /* the whole string */
err = usbd_do_request_flags(dev, &req, (void *)sdesc, USBD_SHORT_XFER_OK,
&actlen, USBD_DEFAULT_TIMEOUT);
if (err)
return (err);
if (actlen != sdesc->bLength)
{
DBG_E(DHOST_SUBR, ("usbd_get_string_desc: expected %d, "
"got %ld\n", sdesc->bLength, actlen));
}
*sizep = actlen;
return (USBD_NORMAL_COMPLETION);
}
/* Tunneling */
ret_code_t ilcore_create_tunnel(ilcore_tunnel_h *h, ilcore_comp_h src_comp, uint32_t src_port, ilcore_comp_h dst_comp,
uint32_t dst_port)
{
omx_tunnel_t *tunnel;
DBG_I("%s: src comp %s srs port %d dst comp %s dst port %d\n", __FUNCTION__, ilcore_get_comp_name(src_comp),
src_port, ilcore_get_comp_name(dst_comp), dst_port);
tunnel = (omx_tunnel_t *)malloc(sizeof(omx_tunnel_t));
if (!tunnel)
{
DBG_E("Memory allocation failed\n");
return L_FAILED;
}
memset(tunnel, 0, sizeof(omx_tunnel_t));
tunnel->src_comp = src_comp;
tunnel->src_port = src_port;
tunnel->dst_comp = dst_comp;
tunnel->dst_port = dst_port;
*h = tunnel;
return L_OK;
}
/**
* Function name: mass_storage_init
* Description: Initializes the mass storage function driver.
* Parameters:
* @ctx: (IN) Core context
*
* Return value: 0 on success, otherwise an error code
* Scope: Global
**/
jresult_t mass_storage_init(void *ctx)
{
jresult_t rc;
fd_storage_t *fd;
fd = jmalloc(sizeof(fd_storage_t), M_ZERO);
if (!fd)
return JENOMEM;
fd->core_ctx = ctx;
fd->state = STATE_DISABLED;
fd->fd_desc = copy_fd_desc();
if (!fd->fd_desc)
{
jfree(fd);
return JENOMEM;
}
/* Allocate requests */
fd->ep0_request = core_request_alloc(1, NULL);
if (!fd->ep0_request)
{
DBG_E(DSLAVE_MS_USB, ("mass_storage_init: Failed to allocate ep0 "
"request\n"));
return JENOMEM;
}
fd->cmd_request = core_request_alloc(SCSI_MAX_REQUEST_SIZE, NULL);
if (!fd->cmd_request)
{
DBG_E(DSLAVE_MS_USB, ("mass_storage_init: Failed to allocate cmd "
"request\n"));
return JENOMEM;
}
/* The completion callback of ep0 is always the same */
fd->ep0_request->complete = ep0_callback;
fd->ep0_request->context = (void *)fd;
rc = scsi_init(fd, &fd->total_luns, &fd->scsi_device);
if (rc)
return rc;
return core_register_fd(fd->core_ctx, &fd_ops, (context_t)fd);
}
static dps_param_t handle_get_file_id(dps_appctx_t appctx,
ptp_obj_handle_t autprint_mrk_file_id, char *dcf_file_path,
ptp_obj_handle_t *id)
{
jint_t i;
char *filename = NULL;
dps_param_t rc;
DECLARE_FNAME("handle_get_file_id");
DBG_X(DSLAVE_DPS_API, ("%s: entered\n", fname));
*id = 0;
rc = DPS_PARAM_MAKE(DPS_RESULT_UNSUPPORTED_OP,
DPS_RESULT_MIN_INVALID_VALUE);
for (i=0; sample_image[i].image; i++)
{
if (!sample_image[i].name)
continue;
filename = j_strdup(sample_image[i].name);
if (!filename)
{
DBG_E(DSLAVE_DPS_API, ("%s: error allocating memory (strdup)\n",
fname));
rc = DPS_RESULT_UNEXECUTED_OP;
goto Exit;
}
to_upper(filename);
/* TODO: The code that should be implemented here is not a
* straightforward string comparison.
* The dcf_file_path is the image's path relative
* to the DPOF file. In a real system e.g, the image'ss full path
* would be reconstructed in order to do a full path search
* for the file */
if (!j_strcmp(dcf_file_path+sizeof(DCF_PREFIX)-1, filename))
{
jfree(filename);
break;
}
jfree(filename);
}
if (sample_image[i].image)
{
*id = sample_image[0].id;
rc = DPS_RESULT_OK;
}
DBG_X(DSLAVE_DPS_API, ("%s: autprint_id: 0x%X filename: %s"
" img_id: 0x%X\n", fname, autprint_mrk_file_id, dcf_file_path, *id));
Exit:
return rc;
}
/* Build encapsulated cmd / response and transfer it */
static jresult_t encapsulated_transfer(cdc_cmd_priv_t *priv, void *membuf,
juint16_t size)
{
usbd_status status = USBD_NORMAL_COMPLETION;
usbd_xfer_handle xfer = NULL;
jcdc_dev_softc_t *sc = priv->sc;
usb_device_request_t req_t;
jbool_t in_xfer = (priv->req_type == SEND_ENCAP_CMD) ? 0 : 1;
DECLARE_FNAME("encapsulated_transfer");
DBG_X(DHOST_CDC_GENERAL, ("%s: Entered\n", fname));
xfer = usbd_alloc_xfer(sc->device);
if (!xfer)
{
DBG_E(DHOST_CDC_GENERAL, ("%s: Failed to allocate xfer\n", fname));
return JENOMEM;
}
/* Build request according to xfer direction */
req_t.bmRequestType = (in_xfer) ? UT_READ_CLASS_INTERFACE :
UT_WRITE_CLASS_INTERFACE;
req_t.bRequest = (in_xfer) ? CDC_GET_ENC_RESPONSE :
CDC_SEND_ENC_COMMAND;
USETW(req_t.wValue, 0);
USETW(req_t.wIndex, (juint16_t)sc->c_iface->index);
USETW(req_t.wLength, size);
/* setup xfer */
usbd_setup_default_xfer(xfer, priv->sc->device, priv,
CDC_CONTROL_XFER_TIMEOUT, &req_t, membuf, size, 0, jcdc_send_encap_cb);
/* Send the request over default pipe (EP0) */
status = usbd_transfer(xfer);
if (status && status != USBD_IN_PROGRESS)
{
DBG_E(DHOST_CDC_GENERAL, ("%s: Failed transferring control request, "
"error %d\n", j_device_get_nameunit(priv->sc->dev), status));
usbd_free_xfer(xfer);
return status_to_result(status);
}
return 0;
}
/* Class specific requests */
static jresult_t cdc_start_encapsulated_xfer(uwh_cdc_dev_h dev_ctx,
void *membuf, juint16_t size, cdc_general_command_cb_t c_cb,
cdc_general_data_cb_t r_cb, uwh_cdc_app_h app_ctx, void *app_priv,
cdc_req_type type)
{
jresult_t rc = JENOMEM;
cdc_cmd_priv_t *priv = NULL;
DECLARE_FNAME("cdc_start_encapsulated_xfer");
DBG_X(DHOST_CDC_GENERAL, ("%s: Entered\n", fname));
if (!IS_CDC_SC_FULL(*(GENERAL_CDC_SC(dev_ctx))))
{
DBG_E(DHOST_CDC_GENERAL, ("%s: Operation not supported\n",
fname));
rc = JEINVAL;
goto Error;
}
priv = cdc_init_request_priv(GENERAL_CDC_SC(dev_ctx), type, app_ctx,
app_priv);
if (!priv)
{
DBG_E(DHOST_CDC_GENERAL, ("%s: Failed to allocate private handle\n",
fname));
goto Error;
}
if (type == SEND_ENCAP_CMD)
priv->cdc_callback.command_cb = c_cb;
else
priv->cdc_callback.data_cb = r_cb;
rc = encapsulated_transfer(priv, membuf, size);
Error:
if (rc)
{
DBG_E(DHOST_CDC_GENERAL, ("%s: Failed [%d]\n", fname, rc));
if (priv)
cdc_uninit_request_priv(priv);
}
return rc;
}
/* Transfer completion callback - passed to the Core for async transfers */
static void cdc_data_xfer_complete(usbd_xfer_handle xfer,
usbd_private_handle priv, usbd_status rc)
{
cdc_cmd_priv_t *xfer_priv = (cdc_cmd_priv_t *)priv;
DECLARE_FNAME("cdc_data_xfer_complete");
KASSERT(xfer, ("%s: Null xfer handle\n", fname));
DBG_V(DHOST_CDC_GENERAL, ("%s: Data xfer %p complete, status %d\n", fname,
xfer, rc));
switch (rc)
{
case 0:
break;
case USBD_CANCELLED:
/* xfer has been canceled (abort_pipe was called) */
DBG_W(DHOST_CDC_GENERAL, ("%s: xfer %p was canceled\n", fname, xfer));
break;
default:
DBG_E(DHOST_CDC_GENERAL, ("%s: xfer completed with %d\n", fname, rc));
}
/* Activate callback */
if (xfer_priv->req_type == GET_DATA || xfer_priv->req_type == SEND_DATA)
{
xfer_priv->cdc_callback.data_cb(xfer_priv->app_ctx,
xfer_priv->app_priv, xfer->buffer, xfer->actlen,
status_to_result(rc));
}
#ifdef JDEBUG
else
{
DBG_E(DHOST_CDC_GENERAL, ("%s: Unknown request type %d\n", fname,
xfer_priv->req_type));
}
#endif
usbd_free_xfer(xfer);
cdc_uninit_request_priv(xfer_priv);
}
ret_code_t ilcore_set_state(ilcore_comp_h h, OMX_STATETYPE state)
{
OMX_ERRORTYPE err;
ilcore_comp_ctx_t *ctx = (ilcore_comp_ctx_t *)h;
err = OMX_SendCommand(ctx->handle, OMX_CommandStateSet, state, NULL);
if (err != OMX_ErrorNone)
{
DBG_E("Change state to idle failed. err=0x%x\n", err);
return L_FAILED;
}
err = omx_core_comp_wait_command(ctx, OMX_CommandStateSet, state, IL_WAIT_TIMEOUT);
if (err != OMX_ErrorNone)
{
DBG_E("Wait event failed. err=0x%x\n", err);
return L_FAILED;
}
return L_OK;
}
