mirror of
https://github.com/Telecominfraproject/OpenCellular.git
synced 2025-12-27 18:25:05 +00:00
0c8c2e453a
We often need to watch for transitions between one state and another, so
that we can issue warnings or take action ONCE. This abstracts that "have I
already reacted to this" stuff into a single set of functions.
For example, this code reads a GPIO every time through the loop, but it only
generates an event when the GPIO value changes from 0 to 1:
cond_t c;
cond_init_false(&c);
while(1) {
int val = read_some_gpio();
cond_set(&c, val);
if (cond_went_true(&c))
host_event(SOMETHING_HAPPENED);
sleep(1);
}
BUG=none
BRANCH=falco,peppy
TEST=manual
make BOARD=falco runtests
Change-Id: I42393fcf3c4eb71b9551118a0f442d55c0691315
Signed-off-by: Bill Richardson <wfrichar@chromium.org>
Reviewed-on: https://gerrit.chromium.org/gerrit/65071
152 lines
4.0 KiB
C
152 lines
4.0 KiB
C
/* Copyright (c) 2012 The Chromium OS Authors. All rights reserved.
|
|
* Use of this source code is governed by a BSD-style license that can be
|
|
* found in the LICENSE file.
|
|
*/
|
|
|
|
/* Various utility functions and macros */
|
|
|
|
#ifndef __CROS_EC_UTIL_H
|
|
#define __CROS_EC_UTIL_H
|
|
|
|
#include "common.h"
|
|
#include "compile_time_macros.h"
|
|
#include "panic.h"
|
|
|
|
/**
|
|
* Trigger a debug exception if the condition
|
|
* is not verified at runtime.
|
|
*/
|
|
#ifdef CONFIG_DEBUG_ASSERT
|
|
#ifdef CONFIG_DEBUG_ASSERT_REBOOTS
|
|
#define ASSERT(cond) do { \
|
|
if (!(cond)) \
|
|
panic_assert_fail(#cond, __func__, __FILE__, \
|
|
__LINE__); \
|
|
} while (0)
|
|
#else
|
|
#define ASSERT(cond) do { \
|
|
if (!(cond)) \
|
|
__asm("bkpt"); \
|
|
} while (0)
|
|
#endif
|
|
#else
|
|
#define ASSERT(cond)
|
|
#endif
|
|
|
|
|
|
/* Standard macros / definitions */
|
|
#ifndef MAX
|
|
#define MAX(a, b) ((a) > (b) ? (a) : (b))
|
|
#endif
|
|
#ifndef MIN
|
|
#define MIN(a, b) ((a) < (b) ? (a) : (b))
|
|
#endif
|
|
#ifndef NULL
|
|
#define NULL ((void *)0)
|
|
#endif
|
|
|
|
/**
|
|
* macros for integer division with various rounding variants
|
|
* default integer division rounds down.
|
|
*/
|
|
#define DIV_ROUND_UP(x, y) (((x) + ((y) - 1)) / (y))
|
|
#define DIV_ROUND_NEAREST(x, y) (((x) + ((y) / 2)) / (y))
|
|
|
|
/* Standard library functions */
|
|
int atoi(const char *nptr);
|
|
int isdigit(int c);
|
|
int isspace(int c);
|
|
int isalpha(int c);
|
|
int isprint(int c);
|
|
int memcmp(const void *s1, const void *s2, int len);
|
|
void *memcpy(void *dest, const void *src, int len);
|
|
void *memset(void *dest, int c, int len);
|
|
void *memmove(void *dest, const void *src, int len);
|
|
int strcasecmp(const char *s1, const char *s2);
|
|
int strncasecmp(const char *s1, const char *s2, int size);
|
|
int strlen(const char *s);
|
|
|
|
/* Like strtol(), but for integers. */
|
|
int strtoi(const char *nptr, char **endptr, int base);
|
|
|
|
/* Like strncpy(), but guarantees null termination. */
|
|
char *strzcpy(char *dest, const char *src, int len);
|
|
|
|
/**
|
|
* Parses a boolean option from a string.
|
|
*
|
|
* Strings that set *dest=0 and return 1 (all case-insensitive):
|
|
* "off"
|
|
* "dis*"
|
|
* "n*"
|
|
* "f*"
|
|
*
|
|
* Strings that set *dest=1 and return 1 (all case-insensitive):
|
|
* "on"
|
|
* "ena*"
|
|
* "y*"
|
|
* "t*"
|
|
*
|
|
* Other strings return 0 and leave *dest unchanged.
|
|
*/
|
|
int parse_bool(const char *s, int *dest);
|
|
|
|
int tolower(int c);
|
|
|
|
/* 64-bit divide-and-modulo. Does the equivalent of:
|
|
*
|
|
* r = *n % d;
|
|
* *n /= d;
|
|
* return r;
|
|
*/
|
|
int uint64divmod(uint64_t *v, int by);
|
|
|
|
|
|
/****************************************************************************/
|
|
/* Conditional stuff.
|
|
*
|
|
* We often need to watch for transitions between one state and another, so
|
|
* that we can issue warnings or take action ONCE. This abstracts that "have I
|
|
* already reacted to this" stuff into a single set of functions.
|
|
*
|
|
* For example:
|
|
*
|
|
* cond_t c;
|
|
*
|
|
* cond_init_false(&c);
|
|
*
|
|
* while(1) {
|
|
* int val = read_some_gpio();
|
|
* cond_set(&c, val);
|
|
*
|
|
* if (cond_went_true(&c))
|
|
* host_event(SOMETHING_HAPPENED);
|
|
* }
|
|
*
|
|
*/
|
|
typedef uint8_t cond_t;
|
|
|
|
/* Initialize a conditional to a specific state. Do this first. */
|
|
void cond_init(cond_t *c, int boolean);
|
|
static inline void cond_init_false(cond_t *c) { cond_init(c, 0); }
|
|
static inline void cond_init_true(cond_t *c) { cond_init(c, 1); }
|
|
|
|
/* Set the current state. Do this as often as you like. */
|
|
void cond_set(cond_t *c, int boolean);
|
|
static inline void cond_set_false(cond_t *c) { cond_set(c, 0); }
|
|
static inline void cond_set_true(cond_t *c) { cond_set(c, 1); }
|
|
|
|
/* Get the current state. Do this as often as you like. */
|
|
int cond_is(cond_t *c, int boolean);
|
|
static inline int cond_is_false(cond_t *c) { return cond_is(c, 0); }
|
|
static inline int cond_is_true(cond_t *c) { return cond_is(c, 1); }
|
|
|
|
/* See if the state has transitioned. If it has, the corresponding function
|
|
* will return true ONCE only, until it's changed back.
|
|
*/
|
|
int cond_went(cond_t *c, int boolean);
|
|
static inline int cond_went_false(cond_t *c) { return cond_went(c, 0); }
|
|
static inline int cond_went_true(cond_t *c) { return cond_went(c, 1); }
|
|
|
|
#endif /* __CROS_EC_UTIL_H */
|