/* Generated by CIL v. 1.5.1 */ /* print_CIL_Input is false */ typedef signed char __s8; typedef unsigned char __u8; typedef unsigned short __u16; typedef int __s32; typedef unsigned int __u32; typedef unsigned long long __u64; typedef signed char s8; typedef unsigned char u8; typedef unsigned short u16; typedef int s32; typedef unsigned int u32; typedef long long s64; typedef unsigned long long u64; typedef long __kernel_long_t; typedef unsigned long __kernel_ulong_t; typedef int __kernel_pid_t; typedef unsigned int __kernel_uid32_t; typedef unsigned int __kernel_gid32_t; typedef __kernel_ulong_t __kernel_size_t; typedef __kernel_long_t __kernel_ssize_t; typedef long long __kernel_loff_t; typedef __kernel_long_t __kernel_time_t; typedef __kernel_long_t __kernel_clock_t; typedef int __kernel_timer_t; typedef int __kernel_clockid_t; typedef __u16 __be16; typedef __u32 __le32; typedef __u32 __be32; typedef __u64 __le64; typedef __u32 __kernel_dev_t; typedef __kernel_dev_t dev_t; typedef unsigned short umode_t; typedef __kernel_pid_t pid_t; typedef __kernel_clockid_t clockid_t; typedef _Bool bool; typedef __kernel_uid32_t uid_t; typedef __kernel_gid32_t gid_t; typedef __kernel_loff_t loff_t; typedef __kernel_size_t size_t; typedef __kernel_ssize_t ssize_t; typedef __kernel_time_t time_t; typedef __s32 int32_t; typedef __u32 uint32_t; typedef unsigned long sector_t; typedef unsigned long blkcnt_t; typedef u64 dma_addr_t; typedef unsigned int gfp_t; typedef unsigned int fmode_t; typedef unsigned int oom_flags_t; typedef u64 phys_addr_t; typedef phys_addr_t resource_size_t; struct __anonstruct_atomic_t_6 { int counter ; }; typedef struct __anonstruct_atomic_t_6 atomic_t; struct __anonstruct_atomic64_t_7 { long counter ; }; typedef struct __anonstruct_atomic64_t_7 atomic64_t; struct list_head { struct list_head *next ; struct list_head *prev ; }; struct hlist_node; struct hlist_head { struct hlist_node *first ; }; struct hlist_node { struct hlist_node *next ; struct hlist_node **pprev ; }; struct callback_head { struct callback_head *next ; void (*func)(struct callback_head * ) ; }; struct class; struct device; struct completion; struct gendisk; struct module; struct mutex; struct request_queue; struct request; typedef u16 __ticket_t; typedef u32 __ticketpair_t; struct __raw_tickets { __ticket_t head ; __ticket_t tail ; }; union __anonunion____missing_field_name_8 { __ticketpair_t head_tail ; struct __raw_tickets tickets ; }; struct arch_spinlock { union __anonunion____missing_field_name_8 __annonCompField4 ; }; typedef struct arch_spinlock arch_spinlock_t; struct qrwlock { atomic_t cnts ; arch_spinlock_t lock ; }; typedef struct qrwlock arch_rwlock_t; struct task_struct; struct lockdep_map; struct kernel_symbol { unsigned long value ; char const *name ; }; struct pt_regs { unsigned long r15 ; unsigned long r14 ; unsigned long r13 ; unsigned long r12 ; unsigned long bp ; unsigned long bx ; unsigned long r11 ; unsigned long r10 ; unsigned long r9 ; unsigned long r8 ; unsigned long ax ; unsigned long cx ; unsigned long dx ; unsigned long si ; unsigned long di ; unsigned long orig_ax ; unsigned long ip ; unsigned long cs ; unsigned long flags ; unsigned long sp ; unsigned long ss ; }; struct __anonstruct____missing_field_name_10 { unsigned int a ; unsigned int b ; }; struct __anonstruct____missing_field_name_11 { u16 limit0 ; u16 base0 ; unsigned char base1 ; unsigned char type : 4 ; unsigned char s : 1 ; unsigned char dpl : 2 ; unsigned char p : 1 ; unsigned char limit : 4 ; unsigned char avl : 1 ; unsigned char l : 1 ; unsigned char d : 1 ; unsigned char g : 1 ; unsigned char base2 ; }; union __anonunion____missing_field_name_9 { struct __anonstruct____missing_field_name_10 __annonCompField5 ; struct __anonstruct____missing_field_name_11 __annonCompField6 ; }; struct desc_struct { union __anonunion____missing_field_name_9 __annonCompField7 ; }; typedef unsigned long pteval_t; typedef unsigned long pgdval_t; typedef unsigned long pgprotval_t; struct __anonstruct_pte_t_12 { pteval_t pte ; }; typedef struct __anonstruct_pte_t_12 pte_t; struct pgprot { pgprotval_t pgprot ; }; typedef struct pgprot pgprot_t; struct __anonstruct_pgd_t_13 { pgdval_t pgd ; }; typedef struct __anonstruct_pgd_t_13 pgd_t; struct page; typedef struct page *pgtable_t; struct file; struct seq_file; struct thread_struct; struct mm_struct; struct cpumask; struct paravirt_callee_save { void *func ; }; struct pv_irq_ops { struct paravirt_callee_save save_fl ; struct paravirt_callee_save restore_fl ; struct paravirt_callee_save irq_disable ; struct paravirt_callee_save irq_enable ; void (*safe_halt)(void) ; void (*halt)(void) ; void (*adjust_exception_frame)(void) ; }; typedef void (*ctor_fn_t)(void); struct file_operations; struct kernel_vm86_regs { struct pt_regs pt ; unsigned short es ; unsigned short __esh ; unsigned short ds ; unsigned short __dsh ; unsigned short fs ; unsigned short __fsh ; unsigned short gs ; unsigned short __gsh ; }; union __anonunion____missing_field_name_16 { struct pt_regs *regs ; struct kernel_vm86_regs *vm86 ; }; struct math_emu_info { long ___orig_eip ; union __anonunion____missing_field_name_16 __annonCompField8 ; }; struct bug_entry { int bug_addr_disp ; int file_disp ; unsigned short line ; unsigned short flags ; }; struct cpumask { unsigned long bits[128U] ; }; typedef struct cpumask cpumask_t; typedef struct cpumask *cpumask_var_t; struct seq_operations; struct i387_fsave_struct { u32 cwd ; u32 swd ; u32 twd ; u32 fip ; u32 fcs ; u32 foo ; u32 fos ; u32 st_space[20U] ; u32 status ; }; struct __anonstruct____missing_field_name_21 { u64 rip ; u64 rdp ; }; struct __anonstruct____missing_field_name_22 { u32 fip ; u32 fcs ; u32 foo ; u32 fos ; }; union __anonunion____missing_field_name_20 { struct __anonstruct____missing_field_name_21 __annonCompField12 ; struct __anonstruct____missing_field_name_22 __annonCompField13 ; }; union __anonunion____missing_field_name_23 { u32 padding1[12U] ; u32 sw_reserved[12U] ; }; struct i387_fxsave_struct { u16 cwd ; u16 swd ; u16 twd ; u16 fop ; union __anonunion____missing_field_name_20 __annonCompField14 ; u32 mxcsr ; u32 mxcsr_mask ; u32 st_space[32U] ; u32 xmm_space[64U] ; u32 padding[12U] ; union __anonunion____missing_field_name_23 __annonCompField15 ; }; struct i387_soft_struct { u32 cwd ; u32 swd ; u32 twd ; u32 fip ; u32 fcs ; u32 foo ; u32 fos ; u32 st_space[20U] ; u8 ftop ; u8 changed ; u8 lookahead ; u8 no_update ; u8 rm ; u8 alimit ; struct math_emu_info *info ; u32 entry_eip ; }; struct ymmh_struct { u32 ymmh_space[64U] ; }; struct lwp_struct { u8 reserved[128U] ; }; struct bndreg { u64 lower_bound ; u64 upper_bound ; }; struct bndcsr { u64 bndcfgu ; u64 bndstatus ; }; struct xsave_hdr_struct { u64 xstate_bv ; u64 xcomp_bv ; u64 reserved[6U] ; }; struct xsave_struct { struct i387_fxsave_struct i387 ; struct xsave_hdr_struct xsave_hdr ; struct ymmh_struct ymmh ; struct lwp_struct lwp ; struct bndreg bndreg[4U] ; struct bndcsr bndcsr ; }; union thread_xstate { struct i387_fsave_struct fsave ; struct i387_fxsave_struct fxsave ; struct i387_soft_struct soft ; struct xsave_struct xsave ; }; struct fpu { unsigned int last_cpu ; unsigned int has_fpu ; union thread_xstate *state ; }; struct kmem_cache; struct perf_event; struct thread_struct { struct desc_struct tls_array[3U] ; unsigned long sp0 ; unsigned long sp ; unsigned long usersp ; unsigned short es ; unsigned short ds ; unsigned short fsindex ; unsigned short gsindex ; unsigned long fs ; unsigned long gs ; struct perf_event *ptrace_bps[4U] ; unsigned long debugreg6 ; unsigned long ptrace_dr7 ; unsigned long cr2 ; unsigned long trap_nr ; unsigned long error_code ; struct fpu fpu ; unsigned long *io_bitmap_ptr ; unsigned long iopl ; unsigned int io_bitmap_max ; unsigned char fpu_counter ; }; typedef atomic64_t atomic_long_t; struct stack_trace { unsigned int nr_entries ; unsigned int max_entries ; unsigned long *entries ; int skip ; }; struct lockdep_subclass_key { char __one_byte ; }; struct lock_class_key { struct lockdep_subclass_key subkeys[8U] ; }; struct lock_class { struct list_head hash_entry ; struct list_head lock_entry ; struct lockdep_subclass_key *key ; unsigned int subclass ; unsigned int dep_gen_id ; unsigned long usage_mask ; struct stack_trace usage_traces[13U] ; struct list_head locks_after ; struct list_head locks_before ; unsigned int version ; unsigned long ops ; char const *name ; int name_version ; unsigned long contention_point[4U] ; unsigned long contending_point[4U] ; }; struct lockdep_map { struct lock_class_key *key ; struct lock_class *class_cache[2U] ; char const *name ; int cpu ; unsigned long ip ; }; struct held_lock { u64 prev_chain_key ; unsigned long acquire_ip ; struct lockdep_map *instance ; struct lockdep_map *nest_lock ; u64 waittime_stamp ; u64 holdtime_stamp ; unsigned short class_idx : 13 ; unsigned char irq_context : 2 ; unsigned char trylock : 1 ; unsigned char read : 2 ; unsigned char check : 1 ; unsigned char hardirqs_off : 1 ; unsigned short references : 12 ; }; struct raw_spinlock { arch_spinlock_t raw_lock ; unsigned int magic ; unsigned int owner_cpu ; void *owner ; struct lockdep_map dep_map ; }; typedef struct raw_spinlock raw_spinlock_t; struct __anonstruct____missing_field_name_27 { u8 __padding[24U] ; struct lockdep_map dep_map ; }; union __anonunion____missing_field_name_26 { struct raw_spinlock rlock ; struct __anonstruct____missing_field_name_27 __annonCompField17 ; }; struct spinlock { union __anonunion____missing_field_name_26 __annonCompField18 ; }; typedef struct spinlock spinlock_t; struct __anonstruct_rwlock_t_28 { arch_rwlock_t raw_lock ; unsigned int magic ; unsigned int owner_cpu ; void *owner ; struct lockdep_map dep_map ; }; typedef struct __anonstruct_rwlock_t_28 rwlock_t; struct ldv_thread; typedef unsigned long kernel_ulong_t; struct pci_device_id { __u32 vendor ; __u32 device ; __u32 subvendor ; __u32 subdevice ; __u32 class ; __u32 class_mask ; kernel_ulong_t driver_data ; }; struct acpi_device_id { __u8 id[9U] ; kernel_ulong_t driver_data ; }; struct of_device_id { char name[32U] ; char type[32U] ; char compatible[128U] ; void const *data ; }; struct resource { resource_size_t start ; resource_size_t end ; char const *name ; unsigned long flags ; struct resource *parent ; struct resource *sibling ; struct resource *child ; }; struct optimistic_spin_queue { atomic_t tail ; }; struct mutex { atomic_t count ; spinlock_t wait_lock ; struct list_head wait_list ; struct task_struct *owner ; void *magic ; struct lockdep_map dep_map ; }; struct mutex_waiter { struct list_head list ; struct task_struct *task ; void *magic ; }; struct timespec; struct compat_timespec; struct __anonstruct_futex_33 { u32 *uaddr ; u32 val ; u32 flags ; u32 bitset ; u64 time ; u32 *uaddr2 ; }; struct __anonstruct_nanosleep_34 { clockid_t clockid ; struct timespec *rmtp ; struct compat_timespec *compat_rmtp ; u64 expires ; }; struct pollfd; struct __anonstruct_poll_35 { struct pollfd *ufds ; int nfds ; int has_timeout ; unsigned long tv_sec ; unsigned long tv_nsec ; }; union __anonunion____missing_field_name_32 { struct __anonstruct_futex_33 futex ; struct __anonstruct_nanosleep_34 nanosleep ; struct __anonstruct_poll_35 poll ; }; struct restart_block { long (*fn)(struct restart_block * ) ; union __anonunion____missing_field_name_32 __annonCompField19 ; }; struct jump_entry; typedef u64 jump_label_t; struct jump_entry { jump_label_t code ; jump_label_t target ; jump_label_t key ; }; struct seqcount { unsigned int sequence ; struct lockdep_map dep_map ; }; typedef struct seqcount seqcount_t; struct __anonstruct_seqlock_t_48 { struct seqcount seqcount ; spinlock_t lock ; }; typedef struct __anonstruct_seqlock_t_48 seqlock_t; struct __wait_queue_head { spinlock_t lock ; struct list_head task_list ; }; typedef struct __wait_queue_head wait_queue_head_t; struct completion { unsigned int done ; wait_queue_head_t wait ; }; union __anonunion____missing_field_name_49 { unsigned long bitmap[4U] ; struct callback_head callback_head ; }; struct idr_layer { int prefix ; int layer ; struct idr_layer *ary[256U] ; int count ; union __anonunion____missing_field_name_49 __annonCompField20 ; }; struct idr { struct idr_layer *hint ; struct idr_layer *top ; int layers ; int cur ; spinlock_t lock ; int id_free_cnt ; struct idr_layer *id_free ; }; struct ida_bitmap { long nr_busy ; unsigned long bitmap[15U] ; }; struct ida { struct idr idr ; struct ida_bitmap *free_bitmap ; }; struct rb_node { unsigned long __rb_parent_color ; struct rb_node *rb_right ; struct rb_node *rb_left ; }; struct rb_root { struct rb_node *rb_node ; }; struct dentry; struct iattr; struct vm_area_struct; struct super_block; struct file_system_type; struct kernfs_open_node; struct kernfs_iattrs; struct kernfs_root; struct kernfs_elem_dir { unsigned long subdirs ; struct rb_root children ; struct kernfs_root *root ; }; struct kernfs_node; struct kernfs_elem_symlink { struct kernfs_node *target_kn ; }; struct kernfs_ops; struct kernfs_elem_attr { struct kernfs_ops const *ops ; struct kernfs_open_node *open ; loff_t size ; struct kernfs_node *notify_next ; }; union __anonunion____missing_field_name_50 { struct kernfs_elem_dir dir ; struct kernfs_elem_symlink symlink ; struct kernfs_elem_attr attr ; }; struct kernfs_node { atomic_t count ; atomic_t active ; struct lockdep_map dep_map ; struct kernfs_node *parent ; char const *name ; struct rb_node rb ; void const *ns ; unsigned int hash ; union __anonunion____missing_field_name_50 __annonCompField21 ; void *priv ; unsigned short flags ; umode_t mode ; unsigned int ino ; struct kernfs_iattrs *iattr ; }; struct kernfs_syscall_ops { int (*remount_fs)(struct kernfs_root * , int * , char * ) ; int (*show_options)(struct seq_file * , struct kernfs_root * ) ; int (*mkdir)(struct kernfs_node * , char const * , umode_t ) ; int (*rmdir)(struct kernfs_node * ) ; int (*rename)(struct kernfs_node * , struct kernfs_node * , char const * ) ; }; struct kernfs_root { struct kernfs_node *kn ; unsigned int flags ; struct ida ino_ida ; struct kernfs_syscall_ops *syscall_ops ; struct list_head supers ; wait_queue_head_t deactivate_waitq ; }; struct vm_operations_struct; struct kernfs_open_file { struct kernfs_node *kn ; struct file *file ; void *priv ; struct mutex mutex ; int event ; struct list_head list ; char *prealloc_buf ; size_t atomic_write_len ; bool mmapped ; struct vm_operations_struct const *vm_ops ; }; struct kernfs_ops { int (*seq_show)(struct seq_file * , void * ) ; void *(*seq_start)(struct seq_file * , loff_t * ) ; void *(*seq_next)(struct seq_file * , void * , loff_t * ) ; void (*seq_stop)(struct seq_file * , void * ) ; ssize_t (*read)(struct kernfs_open_file * , char * , size_t , loff_t ) ; size_t atomic_write_len ; bool prealloc ; ssize_t (*write)(struct kernfs_open_file * , char * , size_t , loff_t ) ; int (*mmap)(struct kernfs_open_file * , struct vm_area_struct * ) ; struct lock_class_key lockdep_key ; }; struct sock; struct kobject; enum kobj_ns_type { KOBJ_NS_TYPE_NONE = 0, KOBJ_NS_TYPE_NET = 1, KOBJ_NS_TYPES = 2 } ; struct kobj_ns_type_operations { enum kobj_ns_type type ; bool (*current_may_mount)(void) ; void *(*grab_current_ns)(void) ; void const *(*netlink_ns)(struct sock * ) ; void const *(*initial_ns)(void) ; void (*drop_ns)(void * ) ; }; struct timespec { __kernel_time_t tv_sec ; long tv_nsec ; }; struct user_namespace; struct __anonstruct_kuid_t_51 { uid_t val ; }; typedef struct __anonstruct_kuid_t_51 kuid_t; struct __anonstruct_kgid_t_52 { gid_t val ; }; typedef struct __anonstruct_kgid_t_52 kgid_t; struct kstat { u64 ino ; dev_t dev ; umode_t mode ; unsigned int nlink ; kuid_t uid ; kgid_t gid ; dev_t rdev ; loff_t size ; struct timespec atime ; struct timespec mtime ; struct timespec ctime ; unsigned long blksize ; unsigned long long blocks ; }; struct bin_attribute; struct attribute { char const *name ; umode_t mode ; bool ignore_lockdep ; struct lock_class_key *key ; struct lock_class_key skey ; }; struct attribute_group { char const *name ; umode_t (*is_visible)(struct kobject * , struct attribute * , int ) ; struct attribute **attrs ; struct bin_attribute **bin_attrs ; }; struct bin_attribute { struct attribute attr ; size_t size ; void *private ; ssize_t (*read)(struct file * , struct kobject * , struct bin_attribute * , char * , loff_t , size_t ) ; ssize_t (*write)(struct file * , struct kobject * , struct bin_attribute * , char * , loff_t , size_t ) ; int (*mmap)(struct file * , struct kobject * , struct bin_attribute * , struct vm_area_struct * ) ; }; struct sysfs_ops { ssize_t (*show)(struct kobject * , struct attribute * , char * ) ; ssize_t (*store)(struct kobject * , struct attribute * , char const * , size_t ) ; }; struct kref { atomic_t refcount ; }; union ktime { s64 tv64 ; }; typedef union ktime ktime_t; struct tvec_base; struct timer_list { struct list_head entry ; unsigned long expires ; struct tvec_base *base ; void (*function)(unsigned long ) ; unsigned long data ; int slack ; int start_pid ; void *start_site ; char start_comm[16U] ; struct lockdep_map lockdep_map ; }; struct hrtimer; enum hrtimer_restart; struct workqueue_struct; struct work_struct; struct work_struct { atomic_long_t data ; struct list_head entry ; void (*func)(struct work_struct * ) ; struct lockdep_map lockdep_map ; }; struct delayed_work { struct work_struct work ; struct timer_list timer ; struct workqueue_struct *wq ; int cpu ; }; struct execute_work { struct work_struct work ; }; struct kset; struct kobj_type; struct kobject { char const *name ; struct list_head entry ; struct kobject *parent ; struct kset *kset ; struct kobj_type *ktype ; struct kernfs_node *sd ; struct kref kref ; struct delayed_work release ; unsigned char state_initialized : 1 ; unsigned char state_in_sysfs : 1 ; unsigned char state_add_uevent_sent : 1 ; unsigned char state_remove_uevent_sent : 1 ; unsigned char uevent_suppress : 1 ; }; struct kobj_type { void (*release)(struct kobject * ) ; struct sysfs_ops const *sysfs_ops ; struct attribute **default_attrs ; struct kobj_ns_type_operations const *(*child_ns_type)(struct kobject * ) ; void const *(*namespace)(struct kobject * ) ; }; struct kobj_uevent_env { char *argv[3U] ; char *envp[32U] ; int envp_idx ; char buf[2048U] ; int buflen ; }; struct kset_uevent_ops { int (* const filter)(struct kset * , struct kobject * ) ; char const *(* const name)(struct kset * , struct kobject * ) ; int (* const uevent)(struct kset * , struct kobject * , struct kobj_uevent_env * ) ; }; struct kset { struct list_head list ; spinlock_t list_lock ; struct kobject kobj ; struct kset_uevent_ops const *uevent_ops ; }; struct klist_node; struct klist_node { void *n_klist ; struct list_head n_node ; struct kref n_ref ; }; struct __anonstruct_nodemask_t_53 { unsigned long bits[16U] ; }; typedef struct __anonstruct_nodemask_t_53 nodemask_t; struct path; struct inode; struct seq_file { char *buf ; size_t size ; size_t from ; size_t count ; size_t pad_until ; loff_t index ; loff_t read_pos ; u64 version ; struct mutex lock ; struct seq_operations const *op ; int poll_event ; struct user_namespace *user_ns ; void *private ; }; struct seq_operations { void *(*start)(struct seq_file * , loff_t * ) ; void (*stop)(struct seq_file * , void * ) ; void *(*next)(struct seq_file * , void * , loff_t * ) ; int (*show)(struct seq_file * , void * ) ; }; struct pinctrl; struct pinctrl_state; struct dev_pin_info { struct pinctrl *p ; struct pinctrl_state *default_state ; struct pinctrl_state *sleep_state ; struct pinctrl_state *idle_state ; }; struct pm_message { int event ; }; typedef struct pm_message pm_message_t; struct dev_pm_ops { int (*prepare)(struct device * ) ; void (*complete)(struct device * ) ; int (*suspend)(struct device * ) ; int (*resume)(struct device * ) ; int (*freeze)(struct device * ) ; int (*thaw)(struct device * ) ; int (*poweroff)(struct device * ) ; int (*restore)(struct device * ) ; int (*suspend_late)(struct device * ) ; int (*resume_early)(struct device * ) ; int (*freeze_late)(struct device * ) ; int (*thaw_early)(struct device * ) ; int (*poweroff_late)(struct device * ) ; int (*restore_early)(struct device * ) ; int (*suspend_noirq)(struct device * ) ; int (*resume_noirq)(struct device * ) ; int (*freeze_noirq)(struct device * ) ; int (*thaw_noirq)(struct device * ) ; int (*poweroff_noirq)(struct device * ) ; int (*restore_noirq)(struct device * ) ; int (*runtime_suspend)(struct device * ) ; int (*runtime_resume)(struct device * ) ; int (*runtime_idle)(struct device * ) ; }; enum rpm_status { RPM_ACTIVE = 0, RPM_RESUMING = 1, RPM_SUSPENDED = 2, RPM_SUSPENDING = 3 } ; enum rpm_request { RPM_REQ_NONE = 0, RPM_REQ_IDLE = 1, RPM_REQ_SUSPEND = 2, RPM_REQ_AUTOSUSPEND = 3, RPM_REQ_RESUME = 4 } ; struct wakeup_source; struct pm_subsys_data { spinlock_t lock ; unsigned int refcount ; struct list_head clock_list ; }; struct dev_pm_qos; struct dev_pm_info { pm_message_t power_state ; unsigned char can_wakeup : 1 ; unsigned char async_suspend : 1 ; bool is_prepared ; bool is_suspended ; bool is_noirq_suspended ; bool is_late_suspended ; bool ignore_children ; bool early_init ; bool direct_complete ; spinlock_t lock ; struct list_head entry ; struct completion completion ; struct wakeup_source *wakeup ; bool wakeup_path ; bool syscore ; struct timer_list suspend_timer ; unsigned long timer_expires ; struct work_struct work ; wait_queue_head_t wait_queue ; atomic_t usage_count ; atomic_t child_count ; unsigned char disable_depth : 3 ; unsigned char idle_notification : 1 ; unsigned char request_pending : 1 ; unsigned char deferred_resume : 1 ; unsigned char run_wake : 1 ; unsigned char runtime_auto : 1 ; unsigned char no_callbacks : 1 ; unsigned char irq_safe : 1 ; unsigned char use_autosuspend : 1 ; unsigned char timer_autosuspends : 1 ; unsigned char memalloc_noio : 1 ; enum rpm_request request ; enum rpm_status runtime_status ; int runtime_error ; int autosuspend_delay ; unsigned long last_busy ; unsigned long active_jiffies ; unsigned long suspended_jiffies ; unsigned long accounting_timestamp ; struct pm_subsys_data *subsys_data ; void (*set_latency_tolerance)(struct device * , s32 ) ; struct dev_pm_qos *qos ; }; struct dev_pm_domain { struct dev_pm_ops ops ; void (*detach)(struct device * , bool ) ; }; struct rw_semaphore; struct rw_semaphore { long count ; struct list_head wait_list ; raw_spinlock_t wait_lock ; struct optimistic_spin_queue osq ; struct task_struct *owner ; struct lockdep_map dep_map ; }; struct pci_dev; struct pci_bus; struct __anonstruct_mm_context_t_118 { void *ldt ; int size ; unsigned short ia32_compat ; struct mutex lock ; void *vdso ; atomic_t perf_rdpmc_allowed ; }; typedef struct __anonstruct_mm_context_t_118 mm_context_t; struct bio_vec; struct device_node; struct llist_node; struct llist_node { struct llist_node *next ; }; struct call_single_data { struct llist_node llist ; void (*func)(void * ) ; void *info ; u16 flags ; }; struct dma_map_ops; struct dev_archdata { struct dma_map_ops *dma_ops ; void *iommu ; }; struct device_private; struct device_driver; struct driver_private; struct subsys_private; struct bus_type; struct iommu_ops; struct iommu_group; struct device_attribute; struct bus_type { char const *name ; char const *dev_name ; struct device *dev_root ; struct device_attribute *dev_attrs ; struct attribute_group const **bus_groups ; struct attribute_group const **dev_groups ; struct attribute_group const **drv_groups ; int (*match)(struct device * , struct device_driver * ) ; int (*uevent)(struct device * , struct kobj_uevent_env * ) ; int (*probe)(struct device * ) ; int (*remove)(struct device * ) ; void (*shutdown)(struct device * ) ; int (*online)(struct device * ) ; int (*offline)(struct device * ) ; int (*suspend)(struct device * , pm_message_t ) ; int (*resume)(struct device * ) ; struct dev_pm_ops const *pm ; struct iommu_ops const *iommu_ops ; struct subsys_private *p ; struct lock_class_key lock_key ; }; struct device_type; struct device_driver { char const *name ; struct bus_type *bus ; struct module *owner ; char const *mod_name ; bool suppress_bind_attrs ; struct of_device_id const *of_match_table ; struct acpi_device_id const *acpi_match_table ; int (*probe)(struct device * ) ; int (*remove)(struct device * ) ; void (*shutdown)(struct device * ) ; int (*suspend)(struct device * , pm_message_t ) ; int (*resume)(struct device * ) ; struct attribute_group const **groups ; struct dev_pm_ops const *pm ; struct driver_private *p ; }; struct class_attribute; struct class { char const *name ; struct module *owner ; struct class_attribute *class_attrs ; struct attribute_group const **dev_groups ; struct kobject *dev_kobj ; int (*dev_uevent)(struct device * , struct kobj_uevent_env * ) ; char *(*devnode)(struct device * , umode_t * ) ; void (*class_release)(struct class * ) ; void (*dev_release)(struct device * ) ; int (*suspend)(struct device * , pm_message_t ) ; int (*resume)(struct device * ) ; struct kobj_ns_type_operations const *ns_type ; void const *(*namespace)(struct device * ) ; struct dev_pm_ops const *pm ; struct subsys_private *p ; }; struct class_attribute { struct attribute attr ; ssize_t (*show)(struct class * , struct class_attribute * , char * ) ; ssize_t (*store)(struct class * , struct class_attribute * , char const * , size_t ) ; }; struct device_type { char const *name ; struct attribute_group const **groups ; int (*uevent)(struct device * , struct kobj_uevent_env * ) ; char *(*devnode)(struct device * , umode_t * , kuid_t * , kgid_t * ) ; void (*release)(struct device * ) ; struct dev_pm_ops const *pm ; }; struct device_attribute { struct attribute attr ; ssize_t (*show)(struct device * , struct device_attribute * , char * ) ; ssize_t (*store)(struct device * , struct device_attribute * , char const * , size_t ) ; }; struct device_dma_parameters { unsigned int max_segment_size ; unsigned long segment_boundary_mask ; }; struct acpi_device; struct acpi_dev_node { struct acpi_device *companion ; }; struct dma_coherent_mem; struct cma; struct device { struct device *parent ; struct device_private *p ; struct kobject kobj ; char const *init_name ; struct device_type const *type ; struct mutex mutex ; struct bus_type *bus ; struct device_driver *driver ; void *platform_data ; void *driver_data ; struct dev_pm_info power ; struct dev_pm_domain *pm_domain ; struct dev_pin_info *pins ; int numa_node ; u64 *dma_mask ; u64 coherent_dma_mask ; unsigned long dma_pfn_offset ; struct device_dma_parameters *dma_parms ; struct list_head dma_pools ; struct dma_coherent_mem *dma_mem ; struct cma *cma_area ; struct dev_archdata archdata ; struct device_node *of_node ; struct acpi_dev_node acpi_node ; dev_t devt ; u32 id ; spinlock_t devres_lock ; struct list_head devres_head ; struct klist_node knode_class ; struct class *class ; struct attribute_group const **groups ; void (*release)(struct device * ) ; struct iommu_group *iommu_group ; bool offline_disabled ; bool offline ; }; struct wakeup_source { char const *name ; struct list_head entry ; spinlock_t lock ; struct timer_list timer ; unsigned long timer_expires ; ktime_t total_time ; ktime_t max_time ; ktime_t last_time ; ktime_t start_prevent_time ; ktime_t prevent_sleep_time ; unsigned long event_count ; unsigned long active_count ; unsigned long relax_count ; unsigned long expire_count ; unsigned long wakeup_count ; bool active ; bool autosleep_enabled ; }; struct kernel_cap_struct { __u32 cap[2U] ; }; typedef struct kernel_cap_struct kernel_cap_t; struct plist_node { int prio ; struct list_head prio_list ; struct list_head node_list ; }; struct arch_uprobe_task { unsigned long saved_scratch_register ; unsigned int saved_trap_nr ; unsigned int saved_tf ; }; enum uprobe_task_state { UTASK_RUNNING = 0, UTASK_SSTEP = 1, UTASK_SSTEP_ACK = 2, UTASK_SSTEP_TRAPPED = 3 } ; struct __anonstruct____missing_field_name_151 { struct arch_uprobe_task autask ; unsigned long vaddr ; }; struct __anonstruct____missing_field_name_152 { struct callback_head dup_xol_work ; unsigned long dup_xol_addr ; }; union __anonunion____missing_field_name_150 { struct __anonstruct____missing_field_name_151 __annonCompField34 ; struct __anonstruct____missing_field_name_152 __annonCompField35 ; }; struct uprobe; struct return_instance; struct uprobe_task { enum uprobe_task_state state ; union __anonunion____missing_field_name_150 __annonCompField36 ; struct uprobe *active_uprobe ; unsigned long xol_vaddr ; struct return_instance *return_instances ; unsigned int depth ; }; struct xol_area; struct uprobes_state { struct xol_area *xol_area ; }; struct address_space; struct mem_cgroup; typedef void compound_page_dtor(struct page * ); union __anonunion____missing_field_name_153 { struct address_space *mapping ; void *s_mem ; }; union __anonunion____missing_field_name_155 { unsigned long index ; void *freelist ; bool pfmemalloc ; }; struct __anonstruct____missing_field_name_159 { unsigned short inuse ; unsigned short objects : 15 ; unsigned char frozen : 1 ; }; union __anonunion____missing_field_name_158 { atomic_t _mapcount ; struct __anonstruct____missing_field_name_159 __annonCompField39 ; int units ; }; struct __anonstruct____missing_field_name_157 { union __anonunion____missing_field_name_158 __annonCompField40 ; atomic_t _count ; }; union __anonunion____missing_field_name_156 { unsigned long counters ; struct __anonstruct____missing_field_name_157 __annonCompField41 ; unsigned int active ; }; struct __anonstruct____missing_field_name_154 { union __anonunion____missing_field_name_155 __annonCompField38 ; union __anonunion____missing_field_name_156 __annonCompField42 ; }; struct __anonstruct____missing_field_name_161 { struct page *next ; int pages ; int pobjects ; }; struct slab; struct __anonstruct____missing_field_name_162 { compound_page_dtor *compound_dtor ; unsigned long compound_order ; }; union __anonunion____missing_field_name_160 { struct list_head lru ; struct __anonstruct____missing_field_name_161 __annonCompField44 ; struct slab *slab_page ; struct callback_head callback_head ; struct __anonstruct____missing_field_name_162 __annonCompField45 ; pgtable_t pmd_huge_pte ; }; union __anonunion____missing_field_name_163 { unsigned long private ; spinlock_t *ptl ; struct kmem_cache *slab_cache ; struct page *first_page ; }; struct page { unsigned long flags ; union __anonunion____missing_field_name_153 __annonCompField37 ; struct __anonstruct____missing_field_name_154 __annonCompField43 ; union __anonunion____missing_field_name_160 __annonCompField46 ; union __anonunion____missing_field_name_163 __annonCompField47 ; struct mem_cgroup *mem_cgroup ; }; struct page_frag { struct page *page ; __u32 offset ; __u32 size ; }; struct __anonstruct_shared_164 { struct rb_node rb ; unsigned long rb_subtree_last ; }; struct anon_vma; struct mempolicy; struct vm_area_struct { unsigned long vm_start ; unsigned long vm_end ; struct vm_area_struct *vm_next ; struct vm_area_struct *vm_prev ; struct rb_node vm_rb ; unsigned long rb_subtree_gap ; struct mm_struct *vm_mm ; pgprot_t vm_page_prot ; unsigned long vm_flags ; struct __anonstruct_shared_164 shared ; struct list_head anon_vma_chain ; struct anon_vma *anon_vma ; struct vm_operations_struct const *vm_ops ; unsigned long vm_pgoff ; struct file *vm_file ; void *vm_private_data ; struct mempolicy *vm_policy ; }; struct core_thread { struct task_struct *task ; struct core_thread *next ; }; struct core_state { atomic_t nr_threads ; struct core_thread dumper ; struct completion startup ; }; struct task_rss_stat { int events ; int count[3U] ; }; struct mm_rss_stat { atomic_long_t count[3U] ; }; struct kioctx_table; struct linux_binfmt; struct mmu_notifier_mm; struct mm_struct { struct vm_area_struct *mmap ; struct rb_root mm_rb ; u32 vmacache_seqnum ; unsigned long (*get_unmapped_area)(struct file * , unsigned long , unsigned long , unsigned long , unsigned long ) ; unsigned long mmap_base ; unsigned long mmap_legacy_base ; unsigned long task_size ; unsigned long highest_vm_end ; pgd_t *pgd ; atomic_t mm_users ; atomic_t mm_count ; atomic_long_t nr_ptes ; atomic_long_t nr_pmds ; int map_count ; spinlock_t page_table_lock ; struct rw_semaphore mmap_sem ; struct list_head mmlist ; unsigned long hiwater_rss ; unsigned long hiwater_vm ; unsigned long total_vm ; unsigned long locked_vm ; unsigned long pinned_vm ; unsigned long shared_vm ; unsigned long exec_vm ; unsigned long stack_vm ; unsigned long def_flags ; unsigned long start_code ; unsigned long end_code ; unsigned long start_data ; unsigned long end_data ; unsigned long start_brk ; unsigned long brk ; unsigned long start_stack ; unsigned long arg_start ; unsigned long arg_end ; unsigned long env_start ; unsigned long env_end ; unsigned long saved_auxv[46U] ; struct mm_rss_stat rss_stat ; struct linux_binfmt *binfmt ; cpumask_var_t cpu_vm_mask_var ; mm_context_t context ; unsigned long flags ; struct core_state *core_state ; spinlock_t ioctx_lock ; struct kioctx_table *ioctx_table ; struct task_struct *owner ; struct file *exe_file ; struct mmu_notifier_mm *mmu_notifier_mm ; struct cpumask cpumask_allocation ; unsigned long numa_next_scan ; unsigned long numa_scan_offset ; int numa_scan_seq ; bool tlb_flush_pending ; struct uprobes_state uprobes_state ; void *bd_addr ; }; typedef unsigned long cputime_t; struct sem_undo_list; struct sysv_sem { struct sem_undo_list *undo_list ; }; struct user_struct; struct sysv_shm { struct list_head shm_clist ; }; struct __anonstruct_sigset_t_166 { unsigned long sig[1U] ; }; typedef struct __anonstruct_sigset_t_166 sigset_t; struct siginfo; typedef void __signalfn_t(int ); typedef __signalfn_t *__sighandler_t; typedef void __restorefn_t(void); typedef __restorefn_t *__sigrestore_t; union sigval { int sival_int ; void *sival_ptr ; }; typedef union sigval sigval_t; struct __anonstruct__kill_168 { __kernel_pid_t _pid ; __kernel_uid32_t _uid ; }; struct __anonstruct__timer_169 { __kernel_timer_t _tid ; int _overrun ; char _pad[0U] ; sigval_t _sigval ; int _sys_private ; }; struct __anonstruct__rt_170 { __kernel_pid_t _pid ; __kernel_uid32_t _uid ; sigval_t _sigval ; }; struct __anonstruct__sigchld_171 { __kernel_pid_t _pid ; __kernel_uid32_t _uid ; int _status ; __kernel_clock_t _utime ; __kernel_clock_t _stime ; }; struct __anonstruct__addr_bnd_173 { void *_lower ; void *_upper ; }; struct __anonstruct__sigfault_172 { void *_addr ; short _addr_lsb ; struct __anonstruct__addr_bnd_173 _addr_bnd ; }; struct __anonstruct__sigpoll_174 { long _band ; int _fd ; }; struct __anonstruct__sigsys_175 { void *_call_addr ; int _syscall ; unsigned int _arch ; }; union __anonunion__sifields_167 { int _pad[28U] ; struct __anonstruct__kill_168 _kill ; struct __anonstruct__timer_169 _timer ; struct __anonstruct__rt_170 _rt ; struct __anonstruct__sigchld_171 _sigchld ; struct __anonstruct__sigfault_172 _sigfault ; struct __anonstruct__sigpoll_174 _sigpoll ; struct __anonstruct__sigsys_175 _sigsys ; }; struct siginfo { int si_signo ; int si_errno ; int si_code ; union __anonunion__sifields_167 _sifields ; }; typedef struct siginfo siginfo_t; struct sigpending { struct list_head list ; sigset_t signal ; }; struct sigaction { __sighandler_t sa_handler ; unsigned long sa_flags ; __sigrestore_t sa_restorer ; sigset_t sa_mask ; }; struct k_sigaction { struct sigaction sa ; }; enum pid_type { PIDTYPE_PID = 0, PIDTYPE_PGID = 1, PIDTYPE_SID = 2, PIDTYPE_MAX = 3 } ; struct pid_namespace; struct upid { int nr ; struct pid_namespace *ns ; struct hlist_node pid_chain ; }; struct pid { atomic_t count ; unsigned int level ; struct hlist_head tasks[3U] ; struct callback_head rcu ; struct upid numbers[1U] ; }; struct pid_link { struct hlist_node node ; struct pid *pid ; }; struct percpu_counter { raw_spinlock_t lock ; s64 count ; struct list_head list ; s32 *counters ; }; struct seccomp_filter; struct seccomp { int mode ; struct seccomp_filter *filter ; }; struct rt_mutex_waiter; struct rlimit { __kernel_ulong_t rlim_cur ; __kernel_ulong_t rlim_max ; }; struct timerqueue_node { struct rb_node node ; ktime_t expires ; }; struct timerqueue_head { struct rb_root head ; struct timerqueue_node *next ; }; struct hrtimer_clock_base; struct hrtimer_cpu_base; enum hrtimer_restart { HRTIMER_NORESTART = 0, HRTIMER_RESTART = 1 } ; struct hrtimer { struct timerqueue_node node ; ktime_t _softexpires ; enum hrtimer_restart (*function)(struct hrtimer * ) ; struct hrtimer_clock_base *base ; unsigned long state ; int start_pid ; void *start_site ; char start_comm[16U] ; }; struct hrtimer_clock_base { struct hrtimer_cpu_base *cpu_base ; int index ; clockid_t clockid ; struct timerqueue_head active ; ktime_t resolution ; ktime_t (*get_time)(void) ; ktime_t softirq_time ; ktime_t offset ; }; struct hrtimer_cpu_base { raw_spinlock_t lock ; unsigned int cpu ; unsigned int active_bases ; unsigned int clock_was_set ; ktime_t expires_next ; int in_hrtirq ; int hres_active ; int hang_detected ; unsigned long nr_events ; unsigned long nr_retries ; unsigned long nr_hangs ; ktime_t max_hang_time ; struct hrtimer_clock_base clock_base[4U] ; }; struct task_io_accounting { u64 rchar ; u64 wchar ; u64 syscr ; u64 syscw ; u64 read_bytes ; u64 write_bytes ; u64 cancelled_write_bytes ; }; struct latency_record { unsigned long backtrace[12U] ; unsigned int count ; unsigned long time ; unsigned long max ; }; struct nsproxy; struct assoc_array_ptr; struct assoc_array { struct assoc_array_ptr *root ; unsigned long nr_leaves_on_tree ; }; typedef int32_t key_serial_t; typedef uint32_t key_perm_t; struct key; struct signal_struct; struct cred; struct key_type; struct keyring_index_key { struct key_type *type ; char const *description ; size_t desc_len ; }; union __anonunion____missing_field_name_180 { struct list_head graveyard_link ; struct rb_node serial_node ; }; struct key_user; union __anonunion____missing_field_name_181 { time_t expiry ; time_t revoked_at ; }; struct __anonstruct____missing_field_name_183 { struct key_type *type ; char *description ; }; union __anonunion____missing_field_name_182 { struct keyring_index_key index_key ; struct __anonstruct____missing_field_name_183 __annonCompField52 ; }; union __anonunion_type_data_184 { struct list_head link ; unsigned long x[2U] ; void *p[2U] ; int reject_error ; }; union __anonunion_payload_186 { unsigned long value ; void *rcudata ; void *data ; void *data2[2U] ; }; union __anonunion____missing_field_name_185 { union __anonunion_payload_186 payload ; struct assoc_array keys ; }; struct key { atomic_t usage ; key_serial_t serial ; union __anonunion____missing_field_name_180 __annonCompField50 ; struct rw_semaphore sem ; struct key_user *user ; void *security ; union __anonunion____missing_field_name_181 __annonCompField51 ; time_t last_used_at ; kuid_t uid ; kgid_t gid ; key_perm_t perm ; unsigned short quotalen ; unsigned short datalen ; unsigned long flags ; union __anonunion____missing_field_name_182 __annonCompField53 ; union __anonunion_type_data_184 type_data ; union __anonunion____missing_field_name_185 __annonCompField54 ; }; struct audit_context; struct group_info { atomic_t usage ; int ngroups ; int nblocks ; kgid_t small_block[32U] ; kgid_t *blocks[0U] ; }; struct cred { atomic_t usage ; atomic_t subscribers ; void *put_addr ; unsigned int magic ; kuid_t uid ; kgid_t gid ; kuid_t suid ; kgid_t sgid ; kuid_t euid ; kgid_t egid ; kuid_t fsuid ; kgid_t fsgid ; unsigned int securebits ; kernel_cap_t cap_inheritable ; kernel_cap_t cap_permitted ; kernel_cap_t cap_effective ; kernel_cap_t cap_bset ; unsigned char jit_keyring ; struct key *session_keyring ; struct key *process_keyring ; struct key *thread_keyring ; struct key *request_key_auth ; void *security ; struct user_struct *user ; struct user_namespace *user_ns ; struct group_info *group_info ; struct callback_head rcu ; }; struct futex_pi_state; struct robust_list_head; struct bio_list; struct fs_struct; struct perf_event_context; struct blk_plug; struct cfs_rq; struct task_group; struct sighand_struct { atomic_t count ; struct k_sigaction action[64U] ; spinlock_t siglock ; wait_queue_head_t signalfd_wqh ; }; struct pacct_struct { int ac_flag ; long ac_exitcode ; unsigned long ac_mem ; cputime_t ac_utime ; cputime_t ac_stime ; unsigned long ac_minflt ; unsigned long ac_majflt ; }; struct cpu_itimer { cputime_t expires ; cputime_t incr ; u32 error ; u32 incr_error ; }; struct cputime { cputime_t utime ; cputime_t stime ; }; struct task_cputime { cputime_t utime ; cputime_t stime ; unsigned long long sum_exec_runtime ; }; struct thread_group_cputimer { struct task_cputime cputime ; int running ; raw_spinlock_t lock ; }; struct autogroup; struct tty_struct; struct taskstats; struct tty_audit_buf; struct signal_struct { atomic_t sigcnt ; atomic_t live ; int nr_threads ; struct list_head thread_head ; wait_queue_head_t wait_chldexit ; struct task_struct *curr_target ; struct sigpending shared_pending ; int group_exit_code ; int notify_count ; struct task_struct *group_exit_task ; int group_stop_count ; unsigned int flags ; unsigned char is_child_subreaper : 1 ; unsigned char has_child_subreaper : 1 ; int posix_timer_id ; struct list_head posix_timers ; struct hrtimer real_timer ; struct pid *leader_pid ; ktime_t it_real_incr ; struct cpu_itimer it[2U] ; struct thread_group_cputimer cputimer ; struct task_cputime cputime_expires ; struct list_head cpu_timers[3U] ; struct pid *tty_old_pgrp ; int leader ; struct tty_struct *tty ; struct autogroup *autogroup ; seqlock_t stats_lock ; cputime_t utime ; cputime_t stime ; cputime_t cutime ; cputime_t cstime ; cputime_t gtime ; cputime_t cgtime ; struct cputime prev_cputime ; unsigned long nvcsw ; unsigned long nivcsw ; unsigned long cnvcsw ; unsigned long cnivcsw ; unsigned long min_flt ; unsigned long maj_flt ; unsigned long cmin_flt ; unsigned long cmaj_flt ; unsigned long inblock ; unsigned long oublock ; unsigned long cinblock ; unsigned long coublock ; unsigned long maxrss ; unsigned long cmaxrss ; struct task_io_accounting ioac ; unsigned long long sum_sched_runtime ; struct rlimit rlim[16U] ; struct pacct_struct pacct ; struct taskstats *stats ; unsigned int audit_tty ; unsigned int audit_tty_log_passwd ; struct tty_audit_buf *tty_audit_buf ; struct rw_semaphore group_rwsem ; oom_flags_t oom_flags ; short oom_score_adj ; short oom_score_adj_min ; struct mutex cred_guard_mutex ; }; struct user_struct { atomic_t __count ; atomic_t processes ; atomic_t sigpending ; atomic_t inotify_watches ; atomic_t inotify_devs ; atomic_t fanotify_listeners ; atomic_long_t epoll_watches ; unsigned long mq_bytes ; unsigned long locked_shm ; struct key *uid_keyring ; struct key *session_keyring ; struct hlist_node uidhash_node ; kuid_t uid ; atomic_long_t locked_vm ; }; struct backing_dev_info; struct reclaim_state; struct sched_info { unsigned long pcount ; unsigned long long run_delay ; unsigned long long last_arrival ; unsigned long long last_queued ; }; struct task_delay_info { spinlock_t lock ; unsigned int flags ; u64 blkio_start ; u64 blkio_delay ; u64 swapin_delay ; u32 blkio_count ; u32 swapin_count ; u64 freepages_start ; u64 freepages_delay ; u32 freepages_count ; }; struct io_context; struct pipe_inode_info; struct load_weight { unsigned long weight ; u32 inv_weight ; }; struct sched_avg { u32 runnable_avg_sum ; u32 runnable_avg_period ; u64 last_runnable_update ; s64 decay_count ; unsigned long load_avg_contrib ; }; struct sched_statistics { u64 wait_start ; u64 wait_max ; u64 wait_count ; u64 wait_sum ; u64 iowait_count ; u64 iowait_sum ; u64 sleep_start ; u64 sleep_max ; s64 sum_sleep_runtime ; u64 block_start ; u64 block_max ; u64 exec_max ; u64 slice_max ; u64 nr_migrations_cold ; u64 nr_failed_migrations_affine ; u64 nr_failed_migrations_running ; u64 nr_failed_migrations_hot ; u64 nr_forced_migrations ; u64 nr_wakeups ; u64 nr_wakeups_sync ; u64 nr_wakeups_migrate ; u64 nr_wakeups_local ; u64 nr_wakeups_remote ; u64 nr_wakeups_affine ; u64 nr_wakeups_affine_attempts ; u64 nr_wakeups_passive ; u64 nr_wakeups_idle ; }; struct sched_entity { struct load_weight load ; struct rb_node run_node ; struct list_head group_node ; unsigned int on_rq ; u64 exec_start ; u64 sum_exec_runtime ; u64 vruntime ; u64 prev_sum_exec_runtime ; u64 nr_migrations ; struct sched_statistics statistics ; int depth ; struct sched_entity *parent ; struct cfs_rq *cfs_rq ; struct cfs_rq *my_q ; struct sched_avg avg ; }; struct rt_rq; struct sched_rt_entity { struct list_head run_list ; unsigned long timeout ; unsigned long watchdog_stamp ; unsigned int time_slice ; struct sched_rt_entity *back ; struct sched_rt_entity *parent ; struct rt_rq *rt_rq ; struct rt_rq *my_q ; }; struct sched_dl_entity { struct rb_node rb_node ; u64 dl_runtime ; u64 dl_deadline ; u64 dl_period ; u64 dl_bw ; s64 runtime ; u64 deadline ; unsigned int flags ; int dl_throttled ; int dl_new ; int dl_boosted ; int dl_yielded ; struct hrtimer dl_timer ; }; struct memcg_oom_info { struct mem_cgroup *memcg ; gfp_t gfp_mask ; int order ; unsigned char may_oom : 1 ; }; struct sched_class; struct files_struct; struct css_set; struct compat_robust_list_head; struct numa_group; struct ftrace_ret_stack; struct task_struct { long volatile state ; void *stack ; atomic_t usage ; unsigned int flags ; unsigned int ptrace ; struct llist_node wake_entry ; int on_cpu ; struct task_struct *last_wakee ; unsigned long wakee_flips ; unsigned long wakee_flip_decay_ts ; int wake_cpu ; int on_rq ; int prio ; int static_prio ; int normal_prio ; unsigned int rt_priority ; struct sched_class const *sched_class ; struct sched_entity se ; struct sched_rt_entity rt ; struct task_group *sched_task_group ; struct sched_dl_entity dl ; struct hlist_head preempt_notifiers ; unsigned int btrace_seq ; unsigned int policy ; int nr_cpus_allowed ; cpumask_t cpus_allowed ; unsigned long rcu_tasks_nvcsw ; bool rcu_tasks_holdout ; struct list_head rcu_tasks_holdout_list ; int rcu_tasks_idle_cpu ; struct sched_info sched_info ; struct list_head tasks ; struct plist_node pushable_tasks ; struct rb_node pushable_dl_tasks ; struct mm_struct *mm ; struct mm_struct *active_mm ; unsigned char brk_randomized : 1 ; u32 vmacache_seqnum ; struct vm_area_struct *vmacache[4U] ; struct task_rss_stat rss_stat ; int exit_state ; int exit_code ; int exit_signal ; int pdeath_signal ; unsigned int jobctl ; unsigned int personality ; unsigned char in_execve : 1 ; unsigned char in_iowait : 1 ; unsigned char sched_reset_on_fork : 1 ; unsigned char sched_contributes_to_load : 1 ; unsigned char memcg_kmem_skip_account : 1 ; unsigned long atomic_flags ; struct restart_block restart_block ; pid_t pid ; pid_t tgid ; struct task_struct *real_parent ; struct task_struct *parent ; struct list_head children ; struct list_head sibling ; struct task_struct *group_leader ; struct list_head ptraced ; struct list_head ptrace_entry ; struct pid_link pids[3U] ; struct list_head thread_group ; struct list_head thread_node ; struct completion *vfork_done ; int *set_child_tid ; int *clear_child_tid ; cputime_t utime ; cputime_t stime ; cputime_t utimescaled ; cputime_t stimescaled ; cputime_t gtime ; struct cputime prev_cputime ; unsigned long nvcsw ; unsigned long nivcsw ; u64 start_time ; u64 real_start_time ; unsigned long min_flt ; unsigned long maj_flt ; struct task_cputime cputime_expires ; struct list_head cpu_timers[3U] ; struct cred const *real_cred ; struct cred const *cred ; char comm[16U] ; int link_count ; int total_link_count ; struct sysv_sem sysvsem ; struct sysv_shm sysvshm ; unsigned long last_switch_count ; struct thread_struct thread ; struct fs_struct *fs ; struct files_struct *files ; struct nsproxy *nsproxy ; struct signal_struct *signal ; struct sighand_struct *sighand ; sigset_t blocked ; sigset_t real_blocked ; sigset_t saved_sigmask ; struct sigpending pending ; unsigned long sas_ss_sp ; size_t sas_ss_size ; int (*notifier)(void * ) ; void *notifier_data ; sigset_t *notifier_mask ; struct callback_head *task_works ; struct audit_context *audit_context ; kuid_t loginuid ; unsigned int sessionid ; struct seccomp seccomp ; u32 parent_exec_id ; u32 self_exec_id ; spinlock_t alloc_lock ; raw_spinlock_t pi_lock ; struct rb_root pi_waiters ; struct rb_node *pi_waiters_leftmost ; struct rt_mutex_waiter *pi_blocked_on ; struct mutex_waiter *blocked_on ; unsigned int irq_events ; unsigned long hardirq_enable_ip ; unsigned long hardirq_disable_ip ; unsigned int hardirq_enable_event ; unsigned int hardirq_disable_event ; int hardirqs_enabled ; int hardirq_context ; unsigned long softirq_disable_ip ; unsigned long softirq_enable_ip ; unsigned int softirq_disable_event ; unsigned int softirq_enable_event ; int softirqs_enabled ; int softirq_context ; u64 curr_chain_key ; int lockdep_depth ; unsigned int lockdep_recursion ; struct held_lock held_locks[48U] ; gfp_t lockdep_reclaim_gfp ; void *journal_info ; struct bio_list *bio_list ; struct blk_plug *plug ; struct reclaim_state *reclaim_state ; struct backing_dev_info *backing_dev_info ; struct io_context *io_context ; unsigned long ptrace_message ; siginfo_t *last_siginfo ; struct task_io_accounting ioac ; u64 acct_rss_mem1 ; u64 acct_vm_mem1 ; cputime_t acct_timexpd ; nodemask_t mems_allowed ; seqcount_t mems_allowed_seq ; int cpuset_mem_spread_rotor ; int cpuset_slab_spread_rotor ; struct css_set *cgroups ; struct list_head cg_list ; struct robust_list_head *robust_list ; struct compat_robust_list_head *compat_robust_list ; struct list_head pi_state_list ; struct futex_pi_state *pi_state_cache ; struct perf_event_context *perf_event_ctxp[2U] ; struct mutex perf_event_mutex ; struct list_head perf_event_list ; struct mempolicy *mempolicy ; short il_next ; short pref_node_fork ; int numa_scan_seq ; unsigned int numa_scan_period ; unsigned int numa_scan_period_max ; int numa_preferred_nid ; unsigned long numa_migrate_retry ; u64 node_stamp ; u64 last_task_numa_placement ; u64 last_sum_exec_runtime ; struct callback_head numa_work ; struct list_head numa_entry ; struct numa_group *numa_group ; unsigned long *numa_faults ; unsigned long total_numa_faults ; unsigned long numa_faults_locality[2U] ; unsigned long numa_pages_migrated ; struct callback_head rcu ; struct pipe_inode_info *splice_pipe ; struct page_frag task_frag ; struct task_delay_info *delays ; int make_it_fail ; int nr_dirtied ; int nr_dirtied_pause ; unsigned long dirty_paused_when ; int latency_record_count ; struct latency_record latency_record[32U] ; unsigned long timer_slack_ns ; unsigned long default_timer_slack_ns ; unsigned int kasan_depth ; int curr_ret_stack ; struct ftrace_ret_stack *ret_stack ; unsigned long long ftrace_timestamp ; atomic_t trace_overrun ; atomic_t tracing_graph_pause ; unsigned long trace ; unsigned long trace_recursion ; struct memcg_oom_info memcg_oom ; struct uprobe_task *utask ; unsigned int sequential_io ; unsigned int sequential_io_avg ; unsigned long task_state_change ; }; struct hotplug_slot; struct pci_slot { struct pci_bus *bus ; struct list_head list ; struct hotplug_slot *hotplug ; unsigned char number ; struct kobject kobj ; }; typedef int pci_power_t; typedef unsigned int pci_channel_state_t; enum pci_channel_state { pci_channel_io_normal = 1, pci_channel_io_frozen = 2, pci_channel_io_perm_failure = 3 } ; typedef unsigned short pci_dev_flags_t; typedef unsigned short pci_bus_flags_t; struct pcie_link_state; struct pci_vpd; struct pci_sriov; struct pci_ats; struct proc_dir_entry; struct pci_driver; union __anonunion____missing_field_name_191 { struct pci_sriov *sriov ; struct pci_dev *physfn ; }; struct pci_dev { struct list_head bus_list ; struct pci_bus *bus ; struct pci_bus *subordinate ; void *sysdata ; struct proc_dir_entry *procent ; struct pci_slot *slot ; unsigned int devfn ; unsigned short vendor ; unsigned short device ; unsigned short subsystem_vendor ; unsigned short subsystem_device ; unsigned int class ; u8 revision ; u8 hdr_type ; u8 pcie_cap ; u8 msi_cap ; u8 msix_cap ; unsigned char pcie_mpss : 3 ; u8 rom_base_reg ; u8 pin ; u16 pcie_flags_reg ; u8 dma_alias_devfn ; struct pci_driver *driver ; u64 dma_mask ; struct device_dma_parameters dma_parms ; pci_power_t current_state ; u8 pm_cap ; unsigned char pme_support : 5 ; unsigned char pme_interrupt : 1 ; unsigned char pme_poll : 1 ; unsigned char d1_support : 1 ; unsigned char d2_support : 1 ; unsigned char no_d1d2 : 1 ; unsigned char no_d3cold : 1 ; unsigned char d3cold_allowed : 1 ; unsigned char mmio_always_on : 1 ; unsigned char wakeup_prepared : 1 ; unsigned char runtime_d3cold : 1 ; unsigned char ignore_hotplug : 1 ; unsigned int d3_delay ; unsigned int d3cold_delay ; struct pcie_link_state *link_state ; pci_channel_state_t error_state ; struct device dev ; int cfg_size ; unsigned int irq ; struct resource resource[17U] ; bool match_driver ; unsigned char transparent : 1 ; unsigned char multifunction : 1 ; unsigned char is_added : 1 ; unsigned char is_busmaster : 1 ; unsigned char no_msi : 1 ; unsigned char no_64bit_msi : 1 ; unsigned char block_cfg_access : 1 ; unsigned char broken_parity_status : 1 ; unsigned char irq_reroute_variant : 2 ; unsigned char msi_enabled : 1 ; unsigned char msix_enabled : 1 ; unsigned char ari_enabled : 1 ; unsigned char is_managed : 1 ; unsigned char needs_freset : 1 ; unsigned char state_saved : 1 ; unsigned char is_physfn : 1 ; unsigned char is_virtfn : 1 ; unsigned char reset_fn : 1 ; unsigned char is_hotplug_bridge : 1 ; unsigned char __aer_firmware_first_valid : 1 ; unsigned char __aer_firmware_first : 1 ; unsigned char broken_intx_masking : 1 ; unsigned char io_window_1k : 1 ; unsigned char irq_managed : 1 ; pci_dev_flags_t dev_flags ; atomic_t enable_cnt ; u32 saved_config_space[16U] ; struct hlist_head saved_cap_space ; struct bin_attribute *rom_attr ; int rom_attr_enabled ; struct bin_attribute *res_attr[17U] ; struct bin_attribute *res_attr_wc[17U] ; struct list_head msi_list ; struct attribute_group const **msi_irq_groups ; struct pci_vpd *vpd ; union __anonunion____missing_field_name_191 __annonCompField58 ; struct pci_ats *ats ; phys_addr_t rom ; size_t romlen ; char *driver_override ; }; struct pci_ops; struct msi_controller; struct pci_bus { struct list_head node ; struct pci_bus *parent ; struct list_head children ; struct list_head devices ; struct pci_dev *self ; struct list_head slots ; struct resource *resource[4U] ; struct list_head resources ; struct resource busn_res ; struct pci_ops *ops ; struct msi_controller *msi ; void *sysdata ; struct proc_dir_entry *procdir ; unsigned char number ; unsigned char primary ; unsigned char max_bus_speed ; unsigned char cur_bus_speed ; char name[48U] ; unsigned short bridge_ctl ; pci_bus_flags_t bus_flags ; struct device *bridge ; struct device dev ; struct bin_attribute *legacy_io ; struct bin_attribute *legacy_mem ; unsigned char is_added : 1 ; }; struct pci_ops { void *(*map_bus)(struct pci_bus * , unsigned int , int ) ; int (*read)(struct pci_bus * , unsigned int , int , int , u32 * ) ; int (*write)(struct pci_bus * , unsigned int , int , int , u32 ) ; }; struct pci_dynids { spinlock_t lock ; struct list_head list ; }; typedef unsigned int pci_ers_result_t; struct pci_error_handlers { pci_ers_result_t (*error_detected)(struct pci_dev * , enum pci_channel_state ) ; pci_ers_result_t (*mmio_enabled)(struct pci_dev * ) ; pci_ers_result_t (*link_reset)(struct pci_dev * ) ; pci_ers_result_t (*slot_reset)(struct pci_dev * ) ; void (*reset_notify)(struct pci_dev * , bool ) ; void (*resume)(struct pci_dev * ) ; }; struct pci_driver { struct list_head node ; char const *name ; struct pci_device_id const *id_table ; int (*probe)(struct pci_dev * , struct pci_device_id const * ) ; void (*remove)(struct pci_dev * ) ; int (*suspend)(struct pci_dev * , pm_message_t ) ; int (*suspend_late)(struct pci_dev * , pm_message_t ) ; int (*resume_early)(struct pci_dev * ) ; int (*resume)(struct pci_dev * ) ; void (*shutdown)(struct pci_dev * ) ; int (*sriov_configure)(struct pci_dev * , int ) ; struct pci_error_handlers const *err_handler ; struct device_driver driver ; struct pci_dynids dynids ; }; struct scatterlist { unsigned long sg_magic ; unsigned long page_link ; unsigned int offset ; unsigned int length ; dma_addr_t dma_address ; unsigned int dma_length ; }; struct msix_entry { u32 vector ; u16 entry ; }; struct shrink_control { gfp_t gfp_mask ; unsigned long nr_to_scan ; int nid ; struct mem_cgroup *memcg ; }; struct shrinker { unsigned long (*count_objects)(struct shrinker * , struct shrink_control * ) ; unsigned long (*scan_objects)(struct shrinker * , struct shrink_control * ) ; int seeks ; long batch ; unsigned long flags ; struct list_head list ; atomic_long_t *nr_deferred ; }; struct file_ra_state; struct writeback_control; struct vm_fault { unsigned int flags ; unsigned long pgoff ; void *virtual_address ; struct page *cow_page ; struct page *page ; unsigned long max_pgoff ; pte_t *pte ; }; struct vm_operations_struct { void (*open)(struct vm_area_struct * ) ; void (*close)(struct vm_area_struct * ) ; int (*fault)(struct vm_area_struct * , struct vm_fault * ) ; void (*map_pages)(struct vm_area_struct * , struct vm_fault * ) ; int (*page_mkwrite)(struct vm_area_struct * , struct vm_fault * ) ; int (*access)(struct vm_area_struct * , unsigned long , void * , int , int ) ; char const *(*name)(struct vm_area_struct * ) ; int (*set_policy)(struct vm_area_struct * , struct mempolicy * ) ; struct mempolicy *(*get_policy)(struct vm_area_struct * , unsigned long ) ; struct page *(*find_special_page)(struct vm_area_struct * , unsigned long ) ; }; struct dma_attrs { unsigned long flags[1U] ; }; enum dma_data_direction { DMA_BIDIRECTIONAL = 0, DMA_TO_DEVICE = 1, DMA_FROM_DEVICE = 2, DMA_NONE = 3 } ; struct sg_table { struct scatterlist *sgl ; unsigned int nents ; unsigned int orig_nents ; }; struct dma_map_ops { void *(*alloc)(struct device * , size_t , dma_addr_t * , gfp_t , struct dma_attrs * ) ; void (*free)(struct device * , size_t , void * , dma_addr_t , struct dma_attrs * ) ; int (*mmap)(struct device * , struct vm_area_struct * , void * , dma_addr_t , size_t , struct dma_attrs * ) ; int (*get_sgtable)(struct device * , struct sg_table * , void * , dma_addr_t , size_t , struct dma_attrs * ) ; dma_addr_t (*map_page)(struct device * , struct page * , unsigned long , size_t , enum dma_data_direction , struct dma_attrs * ) ; void (*unmap_page)(struct device * , dma_addr_t , size_t , enum dma_data_direction , struct dma_attrs * ) ; int (*map_sg)(struct device * , struct scatterlist * , int , enum dma_data_direction , struct dma_attrs * ) ; void (*unmap_sg)(struct device * , struct scatterlist * , int , enum dma_data_direction , struct dma_attrs * ) ; void (*sync_single_for_cpu)(struct device * , dma_addr_t , size_t , enum dma_data_direction ) ; void (*sync_single_for_device)(struct device * , dma_addr_t , size_t , enum dma_data_direction ) ; void (*sync_sg_for_cpu)(struct device * , struct scatterlist * , int , enum dma_data_direction ) ; void (*sync_sg_for_device)(struct device * , struct scatterlist * , int , enum dma_data_direction ) ; int (*mapping_error)(struct device * , dma_addr_t ) ; int (*dma_supported)(struct device * , u64 ) ; int (*set_dma_mask)(struct device * , u64 ) ; int is_phys ; }; struct hlist_bl_node; struct hlist_bl_head { struct hlist_bl_node *first ; }; struct hlist_bl_node { struct hlist_bl_node *next ; struct hlist_bl_node **pprev ; }; struct __anonstruct____missing_field_name_193 { spinlock_t lock ; int count ; }; union __anonunion____missing_field_name_192 { struct __anonstruct____missing_field_name_193 __annonCompField59 ; }; struct lockref { union __anonunion____missing_field_name_192 __annonCompField60 ; }; struct vfsmount; struct __anonstruct____missing_field_name_195 { u32 hash ; u32 len ; }; union __anonunion____missing_field_name_194 { struct __anonstruct____missing_field_name_195 __annonCompField61 ; u64 hash_len ; }; struct qstr { union __anonunion____missing_field_name_194 __annonCompField62 ; unsigned char const *name ; }; struct dentry_operations; union __anonunion_d_u_196 { struct hlist_node d_alias ; struct callback_head d_rcu ; }; struct dentry { unsigned int d_flags ; seqcount_t d_seq ; struct hlist_bl_node d_hash ; struct dentry *d_parent ; struct qstr d_name ; struct inode *d_inode ; unsigned char d_iname[32U] ; struct lockref d_lockref ; struct dentry_operations const *d_op ; struct super_block *d_sb ; unsigned long d_time ; void *d_fsdata ; struct list_head d_lru ; struct list_head d_child ; struct list_head d_subdirs ; union __anonunion_d_u_196 d_u ; }; struct dentry_operations { int (*d_revalidate)(struct dentry * , unsigned int ) ; int (*d_weak_revalidate)(struct dentry * , unsigned int ) ; int (*d_hash)(struct dentry const * , struct qstr * ) ; int (*d_compare)(struct dentry const * , struct dentry const * , unsigned int , char const * , struct qstr const * ) ; int (*d_delete)(struct dentry const * ) ; void (*d_release)(struct dentry * ) ; void (*d_prune)(struct dentry * ) ; void (*d_iput)(struct dentry * , struct inode * ) ; char *(*d_dname)(struct dentry * , char * , int ) ; struct vfsmount *(*d_automount)(struct path * ) ; int (*d_manage)(struct dentry * , bool ) ; }; struct path { struct vfsmount *mnt ; struct dentry *dentry ; }; struct list_lru_one { struct list_head list ; long nr_items ; }; struct list_lru_memcg { struct list_lru_one *lru[0U] ; }; struct list_lru_node { spinlock_t lock ; struct list_lru_one lru ; struct list_lru_memcg *memcg_lrus ; }; struct list_lru { struct list_lru_node *node ; struct list_head list ; }; struct __anonstruct____missing_field_name_198 { struct radix_tree_node *parent ; void *private_data ; }; union __anonunion____missing_field_name_197 { struct __anonstruct____missing_field_name_198 __annonCompField63 ; struct callback_head callback_head ; }; struct radix_tree_node { unsigned int path ; unsigned int count ; union __anonunion____missing_field_name_197 __annonCompField64 ; struct list_head private_list ; void *slots[64U] ; unsigned long tags[3U][1U] ; }; struct radix_tree_root { unsigned int height ; gfp_t gfp_mask ; struct radix_tree_node *rnode ; }; struct fiemap_extent { __u64 fe_logical ; __u64 fe_physical ; __u64 fe_length ; __u64 fe_reserved64[2U] ; __u32 fe_flags ; __u32 fe_reserved[3U] ; }; enum migrate_mode { MIGRATE_ASYNC = 0, MIGRATE_SYNC_LIGHT = 1, MIGRATE_SYNC = 2 } ; struct bio_set; struct bio; struct bio_integrity_payload; struct block_device; struct cgroup_subsys_state; typedef void bio_end_io_t(struct bio * , int ); struct bio_vec { struct page *bv_page ; unsigned int bv_len ; unsigned int bv_offset ; }; struct bvec_iter { sector_t bi_sector ; unsigned int bi_size ; unsigned int bi_idx ; unsigned int bi_bvec_done ; }; union __anonunion____missing_field_name_199 { struct bio_integrity_payload *bi_integrity ; }; struct bio { struct bio *bi_next ; struct block_device *bi_bdev ; unsigned long bi_flags ; unsigned long bi_rw ; struct bvec_iter bi_iter ; unsigned int bi_phys_segments ; unsigned int bi_seg_front_size ; unsigned int bi_seg_back_size ; atomic_t bi_remaining ; bio_end_io_t *bi_end_io ; void *bi_private ; struct io_context *bi_ioc ; struct cgroup_subsys_state *bi_css ; union __anonunion____missing_field_name_199 __annonCompField65 ; unsigned short bi_vcnt ; unsigned short bi_max_vecs ; atomic_t bi_cnt ; struct bio_vec *bi_io_vec ; struct bio_set *bi_pool ; struct bio_vec bi_inline_vecs[0U] ; }; struct export_operations; struct hd_geometry; struct iovec; struct nameidata; struct kiocb; struct poll_table_struct; struct kstatfs; struct swap_info_struct; struct iov_iter; struct iattr { unsigned int ia_valid ; umode_t ia_mode ; kuid_t ia_uid ; kgid_t ia_gid ; loff_t ia_size ; struct timespec ia_atime ; struct timespec ia_mtime ; struct timespec ia_ctime ; struct file *ia_file ; }; struct fs_qfilestat { __u64 qfs_ino ; __u64 qfs_nblks ; __u32 qfs_nextents ; }; typedef struct fs_qfilestat fs_qfilestat_t; struct fs_quota_stat { __s8 qs_version ; __u16 qs_flags ; __s8 qs_pad ; fs_qfilestat_t qs_uquota ; fs_qfilestat_t qs_gquota ; __u32 qs_incoredqs ; __s32 qs_btimelimit ; __s32 qs_itimelimit ; __s32 qs_rtbtimelimit ; __u16 qs_bwarnlimit ; __u16 qs_iwarnlimit ; }; struct fs_qfilestatv { __u64 qfs_ino ; __u64 qfs_nblks ; __u32 qfs_nextents ; __u32 qfs_pad ; }; struct fs_quota_statv { __s8 qs_version ; __u8 qs_pad1 ; __u16 qs_flags ; __u32 qs_incoredqs ; struct fs_qfilestatv qs_uquota ; struct fs_qfilestatv qs_gquota ; struct fs_qfilestatv qs_pquota ; __s32 qs_btimelimit ; __s32 qs_itimelimit ; __s32 qs_rtbtimelimit ; __u16 qs_bwarnlimit ; __u16 qs_iwarnlimit ; __u64 qs_pad2[8U] ; }; struct dquot; typedef __kernel_uid32_t projid_t; struct __anonstruct_kprojid_t_200 { projid_t val ; }; typedef struct __anonstruct_kprojid_t_200 kprojid_t; struct if_dqinfo { __u64 dqi_bgrace ; __u64 dqi_igrace ; __u32 dqi_flags ; __u32 dqi_valid ; }; enum quota_type { USRQUOTA = 0, GRPQUOTA = 1, PRJQUOTA = 2 } ; typedef long long qsize_t; union __anonunion____missing_field_name_201 { kuid_t uid ; kgid_t gid ; kprojid_t projid ; }; struct kqid { union __anonunion____missing_field_name_201 __annonCompField66 ; enum quota_type type ; }; struct mem_dqblk { qsize_t dqb_bhardlimit ; qsize_t dqb_bsoftlimit ; qsize_t dqb_curspace ; qsize_t dqb_rsvspace ; qsize_t dqb_ihardlimit ; qsize_t dqb_isoftlimit ; qsize_t dqb_curinodes ; time_t dqb_btime ; time_t dqb_itime ; }; struct quota_format_type; struct mem_dqinfo { struct quota_format_type *dqi_format ; int dqi_fmt_id ; struct list_head dqi_dirty_list ; unsigned long dqi_flags ; unsigned int dqi_bgrace ; unsigned int dqi_igrace ; qsize_t dqi_max_spc_limit ; qsize_t dqi_max_ino_limit ; void *dqi_priv ; }; struct dquot { struct hlist_node dq_hash ; struct list_head dq_inuse ; struct list_head dq_free ; struct list_head dq_dirty ; struct mutex dq_lock ; atomic_t dq_count ; wait_queue_head_t dq_wait_unused ; struct super_block *dq_sb ; struct kqid dq_id ; loff_t dq_off ; unsigned long dq_flags ; struct mem_dqblk dq_dqb ; }; struct quota_format_ops { int (*check_quota_file)(struct super_block * , int ) ; int (*read_file_info)(struct super_block * , int ) ; int (*write_file_info)(struct super_block * , int ) ; int (*free_file_info)(struct super_block * , int ) ; int (*read_dqblk)(struct dquot * ) ; int (*commit_dqblk)(struct dquot * ) ; int (*release_dqblk)(struct dquot * ) ; }; struct dquot_operations { int (*write_dquot)(struct dquot * ) ; struct dquot *(*alloc_dquot)(struct super_block * , int ) ; void (*destroy_dquot)(struct dquot * ) ; int (*acquire_dquot)(struct dquot * ) ; int (*release_dquot)(struct dquot * ) ; int (*mark_dirty)(struct dquot * ) ; int (*write_info)(struct super_block * , int ) ; qsize_t *(*get_reserved_space)(struct inode * ) ; }; struct qc_dqblk { int d_fieldmask ; u64 d_spc_hardlimit ; u64 d_spc_softlimit ; u64 d_ino_hardlimit ; u64 d_ino_softlimit ; u64 d_space ; u64 d_ino_count ; s64 d_ino_timer ; s64 d_spc_timer ; int d_ino_warns ; int d_spc_warns ; u64 d_rt_spc_hardlimit ; u64 d_rt_spc_softlimit ; u64 d_rt_space ; s64 d_rt_spc_timer ; int d_rt_spc_warns ; }; struct quotactl_ops { int (*quota_on)(struct super_block * , int , int , struct path * ) ; int (*quota_off)(struct super_block * , int ) ; int (*quota_enable)(struct super_block * , unsigned int ) ; int (*quota_disable)(struct super_block * , unsigned int ) ; int (*quota_sync)(struct super_block * , int ) ; int (*get_info)(struct super_block * , int , struct if_dqinfo * ) ; int (*set_info)(struct super_block * , int , struct if_dqinfo * ) ; int (*get_dqblk)(struct super_block * , struct kqid , struct qc_dqblk * ) ; int (*set_dqblk)(struct super_block * , struct kqid , struct qc_dqblk * ) ; int (*get_xstate)(struct super_block * , struct fs_quota_stat * ) ; int (*get_xstatev)(struct super_block * , struct fs_quota_statv * ) ; int (*rm_xquota)(struct super_block * , unsigned int ) ; }; struct quota_format_type { int qf_fmt_id ; struct quota_format_ops const *qf_ops ; struct module *qf_owner ; struct quota_format_type *qf_next ; }; struct quota_info { unsigned int flags ; struct mutex dqio_mutex ; struct mutex dqonoff_mutex ; struct inode *files[2U] ; struct mem_dqinfo info[2U] ; struct quota_format_ops const *ops[2U] ; }; struct address_space_operations { int (*writepage)(struct page * , struct writeback_control * ) ; int (*readpage)(struct file * , struct page * ) ; int (*writepages)(struct address_space * , struct writeback_control * ) ; int (*set_page_dirty)(struct page * ) ; int (*readpages)(struct file * , struct address_space * , struct list_head * , unsigned int ) ; int (*write_begin)(struct file * , struct address_space * , loff_t , unsigned int , unsigned int , struct page ** , void ** ) ; int (*write_end)(struct file * , struct address_space * , loff_t , unsigned int , unsigned int , struct page * , void * ) ; sector_t (*bmap)(struct address_space * , sector_t ) ; void (*invalidatepage)(struct page * , unsigned int , unsigned int ) ; int (*releasepage)(struct page * , gfp_t ) ; void (*freepage)(struct page * ) ; ssize_t (*direct_IO)(int , struct kiocb * , struct iov_iter * , loff_t ) ; int (*migratepage)(struct address_space * , struct page * , struct page * , enum migrate_mode ) ; int (*launder_page)(struct page * ) ; int (*is_partially_uptodate)(struct page * , unsigned long , unsigned long ) ; void (*is_dirty_writeback)(struct page * , bool * , bool * ) ; int (*error_remove_page)(struct address_space * , struct page * ) ; int (*swap_activate)(struct swap_info_struct * , struct file * , sector_t * ) ; void (*swap_deactivate)(struct file * ) ; }; struct address_space { struct inode *host ; struct radix_tree_root page_tree ; spinlock_t tree_lock ; atomic_t i_mmap_writable ; struct rb_root i_mmap ; struct rw_semaphore i_mmap_rwsem ; unsigned long nrpages ; unsigned long nrshadows ; unsigned long writeback_index ; struct address_space_operations const *a_ops ; unsigned long flags ; spinlock_t private_lock ; struct list_head private_list ; void *private_data ; }; struct hd_struct; struct block_device { dev_t bd_dev ; int bd_openers ; struct inode *bd_inode ; struct super_block *bd_super ; struct mutex bd_mutex ; struct list_head bd_inodes ; void *bd_claiming ; void *bd_holder ; int bd_holders ; bool bd_write_holder ; struct list_head bd_holder_disks ; struct block_device *bd_contains ; unsigned int bd_block_size ; struct hd_struct *bd_part ; unsigned int bd_part_count ; int bd_invalidated ; struct gendisk *bd_disk ; struct request_queue *bd_queue ; struct list_head bd_list ; unsigned long bd_private ; int bd_fsfreeze_count ; struct mutex bd_fsfreeze_mutex ; }; struct posix_acl; struct inode_operations; union __anonunion____missing_field_name_204 { unsigned int const i_nlink ; unsigned int __i_nlink ; }; union __anonunion____missing_field_name_205 { struct hlist_head i_dentry ; struct callback_head i_rcu ; }; struct file_lock_context; struct cdev; union __anonunion____missing_field_name_206 { struct pipe_inode_info *i_pipe ; struct block_device *i_bdev ; struct cdev *i_cdev ; }; struct inode { umode_t i_mode ; unsigned short i_opflags ; kuid_t i_uid ; kgid_t i_gid ; unsigned int i_flags ; struct posix_acl *i_acl ; struct posix_acl *i_default_acl ; struct inode_operations const *i_op ; struct super_block *i_sb ; struct address_space *i_mapping ; void *i_security ; unsigned long i_ino ; union __anonunion____missing_field_name_204 __annonCompField67 ; dev_t i_rdev ; loff_t i_size ; struct timespec i_atime ; struct timespec i_mtime ; struct timespec i_ctime ; spinlock_t i_lock ; unsigned short i_bytes ; unsigned int i_blkbits ; blkcnt_t i_blocks ; unsigned long i_state ; struct mutex i_mutex ; unsigned long dirtied_when ; struct hlist_node i_hash ; struct list_head i_wb_list ; struct list_head i_lru ; struct list_head i_sb_list ; union __anonunion____missing_field_name_205 __annonCompField68 ; u64 i_version ; atomic_t i_count ; atomic_t i_dio_count ; atomic_t i_writecount ; atomic_t i_readcount ; struct file_operations const *i_fop ; struct file_lock_context *i_flctx ; struct address_space i_data ; struct list_head i_devices ; union __anonunion____missing_field_name_206 __annonCompField69 ; __u32 i_generation ; __u32 i_fsnotify_mask ; struct hlist_head i_fsnotify_marks ; void *i_private ; }; struct fown_struct { rwlock_t lock ; struct pid *pid ; enum pid_type pid_type ; kuid_t uid ; kuid_t euid ; int signum ; }; struct file_ra_state { unsigned long start ; unsigned int size ; unsigned int async_size ; unsigned int ra_pages ; unsigned int mmap_miss ; loff_t prev_pos ; }; union __anonunion_f_u_207 { struct llist_node fu_llist ; struct callback_head fu_rcuhead ; }; struct file { union __anonunion_f_u_207 f_u ; struct path f_path ; struct inode *f_inode ; struct file_operations const *f_op ; spinlock_t f_lock ; atomic_long_t f_count ; unsigned int f_flags ; fmode_t f_mode ; struct mutex f_pos_lock ; loff_t f_pos ; struct fown_struct f_owner ; struct cred const *f_cred ; struct file_ra_state f_ra ; u64 f_version ; void *f_security ; void *private_data ; struct list_head f_ep_links ; struct list_head f_tfile_llink ; struct address_space *f_mapping ; }; typedef void *fl_owner_t; struct file_lock; struct file_lock_operations { void (*fl_copy_lock)(struct file_lock * , struct file_lock * ) ; void (*fl_release_private)(struct file_lock * ) ; }; struct lock_manager_operations { int (*lm_compare_owner)(struct file_lock * , struct file_lock * ) ; unsigned long (*lm_owner_key)(struct file_lock * ) ; void (*lm_get_owner)(struct file_lock * , struct file_lock * ) ; void (*lm_put_owner)(struct file_lock * ) ; void (*lm_notify)(struct file_lock * ) ; int (*lm_grant)(struct file_lock * , int ) ; bool (*lm_break)(struct file_lock * ) ; int (*lm_change)(struct file_lock * , int , struct list_head * ) ; void (*lm_setup)(struct file_lock * , void ** ) ; }; struct nlm_lockowner; struct nfs_lock_info { u32 state ; struct nlm_lockowner *owner ; struct list_head list ; }; struct nfs4_lock_state; struct nfs4_lock_info { struct nfs4_lock_state *owner ; }; struct fasync_struct; struct __anonstruct_afs_209 { struct list_head link ; int state ; }; union __anonunion_fl_u_208 { struct nfs_lock_info nfs_fl ; struct nfs4_lock_info nfs4_fl ; struct __anonstruct_afs_209 afs ; }; struct file_lock { struct file_lock *fl_next ; struct list_head fl_list ; struct hlist_node fl_link ; struct list_head fl_block ; fl_owner_t fl_owner ; unsigned int fl_flags ; unsigned char fl_type ; unsigned int fl_pid ; int fl_link_cpu ; struct pid *fl_nspid ; wait_queue_head_t fl_wait ; struct file *fl_file ; loff_t fl_start ; loff_t fl_end ; struct fasync_struct *fl_fasync ; unsigned long fl_break_time ; unsigned long fl_downgrade_time ; struct file_lock_operations const *fl_ops ; struct lock_manager_operations const *fl_lmops ; union __anonunion_fl_u_208 fl_u ; }; struct file_lock_context { spinlock_t flc_lock ; struct list_head flc_flock ; struct list_head flc_posix ; struct list_head flc_lease ; }; struct fasync_struct { spinlock_t fa_lock ; int magic ; int fa_fd ; struct fasync_struct *fa_next ; struct file *fa_file ; struct callback_head fa_rcu ; }; struct sb_writers { struct percpu_counter counter[3U] ; wait_queue_head_t wait ; int frozen ; wait_queue_head_t wait_unfrozen ; struct lockdep_map lock_map[3U] ; }; struct super_operations; struct xattr_handler; struct mtd_info; struct super_block { struct list_head s_list ; dev_t s_dev ; unsigned char s_blocksize_bits ; unsigned long s_blocksize ; loff_t s_maxbytes ; struct file_system_type *s_type ; struct super_operations const *s_op ; struct dquot_operations const *dq_op ; struct quotactl_ops const *s_qcop ; struct export_operations const *s_export_op ; unsigned long s_flags ; unsigned long s_magic ; struct dentry *s_root ; struct rw_semaphore s_umount ; int s_count ; atomic_t s_active ; void *s_security ; struct xattr_handler const **s_xattr ; struct list_head s_inodes ; struct hlist_bl_head s_anon ; struct list_head s_mounts ; struct block_device *s_bdev ; struct backing_dev_info *s_bdi ; struct mtd_info *s_mtd ; struct hlist_node s_instances ; unsigned int s_quota_types ; struct quota_info s_dquot ; struct sb_writers s_writers ; char s_id[32U] ; u8 s_uuid[16U] ; void *s_fs_info ; unsigned int s_max_links ; fmode_t s_mode ; u32 s_time_gran ; struct mutex s_vfs_rename_mutex ; char *s_subtype ; char *s_options ; struct dentry_operations const *s_d_op ; int cleancache_poolid ; struct shrinker s_shrink ; atomic_long_t s_remove_count ; int s_readonly_remount ; struct workqueue_struct *s_dio_done_wq ; struct hlist_head s_pins ; struct list_lru s_dentry_lru ; struct list_lru s_inode_lru ; struct callback_head rcu ; int s_stack_depth ; }; struct fiemap_extent_info { unsigned int fi_flags ; unsigned int fi_extents_mapped ; unsigned int fi_extents_max ; struct fiemap_extent *fi_extents_start ; }; struct dir_context; struct dir_context { int (*actor)(struct dir_context * , char const * , int , loff_t , u64 , unsigned int ) ; loff_t pos ; }; struct block_device_operations; struct file_operations { struct module *owner ; loff_t (*llseek)(struct file * , loff_t , int ) ; ssize_t (*read)(struct file * , char * , size_t , loff_t * ) ; ssize_t (*write)(struct file * , char const * , size_t , loff_t * ) ; ssize_t (*aio_read)(struct kiocb * , struct iovec const * , unsigned long , loff_t ) ; ssize_t (*aio_write)(struct kiocb * , struct iovec const * , unsigned long , loff_t ) ; ssize_t (*read_iter)(struct kiocb * , struct iov_iter * ) ; ssize_t (*write_iter)(struct kiocb * , struct iov_iter * ) ; int (*iterate)(struct file * , struct dir_context * ) ; unsigned int (*poll)(struct file * , struct poll_table_struct * ) ; long (*unlocked_ioctl)(struct file * , unsigned int , unsigned long ) ; long (*compat_ioctl)(struct file * , unsigned int , unsigned long ) ; int (*mmap)(struct file * , struct vm_area_struct * ) ; void (*mremap)(struct file * , struct vm_area_struct * ) ; int (*open)(struct inode * , struct file * ) ; int (*flush)(struct file * , fl_owner_t ) ; int (*release)(struct inode * , struct file * ) ; int (*fsync)(struct file * , loff_t , loff_t , int ) ; int (*aio_fsync)(struct kiocb * , int ) ; int (*fasync)(int , struct file * , int ) ; int (*lock)(struct file * , int , struct file_lock * ) ; ssize_t (*sendpage)(struct file * , struct page * , int , size_t , loff_t * , int ) ; unsigned long (*get_unmapped_area)(struct file * , unsigned long , unsigned long , unsigned long , unsigned long ) ; int (*check_flags)(int ) ; int (*flock)(struct file * , int , struct file_lock * ) ; ssize_t (*splice_write)(struct pipe_inode_info * , struct file * , loff_t * , size_t , unsigned int ) ; ssize_t (*splice_read)(struct file * , loff_t * , struct pipe_inode_info * , size_t , unsigned int ) ; int (*setlease)(struct file * , long , struct file_lock ** , void ** ) ; long (*fallocate)(struct file * , int , loff_t , loff_t ) ; void (*show_fdinfo)(struct seq_file * , struct file * ) ; }; struct inode_operations { struct dentry *(*lookup)(struct inode * , struct dentry * , unsigned int ) ; void *(*follow_link)(struct dentry * , struct nameidata * ) ; int (*permission)(struct inode * , int ) ; struct posix_acl *(*get_acl)(struct inode * , int ) ; int (*readlink)(struct dentry * , char * , int ) ; void (*put_link)(struct dentry * , struct nameidata * , void * ) ; int (*create)(struct inode * , struct dentry * , umode_t , bool ) ; int (*link)(struct dentry * , struct inode * , struct dentry * ) ; int (*unlink)(struct inode * , struct dentry * ) ; int (*symlink)(struct inode * , struct dentry * , char const * ) ; int (*mkdir)(struct inode * , struct dentry * , umode_t ) ; int (*rmdir)(struct inode * , struct dentry * ) ; int (*mknod)(struct inode * , struct dentry * , umode_t , dev_t ) ; int (*rename)(struct inode * , struct dentry * , struct inode * , struct dentry * ) ; int (*rename2)(struct inode * , struct dentry * , struct inode * , struct dentry * , unsigned int ) ; int (*setattr)(struct dentry * , struct iattr * ) ; int (*getattr)(struct vfsmount * , struct dentry * , struct kstat * ) ; int (*setxattr)(struct dentry * , char const * , void const * , size_t , int ) ; ssize_t (*getxattr)(struct dentry * , char const * , void * , size_t ) ; ssize_t (*listxattr)(struct dentry * , char * , size_t ) ; int (*removexattr)(struct dentry * , char const * ) ; int (*fiemap)(struct inode * , struct fiemap_extent_info * , u64 , u64 ) ; int (*update_time)(struct inode * , struct timespec * , int ) ; int (*atomic_open)(struct inode * , struct dentry * , struct file * , unsigned int , umode_t , int * ) ; int (*tmpfile)(struct inode * , struct dentry * , umode_t ) ; int (*set_acl)(struct inode * , struct posix_acl * , int ) ; int (*dentry_open)(struct dentry * , struct file * , struct cred const * ) ; }; struct super_operations { struct inode *(*alloc_inode)(struct super_block * ) ; void (*destroy_inode)(struct inode * ) ; void (*dirty_inode)(struct inode * , int ) ; int (*write_inode)(struct inode * , struct writeback_control * ) ; int (*drop_inode)(struct inode * ) ; void (*evict_inode)(struct inode * ) ; void (*put_super)(struct super_block * ) ; int (*sync_fs)(struct super_block * , int ) ; int (*freeze_super)(struct super_block * ) ; int (*freeze_fs)(struct super_block * ) ; int (*thaw_super)(struct super_block * ) ; int (*unfreeze_fs)(struct super_block * ) ; int (*statfs)(struct dentry * , struct kstatfs * ) ; int (*remount_fs)(struct super_block * , int * , char * ) ; void (*umount_begin)(struct super_block * ) ; int (*show_options)(struct seq_file * , struct dentry * ) ; int (*show_devname)(struct seq_file * , struct dentry * ) ; int (*show_path)(struct seq_file * , struct dentry * ) ; int (*show_stats)(struct seq_file * , struct dentry * ) ; ssize_t (*quota_read)(struct super_block * , int , char * , size_t , loff_t ) ; ssize_t (*quota_write)(struct super_block * , int , char const * , size_t , loff_t ) ; struct dquot **(*get_dquots)(struct inode * ) ; int (*bdev_try_to_free_page)(struct super_block * , struct page * , gfp_t ) ; long (*nr_cached_objects)(struct super_block * , struct shrink_control * ) ; long (*free_cached_objects)(struct super_block * , struct shrink_control * ) ; }; struct file_system_type { char const *name ; int fs_flags ; struct dentry *(*mount)(struct file_system_type * , int , char const * , void * ) ; void (*kill_sb)(struct super_block * ) ; struct module *owner ; struct file_system_type *next ; struct hlist_head fs_supers ; struct lock_class_key s_lock_key ; struct lock_class_key s_umount_key ; struct lock_class_key s_vfs_rename_key ; struct lock_class_key s_writers_key[3U] ; struct lock_class_key i_lock_key ; struct lock_class_key i_mutex_key ; struct lock_class_key i_mutex_dir_key ; }; struct disk_stats { unsigned long sectors[2U] ; unsigned long ios[2U] ; unsigned long merges[2U] ; unsigned long ticks[2U] ; unsigned long io_ticks ; unsigned long time_in_queue ; }; struct partition_meta_info { char uuid[37U] ; u8 volname[64U] ; }; struct hd_struct { sector_t start_sect ; sector_t nr_sects ; seqcount_t nr_sects_seq ; sector_t alignment_offset ; unsigned int discard_alignment ; struct device __dev ; struct kobject *holder_dir ; int policy ; int partno ; struct partition_meta_info *info ; int make_it_fail ; unsigned long stamp ; atomic_t in_flight[2U] ; struct disk_stats *dkstats ; atomic_t ref ; struct callback_head callback_head ; }; struct disk_part_tbl { struct callback_head callback_head ; int len ; struct hd_struct *last_lookup ; struct hd_struct *part[] ; }; struct disk_events; struct timer_rand_state; struct blk_integrity; struct gendisk { int major ; int first_minor ; int minors ; char disk_name[32U] ; char *(*devnode)(struct gendisk * , umode_t * ) ; unsigned int events ; unsigned int async_events ; struct disk_part_tbl *part_tbl ; struct hd_struct part0 ; struct block_device_operations const *fops ; struct request_queue *queue ; void *private_data ; int flags ; struct device *driverfs_dev ; struct kobject *slave_dir ; struct timer_rand_state *random ; atomic_t sync_io ; struct disk_events *ev ; struct blk_integrity *integrity ; int node_id ; }; struct exception_table_entry { int insn ; int fixup ; }; enum irqreturn { IRQ_NONE = 0, IRQ_HANDLED = 1, IRQ_WAKE_THREAD = 2 } ; typedef enum irqreturn irqreturn_t; struct fprop_local_percpu { struct percpu_counter events ; unsigned int period ; raw_spinlock_t lock ; }; enum writeback_sync_modes { WB_SYNC_NONE = 0, WB_SYNC_ALL = 1 } ; struct writeback_control { long nr_to_write ; long pages_skipped ; loff_t range_start ; loff_t range_end ; enum writeback_sync_modes sync_mode ; unsigned char for_kupdate : 1 ; unsigned char for_background : 1 ; unsigned char tagged_writepages : 1 ; unsigned char for_reclaim : 1 ; unsigned char range_cyclic : 1 ; unsigned char for_sync : 1 ; }; struct bdi_writeback; typedef int congested_fn(void * , int ); struct bdi_writeback { struct backing_dev_info *bdi ; unsigned long last_old_flush ; struct delayed_work dwork ; struct list_head b_dirty ; struct list_head b_io ; struct list_head b_more_io ; struct list_head b_dirty_time ; spinlock_t list_lock ; }; struct backing_dev_info { struct list_head bdi_list ; unsigned long ra_pages ; unsigned long state ; unsigned int capabilities ; congested_fn *congested_fn ; void *congested_data ; char *name ; struct percpu_counter bdi_stat[4U] ; unsigned long bw_time_stamp ; unsigned long dirtied_stamp ; unsigned long written_stamp ; unsigned long write_bandwidth ; unsigned long avg_write_bandwidth ; unsigned long dirty_ratelimit ; unsigned long balanced_dirty_ratelimit ; struct fprop_local_percpu completions ; int dirty_exceeded ; unsigned int min_ratio ; unsigned int max_ratio ; unsigned int max_prop_frac ; struct bdi_writeback wb ; spinlock_t wb_lock ; struct list_head work_list ; struct device *dev ; struct timer_list laptop_mode_wb_timer ; struct dentry *debug_dir ; struct dentry *debug_stats ; }; typedef void *mempool_alloc_t(gfp_t , void * ); typedef void mempool_free_t(void * , void * ); struct mempool_s { spinlock_t lock ; int min_nr ; int curr_nr ; void **elements ; void *pool_data ; mempool_alloc_t *alloc ; mempool_free_t *free ; wait_queue_head_t wait ; }; typedef struct mempool_s mempool_t; union __anonunion____missing_field_name_214 { struct list_head q_node ; struct kmem_cache *__rcu_icq_cache ; }; union __anonunion____missing_field_name_215 { struct hlist_node ioc_node ; struct callback_head __rcu_head ; }; struct io_cq { struct request_queue *q ; struct io_context *ioc ; union __anonunion____missing_field_name_214 __annonCompField73 ; union __anonunion____missing_field_name_215 __annonCompField74 ; unsigned int flags ; }; struct io_context { atomic_long_t refcount ; atomic_t active_ref ; atomic_t nr_tasks ; spinlock_t lock ; unsigned short ioprio ; int nr_batch_requests ; unsigned long last_waited ; struct radix_tree_root icq_tree ; struct io_cq *icq_hint ; struct hlist_head icq_list ; struct work_struct release_work ; }; struct bio_integrity_payload { struct bio *bip_bio ; struct bvec_iter bip_iter ; bio_end_io_t *bip_end_io ; unsigned short bip_slab ; unsigned short bip_vcnt ; unsigned short bip_max_vcnt ; unsigned short bip_flags ; struct work_struct bip_work ; struct bio_vec *bip_vec ; struct bio_vec bip_inline_vecs[0U] ; }; struct bio_list { struct bio *head ; struct bio *tail ; }; struct bio_set { struct kmem_cache *bio_slab ; unsigned int front_pad ; mempool_t *bio_pool ; mempool_t *bvec_pool ; mempool_t *bio_integrity_pool ; mempool_t *bvec_integrity_pool ; spinlock_t rescue_lock ; struct bio_list rescue_list ; struct work_struct rescue_work ; struct workqueue_struct *rescue_workqueue ; }; struct bsg_class_device { struct device *class_dev ; struct device *parent ; int minor ; struct request_queue *queue ; struct kref ref ; void (*release)(struct device * ) ; }; struct percpu_ref; typedef void percpu_ref_func_t(struct percpu_ref * ); struct percpu_ref { atomic_long_t count ; unsigned long percpu_count_ptr ; percpu_ref_func_t *release ; percpu_ref_func_t *confirm_switch ; bool force_atomic ; struct callback_head rcu ; }; struct elevator_queue; struct blk_trace; struct bsg_job; struct blkcg_gq; struct blk_flush_queue; typedef void rq_end_io_fn(struct request * , int ); struct request_list { struct request_queue *q ; struct blkcg_gq *blkg ; int count[2U] ; int starved[2U] ; mempool_t *rq_pool ; wait_queue_head_t wait[2U] ; unsigned int flags ; }; enum rq_cmd_type_bits { REQ_TYPE_FS = 1, REQ_TYPE_BLOCK_PC = 2, REQ_TYPE_SENSE = 3, REQ_TYPE_PM_SUSPEND = 4, REQ_TYPE_PM_RESUME = 5, REQ_TYPE_PM_SHUTDOWN = 6, REQ_TYPE_SPECIAL = 7, REQ_TYPE_ATA_TASKFILE = 8, REQ_TYPE_ATA_PC = 9 } ; union __anonunion____missing_field_name_216 { struct call_single_data csd ; unsigned long fifo_time ; }; struct blk_mq_ctx; union __anonunion____missing_field_name_217 { struct hlist_node hash ; struct list_head ipi_list ; }; union __anonunion____missing_field_name_218 { struct rb_node rb_node ; void *completion_data ; }; struct __anonstruct_elv_220 { struct io_cq *icq ; void *priv[2U] ; }; struct __anonstruct_flush_221 { unsigned int seq ; struct list_head list ; rq_end_io_fn *saved_end_io ; }; union __anonunion____missing_field_name_219 { struct __anonstruct_elv_220 elv ; struct __anonstruct_flush_221 flush ; }; struct request { struct list_head queuelist ; union __anonunion____missing_field_name_216 __annonCompField75 ; struct request_queue *q ; struct blk_mq_ctx *mq_ctx ; u64 cmd_flags ; enum rq_cmd_type_bits cmd_type ; unsigned long atomic_flags ; int cpu ; unsigned int __data_len ; sector_t __sector ; struct bio *bio ; struct bio *biotail ; union __anonunion____missing_field_name_217 __annonCompField76 ; union __anonunion____missing_field_name_218 __annonCompField77 ; union __anonunion____missing_field_name_219 __annonCompField78 ; struct gendisk *rq_disk ; struct hd_struct *part ; unsigned long start_time ; struct request_list *rl ; unsigned long long start_time_ns ; unsigned long long io_start_time_ns ; unsigned short nr_phys_segments ; unsigned short nr_integrity_segments ; unsigned short ioprio ; void *special ; int tag ; int errors ; unsigned char __cmd[16U] ; unsigned char *cmd ; unsigned short cmd_len ; unsigned int extra_len ; unsigned int sense_len ; unsigned int resid_len ; void *sense ; unsigned long deadline ; struct list_head timeout_list ; unsigned int timeout ; int retries ; rq_end_io_fn *end_io ; void *end_io_data ; struct request *next_rq ; }; struct elevator_type; typedef int elevator_merge_fn(struct request_queue * , struct request ** , struct bio * ); typedef void elevator_merge_req_fn(struct request_queue * , struct request * , struct request * ); typedef void elevator_merged_fn(struct request_queue * , struct request * , int ); typedef int elevator_allow_merge_fn(struct request_queue * , struct request * , struct bio * ); typedef void elevator_bio_merged_fn(struct request_queue * , struct request * , struct bio * ); typedef int elevator_dispatch_fn(struct request_queue * , int ); typedef void elevator_add_req_fn(struct request_queue * , struct request * ); typedef struct request *elevator_request_list_fn(struct request_queue * , struct request * ); typedef void elevator_completed_req_fn(struct request_queue * , struct request * ); typedef int elevator_may_queue_fn(struct request_queue * , int ); typedef void elevator_init_icq_fn(struct io_cq * ); typedef void elevator_exit_icq_fn(struct io_cq * ); typedef int elevator_set_req_fn(struct request_queue * , struct request * , struct bio * , gfp_t ); typedef void elevator_put_req_fn(struct request * ); typedef void elevator_activate_req_fn(struct request_queue * , struct request * ); typedef void elevator_deactivate_req_fn(struct request_queue * , struct request * ); typedef int elevator_init_fn(struct request_queue * , struct elevator_type * ); typedef void elevator_exit_fn(struct elevator_queue * ); struct elevator_ops { elevator_merge_fn *elevator_merge_fn ; elevator_merged_fn *elevator_merged_fn ; elevator_merge_req_fn *elevator_merge_req_fn ; elevator_allow_merge_fn *elevator_allow_merge_fn ; elevator_bio_merged_fn *elevator_bio_merged_fn ; elevator_dispatch_fn *elevator_dispatch_fn ; elevator_add_req_fn *elevator_add_req_fn ; elevator_activate_req_fn *elevator_activate_req_fn ; elevator_deactivate_req_fn *elevator_deactivate_req_fn ; elevator_completed_req_fn *elevator_completed_req_fn ; elevator_request_list_fn *elevator_former_req_fn ; elevator_request_list_fn *elevator_latter_req_fn ; elevator_init_icq_fn *elevator_init_icq_fn ; elevator_exit_icq_fn *elevator_exit_icq_fn ; elevator_set_req_fn *elevator_set_req_fn ; elevator_put_req_fn *elevator_put_req_fn ; elevator_may_queue_fn *elevator_may_queue_fn ; elevator_init_fn *elevator_init_fn ; elevator_exit_fn *elevator_exit_fn ; }; struct elv_fs_entry { struct attribute attr ; ssize_t (*show)(struct elevator_queue * , char * ) ; ssize_t (*store)(struct elevator_queue * , char const * , size_t ) ; }; struct elevator_type { struct kmem_cache *icq_cache ; struct elevator_ops ops ; size_t icq_size ; size_t icq_align ; struct elv_fs_entry *elevator_attrs ; char elevator_name[16U] ; struct module *elevator_owner ; char icq_cache_name[21U] ; struct list_head list ; }; struct elevator_queue { struct elevator_type *type ; void *elevator_data ; struct kobject kobj ; struct mutex sysfs_lock ; unsigned char registered : 1 ; struct hlist_head hash[64U] ; }; typedef void request_fn_proc(struct request_queue * ); typedef void make_request_fn(struct request_queue * , struct bio * ); typedef int prep_rq_fn(struct request_queue * , struct request * ); typedef void unprep_rq_fn(struct request_queue * , struct request * ); struct bvec_merge_data { struct block_device *bi_bdev ; sector_t bi_sector ; unsigned int bi_size ; unsigned long bi_rw ; }; typedef int merge_bvec_fn(struct request_queue * , struct bvec_merge_data * , struct bio_vec * ); typedef void softirq_done_fn(struct request * ); typedef int dma_drain_needed_fn(struct request * ); typedef int lld_busy_fn(struct request_queue * ); typedef int bsg_job_fn(struct bsg_job * ); enum blk_eh_timer_return { BLK_EH_NOT_HANDLED = 0, BLK_EH_HANDLED = 1, BLK_EH_RESET_TIMER = 2 } ; typedef enum blk_eh_timer_return rq_timed_out_fn(struct request * ); struct blk_queue_tag { struct request **tag_index ; unsigned long *tag_map ; int busy ; int max_depth ; int real_max_depth ; atomic_t refcnt ; int alloc_policy ; int next_tag ; }; struct queue_limits { unsigned long bounce_pfn ; unsigned long seg_boundary_mask ; unsigned int max_hw_sectors ; unsigned int chunk_sectors ; unsigned int max_sectors ; unsigned int max_segment_size ; unsigned int physical_block_size ; unsigned int alignment_offset ; unsigned int io_min ; unsigned int io_opt ; unsigned int max_discard_sectors ; unsigned int max_write_same_sectors ; unsigned int discard_granularity ; unsigned int discard_alignment ; unsigned short logical_block_size ; unsigned short max_segments ; unsigned short max_integrity_segments ; unsigned char misaligned ; unsigned char discard_misaligned ; unsigned char cluster ; unsigned char discard_zeroes_data ; unsigned char raid_partial_stripes_expensive ; }; struct blk_mq_ops; struct blk_mq_hw_ctx; struct throtl_data; struct blk_mq_tag_set; struct request_queue { struct list_head queue_head ; struct request *last_merge ; struct elevator_queue *elevator ; int nr_rqs[2U] ; int nr_rqs_elvpriv ; struct request_list root_rl ; request_fn_proc *request_fn ; make_request_fn *make_request_fn ; prep_rq_fn *prep_rq_fn ; unprep_rq_fn *unprep_rq_fn ; merge_bvec_fn *merge_bvec_fn ; softirq_done_fn *softirq_done_fn ; rq_timed_out_fn *rq_timed_out_fn ; dma_drain_needed_fn *dma_drain_needed ; lld_busy_fn *lld_busy_fn ; struct blk_mq_ops *mq_ops ; unsigned int *mq_map ; struct blk_mq_ctx *queue_ctx ; unsigned int nr_queues ; struct blk_mq_hw_ctx **queue_hw_ctx ; unsigned int nr_hw_queues ; sector_t end_sector ; struct request *boundary_rq ; struct delayed_work delay_work ; struct backing_dev_info backing_dev_info ; void *queuedata ; unsigned long queue_flags ; int id ; gfp_t bounce_gfp ; spinlock_t __queue_lock ; spinlock_t *queue_lock ; struct kobject kobj ; struct kobject mq_kobj ; struct device *dev ; int rpm_status ; unsigned int nr_pending ; unsigned long nr_requests ; unsigned int nr_congestion_on ; unsigned int nr_congestion_off ; unsigned int nr_batching ; unsigned int dma_drain_size ; void *dma_drain_buffer ; unsigned int dma_pad_mask ; unsigned int dma_alignment ; struct blk_queue_tag *queue_tags ; struct list_head tag_busy_list ; unsigned int nr_sorted ; unsigned int in_flight[2U] ; unsigned int request_fn_active ; unsigned int rq_timeout ; struct timer_list timeout ; struct list_head timeout_list ; struct list_head icq_list ; unsigned long blkcg_pols[1U] ; struct blkcg_gq *root_blkg ; struct list_head blkg_list ; struct queue_limits limits ; unsigned int sg_timeout ; unsigned int sg_reserved_size ; int node ; struct blk_trace *blk_trace ; unsigned int flush_flags ; unsigned char flush_not_queueable : 1 ; struct blk_flush_queue *fq ; struct list_head requeue_list ; spinlock_t requeue_lock ; struct work_struct requeue_work ; struct mutex sysfs_lock ; int bypass_depth ; int mq_freeze_depth ; bsg_job_fn *bsg_job_fn ; int bsg_job_size ; struct bsg_class_device bsg_dev ; struct throtl_data *td ; struct callback_head callback_head ; wait_queue_head_t mq_freeze_wq ; struct percpu_ref mq_usage_counter ; struct list_head all_q_node ; struct blk_mq_tag_set *tag_set ; struct list_head tag_set_list ; }; struct blk_plug { struct list_head list ; struct list_head mq_list ; struct list_head cb_list ; }; struct blk_integrity_iter { void *prot_buf ; void *data_buf ; sector_t seed ; unsigned int data_size ; unsigned short interval ; char const *disk_name ; }; typedef int integrity_processing_fn(struct blk_integrity_iter * ); struct blk_integrity { integrity_processing_fn *generate_fn ; integrity_processing_fn *verify_fn ; unsigned short flags ; unsigned short tuple_size ; unsigned short interval ; unsigned short tag_size ; char const *name ; struct kobject kobj ; }; struct block_device_operations { int (*open)(struct block_device * , fmode_t ) ; void (*release)(struct gendisk * , fmode_t ) ; int (*rw_page)(struct block_device * , sector_t , struct page * , int ) ; int (*ioctl)(struct block_device * , fmode_t , unsigned int , unsigned long ) ; int (*compat_ioctl)(struct block_device * , fmode_t , unsigned int , unsigned long ) ; long (*direct_access)(struct block_device * , sector_t , void ** , unsigned long * , long ) ; unsigned int (*check_events)(struct gendisk * , unsigned int ) ; int (*media_changed)(struct gendisk * ) ; void (*unlock_native_capacity)(struct gendisk * ) ; int (*revalidate_disk)(struct gendisk * ) ; int (*getgeo)(struct block_device * , struct hd_geometry * ) ; void (*swap_slot_free_notify)(struct block_device * , unsigned long ) ; struct module *owner ; }; struct blk_mq_tags; struct blk_mq_cpu_notifier { struct list_head list ; void *data ; int (*notify)(void * , unsigned long , unsigned int ) ; }; struct blk_align_bitmap; struct blk_mq_ctxmap { unsigned int map_size ; unsigned int bits_per_word ; struct blk_align_bitmap *map ; }; struct __anonstruct____missing_field_name_223 { spinlock_t lock ; struct list_head dispatch ; }; struct blk_mq_hw_ctx { struct __anonstruct____missing_field_name_223 __annonCompField79 ; unsigned long state ; struct delayed_work run_work ; struct delayed_work delay_work ; cpumask_var_t cpumask ; int next_cpu ; int next_cpu_batch ; unsigned long flags ; struct request_queue *queue ; struct blk_flush_queue *fq ; void *driver_data ; struct blk_mq_ctxmap ctx_map ; unsigned int nr_ctx ; struct blk_mq_ctx **ctxs ; atomic_t wait_index ; struct blk_mq_tags *tags ; unsigned long queued ; unsigned long run ; unsigned long dispatched[10U] ; unsigned int numa_node ; unsigned int queue_num ; atomic_t nr_active ; struct blk_mq_cpu_notifier cpu_notifier ; struct kobject kobj ; }; struct blk_mq_tag_set { struct blk_mq_ops *ops ; unsigned int nr_hw_queues ; unsigned int queue_depth ; unsigned int reserved_tags ; unsigned int cmd_size ; int numa_node ; unsigned int timeout ; unsigned int flags ; void *driver_data ; struct blk_mq_tags **tags ; struct mutex tag_list_lock ; struct list_head tag_list ; }; struct blk_mq_queue_data { struct request *rq ; struct list_head *list ; bool last ; }; typedef int queue_rq_fn(struct blk_mq_hw_ctx * , struct blk_mq_queue_data const * ); typedef struct blk_mq_hw_ctx *map_queue_fn(struct request_queue * , int const ); typedef enum blk_eh_timer_return timeout_fn(struct request * , bool ); typedef int init_hctx_fn(struct blk_mq_hw_ctx * , void * , unsigned int ); typedef void exit_hctx_fn(struct blk_mq_hw_ctx * , unsigned int ); typedef int init_request_fn(void * , struct request * , unsigned int , unsigned int , unsigned int ); typedef void exit_request_fn(void * , struct request * , unsigned int , unsigned int ); struct blk_mq_ops { queue_rq_fn *queue_rq ; map_queue_fn *map_queue ; timeout_fn *timeout ; softirq_done_fn *complete ; init_hctx_fn *init_hctx ; exit_hctx_fn *exit_hctx ; init_request_fn *init_request ; exit_request_fn *exit_request ; }; struct scsi_cmnd; struct scsi_lun { __u8 scsi_lun[8U] ; }; struct scsi_device; struct scsi_host_cmd_pool; struct scsi_target; struct Scsi_Host; struct scsi_transport_template; struct scsi_host_template { struct module *module ; char const *name ; int (*detect)(struct scsi_host_template * ) ; int (*release)(struct Scsi_Host * ) ; char const *(*info)(struct Scsi_Host * ) ; int (*ioctl)(struct scsi_device * , int , void * ) ; int (*compat_ioctl)(struct scsi_device * , int , void * ) ; int (*queuecommand)(struct Scsi_Host * , struct scsi_cmnd * ) ; int (*eh_abort_handler)(struct scsi_cmnd * ) ; int (*eh_device_reset_handler)(struct scsi_cmnd * ) ; int (*eh_target_reset_handler)(struct scsi_cmnd * ) ; int (*eh_bus_reset_handler)(struct scsi_cmnd * ) ; int (*eh_host_reset_handler)(struct scsi_cmnd * ) ; int (*slave_alloc)(struct scsi_device * ) ; int (*slave_configure)(struct scsi_device * ) ; void (*slave_destroy)(struct scsi_device * ) ; int (*target_alloc)(struct scsi_target * ) ; void (*target_destroy)(struct scsi_target * ) ; int (*scan_finished)(struct Scsi_Host * , unsigned long ) ; void (*scan_start)(struct Scsi_Host * ) ; int (*change_queue_depth)(struct scsi_device * , int ) ; int (*bios_param)(struct scsi_device * , struct block_device * , sector_t , int * ) ; void (*unlock_native_capacity)(struct scsi_device * ) ; int (*show_info)(struct seq_file * , struct Scsi_Host * ) ; int (*write_info)(struct Scsi_Host * , char * , int ) ; enum blk_eh_timer_return (*eh_timed_out)(struct scsi_cmnd * ) ; int (*host_reset)(struct Scsi_Host * , int ) ; char const *proc_name ; struct proc_dir_entry *proc_dir ; int can_queue ; int this_id ; unsigned short sg_tablesize ; unsigned short sg_prot_tablesize ; unsigned int max_sectors ; unsigned long dma_boundary ; short cmd_per_lun ; unsigned char present ; int tag_alloc_policy ; unsigned char use_blk_tags : 1 ; unsigned char track_queue_depth : 1 ; unsigned char supported_mode : 2 ; unsigned char unchecked_isa_dma : 1 ; unsigned char use_clustering : 1 ; unsigned char emulated : 1 ; unsigned char skip_settle_delay : 1 ; unsigned char no_write_same : 1 ; unsigned char no_async_abort : 1 ; unsigned int max_host_blocked ; struct device_attribute **shost_attrs ; struct device_attribute **sdev_attrs ; struct list_head legacy_hosts ; u64 vendor_id ; unsigned int cmd_size ; struct scsi_host_cmd_pool *cmd_pool ; bool disable_blk_mq ; }; enum scsi_host_state { SHOST_CREATED = 1, SHOST_RUNNING = 2, SHOST_CANCEL = 3, SHOST_DEL = 4, SHOST_RECOVERY = 5, SHOST_CANCEL_RECOVERY = 6, SHOST_DEL_RECOVERY = 7 } ; union __anonunion____missing_field_name_224 { struct blk_queue_tag *bqt ; struct blk_mq_tag_set tag_set ; }; struct Scsi_Host { struct list_head __devices ; struct list_head __targets ; struct scsi_host_cmd_pool *cmd_pool ; spinlock_t free_list_lock ; struct list_head free_list ; struct list_head starved_list ; spinlock_t default_lock ; spinlock_t *host_lock ; struct mutex scan_mutex ; struct list_head eh_cmd_q ; struct task_struct *ehandler ; struct completion *eh_action ; wait_queue_head_t host_wait ; struct scsi_host_template *hostt ; struct scsi_transport_template *transportt ; union __anonunion____missing_field_name_224 __annonCompField80 ; atomic_t host_busy ; atomic_t host_blocked ; unsigned int host_failed ; unsigned int host_eh_scheduled ; unsigned int host_no ; int eh_deadline ; unsigned long last_reset ; unsigned int max_channel ; unsigned int max_id ; u64 max_lun ; unsigned int unique_id ; unsigned short max_cmd_len ; int this_id ; int can_queue ; short cmd_per_lun ; unsigned short sg_tablesize ; unsigned short sg_prot_tablesize ; unsigned int max_sectors ; unsigned long dma_boundary ; unsigned int nr_hw_queues ; unsigned long cmd_serial_number ; unsigned char active_mode : 2 ; unsigned char unchecked_isa_dma : 1 ; unsigned char use_clustering : 1 ; unsigned char host_self_blocked : 1 ; unsigned char reverse_ordering : 1 ; unsigned char tmf_in_progress : 1 ; unsigned char async_scan : 1 ; unsigned char eh_noresume : 1 ; unsigned char no_write_same : 1 ; unsigned char use_blk_mq : 1 ; unsigned char use_cmd_list : 1 ; char work_q_name[20U] ; struct workqueue_struct *work_q ; struct workqueue_struct *tmf_work_q ; unsigned char no_scsi2_lun_in_cdb : 1 ; unsigned int max_host_blocked ; unsigned int prot_capabilities ; unsigned char prot_guard_type ; struct request_queue *uspace_req_q ; unsigned long base ; unsigned long io_port ; unsigned char n_io_port ; unsigned char dma_channel ; unsigned int irq ; enum scsi_host_state shost_state ; struct device shost_gendev ; struct device shost_dev ; struct list_head sht_legacy_list ; void *shost_data ; struct device *dma_dev ; unsigned long hostdata[0U] ; }; typedef __u64 Elf64_Addr; typedef __u16 Elf64_Half; typedef __u32 Elf64_Word; typedef __u64 Elf64_Xword; struct elf64_sym { Elf64_Word st_name ; unsigned char st_info ; unsigned char st_other ; Elf64_Half st_shndx ; Elf64_Addr st_value ; Elf64_Xword st_size ; }; typedef struct elf64_sym Elf64_Sym; struct kernel_param; struct kernel_param_ops { unsigned int flags ; int (*set)(char const * , struct kernel_param const * ) ; int (*get)(char * , struct kernel_param const * ) ; void (*free)(void * ) ; }; struct kparam_string; struct kparam_array; union __anonunion____missing_field_name_231 { void *arg ; struct kparam_string const *str ; struct kparam_array const *arr ; }; struct kernel_param { char const *name ; struct kernel_param_ops const *ops ; u16 perm ; s8 level ; u8 flags ; union __anonunion____missing_field_name_231 __annonCompField81 ; }; struct kparam_string { unsigned int maxlen ; char *string ; }; struct kparam_array { unsigned int max ; unsigned int elemsize ; unsigned int *num ; struct kernel_param_ops const *ops ; void *elem ; }; struct mod_arch_specific { }; struct module_param_attrs; struct module_kobject { struct kobject kobj ; struct module *mod ; struct kobject *drivers_dir ; struct module_param_attrs *mp ; struct completion *kobj_completion ; }; struct module_attribute { struct attribute attr ; ssize_t (*show)(struct module_attribute * , struct module_kobject * , char * ) ; ssize_t (*store)(struct module_attribute * , struct module_kobject * , char const * , size_t ) ; void (*setup)(struct module * , char const * ) ; int (*test)(struct module * ) ; void (*free)(struct module * ) ; }; enum module_state { MODULE_STATE_LIVE = 0, MODULE_STATE_COMING = 1, MODULE_STATE_GOING = 2, MODULE_STATE_UNFORMED = 3 } ; struct module_sect_attrs; struct module_notes_attrs; struct tracepoint; struct ftrace_event_call; struct module { enum module_state state ; struct list_head list ; char name[56U] ; struct module_kobject mkobj ; struct module_attribute *modinfo_attrs ; char const *version ; char const *srcversion ; struct kobject *holders_dir ; struct kernel_symbol const *syms ; unsigned long const *crcs ; unsigned int num_syms ; struct kernel_param *kp ; unsigned int num_kp ; unsigned int num_gpl_syms ; struct kernel_symbol const *gpl_syms ; unsigned long const *gpl_crcs ; struct kernel_symbol const *unused_syms ; unsigned long const *unused_crcs ; unsigned int num_unused_syms ; unsigned int num_unused_gpl_syms ; struct kernel_symbol const *unused_gpl_syms ; unsigned long const *unused_gpl_crcs ; bool sig_ok ; struct kernel_symbol const *gpl_future_syms ; unsigned long const *gpl_future_crcs ; unsigned int num_gpl_future_syms ; unsigned int num_exentries ; struct exception_table_entry *extable ; int (*init)(void) ; void *module_init ; void *module_core ; unsigned int init_size ; unsigned int core_size ; unsigned int init_text_size ; unsigned int core_text_size ; unsigned int init_ro_size ; unsigned int core_ro_size ; struct mod_arch_specific arch ; unsigned int taints ; unsigned int num_bugs ; struct list_head bug_list ; struct bug_entry *bug_table ; Elf64_Sym *symtab ; Elf64_Sym *core_symtab ; unsigned int num_symtab ; unsigned int core_num_syms ; char *strtab ; char *core_strtab ; struct module_sect_attrs *sect_attrs ; struct module_notes_attrs *notes_attrs ; char *args ; void *percpu ; unsigned int percpu_size ; unsigned int num_tracepoints ; struct tracepoint * const *tracepoints_ptrs ; struct jump_entry *jump_entries ; unsigned int num_jump_entries ; unsigned int num_trace_bprintk_fmt ; char const **trace_bprintk_fmt_start ; struct ftrace_event_call **trace_events ; unsigned int num_trace_events ; unsigned int num_ftrace_callsites ; unsigned long *ftrace_callsites ; struct list_head source_list ; struct list_head target_list ; void (*exit)(void) ; atomic_t refcnt ; ctor_fn_t (**ctors)(void) ; unsigned int num_ctors ; }; struct tasklet_struct { struct tasklet_struct *next ; unsigned long state ; atomic_t count ; void (*func)(unsigned long ) ; unsigned long data ; }; enum sas_oob_mode { OOB_NOT_CONNECTED = 0, SATA_OOB_MODE = 1, SAS_OOB_MODE = 2 } ; enum sas_device_type { SAS_PHY_UNUSED = 0, SAS_END_DEVICE = 1, SAS_EDGE_EXPANDER_DEVICE = 2, SAS_FANOUT_EXPANDER_DEVICE = 3, SAS_HA = 4, SAS_SATA_DEV = 5, SAS_SATA_PM = 7, SAS_SATA_PM_PORT = 8, SAS_SATA_PENDING = 9 } ; enum sas_protocol { SAS_PROTOCOL_NONE = 0, SAS_PROTOCOL_SATA = 1, SAS_PROTOCOL_SMP = 2, SAS_PROTOCOL_STP = 4, SAS_PROTOCOL_SSP = 8, SAS_PROTOCOL_ALL = 14, SAS_PROTOCOL_STP_ALL = 5 } ; enum phy_func { PHY_FUNC_NOP = 0, PHY_FUNC_LINK_RESET = 1, PHY_FUNC_HARD_RESET = 2, PHY_FUNC_DISABLE = 3, PHY_FUNC_CLEAR_ERROR_LOG = 5, PHY_FUNC_CLEAR_AFFIL = 6, PHY_FUNC_TX_SATA_PS_SIGNAL = 7, PHY_FUNC_RELEASE_SPINUP_HOLD = 16, PHY_FUNC_SET_LINK_RATE = 17, PHY_FUNC_GET_EVENTS = 18 } ; enum sas_open_rej_reason { SAS_OREJ_UNKNOWN = 0, SAS_OREJ_BAD_DEST = 1, SAS_OREJ_CONN_RATE = 2, SAS_OREJ_EPROTO = 3, SAS_OREJ_RESV_AB0 = 4, SAS_OREJ_RESV_AB1 = 5, SAS_OREJ_RESV_AB2 = 6, SAS_OREJ_RESV_AB3 = 7, SAS_OREJ_WRONG_DEST = 8, SAS_OREJ_STP_NORES = 9, SAS_OREJ_NO_DEST = 10, SAS_OREJ_PATH_BLOCKED = 11, SAS_OREJ_RSVD_CONT0 = 12, SAS_OREJ_RSVD_CONT1 = 13, SAS_OREJ_RSVD_INIT0 = 14, SAS_OREJ_RSVD_INIT1 = 15, SAS_OREJ_RSVD_STOP0 = 16, SAS_OREJ_RSVD_STOP1 = 17, SAS_OREJ_RSVD_RETRY = 18 } ; union __anonunion____missing_field_name_232 { u8 lbam ; u8 byte_count_low ; }; union __anonunion____missing_field_name_233 { u8 lbah ; u8 byte_count_high ; }; union __anonunion____missing_field_name_234 { u8 sector_count ; u8 interrupt_reason ; }; struct dev_to_host_fis { u8 fis_type ; u8 flags ; u8 status ; u8 error ; u8 lbal ; union __anonunion____missing_field_name_232 __annonCompField82 ; union __anonunion____missing_field_name_233 __annonCompField83 ; u8 device ; u8 lbal_exp ; u8 lbam_exp ; u8 lbah_exp ; u8 _r_a ; union __anonunion____missing_field_name_234 __annonCompField84 ; u8 sector_count_exp ; u8 _r_b ; u8 _r_c ; u32 _r_d ; }; union __anonunion____missing_field_name_235 { u8 lbam ; u8 byte_count_low ; }; union __anonunion____missing_field_name_236 { u8 lbah ; u8 byte_count_high ; }; union __anonunion____missing_field_name_237 { u8 sector_count ; u8 interrupt_reason ; }; struct host_to_dev_fis { u8 fis_type ; u8 flags ; u8 command ; u8 features ; u8 lbal ; union __anonunion____missing_field_name_235 __annonCompField85 ; union __anonunion____missing_field_name_236 __annonCompField86 ; u8 device ; u8 lbal_exp ; u8 lbam_exp ; u8 lbah_exp ; u8 features_exp ; union __anonunion____missing_field_name_237 __annonCompField87 ; u8 sector_count_exp ; u8 _r_a ; u8 control ; u32 _r_b ; }; struct report_general_resp { __be16 change_count ; __be16 route_indexes ; u8 _r_a ; u8 num_phys ; unsigned char conf_route_table : 1 ; unsigned char configuring : 1 ; unsigned char config_others : 1 ; unsigned char orej_retry_supp : 1 ; unsigned char stp_cont_awt : 1 ; unsigned char self_config : 1 ; unsigned char zone_config : 1 ; unsigned char t2t_supp : 1 ; u8 _r_c ; u8 enclosure_logical_id[8U] ; u8 _r_d[12U] ; }; struct discover_resp { u8 _r_a[5U] ; u8 phy_id ; __be16 _r_b ; unsigned char _r_c : 4 ; unsigned char attached_dev_type : 3 ; unsigned char _r_d : 1 ; unsigned char linkrate : 4 ; unsigned char _r_e : 4 ; unsigned char attached_sata_host : 1 ; unsigned char iproto : 3 ; unsigned char _r_f : 4 ; unsigned char attached_sata_dev : 1 ; unsigned char tproto : 3 ; unsigned char _r_g : 3 ; unsigned char attached_sata_ps : 1 ; u8 sas_addr[8U] ; u8 attached_sas_addr[8U] ; u8 attached_phy_id ; u8 _r_h[7U] ; unsigned char hmin_linkrate : 4 ; unsigned char pmin_linkrate : 4 ; unsigned char hmax_linkrate : 4 ; unsigned char pmax_linkrate : 4 ; u8 change_count ; unsigned char pptv : 4 ; unsigned char _r_i : 3 ; unsigned char virtual : 1 ; unsigned char routing_attr : 4 ; unsigned char _r_j : 4 ; u8 conn_type ; u8 conn_el_index ; u8 conn_phy_link ; u8 _r_k[8U] ; }; struct report_phy_sata_resp { u8 _r_a[5U] ; u8 phy_id ; u8 _r_b ; unsigned char affil_valid : 1 ; unsigned char affil_supp : 1 ; unsigned char _r_c : 6 ; u32 _r_d ; u8 stp_sas_addr[8U] ; struct dev_to_host_fis fis ; u32 _r_e ; u8 affil_stp_ini_addr[8U] ; __be32 crc ; }; union __anonunion____missing_field_name_242 { struct report_general_resp rg ; struct discover_resp disc ; struct report_phy_sata_resp rps ; }; struct smp_resp { u8 frame_type ; u8 function ; u8 result ; u8 reserved ; union __anonunion____missing_field_name_242 __annonCompField92 ; }; struct ata_bmdma_prd { __le32 addr ; __le32 flags_len ; }; enum fwnode_type { FWNODE_INVALID = 0, FWNODE_OF = 1, FWNODE_ACPI = 2 } ; struct fwnode_handle { enum fwnode_type type ; }; typedef u64 acpi_io_address; typedef void *acpi_handle; typedef u32 acpi_object_type; struct __anonstruct_integer_243 { acpi_object_type type ; u64 value ; }; struct __anonstruct_string_244 { acpi_object_type type ; u32 length ; char *pointer ; }; struct __anonstruct_buffer_245 { acpi_object_type type ; u32 length ; u8 *pointer ; }; struct __anonstruct_package_246 { acpi_object_type type ; u32 count ; union acpi_object *elements ; }; struct __anonstruct_reference_247 { acpi_object_type type ; acpi_object_type actual_type ; acpi_handle handle ; }; struct __anonstruct_processor_248 { acpi_object_type type ; u32 proc_id ; acpi_io_address pblk_address ; u32 pblk_length ; }; struct __anonstruct_power_resource_249 { acpi_object_type type ; u32 system_level ; u32 resource_order ; }; union acpi_object { acpi_object_type type ; struct __anonstruct_integer_243 integer ; struct __anonstruct_string_244 string ; struct __anonstruct_buffer_245 buffer ; struct __anonstruct_package_246 package ; struct __anonstruct_reference_247 reference ; struct __anonstruct_processor_248 processor ; struct __anonstruct_power_resource_249 power_resource ; }; struct acpi_driver; struct acpi_hotplug_profile { struct kobject kobj ; int (*scan_dependent)(struct acpi_device * ) ; void (*notify_online)(struct acpi_device * ) ; bool enabled ; bool demand_offline ; }; struct acpi_scan_handler { struct acpi_device_id const *ids ; struct list_head list_node ; bool (*match)(char * , struct acpi_device_id const ** ) ; int (*attach)(struct acpi_device * , struct acpi_device_id const * ) ; void (*detach)(struct acpi_device * ) ; void (*bind)(struct device * ) ; void (*unbind)(struct device * ) ; struct acpi_hotplug_profile hotplug ; }; struct acpi_hotplug_context { struct acpi_device *self ; int (*notify)(struct acpi_device * , u32 ) ; void (*uevent)(struct acpi_device * , u32 ) ; void (*fixup)(struct acpi_device * ) ; }; struct acpi_device_ops { int (*add)(struct acpi_device * ) ; int (*remove)(struct acpi_device * ) ; void (*notify)(struct acpi_device * , u32 ) ; }; struct acpi_driver { char name[80U] ; char class[80U] ; struct acpi_device_id const *ids ; unsigned int flags ; struct acpi_device_ops ops ; struct device_driver drv ; struct module *owner ; }; struct acpi_device_status { unsigned char present : 1 ; unsigned char enabled : 1 ; unsigned char show_in_ui : 1 ; unsigned char functional : 1 ; unsigned char battery_present : 1 ; unsigned int reserved : 27 ; }; struct acpi_device_flags { unsigned char dynamic_status : 1 ; unsigned char removable : 1 ; unsigned char ejectable : 1 ; unsigned char power_manageable : 1 ; unsigned char match_driver : 1 ; unsigned char initialized : 1 ; unsigned char visited : 1 ; unsigned char hotplug_notify : 1 ; unsigned char is_dock_station : 1 ; unsigned int reserved : 23 ; }; struct acpi_device_dir { struct proc_dir_entry *entry ; }; typedef char acpi_bus_id[8U]; typedef unsigned long acpi_bus_address; typedef char acpi_device_name[40U]; typedef char acpi_device_class[20U]; struct acpi_pnp_type { unsigned char hardware_id : 1 ; unsigned char bus_address : 1 ; unsigned char platform_id : 1 ; unsigned int reserved : 29 ; }; struct acpi_device_pnp { acpi_bus_id bus_id ; struct acpi_pnp_type type ; acpi_bus_address bus_address ; char *unique_id ; struct list_head ids ; acpi_device_name device_name ; acpi_device_class device_class ; union acpi_object *str_obj ; }; struct acpi_device_power_flags { unsigned char explicit_get : 1 ; unsigned char power_resources : 1 ; unsigned char inrush_current : 1 ; unsigned char power_removed : 1 ; unsigned char ignore_parent : 1 ; unsigned char dsw_present : 1 ; unsigned int reserved : 26 ; }; struct __anonstruct_flags_250 { unsigned char valid : 1 ; unsigned char os_accessible : 1 ; unsigned char explicit_set : 1 ; unsigned char reserved : 6 ; }; struct acpi_device_power_state { struct __anonstruct_flags_250 flags ; int power ; int latency ; struct list_head resources ; }; struct acpi_device_power { int state ; struct acpi_device_power_flags flags ; struct acpi_device_power_state states[5U] ; }; struct acpi_device_perf_flags { u8 reserved ; }; struct __anonstruct_flags_251 { unsigned char valid : 1 ; unsigned char reserved : 7 ; }; struct acpi_device_perf_state { struct __anonstruct_flags_251 flags ; u8 power ; u8 performance ; int latency ; }; struct acpi_device_perf { int state ; struct acpi_device_perf_flags flags ; int state_count ; struct acpi_device_perf_state *states ; }; struct acpi_device_wakeup_flags { unsigned char valid : 1 ; unsigned char run_wake : 1 ; unsigned char notifier_present : 1 ; unsigned char enabled : 1 ; }; struct acpi_device_wakeup_context { struct work_struct work ; struct device *dev ; }; struct acpi_device_wakeup { acpi_handle gpe_device ; u64 gpe_number ; u64 sleep_state ; struct list_head resources ; struct acpi_device_wakeup_flags flags ; struct acpi_device_wakeup_context context ; struct wakeup_source *ws ; int prepare_count ; }; struct acpi_device_data { union acpi_object const *pointer ; union acpi_object const *properties ; union acpi_object const *of_compatible ; }; struct acpi_gpio_mapping; struct acpi_device { int device_type ; acpi_handle handle ; struct fwnode_handle fwnode ; struct acpi_device *parent ; struct list_head children ; struct list_head node ; struct list_head wakeup_list ; struct list_head del_list ; struct acpi_device_status status ; struct acpi_device_flags flags ; struct acpi_device_pnp pnp ; struct acpi_device_power power ; struct acpi_device_wakeup wakeup ; struct acpi_device_perf performance ; struct acpi_device_dir dir ; struct acpi_device_data data ; struct acpi_scan_handler *handler ; struct acpi_hotplug_context *hp ; struct acpi_driver *driver ; struct acpi_gpio_mapping const *driver_gpios ; void *driver_data ; struct device dev ; unsigned int physical_node_count ; unsigned int dep_unmet ; struct list_head physical_node_list ; struct mutex physical_node_lock ; void (*remove)(struct acpi_device * ) ; }; struct acpi_gpio_params { unsigned int crs_entry_index ; unsigned int line_index ; bool active_low ; }; struct acpi_gpio_mapping { char const *name ; struct acpi_gpio_params const *data ; unsigned int size ; }; enum ata_lpm_policy { ATA_LPM_UNKNOWN = 0, ATA_LPM_MAX_POWER = 1, ATA_LPM_MED_POWER = 2, ATA_LPM_MIN_POWER = 3 } ; struct ata_port_operations; struct ata_port; struct ata_link; struct ata_queued_cmd; enum sw_activity { OFF = 0, BLINK_ON = 1, BLINK_OFF = 2 } ; struct ata_taskfile { unsigned long flags ; u8 protocol ; u8 ctl ; u8 hob_feature ; u8 hob_nsect ; u8 hob_lbal ; u8 hob_lbam ; u8 hob_lbah ; u8 feature ; u8 nsect ; u8 lbal ; u8 lbam ; u8 lbah ; u8 device ; u8 command ; u32 auxiliary ; }; struct ata_ioports { void *cmd_addr ; void *data_addr ; void *error_addr ; void *feature_addr ; void *nsect_addr ; void *lbal_addr ; void *lbam_addr ; void *lbah_addr ; void *device_addr ; void *status_addr ; void *command_addr ; void *altstatus_addr ; void *ctl_addr ; void *bmdma_addr ; void *scr_addr ; }; struct ata_host { spinlock_t lock ; struct device *dev ; void * const *iomap ; unsigned int n_ports ; unsigned int n_tags ; void *private_data ; struct ata_port_operations *ops ; unsigned long flags ; struct mutex eh_mutex ; struct task_struct *eh_owner ; struct ata_port *simplex_claimed ; struct ata_port *ports[0U] ; }; struct ata_device; struct ata_queued_cmd { struct ata_port *ap ; struct ata_device *dev ; struct scsi_cmnd *scsicmd ; void (*scsidone)(struct scsi_cmnd * ) ; struct ata_taskfile tf ; u8 cdb[16U] ; unsigned long flags ; unsigned int tag ; unsigned int n_elem ; unsigned int orig_n_elem ; int dma_dir ; unsigned int sect_size ; unsigned int nbytes ; unsigned int extrabytes ; unsigned int curbytes ; struct scatterlist sgent ; struct scatterlist *sg ; struct scatterlist *cursg ; unsigned int cursg_ofs ; unsigned int err_mask ; struct ata_taskfile result_tf ; void (*complete_fn)(struct ata_queued_cmd * ) ; void *private_data ; void *lldd_task ; }; struct ata_port_stats { unsigned long unhandled_irq ; unsigned long idle_irq ; unsigned long rw_reqbuf ; }; struct ata_ering_entry { unsigned int eflags ; unsigned int err_mask ; u64 timestamp ; }; struct ata_ering { int cursor ; struct ata_ering_entry ring[32U] ; }; union __anonunion____missing_field_name_259 { u16 id[256U] ; u32 gscr[128U] ; }; struct ata_device { struct ata_link *link ; unsigned int devno ; unsigned int horkage ; unsigned long flags ; struct scsi_device *sdev ; void *private_data ; union acpi_object *gtf_cache ; unsigned int gtf_filter ; void *zpodd ; struct device tdev ; u64 n_sectors ; u64 n_native_sectors ; unsigned int class ; unsigned long unpark_deadline ; u8 pio_mode ; u8 dma_mode ; u8 xfer_mode ; unsigned int xfer_shift ; unsigned int multi_count ; unsigned int max_sectors ; unsigned int cdb_len ; unsigned long pio_mask ; unsigned long mwdma_mask ; unsigned long udma_mask ; u16 cylinders ; u16 heads ; u16 sectors ; union __anonunion____missing_field_name_259 __annonCompField93 ; u8 devslp_timing[8U] ; u8 ncq_send_recv_cmds[16U] ; int spdn_cnt ; struct ata_ering ering ; }; struct ata_eh_info { struct ata_device *dev ; u32 serror ; unsigned int err_mask ; unsigned int action ; unsigned int dev_action[2U] ; unsigned int flags ; unsigned int probe_mask ; char desc[80U] ; int desc_len ; }; struct ata_eh_context { struct ata_eh_info i ; int tries[2U] ; int cmd_timeout_idx[2U][6U] ; unsigned int classes[2U] ; unsigned int did_probe_mask ; unsigned int unloaded_mask ; unsigned int saved_ncq_enabled ; u8 saved_xfer_mode[2U] ; unsigned long last_reset ; }; struct ata_acpi_drive { u32 pio ; u32 dma ; }; struct ata_acpi_gtm { struct ata_acpi_drive drive[2U] ; u32 flags ; }; struct ata_link { struct ata_port *ap ; int pmp ; struct device tdev ; unsigned int active_tag ; u32 sactive ; unsigned int flags ; u32 saved_scontrol ; unsigned int hw_sata_spd_limit ; unsigned int sata_spd_limit ; unsigned int sata_spd ; enum ata_lpm_policy lpm_policy ; struct ata_eh_info eh_info ; struct ata_eh_context eh_context ; struct ata_device device[2U] ; }; struct ata_port { struct Scsi_Host *scsi_host ; struct ata_port_operations *ops ; spinlock_t *lock ; unsigned long flags ; unsigned int pflags ; unsigned int print_id ; unsigned int local_port_no ; unsigned int port_no ; struct ata_ioports ioaddr ; u8 ctl ; u8 last_ctl ; struct ata_link *sff_pio_task_link ; struct delayed_work sff_pio_task ; struct ata_bmdma_prd *bmdma_prd ; dma_addr_t bmdma_prd_dma ; unsigned int pio_mask ; unsigned int mwdma_mask ; unsigned int udma_mask ; unsigned int cbl ; struct ata_queued_cmd qcmd[32U] ; unsigned long sas_tag_allocated ; unsigned int qc_active ; int nr_active_links ; unsigned int sas_last_tag ; struct ata_link link ; struct ata_link *slave_link ; int nr_pmp_links ; struct ata_link *pmp_link ; struct ata_link *excl_link ; struct ata_port_stats stats ; struct ata_host *host ; struct device *dev ; struct device tdev ; struct mutex scsi_scan_mutex ; struct delayed_work hotplug_task ; struct work_struct scsi_rescan_task ; unsigned int hsm_task_state ; u32 msg_enable ; struct list_head eh_done_q ; wait_queue_head_t eh_wait_q ; int eh_tries ; struct completion park_req_pending ; pm_message_t pm_mesg ; enum ata_lpm_policy target_lpm_policy ; struct timer_list fastdrain_timer ; unsigned long fastdrain_cnt ; int em_message_type ; void *private_data ; struct ata_acpi_gtm __acpi_init_gtm ; u8 sector_buf[512U] ; }; struct ata_port_operations { int (*qc_defer)(struct ata_queued_cmd * ) ; int (*check_atapi_dma)(struct ata_queued_cmd * ) ; void (*qc_prep)(struct ata_queued_cmd * ) ; unsigned int (*qc_issue)(struct ata_queued_cmd * ) ; bool (*qc_fill_rtf)(struct ata_queued_cmd * ) ; int (*cable_detect)(struct ata_port * ) ; unsigned long (*mode_filter)(struct ata_device * , unsigned long ) ; void (*set_piomode)(struct ata_port * , struct ata_device * ) ; void (*set_dmamode)(struct ata_port * , struct ata_device * ) ; int (*set_mode)(struct ata_link * , struct ata_device ** ) ; unsigned int (*read_id)(struct ata_device * , struct ata_taskfile * , u16 * ) ; void (*dev_config)(struct ata_device * ) ; void (*freeze)(struct ata_port * ) ; void (*thaw)(struct ata_port * ) ; int (*prereset)(struct ata_link * , unsigned long ) ; int (*softreset)(struct ata_link * , unsigned int * , unsigned long ) ; int (*hardreset)(struct ata_link * , unsigned int * , unsigned long ) ; void (*postreset)(struct ata_link * , unsigned int * ) ; int (*pmp_prereset)(struct ata_link * , unsigned long ) ; int (*pmp_softreset)(struct ata_link * , unsigned int * , unsigned long ) ; int (*pmp_hardreset)(struct ata_link * , unsigned int * , unsigned long ) ; void (*pmp_postreset)(struct ata_link * , unsigned int * ) ; void (*error_handler)(struct ata_port * ) ; void (*lost_interrupt)(struct ata_port * ) ; void (*post_internal_cmd)(struct ata_queued_cmd * ) ; void (*sched_eh)(struct ata_port * ) ; void (*end_eh)(struct ata_port * ) ; int (*scr_read)(struct ata_link * , unsigned int , u32 * ) ; int (*scr_write)(struct ata_link * , unsigned int , u32 ) ; void (*pmp_attach)(struct ata_port * ) ; void (*pmp_detach)(struct ata_port * ) ; int (*set_lpm)(struct ata_link * , enum ata_lpm_policy , unsigned int ) ; int (*port_suspend)(struct ata_port * , pm_message_t ) ; int (*port_resume)(struct ata_port * ) ; int (*port_start)(struct ata_port * ) ; void (*port_stop)(struct ata_port * ) ; void (*host_stop)(struct ata_host * ) ; void (*sff_dev_select)(struct ata_port * , unsigned int ) ; void (*sff_set_devctl)(struct ata_port * , u8 ) ; u8 (*sff_check_status)(struct ata_port * ) ; u8 (*sff_check_altstatus)(struct ata_port * ) ; void (*sff_tf_load)(struct ata_port * , struct ata_taskfile const * ) ; void (*sff_tf_read)(struct ata_port * , struct ata_taskfile * ) ; void (*sff_exec_command)(struct ata_port * , struct ata_taskfile const * ) ; unsigned int (*sff_data_xfer)(struct ata_device * , unsigned char * , unsigned int , int ) ; void (*sff_irq_on)(struct ata_port * ) ; bool (*sff_irq_check)(struct ata_port * ) ; void (*sff_irq_clear)(struct ata_port * ) ; void (*sff_drain_fifo)(struct ata_queued_cmd * ) ; void (*bmdma_setup)(struct ata_queued_cmd * ) ; void (*bmdma_start)(struct ata_queued_cmd * ) ; void (*bmdma_stop)(struct ata_queued_cmd * ) ; u8 (*bmdma_status)(struct ata_port * ) ; ssize_t (*em_show)(struct ata_port * , char * ) ; ssize_t (*em_store)(struct ata_port * , char const * , size_t ) ; ssize_t (*sw_activity_show)(struct ata_device * , char * ) ; ssize_t (*sw_activity_store)(struct ata_device * , enum sw_activity ) ; ssize_t (*transmit_led_message)(struct ata_port * , u32 , ssize_t ) ; void (*phy_reset)(struct ata_port * ) ; void (*eng_timeout)(struct ata_port * ) ; struct ata_port_operations const *inherits ; }; struct scsi_sense_hdr; enum scsi_device_state { SDEV_CREATED = 1, SDEV_RUNNING = 2, SDEV_CANCEL = 3, SDEV_DEL = 4, SDEV_QUIESCE = 5, SDEV_OFFLINE = 6, SDEV_TRANSPORT_OFFLINE = 7, SDEV_BLOCK = 8, SDEV_CREATED_BLOCK = 9 } ; struct scsi_dh_data; struct scsi_device { struct Scsi_Host *host ; struct request_queue *request_queue ; struct list_head siblings ; struct list_head same_target_siblings ; atomic_t device_busy ; atomic_t device_blocked ; spinlock_t list_lock ; struct list_head cmd_list ; struct list_head starved_entry ; struct scsi_cmnd *current_cmnd ; unsigned short queue_depth ; unsigned short max_queue_depth ; unsigned short last_queue_full_depth ; unsigned short last_queue_full_count ; unsigned long last_queue_full_time ; unsigned long queue_ramp_up_period ; unsigned long last_queue_ramp_up ; unsigned int id ; unsigned int channel ; u64 lun ; unsigned int manufacturer ; unsigned int sector_size ; void *hostdata ; char type ; char scsi_level ; char inq_periph_qual ; unsigned char inquiry_len ; unsigned char *inquiry ; char const *vendor ; char const *model ; char const *rev ; int vpd_pg83_len ; unsigned char *vpd_pg83 ; int vpd_pg80_len ; unsigned char *vpd_pg80 ; unsigned char current_tag ; struct scsi_target *sdev_target ; unsigned int sdev_bflags ; unsigned int eh_timeout ; unsigned char removable : 1 ; unsigned char changed : 1 ; unsigned char busy : 1 ; unsigned char lockable : 1 ; unsigned char locked : 1 ; unsigned char borken : 1 ; unsigned char disconnect : 1 ; unsigned char soft_reset : 1 ; unsigned char sdtr : 1 ; unsigned char wdtr : 1 ; unsigned char ppr : 1 ; unsigned char tagged_supported : 1 ; unsigned char simple_tags : 1 ; unsigned char was_reset : 1 ; unsigned char expecting_cc_ua : 1 ; unsigned char use_10_for_rw : 1 ; unsigned char use_10_for_ms : 1 ; unsigned char no_report_opcodes : 1 ; unsigned char no_write_same : 1 ; unsigned char use_16_for_rw : 1 ; unsigned char skip_ms_page_8 : 1 ; unsigned char skip_ms_page_3f : 1 ; unsigned char skip_vpd_pages : 1 ; unsigned char try_vpd_pages : 1 ; unsigned char use_192_bytes_for_3f : 1 ; unsigned char no_start_on_add : 1 ; unsigned char allow_restart : 1 ; unsigned char manage_start_stop : 1 ; unsigned char start_stop_pwr_cond : 1 ; unsigned char no_uld_attach : 1 ; unsigned char select_no_atn : 1 ; unsigned char fix_capacity : 1 ; unsigned char guess_capacity : 1 ; unsigned char retry_hwerror : 1 ; unsigned char last_sector_bug : 1 ; unsigned char no_read_disc_info : 1 ; unsigned char no_read_capacity_16 : 1 ; unsigned char try_rc_10_first : 1 ; unsigned char is_visible : 1 ; unsigned char wce_default_on : 1 ; unsigned char no_dif : 1 ; unsigned char broken_fua : 1 ; unsigned char lun_in_cdb : 1 ; atomic_t disk_events_disable_depth ; unsigned long supported_events[1U] ; unsigned long pending_events[1U] ; struct list_head event_list ; struct work_struct event_work ; unsigned int max_device_blocked ; atomic_t iorequest_cnt ; atomic_t iodone_cnt ; atomic_t ioerr_cnt ; struct device sdev_gendev ; struct device sdev_dev ; struct execute_work ew ; struct work_struct requeue_work ; struct scsi_dh_data *scsi_dh_data ; enum scsi_device_state sdev_state ; unsigned long sdev_data[0U] ; }; struct scsi_device_handler { struct list_head list ; struct module *module ; char const *name ; int (*check_sense)(struct scsi_device * , struct scsi_sense_hdr * ) ; struct scsi_dh_data *(*attach)(struct scsi_device * ) ; void (*detach)(struct scsi_device * ) ; int (*activate)(struct scsi_device * , void (*)(void * , int ) , void * ) ; int (*prep_fn)(struct scsi_device * , struct request * ) ; int (*set_params)(struct scsi_device * , char const * ) ; bool (*match)(struct scsi_device * ) ; }; struct scsi_dh_data { struct scsi_device_handler *scsi_dh ; struct scsi_device *sdev ; struct kref kref ; }; enum scsi_target_state { STARGET_CREATED = 1, STARGET_RUNNING = 2, STARGET_DEL = 3 } ; struct scsi_target { struct scsi_device *starget_sdev_user ; struct list_head siblings ; struct list_head devices ; struct device dev ; struct kref reap_ref ; unsigned int channel ; unsigned int id ; unsigned char create : 1 ; unsigned char single_lun : 1 ; unsigned char pdt_1f_for_no_lun : 1 ; unsigned char no_report_luns : 1 ; unsigned char expecting_lun_change : 1 ; atomic_t target_busy ; atomic_t target_blocked ; unsigned int can_queue ; unsigned int max_target_blocked ; char scsi_level ; enum scsi_target_state state ; void *hostdata ; unsigned long starget_data[0U] ; }; struct scsi_data_buffer { struct sg_table table ; unsigned int length ; int resid ; }; struct scsi_pointer { char *ptr ; int this_residual ; struct scatterlist *buffer ; int buffers_residual ; dma_addr_t dma_handle ; int volatile Status ; int volatile Message ; int volatile have_data_in ; int volatile sent_command ; int volatile phase ; }; struct scsi_cmnd { struct scsi_device *device ; struct list_head list ; struct list_head eh_entry ; struct delayed_work abort_work ; int eh_eflags ; unsigned long serial_number ; unsigned long jiffies_at_alloc ; int retries ; int allowed ; unsigned char prot_op ; unsigned char prot_type ; unsigned char prot_flags ; unsigned short cmd_len ; enum dma_data_direction sc_data_direction ; unsigned char *cmnd ; struct scsi_data_buffer sdb ; struct scsi_data_buffer *prot_sdb ; unsigned int underflow ; unsigned int transfersize ; struct request *request ; unsigned char *sense_buffer ; void (*scsi_done)(struct scsi_cmnd * ) ; struct scsi_pointer SCp ; unsigned char *host_scribble ; int result ; int flags ; unsigned char tag ; }; struct sas_rphy; enum sas_linkrate { SAS_LINK_RATE_UNKNOWN = 0, SAS_PHY_DISABLED = 1, SAS_PHY_RESET_PROBLEM = 2, SAS_SATA_SPINUP_HOLD = 3, SAS_SATA_PORT_SELECTOR = 4, SAS_PHY_RESET_IN_PROGRESS = 5, SAS_LINK_RATE_1_5_GBPS = 8, SAS_LINK_RATE_G1 = 8, SAS_LINK_RATE_3_0_GBPS = 9, SAS_LINK_RATE_G2 = 9, SAS_LINK_RATE_6_0_GBPS = 10, SAS_LINK_RATE_12_0_GBPS = 11, SAS_LINK_RATE_FAILED = 16, SAS_PHY_VIRTUAL = 17 } ; struct sas_identify { enum sas_device_type device_type ; enum sas_protocol initiator_port_protocols ; enum sas_protocol target_port_protocols ; u64 sas_address ; u8 phy_identifier ; }; struct sas_phy { struct device dev ; int number ; int enabled ; struct sas_identify identify ; enum sas_linkrate negotiated_linkrate ; enum sas_linkrate minimum_linkrate_hw ; enum sas_linkrate minimum_linkrate ; enum sas_linkrate maximum_linkrate_hw ; enum sas_linkrate maximum_linkrate ; u32 invalid_dword_count ; u32 running_disparity_error_count ; u32 loss_of_dword_sync_count ; u32 phy_reset_problem_count ; struct list_head port_siblings ; void *hostdata ; }; struct sas_rphy { struct device dev ; struct sas_identify identify ; struct list_head list ; struct request_queue *q ; u32 scsi_target_id ; }; struct sas_port { struct device dev ; int port_identifier ; int num_phys ; unsigned char is_backlink : 1 ; struct sas_rphy *rphy ; struct mutex phy_list_mutex ; struct list_head phy_list ; }; enum sas_class { SAS = 0, EXPANDER = 1 } ; enum sas_phy_role { PHY_ROLE_NONE = 0, PHY_ROLE_TARGET = 64, PHY_ROLE_INITIATOR = 128 } ; enum sas_phy_type { PHY_TYPE_PHYSICAL = 0, PHY_TYPE_VIRTUAL = 1 } ; enum ha_event { HAE_RESET = 0, HA_NUM_EVENTS = 1 } ; enum port_event { PORTE_BYTES_DMAED = 0, PORTE_BROADCAST_RCVD = 1, PORTE_LINK_RESET_ERR = 2, PORTE_TIMER_EVENT = 3, PORTE_HARD_RESET = 4, PORT_NUM_EVENTS = 5 } ; enum phy_event { PHYE_LOSS_OF_SIGNAL = 0, PHYE_OOB_DONE = 1, PHYE_OOB_ERROR = 2, PHYE_SPINUP_HOLD = 3, PHYE_RESUME_TIMEOUT = 4, PHY_NUM_EVENTS = 5 } ; enum routing_attribute { DIRECT_ROUTING = 0, SUBTRACTIVE_ROUTING = 1, TABLE_ROUTING = 2 } ; enum ex_phy_state { PHY_EMPTY = 0, PHY_VACANT = 1, PHY_NOT_PRESENT = 2, PHY_DEVICE_DISCOVERED = 3 } ; struct ex_phy { int phy_id ; enum ex_phy_state phy_state ; enum sas_device_type attached_dev_type ; enum sas_linkrate linkrate ; unsigned char attached_sata_host : 1 ; unsigned char attached_sata_dev : 1 ; unsigned char attached_sata_ps : 1 ; enum sas_protocol attached_tproto ; enum sas_protocol attached_iproto ; u8 attached_sas_addr[8U] ; u8 attached_phy_id ; int phy_change_count ; enum routing_attribute routing_attr ; unsigned char virtual : 1 ; int last_da_index ; struct sas_phy *phy ; struct sas_port *port ; }; struct expander_device { struct list_head children ; int ex_change_count ; u16 max_route_indexes ; u8 num_phys ; unsigned char t2t_supp : 1 ; unsigned char configuring : 1 ; unsigned char conf_route_table : 1 ; u8 enclosure_logical_id[8U] ; struct ex_phy *ex_phy ; struct sas_port *parent_port ; struct mutex cmd_mutex ; }; struct sata_device { unsigned int class ; struct smp_resp rps_resp ; u8 port_no ; struct ata_port *ap ; struct ata_host ata_host ; u8 fis[24U] ; }; struct ssp_device { struct list_head eh_list_node ; struct scsi_lun reset_lun ; }; struct asd_sas_port; union __anonunion____missing_field_name_260 { struct expander_device ex_dev ; struct sata_device sata_dev ; struct ssp_device ssp_dev ; }; struct domain_device { spinlock_t done_lock ; enum sas_device_type dev_type ; enum sas_linkrate linkrate ; enum sas_linkrate min_linkrate ; enum sas_linkrate max_linkrate ; int pathways ; struct domain_device *parent ; struct list_head siblings ; struct asd_sas_port *port ; struct sas_phy *phy ; struct list_head dev_list_node ; struct list_head disco_list_node ; enum sas_protocol iproto ; enum sas_protocol tproto ; struct sas_rphy *rphy ; u8 sas_addr[8U] ; u8 hashed_sas_addr[3U] ; u8 frame_rcvd[32U] ; union __anonunion____missing_field_name_260 __annonCompField94 ; void *lldd_dev ; unsigned long state ; struct kref kref ; }; struct sas_work { struct list_head drain_node ; struct work_struct work ; }; struct sas_discovery_event { struct sas_work work ; struct asd_sas_port *port ; }; struct sas_discovery { struct sas_discovery_event disc_work[7U] ; unsigned long pending ; u8 fanout_sas_addr[8U] ; u8 eeds_a[8U] ; u8 eeds_b[8U] ; int max_level ; }; struct sas_ha_struct; struct asd_sas_port { struct completion port_gone_completion ; struct sas_discovery disc ; struct domain_device *port_dev ; spinlock_t dev_list_lock ; struct list_head dev_list ; struct list_head disco_list ; struct list_head destroy_list ; enum sas_linkrate linkrate ; struct sas_work work ; int suspended ; int id ; enum sas_class class ; u8 sas_addr[8U] ; u8 attached_sas_addr[8U] ; enum sas_protocol iproto ; enum sas_protocol tproto ; enum sas_oob_mode oob_mode ; spinlock_t phy_list_lock ; struct list_head phy_list ; int num_phys ; u32 phy_mask ; struct sas_ha_struct *ha ; struct sas_port *port ; void *lldd_port ; }; struct asd_sas_phy; struct asd_sas_event { struct sas_work work ; struct asd_sas_phy *phy ; }; struct asd_sas_phy { struct asd_sas_event port_events[5U] ; struct asd_sas_event phy_events[5U] ; unsigned long port_events_pending ; unsigned long phy_events_pending ; int error ; int suspended ; struct sas_phy *phy ; int enabled ; int id ; enum sas_class class ; enum sas_protocol iproto ; enum sas_protocol tproto ; enum sas_phy_type type ; enum sas_phy_role role ; enum sas_oob_mode oob_mode ; enum sas_linkrate linkrate ; u8 *sas_addr ; u8 attached_sas_addr[8U] ; spinlock_t frame_rcvd_lock ; u8 *frame_rcvd ; int frame_rcvd_size ; spinlock_t sas_prim_lock ; u32 sas_prim ; struct list_head port_phy_el ; struct asd_sas_port *port ; struct sas_ha_struct *ha ; void *lldd_phy ; }; struct scsi_core { struct Scsi_Host *shost ; }; struct sas_ha_event { struct sas_work work ; struct sas_ha_struct *ha ; }; struct sas_ha_struct { struct sas_ha_event ha_events[1U] ; unsigned long pending ; struct list_head defer_q ; struct mutex drain_mutex ; unsigned long state ; spinlock_t lock ; int eh_active ; wait_queue_head_t eh_wait_q ; struct list_head eh_dev_q ; struct mutex disco_mutex ; struct scsi_core core ; char *sas_ha_name ; struct device *dev ; struct module *lldd_module ; u8 *sas_addr ; u8 hashed_sas_addr[3U] ; spinlock_t phy_port_lock ; struct asd_sas_phy **sas_phy ; struct asd_sas_port **sas_port ; int num_phys ; int strict_wide_ports ; void (*notify_ha_event)(struct sas_ha_struct * , enum ha_event ) ; void (*notify_port_event)(struct asd_sas_phy * , enum port_event ) ; void (*notify_phy_event)(struct asd_sas_phy * , enum phy_event ) ; void *lldd_ha ; struct list_head eh_done_q ; struct list_head eh_ata_q ; }; enum service_response { SAS_TASK_COMPLETE = 0, SAS_TASK_UNDELIVERED = -1 } ; enum exec_status { __SAM_STAT_CHECK_CONDITION = 2, SAS_DEV_NO_RESPONSE = 128, SAS_DATA_UNDERRUN = 129, SAS_DATA_OVERRUN = 130, SAS_INTERRUPTED = 131, SAS_QUEUE_FULL = 132, SAS_DEVICE_UNKNOWN = 133, SAS_SG_ERR = 134, SAS_OPEN_REJECT = 135, SAS_OPEN_TO = 136, SAS_PROTO_RESPONSE = 137, SAS_PHY_DOWN = 138, SAS_NAK_R_ERR = 139, SAS_PENDING = 140, SAS_ABORTED_TASK = 141 } ; struct task_status_struct { enum service_response resp ; enum exec_status stat ; int buf_valid_size ; u8 buf[96U] ; u32 residual ; enum sas_open_rej_reason open_rej_reason ; }; struct sas_ata_task { struct host_to_dev_fis fis ; u8 atapi_packet[16U] ; u8 retry_count ; unsigned char dma_xfer : 1 ; unsigned char use_ncq : 1 ; unsigned char set_affil_pol : 1 ; unsigned char stp_affil_pol : 1 ; unsigned char device_control_reg_update : 1 ; }; struct sas_smp_task { struct scatterlist smp_req ; struct scatterlist smp_resp ; }; enum task_attribute { TASK_ATTR_SIMPLE = 0, TASK_ATTR_HOQ = 1, TASK_ATTR_ORDERED = 2, TASK_ATTR_ACA = 4 } ; struct sas_ssp_task { u8 retry_count ; u8 LUN[8U] ; unsigned char enable_first_burst : 1 ; enum task_attribute task_attr ; u8 task_prio ; struct scsi_cmnd *cmd ; }; union __anonunion____missing_field_name_261 { struct sas_ata_task ata_task ; struct sas_smp_task smp_task ; struct sas_ssp_task ssp_task ; }; struct sas_task_slow; struct sas_task { struct domain_device *dev ; spinlock_t task_state_lock ; unsigned int task_state_flags ; enum sas_protocol task_proto ; union __anonunion____missing_field_name_261 __annonCompField95 ; struct scatterlist *scatter ; int num_scatter ; u32 total_xfer_len ; unsigned char data_dir : 2 ; struct task_status_struct task_status ; void (*task_done)(struct sas_task * ) ; void *lldd_task ; void *uldd_task ; struct sas_task_slow *slow_task ; }; struct sas_task_slow { struct timer_list timer ; struct completion completion ; }; struct sas_domain_function_template { void (*lldd_port_formed)(struct asd_sas_phy * ) ; void (*lldd_port_deformed)(struct asd_sas_phy * ) ; int (*lldd_dev_found)(struct domain_device * ) ; void (*lldd_dev_gone)(struct domain_device * ) ; int (*lldd_execute_task)(struct sas_task * , gfp_t ) ; int (*lldd_abort_task)(struct sas_task * ) ; int (*lldd_abort_task_set)(struct domain_device * , u8 * ) ; int (*lldd_clear_aca)(struct domain_device * , u8 * ) ; int (*lldd_clear_task_set)(struct domain_device * , u8 * ) ; int (*lldd_I_T_nexus_reset)(struct domain_device * ) ; int (*lldd_ata_check_ready)(struct domain_device * ) ; void (*lldd_ata_set_dmamode)(struct domain_device * ) ; int (*lldd_lu_reset)(struct domain_device * , u8 * ) ; int (*lldd_query_task)(struct sas_task * ) ; int (*lldd_clear_nexus_port)(struct asd_sas_port * ) ; int (*lldd_clear_nexus_ha)(struct sas_ha_struct * ) ; int (*lldd_control_phy)(struct asd_sas_phy * , enum phy_func , void * ) ; int (*lldd_write_gpio)(struct sas_ha_struct * , u8 , u8 , u8 , u8 * ) ; }; struct pm8001_dispatch; struct pm8001_hba_info; struct pm8001_ccb_info; struct pm8001_device; struct pm8001_tmf_task { u8 tmf ; u32 tag_of_task_to_be_managed ; }; struct pm8001_ioctl_payload { u32 signature ; u16 major_function ; u16 minor_function ; u16 length ; u16 status ; u16 offset ; u16 id ; u8 *func_specific ; }; struct __anonstruct_gsm_buf_263 { u32 direct_len ; u32 direct_offset ; void *direct_data ; }; struct __anonstruct_queue_buf_264 { u16 queue_type ; u16 queue_index ; u32 direct_len ; void *direct_data ; }; struct __anonstruct_data_buf_265 { u32 direct_len ; u32 direct_offset ; u32 read_len ; void *direct_data ; }; union __anonunion____missing_field_name_262 { struct __anonstruct_gsm_buf_263 gsm_buf ; struct __anonstruct_queue_buf_264 queue_buf ; struct __anonstruct_data_buf_265 data_buf ; }; struct forensic_data { u32 data_type ; union __anonunion____missing_field_name_262 __annonCompField96 ; }; struct pm8001_dispatch { char *name ; int (*chip_init)(struct pm8001_hba_info * ) ; int (*chip_soft_rst)(struct pm8001_hba_info * ) ; void (*chip_rst)(struct pm8001_hba_info * ) ; int (*chip_ioremap)(struct pm8001_hba_info * ) ; void (*chip_iounmap)(struct pm8001_hba_info * ) ; irqreturn_t (*isr)(struct pm8001_hba_info * , u8 ) ; u32 (*is_our_interupt)(struct pm8001_hba_info * ) ; int (*isr_process_oq)(struct pm8001_hba_info * , u8 ) ; void (*interrupt_enable)(struct pm8001_hba_info * , u8 ) ; void (*interrupt_disable)(struct pm8001_hba_info * , u8 ) ; void (*make_prd)(struct scatterlist * , int , void * ) ; int (*smp_req)(struct pm8001_hba_info * , struct pm8001_ccb_info * ) ; int (*ssp_io_req)(struct pm8001_hba_info * , struct pm8001_ccb_info * ) ; int (*sata_req)(struct pm8001_hba_info * , struct pm8001_ccb_info * ) ; int (*phy_start_req)(struct pm8001_hba_info * , u8 ) ; int (*phy_stop_req)(struct pm8001_hba_info * , u8 ) ; int (*reg_dev_req)(struct pm8001_hba_info * , struct pm8001_device * , u32 ) ; int (*dereg_dev_req)(struct pm8001_hba_info * , u32 ) ; int (*phy_ctl_req)(struct pm8001_hba_info * , u32 , u32 ) ; int (*task_abort)(struct pm8001_hba_info * , struct pm8001_device * , u8 , u32 , u32 ) ; int (*ssp_tm_req)(struct pm8001_hba_info * , struct pm8001_ccb_info * , struct pm8001_tmf_task * ) ; int (*get_nvmd_req)(struct pm8001_hba_info * , void * ) ; int (*set_nvmd_req)(struct pm8001_hba_info * , void * ) ; int (*fw_flash_update_req)(struct pm8001_hba_info * , void * ) ; int (*set_dev_state_req)(struct pm8001_hba_info * , struct pm8001_device * , u32 ) ; int (*sas_diag_start_end_req)(struct pm8001_hba_info * , u32 ) ; int (*sas_diag_execute_req)(struct pm8001_hba_info * , u32 ) ; int (*sas_re_init_req)(struct pm8001_hba_info * ) ; }; struct pm8001_chip_info { u32 encrypt ; u32 n_phy ; struct pm8001_dispatch const *dispatch ; }; struct pm8001_port { struct asd_sas_port sas_port ; u8 port_attached ; u8 wide_port_phymap ; u8 port_state ; struct list_head list ; }; struct pm8001_phy { struct pm8001_hba_info *pm8001_ha ; struct pm8001_port *port ; struct asd_sas_phy sas_phy ; struct sas_identify identify ; struct scsi_device *sdev ; u64 dev_sas_addr ; u32 phy_type ; struct completion *enable_completion ; u32 frame_rcvd_size ; u8 frame_rcvd[32U] ; u8 phy_attached ; u8 phy_state ; enum sas_linkrate minimum_linkrate ; enum sas_linkrate maximum_linkrate ; }; struct pm8001_device { enum sas_device_type dev_type ; struct domain_device *sas_device ; u32 attached_phy ; u32 id ; struct completion *dcompletion ; struct completion *setds_completion ; u32 device_id ; u32 running_req ; }; struct pm8001_prd_imt { __le32 len ; __le32 e ; }; struct pm8001_prd { __le64 addr ; struct pm8001_prd_imt im_len ; }; struct fw_control_ex; struct pm8001_ccb_info { struct list_head entry ; struct sas_task *task ; u32 n_elem ; u32 ccb_tag ; dma_addr_t ccb_dma_handle ; struct pm8001_device *device ; struct pm8001_prd buf_prd[128U] ; struct fw_control_ex *fw_control_context ; u8 open_retry ; }; struct mpi_mem { void *virt_ptr ; dma_addr_t phys_addr ; u32 phys_addr_hi ; u32 phys_addr_lo ; u32 total_len ; u32 num_elements ; u32 element_size ; u32 alignment ; }; struct mpi_mem_req { u32 count ; struct mpi_mem region[16U] ; }; struct encrypt { u32 cipher_mode ; u32 sec_mode ; u32 status ; u32 flag ; }; struct sas_phy_attribute_table { u32 phystart1_16[16U] ; u32 outbound_hw_event_pid1_16[16U] ; }; struct __anonstruct_pm8001_tbl_266 { u32 signature ; u32 interface_rev ; u32 firmware_rev ; u32 max_out_io ; u32 max_sgl ; u32 ctrl_cap_flag ; u32 gst_offset ; u32 inbound_queue_offset ; u32 outbound_queue_offset ; u32 inbound_q_nppd_hppd ; u32 outbound_hw_event_pid0_3 ; u32 outbound_hw_event_pid4_7 ; u32 outbound_ncq_event_pid0_3 ; u32 outbound_ncq_event_pid4_7 ; u32 outbound_tgt_ITNexus_event_pid0_3 ; u32 outbound_tgt_ITNexus_event_pid4_7 ; u32 outbound_tgt_ssp_event_pid0_3 ; u32 outbound_tgt_ssp_event_pid4_7 ; u32 outbound_tgt_smp_event_pid0_3 ; u32 outbound_tgt_smp_event_pid4_7 ; u32 upper_event_log_addr ; u32 lower_event_log_addr ; u32 event_log_size ; u32 event_log_option ; u32 upper_iop_event_log_addr ; u32 lower_iop_event_log_addr ; u32 iop_event_log_size ; u32 iop_event_log_option ; u32 fatal_err_interrupt ; u32 fatal_err_dump_offset0 ; u32 fatal_err_dump_length0 ; u32 fatal_err_dump_offset1 ; u32 fatal_err_dump_length1 ; u32 hda_mode_flag ; u32 anolog_setup_table_offset ; u32 rsvd[4U] ; }; struct __anonstruct_pm80xx_tbl_267 { u32 signature ; u32 interface_rev ; u32 firmware_rev ; u32 max_out_io ; u32 max_sgl ; u32 ctrl_cap_flag ; u32 gst_offset ; u32 inbound_queue_offset ; u32 outbound_queue_offset ; u32 inbound_q_nppd_hppd ; u32 rsvd[8U] ; u32 crc_core_dump ; u32 rsvd1 ; u32 upper_event_log_addr ; u32 lower_event_log_addr ; u32 event_log_size ; u32 event_log_severity ; u32 upper_pcs_event_log_addr ; u32 lower_pcs_event_log_addr ; u32 pcs_event_log_size ; u32 pcs_event_log_severity ; u32 fatal_err_interrupt ; u32 fatal_err_dump_offset0 ; u32 fatal_err_dump_length0 ; u32 fatal_err_dump_offset1 ; u32 fatal_err_dump_length1 ; u32 gpio_led_mapping ; u32 analog_setup_table_offset ; u32 int_vec_table_offset ; u32 phy_attr_table_offset ; u32 port_recovery_timer ; u32 interrupt_reassertion_delay ; u32 fatal_n_non_fatal_dump ; }; union main_cfg_table { struct __anonstruct_pm8001_tbl_266 pm8001_tbl ; struct __anonstruct_pm80xx_tbl_267 pm80xx_tbl ; }; struct __anonstruct_pm8001_tbl_268 { u32 gst_len_mpistate ; u32 iq_freeze_state0 ; u32 iq_freeze_state1 ; u32 msgu_tcnt ; u32 iop_tcnt ; u32 rsvd ; u32 phy_state[8U] ; u32 gpio_input_val ; u32 rsvd1[2U] ; u32 recover_err_info[8U] ; }; struct __anonstruct_pm80xx_tbl_269 { u32 gst_len_mpistate ; u32 iq_freeze_state0 ; u32 iq_freeze_state1 ; u32 msgu_tcnt ; u32 iop_tcnt ; u32 rsvd[9U] ; u32 gpio_input_val ; u32 rsvd1[2U] ; u32 recover_err_info[8U] ; }; union general_status_table { struct __anonstruct_pm8001_tbl_268 pm8001_tbl ; struct __anonstruct_pm80xx_tbl_269 pm80xx_tbl ; }; struct inbound_queue_table { u32 element_pri_size_cnt ; u32 upper_base_addr ; u32 lower_base_addr ; u32 ci_upper_base_addr ; u32 ci_lower_base_addr ; u32 pi_pci_bar ; u32 pi_offset ; u32 total_length ; void *base_virt ; void *ci_virt ; u32 reserved ; __le32 consumer_index ; u32 producer_idx ; }; struct outbound_queue_table { u32 element_size_cnt ; u32 upper_base_addr ; u32 lower_base_addr ; void *base_virt ; u32 pi_upper_base_addr ; u32 pi_lower_base_addr ; u32 ci_pci_bar ; u32 ci_offset ; u32 total_length ; void *pi_virt ; u32 interrup_vec_cnt_delay ; u32 dinterrup_to_pci_offset ; __le32 producer_index ; u32 consumer_idx ; }; struct pm8001_hba_memspace { void *memvirtaddr ; u64 membase ; u32 memsize ; }; struct isr_param { struct pm8001_hba_info *drv_inst ; u32 irq_id ; }; struct firmware; struct pm8001_hba_info { char name[32U] ; struct list_head list ; unsigned long flags ; spinlock_t lock ; spinlock_t bitmap_lock ; struct pci_dev *pdev ; struct device *dev ; struct pm8001_hba_memspace io_mem[6U] ; struct mpi_mem_req memoryMap ; struct encrypt encrypt_info ; struct forensic_data forensic_info ; u32 fatal_bar_loc ; u32 forensic_last_offset ; u32 fatal_forensic_shift_offset ; u32 forensic_fatal_step ; u32 evtlog_ib_offset ; u32 evtlog_ob_offset ; void *msg_unit_tbl_addr ; void *main_cfg_tbl_addr ; void *general_stat_tbl_addr ; void *inbnd_q_tbl_addr ; void *outbnd_q_tbl_addr ; void *pspa_q_tbl_addr ; void *ivt_tbl_addr ; void *fatal_tbl_addr ; union main_cfg_table main_cfg_tbl ; union general_status_table gs_tbl ; struct inbound_queue_table inbnd_q_tbl[1U] ; struct outbound_queue_table outbnd_q_tbl[4U] ; struct sas_phy_attribute_table phy_attr_table ; u8 sas_addr[8U] ; struct sas_ha_struct *sas ; struct Scsi_Host *shost ; u32 chip_id ; struct pm8001_chip_info const *chip ; struct completion *nvmd_completion ; int tags_num ; unsigned long *tags ; struct pm8001_phy phy[16U] ; struct pm8001_port port[16U] ; u32 id ; u32 irq ; u32 iomb_size ; struct pm8001_device *devices ; struct pm8001_ccb_info *ccb_info ; struct msix_entry msix_entries[64U] ; int number_of_intr ; struct tasklet_struct tasklet[64U] ; u32 logging_level ; u32 fw_status ; u32 smp_exp_mode ; struct firmware const *fw_image ; struct isr_param irq_vector[64U] ; }; struct fw_control_info { u32 retcode ; u32 phase ; u32 phaseCmplt ; u32 version ; u32 offset ; u32 len ; u32 size ; u32 reserved ; u8 buffer[1U] ; }; struct fw_control_ex { struct fw_control_info *fw_control ; void *buffer ; void *virtAddr ; void *usrAddr ; dma_addr_t phys_addr ; u32 len ; void *payload ; u8 inProgress ; void *param1 ; void *param2 ; void *param3 ; }; struct ldv_struct_EMGentry_34 { int signal_pending ; }; struct ldv_struct_free_irq_26 { int arg0 ; int signal_pending ; }; struct ldv_struct_interrupt_instance_0 { int arg0 ; enum irqreturn (*arg1)(int , void * ) ; enum irqreturn (*arg2)(int , void * ) ; void *arg3 ; int signal_pending ; }; struct ldv_struct_pci_instance_2 { struct pci_driver *arg0 ; int signal_pending ; }; struct ldv_struct_scsi_host_template_instance_3 { struct Scsi_Host *arg0 ; int signal_pending ; }; struct ldv_struct_timer_instance_23 { struct timer_list *arg0 ; int signal_pending ; }; typedef int ldv_func_ret_type___0; typedef int ldv_func_ret_type___1; typedef struct Scsi_Host *ldv_func_ret_type___2; typedef int ldv_func_ret_type___3; typedef int ldv_func_ret_type___4; typedef char *__kernel_caddr_t; typedef __u64 __be64; typedef unsigned long uintptr_t; typedef __kernel_caddr_t *caddr_t; enum hrtimer_restart; struct sas_phy_linkrates { enum sas_linkrate maximum_linkrate ; enum sas_linkrate minimum_linkrate ; }; typedef int ldv_func_ret_type___5; enum hrtimer_restart; struct firmware { size_t size ; u8 const *data ; struct page **pages ; void *priv ; }; struct pm8001_fw_image_header { u8 vender_id[8U] ; u8 product_id ; u8 hardware_rev ; u8 dest_partition ; u8 reserved ; u8 fw_rev[4U] ; __be32 image_length ; __be32 image_crc ; __be32 startup_entry ; }; struct flash_command { u8 command[8U] ; int code ; }; struct error_fw { char *reason ; int err_code ; }; enum hrtimer_restart; struct __anonstruct____missing_field_name_239 { unsigned char _un20 : 1 ; unsigned char smp_iport : 1 ; unsigned char stp_iport : 1 ; unsigned char ssp_iport : 1 ; unsigned char _un247 : 4 ; }; union __anonunion____missing_field_name_238 { struct __anonstruct____missing_field_name_239 __annonCompField88 ; u8 initiator_bits ; }; struct __anonstruct____missing_field_name_241 { unsigned char _un30 : 1 ; unsigned char smp_tport : 1 ; unsigned char stp_tport : 1 ; unsigned char ssp_tport : 1 ; unsigned char _un347 : 4 ; }; union __anonunion____missing_field_name_240 { struct __anonstruct____missing_field_name_241 __annonCompField90 ; u8 target_bits ; }; struct sas_identify_frame { unsigned char frame_type : 4 ; unsigned char dev_type : 3 ; unsigned char _un0 : 1 ; u8 _un1 ; union __anonunion____missing_field_name_238 __annonCompField89 ; union __anonunion____missing_field_name_240 __annonCompField91 ; u8 _un4_11[8U] ; u8 sas_addr[8U] ; u8 phy_id ; u8 _un21_27[7U] ; __be32 crc ; }; struct ssp_response_iu { u8 _r_a[10U] ; unsigned char datapres : 2 ; unsigned char _r_b : 6 ; u8 status ; u32 _r_c ; __be32 sense_data_len ; __be32 response_data_len ; u8 resp_data[0U] ; u8 sense_data[0U] ; }; struct ata_task_resp { u16 frame_len ; u8 ending_fis[24U] ; }; struct pm8001_work { struct work_struct work ; struct pm8001_hba_info *pm8001_ha ; void *data ; int handler ; }; struct fw_flash_updata_info { u32 cur_image_offset ; u32 cur_image_len ; u32 total_image_len ; struct pm8001_prd sgl ; }; struct mpi_msg_hdr { __le32 header ; }; struct phy_start_req { __le32 tag ; __le32 ase_sh_lm_slr_phyid ; struct sas_identify_frame sas_identify ; u32 reserved[5U] ; }; struct phy_stop_req { __le32 tag ; __le32 phy_id ; u32 reserved[13U] ; }; struct sata_completion_resp { __le32 tag ; __le32 status ; __le32 param ; u32 sata_resp[12U] ; }; struct hw_event_resp { __le32 lr_evt_status_phyid_portid ; __le32 evt_param ; __le32 npip_portstate ; struct sas_identify_frame sas_identify ; struct dev_to_host_fis sata_fis ; }; struct reg_dev_req { __le32 tag ; __le32 phyid_portid ; __le32 dtype_dlr_retry ; __le32 firstburstsize_ITNexustimeout ; u8 sas_addr[8U] ; __le32 upper_device_id ; u32 reserved[8U] ; }; struct dereg_dev_req { __le32 tag ; __le32 device_id ; u32 reserved[13U] ; }; struct dev_reg_resp { __le32 tag ; __le32 status ; __le32 device_id ; u32 reserved[12U] ; }; struct local_phy_ctl_req { __le32 tag ; __le32 phyop_phyid ; u32 reserved1[13U] ; }; struct local_phy_ctl_resp { __le32 tag ; __le32 phyop_phyid ; __le32 status ; u32 reserved[12U] ; }; struct hw_event_ack_req { __le32 tag ; __le32 sea_phyid_portid ; __le32 param0 ; __le32 param1 ; u32 reserved1[11U] ; }; struct ssp_completion_resp { __le32 tag ; __le32 status ; __le32 param ; __le32 ssptag_rescv_rescpad ; struct ssp_response_iu ssp_resp_iu ; __le32 residual_count ; }; struct sata_event_resp { __le32 tag ; __le32 event ; __le32 port_id ; __le32 device_id ; u32 reserved[11U] ; }; struct ssp_event_resp { __le32 tag ; __le32 event ; __le32 port_id ; __le32 device_id ; u32 reserved[11U] ; }; struct general_event_resp { __le32 status ; __le32 inb_IOMB_payload[14U] ; }; struct __anonstruct_long_smp_req_271 { __le64 long_req_addr ; __le32 long_req_size ; u32 _r_a ; __le64 long_resp_addr ; __le32 long_resp_size ; u32 _r_b ; }; union __anonunion____missing_field_name_270 { u8 smp_req[32U] ; struct __anonstruct_long_smp_req_271 long_smp_req ; }; struct smp_req { __le32 tag ; __le32 device_id ; __le32 len_ip_ir ; u8 smp_req16[16U] ; union __anonunion____missing_field_name_270 __annonCompField97 ; }; struct smp_completion_resp { __le32 tag ; __le32 status ; __le32 param ; __le32 _r_a[12U] ; }; struct task_abort_req { __le32 tag ; __le32 device_id ; __le32 tag_to_abort ; __le32 abort_all ; u32 reserved[11U] ; }; struct task_abort_resp { __le32 tag ; __le32 status ; __le32 scp ; u32 reserved[12U] ; }; struct set_dev_state_req { __le32 tag ; __le32 device_id ; __le32 nds ; u32 reserved[12U] ; }; struct sas_re_initialization_req { __le32 tag ; __le32 SSAHOLT ; __le32 reserved_maxPorts ; __le32 open_reject_cmdretries_data_retries ; __le32 sata_hol_tmo ; u32 reserved1[10U] ; }; struct sata_start_req { __le32 tag ; __le32 device_id ; __le32 data_len ; __le32 ncqtag_atap_dir_m ; struct host_to_dev_fis sata_fis ; u32 reserved1 ; u32 reserved2 ; u32 addr_low ; u32 addr_high ; __le32 len ; __le32 esgl ; }; struct ssp_ini_tm_start_req { __le32 tag ; __le32 device_id ; __le32 relate_tag ; __le32 tmf ; u8 lun[8U] ; __le32 ds_ads_m ; u32 reserved[8U] ; }; struct ssp_info_unit { u8 lun[8U] ; u8 reserved1 ; u8 efb_prio_attr ; u8 reserved2 ; u8 additional_cdb_len ; u8 cdb[16U] ; }; struct ssp_ini_io_start_req { __le32 tag ; __le32 device_id ; __le32 data_len ; __le32 dir_m_tlr ; struct ssp_info_unit ssp_iu ; __le32 addr_low ; __le32 addr_high ; __le32 len ; __le32 esgl ; }; struct fw_flash_Update_req { __le32 tag ; __le32 cur_image_offset ; __le32 cur_image_len ; __le32 total_image_len ; u32 reserved0[7U] ; __le32 sgl_addr_lo ; __le32 sgl_addr_hi ; __le32 len ; __le32 ext_reserved ; }; struct fw_flash_Update_resp { __le32 tag ; __le32 status ; u32 reserved[13U] ; }; struct get_nvm_data_req { __le32 tag ; __le32 len_ir_vpdd ; __le32 vpd_offset ; u32 reserved[8U] ; __le32 resp_addr_lo ; __le32 resp_addr_hi ; __le32 resp_len ; u32 reserved1 ; }; struct set_nvm_data_req { __le32 tag ; __le32 len_ir_vpdd ; __le32 vpd_offset ; __le32 reserved[8U] ; __le32 resp_addr_lo ; __le32 resp_addr_hi ; __le32 resp_len ; u32 reserved1 ; }; struct get_nvm_data_resp { __le32 tag ; __le32 ir_tda_bn_dps_das_nvm ; __le32 dlen_status ; __le32 nvm_data[12U] ; }; struct set_dev_state_resp { __le32 tag ; __le32 status ; __le32 device_id ; __le32 pds_nds ; u32 reserved[11U] ; }; enum hrtimer_restart; struct phy_start_req___0 { __le32 tag ; __le32 ase_sh_lm_slr_phyid ; struct sas_identify_frame sas_identify ; __le32 spasti ; u32 reserved[21U] ; }; struct phy_stop_req___0 { __le32 tag ; __le32 phy_id ; u32 reserved[29U] ; }; struct thermal_hw_event { __le32 thermal_event ; __le32 rht_lht ; }; struct reg_dev_req___0 { __le32 tag ; __le32 phyid_portid ; __le32 dtype_dlr_mcn_ir_retry ; __le32 firstburstsize_ITNexustimeout ; u8 sas_addr[8U] ; __le32 upper_device_id ; u32 reserved[24U] ; }; struct local_phy_ctl_req___0 { __le32 tag ; __le32 phyop_phyid ; u32 reserved1[29U] ; }; struct hw_event_ack_req___0 { __le32 tag ; __le32 phyid_sea_portid ; __le32 param0 ; __le32 param1 ; u32 reserved1[27U] ; }; struct phy_start_resp { __le32 tag ; __le32 status ; __le32 phyid ; u32 reserved[12U] ; }; struct phy_stop_resp { __le32 tag ; __le32 status ; __le32 phyid ; u32 reserved[12U] ; }; struct sata_event_resp___0 { __le32 tag ; __le32 event ; __le32 port_id ; __le32 device_id ; u32 reserved ; __le32 event_param0 ; __le32 event_param1 ; __le32 sata_addr_h32 ; __le32 sata_addr_l32 ; __le32 e_udt1_udt0_crc ; __le32 e_udt5_udt4_udt3_udt2 ; __le32 a_udt1_udt0_crc ; __le32 a_udt5_udt4_udt3_udt2 ; __le32 hwdevid_diferr ; __le32 err_framelen_byteoffset ; __le32 err_dataframe ; }; struct ssp_event_resp___0 { __le32 tag ; __le32 event ; __le32 port_id ; __le32 device_id ; __le32 ssp_tag ; __le32 event_param0 ; __le32 event_param1 ; __le32 sas_addr_h32 ; __le32 sas_addr_l32 ; __le32 e_udt1_udt0_crc ; __le32 e_udt5_udt4_udt3_udt2 ; __le32 a_udt1_udt0_crc ; __le32 a_udt5_udt4_udt3_udt2 ; __le32 hwdevid_diferr ; __le32 err_framelen_byteoffset ; __le32 err_dataframe ; }; struct __anonstruct_long_smp_req_271___0 { __le64 long_req_addr ; __le32 long_req_size ; u32 _r_a ; __le64 long_resp_addr ; __le32 long_resp_size ; u32 _r_b ; }; union __anonunion____missing_field_name_270___0 { u8 smp_req[32U] ; struct __anonstruct_long_smp_req_271___0 long_smp_req ; }; struct smp_req___0 { __le32 tag ; __le32 device_id ; __le32 len_ip_ir ; u8 smp_req16[16U] ; union __anonunion____missing_field_name_270___0 __annonCompField97 ; __le32 rsvd[16U] ; }; struct smp_completion_resp___0 { __le32 tag ; __le32 status ; __le32 param ; u8 _r_a[252U] ; }; struct task_abort_req___0 { __le32 tag ; __le32 device_id ; __le32 tag_to_abort ; __le32 abort_all ; u32 reserved[27U] ; }; struct sata_start_req___0 { __le32 tag ; __le32 device_id ; __le32 data_len ; __le32 ncqtag_atap_dir_m_dad ; struct host_to_dev_fis sata_fis ; u32 reserved1 ; u32 reserved2 ; u32 addr_low ; u32 addr_high ; __le32 len ; __le32 esgl ; __le32 atapi_scsi_cdb[4U] ; __le32 key_index_mode ; __le32 sector_cnt_enss ; __le32 keytagl ; __le32 keytagh ; __le32 twk_val0 ; __le32 twk_val1 ; __le32 twk_val2 ; __le32 twk_val3 ; __le32 enc_addr_low ; __le32 enc_addr_high ; __le32 enc_len ; __le32 enc_esgl ; }; struct ssp_ini_io_start_req___0 { __le32 tag ; __le32 device_id ; __le32 data_len ; __le32 dad_dir_m_tlr ; struct ssp_info_unit ssp_iu ; __le32 addr_low ; __le32 addr_high ; __le32 len ; __le32 esgl ; u8 udt[12U] ; __le32 sectcnt_ios ; __le32 key_cmode ; __le32 ks_enss ; __le32 keytagl ; __le32 keytagh ; __le32 twk_val0 ; __le32 twk_val1 ; __le32 twk_val2 ; __le32 twk_val3 ; __le32 enc_addr_low ; __le32 enc_addr_high ; __le32 enc_len ; __le32 enc_esgl ; }; struct set_ctrl_cfg_req { __le32 tag ; __le32 cfg_pg[14U] ; u32 reserved[16U] ; }; struct kek_mgmt_req { __le32 tag ; __le32 new_curidx_ksop ; u32 reserved ; __le32 kblob[12U] ; u32 reserved1[16U] ; }; struct set_phy_profile_req { __le32 tag ; __le32 ppc_phyid ; u32 reserved[29U] ; }; struct set_ctrl_cfg_resp { __le32 tag ; __le32 status ; __le32 err_qlfr_pgcd ; u32 reserved[12U] ; }; struct kek_mgmt_resp { __le32 tag ; __le32 status ; __le32 kidx_new_curr_ksop ; __le32 err_qlfr ; u32 reserved[11U] ; }; struct set_phy_profile_resp { __le32 tag ; __le32 status ; __le32 ppc_phyid ; __le32 ppc_specific_rsp[12U] ; }; struct SASProtocolTimerConfig { __le32 pageCode ; __le32 MST_MSI ; __le32 STP_SSP_MCT_TMO ; __le32 STP_FRM_TMO ; __le32 STP_IDLE_TMO ; __le32 OPNRJT_RTRY_INTVL ; __le32 Data_Cmd_OPNRJT_RTRY_TMO ; __le32 Data_Cmd_OPNRJT_RTRY_THR ; __le32 MAX_AIP ; }; typedef struct SASProtocolTimerConfig SASProtocolTimerConfig_t; struct device_private { void *driver_data ; }; typedef short s16; enum hrtimer_restart; struct kthread_work; struct kthread_worker { spinlock_t lock ; struct list_head work_list ; struct task_struct *task ; struct kthread_work *current_work ; }; struct kthread_work { struct list_head node ; void (*func)(struct kthread_work * ) ; struct kthread_worker *worker ; }; struct dma_chan; struct spi_master; struct spi_device { struct device dev ; struct spi_master *master ; u32 max_speed_hz ; u8 chip_select ; u8 bits_per_word ; u16 mode ; int irq ; void *controller_state ; void *controller_data ; char modalias[32U] ; int cs_gpio ; }; struct spi_message; struct spi_transfer; struct spi_master { struct device dev ; struct list_head list ; s16 bus_num ; u16 num_chipselect ; u16 dma_alignment ; u16 mode_bits ; u32 bits_per_word_mask ; u32 min_speed_hz ; u32 max_speed_hz ; u16 flags ; spinlock_t bus_lock_spinlock ; struct mutex bus_lock_mutex ; bool bus_lock_flag ; int (*setup)(struct spi_device * ) ; int (*transfer)(struct spi_device * , struct spi_message * ) ; void (*cleanup)(struct spi_device * ) ; bool (*can_dma)(struct spi_master * , struct spi_device * , struct spi_transfer * ) ; bool queued ; struct kthread_worker kworker ; struct task_struct *kworker_task ; struct kthread_work pump_messages ; spinlock_t queue_lock ; struct list_head queue ; struct spi_message *cur_msg ; bool idling ; bool busy ; bool running ; bool rt ; bool auto_runtime_pm ; bool cur_msg_prepared ; bool cur_msg_mapped ; struct completion xfer_completion ; size_t max_dma_len ; int (*prepare_transfer_hardware)(struct spi_master * ) ; int (*transfer_one_message)(struct spi_master * , struct spi_message * ) ; int (*unprepare_transfer_hardware)(struct spi_master * ) ; int (*prepare_message)(struct spi_master * , struct spi_message * ) ; int (*unprepare_message)(struct spi_master * , struct spi_message * ) ; void (*set_cs)(struct spi_device * , bool ) ; int (*transfer_one)(struct spi_master * , struct spi_device * , struct spi_transfer * ) ; int *cs_gpios ; struct dma_chan *dma_tx ; struct dma_chan *dma_rx ; void *dummy_rx ; void *dummy_tx ; }; struct spi_transfer { void const *tx_buf ; void *rx_buf ; unsigned int len ; dma_addr_t tx_dma ; dma_addr_t rx_dma ; struct sg_table tx_sg ; struct sg_table rx_sg ; unsigned char cs_change : 1 ; unsigned char tx_nbits : 3 ; unsigned char rx_nbits : 3 ; u8 bits_per_word ; u16 delay_usecs ; u32 speed_hz ; struct list_head transfer_list ; }; struct spi_message { struct list_head transfers ; struct spi_device *spi ; unsigned char is_dma_mapped : 1 ; void (*complete)(void * ) ; void *context ; unsigned int frame_length ; unsigned int actual_length ; int status ; struct list_head queue ; void *state ; }; struct notifier_block; enum hrtimer_restart; struct ratelimit_state { raw_spinlock_t lock ; int interval ; int burst ; int printed ; int missed ; unsigned long begin ; }; struct notifier_block { int (*notifier_call)(struct notifier_block * , unsigned long , void * ) ; struct notifier_block *next ; int priority ; }; typedef unsigned int mmc_pm_flag_t; struct mmc_card; struct sdio_func; typedef void sdio_irq_handler_t(struct sdio_func * ); struct sdio_func_tuple { struct sdio_func_tuple *next ; unsigned char code ; unsigned char size ; unsigned char data[0U] ; }; struct sdio_func { struct mmc_card *card ; struct device dev ; sdio_irq_handler_t *irq_handler ; unsigned int num ; unsigned char class ; unsigned short vendor ; unsigned short device ; unsigned int max_blksize ; unsigned int cur_blksize ; unsigned int enable_timeout ; unsigned int state ; u8 tmpbuf[4U] ; unsigned int num_info ; char const **info ; struct sdio_func_tuple *tuples ; }; enum led_brightness { LED_OFF = 0, LED_HALF = 127, LED_FULL = 255 } ; struct led_trigger; struct led_classdev { char const *name ; enum led_brightness brightness ; enum led_brightness max_brightness ; int flags ; void (*brightness_set)(struct led_classdev * , enum led_brightness ) ; int (*brightness_set_sync)(struct led_classdev * , enum led_brightness ) ; enum led_brightness (*brightness_get)(struct led_classdev * ) ; int (*blink_set)(struct led_classdev * , unsigned long * , unsigned long * ) ; struct device *dev ; struct attribute_group const **groups ; struct list_head node ; char const *default_trigger ; unsigned long blink_delay_on ; unsigned long blink_delay_off ; struct timer_list blink_timer ; int blink_brightness ; void (*flash_resume)(struct led_classdev * ) ; struct work_struct set_brightness_work ; int delayed_set_value ; struct rw_semaphore trigger_lock ; struct led_trigger *trigger ; struct list_head trig_list ; void *trigger_data ; bool activated ; struct mutex led_access ; }; struct led_trigger { char const *name ; void (*activate)(struct led_classdev * ) ; void (*deactivate)(struct led_classdev * ) ; rwlock_t leddev_list_lock ; struct list_head led_cdevs ; struct list_head next_trig ; }; struct fault_attr { unsigned long probability ; unsigned long interval ; atomic_t times ; atomic_t space ; unsigned long verbose ; u32 task_filter ; unsigned long stacktrace_depth ; unsigned long require_start ; unsigned long require_end ; unsigned long reject_start ; unsigned long reject_end ; unsigned long count ; struct ratelimit_state ratelimit_state ; struct dentry *dname ; }; struct mmc_data; struct mmc_request; struct mmc_command { u32 opcode ; u32 arg ; u32 resp[4U] ; unsigned int flags ; unsigned int retries ; unsigned int error ; unsigned int busy_timeout ; bool sanitize_busy ; struct mmc_data *data ; struct mmc_request *mrq ; }; struct mmc_data { unsigned int timeout_ns ; unsigned int timeout_clks ; unsigned int blksz ; unsigned int blocks ; unsigned int error ; unsigned int flags ; unsigned int bytes_xfered ; struct mmc_command *stop ; struct mmc_request *mrq ; unsigned int sg_len ; struct scatterlist *sg ; s32 host_cookie ; }; struct mmc_host; struct mmc_request { struct mmc_command *sbc ; struct mmc_command *cmd ; struct mmc_data *data ; struct mmc_command *stop ; struct completion completion ; void (*done)(struct mmc_request * ) ; struct mmc_host *host ; }; struct mmc_async_req; struct mmc_cid { unsigned int manfid ; char prod_name[8U] ; unsigned char prv ; unsigned int serial ; unsigned short oemid ; unsigned short year ; unsigned char hwrev ; unsigned char fwrev ; unsigned char month ; }; struct mmc_csd { unsigned char structure ; unsigned char mmca_vsn ; unsigned short cmdclass ; unsigned short tacc_clks ; unsigned int tacc_ns ; unsigned int c_size ; unsigned int r2w_factor ; unsigned int max_dtr ; unsigned int erase_size ; unsigned int read_blkbits ; unsigned int write_blkbits ; unsigned int capacity ; unsigned char read_partial : 1 ; unsigned char read_misalign : 1 ; unsigned char write_partial : 1 ; unsigned char write_misalign : 1 ; unsigned char dsr_imp : 1 ; }; struct mmc_ext_csd { u8 rev ; u8 erase_group_def ; u8 sec_feature_support ; u8 rel_sectors ; u8 rel_param ; u8 part_config ; u8 cache_ctrl ; u8 rst_n_function ; u8 max_packed_writes ; u8 max_packed_reads ; u8 packed_event_en ; unsigned int part_time ; unsigned int sa_timeout ; unsigned int generic_cmd6_time ; unsigned int power_off_longtime ; u8 power_off_notification ; unsigned int hs_max_dtr ; unsigned int hs200_max_dtr ; unsigned int sectors ; unsigned int hc_erase_size ; unsigned int hc_erase_timeout ; unsigned int sec_trim_mult ; unsigned int sec_erase_mult ; unsigned int trim_timeout ; bool partition_setting_completed ; unsigned long long enhanced_area_offset ; unsigned int enhanced_area_size ; unsigned int cache_size ; bool hpi_en ; bool hpi ; unsigned int hpi_cmd ; bool bkops ; bool man_bkops_en ; unsigned int data_sector_size ; unsigned int data_tag_unit_size ; unsigned int boot_ro_lock ; bool boot_ro_lockable ; bool ffu_capable ; u8 fwrev[8U] ; u8 raw_exception_status ; u8 raw_partition_support ; u8 raw_rpmb_size_mult ; u8 raw_erased_mem_count ; u8 raw_ext_csd_structure ; u8 raw_card_type ; u8 out_of_int_time ; u8 raw_pwr_cl_52_195 ; u8 raw_pwr_cl_26_195 ; u8 raw_pwr_cl_52_360 ; u8 raw_pwr_cl_26_360 ; u8 raw_s_a_timeout ; u8 raw_hc_erase_gap_size ; u8 raw_erase_timeout_mult ; u8 raw_hc_erase_grp_size ; u8 raw_sec_trim_mult ; u8 raw_sec_erase_mult ; u8 raw_sec_feature_support ; u8 raw_trim_mult ; u8 raw_pwr_cl_200_195 ; u8 raw_pwr_cl_200_360 ; u8 raw_pwr_cl_ddr_52_195 ; u8 raw_pwr_cl_ddr_52_360 ; u8 raw_pwr_cl_ddr_200_360 ; u8 raw_bkops_status ; u8 raw_sectors[4U] ; unsigned int feature_support ; }; struct sd_scr { unsigned char sda_vsn ; unsigned char sda_spec3 ; unsigned char bus_widths ; unsigned char cmds ; }; struct sd_ssr { unsigned int au ; unsigned int erase_timeout ; unsigned int erase_offset ; }; struct sd_switch_caps { unsigned int hs_max_dtr ; unsigned int uhs_max_dtr ; unsigned int sd3_bus_mode ; unsigned int sd3_drv_type ; unsigned int sd3_curr_limit ; }; struct sdio_cccr { unsigned int sdio_vsn ; unsigned int sd_vsn ; unsigned char multi_block : 1 ; unsigned char low_speed : 1 ; unsigned char wide_bus : 1 ; unsigned char high_power : 1 ; unsigned char high_speed : 1 ; unsigned char disable_cd : 1 ; }; struct sdio_cis { unsigned short vendor ; unsigned short device ; unsigned short blksize ; unsigned int max_dtr ; }; struct mmc_ios; struct mmc_part { unsigned int size ; unsigned int part_cfg ; char name[20U] ; bool force_ro ; unsigned int area_type ; }; struct mmc_card { struct mmc_host *host ; struct device dev ; u32 ocr ; unsigned int rca ; unsigned int type ; unsigned int state ; unsigned int quirks ; unsigned int erase_size ; unsigned int erase_shift ; unsigned int pref_erase ; u8 erased_byte ; u32 raw_cid[4U] ; u32 raw_csd[4U] ; u32 raw_scr[2U] ; struct mmc_cid cid ; struct mmc_csd csd ; struct mmc_ext_csd ext_csd ; struct sd_scr scr ; struct sd_ssr ssr ; struct sd_switch_caps sw_caps ; unsigned int sdio_funcs ; struct sdio_cccr cccr ; struct sdio_cis cis ; struct sdio_func *sdio_func[7U] ; struct sdio_func *sdio_single_irq ; unsigned int num_info ; char const **info ; struct sdio_func_tuple *tuples ; unsigned int sd_bus_speed ; unsigned int mmc_avail_type ; struct dentry *debugfs_root ; struct mmc_part part[7U] ; unsigned int nr_parts ; }; struct mmc_ios { unsigned int clock ; unsigned short vdd ; unsigned char bus_mode ; unsigned char chip_select ; unsigned char power_mode ; unsigned char bus_width ; unsigned char timing ; unsigned char signal_voltage ; unsigned char drv_type ; }; struct mmc_host_ops { int (*enable)(struct mmc_host * ) ; int (*disable)(struct mmc_host * ) ; void (*post_req)(struct mmc_host * , struct mmc_request * , int ) ; void (*pre_req)(struct mmc_host * , struct mmc_request * , bool ) ; void (*request)(struct mmc_host * , struct mmc_request * ) ; void (*set_ios)(struct mmc_host * , struct mmc_ios * ) ; int (*get_ro)(struct mmc_host * ) ; int (*get_cd)(struct mmc_host * ) ; void (*enable_sdio_irq)(struct mmc_host * , int ) ; void (*init_card)(struct mmc_host * , struct mmc_card * ) ; int (*start_signal_voltage_switch)(struct mmc_host * , struct mmc_ios * ) ; int (*card_busy)(struct mmc_host * ) ; int (*execute_tuning)(struct mmc_host * , u32 ) ; int (*prepare_hs400_tuning)(struct mmc_host * , struct mmc_ios * ) ; int (*select_drive_strength)(unsigned int , int , int ) ; void (*hw_reset)(struct mmc_host * ) ; void (*card_event)(struct mmc_host * ) ; int (*multi_io_quirk)(struct mmc_card * , unsigned int , int ) ; }; struct mmc_async_req { struct mmc_request *mrq ; int (*err_check)(struct mmc_card * , struct mmc_async_req * ) ; }; struct mmc_slot { int cd_irq ; void *handler_priv ; }; struct mmc_context_info { bool is_done_rcv ; bool is_new_req ; bool is_waiting_last_req ; wait_queue_head_t wait ; spinlock_t lock ; }; struct regulator; struct mmc_pwrseq; struct mmc_supply { struct regulator *vmmc ; struct regulator *vqmmc ; }; struct mmc_bus_ops; struct mmc_host { struct device *parent ; struct device class_dev ; int index ; struct mmc_host_ops const *ops ; struct mmc_pwrseq *pwrseq ; unsigned int f_min ; unsigned int f_max ; unsigned int f_init ; u32 ocr_avail ; u32 ocr_avail_sdio ; u32 ocr_avail_sd ; u32 ocr_avail_mmc ; struct notifier_block pm_notify ; u32 max_current_330 ; u32 max_current_300 ; u32 max_current_180 ; u32 caps ; u32 caps2 ; mmc_pm_flag_t pm_caps ; int clk_requests ; unsigned int clk_delay ; bool clk_gated ; struct delayed_work clk_gate_work ; unsigned int clk_old ; spinlock_t clk_lock ; struct mutex clk_gate_mutex ; struct device_attribute clkgate_delay_attr ; unsigned long clkgate_delay ; unsigned int max_seg_size ; unsigned short max_segs ; unsigned short unused ; unsigned int max_req_size ; unsigned int max_blk_size ; unsigned int max_blk_count ; unsigned int max_busy_timeout ; spinlock_t lock ; struct mmc_ios ios ; unsigned char use_spi_crc : 1 ; unsigned char claimed : 1 ; unsigned char bus_dead : 1 ; unsigned char removed : 1 ; int rescan_disable ; int rescan_entered ; bool trigger_card_event ; struct mmc_card *card ; wait_queue_head_t wq ; struct task_struct *claimer ; int claim_cnt ; struct delayed_work detect ; int detect_change ; struct mmc_slot slot ; struct mmc_bus_ops const *bus_ops ; unsigned int bus_refs ; unsigned int sdio_irqs ; struct task_struct *sdio_irq_thread ; bool sdio_irq_pending ; atomic_t sdio_irq_thread_abort ; mmc_pm_flag_t pm_flags ; struct led_trigger *led ; bool regulator_enabled ; struct mmc_supply supply ; struct dentry *debugfs_root ; struct mmc_async_req *areq ; struct mmc_context_info context_info ; struct fault_attr fail_mmc_request ; unsigned int actual_clock ; unsigned int slotno ; int dsr_req ; u32 dsr ; unsigned long private[0U] ; }; typedef int ldv_map; struct usb_device; struct urb; struct ldv_thread_set { int number ; struct ldv_thread **threads ; }; struct ldv_thread { int identifier ; void (*function)(void * ) ; }; typedef _Bool ldv_set; long ldv__builtin_expect(long exp , long c ) ; void ldv_assume(int expression ) ; void ldv_stop(void) ; void ldv_linux_alloc_irq_check_alloc_flags(gfp_t flags ) ; void ldv_linux_alloc_irq_check_alloc_nonatomic(void) ; void ldv_linux_alloc_usb_lock_check_alloc_flags(gfp_t flags ) ; void ldv_linux_alloc_usb_lock_check_alloc_nonatomic(void) ; void ldv_linux_arch_io_check_final_state(void) ; void ldv_linux_block_genhd_check_final_state(void) ; void ldv_linux_block_queue_check_final_state(void) ; void ldv_linux_block_request_check_final_state(void) ; void *ldv_linux_drivers_base_class_create_class(void) ; int ldv_linux_drivers_base_class_register_class(void) ; void ldv_linux_drivers_base_class_check_final_state(void) ; void ldv_linux_fs_char_dev_check_final_state(void) ; void ldv_linux_fs_sysfs_check_final_state(void) ; void ldv_linux_kernel_locking_rwlock_check_final_state(void) ; void ldv_linux_kernel_module_check_final_state(void) ; void ldv_linux_kernel_rcu_update_lock_bh_check_for_read_section(void) ; void ldv_linux_kernel_rcu_update_lock_bh_check_final_state(void) ; void ldv_linux_kernel_rcu_update_lock_sched_check_for_read_section(void) ; void ldv_linux_kernel_rcu_update_lock_sched_check_final_state(void) ; void ldv_linux_kernel_rcu_update_lock_check_for_read_section(void) ; void ldv_linux_kernel_rcu_update_lock_check_final_state(void) ; void ldv_linux_kernel_rcu_srcu_check_for_read_section(void) ; void ldv_linux_kernel_rcu_srcu_check_final_state(void) ; void ldv_linux_lib_find_bit_initialize(void) ; void ldv_linux_lib_idr_check_final_state(void) ; void ldv_linux_mmc_sdio_func_check_final_state(void) ; void ldv_linux_net_register_reset_error_counter(void) ; void ldv_linux_net_register_check_return_value_probe(int retval ) ; void ldv_linux_net_rtnetlink_check_final_state(void) ; void ldv_linux_net_sock_check_final_state(void) ; void ldv_linux_usb_coherent_check_final_state(void) ; void *ldv_linux_usb_gadget_create_class(void) ; int ldv_linux_usb_gadget_register_class(void) ; void ldv_linux_usb_gadget_check_final_state(void) ; void ldv_linux_usb_register_reset_error_counter(void) ; void ldv_linux_usb_register_check_return_value_probe(int retval ) ; void ldv_linux_usb_urb_check_final_state(void) ; void ldv_check_alloc_nonatomic(void) { { { ldv_linux_alloc_irq_check_alloc_nonatomic(); ldv_linux_alloc_usb_lock_check_alloc_nonatomic(); } return; } } void ldv_check_alloc_flags(gfp_t flags ) { { { ldv_linux_alloc_irq_check_alloc_flags(flags); ldv_linux_alloc_usb_lock_check_alloc_flags(flags); } return; } } void ldv_check_for_read_section(void) { { { ldv_linux_kernel_rcu_update_lock_bh_check_for_read_section(); ldv_linux_kernel_rcu_update_lock_sched_check_for_read_section(); ldv_linux_kernel_rcu_update_lock_check_for_read_section(); ldv_linux_kernel_rcu_srcu_check_for_read_section(); } return; } } void *ldv_create_class(void) { void *res1 ; void *tmp ; void *res2 ; void *tmp___0 ; { { tmp = ldv_linux_drivers_base_class_create_class(); res1 = tmp; tmp___0 = ldv_linux_usb_gadget_create_class(); res2 = tmp___0; ldv_assume((unsigned long )res1 == (unsigned long )res2); } return (res1); } } int ldv_register_class(void) { int res1 ; int tmp ; int res2 ; int tmp___0 ; { { tmp = ldv_linux_drivers_base_class_register_class(); res1 = tmp; tmp___0 = ldv_linux_usb_gadget_register_class(); res2 = tmp___0; ldv_assume(res1 == res2); } return (res1); } } void *ldv_kzalloc(size_t size , gfp_t flags ) ; void ldv_linux_kernel_sched_completion_init_completion_completion(void) ; void ldv_linux_kernel_sched_completion_wait_for_completion_completion(void) ; int ldv_undef_int(void) ; void *ldv_linux_arch_io_io_mem_remap(void) ; static void ldv_ldv_initialize_121(void) ; int ldv_post_init(int init_ret_val ) ; static int ldv_ldv_post_init_118(int ldv_func_arg1 ) ; extern void ldv_pre_probe(void) ; static void ldv_ldv_pre_probe_122(void) ; static void ldv_ldv_pre_probe_124(void) ; int ldv_post_probe(int probe_ret_val ) ; static int ldv_ldv_post_probe_123(int retval ) ; static int ldv_ldv_post_probe_125(int retval ) ; int ldv_filter_err_code(int ret_val ) ; static void ldv_ldv_check_final_state_119(void) ; static void ldv_ldv_check_final_state_120(void) ; void ldv_free(void *s ) ; void *ldv_xmalloc(size_t size ) ; void *ldv_malloc_unknown_size(void) ; extern void ldv_after_alloc(void * ) ; void *ldv_alloc_macro(gfp_t flags ) { void *tmp ; { { ldv_check_alloc_flags(flags); tmp = ldv_malloc_unknown_size(); } return (tmp); } } extern struct module __this_module ; extern struct pv_irq_ops pv_irq_ops ; __inline static int test_and_set_bit(long nr , unsigned long volatile *addr ) { { __asm__ volatile ("":); return (0); return (1); } } extern int printk(char const * , ...) ; extern int sprintf(char * , char const * , ...) ; extern int snprintf(char * , size_t , char const * , ...) ; __inline static void INIT_LIST_HEAD(struct list_head *list ) { { list->next = list; list->prev = list; return; } } extern void __list_add(struct list_head * , struct list_head * , struct list_head * ) ; __inline static void list_add_tail(struct list_head *new , struct list_head *head ) { { { __list_add(new, head->prev, head); } return; } } extern void list_del(struct list_head * ) ; extern void *__memcpy(void * , void const * , size_t ) ; extern void *__memset(void * , int , size_t ) ; extern void warn_slowpath_null(char const * , int const ) ; __inline static unsigned long arch_local_save_flags(void) { unsigned long __ret ; unsigned long __edi ; unsigned long __esi ; unsigned long __edx ; unsigned long __ecx ; unsigned long __eax ; long tmp ; { { __edi = __edi; __esi = __esi; __edx = __edx; __ecx = __ecx; __eax = __eax; tmp = ldv__builtin_expect((unsigned long )pv_irq_ops.save_fl.func == (unsigned long )((void *)0), 0L); } if (tmp != 0L) { { __asm__ volatile ("1:\tud2\n.pushsection __bug_table,\"a\"\n2:\t.long 1b - 2b, %c0 - 2b\n\t.word %c1, 0\n\t.org 2b+%c2\n.popsection": : "i" ((char *)"./arch/x86/include/asm/paravirt.h"), "i" (804), "i" (12UL)); __builtin_unreachable(); } } else { } __asm__ volatile ("771:\n\tcall *%c2;\n772:\n.pushsection .parainstructions,\"a\"\n .balign 8 \n .quad 771b\n .byte %c1\n .byte 772b-771b\n .short %c3\n.popsection\n": "=a" (__eax): [paravirt_typenum] "i" (44UL), [paravirt_opptr] "i" (& pv_irq_ops.save_fl.func), [paravirt_clobber] "i" (1): "memory", "cc"); __ret = __eax; return (__ret); } } __inline static int arch_irqs_disabled_flags(unsigned long flags ) { { return ((flags & 512UL) == 0UL); } } void ldv_switch_to_interrupt_context(void) ; void ldv_switch_to_process_context(void) ; extern void __raw_spin_lock_init(raw_spinlock_t * , char const * , struct lock_class_key * ) ; __inline static raw_spinlock_t *spinlock_check(spinlock_t *lock ) { { return (& lock->__annonCompField18.rlock); } } __inline static void ldv_init_completion_100(struct completion *x ) ; __inline static void ldv_init_completion_100(struct completion *x ) ; __inline static void ldv_init_completion_100(struct completion *x ) ; extern void wait_for_completion(struct completion * ) ; static void ldv_wait_for_completion_101(struct completion *ldv_func_arg1 ) ; static void ldv_wait_for_completion_103(struct completion *ldv_func_arg1 ) ; static void ldv_wait_for_completion_114(struct completion *ldv_func_arg1 ) ; extern struct workqueue_struct *__alloc_workqueue_key(char const * , unsigned int , int , struct lock_class_key * , char const * , ...) ; extern void destroy_workqueue(struct workqueue_struct * ) ; extern void flush_workqueue(struct workqueue_struct * ) ; __inline static void *ioremap(resource_size_t offset , unsigned long size ) ; __inline static void *dev_get_drvdata(struct device const *dev ) { { return ((void *)dev->driver_data); } } __inline static void dev_set_drvdata(struct device *dev , void *data ) { { dev->driver_data = data; return; } } extern void dev_printk(char const * , struct device const * , char const * , ...) ; extern void dev_err(struct device const * , char const * , ...) ; extern void kfree(void const * ) ; __inline static void *kcalloc(size_t n , size_t size , gfp_t flags ) ; __inline static void *kzalloc(size_t size , gfp_t flags ) ; extern int pci_bus_read_config_word(struct pci_bus * , unsigned int , int , u16 * ) ; extern int pci_bus_read_config_dword(struct pci_bus * , unsigned int , int , u32 * ) ; extern int pci_bus_write_config_dword(struct pci_bus * , unsigned int , int , u32 ) ; __inline static int pci_read_config_word(struct pci_dev const *dev , int where , u16 *val ) { int tmp ; { { tmp = pci_bus_read_config_word(dev->bus, dev->devfn, where, val); } return (tmp); } } __inline static int pci_read_config_dword(struct pci_dev const *dev , int where , u32 *val ) { int tmp ; { { tmp = pci_bus_read_config_dword(dev->bus, dev->devfn, where, val); } return (tmp); } } __inline static int pci_write_config_dword(struct pci_dev const *dev , int where , u32 val ) { int tmp ; { { tmp = pci_bus_write_config_dword(dev->bus, dev->devfn, where, val); } return (tmp); } } extern int pci_enable_device(struct pci_dev * ) ; extern void pci_disable_device(struct pci_dev * ) ; extern void pci_set_master(struct pci_dev * ) ; extern int pci_save_state(struct pci_dev * ) ; extern void pci_restore_state(struct pci_dev * ) ; extern int pci_set_power_state(struct pci_dev * , pci_power_t ) ; extern pci_power_t pci_choose_state(struct pci_dev * , pm_message_t ) ; extern int __pci_enable_wake(struct pci_dev * , pci_power_t , bool , bool ) ; __inline static int pci_enable_wake(struct pci_dev *dev , pci_power_t state , bool enable ) { int tmp ; { { tmp = __pci_enable_wake(dev, state, 0, (int )enable); } return (tmp); } } extern int pci_request_regions(struct pci_dev * , char const * ) ; extern void pci_release_regions(struct pci_dev * ) ; extern int __pci_register_driver(struct pci_driver * , struct module * , char const * ) ; static int ldv___pci_register_driver_116(struct pci_driver *ldv_func_arg1 , struct module *ldv_func_arg2 , char const *ldv_func_arg3 ) ; extern void pci_unregister_driver(struct pci_driver * ) ; static void ldv_pci_unregister_driver_117(struct pci_driver *ldv_func_arg1 ) ; extern void pci_disable_msix(struct pci_dev * ) ; extern int pci_enable_msix_range(struct pci_dev * , struct msix_entry * , int , int ) ; __inline static int pci_enable_msix_exact(struct pci_dev *dev , struct msix_entry *entries , int nvec ) { int rc ; int tmp ; { { tmp = pci_enable_msix_range(dev, entries, nvec, nvec); rc = tmp; } if (rc < 0) { return (rc); } else { } return (0); } } extern void debug_dma_free_coherent(struct device * , size_t , void * , dma_addr_t ) ; extern struct dma_map_ops *dma_ops ; __inline static struct dma_map_ops *get_dma_ops(struct device *dev ) { long tmp ; { { tmp = ldv__builtin_expect((unsigned long )dev == (unsigned long )((struct device *)0), 0L); } if (tmp != 0L || (unsigned long )dev->archdata.dma_ops == (unsigned long )((struct dma_map_ops *)0)) { return (dma_ops); } else { return (dev->archdata.dma_ops); } } } extern int dma_supported(struct device * , u64 ) ; extern int dma_set_mask(struct device * , u64 ) ; __inline static void dma_free_attrs(struct device *dev , size_t size , void *vaddr , dma_addr_t bus , struct dma_attrs *attrs ) { struct dma_map_ops *ops ; struct dma_map_ops *tmp ; int __ret_warn_on ; unsigned long _flags ; int tmp___0 ; long tmp___1 ; { { tmp = get_dma_ops(dev); ops = tmp; _flags = arch_local_save_flags(); tmp___0 = arch_irqs_disabled_flags(_flags); __ret_warn_on = tmp___0 != 0; tmp___1 = ldv__builtin_expect(__ret_warn_on != 0, 0L); } if (tmp___1 != 0L) { { warn_slowpath_null("./arch/x86/include/asm/dma-mapping.h", 166); } } else { } { ldv__builtin_expect(__ret_warn_on != 0, 0L); debug_dma_free_coherent(dev, size, vaddr, bus); } if ((unsigned long )ops->free != (unsigned long )((void (*)(struct device * , size_t , void * , dma_addr_t , struct dma_attrs * ))0)) { { (*(ops->free))(dev, size, vaddr, bus, attrs); } } else { } return; } } __inline static int dma_set_coherent_mask(struct device *dev , u64 mask ) { int tmp ; { { tmp = dma_supported(dev, mask); } if (tmp == 0) { return (-5); } else { } dev->coherent_dma_mask = mask; return (0); } } __inline static void pci_free_consistent(struct pci_dev *hwdev , size_t size , void *vaddr , dma_addr_t dma_handle ) { { { dma_free_attrs((unsigned long )hwdev != (unsigned long )((struct pci_dev *)0) ? & hwdev->dev : (struct device *)0, size, vaddr, dma_handle, (struct dma_attrs *)0); } return; } } __inline static int pci_set_dma_mask(struct pci_dev *dev , u64 mask ) { int tmp ; { { tmp = dma_set_mask(& dev->dev, mask); } return (tmp); } } __inline static int pci_set_consistent_dma_mask(struct pci_dev *dev , u64 mask ) { int tmp ; { { tmp = dma_set_coherent_mask(& dev->dev, mask); } return (tmp); } } __inline static void *pci_get_drvdata(struct pci_dev *pdev ) { void *tmp ; { { tmp = dev_get_drvdata((struct device const *)(& pdev->dev)); } return (tmp); } } __inline static void pci_set_drvdata(struct pci_dev *pdev , void *data ) { { { dev_set_drvdata(& pdev->dev, data); } return; } } extern void synchronize_irq(unsigned int ) ; extern struct Scsi_Host *scsi_host_alloc(struct scsi_host_template * , int ) ; static struct Scsi_Host *ldv_scsi_host_alloc_107(struct scsi_host_template *ldv_func_arg1 , int ldv_func_arg2 ) ; extern int scsi_add_host_with_dma(struct Scsi_Host * , struct device * , struct device * ) ; extern void scsi_scan_host(struct Scsi_Host * ) ; extern void scsi_remove_host(struct Scsi_Host * ) ; static void ldv_scsi_remove_host_109(struct Scsi_Host *ldv_func_arg1 ) ; static void ldv_scsi_remove_host_110(struct Scsi_Host *ldv_func_arg1 ) ; static void ldv_scsi_remove_host_115(struct Scsi_Host *ldv_func_arg1 ) ; extern void scsi_host_put(struct Scsi_Host * ) ; __inline static int scsi_add_host(struct Scsi_Host *host , struct device *dev ) { int tmp ; { { tmp = scsi_add_host_with_dma(host, dev, dev); } return (tmp); } } __inline static int ldv_scsi_add_host_108(struct Scsi_Host *host , struct device *dev ) ; extern void scsi_block_requests(struct Scsi_Host * ) ; extern int request_threaded_irq(unsigned int , irqreturn_t (*)(int , void * ) , irqreturn_t (*)(int , void * ) , unsigned long , char const * , void * ) ; __inline static int request_irq(unsigned int irq , irqreturn_t (*handler)(int , void * ) , unsigned long flags , char const *name , void *dev ) { int tmp ; { { tmp = request_threaded_irq(irq, handler, (irqreturn_t (*)(int , void * ))0, flags, name, dev); } return (tmp); } } __inline static int ldv_request_irq_104(unsigned int irq , irqreturn_t (*handler)(int , void * ) , unsigned long flags , char const *name , void *dev ) ; __inline static int ldv_request_irq_106(unsigned int irq , irqreturn_t (*handler)(int , void * ) , unsigned long flags , char const *name , void *dev ) ; extern void free_irq(unsigned int , void * ) ; static void ldv_free_irq_105(unsigned int ldv_func_arg1 , void *ldv_func_arg2 ) ; static void ldv_free_irq_111(unsigned int ldv_func_arg1 , void *ldv_func_arg2 ) ; static void ldv_free_irq_112(unsigned int ldv_func_arg1 , void *ldv_func_arg2 ) ; extern void __tasklet_schedule(struct tasklet_struct * ) ; __inline static void tasklet_schedule(struct tasklet_struct *t ) { int tmp ; { { tmp = test_and_set_bit(0L, (unsigned long volatile *)(& t->state)); } if (tmp == 0) { { __tasklet_schedule(t); } } else { } return; } } extern void tasklet_kill(struct tasklet_struct * ) ; extern void tasklet_init(struct tasklet_struct * , void (*)(unsigned long ) , unsigned long ) ; extern void sas_remove_host(struct Scsi_Host * ) ; extern void sas_release_transport(struct scsi_transport_template * ) ; extern int sas_register_ha(struct sas_ha_struct * ) ; extern int sas_unregister_ha(struct sas_ha_struct * ) ; extern void sas_prep_resume_ha(struct sas_ha_struct * ) ; extern void sas_resume_ha(struct sas_ha_struct * ) ; extern void sas_suspend_ha(struct sas_ha_struct * ) ; extern int sas_queuecommand(struct Scsi_Host * , struct scsi_cmnd * ) ; extern int sas_target_alloc(struct scsi_target * ) ; extern int sas_slave_configure(struct scsi_device * ) ; extern int sas_change_queue_depth(struct scsi_device * , int ) ; extern int sas_bios_param(struct scsi_device * , struct block_device * , sector_t , int * ) ; extern struct scsi_transport_template *sas_domain_attach_transport(struct sas_domain_function_template * ) ; extern int sas_eh_device_reset_handler(struct scsi_cmnd * ) ; extern int sas_eh_bus_reset_handler(struct scsi_cmnd * ) ; extern void sas_target_destroy(struct scsi_target * ) ; extern int sas_ioctl(struct scsi_device * , int , void * ) ; struct list_head hba_list ; struct pm8001_dispatch const pm8001_8001_dispatch ; struct pm8001_dispatch const pm8001_80xx_dispatch ; struct workqueue_struct *pm8001_wq ; void pm8001_tag_init(struct pm8001_hba_info *pm8001_ha ) ; int pm8001_phy_control(struct asd_sas_phy *sas_phy , enum phy_func func , void *funcdata ) ; void pm8001_scan_start(struct Scsi_Host *shost ) ; int pm8001_scan_finished(struct Scsi_Host *shost , unsigned long time ) ; int pm8001_queue_command(struct sas_task *task , gfp_t gfp_flags ) ; int pm8001_abort_task(struct sas_task *task ) ; int pm8001_abort_task_set(struct domain_device *dev , u8 *lun ) ; int pm8001_clear_aca(struct domain_device *dev , u8 *lun ) ; int pm8001_clear_task_set(struct domain_device *dev , u8 *lun ) ; int pm8001_dev_found(struct domain_device *dev ) ; void pm8001_dev_gone(struct domain_device *dev ) ; int pm8001_lu_reset(struct domain_device *dev , u8 *lun ) ; int pm8001_I_T_nexus_reset(struct domain_device *dev ) ; int pm8001_query_task(struct sas_task *task ) ; int pm8001_mem_alloc(struct pci_dev *pdev , void **virt_addr , dma_addr_t *pphys_addr , u32 *pphys_addr_hi , u32 *pphys_addr_lo , u32 mem_size , u32 align ) ; int pm80xx_set_thermal_config(struct pm8001_hba_info *pm8001_ha ) ; void pm8001_set_phy_profile(struct pm8001_hba_info *pm8001_ha , u32 length , u8 *buf ) ; struct device_attribute *pm8001_host_attrs[17U] ; static struct scsi_transport_template *pm8001_stt ; static struct pm8001_chip_info const pm8001_chips[8U] = { {0U, 8U, & pm8001_8001_dispatch}, {0U, 8U, & pm8001_80xx_dispatch}, {1U, 8U, & pm8001_80xx_dispatch}, {0U, 16U, & pm8001_80xx_dispatch}, {1U, 16U, & pm8001_80xx_dispatch}, {0U, 8U, & pm8001_80xx_dispatch}, {0U, 16U, & pm8001_80xx_dispatch}, {0U, 16U, & pm8001_80xx_dispatch}}; static int pm8001_id ; struct list_head hba_list = {& hba_list, & hba_list}; static struct scsi_host_template pm8001_sht = {& __this_module, "pm80xx", 0, 0, 0, & sas_ioctl, 0, & sas_queuecommand, 0, & sas_eh_device_reset_handler, 0, & sas_eh_bus_reset_handler, 0, 0, & sas_slave_configure, 0, & sas_target_alloc, & sas_target_destroy, & pm8001_scan_finished, & pm8001_scan_start, & sas_change_queue_depth, & sas_bios_param, 0, 0, 0, 0, 0, 0, 0, 1, -1, 128U, (unsigned short)0, 1024U, 0UL, 1, (unsigned char)0, 0, 1U, 1U, (unsigned char)0, (unsigned char)0, 1U, (unsigned char)0, (unsigned char)0, (unsigned char)0, (unsigned char)0, 0U, (struct device_attribute **)(& pm8001_host_attrs), 0, {0, 0}, 0ULL, 0U, 0, (_Bool)0}; static struct sas_domain_function_template pm8001_transport_ops = {0, 0, & pm8001_dev_found, & pm8001_dev_gone, & pm8001_queue_command, & pm8001_abort_task, & pm8001_abort_task_set, & pm8001_clear_aca, & pm8001_clear_task_set, & pm8001_I_T_nexus_reset, 0, 0, & pm8001_lu_reset, & pm8001_query_task, 0, 0, & pm8001_phy_control, 0}; static void pm8001_phy_init(struct pm8001_hba_info *pm8001_ha , int phy_id ) { struct pm8001_phy *phy ; struct asd_sas_phy *sas_phy ; { phy = (struct pm8001_phy *)(& pm8001_ha->phy) + (unsigned long )phy_id; sas_phy = & phy->sas_phy; phy->phy_state = 0U; phy->pm8001_ha = pm8001_ha; sas_phy->enabled = (unsigned int )phy_id < (unsigned int )(pm8001_ha->chip)->n_phy; sas_phy->class = 0; sas_phy->iproto = 14; sas_phy->tproto = 0; sas_phy->type = 0; sas_phy->role = 128; sas_phy->oob_mode = 0; sas_phy->linkrate = 0; sas_phy->id = phy_id; sas_phy->sas_addr = (u8 *)(& pm8001_ha->sas_addr); sas_phy->frame_rcvd = (u8 *)(& phy->frame_rcvd); sas_phy->ha = (struct sas_ha_struct *)(& (pm8001_ha->shost)->hostdata); sas_phy->lldd_phy = (void *)phy; return; } } static void pm8001_free(struct pm8001_hba_info *pm8001_ha ) { int i ; { if ((unsigned long )pm8001_ha == (unsigned long )((struct pm8001_hba_info *)0)) { return; } else { } i = 0; goto ldv_45831; ldv_45830: ; if ((unsigned long )pm8001_ha->memoryMap.region[i].virt_ptr != (unsigned long )((void *)0)) { { pci_free_consistent(pm8001_ha->pdev, (size_t )(pm8001_ha->memoryMap.region[i].total_len + pm8001_ha->memoryMap.region[i].alignment), pm8001_ha->memoryMap.region[i].virt_ptr, pm8001_ha->memoryMap.region[i].phys_addr); } } else { } i = i + 1; ldv_45831: ; if (i <= 15) { goto ldv_45830; } else { } { (*(((pm8001_ha->chip)->dispatch)->chip_iounmap))(pm8001_ha); } if ((unsigned long )pm8001_ha->shost != (unsigned long )((struct Scsi_Host *)0)) { { scsi_host_put(pm8001_ha->shost); } } else { } { flush_workqueue(pm8001_wq); kfree((void const *)pm8001_ha->tags); kfree((void const *)pm8001_ha); } return; } } static void pm8001_tasklet(unsigned long opaque ) { struct pm8001_hba_info *pm8001_ha ; struct isr_param *irq_vector ; long tmp ; { { irq_vector = (struct isr_param *)opaque; pm8001_ha = irq_vector->drv_inst; tmp = ldv__builtin_expect((unsigned long )pm8001_ha == (unsigned long )((struct pm8001_hba_info *)0), 0L); } if (tmp != 0L) { { __asm__ volatile ("1:\tud2\n.pushsection __bug_table,\"a\"\n2:\t.long 1b - 2b, %c0 - 2b\n\t.word %c1, 0\n\t.org 2b+%c2\n.popsection": : "i" ((char *)"drivers/scsi/pm8001/pm8001_init.c"), "i" (184), "i" (12UL)); __builtin_unreachable(); } } else { } { (*(((pm8001_ha->chip)->dispatch)->isr))(pm8001_ha, (int )((u8 )irq_vector->irq_id)); } return; } } static irqreturn_t pm8001_interrupt_handler_msix(int irq , void *opaque ) { struct isr_param *irq_vector ; struct pm8001_hba_info *pm8001_ha ; irqreturn_t ret ; long tmp ; u32 tmp___0 ; { { ret = 1; irq_vector = (struct isr_param *)opaque; pm8001_ha = irq_vector->drv_inst; tmp = ldv__builtin_expect((unsigned long )pm8001_ha == (unsigned long )((struct pm8001_hba_info *)0), 0L); } if (tmp != 0L) { return (0); } else { } { tmp___0 = (*(((pm8001_ha->chip)->dispatch)->is_our_interupt))(pm8001_ha); } if (tmp___0 == 0U) { return (0); } else { } { tasklet_schedule((struct tasklet_struct *)(& pm8001_ha->tasklet) + (unsigned long )irq_vector->irq_id); } return (ret); } } static irqreturn_t pm8001_interrupt_handler_intx(int irq , void *dev_id ) { struct pm8001_hba_info *pm8001_ha ; irqreturn_t ret ; struct sas_ha_struct *sha ; long tmp ; u32 tmp___0 ; { { ret = 1; sha = (struct sas_ha_struct *)dev_id; pm8001_ha = (struct pm8001_hba_info *)sha->lldd_ha; tmp = ldv__builtin_expect((unsigned long )pm8001_ha == (unsigned long )((struct pm8001_hba_info *)0), 0L); } if (tmp != 0L) { return (0); } else { } { tmp___0 = (*(((pm8001_ha->chip)->dispatch)->is_our_interupt))(pm8001_ha); } if (tmp___0 == 0U) { return (0); } else { } { tasklet_schedule((struct tasklet_struct *)(& pm8001_ha->tasklet)); } return (ret); } } static int pm8001_alloc(struct pm8001_hba_info *pm8001_ha , struct pci_device_id const *ent ) { int i ; struct lock_class_key __key ; struct lock_class_key __key___0 ; long tmp ; void *tmp___0 ; long tmp___1 ; int tmp___2 ; { { spinlock_check(& pm8001_ha->lock); __raw_spin_lock_init(& pm8001_ha->lock.__annonCompField18.rlock, "&(&pm8001_ha->lock)->rlock", & __key); spinlock_check(& pm8001_ha->bitmap_lock); __raw_spin_lock_init(& pm8001_ha->bitmap_lock.__annonCompField18.rlock, "&(&pm8001_ha->bitmap_lock)->rlock", & __key___0); tmp = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:pm8001_alloc: PHY:%x\n", "pm8001_alloc", 253, (pm8001_ha->chip)->n_phy); } } else { } i = 0; goto ldv_45861; ldv_45860: { pm8001_phy_init(pm8001_ha, i); pm8001_ha->port[i].wide_port_phymap = 0U; pm8001_ha->port[i].port_attached = 0U; pm8001_ha->port[i].port_state = 0U; INIT_LIST_HEAD(& pm8001_ha->port[i].list); i = i + 1; } ldv_45861: ; if ((unsigned int )i < (unsigned int )(pm8001_ha->chip)->n_phy) { goto ldv_45860; } else { } { tmp___0 = kzalloc(512UL, 208U); pm8001_ha->tags = (unsigned long *)tmp___0; } if ((unsigned long )pm8001_ha->tags == (unsigned long )((unsigned long *)0UL)) { goto err_out; } else { } pm8001_ha->memoryMap.region[0].num_elements = 1U; pm8001_ha->memoryMap.region[0].element_size = 131072U; pm8001_ha->memoryMap.region[0].total_len = 131072U; pm8001_ha->memoryMap.region[0].alignment = 32U; pm8001_ha->memoryMap.region[1].num_elements = 1U; pm8001_ha->memoryMap.region[1].element_size = 131072U; pm8001_ha->memoryMap.region[1].total_len = 131072U; pm8001_ha->memoryMap.region[1].alignment = 32U; i = 0; goto ldv_45865; ldv_45864: pm8001_ha->memoryMap.region[i + 7].num_elements = 1U; pm8001_ha->memoryMap.region[i + 7].element_size = 4U; pm8001_ha->memoryMap.region[i + 7].total_len = 4U; pm8001_ha->memoryMap.region[i + 7].alignment = 4U; if ((unsigned long )ent->driver_data != 0UL) { pm8001_ha->memoryMap.region[i + 6].num_elements = 1024U; pm8001_ha->memoryMap.region[i + 6].element_size = 128U; pm8001_ha->memoryMap.region[i + 6].total_len = 131072U; pm8001_ha->memoryMap.region[i + 6].alignment = 128U; } else { pm8001_ha->memoryMap.region[i + 6].num_elements = 1024U; pm8001_ha->memoryMap.region[i + 6].element_size = 64U; pm8001_ha->memoryMap.region[i + 6].total_len = 65536U; pm8001_ha->memoryMap.region[i + 6].alignment = 64U; } i = i + 1; ldv_45865: ; if (i <= 0) { goto ldv_45864; } else { } i = 0; goto ldv_45868; ldv_45867: pm8001_ha->memoryMap.region[i + 12].num_elements = 1U; pm8001_ha->memoryMap.region[i + 12].element_size = 4U; pm8001_ha->memoryMap.region[i + 12].total_len = 4U; pm8001_ha->memoryMap.region[i + 12].alignment = 4U; if ((unsigned long )ent->driver_data != 0UL) { pm8001_ha->memoryMap.region[i + 8].num_elements = 1024U; pm8001_ha->memoryMap.region[i + 8].element_size = 128U; pm8001_ha->memoryMap.region[i + 8].total_len = 131072U; pm8001_ha->memoryMap.region[i + 8].alignment = 128U; } else { pm8001_ha->memoryMap.region[i + 8].num_elements = 1024U; pm8001_ha->memoryMap.region[i + 8].element_size = 64U; pm8001_ha->memoryMap.region[i + 8].total_len = 65536U; pm8001_ha->memoryMap.region[i + 8].alignment = 64U; } i = i + 1; ldv_45868: ; if (i <= 3) { goto ldv_45867; } else { } pm8001_ha->memoryMap.region[2].num_elements = 1U; pm8001_ha->memoryMap.region[2].element_size = 4096U; pm8001_ha->memoryMap.region[2].total_len = 4096U; pm8001_ha->memoryMap.region[3].num_elements = 1U; pm8001_ha->memoryMap.region[3].element_size = 98304U; pm8001_ha->memoryMap.region[3].total_len = 98304U; pm8001_ha->memoryMap.region[4].num_elements = 1U; pm8001_ha->memoryMap.region[4].element_size = 1081344U; pm8001_ha->memoryMap.region[4].total_len = 1081344U; pm8001_ha->memoryMap.region[5].total_len = 4096U; pm8001_ha->memoryMap.region[6].num_elements = 1U; pm8001_ha->memoryMap.region[6].total_len = 65536U; pm8001_ha->memoryMap.region[6].element_size = 65536U; pm8001_ha->memoryMap.region[6].alignment = 65536U; i = 0; goto ldv_45871; ldv_45870: { tmp___2 = pm8001_mem_alloc(pm8001_ha->pdev, & pm8001_ha->memoryMap.region[i].virt_ptr, & pm8001_ha->memoryMap.region[i].phys_addr, & pm8001_ha->memoryMap.region[i].phys_addr_hi, & pm8001_ha->memoryMap.region[i].phys_addr_lo, pm8001_ha->memoryMap.region[i].total_len, pm8001_ha->memoryMap.region[i].alignment); } if (tmp___2 != 0) { { tmp___1 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___1 != 0L) { { printk("\016pm80xx %s %d:Mem%d alloc failed\n", "pm8001_alloc", 363, i); } } else { } goto err_out; } else { } i = i + 1; ldv_45871: ; if (i <= 15) { goto ldv_45870; } else { } pm8001_ha->devices = (struct pm8001_device *)pm8001_ha->memoryMap.region[3].virt_ptr; i = 0; goto ldv_45874; ldv_45873: (pm8001_ha->devices + (unsigned long )i)->dev_type = 0; (pm8001_ha->devices + (unsigned long )i)->id = (u32 )i; (pm8001_ha->devices + (unsigned long )i)->device_id = 2048U; (pm8001_ha->devices + (unsigned long )i)->running_req = 0U; i = i + 1; ldv_45874: ; if (i <= 2047) { goto ldv_45873; } else { } pm8001_ha->ccb_info = (struct pm8001_ccb_info *)pm8001_ha->memoryMap.region[4].virt_ptr; i = 0; goto ldv_45877; ldv_45876: (pm8001_ha->ccb_info + (unsigned long )i)->ccb_dma_handle = pm8001_ha->memoryMap.region[4].phys_addr + (unsigned long long )((unsigned long )i * 2112UL); (pm8001_ha->ccb_info + (unsigned long )i)->task = (struct sas_task *)0; (pm8001_ha->ccb_info + (unsigned long )i)->ccb_tag = 4294967295U; (pm8001_ha->ccb_info + (unsigned long )i)->device = (struct pm8001_device *)0; pm8001_ha->tags_num = pm8001_ha->tags_num + 1; i = i + 1; ldv_45877: ; if (i <= 511) { goto ldv_45876; } else { } { pm8001_ha->flags = 1UL; pm8001_tag_init(pm8001_ha); } return (0); err_out: ; return (1); } } static int pm8001_ioremap(struct pm8001_hba_info *pm8001_ha ) { u32 bar ; u32 logicalBar ; struct pci_dev *pdev ; long tmp ; long tmp___0 ; { logicalBar = 0U; pdev = pm8001_ha->pdev; bar = 0U; goto ldv_45888; ldv_45887: ; if (bar == 1U || bar == 3U) { goto ldv_45885; } else { } if ((pdev->resource[bar].flags & 512UL) != 0UL) { { pm8001_ha->io_mem[logicalBar].membase = pdev->resource[bar].start; pm8001_ha->io_mem[logicalBar].membase = pm8001_ha->io_mem[logicalBar].membase & 4294967280ULL; pm8001_ha->io_mem[logicalBar].memsize = pdev->resource[bar].start != 0ULL || pdev->resource[bar].end != pdev->resource[bar].start ? ((u32 )pdev->resource[bar].end - (u32 )pdev->resource[bar].start) + 1U : 0U; pm8001_ha->io_mem[logicalBar].memvirtaddr = ioremap(pm8001_ha->io_mem[logicalBar].membase, (unsigned long )pm8001_ha->io_mem[logicalBar].memsize); tmp = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:PCI: bar %d, logicalBar %d ", "pm8001_ioremap", 429, bar, logicalBar); } } else { } { tmp___0 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___0 != 0L) { { printk("\016pm80xx %s %d:base addr %llx virt_addr=%llx len=%d\n", "pm8001_ioremap", 435, pm8001_ha->io_mem[logicalBar].membase, (unsigned long long )pm8001_ha->io_mem[logicalBar].memvirtaddr, pm8001_ha->io_mem[logicalBar].memsize); } } else { } } else { pm8001_ha->io_mem[logicalBar].membase = 0ULL; pm8001_ha->io_mem[logicalBar].memsize = 0U; pm8001_ha->io_mem[logicalBar].memvirtaddr = (void *)0; } logicalBar = logicalBar + 1U; ldv_45885: bar = bar + 1U; ldv_45888: ; if (bar <= 5U) { goto ldv_45887; } else { } return (0); } } static struct pm8001_hba_info *pm8001_pci_alloc(struct pci_dev *pdev , struct pci_device_id const *ent , struct Scsi_Host *shost ) { struct pm8001_hba_info *pm8001_ha ; struct sas_ha_struct *sha ; int j ; int tmp ; int tmp___0 ; { sha = *((struct sas_ha_struct **)(& shost->hostdata)); pm8001_ha = (struct pm8001_hba_info *)sha->lldd_ha; if ((unsigned long )pm8001_ha == (unsigned long )((struct pm8001_hba_info *)0)) { return ((struct pm8001_hba_info *)0); } else { } { pm8001_ha->pdev = pdev; pm8001_ha->dev = & pdev->dev; pm8001_ha->chip_id = (u32 )ent->driver_data; pm8001_ha->chip = (struct pm8001_chip_info const *)(& pm8001_chips) + (unsigned long )pm8001_ha->chip_id; pm8001_ha->irq = pdev->irq; pm8001_ha->sas = sha; pm8001_ha->shost = shost; tmp = pm8001_id; pm8001_id = pm8001_id + 1; pm8001_ha->id = (u32 )tmp; pm8001_ha->logging_level = 1U; sprintf((char *)(& pm8001_ha->name), "%s%d", (char *)"pm80xx", pm8001_ha->id); } if (pm8001_ha->chip_id != 0U) { pm8001_ha->iomb_size = 128U; } else { pm8001_ha->iomb_size = 64U; } if ((unsigned int )pdev->msix_cap == 0U || pm8001_ha->chip_id == 0U) { { tasklet_init((struct tasklet_struct *)(& pm8001_ha->tasklet), & pm8001_tasklet, (unsigned long )(& pm8001_ha->irq_vector)); } } else { j = 0; goto ldv_45899; ldv_45898: { tasklet_init((struct tasklet_struct *)(& pm8001_ha->tasklet) + (unsigned long )j, & pm8001_tasklet, (unsigned long )((struct isr_param *)(& pm8001_ha->irq_vector) + (unsigned long )j)); j = j + 1; } ldv_45899: ; if (j <= 63) { goto ldv_45898; } else { } } { pm8001_ioremap(pm8001_ha); tmp___0 = pm8001_alloc(pm8001_ha, ent); } if (tmp___0 == 0) { return (pm8001_ha); } else { } { pm8001_free(pm8001_ha); } return ((struct pm8001_hba_info *)0); } } static int pci_go_44(struct pci_dev *pdev ) { int rc ; int tmp ; { { tmp = pci_set_dma_mask(pdev, 17592186044415ULL); } if (tmp == 0) { { rc = pci_set_consistent_dma_mask(pdev, 17592186044415ULL); } if (rc != 0) { { rc = pci_set_consistent_dma_mask(pdev, 4294967295ULL); } if (rc != 0) { { dev_printk("\v", (struct device const *)(& pdev->dev), "44-bit DMA enable failed\n"); } return (rc); } else { } } else { } } else { { rc = pci_set_dma_mask(pdev, 4294967295ULL); } if (rc != 0) { { dev_printk("\v", (struct device const *)(& pdev->dev), "32-bit DMA enable failed\n"); } return (rc); } else { } { rc = pci_set_consistent_dma_mask(pdev, 4294967295ULL); } if (rc != 0) { { dev_printk("\v", (struct device const *)(& pdev->dev), "32-bit consistent DMA enable failed\n"); } return (rc); } else { } } return (rc); } } static int pm8001_prep_sas_ha_init(struct Scsi_Host *shost , struct pm8001_chip_info const *chip_info ) { int phy_nr ; int port_nr ; struct asd_sas_phy **arr_phy ; struct asd_sas_port **arr_port ; struct sas_ha_struct *sha ; void *tmp ; void *tmp___0 ; { { sha = *((struct sas_ha_struct **)(& shost->hostdata)); phy_nr = (int )chip_info->n_phy; port_nr = phy_nr; __memset((void *)sha, 0, 848UL); tmp = kcalloc((size_t )phy_nr, 8UL, 208U); arr_phy = (struct asd_sas_phy **)tmp; } if ((unsigned long )arr_phy == (unsigned long )((struct asd_sas_phy **)0)) { goto exit; } else { } { tmp___0 = kcalloc((size_t )port_nr, 8UL, 208U); arr_port = (struct asd_sas_port **)tmp___0; } if ((unsigned long )arr_port == (unsigned long )((struct asd_sas_port **)0)) { goto exit_free2; } else { } { sha->sas_phy = arr_phy; sha->sas_port = arr_port; sha->lldd_ha = kzalloc(50016UL, 208U); } if ((unsigned long )sha->lldd_ha == (unsigned long )((void *)0)) { goto exit_free1; } else { } shost->transportt = pm8001_stt; shost->max_id = 2048U; shost->max_lun = 8ULL; shost->max_channel = 0U; shost->unique_id = (unsigned int )pm8001_id; shost->max_cmd_len = 16U; shost->can_queue = 508; shost->cmd_per_lun = 32; return (0); exit_free1: { kfree((void const *)arr_port); } exit_free2: { kfree((void const *)arr_phy); } exit: ; return (-1); } } static void pm8001_post_sas_ha_init(struct Scsi_Host *shost , struct pm8001_chip_info const *chip_info ) { int i ; struct pm8001_hba_info *pm8001_ha ; struct sas_ha_struct *sha ; { i = 0; sha = *((struct sas_ha_struct **)(& shost->hostdata)); pm8001_ha = (struct pm8001_hba_info *)sha->lldd_ha; i = 0; goto ldv_45925; ldv_45924: *(sha->sas_phy + (unsigned long )i) = & pm8001_ha->phy[i].sas_phy; *(sha->sas_port + (unsigned long )i) = & pm8001_ha->port[i].sas_port; i = i + 1; ldv_45925: ; if ((unsigned int )i < (unsigned int )chip_info->n_phy) { goto ldv_45924; } else { } sha->sas_ha_name = (char *)"pm80xx"; sha->dev = pm8001_ha->dev; sha->lldd_module = & __this_module; sha->sas_addr = (u8 *)(& pm8001_ha->sas_addr); sha->num_phys = (int )chip_info->n_phy; sha->core.shost = shost; return; } } static void pm8001_init_sas_add(struct pm8001_hba_info *pm8001_ha ) { u8 i ; u8 j ; struct completion completion ; struct pm8001_ioctl_payload payload ; u16 deviceid ; int rc ; void *tmp ; long tmp___0 ; long tmp___1 ; long tmp___2 ; { { ldv_init_completion_100(& completion); completion = completion; pci_read_config_word((struct pci_dev const *)pm8001_ha->pdev, 2, & deviceid); pm8001_ha->nvmd_completion = & completion; } if (pm8001_ha->chip_id == 0U) { if ((unsigned int )deviceid == 32897U || (unsigned int )deviceid == 66U) { payload.minor_function = 4U; payload.length = 4096U; } else { payload.minor_function = 0U; payload.length = 128U; } } else { payload.minor_function = 1U; payload.length = 4096U; } { payload.offset = 0U; tmp = kzalloc((size_t )payload.length, 208U); payload.func_specific = (u8 *)tmp; } if ((unsigned long )payload.func_specific == (unsigned long )((u8 *)0U)) { { tmp___0 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___0 != 0L) { { printk("\016pm80xx %s %d:mem alloc fail\n", "pm8001_init_sas_add", 644); } } else { } return; } else { } { rc = (*(((pm8001_ha->chip)->dispatch)->get_nvmd_req))(pm8001_ha, (void *)(& payload)); } if (rc != 0) { { kfree((void const *)payload.func_specific); tmp___1 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___1 != 0L) { { printk("\016pm80xx %s %d:nvmd failed\n", "pm8001_init_sas_add", 650); } } else { } return; } else { } { ldv_wait_for_completion_101(& completion); i = 0U; j = 0U; } goto ldv_45939; ldv_45938: ; if (pm8001_ha->chip_id == 0U) { if ((unsigned int )deviceid == 32897U) { pm8001_ha->sas_addr[(int )j] = *(payload.func_specific + (unsigned long )((int )i + 1796)); } else if ((unsigned int )deviceid == 66U) { pm8001_ha->sas_addr[(int )j] = *(payload.func_specific + (unsigned long )((int )i + 16)); } else { } } else { pm8001_ha->sas_addr[(int )j] = *(payload.func_specific + (unsigned long )((int )i + 2052)); } i = (u8 )((int )i + 1); j = (u8 )((int )j + 1); ldv_45939: ; if ((unsigned int )i <= 7U) { goto ldv_45938; } else { } i = 0U; goto ldv_45942; ldv_45941: { __memcpy((void *)(& pm8001_ha->phy[(int )i].dev_sas_addr), (void const *)(& pm8001_ha->sas_addr), 8UL); tmp___2 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___2 != 0L) { { printk("\016pm80xx %s %d:phy %d sas_addr = %016llx\n", "pm8001_init_sas_add", 673, (int )i, pm8001_ha->phy[(int )i].dev_sas_addr); } } else { } i = (u8 )((int )i + 1); ldv_45942: ; if ((unsigned int )i < (unsigned int )(pm8001_ha->chip)->n_phy) { goto ldv_45941; } else { } { kfree((void const *)payload.func_specific); } return; } } static int pm8001_get_phy_settings_info(struct pm8001_hba_info *pm8001_ha ) { struct completion completion ; struct pm8001_ioctl_payload payload ; int rc ; void *tmp ; long tmp___0 ; { { ldv_init_completion_100(& completion); completion = completion; pm8001_ha->nvmd_completion = & completion; payload.minor_function = 6U; payload.offset = 0U; payload.length = 4096U; tmp = kzalloc(4096UL, 208U); payload.func_specific = (u8 *)tmp; } if ((unsigned long )payload.func_specific == (unsigned long )((u8 *)0U)) { return (-12); } else { } { rc = (*(((pm8001_ha->chip)->dispatch)->get_nvmd_req))(pm8001_ha, (void *)(& payload)); } if (rc != 0) { { kfree((void const *)payload.func_specific); tmp___0 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___0 != 0L) { { printk("\016pm80xx %s %d:nvmd failed\n", "pm8001_get_phy_settings_info", 713); } } else { } return (-12); } else { } { ldv_wait_for_completion_103(& completion); pm8001_set_phy_profile(pm8001_ha, 1U, payload.func_specific); kfree((void const *)payload.func_specific); } return (0); } } static u32 pm8001_setup_msix(struct pm8001_hba_info *pm8001_ha ) { u32 i ; u32 j ; u32 number_of_intr ; int flag ; u32 max_entry ; int rc ; char intr_drvname[64U][10U] ; long tmp ; { i = 0U; j = 0U; flag = 0; if (pm8001_ha->chip_id == 0U) { number_of_intr = 1U; } else { number_of_intr = 64U; flag = flag & -129; } max_entry = 64U; i = 0U; goto ldv_45963; ldv_45962: pm8001_ha->msix_entries[i].entry = (u16 )i; i = i + 1U; ldv_45963: ; if (i < max_entry) { goto ldv_45962; } else { } { rc = pci_enable_msix_exact(pm8001_ha->pdev, (struct msix_entry *)(& pm8001_ha->msix_entries), (int )number_of_intr); pm8001_ha->number_of_intr = (int )number_of_intr; } if (rc != 0) { return ((u32 )rc); } else { } { tmp = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:pci_enable_msix_exact request ret:%d no of intr %d\n", "pm8001_setup_msix", 758, rc, pm8001_ha->number_of_intr); } } else { } i = 0U; goto ldv_45971; ldv_45970: { snprintf((char *)(& intr_drvname) + (unsigned long )i, 10UL, "pm80xx%d", i); pm8001_ha->irq_vector[i].irq_id = i; pm8001_ha->irq_vector[i].drv_inst = pm8001_ha; rc = ldv_request_irq_104(pm8001_ha->msix_entries[i].vector, & pm8001_interrupt_handler_msix, (unsigned long )flag, (char const *)(& intr_drvname) + (unsigned long )i, (void *)(& pm8001_ha->irq_vector) + (unsigned long )i); } if (rc != 0) { j = 0U; goto ldv_45967; ldv_45966: { ldv_free_irq_105(pm8001_ha->msix_entries[j].vector, (void *)(& pm8001_ha->irq_vector) + (unsigned long )i); j = j + 1U; } ldv_45967: ; if (j < i) { goto ldv_45966; } else { } { pci_disable_msix(pm8001_ha->pdev); } goto ldv_45969; } else { } i = i + 1U; ldv_45971: ; if (i < number_of_intr) { goto ldv_45970; } else { } ldv_45969: ; return ((u32 )rc); } } static u32 pm8001_request_irq(struct pm8001_hba_info *pm8001_ha ) { struct pci_dev *pdev ; int rc ; u32 tmp ; long tmp___0 ; { pdev = pm8001_ha->pdev; if ((unsigned int )pdev->msix_cap != 0U) { { tmp = pm8001_setup_msix(pm8001_ha); } return (tmp); } else { { tmp___0 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___0 != 0L) { { printk("\016pm80xx %s %d:MSIX not supported!!!\n", "pm8001_request_irq", 799); } } else { } goto intx; } intx: { rc = ldv_request_irq_106(pdev->irq, & pm8001_interrupt_handler_intx, 128UL, "pm80xx", (void *)*((struct sas_ha_struct **)(& (pm8001_ha->shost)->hostdata))); } return ((u32 )rc); } } static int pm8001_pci_probe(struct pci_dev *pdev , struct pci_device_id const *ent ) { unsigned int rc ; u32 pci_reg ; u8 i ; struct pm8001_hba_info *pm8001_ha ; struct Scsi_Host *shost ; struct pm8001_chip_info const *chip ; int tmp ; int tmp___0 ; int tmp___1 ; void *tmp___2 ; int tmp___3 ; int tmp___4 ; long tmp___5 ; int tmp___6 ; long tmp___7 ; int tmp___8 ; int tmp___9 ; { { i = 0U; shost = (struct Scsi_Host *)0; dev_printk("\016", (struct device const *)(& pdev->dev), "pm80xx: driver version %s\n", (char *)"0.1.37"); tmp = pci_enable_device(pdev); rc = (unsigned int )tmp; } if (rc != 0U) { goto err_out_enable; } else { } { pci_set_master(pdev); pci_read_config_dword((struct pci_dev const *)pdev, 4, & pci_reg); pci_reg = pci_reg | 343U; pci_write_config_dword((struct pci_dev const *)pdev, 4, pci_reg); tmp___0 = pci_request_regions(pdev, "pm80xx"); rc = (unsigned int )tmp___0; } if (rc != 0U) { goto err_out_disable; } else { } { tmp___1 = pci_go_44(pdev); rc = (unsigned int )tmp___1; } if (rc != 0U) { goto err_out_regions; } else { } { shost = ldv_scsi_host_alloc_107(& pm8001_sht, 8); } if ((unsigned long )shost == (unsigned long )((struct Scsi_Host *)0)) { rc = 4294967284U; goto err_out_regions; } else { } { chip = (struct pm8001_chip_info const *)(& pm8001_chips) + ent->driver_data; tmp___2 = kzalloc(848UL, 208U); *((struct sas_ha_struct **)(& shost->hostdata)) = (struct sas_ha_struct *)tmp___2; } if ((unsigned long )*((struct sas_ha_struct **)(& shost->hostdata)) == (unsigned long )((struct sas_ha_struct *)0)) { rc = 4294967284U; goto err_out_free_host; } else { } { tmp___3 = pm8001_prep_sas_ha_init(shost, chip); rc = (unsigned int )tmp___3; } if (rc != 0U) { rc = 4294967284U; goto err_out_free; } else { } { pci_set_drvdata(pdev, (void *)*((struct sas_ha_struct **)(& shost->hostdata))); pm8001_ha = pm8001_pci_alloc(pdev, ent, shost); } if ((unsigned long )pm8001_ha == (unsigned long )((struct pm8001_hba_info *)0)) { rc = 4294967284U; goto err_out_free; } else { } { list_add_tail(& pm8001_ha->list, & hba_list); (*(((pm8001_ha->chip)->dispatch)->chip_soft_rst))(pm8001_ha); tmp___4 = (*(((pm8001_ha->chip)->dispatch)->chip_init))(pm8001_ha); rc = (unsigned int )tmp___4; } if (rc != 0U) { { tmp___5 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___5 != 0L) { { printk("\016pm80xx %s %d:chip_init failed [ret: %d]\n", "pm8001_pci_probe", 881, rc); } } else { } goto err_out_ha_free; } else { } { tmp___6 = ldv_scsi_add_host_108(shost, & pdev->dev); rc = (unsigned int )tmp___6; } if (rc != 0U) { goto err_out_ha_free; } else { } { rc = pm8001_request_irq(pm8001_ha); } if (rc != 0U) { { tmp___7 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___7 != 0L) { { printk("\016pm80xx %s %d:pm8001_request_irq failed [ret: %d]\n", "pm8001_pci_probe", 891, rc); } } else { } goto err_out_shost; } else { } { (*(((pm8001_ha->chip)->dispatch)->interrupt_enable))(pm8001_ha, 0); } if (pm8001_ha->chip_id != 0U) { i = 1U; goto ldv_45998; ldv_45997: { (*(((pm8001_ha->chip)->dispatch)->interrupt_enable))(pm8001_ha, (int )i); i = (u8 )((int )i + 1); } ldv_45998: ; if ((int )i < pm8001_ha->number_of_intr) { goto ldv_45997; } else { } { pm80xx_set_thermal_config(pm8001_ha); } } else { } { pm8001_init_sas_add(pm8001_ha); } if ((unsigned int )pdev->subsystem_vendor != 36869U && (unsigned int )pdev->subsystem_vendor != 0U) { { tmp___8 = pm8001_get_phy_settings_info(pm8001_ha); rc = (unsigned int )tmp___8; } if (rc != 0U) { goto err_out_shost; } else { } } else { } { pm8001_post_sas_ha_init(shost, chip); tmp___9 = sas_register_ha(*((struct sas_ha_struct **)(& shost->hostdata))); rc = (unsigned int )tmp___9; } if (rc != 0U) { goto err_out_shost; } else { } { scsi_scan_host(pm8001_ha->shost); } return (0); err_out_shost: { ldv_scsi_remove_host_109(pm8001_ha->shost); } err_out_ha_free: { pm8001_free(pm8001_ha); } err_out_free: { kfree((void const *)*((struct sas_ha_struct **)(& shost->hostdata))); } err_out_free_host: { kfree((void const *)shost); } err_out_regions: { pci_release_regions(pdev); } err_out_disable: { pci_disable_device(pdev); } err_out_enable: ; return ((int )rc); } } static void pm8001_pci_remove(struct pci_dev *pdev ) { struct sas_ha_struct *sha ; void *tmp ; struct pm8001_hba_info *pm8001_ha ; int i ; int j ; { { tmp = pci_get_drvdata(pdev); sha = (struct sas_ha_struct *)tmp; pm8001_ha = (struct pm8001_hba_info *)sha->lldd_ha; sas_unregister_ha(sha); sas_remove_host(pm8001_ha->shost); list_del(& pm8001_ha->list); ldv_scsi_remove_host_110(pm8001_ha->shost); (*(((pm8001_ha->chip)->dispatch)->interrupt_disable))(pm8001_ha, 255); (*(((pm8001_ha->chip)->dispatch)->chip_soft_rst))(pm8001_ha); i = 0; } goto ldv_46008; ldv_46007: { synchronize_irq(pm8001_ha->msix_entries[i].vector); i = i + 1; } ldv_46008: ; if (i < pm8001_ha->number_of_intr) { goto ldv_46007; } else { } i = 0; goto ldv_46011; ldv_46010: { ldv_free_irq_111(pm8001_ha->msix_entries[i].vector, (void *)(& pm8001_ha->irq_vector) + (unsigned long )i); i = i + 1; } ldv_46011: ; if (i < pm8001_ha->number_of_intr) { goto ldv_46010; } else { } { pci_disable_msix(pdev); } if ((unsigned int )pdev->msix_cap == 0U || pm8001_ha->chip_id == 0U) { { tasklet_kill((struct tasklet_struct *)(& pm8001_ha->tasklet)); } } else { j = 0; goto ldv_46014; ldv_46013: { tasklet_kill((struct tasklet_struct *)(& pm8001_ha->tasklet) + (unsigned long )j); j = j + 1; } ldv_46014: ; if (j <= 63) { goto ldv_46013; } else { } } { pm8001_free(pm8001_ha); kfree((void const *)sha->sas_phy); kfree((void const *)sha->sas_port); kfree((void const *)sha); pci_release_regions(pdev); pci_disable_device(pdev); } return; } } static int pm8001_pci_suspend(struct pci_dev *pdev , pm_message_t state ) { struct sas_ha_struct *sha ; void *tmp ; struct pm8001_hba_info *pm8001_ha ; int i ; int j ; u32 device_state ; pci_power_t tmp___0 ; { { tmp = pci_get_drvdata(pdev); sha = (struct sas_ha_struct *)tmp; pm8001_ha = (struct pm8001_hba_info *)sha->lldd_ha; sas_suspend_ha(sha); flush_workqueue(pm8001_wq); scsi_block_requests(pm8001_ha->shost); } if ((unsigned int )pdev->pm_cap == 0U) { { dev_err((struct device const *)(& pdev->dev), " PCI PM not supported\n"); } return (-19); } else { } { (*(((pm8001_ha->chip)->dispatch)->interrupt_disable))(pm8001_ha, 255); (*(((pm8001_ha->chip)->dispatch)->chip_soft_rst))(pm8001_ha); i = 0; } goto ldv_46026; ldv_46025: { synchronize_irq(pm8001_ha->msix_entries[i].vector); i = i + 1; } ldv_46026: ; if (i < pm8001_ha->number_of_intr) { goto ldv_46025; } else { } i = 0; goto ldv_46029; ldv_46028: { ldv_free_irq_112(pm8001_ha->msix_entries[i].vector, (void *)(& pm8001_ha->irq_vector) + (unsigned long )i); i = i + 1; } ldv_46029: ; if (i < pm8001_ha->number_of_intr) { goto ldv_46028; } else { } { pci_disable_msix(pdev); } if ((unsigned int )pdev->msix_cap == 0U || pm8001_ha->chip_id == 0U) { { tasklet_kill((struct tasklet_struct *)(& pm8001_ha->tasklet)); } } else { j = 0; goto ldv_46032; ldv_46031: { tasklet_kill((struct tasklet_struct *)(& pm8001_ha->tasklet) + (unsigned long )j); j = j + 1; } ldv_46032: ; if (j <= 63) { goto ldv_46031; } else { } } { tmp___0 = pci_choose_state(pdev, state); device_state = (u32 )tmp___0; printk("\016pm80xx %s %d:pdev=0x%p, slot=%s, entering operating state [D%d]\n", "pm8001_pci_suspend", 1017, pdev, (char *)(& pm8001_ha->name), device_state); pci_save_state(pdev); pci_disable_device(pdev); pci_set_power_state(pdev, (pci_power_t )device_state); } return (0); } } static int pm8001_pci_resume(struct pci_dev *pdev ) { struct sas_ha_struct *sha ; void *tmp ; struct pm8001_hba_info *pm8001_ha ; int rc ; u8 i ; u8 j ; u32 device_state ; struct completion completion ; long tmp___0 ; u32 tmp___1 ; { { tmp = pci_get_drvdata(pdev); sha = (struct sas_ha_struct *)tmp; i = 0U; ldv_init_completion_100(& completion); completion = completion; pm8001_ha = (struct pm8001_hba_info *)sha->lldd_ha; device_state = (u32 )pdev->current_state; printk("\016pm80xx %s %d:pdev=0x%p, slot=%s, resuming from previous operating state [D%d]\n", "pm8001_pci_resume", 1042, pdev, (char *)(& pm8001_ha->name), device_state); pci_set_power_state(pdev, 0); pci_enable_wake(pdev, 0, 0); pci_restore_state(pdev); rc = pci_enable_device(pdev); } if (rc != 0) { { printk("\016pm80xx %s %d:slot=%s Enable device failed during resume\n", "pm8001_pci_resume", 1050, (char *)(& pm8001_ha->name)); } goto err_out_enable; } else { } { pci_set_master(pdev); rc = pci_go_44(pdev); } if (rc != 0) { goto err_out_disable; } else { } { sas_prep_resume_ha(sha); } if (pm8001_ha->chip_id == 0U) { { (*(((pm8001_ha->chip)->dispatch)->chip_soft_rst))(pm8001_ha); tmp___0 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___0 != 0L) { { printk("\016pm80xx %s %d:chip soft reset successful\n", "pm8001_pci_resume", 1063); } } else { } } else { } { rc = (*(((pm8001_ha->chip)->dispatch)->chip_init))(pm8001_ha); } if (rc != 0) { goto err_out_disable; } else { } { (*(((pm8001_ha->chip)->dispatch)->interrupt_disable))(pm8001_ha, 255); tmp___1 = pm8001_request_irq(pm8001_ha); rc = (int )tmp___1; } if (rc != 0) { goto err_out_disable; } else { } if ((unsigned int )pdev->msix_cap == 0U || pm8001_ha->chip_id == 0U) { { tasklet_init((struct tasklet_struct *)(& pm8001_ha->tasklet), & pm8001_tasklet, (unsigned long )(& pm8001_ha->irq_vector)); } } else { j = 0U; goto ldv_46050; ldv_46049: { tasklet_init((struct tasklet_struct *)(& pm8001_ha->tasklet) + (unsigned long )j, & pm8001_tasklet, (unsigned long )((struct isr_param *)(& pm8001_ha->irq_vector) + (unsigned long )j)); j = (u8 )((int )j + 1); } ldv_46050: ; if ((unsigned int )j <= 63U) { goto ldv_46049; } else { } } { (*(((pm8001_ha->chip)->dispatch)->interrupt_enable))(pm8001_ha, 0); } if (pm8001_ha->chip_id != 0U) { i = 1U; goto ldv_46053; ldv_46052: { (*(((pm8001_ha->chip)->dispatch)->interrupt_enable))(pm8001_ha, (int )i); i = (u8 )((int )i + 1); } ldv_46053: ; if ((int )i < pm8001_ha->number_of_intr) { goto ldv_46052; } else { } } else { } pm8001_ha->flags = 2UL; i = 0U; goto ldv_46056; ldv_46055: { pm8001_ha->phy[(int )i].enable_completion = & completion; (*(((pm8001_ha->chip)->dispatch)->phy_start_req))(pm8001_ha, (int )i); ldv_wait_for_completion_114(& completion); i = (u8 )((int )i + 1); } ldv_46056: ; if ((unsigned int )i < (unsigned int )(pm8001_ha->chip)->n_phy) { goto ldv_46055; } else { } { sas_resume_ha(sha); } return (0); err_out_disable: { ldv_scsi_remove_host_115(pm8001_ha->shost); pci_disable_device(pdev); } err_out_enable: ; return (rc); } } static struct pci_device_id pm8001_pci_table[37U] = { {4600U, 32769U, 4294967295U, 4294967295U, 0U, 0U, 0UL}, {4476U, 66U, 4294967295U, 4294967295U, 0U, 0U, 0UL}, {36869U, 32769U, 4294967295U, 4294967295U, 0U, 0U, 0UL}, {4600U, 32776U, 4294967295U, 4294967295U, 0U, 0U, 1UL}, {36869U, 32776U, 4294967295U, 4294967295U, 0U, 0U, 1UL}, {4600U, 32792U, 4294967295U, 4294967295U, 0U, 0U, 3UL}, {36869U, 32792U, 4294967295U, 4294967295U, 0U, 0U, 3UL}, {4600U, 32777U, 4294967295U, 4294967295U, 0U, 0U, 2UL}, {36869U, 32777U, 4294967295U, 4294967295U, 0U, 0U, 2UL}, {4600U, 32793U, 4294967295U, 4294967295U, 0U, 0U, 4UL}, {36869U, 32793U, 4294967295U, 4294967295U, 0U, 0U, 4UL}, {4600U, 32884U, 4294967295U, 4294967295U, 0U, 0U, 5UL}, {36869U, 32884U, 4294967295U, 4294967295U, 0U, 0U, 5UL}, {4600U, 32886U, 4294967295U, 4294967295U, 0U, 0U, 6UL}, {36869U, 32886U, 4294967295U, 4294967295U, 0U, 0U, 6UL}, {4600U, 32887U, 4294967295U, 4294967295U, 0U, 0U, 7UL}, {36869U, 32887U, 4294967295U, 4294967295U, 0U, 0U, 7UL}, {36869U, 32897U, 36869U, 1024U, 0U, 0U, 0UL}, {36869U, 32897U, 36869U, 2048U, 0U, 0U, 0UL}, {36869U, 32904U, 36869U, 8U, 0U, 0U, 1UL}, {36869U, 32904U, 36869U, 2048U, 0U, 0U, 1UL}, {36869U, 32905U, 36869U, 8U, 0U, 0U, 2UL}, {36869U, 32905U, 36869U, 2048U, 0U, 0U, 2UL}, {36869U, 32904U, 36869U, 22U, 0U, 0U, 3UL}, {36869U, 32904U, 36869U, 5632U, 0U, 0U, 3UL}, {36869U, 32905U, 36869U, 22U, 0U, 0U, 4UL}, {36869U, 32905U, 36869U, 5632U, 0U, 0U, 4UL}, {36869U, 32884U, 36869U, 2048U, 0U, 0U, 5UL}, {36869U, 32886U, 36869U, 5632U, 0U, 0U, 6UL}, {36869U, 32887U, 36869U, 5632U, 0U, 0U, 7UL}, {36869U, 32884U, 36869U, 8U, 0U, 0U, 5UL}, {36869U, 32886U, 36869U, 22U, 0U, 0U, 6UL}, {36869U, 32887U, 36869U, 22U, 0U, 0U, 7UL}, {36869U, 32886U, 36869U, 2056U, 0U, 0U, 6UL}, {36869U, 32887U, 36869U, 2056U, 0U, 0U, 7UL}, {36869U, 32884U, 36869U, 1028U, 0U, 0U, 5UL}}; static struct pci_driver pm8001_pci_driver = {{0, 0}, "pm80xx", (struct pci_device_id const *)(& pm8001_pci_table), & pm8001_pci_probe, & pm8001_pci_remove, & pm8001_pci_suspend, 0, 0, & pm8001_pci_resume, 0, 0, 0, {0, 0, 0, 0, (_Bool)0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, {{{{{{0U}}, 0U, 0U, 0, {0, {0, 0}, 0, 0, 0UL}}}}, {0, 0}}}; static int pm8001_init(void) { int rc ; struct lock_class_key __key ; char const *__lock_name ; struct workqueue_struct *tmp ; { { rc = -12; __lock_name = "\"pm80xx\""; tmp = __alloc_workqueue_key("pm80xx", 0U, 0, & __key, __lock_name); pm8001_wq = tmp; } if ((unsigned long )pm8001_wq == (unsigned long )((struct workqueue_struct *)0)) { goto err; } else { } { pm8001_id = 0; pm8001_stt = sas_domain_attach_transport(& pm8001_transport_ops); } if ((unsigned long )pm8001_stt == (unsigned long )((struct scsi_transport_template *)0)) { goto err_wq; } else { } { rc = ldv___pci_register_driver_116(& pm8001_pci_driver, & __this_module, "pm80xx"); } if (rc != 0) { goto err_tp; } else { } return (0); err_tp: { sas_release_transport(pm8001_stt); } err_wq: { destroy_workqueue(pm8001_wq); } err: ; return (rc); } } static void pm8001_exit(void) { { { ldv_pci_unregister_driver_117(& pm8001_pci_driver); sas_release_transport(pm8001_stt); destroy_workqueue(pm8001_wq); } return; } } struct pci_device_id const __mod_pci__pm8001_pci_table_device_table[37U] ; void ldv_EMGentry_exit_pm8001_exit_34_2(void (*arg0)(void) ) ; int ldv_EMGentry_init_pm8001_init_34_15(int (*arg0)(void) ) ; int ldv___pci_register_driver(int arg0 , struct pci_driver *arg1 , struct module *arg2 , char *arg3 ) ; void ldv_dispatch_deregister_31_1(struct Scsi_Host *arg0 ) ; void ldv_dispatch_deregister_32_1(struct pci_driver *arg0 ) ; void ldv_dispatch_deregister_dummy_factory_16_34_4(void) ; void ldv_dispatch_deregister_dummy_resourceless_instance_12_34_5(void) ; void ldv_dispatch_deregister_dummy_resourceless_instance_13_34_6(void) ; void ldv_dispatch_deregister_dummy_resourceless_instance_14_34_7(void) ; void ldv_dispatch_instance_register_24_3(struct timer_list *arg0 ) ; void ldv_dispatch_irq_deregister_26_1(int arg0 ) ; void ldv_dispatch_irq_register_27_2(int arg0 , enum irqreturn (*arg1)(int , void * ) , enum irqreturn (*arg2)(int , void * ) , void *arg3 ) ; void ldv_dispatch_irq_register_28_2(int arg0 , enum irqreturn (*arg1)(int , void * ) , enum irqreturn (*arg2)(int , void * ) , void *arg3 ) ; void ldv_dispatch_register_29_2(struct Scsi_Host *arg0 ) ; void ldv_dispatch_register_33_2(struct pci_driver *arg0 ) ; void ldv_dispatch_register_dummy_factory_16_34_8(void) ; void ldv_dispatch_register_dummy_resourceless_instance_12_34_9(void) ; void ldv_dispatch_register_dummy_resourceless_instance_13_34_10(void) ; void ldv_dispatch_register_dummy_resourceless_instance_14_34_11(void) ; void ldv_dummy_resourceless_instance_callback_10_9(long (*arg0)(struct device * , struct device_attribute * , char * , unsigned long ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 , unsigned long arg4 ) ; void ldv_dummy_resourceless_instance_callback_11_9(long (*arg0)(struct device * , struct device_attribute * , char * , unsigned long ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 , unsigned long arg4 ) ; void ldv_dummy_resourceless_instance_callback_12_9(long (*arg0)(struct device * , struct device_attribute * , char * , unsigned long ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 , unsigned long arg4 ) ; void ldv_dummy_resourceless_instance_callback_14_9(long (*arg0)(struct device * , struct device_attribute * , char * , unsigned long ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 , unsigned long arg4 ) ; void ldv_dummy_resourceless_instance_callback_15_9(long (*arg0)(struct device * , struct device_attribute * , char * , unsigned long ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 , unsigned long arg4 ) ; void ldv_dummy_resourceless_instance_callback_16_9(long (*arg0)(struct device * , struct device_attribute * , char * , unsigned long ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 , unsigned long arg4 ) ; void ldv_dummy_resourceless_instance_callback_17_9(long (*arg0)(struct device * , struct device_attribute * , char * , unsigned long ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 , unsigned long arg4 ) ; void ldv_dummy_resourceless_instance_callback_18_9(long (*arg0)(struct device * , struct device_attribute * , char * , unsigned long ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 , unsigned long arg4 ) ; void ldv_dummy_resourceless_instance_callback_20_10(int (*arg0)(struct pm8001_hba_info * , unsigned int ) , struct pm8001_hba_info *arg1 , unsigned int arg2 ) ; void ldv_dummy_resourceless_instance_callback_20_13(int (*arg0)(struct pm8001_hba_info * , void * ) , struct pm8001_hba_info *arg1 , void *arg2 ) ; void ldv_dummy_resourceless_instance_callback_20_14(int (*arg0)(struct pm8001_hba_info * , void * ) , struct pm8001_hba_info *arg1 , void *arg2 ) ; void ldv_dummy_resourceless_instance_callback_20_15(void (*arg0)(struct pm8001_hba_info * , unsigned char ) , struct pm8001_hba_info *arg1 , unsigned char arg2 ) ; void ldv_dummy_resourceless_instance_callback_20_18(void (*arg0)(struct pm8001_hba_info * , unsigned char ) , struct pm8001_hba_info *arg1 , unsigned char arg2 ) ; void ldv_dummy_resourceless_instance_callback_20_21(unsigned int (*arg0)(struct pm8001_hba_info * ) , struct pm8001_hba_info *arg1 ) ; void ldv_dummy_resourceless_instance_callback_20_22(enum irqreturn (*arg0)(struct pm8001_hba_info * , unsigned char ) , struct pm8001_hba_info *arg1 , unsigned char arg2 ) ; void ldv_dummy_resourceless_instance_callback_20_25(int (*arg0)(struct pm8001_hba_info * , unsigned char ) , struct pm8001_hba_info *arg1 , unsigned char arg2 ) ; void ldv_dummy_resourceless_instance_callback_20_28(void (*arg0)(struct scatterlist * , int , void * ) , struct scatterlist *arg1 , int arg2 , void *arg3 ) ; void ldv_dummy_resourceless_instance_callback_20_3(int (*arg0)(struct pm8001_hba_info * ) , struct pm8001_hba_info *arg1 ) ; void ldv_dummy_resourceless_instance_callback_20_31(int (*arg0)(struct pm8001_hba_info * , unsigned int , unsigned int ) , struct pm8001_hba_info *arg1 , unsigned int arg2 , unsigned int arg3 ) ; void ldv_dummy_resourceless_instance_callback_20_34(int (*arg0)(struct pm8001_hba_info * , unsigned char ) , struct pm8001_hba_info *arg1 , unsigned char arg2 ) ; void ldv_dummy_resourceless_instance_callback_20_37(int (*arg0)(struct pm8001_hba_info * , unsigned char ) , struct pm8001_hba_info *arg1 , unsigned char arg2 ) ; void ldv_dummy_resourceless_instance_callback_20_40(int (*arg0)(struct pm8001_hba_info * , struct pm8001_device * , unsigned int ) , struct pm8001_hba_info *arg1 , struct pm8001_device *arg2 , unsigned int arg3 ) ; void ldv_dummy_resourceless_instance_callback_20_43(int (*arg0)(struct pm8001_hba_info * ) , struct pm8001_hba_info *arg1 ) ; void ldv_dummy_resourceless_instance_callback_20_44(int (*arg0)(struct pm8001_hba_info * , struct pm8001_ccb_info * ) , struct pm8001_hba_info *arg1 , struct pm8001_ccb_info *arg2 ) ; void ldv_dummy_resourceless_instance_callback_20_45(int (*arg0)(struct pm8001_hba_info * , struct pm8001_device * , unsigned int ) , struct pm8001_hba_info *arg1 , struct pm8001_device *arg2 , unsigned int arg3 ) ; void ldv_dummy_resourceless_instance_callback_20_48(int (*arg0)(struct pm8001_hba_info * , void * ) , struct pm8001_hba_info *arg1 , void *arg2 ) ; void ldv_dummy_resourceless_instance_callback_20_49(int (*arg0)(struct pm8001_hba_info * , struct pm8001_ccb_info * ) , struct pm8001_hba_info *arg1 , struct pm8001_ccb_info *arg2 ) ; void ldv_dummy_resourceless_instance_callback_20_50(int (*arg0)(struct pm8001_hba_info * , struct pm8001_ccb_info * ) , struct pm8001_hba_info *arg1 , struct pm8001_ccb_info *arg2 ) ; void ldv_dummy_resourceless_instance_callback_20_51(int (*arg0)(struct pm8001_hba_info * , struct pm8001_ccb_info * , struct pm8001_tmf_task * ) , struct pm8001_hba_info *arg1 , struct pm8001_ccb_info *arg2 , struct pm8001_tmf_task *arg3 ) ; void ldv_dummy_resourceless_instance_callback_20_52(int (*arg0)(struct pm8001_hba_info * , struct pm8001_device * , unsigned char , unsigned int , unsigned int ) , struct pm8001_hba_info *arg1 , struct pm8001_device *arg2 , unsigned char arg3 , unsigned int arg4 , unsigned int arg5 ) ; void ldv_dummy_resourceless_instance_callback_20_7(void (*arg0)(struct pm8001_hba_info * ) , struct pm8001_hba_info *arg1 ) ; void ldv_dummy_resourceless_instance_callback_20_8(void (*arg0)(struct pm8001_hba_info * ) , struct pm8001_hba_info *arg1 ) ; void ldv_dummy_resourceless_instance_callback_20_9(int (*arg0)(struct pm8001_hba_info * ) , struct pm8001_hba_info *arg1 ) ; void ldv_dummy_resourceless_instance_callback_21_10(int (*arg0)(struct pm8001_hba_info * , unsigned int ) , struct pm8001_hba_info *arg1 , unsigned int arg2 ) ; void ldv_dummy_resourceless_instance_callback_21_13(int (*arg0)(struct pm8001_hba_info * , void * ) , struct pm8001_hba_info *arg1 , void *arg2 ) ; void ldv_dummy_resourceless_instance_callback_21_14(int (*arg0)(struct pm8001_hba_info * , void * ) , struct pm8001_hba_info *arg1 , void *arg2 ) ; void ldv_dummy_resourceless_instance_callback_21_15(void (*arg0)(struct pm8001_hba_info * , unsigned char ) , struct pm8001_hba_info *arg1 , unsigned char arg2 ) ; void ldv_dummy_resourceless_instance_callback_21_18(void (*arg0)(struct pm8001_hba_info * , unsigned char ) , struct pm8001_hba_info *arg1 , unsigned char arg2 ) ; void ldv_dummy_resourceless_instance_callback_21_21(unsigned int (*arg0)(struct pm8001_hba_info * ) , struct pm8001_hba_info *arg1 ) ; void ldv_dummy_resourceless_instance_callback_21_22(enum irqreturn (*arg0)(struct pm8001_hba_info * , unsigned char ) , struct pm8001_hba_info *arg1 , unsigned char arg2 ) ; void ldv_dummy_resourceless_instance_callback_21_25(int (*arg0)(struct pm8001_hba_info * , unsigned char ) , struct pm8001_hba_info *arg1 , unsigned char arg2 ) ; void ldv_dummy_resourceless_instance_callback_21_28(void (*arg0)(struct scatterlist * , int , void * ) , struct scatterlist *arg1 , int arg2 , void *arg3 ) ; void ldv_dummy_resourceless_instance_callback_21_3(int (*arg0)(struct pm8001_hba_info * ) , struct pm8001_hba_info *arg1 ) ; void ldv_dummy_resourceless_instance_callback_21_31(int (*arg0)(struct pm8001_hba_info * , unsigned int , unsigned int ) , struct pm8001_hba_info *arg1 , unsigned int arg2 , unsigned int arg3 ) ; void ldv_dummy_resourceless_instance_callback_21_34(int (*arg0)(struct pm8001_hba_info * , unsigned char ) , struct pm8001_hba_info *arg1 , unsigned char arg2 ) ; void ldv_dummy_resourceless_instance_callback_21_37(int (*arg0)(struct pm8001_hba_info * , unsigned char ) , struct pm8001_hba_info *arg1 , unsigned char arg2 ) ; void ldv_dummy_resourceless_instance_callback_21_40(int (*arg0)(struct pm8001_hba_info * , struct pm8001_device * , unsigned int ) , struct pm8001_hba_info *arg1 , struct pm8001_device *arg2 , unsigned int arg3 ) ; void ldv_dummy_resourceless_instance_callback_21_43(int (*arg0)(struct pm8001_hba_info * ) , struct pm8001_hba_info *arg1 ) ; void ldv_dummy_resourceless_instance_callback_21_44(int (*arg0)(struct pm8001_hba_info * , struct pm8001_ccb_info * ) , struct pm8001_hba_info *arg1 , struct pm8001_ccb_info *arg2 ) ; void ldv_dummy_resourceless_instance_callback_21_45(int (*arg0)(struct pm8001_hba_info * , struct pm8001_device * , unsigned int ) , struct pm8001_hba_info *arg1 , struct pm8001_device *arg2 , unsigned int arg3 ) ; void ldv_dummy_resourceless_instance_callback_21_48(int (*arg0)(struct pm8001_hba_info * , void * ) , struct pm8001_hba_info *arg1 , void *arg2 ) ; void ldv_dummy_resourceless_instance_callback_21_49(int (*arg0)(struct pm8001_hba_info * , struct pm8001_ccb_info * ) , struct pm8001_hba_info *arg1 , struct pm8001_ccb_info *arg2 ) ; void ldv_dummy_resourceless_instance_callback_21_50(int (*arg0)(struct pm8001_hba_info * , struct pm8001_ccb_info * ) , struct pm8001_hba_info *arg1 , struct pm8001_ccb_info *arg2 ) ; void ldv_dummy_resourceless_instance_callback_21_51(int (*arg0)(struct pm8001_hba_info * , struct pm8001_ccb_info * , struct pm8001_tmf_task * ) , struct pm8001_hba_info *arg1 , struct pm8001_ccb_info *arg2 , struct pm8001_tmf_task *arg3 ) ; void ldv_dummy_resourceless_instance_callback_21_52(int (*arg0)(struct pm8001_hba_info * , struct pm8001_device * , unsigned char , unsigned int , unsigned int ) , struct pm8001_hba_info *arg1 , struct pm8001_device *arg2 , unsigned char arg3 , unsigned int arg4 , unsigned int arg5 ) ; void ldv_dummy_resourceless_instance_callback_21_7(void (*arg0)(struct pm8001_hba_info * ) , struct pm8001_hba_info *arg1 ) ; void ldv_dummy_resourceless_instance_callback_21_8(void (*arg0)(struct pm8001_hba_info * ) , struct pm8001_hba_info *arg1 ) ; void ldv_dummy_resourceless_instance_callback_21_9(int (*arg0)(struct pm8001_hba_info * ) , struct pm8001_hba_info *arg1 ) ; void ldv_dummy_resourceless_instance_callback_22_11(int (*arg0)(struct domain_device * , unsigned char * ) , struct domain_device *arg1 , unsigned char *arg2 ) ; void ldv_dummy_resourceless_instance_callback_22_14(int (*arg0)(struct domain_device * , unsigned char * ) , struct domain_device *arg1 , unsigned char *arg2 ) ; void ldv_dummy_resourceless_instance_callback_22_17(int (*arg0)(struct asd_sas_phy * , enum phy_func , void * ) , struct asd_sas_phy *arg1 , enum phy_func arg2 , void *arg3 ) ; void ldv_dummy_resourceless_instance_callback_22_18(int (*arg0)(struct domain_device * ) , struct domain_device *arg1 ) ; void ldv_dummy_resourceless_instance_callback_22_19(void (*arg0)(struct domain_device * ) , struct domain_device *arg1 ) ; void ldv_dummy_resourceless_instance_callback_22_20(int (*arg0)(struct sas_task * , unsigned int ) , struct sas_task *arg1 , unsigned int arg2 ) ; void ldv_dummy_resourceless_instance_callback_22_23(int (*arg0)(struct domain_device * , unsigned char * ) , struct domain_device *arg1 , unsigned char *arg2 ) ; void ldv_dummy_resourceless_instance_callback_22_26(int (*arg0)(struct sas_task * ) , struct sas_task *arg1 ) ; void ldv_dummy_resourceless_instance_callback_22_3(int (*arg0)(struct domain_device * ) , struct domain_device *arg1 ) ; void ldv_dummy_resourceless_instance_callback_22_7(int (*arg0)(struct sas_task * ) , struct sas_task *arg1 ) ; void ldv_dummy_resourceless_instance_callback_22_8(int (*arg0)(struct domain_device * , unsigned char * ) , struct domain_device *arg1 , unsigned char *arg2 ) ; void ldv_dummy_resourceless_instance_callback_4_9(long (*arg0)(struct device * , struct device_attribute * , char * , unsigned long ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 , unsigned long arg4 ) ; void ldv_dummy_resourceless_instance_callback_5_9(long (*arg0)(struct device * , struct device_attribute * , char * , unsigned long ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 , unsigned long arg4 ) ; void ldv_dummy_resourceless_instance_callback_6_9(long (*arg0)(struct device * , struct device_attribute * , char * , unsigned long ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 , unsigned long arg4 ) ; void ldv_dummy_resourceless_instance_callback_7_9(long (*arg0)(struct device * , struct device_attribute * , char * , unsigned long ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 , unsigned long arg4 ) ; void ldv_dummy_resourceless_instance_callback_8_9(long (*arg0)(struct device * , struct device_attribute * , char * , unsigned long ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 , unsigned long arg4 ) ; void ldv_dummy_resourceless_instance_callback_9_9(long (*arg0)(struct device * , struct device_attribute * , char * , unsigned long ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 , unsigned long arg4 ) ; void ldv_entry_EMGentry_34(void *arg0 ) ; int main(void) ; void ldv_free_irq(void *arg0 , int arg1 , void *arg2 ) ; enum irqreturn ldv_interrupt_instance_handler_0_5(enum irqreturn (*arg0)(int , void * ) , int arg1 , void *arg2 ) ; enum irqreturn ldv_interrupt_instance_handler_1_5(enum irqreturn (*arg0)(int , void * ) , int arg1 , void *arg2 ) ; void ldv_interrupt_instance_thread_0_3(enum irqreturn (*arg0)(int , void * ) , int arg1 , void *arg2 ) ; void ldv_interrupt_instance_thread_1_3(enum irqreturn (*arg0)(int , void * ) , int arg1 , void *arg2 ) ; void ldv_interrupt_interrupt_instance_0(void *arg0 ) ; void ldv_interrupt_interrupt_instance_1(void *arg0 ) ; int ldv_pci_instance_probe_2_17(int (*arg0)(struct pci_dev * , struct pci_device_id * ) , struct pci_dev *arg1 , struct pci_device_id *arg2 ) ; void ldv_pci_instance_release_2_2(void (*arg0)(struct pci_dev * ) , struct pci_dev *arg1 ) ; void ldv_pci_instance_resume_2_5(int (*arg0)(struct pci_dev * ) , struct pci_dev *arg1 ) ; void ldv_pci_instance_resume_early_2_6(int (*arg0)(struct pci_dev * ) , struct pci_dev *arg1 ) ; void ldv_pci_instance_shutdown_2_3(void (*arg0)(struct pci_dev * ) , struct pci_dev *arg1 ) ; int ldv_pci_instance_suspend_2_8(int (*arg0)(struct pci_dev * , struct pm_message ) , struct pci_dev *arg1 , struct pm_message arg2 ) ; int ldv_pci_instance_suspend_late_2_7(int (*arg0)(struct pci_dev * , struct pm_message ) , struct pci_dev *arg1 , struct pm_message arg2 ) ; void ldv_pci_pci_instance_2(void *arg0 ) ; void ldv_pci_unregister_driver(void *arg0 , struct pci_driver *arg1 ) ; int ldv_request_irq(int arg0 , unsigned int arg1 , enum irqreturn (*arg2)(int , void * ) , unsigned long arg3 , char *arg4 , void *arg5 ) ; int ldv_scsi_add_host(int arg0 , struct Scsi_Host *arg1 , struct device *arg2 ) ; struct Scsi_Host *ldv_scsi_host_alloc(struct Scsi_Host *arg0 , struct scsi_host_template *arg1 , int arg2 ) ; void ldv_scsi_host_template_instance_callback_3_17(int (*arg0)(struct scsi_device * , int ) , struct scsi_device *arg1 , int arg2 ) ; void ldv_scsi_host_template_instance_callback_3_20(int (*arg0)(struct scsi_cmnd * ) , struct scsi_cmnd *arg1 ) ; void ldv_scsi_host_template_instance_callback_3_21(int (*arg0)(struct scsi_cmnd * ) , struct scsi_cmnd *arg1 ) ; void ldv_scsi_host_template_instance_callback_3_22(int (*arg0)(struct scsi_device * , int , void * ) , struct scsi_device *arg1 , int arg2 , void *arg3 ) ; void ldv_scsi_host_template_instance_callback_3_25(int (*arg0)(struct Scsi_Host * , struct scsi_cmnd * ) , struct Scsi_Host *arg1 , struct scsi_cmnd *arg2 ) ; void ldv_scsi_host_template_instance_callback_3_26(int (*arg0)(struct Scsi_Host * , unsigned long ) , struct Scsi_Host *arg1 , unsigned long arg2 ) ; void ldv_scsi_host_template_instance_callback_3_29(void (*arg0)(struct Scsi_Host * ) , struct Scsi_Host *arg1 ) ; void ldv_scsi_host_template_instance_callback_3_30(int (*arg0)(struct scsi_device * ) , struct scsi_device *arg1 ) ; void ldv_scsi_host_template_instance_callback_3_31(int (*arg0)(struct scsi_target * ) , struct scsi_target *arg1 ) ; void ldv_scsi_host_template_instance_callback_3_32(void (*arg0)(struct scsi_target * ) , struct scsi_target *arg1 ) ; void ldv_scsi_host_template_instance_callback_3_4(int (*arg0)(struct scsi_device * , struct block_device * , unsigned long , int * ) , struct scsi_device *arg1 , struct block_device *arg2 , unsigned long arg3 , int *arg4 ) ; int ldv_scsi_host_template_instance_probe_3_10(int (*arg0)(struct Scsi_Host * ) , struct Scsi_Host *arg1 ) ; void ldv_scsi_host_template_instance_release_3_2(int (*arg0)(struct Scsi_Host * ) , struct Scsi_Host *arg1 ) ; void ldv_scsi_host_template_scsi_host_template_instance_3(void *arg0 ) ; void ldv_scsi_remove_host(void *arg0 , struct Scsi_Host *arg1 ) ; void ldv_struct_device_attribute_dummy_resourceless_instance_10(void *arg0 ) ; void ldv_struct_device_attribute_dummy_resourceless_instance_11(void *arg0 ) ; void ldv_struct_device_attribute_dummy_resourceless_instance_12(void *arg0 ) ; void ldv_struct_device_attribute_dummy_resourceless_instance_13(void *arg0 ) ; void ldv_struct_device_attribute_dummy_resourceless_instance_14(void *arg0 ) ; void ldv_struct_device_attribute_dummy_resourceless_instance_15(void *arg0 ) ; void ldv_struct_device_attribute_dummy_resourceless_instance_16(void *arg0 ) ; void ldv_struct_device_attribute_dummy_resourceless_instance_17(void *arg0 ) ; void ldv_struct_device_attribute_dummy_resourceless_instance_18(void *arg0 ) ; void ldv_struct_device_attribute_dummy_resourceless_instance_19(void *arg0 ) ; void ldv_struct_device_attribute_dummy_resourceless_instance_4(void *arg0 ) ; void ldv_struct_device_attribute_dummy_resourceless_instance_5(void *arg0 ) ; void ldv_struct_device_attribute_dummy_resourceless_instance_6(void *arg0 ) ; void ldv_struct_device_attribute_dummy_resourceless_instance_7(void *arg0 ) ; void ldv_struct_device_attribute_dummy_resourceless_instance_8(void *arg0 ) ; void ldv_struct_device_attribute_dummy_resourceless_instance_9(void *arg0 ) ; void ldv_struct_pm8001_dispatch_dummy_resourceless_instance_20(void *arg0 ) ; void ldv_struct_pm8001_dispatch_dummy_resourceless_instance_21(void *arg0 ) ; void ldv_struct_sas_domain_function_template_dummy_resourceless_instance_22(void *arg0 ) ; void ldv_timer_dummy_factory_24(void *arg0 ) ; void ldv_timer_instance_callback_23_2(void (*arg0)(unsigned long ) , unsigned long arg1 ) ; void ldv_timer_timer_instance_23(void *arg0 ) ; struct ldv_thread ldv_thread_0 ; struct ldv_thread ldv_thread_1 ; struct ldv_thread ldv_thread_2 ; struct ldv_thread ldv_thread_20 ; struct ldv_thread ldv_thread_21 ; struct ldv_thread ldv_thread_22 ; struct ldv_thread ldv_thread_23 ; struct ldv_thread ldv_thread_24 ; struct ldv_thread ldv_thread_3 ; struct ldv_thread ldv_thread_34 ; void ldv_EMGentry_exit_pm8001_exit_34_2(void (*arg0)(void) ) { { { pm8001_exit(); } return; } } int ldv_EMGentry_init_pm8001_init_34_15(int (*arg0)(void) ) { int tmp ; { { tmp = pm8001_init(); } return (tmp); } } int ldv___pci_register_driver(int arg0 , struct pci_driver *arg1 , struct module *arg2 , char *arg3 ) { struct pci_driver *ldv_33_pci_driver_pci_driver ; int tmp ; { { tmp = ldv_undef_int(); } if (tmp != 0) { { ldv_assume(arg0 == 0); ldv_33_pci_driver_pci_driver = arg1; ldv_dispatch_register_33_2(ldv_33_pci_driver_pci_driver); } return (arg0); } else { { ldv_assume(arg0 != 0); } return (arg0); } return (arg0); } } void ldv_dispatch_deregister_31_1(struct Scsi_Host *arg0 ) { { return; } } void ldv_dispatch_deregister_32_1(struct pci_driver *arg0 ) { { return; } } void ldv_dispatch_deregister_dummy_factory_16_34_4(void) { { return; } } void ldv_dispatch_deregister_dummy_resourceless_instance_12_34_5(void) { { return; } } void ldv_dispatch_deregister_dummy_resourceless_instance_13_34_6(void) { { return; } } void ldv_dispatch_deregister_dummy_resourceless_instance_14_34_7(void) { { return; } } void ldv_dispatch_instance_register_24_3(struct timer_list *arg0 ) { struct ldv_struct_timer_instance_23 *cf_arg_23 ; void *tmp ; { { tmp = ldv_xmalloc(16UL); cf_arg_23 = (struct ldv_struct_timer_instance_23 *)tmp; cf_arg_23->arg0 = arg0; ldv_timer_timer_instance_23((void *)cf_arg_23); } return; } } void ldv_dispatch_irq_deregister_26_1(int arg0 ) { int tmp ; { { tmp = ldv_undef_int(); } return; } } void ldv_dispatch_irq_register_27_2(int arg0 , enum irqreturn (*arg1)(int , void * ) , enum irqreturn (*arg2)(int , void * ) , void *arg3 ) { struct ldv_struct_interrupt_instance_0 *cf_arg_0 ; struct ldv_struct_interrupt_instance_0 *cf_arg_1 ; void *tmp ; void *tmp___0 ; int tmp___1 ; { { tmp___1 = ldv_undef_int(); } if (tmp___1 != 0) { { tmp = ldv_xmalloc(40UL); cf_arg_0 = (struct ldv_struct_interrupt_instance_0 *)tmp; cf_arg_0->arg0 = arg0; cf_arg_0->arg1 = arg1; cf_arg_0->arg2 = arg2; cf_arg_0->arg3 = arg3; ldv_interrupt_interrupt_instance_0((void *)cf_arg_0); } } else { { tmp___0 = ldv_xmalloc(40UL); cf_arg_1 = (struct ldv_struct_interrupt_instance_0 *)tmp___0; cf_arg_1->arg0 = arg0; cf_arg_1->arg1 = arg1; cf_arg_1->arg2 = arg2; cf_arg_1->arg3 = arg3; ldv_interrupt_interrupt_instance_1((void *)cf_arg_1); } } return; } } void ldv_dispatch_irq_register_28_2(int arg0 , enum irqreturn (*arg1)(int , void * ) , enum irqreturn (*arg2)(int , void * ) , void *arg3 ) { struct ldv_struct_interrupt_instance_0 *cf_arg_0 ; struct ldv_struct_interrupt_instance_0 *cf_arg_1 ; void *tmp ; void *tmp___0 ; int tmp___1 ; { { tmp___1 = ldv_undef_int(); } if (tmp___1 != 0) { { tmp = ldv_xmalloc(40UL); cf_arg_0 = (struct ldv_struct_interrupt_instance_0 *)tmp; cf_arg_0->arg0 = arg0; cf_arg_0->arg1 = arg1; cf_arg_0->arg2 = arg2; cf_arg_0->arg3 = arg3; ldv_interrupt_interrupt_instance_0((void *)cf_arg_0); } } else { { tmp___0 = ldv_xmalloc(40UL); cf_arg_1 = (struct ldv_struct_interrupt_instance_0 *)tmp___0; cf_arg_1->arg0 = arg0; cf_arg_1->arg1 = arg1; cf_arg_1->arg2 = arg2; cf_arg_1->arg3 = arg3; ldv_interrupt_interrupt_instance_1((void *)cf_arg_1); } } return; } } void ldv_dispatch_register_29_2(struct Scsi_Host *arg0 ) { struct ldv_struct_scsi_host_template_instance_3 *cf_arg_3 ; void *tmp ; { { tmp = ldv_xmalloc(16UL); cf_arg_3 = (struct ldv_struct_scsi_host_template_instance_3 *)tmp; cf_arg_3->arg0 = arg0; ldv_scsi_host_template_scsi_host_template_instance_3((void *)cf_arg_3); } return; } } void ldv_dispatch_register_33_2(struct pci_driver *arg0 ) { struct ldv_struct_pci_instance_2 *cf_arg_2 ; void *tmp ; { { tmp = ldv_xmalloc(16UL); cf_arg_2 = (struct ldv_struct_pci_instance_2 *)tmp; cf_arg_2->arg0 = arg0; ldv_pci_pci_instance_2((void *)cf_arg_2); } return; } } void ldv_dispatch_register_dummy_factory_16_34_8(void) { struct ldv_struct_EMGentry_34 *cf_arg_24 ; void *tmp ; { { tmp = ldv_xmalloc(4UL); cf_arg_24 = (struct ldv_struct_EMGentry_34 *)tmp; ldv_timer_dummy_factory_24((void *)cf_arg_24); } return; } } void ldv_dispatch_register_dummy_resourceless_instance_12_34_9(void) { struct ldv_struct_EMGentry_34 *cf_arg_4 ; struct ldv_struct_EMGentry_34 *cf_arg_5 ; struct ldv_struct_EMGentry_34 *cf_arg_6 ; struct ldv_struct_EMGentry_34 *cf_arg_7 ; struct ldv_struct_EMGentry_34 *cf_arg_8 ; struct ldv_struct_EMGentry_34 *cf_arg_9 ; struct ldv_struct_EMGentry_34 *cf_arg_10 ; struct ldv_struct_EMGentry_34 *cf_arg_11 ; struct ldv_struct_EMGentry_34 *cf_arg_12 ; struct ldv_struct_EMGentry_34 *cf_arg_13 ; struct ldv_struct_EMGentry_34 *cf_arg_14 ; struct ldv_struct_EMGentry_34 *cf_arg_15 ; struct ldv_struct_EMGentry_34 *cf_arg_16 ; struct ldv_struct_EMGentry_34 *cf_arg_17 ; struct ldv_struct_EMGentry_34 *cf_arg_18 ; struct ldv_struct_EMGentry_34 *cf_arg_19 ; void *tmp ; void *tmp___0 ; void *tmp___1 ; void *tmp___2 ; void *tmp___3 ; void *tmp___4 ; void *tmp___5 ; void *tmp___6 ; void *tmp___7 ; void *tmp___8 ; void *tmp___9 ; void *tmp___10 ; void *tmp___11 ; void *tmp___12 ; void *tmp___13 ; void *tmp___14 ; { { tmp = ldv_xmalloc(4UL); cf_arg_4 = (struct ldv_struct_EMGentry_34 *)tmp; ldv_struct_device_attribute_dummy_resourceless_instance_4((void *)cf_arg_4); tmp___0 = ldv_xmalloc(4UL); cf_arg_5 = (struct ldv_struct_EMGentry_34 *)tmp___0; ldv_struct_device_attribute_dummy_resourceless_instance_5((void *)cf_arg_5); tmp___1 = ldv_xmalloc(4UL); cf_arg_6 = (struct ldv_struct_EMGentry_34 *)tmp___1; ldv_struct_device_attribute_dummy_resourceless_instance_6((void *)cf_arg_6); tmp___2 = ldv_xmalloc(4UL); cf_arg_7 = (struct ldv_struct_EMGentry_34 *)tmp___2; ldv_struct_device_attribute_dummy_resourceless_instance_7((void *)cf_arg_7); tmp___3 = ldv_xmalloc(4UL); cf_arg_8 = (struct ldv_struct_EMGentry_34 *)tmp___3; ldv_struct_device_attribute_dummy_resourceless_instance_8((void *)cf_arg_8); tmp___4 = ldv_xmalloc(4UL); cf_arg_9 = (struct ldv_struct_EMGentry_34 *)tmp___4; ldv_struct_device_attribute_dummy_resourceless_instance_9((void *)cf_arg_9); tmp___5 = ldv_xmalloc(4UL); cf_arg_10 = (struct ldv_struct_EMGentry_34 *)tmp___5; ldv_struct_device_attribute_dummy_resourceless_instance_10((void *)cf_arg_10); tmp___6 = ldv_xmalloc(4UL); cf_arg_11 = (struct ldv_struct_EMGentry_34 *)tmp___6; ldv_struct_device_attribute_dummy_resourceless_instance_11((void *)cf_arg_11); tmp___7 = ldv_xmalloc(4UL); cf_arg_12 = (struct ldv_struct_EMGentry_34 *)tmp___7; ldv_struct_device_attribute_dummy_resourceless_instance_12((void *)cf_arg_12); tmp___8 = ldv_xmalloc(4UL); cf_arg_13 = (struct ldv_struct_EMGentry_34 *)tmp___8; ldv_struct_device_attribute_dummy_resourceless_instance_13((void *)cf_arg_13); tmp___9 = ldv_xmalloc(4UL); cf_arg_14 = (struct ldv_struct_EMGentry_34 *)tmp___9; ldv_struct_device_attribute_dummy_resourceless_instance_14((void *)cf_arg_14); tmp___10 = ldv_xmalloc(4UL); cf_arg_15 = (struct ldv_struct_EMGentry_34 *)tmp___10; ldv_struct_device_attribute_dummy_resourceless_instance_15((void *)cf_arg_15); tmp___11 = ldv_xmalloc(4UL); cf_arg_16 = (struct ldv_struct_EMGentry_34 *)tmp___11; ldv_struct_device_attribute_dummy_resourceless_instance_16((void *)cf_arg_16); tmp___12 = ldv_xmalloc(4UL); cf_arg_17 = (struct ldv_struct_EMGentry_34 *)tmp___12; ldv_struct_device_attribute_dummy_resourceless_instance_17((void *)cf_arg_17); tmp___13 = ldv_xmalloc(4UL); cf_arg_18 = (struct ldv_struct_EMGentry_34 *)tmp___13; ldv_struct_device_attribute_dummy_resourceless_instance_18((void *)cf_arg_18); tmp___14 = ldv_xmalloc(4UL); cf_arg_19 = (struct ldv_struct_EMGentry_34 *)tmp___14; ldv_struct_device_attribute_dummy_resourceless_instance_19((void *)cf_arg_19); } return; } } void ldv_dispatch_register_dummy_resourceless_instance_13_34_10(void) { struct ldv_struct_EMGentry_34 *cf_arg_20 ; struct ldv_struct_EMGentry_34 *cf_arg_21 ; void *tmp ; void *tmp___0 ; { { tmp = ldv_xmalloc(4UL); cf_arg_20 = (struct ldv_struct_EMGentry_34 *)tmp; ldv_struct_pm8001_dispatch_dummy_resourceless_instance_20((void *)cf_arg_20); tmp___0 = ldv_xmalloc(4UL); cf_arg_21 = (struct ldv_struct_EMGentry_34 *)tmp___0; ldv_struct_pm8001_dispatch_dummy_resourceless_instance_21((void *)cf_arg_21); } return; } } void ldv_dispatch_register_dummy_resourceless_instance_14_34_11(void) { struct ldv_struct_EMGentry_34 *cf_arg_22 ; void *tmp ; { { tmp = ldv_xmalloc(4UL); cf_arg_22 = (struct ldv_struct_EMGentry_34 *)tmp; ldv_struct_sas_domain_function_template_dummy_resourceless_instance_22((void *)cf_arg_22); } return; } } void ldv_dummy_resourceless_instance_callback_10_9(long (*arg0)(struct device * , struct device_attribute * , char * , unsigned long ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 , unsigned long arg4 ) { { { (*arg0)(arg1, arg2, arg3, arg4); } return; } } void ldv_dummy_resourceless_instance_callback_11_9(long (*arg0)(struct device * , struct device_attribute * , char * , unsigned long ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 , unsigned long arg4 ) { { { (*arg0)(arg1, arg2, arg3, arg4); } return; } } void ldv_dummy_resourceless_instance_callback_12_9(long (*arg0)(struct device * , struct device_attribute * , char * , unsigned long ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 , unsigned long arg4 ) { { { (*arg0)(arg1, arg2, arg3, arg4); } return; } } void ldv_dummy_resourceless_instance_callback_14_9(long (*arg0)(struct device * , struct device_attribute * , char * , unsigned long ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 , unsigned long arg4 ) { { { (*arg0)(arg1, arg2, arg3, arg4); } return; } } void ldv_dummy_resourceless_instance_callback_15_9(long (*arg0)(struct device * , struct device_attribute * , char * , unsigned long ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 , unsigned long arg4 ) { { { (*arg0)(arg1, arg2, arg3, arg4); } return; } } void ldv_dummy_resourceless_instance_callback_16_9(long (*arg0)(struct device * , struct device_attribute * , char * , unsigned long ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 , unsigned long arg4 ) { { { (*arg0)(arg1, arg2, arg3, arg4); } return; } } void ldv_dummy_resourceless_instance_callback_17_9(long (*arg0)(struct device * , struct device_attribute * , char * , unsigned long ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 , unsigned long arg4 ) { { { (*arg0)(arg1, arg2, arg3, arg4); } return; } } void ldv_dummy_resourceless_instance_callback_18_9(long (*arg0)(struct device * , struct device_attribute * , char * , unsigned long ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 , unsigned long arg4 ) { { { (*arg0)(arg1, arg2, arg3, arg4); } return; } } void ldv_dummy_resourceless_instance_callback_22_11(int (*arg0)(struct domain_device * , unsigned char * ) , struct domain_device *arg1 , unsigned char *arg2 ) { { { pm8001_clear_aca(arg1, arg2); } return; } } void ldv_dummy_resourceless_instance_callback_22_14(int (*arg0)(struct domain_device * , unsigned char * ) , struct domain_device *arg1 , unsigned char *arg2 ) { { { pm8001_clear_task_set(arg1, arg2); } return; } } void ldv_dummy_resourceless_instance_callback_22_17(int (*arg0)(struct asd_sas_phy * , enum phy_func , void * ) , struct asd_sas_phy *arg1 , enum phy_func arg2 , void *arg3 ) { { { pm8001_phy_control(arg1, arg2, arg3); } return; } } void ldv_dummy_resourceless_instance_callback_22_18(int (*arg0)(struct domain_device * ) , struct domain_device *arg1 ) { { { pm8001_dev_found(arg1); } return; } } void ldv_dummy_resourceless_instance_callback_22_19(void (*arg0)(struct domain_device * ) , struct domain_device *arg1 ) { { { pm8001_dev_gone(arg1); } return; } } void ldv_dummy_resourceless_instance_callback_22_20(int (*arg0)(struct sas_task * , unsigned int ) , struct sas_task *arg1 , unsigned int arg2 ) { { { pm8001_queue_command(arg1, arg2); } return; } } void ldv_dummy_resourceless_instance_callback_22_23(int (*arg0)(struct domain_device * , unsigned char * ) , struct domain_device *arg1 , unsigned char *arg2 ) { { { pm8001_lu_reset(arg1, arg2); } return; } } void ldv_dummy_resourceless_instance_callback_22_26(int (*arg0)(struct sas_task * ) , struct sas_task *arg1 ) { { { pm8001_query_task(arg1); } return; } } void ldv_dummy_resourceless_instance_callback_22_3(int (*arg0)(struct domain_device * ) , struct domain_device *arg1 ) { { { pm8001_I_T_nexus_reset(arg1); } return; } } void ldv_dummy_resourceless_instance_callback_22_7(int (*arg0)(struct sas_task * ) , struct sas_task *arg1 ) { { { pm8001_abort_task(arg1); } return; } } void ldv_dummy_resourceless_instance_callback_22_8(int (*arg0)(struct domain_device * , unsigned char * ) , struct domain_device *arg1 , unsigned char *arg2 ) { { { pm8001_abort_task_set(arg1, arg2); } return; } } void ldv_dummy_resourceless_instance_callback_4_9(long (*arg0)(struct device * , struct device_attribute * , char * , unsigned long ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 , unsigned long arg4 ) { { { (*arg0)(arg1, arg2, arg3, arg4); } return; } } void ldv_dummy_resourceless_instance_callback_5_9(long (*arg0)(struct device * , struct device_attribute * , char * , unsigned long ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 , unsigned long arg4 ) { { { (*arg0)(arg1, arg2, arg3, arg4); } return; } } void ldv_dummy_resourceless_instance_callback_6_9(long (*arg0)(struct device * , struct device_attribute * , char * , unsigned long ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 , unsigned long arg4 ) { { { (*arg0)(arg1, arg2, arg3, arg4); } return; } } void ldv_dummy_resourceless_instance_callback_7_9(long (*arg0)(struct device * , struct device_attribute * , char * , unsigned long ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 , unsigned long arg4 ) { { { (*arg0)(arg1, arg2, arg3, arg4); } return; } } void ldv_dummy_resourceless_instance_callback_8_9(long (*arg0)(struct device * , struct device_attribute * , char * , unsigned long ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 , unsigned long arg4 ) { { { (*arg0)(arg1, arg2, arg3, arg4); } return; } } void ldv_dummy_resourceless_instance_callback_9_9(long (*arg0)(struct device * , struct device_attribute * , char * , unsigned long ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 , unsigned long arg4 ) { { { (*arg0)(arg1, arg2, arg3, arg4); } return; } } void ldv_entry_EMGentry_34(void *arg0 ) { void (*ldv_34_exit_pm8001_exit_default)(void) ; int (*ldv_34_init_pm8001_init_default)(void) ; int ldv_34_ret_default ; int tmp ; int tmp___0 ; { { ldv_34_ret_default = ldv_EMGentry_init_pm8001_init_34_15(ldv_34_init_pm8001_init_default); ldv_34_ret_default = ldv_ldv_post_init_118(ldv_34_ret_default); tmp___0 = ldv_undef_int(); } if (tmp___0 != 0) { { ldv_assume(ldv_34_ret_default != 0); ldv_ldv_check_final_state_119(); ldv_stop(); } return; } else { { ldv_assume(ldv_34_ret_default == 0); tmp = ldv_undef_int(); } if (tmp != 0) { { ldv_dispatch_register_dummy_resourceless_instance_14_34_11(); ldv_dispatch_register_dummy_resourceless_instance_13_34_10(); ldv_dispatch_register_dummy_resourceless_instance_12_34_9(); ldv_dispatch_register_dummy_factory_16_34_8(); ldv_dispatch_deregister_dummy_resourceless_instance_14_34_7(); ldv_dispatch_deregister_dummy_resourceless_instance_13_34_6(); ldv_dispatch_deregister_dummy_resourceless_instance_12_34_5(); ldv_dispatch_deregister_dummy_factory_16_34_4(); } } else { } { ldv_EMGentry_exit_pm8001_exit_34_2(ldv_34_exit_pm8001_exit_default); ldv_ldv_check_final_state_120(); ldv_stop(); } return; } return; } } int main(void) { { { ldv_ldv_initialize_121(); ldv_entry_EMGentry_34((void *)0); } return 0; } } void ldv_free_irq(void *arg0 , int arg1 , void *arg2 ) { int ldv_26_line_line ; { { ldv_26_line_line = arg1; ldv_dispatch_irq_deregister_26_1(ldv_26_line_line); } return; return; } } enum irqreturn ldv_interrupt_instance_handler_0_5(enum irqreturn (*arg0)(int , void * ) , int arg1 , void *arg2 ) { irqreturn_t tmp ; { { tmp = pm8001_interrupt_handler_intx(arg1, arg2); } return (tmp); } } enum irqreturn ldv_interrupt_instance_handler_1_5(enum irqreturn (*arg0)(int , void * ) , int arg1 , void *arg2 ) { irqreturn_t tmp ; { { tmp = pm8001_interrupt_handler_msix(arg1, arg2); } return (tmp); } } void ldv_interrupt_instance_thread_0_3(enum irqreturn (*arg0)(int , void * ) , int arg1 , void *arg2 ) { { { (*arg0)(arg1, arg2); } return; } } void ldv_interrupt_instance_thread_1_3(enum irqreturn (*arg0)(int , void * ) , int arg1 , void *arg2 ) { { { (*arg0)(arg1, arg2); } return; } } void ldv_interrupt_interrupt_instance_0(void *arg0 ) { enum irqreturn (*ldv_0_callback_handler)(int , void * ) ; void *ldv_0_data_data ; int ldv_0_line_line ; enum irqreturn ldv_0_ret_val_default ; enum irqreturn (*ldv_0_thread_thread)(int , void * ) ; struct ldv_struct_interrupt_instance_0 *data ; int tmp ; { data = (struct ldv_struct_interrupt_instance_0 *)arg0; if ((unsigned long )data != (unsigned long )((struct ldv_struct_interrupt_instance_0 *)0)) { { ldv_0_line_line = data->arg0; ldv_0_callback_handler = data->arg1; ldv_0_thread_thread = data->arg2; ldv_0_data_data = data->arg3; ldv_free((void *)data); } } else { } { ldv_switch_to_interrupt_context(); ldv_0_ret_val_default = ldv_interrupt_instance_handler_0_5(ldv_0_callback_handler, ldv_0_line_line, ldv_0_data_data); ldv_switch_to_process_context(); tmp = ldv_undef_int(); } if (tmp != 0) { { ldv_assume((unsigned int )ldv_0_ret_val_default == 2U); } if ((unsigned long )ldv_0_thread_thread != (unsigned long )((enum irqreturn (*)(int , void * ))0)) { { ldv_interrupt_instance_thread_0_3(ldv_0_thread_thread, ldv_0_line_line, ldv_0_data_data); } } else { } } else { { ldv_assume((unsigned int )ldv_0_ret_val_default != 2U); } } return; return; } } void ldv_interrupt_interrupt_instance_1(void *arg0 ) { enum irqreturn (*ldv_1_callback_handler)(int , void * ) ; void *ldv_1_data_data ; int ldv_1_line_line ; enum irqreturn ldv_1_ret_val_default ; enum irqreturn (*ldv_1_thread_thread)(int , void * ) ; struct ldv_struct_interrupt_instance_0 *data ; int tmp ; { data = (struct ldv_struct_interrupt_instance_0 *)arg0; if ((unsigned long )data != (unsigned long )((struct ldv_struct_interrupt_instance_0 *)0)) { { ldv_1_line_line = data->arg0; ldv_1_callback_handler = data->arg1; ldv_1_thread_thread = data->arg2; ldv_1_data_data = data->arg3; ldv_free((void *)data); } } else { } { ldv_switch_to_interrupt_context(); ldv_1_ret_val_default = ldv_interrupt_instance_handler_1_5(ldv_1_callback_handler, ldv_1_line_line, ldv_1_data_data); ldv_switch_to_process_context(); tmp = ldv_undef_int(); } if (tmp != 0) { { ldv_assume((unsigned int )ldv_1_ret_val_default == 2U); } if ((unsigned long )ldv_1_thread_thread != (unsigned long )((enum irqreturn (*)(int , void * ))0)) { { ldv_interrupt_instance_thread_1_3(ldv_1_thread_thread, ldv_1_line_line, ldv_1_data_data); } } else { } } else { { ldv_assume((unsigned int )ldv_1_ret_val_default != 2U); } } return; return; } } int ldv_pci_instance_probe_2_17(int (*arg0)(struct pci_dev * , struct pci_device_id * ) , struct pci_dev *arg1 , struct pci_device_id *arg2 ) { int tmp ; { { tmp = pm8001_pci_probe(arg1, (struct pci_device_id const *)arg2); } return (tmp); } } void ldv_pci_instance_release_2_2(void (*arg0)(struct pci_dev * ) , struct pci_dev *arg1 ) { { { pm8001_pci_remove(arg1); } return; } } void ldv_pci_instance_resume_2_5(int (*arg0)(struct pci_dev * ) , struct pci_dev *arg1 ) { { { pm8001_pci_resume(arg1); } return; } } void ldv_pci_instance_resume_early_2_6(int (*arg0)(struct pci_dev * ) , struct pci_dev *arg1 ) { { { (*arg0)(arg1); } return; } } void ldv_pci_instance_shutdown_2_3(void (*arg0)(struct pci_dev * ) , struct pci_dev *arg1 ) { { { (*arg0)(arg1); } return; } } int ldv_pci_instance_suspend_2_8(int (*arg0)(struct pci_dev * , struct pm_message ) , struct pci_dev *arg1 , struct pm_message arg2 ) { int tmp ; { { tmp = pm8001_pci_suspend(arg1, arg2); } return (tmp); } } int ldv_pci_instance_suspend_late_2_7(int (*arg0)(struct pci_dev * , struct pm_message ) , struct pci_dev *arg1 , struct pm_message arg2 ) { int tmp ; { { tmp = (*arg0)(arg1, arg2); } return (tmp); } } void ldv_pci_pci_instance_2(void *arg0 ) { struct pci_driver *ldv_2_container_pci_driver ; struct pci_dev *ldv_2_resource_dev ; struct pm_message ldv_2_resource_pm_message ; struct pci_device_id *ldv_2_resource_struct_pci_device_id_ptr ; int ldv_2_ret_default ; struct ldv_struct_pci_instance_2 *data ; void *tmp ; void *tmp___0 ; int tmp___1 ; int tmp___2 ; int tmp___3 ; { data = (struct ldv_struct_pci_instance_2 *)arg0; ldv_2_ret_default = 1; if ((unsigned long )data != (unsigned long )((struct ldv_struct_pci_instance_2 *)0)) { { ldv_2_container_pci_driver = data->arg0; ldv_free((void *)data); } } else { } { tmp = ldv_xmalloc(2968UL); ldv_2_resource_dev = (struct pci_dev *)tmp; tmp___0 = ldv_xmalloc(32UL); ldv_2_resource_struct_pci_device_id_ptr = (struct pci_device_id *)tmp___0; } goto ldv_main_2; return; ldv_main_2: { tmp___2 = ldv_undef_int(); } if (tmp___2 != 0) { { ldv_ldv_pre_probe_122(); ldv_2_ret_default = ldv_pci_instance_probe_2_17((int (*)(struct pci_dev * , struct pci_device_id * ))ldv_2_container_pci_driver->probe, ldv_2_resource_dev, ldv_2_resource_struct_pci_device_id_ptr); ldv_2_ret_default = ldv_ldv_post_probe_123(ldv_2_ret_default); tmp___1 = ldv_undef_int(); } if (tmp___1 != 0) { { ldv_assume(ldv_2_ret_default == 0); } goto ldv_call_2; } else { { ldv_assume(ldv_2_ret_default != 0); } goto ldv_main_2; } } else { { ldv_free((void *)ldv_2_resource_dev); ldv_free((void *)ldv_2_resource_struct_pci_device_id_ptr); } return; } return; ldv_call_2: { tmp___3 = ldv_undef_int(); } { if (tmp___3 == 1) { goto case_1; } else { } if (tmp___3 == 2) { goto case_2; } else { } if (tmp___3 == 3) { goto case_3; } else { } goto switch_default; case_1: /* CIL Label */ ; goto ldv_call_2; case_2: /* CIL Label */ { ldv_2_ret_default = ldv_pci_instance_suspend_2_8(ldv_2_container_pci_driver->suspend, ldv_2_resource_dev, ldv_2_resource_pm_message); ldv_2_ret_default = ldv_filter_err_code(ldv_2_ret_default); } if ((unsigned long )ldv_2_container_pci_driver->suspend_late != (unsigned long )((int (*)(struct pci_dev * , pm_message_t ))0)) { { ldv_2_ret_default = ldv_pci_instance_suspend_late_2_7(ldv_2_container_pci_driver->suspend_late, ldv_2_resource_dev, ldv_2_resource_pm_message); } } else { } { ldv_2_ret_default = ldv_filter_err_code(ldv_2_ret_default); } if ((unsigned long )ldv_2_container_pci_driver->resume_early != (unsigned long )((int (*)(struct pci_dev * ))0)) { { ldv_pci_instance_resume_early_2_6(ldv_2_container_pci_driver->resume_early, ldv_2_resource_dev); } } else { } { ldv_pci_instance_resume_2_5(ldv_2_container_pci_driver->resume, ldv_2_resource_dev); } goto ldv_call_2; case_3: /* CIL Label */ ; if ((unsigned long )ldv_2_container_pci_driver->shutdown != (unsigned long )((void (*)(struct pci_dev * ))0)) { { ldv_pci_instance_shutdown_2_3(ldv_2_container_pci_driver->shutdown, ldv_2_resource_dev); } } else { } { ldv_pci_instance_release_2_2(ldv_2_container_pci_driver->remove, ldv_2_resource_dev); } goto ldv_main_2; switch_default: /* CIL Label */ { ldv_stop(); } switch_break: /* CIL Label */ ; } return; } } void ldv_pci_unregister_driver(void *arg0 , struct pci_driver *arg1 ) { struct pci_driver *ldv_32_pci_driver_pci_driver ; { { ldv_32_pci_driver_pci_driver = arg1; ldv_dispatch_deregister_32_1(ldv_32_pci_driver_pci_driver); } return; return; } } int ldv_request_irq(int arg0 , unsigned int arg1 , enum irqreturn (*arg2)(int , void * ) , unsigned long arg3 , char *arg4 , void *arg5 ) { enum irqreturn (*ldv_28_callback_handler)(int , void * ) ; void *ldv_28_data_data ; int ldv_28_line_line ; enum irqreturn (*ldv_28_thread_thread)(int , void * ) ; int tmp ; { { tmp = ldv_undef_int(); } if (tmp != 0) { { ldv_assume(arg0 == 0); ldv_28_line_line = (int )arg1; ldv_28_callback_handler = arg2; ldv_28_thread_thread = (enum irqreturn (*)(int , void * ))0; ldv_28_data_data = arg5; ldv_dispatch_irq_register_28_2(ldv_28_line_line, ldv_28_callback_handler, ldv_28_thread_thread, ldv_28_data_data); } return (arg0); } else { { ldv_assume(arg0 != 0); } return (arg0); } return (arg0); } } int ldv_scsi_add_host(int arg0 , struct Scsi_Host *arg1 , struct device *arg2 ) { struct Scsi_Host *ldv_29_host_host ; int tmp ; { { tmp = ldv_undef_int(); } if (tmp != 0) { { ldv_assume(arg0 == 0); ldv_dispatch_register_29_2(ldv_29_host_host); } return (arg0); } else { { ldv_assume(arg0 != 0); } return (arg0); } return (arg0); } } struct Scsi_Host *ldv_scsi_host_alloc(struct Scsi_Host *arg0 , struct scsi_host_template *arg1 , int arg2 ) { struct Scsi_Host *ldv_30_host_host ; struct scsi_host_template *ldv_30_scsi_host_template_scsi_host_template ; void *tmp ; int tmp___0 ; { { tmp___0 = ldv_undef_int(); } if (tmp___0 != 0) { { tmp = ldv_xmalloc(3800UL); ldv_30_host_host = (struct Scsi_Host *)tmp; ldv_30_scsi_host_template_scsi_host_template = arg1; ldv_30_host_host->hostt = ldv_30_scsi_host_template_scsi_host_template; } return (ldv_30_host_host); return (arg0); } else { return ((struct Scsi_Host *)0); return (arg0); } return (arg0); } } void ldv_scsi_host_template_instance_callback_3_17(int (*arg0)(struct scsi_device * , int ) , struct scsi_device *arg1 , int arg2 ) { { { sas_change_queue_depth(arg1, arg2); } return; } } void ldv_scsi_host_template_instance_callback_3_20(int (*arg0)(struct scsi_cmnd * ) , struct scsi_cmnd *arg1 ) { { { sas_eh_bus_reset_handler(arg1); } return; } } void ldv_scsi_host_template_instance_callback_3_21(int (*arg0)(struct scsi_cmnd * ) , struct scsi_cmnd *arg1 ) { { { sas_eh_device_reset_handler(arg1); } return; } } void ldv_scsi_host_template_instance_callback_3_22(int (*arg0)(struct scsi_device * , int , void * ) , struct scsi_device *arg1 , int arg2 , void *arg3 ) { { { sas_ioctl(arg1, arg2, arg3); } return; } } void ldv_scsi_host_template_instance_callback_3_25(int (*arg0)(struct Scsi_Host * , struct scsi_cmnd * ) , struct Scsi_Host *arg1 , struct scsi_cmnd *arg2 ) { { { sas_queuecommand(arg1, arg2); } return; } } void ldv_scsi_host_template_instance_callback_3_26(int (*arg0)(struct Scsi_Host * , unsigned long ) , struct Scsi_Host *arg1 , unsigned long arg2 ) { { { pm8001_scan_finished(arg1, arg2); } return; } } void ldv_scsi_host_template_instance_callback_3_29(void (*arg0)(struct Scsi_Host * ) , struct Scsi_Host *arg1 ) { { { pm8001_scan_start(arg1); } return; } } void ldv_scsi_host_template_instance_callback_3_30(int (*arg0)(struct scsi_device * ) , struct scsi_device *arg1 ) { { { sas_slave_configure(arg1); } return; } } void ldv_scsi_host_template_instance_callback_3_31(int (*arg0)(struct scsi_target * ) , struct scsi_target *arg1 ) { { { sas_target_alloc(arg1); } return; } } void ldv_scsi_host_template_instance_callback_3_32(void (*arg0)(struct scsi_target * ) , struct scsi_target *arg1 ) { { { sas_target_destroy(arg1); } return; } } void ldv_scsi_host_template_instance_callback_3_4(int (*arg0)(struct scsi_device * , struct block_device * , unsigned long , int * ) , struct scsi_device *arg1 , struct block_device *arg2 , unsigned long arg3 , int *arg4 ) { { { sas_bios_param(arg1, arg2, arg3, arg4); } return; } } int ldv_scsi_host_template_instance_probe_3_10(int (*arg0)(struct Scsi_Host * ) , struct Scsi_Host *arg1 ) { int tmp ; { { tmp = (*arg0)(arg1); } return (tmp); } } void ldv_scsi_host_template_instance_release_3_2(int (*arg0)(struct Scsi_Host * ) , struct Scsi_Host *arg1 ) { { { (*arg0)(arg1); } return; } } void ldv_scsi_host_template_scsi_host_template_instance_3(void *arg0 ) { int (*ldv_3_callback_bios_param)(struct scsi_device * , struct block_device * , unsigned long , int * ) ; int (*ldv_3_callback_change_queue_depth)(struct scsi_device * , int ) ; int (*ldv_3_callback_eh_bus_reset_handler)(struct scsi_cmnd * ) ; int (*ldv_3_callback_eh_device_reset_handler)(struct scsi_cmnd * ) ; int (*ldv_3_callback_ioctl)(struct scsi_device * , int , void * ) ; int (*ldv_3_callback_queuecommand)(struct Scsi_Host * , struct scsi_cmnd * ) ; int (*ldv_3_callback_scan_finished)(struct Scsi_Host * , unsigned long ) ; void (*ldv_3_callback_scan_start)(struct Scsi_Host * ) ; int (*ldv_3_callback_slave_configure)(struct scsi_device * ) ; int (*ldv_3_callback_target_alloc)(struct scsi_target * ) ; void (*ldv_3_callback_target_destroy)(struct scsi_target * ) ; struct Scsi_Host *ldv_3_host_host ; struct scsi_cmnd *ldv_3_host_struct_scsi_cmnd_ptr ; struct scsi_device *ldv_3_host_struct_scsi_device_ptr ; struct scsi_target *ldv_3_host_struct_scsi_target_ptr ; int ldv_3_ldv_param_17_1_default ; int ldv_3_ldv_param_22_1_default ; unsigned long ldv_3_ldv_param_26_1_default ; struct block_device *ldv_3_ldv_param_4_1_default ; unsigned long ldv_3_ldv_param_4_2_default ; int *ldv_3_ldv_param_4_3_default ; int ldv_3_ret_default ; struct ldv_struct_scsi_host_template_instance_3 *data ; int tmp ; int tmp___0 ; void *tmp___1 ; void *tmp___2 ; int tmp___3 ; int tmp___4 ; { data = (struct ldv_struct_scsi_host_template_instance_3 *)arg0; ldv_3_ret_default = 1; if ((unsigned long )data != (unsigned long )((struct ldv_struct_scsi_host_template_instance_3 *)0)) { { ldv_3_host_host = data->arg0; ldv_free((void *)data); } } else { } goto ldv_main_3; return; ldv_main_3: { tmp___0 = ldv_undef_int(); } if (tmp___0 != 0) { { ldv_ldv_pre_probe_124(); } if ((unsigned long )(ldv_3_host_host->hostt)->detect != (unsigned long )((int (*)(struct scsi_host_template * ))0)) { { ldv_3_ret_default = ldv_scsi_host_template_instance_probe_3_10((int (*)(struct Scsi_Host * ))(ldv_3_host_host->hostt)->detect, ldv_3_host_host); } } else { } { ldv_3_ret_default = ldv_ldv_post_probe_125(ldv_3_ret_default); tmp = ldv_undef_int(); } if (tmp != 0) { { ldv_assume(ldv_3_ret_default == 0); } goto ldv_call_3; } else { { ldv_assume(ldv_3_ret_default != 0); } goto ldv_main_3; } } else { return; } return; ldv_call_3: { tmp___4 = ldv_undef_int(); } if (tmp___4 != 0) { if ((unsigned long )(ldv_3_host_host->hostt)->release != (unsigned long )((int (*)(struct Scsi_Host * ))0)) { { ldv_scsi_host_template_instance_release_3_2((ldv_3_host_host->hostt)->release, ldv_3_host_host); } } else { } goto ldv_main_3; } else { { tmp___1 = ldv_xmalloc(480UL); ldv_3_ldv_param_4_1_default = (struct block_device *)tmp___1; tmp___2 = ldv_xmalloc(4UL); ldv_3_ldv_param_4_3_default = (int *)tmp___2; tmp___3 = ldv_undef_int(); } { if (tmp___3 == 1) { goto case_1; } else { } if (tmp___3 == 2) { goto case_2; } else { } if (tmp___3 == 3) { goto case_3; } else { } if (tmp___3 == 4) { goto case_4; } else { } if (tmp___3 == 5) { goto case_5; } else { } if (tmp___3 == 6) { goto case_6; } else { } if (tmp___3 == 7) { goto case_7; } else { } if (tmp___3 == 8) { goto case_8; } else { } if (tmp___3 == 9) { goto case_9; } else { } if (tmp___3 == 10) { goto case_10; } else { } if (tmp___3 == 11) { goto case_11; } else { } goto switch_default; case_1: /* CIL Label */ { ldv_scsi_host_template_instance_callback_3_32(ldv_3_callback_target_destroy, ldv_3_host_struct_scsi_target_ptr); } goto ldv_47552; case_2: /* CIL Label */ { ldv_scsi_host_template_instance_callback_3_31(ldv_3_callback_target_alloc, ldv_3_host_struct_scsi_target_ptr); } goto ldv_47552; case_3: /* CIL Label */ { ldv_scsi_host_template_instance_callback_3_30(ldv_3_callback_slave_configure, ldv_3_host_struct_scsi_device_ptr); } goto ldv_47552; case_4: /* CIL Label */ { ldv_scsi_host_template_instance_callback_3_29(ldv_3_callback_scan_start, ldv_3_host_host); } goto ldv_47552; case_5: /* CIL Label */ { ldv_scsi_host_template_instance_callback_3_26(ldv_3_callback_scan_finished, ldv_3_host_host, ldv_3_ldv_param_26_1_default); } goto ldv_47552; case_6: /* CIL Label */ { ldv_scsi_host_template_instance_callback_3_25(ldv_3_callback_queuecommand, ldv_3_host_host, ldv_3_host_struct_scsi_cmnd_ptr); } goto ldv_47552; case_7: /* CIL Label */ { ldv_scsi_host_template_instance_callback_3_22(ldv_3_callback_ioctl, ldv_3_host_struct_scsi_device_ptr, ldv_3_ldv_param_22_1_default, (void *)ldv_3_host_struct_scsi_cmnd_ptr); } goto ldv_47552; case_8: /* CIL Label */ { ldv_scsi_host_template_instance_callback_3_21(ldv_3_callback_eh_device_reset_handler, ldv_3_host_struct_scsi_cmnd_ptr); } goto ldv_47552; case_9: /* CIL Label */ { ldv_scsi_host_template_instance_callback_3_20(ldv_3_callback_eh_bus_reset_handler, ldv_3_host_struct_scsi_cmnd_ptr); } goto ldv_47552; case_10: /* CIL Label */ { ldv_scsi_host_template_instance_callback_3_17(ldv_3_callback_change_queue_depth, ldv_3_host_struct_scsi_device_ptr, ldv_3_ldv_param_17_1_default); } goto ldv_47552; case_11: /* CIL Label */ { ldv_scsi_host_template_instance_callback_3_4(ldv_3_callback_bios_param, ldv_3_host_struct_scsi_device_ptr, ldv_3_ldv_param_4_1_default, ldv_3_ldv_param_4_2_default, ldv_3_ldv_param_4_3_default); } goto ldv_47552; switch_default: /* CIL Label */ { ldv_stop(); } switch_break: /* CIL Label */ ; } ldv_47552: ; } { ldv_free((void *)ldv_3_ldv_param_4_1_default); ldv_free((void *)ldv_3_ldv_param_4_3_default); } goto ldv_call_3; return; } } void ldv_scsi_remove_host(void *arg0 , struct Scsi_Host *arg1 ) { struct Scsi_Host *ldv_31_host_host ; { { ldv_31_host_host = arg1; ldv_dispatch_deregister_31_1(ldv_31_host_host); } return; return; } } void ldv_struct_pm8001_dispatch_dummy_resourceless_instance_20(void *arg0 ) { int (*ldv_20_callback_chip_init)(struct pm8001_hba_info * ) ; void (*ldv_20_callback_chip_iounmap)(struct pm8001_hba_info * ) ; void (*ldv_20_callback_chip_rst)(struct pm8001_hba_info * ) ; int (*ldv_20_callback_chip_soft_rst)(struct pm8001_hba_info * ) ; int (*ldv_20_callback_dereg_dev_req)(struct pm8001_hba_info * , unsigned int ) ; int (*ldv_20_callback_fw_flash_update_req)(struct pm8001_hba_info * , void * ) ; int (*ldv_20_callback_get_nvmd_req)(struct pm8001_hba_info * , void * ) ; void (*ldv_20_callback_interrupt_disable)(struct pm8001_hba_info * , unsigned char ) ; void (*ldv_20_callback_interrupt_enable)(struct pm8001_hba_info * , unsigned char ) ; unsigned int (*ldv_20_callback_is_our_interupt)(struct pm8001_hba_info * ) ; enum irqreturn (*ldv_20_callback_isr)(struct pm8001_hba_info * , unsigned char ) ; int (*ldv_20_callback_isr_process_oq)(struct pm8001_hba_info * , unsigned char ) ; void (*ldv_20_callback_make_prd)(struct scatterlist * , int , void * ) ; int (*ldv_20_callback_phy_ctl_req)(struct pm8001_hba_info * , unsigned int , unsigned int ) ; int (*ldv_20_callback_phy_start_req)(struct pm8001_hba_info * , unsigned char ) ; int (*ldv_20_callback_phy_stop_req)(struct pm8001_hba_info * , unsigned char ) ; int (*ldv_20_callback_reg_dev_req)(struct pm8001_hba_info * , struct pm8001_device * , unsigned int ) ; int (*ldv_20_callback_sas_re_init_req)(struct pm8001_hba_info * ) ; int (*ldv_20_callback_sata_req)(struct pm8001_hba_info * , struct pm8001_ccb_info * ) ; int (*ldv_20_callback_set_dev_state_req)(struct pm8001_hba_info * , struct pm8001_device * , unsigned int ) ; int (*ldv_20_callback_set_nvmd_req)(struct pm8001_hba_info * , void * ) ; int (*ldv_20_callback_smp_req)(struct pm8001_hba_info * , struct pm8001_ccb_info * ) ; int (*ldv_20_callback_ssp_io_req)(struct pm8001_hba_info * , struct pm8001_ccb_info * ) ; int (*ldv_20_callback_ssp_tm_req)(struct pm8001_hba_info * , struct pm8001_ccb_info * , struct pm8001_tmf_task * ) ; int (*ldv_20_callback_task_abort)(struct pm8001_hba_info * , struct pm8001_device * , unsigned char , unsigned int , unsigned int ) ; struct pm8001_ccb_info *ldv_20_container_struct_pm8001_ccb_info_ptr ; struct pm8001_device *ldv_20_container_struct_pm8001_device_ptr ; struct pm8001_hba_info *ldv_20_container_struct_pm8001_hba_info_ptr ; struct pm8001_tmf_task *ldv_20_container_struct_pm8001_tmf_task_ptr ; struct scatterlist *ldv_20_container_struct_scatterlist_ptr ; unsigned int ldv_20_ldv_param_10_1_default ; unsigned char ldv_20_ldv_param_15_1_default ; unsigned char ldv_20_ldv_param_18_1_default ; unsigned char ldv_20_ldv_param_22_1_default ; unsigned char ldv_20_ldv_param_25_1_default ; int ldv_20_ldv_param_28_1_default ; unsigned int ldv_20_ldv_param_31_1_default ; unsigned int ldv_20_ldv_param_31_2_default ; unsigned char ldv_20_ldv_param_34_1_default ; unsigned char ldv_20_ldv_param_37_1_default ; unsigned int ldv_20_ldv_param_40_2_default ; unsigned int ldv_20_ldv_param_45_2_default ; unsigned char ldv_20_ldv_param_52_2_default ; unsigned int ldv_20_ldv_param_52_3_default ; unsigned int ldv_20_ldv_param_52_4_default ; int tmp ; { goto ldv_call_20; return; ldv_call_20: { tmp = ldv_undef_int(); } { if (tmp == 1) { goto case_1; } else { } if (tmp == 2) { goto case_2; } else { } if (tmp == 3) { goto case_3; } else { } if (tmp == 4) { goto case_4; } else { } if (tmp == 5) { goto case_5; } else { } if (tmp == 6) { goto case_6; } else { } if (tmp == 7) { goto case_7; } else { } if (tmp == 8) { goto case_8; } else { } if (tmp == 9) { goto case_9; } else { } if (tmp == 10) { goto case_10; } else { } if (tmp == 11) { goto case_11; } else { } if (tmp == 12) { goto case_12; } else { } if (tmp == 13) { goto case_13; } else { } if (tmp == 14) { goto case_14; } else { } if (tmp == 15) { goto case_15; } else { } if (tmp == 16) { goto case_16; } else { } if (tmp == 17) { goto case_17; } else { } if (tmp == 18) { goto case_18; } else { } if (tmp == 19) { goto case_19; } else { } if (tmp == 20) { goto case_20; } else { } if (tmp == 21) { goto case_21; } else { } if (tmp == 22) { goto case_22; } else { } if (tmp == 23) { goto case_23; } else { } if (tmp == 24) { goto case_24; } else { } if (tmp == 25) { goto case_25; } else { } if (tmp == 26) { goto case_26; } else { } goto switch_default; case_1: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_20_52(ldv_20_callback_task_abort, ldv_20_container_struct_pm8001_hba_info_ptr, ldv_20_container_struct_pm8001_device_ptr, (int )ldv_20_ldv_param_52_2_default, ldv_20_ldv_param_52_3_default, ldv_20_ldv_param_52_4_default); } goto ldv_call_20; case_2: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_20_51(ldv_20_callback_ssp_tm_req, ldv_20_container_struct_pm8001_hba_info_ptr, ldv_20_container_struct_pm8001_ccb_info_ptr, ldv_20_container_struct_pm8001_tmf_task_ptr); } goto ldv_call_20; goto ldv_call_20; case_3: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_20_50(ldv_20_callback_ssp_io_req, ldv_20_container_struct_pm8001_hba_info_ptr, ldv_20_container_struct_pm8001_ccb_info_ptr); } goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; case_4: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_20_49(ldv_20_callback_smp_req, ldv_20_container_struct_pm8001_hba_info_ptr, ldv_20_container_struct_pm8001_ccb_info_ptr); } goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; case_5: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_20_48(ldv_20_callback_set_nvmd_req, ldv_20_container_struct_pm8001_hba_info_ptr, (void *)ldv_20_container_struct_pm8001_ccb_info_ptr); } goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; case_6: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_20_45(ldv_20_callback_set_dev_state_req, ldv_20_container_struct_pm8001_hba_info_ptr, ldv_20_container_struct_pm8001_device_ptr, ldv_20_ldv_param_45_2_default); } goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; case_7: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_20_44(ldv_20_callback_sata_req, ldv_20_container_struct_pm8001_hba_info_ptr, ldv_20_container_struct_pm8001_ccb_info_ptr); } goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; case_8: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_20_43(ldv_20_callback_sas_re_init_req, ldv_20_container_struct_pm8001_hba_info_ptr); } goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; case_9: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_20_40(ldv_20_callback_reg_dev_req, ldv_20_container_struct_pm8001_hba_info_ptr, ldv_20_container_struct_pm8001_device_ptr, ldv_20_ldv_param_40_2_default); } goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; case_10: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_20_37(ldv_20_callback_phy_stop_req, ldv_20_container_struct_pm8001_hba_info_ptr, (int )ldv_20_ldv_param_37_1_default); } goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; case_11: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_20_34(ldv_20_callback_phy_start_req, ldv_20_container_struct_pm8001_hba_info_ptr, (int )ldv_20_ldv_param_34_1_default); } goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; case_12: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_20_31(ldv_20_callback_phy_ctl_req, ldv_20_container_struct_pm8001_hba_info_ptr, ldv_20_ldv_param_31_1_default, ldv_20_ldv_param_31_2_default); } goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; case_13: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_20_28(ldv_20_callback_make_prd, ldv_20_container_struct_scatterlist_ptr, ldv_20_ldv_param_28_1_default, (void *)ldv_20_container_struct_pm8001_ccb_info_ptr); } goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; case_14: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_20_25(ldv_20_callback_isr_process_oq, ldv_20_container_struct_pm8001_hba_info_ptr, (int )ldv_20_ldv_param_25_1_default); } goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; case_15: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_20_22(ldv_20_callback_isr, ldv_20_container_struct_pm8001_hba_info_ptr, (int )ldv_20_ldv_param_22_1_default); } goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; case_16: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_20_21(ldv_20_callback_is_our_interupt, ldv_20_container_struct_pm8001_hba_info_ptr); } goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; case_17: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_20_18(ldv_20_callback_interrupt_enable, ldv_20_container_struct_pm8001_hba_info_ptr, (int )ldv_20_ldv_param_18_1_default); } goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; case_18: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_20_15(ldv_20_callback_interrupt_disable, ldv_20_container_struct_pm8001_hba_info_ptr, (int )ldv_20_ldv_param_15_1_default); } goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; case_19: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_20_14(ldv_20_callback_get_nvmd_req, ldv_20_container_struct_pm8001_hba_info_ptr, (void *)ldv_20_container_struct_pm8001_ccb_info_ptr); } goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; case_20: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_20_13(ldv_20_callback_fw_flash_update_req, ldv_20_container_struct_pm8001_hba_info_ptr, (void *)ldv_20_container_struct_pm8001_ccb_info_ptr); } goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; case_21: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_20_10(ldv_20_callback_dereg_dev_req, ldv_20_container_struct_pm8001_hba_info_ptr, ldv_20_ldv_param_10_1_default); } goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; case_22: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_20_9(ldv_20_callback_chip_soft_rst, ldv_20_container_struct_pm8001_hba_info_ptr); } goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; case_23: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_20_8(ldv_20_callback_chip_rst, ldv_20_container_struct_pm8001_hba_info_ptr); } goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; case_24: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_20_7(ldv_20_callback_chip_iounmap, ldv_20_container_struct_pm8001_hba_info_ptr); } goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; case_25: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_20_3(ldv_20_callback_chip_init, ldv_20_container_struct_pm8001_hba_info_ptr); } goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; goto ldv_call_20; case_26: /* CIL Label */ ; return; switch_default: /* CIL Label */ { ldv_stop(); } switch_break: /* CIL Label */ ; } return; } } void ldv_struct_pm8001_dispatch_dummy_resourceless_instance_21(void *arg0 ) { int (*ldv_21_callback_chip_init)(struct pm8001_hba_info * ) ; void (*ldv_21_callback_chip_iounmap)(struct pm8001_hba_info * ) ; void (*ldv_21_callback_chip_rst)(struct pm8001_hba_info * ) ; int (*ldv_21_callback_chip_soft_rst)(struct pm8001_hba_info * ) ; int (*ldv_21_callback_dereg_dev_req)(struct pm8001_hba_info * , unsigned int ) ; int (*ldv_21_callback_fw_flash_update_req)(struct pm8001_hba_info * , void * ) ; int (*ldv_21_callback_get_nvmd_req)(struct pm8001_hba_info * , void * ) ; void (*ldv_21_callback_interrupt_disable)(struct pm8001_hba_info * , unsigned char ) ; void (*ldv_21_callback_interrupt_enable)(struct pm8001_hba_info * , unsigned char ) ; unsigned int (*ldv_21_callback_is_our_interupt)(struct pm8001_hba_info * ) ; enum irqreturn (*ldv_21_callback_isr)(struct pm8001_hba_info * , unsigned char ) ; int (*ldv_21_callback_isr_process_oq)(struct pm8001_hba_info * , unsigned char ) ; void (*ldv_21_callback_make_prd)(struct scatterlist * , int , void * ) ; int (*ldv_21_callback_phy_ctl_req)(struct pm8001_hba_info * , unsigned int , unsigned int ) ; int (*ldv_21_callback_phy_start_req)(struct pm8001_hba_info * , unsigned char ) ; int (*ldv_21_callback_phy_stop_req)(struct pm8001_hba_info * , unsigned char ) ; int (*ldv_21_callback_reg_dev_req)(struct pm8001_hba_info * , struct pm8001_device * , unsigned int ) ; int (*ldv_21_callback_sas_re_init_req)(struct pm8001_hba_info * ) ; int (*ldv_21_callback_sata_req)(struct pm8001_hba_info * , struct pm8001_ccb_info * ) ; int (*ldv_21_callback_set_dev_state_req)(struct pm8001_hba_info * , struct pm8001_device * , unsigned int ) ; int (*ldv_21_callback_set_nvmd_req)(struct pm8001_hba_info * , void * ) ; int (*ldv_21_callback_smp_req)(struct pm8001_hba_info * , struct pm8001_ccb_info * ) ; int (*ldv_21_callback_ssp_io_req)(struct pm8001_hba_info * , struct pm8001_ccb_info * ) ; int (*ldv_21_callback_ssp_tm_req)(struct pm8001_hba_info * , struct pm8001_ccb_info * , struct pm8001_tmf_task * ) ; int (*ldv_21_callback_task_abort)(struct pm8001_hba_info * , struct pm8001_device * , unsigned char , unsigned int , unsigned int ) ; struct pm8001_ccb_info *ldv_21_container_struct_pm8001_ccb_info_ptr ; struct pm8001_device *ldv_21_container_struct_pm8001_device_ptr ; struct pm8001_hba_info *ldv_21_container_struct_pm8001_hba_info_ptr ; struct pm8001_tmf_task *ldv_21_container_struct_pm8001_tmf_task_ptr ; struct scatterlist *ldv_21_container_struct_scatterlist_ptr ; unsigned int ldv_21_ldv_param_10_1_default ; unsigned char ldv_21_ldv_param_15_1_default ; unsigned char ldv_21_ldv_param_18_1_default ; unsigned char ldv_21_ldv_param_22_1_default ; unsigned char ldv_21_ldv_param_25_1_default ; int ldv_21_ldv_param_28_1_default ; unsigned int ldv_21_ldv_param_31_1_default ; unsigned int ldv_21_ldv_param_31_2_default ; unsigned char ldv_21_ldv_param_34_1_default ; unsigned char ldv_21_ldv_param_37_1_default ; unsigned int ldv_21_ldv_param_40_2_default ; unsigned int ldv_21_ldv_param_45_2_default ; unsigned char ldv_21_ldv_param_52_2_default ; unsigned int ldv_21_ldv_param_52_3_default ; unsigned int ldv_21_ldv_param_52_4_default ; int tmp ; { goto ldv_call_21; return; ldv_call_21: { tmp = ldv_undef_int(); } { if (tmp == 1) { goto case_1; } else { } if (tmp == 2) { goto case_2; } else { } if (tmp == 3) { goto case_3; } else { } if (tmp == 4) { goto case_4; } else { } if (tmp == 5) { goto case_5; } else { } if (tmp == 6) { goto case_6; } else { } if (tmp == 7) { goto case_7; } else { } if (tmp == 8) { goto case_8; } else { } if (tmp == 9) { goto case_9; } else { } if (tmp == 10) { goto case_10; } else { } if (tmp == 11) { goto case_11; } else { } if (tmp == 12) { goto case_12; } else { } if (tmp == 13) { goto case_13; } else { } if (tmp == 14) { goto case_14; } else { } if (tmp == 15) { goto case_15; } else { } if (tmp == 16) { goto case_16; } else { } if (tmp == 17) { goto case_17; } else { } if (tmp == 18) { goto case_18; } else { } if (tmp == 19) { goto case_19; } else { } if (tmp == 20) { goto case_20; } else { } if (tmp == 21) { goto case_21; } else { } if (tmp == 22) { goto case_22; } else { } if (tmp == 23) { goto case_23; } else { } if (tmp == 24) { goto case_24; } else { } if (tmp == 25) { goto case_25; } else { } if (tmp == 26) { goto case_26; } else { } goto switch_default; case_1: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_21_52(ldv_21_callback_task_abort, ldv_21_container_struct_pm8001_hba_info_ptr, ldv_21_container_struct_pm8001_device_ptr, (int )ldv_21_ldv_param_52_2_default, ldv_21_ldv_param_52_3_default, ldv_21_ldv_param_52_4_default); } goto ldv_call_21; case_2: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_21_51(ldv_21_callback_ssp_tm_req, ldv_21_container_struct_pm8001_hba_info_ptr, ldv_21_container_struct_pm8001_ccb_info_ptr, ldv_21_container_struct_pm8001_tmf_task_ptr); } goto ldv_call_21; goto ldv_call_21; case_3: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_21_50(ldv_21_callback_ssp_io_req, ldv_21_container_struct_pm8001_hba_info_ptr, ldv_21_container_struct_pm8001_ccb_info_ptr); } goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; case_4: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_21_49(ldv_21_callback_smp_req, ldv_21_container_struct_pm8001_hba_info_ptr, ldv_21_container_struct_pm8001_ccb_info_ptr); } goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; case_5: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_21_48(ldv_21_callback_set_nvmd_req, ldv_21_container_struct_pm8001_hba_info_ptr, (void *)ldv_21_container_struct_pm8001_ccb_info_ptr); } goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; case_6: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_21_45(ldv_21_callback_set_dev_state_req, ldv_21_container_struct_pm8001_hba_info_ptr, ldv_21_container_struct_pm8001_device_ptr, ldv_21_ldv_param_45_2_default); } goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; case_7: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_21_44(ldv_21_callback_sata_req, ldv_21_container_struct_pm8001_hba_info_ptr, ldv_21_container_struct_pm8001_ccb_info_ptr); } goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; case_8: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_21_43(ldv_21_callback_sas_re_init_req, ldv_21_container_struct_pm8001_hba_info_ptr); } goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; case_9: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_21_40(ldv_21_callback_reg_dev_req, ldv_21_container_struct_pm8001_hba_info_ptr, ldv_21_container_struct_pm8001_device_ptr, ldv_21_ldv_param_40_2_default); } goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; case_10: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_21_37(ldv_21_callback_phy_stop_req, ldv_21_container_struct_pm8001_hba_info_ptr, (int )ldv_21_ldv_param_37_1_default); } goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; case_11: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_21_34(ldv_21_callback_phy_start_req, ldv_21_container_struct_pm8001_hba_info_ptr, (int )ldv_21_ldv_param_34_1_default); } goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; case_12: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_21_31(ldv_21_callback_phy_ctl_req, ldv_21_container_struct_pm8001_hba_info_ptr, ldv_21_ldv_param_31_1_default, ldv_21_ldv_param_31_2_default); } goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; case_13: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_21_28(ldv_21_callback_make_prd, ldv_21_container_struct_scatterlist_ptr, ldv_21_ldv_param_28_1_default, (void *)ldv_21_container_struct_pm8001_ccb_info_ptr); } goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; case_14: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_21_25(ldv_21_callback_isr_process_oq, ldv_21_container_struct_pm8001_hba_info_ptr, (int )ldv_21_ldv_param_25_1_default); } goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; case_15: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_21_22(ldv_21_callback_isr, ldv_21_container_struct_pm8001_hba_info_ptr, (int )ldv_21_ldv_param_22_1_default); } goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; case_16: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_21_21(ldv_21_callback_is_our_interupt, ldv_21_container_struct_pm8001_hba_info_ptr); } goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; case_17: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_21_18(ldv_21_callback_interrupt_enable, ldv_21_container_struct_pm8001_hba_info_ptr, (int )ldv_21_ldv_param_18_1_default); } goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; case_18: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_21_15(ldv_21_callback_interrupt_disable, ldv_21_container_struct_pm8001_hba_info_ptr, (int )ldv_21_ldv_param_15_1_default); } goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; case_19: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_21_14(ldv_21_callback_get_nvmd_req, ldv_21_container_struct_pm8001_hba_info_ptr, (void *)ldv_21_container_struct_pm8001_ccb_info_ptr); } goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; case_20: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_21_13(ldv_21_callback_fw_flash_update_req, ldv_21_container_struct_pm8001_hba_info_ptr, (void *)ldv_21_container_struct_pm8001_ccb_info_ptr); } goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; case_21: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_21_10(ldv_21_callback_dereg_dev_req, ldv_21_container_struct_pm8001_hba_info_ptr, ldv_21_ldv_param_10_1_default); } goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; case_22: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_21_9(ldv_21_callback_chip_soft_rst, ldv_21_container_struct_pm8001_hba_info_ptr); } goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; case_23: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_21_8(ldv_21_callback_chip_rst, ldv_21_container_struct_pm8001_hba_info_ptr); } goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; case_24: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_21_7(ldv_21_callback_chip_iounmap, ldv_21_container_struct_pm8001_hba_info_ptr); } goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; case_25: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_21_3(ldv_21_callback_chip_init, ldv_21_container_struct_pm8001_hba_info_ptr); } goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; goto ldv_call_21; case_26: /* CIL Label */ ; return; switch_default: /* CIL Label */ { ldv_stop(); } switch_break: /* CIL Label */ ; } return; } } void ldv_struct_sas_domain_function_template_dummy_resourceless_instance_22(void *arg0 ) { int (*ldv_22_callback_lldd_I_T_nexus_reset)(struct domain_device * ) ; int (*ldv_22_callback_lldd_abort_task)(struct sas_task * ) ; int (*ldv_22_callback_lldd_abort_task_set)(struct domain_device * , unsigned char * ) ; int (*ldv_22_callback_lldd_clear_aca)(struct domain_device * , unsigned char * ) ; int (*ldv_22_callback_lldd_clear_task_set)(struct domain_device * , unsigned char * ) ; int (*ldv_22_callback_lldd_control_phy)(struct asd_sas_phy * , enum phy_func , void * ) ; int (*ldv_22_callback_lldd_dev_found)(struct domain_device * ) ; void (*ldv_22_callback_lldd_dev_gone)(struct domain_device * ) ; int (*ldv_22_callback_lldd_execute_task)(struct sas_task * , unsigned int ) ; int (*ldv_22_callback_lldd_lu_reset)(struct domain_device * , unsigned char * ) ; int (*ldv_22_callback_lldd_query_task)(struct sas_task * ) ; enum phy_func ldv_22_container_enum_phy_func ; struct asd_sas_phy *ldv_22_container_struct_asd_sas_phy_ptr ; struct domain_device *ldv_22_container_struct_domain_device_ptr ; struct sas_task *ldv_22_container_struct_sas_task_ptr ; unsigned char *ldv_22_ldv_param_11_1_default ; unsigned char *ldv_22_ldv_param_14_1_default ; unsigned int ldv_22_ldv_param_20_1_default ; unsigned char *ldv_22_ldv_param_23_1_default ; unsigned char *ldv_22_ldv_param_8_1_default ; int tmp ; void *tmp___0 ; void *tmp___1 ; void *tmp___2 ; void *tmp___3 ; { goto ldv_call_22; return; ldv_call_22: { tmp = ldv_undef_int(); } { if (tmp == 1) { goto case_1; } else { } if (tmp == 2) { goto case_2; } else { } if (tmp == 3) { goto case_3; } else { } if (tmp == 4) { goto case_4; } else { } if (tmp == 5) { goto case_5; } else { } if (tmp == 6) { goto case_6; } else { } if (tmp == 7) { goto case_7; } else { } if (tmp == 8) { goto case_8; } else { } if (tmp == 9) { goto case_9; } else { } if (tmp == 10) { goto case_10; } else { } if (tmp == 11) { goto case_11; } else { } if (tmp == 12) { goto case_12; } else { } goto switch_default; case_1: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_22_26(ldv_22_callback_lldd_query_task, ldv_22_container_struct_sas_task_ptr); } goto ldv_call_22; case_2: /* CIL Label */ { tmp___0 = ldv_xmalloc(1UL); ldv_22_ldv_param_23_1_default = (unsigned char *)tmp___0; ldv_dummy_resourceless_instance_callback_22_23(ldv_22_callback_lldd_lu_reset, ldv_22_container_struct_domain_device_ptr, ldv_22_ldv_param_23_1_default); ldv_free((void *)ldv_22_ldv_param_23_1_default); } goto ldv_call_22; goto ldv_call_22; case_3: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_22_20(ldv_22_callback_lldd_execute_task, ldv_22_container_struct_sas_task_ptr, ldv_22_ldv_param_20_1_default); } goto ldv_call_22; goto ldv_call_22; goto ldv_call_22; case_4: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_22_19(ldv_22_callback_lldd_dev_gone, ldv_22_container_struct_domain_device_ptr); } goto ldv_call_22; goto ldv_call_22; goto ldv_call_22; goto ldv_call_22; case_5: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_22_18(ldv_22_callback_lldd_dev_found, ldv_22_container_struct_domain_device_ptr); } goto ldv_call_22; goto ldv_call_22; goto ldv_call_22; goto ldv_call_22; goto ldv_call_22; case_6: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_22_17(ldv_22_callback_lldd_control_phy, ldv_22_container_struct_asd_sas_phy_ptr, ldv_22_container_enum_phy_func, (void *)ldv_22_container_struct_domain_device_ptr); } goto ldv_call_22; goto ldv_call_22; goto ldv_call_22; goto ldv_call_22; goto ldv_call_22; goto ldv_call_22; case_7: /* CIL Label */ { tmp___1 = ldv_xmalloc(1UL); ldv_22_ldv_param_14_1_default = (unsigned char *)tmp___1; ldv_dummy_resourceless_instance_callback_22_14(ldv_22_callback_lldd_clear_task_set, ldv_22_container_struct_domain_device_ptr, ldv_22_ldv_param_14_1_default); ldv_free((void *)ldv_22_ldv_param_14_1_default); } goto ldv_call_22; goto ldv_call_22; goto ldv_call_22; goto ldv_call_22; goto ldv_call_22; goto ldv_call_22; goto ldv_call_22; case_8: /* CIL Label */ { tmp___2 = ldv_xmalloc(1UL); ldv_22_ldv_param_11_1_default = (unsigned char *)tmp___2; ldv_dummy_resourceless_instance_callback_22_11(ldv_22_callback_lldd_clear_aca, ldv_22_container_struct_domain_device_ptr, ldv_22_ldv_param_11_1_default); ldv_free((void *)ldv_22_ldv_param_11_1_default); } goto ldv_call_22; goto ldv_call_22; goto ldv_call_22; goto ldv_call_22; goto ldv_call_22; goto ldv_call_22; goto ldv_call_22; goto ldv_call_22; case_9: /* CIL Label */ { tmp___3 = ldv_xmalloc(1UL); ldv_22_ldv_param_8_1_default = (unsigned char *)tmp___3; ldv_dummy_resourceless_instance_callback_22_8(ldv_22_callback_lldd_abort_task_set, ldv_22_container_struct_domain_device_ptr, ldv_22_ldv_param_8_1_default); ldv_free((void *)ldv_22_ldv_param_8_1_default); } goto ldv_call_22; goto ldv_call_22; goto ldv_call_22; goto ldv_call_22; goto ldv_call_22; goto ldv_call_22; goto ldv_call_22; goto ldv_call_22; goto ldv_call_22; case_10: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_22_7(ldv_22_callback_lldd_abort_task, ldv_22_container_struct_sas_task_ptr); } goto ldv_call_22; goto ldv_call_22; goto ldv_call_22; goto ldv_call_22; goto ldv_call_22; goto ldv_call_22; goto ldv_call_22; goto ldv_call_22; goto ldv_call_22; goto ldv_call_22; case_11: /* CIL Label */ { ldv_dummy_resourceless_instance_callback_22_3(ldv_22_callback_lldd_I_T_nexus_reset, ldv_22_container_struct_domain_device_ptr); } goto ldv_call_22; goto ldv_call_22; goto ldv_call_22; goto ldv_call_22; goto ldv_call_22; goto ldv_call_22; goto ldv_call_22; goto ldv_call_22; goto ldv_call_22; goto ldv_call_22; goto ldv_call_22; case_12: /* CIL Label */ ; return; switch_default: /* CIL Label */ { ldv_stop(); } switch_break: /* CIL Label */ ; } return; } } void ldv_timer_dummy_factory_24(void *arg0 ) { struct timer_list *ldv_24_container_timer_list ; { { ldv_dispatch_instance_register_24_3(ldv_24_container_timer_list); } return; return; } } void ldv_timer_instance_callback_23_2(void (*arg0)(unsigned long ) , unsigned long arg1 ) { { { (*arg0)(arg1); } return; } } void ldv_timer_timer_instance_23(void *arg0 ) { struct timer_list *ldv_23_container_timer_list ; struct ldv_struct_timer_instance_23 *data ; { data = (struct ldv_struct_timer_instance_23 *)arg0; if ((unsigned long )data != (unsigned long )((struct ldv_struct_timer_instance_23 *)0)) { { ldv_23_container_timer_list = data->arg0; ldv_free((void *)data); } } else { } { ldv_switch_to_interrupt_context(); } if ((unsigned long )ldv_23_container_timer_list->function != (unsigned long )((void (*)(unsigned long ))0)) { { ldv_timer_instance_callback_23_2(ldv_23_container_timer_list->function, ldv_23_container_timer_list->data); } } else { } { ldv_switch_to_process_context(); } return; return; } } __inline static void *ioremap(resource_size_t offset , unsigned long size ) { void *tmp ; { { tmp = ldv_linux_arch_io_io_mem_remap(); } return (tmp); } } __inline static void *kcalloc(size_t n , size_t size , gfp_t flags ) { void *res ; { { ldv_check_alloc_flags(flags); res = ldv_malloc_unknown_size(); ldv_after_alloc(res); } return (res); } } __inline static void *kzalloc(size_t size , gfp_t flags ) { void *tmp ; { { tmp = ldv_kzalloc(size, flags); } return (tmp); } } __inline static void ldv_init_completion_100(struct completion *x ) { { { ldv_linux_kernel_sched_completion_init_completion_completion(); } return; } } static void ldv_wait_for_completion_101(struct completion *ldv_func_arg1 ) { { { ldv_linux_kernel_sched_completion_wait_for_completion_completion(); wait_for_completion(ldv_func_arg1); } return; } } static void ldv_wait_for_completion_103(struct completion *ldv_func_arg1 ) { { { ldv_linux_kernel_sched_completion_wait_for_completion_completion(); wait_for_completion(ldv_func_arg1); } return; } } __inline static int ldv_request_irq_104(unsigned int irq , irqreturn_t (*handler)(int , void * ) , unsigned long flags , char const *name , void *dev ) { ldv_func_ret_type___0 ldv_func_res ; int tmp ; int tmp___0 ; { { tmp = request_irq(irq, handler, flags, name, dev); ldv_func_res = tmp; tmp___0 = ldv_request_irq(ldv_func_res, irq, handler, flags, (char *)name, dev); } return (tmp___0); return (ldv_func_res); } } static void ldv_free_irq_105(unsigned int ldv_func_arg1 , void *ldv_func_arg2 ) { { { free_irq(ldv_func_arg1, ldv_func_arg2); ldv_free_irq((void *)0, (int )ldv_func_arg1, ldv_func_arg2); } return; } } __inline static int ldv_request_irq_106(unsigned int irq , irqreturn_t (*handler)(int , void * ) , unsigned long flags , char const *name , void *dev ) { ldv_func_ret_type___1 ldv_func_res ; int tmp ; int tmp___0 ; { { tmp = request_irq(irq, handler, flags, name, dev); ldv_func_res = tmp; tmp___0 = ldv_request_irq(ldv_func_res, irq, handler, flags, (char *)name, dev); } return (tmp___0); return (ldv_func_res); } } static struct Scsi_Host *ldv_scsi_host_alloc_107(struct scsi_host_template *ldv_func_arg1 , int ldv_func_arg2 ) { ldv_func_ret_type___2 ldv_func_res ; struct Scsi_Host *tmp ; struct Scsi_Host *tmp___0 ; { { tmp = scsi_host_alloc(ldv_func_arg1, ldv_func_arg2); ldv_func_res = tmp; tmp___0 = ldv_scsi_host_alloc(ldv_func_res, ldv_func_arg1, ldv_func_arg2); } return (tmp___0); return (ldv_func_res); } } __inline static int ldv_scsi_add_host_108(struct Scsi_Host *host , struct device *dev ) { ldv_func_ret_type___3 ldv_func_res ; int tmp ; int tmp___0 ; { { tmp = scsi_add_host(host, dev); ldv_func_res = tmp; tmp___0 = ldv_scsi_add_host(ldv_func_res, host, dev); } return (tmp___0); return (ldv_func_res); } } static void ldv_scsi_remove_host_109(struct Scsi_Host *ldv_func_arg1 ) { { { scsi_remove_host(ldv_func_arg1); ldv_scsi_remove_host((void *)0, ldv_func_arg1); } return; } } static void ldv_scsi_remove_host_110(struct Scsi_Host *ldv_func_arg1 ) { { { scsi_remove_host(ldv_func_arg1); ldv_scsi_remove_host((void *)0, ldv_func_arg1); } return; } } static void ldv_free_irq_111(unsigned int ldv_func_arg1 , void *ldv_func_arg2 ) { { { free_irq(ldv_func_arg1, ldv_func_arg2); ldv_free_irq((void *)0, (int )ldv_func_arg1, ldv_func_arg2); } return; } } static void ldv_free_irq_112(unsigned int ldv_func_arg1 , void *ldv_func_arg2 ) { { { free_irq(ldv_func_arg1, ldv_func_arg2); ldv_free_irq((void *)0, (int )ldv_func_arg1, ldv_func_arg2); } return; } } static void ldv_wait_for_completion_114(struct completion *ldv_func_arg1 ) { { { ldv_linux_kernel_sched_completion_wait_for_completion_completion(); wait_for_completion(ldv_func_arg1); } return; } } static void ldv_scsi_remove_host_115(struct Scsi_Host *ldv_func_arg1 ) { { { scsi_remove_host(ldv_func_arg1); ldv_scsi_remove_host((void *)0, ldv_func_arg1); } return; } } static int ldv___pci_register_driver_116(struct pci_driver *ldv_func_arg1 , struct module *ldv_func_arg2 , char const *ldv_func_arg3 ) { ldv_func_ret_type___4 ldv_func_res ; int tmp ; int tmp___0 ; { { tmp = __pci_register_driver(ldv_func_arg1, ldv_func_arg2, ldv_func_arg3); ldv_func_res = tmp; tmp___0 = ldv___pci_register_driver(ldv_func_res, ldv_func_arg1, ldv_func_arg2, (char *)ldv_func_arg3); } return (tmp___0); return (ldv_func_res); } } static void ldv_pci_unregister_driver_117(struct pci_driver *ldv_func_arg1 ) { { { pci_unregister_driver(ldv_func_arg1); ldv_pci_unregister_driver((void *)0, ldv_func_arg1); } return; } } static int ldv_ldv_post_init_118(int ldv_func_arg1 ) { int tmp ; { { ldv_linux_net_register_reset_error_counter(); ldv_linux_usb_register_reset_error_counter(); tmp = ldv_post_init(ldv_func_arg1); } return (tmp); } } static void ldv_ldv_check_final_state_119(void) { { { ldv_linux_arch_io_check_final_state(); ldv_linux_block_genhd_check_final_state(); ldv_linux_block_queue_check_final_state(); ldv_linux_block_request_check_final_state(); ldv_linux_drivers_base_class_check_final_state(); ldv_linux_fs_char_dev_check_final_state(); ldv_linux_fs_sysfs_check_final_state(); ldv_linux_kernel_locking_rwlock_check_final_state(); ldv_linux_kernel_module_check_final_state(); ldv_linux_kernel_rcu_update_lock_bh_check_final_state(); ldv_linux_kernel_rcu_update_lock_sched_check_final_state(); ldv_linux_kernel_rcu_update_lock_check_final_state(); ldv_linux_kernel_rcu_srcu_check_final_state(); ldv_linux_lib_idr_check_final_state(); ldv_linux_mmc_sdio_func_check_final_state(); ldv_linux_net_rtnetlink_check_final_state(); ldv_linux_net_sock_check_final_state(); ldv_linux_usb_coherent_check_final_state(); ldv_linux_usb_gadget_check_final_state(); ldv_linux_usb_urb_check_final_state(); } return; } } static void ldv_ldv_check_final_state_120(void) { { { ldv_linux_arch_io_check_final_state(); ldv_linux_block_genhd_check_final_state(); ldv_linux_block_queue_check_final_state(); ldv_linux_block_request_check_final_state(); ldv_linux_drivers_base_class_check_final_state(); ldv_linux_fs_char_dev_check_final_state(); ldv_linux_fs_sysfs_check_final_state(); ldv_linux_kernel_locking_rwlock_check_final_state(); ldv_linux_kernel_module_check_final_state(); ldv_linux_kernel_rcu_update_lock_bh_check_final_state(); ldv_linux_kernel_rcu_update_lock_sched_check_final_state(); ldv_linux_kernel_rcu_update_lock_check_final_state(); ldv_linux_kernel_rcu_srcu_check_final_state(); ldv_linux_lib_idr_check_final_state(); ldv_linux_mmc_sdio_func_check_final_state(); ldv_linux_net_rtnetlink_check_final_state(); ldv_linux_net_sock_check_final_state(); ldv_linux_usb_coherent_check_final_state(); ldv_linux_usb_gadget_check_final_state(); ldv_linux_usb_urb_check_final_state(); } return; } } static void ldv_ldv_initialize_121(void) { { { ldv_linux_lib_find_bit_initialize(); } return; } } static void ldv_ldv_pre_probe_122(void) { { { ldv_linux_net_register_reset_error_counter(); ldv_linux_usb_register_reset_error_counter(); ldv_pre_probe(); } return; } } static int ldv_ldv_post_probe_123(int retval ) { int tmp ; { { ldv_linux_net_register_check_return_value_probe(retval); ldv_linux_usb_register_check_return_value_probe(retval); tmp = ldv_post_probe(retval); } return (tmp); } } static void ldv_ldv_pre_probe_124(void) { { { ldv_linux_net_register_reset_error_counter(); ldv_linux_usb_register_reset_error_counter(); ldv_pre_probe(); } return; } } static int ldv_ldv_post_probe_125(int retval ) { int tmp ; { { ldv_linux_net_register_check_return_value_probe(retval); ldv_linux_usb_register_check_return_value_probe(retval); tmp = ldv_post_probe(retval); } return (tmp); } } void ldv_linux_kernel_sched_completion_wait_for_completion_completion_of_sas_task_slow(void) ; void ldv_linux_kernel_sched_completion_init_completion_completion_setstate(void) ; void ldv_linux_kernel_sched_completion_wait_for_completion_completion_setstate(void) ; unsigned long ldv_linux_lib_find_bit_find_first_bit(unsigned long size ) ; __inline static void set_bit(long nr , unsigned long volatile *addr ) { { __asm__ volatile (".pushsection .smp_locks,\"a\"\n.balign 4\n.long 671f - .\n.popsection\n671:\n\tlock; bts %1,%0": "+m" (*((long volatile *)addr)): "Ir" (nr): "memory"); return; } } __inline static void clear_bit(long nr , unsigned long volatile *addr ) { { __asm__ volatile (".pushsection .smp_locks,\"a\"\n.balign 4\n.long 671f - .\n.popsection\n671:\n\tlock; btr %1,%0": "+m" (*((long volatile *)addr)): "Ir" (nr)); return; } } static unsigned long ldv_find_first_zero_bit_101(unsigned long const *addr , unsigned long size ) ; __inline static __u64 __fswab64(__u64 val ) { long tmp ; { { tmp = __builtin_bswap64((unsigned long )val); } return ((__u64 )tmp); } } extern char *strncpy(char * , char const * , __kernel_size_t ) ; extern void __ldv_linux_kernel_locking_spinlock_spin_lock(spinlock_t * ) ; static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_100(spinlock_t *ldv_func_arg1 ) ; static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_108(spinlock_t *ldv_func_arg1 ) ; static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_111(spinlock_t *ldv_func_arg1 ) ; static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_113(spinlock_t *ldv_func_arg1 ) ; static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_118(spinlock_t *ldv_func_arg1 ) ; static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_129(spinlock_t *ldv_func_arg1 ) ; static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_131(spinlock_t *ldv_func_arg1 ) ; static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_133(spinlock_t *ldv_func_arg1 ) ; static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_134(spinlock_t *ldv_func_arg1 ) ; static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_138(spinlock_t *ldv_func_arg1 ) ; static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_146(spinlock_t *ldv_func_arg1 ) ; void ldv_linux_kernel_locking_spinlock_spin_lock_bitmap_lock_of_pm8001_hba_info(void) ; void ldv_linux_kernel_locking_spinlock_spin_unlock_bitmap_lock_of_pm8001_hba_info(void) ; void ldv_linux_kernel_locking_spinlock_spin_lock_lock_of_pm8001_hba_info(void) ; void ldv_linux_kernel_locking_spinlock_spin_unlock_lock_of_pm8001_hba_info(void) ; void ldv_linux_kernel_locking_spinlock_spin_lock_task_state_lock_of_sas_task(void) ; void ldv_linux_kernel_locking_spinlock_spin_unlock_task_state_lock_of_sas_task(void) ; extern void _raw_spin_lock(raw_spinlock_t * ) ; extern void _raw_spin_unlock(raw_spinlock_t * ) ; extern void _raw_spin_unlock_irqrestore(raw_spinlock_t * , unsigned long ) ; __inline static void spin_lock(spinlock_t *lock ) { { { _raw_spin_lock(& lock->__annonCompField18.rlock); } return; } } __inline static void ldv_spin_lock_114(spinlock_t *lock ) ; __inline static void spin_unlock(spinlock_t *lock ) { { { _raw_spin_unlock(& lock->__annonCompField18.rlock); } return; } } __inline static void ldv_spin_unlock_115(spinlock_t *lock ) ; __inline static void spin_unlock_irqrestore(spinlock_t *lock , unsigned long flags ) { { { _raw_spin_unlock_irqrestore(& lock->__annonCompField18.rlock, flags); } return; } } __inline static void ldv_spin_unlock_irqrestore_102(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_102(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_109(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_109(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_109(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_109(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_109(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_109(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_109(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_109(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_135(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_135(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_109(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_109(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_135(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_135(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_init_completion_100(struct completion *x ) ; __inline static void ldv_init_completion_100(struct completion *x ) ; __inline static void ldv_init_completion_123(struct completion *x ) ; __inline static void ldv_init_completion_123(struct completion *x ) ; __inline static void ldv_init_completion_123(struct completion *x ) ; __inline static void ldv_init_completion_123(struct completion *x ) ; static void ldv_wait_for_completion_105(struct completion *ldv_func_arg1 ) ; static void ldv_wait_for_completion_106(struct completion *ldv_func_arg1 ) ; static void ldv_wait_for_completion_107(struct completion *ldv_func_arg1 ) ; static void ldv_wait_for_completion_120(struct completion *ldv_func_arg1 ) ; static void ldv_wait_for_completion_125(struct completion *ldv_func_arg1 ) ; static void ldv_wait_for_completion_126(struct completion *ldv_func_arg1 ) ; static void ldv_wait_for_completion_128(struct completion *ldv_func_arg1 ) ; static void ldv_wait_for_completion_141(struct completion *ldv_func_arg1 ) ; static void ldv_wait_for_completion_143(struct completion *ldv_func_arg1 ) ; static void ldv_wait_for_completion_145(struct completion *ldv_func_arg1 ) ; extern void complete(struct completion * ) ; extern unsigned long volatile jiffies ; extern int del_timer(struct timer_list * ) ; static int ldv_del_timer_122(struct timer_list *ldv_func_arg1 ) ; static int ldv_del_timer_124(struct timer_list *ldv_func_arg1 ) ; static int ldv_del_timer_127(struct timer_list *ldv_func_arg1 ) ; extern void add_timer(struct timer_list * ) ; extern void put_device(struct device * ) ; __inline static void *lowmem_page_address(struct page const *page ) { { return ((void *)((unsigned long )((unsigned long long )(((long )page + 24189255811072L) / 64L) << 12) + 0xffff880000000000UL)); } } __inline static struct page *sg_page(struct scatterlist *sg ) { long tmp ; long tmp___0 ; { { tmp = ldv__builtin_expect(sg->sg_magic != 2271560481UL, 0L); } if (tmp != 0L) { { __asm__ volatile ("1:\tud2\n.pushsection __bug_table,\"a\"\n2:\t.long 1b - 2b, %c0 - 2b\n\t.word %c1, 0\n\t.org 2b+%c2\n.popsection": : "i" ((char *)"include/linux/scatterlist.h"), "i" (98), "i" (12UL)); __builtin_unreachable(); } } else { } { tmp___0 = ldv__builtin_expect((long )((int )sg->page_link) & 1L, 0L); } if (tmp___0 != 0L) { { __asm__ volatile ("1:\tud2\n.pushsection __bug_table,\"a\"\n2:\t.long 1b - 2b, %c0 - 2b\n\t.word %c1, 0\n\t.org 2b+%c2\n.popsection": : "i" ((char *)"include/linux/scatterlist.h"), "i" (99), "i" (12UL)); __builtin_unreachable(); } } else { } return ((struct page *)(sg->page_link & 0xfffffffffffffffcUL)); } } __inline static void *sg_virt(struct scatterlist *sg ) { struct page *tmp ; void *tmp___0 ; { { tmp = sg_page(sg); tmp___0 = lowmem_page_address((struct page const *)tmp); } return (tmp___0 + (unsigned long )sg->offset); } } extern struct scatterlist *sg_next(struct scatterlist * ) ; __inline static int valid_dma_direction(int dma_direction ) { { return ((unsigned int )dma_direction <= 2U); } } __inline static void kmemcheck_mark_initialized(void *address , unsigned int n ) { { return; } } extern void debug_dma_map_sg(struct device * , struct scatterlist * , int , int , int ) ; extern void debug_dma_unmap_sg(struct device * , struct scatterlist * , int , int ) ; __inline static int dma_map_sg_attrs(struct device *dev , struct scatterlist *sg , int nents , enum dma_data_direction dir , struct dma_attrs *attrs ) { struct dma_map_ops *ops ; struct dma_map_ops *tmp ; int i ; int ents ; struct scatterlist *s ; void *tmp___0 ; int tmp___1 ; long tmp___2 ; { { tmp = get_dma_ops(dev); ops = tmp; i = 0; s = sg; } goto ldv_26311; ldv_26310: { tmp___0 = sg_virt(s); kmemcheck_mark_initialized(tmp___0, s->length); i = i + 1; s = sg_next(s); } ldv_26311: ; if (i < nents) { goto ldv_26310; } else { } { tmp___1 = valid_dma_direction((int )dir); tmp___2 = ldv__builtin_expect(tmp___1 == 0, 0L); } if (tmp___2 != 0L) { { __asm__ volatile ("1:\tud2\n.pushsection __bug_table,\"a\"\n2:\t.long 1b - 2b, %c0 - 2b\n\t.word %c1, 0\n\t.org 2b+%c2\n.popsection": : "i" ((char *)"include/asm-generic/dma-mapping-common.h"), "i" (52), "i" (12UL)); __builtin_unreachable(); } } else { } { ents = (*(ops->map_sg))(dev, sg, nents, dir, attrs); debug_dma_map_sg(dev, sg, nents, ents, (int )dir); } return (ents); } } __inline static void dma_unmap_sg_attrs(struct device *dev , struct scatterlist *sg , int nents , enum dma_data_direction dir , struct dma_attrs *attrs ) { struct dma_map_ops *ops ; struct dma_map_ops *tmp ; int tmp___0 ; long tmp___1 ; { { tmp = get_dma_ops(dev); ops = tmp; tmp___0 = valid_dma_direction((int )dir); tmp___1 = ldv__builtin_expect(tmp___0 == 0, 0L); } if (tmp___1 != 0L) { { __asm__ volatile ("1:\tud2\n.pushsection __bug_table,\"a\"\n2:\t.long 1b - 2b, %c0 - 2b\n\t.word %c1, 0\n\t.org 2b+%c2\n.popsection": : "i" ((char *)"include/asm-generic/dma-mapping-common.h"), "i" (65), "i" (12UL)); __builtin_unreachable(); } } else { } { debug_dma_unmap_sg(dev, sg, nents, (int )dir); } if ((unsigned long )ops->unmap_sg != (unsigned long )((void (*)(struct device * , struct scatterlist * , int , enum dma_data_direction , struct dma_attrs * ))0)) { { (*(ops->unmap_sg))(dev, sg, nents, dir, attrs); } } else { } return; } } __inline static void *dma_zalloc_coherent(struct device *dev , size_t size , dma_addr_t *dma_handle , gfp_t flags ) ; __inline static void *pci_zalloc_consistent(struct pci_dev *hwdev , size_t size , dma_addr_t *dma_handle ) { void *tmp ; { { tmp = dma_zalloc_coherent((unsigned long )hwdev != (unsigned long )((struct pci_dev *)0) ? & hwdev->dev : (struct device *)0, size, dma_handle, 32U); } return (tmp); } } extern int scsi_is_host_device(struct device const * ) ; extern void msleep(unsigned int ) ; extern void int_to_scsilun(u64 , struct scsi_lun * ) ; __inline static int sas_protocol_ata(enum sas_protocol proto ) { { return (((unsigned int )proto & 5U) != 0U); } } __inline static void sas_put_local_phy(struct sas_phy *phy ) { { { put_device(& phy->dev); } return; } } extern struct sas_task *sas_alloc_slow_task(gfp_t ) ; extern void sas_free_task(struct sas_task * ) ; extern int sas_phy_reset(struct sas_phy * , int ) ; extern int sas_drain_work(struct sas_ha_struct * ) ; extern struct sas_phy *sas_get_local_phy(struct domain_device * ) ; __inline static int dev_is_sata(struct domain_device *dev ) { { return ((((unsigned int )dev->dev_type == 5U || (unsigned int )dev->dev_type == 7U) || (unsigned int )dev->dev_type == 8U) || (unsigned int )dev->dev_type == 9U); } } __inline int pm8001_tag_alloc(struct pm8001_hba_info *pm8001_ha , u32 *tag_out ) ; u32 pm8001_get_ncq_tag(struct sas_task *task , u32 *tag ) ; void pm8001_ccb_task_free(struct pm8001_hba_info *pm8001_ha , struct sas_task *task , struct pm8001_ccb_info *ccb , u32 ccb_idx ) ; int pm8001_I_T_nexus_event_handler(struct domain_device *dev ) ; void pm8001_open_reject_retry(struct pm8001_hba_info *pm8001_ha , struct sas_task *task_to_close , struct pm8001_device *device_to_close ) ; void pm8001_task_done(struct sas_task *task ) ; void pm8001_tag_free(struct pm8001_hba_info *pm8001_ha , u32 tag ) ; struct pm8001_device *pm8001_find_dev(struct pm8001_hba_info *pm8001_ha , u32 device_id ) ; int pm8001_bar4_shift(struct pm8001_hba_info *pm8001_ha , u32 shiftValue ) ; static int pm8001_find_tag(struct sas_task *task , u32 *tag ) { struct pm8001_ccb_info *ccb ; { if ((unsigned long )task->lldd_task != (unsigned long )((void *)0)) { ccb = (struct pm8001_ccb_info *)task->lldd_task; *tag = ccb->ccb_tag; return (1); } else { } return (0); } } void pm8001_tag_free(struct pm8001_hba_info *pm8001_ha , u32 tag ) { void *bitmap ; { { bitmap = (void *)pm8001_ha->tags; clear_bit((long )tag, (unsigned long volatile *)bitmap); } return; } } __inline int pm8001_tag_alloc(struct pm8001_hba_info *pm8001_ha , u32 *tag_out ) { unsigned int tag ; void *bitmap ; unsigned long flags ; unsigned long tmp ; { { bitmap = (void *)pm8001_ha->tags; ldv___ldv_linux_kernel_locking_spinlock_spin_lock_100(& pm8001_ha->bitmap_lock); tmp = ldv_find_first_zero_bit_101((unsigned long const *)bitmap, (unsigned long )pm8001_ha->tags_num); tag = (unsigned int )tmp; } if (tag >= (unsigned int )pm8001_ha->tags_num) { { ldv_spin_unlock_irqrestore_102(& pm8001_ha->bitmap_lock, flags); } return (-132); } else { } { set_bit((long )tag, (unsigned long volatile *)bitmap); ldv_spin_unlock_irqrestore_102(& pm8001_ha->bitmap_lock, flags); *tag_out = tag; } return (0); } } void pm8001_tag_init(struct pm8001_hba_info *pm8001_ha ) { int i ; { i = 0; goto ldv_45912; ldv_45911: { pm8001_tag_free(pm8001_ha, (u32 )i); i = i + 1; } ldv_45912: ; if (i < pm8001_ha->tags_num) { goto ldv_45911; } else { } return; } } int pm8001_mem_alloc(struct pci_dev *pdev , void **virt_addr , dma_addr_t *pphys_addr , u32 *pphys_addr_hi , u32 *pphys_addr_lo , u32 mem_size , u32 align ) { caddr_t mem_virt_alloc ; dma_addr_t mem_dma_handle ; u64 phys_align ; u64 align_offset ; void *tmp ; { align_offset = 0ULL; if (align != 0U) { align_offset = (unsigned long long )align - 1ULL; } else { } { tmp = pci_zalloc_consistent(pdev, (size_t )(mem_size + align), & mem_dma_handle); mem_virt_alloc = (caddr_t )tmp; } if ((unsigned long )mem_virt_alloc == (unsigned long )((caddr_t )0)) { { printk("\016pm80xx %s %d:memory allocation error\n", "pm8001_mem_alloc", 122); } return (-1); } else { } *pphys_addr = mem_dma_handle; phys_align = (*pphys_addr + align_offset) & ~ align_offset; *virt_addr = (void *)mem_virt_alloc + ((unsigned long )phys_align - (unsigned long )*pphys_addr); *pphys_addr_hi = (unsigned int )(phys_align >> 32ULL); *pphys_addr_lo = (unsigned int )phys_align; return (0); } } static struct pm8001_hba_info *pm8001_find_ha_by_dev(struct domain_device *dev ) { struct sas_ha_struct *sha ; struct pm8001_hba_info *pm8001_ha ; { sha = (dev->port)->ha; pm8001_ha = (struct pm8001_hba_info *)sha->lldd_ha; return (pm8001_ha); } } int pm8001_phy_control(struct asd_sas_phy *sas_phy , enum phy_func func , void *funcdata ) { int rc ; int phy_id ; struct pm8001_hba_info *pm8001_ha ; struct sas_phy_linkrates *rates ; struct completion completion ; unsigned long flags ; int tmp ; struct sas_phy *phy ; uint32_t *qp ; { { rc = 0; phy_id = sas_phy->id; pm8001_ha = (struct pm8001_hba_info *)0; ldv_init_completion_100(& completion); completion = completion; pm8001_ha = (struct pm8001_hba_info *)(sas_phy->ha)->lldd_ha; pm8001_ha->phy[phy_id].enable_completion = & completion; } { if ((unsigned int )func == 17U) { goto case_17; } else { } if ((unsigned int )func == 2U) { goto case_2; } else { } if ((unsigned int )func == 1U) { goto case_1; } else { } if ((unsigned int )func == 16U) { goto case_16; } else { } if ((unsigned int )func == 3U) { goto case_3; } else { } if ((unsigned int )func == 18U) { goto case_18; } else { } goto switch_default; case_17: /* CIL Label */ rates = (struct sas_phy_linkrates *)funcdata; if ((unsigned int )rates->minimum_linkrate != 0U) { pm8001_ha->phy[phy_id].minimum_linkrate = rates->minimum_linkrate; } else { } if ((unsigned int )rates->maximum_linkrate != 0U) { pm8001_ha->phy[phy_id].maximum_linkrate = rates->maximum_linkrate; } else { } if ((unsigned int )pm8001_ha->phy[phy_id].phy_state == 0U) { { (*(((pm8001_ha->chip)->dispatch)->phy_start_req))(pm8001_ha, (int )((u8 )phy_id)); ldv_wait_for_completion_105(& completion); } } else { } { (*(((pm8001_ha->chip)->dispatch)->phy_ctl_req))(pm8001_ha, (u32 )phy_id, 1U); } goto ldv_45946; case_2: /* CIL Label */ ; if ((unsigned int )pm8001_ha->phy[phy_id].phy_state == 0U) { { (*(((pm8001_ha->chip)->dispatch)->phy_start_req))(pm8001_ha, (int )((u8 )phy_id)); ldv_wait_for_completion_106(& completion); } } else { } { (*(((pm8001_ha->chip)->dispatch)->phy_ctl_req))(pm8001_ha, (u32 )phy_id, 2U); } goto ldv_45946; case_1: /* CIL Label */ ; if ((unsigned int )pm8001_ha->phy[phy_id].phy_state == 0U) { { (*(((pm8001_ha->chip)->dispatch)->phy_start_req))(pm8001_ha, (int )((u8 )phy_id)); ldv_wait_for_completion_107(& completion); } } else { } { (*(((pm8001_ha->chip)->dispatch)->phy_ctl_req))(pm8001_ha, (u32 )phy_id, 1U); } goto ldv_45946; case_16: /* CIL Label */ { (*(((pm8001_ha->chip)->dispatch)->phy_ctl_req))(pm8001_ha, (u32 )phy_id, 1U); } goto ldv_45946; case_3: /* CIL Label */ { (*(((pm8001_ha->chip)->dispatch)->phy_stop_req))(pm8001_ha, (int )((u8 )phy_id)); } goto ldv_45946; case_18: /* CIL Label */ { ldv___ldv_linux_kernel_locking_spinlock_spin_lock_108(& pm8001_ha->lock); } if (pm8001_ha->chip_id == 0U) { { tmp = pm8001_bar4_shift(pm8001_ha, phy_id <= 3 ? 196608U : 262144U); } if (tmp == -1) { { ldv_spin_unlock_irqrestore_109(& pm8001_ha->lock, flags); } return (-22); } else { } } else { } phy = sas_phy->phy; qp = (uint32_t *)pm8001_ha->io_mem[2].memvirtaddr + ((unsigned long )((phy_id & 3) * 16384) + 4148UL); phy->invalid_dword_count = *qp; phy->running_disparity_error_count = *(qp + 1UL); phy->loss_of_dword_sync_count = *(qp + 3UL); phy->phy_reset_problem_count = *(qp + 4UL); if (pm8001_ha->chip_id == 0U) { { pm8001_bar4_shift(pm8001_ha, 0U); } } else { } { ldv_spin_unlock_irqrestore_109(& pm8001_ha->lock, flags); } return (0); switch_default: /* CIL Label */ rc = -95; switch_break: /* CIL Label */ ; } ldv_45946: { msleep(300U); } return (rc); } } void pm8001_scan_start(struct Scsi_Host *shost ) { int i ; struct pm8001_hba_info *pm8001_ha ; struct sas_ha_struct *sha ; { sha = *((struct sas_ha_struct **)(& shost->hostdata)); pm8001_ha = (struct pm8001_hba_info *)sha->lldd_ha; if (pm8001_ha->chip_id == 0U) { { (*(((pm8001_ha->chip)->dispatch)->sas_re_init_req))(pm8001_ha); } } else { } i = 0; goto ldv_45962; ldv_45961: { (*(((pm8001_ha->chip)->dispatch)->phy_start_req))(pm8001_ha, (int )((u8 )i)); i = i + 1; } ldv_45962: ; if ((unsigned int )i < (unsigned int )(pm8001_ha->chip)->n_phy) { goto ldv_45961; } else { } return; } } int pm8001_scan_finished(struct Scsi_Host *shost , unsigned long time ) { struct sas_ha_struct *ha ; { ha = *((struct sas_ha_struct **)(& shost->hostdata)); if (time <= 249UL) { return (0); } else { } { sas_drain_work(ha); } return (1); } } static int pm8001_task_prep_smp(struct pm8001_hba_info *pm8001_ha , struct pm8001_ccb_info *ccb ) { int tmp ; { { tmp = (*(((pm8001_ha->chip)->dispatch)->smp_req))(pm8001_ha, ccb); } return (tmp); } } u32 pm8001_get_ncq_tag(struct sas_task *task , u32 *tag ) { struct ata_queued_cmd *qc ; { qc = (struct ata_queued_cmd *)task->uldd_task; if ((unsigned long )qc != (unsigned long )((struct ata_queued_cmd *)0)) { if ((unsigned int )qc->tf.command - 96U <= 1U) { *tag = qc->tag; return (1U); } else { } } else { } return (0U); } } static int pm8001_task_prep_ata(struct pm8001_hba_info *pm8001_ha , struct pm8001_ccb_info *ccb ) { int tmp ; { { tmp = (*(((pm8001_ha->chip)->dispatch)->sata_req))(pm8001_ha, ccb); } return (tmp); } } static int pm8001_task_prep_ssp_tm(struct pm8001_hba_info *pm8001_ha , struct pm8001_ccb_info *ccb , struct pm8001_tmf_task *tmf ) { int tmp ; { { tmp = (*(((pm8001_ha->chip)->dispatch)->ssp_tm_req))(pm8001_ha, ccb, tmf); } return (tmp); } } static int pm8001_task_prep_ssp(struct pm8001_hba_info *pm8001_ha , struct pm8001_ccb_info *ccb ) { int tmp ; { { tmp = (*(((pm8001_ha->chip)->dispatch)->ssp_io_req))(pm8001_ha, ccb); } return (tmp); } } static int sas_find_local_port_id(struct domain_device *dev ) { struct domain_device *pdev ; struct domain_device *pdev_p ; { pdev = dev->parent; if ((unsigned long )pdev == (unsigned long )((struct domain_device *)0)) { return ((dev->port)->id); } else { } goto ldv_45997; ldv_45996: pdev_p = pdev->parent; if ((unsigned long )pdev_p == (unsigned long )((struct domain_device *)0)) { return ((pdev->port)->id); } else { } pdev = pdev->parent; ldv_45997: ; if ((unsigned long )pdev != (unsigned long )((struct domain_device *)0)) { goto ldv_45996; } else { } return (0); } } static int pm8001_task_exec(struct sas_task *task , gfp_t gfp_flags , int is_tmf , struct pm8001_tmf_task *tmf ) { struct domain_device *dev ; struct pm8001_hba_info *pm8001_ha ; struct pm8001_device *pm8001_dev ; struct pm8001_port *port ; struct sas_task *t ; struct pm8001_ccb_info *ccb ; u32 tag ; u32 rc ; u32 n_elem ; unsigned long flags ; struct task_status_struct *tsm ; long tmp ; int tmp___0 ; struct task_status_struct *ts ; struct task_status_struct *ts___0 ; int tmp___1 ; int tmp___2 ; int tmp___3 ; int tmp___4 ; int tmp___5 ; int tmp___6 ; int tmp___7 ; int tmp___8 ; long tmp___9 ; int tmp___10 ; { dev = task->dev; port = (struct pm8001_port *)0; t = task; tag = 3735928559U; n_elem = 0U; flags = 0UL; if ((unsigned long )dev->port == (unsigned long )((struct asd_sas_port *)0)) { tsm = & t->task_status; tsm->resp = -1; tsm->stat = 138; if ((unsigned int )dev->dev_type != 5U) { { (*(t->task_done))(t); } } else { } return (0); } else { } { pm8001_ha = pm8001_find_ha_by_dev(task->dev); tmp = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:pm8001_task_exec device \n ", "pm8001_task_exec", 374); } } else { } { ldv___ldv_linux_kernel_locking_spinlock_spin_lock_111(& pm8001_ha->lock); dev = t->dev; pm8001_dev = (struct pm8001_device *)dev->lldd_dev; tmp___0 = sas_find_local_port_id(dev); port = (struct pm8001_port *)(& pm8001_ha->port) + (unsigned long )tmp___0; } if (((unsigned long )pm8001_dev == (unsigned long )((struct pm8001_device *)0) || (unsigned int )pm8001_dev->dev_type == 0U) || (unsigned int )port->port_attached == 0U) { { tmp___1 = sas_protocol_ata(t->task_proto); } if (tmp___1 != 0) { { ts = & t->task_status; ts->resp = -1; ts->stat = 138; ldv_spin_unlock_irqrestore_109(& pm8001_ha->lock, flags); (*(t->task_done))(t); ldv___ldv_linux_kernel_locking_spinlock_spin_lock_113(& pm8001_ha->lock); } goto ldv_46018; } else { { ts___0 = & t->task_status; ts___0->resp = -1; ts___0->stat = 138; (*(t->task_done))(t); } goto ldv_46018; } } else { } { tmp___2 = pm8001_tag_alloc(pm8001_ha, & tag); rc = (u32 )tmp___2; } if (rc != 0U) { goto err_out; } else { } { ccb = pm8001_ha->ccb_info + (unsigned long )tag; tmp___4 = sas_protocol_ata(t->task_proto); } if (tmp___4 == 0) { if (t->num_scatter != 0) { { tmp___3 = dma_map_sg_attrs(pm8001_ha->dev, t->scatter, t->num_scatter, (enum dma_data_direction )t->data_dir, (struct dma_attrs *)0); n_elem = (u32 )tmp___3; } if (n_elem == 0U) { rc = 4294967284U; goto err_out_tag; } else { } } else { } } else { n_elem = (u32 )t->num_scatter; } t->lldd_task = (void *)ccb; ccb->n_elem = n_elem; ccb->ccb_tag = tag; ccb->task = t; ccb->device = pm8001_dev; { if ((unsigned int )t->task_proto == 2U) { goto case_2; } else { } if ((unsigned int )t->task_proto == 8U) { goto case_8; } else { } if ((unsigned int )t->task_proto == 1U) { goto case_1; } else { } if ((unsigned int )t->task_proto == 4U) { goto case_4; } else { } goto switch_default; case_2: /* CIL Label */ { tmp___5 = pm8001_task_prep_smp(pm8001_ha, ccb); rc = (u32 )tmp___5; } goto ldv_46023; case_8: /* CIL Label */ ; if (is_tmf != 0) { { tmp___6 = pm8001_task_prep_ssp_tm(pm8001_ha, ccb, tmf); rc = (u32 )tmp___6; } } else { { tmp___7 = pm8001_task_prep_ssp(pm8001_ha, ccb); rc = (u32 )tmp___7; } } goto ldv_46023; case_1: /* CIL Label */ ; case_4: /* CIL Label */ { tmp___8 = pm8001_task_prep_ata(pm8001_ha, ccb); rc = (u32 )tmp___8; } goto ldv_46023; switch_default: /* CIL Label */ { dev_printk("\v", (struct device const *)pm8001_ha->dev, "unknown sas_task proto: 0x%x\n", (unsigned int )t->task_proto); rc = 4294967274U; } goto ldv_46023; switch_break: /* CIL Label */ ; } ldv_46023: ; if (rc != 0U) { { tmp___9 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___9 != 0L) { { printk("\016pm80xx %s %d:rc is %x\n", "pm8001_task_exec", 448, rc); } } else { } goto err_out_tag; } else { } { ldv_spin_lock_114(& t->task_state_lock); t->task_state_flags = t->task_state_flags | 16U; ldv_spin_unlock_115(& t->task_state_lock); pm8001_dev->running_req = pm8001_dev->running_req + 1U; } ldv_46018: rc = 0U; goto out_done; err_out_tag: { pm8001_tag_free(pm8001_ha, tag); } err_out: { dev_printk("\v", (struct device const *)pm8001_ha->dev, "pm8001 exec failed[%d]!\n", rc); tmp___10 = sas_protocol_ata(t->task_proto); } if (tmp___10 == 0) { if (n_elem != 0U) { { dma_unmap_sg_attrs(pm8001_ha->dev, t->scatter, (int )n_elem, (enum dma_data_direction )t->data_dir, (struct dma_attrs *)0); } } else { } } else { } out_done: { ldv_spin_unlock_irqrestore_109(& pm8001_ha->lock, flags); } return ((int )rc); } } int pm8001_queue_command(struct sas_task *task , gfp_t gfp_flags ) { int tmp ; { { tmp = pm8001_task_exec(task, gfp_flags, 0, (struct pm8001_tmf_task *)0); } return (tmp); } } void pm8001_ccb_task_free(struct pm8001_hba_info *pm8001_ha , struct sas_task *task , struct pm8001_ccb_info *ccb , u32 ccb_idx ) { int tmp ; { if ((unsigned long )ccb->task == (unsigned long )((struct sas_task *)0)) { return; } else { } { tmp = sas_protocol_ata(task->task_proto); } if (tmp == 0) { if (ccb->n_elem != 0U) { { dma_unmap_sg_attrs(pm8001_ha->dev, task->scatter, task->num_scatter, (enum dma_data_direction )task->data_dir, (struct dma_attrs *)0); } } else { } } else { } { if ((unsigned int )task->task_proto == 2U) { goto case_2; } else { } if ((unsigned int )task->task_proto == 1U) { goto case_1; } else { } if ((unsigned int )task->task_proto == 4U) { goto case_4; } else { } if ((unsigned int )task->task_proto == 8U) { goto case_8; } else { } goto switch_default; case_2: /* CIL Label */ { dma_unmap_sg_attrs(pm8001_ha->dev, & task->__annonCompField95.smp_task.smp_resp, 1, 2, (struct dma_attrs *)0); dma_unmap_sg_attrs(pm8001_ha->dev, & task->__annonCompField95.smp_task.smp_req, 1, 1, (struct dma_attrs *)0); } goto ldv_46040; case_1: /* CIL Label */ ; case_4: /* CIL Label */ ; case_8: /* CIL Label */ ; switch_default: /* CIL Label */ ; goto ldv_46040; switch_break: /* CIL Label */ ; } ldv_46040: { task->lldd_task = (void *)0; ccb->task = (struct sas_task *)0; ccb->ccb_tag = 4294967295U; ccb->open_retry = 0U; pm8001_tag_free(pm8001_ha, ccb_idx); } return; } } struct pm8001_device *pm8001_alloc_dev(struct pm8001_hba_info *pm8001_ha ) { u32 dev ; long tmp ; { dev = 0U; goto ldv_46050; ldv_46049: ; if ((unsigned int )(pm8001_ha->devices + (unsigned long )dev)->dev_type == 0U) { (pm8001_ha->devices + (unsigned long )dev)->id = dev; return (pm8001_ha->devices + (unsigned long )dev); } else { } dev = dev + 1U; ldv_46050: ; if (dev <= 2047U) { goto ldv_46049; } else { } if (dev == 2048U) { { tmp = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:max support %d devices, ignore ..\n", "pm8001_alloc_dev", 539, 2048); } } else { } } else { } return ((struct pm8001_device *)0); } } struct pm8001_device *pm8001_find_dev(struct pm8001_hba_info *pm8001_ha , u32 device_id ) { u32 dev ; long tmp ; { dev = 0U; goto ldv_46059; ldv_46058: ; if ((pm8001_ha->devices + (unsigned long )dev)->device_id == device_id) { return (pm8001_ha->devices + (unsigned long )dev); } else { } dev = dev + 1U; ldv_46059: ; if (dev <= 2047U) { goto ldv_46058; } else { } if (dev == 2048U) { { tmp = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:NO MATCHING DEVICE FOUND !!!\n", "pm8001_find_dev", 557); } } else { } } else { } return ((struct pm8001_device *)0); } } static void pm8001_free_dev(struct pm8001_device *pm8001_dev ) { u32 id ; { { id = pm8001_dev->id; __memset((void *)pm8001_dev, 0, 48UL); pm8001_dev->id = id; pm8001_dev->dev_type = 0; pm8001_dev->device_id = 2048U; pm8001_dev->sas_device = (struct domain_device *)0; } return; } } static int pm8001_dev_found_notify(struct domain_device *dev ) { unsigned long flags ; int res ; struct pm8001_hba_info *pm8001_ha ; struct domain_device *parent_dev ; struct pm8001_device *pm8001_device ; struct completion completion ; u32 flag ; int phy_id ; struct ex_phy *phy ; __u64 tmp ; __u64 tmp___0 ; __u64 tmp___1 ; __u64 tmp___2 ; long tmp___3 ; long tmp___4 ; { { flags = 0UL; res = 0; pm8001_ha = (struct pm8001_hba_info *)0; parent_dev = dev->parent; ldv_init_completion_100(& completion); completion = completion; flag = 0U; pm8001_ha = pm8001_find_ha_by_dev(dev); ldv___ldv_linux_kernel_locking_spinlock_spin_lock_118(& pm8001_ha->lock); pm8001_device = pm8001_alloc_dev(pm8001_ha); } if ((unsigned long )pm8001_device == (unsigned long )((struct pm8001_device *)0)) { res = -1; goto found_out; } else { } pm8001_device->sas_device = dev; dev->lldd_dev = (void *)pm8001_device; pm8001_device->dev_type = dev->dev_type; pm8001_device->dcompletion = & completion; if ((unsigned long )parent_dev != (unsigned long )((struct domain_device *)0) && (unsigned int )parent_dev->dev_type - 2U <= 1U) { phy_id = 0; goto ldv_46082; ldv_46081: { phy = parent_dev->__annonCompField94.ex_dev.ex_phy + (unsigned long )phy_id; tmp = __fswab64(*((__be64 *)(& phy->attached_sas_addr))); tmp___0 = __fswab64(*((__be64 *)(& dev->sas_addr))); } if (tmp == tmp___0) { pm8001_device->attached_phy = (u32 )phy_id; goto ldv_46080; } else { } phy_id = phy_id + 1; ldv_46082: ; if (phy_id < (int )parent_dev->__annonCompField94.ex_dev.num_phys) { goto ldv_46081; } else { } ldv_46080: ; if (phy_id == (int )parent_dev->__annonCompField94.ex_dev.num_phys) { { tmp___3 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___3 != 0L) { { tmp___1 = __fswab64(*((__be64 *)(& parent_dev->sas_addr))); tmp___2 = __fswab64(*((__be64 *)(& dev->sas_addr))); printk("\016pm80xx %s %d:Error: no attached dev:%016llx at ex:%016llx.\n", "pm8001_dev_found_notify", 621, tmp___2, tmp___1); } } else { } res = -1; } else { } } else if ((unsigned int )dev->dev_type == 5U) { pm8001_device->attached_phy = (u32 )(dev->rphy)->identify.phy_identifier; flag = 1U; } else { } { tmp___4 = ldv__builtin_expect((pm8001_ha->logging_level & 4U) != 0U, 0L); } if (tmp___4 != 0L) { { printk("\016pm80xx %s %d:Found device\n", "pm8001_dev_found_notify", 631); } } else { } { (*(((pm8001_ha->chip)->dispatch)->reg_dev_req))(pm8001_ha, pm8001_device, flag); ldv_spin_unlock_irqrestore_109(& pm8001_ha->lock, flags); ldv_wait_for_completion_120(& completion); } if ((unsigned int )dev->dev_type == 1U) { { msleep(50U); } } else { } pm8001_ha->flags = 2UL; return (0); found_out: { ldv_spin_unlock_irqrestore_109(& pm8001_ha->lock, flags); } return (res); } } int pm8001_dev_found(struct domain_device *dev ) { int tmp ; { { tmp = pm8001_dev_found_notify(dev); } return (tmp); } } void pm8001_task_done(struct sas_task *task ) { int tmp ; { { tmp = ldv_del_timer_122(& (task->slow_task)->timer); } if (tmp == 0) { return; } else { } { complete(& (task->slow_task)->completion); } return; } } static void pm8001_tmf_timedout(unsigned long data ) { struct sas_task *task ; { { task = (struct sas_task *)data; task->task_state_flags = task->task_state_flags | 4U; complete(& (task->slow_task)->completion); } return; } } static int pm8001_exec_internal_tmf_task(struct domain_device *dev , void *parameter , u32 para_len , struct pm8001_tmf_task *tmf ) { int res ; int retry ; struct sas_task *task ; struct pm8001_hba_info *pm8001_ha ; struct pm8001_hba_info *tmp ; struct pm8001_device *pm8001_dev ; struct completion completion_setstate ; long tmp___0 ; long tmp___1 ; long tmp___2 ; __u64 tmp___3 ; long tmp___4 ; long tmp___5 ; { { task = (struct sas_task *)0; tmp = pm8001_find_ha_by_dev(dev); pm8001_ha = tmp; pm8001_dev = (struct pm8001_device *)dev->lldd_dev; ldv_init_completion_123(& completion_setstate); completion_setstate = completion_setstate; retry = 0; } goto ldv_46111; ldv_46110: { task = sas_alloc_slow_task(208U); } if ((unsigned long )task == (unsigned long )((struct sas_task *)0)) { return (-12); } else { } { task->dev = dev; task->task_proto = dev->tproto; __memcpy((void *)(& task->__annonCompField95.ssp_task), (void const *)parameter, (size_t )para_len); task->task_done = & pm8001_task_done; (task->slow_task)->timer.data = (unsigned long )task; (task->slow_task)->timer.function = & pm8001_tmf_timedout; (task->slow_task)->timer.expires = (unsigned long )jiffies + 5000UL; add_timer(& (task->slow_task)->timer); res = pm8001_task_exec(task, 208U, 1, tmf); } if (res != 0) { { ldv_del_timer_124(& (task->slow_task)->timer); tmp___0 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___0 != 0L) { { printk("\016pm80xx %s %d:Executing internal task failed\n", "pm8001_exec_internal_tmf_task", 705); } } else { } goto ex_err; } else { } { ldv_wait_for_completion_125(& (task->slow_task)->completion); } if (pm8001_ha->chip_id != 0U) { { pm8001_dev->setds_completion = & completion_setstate; (*(((pm8001_ha->chip)->dispatch)->set_dev_state_req))(pm8001_ha, pm8001_dev, 1U); ldv_wait_for_completion_126(& completion_setstate); } } else { } res = -5; if ((task->task_state_flags & 4U) != 0U) { if ((task->task_state_flags & 2U) == 0U) { { tmp___1 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___1 != 0L) { { printk("\016pm80xx %s %d:TMF task[%x]timeout.\n", "pm8001_exec_internal_tmf_task", 721, (int )tmf->tmf); } } else { } goto ex_err; } else { } } else { } if ((int )task->task_status.resp == 0 && (unsigned int )task->task_status.stat == 0U) { res = 0; goto ldv_46109; } else { } if ((int )task->task_status.resp == 0 && (unsigned int )task->task_status.stat == 129U) { res = (int )task->task_status.residual; goto ldv_46109; } else { } if ((int )task->task_status.resp == 0 && (unsigned int )task->task_status.stat == 130U) { { tmp___2 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___2 != 0L) { { printk("\016pm80xx %s %d:Blocked task error.\n", "pm8001_exec_internal_tmf_task", 743); } } else { } res = -90; goto ldv_46109; } else { { tmp___4 = ldv__builtin_expect((pm8001_ha->logging_level & 16U) != 0U, 0L); } if (tmp___4 != 0L) { { tmp___3 = __fswab64(*((__be64 *)(& dev->sas_addr))); printk("\016pm80xx %s %d: Task to dev %016llx response:0x%x status 0x%x\n", "pm8001_exec_internal_tmf_task", 752, tmp___3, (int )task->task_status.resp, (unsigned int )task->task_status.stat); } } else { } { sas_free_task(task); task = (struct sas_task *)0; } } retry = retry + 1; ldv_46111: ; if (retry <= 2) { goto ldv_46110; } else { } ldv_46109: ; ex_err: { tmp___5 = ldv__builtin_expect((long )(retry == 3 && (unsigned long )task != (unsigned long )((struct sas_task *)0)), 0L); } if (tmp___5 != 0L) { { __asm__ volatile ("1:\tud2\n.pushsection __bug_table,\"a\"\n2:\t.long 1b - 2b, %c0 - 2b\n\t.word %c1, 0\n\t.org 2b+%c2\n.popsection": : "i" ((char *)"drivers/scsi/pm8001/pm8001_sas.c"), "i" (758), "i" (12UL)); __builtin_unreachable(); } } else { } { sas_free_task(task); } return (res); } } static int pm8001_exec_internal_task_abort(struct pm8001_hba_info *pm8001_ha , struct pm8001_device *pm8001_dev , struct domain_device *dev , u32 flag , u32 task_tag ) { int res ; int retry ; u32 ccb_tag ; struct pm8001_ccb_info *ccb ; struct sas_task *task ; long tmp ; long tmp___0 ; __u64 tmp___1 ; long tmp___2 ; long tmp___3 ; { task = (struct sas_task *)0; retry = 0; goto ldv_46128; ldv_46127: { task = sas_alloc_slow_task(208U); } if ((unsigned long )task == (unsigned long )((struct sas_task *)0)) { return (-12); } else { } { task->dev = dev; task->task_proto = dev->tproto; task->task_done = & pm8001_task_done; (task->slow_task)->timer.data = (unsigned long )task; (task->slow_task)->timer.function = & pm8001_tmf_timedout; (task->slow_task)->timer.expires = (unsigned long )jiffies + 5000UL; add_timer(& (task->slow_task)->timer); res = pm8001_tag_alloc(pm8001_ha, & ccb_tag); } if (res != 0) { return (res); } else { } { ccb = pm8001_ha->ccb_info + (unsigned long )ccb_tag; ccb->device = pm8001_dev; ccb->ccb_tag = ccb_tag; ccb->task = task; res = (*(((pm8001_ha->chip)->dispatch)->task_abort))(pm8001_ha, pm8001_dev, (int )((u8 )flag), task_tag, ccb_tag); } if (res != 0) { { ldv_del_timer_127(& (task->slow_task)->timer); tmp = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:Executing internal task failed\n", "pm8001_exec_internal_task_abort", 801); } } else { } goto ex_err; } else { } { ldv_wait_for_completion_128(& (task->slow_task)->completion); res = 5; } if ((task->task_state_flags & 4U) != 0U) { if ((task->task_state_flags & 2U) == 0U) { { tmp___0 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___0 != 0L) { { printk("\016pm80xx %s %d:TMF task timeout.\n", "pm8001_exec_internal_task_abort", 810); } } else { } goto ex_err; } else { } } else { } if ((int )task->task_status.resp == 0 && (unsigned int )task->task_status.stat == 0U) { res = 0; goto ldv_46126; } else { { tmp___2 = ldv__builtin_expect((pm8001_ha->logging_level & 16U) != 0U, 0L); } if (tmp___2 != 0L) { { tmp___1 = __fswab64(*((__be64 *)(& dev->sas_addr))); printk("\016pm80xx %s %d: Task to dev %016llx response: 0x%x status 0x%x\n", "pm8001_exec_internal_task_abort", 826, tmp___1, (int )task->task_status.resp, (unsigned int )task->task_status.stat); } } else { } { sas_free_task(task); task = (struct sas_task *)0; } } retry = retry + 1; ldv_46128: ; if (retry <= 2) { goto ldv_46127; } else { } ldv_46126: ; ex_err: { tmp___3 = ldv__builtin_expect((long )(retry == 3 && (unsigned long )task != (unsigned long )((struct sas_task *)0)), 0L); } if (tmp___3 != 0L) { { __asm__ volatile ("1:\tud2\n.pushsection __bug_table,\"a\"\n2:\t.long 1b - 2b, %c0 - 2b\n\t.word %c1, 0\n\t.org 2b+%c2\n.popsection": : "i" ((char *)"drivers/scsi/pm8001/pm8001_sas.c"), "i" (832), "i" (12UL)); __builtin_unreachable(); } } else { } { sas_free_task(task); } return (res); } } static void pm8001_dev_gone_notify(struct domain_device *dev ) { unsigned long flags ; struct pm8001_hba_info *pm8001_ha ; struct pm8001_device *pm8001_dev ; u32 device_id ; long tmp ; long tmp___0 ; { { flags = 0UL; pm8001_dev = (struct pm8001_device *)dev->lldd_dev; pm8001_ha = pm8001_find_ha_by_dev(dev); ldv___ldv_linux_kernel_locking_spinlock_spin_lock_129(& pm8001_ha->lock); } if ((unsigned long )pm8001_dev != (unsigned long )((struct pm8001_device *)0)) { { device_id = pm8001_dev->device_id; tmp = ldv__builtin_expect((pm8001_ha->logging_level & 4U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:found dev[%d:%x] is gone.\n", "pm8001_dev_gone_notify", 854, pm8001_dev->device_id, (unsigned int )pm8001_dev->dev_type); } } else { } if (pm8001_dev->running_req != 0U) { { ldv_spin_unlock_irqrestore_109(& pm8001_ha->lock, flags); pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev, dev, 1U, 0U); ldv___ldv_linux_kernel_locking_spinlock_spin_lock_131(& pm8001_ha->lock); } } else { } { (*(((pm8001_ha->chip)->dispatch)->dereg_dev_req))(pm8001_ha, device_id); pm8001_free_dev(pm8001_dev); } } else { { tmp___0 = ldv__builtin_expect((pm8001_ha->logging_level & 4U) != 0U, 0L); } if (tmp___0 != 0L) { { printk("\016pm80xx %s %d:Found dev has gone.\n", "pm8001_dev_gone_notify", 865); } } else { } } { dev->lldd_dev = (void *)0; ldv_spin_unlock_irqrestore_109(& pm8001_ha->lock, flags); } return; } } void pm8001_dev_gone(struct domain_device *dev ) { { { pm8001_dev_gone_notify(dev); } return; } } static int pm8001_issue_ssp_tmf(struct domain_device *dev , u8 *lun , struct pm8001_tmf_task *tmf ) { struct sas_ssp_task ssp_task ; int tmp ; { if (((unsigned int )dev->tproto & 8U) == 0U) { return (4); } else { } { strncpy((char *)(& ssp_task.LUN), (char const *)lun, 8UL); tmp = pm8001_exec_internal_tmf_task(dev, (void *)(& ssp_task), 32U, tmf); } return (tmp); } } void pm8001_open_reject_retry(struct pm8001_hba_info *pm8001_ha , struct sas_task *task_to_close , struct pm8001_device *device_to_close ) { int i ; unsigned long flags ; struct sas_task *task ; struct task_status_struct *ts ; struct pm8001_device *pm8001_dev ; unsigned long flags1 ; u32 tag ; struct pm8001_ccb_info *ccb ; uintptr_t d ; long tmp ; { if ((unsigned long )pm8001_ha == (unsigned long )((struct pm8001_hba_info *)0)) { return; } else { } { ldv___ldv_linux_kernel_locking_spinlock_spin_lock_133(& pm8001_ha->lock); i = 0; } goto ldv_46162; ldv_46161: ccb = pm8001_ha->ccb_info + (unsigned long )i; pm8001_dev = ccb->device; if ((unsigned long )pm8001_dev == (unsigned long )((struct pm8001_device *)0) || (unsigned int )pm8001_dev->dev_type == 0U) { goto ldv_46159; } else { } if ((unsigned long )device_to_close == (unsigned long )((struct pm8001_device *)0)) { d = (unsigned long )pm8001_dev - (unsigned long )(& pm8001_ha->devices); if (d % 48UL != 0UL || d > 98303UL) { goto ldv_46159; } else { } } else if ((unsigned long )pm8001_dev != (unsigned long )device_to_close) { goto ldv_46159; } else { } tag = ccb->ccb_tag; if (tag - 1U > 4294967293U) { goto ldv_46159; } else { } task = ccb->task; if ((unsigned long )task == (unsigned long )((struct sas_task *)0) || (unsigned long )task->task_done == (unsigned long )((void (*)(struct sas_task * ))0)) { goto ldv_46159; } else { } if ((unsigned long )task_to_close != (unsigned long )((struct sas_task *)0) && (unsigned long )task != (unsigned long )task_to_close) { goto ldv_46159; } else { } ts = & task->task_status; ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 18; if ((unsigned long )pm8001_dev != (unsigned long )((struct pm8001_device *)0)) { pm8001_dev->running_req = pm8001_dev->running_req - 1U; } else { } { ldv___ldv_linux_kernel_locking_spinlock_spin_lock_134(& task->task_state_lock); task->task_state_flags = task->task_state_flags & 4294967294U; task->task_state_flags = task->task_state_flags & 4294967279U; task->task_state_flags = task->task_state_flags | 2U; tmp = ldv__builtin_expect((task->task_state_flags & 4U) != 0U, 0L); } if (tmp != 0L) { { ldv_spin_unlock_irqrestore_135(& task->task_state_lock, flags1); pm8001_ccb_task_free(pm8001_ha, task, ccb, tag); } } else { { ldv_spin_unlock_irqrestore_135(& task->task_state_lock, flags1); pm8001_ccb_task_free(pm8001_ha, task, ccb, tag); __asm__ volatile ("mfence": : : "memory"); ldv_spin_unlock_irqrestore_109(& pm8001_ha->lock, flags); (*(task->task_done))(task); ldv___ldv_linux_kernel_locking_spinlock_spin_lock_138(& pm8001_ha->lock); } } ldv_46159: i = i + 1; ldv_46162: ; if (i <= 511) { goto ldv_46161; } else { } { ldv_spin_unlock_irqrestore_109(& pm8001_ha->lock, flags); } return; } } int pm8001_I_T_nexus_reset(struct domain_device *dev ) { int rc ; struct pm8001_device *pm8001_dev ; struct pm8001_hba_info *pm8001_ha ; struct sas_phy *phy ; struct completion completion_setstate ; int tmp ; int tmp___0 ; long tmp___1 ; { rc = 5; if ((unsigned long )dev == (unsigned long )((struct domain_device *)0) || (unsigned long )dev->lldd_dev == (unsigned long )((void *)0)) { return (-19); } else { } { pm8001_dev = (struct pm8001_device *)dev->lldd_dev; pm8001_ha = pm8001_find_ha_by_dev(dev); phy = sas_get_local_phy(dev); tmp___0 = dev_is_sata(dev); } if (tmp___0 != 0) { { ldv_init_completion_123(& completion_setstate); completion_setstate = completion_setstate; tmp = scsi_is_host_device((struct device const *)phy->dev.parent); } if (tmp != 0) { rc = 0; goto out; } else { } { rc = sas_phy_reset(phy, 1); msleep(2000U); rc = pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev, dev, 1U, 0U); pm8001_dev->setds_completion = & completion_setstate; rc = (*(((pm8001_ha->chip)->dispatch)->set_dev_state_req))(pm8001_ha, pm8001_dev, 1U); ldv_wait_for_completion_141(& completion_setstate); } } else { { rc = sas_phy_reset(phy, 1); msleep(2000U); } } { tmp___1 = ldv__builtin_expect((pm8001_ha->logging_level & 16U) != 0U, 0L); } if (tmp___1 != 0L) { { printk("\016pm80xx %s %d: for device[%x]:rc=%d\n", "pm8001_I_T_nexus_reset", 996, pm8001_dev->device_id, rc); } } else { } out: { sas_put_local_phy(phy); } return (rc); } } int pm8001_I_T_nexus_event_handler(struct domain_device *dev ) { int rc ; struct pm8001_device *pm8001_dev ; struct pm8001_hba_info *pm8001_ha ; struct sas_phy *phy ; u32 device_id ; long tmp ; struct completion completion_setstate ; int tmp___0 ; int tmp___1 ; long tmp___2 ; { rc = 5; device_id = 0U; if ((unsigned long )dev == (unsigned long )((struct domain_device *)0) || (unsigned long )dev->lldd_dev == (unsigned long )((void *)0)) { return (-1); } else { } { pm8001_dev = (struct pm8001_device *)dev->lldd_dev; device_id = pm8001_dev->device_id; pm8001_ha = pm8001_find_ha_by_dev(dev); tmp = ldv__builtin_expect((pm8001_ha->logging_level & 16U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:I_T_Nexus handler invoked !!", "pm8001_I_T_nexus_event_handler", 1022); } } else { } { phy = sas_get_local_phy(dev); tmp___1 = dev_is_sata(dev); } if (tmp___1 != 0) { { ldv_init_completion_123(& completion_setstate); completion_setstate = completion_setstate; tmp___0 = scsi_is_host_device((struct device const *)phy->dev.parent); } if (tmp___0 != 0) { rc = 0; goto out; } else { } { rc = pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev, dev, 1U, 0U); msleep(100U); pm8001_dev_gone_notify(dev); msleep(200U); rc = sas_phy_reset(phy, 1); msleep(2000U); pm8001_dev->setds_completion = & completion_setstate; ldv_wait_for_completion_143(& completion_setstate); } } else { { rc = pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev, dev, 1U, 0U); msleep(100U); pm8001_dev_gone_notify(dev); msleep(200U); rc = sas_phy_reset(phy, 1); msleep(2000U); } } { tmp___2 = ldv__builtin_expect((pm8001_ha->logging_level & 16U) != 0U, 0L); } if (tmp___2 != 0L) { { printk("\016pm80xx %s %d: for device[%x]:rc=%d\n", "pm8001_I_T_nexus_event_handler", 1062, pm8001_dev->device_id, rc); } } else { } out: { sas_put_local_phy(phy); } return (rc); } } int pm8001_lu_reset(struct domain_device *dev , u8 *lun ) { int rc ; struct pm8001_tmf_task tmf_task ; struct pm8001_device *pm8001_dev ; struct pm8001_hba_info *pm8001_ha ; struct pm8001_hba_info *tmp ; struct completion completion_setstate ; struct sas_phy *phy ; struct sas_phy *tmp___0 ; int tmp___1 ; long tmp___2 ; { { rc = 5; pm8001_dev = (struct pm8001_device *)dev->lldd_dev; tmp = pm8001_find_ha_by_dev(dev); pm8001_ha = tmp; ldv_init_completion_123(& completion_setstate); completion_setstate = completion_setstate; tmp___1 = dev_is_sata(dev); } if (tmp___1 != 0) { { tmp___0 = sas_get_local_phy(dev); phy = tmp___0; rc = pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev, dev, 1U, 0U); rc = sas_phy_reset(phy, 1); sas_put_local_phy(phy); pm8001_dev->setds_completion = & completion_setstate; rc = (*(((pm8001_ha->chip)->dispatch)->set_dev_state_req))(pm8001_ha, pm8001_dev, 1U); ldv_wait_for_completion_145(& completion_setstate); } } else { { tmf_task.tmf = 8U; rc = pm8001_issue_ssp_tmf(dev, lun, & tmf_task); } } { tmp___2 = ldv__builtin_expect((pm8001_ha->logging_level & 16U) != 0U, 0L); } if (tmp___2 != 0L) { { printk("\016pm80xx %s %d:for device[%x]:rc=%d\n", "pm8001_lu_reset", 1092, pm8001_dev->device_id, rc); } } else { } return (rc); } } int pm8001_query_task(struct sas_task *task ) { u32 tag ; int i ; struct scsi_lun lun ; struct pm8001_tmf_task tmf_task ; int rc ; long tmp ; long tmp___0 ; int tmp___1 ; long tmp___2 ; struct scsi_cmnd *cmnd ; struct domain_device *dev ; struct pm8001_hba_info *pm8001_ha ; struct pm8001_hba_info *tmp___3 ; long tmp___4 ; long tmp___5 ; long tmp___6 ; { { tag = 3735928559U; i = 0; rc = 5; tmp = ldv__builtin_expect((unsigned long )task == (unsigned long )((struct sas_task *)0), 0L); } if (tmp != 0L) { tmp___1 = 1; } else { { tmp___0 = ldv__builtin_expect((unsigned long )task->lldd_task == (unsigned long )((void *)0), 0L); } if (tmp___0 != 0L) { tmp___1 = 1; } else { tmp___1 = 0; } } if (tmp___1 != 0) { return (rc); } else { { tmp___2 = ldv__builtin_expect((unsigned long )task->dev == (unsigned long )((struct domain_device *)0), 0L); } if (tmp___2 != 0L) { return (rc); } else { } } if (((unsigned int )task->task_proto & 8U) != 0U) { { cmnd = (struct scsi_cmnd *)task->uldd_task; dev = task->dev; tmp___3 = pm8001_find_ha_by_dev(dev); pm8001_ha = tmp___3; int_to_scsilun((cmnd->device)->lun, & lun); rc = pm8001_find_tag(task, & tag); } if (rc == 0) { rc = 5; return (rc); } else { } { tmp___4 = ldv__builtin_expect((pm8001_ha->logging_level & 16U) != 0U, 0L); } if (tmp___4 != 0L) { { printk("\016pm80xx %s %d:Query:[", "pm8001_query_task", 1119); } } else { } i = 0; goto ldv_46212; ldv_46211: { printk("\016%02x ", (int )*(cmnd->cmnd + (unsigned long )i)); i = i + 1; } ldv_46212: ; if (i <= 15) { goto ldv_46211; } else { } { printk("\016]\n"); tmf_task.tmf = 128U; tmf_task.tag_of_task_to_be_managed = tag; rc = pm8001_issue_ssp_tmf(dev, (u8 *)(& lun.scsi_lun), & tmf_task); } { if (rc == 8) { goto case_8; } else { } if (rc == 5) { goto case_5; } else { } if (rc == 0) { goto case_0; } else { } goto switch_break; case_8: /* CIL Label */ { tmp___5 = ldv__builtin_expect((pm8001_ha->logging_level & 16U) != 0U, 0L); } if (tmp___5 != 0L) { { printk("\016pm80xx %s %d:The task is still in Lun\n", "pm8001_query_task", 1131); } } else { } goto ldv_46215; case_5: /* CIL Label */ ; case_0: /* CIL Label */ { tmp___6 = ldv__builtin_expect((pm8001_ha->logging_level & 16U) != 0U, 0L); } if (tmp___6 != 0L) { { printk("\016pm80xx %s %d:The task is not in Lun or failed, reset the phy\n", "pm8001_query_task", 1138); } } else { } goto ldv_46215; switch_break: /* CIL Label */ ; } ldv_46215: ; } else { } { printk("\016pm80xx %s %d::rc= %d\n", "pm8001_query_task", 1142, rc); } return (rc); } } int pm8001_abort_task(struct sas_task *task ) { unsigned long flags ; u32 tag ; u32 device_id ; struct domain_device *dev ; struct pm8001_hba_info *pm8001_ha ; struct pm8001_ccb_info *ccb ; struct scsi_lun lun ; struct pm8001_device *pm8001_dev ; struct pm8001_tmf_task tmf_task ; int rc ; long tmp ; long tmp___0 ; int tmp___1 ; long tmp___2 ; struct scsi_cmnd *cmnd ; long tmp___3 ; { { tag = 3735928559U; pm8001_ha = (struct pm8001_hba_info *)0; rc = 5; tmp = ldv__builtin_expect((unsigned long )task == (unsigned long )((struct sas_task *)0), 0L); } if (tmp != 0L) { tmp___1 = 1; } else { { tmp___0 = ldv__builtin_expect((unsigned long )task->lldd_task == (unsigned long )((void *)0), 0L); } if (tmp___0 != 0L) { tmp___1 = 1; } else { tmp___1 = 0; } } if (tmp___1 != 0) { return (rc); } else { { tmp___2 = ldv__builtin_expect((unsigned long )task->dev == (unsigned long )((struct domain_device *)0), 0L); } if (tmp___2 != 0L) { return (rc); } else { } } { ldv___ldv_linux_kernel_locking_spinlock_spin_lock_146(& task->task_state_lock); } if ((task->task_state_flags & 2U) != 0U) { { ldv_spin_unlock_irqrestore_135(& task->task_state_lock, flags); rc = 0; } goto out; } else { } { ldv_spin_unlock_irqrestore_135(& task->task_state_lock, flags); } if (((unsigned int )task->task_proto & 8U) != 0U) { { cmnd = (struct scsi_cmnd *)task->uldd_task; dev = task->dev; ccb = (struct pm8001_ccb_info *)task->lldd_task; pm8001_dev = (struct pm8001_device *)dev->lldd_dev; pm8001_ha = pm8001_find_ha_by_dev(dev); int_to_scsilun((cmnd->device)->lun, & lun); rc = pm8001_find_tag(task, & tag); } if (rc == 0) { { printk("\016No such tag in %s\n", "pm8001_abort_task"); rc = 5; } return (rc); } else { } { device_id = pm8001_dev->device_id; tmp___3 = ldv__builtin_expect((pm8001_ha->logging_level & 16U) != 0U, 0L); } if (tmp___3 != 0L) { { printk("\016pm80xx %s %d:abort io to deviceid= %d\n", "pm8001_abort_task", 1183, device_id); } } else { } { tmf_task.tmf = 1U; tmf_task.tag_of_task_to_be_managed = tag; rc = pm8001_issue_ssp_tmf(dev, (u8 *)(& lun.scsi_lun), & tmf_task); pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev, pm8001_dev->sas_device, 0U, tag); } } else if (*((unsigned int *)task + 21UL) != 0U) { { dev = task->dev; pm8001_dev = (struct pm8001_device *)dev->lldd_dev; pm8001_ha = pm8001_find_ha_by_dev(dev); rc = pm8001_find_tag(task, & tag); } if (rc == 0) { { printk("\016No such tag in %s\n", "pm8001_abort_task"); rc = 5; } return (rc); } else { } { rc = pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev, pm8001_dev->sas_device, 0U, tag); } } else if (((unsigned int )task->task_proto & 2U) != 0U) { { dev = task->dev; pm8001_dev = (struct pm8001_device *)dev->lldd_dev; pm8001_ha = pm8001_find_ha_by_dev(dev); rc = pm8001_find_tag(task, & tag); } if (rc == 0) { { printk("\016No such tag in %s\n", "pm8001_abort_task"); rc = 5; } return (rc); } else { } { rc = pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev, pm8001_dev->sas_device, 0U, tag); } } else { } out: ; if (rc != 0) { { printk("\016pm80xx %s %d:rc= %d\n", "pm8001_abort_task", 1219, rc); } } else { } return (rc); } } int pm8001_abort_task_set(struct domain_device *dev , u8 *lun ) { int rc ; struct pm8001_tmf_task tmf_task ; { { rc = 5; tmf_task.tmf = 2U; rc = pm8001_issue_ssp_tmf(dev, lun, & tmf_task); } return (rc); } } int pm8001_clear_aca(struct domain_device *dev , u8 *lun ) { int rc ; struct pm8001_tmf_task tmf_task ; { { rc = 5; tmf_task.tmf = 64U; rc = pm8001_issue_ssp_tmf(dev, lun, & tmf_task); } return (rc); } } int pm8001_clear_task_set(struct domain_device *dev , u8 *lun ) { int rc ; struct pm8001_tmf_task tmf_task ; struct pm8001_device *pm8001_dev ; struct pm8001_hba_info *pm8001_ha ; struct pm8001_hba_info *tmp ; long tmp___0 ; { { rc = 5; pm8001_dev = (struct pm8001_device *)dev->lldd_dev; tmp = pm8001_find_ha_by_dev(dev); pm8001_ha = tmp; tmp___0 = ldv__builtin_expect((pm8001_ha->logging_level & 16U) != 0U, 0L); } if (tmp___0 != 0L) { { printk("\016pm80xx %s %d:I_T_L_Q clear task set[%x]\n", "pm8001_clear_task_set", 1253, pm8001_dev->device_id); } } else { } { tmf_task.tmf = 4U; rc = pm8001_issue_ssp_tmf(dev, lun, & tmf_task); } return (rc); } } int ldv_del_timer(int arg0 , struct timer_list *arg1 ) ; void ldv_dispatch_instance_deregister_25_1(struct timer_list *arg0 ) ; int ldv_del_timer(int arg0 , struct timer_list *arg1 ) { struct timer_list *ldv_25_timer_list_timer_list ; { { ldv_25_timer_list_timer_list = arg1; ldv_dispatch_instance_deregister_25_1(ldv_25_timer_list_timer_list); } return (arg0); return (arg0); } } void ldv_dispatch_instance_deregister_25_1(struct timer_list *arg0 ) { { return; } } __inline static void *dma_zalloc_coherent(struct device *dev , size_t size , dma_addr_t *dma_handle , gfp_t flags ) { void *tmp ; { { ldv_check_alloc_flags(flags); tmp = ldv_malloc_unknown_size(); } return (tmp); } } static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_100(spinlock_t *ldv_func_arg1 ) { { { ldv_linux_kernel_locking_spinlock_spin_lock_bitmap_lock_of_pm8001_hba_info(); __ldv_linux_kernel_locking_spinlock_spin_lock(ldv_func_arg1); } return; } } static unsigned long ldv_find_first_zero_bit_101(unsigned long const *addr , unsigned long size ) { unsigned long tmp ; { { tmp = ldv_linux_lib_find_bit_find_first_bit(size); } return (tmp); } } __inline static void ldv_spin_unlock_irqrestore_102(spinlock_t *lock , unsigned long flags ) { { { ldv_linux_kernel_locking_spinlock_spin_unlock_bitmap_lock_of_pm8001_hba_info(); spin_unlock_irqrestore(lock, flags); } return; } } static void ldv_wait_for_completion_105(struct completion *ldv_func_arg1 ) { { { ldv_linux_kernel_sched_completion_wait_for_completion_completion(); wait_for_completion(ldv_func_arg1); } return; } } static void ldv_wait_for_completion_106(struct completion *ldv_func_arg1 ) { { { ldv_linux_kernel_sched_completion_wait_for_completion_completion(); wait_for_completion(ldv_func_arg1); } return; } } static void ldv_wait_for_completion_107(struct completion *ldv_func_arg1 ) { { { ldv_linux_kernel_sched_completion_wait_for_completion_completion(); wait_for_completion(ldv_func_arg1); } return; } } static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_108(spinlock_t *ldv_func_arg1 ) { { { ldv_linux_kernel_locking_spinlock_spin_lock_lock_of_pm8001_hba_info(); __ldv_linux_kernel_locking_spinlock_spin_lock(ldv_func_arg1); } return; } } __inline static void ldv_spin_unlock_irqrestore_109(spinlock_t *lock , unsigned long flags ) { { { ldv_linux_kernel_locking_spinlock_spin_unlock_lock_of_pm8001_hba_info(); spin_unlock_irqrestore(lock, flags); } return; } } static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_111(spinlock_t *ldv_func_arg1 ) { { { ldv_linux_kernel_locking_spinlock_spin_lock_lock_of_pm8001_hba_info(); __ldv_linux_kernel_locking_spinlock_spin_lock(ldv_func_arg1); } return; } } static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_113(spinlock_t *ldv_func_arg1 ) { { { ldv_linux_kernel_locking_spinlock_spin_lock_lock_of_pm8001_hba_info(); __ldv_linux_kernel_locking_spinlock_spin_lock(ldv_func_arg1); } return; } } __inline static void ldv_spin_lock_114(spinlock_t *lock ) { { { ldv_linux_kernel_locking_spinlock_spin_lock_task_state_lock_of_sas_task(); spin_lock(lock); } return; } } __inline static void ldv_spin_unlock_115(spinlock_t *lock ) { { { ldv_linux_kernel_locking_spinlock_spin_unlock_task_state_lock_of_sas_task(); spin_unlock(lock); } return; } } static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_118(spinlock_t *ldv_func_arg1 ) { { { ldv_linux_kernel_locking_spinlock_spin_lock_lock_of_pm8001_hba_info(); __ldv_linux_kernel_locking_spinlock_spin_lock(ldv_func_arg1); } return; } } static void ldv_wait_for_completion_120(struct completion *ldv_func_arg1 ) { { { ldv_linux_kernel_sched_completion_wait_for_completion_completion(); wait_for_completion(ldv_func_arg1); } return; } } static int ldv_del_timer_122(struct timer_list *ldv_func_arg1 ) { ldv_func_ret_type___0 ldv_func_res ; int tmp ; int tmp___0 ; { { tmp = del_timer(ldv_func_arg1); ldv_func_res = tmp; tmp___0 = ldv_del_timer(ldv_func_res, ldv_func_arg1); } return (tmp___0); return (ldv_func_res); } } __inline static void ldv_init_completion_123(struct completion *x ) { { { ldv_linux_kernel_sched_completion_init_completion_completion_setstate(); } return; } } static int ldv_del_timer_124(struct timer_list *ldv_func_arg1 ) { ldv_func_ret_type___1 ldv_func_res ; int tmp ; int tmp___0 ; { { tmp = del_timer(ldv_func_arg1); ldv_func_res = tmp; tmp___0 = ldv_del_timer(ldv_func_res, ldv_func_arg1); } return (tmp___0); return (ldv_func_res); } } static void ldv_wait_for_completion_125(struct completion *ldv_func_arg1 ) { { { ldv_linux_kernel_sched_completion_wait_for_completion_completion_of_sas_task_slow(); wait_for_completion(ldv_func_arg1); } return; } } static void ldv_wait_for_completion_126(struct completion *ldv_func_arg1 ) { { { ldv_linux_kernel_sched_completion_wait_for_completion_completion_setstate(); wait_for_completion(ldv_func_arg1); } return; } } static int ldv_del_timer_127(struct timer_list *ldv_func_arg1 ) { ldv_func_ret_type___5 ldv_func_res ; int tmp ; int tmp___0 ; { { tmp = del_timer(ldv_func_arg1); ldv_func_res = tmp; tmp___0 = ldv_del_timer(ldv_func_res, ldv_func_arg1); } return (tmp___0); return (ldv_func_res); } } static void ldv_wait_for_completion_128(struct completion *ldv_func_arg1 ) { { { ldv_linux_kernel_sched_completion_wait_for_completion_completion_of_sas_task_slow(); wait_for_completion(ldv_func_arg1); } return; } } static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_129(spinlock_t *ldv_func_arg1 ) { { { ldv_linux_kernel_locking_spinlock_spin_lock_lock_of_pm8001_hba_info(); __ldv_linux_kernel_locking_spinlock_spin_lock(ldv_func_arg1); } return; } } static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_131(spinlock_t *ldv_func_arg1 ) { { { ldv_linux_kernel_locking_spinlock_spin_lock_lock_of_pm8001_hba_info(); __ldv_linux_kernel_locking_spinlock_spin_lock(ldv_func_arg1); } return; } } static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_133(spinlock_t *ldv_func_arg1 ) { { { ldv_linux_kernel_locking_spinlock_spin_lock_lock_of_pm8001_hba_info(); __ldv_linux_kernel_locking_spinlock_spin_lock(ldv_func_arg1); } return; } } static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_134(spinlock_t *ldv_func_arg1 ) { { { ldv_linux_kernel_locking_spinlock_spin_lock_task_state_lock_of_sas_task(); __ldv_linux_kernel_locking_spinlock_spin_lock(ldv_func_arg1); } return; } } __inline static void ldv_spin_unlock_irqrestore_135(spinlock_t *lock , unsigned long flags ) { { { ldv_linux_kernel_locking_spinlock_spin_unlock_task_state_lock_of_sas_task(); spin_unlock_irqrestore(lock, flags); } return; } } static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_138(spinlock_t *ldv_func_arg1 ) { { { ldv_linux_kernel_locking_spinlock_spin_lock_lock_of_pm8001_hba_info(); __ldv_linux_kernel_locking_spinlock_spin_lock(ldv_func_arg1); } return; } } static void ldv_wait_for_completion_141(struct completion *ldv_func_arg1 ) { { { ldv_linux_kernel_sched_completion_wait_for_completion_completion_setstate(); wait_for_completion(ldv_func_arg1); } return; } } static void ldv_wait_for_completion_143(struct completion *ldv_func_arg1 ) { { { ldv_linux_kernel_sched_completion_wait_for_completion_completion_setstate(); wait_for_completion(ldv_func_arg1); } return; } } static void ldv_wait_for_completion_145(struct completion *ldv_func_arg1 ) { { { ldv_linux_kernel_sched_completion_wait_for_completion_completion_setstate(); wait_for_completion(ldv_func_arg1); } return; } } static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_146(spinlock_t *ldv_func_arg1 ) { { { ldv_linux_kernel_locking_spinlock_spin_lock_task_state_lock_of_sas_task(); __ldv_linux_kernel_locking_spinlock_spin_lock(ldv_func_arg1); } return; } } __inline static __u32 __fswab32(__u32 val ) { int tmp ; { { tmp = __builtin_bswap32(val); } return ((__u32 )tmp); } } extern int sscanf(char const * , char const * , ...) ; extern int memcmp(void const * , void const * , size_t ) ; extern size_t strlen(char const * ) ; __inline static void ldv_init_completion_100(struct completion *x ) ; __inline static void ldv_init_completion_100(struct completion *x ) ; __inline static void ldv_init_completion_100(struct completion *x ) ; static void ldv_wait_for_completion_101___0(struct completion *ldv_func_arg1 ) ; static void ldv_wait_for_completion_103___0(struct completion *ldv_func_arg1 ) ; static void ldv_wait_for_completion_105___0(struct completion *ldv_func_arg1 ) ; extern bool capable(int ) ; __inline static void *kzalloc(size_t size , gfp_t flags ) ; extern int request_firmware(struct firmware const ** , char const * , struct device * ) ; extern void release_firmware(struct firmware const * ) ; ssize_t pm80xx_get_fatal_dump(struct device *cdev , struct device_attribute *attr , char *buf ) ; ssize_t pm8001_get_gsm_dump(struct device *cdev , u32 length , char *buf ) ; static ssize_t pm8001_ctl_mpi_interface_rev_show(struct device *cdev , struct device_attribute *attr , char *buf ) { struct Scsi_Host *shost ; struct device const *__mptr ; struct sas_ha_struct *sha ; struct pm8001_hba_info *pm8001_ha ; int tmp ; int tmp___0 ; { __mptr = (struct device const *)cdev; shost = (struct Scsi_Host *)__mptr + 0xfffffffffffff6c8UL; sha = *((struct sas_ha_struct **)(& shost->hostdata)); pm8001_ha = (struct pm8001_hba_info *)sha->lldd_ha; if (pm8001_ha->chip_id == 0U) { { tmp = snprintf(buf, 4096UL, "%d\n", pm8001_ha->main_cfg_tbl.pm8001_tbl.interface_rev); } return ((ssize_t )tmp); } else { { tmp___0 = snprintf(buf, 4096UL, "%d\n", pm8001_ha->main_cfg_tbl.pm80xx_tbl.interface_rev); } return ((ssize_t )tmp___0); } } } static struct device_attribute dev_attr_interface_rev = {{"interface_rev", 292U, (_Bool)0, 0, {{{(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}}}}, & pm8001_ctl_mpi_interface_rev_show, (ssize_t (*)(struct device * , struct device_attribute * , char const * , size_t ))0}; static ssize_t pm8001_ctl_fw_version_show(struct device *cdev , struct device_attribute *attr , char *buf ) { struct Scsi_Host *shost ; struct device const *__mptr ; struct sas_ha_struct *sha ; struct pm8001_hba_info *pm8001_ha ; int tmp ; int tmp___0 ; { __mptr = (struct device const *)cdev; shost = (struct Scsi_Host *)__mptr + 0xfffffffffffff6c8UL; sha = *((struct sas_ha_struct **)(& shost->hostdata)); pm8001_ha = (struct pm8001_hba_info *)sha->lldd_ha; if (pm8001_ha->chip_id == 0U) { { tmp = snprintf(buf, 4096UL, "%02x.%02x.%02x.%02x\n", (int )((unsigned char )(pm8001_ha->main_cfg_tbl.pm8001_tbl.firmware_rev >> 24)), (int )((unsigned char )(pm8001_ha->main_cfg_tbl.pm8001_tbl.firmware_rev >> 16)), (int )((unsigned char )(pm8001_ha->main_cfg_tbl.pm8001_tbl.firmware_rev >> 8)), (int )((unsigned char )pm8001_ha->main_cfg_tbl.pm8001_tbl.firmware_rev)); } return ((ssize_t )tmp); } else { { tmp___0 = snprintf(buf, 4096UL, "%02x.%02x.%02x.%02x\n", (int )((unsigned char )(pm8001_ha->main_cfg_tbl.pm80xx_tbl.firmware_rev >> 24)), (int )((unsigned char )(pm8001_ha->main_cfg_tbl.pm80xx_tbl.firmware_rev >> 16)), (int )((unsigned char )(pm8001_ha->main_cfg_tbl.pm80xx_tbl.firmware_rev >> 8)), (int )((unsigned char )pm8001_ha->main_cfg_tbl.pm80xx_tbl.firmware_rev)); } return ((ssize_t )tmp___0); } } } static struct device_attribute dev_attr_fw_version = {{"fw_version", 292U, (_Bool)0, 0, {{{(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}}}}, & pm8001_ctl_fw_version_show, (ssize_t (*)(struct device * , struct device_attribute * , char const * , size_t ))0}; static ssize_t pm8001_ctl_max_out_io_show(struct device *cdev , struct device_attribute *attr , char *buf ) { struct Scsi_Host *shost ; struct device const *__mptr ; struct sas_ha_struct *sha ; struct pm8001_hba_info *pm8001_ha ; int tmp ; int tmp___0 ; { __mptr = (struct device const *)cdev; shost = (struct Scsi_Host *)__mptr + 0xfffffffffffff6c8UL; sha = *((struct sas_ha_struct **)(& shost->hostdata)); pm8001_ha = (struct pm8001_hba_info *)sha->lldd_ha; if (pm8001_ha->chip_id == 0U) { { tmp = snprintf(buf, 4096UL, "%d\n", pm8001_ha->main_cfg_tbl.pm8001_tbl.max_out_io); } return ((ssize_t )tmp); } else { { tmp___0 = snprintf(buf, 4096UL, "%d\n", pm8001_ha->main_cfg_tbl.pm80xx_tbl.max_out_io); } return ((ssize_t )tmp___0); } } } static struct device_attribute dev_attr_max_out_io = {{"max_out_io", 292U, (_Bool)0, 0, {{{(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}}}}, & pm8001_ctl_max_out_io_show, (ssize_t (*)(struct device * , struct device_attribute * , char const * , size_t ))0}; static ssize_t pm8001_ctl_max_devices_show(struct device *cdev , struct device_attribute *attr , char *buf ) { struct Scsi_Host *shost ; struct device const *__mptr ; struct sas_ha_struct *sha ; struct pm8001_hba_info *pm8001_ha ; int tmp ; int tmp___0 ; { __mptr = (struct device const *)cdev; shost = (struct Scsi_Host *)__mptr + 0xfffffffffffff6c8UL; sha = *((struct sas_ha_struct **)(& shost->hostdata)); pm8001_ha = (struct pm8001_hba_info *)sha->lldd_ha; if (pm8001_ha->chip_id == 0U) { { tmp = snprintf(buf, 4096UL, "%04d\n", (int )((unsigned short )(pm8001_ha->main_cfg_tbl.pm8001_tbl.max_sgl >> 16))); } return ((ssize_t )tmp); } else { { tmp___0 = snprintf(buf, 4096UL, "%04d\n", (int )((unsigned short )(pm8001_ha->main_cfg_tbl.pm80xx_tbl.max_sgl >> 16))); } return ((ssize_t )tmp___0); } } } static struct device_attribute dev_attr_max_devices = {{"max_devices", 292U, (_Bool)0, 0, {{{(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}}}}, & pm8001_ctl_max_devices_show, (ssize_t (*)(struct device * , struct device_attribute * , char const * , size_t ))0}; static ssize_t pm8001_ctl_max_sg_list_show(struct device *cdev , struct device_attribute *attr , char *buf ) { struct Scsi_Host *shost ; struct device const *__mptr ; struct sas_ha_struct *sha ; struct pm8001_hba_info *pm8001_ha ; int tmp ; int tmp___0 ; { __mptr = (struct device const *)cdev; shost = (struct Scsi_Host *)__mptr + 0xfffffffffffff6c8UL; sha = *((struct sas_ha_struct **)(& shost->hostdata)); pm8001_ha = (struct pm8001_hba_info *)sha->lldd_ha; if (pm8001_ha->chip_id == 0U) { { tmp = snprintf(buf, 4096UL, "%04d\n", pm8001_ha->main_cfg_tbl.pm8001_tbl.max_sgl & 65535U); } return ((ssize_t )tmp); } else { { tmp___0 = snprintf(buf, 4096UL, "%04d\n", pm8001_ha->main_cfg_tbl.pm80xx_tbl.max_sgl & 65535U); } return ((ssize_t )tmp___0); } } } static struct device_attribute dev_attr_max_sg_list = {{"max_sg_list", 292U, (_Bool)0, 0, {{{(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}}}}, & pm8001_ctl_max_sg_list_show, (ssize_t (*)(struct device * , struct device_attribute * , char const * , size_t ))0}; static ssize_t show_sas_spec_support_status(unsigned int mode , char *buf ) { ssize_t len ; int tmp ; int tmp___0 ; int tmp___1 ; { len = 0L; if ((mode & 2U) != 0U) { { tmp = sprintf(buf, "%s", (char *)"SAS1.1"); len = (ssize_t )tmp; } } else { } if ((mode & 4U) != 0U) { { tmp___0 = sprintf(buf + (unsigned long )len, "%s%s", len != 0L ? (char *)", " : (char *)"", (char *)"SAS2.0"); len = len + (ssize_t )tmp___0; } } else { } { tmp___1 = sprintf(buf + (unsigned long )len, "\n"); len = len + (ssize_t )tmp___1; } return (len); } } static ssize_t pm8001_ctl_sas_spec_support_show(struct device *cdev , struct device_attribute *attr , char *buf ) { unsigned int mode ; struct Scsi_Host *shost ; struct device const *__mptr ; struct sas_ha_struct *sha ; struct pm8001_hba_info *pm8001_ha ; ssize_t tmp ; { __mptr = (struct device const *)cdev; shost = (struct Scsi_Host *)__mptr + 0xfffffffffffff6c8UL; sha = *((struct sas_ha_struct **)(& shost->hostdata)); pm8001_ha = (struct pm8001_hba_info *)sha->lldd_ha; if (pm8001_ha->chip_id == 0U) { mode = pm8001_ha->main_cfg_tbl.pm8001_tbl.ctrl_cap_flag >> 25; } else { mode = pm8001_ha->main_cfg_tbl.pm80xx_tbl.ctrl_cap_flag >> 25; } { tmp = show_sas_spec_support_status(mode, buf); } return (tmp); } } static struct device_attribute dev_attr_sas_spec_support = {{"sas_spec_support", 292U, (_Bool)0, 0, {{{(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}}}}, & pm8001_ctl_sas_spec_support_show, (ssize_t (*)(struct device * , struct device_attribute * , char const * , size_t ))0}; static ssize_t pm8001_ctl_host_sas_address_show(struct device *cdev , struct device_attribute *attr , char *buf ) { struct Scsi_Host *shost ; struct device const *__mptr ; struct sas_ha_struct *sha ; struct pm8001_hba_info *pm8001_ha ; __u64 tmp ; int tmp___0 ; { { __mptr = (struct device const *)cdev; shost = (struct Scsi_Host *)__mptr + 0xfffffffffffff6c8UL; sha = *((struct sas_ha_struct **)(& shost->hostdata)); pm8001_ha = (struct pm8001_hba_info *)sha->lldd_ha; tmp = __fswab64(*((__be64 *)(& pm8001_ha->sas_addr))); tmp___0 = snprintf(buf, 4096UL, "0x%016llx\n", tmp); } return ((ssize_t )tmp___0); } } static struct device_attribute dev_attr_host_sas_address = {{"host_sas_address", 292U, (_Bool)0, 0, {{{(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}}}}, & pm8001_ctl_host_sas_address_show, (ssize_t (*)(struct device * , struct device_attribute * , char const * , size_t ))0}; static ssize_t pm8001_ctl_logging_level_show(struct device *cdev , struct device_attribute *attr , char *buf ) { struct Scsi_Host *shost ; struct device const *__mptr ; struct sas_ha_struct *sha ; struct pm8001_hba_info *pm8001_ha ; int tmp ; { { __mptr = (struct device const *)cdev; shost = (struct Scsi_Host *)__mptr + 0xfffffffffffff6c8UL; sha = *((struct sas_ha_struct **)(& shost->hostdata)); pm8001_ha = (struct pm8001_hba_info *)sha->lldd_ha; tmp = snprintf(buf, 4096UL, "%08xh\n", pm8001_ha->logging_level); } return ((ssize_t )tmp); } } static ssize_t pm8001_ctl_logging_level_store(struct device *cdev , struct device_attribute *attr , char const *buf , size_t count ) { struct Scsi_Host *shost ; struct device const *__mptr ; struct sas_ha_struct *sha ; struct pm8001_hba_info *pm8001_ha ; int val ; int tmp ; size_t tmp___0 ; { { __mptr = (struct device const *)cdev; shost = (struct Scsi_Host *)__mptr + 0xfffffffffffff6c8UL; sha = *((struct sas_ha_struct **)(& shost->hostdata)); pm8001_ha = (struct pm8001_hba_info *)sha->lldd_ha; val = 0; tmp = sscanf(buf, "%x", & val); } if (tmp != 1) { return (-22L); } else { } { pm8001_ha->logging_level = (u32 )val; tmp___0 = strlen(buf); } return ((ssize_t )tmp___0); } } static struct device_attribute dev_attr_logging_level = {{"logging_level", 420U, (_Bool)0, 0, {{{(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}}}}, & pm8001_ctl_logging_level_show, & pm8001_ctl_logging_level_store}; static ssize_t pm8001_ctl_aap_log_show(struct device *cdev , struct device_attribute *attr , char *buf ) { struct Scsi_Host *shost ; struct device const *__mptr ; struct sas_ha_struct *sha ; struct pm8001_hba_info *pm8001_ha ; int i ; char *str ; int max ; int tmp ; { __mptr = (struct device const *)cdev; shost = (struct Scsi_Host *)__mptr + 0xfffffffffffff6c8UL; sha = *((struct sas_ha_struct **)(& shost->hostdata)); pm8001_ha = (struct pm8001_hba_info *)sha->lldd_ha; str = buf; max = 2; i = 0; goto ldv_45875; ldv_45874: { tmp = sprintf(str, "0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x0x%08x 0x%08x\n", *((u32 *)pm8001_ha->memoryMap.region[0].virt_ptr + (unsigned long )(i * 32)), *((u32 *)pm8001_ha->memoryMap.region[0].virt_ptr + ((unsigned long )(i * 32) + 4UL)), *((u32 *)pm8001_ha->memoryMap.region[0].virt_ptr + ((unsigned long )(i * 32) + 8UL)), *((u32 *)pm8001_ha->memoryMap.region[0].virt_ptr + ((unsigned long )(i * 32) + 12UL)), *((u32 *)pm8001_ha->memoryMap.region[0].virt_ptr + ((unsigned long )(i * 32) + 16UL)), *((u32 *)pm8001_ha->memoryMap.region[0].virt_ptr + ((unsigned long )(i * 32) + 20UL)), *((u32 *)pm8001_ha->memoryMap.region[0].virt_ptr + ((unsigned long )(i * 32) + 24UL)), *((u32 *)pm8001_ha->memoryMap.region[0].virt_ptr + ((unsigned long )(i * 32) + 28UL))); str = str + (unsigned long )tmp; i = i + 1; } ldv_45875: ; if (i < max) { goto ldv_45874; } else { } return ((long )str - (long )buf); } } static struct device_attribute dev_attr_aap_log = {{"aap_log", 292U, (_Bool)0, 0, {{{(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}}}}, & pm8001_ctl_aap_log_show, (ssize_t (*)(struct device * , struct device_attribute * , char const * , size_t ))0}; static ssize_t pm8001_ctl_ib_queue_log_show(struct device *cdev , struct device_attribute *attr , char *buf ) { struct Scsi_Host *shost ; struct device const *__mptr ; struct sas_ha_struct *sha ; struct pm8001_hba_info *pm8001_ha ; int offset ; char *str ; int start ; int tmp ; { __mptr = (struct device const *)cdev; shost = (struct Scsi_Host *)__mptr + 0xfffffffffffff6c8UL; sha = *((struct sas_ha_struct **)(& shost->hostdata)); pm8001_ha = (struct pm8001_hba_info *)sha->lldd_ha; str = buf; start = 0; offset = 0; goto ldv_45902; ldv_45901: { tmp = sprintf(str, "0x%08x\n", *((u32 *)pm8001_ha->memoryMap.region[6].virt_ptr + ((unsigned long )pm8001_ha->evtlog_ib_offset + (unsigned long )start))); str = str + (unsigned long )tmp; start = start + 4; offset = offset + 1; } ldv_45902: ; if (offset <= 255) { goto ldv_45901; } else { } pm8001_ha->evtlog_ib_offset = pm8001_ha->evtlog_ib_offset + 1024U; if ((pm8001_ha->evtlog_ib_offset & 32767U) == 0U) { pm8001_ha->evtlog_ib_offset = 0U; } else { } return ((long )str - (long )buf); } } static struct device_attribute dev_attr_ib_log = {{"ib_log", 292U, (_Bool)0, 0, {{{(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}}}}, & pm8001_ctl_ib_queue_log_show, (ssize_t (*)(struct device * , struct device_attribute * , char const * , size_t ))0}; static ssize_t pm8001_ctl_ob_queue_log_show(struct device *cdev , struct device_attribute *attr , char *buf ) { struct Scsi_Host *shost ; struct device const *__mptr ; struct sas_ha_struct *sha ; struct pm8001_hba_info *pm8001_ha ; int offset ; char *str ; int start ; int tmp ; { __mptr = (struct device const *)cdev; shost = (struct Scsi_Host *)__mptr + 0xfffffffffffff6c8UL; sha = *((struct sas_ha_struct **)(& shost->hostdata)); pm8001_ha = (struct pm8001_hba_info *)sha->lldd_ha; str = buf; start = 0; offset = 0; goto ldv_45929; ldv_45928: { tmp = sprintf(str, "0x%08x\n", *((u32 *)pm8001_ha->memoryMap.region[8].virt_ptr + ((unsigned long )pm8001_ha->evtlog_ob_offset + (unsigned long )start))); str = str + (unsigned long )tmp; start = start + 4; offset = offset + 1; } ldv_45929: ; if (offset <= 255) { goto ldv_45928; } else { } pm8001_ha->evtlog_ob_offset = pm8001_ha->evtlog_ob_offset + 1024U; if ((pm8001_ha->evtlog_ob_offset & 32767U) == 0U) { pm8001_ha->evtlog_ob_offset = 0U; } else { } return ((long )str - (long )buf); } } static struct device_attribute dev_attr_ob_log = {{"ob_log", 292U, (_Bool)0, 0, {{{(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}}}}, & pm8001_ctl_ob_queue_log_show, (ssize_t (*)(struct device * , struct device_attribute * , char const * , size_t ))0}; static ssize_t pm8001_ctl_bios_version_show(struct device *cdev , struct device_attribute *attr , char *buf ) { struct Scsi_Host *shost ; struct device const *__mptr ; struct sas_ha_struct *sha ; struct pm8001_hba_info *pm8001_ha ; char *str ; int bios_index ; struct completion completion ; struct pm8001_ioctl_payload payload ; void *tmp ; int tmp___0 ; int tmp___1 ; { { __mptr = (struct device const *)cdev; shost = (struct Scsi_Host *)__mptr + 0xfffffffffffff6c8UL; sha = *((struct sas_ha_struct **)(& shost->hostdata)); pm8001_ha = (struct pm8001_hba_info *)sha->lldd_ha; str = buf; ldv_init_completion_100(& completion); completion = completion; pm8001_ha->nvmd_completion = & completion; payload.minor_function = 7U; payload.offset = 0U; payload.length = 4096U; tmp = kzalloc(4096UL, 208U); payload.func_specific = (u8 *)tmp; } if ((unsigned long )payload.func_specific == (unsigned long )((u8 *)0U)) { return (-12L); } else { } { tmp___0 = (*(((pm8001_ha->chip)->dispatch)->get_nvmd_req))(pm8001_ha, (void *)(& payload)); } if (tmp___0 != 0) { { kfree((void const *)payload.func_specific); } return (-12L); } else { } { ldv_wait_for_completion_101___0(& completion); bios_index = 56; } goto ldv_45958; ldv_45957: { tmp___1 = sprintf(str, "%c", (int )*(payload.func_specific + (unsigned long )bios_index)); str = str + (unsigned long )tmp___1; bios_index = bios_index + 1; } ldv_45958: ; if (bios_index <= 60) { goto ldv_45957; } else { } { kfree((void const *)payload.func_specific); } return ((long )str - (long )buf); } } static struct device_attribute dev_attr_bios_version = {{"bios_version", 292U, (_Bool)0, 0, {{{(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}}}}, & pm8001_ctl_bios_version_show, (ssize_t (*)(struct device * , struct device_attribute * , char const * , size_t ))0}; static ssize_t pm8001_ctl_iop_log_show(struct device *cdev , struct device_attribute *attr , char *buf ) { struct Scsi_Host *shost ; struct device const *__mptr ; struct sas_ha_struct *sha ; struct pm8001_hba_info *pm8001_ha ; int i ; char *str ; int max ; int tmp ; { __mptr = (struct device const *)cdev; shost = (struct Scsi_Host *)__mptr + 0xfffffffffffff6c8UL; sha = *((struct sas_ha_struct **)(& shost->hostdata)); pm8001_ha = (struct pm8001_hba_info *)sha->lldd_ha; str = buf; max = 2; i = 0; goto ldv_45985; ldv_45984: { tmp = sprintf(str, "0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x0x%08x 0x%08x\n", *((u32 *)pm8001_ha->memoryMap.region[1].virt_ptr + (unsigned long )(i * 32)), *((u32 *)pm8001_ha->memoryMap.region[1].virt_ptr + ((unsigned long )(i * 32) + 4UL)), *((u32 *)pm8001_ha->memoryMap.region[1].virt_ptr + ((unsigned long )(i * 32) + 8UL)), *((u32 *)pm8001_ha->memoryMap.region[1].virt_ptr + ((unsigned long )(i * 32) + 12UL)), *((u32 *)pm8001_ha->memoryMap.region[1].virt_ptr + ((unsigned long )(i * 32) + 16UL)), *((u32 *)pm8001_ha->memoryMap.region[1].virt_ptr + ((unsigned long )(i * 32) + 20UL)), *((u32 *)pm8001_ha->memoryMap.region[1].virt_ptr + ((unsigned long )(i * 32) + 24UL)), *((u32 *)pm8001_ha->memoryMap.region[1].virt_ptr + ((unsigned long )(i * 32) + 28UL))); str = str + (unsigned long )tmp; i = i + 1; } ldv_45985: ; if (i < max) { goto ldv_45984; } else { } return ((long )str - (long )buf); } } static struct device_attribute dev_attr_iop_log = {{"iop_log", 292U, (_Bool)0, 0, {{{(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}}}}, & pm8001_ctl_iop_log_show, (ssize_t (*)(struct device * , struct device_attribute * , char const * , size_t ))0}; static ssize_t pm8001_ctl_fatal_log_show(struct device *cdev , struct device_attribute *attr , char *buf ) { ssize_t count ; { { count = pm80xx_get_fatal_dump(cdev, attr, buf); } return (count); } } static struct device_attribute dev_attr_fatal_log = {{"fatal_log", 292U, (_Bool)0, 0, {{{(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}}}}, & pm8001_ctl_fatal_log_show, (ssize_t (*)(struct device * , struct device_attribute * , char const * , size_t ))0}; static ssize_t pm8001_ctl_gsm_log_show(struct device *cdev , struct device_attribute *attr , char *buf ) { ssize_t count ; { { count = pm8001_get_gsm_dump(cdev, 1024U, buf); } return (count); } } static struct device_attribute dev_attr_gsm_log = {{"gsm_log", 292U, (_Bool)0, 0, {{{(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}}}}, & pm8001_ctl_gsm_log_show, (ssize_t (*)(struct device * , struct device_attribute * , char const * , size_t ))0}; static struct flash_command flash_command_table[3U] = { {{'s', 'e', 't', '_', 'n', 'v', 'm', 'd'}, 2}, {{'u', 'p', 'd', 'a', 't', 'e', '\000'}, 1}, {{'\000'}, 0}}; static struct error_fw flash_error_table[13U] = { {(char *)"Failed to open fw image file", 256}, {(char *)"image header mismatch", 2}, {(char *)"image offset mismatch", 3}, {(char *)"image CRC Error", 4}, {(char *)"image length Error.", 5}, {(char *)"Failed to program flash chip", 6}, {(char *)"Flash chip not supported.", 16}, {(char *)"Flash update disabled.", 17}, {(char *)"Flash in progress", 4096}, {(char *)"Image file size Error", 2560}, {(char *)"Input parameter error", 2816}, {(char *)"Out of memory", 3072}, {(char *)"OK", 0}}; static int pm8001_set_nvmd(struct pm8001_hba_info *pm8001_ha ) { struct pm8001_ioctl_payload *payload ; struct completion completion ; u8 *ioctlbuffer ; u32 ret ; u32 length ; void *tmp ; int tmp___0 ; { { ldv_init_completion_100(& completion); completion = completion; length = 5143U; } if ((unsigned long )(pm8001_ha->fw_image)->size > 4096UL) { pm8001_ha->fw_status = 2560U; return (-14); } else { } { tmp = kzalloc((size_t )length, 208U); ioctlbuffer = (u8 *)tmp; } if ((unsigned long )ioctlbuffer == (unsigned long )((u8 *)0U)) { pm8001_ha->fw_status = 3072U; return (-12); } else { } { payload = (struct pm8001_ioctl_payload *)ioctlbuffer; __memcpy((void *)(& payload->func_specific), (void const *)(pm8001_ha->fw_image)->data, (pm8001_ha->fw_image)->size); payload->length = (u16 )(pm8001_ha->fw_image)->size; payload->id = 0U; payload->minor_function = 1U; pm8001_ha->nvmd_completion = & completion; tmp___0 = (*(((pm8001_ha->chip)->dispatch)->set_nvmd_req))(pm8001_ha, (void *)payload); ret = (u32 )tmp___0; } if (ret != 0U) { pm8001_ha->fw_status = 3072U; goto out; } else { } { ldv_wait_for_completion_103___0(& completion); } out: { kfree((void const *)ioctlbuffer); } return ((int )ret); } } static int pm8001_update_flash(struct pm8001_hba_info *pm8001_ha ) { struct pm8001_ioctl_payload *payload ; struct completion completion ; u8 *ioctlbuffer ; struct fw_control_info *fwControl ; u32 partitionSize ; u32 partitionSizeTmp ; u32 loopNumber ; u32 loopcount ; struct pm8001_fw_image_header *image_hdr ; u32 sizeRead ; u32 ret ; u32 length ; void *tmp ; __u32 tmp___0 ; int tmp___1 ; { { ldv_init_completion_100(& completion); completion = completion; sizeRead = 0U; ret = 0U; length = 16407U; } if ((unsigned long )(pm8001_ha->fw_image)->size <= 27UL) { pm8001_ha->fw_status = 2560U; return (-14); } else { } { tmp = kzalloc((size_t )length, 208U); ioctlbuffer = (u8 *)tmp; } if ((unsigned long )ioctlbuffer == (unsigned long )((u8 *)0U)) { pm8001_ha->fw_status = 3072U; return (-12); } else { } image_hdr = (struct pm8001_fw_image_header *)(pm8001_ha->fw_image)->data; goto ldv_46071; ldv_46070: { partitionSizeTmp = *(& image_hdr->image_length + (unsigned long )sizeRead); tmp___0 = __fswab32(partitionSizeTmp); partitionSize = tmp___0; loopcount = (partitionSize + 4123U) / 4096U; loopNumber = 0U; } goto ldv_46068; ldv_46067: payload = (struct pm8001_ioctl_payload *)ioctlbuffer; payload->length = 16384U; payload->id = 0U; fwControl = (struct fw_control_info *)(& payload->func_specific); fwControl->len = 4096U; fwControl->size = partitionSize + 28U; fwControl->retcode = 0U; fwControl->offset = loopNumber * 4096U; if (loopcount - loopNumber == 1U && ((partitionSize + 28U) & 4095U) != 0U) { { fwControl->len = (partitionSize + 28U) & 4095U; __memcpy((void *)(& fwControl->buffer), (void const *)(pm8001_ha->fw_image)->data + (unsigned long )sizeRead, (size_t )(partitionSize + 28U) & 4095UL); sizeRead = sizeRead + ((partitionSize + 28U) & 4095U); } } else { { __memcpy((void *)(& fwControl->buffer), (void const *)(pm8001_ha->fw_image)->data + (unsigned long )sizeRead, 4096UL); sizeRead = sizeRead + 4096U; } } { pm8001_ha->nvmd_completion = & completion; tmp___1 = (*(((pm8001_ha->chip)->dispatch)->fw_flash_update_req))(pm8001_ha, (void *)payload); ret = (u32 )tmp___1; } if (ret != 0U) { pm8001_ha->fw_status = 3072U; goto out; } else { } { ldv_wait_for_completion_105___0(& completion); } if (fwControl->retcode > 1U) { pm8001_ha->fw_status = fwControl->retcode; ret = 4294967282U; goto out; } else { } loopNumber = loopNumber + 1U; ldv_46068: ; if (loopNumber < loopcount) { goto ldv_46067; } else { } ldv_46071: ; if ((unsigned long )sizeRead < (unsigned long )(pm8001_ha->fw_image)->size) { goto ldv_46070; } else { } out: { kfree((void const *)ioctlbuffer); } return ((int )ret); } } static ssize_t pm8001_store_update_fw(struct device *cdev , struct device_attribute *attr , char const *buf , size_t count ) { struct Scsi_Host *shost ; struct device const *__mptr ; struct sas_ha_struct *sha ; struct pm8001_hba_info *pm8001_ha ; char *cmd_ptr ; char *filename_ptr ; int res ; int i ; int flash_command ; int ret ; bool tmp ; int tmp___0 ; void *tmp___1 ; size_t tmp___2 ; int tmp___3 ; long tmp___4 ; { { __mptr = (struct device const *)cdev; shost = (struct Scsi_Host *)__mptr + 0xfffffffffffff6c8UL; sha = *((struct sas_ha_struct **)(& shost->hostdata)); pm8001_ha = (struct pm8001_hba_info *)sha->lldd_ha; flash_command = 0; tmp = capable(21); } if (tmp) { tmp___0 = 0; } else { tmp___0 = 1; } if (tmp___0) { return (-13L); } else { } if (pm8001_ha->fw_status == 4096U) { return (-115L); } else { } { pm8001_ha->fw_status = 4096U; tmp___1 = kzalloc(count * 2UL, 208U); cmd_ptr = (char *)tmp___1; } if ((unsigned long )cmd_ptr == (unsigned long )((char *)0)) { pm8001_ha->fw_status = 3072U; return (-12L); } else { } { filename_ptr = cmd_ptr + count; res = sscanf(buf, "%s %s", cmd_ptr, filename_ptr); } if (res != 2) { pm8001_ha->fw_status = 2816U; ret = -22; goto out; } else { } i = 0; goto ldv_46093; ldv_46092: { tmp___2 = strlen((char const *)cmd_ptr); tmp___3 = memcmp((void const *)(& flash_command_table[i].command), (void const *)cmd_ptr, tmp___2); } if (tmp___3 == 0) { flash_command = flash_command_table[i].code; goto ldv_46091; } else { } i = i + 1; ldv_46093: ; if (flash_command_table[i].code != 0) { goto ldv_46092; } else { } ldv_46091: ; if (flash_command == 0) { pm8001_ha->fw_status = 2816U; ret = -22; goto out; } else { } { ret = request_firmware(& pm8001_ha->fw_image, (char const *)filename_ptr, pm8001_ha->dev); } if (ret != 0) { { tmp___4 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___4 != 0L) { { printk("\016pm80xx %s %d:Failed to load firmware image file %s,\terror %d\n", "pm8001_store_update_fw", 691, filename_ptr, ret); } } else { } pm8001_ha->fw_status = 256U; goto out; } else { } if (flash_command == 1) { { ret = pm8001_update_flash(pm8001_ha); } } else { { ret = pm8001_set_nvmd(pm8001_ha); } } { release_firmware(pm8001_ha->fw_image); } out: { kfree((void const *)cmd_ptr); } if (ret != 0) { return ((ssize_t )ret); } else { } pm8001_ha->fw_status = 0U; return ((ssize_t )count); } } static ssize_t pm8001_show_update_fw(struct device *cdev , struct device_attribute *attr , char *buf ) { int i ; struct Scsi_Host *shost ; struct device const *__mptr ; struct sas_ha_struct *sha ; struct pm8001_hba_info *pm8001_ha ; int tmp ; { __mptr = (struct device const *)cdev; shost = (struct Scsi_Host *)__mptr + 0xfffffffffffff6c8UL; sha = *((struct sas_ha_struct **)(& shost->hostdata)); pm8001_ha = (struct pm8001_hba_info *)sha->lldd_ha; i = 0; goto ldv_46108; ldv_46107: ; if ((u32 )flash_error_table[i].err_code == pm8001_ha->fw_status) { goto ldv_46106; } else { } i = i + 1; ldv_46108: ; if (flash_error_table[i].err_code != 0) { goto ldv_46107; } else { } ldv_46106: ; if (pm8001_ha->fw_status != 4096U) { pm8001_ha->fw_status = 0U; } else { } { tmp = snprintf(buf, 4096UL, "status=%x %s\n", flash_error_table[i].err_code, flash_error_table[i].reason); } return ((ssize_t )tmp); } } static struct device_attribute dev_attr_update_fw = {{"update_fw", 436U, (_Bool)0, 0, {{{(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}, {(char)0}}}}, & pm8001_show_update_fw, & pm8001_store_update_fw}; struct device_attribute *pm8001_host_attrs[17U] = { & dev_attr_interface_rev, & dev_attr_fw_version, & dev_attr_update_fw, & dev_attr_aap_log, & dev_attr_iop_log, & dev_attr_fatal_log, & dev_attr_gsm_log, & dev_attr_max_out_io, & dev_attr_max_devices, & dev_attr_max_sg_list, & dev_attr_sas_spec_support, & dev_attr_logging_level, & dev_attr_host_sas_address, & dev_attr_bios_version, & dev_attr_ib_log, & dev_attr_ob_log, (struct device_attribute *)0}; void ldv_dummy_resourceless_instance_callback_10_3(long (*arg0)(struct device * , struct device_attribute * , char * ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 ) ; void ldv_dummy_resourceless_instance_callback_11_3(long (*arg0)(struct device * , struct device_attribute * , char * ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 ) ; void ldv_dummy_resourceless_instance_callback_12_3(long (*arg0)(struct device * , struct device_attribute * , char * ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 ) ; void ldv_dummy_resourceless_instance_callback_13_3(long (*arg0)(struct device * , struct device_attribute * , char * ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 ) ; void ldv_dummy_resourceless_instance_callback_13_9(long (*arg0)(struct device * , struct device_attribute * , char * , unsigned long ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 , unsigned long arg4 ) ; void ldv_dummy_resourceless_instance_callback_14_3(long (*arg0)(struct device * , struct device_attribute * , char * ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 ) ; void ldv_dummy_resourceless_instance_callback_15_3(long (*arg0)(struct device * , struct device_attribute * , char * ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 ) ; void ldv_dummy_resourceless_instance_callback_16_3(long (*arg0)(struct device * , struct device_attribute * , char * ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 ) ; void ldv_dummy_resourceless_instance_callback_17_3(long (*arg0)(struct device * , struct device_attribute * , char * ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 ) ; void ldv_dummy_resourceless_instance_callback_18_3(long (*arg0)(struct device * , struct device_attribute * , char * ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 ) ; void ldv_dummy_resourceless_instance_callback_19_3(long (*arg0)(struct device * , struct device_attribute * , char * ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 ) ; void ldv_dummy_resourceless_instance_callback_19_9(long (*arg0)(struct device * , struct device_attribute * , char * , unsigned long ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 , unsigned long arg4 ) ; void ldv_dummy_resourceless_instance_callback_4_3(long (*arg0)(struct device * , struct device_attribute * , char * ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 ) ; void ldv_dummy_resourceless_instance_callback_5_3(long (*arg0)(struct device * , struct device_attribute * , char * ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 ) ; void ldv_dummy_resourceless_instance_callback_6_3(long (*arg0)(struct device * , struct device_attribute * , char * ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 ) ; void ldv_dummy_resourceless_instance_callback_7_3(long (*arg0)(struct device * , struct device_attribute * , char * ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 ) ; void ldv_dummy_resourceless_instance_callback_8_3(long (*arg0)(struct device * , struct device_attribute * , char * ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 ) ; void ldv_dummy_resourceless_instance_callback_9_3(long (*arg0)(struct device * , struct device_attribute * , char * ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 ) ; struct ldv_thread ldv_thread_10 ; struct ldv_thread ldv_thread_11 ; struct ldv_thread ldv_thread_12 ; struct ldv_thread ldv_thread_13 ; struct ldv_thread ldv_thread_14 ; struct ldv_thread ldv_thread_15 ; struct ldv_thread ldv_thread_16 ; struct ldv_thread ldv_thread_17 ; struct ldv_thread ldv_thread_18 ; struct ldv_thread ldv_thread_19 ; struct ldv_thread ldv_thread_4 ; struct ldv_thread ldv_thread_5 ; struct ldv_thread ldv_thread_6 ; struct ldv_thread ldv_thread_7 ; struct ldv_thread ldv_thread_8 ; struct ldv_thread ldv_thread_9 ; void ldv_dummy_resourceless_instance_callback_10_3(long (*arg0)(struct device * , struct device_attribute * , char * ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 ) { { { pm8001_ctl_ib_queue_log_show(arg1, arg2, arg3); } return; } } void ldv_dummy_resourceless_instance_callback_11_3(long (*arg0)(struct device * , struct device_attribute * , char * ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 ) { { { pm8001_ctl_mpi_interface_rev_show(arg1, arg2, arg3); } return; } } void ldv_dummy_resourceless_instance_callback_12_3(long (*arg0)(struct device * , struct device_attribute * , char * ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 ) { { { pm8001_ctl_iop_log_show(arg1, arg2, arg3); } return; } } void ldv_dummy_resourceless_instance_callback_13_3(long (*arg0)(struct device * , struct device_attribute * , char * ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 ) { { { pm8001_ctl_logging_level_show(arg1, arg2, arg3); } return; } } void ldv_dummy_resourceless_instance_callback_13_9(long (*arg0)(struct device * , struct device_attribute * , char * , unsigned long ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 , unsigned long arg4 ) { { { pm8001_ctl_logging_level_store(arg1, arg2, (char const *)arg3, arg4); } return; } } void ldv_dummy_resourceless_instance_callback_14_3(long (*arg0)(struct device * , struct device_attribute * , char * ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 ) { { { pm8001_ctl_max_devices_show(arg1, arg2, arg3); } return; } } void ldv_dummy_resourceless_instance_callback_15_3(long (*arg0)(struct device * , struct device_attribute * , char * ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 ) { { { pm8001_ctl_max_out_io_show(arg1, arg2, arg3); } return; } } void ldv_dummy_resourceless_instance_callback_16_3(long (*arg0)(struct device * , struct device_attribute * , char * ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 ) { { { pm8001_ctl_max_sg_list_show(arg1, arg2, arg3); } return; } } void ldv_dummy_resourceless_instance_callback_17_3(long (*arg0)(struct device * , struct device_attribute * , char * ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 ) { { { pm8001_ctl_ob_queue_log_show(arg1, arg2, arg3); } return; } } void ldv_dummy_resourceless_instance_callback_18_3(long (*arg0)(struct device * , struct device_attribute * , char * ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 ) { { { pm8001_ctl_sas_spec_support_show(arg1, arg2, arg3); } return; } } void ldv_dummy_resourceless_instance_callback_19_3(long (*arg0)(struct device * , struct device_attribute * , char * ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 ) { { { pm8001_show_update_fw(arg1, arg2, arg3); } return; } } void ldv_dummy_resourceless_instance_callback_19_9(long (*arg0)(struct device * , struct device_attribute * , char * , unsigned long ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 , unsigned long arg4 ) { { { pm8001_store_update_fw(arg1, arg2, (char const *)arg3, arg4); } return; } } void ldv_dummy_resourceless_instance_callback_4_3(long (*arg0)(struct device * , struct device_attribute * , char * ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 ) { { { pm8001_ctl_aap_log_show(arg1, arg2, arg3); } return; } } void ldv_dummy_resourceless_instance_callback_5_3(long (*arg0)(struct device * , struct device_attribute * , char * ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 ) { { { pm8001_ctl_bios_version_show(arg1, arg2, arg3); } return; } } void ldv_dummy_resourceless_instance_callback_6_3(long (*arg0)(struct device * , struct device_attribute * , char * ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 ) { { { pm8001_ctl_fatal_log_show(arg1, arg2, arg3); } return; } } void ldv_dummy_resourceless_instance_callback_7_3(long (*arg0)(struct device * , struct device_attribute * , char * ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 ) { { { pm8001_ctl_fw_version_show(arg1, arg2, arg3); } return; } } void ldv_dummy_resourceless_instance_callback_8_3(long (*arg0)(struct device * , struct device_attribute * , char * ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 ) { { { pm8001_ctl_gsm_log_show(arg1, arg2, arg3); } return; } } void ldv_dummy_resourceless_instance_callback_9_3(long (*arg0)(struct device * , struct device_attribute * , char * ) , struct device *arg1 , struct device_attribute *arg2 , char *arg3 ) { { { pm8001_ctl_host_sas_address_show(arg1, arg2, arg3); } return; } } void ldv_struct_device_attribute_dummy_resourceless_instance_10(void *arg0 ) { long (*ldv_10_callback_show)(struct device * , struct device_attribute * , char * ) ; long (*ldv_10_callback_store)(struct device * , struct device_attribute * , char * , unsigned long ) ; struct device_attribute *ldv_10_container_struct_device_attribute ; struct device *ldv_10_container_struct_device_ptr ; char *ldv_10_ldv_param_3_2_default ; char *ldv_10_ldv_param_9_2_default ; unsigned long ldv_10_ldv_param_9_3_default ; void *tmp ; void *tmp___0 ; int tmp___1 ; int tmp___2 ; { goto ldv_call_10; return; ldv_call_10: { tmp___2 = ldv_undef_int(); } if (tmp___2 != 0) { { tmp = ldv_xmalloc(1UL); ldv_10_ldv_param_3_2_default = (char *)tmp; tmp___1 = ldv_undef_int(); } if (tmp___1 != 0) { { tmp___0 = ldv_xmalloc(1UL); ldv_10_ldv_param_9_2_default = (char *)tmp___0; } if ((unsigned long )ldv_10_callback_store != (unsigned long )((long (*)(struct device * , struct device_attribute * , char * , unsigned long ))0)) { { ldv_dummy_resourceless_instance_callback_10_9(ldv_10_callback_store, ldv_10_container_struct_device_ptr, ldv_10_container_struct_device_attribute, ldv_10_ldv_param_9_2_default, ldv_10_ldv_param_9_3_default); } } else { } { ldv_free((void *)ldv_10_ldv_param_9_2_default); } } else { { ldv_dummy_resourceless_instance_callback_10_3(ldv_10_callback_show, ldv_10_container_struct_device_ptr, ldv_10_container_struct_device_attribute, ldv_10_ldv_param_3_2_default); } } { ldv_free((void *)ldv_10_ldv_param_3_2_default); } goto ldv_call_10; } else { return; } return; } } void ldv_struct_device_attribute_dummy_resourceless_instance_11(void *arg0 ) { long (*ldv_11_callback_show)(struct device * , struct device_attribute * , char * ) ; long (*ldv_11_callback_store)(struct device * , struct device_attribute * , char * , unsigned long ) ; struct device_attribute *ldv_11_container_struct_device_attribute ; struct device *ldv_11_container_struct_device_ptr ; char *ldv_11_ldv_param_3_2_default ; char *ldv_11_ldv_param_9_2_default ; unsigned long ldv_11_ldv_param_9_3_default ; void *tmp ; void *tmp___0 ; int tmp___1 ; int tmp___2 ; { goto ldv_call_11; return; ldv_call_11: { tmp___2 = ldv_undef_int(); } if (tmp___2 != 0) { { tmp = ldv_xmalloc(1UL); ldv_11_ldv_param_3_2_default = (char *)tmp; tmp___1 = ldv_undef_int(); } if (tmp___1 != 0) { { tmp___0 = ldv_xmalloc(1UL); ldv_11_ldv_param_9_2_default = (char *)tmp___0; } if ((unsigned long )ldv_11_callback_store != (unsigned long )((long (*)(struct device * , struct device_attribute * , char * , unsigned long ))0)) { { ldv_dummy_resourceless_instance_callback_11_9(ldv_11_callback_store, ldv_11_container_struct_device_ptr, ldv_11_container_struct_device_attribute, ldv_11_ldv_param_9_2_default, ldv_11_ldv_param_9_3_default); } } else { } { ldv_free((void *)ldv_11_ldv_param_9_2_default); } } else { { ldv_dummy_resourceless_instance_callback_11_3(ldv_11_callback_show, ldv_11_container_struct_device_ptr, ldv_11_container_struct_device_attribute, ldv_11_ldv_param_3_2_default); } } { ldv_free((void *)ldv_11_ldv_param_3_2_default); } goto ldv_call_11; } else { return; } return; } } void ldv_struct_device_attribute_dummy_resourceless_instance_12(void *arg0 ) { long (*ldv_12_callback_show)(struct device * , struct device_attribute * , char * ) ; long (*ldv_12_callback_store)(struct device * , struct device_attribute * , char * , unsigned long ) ; struct device_attribute *ldv_12_container_struct_device_attribute ; struct device *ldv_12_container_struct_device_ptr ; char *ldv_12_ldv_param_3_2_default ; char *ldv_12_ldv_param_9_2_default ; unsigned long ldv_12_ldv_param_9_3_default ; void *tmp ; void *tmp___0 ; int tmp___1 ; int tmp___2 ; { goto ldv_call_12; return; ldv_call_12: { tmp___2 = ldv_undef_int(); } if (tmp___2 != 0) { { tmp = ldv_xmalloc(1UL); ldv_12_ldv_param_3_2_default = (char *)tmp; tmp___1 = ldv_undef_int(); } if (tmp___1 != 0) { { tmp___0 = ldv_xmalloc(1UL); ldv_12_ldv_param_9_2_default = (char *)tmp___0; } if ((unsigned long )ldv_12_callback_store != (unsigned long )((long (*)(struct device * , struct device_attribute * , char * , unsigned long ))0)) { { ldv_dummy_resourceless_instance_callback_12_9(ldv_12_callback_store, ldv_12_container_struct_device_ptr, ldv_12_container_struct_device_attribute, ldv_12_ldv_param_9_2_default, ldv_12_ldv_param_9_3_default); } } else { } { ldv_free((void *)ldv_12_ldv_param_9_2_default); } } else { { ldv_dummy_resourceless_instance_callback_12_3(ldv_12_callback_show, ldv_12_container_struct_device_ptr, ldv_12_container_struct_device_attribute, ldv_12_ldv_param_3_2_default); } } { ldv_free((void *)ldv_12_ldv_param_3_2_default); } goto ldv_call_12; } else { return; } return; } } void ldv_struct_device_attribute_dummy_resourceless_instance_13(void *arg0 ) { long (*ldv_13_callback_show)(struct device * , struct device_attribute * , char * ) ; long (*ldv_13_callback_store)(struct device * , struct device_attribute * , char * , unsigned long ) ; struct device_attribute *ldv_13_container_struct_device_attribute ; struct device *ldv_13_container_struct_device_ptr ; char *ldv_13_ldv_param_3_2_default ; char *ldv_13_ldv_param_9_2_default ; unsigned long ldv_13_ldv_param_9_3_default ; void *tmp ; void *tmp___0 ; int tmp___1 ; int tmp___2 ; { goto ldv_call_13; return; ldv_call_13: { tmp___2 = ldv_undef_int(); } if (tmp___2 != 0) { { tmp = ldv_xmalloc(1UL); ldv_13_ldv_param_3_2_default = (char *)tmp; tmp___1 = ldv_undef_int(); } if (tmp___1 != 0) { { tmp___0 = ldv_xmalloc(1UL); ldv_13_ldv_param_9_2_default = (char *)tmp___0; ldv_dummy_resourceless_instance_callback_13_9(ldv_13_callback_store, ldv_13_container_struct_device_ptr, ldv_13_container_struct_device_attribute, ldv_13_ldv_param_9_2_default, ldv_13_ldv_param_9_3_default); ldv_free((void *)ldv_13_ldv_param_9_2_default); } } else { { ldv_dummy_resourceless_instance_callback_13_3(ldv_13_callback_show, ldv_13_container_struct_device_ptr, ldv_13_container_struct_device_attribute, ldv_13_ldv_param_3_2_default); } } { ldv_free((void *)ldv_13_ldv_param_3_2_default); } goto ldv_call_13; } else { return; } return; } } void ldv_struct_device_attribute_dummy_resourceless_instance_14(void *arg0 ) { long (*ldv_14_callback_show)(struct device * , struct device_attribute * , char * ) ; long (*ldv_14_callback_store)(struct device * , struct device_attribute * , char * , unsigned long ) ; struct device_attribute *ldv_14_container_struct_device_attribute ; struct device *ldv_14_container_struct_device_ptr ; char *ldv_14_ldv_param_3_2_default ; char *ldv_14_ldv_param_9_2_default ; unsigned long ldv_14_ldv_param_9_3_default ; void *tmp ; void *tmp___0 ; int tmp___1 ; int tmp___2 ; { goto ldv_call_14; return; ldv_call_14: { tmp___2 = ldv_undef_int(); } if (tmp___2 != 0) { { tmp = ldv_xmalloc(1UL); ldv_14_ldv_param_3_2_default = (char *)tmp; tmp___1 = ldv_undef_int(); } if (tmp___1 != 0) { { tmp___0 = ldv_xmalloc(1UL); ldv_14_ldv_param_9_2_default = (char *)tmp___0; } if ((unsigned long )ldv_14_callback_store != (unsigned long )((long (*)(struct device * , struct device_attribute * , char * , unsigned long ))0)) { { ldv_dummy_resourceless_instance_callback_14_9(ldv_14_callback_store, ldv_14_container_struct_device_ptr, ldv_14_container_struct_device_attribute, ldv_14_ldv_param_9_2_default, ldv_14_ldv_param_9_3_default); } } else { } { ldv_free((void *)ldv_14_ldv_param_9_2_default); } } else { { ldv_dummy_resourceless_instance_callback_14_3(ldv_14_callback_show, ldv_14_container_struct_device_ptr, ldv_14_container_struct_device_attribute, ldv_14_ldv_param_3_2_default); } } { ldv_free((void *)ldv_14_ldv_param_3_2_default); } goto ldv_call_14; } else { return; } return; } } void ldv_struct_device_attribute_dummy_resourceless_instance_15(void *arg0 ) { long (*ldv_15_callback_show)(struct device * , struct device_attribute * , char * ) ; long (*ldv_15_callback_store)(struct device * , struct device_attribute * , char * , unsigned long ) ; struct device_attribute *ldv_15_container_struct_device_attribute ; struct device *ldv_15_container_struct_device_ptr ; char *ldv_15_ldv_param_3_2_default ; char *ldv_15_ldv_param_9_2_default ; unsigned long ldv_15_ldv_param_9_3_default ; void *tmp ; void *tmp___0 ; int tmp___1 ; int tmp___2 ; { goto ldv_call_15; return; ldv_call_15: { tmp___2 = ldv_undef_int(); } if (tmp___2 != 0) { { tmp = ldv_xmalloc(1UL); ldv_15_ldv_param_3_2_default = (char *)tmp; tmp___1 = ldv_undef_int(); } if (tmp___1 != 0) { { tmp___0 = ldv_xmalloc(1UL); ldv_15_ldv_param_9_2_default = (char *)tmp___0; } if ((unsigned long )ldv_15_callback_store != (unsigned long )((long (*)(struct device * , struct device_attribute * , char * , unsigned long ))0)) { { ldv_dummy_resourceless_instance_callback_15_9(ldv_15_callback_store, ldv_15_container_struct_device_ptr, ldv_15_container_struct_device_attribute, ldv_15_ldv_param_9_2_default, ldv_15_ldv_param_9_3_default); } } else { } { ldv_free((void *)ldv_15_ldv_param_9_2_default); } } else { { ldv_dummy_resourceless_instance_callback_15_3(ldv_15_callback_show, ldv_15_container_struct_device_ptr, ldv_15_container_struct_device_attribute, ldv_15_ldv_param_3_2_default); } } { ldv_free((void *)ldv_15_ldv_param_3_2_default); } goto ldv_call_15; } else { return; } return; } } void ldv_struct_device_attribute_dummy_resourceless_instance_16(void *arg0 ) { long (*ldv_16_callback_show)(struct device * , struct device_attribute * , char * ) ; long (*ldv_16_callback_store)(struct device * , struct device_attribute * , char * , unsigned long ) ; struct device_attribute *ldv_16_container_struct_device_attribute ; struct device *ldv_16_container_struct_device_ptr ; char *ldv_16_ldv_param_3_2_default ; char *ldv_16_ldv_param_9_2_default ; unsigned long ldv_16_ldv_param_9_3_default ; void *tmp ; void *tmp___0 ; int tmp___1 ; int tmp___2 ; { goto ldv_call_16; return; ldv_call_16: { tmp___2 = ldv_undef_int(); } if (tmp___2 != 0) { { tmp = ldv_xmalloc(1UL); ldv_16_ldv_param_3_2_default = (char *)tmp; tmp___1 = ldv_undef_int(); } if (tmp___1 != 0) { { tmp___0 = ldv_xmalloc(1UL); ldv_16_ldv_param_9_2_default = (char *)tmp___0; } if ((unsigned long )ldv_16_callback_store != (unsigned long )((long (*)(struct device * , struct device_attribute * , char * , unsigned long ))0)) { { ldv_dummy_resourceless_instance_callback_16_9(ldv_16_callback_store, ldv_16_container_struct_device_ptr, ldv_16_container_struct_device_attribute, ldv_16_ldv_param_9_2_default, ldv_16_ldv_param_9_3_default); } } else { } { ldv_free((void *)ldv_16_ldv_param_9_2_default); } } else { { ldv_dummy_resourceless_instance_callback_16_3(ldv_16_callback_show, ldv_16_container_struct_device_ptr, ldv_16_container_struct_device_attribute, ldv_16_ldv_param_3_2_default); } } { ldv_free((void *)ldv_16_ldv_param_3_2_default); } goto ldv_call_16; } else { return; } return; } } void ldv_struct_device_attribute_dummy_resourceless_instance_17(void *arg0 ) { long (*ldv_17_callback_show)(struct device * , struct device_attribute * , char * ) ; long (*ldv_17_callback_store)(struct device * , struct device_attribute * , char * , unsigned long ) ; struct device_attribute *ldv_17_container_struct_device_attribute ; struct device *ldv_17_container_struct_device_ptr ; char *ldv_17_ldv_param_3_2_default ; char *ldv_17_ldv_param_9_2_default ; unsigned long ldv_17_ldv_param_9_3_default ; void *tmp ; void *tmp___0 ; int tmp___1 ; int tmp___2 ; { goto ldv_call_17; return; ldv_call_17: { tmp___2 = ldv_undef_int(); } if (tmp___2 != 0) { { tmp = ldv_xmalloc(1UL); ldv_17_ldv_param_3_2_default = (char *)tmp; tmp___1 = ldv_undef_int(); } if (tmp___1 != 0) { { tmp___0 = ldv_xmalloc(1UL); ldv_17_ldv_param_9_2_default = (char *)tmp___0; } if ((unsigned long )ldv_17_callback_store != (unsigned long )((long (*)(struct device * , struct device_attribute * , char * , unsigned long ))0)) { { ldv_dummy_resourceless_instance_callback_17_9(ldv_17_callback_store, ldv_17_container_struct_device_ptr, ldv_17_container_struct_device_attribute, ldv_17_ldv_param_9_2_default, ldv_17_ldv_param_9_3_default); } } else { } { ldv_free((void *)ldv_17_ldv_param_9_2_default); } } else { { ldv_dummy_resourceless_instance_callback_17_3(ldv_17_callback_show, ldv_17_container_struct_device_ptr, ldv_17_container_struct_device_attribute, ldv_17_ldv_param_3_2_default); } } { ldv_free((void *)ldv_17_ldv_param_3_2_default); } goto ldv_call_17; } else { return; } return; } } void ldv_struct_device_attribute_dummy_resourceless_instance_18(void *arg0 ) { long (*ldv_18_callback_show)(struct device * , struct device_attribute * , char * ) ; long (*ldv_18_callback_store)(struct device * , struct device_attribute * , char * , unsigned long ) ; struct device_attribute *ldv_18_container_struct_device_attribute ; struct device *ldv_18_container_struct_device_ptr ; char *ldv_18_ldv_param_3_2_default ; char *ldv_18_ldv_param_9_2_default ; unsigned long ldv_18_ldv_param_9_3_default ; void *tmp ; void *tmp___0 ; int tmp___1 ; int tmp___2 ; { goto ldv_call_18; return; ldv_call_18: { tmp___2 = ldv_undef_int(); } if (tmp___2 != 0) { { tmp = ldv_xmalloc(1UL); ldv_18_ldv_param_3_2_default = (char *)tmp; tmp___1 = ldv_undef_int(); } if (tmp___1 != 0) { { tmp___0 = ldv_xmalloc(1UL); ldv_18_ldv_param_9_2_default = (char *)tmp___0; } if ((unsigned long )ldv_18_callback_store != (unsigned long )((long (*)(struct device * , struct device_attribute * , char * , unsigned long ))0)) { { ldv_dummy_resourceless_instance_callback_18_9(ldv_18_callback_store, ldv_18_container_struct_device_ptr, ldv_18_container_struct_device_attribute, ldv_18_ldv_param_9_2_default, ldv_18_ldv_param_9_3_default); } } else { } { ldv_free((void *)ldv_18_ldv_param_9_2_default); } } else { { ldv_dummy_resourceless_instance_callback_18_3(ldv_18_callback_show, ldv_18_container_struct_device_ptr, ldv_18_container_struct_device_attribute, ldv_18_ldv_param_3_2_default); } } { ldv_free((void *)ldv_18_ldv_param_3_2_default); } goto ldv_call_18; } else { return; } return; } } void ldv_struct_device_attribute_dummy_resourceless_instance_19(void *arg0 ) { long (*ldv_19_callback_show)(struct device * , struct device_attribute * , char * ) ; long (*ldv_19_callback_store)(struct device * , struct device_attribute * , char * , unsigned long ) ; struct device_attribute *ldv_19_container_struct_device_attribute ; struct device *ldv_19_container_struct_device_ptr ; char *ldv_19_ldv_param_3_2_default ; char *ldv_19_ldv_param_9_2_default ; unsigned long ldv_19_ldv_param_9_3_default ; void *tmp ; void *tmp___0 ; int tmp___1 ; int tmp___2 ; { goto ldv_call_19; return; ldv_call_19: { tmp___2 = ldv_undef_int(); } if (tmp___2 != 0) { { tmp = ldv_xmalloc(1UL); ldv_19_ldv_param_3_2_default = (char *)tmp; tmp___1 = ldv_undef_int(); } if (tmp___1 != 0) { { tmp___0 = ldv_xmalloc(1UL); ldv_19_ldv_param_9_2_default = (char *)tmp___0; ldv_dummy_resourceless_instance_callback_19_9(ldv_19_callback_store, ldv_19_container_struct_device_ptr, ldv_19_container_struct_device_attribute, ldv_19_ldv_param_9_2_default, ldv_19_ldv_param_9_3_default); ldv_free((void *)ldv_19_ldv_param_9_2_default); } } else { { ldv_dummy_resourceless_instance_callback_19_3(ldv_19_callback_show, ldv_19_container_struct_device_ptr, ldv_19_container_struct_device_attribute, ldv_19_ldv_param_3_2_default); } } { ldv_free((void *)ldv_19_ldv_param_3_2_default); } goto ldv_call_19; } else { return; } return; } } void ldv_struct_device_attribute_dummy_resourceless_instance_4(void *arg0 ) { long (*ldv_4_callback_show)(struct device * , struct device_attribute * , char * ) ; long (*ldv_4_callback_store)(struct device * , struct device_attribute * , char * , unsigned long ) ; struct device_attribute *ldv_4_container_struct_device_attribute ; struct device *ldv_4_container_struct_device_ptr ; char *ldv_4_ldv_param_3_2_default ; char *ldv_4_ldv_param_9_2_default ; unsigned long ldv_4_ldv_param_9_3_default ; void *tmp ; void *tmp___0 ; int tmp___1 ; int tmp___2 ; { goto ldv_call_4; return; ldv_call_4: { tmp___2 = ldv_undef_int(); } if (tmp___2 != 0) { { tmp = ldv_xmalloc(1UL); ldv_4_ldv_param_3_2_default = (char *)tmp; tmp___1 = ldv_undef_int(); } if (tmp___1 != 0) { { tmp___0 = ldv_xmalloc(1UL); ldv_4_ldv_param_9_2_default = (char *)tmp___0; } if ((unsigned long )ldv_4_callback_store != (unsigned long )((long (*)(struct device * , struct device_attribute * , char * , unsigned long ))0)) { { ldv_dummy_resourceless_instance_callback_4_9(ldv_4_callback_store, ldv_4_container_struct_device_ptr, ldv_4_container_struct_device_attribute, ldv_4_ldv_param_9_2_default, ldv_4_ldv_param_9_3_default); } } else { } { ldv_free((void *)ldv_4_ldv_param_9_2_default); } } else { { ldv_dummy_resourceless_instance_callback_4_3(ldv_4_callback_show, ldv_4_container_struct_device_ptr, ldv_4_container_struct_device_attribute, ldv_4_ldv_param_3_2_default); } } { ldv_free((void *)ldv_4_ldv_param_3_2_default); } goto ldv_call_4; } else { return; } return; } } void ldv_struct_device_attribute_dummy_resourceless_instance_5(void *arg0 ) { long (*ldv_5_callback_show)(struct device * , struct device_attribute * , char * ) ; long (*ldv_5_callback_store)(struct device * , struct device_attribute * , char * , unsigned long ) ; struct device_attribute *ldv_5_container_struct_device_attribute ; struct device *ldv_5_container_struct_device_ptr ; char *ldv_5_ldv_param_3_2_default ; char *ldv_5_ldv_param_9_2_default ; unsigned long ldv_5_ldv_param_9_3_default ; void *tmp ; void *tmp___0 ; int tmp___1 ; int tmp___2 ; { goto ldv_call_5; return; ldv_call_5: { tmp___2 = ldv_undef_int(); } if (tmp___2 != 0) { { tmp = ldv_xmalloc(1UL); ldv_5_ldv_param_3_2_default = (char *)tmp; tmp___1 = ldv_undef_int(); } if (tmp___1 != 0) { { tmp___0 = ldv_xmalloc(1UL); ldv_5_ldv_param_9_2_default = (char *)tmp___0; } if ((unsigned long )ldv_5_callback_store != (unsigned long )((long (*)(struct device * , struct device_attribute * , char * , unsigned long ))0)) { { ldv_dummy_resourceless_instance_callback_5_9(ldv_5_callback_store, ldv_5_container_struct_device_ptr, ldv_5_container_struct_device_attribute, ldv_5_ldv_param_9_2_default, ldv_5_ldv_param_9_3_default); } } else { } { ldv_free((void *)ldv_5_ldv_param_9_2_default); } } else { { ldv_dummy_resourceless_instance_callback_5_3(ldv_5_callback_show, ldv_5_container_struct_device_ptr, ldv_5_container_struct_device_attribute, ldv_5_ldv_param_3_2_default); } } { ldv_free((void *)ldv_5_ldv_param_3_2_default); } goto ldv_call_5; } else { return; } return; } } void ldv_struct_device_attribute_dummy_resourceless_instance_6(void *arg0 ) { long (*ldv_6_callback_show)(struct device * , struct device_attribute * , char * ) ; long (*ldv_6_callback_store)(struct device * , struct device_attribute * , char * , unsigned long ) ; struct device_attribute *ldv_6_container_struct_device_attribute ; struct device *ldv_6_container_struct_device_ptr ; char *ldv_6_ldv_param_3_2_default ; char *ldv_6_ldv_param_9_2_default ; unsigned long ldv_6_ldv_param_9_3_default ; void *tmp ; void *tmp___0 ; int tmp___1 ; int tmp___2 ; { goto ldv_call_6; return; ldv_call_6: { tmp___2 = ldv_undef_int(); } if (tmp___2 != 0) { { tmp = ldv_xmalloc(1UL); ldv_6_ldv_param_3_2_default = (char *)tmp; tmp___1 = ldv_undef_int(); } if (tmp___1 != 0) { { tmp___0 = ldv_xmalloc(1UL); ldv_6_ldv_param_9_2_default = (char *)tmp___0; } if ((unsigned long )ldv_6_callback_store != (unsigned long )((long (*)(struct device * , struct device_attribute * , char * , unsigned long ))0)) { { ldv_dummy_resourceless_instance_callback_6_9(ldv_6_callback_store, ldv_6_container_struct_device_ptr, ldv_6_container_struct_device_attribute, ldv_6_ldv_param_9_2_default, ldv_6_ldv_param_9_3_default); } } else { } { ldv_free((void *)ldv_6_ldv_param_9_2_default); } } else { { ldv_dummy_resourceless_instance_callback_6_3(ldv_6_callback_show, ldv_6_container_struct_device_ptr, ldv_6_container_struct_device_attribute, ldv_6_ldv_param_3_2_default); } } { ldv_free((void *)ldv_6_ldv_param_3_2_default); } goto ldv_call_6; } else { return; } return; } } void ldv_struct_device_attribute_dummy_resourceless_instance_7(void *arg0 ) { long (*ldv_7_callback_show)(struct device * , struct device_attribute * , char * ) ; long (*ldv_7_callback_store)(struct device * , struct device_attribute * , char * , unsigned long ) ; struct device_attribute *ldv_7_container_struct_device_attribute ; struct device *ldv_7_container_struct_device_ptr ; char *ldv_7_ldv_param_3_2_default ; char *ldv_7_ldv_param_9_2_default ; unsigned long ldv_7_ldv_param_9_3_default ; void *tmp ; void *tmp___0 ; int tmp___1 ; int tmp___2 ; { goto ldv_call_7; return; ldv_call_7: { tmp___2 = ldv_undef_int(); } if (tmp___2 != 0) { { tmp = ldv_xmalloc(1UL); ldv_7_ldv_param_3_2_default = (char *)tmp; tmp___1 = ldv_undef_int(); } if (tmp___1 != 0) { { tmp___0 = ldv_xmalloc(1UL); ldv_7_ldv_param_9_2_default = (char *)tmp___0; } if ((unsigned long )ldv_7_callback_store != (unsigned long )((long (*)(struct device * , struct device_attribute * , char * , unsigned long ))0)) { { ldv_dummy_resourceless_instance_callback_7_9(ldv_7_callback_store, ldv_7_container_struct_device_ptr, ldv_7_container_struct_device_attribute, ldv_7_ldv_param_9_2_default, ldv_7_ldv_param_9_3_default); } } else { } { ldv_free((void *)ldv_7_ldv_param_9_2_default); } } else { { ldv_dummy_resourceless_instance_callback_7_3(ldv_7_callback_show, ldv_7_container_struct_device_ptr, ldv_7_container_struct_device_attribute, ldv_7_ldv_param_3_2_default); } } { ldv_free((void *)ldv_7_ldv_param_3_2_default); } goto ldv_call_7; } else { return; } return; } } void ldv_struct_device_attribute_dummy_resourceless_instance_8(void *arg0 ) { long (*ldv_8_callback_show)(struct device * , struct device_attribute * , char * ) ; long (*ldv_8_callback_store)(struct device * , struct device_attribute * , char * , unsigned long ) ; struct device_attribute *ldv_8_container_struct_device_attribute ; struct device *ldv_8_container_struct_device_ptr ; char *ldv_8_ldv_param_3_2_default ; char *ldv_8_ldv_param_9_2_default ; unsigned long ldv_8_ldv_param_9_3_default ; void *tmp ; void *tmp___0 ; int tmp___1 ; int tmp___2 ; { goto ldv_call_8; return; ldv_call_8: { tmp___2 = ldv_undef_int(); } if (tmp___2 != 0) { { tmp = ldv_xmalloc(1UL); ldv_8_ldv_param_3_2_default = (char *)tmp; tmp___1 = ldv_undef_int(); } if (tmp___1 != 0) { { tmp___0 = ldv_xmalloc(1UL); ldv_8_ldv_param_9_2_default = (char *)tmp___0; } if ((unsigned long )ldv_8_callback_store != (unsigned long )((long (*)(struct device * , struct device_attribute * , char * , unsigned long ))0)) { { ldv_dummy_resourceless_instance_callback_8_9(ldv_8_callback_store, ldv_8_container_struct_device_ptr, ldv_8_container_struct_device_attribute, ldv_8_ldv_param_9_2_default, ldv_8_ldv_param_9_3_default); } } else { } { ldv_free((void *)ldv_8_ldv_param_9_2_default); } } else { { ldv_dummy_resourceless_instance_callback_8_3(ldv_8_callback_show, ldv_8_container_struct_device_ptr, ldv_8_container_struct_device_attribute, ldv_8_ldv_param_3_2_default); } } { ldv_free((void *)ldv_8_ldv_param_3_2_default); } goto ldv_call_8; } else { return; } return; } } void ldv_struct_device_attribute_dummy_resourceless_instance_9(void *arg0 ) { long (*ldv_9_callback_show)(struct device * , struct device_attribute * , char * ) ; long (*ldv_9_callback_store)(struct device * , struct device_attribute * , char * , unsigned long ) ; struct device_attribute *ldv_9_container_struct_device_attribute ; struct device *ldv_9_container_struct_device_ptr ; char *ldv_9_ldv_param_3_2_default ; char *ldv_9_ldv_param_9_2_default ; unsigned long ldv_9_ldv_param_9_3_default ; void *tmp ; void *tmp___0 ; int tmp___1 ; int tmp___2 ; { goto ldv_call_9; return; ldv_call_9: { tmp___2 = ldv_undef_int(); } if (tmp___2 != 0) { { tmp = ldv_xmalloc(1UL); ldv_9_ldv_param_3_2_default = (char *)tmp; tmp___1 = ldv_undef_int(); } if (tmp___1 != 0) { { tmp___0 = ldv_xmalloc(1UL); ldv_9_ldv_param_9_2_default = (char *)tmp___0; } if ((unsigned long )ldv_9_callback_store != (unsigned long )((long (*)(struct device * , struct device_attribute * , char * , unsigned long ))0)) { { ldv_dummy_resourceless_instance_callback_9_9(ldv_9_callback_store, ldv_9_container_struct_device_ptr, ldv_9_container_struct_device_attribute, ldv_9_ldv_param_9_2_default, ldv_9_ldv_param_9_3_default); } } else { } { ldv_free((void *)ldv_9_ldv_param_9_2_default); } } else { { ldv_dummy_resourceless_instance_callback_9_3(ldv_9_callback_show, ldv_9_container_struct_device_ptr, ldv_9_container_struct_device_attribute, ldv_9_ldv_param_3_2_default); } } { ldv_free((void *)ldv_9_ldv_param_3_2_default); } goto ldv_call_9; } else { return; } return; } } static void ldv_wait_for_completion_101___0(struct completion *ldv_func_arg1 ) { { { ldv_linux_kernel_sched_completion_wait_for_completion_completion(); wait_for_completion(ldv_func_arg1); } return; } } static void ldv_wait_for_completion_103___0(struct completion *ldv_func_arg1 ) { { { ldv_linux_kernel_sched_completion_wait_for_completion_completion(); wait_for_completion(ldv_func_arg1); } return; } } static void ldv_wait_for_completion_105___0(struct completion *ldv_func_arg1 ) { { { ldv_linux_kernel_sched_completion_wait_for_completion_completion(); wait_for_completion(ldv_func_arg1); } return; } } void ldv_linux_arch_io_io_mem_unmap(void) ; extern void lockdep_init_map(struct lockdep_map * , char const * , struct lock_class_key * , int ) ; static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_100___0(spinlock_t *ldv_func_arg1 ) ; static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_104(spinlock_t *ldv_func_arg1 ) ; static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_108___0(spinlock_t *ldv_func_arg1 ) ; static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_112(spinlock_t *ldv_func_arg1 ) ; static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_124(spinlock_t *ldv_func_arg1 ) ; static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_125(spinlock_t *ldv_func_arg1 ) ; static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_130(spinlock_t *ldv_func_arg1 ) ; static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_135(spinlock_t *ldv_func_arg1 ) ; static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_136(spinlock_t *ldv_func_arg1 ) ; static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_144(spinlock_t *ldv_func_arg1 ) ; static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_147(spinlock_t *ldv_func_arg1 ) ; static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_150(spinlock_t *ldv_func_arg1 ) ; static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_153(spinlock_t *ldv_func_arg1 ) ; static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_156(spinlock_t *ldv_func_arg1 ) ; static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_159(spinlock_t *ldv_func_arg1 ) ; static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_161(spinlock_t *ldv_func_arg1 ) ; static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_163(spinlock_t *ldv_func_arg1 ) ; static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_165(spinlock_t *ldv_func_arg1 ) ; static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_167(spinlock_t *ldv_func_arg1 ) ; static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_169(spinlock_t *ldv_func_arg1 ) ; static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_171(spinlock_t *ldv_func_arg1 ) ; static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_173(spinlock_t *ldv_func_arg1 ) ; void ldv_linux_kernel_locking_spinlock_spin_lock_frame_rcvd_lock_of_asd_sas_phy(void) ; void ldv_linux_kernel_locking_spinlock_spin_unlock_frame_rcvd_lock_of_asd_sas_phy(void) ; void ldv_linux_kernel_locking_spinlock_spin_lock_sas_prim_lock_of_asd_sas_phy(void) ; void ldv_linux_kernel_locking_spinlock_spin_unlock_sas_prim_lock_of_asd_sas_phy(void) ; __inline static void ldv_spin_lock_99(spinlock_t *lock ) ; __inline static void ldv_spin_unlock_98(spinlock_t *lock ) ; __inline static void ldv_spin_unlock_irqrestore_109(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_109(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_109(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_109(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_109(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_109(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_109(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_109(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_109(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_109(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_109(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_109(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_109(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_109(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_109(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_109(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_109(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_109(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_109(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_135(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_109(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_135(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_109(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_135(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_109(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_135(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_109(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_135(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_109(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_135(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_109(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_109(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_109(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_109(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_135(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_135(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_135(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_135(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_135(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_135(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_135(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_135(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_135(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_135(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_160(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_160(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_135(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_166(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_166(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_166(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_109(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_135(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_135(spinlock_t *lock , unsigned long flags ) ; extern void __init_work(struct work_struct * , int ) ; extern bool queue_work_on(int , struct workqueue_struct * , struct work_struct * ) ; __inline static bool queue_work(struct workqueue_struct *wq , struct work_struct *work ) { bool tmp ; { { tmp = queue_work_on(8192, wq, work); } return (tmp); } } __inline static unsigned int readl(void const volatile *addr ) { unsigned int ret ; { __asm__ volatile ("movl %1,%0": "=r" (ret): "m" (*((unsigned int volatile *)addr)): "memory"); return (ret); } } __inline static void writel(unsigned int val , void volatile *addr ) { { __asm__ volatile ("movl %0,%1": : "r" (val), "m" (*((unsigned int volatile *)addr)): "memory"); return; } } static void ldv_iounmap_123(void volatile *ldv_func_arg1 ) ; __inline static void *kmalloc(size_t size , gfp_t flags ) ; __inline static void *kzalloc(size_t size , gfp_t flags ) ; __inline static int dma_map_sg_attrs___0(struct device *dev , struct scatterlist *sg , int nents , enum dma_data_direction dir , struct dma_attrs *attrs ) { struct dma_map_ops *ops ; struct dma_map_ops *tmp ; int i ; int ents ; struct scatterlist *s ; void *tmp___0 ; int tmp___1 ; long tmp___2 ; { { tmp = get_dma_ops(dev); ops = tmp; i = 0; s = sg; } goto ldv_26557; ldv_26556: { tmp___0 = sg_virt(s); kmemcheck_mark_initialized(tmp___0, s->length); i = i + 1; s = sg_next(s); } ldv_26557: ; if (i < nents) { goto ldv_26556; } else { } { tmp___1 = valid_dma_direction((int )dir); tmp___2 = ldv__builtin_expect(tmp___1 == 0, 0L); } if (tmp___2 != 0L) { { __asm__ volatile ("1:\tud2\n.pushsection __bug_table,\"a\"\n2:\t.long 1b - 2b, %c0 - 2b\n\t.word %c1, 0\n\t.org 2b+%c2\n.popsection": : "i" ((char *)"include/asm-generic/dma-mapping-common.h"), "i" (52), "i" (12UL)); __builtin_unreachable(); } } else { } { ents = (*(ops->map_sg))(dev, sg, nents, dir, attrs); debug_dma_map_sg(dev, sg, nents, ents, (int )dir); } return (ents); } } extern void __const_udelay(unsigned long ) ; __inline static void sas_phy_disconnected(struct asd_sas_phy *phy ) { { phy->oob_mode = 0; phy->linkrate = 0; return; } } extern void sas_ssp_task_response(struct device * , struct sas_task * , struct ssp_response_iu * ) ; void pm8001_chip_iounmap(struct pm8001_hba_info *pm8001_ha ) ; int pm8001_mpi_build_cmd(struct pm8001_hba_info *pm8001_ha , struct inbound_queue_table *circularQ , u32 opCode , void *payload , u32 responseQueue ) ; int pm8001_mpi_msg_free_get(struct inbound_queue_table *circularQ , u16 messageSize , void **messagePtr ) ; u32 pm8001_mpi_msg_free_set(struct pm8001_hba_info *pm8001_ha , void *pMsg , struct outbound_queue_table *circularQ , u8 bc ) ; u32 pm8001_mpi_msg_consume(struct pm8001_hba_info *pm8001_ha , struct outbound_queue_table *circularQ , void **messagePtr1 , u8 *pBC ) ; int pm8001_chip_set_dev_state_req(struct pm8001_hba_info *pm8001_ha , struct pm8001_device *pm8001_dev , u32 state ) ; int pm8001_chip_fw_flash_update_req(struct pm8001_hba_info *pm8001_ha , void *payload ) ; int pm8001_chip_fw_flash_update_build(struct pm8001_hba_info *pm8001_ha , void *fw_flash_updata_info , u32 tag ) ; int pm8001_chip_set_nvmd_req(struct pm8001_hba_info *pm8001_ha , void *payload ) ; int pm8001_chip_get_nvmd_req(struct pm8001_hba_info *pm8001_ha , void *payload ) ; int pm8001_chip_ssp_tm_req(struct pm8001_hba_info *pm8001_ha , struct pm8001_ccb_info *ccb , struct pm8001_tmf_task *tmf ) ; int pm8001_chip_abort_task(struct pm8001_hba_info *pm8001_ha , struct pm8001_device *pm8001_dev , u8 flag , u32 task_tag , u32 cmd_tag ) ; int pm8001_chip_dereg_dev_req(struct pm8001_hba_info *pm8001_ha , u32 device_id ) ; void pm8001_chip_make_sg(struct scatterlist *scatter , int nr , void *prd ) ; void pm8001_work_fn(struct work_struct *work ) ; int pm8001_handle_event(struct pm8001_hba_info *pm8001_ha , void *data , int handler ) ; void pm8001_mpi_set_dev_state_resp(struct pm8001_hba_info *pm8001_ha , void *piomb ) ; void pm8001_mpi_set_nvmd_resp(struct pm8001_hba_info *pm8001_ha , void *piomb ) ; void pm8001_mpi_get_nvmd_resp(struct pm8001_hba_info *pm8001_ha , void *piomb ) ; int pm8001_mpi_local_phy_ctl(struct pm8001_hba_info *pm8001_ha , void *piomb ) ; void pm8001_get_lrate_mode(struct pm8001_phy *phy , u8 link_rate ) ; void pm8001_get_attached_sas_addr(struct pm8001_phy *phy , u8 *sas_addr ) ; void pm8001_bytes_dmaed(struct pm8001_hba_info *pm8001_ha , int i ) ; int pm8001_mpi_reg_resp(struct pm8001_hba_info *pm8001_ha , void *piomb ) ; int pm8001_mpi_dereg_resp(struct pm8001_hba_info *pm8001_ha , void *piomb ) ; int pm8001_mpi_fw_flash_update_resp(struct pm8001_hba_info *pm8001_ha , void *piomb ) ; int pm8001_mpi_general_event(struct pm8001_hba_info *pm8001_ha , void *piomb ) ; int pm8001_mpi_task_abort_resp(struct pm8001_hba_info *pm8001_ha , void *piomb ) ; int pm80xx_bar4_shift(struct pm8001_hba_info *pm8001_ha , u32 shift_value ) ; __inline static void pm8001_ccb_task_free_done(struct pm8001_hba_info *pm8001_ha , struct sas_task *task , struct pm8001_ccb_info *ccb , u32 ccb_idx ) { { { pm8001_ccb_task_free(pm8001_ha, task, ccb, ccb_idx); __asm__ volatile ("mfence": : : "memory"); ldv_spin_unlock_98(& pm8001_ha->lock); (*(task->task_done))(task); ldv_spin_lock_99(& pm8001_ha->lock); } return; } } __inline static u32 pm8001_read_32(void *virt_addr ) { { return (*((u32 *)virt_addr)); } } __inline static void pm8001_write_32(void *addr , u32 offset , __le32 val ) { { *((__le32 *)addr + (unsigned long )offset) = val; return; } } __inline static u32 pm8001_cr32(struct pm8001_hba_info *pm8001_ha , u32 bar , u32 offset ) { unsigned int tmp ; { { tmp = readl((void const volatile *)pm8001_ha->io_mem[bar].memvirtaddr + (unsigned long )offset); } return (tmp); } } __inline static void pm8001_cw32(struct pm8001_hba_info *pm8001_ha , u32 bar , u32 addr , u32 val ) { { { writel(val, (void volatile *)pm8001_ha->io_mem[bar].memvirtaddr + (unsigned long )addr); } return; } } __inline static u32 pm8001_mr32(void *addr , u32 offset ) { unsigned int tmp ; { { tmp = readl((void const volatile *)addr + (unsigned long )offset); } return (tmp); } } __inline static void pm8001_mw32(void *addr , u32 offset , u32 val ) { { { writel(val, (void volatile *)addr + (unsigned long )offset); } return; } } __inline static u32 get_pci_bar_index(u32 pcibar ) { { { if (pcibar == 24U) { goto case_24; } else { } if (pcibar == 28U) { goto case_28; } else { } if (pcibar == 32U) { goto case_32; } else { } if (pcibar == 36U) { goto case_36; } else { } goto switch_default; case_24: /* CIL Label */ ; case_28: /* CIL Label */ ; return (1U); case_32: /* CIL Label */ ; return (2U); case_36: /* CIL Label */ ; return (3U); switch_default: /* CIL Label */ ; return (0U); switch_break: /* CIL Label */ ; } } } static void read_main_config_table(struct pm8001_hba_info *pm8001_ha ) { void *address ; { { address = pm8001_ha->main_cfg_tbl_addr; pm8001_ha->main_cfg_tbl.pm8001_tbl.signature = pm8001_mr32(address, 0U); pm8001_ha->main_cfg_tbl.pm8001_tbl.interface_rev = pm8001_mr32(address, 4U); pm8001_ha->main_cfg_tbl.pm8001_tbl.firmware_rev = pm8001_mr32(address, 8U); pm8001_ha->main_cfg_tbl.pm8001_tbl.max_out_io = pm8001_mr32(address, 12U); pm8001_ha->main_cfg_tbl.pm8001_tbl.max_sgl = pm8001_mr32(address, 16U); pm8001_ha->main_cfg_tbl.pm8001_tbl.ctrl_cap_flag = pm8001_mr32(address, 20U); pm8001_ha->main_cfg_tbl.pm8001_tbl.gst_offset = pm8001_mr32(address, 24U); pm8001_ha->main_cfg_tbl.pm8001_tbl.inbound_queue_offset = pm8001_mr32(address, 28U); pm8001_ha->main_cfg_tbl.pm8001_tbl.outbound_queue_offset = pm8001_mr32(address, 32U); pm8001_ha->main_cfg_tbl.pm8001_tbl.hda_mode_flag = pm8001_mr32(address, 132U); pm8001_ha->main_cfg_tbl.pm8001_tbl.anolog_setup_table_offset = pm8001_mr32(address, 136U); pm8001_ha->main_cfg_tbl.pm8001_tbl.fatal_err_dump_offset0 = pm8001_mr32(address, 116U); pm8001_ha->main_cfg_tbl.pm8001_tbl.fatal_err_dump_length0 = pm8001_mr32(address, 120U); pm8001_ha->main_cfg_tbl.pm8001_tbl.fatal_err_dump_offset1 = pm8001_mr32(address, 124U); pm8001_ha->main_cfg_tbl.pm8001_tbl.fatal_err_dump_length1 = pm8001_mr32(address, 128U); } return; } } static void read_general_status_table(struct pm8001_hba_info *pm8001_ha ) { void *address ; { { address = pm8001_ha->general_stat_tbl_addr; pm8001_ha->gs_tbl.pm8001_tbl.gst_len_mpistate = pm8001_mr32(address, 0U); pm8001_ha->gs_tbl.pm8001_tbl.iq_freeze_state0 = pm8001_mr32(address, 4U); pm8001_ha->gs_tbl.pm8001_tbl.iq_freeze_state1 = pm8001_mr32(address, 8U); pm8001_ha->gs_tbl.pm8001_tbl.msgu_tcnt = pm8001_mr32(address, 12U); pm8001_ha->gs_tbl.pm8001_tbl.iop_tcnt = pm8001_mr32(address, 16U); pm8001_ha->gs_tbl.pm8001_tbl.rsvd = pm8001_mr32(address, 20U); pm8001_ha->gs_tbl.pm8001_tbl.phy_state[0] = pm8001_mr32(address, 24U); pm8001_ha->gs_tbl.pm8001_tbl.phy_state[1] = pm8001_mr32(address, 28U); pm8001_ha->gs_tbl.pm8001_tbl.phy_state[2] = pm8001_mr32(address, 32U); pm8001_ha->gs_tbl.pm8001_tbl.phy_state[3] = pm8001_mr32(address, 36U); pm8001_ha->gs_tbl.pm8001_tbl.phy_state[4] = pm8001_mr32(address, 40U); pm8001_ha->gs_tbl.pm8001_tbl.phy_state[5] = pm8001_mr32(address, 44U); pm8001_ha->gs_tbl.pm8001_tbl.phy_state[6] = pm8001_mr32(address, 48U); pm8001_ha->gs_tbl.pm8001_tbl.phy_state[7] = pm8001_mr32(address, 52U); pm8001_ha->gs_tbl.pm8001_tbl.gpio_input_val = pm8001_mr32(address, 56U); pm8001_ha->gs_tbl.pm8001_tbl.rsvd1[0] = pm8001_mr32(address, 60U); pm8001_ha->gs_tbl.pm8001_tbl.rsvd1[1] = pm8001_mr32(address, 64U); pm8001_ha->gs_tbl.pm8001_tbl.recover_err_info[0] = pm8001_mr32(address, 68U); pm8001_ha->gs_tbl.pm8001_tbl.recover_err_info[1] = pm8001_mr32(address, 72U); pm8001_ha->gs_tbl.pm8001_tbl.recover_err_info[2] = pm8001_mr32(address, 76U); pm8001_ha->gs_tbl.pm8001_tbl.recover_err_info[3] = pm8001_mr32(address, 80U); pm8001_ha->gs_tbl.pm8001_tbl.recover_err_info[4] = pm8001_mr32(address, 84U); pm8001_ha->gs_tbl.pm8001_tbl.recover_err_info[5] = pm8001_mr32(address, 88U); pm8001_ha->gs_tbl.pm8001_tbl.recover_err_info[6] = pm8001_mr32(address, 92U); pm8001_ha->gs_tbl.pm8001_tbl.recover_err_info[7] = pm8001_mr32(address, 96U); } return; } } static void read_inbnd_queue_table(struct pm8001_hba_info *pm8001_ha ) { int i ; void *address ; u32 offset ; u32 tmp ; { address = pm8001_ha->inbnd_q_tbl_addr; i = 0; goto ldv_46441; ldv_46440: { offset = (u32 )(i * 32); tmp = pm8001_mr32(address, offset + 20U); pm8001_ha->inbnd_q_tbl[i].pi_pci_bar = get_pci_bar_index(tmp); pm8001_ha->inbnd_q_tbl[i].pi_offset = pm8001_mr32(address, offset + 24U); i = i + 1; } ldv_46441: ; if (i <= 0) { goto ldv_46440; } else { } return; } } static void read_outbnd_queue_table(struct pm8001_hba_info *pm8001_ha ) { int i ; void *address ; u32 offset ; u32 tmp ; { address = pm8001_ha->outbnd_q_tbl_addr; i = 0; goto ldv_46450; ldv_46449: { offset = (u32 )(i * 36); tmp = pm8001_mr32(address, offset + 20U); pm8001_ha->outbnd_q_tbl[i].ci_pci_bar = get_pci_bar_index(tmp); pm8001_ha->outbnd_q_tbl[i].ci_offset = pm8001_mr32(address, offset + 24U); i = i + 1; } ldv_46450: ; if (i <= 0) { goto ldv_46449; } else { } return; } } static void init_default_table_values(struct pm8001_hba_info *pm8001_ha ) { int i ; u32 offsetib ; u32 offsetob ; void *addressib ; void *addressob ; u32 tmp ; u32 tmp___0 ; { addressib = pm8001_ha->inbnd_q_tbl_addr; addressob = pm8001_ha->outbnd_q_tbl_addr; pm8001_ha->main_cfg_tbl.pm8001_tbl.inbound_q_nppd_hppd = 0U; pm8001_ha->main_cfg_tbl.pm8001_tbl.outbound_hw_event_pid0_3 = 0U; pm8001_ha->main_cfg_tbl.pm8001_tbl.outbound_hw_event_pid4_7 = 0U; pm8001_ha->main_cfg_tbl.pm8001_tbl.outbound_ncq_event_pid0_3 = 0U; pm8001_ha->main_cfg_tbl.pm8001_tbl.outbound_ncq_event_pid4_7 = 0U; pm8001_ha->main_cfg_tbl.pm8001_tbl.outbound_tgt_ITNexus_event_pid0_3 = 0U; pm8001_ha->main_cfg_tbl.pm8001_tbl.outbound_tgt_ITNexus_event_pid4_7 = 0U; pm8001_ha->main_cfg_tbl.pm8001_tbl.outbound_tgt_ssp_event_pid0_3 = 0U; pm8001_ha->main_cfg_tbl.pm8001_tbl.outbound_tgt_ssp_event_pid4_7 = 0U; pm8001_ha->main_cfg_tbl.pm8001_tbl.outbound_tgt_smp_event_pid0_3 = 0U; pm8001_ha->main_cfg_tbl.pm8001_tbl.outbound_tgt_smp_event_pid4_7 = 0U; pm8001_ha->main_cfg_tbl.pm8001_tbl.upper_event_log_addr = pm8001_ha->memoryMap.region[0].phys_addr_hi; pm8001_ha->main_cfg_tbl.pm8001_tbl.lower_event_log_addr = pm8001_ha->memoryMap.region[0].phys_addr_lo; pm8001_ha->main_cfg_tbl.pm8001_tbl.event_log_size = 131072U; pm8001_ha->main_cfg_tbl.pm8001_tbl.event_log_option = 1U; pm8001_ha->main_cfg_tbl.pm8001_tbl.upper_iop_event_log_addr = pm8001_ha->memoryMap.region[1].phys_addr_hi; pm8001_ha->main_cfg_tbl.pm8001_tbl.lower_iop_event_log_addr = pm8001_ha->memoryMap.region[1].phys_addr_lo; pm8001_ha->main_cfg_tbl.pm8001_tbl.iop_event_log_size = 131072U; pm8001_ha->main_cfg_tbl.pm8001_tbl.iop_event_log_option = 1U; pm8001_ha->main_cfg_tbl.pm8001_tbl.fatal_err_interrupt = 1U; i = 0; goto ldv_46461; ldv_46460: { pm8001_ha->inbnd_q_tbl[i].element_pri_size_cnt = (pm8001_ha->iomb_size << 16) | 1024U; pm8001_ha->inbnd_q_tbl[i].upper_base_addr = pm8001_ha->memoryMap.region[i + 6].phys_addr_hi; pm8001_ha->inbnd_q_tbl[i].lower_base_addr = pm8001_ha->memoryMap.region[i + 6].phys_addr_lo; pm8001_ha->inbnd_q_tbl[i].base_virt = pm8001_ha->memoryMap.region[i + 6].virt_ptr; pm8001_ha->inbnd_q_tbl[i].total_length = pm8001_ha->memoryMap.region[i + 6].total_len; pm8001_ha->inbnd_q_tbl[i].ci_upper_base_addr = pm8001_ha->memoryMap.region[i + 7].phys_addr_hi; pm8001_ha->inbnd_q_tbl[i].ci_lower_base_addr = pm8001_ha->memoryMap.region[i + 7].phys_addr_lo; pm8001_ha->inbnd_q_tbl[i].ci_virt = pm8001_ha->memoryMap.region[i + 7].virt_ptr; offsetib = (u32 )(i * 32); tmp = pm8001_mr32(addressib, offsetib + 20U); pm8001_ha->inbnd_q_tbl[i].pi_pci_bar = get_pci_bar_index(tmp); pm8001_ha->inbnd_q_tbl[i].pi_offset = pm8001_mr32(addressib, offsetib + 24U); pm8001_ha->inbnd_q_tbl[i].producer_idx = 0U; pm8001_ha->inbnd_q_tbl[i].consumer_index = 0U; i = i + 1; } ldv_46461: ; if (i <= 0) { goto ldv_46460; } else { } i = 0; goto ldv_46464; ldv_46463: { pm8001_ha->outbnd_q_tbl[i].element_size_cnt = (pm8001_ha->iomb_size << 16) | 1073742848U; pm8001_ha->outbnd_q_tbl[i].upper_base_addr = pm8001_ha->memoryMap.region[i + 8].phys_addr_hi; pm8001_ha->outbnd_q_tbl[i].lower_base_addr = pm8001_ha->memoryMap.region[i + 8].phys_addr_lo; pm8001_ha->outbnd_q_tbl[i].base_virt = pm8001_ha->memoryMap.region[i + 8].virt_ptr; pm8001_ha->outbnd_q_tbl[i].total_length = pm8001_ha->memoryMap.region[i + 8].total_len; pm8001_ha->outbnd_q_tbl[i].pi_upper_base_addr = pm8001_ha->memoryMap.region[i + 12].phys_addr_hi; pm8001_ha->outbnd_q_tbl[i].pi_lower_base_addr = pm8001_ha->memoryMap.region[i + 12].phys_addr_lo; pm8001_ha->outbnd_q_tbl[i].interrup_vec_cnt_delay = (u32 )((i << 24) | 655360); pm8001_ha->outbnd_q_tbl[i].pi_virt = pm8001_ha->memoryMap.region[i + 12].virt_ptr; offsetob = (u32 )(i * 36); tmp___0 = pm8001_mr32(addressob, offsetob + 20U); pm8001_ha->outbnd_q_tbl[i].ci_pci_bar = get_pci_bar_index(tmp___0); pm8001_ha->outbnd_q_tbl[i].ci_offset = pm8001_mr32(addressob, offsetob + 24U); pm8001_ha->outbnd_q_tbl[i].consumer_idx = 0U; pm8001_ha->outbnd_q_tbl[i].producer_index = 0U; i = i + 1; } ldv_46464: ; if (i <= 0) { goto ldv_46463; } else { } return; } } static void update_main_config_table(struct pm8001_hba_info *pm8001_ha ) { void *address ; { { address = pm8001_ha->main_cfg_tbl_addr; pm8001_mw32(address, 36U, pm8001_ha->main_cfg_tbl.pm8001_tbl.inbound_q_nppd_hppd); pm8001_mw32(address, 40U, pm8001_ha->main_cfg_tbl.pm8001_tbl.outbound_hw_event_pid0_3); pm8001_mw32(address, 44U, pm8001_ha->main_cfg_tbl.pm8001_tbl.outbound_hw_event_pid4_7); pm8001_mw32(address, 48U, pm8001_ha->main_cfg_tbl.pm8001_tbl.outbound_ncq_event_pid0_3); pm8001_mw32(address, 52U, pm8001_ha->main_cfg_tbl.pm8001_tbl.outbound_ncq_event_pid4_7); pm8001_mw32(address, 56U, pm8001_ha->main_cfg_tbl.pm8001_tbl.outbound_tgt_ITNexus_event_pid0_3); pm8001_mw32(address, 60U, pm8001_ha->main_cfg_tbl.pm8001_tbl.outbound_tgt_ITNexus_event_pid4_7); pm8001_mw32(address, 64U, pm8001_ha->main_cfg_tbl.pm8001_tbl.outbound_tgt_ssp_event_pid0_3); pm8001_mw32(address, 68U, pm8001_ha->main_cfg_tbl.pm8001_tbl.outbound_tgt_ssp_event_pid4_7); pm8001_mw32(address, 72U, pm8001_ha->main_cfg_tbl.pm8001_tbl.outbound_tgt_smp_event_pid0_3); pm8001_mw32(address, 76U, pm8001_ha->main_cfg_tbl.pm8001_tbl.outbound_tgt_smp_event_pid4_7); pm8001_mw32(address, 80U, pm8001_ha->main_cfg_tbl.pm8001_tbl.upper_event_log_addr); pm8001_mw32(address, 84U, pm8001_ha->main_cfg_tbl.pm8001_tbl.lower_event_log_addr); pm8001_mw32(address, 88U, pm8001_ha->main_cfg_tbl.pm8001_tbl.event_log_size); pm8001_mw32(address, 92U, pm8001_ha->main_cfg_tbl.pm8001_tbl.event_log_option); pm8001_mw32(address, 96U, pm8001_ha->main_cfg_tbl.pm8001_tbl.upper_iop_event_log_addr); pm8001_mw32(address, 100U, pm8001_ha->main_cfg_tbl.pm8001_tbl.lower_iop_event_log_addr); pm8001_mw32(address, 104U, pm8001_ha->main_cfg_tbl.pm8001_tbl.iop_event_log_size); pm8001_mw32(address, 108U, pm8001_ha->main_cfg_tbl.pm8001_tbl.iop_event_log_option); pm8001_mw32(address, 112U, pm8001_ha->main_cfg_tbl.pm8001_tbl.fatal_err_interrupt); } return; } } static void update_inbnd_queue_table(struct pm8001_hba_info *pm8001_ha , int number ) { void *address ; u16 offset ; { { address = pm8001_ha->inbnd_q_tbl_addr; offset = (unsigned int )((u16 )number) * 32U; pm8001_mw32(address, (u32 )offset, pm8001_ha->inbnd_q_tbl[number].element_pri_size_cnt); pm8001_mw32(address, (u32 )((int )offset + 4), pm8001_ha->inbnd_q_tbl[number].upper_base_addr); pm8001_mw32(address, (u32 )((int )offset + 8), pm8001_ha->inbnd_q_tbl[number].lower_base_addr); pm8001_mw32(address, (u32 )((int )offset + 12), pm8001_ha->inbnd_q_tbl[number].ci_upper_base_addr); pm8001_mw32(address, (u32 )((int )offset + 16), pm8001_ha->inbnd_q_tbl[number].ci_lower_base_addr); } return; } } static void update_outbnd_queue_table(struct pm8001_hba_info *pm8001_ha , int number ) { void *address ; u16 offset ; { { address = pm8001_ha->outbnd_q_tbl_addr; offset = (unsigned int )((u16 )number) * 36U; pm8001_mw32(address, (u32 )offset, pm8001_ha->outbnd_q_tbl[number].element_size_cnt); pm8001_mw32(address, (u32 )((int )offset + 4), pm8001_ha->outbnd_q_tbl[number].upper_base_addr); pm8001_mw32(address, (u32 )((int )offset + 8), pm8001_ha->outbnd_q_tbl[number].lower_base_addr); pm8001_mw32(address, (u32 )((int )offset + 12), pm8001_ha->outbnd_q_tbl[number].pi_upper_base_addr); pm8001_mw32(address, (u32 )((int )offset + 16), pm8001_ha->outbnd_q_tbl[number].pi_lower_base_addr); pm8001_mw32(address, (u32 )((int )offset + 28), pm8001_ha->outbnd_q_tbl[number].interrup_vec_cnt_delay); } return; } } int pm8001_bar4_shift(struct pm8001_hba_info *pm8001_ha , u32 shiftValue ) { u32 regVal ; unsigned long start ; long tmp ; { { pm8001_cw32(pm8001_ha, 1U, 12888U, shiftValue); start = (unsigned long )jiffies + 250UL; } ldv_46494: { regVal = pm8001_cr32(pm8001_ha, 1U, 12888U); } if (regVal != shiftValue && (long )((unsigned long )jiffies - start) < 0L) { goto ldv_46494; } else { } if (regVal != shiftValue) { { tmp = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:TIMEOUT:SPC_IBW_AXI_TRANSLATION_LOW = 0x%x\n", "pm8001_bar4_shift", 399, regVal); } } else { } return (-1); } else { } return (0); } } static void mpi_set_phys_g3_with_ssc(struct pm8001_hba_info *pm8001_ha , u32 SSCbit ) { u32 value ; u32 offset ; u32 i ; unsigned long flags ; int tmp ; int tmp___0 ; { { ldv___ldv_linux_kernel_locking_spinlock_spin_lock_100___0(& pm8001_ha->lock); tmp = pm8001_bar4_shift(pm8001_ha, 196608U); } if (tmp == -1) { { ldv_spin_unlock_irqrestore_109(& pm8001_ha->lock, flags); } return; } else { } i = 0U; goto ldv_46506; ldv_46505: { offset = i * 16384U + 4212U; pm8001_cw32(pm8001_ha, 2U, offset, 2147489025U); i = i + 1U; } ldv_46506: ; if (i <= 3U) { goto ldv_46505; } else { } { tmp___0 = pm8001_bar4_shift(pm8001_ha, 262144U); } if (tmp___0 == -1) { { ldv_spin_unlock_irqrestore_109(& pm8001_ha->lock, flags); } return; } else { } i = 4U; goto ldv_46509; ldv_46508: { offset = (i + 262140U) * 16384U + 4212U; pm8001_cw32(pm8001_ha, 2U, offset, 2147489025U); i = i + 1U; } ldv_46509: ; if (i <= 7U) { goto ldv_46508; } else { } { value = pm8001_cr32(pm8001_ha, 2U, 216U); pm8001_cw32(pm8001_ha, 2U, 216U, 2147532822U); pm8001_bar4_shift(pm8001_ha, 0U); ldv_spin_unlock_irqrestore_109(& pm8001_ha->lock, flags); } return; } } static void mpi_set_open_retry_interval_reg(struct pm8001_hba_info *pm8001_ha , u32 interval ) { u32 offset ; u32 value ; u32 i ; unsigned long flags ; int tmp ; int tmp___0 ; { { value = interval & 65535U; ldv___ldv_linux_kernel_locking_spinlock_spin_lock_104(& pm8001_ha->lock); tmp = pm8001_bar4_shift(pm8001_ha, 196608U); } if (tmp == -1) { { ldv_spin_unlock_irqrestore_109(& pm8001_ha->lock, flags); } return; } else { } i = 0U; goto ldv_46520; ldv_46519: { offset = i * 16384U + 12468U; pm8001_cw32(pm8001_ha, 2U, offset, value); i = i + 1U; } ldv_46520: ; if (i <= 3U) { goto ldv_46519; } else { } { tmp___0 = pm8001_bar4_shift(pm8001_ha, 262144U); } if (tmp___0 == -1) { { ldv_spin_unlock_irqrestore_109(& pm8001_ha->lock, flags); } return; } else { } i = 4U; goto ldv_46523; ldv_46522: { offset = (i + 262140U) * 16384U + 12468U; pm8001_cw32(pm8001_ha, 2U, offset, value); i = i + 1U; } ldv_46523: ; if (i <= 7U) { goto ldv_46522; } else { } { pm8001_bar4_shift(pm8001_ha, 0U); ldv_spin_unlock_irqrestore_109(& pm8001_ha->lock, flags); } return; } } static int mpi_init_check(struct pm8001_hba_info *pm8001_ha ) { u32 max_wait_count ; u32 value ; u32 gst_len_mpistate ; { { pm8001_cw32(pm8001_ha, 0U, 4U, 1U); max_wait_count = 1000000U; } ldv_46531: { __const_udelay(4295UL); value = pm8001_cr32(pm8001_ha, 0U, 4U); value = value & 1U; } if (value != 0U) { max_wait_count = max_wait_count - 1U; if (max_wait_count != 0U) { goto ldv_46531; } else { goto ldv_46532; } } else { } ldv_46532: ; if (max_wait_count == 0U) { return (-1); } else { } { gst_len_mpistate = pm8001_mr32(pm8001_ha->general_stat_tbl_addr, 0U); } if ((gst_len_mpistate & 7U) != 1U) { return (-1); } else { } gst_len_mpistate = gst_len_mpistate >> 16; if (gst_len_mpistate != 0U) { return (-1); } else { } return (0); } } static int check_fw_ready(struct pm8001_hba_info *pm8001_ha ) { u32 value ; u32 value1 ; u32 max_wait_count ; u32 tmp ; u32 tmp___0 ; { { value = pm8001_cr32(pm8001_ha, 0U, 72U); value1 = pm8001_cr32(pm8001_ha, 0U, 76U); } if ((value & 3U) == 2U) { { value = pm8001_cr32(pm8001_ha, 0U, 68U); } return (-1); } else { } if ((value1 & 3U) == 2U) { { value1 = pm8001_cr32(pm8001_ha, 0U, 80U); } return (-1); } else { } if ((value & 4294967280U) != 0U) { { pm8001_cr32(pm8001_ha, 0U, 68U); } return (-1); } else { } if ((value1 & 4294967284U) != 0U) { return (-1); } else { } max_wait_count = 1000000U; ldv_46539: { __const_udelay(4295UL); tmp = pm8001_cr32(pm8001_ha, 0U, 72U); value = tmp & 3U; tmp___0 = pm8001_cr32(pm8001_ha, 0U, 76U); value1 = tmp___0 & 3U; max_wait_count = max_wait_count - 1U; } if (max_wait_count == 0U) { return (-1); } else { } if (value != 3U || value1 != 3U) { goto ldv_46539; } else { } return (0); } } static void init_pci_device_addresses(struct pm8001_hba_info *pm8001_ha ) { void *base_addr ; u32 value ; u32 offset ; u32 pcibar ; u32 pcilogic ; long tmp ; long tmp___0 ; u32 tmp___1 ; u32 tmp___2 ; u32 tmp___3 ; { { value = pm8001_cr32(pm8001_ha, 0U, 68U); offset = value & 67108863U; tmp = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:Scratchpad 0 Offset: %x\n", "init_pci_device_addresses", 621, offset); } } else { } { pcilogic = value >> 26; pcibar = get_pci_bar_index(pcilogic); tmp___0 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___0 != 0L) { { printk("\016pm80xx %s %d:Scratchpad 0 PCI BAR: %d\n", "init_pci_device_addresses", 625, pcibar); } } else { } { base_addr = pm8001_ha->io_mem[pcibar].memvirtaddr + (unsigned long )offset; pm8001_ha->main_cfg_tbl_addr = base_addr; tmp___1 = pm8001_cr32(pm8001_ha, pcibar, offset + 24U); pm8001_ha->general_stat_tbl_addr = base_addr + (unsigned long )tmp___1; tmp___2 = pm8001_cr32(pm8001_ha, pcibar, offset + 28U); pm8001_ha->inbnd_q_tbl_addr = base_addr + (unsigned long )tmp___2; tmp___3 = pm8001_cr32(pm8001_ha, pcibar, offset + 32U); pm8001_ha->outbnd_q_tbl_addr = base_addr + (unsigned long )tmp___3; } return; } } static int pm8001_chip_init(struct pm8001_hba_info *pm8001_ha ) { u8 i ; u16 deviceid ; long tmp ; int tmp___0 ; long tmp___1 ; int tmp___2 ; long tmp___3 ; int tmp___4 ; { { i = 0U; pci_read_config_word((struct pci_dev const *)pm8001_ha->pdev, 2, & deviceid); } if ((unsigned int )deviceid == 32897U || (unsigned int )deviceid == 66U) { { tmp___0 = pm8001_bar4_shift(pm8001_ha, 5177344U); } if (tmp___0 == -1) { { tmp = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:Shift Bar4 to 0x%x failed\n", "pm8001_chip_init", 651, 5177344); } } else { } return (-1); } else { } } else { } { tmp___2 = check_fw_ready(pm8001_ha); } if (tmp___2 == -1) { { tmp___1 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___1 != 0L) { { printk("\016pm80xx %s %d:Firmware is not ready!\n", "pm8001_chip_init", 658); } } else { } return (-16); } else { } { init_pci_device_addresses(pm8001_ha); init_default_table_values(pm8001_ha); read_main_config_table(pm8001_ha); read_general_status_table(pm8001_ha); read_inbnd_queue_table(pm8001_ha); read_outbnd_queue_table(pm8001_ha); update_main_config_table(pm8001_ha); i = 0U; } goto ldv_46557; ldv_46556: { update_inbnd_queue_table(pm8001_ha, (int )i); i = (u8 )((int )i + 1); } ldv_46557: ; if ((unsigned int )i == 0U) { goto ldv_46556; } else { } i = 0U; goto ldv_46560; ldv_46559: { update_outbnd_queue_table(pm8001_ha, (int )i); i = (u8 )((int )i + 1); } ldv_46560: ; if ((unsigned int )i == 0U) { goto ldv_46559; } else { } if ((unsigned int )deviceid != 32897U && (unsigned int )deviceid != 66U) { { mpi_set_phys_g3_with_ssc(pm8001_ha, 0U); mpi_set_open_retry_interval_reg(pm8001_ha, 119U); } } else { } { tmp___4 = mpi_init_check(pm8001_ha); } if (tmp___4 == 0) { { tmp___3 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___3 != 0L) { { printk("\016pm80xx %s %d:MPI initialize successful!\n", "pm8001_chip_init", 684); } } else { } } else { return (-16); } { pm8001_cw32(pm8001_ha, 1U, 13248U, 1U); pm8001_cw32(pm8001_ha, 1U, 13252U, 0U); } return (0); } } static int mpi_uninit_check(struct pm8001_hba_info *pm8001_ha ) { u32 max_wait_count ; u32 value ; u32 gst_len_mpistate ; u16 deviceid ; long tmp ; int tmp___0 ; long tmp___1 ; long tmp___2 ; { { pci_read_config_word((struct pci_dev const *)pm8001_ha->pdev, 2, & deviceid); } if ((unsigned int )deviceid == 32897U || (unsigned int )deviceid == 66U) { { tmp___0 = pm8001_bar4_shift(pm8001_ha, 5177344U); } if (tmp___0 == -1) { { tmp = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:Shift Bar4 to 0x%x failed\n", "mpi_uninit_check", 708, 5177344); } } else { } return (-1); } else { } } else { } { init_pci_device_addresses(pm8001_ha); pm8001_cw32(pm8001_ha, 0U, 4U, 2U); max_wait_count = 1000000U; } ldv_46570: { __const_udelay(4295UL); value = pm8001_cr32(pm8001_ha, 0U, 4U); value = value & 2U; } if (value != 0U) { max_wait_count = max_wait_count - 1U; if (max_wait_count != 0U) { goto ldv_46570; } else { goto ldv_46571; } } else { } ldv_46571: ; if (max_wait_count == 0U) { { tmp___1 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___1 != 0L) { { printk("\016pm80xx %s %d:TIMEOUT:IBDB value/=0x%x\n", "mpi_uninit_check", 727, value); } } else { } return (-1); } else { } max_wait_count = 1000000U; ldv_46573: { __const_udelay(4295UL); gst_len_mpistate = pm8001_mr32(pm8001_ha->general_stat_tbl_addr, 0U); } if ((gst_len_mpistate & 7U) == 0U) { goto ldv_46572; } else { } max_wait_count = max_wait_count - 1U; if (max_wait_count != 0U) { goto ldv_46573; } else { } ldv_46572: ; if (max_wait_count == 0U) { { tmp___2 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___2 != 0L) { { printk("\016pm80xx %s %d: TIME OUT MPI State = 0x%x\n", "mpi_uninit_check", 746, gst_len_mpistate & 7U); } } else { } return (-1); } else { } return (0); } } static u32 soft_reset_ready_check(struct pm8001_hba_info *pm8001_ha ) { u32 regVal ; u32 regVal1 ; u32 regVal2 ; long tmp ; int tmp___0 ; u32 tmp___1 ; long tmp___2 ; unsigned long flags ; long tmp___3 ; int tmp___4 ; unsigned long __ms ; unsigned long tmp___5 ; u32 tmp___6 ; long tmp___7 ; u32 tmp___8 ; long tmp___9 ; u32 tmp___10 ; long tmp___11 ; { { tmp___0 = mpi_uninit_check(pm8001_ha); } if (tmp___0 != 0) { { tmp = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:MPI state is not ready\n", "soft_reset_ready_check", 761); } } else { } return (4294967295U); } else { } { tmp___1 = pm8001_cr32(pm8001_ha, 0U, 76U); regVal = tmp___1 & 4U; } if (regVal == 4U) { { tmp___2 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___2 != 0L) { { printk("\016pm80xx %s %d:Firmware is ready for reset .\n", "soft_reset_ready_check", 769); } } else { } } else { { ldv___ldv_linux_kernel_locking_spinlock_spin_lock_108___0(& pm8001_ha->lock); tmp___4 = pm8001_bar4_shift(pm8001_ha, 6946816U); } if (tmp___4 == -1) { { ldv_spin_unlock_irqrestore_109(& pm8001_ha->lock, flags); tmp___3 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___3 != 0L) { { printk("\016pm80xx %s %d:Shift Bar4 to 0x%x failed\n", "soft_reset_ready_check", 778, 6946816); } } else { } return (4294967295U); } else { } { pm8001_cw32(pm8001_ha, 2U, 32960U, 4660U); pm8001_cw32(pm8001_ha, 2U, 32960U, 4660U); __ms = 100UL; } goto ldv_46584; ldv_46583: { __const_udelay(4295000UL); } ldv_46584: tmp___5 = __ms; __ms = __ms - 1UL; if (tmp___5 != 0UL) { goto ldv_46583; } else { } { tmp___6 = pm8001_cr32(pm8001_ha, 0U, 76U); regVal = tmp___6 & 4U; } if (regVal != 4U) { { regVal1 = pm8001_cr32(pm8001_ha, 0U, 72U); regVal2 = pm8001_cr32(pm8001_ha, 0U, 76U); tmp___7 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___7 != 0L) { { printk("\016pm80xx %s %d:TIMEOUT:MSGU_SCRATCH_PAD1=0x%x, MSGU_SCRATCH_PAD2=0x%x\n", "soft_reset_ready_check", 794, regVal1, regVal2); } } else { } { tmp___9 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___9 != 0L) { { tmp___8 = pm8001_cr32(pm8001_ha, 0U, 68U); printk("\016pm80xx %s %d:SCRATCH_PAD0 value = 0x%x\n", "soft_reset_ready_check", 797, tmp___8); } } else { } { tmp___11 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___11 != 0L) { { tmp___10 = pm8001_cr32(pm8001_ha, 0U, 80U); printk("\016pm80xx %s %d:SCRATCH_PAD3 value = 0x%x\n", "soft_reset_ready_check", 800, tmp___10); } } else { } { ldv_spin_unlock_irqrestore_109(& pm8001_ha->lock, flags); } return (4294967295U); } else { } { ldv_spin_unlock_irqrestore_109(& pm8001_ha->lock, flags); } } return (0U); } } static int pm8001_chip_soft_rst(struct pm8001_hba_info *pm8001_ha ) { u32 regVal ; u32 toggleVal ; u32 max_wait_count ; u32 regVal1 ; u32 regVal2 ; u32 regVal3 ; u32 signature ; unsigned long flags ; long tmp ; u32 tmp___0 ; long tmp___1 ; int tmp___2 ; long tmp___3 ; long tmp___4 ; int tmp___5 ; long tmp___6 ; long tmp___7 ; long tmp___8 ; long tmp___9 ; long tmp___10 ; u32 tmp___11 ; long tmp___12 ; int tmp___13 ; u32 tmp___14 ; long tmp___15 ; u32 tmp___16 ; long tmp___17 ; long tmp___18 ; u32 tmp___19 ; long tmp___20 ; long tmp___21 ; u32 tmp___22 ; long tmp___23 ; long tmp___24 ; u32 tmp___25 ; long tmp___26 ; long tmp___27 ; int tmp___28 ; long tmp___29 ; long tmp___30 ; int tmp___31 ; long tmp___32 ; long tmp___33 ; long tmp___34 ; long tmp___35 ; int tmp___36 ; u32 tmp___37 ; long tmp___38 ; u32 tmp___39 ; long tmp___40 ; long tmp___41 ; u32 tmp___42 ; long tmp___43 ; u32 tmp___44 ; long tmp___45 ; u32 tmp___46 ; long tmp___47 ; long tmp___48 ; int tmp___49 ; u32 tmp___50 ; long tmp___51 ; u32 tmp___52 ; long tmp___53 ; u32 tmp___54 ; long tmp___55 ; u32 tmp___56 ; long tmp___57 ; long tmp___58 ; long tmp___59 ; u32 tmp___60 ; long tmp___61 ; u32 tmp___62 ; long tmp___63 ; int tmp___64 ; long tmp___65 ; { { signature = 623561677U; tmp___0 = soft_reset_ready_check(pm8001_ha); } if (tmp___0 != 0U) { { tmp = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:FW is not ready\n", "pm8001_chip_soft_rst", 825); } } else { } return (-1); } else { } { ldv___ldv_linux_kernel_locking_spinlock_spin_lock_112(& pm8001_ha->lock); tmp___2 = pm8001_bar4_shift(pm8001_ha, 393216U); } if (tmp___2 == -1) { { ldv_spin_unlock_irqrestore_109(& pm8001_ha->lock, flags); tmp___1 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___1 != 0L) { { printk("\016pm80xx %s %d:Shift Bar4 to 0x%x failed\n", "pm8001_chip_soft_rst", 837, 393216); } } else { } return (-1); } else { } { regVal = pm8001_cr32(pm8001_ha, 2U, 1048U); tmp___3 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___3 != 0L) { { printk("\016pm80xx %s %d:MBIC - NMI Enable VPE0 (IOP)= 0x%x\n", "pm8001_chip_soft_rst", 842, regVal); } } else { } { pm8001_cw32(pm8001_ha, 2U, 1048U, 0U); tmp___5 = pm8001_bar4_shift(pm8001_ha, 458752U); } if (tmp___5 == -1) { { ldv_spin_unlock_irqrestore_109(& pm8001_ha->lock, flags); tmp___4 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___4 != 0L) { { printk("\016pm80xx %s %d:Shift Bar4 to 0x%x failed\n", "pm8001_chip_soft_rst", 849, 458752); } } else { } return (-1); } else { } { regVal = pm8001_cr32(pm8001_ha, 2U, 1048U); tmp___6 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___6 != 0L) { { printk("\016pm80xx %s %d:MBIC - NMI Enable VPE0 (AAP1)= 0x%x\n", "pm8001_chip_soft_rst", 854, regVal); } } else { } { pm8001_cw32(pm8001_ha, 2U, 1048U, 0U); regVal = pm8001_cr32(pm8001_ha, 1U, 12352U); tmp___7 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___7 != 0L) { { printk("\016pm80xx %s %d:PCIE -Event Interrupt Enable = 0x%x\n", "pm8001_chip_soft_rst", 859, regVal); } } else { } { pm8001_cw32(pm8001_ha, 1U, 12352U, 0U); regVal = pm8001_cr32(pm8001_ha, 1U, 12356U); tmp___8 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___8 != 0L) { { printk("\016pm80xx %s %d:PCIE - Event Interrupt = 0x%x\n", "pm8001_chip_soft_rst", 864, regVal); } } else { } { pm8001_cw32(pm8001_ha, 1U, 12356U, regVal); regVal = pm8001_cr32(pm8001_ha, 1U, 12360U); tmp___9 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___9 != 0L) { { printk("\016pm80xx %s %d:PCIE -Error Interrupt Enable = 0x%x\n", "pm8001_chip_soft_rst", 869, regVal); } } else { } { pm8001_cw32(pm8001_ha, 1U, 12360U, 0U); regVal = pm8001_cr32(pm8001_ha, 1U, 12364U); tmp___10 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___10 != 0L) { { printk("\016pm80xx %s %d:PCIE - Error Interrupt = 0x%x\n", "pm8001_chip_soft_rst", 874, regVal); } } else { } { pm8001_cw32(pm8001_ha, 1U, 12364U, regVal); tmp___11 = pm8001_cr32(pm8001_ha, 0U, 72U); regVal = tmp___11 & 4U; toggleVal = regVal ^ 4U; pm8001_cw32(pm8001_ha, 0U, 84U, signature); tmp___13 = pm8001_bar4_shift(pm8001_ha, 7340032U); } if (tmp___13 == -1) { { ldv_spin_unlock_irqrestore_109(& pm8001_ha->lock, flags); tmp___12 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___12 != 0L) { { printk("\016pm80xx %s %d:Shift Bar4 to 0x%x failed\n", "pm8001_chip_soft_rst", 892, 7340032); } } else { } return (-1); } else { } { tmp___15 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___15 != 0L) { { tmp___14 = pm8001_cr32(pm8001_ha, 2U, 0U); printk("\016pm80xx %s %d:GSM 0x0(0x00007b88)-GSM Configuration and Reset = 0x%x\n", "pm8001_chip_soft_rst", 898, tmp___14); } } else { } { regVal = pm8001_cr32(pm8001_ha, 2U, 0U); regVal = regVal & 4294952191U; pm8001_cw32(pm8001_ha, 2U, 0U, regVal); tmp___17 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___17 != 0L) { { tmp___16 = pm8001_cr32(pm8001_ha, 2U, 0U); printk("\016pm80xx %s %d:GSM 0x0 (0x00007b88 ==> 0x00004088) - GSM Configuration and Reset is set to = 0x%x\n", "pm8001_chip_soft_rst", 916, tmp___16); } } else { } { regVal1 = pm8001_cr32(pm8001_ha, 2U, 56U); tmp___18 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___18 != 0L) { { printk("\016pm80xx %s %d:GSM 0x700038 - Read Address Parity Check Enable = 0x%x\n", "pm8001_chip_soft_rst", 923, regVal1); } } else { } { pm8001_cw32(pm8001_ha, 2U, 56U, 0U); tmp___20 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___20 != 0L) { { tmp___19 = pm8001_cr32(pm8001_ha, 2U, 56U); printk("\016pm80xx %s %d:GSM 0x700038 - Read Address Parity Check Enableis set to = 0x%x\n", "pm8001_chip_soft_rst", 928, tmp___19); } } else { } { regVal2 = pm8001_cr32(pm8001_ha, 2U, 64U); tmp___21 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___21 != 0L) { { printk("\016pm80xx %s %d:GSM 0x700040 - Write Address Parity Check Enable = 0x%x\n", "pm8001_chip_soft_rst", 934, regVal2); } } else { } { pm8001_cw32(pm8001_ha, 2U, 64U, 0U); tmp___23 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___23 != 0L) { { tmp___22 = pm8001_cr32(pm8001_ha, 2U, 64U); printk("\016pm80xx %s %d:GSM 0x700040 - Write Address Parity Check Enable is set to = 0x%x\n", "pm8001_chip_soft_rst", 939, tmp___22); } } else { } { regVal3 = pm8001_cr32(pm8001_ha, 2U, 72U); tmp___24 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___24 != 0L) { { printk("\016pm80xx %s %d:GSM 0x300048 - Write Data Parity Check Enable = 0x%x\n", "pm8001_chip_soft_rst", 945, regVal3); } } else { } { pm8001_cw32(pm8001_ha, 2U, 72U, 0U); tmp___26 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___26 != 0L) { { tmp___25 = pm8001_cr32(pm8001_ha, 2U, 72U); printk("\016pm80xx %s %d:GSM 0x300048 - Write Data Parity Check Enableis set to = 0x%x\n", "pm8001_chip_soft_rst", 950, tmp___25); } } else { } { __const_udelay(42950UL); tmp___28 = pm8001_bar4_shift(pm8001_ha, 589824U); } if (tmp___28 == -1) { { ldv_spin_unlock_irqrestore_109(& pm8001_ha->lock, flags); tmp___27 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___27 != 0L) { { printk("\016pm80xx %s %d:Shift Bar4 to 0x%x failed\n", "pm8001_chip_soft_rst", 959, 589824); } } else { } return (-1); } else { } { regVal = pm8001_cr32(pm8001_ha, 2U, 268U); tmp___29 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___29 != 0L) { { printk("\016pm80xx %s %d:GPIO Output Control Register: = 0x%x\n", "pm8001_chip_soft_rst", 965, regVal); } } else { } { regVal = regVal & 4294967292U; pm8001_cw32(pm8001_ha, 2U, 268U, regVal); tmp___31 = pm8001_bar4_shift(pm8001_ha, 0U); } if (tmp___31 == -1) { { ldv_spin_unlock_irqrestore_109(& pm8001_ha->lock, flags); tmp___30 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___30 != 0L) { { printk("\016pm80xx %s %d:SPC Shift Bar4 to 0x%x failed\n", "pm8001_chip_soft_rst", 976, 0); } } else { } return (-1); } else { } { regVal = pm8001_cr32(pm8001_ha, 2U, 0U); tmp___32 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___32 != 0L) { { printk("\016pm80xx %s %d:Top Register before resetting IOP/AAP1:= 0x%x\n", "pm8001_chip_soft_rst", 982, regVal); } } else { } { regVal = regVal & 4294967271U; pm8001_cw32(pm8001_ha, 2U, 0U, regVal); regVal = pm8001_cr32(pm8001_ha, 2U, 0U); tmp___33 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___33 != 0L) { { printk("\016pm80xx %s %d:Top Register before resetting BDMA/OSSP: = 0x%x\n", "pm8001_chip_soft_rst", 990, regVal); } } else { } { regVal = regVal & 4294836222U; pm8001_cw32(pm8001_ha, 2U, 0U, regVal); __const_udelay(42950UL); regVal = pm8001_cr32(pm8001_ha, 2U, 0U); tmp___34 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___34 != 0L) { { printk("\016pm80xx %s %d:Top Register before bringing up BDMA/OSSP:= 0x%x\n", "pm8001_chip_soft_rst", 1001, regVal); } } else { } { regVal = regVal | 131073U; pm8001_cw32(pm8001_ha, 2U, 0U, regVal); __const_udelay(42950UL); tmp___36 = pm8001_bar4_shift(pm8001_ha, 7340032U); } if (tmp___36 == -1) { { ldv_spin_unlock_irqrestore_109(& pm8001_ha->lock, flags); tmp___35 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___35 != 0L) { { printk("\016pm80xx %s %d:SPC Shift Bar4 to 0x%x failed\n", "pm8001_chip_soft_rst", 1014, 7340032); } } else { } return (-1); } else { } { tmp___38 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___38 != 0L) { { tmp___37 = pm8001_cr32(pm8001_ha, 2U, 0U); printk("\016pm80xx %s %d:GSM 0x0 (0x00007b88)-GSM Configuration and Reset = 0x%x\n", "pm8001_chip_soft_rst", 1019, tmp___37); } } else { } { regVal = pm8001_cr32(pm8001_ha, 2U, 0U); regVal = regVal | 15104U; pm8001_cw32(pm8001_ha, 2U, 0U, regVal); tmp___40 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___40 != 0L) { { tmp___39 = pm8001_cr32(pm8001_ha, 2U, 0U); printk("\016pm80xx %s %d:GSM (0x00004088 ==> 0x00007b88) - GSM Configuration and Reset is set to = 0x%x\n", "pm8001_chip_soft_rst", 1034, tmp___39); } } else { } { regVal = pm8001_cr32(pm8001_ha, 2U, 56U); tmp___41 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___41 != 0L) { { printk("\016pm80xx %s %d:GSM 0x700038 - Read Address Parity Check Enable = 0x%x\n", "pm8001_chip_soft_rst", 1041, regVal); } } else { } { pm8001_cw32(pm8001_ha, 2U, 56U, regVal1); tmp___43 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___43 != 0L) { { tmp___42 = pm8001_cr32(pm8001_ha, 2U, 56U); printk("\016pm80xx %s %d:GSM 0x700038 - Read Address Parity Check Enable is set to = 0x%x\n", "pm8001_chip_soft_rst", 1046, tmp___42); } } else { } { regVal = pm8001_cr32(pm8001_ha, 2U, 64U); pm8001_cw32(pm8001_ha, 2U, 64U, regVal2); tmp___45 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___45 != 0L) { { tmp___44 = pm8001_cr32(pm8001_ha, 2U, 64U); printk("\016pm80xx %s %d:GSM 0x700040 - Write Address Parity Check Enable is set to = 0x%x\n", "pm8001_chip_soft_rst", 1053, tmp___44); } } else { } { regVal = pm8001_cr32(pm8001_ha, 2U, 72U); pm8001_cw32(pm8001_ha, 2U, 72U, regVal3); tmp___47 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___47 != 0L) { { tmp___46 = pm8001_cr32(pm8001_ha, 2U, 72U); printk("\016pm80xx %s %d:GSM 0x700048 - Write Data Parity Check Enableis set to = 0x%x\n", "pm8001_chip_soft_rst", 1060, tmp___46); } } else { } { tmp___49 = pm8001_bar4_shift(pm8001_ha, 0U); } if (tmp___49 == -1) { { ldv_spin_unlock_irqrestore_109(& pm8001_ha->lock, flags); tmp___48 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___48 != 0L) { { printk("\016pm80xx %s %d:Shift Bar4 to 0x%x failed\n", "pm8001_chip_soft_rst", 1068, 0); } } else { } return (-1); } else { } { regVal = pm8001_cr32(pm8001_ha, 2U, 0U); regVal = regVal | 24U; pm8001_cw32(pm8001_ha, 2U, 0U, regVal); __const_udelay(42950UL); } if (signature == 623561677U) { max_wait_count = 2000000U; ldv_46598: { __const_udelay(4295UL); tmp___50 = pm8001_cr32(pm8001_ha, 0U, 72U); regVal = tmp___50 & 4U; } if (regVal != toggleVal) { max_wait_count = max_wait_count - 1U; if (max_wait_count != 0U) { goto ldv_46598; } else { goto ldv_46599; } } else { } ldv_46599: ; if (max_wait_count == 0U) { { regVal = pm8001_cr32(pm8001_ha, 0U, 72U); tmp___51 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___51 != 0L) { { printk("\016pm80xx %s %d:TIMEOUT : ToggleVal 0x%x,MSGU_SCRATCH_PAD1 = 0x%x\n", "pm8001_chip_soft_rst", 1094, toggleVal, regVal); } } else { } { tmp___53 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___53 != 0L) { { tmp___52 = pm8001_cr32(pm8001_ha, 0U, 68U); printk("\016pm80xx %s %d:SCRATCH_PAD0 value = 0x%x\n", "pm8001_chip_soft_rst", 1098, tmp___52); } } else { } { tmp___55 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___55 != 0L) { { tmp___54 = pm8001_cr32(pm8001_ha, 0U, 76U); printk("\016pm80xx %s %d:SCRATCH_PAD2 value = 0x%x\n", "pm8001_chip_soft_rst", 1102, tmp___54); } } else { } { tmp___57 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___57 != 0L) { { tmp___56 = pm8001_cr32(pm8001_ha, 0U, 80U); printk("\016pm80xx %s %d:SCRATCH_PAD3 value = 0x%x\n", "pm8001_chip_soft_rst", 1106, tmp___56); } } else { } { ldv_spin_unlock_irqrestore_109(& pm8001_ha->lock, flags); } return (-1); } else { } { pm8001_cw32(pm8001_ha, 0U, 64U, 4294967295U); pm8001_cw32(pm8001_ha, 0U, 116U, 0U); tmp___64 = check_fw_ready(pm8001_ha); } if (tmp___64 == -1) { { regVal = pm8001_cr32(pm8001_ha, 0U, 72U); tmp___58 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___58 != 0L) { { printk("\016pm80xx %s %d:FW not ready SCRATCH_PAD1 = 0x%x\n", "pm8001_chip_soft_rst", 1123, regVal); } } else { } { regVal = pm8001_cr32(pm8001_ha, 0U, 76U); tmp___59 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___59 != 0L) { { printk("\016pm80xx %s %d:FW not ready SCRATCH_PAD2 = 0x%x\n", "pm8001_chip_soft_rst", 1128, regVal); } } else { } { tmp___61 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___61 != 0L) { { tmp___60 = pm8001_cr32(pm8001_ha, 0U, 68U); printk("\016pm80xx %s %d:SCRATCH_PAD0 value = 0x%x\n", "pm8001_chip_soft_rst", 1132, tmp___60); } } else { } { tmp___63 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___63 != 0L) { { tmp___62 = pm8001_cr32(pm8001_ha, 0U, 80U); printk("\016pm80xx %s %d:SCRATCH_PAD3 value = 0x%x\n", "pm8001_chip_soft_rst", 1136, tmp___62); } } else { } { ldv_spin_unlock_irqrestore_109(& pm8001_ha->lock, flags); } return (-1); } else { } } else { } { pm8001_bar4_shift(pm8001_ha, 0U); ldv_spin_unlock_irqrestore_109(& pm8001_ha->lock, flags); tmp___65 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___65 != 0L) { { printk("\016pm80xx %s %d:SPC soft reset Complete\n", "pm8001_chip_soft_rst", 1145); } } else { } return (0); } } static void pm8001_hw_chip_rst(struct pm8001_hba_info *pm8001_ha ) { u32 i ; u32 regVal ; long tmp ; unsigned long __ms ; unsigned long tmp___0 ; long tmp___1 ; { { tmp = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:chip reset start\n", "pm8001_hw_chip_rst", 1154); } } else { } { regVal = pm8001_cr32(pm8001_ha, 1U, 0U); regVal = regVal & 2147483647U; pm8001_cw32(pm8001_ha, 1U, 0U, regVal); __const_udelay(42950UL); regVal = pm8001_cr32(pm8001_ha, 1U, 0U); regVal = regVal | 2147483648U; pm8001_cw32(pm8001_ha, 1U, 0U, regVal); __const_udelay(42950UL); i = 20U; } ldv_46610: ; if (1) { { __const_udelay(4295000UL); } } else { __ms = 1UL; goto ldv_46608; ldv_46607: { __const_udelay(4295000UL); } ldv_46608: tmp___0 = __ms; __ms = __ms - 1UL; if (tmp___0 != 0UL) { goto ldv_46607; } else { } } i = i - 1U; if (i != 0U) { goto ldv_46610; } else { } { tmp___1 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___1 != 0L) { { printk("\016pm80xx %s %d:chip reset finished\n", "pm8001_hw_chip_rst", 1179); } } else { } return; } } void pm8001_chip_iounmap(struct pm8001_hba_info *pm8001_ha ) { s8 bar ; s8 logical ; { logical = 0; bar = 0; goto ldv_46619; ldv_46618: ; if ((int )bar == 1 || (int )bar == 3) { goto ldv_46617; } else { } if ((unsigned long )pm8001_ha->io_mem[(int )logical].memvirtaddr != (unsigned long )((void *)0)) { { ldv_iounmap_123((void volatile *)pm8001_ha->io_mem[(int )logical].memvirtaddr); logical = (s8 )((int )logical + 1); } } else { } ldv_46617: bar = (s8 )((int )bar + 1); ldv_46619: ; if ((int )bar <= 5) { goto ldv_46618; } else { } return; } } static void pm8001_chip_intx_interrupt_enable(struct pm8001_hba_info *pm8001_ha ) { { { pm8001_cw32(pm8001_ha, 0U, 116U, 0U); pm8001_cw32(pm8001_ha, 0U, 64U, 4294967295U); } return; } } static void pm8001_chip_intx_interrupt_disable(struct pm8001_hba_info *pm8001_ha ) { { { pm8001_cw32(pm8001_ha, 0U, 116U, 4294967295U); } return; } } static void pm8001_chip_msix_interrupt_enable(struct pm8001_hba_info *pm8001_ha , u32 int_vec_idx ) { u32 msi_index ; u32 value ; { { msi_index = int_vec_idx * 16U; msi_index = msi_index + 8204U; pm8001_cw32(pm8001_ha, 0U, msi_index, 0U); value = (u32 )(1 << (int )int_vec_idx); pm8001_cw32(pm8001_ha, 0U, 64U, value); } return; } } static void pm8001_chip_msix_interrupt_disable(struct pm8001_hba_info *pm8001_ha , u32 int_vec_idx ) { u32 msi_index ; { { msi_index = int_vec_idx * 16U; msi_index = msi_index + 8204U; pm8001_cw32(pm8001_ha, 0U, msi_index, 1U); } return; } } static void pm8001_chip_interrupt_enable(struct pm8001_hba_info *pm8001_ha , u8 vec ) { { { pm8001_chip_msix_interrupt_enable(pm8001_ha, 0U); } return; { pm8001_chip_intx_interrupt_enable(pm8001_ha); } } } static void pm8001_chip_interrupt_disable(struct pm8001_hba_info *pm8001_ha , u8 vec ) { { { pm8001_chip_msix_interrupt_disable(pm8001_ha, 0U); } return; { pm8001_chip_intx_interrupt_disable(pm8001_ha); } } } int pm8001_mpi_msg_free_get(struct inbound_queue_table *circularQ , u16 messageSize , void **messagePtr ) { u32 offset ; u32 consumer_index ; struct mpi_msg_hdr *msgHeader ; u8 bcCount ; { bcCount = 1U; if ((unsigned int )messageSize > 128U) { *messagePtr = (void *)0; return (-1); } else { } { consumer_index = pm8001_read_32(circularQ->ci_virt); circularQ->consumer_index = consumer_index; } if (((circularQ->producer_idx + (u32 )bcCount) & 1023U) == circularQ->consumer_index) { *messagePtr = (void *)0; return (-1); } else { } offset = circularQ->producer_idx * (u32 )messageSize; circularQ->producer_idx = (circularQ->producer_idx + (u32 )bcCount) & 1023U; msgHeader = (struct mpi_msg_hdr *)circularQ->base_virt + (unsigned long )offset; *messagePtr = (void *)msgHeader + 4UL; return (0); } } int pm8001_mpi_build_cmd(struct pm8001_hba_info *pm8001_ha , struct inbound_queue_table *circularQ , u32 opCode , void *payload , u32 responseQueue ) { u32 Header ; u32 hpriority ; u32 bc ; u32 category ; void *pMessage ; long tmp ; int tmp___0 ; long tmp___1 ; long tmp___2 ; { { Header = 0U; hpriority = 0U; bc = 1U; category = 2U; tmp___0 = pm8001_mpi_msg_free_get(circularQ, (int )((u16 )pm8001_ha->iomb_size), & pMessage); } if (tmp___0 < 0) { { tmp = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:No free mpi buffer\n", "pm8001_mpi_build_cmd", 1348); } } else { } return (-12); } else { } { tmp___1 = ldv__builtin_expect((unsigned long )payload == (unsigned long )((void *)0), 0L); } if (tmp___1 != 0L) { { __asm__ volatile ("1:\tud2\n.pushsection __bug_table,\"a\"\n2:\t.long 1b - 2b, %c0 - 2b\n\t.word %c1, 0\n\t.org 2b+%c2\n.popsection": : "i" ((char *)"drivers/scsi/pm8001/pm8001_hwi.c"), "i" (1351), "i" (12UL)); __builtin_unreachable(); } } else { } { __memcpy(pMessage, (void const *)payload, (unsigned long )pm8001_ha->iomb_size - 4UL); Header = (((((hpriority << 30) | ((bc & 31U) << 24)) | ((responseQueue & 63U) << 16)) | ((category << 12) & 65535U)) | (opCode & 4095U)) | 2147483648U; pm8001_write_32(pMessage + 0xfffffffffffffffcUL, 0U, Header); pm8001_cw32(pm8001_ha, circularQ->pi_pci_bar, circularQ->pi_offset, circularQ->producer_idx); tmp___2 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___2 != 0L) { { printk("\016pm80xx %s %d:INB Q %x OPCODE:%x , UPDATED PI=%d CI=%d\n", "pm8001_mpi_build_cmd", 1368, responseQueue, opCode, circularQ->producer_idx, circularQ->consumer_index); } } else { } return (0); } } u32 pm8001_mpi_msg_free_set(struct pm8001_hba_info *pm8001_ha , void *pMsg , struct outbound_queue_table *circularQ , u8 bc ) { u32 producer_index ; struct mpi_msg_hdr *msgHeader ; struct mpi_msg_hdr *pOutBoundMsgHeader ; long tmp ; long tmp___0 ; long tmp___1 ; { msgHeader = (struct mpi_msg_hdr *)pMsg + 0xfffffffffffffffcUL; pOutBoundMsgHeader = (struct mpi_msg_hdr *)circularQ->base_virt + (unsigned long )(circularQ->consumer_idx * pm8001_ha->iomb_size); if ((unsigned long )pOutBoundMsgHeader != (unsigned long )msgHeader) { { tmp = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:consumer_idx = %d msgHeader = %p\n", "pm8001_mpi_msg_free_set", 1385, circularQ->consumer_idx, msgHeader); } } else { } { producer_index = pm8001_read_32(circularQ->pi_virt); circularQ->producer_index = producer_index; tmp___0 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___0 != 0L) { { printk("\016pm80xx %s %d:consumer_idx = %d producer_index = %dmsgHeader = %p\n", "pm8001_mpi_msg_free_set", 1393, circularQ->consumer_idx, circularQ->producer_index, msgHeader); } } else { } return (0U); } else { } { circularQ->consumer_idx = (circularQ->consumer_idx + (u32 )bc) & 1023U; pm8001_cw32(pm8001_ha, circularQ->ci_pci_bar, circularQ->ci_offset, circularQ->consumer_idx); producer_index = pm8001_read_32(circularQ->pi_virt); circularQ->producer_index = producer_index; tmp___1 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___1 != 0L) { { printk("\016pm80xx %s %d: CI=%d PI=%d\n", "pm8001_mpi_msg_free_set", 1407, circularQ->consumer_idx, circularQ->producer_index); } } else { } return (0U); } } u32 pm8001_mpi_msg_consume(struct pm8001_hba_info *pm8001_ha , struct outbound_queue_table *circularQ , void **messagePtr1 , u8 *pBC ) { struct mpi_msg_hdr *msgHeader ; __le32 msgHeader_tmp ; u32 header_tmp ; long tmp ; u32 producer_index ; void *pi_virt ; { ldv_46690: ; if (circularQ->producer_index != circularQ->consumer_idx) { { msgHeader = (struct mpi_msg_hdr *)circularQ->base_virt + (unsigned long )(circularQ->consumer_idx * pm8001_ha->iomb_size); header_tmp = pm8001_read_32((void *)msgHeader); msgHeader_tmp = header_tmp; } if ((int )msgHeader_tmp < 0) { if ((msgHeader_tmp & 4095U) != 33U) { { *messagePtr1 = (void *)msgHeader + 4U; *pBC = (unsigned int )((unsigned char )(msgHeader_tmp >> 24)) & 31U; tmp = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:: CI=%d PI=%d msgHeader=%x\n", "pm8001_mpi_msg_consume", 1450, circularQ->consumer_idx, circularQ->producer_index, msgHeader_tmp); } } else { } return (0U); } else { { circularQ->consumer_idx = (circularQ->consumer_idx + ((msgHeader_tmp >> 24) & 31U)) & 1023U; msgHeader_tmp = 0U; pm8001_write_32((void *)msgHeader, 0U, 0U); pm8001_cw32(pm8001_ha, circularQ->ci_pci_bar, circularQ->ci_offset, circularQ->consumer_idx); } } } else { { circularQ->consumer_idx = (circularQ->consumer_idx + ((msgHeader_tmp >> 24) & 31U)) & 1023U; msgHeader_tmp = 0U; pm8001_write_32((void *)msgHeader, 0U, 0U); pm8001_cw32(pm8001_ha, circularQ->ci_pci_bar, circularQ->ci_offset, circularQ->consumer_idx); } return (2U); } } else { { pi_virt = circularQ->pi_virt; producer_index = pm8001_read_32(pi_virt); circularQ->producer_index = producer_index; } } if (circularQ->producer_index != circularQ->consumer_idx) { goto ldv_46690; } else { } return (1U); } } void pm8001_work_fn(struct work_struct *work ) { struct pm8001_work *pw ; struct work_struct const *__mptr ; struct pm8001_device *pm8001_dev ; struct domain_device *dev ; struct sas_task *t ; u32 tag ; struct pm8001_ccb_info *ccb ; struct pm8001_hba_info *pm8001_ha ; unsigned long flags ; unsigned long flags1 ; struct task_status_struct *ts ; int i ; int tmp ; long tmp___0 ; long tmp___1 ; long tmp___2 ; struct sas_task *t___0 ; u32 tag___0 ; struct pm8001_ccb_info *ccb___0 ; struct pm8001_hba_info *pm8001_ha___0 ; unsigned long flags___0 ; unsigned long flags1___0 ; int i___0 ; int ret ; long tmp___3 ; long tmp___4 ; long tmp___5 ; long tmp___6 ; long tmp___7 ; long tmp___8 ; { __mptr = (struct work_struct const *)work; pw = (struct pm8001_work *)__mptr; pm8001_dev = (struct pm8001_device *)pw->data; if ((unsigned long )pm8001_dev == (unsigned long )((struct pm8001_device *)0) || (pw->handler != 14 && (unsigned int )pm8001_dev->dev_type == 0U)) { { kfree((void const *)pw); } return; } else { } { if (pw->handler == 14) { goto case_14; } else { } if (pw->handler == 36) { goto case_36; } else { } if (pw->handler == 19) { goto case_19; } else { } if (pw->handler == 22) { goto case_22; } else { } if (pw->handler == 62) { goto case_62; } else { } if (pw->handler == 57) { goto case_57; } else { } goto switch_break; case_14: /* CIL Label */ { t = (struct sas_task *)pm8001_dev; pm8001_ha = pw->pm8001_ha; tmp = pm8001_query_task(t); } if (tmp == 8) { goto ldv_46709; } else { } { ldv___ldv_linux_kernel_locking_spinlock_spin_lock_124(& pm8001_ha->lock); ldv___ldv_linux_kernel_locking_spinlock_spin_lock_125(& t->task_state_lock); tmp___0 = ldv__builtin_expect((t->task_state_flags & 2U) != 0U, 0L); } if (tmp___0 != 0L) { { ldv_spin_unlock_irqrestore_135(& t->task_state_lock, flags1); ldv_spin_unlock_irqrestore_109(& pm8001_ha->lock, flags); } goto ldv_46709; } else { } { ldv_spin_unlock_irqrestore_135(& t->task_state_lock, flags1); i = 0; } goto ldv_46712; ldv_46711: ccb = pm8001_ha->ccb_info + (unsigned long )i; tag = ccb->ccb_tag; if (tag != 4294967295U && (unsigned long )ccb->task == (unsigned long )t) { goto ldv_46710; } else { } i = i + 1; ldv_46712: ccb = (struct pm8001_ccb_info *)0; if (i <= 511) { goto ldv_46711; } else { } ldv_46710: ; if ((unsigned long )ccb == (unsigned long )((struct pm8001_ccb_info *)0)) { { ldv_spin_unlock_irqrestore_109(& pm8001_ha->lock, flags); } goto ldv_46709; } else { } ts = & t->task_status; ts->resp = 0; ts->stat = 132; pm8001_dev = ccb->device; if ((unsigned long )pm8001_dev != (unsigned long )((struct pm8001_device *)0)) { pm8001_dev->running_req = pm8001_dev->running_req - 1U; } else { } { ldv___ldv_linux_kernel_locking_spinlock_spin_lock_130(& t->task_state_lock); t->task_state_flags = t->task_state_flags & 4294967294U; t->task_state_flags = t->task_state_flags & 4294967279U; t->task_state_flags = t->task_state_flags | 2U; tmp___2 = ldv__builtin_expect((t->task_state_flags & 4U) != 0U, 0L); } if (tmp___2 != 0L) { { ldv_spin_unlock_irqrestore_135(& t->task_state_lock, flags1); tmp___1 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___1 != 0L) { { printk("\016pm80xx %s %d:task 0x%p done with event 0x%x resp 0x%x stat 0x%x but aborted by upper layer!\n", "pm8001_work_fn", 1563, t, pw->handler, (int )ts->resp, (unsigned int )ts->stat); } } else { } { pm8001_ccb_task_free(pm8001_ha, t, ccb, tag); ldv_spin_unlock_irqrestore_109(& pm8001_ha->lock, flags); } } else { { ldv_spin_unlock_irqrestore_135(& t->task_state_lock, flags1); pm8001_ccb_task_free(pm8001_ha, t, ccb, tag); __asm__ volatile ("mfence": : : "memory"); ldv_spin_unlock_irqrestore_109(& pm8001_ha->lock, flags); (*(t->task_done))(t); } } goto ldv_46709; case_36: /* CIL Label */ { t___0 = (struct sas_task *)pm8001_dev; pm8001_ha___0 = pw->pm8001_ha; ret = 0; tmp___3 = ldv__builtin_expect((pm8001_ha___0->logging_level & 8U) != 0U, 0L); } if (tmp___3 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_OPEN_RETRY_TIMEOUT\n", "pm8001_work_fn", 1584); } } else { } { ret = pm8001_query_task(t___0); tmp___4 = ldv__builtin_expect((pm8001_ha___0->logging_level & 8U) != 0U, 0L); } if (tmp___4 != 0L) { { if (ret == 8) { goto case_8; } else { } if (ret == 0) { goto case_0; } else { } goto switch_default; case_8: /* CIL Label */ { printk("\016pm80xx %s %d:...Task on lu\n", "pm8001_work_fn", 1601); } goto ldv_46724; case_0: /* CIL Label */ { printk("\016pm80xx %s %d:...Task NOT on lu\n", "pm8001_work_fn", 1601); } goto ldv_46724; switch_default: /* CIL Label */ { printk("\016pm80xx %s %d:...query task failed!!!\n", "pm8001_work_fn", 1601); } goto ldv_46724; switch_break___0: /* CIL Label */ ; } ldv_46724: ; } else { } { ldv___ldv_linux_kernel_locking_spinlock_spin_lock_135(& pm8001_ha___0->lock); ldv___ldv_linux_kernel_locking_spinlock_spin_lock_136(& t___0->task_state_lock); tmp___5 = ldv__builtin_expect((t___0->task_state_flags & 2U) != 0U, 0L); } if (tmp___5 != 0L) { { ldv_spin_unlock_irqrestore_135(& t___0->task_state_lock, flags1___0); ldv_spin_unlock_irqrestore_109(& pm8001_ha___0->lock, flags___0); } if (ret == 8) { { pm8001_abort_task(t___0); } } else { } goto ldv_46709; } else { } { ldv_spin_unlock_irqrestore_135(& t___0->task_state_lock, flags1___0); i___0 = 0; } goto ldv_46729; ldv_46728: ccb___0 = pm8001_ha___0->ccb_info + (unsigned long )i___0; tag___0 = ccb___0->ccb_tag; if (tag___0 != 4294967295U && (unsigned long )ccb___0->task == (unsigned long )t___0) { goto ldv_46727; } else { } i___0 = i___0 + 1; ldv_46729: ccb___0 = (struct pm8001_ccb_info *)0; if (i___0 <= 511) { goto ldv_46728; } else { } ldv_46727: ; if ((unsigned long )ccb___0 == (unsigned long )((struct pm8001_ccb_info *)0)) { { ldv_spin_unlock_irqrestore_109(& pm8001_ha___0->lock, flags___0); } if (ret == 8) { { pm8001_abort_task(t___0); } } else { } goto ldv_46709; } else { } pm8001_dev = ccb___0->device; dev = pm8001_dev->sas_device; { if (ret == 8) { goto case_8___0; } else { } if (ret == 0) { goto case_0___1; } else { } goto switch_default___1; case_8___0: /* CIL Label */ { ccb___0->open_retry = 1U; ldv_spin_unlock_irqrestore_109(& pm8001_ha___0->lock, flags___0); ret = pm8001_abort_task(t___0); ccb___0->open_retry = 0U; } { if (ret == 8) { goto case_8___1; } else { } if (ret == 0) { goto case_0___0; } else { } goto switch_default___0; case_8___1: /* CIL Label */ ; case_0___0: /* CIL Label */ ; goto ldv_46733; switch_default___0: /* CIL Label */ { ret = 5; tmp___6 = ldv__builtin_expect((pm8001_ha___0->logging_level & 8U) != 0U, 0L); } if (tmp___6 != 0L) { { printk("\016pm80xx %s %d:...Reset phy\n", "pm8001_work_fn", 1647); } } else { } { pm8001_I_T_nexus_reset(dev); } goto ldv_46733; switch_break___2: /* CIL Label */ ; } ldv_46733: ; goto ldv_46735; case_0___1: /* CIL Label */ { ldv_spin_unlock_irqrestore_109(& pm8001_ha___0->lock, flags___0); } goto ldv_46735; switch_default___1: /* CIL Label */ { ldv_spin_unlock_irqrestore_109(& pm8001_ha___0->lock, flags___0); ret = 5; tmp___7 = ldv__builtin_expect((pm8001_ha___0->logging_level & 8U) != 0U, 0L); } if (tmp___7 != 0L) { { printk("\016pm80xx %s %d:...Reset phy\n", "pm8001_work_fn", 1662); } } else { } { pm8001_I_T_nexus_reset(dev); } switch_break___1: /* CIL Label */ ; } ldv_46735: ; if (ret == 5) { t___0 = (struct sas_task *)0; } else { } { pm8001_open_reject_retry(pm8001_ha___0, t___0, pm8001_dev); tmp___8 = ldv__builtin_expect((pm8001_ha___0->logging_level & 8U) != 0U, 0L); } if (tmp___8 != 0L) { { printk("\016pm80xx %s %d:...Complete\n", "pm8001_work_fn", 1669); } } else { } goto ldv_46709; case_19: /* CIL Label */ { dev = pm8001_dev->sas_device; pm8001_I_T_nexus_event_handler(dev); } goto ldv_46709; case_22: /* CIL Label */ { dev = pm8001_dev->sas_device; pm8001_I_T_nexus_reset(dev); } goto ldv_46709; case_62: /* CIL Label */ { dev = pm8001_dev->sas_device; pm8001_I_T_nexus_reset(dev); } goto ldv_46709; case_57: /* CIL Label */ { dev = pm8001_dev->sas_device; pm8001_I_T_nexus_reset(dev); } goto ldv_46709; switch_break: /* CIL Label */ ; } ldv_46709: { kfree((void const *)pw); } return; } } int pm8001_handle_event(struct pm8001_hba_info *pm8001_ha , void *data , int handler ) { struct pm8001_work *pw ; int ret ; void *tmp ; struct lock_class_key __key ; atomic_long_t __constr_expr_0 ; { { ret = 0; tmp = kmalloc(104UL, 32U); pw = (struct pm8001_work *)tmp; } if ((unsigned long )pw != (unsigned long )((struct pm8001_work *)0)) { { pw->pm8001_ha = pm8001_ha; pw->data = data; pw->handler = handler; __init_work(& pw->work, 0); __constr_expr_0.counter = 137438953408L; pw->work.data = __constr_expr_0; lockdep_init_map(& pw->work.lockdep_map, "(&pw->work)", & __key, 0); INIT_LIST_HEAD(& pw->work.entry); pw->work.func = & pm8001_work_fn; queue_work(pm8001_wq, & pw->work); } } else { ret = -12; } return (ret); } } static void pm8001_send_abort_all(struct pm8001_hba_info *pm8001_ha , struct pm8001_device *pm8001_ha_dev ) { int res ; u32 ccb_tag ; struct pm8001_ccb_info *ccb ; struct sas_task *task ; struct task_abort_req task_abort ; struct inbound_queue_table *circularQ ; u32 opc ; int ret ; long tmp ; long tmp___0 ; { task = (struct sas_task *)0; opc = 24U; if ((unsigned long )pm8001_ha_dev == (unsigned long )((struct pm8001_device *)0)) { { tmp = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:dev is null\n", "pm8001_send_abort_all", 1723); } } else { } return; } else { } { task = sas_alloc_slow_task(32U); } if ((unsigned long )task == (unsigned long )((struct sas_task *)0)) { { tmp___0 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___0 != 0L) { { printk("\016pm80xx %s %d:cannot allocate task\n", "pm8001_send_abort_all", 1731); } } else { } return; } else { } { task->task_done = & pm8001_task_done; res = pm8001_tag_alloc(pm8001_ha, & ccb_tag); } if (res != 0) { return; } else { } { ccb = pm8001_ha->ccb_info + (unsigned long )ccb_tag; ccb->device = pm8001_ha_dev; ccb->ccb_tag = ccb_tag; ccb->task = task; circularQ = (struct inbound_queue_table *)(& pm8001_ha->inbnd_q_tbl); __memset((void *)(& task_abort), 0, 60UL); task_abort.abort_all = 1U; task_abort.device_id = pm8001_ha_dev->device_id; task_abort.tag = ccb_tag; ret = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, (void *)(& task_abort), 0U); } if (ret != 0) { { pm8001_tag_free(pm8001_ha, ccb_tag); } } else { } return; } } static void pm8001_send_read_log(struct pm8001_hba_info *pm8001_ha , struct pm8001_device *pm8001_ha_dev ) { struct sata_start_req sata_cmd ; int res ; u32 ccb_tag ; struct pm8001_ccb_info *ccb ; struct sas_task *task ; struct host_to_dev_fis fis ; struct domain_device *dev ; struct inbound_queue_table *circularQ ; u32 opc ; long tmp ; long tmp___0 ; void *tmp___1 ; long tmp___2 ; { { task = (struct sas_task *)0; opc = 23U; task = sas_alloc_slow_task(32U); } if ((unsigned long )task == (unsigned long )((struct sas_task *)0)) { { tmp = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:cannot allocate task !!!\n", "pm8001_send_read_log", 1776); } } else { } return; } else { } { task->task_done = & pm8001_task_done; res = pm8001_tag_alloc(pm8001_ha, & ccb_tag); } if (res != 0) { { sas_free_task(task); tmp___0 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___0 != 0L) { { printk("\016pm80xx %s %d:cannot allocate tag !!!\n", "pm8001_send_read_log", 1785); } } else { } return; } else { } { tmp___1 = kzalloc(656UL, 32U); dev = (struct domain_device *)tmp___1; } if ((unsigned long )dev == (unsigned long )((struct domain_device *)0)) { { sas_free_task(task); pm8001_tag_free(pm8001_ha, ccb_tag); tmp___2 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___2 != 0L) { { printk("\016pm80xx %s %d:Domain device cannot be allocated\n", "pm8001_send_read_log", 1797); } } else { } return; } else { } { task->dev = dev; (task->dev)->lldd_dev = (void *)pm8001_ha_dev; ccb = pm8001_ha->ccb_info + (unsigned long )ccb_tag; ccb->device = pm8001_ha_dev; ccb->ccb_tag = ccb_tag; ccb->task = task; pm8001_ha_dev->id = pm8001_ha_dev->id | 2147483648U; pm8001_ha_dev->id = pm8001_ha_dev->id | 536870912U; __memset((void *)(& sata_cmd), 0, 60UL); circularQ = (struct inbound_queue_table *)(& pm8001_ha->inbnd_q_tbl); __memset((void *)(& fis), 0, 20UL); fis.fis_type = 39U; fis.flags = 128U; fis.command = 47U; fis.lbal = 16U; fis.__annonCompField87.sector_count = 1U; sata_cmd.tag = ccb_tag; sata_cmd.device_id = pm8001_ha_dev->device_id; sata_cmd.ncqtag_atap_dir_m = sata_cmd.ncqtag_atap_dir_m | 2688U; __memcpy((void *)(& sata_cmd.sata_fis), (void const *)(& fis), 20UL); res = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, (void *)(& sata_cmd), 0U); } if (res != 0) { { sas_free_task(task); pm8001_tag_free(pm8001_ha, ccb_tag); kfree((void const *)dev); } } else { } return; } } static void mpi_ssp_completion(struct pm8001_hba_info *pm8001_ha , void *piomb ) { struct sas_task *t ; struct pm8001_ccb_info *ccb ; unsigned long flags ; u32 status ; u32 param ; u32 tag ; struct ssp_completion_resp *psspPayload ; struct task_status_struct *ts ; struct ssp_response_iu *iu ; struct pm8001_device *pm8001_dev ; long tmp ; long tmp___0 ; long tmp___1 ; int tmp___2 ; long tmp___3 ; __u64 tmp___4 ; long tmp___5 ; long tmp___6 ; long tmp___7 ; long tmp___8 ; long tmp___9 ; long tmp___10 ; long tmp___11 ; long tmp___12 ; long tmp___13 ; long tmp___14 ; long tmp___15 ; long tmp___16 ; long tmp___17 ; long tmp___18 ; long tmp___19 ; long tmp___20 ; long tmp___21 ; long tmp___22 ; long tmp___23 ; long tmp___24 ; long tmp___25 ; long tmp___26 ; long tmp___27 ; long tmp___28 ; long tmp___29 ; long tmp___30 ; long tmp___31 ; long tmp___32 ; long tmp___33 ; { psspPayload = (struct ssp_completion_resp *)piomb + 4U; status = psspPayload->status; tag = psspPayload->tag; ccb = pm8001_ha->ccb_info + (unsigned long )tag; if (status == 1U && (unsigned int )ccb->open_retry != 0U) { ccb->open_retry = 0U; return; } else { } pm8001_dev = ccb->device; param = psspPayload->param; t = ccb->task; if (status != 0U && status != 3U) { { tmp = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:sas IO status 0x%x\n", "mpi_ssp_completion", 1874, status); } } else { } } else { } { tmp___0 = ldv__builtin_expect((unsigned long )t == (unsigned long )((struct sas_task *)0), 0L); } if (tmp___0 != 0L) { tmp___2 = 1; } else { { tmp___1 = ldv__builtin_expect((unsigned long )t->lldd_task == (unsigned long )((void *)0), 0L); } if (tmp___1 != 0L) { tmp___2 = 1; } else { tmp___2 = 0; } } if (tmp___2 != 0) { return; } else { { tmp___3 = ldv__builtin_expect((unsigned long )t->dev == (unsigned long )((struct domain_device *)0), 0L); } if (tmp___3 != 0L) { return; } else { } } ts = & t->task_status; if ((status != 0U && status != 2U) && status != 3U) { { tmp___5 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___5 != 0L) { { tmp___4 = __fswab64(*((__be64 *)(& (t->dev)->sas_addr))); printk("\016pm80xx %s %d:SAS Address of IO Failure Drive:%016llx", "mpi_ssp_completion", 1883, tmp___4); } } else { } } else { } { if (status == 0U) { goto case_0; } else { } if (status == 1U) { goto case_1; } else { } if (status == 3U) { goto case_3; } else { } if (status == 7U) { goto case_7; } else { } if (status == 14U) { goto case_14; } else { } if (status == 15U) { goto case_15; } else { } if (status == 16U) { goto case_16; } else { } if (status == 17U) { goto case_17; } else { } if (status == 18U) { goto case_18; } else { } if (status == 19U) { goto case_19; } else { } if (status == 20U) { goto case_20; } else { } if (status == 21U) { goto case_21; } else { } if (status == 23U) { goto case_23; } else { } if (status == 25U) { goto case_25; } else { } if (status == 26U) { goto case_26; } else { } if (status == 29U) { goto case_29; } else { } if (status == 36U) { goto case_36; } else { } if (status == 52U) { goto case_52; } else { } if (status == 56U) { goto case_56; } else { } if (status == 57U) { goto case_57; } else { } if (status == 58U) { goto case_58; } else { } if (status == 59U) { goto case_59; } else { } if (status == 61U) { goto case_61; } else { } if (status == 63U) { goto case_63; } else { } goto switch_default; case_0: /* CIL Label */ { tmp___6 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___6 != 0L) { { printk("\016pm80xx %s %d:IO_SUCCESS,param = %d\n", "mpi_ssp_completion", 1888, param); } } else { } if (param == 0U) { ts->resp = 0; ts->stat = 0; } else { { ts->resp = 0; ts->stat = 137; ts->residual = param; iu = & psspPayload->ssp_resp_iu; sas_ssp_task_response(pm8001_ha->dev, t, iu); } } if ((unsigned long )pm8001_dev != (unsigned long )((struct pm8001_device *)0)) { pm8001_dev->running_req = pm8001_dev->running_req - 1U; } else { } goto ldv_46794; case_1: /* CIL Label */ { tmp___7 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___7 != 0L) { { printk("\016pm80xx %s %d:IO_ABORTED IOMB Tag\n", "mpi_ssp_completion", 1904); } } else { } ts->resp = 0; ts->stat = 141; goto ldv_46794; case_3: /* CIL Label */ { tmp___8 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___8 != 0L) { { printk("\016pm80xx %s %d:IO_UNDERFLOW,param = %d\n", "mpi_ssp_completion", 1911, param); } } else { } ts->resp = 0; ts->stat = 129; ts->residual = param; if ((unsigned long )pm8001_dev != (unsigned long )((struct pm8001_device *)0)) { pm8001_dev->running_req = pm8001_dev->running_req - 1U; } else { } goto ldv_46794; case_7: /* CIL Label */ { tmp___9 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___9 != 0L) { { printk("\016pm80xx %s %d:IO_NO_DEVICE\n", "mpi_ssp_completion", 1920); } } else { } ts->resp = -1; ts->stat = 138; goto ldv_46794; case_14: /* CIL Label */ { tmp___10 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___10 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_BREAK\n", "mpi_ssp_completion", 1926); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 18; goto ldv_46794; case_15: /* CIL Label */ { tmp___11 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___11 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_PHY_NOT_READY\n", "mpi_ssp_completion", 1934); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 18; goto ldv_46794; case_16: /* CIL Label */ { tmp___12 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___12 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED\n", "mpi_ssp_completion", 1941); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 3; goto ldv_46794; case_17: /* CIL Label */ { tmp___13 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___13 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_ZONE_VIOLATION\n", "mpi_ssp_completion", 1948); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 0; goto ldv_46794; case_18: /* CIL Label */ { tmp___14 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___14 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_BREAK\n", "mpi_ssp_completion", 1955); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 18; goto ldv_46794; case_19: /* CIL Label */ { tmp___15 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___15 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS\n", "mpi_ssp_completion", 1962); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 0; if ((unsigned long )t->uldd_task == (unsigned long )((void *)0)) { { pm8001_handle_event(pm8001_ha, (void *)pm8001_dev, 19); } } else { } goto ldv_46794; case_20: /* CIL Label */ { tmp___16 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___16 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_BAD_DESTINATION\n", "mpi_ssp_completion", 1973); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 1; goto ldv_46794; case_21: /* CIL Label */ { tmp___17 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___17 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED\n", "mpi_ssp_completion", 1981); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 2; goto ldv_46794; case_23: /* CIL Label */ { tmp___18 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___18 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_WRONG_DESTINATION\n", "mpi_ssp_completion", 1988); } } else { } ts->resp = -1; ts->stat = 135; ts->open_rej_reason = 8; goto ldv_46794; case_25: /* CIL Label */ { tmp___19 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___19 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_NAK_RECEIVED\n", "mpi_ssp_completion", 1995); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 18; goto ldv_46794; case_26: /* CIL Label */ { tmp___20 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___20 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_ACK_NAK_TIMEOUT\n", "mpi_ssp_completion", 2002); } } else { } ts->resp = 0; ts->stat = 139; goto ldv_46794; case_29: /* CIL Label */ { tmp___21 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___21 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_DMA\n", "mpi_ssp_completion", 2008); } } else { } ts->resp = 0; ts->stat = 135; goto ldv_46794; case_36: /* CIL Label */ { tmp___22 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___22 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_OPEN_RETRY_TIMEOUT\n", "mpi_ssp_completion", 2014); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 18; goto ldv_46794; case_52: /* CIL Label */ { tmp___23 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___23 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_OFFSET_MISMATCH\n", "mpi_ssp_completion", 2021); } } else { } ts->resp = 0; ts->stat = 135; goto ldv_46794; case_56: /* CIL Label */ { tmp___24 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___24 != 0L) { { printk("\016pm80xx %s %d:IO_PORT_IN_RESET\n", "mpi_ssp_completion", 2027); } } else { } ts->resp = 0; ts->stat = 135; goto ldv_46794; case_57: /* CIL Label */ { tmp___25 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___25 != 0L) { { printk("\016pm80xx %s %d:IO_DS_NON_OPERATIONAL\n", "mpi_ssp_completion", 2033); } } else { } ts->resp = 0; ts->stat = 135; if ((unsigned long )t->uldd_task == (unsigned long )((void *)0)) { { pm8001_handle_event(pm8001_ha, (void *)pm8001_dev, 57); } } else { } goto ldv_46794; case_58: /* CIL Label */ { tmp___26 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___26 != 0L) { { printk("\016pm80xx %s %d:IO_DS_IN_RECOVERY\n", "mpi_ssp_completion", 2043); } } else { } ts->resp = 0; ts->stat = 135; goto ldv_46794; case_59: /* CIL Label */ { tmp___27 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___27 != 0L) { { printk("\016pm80xx %s %d:IO_TM_TAG_NOT_FOUND\n", "mpi_ssp_completion", 2049); } } else { } ts->resp = 0; ts->stat = 135; goto ldv_46794; case_61: /* CIL Label */ { tmp___28 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___28 != 0L) { { printk("\016pm80xx %s %d:IO_SSP_EXT_IU_ZERO_LEN_ERROR\n", "mpi_ssp_completion", 2055); } } else { } ts->resp = 0; ts->stat = 135; goto ldv_46794; case_63: /* CIL Label */ { tmp___29 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___29 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_HW_RESOURCE_BUSY\n", "mpi_ssp_completion", 2061); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 18; goto ldv_46794; switch_default: /* CIL Label */ { tmp___30 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___30 != 0L) { { printk("\016pm80xx %s %d:Unknown status 0x%x\n", "mpi_ssp_completion", 2068, status); } } else { } ts->resp = 0; ts->stat = 135; goto ldv_46794; switch_break: /* CIL Label */ ; } ldv_46794: { tmp___31 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___31 != 0L) { { printk("\016pm80xx %s %d:scsi_status = %x\n ", "mpi_ssp_completion", 2076, (int )psspPayload->ssp_resp_iu.status); } } else { } { ldv___ldv_linux_kernel_locking_spinlock_spin_lock_144(& t->task_state_lock); t->task_state_flags = t->task_state_flags & 4294967294U; t->task_state_flags = t->task_state_flags & 4294967279U; t->task_state_flags = t->task_state_flags | 2U; tmp___33 = ldv__builtin_expect((t->task_state_flags & 4U) != 0U, 0L); } if (tmp___33 != 0L) { { ldv_spin_unlock_irqrestore_135(& t->task_state_lock, flags); tmp___32 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___32 != 0L) { { printk("\016pm80xx %s %d:task 0x%p done with io_status 0x%x resp 0x%x stat 0x%x but aborted by upper layer!\n", "mpi_ssp_completion", 2086, t, status, (int )ts->resp, (unsigned int )ts->stat); } } else { } { pm8001_ccb_task_free(pm8001_ha, t, ccb, tag); } } else { { ldv_spin_unlock_irqrestore_135(& t->task_state_lock, flags); pm8001_ccb_task_free(pm8001_ha, t, ccb, tag); __asm__ volatile ("mfence": : : "memory"); (*(t->task_done))(t); } } return; } } static void mpi_ssp_event(struct pm8001_hba_info *pm8001_ha , void *piomb ) { struct sas_task *t ; unsigned long flags ; struct task_status_struct *ts ; struct pm8001_ccb_info *ccb ; struct pm8001_device *pm8001_dev ; struct ssp_event_resp *psspPayload ; u32 event ; u32 tag ; u32 port_id ; u32 dev_id ; long tmp ; long tmp___0 ; long tmp___1 ; int tmp___2 ; long tmp___3 ; long tmp___4 ; long tmp___5 ; long tmp___6 ; long tmp___7 ; long tmp___8 ; long tmp___9 ; long tmp___10 ; long tmp___11 ; long tmp___12 ; long tmp___13 ; long tmp___14 ; long tmp___15 ; long tmp___16 ; long tmp___17 ; long tmp___18 ; long tmp___19 ; long tmp___20 ; long tmp___21 ; long tmp___22 ; long tmp___23 ; long tmp___24 ; long tmp___25 ; long tmp___26 ; long tmp___27 ; { psspPayload = (struct ssp_event_resp *)piomb + 4U; event = psspPayload->event; tag = psspPayload->tag; port_id = psspPayload->port_id; dev_id = psspPayload->device_id; ccb = pm8001_ha->ccb_info + (unsigned long )tag; t = ccb->task; pm8001_dev = ccb->device; if (event != 0U) { { tmp = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:sas IO status 0x%x\n", "mpi_ssp_event", 2116, event); } } else { } } else { } { tmp___0 = ldv__builtin_expect((unsigned long )t == (unsigned long )((struct sas_task *)0), 0L); } if (tmp___0 != 0L) { tmp___2 = 1; } else { { tmp___1 = ldv__builtin_expect((unsigned long )t->lldd_task == (unsigned long )((void *)0), 0L); } if (tmp___1 != 0L) { tmp___2 = 1; } else { tmp___2 = 0; } } if (tmp___2 != 0) { return; } else { { tmp___3 = ldv__builtin_expect((unsigned long )t->dev == (unsigned long )((struct domain_device *)0), 0L); } if (tmp___3 != 0L) { return; } else { } } { ts = & t->task_status; tmp___4 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___4 != 0L) { { printk("\016pm80xx %s %d:port_id = %x,device_id = %x\n", "mpi_ssp_event", 2122, port_id, dev_id); } } else { } { if (event == 2U) { goto case_2; } else { } if (event == 14U) { goto case_14; } else { } if (event == 15U) { goto case_15; } else { } if (event == 16U) { goto case_16; } else { } if (event == 17U) { goto case_17; } else { } if (event == 18U) { goto case_18; } else { } if (event == 19U) { goto case_19; } else { } if (event == 20U) { goto case_20; } else { } if (event == 21U) { goto case_21; } else { } if (event == 23U) { goto case_23; } else { } if (event == 25U) { goto case_25; } else { } if (event == 26U) { goto case_26; } else { } if (event == 36U) { goto case_36; } else { } if (event == 38U) { goto case_38; } else { } if (event == 39U) { goto case_39; } else { } if (event == 40U) { goto case_40; } else { } if (event == 48U) { goto case_48; } else { } if (event == 52U) { goto case_52; } else { } if (event == 53U) { goto case_53; } else { } if (event == 54U) { goto case_54; } else { } goto switch_default; case_2: /* CIL Label */ { tmp___5 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___5 != 0L) { { printk("\016pm80xx %s %d:IO_UNDERFLOW\n", "mpi_ssp_event", 2125); } } else { } ts->resp = 0; ts->stat = 130; ts->residual = 0U; if ((unsigned long )pm8001_dev != (unsigned long )((struct pm8001_device *)0)) { pm8001_dev->running_req = pm8001_dev->running_req - 1U; } else { } goto ldv_46835; case_14: /* CIL Label */ { tmp___6 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___6 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_BREAK\n", "mpi_ssp_event", 2134); } } else { } { pm8001_handle_event(pm8001_ha, (void *)t, 14); } return; case_15: /* CIL Label */ { tmp___7 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___7 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_PHY_NOT_READY\n", "mpi_ssp_event", 2139); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 18; goto ldv_46835; case_16: /* CIL Label */ { tmp___8 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___8 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED\n", "mpi_ssp_event", 2147); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 3; goto ldv_46835; case_17: /* CIL Label */ { tmp___9 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___9 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_ZONE_VIOLATION\n", "mpi_ssp_event", 2154); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 0; goto ldv_46835; case_18: /* CIL Label */ { tmp___10 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___10 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_BREAK\n", "mpi_ssp_event", 2161); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 18; goto ldv_46835; case_19: /* CIL Label */ { tmp___11 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___11 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS\n", "mpi_ssp_event", 2168); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 0; if ((unsigned long )t->uldd_task == (unsigned long )((void *)0)) { { pm8001_handle_event(pm8001_ha, (void *)pm8001_dev, 19); } } else { } goto ldv_46835; case_20: /* CIL Label */ { tmp___12 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___12 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_BAD_DESTINATION\n", "mpi_ssp_event", 2179); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 1; goto ldv_46835; case_21: /* CIL Label */ { tmp___13 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___13 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED\n", "mpi_ssp_event", 2187); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 2; goto ldv_46835; case_23: /* CIL Label */ { tmp___14 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___14 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_WRONG_DESTINATION\n", "mpi_ssp_event", 2194); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 8; goto ldv_46835; case_25: /* CIL Label */ { tmp___15 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___15 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_NAK_RECEIVED\n", "mpi_ssp_event", 2201); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 18; goto ldv_46835; case_26: /* CIL Label */ { tmp___16 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___16 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_ACK_NAK_TIMEOUT\n", "mpi_ssp_event", 2208); } } else { } ts->resp = 0; ts->stat = 139; goto ldv_46835; case_36: /* CIL Label */ { tmp___17 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___17 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_OPEN_RETRY_TIMEOUT\n", "mpi_ssp_event", 2214); } } else { } { pm8001_handle_event(pm8001_ha, (void *)t, 36); } return; case_38: /* CIL Label */ { tmp___18 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___18 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_UNEXPECTED_PHASE\n", "mpi_ssp_event", 2219); } } else { } ts->resp = 0; ts->stat = 130; goto ldv_46835; case_39: /* CIL Label */ { tmp___19 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___19 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_XFER_RDY_OVERRUN\n", "mpi_ssp_event", 2225); } } else { } ts->resp = 0; ts->stat = 130; goto ldv_46835; case_40: /* CIL Label */ { tmp___20 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___20 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_XFER_RDY_NOT_EXPECTED\n", "mpi_ssp_event", 2231); } } else { } ts->resp = 0; ts->stat = 130; goto ldv_46835; case_48: /* CIL Label */ { tmp___21 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___21 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_CMD_ISSUE_ACK_NAK_TIMEOUT\n", "mpi_ssp_event", 2237); } } else { } ts->resp = 0; ts->stat = 130; goto ldv_46835; case_52: /* CIL Label */ { tmp___22 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___22 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_OFFSET_MISMATCH\n", "mpi_ssp_event", 2243); } } else { } ts->resp = 0; ts->stat = 130; goto ldv_46835; case_53: /* CIL Label */ { tmp___23 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___23 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_XFER_ZERO_DATA_LEN\n", "mpi_ssp_event", 2249); } } else { } ts->resp = 0; ts->stat = 130; goto ldv_46835; case_54: /* CIL Label */ { tmp___24 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___24 != 0L) { { printk("\016pm80xx %s %d: IO_XFER_CMD_FRAME_ISSUED\n", "mpi_ssp_event", 2255); } } else { } return; switch_default: /* CIL Label */ { tmp___25 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___25 != 0L) { { printk("\016pm80xx %s %d:Unknown status 0x%x\n", "mpi_ssp_event", 2259, event); } } else { } ts->resp = 0; ts->stat = 130; goto ldv_46835; switch_break: /* CIL Label */ ; } ldv_46835: { ldv___ldv_linux_kernel_locking_spinlock_spin_lock_147(& t->task_state_lock); t->task_state_flags = t->task_state_flags & 4294967294U; t->task_state_flags = t->task_state_flags & 4294967279U; t->task_state_flags = t->task_state_flags | 2U; tmp___27 = ldv__builtin_expect((t->task_state_flags & 4U) != 0U, 0L); } if (tmp___27 != 0L) { { ldv_spin_unlock_irqrestore_135(& t->task_state_lock, flags); tmp___26 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___26 != 0L) { { printk("\016pm80xx %s %d:task 0x%p done with event 0x%x resp 0x%x stat 0x%x but aborted by upper layer!\n", "mpi_ssp_event", 2274, t, event, (int )ts->resp, (unsigned int )ts->stat); } } else { } { pm8001_ccb_task_free(pm8001_ha, t, ccb, tag); } } else { { ldv_spin_unlock_irqrestore_135(& t->task_state_lock, flags); pm8001_ccb_task_free(pm8001_ha, t, ccb, tag); __asm__ volatile ("mfence": : : "memory"); (*(t->task_done))(t); } } return; } } static void mpi_sata_completion(struct pm8001_hba_info *pm8001_ha , void *piomb ) { struct sas_task *t ; struct pm8001_ccb_info *ccb ; u32 param ; u32 status ; u32 tag ; int i ; int j ; u8 sata_addr_low[4U] ; u32 temp_sata_addr_low ; u8 sata_addr_hi[4U] ; u32 temp_sata_addr_hi ; struct sata_completion_resp *psataPayload ; struct task_status_struct *ts ; struct ata_task_resp *resp ; u32 *sata_resp ; struct pm8001_device *pm8001_dev ; unsigned long flags ; long tmp ; long tmp___0 ; long tmp___1 ; long tmp___2 ; long tmp___3 ; long tmp___4 ; int tmp___5 ; long tmp___6 ; long tmp___7 ; long tmp___8 ; __u64 tmp___9 ; long tmp___10 ; long tmp___11 ; u8 len ; long tmp___12 ; long tmp___13 ; long tmp___14 ; long tmp___15 ; long tmp___17 ; long tmp___18 ; long tmp___19 ; long tmp___20 ; long tmp___21 ; long tmp___22 ; long tmp___23 ; long tmp___24 ; long tmp___25 ; long tmp___26 ; long tmp___27 ; long tmp___28 ; long tmp___29 ; long tmp___30 ; long tmp___31 ; long tmp___32 ; long tmp___33 ; long tmp___34 ; long tmp___35 ; long tmp___36 ; long tmp___37 ; long tmp___38 ; long tmp___39 ; long tmp___40 ; long tmp___41 ; long tmp___42 ; long tmp___43 ; { psataPayload = (struct sata_completion_resp *)piomb + 4U; status = psataPayload->status; tag = psataPayload->tag; if (tag == 0U) { { tmp = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:tag null\n", "mpi_sata_completion", 2311); } } else { } return; } else { } ccb = pm8001_ha->ccb_info + (unsigned long )tag; param = psataPayload->param; if ((unsigned long )ccb != (unsigned long )((struct pm8001_ccb_info *)0)) { t = ccb->task; pm8001_dev = ccb->device; } else { { tmp___0 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___0 != 0L) { { printk("\016pm80xx %s %d:ccb null\n", "mpi_sata_completion", 2321); } } else { } return; } if ((unsigned long )t != (unsigned long )((struct sas_task *)0)) { if ((unsigned long )t->dev != (unsigned long )((struct domain_device *)0) && (unsigned long )(t->dev)->lldd_dev != (unsigned long )((void *)0)) { pm8001_dev = (struct pm8001_device *)(t->dev)->lldd_dev; } else { } } else { { tmp___1 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___1 != 0L) { { printk("\016pm80xx %s %d:task null\n", "mpi_sata_completion", 2330); } } else { } return; } if ((unsigned long )pm8001_dev != (unsigned long )((struct pm8001_device *)0) && (int )pm8001_dev->id >= 0) { { tmp___3 = ldv__builtin_expect((unsigned long )t == (unsigned long )((struct sas_task *)0), 0L); } if (tmp___3 != 0L) { tmp___5 = 1; } else { { tmp___4 = ldv__builtin_expect((unsigned long )t->lldd_task == (unsigned long )((void *)0), 0L); } if (tmp___4 != 0L) { tmp___5 = 1; } else { tmp___5 = 0; } } if (tmp___5 != 0) { goto _L; } else { { tmp___6 = ldv__builtin_expect((unsigned long )t->dev == (unsigned long )((struct domain_device *)0), 0L); } if (tmp___6 != 0L) { _L: /* CIL Label */ { tmp___2 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___2 != 0L) { { printk("\016pm80xx %s %d:task or dev null\n", "mpi_sata_completion", 2337); } } else { } return; } else { } } } else { } ts = & t->task_status; if ((unsigned long )ts == (unsigned long )((struct task_status_struct *)0)) { { tmp___7 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___7 != 0L) { { printk("\016pm80xx %s %d:ts null\n", "mpi_sata_completion", 2344); } } else { } return; } else { } if ((status != 0U && status != 2U) && status != 3U) { if ((unsigned long )(t->dev)->parent == (unsigned long )((struct domain_device *)0) || (unsigned int )((t->dev)->parent)->dev_type - 2U > 1U) { i = 0; j = 4; goto ldv_46879; ldv_46878: sata_addr_low[i] = pm8001_ha->sas_addr[j]; i = i + 1; j = j + 1; ldv_46879: ; if (j <= 7 && i <= 3) { goto ldv_46878; } else { } i = 0; j = 0; goto ldv_46882; ldv_46881: sata_addr_hi[i] = pm8001_ha->sas_addr[j]; i = i + 1; j = j + 1; ldv_46882: ; if (j <= 3 && i <= 3) { goto ldv_46881; } else { } { __memcpy((void *)(& temp_sata_addr_low), (void const *)(& sata_addr_low), 4UL); __memcpy((void *)(& temp_sata_addr_hi), (void const *)(& sata_addr_hi), 4UL); temp_sata_addr_hi = (((temp_sata_addr_hi >> 24) | ((temp_sata_addr_hi << 8) & 16711680U)) | ((temp_sata_addr_hi >> 8) & 65280U)) | (temp_sata_addr_hi << 24); temp_sata_addr_low = (((((temp_sata_addr_low >> 24) | ((temp_sata_addr_low << 8) & 16711680U)) | ((temp_sata_addr_low >> 8) & 65280U)) | (temp_sata_addr_low << 24)) + pm8001_dev->attached_phy) + 16U; tmp___8 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___8 != 0L) { { printk("\016pm80xx %s %d:SAS Address of IO Failure Drive:%08x%08x", "mpi_sata_completion", 2380, temp_sata_addr_hi, temp_sata_addr_low); } } else { } } else { { tmp___10 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___10 != 0L) { { tmp___9 = __fswab64(*((__be64 *)(& (t->dev)->sas_addr))); printk("\016pm80xx %s %d:SAS Address of IO Failure Drive:%016llx", "mpi_sata_completion", 2384, tmp___9); } } else { } } } else { } { if (status == 0U) { goto case_0; } else { } if (status == 1U) { goto case_1; } else { } if (status == 3U) { goto case_3; } else { } if (status == 7U) { goto case_7; } else { } if (status == 14U) { goto case_14; } else { } if (status == 15U) { goto case_15; } else { } if (status == 16U) { goto case_16; } else { } if (status == 17U) { goto case_17; } else { } if (status == 18U) { goto case_18; } else { } if (status == 19U) { goto case_19; } else { } if (status == 20U) { goto case_20; } else { } if (status == 21U) { goto case_21; } else { } if (status == 22U) { goto case_22; } else { } if (status == 23U) { goto case_23; } else { } if (status == 25U) { goto case_25; } else { } if (status == 26U) { goto case_26; } else { } if (status == 29U) { goto case_29; } else { } if (status == 31U) { goto case_31; } else { } if (status == 33U) { goto case_33; } else { } if (status == 36U) { goto case_36; } else { } if (status == 56U) { goto case_56; } else { } if (status == 57U) { goto case_57; } else { } if (status == 58U) { goto case_58; } else { } if (status == 62U) { goto case_62; } else { } if (status == 63U) { goto case_63; } else { } goto switch_default; case_0: /* CIL Label */ { tmp___11 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___11 != 0L) { { printk("\016pm80xx %s %d:IO_SUCCESS\n", "mpi_sata_completion", 2389); } } else { } if (param == 0U) { ts->resp = 0; ts->stat = 0; if ((unsigned long )pm8001_dev != (unsigned long )((struct pm8001_device *)0) && (int )pm8001_dev->id < 0) { { pm8001_dev->id = pm8001_dev->id | 1073741824U; pm8001_dev->id = pm8001_dev->id & 2147483647U; pm8001_send_abort_all(pm8001_ha, pm8001_dev); pm8001_tag_free(pm8001_ha, tag); sas_free_task(t); } return; } else { } } else { { ts->resp = 0; ts->stat = 137; ts->residual = param; tmp___12 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___12 != 0L) { { printk("\016pm80xx %s %d:SAS_PROTO_RESPONSE len = %d\n", "mpi_sata_completion", 2413, param); } } else { } sata_resp = (u32 *)(& psataPayload->sata_resp); resp = (struct ata_task_resp *)(& ts->buf); if ((unsigned int )*((unsigned char *)t + 125UL) == 0U && (unsigned int )*((unsigned char *)t + 184UL) == 2U) { { len = 19U; tmp___13 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___13 != 0L) { { printk("\016pm80xx %s %d:PIO read len = %d\n", "mpi_sata_completion", 2420, (int )len); } } else { } } else if ((unsigned int )*((unsigned char *)t + 125UL) != 0U) { { len = 8U; tmp___14 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___14 != 0L) { { printk("\016pm80xx %s %d:FPDMA len = %d\n", "mpi_sata_completion", 2424, (int )len); } } else { } } else { { len = 20U; tmp___15 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___15 != 0L) { { printk("\016pm80xx %s %d:other len = %d\n", "mpi_sata_completion", 2428, (int )len); } } else { } } { resp->frame_len = (u16 )len; __memcpy((void *)(& resp->ending_fis), (void const *)sata_resp, (size_t )len); ts->buf_valid_size = 26; } } if ((unsigned long )pm8001_dev != (unsigned long )((struct pm8001_device *)0)) { pm8001_dev->running_req = pm8001_dev->running_req - 1U; } else { } goto ldv_46886; case_1: /* CIL Label */ { tmp___17 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___17 != 0L) { { printk("\016pm80xx %s %d:IO_ABORTED IOMB Tag\n", "mpi_sata_completion", 2443); } } else { } ts->resp = 0; ts->stat = 141; if ((unsigned long )pm8001_dev != (unsigned long )((struct pm8001_device *)0)) { pm8001_dev->running_req = pm8001_dev->running_req - 1U; } else { } goto ldv_46886; case_3: /* CIL Label */ { tmp___18 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___18 != 0L) { { printk("\016pm80xx %s %d:IO_UNDERFLOW param = %d\n", "mpi_sata_completion", 2453, param); } } else { } ts->resp = 0; ts->stat = 129; ts->residual = param; if ((unsigned long )pm8001_dev != (unsigned long )((struct pm8001_device *)0)) { pm8001_dev->running_req = pm8001_dev->running_req - 1U; } else { } goto ldv_46886; case_7: /* CIL Label */ { tmp___19 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___19 != 0L) { { printk("\016pm80xx %s %d:IO_NO_DEVICE\n", "mpi_sata_completion", 2462); } } else { } ts->resp = -1; ts->stat = 138; goto ldv_46886; case_14: /* CIL Label */ { tmp___20 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___20 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_BREAK\n", "mpi_sata_completion", 2468); } } else { } ts->resp = 0; ts->stat = 131; goto ldv_46886; case_15: /* CIL Label */ { tmp___21 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___21 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_PHY_NOT_READY\n", "mpi_sata_completion", 2474); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 18; goto ldv_46886; case_16: /* CIL Label */ { tmp___22 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___22 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED\n", "mpi_sata_completion", 2482); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 3; goto ldv_46886; case_17: /* CIL Label */ { tmp___23 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___23 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_ZONE_VIOLATION\n", "mpi_sata_completion", 2489); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 0; goto ldv_46886; case_18: /* CIL Label */ { tmp___24 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___24 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_BREAK\n", "mpi_sata_completion", 2496); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 12; goto ldv_46886; case_19: /* CIL Label */ { tmp___25 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___25 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS\n", "mpi_sata_completion", 2503); } } else { } ts->resp = 0; ts->stat = 128; if ((unsigned long )t->uldd_task == (unsigned long )((void *)0)) { { pm8001_handle_event(pm8001_ha, (void *)pm8001_dev, 19); ts->resp = -1; ts->stat = 132; pm8001_ccb_task_free_done(pm8001_ha, t, ccb, tag); } return; } else { } goto ldv_46886; case_20: /* CIL Label */ { tmp___26 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___26 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_BAD_DESTINATION\n", "mpi_sata_completion", 2518); } } else { } ts->resp = -1; ts->stat = 135; ts->open_rej_reason = 1; if ((unsigned long )t->uldd_task == (unsigned long )((void *)0)) { { pm8001_handle_event(pm8001_ha, (void *)pm8001_dev, 19); ts->resp = -1; ts->stat = 132; pm8001_ccb_task_free_done(pm8001_ha, t, ccb, tag); } return; } else { } goto ldv_46886; case_21: /* CIL Label */ { tmp___27 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___27 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED\n", "mpi_sata_completion", 2535); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 2; goto ldv_46886; case_22: /* CIL Label */ { tmp___28 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___28 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY\n", "mpi_sata_completion", 2543); } } else { } ts->resp = 0; ts->stat = 128; if ((unsigned long )t->uldd_task == (unsigned long )((void *)0)) { { pm8001_handle_event(pm8001_ha, (void *)pm8001_dev, 22); ts->resp = -1; ts->stat = 132; pm8001_ccb_task_free_done(pm8001_ha, t, ccb, tag); } return; } else { } goto ldv_46886; case_23: /* CIL Label */ { tmp___29 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___29 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_WRONG_DESTINATION\n", "mpi_sata_completion", 2558); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 8; goto ldv_46886; case_25: /* CIL Label */ { tmp___30 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___30 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_NAK_RECEIVED\n", "mpi_sata_completion", 2565); } } else { } ts->resp = 0; ts->stat = 139; goto ldv_46886; case_26: /* CIL Label */ { tmp___31 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___31 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_ACK_NAK_TIMEOUT\n", "mpi_sata_completion", 2571); } } else { } ts->resp = 0; ts->stat = 139; goto ldv_46886; case_29: /* CIL Label */ { tmp___32 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___32 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_DMA\n", "mpi_sata_completion", 2577); } } else { } ts->resp = 0; ts->stat = 141; goto ldv_46886; case_31: /* CIL Label */ { tmp___33 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___33 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_SATA_LINK_TIMEOUT\n", "mpi_sata_completion", 2583); } } else { } ts->resp = -1; ts->stat = 128; goto ldv_46886; case_33: /* CIL Label */ { tmp___34 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___34 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_REJECTED_NCQ_MODE\n", "mpi_sata_completion", 2589); } } else { } ts->resp = 0; ts->stat = 129; goto ldv_46886; case_36: /* CIL Label */ { tmp___35 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___35 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_OPEN_RETRY_TIMEOUT\n", "mpi_sata_completion", 2595); } } else { } ts->resp = 0; ts->stat = 136; goto ldv_46886; case_56: /* CIL Label */ { tmp___36 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___36 != 0L) { { printk("\016pm80xx %s %d:IO_PORT_IN_RESET\n", "mpi_sata_completion", 2601); } } else { } ts->resp = 0; ts->stat = 128; goto ldv_46886; case_57: /* CIL Label */ { tmp___37 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___37 != 0L) { { printk("\016pm80xx %s %d:IO_DS_NON_OPERATIONAL\n", "mpi_sata_completion", 2607); } } else { } ts->resp = 0; ts->stat = 128; if ((unsigned long )t->uldd_task == (unsigned long )((void *)0)) { { pm8001_handle_event(pm8001_ha, (void *)pm8001_dev, 57); ts->resp = -1; ts->stat = 132; pm8001_ccb_task_free_done(pm8001_ha, t, ccb, tag); } return; } else { } goto ldv_46886; case_58: /* CIL Label */ { tmp___38 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___38 != 0L) { { printk("\016pm80xx %s %d: IO_DS_IN_RECOVERY\n", "mpi_sata_completion", 2621); } } else { } ts->resp = 0; ts->stat = 128; goto ldv_46886; case_62: /* CIL Label */ { tmp___39 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___39 != 0L) { { printk("\016pm80xx %s %d:IO_DS_IN_ERROR\n", "mpi_sata_completion", 2627); } } else { } ts->resp = 0; ts->stat = 128; if ((unsigned long )t->uldd_task == (unsigned long )((void *)0)) { { pm8001_handle_event(pm8001_ha, (void *)pm8001_dev, 62); ts->resp = -1; ts->stat = 132; pm8001_ccb_task_free_done(pm8001_ha, t, ccb, tag); } return; } else { } goto ldv_46886; case_63: /* CIL Label */ { tmp___40 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___40 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_HW_RESOURCE_BUSY\n", "mpi_sata_completion", 2641); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 18; switch_default: /* CIL Label */ { tmp___41 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___41 != 0L) { { printk("\016pm80xx %s %d:Unknown status 0x%x\n", "mpi_sata_completion", 2647, status); } } else { } ts->resp = 0; ts->stat = 128; goto ldv_46886; switch_break: /* CIL Label */ ; } ldv_46886: { ldv___ldv_linux_kernel_locking_spinlock_spin_lock_150(& t->task_state_lock); t->task_state_flags = t->task_state_flags & 4294967294U; t->task_state_flags = t->task_state_flags & 4294967279U; t->task_state_flags = t->task_state_flags | 2U; tmp___43 = ldv__builtin_expect((t->task_state_flags & 4U) != 0U, 0L); } if (tmp___43 != 0L) { { ldv_spin_unlock_irqrestore_135(& t->task_state_lock, flags); tmp___42 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___42 != 0L) { { printk("\016pm80xx %s %d:task 0x%p done with io_status 0x%x resp 0x%x stat 0x%x but aborted by upper layer!\n", "mpi_sata_completion", 2662, t, status, (int )ts->resp, (unsigned int )ts->stat); } } else { } { pm8001_ccb_task_free(pm8001_ha, t, ccb, tag); } } else { { ldv_spin_unlock_irqrestore_135(& t->task_state_lock, flags); pm8001_ccb_task_free_done(pm8001_ha, t, ccb, tag); } } return; } } static void mpi_sata_event(struct pm8001_hba_info *pm8001_ha , void *piomb ) { struct sas_task *t ; struct task_status_struct *ts ; struct pm8001_ccb_info *ccb ; struct pm8001_device *pm8001_dev ; struct sata_event_resp *psataPayload ; u32 event ; u32 tag ; u32 port_id ; u32 dev_id ; unsigned long flags ; long tmp ; long tmp___0 ; long tmp___1 ; long tmp___2 ; long tmp___3 ; int tmp___4 ; long tmp___5 ; long tmp___6 ; long tmp___7 ; long tmp___8 ; long tmp___9 ; long tmp___10 ; long tmp___11 ; long tmp___12 ; long tmp___13 ; long tmp___14 ; long tmp___15 ; long tmp___16 ; long tmp___17 ; long tmp___18 ; long tmp___19 ; long tmp___20 ; long tmp___21 ; long tmp___22 ; long tmp___23 ; long tmp___24 ; long tmp___25 ; long tmp___26 ; long tmp___27 ; long tmp___28 ; long tmp___29 ; long tmp___30 ; { psataPayload = (struct sata_event_resp *)piomb + 4U; event = psataPayload->event; tag = psataPayload->tag; port_id = psataPayload->port_id; dev_id = psataPayload->device_id; ccb = pm8001_ha->ccb_info + (unsigned long )tag; if ((unsigned long )ccb != (unsigned long )((struct pm8001_ccb_info *)0)) { t = ccb->task; pm8001_dev = ccb->device; } else { { tmp = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:No CCB !!!. returning\n", "mpi_sata_event", 2692); } } else { } } if (event != 0U) { { tmp___0 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___0 != 0L) { { printk("\016pm80xx %s %d:SATA EVENT 0x%x\n", "mpi_sata_event", 2696, event); } } else { } } else { } if (event == 35U) { { pm8001_dev = pm8001_find_dev(pm8001_ha, dev_id); } if ((unsigned long )pm8001_dev != (unsigned long )((struct pm8001_device *)0)) { { pm8001_send_read_log(pm8001_ha, pm8001_dev); } } else { } return; } else { } ccb = pm8001_ha->ccb_info + (unsigned long )tag; t = ccb->task; pm8001_dev = ccb->device; if (event != 0U) { { tmp___1 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___1 != 0L) { { printk("\016pm80xx %s %d:sata IO status 0x%x\n", "mpi_sata_event", 2713, event); } } else { } } else { } { tmp___2 = ldv__builtin_expect((unsigned long )t == (unsigned long )((struct sas_task *)0), 0L); } if (tmp___2 != 0L) { tmp___4 = 1; } else { { tmp___3 = ldv__builtin_expect((unsigned long )t->lldd_task == (unsigned long )((void *)0), 0L); } if (tmp___3 != 0L) { tmp___4 = 1; } else { tmp___4 = 0; } } if (tmp___4 != 0) { return; } else { { tmp___5 = ldv__builtin_expect((unsigned long )t->dev == (unsigned long )((struct domain_device *)0), 0L); } if (tmp___5 != 0L) { return; } else { } } { ts = & t->task_status; tmp___6 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___6 != 0L) { { printk("\016pm80xx %s %d:port_id:0x%x, device_id:0x%x, tag:0x%x, event:0x%x\n", "mpi_sata_event", 2719, port_id, dev_id, tag, event); } } else { } { if (event == 2U) { goto case_2; } else { } if (event == 14U) { goto case_14; } else { } if (event == 15U) { goto case_15; } else { } if (event == 16U) { goto case_16; } else { } if (event == 17U) { goto case_17; } else { } if (event == 18U) { goto case_18; } else { } if (event == 19U) { goto case_19; } else { } if (event == 20U) { goto case_20; } else { } if (event == 21U) { goto case_21; } else { } if (event == 23U) { goto case_23; } else { } if (event == 25U) { goto case_25; } else { } if (event == 27U) { goto case_27; } else { } if (event == 33U) { goto case_33; } else { } if (event == 36U) { goto case_36; } else { } if (event == 38U) { goto case_38; } else { } if (event == 39U) { goto case_39; } else { } if (event == 40U) { goto case_40; } else { } if (event == 52U) { goto case_52; } else { } if (event == 53U) { goto case_53; } else { } if (event == 54U) { goto case_54; } else { } if (event == 60U) { goto case_60; } else { } goto switch_default; case_2: /* CIL Label */ { tmp___7 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___7 != 0L) { { printk("\016pm80xx %s %d:IO_UNDERFLOW\n", "mpi_sata_event", 2722); } } else { } ts->resp = 0; ts->stat = 130; ts->residual = 0U; if ((unsigned long )pm8001_dev != (unsigned long )((struct pm8001_device *)0)) { pm8001_dev->running_req = pm8001_dev->running_req - 1U; } else { } goto ldv_46928; case_14: /* CIL Label */ { tmp___8 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___8 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_BREAK\n", "mpi_sata_event", 2731); } } else { } ts->resp = 0; ts->stat = 131; goto ldv_46928; case_15: /* CIL Label */ { tmp___9 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___9 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_PHY_NOT_READY\n", "mpi_sata_event", 2737); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 18; goto ldv_46928; case_16: /* CIL Label */ { tmp___10 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___10 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED\n", "mpi_sata_event", 2745); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 3; goto ldv_46928; case_17: /* CIL Label */ { tmp___11 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___11 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_ZONE_VIOLATION\n", "mpi_sata_event", 2752); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 0; goto ldv_46928; case_18: /* CIL Label */ { tmp___12 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___12 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_BREAK\n", "mpi_sata_event", 2759); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 12; goto ldv_46928; case_19: /* CIL Label */ { tmp___13 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___13 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS\n", "mpi_sata_event", 2766); } } else { } ts->resp = -1; ts->stat = 128; if ((unsigned long )t->uldd_task == (unsigned long )((void *)0)) { { pm8001_handle_event(pm8001_ha, (void *)pm8001_dev, 19); ts->resp = 0; ts->stat = 132; pm8001_ccb_task_free_done(pm8001_ha, t, ccb, tag); } return; } else { } goto ldv_46928; case_20: /* CIL Label */ { tmp___14 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___14 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_BAD_DESTINATION\n", "mpi_sata_event", 2781); } } else { } ts->resp = -1; ts->stat = 135; ts->open_rej_reason = 1; goto ldv_46928; case_21: /* CIL Label */ { tmp___15 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___15 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED\n", "mpi_sata_event", 2789); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 2; goto ldv_46928; case_23: /* CIL Label */ { tmp___16 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___16 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_WRONG_DESTINATION\n", "mpi_sata_event", 2796); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 8; goto ldv_46928; case_25: /* CIL Label */ { tmp___17 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___17 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_NAK_RECEIVED\n", "mpi_sata_event", 2803); } } else { } ts->resp = 0; ts->stat = 139; goto ldv_46928; case_27: /* CIL Label */ { tmp___18 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___18 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_PEER_ABORTED\n", "mpi_sata_event", 2809); } } else { } ts->resp = 0; ts->stat = 139; goto ldv_46928; case_33: /* CIL Label */ { tmp___19 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___19 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_REJECTED_NCQ_MODE\n", "mpi_sata_event", 2815); } } else { } ts->resp = 0; ts->stat = 129; goto ldv_46928; case_36: /* CIL Label */ { tmp___20 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___20 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_OPEN_RETRY_TIMEOUT\n", "mpi_sata_event", 2821); } } else { } ts->resp = 0; ts->stat = 136; goto ldv_46928; case_38: /* CIL Label */ { tmp___21 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___21 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_UNEXPECTED_PHASE\n", "mpi_sata_event", 2827); } } else { } ts->resp = 0; ts->stat = 136; goto ldv_46928; case_39: /* CIL Label */ { tmp___22 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___22 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_XFER_RDY_OVERRUN\n", "mpi_sata_event", 2833); } } else { } ts->resp = 0; ts->stat = 136; goto ldv_46928; case_40: /* CIL Label */ { tmp___23 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___23 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_XFER_RDY_NOT_EXPECTED\n", "mpi_sata_event", 2839); } } else { } ts->resp = 0; ts->stat = 136; goto ldv_46928; case_52: /* CIL Label */ { tmp___24 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___24 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_OFFSET_MISMATCH\n", "mpi_sata_event", 2845); } } else { } ts->resp = 0; ts->stat = 136; goto ldv_46928; case_53: /* CIL Label */ { tmp___25 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___25 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_XFER_ZERO_DATA_LEN\n", "mpi_sata_event", 2851); } } else { } ts->resp = 0; ts->stat = 136; goto ldv_46928; case_54: /* CIL Label */ { tmp___26 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___26 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_CMD_FRAME_ISSUED\n", "mpi_sata_event", 2857); } } else { } goto ldv_46928; case_60: /* CIL Label */ { tmp___27 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___27 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_PIO_SETUP_ERROR\n", "mpi_sata_event", 2861); } } else { } ts->resp = 0; ts->stat = 136; goto ldv_46928; switch_default: /* CIL Label */ { tmp___28 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___28 != 0L) { { printk("\016pm80xx %s %d:Unknown status 0x%x\n", "mpi_sata_event", 2867, event); } } else { } ts->resp = 0; ts->stat = 136; goto ldv_46928; switch_break: /* CIL Label */ ; } ldv_46928: { ldv___ldv_linux_kernel_locking_spinlock_spin_lock_153(& t->task_state_lock); t->task_state_flags = t->task_state_flags & 4294967294U; t->task_state_flags = t->task_state_flags & 4294967279U; t->task_state_flags = t->task_state_flags | 2U; tmp___30 = ldv__builtin_expect((t->task_state_flags & 4U) != 0U, 0L); } if (tmp___30 != 0L) { { ldv_spin_unlock_irqrestore_135(& t->task_state_lock, flags); tmp___29 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___29 != 0L) { { printk("\016pm80xx %s %d:task 0x%p done with io_status 0x%x resp 0x%x stat 0x%x but aborted by upper layer!\n", "mpi_sata_event", 2882, t, event, (int )ts->resp, (unsigned int )ts->stat); } } else { } { pm8001_ccb_task_free(pm8001_ha, t, ccb, tag); } } else { { ldv_spin_unlock_irqrestore_135(& t->task_state_lock, flags); pm8001_ccb_task_free_done(pm8001_ha, t, ccb, tag); } } return; } } static void mpi_smp_completion(struct pm8001_hba_info *pm8001_ha , void *piomb ) { u32 param ; struct sas_task *t ; struct pm8001_ccb_info *ccb ; unsigned long flags ; u32 status ; u32 tag ; struct smp_completion_resp *psmpPayload ; struct task_status_struct *ts ; struct pm8001_device *pm8001_dev ; long tmp ; long tmp___0 ; long tmp___1 ; int tmp___2 ; long tmp___3 ; long tmp___4 ; long tmp___5 ; long tmp___6 ; long tmp___7 ; long tmp___8 ; long tmp___9 ; long tmp___10 ; long tmp___11 ; long tmp___12 ; long tmp___13 ; long tmp___14 ; long tmp___15 ; long tmp___16 ; long tmp___17 ; long tmp___18 ; long tmp___19 ; long tmp___20 ; long tmp___21 ; long tmp___22 ; long tmp___23 ; long tmp___24 ; long tmp___25 ; long tmp___26 ; long tmp___27 ; { psmpPayload = (struct smp_completion_resp *)piomb + 4U; status = psmpPayload->status; tag = psmpPayload->tag; ccb = pm8001_ha->ccb_info + (unsigned long )tag; param = psmpPayload->param; t = ccb->task; ts = & t->task_status; pm8001_dev = ccb->device; if (status != 0U) { { tmp = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:smp IO status 0x%x\n", "mpi_smp_completion", 2915, status); } } else { } } else { } { tmp___0 = ldv__builtin_expect((unsigned long )t == (unsigned long )((struct sas_task *)0), 0L); } if (tmp___0 != 0L) { tmp___2 = 1; } else { { tmp___1 = ldv__builtin_expect((unsigned long )t->lldd_task == (unsigned long )((void *)0), 0L); } if (tmp___1 != 0L) { tmp___2 = 1; } else { tmp___2 = 0; } } if (tmp___2 != 0) { return; } else { { tmp___3 = ldv__builtin_expect((unsigned long )t->dev == (unsigned long )((struct domain_device *)0), 0L); } if (tmp___3 != 0L) { return; } else { } } { if (status == 0U) { goto case_0; } else { } if (status == 1U) { goto case_1; } else { } if (status == 2U) { goto case_2; } else { } if (status == 7U) { goto case_7; } else { } if (status == 13U) { goto case_13; } else { } if (status == 14U) { goto case_14; } else { } if (status == 15U) { goto case_15; } else { } if (status == 16U) { goto case_16; } else { } if (status == 17U) { goto case_17; } else { } if (status == 18U) { goto case_18; } else { } if (status == 19U) { goto case_19; } else { } if (status == 20U) { goto case_20; } else { } if (status == 21U) { goto case_21; } else { } if (status == 23U) { goto case_23; } else { } if (status == 28U) { goto case_28; } else { } if (status == 36U) { goto case_36; } else { } if (status == 55U) { goto case_55; } else { } if (status == 56U) { goto case_56; } else { } if (status == 57U) { goto case_57; } else { } if (status == 58U) { goto case_58; } else { } if (status == 63U) { goto case_63; } else { } goto switch_default; case_0: /* CIL Label */ { tmp___4 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___4 != 0L) { { printk("\016pm80xx %s %d:IO_SUCCESS\n", "mpi_smp_completion", 2921); } } else { } ts->resp = 0; ts->stat = 0; if ((unsigned long )pm8001_dev != (unsigned long )((struct pm8001_device *)0)) { pm8001_dev->running_req = pm8001_dev->running_req - 1U; } else { } goto ldv_46965; case_1: /* CIL Label */ { tmp___5 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___5 != 0L) { { printk("\016pm80xx %s %d:IO_ABORTED IOMB\n", "mpi_smp_completion", 2929); } } else { } ts->resp = 0; ts->stat = 141; if ((unsigned long )pm8001_dev != (unsigned long )((struct pm8001_device *)0)) { pm8001_dev->running_req = pm8001_dev->running_req - 1U; } else { } goto ldv_46965; case_2: /* CIL Label */ { tmp___6 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___6 != 0L) { { printk("\016pm80xx %s %d:IO_UNDERFLOW\n", "mpi_smp_completion", 2936); } } else { } ts->resp = 0; ts->stat = 130; ts->residual = 0U; if ((unsigned long )pm8001_dev != (unsigned long )((struct pm8001_device *)0)) { pm8001_dev->running_req = pm8001_dev->running_req - 1U; } else { } goto ldv_46965; case_7: /* CIL Label */ { tmp___7 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___7 != 0L) { { printk("\016pm80xx %s %d:IO_NO_DEVICE\n", "mpi_smp_completion", 2944); } } else { } ts->resp = 0; ts->stat = 138; goto ldv_46965; case_13: /* CIL Label */ { tmp___8 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___8 != 0L) { { printk("\016pm80xx %s %d:IO_ERROR_HW_TIMEOUT\n", "mpi_smp_completion", 2950); } } else { } ts->resp = 0; ts->stat = 8; goto ldv_46965; case_14: /* CIL Label */ { tmp___9 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___9 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_BREAK\n", "mpi_smp_completion", 2956); } } else { } ts->resp = 0; ts->stat = 8; goto ldv_46965; case_15: /* CIL Label */ { tmp___10 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___10 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_PHY_NOT_READY\n", "mpi_smp_completion", 2962); } } else { } ts->resp = 0; ts->stat = 8; goto ldv_46965; case_16: /* CIL Label */ { tmp___11 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___11 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED\n", "mpi_smp_completion", 2968); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 0; goto ldv_46965; case_17: /* CIL Label */ { tmp___12 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___12 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_ZONE_VIOLATION\n", "mpi_smp_completion", 2975); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 0; goto ldv_46965; case_18: /* CIL Label */ { tmp___13 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___13 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_BREAK\n", "mpi_smp_completion", 2982); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 12; goto ldv_46965; case_19: /* CIL Label */ { tmp___14 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___14 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS\n", "mpi_smp_completion", 2989); } } else { } { ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 0; pm8001_handle_event(pm8001_ha, (void *)pm8001_dev, 19); } goto ldv_46965; case_20: /* CIL Label */ { tmp___15 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___15 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_BAD_DESTINATION\n", "mpi_smp_completion", 2999); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 1; goto ldv_46965; case_21: /* CIL Label */ { tmp___16 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___16 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED\n", "mpi_smp_completion", 3007); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 2; goto ldv_46965; case_23: /* CIL Label */ { tmp___17 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___17 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_WRONG_DESTINATION\n", "mpi_smp_completion", 3014); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 8; goto ldv_46965; case_28: /* CIL Label */ { tmp___18 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___18 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_RX_FRAME\n", "mpi_smp_completion", 3021); } } else { } ts->resp = 0; ts->stat = 128; goto ldv_46965; case_36: /* CIL Label */ { tmp___19 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___19 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_OPEN_RETRY_TIMEOUT\n", "mpi_smp_completion", 3027); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 18; goto ldv_46965; case_55: /* CIL Label */ { tmp___20 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___20 != 0L) { { printk("\016pm80xx %s %d:IO_ERROR_INTERNAL_SMP_RESOURCE\n", "mpi_smp_completion", 3034); } } else { } ts->resp = 0; ts->stat = 132; goto ldv_46965; case_56: /* CIL Label */ { tmp___21 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___21 != 0L) { { printk("\016pm80xx %s %d:IO_PORT_IN_RESET\n", "mpi_smp_completion", 3040); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 18; goto ldv_46965; case_57: /* CIL Label */ { tmp___22 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___22 != 0L) { { printk("\016pm80xx %s %d:IO_DS_NON_OPERATIONAL\n", "mpi_smp_completion", 3047); } } else { } ts->resp = 0; ts->stat = 128; goto ldv_46965; case_58: /* CIL Label */ { tmp___23 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___23 != 0L) { { printk("\016pm80xx %s %d:IO_DS_IN_RECOVERY\n", "mpi_smp_completion", 3053); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 18; goto ldv_46965; case_63: /* CIL Label */ { tmp___24 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___24 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_HW_RESOURCE_BUSY\n", "mpi_smp_completion", 3060); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 18; goto ldv_46965; switch_default: /* CIL Label */ { tmp___25 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___25 != 0L) { { printk("\016pm80xx %s %d:Unknown status 0x%x\n", "mpi_smp_completion", 3067, status); } } else { } ts->resp = 0; ts->stat = 128; goto ldv_46965; switch_break: /* CIL Label */ ; } ldv_46965: { ldv___ldv_linux_kernel_locking_spinlock_spin_lock_156(& t->task_state_lock); t->task_state_flags = t->task_state_flags & 4294967294U; t->task_state_flags = t->task_state_flags & 4294967279U; t->task_state_flags = t->task_state_flags | 2U; tmp___27 = ldv__builtin_expect((t->task_state_flags & 4U) != 0U, 0L); } if (tmp___27 != 0L) { { ldv_spin_unlock_irqrestore_135(& t->task_state_lock, flags); tmp___26 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___26 != 0L) { { printk("\016pm80xx %s %d:task 0x%p done with io_status 0x%x resp 0x%x stat 0x%x but aborted by upper layer!\n", "mpi_smp_completion", 3082, t, status, (int )ts->resp, (unsigned int )ts->stat); } } else { } { pm8001_ccb_task_free(pm8001_ha, t, ccb, tag); } } else { { ldv_spin_unlock_irqrestore_135(& t->task_state_lock, flags); pm8001_ccb_task_free(pm8001_ha, t, ccb, tag); __asm__ volatile ("mfence": : : "memory"); (*(t->task_done))(t); } } return; } } void pm8001_mpi_set_dev_state_resp(struct pm8001_hba_info *pm8001_ha , void *piomb ) { struct set_dev_state_resp *pPayload ; u32 tag ; struct pm8001_ccb_info *ccb ; struct pm8001_device *pm8001_dev ; u32 status ; u32 device_id ; u8 pds ; u8 nds ; long tmp ; { { pPayload = (struct set_dev_state_resp *)piomb + 4U; tag = pPayload->tag; ccb = pm8001_ha->ccb_info + (unsigned long )tag; pm8001_dev = ccb->device; status = pPayload->status; device_id = pPayload->device_id; pds = (unsigned int )((u8 )pPayload->pds_nds) & 240U; nds = (unsigned int )((u8 )pPayload->pds_nds) & 15U; tmp = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:Set device id = 0x%x state from 0x%x to 0x%x status = 0x%x!\n", "pm8001_mpi_set_dev_state_resp", 3106, device_id, (int )pds, (int )nds, status); } } else { } { complete(pm8001_dev->setds_completion); ccb->task = (struct sas_task *)0; ccb->ccb_tag = 4294967295U; pm8001_tag_free(pm8001_ha, tag); } return; } } void pm8001_mpi_set_nvmd_resp(struct pm8001_hba_info *pm8001_ha , void *piomb ) { struct get_nvm_data_resp *pPayload ; u32 tag ; struct pm8001_ccb_info *ccb ; u32 dlen_status ; long tmp ; long tmp___0 ; { { pPayload = (struct get_nvm_data_resp *)piomb + 4U; tag = pPayload->tag; ccb = pm8001_ha->ccb_info + (unsigned long )tag; dlen_status = pPayload->dlen_status; complete(pm8001_ha->nvmd_completion); tmp = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:Set nvm data complete!\n", "pm8001_mpi_set_nvmd_resp", 3121); } } else { } if ((dlen_status & 65535U) != 0U) { { tmp___0 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___0 != 0L) { { printk("\016pm80xx %s %d:Set nvm data error!\n", "pm8001_mpi_set_nvmd_resp", 3124); } } else { } return; } else { } { ccb->task = (struct sas_task *)0; ccb->ccb_tag = 4294967295U; pm8001_tag_free(pm8001_ha, tag); } return; } } void pm8001_mpi_get_nvmd_resp(struct pm8001_hba_info *pm8001_ha , void *piomb ) { struct fw_control_ex *fw_control_context ; struct get_nvm_data_resp *pPayload ; u32 tag ; struct pm8001_ccb_info *ccb ; u32 dlen_status ; u32 ir_tds_bn_dps_das_nvm ; void *virt_addr ; long tmp ; long tmp___0 ; long tmp___1 ; long tmp___2 ; long tmp___3 ; long tmp___4 ; { { pPayload = (struct get_nvm_data_resp *)piomb + 4U; tag = pPayload->tag; ccb = pm8001_ha->ccb_info + (unsigned long )tag; dlen_status = pPayload->dlen_status; ir_tds_bn_dps_das_nvm = pPayload->ir_tda_bn_dps_das_nvm; virt_addr = pm8001_ha->memoryMap.region[2].virt_ptr; fw_control_context = ccb->fw_control_context; tmp = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:Get nvm data complete!\n", "pm8001_mpi_get_nvmd_resp", 3146); } } else { } if ((dlen_status & 65535U) != 0U) { { tmp___0 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___0 != 0L) { { printk("\016pm80xx %s %d:Get nvm data error!\n", "pm8001_mpi_get_nvmd_resp", 3149); } } else { } { complete(pm8001_ha->nvmd_completion); } return; } else { } if ((int )ir_tds_bn_dps_das_nvm < 0) { { tmp___1 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___1 != 0L) { { printk("\016pm80xx %s %d:Get NVMD success, IR=1\n", "pm8001_mpi_get_nvmd_resp", 3157); } } else { } if ((ir_tds_bn_dps_das_nvm & 15U) == 0U) { if (ir_tds_bn_dps_das_nvm == 2158494208U) { { __memcpy((void *)(& pm8001_ha->sas_addr), (void const *)virt_addr + 4U, 8UL); tmp___2 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___2 != 0L) { { printk("\016pm80xx %s %d:Get SAS address from VPD successfully!\n", "pm8001_mpi_get_nvmd_resp", 3165); } } else { } } else { } } else if (((ir_tds_bn_dps_das_nvm & 15U) == 1U || (ir_tds_bn_dps_das_nvm & 15U) == 4U) || (ir_tds_bn_dps_das_nvm & 15U) == 7U) { } else if ((ir_tds_bn_dps_das_nvm & 15U) - 5U <= 1U) { } else { { tmp___3 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___3 != 0L) { { printk("\016pm80xx %s %d:(IR=1)Wrong Device type 0x%x\n", "pm8001_mpi_get_nvmd_resp", 3178, ir_tds_bn_dps_das_nvm); } } else { } } } else { { tmp___4 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___4 != 0L) { { printk("\016pm80xx %s %d:Get NVMD success, IR=0, dataLen=%d\n", "pm8001_mpi_get_nvmd_resp", 3183, dlen_status >> 24); } } else { } } { __memcpy(fw_control_context->usrAddr, (void const *)pm8001_ha->memoryMap.region[2].virt_ptr, (size_t )fw_control_context->len); kfree((void const *)ccb->fw_control_context); ccb->task = (struct sas_task *)0; ccb->ccb_tag = 4294967295U; pm8001_tag_free(pm8001_ha, tag); complete(pm8001_ha->nvmd_completion); } return; } } int pm8001_mpi_local_phy_ctl(struct pm8001_hba_info *pm8001_ha , void *piomb ) { struct local_phy_ctl_resp *pPayload ; u32 status ; u32 phy_id ; u32 phy_op ; long tmp ; long tmp___0 ; { pPayload = (struct local_phy_ctl_resp *)piomb + 4U; status = pPayload->status; phy_id = pPayload->phyop_phyid & 255U; phy_op = pPayload->phyop_phyid & 65280U; if (status != 0U) { { tmp = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:%x phy execute %x phy op failed!\n", "pm8001_mpi_local_phy_ctl", 3208, phy_id, phy_op); } } else { } } else { { tmp___0 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___0 != 0L) { { printk("\016pm80xx %s %d:%x phy execute %x phy op success!\n", "pm8001_mpi_local_phy_ctl", 3212, phy_id, phy_op); } } else { } } return (0); } } void pm8001_bytes_dmaed(struct pm8001_hba_info *pm8001_ha , int i ) { struct pm8001_phy *phy ; struct asd_sas_phy *sas_phy ; struct sas_ha_struct *sas_ha ; struct sas_phy *sphy ; struct sas_identify_frame *id ; long tmp ; { phy = (struct pm8001_phy *)(& pm8001_ha->phy) + (unsigned long )i; sas_phy = & phy->sas_phy; if ((unsigned int )phy->phy_attached == 0U) { return; } else { } sas_ha = pm8001_ha->sas; if ((unsigned long )sas_phy->phy != (unsigned long )((struct sas_phy *)0)) { sphy = sas_phy->phy; sphy->negotiated_linkrate = sas_phy->linkrate; sphy->minimum_linkrate = phy->minimum_linkrate; sphy->minimum_linkrate_hw = 8; sphy->maximum_linkrate = phy->maximum_linkrate; sphy->maximum_linkrate_hw = phy->maximum_linkrate; } else { } if ((phy->phy_type & 2U) != 0U) { id = (struct sas_identify_frame *)(& phy->frame_rcvd); id->dev_type = (unsigned char )phy->identify.device_type; id->__annonCompField89.initiator_bits = 14U; id->__annonCompField91.target_bits = (u8 )phy->identify.target_port_protocols; } else { } { tmp = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:phy %d byte dmaded.\n", "pm8001_bytes_dmaed", 3254, i); } } else { } { sas_phy->frame_rcvd_size = (int )phy->frame_rcvd_size; (*((pm8001_ha->sas)->notify_port_event))(sas_phy, 0); } return; } } void pm8001_get_lrate_mode(struct pm8001_phy *phy , u8 link_rate ) { struct sas_phy *sas_phy ; { sas_phy = phy->sas_phy.phy; { if ((int )link_rate == 4) { goto case_4; } else { } if ((int )link_rate == 2) { goto case_2; } else { } if ((int )link_rate == 1) { goto case_1; } else { } goto switch_break; case_4: /* CIL Label */ phy->sas_phy.linkrate = 10; (phy->sas_phy.phy)->negotiated_linkrate = 10; goto ldv_47046; case_2: /* CIL Label */ phy->sas_phy.linkrate = 9; (phy->sas_phy.phy)->negotiated_linkrate = 9; goto ldv_47046; case_1: /* CIL Label */ phy->sas_phy.linkrate = 8; (phy->sas_phy.phy)->negotiated_linkrate = 8; goto ldv_47046; switch_break: /* CIL Label */ ; } ldv_47046: sas_phy->negotiated_linkrate = phy->sas_phy.linkrate; sas_phy->maximum_linkrate_hw = 10; sas_phy->minimum_linkrate_hw = 8; sas_phy->maximum_linkrate = 10; sas_phy->minimum_linkrate = 8; return; } } void pm8001_get_attached_sas_addr(struct pm8001_phy *phy , u8 *sas_addr ) { struct pm8001_hba_info *pm8001_ha ; u64 addr ; __u64 tmp ; __u64 tmp___0 ; struct sas_identify_frame *idframe ; { if ((unsigned int )*(phy->sas_phy.frame_rcvd) == 52U && (unsigned int )phy->sas_phy.oob_mode == 1U) { { pm8001_ha = (struct pm8001_hba_info *)(phy->sas_phy.ha)->lldd_ha; tmp = __fswab64(*((__be64 *)(& pm8001_ha->sas_addr))); addr = tmp; addr = addr + (u64 )phy->sas_phy.id; tmp___0 = __fswab64(addr); *((__be64 *)sas_addr) = tmp___0; } } else { { idframe = (struct sas_identify_frame *)phy->sas_phy.frame_rcvd; __memcpy((void *)sas_addr, (void const *)(& idframe->sas_addr), 8UL); } } return; } } static void pm8001_hw_event_ack_req(struct pm8001_hba_info *pm8001_ha , u32 Qnum , u32 SEA , u32 port_id , u32 phyId , u32 param0 , u32 param1 ) { struct hw_event_ack_req payload ; u32 opc ; struct inbound_queue_table *circularQ ; { { opc = 37U; __memset((void *)(& payload), 0, 60UL); circularQ = (struct inbound_queue_table *)(& pm8001_ha->inbnd_q_tbl) + (unsigned long )Qnum; payload.tag = 1U; payload.sea_phyid_portid = (((SEA & 65535U) << 8) | ((phyId << 4) & 255U)) | (port_id & 15U); payload.param0 = param0; payload.param1 = param1; pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, (void *)(& payload), 0U); } return; } } static int pm8001_chip_phy_ctl_req(struct pm8001_hba_info *pm8001_ha , u32 phyId , u32 phy_op ) ; static void hw_event_sas_phy_up(struct pm8001_hba_info *pm8001_ha , void *piomb ) { struct hw_event_resp *pPayload ; u32 lr_evt_status_phyid_portid ; u8 link_rate ; u8 port_id ; u8 phy_id ; u32 npip_portstate ; u8 portstate ; struct pm8001_port *port ; struct sas_ha_struct *sas_ha ; struct pm8001_phy *phy ; unsigned long flags ; u8 deviceType ; long tmp ; long tmp___0 ; long tmp___1 ; long tmp___2 ; long tmp___3 ; long tmp___4 ; unsigned long __ms ; unsigned long tmp___5 ; { { pPayload = (struct hw_event_resp *)piomb + 4U; lr_evt_status_phyid_portid = pPayload->lr_evt_status_phyid_portid; link_rate = (unsigned char )(lr_evt_status_phyid_portid >> 28); port_id = (unsigned int )((unsigned char )lr_evt_status_phyid_portid) & 15U; phy_id = (unsigned char )((lr_evt_status_phyid_portid & 240U) >> 4); npip_portstate = pPayload->npip_portstate; portstate = (unsigned int )((unsigned char )npip_portstate) & 15U; port = (struct pm8001_port *)(& pm8001_ha->port) + (unsigned long )port_id; sas_ha = pm8001_ha->sas; phy = (struct pm8001_phy *)(& pm8001_ha->phy) + (unsigned long )phy_id; deviceType = pPayload->sas_identify.dev_type; port->port_state = portstate; phy->phy_state = 1U; tmp = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:HW_EVENT_SAS_PHY_UP port id = %d, phy id = %d\n", "hw_event_sas_phy_up", 3374, (int )port_id, (int )phy_id); } } else { } { if ((int )deviceType == 0) { goto case_0; } else { } if ((int )deviceType == 1) { goto case_1; } else { } if ((int )deviceType == 2) { goto case_2; } else { } if ((int )deviceType == 3) { goto case_3; } else { } goto switch_default; case_0: /* CIL Label */ { tmp___0 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___0 != 0L) { { printk("\016pm80xx %s %d:device type no device.\n", "hw_event_sas_phy_up", 3379); } } else { } goto ldv_47090; case_1: /* CIL Label */ { tmp___1 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___1 != 0L) { { printk("\016pm80xx %s %d:end device.\n", "hw_event_sas_phy_up", 3382); } } else { } { pm8001_chip_phy_ctl_req(pm8001_ha, (u32 )phy_id, 16U); port->port_attached = 1U; pm8001_get_lrate_mode(phy, (int )link_rate); } goto ldv_47090; case_2: /* CIL Label */ { tmp___2 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___2 != 0L) { { printk("\016pm80xx %s %d:expander device.\n", "hw_event_sas_phy_up", 3390); } } else { } { port->port_attached = 1U; pm8001_get_lrate_mode(phy, (int )link_rate); } goto ldv_47090; case_3: /* CIL Label */ { tmp___3 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___3 != 0L) { { printk("\016pm80xx %s %d:fanout expander device.\n", "hw_event_sas_phy_up", 3396); } } else { } { port->port_attached = 1U; pm8001_get_lrate_mode(phy, (int )link_rate); } goto ldv_47090; switch_default: /* CIL Label */ { tmp___4 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___4 != 0L) { { printk("\016pm80xx %s %d:unknown device type(%x)\n", "hw_event_sas_phy_up", 3402, (int )deviceType); } } else { } goto ldv_47090; switch_break: /* CIL Label */ ; } ldv_47090: phy->phy_type = phy->phy_type | 2U; phy->identify.device_type = (enum sas_device_type )deviceType; phy->phy_attached = 1U; if ((unsigned int )phy->identify.device_type == 1U) { phy->identify.target_port_protocols = 8; } else if ((unsigned int )phy->identify.device_type != 0U) { phy->identify.target_port_protocols = 2; } else { } { phy->sas_phy.oob_mode = 2; (*(sas_ha->notify_phy_event))(& phy->sas_phy, 1); ldv___ldv_linux_kernel_locking_spinlock_spin_lock_159(& phy->sas_phy.frame_rcvd_lock); __memcpy((void *)(& phy->frame_rcvd), (void const *)(& pPayload->sas_identify), 28UL); phy->frame_rcvd_size = 28U; pm8001_get_attached_sas_addr(phy, (u8 *)(& phy->sas_phy.attached_sas_addr)); ldv_spin_unlock_irqrestore_160(& phy->sas_phy.frame_rcvd_lock, flags); } if (pm8001_ha->flags == 2UL) { __ms = 200UL; goto ldv_47097; ldv_47096: { __const_udelay(4295000UL); } ldv_47097: tmp___5 = __ms; __ms = __ms - 1UL; if (tmp___5 != 0UL) { goto ldv_47096; } else { } } else { } { pm8001_bytes_dmaed(pm8001_ha, (int )phy_id); } return; } } static void hw_event_sata_phy_up(struct pm8001_hba_info *pm8001_ha , void *piomb ) { struct hw_event_resp *pPayload ; u32 lr_evt_status_phyid_portid ; u8 link_rate ; u8 port_id ; u8 phy_id ; u32 npip_portstate ; u8 portstate ; struct pm8001_port *port ; struct sas_ha_struct *sas_ha ; struct pm8001_phy *phy ; unsigned long flags ; long tmp ; { { pPayload = (struct hw_event_resp *)piomb + 4U; lr_evt_status_phyid_portid = pPayload->lr_evt_status_phyid_portid; link_rate = (unsigned char )(lr_evt_status_phyid_portid >> 28); port_id = (unsigned int )((unsigned char )lr_evt_status_phyid_portid) & 15U; phy_id = (unsigned char )((lr_evt_status_phyid_portid & 240U) >> 4); npip_portstate = pPayload->npip_portstate; portstate = (unsigned int )((unsigned char )npip_portstate) & 15U; port = (struct pm8001_port *)(& pm8001_ha->port) + (unsigned long )port_id; sas_ha = pm8001_ha->sas; phy = (struct pm8001_phy *)(& pm8001_ha->phy) + (unsigned long )phy_id; tmp = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:HW_EVENT_SATA_PHY_UP port id = %d, phy id = %d\n", "hw_event_sata_phy_up", 3450, (int )port_id, (int )phy_id); } } else { } { port->port_state = portstate; phy->phy_state = 1U; port->port_attached = 1U; pm8001_get_lrate_mode(phy, (int )link_rate); phy->phy_type = phy->phy_type | 1U; phy->phy_attached = 1U; phy->sas_phy.oob_mode = 1; (*(sas_ha->notify_phy_event))(& phy->sas_phy, 1); ldv___ldv_linux_kernel_locking_spinlock_spin_lock_161(& phy->sas_phy.frame_rcvd_lock); __memcpy((void *)(& phy->frame_rcvd), (void const *)(& pPayload->sata_fis) + 0xfffffffffffffffcUL, 20UL); phy->frame_rcvd_size = 20U; phy->identify.target_port_protocols = 1; phy->identify.device_type = 5; pm8001_get_attached_sas_addr(phy, (u8 *)(& phy->sas_phy.attached_sas_addr)); ldv_spin_unlock_irqrestore_160(& phy->sas_phy.frame_rcvd_lock, flags); pm8001_bytes_dmaed(pm8001_ha, (int )phy_id); } return; } } static void hw_event_phy_down(struct pm8001_hba_info *pm8001_ha , void *piomb ) { struct hw_event_resp *pPayload ; u32 lr_evt_status_phyid_portid ; u8 port_id ; u8 phy_id ; u32 npip_portstate ; u8 portstate ; struct pm8001_port *port ; struct pm8001_phy *phy ; long tmp ; long tmp___0 ; long tmp___1 ; long tmp___2 ; long tmp___3 ; long tmp___4 ; long tmp___5 ; { { pPayload = (struct hw_event_resp *)piomb + 4U; lr_evt_status_phyid_portid = pPayload->lr_evt_status_phyid_portid; port_id = (unsigned int )((unsigned char )lr_evt_status_phyid_portid) & 15U; phy_id = (unsigned char )((lr_evt_status_phyid_portid & 240U) >> 4); npip_portstate = pPayload->npip_portstate; portstate = (unsigned int )((unsigned char )npip_portstate) & 15U; port = (struct pm8001_port *)(& pm8001_ha->port) + (unsigned long )port_id; phy = (struct pm8001_phy *)(& pm8001_ha->phy) + (unsigned long )phy_id; port->port_state = portstate; phy->phy_type = 0U; phy->identify.device_type = 0; phy->phy_attached = 0U; __memset((void *)(& phy->dev_sas_addr), 0, 8UL); } { if ((int )portstate == 1) { goto case_1; } else { } if ((int )portstate == 8) { goto case_8; } else { } if ((int )portstate == 4) { goto case_4; } else { } if ((int )portstate == 0) { goto case_0; } else { } if ((int )portstate == 2) { goto case_2; } else { } goto switch_default; case_1: /* CIL Label */ ; goto ldv_47128; case_8: /* CIL Label */ { tmp = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d: PortInvalid portID %d\n", "hw_event_phy_down", 3499, (int )port_id); } } else { } { tmp___0 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___0 != 0L) { { printk("\016pm80xx %s %d: Last phy Down and port invalid\n", "hw_event_phy_down", 3501); } } else { } { port->port_attached = 0U; pm8001_hw_event_ack_req(pm8001_ha, 0U, 7U, (u32 )port_id, (u32 )phy_id, 0U, 0U); } goto ldv_47128; case_4: /* CIL Label */ { tmp___1 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___1 != 0L) { { printk("\016pm80xx %s %d: Port In Reset portID %d\n", "hw_event_phy_down", 3508, (int )port_id); } } else { } goto ldv_47128; case_0: /* CIL Label */ { tmp___2 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___2 != 0L) { { printk("\016pm80xx %s %d: phy Down and PORT_NOT_ESTABLISHED\n", "hw_event_phy_down", 3512); } } else { } port->port_attached = 0U; goto ldv_47128; case_2: /* CIL Label */ { tmp___3 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___3 != 0L) { { printk("\016pm80xx %s %d: phy Down and PORT_LOSTCOMM\n", "hw_event_phy_down", 3517); } } else { } { tmp___4 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___4 != 0L) { { printk("\016pm80xx %s %d: Last phy Down and port invalid\n", "hw_event_phy_down", 3519); } } else { } { port->port_attached = 0U; pm8001_hw_event_ack_req(pm8001_ha, 0U, 7U, (u32 )port_id, (u32 )phy_id, 0U, 0U); } goto ldv_47128; switch_default: /* CIL Label */ { port->port_attached = 0U; tmp___5 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___5 != 0L) { { printk("\016pm80xx %s %d: phy Down and(default) = %x\n", "hw_event_phy_down", 3528, (int )portstate); } } else { } goto ldv_47128; switch_break: /* CIL Label */ ; } ldv_47128: ; return; } } int pm8001_mpi_reg_resp(struct pm8001_hba_info *pm8001_ha , void *piomb ) { u32 status ; u32 device_id ; u32 htag ; struct pm8001_ccb_info *ccb ; struct pm8001_device *pm8001_dev ; struct dev_reg_resp *registerRespPayload ; long tmp ; long tmp___0 ; long tmp___1 ; long tmp___2 ; long tmp___3 ; long tmp___4 ; long tmp___5 ; long tmp___6 ; long tmp___7 ; long tmp___8 ; { { registerRespPayload = (struct dev_reg_resp *)piomb + 4U; htag = registerRespPayload->tag; ccb = pm8001_ha->ccb_info + (unsigned long )htag; pm8001_dev = ccb->device; status = registerRespPayload->status; device_id = registerRespPayload->device_id; tmp = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d: register device is status = %d\n", "pm8001_mpi_reg_resp", 3560, status); } } else { } { if (status == 0U) { goto case_0; } else { } if (status == 1U) { goto case_1; } else { } if (status == 2U) { goto case_2; } else { } if (status == 3U) { goto case_3; } else { } if (status == 4U) { goto case_4; } else { } if (status == 5U) { goto case_5; } else { } if (status == 6U) { goto case_6; } else { } if (status == 7U) { goto case_7; } else { } goto switch_default; case_0: /* CIL Label */ { tmp___0 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___0 != 0L) { { printk("\016pm80xx %s %d:DEVREG_SUCCESS\n", "pm8001_mpi_reg_resp", 3563); } } else { } pm8001_dev->device_id = device_id; goto ldv_47147; case_1: /* CIL Label */ { tmp___1 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___1 != 0L) { { printk("\016pm80xx %s %d:DEVREG_FAILURE_OUT_OF_RESOURCE\n", "pm8001_mpi_reg_resp", 3568); } } else { } goto ldv_47147; case_2: /* CIL Label */ { tmp___2 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___2 != 0L) { { printk("\016pm80xx %s %d:DEVREG_FAILURE_DEVICE_ALREADY_REGISTERED\n", "pm8001_mpi_reg_resp", 3572); } } else { } goto ldv_47147; case_3: /* CIL Label */ { tmp___3 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___3 != 0L) { { printk("\016pm80xx %s %d:DEVREG_FAILURE_INVALID_PHY_ID\n", "pm8001_mpi_reg_resp", 3576); } } else { } goto ldv_47147; case_4: /* CIL Label */ { tmp___4 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___4 != 0L) { { printk("\016pm80xx %s %d:DEVREG_FAILURE_PHY_ID_ALREADY_REGISTERED\n", "pm8001_mpi_reg_resp", 3580); } } else { } goto ldv_47147; case_5: /* CIL Label */ { tmp___5 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___5 != 0L) { { printk("\016pm80xx %s %d:DEVREG_FAILURE_PORT_ID_OUT_OF_RANGE\n", "pm8001_mpi_reg_resp", 3584); } } else { } goto ldv_47147; case_6: /* CIL Label */ { tmp___6 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___6 != 0L) { { printk("\016pm80xx %s %d:DEVREG_FAILURE_PORT_NOT_VALID_STATE\n", "pm8001_mpi_reg_resp", 3588); } } else { } goto ldv_47147; case_7: /* CIL Label */ { tmp___7 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___7 != 0L) { { printk("\016pm80xx %s %d:DEVREG_FAILURE_DEVICE_TYPE_NOT_VALID\n", "pm8001_mpi_reg_resp", 3592); } } else { } goto ldv_47147; switch_default: /* CIL Label */ { tmp___8 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___8 != 0L) { { printk("\016pm80xx %s %d:DEVREG_FAILURE_DEVICE_TYPE_NOT_UNSORPORTED\n", "pm8001_mpi_reg_resp", 3596); } } else { } goto ldv_47147; switch_break: /* CIL Label */ ; } ldv_47147: { complete(pm8001_dev->dcompletion); ccb->task = (struct sas_task *)0; ccb->ccb_tag = 4294967295U; pm8001_tag_free(pm8001_ha, htag); } return (0); } } int pm8001_mpi_dereg_resp(struct pm8001_hba_info *pm8001_ha , void *piomb ) { u32 status ; u32 device_id ; struct dev_reg_resp *registerRespPayload ; long tmp ; { registerRespPayload = (struct dev_reg_resp *)piomb + 4U; status = registerRespPayload->status; device_id = registerRespPayload->device_id; if (status != 0U) { { tmp = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d: deregister device failed ,status = %x, device_id = %x\n", "pm8001_mpi_dereg_resp", 3618, status, device_id); } } else { } } else { } return (0); } } int pm8001_mpi_fw_flash_update_resp(struct pm8001_hba_info *pm8001_ha , void *piomb ) { u32 status ; struct fw_flash_Update_resp *ppayload ; u32 tag ; struct pm8001_ccb_info *ccb ; long tmp ; long tmp___0 ; long tmp___1 ; long tmp___2 ; long tmp___3 ; long tmp___4 ; long tmp___5 ; long tmp___6 ; long tmp___7 ; long tmp___8 ; { ppayload = (struct fw_flash_Update_resp *)piomb + 4U; tag = ppayload->tag; ccb = pm8001_ha->ccb_info + (unsigned long )tag; status = ppayload->status; { if (status == 0U) { goto case_0; } else { } if (status == 1U) { goto case_1; } else { } if (status == 2U) { goto case_2; } else { } if (status == 3U) { goto case_3; } else { } if (status == 4U) { goto case_4; } else { } if (status == 5U) { goto case_5; } else { } if (status == 6U) { goto case_6; } else { } if (status == 16U) { goto case_16; } else { } if (status == 17U) { goto case_17; } else { } goto switch_default; case_0: /* CIL Label */ { tmp = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:: FLASH_UPDATE_COMPLETE_PENDING_REBOOT\n", "pm8001_mpi_fw_flash_update_resp", 3639); } } else { } goto ldv_47174; case_1: /* CIL Label */ { tmp___0 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___0 != 0L) { { printk("\016pm80xx %s %d:: FLASH_UPDATE_IN_PROGRESS\n", "pm8001_mpi_fw_flash_update_resp", 3643); } } else { } goto ldv_47174; case_2: /* CIL Label */ { tmp___1 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___1 != 0L) { { printk("\016pm80xx %s %d:: FLASH_UPDATE_HDR_ERR\n", "pm8001_mpi_fw_flash_update_resp", 3647); } } else { } goto ldv_47174; case_3: /* CIL Label */ { tmp___2 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___2 != 0L) { { printk("\016pm80xx %s %d:: FLASH_UPDATE_OFFSET_ERR\n", "pm8001_mpi_fw_flash_update_resp", 3651); } } else { } goto ldv_47174; case_4: /* CIL Label */ { tmp___3 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___3 != 0L) { { printk("\016pm80xx %s %d:: FLASH_UPDATE_CRC_ERR\n", "pm8001_mpi_fw_flash_update_resp", 3655); } } else { } goto ldv_47174; case_5: /* CIL Label */ { tmp___4 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___4 != 0L) { { printk("\016pm80xx %s %d:: FLASH_UPDATE_LENGTH_ERR\n", "pm8001_mpi_fw_flash_update_resp", 3659); } } else { } goto ldv_47174; case_6: /* CIL Label */ { tmp___5 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___5 != 0L) { { printk("\016pm80xx %s %d:: FLASH_UPDATE_HW_ERR\n", "pm8001_mpi_fw_flash_update_resp", 3663); } } else { } goto ldv_47174; case_16: /* CIL Label */ { tmp___6 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___6 != 0L) { { printk("\016pm80xx %s %d:: FLASH_UPDATE_DNLD_NOT_SUPPORTED\n", "pm8001_mpi_fw_flash_update_resp", 3667); } } else { } goto ldv_47174; case_17: /* CIL Label */ { tmp___7 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___7 != 0L) { { printk("\016pm80xx %s %d:: FLASH_UPDATE_DISABLED\n", "pm8001_mpi_fw_flash_update_resp", 3671); } } else { } goto ldv_47174; switch_default: /* CIL Label */ { tmp___8 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___8 != 0L) { { printk("\016pm80xx %s %d:No matched status = %d\n", "pm8001_mpi_fw_flash_update_resp", 3675, status); } } else { } goto ldv_47174; switch_break: /* CIL Label */ ; } ldv_47174: { kfree((void const *)ccb->fw_control_context); ccb->task = (struct sas_task *)0; ccb->ccb_tag = 4294967295U; pm8001_tag_free(pm8001_ha, tag); complete(pm8001_ha->nvmd_completion); } return (0); } } int pm8001_mpi_general_event(struct pm8001_hba_info *pm8001_ha , void *piomb ) { u32 status ; int i ; struct general_event_resp *pPayload ; long tmp ; long tmp___0 ; { { pPayload = (struct general_event_resp *)piomb + 4U; status = pPayload->status; tmp = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d: status = 0x%x\n", "pm8001_mpi_general_event", 3694, status); } } else { } i = 0; goto ldv_47193; ldv_47192: { tmp___0 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___0 != 0L) { { printk("\016pm80xx %s %d:inb_IOMB_payload[0x%x] 0x%x,\n", "pm8001_mpi_general_event", 3698, i, pPayload->inb_IOMB_payload[i]); } } else { } i = i + 1; ldv_47193: ; if (i <= 13) { goto ldv_47192; } else { } return (0); } } int pm8001_mpi_task_abort_resp(struct pm8001_hba_info *pm8001_ha , void *piomb ) { struct sas_task *t ; struct pm8001_ccb_info *ccb ; unsigned long flags ; u32 status ; u32 tag ; u32 scp ; struct task_status_struct *ts ; struct pm8001_device *pm8001_dev ; struct task_abort_resp *pPayload ; long tmp ; long tmp___0 ; long tmp___1 ; long tmp___2 ; long tmp___3 ; { pPayload = (struct task_abort_resp *)piomb + 4U; status = pPayload->status; tag = pPayload->tag; if (tag == 0U) { { tmp = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d: TAG NULL. RETURNING !!!", "pm8001_mpi_task_abort_resp", 3719); } } else { } return (-1); } else { } scp = pPayload->scp; ccb = pm8001_ha->ccb_info + (unsigned long )tag; t = ccb->task; pm8001_dev = ccb->device; if ((unsigned long )t == (unsigned long )((struct sas_task *)0)) { { tmp___0 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___0 != 0L) { { printk("\016pm80xx %s %d: TASK NULL. RETURNING !!!", "pm8001_mpi_task_abort_resp", 3730); } } else { } return (-1); } else { } ts = & t->task_status; if (status != 0U) { { tmp___1 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___1 != 0L) { { printk("\016pm80xx %s %d:task abort failed status 0x%x ,tag = 0x%x, scp= 0x%x\n", "pm8001_mpi_task_abort_resp", 3737, status, tag, scp); } } else { } } else { } { if (status == 0U) { goto case_0; } else { } if (status == 6U) { goto case_6; } else { } goto switch_break; case_0: /* CIL Label */ { tmp___2 = ldv__builtin_expect((pm8001_ha->logging_level & 16U) != 0U, 0L); } if (tmp___2 != 0L) { { printk("\016pm80xx %s %d:IO_SUCCESS\n", "pm8001_mpi_task_abort_resp", 3740); } } else { } ts->resp = 0; ts->stat = 0; goto ldv_47210; case_6: /* CIL Label */ { tmp___3 = ldv__builtin_expect((pm8001_ha->logging_level & 16U) != 0U, 0L); } if (tmp___3 != 0L) { { printk("\016pm80xx %s %d:IO_NOT_VALID\n", "pm8001_mpi_task_abort_resp", 3745); } } else { } ts->resp = 5; goto ldv_47210; switch_break: /* CIL Label */ ; } ldv_47210: { ldv___ldv_linux_kernel_locking_spinlock_spin_lock_163(& t->task_state_lock); t->task_state_flags = t->task_state_flags & 4294967294U; t->task_state_flags = t->task_state_flags & 4294967279U; t->task_state_flags = t->task_state_flags | 2U; ldv_spin_unlock_irqrestore_135(& t->task_state_lock, flags); pm8001_ccb_task_free(pm8001_ha, t, ccb, tag); __asm__ volatile ("mfence": : : "memory"); } if ((pm8001_dev->id & 1073741824U) != 0U) { { pm8001_tag_free(pm8001_ha, tag); sas_free_task(t); pm8001_dev->id = pm8001_dev->id & 3221225471U; } } else { { (*(t->task_done))(t); } } return (0); } } static int mpi_hw_event(struct pm8001_hba_info *pm8001_ha , void *piomb ) { unsigned long flags ; struct hw_event_resp *pPayload ; u32 lr_evt_status_phyid_portid ; u8 port_id ; u8 phy_id ; u16 eventType ; u8 status ; struct sas_ha_struct *sas_ha ; struct pm8001_phy *phy ; struct asd_sas_phy *sas_phy ; long tmp ; long tmp___0 ; long tmp___1 ; long tmp___2 ; long tmp___3 ; long tmp___4 ; long tmp___5 ; long tmp___6 ; long tmp___7 ; long tmp___8 ; long tmp___9 ; long tmp___10 ; long tmp___11 ; long tmp___12 ; long tmp___13 ; long tmp___14 ; long tmp___15 ; long tmp___16 ; long tmp___17 ; long tmp___18 ; long tmp___19 ; long tmp___20 ; long tmp___21 ; long tmp___22 ; long tmp___23 ; long tmp___24 ; long tmp___25 ; { { pPayload = (struct hw_event_resp *)piomb + 4U; lr_evt_status_phyid_portid = pPayload->lr_evt_status_phyid_portid; port_id = (unsigned int )((unsigned char )lr_evt_status_phyid_portid) & 15U; phy_id = (unsigned char )((lr_evt_status_phyid_portid & 240U) >> 4); eventType = (unsigned short )((lr_evt_status_phyid_portid & 16776960U) >> 8); status = (unsigned char )((lr_evt_status_phyid_portid & 251658240U) >> 24); sas_ha = pm8001_ha->sas; phy = (struct pm8001_phy *)(& pm8001_ha->phy) + (unsigned long )phy_id; sas_phy = *(sas_ha->sas_phy + (unsigned long )phy_id); tmp = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:outbound queue HW event & event type : ", "mpi_hw_event", 3791); } } else { } { if ((int )eventType == 17) { goto case_17; } else { } if ((int )eventType == 4) { goto case_4; } else { } if ((int )eventType == 5) { goto case_5; } else { } if ((int )eventType == 3) { goto case_3; } else { } if ((int )eventType == 6) { goto case_6; } else { } if ((int )eventType == 7) { goto case_7; } else { } if ((int )eventType == 8) { goto case_8; } else { } if ((int )eventType == 9) { goto case_9; } else { } if ((int )eventType == 10) { goto case_10; } else { } if ((int )eventType == 16) { goto case_16; } else { } if ((int )eventType == 18) { goto case_18; } else { } if ((int )eventType == 19) { goto case_19; } else { } if ((int )eventType == 20) { goto case_20; } else { } if ((int )eventType == 21) { goto case_21; } else { } if ((int )eventType == 14) { goto case_14; } else { } if ((int )eventType == 11) { goto case_11; } else { } if ((int )eventType == 12) { goto case_12; } else { } if ((int )eventType == 13) { goto case_13; } else { } if ((int )eventType == 15) { goto case_15; } else { } if ((int )eventType == 22) { goto case_22; } else { } if ((int )eventType == 25) { goto case_25; } else { } if ((int )eventType == 23) { goto case_23; } else { } if ((int )eventType == 24) { goto case_24; } else { } if ((int )eventType == 32) { goto case_32; } else { } if ((int )eventType == 33) { goto case_33; } else { } goto switch_default; case_17: /* CIL Label */ { tmp___0 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___0 != 0L) { { printk("\016pm80xx %s %d:HW_EVENT_PHY_START_STATUS status = %x\n", "mpi_hw_event", 3796, (int )status); } } else { } if ((unsigned int )status == 0U) { phy->phy_state = 1U; if (pm8001_ha->flags == 2UL) { { complete(phy->enable_completion); } } else { } } else { } goto ldv_47228; case_4: /* CIL Label */ { tmp___1 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___1 != 0L) { { printk("\016pm80xx %s %d:HW_EVENT_PHY_START_STATUS\n", "mpi_hw_event", 3805); } } else { } { hw_event_sas_phy_up(pm8001_ha, piomb); } goto ldv_47228; case_5: /* CIL Label */ { tmp___2 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___2 != 0L) { { printk("\016pm80xx %s %d:HW_EVENT_SATA_PHY_UP\n", "mpi_hw_event", 3810); } } else { } { hw_event_sata_phy_up(pm8001_ha, piomb); } goto ldv_47228; case_3: /* CIL Label */ { tmp___3 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___3 != 0L) { { printk("\016pm80xx %s %d:HW_EVENT_PHY_STOP_STATUS status = %x\n", "mpi_hw_event", 3816, (int )status); } } else { } if ((unsigned int )status == 0U) { phy->phy_state = 0U; } else { } goto ldv_47228; case_6: /* CIL Label */ { tmp___4 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___4 != 0L) { { printk("\016pm80xx %s %d:HW_EVENT_SATA_SPINUP_HOLD\n", "mpi_hw_event", 3822); } } else { } { (*(sas_ha->notify_phy_event))(& phy->sas_phy, 3); } goto ldv_47228; case_7: /* CIL Label */ { tmp___5 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___5 != 0L) { { printk("\016pm80xx %s %d:HW_EVENT_PHY_DOWN\n", "mpi_hw_event", 3827); } } else { } { (*(sas_ha->notify_phy_event))(& phy->sas_phy, 0); phy->phy_attached = 0U; phy->phy_state = 0U; hw_event_phy_down(pm8001_ha, piomb); } goto ldv_47228; case_8: /* CIL Label */ { tmp___6 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___6 != 0L) { { printk("\016pm80xx %s %d:HW_EVENT_PORT_INVALID\n", "mpi_hw_event", 3835); } } else { } { sas_phy_disconnected(sas_phy); phy->phy_attached = 0U; (*(sas_ha->notify_port_event))(sas_phy, 2); } goto ldv_47228; case_9: /* CIL Label */ { tmp___7 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___7 != 0L) { { printk("\016pm80xx %s %d:HW_EVENT_BROADCAST_CHANGE\n", "mpi_hw_event", 3844); } } else { } { pm8001_hw_event_ack_req(pm8001_ha, 0U, 9U, (u32 )port_id, (u32 )phy_id, 1U, 0U); ldv___ldv_linux_kernel_locking_spinlock_spin_lock_165(& sas_phy->sas_prim_lock); sas_phy->sas_prim = 9U; ldv_spin_unlock_irqrestore_166(& sas_phy->sas_prim_lock, flags); (*(sas_ha->notify_port_event))(sas_phy, 1); } goto ldv_47228; case_10: /* CIL Label */ { tmp___8 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___8 != 0L) { { printk("\016pm80xx %s %d:HW_EVENT_PHY_ERROR\n", "mpi_hw_event", 3854); } } else { } { sas_phy_disconnected(& phy->sas_phy); phy->phy_attached = 0U; (*(sas_ha->notify_phy_event))(& phy->sas_phy, 2); } goto ldv_47228; case_16: /* CIL Label */ { tmp___9 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___9 != 0L) { { printk("\016pm80xx %s %d:HW_EVENT_BROADCAST_EXP\n", "mpi_hw_event", 3861); } } else { } { ldv___ldv_linux_kernel_locking_spinlock_spin_lock_167(& sas_phy->sas_prim_lock); sas_phy->sas_prim = 16U; ldv_spin_unlock_irqrestore_166(& sas_phy->sas_prim_lock, flags); (*(sas_ha->notify_port_event))(sas_phy, 1); } goto ldv_47228; case_18: /* CIL Label */ { tmp___10 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___10 != 0L) { { printk("\016pm80xx %s %d:HW_EVENT_LINK_ERR_INVALID_DWORD\n", "mpi_hw_event", 3869); } } else { } { pm8001_hw_event_ack_req(pm8001_ha, 0U, 18U, (u32 )port_id, (u32 )phy_id, 0U, 0U); sas_phy_disconnected(sas_phy); phy->phy_attached = 0U; (*(sas_ha->notify_port_event))(sas_phy, 2); } goto ldv_47228; case_19: /* CIL Label */ { tmp___11 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___11 != 0L) { { printk("\016pm80xx %s %d:HW_EVENT_LINK_ERR_DISPARITY_ERROR\n", "mpi_hw_event", 3878); } } else { } { pm8001_hw_event_ack_req(pm8001_ha, 0U, 19U, (u32 )port_id, (u32 )phy_id, 0U, 0U); sas_phy_disconnected(sas_phy); phy->phy_attached = 0U; (*(sas_ha->notify_port_event))(sas_phy, 2); } goto ldv_47228; case_20: /* CIL Label */ { tmp___12 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___12 != 0L) { { printk("\016pm80xx %s %d:HW_EVENT_LINK_ERR_CODE_VIOLATION\n", "mpi_hw_event", 3888); } } else { } { pm8001_hw_event_ack_req(pm8001_ha, 0U, 20U, (u32 )port_id, (u32 )phy_id, 0U, 0U); sas_phy_disconnected(sas_phy); phy->phy_attached = 0U; (*(sas_ha->notify_port_event))(sas_phy, 2); } goto ldv_47228; case_21: /* CIL Label */ { tmp___13 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___13 != 0L) { { printk("\016pm80xx %s %d:HW_EVENT_LINK_ERR_LOSS_OF_DWORD_SYNCH\n", "mpi_hw_event", 3898); } } else { } { pm8001_hw_event_ack_req(pm8001_ha, 0U, 21U, (u32 )port_id, (u32 )phy_id, 0U, 0U); sas_phy_disconnected(sas_phy); phy->phy_attached = 0U; (*(sas_ha->notify_port_event))(sas_phy, 2); } goto ldv_47228; case_14: /* CIL Label */ { tmp___14 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___14 != 0L) { { printk("\016pm80xx %s %d:HW_EVENT_MALFUNCTION\n", "mpi_hw_event", 3908); } } else { } goto ldv_47228; case_11: /* CIL Label */ { tmp___15 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___15 != 0L) { { printk("\016pm80xx %s %d:HW_EVENT_BROADCAST_SES\n", "mpi_hw_event", 3912); } } else { } { ldv___ldv_linux_kernel_locking_spinlock_spin_lock_169(& sas_phy->sas_prim_lock); sas_phy->sas_prim = 11U; ldv_spin_unlock_irqrestore_166(& sas_phy->sas_prim_lock, flags); (*(sas_ha->notify_port_event))(sas_phy, 1); } goto ldv_47228; case_12: /* CIL Label */ { tmp___16 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___16 != 0L) { { printk("\016pm80xx %s %d:HW_EVENT_INBOUND_CRC_ERROR\n", "mpi_hw_event", 3920); } } else { } { pm8001_hw_event_ack_req(pm8001_ha, 0U, 12U, (u32 )port_id, (u32 )phy_id, 0U, 0U); } goto ldv_47228; case_13: /* CIL Label */ { tmp___17 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___17 != 0L) { { printk("\016pm80xx %s %d:HW_EVENT_HARD_RESET_RECEIVED\n", "mpi_hw_event", 3927); } } else { } { (*(sas_ha->notify_port_event))(sas_phy, 4); } goto ldv_47228; case_15: /* CIL Label */ { tmp___18 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___18 != 0L) { { printk("\016pm80xx %s %d:HW_EVENT_ID_FRAME_TIMEOUT\n", "mpi_hw_event", 3932); } } else { } { sas_phy_disconnected(sas_phy); phy->phy_attached = 0U; (*(sas_ha->notify_port_event))(sas_phy, 2); } goto ldv_47228; case_22: /* CIL Label */ { tmp___19 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___19 != 0L) { { printk("\016pm80xx %s %d:HW_EVENT_LINK_ERR_PHY_RESET_FAILED\n", "mpi_hw_event", 3939); } } else { } { pm8001_hw_event_ack_req(pm8001_ha, 0U, 22U, (u32 )port_id, (u32 )phy_id, 0U, 0U); sas_phy_disconnected(sas_phy); phy->phy_attached = 0U; (*(sas_ha->notify_port_event))(sas_phy, 2); } goto ldv_47228; case_25: /* CIL Label */ { tmp___20 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___20 != 0L) { { printk("\016pm80xx %s %d:HW_EVENT_PORT_RESET_TIMER_TMO\n", "mpi_hw_event", 3949); } } else { } { sas_phy_disconnected(sas_phy); phy->phy_attached = 0U; (*(sas_ha->notify_port_event))(sas_phy, 2); } goto ldv_47228; case_23: /* CIL Label */ { tmp___21 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___21 != 0L) { { printk("\016pm80xx %s %d:HW_EVENT_PORT_RECOVERY_TIMER_TMO\n", "mpi_hw_event", 3956); } } else { } { sas_phy_disconnected(sas_phy); phy->phy_attached = 0U; (*(sas_ha->notify_port_event))(sas_phy, 2); } goto ldv_47228; case_24: /* CIL Label */ { tmp___22 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___22 != 0L) { { printk("\016pm80xx %s %d:HW_EVENT_PORT_RECOVER\n", "mpi_hw_event", 3963); } } else { } goto ldv_47228; case_32: /* CIL Label */ { tmp___23 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___23 != 0L) { { printk("\016pm80xx %s %d:HW_EVENT_PORT_RESET_COMPLETE\n", "mpi_hw_event", 3967); } } else { } goto ldv_47228; case_33: /* CIL Label */ { tmp___24 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___24 != 0L) { { printk("\016pm80xx %s %d:EVENT_BROADCAST_ASYNCH_EVENT\n", "mpi_hw_event", 3971); } } else { } goto ldv_47228; switch_default: /* CIL Label */ { tmp___25 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___25 != 0L) { { printk("\016pm80xx %s %d:Unknown event type = %x\n", "mpi_hw_event", 3975, (int )eventType); } } else { } goto ldv_47228; switch_break: /* CIL Label */ ; } ldv_47228: ; return (0); } } static void process_one_iomb(struct pm8001_hba_info *pm8001_ha , void *piomb ) { __le32 pHeader ; u8 opc ; long tmp ; long tmp___0 ; long tmp___1 ; long tmp___2 ; long tmp___3 ; long tmp___4 ; long tmp___5 ; long tmp___6 ; long tmp___7 ; long tmp___8 ; long tmp___9 ; long tmp___10 ; long tmp___11 ; long tmp___12 ; long tmp___13 ; long tmp___14 ; long tmp___15 ; long tmp___16 ; long tmp___17 ; long tmp___18 ; long tmp___19 ; long tmp___20 ; long tmp___21 ; long tmp___22 ; long tmp___23 ; long tmp___24 ; long tmp___25 ; long tmp___26 ; long tmp___27 ; long tmp___28 ; long tmp___29 ; long tmp___30 ; long tmp___31 ; long tmp___32 ; long tmp___33 ; { { pHeader = *((__le32 *)piomb); opc = (unsigned char )pHeader; tmp = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:process_one_iomb:", "process_one_iomb", 3991); } } else { } { if ((int )opc == 1) { goto case_1; } else { } if ((int )opc == 4) { goto case_4; } else { } if ((int )opc == 5) { goto case_5; } else { } if ((int )opc == 6) { goto case_6; } else { } if ((int )opc == 7) { goto case_7; } else { } if ((int )opc == 10) { goto case_10; } else { } if ((int )opc == 11) { goto case_11; } else { } if ((int )opc == 12) { goto case_12; } else { } if ((int )opc == 13) { goto case_13; } else { } if ((int )opc == 14) { goto case_14; } else { } if ((int )opc == 15) { goto case_15; } else { } if ((int )opc == 16) { goto case_16; } else { } if ((int )opc == 18) { goto case_18; } else { } if ((int )opc == 19) { goto case_19; } else { } if ((int )opc == 20) { goto case_20; } else { } if ((int )opc == 22) { goto case_22; } else { } if ((int )opc == 23) { goto case_23; } else { } if ((int )opc == 24) { goto case_24; } else { } if ((int )opc == 26) { goto case_26; } else { } if ((int )opc == 27) { goto case_27; } else { } if ((int )opc == 28) { goto case_28; } else { } if ((int )opc == 29) { goto case_29; } else { } if ((int )opc == 30) { goto case_30; } else { } if ((int )opc == 31) { goto case_31; } else { } if ((int )opc == 32) { goto case_32; } else { } if ((int )opc == 34) { goto case_34; } else { } if ((int )opc == 35) { goto case_35; } else { } if ((int )opc == 36) { goto case_36; } else { } if ((int )opc == 37) { goto case_37; } else { } if ((int )opc == 38) { goto case_38; } else { } if ((int )opc == 39) { goto case_39; } else { } if ((int )opc == 40) { goto case_40; } else { } if ((int )opc == 41) { goto case_41; } else { } goto switch_default; case_1: /* CIL Label */ { tmp___0 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___0 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_ECHO\n", "process_one_iomb", 3995); } } else { } goto ldv_47262; case_4: /* CIL Label */ { tmp___1 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___1 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_HW_EVENT\n", "process_one_iomb", 3999); } } else { } { mpi_hw_event(pm8001_ha, piomb); } goto ldv_47262; case_5: /* CIL Label */ { tmp___2 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___2 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_SSP_COMP\n", "process_one_iomb", 4004); } } else { } { mpi_ssp_completion(pm8001_ha, piomb); } goto ldv_47262; case_6: /* CIL Label */ { tmp___3 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___3 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_SMP_COMP\n", "process_one_iomb", 4009); } } else { } { mpi_smp_completion(pm8001_ha, piomb); } goto ldv_47262; case_7: /* CIL Label */ { tmp___4 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___4 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_LOCAL_PHY_CNTRL\n", "process_one_iomb", 4014); } } else { } { pm8001_mpi_local_phy_ctl(pm8001_ha, piomb); } goto ldv_47262; case_10: /* CIL Label */ { tmp___5 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___5 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_DEV_REGIST\n", "process_one_iomb", 4019); } } else { } { pm8001_mpi_reg_resp(pm8001_ha, piomb); } goto ldv_47262; case_11: /* CIL Label */ { tmp___6 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___6 != 0L) { { printk("\016pm80xx %s %d:unregister the device\n", "process_one_iomb", 4024); } } else { } { pm8001_mpi_dereg_resp(pm8001_ha, piomb); } goto ldv_47262; case_12: /* CIL Label */ { tmp___7 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___7 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_GET_DEV_HANDLE\n", "process_one_iomb", 4029); } } else { } goto ldv_47262; case_13: /* CIL Label */ { tmp___8 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___8 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_SATA_COMP\n", "process_one_iomb", 4033); } } else { } { mpi_sata_completion(pm8001_ha, piomb); } goto ldv_47262; case_14: /* CIL Label */ { tmp___9 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___9 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_SATA_EVENT\n", "process_one_iomb", 4038); } } else { } { mpi_sata_event(pm8001_ha, piomb); } goto ldv_47262; case_15: /* CIL Label */ { tmp___10 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___10 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_SSP_EVENT\n", "process_one_iomb", 4043); } } else { } { mpi_ssp_event(pm8001_ha, piomb); } goto ldv_47262; case_16: /* CIL Label */ { tmp___11 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___11 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_DEV_HANDLE_ARRIV\n", "process_one_iomb", 4048); } } else { } goto ldv_47262; case_18: /* CIL Label */ { tmp___12 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___12 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_SSP_RECV_EVENT\n", "process_one_iomb", 4053); } } else { } goto ldv_47262; case_19: /* CIL Label */ { tmp___13 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___13 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_DEV_INFO\n", "process_one_iomb", 4058); } } else { } goto ldv_47262; case_20: /* CIL Label */ { tmp___14 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___14 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_FW_FLASH_UPDATE\n", "process_one_iomb", 4062); } } else { } { pm8001_mpi_fw_flash_update_resp(pm8001_ha, piomb); } goto ldv_47262; case_22: /* CIL Label */ { tmp___15 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___15 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_GPIO_RESPONSE\n", "process_one_iomb", 4067); } } else { } goto ldv_47262; case_23: /* CIL Label */ { tmp___16 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___16 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_GPIO_EVENT\n", "process_one_iomb", 4071); } } else { } goto ldv_47262; case_24: /* CIL Label */ { tmp___17 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___17 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_GENERAL_EVENT\n", "process_one_iomb", 4075); } } else { } { pm8001_mpi_general_event(pm8001_ha, piomb); } goto ldv_47262; case_26: /* CIL Label */ { tmp___18 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___18 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_SSP_ABORT_RSP\n", "process_one_iomb", 4080); } } else { } { pm8001_mpi_task_abort_resp(pm8001_ha, piomb); } goto ldv_47262; case_27: /* CIL Label */ { tmp___19 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___19 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_SATA_ABORT_RSP\n", "process_one_iomb", 4085); } } else { } { pm8001_mpi_task_abort_resp(pm8001_ha, piomb); } goto ldv_47262; case_28: /* CIL Label */ { tmp___20 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___20 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_SAS_DIAG_MODE_START_END\n", "process_one_iomb", 4090); } } else { } goto ldv_47262; case_29: /* CIL Label */ { tmp___21 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___21 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_SAS_DIAG_EXECUTE\n", "process_one_iomb", 4094); } } else { } goto ldv_47262; case_30: /* CIL Label */ { tmp___22 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___22 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_GET_TIME_STAMP\n", "process_one_iomb", 4098); } } else { } goto ldv_47262; case_31: /* CIL Label */ { tmp___23 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___23 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_SAS_HW_EVENT_ACK\n", "process_one_iomb", 4102); } } else { } goto ldv_47262; case_32: /* CIL Label */ { tmp___24 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___24 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_PORT_CONTROL\n", "process_one_iomb", 4106); } } else { } goto ldv_47262; case_34: /* CIL Label */ { tmp___25 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___25 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_SMP_ABORT_RSP\n", "process_one_iomb", 4110); } } else { } { pm8001_mpi_task_abort_resp(pm8001_ha, piomb); } goto ldv_47262; case_35: /* CIL Label */ { tmp___26 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___26 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_GET_NVMD_DATA\n", "process_one_iomb", 4115); } } else { } { pm8001_mpi_get_nvmd_resp(pm8001_ha, piomb); } goto ldv_47262; case_36: /* CIL Label */ { tmp___27 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___27 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_SET_NVMD_DATA\n", "process_one_iomb", 4120); } } else { } { pm8001_mpi_set_nvmd_resp(pm8001_ha, piomb); } goto ldv_47262; case_37: /* CIL Label */ { tmp___28 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___28 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_DEVICE_HANDLE_REMOVAL\n", "process_one_iomb", 4125); } } else { } goto ldv_47262; case_38: /* CIL Label */ { tmp___29 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___29 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_SET_DEVICE_STATE\n", "process_one_iomb", 4129); } } else { } { pm8001_mpi_set_dev_state_resp(pm8001_ha, piomb); } goto ldv_47262; case_39: /* CIL Label */ { tmp___30 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___30 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_GET_DEVICE_STATE\n", "process_one_iomb", 4134); } } else { } goto ldv_47262; case_40: /* CIL Label */ { tmp___31 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___31 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_SET_DEV_INFO\n", "process_one_iomb", 4138); } } else { } goto ldv_47262; case_41: /* CIL Label */ { tmp___32 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___32 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_SAS_RE_INITIALIZE\n", "process_one_iomb", 4142); } } else { } goto ldv_47262; switch_default: /* CIL Label */ { tmp___33 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___33 != 0L) { { printk("\016pm80xx %s %d:Unknown outbound Queue IOMB OPC = %x\n", "process_one_iomb", 4147, (int )opc); } } else { } goto ldv_47262; switch_break: /* CIL Label */ ; } ldv_47262: ; return; } } static int process_oq(struct pm8001_hba_info *pm8001_ha , u8 vec ) { struct outbound_queue_table *circularQ ; void *pMsg1 ; u8 bc ; u32 ret ; unsigned long flags ; { { pMsg1 = (void *)0; bc = bc; ret = 2U; ldv___ldv_linux_kernel_locking_spinlock_spin_lock_171(& pm8001_ha->lock); circularQ = (struct outbound_queue_table *)(& pm8001_ha->outbnd_q_tbl) + (unsigned long )vec; } ldv_47306: { ret = pm8001_mpi_msg_consume(pm8001_ha, circularQ, & pMsg1, & bc); } if (ret == 0U) { { process_one_iomb(pm8001_ha, pMsg1 + 0xfffffffffffffffcUL); pm8001_mpi_msg_free_set(pm8001_ha, pMsg1, circularQ, (int )bc); } } else { } if (ret == 1U) { { circularQ->producer_index = pm8001_read_32(circularQ->pi_virt); } if (circularQ->producer_index == circularQ->consumer_idx) { goto ldv_47305; } else { } } else { } goto ldv_47306; ldv_47305: { ldv_spin_unlock_irqrestore_109(& pm8001_ha->lock, flags); } return ((int )ret); } } static u8 const data_dir_flags[4U] = { 4U, 2U, 1U, 0U}; void pm8001_chip_make_sg(struct scatterlist *scatter , int nr , void *prd ) { int i ; struct scatterlist *sg ; struct pm8001_prd *buf_prd ; { buf_prd = (struct pm8001_prd *)prd; i = 0; sg = scatter; goto ldv_47317; ldv_47316: { buf_prd->addr = sg->dma_address; buf_prd->im_len.len = sg->dma_length; buf_prd->im_len.e = 0U; buf_prd = buf_prd + 1; i = i + 1; sg = sg_next(sg); } ldv_47317: ; if (i < nr) { goto ldv_47316; } else { } return; } } static void build_smp_cmd(u32 deviceID , __le32 hTag , struct smp_req *psmp_cmd ) { { psmp_cmd->tag = hTag; psmp_cmd->device_id = deviceID; psmp_cmd->len_ip_ir = 3U; return; } } static int pm8001_chip_smp_req(struct pm8001_hba_info *pm8001_ha , struct pm8001_ccb_info *ccb ) { int elem ; int rc ; struct sas_task *task ; struct domain_device *dev ; struct pm8001_device *pm8001_dev ; struct scatterlist *sg_req ; struct scatterlist *sg_resp ; u32 req_len ; u32 resp_len ; struct smp_req smp_cmd ; u32 opc ; struct inbound_queue_table *circularQ ; { { task = ccb->task; dev = task->dev; pm8001_dev = (struct pm8001_device *)dev->lldd_dev; __memset((void *)(& smp_cmd), 0, 60UL); sg_req = & task->__annonCompField95.smp_task.smp_req; elem = dma_map_sg_attrs___0(pm8001_ha->dev, sg_req, 1, 1, (struct dma_attrs *)0); } if (elem == 0) { return (-12); } else { } { req_len = sg_req->dma_length; sg_resp = & task->__annonCompField95.smp_task.smp_resp; elem = dma_map_sg_attrs___0(pm8001_ha->dev, sg_resp, 1, 2, (struct dma_attrs *)0); } if (elem == 0) { rc = -12; goto err_out; } else { } resp_len = sg_resp->dma_length; if ((req_len & 3U) != 0U || (resp_len & 3U) != 0U) { rc = -22; goto err_out_2; } else { } { opc = 18U; circularQ = (struct inbound_queue_table *)(& pm8001_ha->inbnd_q_tbl); smp_cmd.tag = ccb->ccb_tag; smp_cmd.__annonCompField97.long_smp_req.long_req_addr = task->__annonCompField95.smp_task.smp_req.dma_address; smp_cmd.__annonCompField97.long_smp_req.long_req_size = task->__annonCompField95.smp_task.smp_req.dma_length - 4U; smp_cmd.__annonCompField97.long_smp_req.long_resp_addr = task->__annonCompField95.smp_task.smp_resp.dma_address; smp_cmd.__annonCompField97.long_smp_req.long_resp_size = task->__annonCompField95.smp_task.smp_resp.dma_length - 4U; build_smp_cmd(pm8001_dev->device_id, smp_cmd.tag, & smp_cmd); rc = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, (void *)(& smp_cmd), 0U); } if (rc != 0) { goto err_out_2; } else { } return (0); err_out_2: { dma_unmap_sg_attrs(pm8001_ha->dev, & (ccb->task)->__annonCompField95.smp_task.smp_resp, 1, 2, (struct dma_attrs *)0); } err_out: { dma_unmap_sg_attrs(pm8001_ha->dev, & (ccb->task)->__annonCompField95.smp_task.smp_req, 1, 1, (struct dma_attrs *)0); } return (rc); } } static int pm8001_chip_ssp_io_req(struct pm8001_hba_info *pm8001_ha , struct pm8001_ccb_info *ccb ) { struct sas_task *task ; struct domain_device *dev ; struct pm8001_device *pm8001_dev ; struct ssp_ini_io_start_req ssp_cmd ; u32 tag ; int ret ; u64 phys_addr ; struct inbound_queue_table *circularQ ; u32 opc ; u64 dma_addr ; { { task = ccb->task; dev = task->dev; pm8001_dev = (struct pm8001_device *)dev->lldd_dev; tag = ccb->ccb_tag; opc = 6U; __memset((void *)(& ssp_cmd), 0, 60UL); __memcpy((void *)(& ssp_cmd.ssp_iu.lun), (void const *)(& task->__annonCompField95.ssp_task.LUN), 8UL); ssp_cmd.dir_m_tlr = (unsigned int )((int )data_dir_flags[(int )task->data_dir] << 8); ssp_cmd.data_len = task->total_xfer_len; ssp_cmd.device_id = pm8001_dev->device_id; ssp_cmd.tag = tag; } if ((unsigned int )*((unsigned char *)task + 97UL) != 0U) { ssp_cmd.ssp_iu.efb_prio_attr = (u8 )((unsigned int )ssp_cmd.ssp_iu.efb_prio_attr | 128U); } else { } { ssp_cmd.ssp_iu.efb_prio_attr = (u8 )((int )((signed char )ssp_cmd.ssp_iu.efb_prio_attr) | (int )((signed char )((int )task->__annonCompField95.ssp_task.task_prio << 3))); ssp_cmd.ssp_iu.efb_prio_attr = (unsigned int )ssp_cmd.ssp_iu.efb_prio_attr | ((unsigned int )((u8 )task->__annonCompField95.ssp_task.task_attr) & 7U); __memcpy((void *)(& ssp_cmd.ssp_iu.cdb), (void const *)(task->__annonCompField95.ssp_task.cmd)->cmnd, (size_t )(task->__annonCompField95.ssp_task.cmd)->cmd_len); circularQ = (struct inbound_queue_table *)(& pm8001_ha->inbnd_q_tbl); } if (task->num_scatter > 1) { { pm8001_chip_make_sg(task->scatter, (int )ccb->n_elem, (void *)(& ccb->buf_prd)); phys_addr = ccb->ccb_dma_handle + 48ULL; ssp_cmd.addr_low = (unsigned int )phys_addr; ssp_cmd.addr_high = (unsigned int )(phys_addr >> 32ULL); ssp_cmd.esgl = 2147483648U; } } else if (task->num_scatter == 1) { dma_addr = (task->scatter)->dma_address; ssp_cmd.addr_low = (unsigned int )dma_addr; ssp_cmd.addr_high = (unsigned int )(dma_addr >> 32ULL); ssp_cmd.len = task->total_xfer_len; ssp_cmd.esgl = 0U; } else if (task->num_scatter == 0) { ssp_cmd.addr_low = 0U; ssp_cmd.addr_high = 0U; ssp_cmd.len = task->total_xfer_len; ssp_cmd.esgl = 0U; } else { } { ret = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, (void *)(& ssp_cmd), 0U); } return (ret); } } static int pm8001_chip_sata_req(struct pm8001_hba_info *pm8001_ha , struct pm8001_ccb_info *ccb ) { struct sas_task *task ; struct domain_device *dev ; struct pm8001_device *pm8001_ha_dev ; u32 tag ; int ret ; struct sata_start_req sata_cmd ; u32 hdr_tag ; u32 ncg_tag ; u64 phys_addr ; u32 ATAP ; u32 dir ; struct inbound_queue_table *circularQ ; unsigned long flags ; u32 opc ; long tmp ; long tmp___0 ; long tmp___1 ; long tmp___2 ; long tmp___3 ; u32 tmp___4 ; long tmp___5 ; u64 dma_addr ; struct task_status_struct *ts ; long tmp___6 ; long tmp___7 ; { { task = ccb->task; dev = task->dev; pm8001_ha_dev = (struct pm8001_device *)dev->lldd_dev; tag = ccb->ccb_tag; ncg_tag = 0U; ATAP = 0U; opc = 23U; __memset((void *)(& sata_cmd), 0, 60UL); circularQ = (struct inbound_queue_table *)(& pm8001_ha->inbnd_q_tbl); } if ((unsigned int )*((unsigned char *)task + 184UL) == 3U) { { ATAP = 4U; tmp = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:no data\n", "pm8001_chip_sata_req", 4360); } } else { } } else { { tmp___3 = ldv__builtin_expect((unsigned int )*((unsigned char *)task + 125UL) == 0U, 1L); } if (tmp___3 != 0L) { if ((unsigned int )*((unsigned char *)task + 125UL) != 0U) { { ATAP = 6U; tmp___0 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___0 != 0L) { { printk("\016pm80xx %s %d:DMA\n", "pm8001_chip_sata_req", 4364); } } else { } } else { { ATAP = 5U; tmp___1 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___1 != 0L) { { printk("\016pm80xx %s %d:PIO\n", "pm8001_chip_sata_req", 4367); } } else { } } if ((unsigned int )*((unsigned char *)task + 125UL) != 0U && dev->__annonCompField94.sata_dev.class != 3U) { { ATAP = 7U; tmp___2 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___2 != 0L) { { printk("\016pm80xx %s %d:FPDMA\n", "pm8001_chip_sata_req", 4372); } } else { } } else { } } else { } } if ((unsigned int )*((unsigned char *)task + 125UL) != 0U) { { tmp___4 = pm8001_get_ncq_tag(task, & hdr_tag); } if (tmp___4 != 0U) { task->__annonCompField95.ata_task.fis.__annonCompField87.sector_count = (u8 )((int )task->__annonCompField95.ata_task.fis.__annonCompField87.sector_count | ((int )((unsigned char )hdr_tag) << 3U)); ncg_tag = hdr_tag; } else { } } else { } { dir = (u32 )((int )data_dir_flags[(int )task->data_dir] << 8); sata_cmd.tag = tag; sata_cmd.device_id = pm8001_ha_dev->device_id; sata_cmd.data_len = task->total_xfer_len; sata_cmd.ncqtag_atap_dir_m = (((ncg_tag & 255U) << 16) | ((ATAP << 10) & 65535U)) | dir; sata_cmd.sata_fis = task->__annonCompField95.ata_task.fis; tmp___5 = ldv__builtin_expect((unsigned int )*((unsigned char *)task + 125UL) == 0U, 1L); } if (tmp___5 != 0L) { sata_cmd.sata_fis.flags = (u8 )((unsigned int )sata_cmd.sata_fis.flags | 128U); } else { } sata_cmd.sata_fis.flags = (unsigned int )sata_cmd.sata_fis.flags & 240U; if (task->num_scatter > 1) { { pm8001_chip_make_sg(task->scatter, (int )ccb->n_elem, (void *)(& ccb->buf_prd)); phys_addr = ccb->ccb_dma_handle + 48ULL; sata_cmd.addr_low = (unsigned int )phys_addr; sata_cmd.addr_high = (unsigned int )(phys_addr >> 32ULL); sata_cmd.esgl = 2147483648U; } } else if (task->num_scatter == 1) { dma_addr = (task->scatter)->dma_address; sata_cmd.addr_low = (unsigned int )dma_addr; sata_cmd.addr_high = (unsigned int )(dma_addr >> 32ULL); sata_cmd.len = task->total_xfer_len; sata_cmd.esgl = 0U; } else if (task->num_scatter == 0) { sata_cmd.addr_low = 0U; sata_cmd.addr_high = 0U; sata_cmd.len = task->total_xfer_len; sata_cmd.esgl = 0U; } else { } if ((unsigned int )sata_cmd.sata_fis.command == 47U) { if ((int )pm8001_ha_dev->id < 0 || *((unsigned int *)pm8001_ha_dev + 5UL) != 0U) { { pm8001_ha_dev->id = pm8001_ha_dev->id & 3758096383U; ts = & task->task_status; ldv___ldv_linux_kernel_locking_spinlock_spin_lock_173(& task->task_state_lock); ts->resp = 0; ts->stat = 0; task->task_state_flags = task->task_state_flags & 4294967294U; task->task_state_flags = task->task_state_flags & 4294967279U; task->task_state_flags = task->task_state_flags | 2U; tmp___7 = ldv__builtin_expect((task->task_state_flags & 4U) != 0U, 0L); } if (tmp___7 != 0L) { { ldv_spin_unlock_irqrestore_135(& task->task_state_lock, flags); tmp___6 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___6 != 0L) { { printk("\016pm80xx %s %d:task 0x%p resp 0x%x stat 0x%x but aborted by upper layer \n", "pm8001_chip_sata_req", 4433, task, (int )ts->resp, (unsigned int )ts->stat); } } else { } { pm8001_ccb_task_free(pm8001_ha, task, ccb, tag); } } else { { ldv_spin_unlock_irqrestore_135(& task->task_state_lock, flags); pm8001_ccb_task_free_done(pm8001_ha, task, ccb, tag); } return (0); } } else { } } else { } { ret = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, (void *)(& sata_cmd), 0U); } return (ret); } } static int pm8001_chip_phy_start_req(struct pm8001_hba_info *pm8001_ha , u8 phy_id ) { struct phy_start_req payload ; struct inbound_queue_table *circularQ ; int ret ; u32 tag ; u32 opcode ; { { tag = 1U; opcode = 4U; circularQ = (struct inbound_queue_table *)(& pm8001_ha->inbnd_q_tbl); __memset((void *)(& payload), 0, 60UL); payload.tag = tag; payload.ase_sh_lm_slr_phyid = (unsigned int )((int )phy_id | 14080); payload.sas_identify.dev_type = 1U; payload.sas_identify.__annonCompField89.initiator_bits = 14U; __memcpy((void *)(& payload.sas_identify.sas_addr), (void const *)(& pm8001_ha->sas_addr), 8UL); payload.sas_identify.phy_id = phy_id; ret = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opcode, (void *)(& payload), 0U); } return (ret); } } int pm8001_chip_phy_stop_req(struct pm8001_hba_info *pm8001_ha , u8 phy_id ) { struct phy_stop_req payload ; struct inbound_queue_table *circularQ ; int ret ; u32 tag ; u32 opcode ; { { tag = 1U; opcode = 5U; circularQ = (struct inbound_queue_table *)(& pm8001_ha->inbnd_q_tbl); __memset((void *)(& payload), 0, 60UL); payload.tag = tag; payload.phy_id = (unsigned int )phy_id; ret = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opcode, (void *)(& payload), 0U); } return (ret); } } static int pm8001_chip_reg_dev_req(struct pm8001_hba_info *pm8001_ha , struct pm8001_device *pm8001_dev , u32 flag ) { struct reg_dev_req payload ; u32 opc ; u32 stp_sspsmp_sata ; struct inbound_queue_table *circularQ ; u32 linkrate ; u32 phy_id ; int rc ; int tag ; struct pm8001_ccb_info *ccb ; u8 retryFlag ; u16 firstBurstSize ; u16 ITNT ; struct domain_device *dev ; struct domain_device *parent_dev ; { { stp_sspsmp_sata = 4U; tag = -559038737; retryFlag = 1U; firstBurstSize = 0U; ITNT = 2000U; dev = pm8001_dev->sas_device; parent_dev = dev->parent; circularQ = (struct inbound_queue_table *)(& pm8001_ha->inbnd_q_tbl); __memset((void *)(& payload), 0, 60UL); rc = pm8001_tag_alloc(pm8001_ha, (u32 *)(& tag)); } if (rc != 0) { return (rc); } else { } ccb = pm8001_ha->ccb_info + (unsigned long )tag; ccb->device = pm8001_dev; ccb->ccb_tag = (u32 )tag; payload.tag = (unsigned int )tag; if (flag == 1U) { stp_sspsmp_sata = 2U; } else if ((unsigned int )pm8001_dev->dev_type == 5U) { stp_sspsmp_sata = 0U; } else if ((unsigned int )pm8001_dev->dev_type - 1U <= 2U) { stp_sspsmp_sata = 1U; } else { } if ((unsigned long )parent_dev != (unsigned long )((struct domain_device *)0) && (unsigned int )parent_dev->dev_type - 2U <= 1U) { phy_id = (u32 )(parent_dev->__annonCompField94.ex_dev.ex_phy)->phy_id; } else { phy_id = pm8001_dev->attached_phy; } { opc = 22U; linkrate = (unsigned int )(pm8001_dev->sas_device)->linkrate < (unsigned int )(dev->port)->linkrate ? (unsigned int )(pm8001_dev->sas_device)->linkrate : (unsigned int )(dev->port)->linkrate; payload.phyid_portid = ((u32 )((pm8001_dev->sas_device)->port)->id & 15U) | ((phy_id << 4) & 255U); payload.dtype_dlr_retry = (((u32 )retryFlag & 1U) | (linkrate & 15U) * 16777216U) | (stp_sspsmp_sata & 3U) * 268435456U; payload.firstburstsize_ITNexustimeout = (unsigned int )((int )ITNT | (int )firstBurstSize * 65536); __memcpy((void *)(& payload.sas_addr), (void const *)(& (pm8001_dev->sas_device)->sas_addr), 8UL); rc = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, (void *)(& payload), 0U); } return (rc); } } int pm8001_chip_dereg_dev_req(struct pm8001_hba_info *pm8001_ha , u32 device_id ) { struct dereg_dev_req payload ; u32 opc ; int ret ; struct inbound_queue_table *circularQ ; long tmp ; { { opc = 16U; circularQ = (struct inbound_queue_table *)(& pm8001_ha->inbnd_q_tbl); __memset((void *)(& payload), 0, 60UL); payload.tag = 1U; payload.device_id = device_id; tmp = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:unregister device device_id = %d\n", "pm8001_chip_dereg_dev_req", 4581, device_id); } } else { } { ret = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, (void *)(& payload), 0U); } return (ret); } } static int pm8001_chip_phy_ctl_req(struct pm8001_hba_info *pm8001_ha , u32 phyId , u32 phy_op ) { struct local_phy_ctl_req payload ; struct inbound_queue_table *circularQ ; int ret ; u32 opc ; { { opc = 25U; __memset((void *)(& payload), 0, 60UL); circularQ = (struct inbound_queue_table *)(& pm8001_ha->inbnd_q_tbl); payload.tag = 1U; payload.phyop_phyid = ((phy_op << 8) & 65535U) | (phyId & 15U); ret = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, (void *)(& payload), 0U); } return (ret); } } static u32 pm8001_chip_is_our_interupt(struct pm8001_hba_info *pm8001_ha ) { u32 value ; { return (1U); { value = pm8001_cr32(pm8001_ha, 0U, 60U); } if (value != 0U) { return (1U); } else { } return (0U); } } static irqreturn_t pm8001_chip_isr(struct pm8001_hba_info *pm8001_ha , u8 vec ) { { { pm8001_chip_interrupt_disable(pm8001_ha, (int )vec); process_oq(pm8001_ha, (int )vec); pm8001_chip_interrupt_enable(pm8001_ha, (int )vec); } return (1); } } static int send_task_abort(struct pm8001_hba_info *pm8001_ha , u32 opc , u32 dev_id , u8 flag , u32 task_tag , u32 cmd_tag ) { struct task_abort_req task_abort ; struct inbound_queue_table *circularQ ; int ret ; { { circularQ = (struct inbound_queue_table *)(& pm8001_ha->inbnd_q_tbl); __memset((void *)(& task_abort), 0, 60UL); } if (((int )flag & 3) == 0) { task_abort.abort_all = 0U; task_abort.device_id = dev_id; task_abort.tag_to_abort = task_tag; task_abort.tag = cmd_tag; } else if (((int )flag & 3) == 1) { task_abort.abort_all = 1U; task_abort.device_id = dev_id; task_abort.tag = cmd_tag; } else { } { ret = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, (void *)(& task_abort), 0U); } return (ret); } } int pm8001_chip_abort_task(struct pm8001_hba_info *pm8001_ha , struct pm8001_device *pm8001_dev , u8 flag , u32 task_tag , u32 cmd_tag ) { u32 opc ; u32 device_id ; int rc ; long tmp ; long tmp___0 ; { { rc = 5; tmp = ldv__builtin_expect((pm8001_ha->logging_level & 16U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:cmd_tag = %x, abort task tag = 0x%x", "pm8001_chip_abort_task", 4671, cmd_tag, task_tag); } } else { } if ((unsigned int )pm8001_dev->dev_type == 1U) { opc = 15U; } else if ((unsigned int )pm8001_dev->dev_type == 5U) { opc = 24U; } else { opc = 20U; } { device_id = pm8001_dev->device_id; rc = send_task_abort(pm8001_ha, opc, device_id, (int )flag, task_tag, cmd_tag); } if (rc != 0) { { tmp___0 = ldv__builtin_expect((pm8001_ha->logging_level & 16U) != 0U, 0L); } if (tmp___0 != 0L) { { printk("\016pm80xx %s %d:rc= %d\n", "pm8001_chip_abort_task", 4682, rc); } } else { } } else { } return (rc); } } int pm8001_chip_ssp_tm_req(struct pm8001_hba_info *pm8001_ha , struct pm8001_ccb_info *ccb , struct pm8001_tmf_task *tmf ) { struct sas_task *task ; struct domain_device *dev ; struct pm8001_device *pm8001_dev ; u32 opc ; struct inbound_queue_table *circularQ ; struct ssp_ini_tm_start_req sspTMCmd ; int ret ; { { task = ccb->task; dev = task->dev; pm8001_dev = (struct pm8001_device *)dev->lldd_dev; opc = 7U; __memset((void *)(& sspTMCmd), 0, 60UL); sspTMCmd.device_id = pm8001_dev->device_id; sspTMCmd.relate_tag = tmf->tag_of_task_to_be_managed; sspTMCmd.tmf = (unsigned int )tmf->tmf; __memcpy((void *)(& sspTMCmd.lun), (void const *)(& task->__annonCompField95.ssp_task.LUN), 8UL); sspTMCmd.tag = ccb->ccb_tag; } if (pm8001_ha->chip_id != 0U) { sspTMCmd.ds_ads_m = 8U; } else { } { circularQ = (struct inbound_queue_table *)(& pm8001_ha->inbnd_q_tbl); ret = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, (void *)(& sspTMCmd), 0U); } return (ret); } } int pm8001_chip_get_nvmd_req(struct pm8001_hba_info *pm8001_ha , void *payload ) { u32 opc ; u32 nvmd_type ; int rc ; u32 tag ; struct pm8001_ccb_info *ccb ; struct inbound_queue_table *circularQ ; struct get_nvm_data_req nvmd_req ; struct fw_control_ex *fw_control_context ; struct pm8001_ioctl_payload *ioctl_payload ; void *tmp ; u32 twi_addr ; u32 twi_page_size ; { { opc = 40U; ioctl_payload = (struct pm8001_ioctl_payload *)payload; nvmd_type = (u32 )ioctl_payload->minor_function; tmp = kzalloc(88UL, 208U); fw_control_context = (struct fw_control_ex *)tmp; } if ((unsigned long )fw_control_context == (unsigned long )((struct fw_control_ex *)0)) { return (-12); } else { } { fw_control_context->usrAddr = (void *)ioctl_payload->func_specific; fw_control_context->len = (u32 )ioctl_payload->length; circularQ = (struct inbound_queue_table *)(& pm8001_ha->inbnd_q_tbl); __memset((void *)(& nvmd_req), 0, 60UL); rc = pm8001_tag_alloc(pm8001_ha, & tag); } if (rc != 0) { { kfree((void const *)fw_control_context); } return (rc); } else { } ccb = pm8001_ha->ccb_info + (unsigned long )tag; ccb->ccb_tag = tag; ccb->fw_control_context = fw_control_context; nvmd_req.tag = tag; { if (nvmd_type == 0U) { goto case_0; } else { } if (nvmd_type == 1U) { goto case_1; } else { } if (nvmd_type == 4U) { goto case_4; } else { } if (nvmd_type == 7U) { goto case_7; } else { } if (nvmd_type == 6U) { goto case_6; } else { } goto switch_default; case_0: /* CIL Label */ twi_addr = 168U; twi_page_size = 2U; nvmd_req.len_ir_vpdd = ((twi_addr << 16) | (twi_page_size << 8)) | 2147483648U; nvmd_req.resp_len = (unsigned int )ioctl_payload->length; nvmd_req.resp_addr_hi = pm8001_ha->memoryMap.region[2].phys_addr_hi; nvmd_req.resp_addr_lo = pm8001_ha->memoryMap.region[2].phys_addr_lo; goto ldv_47490; case_1: /* CIL Label */ nvmd_req.len_ir_vpdd = 2147483649U; nvmd_req.resp_len = (unsigned int )ioctl_payload->length; nvmd_req.resp_addr_hi = pm8001_ha->memoryMap.region[2].phys_addr_hi; nvmd_req.resp_addr_lo = pm8001_ha->memoryMap.region[2].phys_addr_lo; goto ldv_47490; case_4: /* CIL Label */ nvmd_req.len_ir_vpdd = 2147483652U; nvmd_req.resp_len = (unsigned int )ioctl_payload->length; nvmd_req.resp_addr_hi = pm8001_ha->memoryMap.region[2].phys_addr_hi; nvmd_req.resp_addr_lo = pm8001_ha->memoryMap.region[2].phys_addr_lo; goto ldv_47490; case_7: /* CIL Label */ nvmd_req.len_ir_vpdd = 2147483655U; nvmd_req.resp_len = (unsigned int )ioctl_payload->length; nvmd_req.resp_addr_hi = pm8001_ha->memoryMap.region[2].phys_addr_hi; nvmd_req.resp_addr_lo = pm8001_ha->memoryMap.region[2].phys_addr_lo; goto ldv_47490; case_6: /* CIL Label */ nvmd_req.len_ir_vpdd = 2147483654U; nvmd_req.resp_len = (unsigned int )ioctl_payload->length; nvmd_req.vpd_offset = (unsigned int )ioctl_payload->offset; nvmd_req.resp_addr_hi = pm8001_ha->memoryMap.region[2].phys_addr_hi; nvmd_req.resp_addr_lo = pm8001_ha->memoryMap.region[2].phys_addr_lo; goto ldv_47490; switch_default: /* CIL Label */ ; goto ldv_47490; switch_break: /* CIL Label */ ; } ldv_47490: { rc = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, (void *)(& nvmd_req), 0U); } if (rc != 0) { { kfree((void const *)fw_control_context); pm8001_tag_free(pm8001_ha, tag); } } else { } return (rc); } } int pm8001_chip_set_nvmd_req(struct pm8001_hba_info *pm8001_ha , void *payload ) { u32 opc ; u32 nvmd_type ; int rc ; u32 tag ; struct pm8001_ccb_info *ccb ; struct inbound_queue_table *circularQ ; struct set_nvm_data_req nvmd_req ; struct fw_control_ex *fw_control_context ; struct pm8001_ioctl_payload *ioctl_payload ; void *tmp ; u32 twi_addr ; u32 twi_page_size ; { { opc = 41U; ioctl_payload = (struct pm8001_ioctl_payload *)payload; nvmd_type = (u32 )ioctl_payload->minor_function; tmp = kzalloc(88UL, 208U); fw_control_context = (struct fw_control_ex *)tmp; } if ((unsigned long )fw_control_context == (unsigned long )((struct fw_control_ex *)0)) { return (-12); } else { } { circularQ = (struct inbound_queue_table *)(& pm8001_ha->inbnd_q_tbl); __memcpy(pm8001_ha->memoryMap.region[2].virt_ptr, (void const *)(& ioctl_payload->func_specific), (size_t )ioctl_payload->length); __memset((void *)(& nvmd_req), 0, 60UL); rc = pm8001_tag_alloc(pm8001_ha, & tag); } if (rc != 0) { { kfree((void const *)fw_control_context); } return (-16); } else { } ccb = pm8001_ha->ccb_info + (unsigned long )tag; ccb->fw_control_context = fw_control_context; ccb->ccb_tag = tag; nvmd_req.tag = tag; { if (nvmd_type == 0U) { goto case_0; } else { } if (nvmd_type == 1U) { goto case_1; } else { } if (nvmd_type == 4U) { goto case_4; } else { } if (nvmd_type == 7U) { goto case_7; } else { } goto switch_default; case_0: /* CIL Label */ twi_addr = 168U; twi_page_size = 2U; nvmd_req.reserved[0] = 4275878552U; nvmd_req.len_ir_vpdd = ((twi_addr << 16) | (twi_page_size << 8)) | 2147483648U; nvmd_req.resp_len = (unsigned int )ioctl_payload->length; nvmd_req.resp_addr_hi = pm8001_ha->memoryMap.region[2].phys_addr_hi; nvmd_req.resp_addr_lo = pm8001_ha->memoryMap.region[2].phys_addr_lo; goto ldv_47512; case_1: /* CIL Label */ nvmd_req.len_ir_vpdd = 2147483649U; nvmd_req.resp_len = (unsigned int )ioctl_payload->length; nvmd_req.reserved[0] = 4275878552U; nvmd_req.resp_addr_hi = pm8001_ha->memoryMap.region[2].phys_addr_hi; nvmd_req.resp_addr_lo = pm8001_ha->memoryMap.region[2].phys_addr_lo; goto ldv_47512; case_4: /* CIL Label */ nvmd_req.len_ir_vpdd = 2147483652U; nvmd_req.resp_len = (unsigned int )ioctl_payload->length; nvmd_req.reserved[0] = 4275878552U; nvmd_req.resp_addr_hi = pm8001_ha->memoryMap.region[2].phys_addr_hi; nvmd_req.resp_addr_lo = pm8001_ha->memoryMap.region[2].phys_addr_lo; goto ldv_47512; case_7: /* CIL Label */ nvmd_req.len_ir_vpdd = 2147483655U; nvmd_req.resp_len = (unsigned int )ioctl_payload->length; nvmd_req.reserved[0] = 4275878552U; nvmd_req.resp_addr_hi = pm8001_ha->memoryMap.region[2].phys_addr_hi; nvmd_req.resp_addr_lo = pm8001_ha->memoryMap.region[2].phys_addr_lo; goto ldv_47512; switch_default: /* CIL Label */ ; goto ldv_47512; switch_break: /* CIL Label */ ; } ldv_47512: { rc = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, (void *)(& nvmd_req), 0U); } if (rc != 0) { { kfree((void const *)fw_control_context); pm8001_tag_free(pm8001_ha, tag); } } else { } return (rc); } } int pm8001_chip_fw_flash_update_build(struct pm8001_hba_info *pm8001_ha , void *fw_flash_updata_info , u32 tag ) { struct fw_flash_Update_req payload ; struct fw_flash_updata_info *info ; struct inbound_queue_table *circularQ ; int ret ; u32 opc ; { { opc = 32U; __memset((void *)(& payload), 0, 60UL); circularQ = (struct inbound_queue_table *)(& pm8001_ha->inbnd_q_tbl); info = (struct fw_flash_updata_info *)fw_flash_updata_info; payload.tag = tag; payload.cur_image_len = info->cur_image_len; payload.cur_image_offset = info->cur_image_offset; payload.total_image_len = info->total_image_len; payload.len = info->sgl.im_len.len; payload.sgl_addr_lo = (unsigned int )info->sgl.addr; payload.sgl_addr_hi = (unsigned int )(info->sgl.addr >> 32ULL); ret = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, (void *)(& payload), 0U); } return (ret); } } int pm8001_chip_fw_flash_update_req(struct pm8001_hba_info *pm8001_ha , void *payload ) { struct fw_flash_updata_info flash_update_info ; struct fw_control_info *fw_control ; struct fw_control_ex *fw_control_context ; int rc ; u32 tag ; struct pm8001_ccb_info *ccb ; void *buffer ; dma_addr_t phys_addr ; struct pm8001_ioctl_payload *ioctl_payload ; void *tmp ; { { buffer = pm8001_ha->memoryMap.region[5].virt_ptr; phys_addr = pm8001_ha->memoryMap.region[5].phys_addr; ioctl_payload = (struct pm8001_ioctl_payload *)payload; tmp = kzalloc(88UL, 208U); fw_control_context = (struct fw_control_ex *)tmp; } if ((unsigned long )fw_control_context == (unsigned long )((struct fw_control_ex *)0)) { return (-12); } else { } { fw_control = (struct fw_control_info *)(& ioctl_payload->func_specific); __memcpy(buffer, (void const *)(& fw_control->buffer), (size_t )fw_control->len); flash_update_info.sgl.addr = phys_addr; flash_update_info.sgl.im_len.len = fw_control->len; flash_update_info.sgl.im_len.e = 0U; flash_update_info.cur_image_offset = fw_control->offset; flash_update_info.cur_image_len = fw_control->len; flash_update_info.total_image_len = fw_control->size; fw_control_context->fw_control = fw_control; fw_control_context->virtAddr = buffer; fw_control_context->phys_addr = phys_addr; fw_control_context->len = fw_control->len; rc = pm8001_tag_alloc(pm8001_ha, & tag); } if (rc != 0) { { kfree((void const *)fw_control_context); } return (-16); } else { } { ccb = pm8001_ha->ccb_info + (unsigned long )tag; ccb->fw_control_context = fw_control_context; ccb->ccb_tag = tag; rc = pm8001_chip_fw_flash_update_build(pm8001_ha, (void *)(& flash_update_info), tag); } return (rc); } } ssize_t pm8001_get_gsm_dump(struct device *cdev , u32 length , char *buf ) { u32 value ; u32 rem ; u32 offset ; u32 bar ; u32 index ; u32 work_offset ; u32 dw_length ; u32 shift_value ; u32 gsm_base ; u32 gsm_dump_offset ; char *direct_data ; struct Scsi_Host *shost ; struct device const *__mptr ; struct sas_ha_struct *sha ; struct pm8001_hba_info *pm8001_ha ; int tmp ; int tmp___0 ; int tmp___1 ; int tmp___2 ; int tmp___3 ; { offset = 0U; bar = 0U; __mptr = (struct device const *)cdev; shost = (struct Scsi_Host *)__mptr + 0xfffffffffffff6c8UL; sha = *((struct sas_ha_struct **)(& shost->hostdata)); pm8001_ha = (struct pm8001_hba_info *)sha->lldd_ha; direct_data = buf; gsm_dump_offset = pm8001_ha->fatal_forensic_shift_offset; if ((length > 1048576U || (gsm_dump_offset & 3U) != 0U) || gsm_dump_offset + length > 16777216U) { return (-22L); } else { } if (pm8001_ha->chip_id == 0U) { bar = 2U; } else { bar = 1U; } work_offset = gsm_dump_offset & 4294901760U; offset = gsm_dump_offset & 65535U; gsm_dump_offset = work_offset; rem = length & 3U; dw_length = length >> 2; index = 0U; goto ldv_47562; ldv_47561: ; if (((work_offset + offset) & 4294901760U) != 0U) { if (pm8001_ha->chip_id == 0U) { shift_value = (gsm_dump_offset + offset) & 4294901760U; } else { shift_value = ((gsm_dump_offset + offset) & 4294901760U) >> 8; } if (pm8001_ha->chip_id == 0U) { { gsm_base = 5177344U; tmp = pm8001_bar4_shift(pm8001_ha, gsm_base + shift_value); } if (tmp == -1) { return (-5L); } else { } } else { { gsm_base = 0U; tmp___0 = pm80xx_bar4_shift(pm8001_ha, gsm_base + shift_value); } if (tmp___0 == -1) { return (-5L); } else { } } gsm_dump_offset = (gsm_dump_offset + offset) & 4294901760U; work_offset = 0U; offset = offset & 65535U; } else { } { value = pm8001_cr32(pm8001_ha, bar, (work_offset + offset) & 65535U); tmp___1 = sprintf(direct_data, "%08x ", value); direct_data = direct_data + (unsigned long )tmp___1; offset = offset + 4U; index = index + 1U; } ldv_47562: ; if (index < dw_length) { goto ldv_47561; } else { } if (rem != 0U) { { value = pm8001_cr32(pm8001_ha, bar, (work_offset + offset) & 65535U); tmp___2 = sprintf(direct_data, "%08x ", value); direct_data = direct_data + (unsigned long )tmp___2; } } else { } { tmp___3 = pm8001_bar4_shift(pm8001_ha, 0U); } if (tmp___3 == -1) { return (-5L); } else { } pm8001_ha->fatal_forensic_shift_offset = pm8001_ha->fatal_forensic_shift_offset + 1024U; if (pm8001_ha->fatal_forensic_shift_offset > 1048575U) { pm8001_ha->fatal_forensic_shift_offset = 0U; } else { } return ((long )direct_data - (long )buf); } } int pm8001_chip_set_dev_state_req(struct pm8001_hba_info *pm8001_ha , struct pm8001_device *pm8001_dev , u32 state ) { struct set_dev_state_req payload ; struct inbound_queue_table *circularQ ; struct pm8001_ccb_info *ccb ; int rc ; u32 tag ; u32 opc ; { { opc = 42U; __memset((void *)(& payload), 0, 60UL); rc = pm8001_tag_alloc(pm8001_ha, & tag); } if (rc != 0) { return (-1); } else { } { ccb = pm8001_ha->ccb_info + (unsigned long )tag; ccb->ccb_tag = tag; ccb->device = pm8001_dev; circularQ = (struct inbound_queue_table *)(& pm8001_ha->inbnd_q_tbl); payload.tag = tag; payload.device_id = pm8001_dev->device_id; payload.nds = state; rc = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, (void *)(& payload), 0U); } return (rc); } } static int pm8001_chip_sas_re_initialization(struct pm8001_hba_info *pm8001_ha ) { struct sas_re_initialization_req payload ; struct inbound_queue_table *circularQ ; struct pm8001_ccb_info *ccb ; int rc ; u32 tag ; u32 opc ; { { opc = 45U; __memset((void *)(& payload), 0, 60UL); rc = pm8001_tag_alloc(pm8001_ha, & tag); } if (rc != 0) { return (-12); } else { } { ccb = pm8001_ha->ccb_info + (unsigned long )tag; ccb->ccb_tag = tag; circularQ = (struct inbound_queue_table *)(& pm8001_ha->inbnd_q_tbl); payload.tag = tag; payload.SSAHOLT = 436207616U; payload.sata_hol_tmo = 80U; payload.open_reject_cmdretries_data_retries = 16711935U; rc = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, (void *)(& payload), 0U); } if (rc != 0) { { pm8001_tag_free(pm8001_ha, tag); } } else { } return (rc); } } struct pm8001_dispatch const pm8001_8001_dispatch = {(char *)"pmc8001", & pm8001_chip_init, & pm8001_chip_soft_rst, & pm8001_hw_chip_rst, 0, & pm8001_chip_iounmap, & pm8001_chip_isr, & pm8001_chip_is_our_interupt, & process_oq, & pm8001_chip_interrupt_enable, & pm8001_chip_interrupt_disable, & pm8001_chip_make_sg, & pm8001_chip_smp_req, & pm8001_chip_ssp_io_req, & pm8001_chip_sata_req, & pm8001_chip_phy_start_req, & pm8001_chip_phy_stop_req, & pm8001_chip_reg_dev_req, & pm8001_chip_dereg_dev_req, & pm8001_chip_phy_ctl_req, & pm8001_chip_abort_task, & pm8001_chip_ssp_tm_req, & pm8001_chip_get_nvmd_req, & pm8001_chip_set_nvmd_req, & pm8001_chip_fw_flash_update_req, & pm8001_chip_set_dev_state_req, 0, 0, & pm8001_chip_sas_re_initialization}; void ldv_dummy_resourceless_instance_callback_20_15(void (*arg0)(struct pm8001_hba_info * , unsigned char ) , struct pm8001_hba_info *arg1 , unsigned char arg2 ) { { { pm8001_chip_interrupt_disable(arg1, (int )arg2); } return; } } void ldv_dummy_resourceless_instance_callback_20_18(void (*arg0)(struct pm8001_hba_info * , unsigned char ) , struct pm8001_hba_info *arg1 , unsigned char arg2 ) { { { pm8001_chip_interrupt_enable(arg1, (int )arg2); } return; } } void ldv_dummy_resourceless_instance_callback_20_21(unsigned int (*arg0)(struct pm8001_hba_info * ) , struct pm8001_hba_info *arg1 ) { { { pm8001_chip_is_our_interupt(arg1); } return; } } void ldv_dummy_resourceless_instance_callback_20_22(enum irqreturn (*arg0)(struct pm8001_hba_info * , unsigned char ) , struct pm8001_hba_info *arg1 , unsigned char arg2 ) { { { pm8001_chip_isr(arg1, (int )arg2); } return; } } void ldv_dummy_resourceless_instance_callback_20_3(int (*arg0)(struct pm8001_hba_info * ) , struct pm8001_hba_info *arg1 ) { { { pm8001_chip_init(arg1); } return; } } void ldv_dummy_resourceless_instance_callback_20_31(int (*arg0)(struct pm8001_hba_info * , unsigned int , unsigned int ) , struct pm8001_hba_info *arg1 , unsigned int arg2 , unsigned int arg3 ) { { { pm8001_chip_phy_ctl_req(arg1, arg2, arg3); } return; } } void ldv_dummy_resourceless_instance_callback_20_34(int (*arg0)(struct pm8001_hba_info * , unsigned char ) , struct pm8001_hba_info *arg1 , unsigned char arg2 ) { { { pm8001_chip_phy_start_req(arg1, (int )arg2); } return; } } void ldv_dummy_resourceless_instance_callback_20_37(int (*arg0)(struct pm8001_hba_info * , unsigned char ) , struct pm8001_hba_info *arg1 , unsigned char arg2 ) { { { pm8001_chip_phy_stop_req(arg1, (int )arg2); } return; } } void ldv_dummy_resourceless_instance_callback_20_40(int (*arg0)(struct pm8001_hba_info * , struct pm8001_device * , unsigned int ) , struct pm8001_hba_info *arg1 , struct pm8001_device *arg2 , unsigned int arg3 ) { { { pm8001_chip_reg_dev_req(arg1, arg2, arg3); } return; } } void ldv_dummy_resourceless_instance_callback_20_43(int (*arg0)(struct pm8001_hba_info * ) , struct pm8001_hba_info *arg1 ) { { { pm8001_chip_sas_re_initialization(arg1); } return; } } void ldv_dummy_resourceless_instance_callback_20_44(int (*arg0)(struct pm8001_hba_info * , struct pm8001_ccb_info * ) , struct pm8001_hba_info *arg1 , struct pm8001_ccb_info *arg2 ) { { { pm8001_chip_sata_req(arg1, arg2); } return; } } void ldv_dummy_resourceless_instance_callback_20_49(int (*arg0)(struct pm8001_hba_info * , struct pm8001_ccb_info * ) , struct pm8001_hba_info *arg1 , struct pm8001_ccb_info *arg2 ) { { { pm8001_chip_smp_req(arg1, arg2); } return; } } void ldv_dummy_resourceless_instance_callback_20_50(int (*arg0)(struct pm8001_hba_info * , struct pm8001_ccb_info * ) , struct pm8001_hba_info *arg1 , struct pm8001_ccb_info *arg2 ) { { { pm8001_chip_ssp_io_req(arg1, arg2); } return; } } void ldv_dummy_resourceless_instance_callback_20_8(void (*arg0)(struct pm8001_hba_info * ) , struct pm8001_hba_info *arg1 ) { { { pm8001_hw_chip_rst(arg1); } return; } } void ldv_dummy_resourceless_instance_callback_20_9(int (*arg0)(struct pm8001_hba_info * ) , struct pm8001_hba_info *arg1 ) { { { pm8001_chip_soft_rst(arg1); } return; } } void ldv_dummy_resourceless_instance_callback_21_43(int (*arg0)(struct pm8001_hba_info * ) , struct pm8001_hba_info *arg1 ) { { { pm8001_chip_sas_re_initialization(arg1); } return; } } __inline static void *kmalloc(size_t size , gfp_t flags ) { void *res ; { { ldv_check_alloc_flags(flags); res = ldv_malloc_unknown_size(); ldv_after_alloc(res); } return (res); } } __inline static void ldv_spin_unlock_98(spinlock_t *lock ) { { { ldv_linux_kernel_locking_spinlock_spin_unlock_lock_of_pm8001_hba_info(); spin_unlock(lock); } return; } } __inline static void ldv_spin_lock_99(spinlock_t *lock ) { { { ldv_linux_kernel_locking_spinlock_spin_lock_lock_of_pm8001_hba_info(); spin_lock(lock); } return; } } static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_100___0(spinlock_t *ldv_func_arg1 ) { { { ldv_linux_kernel_locking_spinlock_spin_lock_lock_of_pm8001_hba_info(); __ldv_linux_kernel_locking_spinlock_spin_lock(ldv_func_arg1); } return; } } static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_104(spinlock_t *ldv_func_arg1 ) { { { ldv_linux_kernel_locking_spinlock_spin_lock_lock_of_pm8001_hba_info(); __ldv_linux_kernel_locking_spinlock_spin_lock(ldv_func_arg1); } return; } } static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_108___0(spinlock_t *ldv_func_arg1 ) { { { ldv_linux_kernel_locking_spinlock_spin_lock_lock_of_pm8001_hba_info(); __ldv_linux_kernel_locking_spinlock_spin_lock(ldv_func_arg1); } return; } } static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_112(spinlock_t *ldv_func_arg1 ) { { { ldv_linux_kernel_locking_spinlock_spin_lock_lock_of_pm8001_hba_info(); __ldv_linux_kernel_locking_spinlock_spin_lock(ldv_func_arg1); } return; } } static void ldv_iounmap_123(void volatile *ldv_func_arg1 ) { { { ldv_linux_arch_io_io_mem_unmap(); } return; } } static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_124(spinlock_t *ldv_func_arg1 ) { { { ldv_linux_kernel_locking_spinlock_spin_lock_lock_of_pm8001_hba_info(); __ldv_linux_kernel_locking_spinlock_spin_lock(ldv_func_arg1); } return; } } static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_125(spinlock_t *ldv_func_arg1 ) { { { ldv_linux_kernel_locking_spinlock_spin_lock_task_state_lock_of_sas_task(); __ldv_linux_kernel_locking_spinlock_spin_lock(ldv_func_arg1); } return; } } static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_130(spinlock_t *ldv_func_arg1 ) { { { ldv_linux_kernel_locking_spinlock_spin_lock_task_state_lock_of_sas_task(); __ldv_linux_kernel_locking_spinlock_spin_lock(ldv_func_arg1); } return; } } static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_135(spinlock_t *ldv_func_arg1 ) { { { ldv_linux_kernel_locking_spinlock_spin_lock_lock_of_pm8001_hba_info(); __ldv_linux_kernel_locking_spinlock_spin_lock(ldv_func_arg1); } return; } } static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_136(spinlock_t *ldv_func_arg1 ) { { { ldv_linux_kernel_locking_spinlock_spin_lock_task_state_lock_of_sas_task(); __ldv_linux_kernel_locking_spinlock_spin_lock(ldv_func_arg1); } return; } } static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_144(spinlock_t *ldv_func_arg1 ) { { { ldv_linux_kernel_locking_spinlock_spin_lock_task_state_lock_of_sas_task(); __ldv_linux_kernel_locking_spinlock_spin_lock(ldv_func_arg1); } return; } } static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_147(spinlock_t *ldv_func_arg1 ) { { { ldv_linux_kernel_locking_spinlock_spin_lock_task_state_lock_of_sas_task(); __ldv_linux_kernel_locking_spinlock_spin_lock(ldv_func_arg1); } return; } } static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_150(spinlock_t *ldv_func_arg1 ) { { { ldv_linux_kernel_locking_spinlock_spin_lock_task_state_lock_of_sas_task(); __ldv_linux_kernel_locking_spinlock_spin_lock(ldv_func_arg1); } return; } } static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_153(spinlock_t *ldv_func_arg1 ) { { { ldv_linux_kernel_locking_spinlock_spin_lock_task_state_lock_of_sas_task(); __ldv_linux_kernel_locking_spinlock_spin_lock(ldv_func_arg1); } return; } } static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_156(spinlock_t *ldv_func_arg1 ) { { { ldv_linux_kernel_locking_spinlock_spin_lock_task_state_lock_of_sas_task(); __ldv_linux_kernel_locking_spinlock_spin_lock(ldv_func_arg1); } return; } } static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_159(spinlock_t *ldv_func_arg1 ) { { { ldv_linux_kernel_locking_spinlock_spin_lock_frame_rcvd_lock_of_asd_sas_phy(); __ldv_linux_kernel_locking_spinlock_spin_lock(ldv_func_arg1); } return; } } __inline static void ldv_spin_unlock_irqrestore_160(spinlock_t *lock , unsigned long flags ) { { { ldv_linux_kernel_locking_spinlock_spin_unlock_frame_rcvd_lock_of_asd_sas_phy(); spin_unlock_irqrestore(lock, flags); } return; } } static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_161(spinlock_t *ldv_func_arg1 ) { { { ldv_linux_kernel_locking_spinlock_spin_lock_frame_rcvd_lock_of_asd_sas_phy(); __ldv_linux_kernel_locking_spinlock_spin_lock(ldv_func_arg1); } return; } } static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_163(spinlock_t *ldv_func_arg1 ) { { { ldv_linux_kernel_locking_spinlock_spin_lock_task_state_lock_of_sas_task(); __ldv_linux_kernel_locking_spinlock_spin_lock(ldv_func_arg1); } return; } } static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_165(spinlock_t *ldv_func_arg1 ) { { { ldv_linux_kernel_locking_spinlock_spin_lock_sas_prim_lock_of_asd_sas_phy(); __ldv_linux_kernel_locking_spinlock_spin_lock(ldv_func_arg1); } return; } } __inline static void ldv_spin_unlock_irqrestore_166(spinlock_t *lock , unsigned long flags ) { { { ldv_linux_kernel_locking_spinlock_spin_unlock_sas_prim_lock_of_asd_sas_phy(); spin_unlock_irqrestore(lock, flags); } return; } } static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_167(spinlock_t *ldv_func_arg1 ) { { { ldv_linux_kernel_locking_spinlock_spin_lock_sas_prim_lock_of_asd_sas_phy(); __ldv_linux_kernel_locking_spinlock_spin_lock(ldv_func_arg1); } return; } } static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_169(spinlock_t *ldv_func_arg1 ) { { { ldv_linux_kernel_locking_spinlock_spin_lock_sas_prim_lock_of_asd_sas_phy(); __ldv_linux_kernel_locking_spinlock_spin_lock(ldv_func_arg1); } return; } } static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_171(spinlock_t *ldv_func_arg1 ) { { { ldv_linux_kernel_locking_spinlock_spin_lock_lock_of_pm8001_hba_info(); __ldv_linux_kernel_locking_spinlock_spin_lock(ldv_func_arg1); } return; } } static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_173(spinlock_t *ldv_func_arg1 ) { { { ldv_linux_kernel_locking_spinlock_spin_lock_task_state_lock_of_sas_task(); __ldv_linux_kernel_locking_spinlock_spin_lock(ldv_func_arg1); } return; } } static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_100___1(spinlock_t *ldv_func_arg1 ) ; static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_103(spinlock_t *ldv_func_arg1 ) ; static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_106(spinlock_t *ldv_func_arg1 ) ; static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_109(spinlock_t *ldv_func_arg1 ) ; static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_112___0(spinlock_t *ldv_func_arg1 ) ; static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_115(spinlock_t *ldv_func_arg1 ) ; static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_117(spinlock_t *ldv_func_arg1 ) ; static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_119(spinlock_t *ldv_func_arg1 ) ; static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_121(spinlock_t *ldv_func_arg1 ) ; static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_123(spinlock_t *ldv_func_arg1 ) ; static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_125___0(spinlock_t *ldv_func_arg1 ) ; static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_127(spinlock_t *ldv_func_arg1 ) ; __inline static void ldv_spin_lock_99(spinlock_t *lock ) ; __inline static void ldv_spin_unlock_98(spinlock_t *lock ) ; __inline static void ldv_spin_unlock_irqrestore_135(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_135(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_135(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_135(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_135(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_135(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_135(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_135(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_135(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_135(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_160(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_160(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_166(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_166(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_166(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_109(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_135(spinlock_t *lock , unsigned long flags ) ; __inline static void ldv_spin_unlock_irqrestore_135(spinlock_t *lock , unsigned long flags ) ; __inline static void *phys_to_virt(phys_addr_t address ) { { return ((void *)((unsigned long )address + 0xffff880000000000UL)); } } __inline static void *kzalloc(size_t size , gfp_t flags ) ; __inline static int dma_map_sg_attrs___1(struct device *dev , struct scatterlist *sg , int nents , enum dma_data_direction dir , struct dma_attrs *attrs ) { struct dma_map_ops *ops ; struct dma_map_ops *tmp ; int i ; int ents ; struct scatterlist *s ; void *tmp___0 ; int tmp___1 ; long tmp___2 ; { { tmp = get_dma_ops(dev); ops = tmp; i = 0; s = sg; } goto ldv_26233; ldv_26232: { tmp___0 = sg_virt(s); kmemcheck_mark_initialized(tmp___0, s->length); i = i + 1; s = sg_next(s); } ldv_26233: ; if (i < nents) { goto ldv_26232; } else { } { tmp___1 = valid_dma_direction((int )dir); tmp___2 = ldv__builtin_expect(tmp___1 == 0, 0L); } if (tmp___2 != 0L) { { __asm__ volatile ("1:\tud2\n.pushsection __bug_table,\"a\"\n2:\t.long 1b - 2b, %c0 - 2b\n\t.word %c1, 0\n\t.org 2b+%c2\n.popsection": : "i" ((char *)"include/asm-generic/dma-mapping-common.h"), "i" (52), "i" (12UL)); __builtin_unreachable(); } } else { } { ents = (*(ops->map_sg))(dev, sg, nents, dir, attrs); debug_dma_map_sg(dev, sg, nents, ents, (int )dir); } return (ents); } } __inline static void pm8001_ccb_task_free_done___0(struct pm8001_hba_info *pm8001_ha , struct sas_task *task , struct pm8001_ccb_info *ccb , u32 ccb_idx ) { { { pm8001_ccb_task_free(pm8001_ha, task, ccb, ccb_idx); __asm__ volatile ("mfence": : : "memory"); ldv_spin_unlock_98(& pm8001_ha->lock); (*(task->task_done))(task); ldv_spin_lock_99(& pm8001_ha->lock); } return; } } int pm80xx_bar4_shift(struct pm8001_hba_info *pm8001_ha , u32 shift_value ) { u32 reg_val ; unsigned long start ; long tmp ; { { pm8001_cw32(pm8001_ha, 0U, 4112U, shift_value); start = (unsigned long )jiffies + 250UL; } ldv_46303: { reg_val = pm8001_cr32(pm8001_ha, 0U, 4112U); } if (reg_val != shift_value && (long )((unsigned long )jiffies - start) < 0L) { goto ldv_46303; } else { } if (reg_val != shift_value) { { tmp = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:TIMEOUT:MEMBASE_II_SHIFT_REGISTER = 0x%x\n", "pm80xx_bar4_shift", 63, reg_val); } } else { } return (-1); } else { } return (0); } } void pm80xx_pci_mem_copy(struct pm8001_hba_info *pm8001_ha , u32 soffset , void const *destination , u32 dw_count , u32 bus_base_number ) { u32 index ; u32 value ; u32 offset ; u32 *destination1 ; { destination1 = (u32 *)destination; index = 0U; goto ldv_46318; ldv_46317: offset = soffset + index / 4U; if (offset <= 65535U) { { value = pm8001_cr32(pm8001_ha, bus_base_number, offset); *destination1 = value; } } else { } index = index + 4U; destination1 = destination1 + 1; ldv_46318: ; if (index < dw_count) { goto ldv_46317; } else { } return; } } ssize_t pm80xx_get_fatal_dump(struct device *cdev , struct device_attribute *attr , char *buf ) { struct Scsi_Host *shost ; struct device const *__mptr ; struct sas_ha_struct *sha ; struct pm8001_hba_info *pm8001_ha ; void *fatal_table_address ; u32 accum_len ; u32 reg_val ; u32 index ; u32 *temp ; unsigned long start ; u8 *direct_data ; char *fatal_error_data ; int tmp ; long tmp___0 ; long tmp___1 ; long tmp___2 ; int tmp___3 ; int tmp___4 ; int tmp___5 ; int tmp___6 ; int tmp___7 ; int tmp___8 ; int tmp___9 ; long tmp___10 ; int tmp___11 ; u32 tmp___12 ; { __mptr = (struct device const *)cdev; shost = (struct Scsi_Host *)__mptr + 0xfffffffffffff6c8UL; sha = *((struct sas_ha_struct **)(& shost->hostdata)); pm8001_ha = (struct pm8001_hba_info *)sha->lldd_ha; fatal_table_address = pm8001_ha->fatal_tbl_addr; fatal_error_data = buf; pm8001_ha->forensic_info.__annonCompField96.data_buf.direct_data = (void *)buf; if (pm8001_ha->chip_id == 0U) { { tmp = sprintf((char *)pm8001_ha->forensic_info.__annonCompField96.data_buf.direct_data, "Not supported for SPC controller"); pm8001_ha->forensic_info.__annonCompField96.data_buf.direct_data = pm8001_ha->forensic_info.__annonCompField96.data_buf.direct_data + (unsigned long )tmp; } return ((long )pm8001_ha->forensic_info.__annonCompField96.data_buf.direct_data - (long )buf); } else { } if (pm8001_ha->forensic_info.__annonCompField96.data_buf.direct_offset == 0U) { { tmp___0 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___0 != 0L) { { printk("\016pm80xx %s %d:forensic_info TYPE_NON_FATAL..............\n", "pm80xx_get_fatal_dump", 109); } } else { } { direct_data = (u8 *)fatal_error_data; pm8001_ha->forensic_info.data_type = 4U; pm8001_ha->forensic_info.__annonCompField96.data_buf.direct_len = 1024U; pm8001_ha->forensic_info.__annonCompField96.data_buf.read_len = 0U; pm8001_ha->forensic_info.__annonCompField96.data_buf.direct_data = (void *)direct_data; pm8001_cw32(pm8001_ha, 0U, 4112U, pm8001_ha->fatal_forensic_shift_offset); pm8001_ha->forensic_last_offset = 0U; pm8001_ha->forensic_fatal_step = 0U; pm8001_ha->fatal_bar_loc = 0U; } } else { } { accum_len = pm8001_mr32(fatal_table_address, 20U); tmp___1 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___1 != 0L) { { printk("\016pm80xx %s %d:accum_len 0x%x\n", "pm80xx_get_fatal_dump", 130, accum_len); } } else { } if (accum_len == 4294967295U) { { tmp___2 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___2 != 0L) { { printk("\016pm80xx %s %d:Possible PCI issue 0x%x not expected\n", "pm80xx_get_fatal_dump", 134, accum_len); } } else { } return (-5L); } else { } if (accum_len - 1U > 1048574U) { { tmp___3 = sprintf((char *)pm8001_ha->forensic_info.__annonCompField96.data_buf.direct_data, "%08x ", 4294967295U); pm8001_ha->forensic_info.__annonCompField96.data_buf.direct_data = pm8001_ha->forensic_info.__annonCompField96.data_buf.direct_data + (unsigned long )tmp___3; } return ((long )pm8001_ha->forensic_info.__annonCompField96.data_buf.direct_data - (long )buf); } else { } temp = (u32 *)pm8001_ha->memoryMap.region[6].virt_ptr; if (pm8001_ha->forensic_fatal_step == 0U) { moreData: ; if ((unsigned long )pm8001_ha->forensic_info.__annonCompField96.data_buf.direct_data != (unsigned long )((void *)0)) { { pm80xx_pci_mem_copy(pm8001_ha, pm8001_ha->fatal_bar_loc, (void const *)pm8001_ha->memoryMap.region[6].virt_ptr, pm8001_ha->forensic_info.__annonCompField96.data_buf.direct_len, 1U); } } else { } pm8001_ha->fatal_bar_loc = pm8001_ha->fatal_bar_loc + pm8001_ha->forensic_info.__annonCompField96.data_buf.direct_len; pm8001_ha->forensic_info.__annonCompField96.data_buf.direct_offset = pm8001_ha->forensic_info.__annonCompField96.data_buf.direct_offset + pm8001_ha->forensic_info.__annonCompField96.data_buf.direct_len; pm8001_ha->forensic_last_offset = pm8001_ha->forensic_last_offset + pm8001_ha->forensic_info.__annonCompField96.data_buf.direct_len; pm8001_ha->forensic_info.__annonCompField96.data_buf.read_len = pm8001_ha->forensic_info.__annonCompField96.data_buf.direct_len; if (pm8001_ha->forensic_last_offset >= accum_len) { { tmp___4 = sprintf((char *)pm8001_ha->forensic_info.__annonCompField96.data_buf.direct_data, "%08x ", 3); pm8001_ha->forensic_info.__annonCompField96.data_buf.direct_data = pm8001_ha->forensic_info.__annonCompField96.data_buf.direct_data + (unsigned long )tmp___4; index = 0U; } goto ldv_46341; ldv_46340: { tmp___5 = sprintf((char *)pm8001_ha->forensic_info.__annonCompField96.data_buf.direct_data, "%08x ", *(temp + (unsigned long )index)); pm8001_ha->forensic_info.__annonCompField96.data_buf.direct_data = pm8001_ha->forensic_info.__annonCompField96.data_buf.direct_data + (unsigned long )tmp___5; index = index + 1U; } ldv_46341: ; if (index <= 255U) { goto ldv_46340; } else { } pm8001_ha->fatal_bar_loc = 0U; pm8001_ha->forensic_fatal_step = 1U; pm8001_ha->fatal_forensic_shift_offset = 0U; pm8001_ha->forensic_last_offset = 0U; return ((long )pm8001_ha->forensic_info.__annonCompField96.data_buf.direct_data - (long )buf); } else { } if (pm8001_ha->fatal_bar_loc <= 65535U) { { tmp___6 = sprintf((char *)pm8001_ha->forensic_info.__annonCompField96.data_buf.direct_data, "%08x ", 2); pm8001_ha->forensic_info.__annonCompField96.data_buf.direct_data = pm8001_ha->forensic_info.__annonCompField96.data_buf.direct_data + (unsigned long )tmp___6; index = 0U; } goto ldv_46344; ldv_46343: { tmp___7 = sprintf((char *)pm8001_ha->forensic_info.__annonCompField96.data_buf.direct_data, "%08x ", *(temp + (unsigned long )index)); pm8001_ha->forensic_info.__annonCompField96.data_buf.direct_data = pm8001_ha->forensic_info.__annonCompField96.data_buf.direct_data + (unsigned long )tmp___7; index = index + 1U; } ldv_46344: ; if (index <= 255U) { goto ldv_46343; } else { } return ((long )pm8001_ha->forensic_info.__annonCompField96.data_buf.direct_data - (long )buf); } else { } { tmp___8 = sprintf((char *)pm8001_ha->forensic_info.__annonCompField96.data_buf.direct_data, "%08x ", 2); pm8001_ha->forensic_info.__annonCompField96.data_buf.direct_data = pm8001_ha->forensic_info.__annonCompField96.data_buf.direct_data + (unsigned long )tmp___8; index = 0U; } goto ldv_46347; ldv_46346: { tmp___9 = sprintf((char *)pm8001_ha->forensic_info.__annonCompField96.data_buf.direct_data, "%08x ", *(temp + (unsigned long )index)); pm8001_ha->forensic_info.__annonCompField96.data_buf.direct_data = pm8001_ha->forensic_info.__annonCompField96.data_buf.direct_data + (unsigned long )tmp___9; index = index + 1U; } ldv_46347: ; if (index <= 255U) { goto ldv_46346; } else { } { pm8001_ha->fatal_forensic_shift_offset = pm8001_ha->fatal_forensic_shift_offset + 256U; pm8001_cw32(pm8001_ha, 0U, 4112U, pm8001_ha->fatal_forensic_shift_offset); pm8001_ha->fatal_bar_loc = 0U; } return ((long )pm8001_ha->forensic_info.__annonCompField96.data_buf.direct_data - (long )buf); } else { } if (pm8001_ha->forensic_fatal_step == 1U) { { pm8001_ha->fatal_forensic_shift_offset = 0U; pm8001_cw32(pm8001_ha, 0U, 4112U, pm8001_ha->fatal_forensic_shift_offset); pm8001_mw32(fatal_table_address, 12U, 1U); start = (unsigned long )jiffies + 500UL; } ldv_46355: { reg_val = pm8001_mr32(fatal_table_address, 12U); } if (reg_val != 0U && (long )((unsigned long )jiffies - start) < 0L) { goto ldv_46355; } else { } if (reg_val != 0U) { { tmp___10 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___10 != 0L) { { printk("\016pm80xx %s %d:TIMEOUT:MEMBASE_II_SHIFT_REGISTER = 0x%x\n", "pm80xx_get_fatal_dump", 235, reg_val); } } else { } return (-5L); } else { } { pm8001_ha->forensic_fatal_step = 0U; tmp___12 = pm8001_mr32(fatal_table_address, 16U); } if (tmp___12 != 3U) { { pm8001_mw32(fatal_table_address, 12U, 0U); } goto moreData; } else { { tmp___11 = sprintf((char *)pm8001_ha->forensic_info.__annonCompField96.data_buf.direct_data, "%08x ", 4); pm8001_ha->forensic_info.__annonCompField96.data_buf.direct_data = pm8001_ha->forensic_info.__annonCompField96.data_buf.direct_data + (unsigned long )tmp___11; pm8001_ha->forensic_info.__annonCompField96.data_buf.read_len = 4294967295U; pm8001_ha->forensic_info.__annonCompField96.data_buf.direct_len = 0U; pm8001_ha->forensic_info.__annonCompField96.data_buf.direct_offset = 0U; pm8001_ha->forensic_info.__annonCompField96.data_buf.read_len = 0U; } } } else { } return ((long )pm8001_ha->forensic_info.__annonCompField96.data_buf.direct_data - (long )buf); } } static void read_main_config_table___0(struct pm8001_hba_info *pm8001_ha ) { void *address ; { { address = pm8001_ha->main_cfg_tbl_addr; pm8001_ha->main_cfg_tbl.pm80xx_tbl.signature = pm8001_mr32(address, 0U); pm8001_ha->main_cfg_tbl.pm80xx_tbl.interface_rev = pm8001_mr32(address, 4U); pm8001_ha->main_cfg_tbl.pm80xx_tbl.firmware_rev = pm8001_mr32(address, 8U); pm8001_ha->main_cfg_tbl.pm80xx_tbl.max_out_io = pm8001_mr32(address, 12U); pm8001_ha->main_cfg_tbl.pm80xx_tbl.max_sgl = pm8001_mr32(address, 16U); pm8001_ha->main_cfg_tbl.pm80xx_tbl.ctrl_cap_flag = pm8001_mr32(address, 20U); pm8001_ha->main_cfg_tbl.pm80xx_tbl.gst_offset = pm8001_mr32(address, 24U); pm8001_ha->main_cfg_tbl.pm80xx_tbl.inbound_queue_offset = pm8001_mr32(address, 28U); pm8001_ha->main_cfg_tbl.pm80xx_tbl.outbound_queue_offset = pm8001_mr32(address, 32U); pm8001_ha->main_cfg_tbl.pm80xx_tbl.fatal_err_dump_offset0 = pm8001_mr32(address, 116U); pm8001_ha->main_cfg_tbl.pm80xx_tbl.fatal_err_dump_length0 = pm8001_mr32(address, 120U); pm8001_ha->main_cfg_tbl.pm80xx_tbl.fatal_err_dump_offset1 = pm8001_mr32(address, 124U); pm8001_ha->main_cfg_tbl.pm80xx_tbl.fatal_err_dump_length1 = pm8001_mr32(address, 128U); pm8001_ha->main_cfg_tbl.pm80xx_tbl.gpio_led_mapping = pm8001_mr32(address, 132U); pm8001_ha->main_cfg_tbl.pm80xx_tbl.analog_setup_table_offset = pm8001_mr32(address, 136U); pm8001_ha->main_cfg_tbl.pm80xx_tbl.int_vec_table_offset = pm8001_mr32(address, 140U); pm8001_ha->main_cfg_tbl.pm80xx_tbl.phy_attr_table_offset = pm8001_mr32(address, 144U); } return; } } static void read_general_status_table___0(struct pm8001_hba_info *pm8001_ha ) { void *address ; { { address = pm8001_ha->general_stat_tbl_addr; pm8001_ha->gs_tbl.pm80xx_tbl.gst_len_mpistate = pm8001_mr32(address, 0U); pm8001_ha->gs_tbl.pm80xx_tbl.iq_freeze_state0 = pm8001_mr32(address, 4U); pm8001_ha->gs_tbl.pm80xx_tbl.iq_freeze_state1 = pm8001_mr32(address, 8U); pm8001_ha->gs_tbl.pm80xx_tbl.msgu_tcnt = pm8001_mr32(address, 12U); pm8001_ha->gs_tbl.pm80xx_tbl.iop_tcnt = pm8001_mr32(address, 16U); pm8001_ha->gs_tbl.pm80xx_tbl.gpio_input_val = pm8001_mr32(address, 56U); pm8001_ha->gs_tbl.pm80xx_tbl.recover_err_info[0] = pm8001_mr32(address, 68U); pm8001_ha->gs_tbl.pm80xx_tbl.recover_err_info[1] = pm8001_mr32(address, 72U); pm8001_ha->gs_tbl.pm80xx_tbl.recover_err_info[2] = pm8001_mr32(address, 76U); pm8001_ha->gs_tbl.pm80xx_tbl.recover_err_info[3] = pm8001_mr32(address, 80U); pm8001_ha->gs_tbl.pm80xx_tbl.recover_err_info[4] = pm8001_mr32(address, 84U); pm8001_ha->gs_tbl.pm80xx_tbl.recover_err_info[5] = pm8001_mr32(address, 88U); pm8001_ha->gs_tbl.pm80xx_tbl.recover_err_info[6] = pm8001_mr32(address, 92U); pm8001_ha->gs_tbl.pm80xx_tbl.recover_err_info[7] = pm8001_mr32(address, 96U); } return; } } static void read_phy_attr_table(struct pm8001_hba_info *pm8001_ha ) { void *address ; { { address = pm8001_ha->pspa_q_tbl_addr; pm8001_ha->phy_attr_table.phystart1_16[0] = pm8001_mr32(address, 0U); pm8001_ha->phy_attr_table.phystart1_16[1] = pm8001_mr32(address, 8U); pm8001_ha->phy_attr_table.phystart1_16[2] = pm8001_mr32(address, 16U); pm8001_ha->phy_attr_table.phystart1_16[3] = pm8001_mr32(address, 24U); pm8001_ha->phy_attr_table.phystart1_16[4] = pm8001_mr32(address, 32U); pm8001_ha->phy_attr_table.phystart1_16[5] = pm8001_mr32(address, 40U); pm8001_ha->phy_attr_table.phystart1_16[6] = pm8001_mr32(address, 48U); pm8001_ha->phy_attr_table.phystart1_16[7] = pm8001_mr32(address, 56U); pm8001_ha->phy_attr_table.phystart1_16[8] = pm8001_mr32(address, 64U); pm8001_ha->phy_attr_table.phystart1_16[9] = pm8001_mr32(address, 72U); pm8001_ha->phy_attr_table.phystart1_16[10] = pm8001_mr32(address, 80U); pm8001_ha->phy_attr_table.phystart1_16[11] = pm8001_mr32(address, 88U); pm8001_ha->phy_attr_table.phystart1_16[12] = pm8001_mr32(address, 96U); pm8001_ha->phy_attr_table.phystart1_16[13] = pm8001_mr32(address, 104U); pm8001_ha->phy_attr_table.phystart1_16[14] = pm8001_mr32(address, 112U); pm8001_ha->phy_attr_table.phystart1_16[15] = pm8001_mr32(address, 120U); pm8001_ha->phy_attr_table.outbound_hw_event_pid1_16[0] = pm8001_mr32(address, 4U); pm8001_ha->phy_attr_table.outbound_hw_event_pid1_16[1] = pm8001_mr32(address, 12U); pm8001_ha->phy_attr_table.outbound_hw_event_pid1_16[2] = pm8001_mr32(address, 20U); pm8001_ha->phy_attr_table.outbound_hw_event_pid1_16[3] = pm8001_mr32(address, 28U); pm8001_ha->phy_attr_table.outbound_hw_event_pid1_16[4] = pm8001_mr32(address, 36U); pm8001_ha->phy_attr_table.outbound_hw_event_pid1_16[5] = pm8001_mr32(address, 44U); pm8001_ha->phy_attr_table.outbound_hw_event_pid1_16[6] = pm8001_mr32(address, 52U); pm8001_ha->phy_attr_table.outbound_hw_event_pid1_16[7] = pm8001_mr32(address, 60U); pm8001_ha->phy_attr_table.outbound_hw_event_pid1_16[8] = pm8001_mr32(address, 68U); pm8001_ha->phy_attr_table.outbound_hw_event_pid1_16[9] = pm8001_mr32(address, 76U); pm8001_ha->phy_attr_table.outbound_hw_event_pid1_16[10] = pm8001_mr32(address, 84U); pm8001_ha->phy_attr_table.outbound_hw_event_pid1_16[11] = pm8001_mr32(address, 92U); pm8001_ha->phy_attr_table.outbound_hw_event_pid1_16[12] = pm8001_mr32(address, 100U); pm8001_ha->phy_attr_table.outbound_hw_event_pid1_16[13] = pm8001_mr32(address, 108U); pm8001_ha->phy_attr_table.outbound_hw_event_pid1_16[14] = pm8001_mr32(address, 116U); pm8001_ha->phy_attr_table.outbound_hw_event_pid1_16[15] = pm8001_mr32(address, 124U); } return; } } static void read_inbnd_queue_table___0(struct pm8001_hba_info *pm8001_ha ) { int i ; void *address ; u32 offset ; u32 tmp ; { address = pm8001_ha->inbnd_q_tbl_addr; i = 0; goto ldv_46376; ldv_46375: { offset = (u32 )(i * 32); tmp = pm8001_mr32(address, offset + 20U); pm8001_ha->inbnd_q_tbl[i].pi_pci_bar = get_pci_bar_index(tmp); pm8001_ha->inbnd_q_tbl[i].pi_offset = pm8001_mr32(address, offset + 24U); i = i + 1; } ldv_46376: ; if (i <= 0) { goto ldv_46375; } else { } return; } } static void read_outbnd_queue_table___0(struct pm8001_hba_info *pm8001_ha ) { int i ; void *address ; u32 offset ; u32 tmp ; { address = pm8001_ha->outbnd_q_tbl_addr; i = 0; goto ldv_46385; ldv_46384: { offset = (u32 )(i * 36); tmp = pm8001_mr32(address, offset + 20U); pm8001_ha->outbnd_q_tbl[i].ci_pci_bar = get_pci_bar_index(tmp); pm8001_ha->outbnd_q_tbl[i].ci_offset = pm8001_mr32(address, offset + 24U); i = i + 1; } ldv_46385: ; if (i <= 3) { goto ldv_46384; } else { } return; } } static void init_default_table_values___0(struct pm8001_hba_info *pm8001_ha ) { int i ; u32 offsetib ; u32 offsetob ; void *addressib ; void *addressob ; u32 tmp ; u32 tmp___0 ; { addressib = pm8001_ha->inbnd_q_tbl_addr; addressob = pm8001_ha->outbnd_q_tbl_addr; pm8001_ha->main_cfg_tbl.pm80xx_tbl.upper_event_log_addr = pm8001_ha->memoryMap.region[0].phys_addr_hi; pm8001_ha->main_cfg_tbl.pm80xx_tbl.lower_event_log_addr = pm8001_ha->memoryMap.region[0].phys_addr_lo; pm8001_ha->main_cfg_tbl.pm80xx_tbl.event_log_size = 131072U; pm8001_ha->main_cfg_tbl.pm80xx_tbl.event_log_severity = 1U; pm8001_ha->main_cfg_tbl.pm80xx_tbl.upper_pcs_event_log_addr = pm8001_ha->memoryMap.region[1].phys_addr_hi; pm8001_ha->main_cfg_tbl.pm80xx_tbl.lower_pcs_event_log_addr = pm8001_ha->memoryMap.region[1].phys_addr_lo; pm8001_ha->main_cfg_tbl.pm80xx_tbl.pcs_event_log_size = 131072U; pm8001_ha->main_cfg_tbl.pm80xx_tbl.pcs_event_log_severity = 1U; pm8001_ha->main_cfg_tbl.pm80xx_tbl.fatal_err_interrupt = 1U; pm8001_ha->main_cfg_tbl.pm80xx_tbl.crc_core_dump = 65536U; i = 0; goto ldv_46396; ldv_46395: { pm8001_ha->inbnd_q_tbl[i].element_pri_size_cnt = (pm8001_ha->iomb_size << 16) | 1024U; pm8001_ha->inbnd_q_tbl[i].upper_base_addr = pm8001_ha->memoryMap.region[i + 6].phys_addr_hi; pm8001_ha->inbnd_q_tbl[i].lower_base_addr = pm8001_ha->memoryMap.region[i + 6].phys_addr_lo; pm8001_ha->inbnd_q_tbl[i].base_virt = pm8001_ha->memoryMap.region[i + 6].virt_ptr; pm8001_ha->inbnd_q_tbl[i].total_length = pm8001_ha->memoryMap.region[i + 6].total_len; pm8001_ha->inbnd_q_tbl[i].ci_upper_base_addr = pm8001_ha->memoryMap.region[i + 7].phys_addr_hi; pm8001_ha->inbnd_q_tbl[i].ci_lower_base_addr = pm8001_ha->memoryMap.region[i + 7].phys_addr_lo; pm8001_ha->inbnd_q_tbl[i].ci_virt = pm8001_ha->memoryMap.region[i + 7].virt_ptr; offsetib = (u32 )(i * 32); tmp = pm8001_mr32(addressib, offsetib + 20U); pm8001_ha->inbnd_q_tbl[i].pi_pci_bar = get_pci_bar_index(tmp); pm8001_ha->inbnd_q_tbl[i].pi_offset = pm8001_mr32(addressib, offsetib + 24U); pm8001_ha->inbnd_q_tbl[i].producer_idx = 0U; pm8001_ha->inbnd_q_tbl[i].consumer_index = 0U; i = i + 1; } ldv_46396: ; if (i <= 0) { goto ldv_46395; } else { } i = 0; goto ldv_46399; ldv_46398: { pm8001_ha->outbnd_q_tbl[i].element_size_cnt = (pm8001_ha->iomb_size << 16) | 1073742848U; pm8001_ha->outbnd_q_tbl[i].upper_base_addr = pm8001_ha->memoryMap.region[i + 8].phys_addr_hi; pm8001_ha->outbnd_q_tbl[i].lower_base_addr = pm8001_ha->memoryMap.region[i + 8].phys_addr_lo; pm8001_ha->outbnd_q_tbl[i].base_virt = pm8001_ha->memoryMap.region[i + 8].virt_ptr; pm8001_ha->outbnd_q_tbl[i].total_length = pm8001_ha->memoryMap.region[i + 8].total_len; pm8001_ha->outbnd_q_tbl[i].pi_upper_base_addr = pm8001_ha->memoryMap.region[i + 12].phys_addr_hi; pm8001_ha->outbnd_q_tbl[i].pi_lower_base_addr = pm8001_ha->memoryMap.region[i + 12].phys_addr_lo; pm8001_ha->outbnd_q_tbl[i].interrup_vec_cnt_delay = (u32 )(i << 24); pm8001_ha->outbnd_q_tbl[i].pi_virt = pm8001_ha->memoryMap.region[i + 12].virt_ptr; offsetob = (u32 )(i * 36); tmp___0 = pm8001_mr32(addressob, offsetob + 20U); pm8001_ha->outbnd_q_tbl[i].ci_pci_bar = get_pci_bar_index(tmp___0); pm8001_ha->outbnd_q_tbl[i].ci_offset = pm8001_mr32(addressob, offsetob + 24U); pm8001_ha->outbnd_q_tbl[i].consumer_idx = 0U; pm8001_ha->outbnd_q_tbl[i].producer_index = 0U; i = i + 1; } ldv_46399: ; if (i <= 3) { goto ldv_46398; } else { } return; } } static void update_main_config_table___0(struct pm8001_hba_info *pm8001_ha ) { void *address ; { { address = pm8001_ha->main_cfg_tbl_addr; pm8001_mw32(address, 36U, pm8001_ha->main_cfg_tbl.pm80xx_tbl.inbound_q_nppd_hppd); pm8001_mw32(address, 80U, pm8001_ha->main_cfg_tbl.pm80xx_tbl.upper_event_log_addr); pm8001_mw32(address, 84U, pm8001_ha->main_cfg_tbl.pm80xx_tbl.lower_event_log_addr); pm8001_mw32(address, 88U, pm8001_ha->main_cfg_tbl.pm80xx_tbl.event_log_size); pm8001_mw32(address, 92U, pm8001_ha->main_cfg_tbl.pm80xx_tbl.event_log_severity); pm8001_mw32(address, 96U, pm8001_ha->main_cfg_tbl.pm80xx_tbl.upper_pcs_event_log_addr); pm8001_mw32(address, 100U, pm8001_ha->main_cfg_tbl.pm80xx_tbl.lower_pcs_event_log_addr); pm8001_mw32(address, 104U, pm8001_ha->main_cfg_tbl.pm80xx_tbl.pcs_event_log_size); pm8001_mw32(address, 108U, pm8001_ha->main_cfg_tbl.pm80xx_tbl.pcs_event_log_severity); pm8001_mw32(address, 112U, pm8001_ha->main_cfg_tbl.pm80xx_tbl.fatal_err_interrupt); pm8001_mw32(address, 72U, pm8001_ha->main_cfg_tbl.pm80xx_tbl.crc_core_dump); pm8001_ha->main_cfg_tbl.pm80xx_tbl.gpio_led_mapping = pm8001_ha->main_cfg_tbl.pm80xx_tbl.gpio_led_mapping & 3489660927U; pm8001_ha->main_cfg_tbl.pm80xx_tbl.gpio_led_mapping = pm8001_ha->main_cfg_tbl.pm80xx_tbl.gpio_led_mapping | 536870912U; pm8001_mw32(address, 132U, pm8001_ha->main_cfg_tbl.pm80xx_tbl.gpio_led_mapping); pm8001_mw32(address, 148U, pm8001_ha->main_cfg_tbl.pm80xx_tbl.port_recovery_timer); pm8001_mw32(address, 152U, pm8001_ha->main_cfg_tbl.pm80xx_tbl.interrupt_reassertion_delay); } return; } } static void update_inbnd_queue_table___0(struct pm8001_hba_info *pm8001_ha , int number ) { void *address ; u16 offset ; { { address = pm8001_ha->inbnd_q_tbl_addr; offset = (unsigned int )((u16 )number) * 32U; pm8001_mw32(address, (u32 )offset, pm8001_ha->inbnd_q_tbl[number].element_pri_size_cnt); pm8001_mw32(address, (u32 )((int )offset + 4), pm8001_ha->inbnd_q_tbl[number].upper_base_addr); pm8001_mw32(address, (u32 )((int )offset + 8), pm8001_ha->inbnd_q_tbl[number].lower_base_addr); pm8001_mw32(address, (u32 )((int )offset + 12), pm8001_ha->inbnd_q_tbl[number].ci_upper_base_addr); pm8001_mw32(address, (u32 )((int )offset + 16), pm8001_ha->inbnd_q_tbl[number].ci_lower_base_addr); } return; } } static void update_outbnd_queue_table___0(struct pm8001_hba_info *pm8001_ha , int number ) { void *address ; u16 offset ; { { address = pm8001_ha->outbnd_q_tbl_addr; offset = (unsigned int )((u16 )number) * 36U; pm8001_mw32(address, (u32 )offset, pm8001_ha->outbnd_q_tbl[number].element_size_cnt); pm8001_mw32(address, (u32 )((int )offset + 4), pm8001_ha->outbnd_q_tbl[number].upper_base_addr); pm8001_mw32(address, (u32 )((int )offset + 8), pm8001_ha->outbnd_q_tbl[number].lower_base_addr); pm8001_mw32(address, (u32 )((int )offset + 12), pm8001_ha->outbnd_q_tbl[number].pi_upper_base_addr); pm8001_mw32(address, (u32 )((int )offset + 16), pm8001_ha->outbnd_q_tbl[number].pi_lower_base_addr); pm8001_mw32(address, (u32 )((int )offset + 28), pm8001_ha->outbnd_q_tbl[number].interrup_vec_cnt_delay); } return; } } static int mpi_init_check___0(struct pm8001_hba_info *pm8001_ha ) { u32 max_wait_count ; u32 value ; u32 gst_len_mpistate ; { { pm8001_cw32(pm8001_ha, 0U, 0U, 1U); } if (((unsigned int )(pm8001_ha->pdev)->device == 32884U || (unsigned int )(pm8001_ha->pdev)->device == 32886U) || (unsigned int )(pm8001_ha->pdev)->device == 32887U) { max_wait_count = 4000000U; } else { max_wait_count = 2000000U; } ldv_46423: { __const_udelay(4295UL); value = pm8001_cr32(pm8001_ha, 0U, 0U); value = value & 1U; } if (value != 0U) { max_wait_count = max_wait_count - 1U; if (max_wait_count != 0U) { goto ldv_46423; } else { goto ldv_46424; } } else { } ldv_46424: ; if (max_wait_count == 0U) { return (-1); } else { } max_wait_count = 100000U; ldv_46425: { __const_udelay(4295UL); gst_len_mpistate = pm8001_mr32(pm8001_ha->general_stat_tbl_addr, 0U); } if ((gst_len_mpistate & 7U) != 1U) { max_wait_count = max_wait_count - 1U; if (max_wait_count != 0U) { goto ldv_46425; } else { goto ldv_46426; } } else { } ldv_46426: ; if (max_wait_count == 0U) { return (-1); } else { } gst_len_mpistate = gst_len_mpistate >> 16; if (gst_len_mpistate != 0U) { return (-1); } else { } return (0); } } static int check_fw_ready___0(struct pm8001_hba_info *pm8001_ha ) { u32 value ; u32 max_wait_count ; u32 max_wait_time ; int ret ; long tmp ; long tmp___0 ; long tmp___1 ; long tmp___2 ; { ret = 0; max_wait_count = 100000U; max_wait_time = max_wait_count; ldv_46434: { __const_udelay(4295UL); value = pm8001_cr32(pm8001_ha, 0U, 72U); } if (value == 4294967295U) { max_wait_count = max_wait_count - 1U; if (max_wait_count != 0U) { goto ldv_46434; } else { goto ldv_46435; } } else { } ldv_46435: max_wait_count = 1000000U; max_wait_time = max_wait_count; ldv_46436: { __const_udelay(4295UL); value = pm8001_cr32(pm8001_ha, 0U, 72U); } if ((value & 12U) != 12U) { max_wait_count = max_wait_count - 1U; if (max_wait_count != 0U) { goto ldv_46436; } else { goto ldv_46437; } } else { } ldv_46437: ; if (max_wait_count == 0U) { ret = -1; } else { { tmp = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d: ila ready status in %d millisec\n", "check_fw_ready", 711, max_wait_time - max_wait_count); } } else { } } max_wait_count = 1800000U; max_wait_time = max_wait_count; ldv_46439: { __const_udelay(4295UL); value = pm8001_cr32(pm8001_ha, 0U, 72U); } if ((value & 3U) != 3U) { max_wait_count = max_wait_count - 1U; if (max_wait_count != 0U) { goto ldv_46439; } else { goto ldv_46440; } } else { } ldv_46440: ; if (max_wait_count == 0U) { ret = -1; } else { { tmp___0 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___0 != 0L) { { printk("\016pm80xx %s %d: raae ready status in %d millisec\n", "check_fw_ready", 726, max_wait_time - max_wait_count); } } else { } } max_wait_count = 600000U; max_wait_time = max_wait_count; ldv_46441: { __const_udelay(4295UL); value = pm8001_cr32(pm8001_ha, 0U, 72U); } if ((value & 3072U) != 3072U) { max_wait_count = max_wait_count - 1U; if (max_wait_count != 0U) { goto ldv_46441; } else { goto ldv_46442; } } else { } ldv_46442: ; if (max_wait_count == 0U) { ret = -1; } else { { tmp___1 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___1 != 0L) { { printk("\016pm80xx %s %d: iop0 ready status in %d millisec\n", "check_fw_ready", 741, max_wait_time - max_wait_count); } } else { } } if (pm8001_ha->chip_id - 1U > 1U) { max_wait_count = 200000U; max_wait_time = max_wait_count; ldv_46443: { __const_udelay(4295UL); value = pm8001_cr32(pm8001_ha, 0U, 72U); } if ((value & 12288U) != 12288U) { max_wait_count = max_wait_count - 1U; if (max_wait_count != 0U) { goto ldv_46443; } else { goto ldv_46444; } } else { } ldv_46444: ; if (max_wait_count == 0U) { ret = -1; } else { { tmp___2 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___2 != 0L) { { printk("\016pm80xx %s %d:iop1 ready status in %d millisec\n", "check_fw_ready", 759, max_wait_time - max_wait_count); } } else { } } } else { } return (ret); } } static void init_pci_device_addresses___0(struct pm8001_hba_info *pm8001_ha ) { void *base_addr ; u32 value ; u32 offset ; u32 pcibar ; u32 pcilogic ; long tmp ; long tmp___0 ; u32 tmp___1 ; u32 tmp___2 ; u32 tmp___3 ; u32 tmp___4 ; u32 tmp___5 ; u32 tmp___6 ; u32 tmp___7 ; long tmp___8 ; u32 tmp___9 ; long tmp___10 ; u32 tmp___11 ; long tmp___12 ; u32 tmp___13 ; long tmp___14 ; u32 tmp___15 ; long tmp___16 ; long tmp___17 ; long tmp___18 ; long tmp___19 ; { { value = pm8001_cr32(pm8001_ha, 0U, 68U); offset = value & 67108863U; tmp = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:Scratchpad 0 Offset: 0x%x value 0x%x\n", "init_pci_device_addresses", 779, offset, value); } } else { } { pcilogic = value >> 26; pcibar = get_pci_bar_index(pcilogic); tmp___0 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___0 != 0L) { { printk("\016pm80xx %s %d:Scratchpad 0 PCI BAR: %d\n", "init_pci_device_addresses", 783, pcibar); } } else { } { base_addr = pm8001_ha->io_mem[pcibar].memvirtaddr + (unsigned long )offset; pm8001_ha->main_cfg_tbl_addr = base_addr; tmp___1 = pm8001_cr32(pm8001_ha, pcibar, offset + 24U); pm8001_ha->general_stat_tbl_addr = base_addr + ((unsigned long )tmp___1 & 16777215UL); tmp___2 = pm8001_cr32(pm8001_ha, pcibar, offset + 28U); pm8001_ha->inbnd_q_tbl_addr = base_addr + ((unsigned long )tmp___2 & 16777215UL); tmp___3 = pm8001_cr32(pm8001_ha, pcibar, offset + 32U); pm8001_ha->outbnd_q_tbl_addr = base_addr + ((unsigned long )tmp___3 & 16777215UL); tmp___4 = pm8001_cr32(pm8001_ha, pcibar, offset + 140U); pm8001_ha->ivt_tbl_addr = base_addr + ((unsigned long )tmp___4 & 16777215UL); tmp___5 = pm8001_cr32(pm8001_ha, pcibar, offset + 144U); pm8001_ha->pspa_q_tbl_addr = base_addr + ((unsigned long )tmp___5 & 16777215UL); tmp___6 = pm8001_cr32(pm8001_ha, pcibar, offset + 160U); pm8001_ha->fatal_tbl_addr = base_addr + ((unsigned long )tmp___6 & 16777215UL); tmp___8 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___8 != 0L) { { tmp___7 = pm8001_cr32(pm8001_ha, pcibar, offset + 24U); printk("\016pm80xx %s %d:GST OFFSET 0x%x\n", "init_pci_device_addresses", 807, tmp___7); } } else { } { tmp___10 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___10 != 0L) { { tmp___9 = pm8001_cr32(pm8001_ha, pcibar, offset + 28U); printk("\016pm80xx %s %d:INBND OFFSET 0x%x\n", "init_pci_device_addresses", 810, tmp___9); } } else { } { tmp___12 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___12 != 0L) { { tmp___11 = pm8001_cr32(pm8001_ha, pcibar, offset + 32U); printk("\016pm80xx %s %d:OBND OFFSET 0x%x\n", "init_pci_device_addresses", 813, tmp___11); } } else { } { tmp___14 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___14 != 0L) { { tmp___13 = pm8001_cr32(pm8001_ha, pcibar, offset + 140U); printk("\016pm80xx %s %d:IVT OFFSET 0x%x\n", "init_pci_device_addresses", 816, tmp___13); } } else { } { tmp___16 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___16 != 0L) { { tmp___15 = pm8001_cr32(pm8001_ha, pcibar, offset + 144U); printk("\016pm80xx %s %d:PSPA OFFSET 0x%x\n", "init_pci_device_addresses", 819, tmp___15); } } else { } { tmp___17 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___17 != 0L) { { printk("\016pm80xx %s %d:addr - main cfg %p general status %p\n", "init_pci_device_addresses", 823, pm8001_ha->main_cfg_tbl_addr, pm8001_ha->general_stat_tbl_addr); } } else { } { tmp___18 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___18 != 0L) { { printk("\016pm80xx %s %d:addr - inbnd %p obnd %p\n", "init_pci_device_addresses", 827, pm8001_ha->inbnd_q_tbl_addr, pm8001_ha->outbnd_q_tbl_addr); } } else { } { tmp___19 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___19 != 0L) { { printk("\016pm80xx %s %d:addr - pspa %p ivt %p\n", "init_pci_device_addresses", 831, pm8001_ha->pspa_q_tbl_addr, pm8001_ha->ivt_tbl_addr); } } else { } return; } } int pm80xx_set_thermal_config(struct pm8001_hba_info *pm8001_ha ) { struct set_ctrl_cfg_req payload ; struct inbound_queue_table *circularQ ; int rc ; u32 tag ; u32 opc ; { { opc = 48U; __memset((void *)(& payload), 0, 124UL); rc = pm8001_tag_alloc(pm8001_ha, & tag); } if (rc != 0) { return (-1); } else { } { circularQ = (struct inbound_queue_table *)(& pm8001_ha->inbnd_q_tbl); payload.tag = tag; payload.cfg_pg[0] = 774U; payload.cfg_pg[1] = 1174430720U; rc = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, (void *)(& payload), 0U); } if (rc != 0) { { pm8001_tag_free(pm8001_ha, tag); } } else { } return (rc); } } static int pm80xx_set_sas_protocol_timer_config(struct pm8001_hba_info *pm8001_ha ) { struct set_ctrl_cfg_req payload ; struct inbound_queue_table *circularQ ; SASProtocolTimerConfig_t SASConfigPage ; int rc ; u32 tag ; u32 opc ; long tmp ; long tmp___0 ; long tmp___1 ; long tmp___2 ; long tmp___3 ; long tmp___4 ; long tmp___5 ; long tmp___6 ; long tmp___7 ; { { opc = 48U; __memset((void *)(& payload), 0, 124UL); __memset((void *)(& SASConfigPage), 0, 36UL); rc = pm8001_tag_alloc(pm8001_ha, & tag); } if (rc != 0) { return (-1); } else { } circularQ = (struct inbound_queue_table *)(& pm8001_ha->inbnd_q_tbl); payload.tag = tag; SASConfigPage.pageCode = 4U; SASConfigPage.MST_MSI = 98304U; SASConfigPage.STP_SSP_MCT_TMO = 2097184U; SASConfigPage.STP_FRM_TMO = 100597760U; SASConfigPage.STP_IDLE_TMO = 5U; if (SASConfigPage.STP_IDLE_TMO > 67108863U) { SASConfigPage.STP_IDLE_TMO = 67108863U; } else { } { SASConfigPage.OPNRJT_RTRY_INTVL = 2U; SASConfigPage.Data_Cmd_OPNRJT_RTRY_TMO = 8388736U; SASConfigPage.Data_Cmd_OPNRJT_RTRY_THR = 1536056206U; SASConfigPage.MAX_AIP = 2097152U; tmp = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:SASConfigPage.pageCode 0x%08x\n", "pm80xx_set_sas_protocol_timer_config", 912, SASConfigPage.pageCode); } } else { } { tmp___0 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___0 != 0L) { { printk("\016pm80xx %s %d:SASConfigPage.MST_MSI 0x%08x\n", "pm80xx_set_sas_protocol_timer_config", 915, SASConfigPage.MST_MSI); } } else { } { tmp___1 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___1 != 0L) { { printk("\016pm80xx %s %d:SASConfigPage.STP_SSP_MCT_TMO 0x%08x\n", "pm80xx_set_sas_protocol_timer_config", 918, SASConfigPage.STP_SSP_MCT_TMO); } } else { } { tmp___2 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___2 != 0L) { { printk("\016pm80xx %s %d:SASConfigPage.STP_FRM_TMO 0x%08x\n", "pm80xx_set_sas_protocol_timer_config", 921, SASConfigPage.STP_FRM_TMO); } } else { } { tmp___3 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___3 != 0L) { { printk("\016pm80xx %s %d:SASConfigPage.STP_IDLE_TMO 0x%08x\n", "pm80xx_set_sas_protocol_timer_config", 924, SASConfigPage.STP_IDLE_TMO); } } else { } { tmp___4 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___4 != 0L) { { printk("\016pm80xx %s %d:SASConfigPage.OPNRJT_RTRY_INTVL 0x%08x\n", "pm80xx_set_sas_protocol_timer_config", 927, SASConfigPage.OPNRJT_RTRY_INTVL); } } else { } { tmp___5 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___5 != 0L) { { printk("\016pm80xx %s %d:SASConfigPage.Data_Cmd_OPNRJT_RTRY_TMO 0x%08x\n", "pm80xx_set_sas_protocol_timer_config", 930, SASConfigPage.Data_Cmd_OPNRJT_RTRY_TMO); } } else { } { tmp___6 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___6 != 0L) { { printk("\016pm80xx %s %d:SASConfigPage.Data_Cmd_OPNRJT_RTRY_THR 0x%08x\n", "pm80xx_set_sas_protocol_timer_config", 933, SASConfigPage.Data_Cmd_OPNRJT_RTRY_THR); } } else { } { tmp___7 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___7 != 0L) { { printk("\016pm80xx %s %d:SASConfigPage.MAX_AIP 0x%08x\n", "pm80xx_set_sas_protocol_timer_config", 935, SASConfigPage.MAX_AIP); } } else { } { __memcpy((void *)(& payload.cfg_pg), (void const *)(& SASConfigPage), 36UL); rc = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, (void *)(& payload), 0U); } if (rc != 0) { { pm8001_tag_free(pm8001_ha, tag); } } else { } return (rc); } } static int pm80xx_get_encrypt_info(struct pm8001_hba_info *pm8001_ha ) { u32 scratch3_value ; int ret ; long tmp ; long tmp___0 ; long tmp___1 ; long tmp___2 ; { { ret = -1; scratch3_value = pm8001_cr32(pm8001_ha, 0U, 80U); } if ((scratch3_value & 3U) == 3U) { if ((scratch3_value & 16384U) != 0U) { pm8001_ha->encrypt_info.cipher_mode = 2U; } else { } if ((scratch3_value & 240U) == 0U) { pm8001_ha->encrypt_info.sec_mode = 0U; } else { } if ((scratch3_value & 240U) == 16U) { pm8001_ha->encrypt_info.sec_mode = 256U; } else { } if ((scratch3_value & 240U) == 32U) { pm8001_ha->encrypt_info.sec_mode = 512U; } else { } { pm8001_ha->encrypt_info.status = 0U; tmp = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:Encryption: SCRATCH_PAD3_ENC_READY 0x%08X.Cipher mode 0x%x Sec mode 0x%x status 0x%x\n", "pm80xx_get_encrypt_info", 979, scratch3_value, pm8001_ha->encrypt_info.cipher_mode, pm8001_ha->encrypt_info.sec_mode, pm8001_ha->encrypt_info.status); } } else { } ret = 0; } else if ((scratch3_value & 3U) == 0U) { { tmp___0 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___0 != 0L) { { printk("\016pm80xx %s %d:Encryption: SCRATCH_PAD3_ENC_DISABLED 0x%08X\n", "pm80xx_get_encrypt_info", 985, scratch3_value); } } else { } pm8001_ha->encrypt_info.status = 4294967295U; pm8001_ha->encrypt_info.cipher_mode = 0U; pm8001_ha->encrypt_info.sec_mode = 0U; ret = 0; } else if ((scratch3_value & 3U) == 1U) { pm8001_ha->encrypt_info.status = (scratch3_value & 16711680U) >> 16; if ((scratch3_value & 16384U) != 0U) { pm8001_ha->encrypt_info.cipher_mode = 2U; } else { } if ((scratch3_value & 240U) == 0U) { pm8001_ha->encrypt_info.sec_mode = 0U; } else { } if ((scratch3_value & 240U) == 16U) { pm8001_ha->encrypt_info.sec_mode = 256U; } else { } if ((scratch3_value & 240U) == 32U) { pm8001_ha->encrypt_info.sec_mode = 512U; } else { } { tmp___1 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___1 != 0L) { { printk("\016pm80xx %s %d:Encryption: SCRATCH_PAD3_DIS_ERR 0x%08X.Cipher mode 0x%x sec mode 0x%x status 0x%x\n", "pm80xx_get_encrypt_info", 1010, scratch3_value, pm8001_ha->encrypt_info.cipher_mode, pm8001_ha->encrypt_info.sec_mode, pm8001_ha->encrypt_info.status); } } else { } } else if ((scratch3_value & 3U) == 2U) { pm8001_ha->encrypt_info.status = (scratch3_value & 16711680U) >> 16; if ((scratch3_value & 16384U) != 0U) { pm8001_ha->encrypt_info.cipher_mode = 2U; } else { } if ((scratch3_value & 240U) == 0U) { pm8001_ha->encrypt_info.sec_mode = 0U; } else { } if ((scratch3_value & 240U) == 16U) { pm8001_ha->encrypt_info.sec_mode = 256U; } else { } if ((scratch3_value & 240U) == 32U) { pm8001_ha->encrypt_info.sec_mode = 512U; } else { } { tmp___2 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___2 != 0L) { { printk("\016pm80xx %s %d:Encryption: SCRATCH_PAD3_ENA_ERR 0x%08X.Cipher mode 0x%x sec mode 0x%x status 0x%x\n", "pm80xx_get_encrypt_info", 1033, scratch3_value, pm8001_ha->encrypt_info.cipher_mode, pm8001_ha->encrypt_info.sec_mode, pm8001_ha->encrypt_info.status); } } else { } } else { } return (ret); } } static int pm80xx_encrypt_update(struct pm8001_hba_info *pm8001_ha ) { struct kek_mgmt_req payload ; struct inbound_queue_table *circularQ ; int rc ; u32 tag ; u32 opc ; { { opc = 256U; __memset((void *)(& payload), 0, 124UL); rc = pm8001_tag_alloc(pm8001_ha, & tag); } if (rc != 0) { return (-1); } else { } { circularQ = (struct inbound_queue_table *)(& pm8001_ha->inbnd_q_tbl); payload.tag = tag; payload.new_curidx_ksop = 16843012U; rc = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, (void *)(& payload), 0U); } if (rc != 0) { { pm8001_tag_free(pm8001_ha, tag); } } else { } return (rc); } } static int pm80xx_chip_init(struct pm8001_hba_info *pm8001_ha ) { int ret ; u8 i ; long tmp ; int tmp___0 ; long tmp___1 ; int tmp___2 ; long tmp___3 ; long tmp___4 ; long tmp___5 ; { { i = 0U; tmp___0 = check_fw_ready___0(pm8001_ha); } if (tmp___0 == -1) { { tmp = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:Firmware is not ready!\n", "pm80xx_chip_init", 1082); } } else { } return (-16); } else { } { init_pci_device_addresses___0(pm8001_ha); init_default_table_values___0(pm8001_ha); read_main_config_table___0(pm8001_ha); read_general_status_table___0(pm8001_ha); read_inbnd_queue_table___0(pm8001_ha); read_outbnd_queue_table___0(pm8001_ha); read_phy_attr_table(pm8001_ha); update_main_config_table___0(pm8001_ha); i = 0U; } goto ldv_46493; ldv_46492: { update_inbnd_queue_table___0(pm8001_ha, (int )i); i = (u8 )((int )i + 1); } ldv_46493: ; if ((unsigned int )i == 0U) { goto ldv_46492; } else { } i = 0U; goto ldv_46496; ldv_46495: { update_outbnd_queue_table___0(pm8001_ha, (int )i); i = (u8 )((int )i + 1); } ldv_46496: ; if ((unsigned int )i <= 3U) { goto ldv_46495; } else { } { tmp___2 = mpi_init_check___0(pm8001_ha); } if (tmp___2 == 0) { { tmp___1 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___1 != 0L) { { printk("\016pm80xx %s %d:MPI initialize successful!\n", "pm80xx_chip_init", 1105); } } else { } } else { return (-16); } { ret = pm80xx_set_sas_protocol_timer_config(pm8001_ha); } if ((unsigned int )(pm8001_ha->chip)->encrypt != 0U) { { tmp___3 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___3 != 0L) { { printk("\016pm80xx %s %d:Checking for encryption\n", "pm80xx_chip_init", 1115); } } else { } { ret = pm80xx_get_encrypt_info(pm8001_ha); } if (ret == -1) { { tmp___4 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___4 != 0L) { { printk("\016pm80xx %s %d:Encryption error !!\n", "pm80xx_chip_init", 1119); } } else { } if (pm8001_ha->encrypt_info.status == 129U) { { tmp___5 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___5 != 0L) { { printk("\016pm80xx %s %d:Encryption enabled with error.Saving encryption key to flash\n", "pm80xx_chip_init", 1123); } } else { } { pm80xx_encrypt_update(pm8001_ha); } } else { } } else { } } else { } return (0); } } static int mpi_uninit_check___0(struct pm8001_hba_info *pm8001_ha ) { u32 max_wait_count ; u32 value ; u32 gst_len_mpistate ; long tmp ; long tmp___0 ; { { init_pci_device_addresses___0(pm8001_ha); pm8001_cw32(pm8001_ha, 0U, 0U, 2U); } if (((unsigned int )(pm8001_ha->pdev)->device == 32884U || (unsigned int )(pm8001_ha->pdev)->device == 32886U) || (unsigned int )(pm8001_ha->pdev)->device == 32887U) { max_wait_count = 4000000U; } else { max_wait_count = 2000000U; } ldv_46504: { __const_udelay(4295UL); value = pm8001_cr32(pm8001_ha, 0U, 0U); value = value & 2U; } if (value != 0U) { max_wait_count = max_wait_count - 1U; if (max_wait_count != 0U) { goto ldv_46504; } else { goto ldv_46505; } } else { } ldv_46505: ; if (max_wait_count == 0U) { { tmp = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:TIMEOUT:IBDB value/=%x\n", "mpi_uninit_check", 1155, value); } } else { } return (-1); } else { } max_wait_count = 2000000U; ldv_46508: { __const_udelay(4295UL); gst_len_mpistate = pm8001_mr32(pm8001_ha->general_stat_tbl_addr, 0U); } if ((gst_len_mpistate & 7U) == 0U) { goto ldv_46507; } else { } max_wait_count = max_wait_count - 1U; if (max_wait_count != 0U) { goto ldv_46508; } else { } ldv_46507: ; if (max_wait_count == 0U) { { tmp___0 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___0 != 0L) { { printk("\016pm80xx %s %d: TIME OUT MPI State = 0x%x\n", "mpi_uninit_check", 1174, gst_len_mpistate & 7U); } } else { } return (-1); } else { } return (0); } } static int pm80xx_chip_soft_rst(struct pm8001_hba_info *pm8001_ha ) { u32 regval ; u32 bootloader_state ; u32 ibutton0 ; u32 ibutton1 ; long tmp ; int tmp___0 ; long tmp___1 ; unsigned long __ms ; unsigned long tmp___2 ; long tmp___3 ; long tmp___4 ; long tmp___5 ; u32 tmp___6 ; long tmp___7 ; long tmp___8 ; long tmp___9 ; long tmp___10 ; long tmp___11 ; long tmp___12 ; long tmp___13 ; int tmp___14 ; long tmp___15 ; { { tmp___0 = mpi_uninit_check___0(pm8001_ha); } if (tmp___0 != 0) { { tmp = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:MPI state is not ready\n", "pm80xx_chip_soft_rst", 1197); } } else { } return (-1); } else { } { regval = pm8001_cr32(pm8001_ha, 0U, 4096U); tmp___1 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___1 != 0L) { { printk("\016pm80xx %s %d:reset register before write : 0x%x\n", "pm80xx_chip_soft_rst", 1204, regval); } } else { } { pm8001_cw32(pm8001_ha, 0U, 4096U, 1U); __ms = 500UL; } goto ldv_46519; ldv_46518: { __const_udelay(4295000UL); } ldv_46519: tmp___2 = __ms; __ms = __ms - 1UL; if (tmp___2 != 0UL) { goto ldv_46518; } else { } { regval = pm8001_cr32(pm8001_ha, 0U, 4096U); tmp___3 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___3 != 0L) { { printk("\016pm80xx %s %d:reset register after write 0x%x\n", "pm80xx_chip_soft_rst", 1211, regval); } } else { } if ((regval & 192U) == 64U) { { tmp___4 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___4 != 0L) { { printk("\016pm80xx %s %d: soft reset successful [regval: 0x%x]\n", "pm80xx_chip_soft_rst", 1217, regval); } } else { } } else { { tmp___5 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___5 != 0L) { { printk("\016pm80xx %s %d: soft reset failed [regval: 0x%x]\n", "pm80xx_chip_soft_rst", 1221, regval); } } else { } { tmp___6 = pm8001_cr32(pm8001_ha, 0U, 72U); bootloader_state = tmp___6 & 112U; } if (bootloader_state == 16U) { { tmp___7 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___7 != 0L) { { printk("\016pm80xx %s %d:Bootloader state - HDA mode SEEPROM\n", "pm80xx_chip_soft_rst", 1230); } } else { } } else if (bootloader_state == 32U) { { tmp___8 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___8 != 0L) { { printk("\016pm80xx %s %d:Bootloader state - HDA mode Bootstrap Pin\n", "pm80xx_chip_soft_rst", 1234); } } else { } } else if (bootloader_state == 48U) { { tmp___9 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___9 != 0L) { { printk("\016pm80xx %s %d:Bootloader state - HDA mode soft reset\n", "pm80xx_chip_soft_rst", 1238); } } else { } } else if (bootloader_state == 64U) { { tmp___10 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___10 != 0L) { { printk("\016pm80xx %s %d:Bootloader state-HDA mode critical error\n", "pm80xx_chip_soft_rst", 1242); } } else { } } else { } return (-16); } { tmp___14 = check_fw_ready___0(pm8001_ha); } if (tmp___14 == -1) { { tmp___11 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___11 != 0L) { { printk("\016pm80xx %s %d:Firmware is not ready!\n", "pm80xx_chip_soft_rst", 1250); } } else { } if ((unsigned int )(pm8001_ha->pdev)->subsystem_vendor != 36869U && (unsigned int )(pm8001_ha->pdev)->subsystem_vendor != 0U) { { ibutton0 = pm8001_cr32(pm8001_ha, 0U, 108U); ibutton1 = pm8001_cr32(pm8001_ha, 0U, 112U); } if ((ibutton0 | ibutton1) == 0U) { { tmp___12 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___12 != 0L) { { printk("\016pm80xx %s %d:iButton Feature is not Available!!!\n", "pm80xx_chip_soft_rst", 1262); } } else { } return (-16); } else { } if (ibutton0 == 3735928559U && ibutton1 == 3735928559U) { { tmp___13 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___13 != 0L) { { printk("\016pm80xx %s %d:CRC Check for iButton Feature Failed!!!\n", "pm80xx_chip_soft_rst", 1268); } } else { } return (-16); } else { } } else { } } else { } { tmp___15 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___15 != 0L) { { printk("\016pm80xx %s %d:SPCv soft reset Complete\n", "pm80xx_chip_soft_rst", 1274); } } else { } return (0); } } static void pm80xx_hw_chip_rst(struct pm8001_hba_info *pm8001_ha ) { u32 i ; long tmp ; long tmp___0 ; unsigned long __ms ; unsigned long tmp___1 ; long tmp___2 ; { { tmp = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:chip reset start\n", "pm80xx_hw_chip_rst", 1283); } } else { } { pm8001_cw32(pm8001_ha, 0U, 4096U, 17U); tmp___0 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___0 != 0L) { { printk("\016pm80xx %s %d:SPC soft reset Complete\n", "pm80xx_hw_chip_rst", 1288); } } else { } { __const_udelay(42950UL); i = 20U; } ldv_46530: ; if (1) { { __const_udelay(4295000UL); } } else { __ms = 1UL; goto ldv_46528; ldv_46527: { __const_udelay(4295000UL); } ldv_46528: tmp___1 = __ms; __ms = __ms - 1UL; if (tmp___1 != 0UL) { goto ldv_46527; } else { } } i = i - 1U; if (i != 0U) { goto ldv_46530; } else { } { tmp___2 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___2 != 0L) { { printk("\016pm80xx %s %d:chip reset finished\n", "pm80xx_hw_chip_rst", 1301); } } else { } return; } } static void pm80xx_chip_intx_interrupt_enable(struct pm8001_hba_info *pm8001_ha ) { { { pm8001_cw32(pm8001_ha, 0U, 48U, 0U); pm8001_cw32(pm8001_ha, 0U, 40U, 4294967295U); } return; } } static void pm80xx_chip_intx_interrupt_disable(struct pm8001_hba_info *pm8001_ha ) { { { pm8001_cw32(pm8001_ha, 0U, 56U, 4294967295U); } return; } } static void pm80xx_chip_interrupt_enable(struct pm8001_hba_info *pm8001_ha , u8 vec ) { u32 mask ; { { mask = (unsigned int )(1 << (int )vec); pm8001_cw32(pm8001_ha, 0U, 56U, mask); } return; { pm80xx_chip_intx_interrupt_enable(pm8001_ha); } } } static void pm80xx_chip_interrupt_disable(struct pm8001_hba_info *pm8001_ha , u8 vec ) { u32 mask ; { if ((unsigned int )vec == 255U) { mask = 4294967295U; } else { mask = (unsigned int )(1 << (int )vec); } { pm8001_cw32(pm8001_ha, 0U, 48U, mask); } return; { pm80xx_chip_intx_interrupt_disable(pm8001_ha); } } } static void pm80xx_send_abort_all(struct pm8001_hba_info *pm8001_ha , struct pm8001_device *pm8001_ha_dev ) { int res ; u32 ccb_tag ; struct pm8001_ccb_info *ccb ; struct sas_task *task ; struct task_abort_req___0 task_abort ; struct inbound_queue_table *circularQ ; u32 opc ; int ret ; long tmp ; long tmp___0 ; { task = (struct sas_task *)0; opc = 24U; if ((unsigned long )pm8001_ha_dev == (unsigned long )((struct pm8001_device *)0)) { { tmp = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:dev is null\n", "pm80xx_send_abort_all", 1375); } } else { } return; } else { } { task = sas_alloc_slow_task(32U); } if ((unsigned long )task == (unsigned long )((struct sas_task *)0)) { { tmp___0 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___0 != 0L) { { printk("\016pm80xx %s %d:cannot allocate task\n", "pm80xx_send_abort_all", 1383); } } else { } return; } else { } { task->task_done = & pm8001_task_done; res = pm8001_tag_alloc(pm8001_ha, & ccb_tag); } if (res != 0) { { sas_free_task(task); } return; } else { } { ccb = pm8001_ha->ccb_info + (unsigned long )ccb_tag; ccb->device = pm8001_ha_dev; ccb->ccb_tag = ccb_tag; ccb->task = task; circularQ = (struct inbound_queue_table *)(& pm8001_ha->inbnd_q_tbl); __memset((void *)(& task_abort), 0, 124UL); task_abort.abort_all = 1U; task_abort.device_id = pm8001_ha_dev->device_id; task_abort.tag = ccb_tag; ret = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, (void *)(& task_abort), 0U); } if (ret != 0) { { sas_free_task(task); pm8001_tag_free(pm8001_ha, ccb_tag); } } else { } return; } } static void pm80xx_send_read_log(struct pm8001_hba_info *pm8001_ha , struct pm8001_device *pm8001_ha_dev ) { struct sata_start_req___0 sata_cmd ; int res ; u32 ccb_tag ; struct pm8001_ccb_info *ccb ; struct sas_task *task ; struct host_to_dev_fis fis ; struct domain_device *dev ; struct inbound_queue_table *circularQ ; u32 opc ; long tmp ; long tmp___0 ; void *tmp___1 ; long tmp___2 ; { { task = (struct sas_task *)0; opc = 23U; task = sas_alloc_slow_task(32U); } if ((unsigned long )task == (unsigned long )((struct sas_task *)0)) { { tmp = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:cannot allocate task !!!\n", "pm80xx_send_read_log", 1431); } } else { } return; } else { } { task->task_done = & pm8001_task_done; res = pm8001_tag_alloc(pm8001_ha, & ccb_tag); } if (res != 0) { { sas_free_task(task); tmp___0 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___0 != 0L) { { printk("\016pm80xx %s %d:cannot allocate tag !!!\n", "pm80xx_send_read_log", 1440); } } else { } return; } else { } { tmp___1 = kzalloc(656UL, 32U); dev = (struct domain_device *)tmp___1; } if ((unsigned long )dev == (unsigned long )((struct domain_device *)0)) { { sas_free_task(task); pm8001_tag_free(pm8001_ha, ccb_tag); tmp___2 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___2 != 0L) { { printk("\016pm80xx %s %d:Domain device cannot be allocated\n", "pm80xx_send_read_log", 1452); } } else { } return; } else { } { task->dev = dev; (task->dev)->lldd_dev = (void *)pm8001_ha_dev; ccb = pm8001_ha->ccb_info + (unsigned long )ccb_tag; ccb->device = pm8001_ha_dev; ccb->ccb_tag = ccb_tag; ccb->task = task; pm8001_ha_dev->id = pm8001_ha_dev->id | 2147483648U; pm8001_ha_dev->id = pm8001_ha_dev->id | 536870912U; __memset((void *)(& sata_cmd), 0, 124UL); circularQ = (struct inbound_queue_table *)(& pm8001_ha->inbnd_q_tbl); __memset((void *)(& fis), 0, 20UL); fis.fis_type = 39U; fis.flags = 128U; fis.command = 47U; fis.lbal = 16U; fis.__annonCompField87.sector_count = 1U; sata_cmd.tag = ccb_tag; sata_cmd.device_id = pm8001_ha_dev->device_id; sata_cmd.ncqtag_atap_dir_m_dad = sata_cmd.ncqtag_atap_dir_m_dad | 2688U; __memcpy((void *)(& sata_cmd.sata_fis), (void const *)(& fis), 20UL); res = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, (void *)(& sata_cmd), 0U); } if (res != 0) { { sas_free_task(task); pm8001_tag_free(pm8001_ha, ccb_tag); kfree((void const *)dev); } } else { } return; } } static void mpi_ssp_completion___0(struct pm8001_hba_info *pm8001_ha , void *piomb ) { struct sas_task *t ; struct pm8001_ccb_info *ccb ; unsigned long flags ; u32 status ; u32 param ; u32 tag ; struct ssp_completion_resp *psspPayload ; struct task_status_struct *ts ; struct ssp_response_iu *iu ; struct pm8001_device *pm8001_dev ; long tmp ; long tmp___0 ; long tmp___1 ; int tmp___2 ; long tmp___3 ; __u64 tmp___4 ; long tmp___5 ; long tmp___6 ; long tmp___7 ; long tmp___8 ; long tmp___9 ; long tmp___10 ; long tmp___11 ; long tmp___12 ; long tmp___13 ; long tmp___14 ; long tmp___15 ; long tmp___16 ; long tmp___17 ; long tmp___18 ; long tmp___19 ; long tmp___20 ; long tmp___21 ; long tmp___22 ; long tmp___23 ; long tmp___24 ; long tmp___25 ; long tmp___26 ; long tmp___27 ; long tmp___28 ; long tmp___29 ; long tmp___30 ; long tmp___31 ; long tmp___32 ; long tmp___33 ; { psspPayload = (struct ssp_completion_resp *)piomb + 4U; status = psspPayload->status; tag = psspPayload->tag; ccb = pm8001_ha->ccb_info + (unsigned long )tag; if (status == 1U && (unsigned int )ccb->open_retry != 0U) { ccb->open_retry = 0U; return; } else { } pm8001_dev = ccb->device; param = psspPayload->param; t = ccb->task; if (status != 0U && status != 3U) { { tmp = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:sas IO status 0x%x\n", "mpi_ssp_completion", 1529, status); } } else { } } else { } { tmp___0 = ldv__builtin_expect((unsigned long )t == (unsigned long )((struct sas_task *)0), 0L); } if (tmp___0 != 0L) { tmp___2 = 1; } else { { tmp___1 = ldv__builtin_expect((unsigned long )t->lldd_task == (unsigned long )((void *)0), 0L); } if (tmp___1 != 0L) { tmp___2 = 1; } else { tmp___2 = 0; } } if (tmp___2 != 0) { return; } else { { tmp___3 = ldv__builtin_expect((unsigned long )t->dev == (unsigned long )((struct domain_device *)0), 0L); } if (tmp___3 != 0L) { return; } else { } } ts = & t->task_status; if ((status != 0U && status != 2U) && status != 3U) { { tmp___5 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___5 != 0L) { { tmp___4 = __fswab64(*((__be64 *)(& (t->dev)->sas_addr))); printk("\016pm80xx %s %d:SAS Address of IO Failure Drive:%016llx", "mpi_ssp_completion", 1538, tmp___4); } } else { } } else { } { if (status == 0U) { goto case_0; } else { } if (status == 1U) { goto case_1; } else { } if (status == 3U) { goto case_3; } else { } if (status == 7U) { goto case_7; } else { } if (status == 14U) { goto case_14; } else { } if (status == 15U) { goto case_15; } else { } if (status == 16U) { goto case_16; } else { } if (status == 17U) { goto case_17; } else { } if (status == 18U) { goto case_18; } else { } if (status == 19U) { goto case_19; } else { } if (status == 68U) { goto case_68; } else { } if (status == 69U) { goto case_69; } else { } if (status == 70U) { goto case_70; } else { } if (status == 71U) { goto case_71; } else { } if (status == 72U) { goto case_72; } else { } if (status == 20U) { goto case_20; } else { } if (status == 21U) { goto case_21; } else { } if (status == 23U) { goto case_23; } else { } if (status == 25U) { goto case_25; } else { } if (status == 26U) { goto case_26; } else { } if (status == 29U) { goto case_29; } else { } if (status == 36U) { goto case_36; } else { } if (status == 52U) { goto case_52; } else { } if (status == 56U) { goto case_56; } else { } if (status == 57U) { goto case_57; } else { } if (status == 58U) { goto case_58; } else { } if (status == 59U) { goto case_59; } else { } if (status == 61U) { goto case_61; } else { } if (status == 63U) { goto case_63; } else { } goto switch_default; case_0: /* CIL Label */ { tmp___6 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___6 != 0L) { { printk("\016pm80xx %s %d:IO_SUCCESS ,param = 0x%x\n", "mpi_ssp_completion", 1544, param); } } else { } if (param == 0U) { ts->resp = 0; ts->stat = 0; } else { { ts->resp = 0; ts->stat = 137; ts->residual = param; iu = & psspPayload->ssp_resp_iu; sas_ssp_task_response(pm8001_ha->dev, t, iu); } } if ((unsigned long )pm8001_dev != (unsigned long )((struct pm8001_device *)0)) { pm8001_dev->running_req = pm8001_dev->running_req - 1U; } else { } goto ldv_46591; case_1: /* CIL Label */ { tmp___7 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___7 != 0L) { { printk("\016pm80xx %s %d:IO_ABORTED IOMB Tag\n", "mpi_ssp_completion", 1560); } } else { } ts->resp = 0; ts->stat = 141; goto ldv_46591; case_3: /* CIL Label */ { tmp___8 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___8 != 0L) { { printk("\016pm80xx %s %d:IO_UNDERFLOW ,param = 0x%x\n", "mpi_ssp_completion", 1568, param); } } else { } ts->resp = 0; ts->stat = 129; ts->residual = param; if ((unsigned long )pm8001_dev != (unsigned long )((struct pm8001_device *)0)) { pm8001_dev->running_req = pm8001_dev->running_req - 1U; } else { } goto ldv_46591; case_7: /* CIL Label */ { tmp___9 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___9 != 0L) { { printk("\016pm80xx %s %d:IO_NO_DEVICE\n", "mpi_ssp_completion", 1577); } } else { } ts->resp = -1; ts->stat = 138; goto ldv_46591; case_14: /* CIL Label */ { tmp___10 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___10 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_BREAK\n", "mpi_ssp_completion", 1583); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 18; goto ldv_46591; case_15: /* CIL Label */ { tmp___11 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___11 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_PHY_NOT_READY\n", "mpi_ssp_completion", 1591); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 18; goto ldv_46591; case_16: /* CIL Label */ { tmp___12 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___12 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED\n", "mpi_ssp_completion", 1598); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 3; goto ldv_46591; case_17: /* CIL Label */ { tmp___13 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___13 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_ZONE_VIOLATION\n", "mpi_ssp_completion", 1605); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 0; goto ldv_46591; case_18: /* CIL Label */ { tmp___14 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___14 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_BREAK\n", "mpi_ssp_completion", 1612); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 18; goto ldv_46591; case_19: /* CIL Label */ ; case_68: /* CIL Label */ ; case_69: /* CIL Label */ ; case_70: /* CIL Label */ ; case_71: /* CIL Label */ ; case_72: /* CIL Label */ { tmp___15 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___15 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS\n", "mpi_ssp_completion", 1624); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 0; if ((unsigned long )t->uldd_task == (unsigned long )((void *)0)) { { pm8001_handle_event(pm8001_ha, (void *)pm8001_dev, 19); } } else { } goto ldv_46591; case_20: /* CIL Label */ { tmp___16 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___16 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_BAD_DESTINATION\n", "mpi_ssp_completion", 1635); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 1; goto ldv_46591; case_21: /* CIL Label */ { tmp___17 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___17 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED\n", "mpi_ssp_completion", 1642); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 2; goto ldv_46591; case_23: /* CIL Label */ { tmp___18 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___18 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_WRONG_DESTINATION\n", "mpi_ssp_completion", 1649); } } else { } ts->resp = -1; ts->stat = 135; ts->open_rej_reason = 8; goto ldv_46591; case_25: /* CIL Label */ { tmp___19 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___19 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_NAK_RECEIVED\n", "mpi_ssp_completion", 1656); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 18; goto ldv_46591; case_26: /* CIL Label */ { tmp___20 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___20 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_ACK_NAK_TIMEOUT\n", "mpi_ssp_completion", 1663); } } else { } ts->resp = 0; ts->stat = 139; goto ldv_46591; case_29: /* CIL Label */ { tmp___21 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___21 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_DMA\n", "mpi_ssp_completion", 1669); } } else { } ts->resp = 0; ts->stat = 135; goto ldv_46591; case_36: /* CIL Label */ { tmp___22 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___22 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_OPEN_RETRY_TIMEOUT\n", "mpi_ssp_completion", 1675); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 18; goto ldv_46591; case_52: /* CIL Label */ { tmp___23 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___23 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_OFFSET_MISMATCH\n", "mpi_ssp_completion", 1682); } } else { } ts->resp = 0; ts->stat = 135; goto ldv_46591; case_56: /* CIL Label */ { tmp___24 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___24 != 0L) { { printk("\016pm80xx %s %d:IO_PORT_IN_RESET\n", "mpi_ssp_completion", 1688); } } else { } ts->resp = 0; ts->stat = 135; goto ldv_46591; case_57: /* CIL Label */ { tmp___25 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___25 != 0L) { { printk("\016pm80xx %s %d:IO_DS_NON_OPERATIONAL\n", "mpi_ssp_completion", 1694); } } else { } ts->resp = 0; ts->stat = 135; if ((unsigned long )t->uldd_task == (unsigned long )((void *)0)) { { pm8001_handle_event(pm8001_ha, (void *)pm8001_dev, 57); } } else { } goto ldv_46591; case_58: /* CIL Label */ { tmp___26 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___26 != 0L) { { printk("\016pm80xx %s %d:IO_DS_IN_RECOVERY\n", "mpi_ssp_completion", 1704); } } else { } ts->resp = 0; ts->stat = 135; goto ldv_46591; case_59: /* CIL Label */ { tmp___27 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___27 != 0L) { { printk("\016pm80xx %s %d:IO_TM_TAG_NOT_FOUND\n", "mpi_ssp_completion", 1710); } } else { } ts->resp = 0; ts->stat = 135; goto ldv_46591; case_61: /* CIL Label */ { tmp___28 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___28 != 0L) { { printk("\016pm80xx %s %d:IO_SSP_EXT_IU_ZERO_LEN_ERROR\n", "mpi_ssp_completion", 1716); } } else { } ts->resp = 0; ts->stat = 135; goto ldv_46591; case_63: /* CIL Label */ { tmp___29 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___29 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_HW_RESOURCE_BUSY\n", "mpi_ssp_completion", 1722); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 18; goto ldv_46591; switch_default: /* CIL Label */ { tmp___30 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___30 != 0L) { { printk("\016pm80xx %s %d:Unknown status 0x%x\n", "mpi_ssp_completion", 1729, status); } } else { } ts->resp = 0; ts->stat = 135; goto ldv_46591; switch_break: /* CIL Label */ ; } ldv_46591: { tmp___31 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___31 != 0L) { { printk("\016pm80xx %s %d:scsi_status = 0x%x\n ", "mpi_ssp_completion", 1737, (int )psspPayload->ssp_resp_iu.status); } } else { } { ldv___ldv_linux_kernel_locking_spinlock_spin_lock_100___1(& t->task_state_lock); t->task_state_flags = t->task_state_flags & 4294967294U; t->task_state_flags = t->task_state_flags & 4294967279U; t->task_state_flags = t->task_state_flags | 2U; tmp___33 = ldv__builtin_expect((t->task_state_flags & 4U) != 0U, 0L); } if (tmp___33 != 0L) { { ldv_spin_unlock_irqrestore_135(& t->task_state_lock, flags); tmp___32 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___32 != 0L) { { printk("\016pm80xx %s %d:task 0x%p done with io_status 0x%x resp 0x%x stat 0x%x but aborted by upper layer!\n", "mpi_ssp_completion", 1747, t, status, (int )ts->resp, (unsigned int )ts->stat); } } else { } { pm8001_ccb_task_free(pm8001_ha, t, ccb, tag); } } else { { ldv_spin_unlock_irqrestore_135(& t->task_state_lock, flags); pm8001_ccb_task_free(pm8001_ha, t, ccb, tag); __asm__ volatile ("mfence": : : "memory"); (*(t->task_done))(t); } } return; } } static void mpi_ssp_event___0(struct pm8001_hba_info *pm8001_ha , void *piomb ) { struct sas_task *t ; unsigned long flags ; struct task_status_struct *ts ; struct pm8001_ccb_info *ccb ; struct pm8001_device *pm8001_dev ; struct ssp_event_resp___0 *psspPayload ; u32 event ; u32 tag ; u32 port_id ; long tmp ; long tmp___0 ; long tmp___1 ; int tmp___2 ; long tmp___3 ; long tmp___4 ; long tmp___5 ; long tmp___6 ; long tmp___7 ; long tmp___8 ; long tmp___9 ; long tmp___10 ; long tmp___11 ; long tmp___12 ; long tmp___13 ; long tmp___14 ; long tmp___15 ; long tmp___16 ; long tmp___17 ; long tmp___18 ; long tmp___19 ; long tmp___20 ; long tmp___21 ; long tmp___22 ; long tmp___23 ; long tmp___24 ; long tmp___25 ; long tmp___26 ; long tmp___27 ; long tmp___28 ; { psspPayload = (struct ssp_event_resp___0 *)piomb + 4U; event = psspPayload->event; tag = psspPayload->tag; port_id = psspPayload->port_id; ccb = pm8001_ha->ccb_info + (unsigned long )tag; t = ccb->task; pm8001_dev = ccb->device; if (event != 0U) { { tmp = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:sas IO status 0x%x\n", "mpi_ssp_event", 1776, event); } } else { } } else { } { tmp___0 = ldv__builtin_expect((unsigned long )t == (unsigned long )((struct sas_task *)0), 0L); } if (tmp___0 != 0L) { tmp___2 = 1; } else { { tmp___1 = ldv__builtin_expect((unsigned long )t->lldd_task == (unsigned long )((void *)0), 0L); } if (tmp___1 != 0L) { tmp___2 = 1; } else { tmp___2 = 0; } } if (tmp___2 != 0) { return; } else { { tmp___3 = ldv__builtin_expect((unsigned long )t->dev == (unsigned long )((struct domain_device *)0), 0L); } if (tmp___3 != 0L) { return; } else { } } { ts = & t->task_status; tmp___4 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___4 != 0L) { { printk("\016pm80xx %s %d:port_id:0x%x, tag:0x%x, event:0x%x\n", "mpi_ssp_event", 1782, port_id, tag, event); } } else { } { if (event == 2U) { goto case_2; } else { } if (event == 14U) { goto case_14; } else { } if (event == 15U) { goto case_15; } else { } if (event == 16U) { goto case_16; } else { } if (event == 17U) { goto case_17; } else { } if (event == 18U) { goto case_18; } else { } if (event == 19U) { goto case_19; } else { } if (event == 68U) { goto case_68; } else { } if (event == 69U) { goto case_69; } else { } if (event == 70U) { goto case_70; } else { } if (event == 71U) { goto case_71; } else { } if (event == 72U) { goto case_72; } else { } if (event == 20U) { goto case_20; } else { } if (event == 21U) { goto case_21; } else { } if (event == 23U) { goto case_23; } else { } if (event == 25U) { goto case_25; } else { } if (event == 26U) { goto case_26; } else { } if (event == 36U) { goto case_36; } else { } if (event == 38U) { goto case_38; } else { } if (event == 39U) { goto case_39; } else { } if (event == 40U) { goto case_40; } else { } if (event == 48U) { goto case_48; } else { } if (event == 52U) { goto case_52; } else { } if (event == 53U) { goto case_53; } else { } if (event == 84U) { goto case_84; } else { } if (event == 54U) { goto case_54; } else { } goto switch_default; case_2: /* CIL Label */ { tmp___5 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___5 != 0L) { { printk("\016pm80xx %s %d:IO_UNDERFLOW\n", "mpi_ssp_event", 1785); } } else { } ts->resp = 0; ts->stat = 130; ts->residual = 0U; if ((unsigned long )pm8001_dev != (unsigned long )((struct pm8001_device *)0)) { pm8001_dev->running_req = pm8001_dev->running_req - 1U; } else { } goto ldv_46636; case_14: /* CIL Label */ { tmp___6 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___6 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_BREAK\n", "mpi_ssp_event", 1794); } } else { } { pm8001_handle_event(pm8001_ha, (void *)t, 14); } return; case_15: /* CIL Label */ { tmp___7 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___7 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_PHY_NOT_READY\n", "mpi_ssp_event", 1799); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 18; goto ldv_46636; case_16: /* CIL Label */ { tmp___8 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___8 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED\n", "mpi_ssp_event", 1806); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 3; goto ldv_46636; case_17: /* CIL Label */ { tmp___9 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___9 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_ZONE_VIOLATION\n", "mpi_ssp_event", 1813); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 0; goto ldv_46636; case_18: /* CIL Label */ { tmp___10 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___10 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_BREAK\n", "mpi_ssp_event", 1820); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 18; goto ldv_46636; case_19: /* CIL Label */ ; case_68: /* CIL Label */ ; case_69: /* CIL Label */ ; case_70: /* CIL Label */ ; case_71: /* CIL Label */ ; case_72: /* CIL Label */ { tmp___11 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___11 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS\n", "mpi_ssp_event", 1832); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 0; if ((unsigned long )t->uldd_task == (unsigned long )((void *)0)) { { pm8001_handle_event(pm8001_ha, (void *)pm8001_dev, 19); } } else { } goto ldv_46636; case_20: /* CIL Label */ { tmp___12 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___12 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_BAD_DESTINATION\n", "mpi_ssp_event", 1843); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 1; goto ldv_46636; case_21: /* CIL Label */ { tmp___13 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___13 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED\n", "mpi_ssp_event", 1850); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 2; goto ldv_46636; case_23: /* CIL Label */ { tmp___14 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___14 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_WRONG_DESTINATION\n", "mpi_ssp_event", 1857); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 8; goto ldv_46636; case_25: /* CIL Label */ { tmp___15 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___15 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_NAK_RECEIVED\n", "mpi_ssp_event", 1864); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 18; goto ldv_46636; case_26: /* CIL Label */ { tmp___16 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___16 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_ACK_NAK_TIMEOUT\n", "mpi_ssp_event", 1871); } } else { } ts->resp = 0; ts->stat = 139; goto ldv_46636; case_36: /* CIL Label */ { tmp___17 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___17 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_OPEN_RETRY_TIMEOUT\n", "mpi_ssp_event", 1877); } } else { } { pm8001_handle_event(pm8001_ha, (void *)t, 36); } return; case_38: /* CIL Label */ { tmp___18 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___18 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_UNEXPECTED_PHASE\n", "mpi_ssp_event", 1882); } } else { } ts->resp = 0; ts->stat = 130; goto ldv_46636; case_39: /* CIL Label */ { tmp___19 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___19 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_XFER_RDY_OVERRUN\n", "mpi_ssp_event", 1888); } } else { } ts->resp = 0; ts->stat = 130; goto ldv_46636; case_40: /* CIL Label */ { tmp___20 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___20 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_XFER_RDY_NOT_EXPECTED\n", "mpi_ssp_event", 1894); } } else { } ts->resp = 0; ts->stat = 130; goto ldv_46636; case_48: /* CIL Label */ { tmp___21 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___21 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_CMD_ISSUE_ACK_NAK_TIMEOUT\n", "mpi_ssp_event", 1900); } } else { } ts->resp = 0; ts->stat = 130; goto ldv_46636; case_52: /* CIL Label */ { tmp___22 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___22 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_OFFSET_MISMATCH\n", "mpi_ssp_event", 1906); } } else { } ts->resp = 0; ts->stat = 130; goto ldv_46636; case_53: /* CIL Label */ { tmp___23 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___23 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_XFER_ZERO_DATA_LEN\n", "mpi_ssp_event", 1912); } } else { } ts->resp = 0; ts->stat = 130; goto ldv_46636; case_84: /* CIL Label */ { tmp___24 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___24 != 0L) { { printk("\016pm80xx %s %d:IO_XFR_ERROR_INTERNAL_CRC_ERROR\n", "mpi_ssp_event", 1918); } } else { } ts->resp = 0; ts->stat = 130; goto ldv_46636; case_54: /* CIL Label */ { tmp___25 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___25 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_CMD_FRAME_ISSUED\n", "mpi_ssp_event", 1925); } } else { } return; switch_default: /* CIL Label */ { tmp___26 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___26 != 0L) { { printk("\016pm80xx %s %d:Unknown status 0x%x\n", "mpi_ssp_event", 1929, event); } } else { } ts->resp = 0; ts->stat = 130; goto ldv_46636; switch_break: /* CIL Label */ ; } ldv_46636: { ldv___ldv_linux_kernel_locking_spinlock_spin_lock_103(& t->task_state_lock); t->task_state_flags = t->task_state_flags & 4294967294U; t->task_state_flags = t->task_state_flags & 4294967279U; t->task_state_flags = t->task_state_flags | 2U; tmp___28 = ldv__builtin_expect((t->task_state_flags & 4U) != 0U, 0L); } if (tmp___28 != 0L) { { ldv_spin_unlock_irqrestore_135(& t->task_state_lock, flags); tmp___27 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___27 != 0L) { { printk("\016pm80xx %s %d:task 0x%p done with event 0x%x resp 0x%x stat 0x%x but aborted by upper layer!\n", "mpi_ssp_event", 1944, t, event, (int )ts->resp, (unsigned int )ts->stat); } } else { } { pm8001_ccb_task_free(pm8001_ha, t, ccb, tag); } } else { { ldv_spin_unlock_irqrestore_135(& t->task_state_lock, flags); pm8001_ccb_task_free(pm8001_ha, t, ccb, tag); __asm__ volatile ("mfence": : : "memory"); (*(t->task_done))(t); } } return; } } static void mpi_sata_completion___0(struct pm8001_hba_info *pm8001_ha , void *piomb ) { struct sas_task *t ; struct pm8001_ccb_info *ccb ; u32 param ; u32 status ; u32 tag ; int i ; int j ; u8 sata_addr_low[4U] ; u32 temp_sata_addr_low ; u32 temp_sata_addr_hi ; u8 sata_addr_hi[4U] ; struct sata_completion_resp *psataPayload ; struct task_status_struct *ts ; struct ata_task_resp *resp ; u32 *sata_resp ; struct pm8001_device *pm8001_dev ; unsigned long flags ; long tmp ; long tmp___0 ; long tmp___1 ; long tmp___2 ; long tmp___3 ; long tmp___4 ; int tmp___5 ; long tmp___6 ; long tmp___7 ; long tmp___8 ; __u64 tmp___9 ; long tmp___10 ; long tmp___11 ; u8 len ; long tmp___12 ; long tmp___13 ; long tmp___14 ; long tmp___15 ; long tmp___17 ; long tmp___18 ; long tmp___19 ; long tmp___20 ; long tmp___21 ; long tmp___22 ; long tmp___23 ; long tmp___24 ; long tmp___25 ; long tmp___26 ; long tmp___27 ; long tmp___28 ; long tmp___29 ; long tmp___30 ; long tmp___31 ; long tmp___32 ; long tmp___33 ; long tmp___34 ; long tmp___35 ; long tmp___36 ; long tmp___37 ; long tmp___38 ; long tmp___39 ; long tmp___40 ; long tmp___41 ; long tmp___42 ; long tmp___43 ; { psataPayload = (struct sata_completion_resp *)piomb + 4U; status = psataPayload->status; tag = psataPayload->tag; if (tag == 0U) { { tmp = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:tag null\n", "mpi_sata_completion", 1980); } } else { } return; } else { } ccb = pm8001_ha->ccb_info + (unsigned long )tag; param = psataPayload->param; if ((unsigned long )ccb != (unsigned long )((struct pm8001_ccb_info *)0)) { t = ccb->task; pm8001_dev = ccb->device; } else { { tmp___0 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___0 != 0L) { { printk("\016pm80xx %s %d:ccb null\n", "mpi_sata_completion", 1990); } } else { } return; } if ((unsigned long )t != (unsigned long )((struct sas_task *)0)) { if ((unsigned long )t->dev != (unsigned long )((struct domain_device *)0) && (unsigned long )(t->dev)->lldd_dev != (unsigned long )((void *)0)) { pm8001_dev = (struct pm8001_device *)(t->dev)->lldd_dev; } else { } } else { { tmp___1 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___1 != 0L) { { printk("\016pm80xx %s %d:task null\n", "mpi_sata_completion", 1999); } } else { } return; } if ((unsigned long )pm8001_dev != (unsigned long )((struct pm8001_device *)0) && (int )pm8001_dev->id >= 0) { { tmp___3 = ldv__builtin_expect((unsigned long )t == (unsigned long )((struct sas_task *)0), 0L); } if (tmp___3 != 0L) { tmp___5 = 1; } else { { tmp___4 = ldv__builtin_expect((unsigned long )t->lldd_task == (unsigned long )((void *)0), 0L); } if (tmp___4 != 0L) { tmp___5 = 1; } else { tmp___5 = 0; } } if (tmp___5 != 0) { goto _L; } else { { tmp___6 = ldv__builtin_expect((unsigned long )t->dev == (unsigned long )((struct domain_device *)0), 0L); } if (tmp___6 != 0L) { _L: /* CIL Label */ { tmp___2 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___2 != 0L) { { printk("\016pm80xx %s %d:task or dev null\n", "mpi_sata_completion", 2006); } } else { } return; } else { } } } else { } ts = & t->task_status; if ((unsigned long )ts == (unsigned long )((struct task_status_struct *)0)) { { tmp___7 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___7 != 0L) { { printk("\016pm80xx %s %d:ts null\n", "mpi_sata_completion", 2013); } } else { } return; } else { } if ((status != 0U && status != 2U) && status != 3U) { if ((unsigned long )(t->dev)->parent == (unsigned long )((struct domain_device *)0) || (unsigned int )((t->dev)->parent)->dev_type - 2U > 1U) { i = 0; j = 4; goto ldv_46686; ldv_46685: sata_addr_low[i] = pm8001_ha->sas_addr[j]; i = i + 1; j = j + 1; ldv_46686: ; if (i <= 3 && j <= 7) { goto ldv_46685; } else { } i = 0; j = 0; goto ldv_46689; ldv_46688: sata_addr_hi[i] = pm8001_ha->sas_addr[j]; i = i + 1; j = j + 1; ldv_46689: ; if (i <= 3 && j <= 3) { goto ldv_46688; } else { } { __memcpy((void *)(& temp_sata_addr_low), (void const *)(& sata_addr_low), 4UL); __memcpy((void *)(& temp_sata_addr_hi), (void const *)(& sata_addr_hi), 4UL); temp_sata_addr_hi = (((temp_sata_addr_hi >> 24) | ((temp_sata_addr_hi << 8) & 16711680U)) | ((temp_sata_addr_hi >> 8) & 65280U)) | (temp_sata_addr_hi << 24); temp_sata_addr_low = (((((temp_sata_addr_low >> 24) | ((temp_sata_addr_low << 8) & 16711680U)) | ((temp_sata_addr_low >> 8) & 65280U)) | (temp_sata_addr_low << 24)) + pm8001_dev->attached_phy) + 16U; tmp___8 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___8 != 0L) { { printk("\016pm80xx %s %d:SAS Address of IO Failure Drive:%08x%08x", "mpi_sata_completion", 2049, temp_sata_addr_hi, temp_sata_addr_low); } } else { } } else { { tmp___10 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___10 != 0L) { { tmp___9 = __fswab64(*((__be64 *)(& (t->dev)->sas_addr))); printk("\016pm80xx %s %d:SAS Address of IO Failure Drive:%016llx", "mpi_sata_completion", 2054, tmp___9); } } else { } } } else { } { if (status == 0U) { goto case_0; } else { } if (status == 1U) { goto case_1; } else { } if (status == 3U) { goto case_3; } else { } if (status == 7U) { goto case_7; } else { } if (status == 14U) { goto case_14; } else { } if (status == 15U) { goto case_15; } else { } if (status == 16U) { goto case_16; } else { } if (status == 17U) { goto case_17; } else { } if (status == 18U) { goto case_18; } else { } if (status == 19U) { goto case_19; } else { } if (status == 68U) { goto case_68; } else { } if (status == 69U) { goto case_69; } else { } if (status == 70U) { goto case_70; } else { } if (status == 71U) { goto case_71; } else { } if (status == 72U) { goto case_72; } else { } if (status == 20U) { goto case_20; } else { } if (status == 21U) { goto case_21; } else { } if (status == 22U) { goto case_22; } else { } if (status == 23U) { goto case_23; } else { } if (status == 25U) { goto case_25; } else { } if (status == 26U) { goto case_26; } else { } if (status == 29U) { goto case_29; } else { } if (status == 31U) { goto case_31; } else { } if (status == 33U) { goto case_33; } else { } if (status == 36U) { goto case_36; } else { } if (status == 56U) { goto case_56; } else { } if (status == 57U) { goto case_57; } else { } if (status == 58U) { goto case_58; } else { } if (status == 62U) { goto case_62; } else { } if (status == 63U) { goto case_63; } else { } goto switch_default; case_0: /* CIL Label */ { tmp___11 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___11 != 0L) { { printk("\016pm80xx %s %d:IO_SUCCESS\n", "mpi_sata_completion", 2059); } } else { } if (param == 0U) { ts->resp = 0; ts->stat = 0; if ((unsigned long )pm8001_dev != (unsigned long )((struct pm8001_device *)0) && (int )pm8001_dev->id < 0) { { pm8001_dev->id = pm8001_dev->id | 1073741824U; pm8001_dev->id = pm8001_dev->id & 2147483647U; pm80xx_send_abort_all(pm8001_ha, pm8001_dev); pm8001_tag_free(pm8001_ha, tag); sas_free_task(t); } return; } else { } } else { { ts->resp = 0; ts->stat = 137; ts->residual = param; tmp___12 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___12 != 0L) { { printk("\016pm80xx %s %d:SAS_PROTO_RESPONSE len = %d\n", "mpi_sata_completion", 2083, param); } } else { } sata_resp = (u32 *)(& psataPayload->sata_resp); resp = (struct ata_task_resp *)(& ts->buf); if ((unsigned int )*((unsigned char *)t + 125UL) == 0U && (unsigned int )*((unsigned char *)t + 184UL) == 2U) { { len = 19U; tmp___13 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___13 != 0L) { { printk("\016pm80xx %s %d:PIO read len = %d\n", "mpi_sata_completion", 2090, (int )len); } } else { } } else if ((unsigned int )*((unsigned char *)t + 125UL) != 0U) { { len = 8U; tmp___14 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___14 != 0L) { { printk("\016pm80xx %s %d:FPDMA len = %d\n", "mpi_sata_completion", 2094, (int )len); } } else { } } else { { len = 20U; tmp___15 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___15 != 0L) { { printk("\016pm80xx %s %d:other len = %d\n", "mpi_sata_completion", 2098, (int )len); } } else { } } { resp->frame_len = (u16 )len; __memcpy((void *)(& resp->ending_fis), (void const *)sata_resp, (size_t )len); ts->buf_valid_size = 26; } } if ((unsigned long )pm8001_dev != (unsigned long )((struct pm8001_device *)0)) { pm8001_dev->running_req = pm8001_dev->running_req - 1U; } else { } goto ldv_46693; case_1: /* CIL Label */ { tmp___17 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___17 != 0L) { { printk("\016pm80xx %s %d:IO_ABORTED IOMB Tag\n", "mpi_sata_completion", 2113); } } else { } ts->resp = 0; ts->stat = 141; if ((unsigned long )pm8001_dev != (unsigned long )((struct pm8001_device *)0)) { pm8001_dev->running_req = pm8001_dev->running_req - 1U; } else { } goto ldv_46693; case_3: /* CIL Label */ { tmp___18 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___18 != 0L) { { printk("\016pm80xx %s %d:IO_UNDERFLOW param = %d\n", "mpi_sata_completion", 2123, param); } } else { } ts->resp = 0; ts->stat = 129; ts->residual = param; if ((unsigned long )pm8001_dev != (unsigned long )((struct pm8001_device *)0)) { pm8001_dev->running_req = pm8001_dev->running_req - 1U; } else { } goto ldv_46693; case_7: /* CIL Label */ { tmp___19 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___19 != 0L) { { printk("\016pm80xx %s %d:IO_NO_DEVICE\n", "mpi_sata_completion", 2132); } } else { } ts->resp = -1; ts->stat = 138; goto ldv_46693; case_14: /* CIL Label */ { tmp___20 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___20 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_BREAK\n", "mpi_sata_completion", 2138); } } else { } ts->resp = 0; ts->stat = 131; goto ldv_46693; case_15: /* CIL Label */ { tmp___21 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___21 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_PHY_NOT_READY\n", "mpi_sata_completion", 2144); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 18; goto ldv_46693; case_16: /* CIL Label */ { tmp___22 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___22 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED\n", "mpi_sata_completion", 2151); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 3; goto ldv_46693; case_17: /* CIL Label */ { tmp___23 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___23 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_ZONE_VIOLATION\n", "mpi_sata_completion", 2158); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 0; goto ldv_46693; case_18: /* CIL Label */ { tmp___24 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___24 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_BREAK\n", "mpi_sata_completion", 2165); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 12; goto ldv_46693; case_19: /* CIL Label */ ; case_68: /* CIL Label */ ; case_69: /* CIL Label */ ; case_70: /* CIL Label */ ; case_71: /* CIL Label */ ; case_72: /* CIL Label */ { tmp___25 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___25 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS\n", "mpi_sata_completion", 2177); } } else { } ts->resp = 0; ts->stat = 128; if ((unsigned long )t->uldd_task == (unsigned long )((void *)0)) { { pm8001_handle_event(pm8001_ha, (void *)pm8001_dev, 19); ts->resp = -1; ts->stat = 132; pm8001_ccb_task_free_done___0(pm8001_ha, t, ccb, tag); } return; } else { } goto ldv_46693; case_20: /* CIL Label */ { tmp___26 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___26 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_BAD_DESTINATION\n", "mpi_sata_completion", 2192); } } else { } ts->resp = -1; ts->stat = 135; ts->open_rej_reason = 1; if ((unsigned long )t->uldd_task == (unsigned long )((void *)0)) { { pm8001_handle_event(pm8001_ha, (void *)pm8001_dev, 19); ts->resp = -1; ts->stat = 132; pm8001_ccb_task_free_done___0(pm8001_ha, t, ccb, tag); } return; } else { } goto ldv_46693; case_21: /* CIL Label */ { tmp___27 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___27 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED\n", "mpi_sata_completion", 2208); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 2; goto ldv_46693; case_22: /* CIL Label */ { tmp___28 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___28 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY\n", "mpi_sata_completion", 2215); } } else { } ts->resp = 0; ts->stat = 128; if ((unsigned long )t->uldd_task == (unsigned long )((void *)0)) { { pm8001_handle_event(pm8001_ha, (void *)pm8001_dev, 22); ts->resp = -1; ts->stat = 132; pm8001_ccb_task_free_done___0(pm8001_ha, t, ccb, tag); } return; } else { } goto ldv_46693; case_23: /* CIL Label */ { tmp___29 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___29 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_WRONG_DESTINATION\n", "mpi_sata_completion", 2230); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 8; goto ldv_46693; case_25: /* CIL Label */ { tmp___30 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___30 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_NAK_RECEIVED\n", "mpi_sata_completion", 2237); } } else { } ts->resp = 0; ts->stat = 139; goto ldv_46693; case_26: /* CIL Label */ { tmp___31 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___31 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_ACK_NAK_TIMEOUT\n", "mpi_sata_completion", 2243); } } else { } ts->resp = 0; ts->stat = 139; goto ldv_46693; case_29: /* CIL Label */ { tmp___32 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___32 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_DMA\n", "mpi_sata_completion", 2249); } } else { } ts->resp = 0; ts->stat = 141; goto ldv_46693; case_31: /* CIL Label */ { tmp___33 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___33 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_SATA_LINK_TIMEOUT\n", "mpi_sata_completion", 2255); } } else { } ts->resp = -1; ts->stat = 128; goto ldv_46693; case_33: /* CIL Label */ { tmp___34 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___34 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_REJECTED_NCQ_MODE\n", "mpi_sata_completion", 2261); } } else { } ts->resp = 0; ts->stat = 129; goto ldv_46693; case_36: /* CIL Label */ { tmp___35 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___35 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_OPEN_RETRY_TIMEOUT\n", "mpi_sata_completion", 2267); } } else { } ts->resp = 0; ts->stat = 136; goto ldv_46693; case_56: /* CIL Label */ { tmp___36 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___36 != 0L) { { printk("\016pm80xx %s %d:IO_PORT_IN_RESET\n", "mpi_sata_completion", 2273); } } else { } ts->resp = 0; ts->stat = 128; goto ldv_46693; case_57: /* CIL Label */ { tmp___37 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___37 != 0L) { { printk("\016pm80xx %s %d:IO_DS_NON_OPERATIONAL\n", "mpi_sata_completion", 2279); } } else { } ts->resp = 0; ts->stat = 128; if ((unsigned long )t->uldd_task == (unsigned long )((void *)0)) { { pm8001_handle_event(pm8001_ha, (void *)pm8001_dev, 57); ts->resp = -1; ts->stat = 132; pm8001_ccb_task_free_done___0(pm8001_ha, t, ccb, tag); } return; } else { } goto ldv_46693; case_58: /* CIL Label */ { tmp___38 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___38 != 0L) { { printk("\016pm80xx %s %d:IO_DS_IN_RECOVERY\n", "mpi_sata_completion", 2293); } } else { } ts->resp = 0; ts->stat = 128; goto ldv_46693; case_62: /* CIL Label */ { tmp___39 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___39 != 0L) { { printk("\016pm80xx %s %d:IO_DS_IN_ERROR\n", "mpi_sata_completion", 2299); } } else { } ts->resp = 0; ts->stat = 128; if ((unsigned long )t->uldd_task == (unsigned long )((void *)0)) { { pm8001_handle_event(pm8001_ha, (void *)pm8001_dev, 62); ts->resp = -1; ts->stat = 132; pm8001_ccb_task_free_done___0(pm8001_ha, t, ccb, tag); } return; } else { } goto ldv_46693; case_63: /* CIL Label */ { tmp___40 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___40 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_HW_RESOURCE_BUSY\n", "mpi_sata_completion", 2313); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 18; switch_default: /* CIL Label */ { tmp___41 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___41 != 0L) { { printk("\016pm80xx %s %d:Unknown status 0x%x\n", "mpi_sata_completion", 2319, status); } } else { } ts->resp = 0; ts->stat = 128; goto ldv_46693; switch_break: /* CIL Label */ ; } ldv_46693: { ldv___ldv_linux_kernel_locking_spinlock_spin_lock_106(& t->task_state_lock); t->task_state_flags = t->task_state_flags & 4294967294U; t->task_state_flags = t->task_state_flags & 4294967279U; t->task_state_flags = t->task_state_flags | 2U; tmp___43 = ldv__builtin_expect((t->task_state_flags & 4U) != 0U, 0L); } if (tmp___43 != 0L) { { ldv_spin_unlock_irqrestore_135(& t->task_state_lock, flags); tmp___42 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___42 != 0L) { { printk("\016pm80xx %s %d:task 0x%p done with io_status 0x%x resp 0x%x stat 0x%x but aborted by upper layer!\n", "mpi_sata_completion", 2334, t, status, (int )ts->resp, (unsigned int )ts->stat); } } else { } { pm8001_ccb_task_free(pm8001_ha, t, ccb, tag); } } else { { ldv_spin_unlock_irqrestore_135(& t->task_state_lock, flags); pm8001_ccb_task_free_done___0(pm8001_ha, t, ccb, tag); } } return; } } static void mpi_sata_event___0(struct pm8001_hba_info *pm8001_ha , void *piomb ) { struct sas_task *t ; struct task_status_struct *ts ; struct pm8001_ccb_info *ccb ; struct pm8001_device *pm8001_dev ; struct sata_event_resp___0 *psataPayload ; u32 event ; u32 tag ; u32 port_id ; u32 dev_id ; unsigned long flags ; long tmp ; long tmp___0 ; long tmp___1 ; long tmp___2 ; long tmp___3 ; int tmp___4 ; long tmp___5 ; long tmp___6 ; long tmp___7 ; long tmp___8 ; long tmp___9 ; long tmp___10 ; long tmp___11 ; long tmp___12 ; long tmp___13 ; long tmp___14 ; long tmp___15 ; long tmp___16 ; long tmp___17 ; long tmp___18 ; long tmp___19 ; long tmp___20 ; long tmp___21 ; long tmp___22 ; long tmp___23 ; long tmp___24 ; long tmp___25 ; long tmp___26 ; long tmp___27 ; long tmp___28 ; long tmp___29 ; long tmp___30 ; long tmp___31 ; long tmp___32 ; { psataPayload = (struct sata_event_resp___0 *)piomb + 4U; event = psataPayload->event; tag = psataPayload->tag; port_id = psataPayload->port_id; dev_id = psataPayload->device_id; ccb = pm8001_ha->ccb_info + (unsigned long )tag; if ((unsigned long )ccb != (unsigned long )((struct pm8001_ccb_info *)0)) { t = ccb->task; pm8001_dev = ccb->device; } else { { tmp = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:No CCB !!!. returning\n", "mpi_sata_event", 2364); } } else { } return; } if (event != 0U) { { tmp___0 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___0 != 0L) { { printk("\016pm80xx %s %d:SATA EVENT 0x%x\n", "mpi_sata_event", 2369, event); } } else { } } else { } if (event == 35U) { { pm8001_dev = pm8001_find_dev(pm8001_ha, dev_id); } if ((unsigned long )pm8001_dev != (unsigned long )((struct pm8001_device *)0)) { { pm80xx_send_read_log(pm8001_ha, pm8001_dev); } } else { } return; } else { } { tmp___2 = ldv__builtin_expect((unsigned long )t == (unsigned long )((struct sas_task *)0), 0L); } if (tmp___2 != 0L) { tmp___4 = 1; } else { { tmp___3 = ldv__builtin_expect((unsigned long )t->lldd_task == (unsigned long )((void *)0), 0L); } if (tmp___3 != 0L) { tmp___4 = 1; } else { tmp___4 = 0; } } if (tmp___4 != 0) { goto _L; } else { { tmp___5 = ldv__builtin_expect((unsigned long )t->dev == (unsigned long )((struct domain_device *)0), 0L); } if (tmp___5 != 0L) { _L: /* CIL Label */ { tmp___1 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___1 != 0L) { { printk("\016pm80xx %s %d:task or dev null\n", "mpi_sata_event", 2383); } } else { } return; } else { } } { ts = & t->task_status; tmp___6 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___6 != 0L) { { printk("\016pm80xx %s %d:port_id:0x%x, tag:0x%x, event:0x%x\n", "mpi_sata_event", 2390, port_id, tag, event); } } else { } { if (event == 2U) { goto case_2; } else { } if (event == 14U) { goto case_14; } else { } if (event == 15U) { goto case_15; } else { } if (event == 16U) { goto case_16; } else { } if (event == 17U) { goto case_17; } else { } if (event == 18U) { goto case_18; } else { } if (event == 19U) { goto case_19; } else { } if (event == 68U) { goto case_68; } else { } if (event == 69U) { goto case_69; } else { } if (event == 70U) { goto case_70; } else { } if (event == 71U) { goto case_71; } else { } if (event == 72U) { goto case_72; } else { } if (event == 20U) { goto case_20; } else { } if (event == 21U) { goto case_21; } else { } if (event == 23U) { goto case_23; } else { } if (event == 25U) { goto case_25; } else { } if (event == 27U) { goto case_27; } else { } if (event == 33U) { goto case_33; } else { } if (event == 36U) { goto case_36; } else { } if (event == 38U) { goto case_38; } else { } if (event == 39U) { goto case_39; } else { } if (event == 40U) { goto case_40; } else { } if (event == 52U) { goto case_52; } else { } if (event == 53U) { goto case_53; } else { } if (event == 54U) { goto case_54; } else { } if (event == 60U) { goto case_60; } else { } if (event == 84U) { goto case_84; } else { } if (event == 83U) { goto case_83; } else { } goto switch_default; case_2: /* CIL Label */ { tmp___7 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___7 != 0L) { { printk("\016pm80xx %s %d:IO_UNDERFLOW\n", "mpi_sata_event", 2393); } } else { } ts->resp = 0; ts->stat = 130; ts->residual = 0U; if ((unsigned long )pm8001_dev != (unsigned long )((struct pm8001_device *)0)) { pm8001_dev->running_req = pm8001_dev->running_req - 1U; } else { } goto ldv_46740; case_14: /* CIL Label */ { tmp___8 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___8 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_BREAK\n", "mpi_sata_event", 2402); } } else { } ts->resp = 0; ts->stat = 131; goto ldv_46740; case_15: /* CIL Label */ { tmp___9 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___9 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_PHY_NOT_READY\n", "mpi_sata_event", 2408); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 18; goto ldv_46740; case_16: /* CIL Label */ { tmp___10 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___10 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED\n", "mpi_sata_event", 2415); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 3; goto ldv_46740; case_17: /* CIL Label */ { tmp___11 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___11 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_ZONE_VIOLATION\n", "mpi_sata_event", 2422); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 0; goto ldv_46740; case_18: /* CIL Label */ { tmp___12 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___12 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_BREAK\n", "mpi_sata_event", 2429); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 12; goto ldv_46740; case_19: /* CIL Label */ ; case_68: /* CIL Label */ ; case_69: /* CIL Label */ ; case_70: /* CIL Label */ ; case_71: /* CIL Label */ ; case_72: /* CIL Label */ { tmp___13 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___13 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS\n", "mpi_sata_event", 2441); } } else { } ts->resp = -1; ts->stat = 128; if ((unsigned long )t->uldd_task == (unsigned long )((void *)0)) { { pm8001_handle_event(pm8001_ha, (void *)pm8001_dev, 19); ts->resp = 0; ts->stat = 132; pm8001_ccb_task_free_done___0(pm8001_ha, t, ccb, tag); } return; } else { } goto ldv_46740; case_20: /* CIL Label */ { tmp___14 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___14 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_BAD_DESTINATION\n", "mpi_sata_event", 2456); } } else { } ts->resp = -1; ts->stat = 135; ts->open_rej_reason = 1; goto ldv_46740; case_21: /* CIL Label */ { tmp___15 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___15 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED\n", "mpi_sata_event", 2463); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 2; goto ldv_46740; case_23: /* CIL Label */ { tmp___16 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___16 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_WRONG_DESTINATION\n", "mpi_sata_event", 2470); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 8; goto ldv_46740; case_25: /* CIL Label */ { tmp___17 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___17 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_NAK_RECEIVED\n", "mpi_sata_event", 2477); } } else { } ts->resp = 0; ts->stat = 139; goto ldv_46740; case_27: /* CIL Label */ { tmp___18 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___18 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_PEER_ABORTED\n", "mpi_sata_event", 2483); } } else { } ts->resp = 0; ts->stat = 139; goto ldv_46740; case_33: /* CIL Label */ { tmp___19 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___19 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_REJECTED_NCQ_MODE\n", "mpi_sata_event", 2489); } } else { } ts->resp = 0; ts->stat = 129; goto ldv_46740; case_36: /* CIL Label */ { tmp___20 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___20 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_OPEN_RETRY_TIMEOUT\n", "mpi_sata_event", 2495); } } else { } ts->resp = 0; ts->stat = 136; goto ldv_46740; case_38: /* CIL Label */ { tmp___21 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___21 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_UNEXPECTED_PHASE\n", "mpi_sata_event", 2501); } } else { } ts->resp = 0; ts->stat = 136; goto ldv_46740; case_39: /* CIL Label */ { tmp___22 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___22 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_XFER_RDY_OVERRUN\n", "mpi_sata_event", 2507); } } else { } ts->resp = 0; ts->stat = 136; goto ldv_46740; case_40: /* CIL Label */ { tmp___23 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___23 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_XFER_RDY_NOT_EXPECTED\n", "mpi_sata_event", 2513); } } else { } ts->resp = 0; ts->stat = 136; goto ldv_46740; case_52: /* CIL Label */ { tmp___24 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___24 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_OFFSET_MISMATCH\n", "mpi_sata_event", 2519); } } else { } ts->resp = 0; ts->stat = 136; goto ldv_46740; case_53: /* CIL Label */ { tmp___25 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___25 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_XFER_ZERO_DATA_LEN\n", "mpi_sata_event", 2525); } } else { } ts->resp = 0; ts->stat = 136; goto ldv_46740; case_54: /* CIL Label */ { tmp___26 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___26 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_CMD_FRAME_ISSUED\n", "mpi_sata_event", 2531); } } else { } goto ldv_46740; case_60: /* CIL Label */ { tmp___27 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___27 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_PIO_SETUP_ERROR\n", "mpi_sata_event", 2535); } } else { } ts->resp = 0; ts->stat = 136; goto ldv_46740; case_84: /* CIL Label */ { tmp___28 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___28 != 0L) { { printk("\016pm80xx %s %d:IO_XFR_ERROR_INTERNAL_CRC_ERROR\n", "mpi_sata_event", 2541); } } else { } ts->resp = 0; ts->stat = 136; goto ldv_46740; case_83: /* CIL Label */ { tmp___29 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___29 != 0L) { { printk("\016pm80xx %s %d:IO_XFR_DMA_ACTIVATE_TIMEOUT\n", "mpi_sata_event", 2548); } } else { } ts->resp = 0; ts->stat = 136; goto ldv_46740; switch_default: /* CIL Label */ { tmp___30 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___30 != 0L) { { printk("\016pm80xx %s %d:Unknown status 0x%x\n", "mpi_sata_event", 2555, event); } } else { } ts->resp = 0; ts->stat = 136; goto ldv_46740; switch_break: /* CIL Label */ ; } ldv_46740: { ldv___ldv_linux_kernel_locking_spinlock_spin_lock_109(& t->task_state_lock); t->task_state_flags = t->task_state_flags & 4294967294U; t->task_state_flags = t->task_state_flags & 4294967279U; t->task_state_flags = t->task_state_flags | 2U; tmp___32 = ldv__builtin_expect((t->task_state_flags & 4U) != 0U, 0L); } if (tmp___32 != 0L) { { ldv_spin_unlock_irqrestore_135(& t->task_state_lock, flags); tmp___31 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___31 != 0L) { { printk("\016pm80xx %s %d:task 0x%p done with io_status 0x%x resp 0x%x stat 0x%x but aborted by upper layer!\n", "mpi_sata_event", 2570, t, event, (int )ts->resp, (unsigned int )ts->stat); } } else { } { pm8001_ccb_task_free(pm8001_ha, t, ccb, tag); } } else { { ldv_spin_unlock_irqrestore_135(& t->task_state_lock, flags); pm8001_ccb_task_free_done___0(pm8001_ha, t, ccb, tag); } } return; } } static void mpi_smp_completion___0(struct pm8001_hba_info *pm8001_ha , void *piomb ) { u32 param ; u32 i ; struct sas_task *t ; struct pm8001_ccb_info *ccb ; unsigned long flags ; u32 status ; u32 tag ; struct smp_completion_resp___0 *psmpPayload ; struct task_status_struct *ts ; struct pm8001_device *pm8001_dev ; char *pdma_respaddr ; long tmp ; long tmp___0 ; long tmp___1 ; int tmp___2 ; long tmp___3 ; long tmp___4 ; long tmp___5 ; void *tmp___6 ; long tmp___7 ; long tmp___8 ; long tmp___9 ; long tmp___10 ; long tmp___11 ; long tmp___12 ; long tmp___13 ; long tmp___14 ; long tmp___15 ; long tmp___16 ; long tmp___17 ; long tmp___18 ; long tmp___19 ; long tmp___20 ; long tmp___21 ; long tmp___22 ; long tmp___23 ; long tmp___24 ; long tmp___25 ; long tmp___26 ; long tmp___27 ; long tmp___28 ; long tmp___29 ; long tmp___30 ; { pdma_respaddr = (char *)0; psmpPayload = (struct smp_completion_resp___0 *)piomb + 4U; status = psmpPayload->status; tag = psmpPayload->tag; ccb = pm8001_ha->ccb_info + (unsigned long )tag; param = psmpPayload->param; t = ccb->task; ts = & t->task_status; pm8001_dev = ccb->device; if (status != 0U) { { tmp = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:smp IO status 0x%x\n", "mpi_smp_completion", 2604, status); } } else { } } else { } { tmp___0 = ldv__builtin_expect((unsigned long )t == (unsigned long )((struct sas_task *)0), 0L); } if (tmp___0 != 0L) { tmp___2 = 1; } else { { tmp___1 = ldv__builtin_expect((unsigned long )t->lldd_task == (unsigned long )((void *)0), 0L); } if (tmp___1 != 0L) { tmp___2 = 1; } else { tmp___2 = 0; } } if (tmp___2 != 0) { return; } else { { tmp___3 = ldv__builtin_expect((unsigned long )t->dev == (unsigned long )((struct domain_device *)0), 0L); } if (tmp___3 != 0L) { return; } else { } } { if (status == 0U) { goto case_0; } else { } if (status == 1U) { goto case_1; } else { } if (status == 2U) { goto case_2; } else { } if (status == 7U) { goto case_7; } else { } if (status == 13U) { goto case_13; } else { } if (status == 14U) { goto case_14; } else { } if (status == 15U) { goto case_15; } else { } if (status == 16U) { goto case_16; } else { } if (status == 17U) { goto case_17; } else { } if (status == 18U) { goto case_18; } else { } if (status == 19U) { goto case_19; } else { } if (status == 68U) { goto case_68; } else { } if (status == 69U) { goto case_69; } else { } if (status == 70U) { goto case_70; } else { } if (status == 71U) { goto case_71; } else { } if (status == 72U) { goto case_72; } else { } if (status == 20U) { goto case_20; } else { } if (status == 21U) { goto case_21; } else { } if (status == 23U) { goto case_23; } else { } if (status == 28U) { goto case_28; } else { } if (status == 36U) { goto case_36; } else { } if (status == 55U) { goto case_55; } else { } if (status == 56U) { goto case_56; } else { } if (status == 57U) { goto case_57; } else { } if (status == 58U) { goto case_58; } else { } if (status == 63U) { goto case_63; } else { } goto switch_default; case_0: /* CIL Label */ { tmp___4 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___4 != 0L) { { printk("\016pm80xx %s %d:IO_SUCCESS\n", "mpi_smp_completion", 2611); } } else { } ts->resp = 0; ts->stat = 0; if ((unsigned long )pm8001_dev != (unsigned long )((struct pm8001_device *)0)) { pm8001_dev->running_req = pm8001_dev->running_req - 1U; } else { } if (pm8001_ha->smp_exp_mode == 1U) { { tmp___5 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___5 != 0L) { { printk("\016pm80xx %s %d:DIRECT RESPONSE Length:%d\n", "mpi_smp_completion", 2619, param); } } else { } { tmp___6 = phys_to_virt(t->__annonCompField95.smp_task.smp_resp.dma_address); pdma_respaddr = (char *)tmp___6; i = 0U; } goto ldv_46787; ldv_46786: { *(pdma_respaddr + (unsigned long )i) = (char )psmpPayload->_r_a[i]; tmp___7 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___7 != 0L) { { printk("\016pm80xx %s %d:SMP Byte%d DMA data 0x%x psmp 0x%x\n", "mpi_smp_completion", 2628, i, (int )*(pdma_respaddr + (unsigned long )i), (int )psmpPayload->_r_a[i]); } } else { } i = i + 1U; ldv_46787: ; if (i < param) { goto ldv_46786; } else { } } else { } goto ldv_46789; case_1: /* CIL Label */ { tmp___8 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___8 != 0L) { { printk("\016pm80xx %s %d:IO_ABORTED IOMB\n", "mpi_smp_completion", 2634); } } else { } ts->resp = 0; ts->stat = 141; if ((unsigned long )pm8001_dev != (unsigned long )((struct pm8001_device *)0)) { pm8001_dev->running_req = pm8001_dev->running_req - 1U; } else { } goto ldv_46789; case_2: /* CIL Label */ { tmp___9 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___9 != 0L) { { printk("\016pm80xx %s %d:IO_UNDERFLOW\n", "mpi_smp_completion", 2641); } } else { } ts->resp = 0; ts->stat = 130; ts->residual = 0U; if ((unsigned long )pm8001_dev != (unsigned long )((struct pm8001_device *)0)) { pm8001_dev->running_req = pm8001_dev->running_req - 1U; } else { } goto ldv_46789; case_7: /* CIL Label */ { tmp___10 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___10 != 0L) { { printk("\016pm80xx %s %d:IO_NO_DEVICE\n", "mpi_smp_completion", 2649); } } else { } ts->resp = 0; ts->stat = 138; goto ldv_46789; case_13: /* CIL Label */ { tmp___11 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___11 != 0L) { { printk("\016pm80xx %s %d:IO_ERROR_HW_TIMEOUT\n", "mpi_smp_completion", 2655); } } else { } ts->resp = 0; ts->stat = 8; goto ldv_46789; case_14: /* CIL Label */ { tmp___12 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___12 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_BREAK\n", "mpi_smp_completion", 2661); } } else { } ts->resp = 0; ts->stat = 8; goto ldv_46789; case_15: /* CIL Label */ { tmp___13 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___13 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_PHY_NOT_READY\n", "mpi_smp_completion", 2667); } } else { } ts->resp = 0; ts->stat = 8; goto ldv_46789; case_16: /* CIL Label */ { tmp___14 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___14 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED\n", "mpi_smp_completion", 2673); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 0; goto ldv_46789; case_17: /* CIL Label */ { tmp___15 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___15 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_ZONE_VIOLATION\n", "mpi_smp_completion", 2680); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 0; goto ldv_46789; case_18: /* CIL Label */ { tmp___16 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___16 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_BREAK\n", "mpi_smp_completion", 2687); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 12; goto ldv_46789; case_19: /* CIL Label */ ; case_68: /* CIL Label */ ; case_69: /* CIL Label */ ; case_70: /* CIL Label */ ; case_71: /* CIL Label */ ; case_72: /* CIL Label */ { tmp___17 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___17 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS\n", "mpi_smp_completion", 2699); } } else { } { ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 0; pm8001_handle_event(pm8001_ha, (void *)pm8001_dev, 19); } goto ldv_46789; case_20: /* CIL Label */ { tmp___18 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___18 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_BAD_DESTINATION\n", "mpi_smp_completion", 2709); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 1; goto ldv_46789; case_21: /* CIL Label */ { tmp___19 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___19 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED\n", "mpi_smp_completion", 2716); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 2; goto ldv_46789; case_23: /* CIL Label */ { tmp___20 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___20 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_WRONG_DESTINATION\n", "mpi_smp_completion", 2723); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 8; goto ldv_46789; case_28: /* CIL Label */ { tmp___21 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___21 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_ERROR_RX_FRAME\n", "mpi_smp_completion", 2730); } } else { } ts->resp = 0; ts->stat = 128; goto ldv_46789; case_36: /* CIL Label */ { tmp___22 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___22 != 0L) { { printk("\016pm80xx %s %d:IO_XFER_OPEN_RETRY_TIMEOUT\n", "mpi_smp_completion", 2736); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 18; goto ldv_46789; case_55: /* CIL Label */ { tmp___23 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___23 != 0L) { { printk("\016pm80xx %s %d:IO_ERROR_INTERNAL_SMP_RESOURCE\n", "mpi_smp_completion", 2743); } } else { } ts->resp = 0; ts->stat = 132; goto ldv_46789; case_56: /* CIL Label */ { tmp___24 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___24 != 0L) { { printk("\016pm80xx %s %d:IO_PORT_IN_RESET\n", "mpi_smp_completion", 2749); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 18; goto ldv_46789; case_57: /* CIL Label */ { tmp___25 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___25 != 0L) { { printk("\016pm80xx %s %d:IO_DS_NON_OPERATIONAL\n", "mpi_smp_completion", 2756); } } else { } ts->resp = 0; ts->stat = 128; goto ldv_46789; case_58: /* CIL Label */ { tmp___26 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___26 != 0L) { { printk("\016pm80xx %s %d:IO_DS_IN_RECOVERY\n", "mpi_smp_completion", 2762); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 18; goto ldv_46789; case_63: /* CIL Label */ { tmp___27 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___27 != 0L) { { printk("\016pm80xx %s %d:IO_OPEN_CNX_ERROR_HW_RESOURCE_BUSY\n", "mpi_smp_completion", 2769); } } else { } ts->resp = 0; ts->stat = 135; ts->open_rej_reason = 18; goto ldv_46789; switch_default: /* CIL Label */ { tmp___28 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___28 != 0L) { { printk("\016pm80xx %s %d:Unknown status 0x%x\n", "mpi_smp_completion", 2776, status); } } else { } ts->resp = 0; ts->stat = 128; goto ldv_46789; switch_break: /* CIL Label */ ; } ldv_46789: { ldv___ldv_linux_kernel_locking_spinlock_spin_lock_112___0(& t->task_state_lock); t->task_state_flags = t->task_state_flags & 4294967294U; t->task_state_flags = t->task_state_flags & 4294967279U; t->task_state_flags = t->task_state_flags | 2U; tmp___30 = ldv__builtin_expect((t->task_state_flags & 4U) != 0U, 0L); } if (tmp___30 != 0L) { { ldv_spin_unlock_irqrestore_135(& t->task_state_lock, flags); tmp___29 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___29 != 0L) { { printk("\016pm80xx %s %d:task 0x%p done with io_status 0x%x resp 0x%xstat 0x%x but aborted by upper layer!\n", "mpi_smp_completion", 2791, t, status, (int )ts->resp, (unsigned int )ts->stat); } } else { } { pm8001_ccb_task_free(pm8001_ha, t, ccb, tag); } } else { { ldv_spin_unlock_irqrestore_135(& t->task_state_lock, flags); pm8001_ccb_task_free(pm8001_ha, t, ccb, tag); __asm__ volatile ("mfence": : : "memory"); (*(t->task_done))(t); } } return; } } static void pm80xx_hw_event_ack_req(struct pm8001_hba_info *pm8001_ha , u32 Qnum , u32 SEA , u32 port_id , u32 phyId , u32 param0 , u32 param1 ) { struct hw_event_ack_req___0 payload ; u32 opc ; struct inbound_queue_table *circularQ ; { { opc = 51U; __memset((void *)(& payload), 0, 124UL); circularQ = (struct inbound_queue_table *)(& pm8001_ha->inbnd_q_tbl) + (unsigned long )Qnum; payload.tag = 1U; payload.phyid_sea_portid = (((SEA & 65535U) << 8) | (phyId << 24)) | (port_id & 255U); payload.param0 = param0; payload.param1 = param1; pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, (void *)(& payload), 0U); } return; } } static int pm80xx_chip_phy_ctl_req(struct pm8001_hba_info *pm8001_ha , u32 phyId , u32 phy_op ) ; static void hw_event_sas_phy_up___0(struct pm8001_hba_info *pm8001_ha , void *piomb ) { struct hw_event_resp *pPayload ; u32 lr_status_evt_portid ; u32 phyid_npip_portstate ; u8 link_rate ; u8 port_id ; u8 phy_id ; u8 portstate ; struct pm8001_port *port ; struct sas_ha_struct *sas_ha ; struct pm8001_phy *phy ; unsigned long flags ; u8 deviceType ; long tmp ; long tmp___0 ; long tmp___1 ; long tmp___2 ; long tmp___3 ; long tmp___4 ; unsigned long __ms ; unsigned long tmp___5 ; { { pPayload = (struct hw_event_resp *)piomb + 4U; lr_status_evt_portid = pPayload->lr_evt_status_phyid_portid; phyid_npip_portstate = pPayload->npip_portstate; link_rate = (unsigned char )(lr_status_evt_portid >> 28); port_id = (unsigned char )lr_status_evt_portid; phy_id = (unsigned char )((phyid_npip_portstate & 16711680U) >> 16); portstate = (unsigned int )((unsigned char )phyid_npip_portstate) & 15U; port = (struct pm8001_port *)(& pm8001_ha->port) + (unsigned long )port_id; sas_ha = pm8001_ha->sas; phy = (struct pm8001_phy *)(& pm8001_ha->phy) + (unsigned long )phy_id; deviceType = pPayload->sas_identify.dev_type; port->port_state = portstate; phy->phy_state = 2U; tmp = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:portid:%d; phyid:%d; linkrate:%d; portstate:%x; devicetype:%x\n", "hw_event_sas_phy_up", 2863, (int )port_id, (int )phy_id, (int )link_rate, (int )portstate, (int )deviceType); } } else { } { if ((int )deviceType == 0) { goto case_0; } else { } if ((int )deviceType == 1) { goto case_1; } else { } if ((int )deviceType == 2) { goto case_2; } else { } if ((int )deviceType == 3) { goto case_3; } else { } goto switch_default; case_0: /* CIL Label */ { tmp___0 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___0 != 0L) { { printk("\016pm80xx %s %d:device type no device.\n", "hw_event_sas_phy_up", 2868); } } else { } goto ldv_46850; case_1: /* CIL Label */ { tmp___1 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___1 != 0L) { { printk("\016pm80xx %s %d:end device.\n", "hw_event_sas_phy_up", 2871); } } else { } { pm80xx_chip_phy_ctl_req(pm8001_ha, (u32 )phy_id, 16U); port->port_attached = 1U; pm8001_get_lrate_mode(phy, (int )link_rate); } goto ldv_46850; case_2: /* CIL Label */ { tmp___2 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___2 != 0L) { { printk("\016pm80xx %s %d:expander device.\n", "hw_event_sas_phy_up", 2879); } } else { } { port->port_attached = 1U; pm8001_get_lrate_mode(phy, (int )link_rate); } goto ldv_46850; case_3: /* CIL Label */ { tmp___3 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___3 != 0L) { { printk("\016pm80xx %s %d:fanout expander device.\n", "hw_event_sas_phy_up", 2885); } } else { } { port->port_attached = 1U; pm8001_get_lrate_mode(phy, (int )link_rate); } goto ldv_46850; switch_default: /* CIL Label */ { tmp___4 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___4 != 0L) { { printk("\016pm80xx %s %d:unknown device type(%x)\n", "hw_event_sas_phy_up", 2891, (int )deviceType); } } else { } goto ldv_46850; switch_break: /* CIL Label */ ; } ldv_46850: phy->phy_type = phy->phy_type | 2U; phy->identify.device_type = (enum sas_device_type )deviceType; phy->phy_attached = 1U; if ((unsigned int )phy->identify.device_type == 1U) { phy->identify.target_port_protocols = 8; } else if ((unsigned int )phy->identify.device_type != 0U) { phy->identify.target_port_protocols = 2; } else { } { phy->sas_phy.oob_mode = 2; (*(sas_ha->notify_phy_event))(& phy->sas_phy, 1); ldv___ldv_linux_kernel_locking_spinlock_spin_lock_115(& phy->sas_phy.frame_rcvd_lock); __memcpy((void *)(& phy->frame_rcvd), (void const *)(& pPayload->sas_identify), 28UL); phy->frame_rcvd_size = 28U; pm8001_get_attached_sas_addr(phy, (u8 *)(& phy->sas_phy.attached_sas_addr)); ldv_spin_unlock_irqrestore_160(& phy->sas_phy.frame_rcvd_lock, flags); } if (pm8001_ha->flags == 2UL) { __ms = 200UL; goto ldv_46857; ldv_46856: { __const_udelay(4295000UL); } ldv_46857: tmp___5 = __ms; __ms = __ms - 1UL; if (tmp___5 != 0UL) { goto ldv_46856; } else { } } else { } { pm8001_bytes_dmaed(pm8001_ha, (int )phy_id); } return; } } static void hw_event_sata_phy_up___0(struct pm8001_hba_info *pm8001_ha , void *piomb ) { struct hw_event_resp *pPayload ; u32 phyid_npip_portstate ; u32 lr_status_evt_portid ; u8 link_rate ; u8 port_id ; u8 phy_id ; u8 portstate ; struct pm8001_port *port ; struct sas_ha_struct *sas_ha ; struct pm8001_phy *phy ; unsigned long flags ; long tmp ; { { pPayload = (struct hw_event_resp *)piomb + 4U; phyid_npip_portstate = pPayload->npip_portstate; lr_status_evt_portid = pPayload->lr_evt_status_phyid_portid; link_rate = (unsigned char )(lr_status_evt_portid >> 28); port_id = (unsigned char )lr_status_evt_portid; phy_id = (unsigned char )((phyid_npip_portstate & 16711680U) >> 16); portstate = (unsigned int )((unsigned char )phyid_npip_portstate) & 15U; port = (struct pm8001_port *)(& pm8001_ha->port) + (unsigned long )port_id; sas_ha = pm8001_ha->sas; phy = (struct pm8001_phy *)(& pm8001_ha->phy) + (unsigned long )phy_id; tmp = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:port id %d, phy id %d link_rate %d portstate 0x%x\n", "hw_event_sata_phy_up", 2941, (int )port_id, (int )phy_id, (int )link_rate, (int )portstate); } } else { } { port->port_state = portstate; phy->phy_state = 2U; port->port_attached = 1U; pm8001_get_lrate_mode(phy, (int )link_rate); phy->phy_type = phy->phy_type | 1U; phy->phy_attached = 1U; phy->sas_phy.oob_mode = 1; (*(sas_ha->notify_phy_event))(& phy->sas_phy, 1); ldv___ldv_linux_kernel_locking_spinlock_spin_lock_117(& phy->sas_phy.frame_rcvd_lock); __memcpy((void *)(& phy->frame_rcvd), (void const *)(& pPayload->sata_fis) + 0xfffffffffffffffcUL, 20UL); phy->frame_rcvd_size = 20U; phy->identify.target_port_protocols = 1; phy->identify.device_type = 5; pm8001_get_attached_sas_addr(phy, (u8 *)(& phy->sas_phy.attached_sas_addr)); ldv_spin_unlock_irqrestore_160(& phy->sas_phy.frame_rcvd_lock, flags); pm8001_bytes_dmaed(pm8001_ha, (int )phy_id); } return; } } static void hw_event_phy_down___0(struct pm8001_hba_info *pm8001_ha , void *piomb ) { struct hw_event_resp *pPayload ; u32 lr_status_evt_portid ; u8 port_id ; u32 phyid_npip_portstate ; u8 phy_id ; u8 portstate ; struct pm8001_port *port ; struct pm8001_phy *phy ; long tmp ; long tmp___0 ; long tmp___1 ; long tmp___2 ; long tmp___3 ; long tmp___4 ; long tmp___5 ; { { pPayload = (struct hw_event_resp *)piomb + 4U; lr_status_evt_portid = pPayload->lr_evt_status_phyid_portid; port_id = (unsigned char )lr_status_evt_portid; phyid_npip_portstate = pPayload->npip_portstate; phy_id = (unsigned char )((phyid_npip_portstate & 16711680U) >> 16); portstate = (unsigned int )((unsigned char )phyid_npip_portstate) & 15U; port = (struct pm8001_port *)(& pm8001_ha->port) + (unsigned long )port_id; phy = (struct pm8001_phy *)(& pm8001_ha->phy) + (unsigned long )phy_id; port->port_state = portstate; phy->phy_type = 0U; phy->identify.device_type = 0; phy->phy_attached = 0U; __memset((void *)(& phy->dev_sas_addr), 0, 8UL); } { if ((int )portstate == 1) { goto case_1; } else { } if ((int )portstate == 8) { goto case_8; } else { } if ((int )portstate == 4) { goto case_4; } else { } if ((int )portstate == 0) { goto case_0; } else { } if ((int )portstate == 2) { goto case_2; } else { } goto switch_default; case_1: /* CIL Label */ ; goto ldv_46888; case_8: /* CIL Label */ { tmp = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d: PortInvalid portID %d\n", "hw_event_phy_down", 2993, (int )port_id); } } else { } { tmp___0 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___0 != 0L) { { printk("\016pm80xx %s %d: Last phy Down and port invalid\n", "hw_event_phy_down", 2995); } } else { } { port->port_attached = 0U; pm80xx_hw_event_ack_req(pm8001_ha, 0U, 7U, (u32 )port_id, (u32 )phy_id, 0U, 0U); } goto ldv_46888; case_4: /* CIL Label */ { tmp___1 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___1 != 0L) { { printk("\016pm80xx %s %d: Port In Reset portID %d\n", "hw_event_phy_down", 3002, (int )port_id); } } else { } goto ldv_46888; case_0: /* CIL Label */ { tmp___2 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___2 != 0L) { { printk("\016pm80xx %s %d: phy Down and PORT_NOT_ESTABLISHED\n", "hw_event_phy_down", 3006); } } else { } port->port_attached = 0U; goto ldv_46888; case_2: /* CIL Label */ { tmp___3 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___3 != 0L) { { printk("\016pm80xx %s %d: phy Down and PORT_LOSTCOMM\n", "hw_event_phy_down", 3011); } } else { } { tmp___4 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___4 != 0L) { { printk("\016pm80xx %s %d: Last phy Down and port invalid\n", "hw_event_phy_down", 3013); } } else { } { port->port_attached = 0U; pm80xx_hw_event_ack_req(pm8001_ha, 0U, 7U, (u32 )port_id, (u32 )phy_id, 0U, 0U); } goto ldv_46888; switch_default: /* CIL Label */ { port->port_attached = 0U; tmp___5 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___5 != 0L) { { printk("\016pm80xx %s %d: phy Down and(default) = 0x%x\n", "hw_event_phy_down", 3022, (int )portstate); } } else { } goto ldv_46888; switch_break: /* CIL Label */ ; } ldv_46888: ; return; } } static int mpi_phy_start_resp(struct pm8001_hba_info *pm8001_ha , void *piomb ) { struct phy_start_resp *pPayload ; u32 status ; u32 phy_id ; struct pm8001_phy *phy ; long tmp ; { { pPayload = (struct phy_start_resp *)piomb + 4U; status = pPayload->status; phy_id = pPayload->phyid; phy = (struct pm8001_phy *)(& pm8001_ha->phy) + (unsigned long )phy_id; tmp = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:phy start resp status:0x%x, phyid:0x%x\n", "mpi_phy_start_resp", 3040, status, phy_id); } } else { } if (status == 0U) { phy->phy_state = 1U; if (pm8001_ha->flags == 2UL) { { complete(phy->enable_completion); } } else { } } else { } return (0); } } static int mpi_thermal_hw_event(struct pm8001_hba_info *pm8001_ha , void *piomb ) { struct thermal_hw_event *pPayload ; u32 thermal_event ; u32 rht_lht ; long tmp ; long tmp___0 ; long tmp___1 ; long tmp___2 ; { pPayload = (struct thermal_hw_event *)piomb + 4U; thermal_event = pPayload->thermal_event; rht_lht = pPayload->rht_lht; if ((thermal_event & 64U) != 0U) { { tmp = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:Thermal Event: Local high temperature violated!\n", "mpi_thermal_hw_event", 3065); } } else { } { tmp___0 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___0 != 0L) { { printk("\016pm80xx %s %d:Thermal Event: Measured local high temperature %d\n", "mpi_thermal_hw_event", 3068, (rht_lht & 65280U) >> 8); } } else { } } else { } if ((thermal_event & 16U) != 0U) { { tmp___1 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___1 != 0L) { { printk("\016pm80xx %s %d:Thermal Event: Remote high temperature violated!\n", "mpi_thermal_hw_event", 3072); } } else { } { tmp___2 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___2 != 0L) { { printk("\016pm80xx %s %d:Thermal Event: Measured remote high temperature %d\n", "mpi_thermal_hw_event", 3075, rht_lht >> 24); } } else { } } else { } return (0); } } static int mpi_hw_event___0(struct pm8001_hba_info *pm8001_ha , void *piomb ) { unsigned long flags ; struct hw_event_resp *pPayload ; u32 lr_status_evt_portid ; u32 phyid_npip_portstate ; u8 port_id ; u8 phy_id ; u16 eventType ; u8 status ; struct sas_ha_struct *sas_ha ; struct pm8001_phy *phy ; struct asd_sas_phy *sas_phy ; long tmp ; long tmp___0 ; long tmp___1 ; long tmp___2 ; long tmp___3 ; long tmp___4 ; long tmp___5 ; long tmp___6 ; long tmp___7 ; long tmp___8 ; long tmp___9 ; long tmp___10 ; long tmp___11 ; long tmp___12 ; long tmp___13 ; long tmp___14 ; long tmp___15 ; long tmp___16 ; long tmp___17 ; long tmp___18 ; long tmp___19 ; long tmp___20 ; long tmp___21 ; long tmp___22 ; long tmp___23 ; { { pPayload = (struct hw_event_resp *)piomb + 4U; lr_status_evt_portid = pPayload->lr_evt_status_phyid_portid; phyid_npip_portstate = pPayload->npip_portstate; port_id = (unsigned char )lr_status_evt_portid; phy_id = (unsigned char )((phyid_npip_portstate & 16711680U) >> 16); eventType = (unsigned short )((lr_status_evt_portid & 16776960U) >> 8); status = (unsigned char )((lr_status_evt_portid & 251658240U) >> 24); sas_ha = pm8001_ha->sas; phy = (struct pm8001_phy *)(& pm8001_ha->phy) + (unsigned long )phy_id; sas_phy = *(sas_ha->sas_phy + (unsigned long )phy_id); tmp = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:portid:%d phyid:%d event:0x%x status:0x%x\n", "mpi_hw_event", 3106, (int )port_id, (int )phy_id, (int )eventType, (int )status); } } else { } { if ((int )eventType == 4) { goto case_4; } else { } if ((int )eventType == 5) { goto case_5; } else { } if ((int )eventType == 6) { goto case_6; } else { } if ((int )eventType == 7) { goto case_7; } else { } if ((int )eventType == 8) { goto case_8; } else { } if ((int )eventType == 9) { goto case_9; } else { } if ((int )eventType == 10) { goto case_10; } else { } if ((int )eventType == 16) { goto case_16; } else { } if ((int )eventType == 18) { goto case_18; } else { } if ((int )eventType == 19) { goto case_19; } else { } if ((int )eventType == 20) { goto case_20; } else { } if ((int )eventType == 21) { goto case_21; } else { } if ((int )eventType == 14) { goto case_14; } else { } if ((int )eventType == 11) { goto case_11; } else { } if ((int )eventType == 12) { goto case_12; } else { } if ((int )eventType == 13) { goto case_13; } else { } if ((int )eventType == 15) { goto case_15; } else { } if ((int )eventType == 22) { goto case_22; } else { } if ((int )eventType == 25) { goto case_25; } else { } if ((int )eventType == 23) { goto case_23; } else { } if ((int )eventType == 24) { goto case_24; } else { } if ((int )eventType == 32) { goto case_32; } else { } if ((int )eventType == 33) { goto case_33; } else { } goto switch_default; case_4: /* CIL Label */ { tmp___0 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___0 != 0L) { { printk("\016pm80xx %s %d:HW_EVENT_PHY_START_STATUS\n", "mpi_hw_event", 3112); } } else { } { hw_event_sas_phy_up___0(pm8001_ha, piomb); } goto ldv_46929; case_5: /* CIL Label */ { tmp___1 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___1 != 0L) { { printk("\016pm80xx %s %d:HW_EVENT_SATA_PHY_UP\n", "mpi_hw_event", 3117); } } else { } { hw_event_sata_phy_up___0(pm8001_ha, piomb); } goto ldv_46929; case_6: /* CIL Label */ { tmp___2 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___2 != 0L) { { printk("\016pm80xx %s %d:HW_EVENT_SATA_SPINUP_HOLD\n", "mpi_hw_event", 3122); } } else { } { (*(sas_ha->notify_phy_event))(& phy->sas_phy, 3); } goto ldv_46929; case_7: /* CIL Label */ { tmp___3 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___3 != 0L) { { printk("\016pm80xx %s %d:HW_EVENT_PHY_DOWN\n", "mpi_hw_event", 3127); } } else { } { (*(sas_ha->notify_phy_event))(& phy->sas_phy, 0); phy->phy_attached = 0U; phy->phy_state = 0U; hw_event_phy_down___0(pm8001_ha, piomb); } goto ldv_46929; case_8: /* CIL Label */ { tmp___4 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___4 != 0L) { { printk("\016pm80xx %s %d:HW_EVENT_PORT_INVALID\n", "mpi_hw_event", 3135); } } else { } { sas_phy_disconnected(sas_phy); phy->phy_attached = 0U; (*(sas_ha->notify_port_event))(sas_phy, 2); } goto ldv_46929; case_9: /* CIL Label */ { tmp___5 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___5 != 0L) { { printk("\016pm80xx %s %d:HW_EVENT_BROADCAST_CHANGE\n", "mpi_hw_event", 3144); } } else { } { pm80xx_hw_event_ack_req(pm8001_ha, 0U, 9U, (u32 )port_id, (u32 )phy_id, 1U, 0U); ldv___ldv_linux_kernel_locking_spinlock_spin_lock_119(& sas_phy->sas_prim_lock); sas_phy->sas_prim = 9U; ldv_spin_unlock_irqrestore_166(& sas_phy->sas_prim_lock, flags); (*(sas_ha->notify_port_event))(sas_phy, 1); } goto ldv_46929; case_10: /* CIL Label */ { tmp___6 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___6 != 0L) { { printk("\016pm80xx %s %d:HW_EVENT_PHY_ERROR\n", "mpi_hw_event", 3154); } } else { } { sas_phy_disconnected(& phy->sas_phy); phy->phy_attached = 0U; (*(sas_ha->notify_phy_event))(& phy->sas_phy, 2); } goto ldv_46929; case_16: /* CIL Label */ { tmp___7 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___7 != 0L) { { printk("\016pm80xx %s %d:HW_EVENT_BROADCAST_EXP\n", "mpi_hw_event", 3161); } } else { } { ldv___ldv_linux_kernel_locking_spinlock_spin_lock_121(& sas_phy->sas_prim_lock); sas_phy->sas_prim = 16U; ldv_spin_unlock_irqrestore_166(& sas_phy->sas_prim_lock, flags); (*(sas_ha->notify_port_event))(sas_phy, 1); } goto ldv_46929; case_18: /* CIL Label */ { tmp___8 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___8 != 0L) { { printk("\016pm80xx %s %d:HW_EVENT_LINK_ERR_INVALID_DWORD\n", "mpi_hw_event", 3169); } } else { } { pm80xx_hw_event_ack_req(pm8001_ha, 0U, 18U, (u32 )port_id, (u32 )phy_id, 0U, 0U); sas_phy_disconnected(sas_phy); phy->phy_attached = 0U; (*(sas_ha->notify_port_event))(sas_phy, 2); } goto ldv_46929; case_19: /* CIL Label */ { tmp___9 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___9 != 0L) { { printk("\016pm80xx %s %d:HW_EVENT_LINK_ERR_DISPARITY_ERROR\n", "mpi_hw_event", 3178); } } else { } { pm80xx_hw_event_ack_req(pm8001_ha, 0U, 19U, (u32 )port_id, (u32 )phy_id, 0U, 0U); sas_phy_disconnected(sas_phy); phy->phy_attached = 0U; (*(sas_ha->notify_port_event))(sas_phy, 2); } goto ldv_46929; case_20: /* CIL Label */ { tmp___10 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___10 != 0L) { { printk("\016pm80xx %s %d:HW_EVENT_LINK_ERR_CODE_VIOLATION\n", "mpi_hw_event", 3188); } } else { } { pm80xx_hw_event_ack_req(pm8001_ha, 0U, 20U, (u32 )port_id, (u32 )phy_id, 0U, 0U); sas_phy_disconnected(sas_phy); phy->phy_attached = 0U; (*(sas_ha->notify_port_event))(sas_phy, 2); } goto ldv_46929; case_21: /* CIL Label */ { tmp___11 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___11 != 0L) { { printk("\016pm80xx %s %d:HW_EVENT_LINK_ERR_LOSS_OF_DWORD_SYNCH\n", "mpi_hw_event", 3198); } } else { } { pm80xx_hw_event_ack_req(pm8001_ha, 0U, 21U, (u32 )port_id, (u32 )phy_id, 0U, 0U); sas_phy_disconnected(sas_phy); phy->phy_attached = 0U; (*(sas_ha->notify_port_event))(sas_phy, 2); } goto ldv_46929; case_14: /* CIL Label */ { tmp___12 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___12 != 0L) { { printk("\016pm80xx %s %d:HW_EVENT_MALFUNCTION\n", "mpi_hw_event", 3208); } } else { } goto ldv_46929; case_11: /* CIL Label */ { tmp___13 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___13 != 0L) { { printk("\016pm80xx %s %d:HW_EVENT_BROADCAST_SES\n", "mpi_hw_event", 3212); } } else { } { ldv___ldv_linux_kernel_locking_spinlock_spin_lock_123(& sas_phy->sas_prim_lock); sas_phy->sas_prim = 11U; ldv_spin_unlock_irqrestore_166(& sas_phy->sas_prim_lock, flags); (*(sas_ha->notify_port_event))(sas_phy, 1); } goto ldv_46929; case_12: /* CIL Label */ { tmp___14 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___14 != 0L) { { printk("\016pm80xx %s %d:HW_EVENT_INBOUND_CRC_ERROR\n", "mpi_hw_event", 3220); } } else { } { pm80xx_hw_event_ack_req(pm8001_ha, 0U, 12U, (u32 )port_id, (u32 )phy_id, 0U, 0U); } goto ldv_46929; case_13: /* CIL Label */ { tmp___15 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___15 != 0L) { { printk("\016pm80xx %s %d:HW_EVENT_HARD_RESET_RECEIVED\n", "mpi_hw_event", 3227); } } else { } { (*(sas_ha->notify_port_event))(sas_phy, 4); } goto ldv_46929; case_15: /* CIL Label */ { tmp___16 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___16 != 0L) { { printk("\016pm80xx %s %d:HW_EVENT_ID_FRAME_TIMEOUT\n", "mpi_hw_event", 3232); } } else { } { sas_phy_disconnected(sas_phy); phy->phy_attached = 0U; (*(sas_ha->notify_port_event))(sas_phy, 2); } goto ldv_46929; case_22: /* CIL Label */ { tmp___17 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___17 != 0L) { { printk("\016pm80xx %s %d:HW_EVENT_LINK_ERR_PHY_RESET_FAILED\n", "mpi_hw_event", 3239); } } else { } { pm80xx_hw_event_ack_req(pm8001_ha, 0U, 22U, (u32 )port_id, (u32 )phy_id, 0U, 0U); sas_phy_disconnected(sas_phy); phy->phy_attached = 0U; (*(sas_ha->notify_port_event))(sas_phy, 2); } goto ldv_46929; case_25: /* CIL Label */ { tmp___18 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___18 != 0L) { { printk("\016pm80xx %s %d:HW_EVENT_PORT_RESET_TIMER_TMO\n", "mpi_hw_event", 3249); } } else { } { sas_phy_disconnected(sas_phy); phy->phy_attached = 0U; (*(sas_ha->notify_port_event))(sas_phy, 2); } goto ldv_46929; case_23: /* CIL Label */ { tmp___19 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___19 != 0L) { { printk("\016pm80xx %s %d:HW_EVENT_PORT_RECOVERY_TIMER_TMO\n", "mpi_hw_event", 3256); } } else { } { pm80xx_hw_event_ack_req(pm8001_ha, 0U, 23U, (u32 )port_id, (u32 )phy_id, 0U, 0U); sas_phy_disconnected(sas_phy); phy->phy_attached = 0U; (*(sas_ha->notify_port_event))(sas_phy, 2); } goto ldv_46929; case_24: /* CIL Label */ { tmp___20 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___20 != 0L) { { printk("\016pm80xx %s %d:HW_EVENT_PORT_RECOVER\n", "mpi_hw_event", 3266); } } else { } goto ldv_46929; case_32: /* CIL Label */ { tmp___21 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___21 != 0L) { { printk("\016pm80xx %s %d:HW_EVENT_PORT_RESET_COMPLETE\n", "mpi_hw_event", 3270); } } else { } goto ldv_46929; case_33: /* CIL Label */ { tmp___22 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___22 != 0L) { { printk("\016pm80xx %s %d:EVENT_BROADCAST_ASYNCH_EVENT\n", "mpi_hw_event", 3274); } } else { } goto ldv_46929; switch_default: /* CIL Label */ { tmp___23 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___23 != 0L) { { printk("\016pm80xx %s %d:Unknown event type 0x%x\n", "mpi_hw_event", 3278, (int )eventType); } } else { } goto ldv_46929; switch_break: /* CIL Label */ ; } ldv_46929: ; return (0); } } static int mpi_phy_stop_resp(struct pm8001_hba_info *pm8001_ha , void *piomb ) { struct phy_stop_resp *pPayload ; u32 status ; u32 phyid ; struct pm8001_phy *phy ; long tmp ; { { pPayload = (struct phy_stop_resp *)piomb + 4U; status = pPayload->status; phyid = pPayload->phyid; phy = (struct pm8001_phy *)(& pm8001_ha->phy) + (unsigned long )phyid; tmp = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:phy:0x%x status:0x%x\n", "mpi_phy_stop_resp", 3300, phyid, status); } } else { } if (status == 0U) { phy->phy_state = 0U; } else { } return (0); } } static int mpi_set_controller_config_resp(struct pm8001_hba_info *pm8001_ha , void *piomb ) { struct set_ctrl_cfg_resp *pPayload ; u32 status ; u32 err_qlfr_pgcd ; long tmp ; { { pPayload = (struct set_ctrl_cfg_resp *)piomb + 4U; status = pPayload->status; err_qlfr_pgcd = pPayload->err_qlfr_pgcd; tmp = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:SET CONTROLLER RESP: status 0x%x qlfr_pgcd 0x%x\n", "mpi_set_controller_config_resp", 3321, status, err_qlfr_pgcd); } } else { } return (0); } } static int mpi_get_controller_config_resp(struct pm8001_hba_info *pm8001_ha , void *piomb ) { long tmp ; { { tmp = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d: pm80xx_addition_functionality\n", "mpi_get_controller_config_resp", 3335); } } else { } return (0); } } static int mpi_get_phy_profile_resp(struct pm8001_hba_info *pm8001_ha , void *piomb ) { long tmp ; { { tmp = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d: pm80xx_addition_functionality\n", "mpi_get_phy_profile_resp", 3349); } } else { } return (0); } } static int mpi_flash_op_ext_resp(struct pm8001_hba_info *pm8001_ha , void *piomb ) { long tmp ; { { tmp = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d: pm80xx_addition_functionality\n", "mpi_flash_op_ext_resp", 3362); } } else { } return (0); } } static int mpi_set_phy_profile_resp(struct pm8001_hba_info *pm8001_ha , void *piomb ) { u8 page_code ; struct set_phy_profile_resp *pPayload ; u32 ppc_phyid ; u32 status ; long tmp ; long tmp___0 ; { pPayload = (struct set_phy_profile_resp *)piomb + 4U; ppc_phyid = pPayload->ppc_phyid; status = pPayload->status; page_code = (unsigned char )((ppc_phyid & 65280U) >> 8); if (status != 0U) { { tmp = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:PhyProfile command failed with status 0x%08X \n", "mpi_set_phy_profile_resp", 3386, status); } } else { } return (-1); } else if ((unsigned int )page_code != 4U) { { tmp___0 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___0 != 0L) { { printk("\016pm80xx %s %d:Invalid page code 0x%X\n", "mpi_set_phy_profile_resp", 3392, (int )page_code); } } else { } return (-1); } else { } return (0); } } static int mpi_kek_management_resp(struct pm8001_hba_info *pm8001_ha , void *piomb ) { struct kek_mgmt_resp *pPayload ; u32 status ; u32 kidx_new_curr_ksop ; u32 err_qlfr ; long tmp ; { { pPayload = (struct kek_mgmt_resp *)piomb + 4U; status = pPayload->status; kidx_new_curr_ksop = pPayload->kidx_new_curr_ksop; err_qlfr = pPayload->err_qlfr; tmp = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:KEK MGMT RESP. Status 0x%x idx_ksop 0x%x err_qlfr 0x%x\n", "mpi_kek_management_resp", 3415, status, kidx_new_curr_ksop, err_qlfr); } } else { } return (0); } } static int mpi_dek_management_resp(struct pm8001_hba_info *pm8001_ha , void *piomb ) { long tmp ; { { tmp = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d: pm80xx_addition_functionality\n", "mpi_dek_management_resp", 3429); } } else { } return (0); } } static int ssp_coalesced_comp_resp(struct pm8001_hba_info *pm8001_ha , void *piomb ) { long tmp ; { { tmp = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d: pm80xx_addition_functionality\n", "ssp_coalesced_comp_resp", 3443); } } else { } return (0); } } static void process_one_iomb___0(struct pm8001_hba_info *pm8001_ha , void *piomb ) { __le32 pHeader ; u32 opc ; long tmp ; long tmp___0 ; long tmp___1 ; long tmp___2 ; long tmp___3 ; long tmp___4 ; long tmp___5 ; long tmp___6 ; long tmp___7 ; long tmp___8 ; long tmp___9 ; long tmp___10 ; long tmp___11 ; long tmp___12 ; long tmp___13 ; long tmp___14 ; long tmp___15 ; long tmp___16 ; long tmp___17 ; long tmp___18 ; long tmp___19 ; long tmp___20 ; long tmp___21 ; long tmp___22 ; long tmp___23 ; long tmp___24 ; long tmp___25 ; long tmp___26 ; long tmp___27 ; long tmp___28 ; long tmp___29 ; long tmp___30 ; long tmp___31 ; long tmp___32 ; long tmp___33 ; long tmp___34 ; long tmp___35 ; long tmp___36 ; long tmp___37 ; long tmp___38 ; long tmp___39 ; long tmp___40 ; long tmp___41 ; { pHeader = *((__le32 *)piomb); opc = pHeader & 4095U; { if (opc == 1U) { goto case_1; } else { } if (opc == 1792U) { goto case_1792; } else { } if (opc == 1840U) { goto case_1840; } else { } if (opc == 5U) { goto case_5; } else { } if (opc == 6U) { goto case_6; } else { } if (opc == 7U) { goto case_7; } else { } if (opc == 2098U) { goto case_2098; } else { } if (opc == 11U) { goto case_11; } else { } if (opc == 12U) { goto case_12; } else { } if (opc == 13U) { goto case_13; } else { } if (opc == 14U) { goto case_14; } else { } if (opc == 15U) { goto case_15; } else { } if (opc == 1824U) { goto case_1824; } else { } if (opc == 18U) { goto case_18; } else { } if (opc == 20U) { goto case_20; } else { } if (opc == 22U) { goto case_22; } else { } if (opc == 23U) { goto case_23; } else { } if (opc == 24U) { goto case_24; } else { } if (opc == 26U) { goto case_26; } else { } if (opc == 27U) { goto case_27; } else { } if (opc == 28U) { goto case_28; } else { } if (opc == 29U) { goto case_29; } else { } if (opc == 30U) { goto case_30; } else { } if (opc == 2099U) { goto case_2099; } else { } if (opc == 32U) { goto case_32; } else { } if (opc == 34U) { goto case_34; } else { } if (opc == 35U) { goto case_35; } else { } if (opc == 36U) { goto case_36; } else { } if (opc == 37U) { goto case_37; } else { } if (opc == 38U) { goto case_38; } else { } if (opc == 39U) { goto case_39; } else { } if (opc == 40U) { goto case_40; } else { } if (opc == 2052U) { goto case_2052; } else { } if (opc == 2053U) { goto case_2053; } else { } if (opc == 2096U) { goto case_2096; } else { } if (opc == 2097U) { goto case_2097; } else { } if (opc == 2101U) { goto case_2101; } else { } if (opc == 2102U) { goto case_2102; } else { } if (opc == 2103U) { goto case_2103; } else { } if (opc == 2304U) { goto case_2304; } else { } if (opc == 2305U) { goto case_2305; } else { } if (opc == 2306U) { goto case_2306; } else { } goto switch_default; case_1: /* CIL Label */ { tmp = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_ECHO\n", "process_one_iomb", 3460); } } else { } goto ldv_47021; case_1792: /* CIL Label */ { tmp___0 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___0 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_HW_EVENT\n", "process_one_iomb", 3464); } } else { } { mpi_hw_event___0(pm8001_ha, piomb); } goto ldv_47021; case_1840: /* CIL Label */ { tmp___1 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___1 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_THERMAL_EVENT\n", "process_one_iomb", 3469); } } else { } { mpi_thermal_hw_event(pm8001_ha, piomb); } goto ldv_47021; case_5: /* CIL Label */ { tmp___2 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___2 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_SSP_COMP\n", "process_one_iomb", 3474); } } else { } { mpi_ssp_completion___0(pm8001_ha, piomb); } goto ldv_47021; case_6: /* CIL Label */ { tmp___3 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___3 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_SMP_COMP\n", "process_one_iomb", 3479); } } else { } { mpi_smp_completion___0(pm8001_ha, piomb); } goto ldv_47021; case_7: /* CIL Label */ { tmp___4 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___4 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_LOCAL_PHY_CNTRL\n", "process_one_iomb", 3484); } } else { } { pm8001_mpi_local_phy_ctl(pm8001_ha, piomb); } goto ldv_47021; case_2098: /* CIL Label */ { tmp___5 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___5 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_DEV_REGIST\n", "process_one_iomb", 3489); } } else { } { pm8001_mpi_reg_resp(pm8001_ha, piomb); } goto ldv_47021; case_11: /* CIL Label */ { tmp___6 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___6 != 0L) { { printk("\016pm80xx %s %d:unregister the device\n", "process_one_iomb", 3494); } } else { } { pm8001_mpi_dereg_resp(pm8001_ha, piomb); } goto ldv_47021; case_12: /* CIL Label */ { tmp___7 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___7 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_GET_DEV_HANDLE\n", "process_one_iomb", 3499); } } else { } goto ldv_47021; case_13: /* CIL Label */ { tmp___8 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___8 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_SATA_COMP\n", "process_one_iomb", 3503); } } else { } { mpi_sata_completion___0(pm8001_ha, piomb); } goto ldv_47021; case_14: /* CIL Label */ { tmp___9 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___9 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_SATA_EVENT\n", "process_one_iomb", 3508); } } else { } { mpi_sata_event___0(pm8001_ha, piomb); } goto ldv_47021; case_15: /* CIL Label */ { tmp___10 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___10 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_SSP_EVENT\n", "process_one_iomb", 3513); } } else { } { mpi_ssp_event___0(pm8001_ha, piomb); } goto ldv_47021; case_1824: /* CIL Label */ { tmp___11 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___11 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_DEV_HANDLE_ARRIV\n", "process_one_iomb", 3518); } } else { } goto ldv_47021; case_18: /* CIL Label */ { tmp___12 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___12 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_SSP_RECV_EVENT\n", "process_one_iomb", 3523); } } else { } goto ldv_47021; case_20: /* CIL Label */ { tmp___13 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___13 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_FW_FLASH_UPDATE\n", "process_one_iomb", 3528); } } else { } { pm8001_mpi_fw_flash_update_resp(pm8001_ha, piomb); } goto ldv_47021; case_22: /* CIL Label */ { tmp___14 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___14 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_GPIO_RESPONSE\n", "process_one_iomb", 3533); } } else { } goto ldv_47021; case_23: /* CIL Label */ { tmp___15 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___15 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_GPIO_EVENT\n", "process_one_iomb", 3537); } } else { } goto ldv_47021; case_24: /* CIL Label */ { tmp___16 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___16 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_GENERAL_EVENT\n", "process_one_iomb", 3541); } } else { } { pm8001_mpi_general_event(pm8001_ha, piomb); } goto ldv_47021; case_26: /* CIL Label */ { tmp___17 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___17 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_SSP_ABORT_RSP\n", "process_one_iomb", 3546); } } else { } { pm8001_mpi_task_abort_resp(pm8001_ha, piomb); } goto ldv_47021; case_27: /* CIL Label */ { tmp___18 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___18 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_SATA_ABORT_RSP\n", "process_one_iomb", 3551); } } else { } { pm8001_mpi_task_abort_resp(pm8001_ha, piomb); } goto ldv_47021; case_28: /* CIL Label */ { tmp___19 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___19 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_SAS_DIAG_MODE_START_END\n", "process_one_iomb", 3556); } } else { } goto ldv_47021; case_29: /* CIL Label */ { tmp___20 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___20 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_SAS_DIAG_EXECUTE\n", "process_one_iomb", 3560); } } else { } goto ldv_47021; case_30: /* CIL Label */ { tmp___21 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___21 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_GET_TIME_STAMP\n", "process_one_iomb", 3564); } } else { } goto ldv_47021; case_2099: /* CIL Label */ { tmp___22 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___22 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_SAS_HW_EVENT_ACK\n", "process_one_iomb", 3568); } } else { } goto ldv_47021; case_32: /* CIL Label */ { tmp___23 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___23 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_PORT_CONTROL\n", "process_one_iomb", 3572); } } else { } goto ldv_47021; case_34: /* CIL Label */ { tmp___24 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___24 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_SMP_ABORT_RSP\n", "process_one_iomb", 3576); } } else { } { pm8001_mpi_task_abort_resp(pm8001_ha, piomb); } goto ldv_47021; case_35: /* CIL Label */ { tmp___25 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___25 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_GET_NVMD_DATA\n", "process_one_iomb", 3581); } } else { } { pm8001_mpi_get_nvmd_resp(pm8001_ha, piomb); } goto ldv_47021; case_36: /* CIL Label */ { tmp___26 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___26 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_SET_NVMD_DATA\n", "process_one_iomb", 3586); } } else { } { pm8001_mpi_set_nvmd_resp(pm8001_ha, piomb); } goto ldv_47021; case_37: /* CIL Label */ { tmp___27 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___27 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_DEVICE_HANDLE_REMOVAL\n", "process_one_iomb", 3591); } } else { } goto ldv_47021; case_38: /* CIL Label */ { tmp___28 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___28 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_SET_DEVICE_STATE\n", "process_one_iomb", 3595); } } else { } { pm8001_mpi_set_dev_state_resp(pm8001_ha, piomb); } goto ldv_47021; case_39: /* CIL Label */ { tmp___29 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___29 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_GET_DEVICE_STATE\n", "process_one_iomb", 3600); } } else { } goto ldv_47021; case_40: /* CIL Label */ { tmp___30 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___30 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_SET_DEV_INFO\n", "process_one_iomb", 3604); } } else { } goto ldv_47021; case_2052: /* CIL Label */ { tmp___31 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___31 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_PHY_START_RESP opcode:%x\n", "process_one_iomb", 3609, opc); } } else { } { mpi_phy_start_resp(pm8001_ha, piomb); } goto ldv_47021; case_2053: /* CIL Label */ { tmp___32 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___32 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_PHY_STOP_RESP opcode:%x\n", "process_one_iomb", 3614, opc); } } else { } { mpi_phy_stop_resp(pm8001_ha, piomb); } goto ldv_47021; case_2096: /* CIL Label */ { tmp___33 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___33 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_SET_CONTROLLER_CONFIG opcode:%x\n", "process_one_iomb", 3619, opc); } } else { } { mpi_set_controller_config_resp(pm8001_ha, piomb); } goto ldv_47021; case_2097: /* CIL Label */ { tmp___34 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___34 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_GET_CONTROLLER_CONFIG opcode:%x\n", "process_one_iomb", 3624, opc); } } else { } { mpi_get_controller_config_resp(pm8001_ha, piomb); } goto ldv_47021; case_2101: /* CIL Label */ { tmp___35 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___35 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_GET_PHY_PROFILE opcode:%x\n", "process_one_iomb", 3629, opc); } } else { } { mpi_get_phy_profile_resp(pm8001_ha, piomb); } goto ldv_47021; case_2102: /* CIL Label */ { tmp___36 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___36 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_FLASH_OP_EXT opcode:%x\n", "process_one_iomb", 3634, opc); } } else { } { mpi_flash_op_ext_resp(pm8001_ha, piomb); } goto ldv_47021; case_2103: /* CIL Label */ { tmp___37 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___37 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_SET_PHY_PROFILE opcode:%x\n", "process_one_iomb", 3639, opc); } } else { } { mpi_set_phy_profile_resp(pm8001_ha, piomb); } goto ldv_47021; case_2304: /* CIL Label */ { tmp___38 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___38 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_KEK_MANAGEMENT_RESP opcode:%x\n", "process_one_iomb", 3644, opc); } } else { } { mpi_kek_management_resp(pm8001_ha, piomb); } goto ldv_47021; case_2305: /* CIL Label */ { tmp___39 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___39 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_DEK_MANAGEMENT_RESP opcode:%x\n", "process_one_iomb", 3649, opc); } } else { } { mpi_dek_management_resp(pm8001_ha, piomb); } goto ldv_47021; case_2306: /* CIL Label */ { tmp___40 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___40 != 0L) { { printk("\016pm80xx %s %d:OPC_OUB_SSP_COALESCED_COMP_RESP opcode:%x\n", "process_one_iomb", 3654, opc); } } else { } { ssp_coalesced_comp_resp(pm8001_ha, piomb); } goto ldv_47021; switch_default: /* CIL Label */ { tmp___41 = ldv__builtin_expect((pm8001_ha->logging_level & 64U) != 0U, 0L); } if (tmp___41 != 0L) { { printk("\016pm80xx %s %d:Unknown outbound Queue IOMB OPC = 0x%x\n", "process_one_iomb", 3659, opc); } } else { } goto ldv_47021; switch_break: /* CIL Label */ ; } ldv_47021: ; return; } } static int process_oq___0(struct pm8001_hba_info *pm8001_ha , u8 vec ) { struct outbound_queue_table *circularQ ; void *pMsg1 ; u8 bc ; u32 ret ; unsigned long flags ; { { pMsg1 = (void *)0; bc = bc; ret = 2U; ldv___ldv_linux_kernel_locking_spinlock_spin_lock_125___0(& pm8001_ha->lock); circularQ = (struct outbound_queue_table *)(& pm8001_ha->outbnd_q_tbl) + (unsigned long )vec; } ldv_47074: { ret = pm8001_mpi_msg_consume(pm8001_ha, circularQ, & pMsg1, & bc); } if (ret == 0U) { { process_one_iomb___0(pm8001_ha, pMsg1 + 0xfffffffffffffffcUL); pm8001_mpi_msg_free_set(pm8001_ha, pMsg1, circularQ, (int )bc); } } else { } if (ret == 1U) { { circularQ->producer_index = pm8001_read_32(circularQ->pi_virt); } if (circularQ->producer_index == circularQ->consumer_idx) { goto ldv_47073; } else { } } else { } goto ldv_47074; ldv_47073: { ldv_spin_unlock_irqrestore_109(& pm8001_ha->lock, flags); } return ((int )ret); } } static u8 const data_dir_flags___0[4U] = { 4U, 2U, 1U, 0U}; static void build_smp_cmd___0(u32 deviceID , __le32 hTag , struct smp_req___0 *psmp_cmd , int mode , int length ) { { psmp_cmd->tag = hTag; psmp_cmd->device_id = deviceID; if (mode == 1) { length = length + -4; psmp_cmd->len_ip_ir = (unsigned int )(length << 16); } else { psmp_cmd->len_ip_ir = 3U; } return; } } static int pm80xx_chip_smp_req(struct pm8001_hba_info *pm8001_ha , struct pm8001_ccb_info *ccb ) { int elem ; int rc ; struct sas_task *task ; struct domain_device *dev ; struct pm8001_device *pm8001_dev ; struct scatterlist *sg_req ; struct scatterlist *sg_resp ; u32 req_len ; u32 resp_len ; struct smp_req___0 smp_cmd ; u32 opc ; struct inbound_queue_table *circularQ ; char *preq_dma_addr ; __le64 tmp_addr ; u32 i ; u32 length ; long tmp ; void *tmp___0 ; long tmp___1 ; long tmp___2 ; long tmp___3 ; long tmp___4 ; { { task = ccb->task; dev = task->dev; pm8001_dev = (struct pm8001_device *)dev->lldd_dev; preq_dma_addr = (char *)0; __memset((void *)(& smp_cmd), 0, 124UL); sg_req = & task->__annonCompField95.smp_task.smp_req; elem = dma_map_sg_attrs___1(pm8001_ha->dev, sg_req, 1, 1, (struct dma_attrs *)0); } if (elem == 0) { return (-12); } else { } { req_len = sg_req->dma_length; sg_resp = & task->__annonCompField95.smp_task.smp_resp; elem = dma_map_sg_attrs___1(pm8001_ha->dev, sg_resp, 1, 2, (struct dma_attrs *)0); } if (elem == 0) { rc = -12; goto err_out; } else { } resp_len = sg_resp->dma_length; if ((req_len & 3U) != 0U || (resp_len & 3U) != 0U) { rc = -22; goto err_out_2; } else { } { opc = 18U; circularQ = (struct inbound_queue_table *)(& pm8001_ha->inbnd_q_tbl); smp_cmd.tag = ccb->ccb_tag; length = sg_req->length; tmp = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:SMP Frame Length %d\n", "pm80xx_chip_smp_req", 3768, sg_req->length); } } else { } if (length == 8U) { pm8001_ha->smp_exp_mode = 1U; } else { pm8001_ha->smp_exp_mode = 2U; } { tmp_addr = task->__annonCompField95.smp_task.smp_req.dma_address; tmp___0 = phys_to_virt(tmp_addr); preq_dma_addr = (char *)tmp___0; } if (pm8001_ha->smp_exp_mode == 2U) { { tmp___1 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___1 != 0L) { { printk("\016pm80xx %s %d:SMP REQUEST INDIRECT MODE\n", "pm80xx_chip_smp_req", 3781); } } else { } i = 0U; goto ldv_47107; ldv_47106: smp_cmd.smp_req16[i] = (u8 )*(preq_dma_addr + (unsigned long )i); i = i + 1U; ldv_47107: ; if (i <= 3U) { goto ldv_47106; } else { } smp_cmd.__annonCompField97.long_smp_req.long_req_addr = task->__annonCompField95.smp_task.smp_req.dma_address + 4ULL; smp_cmd.__annonCompField97.long_smp_req.long_req_size = task->__annonCompField95.smp_task.smp_req.dma_length - 8U; smp_cmd.__annonCompField97.long_smp_req.long_resp_addr = task->__annonCompField95.smp_task.smp_resp.dma_address; smp_cmd.__annonCompField97.long_smp_req.long_resp_size = task->__annonCompField95.smp_task.smp_resp.dma_length - 4U; } else { smp_cmd.__annonCompField97.long_smp_req.long_req_addr = task->__annonCompField95.smp_task.smp_req.dma_address; smp_cmd.__annonCompField97.long_smp_req.long_req_size = task->__annonCompField95.smp_task.smp_req.dma_length - 4U; smp_cmd.__annonCompField97.long_smp_req.long_resp_addr = task->__annonCompField95.smp_task.smp_resp.dma_address; smp_cmd.__annonCompField97.long_smp_req.long_resp_size = task->__annonCompField95.smp_task.smp_resp.dma_length - 4U; } if (pm8001_ha->smp_exp_mode == 1U) { { tmp___2 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___2 != 0L) { { printk("\016pm80xx %s %d:SMP REQUEST DIRECT MODE\n", "pm80xx_chip_smp_req", 3814); } } else { } i = 0U; goto ldv_47110; ldv_47109: ; if (i <= 15U) { { smp_cmd.smp_req16[i] = (u8 )*(preq_dma_addr + (unsigned long )i); tmp___3 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___3 != 0L) { { printk("\016pm80xx %s %d:Byte[%d]:%x (DMA data:%x)\n", "pm80xx_chip_smp_req", 3821, i, (int )smp_cmd.smp_req16[i], (int )*preq_dma_addr); } } else { } } else { { smp_cmd.__annonCompField97.smp_req[i] = (u8 )*(preq_dma_addr + (unsigned long )i); tmp___4 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___4 != 0L) { { printk("\016pm80xx %s %d:Byte[%d]:%x (DMA data:%x)\n", "pm80xx_chip_smp_req", 3827, i, (int )smp_cmd.__annonCompField97.smp_req[i], (int )*preq_dma_addr); } } else { } } i = i + 1U; ldv_47110: ; if (i < length) { goto ldv_47109; } else { } } else { } { build_smp_cmd___0(pm8001_dev->device_id, smp_cmd.tag, & smp_cmd, (int )pm8001_ha->smp_exp_mode, (int )length); rc = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, (void *)(& smp_cmd), 0U); } if (rc != 0) { goto err_out_2; } else { } return (0); err_out_2: { dma_unmap_sg_attrs(pm8001_ha->dev, & (ccb->task)->__annonCompField95.smp_task.smp_resp, 1, 2, (struct dma_attrs *)0); } err_out: { dma_unmap_sg_attrs(pm8001_ha->dev, & (ccb->task)->__annonCompField95.smp_task.smp_req, 1, 1, (struct dma_attrs *)0); } return (rc); } } static int check_enc_sas_cmd(struct sas_task *task ) { u8 cmd ; { cmd = *((task->__annonCompField95.ssp_task.cmd)->cmnd); if (((unsigned int )cmd == 40U || (unsigned int )cmd == 42U) || (unsigned int )cmd == 46U) { return (1); } else { return (0); } } } static int check_enc_sat_cmd(struct sas_task *task ) { int ret ; { ret = 0; { if ((int )task->__annonCompField95.ata_task.fis.command == 96) { goto case_96; } else { } if ((int )task->__annonCompField95.ata_task.fis.command == 37) { goto case_37; } else { } if ((int )task->__annonCompField95.ata_task.fis.command == 200) { goto case_200; } else { } if ((int )task->__annonCompField95.ata_task.fis.command == 97) { goto case_97; } else { } if ((int )task->__annonCompField95.ata_task.fis.command == 53) { goto case_53; } else { } if ((int )task->__annonCompField95.ata_task.fis.command == 202) { goto case_202; } else { } if ((int )task->__annonCompField95.ata_task.fis.command == 32) { goto case_32; } else { } if ((int )task->__annonCompField95.ata_task.fis.command == 36) { goto case_36; } else { } if ((int )task->__annonCompField95.ata_task.fis.command == 48) { goto case_48; } else { } if ((int )task->__annonCompField95.ata_task.fis.command == 52) { goto case_52; } else { } goto switch_default; case_96: /* CIL Label */ ; case_37: /* CIL Label */ ; case_200: /* CIL Label */ ; case_97: /* CIL Label */ ; case_53: /* CIL Label */ ; case_202: /* CIL Label */ ; case_32: /* CIL Label */ ; case_36: /* CIL Label */ ; case_48: /* CIL Label */ ; case_52: /* CIL Label */ ret = 1; goto ldv_47130; switch_default: /* CIL Label */ ret = 0; goto ldv_47130; switch_break: /* CIL Label */ ; } ldv_47130: ; return (ret); } } static int pm80xx_chip_ssp_io_req(struct pm8001_hba_info *pm8001_ha , struct pm8001_ccb_info *ccb ) { struct sas_task *task ; struct domain_device *dev ; struct pm8001_device *pm8001_dev ; struct ssp_ini_io_start_req___0 ssp_cmd ; u32 tag ; int ret ; u64 phys_addr ; u64 start_addr ; u64 end_addr ; u32 end_addr_high ; u32 end_addr_low ; struct inbound_queue_table *circularQ ; u32 q_index ; u32 opc ; long tmp ; u64 dma_addr ; long tmp___0 ; long tmp___1 ; u64 dma_addr___0 ; long tmp___2 ; int tmp___3 ; { { task = ccb->task; dev = task->dev; pm8001_dev = (struct pm8001_device *)dev->lldd_dev; tag = ccb->ccb_tag; opc = 6U; __memset((void *)(& ssp_cmd), 0, 124UL); __memcpy((void *)(& ssp_cmd.ssp_iu.lun), (void const *)(& task->__annonCompField95.ssp_task.LUN), 8UL); ssp_cmd.dad_dir_m_tlr = (unsigned int )((int )data_dir_flags___0[(int )task->data_dir] << 8); ssp_cmd.data_len = task->total_xfer_len; ssp_cmd.device_id = pm8001_dev->device_id; ssp_cmd.tag = tag; } if ((unsigned int )*((unsigned char *)task + 97UL) != 0U) { ssp_cmd.ssp_iu.efb_prio_attr = (u8 )((unsigned int )ssp_cmd.ssp_iu.efb_prio_attr | 128U); } else { } { ssp_cmd.ssp_iu.efb_prio_attr = (u8 )((int )((signed char )ssp_cmd.ssp_iu.efb_prio_attr) | (int )((signed char )((int )task->__annonCompField95.ssp_task.task_prio << 3))); ssp_cmd.ssp_iu.efb_prio_attr = (unsigned int )ssp_cmd.ssp_iu.efb_prio_attr | ((unsigned int )((u8 )task->__annonCompField95.ssp_task.task_attr) & 7U); __memcpy((void *)(& ssp_cmd.ssp_iu.cdb), (void const *)(task->__annonCompField95.ssp_task.cmd)->cmnd, (size_t )(task->__annonCompField95.ssp_task.cmd)->cmd_len); q_index = 0U; circularQ = (struct inbound_queue_table *)(& pm8001_ha->inbnd_q_tbl) + (unsigned long )q_index; } if ((unsigned int )(pm8001_ha->chip)->encrypt != 0U && pm8001_ha->encrypt_info.status == 0U) { { tmp___3 = check_enc_sas_cmd(task); } if (tmp___3 != 0) { { tmp = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:Encryption enabled.Sending Encrypt SAS command 0x%x\n", "pm80xx_chip_ssp_io_req", 3925, (int )*((task->__annonCompField95.ssp_task.cmd)->cmnd)); } } else { } opc = 258U; ssp_cmd.dad_dir_m_tlr = (unsigned int )(((int )data_dir_flags___0[(int )task->data_dir] << 8) | 32); if (task->num_scatter > 1) { { pm8001_chip_make_sg(task->scatter, (int )ccb->n_elem, (void *)(& ccb->buf_prd)); phys_addr = ccb->ccb_dma_handle + 48ULL; ssp_cmd.enc_addr_low = (unsigned int )phys_addr; ssp_cmd.enc_addr_high = (unsigned int )(phys_addr >> 32ULL); ssp_cmd.enc_esgl = 2147483648U; } } else if (task->num_scatter == 1) { dma_addr = (task->scatter)->dma_address; ssp_cmd.enc_addr_low = (unsigned int )dma_addr; ssp_cmd.enc_addr_high = (unsigned int )(dma_addr >> 32ULL); ssp_cmd.enc_len = task->total_xfer_len; ssp_cmd.enc_esgl = 0U; start_addr = dma_addr; end_addr = (start_addr + (u64 )ssp_cmd.enc_len) - 1ULL; end_addr_low = (unsigned int )end_addr; end_addr_high = (unsigned int )(end_addr >> 32ULL); if (end_addr_high != ssp_cmd.enc_addr_high) { { tmp___0 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___0 != 0L) { { printk("\016pm80xx %s %d:The sg list address start_addr=0x%016llx data_len=0x%x end_addr_high=0x%08x end_addr_low=0x%08x has crossed 4G boundary\n", "pm80xx_chip_ssp_io_req", 3962, start_addr, ssp_cmd.enc_len, end_addr_high, end_addr_low); } } else { } { pm8001_chip_make_sg(task->scatter, 1, (void *)(& ccb->buf_prd)); phys_addr = ccb->ccb_dma_handle + 48ULL; ssp_cmd.enc_addr_low = (unsigned int )phys_addr; ssp_cmd.enc_addr_high = (unsigned int )(phys_addr >> 32ULL); ssp_cmd.enc_esgl = 2147483648U; } } else { } } else if (task->num_scatter == 0) { ssp_cmd.enc_addr_low = 0U; ssp_cmd.enc_addr_high = 0U; ssp_cmd.enc_len = task->total_xfer_len; ssp_cmd.enc_esgl = 0U; } else { } ssp_cmd.key_cmode = 96U; ssp_cmd.twk_val0 = (unsigned int )(((((int )*((task->__annonCompField95.ssp_task.cmd)->cmnd + 2UL) << 24) | ((int )*((task->__annonCompField95.ssp_task.cmd)->cmnd + 3UL) << 16)) | ((int )*((task->__annonCompField95.ssp_task.cmd)->cmnd + 4UL) << 8)) | (int )*((task->__annonCompField95.ssp_task.cmd)->cmnd + 5UL)); } else { goto _L; } } else { _L: /* CIL Label */ { tmp___1 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___1 != 0L) { { printk("\016pm80xx %s %d:Sending Normal SAS command 0x%x inb q %x\n", "pm80xx_chip_ssp_io_req", 3990, (int )*((task->__annonCompField95.ssp_task.cmd)->cmnd), q_index); } } else { } if (task->num_scatter > 1) { { pm8001_chip_make_sg(task->scatter, (int )ccb->n_elem, (void *)(& ccb->buf_prd)); phys_addr = ccb->ccb_dma_handle + 48ULL; ssp_cmd.addr_low = (unsigned int )phys_addr; ssp_cmd.addr_high = (unsigned int )(phys_addr >> 32ULL); ssp_cmd.esgl = 2147483648U; } } else if (task->num_scatter == 1) { dma_addr___0 = (task->scatter)->dma_address; ssp_cmd.addr_low = (unsigned int )dma_addr___0; ssp_cmd.addr_high = (unsigned int )(dma_addr___0 >> 32ULL); ssp_cmd.len = task->total_xfer_len; ssp_cmd.esgl = 0U; start_addr = dma_addr___0; end_addr = (start_addr + (u64 )ssp_cmd.len) - 1ULL; end_addr_low = (unsigned int )end_addr; end_addr_high = (unsigned int )(end_addr >> 32ULL); if (end_addr_high != ssp_cmd.addr_high) { { tmp___2 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___2 != 0L) { { printk("\016pm80xx %s %d:The sg list address start_addr=0x%016llx data_len=0x%x end_addr_high=0x%08x end_addr_low=0x%08x has crossed 4G boundary\n", "pm80xx_chip_ssp_io_req", 4021, start_addr, ssp_cmd.len, end_addr_high, end_addr_low); } } else { } { pm8001_chip_make_sg(task->scatter, 1, (void *)(& ccb->buf_prd)); phys_addr = ccb->ccb_dma_handle + 48ULL; ssp_cmd.addr_low = (unsigned int )phys_addr; ssp_cmd.addr_high = (unsigned int )(phys_addr >> 32ULL); ssp_cmd.esgl = 2147483648U; } } else { } } else if (task->num_scatter == 0) { ssp_cmd.addr_low = 0U; ssp_cmd.addr_high = 0U; ssp_cmd.len = task->total_xfer_len; ssp_cmd.esgl = 0U; } else { } } { q_index = 0U; ret = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, (void *)(& ssp_cmd), q_index); } return (ret); } } static int pm80xx_chip_sata_req(struct pm8001_hba_info *pm8001_ha , struct pm8001_ccb_info *ccb ) { struct sas_task *task ; struct domain_device *dev ; struct pm8001_device *pm8001_ha_dev ; u32 tag ; int ret ; u32 q_index ; struct sata_start_req___0 sata_cmd ; u32 hdr_tag ; u32 ncg_tag ; u64 phys_addr ; u64 start_addr ; u64 end_addr ; u32 end_addr_high ; u32 end_addr_low ; u32 ATAP ; u32 dir ; struct inbound_queue_table *circularQ ; unsigned long flags ; u32 opc ; long tmp ; long tmp___0 ; long tmp___1 ; long tmp___2 ; long tmp___3 ; u32 tmp___4 ; long tmp___5 ; long tmp___6 ; u64 dma_addr ; long tmp___7 ; long tmp___8 ; u64 dma_addr___0 ; long tmp___9 ; int tmp___10 ; struct task_status_struct *ts ; long tmp___11 ; long tmp___12 ; { { task = ccb->task; dev = task->dev; pm8001_ha_dev = (struct pm8001_device *)dev->lldd_dev; tag = ccb->ccb_tag; ncg_tag = 0U; ATAP = 0U; opc = 23U; __memset((void *)(& sata_cmd), 0, 124UL); q_index = 0U; circularQ = (struct inbound_queue_table *)(& pm8001_ha->inbnd_q_tbl) + (unsigned long )q_index; } if ((unsigned int )*((unsigned char *)task + 184UL) == 3U) { { ATAP = 4U; tmp = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:no data\n", "pm80xx_chip_sata_req", 4070); } } else { } } else { { tmp___3 = ldv__builtin_expect((unsigned int )*((unsigned char *)task + 125UL) == 0U, 1L); } if (tmp___3 != 0L) { if ((unsigned int )*((unsigned char *)task + 125UL) != 0U) { { ATAP = 6U; tmp___0 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___0 != 0L) { { printk("\016pm80xx %s %d:DMA\n", "pm80xx_chip_sata_req", 4074); } } else { } } else { { ATAP = 5U; tmp___1 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___1 != 0L) { { printk("\016pm80xx %s %d:PIO\n", "pm80xx_chip_sata_req", 4077); } } else { } } if ((unsigned int )*((unsigned char *)task + 125UL) != 0U && dev->__annonCompField94.sata_dev.class != 3U) { { ATAP = 7U; tmp___2 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___2 != 0L) { { printk("\016pm80xx %s %d:FPDMA\n", "pm80xx_chip_sata_req", 4082); } } else { } } else { } } else { } } if ((unsigned int )*((unsigned char *)task + 125UL) != 0U) { { tmp___4 = pm8001_get_ncq_tag(task, & hdr_tag); } if (tmp___4 != 0U) { task->__annonCompField95.ata_task.fis.__annonCompField87.sector_count = (u8 )((int )task->__annonCompField95.ata_task.fis.__annonCompField87.sector_count | ((int )((unsigned char )hdr_tag) << 3U)); ncg_tag = hdr_tag; } else { } } else { } { dir = (u32 )((int )data_dir_flags___0[(int )task->data_dir] << 8); sata_cmd.tag = tag; sata_cmd.device_id = pm8001_ha_dev->device_id; sata_cmd.data_len = task->total_xfer_len; sata_cmd.sata_fis = task->__annonCompField95.ata_task.fis; tmp___5 = ldv__builtin_expect((unsigned int )*((unsigned char *)task + 125UL) == 0U, 1L); } if (tmp___5 != 0L) { sata_cmd.sata_fis.flags = (u8 )((unsigned int )sata_cmd.sata_fis.flags | 128U); } else { } sata_cmd.sata_fis.flags = (unsigned int )sata_cmd.sata_fis.flags & 240U; if ((unsigned int )(pm8001_ha->chip)->encrypt != 0U && pm8001_ha->encrypt_info.status == 0U) { { tmp___10 = check_enc_sat_cmd(task); } if (tmp___10 != 0) { { tmp___6 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___6 != 0L) { { printk("\016pm80xx %s %d:Encryption enabled.Sending Encrypt SATA cmd 0x%x\n", "pm80xx_chip_sata_req", 4104, (int )sata_cmd.sata_fis.command); } } else { } opc = 259U; sata_cmd.ncqtag_atap_dir_m_dad = ((((ncg_tag & 255U) << 16) | ((ATAP << 10) & 65535U)) | dir) | 32U; if (task->num_scatter > 1) { { pm8001_chip_make_sg(task->scatter, (int )ccb->n_elem, (void *)(& ccb->buf_prd)); phys_addr = ccb->ccb_dma_handle + 48ULL; sata_cmd.enc_addr_low = (unsigned int )phys_addr; sata_cmd.enc_addr_high = (unsigned int )(phys_addr >> 32ULL); sata_cmd.enc_esgl = 2147483648U; } } else if (task->num_scatter == 1) { dma_addr = (task->scatter)->dma_address; sata_cmd.enc_addr_low = (unsigned int )dma_addr; sata_cmd.enc_addr_high = (unsigned int )(dma_addr >> 32ULL); sata_cmd.enc_len = task->total_xfer_len; sata_cmd.enc_esgl = 0U; start_addr = dma_addr; end_addr = (start_addr + (u64 )sata_cmd.enc_len) - 1ULL; end_addr_low = (unsigned int )end_addr; end_addr_high = (unsigned int )(end_addr >> 32ULL); if (end_addr_high != sata_cmd.enc_addr_high) { { tmp___7 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___7 != 0L) { { printk("\016pm80xx %s %d:The sg list address start_addr=0x%016llx data_len=0x%x end_addr_high=0x%08x end_addr_low=0x%08x has crossed 4G boundary\n", "pm80xx_chip_sata_req", 4139, start_addr, sata_cmd.enc_len, end_addr_high, end_addr_low); } } else { } { pm8001_chip_make_sg(task->scatter, 1, (void *)(& ccb->buf_prd)); phys_addr = ccb->ccb_dma_handle + 48ULL; sata_cmd.enc_addr_low = (unsigned int )phys_addr; sata_cmd.enc_addr_high = (unsigned int )(phys_addr >> 32ULL); sata_cmd.enc_esgl = 2147483648U; } } else { } } else if (task->num_scatter == 0) { sata_cmd.enc_addr_low = 0U; sata_cmd.enc_addr_high = 0U; sata_cmd.enc_len = task->total_xfer_len; sata_cmd.enc_esgl = 0U; } else { } sata_cmd.key_index_mode = 96U; sata_cmd.twk_val0 = (unsigned int )(((((int )sata_cmd.sata_fis.lbal_exp << 24) | ((int )sata_cmd.sata_fis.__annonCompField86.lbah << 16)) | ((int )sata_cmd.sata_fis.__annonCompField85.lbam << 8)) | (int )sata_cmd.sata_fis.lbal); sata_cmd.twk_val1 = (unsigned int )(((int )sata_cmd.sata_fis.lbah_exp << 8) | (int )sata_cmd.sata_fis.lbam_exp); } else { goto _L; } } else { _L: /* CIL Label */ { tmp___8 = ldv__builtin_expect((pm8001_ha->logging_level & 8U) != 0U, 0L); } if (tmp___8 != 0L) { { printk("\016pm80xx %s %d:Sending Normal SATA command 0x%x inb %x\n", "pm80xx_chip_sata_req", 4172, (int )sata_cmd.sata_fis.command, q_index); } } else { } sata_cmd.ncqtag_atap_dir_m_dad = (((ncg_tag & 255U) << 16) | ((ATAP << 10) & 65535U)) | dir; if (task->num_scatter > 1) { { pm8001_chip_make_sg(task->scatter, (int )ccb->n_elem, (void *)(& ccb->buf_prd)); phys_addr = ccb->ccb_dma_handle + 48ULL; sata_cmd.addr_low = (unsigned int )phys_addr; sata_cmd.addr_high = (unsigned int )(phys_addr >> 32ULL); sata_cmd.esgl = 2147483648U; } } else if (task->num_scatter == 1) { dma_addr___0 = (task->scatter)->dma_address; sata_cmd.addr_low = (unsigned int )dma_addr___0; sata_cmd.addr_high = (unsigned int )(dma_addr___0 >> 32ULL); sata_cmd.len = task->total_xfer_len; sata_cmd.esgl = 0U; start_addr = dma_addr___0; end_addr = (start_addr + (u64 )sata_cmd.len) - 1ULL; end_addr_low = (unsigned int )end_addr; end_addr_high = (unsigned int )(end_addr >> 32ULL); if (end_addr_high != sata_cmd.addr_high) { { tmp___9 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___9 != 0L) { { printk("\016pm80xx %s %d:The sg list address start_addr=0x%016llx data_len=0x%xend_addr_high=0x%08x end_addr_low=0x%08x has crossed 4G boundary\n", "pm80xx_chip_sata_req", 4205, start_addr, sata_cmd.len, end_addr_high, end_addr_low); } } else { } { pm8001_chip_make_sg(task->scatter, 1, (void *)(& ccb->buf_prd)); phys_addr = ccb->ccb_dma_handle + 48ULL; sata_cmd.addr_low = (unsigned int )phys_addr; sata_cmd.addr_high = (unsigned int )(phys_addr >> 32ULL); sata_cmd.esgl = 2147483648U; } } else { } } else if (task->num_scatter == 0) { sata_cmd.addr_low = 0U; sata_cmd.addr_high = 0U; sata_cmd.len = task->total_xfer_len; sata_cmd.esgl = 0U; } else { } sata_cmd.atapi_scsi_cdb[0] = (unsigned int )((((int )task->__annonCompField95.ata_task.atapi_packet[0] | ((int )task->__annonCompField95.ata_task.atapi_packet[1] << 8)) | ((int )task->__annonCompField95.ata_task.atapi_packet[2] << 16)) | ((int )task->__annonCompField95.ata_task.atapi_packet[3] << 24)); sata_cmd.atapi_scsi_cdb[1] = (unsigned int )((((int )task->__annonCompField95.ata_task.atapi_packet[4] | ((int )task->__annonCompField95.ata_task.atapi_packet[5] << 8)) | ((int )task->__annonCompField95.ata_task.atapi_packet[6] << 16)) | ((int )task->__annonCompField95.ata_task.atapi_packet[7] << 24)); sata_cmd.atapi_scsi_cdb[2] = (unsigned int )((((int )task->__annonCompField95.ata_task.atapi_packet[8] | ((int )task->__annonCompField95.ata_task.atapi_packet[9] << 8)) | ((int )task->__annonCompField95.ata_task.atapi_packet[10] << 16)) | ((int )task->__annonCompField95.ata_task.atapi_packet[11] << 24)); sata_cmd.atapi_scsi_cdb[3] = (unsigned int )((((int )task->__annonCompField95.ata_task.atapi_packet[12] | ((int )task->__annonCompField95.ata_task.atapi_packet[13] << 8)) | ((int )task->__annonCompField95.ata_task.atapi_packet[14] << 16)) | ((int )task->__annonCompField95.ata_task.atapi_packet[15] << 24)); } if ((unsigned int )sata_cmd.sata_fis.command == 47U) { if ((unsigned long )pm8001_ha_dev != (unsigned long )((struct pm8001_device *)0) && ((int )pm8001_ha_dev->id < 0 || *((unsigned int *)pm8001_ha_dev + 5UL) != 0U)) { { pm8001_ha_dev->id = pm8001_ha_dev->id & 3758096383U; ts = & task->task_status; ldv___ldv_linux_kernel_locking_spinlock_spin_lock_127(& task->task_state_lock); ts->resp = 0; ts->stat = 0; task->task_state_flags = task->task_state_flags & 4294967294U; task->task_state_flags = task->task_state_flags & 4294967279U; task->task_state_flags = task->task_state_flags | 2U; tmp___12 = ldv__builtin_expect((task->task_state_flags & 4U) != 0U, 0L); } if (tmp___12 != 0L) { { ldv_spin_unlock_irqrestore_135(& task->task_state_lock, flags); tmp___11 = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp___11 != 0L) { { printk("\016pm80xx %s %d:task 0x%p resp 0x%x stat 0x%x but aborted by upper layer \n", "pm80xx_chip_sata_req", 4269, task, (int )ts->resp, (unsigned int )ts->stat); } } else { } { pm8001_ccb_task_free(pm8001_ha, task, ccb, tag); } return (0); } else { { ldv_spin_unlock_irqrestore_135(& task->task_state_lock, flags); pm8001_ccb_task_free_done___0(pm8001_ha, task, ccb, tag); } return (0); } } else { } } else { } { q_index = 0U; ret = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, (void *)(& sata_cmd), q_index); } return (ret); } } static int pm80xx_chip_phy_start_req(struct pm8001_hba_info *pm8001_ha , u8 phy_id ) { struct phy_start_req___0 payload ; struct inbound_queue_table *circularQ ; int ret ; u32 tag ; u32 opcode ; long tmp ; { { tag = 1U; opcode = 4U; circularQ = (struct inbound_queue_table *)(& pm8001_ha->inbnd_q_tbl); __memset((void *)(& payload), 0, 128UL); payload.tag = tag; tmp = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:PHY START REQ for phy_id %d\n", "pm80xx_chip_phy_start_req", 4306, (int )phy_id); } } else { } if (((unsigned int )(pm8001_ha->pdev)->device != 32884U && (unsigned int )(pm8001_ha->pdev)->device != 32886U) && (unsigned int )(pm8001_ha->pdev)->device != 32887U) { payload.ase_sh_lm_slr_phyid = (unsigned int )((int )phy_id | 14080); } else { payload.ase_sh_lm_slr_phyid = (unsigned int )((int )phy_id | 16128); } { payload.sas_identify.dev_type = 1U; payload.sas_identify.__annonCompField89.initiator_bits = 14U; __memcpy((void *)(& payload.sas_identify.sas_addr), (void const *)(& pm8001_ha->sas_addr), 8UL); payload.sas_identify.phy_id = phy_id; ret = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opcode, (void *)(& payload), 0U); } return (ret); } } static int pm80xx_chip_phy_stop_req(struct pm8001_hba_info *pm8001_ha , u8 phy_id ) { struct phy_stop_req___0 payload ; struct inbound_queue_table *circularQ ; int ret ; u32 tag ; u32 opcode ; { { tag = 1U; opcode = 5U; circularQ = (struct inbound_queue_table *)(& pm8001_ha->inbnd_q_tbl); __memset((void *)(& payload), 0, 124UL); payload.tag = tag; payload.phy_id = (unsigned int )phy_id; ret = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opcode, (void *)(& payload), 0U); } return (ret); } } static int pm80xx_chip_reg_dev_req(struct pm8001_hba_info *pm8001_ha , struct pm8001_device *pm8001_dev , u32 flag ) { struct reg_dev_req___0 payload ; u32 opc ; u32 stp_sspsmp_sata ; struct inbound_queue_table *circularQ ; u32 linkrate ; u32 phy_id ; int rc ; int tag ; struct pm8001_ccb_info *ccb ; u8 retryFlag ; u16 firstBurstSize ; u16 ITNT ; struct domain_device *dev ; struct domain_device *parent_dev ; { { stp_sspsmp_sata = 4U; tag = -559038737; retryFlag = 1U; firstBurstSize = 0U; ITNT = 2000U; dev = pm8001_dev->sas_device; parent_dev = dev->parent; circularQ = (struct inbound_queue_table *)(& pm8001_ha->inbnd_q_tbl); __memset((void *)(& payload), 0, 124UL); rc = pm8001_tag_alloc(pm8001_ha, (u32 *)(& tag)); } if (rc != 0) { return (rc); } else { } ccb = pm8001_ha->ccb_info + (unsigned long )tag; ccb->device = pm8001_dev; ccb->ccb_tag = (u32 )tag; payload.tag = (unsigned int )tag; if (flag == 1U) { stp_sspsmp_sata = 2U; } else if ((unsigned int )pm8001_dev->dev_type == 5U) { stp_sspsmp_sata = 0U; } else if ((unsigned int )pm8001_dev->dev_type - 1U <= 2U) { stp_sspsmp_sata = 1U; } else { } if ((unsigned long )parent_dev != (unsigned long )((struct domain_device *)0) && (unsigned int )parent_dev->dev_type - 2U <= 1U) { phy_id = (u32 )(parent_dev->__annonCompField94.ex_dev.ex_phy)->phy_id; } else { phy_id = pm8001_dev->attached_phy; } { opc = 50U; linkrate = (unsigned int )(pm8001_dev->sas_device)->linkrate < (unsigned int )(dev->port)->linkrate ? (unsigned int )(pm8001_dev->sas_device)->linkrate : (unsigned int )(dev->port)->linkrate; payload.phyid_portid = ((u32 )((pm8001_dev->sas_device)->port)->id & 255U) | ((phy_id << 8) & 65535U); payload.dtype_dlr_mcn_ir_retry = (((u32 )retryFlag & 1U) | ((linkrate & 15U) << 24)) | ((stp_sspsmp_sata & 3U) << 28); payload.firstburstsize_ITNexustimeout = (unsigned int )((int )ITNT | (int )firstBurstSize * 65536); __memcpy((void *)(& payload.sas_addr), (void const *)(& (pm8001_dev->sas_device)->sas_addr), 8UL); rc = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, (void *)(& payload), 0U); } if (rc != 0) { { pm8001_tag_free(pm8001_ha, (u32 )tag); } } else { } return (rc); } } static int pm80xx_chip_phy_ctl_req(struct pm8001_hba_info *pm8001_ha , u32 phyId , u32 phy_op ) { struct local_phy_ctl_req___0 payload ; struct inbound_queue_table *circularQ ; int ret ; u32 opc ; { { opc = 25U; __memset((void *)(& payload), 0, 124UL); circularQ = (struct inbound_queue_table *)(& pm8001_ha->inbnd_q_tbl); payload.tag = 1U; payload.phyop_phyid = ((phy_op << 8) & 65535U) | (phyId & 255U); ret = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, (void *)(& payload), 0U); } return (ret); } } static u32 pm80xx_chip_is_our_interupt(struct pm8001_hba_info *pm8001_ha ) { u32 value ; { return (1U); { value = pm8001_cr32(pm8001_ha, 0U, 32U); } if (value != 0U) { return (1U); } else { } return (0U); } } static irqreturn_t pm80xx_chip_isr(struct pm8001_hba_info *pm8001_ha , u8 vec ) { { { pm80xx_chip_interrupt_disable(pm8001_ha, (int )vec); process_oq___0(pm8001_ha, (int )vec); pm80xx_chip_interrupt_enable(pm8001_ha, (int )vec); } return (1); } } void mpi_set_phy_profile_req(struct pm8001_hba_info *pm8001_ha , u32 operation , u32 phyid , u32 length , u32 *buf ) { u32 tag ; u32 i ; u32 j ; int rc ; struct set_phy_profile_req payload ; struct inbound_queue_table *circularQ ; u32 opc ; long tmp ; long tmp___0 ; { { j = 0U; opc = 55U; __memset((void *)(& payload), 0, 124UL); rc = pm8001_tag_alloc(pm8001_ha, & tag); } if (rc != 0) { { tmp = ldv__builtin_expect((long )((int )pm8001_ha->logging_level) & 1L, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:Invalid tag\n", "mpi_set_phy_profile_req", 4496); } } else { } } else { } { circularQ = (struct inbound_queue_table *)(& pm8001_ha->inbnd_q_tbl); payload.tag = tag; payload.ppc_phyid = ((operation & 15U) << 8) | (phyid & 255U); tmp___0 = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp___0 != 0L) { { printk("\016pm80xx %s %d: phy profile command for phy %x ,length is %d\n", "mpi_set_phy_profile_req", 4502, payload.ppc_phyid, length); } } else { } i = length; goto ldv_47251; ldv_47250: payload.reserved[j] = *(buf + (unsigned long )i); j = j + 1U; i = i + 1U; ldv_47251: ; if (i < length + 11U) { goto ldv_47250; } else { } { rc = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, (void *)(& payload), 0U); } if (rc != 0) { { pm8001_tag_free(pm8001_ha, tag); } } else { } return; } } void pm8001_set_phy_profile(struct pm8001_hba_info *pm8001_ha , u32 length , u8 *buf ) { u32 page_code ; u32 i ; long tmp ; { page_code = 4U; i = 0U; goto ldv_47261; ldv_47260: { mpi_set_phy_profile_req(pm8001_ha, 4U, i, length, (u32 *)buf); length = length + 12U; i = i + 1U; } ldv_47261: ; if (i < (u32 )(pm8001_ha->chip)->n_phy) { goto ldv_47260; } else { } { tmp = ldv__builtin_expect((pm8001_ha->logging_level & 2U) != 0U, 0L); } if (tmp != 0L) { { printk("\016pm80xx %s %d:phy settings completed\n", "pm8001_set_phy_profile", 4523); } } else { } return; } } struct pm8001_dispatch const pm8001_80xx_dispatch = {(char *)"pmc80xx", & pm80xx_chip_init, & pm80xx_chip_soft_rst, & pm80xx_hw_chip_rst, 0, & pm8001_chip_iounmap, & pm80xx_chip_isr, & pm80xx_chip_is_our_interupt, & process_oq___0, & pm80xx_chip_interrupt_enable, & pm80xx_chip_interrupt_disable, & pm8001_chip_make_sg, & pm80xx_chip_smp_req, & pm80xx_chip_ssp_io_req, & pm80xx_chip_sata_req, & pm80xx_chip_phy_start_req, & pm80xx_chip_phy_stop_req, & pm80xx_chip_reg_dev_req, & pm8001_chip_dereg_dev_req, & pm80xx_chip_phy_ctl_req, & pm8001_chip_abort_task, & pm8001_chip_ssp_tm_req, & pm8001_chip_get_nvmd_req, & pm8001_chip_set_nvmd_req, & pm8001_chip_fw_flash_update_req, & pm8001_chip_set_dev_state_req, 0, 0, 0}; void ldv_dummy_resourceless_instance_callback_20_10(int (*arg0)(struct pm8001_hba_info * , unsigned int ) , struct pm8001_hba_info *arg1 , unsigned int arg2 ) { { { pm8001_chip_dereg_dev_req(arg1, arg2); } return; } } void ldv_dummy_resourceless_instance_callback_20_13(int (*arg0)(struct pm8001_hba_info * , void * ) , struct pm8001_hba_info *arg1 , void *arg2 ) { { { pm8001_chip_fw_flash_update_req(arg1, arg2); } return; } } void ldv_dummy_resourceless_instance_callback_20_14(int (*arg0)(struct pm8001_hba_info * , void * ) , struct pm8001_hba_info *arg1 , void *arg2 ) { { { pm8001_chip_get_nvmd_req(arg1, arg2); } return; } } void ldv_dummy_resourceless_instance_callback_20_25(int (*arg0)(struct pm8001_hba_info * , unsigned char ) , struct pm8001_hba_info *arg1 , unsigned char arg2 ) { { { process_oq___0(arg1, (int )arg2); } return; } } void ldv_dummy_resourceless_instance_callback_20_28(void (*arg0)(struct scatterlist * , int , void * ) , struct scatterlist *arg1 , int arg2 , void *arg3 ) { { { pm8001_chip_make_sg(arg1, arg2, arg3); } return; } } void ldv_dummy_resourceless_instance_callback_20_45(int (*arg0)(struct pm8001_hba_info * , struct pm8001_device * , unsigned int ) , struct pm8001_hba_info *arg1 , struct pm8001_device *arg2 , unsigned int arg3 ) { { { pm8001_chip_set_dev_state_req(arg1, arg2, arg3); } return; } } void ldv_dummy_resourceless_instance_callback_20_48(int (*arg0)(struct pm8001_hba_info * , void * ) , struct pm8001_hba_info *arg1 , void *arg2 ) { { { pm8001_chip_set_nvmd_req(arg1, arg2); } return; } } void ldv_dummy_resourceless_instance_callback_20_51(int (*arg0)(struct pm8001_hba_info * , struct pm8001_ccb_info * , struct pm8001_tmf_task * ) , struct pm8001_hba_info *arg1 , struct pm8001_ccb_info *arg2 , struct pm8001_tmf_task *arg3 ) { { { pm8001_chip_ssp_tm_req(arg1, arg2, arg3); } return; } } void ldv_dummy_resourceless_instance_callback_20_52(int (*arg0)(struct pm8001_hba_info * , struct pm8001_device * , unsigned char , unsigned int , unsigned int ) , struct pm8001_hba_info *arg1 , struct pm8001_device *arg2 , unsigned char arg3 , unsigned int arg4 , unsigned int arg5 ) { { { pm8001_chip_abort_task(arg1, arg2, (int )arg3, arg4, arg5); } return; } } void ldv_dummy_resourceless_instance_callback_20_7(void (*arg0)(struct pm8001_hba_info * ) , struct pm8001_hba_info *arg1 ) { { { pm8001_chip_iounmap(arg1); } return; } } void ldv_dummy_resourceless_instance_callback_21_10(int (*arg0)(struct pm8001_hba_info * , unsigned int ) , struct pm8001_hba_info *arg1 , unsigned int arg2 ) { { { pm8001_chip_dereg_dev_req(arg1, arg2); } return; } } void ldv_dummy_resourceless_instance_callback_21_13(int (*arg0)(struct pm8001_hba_info * , void * ) , struct pm8001_hba_info *arg1 , void *arg2 ) { { { pm8001_chip_fw_flash_update_req(arg1, arg2); } return; } } void ldv_dummy_resourceless_instance_callback_21_14(int (*arg0)(struct pm8001_hba_info * , void * ) , struct pm8001_hba_info *arg1 , void *arg2 ) { { { pm8001_chip_get_nvmd_req(arg1, arg2); } return; } } void ldv_dummy_resourceless_instance_callback_21_15(void (*arg0)(struct pm8001_hba_info * , unsigned char ) , struct pm8001_hba_info *arg1 , unsigned char arg2 ) { { { pm80xx_chip_interrupt_disable(arg1, (int )arg2); } return; } } void ldv_dummy_resourceless_instance_callback_21_18(void (*arg0)(struct pm8001_hba_info * , unsigned char ) , struct pm8001_hba_info *arg1 , unsigned char arg2 ) { { { pm80xx_chip_interrupt_enable(arg1, (int )arg2); } return; } } void ldv_dummy_resourceless_instance_callback_21_21(unsigned int (*arg0)(struct pm8001_hba_info * ) , struct pm8001_hba_info *arg1 ) { { { pm80xx_chip_is_our_interupt(arg1); } return; } } void ldv_dummy_resourceless_instance_callback_21_22(enum irqreturn (*arg0)(struct pm8001_hba_info * , unsigned char ) , struct pm8001_hba_info *arg1 , unsigned char arg2 ) { { { pm80xx_chip_isr(arg1, (int )arg2); } return; } } void ldv_dummy_resourceless_instance_callback_21_25(int (*arg0)(struct pm8001_hba_info * , unsigned char ) , struct pm8001_hba_info *arg1 , unsigned char arg2 ) { { { process_oq___0(arg1, (int )arg2); } return; } } void ldv_dummy_resourceless_instance_callback_21_28(void (*arg0)(struct scatterlist * , int , void * ) , struct scatterlist *arg1 , int arg2 , void *arg3 ) { { { pm8001_chip_make_sg(arg1, arg2, arg3); } return; } } void ldv_dummy_resourceless_instance_callback_21_3(int (*arg0)(struct pm8001_hba_info * ) , struct pm8001_hba_info *arg1 ) { { { pm80xx_chip_init(arg1); } return; } } void ldv_dummy_resourceless_instance_callback_21_31(int (*arg0)(struct pm8001_hba_info * , unsigned int , unsigned int ) , struct pm8001_hba_info *arg1 , unsigned int arg2 , unsigned int arg3 ) { { { pm80xx_chip_phy_ctl_req(arg1, arg2, arg3); } return; } } void ldv_dummy_resourceless_instance_callback_21_34(int (*arg0)(struct pm8001_hba_info * , unsigned char ) , struct pm8001_hba_info *arg1 , unsigned char arg2 ) { { { pm80xx_chip_phy_start_req(arg1, (int )arg2); } return; } } void ldv_dummy_resourceless_instance_callback_21_37(int (*arg0)(struct pm8001_hba_info * , unsigned char ) , struct pm8001_hba_info *arg1 , unsigned char arg2 ) { { { pm80xx_chip_phy_stop_req(arg1, (int )arg2); } return; } } void ldv_dummy_resourceless_instance_callback_21_40(int (*arg0)(struct pm8001_hba_info * , struct pm8001_device * , unsigned int ) , struct pm8001_hba_info *arg1 , struct pm8001_device *arg2 , unsigned int arg3 ) { { { pm80xx_chip_reg_dev_req(arg1, arg2, arg3); } return; } } void ldv_dummy_resourceless_instance_callback_21_44(int (*arg0)(struct pm8001_hba_info * , struct pm8001_ccb_info * ) , struct pm8001_hba_info *arg1 , struct pm8001_ccb_info *arg2 ) { { { pm80xx_chip_sata_req(arg1, arg2); } return; } } void ldv_dummy_resourceless_instance_callback_21_45(int (*arg0)(struct pm8001_hba_info * , struct pm8001_device * , unsigned int ) , struct pm8001_hba_info *arg1 , struct pm8001_device *arg2 , unsigned int arg3 ) { { { pm8001_chip_set_dev_state_req(arg1, arg2, arg3); } return; } } void ldv_dummy_resourceless_instance_callback_21_48(int (*arg0)(struct pm8001_hba_info * , void * ) , struct pm8001_hba_info *arg1 , void *arg2 ) { { { pm8001_chip_set_nvmd_req(arg1, arg2); } return; } } void ldv_dummy_resourceless_instance_callback_21_49(int (*arg0)(struct pm8001_hba_info * , struct pm8001_ccb_info * ) , struct pm8001_hba_info *arg1 , struct pm8001_ccb_info *arg2 ) { { { pm80xx_chip_smp_req(arg1, arg2); } return; } } void ldv_dummy_resourceless_instance_callback_21_50(int (*arg0)(struct pm8001_hba_info * , struct pm8001_ccb_info * ) , struct pm8001_hba_info *arg1 , struct pm8001_ccb_info *arg2 ) { { { pm80xx_chip_ssp_io_req(arg1, arg2); } return; } } void ldv_dummy_resourceless_instance_callback_21_51(int (*arg0)(struct pm8001_hba_info * , struct pm8001_ccb_info * , struct pm8001_tmf_task * ) , struct pm8001_hba_info *arg1 , struct pm8001_ccb_info *arg2 , struct pm8001_tmf_task *arg3 ) { { { pm8001_chip_ssp_tm_req(arg1, arg2, arg3); } return; } } void ldv_dummy_resourceless_instance_callback_21_52(int (*arg0)(struct pm8001_hba_info * , struct pm8001_device * , unsigned char , unsigned int , unsigned int ) , struct pm8001_hba_info *arg1 , struct pm8001_device *arg2 , unsigned char arg3 , unsigned int arg4 , unsigned int arg5 ) { { { pm8001_chip_abort_task(arg1, arg2, (int )arg3, arg4, arg5); } return; } } void ldv_dummy_resourceless_instance_callback_21_7(void (*arg0)(struct pm8001_hba_info * ) , struct pm8001_hba_info *arg1 ) { { { pm8001_chip_iounmap(arg1); } return; } } void ldv_dummy_resourceless_instance_callback_21_8(void (*arg0)(struct pm8001_hba_info * ) , struct pm8001_hba_info *arg1 ) { { { pm80xx_hw_chip_rst(arg1); } return; } } void ldv_dummy_resourceless_instance_callback_21_9(int (*arg0)(struct pm8001_hba_info * ) , struct pm8001_hba_info *arg1 ) { { { pm80xx_chip_soft_rst(arg1); } return; } } static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_100___1(spinlock_t *ldv_func_arg1 ) { { { ldv_linux_kernel_locking_spinlock_spin_lock_task_state_lock_of_sas_task(); __ldv_linux_kernel_locking_spinlock_spin_lock(ldv_func_arg1); } return; } } static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_103(spinlock_t *ldv_func_arg1 ) { { { ldv_linux_kernel_locking_spinlock_spin_lock_task_state_lock_of_sas_task(); __ldv_linux_kernel_locking_spinlock_spin_lock(ldv_func_arg1); } return; } } static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_106(spinlock_t *ldv_func_arg1 ) { { { ldv_linux_kernel_locking_spinlock_spin_lock_task_state_lock_of_sas_task(); __ldv_linux_kernel_locking_spinlock_spin_lock(ldv_func_arg1); } return; } } static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_109(spinlock_t *ldv_func_arg1 ) { { { ldv_linux_kernel_locking_spinlock_spin_lock_task_state_lock_of_sas_task(); __ldv_linux_kernel_locking_spinlock_spin_lock(ldv_func_arg1); } return; } } static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_112___0(spinlock_t *ldv_func_arg1 ) { { { ldv_linux_kernel_locking_spinlock_spin_lock_task_state_lock_of_sas_task(); __ldv_linux_kernel_locking_spinlock_spin_lock(ldv_func_arg1); } return; } } static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_115(spinlock_t *ldv_func_arg1 ) { { { ldv_linux_kernel_locking_spinlock_spin_lock_frame_rcvd_lock_of_asd_sas_phy(); __ldv_linux_kernel_locking_spinlock_spin_lock(ldv_func_arg1); } return; } } static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_117(spinlock_t *ldv_func_arg1 ) { { { ldv_linux_kernel_locking_spinlock_spin_lock_frame_rcvd_lock_of_asd_sas_phy(); __ldv_linux_kernel_locking_spinlock_spin_lock(ldv_func_arg1); } return; } } static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_119(spinlock_t *ldv_func_arg1 ) { { { ldv_linux_kernel_locking_spinlock_spin_lock_sas_prim_lock_of_asd_sas_phy(); __ldv_linux_kernel_locking_spinlock_spin_lock(ldv_func_arg1); } return; } } static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_121(spinlock_t *ldv_func_arg1 ) { { { ldv_linux_kernel_locking_spinlock_spin_lock_sas_prim_lock_of_asd_sas_phy(); __ldv_linux_kernel_locking_spinlock_spin_lock(ldv_func_arg1); } return; } } static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_123(spinlock_t *ldv_func_arg1 ) { { { ldv_linux_kernel_locking_spinlock_spin_lock_sas_prim_lock_of_asd_sas_phy(); __ldv_linux_kernel_locking_spinlock_spin_lock(ldv_func_arg1); } return; } } static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_125___0(spinlock_t *ldv_func_arg1 ) { { { ldv_linux_kernel_locking_spinlock_spin_lock_lock_of_pm8001_hba_info(); __ldv_linux_kernel_locking_spinlock_spin_lock(ldv_func_arg1); } return; } } static void ldv___ldv_linux_kernel_locking_spinlock_spin_lock_127(spinlock_t *ldv_func_arg1 ) { { { ldv_linux_kernel_locking_spinlock_spin_lock_task_state_lock_of_sas_task(); __ldv_linux_kernel_locking_spinlock_spin_lock(ldv_func_arg1); } return; } } void ldv_assert_linux_alloc_irq__nonatomic(int expr ) ; void ldv_assert_linux_alloc_irq__wrong_flags(int expr ) ; bool ldv_in_interrupt_context(void) ; void ldv_linux_alloc_irq_check_alloc_flags(gfp_t flags ) { bool tmp ; int tmp___0 ; { { tmp = ldv_in_interrupt_context(); } if (tmp) { tmp___0 = 0; } else { tmp___0 = 1; } { ldv_assert_linux_alloc_irq__wrong_flags(tmp___0 || flags == 32U); } return; } } void ldv_linux_alloc_irq_check_alloc_nonatomic(void) { bool tmp ; { { tmp = ldv_in_interrupt_context(); } if ((int )tmp) { { ldv_assert_linux_alloc_irq__nonatomic(0); } } else { } return; } } void ldv_assert_linux_alloc_spinlock__nonatomic(int expr ) ; void ldv_assert_linux_alloc_spinlock__wrong_flags(int expr ) ; int ldv_exclusive_spin_is_locked(void) ; void ldv_linux_alloc_spinlock_check_alloc_flags(gfp_t flags ) { int tmp ; { if (flags != 32U && flags != 0U) { { tmp = ldv_exclusive_spin_is_locked(); ldv_assert_linux_alloc_spinlock__wrong_flags(tmp == 0); } } else { } return; } } void ldv_linux_alloc_spinlock_check_alloc_nonatomic(void) { int tmp ; { { tmp = ldv_exclusive_spin_is_locked(); ldv_assert_linux_alloc_spinlock__nonatomic(tmp == 0); } return; } } void ldv_assert_linux_alloc_usb_lock__nonatomic(int expr ) ; void ldv_assert_linux_alloc_usb_lock__wrong_flags(int expr ) ; int ldv_linux_alloc_usb_lock_lock = 1; void ldv_linux_alloc_usb_lock_check_alloc_flags(gfp_t flags ) { { if (ldv_linux_alloc_usb_lock_lock == 2) { { ldv_assert_linux_alloc_usb_lock__wrong_flags(flags == 16U || flags == 32U); } } else { } return; } } void ldv_linux_alloc_usb_lock_check_alloc_nonatomic(void) { { { ldv_assert_linux_alloc_usb_lock__nonatomic(ldv_linux_alloc_usb_lock_lock == 1); } return; } } void ldv_linux_alloc_usb_lock_usb_lock_device(void) { { ldv_linux_alloc_usb_lock_lock = 2; return; } } int ldv_linux_alloc_usb_lock_usb_trylock_device(void) { int tmp ; { if (ldv_linux_alloc_usb_lock_lock == 1) { { tmp = ldv_undef_int(); } if (tmp != 0) { ldv_linux_alloc_usb_lock_lock = 2; return (1); } else { return (0); } } else { return (0); } } } int ldv_linux_alloc_usb_lock_usb_lock_device_for_reset(void) { int tmp ; { if (ldv_linux_alloc_usb_lock_lock == 1) { { tmp = ldv_undef_int(); } if (tmp != 0) { ldv_linux_alloc_usb_lock_lock = 2; return (0); } else { return (-1); } } else { return (-1); } } } void ldv_linux_alloc_usb_lock_usb_unlock_device(void) { { ldv_linux_alloc_usb_lock_lock = 1; return; } } void ldv_linux_usb_dev_atomic_add(int i , atomic_t *v ) { { v->counter = v->counter + i; return; } } void ldv_linux_usb_dev_atomic_sub(int i , atomic_t *v ) { { v->counter = v->counter - i; return; } } int ldv_linux_usb_dev_atomic_sub_and_test(int i , atomic_t *v ) { { v->counter = v->counter - i; if (v->counter != 0) { return (0); } else { } return (1); } } void ldv_linux_usb_dev_atomic_inc(atomic_t *v ) { { v->counter = v->counter + 1; return; } } void ldv_linux_usb_dev_atomic_dec(atomic_t *v ) { { v->counter = v->counter - 1; return; } } int ldv_linux_usb_dev_atomic_dec_and_test(atomic_t *v ) { { v->counter = v->counter - 1; if (v->counter != 0) { return (0); } else { } return (1); } } int ldv_linux_usb_dev_atomic_inc_and_test(atomic_t *v ) { { v->counter = v->counter + 1; if (v->counter != 0) { return (0); } else { } return (1); } } int ldv_linux_usb_dev_atomic_add_return(int i , atomic_t *v ) { { v->counter = v->counter + i; return (v->counter); } } int ldv_linux_usb_dev_atomic_add_negative(int i , atomic_t *v ) { { v->counter = v->counter + i; return (v->counter < 0); } } int ldv_linux_usb_dev_atomic_inc_short(short *v ) { { *v = (short )((unsigned int )((unsigned short )*v) + 1U); return ((int )*v); } } void ldv_assert_linux_arch_io__less_initial_decrement(int expr ) ; void ldv_assert_linux_arch_io__more_initial_at_exit(int expr ) ; void *ldv_undef_ptr(void) ; int ldv_linux_arch_io_iomem = 0; void *ldv_linux_arch_io_io_mem_remap(void) { void *ptr ; void *tmp ; { { tmp = ldv_undef_ptr(); ptr = tmp; } if ((unsigned long )ptr != (unsigned long )((void *)0)) { ldv_linux_arch_io_iomem = ldv_linux_arch_io_iomem + 1; return (ptr); } else { } return (ptr); } } void ldv_linux_arch_io_io_mem_unmap(void) { { { ldv_assert_linux_arch_io__less_initial_decrement(ldv_linux_arch_io_iomem > 0); ldv_linux_arch_io_iomem = ldv_linux_arch_io_iomem - 1; } return; } } void ldv_linux_arch_io_check_final_state(void) { { { ldv_assert_linux_arch_io__more_initial_at_exit(ldv_linux_arch_io_iomem == 0); } return; } } void ldv_assert_linux_block_genhd__delete_before_add(int expr ) ; void ldv_assert_linux_block_genhd__double_allocation(int expr ) ; void ldv_assert_linux_block_genhd__free_before_allocation(int expr ) ; void ldv_assert_linux_block_genhd__more_initial_at_exit(int expr ) ; void ldv_assert_linux_block_genhd__use_before_allocation(int expr ) ; static int ldv_linux_block_genhd_disk_state = 0; struct gendisk *ldv_linux_block_genhd_alloc_disk(void) { struct gendisk *res ; void *tmp ; { { tmp = ldv_undef_ptr(); res = (struct gendisk *)tmp; ldv_assert_linux_block_genhd__double_allocation(ldv_linux_block_genhd_disk_state == 0); } if ((unsigned long )res != (unsigned long )((struct gendisk *)0)) { ldv_linux_block_genhd_disk_state = 1; return (res); } else { } return (res); } } void ldv_linux_block_genhd_add_disk(void) { { { ldv_assert_linux_block_genhd__use_before_allocation(ldv_linux_block_genhd_disk_state == 1); ldv_linux_block_genhd_disk_state = 2; } return; } } void ldv_linux_block_genhd_del_gendisk(void) { { { ldv_assert_linux_block_genhd__delete_before_add(ldv_linux_block_genhd_disk_state == 2); ldv_linux_block_genhd_disk_state = 1; } return; } } void ldv_linux_block_genhd_put_disk(struct gendisk *disk ) { { if ((unsigned long )disk != (unsigned long )((struct gendisk *)0)) { { ldv_assert_linux_block_genhd__free_before_allocation(ldv_linux_block_genhd_disk_state > 0); ldv_linux_block_genhd_disk_state = 0; } } else { } return; } } void ldv_linux_block_genhd_check_final_state(void) { { { ldv_assert_linux_block_genhd__more_initial_at_exit(ldv_linux_block_genhd_disk_state == 0); } return; } } void ldv_assert_linux_block_queue__double_allocation(int expr ) ; void ldv_assert_linux_block_queue__more_initial_at_exit(int expr ) ; void ldv_assert_linux_block_queue__use_before_allocation(int expr ) ; static int ldv_linux_block_queue_queue_state = 0; struct request_queue *ldv_linux_block_queue_request_queue(void) { struct request_queue *res ; void *tmp ; { { tmp = ldv_undef_ptr(); res = (struct request_queue *)tmp; ldv_assert_linux_block_queue__double_allocation(ldv_linux_block_queue_queue_state == 0); } if ((unsigned long )res != (unsigned long )((struct request_queue *)0)) { ldv_linux_block_queue_queue_state = 1; return (res); } else { } return (res); } } void ldv_linux_block_queue_blk_cleanup_queue(void) { { { ldv_assert_linux_block_queue__use_before_allocation(ldv_linux_block_queue_queue_state == 1); ldv_linux_block_queue_queue_state = 0; } return; } } void ldv_linux_block_queue_check_final_state(void) { { { ldv_assert_linux_block_queue__more_initial_at_exit(ldv_linux_block_queue_queue_state == 0); } return; } } void ldv_assert_linux_block_request__double_get(int expr ) ; void ldv_assert_linux_block_request__double_put(int expr ) ; void ldv_assert_linux_block_request__get_at_exit(int expr ) ; long ldv_is_err(void const *ptr ) ; int ldv_linux_block_request_blk_rq = 0; struct request *ldv_linux_block_request_blk_get_request(gfp_t mask ) { struct request *res ; void *tmp ; { { ldv_assert_linux_block_request__double_get(ldv_linux_block_request_blk_rq == 0); tmp = ldv_undef_ptr(); res = (struct request *)tmp; } if ((mask == 16U || mask == 208U) || mask == 16U) { { ldv_assume((unsigned long )res != (unsigned long )((struct request *)0)); } } else { } if ((unsigned long )res != (unsigned long )((struct request *)0)) { ldv_linux_block_request_blk_rq = 1; } else { } return (res); } } struct request *ldv_linux_block_request_blk_make_request(gfp_t mask ) { struct request *res ; void *tmp ; long tmp___0 ; { { ldv_assert_linux_block_request__double_get(ldv_linux_block_request_blk_rq == 0); tmp = ldv_undef_ptr(); res = (struct request *)tmp; ldv_assume((unsigned long )res != (unsigned long )((struct request *)0)); tmp___0 = ldv_is_err((void const *)res); } if (tmp___0 == 0L) { ldv_linux_block_request_blk_rq = 1; } else { } return (res); } } void ldv_linux_block_request_put_blk_rq(void) { { { ldv_assert_linux_block_request__double_put(ldv_linux_block_request_blk_rq == 1); ldv_linux_block_request_blk_rq = 0; } return; } } void ldv_linux_block_request_check_final_state(void) { { { ldv_assert_linux_block_request__get_at_exit(ldv_linux_block_request_blk_rq == 0); } return; } } void ldv_assert_linux_drivers_base_class__double_deregistration(int expr ) ; void ldv_assert_linux_drivers_base_class__double_registration(int expr ) ; void ldv_assert_linux_drivers_base_class__registered_at_exit(int expr ) ; int ldv_undef_int_nonpositive(void) ; int ldv_linux_drivers_base_class_usb_gadget_class = 0; void *ldv_linux_drivers_base_class_create_class(void) { void *is_got ; long tmp ; { { is_got = ldv_undef_ptr(); ldv_assume((int )((long )is_got)); tmp = ldv_is_err((void const *)is_got); } if (tmp == 0L) { { ldv_assert_linux_drivers_base_class__double_registration(ldv_linux_drivers_base_class_usb_gadget_class == 0); ldv_linux_drivers_base_class_usb_gadget_class = 1; } } else { } return (is_got); } } int ldv_linux_drivers_base_class_register_class(void) { int is_reg ; { { is_reg = ldv_undef_int_nonpositive(); } if (is_reg == 0) { { ldv_assert_linux_drivers_base_class__double_registration(ldv_linux_drivers_base_class_usb_gadget_class == 0); ldv_linux_drivers_base_class_usb_gadget_class = 1; } } else { } return (is_reg); } } void ldv_linux_drivers_base_class_unregister_class(void) { { { ldv_assert_linux_drivers_base_class__double_deregistration(ldv_linux_drivers_base_class_usb_gadget_class == 1); ldv_linux_drivers_base_class_usb_gadget_class = 0; } return; } } void ldv_linux_drivers_base_class_destroy_class(struct class *cls ) { long tmp ; { if ((unsigned long )cls == (unsigned long )((struct class *)0)) { return; } else { { tmp = ldv_is_err((void const *)cls); } if (tmp != 0L) { return; } else { } } { ldv_linux_drivers_base_class_unregister_class(); } return; } } void ldv_linux_drivers_base_class_check_final_state(void) { { { ldv_assert_linux_drivers_base_class__registered_at_exit(ldv_linux_drivers_base_class_usb_gadget_class == 0); } return; } } void *ldv_xzalloc(size_t size ) ; void *ldv_dev_get_drvdata(struct device const *dev ) { { if ((unsigned long )dev != (unsigned long )((struct device const *)0) && (unsigned long )dev->p != (unsigned long )((struct device_private */* const */)0)) { return ((dev->p)->driver_data); } else { } return ((void *)0); } } int ldv_dev_set_drvdata(struct device *dev , void *data ) { void *tmp ; { { tmp = ldv_xzalloc(8UL); dev->p = (struct device_private *)tmp; (dev->p)->driver_data = data; } return (0); } } void *ldv_zalloc(size_t size ) ; struct spi_master *ldv_spi_alloc_master(struct device *host , unsigned int size ) { struct spi_master *master ; void *tmp ; { { tmp = ldv_zalloc((unsigned long )size + 2176UL); master = (struct spi_master *)tmp; } if ((unsigned long )master == (unsigned long )((struct spi_master *)0)) { return ((struct spi_master *)0); } else { } { ldv_dev_set_drvdata(& master->dev, (void *)master + 1U); } return (master); } } long ldv_is_err(void const *ptr ) { { return ((unsigned long )ptr > 4294967295UL); } } void *ldv_err_ptr(long error ) { { return ((void *)(4294967295L - error)); } } long ldv_ptr_err(void const *ptr ) { { return ((long )(4294967295UL - (unsigned long )ptr)); } } long ldv_is_err_or_null(void const *ptr ) { long tmp ; int tmp___0 ; { if ((unsigned long )ptr == (unsigned long )((void const *)0)) { tmp___0 = 1; } else { { tmp = ldv_is_err(ptr); } if (tmp != 0L) { tmp___0 = 1; } else { tmp___0 = 0; } } return ((long )tmp___0); } } void ldv_assert_linux_fs_char_dev__double_deregistration(int expr ) ; void ldv_assert_linux_fs_char_dev__double_registration(int expr ) ; void ldv_assert_linux_fs_char_dev__registered_at_exit(int expr ) ; int ldv_linux_fs_char_dev_usb_gadget_chrdev = 0; int ldv_linux_fs_char_dev_register_chrdev(int major ) { int is_reg ; { { is_reg = ldv_undef_int_nonpositive(); } if (is_reg == 0) { { ldv_assert_linux_fs_char_dev__double_registration(ldv_linux_fs_char_dev_usb_gadget_chrdev == 0); ldv_linux_fs_char_dev_usb_gadget_chrdev = 1; } if (major == 0) { { is_reg = ldv_undef_int(); ldv_assume(is_reg > 0); } } else { } } else { } return (is_reg); } } int ldv_linux_fs_char_dev_register_chrdev_region(void) { int is_reg ; { { is_reg = ldv_undef_int_nonpositive(); } if (is_reg == 0) { { ldv_assert_linux_fs_char_dev__double_registration(ldv_linux_fs_char_dev_usb_gadget_chrdev == 0); ldv_linux_fs_char_dev_usb_gadget_chrdev = 1; } } else { } return (is_reg); } } void ldv_linux_fs_char_dev_unregister_chrdev_region(void) { { { ldv_assert_linux_fs_char_dev__double_deregistration(ldv_linux_fs_char_dev_usb_gadget_chrdev == 1); ldv_linux_fs_char_dev_usb_gadget_chrdev = 0; } return; } } void ldv_linux_fs_char_dev_check_final_state(void) { { { ldv_assert_linux_fs_char_dev__registered_at_exit(ldv_linux_fs_char_dev_usb_gadget_chrdev == 0); } return; } } void ldv_assert_linux_fs_sysfs__less_initial_decrement(int expr ) ; void ldv_assert_linux_fs_sysfs__more_initial_at_exit(int expr ) ; int ldv_linux_fs_sysfs_sysfs = 0; int ldv_linux_fs_sysfs_sysfs_create_group(void) { int res ; int tmp ; { { tmp = ldv_undef_int_nonpositive(); res = tmp; } if (res == 0) { ldv_linux_fs_sysfs_sysfs = ldv_linux_fs_sysfs_sysfs + 1; return (0); } else { } return (res); } } void ldv_linux_fs_sysfs_sysfs_remove_group(void) { { { ldv_assert_linux_fs_sysfs__less_initial_decrement(ldv_linux_fs_sysfs_sysfs > 0); ldv_linux_fs_sysfs_sysfs = ldv_linux_fs_sysfs_sysfs - 1; } return; } } void ldv_linux_fs_sysfs_check_final_state(void) { { { ldv_assert_linux_fs_sysfs__more_initial_at_exit(ldv_linux_fs_sysfs_sysfs == 0); } return; } } void ldv_assert_linux_kernel_locking_rwlock__double_write_lock(int expr ) ; void ldv_assert_linux_kernel_locking_rwlock__double_write_unlock(int expr ) ; void ldv_assert_linux_kernel_locking_rwlock__more_read_unlocks(int expr ) ; void ldv_assert_linux_kernel_locking_rwlock__read_lock_at_exit(int expr ) ; void ldv_assert_linux_kernel_locking_rwlock__read_lock_on_write_lock(int expr ) ; void ldv_assert_linux_kernel_locking_rwlock__write_lock_at_exit(int expr ) ; int ldv_linux_kernel_locking_rwlock_rlock = 1; int ldv_linux_kernel_locking_rwlock_wlock = 1; void ldv_linux_kernel_locking_rwlock_read_lock(void) { { { ldv_assert_linux_kernel_locking_rwlock__read_lock_on_write_lock(ldv_linux_kernel_locking_rwlock_wlock == 1); ldv_linux_kernel_locking_rwlock_rlock = ldv_linux_kernel_locking_rwlock_rlock + 1; } return; } } void ldv_linux_kernel_locking_rwlock_read_unlock(void) { { { ldv_assert_linux_kernel_locking_rwlock__more_read_unlocks(ldv_linux_kernel_locking_rwlock_rlock > 1); ldv_linux_kernel_locking_rwlock_rlock = ldv_linux_kernel_locking_rwlock_rlock + -1; } return; } } void ldv_linux_kernel_locking_rwlock_write_lock(void) { { { ldv_assert_linux_kernel_locking_rwlock__double_write_lock(ldv_linux_kernel_locking_rwlock_wlock == 1); ldv_linux_kernel_locking_rwlock_wlock = 2; } return; } } void ldv_linux_kernel_locking_rwlock_write_unlock(void) { { { ldv_assert_linux_kernel_locking_rwlock__double_write_unlock(ldv_linux_kernel_locking_rwlock_wlock != 1); ldv_linux_kernel_locking_rwlock_wlock = 1; } return; } } int ldv_linux_kernel_locking_rwlock_read_trylock(void) { int tmp ; { if (ldv_linux_kernel_locking_rwlock_wlock == 1) { { tmp = ldv_undef_int(); } if (tmp != 0) { ldv_linux_kernel_locking_rwlock_rlock = ldv_linux_kernel_locking_rwlock_rlock + 1; return (1); } else { return (0); } } else { return (0); } } } int ldv_linux_kernel_locking_rwlock_write_trylock(void) { int tmp ; { if (ldv_linux_kernel_locking_rwlock_wlock == 1) { { tmp = ldv_undef_int(); } if (tmp != 0) { ldv_linux_kernel_locking_rwlock_wlock = 2; return (1); } else { return (0); } } else { return (0); } } } void ldv_linux_kernel_locking_rwlock_check_final_state(void) { { { ldv_assert_linux_kernel_locking_rwlock__read_lock_at_exit(ldv_linux_kernel_locking_rwlock_rlock == 1); ldv_assert_linux_kernel_locking_rwlock__write_lock_at_exit(ldv_linux_kernel_locking_rwlock_wlock == 1); } return; } } void ldv_assert_linux_kernel_module__less_initial_decrement(int expr ) ; void ldv_assert_linux_kernel_module__more_initial_at_exit(int expr ) ; int ldv_linux_kernel_module_module_refcounter = 1; void ldv_linux_kernel_module_module_get(struct module *module ) { { if ((unsigned long )module != (unsigned long )((struct module *)0)) { ldv_linux_kernel_module_module_refcounter = ldv_linux_kernel_module_module_refcounter + 1; } else { } return; } } int ldv_linux_kernel_module_try_module_get(struct module *module ) { int tmp ; { if ((unsigned long )module != (unsigned long )((struct module *)0)) { { tmp = ldv_undef_int(); } if (tmp == 1) { ldv_linux_kernel_module_module_refcounter = ldv_linux_kernel_module_module_refcounter + 1; return (1); } else { return (0); } } else { } return (0); } } void ldv_linux_kernel_module_module_put(struct module *module ) { { if ((unsigned long )module != (unsigned long )((struct module *)0)) { { ldv_assert_linux_kernel_module__less_initial_decrement(ldv_linux_kernel_module_module_refcounter > 1); ldv_linux_kernel_module_module_refcounter = ldv_linux_kernel_module_module_refcounter - 1; } } else { } return; } } void ldv_linux_kernel_module_module_put_and_exit(void) { { { ldv_linux_kernel_module_module_put((struct module *)1); } LDV_LINUX_KERNEL_MODULE_STOP: ; goto LDV_LINUX_KERNEL_MODULE_STOP; } } unsigned int ldv_linux_kernel_module_module_refcount(void) { { return ((unsigned int )(ldv_linux_kernel_module_module_refcounter + -1)); } } void ldv_linux_kernel_module_check_final_state(void) { { { ldv_assert_linux_kernel_module__more_initial_at_exit(ldv_linux_kernel_module_module_refcounter == 1); } return; } } void ldv_assert_linux_kernel_rcu_srcu__locked_at_exit(int expr ) ; void ldv_assert_linux_kernel_rcu_srcu__locked_at_read_section(int expr ) ; void ldv_assert_linux_kernel_rcu_srcu__more_unlocks(int expr ) ; int ldv_linux_kernel_rcu_srcu_srcu_nested = 0; void ldv_linux_kernel_rcu_srcu_srcu_read_lock(void) { { ldv_linux_kernel_rcu_srcu_srcu_nested = ldv_linux_kernel_rcu_srcu_srcu_nested + 1; return; } } void ldv_linux_kernel_rcu_srcu_srcu_read_unlock(void) { { { ldv_assert_linux_kernel_rcu_srcu__more_unlocks(ldv_linux_kernel_rcu_srcu_srcu_nested > 0); ldv_linux_kernel_rcu_srcu_srcu_nested = ldv_linux_kernel_rcu_srcu_srcu_nested - 1; } return; } } void ldv_linux_kernel_rcu_srcu_check_for_read_section(void) { { { ldv_assert_linux_kernel_rcu_srcu__locked_at_read_section(ldv_linux_kernel_rcu_srcu_srcu_nested == 0); } return; } } void ldv_linux_kernel_rcu_srcu_check_final_state(void) { { { ldv_assert_linux_kernel_rcu_srcu__locked_at_exit(ldv_linux_kernel_rcu_srcu_srcu_nested == 0); } return; } } void ldv_assert_linux_kernel_rcu_update_lock_bh__locked_at_exit(int expr ) ; void ldv_assert_linux_kernel_rcu_update_lock_bh__locked_at_read_section(int expr ) ; void ldv_assert_linux_kernel_rcu_update_lock_bh__more_unlocks(int expr ) ; int ldv_linux_kernel_rcu_update_lock_bh_rcu_nested_bh = 0; void ldv_linux_kernel_rcu_update_lock_bh_rcu_read_lock_bh(void) { { ldv_linux_kernel_rcu_update_lock_bh_rcu_nested_bh = ldv_linux_kernel_rcu_update_lock_bh_rcu_nested_bh + 1; return; } } void ldv_linux_kernel_rcu_update_lock_bh_rcu_read_unlock_bh(void) { { { ldv_assert_linux_kernel_rcu_update_lock_bh__more_unlocks(ldv_linux_kernel_rcu_update_lock_bh_rcu_nested_bh > 0); ldv_linux_kernel_rcu_update_lock_bh_rcu_nested_bh = ldv_linux_kernel_rcu_update_lock_bh_rcu_nested_bh - 1; } return; } } void ldv_linux_kernel_rcu_update_lock_bh_check_for_read_section(void) { { { ldv_assert_linux_kernel_rcu_update_lock_bh__locked_at_read_section(ldv_linux_kernel_rcu_update_lock_bh_rcu_nested_bh == 0); } return; } } void ldv_linux_kernel_rcu_update_lock_bh_check_final_state(void) { { { ldv_assert_linux_kernel_rcu_update_lock_bh__locked_at_exit(ldv_linux_kernel_rcu_update_lock_bh_rcu_nested_bh == 0); } return; } } void ldv_assert_linux_kernel_rcu_update_lock_sched__locked_at_exit(int expr ) ; void ldv_assert_linux_kernel_rcu_update_lock_sched__locked_at_read_section(int expr ) ; void ldv_assert_linux_kernel_rcu_update_lock_sched__more_unlocks(int expr ) ; int ldv_linux_kernel_rcu_update_lock_sched_rcu_nested_sched = 0; void ldv_linux_kernel_rcu_update_lock_sched_rcu_read_lock_sched(void) { { ldv_linux_kernel_rcu_update_lock_sched_rcu_nested_sched = ldv_linux_kernel_rcu_update_lock_sched_rcu_nested_sched + 1; return; } } void ldv_linux_kernel_rcu_update_lock_sched_rcu_read_unlock_sched(void) { { { ldv_assert_linux_kernel_rcu_update_lock_sched__more_unlocks(ldv_linux_kernel_rcu_update_lock_sched_rcu_nested_sched > 0); ldv_linux_kernel_rcu_update_lock_sched_rcu_nested_sched = ldv_linux_kernel_rcu_update_lock_sched_rcu_nested_sched - 1; } return; } } void ldv_linux_kernel_rcu_update_lock_sched_check_for_read_section(void) { { { ldv_assert_linux_kernel_rcu_update_lock_sched__locked_at_read_section(ldv_linux_kernel_rcu_update_lock_sched_rcu_nested_sched == 0); } return; } } void ldv_linux_kernel_rcu_update_lock_sched_check_final_state(void) { { { ldv_assert_linux_kernel_rcu_update_lock_sched__locked_at_exit(ldv_linux_kernel_rcu_update_lock_sched_rcu_nested_sched == 0); } return; } } void ldv_assert_linux_kernel_rcu_update_lock__locked_at_exit(int expr ) ; void ldv_assert_linux_kernel_rcu_update_lock__locked_at_read_section(int expr ) ; void ldv_assert_linux_kernel_rcu_update_lock__more_unlocks(int expr ) ; int ldv_linux_kernel_rcu_update_lock_rcu_nested = 0; void ldv_linux_kernel_rcu_update_lock_rcu_read_lock(void) { { ldv_linux_kernel_rcu_update_lock_rcu_nested = ldv_linux_kernel_rcu_update_lock_rcu_nested + 1; return; } } void ldv_linux_kernel_rcu_update_lock_rcu_read_unlock(void) { { { ldv_assert_linux_kernel_rcu_update_lock__more_unlocks(ldv_linux_kernel_rcu_update_lock_rcu_nested > 0); ldv_linux_kernel_rcu_update_lock_rcu_nested = ldv_linux_kernel_rcu_update_lock_rcu_nested - 1; } return; } } void ldv_linux_kernel_rcu_update_lock_check_for_read_section(void) { { { ldv_assert_linux_kernel_rcu_update_lock__locked_at_read_section(ldv_linux_kernel_rcu_update_lock_rcu_nested == 0); } return; } } void ldv_linux_kernel_rcu_update_lock_check_final_state(void) { { { ldv_assert_linux_kernel_rcu_update_lock__locked_at_exit(ldv_linux_kernel_rcu_update_lock_rcu_nested == 0); } return; } } static int ldv_filter_positive_int(int val ) { { { ldv_assume(val <= 0); } return (val); } } int ldv_post_init(int init_ret_val ) { int tmp ; { { tmp = ldv_filter_positive_int(init_ret_val); } return (tmp); } } int ldv_post_probe(int probe_ret_val ) { int tmp ; { { tmp = ldv_filter_positive_int(probe_ret_val); } return (tmp); } } int ldv_filter_err_code(int ret_val ) { int tmp ; { { tmp = ldv_filter_positive_int(ret_val); } return (tmp); } } static bool __ldv_in_interrupt_context = 0; void ldv_switch_to_interrupt_context(void) { { __ldv_in_interrupt_context = 1; return; } } void ldv_switch_to_process_context(void) { { __ldv_in_interrupt_context = 0; return; } } bool ldv_in_interrupt_context(void) { { return (__ldv_in_interrupt_context); } } void ldv_assert_linux_lib_find_bit__offset_out_of_range(int expr ) ; extern int nr_cpu_ids ; unsigned long ldv_undef_ulong(void) ; unsigned long ldv_linux_lib_find_bit_find_next_bit(unsigned long size , unsigned long offset ) { unsigned long nondet ; unsigned long tmp ; { { tmp = ldv_undef_ulong(); nondet = tmp; ldv_assert_linux_lib_find_bit__offset_out_of_range(offset <= size); ldv_assume(nondet <= size); ldv_assume(1); } return (nondet); } } unsigned long ldv_linux_lib_find_bit_find_first_bit(unsigned long size ) { unsigned long nondet ; unsigned long tmp ; { { tmp = ldv_undef_ulong(); nondet = tmp; ldv_assume(nondet <= size); ldv_assume(1); } return (nondet); } } void ldv_linux_lib_find_bit_initialize(void) { { { ldv_assume(nr_cpu_ids > 0); } return; } } void *ldv_kzalloc(size_t size , gfp_t flags ) { void *res ; { { ldv_check_alloc_flags(flags); res = ldv_zalloc(size); ldv_after_alloc(res); } return (res); } } void ldv_assert_linux_mmc_sdio_func__double_claim(int expr ) ; void ldv_assert_linux_mmc_sdio_func__release_without_claim(int expr ) ; void ldv_assert_linux_mmc_sdio_func__unreleased_at_exit(int expr ) ; void ldv_assert_linux_mmc_sdio_func__wrong_params(int expr ) ; unsigned short ldv_linux_mmc_sdio_func_sdio_element = 0U; void ldv_linux_mmc_sdio_func_check_context(struct sdio_func *func ) { { { ldv_assert_linux_mmc_sdio_func__wrong_params((int )ldv_linux_mmc_sdio_func_sdio_element == ((func->card)->host)->index); } return; } } void ldv_linux_mmc_sdio_func_sdio_claim_host(struct sdio_func *func ) { { { ldv_assert_linux_mmc_sdio_func__double_claim((unsigned int )ldv_linux_mmc_sdio_func_sdio_element == 0U); ldv_linux_mmc_sdio_func_sdio_element = (unsigned short )((func->card)->host)->index; } return; } } void ldv_linux_mmc_sdio_func_sdio_release_host(struct sdio_func *func ) { { { ldv_assert_linux_mmc_sdio_func__release_without_claim((int )ldv_linux_mmc_sdio_func_sdio_element == ((func->card)->host)->index); ldv_linux_mmc_sdio_func_sdio_element = 0U; } return; } } void ldv_linux_mmc_sdio_func_check_final_state(void) { { { ldv_assert_linux_mmc_sdio_func__unreleased_at_exit((unsigned int )ldv_linux_mmc_sdio_func_sdio_element == 0U); } return; } } void ldv_assert_linux_net_register__wrong_return_value(int expr ) ; int ldv_pre_register_netdev(void) ; int ldv_linux_net_register_probe_state = 0; int ldv_pre_register_netdev(void) { int nondet ; int tmp ; { { tmp = ldv_undef_int(); nondet = tmp; } if (nondet < 0) { ldv_linux_net_register_probe_state = 1; return (nondet); } else { return (0); } } } void ldv_linux_net_register_reset_error_counter(void) { { ldv_linux_net_register_probe_state = 0; return; } } void ldv_linux_net_register_check_return_value_probe(int retval ) { { if (ldv_linux_net_register_probe_state == 1) { { ldv_assert_linux_net_register__wrong_return_value(retval != 0); } } else { } { ldv_linux_net_register_reset_error_counter(); } return; } } void ldv_assert_linux_net_rtnetlink__double_lock(int expr ) ; void ldv_assert_linux_net_rtnetlink__double_unlock(int expr ) ; void ldv_assert_linux_net_rtnetlink__lock_on_exit(int expr ) ; int rtnllocknumber = 0; void ldv_linux_net_rtnetlink_past_rtnl_unlock(void) { { { ldv_assert_linux_net_rtnetlink__double_unlock(rtnllocknumber == 1); rtnllocknumber = 0; } return; } } void ldv_linux_net_rtnetlink_past_rtnl_lock(void) { { { ldv_assert_linux_net_rtnetlink__double_lock(rtnllocknumber == 0); rtnllocknumber = 1; } return; } } void ldv_linux_net_rtnetlink_before_ieee80211_unregister_hw(void) { { { ldv_linux_net_rtnetlink_past_rtnl_lock(); ldv_linux_net_rtnetlink_past_rtnl_unlock(); } return; } } int ldv_linux_net_rtnetlink_rtnl_is_locked(void) { int tmp ; { if (rtnllocknumber != 0) { return (rtnllocknumber); } else { { tmp = ldv_undef_int(); } if (tmp != 0) { return (1); } else { return (0); } } } } int ldv_linux_net_rtnetlink_rtnl_trylock(void) { int tmp ; { { ldv_assert_linux_net_rtnetlink__double_lock(rtnllocknumber == 0); tmp = ldv_linux_net_rtnetlink_rtnl_is_locked(); } if (tmp == 0) { rtnllocknumber = 1; return (1); } else { return (0); } } } void ldv_linux_net_rtnetlink_check_final_state(void) { { { ldv_assert_linux_net_rtnetlink__lock_on_exit(rtnllocknumber == 0); } return; } } void ldv_assert_linux_net_sock__all_locked_sockets_must_be_released(int expr ) ; void ldv_assert_linux_net_sock__double_release(int expr ) ; int locksocknumber = 0; void ldv_linux_net_sock_past_lock_sock_nested(void) { { locksocknumber = locksocknumber + 1; return; } } bool ldv_linux_net_sock_lock_sock_fast(void) { int tmp ; { { tmp = ldv_undef_int(); } if (tmp != 0) { locksocknumber = locksocknumber + 1; return (1); } else { } return (0); } } void ldv_linux_net_sock_unlock_sock_fast(void) { { { ldv_assert_linux_net_sock__double_release(locksocknumber > 0); locksocknumber = locksocknumber - 1; } return; } } void ldv_linux_net_sock_before_release_sock(void) { { { ldv_assert_linux_net_sock__double_release(locksocknumber > 0); locksocknumber = locksocknumber - 1; } return; } } void ldv_linux_net_sock_check_final_state(void) { { { ldv_assert_linux_net_sock__all_locked_sockets_must_be_released(locksocknumber == 0); } return; } } void ldv_assert_linux_usb_coherent__less_initial_decrement(int expr ) ; void ldv_assert_linux_usb_coherent__more_initial_at_exit(int expr ) ; int ldv_linux_usb_coherent_coherent_state = 0; void *ldv_linux_usb_coherent_usb_alloc_coherent(void) { void *arbitrary_memory ; void *tmp ; { { tmp = ldv_undef_ptr(); arbitrary_memory = tmp; } if ((unsigned long )arbitrary_memory == (unsigned long )((void *)0)) { return (arbitrary_memory); } else { } ldv_linux_usb_coherent_coherent_state = ldv_linux_usb_coherent_coherent_state + 1; return (arbitrary_memory); } } void ldv_linux_usb_coherent_usb_free_coherent(void *addr ) { { if ((unsigned long )addr != (unsigned long )((void *)0)) { { ldv_assert_linux_usb_coherent__less_initial_decrement(ldv_linux_usb_coherent_coherent_state > 0); ldv_linux_usb_coherent_coherent_state = ldv_linux_usb_coherent_coherent_state + -1; } } else { } return; } } void ldv_linux_usb_coherent_check_final_state(void) { { { ldv_assert_linux_usb_coherent__more_initial_at_exit(ldv_linux_usb_coherent_coherent_state == 0); } return; } } void ldv_assert_linux_usb_dev__less_initial_decrement(int expr ) ; void ldv_assert_linux_usb_dev__more_initial_at_exit(int expr ) ; void ldv_assert_linux_usb_dev__probe_failed(int expr ) ; void ldv_assert_linux_usb_dev__unincremented_counter_decrement(int expr ) ; ldv_map LDV_LINUX_USB_DEV_USB_DEV_REF_COUNTS ; struct usb_device *ldv_linux_usb_dev_usb_get_dev(struct usb_device *dev ) { { if ((unsigned long )dev != (unsigned long )((struct usb_device *)0)) { LDV_LINUX_USB_DEV_USB_DEV_REF_COUNTS = LDV_LINUX_USB_DEV_USB_DEV_REF_COUNTS != 0 ? LDV_LINUX_USB_DEV_USB_DEV_REF_COUNTS + 1 : 1; } else { } return (dev); } } void ldv_linux_usb_dev_usb_put_dev(struct usb_device *dev ) { { if ((unsigned long )dev != (unsigned long )((struct usb_device *)0)) { { ldv_assert_linux_usb_dev__unincremented_counter_decrement(LDV_LINUX_USB_DEV_USB_DEV_REF_COUNTS != 0); ldv_assert_linux_usb_dev__less_initial_decrement(LDV_LINUX_USB_DEV_USB_DEV_REF_COUNTS > 0); } if (LDV_LINUX_USB_DEV_USB_DEV_REF_COUNTS > 1) { LDV_LINUX_USB_DEV_USB_DEV_REF_COUNTS = LDV_LINUX_USB_DEV_USB_DEV_REF_COUNTS + -1; } else { LDV_LINUX_USB_DEV_USB_DEV_REF_COUNTS = 0; } } else { } return; } } void ldv_linux_usb_dev_check_return_value_probe(int retval ) { { if (retval != 0) { { ldv_assert_linux_usb_dev__probe_failed(LDV_LINUX_USB_DEV_USB_DEV_REF_COUNTS == 0); } } else { } return; } } void ldv_linux_usb_dev_initialize(void) { { LDV_LINUX_USB_DEV_USB_DEV_REF_COUNTS = 0; return; } } void ldv_linux_usb_dev_check_final_state(void) { { { ldv_assert_linux_usb_dev__more_initial_at_exit(LDV_LINUX_USB_DEV_USB_DEV_REF_COUNTS == 0); } return; } } void ldv_assert_linux_usb_gadget__chrdev_deregistration_with_usb_gadget(int expr ) ; void ldv_assert_linux_usb_gadget__chrdev_registration_with_usb_gadget(int expr ) ; void ldv_assert_linux_usb_gadget__class_deregistration_with_usb_gadget(int expr ) ; void ldv_assert_linux_usb_gadget__class_registration_with_usb_gadget(int expr ) ; void ldv_assert_linux_usb_gadget__double_usb_gadget_deregistration(int expr ) ; void ldv_assert_linux_usb_gadget__double_usb_gadget_registration(int expr ) ; void ldv_assert_linux_usb_gadget__usb_gadget_registered_at_exit(int expr ) ; int ldv_linux_usb_gadget_usb_gadget = 0; void *ldv_linux_usb_gadget_create_class(void) { void *is_got ; long tmp ; { { is_got = ldv_undef_ptr(); ldv_assume((int )((long )is_got)); tmp = ldv_is_err((void const *)is_got); } if (tmp == 0L) { { ldv_assert_linux_usb_gadget__class_registration_with_usb_gadget(ldv_linux_usb_gadget_usb_gadget == 0); } } else { } return (is_got); } } int ldv_linux_usb_gadget_register_class(void) { int is_reg ; { { is_reg = ldv_undef_int_nonpositive(); } if (is_reg == 0) { { ldv_assert_linux_usb_gadget__class_registration_with_usb_gadget(ldv_linux_usb_gadget_usb_gadget == 0); } } else { } return (is_reg); } } void ldv_linux_usb_gadget_unregister_class(void) { { { ldv_assert_linux_usb_gadget__class_deregistration_with_usb_gadget(ldv_linux_usb_gadget_usb_gadget == 0); } return; } } void ldv_linux_usb_gadget_destroy_class(struct class *cls ) { long tmp ; { if ((unsigned long )cls == (unsigned long )((struct class *)0)) { return; } else { { tmp = ldv_is_err((void const *)cls); } if (tmp != 0L) { return; } else { } } { ldv_linux_usb_gadget_unregister_class(); } return; } } int ldv_linux_usb_gadget_register_chrdev(int major ) { int is_reg ; { { is_reg = ldv_undef_int_nonpositive(); } if (is_reg == 0) { { ldv_assert_linux_usb_gadget__chrdev_registration_with_usb_gadget(ldv_linux_usb_gadget_usb_gadget == 0); } if (major == 0) { { is_reg = ldv_undef_int(); ldv_assume(is_reg > 0); } } else { } } else { } return (is_reg); } } int ldv_linux_usb_gadget_register_chrdev_region(void) { int is_reg ; { { is_reg = ldv_undef_int_nonpositive(); } if (is_reg == 0) { { ldv_assert_linux_usb_gadget__chrdev_registration_with_usb_gadget(ldv_linux_usb_gadget_usb_gadget == 0); } } else { } return (is_reg); } } void ldv_linux_usb_gadget_unregister_chrdev_region(void) { { { ldv_assert_linux_usb_gadget__chrdev_deregistration_with_usb_gadget(ldv_linux_usb_gadget_usb_gadget == 0); } return; } } int ldv_linux_usb_gadget_register_usb_gadget(void) { int is_reg ; { { is_reg = ldv_undef_int_nonpositive(); } if (is_reg == 0) { { ldv_assert_linux_usb_gadget__double_usb_gadget_registration(ldv_linux_usb_gadget_usb_gadget == 0); ldv_linux_usb_gadget_usb_gadget = 1; } } else { } return (is_reg); } } void ldv_linux_usb_gadget_unregister_usb_gadget(void) { { { ldv_assert_linux_usb_gadget__double_usb_gadget_deregistration(ldv_linux_usb_gadget_usb_gadget == 1); ldv_linux_usb_gadget_usb_gadget = 0; } return; } } void ldv_linux_usb_gadget_check_final_state(void) { { { ldv_assert_linux_usb_gadget__usb_gadget_registered_at_exit(ldv_linux_usb_gadget_usb_gadget == 0); } return; } } void ldv_assert_linux_usb_register__wrong_return_value(int expr ) ; int ldv_pre_usb_register_driver(void) ; int ldv_linux_usb_register_probe_state = 0; int ldv_pre_usb_register_driver(void) { int nondet ; int tmp ; { { tmp = ldv_undef_int(); nondet = tmp; } if (nondet < 0) { ldv_linux_usb_register_probe_state = 1; return (nondet); } else { return (0); } } } void ldv_linux_usb_register_reset_error_counter(void) { { ldv_linux_usb_register_probe_state = 0; return; } } void ldv_linux_usb_register_check_return_value_probe(int retval ) { { if (ldv_linux_usb_register_probe_state == 1) { { ldv_assert_linux_usb_register__wrong_return_value(retval != 0); } } else { } { ldv_linux_usb_register_reset_error_counter(); } return; } } void ldv_assert_linux_usb_urb__less_initial_decrement(int expr ) ; void ldv_assert_linux_usb_urb__more_initial_at_exit(int expr ) ; int ldv_linux_usb_urb_urb_state = 0; struct urb *ldv_linux_usb_urb_usb_alloc_urb(void) { void *arbitrary_memory ; void *tmp ; { { tmp = ldv_undef_ptr(); arbitrary_memory = tmp; } if ((unsigned long )arbitrary_memory == (unsigned long )((void *)0)) { return ((struct urb *)arbitrary_memory); } else { } ldv_linux_usb_urb_urb_state = ldv_linux_usb_urb_urb_state + 1; return ((struct urb *)arbitrary_memory); } } void ldv_linux_usb_urb_usb_free_urb(struct urb *urb ) { { if ((unsigned long )urb != (unsigned long )((struct urb *)0)) { { ldv_assert_linux_usb_urb__less_initial_decrement(ldv_linux_usb_urb_urb_state > 0); ldv_linux_usb_urb_urb_state = ldv_linux_usb_urb_urb_state + -1; } } else { } return; } } void ldv_linux_usb_urb_check_final_state(void) { { { ldv_assert_linux_usb_urb__more_initial_at_exit(ldv_linux_usb_urb_urb_state == 0); } return; } } extern void ldv_assert(char const * , int ) ; void ldv__builtin_trap(void) ; void ldv_assume(int expression ) { { if (expression == 0) { ldv_assume_label: ; goto ldv_assume_label; } else { } return; } } void ldv_stop(void) { { ldv_stop_label: ; goto ldv_stop_label; } } long ldv__builtin_expect(long exp , long c ) { { return (exp); } } void ldv__builtin_trap(void) { { { ldv_assert("", 0); } return; } } void *ldv_malloc(size_t size ) ; void *ldv_calloc(size_t nmemb , size_t size ) ; extern void *external_allocated_data(void) ; void *ldv_calloc_unknown_size(void) ; void *ldv_zalloc_unknown_size(void) ; void *ldv_xmalloc_unknown_size(size_t size ) ; extern void *malloc(size_t ) ; extern void *calloc(size_t , size_t ) ; extern void free(void * ) ; extern void *memset(void * , int , size_t ) ; void *ldv_malloc(size_t size ) { void *res ; void *tmp ; long tmp___0 ; int tmp___1 ; { { tmp___1 = ldv_undef_int(); } if (tmp___1 != 0) { { tmp = malloc(size); res = tmp; ldv_assume((unsigned long )res != (unsigned long )((void *)0)); tmp___0 = ldv_is_err((void const *)res); ldv_assume(tmp___0 == 0L); } return (res); } else { return ((void *)0); } } } void *ldv_calloc(size_t nmemb , size_t size ) { void *res ; void *tmp ; long tmp___0 ; int tmp___1 ; { { tmp___1 = ldv_undef_int(); } if (tmp___1 != 0) { { tmp = calloc(nmemb, size); res = tmp; ldv_assume((unsigned long )res != (unsigned long )((void *)0)); tmp___0 = ldv_is_err((void const *)res); ldv_assume(tmp___0 == 0L); } return (res); } else { return ((void *)0); } } } void *ldv_zalloc(size_t size ) { void *tmp ; { { tmp = ldv_calloc(1UL, size); } return (tmp); } } void ldv_free(void *s ) { { { free(s); } return; } } void *ldv_xmalloc(size_t size ) { void *res ; void *tmp ; long tmp___0 ; { { tmp = malloc(size); res = tmp; ldv_assume((unsigned long )res != (unsigned long )((void *)0)); tmp___0 = ldv_is_err((void const *)res); ldv_assume(tmp___0 == 0L); } return (res); } } void *ldv_xzalloc(size_t size ) { void *res ; void *tmp ; long tmp___0 ; { { tmp = calloc(1UL, size); res = tmp; ldv_assume((unsigned long )res != (unsigned long )((void *)0)); tmp___0 = ldv_is_err((void const *)res); ldv_assume(tmp___0 == 0L); } return (res); } } void *ldv_malloc_unknown_size(void) { void *res ; void *tmp ; long tmp___0 ; int tmp___1 ; { { tmp___1 = ldv_undef_int(); } if (tmp___1 != 0) { { tmp = external_allocated_data(); res = tmp; ldv_assume((unsigned long )res != (unsigned long )((void *)0)); tmp___0 = ldv_is_err((void const *)res); ldv_assume(tmp___0 == 0L); } return (res); } else { return ((void *)0); } } } void *ldv_calloc_unknown_size(void) { void *res ; void *tmp ; long tmp___0 ; int tmp___1 ; { { tmp___1 = ldv_undef_int(); } if (tmp___1 != 0) { { tmp = external_allocated_data(); res = tmp; memset(res, 0, 8UL); ldv_assume((unsigned long )res != (unsigned long )((void *)0)); tmp___0 = ldv_is_err((void const *)res); ldv_assume(tmp___0 == 0L); } return (res); } else { return ((void *)0); } } } void *ldv_zalloc_unknown_size(void) { void *tmp ; { { tmp = ldv_calloc_unknown_size(); } return (tmp); } } void *ldv_xmalloc_unknown_size(size_t size ) { void *res ; void *tmp ; long tmp___0 ; { { tmp = external_allocated_data(); res = tmp; ldv_assume((unsigned long )res != (unsigned long )((void *)0)); tmp___0 = ldv_is_err((void const *)res); ldv_assume(tmp___0 == 0L); } return (res); } } int ldv_undef_int_negative(void) ; extern int __VERIFIER_nondet_int(void) ; extern unsigned long __VERIFIER_nondet_ulong(void) ; extern void *__VERIFIER_nondet_pointer(void) ; int ldv_undef_int(void) { int tmp ; { { tmp = __VERIFIER_nondet_int(); } return (tmp); } } void *ldv_undef_ptr(void) { void *tmp ; { { tmp = __VERIFIER_nondet_pointer(); } return (tmp); } } unsigned long ldv_undef_ulong(void) { unsigned long tmp ; { { tmp = __VERIFIER_nondet_ulong(); } return (tmp); } } int ldv_undef_int_negative(void) { int ret ; int tmp ; { { tmp = ldv_undef_int(); ret = tmp; ldv_assume(ret < 0); } return (ret); } } int ldv_undef_int_nonpositive(void) { int ret ; int tmp ; { { tmp = ldv_undef_int(); ret = tmp; ldv_assume(ret <= 0); } return (ret); } } int ldv_thread_create(struct ldv_thread *ldv_thread , void (*function)(void * ) , void *data ) ; int ldv_thread_create_N(struct ldv_thread_set *ldv_thread_set , void (*function)(void * ) , void *data ) ; int ldv_thread_join(struct ldv_thread *ldv_thread , void (*function)(void * ) ) ; int ldv_thread_join_N(struct ldv_thread_set *ldv_thread_set , void (*function)(void * ) ) ; int ldv_thread_create(struct ldv_thread *ldv_thread , void (*function)(void * ) , void *data ) { { if ((unsigned long )function != (unsigned long )((void (*)(void * ))0)) { { (*function)(data); } } else { } return (0); } } int ldv_thread_create_N(struct ldv_thread_set *ldv_thread_set , void (*function)(void * ) , void *data ) { int i ; { if ((unsigned long )function != (unsigned long )((void (*)(void * ))0)) { i = 0; goto ldv_1179; ldv_1178: { (*function)(data); i = i + 1; } ldv_1179: ; if (i < ldv_thread_set->number) { goto ldv_1178; } else { } } else { } return (0); } } int ldv_thread_join(struct ldv_thread *ldv_thread , void (*function)(void * ) ) { { return (0); } } int ldv_thread_join_N(struct ldv_thread_set *ldv_thread_set , void (*function)(void * ) ) { { return (0); } } void ldv_assert_linux_kernel_locking_mutex__one_thread_double_lock(int expr ) ; void ldv_assert_linux_kernel_locking_mutex__one_thread_double_lock_try(int expr ) ; void ldv_assert_linux_kernel_locking_mutex__one_thread_double_unlock(int expr ) ; void ldv_assert_linux_kernel_locking_mutex__one_thread_locked_at_exit(int expr ) ; ldv_set LDV_LINUX_KERNEL_LOCKING_MUTEX_MUTEXES_i_mutex_of_inode ; void ldv_linux_kernel_locking_mutex_mutex_lock_i_mutex_of_inode(struct mutex *lock ) { { { ldv_assert_linux_kernel_locking_mutex__one_thread_double_lock(! LDV_LINUX_KERNEL_LOCKING_MUTEX_MUTEXES_i_mutex_of_inode); LDV_LINUX_KERNEL_LOCKING_MUTEX_MUTEXES_i_mutex_of_inode = 1; } return; } } int ldv_linux_kernel_locking_mutex_mutex_lock_interruptible_or_killable_i_mutex_of_inode(struct mutex *lock ) { int tmp ; { { ldv_assert_linux_kernel_locking_mutex__one_thread_double_lock(! LDV_LINUX_KERNEL_LOCKING_MUTEX_MUTEXES_i_mutex_of_inode); tmp = ldv_undef_int(); } if (tmp != 0) { LDV_LINUX_KERNEL_LOCKING_MUTEX_MUTEXES_i_mutex_of_inode = 1; return (0); } else { return (-4); } } } int ldv_linux_kernel_locking_mutex_mutex_is_locked_i_mutex_of_inode(struct mutex *lock ) { int tmp ; { if ((int )LDV_LINUX_KERNEL_LOCKING_MUTEX_MUTEXES_i_mutex_of_inode) { return (1); } else { { tmp = ldv_undef_int(); } if (tmp != 0) { return (1); } else { return (0); } } } } int ldv_linux_kernel_locking_mutex_mutex_trylock_i_mutex_of_inode(struct mutex *lock ) { int tmp ; { { ldv_assert_linux_kernel_locking_mutex__one_thread_double_lock_try(! LDV_LINUX_KERNEL_LOCKING_MUTEX_MUTEXES_i_mutex_of_inode); tmp = ldv_linux_kernel_locking_mutex_mutex_is_locked_i_mutex_of_inode(lock); } if (tmp != 0) { return (0); } else { LDV_LINUX_KERNEL_LOCKING_MUTEX_MUTEXES_i_mutex_of_inode = 1; return (1); } } } int ldv_linux_kernel_locking_mutex_atomic_dec_and_mutex_lock_i_mutex_of_inode(atomic_t *cnt , struct mutex *lock ) { { cnt->counter = cnt->counter - 1; if (cnt->counter != 0) { return (0); } else { { ldv_linux_kernel_locking_mutex_mutex_lock_i_mutex_of_inode(lock); } return (1); } } } void ldv_linux_kernel_locking_mutex_mutex_unlock_i_mutex_of_inode(struct mutex *lock ) { { { ldv_assert_linux_kernel_locking_mutex__one_thread_double_unlock((int )LDV_LINUX_KERNEL_LOCKING_MUTEX_MUTEXES_i_mutex_of_inode); LDV_LINUX_KERNEL_LOCKING_MUTEX_MUTEXES_i_mutex_of_inode = 0; } return; } } ldv_set LDV_LINUX_KERNEL_LOCKING_MUTEX_MUTEXES_lock ; void ldv_linux_kernel_locking_mutex_mutex_lock_lock(struct mutex *lock ) { { { ldv_assert_linux_kernel_locking_mutex__one_thread_double_lock(! LDV_LINUX_KERNEL_LOCKING_MUTEX_MUTEXES_lock); LDV_LINUX_KERNEL_LOCKING_MUTEX_MUTEXES_lock = 1; } return; } } int ldv_linux_kernel_locking_mutex_mutex_lock_interruptible_or_killable_lock(struct mutex *lock ) { int tmp ; { { ldv_assert_linux_kernel_locking_mutex__one_thread_double_lock(! LDV_LINUX_KERNEL_LOCKING_MUTEX_MUTEXES_lock); tmp = ldv_undef_int(); } if (tmp != 0) { LDV_LINUX_KERNEL_LOCKING_MUTEX_MUTEXES_lock = 1; return (0); } else { return (-4); } } } int ldv_linux_kernel_locking_mutex_mutex_is_locked_lock(struct mutex *lock ) { int tmp ; { if ((int )LDV_LINUX_KERNEL_LOCKING_MUTEX_MUTEXES_lock) { return (1); } else { { tmp = ldv_undef_int(); } if (tmp != 0) { return (1); } else { return (0); } } } } int ldv_linux_kernel_locking_mutex_mutex_trylock_lock(struct mutex *lock ) { int tmp ; { { ldv_assert_linux_kernel_locking_mutex__one_thread_double_lock_try(! LDV_LINUX_KERNEL_LOCKING_MUTEX_MUTEXES_lock); tmp = ldv_linux_kernel_locking_mutex_mutex_is_locked_lock(lock); } if (tmp != 0) { return (0); } else { LDV_LINUX_KERNEL_LOCKING_MUTEX_MUTEXES_lock = 1; return (1); } } } int ldv_linux_kernel_locking_mutex_atomic_dec_and_mutex_lock_lock(atomic_t *cnt , struct mutex *lock ) { { cnt->counter = cnt->counter - 1; if (cnt->counter != 0) { return (0); } else { { ldv_linux_kernel_locking_mutex_mutex_lock_lock(lock); } return (1); } } } void ldv_linux_kernel_locking_mutex_mutex_unlock_lock(struct mutex *lock ) { { { ldv_assert_linux_kernel_locking_mutex__one_thread_double_unlock((int )LDV_LINUX_KERNEL_LOCKING_MUTEX_MUTEXES_lock); LDV_LINUX_KERNEL_LOCKING_MUTEX_MUTEXES_lock = 0; } return; } } ldv_set LDV_LINUX_KERNEL_LOCKING_MUTEX_MUTEXES_mutex_of_device ; void ldv_linux_kernel_locking_mutex_mutex_lock_mutex_of_device(struct mutex *lock ) { { { ldv_assert_linux_kernel_locking_mutex__one_thread_double_lock(! LDV_LINUX_KERNEL_LOCKING_MUTEX_MUTEXES_mutex_of_device); LDV_LINUX_KERNEL_LOCKING_MUTEX_MUTEXES_mutex_of_device = 1; } return; } } int ldv_linux_kernel_locking_mutex_mutex_lock_interruptible_or_killable_mutex_of_device(struct mutex *lock ) { int tmp ; { { ldv_assert_linux_kernel_locking_mutex__one_thread_double_lock(! LDV_LINUX_KERNEL_LOCKING_MUTEX_MUTEXES_mutex_of_device); tmp = ldv_undef_int(); } if (tmp != 0) { LDV_LINUX_KERNEL_LOCKING_MUTEX_MUTEXES_mutex_of_device = 1; return (0); } else { return (-4); } } } int ldv_linux_kernel_locking_mutex_mutex_is_locked_mutex_of_device(struct mutex *lock ) { int tmp ; { if ((int )LDV_LINUX_KERNEL_LOCKING_MUTEX_MUTEXES_mutex_of_device) { return (1); } else { { tmp = ldv_undef_int(); } if (tmp != 0) { return (1); } else { return (0); } } } } int ldv_linux_kernel_locking_mutex_mutex_trylock_mutex_of_device(struct mutex *lock ) { int tmp ; { { ldv_assert_linux_kernel_locking_mutex__one_thread_double_lock_try(! LDV_LINUX_KERNEL_LOCKING_MUTEX_MUTEXES_mutex_of_device); tmp = ldv_linux_kernel_locking_mutex_mutex_is_locked_mutex_of_device(lock); } if (tmp != 0) { return (0); } else { LDV_LINUX_KERNEL_LOCKING_MUTEX_MUTEXES_mutex_of_device = 1; return (1); } } } int ldv_linux_kernel_locking_mutex_atomic_dec_and_mutex_lock_mutex_of_device(atomic_t *cnt , struct mutex *lock ) { { cnt->counter = cnt->counter - 1; if (cnt->counter != 0) { return (0); } else { { ldv_linux_kernel_locking_mutex_mutex_lock_mutex_of_device(lock); } return (1); } } } void ldv_linux_kernel_locking_mutex_mutex_unlock_mutex_of_device(struct mutex *lock ) { { { ldv_assert_linux_kernel_locking_mutex__one_thread_double_unlock((int )LDV_LINUX_KERNEL_LOCKING_MUTEX_MUTEXES_mutex_of_device); LDV_LINUX_KERNEL_LOCKING_MUTEX_MUTEXES_mutex_of_device = 0; } return; } } void ldv_linux_kernel_locking_mutex_initialize(void) { { LDV_LINUX_KERNEL_LOCKING_MUTEX_MUTEXES_i_mutex_of_inode = 0; LDV_LINUX_KERNEL_LOCKING_MUTEX_MUTEXES_lock = 0; LDV_LINUX_KERNEL_LOCKING_MUTEX_MUTEXES_mutex_of_device = 0; return; } } void ldv_linux_kernel_locking_mutex_check_final_state(void) { { { ldv_assert_linux_kernel_locking_mutex__one_thread_locked_at_exit(! LDV_LINUX_KERNEL_LOCKING_MUTEX_MUTEXES_i_mutex_of_inode); ldv_assert_linux_kernel_locking_mutex__one_thread_locked_at_exit(! LDV_LINUX_KERNEL_LOCKING_MUTEX_MUTEXES_lock); ldv_assert_linux_kernel_locking_mutex__one_thread_locked_at_exit(! LDV_LINUX_KERNEL_LOCKING_MUTEX_MUTEXES_mutex_of_device); } return; } } void ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock(int expr ) ; void ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock_try(int expr ) ; void ldv_assert_linux_kernel_locking_spinlock__one_thread_double_unlock(int expr ) ; void ldv_assert_linux_kernel_locking_spinlock__one_thread_locked_at_exit(int expr ) ; static int ldv_linux_kernel_locking_spinlock_spin_alloc_lock_of_task_struct = 1; void ldv_linux_kernel_locking_spinlock_spin_lock_alloc_lock_of_task_struct(void) { { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock(ldv_linux_kernel_locking_spinlock_spin_alloc_lock_of_task_struct == 1); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_alloc_lock_of_task_struct == 1); ldv_linux_kernel_locking_spinlock_spin_alloc_lock_of_task_struct = 2; } return; } } void ldv_linux_kernel_locking_spinlock_spin_unlock_alloc_lock_of_task_struct(void) { { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_unlock(ldv_linux_kernel_locking_spinlock_spin_alloc_lock_of_task_struct == 2); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_alloc_lock_of_task_struct == 2); ldv_linux_kernel_locking_spinlock_spin_alloc_lock_of_task_struct = 1; } return; } } int ldv_linux_kernel_locking_spinlock_spin_trylock_alloc_lock_of_task_struct(void) { int is_spin_held_by_another_thread ; { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock_try(ldv_linux_kernel_locking_spinlock_spin_alloc_lock_of_task_struct == 1); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_alloc_lock_of_task_struct == 1); is_spin_held_by_another_thread = ldv_undef_int(); } if (is_spin_held_by_another_thread != 0) { return (0); } else { ldv_linux_kernel_locking_spinlock_spin_alloc_lock_of_task_struct = 2; return (1); } } } void ldv_linux_kernel_locking_spinlock_spin_unlock_wait_alloc_lock_of_task_struct(void) { { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock_try(ldv_linux_kernel_locking_spinlock_spin_alloc_lock_of_task_struct == 1); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_alloc_lock_of_task_struct == 1); } return; } } int ldv_linux_kernel_locking_spinlock_spin_is_locked_alloc_lock_of_task_struct(void) { int is_spin_held_by_another_thread ; { { is_spin_held_by_another_thread = ldv_undef_int(); } if (ldv_linux_kernel_locking_spinlock_spin_alloc_lock_of_task_struct == 1 && is_spin_held_by_another_thread == 0) { return (0); } else { return (1); } } } int ldv_linux_kernel_locking_spinlock_spin_can_lock_alloc_lock_of_task_struct(void) { int tmp ; { { tmp = ldv_linux_kernel_locking_spinlock_spin_is_locked_alloc_lock_of_task_struct(); } return (tmp == 0); } } int ldv_linux_kernel_locking_spinlock_spin_is_contended_alloc_lock_of_task_struct(void) { int is_spin_contended ; { { is_spin_contended = ldv_undef_int(); } if (is_spin_contended != 0) { return (0); } else { return (1); } } } int ldv_linux_kernel_locking_spinlock_atomic_dec_and_lock_alloc_lock_of_task_struct(void) { int atomic_value_after_dec ; { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock_try(ldv_linux_kernel_locking_spinlock_spin_alloc_lock_of_task_struct == 1); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_alloc_lock_of_task_struct == 1); atomic_value_after_dec = ldv_undef_int(); } if (atomic_value_after_dec == 0) { ldv_linux_kernel_locking_spinlock_spin_alloc_lock_of_task_struct = 2; return (1); } else { } return (0); } } static int ldv_linux_kernel_locking_spinlock_spin_bitmap_lock_of_pm8001_hba_info = 1; void ldv_linux_kernel_locking_spinlock_spin_lock_bitmap_lock_of_pm8001_hba_info(void) { { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock(ldv_linux_kernel_locking_spinlock_spin_bitmap_lock_of_pm8001_hba_info == 1); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_bitmap_lock_of_pm8001_hba_info == 1); ldv_linux_kernel_locking_spinlock_spin_bitmap_lock_of_pm8001_hba_info = 2; } return; } } void ldv_linux_kernel_locking_spinlock_spin_unlock_bitmap_lock_of_pm8001_hba_info(void) { { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_unlock(ldv_linux_kernel_locking_spinlock_spin_bitmap_lock_of_pm8001_hba_info == 2); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_bitmap_lock_of_pm8001_hba_info == 2); ldv_linux_kernel_locking_spinlock_spin_bitmap_lock_of_pm8001_hba_info = 1; } return; } } int ldv_linux_kernel_locking_spinlock_spin_trylock_bitmap_lock_of_pm8001_hba_info(void) { int is_spin_held_by_another_thread ; { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock_try(ldv_linux_kernel_locking_spinlock_spin_bitmap_lock_of_pm8001_hba_info == 1); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_bitmap_lock_of_pm8001_hba_info == 1); is_spin_held_by_another_thread = ldv_undef_int(); } if (is_spin_held_by_another_thread != 0) { return (0); } else { ldv_linux_kernel_locking_spinlock_spin_bitmap_lock_of_pm8001_hba_info = 2; return (1); } } } void ldv_linux_kernel_locking_spinlock_spin_unlock_wait_bitmap_lock_of_pm8001_hba_info(void) { { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock_try(ldv_linux_kernel_locking_spinlock_spin_bitmap_lock_of_pm8001_hba_info == 1); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_bitmap_lock_of_pm8001_hba_info == 1); } return; } } int ldv_linux_kernel_locking_spinlock_spin_is_locked_bitmap_lock_of_pm8001_hba_info(void) { int is_spin_held_by_another_thread ; { { is_spin_held_by_another_thread = ldv_undef_int(); } if (ldv_linux_kernel_locking_spinlock_spin_bitmap_lock_of_pm8001_hba_info == 1 && is_spin_held_by_another_thread == 0) { return (0); } else { return (1); } } } int ldv_linux_kernel_locking_spinlock_spin_can_lock_bitmap_lock_of_pm8001_hba_info(void) { int tmp ; { { tmp = ldv_linux_kernel_locking_spinlock_spin_is_locked_bitmap_lock_of_pm8001_hba_info(); } return (tmp == 0); } } int ldv_linux_kernel_locking_spinlock_spin_is_contended_bitmap_lock_of_pm8001_hba_info(void) { int is_spin_contended ; { { is_spin_contended = ldv_undef_int(); } if (is_spin_contended != 0) { return (0); } else { return (1); } } } int ldv_linux_kernel_locking_spinlock_atomic_dec_and_lock_bitmap_lock_of_pm8001_hba_info(void) { int atomic_value_after_dec ; { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock_try(ldv_linux_kernel_locking_spinlock_spin_bitmap_lock_of_pm8001_hba_info == 1); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_bitmap_lock_of_pm8001_hba_info == 1); atomic_value_after_dec = ldv_undef_int(); } if (atomic_value_after_dec == 0) { ldv_linux_kernel_locking_spinlock_spin_bitmap_lock_of_pm8001_hba_info = 2; return (1); } else { } return (0); } } static int ldv_linux_kernel_locking_spinlock_spin_frame_rcvd_lock_of_asd_sas_phy = 1; void ldv_linux_kernel_locking_spinlock_spin_lock_frame_rcvd_lock_of_asd_sas_phy(void) { { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock(ldv_linux_kernel_locking_spinlock_spin_frame_rcvd_lock_of_asd_sas_phy == 1); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_frame_rcvd_lock_of_asd_sas_phy == 1); ldv_linux_kernel_locking_spinlock_spin_frame_rcvd_lock_of_asd_sas_phy = 2; } return; } } void ldv_linux_kernel_locking_spinlock_spin_unlock_frame_rcvd_lock_of_asd_sas_phy(void) { { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_unlock(ldv_linux_kernel_locking_spinlock_spin_frame_rcvd_lock_of_asd_sas_phy == 2); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_frame_rcvd_lock_of_asd_sas_phy == 2); ldv_linux_kernel_locking_spinlock_spin_frame_rcvd_lock_of_asd_sas_phy = 1; } return; } } int ldv_linux_kernel_locking_spinlock_spin_trylock_frame_rcvd_lock_of_asd_sas_phy(void) { int is_spin_held_by_another_thread ; { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock_try(ldv_linux_kernel_locking_spinlock_spin_frame_rcvd_lock_of_asd_sas_phy == 1); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_frame_rcvd_lock_of_asd_sas_phy == 1); is_spin_held_by_another_thread = ldv_undef_int(); } if (is_spin_held_by_another_thread != 0) { return (0); } else { ldv_linux_kernel_locking_spinlock_spin_frame_rcvd_lock_of_asd_sas_phy = 2; return (1); } } } void ldv_linux_kernel_locking_spinlock_spin_unlock_wait_frame_rcvd_lock_of_asd_sas_phy(void) { { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock_try(ldv_linux_kernel_locking_spinlock_spin_frame_rcvd_lock_of_asd_sas_phy == 1); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_frame_rcvd_lock_of_asd_sas_phy == 1); } return; } } int ldv_linux_kernel_locking_spinlock_spin_is_locked_frame_rcvd_lock_of_asd_sas_phy(void) { int is_spin_held_by_another_thread ; { { is_spin_held_by_another_thread = ldv_undef_int(); } if (ldv_linux_kernel_locking_spinlock_spin_frame_rcvd_lock_of_asd_sas_phy == 1 && is_spin_held_by_another_thread == 0) { return (0); } else { return (1); } } } int ldv_linux_kernel_locking_spinlock_spin_can_lock_frame_rcvd_lock_of_asd_sas_phy(void) { int tmp ; { { tmp = ldv_linux_kernel_locking_spinlock_spin_is_locked_frame_rcvd_lock_of_asd_sas_phy(); } return (tmp == 0); } } int ldv_linux_kernel_locking_spinlock_spin_is_contended_frame_rcvd_lock_of_asd_sas_phy(void) { int is_spin_contended ; { { is_spin_contended = ldv_undef_int(); } if (is_spin_contended != 0) { return (0); } else { return (1); } } } int ldv_linux_kernel_locking_spinlock_atomic_dec_and_lock_frame_rcvd_lock_of_asd_sas_phy(void) { int atomic_value_after_dec ; { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock_try(ldv_linux_kernel_locking_spinlock_spin_frame_rcvd_lock_of_asd_sas_phy == 1); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_frame_rcvd_lock_of_asd_sas_phy == 1); atomic_value_after_dec = ldv_undef_int(); } if (atomic_value_after_dec == 0) { ldv_linux_kernel_locking_spinlock_spin_frame_rcvd_lock_of_asd_sas_phy = 2; return (1); } else { } return (0); } } static int ldv_linux_kernel_locking_spinlock_spin_i_lock_of_inode = 1; void ldv_linux_kernel_locking_spinlock_spin_lock_i_lock_of_inode(void) { { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock(ldv_linux_kernel_locking_spinlock_spin_i_lock_of_inode == 1); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_i_lock_of_inode == 1); ldv_linux_kernel_locking_spinlock_spin_i_lock_of_inode = 2; } return; } } void ldv_linux_kernel_locking_spinlock_spin_unlock_i_lock_of_inode(void) { { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_unlock(ldv_linux_kernel_locking_spinlock_spin_i_lock_of_inode == 2); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_i_lock_of_inode == 2); ldv_linux_kernel_locking_spinlock_spin_i_lock_of_inode = 1; } return; } } int ldv_linux_kernel_locking_spinlock_spin_trylock_i_lock_of_inode(void) { int is_spin_held_by_another_thread ; { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock_try(ldv_linux_kernel_locking_spinlock_spin_i_lock_of_inode == 1); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_i_lock_of_inode == 1); is_spin_held_by_another_thread = ldv_undef_int(); } if (is_spin_held_by_another_thread != 0) { return (0); } else { ldv_linux_kernel_locking_spinlock_spin_i_lock_of_inode = 2; return (1); } } } void ldv_linux_kernel_locking_spinlock_spin_unlock_wait_i_lock_of_inode(void) { { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock_try(ldv_linux_kernel_locking_spinlock_spin_i_lock_of_inode == 1); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_i_lock_of_inode == 1); } return; } } int ldv_linux_kernel_locking_spinlock_spin_is_locked_i_lock_of_inode(void) { int is_spin_held_by_another_thread ; { { is_spin_held_by_another_thread = ldv_undef_int(); } if (ldv_linux_kernel_locking_spinlock_spin_i_lock_of_inode == 1 && is_spin_held_by_another_thread == 0) { return (0); } else { return (1); } } } int ldv_linux_kernel_locking_spinlock_spin_can_lock_i_lock_of_inode(void) { int tmp ; { { tmp = ldv_linux_kernel_locking_spinlock_spin_is_locked_i_lock_of_inode(); } return (tmp == 0); } } int ldv_linux_kernel_locking_spinlock_spin_is_contended_i_lock_of_inode(void) { int is_spin_contended ; { { is_spin_contended = ldv_undef_int(); } if (is_spin_contended != 0) { return (0); } else { return (1); } } } int ldv_linux_kernel_locking_spinlock_atomic_dec_and_lock_i_lock_of_inode(void) { int atomic_value_after_dec ; { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock_try(ldv_linux_kernel_locking_spinlock_spin_i_lock_of_inode == 1); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_i_lock_of_inode == 1); atomic_value_after_dec = ldv_undef_int(); } if (atomic_value_after_dec == 0) { ldv_linux_kernel_locking_spinlock_spin_i_lock_of_inode = 2; return (1); } else { } return (0); } } static int ldv_linux_kernel_locking_spinlock_spin_lock = 1; void ldv_linux_kernel_locking_spinlock_spin_lock_lock(void) { { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock(ldv_linux_kernel_locking_spinlock_spin_lock == 1); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_lock == 1); ldv_linux_kernel_locking_spinlock_spin_lock = 2; } return; } } void ldv_linux_kernel_locking_spinlock_spin_unlock_lock(void) { { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_unlock(ldv_linux_kernel_locking_spinlock_spin_lock == 2); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_lock == 2); ldv_linux_kernel_locking_spinlock_spin_lock = 1; } return; } } int ldv_linux_kernel_locking_spinlock_spin_trylock_lock(void) { int is_spin_held_by_another_thread ; { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock_try(ldv_linux_kernel_locking_spinlock_spin_lock == 1); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_lock == 1); is_spin_held_by_another_thread = ldv_undef_int(); } if (is_spin_held_by_another_thread != 0) { return (0); } else { ldv_linux_kernel_locking_spinlock_spin_lock = 2; return (1); } } } void ldv_linux_kernel_locking_spinlock_spin_unlock_wait_lock(void) { { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock_try(ldv_linux_kernel_locking_spinlock_spin_lock == 1); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_lock == 1); } return; } } int ldv_linux_kernel_locking_spinlock_spin_is_locked_lock(void) { int is_spin_held_by_another_thread ; { { is_spin_held_by_another_thread = ldv_undef_int(); } if (ldv_linux_kernel_locking_spinlock_spin_lock == 1 && is_spin_held_by_another_thread == 0) { return (0); } else { return (1); } } } int ldv_linux_kernel_locking_spinlock_spin_can_lock_lock(void) { int tmp ; { { tmp = ldv_linux_kernel_locking_spinlock_spin_is_locked_lock(); } return (tmp == 0); } } int ldv_linux_kernel_locking_spinlock_spin_is_contended_lock(void) { int is_spin_contended ; { { is_spin_contended = ldv_undef_int(); } if (is_spin_contended != 0) { return (0); } else { return (1); } } } int ldv_linux_kernel_locking_spinlock_atomic_dec_and_lock_lock(void) { int atomic_value_after_dec ; { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock_try(ldv_linux_kernel_locking_spinlock_spin_lock == 1); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_lock == 1); atomic_value_after_dec = ldv_undef_int(); } if (atomic_value_after_dec == 0) { ldv_linux_kernel_locking_spinlock_spin_lock = 2; return (1); } else { } return (0); } } static int ldv_linux_kernel_locking_spinlock_spin_lock_of_NOT_ARG_SIGN = 1; void ldv_linux_kernel_locking_spinlock_spin_lock_lock_of_NOT_ARG_SIGN(void) { { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock(ldv_linux_kernel_locking_spinlock_spin_lock_of_NOT_ARG_SIGN == 1); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_lock_of_NOT_ARG_SIGN == 1); ldv_linux_kernel_locking_spinlock_spin_lock_of_NOT_ARG_SIGN = 2; } return; } } void ldv_linux_kernel_locking_spinlock_spin_unlock_lock_of_NOT_ARG_SIGN(void) { { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_unlock(ldv_linux_kernel_locking_spinlock_spin_lock_of_NOT_ARG_SIGN == 2); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_lock_of_NOT_ARG_SIGN == 2); ldv_linux_kernel_locking_spinlock_spin_lock_of_NOT_ARG_SIGN = 1; } return; } } int ldv_linux_kernel_locking_spinlock_spin_trylock_lock_of_NOT_ARG_SIGN(void) { int is_spin_held_by_another_thread ; { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock_try(ldv_linux_kernel_locking_spinlock_spin_lock_of_NOT_ARG_SIGN == 1); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_lock_of_NOT_ARG_SIGN == 1); is_spin_held_by_another_thread = ldv_undef_int(); } if (is_spin_held_by_another_thread != 0) { return (0); } else { ldv_linux_kernel_locking_spinlock_spin_lock_of_NOT_ARG_SIGN = 2; return (1); } } } void ldv_linux_kernel_locking_spinlock_spin_unlock_wait_lock_of_NOT_ARG_SIGN(void) { { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock_try(ldv_linux_kernel_locking_spinlock_spin_lock_of_NOT_ARG_SIGN == 1); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_lock_of_NOT_ARG_SIGN == 1); } return; } } int ldv_linux_kernel_locking_spinlock_spin_is_locked_lock_of_NOT_ARG_SIGN(void) { int is_spin_held_by_another_thread ; { { is_spin_held_by_another_thread = ldv_undef_int(); } if (ldv_linux_kernel_locking_spinlock_spin_lock_of_NOT_ARG_SIGN == 1 && is_spin_held_by_another_thread == 0) { return (0); } else { return (1); } } } int ldv_linux_kernel_locking_spinlock_spin_can_lock_lock_of_NOT_ARG_SIGN(void) { int tmp ; { { tmp = ldv_linux_kernel_locking_spinlock_spin_is_locked_lock_of_NOT_ARG_SIGN(); } return (tmp == 0); } } int ldv_linux_kernel_locking_spinlock_spin_is_contended_lock_of_NOT_ARG_SIGN(void) { int is_spin_contended ; { { is_spin_contended = ldv_undef_int(); } if (is_spin_contended != 0) { return (0); } else { return (1); } } } int ldv_linux_kernel_locking_spinlock_atomic_dec_and_lock_lock_of_NOT_ARG_SIGN(void) { int atomic_value_after_dec ; { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock_try(ldv_linux_kernel_locking_spinlock_spin_lock_of_NOT_ARG_SIGN == 1); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_lock_of_NOT_ARG_SIGN == 1); atomic_value_after_dec = ldv_undef_int(); } if (atomic_value_after_dec == 0) { ldv_linux_kernel_locking_spinlock_spin_lock_of_NOT_ARG_SIGN = 2; return (1); } else { } return (0); } } static int ldv_linux_kernel_locking_spinlock_spin_lock_of_pm8001_hba_info = 1; void ldv_linux_kernel_locking_spinlock_spin_lock_lock_of_pm8001_hba_info(void) { { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock(ldv_linux_kernel_locking_spinlock_spin_lock_of_pm8001_hba_info == 1); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_lock_of_pm8001_hba_info == 1); ldv_linux_kernel_locking_spinlock_spin_lock_of_pm8001_hba_info = 2; } return; } } void ldv_linux_kernel_locking_spinlock_spin_unlock_lock_of_pm8001_hba_info(void) { { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_unlock(ldv_linux_kernel_locking_spinlock_spin_lock_of_pm8001_hba_info == 2); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_lock_of_pm8001_hba_info == 2); ldv_linux_kernel_locking_spinlock_spin_lock_of_pm8001_hba_info = 1; } return; } } int ldv_linux_kernel_locking_spinlock_spin_trylock_lock_of_pm8001_hba_info(void) { int is_spin_held_by_another_thread ; { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock_try(ldv_linux_kernel_locking_spinlock_spin_lock_of_pm8001_hba_info == 1); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_lock_of_pm8001_hba_info == 1); is_spin_held_by_another_thread = ldv_undef_int(); } if (is_spin_held_by_another_thread != 0) { return (0); } else { ldv_linux_kernel_locking_spinlock_spin_lock_of_pm8001_hba_info = 2; return (1); } } } void ldv_linux_kernel_locking_spinlock_spin_unlock_wait_lock_of_pm8001_hba_info(void) { { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock_try(ldv_linux_kernel_locking_spinlock_spin_lock_of_pm8001_hba_info == 1); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_lock_of_pm8001_hba_info == 1); } return; } } int ldv_linux_kernel_locking_spinlock_spin_is_locked_lock_of_pm8001_hba_info(void) { int is_spin_held_by_another_thread ; { { is_spin_held_by_another_thread = ldv_undef_int(); } if (ldv_linux_kernel_locking_spinlock_spin_lock_of_pm8001_hba_info == 1 && is_spin_held_by_another_thread == 0) { return (0); } else { return (1); } } } int ldv_linux_kernel_locking_spinlock_spin_can_lock_lock_of_pm8001_hba_info(void) { int tmp ; { { tmp = ldv_linux_kernel_locking_spinlock_spin_is_locked_lock_of_pm8001_hba_info(); } return (tmp == 0); } } int ldv_linux_kernel_locking_spinlock_spin_is_contended_lock_of_pm8001_hba_info(void) { int is_spin_contended ; { { is_spin_contended = ldv_undef_int(); } if (is_spin_contended != 0) { return (0); } else { return (1); } } } int ldv_linux_kernel_locking_spinlock_atomic_dec_and_lock_lock_of_pm8001_hba_info(void) { int atomic_value_after_dec ; { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock_try(ldv_linux_kernel_locking_spinlock_spin_lock_of_pm8001_hba_info == 1); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_lock_of_pm8001_hba_info == 1); atomic_value_after_dec = ldv_undef_int(); } if (atomic_value_after_dec == 0) { ldv_linux_kernel_locking_spinlock_spin_lock_of_pm8001_hba_info = 2; return (1); } else { } return (0); } } static int ldv_linux_kernel_locking_spinlock_spin_node_size_lock_of_pglist_data = 1; void ldv_linux_kernel_locking_spinlock_spin_lock_node_size_lock_of_pglist_data(void) { { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock(ldv_linux_kernel_locking_spinlock_spin_node_size_lock_of_pglist_data == 1); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_node_size_lock_of_pglist_data == 1); ldv_linux_kernel_locking_spinlock_spin_node_size_lock_of_pglist_data = 2; } return; } } void ldv_linux_kernel_locking_spinlock_spin_unlock_node_size_lock_of_pglist_data(void) { { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_unlock(ldv_linux_kernel_locking_spinlock_spin_node_size_lock_of_pglist_data == 2); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_node_size_lock_of_pglist_data == 2); ldv_linux_kernel_locking_spinlock_spin_node_size_lock_of_pglist_data = 1; } return; } } int ldv_linux_kernel_locking_spinlock_spin_trylock_node_size_lock_of_pglist_data(void) { int is_spin_held_by_another_thread ; { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock_try(ldv_linux_kernel_locking_spinlock_spin_node_size_lock_of_pglist_data == 1); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_node_size_lock_of_pglist_data == 1); is_spin_held_by_another_thread = ldv_undef_int(); } if (is_spin_held_by_another_thread != 0) { return (0); } else { ldv_linux_kernel_locking_spinlock_spin_node_size_lock_of_pglist_data = 2; return (1); } } } void ldv_linux_kernel_locking_spinlock_spin_unlock_wait_node_size_lock_of_pglist_data(void) { { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock_try(ldv_linux_kernel_locking_spinlock_spin_node_size_lock_of_pglist_data == 1); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_node_size_lock_of_pglist_data == 1); } return; } } int ldv_linux_kernel_locking_spinlock_spin_is_locked_node_size_lock_of_pglist_data(void) { int is_spin_held_by_another_thread ; { { is_spin_held_by_another_thread = ldv_undef_int(); } if (ldv_linux_kernel_locking_spinlock_spin_node_size_lock_of_pglist_data == 1 && is_spin_held_by_another_thread == 0) { return (0); } else { return (1); } } } int ldv_linux_kernel_locking_spinlock_spin_can_lock_node_size_lock_of_pglist_data(void) { int tmp ; { { tmp = ldv_linux_kernel_locking_spinlock_spin_is_locked_node_size_lock_of_pglist_data(); } return (tmp == 0); } } int ldv_linux_kernel_locking_spinlock_spin_is_contended_node_size_lock_of_pglist_data(void) { int is_spin_contended ; { { is_spin_contended = ldv_undef_int(); } if (is_spin_contended != 0) { return (0); } else { return (1); } } } int ldv_linux_kernel_locking_spinlock_atomic_dec_and_lock_node_size_lock_of_pglist_data(void) { int atomic_value_after_dec ; { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock_try(ldv_linux_kernel_locking_spinlock_spin_node_size_lock_of_pglist_data == 1); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_node_size_lock_of_pglist_data == 1); atomic_value_after_dec = ldv_undef_int(); } if (atomic_value_after_dec == 0) { ldv_linux_kernel_locking_spinlock_spin_node_size_lock_of_pglist_data = 2; return (1); } else { } return (0); } } static int ldv_linux_kernel_locking_spinlock_spin_ptl = 1; void ldv_linux_kernel_locking_spinlock_spin_lock_ptl(void) { { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock(ldv_linux_kernel_locking_spinlock_spin_ptl == 1); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_ptl == 1); ldv_linux_kernel_locking_spinlock_spin_ptl = 2; } return; } } void ldv_linux_kernel_locking_spinlock_spin_unlock_ptl(void) { { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_unlock(ldv_linux_kernel_locking_spinlock_spin_ptl == 2); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_ptl == 2); ldv_linux_kernel_locking_spinlock_spin_ptl = 1; } return; } } int ldv_linux_kernel_locking_spinlock_spin_trylock_ptl(void) { int is_spin_held_by_another_thread ; { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock_try(ldv_linux_kernel_locking_spinlock_spin_ptl == 1); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_ptl == 1); is_spin_held_by_another_thread = ldv_undef_int(); } if (is_spin_held_by_another_thread != 0) { return (0); } else { ldv_linux_kernel_locking_spinlock_spin_ptl = 2; return (1); } } } void ldv_linux_kernel_locking_spinlock_spin_unlock_wait_ptl(void) { { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock_try(ldv_linux_kernel_locking_spinlock_spin_ptl == 1); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_ptl == 1); } return; } } int ldv_linux_kernel_locking_spinlock_spin_is_locked_ptl(void) { int is_spin_held_by_another_thread ; { { is_spin_held_by_another_thread = ldv_undef_int(); } if (ldv_linux_kernel_locking_spinlock_spin_ptl == 1 && is_spin_held_by_another_thread == 0) { return (0); } else { return (1); } } } int ldv_linux_kernel_locking_spinlock_spin_can_lock_ptl(void) { int tmp ; { { tmp = ldv_linux_kernel_locking_spinlock_spin_is_locked_ptl(); } return (tmp == 0); } } int ldv_linux_kernel_locking_spinlock_spin_is_contended_ptl(void) { int is_spin_contended ; { { is_spin_contended = ldv_undef_int(); } if (is_spin_contended != 0) { return (0); } else { return (1); } } } int ldv_linux_kernel_locking_spinlock_atomic_dec_and_lock_ptl(void) { int atomic_value_after_dec ; { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock_try(ldv_linux_kernel_locking_spinlock_spin_ptl == 1); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_ptl == 1); atomic_value_after_dec = ldv_undef_int(); } if (atomic_value_after_dec == 0) { ldv_linux_kernel_locking_spinlock_spin_ptl = 2; return (1); } else { } return (0); } } static int ldv_linux_kernel_locking_spinlock_spin_sas_prim_lock_of_asd_sas_phy = 1; void ldv_linux_kernel_locking_spinlock_spin_lock_sas_prim_lock_of_asd_sas_phy(void) { { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock(ldv_linux_kernel_locking_spinlock_spin_sas_prim_lock_of_asd_sas_phy == 1); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_sas_prim_lock_of_asd_sas_phy == 1); ldv_linux_kernel_locking_spinlock_spin_sas_prim_lock_of_asd_sas_phy = 2; } return; } } void ldv_linux_kernel_locking_spinlock_spin_unlock_sas_prim_lock_of_asd_sas_phy(void) { { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_unlock(ldv_linux_kernel_locking_spinlock_spin_sas_prim_lock_of_asd_sas_phy == 2); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_sas_prim_lock_of_asd_sas_phy == 2); ldv_linux_kernel_locking_spinlock_spin_sas_prim_lock_of_asd_sas_phy = 1; } return; } } int ldv_linux_kernel_locking_spinlock_spin_trylock_sas_prim_lock_of_asd_sas_phy(void) { int is_spin_held_by_another_thread ; { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock_try(ldv_linux_kernel_locking_spinlock_spin_sas_prim_lock_of_asd_sas_phy == 1); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_sas_prim_lock_of_asd_sas_phy == 1); is_spin_held_by_another_thread = ldv_undef_int(); } if (is_spin_held_by_another_thread != 0) { return (0); } else { ldv_linux_kernel_locking_spinlock_spin_sas_prim_lock_of_asd_sas_phy = 2; return (1); } } } void ldv_linux_kernel_locking_spinlock_spin_unlock_wait_sas_prim_lock_of_asd_sas_phy(void) { { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock_try(ldv_linux_kernel_locking_spinlock_spin_sas_prim_lock_of_asd_sas_phy == 1); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_sas_prim_lock_of_asd_sas_phy == 1); } return; } } int ldv_linux_kernel_locking_spinlock_spin_is_locked_sas_prim_lock_of_asd_sas_phy(void) { int is_spin_held_by_another_thread ; { { is_spin_held_by_another_thread = ldv_undef_int(); } if (ldv_linux_kernel_locking_spinlock_spin_sas_prim_lock_of_asd_sas_phy == 1 && is_spin_held_by_another_thread == 0) { return (0); } else { return (1); } } } int ldv_linux_kernel_locking_spinlock_spin_can_lock_sas_prim_lock_of_asd_sas_phy(void) { int tmp ; { { tmp = ldv_linux_kernel_locking_spinlock_spin_is_locked_sas_prim_lock_of_asd_sas_phy(); } return (tmp == 0); } } int ldv_linux_kernel_locking_spinlock_spin_is_contended_sas_prim_lock_of_asd_sas_phy(void) { int is_spin_contended ; { { is_spin_contended = ldv_undef_int(); } if (is_spin_contended != 0) { return (0); } else { return (1); } } } int ldv_linux_kernel_locking_spinlock_atomic_dec_and_lock_sas_prim_lock_of_asd_sas_phy(void) { int atomic_value_after_dec ; { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock_try(ldv_linux_kernel_locking_spinlock_spin_sas_prim_lock_of_asd_sas_phy == 1); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_sas_prim_lock_of_asd_sas_phy == 1); atomic_value_after_dec = ldv_undef_int(); } if (atomic_value_after_dec == 0) { ldv_linux_kernel_locking_spinlock_spin_sas_prim_lock_of_asd_sas_phy = 2; return (1); } else { } return (0); } } static int ldv_linux_kernel_locking_spinlock_spin_siglock_of_sighand_struct = 1; void ldv_linux_kernel_locking_spinlock_spin_lock_siglock_of_sighand_struct(void) { { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock(ldv_linux_kernel_locking_spinlock_spin_siglock_of_sighand_struct == 1); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_siglock_of_sighand_struct == 1); ldv_linux_kernel_locking_spinlock_spin_siglock_of_sighand_struct = 2; } return; } } void ldv_linux_kernel_locking_spinlock_spin_unlock_siglock_of_sighand_struct(void) { { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_unlock(ldv_linux_kernel_locking_spinlock_spin_siglock_of_sighand_struct == 2); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_siglock_of_sighand_struct == 2); ldv_linux_kernel_locking_spinlock_spin_siglock_of_sighand_struct = 1; } return; } } int ldv_linux_kernel_locking_spinlock_spin_trylock_siglock_of_sighand_struct(void) { int is_spin_held_by_another_thread ; { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock_try(ldv_linux_kernel_locking_spinlock_spin_siglock_of_sighand_struct == 1); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_siglock_of_sighand_struct == 1); is_spin_held_by_another_thread = ldv_undef_int(); } if (is_spin_held_by_another_thread != 0) { return (0); } else { ldv_linux_kernel_locking_spinlock_spin_siglock_of_sighand_struct = 2; return (1); } } } void ldv_linux_kernel_locking_spinlock_spin_unlock_wait_siglock_of_sighand_struct(void) { { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock_try(ldv_linux_kernel_locking_spinlock_spin_siglock_of_sighand_struct == 1); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_siglock_of_sighand_struct == 1); } return; } } int ldv_linux_kernel_locking_spinlock_spin_is_locked_siglock_of_sighand_struct(void) { int is_spin_held_by_another_thread ; { { is_spin_held_by_another_thread = ldv_undef_int(); } if (ldv_linux_kernel_locking_spinlock_spin_siglock_of_sighand_struct == 1 && is_spin_held_by_another_thread == 0) { return (0); } else { return (1); } } } int ldv_linux_kernel_locking_spinlock_spin_can_lock_siglock_of_sighand_struct(void) { int tmp ; { { tmp = ldv_linux_kernel_locking_spinlock_spin_is_locked_siglock_of_sighand_struct(); } return (tmp == 0); } } int ldv_linux_kernel_locking_spinlock_spin_is_contended_siglock_of_sighand_struct(void) { int is_spin_contended ; { { is_spin_contended = ldv_undef_int(); } if (is_spin_contended != 0) { return (0); } else { return (1); } } } int ldv_linux_kernel_locking_spinlock_atomic_dec_and_lock_siglock_of_sighand_struct(void) { int atomic_value_after_dec ; { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock_try(ldv_linux_kernel_locking_spinlock_spin_siglock_of_sighand_struct == 1); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_siglock_of_sighand_struct == 1); atomic_value_after_dec = ldv_undef_int(); } if (atomic_value_after_dec == 0) { ldv_linux_kernel_locking_spinlock_spin_siglock_of_sighand_struct = 2; return (1); } else { } return (0); } } static int ldv_linux_kernel_locking_spinlock_spin_task_state_lock_of_sas_task = 1; void ldv_linux_kernel_locking_spinlock_spin_lock_task_state_lock_of_sas_task(void) { { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock(ldv_linux_kernel_locking_spinlock_spin_task_state_lock_of_sas_task == 1); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_task_state_lock_of_sas_task == 1); ldv_linux_kernel_locking_spinlock_spin_task_state_lock_of_sas_task = 2; } return; } } void ldv_linux_kernel_locking_spinlock_spin_unlock_task_state_lock_of_sas_task(void) { { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_unlock(ldv_linux_kernel_locking_spinlock_spin_task_state_lock_of_sas_task == 2); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_task_state_lock_of_sas_task == 2); ldv_linux_kernel_locking_spinlock_spin_task_state_lock_of_sas_task = 1; } return; } } int ldv_linux_kernel_locking_spinlock_spin_trylock_task_state_lock_of_sas_task(void) { int is_spin_held_by_another_thread ; { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock_try(ldv_linux_kernel_locking_spinlock_spin_task_state_lock_of_sas_task == 1); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_task_state_lock_of_sas_task == 1); is_spin_held_by_another_thread = ldv_undef_int(); } if (is_spin_held_by_another_thread != 0) { return (0); } else { ldv_linux_kernel_locking_spinlock_spin_task_state_lock_of_sas_task = 2; return (1); } } } void ldv_linux_kernel_locking_spinlock_spin_unlock_wait_task_state_lock_of_sas_task(void) { { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock_try(ldv_linux_kernel_locking_spinlock_spin_task_state_lock_of_sas_task == 1); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_task_state_lock_of_sas_task == 1); } return; } } int ldv_linux_kernel_locking_spinlock_spin_is_locked_task_state_lock_of_sas_task(void) { int is_spin_held_by_another_thread ; { { is_spin_held_by_another_thread = ldv_undef_int(); } if (ldv_linux_kernel_locking_spinlock_spin_task_state_lock_of_sas_task == 1 && is_spin_held_by_another_thread == 0) { return (0); } else { return (1); } } } int ldv_linux_kernel_locking_spinlock_spin_can_lock_task_state_lock_of_sas_task(void) { int tmp ; { { tmp = ldv_linux_kernel_locking_spinlock_spin_is_locked_task_state_lock_of_sas_task(); } return (tmp == 0); } } int ldv_linux_kernel_locking_spinlock_spin_is_contended_task_state_lock_of_sas_task(void) { int is_spin_contended ; { { is_spin_contended = ldv_undef_int(); } if (is_spin_contended != 0) { return (0); } else { return (1); } } } int ldv_linux_kernel_locking_spinlock_atomic_dec_and_lock_task_state_lock_of_sas_task(void) { int atomic_value_after_dec ; { { ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock_try(ldv_linux_kernel_locking_spinlock_spin_task_state_lock_of_sas_task == 1); ldv_assume(ldv_linux_kernel_locking_spinlock_spin_task_state_lock_of_sas_task == 1); atomic_value_after_dec = ldv_undef_int(); } if (atomic_value_after_dec == 0) { ldv_linux_kernel_locking_spinlock_spin_task_state_lock_of_sas_task = 2; return (1); } else { } return (0); } } void ldv_linux_kernel_locking_spinlock_check_final_state(void) { { { ldv_assert_linux_kernel_locking_spinlock__one_thread_locked_at_exit(ldv_linux_kernel_locking_spinlock_spin_alloc_lock_of_task_struct == 1); ldv_assert_linux_kernel_locking_spinlock__one_thread_locked_at_exit(ldv_linux_kernel_locking_spinlock_spin_bitmap_lock_of_pm8001_hba_info == 1); ldv_assert_linux_kernel_locking_spinlock__one_thread_locked_at_exit(ldv_linux_kernel_locking_spinlock_spin_frame_rcvd_lock_of_asd_sas_phy == 1); ldv_assert_linux_kernel_locking_spinlock__one_thread_locked_at_exit(ldv_linux_kernel_locking_spinlock_spin_i_lock_of_inode == 1); ldv_assert_linux_kernel_locking_spinlock__one_thread_locked_at_exit(ldv_linux_kernel_locking_spinlock_spin_lock == 1); ldv_assert_linux_kernel_locking_spinlock__one_thread_locked_at_exit(ldv_linux_kernel_locking_spinlock_spin_lock_of_NOT_ARG_SIGN == 1); ldv_assert_linux_kernel_locking_spinlock__one_thread_locked_at_exit(ldv_linux_kernel_locking_spinlock_spin_lock_of_pm8001_hba_info == 1); ldv_assert_linux_kernel_locking_spinlock__one_thread_locked_at_exit(ldv_linux_kernel_locking_spinlock_spin_node_size_lock_of_pglist_data == 1); ldv_assert_linux_kernel_locking_spinlock__one_thread_locked_at_exit(ldv_linux_kernel_locking_spinlock_spin_ptl == 1); ldv_assert_linux_kernel_locking_spinlock__one_thread_locked_at_exit(ldv_linux_kernel_locking_spinlock_spin_sas_prim_lock_of_asd_sas_phy == 1); ldv_assert_linux_kernel_locking_spinlock__one_thread_locked_at_exit(ldv_linux_kernel_locking_spinlock_spin_siglock_of_sighand_struct == 1); ldv_assert_linux_kernel_locking_spinlock__one_thread_locked_at_exit(ldv_linux_kernel_locking_spinlock_spin_task_state_lock_of_sas_task == 1); } return; } } int ldv_exclusive_spin_is_locked(void) { { if (ldv_linux_kernel_locking_spinlock_spin_alloc_lock_of_task_struct == 2) { return (1); } else { } if (ldv_linux_kernel_locking_spinlock_spin_bitmap_lock_of_pm8001_hba_info == 2) { return (1); } else { } if (ldv_linux_kernel_locking_spinlock_spin_frame_rcvd_lock_of_asd_sas_phy == 2) { return (1); } else { } if (ldv_linux_kernel_locking_spinlock_spin_i_lock_of_inode == 2) { return (1); } else { } if (ldv_linux_kernel_locking_spinlock_spin_lock == 2) { return (1); } else { } if (ldv_linux_kernel_locking_spinlock_spin_lock_of_NOT_ARG_SIGN == 2) { return (1); } else { } if (ldv_linux_kernel_locking_spinlock_spin_lock_of_pm8001_hba_info == 2) { return (1); } else { } if (ldv_linux_kernel_locking_spinlock_spin_node_size_lock_of_pglist_data == 2) { return (1); } else { } if (ldv_linux_kernel_locking_spinlock_spin_ptl == 2) { return (1); } else { } if (ldv_linux_kernel_locking_spinlock_spin_sas_prim_lock_of_asd_sas_phy == 2) { return (1); } else { } if (ldv_linux_kernel_locking_spinlock_spin_siglock_of_sighand_struct == 2) { return (1); } else { } if (ldv_linux_kernel_locking_spinlock_spin_task_state_lock_of_sas_task == 2) { return (1); } else { } return (0); } } void ldv_assert_linux_kernel_sched_completion__double_init(int expr ) ; void ldv_assert_linux_kernel_sched_completion__wait_without_init(int expr ) ; static int ldv_linux_kernel_sched_completion_completion_completion = 0; void ldv_linux_kernel_sched_completion_init_completion_completion(void) { { ldv_linux_kernel_sched_completion_completion_completion = 1; return; } } void ldv_linux_kernel_sched_completion_init_completion_macro_completion(void) { { { ldv_assert_linux_kernel_sched_completion__double_init(ldv_linux_kernel_sched_completion_completion_completion != 0); ldv_linux_kernel_sched_completion_completion_completion = 1; } return; } } void ldv_linux_kernel_sched_completion_wait_for_completion_completion(void) { { { ldv_assert_linux_kernel_sched_completion__wait_without_init(ldv_linux_kernel_sched_completion_completion_completion != 0); ldv_linux_kernel_sched_completion_completion_completion = 2; } return; } } static int ldv_linux_kernel_sched_completion_completion_completion_of_sas_task_slow = 0; void ldv_linux_kernel_sched_completion_init_completion_completion_of_sas_task_slow(void) { { ldv_linux_kernel_sched_completion_completion_completion_of_sas_task_slow = 1; return; } } void ldv_linux_kernel_sched_completion_init_completion_macro_completion_of_sas_task_slow(void) { { { ldv_assert_linux_kernel_sched_completion__double_init(ldv_linux_kernel_sched_completion_completion_completion_of_sas_task_slow != 0); ldv_linux_kernel_sched_completion_completion_completion_of_sas_task_slow = 1; } return; } } void ldv_linux_kernel_sched_completion_wait_for_completion_completion_of_sas_task_slow(void) { { { ldv_assert_linux_kernel_sched_completion__wait_without_init(ldv_linux_kernel_sched_completion_completion_completion_of_sas_task_slow != 0); ldv_linux_kernel_sched_completion_completion_completion_of_sas_task_slow = 2; } return; } } static int ldv_linux_kernel_sched_completion_completion_completion_setstate = 0; void ldv_linux_kernel_sched_completion_init_completion_completion_setstate(void) { { ldv_linux_kernel_sched_completion_completion_completion_setstate = 1; return; } } void ldv_linux_kernel_sched_completion_init_completion_macro_completion_setstate(void) { { { ldv_assert_linux_kernel_sched_completion__double_init(ldv_linux_kernel_sched_completion_completion_completion_setstate != 0); ldv_linux_kernel_sched_completion_completion_completion_setstate = 1; } return; } } void ldv_linux_kernel_sched_completion_wait_for_completion_completion_setstate(void) { { { ldv_assert_linux_kernel_sched_completion__wait_without_init(ldv_linux_kernel_sched_completion_completion_completion_setstate != 0); ldv_linux_kernel_sched_completion_completion_completion_setstate = 2; } return; } } void ldv_assert_linux_lib_idr__destroyed_before_usage(int expr ) ; void ldv_assert_linux_lib_idr__double_init(int expr ) ; void ldv_assert_linux_lib_idr__more_at_exit(int expr ) ; void ldv_assert_linux_lib_idr__not_initialized(int expr ) ; static int ldv_linux_lib_idr_idr = 0; void ldv_linux_lib_idr_idr_init(void) { { { ldv_assert_linux_lib_idr__double_init(ldv_linux_lib_idr_idr == 0); ldv_linux_lib_idr_idr = 1; } return; } } void ldv_linux_lib_idr_idr_alloc(void) { { { ldv_assert_linux_lib_idr__not_initialized(ldv_linux_lib_idr_idr != 0); ldv_assert_linux_lib_idr__destroyed_before_usage(ldv_linux_lib_idr_idr != 3); ldv_linux_lib_idr_idr = 2; } return; } } void ldv_linux_lib_idr_idr_find(void) { { { ldv_assert_linux_lib_idr__not_initialized(ldv_linux_lib_idr_idr != 0); ldv_assert_linux_lib_idr__destroyed_before_usage(ldv_linux_lib_idr_idr != 3); ldv_linux_lib_idr_idr = 2; } return; } } void ldv_linux_lib_idr_idr_remove(void) { { { ldv_assert_linux_lib_idr__not_initialized(ldv_linux_lib_idr_idr != 0); ldv_assert_linux_lib_idr__destroyed_before_usage(ldv_linux_lib_idr_idr != 3); ldv_linux_lib_idr_idr = 2; } return; } } void ldv_linux_lib_idr_idr_destroy(void) { { { ldv_assert_linux_lib_idr__not_initialized(ldv_linux_lib_idr_idr != 0); ldv_assert_linux_lib_idr__destroyed_before_usage(ldv_linux_lib_idr_idr != 3); ldv_linux_lib_idr_idr = 3; } return; } } void ldv_linux_lib_idr_check_final_state(void) { { { ldv_assert_linux_lib_idr__more_at_exit(ldv_linux_lib_idr_idr == 0 || ldv_linux_lib_idr_idr == 3); } return; } } extern void __VERIFIER_error(void) ; void ldv_assert_linux_net_rtnetlink__double_lock(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_net_rtnetlink__lock_on_exit(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_net_rtnetlink__double_unlock(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } extern void __VERIFIER_error(void) ; void ldv_assert_linux_kernel_locking_rwlock__read_lock_on_write_lock(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_kernel_locking_rwlock__more_read_unlocks(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_kernel_locking_rwlock__read_lock_at_exit(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_kernel_locking_rwlock__double_write_lock(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_kernel_locking_rwlock__double_write_unlock(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_kernel_locking_rwlock__write_lock_at_exit(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } extern void __VERIFIER_error(void) ; void ldv_assert_linux_lib_idr__double_init(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_lib_idr__not_initialized(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_lib_idr__destroyed_before_usage(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_lib_idr__more_at_exit(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } extern void __VERIFIER_error(void) ; void ldv_assert_linux_kernel_sched_completion__double_init(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_kernel_sched_completion__wait_without_init(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } extern void __VERIFIER_error(void) ; void ldv_assert_linux_net_register__wrong_return_value(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } extern void __VERIFIER_error(void) ; void ldv_assert_linux_fs_char_dev__double_registration(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_fs_char_dev__double_deregistration(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_fs_char_dev__registered_at_exit(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } extern void __VERIFIER_error(void) ; void ldv_assert_linux_kernel_rcu_srcu__more_unlocks(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_kernel_rcu_srcu__locked_at_read_section(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_kernel_rcu_srcu__locked_at_exit(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } extern void __VERIFIER_error(void) ; void ldv_assert_linux_kernel_module__less_initial_decrement(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_kernel_module__more_initial_at_exit(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } extern void __VERIFIER_error(void) ; void ldv_assert_linux_alloc_spinlock__wrong_flags(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_alloc_spinlock__nonatomic(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } extern void __VERIFIER_error(void) ; void ldv_assert_linux_lib_find_bit__offset_out_of_range(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } extern void __VERIFIER_error(void) ; void ldv_assert_linux_mmc_sdio_func__wrong_params(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_mmc_sdio_func__double_claim(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_mmc_sdio_func__release_without_claim(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_mmc_sdio_func__unreleased_at_exit(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } extern void __VERIFIER_error(void) ; void ldv_assert_linux_usb_coherent__less_initial_decrement(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_usb_coherent__more_initial_at_exit(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } extern void __VERIFIER_error(void) ; void ldv_assert_linux_kernel_rcu_update_lock__more_unlocks(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_kernel_rcu_update_lock__locked_at_read_section(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_kernel_rcu_update_lock__locked_at_exit(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } extern void __VERIFIER_error(void) ; void ldv_assert_linux_net_sock__all_locked_sockets_must_be_released(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_net_sock__double_release(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } extern void __VERIFIER_error(void) ; void ldv_assert_linux_kernel_rcu_update_lock_bh__more_unlocks(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_kernel_rcu_update_lock_bh__locked_at_read_section(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_kernel_rcu_update_lock_bh__locked_at_exit(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } extern void __VERIFIER_error(void) ; void ldv_assert_linux_usb_dev__unincremented_counter_decrement(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_usb_dev__less_initial_decrement(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_usb_dev__more_initial_at_exit(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_usb_dev__probe_failed(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } extern void __VERIFIER_error(void) ; void ldv_assert_linux_kernel_locking_mutex__one_thread_double_lock(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_kernel_locking_mutex__one_thread_double_lock_try(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_kernel_locking_mutex__one_thread_double_unlock(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_kernel_locking_mutex__one_thread_locked_at_exit(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } extern void __VERIFIER_error(void) ; void ldv_assert_linux_usb_gadget__class_registration_with_usb_gadget(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_usb_gadget__class_deregistration_with_usb_gadget(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_usb_gadget__chrdev_registration_with_usb_gadget(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_usb_gadget__chrdev_deregistration_with_usb_gadget(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_usb_gadget__double_usb_gadget_registration(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_usb_gadget__double_usb_gadget_deregistration(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_usb_gadget__usb_gadget_registered_at_exit(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } extern void __VERIFIER_error(void) ; void ldv_assert_linux_alloc_usb_lock__wrong_flags(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_alloc_usb_lock__nonatomic(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } extern void __VERIFIER_error(void) ; void ldv_assert_linux_block_request__double_get(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_block_request__double_put(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_block_request__get_at_exit(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } extern void __VERIFIER_error(void) ; void ldv_assert_linux_alloc_irq__wrong_flags(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_alloc_irq__nonatomic(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } extern void __VERIFIER_error(void) ; void ldv_assert_linux_drivers_base_class__double_registration(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_drivers_base_class__double_deregistration(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_drivers_base_class__registered_at_exit(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } extern void __VERIFIER_error(void) ; void ldv_assert_linux_block_queue__double_allocation(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_block_queue__use_before_allocation(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_block_queue__more_initial_at_exit(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } extern void __VERIFIER_error(void) ; void ldv_assert_linux_block_genhd__double_allocation(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_block_genhd__use_before_allocation(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_block_genhd__delete_before_add(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_block_genhd__free_before_allocation(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_block_genhd__more_initial_at_exit(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } extern void __VERIFIER_error(void) ; void ldv_assert_linux_arch_io__less_initial_decrement(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_arch_io__more_initial_at_exit(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } extern void __VERIFIER_error(void) ; void ldv_assert_linux_usb_register__wrong_return_value(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } extern void __VERIFIER_error(void) ; void ldv_assert_linux_fs_sysfs__less_initial_decrement(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_fs_sysfs__more_initial_at_exit(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } extern void __VERIFIER_error(void) ; void ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_kernel_locking_spinlock__one_thread_double_lock_try(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_kernel_locking_spinlock__one_thread_double_unlock(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_kernel_locking_spinlock__one_thread_locked_at_exit(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } extern void __VERIFIER_error(void) ; void ldv_assert_linux_usb_urb__less_initial_decrement(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_usb_urb__more_initial_at_exit(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } extern void __VERIFIER_error(void) ; void ldv_assert_linux_kernel_rcu_update_lock_sched__more_unlocks(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_kernel_rcu_update_lock_sched__locked_at_read_section(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } } void ldv_assert_linux_kernel_rcu_update_lock_sched__locked_at_exit(int expr ) { { if (! expr) { { __VERIFIER_error(); } } else { } return; } }