};
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();
