static int acpi_processor_power_seq_show(struct seq_file *seq, void *offset)
{
	struct acpi_processor *pr = seq->private;
	unsigned int i;


	if (!pr)
		goto end;

	seq_printf(seq, "active state:            C%zd\n"
		   "max_cstate:              C%d\n"
		   "maximum allowed latency: %d usec\n",
		   pr->power.state ? pr->power.state - pr->power.states : 0,
		   max_cstate, pm_qos_requirement(PM_QOS_CPU_DMA_LATENCY));

	seq_puts(seq, "states:\n");

	for (i = 1; i <= pr->power.count; i++) {
		seq_printf(seq, "   %cC%d:                  ",
			   (&pr->power.states[i] ==
			    pr->power.state ? '*' : ' '), i);

		if (!pr->power.states[i].valid) {
			seq_puts(seq, "<not supported>\n");
			continue;
		}

		switch (pr->power.states[i].type) {
		case ACPI_STATE_C1:
			seq_printf(seq, "type[C1] ");
			break;
		case ACPI_STATE_C2:
			seq_printf(seq, "type[C2] ");
			break;
		case ACPI_STATE_C3:
			seq_printf(seq, "type[C3] ");
			break;
		default:
			seq_printf(seq, "type[--] ");
			break;
		}

		if (pr->power.states[i].promotion.state)
			seq_printf(seq, "promotion[C%zd] ",
				   (pr->power.states[i].promotion.state -
				    pr->power.states));
		else
			seq_puts(seq, "promotion[--] ");

		if (pr->power.states[i].demotion.state)
			seq_printf(seq, "demotion[C%zd] ",
				   (pr->power.states[i].demotion.state -
				    pr->power.states));
		else
			seq_puts(seq, "demotion[--] ");

		seq_printf(seq, "latency[%03d] usage[%08d] duration[%020llu]\n",
			   pr->power.states[i].latency,
			   pr->power.states[i].usage,
			   (unsigned long long)pr->power.states[i].time);
	}

      end:
	return 0;
}
Ejemplo n.º 2
0
static int mdfld_dc_pipeline_b_regs_info(struct seq_file *m, void *data)
{
	struct drm_info_node *node = (struct drm_info_node *)m->private;
	struct drm_device *dev = node->minor->dev;
	int i;

	seq_printf(m, "DISPLAY PIPELINE B\n");

	seq_printf(m, "\tPALETTE B:\n");
	seq_printf(m, "\t\t reg(0xa800) = 0x%x\n", REG_READ(0xa800));

	seq_printf(m, "\tPIPELINE B:\n");
	for (i=0x61000; i<0x610ff; i+=4)
		seq_printf(m, "\t\t reg(0x%x) = 0x%x\n", i, REG_READ(i));

	seq_printf(m, "\tHDMI PORT CONTROL/HDCP/TV:\n");
	for (i=0x61110; i<=0x61178; i+=4)
		seq_printf(m, "\t\t reg(0x%x) = 0x%x\n", i, REG_READ(i));

	seq_printf(m, "\tPANEL FITTING:\n");
	for (i=0x61200; i<0x612ff; i+=4)
		seq_printf(m, "\t\t reg(0x%x) = 0x%x\n", i, REG_READ(i));

	seq_printf(m, "\tPIPELINE B CONTROL:\n");
	for (i=0x71000; i<0x710ff; i+=4)
		seq_printf(m, "\t\t reg(0x%x) = 0x%x\n", i, REG_READ(i));

	return 0;
}
Ejemplo n.º 3
0
/*
 * Logic: we've got two memory sums for each process, "shared", and
 * "non-shared". Shared memory may get counted more than once, for
 * each process that owns it. Non-shared memory is counted
 * accurately.
 */
