type stringclasses 5
values | content stringlengths 9 163k |
|---|---|
functions | ssize_t store_timer_slack(struct cpufreq_interactive_tunables *tunables,
const char *buf, size_t count)
{
int ret;
unsigned long val;
ret = kstrtol(buf, 10, &val);
if (ret < 0)
return ret;
tunables->timer_slack_val = val;
return count;
} |
functions | ssize_t show_boost(struct cpufreq_interactive_tunables *tunables,
char *buf)
{
return sprintf(buf, "%d\n", tunables->boost_val);
} |
functions | ssize_t store_boost(struct cpufreq_interactive_tunables *tunables,
const char *buf, size_t count)
{
int ret;
unsigned long val;
ret = kstrtoul(buf, 0, &val);
if (ret < 0)
return ret;
tunables->boost_val = val;
if (tunables->boost_val) {
trace_cpufreq_interactive_boost("on");
cpufreq_interactive_boo... |
functions | ssize_t store_boostpulse(struct cpufreq_interactive_tunables *tunables,
const char *buf, size_t count)
{
int ret;
unsigned long val;
ret = kstrtoul(buf, 0, &val);
if (ret < 0)
return ret;
tunables->boostpulse_endtime = ktime_to_us(ktime_get()) +
tunables->boostpulse_duration_val;
trace_cpufreq_interacti... |
functions | ssize_t show_boostpulse_duration(struct cpufreq_interactive_tunables
*tunables, char *buf)
{
return sprintf(buf, "%d\n", tunables->boostpulse_duration_val);
} |
functions | ssize_t store_boostpulse_duration(struct cpufreq_interactive_tunables
*tunables, const char *buf, size_t count)
{
int ret;
unsigned long val;
ret = kstrtoul(buf, 0, &val);
if (ret < 0)
return ret;
tunables->boostpulse_duration_val = val;
return count;
} |
functions | ssize_t show_io_is_busy(struct cpufreq_interactive_tunables *tunables,
char *buf)
{
return sprintf(buf, "%u\n", tunables->io_is_busy);
} |
functions | ssize_t store_io_is_busy(struct cpufreq_interactive_tunables *tunables,
const char *buf, size_t count)
{
int ret;
unsigned long val;
ret = kstrtoul(buf, 0, &val);
if (ret < 0)
return ret;
tunables->io_is_busy = val;
return count;
} |
functions | ssize_t show_input_dev_monitor(struct cpufreq_interactive_tunables *tunables,
char *buf)
{
return sprintf(buf, "%u\n", tunables->input_dev_monitor);
} |
functions | ssize_t store_input_dev_monitor(struct cpufreq_interactive_tunables *tunables,
const char *buf, size_t count)
{
int ret;
unsigned long val;
ret = kstrtoul(buf, 0, &val);
if (ret < 0)
return ret;
tunables->input_dev_monitor = val? 1 : 0;
return count;
} |
functions | ssize_t show_input_event_freq(struct cpufreq_interactive_tunables *tunables,
char *buf)
{
return sprintf(buf, "%u\n", tunables->input_event_freq);
} |
functions | ssize_t store_input_event_freq(struct cpufreq_interactive_tunables *tunables,
const char *buf, size_t count)
{
int ret;
unsigned long val;
ret = kstrtoul(buf, 0, &val);
if (ret < 0)
return ret;
tunables->input_event_freq = val;
return count;
} |
functions | void cpufreq_interactive_boosttop(void)
{
int i;
int anytop = 0;
unsigned long flags[2];
struct cpufreq_interactive_cpuinfo *pcpu;
spin_lock_irqsave(&speedchange_cpumask_lock, flags[0]);
for_each_online_cpu(i) {
pcpu = &per_cpu(cpuinfo, i);
spin_lock_irqsave(&pcpu->target_freq... |
functions | ssize_t store_boosttop(struct cpufreq_interactive_tunables *tunables,
const char *buf, size_t count)
{
int ret;
unsigned long val;
ret = kstrtoul(buf, 0, &val);
if (ret < 0)
return ret;
tunables->boosttop_endtime = ktime_to_us(ktime_get()) +
tunables->boosttop_duration_val;
... |
functions | ssize_t show_boosttop_duration(struct cpufreq_interactive_tunables
*tunables, char *buf)
{
return sprintf(buf, "%d\n", tunables->boosttop_duration_val);
} |
functions | ssize_t store_boosttop_duration(struct cpufreq_interactive_tunables
*tunables, const char *buf, size_t count)
{
int ret;
unsigned long val;
ret = kstrtoul(buf, 0, &val);
if (ret < 0)
return ret;
tunables->boosttop_duration_val = val;
return count;
} |
functions | int cpufreq_interactive_idle_notifier(struct notifier_block *nb,
unsigned long val,
void *data)
{
switch (val) {
case IDLE_START:
cpufreq_interactive_idle_start();
break;
case IDLE_END:
cpufreq_interactive_idle_end();
break;
} |
functions | void cpufreq_interactive_input_event(struct input_handle *handle,
unsigned int type,
unsigned int code, int value)
{
int i;
int anyboost = 0;
unsigned long flags[2];
struct cpufreq_interactive_cpuinfo *pcpu;
struct cpufreq_interactive_tunables *tunable... |
functions | int cpufreq_interactive_input_connect(struct input_handler *handler,
struct input_dev *dev,
const struct input_device_id *id)
{
struct input_handle *handle;
int error;
handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
if (!handle)
retur... |
functions | void cpufreq_interactive_input_disconnect(struct input_handle *handle)
{
input_close_device(handle);
input_unregister_handle(handle);
kfree(handle);
} |
functions | int cpufreq_governor_interactive(struct cpufreq_policy *policy,
unsigned int event)
{
int rc;
unsigned int j;
struct cpufreq_interactive_cpuinfo *pcpu;
struct cpufreq_frequency_table *freq_table;
struct cpufreq_interactive_tunables *tunables;
unsigned long flags;
if (have_governor_per_policy())
tunables = p... |
functions | else if (tunables) {
tunables->usage_count++;
policy->governor_data = tunables;
return 0;
} |
functions | CONFIG_CPU_FREQ_INPUT_EVNT_NOTIFY
if(!input_handler_register_count) {
cpumask_clear(&interactive_cpumask);
input_register_handler(&cpufreq_interactive_input_handler);
} |
functions | void cpufreq_interactive_nop_timer(unsigned long data)
{
} |
functions | __init cpufreq_interactive_init(void)
{
unsigned int i;
struct cpufreq_interactive_cpuinfo *pcpu;
struct sched_param param = { .sched_priority = MAX_RT_PRIO-1 } |
functions | __exit cpufreq_interactive_exit(void)
{
cpufreq_unregister_governor(&cpufreq_gov_interactive);
kthread_stop(speedchange_task);
put_task_struct(speedchange_task);
} |
includes |
#include <errno.h> |
includes | #include <limits.h> |
includes | #include <stddef.h> |
includes | #include <dirent.h> |
includes | #include <sys/types.h> |
includes | #include <sys/stat.h> |
includes | #include <unistd.h> |
includes | #include <string.h> |
includes | #include <stdlib.h> |
functions | internal_function
getttyname (int fd, dev_t mydev, ino_t myino, int save, int *dostat)
{
static const char dev[] = "/dev";
static size_t namelen;
struct stat st;
DIR *dirstream;
struct dirent *d;
dirstream = __opendir (dev);
if (dirstream == NULL)
{
*dostat = -1;
return NULL;
} |
functions | endif
if (!name && dostat != -1)
{
dostat = 1;
#ifdef _STATBUF_ST_RDEV
name = getttyname (fd, st.st_rdev, st.st_ino, save, &dostat);
#else
name = getttyname (fd, st.st_dev, st.st_ino, save, &dostat);
#endif
} |
includes |
#include <pic18f67j11.h> |
includes | #include <linux/module.h> |
includes | #include <linux/skbuff.h> |
includes | #include <net/ip.h> |
includes | #include <net/ipv6.h> |
includes | #include <linux/sctp.h> |
includes |
#include <linux/netfilter/x_tables.h> |
includes | #include <linux/netfilter/xt_sctp.h> |
includes | #include <linux/netfilter_ipv4/ip_tables.h> |
includes | #include <linux/netfilter_ipv6/ip6_tables.h> |
defines | #define duprintf(format, args...) printk(format , ## args) |
defines | #define duprintf(format, args...) |
defines |
#define SCCHECK(cond, option, flag, invflag) (!((flag) & (option)) \ |
functions | bool
match_flags(const struct xt_sctp_flag_info *flag_info,
const int flag_count,
u_int8_t chunktype,
u_int8_t chunkflags)
{
int i;
for (i = 0; i < flag_count; i++)
if (flag_info[i].chunktype == chunktype)
return (chunkflags & flag_info[i].flag_mask) == flag_info[i].flag;
return true;
} |
functions | bool
match_packet(const struct sk_buff *skb,
unsigned int offset,
const struct xt_sctp_info *info,
bool *hotdrop)
{
u_int32_t chunkmapcopy[256 / sizeof (u_int32_t)];
sctp_chunkhdr_t _sch, *sch;
int chunk_match_type = info->chunk_match_type;
const struct xt_sctp_flag_info *flag_info = info->flag_in... |
functions | bool
sctp_mt(const struct sk_buff *skb, const struct net_device *in,
const struct net_device *out, const struct xt_match *match,
const void *matchinfo, int offset, unsigned int protoff, bool *hotdrop)
{
const struct xt_sctp_info *info = matchinfo;
sctp_sctphdr_t _sh, *sh;
if (offset) {
duprintf("D... |
functions | bool
sctp_mt_check(const char *tablename, const void *inf,
const struct xt_match *match, void *matchinfo,
unsigned int hook_mask)
{
const struct xt_sctp_info *info = matchinfo;
return !(info->flags & ~XT_SCTP_VALID_FLAGS)
&& !(info->invflags & ~XT_SCTP_VALID_FLAGS)
&& !(info->invflags... |
functions | __init sctp_mt_init(void)
{
return xt_register_matches(sctp_mt_reg, ARRAY_SIZE(sctp_mt_reg));
} |
functions | __exit sctp_mt_exit(void)
{
xt_unregister_matches(sctp_mt_reg, ARRAY_SIZE(sctp_mt_reg));
} |
includes |
#include <rsf.h> |
functions | void lpuart_dma_send_cplt(void *arg)
{
lpuart_handle_t *hperh = (lpuart_handle_t *)arg;
hperh->tx_count = 0;
ald_lpuart_dma_req_config(hperh, LPUART_DMA_REQ_TX, DISABLE);
ald_lpuart_interrupt_config(hperh, LPUART_IT_TC, ENABLE);
} |
functions | void lpuart_dma_recv_cplt(void *arg)
{
lpuart_handle_t *hperh = (lpuart_handle_t *)arg;
hperh->rx_count = 0;
ald_lpuart_dma_req_config(hperh, LPUART_DMA_REQ_RX, DISABLE);
CLEAR_BIT(hperh->state, LPUART_STATE_RX_MASK);
if (hperh->rx_cplt_cbk)
hperh->rx_cplt_cbk(hperh);
} |
functions | void lpuart_dma_error(void *arg)
{
lpuart_handle_t *hperh = (lpuart_handle_t *)arg;
hperh->rx_count = 0;
hperh->tx_count = 0;
hperh->state = LPUART_STATE_READY;
hperh->err_code |= LPUART_ERROR_DMA;
if (hperh->error_cbk)
hperh->error_cbk(hperh);
} |
functions | ald_status_t lpuart_wait_flag(lpuart_handle_t *hperh, lpuart_status_t flag, flag_status_t status, uint32_t timeout)
{
uint32_t tick;
if (timeout == 0)
return OK;
tick = ald_get_tick();
/* Waiting for flag */
while ((ald_lpuart_get_status(hperh, flag)) != status) {
if (((ald_get_tick()) - tick) > timeout)
... |
functions | ald_status_t __lpuart_send_by_it(lpuart_handle_t *hperh)
{
if ((hperh->state & LPUART_STATE_TX_MASK) == 0x0)
return BUSY;
WRITE_REG(hperh->perh->TXDR, *hperh->tx_buf++);
if (--hperh->tx_count == 0) {
ald_lpuart_interrupt_config(hperh, LPUART_IT_TBEMP, DISABLE);
ald_lpuart_interrupt_config(hperh, LPUART_IT_TC... |
functions | ald_status_t __lpuart_end_send_by_it(lpuart_handle_t *hperh)
{
ald_lpuart_interrupt_config(hperh, LPUART_IT_TC, DISABLE);
CLEAR_BIT(hperh->state, LPUART_STATE_TX_MASK);
if (hperh->tx_cplt_cbk)
hperh->tx_cplt_cbk(hperh);
return OK;
} |
functions | ald_status_t __lpuart_recv_by_it(lpuart_handle_t *hperh)
{
uint32_t tmp;
uint16_t i;
if ((hperh->state & LPUART_STATE_RX_MASK) == 0x0)
return BUSY;
do {
i = 10000;
tmp = hperh->perh->STAT & LPUART_STAT_RXPTR_MSK;
*hperh->rx_buf++ = (uint8_t)(hperh->perh->RXDR & 0xFF);
--hperh->rx_count;
while (((hp... |
functions | void ald_lpuart_reset(lpuart_handle_t *hperh)
{
WRITE_REG(hperh->perh->CON0, 0x3000);
WRITE_REG(hperh->perh->CON1, 0x4);
WRITE_REG(hperh->perh->CLKDIV, 0x0);
WRITE_REG(hperh->perh->FIFOCON, 0x0);
WRITE_REG(hperh->perh->IER, 0x0);
hperh->err_code = LPUART_ERROR_NONE;
hperh->state = LPUART_STATE_RESET;
__UNLO... |
functions | void ald_lpuart_init(lpuart_handle_t *hperh)
{
uint32_t tmp;
assert_param(IS_LPUART(hperh->perh));
assert_param(IS_LPUART_BAUDRATE(hperh->init.baud));
assert_param(IS_LPUART_WORD_LENGTH(hperh->init.word_length));
assert_param(IS_LPUART_STOPBITS(hperh->init.stop_bits));
assert_param(IS_LPUART_PARITY(hperh->init.p... |
functions | void ald_lpuart_rs485_config(lpuart_handle_t *hperh, lpuart_rs485_config_t *config)
{
uint32_t tmp;
assert_param(IS_LPUART(hperh->perh));
assert_param(IS_FUNC_STATE(config->RS485_NMM));
assert_param(IS_FUNC_STATE(config->RS485_AAD));
assert_param(IS_FUNC_STATE(config->RS485_AUD));
assert_param(IS_FUNC_STATE(conf... |
functions | ald_status_t ald_lpuart_send(lpuart_handle_t *hperh, uint8_t *buf, uint16_t size, uint32_t timeout)
{
if ((hperh->state != LPUART_STATE_READY) && (hperh->state != LPUART_STATE_BUSY_RX))
return BUSY;
if ((buf == NULL) || (size == 0))
return ERROR;
__LOCK(hperh);
hperh->err_code = LPUART_ERROR_NONE;
SET_BIT(h... |
functions | ald_status_t ald_lpuart_recv(lpuart_handle_t *hperh, uint8_t *buf, uint16_t size, uint32_t timeout)
{
if ((hperh->state != LPUART_STATE_READY) && (hperh->state != LPUART_STATE_BUSY_TX))
return BUSY;
if ((buf == NULL ) || (size == 0))
return ERROR;
__LOCK(hperh);
hperh->err_code = LPUART_ERROR_NONE;
SET_BIT... |
functions | ald_status_t ald_lpuart_send_by_it(lpuart_handle_t *hperh, uint8_t *buf, uint16_t size)
{
if ((hperh->state != LPUART_STATE_READY) && (hperh->state != LPUART_STATE_BUSY_RX))
return BUSY;
if ((buf == NULL ) || (size == 0))
return ERROR;
__LOCK(hperh);
hperh->tx_buf = buf;
hperh->tx_size = size;
hperh->tx... |
functions | ald_status_t ald_lpuart_recv_by_it(lpuart_handle_t *hperh, uint8_t *buf, uint16_t size)
{
if ((hperh->state != LPUART_STATE_READY) && (hperh->state != LPUART_STATE_BUSY_TX))
return BUSY;
if ((buf == NULL ) || (size == 0))
return ERROR;
__LOCK(hperh);
hperh->rx_buf = buf;
hperh->rx_size = size;
hperh->rx... |
functions | ald_status_t ald_lpuart_send_by_dma(lpuart_handle_t *hperh, uint8_t *buf, uint16_t size, uint8_t channel)
{
if ((hperh->state != LPUART_STATE_READY) && (hperh->state != LPUART_STATE_BUSY_RX))
return BUSY;
if ((buf == NULL ) || (size == 0))
return ERROR;
__LOCK(hperh);
hperh->tx_buf = buf;
hperh->tx_size ... |
functions | ald_status_t ald_lpuart_recv_by_dma(lpuart_handle_t *hperh, uint8_t *buf, uint16_t size, uint8_t channel)
{
if ((hperh->state != LPUART_STATE_READY) && (hperh->state != LPUART_STATE_BUSY_TX))
return BUSY;
if ((buf == NULL ) || (size == 0))
return ERROR;
__LOCK(hperh);
hperh->rx_buf = buf;
hperh->rx_size ... |
functions | ald_status_t ald_lpuart_dma_pause(lpuart_handle_t *hperh)
{
__LOCK(hperh);
if (hperh->state == LPUART_STATE_BUSY_TX) {
ald_lpuart_dma_req_config(hperh, LPUART_DMA_REQ_TX, DISABLE);
} |
functions | else if (hperh->state == LPUART_STATE_BUSY_RX) {
ald_lpuart_dma_req_config(hperh, LPUART_DMA_REQ_RX, DISABLE);
} |
functions | else if (hperh->state == LPUART_STATE_BUSY_TX_RX) {
ald_lpuart_dma_req_config(hperh, LPUART_DMA_REQ_TX, DISABLE);
ald_lpuart_dma_req_config(hperh, LPUART_DMA_REQ_RX, DISABLE);
} |
functions | ald_status_t ald_lpuart_dma_resume(lpuart_handle_t *hperh)
{
__LOCK(hperh);
if (hperh->state == LPUART_STATE_BUSY_TX) {
ald_lpuart_dma_req_config(hperh, LPUART_DMA_REQ_TX, ENABLE);
} |
functions | else if (hperh->state == LPUART_STATE_BUSY_RX) {
ald_lpuart_clear_flag_status(hperh, LPUART_IF_RXOV);
ald_lpuart_dma_req_config(hperh, LPUART_DMA_REQ_RX, ENABLE);
} |
functions | else if (hperh->state == LPUART_STATE_BUSY_TX_RX) {
ald_lpuart_clear_flag_status(hperh, LPUART_IF_RXOV);
ald_lpuart_dma_req_config(hperh, LPUART_DMA_REQ_TX, ENABLE);
ald_lpuart_dma_req_config(hperh, LPUART_DMA_REQ_RX, ENABLE);
} |
functions | ald_status_t ald_lpuart_dma_stop(lpuart_handle_t *hperh)
{
ald_lpuart_dma_req_config(hperh, LPUART_DMA_REQ_TX, DISABLE);
ald_lpuart_dma_req_config(hperh, LPUART_DMA_REQ_RX, DISABLE);
hperh->state = LPUART_STATE_READY;
return OK;
} |
functions | void ald_lpuart_irq_handler(lpuart_handle_t *hperh)
{
uint32_t flag;
uint32_t source;
/* Handle CTS wakeup */
flag = ald_lpuart_get_flag_status(hperh, LPUART_IF_CTSWK);
source = ald_lpuart_get_it_status(hperh, LPUART_IT_CTSWK);
if ((flag != RESET) && (source != RESET))
ald_lpuart_clear_flag_status(hperh, LPUAR... |
functions | void ald_lpuart_interrupt_config(lpuart_handle_t *hperh, lpuart_it_t it, type_func_t status)
{
assert_param(IS_LPUART(hperh->perh));
assert_param(IS_LPUART_IT(it));
assert_param(IS_FUNC_STATE(status));
if (status == ENABLE)
SET_BIT(hperh->perh->IER, it);
else
CLEAR_BIT(hperh->perh->IER, it);
return;
} |
functions | void ald_lpuart_tx_interval_config(lpuart_handle_t *hperh, uint8_t val)
{
assert_param(IS_LPUART(hperh->perh));
MODIFY_REG(hperh->perh->CON0, LPUART_CON0_INTERVAL_MSK, val << LPUART_CON0_INTERVAL_POSS);
return;
} |
functions | void ald_lpuart_dma_req_config(lpuart_handle_t *hperh, lpuart_dma_req_t req, type_func_t status)
{
assert_param(IS_LPUART(hperh->perh));
assert_param(IS_LPUART_DMAREQ(req));
assert_param(IS_FUNC_STATE(status));
if (req == LPUART_DMA_REQ_TX) {
if (status == ENABLE)
SET_BIT(hperh->perh->CON0, LPUART_CON0_TXDMAE... |
functions | void ald_lpuart_rx_fifo_it_config(lpuart_handle_t *hperh, lpuart_rxfifo_t config)
{
assert_param(IS_LPUART(hperh->perh));
assert_param(IS_LPUART_RXFIFO(config));
MODIFY_REG(hperh->perh->FIFOCON, LPUART_FIFOCON_RXTRGLVL_MSK, config << LPUART_FIFOCON_RXTRGLVL_POSS);
return;
} |
functions | void ald_lpuart_rx_fifo_rts_config(lpuart_handle_t *hperh, lpuart_rxfifo_t config)
{
assert_param(IS_LPUART(hperh->perh));
assert_param(IS_LPUART_RXFIFO(config));
MODIFY_REG(hperh->perh->FIFOCON, LPUART_FIFOCON_RTSTRGLVL_MSK, config << LPUART_FIFOCON_RTSTRGLVL_POSS);
return;
} |
functions | ald_status_t ald_lpuart_rs485_send_addr(lpuart_handle_t *hperh, uint16_t addr, uint32_t timeout)
{
assert_param(IS_LPUART(hperh->perh));
if ((hperh->state != LPUART_STATE_READY) && (hperh->state != LPUART_STATE_BUSY_RX))
return BUSY;
SET_BIT(hperh->state, LPUART_STATE_TX_MASK);
if (lpuart_wait_flag(hperh, LPUA... |
functions | flag_status_t ald_lpuart_get_status(lpuart_handle_t *hperh, lpuart_status_t flag)
{
assert_param(IS_LPUART(hperh->perh));
assert_param(IS_LPUART_STAT(flag));
if (READ_BIT(hperh->perh->STAT, flag))
return SET;
return RESET;
} |
functions | flag_status_t ald_lpuart_get_flag_status(lpuart_handle_t *hperh, lpuart_flag_t flag)
{
assert_param(IS_LPUART(hperh->perh));
assert_param(IS_LPUART_IF(flag));
if (READ_BIT(hperh->perh->IFLAG, flag))
return SET;
return RESET;
} |
functions | void ald_lpuart_clear_flag_status(lpuart_handle_t *hperh, lpuart_flag_t flag)
{
assert_param(IS_LPUART(hperh->perh));
assert_param(IS_LPUART_IF(flag));
WRITE_REG(hperh->perh->IFC, flag);
return;
} |
functions | it_status_t ald_lpuart_get_it_status(lpuart_handle_t *hperh, lpuart_it_t it)
{
assert_param(IS_LPUART(hperh->perh));
assert_param(IS_LPUART_IT(it));
if (READ_BIT(hperh->perh->IER, it))
return SET;
return RESET;
} |
functions | lpuart_state_t ald_lpuart_get_state(lpuart_handle_t *hperh)
{
return hperh->state;
} |
functions | uint32_t ald_lpuart_get_error(lpuart_handle_t *hperh)
{
return hperh->err_code;
} |
defines | #define _DEBUG_INSTRUCTION_EXECUTION_ |
defines |
#define NB_CACHE_WAYS 4 |
functions | int arm946e_init_arch_info(struct target *target, struct arm946e_common *arm946e, struct jtag_tap *tap)
{
struct arm7_9_common *arm7_9 = &arm946e->arm7_9_common;
/* initialize arm7/arm9 specific info (including armv4_5) */
arm9tdmi_init_arch_info(target, arm7_9, tap);
arm946e->common_magic = ARM946E_COMMON_MAGIC;... |
functions | int arm946e_target_create(struct target *target, Jim_Interp *interp)
{
struct arm946e_common *arm946e = calloc(1,sizeof(struct arm946e_common));
arm946e_init_arch_info(target, arm946e, target->tap);
return ERROR_OK;
} |
functions | int arm946e_verify_pointer(struct command_context *cmd_ctx,
struct arm946e_common *arm946e)
{
if (arm946e->common_magic != ARM946E_COMMON_MAGIC) {
command_print(cmd_ctx, "target is not an ARM946");
return ERROR_TARGET_INVALID;
} |
functions | int arm946e_read_cp15(struct target *target, int reg_addr, uint32_t *value)
{
int retval = ERROR_OK;
struct arm7_9_common *arm7_9 = target_to_arm7_9(target);
struct arm_jtag *jtag_info = &arm7_9->jtag_info;
struct scan_field fields[3];
uint8_t reg_addr_buf = reg_addr & 0x3f;
uint8_t nr_w_buf = 0;
if ((retval = ... |
functions | int arm946e_write_cp15(struct target *target, int reg_addr, uint32_t value)
{
int retval = ERROR_OK;
struct arm7_9_common *arm7_9 = target_to_arm7_9(target);
struct arm_jtag *jtag_info = &arm7_9->jtag_info;
struct scan_field fields[3];
uint8_t reg_addr_buf = reg_addr & 0x3f;
uint8_t nr_w_buf = 1;
uint8_t value_b... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.