1
2
3
4#line 20 "include/asm-generic/int-ll64.h"
5typedef unsigned char __u8;
6#line 23 "include/asm-generic/int-ll64.h"
7typedef unsigned short __u16;
8#line 26 "include/asm-generic/int-ll64.h"
9typedef unsigned int __u32;
10#line 30 "include/asm-generic/int-ll64.h"
11typedef unsigned long long __u64;
12#line 45 "include/asm-generic/int-ll64.h"
13typedef short s16;
14#line 46 "include/asm-generic/int-ll64.h"
15typedef unsigned short u16;
16#line 49 "include/asm-generic/int-ll64.h"
17typedef unsigned int u32;
18#line 51 "include/asm-generic/int-ll64.h"
19typedef long long s64;
20#line 52 "include/asm-generic/int-ll64.h"
21typedef unsigned long long u64;
22#line 14 "include/asm-generic/posix_types.h"
23typedef long __kernel_long_t;
24#line 15 "include/asm-generic/posix_types.h"
25typedef unsigned long __kernel_ulong_t;
26#line 75 "include/asm-generic/posix_types.h"
27typedef __kernel_ulong_t __kernel_size_t;
28#line 76 "include/asm-generic/posix_types.h"
29typedef __kernel_long_t __kernel_ssize_t;
30#line 91 "include/asm-generic/posix_types.h"
31typedef long long __kernel_loff_t;
32#line 21 "include/linux/types.h"
33typedef __u32 __kernel_dev_t;
34#line 24 "include/linux/types.h"
35typedef __kernel_dev_t dev_t;
36#line 27 "include/linux/types.h"
37typedef unsigned short umode_t;
38#line 38 "include/linux/types.h"
39typedef _Bool bool;
40#line 54 "include/linux/types.h"
41typedef __kernel_loff_t loff_t;
42#line 63 "include/linux/types.h"
43typedef __kernel_size_t size_t;
44#line 68 "include/linux/types.h"
45typedef __kernel_ssize_t ssize_t;
46#line 202 "include/linux/types.h"
47typedef unsigned int gfp_t;
48#line 206 "include/linux/types.h"
49typedef u64 phys_addr_t;
50#line 211 "include/linux/types.h"
51typedef phys_addr_t resource_size_t;
52#line 219 "include/linux/types.h"
53struct __anonstruct_atomic_t_7 {
54 int counter ;
55};
56#line 219 "include/linux/types.h"
57typedef struct __anonstruct_atomic_t_7 atomic_t;
58#line 224 "include/linux/types.h"
59struct __anonstruct_atomic64_t_8 {
60 long counter ;
61};
62#line 224 "include/linux/types.h"
63typedef struct __anonstruct_atomic64_t_8 atomic64_t;
64#line 229 "include/linux/types.h"
65struct list_head {
66 struct list_head *next ;
67 struct list_head *prev ;
68};
69#line 56 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/alternative.h"
70struct module;
71#line 56
72struct module;
73#line 146 "include/linux/init.h"
74typedef void (*ctor_fn_t)(void);
75#line 47 "include/linux/dynamic_debug.h"
76struct device;
77#line 47
78struct device;
79#line 135 "include/linux/kernel.h"
80struct completion;
81#line 135
82struct completion;
83#line 20 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/thread_info.h"
84struct task_struct;
85#line 20
86struct task_struct;
87#line 7 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/processor.h"
88struct task_struct;
89#line 295 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/pgtable_types.h"
90struct file;
91#line 295
92struct file;
93#line 52 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/paravirt_types.h"
94struct task_struct;
95#line 329
96struct arch_spinlock;
97#line 329
98struct arch_spinlock;
99#line 139 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/ptrace.h"
100struct task_struct;
101#line 8 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/current.h"
102struct task_struct;
103#line 10 "include/asm-generic/bug.h"
104struct bug_entry {
105 int bug_addr_disp ;
106 int file_disp ;
107 unsigned short line ;
108 unsigned short flags ;
109};
110#line 234 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/paravirt.h"
111struct static_key;
112#line 234
113struct static_key;
114#line 23 "include/asm-generic/atomic-long.h"
115typedef atomic64_t atomic_long_t;
116#line 14 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/spinlock_types.h"
117typedef u16 __ticket_t;
118#line 15 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/spinlock_types.h"
119typedef u32 __ticketpair_t;
120#line 20 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/spinlock_types.h"
121struct __raw_tickets {
122 __ticket_t head ;
123 __ticket_t tail ;
124};
125#line 20 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/spinlock_types.h"
126union __anonunion____missing_field_name_36 {
127 __ticketpair_t head_tail ;
128 struct __raw_tickets tickets ;
129};
130#line 20 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/spinlock_types.h"
131struct arch_spinlock {
132 union __anonunion____missing_field_name_36 __annonCompField17 ;
133};
134#line 20 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/spinlock_types.h"
135typedef struct arch_spinlock arch_spinlock_t;
136#line 12 "include/linux/lockdep.h"
137struct task_struct;
138#line 391 "include/linux/lockdep.h"
139struct lock_class_key {
140
141};
142#line 20 "include/linux/spinlock_types.h"
143struct raw_spinlock {
144 arch_spinlock_t raw_lock ;
145 unsigned int magic ;
146 unsigned int owner_cpu ;
147 void *owner ;
148};
149#line 64 "include/linux/spinlock_types.h"
150union __anonunion____missing_field_name_39 {
151 struct raw_spinlock rlock ;
152};
153#line 64 "include/linux/spinlock_types.h"
154struct spinlock {
155 union __anonunion____missing_field_name_39 __annonCompField19 ;
156};
157#line 64 "include/linux/spinlock_types.h"
158typedef struct spinlock spinlock_t;
159#line 49 "include/linux/wait.h"
160struct __wait_queue_head {
161 spinlock_t lock ;
162 struct list_head task_list ;
163};
164#line 53 "include/linux/wait.h"
165typedef struct __wait_queue_head wait_queue_head_t;
166#line 55
167struct task_struct;
168#line 48 "include/linux/mutex.h"
169struct mutex {
170 atomic_t count ;
171 spinlock_t wait_lock ;
172 struct list_head wait_list ;
173 struct task_struct *owner ;
174 char const *name ;
175 void *magic ;
176};
177#line 25 "include/linux/completion.h"
178struct completion {
179 unsigned int done ;
180 wait_queue_head_t wait ;
181};
182#line 18 "include/linux/ioport.h"
183struct resource {
184 resource_size_t start ;
185 resource_size_t end ;
186 char const *name ;
187 unsigned long flags ;
188 struct resource *parent ;
189 struct resource *sibling ;
190 struct resource *child ;
191};
192#line 202
193struct device;
194#line 103 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/mpspec.h"
195struct device;
196#line 46 "include/linux/ktime.h"
197union ktime {
198 s64 tv64 ;
199};
200#line 59 "include/linux/ktime.h"
201typedef union ktime ktime_t;
202#line 10 "include/linux/timer.h"
203struct tvec_base;
204#line 10
205struct tvec_base;
206#line 12 "include/linux/timer.h"
207struct timer_list {
208 struct list_head entry ;
209 unsigned long expires ;
210 struct tvec_base *base ;
211 void (*function)(unsigned long ) ;
212 unsigned long data ;
213 int slack ;
214 int start_pid ;
215 void *start_site ;
216 char start_comm[16] ;
217};
218#line 17 "include/linux/workqueue.h"
219struct work_struct;
220#line 17
221struct work_struct;
222#line 79 "include/linux/workqueue.h"
223struct work_struct {
224 atomic_long_t data ;
225 struct list_head entry ;
226 void (*func)(struct work_struct *work ) ;
227};
228#line 42 "include/linux/pm.h"
229struct device;
230#line 50 "include/linux/pm.h"
231struct pm_message {
232 int event ;
233};
234#line 50 "include/linux/pm.h"
235typedef struct pm_message pm_message_t;
236#line 264 "include/linux/pm.h"
237struct dev_pm_ops {
238 int (*prepare)(struct device *dev ) ;
239 void (*complete)(struct device *dev ) ;
240 int (*suspend)(struct device *dev ) ;
241 int (*resume)(struct device *dev ) ;
242 int (*freeze)(struct device *dev ) ;
243 int (*thaw)(struct device *dev ) ;
244 int (*poweroff)(struct device *dev ) ;
245 int (*restore)(struct device *dev ) ;
246 int (*suspend_late)(struct device *dev ) ;
247 int (*resume_early)(struct device *dev ) ;
248 int (*freeze_late)(struct device *dev ) ;
249 int (*thaw_early)(struct device *dev ) ;
250 int (*poweroff_late)(struct device *dev ) ;
251 int (*restore_early)(struct device *dev ) ;
252 int (*suspend_noirq)(struct device *dev ) ;
253 int (*resume_noirq)(struct device *dev ) ;
254 int (*freeze_noirq)(struct device *dev ) ;
255 int (*thaw_noirq)(struct device *dev ) ;
256 int (*poweroff_noirq)(struct device *dev ) ;
257 int (*restore_noirq)(struct device *dev ) ;
258 int (*runtime_suspend)(struct device *dev ) ;
259 int (*runtime_resume)(struct device *dev ) ;
260 int (*runtime_idle)(struct device *dev ) ;
261};
262#line 458
263enum rpm_status {
264 RPM_ACTIVE = 0,
265 RPM_RESUMING = 1,
266 RPM_SUSPENDED = 2,
267 RPM_SUSPENDING = 3
268} ;
269#line 480
270enum rpm_request {
271 RPM_REQ_NONE = 0,
272 RPM_REQ_IDLE = 1,
273 RPM_REQ_SUSPEND = 2,
274 RPM_REQ_AUTOSUSPEND = 3,
275 RPM_REQ_RESUME = 4
276} ;
277#line 488
278struct wakeup_source;
279#line 488
280struct wakeup_source;
281#line 495 "include/linux/pm.h"
282struct pm_subsys_data {
283 spinlock_t lock ;
284 unsigned int refcount ;
285};
286#line 506
287struct dev_pm_qos_request;
288#line 506
289struct pm_qos_constraints;
290#line 506 "include/linux/pm.h"
291struct dev_pm_info {
292 pm_message_t power_state ;
293 unsigned int can_wakeup : 1 ;
294 unsigned int async_suspend : 1 ;
295 bool is_prepared : 1 ;
296 bool is_suspended : 1 ;
297 bool ignore_children : 1 ;
298 spinlock_t lock ;
299 struct list_head entry ;
300 struct completion completion ;
301 struct wakeup_source *wakeup ;
302 bool wakeup_path : 1 ;
303 struct timer_list suspend_timer ;
304 unsigned long timer_expires ;
305 struct work_struct work ;
306 wait_queue_head_t wait_queue ;
307 atomic_t usage_count ;
308 atomic_t child_count ;
309 unsigned int disable_depth : 3 ;
310 unsigned int idle_notification : 1 ;
311 unsigned int request_pending : 1 ;
312 unsigned int deferred_resume : 1 ;
313 unsigned int run_wake : 1 ;
314 unsigned int runtime_auto : 1 ;
315 unsigned int no_callbacks : 1 ;
316 unsigned int irq_safe : 1 ;
317 unsigned int use_autosuspend : 1 ;
318 unsigned int timer_autosuspends : 1 ;
319 enum rpm_request request ;
320 enum rpm_status runtime_status ;
321 int runtime_error ;
322 int autosuspend_delay ;
323 unsigned long last_busy ;
324 unsigned long active_jiffies ;
325 unsigned long suspended_jiffies ;
326 unsigned long accounting_timestamp ;
327 ktime_t suspend_time ;
328 s64 max_time_suspended_ns ;
329 struct dev_pm_qos_request *pq_req ;
330 struct pm_subsys_data *subsys_data ;
331 struct pm_qos_constraints *constraints ;
332};
333#line 564 "include/linux/pm.h"
334struct dev_pm_domain {
335 struct dev_pm_ops ops ;
336};
337#line 8 "include/linux/vmalloc.h"
338struct vm_area_struct;
339#line 8
340struct vm_area_struct;
341#line 10 "include/linux/gfp.h"
342struct vm_area_struct;
343#line 29 "include/linux/sysctl.h"
344struct completion;
345#line 49 "include/linux/kmod.h"
346struct file;
347#line 270 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/elf.h"
348struct task_struct;
349#line 18 "include/linux/elf.h"
350typedef __u64 Elf64_Addr;
351#line 19 "include/linux/elf.h"
352typedef __u16 Elf64_Half;
353#line 23 "include/linux/elf.h"
354typedef __u32 Elf64_Word;
355#line 24 "include/linux/elf.h"
356typedef __u64 Elf64_Xword;
357#line 194 "include/linux/elf.h"
358struct elf64_sym {
359 Elf64_Word st_name ;
360 unsigned char st_info ;
361 unsigned char st_other ;
362 Elf64_Half st_shndx ;
363 Elf64_Addr st_value ;
364 Elf64_Xword st_size ;
365};
366#line 194 "include/linux/elf.h"
367typedef struct elf64_sym Elf64_Sym;
368#line 438
369struct file;
370#line 20 "include/linux/kobject_ns.h"
371struct sock;
372#line 20
373struct sock;
374#line 21
375struct kobject;
376#line 21
377struct kobject;
378#line 27
379enum kobj_ns_type {
380 KOBJ_NS_TYPE_NONE = 0,
381 KOBJ_NS_TYPE_NET = 1,
382 KOBJ_NS_TYPES = 2
383} ;
384#line 40 "include/linux/kobject_ns.h"
385struct kobj_ns_type_operations {
386 enum kobj_ns_type type ;
387 void *(*grab_current_ns)(void) ;
388 void const *(*netlink_ns)(struct sock *sk ) ;
389 void const *(*initial_ns)(void) ;
390 void (*drop_ns)(void * ) ;
391};
392#line 22 "include/linux/sysfs.h"
393struct kobject;
394#line 23
395struct module;
396#line 24
397enum kobj_ns_type;
398#line 26 "include/linux/sysfs.h"
399struct attribute {
400 char const *name ;
401 umode_t mode ;
402};
403#line 56 "include/linux/sysfs.h"
404struct attribute_group {
405 char const *name ;
406 umode_t (*is_visible)(struct kobject * , struct attribute * , int ) ;
407 struct attribute **attrs ;
408};
409#line 85
410struct file;
411#line 86
412struct vm_area_struct;
413#line 88 "include/linux/sysfs.h"
414struct bin_attribute {
415 struct attribute attr ;
416 size_t size ;
417 void *private ;
418 ssize_t (*read)(struct file * , struct kobject * , struct bin_attribute * , char * ,
419 loff_t , size_t ) ;
420 ssize_t (*write)(struct file * , struct kobject * , struct bin_attribute * , char * ,
421 loff_t , size_t ) ;
422 int (*mmap)(struct file * , struct kobject * , struct bin_attribute *attr , struct vm_area_struct *vma ) ;
423};
424#line 112 "include/linux/sysfs.h"
425struct sysfs_ops {
426 ssize_t (*show)(struct kobject * , struct attribute * , char * ) ;
427 ssize_t (*store)(struct kobject * , struct attribute * , char const * , size_t ) ;
428 void const *(*namespace)(struct kobject * , struct attribute const * ) ;
429};
430#line 118
431struct sysfs_dirent;
432#line 118
433struct sysfs_dirent;
434#line 22 "include/linux/kref.h"
435struct kref {
436 atomic_t refcount ;
437};
438#line 60 "include/linux/kobject.h"
439struct kset;
440#line 60
441struct kobj_type;
442#line 60 "include/linux/kobject.h"
443struct kobject {
444 char const *name ;
445 struct list_head entry ;
446 struct kobject *parent ;
447 struct kset *kset ;
448 struct kobj_type *ktype ;
449 struct sysfs_dirent *sd ;
450 struct kref kref ;
451 unsigned int state_initialized : 1 ;
452 unsigned int state_in_sysfs : 1 ;
453 unsigned int state_add_uevent_sent : 1 ;
454 unsigned int state_remove_uevent_sent : 1 ;
455 unsigned int uevent_suppress : 1 ;
456};
457#line 108 "include/linux/kobject.h"
458struct kobj_type {
459 void (*release)(struct kobject *kobj ) ;
460 struct sysfs_ops const *sysfs_ops ;
461 struct attribute **default_attrs ;
462 struct kobj_ns_type_operations const *(*child_ns_type)(struct kobject *kobj ) ;
463 void const *(*namespace)(struct kobject *kobj ) ;
464};
465#line 116 "include/linux/kobject.h"
466struct kobj_uevent_env {
467 char *envp[32] ;
468 int envp_idx ;
469 char buf[2048] ;
470 int buflen ;
471};
472#line 123 "include/linux/kobject.h"
473struct kset_uevent_ops {
474 int (* const filter)(struct kset *kset , struct kobject *kobj ) ;
475 char const *(* const name)(struct kset *kset , struct kobject *kobj ) ;
476 int (* const uevent)(struct kset *kset , struct kobject *kobj , struct kobj_uevent_env *env ) ;
477};
478#line 140
479struct sock;
480#line 159 "include/linux/kobject.h"
481struct kset {
482 struct list_head list ;
483 spinlock_t list_lock ;
484 struct kobject kobj ;
485 struct kset_uevent_ops const *uevent_ops ;
486};
487#line 39 "include/linux/moduleparam.h"
488struct kernel_param;
489#line 39
490struct kernel_param;
491#line 41 "include/linux/moduleparam.h"
492struct kernel_param_ops {
493 int (*set)(char const *val , struct kernel_param const *kp ) ;
494 int (*get)(char *buffer , struct kernel_param const *kp ) ;
495 void (*free)(void *arg ) ;
496};
497#line 50
498struct kparam_string;
499#line 50
500struct kparam_array;
501#line 50 "include/linux/moduleparam.h"
502union __anonunion____missing_field_name_199 {
503 void *arg ;
504 struct kparam_string const *str ;
505 struct kparam_array const *arr ;
506};
507#line 50 "include/linux/moduleparam.h"
508struct kernel_param {
509 char const *name ;
510 struct kernel_param_ops const *ops ;
511 u16 perm ;
512 s16 level ;
513 union __anonunion____missing_field_name_199 __annonCompField32 ;
514};
515#line 63 "include/linux/moduleparam.h"
516struct kparam_string {
517 unsigned int maxlen ;
518 char *string ;
519};
520#line 69 "include/linux/moduleparam.h"
521struct kparam_array {
522 unsigned int max ;
523 unsigned int elemsize ;
524 unsigned int *num ;
525 struct kernel_param_ops const *ops ;
526 void *elem ;
527};
528#line 445
529struct module;
530#line 80 "include/linux/jump_label.h"
531struct module;
532#line 143 "include/linux/jump_label.h"
533struct static_key {
534 atomic_t enabled ;
535};
536#line 22 "include/linux/tracepoint.h"
537struct module;
538#line 23
539struct tracepoint;
540#line 23
541struct tracepoint;
542#line 25 "include/linux/tracepoint.h"
543struct tracepoint_func {
544 void *func ;
545 void *data ;
546};
547#line 30 "include/linux/tracepoint.h"
548struct tracepoint {
549 char const *name ;
550 struct static_key key ;
551 void (*regfunc)(void) ;
552 void (*unregfunc)(void) ;
553 struct tracepoint_func *funcs ;
554};
555#line 19 "include/linux/export.h"
556struct kernel_symbol {
557 unsigned long value ;
558 char const *name ;
559};
560#line 8 "include/asm-generic/module.h"
561struct mod_arch_specific {
562
563};
564#line 35 "include/linux/module.h"
565struct module;
566#line 37
567struct module_param_attrs;
568#line 37 "include/linux/module.h"
569struct module_kobject {
570 struct kobject kobj ;
571 struct module *mod ;
572 struct kobject *drivers_dir ;
573 struct module_param_attrs *mp ;
574};
575#line 44 "include/linux/module.h"
576struct module_attribute {
577 struct attribute attr ;
578 ssize_t (*show)(struct module_attribute * , struct module_kobject * , char * ) ;
579 ssize_t (*store)(struct module_attribute * , struct module_kobject * , char const * ,
580 size_t count ) ;
581 void (*setup)(struct module * , char const * ) ;
582 int (*test)(struct module * ) ;
583 void (*free)(struct module * ) ;
584};
585#line 71
586struct exception_table_entry;
587#line 71
588struct exception_table_entry;
589#line 199
590enum module_state {
591 MODULE_STATE_LIVE = 0,
592 MODULE_STATE_COMING = 1,
593 MODULE_STATE_GOING = 2
594} ;
595#line 215 "include/linux/module.h"
596struct module_ref {
597 unsigned long incs ;
598 unsigned long decs ;
599} __attribute__((__aligned__((2) * (sizeof(unsigned long )) ))) ;
600#line 220
601struct module_sect_attrs;
602#line 220
603struct module_notes_attrs;
604#line 220
605struct ftrace_event_call;
606#line 220 "include/linux/module.h"
607struct module {
608 enum module_state state ;
609 struct list_head list ;
610 char name[64UL - sizeof(unsigned long )] ;
611 struct module_kobject mkobj ;
612 struct module_attribute *modinfo_attrs ;
613 char const *version ;
614 char const *srcversion ;
615 struct kobject *holders_dir ;
616 struct kernel_symbol const *syms ;
617 unsigned long const *crcs ;
618 unsigned int num_syms ;
619 struct kernel_param *kp ;
620 unsigned int num_kp ;
621 unsigned int num_gpl_syms ;
622 struct kernel_symbol const *gpl_syms ;
623 unsigned long const *gpl_crcs ;
624 struct kernel_symbol const *unused_syms ;
625 unsigned long const *unused_crcs ;
626 unsigned int num_unused_syms ;
627 unsigned int num_unused_gpl_syms ;
628 struct kernel_symbol const *unused_gpl_syms ;
629 unsigned long const *unused_gpl_crcs ;
630 struct kernel_symbol const *gpl_future_syms ;
631 unsigned long const *gpl_future_crcs ;
632 unsigned int num_gpl_future_syms ;
633 unsigned int num_exentries ;
634 struct exception_table_entry *extable ;
635 int (*init)(void) ;
636 void *module_init ;
637 void *module_core ;
638 unsigned int init_size ;
639 unsigned int core_size ;
640 unsigned int init_text_size ;
641 unsigned int core_text_size ;
642 unsigned int init_ro_size ;
643 unsigned int core_ro_size ;
644 struct mod_arch_specific arch ;
645 unsigned int taints ;
646 unsigned int num_bugs ;
647 struct list_head bug_list ;
648 struct bug_entry *bug_table ;
649 Elf64_Sym *symtab ;
650 Elf64_Sym *core_symtab ;
651 unsigned int num_symtab ;
652 unsigned int core_num_syms ;
653 char *strtab ;
654 char *core_strtab ;
655 struct module_sect_attrs *sect_attrs ;
656 struct module_notes_attrs *notes_attrs ;
657 char *args ;
658 void *percpu ;
659 unsigned int percpu_size ;
660 unsigned int num_tracepoints ;
661 struct tracepoint * const *tracepoints_ptrs ;
662 unsigned int num_trace_bprintk_fmt ;
663 char const **trace_bprintk_fmt_start ;
664 struct ftrace_event_call **trace_events ;
665 unsigned int num_trace_events ;
666 struct list_head source_list ;
667 struct list_head target_list ;
668 struct task_struct *waiter ;
669 void (*exit)(void) ;
670 struct module_ref *refptr ;
671 ctor_fn_t *ctors ;
672 unsigned int num_ctors ;
673};
674#line 19 "include/linux/klist.h"
675struct klist_node;
676#line 19
677struct klist_node;
678#line 39 "include/linux/klist.h"
679struct klist_node {
680 void *n_klist ;
681 struct list_head n_node ;
682 struct kref n_ref ;
683};
684#line 4 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/device.h"
685struct dma_map_ops;
686#line 4 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/device.h"
687struct dev_archdata {
688 void *acpi_handle ;
689 struct dma_map_ops *dma_ops ;
690 void *iommu ;
691};
692#line 16 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/device.h"
693struct pdev_archdata {
694
695};
696#line 28 "include/linux/device.h"
697struct device;
698#line 29
699struct device_private;
700#line 29
701struct device_private;
702#line 30
703struct device_driver;
704#line 30
705struct device_driver;
706#line 31
707struct driver_private;
708#line 31
709struct driver_private;
710#line 32
711struct module;
712#line 33
713struct class;
714#line 33
715struct class;
716#line 34
717struct subsys_private;
718#line 34
719struct subsys_private;
720#line 35
721struct bus_type;
722#line 35
723struct bus_type;
724#line 36
725struct device_node;
726#line 36
727struct device_node;
728#line 37
729struct iommu_ops;
730#line 37
731struct iommu_ops;
732#line 39 "include/linux/device.h"
733struct bus_attribute {
734 struct attribute attr ;
735 ssize_t (*show)(struct bus_type *bus , char *buf ) ;
736 ssize_t (*store)(struct bus_type *bus , char const *buf , size_t count ) ;
737};
738#line 89
739struct device_attribute;
740#line 89
741struct driver_attribute;
742#line 89 "include/linux/device.h"
743struct bus_type {
744 char const *name ;
745 char const *dev_name ;
746 struct device *dev_root ;
747 struct bus_attribute *bus_attrs ;
748 struct device_attribute *dev_attrs ;
749 struct driver_attribute *drv_attrs ;
750 int (*match)(struct device *dev , struct device_driver *drv ) ;
751 int (*uevent)(struct device *dev , struct kobj_uevent_env *env ) ;
752 int (*probe)(struct device *dev ) ;
753 int (*remove)(struct device *dev ) ;
754 void (*shutdown)(struct device *dev ) ;
755 int (*suspend)(struct device *dev , pm_message_t state ) ;
756 int (*resume)(struct device *dev ) ;
757 struct dev_pm_ops const *pm ;
758 struct iommu_ops *iommu_ops ;
759 struct subsys_private *p ;
760};
761#line 127
762struct device_type;
763#line 214
764struct of_device_id;
765#line 214 "include/linux/device.h"
766struct device_driver {
767 char const *name ;
768 struct bus_type *bus ;
769 struct module *owner ;
770 char const *mod_name ;
771 bool suppress_bind_attrs ;
772 struct of_device_id const *of_match_table ;
773 int (*probe)(struct device *dev ) ;
774 int (*remove)(struct device *dev ) ;
775 void (*shutdown)(struct device *dev ) ;
776 int (*suspend)(struct device *dev , pm_message_t state ) ;
777 int (*resume)(struct device *dev ) ;
778 struct attribute_group const **groups ;
779 struct dev_pm_ops const *pm ;
780 struct driver_private *p ;
781};
782#line 249 "include/linux/device.h"
783struct driver_attribute {
784 struct attribute attr ;
785 ssize_t (*show)(struct device_driver *driver , char *buf ) ;
786 ssize_t (*store)(struct device_driver *driver , char const *buf , size_t count ) ;
787};
788#line 330
789struct class_attribute;
790#line 330 "include/linux/device.h"
791struct class {
792 char const *name ;
793 struct module *owner ;
794 struct class_attribute *class_attrs ;
795 struct device_attribute *dev_attrs ;
796 struct bin_attribute *dev_bin_attrs ;
797 struct kobject *dev_kobj ;
798 int (*dev_uevent)(struct device *dev , struct kobj_uevent_env *env ) ;
799 char *(*devnode)(struct device *dev , umode_t *mode ) ;
800 void (*class_release)(struct class *class ) ;
801 void (*dev_release)(struct device *dev ) ;
802 int (*suspend)(struct device *dev , pm_message_t state ) ;
803 int (*resume)(struct device *dev ) ;
804 struct kobj_ns_type_operations const *ns_type ;
805 void const *(*namespace)(struct device *dev ) ;
806 struct dev_pm_ops const *pm ;
807 struct subsys_private *p ;
808};
809#line 397 "include/linux/device.h"
810struct class_attribute {
811 struct attribute attr ;
812 ssize_t (*show)(struct class *class , struct class_attribute *attr , char *buf ) ;
813 ssize_t (*store)(struct class *class , struct class_attribute *attr , char const *buf ,
814 size_t count ) ;
815 void const *(*namespace)(struct class *class , struct class_attribute const *attr ) ;
816};
817#line 465 "include/linux/device.h"
818struct device_type {
819 char const *name ;
820 struct attribute_group const **groups ;
821 int (*uevent)(struct device *dev , struct kobj_uevent_env *env ) ;
822 char *(*devnode)(struct device *dev , umode_t *mode ) ;
823 void (*release)(struct device *dev ) ;
824 struct dev_pm_ops const *pm ;
825};
826#line 476 "include/linux/device.h"
827struct device_attribute {
828 struct attribute attr ;
829 ssize_t (*show)(struct device *dev , struct device_attribute *attr , char *buf ) ;
830 ssize_t (*store)(struct device *dev , struct device_attribute *attr , char const *buf ,
831 size_t count ) ;
832};
833#line 559 "include/linux/device.h"
834struct device_dma_parameters {
835 unsigned int max_segment_size ;
836 unsigned long segment_boundary_mask ;
837};
838#line 627
839struct dma_coherent_mem;
840#line 627 "include/linux/device.h"
841struct device {
842 struct device *parent ;
843 struct device_private *p ;
844 struct kobject kobj ;
845 char const *init_name ;
846 struct device_type const *type ;
847 struct mutex mutex ;
848 struct bus_type *bus ;
849 struct device_driver *driver ;
850 void *platform_data ;
851 struct dev_pm_info power ;
852 struct dev_pm_domain *pm_domain ;
853 int numa_node ;
854 u64 *dma_mask ;
855 u64 coherent_dma_mask ;
856 struct device_dma_parameters *dma_parms ;
857 struct list_head dma_pools ;
858 struct dma_coherent_mem *dma_mem ;
859 struct dev_archdata archdata ;
860 struct device_node *of_node ;
861 dev_t devt ;
862 u32 id ;
863 spinlock_t devres_lock ;
864 struct list_head devres_head ;
865 struct klist_node knode_class ;
866 struct class *class ;
867 struct attribute_group const **groups ;
868 void (*release)(struct device *dev ) ;
869};
870#line 43 "include/linux/pm_wakeup.h"
871struct wakeup_source {
872 char const *name ;
873 struct list_head entry ;
874 spinlock_t lock ;
875 struct timer_list timer ;
876 unsigned long timer_expires ;
877 ktime_t total_time ;
878 ktime_t max_time ;
879 ktime_t last_time ;
880 unsigned long event_count ;
881 unsigned long active_count ;
882 unsigned long relax_count ;
883 unsigned long hit_count ;
884 unsigned int active : 1 ;
885};
886#line 12 "include/linux/mod_devicetable.h"
887typedef unsigned long kernel_ulong_t;
888#line 219 "include/linux/mod_devicetable.h"
889struct of_device_id {
890 char name[32] ;
891 char type[32] ;
892 char compatible[128] ;
893 void *data ;
894};
895#line 506 "include/linux/mod_devicetable.h"
896struct platform_device_id {
897 char name[20] ;
898 kernel_ulong_t driver_data __attribute__((__aligned__(sizeof(kernel_ulong_t )))) ;
899};
900#line 17 "include/linux/platform_device.h"
901struct mfd_cell;
902#line 17
903struct mfd_cell;
904#line 19 "include/linux/platform_device.h"
905struct platform_device {
906 char const *name ;
907 int id ;
908 struct device dev ;
909 u32 num_resources ;
910 struct resource *resource ;
911 struct platform_device_id const *id_entry ;
912 struct mfd_cell *mfd_cell ;
913 struct pdev_archdata archdata ;
914};
915#line 164 "include/linux/platform_device.h"
916struct platform_driver {
917 int (*probe)(struct platform_device * ) ;
918 int (*remove)(struct platform_device * ) ;
919 void (*shutdown)(struct platform_device * ) ;
920 int (*suspend)(struct platform_device * , pm_message_t state ) ;
921 int (*resume)(struct platform_device * ) ;
922 struct device_driver driver ;
923 struct platform_device_id const *id_table ;
924};
925#line 17 "include/linux/watchdog.h"
926struct watchdog_info {
927 __u32 options ;
928 __u32 firmware_version ;
929 __u8 identity[32] ;
930};
931#line 58
932struct watchdog_ops;
933#line 58
934struct watchdog_ops;
935#line 59
936struct watchdog_device;
937#line 59
938struct watchdog_device;
939#line 77 "include/linux/watchdog.h"
940struct watchdog_ops {
941 struct module *owner ;
942 int (*start)(struct watchdog_device * ) ;
943 int (*stop)(struct watchdog_device * ) ;
944 int (*ping)(struct watchdog_device * ) ;
945 unsigned int (*status)(struct watchdog_device * ) ;
946 int (*set_timeout)(struct watchdog_device * , unsigned int ) ;
947 unsigned int (*get_timeleft)(struct watchdog_device * ) ;
948 long (*ioctl)(struct watchdog_device * , unsigned int , unsigned long ) ;
949};
950#line 107 "include/linux/watchdog.h"
951struct watchdog_device {
952 struct watchdog_info const *info ;
953 struct watchdog_ops const *ops ;
954 unsigned int bootstatus ;
955 unsigned int timeout ;
956 unsigned int min_timeout ;
957 unsigned int max_timeout ;
958 void *driver_data ;
959 unsigned long status ;
960};
961#line 94 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/uaccess.h"
962struct exception_table_entry {
963 unsigned long insn ;
964 unsigned long fixup ;
965};
966#line 28 "include/linux/of.h"
967typedef u32 phandle;
968#line 31 "include/linux/of.h"
969struct property {
970 char *name ;
971 int length ;
972 void *value ;
973 struct property *next ;
974 unsigned long _flags ;
975 unsigned int unique_id ;
976};
977#line 44
978struct proc_dir_entry;
979#line 44 "include/linux/of.h"
980struct device_node {
981 char const *name ;
982 char const *type ;
983 phandle phandle ;
984 char *full_name ;
985 struct property *properties ;
986 struct property *deadprops ;
987 struct device_node *parent ;
988 struct device_node *child ;
989 struct device_node *sibling ;
990 struct device_node *next ;
991 struct device_node *allnext ;
992 struct proc_dir_entry *pde ;
993 struct kref kref ;
994 unsigned long _flags ;
995 void *data ;
996};
997#line 44 "include/asm-generic/gpio.h"
998struct device;
999#line 47
1000struct module;
1001#line 48
1002struct device_node;
1003#line 32 "include/linux/irq.h"
1004struct module;
1005#line 12 "include/linux/irqdesc.h"
1006struct proc_dir_entry;
1007#line 14
1008struct module;
1009#line 16 "include/linux/profile.h"
1010struct proc_dir_entry;
1011#line 65
1012struct task_struct;
1013#line 132 "include/linux/hardirq.h"
1014struct task_struct;
1015#line 187 "include/linux/interrupt.h"
1016struct device;
1017#line 18 "include/linux/regmap.h"
1018struct module;
1019#line 19
1020struct device;
1021#line 22
1022struct regmap;
1023#line 22
1024struct regmap;
1025#line 355 "include/linux/mfd/wm831x/core.h"
1026struct wm831x;
1027#line 355
1028struct wm831x;
1029#line 356
1030enum wm831x_auxadc;
1031#line 356
1032enum wm831x_auxadc;
1033#line 361 "include/linux/mfd/wm831x/core.h"
1034struct wm831x {
1035 struct mutex io_lock ;
1036 struct device *dev ;
1037 struct regmap *regmap ;
1038 int irq ;
1039 struct mutex irq_lock ;
1040 int irq_base ;
1041 int irq_masks_cur[5] ;
1042 int irq_masks_cache[5] ;
1043 bool soft_shutdown ;
1044 unsigned int has_gpio_ena : 1 ;
1045 unsigned int has_cs_sts : 1 ;
1046 unsigned int charger_irq_wake : 1 ;
1047 int num_gpio ;
1048 int gpio_update[16] ;
1049 bool gpio_level[16] ;
1050 struct mutex auxadc_lock ;
1051 struct list_head auxadc_pending ;
1052 u16 auxadc_active ;
1053 int (*auxadc_read)(struct wm831x *wm831x , enum wm831x_auxadc input ) ;
1054 struct mutex key_lock ;
1055 unsigned int locked : 1 ;
1056};
1057#line 18 "include/linux/mfd/wm831x/pdata.h"
1058struct wm831x;
1059#line 19
1060struct regulator_init_data;
1061#line 19
1062struct regulator_init_data;
1063#line 21 "include/linux/mfd/wm831x/pdata.h"
1064struct wm831x_backlight_pdata {
1065 int isink ;
1066 int max_uA ;
1067};
1068#line 26 "include/linux/mfd/wm831x/pdata.h"
1069struct wm831x_backup_pdata {
1070 int charger_enable ;
1071 int no_constant_voltage ;
1072 int vlim ;
1073 int ilim ;
1074};
1075#line 33 "include/linux/mfd/wm831x/pdata.h"
1076struct wm831x_battery_pdata {
1077 int enable ;
1078 int fast_enable ;
1079 int off_mask ;
1080 int trickle_ilim ;
1081 int vsel ;
1082 int eoc_iterm ;
1083 int fast_ilim ;
1084 int timeout ;
1085};
1086#line 64
1087enum wm831x_status_src {
1088 WM831X_STATUS_PRESERVE = 0,
1089 WM831X_STATUS_OTP = 1,
1090 WM831X_STATUS_POWER = 2,
1091 WM831X_STATUS_CHARGER = 3,
1092 WM831X_STATUS_MANUAL = 4
1093} ;
1094#line 72 "include/linux/mfd/wm831x/pdata.h"
1095struct wm831x_status_pdata {
1096 enum wm831x_status_src default_src ;
1097 char const *name ;
1098 char const *default_trigger ;
1099};
1100#line 78 "include/linux/mfd/wm831x/pdata.h"
1101struct wm831x_touch_pdata {
1102 int fivewire ;
1103 int isel ;
1104 int rpu ;
1105 int pressure ;
1106 unsigned int data_irq ;
1107 int data_irqf ;
1108 unsigned int pd_irq ;
1109 int pd_irqf ;
1110};
1111#line 89
1112enum wm831x_watchdog_action {
1113 WM831X_WDOG_NONE = 0,
1114 WM831X_WDOG_INTERRUPT = 1,
1115 WM831X_WDOG_RESET = 2,
1116 WM831X_WDOG_WAKE = 3
1117} ;
1118#line 96 "include/linux/mfd/wm831x/pdata.h"
1119struct wm831x_watchdog_pdata {
1120 enum wm831x_watchdog_action primary ;
1121 enum wm831x_watchdog_action secondary ;
1122 int update_gpio ;
1123 unsigned int software : 1 ;
1124};
1125#line 111 "include/linux/mfd/wm831x/pdata.h"
1126struct wm831x_pdata {
1127 int wm831x_num ;
1128 int (*pre_init)(struct wm831x *wm831x ) ;
1129 int (*post_init)(struct wm831x *wm831x ) ;
1130 bool irq_cmos ;
1131 bool disable_touch ;
1132 bool soft_shutdown ;
1133 int irq_base ;
1134 int gpio_base ;
1135 int gpio_defaults[16] ;
1136 struct wm831x_backlight_pdata *backlight ;
1137 struct wm831x_backup_pdata *backup ;
1138 struct wm831x_battery_pdata *battery ;
1139 struct wm831x_touch_pdata *touch ;
1140 struct wm831x_watchdog_pdata *watchdog ;
1141 struct wm831x_status_pdata *status[2] ;
1142 struct regulator_init_data *dcdc[4] ;
1143 struct regulator_init_data *epe[2] ;
1144 struct regulator_init_data *ldo[11] ;
1145 struct regulator_init_data *isink[2] ;
1146};
1147#line 32 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/16432/dscv_tempdir/dscv/ri/32_1/drivers/watchdog/wm831x_wdt.c.common.c"
1148struct wm831x_wdt_drvdata {
1149 struct watchdog_device wdt ;
1150 struct wm831x *wm831x ;
1151 struct mutex lock ;
1152 int update_gpio ;
1153 int update_state ;
1154};
1155#line 42 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/16432/dscv_tempdir/dscv/ri/32_1/drivers/watchdog/wm831x_wdt.c.common.c"
1156struct __anonstruct_wm831x_wdt_cfgs_212 {
1157 unsigned int time ;
1158 u16 val ;
1159};
1160#line 150 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/16432/dscv_tempdir/dscv/ri/32_1/drivers/watchdog/wm831x_wdt.c.common.c"
1161struct __anonstruct_213 {
1162 int : 0 ;
1163};
1164#line 153 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/16432/dscv_tempdir/dscv/ri/32_1/drivers/watchdog/wm831x_wdt.c.common.c"
1165struct __anonstruct_214 {
1166 int : 0 ;
1167};
1168#line 225 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/16432/dscv_tempdir/dscv/ri/32_1/drivers/watchdog/wm831x_wdt.c.common.c"
1169struct __anonstruct_215 {
1170 int : 0 ;
1171};
1172#line 228 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/16432/dscv_tempdir/dscv/ri/32_1/drivers/watchdog/wm831x_wdt.c.common.c"
1173struct __anonstruct_216 {
1174 int : 0 ;
1175};
1176#line 1 "<compiler builtins>"
1177long __builtin_expect(long val , long res ) ;
1178#line 59 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/bitops.h"
1179__inline static void ( __attribute__((__always_inline__)) set_bit)(unsigned int nr ,
1180 unsigned long volatile *addr ) __attribute__((__no_instrument_function__)) ;
1181#line 59 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/bitops.h"
1182__inline static void ( __attribute__((__always_inline__)) set_bit)(unsigned int nr ,
1183 unsigned long volatile *addr )
1184{ long volatile *__cil_tmp3 ;
1185
1186 {
1187#line 68
1188 __cil_tmp3 = (long volatile *)addr;
1189#line 68
1190 __asm__ volatile (".section .smp_locks,\"a\"\n"
1191 ".balign 4\n"
1192 ".long 671f - .\n"
1193 ".previous\n"
1194 "671:"
1195 "\n\tlock; "
1196 "bts %1,%0": "+m" (*__cil_tmp3): "Ir" (nr): "memory");
1197#line 71
1198 return;
1199}
1200}
1201#line 115 "include/linux/mutex.h"
1202extern void __mutex_init(struct mutex *lock , char const *name , struct lock_class_key *key ) ;
1203#line 152
1204void mutex_lock(struct mutex *lock ) ;
1205#line 153
1206int __attribute__((__warn_unused_result__)) mutex_lock_interruptible(struct mutex *lock ) ;
1207#line 154
1208int __attribute__((__warn_unused_result__)) mutex_lock_killable(struct mutex *lock ) ;
1209#line 168
1210int mutex_trylock(struct mutex *lock ) ;
1211#line 169
1212void mutex_unlock(struct mutex *lock ) ;
1213#line 170
1214int atomic_dec_and_mutex_lock(atomic_t *cnt , struct mutex *lock ) ;
1215#line 382 "include/linux/moduleparam.h"
1216extern struct kernel_param_ops param_ops_bool ;
1217#line 26 "include/linux/export.h"
1218extern struct module __this_module ;
1219#line 67 "include/linux/module.h"
1220int init_module(void) ;
1221#line 68
1222void cleanup_module(void) ;
1223#line 553 "include/linux/device.h"
1224extern void *devm_kzalloc(struct device *dev , size_t size , gfp_t gfp ) ;
1225#line 792
1226extern void *dev_get_drvdata(struct device const *dev ) ;
1227#line 793
1228extern int dev_set_drvdata(struct device *dev , void *data ) ;
1229#line 891
1230extern int ( dev_err)(struct device const *dev , char const *fmt
1231 , ...) ;
1232#line 893
1233extern int ( dev_warn)(struct device const *dev , char const *fmt
1234 , ...) ;
1235#line 174 "include/linux/platform_device.h"
1236extern int platform_driver_register(struct platform_driver * ) ;
1237#line 175
1238extern void platform_driver_unregister(struct platform_driver * ) ;
1239#line 132 "include/linux/watchdog.h"
1240__inline static void watchdog_set_nowayout(struct watchdog_device *wdd , bool nowayout ) __attribute__((__no_instrument_function__)) ;
1241#line 132 "include/linux/watchdog.h"
1242__inline static void watchdog_set_nowayout(struct watchdog_device *wdd , bool nowayout )
1243{ unsigned long __cil_tmp3 ;
1244 unsigned long __cil_tmp4 ;
1245 unsigned long *__cil_tmp5 ;
1246 unsigned long volatile *__cil_tmp6 ;
1247
1248 {
1249#line 134
1250 if (nowayout) {
1251 {
1252#line 135
1253 __cil_tmp3 = (unsigned long )wdd;
1254#line 135
1255 __cil_tmp4 = __cil_tmp3 + 40;
1256#line 135
1257 __cil_tmp5 = (unsigned long *)__cil_tmp4;
1258#line 135
1259 __cil_tmp6 = (unsigned long volatile *)__cil_tmp5;
1260#line 135
1261 set_bit(3U, __cil_tmp6);
1262 }
1263 } else {
1264
1265 }
1266#line 136
1267 return;
1268}
1269}
1270#line 139
1271__inline static void watchdog_set_drvdata(struct watchdog_device *wdd , void *data ) __attribute__((__no_instrument_function__)) ;
1272#line 139 "include/linux/watchdog.h"
1273__inline static void watchdog_set_drvdata(struct watchdog_device *wdd , void *data )
1274{ unsigned long __cil_tmp3 ;
1275 unsigned long __cil_tmp4 ;
1276
1277 {
1278#line 141
1279 __cil_tmp3 = (unsigned long )wdd;
1280#line 141
1281 __cil_tmp4 = __cil_tmp3 + 32;
1282#line 141
1283 *((void **)__cil_tmp4) = data;
1284#line 142
1285 return;
1286}
1287}
1288#line 144
1289__inline static void *watchdog_get_drvdata(struct watchdog_device *wdd ) __attribute__((__no_instrument_function__)) ;
1290#line 144 "include/linux/watchdog.h"
1291__inline static void *watchdog_get_drvdata(struct watchdog_device *wdd )
1292{ unsigned long __cil_tmp2 ;
1293 unsigned long __cil_tmp3 ;
1294
1295 {
1296 {
1297#line 146
1298 __cil_tmp2 = (unsigned long )wdd;
1299#line 146
1300 __cil_tmp3 = __cil_tmp2 + 32;
1301#line 146
1302 return (*((void **)__cil_tmp3));
1303 }
1304}
1305}
1306#line 150
1307extern int watchdog_register_device(struct watchdog_device * ) ;
1308#line 151
1309extern void watchdog_unregister_device(struct watchdog_device * ) ;
1310#line 153 "include/asm-generic/gpio.h"
1311extern int gpio_request(unsigned int gpio , char const *label ) ;
1312#line 154
1313extern void gpio_free(unsigned int gpio ) ;
1314#line 157
1315extern int gpio_direction_output(unsigned int gpio , int value ) ;
1316#line 162
1317extern void gpio_set_value_cansleep(unsigned int gpio , int value ) ;
1318#line 402 "include/linux/mfd/wm831x/core.h"
1319extern int wm831x_reg_read(struct wm831x *wm831x , unsigned short reg ) ;
1320#line 403
1321extern int wm831x_reg_write(struct wm831x *wm831x , unsigned short reg , unsigned short val ) ;
1322#line 405
1323extern void wm831x_reg_lock(struct wm831x *wm831x ) ;
1324#line 406
1325extern int wm831x_reg_unlock(struct wm831x *wm831x ) ;
1326#line 407
1327extern int wm831x_set_bits(struct wm831x *wm831x , unsigned short reg , unsigned short mask ,
1328 unsigned short val ) ;
1329#line 26 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/16432/dscv_tempdir/dscv/ri/32_1/drivers/watchdog/wm831x_wdt.c.common.c"
1330static bool nowayout = (bool )1;
1331#line 27 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/16432/dscv_tempdir/dscv/ri/32_1/drivers/watchdog/wm831x_wdt.c.common.c"
1332static char const __param_str_nowayout[9] =
1333#line 27
1334 { (char const )'n', (char const )'o', (char const )'w', (char const )'a',
1335 (char const )'y', (char const )'o', (char const )'u', (char const )'t',
1336 (char const )'\000'};
1337#line 27 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/16432/dscv_tempdir/dscv/ri/32_1/drivers/watchdog/wm831x_wdt.c.common.c"
1338static struct kernel_param const __param_nowayout __attribute__((__used__, __unused__,
1339__section__("__param"), __aligned__(sizeof(void *)))) = {__param_str_nowayout, (struct kernel_param_ops const *)(& param_ops_bool), (u16 )0,
1340 (s16 )0, {(void *)(& nowayout)}};
1341#line 27 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/16432/dscv_tempdir/dscv/ri/32_1/drivers/watchdog/wm831x_wdt.c.common.c"
1342static char const __mod_nowayouttype27[23] __attribute__((__used__, __unused__,
1343__section__(".modinfo"), __aligned__(1))) =
1344#line 27
1345 { (char const )'p', (char const )'a', (char const )'r', (char const )'m',
1346 (char const )'t', (char const )'y', (char const )'p', (char const )'e',
1347 (char const )'=', (char const )'n', (char const )'o', (char const )'w',
1348 (char const )'a', (char const )'y', (char const )'o', (char const )'u',
1349 (char const )'t', (char const )':', (char const )'b', (char const )'o',
1350 (char const )'o', (char const )'l', (char const )'\000'};
1351#line 28 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/16432/dscv_tempdir/dscv/ri/32_1/drivers/watchdog/wm831x_wdt.c.common.c"
1352static char const __mod_nowayout30[66] __attribute__((__used__, __unused__, __section__(".modinfo"),
1353__aligned__(1))) =
1354#line 28
1355 { (char const )'p', (char const )'a', (char const )'r', (char const )'m',
1356 (char const )'=', (char const )'n', (char const )'o', (char const )'w',
1357 (char const )'a', (char const )'y', (char const )'o', (char const )'u',
1358 (char const )'t', (char const )':', (char const )'W', (char const )'a',
1359 (char const )'t', (char const )'c', (char const )'h', (char const )'d',
1360 (char const )'o', (char const )'g', (char const )' ', (char const )'c',
1361 (char const )'a', (char const )'n', (char const )'n', (char const )'o',
1362 (char const )'t', (char const )' ', (char const )'b', (char const )'e',
1363 (char const )' ', (char const )'s', (char const )'t', (char const )'o',
1364 (char const )'p', (char const )'p', (char const )'e', (char const )'d',
1365 (char const )' ', (char const )'o', (char const )'n', (char const )'c',
1366 (char const )'e', (char const )' ', (char const )'s', (char const )'t',
1367 (char const )'a', (char const )'r', (char const )'t', (char const )'e',
1368 (char const )'d', (char const )' ', (char const )'(', (char const )'d',
1369 (char const )'e', (char const )'f', (char const )'a', (char const )'u',
1370 (char const )'l', (char const )'t', (char const )'=', (char const )'1',
1371 (char const )')', (char const )'\000'};
1372#line 42 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/16432/dscv_tempdir/dscv/ri/32_1/drivers/watchdog/wm831x_wdt.c.common.c"
1373static struct __anonstruct_wm831x_wdt_cfgs_212 wm831x_wdt_cfgs[7] = { {1U, (u16 )2},
1374 {2U, (u16 )3},
1375 {4U, (u16 )4},
1376 {8U, (u16 )5},
1377 {16U, (u16 )6},
1378 {32U, (u16 )7},
1379 {33U, (u16 )7}};
1380#line 55 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/16432/dscv_tempdir/dscv/ri/32_1/drivers/watchdog/wm831x_wdt.c.common.c"
1381static int wm831x_wdt_start(struct watchdog_device *wdt_dev )
1382{ struct wm831x_wdt_drvdata *driver_data ;
1383 void *tmp ;
1384 struct wm831x *wm831x ;
1385 int ret ;
1386 unsigned long __cil_tmp6 ;
1387 unsigned long __cil_tmp7 ;
1388 unsigned long __cil_tmp8 ;
1389 unsigned long __cil_tmp9 ;
1390 struct mutex *__cil_tmp10 ;
1391 unsigned long __cil_tmp11 ;
1392 unsigned long __cil_tmp12 ;
1393 struct device *__cil_tmp13 ;
1394 struct device const *__cil_tmp14 ;
1395 unsigned long __cil_tmp15 ;
1396 unsigned long __cil_tmp16 ;
1397 struct mutex *__cil_tmp17 ;
1398
1399 {
1400 {
1401#line 57
1402 tmp = watchdog_get_drvdata(wdt_dev);
1403#line 57
1404 driver_data = (struct wm831x_wdt_drvdata *)tmp;
1405#line 58
1406 __cil_tmp6 = (unsigned long )driver_data;
1407#line 58
1408 __cil_tmp7 = __cil_tmp6 + 48;
1409#line 58
1410 wm831x = *((struct wm831x **)__cil_tmp7);
1411#line 61
1412 __cil_tmp8 = (unsigned long )driver_data;
1413#line 61
1414 __cil_tmp9 = __cil_tmp8 + 56;
1415#line 61
1416 __cil_tmp10 = (struct mutex *)__cil_tmp9;
1417#line 61
1418 mutex_lock(__cil_tmp10);
1419#line 63
1420 ret = wm831x_reg_unlock(wm831x);
1421 }
1422#line 64
1423 if (ret == 0) {
1424 {
1425#line 65
1426 ret = wm831x_set_bits(wm831x, (unsigned short)16388, (unsigned short)32768, (unsigned short)32768);
1427#line 67
1428 wm831x_reg_lock(wm831x);
1429 }
1430 } else {
1431 {
1432#line 69
1433 __cil_tmp11 = (unsigned long )wm831x;
1434#line 69
1435 __cil_tmp12 = __cil_tmp11 + 72;
1436#line 69
1437 __cil_tmp13 = *((struct device **)__cil_tmp12);
1438#line 69
1439 __cil_tmp14 = (struct device const *)__cil_tmp13;
1440#line 69
1441 dev_err(__cil_tmp14, "Failed to unlock security key: %d\n", ret);
1442 }
1443 }
1444 {
1445#line 73
1446 __cil_tmp15 = (unsigned long )driver_data;
1447#line 73
1448 __cil_tmp16 = __cil_tmp15 + 56;
1449#line 73
1450 __cil_tmp17 = (struct mutex *)__cil_tmp16;
1451#line 73
1452 mutex_unlock(__cil_tmp17);
1453 }
1454#line 75
1455 return (ret);
1456}
1457}
1458#line 78 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/16432/dscv_tempdir/dscv/ri/32_1/drivers/watchdog/wm831x_wdt.c.common.c"
1459static int wm831x_wdt_stop(struct watchdog_device *wdt_dev )
1460{ struct wm831x_wdt_drvdata *driver_data ;
1461 void *tmp ;
1462 struct wm831x *wm831x ;
1463 int ret ;
1464 unsigned long __cil_tmp6 ;
1465 unsigned long __cil_tmp7 ;
1466 unsigned long __cil_tmp8 ;
1467 unsigned long __cil_tmp9 ;
1468 struct mutex *__cil_tmp10 ;
1469 unsigned long __cil_tmp11 ;
1470 unsigned long __cil_tmp12 ;
1471 struct device *__cil_tmp13 ;
1472 struct device const *__cil_tmp14 ;
1473 unsigned long __cil_tmp15 ;
1474 unsigned long __cil_tmp16 ;
1475 struct mutex *__cil_tmp17 ;
1476
1477 {
1478 {
1479#line 80
1480 tmp = watchdog_get_drvdata(wdt_dev);
1481#line 80
1482 driver_data = (struct wm831x_wdt_drvdata *)tmp;
1483#line 81
1484 __cil_tmp6 = (unsigned long )driver_data;
1485#line 81
1486 __cil_tmp7 = __cil_tmp6 + 48;
1487#line 81
1488 wm831x = *((struct wm831x **)__cil_tmp7);
1489#line 84
1490 __cil_tmp8 = (unsigned long )driver_data;
1491#line 84
1492 __cil_tmp9 = __cil_tmp8 + 56;
1493#line 84
1494 __cil_tmp10 = (struct mutex *)__cil_tmp9;
1495#line 84
1496 mutex_lock(__cil_tmp10);
1497#line 86
1498 ret = wm831x_reg_unlock(wm831x);
1499 }
1500#line 87
1501 if (ret == 0) {
1502 {
1503#line 88
1504 ret = wm831x_set_bits(wm831x, (unsigned short)16388, (unsigned short)32768, (unsigned short)0);
1505#line 90
1506 wm831x_reg_lock(wm831x);
1507 }
1508 } else {
1509 {
1510#line 92
1511 __cil_tmp11 = (unsigned long )wm831x;
1512#line 92
1513 __cil_tmp12 = __cil_tmp11 + 72;
1514#line 92
1515 __cil_tmp13 = *((struct device **)__cil_tmp12);
1516#line 92
1517 __cil_tmp14 = (struct device const *)__cil_tmp13;
1518#line 92
1519 dev_err(__cil_tmp14, "Failed to unlock security key: %d\n", ret);
1520 }
1521 }
1522 {
1523#line 96
1524 __cil_tmp15 = (unsigned long )driver_data;
1525#line 96
1526 __cil_tmp16 = __cil_tmp15 + 56;
1527#line 96
1528 __cil_tmp17 = (struct mutex *)__cil_tmp16;
1529#line 96
1530 mutex_unlock(__cil_tmp17);
1531 }
1532#line 98
1533 return (ret);
1534}
1535}
1536#line 101 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/16432/dscv_tempdir/dscv/ri/32_1/drivers/watchdog/wm831x_wdt.c.common.c"
1537static int wm831x_wdt_ping(struct watchdog_device *wdt_dev )
1538{ struct wm831x_wdt_drvdata *driver_data ;
1539 void *tmp ;
1540 struct wm831x *wm831x ;
1541 int ret ;
1542 u16 reg ;
1543 int tmp___0 ;
1544 unsigned long __cil_tmp8 ;
1545 unsigned long __cil_tmp9 ;
1546 unsigned long __cil_tmp10 ;
1547 unsigned long __cil_tmp11 ;
1548 struct mutex *__cil_tmp12 ;
1549 unsigned long __cil_tmp13 ;
1550 unsigned long __cil_tmp14 ;
1551 unsigned long __cil_tmp15 ;
1552 unsigned long __cil_tmp16 ;
1553 int __cil_tmp17 ;
1554 unsigned int __cil_tmp18 ;
1555 unsigned long __cil_tmp19 ;
1556 unsigned long __cil_tmp20 ;
1557 int __cil_tmp21 ;
1558 unsigned long __cil_tmp22 ;
1559 unsigned long __cil_tmp23 ;
1560 unsigned long __cil_tmp24 ;
1561 unsigned long __cil_tmp25 ;
1562 int __cil_tmp26 ;
1563 int __cil_tmp27 ;
1564 int __cil_tmp28 ;
1565 unsigned long __cil_tmp29 ;
1566 unsigned long __cil_tmp30 ;
1567 struct device *__cil_tmp31 ;
1568 struct device const *__cil_tmp32 ;
1569 int __cil_tmp33 ;
1570 int __cil_tmp34 ;
1571 unsigned long __cil_tmp35 ;
1572 unsigned long __cil_tmp36 ;
1573 struct device *__cil_tmp37 ;
1574 struct device const *__cil_tmp38 ;
1575 unsigned long __cil_tmp39 ;
1576 unsigned long __cil_tmp40 ;
1577 struct mutex *__cil_tmp41 ;
1578
1579 {
1580 {
1581#line 103
1582 tmp = watchdog_get_drvdata(wdt_dev);
1583#line 103
1584 driver_data = (struct wm831x_wdt_drvdata *)tmp;
1585#line 104
1586 __cil_tmp8 = (unsigned long )driver_data;
1587#line 104
1588 __cil_tmp9 = __cil_tmp8 + 48;
1589#line 104
1590 wm831x = *((struct wm831x **)__cil_tmp9);
1591#line 108
1592 __cil_tmp10 = (unsigned long )driver_data;
1593#line 108
1594 __cil_tmp11 = __cil_tmp10 + 56;
1595#line 108
1596 __cil_tmp12 = (struct mutex *)__cil_tmp11;
1597#line 108
1598 mutex_lock(__cil_tmp12);
1599 }
1600 {
1601#line 110
1602 __cil_tmp13 = (unsigned long )driver_data;
1603#line 110
1604 __cil_tmp14 = __cil_tmp13 + 128;
1605#line 110
1606 if (*((int *)__cil_tmp14)) {
1607 {
1608#line 111
1609 __cil_tmp15 = (unsigned long )driver_data;
1610#line 111
1611 __cil_tmp16 = __cil_tmp15 + 128;
1612#line 111
1613 __cil_tmp17 = *((int *)__cil_tmp16);
1614#line 111
1615 __cil_tmp18 = (unsigned int )__cil_tmp17;
1616#line 111
1617 __cil_tmp19 = (unsigned long )driver_data;
1618#line 111
1619 __cil_tmp20 = __cil_tmp19 + 132;
1620#line 111
1621 __cil_tmp21 = *((int *)__cil_tmp20);
1622#line 111
1623 gpio_set_value_cansleep(__cil_tmp18, __cil_tmp21);
1624#line 113
1625 __cil_tmp22 = (unsigned long )driver_data;
1626#line 113
1627 __cil_tmp23 = __cil_tmp22 + 132;
1628#line 113
1629 __cil_tmp24 = (unsigned long )driver_data;
1630#line 113
1631 __cil_tmp25 = __cil_tmp24 + 132;
1632#line 113
1633 __cil_tmp26 = *((int *)__cil_tmp25);
1634#line 113
1635 *((int *)__cil_tmp23) = ! __cil_tmp26;
1636#line 114
1637 ret = 0;
1638 }
1639#line 115
1640 goto out;
1641 } else {
1642
1643 }
1644 }
1645 {
1646#line 118
1647 tmp___0 = wm831x_reg_read(wm831x, (unsigned short)16388);
1648#line 118
1649 reg = (u16 )tmp___0;
1650 }
1651 {
1652#line 120
1653 __cil_tmp27 = (int )reg;
1654#line 120
1655 __cil_tmp28 = __cil_tmp27 & 8192;
1656#line 120
1657 if (! __cil_tmp28) {
1658 {
1659#line 121
1660 __cil_tmp29 = (unsigned long )wm831x;
1661#line 121
1662 __cil_tmp30 = __cil_tmp29 + 72;
1663#line 121
1664 __cil_tmp31 = *((struct device **)__cil_tmp30);
1665#line 121
1666 __cil_tmp32 = (struct device const *)__cil_tmp31;
1667#line 121
1668 dev_err(__cil_tmp32, "Hardware watchdog update unsupported\n");
1669#line 122
1670 ret = -22;
1671 }
1672#line 123
1673 goto out;
1674 } else {
1675
1676 }
1677 }
1678 {
1679#line 126
1680 __cil_tmp33 = (int )reg;
1681#line 126
1682 __cil_tmp34 = __cil_tmp33 | 2048;
1683#line 126
1684 reg = (u16 )__cil_tmp34;
1685#line 128
1686 ret = wm831x_reg_unlock(wm831x);
1687 }
1688#line 129
1689 if (ret == 0) {
1690 {
1691#line 130
1692 ret = wm831x_reg_write(wm831x, (unsigned short)16388, reg);
1693#line 131
1694 wm831x_reg_lock(wm831x);
1695 }
1696 } else {
1697 {
1698#line 133
1699 __cil_tmp35 = (unsigned long )wm831x;
1700#line 133
1701 __cil_tmp36 = __cil_tmp35 + 72;
1702#line 133
1703 __cil_tmp37 = *((struct device **)__cil_tmp36);
1704#line 133
1705 __cil_tmp38 = (struct device const *)__cil_tmp37;
1706#line 133
1707 dev_err(__cil_tmp38, "Failed to unlock security key: %d\n", ret);
1708 }
1709 }
1710 out:
1711 {
1712#line 138
1713 __cil_tmp39 = (unsigned long )driver_data;
1714#line 138
1715 __cil_tmp40 = __cil_tmp39 + 56;
1716#line 138
1717 __cil_tmp41 = (struct mutex *)__cil_tmp40;
1718#line 138
1719 mutex_unlock(__cil_tmp41);
1720 }
1721#line 140
1722 return (ret);
1723}
1724}
1725#line 143 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/16432/dscv_tempdir/dscv/ri/32_1/drivers/watchdog/wm831x_wdt.c.common.c"
1726static int wm831x_wdt_set_timeout(struct watchdog_device *wdt_dev , unsigned int timeout )
1727{ struct wm831x_wdt_drvdata *driver_data ;
1728 void *tmp ;
1729 struct wm831x *wm831x ;
1730 int ret ;
1731 int i ;
1732 unsigned long __cil_tmp8 ;
1733 unsigned long __cil_tmp9 ;
1734 unsigned long __cil_tmp10 ;
1735 unsigned long __cil_tmp11 ;
1736 unsigned long __cil_tmp12 ;
1737 unsigned long __cil_tmp13 ;
1738 unsigned long __cil_tmp14 ;
1739 unsigned int __cil_tmp15 ;
1740 unsigned long __cil_tmp16 ;
1741 unsigned long __cil_tmp17 ;
1742 unsigned long __cil_tmp18 ;
1743 unsigned long __cil_tmp19 ;
1744 unsigned long __cil_tmp20 ;
1745 unsigned long __cil_tmp21 ;
1746 u16 __cil_tmp22 ;
1747 unsigned long __cil_tmp23 ;
1748 unsigned long __cil_tmp24 ;
1749 struct device *__cil_tmp25 ;
1750 struct device const *__cil_tmp26 ;
1751 unsigned long __cil_tmp27 ;
1752 unsigned long __cil_tmp28 ;
1753
1754 {
1755 {
1756#line 146
1757 tmp = watchdog_get_drvdata(wdt_dev);
1758#line 146
1759 driver_data = (struct wm831x_wdt_drvdata *)tmp;
1760#line 147
1761 __cil_tmp8 = (unsigned long )driver_data;
1762#line 147
1763 __cil_tmp9 = __cil_tmp8 + 48;
1764#line 147
1765 wm831x = *((struct wm831x **)__cil_tmp9);
1766#line 150
1767 i = 0;
1768 }
1769 {
1770#line 150
1771 while (1) {
1772 while_continue: ;
1773 {
1774#line 150
1775 __cil_tmp10 = 56UL / 8UL;
1776#line 150
1777 __cil_tmp11 = __cil_tmp10 + 0UL;
1778#line 150
1779 __cil_tmp12 = (unsigned long )i;
1780#line 150
1781 if (__cil_tmp12 < __cil_tmp11) {
1782
1783 } else {
1784#line 150
1785 goto while_break;
1786 }
1787 }
1788 {
1789#line 151
1790 __cil_tmp13 = i * 8UL;
1791#line 151
1792 __cil_tmp14 = (unsigned long )(wm831x_wdt_cfgs) + __cil_tmp13;
1793#line 151
1794 __cil_tmp15 = *((unsigned int *)__cil_tmp14);
1795#line 151
1796 if (__cil_tmp15 == timeout) {
1797#line 152
1798 goto while_break;
1799 } else {
1800
1801 }
1802 }
1803#line 150
1804 i = i + 1;
1805 }
1806 while_break: ;
1807 }
1808 {
1809#line 153
1810 __cil_tmp16 = 56UL / 8UL;
1811#line 153
1812 __cil_tmp17 = __cil_tmp16 + 0UL;
1813#line 153
1814 __cil_tmp18 = (unsigned long )i;
1815#line 153
1816 if (__cil_tmp18 == __cil_tmp17) {
1817#line 154
1818 return (-22);
1819 } else {
1820
1821 }
1822 }
1823 {
1824#line 156
1825 ret = wm831x_reg_unlock(wm831x);
1826 }
1827#line 157
1828 if (ret == 0) {
1829 {
1830#line 158
1831 __cil_tmp19 = i * 8UL;
1832#line 158
1833 __cil_tmp20 = __cil_tmp19 + 4;
1834#line 158
1835 __cil_tmp21 = (unsigned long )(wm831x_wdt_cfgs) + __cil_tmp20;
1836#line 158
1837 __cil_tmp22 = *((u16 *)__cil_tmp21);
1838#line 158
1839 ret = wm831x_set_bits(wm831x, (unsigned short)16388, (unsigned short)7, __cil_tmp22);
1840#line 161
1841 wm831x_reg_lock(wm831x);
1842 }
1843 } else {
1844 {
1845#line 163
1846 __cil_tmp23 = (unsigned long )wm831x;
1847#line 163
1848 __cil_tmp24 = __cil_tmp23 + 72;
1849#line 163
1850 __cil_tmp25 = *((struct device **)__cil_tmp24);
1851#line 163
1852 __cil_tmp26 = (struct device const *)__cil_tmp25;
1853#line 163
1854 dev_err(__cil_tmp26, "Failed to unlock security key: %d\n", ret);
1855 }
1856 }
1857#line 167
1858 __cil_tmp27 = (unsigned long )wdt_dev;
1859#line 167
1860 __cil_tmp28 = __cil_tmp27 + 20;
1861#line 167
1862 *((unsigned int *)__cil_tmp28) = timeout;
1863#line 169
1864 return (ret);
1865}
1866}
1867#line 172 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/16432/dscv_tempdir/dscv/ri/32_1/drivers/watchdog/wm831x_wdt.c.common.c"
1868static struct watchdog_info const wm831x_wdt_info = {(__u32 )33152, 0U, {(__u8 )'W', (__u8 )'M', (__u8 )'8', (__u8 )'3', (__u8 )'1',
1869 (__u8 )'x', (__u8 )' ', (__u8 )'W', (__u8 )'a', (__u8 )'t',
1870 (__u8 )'c', (__u8 )'h', (__u8 )'d', (__u8 )'o', (__u8 )'g',
1871 (__u8 )'\000', (unsigned char)0, (unsigned char)0, (unsigned char)0,
1872 (unsigned char)0, (unsigned char)0, (unsigned char)0, (unsigned char)0,
1873 (unsigned char)0, (unsigned char)0, (unsigned char)0, (unsigned char)0,
1874 (unsigned char)0, (unsigned char)0, (unsigned char)0, (unsigned char)0,
1875 (unsigned char)0}};
1876#line 177 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/16432/dscv_tempdir/dscv/ri/32_1/drivers/watchdog/wm831x_wdt.c.common.c"
1877static struct watchdog_ops const wm831x_wdt_ops =
1878#line 177
1879 {& __this_module, & wm831x_wdt_start, & wm831x_wdt_stop, & wm831x_wdt_ping, (unsigned int (*)(struct watchdog_device * ))0,
1880 & wm831x_wdt_set_timeout, (unsigned int (*)(struct watchdog_device * ))0, (long (*)(struct watchdog_device * ,
1881 unsigned int ,
1882 unsigned long ))0};
1883#line 213 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/16432/dscv_tempdir/dscv/ri/32_1/drivers/watchdog/wm831x_wdt.c.common.c"
1884static struct lock_class_key __key___2 ;
1885#line 185
1886static int wm831x_wdt_probe(struct platform_device *pdev ) __attribute__((__section__(".devinit.text"),
1887__no_instrument_function__)) ;
1888#line 185 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/16432/dscv_tempdir/dscv/ri/32_1/drivers/watchdog/wm831x_wdt.c.common.c"
1889static int wm831x_wdt_probe(struct platform_device *pdev )
1890{ struct wm831x *wm831x ;
1891 void *tmp ;
1892 struct wm831x_pdata *chip_pdata ;
1893 struct wm831x_watchdog_pdata *pdata ;
1894 struct wm831x_wdt_drvdata *driver_data ;
1895 struct watchdog_device *wm831x_wdt ;
1896 int reg ;
1897 int ret ;
1898 int i ;
1899 void *tmp___0 ;
1900 unsigned long __cil_tmp12 ;
1901 unsigned long __cil_tmp13 ;
1902 struct device *__cil_tmp14 ;
1903 struct device const *__cil_tmp15 ;
1904 unsigned long __cil_tmp16 ;
1905 unsigned long __cil_tmp17 ;
1906 struct device *__cil_tmp18 ;
1907 struct device const *__cil_tmp19 ;
1908 unsigned long __cil_tmp20 ;
1909 unsigned long __cil_tmp21 ;
1910 struct device *__cil_tmp22 ;
1911 struct device const *__cil_tmp23 ;
1912 unsigned long __cil_tmp24 ;
1913 unsigned long __cil_tmp25 ;
1914 struct device *__cil_tmp26 ;
1915 unsigned long __cil_tmp27 ;
1916 unsigned long __cil_tmp28 ;
1917 struct device *__cil_tmp29 ;
1918 struct device const *__cil_tmp30 ;
1919 unsigned long __cil_tmp31 ;
1920 unsigned long __cil_tmp32 ;
1921 struct mutex *__cil_tmp33 ;
1922 unsigned long __cil_tmp34 ;
1923 unsigned long __cil_tmp35 ;
1924 unsigned long __cil_tmp36 ;
1925 unsigned long __cil_tmp37 ;
1926 bool *__cil_tmp38 ;
1927 bool __cil_tmp39 ;
1928 void *__cil_tmp40 ;
1929 unsigned long __cil_tmp41 ;
1930 unsigned long __cil_tmp42 ;
1931 unsigned long __cil_tmp43 ;
1932 unsigned long __cil_tmp44 ;
1933 unsigned long __cil_tmp45 ;
1934 unsigned long __cil_tmp46 ;
1935 u16 __cil_tmp47 ;
1936 int __cil_tmp48 ;
1937 unsigned long __cil_tmp49 ;
1938 unsigned long __cil_tmp50 ;
1939 unsigned long __cil_tmp51 ;
1940 unsigned long __cil_tmp52 ;
1941 unsigned long __cil_tmp53 ;
1942 struct device *__cil_tmp54 ;
1943 struct device const *__cil_tmp55 ;
1944 unsigned long __cil_tmp56 ;
1945 unsigned long __cil_tmp57 ;
1946 unsigned long __cil_tmp58 ;
1947 unsigned long __cil_tmp59 ;
1948 unsigned long __cil_tmp60 ;
1949 unsigned long __cil_tmp61 ;
1950 struct device *__cil_tmp62 ;
1951 unsigned long __cil_tmp63 ;
1952 unsigned long __cil_tmp64 ;
1953 unsigned long __cil_tmp65 ;
1954 unsigned long __cil_tmp66 ;
1955 struct device *__cil_tmp67 ;
1956 unsigned long __cil_tmp68 ;
1957 unsigned long __cil_tmp69 ;
1958 void *__cil_tmp70 ;
1959 unsigned long __cil_tmp71 ;
1960 unsigned long __cil_tmp72 ;
1961 void *__cil_tmp73 ;
1962 enum wm831x_watchdog_action __cil_tmp74 ;
1963 unsigned int __cil_tmp75 ;
1964 unsigned int __cil_tmp76 ;
1965 unsigned int __cil_tmp77 ;
1966 unsigned int __cil_tmp78 ;
1967 unsigned long __cil_tmp79 ;
1968 unsigned long __cil_tmp80 ;
1969 enum wm831x_watchdog_action __cil_tmp81 ;
1970 unsigned int __cil_tmp82 ;
1971 unsigned int __cil_tmp83 ;
1972 unsigned int __cil_tmp84 ;
1973 unsigned int __cil_tmp85 ;
1974 unsigned long __cil_tmp86 ;
1975 unsigned long __cil_tmp87 ;
1976 unsigned int __cil_tmp88 ;
1977 unsigned int __cil_tmp89 ;
1978 unsigned int __cil_tmp90 ;
1979 unsigned int __cil_tmp91 ;
1980 unsigned long __cil_tmp92 ;
1981 unsigned long __cil_tmp93 ;
1982 unsigned long __cil_tmp94 ;
1983 unsigned long __cil_tmp95 ;
1984 int __cil_tmp96 ;
1985 unsigned int __cil_tmp97 ;
1986 unsigned long __cil_tmp98 ;
1987 unsigned long __cil_tmp99 ;
1988 struct device *__cil_tmp100 ;
1989 struct device const *__cil_tmp101 ;
1990 unsigned long __cil_tmp102 ;
1991 unsigned long __cil_tmp103 ;
1992 int __cil_tmp104 ;
1993 unsigned int __cil_tmp105 ;
1994 unsigned long __cil_tmp106 ;
1995 unsigned long __cil_tmp107 ;
1996 struct device *__cil_tmp108 ;
1997 struct device const *__cil_tmp109 ;
1998 unsigned long __cil_tmp110 ;
1999 unsigned long __cil_tmp111 ;
2000 unsigned long __cil_tmp112 ;
2001 unsigned long __cil_tmp113 ;
2002 unsigned short __cil_tmp114 ;
2003 unsigned long __cil_tmp115 ;
2004 unsigned long __cil_tmp116 ;
2005 struct device *__cil_tmp117 ;
2006 struct device const *__cil_tmp118 ;
2007 struct watchdog_device *__cil_tmp119 ;
2008 unsigned long __cil_tmp120 ;
2009 unsigned long __cil_tmp121 ;
2010 struct device *__cil_tmp122 ;
2011 struct device const *__cil_tmp123 ;
2012 unsigned long __cil_tmp124 ;
2013 unsigned long __cil_tmp125 ;
2014 struct device *__cil_tmp126 ;
2015 void *__cil_tmp127 ;
2016 unsigned long __cil_tmp128 ;
2017 unsigned long __cil_tmp129 ;
2018 unsigned long __cil_tmp130 ;
2019 unsigned long __cil_tmp131 ;
2020 int __cil_tmp132 ;
2021 unsigned int __cil_tmp133 ;
2022
2023 {
2024 {
2025#line 187
2026 __cil_tmp12 = (unsigned long )pdev;
2027#line 187
2028 __cil_tmp13 = __cil_tmp12 + 16;
2029#line 187
2030 __cil_tmp14 = *((struct device **)__cil_tmp13);
2031#line 187
2032 __cil_tmp15 = (struct device const *)__cil_tmp14;
2033#line 187
2034 tmp = dev_get_drvdata(__cil_tmp15);
2035#line 187
2036 wm831x = (struct wm831x *)tmp;
2037#line 194
2038 ret = wm831x_reg_read(wm831x, (unsigned short)16388);
2039 }
2040#line 195
2041 if (ret < 0) {
2042 {
2043#line 196
2044 __cil_tmp16 = (unsigned long )wm831x;
2045#line 196
2046 __cil_tmp17 = __cil_tmp16 + 72;
2047#line 196
2048 __cil_tmp18 = *((struct device **)__cil_tmp17);
2049#line 196
2050 __cil_tmp19 = (struct device const *)__cil_tmp18;
2051#line 196
2052 dev_err(__cil_tmp19, "Failed to read watchdog status: %d\n", ret);
2053 }
2054#line 198
2055 goto err;
2056 } else {
2057
2058 }
2059#line 200
2060 reg = ret;
2061#line 202
2062 if (reg & 16384) {
2063 {
2064#line 203
2065 __cil_tmp20 = (unsigned long )wm831x;
2066#line 203
2067 __cil_tmp21 = __cil_tmp20 + 72;
2068#line 203
2069 __cil_tmp22 = *((struct device **)__cil_tmp21);
2070#line 203
2071 __cil_tmp23 = (struct device const *)__cil_tmp22;
2072#line 203
2073 dev_warn(__cil_tmp23, "Watchdog is paused\n");
2074 }
2075 } else {
2076
2077 }
2078 {
2079#line 205
2080 __cil_tmp24 = (unsigned long )pdev;
2081#line 205
2082 __cil_tmp25 = __cil_tmp24 + 16;
2083#line 205
2084 __cil_tmp26 = (struct device *)__cil_tmp25;
2085#line 205
2086 tmp___0 = devm_kzalloc(__cil_tmp26, 136UL, 208U);
2087#line 205
2088 driver_data = (struct wm831x_wdt_drvdata *)tmp___0;
2089 }
2090#line 207
2091 if (! driver_data) {
2092 {
2093#line 208
2094 __cil_tmp27 = (unsigned long )wm831x;
2095#line 208
2096 __cil_tmp28 = __cil_tmp27 + 72;
2097#line 208
2098 __cil_tmp29 = *((struct device **)__cil_tmp28);
2099#line 208
2100 __cil_tmp30 = (struct device const *)__cil_tmp29;
2101#line 208
2102 dev_err(__cil_tmp30, "Unable to alloacate watchdog device\n");
2103#line 209
2104 ret = -12;
2105 }
2106#line 210
2107 goto err;
2108 } else {
2109
2110 }
2111 {
2112#line 213
2113 while (1) {
2114 while_continue: ;
2115 {
2116#line 213
2117 __cil_tmp31 = (unsigned long )driver_data;
2118#line 213
2119 __cil_tmp32 = __cil_tmp31 + 56;
2120#line 213
2121 __cil_tmp33 = (struct mutex *)__cil_tmp32;
2122#line 213
2123 __mutex_init(__cil_tmp33, "&driver_data->lock", & __key___2);
2124 }
2125#line 213
2126 goto while_break;
2127 }
2128 while_break: ;
2129 }
2130 {
2131#line 214
2132 __cil_tmp34 = (unsigned long )driver_data;
2133#line 214
2134 __cil_tmp35 = __cil_tmp34 + 48;
2135#line 214
2136 *((struct wm831x **)__cil_tmp35) = wm831x;
2137#line 216
2138 wm831x_wdt = (struct watchdog_device *)driver_data;
2139#line 218
2140 *((struct watchdog_info const **)wm831x_wdt) = & wm831x_wdt_info;
2141#line 219
2142 __cil_tmp36 = (unsigned long )wm831x_wdt;
2143#line 219
2144 __cil_tmp37 = __cil_tmp36 + 8;
2145#line 219
2146 *((struct watchdog_ops const **)__cil_tmp37) = & wm831x_wdt_ops;
2147#line 220
2148 __cil_tmp38 = & nowayout;
2149#line 220
2150 __cil_tmp39 = *__cil_tmp38;
2151#line 220
2152 watchdog_set_nowayout(wm831x_wdt, __cil_tmp39);
2153#line 221
2154 __cil_tmp40 = (void *)driver_data;
2155#line 221
2156 watchdog_set_drvdata(wm831x_wdt, __cil_tmp40);
2157#line 223
2158 reg = wm831x_reg_read(wm831x, (unsigned short)16388);
2159#line 224
2160 reg = reg & 7;
2161#line 225
2162 i = 0;
2163 }
2164 {
2165#line 225
2166 while (1) {
2167 while_continue___0: ;
2168 {
2169#line 225
2170 __cil_tmp41 = 56UL / 8UL;
2171#line 225
2172 __cil_tmp42 = __cil_tmp41 + 0UL;
2173#line 225
2174 __cil_tmp43 = (unsigned long )i;
2175#line 225
2176 if (__cil_tmp43 < __cil_tmp42) {
2177
2178 } else {
2179#line 225
2180 goto while_break___0;
2181 }
2182 }
2183 {
2184#line 226
2185 __cil_tmp44 = i * 8UL;
2186#line 226
2187 __cil_tmp45 = __cil_tmp44 + 4;
2188#line 226
2189 __cil_tmp46 = (unsigned long )(wm831x_wdt_cfgs) + __cil_tmp45;
2190#line 226
2191 __cil_tmp47 = *((u16 *)__cil_tmp46);
2192#line 226
2193 __cil_tmp48 = (int )__cil_tmp47;
2194#line 226
2195 if (__cil_tmp48 == reg) {
2196#line 227
2197 goto while_break___0;
2198 } else {
2199
2200 }
2201 }
2202#line 225
2203 i = i + 1;
2204 }
2205 while_break___0: ;
2206 }
2207 {
2208#line 228
2209 __cil_tmp49 = 56UL / 8UL;
2210#line 228
2211 __cil_tmp50 = __cil_tmp49 + 0UL;
2212#line 228
2213 __cil_tmp51 = (unsigned long )i;
2214#line 228
2215 if (__cil_tmp51 == __cil_tmp50) {
2216 {
2217#line 229
2218 __cil_tmp52 = (unsigned long )wm831x;
2219#line 229
2220 __cil_tmp53 = __cil_tmp52 + 72;
2221#line 229
2222 __cil_tmp54 = *((struct device **)__cil_tmp53);
2223#line 229
2224 __cil_tmp55 = (struct device const *)__cil_tmp54;
2225#line 229
2226 dev_warn(__cil_tmp55, "Unknown watchdog timeout: %x\n", reg);
2227 }
2228 } else {
2229#line 232
2230 __cil_tmp56 = (unsigned long )wm831x_wdt;
2231#line 232
2232 __cil_tmp57 = __cil_tmp56 + 20;
2233#line 232
2234 __cil_tmp58 = i * 8UL;
2235#line 232
2236 __cil_tmp59 = (unsigned long )(wm831x_wdt_cfgs) + __cil_tmp58;
2237#line 232
2238 *((unsigned int *)__cil_tmp57) = *((unsigned int *)__cil_tmp59);
2239 }
2240 }
2241 {
2242#line 235
2243 __cil_tmp60 = (unsigned long )pdev;
2244#line 235
2245 __cil_tmp61 = __cil_tmp60 + 16;
2246#line 235
2247 __cil_tmp62 = *((struct device **)__cil_tmp61);
2248#line 235
2249 __cil_tmp63 = (unsigned long )__cil_tmp62;
2250#line 235
2251 __cil_tmp64 = __cil_tmp63 + 184;
2252#line 235
2253 if (*((void **)__cil_tmp64)) {
2254#line 236
2255 __cil_tmp65 = (unsigned long )pdev;
2256#line 236
2257 __cil_tmp66 = __cil_tmp65 + 16;
2258#line 236
2259 __cil_tmp67 = *((struct device **)__cil_tmp66);
2260#line 236
2261 __cil_tmp68 = (unsigned long )__cil_tmp67;
2262#line 236
2263 __cil_tmp69 = __cil_tmp68 + 184;
2264#line 236
2265 __cil_tmp70 = *((void **)__cil_tmp69);
2266#line 236
2267 chip_pdata = (struct wm831x_pdata *)__cil_tmp70;
2268#line 237
2269 __cil_tmp71 = (unsigned long )chip_pdata;
2270#line 237
2271 __cil_tmp72 = __cil_tmp71 + 136;
2272#line 237
2273 pdata = *((struct wm831x_watchdog_pdata **)__cil_tmp72);
2274 } else {
2275#line 239
2276 __cil_tmp73 = (void *)0;
2277#line 239
2278 pdata = (struct wm831x_watchdog_pdata *)__cil_tmp73;
2279 }
2280 }
2281#line 242
2282 if (pdata) {
2283#line 243
2284 reg = reg & -9009;
2285#line 246
2286 __cil_tmp74 = *((enum wm831x_watchdog_action *)pdata);
2287#line 246
2288 __cil_tmp75 = (unsigned int )__cil_tmp74;
2289#line 246
2290 __cil_tmp76 = __cil_tmp75 << 4;
2291#line 246
2292 __cil_tmp77 = (unsigned int )reg;
2293#line 246
2294 __cil_tmp78 = __cil_tmp77 | __cil_tmp76;
2295#line 246
2296 reg = (int )__cil_tmp78;
2297#line 247
2298 __cil_tmp79 = (unsigned long )pdata;
2299#line 247
2300 __cil_tmp80 = __cil_tmp79 + 4;
2301#line 247
2302 __cil_tmp81 = *((enum wm831x_watchdog_action *)__cil_tmp80);
2303#line 247
2304 __cil_tmp82 = (unsigned int )__cil_tmp81;
2305#line 247
2306 __cil_tmp83 = __cil_tmp82 << 8;
2307#line 247
2308 __cil_tmp84 = (unsigned int )reg;
2309#line 247
2310 __cil_tmp85 = __cil_tmp84 | __cil_tmp83;
2311#line 247
2312 reg = (int )__cil_tmp85;
2313#line 248
2314 __cil_tmp86 = (unsigned long )pdata;
2315#line 248
2316 __cil_tmp87 = __cil_tmp86 + 12;
2317#line 248
2318 __cil_tmp88 = *((unsigned int *)__cil_tmp87);
2319#line 248
2320 __cil_tmp89 = __cil_tmp88 << 13;
2321#line 248
2322 __cil_tmp90 = (unsigned int )reg;
2323#line 248
2324 __cil_tmp91 = __cil_tmp90 | __cil_tmp89;
2325#line 248
2326 reg = (int )__cil_tmp91;
2327 {
2328#line 250
2329 __cil_tmp92 = (unsigned long )pdata;
2330#line 250
2331 __cil_tmp93 = __cil_tmp92 + 8;
2332#line 250
2333 if (*((int *)__cil_tmp93)) {
2334 {
2335#line 251
2336 __cil_tmp94 = (unsigned long )pdata;
2337#line 251
2338 __cil_tmp95 = __cil_tmp94 + 8;
2339#line 251
2340 __cil_tmp96 = *((int *)__cil_tmp95);
2341#line 251
2342 __cil_tmp97 = (unsigned int )__cil_tmp96;
2343#line 251
2344 ret = gpio_request(__cil_tmp97, "Watchdog update");
2345 }
2346#line 253
2347 if (ret < 0) {
2348 {
2349#line 254
2350 __cil_tmp98 = (unsigned long )wm831x;
2351#line 254
2352 __cil_tmp99 = __cil_tmp98 + 72;
2353#line 254
2354 __cil_tmp100 = *((struct device **)__cil_tmp99);
2355#line 254
2356 __cil_tmp101 = (struct device const *)__cil_tmp100;
2357#line 254
2358 dev_err(__cil_tmp101, "Failed to request update GPIO: %d\n", ret);
2359 }
2360#line 257
2361 goto err;
2362 } else {
2363
2364 }
2365 {
2366#line 260
2367 __cil_tmp102 = (unsigned long )pdata;
2368#line 260
2369 __cil_tmp103 = __cil_tmp102 + 8;
2370#line 260
2371 __cil_tmp104 = *((int *)__cil_tmp103);
2372#line 260
2373 __cil_tmp105 = (unsigned int )__cil_tmp104;
2374#line 260
2375 ret = gpio_direction_output(__cil_tmp105, 0);
2376 }
2377#line 261
2378 if (ret != 0) {
2379 {
2380#line 262
2381 __cil_tmp106 = (unsigned long )wm831x;
2382#line 262
2383 __cil_tmp107 = __cil_tmp106 + 72;
2384#line 262
2385 __cil_tmp108 = *((struct device **)__cil_tmp107);
2386#line 262
2387 __cil_tmp109 = (struct device const *)__cil_tmp108;
2388#line 262
2389 dev_err(__cil_tmp109, "gpio_direction_output returned: %d\n", ret);
2390 }
2391#line 265
2392 goto err_gpio;
2393 } else {
2394
2395 }
2396#line 268
2397 __cil_tmp110 = (unsigned long )driver_data;
2398#line 268
2399 __cil_tmp111 = __cil_tmp110 + 128;
2400#line 268
2401 __cil_tmp112 = (unsigned long )pdata;
2402#line 268
2403 __cil_tmp113 = __cil_tmp112 + 8;
2404#line 268
2405 *((int *)__cil_tmp111) = *((int *)__cil_tmp113);
2406#line 271
2407 reg = reg | 8192;
2408 } else {
2409
2410 }
2411 }
2412 {
2413#line 274
2414 ret = wm831x_reg_unlock(wm831x);
2415 }
2416#line 275
2417 if (ret == 0) {
2418 {
2419#line 276
2420 __cil_tmp114 = (unsigned short )reg;
2421#line 276
2422 ret = wm831x_reg_write(wm831x, (unsigned short)16388, __cil_tmp114);
2423#line 277
2424 wm831x_reg_lock(wm831x);
2425 }
2426 } else {
2427 {
2428#line 279
2429 __cil_tmp115 = (unsigned long )wm831x;
2430#line 279
2431 __cil_tmp116 = __cil_tmp115 + 72;
2432#line 279
2433 __cil_tmp117 = *((struct device **)__cil_tmp116);
2434#line 279
2435 __cil_tmp118 = (struct device const *)__cil_tmp117;
2436#line 279
2437 dev_err(__cil_tmp118, "Failed to unlock security key: %d\n", ret);
2438 }
2439#line 281
2440 goto err_gpio;
2441 }
2442 } else {
2443
2444 }
2445 {
2446#line 285
2447 __cil_tmp119 = (struct watchdog_device *)driver_data;
2448#line 285
2449 ret = watchdog_register_device(__cil_tmp119);
2450 }
2451#line 286
2452 if (ret != 0) {
2453 {
2454#line 287
2455 __cil_tmp120 = (unsigned long )wm831x;
2456#line 287
2457 __cil_tmp121 = __cil_tmp120 + 72;
2458#line 287
2459 __cil_tmp122 = *((struct device **)__cil_tmp121);
2460#line 287
2461 __cil_tmp123 = (struct device const *)__cil_tmp122;
2462#line 287
2463 dev_err(__cil_tmp123, "watchdog_register_device() failed: %d\n", ret);
2464 }
2465#line 289
2466 goto err_gpio;
2467 } else {
2468
2469 }
2470 {
2471#line 292
2472 __cil_tmp124 = (unsigned long )pdev;
2473#line 292
2474 __cil_tmp125 = __cil_tmp124 + 16;
2475#line 292
2476 __cil_tmp126 = (struct device *)__cil_tmp125;
2477#line 292
2478 __cil_tmp127 = (void *)driver_data;
2479#line 292
2480 dev_set_drvdata(__cil_tmp126, __cil_tmp127);
2481 }
2482#line 294
2483 return (0);
2484 err_gpio:
2485 {
2486#line 297
2487 __cil_tmp128 = (unsigned long )driver_data;
2488#line 297
2489 __cil_tmp129 = __cil_tmp128 + 128;
2490#line 297
2491 if (*((int *)__cil_tmp129)) {
2492 {
2493#line 298
2494 __cil_tmp130 = (unsigned long )driver_data;
2495#line 298
2496 __cil_tmp131 = __cil_tmp130 + 128;
2497#line 298
2498 __cil_tmp132 = *((int *)__cil_tmp131);
2499#line 298
2500 __cil_tmp133 = (unsigned int )__cil_tmp132;
2501#line 298
2502 gpio_free(__cil_tmp133);
2503 }
2504 } else {
2505
2506 }
2507 }
2508 err:
2509#line 300
2510 return (ret);
2511}
2512}
2513#line 303
2514static int wm831x_wdt_remove(struct platform_device *pdev ) __attribute__((__section__(".devexit.text"),
2515__no_instrument_function__)) ;
2516#line 303 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/16432/dscv_tempdir/dscv/ri/32_1/drivers/watchdog/wm831x_wdt.c.common.c"
2517static int wm831x_wdt_remove(struct platform_device *pdev )
2518{ struct wm831x_wdt_drvdata *driver_data ;
2519 void *tmp ;
2520 unsigned long __cil_tmp4 ;
2521 unsigned long __cil_tmp5 ;
2522 struct device *__cil_tmp6 ;
2523 struct device const *__cil_tmp7 ;
2524 struct watchdog_device *__cil_tmp8 ;
2525 unsigned long __cil_tmp9 ;
2526 unsigned long __cil_tmp10 ;
2527 unsigned long __cil_tmp11 ;
2528 unsigned long __cil_tmp12 ;
2529 int __cil_tmp13 ;
2530 unsigned int __cil_tmp14 ;
2531
2532 {
2533 {
2534#line 305
2535 __cil_tmp4 = (unsigned long )pdev;
2536#line 305
2537 __cil_tmp5 = __cil_tmp4 + 16;
2538#line 305
2539 __cil_tmp6 = (struct device *)__cil_tmp5;
2540#line 305
2541 __cil_tmp7 = (struct device const *)__cil_tmp6;
2542#line 305
2543 tmp = dev_get_drvdata(__cil_tmp7);
2544#line 305
2545 driver_data = (struct wm831x_wdt_drvdata *)tmp;
2546#line 307
2547 __cil_tmp8 = (struct watchdog_device *)driver_data;
2548#line 307
2549 watchdog_unregister_device(__cil_tmp8);
2550 }
2551 {
2552#line 309
2553 __cil_tmp9 = (unsigned long )driver_data;
2554#line 309
2555 __cil_tmp10 = __cil_tmp9 + 128;
2556#line 309
2557 if (*((int *)__cil_tmp10)) {
2558 {
2559#line 310
2560 __cil_tmp11 = (unsigned long )driver_data;
2561#line 310
2562 __cil_tmp12 = __cil_tmp11 + 128;
2563#line 310
2564 __cil_tmp13 = *((int *)__cil_tmp12);
2565#line 310
2566 __cil_tmp14 = (unsigned int )__cil_tmp13;
2567#line 310
2568 gpio_free(__cil_tmp14);
2569 }
2570 } else {
2571
2572 }
2573 }
2574#line 312
2575 return (0);
2576}
2577}
2578#line 315 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/16432/dscv_tempdir/dscv/ri/32_1/drivers/watchdog/wm831x_wdt.c.common.c"
2579static struct platform_driver wm831x_wdt_driver = {& wm831x_wdt_probe, & wm831x_wdt_remove, (void (*)(struct platform_device * ))0,
2580 (int (*)(struct platform_device * , pm_message_t state ))0, (int (*)(struct platform_device * ))0,
2581 {"wm831x-watchdog", (struct bus_type *)0, (struct module *)0, (char const *)0,
2582 (_Bool)0, (struct of_device_id const *)0, (int (*)(struct device *dev ))0,
2583 (int (*)(struct device *dev ))0, (void (*)(struct device *dev ))0, (int (*)(struct device *dev ,
2584 pm_message_t state ))0,
2585 (int (*)(struct device *dev ))0, (struct attribute_group const **)0, (struct dev_pm_ops const *)0,
2586 (struct driver_private *)0}, (struct platform_device_id const *)0};
2587#line 323
2588static int wm831x_wdt_driver_init(void) __attribute__((__section__(".init.text"),
2589__no_instrument_function__)) ;
2590#line 323 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/16432/dscv_tempdir/dscv/ri/32_1/drivers/watchdog/wm831x_wdt.c.common.c"
2591static int wm831x_wdt_driver_init(void)
2592{ int tmp ;
2593
2594 {
2595 {
2596#line 323
2597 tmp = platform_driver_register(& wm831x_wdt_driver);
2598 }
2599#line 323
2600 return (tmp);
2601}
2602}
2603#line 323 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/16432/dscv_tempdir/dscv/ri/32_1/drivers/watchdog/wm831x_wdt.c.common.c"
2604int init_module(void)
2605{ int tmp ;
2606
2607 {
2608 {
2609#line 323
2610 tmp = wm831x_wdt_driver_init();
2611 }
2612#line 323
2613 return (tmp);
2614}
2615}
2616#line 323
2617static void wm831x_wdt_driver_exit(void) __attribute__((__section__(".exit.text"),
2618__no_instrument_function__)) ;
2619#line 323 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/16432/dscv_tempdir/dscv/ri/32_1/drivers/watchdog/wm831x_wdt.c.common.c"
2620static void wm831x_wdt_driver_exit(void)
2621{
2622
2623 {
2624 {
2625#line 323
2626 platform_driver_unregister(& wm831x_wdt_driver);
2627 }
2628#line 323
2629 return;
2630}
2631}
2632#line 323 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/16432/dscv_tempdir/dscv/ri/32_1/drivers/watchdog/wm831x_wdt.c.common.c"
2633void cleanup_module(void)
2634{
2635
2636 {
2637 {
2638#line 323
2639 wm831x_wdt_driver_exit();
2640 }
2641#line 323
2642 return;
2643}
2644}
2645#line 325 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/16432/dscv_tempdir/dscv/ri/32_1/drivers/watchdog/wm831x_wdt.c.common.c"
2646static char const __mod_author325[18] __attribute__((__used__, __unused__, __section__(".modinfo"),
2647__aligned__(1))) =
2648#line 325
2649 { (char const )'a', (char const )'u', (char const )'t', (char const )'h',
2650 (char const )'o', (char const )'r', (char const )'=', (char const )'M',
2651 (char const )'a', (char const )'r', (char const )'k', (char const )' ',
2652 (char const )'B', (char const )'r', (char const )'o', (char const )'w',
2653 (char const )'n', (char const )'\000'};
2654#line 326 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/16432/dscv_tempdir/dscv/ri/32_1/drivers/watchdog/wm831x_wdt.c.common.c"
2655static char const __mod_description326[28] __attribute__((__used__, __unused__,
2656__section__(".modinfo"), __aligned__(1))) =
2657#line 326
2658 { (char const )'d', (char const )'e', (char const )'s', (char const )'c',
2659 (char const )'r', (char const )'i', (char const )'p', (char const )'t',
2660 (char const )'i', (char const )'o', (char const )'n', (char const )'=',
2661 (char const )'W', (char const )'M', (char const )'8', (char const )'3',
2662 (char const )'1', (char const )'x', (char const )' ', (char const )'W',
2663 (char const )'a', (char const )'t', (char const )'c', (char const )'h',
2664 (char const )'d', (char const )'o', (char const )'g', (char const )'\000'};
2665#line 327 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/16432/dscv_tempdir/dscv/ri/32_1/drivers/watchdog/wm831x_wdt.c.common.c"
2666static char const __mod_license327[12] __attribute__((__used__, __unused__, __section__(".modinfo"),
2667__aligned__(1))) =
2668#line 327
2669 { (char const )'l', (char const )'i', (char const )'c', (char const )'e',
2670 (char const )'n', (char const )'s', (char const )'e', (char const )'=',
2671 (char const )'G', (char const )'P', (char const )'L', (char const )'\000'};
2672#line 328 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/16432/dscv_tempdir/dscv/ri/32_1/drivers/watchdog/wm831x_wdt.c.common.c"
2673static char const __mod_alias328[31] __attribute__((__used__, __unused__, __section__(".modinfo"),
2674__aligned__(1))) =
2675#line 328
2676 { (char const )'a', (char const )'l', (char const )'i', (char const )'a',
2677 (char const )'s', (char const )'=', (char const )'p', (char const )'l',
2678 (char const )'a', (char const )'t', (char const )'f', (char const )'o',
2679 (char const )'r', (char const )'m', (char const )':', (char const )'w',
2680 (char const )'m', (char const )'8', (char const )'3', (char const )'1',
2681 (char const )'x', (char const )'-', (char const )'w', (char const )'a',
2682 (char const )'t', (char const )'c', (char const )'h', (char const )'d',
2683 (char const )'o', (char const )'g', (char const )'\000'};
2684#line 346
2685void ldv_check_final_state(void) ;
2686#line 349
2687extern void ldv_check_return_value(int res ) ;
2688#line 352
2689extern void ldv_initialize(void) ;
2690#line 355
2691extern int __VERIFIER_nondet_int(void) ;
2692#line 358 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/16432/dscv_tempdir/dscv/ri/32_1/drivers/watchdog/wm831x_wdt.c.common.c"
2693int LDV_IN_INTERRUPT ;
2694#line 387 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/16432/dscv_tempdir/dscv/ri/32_1/drivers/watchdog/wm831x_wdt.c.common.c"
2695static int res_wm831x_wdt_probe_4 ;
2696#line 361 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/16432/dscv_tempdir/dscv/ri/32_1/drivers/watchdog/wm831x_wdt.c.common.c"
2697void main(void)
2698{ struct watchdog_device *var_group1 ;
2699 unsigned int var_wm831x_wdt_set_timeout_3_p1 ;
2700 struct platform_device *var_group2 ;
2701 int ldv_s_wm831x_wdt_driver_platform_driver ;
2702 int tmp ;
2703 int tmp___0 ;
2704 int __cil_tmp7 ;
2705
2706 {
2707 {
2708#line 395
2709 LDV_IN_INTERRUPT = 1;
2710#line 404
2711 ldv_initialize();
2712#line 407
2713 ldv_s_wm831x_wdt_driver_platform_driver = 0;
2714 }
2715 {
2716#line 410
2717 while (1) {
2718 while_continue: ;
2719 {
2720#line 410
2721 tmp___0 = __VERIFIER_nondet_int();
2722 }
2723#line 410
2724 if (tmp___0) {
2725
2726 } else {
2727 {
2728#line 410
2729 __cil_tmp7 = ldv_s_wm831x_wdt_driver_platform_driver == 0;
2730#line 410
2731 if (! __cil_tmp7) {
2732
2733 } else {
2734#line 410
2735 goto while_break;
2736 }
2737 }
2738 }
2739 {
2740#line 414
2741 tmp = __VERIFIER_nondet_int();
2742 }
2743#line 416
2744 if (tmp == 0) {
2745#line 416
2746 goto case_0;
2747 } else
2748#line 432
2749 if (tmp == 1) {
2750#line 432
2751 goto case_1;
2752 } else
2753#line 448
2754 if (tmp == 2) {
2755#line 448
2756 goto case_2;
2757 } else
2758#line 464
2759 if (tmp == 3) {
2760#line 464
2761 goto case_3;
2762 } else
2763#line 480
2764 if (tmp == 4) {
2765#line 480
2766 goto case_4;
2767 } else {
2768 {
2769#line 499
2770 goto switch_default;
2771#line 414
2772 if (0) {
2773 case_0:
2774 {
2775#line 424
2776 wm831x_wdt_start(var_group1);
2777 }
2778#line 431
2779 goto switch_break;
2780 case_1:
2781 {
2782#line 440
2783 wm831x_wdt_stop(var_group1);
2784 }
2785#line 447
2786 goto switch_break;
2787 case_2:
2788 {
2789#line 456
2790 wm831x_wdt_ping(var_group1);
2791 }
2792#line 463
2793 goto switch_break;
2794 case_3:
2795 {
2796#line 472
2797 wm831x_wdt_set_timeout(var_group1, var_wm831x_wdt_set_timeout_3_p1);
2798 }
2799#line 479
2800 goto switch_break;
2801 case_4:
2802#line 483
2803 if (ldv_s_wm831x_wdt_driver_platform_driver == 0) {
2804 {
2805#line 488
2806 res_wm831x_wdt_probe_4 = wm831x_wdt_probe(var_group2);
2807#line 489
2808 ldv_check_return_value(res_wm831x_wdt_probe_4);
2809 }
2810#line 490
2811 if (res_wm831x_wdt_probe_4) {
2812#line 491
2813 goto ldv_module_exit;
2814 } else {
2815
2816 }
2817#line 492
2818 ldv_s_wm831x_wdt_driver_platform_driver = 0;
2819 } else {
2820
2821 }
2822#line 498
2823 goto switch_break;
2824 switch_default:
2825#line 499
2826 goto switch_break;
2827 } else {
2828 switch_break: ;
2829 }
2830 }
2831 }
2832 }
2833 while_break: ;
2834 }
2835 ldv_module_exit:
2836 {
2837#line 508
2838 ldv_check_final_state();
2839 }
2840#line 511
2841 return;
2842}
2843}
2844#line 5 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/16432/dscv_tempdir/dscv/ri/32_1/kernel-rules/files/engine-blast-assert.h"
2845void ldv_blast_assert(void)
2846{
2847
2848 {
2849 ERROR:
2850#line 6
2851 goto ERROR;
2852}
2853}
2854#line 6 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/16432/dscv_tempdir/dscv/ri/32_1/kernel-rules/files/engine-blast.h"
2855extern int __VERIFIER_nondet_int(void) ;
2856#line 19 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/16432/dscv_tempdir/dscv/ri/32_1/kernel-rules/files/model0032.c"
2857int ldv_mutex = 1;
2858#line 22 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/16432/dscv_tempdir/dscv/ri/32_1/kernel-rules/files/model0032.c"
2859int __attribute__((__warn_unused_result__)) mutex_lock_interruptible(struct mutex *lock )
2860{ int nondetermined ;
2861
2862 {
2863#line 29
2864 if (ldv_mutex == 1) {
2865
2866 } else {
2867 {
2868#line 29
2869 ldv_blast_assert();
2870 }
2871 }
2872 {
2873#line 32
2874 nondetermined = __VERIFIER_nondet_int();
2875 }
2876#line 35
2877 if (nondetermined) {
2878#line 38
2879 ldv_mutex = 2;
2880#line 40
2881 return (0);
2882 } else {
2883#line 45
2884 return (-4);
2885 }
2886}
2887}
2888#line 50 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/16432/dscv_tempdir/dscv/ri/32_1/kernel-rules/files/model0032.c"
2889int __attribute__((__warn_unused_result__)) mutex_lock_killable(struct mutex *lock )
2890{ int nondetermined ;
2891
2892 {
2893#line 57
2894 if (ldv_mutex == 1) {
2895
2896 } else {
2897 {
2898#line 57
2899 ldv_blast_assert();
2900 }
2901 }
2902 {
2903#line 60
2904 nondetermined = __VERIFIER_nondet_int();
2905 }
2906#line 63
2907 if (nondetermined) {
2908#line 66
2909 ldv_mutex = 2;
2910#line 68
2911 return (0);
2912 } else {
2913#line 73
2914 return (-4);
2915 }
2916}
2917}
2918#line 78 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/16432/dscv_tempdir/dscv/ri/32_1/kernel-rules/files/model0032.c"
2919int atomic_dec_and_mutex_lock(atomic_t *cnt , struct mutex *lock )
2920{ int atomic_value_after_dec ;
2921
2922 {
2923#line 83
2924 if (ldv_mutex == 1) {
2925
2926 } else {
2927 {
2928#line 83
2929 ldv_blast_assert();
2930 }
2931 }
2932 {
2933#line 86
2934 atomic_value_after_dec = __VERIFIER_nondet_int();
2935 }
2936#line 89
2937 if (atomic_value_after_dec == 0) {
2938#line 92
2939 ldv_mutex = 2;
2940#line 94
2941 return (1);
2942 } else {
2943
2944 }
2945#line 98
2946 return (0);
2947}
2948}
2949#line 103 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/16432/dscv_tempdir/dscv/ri/32_1/kernel-rules/files/model0032.c"
2950void mutex_lock(struct mutex *lock )
2951{
2952
2953 {
2954#line 108
2955 if (ldv_mutex == 1) {
2956
2957 } else {
2958 {
2959#line 108
2960 ldv_blast_assert();
2961 }
2962 }
2963#line 110
2964 ldv_mutex = 2;
2965#line 111
2966 return;
2967}
2968}
2969#line 114 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/16432/dscv_tempdir/dscv/ri/32_1/kernel-rules/files/model0032.c"
2970int mutex_trylock(struct mutex *lock )
2971{ int nondetermined ;
2972
2973 {
2974#line 121
2975 if (ldv_mutex == 1) {
2976
2977 } else {
2978 {
2979#line 121
2980 ldv_blast_assert();
2981 }
2982 }
2983 {
2984#line 124
2985 nondetermined = __VERIFIER_nondet_int();
2986 }
2987#line 127
2988 if (nondetermined) {
2989#line 130
2990 ldv_mutex = 2;
2991#line 132
2992 return (1);
2993 } else {
2994#line 137
2995 return (0);
2996 }
2997}
2998}
2999#line 142 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/16432/dscv_tempdir/dscv/ri/32_1/kernel-rules/files/model0032.c"
3000void mutex_unlock(struct mutex *lock )
3001{
3002
3003 {
3004#line 147
3005 if (ldv_mutex == 2) {
3006
3007 } else {
3008 {
3009#line 147
3010 ldv_blast_assert();
3011 }
3012 }
3013#line 149
3014 ldv_mutex = 1;
3015#line 150
3016 return;
3017}
3018}
3019#line 153 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/16432/dscv_tempdir/dscv/ri/32_1/kernel-rules/files/model0032.c"
3020void ldv_check_final_state(void)
3021{
3022
3023 {
3024#line 156
3025 if (ldv_mutex == 1) {
3026
3027 } else {
3028 {
3029#line 156
3030 ldv_blast_assert();
3031 }
3032 }
3033#line 157
3034 return;
3035}
3036}
3037#line 520 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/16432/dscv_tempdir/dscv/ri/32_1/drivers/watchdog/wm831x_wdt.c.common.c"
3038long s__builtin_expect(long val , long res )
3039{
3040
3041 {
3042#line 521
3043 return (val);
3044}
3045}