/** Take the following timing into consideration for future calculations */
static void update_timings(JitterBuffer *jitter, spx_int32_t timing)
{
if (timing < -32767)
timing = -32767;
if (timing > 32767)
timing = 32767;
/* If the current sub-window is full, perform a rotation and discard oldest sub-widow */
if (jitter->timeBuffers[0]->curr_count >= jitter->subwindow_size)
{
int i;
/*fprintf(stderr, "Rotate buffer\n");*/
struct TimingBuffer *tmp = jitter->timeBuffers[MAX_BUFFERS-1];
for (i=MAX_BUFFERS-1;i>=1;i--)
jitter->timeBuffers[i] = jitter->timeBuffers[i-1];
jitter->timeBuffers[0] = tmp;
tb_init(jitter->timeBuffers[0]);
}
tb_add(jitter->timeBuffers[0], timing);
}
int GaviotaTb::initTB(const string &path, const string &scheme,
uint64 cache_size) {
if (NULL == paths) {
cerr << "error in path initialization for Gaviota TBs" << endl;
return 0;
}
paths = tbpaths_add(paths, path.c_str());
if (NULL == paths) {
cerr << "error in path initialization for Gaviota TBs" << endl;
return 0;
}
int intScheme;
if (scheme == "cp1")
intScheme = tb_CP1;
else if (scheme == "cp2")
intScheme = tb_CP2;
else if (scheme == "cp3")
intScheme = tb_CP3;
else if (scheme == "cp4")
intScheme = tb_CP4;
else {
cerr << "unrecognized compression scheme for GTBs: " << scheme << endl;
return 0;
}
char *initinfo = tb_init (0, intScheme, paths);
tbcache_init((size_t)cache_size, WDL_FRACTION);
tbstats_reset();
if (initinfo != NULL) {
cout << initinfo << endl;
}
int avail = tb_availability();
if (avail & (1<<6)) return 6;
else if (avail & (1<<4)) return 5;
else if (avail & (1<<2)) return 4;
else if (avail & 1) return 3;
else return 0; // error?
}
/* //////////////////////////////////////////////////////////////////////////////////////
* implementation
*/
tb_bool_t xm_init_(tb_size_t mode, tb_hize_t build)
{
// is inited?
if (tb_atomic_fetch_and_inc(&g_init)) return tb_true;
// trace
tb_trace_d("init: ..");
// check mode
if (!xm_check_mode(mode)) return tb_false;
// check version
xm_version_check(build);
// init tbox
if (!tb_init(tb_null, tb_null)) return tb_false;
// trace
tb_trace_d("init: ok");
// ok
return tb_true;
}
int main(int argc, char const *argv[])
{
tb_init();
Player player;
while (1) {
g_input.update();
if (g_input.getKey() == KeyEsc) {
tb_shutdown();
return 0;
}
player.update();
tb_clear();
player.render();
tb_present();
}
tb_shutdown();
return 0;
}
/*
* readpattern -- read a pattern. if it is the
* search string, recompile it.
* pattern not updated if the user types in an empty line.
*/
int
readpattern(const char *prompt,
TBUFF **apat,
regexp ** srchexpp,
int c,
int fromscreen)
{
char temp[NPAT];
int status;
TRACE((T_CALLED "readpattern(%s, %s, %p, %d, %d)\n",
prompt ? prompt : "",
tb_visible(*apat),
(void *) srchexpp,
c,
fromscreen));
if (fromscreen) {
if ((status = screen_to_ident(temp, sizeof(temp))) == TRUE) {
if (tb_init(apat, EOS) == 0
|| tb_bappend(apat, temp, strlen(temp)) == 0) {
status = FALSE;
}
}
if (status != TRUE)
returnCode(status);
} else {
/* don't expand #, %, :, and never process backslashes
since they're handled by regexp directly for the
search pattern, and in delins() for the replacement
pattern */
hst_glue(c);
/*
* kbd_reply() expects a trailing null, to simplify calls from
* kbd_string().
*/
if (tb_values(*apat) != 0)
tb_append(apat, EOS);
status = kbd_reply(prompt, apat,
eol_history, c,
KBD_EXPPAT | KBD_0CHAR,
no_completion);
if (tb_length(*apat) != 0)
tb_unput(*apat); /* trim the trailing null */
}
if (status == TRUE) {
if (srchexpp) { /* compile it */
beginDisplay();
FreeIfNeeded(*srchexpp);
endofDisplay();
*srchexpp = regcomp(tb_values(*apat),
tb_length(*apat),
b_val(curbp, MDMAGIC));
if (!*srchexpp)
returnCode(FALSE);
}
} else if (status == FALSE && tb_length(*apat) != 0) { /* Old one */
status = TRUE;
}
returnCode(status);
}
CAMLprim value tbstub_init() {
return Val_int(tb_init());
}
/* //////////////////////////////////////////////////////////////////////////////////////
* main
*/
tb_int_t main(tb_int_t argc, tb_char_t** argv)
{
// init tbox
#if 0
if (!tb_init(tb_null, (tb_byte_t*)malloc(300 * 1024 * 1024), 300 * 1024 * 1024)) return 0;
#else
if (!tb_init(tb_null, tb_null, 0)) return 0;
#endif
// init
tb_int_t ok = 0;
tb_char_t const* name = tb_null;
// find the main func from the .demo file
if (!name)
{
// init file
tb_file_ref_t file = tb_file_init(".demo", TB_FILE_MODE_RO);
if (file)
{
// read line
tb_char_t line[8192] = {0};
if (tb_file_read(file, (tb_byte_t*)line, sizeof(line) - 1))
{
tb_size_t i = 0;
tb_size_t n = tb_arrayn(g_demo);
for (i = 0; i < n; i++)
{
// find it?
if (g_demo[i].name && !tb_strnicmp(g_demo[i].name, line, tb_strlen(g_demo[i].name)))
{
// save name
name = g_demo[i].name;
// done main
ok = g_demo[i].main(argc, argv);
break;
}
}
}
// exit file
tb_file_exit(file);
}
}
// find the main func from the first argument
if (!name && argc > 1 && argv[1])
{
tb_size_t i = 0;
tb_size_t n = tb_arrayn(g_demo);
for (i = 0; i < n; i++)
{
// find it?
if (g_demo[i].name && !tb_stricmp(g_demo[i].name, argv[1]))
{
// save name
name = g_demo[i].name;
// done main
ok = g_demo[i].main(argc - 1, argv + 1);
break;
}
}
}
// no this demo? help it
if (!name)
{
tb_trace_i("======================================================================");
tb_trace_i("help: echo \"name\" > ./.demo");
tb_trace_i("help: ./demo.b args ...");
tb_trace_i("help: or");
tb_trace_i("help: ./demo.b name args ...");
tb_trace_i("help: ");
tb_trace_i("help: example: echo \"stream\" > ./.demo");
tb_trace_i("help: example: ./demo.b --help");
tb_trace_i("help: example: ./demo.b http://www.xxxxx.com /tmp/a");
tb_trace_i("help: example: or");
tb_trace_i("help: example: ./demo.b stream http://www.xxxxx.com /tmp/a");
tb_trace_i("help: ");
// walk name
tb_size_t i = 0;
tb_size_t n = tb_arrayn(g_demo);
for (i = 0; i < n; i++) tb_trace_i("help: name: %s", g_demo[i].name);
}
// exit tbox
tb_exit();
// ok?
return ok;
}
/*
* This is invoked as a wrapper for 'kbd_putc()'. It writes to the Messages
* scratch buffer, and also to the message line. If the Messages buffer isn't
* visible, it is automatically popped up when a new message line is begun.
* Since it's a scratch buffer, popping it down destroys it.
*/
int
msg_putc(int c)
{
BUFFER *savebp = curbp;
WINDOW *savewp = curwp;
MARK savemk;
int saverow = ttrow;
int savecol = ttcol;
register BUFFER *bp;
register WINDOW *wp;
if ((bp = create_msgs()) == 0)
return TRUE;
savemk = DOT;
beginDisplay();
/*
* Modify the current-buffer state as unobtrusively as possible (i.e.,
* don't modify the buffer order, and don't make the buffer visible if
* it isn't already!). To use the 'bputc()' logic, though, we've got
* to have a window, even if it's not real.
*/
curbp = bp;
if ((wp = bp2any_wp(bp)) == NULL) {
static WINDOW dummy;
wp = &dummy;
wp->w_bufp = bp;
}
curwp = wp;
DOT.l = lback(buf_head(bp));
DOT.o = llength(DOT.l);
/*
* Write into the [Messages]-buffer
*/
#if OPT_TRACE
if (c == '\n') {
static TBUFF *ss;
int len = (DOT.o > 0) ? DOT.o : 1;
if (tb_init(&ss, EOS) != 0
&& tb_bappend(&ss,
(DOT.o > 0) ? lvalue(DOT.l) : "?",
(size_t) len) != 0
&& tb_append(&ss, EOS) != 0) {
TRACE(("msg:%s\n",
visible_buff(tb_values(ss),
(int) tb_length(ss) - 1, TRUE)));
}
}
#endif
if ((c != '\n') || (DOT.o > 0)) {
bputc(c);
b_clr_changed(bp);
}
/* Finally, restore the original current-buffer and write the character
* to the message line.
*/
curbp = savebp;
curwp = savewp;
if (savewp)
DOT = savemk;
movecursor(saverow, savecol);
if (c != '\n') {
if (sgarbf) {
mlsavec(c);
} else {
kbd_putc(c);
}
}
endofDisplay();
return TRUE;
}
/**
* \fn wlanDrvIf_Create
* \brief Create the driver instance
*
* Allocate driver object.
* Initialize driver OS resources (IRQ, workqueue, events socket)
* Setup driver network interface.
* Create and link all driver modules.
*
* \note
* \param void
* \return 0 - OK, else - failure
* \sa wlanDrvIf_Destroy
*/
static int wlanDrvIf_Create (void)
{
TWlanDrvIfObj *drv;
int rc;
/* Allocate driver's structure */
drv = kmalloc (sizeof(TWlanDrvIfObj), GFP_KERNEL);
if (!drv)
{
return -ENOMEM;
}
#ifdef TI_DBG
tb_init(TB_OPTION_NONE);
#endif
pDrvStaticHandle = drv; /* save for module destroy */
#ifdef TI_MEM_ALLOC_TRACE
os_printf ("MTT:%s:%d ::kmalloc(%lu, %x) : %lu\n", __FUNCTION__, __LINE__, sizeof(TWlanDrvIfObj), GFP_KERNEL, sizeof(TWlanDrvIfObj));
#endif
memset (drv, 0, sizeof(TWlanDrvIfObj));
/*
#if defined HOST_PLATFORM_OMAP3430 || defined HOST_PLATFORM_ZOOM2 || defined HOST_PLATFORM_ZOOM1
if(g_external_board)
{
WLAN_OS_REPORT(("\nZoom2 use external board"));
drv->irq = (OMAP_GPIO_IRQ(IRQ_GPIO_EXT));
}
else
{
drv->irq = (OMAP_GPIO_IRQ(IRQ_GPIO));
}
#endif
*/
drv->irq = tiwlan_ext_int_init();
drv->tCommon.eDriverState = DRV_STATE_IDLE;
#ifdef AP_MODE_ENABLED
/* for STA role, need to allocate another driver and to set STA role */
drv->tCommon.eIfRole = IF_ROLE_TYPE_AP;
#endif
drv->pWorkQueue = create_singlethread_workqueue (TIWLAN_DRV_NAME);
if (!drv->pWorkQueue)
{
return -ENOMEM;
}
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
INIT_WORK(&drv->tWork, wlanDrvIf_DriverTask, (void *)drv);
#else
INIT_WORK(&drv->tWork, wlanDrvIf_DriverTask);
#endif
spin_lock_init (&drv->lock);
/* Setup driver network interface. */
rc = wlanDrvIf_SetupNetif (drv);
if (rc)
{
kfree (drv);
return rc;
}
/* Create the events socket interface */
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
drv->wl_sock = netlink_kernel_create( NETLINK_USERSOCK, 0, NULL, THIS_MODULE );
#else
drv->wl_sock = netlink_kernel_create(&init_net, NETLINK_USERSOCK, 0, NULL, NULL, THIS_MODULE );
#endif
if (drv->wl_sock == NULL)
{
ti_dprintf (TIWLAN_LOG_ERROR, "netlink_kernel_create() failed !\n");
return -EINVAL;
}
/* Create all driver modules and link their handles */
drvMain_Create (drv,
&drv->tCommon.hDrvMain,
&drv->tCommon.hCmdHndlr,
&drv->tCommon.hContext,
&drv->tCommon.hTxDataQ,
&drv->tCommon.hTxMgmtQ,
&drv->tCommon.hTxCtrl,
&drv->tCommon.hTWD,
&drv->tCommon.hEvHandler,
&drv->tCommon.hCmdDispatch,
&drv->tCommon.hReport);
/*
* Initialize interrupts (or polling mode for debug):
*/
#ifdef PRIODIC_INTERRUPT
/* Debug mode: Polling (the timer is started by HwInit process) */
drv->hPollTimer = os_timerCreate ((TI_HANDLE)drv, wlanDrvIf_PollIrqHandler, (TI_HANDLE)drv);
#else
/* Normal mode: Interrupts (the default mode) */
rc = hPlatform_initInterrupt (drv, (void*)wlanDrvIf_HandleInterrupt);
if (rc)
{
ti_dprintf (TIWLAN_LOG_ERROR, "wlanDrvIf_Create(): Failed to register interrupt handler!\n");
return rc;
}
#ifdef HOST_PLATFORM_OMAP2430
set_irq_type (drv->irq, IRQT_FALLING);
#endif
#endif /* PRIODIC_INTERRUPT */
return 0;
}
/**
* \fn wlanDrvIf_Create
* \brief Create the driver instance
*
* Allocate driver object.
* Initialize driver OS resources (IRQ, workqueue, events socket)
* Setup driver network interface.
* Create and link all driver modules.
*
* \note
* \param void
* \return 0 - OK, else - failure
* \sa wlanDrvIf_Destroy
*/
static int wlanDrvIf_Create (void)
{
TWlanDrvIfObj *drv; /* Dm: Failure is not cleaned properly !!! */
int rc;
/* Allocate driver's structure */
drv = kmalloc (sizeof(TWlanDrvIfObj), GFP_KERNEL);
if (!drv)
{
return -ENOMEM;
}
#ifdef TI_DBG
tb_init(TB_OPTION_NONE);
#endif
pDrvStaticHandle = drv; /* save for module destroy */
#ifdef TI_MEM_ALLOC_TRACE
os_printf ("MTT:%s:%d ::kmalloc(%lu, %x) : %lu\n", __FUNCTION__, __LINE__, sizeof(TWlanDrvIfObj), GFP_KERNEL, sizeof(TWlanDrvIfObj));
#endif
memset (drv, 0, sizeof(TWlanDrvIfObj));
/* Dm: drv->irq = TNETW_IRQ; */
drv->tCommon.eDriverState = DRV_STATE_IDLE;
drv->tiwlan_wq = create_freezeable_workqueue(DRIVERWQ_NAME);
if (!drv->tiwlan_wq) {
ti_dprintf (TIWLAN_LOG_ERROR, "wlanDrvIf_Create(): Failed to create workQ!\n");
rc = -EINVAL;
goto drv_create_end_1;
}
drv->wl_packet = 0;
drv->wl_count = 0;
#ifdef CONFIG_HAS_WAKELOCK
wake_lock_init(&drv->wl_wifi, WAKE_LOCK_SUSPEND, "wifi_wake");
wake_lock_init(&drv->wl_rxwake, WAKE_LOCK_SUSPEND, "wifi_rx_wake");
#endif
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
INIT_WORK(&drv->tWork, wlanDrvIf_DriverTask, (void *)drv);
#else
INIT_WORK(&drv->tWork, wlanDrvIf_DriverTask);
#endif
spin_lock_init (&drv->lock);
/* Setup driver network interface. */
rc = wlanDrvIf_SetupNetif (drv);
if (rc) {
goto drv_create_end_2;
}
/* Create the events socket interface */
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
drv->wl_sock = netlink_kernel_create( NETLINK_USERSOCK, 0, NULL, THIS_MODULE );
#else
drv->wl_sock = netlink_kernel_create(&init_net, NETLINK_USERSOCK, 0, NULL, NULL, THIS_MODULE );
#endif
if (drv->wl_sock == NULL) {
ti_dprintf (TIWLAN_LOG_ERROR, "netlink_kernel_create() failed !\n");
rc = -EINVAL;
goto drv_create_end_3;
}
/* Create all driver modules and link their handles */
rc = drvMain_Create (drv,
&drv->tCommon.hDrvMain,
&drv->tCommon.hCmdHndlr,
&drv->tCommon.hContext,
&drv->tCommon.hTxDataQ,
&drv->tCommon.hTxMgmtQ,
&drv->tCommon.hTxCtrl,
&drv->tCommon.hTWD,
&drv->tCommon.hEvHandler,
&drv->tCommon.hCmdDispatch,
&drv->tCommon.hReport);
if (rc != TI_OK) {
ti_dprintf (TIWLAN_LOG_ERROR, "%s: Failed to dvrMain_Create!\n", __func__);
rc = -EINVAL;
goto drv_create_end_4;
}
/*
* Initialize interrupts (or polling mode for debug):
*/
#ifdef PRIODIC_INTERRUPT
/* Debug mode: Polling (the timer is started by HwInit process) */
drv->hPollTimer = os_timerCreate ((TI_HANDLE)drv, wlanDrvIf_PollIrqHandler, (TI_HANDLE)drv);
#else
/* Normal mode: Interrupts (the default mode) */
rc = hPlatform_initInterrupt (drv, (void*)wlanDrvIf_HandleInterrupt);
#if 1 //wait to debug
if (rc) {
ti_dprintf (TIWLAN_LOG_ERROR, "wlanDrvIf_Create(): Failed to register interrupt handler!\n");
goto drv_create_end_5;
}
#endif
#endif /* PRIODIC_INTERRUPT */
return 0;
#if 1 //wait to debug
drv_create_end_5:
/* Destroy all driver modules */
if (drv->tCommon.hDrvMain) {
drvMain_Destroy (drv->tCommon.hDrvMain);
}
#endif
drv_create_end_4:
if (drv->wl_sock) {
sock_release (drv->wl_sock->sk_socket);
}
drv_create_end_3:
/* Release the driver network interface */
if (drv->netdev) {
unregister_netdev (drv->netdev);
free_netdev (drv->netdev);
}
drv_create_end_2:
#ifdef CONFIG_HAS_WAKELOCK
wake_lock_destroy(&drv->wl_wifi);
wake_lock_destroy(&drv->wl_rxwake);
#endif
if (drv->tiwlan_wq)
destroy_workqueue(drv->tiwlan_wq);
drv_create_end_1:
kfree(drv);
printk("%s: Fail\n", __func__);
return rc;
}
/*
* Parse a cntl_a sequence, returning the number of characters processed.
* Set videoattribute and hypercmd as side-effects.
*/
int
decode_attribute(char *text, size_t length, size_t offset, int *countp)
{
int c; /* current char during scan */
int count = 0;
int found;
#if OPT_HYPERTEXT
size_t save_offset;
#endif
while (text[offset] == CONTROL_A) {
found = FALSE;
count = 0;
offset++;
while (offset < length) {
c = text[offset];
if (isDigit(c)) {
count = count * 10 + c - '0';
offset++;
} else
break;
}
if (count == 0)
count = 1;
videoattribute = VOWN_CTLA;
while (offset < length
&& (c = text[offset]) != CONTROL_A
&& !found) {
switch (c) {
case 'C':
/* We have color. Get color value */
offset++;
c = text[offset];
if (isDigit(c))
videoattribute |= VCOLORATTR(c - '0');
else if ('A' <= c && c <= 'F')
videoattribute |= VCOLORATTR(c - 'A' + 10);
else if ('a' <= c && c <= 'f')
videoattribute |= VCOLORATTR(c - 'a' + 10);
else
offset--; /* Invalid attribute */
break;
case 'U':
videoattribute |= VAUL;
break;
case 'B':
videoattribute |= VABOLD;
break;
case 'R':
videoattribute |= VAREV;
break;
case 'I':
videoattribute |= VAITAL;
break;
#if OPT_HYPERTEXT
case 'H':
save_offset = offset;
offset++;
while (offset < length
&& text[offset] != EOS)
offset++;
if (offset < length) {
tb_init(&hypercmd, EOS);
tb_bappend(&hypercmd,
&text[save_offset + 1],
offset - save_offset);
tb_append(&hypercmd, EOS);
} else { /* skip bad hypertext string */
offset = save_offset;
}
break;
#endif
case ':':
found = TRUE;
break;
default:
offset--;
found = TRUE;
break;
}
offset++;
}
if (videoattribute != VOWN_CTLA && count != 0)
break;
}
*countp = count;
return (int) offset;
}
int
attributeregion(void)
{
BUFFER *bp = curbp;
int status;
REGION region;
AREGION *arp;
if ((status = getregion(bp, ®ion)) == TRUE) {
if (apply_attribute()) {
if (add_line_attrib(bp, ®ion, regionshape, videoattribute,
#if OPT_HYPERTEXT
hypercmd
#else
0
#endif
)) {
return TRUE;
}
/* add new attribute-region */
if ((arp = alloc_AREGION()) == NULL) {
return FALSE;
}
arp->ar_region = region;
arp->ar_vattr = videoattribute; /* include ownership */
arp->ar_shape = regionshape;
#if OPT_HYPERTEXT
arp->ar_hypercmd = 0;
if (tb_length(hypercmd) && *tb_values(hypercmd)) {
#if OPT_EXTRA_COLOR
if (tb_length(hypercmd) > 4
&& !memcmp(tb_values(hypercmd), "view ", (size_t) 4)) {
int *newVideo = lookup_extra_color(XCOLOR_HYPERTEXT);
if (!isEmpty(newVideo)) {
arp->ar_vattr = (VIDEO_ATTR) * newVideo;
}
}
#endif
arp->ar_hypercmd = strmalloc(tb_values(hypercmd));
tb_init(&hypercmd, 0);
}
#endif
attach_attrib(bp, arp);
} else { /* purge attributes in this region */
L_NUM rls = line_no(bp, region.r_orig.l);
L_NUM rle = line_no(bp, region.r_end.l);
C_NUM ros = region.r_orig.o;
C_NUM roe = region.r_end.o;
AREGION **pp;
AREGION **qq;
AREGION *p, *n;
int owner;
owner = VOWNER(videoattribute);
purge_line_attribs(bp, ®ion, regionshape, owner);
pp = &(bp->b_attribs);
for (p = *pp; p != 0; pp = qq, p = *pp) {
L_NUM pls, ple;
C_NUM pos, poe;
if (interrupted())
return FALSE;
qq = &(p->ar_next);
if (owner != 0 && owner != VOWNER(p->ar_vattr))
continue;
pls = line_no(bp, p->ar_region.r_orig.l);
ple = line_no(bp, p->ar_region.r_end.l);
pos = p->ar_region.r_orig.o;
poe = p->ar_region.r_end.o;
/* Earlier the overlapping region check was made based only
* on line numbers and so was right only for FULLINES shape
* changed it to be correct for rgn_EXACT and rgn_RECTANGLE also
* -kuntal 9/13/98
*/
/*
* check for overlap:
* for any shape of region 'p' things are fine as long as
* 'region' is above or below it
*/
if (ple < rls || pls > rle)
continue;
/*
* for rgn_EXACT 'p' region
*/
if (p->ar_shape == rgn_EXACT) {
if (ple == rls && poe - 1 < ros)
continue;
if (pls == rle && pos > roe)
continue;
}
/*
* for rgn_RECTANGLE 'p' region
*/
if (p->ar_shape == rgn_RECTANGLE)
if (poe < ros || pos > roe)
continue;
/*
* FIXME: this removes the whole of an overlapping region;
* we really only want to remove the overlapping portion...
*/
/*
* we take care of this fix easily as long as neither of
* 'p' or 'region' are rgn_RECTANGLE. we will need to create
* at the most one new region in case 'region' is
* completely contained within 'p'
*/
if (p->ar_shape != rgn_RECTANGLE && regionshape != rgn_RECTANGLE) {
if ((rls > pls) || (rls == pls && ros > pos)) {
p->ar_shape = rgn_EXACT;
if ((rle < ple) || (rle == ple && roe < poe)) {
/* open a new region */
if ((n = alloc_AREGION()) == NULL) {
return FALSE;
}
n->ar_region = p->ar_region;
n->ar_vattr = p->ar_vattr;
n->ar_shape = p->ar_shape;
#if OPT_HYPERTEXT
n->ar_hypercmd = p->ar_hypercmd;
#endif
n->ar_region.r_orig.l = (region.r_end.l);
n->ar_region.r_orig.o = (region.r_end.o);
attach_attrib(bp, n);
}
p->ar_region.r_end.l = (region.r_orig.l);
p->ar_region.r_end.o = (region.r_orig.o);
curwp->w_flag |= WFHARD;
continue;
} else if ((rle < ple) || (rle == ple && roe < poe)) {
p->ar_region.r_orig.l = (region.r_end.l);
p->ar_region.r_orig.o = (region.r_end.o);
curwp->w_flag |= WFHARD;
continue;
}
}
free_attrib2(bp, pp);
qq = pp;
}
}
}
return status;
}
/**
* \fn wlanDrvIf_Create
* \brief Create the driver instance
*
* Allocate driver object.
* Initialize driver OS resources (IRQ, workqueue, events socket)
* Setup driver network interface.
* Create and link all driver modules.
*
* \note
* \param void
* \return 0 - OK, else - failure
* \sa wlanDrvIf_Destroy
*/
static int wlanDrvIf_Create (void)
{
TWlanDrvIfObj *drv;
int rc;
/* Allocate driver's structure */
drv = kmalloc (sizeof(TWlanDrvIfObj), GFP_KERNEL);
if (!drv)
{
return -ENOMEM;
}
#ifdef TI_DBG
tb_init(TB_OPTION_NONE);
#endif
pDrvStaticHandle = drv; /* save for module destroy */
#ifdef TI_MEM_ALLOC_TRACE
os_printf ("MTT:%s:%d ::kmalloc(%lu, %x) : %lu\n", __FUNCTION__, __LINE__, sizeof(TWlanDrvIfObj), GFP_KERNEL, sizeof(TWlanDrvIfObj));
#endif
memset (drv, 0, sizeof(TWlanDrvIfObj));
drv->tCommon.eDriverState = DRV_STATE_IDLE;
drv->pWorkQueue = create_singlethread_workqueue(TIWLAN_WQ_NAME);
if (!drv->pWorkQueue)
{
return -ENOMEM;
}
drv->wl_packet = 0;
drv->wl_count = 0;
#ifdef CONFIG_HAS_WAKELOCK
wake_lock_init(&drv->wl_wifi, WAKE_LOCK_SUSPEND, "wifi_wake");
wake_lock_init(&drv->wl_rxwake, WAKE_LOCK_SUSPEND, "wifi_rx_wake");
#endif
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
INIT_WORK(&drv->tWork, wlanDrvIf_DriverTask, (void *)drv);
#else
INIT_WORK(&drv->tWork, wlanDrvIf_DriverTask);
#endif
spin_lock_init (&drv->lock);
/* Setup driver network interface. */
rc = wlanDrvIf_SetupNetif (drv);
if (rc)
{
kfree (drv);
return rc;
}
/* Create the events socket interface */
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
drv->wl_sock = netlink_kernel_create( NETLINK_USERSOCK, 0, NULL, THIS_MODULE );
#else
drv->wl_sock = netlink_kernel_create(&init_net, NETLINK_USERSOCK, 0, NULL, NULL, THIS_MODULE );
#endif
if (drv->wl_sock == NULL)
{
ti_dprintf (TIWLAN_LOG_ERROR, "netlink_kernel_create() failed !\n");
return -EINVAL;
}
/* Create all driver modules and link their handles */
drvMain_Create (drv,
&drv->tCommon.hDrvMain,
&drv->tCommon.hCmdHndlr,
&drv->tCommon.hContext,
&drv->tCommon.hTxDataQ,
&drv->tCommon.hTxMgmtQ,
&drv->tCommon.hTxCtrl,
&drv->tCommon.hTWD,
&drv->tCommon.hEvHandler,
&drv->tCommon.hCmdDispatch,
&drv->tCommon.hReport);
/*
* Initialize interrupts (or polling mode for debug):
*/
#ifdef PRIODIC_INTERRUPT
/* Debug mode: Polling (the timer is started by HwInit process) */
drv->hPollTimer = os_timerCreate ((TI_HANDLE)drv, wlanDrvIf_PollIrqHandler, (TI_HANDLE)drv);
#else
/* Normal mode: Interrupts (the default mode) */
rc = hPlatform_initInterrupt (drv, (void*)wlanDrvIf_HandleInterrupt);
if (rc)
{
ti_dprintf (TIWLAN_LOG_ERROR, "wlanDrvIf_Create(): Failed to register interrupt handler!\n");
return rc;
}
#endif /* PRIODIC_INTERRUPT */
#ifdef CONFIG_PM
/* register PM hooks in our SDIO driver */
sdioDrv_register_pm(wlanDrvIf_Resume, wlanDrvIf_Suspend);
#endif
return 0;
}
/* Return comma-delimited list of "interesting" options. */
static char *
cfgopts(void)
{
static const char *opts[] =
{
#if !OPT_SHELL
"noshell",
#endif
#if SYS_WINNT && defined(VILE_OLE)
"oleauto",
#endif
#if OPT_HYPERTEXT
"hypertext",
#endif
#if OPT_LOCALE
"locale",
#endif
#if OPT_ICONV_FUNCS
"iconv",
#endif
#if OPT_MULTIBYTE
"multibyte",
#endif
#if OPT_PERL
"perl",
#endif
#if DISP_ANSI
"ansi",
#endif
#if DISP_BORLAND
"borland",
#endif
#if DISP_CURSES
"curses",
#endif
#if DISP_NTCONS
"ntcons",
#endif
#if DISP_NTWIN
"ntwin",
#endif
#if DISP_TERMCAP
# if USE_TERMINFO
"terminfo",
# else
"termcap",
# endif
#endif
#if DISP_VIO
"os2vio",
#endif
#if DISP_VMSVT
"vmsvt",
#endif
#if DISP_X11
# if MOTIF_WIDGETS
"motif",
# endif
# if ATHENA_WIDGETS
"athena",
# ifdef HAVE_LIB_XAW
"xaw",
# endif
# ifdef HAVE_LIB_XAW3D
"xaw3d",
# endif
# ifdef HAVE_LIB_NEXTAW
"nextaw",
# endif
# endif
#endif
NULL /* End of list marker */
};
static TBUFF *optstring;
if (optstring == 0) {
const char **lclopt;
optstring = tb_init(&optstring, EOS);
for (lclopt = opts; *lclopt; lclopt++) {
if (tb_length(optstring))
optstring = tb_append(&optstring, ',');
optstring = tb_sappend(&optstring, *lclopt);
}
optstring = tb_append(&optstring, EOS);
}
return tb_values(optstring);
}
/* ARGSUSED */
static int
isearch(int f GCC_UNUSED, int n)
{
static TBUFF *pat_save = 0; /* Saved copy of the old pattern str */
int status; /* Search status */
register int cpos; /* character number in search string */
register int c; /* current input character */
MARK curpos, curp; /* Current point on entry */
int init_direction; /* The initial search direction */
/* Initialize starting conditions */
cmd_reexecute = -1; /* We're not re-executing (yet?) */
itb_init(&cmd_buff, EOS); /* Init the command buffer */
/* Save the old pattern string */
(void) tb_copy(&pat_save, searchpat);
curpos = DOT; /* Save the current pointer */
init_direction = n; /* Save the initial search direction */
ignorecase = window_b_val(curwp, MDIGNCASE);
scanboundry(FALSE, DOT, FORWARD); /* keep scanner() finite */
/* This is a good place to start a re-execution: */
start_over:
/* ask the user for the text of a pattern */
promptpattern("ISearch: ");
status = TRUE; /* Assume everything's cool */
/*
* Get the first character in the pattern. If we get an initial
* Control-S or Control-R, re-use the old search string and find the
* first occurrence
*/
c = kcod2key(get_char()); /* Get the first character */
if ((c == IS_FORWARD) ||
(c == IS_REVERSE)) { /* Reuse old search string? */
for (cpos = 0; cpos < (int) tb_length(searchpat); ++cpos)
echochar(tb_values(searchpat)[cpos]); /* and re-echo the string */
curp = DOT;
if (c == IS_REVERSE) { /* forward search? */
n = -1; /* No, search in reverse */
last_srch_direc = REVERSE;
backchar(TRUE, 1); /* Be defensive about EOB */
} else {
n = 1; /* Yes, search forward */
last_srch_direc = FORWARD;
forwchar(TRUE, 1);
}
unget_char();
status = scanmore(searchpat, n); /* Do the search */
if (status != TRUE)
DOT = curp;
c = kcod2key(get_char()); /* Get another character */
} else {
tb_init(&searchpat, EOS);
}
/* Top of the per character loop */
for_ever { /* ISearch per character loop */
/* Check for special characters, since they might change the
* search to be done
*/
if (ABORTED(c) || c == '\r') /* search aborted? */
return (TRUE); /* end the search */
if (isbackspace(c))
c = '\b';
if (c == quotec) /* quote character? */
c = kcod2key(get_char()); /* Get the next char */
switch (c) { /* dispatch on the input char */
case IS_REVERSE: /* If backward search */
case IS_FORWARD: /* If forward search */
curp = DOT;
if (c == IS_REVERSE) { /* forward search? */
last_srch_direc = REVERSE;
n = -1; /* No, search in reverse */
backchar(TRUE, 1); /* Be defensive about
* EOB */
} else {
n = 1; /* Yes, search forward */
last_srch_direc = FORWARD;
forwchar(TRUE, 1);
}
status = scanmore(searchpat, n); /* Do the search */
if (status != TRUE)
DOT = curp;
c = kcod2key(get_char()); /* Get the next char */
continue; /* Go continue with the search */
case '\t': /* Generically allowed */
case '\n': /* controlled characters */
break; /* Make sure we use it */
case '\b': /* or if a Rubout: */
if (itb_length(cmd_buff) <= 1) /* Anything to delete? */
return (TRUE); /* No, just exit */
unget_char();
DOT = curpos; /* Reset the pointer */
n = init_direction; /* Reset the search direction */
(void) tb_copy(&searchpat, pat_save);
/* Restore the old search str */
cmd_reexecute = 0; /* Start the whole mess over */
goto start_over; /* Let it take care of itself */
/* Presumably a quasi-normal character comes here */
default: /* All other chars */
if (!isPrint(c)) { /* Is it printable? */
/* Nope. */
unkeystroke(c); /* Re-eat the char */
return (TRUE); /* And return the last status */
}
} /* Switch */
/* I guess we got something to search for, so search for it */
tb_append(&searchpat, c); /* put the char in the buffer */
echochar(c); /* Echo the character */
if (!status) { /* If we lost last time */
kbd_alarm(); /* Feep again */
} else /* Otherwise, we must have won */
status = scanmore(searchpat, n); /* or find the next
* match */
c = kcod2key(get_char()); /* Get the next char */
} /* for_ever */
}
