}; static unsigned char key_val; // interrupt flag, interrupt server function set it 1, key_int_drv_read clear it static volatile int ev_press = 0; static struct fasync_struct *button_async; static DECLARE_WAIT_QUEUE_HEAD(button_waitq); static DECLARE_MUTEX(button_lock); #ifdef __ATOMIC__ static atomic_t canopen = ATOMIC_INIT(1); //定义原子变量,并初始化为1 #endif struct pin_desc pins_desc[4] = { {S3C2410_GPF0, 0x01}, {S3C2410_GPF2, 0x02}, {S3C2410_GPG3, 0x03}, {S3C2410_GPG11, 0x04}, }; static irqreturn_t key_int_irq(int irq, void *dev_id) { struct pin_desc *pindesc = (struct pin_desc *)dev_id; unsigned int pinval; pinval = s3c2410_gpio_getpin(pindesc->pin);
#include <mach/socinfo.h> #include <mach/msm_subsystem_map.h> char iommu_dummy[2*SZ_64K-4]; struct msm_iova_data { struct rb_node node; struct mem_pool *pools; int npools; struct iommu_domain *domain; int domain_num; }; static struct rb_root domain_root; DEFINE_MUTEX(domain_mutex); static atomic_t domain_nums = ATOMIC_INIT(-1); int msm_use_iommu() { return iommu_present(&platform_bus_type); } int msm_iommu_map_extra(struct iommu_domain *domain, unsigned long start_iova, unsigned long size, unsigned long page_size, int cached) { int ret = 0; int i = 0; unsigned long phy_addr = ALIGN(virt_to_phys(iommu_dummy), page_size);
#include <asm/semaphore.h> #include <linux/spinlock.h> #include <linux/timer.h> #include <linux/delay.h> #include <linux/poll.h> #include "ccid.h" #include "dccp.h" #include "feat.h" DEFINE_SNMP_STAT(struct dccp_mib, dccp_statistics) __read_mostly; EXPORT_SYMBOL_GPL(dccp_statistics); atomic_t dccp_orphan_count = ATOMIC_INIT(0); EXPORT_SYMBOL_GPL(dccp_orphan_count); struct inet_hashinfo __cacheline_aligned dccp_hashinfo = { .lhash_lock = RW_LOCK_UNLOCKED, .lhash_users = ATOMIC_INIT(0), .lhash_wait = __WAIT_QUEUE_HEAD_INITIALIZER(dccp_hashinfo.lhash_wait), }; EXPORT_SYMBOL_GPL(dccp_hashinfo); void dccp_set_state(struct sock *sk, const int state) { const int oldstate = sk->sk_state;
#include <linux/clk.h> #include <linux/proc_fs.h> #include <asm/io.h> #include <asm/hardware.h> #include <asm/arch/dma.h> #include <asm/delay.h> #include <asm/atomic.h> /*! * This variable is used to controll the clock of DMA. * It counts the number of actived channels */ static atomic_t g_dma_actived = ATOMIC_INIT(0); /*! * This variable point a proc file which contains the information * of DMA channels */ static struct proc_dir_entry *g_proc_dir; /*! * The dma channels */ static mxc_dma_channel_t g_dma_channels[MAX_DMA_CHANNELS]; static mx2_dma_priv_t g_dma_privates[MXC_DMA_CHANNELS]; static mx2_dma_bd_t g_dma_bd_table[MXC_DMA_CHANNELS][MAX_BD_SIZE]; static DEFINE_SPINLOCK(dma_list_lock);
#include <linux/err.h> #include <linux/mutex.h> #include <linux/security.h> #include <linux/user_namespace.h> #include <asm/uaccess.h> #include "internal.h" /* Session keyring create vs join semaphore */ static DEFINE_MUTEX(key_session_mutex); /* User keyring creation semaphore */ static DEFINE_MUTEX(key_user_keyring_mutex); /* The root user's tracking struct */ struct key_user root_key_user = { .usage = ATOMIC_INIT(3), .cons_lock = __MUTEX_INITIALIZER(root_key_user.cons_lock), .lock = __SPIN_LOCK_UNLOCKED(root_key_user.lock), .nkeys = ATOMIC_INIT(2), .nikeys = ATOMIC_INIT(2), .uid = 0, .user_ns = &init_user_ns, }; /* * Install the user and user session keyrings for the current process's UID. */ int install_user_keyrings(void) { struct user_struct *user; const struct cred *cred;
int __cfs_fail_check_set(__u32 id, __u32 value, int set) { static atomic_t cfs_fail_count = ATOMIC_INIT(0); LASSERT(!(id & CFS_FAIL_ONCE)); if ((cfs_fail_loc & (CFS_FAILED | CFS_FAIL_ONCE)) == (CFS_FAILED | CFS_FAIL_ONCE)) { atomic_set(&cfs_fail_count, 0); /* paranoia */ return 0; } /* Fail 1/cfs_fail_val times */ if (cfs_fail_loc & CFS_FAIL_RAND) { if (cfs_fail_val < 2 || cfs_rand() % cfs_fail_val > 0) return 0; } /* Skip the first cfs_fail_val, then fail */ if (cfs_fail_loc & CFS_FAIL_SKIP) { if (atomic_inc_return(&cfs_fail_count) <= cfs_fail_val) return 0; } /* check cfs_fail_val... */ if (set == CFS_FAIL_LOC_VALUE) { if (cfs_fail_val != -1 && cfs_fail_val != value) return 0; } /* Fail cfs_fail_val times, overridden by FAIL_ONCE */ if (cfs_fail_loc & CFS_FAIL_SOME && (!(cfs_fail_loc & CFS_FAIL_ONCE) || cfs_fail_val <= 1)) { int count = atomic_inc_return(&cfs_fail_count); if (count >= cfs_fail_val) { set_bit(CFS_FAIL_ONCE_BIT, &cfs_fail_loc); atomic_set(&cfs_fail_count, 0); /* we are lost race to increase */ if (count > cfs_fail_val) return 0; } } if ((set == CFS_FAIL_LOC_ORSET || set == CFS_FAIL_LOC_RESET) && (value & CFS_FAIL_ONCE)) set_bit(CFS_FAIL_ONCE_BIT, &cfs_fail_loc); /* Lost race to set CFS_FAILED_BIT. */ if (test_and_set_bit(CFS_FAILED_BIT, &cfs_fail_loc)) { /* If CFS_FAIL_ONCE is valid, only one process can fail, * otherwise multi-process can fail at the same time. */ if (cfs_fail_loc & CFS_FAIL_ONCE) return 0; } switch (set) { case CFS_FAIL_LOC_NOSET: case CFS_FAIL_LOC_VALUE: break; case CFS_FAIL_LOC_ORSET: cfs_fail_loc |= value & ~(CFS_FAILED | CFS_FAIL_ONCE); break; case CFS_FAIL_LOC_RESET: cfs_fail_loc = value; break; default: LASSERTF(0, "called with bad set %u\n", set); break; } return 1; }
/* Random magic number */ #define SYSFS_MAGIC 0x62656572 static struct vfsmount *sysfs_mount; struct super_block * sysfs_sb = NULL; struct kmem_cache *sysfs_dir_cachep; static const struct super_operations sysfs_ops = { .statfs = simple_statfs, .drop_inode = generic_delete_inode, }; struct sysfs_dirent sysfs_root = { .s_name = "", .s_count = ATOMIC_INIT(1), .s_flags = SYSFS_DIR, .s_mode = S_IFDIR | S_IRWXU | S_IRUGO | S_IXUGO, .s_ino = 1, }; static int sysfs_fill_super(struct super_block *sb, void *data, int silent) { struct inode *inode; struct dentry *root; sb->s_blocksize = PAGE_CACHE_SIZE; sb->s_blocksize_bits = PAGE_CACHE_SHIFT; sb->s_magic = SYSFS_MAGIC; sb->s_op = &sysfs_ops; sb->s_time_gran = 1;
#include <linux/mutex.h> #include <linux/module.h> #include <linux/sched.h> #include <linux/tick.h> #include <linux/time.h> #include <linux/timer.h> #include <linux/workqueue.h> #include <linux/kthread.h> #include <linux/mutex.h> #ifdef CONFIG_POWERSUSPEND #include <linux/powersuspend.h> #endif #include <asm/cputime.h> static atomic_t active_count = ATOMIC_INIT(0); static unsigned long stored_timer_rate; struct cpufreq_interactivex_cpuinfo { struct timer_list cpu_timer; int timer_idlecancel; u64 time_in_idle; u64 idle_exit_time; u64 timer_run_time; int idling; u64 target_set_time; u64 target_set_time_in_idle; struct cpufreq_policy *policy; struct cpufreq_frequency_table *freq_table; unsigned int target_freq; int governor_enabled;
* * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. */ #include <linux/cpuidle.h> #include <linux/module.h> #include <asm/cpuidle.h> #include <asm/proc-fns.h> #include "common.h" #include "cpuidle.h" #include "hardware.h" static atomic_t master = ATOMIC_INIT(0); static DEFINE_SPINLOCK(master_lock); static int imx6q_enter_wait(struct cpuidle_device *dev, struct cpuidle_driver *drv, int index) { if (atomic_inc_return(&master) == num_online_cpus()) { /* * With this lock, we prevent other cpu to exit and enter * this function again and become the master. */ if (!spin_trylock(&master_lock)) goto idle; imx6q_set_lpm(WAIT_UNCLOCKED); cpu_do_idle(); imx6q_set_lpm(WAIT_CLOCKED);
#include <linux/mm_types.h> #include <linux/rbtree.h> #include <linux/rwsem.h> #include <linux/spinlock.h> #include <linux/list.h> #include <linux/cpumask.h> #include <asm/atomic.h> #include <asm/pgtable.h> struct mm_struct init_mm = { .mm_rb = RB_ROOT, .pgd = swapper_pg_dir, .mm_users = ATOMIC_INIT(2), .mm_count = ATOMIC_INIT(1), .mmap_sem = __RWSEM_INITIALIZER(init_mm.mmap_sem), .page_table_lock = __SPIN_LOCK_UNLOCKED(init_mm.page_table_lock), .mmlist = LIST_HEAD_INIT(init_mm.mmlist), .cpu_vm_mask = CPU_MASK_ALL, /* FIXME should we initialize scribe stuff ? */ };
* request probing to be deferred by returning -EPROBE_DEFER from its probe hook * * Deferred probe maintains two lists of devices, a pending list and an active * list. A driver returning -EPROBE_DEFER causes the device to be added to the * pending list. A successful driver probe will trigger moving all devices * from the pending to the active list so that the workqueue will eventually * retry them. * * The deferred_probe_mutex must be held any time the deferred_probe_*_list * of the (struct device*)->p->deferred_probe pointers are manipulated */ static DEFINE_MUTEX(deferred_probe_mutex); static LIST_HEAD(deferred_probe_pending_list); static LIST_HEAD(deferred_probe_active_list); static struct workqueue_struct *deferred_wq; static atomic_t deferred_trigger_count = ATOMIC_INIT(0); /** * deferred_probe_work_func() - Retry probing devices in the active list. */ static void deferred_probe_work_func(struct work_struct *work) { struct device *dev; struct device_private *private; /* * This block processes every device in the deferred 'active' list. * Each device is removed from the active list and passed to * bus_probe_device() to re-attempt the probe. The loop continues * until every device in the active list is removed and retried. * * Note: Once the device is removed from the list and the mutex is
static struct sk_buff *oz_build_frame(struct oz_pd *pd, struct oz_tx_frame *f); static int oz_send_isoc_frame(struct oz_pd *pd); static void oz_retire_frame(struct oz_pd *pd, struct oz_tx_frame *f); static void oz_isoc_stream_free(struct oz_isoc_stream *st); static int oz_send_next_queued_frame(struct oz_pd *pd, int more_data); static void oz_isoc_destructor(struct sk_buff *skb); static int oz_def_app_init(void); static void oz_def_app_term(void); static int oz_def_app_start(struct oz_pd *pd, int resume); static void oz_def_app_stop(struct oz_pd *pd, int pause); static void oz_def_app_rx(struct oz_pd *pd, struct oz_elt *elt); /* * Counts the uncompleted isoc frames submitted to netcard. */ static atomic_t g_submitted_isoc = ATOMIC_INIT(0); /* Application handler functions. */ static const struct oz_app_if g_app_if[OZ_APPID_MAX] = { {oz_usb_init, oz_usb_term, oz_usb_start, oz_usb_stop, oz_usb_rx, oz_usb_heartbeat, oz_usb_farewell, OZ_APPID_USB}, {oz_def_app_init, oz_def_app_term,
{ mpic_setup_this_cpu(); if (cpu_has_feature(CPU_FTR_DBELL)) doorbell_setup_this_cpu(); } struct smp_ops_t smp_85xx_ops = { .kick_cpu = smp_85xx_kick_cpu, #ifdef CONFIG_KEXEC .give_timebase = smp_generic_give_timebase, .take_timebase = smp_generic_take_timebase, #endif }; #ifdef CONFIG_KEXEC atomic_t kexec_down_cpus = ATOMIC_INIT(0); void mpc85xx_smp_kexec_cpu_down(int crash_shutdown, int secondary) { local_irq_disable(); if (secondary) { atomic_inc(&kexec_down_cpus); /* loop forever */ while (1); } } static void mpc85xx_smp_kexec_down(void *arg) { if (ppc_md.kexec_cpu_down)
int cx18_first_minor; /* Callback for registering extensions */ int (*cx18_ext_init)(struct cx18 *); EXPORT_SYMBOL(cx18_ext_init); /* add your revision and whatnot here */ static struct pci_device_id cx18_pci_tbl[] = { {PCI_VENDOR_ID_CX, PCI_DEVICE_ID_CX23418, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, {0,} }; MODULE_DEVICE_TABLE(pci, cx18_pci_tbl); static atomic_t cx18_instance = ATOMIC_INIT(0); /* Parameter declarations */ static int cardtype[CX18_MAX_CARDS]; static int tuner[CX18_MAX_CARDS] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }; static int radio[CX18_MAX_CARDS] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }; static unsigned cardtype_c = 1; static unsigned tuner_c = 1; static unsigned radio_c = 1; static char pal[] = "--";
CHARGER_INTR_OFFSET, /* Bit 20 CHRG_CTRL */ CHARGERFAULT_INTR_OFFSET, /* Bit 21 EXT_CHRG */ CHARGERFAULT_INTR_OFFSET, /* Bit 22 INT_CHRG */ RSV_INTR_OFFSET, /* Bit 23 Reserved */ }; static int *twl6030_interrupt_mapping = twl6030_interrupt_mapping_table; /*----------------------------------------------------------------------*/ static unsigned twl6030_irq_base, twl6030_irq_end; static int twl_irq; static bool twl_irq_wake_enabled; static struct task_struct *task; static struct completion irq_event; static atomic_t twl6030_wakeirqs = ATOMIC_INIT(0); static u8 vbatmin_hi_threshold; static int twl6030_irq_pm_notifier(struct notifier_block *notifier, unsigned long pm_event, void *unused) { int chained_wakeups; switch (pm_event) { case PM_SUSPEND_PREPARE: chained_wakeups = atomic_read(&twl6030_wakeirqs); if (chained_wakeups && !twl_irq_wake_enabled) { if (enable_irq_wake(twl_irq)) pr_err("twl6030 IRQ wake enable failed\n");
static smd_channel_t *smd_channel; static int initialized; static wait_queue_head_t newserver_wait; static wait_queue_head_t smd_wait; static wait_queue_head_t init_wait; static int smd_wait_count; /* odd while waiting */ static DEFINE_SPINLOCK(local_endpoints_lock); static DEFINE_SPINLOCK(remote_endpoints_lock); static DEFINE_SPINLOCK(server_list_lock); static struct workqueue_struct *rpcrouter_workqueue; static struct wake_lock rpcrouter_wake_lock; static int rpcrouter_need_len; static atomic_t next_xid = ATOMIC_INIT(1); static atomic_t next_mid = ATOMIC_INIT(0); static void do_read_data(struct work_struct *work); static void do_create_pdevs(struct work_struct *work); static void do_create_rpcrouter_pdev(struct work_struct *work); static DECLARE_WORK(work_read_data, do_read_data); static DECLARE_WORK(work_create_pdevs, do_create_pdevs); static DECLARE_WORK(work_create_rpcrouter_pdev, do_create_rpcrouter_pdev); static atomic_t rpcrouter_pdev_created = ATOMIC_INIT(0); #define RR_STATE_IDLE 0 #define RR_STATE_HEADER 1 #define RR_STATE_BODY 2 #define RR_STATE_ERROR 3
#include <mach/debug_mm.h> #include <mach/custmproc.h> #include <mach/smem_pc_oem_cmd.h> #include <linux/sched.h> #define DEBUG #ifdef DEBUG #define D(fmt, args...) printk(KERN_INFO "tid = %d: " fmt , (int)current->pid , ##args) #else #define D(fmt, args...) do {} while (0) #endif #define BUFSZ (0) static DEFINE_MUTEX(voice_lock); atomic_t voice_started=ATOMIC_INIT(0); static struct audio_client *voc_tx_clnt; static struct audio_client *voc_rx_clnt; static int q6_voice_start(void) { int rc = 0; mutex_lock(&voice_lock); if (atomic_read(&voice_started)) { pr_err("[%s:%s] busy\n", __MM_FILE__, __func__); rc = -EBUSY; goto done; }
const struct rpc_authops authnull_ops = { .owner = THIS_MODULE, .au_flavor = RPC_AUTH_NULL, .au_name = "NULL", .create = nul_create, .destroy = nul_destroy, .lookup_cred = nul_lookup_cred, }; static struct rpc_auth null_auth = { .au_cslack = 4, .au_rslack = 2, .au_ops = &authnull_ops, .au_flavor = RPC_AUTH_NULL, .au_count = ATOMIC_INIT(0), }; static const struct rpc_credops null_credops = { .cr_name = "AUTH_NULL", .crdestroy = nul_destroy_cred, .crbind = rpcauth_generic_bind_cred, .crmatch = nul_match, .crmarshal = nul_marshal, .crrefresh = nul_refresh, .crvalidate = nul_validate, }; static struct rpc_cred null_cred = {
#include <linux/kernel.h> #include <linux/ktime.h> #include <linux/init.h> #include <linux/connector.h> #include <linux/gfp.h> #include <linux/ptrace.h> #include <linux/atomic.h> #include <linux/pid_namespace.h> #include <asm/unaligned.h> #include <linux/cn_proc.h> #define CN_PROC_MSG_SIZE (sizeof(struct cn_msg) + sizeof(struct proc_event)) static atomic_t proc_event_num_listeners = ATOMIC_INIT(0); static struct cb_id cn_proc_event_id = { CN_IDX_PROC, CN_VAL_PROC }; /* proc_event_counts is used as the sequence number of the netlink message */ static DEFINE_PER_CPU(__u32, proc_event_counts) = { 0 }; static inline void get_seq(__u32 *ts, int *cpu) { preempt_disable(); *ts = __this_cpu_inc_return(proc_event_counts) - 1; *cpu = smp_processor_id(); preempt_enable(); } void proc_fork_connector(struct task_struct *task) {
long spl_console_min_delay; EXPORT_SYMBOL(spl_console_min_delay); unsigned int spl_console_backoff = SPL_DEFAULT_BACKOFF; EXPORT_SYMBOL(spl_console_backoff); unsigned int spl_debug_stack; EXPORT_SYMBOL(spl_debug_stack); static int spl_panic_in_progress; union trace_data_union (*trace_data[TCD_TYPE_MAX])[NR_CPUS] __cacheline_aligned; char *trace_console_buffers[NR_CPUS][3]; struct rw_semaphore trace_sem; atomic_t trace_tage_allocated = ATOMIC_INIT(0); static int spl_debug_dump_all_pages(dumplog_priv_t *dp, char *); static void trace_fini(void); /* Memory percentage breakdown by type */ static unsigned int pages_factor[TCD_TYPE_MAX] = { 80, /* 80% pages for TCD_TYPE_PROC */ 10, /* 10% pages for TCD_TYPE_SOFTIRQ */ 10 /* 10% pages for TCD_TYPE_IRQ */ }; const char * spl_debug_subsys2str(int subsys) {
#include <asm/uaccess.h> #define FL_MIN_LINGER 6 /* Minimal linger. It is set to 6sec specified in old IPv6 RFC. Well, it was reasonable value. */ #define FL_MAX_LINGER 150 /* Maximal linger timeout */ /* FL hash table */ #define FL_MAX_PER_SOCK 32 #define FL_MAX_SIZE 4096 #define FL_HASH_MASK 255 #define FL_HASH(l) (ntohl(l)&FL_HASH_MASK) static atomic_t fl_size = ATOMIC_INIT(0); static struct ip6_flowlabel *fl_ht[FL_HASH_MASK+1]; static void ip6_fl_gc(unsigned long dummy); static DEFINE_TIMER(ip6_fl_gc_timer, ip6_fl_gc, 0, 0); /* FL hash table lock: it protects only of GC */ static DEFINE_RWLOCK(ip6_fl_lock); /* Big socket sock */ static DEFINE_RWLOCK(ip6_sk_fl_lock); static inline struct ip6_flowlabel *__fl_lookup(struct net *net, __be32 label)
NIPQUAD(en->addr), NIPQUAD(dest->addr), ntohs(dest->port)); return dest; } /* * IPVS LBLCR Scheduler structure */ static struct ip_vs_scheduler ip_vs_lblcr_scheduler = { {0}, /* n_list */ "lblcr", /* name */ ATOMIC_INIT(0), /* refcnt */ THIS_MODULE, /* this module */ ip_vs_lblcr_init_svc, /* service initializer */ ip_vs_lblcr_done_svc, /* service done */ ip_vs_lblcr_update_svc, /* service updater */ ip_vs_lblcr_schedule, /* select a server from the destination list */ }; static int __init ip_vs_lblcr_init(void) { INIT_LIST_HEAD(&ip_vs_lblcr_scheduler.n_list); lblcr_sysctl_table.sysctl_header = register_sysctl_table(lblcr_sysctl_table.root_dir, 0); #ifdef CONFIG_IP_VS_LBLCR_DEBUG proc_net_create("ip_vs_lblcr", 0, ip_vs_lblcr_getinfo);
* published by the Free Software Foundation; either version 2 of * the License, or (at your option) any later version. * */ #include "sun6i_dma_test.h" #include <linux/random.h> #define DTC_TOTAL_LEN SZ_512K //#define DTC_TOTAL_LEN SZ_16K #define DTC_ONE_LEN SZ_4K /* src/dst addr for loop dma transfer */ static u32 g_src_addr = 0, g_dst_addr = 0; static u32 g_qd_cnt = 0; /* queue done count */ static atomic_t g_acur_cnt = ATOMIC_INIT(0); u32 __cb_qd_single_mode(dm_hdl_t dma_hdl, void *parg, enum dma_cb_cause_e cause) { u32 uret = 0; u32 ucur_saddr = 0, ucur_daddr = 0; u32 uloop_cnt = DTC_TOTAL_LEN / DTC_ONE_LEN; u32 ucur_cnt = 0; pr_info("%s: called!\n", __func__); switch(cause) { case DMA_CB_OK: g_qd_cnt++; /* enqueue if not done */ ucur_cnt = atomic_add_return(1, &g_acur_cnt); if(ucur_cnt < uloop_cnt) {
/* ==========================================================================*/ #ifdef MODULE_PARAM_PREFIX #undef MODULE_PARAM_PREFIX #endif #define MODULE_PARAM_PREFIX "ambarella_config." #if defined(CONFIG_AMBARELLA_IPC) #define HANDLE_SDIO_FAKE_IRQ 1 #else #define HANDLE_SDIO_FAKE_IRQ 0 #endif /* ==========================================================================*/ static DECLARE_WAIT_QUEUE_HEAD(fio_lock); static atomic_t fio_owner = ATOMIC_INIT(SELECT_FIO_FREE); module_param_cb(fio_owner, ¶m_ops_int, &fio_owner, 0644); int fio_default_owner = SELECT_FIO_FREE; int fio_select_sdio_as_default = 1; module_param_cb(fio_default_owner, ¶m_ops_int, &fio_default_owner, 0644); /* ==========================================================================*/ void __fio_select_lock(int module) { u32 fio_ctr; u32 fio_dmactr; fio_ctr = amba_readl(FIO_CTR_REG); fio_dmactr = amba_readl(FIO_DMACTR_REG);
isEnabled, NULL, (void (*)(void*))deleteDegradedModeProcessor }, { configName, allConfig, config, setConfig, NULL, (void (*)(void*))deleteDegradedModeProcessor }, deleteDegradedModeProcessor, true, TALPA_SIMPLE_UNLOCKED(talpa_degraded_mode_processor_lock), ATOMIC_INIT(CFG_DEFAULT_THRESHOLD), false, TALPA_MUTEX_INIT, { {NULL, NULL, DMD_CFGDATASIZE, true, true }, {NULL, NULL, DMD_CFGDATASIZE, true, true }, {NULL, NULL, DMD_CFGDATASIZE, true, true }, {NULL, NULL, 0, false, false } }, { CFG_STATUS, CFG_VALUE_ENABLED }, { CFG_THRESHOLD, CFG_VALUE_THRESHOLD }, { CFG_ACTIVE, CFG_VALUE_ACTIVE } }; #define this ((DegradedModeProcessor*)self)
#define WDRTAS_SUPPORTED_MASK (WDIOF_SETTIMEOUT | \ WDIOF_MAGICCLOSE) MODULE_AUTHOR("Utz Bacher <*****@*****.**>"); MODULE_DESCRIPTION("RTAS watchdog driver"); MODULE_LICENSE("GPL"); MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); MODULE_ALIAS_MISCDEV(TEMP_MINOR); #ifdef CONFIG_WATCHDOG_NOWAYOUT static int wdrtas_nowayout = 1; #else static int wdrtas_nowayout = 0; #endif static atomic_t wdrtas_miscdev_open = ATOMIC_INIT(0); static char wdrtas_expect_close = 0; static int wdrtas_interval; #define WDRTAS_THERMAL_SENSOR 3 static int wdrtas_token_get_sensor_state; #define WDRTAS_SURVEILLANCE_IND 9000 static int wdrtas_token_set_indicator; #define WDRTAS_SP_SPI 28 static int wdrtas_token_get_sp; static int wdrtas_token_event_scan; #define WDRTAS_DEFAULT_INTERVAL 300 #define WDRTAS_LOGBUFFER_LEN 128
#include <mach/mt_typedefs.h> #include <asm/setup.h> #include <mach/mt_devinfo.h> void __iomem *APHW_CODE = NULL; void __iomem *APHW_SUBCODE = NULL; void __iomem *APHW_VER = NULL; void __iomem *APSW_VER = NULL; enum { CID_UNINIT = 0, CID_INITIALIZING = 1, CID_INITIALIZED = 2, } CID_INIT_STATE; static atomic_t g_cid_init = ATOMIC_INIT(CID_UNINIT); static void init_chip_id(unsigned int line) { if (CID_INITIALIZED == atomic_read(&g_cid_init)) return; if (CID_INITIALIZING == atomic_read(&g_cid_init)) { pr_warn("%s (%d) state(%d)\n", __func__, line, atomic_read(&g_cid_init)); return; } atomic_set(&g_cid_init, CID_INITIALIZING); #ifdef CONFIG_OF { struct device_node *node = of_find_compatible_node(NULL, NULL, "mediatek,CHIPID");
#define MMC_PLATFORM_DEV "msm_sdcc.2" #else #define MMC_PLATFORM_DEV "sdcc" #endif /* End MMC polling stuff */ #define GET_INODE_FROM_FILEP(filp) \ ((filp)->f_path.dentry->d_inode) #define ATH6KL_INIT_TIMEOUT (3 * HZ) wait_queue_head_t init_wq; static atomic_t init_done = ATOMIC_INIT(0); int android_readwrite_file(const char *filename, char *rbuf, const char *wbuf, size_t length) { int ret = 0; struct file *filp = (struct file *)-ENOENT; mm_segment_t oldfs; oldfs = get_fs(); set_fs(KERNEL_DS); do { int mode = (wbuf) ? O_RDWR|O_CREAT : O_RDONLY; filp = filp_open(filename, mode, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH); if (IS_ERR(filp) || !filp->f_op) {
#include <mach/gpio.h> #include <mach/pmic.h> #include <mach/dal.h> #include "board-mecha.h" #include <mach/qdsp5v2_2x/snddev_icodec.h> #include <mach/qdsp5v2_2x/snddev_ecodec.h> #include <mach/qdsp5v2_2x/audio_def.h> #include <mach/qdsp5v2_2x/voice.h> #include <mach/htc_acoustic_7x30.h> #include <mach/htc_acdb_7x30.h> #include <mach/board_htc.h> #include <linux/spi/spi_aic3254.h> static struct mutex bt_sco_lock; static int curr_rx_mode; static atomic_t aic3254_ctl = ATOMIC_INIT(0); void mecha_back_mic_enable(int); #define BIT_SPEAKER (1 << 0) #define BIT_HEADSET (1 << 1) #define BIT_RECEIVER (1 << 2) #define BIT_FM_SPK (1 << 3) #define BIT_FM_HS (1 << 4) #define MECHA_ACDB_RADIO_BUFFER_SIZE (1024 * 2304) static struct q5v2_hw_info q5v2_audio_hw[Q5V2_HW_COUNT] = { [Q5V2_HW_HANDSET] = { .max_gain[VOC_NB_INDEX] = 0, .min_gain[VOC_NB_INDEX] = 0,
#include "esif_uf_primitive.h" #include "esif_uf_ccb_timedwait.h" #ifdef ESIF_ATTR_OS_WINDOWS // // The Windows banned-API check header must be included after all other headers, or issues can be identified // against Windows SDK/DDK included headers which we have no control over. // #define _SDL_BANNED_RECOMMENDED #include "win\banned.h" #endif #define ESIF_DATALOG_LOCK_SLEEP_MS 1 static atomic_t g_dataLogLock = ATOMIC_INIT(0); static Bool g_dataLogActive = ESIF_FALSE; static Bool g_dataLogQuit = ESIF_FALSE; static esif_ccb_event_t g_dataLogQuitEvent; static esif_thread_t g_dataLogThread; //upper framework polling thread static DataLogParticipant g_dataLogParticipants[MAX_PARTICIPANT_ENTRY]; static UInt32 g_dataLogInterval = DEFAULT_STATUS_LOG_INTERVAL; static void EsifDataLogExit(esif_thread_t *dataLogThread); static void EsifDataLogFire(int isHeader); static eEsifError EsifDataLogValidateParticipantList(char *inParticipantList); static eEsifError EsifDataLogAddParticipant(char *logString, int logColumn, int isHeader); static void *ESIF_CALLCONV EsifDataLogWorkerThread(void *ptr); static UInt8 EsifDataIsLogStarted(); static eEsifError EsifDataLogOpenLogFile();