void task_mem(struct seq_file *m, struct mm_struct *mm)
{
	struct vm_area_struct *vma;
	struct vm_region *region;
	struct rb_node *p;
	unsigned long bytes = 0, sbytes = 0, slack = 0, size;
        
	down_read(&mm->mmap_sem);
	for (p = rb_first(&mm->mm_rb); p; p = rb_next(p)) {
		vma = rb_entry(p, struct vm_area_struct, vm_rb);

		bytes += kobjsize(vma);

		region = vma->vm_region;
		if (region) {
			size = kobjsize(region);
			size += region->vm_end - region->vm_start;
		} else {
			size = vma->vm_end - vma->vm_start;
		}

		if (atomic_read(&mm->mm_count) > 1 ||
		    vma->vm_flags & VM_MAYSHARE) {
			sbytes += size;
		} else {
			bytes += size;
			if (region)
				slack = region->vm_end - vma->vm_end;
		}
	}

	if (atomic_read(&mm->mm_count) > 1)
		sbytes += kobjsize(mm);
	else
		bytes += kobjsize(mm);
	
	if (current->fs && current->fs->users > 1)
		sbytes += kobjsize(current->fs);
	else
		bytes += kobjsize(current->fs);

	if (current->files && atomic_read(&current->files->count) > 1)
		sbytes += kobjsize(current->files);
	else
		bytes += kobjsize(current->files);

	if (current->sighand && atomic_read(&current->sighand->count) > 1)
		sbytes += kobjsize(current->sighand);
	else
		bytes += kobjsize(current->sighand);

	bytes += kobjsize(current); /* includes kernel stack */

	seq_printf(m,
		"Mem:\t%8lu bytes\n"
		"Slack:\t%8lu bytes\n"
		"Shared:\t%8lu bytes\n",
		bytes, slack, sbytes);

	up_read(&mm->mmap_sem);
}
Ejemplo n.º 4
0
static int wandev_show(struct seq_file *m, void *v)
{
	struct wan_device *wandev = m->private;

	if (wandev->magic != ROUTER_MAGIC)
		return 0;

	if (!wandev->state) {
		seq_puts(m, "device is not configured!\n");
		return 0;
	}

	/* Update device statistics */
	if (wandev->update) {
		int err = wandev->update(wandev);
		if (err == -EAGAIN) {
			seq_puts(m, "Device is busy!\n");
			return 0;
		}
		if (err) {
			seq_puts(m, "Device is not configured!\n");
			return 0;
		}
	}

	seq_printf(m, PROC_STATS_FORMAT,
		"total packets received", wandev->stats.rx_packets);
	seq_printf(m, PROC_STATS_FORMAT,
		"total packets transmitted", wandev->stats.tx_packets);
	seq_printf(m, PROC_STATS_FORMAT,
		"total bytes received", wandev->stats.rx_bytes);
	seq_printf(m, PROC_STATS_FORMAT,
		"total bytes transmitted", wandev->stats.tx_bytes);
	seq_printf(m, PROC_STATS_FORMAT,
		"bad packets received", wandev->stats.rx_errors);
	seq_printf(m, PROC_STATS_FORMAT,
		"packet transmit problems", wandev->stats.tx_errors);
	seq_printf(m, PROC_STATS_FORMAT,
		"received frames dropped", wandev->stats.rx_dropped);
	seq_printf(m, PROC_STATS_FORMAT,
		"transmit frames dropped", wandev->stats.tx_dropped);
	seq_printf(m, PROC_STATS_FORMAT,
		"multicast packets received", wandev->stats.multicast);
	seq_printf(m, PROC_STATS_FORMAT,
		"transmit collisions", wandev->stats.collisions);
	seq_printf(m, PROC_STATS_FORMAT,
		"receive length errors", wandev->stats.rx_length_errors);
	seq_printf(m, PROC_STATS_FORMAT,
		"receiver overrun errors", wandev->stats.rx_over_errors);
	seq_printf(m, PROC_STATS_FORMAT,
		"CRC errors", wandev->stats.rx_crc_errors);
	seq_printf(m, PROC_STATS_FORMAT,
		"frame format errors (aborts)", wandev->stats.rx_frame_errors);
	seq_printf(m, PROC_STATS_FORMAT,
		"receiver fifo overrun", wandev->stats.rx_fifo_errors);
	seq_printf(m, PROC_STATS_FORMAT,
		"receiver missed packet", wandev->stats.rx_missed_errors);
	seq_printf(m, PROC_STATS_FORMAT,
		"aborted frames transmitted", wandev->stats.tx_aborted_errors);
	return 0;
}
Ejemplo n.º 5
0
static int mdfld_dc_pipeline_c_regs_info(struct seq_file *m, void *data)
{
	struct drm_info_node *node = (struct drm_info_node *)m->private;
	struct drm_device *dev = node->minor->dev;
	int i;

	seq_printf(m, "DISPLAY PIPELINE C\n");
	seq_printf(m, "\tPALETTE C:\n");
	seq_printf(m, "\t\t reg(0xac00) = 0x%x\n", REG_READ(0xac00));

	seq_printf(m, "\tMIPI C:\n");
	for (i=0xb800; i<0xb8ff; i+=4)
		seq_printf(m, "\t\t reg(0x%x) = 0x%x\n", i, REG_READ(i));

	seq_printf(m, "\tDSI ADAPTER:\n");
	for (i=0xb904; i<=0xb938; i+=4)
		seq_printf(m, "\t\t reg(0x%x) = 0x%x\n", i, REG_READ(i));

	seq_printf(m, "\tPIPELINE C:\n");
	for (i=0x62000; i<0x620ff; i+=4)
		seq_printf(m, "\t\t reg(0x%x) = 0x%x\n", i, REG_READ(i));

	seq_printf(m, "\tPORT CONTROL:\n");
	for (i=0x62190; i<0x62194; i+=4)
		seq_printf(m, "\t\t reg(0x%x) = 0x%x\n", i, REG_READ(i));

	seq_printf(m, "\tPIPELINE C CONTROL:\n");
	for (i=0x72000; i<0x720ff; i+=4)
		seq_printf(m, "\t\t reg(0x%x) = 0x%x\n", i, REG_READ(i));

	return 0;
}
Ejemplo n.º 6
0
/* The debugfs functions are optimized away when CONFIG_DEBUG_FS isn't set. */
static int mmc_ios_show(struct seq_file *s, void *data)
{
	static const char *vdd_str[] = {
		[8]	= "2.0",
		[9]	= "2.1",
		[10]	= "2.2",
		[11]	= "2.3",
		[12]	= "2.4",
		[13]	= "2.5",
		[14]	= "2.6",
		[15]	= "2.7",
		[16]	= "2.8",
		[17]	= "2.9",
		[18]	= "3.0",
		[19]	= "3.1",
		[20]	= "3.2",
		[21]	= "3.3",
		[22]	= "3.4",
		[23]	= "3.5",
		[24]	= "3.6",
	};
	struct mmc_host	*host = s->private;
	struct mmc_ios	*ios = &host->ios;
	const char *str;

	seq_printf(s, "clock:\t\t%u Hz\n", ios->clock);
	seq_printf(s, "vdd:\t\t%u ", ios->vdd);
	if ((1 << ios->vdd) & MMC_VDD_165_195)
		seq_printf(s, "(1.65 - 1.95 V)\n");
	else if (ios->vdd < (ARRAY_SIZE(vdd_str) - 1)
			&& vdd_str[ios->vdd] && vdd_str[ios->vdd + 1])
		seq_printf(s, "(%s ~ %s V)\n", vdd_str[ios->vdd],
				vdd_str[ios->vdd + 1]);
	else
		seq_printf(s, "(invalid)\n");

	switch (ios->bus_mode) {
	case MMC_BUSMODE_OPENDRAIN:
		str = "open drain";
		break;
	case MMC_BUSMODE_PUSHPULL:
		str = "push-pull";
		break;
	default:
		str = "invalid";
		break;
	}
	seq_printf(s, "bus mode:\t%u (%s)\n", ios->bus_mode, str);

	switch (ios->chip_select) {
	case MMC_CS_DONTCARE:
		str = "don't care";
		break;
	case MMC_CS_HIGH:
		str = "active high";
		break;
	case MMC_CS_LOW:
		str = "active low";
		break;
	default:
		str = "invalid";
		break;
	}
	seq_printf(s, "chip select:\t%u (%s)\n", ios->chip_select, str);

	switch (ios->power_mode) {
	case MMC_POWER_OFF:
		str = "off";
		break;
	case MMC_POWER_UP:
		str = "up";
		break;
	case MMC_POWER_ON:
		str = "on";
		break;
	default:
		str = "invalid";
		break;
	}
	seq_printf(s, "power mode:\t%u (%s)\n", ios->power_mode, str);
	seq_printf(s, "bus width:\t%u (%u bits)\n",
			ios->bus_width, 1 << ios->bus_width);

	switch (ios->timing) {
	case MMC_TIMING_LEGACY:
		str = "legacy";
		break;
	case MMC_TIMING_MMC_HS:
		str = "mmc high-speed";
		break;
	case MMC_TIMING_SD_HS:
		str = "sd high-speed";
		break;
	default:
		str = "invalid";
		break;
	}
	seq_printf(s, "timing spec:\t%u (%s)\n", ios->timing, str);

	return 0;
}
Ejemplo n.º 7
0
static int proc_fasttimer_show(struct seq_file *m, void *v)
{
	unsigned long flags;
	int i = 0;
	int num_to_show;
	struct fasttime_t tv;
	struct fast_timer *t, *nextt;

	do_gettimeofday_fast(&tv);

	seq_printf(m, "Fast timers added:     %i\n", fast_timers_added);
	seq_printf(m, "Fast timers started:   %i\n", fast_timers_started);
	seq_printf(m, "Fast timer interrupts: %i\n", fast_timer_ints);
	seq_printf(m, "Fast timers expired:   %i\n", fast_timers_expired);
	seq_printf(m, "Fast timers deleted:   %i\n", fast_timers_deleted);
	seq_printf(m, "Fast timer running:    %s\n",
		   fast_timer_running ? "yes" : "no");
	seq_printf(m, "Current time:          %lu.%06lu\n",
		   (unsigned long)tv.tv_jiff,
		   (unsigned long)tv.tv_usec);
#ifdef FAST_TIMER_SANITY_CHECKS
	seq_printf(m, "Sanity failed:         %i\n", sanity_failed);
#endif
	seq_putc(m, '\n');

#ifdef DEBUG_LOG_INCLUDED
	{
		int end_i = debug_log_cnt;
		i = 0;

		if (debug_log_cnt_wrapped)
			i = debug_log_cnt;

		while (i != end_i || debug_log_cnt_wrapped) {
			seq_printf(m, debug_log_string[i], debug_log_value[i]);
			if (seq_has_overflowed(m))
				return 0;
			i = (i+1) % DEBUG_LOG_MAX;
		}
	}
	seq_putc(m, '\n');
#endif

	num_to_show = (fast_timers_started < NUM_TIMER_STATS ? fast_timers_started:
		       NUM_TIMER_STATS);
	seq_printf(m, "Timers started: %i\n", fast_timers_started);
	for (i = 0; i < num_to_show; i++) {
		int cur = (fast_timers_started - i - 1) % NUM_TIMER_STATS;

#if 1 //ndef FAST_TIMER_LOG
		seq_printf(m, "div: %i freq: %i delay: %i\n",
			   timer_div_settings[cur],
			   timer_freq_settings[cur],
			   timer_delay_settings[cur]);
#endif
#ifdef FAST_TIMER_LOG
		t = &timer_started_log[cur];
		seq_printf(m, "%-14s s: %6lu.%06lu e: %6lu.%06lu d: %6li us data: 0x%08lX\n",
			   t->name,
			   (unsigned long)t->tv_set.tv_jiff,
			   (unsigned long)t->tv_set.tv_usec,
			   (unsigned long)t->tv_expires.tv_jiff,
			   (unsigned long)t->tv_expires.tv_usec,
			   t->delay_us,
			   t->data);
		if (seq_has_overflowed(m))
			return 0;
#endif
	}
	seq_putc(m, '\n');

#ifdef FAST_TIMER_LOG
	num_to_show = (fast_timers_added < NUM_TIMER_STATS ? fast_timers_added:
		       NUM_TIMER_STATS);
	seq_printf(m, "Timers added: %i\n", fast_timers_added);
	for (i = 0; i < num_to_show; i++) {
		t = &timer_added_log[(fast_timers_added - i - 1) % NUM_TIMER_STATS];
		seq_printf(m, "%-14s s: %6lu.%06lu e: %6lu.%06lu d: %6li us data: 0x%08lX\n",
			   t->name,
			   (unsigned long)t->tv_set.tv_jiff,
			   (unsigned long)t->tv_set.tv_usec,
			   (unsigned long)t->tv_expires.tv_jiff,
			   (unsigned long)t->tv_expires.tv_usec,
			   t->delay_us,
			   t->data);
		if (seq_has_overflowed(m))
			return 0;
	}
	seq_putc(m, '\n');

	num_to_show = (fast_timers_expired < NUM_TIMER_STATS ? fast_timers_expired:
		       NUM_TIMER_STATS);
	seq_printf(m, "Timers expired: %i\n", fast_timers_expired);
	for (i = 0; i < num_to_show; i++) {
		t = &timer_expired_log[(fast_timers_expired - i - 1) % NUM_TIMER_STATS];
		seq_printf(m, "%-14s s: %6lu.%06lu e: %6lu.%06lu d: %6li us data: 0x%08lX\n",
			   t->name,
			   (unsigned long)t->tv_set.tv_jiff,
			   (unsigned long)t->tv_set.tv_usec,
			   (unsigned long)t->tv_expires.tv_jiff,
			   (unsigned long)t->tv_expires.tv_usec,
			   t->delay_us,
			   t->data);
		if (seq_has_overflowed(m))
			return 0;
	}
	seq_putc(m, '\n');
#endif

	seq_puts(m, "Active timers:\n");
	local_irq_save(flags);
	t = fast_timer_list;
	while (t) {
		nextt = t->next;
		local_irq_restore(flags);
		seq_printf(m, "%-14s s: %6lu.%06lu e: %6lu.%06lu d: %6li us data: 0x%08lX\n",
			   t->name,
			   (unsigned long)t->tv_set.tv_jiff,
			   (unsigned long)t->tv_set.tv_usec,
			   (unsigned long)t->tv_expires.tv_jiff,
			   (unsigned long)t->tv_expires.tv_usec,
			   t->delay_us,
			   t->data);
		if (seq_has_overflowed(m))
			return 0;
		local_irq_save(flags);
		if (t->next != nextt)
			printk(KERN_WARNING "timer removed!\n");
		t = nextt;
	}
	local_irq_restore(flags);

	return 0;
}
Ejemplo n.º 8
0
static int bm_proc_dummy_product_type_show(struct seq_file *file, void *ptr)
{
	seq_printf(file, "%d\n", PRODUCT_AS2K_3200);
	return 0;
}
Ejemplo n.º 9
0
static int bm_proc_dummy_board_type_show(struct seq_file *file, void *ptr)
{
	seq_printf(file, "%d\n", PPAL_BOARD_TYPE_DUMMY);
	return 0;
}
Ejemplo n.º 10
0
static int bm_proc_dummy_snmp_sys_oid_show(struct seq_file *file, void *ptr)
{
	seq_printf(file, "%s\n", "dummy");
	return 0;
}
Ejemplo n.º 11
0
static int bm_proc_dummy_admin_passwd_show(struct seq_file *file, void *ptr)
{
	seq_printf(file, "%s\n", "dummy_user");
	return 0;
}
Ejemplo n.º 12
0
static int bm_proc_dummy_enterprise_name_show(struct seq_file *file, void *ptr)
{
	seq_printf(file, "%s\n", "AUTELAN");

	return 0;
}
Ejemplo n.º 13
0
static int bm_proc_dummy_software_name_show(struct seq_file *file, void *ptr)
{
	seq_printf(file, "%s\n", "Auteware");
	return 0;
}
Ejemplo n.º 14
0
static int bm_proc_dummy_product_base_mac_addr_show(struct seq_file *file, void *ptr)
{
	seq_printf(file, "%s\n", "000A7AFE0106");
	return 0;
}
static int profiling_events_show_human_readable(struct seq_file *seq_file, void *v)
{
#define MALI_EVENT_ID_IS_HW(event_id) (((event_id & 0x00FF0000) >= MALI_PROFILING_EVENT_CHANNEL_GP0) && ((event_id & 0x00FF0000) <= MALI_PROFILING_EVENT_CHANNEL_PP7))

	static u64 start_time = 0;
	loff_t *spos = v;
	u32 index;
	u64 timestamp;
	u32 event_id;
	u32 data[5];

	index = (u32)*spos;

	/* Retrieve all events */
	if (_MALI_OSK_ERR_OK == _mali_internal_profiling_get_event(index, &timestamp, &event_id, data)) {
		seq_printf(seq_file, "%llu %u %u %u %u %u %u # ", timestamp, event_id, data[0], data[1], data[2], data[3], data[4]);

		if (0 == index) {
			start_time = timestamp;
		}

		seq_printf(seq_file, "[%06u] ", index);

		switch(event_id & 0x0F000000) {
		case MALI_PROFILING_EVENT_TYPE_SINGLE:
			seq_printf(seq_file, "SINGLE | ");
			break;
		case MALI_PROFILING_EVENT_TYPE_START:
			seq_printf(seq_file, "START | ");
			break;
		case MALI_PROFILING_EVENT_TYPE_STOP:
			seq_printf(seq_file, "STOP | ");
			break;
		case MALI_PROFILING_EVENT_TYPE_SUSPEND:
			seq_printf(seq_file, "SUSPEND | ");
			break;
		case MALI_PROFILING_EVENT_TYPE_RESUME:
			seq_printf(seq_file, "RESUME | ");
			break;
		default:
			seq_printf(seq_file, "0x%01X | ", (event_id & 0x0F000000) >> 24);
			break;
		}

		switch(event_id & 0x00FF0000) {
		case MALI_PROFILING_EVENT_CHANNEL_SOFTWARE:
			seq_printf(seq_file, "SW | ");
			break;
		case MALI_PROFILING_EVENT_CHANNEL_GP0:
			seq_printf(seq_file, "GP0 | ");
			break;
		case MALI_PROFILING_EVENT_CHANNEL_PP0:
			seq_printf(seq_file, "PP0 | ");
			break;
		case MALI_PROFILING_EVENT_CHANNEL_PP1:
			seq_printf(seq_file, "PP1 | ");
			break;
		case MALI_PROFILING_EVENT_CHANNEL_PP2:
			seq_printf(seq_file, "PP2 | ");
			break;
		case MALI_PROFILING_EVENT_CHANNEL_PP3:
			seq_printf(seq_file, "PP3 | ");
			break;
		case MALI_PROFILING_EVENT_CHANNEL_PP4:
			seq_printf(seq_file, "PP4 | ");
			break;
		case MALI_PROFILING_EVENT_CHANNEL_PP5:
			seq_printf(seq_file, "PP5 | ");
			break;
		case MALI_PROFILING_EVENT_CHANNEL_PP6:
			seq_printf(seq_file, "PP6 | ");
			break;
		case MALI_PROFILING_EVENT_CHANNEL_PP7:
			seq_printf(seq_file, "PP7 | ");
			break;
		case MALI_PROFILING_EVENT_CHANNEL_GPU:
			seq_printf(seq_file, "GPU | ");
			break;
		default:
			seq_printf(seq_file, "0x%02X | ", (event_id & 0x00FF0000) >> 16);
			break;
		}

		if (MALI_EVENT_ID_IS_HW(event_id)) {
			if (((event_id & 0x0F000000) == MALI_PROFILING_EVENT_TYPE_START) || ((event_id & 0x0F000000) == MALI_PROFILING_EVENT_TYPE_STOP)) {
				switch(event_id & 0x0000FFFF) {
				case MALI_PROFILING_EVENT_REASON_START_STOP_HW_PHYSICAL:
					seq_printf(seq_file, "PHYSICAL | ");
					break;
				case MALI_PROFILING_EVENT_REASON_START_STOP_HW_VIRTUAL:
					seq_printf(seq_file, "VIRTUAL | ");
					break;
				default:
					seq_printf(seq_file, "0x%04X | ", event_id & 0x0000FFFF);
					break;
				}
			} else {
				seq_printf(seq_file, "0x%04X | ", event_id & 0x0000FFFF);
			}
		} else {
			seq_printf(seq_file, "0x%04X | ", event_id & 0x0000FFFF);
		}

		seq_printf(seq_file, "T0 + 0x%016llX\n", timestamp - start_time);

		return 0;
	}
Ejemplo n.º 16
0
static int bm_proc_dummy_master_slot_id_show(struct seq_file *file, void *ptr)
{
	seq_printf(file, "%d\n", 1);
	return 0;
}
Ejemplo n.º 17
0
static int seq_proc_show(struct seq_file *s,void *v)
{
	return seq_printf(s,"%s\n","it is a test!");
}
Ejemplo n.º 18
0
static int bm_proc_dummy_module_name_show(struct seq_file *file, void *ptr)
{
	seq_printf(file, "%s\n", "dummy_module");
	return 0;
}
Ejemplo n.º 19
0
static int version_proc_show(struct seq_file *m, void *v)
{
	seq_printf(m, "driver:                  %s\n", TOSHIBA_ACPI_VERSION);
	seq_printf(m, "proc_interface:          %d\n", PROC_INTERFACE_VERSION);
	return 0;
}
Ejemplo n.º 20
0
static int bm_proc_dummy_product_sn_show(struct seq_file *file, void *ptr)
{
	seq_printf(file, "%s\n", "1000");
	return 0;
}
Ejemplo n.º 21
0
static void dccp_print_conntrack(struct seq_file *s, struct nf_conn *ct)
{
	seq_printf(s, "%s ", dccp_state_names[ct->proto.dccp.state]);
}
Ejemplo n.º 22
0
static void holly_show_cpuinfo(struct seq_file *m)
{
	seq_printf(m, "vendor\t\t: IBM\n");
	seq_printf(m, "machine\t\t: PPC750 GX/CL\n");
}
Ejemplo n.º 23
0
static int yam_seq_show(struct seq_file *seq, void *v)
{
	struct net_device *dev = v;
	const struct yam_port *yp = netdev_priv(dev);

	seq_printf(seq, "Device %s\n", dev->name);
	seq_printf(seq, "  Up       %d\n", netif_running(dev));
	seq_printf(seq, "  Speed    %u\n", yp->bitrate);
	seq_printf(seq, "  IoBase   0x%x\n", yp->iobase);
	seq_printf(seq, "  BaudRate %u\n", yp->baudrate);
	seq_printf(seq, "  IRQ      %u\n", yp->irq);
	seq_printf(seq, "  TxState  %u\n", yp->tx_state);
	seq_printf(seq, "  Duplex   %u\n", yp->dupmode);
	seq_printf(seq, "  HoldDly  %u\n", yp->holdd);
	seq_printf(seq, "  TxDelay  %u\n", yp->txd);
	seq_printf(seq, "  TxTail   %u\n", yp->txtail);
	seq_printf(seq, "  SlotTime %u\n", yp->slot);
	seq_printf(seq, "  Persist  %u\n", yp->pers);
	seq_printf(seq, "  TxFrames %lu\n", dev->stats.tx_packets);
	seq_printf(seq, "  RxFrames %lu\n", dev->stats.rx_packets);
	seq_printf(seq, "  TxInt    %u\n", yp->nb_mdint);
	seq_printf(seq, "  RxInt    %u\n", yp->nb_rxint);
	seq_printf(seq, "  RxOver   %lu\n", dev->stats.rx_fifo_errors);
	seq_printf(seq, "\n");
	return 0;
}
Ejemplo n.º 24
0
static int proc_keys_show(struct seq_file *m, void *v)
{
	struct rb_node *_p = v;
	struct key *key = rb_entry(_p, struct key, serial_node);
	struct timespec now;
	unsigned long timo;
	char xbuf[12];
	int rc;

	/* check whether the current task is allowed to view the key (assuming
	 * non-possession) */
	rc = key_task_permission(make_key_ref(key, 0), current, KEY_VIEW);
	if (rc < 0)
		return 0;

	now = current_kernel_time();

	rcu_read_lock();

	/* come up with a suitable timeout value */
	if (key->expiry == 0) {
		memcpy(xbuf, "perm", 5);
	}
	else if (now.tv_sec >= key->expiry) {
		memcpy(xbuf, "expd", 5);
	}
	else {
		timo = key->expiry - now.tv_sec;

		if (timo < 60)
			sprintf(xbuf, "%lus", timo);
		else if (timo < 60*60)
			sprintf(xbuf, "%lum", timo / 60);
		else if (timo < 60*60*24)
			sprintf(xbuf, "%luh", timo / (60*60));
		else if (timo < 60*60*24*7)
			sprintf(xbuf, "%lud", timo / (60*60*24));
		else
			sprintf(xbuf, "%luw", timo / (60*60*24*7));
	}

#define showflag(KEY, LETTER, FLAG) \
	(test_bit(FLAG,	&(KEY)->flags) ? LETTER : '-')

	seq_printf(m, "%08x %c%c%c%c%c%c %5d %4s %08x %5d %5d %-9.9s ",
		   key->serial,
		   showflag(key, 'I', KEY_FLAG_INSTANTIATED),
		   showflag(key, 'R', KEY_FLAG_REVOKED),
		   showflag(key, 'D', KEY_FLAG_DEAD),
		   showflag(key, 'Q', KEY_FLAG_IN_QUOTA),
		   showflag(key, 'U', KEY_FLAG_USER_CONSTRUCT),
		   showflag(key, 'N', KEY_FLAG_NEGATIVE),
		   atomic_read(&key->usage),
		   xbuf,
		   key->perm,
		   key->uid,
		   key->gid,
		   key->type->name);

#undef showflag

	if (key->type->describe)
		key->type->describe(key, m);
	seq_putc(m, '\n');

	rcu_read_unlock();

	return 0;

}
Ejemplo n.º 25
0
static int mdfld_dc_pipeline_a_regs_info(struct seq_file *m, void *data)
{
	struct drm_info_node *node = (struct drm_info_node *)m->private;
	struct drm_device *dev = node->minor->dev;
	int i;

	seq_printf(m, "DISPLAY PIPELINE A\n");

	seq_printf(m, "\tPALETTE A/B/C:\n");
	seq_printf(m, "\t\t reg(0xa000) = 0x%x\n", REG_READ(0xa000));

	seq_printf(m, "\tMIPI A:\n");
	for (i=0xb000; i<0xb0ff; i+=4)
		seq_printf(m, "\t\t reg(0x%x) = 0x%x\n", i, REG_READ(i));

	seq_printf(m, "\tDSI ADAPTER:\n");
	for (i=0xb104; i<=0xb138; i+=4)
		seq_printf(m, "\t\t reg(0x%x) = 0x%x\n", i, REG_READ(i));

	seq_printf(m, "\tDPLL:\n");
	for (i=0xf000; i<0xffff; i+=4)
		seq_printf(m, "\t\t reg(0x%x) = 0x%x\n", i, REG_READ(i));

	seq_printf(m, "\tPIPELINE A:\n");
	for (i=0x60000; i<0x600ff; i+=4)
		seq_printf(m, "\t\t reg(0x%x) = 0x%x\n", i, REG_READ(i));

	seq_printf(m, "\tPORT CONTROL:\n");
	for (i=0x61190; i<0x61194; i+=4)
		seq_printf(m, "\t\t reg(0x%x) = 0x%x\n", i, REG_READ(i));

	seq_printf(m, "\tPIPELINE A CONTROL:\n");
	for (i=0x70000; i<0x700ff; i+=4)
		seq_printf(m, "\t\t reg(0x%x) = 0x%x\n", i, REG_READ(i));

	return 0;
}
Ejemplo n.º 26
0
Archivo: inode.c Proyecto: Lyude/linux
static int autofs_show_options(struct seq_file *m, struct dentry *root)
{
	struct autofs_sb_info *sbi = autofs_sbi(root->d_sb);
	struct inode *root_inode = d_inode(root->d_sb->s_root);

	if (!sbi)
		return 0;

	seq_printf(m, ",fd=%d", sbi->pipefd);
	if (!uid_eq(root_inode->i_uid, GLOBAL_ROOT_UID))
		seq_printf(m, ",uid=%u",
			from_kuid_munged(&init_user_ns, root_inode->i_uid));
	if (!gid_eq(root_inode->i_gid, GLOBAL_ROOT_GID))
		seq_printf(m, ",gid=%u",
			from_kgid_munged(&init_user_ns, root_inode->i_gid));
	seq_printf(m, ",pgrp=%d", pid_vnr(sbi->oz_pgrp));
	seq_printf(m, ",timeout=%lu", sbi->exp_timeout/HZ);
	seq_printf(m, ",minproto=%d", sbi->min_proto);
	seq_printf(m, ",maxproto=%d", sbi->max_proto);

	if (autofs_type_offset(sbi->type))
		seq_printf(m, ",offset");
	else if (autofs_type_direct(sbi->type))
		seq_printf(m, ",direct");
	else
		seq_printf(m, ",indirect");
#ifdef CONFIG_CHECKPOINT_RESTORE
	if (sbi->pipe)
		seq_printf(m, ",pipe_ino=%ld", file_inode(sbi->pipe)->i_ino);
	else
		seq_printf(m, ",pipe_ino=-1");
#endif
	return 0;
}
Ejemplo n.º 27
0
Archivo: c2k.c Proyecto: E-LLP/n900
void c2k_show_cpuinfo(struct seq_file *m)
{
	seq_printf(m, "Vendor\t\t: GEFanuc\n");
	seq_printf(m, "coherency\t: %s\n", COHERENCY_SETTING);
}
Ejemplo n.º 28
0
static int mpc_show(struct seq_file *m, void *v)
{
	struct mpoa_client *mpc = v;
	int i;
	in_cache_entry *in_entry;
	eg_cache_entry *eg_entry;
	struct timeval now;
	unsigned char ip_string[16];

	if (v == SEQ_START_TOKEN) {
		atm_mpoa_disp_qos(m);
		return 0;
	}

	seq_printf(m, "\nInterface %d:\n\n", mpc->dev_num);
	seq_printf(m, "Ingress Entries:\nIP address      State      Holding time  Packets fwded  VPI  VCI\n");
	do_gettimeofday(&now);

	for (in_entry = mpc->in_cache; in_entry; in_entry = in_entry->next) {
		sprintf(ip_string, "%pI4", &in_entry->ctrl_info.in_dst_ip);
		seq_printf(m, "%-16s%s%-14lu%-12u",
			   ip_string,
			   ingress_state_string(in_entry->entry_state),
			   in_entry->ctrl_info.holding_time -
			   (now.tv_sec-in_entry->tv.tv_sec),
			   in_entry->packets_fwded);
		if (in_entry->shortcut)
			seq_printf(m, "   %-3d  %-3d",
				   in_entry->shortcut->vpi,
				   in_entry->shortcut->vci);
		seq_printf(m, "\n");
	}

	seq_printf(m, "\n");
	seq_printf(m, "Egress Entries:\nIngress MPC ATM addr\nCache-id        State      Holding time  Packets recvd  Latest IP addr   VPI VCI\n");
	for (eg_entry = mpc->eg_cache; eg_entry; eg_entry = eg_entry->next) {
		unsigned char *p = eg_entry->ctrl_info.in_MPC_data_ATM_addr;
		for (i = 0; i < ATM_ESA_LEN; i++)
			seq_printf(m, "%02x", p[i]);
		seq_printf(m, "\n%-16lu%s%-14lu%-15u",
			   (unsigned long)ntohl(eg_entry->ctrl_info.cache_id),
			   egress_state_string(eg_entry->entry_state),
			   (eg_entry->ctrl_info.holding_time -
			    (now.tv_sec-eg_entry->tv.tv_sec)),
			   eg_entry->packets_rcvd);

		/*                   */
		sprintf(ip_string, "%pI4", &eg_entry->latest_ip_addr);
		seq_printf(m, "%-16s", ip_string);

		if (eg_entry->shortcut)
			seq_printf(m, " %-3d %-3d",
				   eg_entry->shortcut->vpi,
				   eg_entry->shortcut->vci);
		seq_printf(m, "\n");
	}
	seq_printf(m, "\n");
	return 0;
}
static int rmnet_usb_data_status(struct seq_file *s, void *unused)
{
	struct usbnet *unet = s->private;

	seq_printf(s, "RMNET_MODE_LLP_IP:  %d\n",
			test_bit(RMNET_MODE_LLP_IP, &unet->data[0]));
	seq_printf(s, "RMNET_MODE_LLP_ETH: %d\n",
			test_bit(RMNET_MODE_LLP_ETH, &unet->data[0]));
	seq_printf(s, "RMNET_MODE_QOS:     %d\n",
			test_bit(RMNET_MODE_QOS, &unet->data[0]));
	seq_printf(s, "Net MTU:            %u\n", unet->net->mtu);
	seq_printf(s, "rx_urb_size:        %u\n", unet->rx_urb_size);
	seq_printf(s, "rx skb q len:       %u\n", unet->rxq.qlen);
	seq_printf(s, "rx skb done q len:  %u\n", unet->done.qlen);
	seq_printf(s, "rx errors:          %lu\n", unet->net->stats.rx_errors);
	seq_printf(s, "rx over errors:     %lu\n",
			unet->net->stats.rx_over_errors);
	seq_printf(s, "rx length errors:   %lu\n",
			unet->net->stats.rx_length_errors);
	seq_printf(s, "rx packets:         %lu\n", unet->net->stats.rx_packets);
	seq_printf(s, "rx bytes:           %lu\n", unet->net->stats.rx_bytes);
	seq_printf(s, "tx skb q len:       %u\n", unet->txq.qlen);
	seq_printf(s, "tx errors:          %lu\n", unet->net->stats.tx_errors);
	seq_printf(s, "tx packets:         %lu\n", unet->net->stats.tx_packets);
	seq_printf(s, "tx bytes:           %lu\n", unet->net->stats.tx_bytes);
	seq_printf(s, "suspend count:      %d\n", unet->suspend_count);
	seq_printf(s, "EVENT_DEV_OPEN:     %d\n",
			test_bit(EVENT_DEV_OPEN, &unet->flags));
	seq_printf(s, "EVENT_TX_HALT:      %d\n",
			test_bit(EVENT_TX_HALT, &unet->flags));
	seq_printf(s, "EVENT_RX_HALT:      %d\n",
			test_bit(EVENT_RX_HALT, &unet->flags));
	seq_printf(s, "EVENT_RX_MEMORY:    %d\n",
			test_bit(EVENT_RX_MEMORY, &unet->flags));
	seq_printf(s, "EVENT_DEV_ASLEEP:   %d\n",
			test_bit(EVENT_DEV_ASLEEP, &unet->flags));

	return 0;
}
Ejemplo n.º 30
0
/* cpu_ss_period */
static int cpu_ss_period_proc_show(struct seq_file *m, void *v)
{
        seq_printf(m, "%d (s) %d (ns)\n", mt_cpu_ss_period_s, mt_cpu_ss_period_ns);

	return 0;
}