int w99685_v4l1_ioctl(w685cf_t *priv, unsigned int cmd, void * buf)
{
int err = 0;
CmdParameters_t *paramsp = NULL;
CmdReturns_t *retsp = NULL;
Firmware_t ifirmware;
UINT8 *datap;
int i;
#ifdef W865THREAD
int whichselect;
ImageContainer_t *containerp = priv->images;
#endif
if (down_interruptible2(&priv->lock)) {
printk("Device has been locked\n");
err = -EINTR;
goto out;
}
//printk("Cmd: %x, getclass: %x, IOCTLSETFW_CAMERA = %x\n", cmd, IOCTLGETCLASS,IOCTLSETFW_CAMERA);
if(cmd == IOCTLGETCLASS)
{
if(!buf) {
printk("Illegal buffer address\n");
err = -EINVAL;
goto outup;
}
if(copy_to_user(buf, DEVICECLALSS, (strlen(DEVICECLALSS)+1)))
{
printk("Cannot put data to user\n");
err = -EFAULT;
}
err = (strlen(DEVICECLALSS)+1);
printk("Get Class name: %s\n", DEVICECLALSS);
goto outup;
}
else if(cmd == IOCTLGETSTATUS)
{
if(!buf) {
printk("Illegal buffer address\n");
err = -EINVAL;
goto outup;
}
if(copy_to_user(buf, (char *)&(FREG7), sizeof(FREG7)))
{
printk("Cannot put data to user\n");
err = -EFAULT;
}
goto outup;
}
else if(cmd == IOCTLSETFW_CAMERA)
{
diag_printf("IOCTLSETFW_CAMERA = %x\n",IOCTLSETFW_CAMERA);
if(copy_from_user(&ifirmware, (void *)buf, sizeof(Firmware_t))) {
printk("Cannot copy data from user\n");
err = -EFAULT;
goto outup;
}
printk("Firmware size: %d, %x\n", ifirmware.Length, ifirmware.Data);
datap = (UINT8 *)malloc(ifirmware.Length*sizeof(UINT8));
diag_printf("datap %p\n",datap);
if(!datap)
{
printk("No enough memory\n");
err = -ENOMEM;
goto outup;
}
if(copy_from_user(datap, (void *)ifirmware.Data, ifirmware.Length*sizeof(UINT8))) {
printk("Cannot copy data from user\n");
free(datap);
err = -EFAULT;
goto outup;
}
InitCFI(0);
DownLoadFirmware2Camera(datap, ifirmware.Length);
free(datap);
for(i=0;i<100;i++)
wait_ms(20);
printk("DownLoad Firmware ok\n");
InitCFI(0);
wait_ms(40);
//CardDection();
//W99685CMD_Suspand();
//wait_ms(40);
#if 1//ndef __OUTPUT2TV__
W99685CMD_SetOpMode(OP_SINGLE, PPC_YUV422, 0);
W99685CMD_SetLCMNums(LCD1_ON_685,LCD_BUS_16);
//KDEBUG("Have set LCMNUMS");
W99685CMD_SelectLCM(LCM_1ST);
//KDEBUG("Have selected LCM\n");
W99685CMD_SetLCMRes(128, 161);
//KDEBUG("Have set LCM resolution\n");
LCM_FillChar(lcm_buf, LEN_LCMBF);
//wait_ms(100000);
//memset(lcm_buf, 0xff, LEN_LCMBF);
//LCM_FillChar(lcm_buf, LEN_LCMBF);
//KDEBUG("Have Filled LCM with char\n");
W99685CMD_SetLCMWndPos(0, 32);
W99685CMD_SetLCMWndSize(128, 96);
#endif
goto outup;
}
else if(cmd == IOCTLSETFW_USBBRIDGE)
{
DownLoadFirmware2Camera(W685BRIDGEFW, sizeof(W685BRIDGEFW));
printk("Have DownLoad Bridge Firmware to W99685\n");
goto outup;
}
else if(cmd == IOCTLDRAWINBYPASS)
{
#if 1
if(copy_from_user(&ifirmware, (void *)buf, sizeof(Firmware_t))) {
diag_printf("Cannot copy data from user\n");
err = -EFAULT;
goto outup;
}
printk("Image size: %d\n", ifirmware.Length);
datap = (UINT8 *)malloc(ifirmware.Length*sizeof(UINT8));
if(!datap)
{
printk("No enough memory\n");
err = -ENOMEM;
goto outup;
}
if(copy_from_user(datap, (void *)ifirmware.Data, ifirmware.Length*sizeof(UINT8))) {
printk("Cannot copy data from user\n");
free(datap);
err = -EFAULT;
goto outup;
}
InitCFI(1);
wait_ms(20);
DrawInByPassMode(datap, ifirmware.Length);
InitCFI(0);
wait_ms(20);
free(datap);
#else
InitCFI(1);
wait_ms(20);
ByPass_Test();
InitCFI(0);
wait_ms(20);
#endif
goto outup;
}
if (copy_from_user(&priv->m_req, (void *)buf, sizeof(CmdReq_t))) {
diag_printf("Cannot copy data from user\n");
err = -EFAULT;
goto outup;
}
if(priv->m_req.cmd_params)
{
if (copy_from_user(&priv->m_cmdparams, (void *)priv->m_req.cmd_params, sizeof(CmdParameters_t))) {
diag_printf("Cannot copy data from user\n");
err = -EFAULT;
goto outup;
}
paramsp = &priv->m_cmdparams;
}
// allow no parameters
// else {
// printk("Command has not parameters\n");
// err = -EINVAL;
// goto outup;
// }
//printk("priv->m_req.cmd_rets: %x, %d\n", priv->m_req.cmd_rets, __LINE__);
if(priv->m_req.cmd_rets)
{
retsp = &priv->m_cmdrets;
memset(retsp, 0, sizeof(CmdReturns_t));
}
// printk("priv->m_req.cmd_rets: %x, %d\n", priv->m_req.cmd_rets, __LINE__);
// CommandDump(&priv->m_req, &priv->m_cmdparams);
#ifdef W865THREAD
if(priv->m_req.subcmd == CMD_GETJPGBITS)
{
err = GetImageLenFromContainer(containerp);
TDEBUG("Get Image len: %d, which: %d", err, containerp->reading);
if(err >= 0) {
RETVAL4(retsp) = ABYTE(err);
RETVAL3(retsp) = BBYTE(err);
RETVAL2(retsp) = CBYTE(err);
RETVAL1(retsp) = DBYTE(err);
}
if(priv->m_req.cmd_rets)
{
if(copy_to_user(priv->m_req.cmd_rets, retsp, sizeof(CmdReturns_t)))
{
err = -EFAULT;
goto outup;
}
}
up(&priv->lock);
return err;
}
#endif
// printk("subcmd: 0x%x, priv->m_req.cmd_rets: %x, %d\n", priv->m_req.subcmd, priv->m_req.cmd_rets, __LINE__);
err = SendCommand2W685(cmd, priv->m_req.subcmd, paramsp, retsp, priv->m_req.flag, NULL);
if(err < 0)
{
printf("W99685: send command erro\n");
goto outup;
}
if(priv->m_req.cmd_rets)
{
// printk("Copy to user retvals: %x, val: %x, %x, %x, %x\n", priv->m_req.cmd_rets,\
// RETVAL4(retsp), RETVAL3(retsp), RETVAL2(retsp), RETVAL1(retsp));
if(copy_to_user(priv->m_req.cmd_rets, retsp, sizeof(CmdReturns_t)))
{
diag_printf("Cannot copy data to user\n");
err = -EFAULT;
goto outup;
}
}
outup:
up(&priv->lock);
// printk("return value: %d\n", err);
out:
return err;
}
/*
* The ->queue() hook is responsible for initiating io on the io_u
* being passed in. If the io engine is a synchronous one, io may complete
* before ->queue() returns. Required.
*
* The io engine must transfer in the direction noted by io_u->ddir
* to the buffer pointed to by io_u->xfer_buf for as many bytes as
* io_u->xfer_buflen. Residual data count may be set in io_u->resid
* for a short read/write.
*/
static int fio_unvme_queue(struct thread_data *td, struct io_u *io_u)
{
/*
* Double sanity check to catch errant write on a readonly setup
*/
fio_ro_check(td, io_u);
int ret = 1;
unvme_page_t* page = io_u->engine_data;
page->slba = io_u->offset / unvme.ns->blocksize;
page->nlb = io_u->xfer_buflen / unvme.ns->blocksize;
switch (io_u->ddir) {
case DDIR_READ:
TDEBUG("READ page=%d lba=%#lx", page->id, page->slba);
ret = unvme_aread(unvme.ns, page);
break;
case DDIR_WRITE:
TDEBUG("WRITE page=%d lba=%#lx", page->id, page->slba);
ret = unvme_awrite(unvme.ns, page);
break;
default:
break;
}
/*
* Could return FIO_Q_QUEUED for a queued request,
* FIO_Q_COMPLETED for a completed request, and FIO_Q_BUSY
* if we could queue no more at this point (you'd have to
* define ->commit() to handle that.
*/
return ret ? FIO_Q_COMPLETED : FIO_Q_QUEUED;
}
QImage NemoThumbnailProvider::requestImage(const QString &id, QSize *size, const QSize &requestedSize)
{
setupCache();
// needed for stupid things like gallery model, which pass us a url
if (id.startsWith("file://")) {
// qWarning() << Q_FUNC_INFO << "Removing file:// prefix, before: " << id;
QString &nid = const_cast<QString &>(id);
nid = nid.remove(0, 7);
}
TDEBUG() << Q_FUNC_INFO << "Requested image: " << id << " with size " << requestedSize;
// sourceSize should indicate what size thumbnail you want. i.e. if you want a 120x120px thumbnail,
// set sourceSize: Qt.size(120, 120).
if (!requestedSize.isValid())
qFatal("You must request a sourceSize whenever you use nemoThumbnail");
if (size)
*size = requestedSize;
QByteArray hashData = cacheKey(id, requestedSize);
QImage img = attemptCachedServe(id, hashData);
if (!img.isNull()) {
TDEBUG() << Q_FUNC_INFO << "Read " << id << " from cache";
return img;
}
return generateThumbnail(id, hashData, requestedSize);
}
void ConnectionManager::connectionClose()
{
TDEBUG("connectionClose");
notifier->setEnabled(false);
::close(connectionFd);
connectionFd = -1;
if (treeManager) {
treeManager->touch();
disconnect(treeManager.get(), 0, this, 0);
TDEBUG("disconnected");
treeManager.reset();
}
deleteLater();
}
bool AsyncThriftForwarder::reloadConfig()
{
TDEBUG("Load configuration...");
if (!config_dir.exists(LOG4CXX_CONFIG_FILE)) {
TWARN("Cannot find '%s'", LOG4CXX_CONFIG_FILE);
return false;
}
if (!config_dir.exists(ASYNCTHRIFT_CONFIG_FILE)) {
TWARN("Cannot find '%s'", ASYNCTHRIFT_CONFIG_FILE);
return false;
}
TLogger::configure(qPrintable(config_dir.absoluteFilePath(LOG4CXX_CONFIG_FILE)));
QSettings settings(config_dir.absoluteFilePath(ASYNCTHRIFT_CONFIG_FILE), QSettings::IniFormat);
QString socket(settings.value("ForwarderSocket", QString(PKGSTATEDIR "/logger")).toString());
// TODO: Check reconfiguration. We could reconfigure delay and flush_interval
settings.beginGroup("LogForwarder");
int nentries = settings.beginReadArray("Forwarders");
for (int i = 0; i < nentries; i++) {
settings.setArrayIndex(i);
forwarders.append(new ForwarderManager(settings.value("Name").toString(), settings.value("ZQuorum").toString(), settings.value("Delay").toUInt(), settings.value("FlushInterval").toUInt(), socket));
}
settings.endArray();
return true;
}
/*
* The ->io_u_init() function is called once for each queue depth entry
* (numjobs x iodepth) prior to .init and after .get_file_size.
* It is needed if io_u buffer needs to be remapped.
*/
static int fio_unvme_io_u_init(struct thread_data *td, struct io_u *io_u)
{
int np = 0;
if (td->o.bs[DDIR_READ] > np) np = td->o.bs[DDIR_READ];
if (td->o.bs[DDIR_WRITE] > np) np = td->o.bs[DDIR_WRITE];
if (td->o.max_bs[DDIR_READ] > np) np = td->o.max_bs[DDIR_READ];
if (td->o.max_bs[DDIR_WRITE] > np) np = td->o.max_bs[DDIR_WRITE];
np = ((np + unvme.ns->pagesize - 1) & ~(unvme.ns->pagesize - 1));
np /= unvme.ns->pagesize;
if (np > unvme.ns->maxppio) {
error(0, 0, "%s np %d > %d", __func__, np, unvme.ns->maxppio);
return 1;
}
unvme_page_t* page = unvme_alloc(unvme.ns, td->thread_number - 1, np);
if (!page) {
error(0, 0, "%s unvme_alloc", __func__);
return 1;
}
page->data = io_u;
io_u->engine_data = page;
TDEBUG("page=%d", page->id);
return 0;
}
/*
* The ->getevents() hook is used to reap completion events from an async
* io engine. It returns the number of completed events since the last call,
* which may then be retrieved by calling the ->event() hook with the event
* numbers. Required.
*/
static int fio_unvme_getevents(struct thread_data *td, unsigned int min,
unsigned int max, const struct timespec *t)
{
unvme_data_t* udata = td->io_ops->data;
int events = 0;
struct timespec t0, t1;
uint64_t timeout = 0;
if (t) {
timeout = t->tv_sec * 1000000000L + t->tv_nsec;
clock_gettime(CLOCK_MONOTONIC_RAW, &t0);
}
for (;;) {
unvme_page_t* page = unvme_apoll(unvme.ns, td->thread_number - 1, 0);
if (page) {
udata->iocq[udata->tail] = page->data;
TDEBUG("PUT %d page=%d lba=%#lx", udata->tail, page->id, page->slba);
if (++udata->tail > td->o.iodepth) udata->tail = 0;
if (++events >= min) break;
} else if (t) {
clock_gettime(CLOCK_MONOTONIC_RAW, &t1);
uint64_t elapse = ((t1.tv_sec - t0.tv_sec) * 1000000000L)
+ t1.tv_nsec - t0.tv_nsec;
if (elapse > timeout) break;
}
}
return events;
}
/*
* The ->io_u_free() function is called once for each queue depth entry
* (numjobs x iodepth) prior to .init and after .get_file_size.
* It is needed if io_u buffer needs to be remapped.
*/
static void fio_unvme_io_u_free(struct thread_data *td, struct io_u *io_u)
{
unvme_page_t* page = io_u->engine_data;
if (page) {
TDEBUG("page=%d", page->id);
assert(page->data == io_u);
unvme_free(unvme.ns, page);
io_u->engine_data = NULL;
}
}
QImage NemoThumbnailProvider::generateThumbnail(const QString &id, const QByteArray &hashData, const QSize &requestedSize, bool crop)
{
QImage img;
QSize originalSize;
QByteArray format;
// image was not in cache thus we read it
QImageReader ir(id);
if (!ir.canRead())
return img;
originalSize = ir.size();
format = ir.format();
if (originalSize != requestedSize && originalSize.isValid()) {
if (crop) {
// scales arbitrary sized source image to requested size scaling either up or down
// keeping aspect ratio of the original image intact by maximizing either width or height
// and cropping the rest of the image away
QSize scaledSize(originalSize);
// now scale it filling the original rectangle by keeping aspect ratio, but expand if needed.
scaledSize.scale(requestedSize, Qt::KeepAspectRatioByExpanding);
// set the adjusted clipping rectangle in the center of the scaled image
QPoint center((scaledSize.width() - 1) / 2, (scaledSize.height() - 1) / 2);
QRect cr(0,0,requestedSize.width(), requestedSize.height());
cr.moveCenter(center);
ir.setScaledClipRect(cr);
// set requested target size of a thumbnail
ir.setScaledSize(scaledSize);
} else {
// Maintains correct aspect ratio without cropping, as such the final image may
// be smaller than requested in one dimension.
QSize scaledSize(originalSize);
scaledSize.scale(requestedSize, Qt::KeepAspectRatio);
ir.setScaledSize(scaledSize);
}
}
img = ir.read();
NemoImageMetadata meta(id, format);
if (meta.orientation() != NemoImageMetadata::TopLeft)
img = rotate(img, meta.orientation());
// write the scaled image to cache
if (meta.orientation() != NemoImageMetadata::TopLeft ||
(originalSize != requestedSize && originalSize.isValid())) {
writeCacheFile(hashData, img);
}
TDEBUG() << Q_FUNC_INFO << "Wrote " << id << " to cache";
return img;
}
unsigned long tar_read_tarblock(FILE *tarfile, struct tarinfotype *tarinfoptr)
{
unsigned long result;
TDEBUG(printf("Entering tar_read_tarblock.\n"));
/* reading the first info block */
result = fread(tarinfoptr, 512, 1, tarfile);
if (result < 0) { perror("Can't read tar info"); exit(1); }
if (feof(tarfile) ||
((tarinfoptr->name)[0] == '\0' && (tarinfoptr->name)[1] == '\0'))
{ TDEBUG(printf("End of tar file reached.\n"));
return FALSE;
}
TDEBUG({
tarblock_print(tarinfoptr);
printf("Comparing checksums:\n");
});
void ConnectionManager::onNewTreeAvailable()
{
TTRACE("onNewTreeAvailable");
if (treeManager) {
auto tree = treeManager->getConfigurationTree();
if (tree) {
TTRACE("got path %s", tree->path.toLatin1().data());
sendPush(tree->path, tree->fd);
}
} else {
TDEBUG("Connection already closed when new tree is available");
}
}
/*
* The ->event() hook is called to match an event number with an io_u.
* After the core has called ->getevents() and it has returned eg 3,
* the ->event() hook must return the 3 events that have completed for
* subsequent calls to ->event() with [0-2]. Required.
*/
static struct io_u* fio_unvme_event(struct thread_data *td, int event)
{
unvme_data_t* udata = td->io_ops->data;
struct io_u* io_u = NULL;
if (udata->head != udata->tail) {
io_u = udata->iocq[udata->head];
TDEBUG("GET %d page=%d lba=%#lx", udata->head,
((unvme_page_t*)io_u->engine_data)->id,
((unvme_page_t*)io_u->engine_data)->slba);
if (++udata->head > td->o.iodepth) udata->head = 0;
}
return io_u;
}
/*
* The ->get_file_size() is called once for every job (i.e. numjobs)
* before all other functions. This is called after ->setup() but
* is simpler to initialize here since we only care about the device name
* (given as file_name) and just have to specify the device size.
*/
static int fio_unvme_get_file_size(struct thread_data *td, struct fio_file *f)
{
TDEBUG("file=%s", f->file_name);
if (!fio_file_size_known(f)) {
if (do_unvme_init(f->file_name, td)) {
error(0, 0, "%s do_unvme_init", __func__);
return 1;
}
f->filetype = FIO_TYPE_CHAR;
f->real_file_size = unvme.ns->blockcount * unvme.ns->blocksize;
fio_file_set_size_known(f);
}
return 0;
}
/*
* This is paired with the ->init() function and is called when a thread is
* done doing io. Should tear down anything setup by the ->init() function.
* Not required.
*/
static void fio_unvme_cleanup(struct thread_data *td)
{
unvme_data_t* udata = td->io_ops->data;
if (udata) {
if (udata->iocq) free(udata->iocq);
free(udata);
}
pthread_mutex_lock(&unvme.mutex);
TDEBUG("active=%d", unvme.active);
if (--unvme.active == 0 && unvme.ns) {
DEBUG("%s unvme_close", __func__);
unvme_close(unvme.ns);
unvme.ns = NULL;
}
pthread_mutex_unlock(&unvme.mutex);
}
void ItemModel::Read(char * File)
{
int Token;
// ----
if( !g_ScriptEncode.ReadScript(File) )
{
//MessageBox(NULL, "file not found", "[ItemModel]", ERROR);
return;
}
// ----
while(true)
{
Token = g_ScriptEncode.GetToken();
// ----
if( Token == END )
{
break;
}
// ----
ItemModelData lpData;
// ----
lpData.ItemType = g_ScriptEncode.GetNumber();
// ----
g_ScriptEncode.GetToken();
lpData.ItemIndex = g_ScriptEncode.GetNumber();
// ----
g_ScriptEncode.GetToken();
strcpy(lpData.Model, g_ScriptEncode.GetString());
// ----
g_ScriptEncode.GetToken();
lpData.R = g_ScriptEncode.GetNumber();
// ----
g_ScriptEncode.GetToken();
lpData.G = g_ScriptEncode.GetNumber();
// ----
g_ScriptEncode.GetToken();
lpData.B = g_ScriptEncode.GetNumber();
// ----
TDEBUG("[%d] %d %d - %s", m_Data.size(), lpData.ItemType, lpData.ItemIndex, lpData.Model);
m_Data.push_back(lpData);
}
}
static int w99685_thread(void *arg)
{
int ret = 0;
UINT32 imglen = 0;;
UINT16 blocks = 0;
UINT8 choice = 0;
w685cf_t *priv = arg;
ImageContainer_t *imgcontainerp = priv->images;
/*
* This thread doesn't need any user-level access,
* so get rid of all our resources..
*/
daemonize();
reparent_to_init();
// exit_files(current);
// current->files = init_task.files;
// atomic_inc(¤t->files->count);
// daemonize();
// reparent_to_init();
/* avoid getting signals */
// spin_lock_irq(¤t->sigmask_lock);
// flush_signals(current);
// sigfillset(¤t->blocked);
// recalc_sigpending(current);
// spin_unlock_irq(¤t->sigmask_lock);
/* set our name for identification purposes */
sprintf(current->comm, "W99685CFI_thread");
//Get Image Data, :P
for(;;) {
if(priv->user) { // Someone open the camera, get the data.
W99685CMD_GetImageLen(&imglen);
TDEBUG("imagelen: %d", imglen);
if(imglen > 0&& imglen <= W685BUF_SIZE)
{
blocks = (imglen-1+DATABLOCKSIZE)/DATABLOCKSIZE;
if(blocks < W685BUF_SIZE/DATABLOCKSIZE) {
choice = imgcontainerp->which;
TDEBUG("Write choice: %d, and choicelen: %d", choice, IMAGELEN(imgcontainerp, choice));
down( &((IMAGEHOLD(imgcontainerp, choice)).ilock) );
if(IMAGELEN(imgcontainerp, choice) > 0) //Have had data, don't overwrite it.
goto do_next;
W99685_GetData(IMAGEDATA(imgcontainerp, choice) ,blocks);
(IMAGEHOLD(imgcontainerp, choice)).len = imglen;
do_next:
imgcontainerp->which = (++(imgcontainerp->which))%IMGCONTAINERSIZE;
up( &((IMAGEHOLD(imgcontainerp, choice)).ilock) );
}
TDEBUG("Sleep...");
wait_ms(20);
}
else if(imglen < 0) //can't recover, it crazy :(
{
W685_ERR("Get image length error: %d\n", imglen);
break;
}
else {
wait_ms(500);
continue;
}
}
else
sleep_on_timeout(&priv->waitq, 10);
}
out:
return ret;
}
/**
* Setup trigger handling
* @return void
*/
void tikle_trigger_handling(void)
{
unsigned int i = 0, base;
struct task_struct *stop;
/*
* setting up triggers
*/
TDEBUG("TRIGGERS:\n");
for (i = 0; i < tikle_num_timers; i++) {
init_timer(&tikle_timers[i].trigger);
tikle_timers[i].trigger.function = tikle_flag_handling;
/*
* send the next trigger ID, if actual trigger it is
* not the latest, else send your own trigger ID
*/
if (tikle_timers[i].trigger_id < tikle_timers[tikle_num_timers-1].trigger_id) {
tikle_timers[i].trigger.data = tikle_timers[i+1].trigger_id;
} else {
tikle_timers[i].trigger.data = tikle_timers[i].trigger_id;
}
TDEBUG("Registering timer %d; trigger_id=%d ; trigger_data=%ld\n",
i, tikle_timers[i].trigger_id, tikle_timers[i].trigger.data);
/*
* calculate expire time to trigger
* based on the experiment start time
*/
base = jiffies;
tikle_timers[i].trigger.expires = base +
msecs_to_jiffies(faultload[tikle_timers[i].trigger_id].op_value[0].num * 1000);
if (tikle_timers[i].trigger_id == 0) { /* if timer corresponds to the first timer */
/*
* register hook
*/
tikle_pre_hook.hook = &tikle_pre_hook_function;
tikle_pre_hook.hooknum = NF_IP_PRE_ROUTING;
tikle_pre_hook.pf = PF_INET;
tikle_pre_hook.priority = NF_IP_PRI_FIRST;
nf_register_hook(&tikle_pre_hook);
tikle_post_hook.hook = &tikle_post_hook_function;
tikle_post_hook.hooknum = NF_IP_POST_ROUTING;
tikle_post_hook.pf = PF_INET;
tikle_post_hook.priority = NF_IP_PRI_FIRST;
nf_register_hook(&tikle_post_hook);
//nf_register_queue_handler(PF_INET, &qh);
/*
* if timer corresponds
* to the last timer
*/
} else if (tikle_timers[i].trigger_id == tikle_timers[tikle_num_timers-1].trigger_id) {
/*
* unregister hook timer
* this is done by a thread
* to avoid console freezing
*/
/* not handled here */
stop = kthread_run((void *)tikle_stop_trigger, (unsigned int *)base, "thread stop trigger");
}
add_timer(&tikle_timers[i].trigger);
}
TDEBUG("--------------------------------\n");
}
long w99685_v4l1_read(w685cf_t *priv, char * buf, cyg_uint32 *count)
{
int k, j;
long rc = 0;
long size = 0;
long blocks = (*count-1+DATABLOCKSIZE)/DATABLOCKSIZE;
//w685cf_t *priv = (w685cf_t *)vdev->priv;
#ifndef W865THREAD
char *buffer = priv->rawbuf;
//KDEBUG("Read data\n");
if(blocks > W685BUF_SIZE/DATABLOCKSIZE) {
printf("Too long data: %dbytes\n", *count);
rc = -EINVAL;
goto out;
}
if (down_interruptible2(&(priv->lock))) {
rc = -EINTR;
goto out;
}
if (!buf ) {
printf("W99865:vdev || !buf \n");
rc = -EFAULT;
goto out_up;
}
rc = W99685_GetData(buffer, blocks);
if(!rc)
rc = ENOERR;//clyu
//if(rc > 0) //yc
{
if (copy_to_user(buf, buffer, *count)<0) {
printf("copy_to_user\n");
rc = -EFAULT;
goto out_up;
}
}
#if 0
int i;
for(i = 0; i < 20; i++)
diag_printf("%x ", *(buffer+i));
diag_printf("\n");
for(i = 0; i < 20; i++)
diag_printf("%x ", *(buf+i));
diag_printf("\n");
#endif
#endif
#ifdef W865THREAD
ImageContainer_t *container = priv->images;
UINT8 choice = container->reading; //Get Write Position
TDEBUG("Begin reading...");
if(blocks > W685BUF_SIZE/DATABLOCKSIZE) {
printk("Too long data: %dbytes\n", *count);
rc = -EINVAL;
goto out;
}
if (down_interruptible2(&priv->lock)) {
rc = -EINTR;
goto out;
}
down( &(IMAGEHOLD(container, choice).ilock) );
TDEBUG("read choice: %d, imglen: %d", choice, IMAGELEN(container, choice));
if(IMAGELEN(container, choice) == 0) {
// == 0, shouldn't happen, if so, just out.
rc = 0;
goto flag_up;
}
else if(IMAGELEN(container, choice) != *count)
{ // != count, :(, wrong data ,remove it
IMAGELEN(container, choice) = 0;
rc = 0;
goto flag_up;
}
if (copy_to_user(buf, IMAGEDATA(container, choice), *count)) {
printk("copy_to_user\n");
rc = -EFAULT;
goto flag_up;
}
IMAGELEN(container, choice) = 0; // clean the container's data
container->reading = (++(container->reading))%IMGCONTAINERSIZE; // Goto Next Reading Position
rc = ENOERR;//clyu
//rc = *count;//clyu
flag_up:
up( &(IMAGEHOLD(container, choice).ilock) );
#endif
out_up:
up(&priv->lock);
out:
//TDEBUG("End reading...");
//diag_printf("read rc: %d \n",rc);
return rc;
}
