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));
}
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;
}
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));
}
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;
}
static ret_code_t av_codecid2max_type(enum AVCodecID codec_id, OMX_VIDEO_CODINGTYPE *coding_type)
{
switch (codec_id)
{
case AV_CODEC_ID_H264:
DBG_I("Use codec: H264\n");
*coding_type = OMX_VIDEO_CodingAVC;
break;
case AV_CODEC_ID_MPEG4:
DBG_I("Use codec: MPEG4\n");
*coding_type = OMX_VIDEO_CodingMPEG4;
break;
case AV_CODEC_ID_MPEG1VIDEO:
case AV_CODEC_ID_MPEG2VIDEO:
DBG_I("Use codec: MPEG2\n");
*coding_type = OMX_VIDEO_CodingMPEG2;
break;
case AV_CODEC_ID_H263:
DBG_I("Use codec: H263\n");
*coding_type = OMX_VIDEO_CodingMPEG4;
break;
case AV_CODEC_ID_VP6:
case AV_CODEC_ID_VP6F:
case AV_CODEC_ID_VP6A:
DBG_I("Use codec: VP6\n");
*coding_type = OMX_VIDEO_CodingVP6;
break;
case AV_CODEC_ID_VP8:
DBG_I("Use codec: VP8\n");
*coding_type = OMX_VIDEO_CodingVP8;
break;
case AV_CODEC_ID_THEORA:
DBG_I("Use codec: THEORA\n");
*coding_type = OMX_VIDEO_CodingTheora;
break;
case AV_CODEC_ID_MJPEG:
case AV_CODEC_ID_MJPEGB:
DBG_I("Use codec: MJPEG\n");
*coding_type = OMX_VIDEO_CodingMJPEG;
break;
case AV_CODEC_ID_VC1:
case AV_CODEC_ID_WMV3:
DBG_I("Use codec: WMV\n");
*coding_type = OMX_VIDEO_CodingWMV;
break;
default:
DBG_E("Unknown codec ID: %d\n", codec_id);
*coding_type = OMX_VIDEO_CodingAutoDetect;
break;
}
return L_OK;
}
static void speaker_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: Speaker stream disabled, "
"xfered=%d\n", app->speaker.xfered));
return;
}
fmt = (uwd_audio_format_I_t *)stream_alt->format;
DBG_I(DSLAVE_AUDIO_APP, ("AUDIO_APP: Speaker stream enabled, freq %d Hz "
"%dbits %s\n", samp_freq, fmt->bit_resolution,
fmt->nr_channels == MONO ? "MONO":"STEREO"));
/* TODO configure hardware for selected audio settings */
app->speaker.buf_len = SPEAKER_BUFFER_SIZE;
app->speaker.xfered = 0;
/* Use double buffering for stable streaming */
buf1 = &speaker_bufs[0][0];
buf2 = &speaker_bufs[1][0];
rc = uwd_audio_stream_read(app->fd_ctx, stream, buf1,
app->speaker.buf_len, speaker_complete, buf1);
if (rc)
goto Error;
rc = uwd_audio_stream_read(app->fd_ctx, stream, buf2,
app->speaker.buf_len, speaker_complete, buf2);
if (rc)
goto Error;
return;
Error:
DBG_E(DSLAVE_AUDIO_APP, ("AUDIO_APP: Speaker stream start failed, rc=%d\n",
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);
}
}
jresult_t devmon_force_detach(mdev_t dev)
{
DBG_I(DUTIL_DEVMON, ("DEVMON: Forcing detach for %p [%s]\n",
dev, j_device_get_nameunit(dev)));
return j_device_detach((jdevice_t)dev);
}
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;
}
/**
* Function name: cbw_read_complete
* Description: Completion callback, which is called at the completion of a
* command block wrapper (CBW) request (send_csw).
* Description: Command block wrapper (CBW) read completion callback.
* Sets the command to status ''in progress''.
* Parameters:
* @fd: (IN) FD context
*
* Return value: Last command status
* Scope: Local
**/
void cbw_read_complete(request_t *request)
{
fd_storage_t *fd = (fd_storage_t *)request->context;
request_status_t status = request->status;
DBG_V(DSLAVE_MS_USB, ("CBW Complete ep %d size %d status %d\n",
fd->out_pipe->address, request->transfer_size, status));
/* Request is ready for next transfer */
request->status = REQUEST_READY;
if (status != REQUEST_COMPLETED)
{
/* HSU addition: Error handling */
if (status != REQUEST_CANCELLED)
{
DBG_W(DSLAVE_MS_USB, ("MASS: Error %d on reading data from out pipe.\n", status));
}
else
DBG_I(DSLAVE_MS_USB, ("MASS: %s - failed reading data from out pipe.\n",
status == REQUEST_CANCELLED ? "Cancelled" : "Error", status));
/******* End HSU addition **************************/
}
else
{
DBG_V(DSLAVE_MS_USB, ("MASS: Got packet (%d)\n",
request->bytes_transferred));
handle_cbw(fd, request->buffer.vaddr, request->bytes_transferred);
}
}
/* Disable an endpoint */
static jresult_t dcd_disable_ep(jdevice_t dev, pipe_desc_t *pipe)
{
td243fc_rev2_softc_t *sc = (td243fc_rev2_softc_t *)j_device_get_softc(dev);
jint_t ep_n = (jint_t)(pipe->dcd_handle);
td243fc_rev2_ep_t *ep = NULL;
jbool_t is_in = FALSE;
KASSERT(pipe, ("Pipe is NULL\n"));
KASSERT(pipe->dcd_handle, ("Pipe was not allocated\n"));
/* HSU Addition */
ep = &sc->ep[ep_n];
/* First set value in ep, only then try to ASSERT on ep->pipe */
KASSERT(ep->pipe, ("Pipe was not enabled\n"));
/* End of HSU Addition */
is_in = EP_IS_IN(ep_n);
DBG_I(DSLAVE_DCD, ("DCD: dcd_disable_ep pipe=%p, buf_size=%d\n", pipe,
ep->buf_size));
WRITE4(TD243FC_EPN_CONFIG_CONTROL_REG(ep_n/2, is_in), 0);
pipe->status = PIPE_DISABLED;
td243fc_mem_free(sc, ep->buf_size * 2);
ep->pipe = NULL;
return 0;
}
static jresult_t td243fc_rev2_detach(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);
DBG_I(DSLAVE_DCD, ("DCD: Detaching controller: %s\n",
j_device_get_nameunit(dev)));
/* Cleanup DCD context and unregister DCD */
if (sc->core_ctx)
core_unregister_dcd(sc->core_ctx);
if (sc->irq_res)
jbus_release_resource(bus, sc->irq_res);
if (sc->mem_res)
jbus_release_resource(bus, sc->mem_res);
if (sc->dma_buf.cookie)
jdma_free(sc->dma_buf.cookie);
if (sc->sc_lock)
jspinlock_uninit(sc->sc_lock);
DBG_V(DSLAVE_DCD, ("DCD: Controller detached\n"));
return 0;
}
void devmon_get_info(mdev_t dev, devmon_info_t *info)
{
usb_device_descriptor_t *desc;
void *usbd_device;
DBG_I(DUTIL_DEVMON, ("DEVMON: Info for %p\n", dev));
j_memset(info, 0, sizeof(devmon_info_t));
if (!dev)
return;
/* HSU addition - CR fix 255791 -
j_get_usbd_device() shouldn't be used for devices of type "ehci_local",
because it returns a core number rather than a device handle */
if ((j_device_get_parent((jdevice_t)dev)) == 0)
{
return;
}
/* End of HSU addition */
usbd_device = j_get_usbd_device(dev);
if (!usbd_device)
return;
desc = &((usbd_device_handle)usbd_device)->ddesc;
info->dev_class = desc->bDeviceClass;
info->subclass = desc->bDeviceSubClass;
info->protocol = desc->bDeviceProtocol;
info->vendor = UGETW(desc->idVendor);
info->product = UGETW(desc->idProduct);
info->version = UGETW(desc->bcdDevice);
info->name = j_device_get_nameunit(dev);
info->desc = j_device_get_desc(dev);
info->depth = ((usbd_device_handle)usbd_device)->depth;
}
/* 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;
}
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;
}
void devmon_handle_attached(mdev_t dev, mdev_t parent)
{
if (!dev_monitor || !dev || !dev_monitor->attached)
return;
DBG_I(DUTIL_DEVMON, ("DEVMON: Handling attach of %p [%s] parent [%p]\n",
dev, j_device_get_nameunit(dev), parent));
dev_monitor->attached(dev, parent);
}
jresult_t devmon_register(devmon_methods_t *methods)
{
DBG_I(DUTIL_DEVMON, ("DEVMON: Registered monitor %p\n", methods));
if (dev_monitor)
return JEINVAL;
dev_monitor = methods;
return 0;
}
jresult_t devmon_allow_attach(mdev_t dev)
{
if (!dev_monitor || !dev || !dev_monitor->allow_attach)
return 0;
DBG_I(DUTIL_DEVMON, ("DEVMON: Checking if attach allowed for %p [%s]\n",
dev, j_device_get_nameunit(dev)));
return dev_monitor->allow_attach(dev);
}
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;
}
/**
* Function name: enable
* Description: Enables the mass storage function driver.
* Parameters:
* @context: (IN) FD context
*
* Return value: 0 on success, otherwise an error code
* Scope: Local
**/
static jresult_t enable(context_t context)
{
jresult_t rc = 0;
jint_t i;
fd_storage_t *fd = (fd_storage_t *)context;
if (fd->state == STATE_ENABLED)
{
DBG_W(DSLAVE_MS_USB, ("enable: Trying to enable already enabled FD\n"));
goto Exit;
}
for (i = 0; i < SCSI_TRANSFER_BUFFERS; i++)
ALLOC_MSFD_REQUEST(i);
/* Get the pipe numbers that the Core assigned to our descriptors */
DBG_I(DSLAVE_MS_USB, ("FD: Pipe %p is %d.\n",
&fd->fd_desc->interfaces[0].alt_ifs[0].pipes[0],
fd->fd_desc->interfaces[0].alt_ifs[0].pipes[0].address));
fd->out_pipe = &fd->fd_desc->interfaces[0].alt_ifs[0].pipes[0];
fd->in_pipe = &fd->fd_desc->interfaces[0].alt_ifs[0].pipes[1];
rc = scsi_enable(fd->scsi_device);
if (rc)
goto Exit;
rc = post_read(fd, fd->cmd_request, USB_BULK_CB_WRAP_LEN,
cbw_read_complete, fd);
if (rc)
/* HSU addition: CR 159898 */
{
DBG_E(DSLAVE_MS_USB, ("Failed to post CBW on enable (%d)\n", rc));
goto Exit;
}
/******* End HSU addition **************************/
fd->state = STATE_ENABLED;
Exit:
if (rc)
{
for (i = 0; i < SCSI_TRANSFER_BUFFERS; i++)
FREE_MSFD_REQUEST(i);
}
return rc;
}
OMX_ERRORTYPE il_event_handler(OMX_HANDLETYPE hComponent, OMX_PTR pAppData, OMX_EVENTTYPE eEvent,
OMX_U32 nData1, OMX_U32 nData2, OMX_PTR pEventData)
{
ilcore_comp_ctx_t *ctx = (ilcore_comp_ctx_t *)pAppData;
ilcore_add_comp_event(ctx, eEvent, nData1, nData2);
if (eEvent == OMX_EventBufferFlag && (nData2 & OMX_BUFFERFLAG_EOS))
{
DBG_I("EOS event recieved\n");
if (ctx->eos_cb)
ctx->eos_cb(ctx->ctx_cb);
}
return OMX_ErrorNone;
}
/* Stop and Disconnect controller */
static void dcd_disable(jdevice_t dev)
{
td243fc_rev2_softc_t *sc = (td243fc_rev2_softc_t *)j_device_get_softc(dev);
DBG_I(DSLAVE_DCD, ("DCD: dcd_disable\n"));
CLEAR4(TD243FC_CHIP_INT_ENABLE_REG, TD243FC_INTF);
td243fc_mem_free(sc, sc->ep[0].buf_size * 2);
td243fc_mem_free(sc, sc->ep[1].buf_size * 2);
if (sc->interrupt_h)
{
jinterrupt_teardown(sc->irq_res, sc->interrupt_h);
sc->interrupt_h = NULL;
}
}
static void dev_stat_complete(dps_appctx_t appctx, dps_param_t result,
dps_device_status_t *status)
{
DECLARE_FNAME("dev_stat_complete");
DBG_X(DSLAVE_DPS_API, ("%s: entered\n", fname));
if (!status)
{
DBG_E(DSLAVE_DPS_API, ("%s: failed to parse device status (%d)\n",
fname, result));
return;
}
if (result)
{
DBG_I(DSLAVE_DPS_API, ("%s: result: %X\n", fname, result));
}
if (app_ctx.dpof_file_id &&
status->job_end_reason != DPS_DEV_STAT_JOB_NOT_ENDED)
{
sicd_store_remove_object(app_ctx.store_id, app_ctx.dpof_file_id);
app_ctx.dpof_file_id = 0;
j_memset(&app_ctx.dpof_restart_info, 0, sizeof(dpof_params_t));
app_ctx.can_restart = 0;
}
DBG_I(DSLAVE_DPS_API, ("%s: print service status: %X\n", fname,
status->print_service_status));
DBG_I(DSLAVE_DPS_API, ("%s: job end reason: %X\n", fname,
status->job_end_reason));
DBG_I(DSLAVE_DPS_API, ("%s: error status: %X\n", fname,
status->error_status));
DBG_I(DSLAVE_DPS_API, ("%s: error reason: %X\n", fname,
status->error_reason));
DBG_I(DSLAVE_DPS_API, ("%s: disconnect enabled: %X\n", fname,
status->disconnect_enable));
DBG_I(DSLAVE_DPS_API, ("%s: capability changed: %X\n", fname,
status->capability_changed));
DBG_I(DSLAVE_DPS_API, ("%s: new job OK: %X\n", fname,
status->new_job_ok));
}
/* Selector Unit Requests Handling */
static jresult_t selector_unit_cb(uwd_audio_app_h app, uwd_audio_entity_h entity,
uwd_audio_req_code_t code, juint16_t value, juint16_t len, void *data)
{
uwd_audio_selector_unit_t *su = (uwd_audio_selector_unit_t *)entity->data;
juint8_t *selector_cur = (juint8_t *)entity->app_priv;
juint8_t *selector_req = (juint8_t *)data;
DBG_I(DSLAVE_AUDIO_APP, ("AUDIO_APP: Selector Unit (%d) request, "
"code=0x%02x\n", entity->id, code));
if (len < sizeof(juint8_t))
return JEINVAL;
switch (code)
{
case UWD_AUDIO_RC_SET_CUR:
if (*selector_req == 0)
*selector_req = 1;
else if (*selector_req > su->nr_in_pins)
*selector_req = su->nr_in_pins;
*selector_cur = *selector_req;
/* TODO change selector */
return 0;
case UWD_AUDIO_RC_GET_CUR:
*selector_req = *selector_cur;
return 0;
case UWD_AUDIO_RC_GET_MIN:
case UWD_AUDIO_RC_GET_RES:
*selector_req = 1;
return 0;
case UWD_AUDIO_RC_GET_MAX:
*selector_req = su->nr_in_pins;
return 0;
default:
return JENOTSUP;
}
}
static void job_stat_complete(dps_appctx_t appctx, dps_param_t result,
dps_job_status_t *status)
{
DECLARE_FNAME("job_stat_complete");
DBG_X(DSLAVE_DPS_API, ("%s: entered\n", fname));
if (!status)
{
DBG_E(DSLAVE_DPS_API, ("%s: failed to parse job status (%d)\n",
fname, result));
return;
}
if (result)
{
DBG_I(DSLAVE_DPS_API, ("%s: result: %X\n", fname, result));
}
DBG_I(DSLAVE_DPS_API, ("%s: DPOF: %s\n", fname,
status->job_is_dpof?"yes":"no"));
DBG_I(DSLAVE_DPS_API, ("%s: Progress: %u/%u\n", fname,
status->pages_done, status->total_pages));
if (status->job_is_dpof)
{
j_memcpy(&app_ctx.dpof_restart_info, &status->dpof_params,
sizeof(dpof_params_t));
app_ctx.can_restart = 1;
DBG_I(DSLAVE_DPS_API, ("%s: print PID: %u\n", fname,
status->dpof_params.prt_pid));
DBG_I(DSLAVE_DPS_API, ("%s: file: %s\n", fname,
status->dpof_params.file_path));
DBG_I(DSLAVE_DPS_API, ("%s: page number: %u\n", fname,
status->dpof_params.copy_id));
}
else
{
#ifdef JDEBUG
DBG_I(DSLAVE_DPS_API, ("%s: Images printed: %u\n", fname,
status->images_printed));
#endif
}
}
jresult_t uwd_audio_app_init(uwd_audio_drv_h fd_ctx, uwd_audio_app_h *app_ctx,
uwd_audio_config_t **config)
{
app_ctx_h app;
DBG_I(DSLAVE_AUDIO_APP, ("AUDIO_APP: uwd_audio_app_init\n"));
app = (app_ctx_h)jmalloc(sizeof(app_ctx_t), M_ZERO);
if(!app)
{
DBG_E(DSLAVE_AUDIO_APP, ("AUDIO_APP: No memory\n"));
return JENOMEM;
}
app->fd_ctx = fd_ctx;
*config = &app_config;
*app_ctx = app;
return 0;
}
ret_code_t ilcore_disable_all_ports(ilcore_comp_h h)
{
OMX_PORT_PARAM_TYPE ports;
OMX_ERRORTYPE err;
int i, j;
OMX_INDEXTYPE types[] = {OMX_IndexParamAudioInit, OMX_IndexParamVideoInit, OMX_IndexParamImageInit,
OMX_IndexParamOtherInit};
ilcore_comp_ctx_t *ctx = (ilcore_comp_ctx_t *)h;
ports.nSize = sizeof(OMX_PORT_PARAM_TYPE);
ports.nVersion.nVersion = OMX_VERSION;
for (j = 0; j < 4; j++)
{
err = OMX_GetParameter(ctx->handle, types[j], &ports);
if (err != OMX_ErrorNone)
{
DBG_E("Get port paraneters failed. err=%d\n");
return L_FAILED;
}
for(i = 0; i < ports.nPorts; i++)
{
DBG_I("Disabling port #%d\n", ports.nStartPortNumber + i);
err = OMX_SendCommand(ctx->handle, OMX_CommandPortDisable, ports.nStartPortNumber + i, NULL);
if (err != OMX_ErrorNone)
{
DBG_E("Port disable failed. err=%d\n");
return L_FAILED;
}
err = omx_core_comp_wait_command(ctx, OMX_CommandPortDisable, ports.nStartPortNumber + i, IL_WAIT_TIMEOUT);
if (err != OMX_ErrorNone)
{
DBG_E("Wait event failed. err=%d\n");
return L_FAILED;
}
}
}
return L_OK;
}
ret_code_t ilcore_enable_port(ilcore_comp_h h, uint32_t port, int wait)
{
ilcore_comp_ctx_t *ctx = (ilcore_comp_ctx_t *)h;
OMX_PARAM_PORTDEFINITIONTYPE param;
OMX_ERRORTYPE omx_err;
DBG_I("%s: enable port %d on comp %s\n", __FUNCTION__, port, ilcore_get_comp_name(h));
OMX_INIT_STRUCT(param);
param.nPortIndex = port;
omx_err = OMX_GetParameter(ctx->handle, OMX_IndexParamPortDefinition, ¶m);
if(omx_err != OMX_ErrorNone)
{
DBG_E("%s: Error get port %d status on component %s err = 0x%08x\n", __FUNCTION__, port,
ilcore_get_comp_name(h), omx_err);
return L_FAILED;
}
if(param.bEnabled == OMX_TRUE)
return L_OK; /* Port already enable */
omx_err = OMX_SendCommand(ctx->handle, OMX_CommandPortEnable, port, NULL);
if(omx_err != OMX_ErrorNone)
{
DBG_E("%s: Error disable port %d on component %s err = 0x%08x\n", __FUNCTION__, port, ilcore_get_comp_name(h),
omx_err);
return L_FAILED;
}
if (wait)
{
omx_err = omx_core_comp_wait_command(h, OMX_CommandPortEnable, port, 2000);
if(omx_err != OMX_ErrorNone)
return L_FAILED;
}
return L_OK;
}
/* Feature Unit Requests Handling */
static jresult_t feature_unit_cb(uwd_audio_app_h app_ctx,
uwd_audio_entity_h entity, uwd_audio_req_code_t code, juint16_t value,
juint16_t len, void *data)
{
juint8_t ch = (juint8_t)value;
uwd_audio_feature_unit_cs_t cs = (uwd_audio_feature_unit_cs_t)(value >> 8);
app_feature_unit_t *fu = (app_feature_unit_t *)entity->app_priv;
DBG_I(DSLAVE_AUDIO_APP, ("AUDIO_APP: Feature Unit (%d) request, code=0x%02x"
" channel=%d control selector=0x%02x\n", entity->id, code, ch, cs));
if (ch == UWD_AUDIO_CTRL_ALL_CH)
return JENOTSUP;
switch (cs)
{
case UWD_AUDIO_FU_MUTE_CONTROL:
{
juint8_t *mute = (juint8_t *)data;
if (len < sizeof(fu[ch].mute.cur))
return JEINVAL;
switch (code)
{
case UWD_AUDIO_RC_SET_CUR:
fu[ch].mute.cur = *mute ? 1 : 0;
/* TODO change HW mute */
return 0;
case UWD_AUDIO_RC_GET_CUR:
*mute = fu[ch].mute.cur;
return 0;
case UWD_AUDIO_RC_GET_RES:
*mute = 0;
return 0;
default:
return JENOTSUP;
}
}
case UWD_AUDIO_FU_VOLUME_CONTROL:
{
juint16_t volume;
if (len < sizeof(volume))
return JEINVAL;
switch (code)
{
case UWD_AUDIO_RC_SET_CUR:
volume = ua_le16toh(data);
if (volume > fu[ch].volume.max || volume < fu[ch].volume.min)
return JEINVAL;
fu[ch].volume.cur = ua_le16toh(data);
/* TODO change HW volume */
return 0;
case UWD_AUDIO_RC_GET_CUR:
ua_htole16(data, fu[ch].volume.cur);
return 0;
case UWD_AUDIO_RC_GET_MIN:
ua_htole16(data, fu[ch].volume.min);
return 0;
case UWD_AUDIO_RC_GET_MAX:
ua_htole16(data, fu[ch].volume.max);
return 0;
case UWD_AUDIO_RC_GET_RES:
ua_htole16(data, fu[ch].volume.res);
return 0;
default:
return JENOTSUP;
}
}
default:
return JENOTSUP;
}
}
static void uninit(uwd_audio_app_h app_ctx)
{
DBG_I(DSLAVE_AUDIO_APP, ("AUDIO_APP: uninit\n"));
jfree(app_ctx);
}
