username
stringlengths 1
36
| repo
stringlengths 1
82
| path
stringlengths 4
161
| function
stringlengths 0
328
| code
stringlengths 15
240k
| func_defs
stringlengths 0
313k
| llvm
stringclasses 1
value | hash
stringlengths 64
64
| memory
int64 15
240k
|
|---|---|---|---|---|---|---|---|---|
chriskmanx | qmole | QMOLEDEV/vnc-4_1_3-unixsrc/unix/xc/lib/GL/mesa/src/drv/mga/mgatris.c | mga_draw_quad |
static void __inline__ mga_draw_quad( mgaContextPtr mmesa,
mgaVertexPtr v0,
mgaVertexPtr v1,
mgaVertexPtr v2,
mgaVertexPtr v3 )
{
GLuint vertex_size = mmesa->vertex_size;
GLuint *vb = mgaAllocDmaLow( mmesa, 6 * 4 * vertex_size );
int j;
EMIT_VERT( j, vb, vertex_size, v0 );
EMIT_VERT( j, vb, vertex_size, v1 );
EMIT_VERT( j, vb, vertex_size, v3 );
EMIT_VERT( j, vb, vertex_size, v1 );
EMIT_VERT( j, vb, vertex_size, v2 );
EMIT_VERT( j, vb, vertex_size, v3 );
} |
static void init_rast_tab( void );
static void mgaRenderClippedPoly( GLcontext *ctx, const GLuint *elts, GLuint n );
static void mgaRenderClippedLine( GLcontext *ctx, GLuint ii, GLuint jj );
static void mgaChooseRenderState(GLcontext *ctx);
static void mgaRunPipeline( GLcontext *ctx );
void mgaRasterPrimitive( GLcontext *ctx, GLenum prim, GLuint hwprim );
static void mgaRenderPrimitive( GLcontext *ctx, GLenum prim );
static void mgaRenderFinish( GLcontext *ctx );
void mgaFallback( GLcontext *ctx, GLuint bit, GLboolean mode );
void mgaDDInitTriFuncs( GLcontext *ctx );
| 7e6b1dc08c7ef836c483ab960a9c8536da12027fc2e2e9498495320acb0994d2 | 533 |
|
alistairking | wandio | lib/ior-peek.c | peek_peek |
static int64_t peek_peek(io_t *io, void *buffer, int64_t len) {
int64_t ret = 0;
int res = 0;
if (DATA(io)->length - DATA(io)->offset < len) {
int64_t read_amount =
len - (DATA(io)->length - DATA(io)->offset);
read_amount +=
PEEK_SIZE - ((DATA(io)->length + read_amount) % PEEK_SIZE);
DATA(io)->buffer =
alignedrealloc(DATA(io)->buffer, DATA(io)->length,
DATA(io)->length + read_amount, &res);
if (DATA(io)->buffer == NULL) {
return res;
}
read_amount = wandio_read(DATA(io)->child,
DATA(io)->buffer + DATA(io)->length,
read_amount);
if (read_amount < 0) {
return read_amount;
}
DATA(io)->length += read_amount;
}
ret = MIN(len, DATA(io)->length - DATA(io)->offset);
memcpy(buffer, DATA(io)->buffer + DATA(io)->offset, ret);
return ret;
} |
DLLEXPORT io_t *peek_open(io_t *child);
static int64_t refill_buffer(io_t *io, int64_t len);
static int64_t peek_read(io_t *io, void *buffer, int64_t len);
static void *alignedrealloc(void *old, size_t oldsize, size_t size, int *res);
static int64_t peek_tell(io_t *io);
static int64_t peek_seek(io_t *io, int64_t offset, int whence);
static void peek_close(io_t *io);
| dadab1821fca6a485e217f69180fe96d6fe254ea601a2aaa32862ba28aceab52 | 1,264 |
|
garbear | v4l-utils | lib/libdvbv5/dvb-file.c | parse_delsys |
int parse_delsys(const char *name)
{
int i, cnt = 0;
for (i = 0; i < ARRAY_SIZE(delivery_system_name); i++)
if (delivery_system_name[i] &&
!strcasecmp(name, delivery_system_name[i]))
break;
if (i < ARRAY_SIZE(delivery_system_name))
return i;
for (i = 0; i < ARRAY_SIZE(alt_names); i++)
if (!strcasecmp(name, alt_names[i].name))
break;
if (i < ARRAY_SIZE(alt_names))
return alt_names[i].delsys;
fprintf(stderr, "ERROR: Delivery system %s is not known. Valid values are:\n",
name);
for (i = 0; i < ARRAY_SIZE(alt_names) - 1; i++) {
if (!(cnt % 5))
fprintf(stderr, "\n");
fprintf(stderr, "%-15s", alt_names[i].name);
cnt++;
}
for (i = 1; i < ARRAY_SIZE(delivery_system_name) - 1; i++) {
if (!(cnt % 5))
fprintf(stderr, "\n");
fprintf(stderr, "%-15s", delivery_system_name[i]);
cnt++;
}
if (cnt % 5)
fprintf(stderr, "\n");
fprintf(stderr, "\n");
return -1;
} |
static void adjust_delsys(struct dvb_entry *entry);
static uint32_t get_compat_format(uint32_t delivery_system);
static int fill_entry(struct dvb_entry *entry, char *key, char *value);
struct dvb_file *read_dvb_file(const char *fname);
int write_dvb_file(const char *fname, struct dvb_file *dvb_file);
static char *dvb_vchannel(struct dvb_v5_fe_parms *parms, struct dvb_table_nit *nit, uint16_t service_id);
static int sort_other_el_pid(const void *a_arg, const void *b_arg);
enum file_formats parse_format(const char *name);
| 496ebfdcb652d2352fd4d5f14e998c1e25e20a2cf9e89b666ae73e9388183a76 | 921 |
|
jmahler | EECE344-Digital_System_Design | empty_project/Libraries/STM32_TouchSensing_Driver/src/stm32_tsl_services.c | TSL_DeltaCalculation |
void TSL_DeltaCalculation(void)
{
Delta = (int16_t)(pKeyStruct->Channel.Reference - pKeyStruct->Channel.LastMeas);
} |
void TSL_SetStructPointer(void);
void TSL_SCKey_SetIdleState(void);
void TSL_SCKey_BackToIdleState(void);
void TSL_SCKey_SetPreDetectState(void);
void TSL_SCKey_SetDetectedState(void);
void TSL_SCKey_SetPostDetectState(void);
void TSL_SCKey_BackToDetectedState(void);
void TSL_SCKey_SetPreRecalibrationState(void);
void TSL_SCKey_SetCalibrationState(void);
void TSL_SCKey_SetErrorState(void);
void TSL_SCKey_SetDisabledState(void);
void TSL_SCKey_DxS(void);
void TSL_SCKey_DetectionTimeout(void);
void TSL_ECS(void);
uint16_t TSL_MCKey_InitAcq(uint8_t channel);
void TSL_MCKey_SetStructPointer(void);
void TSL_MCKey_DeltaCalculation(uint8_t ChIdx);
void TSL_MCKey_SetIdleState(void);
void TSL_MCKey_BackToIdleState(void);
void TSL_MCKey_SetPreDetectState(void);
void TSL_MCKey_SetDetectedState(void);
void TSL_MCKey_SetPostDetectState(void);
void TSL_MCKey_BackToDetectedState(void);
void TSL_MCKey_SetPreRecalibrationState(void);
void TSL_MCKey_SetCalibrationState(void);
void TSL_MCKey_SetErrorState(void);
void TSL_MCKey_SetDisabledState(void);
void TSL_MCKey_DxS(void);
void TSL_MCKey_DetectionTimeout(void);
| df8f52db3784c97363960c19c2a2f7b144760543eb261295cd17c0d2e82ee988 | 123 |
|
odit | rv042 | linux/kernel_2.6/linux/fs/openpromfs/inode.c | check_space |
static int __init check_space (u16 n)
{
unsigned long pages;
if ((1 << alloced) * PAGE_SIZE < (n + 2) * sizeof(openpromfs_node)) {
pages = __get_free_pages (GFP_KERNEL, alloced + 1);
if (!pages)
return -1;
if (nodes) {
memcpy ((char *)pages, (char *)nodes,
(1 << alloced) * PAGE_SIZE);
free_pages ((unsigned long)nodes, alloced);
}
alloced++;
nodes = (openpromfs_node *)pages;
}
return 0;
} |
int property_release (struct inode *inode, struct file *filp);
static int lookup_children(u16 n, const char * name, int len);
static struct dentry *openpromfs_lookup(struct inode * dir, struct dentry *dentry, struct nameidata *nd);
static int openpromfs_readdir(struct file * filp, void * dirent, filldir_t filldir);
static int openpromfs_unlink (struct inode *dir, struct dentry *dentry);
static u16 __init get_nodes (u16 parent, u32 node);
static void openprom_read_inode(struct inode * inode);
static int openprom_remount(struct super_block *sb, int *flags, char *data);
static int openprom_fill_super(struct super_block *s, void *data, int silent);
static int __init init_openprom_fs(void);
static void __exit exit_openprom_fs(void);
| ae08c29502a531e0a2063e35f62dde35f5fa2d2b62efbfbb5bc69cf580e9c6e4 | 422 |
|
sdudley | maximus | install/cvt202.c | CvtParse |
static void CvtParse(void)
{
char szTemp[MAX_CTL_LINE];
char szLine[MAX_CTL_LINE];
char szStrippedLine[MAX_CTL_LINE];
char szKeyword[MAX_CTL_LINE];
int iWord;
CVTPARM cp;
CVTSTATE csOld;
while (fgets(szLine, MAX_CTL_LINE, pfsCur->fpIn))
{
pfsCur->iLine++;
strcpy(szStrippedLine, szLine);
StripComment(szStrippedLine);
getword(szStrippedLine, szKeyword, szCtlDelim, 1);
memset(cp.szWords, 0, sizeof cp.szWords);
iWord = 0;
do
{
getword(szStrippedLine, szTemp, szCtlDelim, iWord+1);
if (*szTemp)
cp.szWords[iWord++] = sstrdup(szTemp);
else
cp.szWords[iWord++] = NULL;
}
while (*szTemp);
cp.szLine = szLine;
cp.szStrippedLine = szStrippedLine;
cp.szKeyword = szKeyword;
do_xlat(&cp, xtTop);
if (ptsTables[csState].pxt)
do_xlat(&cp, ptsTables[csState].pxt);
csOld = csState;
handle_keyword(&cp, ptsTables[csState].ptt);
for (iWord=0; cp.szWords[iWord]; iWord++)
free(cp.szWords[iWord]);
if (!ptsTables[csOld].fHaltOutput || csState != csOld)
fprintf(pfsCur->fpOut, "%s", szLine);
}
} |
CVTSTATE HandleEventEvent(CVTPARM *pcp);
CVTSTATE HandleSystemEnd(CVTPARM *pcp);
CVTSTATE HandleSystemFile(CVTPARM *pcp);
CVTSTATE HandleMatrixEnd(CVTPARM *pcp);
CVTSTATE HandleMenuHeader(CVTPARM *pcp);
CVTSTATE HandleHeaderFile(CVTPARM *pcp);
CVTSTATE HandleMenuDefault(CVTPARM *pcp);
CVTSTATE HandleMenuEnd(CVTPARM *pcp);
CVTSTATE HandleColourStrip(CVTPARM *pcp);
CVTSTATE HandleColourEnd(CVTPARM *pcp);
CVTSTATE HandleLanguageStrip(CVTPARM *pcp);
CVTSTATE HandleLanguageEnd(CVTPARM *pcp);
CVTSTATE HandleSessionUpload(CVTPARM *pcp);
CVTSTATE HandleSessionNo(CVTPARM *pcp);
CVTSTATE HandleSessionStrip(CVTPARM *pcp);
CVTSTATE HandleSessionFormat(CVTPARM *pcp);
CVTSTATE HandleSessionArea(CVTPARM *pcp);
CVTSTATE HandleSessionBegin(CVTPARM *pcp);
CVTSTATE HandleSessionEnd(CVTPARM *pcp);
CVTSTATE HandleAreaEnd(CVTPARM *pcp);
CVTSTATE HandleAreaMsgInfo(CVTPARM *pcp);
CVTSTATE HandleAreaMsgAccess(CVTPARM *pcp);
CVTSTATE HandleAreaType(CVTPARM *pcp);
CVTSTATE HandleAreaRenum(CVTPARM *pcp);
CVTSTATE HandleAreaMsgMenuName(CVTPARM *pcp);
CVTSTATE HandleAreaMsgName(CVTPARM *pcp);
CVTSTATE HandleAreaMatrix(CVTPARM *pcp);
CVTSTATE HandleAreaEcho(CVTPARM *pcp);
CVTSTATE HandleAreaConf(CVTPARM *pcp);
CVTSTATE HandleAreaLocal(CVTPARM *pcp);
CVTSTATE HandleAreaPublic(CVTPARM *pcp);
CVTSTATE HandleAreaPrivate(CVTPARM *pcp);
CVTSTATE HandleAreaAlias(CVTPARM *pcp);
CVTSTATE HandleAreaReadOnly(CVTPARM *pcp);
CVTSTATE HandleAreaAnonymous(CVTPARM *pcp);
CVTSTATE HandleAreaHigh(CVTPARM *pcp);
CVTSTATE HandleAreaNoNameKludge(CVTPARM *pcp);
CVTSTATE HandleAreaUseRealname(CVTPARM *pcp);
CVTSTATE HandleAreaOrigin(CVTPARM *pcp);
CVTSTATE HandleAreaMsgOverride(CVTPARM *pcp);
CVTSTATE HandleAreaMsgBarricade(CVTPARM *pcp);
CVTSTATE HandleAreaDownload(CVTPARM *pcp);
CVTSTATE HandleAreaUpload(CVTPARM *pcp);
CVTSTATE HandleAreaFileInfo(CVTPARM *pcp);
CVTSTATE HandleAreaFileAccess(CVTPARM *pcp);
CVTSTATE HandleAreaFileMenuName(CVTPARM *pcp);
CVTSTATE HandleAreaFileList(CVTPARM *pcp);
CVTSTATE HandleAreaFileOverride(CVTPARM *pcp);
CVTSTATE HandleAreaFileBarricade(CVTPARM *pcp);
CVTSTATE HandleAreaObsolete(CVTPARM *pcp);
CVTSTATE HandleAreaApp(CVTPARM *pcp);
CVTSTATE HandleAreaPrivRelated(CVTPARM *pcp);
CVTSTATE HandleTopSystem(CVTPARM *pcp);
CVTSTATE HandleTopMatrix(CVTPARM *pcp);
CVTSTATE HandleTopColour(CVTPARM *pcp);
CVTSTATE HandleTopLanguage(CVTPARM *pcp);
CVTSTATE HandleTopSession(CVTPARM *pcp);
CVTSTATE HandleTopMenu(CVTPARM *pcp);
CVTSTATE HandleTopArea(CVTPARM *pcp);
CVTSTATE HandleTopInclude(CVTPARM *pcp);
dword SqHash(byte *f);
static void set_status(char *pszName);
void Unknown(char *szWhat, char *szValue);
char *fchar(char *str,char *delim,int wordno);
static void CvtInit(void);
static void near set_extension(char *szName, char *szNewExt);
static int query_overwrite(char *szName);
static void fatal_file_err(char *szErrFmt, char *szName);
void StripComment(char *szLine);
static void do_xlat(CVTPARM *pcp, XLATTABLE *pxt);
static void handle_keyword(CVTPARM *pcp, TRANSLATOR *pttTable);
static void CvtFile(char *pszName);
void CvtConfig(char *szCfg, char *szPrm);
static void CvtTag(char *szTag);
static void CvtEvents(char *szFilespec);
void set_files_base(char *szBase);
MenuFunction(ValFile);
| 4e67c5b0e4f883a4ec32b3cc5a6b9ca431e1e14cb829e47a54928372359a2923 | 1,178 |
|
RDemers | org.rd.qtx.toolboxlib | QtxToolboxLib/DecNumber/decBasic.c | decFloatRemainder |
decFloat * decFloatRemainder(decFloat *result,
const decFloat *dfl, const decFloat *dfr,
decContext *set) {
return decDivide(result, dfl, dfr, set, REMAINDER);
} |
static decFloat * decCanonical(decFloat *result, const decFloat *df);
decFloat * decFloatCanonical(decFloat *result, const decFloat *df);
enum decClass decFloatClass(const decFloat *df);
const char *decFloatClassString(const decFloat *df);
decFloat * decFloatCopy(decFloat *result, const decFloat *dfl);
decFloat * decFloatCopyAbs(decFloat *result, const decFloat *dfl);
decFloat * decFloatCopyNegate(decFloat *result, const decFloat *dfl);
uInt decFloatDigits(const decFloat *df);
decFloat * decFloatFromInt32(decFloat *result, Int n);
decFloat * decFloatFromUInt32(decFloat *result, uInt u);
uInt decFloatIsCanonical(const decFloat *df);
uInt decFloatIsFinite(const decFloat *df);
uInt decFloatIsInfinite(const decFloat *df);
uInt decFloatIsInteger(const decFloat *df);
uInt decFloatIsLogical(const decFloat *df);
uInt decFloatIsNaN(const decFloat *df);
uInt decFloatIsNegative(const decFloat *df);
uInt decFloatIsNormal(const decFloat *df);
uInt decFloatIsPositive(const decFloat *df);
uInt decFloatIsSignaling(const decFloat *df);
uInt decFloatIsSignalling(const decFloat *df);
uInt decFloatIsSigned(const decFloat *df);
uInt decFloatIsSubnormal(const decFloat *df);
uInt decFloatIsZero(const decFloat *df);
uInt decFloatSameQuantum(const decFloat *dfl, const decFloat *dfr);
static decFloat *decInvalid(decFloat *result, decContext *set);
static decFloat *decInfinity(decFloat *result, const decFloat *df);
static Int decNumCompare(const decFloat *dfl, const decFloat *dfr, Flag tot);
| f4a4054fc6acb5b78c3c180ff427437e10a44ce732813730b2ad8b5ef92263c4 | 228 |
|
cranes-bill | cedit | plugins/spell/cedit-spell-checker.c | void
cedit_spell_checker_get_property |
static void
cedit_spell_checker_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
switch (prop_id)
{
case PROP_LANGUAGE:
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
} | 4a814fefe4f9256addcbc70ee8b8d21e382f499e295c2af2fb879e12cb4f7947 | 263 |
||
0xD34D | kernel_omap_bowser-common | arch/arm/mach-omap2/omap_hwmod.c | omap_hwmod_disable_wakeup | int omap_hwmod_disable_wakeup(struct omap_hwmod *oh)
{
unsigned long flags;
u32 v;
if (!oh->class->sysc ||
!(oh->class->sysc->sysc_flags & SYSC_HAS_ENAWAKEUP))
return -EINVAL;
spin_lock_irqsave(&oh->_lock, flags);
v = oh->_sysc_cache;
_disable_wakeup(oh, &v);
_write_sysconfig(v, oh);
omap_hwmod_disable_ioring_wakeup(oh);
spin_unlock_irqrestore(&oh->_lock, flags);
return 0;
}
| static int _update_sysc_cache(struct omap_hwmod *oh);
static void _write_sysconfig_raw(u32 v, struct omap_hwmod *oh);
static void _write_sysconfig(u32 v, struct omap_hwmod *oh);
static int _set_master_standbymode(struct omap_hwmod *oh, u8 standbymode,
u32 *v);
static int _set_slave_idlemode(struct omap_hwmod *oh, u8 idlemode, u32 *v);
static int _set_clockactivity(struct omap_hwmod *oh, u8 clockact, u32 *v);
static int _set_softreset(struct omap_hwmod *oh, u32 *v);
static int _set_module_autoidle(struct omap_hwmod *oh, u8 autoidle,
u32 *v);
static int _enable_wakeup(struct omap_hwmod *oh, u32 *v);
static int _disable_wakeup(struct omap_hwmod *oh, u32 *v);
static int _add_initiator_dep(struct omap_hwmod *oh, struct omap_hwmod *init_oh);
static int _del_initiator_dep(struct omap_hwmod *oh, struct omap_hwmod *init_oh);
static int _init_main_clk(struct omap_hwmod *oh);
static int _init_interface_clks(struct omap_hwmod *oh);
static int _init_opt_clks(struct omap_hwmod *oh);
static int _enable_clocks(struct omap_hwmod *oh);
static int _disable_clocks(struct omap_hwmod *oh);
static void _enable_optional_clocks(struct omap_hwmod *oh);
static void _disable_optional_clocks(struct omap_hwmod *oh);
static int __init _find_mpu_port_index(struct omap_hwmod *oh);
static void __iomem * __init _find_mpu_rt_base(struct omap_hwmod *oh, u8 index);
static void _enable_sysc(struct omap_hwmod *oh);
static void _idle_sysc(struct omap_hwmod *oh);
static void _shutdown_sysc(struct omap_hwmod *oh);
static struct omap_hwmod *_lookup(const char *name);
static int _init_clocks(struct omap_hwmod *oh, void *data);
static int _wait_target_ready(struct omap_hwmod *oh);
static u8 _lookup_hardreset(struct omap_hwmod *oh, const char *name,
struct omap_hwmod_rst_info *ohri);
static int _assert_hardreset(struct omap_hwmod *oh, const char *name);
static int _deassert_hardreset(struct omap_hwmod *oh, const char *name);
static int _read_hardreset(struct omap_hwmod *oh, const char *name);
static int _ocp_softreset(struct omap_hwmod *oh);
static int _reset(struct omap_hwmod *oh);
static int _enable(struct omap_hwmod *oh);
static int _idle(struct omap_hwmod *oh);
int omap_hwmod_set_ocp_autoidle(struct omap_hwmod *oh, u8 autoidle);
static int _shutdown(struct omap_hwmod *oh);
static int _setup(struct omap_hwmod *oh, void *data);
static int __init _register(struct omap_hwmod *oh);
u32 omap_hwmod_read(struct omap_hwmod *oh, u16 reg_offs);
void omap_hwmod_write(u32 v, struct omap_hwmod *oh, u16 reg_offs);
int omap_hwmod_softreset(struct omap_hwmod *oh);
int omap_hwmod_set_slave_idlemode(struct omap_hwmod *oh, u8 idlemode);
struct omap_hwmod *omap_hwmod_lookup(const char *name);
int omap_hwmod_for_each(int (*fn);
int __init omap_hwmod_register(struct omap_hwmod **ohs);
static int __init _populate_mpu_rt_base(struct omap_hwmod *oh, void *data);
int __init omap_hwmod_setup_one(const char *oh_name);
static int __init omap_hwmod_setup_all(void);
static int omap_hwmod_set_ioring_wakeup(struct omap_hwmod *oh, bool set_wake);
static bool omap_hwmod_get_ioring_wakeup_status(struct omap_hwmod *oh);
int omap_hwmod_enable(struct omap_hwmod *oh);
int omap_hwmod_idle(struct omap_hwmod *oh);
int omap_hwmod_shutdown(struct omap_hwmod *oh);
int omap_hwmod_enable_clocks(struct omap_hwmod *oh);
int omap_hwmod_disable_clocks(struct omap_hwmod *oh);
void omap_hwmod_ocp_barrier(struct omap_hwmod *oh);
int omap_hwmod_reset(struct omap_hwmod *oh);
int omap_hwmod_count_resources(struct omap_hwmod *oh);
int omap_hwmod_fill_resources(struct omap_hwmod *oh, struct resource *res);
struct powerdomain *omap_hwmod_get_pwrdm(struct omap_hwmod *oh);
void __iomem *omap_hwmod_get_mpu_rt_va(struct omap_hwmod *oh);
int omap_hwmod_add_initiator_dep(struct omap_hwmod *oh,
struct omap_hwmod *init_oh);
int omap_hwmod_del_initiator_dep(struct omap_hwmod *oh,
struct omap_hwmod *init_oh);
int omap_hwmod_enable_ioring_wakeup(struct omap_hwmod *oh);
int omap_hwmod_disable_ioring_wakeup(struct omap_hwmod *oh);
int omap_hwmod_enable_wakeup(struct omap_hwmod *oh);
int omap_hwmod_assert_hardreset(struct omap_hwmod *oh, const char *name);
int omap_hwmod_deassert_hardreset(struct omap_hwmod *oh, const char *name);
int omap_hwmod_read_hardreset(struct omap_hwmod *oh, const char *name);
int omap_hwmod_for_each_by_class(const char *classname,
int (*fn);
int omap_hwmod_set_postsetup_state(struct omap_hwmod *oh, u8 state);
int omap_hwmod_get_context_loss_count(struct omap_hwmod *oh);
int omap_hwmod_no_setup_reset(struct omap_hwmod *oh);
int omap_hwmod_pad_get_wakeup_status(struct omap_hwmod *oh);
bool omap_hwmod_pad_is_ioring_enabled(struct omap_hwmod *oh);
struct device *omap_hwmod_name_get_dev(const char *oh_name);
| b60090da6f01cd5737e5df62cb3a7a888668a0302d37f26bd6ccb67fefa0681a | 398 |
|
SAOImageDS9 | SAOImageDS9 | ast/src/selectormap.c | Delete |
static void Delete( AstObject *obj, int *status ) {
AstSelectorMap *this;
int i;
this = (AstSelectorMap *) obj;
for( i = 0; i < this->nreg; i++ ) {
this->reg[ i ] = astAnnul( this->reg[ i ] );
}
this->reg = astFree( this->reg );
this->nreg = 0;
} |
static int Equal( AstObject *this_object, AstObject *that_object, int *status );
static size_t GetObjSize( AstObject *this_object, int *status );
void astInitSelectorMapVtab_( AstSelectorMapVtab *vtab, const char *name, int *status );
static void Copy( const AstObject *objin, AstObject *objout, int *status );
static void Dump( AstObject *this_object, AstChannel *channel, int *status );
astMAKE_CHECK(SelectorMap);
| 65e3b02b3d03e60b5fe3151740a9d7565960753561809e2ba176f5c0b9d7cf76 | 303 |
|
ntfreak | openocd | src/target/riscv/riscv-013.c | dmi_read |
static int dmi_read(struct target *target, uint32_t *value, uint32_t address)
{
return dmi_op(target, value, NULL, DMI_OP_READ, address, 0, false, true);
} |
static riscv013_info_t *get_info(const struct target *target);
dm013_info_t *get_dm(struct target *target);
static uint32_t set_hartsel(uint32_t initial, uint32_t index);
static void decode_dmi(char *text, unsigned address, unsigned data);
static void dump_field(int idle, const struct scan_field *field);
static void select_dmi(struct target *target);
static uint32_t dtmcontrol_scan(struct target *target, uint32_t out);
static void increase_dmi_busy_delay(struct target *target);
static int dmi_read_exec(struct target *target, uint32_t *value, uint32_t address);
static int dmi_write(struct target *target, uint32_t address, uint32_t value);
static void increase_ac_busy_delay(struct target *target);
uint32_t abstract_register_size(unsigned width);
static int wait_for_idle(struct target *target, uint32_t *abstractcs);
static int execute_abstract_command(struct target *target, uint32_t command);
static uint32_t abstract_memory_size(unsigned width);
static int examine_progbuf(struct target *target);
static int is_fpu_reg(uint32_t gdb_regno);
static int is_vector_reg(uint32_t gdb_regno);
static unsigned register_size(struct target *target, unsigned number);
static bool has_sufficient_progbuf(struct target *target, unsigned size);
static int register_read(struct target *target, uint64_t *value, uint32_t number);
static int register_read_direct(struct target *target, uint64_t *value, uint32_t number);
int wait_for_authbusy(struct target *target, uint32_t *dmstatus);
static void deinit_target(struct target *target);
static int set_haltgroup(struct target *target, bool *supported);
static int discover_vlenb(struct target *target, int hartid);
static int examine(struct target *target);
int riscv013_authdata_read(struct target *target, uint32_t *value);
int riscv013_authdata_write(struct target *target, uint32_t value);
static int riscv013_hart_count(struct target *target);
static unsigned riscv013_data_bits(struct target *target);
static int assert_reset(struct target *target);
static int deassert_reset(struct target *target);
static int execute_fence(struct target *target);
static uint32_t sb_sbaccess(unsigned size_bytes);
static target_addr_t sb_read_address(struct target *target);
static int sb_write_address(struct target *target, target_addr_t address);
static int read_sbcs_nonbusy(struct target *target, uint32_t *sbcs);
static int modify_privilege(struct target *target, uint64_t *mstatus, uint64_t *mstatus_old);
static int batch_run(const struct target *target, struct riscv_batch *batch);
static int arch_state(struct target *target);
static int riscv013_set_register(struct target *target, int hid, int rid, uint64_t value);
static int riscv013_select_current_hart(struct target *target);
static int select_prepped_harts(struct target *target, bool *use_hasel);
static int riscv013_halt_prep(struct target *target);
static int riscv013_halt_go(struct target *target);
static int riscv013_resume_go(struct target *target);
static int riscv013_step_current_hart(struct target *target);
static int riscv013_resume_prep(struct target *target);
static int riscv013_on_step(struct target *target);
static int riscv013_on_halt(struct target *target);
static bool riscv013_is_halted(struct target *target);
static enum riscv_halt_reason riscv013_halt_reason(struct target *target);
int riscv013_write_debug_buffer(struct target *target, unsigned index, riscv_insn_t data);
riscv_insn_t riscv013_read_debug_buffer(struct target *target, unsigned index);
int riscv013_execute_debug_buffer(struct target *target);
void riscv013_fill_dmi_write_u64(struct target *target, char *buf, int a, uint64_t d);
void riscv013_fill_dmi_read_u64(struct target *target, char *buf, int a);
void riscv013_fill_dmi_nop_u64(struct target *target, char *buf);
static int get_max_sbaccess(struct target *target);
static uint32_t get_num_sbdata_regs(struct target *target);
int riscv013_dmi_write_u64_bits(struct target *target);
static int maybe_execute_fence_i(struct target *target);
static int riscv013_on_step_or_resume(struct target *target, bool step);
void riscv013_clear_abstract_error(struct target *target);
int riscv013_test_compliance(struct target *target);
| a27314d950d52cef581f6a6b4a34ebb344f339d18eb4c40837ca405dbcf8bf4b | 157 |
|
osvx | pmacct | src/sql_handlers.c | count_dst_host_country_handler |
void count_dst_host_country_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where)
{
snprintf(*ptr_where, SPACELEFT(where_clause), where[num].string, GeoIP_code_by_id(cache_elem->primitives.dst_ip_country));
snprintf(*ptr_values, SPACELEFT(values_clause), values[num].string, GeoIP_code_by_id(cache_elem->primitives.dst_ip_country));
*ptr_where += strlen(*ptr_where);
*ptr_values += strlen(*ptr_values);
} |
void count_src_mac_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void count_dst_mac_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void count_vlan_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void count_cos_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void count_etype_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void count_src_host_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void count_src_as_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void count_dst_host_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void count_dst_as_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void count_in_iface_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void count_out_iface_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void count_src_nmask_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void count_dst_nmask_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void count_src_host_country_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void count_sampling_rate_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void count_pkt_len_distrib_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void count_post_nat_src_ip_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void count_post_nat_dst_ip_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void count_post_nat_src_port_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void count_post_nat_dst_port_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void count_nat_event_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void PG_copy_count_timestamp_start_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void count_timestamp_start_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void count_timestamp_start_residual_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void PG_copy_count_timestamp_end_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void count_timestamp_end_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void count_timestamp_end_residual_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void count_std_comm_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void count_ext_comm_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void count_as_path_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void count_src_std_comm_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void count_src_ext_comm_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void count_src_as_path_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void count_local_pref_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void count_src_local_pref_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void count_med_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void count_src_med_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void count_mpls_vpn_rd_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void count_peer_src_as_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void count_peer_dst_as_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void count_peer_src_ip_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void count_peer_dst_ip_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void count_src_port_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void count_dst_port_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void count_tcpflags_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void count_ip_tos_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void MY_count_ip_proto_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void PG_count_ip_proto_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void count_copy_timestamp_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void count_timestamp_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void count_id_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void count_id2_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void count_class_id_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void count_counters_setclause_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_set, char **ptr_none);
void count_flows_setclause_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_set, char **ptr_none);
void count_tcpflags_setclause_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_set, char **ptr_none);
void count_noop_setclause_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_set, char **ptr_none);
void count_noop_setclause_event_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_set, char **ptr_none);
void fake_mac_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void fake_host_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void fake_as_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void fake_comms_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
void fake_as_path_handler(const struct db_cache *cache_elem, const struct insert_data *idata, int num, char **ptr_values, char **ptr_where);
| ffc048aae33cee4d6345299ad92cf6ea7b8e813f3c798f1aeb97c9a84934a252 | 481 |
|
MattDevo | coreboot | src/lib/ramtest.c | write_phys |
static void write_phys(unsigned long addr, u32 value)
{
#if IS_ENABLED(CONFIG_SSE2)
asm volatile(
"movnti %1, (%0)"
:
: "r" (addr), "r" (value)
#ifndef __GNUC__
:
#endif
);
#else
volatile unsigned long *ptr;
ptr = (void *)addr;
*ptr = value;
#endif
} |
static u32 read_phys(unsigned long addr);
static void phys_memory_barrier(void);
static int ram_bitset_nodie(unsigned long start);
void ram_check(unsigned long start, unsigned long stop);
int ram_check_nodie(unsigned long start, unsigned long stop);
int ram_check_noprint_nodie(unsigned long start, unsigned long stop);
static void __quick_ram_check(uintptr_t dst);
void quick_ram_check(void);
| 9274c8ad3d6e8441fb8ffcfe3a88c40e2452b5ff220c650461faf754bd86c1bc | 279 |
|
emacs-mirror | emacs | src/keyboard.c | AVOID
user_error |
static AVOID
user_error (const char *msg)
{
xsignal1 (Quser_error, build_string (msg));
} | FOR_EACH_TAIL_SAFE (event_desc);
void init_raw_keybuf_count (void);
| fd4814738aed49f5b526ff201f355606604527540ab92b8391da090ad53dd156 | 92 |
|
Angor00 | linux-aura-hd-android-2.6.35.3 | drivers/mxc/pmic/mc13892/pmic_adc.c | pmic_adc_convert_8x |
PMIC_STATUS pmic_adc_convert_8x(t_channel channel, unsigned short *result)
{
t_adc_param adc_param;
int i;
PMIC_STATUS ret;
if (suspend_flag == 1)
return -EBUSY;
channel = channel_num[channel];
if (channel == -1) {
pr_debug("Wrong channel ID\n");
return PMIC_PARAMETER_ERROR;
}
mc13892_adc_init_param(&adc_param);
pr_debug("pmic_adc_convert_8x\n");
adc_param.read_ts = false;
adc_param.single_channel = true;
adc_param.read_mode = mc13892_set_read_mode(channel);
if (channel <= 7) {
adc_param.channel_0 = channel;
adc_param.channel_1 = channel;
} else
return PMIC_PARAMETER_ERROR;
ret = mc13892_adc_convert(&adc_param);
for (i = 0; i <= 7; i++)
result[i] = adc_param.value[i];
return ret;
} |
int is_pmic_adc_ready();
static int pmic_adc_suspend(struct platform_device *pdev, pm_message_t state);
static int pmic_adc_resume(struct platform_device *pdev);
static void callback_tsi(void *unused);
static void callback_adcdone(void *unused);
static void callback_adcbisdone(void *unused);
static int pmic_adc_filter(t_touch_screen *ts_curr);
int pmic_adc_init(void);
PMIC_STATUS pmic_adc_deinit(void);
int mc13892_adc_init_param(t_adc_param *adc_param);
PMIC_STATUS mc13892_adc_convert(t_adc_param *adc_param);
t_reading_mode mc13892_set_read_mode(t_channel channel);
PMIC_STATUS pmic_adc_convert(t_channel channel, unsigned short *result);
PMIC_STATUS pmic_adc_set_touch_mode(t_touch_mode touch_mode);
PMIC_STATUS pmic_adc_get_touch_mode(t_touch_mode *touch_mode);
PMIC_STATUS pmic_adc_get_touch_sample(t_touch_screen *touch_sample, int wait);
PMIC_STATUS mc13892_adc_read_ts(t_touch_screen *ts_value, int wait_tsi);
int mc13892_adc_request(bool read_ts);
int mc13892_adc_release(int adc_index);
static int cmd(unsigned int index, int value);
static int pmic_adc_module_probe(struct platform_device *pdev);
static int pmic_adc_module_remove(struct platform_device *pdev);
static int __init pmic_adc_module_init(void);
static void __exit pmic_adc_module_exit(void);
| 52c7e99c643d98a68e9d7c2a380d8735afd0bb755baf47b0dc8cc45810012e4c | 727 |
|
ArcticVanguard | navalcombat | navalcombat.c |
int
genrand |
int
genrand(int a) {
int r = rand();
return r % a;
} |
float calcforce(float m, float a);
void main();
| 4756f4c4307480b1f10b630917b716946396c53fcb3e1f6df0be9c47d1f3d90a | 55 |
|
Sidnioulz | Planner | libplanner/mrp-task.c | *
mrp_task_set_unit_ivals |
GList *
mrp_task_set_unit_ivals (MrpTask *task, GList *ivals)
{
g_return_val_if_fail (MRP_IS_TASK (task), 0);
if (task->priv->unit_ivals) {
g_list_foreach (task->priv->unit_ivals, (GFunc) g_free, NULL);
g_list_free (task->priv->unit_ivals);
task->priv->unit_ivals = NULL;
}
task->priv->unit_ivals = ivals;
return task->priv->unit_ivals;
} |
void mrp_task_set_name (MrpTask *task, const gchar *name);
gint mrp_task_get_nres (MrpTask *task);
| 6bc7a3335a6b4e41df9e2bd4ba157bb9ef8b8ee0ea0ccd3b5c0ee9795af04ab7 | 352 |
|
muggenhor | GNUnet | src/gns/plugin_block_gns.c | *
libgnunet_plugin_block_gns_done |
void *
libgnunet_plugin_block_gns_done (void *cls)
{
struct GNUNET_TRANSPORT_PluginFunctions *api = cls;
GNUNET_free (api);
return NULL;
} | 2eaa960d46cb5b0d18401692cfa1f1d62d8a8efaa50a9ecdd6c76736261542f0 | 146 |
||
hyller | CodeLibrary | ZigBee/Z-Stack 3.0.0/Components/stack/zcl/zcl_green_power.c | gp_CreateNotificationMsgList |
void gp_CreateNotificationMsgList( gpNotificationMsg_t **pHead )
{
if ( *pHead == NULL )
{
*pHead = ( gpNotificationMsg_t* )osal_mem_alloc( sizeof( gpNotificationMsg_t ) );
if ( *pHead != NULL )
{
(*pHead)->pNext = NULL;
}
}
return;
} |
ZStatus_t zclGp_RegisterCmdCallbacks( uint8 endpoint, zclGp_AppCallbacks_t *callbacks );
static zclGp_AppCallbacks_t *zclGp_FindCallbacks( uint8 endpoint );
static ZStatus_t zclGp_HdlIncoming( zclIncoming_t *pInMsg );
static ZStatus_t zclGp_HdlInSpecificCommands( zclIncoming_t *pInMsg );
ZStatus_t zclGp_SendGpNotificationCommand( gpNotificationCmd_t *pCmd );
ZStatus_t zclGp_SendGpCommissioningNotificationCommand( gpCommissioningNotificationCmd_t *pCmd );
static uint8 gp_addPairedSinksToMsgQueue( uint8 appId, uint8 *pId, gpCmdPayloadMsg_t* pMsg );
void gp_CreateCmdPayloadMsgList( gpCmdPayloadMsg_t **pHead );
gpNotificationMsg_t* gp_AddNotificationMsgNode( gpNotificationMsg_t **pHead, gpCmdPayloadMsg_t *pMsg );
gpCmdPayloadMsg_t* gp_AddCmdPayloadMsgNode( gpCmdPayloadMsg_t **pHead, uint8* pBuf, uint8 len );
gpNotificationMsg_t* gp_GetHeadNotificationMsg(void);
gpNotificationMsg_t** gp_GetPHeadNotification(void);
gpCmdPayloadMsg_t* gp_GetHeadCmdPayloadMsg(void);
gpCmdPayloadMsg_t** gp_GetPHeadCmdPayload(void);
void gp_NotificationMsgClean( gpNotificationMsg_t **pHead );
void gp_CmdPayloadMsgClean( gpCmdPayloadMsg_t **pHead );
| 2c24d58efbfdb8c47f6250c1de31c3950019322378571a3c6a01b1e2f46f12c0 | 288 |
|
371816210 | kk44 | drivers/usb/dwc_otg/usbdev_rk3026.c | usbdev_init_devices |
static int __init usbdev_init_devices(void)
{
int ret = 0;
#ifdef CONFIG_USB20_OTG
ret = platform_device_register(&device_usb20_otg);
if(ret < 0){
printk("%s: platform_device_register(usb20_otg) failed\n", __func__);
return ret;
}
#endif
#ifdef CONFIG_USB20_HOST
ret = platform_device_register(&device_usb20_host);
#endif
return ret;
} |
int dwc_otg_check_dpdm(void);
void usb20otg_hw_init(void);
void usb20otg_phy_suspend(void* pdata, int suspend);
void usb20otg_soft_reset(void);
void usb20otg_clock_init(void* pdata);
void usb20otg_clock_enable(void* pdata, int enable);
int usb20otg_get_status(int id);
void dwc_otg_uart_mode(void* pdata, int enter_usb_uart_mode);
void usb20otg_power_enable(int enable);
void usb20host_hw_init(void);
void usb20host_phy_suspend(void* pdata, int suspend);
void usb20host_soft_reset(void);
void usb20host_clock_init(void* pdata);
void usb20host_clock_enable(void* pdata, int enable);
int usb20host_get_status(int id);
void usb20host_power_enable(int enable);
inline void do_wakeup(void);
static irqreturn_t bvalid_irq_handler(int irq, void *dev_id);
static irqreturn_t id_irq_handler(int irq, void *dev_id);
static irqreturn_t line_irq_handler(int irq, void *dev_id);
static int __init otg_irq_detect_init(void);
| 7efcd89401016d47fadfc2b862de1be382ac9efe436a73a5cef46b4e3e142ecd | 402 |
|
ORNL-TechInt | lustre | lustre/utils/loadgen.c | loadgen_start_echosrv |
static int loadgen_start_echosrv(int argc, char **argv)
{
char *args[5];
int rc;
pthread_mutex_lock(&m_config);
args[0] = cmdname;
args[1] = "obdecho";
args[2] = args[3] = ecsname;
rc = jt_lcfg_attach(4, args);
if (rc) {
fprintf(stderr, "%s: can't attach echo server (%d)\n",
cmdname, rc);
goto clean;
}
my_ecs = 1;
rc = jt_lcfg_setup(1, args);
if (rc) {
fprintf(stderr, "%s: can't setup echo server (%d)\n",
cmdname, rc);
goto clean;
}
args[1] = "ost";
args[2] = args[3] = "OSS";
rc = jt_lcfg_attach(4, args);
if (rc == EEXIST) {
printf("OSS already set up, no problem.\n");
pthread_mutex_unlock(&m_config);
return 0;
}
if (rc) {
fprintf(stderr, "%s: can't attach OSS (%d)\n",
cmdname, rc);
goto clean;
}
my_oss = 1;
rc = jt_lcfg_setup(1, args);
if (rc) {
fprintf(stderr, "%s: can't setup OSS (%d)\n",
cmdname, rc);
goto clean;
}
pthread_mutex_unlock(&m_config);
return rc;
clean:
pthread_mutex_unlock(&m_config);
loadgen_stop_echosrv(9, argv);
return rc;
} |
static int jt_quit(int argc, char **argv);
static int loadgen_usage(int argc, char **argv);
static struct kid_t *push_kid(int tnum);
static void trigger(int command, int threads, int repeat, int delay);
static __inline__ void stop_all(int unused);
static void kill_kids(void);
static void sig_master(int unused);
static int wait_for_threads();
static int write_proc(char *proc_path, char *value);
static int read_proc(char *proc_path, unsigned long long *value);
static int grant_estimate(int thread);
static int cleanup(char *obdname, int quiet);
static int echocli_setup(char *oname, char *ename, int *dev);
static int obj_ioctl(int cmd, struct obd_ioctl_data *data, int unpack);
static int obj_create(struct kid_t *kid);
static int obj_delete(struct kid_t *kid);
static int obj_write(struct kid_t *kid);
static int do_work(struct kid_t *kid);
static void report_perf();
static void *run_one_child(void *threadvp);
static int loadgen_start_clients(int argc, char **argv);
static int loadgen_target(int argc, char **argv);
static int loadgen_verbose(int argc, char **argv);
static int loadgen_write(int argc, char **argv);
static int loadgen_stop_echosrv(int argc, char **argv);
static int loadgen_wait(int argc, char **argv);
static int loadgen_init(int argc, char **argv);
static int loadgen_exit();
static int loadgen_main(int argc, char **argv);
int main (int argc, char **argv);
| 4816a1fbe94f9168fb55947bad703d633bb4e2e0721fe9d731822b40e58adffa | 1,558 |
|
alan-mushi | connman-json-client | engine.c | react_to_sig_technology |
static void react_to_sig_technology(struct json_object *interface,
struct json_object *path, struct json_object *data,
const char *sig_name)
{
char tech_dbus_name[256];
struct json_object *tech, *tech_dict, *val;
const char *key;
snprintf(tech_dbus_name, 256, "/net/connman/technology/%s", json_object_get_string(path));
tech_dbus_name[255] = '\0';
tech = search_technology_or_service(technologies, tech_dbus_name);
if (!tech)
return;
key = json_object_get_string(json_object_array_get_idx(data, 0));
val = json_object_array_get_idx(data, 1);
tech_dict = json_object_array_get_idx(tech, 1);
if (tech_dict && json_object_object_get_ex(tech_dict, key, NULL)) {
json_object_object_del(tech_dict, key);
json_object_object_add(tech_dict, key, json_object_get(val));
}
} |
static void engine_commands_cb(struct json_object *data, json_bool is_error);
static void engine_agent_cb(struct json_object *data, struct agent_data *request);
static void engine_agent_error_cb(struct json_object *data);
static int agent_response(struct json_object *data);
static int agent_error_response(struct json_object *data);
static struct json_object* get_technology(const char *dbus_name);
static bool has_technology(const char *dbus_name);
static struct json_object* get_service(const char *dbus_name);
static bool has_service(const char *dbus_name);
static int init_get_state(void);
static int init_get_technologies(void);
static int init_get_services(void);
static int get_state(struct json_object *jobj);
static int get_services(struct json_object *jobj);
static int get_technologies(struct json_object *jobj);
static int get_home_page(struct json_object *jobj);
static int get_services_from_tech(struct json_object *jobj);
static int connect_to_service(struct json_object *jobj);
static int disconnect_technology(struct json_object *jobj);
static int scan_technology(struct json_object *jobj);
static int config_service(struct json_object *jobj);
static int toggle_power_technology(struct json_object *jobj);
static int toggle_offline_mode(struct json_object *jobj);
static int remove_service(struct json_object *jobj);
static int engine_get_service(struct json_object *jobj);
static void init_cmd_table(void);
static int command_exist(const char *cmd);
static bool command_data_is_clean(struct json_object *jobj, int cmd_pos);
static void engine_commands_sig(struct json_object *jobj);
int engine_query(struct json_object *jobj);
int engine_init(void);
void engine_terminate(void);
| 5bb1c09b02bb22932889c7677ac7a051c7c2a7eff4c5ddf1e543b3063cd7eb79 | 793 |
|
vipshop | redis-migrate-tool | src/rmt_redis.c | *sendReplSyncCommand |
static char *sendReplSyncCommand(int flags, redis_node *srnode, ...) {
tcp_context *tc = srnode->tc;
redis_repl *rr = srnode->rr;
thread_data *rdata = srnode->read_data;
if (flags & SYNC_CMD_WRITE) {
char *arg;
va_list ap;
sds cmd = sdsempty();
va_start(ap,srnode);
while(1) {
arg = va_arg(ap, char*);
if (arg == NULL) break;
if (sdslen(cmd) != 0) cmd = sdscatlen(cmd," ",1);
cmd = sdscat(cmd,arg);
}
cmd = sdscatlen(cmd,"\r\n",2);
if (rmt_sync_write(tc->sd,cmd,sdslen(cmd),1000)
== -1)
{
sdsfree(cmd);
return sdscatprintf(sdsempty(),"-Writing to master: %s",
strerror(errno));
}
sdsfree(cmd);
va_end(ap);
}
if (flags & SYNC_CMD_READ) {
ssize_t nread;
char buf[256];
nread = rmt_sync_readline(tc->sd,buf,sizeof(buf),1000);
if (nread == -1) {
return sdscatprintf(sdsempty(),"-Reading from master: %s",
strerror(errno));
}
rr->repl_lastio = rdata->unixtime;
return sdsnew(buf);
}
return NULL;
} |
int redis_replication_init(redis_repl *rr);
void redis_replication_deinit(redis_repl *rr);
int redis_node_init(redis_node *rnode, const char *addr, redis_group *rgroup);
void redis_node_deinit(redis_node *rnode);
void redis_group_deinit(redis_group *rgroup);
int redis_rdb_init(redis_rdb *rdb, const char *addr, int type);
void redis_rdb_deinit(redis_rdb *rdb);
char *rmt_send_sync_cmd_read_line(int fd, ...);
static int rmt_redis_send_cmd(int fd, ...);
static int redisRplicationReset(redis_node *srnode);
static int rmtSlaveIsInHandshakeState(redis_node *srnode);
static int rmtTryPartialResynchronization(redis_node *srnode, int read_reply);
static void rmtRedisSlaveReadQueryFromMaster(aeEventLoop *el, int fd, void *privdata, int mask);
static void rmtRedisRdbDataPost(redis_node *srnode);
static int rmtRedisSlavePrepareOnline(redis_node *srnode);
void rmtRedisSlaveOffline(redis_node *srnode);
static int rmtRedisSlaveAgainOnline(redis_node *srnode);
void rmtReceiveRdbAbort(redis_node *srnode);
static void rmtReceiveRdb(aeEventLoop *el, int fd, void *privdata, int mask);
static void rmtSyncRedisMaster(aeEventLoop *el, int fd, void *privdata, int mask);
int rmtConnectRedisMaster(redis_node *srnode);
void redisSlaveReplCorn(redis_node *srnode);
int redis_response_check(redis_node *rnode, struct msg *r);
static int redis_copy_bulk(struct msg *dst, struct msg *src);
void redis_pre_coalesce(struct msg *r);
static int redis_append_key(struct msg *r, uint8_t *key, uint32_t keylen);
int redis_append_bulk(struct msg *r, uint8_t *str, uint32_t str_len);
static void redis_erase_one_head_bulk(struct msg *msg);
int redis_reply(struct msg *r);
static void redis_post_coalesce_mset(struct msg *request);
static void redis_post_coalesce_del(struct msg *request);
static void redis_post_coalesce_mget(struct msg *request);
void redis_post_coalesce(struct msg *r);
sds redis_msg_response_get_bulk_string(struct msg *msg);
int redis_msg_append_multi_bulk_len_full(struct msg *msg, uint32_t integer);
int redis_msg_append_bulk_full(struct msg *msg, const char *str, uint32_t len);
int redis_msg_append_command_full(struct msg * msg, ...);
int redis_msg_append_command_full_safe(struct msg * msg, struct array *args);
struct array *redis_value_create(uint32_t nelem);
void redis_value_destroy(struct array *value);
static int redis_rdb_file_read(redis_rdb *rdb, void *buf, size_t len);
static uint32_t redis_rdb_file_load_len(redis_rdb *rdb, int *isencoded);
static long long redis_rdb_file_load_int(redis_rdb *rdb, int enctype);
static sds redis_rdb_file_load_double_str(redis_rdb *rdb);
static sds redis_rdb_file_load_lzf_str(redis_rdb *rdb);
static sds redis_rdb_file_load_str(redis_rdb *rdb);
static struct array *redis_rdb_file_load_value(redis_rdb *rdb, int rdbtype);
static int redis_object_type_get_by_rdbtype(int dbtype);
void redis_delete_rdb_file(redis_rdb *rdb, int always);
int redis_parse_rdb_file(redis_node *srnode, int mbuf_count_one_time);
int redis_parse_rdb_time(aeEventLoop *el, long long id, void *privdata);
void redis_parse_rdb(aeEventLoop *el, int fd, void *privdata, int mask);
int redis_load_aof_file(redis_node *srnode, char *aof_file);
static unsigned int clusterKeyHashSlot(char *key, int keylen);
static void cluster_nodes_swap_tc(dict *nodes_f, dict *nodes_t);
static ssize_t rmt_redis_sync_read_string(int fd, char *ptr, long long timeout);
static int cluster_update_route(redis_group *rgroup);
int redis_cluster_init_from_addrs(redis_group *rgroup, const char *addrs);
int redis_cluster_init_from_conf(redis_group *rgroup, conf_pool *cp);
int redis_rdb_file_init_from_conf(redis_group *rgroup, conf_pool *cp);
int redis_aof_file_init_from_conf(redis_group *rgroup, conf_pool *cp);
| 2d4b52dc5392f4aaec4a4dffcee12f4ed95d94ca7aebf645fd8573655f0922ba | 1,245 |
|
thenickreynolds | pebblesnake | snake.c | pbl_main |
void pbl_main(void *params) {
PebbleAppHandlers handlers = {
.init_handler = &handle_init,
.timer_handler = &handle_timer
};
app_event_loop(params, &handlers);
} |
void draw_rect(GContext *ctx, GPoint topLeft, unsigned short width, unsigned short height);
GPoint get_point_from_position(Position *pos);
void draw_fruit(GContext *ctx);
void draw_snake(GContext *ctx);
void draw_border(GContext *ctx);
void draw(GContext *ctx);
unsigned short random();
void gen_fruit_position();
void copy_position(unsigned short to, unsigned short from);
unsigned short is_same_position(Position *a, Position *b);
unsigned short is_out_of_bounds(Position *pos);
unsigned short is_game_over();
void tick_game();
void init_snake();
void schedule_timer(AppContextRef ctx);
void reset_game();
void init_game(AppContextRef ctx);
void update_snake_callback(Layer *me, GContext *ctx);
void handle_timer(AppContextRef ctx, AppTimerHandle handle, uint32_t cookie);
void change_snake_direction(short direction);
void handle_up_button_press(ClickRecognizerRef recognizer, Window *window);
void handle_down_button_press(ClickRecognizerRef recognizer, Window *window);
void handle_select_button_press(ClickRecognizerRef recognizer, Window *window);
void click_config_provider(ClickConfig **config, Window *window);
void handle_init(AppContextRef ctx);
| 0f5a1a2d32f213b77bae2d4fbfa51698361322de3a4ac49a8134a3360738971e | 176 |
|
Rover-Yu | ali_kernel | drivers/ata/ahci.c | *ahci_port_base |
static inline void __iomem *ahci_port_base(struct ata_port *ap)
{
return __ahci_port_base(ap->host, ap->port_no);
} |
static void ahci_enable_ahci(void __iomem *mmio);
static void ahci_restore_initial_config(struct ata_host *host);
static unsigned ahci_scr_offset(struct ata_port *ap, unsigned int sc_reg);
static int ahci_scr_read(struct ata_link *link, unsigned int sc_reg, u32 *val);
static int ahci_scr_write(struct ata_link *link, unsigned int sc_reg, u32 val);
static int ahci_stop_engine(struct ata_port *ap);
static void ahci_start_engine(struct ata_port *ap);
static void ahci_start_fis_rx(struct ata_port *ap);
static int ahci_stop_fis_rx(struct ata_port *ap);
static void ahci_power_up(struct ata_port *ap);
static void ahci_disable_alpm(struct ata_port *ap);
static void ahci_power_down(struct ata_port *ap);
static void ahci_start_port(struct ata_port *ap);
static int ahci_deinit_port(struct ata_port *ap, const char **emsg);
static int ahci_reset_controller(struct ata_host *host);
static void ahci_sw_activity(struct ata_link *link);
static void ahci_sw_activity_blink(unsigned long arg);
static void ahci_init_sw_activity(struct ata_link *link);
static int ahci_reset_em(struct ata_host *host);
static ssize_t ahci_led_show(struct ata_port *ap, char *buf);
static ssize_t ahci_activity_store(struct ata_device *dev, enum sw_activity val);
static ssize_t ahci_activity_show(struct ata_device *dev, char *buf);
static void ahci_init_controller(struct ata_host *host);
static void ahci_dev_config(struct ata_device *dev);
static unsigned int ahci_dev_classify(struct ata_port *ap);
static int ahci_kick_engine(struct ata_port *ap);
static int ahci_check_ready(struct ata_link *link);
static int ahci_sb600_check_ready(struct ata_link *link);
static void ahci_postreset(struct ata_link *link, unsigned int *class);
static unsigned int ahci_fill_sg(struct ata_queued_cmd *qc, void *cmd_tbl);
static int ahci_pmp_qc_defer(struct ata_queued_cmd *qc);
static void ahci_qc_prep(struct ata_queued_cmd *qc);
static void ahci_fbs_dec_intr(struct ata_port *ap);
static void ahci_error_intr(struct ata_port *ap, u32 irq_stat);
static void ahci_port_intr(struct ata_port *ap);
static irqreturn_t ahci_interrupt(int irq, void *dev_instance);
static unsigned int ahci_qc_issue(struct ata_queued_cmd *qc);
static bool ahci_qc_fill_rtf(struct ata_queued_cmd *qc);
static void ahci_freeze(struct ata_port *ap);
static void ahci_thaw(struct ata_port *ap);
static void ahci_error_handler(struct ata_port *ap);
static void ahci_post_internal_cmd(struct ata_queued_cmd *qc);
static void ahci_enable_fbs(struct ata_port *ap);
static void ahci_disable_fbs(struct ata_port *ap);
static void ahci_pmp_attach(struct ata_port *ap);
static void ahci_pmp_detach(struct ata_port *ap);
static int ahci_port_resume(struct ata_port *ap);
static int ahci_port_suspend(struct ata_port *ap, pm_message_t mesg);
static int ahci_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg);
static int ahci_pci_device_resume(struct pci_dev *pdev);
static int ahci_port_start(struct ata_port *ap);
static void ahci_port_stop(struct ata_port *ap);
static int ahci_configure_dma_masks(struct pci_dev *pdev, int using_dac);
static void ahci_print_info(struct ata_host *host);
static void ahci_p5wdh_workaround(struct ata_host *host);
static bool ahci_sb600_enable_64bit(struct pci_dev *pdev);
static bool ahci_broken_system_poweroff(struct pci_dev *pdev);
static bool ahci_broken_suspend(struct pci_dev *pdev);
static bool ahci_broken_online(struct pci_dev *pdev);
static void ahci_gtf_filter_workaround(struct ata_host *host);
static inline void ahci_gtf_filter_workaround(struct ata_host *host);
static int ahci_init_one(struct pci_dev *pdev, const struct pci_device_id *ent);
static int __init ahci_init(void);
static void __exit ahci_exit(void);
| 120e50f2711a957be8cfa7e2d8a0ef2f223b7b3f3f03901cbbd13d4648be2646 | 117 |
|
Mustaavalkosta | toolchain_gcc-4.8 | gcc/config/sh/sh.c | rtx
gen_block_redirect |
static rtx
gen_block_redirect (rtx jump, int addr, int need_block)
{
int dead = 0;
rtx prev = prev_nonnote_insn (jump);
rtx dest;
if (prev && NONJUMP_INSN_P (prev) && ! INSN_DELETED_P (prev))
{
if (INSN_CODE (prev) == CODE_FOR_indirect_jump_scratch)
return prev;
if (GET_CODE (PATTERN (prev)) == USE
|| GET_CODE (PATTERN (prev)) == CLOBBER
|| get_attr_in_delay_slot (prev) == IN_DELAY_SLOT_YES)
prev = jump;
else if ((need_block &= ~1) < 0)
return prev;
else if (recog_memoized (prev) == CODE_FOR_block_branch_redirect)
need_block = 0;
}
if (GET_CODE (PATTERN (jump)) == RETURN)
{
if (! need_block)
return prev;
return emit_insn_before (gen_block_branch_redirect (const0_rtx) , jump);
}
dest = XEXP (SET_SRC (PATTERN (jump)), 0);
if (optimize
&& (INSN_ADDRESSES (INSN_UID (dest)) - addr + (unsigned) 4092
> 4092 + 4098))
{
rtx scan;
unsigned attempt = 0x7fff, used;
int jump_left = flag_expensive_optimizations + 1;
for (scan = jump; (scan = PREV_INSN (scan)); )
{
enum rtx_code code;
if (INSN_DELETED_P (scan))
continue;
code = GET_CODE (scan);
if (code == CODE_LABEL || code == JUMP_INSN)
break;
if (code == INSN
&& GET_CODE (PATTERN (scan)) != USE
&& GET_CODE (PATTERN (scan)) != CLOBBER
&& get_attr_in_delay_slot (scan) == IN_DELAY_SLOT_YES)
{
attempt &= ~regs_used (PATTERN (scan), 0);
break;
}
}
for (used = dead = 0, scan = JUMP_LABEL (jump);
(scan = NEXT_INSN (scan)); )
{
enum rtx_code code;
if (INSN_DELETED_P (scan))
continue;
code = GET_CODE (scan);
if (INSN_P (scan))
{
used |= regs_used (PATTERN (scan), 0);
if (code == CALL_INSN)
used |= regs_used (CALL_INSN_FUNCTION_USAGE (scan), 0);
dead |= (used >> 16) & ~used;
if (dead & attempt)
{
dead &= attempt;
break;
}
if (code == JUMP_INSN)
{
if (jump_left-- && simplejump_p (scan))
scan = JUMP_LABEL (scan);
else
break;
}
}
}
dead &= 0x7fff;
}
else if (optimize && need_block >= 0)
{
rtx next = next_active_insn (next_active_insn (dest));
if (next && JUMP_P (next)
&& GET_CODE (PATTERN (next)) == SET
&& recog_memoized (next) == CODE_FOR_jump_compact)
{
dest = JUMP_LABEL (next);
if (dest
&& (INSN_ADDRESSES (INSN_UID (dest)) - addr + (unsigned) 4092
> 4092 + 4098))
gen_block_redirect (next, INSN_ADDRESSES (INSN_UID (next)), -1);
}
}
if (dead)
{
rtx reg = gen_rtx_REG (SImode, exact_log2 (dead & -dead));
rtx insn = emit_insn_before (gen_indirect_jump_scratch
(reg, GEN_INT (unspec_bbr_uid++)),
jump);
INSN_LOCATION (insn) = INSN_LOCATION (jump);
INSN_CODE (insn) = CODE_FOR_indirect_jump_scratch;
return insn;
}
else if (need_block)
return emit_insn_before (gen_block_branch_redirect
(GEN_INT (unspec_bbr_uid++)),
jump);
return prev;
} | 56e7d04e1d5a0e828c5df2b25e74bc519dc77687c5b4b4bd971e40cee7ebd945 | 3,118 |
||
Qihoo360 | huststore | hustdb/ha/nginx/src/core/cjson_serialization_base.c | cjson_serialize_double |
json_t * cjson_serialize_double(const double * obj_val)
{
return obj_val ? cJSON_CreateNumber(*obj_val) : NULL;
} |
void json_init_hooks(json_hooks_t* hooks);
void * json_malloc(size_t size);
void json_free(void * obj);
static char * __load_from_file(const char * path);
static json_bool_t __save_to_file(const char * data, const char * path);
json_bool_t json_is_array(const json_t * json_val);
json_bool_t json_is_object(const json_t * json_val);
json_t * json_object();
json_t * json_array();
size_t json_array_size(const json_t * json_val);
json_t * json_array_get_item(const json_t * json_val, size_t index);
json_bool_t json_array_append_item(json_t * json_val, json_t * item);
json_t * json_object_get_field(const json_t * json_val, const char * key);
json_bool_t json_object_set_field(json_t * json_val, const char * key, json_t * child);
json_t * json_load_from_str(const char * json_val);
char * json_dump_to_str(const json_t * json_val);
json_t * json_load_from_file(const char * path);
json_bool_t json_dump_to_file(const json_t * json_val, const char * path);
json_bool_t cjson_copy_to_string(const char * src, json_str_t * des);
json_bool_t cjson_set_integer(const json_int_t * src, json_int_t * des);
json_bool_t cjson_set_double(const double * src, double * des);
json_bool_t cjson_set_string(const json_str_t * src, json_str_t * des);
json_bool_t cjson_eq_integer(const json_int_t * src, json_int_t * des);
json_bool_t cjson_eq_double(const double * src, double * des);
json_bool_t cjson_eq_string(const json_str_t * src, json_str_t * des);
void cjson_dispose_integer(json_int_t * obj_val);
void cjson_dispose_double(double * obj_val);
void cjson_dispose_string(json_str_t * obj_val);
json_t * cjson_serialize_integer(const json_int_t * obj_val);
json_t * cjson_serialize_string(const json_str_t * obj_val);
json_bool_t cjson_deserialize_integer(const json_t * json_val, json_int_t * obj_val);
json_bool_t cjson_deserialize_double(const json_t * json_val, double * obj_val);
json_bool_t cjson_deserialize_string(const json_t * json_val, json_str_t * obj_val);
void cjson_dispose_json_value(json_t * json_val);
| 6e9751a84bcb28b64a877f05d422b101e1d768ab4ce50951fa95d67b0daa3912 | 115 |
|
MobileCloudNetworking | icnaas | csrc/sync/SyncUtil.c | void
SyncNoteErr |
extern void
SyncNoteErr(const char *msg) {
char *s = getenv("CCNS_NOTE_ERR");
int useStdErr = 0;
if (s != NULL && s[0] != 0)
useStdErr = strtol(s, NULL, 10);
if (useStdErr > 0) {
fprintf(stderr, "**** error in %s\n", msg);
fflush(stderr);
}
} | ea3878f7f268aba08533414843bb0f4fe295f94b14d6928a3196941092ad4421 | 287 |
||
ChibiOS | ChibiOS | test/mfs/source/test/mfs_test_sequence_001.c | mfs_test_001_005_teardown |
static void mfs_test_001_005_teardown(void) {
mfsStop(&mfs1);
} |
static void mfs_test_001_001_setup(void);
static void mfs_test_001_001_teardown(void);
static void mfs_test_001_001_execute(void);
static void mfs_test_001_002_setup(void);
static void mfs_test_001_002_teardown(void);
static void mfs_test_001_002_execute(void);
static void mfs_test_001_003_setup(void);
static void mfs_test_001_003_teardown(void);
static void mfs_test_001_003_execute(void);
static void mfs_test_001_004_setup(void);
static void mfs_test_001_004_teardown(void);
static void mfs_test_001_004_execute(void);
static void mfs_test_001_005_setup(void);
static void mfs_test_001_005_execute(void);
static void mfs_test_001_006_setup(void);
static void mfs_test_001_006_teardown(void);
static void mfs_test_001_006_execute(void);
static void mfs_test_001_007_setup(void);
static void mfs_test_001_007_teardown(void);
static void mfs_test_001_007_execute(void);
| eebd5ec646ee7ce229136ccce1e95472055d00afee86f36876b85da4ce0316dd | 66 |
|
GenaSG | ET | src/client/cl_ui.c | LAN_GetPing | tatic void LAN_GetPing( int n, char *buf, int buflen, int *pingtime ) {
CL_GetPing( n, buf, buflen, pingtime );
}
| tatic void GetClientState( uiClientState_t *state );
oid LAN_LoadCachedServers();
oid LAN_SaveServersToCache();
tatic void LAN_ResetPings( int source );
tatic int LAN_AddServer( int source, const char *name, const char *address );
tatic void LAN_RemoveServer( int source, const char *addr );
tatic int LAN_GetServerCount( int source );
tatic void LAN_GetServerAddressString( int source, int n, char *buf, int buflen );
tatic void LAN_GetServerInfo( int source, int n, char *buf, int buflen );
tatic int LAN_GetServerPing( int source, int n );
tatic serverInfo_t *LAN_GetServerPtr( int source, int n );
tatic int LAN_CompareServers( int source, int sortKey, int sortDir, int s1, int s2 );
tatic int LAN_GetPingQueueCount( void );
tatic void LAN_ClearPing( int n );
tatic void LAN_GetPingInfo( int n, char *buf, int buflen );
tatic void LAN_MarkServerVisible( int source, int n, qboolean visible );
tatic int LAN_ServerIsVisible( int source, int n );
boolean LAN_UpdateVisiblePings( int source );
nt LAN_GetServerStatus( char *serverAddress, char *serverStatus, int maxLen );
boolean LAN_ServerIsInFavoriteList( int source, int n );
tatic void CL_GetGlconfig( glconfig_t *config );
tatic void GetClipboardData( char *buf, int buflen );
oid Key_KeynumToStringBuf( int keynum, char *buf, int buflen );
oid Key_GetBindingBuf( int keynum, char *buf, int buflen );
nt Key_GetCatcher( void );
oid Key_SetCatcher( int catcher );
tatic void CLUI_GetCDKey( char *buf, int buflen );
tatic void CLUI_SetCDKey( char *buf );
tatic int GetConfigString( int index, char *buf, int size );
tatic int FloatAsInt( float f );
nt CL_UISystemCalls( int *args );
oid CL_ShutdownUI( void );
oid CL_InitUI( void );
boolean UI_usesUniqueCDKey();
boolean UI_checkKeyExec( int key );
boolean UI_GameCommand( void );
| 60e669b883d65d84788bd3e962f7713656acc1f9f81d72b4227d3c2a33d3c36a | 116 |
|
polaco1782 | quake2 | src/game/p_hud.c | DeathmatchScoreboardMessage |
void DeathmatchScoreboardMessage (edict_t *ent, edict_t *killer)
{
char entry[1024];
char string[1400];
int stringlength;
int i, j, k;
int sorted[MAX_CLIENTS];
int sortedscores[MAX_CLIENTS];
int score, total;
int picnum;
int x, y;
gclient_t *cl;
edict_t *cl_ent;
char *tag;
if (ent->is_bot)
return;
total = 0;
for (i=0 ; i<game.maxclients ; i++)
{
cl_ent = g_edicts + 1 + i;
if (!cl_ent->inuse || game.clients[i].resp.spectator)
continue;
score = game.clients[i].resp.score;
for (j=0 ; j<total ; j++)
{
if (score > sortedscores[j])
break;
}
for (k=total ; k>j ; k--)
{
sorted[k] = sorted[k-1];
sortedscores[k] = sortedscores[k-1];
}
sorted[j] = i;
sortedscores[j] = score;
total++;
}
string[0] = 0;
stringlength = strlen(string);
if (total > 12)
total = 12;
for (i=0 ; i<total ; i++)
{
cl = &game.clients[sorted[i]];
cl_ent = g_edicts + 1 + sorted[i];
picnum = gi.imageindex ("i_fixme");
x = (i>=6) ? 160 : 0;
y = 32 + 32 * (i%6);
if (cl_ent == ent)
tag = "tag1";
else if (cl_ent == killer)
tag = "tag2";
else
tag = NULL;
if (tag)
{
Com_sprintf (entry, sizeof(entry),
"xv %i yv %i picn %s ",x+32, y, tag);
j = strlen(entry);
if (stringlength + j > 1024)
break;
strcpy (string + stringlength, entry);
stringlength += j;
}
Com_sprintf (entry, sizeof(entry),
"client %i %i %i %i %i %i ",
x, y, sorted[i], cl->resp.score, cl->ping, (level.framenum - cl->resp.enterframe)/600);
j = strlen(entry);
if (stringlength + j > 1024)
break;
strcpy (string + stringlength, entry);
stringlength += j;
}
gi.WriteByte (svc_layout);
gi.WriteString (string);
} |
void MoveClientToIntermission (edict_t *ent);
void BeginIntermission (edict_t *targ);
void DeathmatchScoreboard (edict_t *ent);
void Cmd_Score_f (edict_t *ent);
void HelpComputer (edict_t *ent);
void Cmd_Help_f (edict_t *ent);
void G_SetStats (edict_t *ent);
void G_CheckChaseStats (edict_t *ent);
void G_SetSpectatorStats (edict_t *ent);
| fce2ee870ae0e76d1ca4539d898ab7962ea309be2d58b4b99be1cc7bbc3dedac | 1,723 |
|
aceofall | zephyr-iotos | ext/hal/silabs/gecko/emlib/src/em_cmu.c | CMU_HFRCOStartupDelaySet |
void CMU_HFRCOStartupDelaySet(uint32_t delay)
{
EFM_ASSERT(delay <= 31);
delay &= _CMU_HFRCOCTRL_SUDELAY_MASK >> _CMU_HFRCOCTRL_SUDELAY_SHIFT;
CMU->HFRCOCTRL = (CMU->HFRCOCTRL & ~(_CMU_HFRCOCTRL_SUDELAY_MASK))
| (delay << _CMU_HFRCOCTRL_SUDELAY_SHIFT);
} |
static uint32_t maxFreqHfle(void);
static void setHfLeConfig(uint32_t hfFreq, uint32_t maxLeFreq);
static uint32_t getHfLeConfig(void);
static uint32_t auxClkGet(void);
static uint32_t dbgClkGet(void);
static void flashWaitStateControl(uint32_t coreFreq);
static void flashWaitStateMax(void);
static uint32_t getRegIshUpperVal(uint32_t steadyStateRegIsh);
static uint32_t lfClkGet(CMU_Clock_TypeDef lfClkBranch);
__STATIC_INLINE void syncReg(uint32_t mask);
static uint32_t usbCClkGet(void);
CMU_AUXHFRCOBand_TypeDef CMU_AUXHFRCOBandGet(void);
void CMU_AUXHFRCOBandSet(CMU_AUXHFRCOBand_TypeDef band);
static uint32_t CMU_AUXHFRCODevinfoGet(CMU_AUXHFRCOFreq_TypeDef freq);
CMU_AUXHFRCOFreq_TypeDef CMU_AUXHFRCOBandGet(void);
void CMU_AUXHFRCOBandSet(CMU_AUXHFRCOFreq_TypeDef setFreq);
uint32_t CMU_Calibrate(uint32_t HFCycles, CMU_Osc_TypeDef ref);
uint32_t CMU_CalibrateCountGet(void);
CMU_ClkDiv_TypeDef CMU_ClockDivGet(CMU_Clock_TypeDef clock);
void CMU_ClockDivSet(CMU_Clock_TypeDef clock, CMU_ClkDiv_TypeDef div);
void CMU_ClockEnable(CMU_Clock_TypeDef clock, bool enable);
uint32_t CMU_ClockFreqGet(CMU_Clock_TypeDef clock);
uint32_t CMU_ClockPrescGet(CMU_Clock_TypeDef clock);
void CMU_ClockPrescSet(CMU_Clock_TypeDef clock, CMU_ClkPresc_TypeDef presc);
CMU_Select_TypeDef CMU_ClockSelectGet(CMU_Clock_TypeDef clock);
void CMU_ClockSelectSet(CMU_Clock_TypeDef clock, CMU_Select_TypeDef ref);
void CMU_FreezeEnable(bool enable);
CMU_HFRCOBand_TypeDef CMU_HFRCOBandGet(void);
void CMU_HFRCOBandSet(CMU_HFRCOBand_TypeDef band);
static uint32_t CMU_HFRCODevinfoGet(CMU_HFRCOFreq_TypeDef freq);
CMU_HFRCOFreq_TypeDef CMU_HFRCOBandGet(void);
void CMU_HFRCOBandSet(CMU_HFRCOFreq_TypeDef setFreq);
uint32_t CMU_HFRCOStartupDelayGet(void);
void CMU_HFXOInit(const CMU_HFXOInit_TypeDef *hfxoInit);
uint32_t CMU_LCDClkFDIVGet(void);
void CMU_LCDClkFDIVSet(uint32_t div);
void CMU_LFXOInit(const CMU_LFXOInit_TypeDef *lfxoInit);
void CMU_OscillatorEnable(CMU_Osc_TypeDef osc, bool enable, bool wait);
uint32_t CMU_OscillatorTuningGet(CMU_Osc_TypeDef osc);
void CMU_OscillatorTuningSet(CMU_Osc_TypeDef osc, uint32_t val);
bool CMU_PCNTClockExternalGet(unsigned int instance);
void CMU_PCNTClockExternalSet(unsigned int instance, bool external);
CMU_USHFRCOBand_TypeDef CMU_USHFRCOBandGet(void);
void CMU_USHFRCOBandSet(CMU_USHFRCOBand_TypeDef band);
| a8f03adb7476d3e86c555f8dd7f962b11d4ae79b9cdda33038f0649f6c2ce90e | 288 |
|
jrobhoward | SCADAbase | usr.sbin/newsyslog/newsyslog.c | void
expand_globs |
static void
expand_globs(struct cflist *work_p, struct cflist *glob_p)
{
int gmatch, gres;
size_t i;
char *mfname;
struct conf_entry *dupent, *ent, *globent;
glob_t pglob;
struct stat st_fm;
STAILQ_FOREACH(globent, glob_p, cf_nextp) {
gres = glob(globent->log, GLOB_NOCHECK, NULL, &pglob);
if (gres != 0) {
warn("cannot expand pattern (%d): %s", gres,
globent->log);
continue;
}
if (verbose > 2)
printf("\t+ Expanding pattern %s\n", globent->log);
for (i = 0; i < pglob.gl_matchc; i++) {
mfname = pglob.gl_pathv[i];
gmatch = 0;
STAILQ_FOREACH(ent, work_p, cf_nextp) {
if (strcmp(mfname, ent->log) == 0) {
gmatch++;
break;
}
}
if (gmatch)
continue;
gres = lstat(mfname, &st_fm);
if (gres != 0) {
warn("Skipping %s - lstat() error", mfname);
continue;
}
if (!S_ISREG(st_fm.st_mode)) {
if (verbose > 2)
printf("\t+ . skipping %s (!file)\n",
mfname);
continue;
}
if (verbose > 2)
printf("\t+ . add file %s\n", mfname);
dupent = init_entry(mfname, globent);
dupent->flags &= ~CE_GLOB;
STAILQ_INSERT_TAIL(work_p, dupent, cf_nextp);
}
globfree(&pglob);
if (verbose > 2)
printf("\t+ Done with pattern %s\n", globent->log);
}
} | a816e913f2c017ca208b636aaf34f4688b531148967221a218e57d0c7e895057 | 1,303 |
||
GabrielGanne | vpp-flowtable | src/vnet/bfd/bfd_udp.c | bfd_udp_add_session |
vnet_api_error_t bfd_udp_add_session (u32 sw_if_index, u32 desired_min_tx_us,
u32 required_min_rx_us, u8 detect_mult,
const ip46_address_t *local_addr,
const ip46_address_t *peer_addr)
{
vnet_api_error_t rv =
bfd_udp_validate_api_input (sw_if_index, local_addr, peer_addr);
if (rv)
{
return rv;
}
if (detect_mult < 1)
{
BFD_ERR ("detect_mult < 1");
return VNET_API_ERROR_INVALID_ARGUMENT;
}
if (desired_min_tx_us < 1)
{
BFD_ERR ("desired_min_tx_us < 1");
return VNET_API_ERROR_INVALID_ARGUMENT;
}
return bfd_udp_add_session_internal (&bfd_udp_main, sw_if_index,
desired_min_tx_us, required_min_rx_us,
detect_mult, local_addr, peer_addr);
} |
static void bfd_rpc_update_session_cb (const bfd_rpc_update_t *a);
static void bfd_rpc_update_session (u32 bs_idx, const bfd_pkt_t *pkt);
static bfd_udp_error_t bfd_udp6_scan (vlib_main_t *vm, vlib_buffer_t *b);
static clib_error_t *bfd_udp_init (vlib_main_t *vm);
| b48a53d2176393179e209e2dd1b0bbbe6bca1ee5b8fd213029f25f724404eca9 | 902 |
|
juddy | edcde | programs/dtsr/dtsrkdump.c | main |
int main (int argc, char *argv[])
{
int i;
int oops;
int dotcount;
long keycount;
long total;
char *ptr;
int do_objkeys = FALSE;
int do_wordkeys = FALSE;
char dbpath[2048];
char rcs_revision [8];
char dbname[12];
time_t now;
double percent = 0.0;
int listing_most_words = FALSE;
static char *word_labels[6] =
{
"Short Stems = %8ld\n", "Short Words = %8ld\n",
"Long Stems = %8ld\n", "Long Words = %8ld\n",
"Huge Stems = %8ld\n", "Huge Words = %8ld\n"
};
aa_argv0 = argv[0];
time (&now);
sscanf ("$Revision: /main/3 $", "%*s %s", rcs_revision);
setlocale (LC_ALL, "");
dtsearch_catd = catopen (FNAME_DTSRCAT, 0);
strftime (buf, sizeof (buf), "%m/%d/%Y, %I:%M %p",
localtime (&now));
printf (catgets(dtsearch_catd, MS_dtsrkdump, 3,
"%s %s, engine %s. %s.\n"),
aa_argv0, rcs_revision, AUSAPI_VERSION, buf);
if (argc <= 1) {
PRINT_USAGE:
printf (catgets(dtsearch_catd, MS_dtsrkdump, 4,
"\nUSAGE: %s -o|w|ow [-v] [-t<N> | -p<N>] dbname\n"
" Reads DtSearch key files and prints summary report.\n"
" -o Keys examined are OBJECT record keys.\n"
" -w Keys examined are inverted index WORDS.\n"
" -v VERBOSE mode, lists every key.\n"
" -t<N> Threshold. Sets w and v options, and lists only words\n"
" with >= <N> addresses. All words will be listed if <N> = 1.\n"
" -p<N> Another threshold. Same as -t except <N> is percent\n"
" of the entire database (<N> may include a decimal point).\n"
" For example -p99.9 prints out every word that occurs\n"
" in 99.9%% or more of the records--an excellent way to find\n"
" candidates for the stop list.\n"
" If w and v are set without threshold, default is -t%d.\n"
" <dbname> 1 - 8 character database name with optional path prefix.\n")
,aa_argv0
,MIN_THRESHOLD
);
DtSearchExit (2);
}
else {
for (;;) {
--argc;
++argv;
if (argc <= 0)
break;
ptr = argv[0];
if (*ptr != '-')
break;
while (*(++ptr) != 0) {
switch (*ptr) {
case 'o':
do_objkeys = TRUE;
break;
case 'w':
do_wordkeys = TRUE;
break;
case 'v':
do_verbose = TRUE;
break;
case 'p':
do_verbose = TRUE;
do_wordkeys = TRUE;
percent = atof (ptr + 1);
if (percent <= 0.0 || percent > 100.0) {
fprintf (stderr,
catgets (dtsearch_catd, MS_dtsrkdump, 5,
"%s Invalid percent value %lf.\a\n"),
PROGNAME"195", percent);
goto PRINT_USAGE;
}
ptr[1] = 0;
break;
case 't':
do_verbose = TRUE;
do_wordkeys = TRUE;
if ((min_threshold = atol (ptr + 1)) <= 0L) {
fprintf (stderr,
catgets (dtsearch_catd, MS_dtsrkdump, 53,
"%s Invalid threshold value.\a\n"),
PROGNAME"198");
goto PRINT_USAGE;
}
ptr[1] = 0;
break;
default:
fprintf (stderr,
catgets (dtsearch_catd, MS_dtsrkdump, 55,
"%s Unknown command line argument '%c'.\a\n"),
PROGNAME"278", *ptr);
goto PRINT_USAGE;
}
}
}
}
oops = FALSE;
if (argc <= 0) {
printf (catgets (dtsearch_catd, MS_dtsrkdump, 56,
"%s Missing required database name.\a\n"),
PROGNAME"267");
oops = TRUE;
}
if (!do_wordkeys && !do_objkeys) {
printf (catgets (dtsearch_catd, MS_dtsrkdump, 57,
"%s Either -o or -w must be specified.\a\n"),
PROGNAME"271");
oops = TRUE;
}
if (oops)
goto PRINT_USAGE;
strncpy (dbpath, argv[0], sizeof (dbpath));
dbpath[sizeof (dbpath) - 1] = 0;
for (ptr = dbpath + strlen (dbpath) - 1; ptr >= dbpath; ptr--)
if (!isalnum (*ptr)) {
ptr++;
break;
}
if (ptr < dbpath)
ptr = dbpath;
i = strlen (ptr);
if (i < 1 || i > 8) {
fprintf (stderr, catgets (dtsearch_catd, MS_dtsrkdump, 58,
"%s Invalid database name '%s'.\a\n"),
PROGNAME"297", ptr);
goto PRINT_USAGE;
}
strcpy (dbname, ptr);
*ptr = 0;
db_oflag = O_RDONLY;
if (!austext_dopen (dbname, dbpath, NULL, 0, &dbrec)) {
fprintf (stderr, "%s\n", DtSearchGetMessages());
DtSearchExit (3);
}
maxdba = dbrec.or_maxdba;
printf (catgets(dtsearch_catd, MS_dtsrkdump, 60,
"%s: '%s' reccount=%ld maxdba=%ld recslots=%hd minw=%hd maxw=%hd\n"),
aa_argv0, dbname, dbrec.or_reccount,
dbrec.or_maxdba, dbrec.or_recslots,
dbrec.or_minwordsz, dbrec.or_maxwordsz);
if (percent > 0.0)
min_threshold = (long)
((float) percent * (float) dbrec.or_reccount / 100.0);
if (min_threshold > dbrec.or_reccount)
min_threshold = dbrec.or_reccount;
if (do_wordkeys && do_verbose) {
if (min_threshold > 1 && min_threshold < dbrec.or_reccount) {
printf (catgets(dtsearch_catd, MS_dtsrkdump, 70,
"%s Will only list words occurring "
"in %ld or more records.\n"),
aa_argv0, min_threshold);
listing_most_words =
(float) min_threshold / (float) dbrec.or_reccount > .90;
}
else {
printf (catgets(dtsearch_catd, MS_dtsrkdump, 80,
"%s: Listing all words in database.\n"),
aa_argv0);
listing_most_words = TRUE;
}
}
if (do_objkeys) {
counters = austext_malloc (258 * sizeof(long), PROGNAME"113", NULL);
memset (counters, 0, 258 * sizeof(long));
dotcount = 0;
keycount = 0;
KEYFRST (PROGNAME"111", OR_OBJKEY, 0);
while (db_status == S_OKAY) {
KEYREAD (PROGNAME"288", buf);
(counters[buf[0]])++;
CRGET (PROGNAME"251", &dba, 0);
if (maxdba < (dba & 0xffffff))
maxdba = dba;
if (do_verbose) {
i = 0;
putchar ('\"');
for (ptr = buf; *ptr != 0; ptr++) {
if (*ptr < 32 | *ptr >= 127) {
putchar ('.');
i++;
}
else {
putchar (*ptr);
i++;
}
}
printf ("\" ");
while (i++ < DtSrMAX_DB_KEYSIZE)
putchar (' ');
printf (catgets(dtsearch_catd, MS_dtsrkdump, 100,
"dba x%08lx, %6ld\n"), dba, dba);
}
else {
if (++keycount % KEYS_PER_DOT == 0) {
putchar ('.');
if (++dotcount % 10 == 0)
putchar (' ');
if (dotcount % 50 == 0) {
putchar ('\n');
dotcount = 0;
}
fflush (stdout);
}
}
KEYNEXT (PROGNAME"291", OR_OBJKEY, 0);
}
if (dotcount)
putchar ('\n');
if (dbpath[0] == 0)
buf[0] = 0;
else
sprintf (buf, catgets(dtsearch_catd, MS_dtsrkdump, 110,
" in %s"), dbpath);
printf (catgets(dtsearch_catd, MS_dtsrkdump, 120,
"Object Summary for '%s'%s:\n"), dbname, buf);
puts (catgets(dtsearch_catd, MS_dtsrkdump, 130,
"Object Count by Keytypes:"));
total = 0L;
for (i = 0; i < 256; i++) {
if (counters[i] > 0L) {
total += counters[i];
if (i > 32 && i < 127)
printf (" '%c' %6ld\n", i, counters[i]);
else
printf (" x%02x %6ld\n", i, counters[i]);
}
}
printf (catgets(dtsearch_catd, MS_dtsrkdump, 160,
"TOTAL Objects Count = %ld\n"), total);
printf (catgets(dtsearch_catd, MS_dtsrkdump, 170,
"Largest Object DBA = %ld\n"), maxdba);
free (counters);
}
if (do_wordkeys) {
if (listing_most_words)
printf (catgets(dtsearch_catd, MS_dtsrkdump, 180,
"%s: * Words marked with asterisk occur in every record.\n"),
aa_argv0);
counters = austext_malloc (8 * sizeof (long), PROGNAME"113", NULL);
memset (counters, 0, 6 * sizeof(long));
count_words (0);
count_words (2);
count_words (4);
if (do_objkeys)
putchar ('\n');
if (dbpath[0] == 0)
buf[0] = 0;
else
sprintf (buf, catgets(dtsearch_catd, MS_dtsrkdump, 110,
" in %s"), dbpath);
printf (catgets(dtsearch_catd, MS_dtsrkdump, 200,
"Words Summary for '%s'%s:\n"), dbname, buf);
total = 0L;
for (i = 0; i < 6; i++) {
printf (word_labels[i], counters[i]);
total += counters[i];
}
printf (catgets(dtsearch_catd, MS_dtsrkdump, 210,
"TOTAL Words Count = %ld\n"), total);
free (counters);
}
DtSearchExit (0);
} |
void count_words (int index);
| 3cd91d9c1cd7bb7e13c8f544dd470f2777d06c49cf1dec4cbd0ac4a2adc60949 | 8,052 |
|
durandj | devkitadv | insight-5.3/gdb/dwarf2read.c | void
parse_macro_definition |
static void
parse_macro_definition (struct macro_source_file *file, int line,
const char *body)
{
const char *p;
for (p = body; *p; p++)
if (*p == ' ' || *p == '(')
break;
if (*p == ' ' || *p == '\0')
{
int name_len = p - body;
char *name = copy_string (body, name_len);
const char *replacement;
if (*p == ' ')
replacement = body + name_len + 1;
else
{
complain (&dwarf2_macro_malformed_definition, body);
replacement = body + name_len;
}
macro_define_object (file, line, name, replacement);
xfree (name);
}
else if (*p == '(')
{
char *name = copy_string (body, p - body);
int argc = 0;
int argv_size = 1;
char **argv = xmalloc (argv_size * sizeof (*argv));
p++;
p = consume_improper_spaces (p, body);
while (*p && *p != ')')
{
const char *arg_start = p;
while (*p && *p != ',' && *p != ')' && *p != ' ')
p++;
if (! *p || p == arg_start)
complain (&dwarf2_macro_malformed_definition,
body);
else
{
if (argc >= argv_size)
{
argv_size *= 2;
argv = xrealloc (argv, argv_size * sizeof (*argv));
}
argv[argc++] = copy_string (arg_start, p - arg_start);
}
p = consume_improper_spaces (p, body);
if (*p == ',')
{
p++;
p = consume_improper_spaces (p, body);
}
}
if (*p == ')')
{
p++;
if (*p == ' ')
macro_define_function (file, line, name,
argc, (const char **) argv,
p + 1);
else if (*p == '\0')
{
complain (&dwarf2_macro_malformed_definition, body);
macro_define_function (file, line, name,
argc, (const char **) argv,
p);
}
else
complain (&dwarf2_macro_malformed_definition, body);
}
else
complain (&dwarf2_macro_malformed_definition, body);
xfree (name);
{
int i;
for (i = 0; i < argc; i++)
xfree (argv[i]);
}
xfree (argv);
}
else
complain (&dwarf2_macro_malformed_definition, body);
} | bf4138cf96e5c380fc92a4fa6a0e6b4bd11385fb80290ea16683c4bba93d6b8d | 2,668 |
||
easion | os_sdk | jwm-2.0.1/src/border.c | DestroyBorders |
void DestroyBorders() {
} |
void InitializeBorders();
void StartupBorders();
void ShutdownBorders();
int GetBorderIconSize();
BorderActionType GetBorderActionType(const ClientNode *np, int x, int y);
void DrawBorder(const ClientNode *np, const XExposeEvent *expose);
void DrawBorderHelper(const ClientNode *np, int drawIcon);
int GetButtonCount(const ClientNode *np);
void DrawBorderButtons(const ClientNode *np, Pixmap canvas, GC gc);
void ExposeCurrentDesktop();
void SetBorderWidth(const char *str);
void SetTitleHeight(const char *str);
| f6cd21b8c940d49b8445e4a2578e6b2ef8775fc2dc1ff054870753f4f58fd7cb | 26 |
|
retrodeluxe | FUZIX | Kernel/platform-rc2014/devtty.c | quart_intr |
static uint8_t quart_intr(uint8_t minor)
{
uint8_t r = in16(QUARTPORT + QUARTREG(ISR1));
if (r & 0x02) {
r = in16(QUARTPORT + QUARTREG(RHRA));
tty_inproc(minor, r);
}
if (r & 0x20) {
r = in16(QUARTPORT + QUARTREG(RHRB));
if (minor + 1 <= NUM_DEV_TTY)
tty_inproc(minor + 1 , r);
}
r = in16(QUARTPORT + QUARTREG(ISR2));
if (r & 0x02) {
r = in16(QUARTPORT + QUARTREG(RHRC));
if (minor + 2 <= NUM_DEV_TTY)
tty_inproc(minor + 2 , r);
}
if (r & 0x20) {
r = in16(QUARTPORT + QUARTREG(RHRD));
if (minor + 3 <= NUM_DEV_TTY)
tty_inproc(minor + 3, r);
}
if (quart_timer && (r & 0x10)) {
in16(QUARTPORT + QUARTREG(STC2));
timer_interrupt();
}
return 4;
} |
void tty_setup(uint_fast8_t minor, uint_fast8_t flags);
int tty_carrier(uint_fast8_t minor);
void tty_pollirq(void);
void tty_putc(uint_fast8_t minor, uint_fast8_t c);
void tty_sleeping(uint_fast8_t minor);
ttyready_t tty_writeready(uint_fast8_t minor);
void tty_data_consumed(uint_fast8_t minor);
void kputchar(char c);
int rctty_open(uint_fast8_t minor, uint16_t flag);
static uint8_t acia_intr(uint8_t minor);
static void acia_setup(uint8_t minor);
static uint8_t acia_writeready(uint_fast8_t minor);
static void acia_putc(uint_fast8_t minor, uint_fast8_t c);
static uint8_t carrier_unwired(uint_fast8_t minor);
static uint8_t sio_intrb(uint_fast8_t minor);
static uint8_t sio_intr(uint_fast8_t minor);
static ttyready_t sio_writeready(uint_fast8_t minor);
static void sio_putc(uint_fast8_t minor, uint_fast8_t c);
static void sio_setup(uint_fast8_t minor);
static uint8_t sio_carrier(uint_fast8_t minor);
static uint8_t ns16x50_intr(uint_fast8_t minor);
static ttyready_t ns16x50_writeready(uint_fast8_t minor);
static void ns16x50_putc(uint_fast8_t minor, uint_fast8_t c);
static void ns16x50_setup(uint_fast8_t minor);
static uint8_t ns16x50_carrier(uint_fast8_t minor);
static uint8_t asci_intr0(uint_fast8_t minor);
static uint8_t asci_intr1(uint_fast8_t minor);
ttyready_t asci_writeready0(uint_fast8_t minor);
ttyready_t asci_writeready1(uint_fast8_t minor);
static void asci_putc0(uint_fast8_t minor, uint_fast8_t c);
static void asci_putc1(uint_fast8_t minor, uint_fast8_t c);
static void asci_setup(uint_fast8_t minor);
static void quart_setup(uint8_t minor);
static uint8_t quart_writeready(uint_fast8_t minor);
static void quart_putc(uint_fast8_t minor, uint_fast8_t c);
static uint8_t tms_intr(uint8_t minor);
static void tms_setup(uint8_t minor);
static uint8_t tms_writeready(uint_fast8_t minor);
static void tms_setoutput(uint_fast8_t minor);
static void tms_putc(uint_fast8_t minor, uint_fast8_t c);
void do_conswitch(uint8_t c);
void ps2kbd_conswitch(uint8_t console);
uint8_t register_uart(uint16_t port, struct uart *ops);
void insert_uart(uint16_t port, struct uart *ops);
void display_uarts(void);
int rctty_ioctl(uint8_t minor, uarg_t arg, char *ptr);
| b7611fba6020a2935c98fabd0614b9c6c1daea60351757061ddda5a6a1000497 | 747 |
|
gatieme | LDD-LinuxDeviceDrivers | books/fengguojin/src/2synchronous/2-1spinlock/spin/spinlock.c | *×¢ÏúÉ豸Çý¶¯*/
unregister_chrdev | *×¢ÏúÉ豸Çý¶¯*/
unregister_chrdev(MAJOR_NUM, "chardev");
}
module_init(simple_init);
module_exit(simple_exit); |
static int simple_open(struct inode *inode, struct file *filp);
t inode *inode, struct file *filp);
ct file *filp, char *buf, size_t len, loff_t*off);
uct file *filp, const char *buf, size_t len,loff_t *off);
oid);
| 7c6057cb1b902f775443fe77e30664f1975da0ef1d405fb42115e661bc2dd9be | 129 |
|
alishakiba | libflame | src/lapack/inv/tri/un/flamec/FLA_Trinv_un_opt_var1.c | FLA_Trinv_un_ops_var1 |
FLA_Error FLA_Trinv_un_ops_var1( int mn_A,
float* buff_A, int rs_A, int cs_A )
{
float alpha11_m1;
int i;
for ( i = 0; i < mn_A; ++i )
{
float* A00 = buff_A + (0 )*cs_A + (0 )*rs_A;
float* a01 = buff_A + (i )*cs_A + (0 )*rs_A;
float* alpha11 = buff_A + (i )*cs_A + (i )*rs_A;
int mn_behind = i;
bl1_strmv( BLIS1_UPPER_TRIANGULAR,
BLIS1_NO_TRANSPOSE,
BLIS1_NONUNIT_DIAG,
mn_behind,
A00, rs_A, cs_A,
a01, rs_A );
bl1_sneg2( alpha11, &alpha11_m1 );
bl1_sinvscalv( BLIS1_NO_CONJUGATE,
mn_behind,
&alpha11_m1,
a01, rs_A );
bl1_sinverts( BLIS1_NO_CONJUGATE,
alpha11 );
}
return FLA_SUCCESS;
} |
FLA_Error FLA_Trinv_un_opt_var1( FLA_Obj A );
| 230fbcaa3609c8f86e5b04bd63333238caa24a8c68d319873e6a9984bdae72ce | 904 |
|
Drusyc | shell | src/readcmd.c | read_word | atic void read_word(char ** cur, char ** cur_buf) {
while(1) {
char c = **cur;
switch (c) {
case '\0':
case ' ':
case '\t':
case '<':
case '>':
case '|':
**cur_buf = '\0';
return;
case '\'':
read_single_quote(cur, cur_buf);
break;
case '"':
read_double_quote(cur, cur_buf);
break;
case '\\':
SKIP_CHAR;
READ_CHAR;
break;
default:
READ_CHAR;
break;
}
}
}
/ | atic void memory_error(void);
atic void *xmalloc(size_t size);
atic void *xrealloc(void *ptr, size_t size);
atic char *readline(char *prompt);
atic void read_single_quote(char ** cur, char ** cur_buf);
atic void read_double_quote(char ** cur, char ** cur_buf);
atic char **split_in_words(char *line);
atic void freeseq(char ***seq);
atic void freecmd(struct cmdline *s);
ruct cmdline *readcmd(char *prompt);
| b4cab62913d141d969e0b87d0daaf453add4b8cc862077aa8453e948539a279f | 417 |
|
ApisSys | linux-analogdevicesinc-ap6 | ECE695-Spring17/t3-scheduler/linux-4.10.6/drivers/rtc/rtc-tegra.c | tegra_rtc_probe |
static int __init tegra_rtc_probe(struct platform_device *pdev)
{
struct tegra_rtc_info *info;
struct resource *res;
int ret;
info = devm_kzalloc(&pdev->dev, sizeof(struct tegra_rtc_info),
GFP_KERNEL);
if (!info)
return -ENOMEM;
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
info->rtc_base = devm_ioremap_resource(&pdev->dev, res);
if (IS_ERR(info->rtc_base))
return PTR_ERR(info->rtc_base);
info->tegra_rtc_irq = platform_get_irq(pdev, 0);
if (info->tegra_rtc_irq <= 0)
return -EBUSY;
info->pdev = pdev;
spin_lock_init(&info->tegra_rtc_lock);
platform_set_drvdata(pdev, info);
writel(0, info->rtc_base + TEGRA_RTC_REG_SECONDS_ALARM0);
writel(0xffffffff, info->rtc_base + TEGRA_RTC_REG_INTR_STATUS);
writel(0, info->rtc_base + TEGRA_RTC_REG_INTR_MASK);
device_init_wakeup(&pdev->dev, 1);
info->rtc_dev = devm_rtc_device_register(&pdev->dev,
dev_name(&pdev->dev), &tegra_rtc_ops,
THIS_MODULE);
if (IS_ERR(info->rtc_dev)) {
ret = PTR_ERR(info->rtc_dev);
dev_err(&pdev->dev, "Unable to register device (err=%d).\n",
ret);
return ret;
}
ret = devm_request_irq(&pdev->dev, info->tegra_rtc_irq,
tegra_rtc_irq_handler, IRQF_TRIGGER_HIGH,
dev_name(&pdev->dev), &pdev->dev);
if (ret) {
dev_err(&pdev->dev,
"Unable to request interrupt for device (err=%d).\n",
ret);
return ret;
}
dev_notice(&pdev->dev, "Tegra internal Real Time Clock\n");
return 0;
} |
static inline u32 tegra_rtc_check_busy(struct tegra_rtc_info *info);
static int tegra_rtc_wait_while_busy(struct device *dev);
static int tegra_rtc_read_time(struct device *dev, struct rtc_time *tm);
static int tegra_rtc_set_time(struct device *dev, struct rtc_time *tm);
static int tegra_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm);
static int tegra_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled);
static int tegra_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm);
static int tegra_rtc_proc(struct device *dev, struct seq_file *seq);
static irqreturn_t tegra_rtc_irq_handler(int irq, void *data);
static int tegra_rtc_suspend(struct device *dev);
static int tegra_rtc_resume(struct device *dev);
static void tegra_rtc_shutdown(struct platform_device *pdev);
| b34820ee006332a1c6e20e50b415be458488699fd402f61d95a88169dd3143ac | 1,434 |
|
pedia | moosefs | mfsmaster/filesystem.c | fs_loadnode |
int fs_loadnode(FILE *fd) {
uint8_t unodebuff[4+1+2+4+4+4+4+4+4+8+4+2+8*MAX_CHUNKS_PER_FILE+4*65536+4];
const uint8_t *ptr;
uint8_t type;
uint32_t indx,pleng,ch,sessionids,sessionid;
fsnode *p;
sessionidrec *sessionidptr;
uint32_t nodepos;
#ifndef METARESTORE
statsrecord *sr;
#endif
type = fgetc(fd);
if (type==0) {
return 1;
}
p = malloc(sizeof(fsnode));
passert(p);
p->type = type;
switch (type) {
case TYPE_DIRECTORY:
case TYPE_FIFO:
case TYPE_SOCKET:
if (fread(unodebuff,1,4+1+2+4+4+4+4+4+4,fd)!=4+1+2+4+4+4+4+4+4) {
mfs_errlog(LOG_ERR,"loading node: read error");
free(p);
return -1;
}
break;
case TYPE_BLOCKDEV:
case TYPE_CHARDEV:
case TYPE_SYMLINK:
if (fread(unodebuff,1,4+1+2+4+4+4+4+4+4+4,fd)!=4+1+2+4+4+4+4+4+4+4) {
mfs_errlog(LOG_ERR,"loading node: read error");
free(p);
return -1;
}
break;
case TYPE_FILE:
case TYPE_TRASH:
case TYPE_RESERVED:
if (fread(unodebuff,1,4+1+2+4+4+4+4+4+4+8+4+2,fd)!=4+1+2+4+4+4+4+4+4+8+4+2) {
mfs_errlog(LOG_ERR,"loading node: read error");
free(p);
return -1;
}
break;
default:
mfs_arg_syslog(LOG_ERR,"loading node: unrecognized node type: %c",type);
free(p);
return -1;
}
ptr = unodebuff;
p->id = get32bit(&ptr);
p->goal = get8bit(&ptr);
p->mode = get16bit(&ptr);
p->uid = get32bit(&ptr);
p->gid = get32bit(&ptr);
p->atime = get32bit(&ptr);
p->mtime = get32bit(&ptr);
p->ctime = get32bit(&ptr);
p->trashtime = get32bit(&ptr);
switch (type) {
case TYPE_DIRECTORY:
#ifndef METARESTORE
sr = malloc(sizeof(statsrecord));
passert(sr);
memset(sr,0,sizeof(statsrecord));
p->data.ddata.stats = sr;
p->data.ddata.quota = NULL;
#endif
p->data.ddata.children = NULL;
p->data.ddata.nlink = 2;
p->data.ddata.elements = 0;
case TYPE_SOCKET:
case TYPE_FIFO:
break;
case TYPE_BLOCKDEV:
case TYPE_CHARDEV:
p->data.rdev = get32bit(&ptr);
break;
case TYPE_SYMLINK:
pleng = get32bit(&ptr);
p->data.sdata.pleng = pleng;
if (pleng>0) {
p->data.sdata.path = malloc(pleng);
passert(p->data.sdata.path);
if (fread(p->data.sdata.path,1,pleng,fd)!=pleng) {
mfs_errlog(LOG_ERR,"loading node: read error");
free(p->data.sdata.path);
free(p);
return -1;
}
} else {
p->data.sdata.path = NULL;
}
break;
case TYPE_FILE:
case TYPE_TRASH:
case TYPE_RESERVED:
p->data.fdata.length = get64bit(&ptr);
ch = get32bit(&ptr);
p->data.fdata.chunks = ch;
sessionids = get16bit(&ptr);
if (ch>0) {
p->data.fdata.chunktab = malloc(sizeof(uint64_t)*ch);
passert(p->data.fdata.chunktab);
} else {
p->data.fdata.chunktab = NULL;
}
if (fread((uint8_t*)ptr,1,8*ch+4*sessionids,fd)!=8*ch+4*sessionids) {
mfs_errlog(LOG_ERR,"loading node: read error");
if (p->data.fdata.chunktab) {
free(p->data.fdata.chunktab);
}
free(p);
return -1;
}
for (indx=0 ; indx<ch ; indx++) {
p->data.fdata.chunktab[indx] = get64bit(&ptr);;
}
p->data.fdata.sessionids=NULL;
while (sessionids) {
sessionid = get32bit(&ptr);
sessionidptr = sessionidrec_malloc();
sessionidptr->sessionid = sessionid;
sessionidptr->next = p->data.fdata.sessionids;
p->data.fdata.sessionids = sessionidptr;
#ifndef METARESTORE
matocuserv_init_sessions(sessionid,p->id);
#endif
sessionids--;
}
}
p->parents = NULL;
nodepos = NODEHASHPOS(p->id);
p->next = nodehash[nodepos];
nodehash[nodepos] = p;
fsnodes_used_inode(p->id);
nodes++;
if (type==TYPE_DIRECTORY) {
dirnodes++;
}
if (type==TYPE_FILE || type==TYPE_TRASH || type==TYPE_RESERVED) {
filenodes++;
}
return 0;
} |
void fs_stats(uint32_t stats[16]);
static inline freenode* freenode_malloc();
static inline void freenode_free(freenode *p);
static inline freenode* freenode_malloc();
static inline void freenode_free(freenode* p);
static inline sessionidrec* sessionidrec_malloc();
static inline void sessionidrec_free(sessionidrec *p);
static inline sessionidrec* sessionidrec_malloc();
static inline void sessionidrec_free(sessionidrec* p);
uint32_t fsnodes_get_next_id();
void fsnodes_free_id(uint32_t id,uint32_t ts);
uint8_t fs_freeinodes(uint32_t ts,uint32_t freeinodes);
void fsnodes_init_freebitmask (void);
void fsnodes_used_inode (uint32_t id);
static char* fsnodes_escape_name(uint16_t nleng,const uint8_t *name);
static inline uint32_t fsnodes_hash(uint32_t parentid,uint16_t nleng,const uint8_t *name);
static inline int fsnodes_nameisused(fsnode *node,uint16_t nleng,const uint8_t *name);
static inline fsedge* fsnodes_lookup(fsnode *node,uint16_t nleng,const uint8_t *name);
static inline fsnode* fsnodes_id_to_node(uint32_t id);
static inline int fsnodes_isancestor(fsnode *f,fsnode *p);
static inline quotanode* fsnodes_new_quotanode();
static inline void fsnodes_delete_quotanode(quotanode *qn);
static inline void fsnodes_check_quotanode(quotanode *qn,uint32_t ts);
void fsnodes_check_all_quotas(void);
static inline uint8_t fsnodes_test_quota(fsnode *node);
static inline void fsnodes_get_stats(fsnode *node,statsrecord *sr);
static inline void fsnodes_sub_stats(fsnode *parent,statsrecord *sr);
static inline void fsnodes_add_stats(fsnode *parent,statsrecord *sr);
static inline void fsnodes_add_sub_stats(fsnode *parent,statsrecord *newsr,statsrecord *prevsr);
static inline void fsnodes_remove_edge(uint32_t ts,fsedge *e);
static inline void fsnodes_link(uint32_t ts,fsnode *parent,fsnode *child,uint16_t nleng,const uint8_t *name);
static inline fsnode* fsnodes_create_node(uint32_t ts,fsnode* node,uint16_t nleng,const uint8_t *name,uint8_t type,uint16_t mode,uint32_t uid,uint32_t gid);
static inline uint32_t fsnodes_getpath_size(fsedge *e);
static inline void fsnodes_getpath_data(fsedge *e,uint8_t *path,uint32_t size);
static inline void fsnodes_getpath(fsedge *e,uint16_t *pleng,uint8_t **path);
static inline void fsnodes_fill_attr(fsnode *node,fsnode *parent,uint32_t uid,uint32_t gid,uint32_t auid,uint32_t agid,uint8_t sesflags,uint8_t attr[35]);
static inline uint32_t fsnodes_getdetachedsize(fsedge *start);
static inline void fsnodes_getdetacheddata(fsedge *start,uint8_t *dbuff);
static inline uint32_t fsnodes_getdirsize(fsnode *p,uint8_t withattr);
static inline void fsnodes_getdirdata(uint32_t ts,uint32_t rootinode,uint32_t uid,uint32_t gid,uint32_t auid,uint32_t agid,uint8_t sesflags,fsnode *p,uint8_t *dbuff,uint8_t withattr);
static inline void fsnodes_checkfile(fsnode *p,uint16_t chunkcount[256]);
static inline uint8_t fsnodes_appendchunks(uint32_t ts,fsnode *dstobj,fsnode *srcobj);
static inline void fsnodes_changefilegoal(fsnode *obj,uint8_t goal);
static inline void fsnodes_change_levelgoal(fsnode *obj,uint8_t level, uint8_t goal);
static inline void fsnodes_setlength(fsnode *obj,uint64_t length);
static inline void fsnodes_remove_node(uint32_t ts,fsnode *toremove);
static inline void fsnodes_unlink(uint32_t ts,fsedge *e);
static inline int fsnodes_purge(uint32_t ts,fsnode *p);
static inline uint8_t fsnodes_undel(uint32_t ts,fsnode *node);
static inline void fsnodes_getgoal_recursive(fsnode *node,uint8_t gmode,uint32_t fgtab[10],uint32_t dgtab[10]);
static inline void fsnodes_getlevelgoal_recursive(fsnode *node,uint8_t gmode,uint32_t fgtab[40],uint32_t dgtab[40]);
static inline void fsnodes_bst_add(bstnode **n,uint32_t val);
static inline uint32_t fsnodes_bst_nodes(bstnode *n);
static inline void fsnodes_bst_storedata(bstnode *n,uint8_t **ptr);
static inline void fsnodes_bst_free(bstnode *n);
static inline void fsnodes_gettrashtime_recursive(fsnode *node,uint8_t gmode,bstnode **bstrootfiles,bstnode **bstrootdirs);
static inline void fsnodes_geteattr_recursive(fsnode *node,uint8_t gmode,uint32_t feattrtab[16],uint32_t deattrtab[16]);
static inline void fsnodes_setgoal_recursive(fsnode *node,uint32_t ts,uint32_t uid/*,uint8_t quota*/,uint8_t goal,uint8_t smode,uint32_t *sinodes,uint32_t *ncinodes,uint32_t *nsinodes/*,uint32_t *qeinodes*/);
static inline void fsnodes_setlevelgoal_recursive(fsnode *node,uint32_t ts,uint32_t uid/*,uint8_t quota*/,uint8_t level,uint8_t goal,uint8_t smode,uint32_t *sinodes,uint32_t *ncinodes,uint32_t *nsinodes/*,uint32_t *qeinodes*/);
static inline void fsnodes_settrashtime_recursive(fsnode *node,uint32_t ts,uint32_t uid,uint32_t trashtime,uint8_t smode,uint32_t *sinodes,uint32_t *ncinodes,uint32_t *nsinodes);
static inline void fsnodes_seteattr_recursive(fsnode *node,uint32_t ts,uint32_t uid,uint8_t eattr,uint8_t smode,uint32_t *sinodes,uint32_t *ncinodes,uint32_t *nsinodes);
static inline void fsnodes_snapshot(uint32_t ts,fsnode *srcnode,fsnode *parentnode,uint32_t nleng,const uint8_t *name);
static inline uint8_t fsnodes_snapshot_test(fsnode *origsrcnode,fsnode *srcnode,fsnode *parentnode,uint32_t nleng,const uint8_t *name,uint8_t canoverwrite);
static inline int fsnodes_namecheck(uint32_t nleng,const uint8_t *name);
static inline int fsnodes_access(fsnode *node,uint32_t uid,uint32_t gid,uint8_t modemask,uint8_t sesflags);
static inline int fsnodes_sticky_access(fsnode *parent,fsnode *node,uint32_t uid);
uint8_t fs_access(uint32_t ts,uint32_t inode);
uint8_t fs_readreserved_size(uint32_t rootinode,uint8_t sesflags,uint32_t *dbuffsize);
void fs_readreserved_data(uint32_t rootinode,uint8_t sesflags,uint8_t *dbuff);
uint8_t fs_readtrash_size(uint32_t rootinode,uint8_t sesflags,uint32_t *dbuffsize);
void fs_readtrash_data(uint32_t rootinode,uint8_t sesflags,uint8_t *dbuff);
uint8_t fs_getdetachedattr(uint32_t rootinode,uint8_t sesflags,uint32_t inode,uint8_t attr[35],uint8_t dtype);
uint8_t fs_gettrashpath(uint32_t rootinode,uint8_t sesflags,uint32_t inode,uint32_t *pleng,uint8_t **path);
uint8_t fs_setpath(uint32_t inode,const uint8_t *path);
uint8_t fs_undel(uint32_t ts,uint32_t inode);
uint8_t fs_purge(uint32_t ts,uint32_t inode);
void fs_info(uint64_t *totalspace,uint64_t *availspace,uint64_t *trspace,uint32_t *trnodes,uint64_t *respace,uint32_t *renodes,uint32_t *inodes,uint32_t *dnodes,uint32_t *fnodes);
uint8_t fs_getrootinode(uint32_t *rootinode,const uint8_t *path);
void fs_statfs(uint32_t rootinode,uint8_t sesflags,uint64_t *totalspace,uint64_t *availspace,uint64_t *trspace,uint64_t *respace,uint32_t *inodes);
uint8_t fs_access(uint32_t rootinode,uint8_t sesflags,uint32_t inode,uint32_t uid,uint32_t gid,int modemask);
uint8_t fs_lookup(uint32_t rootinode,uint8_t sesflags,uint32_t parent,uint16_t nleng,const uint8_t *name,uint32_t uid,uint32_t gid,uint32_t auid,uint32_t agid,uint32_t *inode,uint8_t attr[35]);
uint8_t fs_getattr(uint32_t rootinode,uint8_t sesflags,uint32_t inode,uint32_t uid,uint32_t gid,uint32_t auid,uint32_t agid,uint8_t attr[35]);
uint8_t fs_try_setlength(uint32_t rootinode,uint8_t sesflags,uint32_t inode,uint8_t opened,uint32_t uid,uint32_t gid,uint32_t auid,uint32_t agid,uint64_t length,uint8_t attr[35],uint64_t *chunkid);
uint8_t fs_trunc(uint32_t ts,uint32_t inode,uint32_t indx,uint64_t chunkid);
uint8_t fs_end_setlength(uint64_t chunkid);
uint8_t fs_unlock(uint64_t chunkid);
uint8_t fs_do_setlength(uint32_t rootinode,uint8_t sesflags,uint32_t inode,uint32_t uid,uint32_t gid,uint32_t auid,uint32_t agid,uint64_t length,uint8_t attr[35]);
uint8_t fs_setattr(uint32_t rootinode,uint8_t sesflags,uint32_t inode,uint32_t uid,uint32_t gid,uint32_t auid,uint32_t agid,uint8_t setmask,uint16_t attrmode,uint32_t attruid,uint32_t attrgid,uint32_t attratime,uint32_t attrmtime,uint8_t attr[35]);
uint8_t fs_attr(uint32_t ts,uint32_t inode,uint32_t mode,uint32_t uid,uint32_t gid,uint32_t atime,uint32_t mtime);
uint8_t fs_length(uint32_t ts,uint32_t inode,uint64_t length);
uint8_t fs_readlink(uint32_t rootinode,uint8_t sesflags,uint32_t inode,uint32_t *pleng,uint8_t **path);
uint8_t fs_symlink(uint32_t ts,uint32_t parent,uint32_t nleng,const uint8_t *name,const uint8_t *path,uint32_t uid,uint32_t gid,uint32_t inode);
uint8_t fs_mknod(uint32_t rootinode,uint8_t sesflags,uint32_t parent,uint16_t nleng,const uint8_t *name,uint8_t type,uint16_t mode,uint32_t uid,uint32_t gid,uint32_t auid,uint32_t agid,uint32_t rdev,uint32_t *inode,uint8_t attr[35]);
uint8_t fs_mkdir(uint32_t rootinode,uint8_t sesflags,uint32_t parent,uint16_t nleng,const uint8_t *name,uint16_t mode,uint32_t uid,uint32_t gid,uint32_t auid,uint32_t agid,uint32_t *inode,uint8_t attr[35]);
uint8_t fs_create(uint32_t ts,uint32_t parent,uint32_t nleng,const uint8_t *name,uint8_t type,uint32_t mode,uint32_t uid,uint32_t gid,uint32_t rdev,uint32_t inode);
uint8_t fs_unlink(uint32_t rootinode,uint8_t sesflags,uint32_t parent,uint16_t nleng,const uint8_t *name,uint32_t uid,uint32_t gid);
uint8_t fs_rmdir(uint32_t rootinode,uint8_t sesflags,uint32_t parent,uint16_t nleng,const uint8_t *name,uint32_t uid,uint32_t gid);
uint8_t fs_unlink(uint32_t ts,uint32_t parent,uint32_t nleng,const uint8_t *name,uint32_t inode);
uint8_t fs_move(uint32_t ts,uint32_t parent_src,uint32_t nleng_src,const uint8_t *name_src,uint32_t parent_dst,uint32_t nleng_dst,const uint8_t *name_dst,uint32_t inode);
uint8_t fs_link(uint32_t ts,uint32_t inode_src,uint32_t parent_dst,uint32_t nleng_dst,uint8_t *name_dst);
uint8_t fs_snapshot(uint32_t ts,uint32_t inode_src,uint32_t parent_dst,uint16_t nleng_dst,uint8_t *name_dst,uint8_t canoverwrite);
uint8_t fs_append(uint32_t ts,uint32_t inode,uint32_t inode_src);
uint8_t fs_readdir_size(uint32_t rootinode,uint8_t sesflags,uint32_t inode,uint32_t uid,uint32_t gid,uint8_t flags,void **dnode,uint32_t *dbuffsize);
void fs_readdir_data(uint32_t rootinode,uint8_t sesflags,uint32_t uid,uint32_t gid,uint32_t auid,uint32_t agid,uint8_t flags,void *dnode,uint8_t *dbuff);
uint8_t fs_checkfile(uint32_t rootinode,uint8_t sesflags,uint32_t inode,uint16_t chunkcount[256]);
uint8_t fs_opencheck(uint32_t rootinode,uint8_t sesflags,uint32_t inode,uint32_t uid,uint32_t gid,uint32_t auid,uint32_t agid,uint8_t flags,uint8_t attr[35]);
uint8_t fs_aquire(uint32_t inode,uint32_t sessionid);
uint8_t fs_release(uint32_t inode,uint32_t sessionid);
uint32_t fs_newsessionid(void);
uint8_t fs_session(uint32_t sessionid);
uint8_t fs_readchunk(uint32_t inode,uint32_t indx,uint64_t *chunkid,uint64_t *length);
uint8_t fs_writechunk(uint32_t inode,uint32_t indx,uint64_t *chunkid,uint64_t *length,uint8_t *opflag);
uint8_t fs_write(uint32_t ts,uint32_t inode,uint32_t indx,uint8_t opflag,uint64_t chunkid);
uint8_t fs_writeend(uint32_t inode,uint64_t length,uint64_t chunkid);
void fs_incversion(uint64_t chunkid);
uint8_t fs_incversion(uint64_t chunkid);
uint8_t fs_repair(uint32_t rootinode,uint8_t sesflags,uint32_t inode,uint32_t uid,uint32_t gid,uint32_t *notchanged,uint32_t *erased,uint32_t *repaired);
uint8_t fs_repair(uint32_t ts,uint32_t inode,uint32_t indx,uint32_t nversion);
uint8_t fs_getgoal(uint32_t rootinode,uint8_t sesflags,uint32_t inode,uint8_t gmode,uint32_t fgtab[10],uint32_t dgtab[10]);
uint8_t fs_getlevelgoal(uint32_t rootinode,uint8_t sesflags,uint32_t inode,uint8_t gmode,uint32_t fgtab[40],uint32_t dgtab[40]);
uint8_t fs_gettrashtime_prepare(uint32_t rootinode,uint8_t sesflags,uint32_t inode,uint8_t gmode,void **fptr,void **dptr,uint32_t *fnodes,uint32_t *dnodes);
void fs_gettrashtime_store(void *fptr,void *dptr,uint8_t *buff);
uint8_t fs_geteattr(uint32_t rootinode,uint8_t sesflags,uint32_t inode,uint8_t gmode,uint32_t feattrtab[16],uint32_t deattrtab[16]);
uint8_t fs_setgoal(uint32_t ts,uint32_t inode,uint32_t uid,uint8_t goal,uint8_t smode,uint32_t sinodes,uint32_t ncinodes,uint32_t nsinodes/*,uint32_t qeinodes*/);
uint8_t fs_setlevelgoal(uint32_t ts,uint32_t inode,uint32_t uid,uint8_t level,uint8_t goal,uint8_t smode,uint32_t sinodes,uint32_t ncinodes,uint32_t nsinodes/*,uint32_t qeinodes*/);
uint8_t fs_settrashtime(uint32_t ts,uint32_t inode,uint32_t uid,uint32_t trashtime,uint8_t smode,uint32_t sinodes,uint32_t ncinodes,uint32_t nsinodes);
uint8_t fs_seteattr(uint32_t ts,uint32_t inode,uint32_t uid,uint8_t eattr,uint8_t smode,uint32_t sinodes,uint32_t ncinodes,uint32_t nsinodes);
uint8_t fs_quotacontrol(uint32_t rootinode,uint8_t sesflags,uint32_t inode,uint8_t delflag,uint8_t *flags,uint32_t *sinodes,uint64_t *slength,uint64_t *ssize,uint64_t *srealsize,uint32_t *hinodes,uint64_t *hlength,uint64_t *hsize,uint64_t *hrealsize,uint32_t *curinodes,uint64_t *curlength,uint64_t *cursize,uint64_t *currealsize);
uint32_t fs_getquotainfo_size();
void fs_getquotainfo_data(uint8_t * buff);
uint32_t fs_getdirpath_size(uint32_t inode);
void fs_getdirpath_data(uint32_t inode,uint8_t *buff,uint32_t size);
uint8_t fs_get_dir_stats(uint32_t rootinode,uint8_t sesflags,uint32_t inode,uint32_t *inodes,uint32_t *dirs,uint32_t *files,uint32_t *chunks,uint64_t *length,uint64_t *size,uint64_t *rsize);
void fs_add_files_to_chunks();
void fs_test_getdata(uint32_t *loopstart,uint32_t *loopend,uint32_t *files,uint32_t *ugfiles,uint32_t *mfiles,uint32_t *chunks,uint32_t *ugchunks,uint32_t *mchunks,char **msgbuff,uint32_t *msgbuffleng);
uint32_t fs_test_log_inconsistency(fsedge *e,const char *iname,char *buff,uint32_t size);
uint8_t fs_emptytrash(uint32_t ts,uint32_t freeinodes,uint32_t reservedinodes);
uint8_t fs_emptyreserved(uint32_t ts,uint32_t freeinodes);
uint64_t fs_getversion();
void fs_dumpedge(fsedge *e);
void fs_dumpnode(fsnode *f);
void fs_dumpnodes();
void fs_dumpedgelist(fsedge *e);
void fs_dumpedges(fsnode *f);
void fs_dumpfree();
void fs_dump(void);
void fs_storeedge(fsedge *e,FILE *fd);
int fs_loadedge(FILE *fd);
void fs_storenode(fsnode *f,FILE *fd);
void fs_storenodes(FILE *fd);
void fs_storeedgelist(fsedge *e,FILE *fd);
void fs_storeedges_rec(fsnode *f,FILE *fd);
void fs_storeedges(FILE *fd);
int fs_lostnode(fsnode *p);
int fs_checknodes();
int fs_loadnodes(FILE *fd);
int fs_loadedges(FILE *fd);
void fs_storefree(FILE *fd);
int fs_loadfree(FILE *fd);
void fs_store(FILE *fd);
int fs_loadnode_with_levelgoal(FILE *fd);
int fs_loadnodes_with_levelgoal(FILE *fd);
int fs_load_with_levelgoal(FILE *fd);
void fs_storenode_with_levelgoal(fsnode *f,FILE *fd);
void fs_storenodes_with_levelgoal(FILE *fd);
void fs_store_with_levelgoal(FILE *fd);
uint64_t fs_loadversion(FILE *fd);
int fs_load(FILE *fd);
void fs_new(void);
int fs_emergency_storeall(const char *fname);
int fs_emergency_saves();
void fs_dostoreall(void);
void fs_term(void);
void fs_storeall(const char *fname);
void fs_term(const char *fname);
int fs_loadall(void);
void fs_strinit(void);
void fs_cs_disconnected(void);
int fs_init(void);
int fs_init(const char *fname);
| 41ffb56c3e6daf46c18d6284c0b789b667842615f628aba9ec00b0204ffdc702 | 3,577 |
|
ialexyi | ATE | DRIVERs__PowerSupply__Lambda_Gen/GenPSie.c | GenPSie_selfTest |
ViStatus _VI_FUNC GenPSie_selfTest (ViSession instrSession, ViPInt16 testResult,
ViChar _VI_FAR testMessage[])
{
ViStatus GenPSie_status = VI_SUCCESS;
ViChar retStr [BUFFER_SIZE];
ViUInt32 retCnt;
GenPSie_status = GenPSie_readQry (instrSession, "*TST?", retStr, &retCnt);
if (GenPSie_status != VI_SUCCESS) return (GenPSie_status);
if ( 0 == strcmp ("0", retStr)) {
strcpy (testMessage, "Self-test passed");
*testResult = 0;
}
else {
strcpy (testMessage, "Self-test failed");
*testResult = -1;
}
return (GenPSie_status);
} |
ViStatus _VI_FUNC GenPSie_sendCmd (ViSession instrSession, ViString cmdString);
ViStatus _VI_FUNC GenPSie_close (ViSession instrSession);
ViStatus _VI_FUNC GenPSie_setOvpMaxLevel (ViSession instrSession);
ViStatus _VI_FUNC GenPSie_reset (ViSession instrSession);
ViStatus _VI_FUNC GenPSie_saveSettings (ViSession instrSession);
ViStatus _VI_FUNC GenPSie_recallSettings (ViSession instrSession);
ViStatus GenPSie_convertErrNumb (ViInt32 systErr);
ViBoolean GenPSie_invalidViBooleanRange (ViBoolean val);
ViBoolean GenPSie_invalidViInt16Range (ViInt16 val, ViInt16 min, ViInt16 max);
ViBoolean GenPSie_invalidViInt32Range (ViInt32 val, ViInt32 min, ViInt32 max);
ViBoolean GenPSie_invalidViUInt8Range (ViUInt8 val, ViUInt8 min, ViUInt8 max);
ViBoolean GenPSie_invalidViUInt16Range (ViUInt16 val, ViUInt16 min, ViUInt16 max);
ViBoolean GenPSie_invalidViUInt32Range (ViUInt32 val, ViUInt32 min, ViUInt32 max);
ViBoolean GenPSie_invalidViReal32Range (ViReal32 val, ViReal32 min, ViReal32 max);
ViBoolean GenPSie_invalidViReal64Range (ViReal64 val, ViReal64 min, ViReal64 max);
ViStatus _VI_FUNC GenPSie_STB (ViSession instrSession, ViUInt16* spollByte);
void GenPSie_waitMS (ViUInt16 mSecWait);
ViStatus GenPSie_defaultInstrSetup (ViSession instrSession);
| 1296c6f6351d80ea37a61baacfff2b7b96b9a3c444b771febf44c848e41aa362 | 721 |
|
Rajesh-Sec-Project | simon | hard.d/leds_board/soft/drivers/src_peripherals/stm32f10x_tim.c | TIM_SetIC1Prescaler |
void TIM_SetIC1Prescaler(TIM_TypeDef* TIMx, uint16_t TIM_ICPSC) {
assert_param(IS_TIM_LIST8_PERIPH(TIMx));
assert_param(IS_TIM_IC_PRESCALER(TIM_ICPSC));
TIMx->CCMR1 &= (uint16_t) ~((uint16_t)TIM_CCMR1_IC1PSC);
TIMx->CCMR1 |= TIM_ICPSC;
} |
void TIM_DeInit(TIM_TypeDef* TIMx);
void TIM_TimeBaseInit(TIM_TypeDef* TIMx, TIM_TimeBaseInitTypeDef* TIM_TimeBaseInitStruct);
void TIM_OC1Init(TIM_TypeDef* TIMx, TIM_OCInitTypeDef* TIM_OCInitStruct);
void TIM_OC2Init(TIM_TypeDef* TIMx, TIM_OCInitTypeDef* TIM_OCInitStruct);
void TIM_OC3Init(TIM_TypeDef* TIMx, TIM_OCInitTypeDef* TIM_OCInitStruct);
void TIM_OC4Init(TIM_TypeDef* TIMx, TIM_OCInitTypeDef* TIM_OCInitStruct);
void TIM_ICInit(TIM_TypeDef* TIMx, TIM_ICInitTypeDef* TIM_ICInitStruct);
void TIM_PWMIConfig(TIM_TypeDef* TIMx, TIM_ICInitTypeDef* TIM_ICInitStruct);
void TIM_BDTRConfig(TIM_TypeDef* TIMx, TIM_BDTRInitTypeDef* TIM_BDTRInitStruct);
void TIM_TimeBaseStructInit(TIM_TimeBaseInitTypeDef* TIM_TimeBaseInitStruct);
void TIM_OCStructInit(TIM_OCInitTypeDef* TIM_OCInitStruct);
void TIM_ICStructInit(TIM_ICInitTypeDef* TIM_ICInitStruct);
void TIM_BDTRStructInit(TIM_BDTRInitTypeDef* TIM_BDTRInitStruct);
void TIM_Cmd(TIM_TypeDef* TIMx, FunctionalState NewState);
void TIM_CtrlPWMOutputs(TIM_TypeDef* TIMx, FunctionalState NewState);
void TIM_ITConfig(TIM_TypeDef* TIMx, uint16_t TIM_IT, FunctionalState NewState);
void TIM_GenerateEvent(TIM_TypeDef* TIMx, uint16_t TIM_EventSource);
void TIM_DMAConfig(TIM_TypeDef* TIMx, uint16_t TIM_DMABase, uint16_t TIM_DMABurstLength);
void TIM_DMACmd(TIM_TypeDef* TIMx, uint16_t TIM_DMASource, FunctionalState NewState);
void TIM_InternalClockConfig(TIM_TypeDef* TIMx);
void TIM_ITRxExternalClockConfig(TIM_TypeDef* TIMx, uint16_t TIM_InputTriggerSource);
void TIM_TIxExternalClockConfig(TIM_TypeDef* TIMx, uint16_t TIM_TIxExternalCLKSource, uint16_t TIM_ICPolarity, uint16_t ICFilter);
void TIM_ETRClockMode1Config(TIM_TypeDef* TIMx, uint16_t TIM_ExtTRGPrescaler, uint16_t TIM_ExtTRGPolarity, uint16_t ExtTRGFilter);
void TIM_ETRClockMode2Config(TIM_TypeDef* TIMx, uint16_t TIM_ExtTRGPrescaler, uint16_t TIM_ExtTRGPolarity, uint16_t ExtTRGFilter);
void TIM_ETRConfig(TIM_TypeDef* TIMx, uint16_t TIM_ExtTRGPrescaler, uint16_t TIM_ExtTRGPolarity, uint16_t ExtTRGFilter);
void TIM_PrescalerConfig(TIM_TypeDef* TIMx, uint16_t Prescaler, uint16_t TIM_PSCReloadMode);
void TIM_CounterModeConfig(TIM_TypeDef* TIMx, uint16_t TIM_CounterMode);
void TIM_SelectInputTrigger(TIM_TypeDef* TIMx, uint16_t TIM_InputTriggerSource);
void TIM_EncoderInterfaceConfig(TIM_TypeDef* TIMx, uint16_t TIM_EncoderMode, uint16_t TIM_IC1Polarity, uint16_t TIM_IC2Polarity);
void TIM_ForcedOC1Config(TIM_TypeDef* TIMx, uint16_t TIM_ForcedAction);
void TIM_ForcedOC2Config(TIM_TypeDef* TIMx, uint16_t TIM_ForcedAction);
void TIM_ForcedOC3Config(TIM_TypeDef* TIMx, uint16_t TIM_ForcedAction);
void TIM_ForcedOC4Config(TIM_TypeDef* TIMx, uint16_t TIM_ForcedAction);
void TIM_ARRPreloadConfig(TIM_TypeDef* TIMx, FunctionalState NewState);
void TIM_SelectCOM(TIM_TypeDef* TIMx, FunctionalState NewState);
void TIM_SelectCCDMA(TIM_TypeDef* TIMx, FunctionalState NewState);
void TIM_CCPreloadControl(TIM_TypeDef* TIMx, FunctionalState NewState);
void TIM_OC1PreloadConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPreload);
void TIM_OC2PreloadConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPreload);
void TIM_OC3PreloadConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPreload);
void TIM_OC4PreloadConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPreload);
void TIM_OC1FastConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCFast);
void TIM_OC2FastConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCFast);
void TIM_OC3FastConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCFast);
void TIM_OC4FastConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCFast);
void TIM_ClearOC1Ref(TIM_TypeDef* TIMx, uint16_t TIM_OCClear);
void TIM_ClearOC2Ref(TIM_TypeDef* TIMx, uint16_t TIM_OCClear);
void TIM_ClearOC3Ref(TIM_TypeDef* TIMx, uint16_t TIM_OCClear);
void TIM_ClearOC4Ref(TIM_TypeDef* TIMx, uint16_t TIM_OCClear);
void TIM_OC1PolarityConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPolarity);
void TIM_OC1NPolarityConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCNPolarity);
void TIM_OC2PolarityConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPolarity);
void TIM_OC2NPolarityConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCNPolarity);
void TIM_OC3PolarityConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPolarity);
void TIM_OC3NPolarityConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCNPolarity);
void TIM_OC4PolarityConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPolarity);
void TIM_CCxCmd(TIM_TypeDef* TIMx, uint16_t TIM_Channel, uint16_t TIM_CCx);
void TIM_CCxNCmd(TIM_TypeDef* TIMx, uint16_t TIM_Channel, uint16_t TIM_CCxN);
void TIM_SelectOCxM(TIM_TypeDef* TIMx, uint16_t TIM_Channel, uint16_t TIM_OCMode);
void TIM_UpdateDisableConfig(TIM_TypeDef* TIMx, FunctionalState NewState);
void TIM_UpdateRequestConfig(TIM_TypeDef* TIMx, uint16_t TIM_UpdateSource);
void TIM_SelectHallSensor(TIM_TypeDef* TIMx, FunctionalState NewState);
void TIM_SelectOnePulseMode(TIM_TypeDef* TIMx, uint16_t TIM_OPMode);
void TIM_SelectOutputTrigger(TIM_TypeDef* TIMx, uint16_t TIM_TRGOSource);
void TIM_SelectSlaveMode(TIM_TypeDef* TIMx, uint16_t TIM_SlaveMode);
void TIM_SelectMasterSlaveMode(TIM_TypeDef* TIMx, uint16_t TIM_MasterSlaveMode);
void TIM_SetCounter(TIM_TypeDef* TIMx, uint16_t Counter);
void TIM_SetAutoreload(TIM_TypeDef* TIMx, uint16_t Autoreload);
void TIM_SetCompare1(TIM_TypeDef* TIMx, uint16_t Compare1);
void TIM_SetCompare2(TIM_TypeDef* TIMx, uint16_t Compare2);
void TIM_SetCompare3(TIM_TypeDef* TIMx, uint16_t Compare3);
void TIM_SetCompare4(TIM_TypeDef* TIMx, uint16_t Compare4);
void TIM_SetIC2Prescaler(TIM_TypeDef* TIMx, uint16_t TIM_ICPSC);
void TIM_SetIC3Prescaler(TIM_TypeDef* TIMx, uint16_t TIM_ICPSC);
void TIM_SetIC4Prescaler(TIM_TypeDef* TIMx, uint16_t TIM_ICPSC);
void TIM_SetClockDivision(TIM_TypeDef* TIMx, uint16_t TIM_CKD);
uint16_t TIM_GetCapture1(TIM_TypeDef* TIMx);
uint16_t TIM_GetCapture2(TIM_TypeDef* TIMx);
uint16_t TIM_GetCapture3(TIM_TypeDef* TIMx);
uint16_t TIM_GetCapture4(TIM_TypeDef* TIMx);
uint16_t TIM_GetCounter(TIM_TypeDef* TIMx);
uint16_t TIM_GetPrescaler(TIM_TypeDef* TIMx);
FlagStatus TIM_GetFlagStatus(TIM_TypeDef* TIMx, uint16_t TIM_FLAG);
void TIM_ClearFlag(TIM_TypeDef* TIMx, uint16_t TIM_FLAG);
ITStatus TIM_GetITStatus(TIM_TypeDef* TIMx, uint16_t TIM_IT);
void TIM_ClearITPendingBit(TIM_TypeDef* TIMx, uint16_t TIM_IT);
static void TI1_Config(TIM_TypeDef* TIMx, uint16_t TIM_ICPolarity, uint16_t TIM_ICSelection, uint16_t TIM_ICFilter);
static void TI2_Config(TIM_TypeDef* TIMx, uint16_t TIM_ICPolarity, uint16_t TIM_ICSelection, uint16_t TIM_ICFilter);
static void TI3_Config(TIM_TypeDef* TIMx, uint16_t TIM_ICPolarity, uint16_t TIM_ICSelection, uint16_t TIM_ICFilter);
static void TI4_Config(TIM_TypeDef* TIMx, uint16_t TIM_ICPolarity, uint16_t TIM_ICSelection, uint16_t TIM_ICFilter);
| 0ed82c58a9a510bf4a3f5c49d1e90cb56779aba96e047a0f5b9ebb119e0a0d81 | 272 |
|
wayling | xboot-clone | src/arch/arm/mach-mid560/driver/s3c6410-mmc.c | ClearCommandCompleteStatus |
static void ClearCommandCompleteStatus(void)
{
writew(S3C6410_HM_NORINTSTS1, 1 << 0);
while (readw(S3C6410_HM_NORINTSTS1) & 0x1) {
writew(S3C6410_HM_NORINTSTS1, 1 << 0);
}
} |
static void set_cmd_register (u16_t cmd, u32_t data, u32_t flags);
static int wait_for_cmd_done (void);
static void ClearErrInterruptStatus(void);
static void InterruptEnable(u16_t NormalIntEn, u16_t ErrorIntEn);
static void set_hostctl_speed (u8_t mode);
static void hsmmc_clock_onoff(bool_t on);
static void set_clock (u32_t clksrc, u32_t div);
static int issue_command (u16_t cmd, u32_t arg, u32_t data, u32_t flags);
static int set_mmc_ocr (void);
static int set_sd_ocr (void);
static void display_card_info (void);
static void mmc_init(void);
static __init void s3c6410_mmc_init(void);
static __exit void s3c6410_mmc_exit(void);
| 53583daeff6b093b0ed9bc3cefe4db9a8130578e115bcbef5a066332c4c9630e | 179 |
|
Cabalist | Mycodo | 2.0/mycodo/source/mycodo-1.7.c | CheckTemp |
int CheckTemp (void)
{
if ( temp < minTemp )
{
tempState = 1;
printf("< minTemp. Heat On.");
}
else if ( temp >= minTemp && temp < maxTemp)
{
tempState = 2;
printf(">= minTemp. Heat off until < minTemp.");
}
else if ( temp >= highTemp )
{
tempState = 3;
printf("> highTemp. Heat Off, All fans On.");
}
else
{
if ( tempState == 2 ) printf("Heat off until < minTemp.");
else printf("Heat on until > minTemp.");
return;
}
writeCfg();
return 0;
} |
int main( int argc, char *argv[] );
int readCfg (void);
int writeCfg (void);
int CheckHum (void);
int ChangeRelays (double tdiff, double hdiff);
| 8b3001cdcb5f48ed486f17d70b7ad2bb2e546a98b833f352f9aedcdde10241bd | 477 |
|
dduval | kernel-rhel4 | drivers/xen/xenbus/xenbus_probe.c | exists_disconnected_device |
static int exists_disconnected_device(struct device_driver *drv)
{
if (xenbus_frontend.error)
return xenbus_frontend.error;
return bus_for_each_dev(&xenbus_frontend.bus, NULL, drv,
is_disconnected_device);
} |
static int xenbus_match(struct device *_dev, struct device_driver *_drv);
static int frontend_bus_id(char bus_id[BUS_ID_SIZE], const char *nodename);
static void free_otherend_details(struct xenbus_device *dev);
static void free_otherend_watch(struct xenbus_device *dev);
static int read_backend_details(struct xenbus_device *xendev);
static int read_frontend_details(struct xenbus_device *xendev);
static int backend_bus_id(char bus_id[BUS_ID_SIZE], const char *nodename);
static int talk_to_otherend(struct xenbus_device *dev);
static int watch_otherend(struct xenbus_device *dev);
static int xenbus_dev_probe(struct device *_dev);
static int xenbus_dev_remove(struct device *_dev);
static void xenbus_dev_shutdown(struct device *_dev);
int xenbus_register_frontend(struct xenbus_driver *drv);
int xenbus_register_backend(struct xenbus_driver *drv);
void xenbus_unregister_driver(struct xenbus_driver *drv);
static int cmp_dev(struct device *dev, void *data);
static int cleanup_dev(struct device *dev, void *data);
static void xenbus_cleanup_devices(const char *path, struct bus_type *bus);
static void xenbus_dev_release(struct device *dev);
char *kasprintf(gfp_t gfp, const char *fmt, ...);
static ssize_t xendev_show_nodename(struct device *dev, char *buf);
static ssize_t xendev_show_devtype(struct device *dev, char *buf);
static int xenbus_probe_frontend(const char *type, const char *name);
static int xenbus_probe_backend(const char *type, const char *domid);
static int xenbus_probe_device_type(struct xen_bus_type *bus, const char *type);
static int xenbus_probe_devices(struct xen_bus_type *bus);
static unsigned int char_count(const char *str, char c);
static int strsep_len(const char *str, char c, unsigned int len);
static void dev_changed(const char *node, struct xen_bus_type *bus);
static int suspend_dev(struct device *dev, void *data);
static int suspend_cancel_dev(struct device *dev, void *data);
static int resume_dev(struct device *dev, void *data);
void xenbus_suspend(void);
void xenbus_resume(void);
void xenbus_suspend_cancel(void);
int register_xenstore_notifier(struct notifier_block *nb);
void unregister_xenstore_notifier(struct notifier_block *nb);
static int all_devices_ready_(struct device *dev, void *data);
static int all_devices_ready(void);
void xenbus_probe(void *unused);
static int xsd_kva_mmap(struct file *file, struct vm_area_struct *vma);
static int __init xenbus_probe_init(void);
int xenbus_init(void);
static int is_disconnected_device(struct device *dev, void *data);
static int print_device_status(struct device *dev, void *data);
static void wait_for_devices(struct xenbus_driver *xendrv);
static int __init boot_wait_for_devices(void);
| a9d477ab392f8d1bd3586ea11e83c3b689c7706f7079d7533a48e69f9d8a5973 | 237 |
|
jcmcclurg | serverpower | unused/transcoders/libav-11.4/libavcodec/libgsmenc.c | libgsm_encode_init |
static av_cold int libgsm_encode_init(AVCodecContext *avctx) {
if (avctx->channels > 1) {
av_log(avctx, AV_LOG_ERROR, "Mono required for GSM, got %d channels\n",
avctx->channels);
return -1;
}
if (avctx->sample_rate != 8000) {
av_log(avctx, AV_LOG_ERROR, "Sample rate 8000Hz required for GSM, got %dHz\n",
avctx->sample_rate);
if (avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL)
return -1;
}
if (avctx->bit_rate != 13000
&&
avctx->bit_rate != 13200
&&
avctx->bit_rate != 0
) {
av_log(avctx, AV_LOG_ERROR, "Bitrate 13000bps required for GSM, got %dbps\n",
avctx->bit_rate);
if (avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL)
return -1;
}
avctx->priv_data = gsm_create();
switch(avctx->codec_id) {
case AV_CODEC_ID_GSM:
avctx->frame_size = GSM_FRAME_SIZE;
avctx->block_align = GSM_BLOCK_SIZE;
break;
case AV_CODEC_ID_GSM_MS: {
int one = 1;
gsm_option(avctx->priv_data, GSM_OPT_WAV49, &one);
avctx->frame_size = 2*GSM_FRAME_SIZE;
avctx->block_align = GSM_MS_BLOCK_SIZE;
}
}
return 0;
} |
static av_cold int libgsm_encode_close(AVCodecContext *avctx);
| 4280c5bd0493b2b452c9609a1f589132f4488b48773014755ac124966d6b0fc3 | 1,257 |
|
Denshikobo-Life | bcmlib_for_java | common/bi_common.c | dump_buff |
void dump_buff(void)
{
int i;
printf("pid=%d ",pid);
printf("w_buff=%08x wp=%d rp=%d \n",w_buff,w_buff->wp,w_buff->rp);
printf("r_buff=%08x wp=%d rp=%d \n",r_buff,r_buff->wp,r_buff->rp);
for( i=0;i<wp;i++)
{
printf("%02x ",buff[i]);
}
printf(" \n");
} |
int calc_data_size( struct ring_buff *rb);
int calc_rest_size( struct ring_buff *rb);
int put_ring_buff(struct ring_buff *rb, char *str, int len );
int get_ring_buff(struct ring_buff *rb, char *buff, int max_len);
void init_ring_buff(struct ring_buff *rb, int init_type);
void set_ope_code( unsigned char ope_code);
void set_byte_code( unsigned char code);
void set_short_code( short int code );
void set_int_code( int code);
void set_long_code( long code);
void get_ope_code( void );
void get_byte_code( void );
void get_short_code( void );
void get_int_code( void );
void get_long_code( void );
void copy_str( char *dest, char* src, int len);
int context_switch( int max_count);
| 4325995241b02a6400c685184af2d677efbf547f8ce2868fd7d60ca92e5b2c82 | 291 |
|
scs | uclinux | user/blkfin-apps/vlc/vlc-0.8.6b/src/playlist/playlist.c | playlist_PreparseEnqueueItem | int playlist_PreparseEnqueueItem( playlist_t *p_playlist,
playlist_item_t *p_item )
{
vlc_mutex_lock( &p_playlist->object_lock );
vlc_mutex_lock( &p_playlist->p_preparse->object_lock );
playlist_PreparseEnqueueItemSub( p_playlist, p_item );
vlc_mutex_unlock( &p_playlist->p_preparse->object_lock );
vlc_mutex_unlock( &p_playlist->object_lock );
return VLC_SUCCESS;
}
| playlist_item_t *playlist_RecursiveFindLast(playlist_t *p_playlist,
playlist_item_t *p_node );
playlist_t * __playlist_Create ( vlc_object_t *p_parent );
int playlist_Destroy( playlist_t * p_playlist );
int playlist_LockControl( playlist_t * p_playlist, int i_query, ... );
int playlist_Control( playlist_t * p_playlist, int i_query, ... );
int playlist_vaControl( playlist_t * p_playlist, int i_query, va_list args );
int playlist_PreparseEnqueue( playlist_t *p_playlist,
input_item_t *p_item );
void playlist_PreparseEnqueueItemSub( playlist_t *p_playlist,
playlist_item_t *p_item );
static mtime_t ObjectGarbageCollector( playlist_t *p_playlist, int i_type,
mtime_t destroy_date );
static void RunThread ( playlist_t *p_playlist );
static void RunPreparse ( playlist_preparse_t *p_obj );
static playlist_item_t * NextItem( playlist_t *p_playlist );
static int PlayItem( playlist_t *p_playlist, playlist_item_t *p_item );
| 3ceb705c71b926b097fbe56e6c3d9f13b1ea60ccd4029afccde7c217c990b94c | 425 |
|
sisuani | iaxclient | lib/libiax2/src/iax.c | iax_enable_jitterbuffer |
void iax_enable_jitterbuffer(void)
{
iax_use_jitterbuffer = 1;
} |
void iax_enable_debug(void);
void iax_disable_debug(void);
void iax_disable_jitterbuffer(void);
void iax_set_private(struct iax_session *s, void *ptr);
void *iax_get_private(struct iax_session *s);
void iax_set_sendto(struct iax_session *s, iax_sendto_t ptr);
static int __debug(const char *file, int lineno, const char *fmt, ...);
static int __debug(const char *file, int lineno, const char *func, const char *fmt, ...);
void iax_seed_random();
int iax_random();
unsigned int iax_session_get_capability(struct iax_session *s);
static int inaddrcmp(struct sockaddr_in *sin1, struct sockaddr_in *sin2);
static int iax_sched_add(struct iax_event *event, struct iax_frame *frame, sched_func func, void *arg, int ms);
static int iax_sched_del(struct iax_event *event, struct iax_frame *frame, sched_func func, void *arg, int all);
int iax_time_to_next_event(void);
struct iax_session *iax_session_new(void);
static int iax_session_valid(struct iax_session *session);
int iax_get_netstats(struct iax_session *session, int *rtt, struct iax_netstat *local, struct iax_netstat *remote);
static void add_ms(struct timeval *tv, int ms);
static int calc_timestamp(struct iax_session *session, unsigned int ts, struct ast_frame *f);
static unsigned char get_n_bits_at(unsigned char *data, int n, int bit);
static int speex_get_wb_sz_at(unsigned char *data, int len, int bit);
static int speex_get_samples(unsigned char *data, int len);
static inline int get_interp_len(int format);
static int get_sample_cnt(struct iax_event *e);
static int iax_xmit_frame(struct iax_frame *f);
static int iax_reliable_xmit(struct iax_frame *f);
void iax_set_networking(iax_sendto_t st, iax_recvfrom_t rf);
void iax_set_jb_target_extra( long value );
int iax_init(int preferredportno);
| e1572771bbda6c49fdb68524da23c6bcde97e66275a14b7918cbeb6b9227691d | 66 |
|
danielgpalmer | linux-picosam9g45 | sound/usb/pcm.c | snd_usb_pcm_pointer |
static snd_pcm_uframes_t snd_usb_pcm_pointer(struct snd_pcm_substream *substream)
{
struct snd_usb_substream *subs;
unsigned int hwptr_done;
subs = (struct snd_usb_substream *)substream->runtime->private_data;
spin_lock(&subs->lock);
hwptr_done = subs->hwptr_done;
substream->runtime->delay = snd_usb_pcm_delay(subs,
substream->runtime->rate);
spin_unlock(&subs->lock);
return hwptr_done / (substream->runtime->frame_bits >> 3);
} |
static int start_endpoints(struct snd_usb_substream *subs);
static int activate_endpoints(struct snd_usb_substream *subs);
static int deactivate_endpoints(struct snd_usb_substream *subs);
static int set_format(struct snd_usb_substream *subs, struct audioformat *fmt);
static int snd_usb_hw_free(struct snd_pcm_substream *substream);
static int snd_usb_pcm_prepare(struct snd_pcm_substream *substream);
static int setup_hw_info(struct snd_pcm_runtime *runtime, struct snd_usb_substream *subs);
static int snd_usb_pcm_open(struct snd_pcm_substream *substream, int direction);
static int snd_usb_pcm_close(struct snd_pcm_substream *substream, int direction);
static int snd_usb_playback_open(struct snd_pcm_substream *substream);
static int snd_usb_playback_close(struct snd_pcm_substream *substream);
static int snd_usb_capture_open(struct snd_pcm_substream *substream);
static int snd_usb_capture_close(struct snd_pcm_substream *substream);
int snd_usb_substream_capture_trigger(struct snd_pcm_substream *substream, int cmd);
void snd_usb_set_pcm_ops(struct snd_pcm *pcm, int stream);
| d0d80838d7dd0be7f246633816aa1af2fc9776908f2e95cd30ccb651e2503b3c | 446 |
|
bogus | mydlp-host-win32 | libclamav/scanners.c | cli_scanmschm |
static int cli_scanmschm(int desc, cli_ctx *ctx)
{
int ret = CL_CLEAN, rc;
chm_metadata_t metadata;
char *dir;
cli_dbgmsg("in cli_scanmschm()\n");
if(!(dir = cli_gentemp(ctx->engine->tmpdir)))
return CL_EMEM;
if(mkdir(dir, 0700)) {
cli_dbgmsg("CHM: Can't create temporary directory %s\n", dir);
free(dir);
return CL_ETMPDIR;
}
ret = cli_chm_open(desc, dir, &metadata, ctx);
if (ret != CL_SUCCESS) {
if(!ctx->engine->keeptmp)
cli_rmdirs(dir);
free(dir);
cli_dbgmsg("CHM: Error: %s\n", cl_strerror(ret));
return ret;
}
do {
ret = cli_chm_prepare_file(&metadata);
if (ret != CL_SUCCESS) {
break;
}
ret = cli_chm_extract_file(dir, &metadata, ctx);
if (ret == CL_SUCCESS) {
lseek(metadata.ofd, 0, SEEK_SET);
rc = cli_magic_scandesc(metadata.ofd, ctx);
close(metadata.ofd);
if (rc == CL_VIRUS) {
cli_dbgmsg("CHM: infected with %s\n",*ctx->virname);
ret = CL_VIRUS;
break;
}
}
} while(ret == CL_SUCCESS);
cli_chm_close(&metadata);
if(!ctx->engine->keeptmp)
cli_rmdirs(dir);
free(dir);
cli_dbgmsg("CHM: Exit code: %d\n", ret);
if (ret == CL_BREAK)
ret = CL_CLEAN;
return ret;
} |
static int cli_unrar_scanmetadata(int desc, unrar_metadata_t *metadata, cli_ctx *ctx, unsigned int files, uint32_t* sfx_check);
static int cli_scanrar(int desc, cli_ctx *ctx, off_t sfx_offset, uint32_t *sfx_check);
static int cli_scanarj(int desc, cli_ctx *ctx, off_t sfx_offset, uint32_t *sfx_check);
static int cli_scangzip_with_zib_from_the_80s(cli_ctx *ctx, unsigned char *buff);
static int cli_scangzip(cli_ctx *ctx);
static int cli_scanbzip(int desc, cli_ctx *ctx);
static int cli_scanbzip(int desc, cli_ctx *ctx);
static int cli_scanszdd(int desc, cli_ctx *ctx);
static int cli_scanmscab(int desc, cli_ctx *ctx, off_t sfx_offset);
static int cli_scanhtml(cli_ctx *ctx);
static int cli_scanscript(cli_ctx *ctx);
static int cli_scanhtml_utf16(cli_ctx *ctx);
static int cli_scanole2(cli_ctx *ctx);
static int cli_scanole2_structured(cli_ctx *ctx);
static int cli_scanpdf_structured(cli_ctx *ctx);
static int cli_scanps_structured(cli_ctx *ctx);
static int cli_scantar(int desc, cli_ctx *ctx, unsigned int posix);
static int cli_scanscrenc(int desc, cli_ctx *ctx);
static int cli_scanriff(int desc, cli_ctx *ctx);
static int cli_scanjpeg(int desc, cli_ctx *ctx);
static int cli_scancryptff(int desc, cli_ctx *ctx);
static int cli_scanpdf(cli_ctx *ctx, off_t offset);
static int cli_scantnef(int desc, cli_ctx *ctx);
static int cli_scanuuencoded(cli_ctx *ctx);
static int cli_scanmail(int desc, cli_ctx *ctx);
static int cli_scan_structured(int desc, cli_ctx *ctx);
static int cli_scanembpe(int desc, cli_ctx *ctx);
static int cli_scanraw(cli_ctx *ctx, cli_file_t type, uint8_t typercg, cli_file_t *dettype, unsigned char *refhash);
static void emax_reached(cli_ctx *ctx);
int cli_magic_scandesc(int desc, cli_ctx *ctx);
int cl_scandesc(int desc, const char **virname, unsigned long int *scanned, const struct cl_engine *engine, unsigned int scanoptions);
int cli_found_possibly_unwanted(cli_ctx* ctx);
static int cli_scanfile(const char *filename, cli_ctx *ctx);
int cl_scanfile(const char *filename, const char **virname, unsigned long int *scanned, const struct cl_engine *engine, unsigned int scanoptions);
| 8991e47ed1d6d67c38b212f6570940197b51f710ab0dfede1453024dc06cf404 | 1,209 |
|
execunix | vinos | gnu/dist/diffutils/src/context.c |
void
print_context_header |
void
print_context_header (struct file_data inf[], bool unidiff)
{
if (unidiff)
{
print_context_label ("---", &inf[0], file_label[0]);
print_context_label ("+++", &inf[1], file_label[1]);
}
else
{
print_context_label ("***", &inf[0], file_label[0]);
print_context_label ("---", &inf[1], file_label[1]);
}
} | 55e2ab3ec5a26df9c8e325374fc390d63b81a7a129c349c0a29f9db5d5d5e4db | 351 |
||
Alex-V2 | One_M8_4.4.3_kernel | drivers/media/platform/msm/camera_v2/sensor/actuator/LC898111/OisCmd.c | ;
if | UnDwdVal StTneVal, unsigned char UcTneAxs )
{
long SlSetBia ;
unsigned short UsSetBia ;
unsigned char UcChkFst ;
static unsigned short UsTneVax ;
UcChkFst = 1 ;
if ( UsStpSiz == 1) {
UsTneVax = 2 ;
if ( ( StTneVal.StDwdVal.UsHigVal + StTneVal.StDwdVal.UsLowVal ) / 2 < BIAS_ADJ_BORDER ) {
UcChkFst = 0 ;
}
if( ( UcTneAxs & 0xF0 ) && UcChkFst )
{
;
}else{
if ( !UcTneAxs ) {
RamWriteA( DAHLXB, 0x8001 ) ;
RamWriteA( DAHLXO, 0x0000 ) ;
UsStpSiz = BIAS_LIMIT / UsTneVax ;
} else {
RamWriteA( DAHLYB, 0x8001 ) ;
RamWriteA( DAHLYO, 0x0000 ) ;
UsStpSiz = BIAS_LIMIT / UsTneVax ;
}
}
}
if ( !( UcTneAxs & 0x0F ) ) {
RamReadA( DAHLXB, &UsSetBia ) ;
SlSetBia = ( long )UsSetBia ;
} else {
RamReadA( DAHLYB, &UsSetBia ) ;
SlSetBia = ( long )UsSetBia ;
}
if( SlSetBia > 0x00008000 ) {
SlSetBia |= 0xFFFF0000 ;
}
if( UcChkFst ) {
if( UcTneAxs & 0xF0 )
{
if ( ( StTneVal.StDwdVal.UsHigVal + StTneVal.StDwdVal.UsLowVal ) / 2 > BIAS_ADJ_BORDER ) {
SlSetBia += 0x0100 ;
} else {
SlSetBia -= 0x0100 ;
}
UsStpSiz = 0x0200 ;
}else{
if ( ( StTneVal.StDwdVal.UsHigVal + StTneVal.StDwdVal.UsLowVal ) / 2 > BIAS_ADJ_BORDER ) {
SlSetBia += UsStpSiz ;
} else {
SlSetBia -= UsStpSiz ;
}
UsTneVax = UsTneVax * 2 ;
UsStpSiz = BIAS_LIMIT / UsTneVax ;
}
}
if( SlSetBia > ( long )0x00007FFF ) {
SlSetBia = 0x00007FFF ;
} else if( SlSetBia < ( long )0xFFFF8001 ) {
SlSetBia = 0xFFFF8001 ;
}
if ( !( UcTneAxs & 0x0F ) ) {
RamWriteA( DAHLXB, SlSetBia ) ;
} else {
RamWriteA( DAHLYB, SlSetBia ) ;
}
StTneVal.UlDwdVal = TnePtp( UcTneAxs & 0x0F , PTP_AFTER ) ;
return( StTneVal.UlDwdVal ) ;
}
|
unsigned short TneRun( void );
unsigned long TnePtp ( unsigned char UcDirSel, unsigned char UcBfrAft );
unsigned char UcTneAxs, UnDwdVal StTneVal );
UnDwdVal StTneVal, unsigned char UcTneAxs );
char UcMesMod );
char UcDirSel, unsigned char UcSwcCon );
unsigned char UcDirSel );
char UcDirSel );
char UcDirSel );
char UcDirSel, unsigned char UcSonOff );
unsigned char UcDirSel );
BsyWit( DLYCLR2, 0xC0 );
unsigned char UcXg1Xg2 );
void );
riteA( GSHTON, 0x00 );
DIR, ON );
STR );
H1COEF_CHANGER
SetH1cMod( S2MODE );
);
p,X-amp,DAC,ADC Standby */
RegWriteA( PWMA, 0x00 );
oomStepDat > (ZOOMTBL - 1);
iteA( HXINOD , UsOptXval );
ÝèµÄ¾³¢@
// - RAM:1290h`12A8h (TCge[u);
0E3 [ SINXADD(7:0);
//==============================================================================
// Function : StopMeasFil();
/==============================================================================
// Function : LoopGainAdj();
( GYRO_GAIN_X, 4, ( unsigned char * );
0x0083 Linearâ³OFF
RegWriteA( LYEQFC2 , 0x00 );
Filter1 Equalizer ON
RegWriteA( MSF2EN, 0x01 );
gyl2b_2, MAXLMT );
| 7c8b50bb0ec6df1d1e22b183b68eb8d1a36b6eb27d4efa34bd02deb6bcee31e3 | 1,809 |
|
ryo-on | vmkdrivers-gpl | vmkdrivers/src_9/drivers/net/nx_nic/unm_nic_main.c | vlan_accel_setup |
static void vlan_accel_setup(struct unm_adapter_s *adapter,
struct net_device *netdev)
{
if (adapter->ahw.fw_capabilities_1 & NX_FW_CAPABILITY_FVLANTX) {
netdev->features |= NETIF_F_HW_VLAN_RX;
netdev->vlan_rx_register = nx_vlan_rx_register;
netdev->vlan_rx_kill_vid = nx_rx_kill_vid;
netdev->features |= NETIF_F_HW_VLAN_TX;
NX_NIC_TRC_FN(adapter, vlan_accel_setup, NX_FW_CAPABILITY_FVLANTX);
}
} |
U32 nx_os_free_mem(nx_dev_handle_t handle, void *addr, U32 len, U32 flags);
void nx_os_nic_reg_read_w0(nx_dev_handle_t handle, U32 index, U32 * value);
void nx_os_nic_reg_write_w0(nx_dev_handle_t handle, U32 index, U32 value);
void nx_os_nic_reg_read_w1(nx_dev_handle_t handle, U64 off, U32 * value);
void nx_os_nic_reg_write_w1(nx_dev_handle_t handle, U64 off, U32 val);
void nx_init_napi (struct unm_adapter_s *adapter);
void nx_napi_enable(struct unm_adapter_s *adapter);
void nx_napi_disable(struct unm_adapter_s *adapter);
static int nx_alloc_adapter_sds_rings(struct unm_adapter_s *adapter);
static void nx_verify_module_params(void);
static void unm_check_options(unm_adapter *adapter);
static int get_flash_mac_addr(struct unm_adapter_s *adapter, uint64_t mac[]);
static int initialize_dummy_dma(unm_adapter *adapter);
static void destroy_dummy_dma(unm_adapter *adapter);
static void nx_reset_msix_bit(struct pci_dev *pdev);
static int nx_nic_setup_minidump(struct unm_adapter_s *adapter);
static void nx_nic_cleanup_minidump(struct unm_adapter_s *adapter);
static void nx_nic_logs_free (struct unm_adapter_s *adapter);
static void cleanup_adapter(struct unm_adapter_s *adapter);
static int nx_set_dma_mask(struct unm_adapter_s *adapter, uint8_t revision_id);
static void nx_set_num_rx_queues(unm_adapter *adapter);
static void init_msix_entries(struct unm_adapter_s *adapter);
static inline int unm_pci_region_offset(struct pci_dev *pdev, int region);
static inline int unm_pci_region_len(struct pci_dev *pdev, int region);
static void nx_hwbug_8_workaround(struct pci_dev *pdev);
static int nx_enable_msi_x(struct unm_adapter_s *adapter);
static int nx_enable_msi(struct unm_adapter_s *adapter);
static int nx_read_flashed_versions(struct unm_adapter_s *adapter);
static int nx_start_firmware(struct unm_adapter_s *adapter);
static int __devinit get_adapter_attr(struct unm_adapter_s *adapter);
static void nx_rx_kill_vid(struct net_device *netdev, unsigned short vid);
static int initialize_adapter_hw(struct unm_adapter_s *adapter);
static int init_firmware(struct unm_adapter_s *adapter);
static void unm_nic_free_ring_context(struct unm_adapter_s *adapter);
static void unm_nic_free_ring_context_in_fw(struct unm_adapter_s *adapter, int ctx_destroy);
void unm_nic_free_hw_resources(struct unm_adapter_s *adapter);
static void inline unm_nic_clear_stats(struct unm_adapter_s *adapter);
static int unm_nic_attach(struct unm_adapter_s *adapter);
static void nx_nic_p3_free_mac_list(struct unm_adapter_s *adapter);
static void unm_nic_detach(struct unm_adapter_s *adapter, int ctx_destroy);
static void __devexit unm_nic_remove(struct pci_dev *pdev);
static int nx_config_rss(struct unm_adapter_s *adapter, int enable);
int nx_nic_multictx_get_filter_count(struct net_device *netdev, int queue_type);
struct napi_struct * nx_nic_multictx_get_napi(struct net_device *netdev , int queue_id);
int nx_nic_multictx_get_ctx_count(struct net_device *netdev, int queue_type);
int nx_nic_multictx_get_queue_vector(struct net_device *netdev, int qid);
int nx_nic_multictx_get_default_rx_queue(struct net_device *netdev);
int nx_nic_multictx_alloc_tx_ctx(struct net_device *netdev);
int nx_nic_multictx_alloc_rx_ctx(struct net_device *netdev);
int nx_nic_create_rx_ctx(struct net_device *netdev);
int nx_nic_multictx_free_tx_ctx(struct net_device *netdev, int ctx_id);
int nx_nic_multictx_free_rx_ctx(struct net_device *netdev, int ctx_id);
int nx_nic_multictx_set_rx_rule(struct net_device *netdev, int ctx_id, char* mac_addr);
int nx_nic_multictx_remove_rx_rule(struct net_device *netdev, int ctx_id, int rule_id);
int nx_pqm_queuelen (struct unm_adapter_s *adapter, int qnum);
int nx_testmux_lock(struct unm_adapter_s *adapter);
int nx_testmux_unlock(struct unm_adapter_s *adapter);
static void nx_clear_all_tm(struct unm_adapter_s *adapter);
static void nx_sre_status (struct unm_adapter_s *adapter);
static void nx_epg_status (struct unm_adapter_s *adapter);
static void nx_peg_status(struct unm_adapter_s *adapter);
static void nx_phanstat(struct unm_adapter_s *adapter);
static void nx_pegconsole(struct unm_adapter_s *adapter);
static void nx_sre_statistics (struct unm_adapter_s *adapter);
static void nx_epg_statistics (struct unm_adapter_s *adapter);
static void nx_nic_regs (struct unm_adapter_s *adapter);
static void nx_mac_statistics (struct unm_adapter_s *adapter);
int nx_nic_minidump(struct unm_adapter_s *adapter);
static void nx_nic_collect_fw_logs (struct unm_adapter_s *adapter);
static int unm_nic_open(struct net_device *netdev);
static int receive_peg_ready(struct unm_adapter_s *adapter);
static int unm_nic_hw_resources(struct unm_adapter_s *adapter);
static int unm_nic_new_rx_context_destroy(struct unm_adapter_s *adapter, int ctx_destroy);
static int unm_nic_new_tx_context_prepare(struct unm_adapter_s *adapter);
static int unm_nic_new_tx_context_destroy(struct unm_adapter_s *adapter, int ctx_destroy);
void nx_free_tx_resources(struct unm_adapter_s *adapter);
static void unm_nic_down(struct net_device *netdev);
static int unm_nic_close(struct net_device *netdev);
static int unm_nic_set_mac(struct net_device *netdev, void *p);
static void nx_nic_p3_set_multi(struct net_device *netdev);
static inline int is_packet_tagged(struct sk_buff *skb);
int unm_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev);
static void unm_watchdog_fw_reset(unsigned long v);
static void unm_watchdog(unsigned long v);
static int unm_nic_check_temp(struct unm_adapter_s *adapter);
int nx_p3_set_vport_miss_mode(struct unm_adapter_s *adapter, int mode);
static void unm_nic_handle_phy_intr(struct unm_adapter_s *adapter);
int nx_reset_netq_rx_queues( struct net_device *netdev);
int netxen_nic_attach_all_ports(struct unm_adapter_s *adapter);
int check_fw_reset_failure(struct unm_adapter_s *adapter);
int netxen_nic_restart_fw(struct unm_adapter_s *adapter);
int netxen_nic_reset_tx_timeout(struct unm_adapter_s *adapter);
int netxen_nic_detach_all_ports(struct unm_adapter_s *adapter, int fw_health);
void nx_nic_halt_firmware(struct unm_adapter_s *adapter);
static void unm_watchdog_task_fw_reset(TASK_PARAM adapid);
static void unm_watchdog_task(TASK_PARAM adapid);
static void unm_tx_timeout(struct net_device *netdev);
static void unm_tx_timeout_task(TASK_PARAM adapid);
static struct net_device_stats *unm_nic_get_stats(struct net_device *netdev);
static int nx_nic_fw40_change_mtu(struct net_device *netdev, int new_mtu);
irqreturn_t nx_nic_legacy_intr(int irq, void *data);
irqreturn_t nx_nic_msi_intr(int irq, void *data);
irqreturn_t nx_nic_msix_intr(int irq, void *data);
static int nx_nic_poll_sts(struct napi_struct *napi, int work_to_do);
static void unm_nic_poll_controller(struct net_device *netdev);
static inline void lro2_adjust_skb(struct sk_buff *skb, statusDesc_t *desc);
int nx_nic_is_netxen_device(struct net_device *netdev);
int nx_nic_get_device_port(struct net_device *netdev);
static int unm_process_cmd_ring(unsigned long data);
static inline int nx_pci_choose_state(struct pci_dev *pdev, PM_MESSAGE_T state);
static int unm_nic_suspend(struct pci_dev *pdev, PM_MESSAGE_T state);
static int unm_nic_resume(struct pci_dev *pdev);
static int __init unm_init_module(void);
static void __exit unm_exit_module(void);
int nx_nic_get_linkevent_cap(struct unm_adapter_s *adapter);
| 4b8a64253163608e08eb3e5406dfb0da0c65850fa762913e6e98a9ae22598411 | 413 |
|
DmitryADP | diff_qc750 | vendor/nvidia/tegra/multimedia-partner/nvmm/nvmm/blocks/super_parser/parser_core/ogg/nvmm_oggframing.c | NvOggSyncPageseek |
NvS32 NvOggSyncPageseek(ogg_sync_state *oy,ogg_page *og){
NvOggByteBuffer page;
NvS32 bytes,ret=0;
NvOggPageRelease(og);
bytes=oy->fifo_fill;
NvOggbyteInit(&page,oy->fifo_tail);
if(oy->headerbytes==0){
if(bytes<27)goto sync_out;
if(NvOggbyteRead1(&page,0)!=(NvS32)'O' ||
NvOggbyteRead1(&page,1)!=(NvS32)'g' ||
NvOggbyteRead1(&page,2)!=(NvS32)'g' ||
NvOggbyteRead1(&page,3)!=(NvS32)'S' ) goto sync_fail;
oy->headerbytes=NvOggbyteRead1(&page,26)+27;
}
if(bytes<oy->headerbytes)goto sync_out;
if(oy->bodybytes==0){
NvS32 i;
for(i=0;i<oy->headerbytes-27;i++)
oy->bodybytes+=NvOggbyteRead1(&page,27+i);
}
if(oy->bodybytes+oy->headerbytes>bytes)goto sync_out;
{
ogg_uint32_t chksum=NvOggbyteRead4(&page,22);
NvOggbyteSet4(&page,0,22);
if(chksum!=NvChecksum(oy->fifo_tail,oy->bodybytes+oy->headerbytes)){
NvOggbyteSet4(&page,chksum,22);
goto sync_fail;
}
NvOggbyteSet4(&page,chksum,22);
}
if(og){
og->header=NvOggBufferSplit(&oy->fifo_tail,&oy->fifo_head,oy->headerbytes);
og->header_len=oy->headerbytes;
og->body=NvOggBufferSplit(&oy->fifo_tail,&oy->fifo_head,oy->bodybytes);
og->body_len=oy->bodybytes;
}else{
oy->fifo_tail=
NvOggBufferPretruncate(oy->fifo_tail,oy->headerbytes+oy->bodybytes);
if(!oy->fifo_tail)oy->fifo_head=0;
}
ret=oy->headerbytes+oy->bodybytes;
oy->unsynced=0;
oy->headerbytes=0;
oy->bodybytes=0;
oy->fifo_fill-=ret;
return ret;
sync_fail:
oy->headerbytes=0;
oy->bodybytes=0;
oy->fifo_tail=NvOggBufferPretruncate(oy->fifo_tail,1);
ret--;
while(oy->fifo_tail){
NvU8 *now=oy->fifo_tail->buffer->data+oy->fifo_tail->begin;
NvU8 *next=memchr(now, 'O', oy->fifo_tail->length);
if(next){
NvS32 bytes=next-now;
oy->fifo_tail=NvOggBufferPretruncate(oy->fifo_tail,bytes);
ret-=bytes;
break;
}else{
NvS32 bytes=oy->fifo_tail->length;
ret-=bytes;
oy->fifo_tail=NvOggBufferPretruncate(oy->fifo_tail,bytes);
}
}
if(!oy->fifo_tail)oy->fifo_head=0;
oy->fifo_fill+=ret;
sync_out:
return ret;
} |
static ogg_buffer_state *NvOggBufferCreate(void);
void NvOggBufferDestroy(ogg_buffer_state *bs);
ogg_buffer *NvFetchBuffer(ogg_buffer_state *bs,NvS32 bytes);
ogg_reference *NvFetchRef(ogg_buffer_state *bs);
ogg_reference *NvOggBufferAlloc(ogg_buffer_state *bs,NvS32 bytes);
void NvOggBufferRealloc(ogg_reference *or,NvS32 bytes);
void NvOggBufferMarkOne(ogg_reference *or);
void NvOggBufferMark(ogg_reference *or);
ogg_reference *NvOggBufferSub(ogg_reference *or,NvS32 begin,NvS32 length);
ogg_reference *NvOggBufferDup(ogg_reference *or);
ogg_reference *NvOggBufferSplit(ogg_reference **tail,
ogg_reference **head,NvS32 pos);
void NvOggBufferReleaseOne(ogg_reference *or);
void NvOggBufferRelease(ogg_reference *or);
ogg_reference *NvOggBufferPretruncate(ogg_reference *or,NvS32 pos);
static ogg_reference *NvOggBufferWalk(ogg_reference *or);
ogg_reference *NvOggBufferCat(ogg_reference *tail, ogg_reference *head);
void NvPositionB(NvOggByteBuffer *b,NvS32 pos);
void NvPositionF(NvOggByteBuffer *b,NvS32 pos);
NvS32 NvOggbyteInit(NvOggByteBuffer *b,ogg_reference *or);
void NvOggbyteSet4(NvOggByteBuffer *b,ogg_uint32_t val,NvS32 pos);
NvU8 NvOggbyteRead1(NvOggByteBuffer *b,NvS32 pos);
ogg_uint32_t NvOggbyteRead4(NvOggByteBuffer *b,NvS32 pos);
ogg_int64_t NvOggbyteRead8(NvOggByteBuffer *b,NvS32 pos);
NvS32 NvOggPageVersion(ogg_page *og);
NvS32 NvOggPageBos(ogg_page *og);
ogg_uint32_t NvOggPagePageno(ogg_page *og);
ogg_uint32_t NvChecksum(ogg_reference *or, NvS32 bytes);
void NvNextLace(NvOggByteBuffer *ob,ogg_stream_state *os);
void NVSpanQueuedPage(ogg_stream_state *os);
NvS32 NvPacketout(ogg_stream_state *os,NvOggPacket *op,NvS32 adv);
NvS32 NvOggStreamPacketout(ogg_stream_state *os,NvOggPacket *op);
NvS32 NvOggStreamPacketpeek(ogg_stream_state *os,NvOggPacket *op);
NvS32 NvOggPacketRelease(NvOggPacket *op);
NvS32 NvOggPageRelease(ogg_page *og);
void NvOggPageDup(ogg_page *dup,ogg_page *orig);
NvS32 Nv0ggPageContinued(ogg_page *og);
NvS32 NvOggPageEos(ogg_page *og);
ogg_int64_t NvOggPageGranulepos(ogg_page *og);
ogg_uint32_t NvOggPageSerialno(ogg_page *og);
ogg_sync_state *NvOggSyncCreate(void);
NvS32 NvOggSyncDestroy(ogg_sync_state *oy);
NvU8 *NvOggSyncBufferin(ogg_sync_state *oy, NvS32 bytes);
NvS32 NvOggSyncWrote(ogg_sync_state *oy, NvS32 bytes);
NvS32 NvOggSyncReset(ogg_sync_state *oy);
ogg_stream_state *NvOggStreamCreate(NvS32 serialno);
NvS32 NvOggStreamDestroy(ogg_stream_state *os);
NvS32 NvOggStreamDestroyEnd(ogg_stream_state *os);
NvS32 NvOggStreamPagein(ogg_stream_state *os, ogg_page *og);
NvS32 NvOggStreamReset(ogg_stream_state *os);
NvS32 NvOggStreamResetSerialno(ogg_stream_state *os,NvS32 serialno);
| 5d1e012bc925f1dd457c430b001260c69504b0540cb8bfc8a9241d4aa024c29a | 2,236 |
|
JianpingZeng | xcc | samples/Juliet/testcases/CWE321_Hard_Coded_Cryptographic_Key/CWE321_Hard_Coded_Cryptographic_Key__w32_char_53d.c | CWE321_Hard_Coded_Cryptographic_Key__w32_char_53d_goodG2BSink |
void CWE321_Hard_Coded_Cryptographic_Key__w32_char_53d_goodG2BSink(char * cryptoKey)
{
{
HCRYPTPROV hCryptProv;
HCRYPTKEY hKey;
HCRYPTHASH hHash;
char toBeEncrypted[] = "String to be encrypted";
DWORD encryptedLen = strlen(toBeEncrypted)*sizeof(char);
BYTE encrypted[200];
memcpy(encrypted, toBeEncrypted, encryptedLen);
if(!CryptAcquireContext(&hCryptProv, NULL, MS_ENHANCED_PROV, PROV_RSA_AES, 0))
{
if(!CryptAcquireContext(&hCryptProv, NULL, MS_ENHANCED_PROV, PROV_RSA_AES, CRYPT_NEWKEYSET))
{
printLine("Error in acquiring cryptographic context");
exit(1);
}
}
if(!CryptCreateHash(hCryptProv, CALG_SHA_256, 0, 0, &hHash))
{
printLine("Error in creating hash");
exit(1);
}
if(!CryptHashData(hHash, (BYTE *) cryptoKey, strlen(cryptoKey)*sizeof(char), 0))
{
printLine("Error in hashing cryptoKey");
exit(1);
}
if(!CryptDeriveKey(hCryptProv, CALG_AES_256, hHash, 0, &hKey))
{
printLine("Error in CryptDeriveKey");
exit(1);
}
if(!CryptEncrypt(hKey, (HCRYPTHASH)NULL, 1, 0, encrypted, &encryptedLen, sizeof(encrypted)))
{
printLine("Error in CryptEncrypt");
exit(1);
}
printBytesLine(encrypted, encryptedLen);
if (hKey)
{
CryptDestroyKey(hKey);
}
if (hHash)
{
CryptDestroyHash(hHash);
}
if (hCryptProv)
{
CryptReleaseContext(hCryptProv, 0);
}
}
} |
void CWE321_Hard_Coded_Cryptographic_Key__w32_char_53d_badSink(char * cryptoKey);
| 27139bf8b4b60dd2ad987ee2a9389ce6f5f6cbd40fca5a0ea1922d2604da502a | 1,854 |
|
yzfcer | wind_os | src/core/wind_mutex.c | rent | rent();
if (!IS_F_MUTEX_LOCKED(mutex))
{
SET_F_MUTEX_LOCKED(mutex);
mutex->nest ++;
mutex->owner = wind_thread_current();
wind_enable_switch();
return W_ERR_OK;
}
if(thread == mutex->owner)
{
if(mutex->nest < 65535)
mutex->nest ++;
wind_enable_switch();
return W_ERR_OK;
}
thread->runstat = THREAD_STATUS_SUSPEND;
thread->cause = CAUSE_LOCK;
thread->sleep_ticks = 0x7fffffff;
dlist_insert_prio(&mutex->waitlist,&thread->suspendnode,thread->prio);
wind_enable_switch();
_wind_thread_dispatch();
return W_ERR_OK;
}
w_err_t wind_mutex_trylock(w_mutex_s *mutex)
{
w_err_t err;
WIND_ASSERT_RETURN(mutex != W_NULL,W_ERR_PTR_NULL);
WIND_ASSERT_RETURN(mutex->obj.magic == WIND_MUTEX_MAGIC,W_ERR_INVALID);
wind_disable_switch();
if (!IS_F_MUTEX_LOCKED(mu | w_err_t mutex_free(void *mutex);
nit(void);
ol,sizeof(mutexpool);
init(w_mutex_s *mutex,const char *name);
NULL,W_NULL);
itch();
RN(err == W_ERR_OK, W_ERR_FAIL);
);
nd_enable_switch();
| 82b09a48747cfc25e06c5067c6575f51719b02fd86ee7744581bae96b3a1613a | 941 |
|
HarryR | ZeroDB | bench/db-bench.c | void
db_test_pseudorandom |
static void
db_test_pseudorandom( benchmark_t* b ) {
assert(b != NULL);
run_test_rwmix(b, b->entries, bop_read_pseudorand, bop_write_pseudorand);
} |
DB_OP(count_value);
| c9b46888075f7cba7dae7e003eb75afd9f4739c22bd1b402e729f3ff5622f530 | 150 |
|
Blackburn29 | PsycoKernel | drivers/mfd/wm8350-core.c | wm8350_phys_read |
static int wm8350_phys_read(struct wm8350 *wm8350, u8 reg, int num_regs,
u16 *dest)
{
int i, ret;
int bytes = num_regs * 2;
dev_dbg(wm8350->dev, "volatile read\n");
ret = wm8350->read_dev(wm8350, reg, bytes, (char *)dest);
for (i = reg; i < reg + num_regs; i++) {
dest[i - reg] = be16_to_cpu(dest[i - reg]);
dest[i - reg] &= wm8350_reg_io_map[i].readable;
}
dump(num_regs, dest);
return ret;
} |
static int wm8350_read(struct wm8350 *wm8350, u8 reg, int num_regs, u16 *dest);
static inline int is_reg_locked(struct wm8350 *wm8350, u8 reg);
static int wm8350_write(struct wm8350 *wm8350, u8 reg, int num_regs, u16 *src);
int wm8350_clear_bits(struct wm8350 *wm8350, u16 reg, u16 mask);
int wm8350_set_bits(struct wm8350 *wm8350, u16 reg, u16 mask);
u16 wm8350_reg_read(struct wm8350 *wm8350, int reg);
int wm8350_reg_write(struct wm8350 *wm8350, int reg, u16 val);
int wm8350_reg_lock(struct wm8350 *wm8350);
int wm8350_reg_unlock(struct wm8350 *wm8350);
int wm8350_read_auxadc(struct wm8350 *wm8350, int channel, int scale, int vref);
static irqreturn_t wm8350_auxadc_irq(int irq, void *irq_data);
static int wm8350_create_cache(struct wm8350 *wm8350, int type, int mode);
void wm8350_device_exit(struct wm8350 *wm8350);
| 92875f24e69eac5ec43e6dbaf50cb343dd89ce77deaaac94774962999d2c0df9 | 424 |
|
CEG-ICRISAT | Raspberry | c/htslib-1.2.1/cram/cram_io.c | cram_uncompress_block |
int cram_uncompress_block(cram_block *b) {
char *uncomp;
size_t uncomp_size = 0;
if (b->uncomp_size == 0) {
b->method = RAW;
return 0;
}
switch (b->method) {
case RAW:
return 0;
case GZIP:
uncomp = zlib_mem_inflate((char *)b->data, b->comp_size, &uncomp_size);
if (!uncomp)
return -1;
if ((int)uncomp_size != b->uncomp_size) {
free(uncomp);
return -1;
}
free(b->data);
b->data = (unsigned char *)uncomp;
b->alloc = uncomp_size;
b->method = RAW;
break;
#ifdef HAVE_LIBBZ2
case BZIP2: {
unsigned int usize = b->uncomp_size;
if (!(uncomp = malloc(usize)))
return -1;
if (BZ_OK != BZ2_bzBuffToBuffDecompress(uncomp, &usize,
(char *)b->data, b->comp_size,
0, 0)) {
free(uncomp);
return -1;
}
free(b->data);
b->data = (unsigned char *)uncomp;
b->alloc = usize;
b->method = RAW;
b->uncomp_size = usize;
break;
}
#else
case BZIP2:
fprintf(stderr, "Bzip2 compression is not compiled into this "
"version.\nPlease rebuild and try again.\n");
return -1;
#endif
#ifdef HAVE_LIBLZMA
case LZMA:
uncomp = lzma_mem_inflate((char *)b->data, b->comp_size, &uncomp_size);
if (!uncomp)
return -1;
if ((int)uncomp_size != b->uncomp_size)
return -1;
free(b->data);
b->data = (unsigned char *)uncomp;
b->alloc = uncomp_size;
b->method = RAW;
break;
#else
case LZMA:
fprintf(stderr, "Lzma compression is not compiled into this "
"version.\nPlease rebuild and try again.\n");
return -1;
break;
#endif
case RANS: {
unsigned int usize = b->uncomp_size, usize2;
uncomp = (char *)rans_uncompress(b->data, b->comp_size, &usize2);
assert(usize == usize2);
free(b->data);
b->data = (unsigned char *)uncomp;
b->alloc = usize2;
b->method = RAW;
b->uncomp_size = usize2;
break;
}
default:
return -1;
}
return 0;
} |
int itf8_decode(cram_fd *fd, int32_t *val_p);
int itf8_encode(cram_fd *fd, int32_t val);
int itf8_get(char *cp, int32_t *val_p);
int itf8_put(char *cp, int32_t val);
int ltf8_put(char *cp, int64_t val);
int ltf8_get(char *cp, int64_t *val_p);
int ltf8_decode(cram_fd *fd, int64_t *val_p);
int itf8_put_blk(cram_block *blk, int val);
int int32_decode(cram_fd *fd, int32_t *val);
int int32_encode(cram_fd *fd, int32_t val);
int int32_get(cram_block *b, int32_t *val);
int int32_put(cram_block *b, int32_t val);
char *zlib_mem_inflate(char *cdata, size_t csize, size_t *size);
static char *lzma_mem_inflate(char *cdata, size_t csize, size_t *size);
cram_block *cram_read_block(cram_fd *fd);
int cram_write_block(cram_fd *fd, cram_block *b);
void cram_free_block(cram_block *b);
cram_metrics *cram_new_metrics(void);
char *cram_block_method2str(enum cram_block_method m);
char *cram_content_type2str(enum cram_content_type t);
int paranoid_fclose(FILE *fp);
void refs_free(refs_t *r);
static refs_t *refs_create(void);
static BGZF *bgzf_open_ref(char *fn, char *mode);
static refs_t *refs_load_fai(refs_t *r_orig, char *fn, int is_err);
int refs2id(refs_t *r, SAM_hdr *h);
static int refs_from_header(refs_t *r, cram_fd *fd, SAM_hdr *h);
int cram_set_header(cram_fd *fd, SAM_hdr *hdr);
void expand_cache_path(char *path, char *dir, char *fn);
void mkdir_prefix(char *path, int mode);
static const char *get_cache_basedir(const char **extra);
static int cram_populate_ref(cram_fd *fd, int id, ref_entry *r);
static void cram_ref_incr_locked(refs_t *r, int id);
void cram_ref_incr(refs_t *r, int id);
static void cram_ref_decr_locked(refs_t *r, int id);
void cram_ref_decr(refs_t *r, int id);
static char *load_ref_portion(BGZF *fp, ref_entry *e, int start, int end);
ref_entry *cram_ref_load(refs_t *r, int id);
char *cram_get_ref(cram_fd *fd, int id, int start, int end);
int cram_load_reference(cram_fd *fd, char *fn);
cram_container *cram_new_container(int nrec, int nslice);
void cram_free_container(cram_container *c);
cram_container *cram_read_container(cram_fd *fd);
int cram_write_container(cram_fd *fd, cram_container *c);
static int cram_flush_container2(cram_fd *fd, cram_container *c);
int cram_flush_container(cram_fd *fd, cram_container *c);
void *cram_flush_thread(void *arg);
static int cram_flush_result(cram_fd *fd);
int cram_flush_container_mt(cram_fd *fd, cram_container *c);
cram_block_compression_hdr *cram_new_compression_header(void);
void cram_free_compression_header(cram_block_compression_hdr *hdr);
void cram_free_slice_header(cram_block_slice_hdr *hdr);
void cram_free_slice(cram_slice *s);
cram_slice *cram_new_slice(enum cram_content_type type, int nrecs);
cram_slice *cram_read_slice(cram_fd *fd);
cram_file_def *cram_read_file_def(cram_fd *fd);
int cram_write_file_def(cram_fd *fd, cram_file_def *def);
void cram_free_file_def(cram_file_def *def);
SAM_hdr *cram_read_SAM_hdr(cram_fd *fd);
static void full_path(char *out, char *in);
int cram_write_SAM_hdr(cram_fd *fd, SAM_hdr *hdr);
static void cram_init_tables(cram_fd *fd);
cram_fd *cram_open(const char *filename, const char *mode);
cram_fd *cram_dopen(hFILE *fp, const char *filename, const char *mode);
int cram_seek(cram_fd *fd, off_t offset, int whence);
int cram_flush(cram_fd *fd);
int cram_close(cram_fd *fd);
int cram_eof(cram_fd *fd);
int cram_set_option(cram_fd *fd, enum cram_option opt, ...);
int cram_set_voption(cram_fd *fd, enum cram_option opt, va_list args);
| 542d30d1da9f411279d4e9bf0a699250efd0db01ae47d3ee5851de72ed7adfa2 | 1,866 |
|
AndreyPopovNew | asuswrt-merlin-rt-n | linux-2.6.22.19-cs543/scripts/mod/sumversion.c | cpu_to_le32_array |
static inline void cpu_to_le32_array(uint32_t *buf, unsigned int words)
{
while (words--) {
*buf = htonl(*buf);
buf++;
}
} |
static inline uint32_t lshift(uint32_t x, unsigned int s);
static inline uint32_t F(uint32_t x, uint32_t y, uint32_t z);
static inline uint32_t G(uint32_t x, uint32_t y, uint32_t z);
static inline uint32_t H(uint32_t x, uint32_t y, uint32_t z);
static inline void le32_to_cpu_array(uint32_t *buf, unsigned int words);
static void md4_transform(uint32_t *hash, uint32_t const *in);
static inline void md4_transform_helper(struct md4_ctx *ctx);
static void md4_init(struct md4_ctx *mctx);
static void md4_final_ascii(struct md4_ctx *mctx, char *out, unsigned int len);
static inline void add_char(unsigned char c, struct md4_ctx *md);
static int parse_comment(const char *file, unsigned long len);
static int parse_file(const char *fname, struct md4_ctx *md);
static int parse_source_files(const char *objfile, struct md4_ctx *md);
void get_src_version(const char *modname, char sum[], unsigned sumlen);
static int strip_rcs_crap(char *version);
| 8020fda37fb37cf8a1f01961b0e20ba7801a15990c01da6fd24126e09d11b6a6 | 129 |
|
matthiasbeyer | linux | drivers/mtd/nand/raw/omap2.c | omap_hwcontrol | atic void omap_hwcontrol(struct nand_chip *chip, int cmd, unsigned int ctrl)
{
struct omap_nand_info *info = mtd_to_omap(nand_to_mtd(chip));
if (cmd != NAND_CMD_NONE) {
if (ctrl & NAND_CLE)
writeb(cmd, info->reg.gpmc_nand_command);
else if (ctrl & NAND_ALE)
writeb(cmd, info->reg.gpmc_nand_address);
else
writeb(cmd, info->reg.gpmc_nand_data);
}
}
/ | atic inline struct omap_nand_info *mtd_to_omap(struct mtd_info *mtd);
atic int omap_prefetch_enable(int cs, int fifo_th, int dma_mode,
unsigned int u32_count, int is_write, struct omap_nand_info *info);
atic int omap_prefetch_reset(int cs, struct omap_nand_info *info);
atic void omap_read_buf8(struct mtd_info *mtd, u_char *buf, int len);
atic void omap_write_buf8(struct mtd_info *mtd, const u_char *buf, int len);
atic void omap_read_buf16(struct mtd_info *mtd, u_char *buf, int len);
atic void omap_write_buf16(struct mtd_info *mtd, const u_char * buf, int len);
atic void omap_read_buf_pref(struct nand_chip *chip, u_char *buf, int len);
atic void omap_write_buf_pref(struct nand_chip *chip, const u_char *buf,
int len);
atic void omap_nand_dma_callback(void *data);
atic inline int omap_nand_dma_transfer(struct mtd_info *mtd, void *addr,
unsigned int len, int is_write);
atic void omap_read_buf_dma_pref(struct nand_chip *chip, u_char *buf,
int len);
atic void omap_write_buf_dma_pref(struct nand_chip *chip, const u_char *buf,
int len);
atic irqreturn_t omap_nand_irq(int this_irq, void *dev);
atic void omap_read_buf_irq_pref(struct nand_chip *chip, u_char *buf,
int len);
atic void omap_write_buf_irq_pref(struct nand_chip *chip, const u_char *buf,
int len);
atic void gen_true_ecc(u8 *ecc_buf);
atic int omap_correct_data(struct nand_chip *chip, u_char *dat,
u_char *read_ecc, u_char *calc_ecc);
atic int omap_calculate_ecc(struct nand_chip *chip, const u_char *dat,
u_char *ecc_code);
atic void omap_enable_hwecc(struct nand_chip *chip, int mode);
atic int omap_wait(struct nand_chip *this);
atic int omap_dev_ready(struct nand_chip *chip);
atic void __maybe_unused omap_enable_hwecc_bch(struct nand_chip *chip,
int mode);
atic int _omap_calculate_ecc_bch(struct mtd_info *mtd,
const u_char *dat, u_char *ecc_calc, int i);
atic int omap_calculate_ecc_bch_sw(struct nand_chip *chip,
const u_char *dat, u_char *ecc_calc);
atic int omap_calculate_ecc_bch_multi(struct mtd_info *mtd,
const u_char *dat, u_char *ecc_calc);
atic int erased_sector_bitflips(u_char *data, u_char *oob,
struct omap_nand_info *info);
atic int omap_elm_correct_data(struct nand_chip *chip, u_char *data,
u_char *read_ecc, u_char *calc_ecc);
atic int omap_write_page_bch(struct nand_chip *chip, const uint8_t *buf,
int oob_required, int page);
atic int omap_read_page_bch(struct nand_chip *chip, uint8_t *buf,
int oob_required, int page);
atic bool is_elm_present(struct omap_nand_info *info,
struct device_node *elm_node);
atic bool omap2_nand_ecc_check(struct omap_nand_info *info);
atic int omap_get_dt_info(struct device *dev, struct omap_nand_info *info);
atic int omap_ooblayout_ecc(struct mtd_info *mtd, int section,
struct mtd_oob_region *oobregion);
atic int omap_ooblayout_free(struct mtd_info *mtd, int section,
struct mtd_oob_region *oobregion);
atic int omap_sw_ooblayout_ecc(struct mtd_info *mtd, int section,
struct mtd_oob_region *oobregion);
atic int omap_sw_ooblayout_free(struct mtd_info *mtd, int section,
struct mtd_oob_region *oobregion);
atic int omap_nand_attach_chip(struct nand_chip *chip);
atic int omap_nand_probe(struct platform_device *pdev);
atic int omap_nand_remove(struct platform_device *pdev);
| 09354f928f23f6de5396c1f42100200a9388c23223192cae3cadac69f7831926 | 373 |
|
SNDBXIE | myway-eathena | src/map/battle.c | battle_getenemy |
struct block_list* battle_getenemy(struct block_list *target, int type, int range) {
struct block_list *bl_list[24];
int c = 0;
memset(bl_list, 0, sizeof(bl_list));
map_foreachinrange(battle_getenemy_sub, target, range, type, bl_list, &c, target);
if ( c == 0 )
return NULL;
if( c > 24 )
c = 24;
return bl_list[rnd()%c];
} |
int battle_getcurrentskill(struct block_list *bl);
static int battle_gettargeted_sub(struct block_list *bl, va_list ap);
struct block_list* battle_gettargeted(struct block_list *target);
int battle_gettarget(struct block_list* bl);
static int battle_getenemy_sub(struct block_list *bl, va_list ap);
static int battle_getenemyarea_sub(struct block_list *bl, va_list ap);
struct block_list* battle_getenemyarea(struct block_list *src, int x, int y, int range, int type, int ignore_id);
int battle_delay_damage_sub(int tid, unsigned int tick, int id, intptr_t data);
int battle_delay_damage (unsigned int tick, int amotion, struct block_list *src, struct block_list *target, int attack_type, uint16 skill_id, uint16 skill_lv, int damage, enum damage_lv dmg_lv, int ddelay, bool additional_effects);
int battle_attr_ratio(int atk_elem,int def_type, int def_lv);
int battle_attr_fix(struct block_list *src, struct block_list *target, int damage,int atk_elem,int def_type, int def_lv);
int battle_calc_cardfix(int attack_type, struct block_list *src, struct block_list *target, int nk, int s_ele, int s_ele_, int damage, int left, int flag);
int battle_calc_damage(struct block_list *src,struct block_list *bl,struct Damage *d,int damage,uint16 skill_id,uint16 skill_lv);
int battle_calc_bg_damage(struct block_list *src, struct block_list *bl, int damage, int div_, uint16 skill_id, uint16 skill_lv, int flag);
int battle_calc_gvg_damage(struct block_list *src,struct block_list *bl,int damage,int div_,uint16 skill_id,uint16 skill_lv,int flag);
static int battle_calc_drain(int damage, int rate, int per);
int battle_addmastery(struct map_session_data *sd,struct block_list *target,int dmg,int type);
static int battle_calc_base_damage(struct status_data *status, struct weapon_atk *wa, struct status_change *sc, unsigned short t_size, struct map_session_data *sd, int flag);
void battle_consume_ammo(TBL_PC*sd, int skill, int lv);
static int battle_blewcount_bonus(struct map_session_data *sd, uint16 skill_id);
static int battle_SAD(struct map_session_data *sd, struct block_list *target, uint16 skill_id);
static struct Damage battle_calc_weapon_attack(struct block_list *src,struct block_list *target,uint16 skill_id,uint16 skill_lv,int wflag);
struct Damage battle_calc_magic_attack(struct block_list *src,struct block_list *target,uint16 skill_id,uint16 skill_lv,int mflag);
struct Damage battle_calc_misc_attack(struct block_list *src,struct block_list *target,uint16 skill_id,uint16 skill_lv,int mflag);
struct Damage battle_calc_attack(int attack_type,struct block_list *bl,struct block_list *target,uint16 skill_id,uint16 skill_lv,int count);
int battle_calc_return_damage(struct block_list* bl, struct block_list *src, int *dmg, int flag, uint16 skill_id);
void battle_drain(TBL_PC *sd, struct block_list *tbl, int rdamage, int ldamage, int race, int boss);
int battle_damage_area( struct block_list *bl, va_list ap);
enum damage_lv battle_weapon_attack(struct block_list* src, struct block_list* target, unsigned int tick, int flag);
int battle_check_undead(int race,int element);
struct block_list* battle_get_master(struct block_list *src);
int battle_check_target( struct block_list *src, struct block_list *target,int flag);
bool battle_check_range(struct block_list *src, struct block_list *bl, int range);
void rAthena_report(char* date, char *time_c);
static int rAthena_report_timer(int tid, unsigned int tick, int id, intptr_t data);
int battle_set_value(const char* w1, const char* w2);
int battle_get_value(const char* w1);
void battle_set_defaults();
void battle_adjust_conf();
int battle_config_read(const char* cfgName);
void do_init_battle(void);
void do_final_battle(void);
| fed3bbcafd7aed8508d8714f4c6c38c2cf3fc0093c4b6402755df468145f4b56 | 352 |
End of preview. Expand
in Dataset Viewer.
No dataset card yet
New: Create and edit this dataset card directly on the website!
Contribute a Dataset Card- Downloads last month
- 5