type stringclasses 5
values | content stringlengths 9 163k |
|---|---|
includes | #include <asm/ppc4xx.h> |
includes | #include <asm/prom.h> |
includes | #include <asm/time.h> |
includes | #include <asm/udbg.h> |
includes | #include <asm/uic.h> |
includes |
#include <linux/init.h> |
includes | #include <linux/of_platform.h> |
functions | __init ppc44x_device_probe(void)
{
of_platform_bus_probe(NULL, ppc44x_of_bus, NULL);
return 0;
} |
functions | __init ppc44x_probe(void)
{
unsigned long root = of_get_flat_dt_root();
int i = 0;
for (i = 0; i < ARRAY_SIZE(board); i++) {
if (of_flat_dt_is_compatible(root, board[i])) {
ppc_pci_set_flags(PPC_PCI_REASSIGN_ALL_RSRC);
return 1;
} |
includes |
#include <linux/gpio.h> |
includes | #include <linux/io.h> |
includes | #include <plat/iic.h> |
includes | #include <plat/gpio-cfg.h> |
includes | #include <plat/cpu.h> |
includes | #include <plat/map-base.h> |
defines |
#define EXYNOS3472_I2C_MUX (S3C_VA_SYS + 0x228) |
functions | void s3c_i2c7_cfg_gpio(struct platform_device *dev)
{
if (soc_is_exynos5250())
s3c_gpio_cfgall_range(EXYNOS5_GPB2(2), 2,
S3C_GPIO_SFN(3), S3C_GPIO_PULL_UP);
else if (soc_is_exynos5260())
s3c_gpio_cfgall_range(EXYNOS5260_GPB5(6), 2,
S3C_GPIO_SFN(2), S3C_GPIO_PULL_UP);
else if (soc_is_exynos3... |
functions | void s3c_i2c7_cfg_mux(void)
{
#if 0
if (soc_is_exynos3472())
writel(0x0, EXYNOS3472_I2C_MUX);
#endif
} |
includes | #include <linux/module.h> |
includes | #include <linux/slab.h> |
includes | #include <linux/blkdev.h> |
includes | #include <linux/elevator.h> |
includes | #include <linux/jiffies.h> |
includes | #include <linux/rbtree.h> |
includes | #include <linux/ioprio.h> |
includes | #include <linux/blktrace_api.h> |
defines | #define CFQ_IDLE_DELAY (HZ / 5) |
defines | #define CFQ_MIN_TT (2) |
defines |
#define CFQ_SLICE_SCALE (5) |
defines | #define CFQ_HW_QUEUE_MIN (5) |
defines | #define CFQ_SERVICE_SHIFT 12 |
defines |
#define CFQQ_SEEK_THR (sector_t)(8 * 100) |
defines | #define CFQQ_CLOSE_THR (sector_t)(8 * 1024) |
defines | #define CFQQ_SECT_THR_NONROT (sector_t)(2 * 32) |
defines | #define CFQQ_SEEKY(cfqq) (hweight32(cfqq->seek_history) > 32/8) |
defines |
#define RQ_CIC(rq) icq_to_cic((rq)->elv.icq) |
defines | #define RQ_CFQQ(rq) (struct cfq_queue *) ((rq)->elv.priv[0]) |
defines | #define RQ_CFQG(rq) (struct cfq_group *) ((rq)->elv.priv[1]) |
defines |
#define CFQ_PRIO_LISTS IOPRIO_BE_NR |
defines | #define cfq_class_idle(cfqq) ((cfqq)->ioprio_class == IOPRIO_CLASS_IDLE) |
defines | #define cfq_class_rt(cfqq) ((cfqq)->ioprio_class == IOPRIO_CLASS_RT) |
defines |
#define sample_valid(samples) ((samples) > 80) |
defines | #define rb_entry_cfqg(node) rb_entry((node), struct cfq_group, rb_node) |
defines | #define CFQ_RB_ROOT (struct cfq_rb_root) { .rb = RB_ROOT, \ |
defines |
#define CFQ_CFQQ_FNS(name) \ |
defines |
#define CFQG_FLAG_FNS(name) \ |
defines |
#define cfq_log_cfqq(cfqd, cfqq, fmt, args...) do { \ |
defines |
#define cfq_log_cfqg(cfqd, cfqg, fmt, args...) do { \ |
defines |
#define cfq_log_cfqq(cfqd, cfqq, fmt, args...) \ |
defines | #define cfq_log_cfqg(cfqd, cfqg, fmt, args...) do {} while (0) |
defines |
#define cfq_log(cfqd, fmt, args...) \ |
defines | #define for_each_cfqg_st(cfqg, i, j, st) \ |
defines | #define CFQ_RQ1_WRAP 0x01 /* request 1 wraps */ |
defines | #define CFQ_RQ2_WRAP 0x02 /* request 2 wraps */ |
defines |
#define SHOW_FUNCTION(__FUNC, __VAR, __CONV) \ |
defines |
#define STORE_FUNCTION(__FUNC, __PTR, MIN, MAX, __CONV) \ |
defines |
#define CFQ_ATTR(name) \ |
structs | struct cfq_ttime {
unsigned long last_end_request;
unsigned long ttime_total;
unsigned long ttime_samples;
unsigned long ttime_mean;
}; |
structs | struct cfq_rb_root {
struct rb_root rb;
struct rb_node *left;
unsigned count;
u64 min_vdisktime;
struct cfq_ttime ttime;
}; |
structs | struct cfq_queue {
/* reference count */
int ref;
/* various state flags, see below */
unsigned int flags;
/* parent cfq_data */
struct cfq_data *cfqd;
/* service_tree member */
struct rb_node rb_node;
/* service_tree key */
unsigned long rb_key;
/* prio tree member */
struct rb_node p_node;
/* prio tree r... |
structs | struct cfqg_stats {
#ifdef CONFIG_CFQ_GROUP_IOSCHED
/* total bytes transferred */
struct blkg_rwstat service_bytes;
/* total IOs serviced, post merge */
struct blkg_rwstat serviced;
/* number of ios merged */
struct blkg_rwstat merged;
/* total time spent on device in ns, may not be accurate w/ queueing */
s... |
structs | struct cfq_group {
/* must be the first member */
struct blkg_policy_data pd;
/* group service_tree member */
struct rb_node rb_node;
/* group service_tree key */
u64 vdisktime;
/*
* The number of active cfqgs and sum of their weights under this
* cfqg. This covers this cfqg's leaf_weight and all childre... |
structs | struct cfq_io_cq {
struct io_cq icq; /* must be the first member */
struct cfq_queue *cfqq[2];
struct cfq_ttime ttime;
int ioprio; /* the current ioprio */
#ifdef CONFIG_CFQ_GROUP_IOSCHED
uint64_t blkcg_id; /* the current blkcg ID */
#endif
}; |
structs | struct cfq_data {
struct request_queue *queue;
/* Root service tree for cfq_groups */
struct cfq_rb_root grp_service_tree;
struct cfq_group *root_group;
/*
* The priority currently being served
*/
enum wl_class_t serving_wl_class;
enum wl_type_t serving_wl_type;
unsigned long workload_expires;
struct cfq_... |
functions | void cfqg_stats_update_group_wait_time(struct cfqg_stats *stats)
{
unsigned long long now;
if (!cfqg_stats_waiting(stats))
return;
now = sched_clock();
if (time_after64(now, stats->start_group_wait_time))
blkg_stat_add(&stats->group_wait_time,
now - stats->start_group_wait_time);
cfqg_stats_clear_wa... |
functions | void cfqg_stats_set_start_group_wait_time(struct cfq_group *cfqg,
struct cfq_group *curr_cfqg)
{
struct cfqg_stats *stats = &cfqg->stats;
if (cfqg_stats_waiting(stats))
return;
if (cfqg == curr_cfqg)
return;
stats->start_group_wait_time = sched_clock();
cfqg_stats_mark_waiting(stats);
} |
functions | void cfqg_stats_end_empty_time(struct cfqg_stats *stats)
{
unsigned long long now;
if (!cfqg_stats_empty(stats))
return;
now = sched_clock();
if (time_after64(now, stats->start_empty_time))
blkg_stat_add(&stats->empty_time,
now - stats->start_empty_time);
cfqg_stats_clear_empty(stats);
} |
functions | void cfqg_stats_update_dequeue(struct cfq_group *cfqg)
{
blkg_stat_add(&cfqg->stats.dequeue, 1);
} |
functions | void cfqg_stats_set_start_empty_time(struct cfq_group *cfqg)
{
struct cfqg_stats *stats = &cfqg->stats;
if (blkg_rwstat_total(&stats->queued))
return;
/*
* group is already marked empty. This can happen if cfqq got new
* request in parent group and moved to this group while being added
* to service tree. J... |
functions | void cfqg_stats_update_idle_time(struct cfq_group *cfqg)
{
struct cfqg_stats *stats = &cfqg->stats;
if (cfqg_stats_idling(stats)) {
unsigned long long now = sched_clock();
if (time_after64(now, stats->start_idle_time))
blkg_stat_add(&stats->idle_time,
now - stats->start_idle_time);
cfqg_stats_cle... |
functions | void cfqg_stats_set_start_idle_time(struct cfq_group *cfqg)
{
struct cfqg_stats *stats = &cfqg->stats;
BUG_ON(cfqg_stats_idling(stats));
stats->start_idle_time = sched_clock();
cfqg_stats_mark_idling(stats);
} |
functions | void cfqg_stats_update_avg_queue_size(struct cfq_group *cfqg)
{
struct cfqg_stats *stats = &cfqg->stats;
blkg_stat_add(&stats->avg_queue_size_sum,
blkg_rwstat_total(&stats->queued));
blkg_stat_add(&stats->avg_queue_size_samples, 1);
cfqg_stats_update_group_wait_time(stats);
} |
functions | void cfqg_stats_set_start_group_wait_time(struct cfq_group *cfqg, struct cfq_group *curr_cfqg) { } |
functions | void cfqg_stats_end_empty_time(struct cfqg_stats *stats) { } |
functions | void cfqg_stats_update_dequeue(struct cfq_group *cfqg) { } |
functions | void cfqg_stats_set_start_empty_time(struct cfq_group *cfqg) { } |
functions | void cfqg_stats_update_idle_time(struct cfq_group *cfqg) { } |
functions | void cfqg_stats_set_start_idle_time(struct cfq_group *cfqg) { } |
functions | void cfqg_stats_update_avg_queue_size(struct cfq_group *cfqg) { } |
functions | void cfqg_get(struct cfq_group *cfqg)
{
return blkg_get(cfqg_to_blkg(cfqg));
} |
functions | void cfqg_put(struct cfq_group *cfqg)
{
return blkg_put(cfqg_to_blkg(cfqg));
} |
functions | void cfqg_stats_update_io_add(struct cfq_group *cfqg,
struct cfq_group *curr_cfqg, int rw)
{
blkg_rwstat_add(&cfqg->stats.queued, rw, 1);
cfqg_stats_end_empty_time(&cfqg->stats);
cfqg_stats_set_start_group_wait_time(cfqg, curr_cfqg);
} |
functions | void cfqg_stats_update_timeslice_used(struct cfq_group *cfqg,
unsigned long time, unsigned long unaccounted_time)
{
blkg_stat_add(&cfqg->stats.time, time);
#ifdef CONFIG_DEBUG_BLK_CGROUP
blkg_stat_add(&cfqg->stats.unaccounted_time, unaccounted_time);
#endif
} |
functions | void cfqg_stats_update_io_remove(struct cfq_group *cfqg, int rw)
{
blkg_rwstat_add(&cfqg->stats.queued, rw, -1);
} |
functions | void cfqg_stats_update_io_merged(struct cfq_group *cfqg, int rw)
{
blkg_rwstat_add(&cfqg->stats.merged, rw, 1);
} |
functions | void cfqg_stats_update_dispatch(struct cfq_group *cfqg,
uint64_t bytes, int rw)
{
blkg_stat_add(&cfqg->stats.sectors, bytes >> 9);
blkg_rwstat_add(&cfqg->stats.serviced, rw, 1);
blkg_rwstat_add(&cfqg->stats.service_bytes, rw, bytes);
} |
functions | void cfqg_stats_update_completion(struct cfq_group *cfqg,
uint64_t start_time, uint64_t io_start_time, int rw)
{
struct cfqg_stats *stats = &cfqg->stats;
unsigned long long now = sched_clock();
if (time_after64(now, io_start_time))
blkg_rwstat_add(&stats->service_time, rw, now - io_start_time);
if (time_after... |
functions | void cfqg_stats_reset(struct cfqg_stats *stats)
{
/* queued stats shouldn't be cleared */
blkg_rwstat_reset(&stats->service_bytes);
blkg_rwstat_reset(&stats->serviced);
blkg_rwstat_reset(&stats->merged);
blkg_rwstat_reset(&stats->service_time);
blkg_rwstat_reset(&stats->wait_time);
blkg_stat_reset(&stats->time);... |
functions | void cfqg_stats_merge(struct cfqg_stats *to, struct cfqg_stats *from)
{
/* queued stats shouldn't be cleared */
blkg_rwstat_merge(&to->service_bytes, &from->service_bytes);
blkg_rwstat_merge(&to->serviced, &from->serviced);
blkg_rwstat_merge(&to->merged, &from->merged);
blkg_rwstat_merge(&to->service_time, &from->... |
functions | void cfqg_stats_xfer_dead(struct cfq_group *cfqg)
{
struct cfq_group *parent = cfqg_parent(cfqg);
lockdep_assert_held(cfqg_to_blkg(cfqg)->q->queue_lock);
if (unlikely(!parent))
return;
cfqg_stats_merge(&parent->dead_stats, &cfqg->stats);
cfqg_stats_merge(&parent->dead_stats, &cfqg->dead_stats);
cfqg_stats_re... |
functions | void cfqg_get(struct cfq_group *cfqg) { } |
functions | void cfqg_put(struct cfq_group *cfqg) { } |
functions | void cfqg_stats_update_io_add(struct cfq_group *cfqg,
struct cfq_group *curr_cfqg, int rw) { } |
functions | void cfqg_stats_update_timeslice_used(struct cfq_group *cfqg,
unsigned long time, unsigned long unaccounted_time) { } |
functions | void cfqg_stats_update_io_remove(struct cfq_group *cfqg, int rw) { } |
functions | void cfqg_stats_update_io_merged(struct cfq_group *cfqg, int rw) { } |
functions | void cfqg_stats_update_dispatch(struct cfq_group *cfqg,
uint64_t bytes, int rw) { } |
functions | void cfqg_stats_update_completion(struct cfq_group *cfqg,
uint64_t start_time, uint64_t io_start_time, int rw) { } |
functions | bool cfq_io_thinktime_big(struct cfq_data *cfqd,
struct cfq_ttime *ttime, bool group_idle)
{
unsigned long slice;
if (!sample_valid(ttime->ttime_samples))
return false;
if (group_idle)
slice = cfqd->cfq_group_idle;
else
slice = cfqd->cfq_slice_idle;
return ttime->ttime_mean > slice;
} |
functions | bool iops_mode(struct cfq_data *cfqd)
{
/*
* If we are not idling on queues and it is a NCQ drive, parallel
* execution of requests is on and measuring time is not possible
* in most of the cases until and unless we drive shallower queue
* depths and that becomes a performance bottleneck. In such cases
* swi... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.