type stringclasses 5
values | content stringlengths 9 163k |
|---|---|
includes | #include <sys/sunddi.h> |
includes | #include <sys/ksynch.h> |
includes | #include <sys/conf.h> |
includes | #include <sys/kmem.h> |
includes | #include <sys/kcpc.h> |
includes | #include <sys/cap_util.h> |
includes | #include <sys/cpc_pcbe.h> |
includes | #include <sys/cpc_impl.h> |
includes | #include <sys/dtrace_impl.h> |
defines | #define DCPC_MIN_OVF_DEFAULT 5000 |
defines | #define DCPC_ARTIFICIAL_FRAMES 8 |
defines | #define DCPC_ARTIFICIAL_FRAMES 2 |
functions | void
dcpc_fire(uint64_t bitmap)
{
int i;
/*
* No counter was marked as overflowing. Shout about it and get out.
*/
if ((bitmap & dcpc_ovf_mask) == 0) {
cmn_err(CE_NOTE, "dcpc_fire: no counter overflow found\n");
return;
} |
functions | void
dcpc_create_probe(dtrace_provider_id_t id, const char *probename,
char *eventname, int64_t umask, uint32_t ovfval, char flag)
{
dcpc_probe_t *pp;
int nr_frames = DCPC_ARTIFICIAL_FRAMES + dtrace_mach_aframes();
if (dcpc_aframes)
nr_frames = dcpc_aframes;
if (dtrace_probe_lookup(id, NULL, NULL, probename... |
functions | void
dcpc_provide(void *arg, const dtrace_probedesc_t *desc)
{
/*
* The format of a probe is:
*
* event_name-mode-{optional_umask} |
functions | void
dcpc_destroy(void *arg, dtrace_id_t id, void *parg)
{
dcpc_probe_t *pp = parg;
ASSERT(pp->dcpc_enabled == 0);
kmem_free(pp, sizeof (dcpc_probe_t));
} |
functions | int
dcpc_usermode(void *arg, dtrace_id_t id, void *parg)
{
return (CPU->cpu_cpcprofile_pc == 0);
} |
functions | void
dcpc_populate_set(cpu_t *c, dcpc_probe_t *pp, kcpc_set_t *set, int reqno)
{
kcpc_set_t *oset;
int i;
(void) strncpy(set->ks_req[reqno].kr_event, pp->dcpc_event_name,
CPC_MAX_EVENT_LEN);
set->ks_req[reqno].kr_config = NULL;
set->ks_req[reqno].kr_index = reqno;
set->ks_req[reqno].kr_picnum = -1;
set->ks... |
functions | int
dcpc_program_cpu_event(cpu_t *c)
{
int i, j, subcode;
kcpc_ctx_t *ctx, *octx;
kcpc_set_t *set;
set = dcpc_create_set(c);
set->ks_ctx = ctx = kcpc_ctx_alloc(KM_SLEEP);
ctx->kc_set = set;
ctx->kc_cpuid = c->cpu_id;
if (kcpc_assign_reqs(set, ctx) != 0)
goto err;
if (kcpc_configure_reqs(ctx, set, &subcod... |
functions | void
dcpc_disable_cpu(cpu_t *c)
{
kcpc_ctx_t *ctx;
kcpc_set_t *set;
/*
* Leave this CPU alone if it's already offline.
*/
if (c->cpu_flags & CPU_OFFLINE)
return;
/*
* Grab CPUs CPC context before kcpc_cpu_stop() stops counters and
* changes it.
*/
ctx = c->cpu_cpc_ctx;
kcpc_cpu_stop(c, B_FALSE);
... |
functions | void
dcpc_block_interrupts(void)
{
cpu_t *c = cpu_list;
uint8_t *state;
ASSERT(cpu_core[c->cpu_id].cpuc_dcpc_intr_state != DCPC_INTR_INACTIVE);
do {
state = &cpu_core[c->cpu_id].cpuc_dcpc_intr_state;
while (atomic_cas_8(state, DCPC_INTR_FREE,
DCPC_INTR_CONFIG) != DCPC_INTR_FREE)
continue;
} |
functions | void
dcpc_release_interrupts(void)
{
cpu_t *c = cpu_list;
ASSERT(cpu_core[c->cpu_id].cpuc_dcpc_intr_state != DCPC_INTR_INACTIVE);
do {
cpu_core[c->cpu_id].cpuc_dcpc_intr_state = DCPC_INTR_FREE;
membar_producer();
} |
functions | void
dcpc_claim_interrupts(void)
{
cpu_t *c = cpu_list;
ASSERT(cpu_core[c->cpu_id].cpuc_dcpc_intr_state == DCPC_INTR_INACTIVE);
do {
cpu_core[c->cpu_id].cpuc_dcpc_intr_state = DCPC_INTR_FREE;
membar_producer();
} |
functions | void
dcpc_surrender_interrupts(void)
{
cpu_t *c = cpu_list;
ASSERT(cpu_core[c->cpu_id].cpuc_dcpc_intr_state != DCPC_INTR_INACTIVE);
do {
cpu_core[c->cpu_id].cpuc_dcpc_intr_state = DCPC_INTR_INACTIVE;
membar_producer();
} |
functions | int
dcpc_program_event(dcpc_probe_t *pp)
{
cpu_t *c;
int ret = 0;
ASSERT(MUTEX_HELD(&cpu_lock));
kpreempt_disable();
dcpc_block_interrupts();
c = cpu_list;
do {
/*
* Skip CPUs that are currently offline.
*/
if (c->cpu_flags & CPU_OFFLINE)
continue;
/*
* Stop counters but preserve existing... |
functions | int
dcpc_enable(void *arg, dtrace_id_t id, void *parg)
{
dcpc_probe_t *pp = parg;
int i, found = 0;
cpu_t *c;
ASSERT(MUTEX_HELD(&cpu_lock));
/*
* Bail out if the counters are being used by a libcpc consumer.
*/
rw_enter(&kcpc_cpuctx_lock, RW_READER);
if (kcpc_cpuctx > 0) {
rw_exit(&kcpc_cpuctx_lock);
r... |
functions | void
dcpc_disable(void *arg, dtrace_id_t id, void *parg)
{
cpu_t *c;
dcpc_probe_t *pp = parg;
ASSERT(MUTEX_HELD(&cpu_lock));
kpreempt_disable();
/*
* This probe didn't actually make it as far as being fully enabled
* so we needn't do anything with it.
*/
if (pp->dcpc_enabled == 0) {
/*
* If we actua... |
functions | int
dcpc_cpu_setup(cpu_setup_t what, processorid_t cpu, void *arg)
{
cpu_t *c;
uint8_t *state;
ASSERT(MUTEX_HELD(&cpu_lock));
switch (what) {
case CPU_OFF:
/*
* Offline CPUs are not allowed to take part so remove this
* CPU if we are actively tracing.
*/
if (dtrace_cpc_in_use) {
c = cpu_get(cpu);... |
functions | int
dcpc_open(dev_t *devp, int flag, int otyp, cred_t *cred_p)
{
return (0);
} |
functions | int
dcpc_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
{
int error;
switch (infocmd) {
case DDI_INFO_DEVT2DEVINFO:
*result = (void *)dcpc_devi;
error = DDI_SUCCESS;
break;
case DDI_INFO_DEVT2INSTANCE:
*result = (void *)0;
error = DDI_SUCCESS;
break;
default:
error = DDI_FAI... |
functions | int
dcpc_detach(dev_info_t *devi, ddi_detach_cmd_t cmd)
{
switch (cmd) {
case DDI_DETACH:
break;
case DDI_SUSPEND:
return (DDI_SUCCESS);
default:
return (DDI_FAILURE);
} |
functions | int
dcpc_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
{
uint_t caps;
char *attrs;
switch (cmd) {
case DDI_ATTACH:
break;
case DDI_RESUME:
return (DDI_SUCCESS);
default:
return (DDI_FAILURE);
} |
functions | int
_init(void)
{
return (mod_install(&modlinkage));
} |
functions | int
_info(struct modinfo *modinfop)
{
return (mod_info(&modlinkage, modinfop));
} |
functions | int
_fini(void)
{
return (mod_remove(&modlinkage));
} |
includes | #include <common.h> |
includes | #include <linux/sizes.h> |
includes | #include <io.h> |
includes | #include <asm/barebox-arm-head.h> |
includes | #include <asm/barebox-arm.h> |
includes | #include <mach/generic.h> |
includes | #include <debug_ll.h> |
includes | #include <asm/cache.h> |
includes | #include <mach/sdram_config.h> |
includes | #include <mach/pll_config.h> |
includes | #include <mach/sequencer.c> |
functions | void ledon(int led)
{
u32 val;
val = readl(0xFF709000);
val |= 1 << (led + 24);
writel(val, 0xFF709000);
val = readl(0xFF709004);
val |= 1 << (led + 24);
writel(val, 0xFF709004);
} |
functions | void ledoff(int led)
{
u32 val;
val = readl(0xFF709000);
val &= ~(1 << (led + 24));
writel(val, 0xFF709000);
val = readl(0xFF709004);
val &= ~(1 << (led + 24));
writel(val, 0xFF709004);
} |
functions | void sockit_entry(void)
{
struct socfpga_io_config io_config;
int ret;
arm_early_mmu_cache_invalidate();
relocate_to_current_adr();
setup_c();
io_config.pinmux = sys_mgr_init_table;
io_config.num_pin = ARRAY_SIZE(sys_mgr_init_table);
io_config.iocsr_emac_mixed2 = iocsr_scan_chain0_table;
io_config.iocsr_mix... |
functions | void ddl_set_default_meta_data_hdr(struct ddl_client_context *ddl)
{
struct ddl_buf_addr *main_buffer =
&ddl->ddl_context->metadata_shared_input;
struct ddl_buf_addr *client_buffer;
u32 *hdr_entry;
if (ddl->decoding)
client_buffer = &(ddl->codec_data.decoder.meta_data_input);
else
client_buffer = &(ddl->cod... |
functions | u32 ddl_supported_metadata_flag(struct ddl_client_context *ddl)
{
u32 flag = 0;
if (ddl->decoding) {
enum vcd_codec codec =
ddl->codec_data.decoder.codec.codec;
flag |= (VCD_METADATA_CONCEALMB | VCD_METADATA_PASSTHROUGH |
VCD_METADATA_QPARRAY);
if (codec == VCD_CODEC_H264)
flag |= (VCD_METADATA_SEI ... |
functions | void ddl_set_default_metadata_flag(struct ddl_client_context *ddl)
{
if (ddl->decoding)
ddl->codec_data.decoder.meta_data_enable_flag = 0;
else
ddl->codec_data.encoder.meta_data_enable_flag = 0;
} |
functions | void ddl_set_default_decoder_metadata_buffer_size(struct ddl_decoder_data
*decoder, struct vcd_property_frame_size *frame_size,
struct vcd_buffer_requirement *output_buf_req)
{
u32 flag = decoder->meta_data_enable_flag;
u32 suffix = 0, size = 0;
if (!flag) {
decoder->suffix = 0;
return;
} |
functions | void ddl_set_default_encoder_metadata_buffer_size(struct ddl_encoder_data
*encoder)
{
u32 flag = encoder->meta_data_enable_flag;
u32 suffix = 0, size = 0;
if (!flag) {
encoder->suffix = 0;
return;
} |
functions | u32 ddl_set_metadata_params(struct ddl_client_context *ddl,
struct vcd_property_hdr *property_hdr, void *property_value)
{
u32 vcd_status = VCD_ERR_ILLEGAL_PARM;
if (property_hdr->prop_id == VCD_I_METADATA_ENABLE) {
struct vcd_property_meta_data_enable *meta_data_enable =
(struct vcd_property_meta_data_enable ... |
functions | else if (property_hdr->prop_id == VCD_I_METADATA_HEADER) {
struct vcd_property_metadata_hdr *hdr =
(struct vcd_property_metadata_hdr *) property_value;
if (sizeof(struct vcd_property_metadata_hdr) ==
property_hdr->sz) {
u32 flag = ddl_supported_metadata_flag(ddl);
flag |= DDL_METADATA_MANDATORY;
fl... |
functions | u32 ddl_get_metadata_params(struct ddl_client_context *ddl,
struct vcd_property_hdr *property_hdr, void *property_value)
{
u32 vcd_status = VCD_ERR_ILLEGAL_PARM;
if (property_hdr->prop_id == VCD_I_METADATA_ENABLE &&
sizeof(struct vcd_property_meta_data_enable) ==
property_hdr->sz) {
struct vcd_property_meta_da... |
functions | void ddl_vidc_metadata_enable(struct ddl_client_context *ddl)
{
u32 flag, extradata_enable = false;
u32 qp_enable = false, concealed_mb_enable = false;
u32 vc1_param_enable = false, sei_nal_enable = false;
u32 vui_enable = false, enc_slice_size_enable = false;
if (ddl->decoding)
flag = ddl->codec_data.decoder.m... |
functions | u32 ddl_vidc_encode_set_metadata_output_buf(struct ddl_client_context *ddl)
{
struct ddl_encoder_data *encoder = &ddl->codec_data.encoder;
struct vcd_frame_data *stream = &ddl->output_frame.vcd_frm;
struct ddl_context *ddl_context;
u32 ext_buffer_end, hw_metadata_start;
u32 *buffer;
ddl_context = ddl_get_context... |
functions | void ddl_vidc_decode_set_metadata_output(struct ddl_decoder_data *decoder)
{
struct ddl_context *ddl_context;
u32 loopc, yuv_size;
u32 *buffer;
if (!decoder->meta_data_enable_flag) {
decoder->meta_data_offset = 0;
return;
} |
functions | void ddl_process_encoder_metadata(struct ddl_client_context *ddl)
{
struct ddl_encoder_data *encoder = &(ddl->codec_data.encoder);
struct vcd_frame_data *out_frame =
&(ddl->output_frame.vcd_frm);
u32 *qfiller_hdr, *qfiller, start_addr;
u32 qfiller_size;
if (!encoder->meta_data_enable_flag) {
out_frame->flags &... |
functions | void ddl_process_decoder_metadata(struct ddl_client_context *ddl)
{
struct ddl_decoder_data *decoder = &(ddl->codec_data.decoder);
struct vcd_frame_data *output_frame =
&(ddl->output_frame.vcd_frm);
u32 *qfiller_hdr, *qfiller;
u32 qfiller_size;
if (!decoder->meta_data_enable_flag) {
output_frame->flags &= ~(V... |
includes |
#include <common.h> |
includes | #include <asm/fsl_portals.h> |
includes | #include <asm/fsl_liodn.h> |
defines |
#define COMPRESS_ID 1 |
defines |
#define DDBITS 0 |
defines | #define CLEVEL 1 |
includes |
#include <stdint.h> |
includes | #include <inttypes.h> |
includes | #include <string.h> |
includes | #include <sys/mman.h> |
defines | #define NUM_LBTABLE_CHOICES 14 |
defines |
#define NUM_MEM_RANGES 2 |
defines | #define vtophys(vaddr) (((unsigned long) vaddr) - \ |
defines | #define phystov(paddr) (((unsigned long) low_phys_mem) + \ |
functions | void map_pages(unsigned long base_address, unsigned long length)
{
unsigned long num_pages = (length +
(base_address & (getpagesize() - 1)) +
getpagesize() - 1) >> 12;
base_address &= ~(getpagesize() - 1);
/* no need to do anything */
if ((low_phys_base == base_address) && (mapped_pages == num_pages)) {
re... |
functions | void get_lbtable(void)
{
int i, bad_header_count, bad_table_count, bad_headers, bad_tables;
if (lbtable != NULL)
return;
/* The coreboot table is located in low physical memory, which may be
* conveniently accessed by calling mmap() on /dev/mem.
*/
if ((fd = open("/dev/mem", O_RDONLY, 0)) < 0) {
fprintf(... |
functions | void dump_lbtable(void)
{
const char *p, *data;
uint32_t bytes_processed;
const struct lb_record *lbrec;
p = ((const char *)lbtable) + lbtable->header_bytes;
printf("Coreboot table at physical address 0x%lx:\n"
" signature: 0x%x (ASCII: %c%c%c%c)\n"
" header_bytes: 0x%x (decimal: %d... |
functions | void list_lbtable_choices(void)
{
int i;
for (i = 0;;) {
printf("%s:\n%s",
lbtable_choices[i].name, lbtable_choices[i].description);
if (++i >= NUM_LBTABLE_CHOICES)
break;
printf("\n");
} |
functions | void list_lbtable_item(const char item[])
{
int i;
const struct lb_record *rec;
for (i = 0; i < NUM_LBTABLE_CHOICES; i++) {
if (strcmp(item, lbtable_choices[i].name) == 0)
break;
} |
functions | void memory_print_fn(const struct lb_record *rec)
{
const struct lb_memory *p;
const char *mem_type;
const struct lb_memory_range *ranges;
uint64_t size, start, end;
int i, entries;
p = (const struct lb_memory *)rec;
entries = (p->size - sizeof(*p)) / sizeof(p->map[0]);
ranges = p->map;
if (entries == 0) {
... |
functions | void mainboard_print_fn(const struct lb_record *rec)
{
const struct lb_mainboard *p;
p = (const struct lb_mainboard *)rec;
printf("Vendor: %s\n"
"Part number: %s\n",
&p->strings[p->vendor_idx], &p->strings[p->part_number_idx]);
} |
functions | void cmos_opt_table_print_fn(const struct lb_record *rec)
{
const struct cmos_option_table *p;
const struct lb_record *cmos_item;
uint32_t bytes_processed, bytes_for_entries;
const char *q;
p = (const struct cmos_option_table *)rec;
q = ((const char *)p) + p->header_length;
bytes_for_entries = p->size - p->head... |
functions | void print_option_record(const struct cmos_entries *cmos_entry)
{
static const size_t S_BUFSIZE = 80;
char s[S_BUFSIZE];
switch (cmos_entry->config) {
case 'e':
strcpy(s, "ENUM");
break;
case 'h':
strcpy(s, "HEX");
break;
case 'r':
strcpy(s, "RESERVED");
break;
default:
snprintf(s, S_BUFSIZE, "... |
functions | void print_enum_record(const struct cmos_enums *cmos_enum)
{
printf(" ENUM record at physical address 0x%lx:\n"
" tag: 0x%x (decimal: %d)\n"
" size: 0x%x (decimal: %d)\n"
" config_id: 0x%x (decimal: %d)\n"
" value: 0x%x (decimal: %d)\n"
... |
functions | void print_defaults_record(const struct cmos_defaults *cmos_defaults)
{
printf(" DEFAULTS record at physical address 0x%lx:\n"
" tag: 0x%x (decimal: %d)\n"
" size: 0x%x (decimal: %d)\n"
" name_length: 0x%x (decimal: %d)\n"
" name: %s\... |
functions | void print_unknown_record(const struct lb_record *cmos_item)
{
const char *data;
printf(" UNKNOWN record at physical address 0x%lx:\n"
" tag: 0x%x (decimal: %d)\n"
" size: 0x%x (decimal: %d)\n"
" data:\n",
vtophys(cmos_item), cmos_item->tag, cmos_item->tag,
... |
functions | void option_checksum_print_fn(const struct lb_record *rec)
{
struct cmos_checksum *p;
p = (struct cmos_checksum *)rec;
printf("CMOS checksum from bit %d to bit %d\n"
"at position %d is type %s.\n",
p->range_start, p->range_end, p->location,
(p->type == CHECKSUM_PCBIOS) ? "PC BIOS" : "NONE");... |
functions | void string_print_fn(const struct lb_record *rec)
{
const struct lb_string *p;
p = (const struct lb_string *)rec;
printf("%s\n", p->string);
} |
includes |
#include <console/console.h> |
includes | #include <device/device.h> |
includes | #include <device/dram/ddr3.h> |
functions | int dimm_is_registered(enum spd_dimm_type type)
{
if ((type == SPD_DIMM_TYPE_RDIMM)
| (type == SPD_DIMM_TYPE_MINI_RDIMM)
| (type == SPD_DIMM_TYPE_72B_SO_RDIMM))
return 1;
return 0;
} |
functions | u16 spd_ddr3_calc_crc(u8 *spd, int len)
{
int n_crc, i;
u8 *ptr;
u16 crc;
/* Find the number of bytes covered by CRC */
if (spd[0] & 0x80) {
n_crc = 117;
} |
functions | int spd_decode_ddr3(dimm_attr * dimm, spd_raw_data spd)
{
int ret;
u16 crc, spd_crc;
u8 ftb_divisor, ftb_dividend, capacity_shift, bus_width;
u8 reg8;
u32 mtb; /* medium time base */
unsigned int val, param;
ret = SPD_STATUS_OK;
/* Don't assume we memset 0 dimm struct. Clear all our flags */
dimm->flags.raw... |
functions | void print_ns(const char *msg, u32 val)
{
u32 mant, fp;
mant = val / 256;
fp = (val % 256) * 1000 / 256;
printk(BIOS_INFO, "%s%3u.%.3u ns\n", msg, mant, fp);
} |
functions | void dram_print_spd_ddr3(const dimm_attr * dimm)
{
u16 val16;
int i;
printk(BIOS_INFO, " Row addr bits : %u\n", dimm->row_bits);
printk(BIOS_INFO, " Column addr bits : %u\n", dimm->col_bits);
printk(BIOS_INFO, " Number of ranks : %u\n", dimm->ranks);
printk(BIOS_INFO, " DIMM Capacity : %u MB\n", d... |
functions | u16 ddr3_twr_to_mr0_map(u8 twr)
{
if ((twr >= 5) && (twr <= 8))
return (twr - 4) << 9;
/*
* From 8T onwards, we can only use even values. Round up if we are
* given an odd value.
*/
if ((twr >= 9) && (twr <= 14))
return ((twr + 1) >> 1) << 9;
/* tWR == 16T is [000] */
return 0;
} |
functions | u16 ddr3_cas_to_mr0_map(u8 cas)
{
u16 mask = 0;
/* A[6:4] are bits [2:0] of (CAS - 4) */
mask = ((cas - 4) & 0x07) << 4;
/* A2 is the MSB of (CAS - 4) */
if ((cas - 4) & (1 << 3))
mask |= (1 << 2);
return mask;
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.