type stringclasses 5
values | content stringlengths 9 163k |
|---|---|
defines |
#define MAX_STRING_SIZE 128 |
defines |
#define pct(a,b) (b ? a * 100 / b : 0) |
functions | int ll_blksize_seq_show(struct seq_file *m, void *v)
{
struct super_block *sb = m->private;
struct obd_statfs osfs;
int rc;
LASSERT(sb != NULL);
rc = ll_statfs_internal(sb, &osfs,
cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS),
OBD_STATFS_NODELAY);
if (!rc)
rc = seq_printf(m, "%u\n", osfs.os_bsize);
ret... |
functions | int ll_kbytestotal_seq_show(struct seq_file *m, void *v)
{
struct super_block *sb = m->private;
struct obd_statfs osfs;
int rc;
LASSERT(sb != NULL);
rc = ll_statfs_internal(sb, &osfs,
cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS),
OBD_STATFS_NODELAY);
if (!rc) {
__u32 blk_size = osfs.os_bsize >> 10;
_... |
functions | int ll_kbytesfree_seq_show(struct seq_file *m, void *v)
{
struct super_block *sb = m->private;
struct obd_statfs osfs;
int rc;
LASSERT(sb != NULL);
rc = ll_statfs_internal(sb, &osfs,
cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS),
OBD_STATFS_NODELAY);
if (!rc) {
__u32 blk_size = osfs.os_bsize >> 10;
__... |
functions | int ll_kbytesavail_seq_show(struct seq_file *m, void *v)
{
struct super_block *sb = m->private;
struct obd_statfs osfs;
int rc;
LASSERT(sb != NULL);
rc = ll_statfs_internal(sb, &osfs,
cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS),
OBD_STATFS_NODELAY);
if (!rc) {
__u32 blk_size = osfs.os_bsize >> 10;
_... |
functions | int ll_filestotal_seq_show(struct seq_file *m, void *v)
{
struct super_block *sb = m->private;
struct obd_statfs osfs;
int rc;
LASSERT(sb != NULL);
rc = ll_statfs_internal(sb, &osfs,
cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS),
OBD_STATFS_NODELAY);
if (!rc)
rc = seq_printf(m, LPU64"\n", osfs.os_files)... |
functions | int ll_filesfree_seq_show(struct seq_file *m, void *v)
{
struct super_block *sb = m->private;
struct obd_statfs osfs;
int rc;
LASSERT(sb != NULL);
rc = ll_statfs_internal(sb, &osfs,
cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS),
OBD_STATFS_NODELAY);
if (!rc)
rc = seq_printf(m, LPU64"\n", osfs.os_ffree);... |
functions | int ll_client_type_seq_show(struct seq_file *m, void *v)
{
struct ll_sb_info *sbi = ll_s2sbi((struct super_block *)m->private);
int rc;
LASSERT(sbi != NULL);
if (sbi->ll_flags & LL_SBI_RMT_CLIENT)
rc = seq_printf(m, "remote client\n");
else
rc = seq_printf(m, "local client\n");
return rc;
} |
functions | int ll_fstype_seq_show(struct seq_file *m, void *v)
{
struct super_block *sb = m->private;
LASSERT(sb != NULL);
return seq_printf(m, "%s\n", sb->s_type->name);
} |
functions | int ll_sb_uuid_seq_show(struct seq_file *m, void *v)
{
struct super_block *sb = m->private;
LASSERT(sb != NULL);
return seq_printf(m, "%s\n", ll_s2sbi(sb)->ll_sb_uuid.uuid);
} |
functions | int ll_xattr_cache_seq_show(struct seq_file *m, void *v)
{
struct ll_sb_info *sbi = ll_s2sbi((struct super_block *)m->private);
return seq_printf(m, "%u\n", sbi->ll_xattr_cache_enabled);
} |
functions | ssize_t ll_xattr_cache_seq_write(struct file *file,
const char __user *buffer,
size_t count, loff_t *off)
{
struct seq_file *m = file->private_data;
struct ll_sb_info *sbi = ll_s2sbi((struct super_block *)m->private);
int val, rc;
rc = lprocfs_write_helper(buffer, count, &val);
if (rc)
return rc;
if... |
functions | int ll_site_stats_seq_show(struct seq_file *m, void *v)
{
struct super_block *sb = m->private;
/*
* See description of statistical counters in struct cl_site, and
* struct lu_site.
*/
return cl_site_stats_print(lu2cl_site(ll_s2sbi(sb)->ll_site), m);
} |
functions | int ll_max_readahead_mb_seq_show(struct seq_file *m, void *v)
{
struct super_block *sb = m->private;
struct ll_sb_info *sbi = ll_s2sbi(sb);
long pages_number;
int mult;
spin_lock(&sbi->ll_lock);
pages_number = sbi->ll_ra_info.ra_max_pages;
spin_unlock(&sbi->ll_lock);
mult = 1 << (20 - PAGE_CACHE_SHIFT);
retu... |
functions | ssize_t
ll_max_readahead_mb_seq_write(struct file *file, const char __user *buffer,
size_t count, loff_t *off)
{
struct seq_file *m = file->private_data;
struct ll_sb_info *sbi = ll_s2sbi((struct super_block *)m->private);
__u64 val;
long pages_number;
int mult;
int rc;
mult = 1 << (20 - PAGE_CACHE_SHI... |
functions | int ll_max_readahead_per_file_mb_seq_show(struct seq_file *m, void *v)
{
struct super_block *sb = m->private;
struct ll_sb_info *sbi = ll_s2sbi(sb);
long pages_number;
int mult;
spin_lock(&sbi->ll_lock);
pages_number = sbi->ll_ra_info.ra_max_pages_per_file;
spin_unlock(&sbi->ll_lock);
mult = 1 << (20 - PAGE_C... |
functions | ssize_t
ll_max_readahead_per_file_mb_seq_write(struct file *file,
const char __user *buffer,
size_t count, loff_t *off)
{
struct seq_file *m = file->private_data;
struct ll_sb_info *sbi = ll_s2sbi((struct super_block *)m->private);
int mult, rc, pages_number;
mult = 1 << (20 - PAGE_CACHE_SHIF... |
functions | int ll_max_read_ahead_whole_mb_seq_show(struct seq_file *m, void *v)
{
struct super_block *sb = m->private;
struct ll_sb_info *sbi = ll_s2sbi(sb);
long pages_number;
int mult;
spin_lock(&sbi->ll_lock);
pages_number = sbi->ll_ra_info.ra_max_read_ahead_whole_pages;
spin_unlock(&sbi->ll_lock);
mult = 1 << (20 - ... |
functions | ssize_t
ll_max_read_ahead_whole_mb_seq_write(struct file *file,
const char __user *buffer,
size_t count, loff_t *off)
{
struct seq_file *m = file->private_data;
struct ll_sb_info *sbi = ll_s2sbi((struct super_block *)m->private);
int mult, rc, pages_number;
mult = 1 << (20 - PAGE_CACHE_SHIFT);
r... |
functions | int ll_max_cached_mb_seq_show(struct seq_file *m, void *v)
{
struct super_block *sb = m->private;
struct ll_sb_info *sbi = ll_s2sbi(sb);
struct cl_client_cache *cache = &sbi->ll_cache;
int shift = 20 - PAGE_CACHE_SHIFT;
long max_cached_mb;
long unused_mb;
max_cached_mb = cache->ccc_lru_max >> shif... |
functions | ssize_t
ll_max_cached_mb_seq_write(struct file *file, const char __user *buffer,
size_t count, loff_t *off)
{
struct seq_file *m = file->private_data;
struct super_block *sb = m->private;
struct ll_sb_info *sbi = ll_s2sbi(sb);
struct cl_client_cache *cache = &sbi->ll_cache;
struct lu_env *env;
__u64 val;
l... |
functions | int ll_checksum_seq_show(struct seq_file *m, void *v)
{
struct super_block *sb = m->private;
struct ll_sb_info *sbi = ll_s2sbi(sb);
return seq_printf(m, "%u\n", (sbi->ll_flags & LL_SBI_CHECKSUM) ? 1 : 0);
} |
functions | ssize_t ll_checksum_seq_write(struct file *file,
const char __user *buffer,
size_t count, loff_t *off)
{
struct seq_file *m = file->private_data;
struct ll_sb_info *sbi = ll_s2sbi((struct super_block *)m->private);
int val, rc;
if (!sbi->ll_dt_exp)
/* Not set up yet ... |
functions | int ll_max_rw_chunk_seq_show(struct seq_file *m, void *v)
{
struct super_block *sb = m->private;
return seq_printf(m, "%lu\n", ll_s2sbi(sb)->ll_max_rw_chunk);
} |
functions | ssize_t ll_max_rw_chunk_seq_write(struct file *file,
const char __user *buffer,
size_t count, loff_t *off)
{
struct seq_file *m = file->private_data;
struct super_block *sb = m->private;
int rc, val;
rc = lprocfs_write_helper(buffer, count, &val);
if (rc)
return rc... |
functions | int ll_rd_track_id(struct seq_file *m, enum stats_track_type type)
{
struct super_block *sb = m->private;
if (ll_s2sbi(sb)->ll_stats_track_type == type) {
return seq_printf(m, "%d\n",
ll_s2sbi(sb)->ll_stats_track_id);
} |
functions | int ll_wr_track_id(const char __user *buffer, unsigned long count,
void *data, enum stats_track_type type)
{
struct super_block *sb = data;
int rc, pid;
rc = lprocfs_write_helper(buffer, count, &pid);
if (rc)
return rc;
ll_s2sbi(sb)->ll_stats_track_id = pid;
... |
functions | int ll_track_pid_seq_show(struct seq_file *m, void *v)
{
return ll_rd_track_id(m, STATS_TRACK_PID);
} |
functions | ssize_t ll_track_pid_seq_write(struct file *file,
const char __user *buffer,
size_t count, loff_t *off)
{
struct seq_file *seq = file->private_data;
return ll_wr_track_id(buffer, count, seq->private, STATS_TRACK_PID);
} |
functions | int ll_track_ppid_seq_show(struct seq_file *m, void *v)
{
return ll_rd_track_id(m, STATS_TRACK_PPID);
} |
functions | ssize_t ll_track_ppid_seq_write(struct file *file,
const char __user *buffer,
size_t count, loff_t *off)
{
struct seq_file *seq = file->private_data;
return ll_wr_track_id(buffer, count, seq->private, STATS_TRACK_PPID);
} |
functions | int ll_track_gid_seq_show(struct seq_file *m, void *v)
{
return ll_rd_track_id(m, STATS_TRACK_GID);
} |
functions | ssize_t ll_track_gid_seq_write(struct file *file,
const char __user *buffer,
size_t count, loff_t *off)
{
struct seq_file *seq = file->private_data;
return ll_wr_track_id(buffer, count, seq->private, STATS_TRACK_GID);
} |
functions | int ll_statahead_max_seq_show(struct seq_file *m, void *v)
{
struct super_block *sb = m->private;
struct ll_sb_info *sbi = ll_s2sbi(sb);
return seq_printf(m, "%u\n", sbi->ll_sa_max);
} |
functions | ssize_t ll_statahead_max_seq_write(struct file *file,
const char __user *buffer,
size_t count, loff_t *off)
{
struct seq_file *m = file->private_data;
struct ll_sb_info *sbi = ll_s2sbi((struct super_block *)m->private);
int val, rc;
rc = lprocfs_write_helper(buffer, count, &val);
if (r... |
functions | int ll_statahead_agl_seq_show(struct seq_file *m, void *v)
{
struct super_block *sb = m->private;
struct ll_sb_info *sbi = ll_s2sbi(sb);
return seq_printf(m, "%u\n",
sbi->ll_flags & LL_SBI_AGL_ENABLED ? 1 : 0);
} |
functions | ssize_t ll_statahead_agl_seq_write(struct file *file,
const char __user *buffer,
size_t count, loff_t *off)
{
struct seq_file *m = file->private_data;
struct ll_sb_info *sbi = ll_s2sbi((struct super_block *)m->private);
int val, rc;
rc = lprocfs_write_helper(buffer, count, &val);
if (r... |
functions | int ll_statahead_stats_seq_show(struct seq_file *m, void *v)
{
struct super_block *sb = m->private;
struct ll_sb_info *sbi = ll_s2sbi(sb);
return seq_printf(m,
"statahead total: %u\n"
"statahead wrong: %u\n"
"agl total: %u\n",
... |
functions | int ll_lazystatfs_seq_show(struct seq_file *m, void *v)
{
struct super_block *sb = m->private;
struct ll_sb_info *sbi = ll_s2sbi(sb);
return seq_printf(m, "%u\n",
(sbi->ll_flags & LL_SBI_LAZYSTATFS) ? 1 : 0);
} |
functions | ssize_t ll_lazystatfs_seq_write(struct file *file,
const char __user *buffer,
size_t count, loff_t *off)
{
struct seq_file *m = file->private_data;
struct ll_sb_info *sbi = ll_s2sbi((struct super_block *)m->private);
int val, rc;
rc = lprocfs_write_helper(buffer, count, &val);
if (rc... |
functions | int ll_max_easize_seq_show(struct seq_file *m, void *v)
{
struct super_block *sb = m->private;
struct ll_sb_info *sbi = ll_s2sbi(sb);
unsigned int ealen;
int rc;
rc = ll_get_max_mdsize(sbi, &ealen);
if (rc)
return rc;
return seq_printf(m, "%u\n", ealen);
} |
functions | int ll_defult_easize_seq_show(struct seq_file *m, void *v)
{
struct super_block *sb = m->private;
struct ll_sb_info *sbi = ll_s2sbi(sb);
unsigned int ealen;
int rc;
rc = ll_get_default_mdsize(sbi, &ealen);
if (rc)
return rc;
return seq_printf(m, "%u\n", ealen);
} |
functions | int ll_max_cookiesize_seq_show(struct seq_file *m, void *v)
{
struct super_block *sb = m->private;
struct ll_sb_info *sbi = ll_s2sbi(sb);
unsigned int cookielen;
int rc;
rc = ll_get_max_cookiesize(sbi, &cookielen);
if (rc)
return rc;
return seq_printf(m, "%u\n", cookielen);
} |
functions | int ll_defult_cookiesize_seq_show(struct seq_file *m, void *v)
{
struct super_block *sb = m->private;
struct ll_sb_info *sbi = ll_s2sbi(sb);
unsigned int cookielen;
int rc;
rc = ll_get_default_cookiesize(sbi, &cookielen);
if (rc)
return rc;
return seq_printf(m, "%u\n", cookielen);
} |
functions | int ll_sbi_flags_seq_show(struct seq_file *m, void *v)
{
const char *str[] = LL_SBI_FLAGS;
struct super_block *sb = m->private;
int flags = ll_s2sbi(sb)->ll_flags;
int i = 0;
while (flags != 0) {
if (ARRAY_SIZE(str) <= i) {
CERROR("%s: Revise array LL_SBI_FLAGS to match sbi "
"flags please.\n", ll_get_fs... |
functions | int ll_unstable_stats_seq_show(struct seq_file *m, void *v)
{
struct super_block *sb = m->private;
struct ll_sb_info *sbi = ll_s2sbi(sb);
struct cl_client_cache *cache = &sbi->ll_cache;
long pages;
int mb;
pages = atomic_long_read(&cache->ccc_unstable_nr);
mb = (pages * PAGE_CACHE_SIZE) >> 20;
return ... |
functions | ssize_t ll_unstable_stats_seq_write(struct file *file,
const char __user *buffer,
size_t count, loff_t *unused)
{
struct seq_file *seq = file->private_data;
struct ll_sb_info *sbi = ll_s2sbi((struct super_block *)seq->private);
char kernbuf[128];
int val, rc;
if (count == 0)
return 0;
if (count... |
functions | int ll_root_squash_seq_show(struct seq_file *m, void *v)
{
struct super_block *sb = m->private;
struct ll_sb_info *sbi = ll_s2sbi(sb);
struct root_squash_info *squash = &sbi->ll_squash;
return seq_printf(m, "%u:%u\n", squash->rsi_uid, squash->rsi_gid);
} |
functions | ssize_t ll_root_squash_seq_write(struct file *file,
const char __user *buffer,
size_t count, loff_t *off)
{
struct seq_file *m = file->private_data;
struct super_block *sb = m->private;
struct ll_sb_info *sbi = ll_s2sbi(sb);
struct root_squash_info *squash = &sbi->ll_squash;
return lprocfs_wr_root_squas... |
functions | int ll_nosquash_nids_seq_show(struct seq_file *m, void *v)
{
struct super_block *sb = m->private;
struct ll_sb_info *sbi = ll_s2sbi(sb);
struct root_squash_info *squash = &sbi->ll_squash;
int len, rc;
down_read(&squash->rsi_sem);
if (!list_empty(&squash->rsi_nosquash_nids)) {
len = cfs_print_nidlist(m->buf + m... |
functions | ssize_t ll_nosquash_nids_seq_write(struct file *file,
const char __user *buffer,
size_t count, loff_t *off)
{
struct seq_file *m = file->private_data;
struct super_block *sb = m->private;
struct ll_sb_info *sbi = ll_s2sbi(sb);
struct root_squash_info *squash = &sbi->ll_squash;
int rc;
rc = lprocfs_... |
functions | void ll_stats_ops_tally(struct ll_sb_info *sbi, int op, int count)
{
if (!sbi->ll_stats)
return;
if (sbi->ll_stats_track_type == STATS_TRACK_ALL)
lprocfs_counter_add(sbi->ll_stats, op, count);
else if (sbi->ll_stats_track_type == STATS_TRACK_PID &&
... |
functions | int lprocfs_register_mountpoint(struct proc_dir_entry *parent,
struct super_block *sb, char *osc, char *mdc)
{
struct lprocfs_seq_vars lvars[2];
struct lustre_sb_info *lsi = s2lsi(sb);
struct ll_sb_info *sbi = ll_s2sbi(sb);
struct obd_device *obd;
struct proc_dir_entry *dir;
char n... |
functions | void lprocfs_unregister_mountpoint(struct ll_sb_info *sbi)
{
if (sbi->ll_proc_root) {
lprocfs_remove(&sbi->ll_proc_root);
lprocfs_free_stats(&sbi->ll_ra_stats);
lprocfs_free_stats(&sbi->ll_stats);
} |
functions | void ll_display_extents_info(struct ll_rw_extents_info *io_extents,
struct seq_file *seq, int which)
{
unsigned long read_tot = 0, write_tot = 0, read_cum, write_cum;
unsigned long start, end, r, w;
char *unitp = "KMGTPEZY";
int i, units = 10;
s... |
functions | int ll_rw_extents_stats_pp_seq_show(struct seq_file *seq, void *v)
{
struct timeval now;
struct ll_sb_info *sbi = seq->private;
struct ll_rw_extents_info *io_extents = &sbi->ll_rw_extents_info;
int k;
do_gettimeofday(&now);
if (!sbi->ll_rw_stats_on) {
seq_printf(seq, "disabled\n"
... |
functions | ssize_t ll_rw_extents_stats_pp_seq_write(struct file *file,
const char __user *buf,
size_t len,
loff_t *off)
{
struct seq_file *seq = file->private_data;
struct ll_sb_info *sbi = seq->private;
struct ll_rw_extents_info *io_extents = &sbi->ll_rw_extents_info;
int i;
int value = 1, rc = 0;
if (le... |
functions | int ll_rw_extents_stats_seq_show(struct seq_file *seq, void *v)
{
struct timeval now;
struct ll_sb_info *sbi = seq->private;
struct ll_rw_extents_info *io_extents = &sbi->ll_rw_extents_info;
do_gettimeofday(&now);
if (!sbi->ll_rw_stats_on) {
seq_printf(seq, "disabled\n"
... |
functions | ssize_t ll_rw_extents_stats_seq_write(struct file *file,
const char __user *buf,
size_t len, loff_t *off)
{
struct seq_file *seq = file->private_data;
struct ll_sb_info *sbi = seq->private;
struct ll_rw_extents_info *io_extents = &sbi->ll_rw_extents_info;
int i;
int value = 1, rc = 0;
if (len... |
functions | void ll_rw_stats_tally(struct ll_sb_info *sbi, pid_t pid,
struct ll_file_data *file, loff_t pos,
size_t count, int rw)
{
int i, cur = -1;
struct ll_rw_process_info *process;
struct ll_rw_process_info *offset;
int *off_count = &sbi->ll_rw_offs... |
functions | int ll_rw_offset_stats_seq_show(struct seq_file *seq, void *v)
{
struct timeval now;
struct ll_sb_info *sbi = seq->private;
struct ll_rw_process_info *offset = sbi->ll_rw_offset_info;
struct ll_rw_process_info *process = sbi->ll_rw_process_info;
int i;
do_gettimeofday(&now);
if (!sb... |
functions | ssize_t ll_rw_offset_stats_seq_write(struct file *file,
const char __user *buf,
size_t len, loff_t *off)
{
struct seq_file *seq = file->private_data;
struct ll_sb_info *sbi = seq->private;
struct ll_rw_process_info *process_info = sbi->ll_rw_process_info;
struct ll_rw_process_info *offset_info = s... |
includes |
#include <linux/clk.h> |
includes | #include <linux/cpufreq.h> |
includes | #include <linux/err.h> |
includes | #include <linux/errno.h> |
includes | #include <linux/init.h> |
includes | #include <linux/io.h> |
includes | #include <linux/kernel.h> |
includes | #include <linux/list.h> |
includes | #include <linux/module.h> |
includes | #include <linux/mutex.h> |
includes | #include <linux/platform_device.h> |
includes | #include <linux/proc_fs.h> |
includes | #include <linux/seq_file.h> |
includes | #include <linux/semaphore.h> |
includes | #include <linux/string.h> |
includes | #include <linux/hardirq.h> |
includes | #include <mach/clock.h> |
includes | #include <mach/hardware.h> |
functions | void __clk_disable(struct clk *clk)
{
if (clk == NULL || IS_ERR(clk) || !clk->usecount)
return;
if (!(--clk->usecount)) {
if (clk->disable)
clk->disable(clk);
__clk_disable(clk->secondary);
__clk_disable(clk->parent);
} |
functions | int __clk_enable(struct clk *clk)
{
if (clk == NULL || IS_ERR(clk))
return -EINVAL;
if (clk->usecount++ == 0) {
__clk_enable(clk->parent);
__clk_enable(clk->secondary);
if (clk->enable)
clk->enable(clk);
} |
functions | int clk_enable(struct clk *clk)
{
unsigned long flags;
int ret = 0;
if (in_interrupt()) {
printk(KERN_ERR " clk_enable cannot be called in an interrupt context\n");
dump_stack();
BUG();
} |
functions | void clk_disable(struct clk *clk)
{
unsigned long flags;
if (in_interrupt()) {
printk(KERN_ERR " clk_disable cannot be called in an interrupt context\n");
dump_stack();
BUG();
} |
functions | int clk_get_usecount(struct clk *clk)
{
if (clk == NULL || IS_ERR(clk))
return 0;
return clk->usecount;
} |
functions | long clk_get_rate(struct clk *clk)
{
if (clk == NULL || IS_ERR(clk))
return 0UL;
if (clk->get_rate)
return clk->get_rate(clk);
return clk_get_rate(clk->parent);
} |
functions | void clk_put(struct clk *clk)
{
if (clk && !IS_ERR(clk))
module_put(clk->owner);
} |
functions | long clk_round_rate(struct clk *clk, unsigned long rate)
{
if (clk == NULL || IS_ERR(clk) || !clk->round_rate)
return 0;
return clk->round_rate(clk, rate);
} |
functions | void propagate_rate(struct mxc_clk *mxc_tclk)
{
struct mxc_clk *mxc_clkp;
struct clk *clkp;
struct clk *tclk = mxc_tclk->reg_clk;
unsigned long rate;
if (tclk == NULL || IS_ERR(tclk))
return;
list_for_each_entry(mxc_clkp, &clocks, node) {
clkp = mxc_clkp->reg_clk;
if (likely(clkp->parent != tclk))
c... |
functions | int clk_set_rate(struct clk *clk, unsigned long rate)
{
unsigned long flags;
int ret = -EINVAL;
if (clk == NULL || IS_ERR(clk) || clk->set_rate == NULL || rate == 0)
return ret;
spin_lock_irqsave(&clockfw_lock, flags);
ret = clk->set_rate(clk, rate);
spin_unlock_irqrestore(&clockfw_lock, flags);
return ret;... |
functions | int clk_set_parent(struct clk *clk, struct clk *parent)
{
unsigned long flags;
int ret = -EINVAL;
struct clk *prev_parent = clk->parent;
if (clk == NULL || IS_ERR(clk) || parent == NULL ||
IS_ERR(parent) || clk->set_parent == NULL)
return ret;
if (clk->usecount != 0) {
clk_enable(parent);
} |
functions | int clk_register(struct mxc_clk *clk)
{
if (clk == NULL || IS_ERR(clk))
return -EINVAL;
mutex_lock(&clocks_mutex);
list_add(&clk->node, &clocks);
mutex_unlock(&clocks_mutex);
return 0;
} |
functions | void clk_unregister(struct mxc_clk *clk)
{
if (clk == NULL || IS_ERR(clk))
return;
mutex_lock(&clocks_mutex);
list_del(&clk->node);
mutex_unlock(&clocks_mutex);
} |
functions | void mxc_proc_clocks_seq_stop(struct seq_file *file, void *data)
{
} |
functions | int mxc_proc_clocks_seq_show(struct seq_file *file, void *data)
{
int result;
struct mxc_clk *clock = (struct mxc_clk *) data;
struct clk *parent = clock->reg_clk->parent;
unsigned int longest_length = (unsigned int) file->private;
unsigned long range_divisor;
const char *range_units;
i... |
functions | else if (rate >= 1000) {
range_divisor = 1000;
range_units = "KHz";
} |
functions | int mxc_proc_clocks_open(struct inode *inode, struct file *file)
{
return seq_open(file, &mxc_proc_clocks_seq_ops);
} |
functions | __init mxc_setup_proc_entry(void)
{
struct proc_dir_entry *res;
res = create_proc_entry("cpu/clocks", 0, NULL);
if (!res) {
printk(KERN_ERR "Failed to create proc/cpu/clocks\n");
return -ENOMEM;
} |
functions | long mxc_decode_pll(unsigned int reg_val, u32 freq)
{
long long ll;
int mfn_abs;
unsigned int mfi, mfn, mfd, pd;
mfi = (reg_val >> 10) & 0xf;
mfn = reg_val & 0x3ff;
mfd = (reg_val >> 16) & 0x3ff;
pd = (reg_val >> 26) & 0xf;
mfi = mfi <= 5 ? 5 : mfi;
mfn_abs = mfn;
/* On all i.MXs except i.MX1 and i.MX21 ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.