DisplayPlane* TngPlaneManager::getPlaneHelper(int dsp, int type)
{
RETURN_NULL_IF_NOT_INIT();
if (dsp < 0 || dsp > IDisplayDevice::DEVICE_EXTERNAL) {
ETRACE("Invalid display device %d", dsp);
return 0;
}
int index = dsp == IDisplayDevice::DEVICE_PRIMARY ? 0 : 1;
if (type == DisplayPlane::PLANE_PRIMARY ||
type == DisplayPlane::PLANE_CURSOR) {
return getPlane(type, index);
} else if (type == DisplayPlane::PLANE_SPRITE) {
return getAnyPlane(type);
} else if (type == DisplayPlane::PLANE_OVERLAY) {
// use overlay A for pipe A and overlay C for pipe B if possible
DisplayPlane *plane = getPlane(type, index);
if (plane == NULL) {
plane = getPlane(type, !index);
}
return plane;
} else {
ETRACE("invalid plane type %d", type);
return 0;
}
}
static struct _ValidateNode * pvrAlloc(struct _WsbmVNodeFuncs * func,
int typeId)
{
CTRACE();
if(typeId == 0) {
struct PsbWsbmValidateNode * vNode = malloc(sizeof(*vNode));
if(!vNode) {
ETRACE("failed to allocate memory");
return NULL;
}
vNode->base.func = func;
vNode->base.type_id = 0;
return &vNode->base;
} else {
struct _ValidateNode * node = malloc(sizeof(*node));
if(!node) {
ETRACE("failed to allocate node");
return NULL;
}
node->func = func;
node->type_id = 1;
return node;
}
}
DisplayPlane* TngPlaneManager::allocPlane(int index, int type)
{
DisplayPlane *plane = 0;
switch (type) {
case DisplayPlane::PLANE_PRIMARY:
plane = new TngPrimaryPlane(index, index);
break;
case DisplayPlane::PLANE_SPRITE:
plane = new TngSpritePlane(index, 0);
break;
case DisplayPlane::PLANE_OVERLAY:
plane = new TngOverlayPlane(index, 0);
break;
case DisplayPlane::PLANE_CURSOR:
plane = new TngCursorPlane(index, index /*disp */);
break;
default:
ETRACE("unsupported type %d", type);
break;
}
if (plane && !plane->initialize(DisplayPlane::MIN_DATA_BUFFER_COUNT)) {
ETRACE("failed to initialize plane.");
DEINIT_AND_DELETE_OBJ(plane);
}
return plane;
}
int DisplayPlaneManager::getFreePlanes(int dsp, int type)
{
RETURN_NULL_IF_NOT_INIT();
if (dsp < 0 || dsp > IDisplayDevice::DEVICE_EXTERNAL) {
ETRACE("Invalid display device %d", dsp);
return 0;
}
if (type < 0 || type >= DisplayPlane::PLANE_MAX) {
ETRACE("Invalid plane type %d", type);
return 0;
}
uint32_t freePlanes = mFreePlanes[type] | mReclaimedPlanes[type];
if (type == DisplayPlane::PLANE_PRIMARY ||
type == DisplayPlane::PLANE_CURSOR) {
return ((freePlanes & (1 << dsp)) == 0) ? 0 : 1;
} else {
int count = 0;
for (int i = 0; i < 32; i++) {
if ((1 << i) & freePlanes) {
count++;
}
}
return count;
}
return 0;
}
int psbWsbmWrapTTMBuffer(uint64_t handle, void **buf)
{
int ret = 0;
struct _WsbmBufferObject *wsbmBuf;
if (!buf) {
ETRACE("invalid parameter");
return -EINVAL;
}
ret = wsbmGenBuffers(mainPool, 1, &wsbmBuf, 0,
(WSBM_PL_FLAG_VRAM | WSBM_PL_FLAG_TT |
/*WSBM_PL_FLAG_NO_EVICT |*/ WSBM_PL_FLAG_SHARED));
if (ret) {
ETRACE("wsbmGenBuffers failed with error code %d", ret);
return ret;
}
ret = wsbmBOSetReferenced(wsbmBuf, handle);
if (ret) {
ETRACE("wsbmBOSetReferenced failed with error code %d", ret);
return ret;
}
*buf = (void *)wsbmBuf;
VTRACE("wrap buffer %p for handle %#x", wsbmBuf, handle);
return 0;
}
OverlayBackBuffer* OverlayPlaneBase::createBackBuffer()
{
CTRACE();
// create back buffer
OverlayBackBuffer *backBuffer = (OverlayBackBuffer *)malloc(sizeof(OverlayBackBuffer));
if (!backBuffer) {
ETRACE("failed to allocate back buffer");
return 0;
}
int size = sizeof(OverlayBackBufferBlk);
int alignment = 64 * 1024;
void *wsbmBufferObject = 0;
bool ret = mWsbm->allocateTTMBuffer(size, alignment, &wsbmBufferObject);
if (ret == false) {
ETRACE("failed to allocate TTM buffer");
return 0;
}
void *virtAddr = mWsbm->getCPUAddress(wsbmBufferObject);
uint32_t gttOffsetInPage = mWsbm->getGttOffset(wsbmBufferObject);
backBuffer->buf = (OverlayBackBufferBlk *)virtAddr;
backBuffer->gttOffsetInPage = gttOffsetInPage;
backBuffer->bufObject = wsbmBufferObject;
VTRACE("cpu %p, gtt %d", virtAddr, gttOffsetInPage);
return backBuffer;
}
static int saudio_snd_init_ipc(struct snd_saudio *saudio)
{
int result = 0;
int32_t i = 0, j = 0;
struct saudio_stream *stream = NULL;
struct saudio_dev_ctrl *dev_ctrl = NULL;
ADEBUG();
for (i = 0; i < SAUDIO_DEV_MAX; i++) { /* now only support one device */
dev_ctrl = &saudio->dev_ctrl[i];
result =
sblock_create(dev_ctrl->dst, dev_ctrl->monitor_channel,
SAUDIO_MONITOR_BLOCK_COUNT, CMD_BLOCK_SIZE,
SAUDIO_MONITOR_BLOCK_COUNT, CMD_BLOCK_SIZE);
if (result) {
ETRACE
("saudio:monitor channel create failed result is %d\n",
result);
goto __nodev;
}
result =
sblock_create(dev_ctrl->dst, dev_ctrl->channel,
SAUDIO_CMD_BLOCK_COUNT, CMD_BLOCK_SIZE,
SAUDIO_CMD_BLOCK_COUNT, CMD_BLOCK_SIZE);
if (result) {
ETRACE
("saudio_thread sblock create failed result is %d\n",
result);
goto __nodev;
}
pr_debug("saudio_thread sblock create result is %d\n", result);
for (j = 0; j < SAUDIO_STREAM_MAX; j++) {
stream = &dev_ctrl->stream[j];
result =
sblock_create(stream->dst, stream->channel,
SAUDIO_STREAM_BLOCK_COUNT,
TX_DATA_BLOCK_SIZE,
SAUDIO_STREAM_BLOCK_COUNT,
RX_DATA_BLOCK_SIZE);
if (result) {
ETRACE
("saudio_thread sblock create failed result is %d\n",
result);
goto __nodev;
}
sblock_register_notifier(stream->dst, stream->channel,
sblock_notifier, stream);
pr_debug("saudio_thread sblock create result is %d\n",
result);
}
}
ADEBUG();
return result;
__nodev:
ETRACE("initialization failed\n");
return result;
}
static int snd_card_saudio_pcm_trigger(struct snd_pcm_substream *substream,
int cmd)
{
const struct snd_saudio *saudio = snd_pcm_substream_chip(substream);
const int stream_id = substream->pstr->stream;
const int dev = substream->pcm->device;
struct saudio_dev_ctrl *dev_ctrl = NULL;
struct saudio_stream *stream = NULL;
struct saudio_msg msg = { 0 };
int err = 0;
int result = 0;
ADEBUG();
dev_ctrl = (struct saudio_dev_ctrl *)&(saudio->dev_ctrl[dev]);
stream = (struct saudio_stream *)&(dev_ctrl->stream[stream_id]);
switch (cmd) {
case SNDRV_PCM_TRIGGER_START:
case SNDRV_PCM_TRIGGER_RESUME:
msg.stream_id = stream_id;
stream->stream_state = SAUDIO_TRIGGERED;
result = saudio_data_trigger_process(stream, &msg);
result = saudio_send_common_cmd(dev_ctrl->dst, dev_ctrl->channel,
SAUDIO_CMD_START, stream->stream_id,0);
if (result) {
ETRACE("saudio.c: snd_card_saudio_pcm_trigger: RESUME, send_common_cmd result is %d", result);
saudio_snd_card_free(saudio);
return result;
}
break;
case SNDRV_PCM_TRIGGER_STOP:
case SNDRV_PCM_TRIGGER_SUSPEND:
stream->stream_state = SAUDIO_STOPPED;
result = saudio_send_common_cmd(dev_ctrl->dst, dev_ctrl->channel,
SAUDIO_CMD_STOP, stream->stream_id, 0);
if (result) {
ETRACE("saudio.c: snd_card_saudio_pcm_trigger: SUSPEND, send_common_cmd result is %d", result);
saudio_snd_card_free(saudio);
return result;
}
break;
default:
err = -EINVAL;
break;
}
return 0;
}
bool UeventObserver::initialize()
{
mListeners.clear();
if (mUeventFd != -1) {
return true;
}
mThread = new UeventObserverThread(this);
if (!mThread.get()) {
ETRACE("failed to create uevent observer thread");
return false;
}
// init uevent socket
struct sockaddr_nl addr;
// set the socket receive buffer to 64K
// NOTE: this is only called for once
int sz = 64 * 1024;
memset(&addr, 0, sizeof(addr));
addr.nl_family = AF_NETLINK;
addr.nl_pid = pthread_self() | getpid();
addr.nl_groups = 0xffffffff;
mUeventFd = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_KOBJECT_UEVENT);
if (mUeventFd < 0) {
DEINIT_AND_RETURN_FALSE("failed to create uevent socket");
}
if (setsockopt(mUeventFd, SOL_SOCKET, SO_RCVBUFFORCE, &sz, sizeof(sz))) {
WTRACE("setsockopt() failed");
//return false;
}
if (bind(mUeventFd, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
DEINIT_AND_RETURN_FALSE("failed to bind scoket");
return false;
}
memset(mUeventMessage, 0, UEVENT_MSG_LEN);
int exitFds[2];
if (pipe(exitFds) < 0) {
ETRACE("failed to make pipe");
deinitialize();
return false;
}
mExitRDFd = exitFds[0];
mExitWDFd = exitFds[1];
return true;
}
void vp8_translate_parse_status(vp8_Status status)
{
switch (status)
{
case VP8_UNSUPPORTED_VERSION:
ETRACE("Parser returns VP8_UNSUPPORTED_VERSION");
break;
case VP8_UNSUPPORTED_BITSTREAM:
ETRACE("Parser returns VP8_UNSUPPORTED_BITSTREAM");
break;
case VP8_INVALID_FRAME_SYNC_CODE:
ETRACE("Parser returns VP8_INVALID_FRAME_SYNC_CODE");
break;
case VP8_UNEXPECTED_END_OF_BITSTREAM:
ETRACE("Parser returns VP8_UNEXPECTED_END_OF_BITSTREAM");
break;
case VP8_CORRUPT_FRAME:
ETRACE("Parser returns VP8_CORRUPT_FRAME");
break;
case VP8_MEMORY_ERROR:
ETRACE("Parser returns MEMORY_ERROR");
break;
case VP8_NO_INITIALIZATION:
ETRACE("Parser returns VP8_NO_INITIALIZATION");
break;
case VP8_UNKNOWN_ERROR:
ETRACE("Parser returns VP8_UNKNOWN_ERROR");
break;
}
return;
}
int psbWsbmInitialize(int drmFD)
{
union drm_psb_extension_arg arg;
const char drmExt[] = "psb_ttm_placement_alphadrop";
int ret = 0;
CTRACE();
if (drmFD <= 0) {
ETRACE("invalid drm fd %d", drmFD);
return drmFD;
}
/*init wsbm*/
ret = wsbmInit(wsbmNullThreadFuncs(), &vNodeFuncs);
if (ret) {
ETRACE("failed to initialize Wsbm, error code %d", ret);
return ret;
}
VTRACE("DRM_PSB_EXTENSION %d", DRM_PSB_EXTENSION);
/*get devOffset via drm IOCTL*/
strncpy(arg.extension, drmExt, sizeof(drmExt));
ret = drmCommandWriteRead(drmFD, 6/*DRM_PSB_EXTENSION*/, &arg, sizeof(arg));
if(ret || !arg.rep.exists) {
ETRACE("failed to get device offset, error code %d", ret);
goto out;
}
VTRACE("ioctl offset %#x", arg.rep.driver_ioctl_offset);
mainPool = wsbmTTMPoolInit(drmFD, arg.rep.driver_ioctl_offset);
if(!mainPool) {
ETRACE("failed to initialize TTM Pool");
ret = -EINVAL;
goto out;
}
VTRACE("Wsbm initialization succeeded. mainPool %p", mainPool);
return 0;
out:
psbWsbmTakedown();
return ret;
}
void
EventDispatcher::SetDragMessage(BMessage& message,
ServerBitmap* bitmap, const BPoint& offsetFromCursor)
{
ETRACE(("EventDispatcher::SetDragMessage()\n"));
BAutolock _(this);
if (fLastButtons == 0) {
// mouse buttons has already been released or was never pressed
bitmap->ReleaseReference();
return;
}
if (fDragBitmap != bitmap) {
if (fDragBitmap)
fDragBitmap->ReleaseReference();
fDragBitmap = bitmap;
if (fDragBitmap != NULL)
fDragBitmap->AcquireReference();
}
fHWInterface->SetDragBitmap(bitmap, offsetFromCursor);
fDragMessage = message;
fDraggingMessage = true;
fDragOffset = offsetFromCursor;
}
bool FDHandler::AddFd(int fd) {
if (fd < 0) {
ETRACE("Cannot add negative fd: %d", fd);
return false;
}
auto it = fds_.find(fd);
if (it != fds_.end()) {
ETRACE("FD already being watched: %d\n", it->first);
return false;
}
fds_.emplace(fd, FDWatch());
return true;
}
void TngSpritePlane::setZOrderConfig(ZOrderConfig& zorderConfig,
void *nativeConfig)
{
if (!nativeConfig) {
ETRACE("Invalid parameter, no native config");
return;
}
mAbovePrimary = false;
int primaryIndex = -1;
int spriteIndex = -1;
// only consider force bottom when overlay is active
for (size_t i = 0; i < zorderConfig.size(); i++) {
DisplayPlane *plane = zorderConfig[i]->plane;
if (plane->getType() == DisplayPlane::PLANE_PRIMARY)
primaryIndex = i;
if (plane->getType() == DisplayPlane::PLANE_SPRITE) {
spriteIndex = i;
}
}
// if has overlay plane which is below primary plane
if (spriteIndex > primaryIndex) {
mAbovePrimary = true;
}
struct intel_dc_plane_zorder *zorder =
(struct intel_dc_plane_zorder *)nativeConfig;
zorder->abovePrimary = mAbovePrimary ? 1 : 0;
}
static int saudio_wait_common_cmd(uint32_t dst, uint32_t channel,
uint32_t cmd, uint32_t subcmd,int32_t timeout)
{
int result = 0;
struct sblock blk = { 0 };
struct cmd_common *common = NULL;
ADEBUG();
result =
sblock_receive(dst, channel, (struct sblock *)&blk, timeout);
if (result < 0) {
ETRACE("sblock_receive dst %d, channel %d result is %d \n", dst,
channel, result);
return result;
}
common = (struct cmd_common *)blk.addr;
pr_debug("dst is %d, channel %d, common->command is %x ,sub cmd %x,\n",
dst, channel, common->command, common->sub_cmd);
if (subcmd) {
if ((common->command == cmd) && (common->sub_cmd == subcmd)) {
result = 0;
} else {
result = -1;
}
} else {
if (common->command == cmd) {
result = 0;
} else {
result = -1;
}
}
sblock_release(dst, channel, &blk);
return result;
}
static int
vaudio_thread (void* data)
{
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
daemonize();
#else
daemonize("vaudio-fe");
#endif
data = (void*) vaudio;
while (!vaudio_thread_aborted) {
down (&vaudio_thread_sem);
if ( (vaudio_thread_init_now & 2) ) {
vaudio_thread_init_now &= ~2;
snd_card_free(vaudio_card);
if (vaudio_snd_probe() < 0) {
ETRACE ("virtual audio ALSA card initialization failed\n");
}
}
if ( (vaudio_thread_init_now & 1) ) {
vaudio_thread_init_now &= ~1;
vaudio_snd_init_card(data);
}
}
complete_and_exit(&vaudio_thread_completion, 0);
/*NOTREACHED*/
return 0;
}
bool UeventObserver::threadLoop()
{
if (mUeventFd == -1) {
ETRACE("invalid uEvent file descriptor");
return false;
}
struct pollfd fds[2];
int nr;
fds[0].fd = mUeventFd;
fds[0].events = POLLIN;
fds[0].revents = 0;
fds[1].fd = mExitRDFd;
fds[1].events = POLLIN;
fds[1].revents = 0;
nr = poll(fds, 2, -1);
if (nr > 0 && fds[0].revents == POLLIN) {
int count = recv(mUeventFd, mUeventMessage, UEVENT_MSG_LEN - 2, 0);
if (count > 0) {
onUevent();
}
} else if (fds[1].revents) {
close(mExitRDFd);
mExitRDFd = -1;
ITRACE("exiting wait");
return false;
}
// always looping
return true;
}
bool
EventDispatcher::_AddTokens(BMessage* message, EventTarget* target,
uint32 eventMask, BMessage* nextMouseMoved, int32* _viewToken)
{
_RemoveTokens(message);
int32 count = target->CountListeners();
int32 added = 0;
for (int32 i = 0; i < count; i++) {
event_listener* listener = target->ListenerAt(i);
if ((listener->EffectiveEventMask() & eventMask) == 0)
continue;
if (nextMouseMoved != NULL && message->what == B_MOUSE_MOVED
&& (listener->EffectiveOptions() & B_NO_POINTER_HISTORY) != 0
&& message != nextMouseMoved
&& _viewToken != NULL) {
if (listener->token == *_viewToken) {
// focus view doesn't want to get pointer history
*_viewToken = B_NULL_TOKEN;
}
continue;
}
ETRACE((" add token %ld\n", listener->token));
if (message->AddInt32(kTokenName, listener->token) == B_OK)
added++;
}
return added != 0;
}
void UeventObserver::onUevent()
{
char *msg = mUeventMessage;
const char *envelope = DrmConfig::getUeventEnvelope();
if (strncmp(msg, envelope, strlen(envelope)) != 0)
return;
msg += strlen(msg) + 1;
UeventListener *listener;
String8 key;
while (*msg) {
key = String8(msg);
if (mListeners.indexOfKey(key) >= 0) {
DTRACE("received Uevent: %s", msg);
listener = mListeners.valueFor(key);
if (listener) {
listener->func(listener->data);
} else {
ETRACE("no listener for uevent %s", msg);
}
}
msg += strlen(msg) + 1;
}
}
void
EventDispatcher::_DeliverDragMessage()
{
ETRACE(("EventDispatcher::_DeliverDragMessage()\n"));
if (fDraggingMessage && fPreviousMouseTarget != NULL) {
BMessage::Private(fDragMessage).SetWasDropped(true);
fDragMessage.RemoveName("_original_what");
fDragMessage.AddInt32("_original_what", fDragMessage.what);
fDragMessage.AddPoint("_drop_point_", fLastCursorPosition);
fDragMessage.AddPoint("_drop_offset_", fDragOffset);
fDragMessage.what = _MESSAGE_DROPPED_;
_SendMessage(fPreviousMouseTarget->Messenger(),
&fDragMessage, 100.0);
}
fDragMessage.MakeEmpty();
fDragMessage.what = 0;
fDraggingMessage = false;
fHWInterface->SetDragBitmap(NULL, B_ORIGIN);
if (fDragBitmap != NULL) {
fDragBitmap->ReleaseReference();
fDragBitmap = NULL;
}
}
static int snd_card_saudio_pcm_close(struct snd_pcm_substream *substream)
{
const struct snd_saudio *saudio = snd_pcm_substream_chip(substream);
const int stream_id = substream->pstr->stream;
const int dev = substream->pcm->device;
struct saudio_dev_ctrl *dev_ctrl = NULL;
int result = 0;
ADEBUG();
pr_info("%s IN, stream_id=%d\n", __func__, stream_id);
dev_ctrl = (struct saudio_dev_ctrl *)&(saudio->dev_ctrl[dev]);
mutex_lock(&dev_ctrl->mutex);
result = saudio_send_common_cmd(dev_ctrl->dst, dev_ctrl->channel,
SAUDIO_CMD_CLOSE, stream_id,CMD_TIMEOUT);
if (result) {
ETRACE("saudio.c: snd_card_saudio_pcm_close: saudio_send_common_cmd result is %d", result);
saudio_snd_card_free(saudio);
mutex_unlock(&dev_ctrl->mutex);
return result;
}
pr_info("%s send cmd done\n", __func__);
result =
saudio_wait_common_cmd(dev_ctrl->dst,
dev_ctrl->channel,
SAUDIO_CMD_CLOSE_RET, 0,CMD_TIMEOUT);
if(result)
saudio_snd_card_free(saudio);
mutex_unlock(&dev_ctrl->mutex);
pr_info("%s OUT, result=%d\n", __func__, result);
return result;
}
Decode_Status VideoDecoderVP8::decode(VideoDecodeBuffer *buffer) {
Decode_Status status;
vbp_data_vp8 *data = NULL;
if (buffer == NULL) {
ETRACE("VideoDecodeBuffer is NULL.");
return DECODE_INVALID_DATA;
}
status = VideoDecoderBase::parseBuffer(
buffer->data,
buffer->size,
false,
(void**)&data);
CHECK_STATUS("VideoDecoderBase::parseBuffer");
mShowFrame = data->codec_data->show_frame;
if (!mVAStarted) {
status = startVA(data);
CHECK_STATUS("startVA");
}
VideoDecoderBase::setRotationDegrees(buffer->rotationDegrees);
status = decodeFrame(buffer, data);
return status;
}
static int saudio_ctrl_thread(void *data)
{
int result = 0;
struct snd_saudio *saudio = (struct snd_saudio *)data;
ADEBUG();
daemonize("saudio");
result = saudio_snd_init_ipc(saudio);
if(result) {
printk(KERN_ERR "saudio:saudio_snd_init_ipc error %d\n",result);
return -1;
}
{
printk(KERN_INFO "saudio: waiting for modem boot handshake\n");
printk(KERN_INFO "saudio: modem boot and handshake ok\n");
if(saudio->card) {
printk(KERN_INFO "saudio: snd card free in\n");
result = snd_card_free(saudio->card);
saudio->card = NULL;
printk(KERN_INFO "saudio: snd card free reulst %d\n",result);
}
flush_workqueue(saudio->queue);
result = saudio_snd_init_card(saudio);
printk(KERN_INFO "saudio: snd card init reulst %d\n",result);
}
ETRACE("saudio_ctrl_thread create ok\n");
return 0;
}
bool DisplayPlaneManager::initialize()
{
int i, j;
if (mInitialized) {
WTRACE("object has been initialized");
return true;
}
// calculate total plane number and free plane bitmaps
mPlaneCount[DisplayPlane::PLANE_SPRITE] = mSpritePlaneCount;
mPlaneCount[DisplayPlane::PLANE_OVERLAY] = mOverlayPlaneCount;
mPlaneCount[DisplayPlane::PLANE_PRIMARY] = mPrimaryPlaneCount;
mPlaneCount[DisplayPlane::PLANE_CURSOR] = mCursorPlaneCount;
mTotalPlaneCount = mSpritePlaneCount+ mOverlayPlaneCount+ mPrimaryPlaneCount + mCursorPlaneCount;
if (mTotalPlaneCount == 0) {
ETRACE("plane count is not initialized");
return false;
}
for (i = 0; i < DisplayPlane::PLANE_MAX; i++) {
mFreePlanes[i] = ((1 << mPlaneCount[i]) - 1);
}
// allocate plane pools
for (i = 0; i < DisplayPlane::PLANE_MAX; i++) {
if (mPlaneCount[i]) {
mPlanes[i].setCapacity(mPlaneCount[i]);
for (j = 0; j < mPlaneCount[i]; j++) {
DisplayPlane* plane = allocPlane(j, i);
if (!plane) {
ETRACE("failed to allocate plane %d, type %d", j, i);
DEINIT_AND_RETURN_FALSE();
}
mPlanes[i].push_back(plane);
}
}
}
mInitialized = true;
return true;
}
static int saudio_ctrl_thread(void *data)
{
int result = 0;
struct snd_saudio *saudio = (struct snd_saudio *)data;
ADEBUG();
result = saudio_snd_init_ipc(saudio);
if (result) {
printk(KERN_ERR "saudio:saudio_snd_init_ipc error %d\n",
result);
return -1;
}
while (!kthread_should_stop()) {
printk(KERN_INFO
"%s,saudio: waiting for modem boot handshake,dst %d,channel %d\n",
__func__, saudio->dst, saudio->channel);
saudio_snd_wait_modem_restart(saudio);
saudio->in_init = 1;
printk(KERN_INFO
"%s,saudio: modem boot and handshake ok,dst %d, channel %d\n",
__func__, saudio->dst, saudio->channel);
saudio_snd_card_free(saudio);
printk(KERN_INFO
"saudio_ctrl_thread flush work queue in dst %d, channel %d\n",
saudio->dst, saudio->channel);
flush_workqueue(saudio->queue);
saudio->in_init = 0;
printk(KERN_INFO
"saudio_ctrl_thread flush work queue out,dst %d, channel %d\n",
saudio->dst, saudio->channel);
if(saudio_snd_notify_modem_clear(saudio)) {
printk(KERN_ERR " saudio_ctrl_thread modem error again when notify modem clear \n");
continue;
}
saudio_clear_ctrl_cmd(saudio);
if(!saudio->card) {
result = saudio_snd_init_card(saudio);
printk(KERN_INFO
"saudio: snd card init reulst %d, dst %d, channel %d\n",
result, saudio->dst, saudio->channel);
}
mutex_lock(&saudio->mutex);
saudio->state = 1;
mutex_unlock(&saudio->mutex);
}
ETRACE("saudio_ctrl_thread create ok\n");
return 0;
}
/*static*/
status_t
EventDispatcher::_event_looper(void* _dispatcher)
{
EventDispatcher* dispatcher = (EventDispatcher*)_dispatcher;
ETRACE(("Start event loop\n"));
dispatcher->_EventLoop();
return B_OK;
}
void
EventDispatcher::RemoveTemporaryListener(EventTarget& target, int32 token)
{
BAutolock _(this);
ETRACE(("events: remove temporary listener token %ld\n", token));
if (target.RemoveTemporaryListener(token) && target.IsEmpty())
fTargets.RemoveItem(&target);
}
uint32_t psbWsbmGetKBufHandle(void *buf)
{
if (!buf) {
ETRACE("invalid ttm buffer");
return 0;
}
return (wsbmKBufHandle(wsbmKBuf((struct _WsbmBufferObject *)buf)));
}
/*static*/
status_t
EventDispatcher::_cursor_looper(void* _dispatcher)
{
EventDispatcher* dispatcher = (EventDispatcher*)_dispatcher;
ETRACE(("Start cursor loop\n"));
dispatcher->_CursorLoop();
return B_OK;
}
int main(int argc, char **argv)
{
int i_fd, w_fd;
char f_name[255];
int res, ie_size = 256 * (sizeof(struct inotify_event) + 16); /* + len */
struct inotify_event *ie = malloc(ie_size);
I = stdout;
if( argc < 2 ) {
TRACE(0,"./ino file-for-watch\n");
return -1;
}
// FIXME
snprintf(f_name, 255, argv[1]);
/* init inotify subsystem */
i_fd = inotify_init();
if( i_fd < 0 ) {
ETRACE("[ERR] Cannot init inotify. errno: ");
return -1;
}
w_fd = inotify_add_watch(i_fd, f_name, IN_MODIFY|IN_ATTRIB);
if( w_fd < 0 ) {
ETRACE("[ERR] Cannot inotify fd event. errno: ");
return -1;
}
TRACE(0, "name of file for inotify %s\n", f_name);
do {
res = read(i_fd, ie, ie_size);
TRACE(0, "%s(): readed %d bytes\n", __func__, res);
if(ie->mask & IN_MODIFY) {
TRACE(0, "fd:%02d\tIN_MODIFY\n", ie->wd);
}
} while(1);
return 0;
}
