extern void abort(void); #include void reach_error() { assert(0); } /* Generated by CIL v. 1.5.1 */ /* print_CIL_Input is false */ struct __va_list_tag; typedef struct __va_list_tag __va_list_tag; typedef __builtin_va_list __gnuc_va_list[1U]; typedef __gnuc_va_list va_list[1U]; typedef signed char __s8; typedef unsigned char __u8; typedef short __s16; typedef unsigned short __u16; typedef int __s32; typedef unsigned int __u32; typedef long long __s64; typedef unsigned long long __u64; typedef signed char s8; typedef unsigned char u8; typedef short s16; 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 __kernel_long_t __kernel_off_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 __be32; typedef __u32 __wsum; typedef __u32 __kernel_dev_t; typedef __kernel_dev_t dev_t; typedef unsigned short umode_t; typedef __u32 nlink_t; typedef __kernel_off_t off_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 unsigned char u_char; typedef unsigned int u_int; typedef unsigned long u_long; typedef unsigned long ulong; typedef __s32 int32_t; typedef __u8 uint8_t; typedef __u32 uint32_t; typedef __u64 uint64_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 module; typedef void (*ctor_fn_t)(void); struct file_operations; struct device; struct net_device; struct completion; struct pt_regs; struct pid; typedef u16 __ticket_t; typedef u32 __ticketpair_t; struct __raw_tickets { __ticket_t head ; __ticket_t tail ; }; union __anonunion_ldv_2024_8 { __ticketpair_t head_tail ; struct __raw_tickets tickets ; }; struct arch_spinlock { union __anonunion_ldv_2024_8 ldv_2024 ; }; typedef struct arch_spinlock arch_spinlock_t; struct __anonstruct_ldv_2031_10 { u32 read ; s32 write ; }; union __anonunion_arch_rwlock_t_9 { s64 lock ; struct __anonstruct_ldv_2031_10 ldv_2031 ; }; typedef union __anonunion_arch_rwlock_t_9 arch_rwlock_t; struct task_struct; struct lockdep_map; struct mm_struct; 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_ldv_2096_12 { unsigned int a ; unsigned int b ; }; struct __anonstruct_ldv_2111_13 { 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_ldv_2112_11 { struct __anonstruct_ldv_2096_12 ldv_2096 ; struct __anonstruct_ldv_2111_13 ldv_2111 ; }; struct desc_struct { union __anonunion_ldv_2112_11 ldv_2112 ; }; typedef unsigned long pgdval_t; typedef unsigned long pgprotval_t; struct pgprot { pgprotval_t pgprot ; }; typedef struct pgprot pgprot_t; struct __anonstruct_pgd_t_15 { pgdval_t pgd ; }; typedef struct __anonstruct_pgd_t_15 pgd_t; struct page; typedef struct page *pgtable_t; struct file; struct seq_file; struct thread_struct; struct cpumask; 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_ldv_2767_18 { struct pt_regs *regs ; struct kernel_vm86_regs *vm86 ; }; struct math_emu_info { long ___orig_eip ; union __anonunion_ldv_2767_18 ldv_2767 ; }; struct bug_entry { int bug_addr_disp ; int file_disp ; unsigned short line ; unsigned short flags ; }; struct cpumask { unsigned long bits[64U] ; }; typedef struct cpumask cpumask_t; typedef struct cpumask *cpumask_var_t; struct static_key; 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_ldv_5125_23 { u64 rip ; u64 rdp ; }; struct __anonstruct_ldv_5131_24 { u32 fip ; u32 fcs ; u32 foo ; u32 fos ; }; union __anonunion_ldv_5132_22 { struct __anonstruct_ldv_5125_23 ldv_5125 ; struct __anonstruct_ldv_5131_24 ldv_5131 ; }; union __anonunion_ldv_5141_25 { u32 padding1[12U] ; u32 sw_reserved[12U] ; }; struct i387_fxsave_struct { u16 cwd ; u16 swd ; u16 twd ; u16 fop ; union __anonunion_ldv_5132_22 ldv_5132 ; u32 mxcsr ; u32 mxcsr_mask ; u32 st_space[32U] ; u32 xmm_space[64U] ; u32 padding[12U] ; union __anonunion_ldv_5141_25 ldv_5141 ; }; 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 xsave_hdr_struct { u64 xstate_bv ; u64 reserved1[2U] ; u64 reserved2[5U] ; }; struct xsave_struct { struct i387_fxsave_struct i387 ; struct xsave_hdr_struct xsave_hdr ; struct ymmh_struct ymmh ; }; 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 ; }; 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 ; } __attribute__((__packed__)) ; 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 : 2 ; unsigned char hardirqs_off : 1 ; unsigned short references : 11 ; }; 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_ldv_5960_29 { u8 __padding[24U] ; struct lockdep_map dep_map ; }; union __anonunion_ldv_5961_28 { struct raw_spinlock rlock ; struct __anonstruct_ldv_5960_29 ldv_5960 ; }; struct spinlock { union __anonunion_ldv_5961_28 ldv_5961 ; }; typedef struct spinlock spinlock_t; struct __anonstruct_rwlock_t_30 { arch_rwlock_t raw_lock ; unsigned int magic ; unsigned int owner_cpu ; void *owner ; struct lockdep_map dep_map ; }; typedef struct __anonstruct_rwlock_t_30 rwlock_t; struct mutex { atomic_t count ; spinlock_t wait_lock ; struct list_head wait_list ; struct task_struct *owner ; char const *name ; void *magic ; struct lockdep_map dep_map ; }; struct mutex_waiter { struct list_head list ; struct task_struct *task ; void *magic ; }; struct timespec; struct __anonstruct_seqlock_t_35 { unsigned int sequence ; spinlock_t lock ; }; typedef struct __anonstruct_seqlock_t_35 seqlock_t; struct seqcount { unsigned int sequence ; }; typedef struct seqcount seqcount_t; struct timespec { __kernel_time_t tv_sec ; long tv_nsec ; }; 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 __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 ; }; struct notifier_block; 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 nameidata; struct path; struct vfsmount; struct __anonstruct_ldv_7748_37 { u32 hash ; u32 len ; }; union __anonunion_ldv_7750_36 { struct __anonstruct_ldv_7748_37 ldv_7748 ; u64 hash_len ; }; struct qstr { union __anonunion_ldv_7750_36 ldv_7750 ; unsigned char const *name ; }; struct inode; struct dentry_operations; struct super_block; union __anonunion_d_u_38 { struct list_head d_child ; 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] ; unsigned int d_count ; spinlock_t d_lock ; struct dentry_operations const *d_op ; struct super_block *d_sb ; unsigned long d_time ; void *d_fsdata ; struct list_head d_lru ; union __anonunion_d_u_38 d_u ; struct list_head d_subdirs ; struct hlist_node d_alias ; }; struct dentry_operations { int (*d_revalidate)(struct dentry * , unsigned int ) ; int (*d_hash)(struct dentry const * , struct inode const * , struct qstr * ) ; int (*d_compare)(struct dentry const * , struct inode const * , struct dentry const * , struct inode 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 user_namespace; typedef uid_t kuid_t; typedef gid_t 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 radix_tree_node; struct radix_tree_root { unsigned int height ; gfp_t gfp_mask ; struct radix_tree_node *rnode ; }; 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 ; }; 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 kernel_cap_struct { __u32 cap[2U] ; }; typedef struct kernel_cap_struct kernel_cap_t; struct fiemap_extent { __u64 fe_logical ; __u64 fe_physical ; __u64 fe_length ; __u64 fe_reserved64[2U] ; __u32 fe_flags ; __u32 fe_reserved[3U] ; }; struct shrink_control { gfp_t gfp_mask ; unsigned long nr_to_scan ; }; struct shrinker { int (*shrink)(struct shrinker * , struct shrink_control * ) ; int seeks ; long batch ; struct list_head list ; atomic_long_t nr_in_batch ; }; enum migrate_mode { MIGRATE_ASYNC = 0, MIGRATE_SYNC_LIGHT = 1, MIGRATE_SYNC = 2 } ; struct rw_semaphore; struct rw_semaphore { long count ; raw_spinlock_t wait_lock ; struct list_head wait_list ; struct lockdep_map dep_map ; }; 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 pci_dev; 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 ; int cpu ; }; 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 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 ignore_children ; bool early_init ; 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 ; 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 ; struct dev_pm_qos *qos ; }; struct dev_pm_domain { struct dev_pm_ops ops ; }; struct __anonstruct_nodemask_t_104 { unsigned long bits[16U] ; }; typedef struct __anonstruct_nodemask_t_104 nodemask_t; struct pci_bus; struct __anonstruct_mm_context_t_105 { void *ldt ; int size ; unsigned short ia32_compat ; struct mutex lock ; void *vdso ; }; typedef struct __anonstruct_mm_context_t_105 mm_context_t; struct vm_area_struct; struct block_device; struct io_context; struct cgroup_subsys_state; struct export_operations; struct iovec; struct kiocb; struct kobject; struct pipe_inode_info; struct poll_table_struct; struct kstatfs; struct cred; struct swap_info_struct; 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 percpu_counter { raw_spinlock_t lock ; s64 count ; struct list_head list ; s32 *counters ; }; struct fs_disk_quota { __s8 d_version ; __s8 d_flags ; __u16 d_fieldmask ; __u32 d_id ; __u64 d_blk_hardlimit ; __u64 d_blk_softlimit ; __u64 d_ino_hardlimit ; __u64 d_ino_softlimit ; __u64 d_bcount ; __u64 d_icount ; __s32 d_itimer ; __s32 d_btimer ; __u16 d_iwarns ; __u16 d_bwarns ; __s32 d_padding2 ; __u64 d_rtb_hardlimit ; __u64 d_rtb_softlimit ; __u64 d_rtbcount ; __s32 d_rtbtimer ; __u16 d_rtbwarns ; __s16 d_padding3 ; char d_padding4[8U] ; }; 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 dquot; typedef __kernel_uid32_t projid_t; typedef projid_t 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_ldv_12553_132 { kuid_t uid ; kgid_t gid ; kprojid_t projid ; }; struct kqid { union __anonunion_ldv_12553_132 ldv_12553 ; 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_maxblimit ; qsize_t dqi_maxilimit ; 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 quotactl_ops { int (*quota_on)(struct super_block * , int , int , struct path * ) ; int (*quota_on_meta)(struct super_block * , int , int ) ; int (*quota_off)(struct super_block * , 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 fs_disk_quota * ) ; int (*set_dqblk)(struct super_block * , struct kqid , struct fs_disk_quota * ) ; int (*get_xstate)(struct super_block * , struct fs_quota_stat * ) ; int (*set_xstate)(struct super_block * , unsigned int , 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 rw_semaphore dqptr_sem ; struct inode *files[2U] ; struct mem_dqinfo info[2U] ; struct quota_format_ops const *ops[2U] ; }; struct address_space; struct writeback_control; union __anonunion_arg_134 { char *buf ; void *data ; }; struct __anonstruct_read_descriptor_t_133 { size_t written ; size_t count ; union __anonunion_arg_134 arg ; int error ; }; typedef struct __anonstruct_read_descriptor_t_133 read_descriptor_t; 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 long ) ; int (*releasepage)(struct page * , gfp_t ) ; void (*freepage)(struct page * ) ; ssize_t (*direct_IO)(int , struct kiocb * , struct iovec const * , loff_t , unsigned long ) ; int (*get_xip_mem)(struct address_space * , unsigned long , int , void ** , unsigned long * ) ; int (*migratepage)(struct address_space * , struct page * , struct page * , enum migrate_mode ) ; int (*launder_page)(struct page * ) ; int (*is_partially_uptodate)(struct page * , read_descriptor_t * , unsigned long ) ; 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 backing_dev_info; struct address_space { struct inode *host ; struct radix_tree_root page_tree ; spinlock_t tree_lock ; unsigned int i_mmap_writable ; struct rb_root i_mmap ; struct list_head i_mmap_nonlinear ; struct mutex i_mmap_mutex ; unsigned long nrpages ; unsigned long writeback_index ; struct address_space_operations const *a_ops ; unsigned long flags ; struct backing_dev_info *backing_dev_info ; spinlock_t private_lock ; struct list_head private_list ; void *private_data ; }; struct request_queue; struct hd_struct; struct gendisk; 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_ldv_12989_135 { unsigned int const i_nlink ; unsigned int __i_nlink ; }; union __anonunion_ldv_13009_136 { struct hlist_head i_dentry ; struct callback_head i_rcu ; }; struct file_lock; struct cdev; union __anonunion_ldv_13025_137 { 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_ldv_12989_135 ldv_12989 ; 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_ldv_13009_136 ldv_13009 ; u64 i_version ; atomic_t i_count ; atomic_t i_dio_count ; atomic_t i_writecount ; struct file_operations const *i_fop ; struct file_lock *i_flock ; struct address_space i_data ; struct dquot *i_dquot[2U] ; struct list_head i_devices ; union __anonunion_ldv_13025_137 ldv_13025 ; __u32 i_generation ; __u32 i_fsnotify_mask ; struct hlist_head i_fsnotify_marks ; atomic_t i_readcount ; 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_138 { struct list_head fu_list ; struct callback_head fu_rcuhead ; }; struct file { union __anonunion_f_u_138 f_u ; struct path f_path ; struct file_operations const *f_op ; spinlock_t f_lock ; int f_sb_list_cpu ; atomic_long_t f_count ; unsigned int f_flags ; fmode_t f_mode ; 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 ; unsigned long f_mnt_write_state ; }; struct files_struct; typedef struct files_struct *fl_owner_t; 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 * ) ; void (*lm_notify)(struct file_lock * ) ; int (*lm_grant)(struct file_lock * , struct file_lock * , int ) ; void (*lm_break)(struct file_lock * ) ; int (*lm_change)(struct file_lock ** , int ) ; }; struct net; 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_140 { struct list_head link ; int state ; }; union __anonunion_fl_u_139 { struct nfs_lock_info nfs_fl ; struct nfs4_lock_info nfs4_fl ; struct __anonstruct_afs_140 afs ; }; struct file_lock { struct file_lock *fl_next ; struct list_head fl_link ; struct list_head fl_block ; fl_owner_t fl_owner ; unsigned int fl_flags ; unsigned char fl_type ; unsigned int fl_pid ; 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_139 fl_u ; }; 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 file_system_type; 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_files ; struct list_head s_mounts ; struct list_head s_dentry_lru ; int s_nr_dentry_unused ; spinlock_t s_inode_lru_lock ; struct list_head s_inode_lru ; int s_nr_inodes_unused ; struct block_device *s_bdev ; struct backing_dev_info *s_bdi ; struct mtd_info *s_mtd ; struct hlist_node s_instances ; 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 fiemap_extent_info { unsigned int fi_flags ; unsigned int fi_extents_mapped ; unsigned int fi_extents_max ; struct fiemap_extent *fi_extents_start ; }; 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 ) ; int (*readdir)(struct file * , void * , int (*)(void * , char const * , int , loff_t , u64 , unsigned int ) ) ; 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 * ) ; 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 ** ) ; long (*fallocate)(struct file * , int , loff_t , loff_t ) ; int (*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 (*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 * ) ; }; 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_fs)(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 ) ; int (*bdev_try_to_free_page)(struct super_block * , struct page * , gfp_t ) ; int (*nr_cached_objects)(struct super_block * ) ; void (*free_cached_objects)(struct super_block * , int ) ; }; 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 ctl_table; struct __anonstruct_sigset_t_141 { unsigned long sig[1U] ; }; typedef struct __anonstruct_sigset_t_141 sigset_t; struct siginfo; typedef void __signalfn_t(int ); typedef __signalfn_t *__sighandler_t; typedef void __restorefn_t(void); typedef __restorefn_t *__sigrestore_t; struct sigaction { __sighandler_t sa_handler ; unsigned long sa_flags ; __sigrestore_t sa_restorer ; sigset_t sa_mask ; }; struct k_sigaction { struct sigaction sa ; }; union sigval { int sival_int ; void *sival_ptr ; }; typedef union sigval sigval_t; struct __anonstruct__kill_143 { __kernel_pid_t _pid ; __kernel_uid32_t _uid ; }; struct __anonstruct__timer_144 { __kernel_timer_t _tid ; int _overrun ; char _pad[0U] ; sigval_t _sigval ; int _sys_private ; }; struct __anonstruct__rt_145 { __kernel_pid_t _pid ; __kernel_uid32_t _uid ; sigval_t _sigval ; }; struct __anonstruct__sigchld_146 { __kernel_pid_t _pid ; __kernel_uid32_t _uid ; int _status ; __kernel_clock_t _utime ; __kernel_clock_t _stime ; }; struct __anonstruct__sigfault_147 { void *_addr ; short _addr_lsb ; }; struct __anonstruct__sigpoll_148 { long _band ; int _fd ; }; struct __anonstruct__sigsys_149 { void *_call_addr ; int _syscall ; unsigned int _arch ; }; union __anonunion__sifields_142 { int _pad[28U] ; struct __anonstruct__kill_143 _kill ; struct __anonstruct__timer_144 _timer ; struct __anonstruct__rt_145 _rt ; struct __anonstruct__sigchld_146 _sigchld ; struct __anonstruct__sigfault_147 _sigfault ; struct __anonstruct__sigpoll_148 _sigpoll ; struct __anonstruct__sigsys_149 _sigsys ; }; struct siginfo { int si_signo ; int si_errno ; int si_code ; union __anonunion__sifields_142 _sifields ; }; typedef struct siginfo siginfo_t; struct user_struct; struct sigpending { struct list_head list ; sigset_t signal ; }; struct notifier_block { int (*notifier_call)(struct notifier_block * , unsigned long , void * ) ; struct notifier_block *next ; int priority ; }; struct blocking_notifier_head { struct rw_semaphore rwsem ; struct notifier_block *head ; }; struct mem_cgroup; struct __anonstruct_ldv_16323_153 { struct mem_cgroup *memcg ; struct list_head list ; struct kmem_cache *root_cache ; bool dead ; atomic_t nr_pages ; struct work_struct destroy ; }; union __anonunion_ldv_16324_152 { struct kmem_cache *memcg_caches[0U] ; struct __anonstruct_ldv_16323_153 ldv_16323 ; }; struct memcg_cache_params { bool is_root_cache ; union __anonunion_ldv_16324_152 ldv_16324 ; }; struct sock; 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 ; void *(*grab_current_ns)(void) ; void const *(*netlink_ns)(struct sock * ) ; void const *(*initial_ns)(void) ; void (*drop_ns)(void * ) ; }; 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 { 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 ) ; void const *(*namespace)(struct kobject * , struct attribute const * ) ; }; struct sysfs_dirent; struct kref { atomic_t refcount ; }; 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 sysfs_dirent *sd ; struct kref kref ; 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 *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 kmem_cache_cpu { void **freelist ; unsigned long tid ; struct page *page ; struct page *partial ; unsigned int stat[26U] ; }; struct kmem_cache_node { spinlock_t list_lock ; unsigned long nr_partial ; struct list_head partial ; atomic_long_t nr_slabs ; atomic_long_t total_objects ; struct list_head full ; }; struct kmem_cache_order_objects { unsigned long x ; }; struct kmem_cache { struct kmem_cache_cpu *cpu_slab ; unsigned long flags ; unsigned long min_partial ; int size ; int object_size ; int offset ; int cpu_partial ; struct kmem_cache_order_objects oo ; struct kmem_cache_order_objects max ; struct kmem_cache_order_objects min ; gfp_t allocflags ; int refcount ; void (*ctor)(void * ) ; int inuse ; int align ; int reserved ; char const *name ; struct list_head list ; struct kobject kobj ; struct memcg_cache_params *memcg_params ; int max_attr_size ; int remote_node_defrag_ratio ; struct kmem_cache_node *node[1024U] ; }; 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 uprobe; struct uprobe_task { enum uprobe_task_state state ; struct arch_uprobe_task autask ; struct uprobe *active_uprobe ; unsigned long xol_vaddr ; unsigned long vaddr ; }; struct xol_area { wait_queue_head_t wq ; atomic_t slot_count ; unsigned long *bitmap ; struct page *page ; unsigned long vaddr ; }; struct uprobes_state { struct xol_area *xol_area ; }; union __anonunion_ldv_17037_155 { unsigned long index ; void *freelist ; bool pfmemalloc ; }; struct __anonstruct_ldv_17047_159 { unsigned short inuse ; unsigned short objects : 15 ; unsigned char frozen : 1 ; }; union __anonunion_ldv_17049_158 { atomic_t _mapcount ; struct __anonstruct_ldv_17047_159 ldv_17047 ; int units ; }; struct __anonstruct_ldv_17051_157 { union __anonunion_ldv_17049_158 ldv_17049 ; atomic_t _count ; }; union __anonunion_ldv_17052_156 { unsigned long counters ; struct __anonstruct_ldv_17051_157 ldv_17051 ; }; struct __anonstruct_ldv_17053_154 { union __anonunion_ldv_17037_155 ldv_17037 ; union __anonunion_ldv_17052_156 ldv_17052 ; }; struct __anonstruct_ldv_17060_161 { struct page *next ; int pages ; int pobjects ; }; struct slab; union __anonunion_ldv_17064_160 { struct list_head lru ; struct __anonstruct_ldv_17060_161 ldv_17060 ; struct list_head list ; struct slab *slab_page ; }; union __anonunion_ldv_17069_162 { unsigned long private ; struct kmem_cache *slab_cache ; struct page *first_page ; }; struct page { unsigned long flags ; struct address_space *mapping ; struct __anonstruct_ldv_17053_154 ldv_17053 ; union __anonunion_ldv_17064_160 ldv_17064 ; union __anonunion_ldv_17069_162 ldv_17069 ; unsigned long debug_flags ; int _last_nid ; }; struct page_frag { struct page *page ; __u32 offset ; __u32 size ; }; struct __anonstruct_linear_164 { struct rb_node rb ; unsigned long rb_subtree_last ; }; union __anonunion_shared_163 { struct __anonstruct_linear_164 linear ; struct list_head nonlinear ; }; struct anon_vma; struct vm_operations_struct; 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 ; union __anonunion_shared_163 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 mm_rss_stat { atomic_long_t count[3U] ; }; struct linux_binfmt; struct mmu_notifier_mm; struct mm_struct { struct vm_area_struct *mmap ; struct rb_root mm_rb ; struct vm_area_struct *mmap_cache ; unsigned long (*get_unmapped_area)(struct file * , unsigned long , unsigned long , unsigned long , unsigned long ) ; void (*unmap_area)(struct mm_struct * , unsigned long ) ; unsigned long mmap_base ; unsigned long task_size ; unsigned long cached_hole_size ; unsigned long free_area_cache ; unsigned long highest_vm_end ; pgd_t *pgd ; atomic_t mm_users ; atomic_t mm_count ; 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 nr_ptes ; 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[44U] ; 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 hlist_head ioctx_list ; struct task_struct *owner ; struct file *exe_file ; struct mmu_notifier_mm *mmu_notifier_mm ; pgtable_t pmd_huge_pte ; struct cpumask cpumask_allocation ; unsigned long numa_next_scan ; unsigned long numa_next_reset ; unsigned long numa_scan_offset ; int numa_scan_seq ; int first_nid ; struct uprobes_state uprobes_state ; }; struct vm_fault { unsigned int flags ; unsigned long pgoff ; void *virtual_address ; struct page *page ; }; 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 * ) ; int (*page_mkwrite)(struct vm_area_struct * , struct vm_fault * ) ; int (*access)(struct vm_area_struct * , unsigned long , void * , int , int ) ; int (*set_policy)(struct vm_area_struct * , struct mempolicy * ) ; struct mempolicy *(*get_policy)(struct vm_area_struct * , unsigned long ) ; int (*migrate)(struct vm_area_struct * , nodemask_t const * , nodemask_t const * , unsigned long ) ; int (*remap_pages)(struct vm_area_struct * , unsigned long , unsigned long , unsigned long ) ; }; enum irqreturn { IRQ_NONE = 0, IRQ_HANDLED = 1, IRQ_WAKE_THREAD = 2 } ; typedef enum irqreturn irqreturn_t; struct proc_dir_entry; struct exception_table_entry { int insn ; int fixup ; }; 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 active_bases ; unsigned int clock_was_set ; ktime_t expires_next ; 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[3U] ; }; struct iovec { void *iov_base ; __kernel_size_t iov_len ; }; typedef unsigned short __kernel_sa_family_t; typedef __kernel_sa_family_t sa_family_t; struct sockaddr { sa_family_t sa_family ; char sa_data[14U] ; }; struct sk_buff; struct klist_node; struct klist_node { void *n_klist ; struct list_head n_node ; struct kref n_ref ; }; 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 class; struct subsys_private; struct bus_type; struct device_node; struct iommu_ops; struct iommu_group; struct bus_attribute { struct attribute attr ; ssize_t (*show)(struct bus_type * , char * ) ; ssize_t (*store)(struct bus_type * , char const * , size_t ) ; }; struct device_attribute; struct driver_attribute; struct bus_type { char const *name ; char const *dev_name ; struct device *dev_root ; struct bus_attribute *bus_attrs ; struct device_attribute *dev_attrs ; struct driver_attribute *drv_attrs ; 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 (*suspend)(struct device * , pm_message_t ) ; int (*resume)(struct device * ) ; struct dev_pm_ops const *pm ; struct iommu_ops *iommu_ops ; struct subsys_private *p ; }; struct device_type; struct of_device_id; struct acpi_device_id; 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 driver_attribute { struct attribute attr ; ssize_t (*show)(struct device_driver * , char * ) ; ssize_t (*store)(struct device_driver * , char const * , size_t ) ; }; struct class_attribute; struct class { char const *name ; struct module *owner ; struct class_attribute *class_attrs ; struct device_attribute *dev_attrs ; struct bin_attribute *dev_bin_attrs ; 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 ) ; void const *(*namespace)(struct class * , struct class_attribute const * ) ; }; 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 * ) ; 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_dev_node { void *handle ; }; struct dma_coherent_mem; 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 ; struct dev_pm_info power ; struct dev_pm_domain *pm_domain ; int numa_node ; u64 *dma_mask ; u64 coherent_dma_mask ; struct device_dma_parameters *dma_parms ; struct list_head dma_pools ; struct dma_coherent_mem *dma_mem ; 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 ; }; 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 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 sg_table { struct scatterlist *sgl ; unsigned int nents ; unsigned int orig_nents ; }; typedef s32 dma_cookie_t; 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 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 ; }; typedef u64 netdev_features_t; struct nf_conntrack { atomic_t use ; }; struct nf_bridge_info { atomic_t use ; unsigned int mask ; struct net_device *physindev ; struct net_device *physoutdev ; unsigned long data[4U] ; }; struct sk_buff_head { struct sk_buff *next ; struct sk_buff *prev ; __u32 qlen ; spinlock_t lock ; }; typedef unsigned int sk_buff_data_t; struct sec_path; struct __anonstruct_ldv_24366_169 { __u16 csum_start ; __u16 csum_offset ; }; union __anonunion_ldv_24367_168 { __wsum csum ; struct __anonstruct_ldv_24366_169 ldv_24366 ; }; union __anonunion_ldv_24406_170 { __u32 mark ; __u32 dropcount ; __u32 avail_size ; }; struct sk_buff { struct sk_buff *next ; struct sk_buff *prev ; ktime_t tstamp ; struct sock *sk ; struct net_device *dev ; char cb[48U] ; unsigned long _skb_refdst ; struct sec_path *sp ; unsigned int len ; unsigned int data_len ; __u16 mac_len ; __u16 hdr_len ; union __anonunion_ldv_24367_168 ldv_24367 ; __u32 priority ; unsigned char local_df : 1 ; unsigned char cloned : 1 ; unsigned char ip_summed : 2 ; unsigned char nohdr : 1 ; unsigned char nfctinfo : 3 ; unsigned char pkt_type : 3 ; unsigned char fclone : 2 ; unsigned char ipvs_property : 1 ; unsigned char peeked : 1 ; unsigned char nf_trace : 1 ; __be16 protocol ; void (*destructor)(struct sk_buff * ) ; struct nf_conntrack *nfct ; struct sk_buff *nfct_reasm ; struct nf_bridge_info *nf_bridge ; int skb_iif ; __u32 rxhash ; __u16 vlan_tci ; __u16 tc_index ; __u16 tc_verd ; __u16 queue_mapping ; unsigned char ndisc_nodetype : 2 ; unsigned char pfmemalloc : 1 ; unsigned char ooo_okay : 1 ; unsigned char l4_rxhash : 1 ; unsigned char wifi_acked_valid : 1 ; unsigned char wifi_acked : 1 ; unsigned char no_fcs : 1 ; unsigned char head_frag : 1 ; unsigned char encapsulation : 1 ; dma_cookie_t dma_cookie ; __u32 secmark ; union __anonunion_ldv_24406_170 ldv_24406 ; sk_buff_data_t inner_transport_header ; sk_buff_data_t inner_network_header ; sk_buff_data_t transport_header ; sk_buff_data_t network_header ; sk_buff_data_t mac_header ; sk_buff_data_t tail ; sk_buff_data_t end ; unsigned char *head ; unsigned char *data ; unsigned int truesize ; atomic_t users ; }; struct dst_entry; struct __anonstruct_isdn_cmd_stat_171 { ulong ll_id ; int hl_id ; int proc ; int timeout ; int datalen ; u_char *data ; }; typedef struct __anonstruct_isdn_cmd_stat_171 isdn_cmd_stat; struct setup_parm { unsigned char phone[32U] ; unsigned char eazmsn[32U] ; unsigned char si1 ; unsigned char si2 ; unsigned char plan ; unsigned char screen ; }; typedef struct setup_parm setup_parm; struct T30_s { __u8 resolution ; __u8 rate ; __u8 width ; __u8 length ; __u8 compression ; __u8 ecm ; __u8 binary ; __u8 scantime ; __u8 id[21U] ; __u8 phase ; __u8 direction ; __u8 code ; __u8 badlin ; __u8 badmul ; __u8 bor ; __u8 fet ; __u8 pollid[21U] ; __u8 cq ; __u8 cr ; __u8 ctcrty ; __u8 minsp ; __u8 phcto ; __u8 rel ; __u8 nbc ; __u8 r_resolution ; __u8 r_rate ; __u8 r_width ; __u8 r_length ; __u8 r_compression ; __u8 r_ecm ; __u8 r_binary ; __u8 r_scantime ; __u8 r_id[21U] ; __u8 r_code ; }; typedef struct T30_s T30_s; struct __anonstruct_aux_s_172 { __u8 cmd ; __u8 subcmd ; __u8 para[50U] ; }; typedef struct __anonstruct_aux_s_172 aux_s; union __anonunion_adr_174 { __u32 Controller ; __u32 PLCI ; __u32 NCCI ; }; struct __anonstruct_capi_msg_173 { __u16 Length ; __u16 ApplId ; __u8 Command ; __u8 Subcommand ; __u16 Messagenumber ; union __anonunion_adr_174 adr ; __u8 para[50U] ; }; typedef struct __anonstruct_capi_msg_173 capi_msg; union __anonunion_parm_176 { ulong errcode ; int length ; u_char num[50U] ; setup_parm setup ; capi_msg cmsg ; char display[85U] ; isdn_cmd_stat isdn_io ; aux_s aux ; T30_s *fax ; ulong userdata ; }; struct __anonstruct_isdn_ctrl_175 { int driver ; int command ; ulong arg ; union __anonunion_parm_176 parm ; }; typedef struct __anonstruct_isdn_ctrl_175 isdn_ctrl; struct __anonstruct_isdn_if_177 { struct module *owner ; int channels ; int maxbufsize ; unsigned long features ; unsigned short hl_hdrlen ; void (*rcvcallb_skb)(int , int , struct sk_buff * ) ; int (*statcallb)(isdn_ctrl * ) ; int (*command)(isdn_ctrl * ) ; int (*writebuf_skb)(int , int , int , struct sk_buff * ) ; int (*writecmd)(u_char const * , int , int , int ) ; int (*readstat)(u_char * , int , int , int ) ; char id[20U] ; }; typedef struct __anonstruct_isdn_if_177 isdn_if; typedef unsigned char cc_t; typedef unsigned int speed_t; typedef unsigned int tcflag_t; struct ktermios { tcflag_t c_iflag ; tcflag_t c_oflag ; tcflag_t c_cflag ; tcflag_t c_lflag ; cc_t c_line ; cc_t c_cc[19U] ; speed_t c_ispeed ; speed_t c_ospeed ; }; struct winsize { unsigned short ws_row ; unsigned short ws_col ; unsigned short ws_xpixel ; unsigned short ws_ypixel ; }; struct termiox { __u16 x_hflag ; __u16 x_cflag ; __u16 x_rflag[5U] ; __u16 x_sflag ; }; struct kernel_symbol { unsigned long value ; char const *name ; }; struct cdev { struct kobject kobj ; struct module *owner ; struct file_operations const *ops ; struct list_head list ; dev_t dev ; unsigned int count ; }; struct tty_struct; struct tty_driver; struct serial_icounter_struct; struct tty_operations { struct tty_struct *(*lookup)(struct tty_driver * , struct inode * , int ) ; int (*install)(struct tty_driver * , struct tty_struct * ) ; void (*remove)(struct tty_driver * , struct tty_struct * ) ; int (*open)(struct tty_struct * , struct file * ) ; void (*close)(struct tty_struct * , struct file * ) ; void (*shutdown)(struct tty_struct * ) ; void (*cleanup)(struct tty_struct * ) ; int (*write)(struct tty_struct * , unsigned char const * , int ) ; int (*put_char)(struct tty_struct * , unsigned char ) ; void (*flush_chars)(struct tty_struct * ) ; int (*write_room)(struct tty_struct * ) ; int (*chars_in_buffer)(struct tty_struct * ) ; int (*ioctl)(struct tty_struct * , unsigned int , unsigned long ) ; long (*compat_ioctl)(struct tty_struct * , unsigned int , unsigned long ) ; void (*set_termios)(struct tty_struct * , struct ktermios * ) ; void (*throttle)(struct tty_struct * ) ; void (*unthrottle)(struct tty_struct * ) ; void (*stop)(struct tty_struct * ) ; void (*start)(struct tty_struct * ) ; void (*hangup)(struct tty_struct * ) ; int (*break_ctl)(struct tty_struct * , int ) ; void (*flush_buffer)(struct tty_struct * ) ; void (*set_ldisc)(struct tty_struct * ) ; void (*wait_until_sent)(struct tty_struct * , int ) ; void (*send_xchar)(struct tty_struct * , char ) ; int (*tiocmget)(struct tty_struct * ) ; int (*tiocmset)(struct tty_struct * , unsigned int , unsigned int ) ; int (*resize)(struct tty_struct * , struct winsize * ) ; int (*set_termiox)(struct tty_struct * , struct termiox * ) ; int (*get_icount)(struct tty_struct * , struct serial_icounter_struct * ) ; int (*poll_init)(struct tty_driver * , int , char * ) ; int (*poll_get_char)(struct tty_driver * , int ) ; void (*poll_put_char)(struct tty_driver * , int , char ) ; struct file_operations const *proc_fops ; }; struct tty_port; struct tty_driver { int magic ; struct kref kref ; struct cdev *cdevs ; struct module *owner ; char const *driver_name ; char const *name ; int name_base ; int major ; int minor_start ; unsigned int num ; short type ; short subtype ; struct ktermios init_termios ; unsigned long flags ; struct proc_dir_entry *proc_entry ; struct tty_driver *other ; struct tty_struct **ttys ; struct tty_port **ports ; struct ktermios **termios ; void *driver_state ; struct tty_operations const *ops ; struct list_head tty_drivers ; }; struct pps_event_time { struct timespec ts_real ; }; struct tty_ldisc_ops { int magic ; char *name ; int num ; int flags ; int (*open)(struct tty_struct * ) ; void (*close)(struct tty_struct * ) ; void (*flush_buffer)(struct tty_struct * ) ; ssize_t (*chars_in_buffer)(struct tty_struct * ) ; ssize_t (*read)(struct tty_struct * , struct file * , unsigned char * , size_t ) ; ssize_t (*write)(struct tty_struct * , struct file * , unsigned char const * , size_t ) ; int (*ioctl)(struct tty_struct * , struct file * , unsigned int , unsigned long ) ; long (*compat_ioctl)(struct tty_struct * , struct file * , unsigned int , unsigned long ) ; void (*set_termios)(struct tty_struct * , struct ktermios * ) ; unsigned int (*poll)(struct tty_struct * , struct file * , struct poll_table_struct * ) ; int (*hangup)(struct tty_struct * ) ; void (*receive_buf)(struct tty_struct * , unsigned char const * , char * , int ) ; void (*write_wakeup)(struct tty_struct * ) ; void (*dcd_change)(struct tty_struct * , unsigned int , struct pps_event_time * ) ; struct module *owner ; int refcount ; }; struct tty_ldisc { struct tty_ldisc_ops *ops ; atomic_t users ; wait_queue_head_t wq_idle ; }; struct tty_buffer { struct tty_buffer *next ; char *char_buf_ptr ; unsigned char *flag_buf_ptr ; int used ; int size ; int commit ; int read ; unsigned long data[0U] ; }; struct tty_bufhead { struct work_struct work ; spinlock_t lock ; struct tty_buffer *head ; struct tty_buffer *tail ; struct tty_buffer *free ; int memory_used ; }; struct signal_struct; struct tty_port_operations { int (*carrier_raised)(struct tty_port * ) ; void (*dtr_rts)(struct tty_port * , int ) ; void (*shutdown)(struct tty_port * ) ; void (*drop)(struct tty_port * ) ; int (*activate)(struct tty_port * , struct tty_struct * ) ; void (*destruct)(struct tty_port * ) ; }; struct tty_port { struct tty_bufhead buf ; struct tty_struct *tty ; struct tty_struct *itty ; struct tty_port_operations const *ops ; spinlock_t lock ; int blocked_open ; int count ; wait_queue_head_t open_wait ; wait_queue_head_t close_wait ; wait_queue_head_t delta_msr_wait ; unsigned long flags ; unsigned long iflags ; unsigned char console : 1 ; struct mutex mutex ; struct mutex buf_mutex ; unsigned char *xmit_buf ; unsigned int close_delay ; unsigned int closing_wait ; int drain_delay ; struct kref kref ; }; struct tty_struct { int magic ; struct kref kref ; struct device *dev ; struct tty_driver *driver ; struct tty_operations const *ops ; int index ; struct mutex ldisc_mutex ; struct tty_ldisc *ldisc ; struct mutex atomic_write_lock ; struct mutex legacy_mutex ; struct mutex termios_mutex ; spinlock_t ctrl_lock ; struct ktermios termios ; struct ktermios termios_locked ; struct termiox *termiox ; char name[64U] ; struct pid *pgrp ; struct pid *session ; unsigned long flags ; int count ; struct winsize winsize ; unsigned char stopped : 1 ; unsigned char hw_stopped : 1 ; unsigned char flow_stopped : 1 ; unsigned char packet : 1 ; unsigned char low_latency : 1 ; unsigned char warned : 1 ; unsigned char ctrl_status ; unsigned int receive_room ; struct tty_struct *link ; struct fasync_struct *fasync ; int alt_speed ; wait_queue_head_t write_wait ; wait_queue_head_t read_wait ; struct work_struct hangup_work ; void *disc_data ; void *driver_data ; struct list_head tty_files ; unsigned char closing : 1 ; unsigned short minimum_to_wake ; unsigned char *write_buf ; int write_cnt ; struct work_struct SAK_work ; struct tty_port *port ; }; struct plist_head { struct list_head node_list ; }; struct plist_node { int prio ; struct list_head prio_list ; struct list_head node_list ; }; struct pm_qos_request { struct plist_node node ; int pm_qos_class ; struct delayed_work work ; }; struct pm_qos_flags_request { struct list_head node ; s32 flags ; }; enum dev_pm_qos_req_type { DEV_PM_QOS_LATENCY = 1, DEV_PM_QOS_FLAGS = 2 } ; union __anonunion_data_178 { struct plist_node pnode ; struct pm_qos_flags_request flr ; }; struct dev_pm_qos_request { enum dev_pm_qos_req_type type ; union __anonunion_data_178 data ; struct device *dev ; }; enum pm_qos_type { PM_QOS_UNITIALIZED = 0, PM_QOS_MAX = 1, PM_QOS_MIN = 2 } ; struct pm_qos_constraints { struct plist_head list ; s32 target_value ; s32 default_value ; enum pm_qos_type type ; struct blocking_notifier_head *notifiers ; }; struct pm_qos_flags { struct list_head list ; s32 effective_flags ; }; struct dev_pm_qos { struct pm_qos_constraints latency ; struct pm_qos_flags flags ; struct dev_pm_qos_request *latency_req ; struct dev_pm_qos_request *flags_req ; }; struct dql { unsigned int num_queued ; unsigned int adj_limit ; unsigned int last_obj_cnt ; unsigned int limit ; unsigned int num_completed ; unsigned int prev_ovlimit ; unsigned int prev_num_queued ; unsigned int prev_last_obj_cnt ; unsigned int lowest_slack ; unsigned long slack_start_time ; unsigned int max_limit ; unsigned int min_limit ; unsigned int slack_hold_time ; }; struct sem_undo_list; struct sysv_sem { struct sem_undo_list *undo_list ; }; struct __anonstruct_sync_serial_settings_179 { unsigned int clock_rate ; unsigned int clock_type ; unsigned short loopback ; }; typedef struct __anonstruct_sync_serial_settings_179 sync_serial_settings; struct __anonstruct_te1_settings_180 { unsigned int clock_rate ; unsigned int clock_type ; unsigned short loopback ; unsigned int slot_map ; }; typedef struct __anonstruct_te1_settings_180 te1_settings; struct __anonstruct_raw_hdlc_proto_181 { unsigned short encoding ; unsigned short parity ; }; typedef struct __anonstruct_raw_hdlc_proto_181 raw_hdlc_proto; struct __anonstruct_fr_proto_182 { unsigned int t391 ; unsigned int t392 ; unsigned int n391 ; unsigned int n392 ; unsigned int n393 ; unsigned short lmi ; unsigned short dce ; }; typedef struct __anonstruct_fr_proto_182 fr_proto; struct __anonstruct_fr_proto_pvc_183 { unsigned int dlci ; }; typedef struct __anonstruct_fr_proto_pvc_183 fr_proto_pvc; struct __anonstruct_fr_proto_pvc_info_184 { unsigned int dlci ; char master[16U] ; }; typedef struct __anonstruct_fr_proto_pvc_info_184 fr_proto_pvc_info; struct __anonstruct_cisco_proto_185 { unsigned int interval ; unsigned int timeout ; }; typedef struct __anonstruct_cisco_proto_185 cisco_proto; struct ifmap { unsigned long mem_start ; unsigned long mem_end ; unsigned short base_addr ; unsigned char irq ; unsigned char dma ; unsigned char port ; }; union __anonunion_ifs_ifsu_186 { raw_hdlc_proto *raw_hdlc ; cisco_proto *cisco ; fr_proto *fr ; fr_proto_pvc *fr_pvc ; fr_proto_pvc_info *fr_pvc_info ; sync_serial_settings *sync ; te1_settings *te1 ; }; struct if_settings { unsigned int type ; unsigned int size ; union __anonunion_ifs_ifsu_186 ifs_ifsu ; }; union __anonunion_ifr_ifrn_187 { char ifrn_name[16U] ; }; union __anonunion_ifr_ifru_188 { struct sockaddr ifru_addr ; struct sockaddr ifru_dstaddr ; struct sockaddr ifru_broadaddr ; struct sockaddr ifru_netmask ; struct sockaddr ifru_hwaddr ; short ifru_flags ; int ifru_ivalue ; int ifru_mtu ; struct ifmap ifru_map ; char ifru_slave[16U] ; char ifru_newname[16U] ; void *ifru_data ; struct if_settings ifru_settings ; }; struct ifreq { union __anonunion_ifr_ifrn_187 ifr_ifrn ; union __anonunion_ifr_ifru_188 ifr_ifru ; }; struct io_event { __u64 data ; __u64 obj ; __s64 res ; __s64 res2 ; }; typedef unsigned long cputime_t; struct seccomp_filter; struct seccomp { int mode ; struct seccomp_filter *filter ; }; struct rt_mutex_waiter; struct rlimit { unsigned long rlim_cur ; unsigned long rlim_max ; }; 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 ctl_table_root; struct ctl_table_header; struct ctl_dir; typedef int proc_handler(struct ctl_table * , int , void * , size_t * , loff_t * ); struct ctl_table_poll { atomic_t event ; wait_queue_head_t wait ; }; struct ctl_table { char const *procname ; void *data ; int maxlen ; umode_t mode ; struct ctl_table *child ; proc_handler *proc_handler ; struct ctl_table_poll *poll ; void *extra1 ; void *extra2 ; }; struct ctl_node { struct rb_node node ; struct ctl_table_header *header ; }; struct __anonstruct_ldv_27864_191 { struct ctl_table *ctl_table ; int used ; int count ; int nreg ; }; union __anonunion_ldv_27866_190 { struct __anonstruct_ldv_27864_191 ldv_27864 ; struct callback_head rcu ; }; struct ctl_table_set; struct ctl_table_header { union __anonunion_ldv_27866_190 ldv_27866 ; struct completion *unregistering ; struct ctl_table *ctl_table_arg ; struct ctl_table_root *root ; struct ctl_table_set *set ; struct ctl_dir *parent ; struct ctl_node *node ; }; struct ctl_dir { struct ctl_table_header header ; struct rb_root root ; }; struct ctl_table_set { int (*is_seen)(struct ctl_table_set * ) ; struct ctl_dir dir ; }; struct ctl_table_root { struct ctl_table_set default_set ; struct ctl_table_set *(*lookup)(struct ctl_table_root * , struct nsproxy * ) ; int (*permissions)(struct ctl_table_header * , struct ctl_table * ) ; }; typedef int32_t key_serial_t; typedef uint32_t key_perm_t; struct key; struct key_type; struct keyring_list; union __anonunion_ldv_27943_192 { struct list_head graveyard_link ; struct rb_node serial_node ; }; struct key_user; union __anonunion_ldv_27952_193 { time_t expiry ; time_t revoked_at ; }; union __anonunion_type_data_194 { struct list_head link ; unsigned long x[2U] ; void *p[2U] ; int reject_error ; }; union __anonunion_payload_195 { unsigned long value ; void *rcudata ; void *data ; struct keyring_list *subscriptions ; }; struct key { atomic_t usage ; key_serial_t serial ; union __anonunion_ldv_27943_192 ldv_27943 ; struct key_type *type ; struct rw_semaphore sem ; struct key_user *user ; void *security ; union __anonunion_ldv_27952_193 ldv_27952 ; time_t last_used_at ; kuid_t uid ; kgid_t gid ; key_perm_t perm ; unsigned short quotalen ; unsigned short datalen ; unsigned long flags ; char *description ; union __anonunion_type_data_194 type_data ; union __anonunion_payload_195 payload ; }; struct audit_context; struct group_info { atomic_t usage ; int ngroups ; int nblocks ; kgid_t small_block[32U] ; kgid_t *blocks[0U] ; }; struct thread_group_cred; 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 ; struct thread_group_cred *tgcred ; void *security ; struct user_struct *user ; struct user_namespace *user_ns ; struct group_info *group_info ; struct callback_head rcu ; }; struct llist_node; struct llist_node { struct llist_node *next ; }; 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 kioctx; union __anonunion_ki_obj_196 { void *user ; struct task_struct *tsk ; }; struct eventfd_ctx; struct kiocb { struct list_head ki_run_list ; unsigned long ki_flags ; int ki_users ; unsigned int ki_key ; struct file *ki_filp ; struct kioctx *ki_ctx ; int (*ki_cancel)(struct kiocb * , struct io_event * ) ; ssize_t (*ki_retry)(struct kiocb * ) ; void (*ki_dtor)(struct kiocb * ) ; union __anonunion_ki_obj_196 ki_obj ; __u64 ki_user_data ; loff_t ki_pos ; void *private ; unsigned short ki_opcode ; size_t ki_nbytes ; char *ki_buf ; size_t ki_left ; struct iovec ki_inline_vec ; struct iovec *ki_iovec ; unsigned long ki_nr_segs ; unsigned long ki_cur_seg ; struct list_head ki_list ; struct list_head ki_batch ; struct eventfd_ctx *ki_eventfd ; }; struct aio_ring_info { unsigned long mmap_base ; unsigned long mmap_size ; struct page **ring_pages ; spinlock_t ring_lock ; long nr_pages ; unsigned int nr ; unsigned int tail ; struct page *internal_pages[8U] ; }; struct kioctx { atomic_t users ; int dead ; struct mm_struct *mm ; unsigned long user_id ; struct hlist_node list ; wait_queue_head_t wait ; spinlock_t ctx_lock ; int reqs_active ; struct list_head active_reqs ; struct list_head run_list ; unsigned int max_reqs ; struct aio_ring_info ring_info ; struct delayed_work wq ; struct callback_head callback_head ; }; 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 taskstats; struct tty_audit_buf; struct signal_struct { atomic_t sigcnt ; atomic_t live ; int nr_threads ; 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 ; 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 ; 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 ; 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 files ; 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 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 ; struct timespec blkio_start ; struct timespec blkio_end ; u64 blkio_delay ; u64 swapin_delay ; u32 blkio_count ; u32 swapin_count ; struct timespec freepages_start ; struct timespec freepages_end ; u64 freepages_delay ; u32 freepages_count ; }; struct uts_namespace; struct rq; struct sched_class { struct sched_class const *next ; void (*enqueue_task)(struct rq * , struct task_struct * , int ) ; void (*dequeue_task)(struct rq * , struct task_struct * , int ) ; void (*yield_task)(struct rq * ) ; bool (*yield_to_task)(struct rq * , struct task_struct * , bool ) ; void (*check_preempt_curr)(struct rq * , struct task_struct * , int ) ; struct task_struct *(*pick_next_task)(struct rq * ) ; void (*put_prev_task)(struct rq * , struct task_struct * ) ; int (*select_task_rq)(struct task_struct * , int , int ) ; void (*migrate_task_rq)(struct task_struct * , int ) ; void (*pre_schedule)(struct rq * , struct task_struct * ) ; void (*post_schedule)(struct rq * ) ; void (*task_waking)(struct task_struct * ) ; void (*task_woken)(struct rq * , struct task_struct * ) ; void (*set_cpus_allowed)(struct task_struct * , struct cpumask const * ) ; void (*rq_online)(struct rq * ) ; void (*rq_offline)(struct rq * ) ; void (*set_curr_task)(struct rq * ) ; void (*task_tick)(struct rq * , struct task_struct * , int ) ; void (*task_fork)(struct task_struct * ) ; void (*switched_from)(struct rq * , struct task_struct * ) ; void (*switched_to)(struct rq * , struct task_struct * ) ; void (*prio_changed)(struct rq * , struct task_struct * , int ) ; unsigned int (*get_rr_interval)(struct rq * , struct task_struct * ) ; void (*task_move_group)(struct task_struct * , int ) ; }; struct load_weight { unsigned long weight ; unsigned long 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 ; 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 int time_slice ; struct sched_rt_entity *back ; struct sched_rt_entity *parent ; struct rt_rq *rt_rq ; struct rt_rq *my_q ; }; struct memcg_batch_info { int do_batch ; struct mem_cgroup *memcg ; unsigned long nr_pages ; unsigned long memsw_nr_pages ; }; struct css_set; struct compat_robust_list_head; 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 ; 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 hlist_head preempt_notifiers ; unsigned char fpu_counter ; unsigned int policy ; int nr_cpus_allowed ; cpumask_t cpus_allowed ; struct sched_info sched_info ; struct list_head tasks ; struct plist_node pushable_tasks ; struct mm_struct *mm ; struct mm_struct *active_mm ; unsigned char brk_randomized : 1 ; int exit_state ; int exit_code ; int exit_signal ; int pdeath_signal ; unsigned int jobctl ; unsigned int personality ; unsigned char did_exec : 1 ; unsigned char in_execve : 1 ; unsigned char in_iowait : 1 ; unsigned char no_new_privs : 1 ; unsigned char sched_reset_on_fork : 1 ; unsigned char sched_contributes_to_load : 1 ; pid_t pid ; pid_t tgid ; unsigned long stack_canary ; 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 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 ; struct timespec start_time ; struct timespec 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 ; 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 plist_head pi_waiters ; 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 ; int numa_migrate_seq ; unsigned int numa_scan_period ; u64 node_stamp ; struct callback_head numa_work ; 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 long trace ; unsigned long trace_recursion ; struct memcg_batch_info memcg_batch ; unsigned int memcg_kmem_skip_account ; atomic_t ptrace_bp_refcnt ; struct uprobe_task *utask ; }; typedef s32 compat_long_t; typedef u32 compat_uptr_t; struct compat_robust_list { compat_uptr_t next ; }; struct compat_robust_list_head { struct compat_robust_list list ; compat_long_t futex_offset ; compat_uptr_t list_op_pending ; }; struct ethhdr { unsigned char h_dest[6U] ; unsigned char h_source[6U] ; __be16 h_proto ; }; struct ethtool_cmd { __u32 cmd ; __u32 supported ; __u32 advertising ; __u16 speed ; __u8 duplex ; __u8 port ; __u8 phy_address ; __u8 transceiver ; __u8 autoneg ; __u8 mdio_support ; __u32 maxtxpkt ; __u32 maxrxpkt ; __u16 speed_hi ; __u8 eth_tp_mdix ; __u8 eth_tp_mdix_ctrl ; __u32 lp_advertising ; __u32 reserved[2U] ; }; struct ethtool_drvinfo { __u32 cmd ; char driver[32U] ; char version[32U] ; char fw_version[32U] ; char bus_info[32U] ; char reserved1[32U] ; char reserved2[12U] ; __u32 n_priv_flags ; __u32 n_stats ; __u32 testinfo_len ; __u32 eedump_len ; __u32 regdump_len ; }; struct ethtool_wolinfo { __u32 cmd ; __u32 supported ; __u32 wolopts ; __u8 sopass[6U] ; }; struct ethtool_regs { __u32 cmd ; __u32 version ; __u32 len ; __u8 data[0U] ; }; struct ethtool_eeprom { __u32 cmd ; __u32 magic ; __u32 offset ; __u32 len ; __u8 data[0U] ; }; struct ethtool_eee { __u32 cmd ; __u32 supported ; __u32 advertised ; __u32 lp_advertised ; __u32 eee_active ; __u32 eee_enabled ; __u32 tx_lpi_enabled ; __u32 tx_lpi_timer ; __u32 reserved[2U] ; }; struct ethtool_modinfo { __u32 cmd ; __u32 type ; __u32 eeprom_len ; __u32 reserved[8U] ; }; struct ethtool_coalesce { __u32 cmd ; __u32 rx_coalesce_usecs ; __u32 rx_max_coalesced_frames ; __u32 rx_coalesce_usecs_irq ; __u32 rx_max_coalesced_frames_irq ; __u32 tx_coalesce_usecs ; __u32 tx_max_coalesced_frames ; __u32 tx_coalesce_usecs_irq ; __u32 tx_max_coalesced_frames_irq ; __u32 stats_block_coalesce_usecs ; __u32 use_adaptive_rx_coalesce ; __u32 use_adaptive_tx_coalesce ; __u32 pkt_rate_low ; __u32 rx_coalesce_usecs_low ; __u32 rx_max_coalesced_frames_low ; __u32 tx_coalesce_usecs_low ; __u32 tx_max_coalesced_frames_low ; __u32 pkt_rate_high ; __u32 rx_coalesce_usecs_high ; __u32 rx_max_coalesced_frames_high ; __u32 tx_coalesce_usecs_high ; __u32 tx_max_coalesced_frames_high ; __u32 rate_sample_interval ; }; struct ethtool_ringparam { __u32 cmd ; __u32 rx_max_pending ; __u32 rx_mini_max_pending ; __u32 rx_jumbo_max_pending ; __u32 tx_max_pending ; __u32 rx_pending ; __u32 rx_mini_pending ; __u32 rx_jumbo_pending ; __u32 tx_pending ; }; struct ethtool_channels { __u32 cmd ; __u32 max_rx ; __u32 max_tx ; __u32 max_other ; __u32 max_combined ; __u32 rx_count ; __u32 tx_count ; __u32 other_count ; __u32 combined_count ; }; struct ethtool_pauseparam { __u32 cmd ; __u32 autoneg ; __u32 rx_pause ; __u32 tx_pause ; }; struct ethtool_test { __u32 cmd ; __u32 flags ; __u32 reserved ; __u32 len ; __u64 data[0U] ; }; struct ethtool_stats { __u32 cmd ; __u32 n_stats ; __u64 data[0U] ; }; struct ethtool_tcpip4_spec { __be32 ip4src ; __be32 ip4dst ; __be16 psrc ; __be16 pdst ; __u8 tos ; }; struct ethtool_ah_espip4_spec { __be32 ip4src ; __be32 ip4dst ; __be32 spi ; __u8 tos ; }; struct ethtool_usrip4_spec { __be32 ip4src ; __be32 ip4dst ; __be32 l4_4_bytes ; __u8 tos ; __u8 ip_ver ; __u8 proto ; }; union ethtool_flow_union { struct ethtool_tcpip4_spec tcp_ip4_spec ; struct ethtool_tcpip4_spec udp_ip4_spec ; struct ethtool_tcpip4_spec sctp_ip4_spec ; struct ethtool_ah_espip4_spec ah_ip4_spec ; struct ethtool_ah_espip4_spec esp_ip4_spec ; struct ethtool_usrip4_spec usr_ip4_spec ; struct ethhdr ether_spec ; __u8 hdata[52U] ; }; struct ethtool_flow_ext { __u8 padding[2U] ; unsigned char h_dest[6U] ; __be16 vlan_etype ; __be16 vlan_tci ; __be32 data[2U] ; }; struct ethtool_rx_flow_spec { __u32 flow_type ; union ethtool_flow_union h_u ; struct ethtool_flow_ext h_ext ; union ethtool_flow_union m_u ; struct ethtool_flow_ext m_ext ; __u64 ring_cookie ; __u32 location ; }; struct ethtool_rxnfc { __u32 cmd ; __u32 flow_type ; __u64 data ; struct ethtool_rx_flow_spec fs ; __u32 rule_cnt ; __u32 rule_locs[0U] ; }; struct ethtool_flash { __u32 cmd ; __u32 region ; char data[128U] ; }; struct ethtool_dump { __u32 cmd ; __u32 version ; __u32 flag ; __u32 len ; __u8 data[0U] ; }; struct ethtool_ts_info { __u32 cmd ; __u32 so_timestamping ; __s32 phc_index ; __u32 tx_types ; __u32 tx_reserved[3U] ; __u32 rx_filters ; __u32 rx_reserved[3U] ; }; enum ethtool_phys_id_state { ETHTOOL_ID_INACTIVE = 0, ETHTOOL_ID_ACTIVE = 1, ETHTOOL_ID_ON = 2, ETHTOOL_ID_OFF = 3 } ; struct ethtool_ops { int (*get_settings)(struct net_device * , struct ethtool_cmd * ) ; int (*set_settings)(struct net_device * , struct ethtool_cmd * ) ; void (*get_drvinfo)(struct net_device * , struct ethtool_drvinfo * ) ; int (*get_regs_len)(struct net_device * ) ; void (*get_regs)(struct net_device * , struct ethtool_regs * , void * ) ; void (*get_wol)(struct net_device * , struct ethtool_wolinfo * ) ; int (*set_wol)(struct net_device * , struct ethtool_wolinfo * ) ; u32 (*get_msglevel)(struct net_device * ) ; void (*set_msglevel)(struct net_device * , u32 ) ; int (*nway_reset)(struct net_device * ) ; u32 (*get_link)(struct net_device * ) ; int (*get_eeprom_len)(struct net_device * ) ; int (*get_eeprom)(struct net_device * , struct ethtool_eeprom * , u8 * ) ; int (*set_eeprom)(struct net_device * , struct ethtool_eeprom * , u8 * ) ; int (*get_coalesce)(struct net_device * , struct ethtool_coalesce * ) ; int (*set_coalesce)(struct net_device * , struct ethtool_coalesce * ) ; void (*get_ringparam)(struct net_device * , struct ethtool_ringparam * ) ; int (*set_ringparam)(struct net_device * , struct ethtool_ringparam * ) ; void (*get_pauseparam)(struct net_device * , struct ethtool_pauseparam * ) ; int (*set_pauseparam)(struct net_device * , struct ethtool_pauseparam * ) ; void (*self_test)(struct net_device * , struct ethtool_test * , u64 * ) ; void (*get_strings)(struct net_device * , u32 , u8 * ) ; int (*set_phys_id)(struct net_device * , enum ethtool_phys_id_state ) ; void (*get_ethtool_stats)(struct net_device * , struct ethtool_stats * , u64 * ) ; int (*begin)(struct net_device * ) ; void (*complete)(struct net_device * ) ; u32 (*get_priv_flags)(struct net_device * ) ; int (*set_priv_flags)(struct net_device * , u32 ) ; int (*get_sset_count)(struct net_device * , int ) ; int (*get_rxnfc)(struct net_device * , struct ethtool_rxnfc * , u32 * ) ; int (*set_rxnfc)(struct net_device * , struct ethtool_rxnfc * ) ; int (*flash_device)(struct net_device * , struct ethtool_flash * ) ; int (*reset)(struct net_device * , u32 * ) ; u32 (*get_rxfh_indir_size)(struct net_device * ) ; int (*get_rxfh_indir)(struct net_device * , u32 * ) ; int (*set_rxfh_indir)(struct net_device * , u32 const * ) ; void (*get_channels)(struct net_device * , struct ethtool_channels * ) ; int (*set_channels)(struct net_device * , struct ethtool_channels * ) ; int (*get_dump_flag)(struct net_device * , struct ethtool_dump * ) ; int (*get_dump_data)(struct net_device * , struct ethtool_dump * , void * ) ; int (*set_dump)(struct net_device * , struct ethtool_dump * ) ; int (*get_ts_info)(struct net_device * , struct ethtool_ts_info * ) ; int (*get_module_info)(struct net_device * , struct ethtool_modinfo * ) ; int (*get_module_eeprom)(struct net_device * , struct ethtool_eeprom * , u8 * ) ; int (*get_eee)(struct net_device * , struct ethtool_eee * ) ; int (*set_eee)(struct net_device * , struct ethtool_eee * ) ; }; struct prot_inuse; struct netns_core { struct ctl_table_header *sysctl_hdr ; int sysctl_somaxconn ; struct prot_inuse *inuse ; }; struct u64_stats_sync { }; struct ipstats_mib { u64 mibs[31U] ; struct u64_stats_sync syncp ; }; struct icmp_mib { unsigned long mibs[27U] ; }; struct icmpmsg_mib { atomic_long_t mibs[512U] ; }; struct icmpv6_mib { unsigned long mibs[5U] ; }; struct icmpv6msg_mib { atomic_long_t mibs[512U] ; }; struct tcp_mib { unsigned long mibs[15U] ; }; struct udp_mib { unsigned long mibs[7U] ; }; struct linux_mib { unsigned long mibs[92U] ; }; struct linux_xfrm_mib { unsigned long mibs[27U] ; }; struct netns_mib { struct tcp_mib *tcp_statistics[1U] ; struct ipstats_mib *ip_statistics[1U] ; struct linux_mib *net_statistics[1U] ; struct udp_mib *udp_statistics[1U] ; struct udp_mib *udplite_statistics[1U] ; struct icmp_mib *icmp_statistics[1U] ; struct icmpmsg_mib *icmpmsg_statistics ; struct proc_dir_entry *proc_net_devsnmp6 ; struct udp_mib *udp_stats_in6[1U] ; struct udp_mib *udplite_stats_in6[1U] ; struct ipstats_mib *ipv6_statistics[1U] ; struct icmpv6_mib *icmpv6_statistics[1U] ; struct icmpv6msg_mib *icmpv6msg_statistics ; struct linux_xfrm_mib *xfrm_statistics[1U] ; }; struct netns_unix { int sysctl_max_dgram_qlen ; struct ctl_table_header *ctl ; }; struct netns_packet { struct mutex sklist_lock ; struct hlist_head sklist ; }; struct netns_frags { int nqueues ; atomic_t mem ; struct list_head lru_list ; int timeout ; int high_thresh ; int low_thresh ; }; struct tcpm_hash_bucket; struct ipv4_devconf; struct fib_rules_ops; struct fib_table; struct inet_peer_base; struct xt_table; struct netns_ipv4 { struct ctl_table_header *forw_hdr ; struct ctl_table_header *frags_hdr ; struct ctl_table_header *ipv4_hdr ; struct ctl_table_header *route_hdr ; struct ipv4_devconf *devconf_all ; struct ipv4_devconf *devconf_dflt ; struct fib_rules_ops *rules_ops ; bool fib_has_custom_rules ; struct fib_table *fib_local ; struct fib_table *fib_main ; struct fib_table *fib_default ; int fib_num_tclassid_users ; struct hlist_head *fib_table_hash ; struct sock *fibnl ; struct sock **icmp_sk ; struct inet_peer_base *peers ; struct tcpm_hash_bucket *tcp_metrics_hash ; unsigned int tcp_metrics_hash_log ; struct netns_frags frags ; struct xt_table *iptable_filter ; struct xt_table *iptable_mangle ; struct xt_table *iptable_raw ; struct xt_table *arptable_filter ; struct xt_table *iptable_security ; struct xt_table *nat_table ; int sysctl_icmp_echo_ignore_all ; int sysctl_icmp_echo_ignore_broadcasts ; int sysctl_icmp_ignore_bogus_error_responses ; int sysctl_icmp_ratelimit ; int sysctl_icmp_ratemask ; int sysctl_icmp_errors_use_inbound_ifaddr ; kgid_t sysctl_ping_group_range[2U] ; long sysctl_tcp_mem[3U] ; atomic_t dev_addr_genid ; struct list_head mr_tables ; struct fib_rules_ops *mr_rules_ops ; }; struct neighbour; struct dst_ops { unsigned short family ; __be16 protocol ; unsigned int gc_thresh ; int (*gc)(struct dst_ops * ) ; struct dst_entry *(*check)(struct dst_entry * , __u32 ) ; unsigned int (*default_advmss)(struct dst_entry const * ) ; unsigned int (*mtu)(struct dst_entry const * ) ; u32 *(*cow_metrics)(struct dst_entry * , unsigned long ) ; void (*destroy)(struct dst_entry * ) ; void (*ifdown)(struct dst_entry * , struct net_device * , int ) ; struct dst_entry *(*negative_advice)(struct dst_entry * ) ; void (*link_failure)(struct sk_buff * ) ; void (*update_pmtu)(struct dst_entry * , struct sock * , struct sk_buff * , u32 ) ; void (*redirect)(struct dst_entry * , struct sock * , struct sk_buff * ) ; int (*local_out)(struct sk_buff * ) ; struct neighbour *(*neigh_lookup)(struct dst_entry const * , struct sk_buff * , void const * ) ; struct kmem_cache *kmem_cachep ; struct percpu_counter pcpuc_entries ; }; struct netns_sysctl_ipv6 { struct ctl_table_header *hdr ; struct ctl_table_header *route_hdr ; struct ctl_table_header *icmp_hdr ; struct ctl_table_header *frags_hdr ; int bindv6only ; int flush_delay ; int ip6_rt_max_size ; int ip6_rt_gc_min_interval ; int ip6_rt_gc_timeout ; int ip6_rt_gc_interval ; int ip6_rt_gc_elasticity ; int ip6_rt_mtu_expires ; int ip6_rt_min_advmss ; int icmpv6_time ; }; struct ipv6_devconf; struct rt6_info; struct rt6_statistics; struct fib6_table; struct netns_ipv6 { struct netns_sysctl_ipv6 sysctl ; struct ipv6_devconf *devconf_all ; struct ipv6_devconf *devconf_dflt ; struct inet_peer_base *peers ; struct netns_frags frags ; struct xt_table *ip6table_filter ; struct xt_table *ip6table_mangle ; struct xt_table *ip6table_raw ; struct xt_table *ip6table_security ; struct xt_table *ip6table_nat ; struct rt6_info *ip6_null_entry ; struct rt6_statistics *rt6_stats ; struct timer_list ip6_fib_timer ; struct hlist_head *fib_table_hash ; struct fib6_table *fib6_main_tbl ; struct dst_ops ip6_dst_ops ; unsigned int ip6_rt_gc_expire ; unsigned long ip6_rt_last_gc ; struct rt6_info *ip6_prohibit_entry ; struct rt6_info *ip6_blk_hole_entry ; struct fib6_table *fib6_local_tbl ; struct fib_rules_ops *fib6_rules_ops ; struct sock **icmp_sk ; struct sock *ndisc_sk ; struct sock *tcp_sk ; struct sock *igmp_sk ; struct list_head mr6_tables ; struct fib_rules_ops *mr6_rules_ops ; }; struct netns_nf_frag { struct netns_sysctl_ipv6 sysctl ; struct netns_frags frags ; }; struct sctp_mib; struct netns_sctp { struct sctp_mib *sctp_statistics[1U] ; struct proc_dir_entry *proc_net_sctp ; struct ctl_table_header *sysctl_header ; struct sock *ctl_sock ; struct list_head local_addr_list ; struct list_head addr_waitq ; struct timer_list addr_wq_timer ; struct list_head auto_asconf_splist ; spinlock_t addr_wq_lock ; spinlock_t local_addr_lock ; unsigned int rto_initial ; unsigned int rto_min ; unsigned int rto_max ; int rto_alpha ; int rto_beta ; int max_burst ; int cookie_preserve_enable ; char *sctp_hmac_alg ; unsigned int valid_cookie_life ; unsigned int sack_timeout ; unsigned int hb_interval ; int max_retrans_association ; int max_retrans_path ; int max_retrans_init ; int pf_retrans ; int sndbuf_policy ; int rcvbuf_policy ; int default_auto_asconf ; int addip_enable ; int addip_noauth ; int prsctp_enable ; int auth_enable ; int scope_policy ; int rwnd_upd_shift ; unsigned long max_autoclose ; }; struct netns_dccp { struct sock *v4_ctl_sk ; struct sock *v6_ctl_sk ; }; struct static_key { atomic_t enabled ; }; typedef int read_proc_t(char * , char ** , off_t , int , int * , void * ); typedef int write_proc_t(struct file * , char const * , unsigned long , void * ); struct proc_dir_entry { unsigned int low_ino ; umode_t mode ; nlink_t nlink ; kuid_t uid ; kgid_t gid ; loff_t size ; struct inode_operations const *proc_iops ; struct file_operations const *proc_fops ; struct proc_dir_entry *next ; struct proc_dir_entry *parent ; struct proc_dir_entry *subdir ; void *data ; read_proc_t *read_proc ; write_proc_t *write_proc ; atomic_t count ; int pde_users ; struct completion *pde_unload_completion ; struct list_head pde_openers ; spinlock_t pde_unload_lock ; u8 namelen ; char name[] ; }; struct nlattr; struct ebt_table; struct netns_xt { struct list_head tables[13U] ; struct ebt_table *broute_table ; struct ebt_table *frame_filter ; struct ebt_table *frame_nat ; }; struct hlist_nulls_node; struct hlist_nulls_head { struct hlist_nulls_node *first ; }; struct hlist_nulls_node { struct hlist_nulls_node *next ; struct hlist_nulls_node **pprev ; }; struct nf_proto_net { struct ctl_table_header *ctl_table_header ; struct ctl_table *ctl_table ; struct ctl_table_header *ctl_compat_header ; struct ctl_table *ctl_compat_table ; unsigned int users ; }; struct nf_generic_net { struct nf_proto_net pn ; unsigned int timeout ; }; struct nf_tcp_net { struct nf_proto_net pn ; unsigned int timeouts[14U] ; unsigned int tcp_loose ; unsigned int tcp_be_liberal ; unsigned int tcp_max_retrans ; }; struct nf_udp_net { struct nf_proto_net pn ; unsigned int timeouts[2U] ; }; struct nf_icmp_net { struct nf_proto_net pn ; unsigned int timeout ; }; struct nf_ip_net { struct nf_generic_net generic ; struct nf_tcp_net tcp ; struct nf_udp_net udp ; struct nf_icmp_net icmp ; struct nf_icmp_net icmpv6 ; struct ctl_table_header *ctl_table_header ; struct ctl_table *ctl_table ; }; struct ip_conntrack_stat; struct nf_ct_event_notifier; struct nf_exp_event_notifier; struct netns_ct { atomic_t count ; unsigned int expect_count ; unsigned int htable_size ; struct kmem_cache *nf_conntrack_cachep ; struct hlist_nulls_head *hash ; struct hlist_head *expect_hash ; struct hlist_nulls_head unconfirmed ; struct hlist_nulls_head dying ; struct ip_conntrack_stat *stat ; struct nf_ct_event_notifier *nf_conntrack_event_cb ; struct nf_exp_event_notifier *nf_expect_event_cb ; int sysctl_events ; unsigned int sysctl_events_retry_timeout ; int sysctl_acct ; int sysctl_tstamp ; int sysctl_checksum ; unsigned int sysctl_log_invalid ; int sysctl_auto_assign_helper ; bool auto_assign_helper_warned ; struct nf_ip_net nf_ct_proto ; struct hlist_head *nat_bysource ; unsigned int nat_htable_size ; struct ctl_table_header *sysctl_header ; struct ctl_table_header *acct_sysctl_header ; struct ctl_table_header *tstamp_sysctl_header ; struct ctl_table_header *event_sysctl_header ; struct ctl_table_header *helper_sysctl_header ; char *slabname ; }; struct xfrm_policy_hash { struct hlist_head *table ; unsigned int hmask ; }; struct netns_xfrm { struct list_head state_all ; struct hlist_head *state_bydst ; struct hlist_head *state_bysrc ; struct hlist_head *state_byspi ; unsigned int state_hmask ; unsigned int state_num ; struct work_struct state_hash_work ; struct hlist_head state_gc_list ; struct work_struct state_gc_work ; wait_queue_head_t km_waitq ; struct list_head policy_all ; struct hlist_head *policy_byidx ; unsigned int policy_idx_hmask ; struct hlist_head policy_inexact[6U] ; struct xfrm_policy_hash policy_bydst[6U] ; unsigned int policy_count[6U] ; struct work_struct policy_hash_work ; struct sock *nlsk ; struct sock *nlsk_stash ; u32 sysctl_aevent_etime ; u32 sysctl_aevent_rseqth ; int sysctl_larval_drop ; u32 sysctl_acq_expires ; struct ctl_table_header *sysctl_hdr ; struct dst_ops xfrm4_dst_ops ; struct dst_ops xfrm6_dst_ops ; }; struct net_generic; struct netns_ipvs; struct net { atomic_t passive ; atomic_t count ; spinlock_t rules_mod_lock ; struct list_head list ; struct list_head cleanup_list ; struct list_head exit_list ; struct user_namespace *user_ns ; unsigned int proc_inum ; struct proc_dir_entry *proc_net ; struct proc_dir_entry *proc_net_stat ; struct ctl_table_set sysctls ; struct sock *rtnl ; struct sock *genl_sock ; struct list_head dev_base_head ; struct hlist_head *dev_name_head ; struct hlist_head *dev_index_head ; unsigned int dev_base_seq ; int ifindex ; struct list_head rules_ops ; struct net_device *loopback_dev ; struct netns_core core ; struct netns_mib mib ; struct netns_packet packet ; struct netns_unix unx ; struct netns_ipv4 ipv4 ; struct netns_ipv6 ipv6 ; struct netns_sctp sctp ; struct netns_dccp dccp ; struct netns_xt xt ; struct netns_ct ct ; struct netns_nf_frag nf_frag ; struct sock *nfnl ; struct sock *nfnl_stash ; struct sk_buff_head wext_nlevents ; struct net_generic *gen ; struct netns_xfrm xfrm ; struct netns_ipvs *ipvs ; struct sock *diag_nlsk ; atomic_t rt_genid ; }; struct seq_file { char *buf ; size_t size ; size_t from ; size_t count ; loff_t index ; loff_t read_pos ; u64 version ; struct mutex lock ; struct seq_operations const *op ; int poll_event ; 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 dsa_chip_data { struct device *mii_bus ; int sw_addr ; char *port_names[12U] ; s8 *rtable ; }; struct dsa_platform_data { struct device *netdev ; int nr_chips ; struct dsa_chip_data *chip ; }; struct dsa_switch; struct dsa_switch_tree { struct dsa_platform_data *pd ; struct net_device *master_netdev ; __be16 tag_protocol ; s8 cpu_switch ; s8 cpu_port ; int link_poll_needed ; struct work_struct link_poll_work ; struct timer_list link_poll_timer ; struct dsa_switch *ds[4U] ; }; struct dsa_switch_driver; struct mii_bus; struct dsa_switch { struct dsa_switch_tree *dst ; int index ; struct dsa_chip_data *pd ; struct dsa_switch_driver *drv ; struct mii_bus *master_mii_bus ; u32 dsa_port_mask ; u32 phys_port_mask ; struct mii_bus *slave_mii_bus ; struct net_device *ports[12U] ; }; struct dsa_switch_driver { struct list_head list ; __be16 tag_protocol ; int priv_size ; char *(*probe)(struct mii_bus * , int ) ; int (*setup)(struct dsa_switch * ) ; int (*set_addr)(struct dsa_switch * , u8 * ) ; int (*phy_read)(struct dsa_switch * , int , int ) ; int (*phy_write)(struct dsa_switch * , int , int , u16 ) ; void (*poll_link)(struct dsa_switch * ) ; void (*get_strings)(struct dsa_switch * , int , uint8_t * ) ; void (*get_ethtool_stats)(struct dsa_switch * , int , uint64_t * ) ; int (*get_sset_count)(struct dsa_switch * ) ; }; struct ieee_ets { __u8 willing ; __u8 ets_cap ; __u8 cbs ; __u8 tc_tx_bw[8U] ; __u8 tc_rx_bw[8U] ; __u8 tc_tsa[8U] ; __u8 prio_tc[8U] ; __u8 tc_reco_bw[8U] ; __u8 tc_reco_tsa[8U] ; __u8 reco_prio_tc[8U] ; }; struct ieee_maxrate { __u64 tc_maxrate[8U] ; }; struct ieee_pfc { __u8 pfc_cap ; __u8 pfc_en ; __u8 mbc ; __u16 delay ; __u64 requests[8U] ; __u64 indications[8U] ; }; struct cee_pg { __u8 willing ; __u8 error ; __u8 pg_en ; __u8 tcs_supported ; __u8 pg_bw[8U] ; __u8 prio_pg[8U] ; }; struct cee_pfc { __u8 willing ; __u8 error ; __u8 pfc_en ; __u8 tcs_supported ; }; struct dcb_app { __u8 selector ; __u8 priority ; __u16 protocol ; }; struct dcb_peer_app_info { __u8 willing ; __u8 error ; }; struct dcbnl_rtnl_ops { int (*ieee_getets)(struct net_device * , struct ieee_ets * ) ; int (*ieee_setets)(struct net_device * , struct ieee_ets * ) ; int (*ieee_getmaxrate)(struct net_device * , struct ieee_maxrate * ) ; int (*ieee_setmaxrate)(struct net_device * , struct ieee_maxrate * ) ; int (*ieee_getpfc)(struct net_device * , struct ieee_pfc * ) ; int (*ieee_setpfc)(struct net_device * , struct ieee_pfc * ) ; int (*ieee_getapp)(struct net_device * , struct dcb_app * ) ; int (*ieee_setapp)(struct net_device * , struct dcb_app * ) ; int (*ieee_delapp)(struct net_device * , struct dcb_app * ) ; int (*ieee_peer_getets)(struct net_device * , struct ieee_ets * ) ; int (*ieee_peer_getpfc)(struct net_device * , struct ieee_pfc * ) ; u8 (*getstate)(struct net_device * ) ; u8 (*setstate)(struct net_device * , u8 ) ; void (*getpermhwaddr)(struct net_device * , u8 * ) ; void (*setpgtccfgtx)(struct net_device * , int , u8 , u8 , u8 , u8 ) ; void (*setpgbwgcfgtx)(struct net_device * , int , u8 ) ; void (*setpgtccfgrx)(struct net_device * , int , u8 , u8 , u8 , u8 ) ; void (*setpgbwgcfgrx)(struct net_device * , int , u8 ) ; void (*getpgtccfgtx)(struct net_device * , int , u8 * , u8 * , u8 * , u8 * ) ; void (*getpgbwgcfgtx)(struct net_device * , int , u8 * ) ; void (*getpgtccfgrx)(struct net_device * , int , u8 * , u8 * , u8 * , u8 * ) ; void (*getpgbwgcfgrx)(struct net_device * , int , u8 * ) ; void (*setpfccfg)(struct net_device * , int , u8 ) ; void (*getpfccfg)(struct net_device * , int , u8 * ) ; u8 (*setall)(struct net_device * ) ; u8 (*getcap)(struct net_device * , int , u8 * ) ; int (*getnumtcs)(struct net_device * , int , u8 * ) ; int (*setnumtcs)(struct net_device * , int , u8 ) ; u8 (*getpfcstate)(struct net_device * ) ; void (*setpfcstate)(struct net_device * , u8 ) ; void (*getbcncfg)(struct net_device * , int , u32 * ) ; void (*setbcncfg)(struct net_device * , int , u32 ) ; void (*getbcnrp)(struct net_device * , int , u8 * ) ; void (*setbcnrp)(struct net_device * , int , u8 ) ; u8 (*setapp)(struct net_device * , u8 , u16 , u8 ) ; u8 (*getapp)(struct net_device * , u8 , u16 ) ; u8 (*getfeatcfg)(struct net_device * , int , u8 * ) ; u8 (*setfeatcfg)(struct net_device * , int , u8 ) ; u8 (*getdcbx)(struct net_device * ) ; u8 (*setdcbx)(struct net_device * , u8 ) ; int (*peer_getappinfo)(struct net_device * , struct dcb_peer_app_info * , u16 * ) ; int (*peer_getapptable)(struct net_device * , struct dcb_app * ) ; int (*cee_peer_getpg)(struct net_device * , struct cee_pg * ) ; int (*cee_peer_getpfc)(struct net_device * , struct cee_pfc * ) ; }; struct taskstats { __u16 version ; __u32 ac_exitcode ; __u8 ac_flag ; __u8 ac_nice ; __u64 cpu_count ; __u64 cpu_delay_total ; __u64 blkio_count ; __u64 blkio_delay_total ; __u64 swapin_count ; __u64 swapin_delay_total ; __u64 cpu_run_real_total ; __u64 cpu_run_virtual_total ; char ac_comm[32U] ; __u8 ac_sched ; __u8 ac_pad[3U] ; __u32 ac_uid ; __u32 ac_gid ; __u32 ac_pid ; __u32 ac_ppid ; __u32 ac_btime ; __u64 ac_etime ; __u64 ac_utime ; __u64 ac_stime ; __u64 ac_minflt ; __u64 ac_majflt ; __u64 coremem ; __u64 virtmem ; __u64 hiwater_rss ; __u64 hiwater_vm ; __u64 read_char ; __u64 write_char ; __u64 read_syscalls ; __u64 write_syscalls ; __u64 read_bytes ; __u64 write_bytes ; __u64 cancelled_write_bytes ; __u64 nvcsw ; __u64 nivcsw ; __u64 ac_utimescaled ; __u64 ac_stimescaled ; __u64 cpu_scaled_run_real_total ; __u64 freepages_count ; __u64 freepages_delay_total ; }; struct xattr_handler { char const *prefix ; int flags ; size_t (*list)(struct dentry * , char * , size_t , char const * , size_t , int ) ; int (*get)(struct dentry * , char const * , void * , size_t , int ) ; int (*set)(struct dentry * , char const * , void const * , size_t , int , int ) ; }; struct simple_xattrs { struct list_head head ; spinlock_t lock ; }; struct cgroupfs_root; struct cgroup; struct css_id; struct cgroup_subsys_state { struct cgroup *cgroup ; atomic_t refcnt ; unsigned long flags ; struct css_id *id ; struct work_struct dput_work ; }; struct cgroup { unsigned long flags ; atomic_t count ; int id ; struct list_head sibling ; struct list_head children ; struct list_head files ; struct cgroup *parent ; struct dentry *dentry ; struct cgroup_subsys_state *subsys[12U] ; struct cgroupfs_root *root ; struct cgroup *top_cgroup ; struct list_head css_sets ; struct list_head allcg_node ; struct list_head cft_q_node ; struct list_head release_list ; struct list_head pidlists ; struct mutex pidlist_mutex ; struct callback_head callback_head ; struct list_head event_list ; spinlock_t event_list_lock ; struct simple_xattrs xattrs ; }; struct css_set { atomic_t refcount ; struct hlist_node hlist ; struct list_head tasks ; struct list_head cg_links ; struct cgroup_subsys_state *subsys[12U] ; struct callback_head callback_head ; }; struct netprio_map { struct callback_head rcu ; u32 priomap_len ; u32 priomap[] ; }; struct mnt_namespace; struct ipc_namespace; struct nsproxy { atomic_t count ; struct uts_namespace *uts_ns ; struct ipc_namespace *ipc_ns ; struct mnt_namespace *mnt_ns ; struct pid_namespace *pid_ns ; struct net *net_ns ; }; struct nlmsghdr { __u32 nlmsg_len ; __u16 nlmsg_type ; __u16 nlmsg_flags ; __u32 nlmsg_seq ; __u32 nlmsg_pid ; }; struct nlattr { __u16 nla_len ; __u16 nla_type ; }; struct netlink_callback { struct sk_buff *skb ; struct nlmsghdr const *nlh ; int (*dump)(struct sk_buff * , struct netlink_callback * ) ; int (*done)(struct netlink_callback * ) ; void *data ; struct module *module ; u16 family ; u16 min_dump_alloc ; unsigned int prev_seq ; unsigned int seq ; long args[6U] ; }; struct ndmsg { __u8 ndm_family ; __u8 ndm_pad1 ; __u16 ndm_pad2 ; __s32 ndm_ifindex ; __u16 ndm_state ; __u8 ndm_flags ; __u8 ndm_type ; }; struct rtnl_link_stats64 { __u64 rx_packets ; __u64 tx_packets ; __u64 rx_bytes ; __u64 tx_bytes ; __u64 rx_errors ; __u64 tx_errors ; __u64 rx_dropped ; __u64 tx_dropped ; __u64 multicast ; __u64 collisions ; __u64 rx_length_errors ; __u64 rx_over_errors ; __u64 rx_crc_errors ; __u64 rx_frame_errors ; __u64 rx_fifo_errors ; __u64 rx_missed_errors ; __u64 tx_aborted_errors ; __u64 tx_carrier_errors ; __u64 tx_fifo_errors ; __u64 tx_heartbeat_errors ; __u64 tx_window_errors ; __u64 rx_compressed ; __u64 tx_compressed ; }; struct ifla_vf_info { __u32 vf ; __u8 mac[32U] ; __u32 vlan ; __u32 qos ; __u32 tx_rate ; __u32 spoofchk ; }; struct netpoll_info; struct phy_device; struct wireless_dev; enum netdev_tx { __NETDEV_TX_MIN = (-0x7FFFFFFF-1), NETDEV_TX_OK = 0, NETDEV_TX_BUSY = 16, NETDEV_TX_LOCKED = 32 } ; typedef enum netdev_tx netdev_tx_t; struct net_device_stats { unsigned long rx_packets ; unsigned long tx_packets ; unsigned long rx_bytes ; unsigned long tx_bytes ; unsigned long rx_errors ; unsigned long tx_errors ; unsigned long rx_dropped ; unsigned long tx_dropped ; unsigned long multicast ; unsigned long collisions ; unsigned long rx_length_errors ; unsigned long rx_over_errors ; unsigned long rx_crc_errors ; unsigned long rx_frame_errors ; unsigned long rx_fifo_errors ; unsigned long rx_missed_errors ; unsigned long tx_aborted_errors ; unsigned long tx_carrier_errors ; unsigned long tx_fifo_errors ; unsigned long tx_heartbeat_errors ; unsigned long tx_window_errors ; unsigned long rx_compressed ; unsigned long tx_compressed ; }; struct neigh_parms; struct netdev_hw_addr_list { struct list_head list ; int count ; }; struct hh_cache { u16 hh_len ; u16 __pad ; seqlock_t hh_lock ; unsigned long hh_data[16U] ; }; struct header_ops { int (*create)(struct sk_buff * , struct net_device * , unsigned short , void const * , void const * , unsigned int ) ; int (*parse)(struct sk_buff const * , unsigned char * ) ; int (*rebuild)(struct sk_buff * ) ; int (*cache)(struct neighbour const * , struct hh_cache * , __be16 ) ; void (*cache_update)(struct hh_cache * , struct net_device const * , unsigned char const * ) ; }; enum rx_handler_result { RX_HANDLER_CONSUMED = 0, RX_HANDLER_ANOTHER = 1, RX_HANDLER_EXACT = 2, RX_HANDLER_PASS = 3 } ; typedef enum rx_handler_result rx_handler_result_t; typedef rx_handler_result_t rx_handler_func_t(struct sk_buff ** ); struct Qdisc; struct netdev_queue { struct net_device *dev ; struct Qdisc *qdisc ; struct Qdisc *qdisc_sleeping ; struct kobject kobj ; int numa_node ; spinlock_t _xmit_lock ; int xmit_lock_owner ; unsigned long trans_start ; unsigned long trans_timeout ; unsigned long state ; struct dql dql ; }; struct rps_map { unsigned int len ; struct callback_head rcu ; u16 cpus[0U] ; }; struct rps_dev_flow { u16 cpu ; u16 filter ; unsigned int last_qtail ; }; struct rps_dev_flow_table { unsigned int mask ; struct callback_head rcu ; struct work_struct free_work ; struct rps_dev_flow flows[0U] ; }; struct netdev_rx_queue { struct rps_map *rps_map ; struct rps_dev_flow_table *rps_flow_table ; struct kobject kobj ; struct net_device *dev ; }; struct xps_map { unsigned int len ; unsigned int alloc_len ; struct callback_head rcu ; u16 queues[0U] ; }; struct xps_dev_maps { struct callback_head rcu ; struct xps_map *cpu_map[0U] ; }; struct netdev_tc_txq { u16 count ; u16 offset ; }; struct netdev_fcoe_hbainfo { char manufacturer[64U] ; char serial_number[64U] ; char hardware_version[64U] ; char driver_version[64U] ; char optionrom_version[64U] ; char firmware_version[64U] ; char model[256U] ; char model_description[256U] ; }; struct net_device_ops { int (*ndo_init)(struct net_device * ) ; void (*ndo_uninit)(struct net_device * ) ; int (*ndo_open)(struct net_device * ) ; int (*ndo_stop)(struct net_device * ) ; netdev_tx_t (*ndo_start_xmit)(struct sk_buff * , struct net_device * ) ; u16 (*ndo_select_queue)(struct net_device * , struct sk_buff * ) ; void (*ndo_change_rx_flags)(struct net_device * , int ) ; void (*ndo_set_rx_mode)(struct net_device * ) ; int (*ndo_set_mac_address)(struct net_device * , void * ) ; int (*ndo_validate_addr)(struct net_device * ) ; int (*ndo_do_ioctl)(struct net_device * , struct ifreq * , int ) ; int (*ndo_set_config)(struct net_device * , struct ifmap * ) ; int (*ndo_change_mtu)(struct net_device * , int ) ; int (*ndo_neigh_setup)(struct net_device * , struct neigh_parms * ) ; void (*ndo_tx_timeout)(struct net_device * ) ; struct rtnl_link_stats64 *(*ndo_get_stats64)(struct net_device * , struct rtnl_link_stats64 * ) ; struct net_device_stats *(*ndo_get_stats)(struct net_device * ) ; int (*ndo_vlan_rx_add_vid)(struct net_device * , unsigned short ) ; int (*ndo_vlan_rx_kill_vid)(struct net_device * , unsigned short ) ; void (*ndo_poll_controller)(struct net_device * ) ; int (*ndo_netpoll_setup)(struct net_device * , struct netpoll_info * , gfp_t ) ; void (*ndo_netpoll_cleanup)(struct net_device * ) ; int (*ndo_set_vf_mac)(struct net_device * , int , u8 * ) ; int (*ndo_set_vf_vlan)(struct net_device * , int , u16 , u8 ) ; int (*ndo_set_vf_tx_rate)(struct net_device * , int , int ) ; int (*ndo_set_vf_spoofchk)(struct net_device * , int , bool ) ; int (*ndo_get_vf_config)(struct net_device * , int , struct ifla_vf_info * ) ; int (*ndo_set_vf_port)(struct net_device * , int , struct nlattr ** ) ; int (*ndo_get_vf_port)(struct net_device * , int , struct sk_buff * ) ; int (*ndo_setup_tc)(struct net_device * , u8 ) ; int (*ndo_fcoe_enable)(struct net_device * ) ; int (*ndo_fcoe_disable)(struct net_device * ) ; int (*ndo_fcoe_ddp_setup)(struct net_device * , u16 , struct scatterlist * , unsigned int ) ; int (*ndo_fcoe_ddp_done)(struct net_device * , u16 ) ; int (*ndo_fcoe_ddp_target)(struct net_device * , u16 , struct scatterlist * , unsigned int ) ; int (*ndo_fcoe_get_hbainfo)(struct net_device * , struct netdev_fcoe_hbainfo * ) ; int (*ndo_fcoe_get_wwn)(struct net_device * , u64 * , int ) ; int (*ndo_rx_flow_steer)(struct net_device * , struct sk_buff const * , u16 , u32 ) ; int (*ndo_add_slave)(struct net_device * , struct net_device * ) ; int (*ndo_del_slave)(struct net_device * , struct net_device * ) ; netdev_features_t (*ndo_fix_features)(struct net_device * , netdev_features_t ) ; int (*ndo_set_features)(struct net_device * , netdev_features_t ) ; int (*ndo_neigh_construct)(struct neighbour * ) ; void (*ndo_neigh_destroy)(struct neighbour * ) ; int (*ndo_fdb_add)(struct ndmsg * , struct nlattr ** , struct net_device * , unsigned char const * , u16 ) ; int (*ndo_fdb_del)(struct ndmsg * , struct net_device * , unsigned char const * ) ; int (*ndo_fdb_dump)(struct sk_buff * , struct netlink_callback * , struct net_device * , int ) ; int (*ndo_bridge_setlink)(struct net_device * , struct nlmsghdr * ) ; int (*ndo_bridge_getlink)(struct sk_buff * , u32 , u32 , struct net_device * ) ; }; struct iw_handler_def; struct iw_public_data; struct vlan_info; struct in_device; struct dn_dev; struct inet6_dev; struct cpu_rmap; struct pcpu_lstats; struct pcpu_tstats; struct pcpu_dstats; union __anonunion_ldv_37185_223 { void *ml_priv ; struct pcpu_lstats *lstats ; struct pcpu_tstats *tstats ; struct pcpu_dstats *dstats ; }; struct garp_port; struct rtnl_link_ops; struct net_device { char name[16U] ; struct hlist_node name_hlist ; char *ifalias ; unsigned long mem_end ; unsigned long mem_start ; unsigned long base_addr ; unsigned int irq ; unsigned long state ; struct list_head dev_list ; struct list_head napi_list ; struct list_head unreg_list ; netdev_features_t features ; netdev_features_t hw_features ; netdev_features_t wanted_features ; netdev_features_t vlan_features ; netdev_features_t hw_enc_features ; int ifindex ; int iflink ; struct net_device_stats stats ; atomic_long_t rx_dropped ; struct iw_handler_def const *wireless_handlers ; struct iw_public_data *wireless_data ; struct net_device_ops const *netdev_ops ; struct ethtool_ops const *ethtool_ops ; struct header_ops const *header_ops ; unsigned int flags ; unsigned int priv_flags ; unsigned short gflags ; unsigned short padded ; unsigned char operstate ; unsigned char link_mode ; unsigned char if_port ; unsigned char dma ; unsigned int mtu ; unsigned short type ; unsigned short hard_header_len ; unsigned short needed_headroom ; unsigned short needed_tailroom ; unsigned char perm_addr[32U] ; unsigned char addr_assign_type ; unsigned char addr_len ; unsigned char neigh_priv_len ; unsigned short dev_id ; spinlock_t addr_list_lock ; struct netdev_hw_addr_list uc ; struct netdev_hw_addr_list mc ; bool uc_promisc ; unsigned int promiscuity ; unsigned int allmulti ; struct vlan_info *vlan_info ; struct dsa_switch_tree *dsa_ptr ; void *atalk_ptr ; struct in_device *ip_ptr ; struct dn_dev *dn_ptr ; struct inet6_dev *ip6_ptr ; void *ax25_ptr ; struct wireless_dev *ieee80211_ptr ; unsigned long last_rx ; struct net_device *master ; unsigned char *dev_addr ; struct netdev_hw_addr_list dev_addrs ; unsigned char broadcast[32U] ; struct kset *queues_kset ; struct netdev_rx_queue *_rx ; unsigned int num_rx_queues ; unsigned int real_num_rx_queues ; struct cpu_rmap *rx_cpu_rmap ; rx_handler_func_t *rx_handler ; void *rx_handler_data ; struct netdev_queue *ingress_queue ; struct netdev_queue *_tx ; unsigned int num_tx_queues ; unsigned int real_num_tx_queues ; struct Qdisc *qdisc ; unsigned long tx_queue_len ; spinlock_t tx_global_lock ; struct xps_dev_maps *xps_maps ; unsigned long trans_start ; int watchdog_timeo ; struct timer_list watchdog_timer ; int *pcpu_refcnt ; struct list_head todo_list ; struct hlist_node index_hlist ; struct list_head link_watch_list ; unsigned char reg_state ; bool dismantle ; unsigned short rtnl_link_state ; void (*destructor)(struct net_device * ) ; struct netpoll_info *npinfo ; struct net *nd_net ; union __anonunion_ldv_37185_223 ldv_37185 ; struct garp_port *garp_port ; struct device dev ; struct attribute_group const *sysfs_groups[4U] ; struct rtnl_link_ops const *rtnl_link_ops ; unsigned int gso_max_size ; u16 gso_max_segs ; struct dcbnl_rtnl_ops const *dcbnl_ops ; u8 num_tc ; struct netdev_tc_txq tc_to_txq[16U] ; u8 prio_tc_map[16U] ; unsigned int fcoe_ddp_xid ; struct netprio_map *priomap ; struct phy_device *phydev ; struct lock_class_key *qdisc_tx_busylock ; int group ; struct pm_qos_request pm_qos_req ; }; struct __anonstruct_dss1_proc_priv_224 { unsigned char invoke_id ; ulong ll_id ; u8 remote_operation ; int proc ; ulong remote_result ; char uus1_data[35U] ; }; typedef struct __anonstruct_dss1_proc_priv_224 dss1_proc_priv; struct __anonstruct_dss1_stk_priv_225 { unsigned char last_invoke_id ; unsigned char invoke_used[32U] ; }; typedef struct __anonstruct_dss1_stk_priv_225 dss1_stk_priv; struct __anonstruct_ni1_proc_priv_226 { unsigned char invoke_id ; ulong ll_id ; u8 remote_operation ; int proc ; ulong remote_result ; char uus1_data[35U] ; }; typedef struct __anonstruct_ni1_proc_priv_226 ni1_proc_priv; struct __anonstruct_ni1_stk_priv_227 { unsigned char last_invoke_id ; unsigned char invoke_used[32U] ; }; typedef struct __anonstruct_ni1_stk_priv_227 ni1_stk_priv; struct FsmInst; typedef void (*FSMFNPTR)(struct FsmInst * , int , void * ); struct Fsm { FSMFNPTR (**jumpmatrix)(struct FsmInst * , int , void * ) ; int state_count ; int event_count ; char **strEvent ; char **strState ; }; struct FsmInst { struct Fsm *fsm ; int state ; int debug ; void *userdata ; int userint ; void (*printdebug)(struct FsmInst * , char * , ...) ; }; struct FsmTimer { struct FsmInst *fi ; struct timer_list tl ; int event ; void *arg ; }; struct l3_process; struct L3Timer { struct l3_process *pc ; struct timer_list tl ; int event ; }; struct BCState; struct PStack; struct Layer1 { void *hardware ; struct BCState *bcs ; struct PStack **stlistp ; unsigned long Flags ; struct FsmInst l1m ; struct FsmTimer timer ; void (*l1l2)(struct PStack * , int , void * ) ; void (*l1hw)(struct PStack * , int , void * ) ; void (*l1tei)(struct PStack * , int , void * ) ; int mode ; int bc ; int delay ; }; struct Layer2 { int tei ; int sap ; int maxlen ; u_long flag ; spinlock_t lock ; u_int vs ; u_int va ; u_int vr ; int rc ; unsigned int window ; unsigned int sow ; struct sk_buff *windowar[8U] ; struct sk_buff_head i_queue ; struct sk_buff_head ui_queue ; void (*l2l1)(struct PStack * , int , void * ) ; void (*l2l3)(struct PStack * , int , void * ) ; void (*l2tei)(struct PStack * , int , void * ) ; struct FsmInst l2m ; struct FsmTimer t200 ; struct FsmTimer t203 ; int T200 ; int N200 ; int T203 ; int debug ; char debug_id[16U] ; }; struct Layer3 { void (*l3l4)(struct PStack * , int , void * ) ; void (*l3ml3)(struct PStack * , int , void * ) ; void (*l3l2)(struct PStack * , int , void * ) ; struct FsmInst l3m ; struct FsmTimer l3m_timer ; struct sk_buff_head squeue ; struct l3_process *proc ; struct l3_process *global ; int N303 ; int debug ; char debug_id[8U] ; }; struct LLInterface { void (*l4l3)(struct PStack * , int , void * ) ; int (*l4l3_proto)(struct PStack * , isdn_ctrl * ) ; void *userdata ; u_long flag ; }; struct Management { int ri ; struct FsmInst tei_m ; struct FsmTimer t202 ; int T202 ; int N202 ; int debug ; void (*layer)(struct PStack * , int , void * ) ; }; struct Param { u_char cause ; u_char loc ; u_char diag[6U] ; int bchannel ; int chargeinfo ; int spv ; setup_parm setup ; u_char moderate ; }; union __anonunion_prot_228 { u_char uuuu ; dss1_stk_priv dss1 ; ni1_stk_priv ni1 ; }; struct PStack { struct PStack *next ; struct Layer1 l1 ; struct Layer2 l2 ; struct Layer3 l3 ; struct LLInterface lli ; struct Management ma ; int protocol ; union __anonunion_prot_228 prot ; }; struct Channel; union __anonunion_prot_229 { u_char uuuu ; dss1_proc_priv dss1 ; ni1_proc_priv ni1 ; }; struct l3_process { int callref ; int state ; struct L3Timer timer ; int N303 ; int debug ; struct Param para ; struct Channel *chan ; struct PStack *st ; struct l3_process *next ; ulong redir_result ; union __anonunion_prot_229 prot ; }; struct hscx_hw { int hscx ; int rcvidx ; int count ; u_char *rcvbuf ; u_char tsaxr0 ; u_char tsaxr1 ; }; struct w6692B_hw { int bchan ; int rcvidx ; int count ; u_char *rcvbuf ; }; struct isar_reg { unsigned long Flags ; u_char volatile bstat ; u_char volatile iis ; u_char volatile cmsb ; u_char volatile clsb ; u_char volatile par[8U] ; }; struct isar_hw { int dpath ; int rcvidx ; int txcnt ; int mml ; u_char state ; u_char cmd ; u_char mod ; u_char newcmd ; u_char newmod ; char try_mod ; struct timer_list ftimer ; u_char *rcvbuf ; u_char conmsg[16U] ; struct isar_reg *reg ; }; struct hdlc_stat_reg { u_char cmd ; u_char xml ; u_char mode ; u_char fill ; }; union __anonunion_ctrl_230 { u_int ctrl ; struct hdlc_stat_reg sr ; }; struct hdlc_hw { union __anonunion_ctrl_230 ctrl ; u_int stat ; int rcvidx ; int count ; u_char *rcvbuf ; }; struct hfcB_hw { unsigned int *send ; int f1 ; int f2 ; }; struct tiger_hw { u_int *send ; u_int *s_irq ; u_int *s_end ; u_int *sendp ; u_int *rec ; int free ; u_char *rcvbuf ; u_char *sendbuf ; u_char *sp ; int sendcnt ; u_int s_tot ; u_int r_bitcnt ; u_int r_tot ; u_int r_err ; u_int r_fcs ; u_char r_state ; u_char r_one ; u_char r_val ; u_char s_state ; }; struct hdlc_state; struct amd7930_hw { u_char *tx_buff ; u_char *rv_buff ; int rv_buff_in ; int rv_buff_out ; struct sk_buff *rv_skb ; struct hdlc_state *hdlc_state ; struct work_struct tq_rcv ; struct work_struct tq_xmt ; }; struct IsdnCardState; struct hisax_b_if; union __anonunion_hw_231 { struct hscx_hw hscx ; struct hdlc_hw hdlc ; struct isar_hw isar ; struct hfcB_hw hfc ; struct tiger_hw tiger ; struct amd7930_hw amd7930 ; struct w6692B_hw w6692 ; struct hisax_b_if *b_if ; }; struct BCState { int channel ; int mode ; u_long Flag ; struct IsdnCardState *cs ; int tx_cnt ; struct sk_buff *tx_skb ; struct sk_buff_head rqueue ; struct sk_buff_head squeue ; int ackcnt ; spinlock_t aclock ; struct PStack *st ; u_char *blog ; u_char *conmsg ; struct timer_list transbusy ; struct work_struct tqueue ; u_long event ; int (*BC_SetStack)(struct PStack * , struct BCState * ) ; void (*BC_Close)(struct BCState * ) ; int err_crc ; int err_tx ; int err_rdo ; int err_inv ; union __anonunion_hw_231 hw ; }; struct Channel { struct PStack *b_st ; struct PStack *d_st ; struct IsdnCardState *cs ; struct BCState *bcs ; int chan ; int incoming ; struct FsmInst fi ; struct FsmTimer drel_timer ; struct FsmTimer dial_timer ; int debug ; int l2_protocol ; int l2_active_protocol ; int l3_protocol ; int data_open ; struct l3_process *proc ; setup_parm setup ; u_long Flags ; int leased ; }; struct elsa_hw { struct pci_dev *dev ; unsigned long base ; unsigned int cfg ; unsigned int ctrl ; unsigned int ale ; unsigned int isac ; unsigned int itac ; unsigned int hscx ; unsigned int trig ; unsigned int timer ; unsigned int counter ; unsigned int status ; struct timer_list tl ; unsigned int MFlag ; struct BCState *bcs ; u_char *transbuf ; u_char *rcvbuf ; unsigned int transp ; unsigned int rcvp ; unsigned int transcnt ; unsigned int rcvcnt ; u_char IER ; u_char FCR ; u_char LCR ; u_char MCR ; u_char ctrl_reg ; }; struct teles3_hw { unsigned int cfg_reg ; int isac ; int hscx[2U] ; int isacfifo ; int hscxfifo[2U] ; }; struct teles0_hw { unsigned int cfg_reg ; void *membase ; unsigned long phymem ; }; struct avm_hw { unsigned int cfg_reg ; unsigned int isac ; unsigned int hscx[2U] ; unsigned int isacfifo ; unsigned int hscxfifo[2U] ; unsigned int counter ; struct pci_dev *dev ; }; struct ix1_hw { unsigned int cfg_reg ; unsigned int isac_ale ; unsigned int isac ; unsigned int hscx_ale ; unsigned int hscx ; }; struct diva_hw { unsigned long cfg_reg ; unsigned long pci_cfg ; unsigned int ctrl ; unsigned long isac_adr ; unsigned int isac ; unsigned long hscx_adr ; unsigned int hscx ; unsigned int status ; struct timer_list tl ; u_char ctrl_reg ; struct pci_dev *dev ; }; struct asus_hw { unsigned int cfg_reg ; unsigned int adr ; unsigned int isac ; unsigned int hscx ; unsigned int u7 ; unsigned int pots ; }; struct hfc_hw { unsigned int addr ; unsigned int fifosize ; unsigned char cirm ; unsigned char ctmt ; unsigned char cip ; u_char isac_spcr ; struct timer_list timer ; }; struct sedl_hw { unsigned int cfg_reg ; unsigned int adr ; unsigned int isac ; unsigned int hscx ; unsigned int reset_on ; unsigned int reset_off ; struct isar_reg isar ; unsigned int chip ; unsigned int bus ; struct pci_dev *dev ; }; struct spt_hw { unsigned int cfg_reg ; unsigned int isac ; unsigned int hscx[2U] ; unsigned char res_irq ; }; struct mic_hw { unsigned int cfg_reg ; unsigned int adr ; unsigned int isac ; unsigned int hscx ; }; struct njet_hw { unsigned long base ; unsigned int isac ; unsigned int auxa ; unsigned char auxd ; unsigned char dmactrl ; unsigned char ctrl_reg ; unsigned char irqmask0 ; unsigned char irqstat0 ; unsigned char last_is0 ; struct pci_dev *dev ; }; struct hfcPCI_hw { unsigned char cirm ; unsigned char ctmt ; unsigned char conn ; unsigned char mst_m ; unsigned char int_m1 ; unsigned char int_m2 ; unsigned char int_s1 ; unsigned char sctrl ; unsigned char sctrl_r ; unsigned char sctrl_e ; unsigned char trm ; unsigned char stat ; unsigned char fifo ; unsigned char fifo_en ; unsigned char bswapped ; unsigned char nt_mode ; int nt_timer ; struct pci_dev *dev ; unsigned char *pci_io ; dma_addr_t dma ; void *fifos ; int last_bfifo_cnt[2U] ; struct timer_list timer ; }; struct hfcSX_hw { unsigned long base ; unsigned char cirm ; unsigned char ctmt ; unsigned char conn ; unsigned char mst_m ; unsigned char int_m1 ; unsigned char int_m2 ; unsigned char int_s1 ; unsigned char sctrl ; unsigned char sctrl_r ; unsigned char sctrl_e ; unsigned char trm ; unsigned char stat ; unsigned char fifo ; unsigned char bswapped ; unsigned char nt_mode ; unsigned char chip ; int b_fifo_size ; unsigned char last_fifo ; void *extra ; int nt_timer ; struct timer_list timer ; }; struct hfcD_hw { unsigned int addr ; unsigned int bfifosize ; unsigned int dfifosize ; unsigned char cirm ; unsigned char ctmt ; unsigned char cip ; unsigned char conn ; unsigned char mst_m ; unsigned char int_m1 ; unsigned char int_m2 ; unsigned char int_s1 ; unsigned char sctrl ; unsigned char stat ; unsigned char fifo ; unsigned char f1 ; unsigned char f2 ; unsigned int *send ; struct timer_list timer ; }; struct isurf_hw { unsigned int reset ; unsigned long phymem ; void *isac ; void *isar ; struct isar_reg isar_r ; }; struct saphir_hw { struct pci_dev *dev ; unsigned int cfg_reg ; unsigned int ale ; unsigned int isac ; unsigned int hscx ; struct timer_list timer ; }; struct bkm_hw { struct pci_dev *dev ; unsigned long base ; unsigned long isac_adr ; unsigned int isac_ale ; unsigned long jade_adr ; unsigned int jade_ale ; unsigned long plx_adr ; unsigned long data_adr ; }; struct gazel_hw { struct pci_dev *dev ; unsigned int cfg_reg ; unsigned int pciaddr[2U] ; int ipac ; int isac ; int hscx[2U] ; int isacfifo ; int hscxfifo[2U] ; unsigned char timeslot ; unsigned char iom2 ; }; struct w6692_hw { struct pci_dev *dev ; unsigned int iobase ; struct timer_list timer ; }; struct arcofi_msg { struct arcofi_msg *next ; u_char receive ; u_char len ; u_char msg[10U] ; }; struct isac_chip { int ph_state ; u_char *mon_tx ; u_char *mon_rx ; int mon_txp ; int mon_txc ; int mon_rxp ; struct arcofi_msg *arcofi_list ; struct timer_list arcofitimer ; wait_queue_head_t arcofi_wait ; u_char arcofi_bc ; u_char arcofi_state ; u_char mocr ; u_char adf2 ; }; struct hfcd_chip { int ph_state ; }; struct hfcpci_chip { int ph_state ; }; struct hfcsx_chip { int ph_state ; }; struct w6692_chip { int ph_state ; }; struct amd7930_chip { u_char lmr1 ; u_char ph_state ; u_char old_state ; u_char flg_t3 ; unsigned int tx_xmtlen ; struct timer_list timer3 ; void (*ph_command)(struct IsdnCardState * , u_char , char * ) ; void (*setIrqMask)(struct IsdnCardState * , u_char ) ; }; struct icc_chip { int ph_state ; u_char *mon_tx ; u_char *mon_rx ; int mon_txp ; int mon_txc ; int mon_rxp ; struct arcofi_msg *arcofi_list ; struct timer_list arcofitimer ; wait_queue_head_t arcofi_wait ; u_char arcofi_bc ; u_char arcofi_state ; u_char mocr ; u_char adf2 ; }; struct hisax_d_if; union __anonunion_hw_232 { struct elsa_hw elsa ; struct teles0_hw teles0 ; struct teles3_hw teles3 ; struct avm_hw avm ; struct ix1_hw ix1 ; struct diva_hw diva ; struct asus_hw asus ; struct hfc_hw hfc ; struct sedl_hw sedl ; struct spt_hw spt ; struct mic_hw mic ; struct njet_hw njet ; struct hfcD_hw hfcD ; struct hfcPCI_hw hfcpci ; struct hfcSX_hw hfcsx ; struct ix1_hw niccy ; struct isurf_hw isurf ; struct saphir_hw saphir ; struct bkm_hw ax ; struct gazel_hw gazel ; struct w6692_hw w6692 ; struct hisax_d_if *hisax_d_if ; }; union __anonunion_dc_233 { struct isac_chip isac ; struct hfcd_chip hfcd ; struct hfcpci_chip hfcpci ; struct hfcsx_chip hfcsx ; struct w6692_chip w6692 ; struct amd7930_chip amd7930 ; struct icc_chip icc ; }; struct IsdnCardState { spinlock_t lock ; u_char typ ; u_char subtyp ; int protocol ; u_int irq ; u_long irq_flags ; u_long HW_Flags ; int *busy_flag ; int chanlimit ; int logecho ; union __anonunion_hw_232 hw ; int myid ; isdn_if iif ; spinlock_t statlock ; u_char *status_buf ; u_char *status_read ; u_char *status_write ; u_char *status_end ; u_char (*readisac)(struct IsdnCardState * , u_char ) ; void (*writeisac)(struct IsdnCardState * , u_char , u_char ) ; void (*readisacfifo)(struct IsdnCardState * , u_char * , int ) ; void (*writeisacfifo)(struct IsdnCardState * , u_char * , int ) ; u_char (*BC_Read_Reg)(struct IsdnCardState * , int , u_char ) ; void (*BC_Write_Reg)(struct IsdnCardState * , int , u_char , u_char ) ; void (*BC_Send_Data)(struct BCState * ) ; int (*cardmsg)(struct IsdnCardState * , int , void * ) ; void (*setstack_d)(struct PStack * , struct IsdnCardState * ) ; void (*DC_Close)(struct IsdnCardState * ) ; irqreturn_t (*irq_func)(int , void * ) ; int (*auxcmd)(struct IsdnCardState * , isdn_ctrl * ) ; struct Channel channel[4U] ; struct BCState bcs[4U] ; struct PStack *stlist ; struct sk_buff_head rq ; struct sk_buff_head sq ; int cardnr ; char *dlog ; int debug ; union __anonunion_dc_233 dc ; u_char *rcvbuf ; int rcvidx ; struct sk_buff *tx_skb ; int tx_cnt ; u_long event ; struct work_struct tqueue ; struct timer_list dbusytimer ; unsigned int irq_cnt ; int err_crc ; int err_tx ; int err_rx ; }; typedef struct IsdnCardState IsdnCardState_t; struct IsdnCard; struct IsdnCard { int typ ; int protocol ; unsigned long para[4U] ; IsdnCardState_t *cs ; }; 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[16U] ; kernel_ulong_t driver_data ; }; struct of_device_id { char name[32U] ; char type[32U] ; char compatible[128U] ; void const *data ; }; 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 pci_driver; union __anonunion_ldv_39647_235 { 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 ; unsigned char pcie_mpss : 3 ; u8 rom_base_reg ; u8 pin ; u16 pcie_flags_reg ; struct pci_driver *driver ; u64 dma_mask ; struct device_dma_parameters dma_parms ; pci_power_t current_state ; int 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 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] ; 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 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 is_pcie : 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 ; 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 kset *msi_kset ; struct pci_vpd *vpd ; union __anonunion_ldv_39647_235 ldv_39647 ; struct pci_ats *ats ; phys_addr_t rom ; size_t romlen ; }; struct pci_ops; 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 ; 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 { 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 (*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 ; }; 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 { 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_ldv_41295_240 { 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 ; s16 level ; union __anonunion_ldv_41295_240 ldv_41295 ; }; 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 tracepoint; struct tracepoint_func { void *func ; void *data ; }; struct tracepoint { char const *name ; struct static_key key ; void (*regfunc)(void) ; void (*unregfunc)(void) ; struct tracepoint_func *funcs ; }; 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 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 } ; struct module_ref { unsigned long incs ; unsigned long decs ; }; struct module_sect_attrs; struct module_notes_attrs; 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 ; 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 ; unsigned int num_trace_bprintk_fmt ; char const **trace_bprintk_fmt_start ; struct ftrace_event_call **trace_events ; unsigned int num_trace_events ; struct list_head source_list ; struct list_head target_list ; struct task_struct *waiter ; void (*exit)(void) ; struct module_ref *refptr ; ctor_fn_t (**ctors)(void) ; unsigned int num_ctors ; }; struct hisax_if { void *priv ; void (*l1l2)(struct hisax_if * , int , void * ) ; void (*l2l1)(struct hisax_if * , int , void * ) ; }; struct hisax_b_if { struct hisax_if ifc ; struct BCState *bcs ; }; struct hisax_d_if { struct hisax_if ifc ; struct module *owner ; struct IsdnCardState *cs ; struct hisax_b_if *b_if[2U] ; struct sk_buff_head erq ; unsigned long ph_state ; }; typedef int ldv_func_ret_type___2; enum hrtimer_restart; struct FsmNode { int state ; int event ; void (*routine)(struct FsmInst * , int , void * ) ; }; enum hrtimer_restart; enum hrtimer_restart; enum hrtimer_restart; enum hrtimer_restart; enum hrtimer_restart; struct MessageType { u_char nr ; char *descr ; }; struct CauseValue { u_char nr ; char *edescr ; char *ddescr ; }; struct DTag { u_char nr ; char *descr ; }; struct InformationElement { u_char nr ; char *descr ; int (*f)(char * , u_char * ) ; }; enum hrtimer_restart; enum hrtimer_restart; enum hrtimer_restart; struct stateentry { int state ; int primitive ; void (*rout)(struct l3_process * , u8 , void * ) ; }; struct ie_len { int ie ; int len ; }; enum hrtimer_restart; enum hrtimer_restart; enum hrtimer_restart; enum hrtimer_restart; enum hrtimer_restart; typedef int ldv_func_ret_type___4; enum hrtimer_restart; enum hrtimer_restart; struct gate_struct64 { u16 offset_low ; u16 segment ; unsigned char ist : 3 ; unsigned char zero0 : 5 ; unsigned char type : 5 ; unsigned char dpl : 2 ; unsigned char p : 1 ; u16 offset_middle ; u32 offset_high ; u32 zero1 ; }; typedef struct gate_struct64 gate_desc; struct desc_ptr { unsigned short size ; unsigned long address ; }; struct tss_struct; struct pv_cpu_ops { unsigned long (*get_debugreg)(int ) ; void (*set_debugreg)(int , unsigned long ) ; void (*clts)(void) ; unsigned long (*read_cr0)(void) ; void (*write_cr0)(unsigned long ) ; unsigned long (*read_cr4_safe)(void) ; unsigned long (*read_cr4)(void) ; void (*write_cr4)(unsigned long ) ; unsigned long (*read_cr8)(void) ; void (*write_cr8)(unsigned long ) ; void (*load_tr_desc)(void) ; void (*load_gdt)(struct desc_ptr const * ) ; void (*load_idt)(struct desc_ptr const * ) ; void (*store_gdt)(struct desc_ptr * ) ; void (*store_idt)(struct desc_ptr * ) ; void (*set_ldt)(void const * , unsigned int ) ; unsigned long (*store_tr)(void) ; void (*load_tls)(struct thread_struct * , unsigned int ) ; void (*load_gs_index)(unsigned int ) ; void (*write_ldt_entry)(struct desc_struct * , int , void const * ) ; void (*write_gdt_entry)(struct desc_struct * , int , void const * , int ) ; void (*write_idt_entry)(gate_desc * , int , gate_desc const * ) ; void (*alloc_ldt)(struct desc_struct * , unsigned int ) ; void (*free_ldt)(struct desc_struct * , unsigned int ) ; void (*load_sp0)(struct tss_struct * , struct thread_struct * ) ; void (*set_iopl_mask)(unsigned int ) ; void (*wbinvd)(void) ; void (*io_delay)(void) ; void (*cpuid)(unsigned int * , unsigned int * , unsigned int * , unsigned int * ) ; u64 (*read_msr)(unsigned int , int * ) ; int (*write_msr)(unsigned int , unsigned int , unsigned int ) ; u64 (*read_tsc)(void) ; u64 (*read_pmc)(int ) ; unsigned long long (*read_tscp)(unsigned int * ) ; void (*irq_enable_sysexit)(void) ; void (*usergs_sysret64)(void) ; void (*usergs_sysret32)(void) ; void (*iret)(void) ; void (*swapgs)(void) ; void (*start_context_switch)(struct task_struct * ) ; void (*end_context_switch)(struct task_struct * ) ; }; struct x86_hw_tss { u32 reserved1 ; u64 sp0 ; u64 sp1 ; u64 sp2 ; u64 reserved2 ; u64 ist[7U] ; u32 reserved3 ; u32 reserved4 ; u16 reserved5 ; u16 io_bitmap_base ; }; struct tss_struct { struct x86_hw_tss x86_tss ; unsigned long io_bitmap[1025U] ; unsigned long stack[64U] ; }; enum hrtimer_restart; enum hrtimer_restart; enum hrtimer_restart; enum hrtimer_restart; struct serial_icounter_struct { int cts ; int dsr ; int rng ; int dcd ; int rx ; int tx ; int frame ; int overrun ; int parity ; int brk ; int buf_overrun ; int reserved[9U] ; }; enum hrtimer_restart; enum hrtimer_restart; enum hrtimer_restart; typedef unsigned short u_short; enum hrtimer_restart; struct __anonstruct_blk_head_237 { u_short sadr ; u_short len ; u_short d_key ; }; enum hrtimer_restart; enum hrtimer_restart; enum hrtimer_restart; enum hrtimer_restart; 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) ; }; enum hrtimer_restart; struct __anonstruct_z_type_236 { unsigned short z1 ; unsigned short z2 ; }; typedef struct __anonstruct_z_type_236 z_type; struct __anonstruct_dfifo_type_237 { u_char data[512U] ; u_char fill1[7840U] ; u_char f1 ; u_char f2 ; u_char fill2[30U] ; z_type za[16U] ; u_char fill3[7936U] ; }; typedef struct __anonstruct_dfifo_type_237 dfifo_type; struct __anonstruct_bzfifo_type_238 { z_type za[32U] ; u_char f1 ; u_char f2 ; u_char fill[126U] ; }; typedef struct __anonstruct_bzfifo_type_238 bzfifo_type; struct __anonstruct_d_chan_240 { dfifo_type d_tx ; dfifo_type d_rx ; }; struct __anonstruct_b_chans_241 { u_char fill1[512U] ; u_char txdat_b1[7680U] ; bzfifo_type txbz_b1 ; bzfifo_type txbz_b2 ; u_char txdat_b2[7680U] ; u_char fill2[512U] ; u_char rxdat_b1[7680U] ; bzfifo_type rxbz_b1 ; bzfifo_type rxbz_b2 ; u_char rxdat_b2[7680U] ; }; union __anonunion_fifo_area_239 { struct __anonstruct_d_chan_240 d_chan ; struct __anonstruct_b_chans_241 b_chans ; u_char fill[32768U] ; }; typedef union __anonunion_fifo_area_239 fifo_area; struct __anonstruct_PCI_ENTRY_242 { int vendor_id ; int device_id ; char *vendor_name ; char *card_name ; }; typedef struct __anonstruct_PCI_ENTRY_242 PCI_ENTRY; enum hrtimer_restart; struct hfcsx_extra { unsigned short marker[80U] ; }; enum hrtimer_restart; enum hrtimer_restart; struct __anonstruct_I20_REGISTER_FILE_236 { u_int volatile i20VFEHorzCfg ; u_int volatile i20VFEVertCfg ; u_int volatile i20VFEScaler ; u_int volatile i20VDispTop ; u_int volatile i20VDispBottom ; u_int volatile i20VidFrameGrab ; u_int volatile i20VDispCfg ; u_int volatile i20VMaskTop ; u_int volatile i20VMaskBottom ; u_int volatile i20OvlyControl ; u_int volatile i20SysControl ; u_int volatile i20GuestControl ; u_int volatile i20CodeSource ; u_int volatile i20CodeXferCtrl ; u_int volatile i20CodeMemPtr ; u_int volatile i20IntStatus ; u_int volatile i20IntCtrl ; u_int volatile i20I2CCtrl ; }; typedef struct __anonstruct_I20_REGISTER_FILE_236 I20_REGISTER_FILE; enum hrtimer_restart; enum hrtimer_restart; enum hrtimer_restart; enum hrtimer_restart; enum hrtimer_restart; enum hrtimer_restart; __inline static void set_bit(unsigned int 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(int 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; } } __inline static int test_and_set_bit(int nr , unsigned long volatile *addr ) { int oldbit ; { __asm__ volatile (".pushsection .smp_locks,\"a\"\n.balign 4\n.long 671f - .\n.popsection\n671:\n\tlock; bts %2,%1\n\tsbb %0,%0": "=r" (oldbit), "+m" (*((long volatile *)addr)): "Ir" (nr): "memory"); return (oldbit); } } __inline static int test_and_clear_bit(int nr , unsigned long volatile *addr ) { int oldbit ; { __asm__ volatile (".pushsection .smp_locks,\"a\"\n.balign 4\n.long 671f - .\n.popsection\n671:\n\tlock; btr %2,%1\n\tsbb %0,%0": "=r" (oldbit), "+m" (*((long volatile *)addr)): "Ir" (nr): "memory"); return (oldbit); } } __inline static int constant_test_bit(unsigned int nr , unsigned long const volatile *addr ) { { return ((int )((unsigned long )*(addr + (unsigned long )(nr / 64U)) >> ((int )nr & 63)) & 1); } } extern int printk(char const * , ...) ; extern void might_fault(void) ; extern int sprintf(char * , char const * , ...) ; extern int vsprintf(char * , char const * , __va_list_tag * ) ; __inline static void INIT_LIST_HEAD(struct list_head *list ) { { list->next = list; list->prev = list; return; } } extern void *memcpy(void * , void const * , size_t ) ; extern size_t strlen(char const * ) ; extern char *strcpy(char * , char const * ) ; extern char *strchr(char const * , int ) ; extern void lockdep_init_map(struct lockdep_map * , char const * , struct lock_class_key * , int ) ; extern int mutex_trylock(struct mutex * ) ; int ldv_mutex_trylock_4(struct mutex *ldv_func_arg1 ) ; extern void mutex_unlock(struct mutex * ) ; void ldv_mutex_unlock_2(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_5(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_7(struct mutex *ldv_func_arg1 ) ; extern void mutex_lock(struct mutex * ) ; void ldv_mutex_lock_1(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_3(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_6(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_cred_guard_mutex(struct mutex *lock ) ; void ldv_mutex_unlock_cred_guard_mutex(struct mutex *lock ) ; void ldv_mutex_lock_lock(struct mutex *lock ) ; void ldv_mutex_unlock_lock(struct mutex *lock ) ; void ldv_mutex_lock_mutex(struct mutex *lock ) ; int ldv_mutex_trylock_mutex(struct mutex *lock ) ; void ldv_mutex_unlock_mutex(struct mutex *lock ) ; extern void __raw_spin_lock_init(raw_spinlock_t * , char const * , struct lock_class_key * ) ; extern unsigned long _raw_spin_lock_irqsave(raw_spinlock_t * ) ; extern void _raw_spin_unlock_irqrestore(raw_spinlock_t * , unsigned long ) ; __inline static raw_spinlock_t *spinlock_check(spinlock_t *lock ) { { return (& lock->ldv_5961.rlock); } } __inline static void spin_unlock_irqrestore(spinlock_t *lock , unsigned long flags ) { { _raw_spin_unlock_irqrestore(& lock->ldv_5961.rlock, flags); return; } } extern unsigned long volatile jiffies ; extern int del_timer(struct timer_list * ) ; extern void __init_work(struct work_struct * , int ) ; extern bool schedule_work(struct work_struct * ) ; extern void msleep(unsigned int ) ; extern void kfree(void const * ) ; extern int __VERIFIER_nondet_int(void); extern void abort(void); void assume_abort_if_not(int cond) { if(!cond) {abort();} } extern void *malloc(size_t size); long ldv_is_err(const void *ptr) { return ((unsigned long)ptr > ((unsigned long)-4095)); } void *ldv_malloc(size_t size) { if (__VERIFIER_nondet_int()) { void *res = malloc(size); assume_abort_if_not(!ldv_is_err(res)); return res; } else { return ((void *)0); } } void *__kmalloc(size_t size, gfp_t t) { return ldv_malloc(size); } void *ldv_malloc(size_t size ) ; __inline static void *kmalloc(size_t size , gfp_t flags ) { void *tmp___2 ; { tmp___2 = __kmalloc(size, flags); return (tmp___2); } } void *ldv_zalloc(size_t size ) ; __inline static void *kzalloc(size_t size , gfp_t flags ) { void *tmp ; { tmp = kmalloc(size, flags | 32768U); return (tmp); } } extern unsigned long _copy_to_user(void * , void const * , unsigned int ) ; __inline static int copy_to_user(void *dst , void const *src , unsigned int size ) { unsigned long tmp ; { might_fault(); tmp = _copy_to_user(dst, src, size); return ((int )tmp); } } 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___0 , irqreturn_t (*handler)(int , void * ) , unsigned long flags , char const *name , void *dev ) { int tmp ; { tmp = request_threaded_irq(irq___0, handler, 0, flags, name, dev); return (tmp); } } extern void free_irq(unsigned int , void * ) ; extern void consume_skb(struct sk_buff * ) ; __inline static void __skb_queue_head_init(struct sk_buff_head *list ) { struct sk_buff *tmp ; { tmp = (struct sk_buff *)list; list->next = tmp; list->prev = tmp; list->qlen = 0U; return; } } __inline static void skb_queue_head_init(struct sk_buff_head *list ) { struct lock_class_key __key ; { spinlock_check(& list->lock); __raw_spin_lock_init(& list->lock.ldv_5961.rlock, "&(&list->lock)->rlock", & __key); __skb_queue_head_init(list); return; } } extern void skb_queue_tail(struct sk_buff_head * , struct sk_buff * ) ; extern struct sk_buff *skb_dequeue(struct sk_buff_head * ) ; extern void skb_queue_purge(struct sk_buff_head * ) ; extern int register_isdn(isdn_if * ) ; extern struct module __this_module ; extern void dev_kfree_skb_any(struct sk_buff * ) ; char const *CardType[42U] ; int nrcards ; char const *l1_revision ; char const *l2_revision ; char const *l3_revision ; char const *lli_revision ; char const *tei_revision ; void Logl2Frame(struct IsdnCardState *cs , struct sk_buff *skb , char *buf , int dir ) ; void HiSax_closecard(int cardnr ) ; int hisax_init_pcmcia(void *pcm_iob , int *busy_flag , struct IsdnCard *card ) ; void init_bcstate(struct IsdnCardState *cs , int bc ) ; void setstack_l1_B(struct PStack *st ) ; void setstack_manager(struct PStack *st ) ; int jiftime(char *s , long mark ) ; int HiSax_command(isdn_ctrl *ic ) ; int HiSax_writebuf_skb(int id___0 , int chan , int ack , struct sk_buff *skb ) ; void HiSax_putstatus(struct IsdnCardState *cs , char *head , char *fmt , ...) ; void VHiSax_putstatus(struct IsdnCardState *cs , char *head , char *fmt , __va_list_tag *args ) ; void HiSax_reportcard(int cardnr , int sel ) ; int QuickHex(char *txt , u_char *p , int cnt ) ; void LogFrame(struct IsdnCardState *cs , u_char *buf , int size ) ; void dlogframe(struct IsdnCardState *cs , struct sk_buff *skb , int dir ) ; int ll_run(struct IsdnCardState *cs , int addfeatures ) ; int CallcNew(void) ; void CallcFree(void) ; int CallcNewChan(struct IsdnCardState *csta ) ; void CallcFreeChan(struct IsdnCardState *csta ) ; int Isdnl1New(void) ; void Isdnl1Free(void) ; int Isdnl2New(void) ; void Isdnl2Free(void) ; int Isdnl3New(void) ; void Isdnl3Free(void) ; void init_tei(struct IsdnCardState *cs , int protocol___0 ) ; void release_tei(struct IsdnCardState *cs ) ; char *HiSax_getrev(char const *revision ) ; int TeiNew(void) ; void TeiFree(void) ; char const *CardType[42U] = { "No Card", "Teles 16.0", "Teles 8.0", "Teles 16.3", "Creatix/Teles PnP", "AVM A1", "Elsa ML", "Elsa Quickstep", "Teles PCMCIA", "ITK ix1-micro Rev.2", "Elsa PCMCIA", "Eicon.Diehl Diva", "ISDNLink", "TeleInt", "Teles 16.3c", "Sedlbauer Speed Card", "USR Sportster", "ith mic Linux", "Elsa PCI", "Compaq ISA", "NETjet-S", "Teles PCI", "Sedlbauer Speed Star (PCMCIA)", "AMD 7930", "NICCY", "S0Box", "AVM A1 (PCMCIA)", "AVM Fritz PnP/PCI", "Sedlbauer Speed Fax +", "Siemens I-Surf", "Acer P10", "HST Saphir", "Telekom A4T", "Scitel Quadro", "Gazel", "HFC 2BDS0 PCI", "Winbond 6692", "HFC 2BDS0 SX", "NETspider-U", "HFC-2BDS0-SP PCMCIA", "Hotplug", "Formula-n enter:now PCI a/b"}; struct IsdnCard cards[8U] = { {38, 2, {0UL, 0UL, 0UL, 0UL}, 0}}; static char HiSaxID[64U] = { 0}; static char *HiSax_id = (char *)(& HiSaxID); static int type[8U] = { 0}; static int protocol[8U] = { 0}; static int io[8U] = { 0}; static int io0[8U] = { 0}; static int io1[8U] = { 0}; static int irq[8U] = { 0}; static int mem[8U] = { 0}; static char *id = (char *)(& HiSaxID); char *HiSax_getrev(char const *revision ) { char *rev ; char *p ; { p = strchr(revision, 58); if ((unsigned long )p != (unsigned long )((char *)0)) { rev = p + 2UL; p = strchr((char const *)rev, 36); p = p - 1; *p = 0; } else { rev = (char *)"???"; } return (rev); } } static void HiSaxVersion(void) { char tmp[64U] ; char *tmp___0 ; char *tmp___1 ; char *tmp___2 ; char *tmp___3 ; char *tmp___4 ; { printk("\016HiSax: Linux Driver for passive ISDN cards\n"); printk("\016HiSax: Version 3.5 (module)\n"); strcpy((char *)(& tmp), l1_revision); tmp___0 = HiSax_getrev((char const *)(& tmp)); printk("\016HiSax: Layer1 Revision %s\n", tmp___0); strcpy((char *)(& tmp), l2_revision); tmp___1 = HiSax_getrev((char const *)(& tmp)); printk("\016HiSax: Layer2 Revision %s\n", tmp___1); strcpy((char *)(& tmp), tei_revision); tmp___2 = HiSax_getrev((char const *)(& tmp)); printk("\016HiSax: TeiMgr Revision %s\n", tmp___2); strcpy((char *)(& tmp), l3_revision); tmp___3 = HiSax_getrev((char const *)(& tmp)); printk("\016HiSax: Layer3 Revision %s\n", tmp___3); strcpy((char *)(& tmp), lli_revision); tmp___4 = HiSax_getrev((char const *)(& tmp)); printk("\016HiSax: LinkLayer Revision %s\n", tmp___4); return; } } int setup_teles3(struct IsdnCard *card ) ; int setup_s0box(struct IsdnCard *card ) ; int setup_telespci(struct IsdnCard *card ) ; int setup_avm_a1_pcmcia(struct IsdnCard *card ) ; int setup_avm_pcipnp(struct IsdnCard *card ) ; int setup_elsa(struct IsdnCard *card ) ; int setup_diva(struct IsdnCard *card ) ; int setup_sedlbauer(struct IsdnCard *card ) ; int setup_netjet_s(struct IsdnCard *card ) ; int setup_hfcpci(struct IsdnCard *card ) ; int setup_hfcsx(struct IsdnCard *card ) ; int setup_niccy(struct IsdnCard *card ) ; int setup_bkm_a4t(struct IsdnCard *card ) ; int setup_sct_quadro(struct IsdnCard *card ) ; int setup_gazel(struct IsdnCard *card ) ; int setup_w6692(struct IsdnCard *card ) ; int setup_netjet_u(struct IsdnCard *card ) ; int setup_enternow_pci(struct IsdnCard *card ) ; __inline static struct IsdnCardState *hisax_findcard(int driverid ) { int i ; { i = 0; goto ldv_42011; ldv_42010: ; if ((unsigned long )cards[i].cs != (unsigned long )((IsdnCardState_t *)0)) { if ((cards[i].cs)->myid == driverid) { return (cards[i].cs); } else { } } else { } i = i + 1; ldv_42011: ; if (i < nrcards) { goto ldv_42010; } else { } return (0); } } static int HiSax_readstatus(u_char *buf , int len , int id___0 , int channel ) { int count ; int cnt ; u_char *p ; struct IsdnCardState *cs ; struct IsdnCardState *tmp ; int tmp___0 ; int tmp___1 ; { p = buf; tmp = hisax_findcard(id___0); cs = tmp; if ((unsigned long )cs != (unsigned long )((struct IsdnCardState *)0)) { if (len > 4096) { printk("\fHiSax: status overflow readstat %d/%d\n", len, 4096); } else { } count = (int )(((unsigned int )((long )cs->status_end) - (unsigned int )((long )cs->status_read)) + 1U); if (count >= len) { count = len; } else { } tmp___0 = copy_to_user((void *)p, (void const *)cs->status_read, (unsigned int )count); if (tmp___0 != 0) { return (-14); } else { } cs->status_read = cs->status_read + (unsigned long )count; if ((unsigned long )cs->status_read > (unsigned long )cs->status_end) { cs->status_read = cs->status_buf; } else { } p = p + (unsigned long )count; count = len - count; goto ldv_42024; ldv_42023: ; if (count > 4096) { cnt = 4096; } else { cnt = count; } tmp___1 = copy_to_user((void *)p, (void const *)cs->status_read, (unsigned int )cnt); if (tmp___1 != 0) { return (-14); } else { } p = p + (unsigned long )cnt; cs->status_read = cs->status_read + (unsigned long )(cnt % 4096); count = count - cnt; ldv_42024: ; if (count != 0) { goto ldv_42023; } else { } return (len); } else { printk("\vHiSax: if_readstatus called with invalid driverId!\n"); return (-19); } } } int jiftime(char *s , long mark ) { char *tmp ; char *tmp___0 ; char *tmp___1 ; char *tmp___2 ; char *tmp___3 ; char *tmp___4 ; char *tmp___5 ; char *tmp___6 ; char *tmp___7 ; { s = s + 8UL; tmp = s; s = s - 1; *tmp = 0; tmp___0 = s; s = s - 1; *tmp___0 = (char )((unsigned int )((unsigned char )(mark % 10L)) + 48U); mark = mark / 10L; tmp___1 = s; s = s - 1; *tmp___1 = (char )((unsigned int )((unsigned char )(mark % 10L)) + 48U); mark = mark / 10L; tmp___2 = s; s = s - 1; *tmp___2 = 46; tmp___3 = s; s = s - 1; *tmp___3 = (char )((unsigned int )((unsigned char )(mark % 10L)) + 48U); mark = mark / 10L; tmp___4 = s; s = s - 1; *tmp___4 = (char )((unsigned int )((unsigned char )(mark % 6L)) + 48U); mark = mark / 6L; tmp___5 = s; s = s - 1; *tmp___5 = 58; tmp___6 = s; s = s - 1; *tmp___6 = (char )((unsigned int )((unsigned char )(mark % 10L)) + 48U); mark = mark / 10L; tmp___7 = s; s = s - 1; *tmp___7 = (char )((unsigned int )((unsigned char )(mark % 10L)) + 48U); return (8); } } static u_char tmpbuf[4096U] ; void VHiSax_putstatus(struct IsdnCardState *cs , char *head , char *fmt , __va_list_tag *args ) { u_long flags ; int count ; int i ; u_char *p ; isdn_ctrl ic ; int len ; raw_spinlock_t *tmp ; int tmp___0 ; int tmp___1 ; int tmp___2 ; u_char *tmp___3 ; size_t tmp___4 ; size_t __len ; void *__ret ; size_t __len___0 ; void *__ret___0 ; { if ((unsigned long )cs == (unsigned long )((struct IsdnCardState *)0)) { printk("\fHiSax: No CardStatus for message"); return; } else { } tmp = spinlock_check(& cs->statlock); flags = _raw_spin_lock_irqsave(tmp); p = (u_char *)(& tmpbuf); if ((unsigned long )head != (unsigned long )((char *)0)) { tmp___0 = jiftime((char *)p, (long )jiffies); p = p + (unsigned long )tmp___0; tmp___1 = sprintf((char *)p, " %s", head); p = p + (unsigned long )tmp___1; tmp___2 = vsprintf((char *)p, (char const *)fmt, args); p = p + (unsigned long )tmp___2; tmp___3 = p; p = p + 1; *tmp___3 = 10U; *p = 0U; len = (int )((unsigned int )((long )p) - (unsigned int )((long )(& tmpbuf))); p = (u_char *)(& tmpbuf); } else { p = (u_char *)fmt; tmp___4 = strlen((char const *)fmt); len = (int )tmp___4; } if (len > 4096) { spin_unlock_irqrestore(& cs->statlock, flags); printk("\fHiSax: status overflow %d/%d\n", len, 4096); return; } else { } count = len; i = (int )(((unsigned int )((long )cs->status_end) - (unsigned int )((long )cs->status_write)) + 1U); if (i >= len) { i = len; } else { } len = len - i; __len = (size_t )i; __ret = memcpy((void *)cs->status_write, (void const *)p, __len); cs->status_write = cs->status_write + (unsigned long )i; if ((unsigned long )cs->status_write > (unsigned long )cs->status_end) { cs->status_write = cs->status_buf; } else { } p = p + (unsigned long )i; if (len != 0) { __len___0 = (size_t )len; __ret___0 = memcpy((void *)cs->status_write, (void const *)p, __len___0); cs->status_write = cs->status_write + (unsigned long )len; } else { } spin_unlock_irqrestore(& cs->statlock, flags); if (count != 0) { ic.command = 256; ic.driver = cs->myid; ic.arg = (ulong )count; (*(cs->iif.statcallb))(& ic); } else { } return; } } void HiSax_putstatus(struct IsdnCardState *cs , char *head , char *fmt , ...) { va_list args ; { __builtin_va_start((__va_list_tag *)(& args), fmt); VHiSax_putstatus(cs, head, fmt, (__va_list_tag *)(& args)); __builtin_va_end((__va_list_tag *)(& args)); return; } } int ll_run(struct IsdnCardState *cs , int addfeatures ) { isdn_ctrl ic ; { ic.driver = cs->myid; ic.command = 258; cs->iif.features = cs->iif.features | (unsigned long )addfeatures; (*(cs->iif.statcallb))(& ic); return (0); } } static void ll_stop(struct IsdnCardState *cs ) { isdn_ctrl ic ; { ic.command = 259; ic.driver = cs->myid; (*(cs->iif.statcallb))(& ic); return; } } static void ll_unload(struct IsdnCardState *cs ) { isdn_ctrl ic ; { ic.command = 266; ic.driver = cs->myid; (*(cs->iif.statcallb))(& ic); kfree((void const *)cs->status_buf); cs->status_read = 0; cs->status_write = 0; cs->status_end = 0; kfree((void const *)cs->dlog); cs->dlog = 0; return; } } static void closecard(int cardnr ) { struct IsdnCardState *csta ; { csta = cards[cardnr].cs; if ((unsigned long )((struct BCState *)(& csta->bcs))->BC_Close != (unsigned long )((void (*)(struct BCState * ))0)) { (*(((struct BCState *)(& csta->bcs))->BC_Close))((struct BCState *)(& csta->bcs) + 1UL); (*(((struct BCState *)(& csta->bcs))->BC_Close))((struct BCState *)(& csta->bcs)); } else { } skb_queue_purge(& csta->rq); skb_queue_purge(& csta->sq); kfree((void const *)csta->rcvbuf); csta->rcvbuf = 0; if ((unsigned long )csta->tx_skb != (unsigned long )((struct sk_buff *)0)) { consume_skb(csta->tx_skb); csta->tx_skb = 0; } else { } if ((unsigned long )csta->DC_Close != (unsigned long )((void (*)(struct IsdnCardState * ))0)) { (*(csta->DC_Close))(csta); } else { } if ((unsigned long )csta->cardmsg != (unsigned long )((int (*)(struct IsdnCardState * , int , void * ))0)) { (*(csta->cardmsg))(csta, 243, 0); } else { } if ((unsigned long )csta->dbusytimer.function != (unsigned long )((void (*)(unsigned long ))0)) { del_timer(& csta->dbusytimer); } else { } ll_unload(csta); return; } } static irqreturn_t card_irq(int intno , void *dev_id ) { struct IsdnCardState *cs ; irqreturn_t ret ; irqreturn_t tmp ; { cs = (struct IsdnCardState *)dev_id; tmp = (*(cs->irq_func))(intno, (void *)cs); ret = tmp; if ((unsigned int )ret == 1U) { cs->irq_cnt = cs->irq_cnt + 1U; } else { } return (ret); } } static int init_card(struct IsdnCardState *cs ) { int irq_cnt ; int cnt ; int ret ; int tmp ; { cnt = 3; if (cs->irq == 0U) { ret = (*(cs->cardmsg))(cs, 242, 0); return (ret); } else { } cs->irq_cnt = 0U; irq_cnt = 0; printk("\016%s: IRQ %d count %d\n", CardType[(int )cs->typ], cs->irq, irq_cnt); tmp = request_irq(cs->irq, & card_irq, cs->irq_flags, "HiSax", (void *)cs); if (tmp != 0) { printk("\fHiSax: couldn\'t get interrupt %d\n", cs->irq); return (1); } else { } goto ldv_42088; ldv_42087: (*(cs->cardmsg))(cs, 242, 0); msleep(10U); printk("\016%s: IRQ %d count %d\n", CardType[(int )cs->typ], cs->irq, cs->irq_cnt); if (cs->irq_cnt == (unsigned int )irq_cnt) { printk("\f%s: IRQ(%d) getting no interrupts during init %d\n", CardType[(int )cs->typ], cs->irq, 4 - cnt); if (cnt == 1) { free_irq(cs->irq, (void *)cs); return (2); } else { (*(cs->cardmsg))(cs, 240, 0); cnt = cnt - 1; } } else { (*(cs->cardmsg))(cs, 244, 0); return (0); } ldv_42088: ; if (cnt != 0) { goto ldv_42087; } else { } return (3); } } static int hisax_cs_setup_card(struct IsdnCard *card ) { int ret ; { switch (card->typ) { case 3: ; case 4: ; case 8: ; case 19: ret = setup_teles3(card); goto ldv_42098; case 25: ret = setup_s0box(card); goto ldv_42098; case 21: ret = setup_telespci(card); goto ldv_42098; case 26: ret = setup_avm_a1_pcmcia(card); goto ldv_42098; case 27: ret = setup_avm_pcipnp(card); goto ldv_42098; case 6: ; case 7: ; case 10: ; case 18: ret = setup_elsa(card); goto ldv_42098; case 11: ret = setup_diva(card); goto ldv_42098; case 15: ; case 22: ; case 28: ret = setup_sedlbauer(card); goto ldv_42098; case 20: ret = setup_netjet_s(card); goto ldv_42098; case 35: ret = setup_hfcpci(card); goto ldv_42098; case 37: ret = setup_hfcsx(card); goto ldv_42098; case 24: ret = setup_niccy(card); goto ldv_42098; case 32: ret = setup_bkm_a4t(card); goto ldv_42098; case 33: ret = setup_sct_quadro(card); goto ldv_42098; case 34: ret = setup_gazel(card); goto ldv_42098; case 36: ret = setup_w6692(card); goto ldv_42098; case 38: ret = setup_netjet_u(card); goto ldv_42098; case 41: ret = setup_enternow_pci(card); goto ldv_42098; case 40: ret = 2; goto ldv_42098; default: printk("\fHiSax: Support for %s Card not selected\n", CardType[card->typ]); ret = 0; goto ldv_42098; } ldv_42098: ; return (ret); } } static int hisax_cs_new(int cardnr , char *id___0 , struct IsdnCard *card , struct IsdnCardState **cs_out , int *busy_flag , struct module *lockowner ) { struct IsdnCardState *cs ; void *tmp ; struct lock_class_key __key ; struct lock_class_key __key___0 ; char *tmp___0 ; void *tmp___1 ; u_char *tmp___2 ; void *tmp___3 ; { *cs_out = 0; tmp = kzalloc(6584UL, 32U); cs = (struct IsdnCardState *)tmp; if ((unsigned long )cs == (unsigned long )((struct IsdnCardState *)0)) { printk("\fHiSax: No memory for IsdnCardState(card %d)\n", cardnr + 1); goto out; } else { } card->cs = cs; spinlock_check(& cs->statlock); __raw_spin_lock_init(& cs->statlock.ldv_5961.rlock, "&(&cs->statlock)->rlock", & __key); spinlock_check(& cs->lock); __raw_spin_lock_init(& cs->lock.ldv_5961.rlock, "&(&cs->lock)->rlock", & __key___0); cs->chanlimit = 2; cs->logecho = 0; cs->cardnr = cardnr; cs->debug = 1; cs->HW_Flags = 0UL; cs->busy_flag = busy_flag; cs->irq_flags = 0UL; if (card->protocol == 4) { test_and_set_bit(4, (unsigned long volatile *)(& cs->HW_Flags)); } else { } cs->protocol = card->protocol; if (card->typ <= 0 || card->typ > 41) { printk("\fHiSax: Card Type %d out of range\n", card->typ); goto outf_cs; } else { } tmp___1 = kmalloc(2048UL, 32U); tmp___0 = (char *)tmp___1; cs->dlog = tmp___0; if ((unsigned long )tmp___0 == (unsigned long )((char *)0)) { printk("\fHiSax: No memory for dlog(card %d)\n", cardnr + 1); goto outf_cs; } else { } tmp___3 = kmalloc(4096UL, 32U); tmp___2 = (u_char *)tmp___3; cs->status_buf = tmp___2; if ((unsigned long )tmp___2 == (unsigned long )((u_char *)0)) { printk("\fHiSax: No memory for status_buf(card %d)\n", cardnr + 1); goto outf_dlog; } else { } cs->stlist = 0; cs->status_read = cs->status_buf; cs->status_write = cs->status_buf; cs->status_end = cs->status_buf + 4095U; cs->typ = (u_char )card->typ; cs->iif.owner = lockowner; strcpy((char *)(& cs->iif.id), (char const *)id___0); cs->iif.channels = 2; cs->iif.maxbufsize = 4092; cs->iif.hl_hdrlen = 4U; cs->iif.features = 369168409UL; cs->iif.command = & HiSax_command; cs->iif.writecmd = 0; cs->iif.writebuf_skb = & HiSax_writebuf_skb; cs->iif.readstat = & HiSax_readstatus; register_isdn(& cs->iif); cs->myid = cs->iif.channels; *cs_out = cs; return (1); outf_dlog: kfree((void const *)cs->dlog); outf_cs: kfree((void const *)cs); card->cs = 0; out: ; return (0); } } static int hisax_cs_setup(int cardnr , struct IsdnCard *card , struct IsdnCardState *cs ) { int ret ; u_char *tmp ; void *tmp___0 ; int tmp___1 ; { tmp___0 = kmalloc(300UL, 32U); tmp = (u_char *)tmp___0; cs->rcvbuf = tmp; if ((unsigned long )tmp == (unsigned long )((u_char *)0)) { printk("\fHiSax: No memory for isac rcvbuf\n"); ll_unload(cs); goto outf_cs; } else { } cs->rcvidx = 0; cs->tx_skb = 0; cs->tx_cnt = 0; cs->event = 0UL; skb_queue_head_init(& cs->rq); skb_queue_head_init(& cs->sq); init_bcstate(cs, 0); init_bcstate(cs, 1); switch (card->typ) { case 40: ret = 0; goto ldv_42145; default: ret = init_card(cs); goto ldv_42145; } ldv_42145: ; if (ret != 0) { closecard(cardnr); goto outf_cs; } else { } init_tei(cs, cs->protocol); ret = CallcNewChan(cs); if (ret != 0) { closecard(cardnr); goto outf_cs; } else { } tmp___1 = constant_test_bit(2U, (unsigned long const volatile *)(& cs->HW_Flags)); if (tmp___1 == 0) { ll_run(cs, 0); } else { } return (1); outf_cs: kfree((void const *)cs); card->cs = 0; return (0); } } static int checkcard(int cardnr , char *id___0 , int *busy_flag , struct module *lockowner , int (*card_setup)(struct IsdnCard * ) ) { int ret ; struct IsdnCard *card ; struct IsdnCardState *cs ; { card = (struct IsdnCard *)(& cards) + (unsigned long )cardnr; ret = hisax_cs_new(cardnr, id___0, card, & cs, busy_flag, lockowner); if (ret == 0) { return (0); } else { } printk("\016HiSax: Card %d Protocol %s Id=%s (%d)\n", cardnr + 1, card->protocol != 1 ? (card->protocol != 2 ? (card->protocol != 3 ? (card->protocol == 4 ? (char *)"NI1" : (char *)"NONE") : (char *)"LEASED") : (char *)"EDSS1") : (char *)"1TR6", (char *)(& cs->iif.id), cs->myid); ret = (*card_setup)(card); if (ret == 0) { ll_unload(cs); goto outf_cs; } else { } ret = hisax_cs_setup(cardnr, card, cs); goto out; outf_cs: kfree((void const *)cs); card->cs = 0; out: ; return (ret); } } static void HiSax_shiftcards(int idx ) { int i ; size_t __len ; void *__ret ; { i = idx; goto ldv_42167; ldv_42166: __len = 48UL; if (__len > 63UL) { __ret = memcpy((void *)(& cards) + (unsigned long )i, (void const *)(& cards) + ((unsigned long )i + 1UL), __len); } else { __ret = memcpy((void *)(& cards) + (unsigned long )i, (void const *)(& cards) + ((unsigned long )i + 1UL), __len); } i = i + 1; ldv_42167: ; if (i <= 6) { goto ldv_42166; } else { } return; } } static int HiSax_inithardware(int *busy_flag ) { int foundcards ; int i ; int t ; int flg ; char *id___0 ; char *next_id ; char ids[20U] ; char *tmp ; char *tmp___0 ; char *tmp___1 ; int tmp___2 ; { foundcards = 0; i = 0; t = 44; flg = 0; next_id = HiSax_id; tmp___0 = strchr((char const *)HiSax_id, 44); if ((unsigned long )tmp___0 != (unsigned long )((char *)0)) { t = 44; } else { tmp = strchr((char const *)HiSax_id, 37); if ((unsigned long )tmp != (unsigned long )((char *)0)) { t = 37; } else { } } goto ldv_42181; ldv_42180: ; if (cards[i].typ <= 0) { goto ldv_42179; } else { } id___0 = next_id; next_id = strchr((char const *)id___0, t); if ((unsigned long )next_id != (unsigned long )((char *)0)) { tmp___1 = next_id; next_id = next_id + 1; *tmp___1 = 0; strcpy((char *)(& ids), (char const *)id___0); flg = i + 1; } else { next_id = id___0; if (flg >= i) { strcpy((char *)(& ids), (char const *)id___0); } else { sprintf((char *)(& ids), "%s%d", id___0, i); } } tmp___2 = checkcard(i, (char *)(& ids), busy_flag, & __this_module, & hisax_cs_setup_card); if (tmp___2 != 0) { foundcards = foundcards + 1; i = i + 1; } else { if (cards[i].typ > 0 && cards[i].typ <= 41) { printk("\fHiSax: Card %s not installed !\n", CardType[cards[i].typ]); } else { } HiSax_shiftcards(i); nrcards = nrcards - 1; } ldv_42181: ; if (i < nrcards) { goto ldv_42180; } else { } ldv_42179: ; return (foundcards); } } void HiSax_closecard(int cardnr ) { int i ; int last ; { last = nrcards + -1; if (cardnr > last || cardnr < 0) { return; } else { } if ((unsigned long )cards[cardnr].cs != (unsigned long )((IsdnCardState_t *)0)) { ll_stop(cards[cardnr].cs); release_tei(cards[cardnr].cs); CallcFreeChan(cards[cardnr].cs); closecard(cardnr); if ((cards[cardnr].cs)->irq != 0U) { free_irq((cards[cardnr].cs)->irq, (void *)cards[cardnr].cs); } else { } kfree((void const *)cards[cardnr].cs); cards[cardnr].cs = 0; } else { } i = cardnr; goto ldv_42188; ldv_42187: cards[i] = cards[i + 1]; i = i + 1; ldv_42188: ; if (i <= last) { goto ldv_42187; } else { } nrcards = nrcards - 1; return; } } void HiSax_reportcard(int cardnr , int sel ) { struct IsdnCardState *cs ; { cs = cards[cardnr].cs; printk("\017HiSax: reportcard No %d\n", cardnr + 1); printk("\017HiSax: Type %s\n", CardType[(int )cs->typ]); printk("\017HiSax: debuglevel %x\n", cs->debug); printk("\017HiSax: HiSax_reportcard address 0x%lX\n", (unsigned long )(& HiSax_reportcard)); printk("\017HiSax: cs 0x%lX\n", (unsigned long )cs); printk("\017HiSax: HW_Flags %lx bc0 flg %lx bc1 flg %lx\n", cs->HW_Flags, cs->bcs[0].Flag, cs->bcs[1].Flag); printk("\017HiSax: bcs 0 mode %d ch%d\n", cs->bcs[0].mode, cs->bcs[0].channel); printk("\017HiSax: bcs 1 mode %d ch%d\n", cs->bcs[1].mode, cs->bcs[1].channel); printk("\017HiSax: dc errors(rx,crc,tx) %d,%d,%d\n", cs->err_rx, cs->err_crc, cs->err_tx); printk("\017HiSax: bc0 errors(inv,rdo,crc,tx) %d,%d,%d,%d\n", cs->bcs[0].err_inv, cs->bcs[0].err_rdo, cs->bcs[0].err_crc, cs->bcs[0].err_tx); printk("\017HiSax: bc1 errors(inv,rdo,crc,tx) %d,%d,%d,%d\n", cs->bcs[1].err_inv, cs->bcs[1].err_rdo, cs->bcs[1].err_crc, cs->bcs[1].err_tx); if (sel == 99) { cs->err_rx = 0; cs->err_crc = 0; cs->err_tx = 0; cs->bcs[0].err_inv = 0; cs->bcs[0].err_rdo = 0; cs->bcs[0].err_crc = 0; cs->bcs[0].err_tx = 0; cs->bcs[1].err_inv = 0; cs->bcs[1].err_rdo = 0; cs->bcs[1].err_crc = 0; cs->bcs[1].err_tx = 0; } else { } return; } } static int HiSax_init(void) { int i ; int retval ; int j ; int nzproto ; int tmp ; int tmp___0 ; int tmp___1 ; int tmp___2 ; { nzproto = 0; HiSaxVersion(); retval = CallcNew(); if (retval != 0) { goto out; } else { } retval = Isdnl3New(); if (retval != 0) { goto out_callc; } else { } retval = Isdnl2New(); if (retval != 0) { goto out_isdnl3; } else { } retval = TeiNew(); if (retval != 0) { goto out_isdnl2; } else { } retval = Isdnl1New(); if (retval != 0) { goto out_tei; } else { } if (type[0] == 0) { i = 0; goto ldv_42208; ldv_42207: cards[i].typ = 0; i = i + 1; ldv_42208: ; if (i <= 7) { goto ldv_42207; } else { } return (0); } else { } if (type[0] == 10) { return (0); } else { } if (type[0] == 22) { return (0); } else { } if (type[0] == 26) { return (0); } else { } if (type[0] == 39) { return (0); } else { } nrcards = 0; if ((unsigned long )id != (unsigned long )((char *)0)) { HiSax_id = id; } else { } j = 0; i = j; goto ldv_42250; ldv_42249: cards[j].typ = type[i]; if (protocol[i] != 0) { cards[j].protocol = protocol[i]; nzproto = nzproto + 1; } else { cards[j].protocol = 2; } switch (type[i]) { case 1: cards[j].para[0] = (unsigned long )irq[i]; cards[j].para[1] = (unsigned long )mem[i]; cards[j].para[2] = (unsigned long )io[i]; goto ldv_42211; case 2: cards[j].para[0] = (unsigned long )irq[i]; cards[j].para[1] = (unsigned long )mem[i]; goto ldv_42211; case 4: ; case 24: cards[j].para[0] = (unsigned long )irq[i]; cards[j].para[1] = (unsigned long )io0[i]; cards[j].para[2] = (unsigned long )io1[i]; goto ldv_42211; case 19: cards[j].para[0] = (unsigned long )irq[i]; cards[j].para[1] = (unsigned long )io0[i]; cards[j].para[2] = (unsigned long )io1[i]; cards[j].para[3] = (unsigned long )io[i]; goto ldv_42211; case 6: ; case 35: cards[j].para[0] = (unsigned long )io[i]; goto ldv_42211; case 3: ; case 8: ; case 5: ; case 26: ; case 7: ; case 10: ; case 9: ; case 11: ; case 12: ; case 13: ; case 15: ; case 22: ; case 28: ; case 16: ; case 17: ; case 14: ; case 30: ; case 25: ; case 27: ; case 31: ; case 34: ; case 37: ; case 39: cards[j].para[0] = (unsigned long )irq[i]; cards[j].para[1] = (unsigned long )io[i]; goto ldv_42211; case 29: cards[j].para[0] = (unsigned long )irq[i]; cards[j].para[1] = (unsigned long )io[i]; cards[j].para[2] = (unsigned long )mem[i]; goto ldv_42211; case 18: ; case 20: ; case 21: ; case 36: ; case 38: ; goto ldv_42211; case 32: ; goto ldv_42211; case 33: ; if (irq[i] != 0) { cards[j].para[0] = (unsigned long )irq[i]; } else { tmp = j; j = j + 1; cards[tmp].para[0] = 1UL; if (j <= 7) { cards[j].typ = 33; cards[j].protocol = protocol[i]; tmp___0 = j; j = j + 1; cards[tmp___0].para[0] = 2UL; } else { } if (j <= 7) { cards[j].typ = 33; cards[j].protocol = protocol[i]; tmp___1 = j; j = j + 1; cards[tmp___1].para[0] = 3UL; } else { } if (j <= 7) { cards[j].typ = 33; cards[j].protocol = protocol[i]; cards[j].para[0] = 4UL; } else { } } goto ldv_42211; } ldv_42211: j = j + 1; i = i + 1; ldv_42250: ; if (j <= 7) { goto ldv_42249; } else { } if (nzproto == 0) { printk("\fHiSax: Warning - no protocol specified\n"); printk("\fHiSax: using protocol %s\n", (char *)"EURO"); } else { } if ((unsigned long )HiSax_id == (unsigned long )((char *)0)) { HiSax_id = (char *)(& HiSaxID); } else { } if ((int )((signed char )HiSaxID[0]) == 0) { strcpy((char *)(& HiSaxID), "HiSax"); } else { } i = 0; goto ldv_42253; ldv_42252: ; if (cards[i].typ > 0) { nrcards = nrcards + 1; } else { } i = i + 1; ldv_42253: ; if (i <= 7) { goto ldv_42252; } else { } printk("\017HiSax: Total %d card%s defined\n", nrcards, nrcards > 1 ? (char *)"s" : (char *)""); tmp___2 = HiSax_inithardware(0); if (tmp___2 == 0) { return (-19); } else { } return (0); out_tei: TeiFree(); out_isdnl2: Isdnl2Free(); out_isdnl3: Isdnl3Free(); out_callc: CallcFree(); out: ; return (retval); } } static void HiSax_exit(void) { int cardnr ; int tmp ; { cardnr = nrcards + -1; goto ldv_42260; ldv_42259: tmp = cardnr; cardnr = cardnr - 1; HiSax_closecard(tmp); ldv_42260: ; if (cardnr >= 0) { goto ldv_42259; } else { } Isdnl1Free(); TeiFree(); Isdnl2Free(); Isdnl3Free(); CallcFree(); printk("\016HiSax module removed\n"); return; } } int hisax_init_pcmcia(void *pcm_iob , int *busy_flag , struct IsdnCard *card ) { u_char ids[16U] ; int ret ; int tmp ; { ret = -1; cards[nrcards] = *card; if (nrcards != 0) { sprintf((char *)(& ids), "HiSax%d", nrcards); } else { sprintf((char *)(& ids), "HiSax"); } tmp = checkcard(nrcards, (char *)(& ids), busy_flag, & __this_module, & hisax_cs_setup_card); if (tmp == 0) { goto error; } else { } ret = nrcards; nrcards = nrcards + 1; error: ; return (ret); } } int hisax_register(struct hisax_d_if *hisax_d_if , struct hisax_b_if **b_if , char *name , int protocol___0 ) ; void hisax_unregister(struct hisax_d_if *hisax_d_if ) ; static void hisax_d_l1l2(struct hisax_if *ifc , int pr , void *arg ) ; static void hisax_b_l1l2(struct hisax_if *ifc , int pr , void *arg ) ; static void hisax_d_l2l1(struct PStack *st , int pr , void *arg ) ; static void hisax_b_l2l1(struct PStack *st , int pr , void *arg ) ; static int hisax_cardmsg(struct IsdnCardState *cs , int mt , void *arg ) ; static int hisax_bc_setstack(struct PStack *st , struct BCState *bcs ) ; static void hisax_bc_close(struct BCState *bcs ) ; static void hisax_bh(struct work_struct *work ) ; static void EChannel_proc_rcv(struct hisax_d_if *d_if ) ; static int hisax_setup_card_dynamic(struct IsdnCard *card ) { { return (2); } } int hisax_register(struct hisax_d_if *hisax_d_if , struct hisax_b_if **b_if , char *name , int protocol___0 ) { int i ; int retval ; char id___0[20U] ; struct IsdnCardState *cs ; struct lock_class_key __key ; atomic_long_t __constr_expr_0 ; { i = 0; goto ldv_42363; ldv_42362: ; if (cards[i].typ == 0) { goto ldv_42361; } else { } i = i + 1; ldv_42363: ; if (i <= 7) { goto ldv_42362; } else { } ldv_42361: ; if (i > 7) { return (-16); } else { } cards[i].typ = 40; cards[i].protocol = protocol___0; sprintf((char *)(& id___0), "%s%d", name, i); nrcards = nrcards + 1; retval = checkcard(i, (char *)(& id___0), 0, hisax_d_if->owner, & hisax_setup_card_dynamic); if (retval == 0) { cards[i].typ = 0; nrcards = nrcards - 1; return (-22); } else { } cs = cards[i].cs; hisax_d_if->cs = cs; cs->hw.hisax_d_if = hisax_d_if; cs->cardmsg = & hisax_cardmsg; __init_work(& cs->tqueue, 0); __constr_expr_0.counter = 4195328L; cs->tqueue.data = __constr_expr_0; lockdep_init_map(& cs->tqueue.lockdep_map, "(&cs->tqueue)", & __key, 0); INIT_LIST_HEAD(& cs->tqueue.entry); cs->tqueue.func = & hisax_bh; (cs->channel[0].d_st)->l2.l2l1 = & hisax_d_l2l1; i = 0; goto ldv_42367; ldv_42366: cs->bcs[i].BC_SetStack = & hisax_bc_setstack; cs->bcs[i].BC_Close = & hisax_bc_close; (*(b_if + (unsigned long )i))->ifc.l1l2 = & hisax_b_l1l2; hisax_d_if->b_if[i] = *(b_if + (unsigned long )i); i = i + 1; ldv_42367: ; if (i <= 1) { goto ldv_42366; } else { } hisax_d_if->ifc.l1l2 = & hisax_d_l1l2; skb_queue_head_init(& hisax_d_if->erq); clear_bit(0, (unsigned long volatile *)(& hisax_d_if->ph_state)); return (0); } } void hisax_unregister(struct hisax_d_if *hisax_d_if ) { { cards[(hisax_d_if->cs)->cardnr].typ = 0; HiSax_closecard((hisax_d_if->cs)->cardnr); skb_queue_purge(& hisax_d_if->erq); return; } } void DChannel_proc_rcv(struct IsdnCardState *cs ) ; static void hisax_sched_event(struct IsdnCardState *cs , int event ) { { test_and_set_bit(event, (unsigned long volatile *)(& cs->event)); schedule_work(& cs->tqueue); return; } } static void hisax_bh(struct work_struct *work ) { struct IsdnCardState *cs ; struct work_struct const *__mptr ; struct PStack *st ; int pr ; int tmp ; int tmp___0 ; int tmp___1 ; int tmp___2 ; { __mptr = (struct work_struct const *)work; cs = (struct IsdnCardState *)__mptr + 0xffffffffffffe728UL; tmp = test_and_clear_bit(0, (unsigned long volatile *)(& cs->event)); if (tmp != 0) { DChannel_proc_rcv(cs); } else { } tmp___0 = test_and_clear_bit(8, (unsigned long volatile *)(& cs->event)); if (tmp___0 != 0) { EChannel_proc_rcv(cs->hw.hisax_d_if); } else { } tmp___2 = test_and_clear_bit(2, (unsigned long volatile *)(& cs->event)); if (tmp___2 != 0) { tmp___1 = constant_test_bit(0U, (unsigned long const volatile *)(& (cs->hw.hisax_d_if)->ph_state)); if (tmp___1 != 0) { pr = 258; } else { pr = 274; } st = cs->stlist; goto ldv_42407; ldv_42406: (*(st->l1.l1l2))(st, pr, 0); st = st->next; ldv_42407: ; if ((unsigned long )st != (unsigned long )((struct PStack *)0)) { goto ldv_42406; } else { } } else { } return; } } static void hisax_b_sched_event(struct BCState *bcs , int event ) { { test_and_set_bit(event, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); return; } } __inline static void D_L2L1(struct hisax_d_if *d_if , int pr , void *arg ) { struct hisax_if *ifc ; { ifc = (struct hisax_if *)d_if; (*(ifc->l2l1))(ifc, pr, arg); return; } } __inline static void B_L2L1(struct hisax_b_if *b_if , int pr , void *arg ) { struct hisax_if *ifc ; { ifc = (struct hisax_if *)b_if; (*(ifc->l2l1))(ifc, pr, arg); return; } } static void hisax_d_l1l2(struct hisax_if *ifc , int pr , void *arg ) { struct hisax_d_if *d_if ; struct IsdnCardState *cs ; struct PStack *st ; struct sk_buff *skb ; int tmp ; { d_if = (struct hisax_d_if *)ifc; cs = d_if->cs; switch (pr) { case 258: set_bit(0U, (unsigned long volatile *)(& d_if->ph_state)); hisax_sched_event(cs, 2); goto ldv_42435; case 274: clear_bit(0, (unsigned long volatile *)(& d_if->ph_state)); hisax_sched_event(cs, 2); goto ldv_42435; case 290: skb_queue_tail(& cs->rq, (struct sk_buff *)arg); hisax_sched_event(cs, 0); goto ldv_42435; case 289: skb = skb_dequeue(& cs->sq); if ((unsigned long )skb != (unsigned long )((struct sk_buff *)0)) { D_L2L1(d_if, 288, (void *)skb); goto ldv_42435; } else { } clear_bit(5, (unsigned long volatile *)(& cs->HW_Flags)); st = cs->stlist; goto ldv_42441; ldv_42440: tmp = test_and_clear_bit(6, (unsigned long volatile *)(& st->l1.Flags)); if (tmp != 0) { (*(st->l1.l1l2))(st, 305, 0); goto ldv_42439; } else { } st = st->next; ldv_42441: ; if ((unsigned long )st != (unsigned long )((struct PStack *)0)) { goto ldv_42440; } else { } ldv_42439: ; goto ldv_42435; case 322: skb_queue_tail(& d_if->erq, (struct sk_buff *)arg); hisax_sched_event(cs, 8); goto ldv_42435; default: printk("pr %#x\n", pr); goto ldv_42435; } ldv_42435: ; return; } } static void hisax_b_l1l2(struct hisax_if *ifc , int pr , void *arg ) { struct hisax_b_if *b_if ; struct BCState *bcs ; struct PStack *st ; struct sk_buff *skb ; u_long flags ; raw_spinlock_t *tmp ; int tmp___0 ; int tmp___1 ; { b_if = (struct hisax_b_if *)ifc; bcs = b_if->bcs; st = bcs->st; switch (pr) { case 258: (*(st->l1.l1l2))(st, pr, 0); goto ldv_42454; case 274: (*(st->l1.l1l2))(st, pr, 0); clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); skb_queue_purge(& bcs->squeue); bcs->hw.b_if = 0; goto ldv_42454; case 290: skb_queue_tail(& bcs->rqueue, (struct sk_buff *)arg); hisax_b_sched_event(bcs, 0); goto ldv_42454; case 289: bcs->tx_cnt = (int )((unsigned int )bcs->tx_cnt - (unsigned int )((long )arg)); tmp___0 = constant_test_bit(1U, (unsigned long const volatile *)(& (bcs->st)->lli.flag)); if (tmp___0 != 0) { tmp = spinlock_check(& bcs->aclock); flags = _raw_spin_lock_irqsave(tmp); bcs->ackcnt = (int )((unsigned int )bcs->ackcnt + (unsigned int )((long )arg)); spin_unlock_irqrestore(& bcs->aclock, flags); test_and_set_bit(2, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } skb = skb_dequeue(& bcs->squeue); if ((unsigned long )skb != (unsigned long )((struct sk_buff *)0)) { B_L2L1(b_if, 288, (void *)skb); goto ldv_42454; } else { } clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); tmp___1 = test_and_clear_bit(6, (unsigned long volatile *)(& st->l1.Flags)); if (tmp___1 != 0) { (*(st->l1.l1l2))(st, 305, 0); } else { } goto ldv_42454; default: printk("hisax_b_l1l2 pr %#x\n", pr); goto ldv_42454; } ldv_42454: ; return; } } static void hisax_d_l2l1(struct PStack *st , int pr , void *arg ) { struct IsdnCardState *cs ; struct hisax_d_if *hisax_d_if ; struct sk_buff *skb ; int tmp ; int tmp___0 ; { cs = (struct IsdnCardState *)st->l1.hardware; hisax_d_if = cs->hw.hisax_d_if; skb = (struct sk_buff *)arg; switch (pr) { case 288: ; case 306: ; if ((cs->debug & 1024) != 0) { LogFrame(cs, skb->data, (int )skb->len); } else { } if ((cs->debug & 2048) != 0) { dlogframe(cs, skb, 0); } else { } Logl2Frame(cs, skb, (char *)"PH_DATA_REQ", 0); tmp = test_and_set_bit(5, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp == 0) { D_L2L1(hisax_d_if, 288, (void *)skb); } else { skb_queue_tail(& cs->sq, skb); } goto ldv_42473; case 304: tmp___0 = constant_test_bit(5U, (unsigned long const volatile *)(& cs->HW_Flags)); if (tmp___0 == 0) { (*(st->l1.l1l2))(st, 305, 0); } else { set_bit(6U, (unsigned long volatile *)(& st->l1.Flags)); } goto ldv_42473; default: D_L2L1(hisax_d_if, pr, arg); goto ldv_42473; } ldv_42473: ; return; } } static int hisax_cardmsg(struct IsdnCardState *cs , int mt , void *arg ) { { return (0); } } static void hisax_b_l2l1(struct PStack *st , int pr , void *arg ) { struct BCState *bcs ; struct hisax_b_if *b_if ; int tmp ; int tmp___0 ; { bcs = st->l1.bcs; b_if = bcs->hw.b_if; switch (pr) { case 256: B_L2L1(b_if, pr, (void *)((unsigned long )st->l1.mode)); goto ldv_42489; case 288: ; case 306: tmp = test_and_set_bit(3, (unsigned long volatile *)(& bcs->Flag)); if (tmp == 0) { B_L2L1(b_if, 288, arg); } else { skb_queue_tail(& bcs->squeue, (struct sk_buff *)arg); } goto ldv_42489; case 304: tmp___0 = constant_test_bit(3U, (unsigned long const volatile *)(& bcs->Flag)); if (tmp___0 == 0) { (*(st->l1.l1l2))(st, 305, 0); } else { set_bit(6U, (unsigned long volatile *)(& st->l1.Flags)); } goto ldv_42489; case 272: test_and_clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); skb_queue_purge(& bcs->squeue); default: B_L2L1(b_if, pr, arg); goto ldv_42489; } ldv_42489: ; return; } } static int hisax_bc_setstack(struct PStack *st , struct BCState *bcs ) { struct IsdnCardState *cs ; struct hisax_d_if *hisax_d_if ; { cs = (struct IsdnCardState *)st->l1.hardware; hisax_d_if = cs->hw.hisax_d_if; bcs->channel = st->l1.bc; bcs->hw.b_if = hisax_d_if->b_if[st->l1.bc]; (hisax_d_if->b_if[st->l1.bc])->bcs = bcs; st->l1.bcs = bcs; st->l2.l2l1 = & hisax_b_l2l1; setstack_manager(st); bcs->st = st; setstack_l1_B(st); skb_queue_head_init(& bcs->rqueue); skb_queue_head_init(& bcs->squeue); return (0); } } static void hisax_bc_close(struct BCState *bcs ) { struct hisax_b_if *b_if ; { b_if = bcs->hw.b_if; if ((unsigned long )b_if != (unsigned long )((struct hisax_b_if *)0)) { B_L2L1(b_if, 272, 0); } else { } return; } } static void EChannel_proc_rcv(struct hisax_d_if *d_if ) { struct IsdnCardState *cs ; u_char *ptr ; struct sk_buff *skb ; u_char *tmp ; u_char *tmp___0 ; u_char *tmp___1 ; u_char *tmp___2 ; u_char *tmp___3 ; int tmp___4 ; u_char *tmp___5 ; { cs = d_if->cs; goto ldv_42512; ldv_42511: ; if ((cs->debug & 1024) != 0) { ptr = (u_char *)cs->dlog; if (skb->len <= 671U) { tmp = ptr; ptr = ptr + 1; *tmp = 69U; tmp___0 = ptr; ptr = ptr + 1; *tmp___0 = 67U; tmp___1 = ptr; ptr = ptr + 1; *tmp___1 = 72U; tmp___2 = ptr; ptr = ptr + 1; *tmp___2 = 79U; tmp___3 = ptr; ptr = ptr + 1; *tmp___3 = 58U; tmp___4 = QuickHex((char *)ptr, skb->data, (int )skb->len); ptr = ptr + (unsigned long )tmp___4; ptr = ptr - 1; tmp___5 = ptr; ptr = ptr + 1; *tmp___5 = 10U; *ptr = 0U; HiSax_putstatus(cs, 0, cs->dlog); } else { HiSax_putstatus(cs, (char *)"LogEcho: ", (char *)"warning Frame too big (%d)", skb->len); } } else { } dev_kfree_skb_any(skb); ldv_42512: skb = skb_dequeue(& d_if->erq); if ((unsigned long )skb != (unsigned long )((struct sk_buff *)0)) { goto ldv_42511; } else { } return; } } struct pci_device_id const __mod_pci_device_table ; void ldv_check_final_state(void) ; void ldv_initialize(void) ; extern void ldv_handler_precall(void) ; extern int __VERIFIER_nondet_int(void) ; int LDV_IN_INTERRUPT ; int main(void) { int var_card_irq_12_p0 ; void *var_card_irq_12_p1 ; int tmp ; int tmp___0 ; int tmp___1 ; { LDV_IN_INTERRUPT = 1; ldv_initialize(); ldv_handler_precall(); tmp = HiSax_init(); if (tmp != 0) { goto ldv_final; } else { } goto ldv_42584; ldv_42583: tmp___0 = __VERIFIER_nondet_int(); switch (tmp___0) { case 0: LDV_IN_INTERRUPT = 2; ldv_handler_precall(); card_irq(var_card_irq_12_p0, var_card_irq_12_p1); LDV_IN_INTERRUPT = 1; goto ldv_42581; default: ; goto ldv_42581; } ldv_42581: ; ldv_42584: tmp___1 = __VERIFIER_nondet_int(); if (tmp___1 != 0) { goto ldv_42583; } else { } ldv_handler_precall(); HiSax_exit(); ldv_final: ldv_check_final_state(); return 0; } } void ldv_mutex_lock_1(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_lock(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_2(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_lock(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_3(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } int ldv_mutex_trylock_4(struct mutex *ldv_func_arg1 ) { ldv_func_ret_type___2 ldv_func_res ; int tmp ; int tmp___0 ; { tmp = mutex_trylock(ldv_func_arg1); ldv_func_res = tmp; tmp___0 = ldv_mutex_trylock_mutex(ldv_func_arg1); return (tmp___0); return (ldv_func_res); } } void ldv_mutex_unlock_5(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_6(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_cred_guard_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_7(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_cred_guard_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } int ldv_mutex_trylock_18(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_16(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_19(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_21(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_15(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_17(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_20(struct mutex *ldv_func_arg1 ) ; extern struct sk_buff *skb_clone(struct sk_buff * , gfp_t ) ; __inline static int skb_queue_empty(struct sk_buff_head const *list ) { { return ((unsigned long )((struct sk_buff *)list->next) == (unsigned long )((struct sk_buff *)list)); } } void setstack_HiSax(struct PStack *st , struct IsdnCardState *cs ) ; void HiSax_addlist(struct IsdnCardState *cs , struct PStack *st ) ; void HiSax_rmlist(struct IsdnCardState *cs , struct PStack *st ) ; void setstack_tei(struct PStack *st ) ; void lli_writewakeup(struct PStack *st , int len ) ; int FsmNew(struct Fsm *fsm , struct FsmNode *fnlist___0 , int fncount ) ; void FsmFree(struct Fsm *fsm ) ; int FsmEvent(struct FsmInst *fi , int event , void *arg ) ; void FsmChangeState(struct FsmInst *fi , int newstate ) ; void FsmInitTimer(struct FsmInst *fi , struct FsmTimer *ft ) ; void FsmRestartTimer(struct FsmTimer *ft , int millisec , int event , void *arg , int where ) ; void FsmDelTimer(struct FsmTimer *ft , int where ) ; void debugl1(struct IsdnCardState *cs , char *fmt , ...) ; void DChannel_proc_xmt(struct IsdnCardState *cs ) ; void l1_msg(struct IsdnCardState *cs , int pr , void *arg ) ; void l1_msg_b(struct PStack *st , int pr , void *arg ) ; void BChannel_bh(struct work_struct *work ) ; char const *l1_revision = "$Revision: 2.46.2.5 $"; static struct Fsm l1fsm_b ; static struct Fsm l1fsm_s ; static char *strL1SState[7U] = { (char *)"ST_L1_F2", (char *)"ST_L1_F3", (char *)"ST_L1_F4", (char *)"ST_L1_F5", (char *)"ST_L1_F6", (char *)"ST_L1_F7", (char *)"ST_L1_F8"}; static struct Fsm l1fsm_u = {0, 0, 0, 0, 0}; static char *strL1UState[4U] = { (char *)"ST_L1_RESET", (char *)"ST_L1_DEACT", (char *)"ST_L1_SYNC2", (char *)"ST_L1_TRANS"}; static char *strL1BState[4U] = { (char *)"ST_L1_NULL", (char *)"ST_L1_WAIT_ACT", (char *)"ST_L1_WAIT_DEACT", (char *)"ST_L1_ACTIV"}; static char *strL1Event[12U] = { (char *)"EV_PH_ACTIVATE", (char *)"EV_PH_DEACTIVATE", (char *)"EV_RESET_IND", (char *)"EV_DEACT_CNF", (char *)"EV_DEACT_IND", (char *)"EV_POWER_UP", (char *)"EV_RSYNC_IND", (char *)"EV_INFO2_IND", (char *)"EV_INFO4_IND", (char *)"EV_TIMER_DEACT", (char *)"EV_TIMER_ACT", (char *)"EV_TIMER3"}; void debugl1(struct IsdnCardState *cs , char *fmt , ...) { va_list args ; char tmp[8U] ; { __builtin_va_start((__va_list_tag *)(& args), fmt); sprintf((char *)(& tmp), "Card%d ", cs->cardnr + 1); VHiSax_putstatus(cs, (char *)(& tmp), fmt, (__va_list_tag *)(& args)); __builtin_va_end((__va_list_tag *)(& args)); return; } } static void l1m_debug(struct FsmInst *fi , char *fmt , ...) { va_list args ; struct PStack *st ; struct IsdnCardState *cs ; char tmp[8U] ; { st = (struct PStack *)fi->userdata; cs = (struct IsdnCardState *)st->l1.hardware; __builtin_va_start((__va_list_tag *)(& args), fmt); sprintf((char *)(& tmp), "Card%d ", cs->cardnr + 1); VHiSax_putstatus(cs, (char *)(& tmp), fmt, (__va_list_tag *)(& args)); __builtin_va_end((__va_list_tag *)(& args)); return; } } static void L1activated(struct IsdnCardState *cs ) { struct PStack *st ; int tmp ; { st = cs->stlist; goto ldv_41020; ldv_41019: tmp = test_and_clear_bit(1, (unsigned long volatile *)(& st->l1.Flags)); if (tmp != 0) { (*(st->l1.l1l2))(st, 257, 0); } else { (*(st->l1.l1l2))(st, 258, 0); } st = st->next; ldv_41020: ; if ((unsigned long )st != (unsigned long )((struct PStack *)0)) { goto ldv_41019; } else { } return; } } static void L1deactivated(struct IsdnCardState *cs ) { struct PStack *st ; int tmp ; { st = cs->stlist; goto ldv_41027; ldv_41026: tmp = constant_test_bit(5U, (unsigned long const volatile *)(& cs->HW_Flags)); if (tmp != 0) { (*(st->l1.l1l2))(st, 337, 0); } else { } (*(st->l1.l1l2))(st, 274, 0); st = st->next; ldv_41027: ; if ((unsigned long )st != (unsigned long )((struct PStack *)0)) { goto ldv_41026; } else { } test_and_clear_bit(5, (unsigned long volatile *)(& cs->HW_Flags)); return; } } void DChannel_proc_xmt(struct IsdnCardState *cs ) { struct PStack *stptr ; int tmp ; { if ((unsigned long )cs->tx_skb != (unsigned long )((struct sk_buff *)0)) { return; } else { } stptr = cs->stlist; goto ldv_41035; ldv_41034: tmp = test_and_clear_bit(6, (unsigned long volatile *)(& stptr->l1.Flags)); if (tmp != 0) { (*(stptr->l1.l1l2))(stptr, 305, 0); goto ldv_41033; } else { stptr = stptr->next; } ldv_41035: ; if ((unsigned long )stptr != (unsigned long )((struct PStack *)0)) { goto ldv_41034; } else { } ldv_41033: ; return; } } void DChannel_proc_rcv(struct IsdnCardState *cs ) { struct sk_buff *skb ; struct sk_buff *nskb ; struct PStack *stptr ; int found ; int tei ; int sapi ; int tmp ; { stptr = cs->stlist; if ((unsigned long )stptr != (unsigned long )((struct PStack *)0)) { tmp = constant_test_bit(4U, (unsigned long const volatile *)(& stptr->l1.Flags)); if (tmp != 0) { FsmEvent(& stptr->l1.l1m, 10, 0); } else { } } else { } goto ldv_41055; ldv_41054: ; if ((cs->debug & 64) != 0) { Logl2Frame(cs, skb, (char *)"PH_DATA", 1); } else { } stptr = cs->stlist; if (skb->len <= 2U) { debugl1(cs, (char *)"D-channel frame too short(%d)", skb->len); consume_skb(skb); return; } else { } if ((int )*(skb->data) & 1 || ((int )*(skb->data + 1UL) & 1) == 0) { debugl1(cs, (char *)"D-channel frame wrong EA0/EA1"); consume_skb(skb); return; } else { } sapi = (int )*(skb->data) >> 2; tei = (int )*(skb->data + 1UL) >> 1; if ((cs->debug & 1024) != 0) { LogFrame(cs, skb->data, (int )skb->len); } else { } if ((cs->debug & 2048) != 0) { dlogframe(cs, skb, 1); } else { } if (tei == 127) { if (sapi == 0) { goto ldv_41046; ldv_41045: nskb = skb_clone(skb, 32U); if ((unsigned long )nskb != (unsigned long )((struct sk_buff *)0)) { (*(stptr->l1.l1l2))(stptr, 290, (void *)nskb); } else { printk("\fHiSax: isdn broadcast buffer shortage\n"); } stptr = stptr->next; ldv_41046: ; if ((unsigned long )stptr != (unsigned long )((struct PStack *)0)) { goto ldv_41045; } else { } } else if (sapi == 63) { goto ldv_41049; ldv_41048: nskb = skb_clone(skb, 32U); if ((unsigned long )nskb != (unsigned long )((struct sk_buff *)0)) { (*(stptr->l1.l1tei))(stptr, 290, (void *)nskb); } else { printk("\fHiSax: tei broadcast buffer shortage\n"); } stptr = stptr->next; ldv_41049: ; if ((unsigned long )stptr != (unsigned long )((struct PStack *)0)) { goto ldv_41048; } else { } } else { } consume_skb(skb); } else if (sapi == 0) { found = 0; goto ldv_41053; ldv_41052: ; if (stptr->l2.tei == tei) { (*(stptr->l1.l1l2))(stptr, 290, (void *)skb); found = 1; goto ldv_41051; } else { stptr = stptr->next; } ldv_41053: ; if ((unsigned long )stptr != (unsigned long )((struct PStack *)0)) { goto ldv_41052; } else { } ldv_41051: ; if (found == 0) { consume_skb(skb); } else { } } else { consume_skb(skb); } ldv_41055: skb = skb_dequeue(& cs->rq); if ((unsigned long )skb != (unsigned long )((struct sk_buff *)0)) { goto ldv_41054; } else { } return; } } static void BChannel_proc_xmt(struct BCState *bcs ) { struct PStack *st ; int tmp ; int tmp___0 ; int tmp___1 ; int tmp___2 ; int tmp___3 ; { st = bcs->st; tmp = constant_test_bit(3U, (unsigned long const volatile *)(& bcs->Flag)); if (tmp != 0) { debugl1(bcs->cs, (char *)"BC_BUSY Error"); return; } else { } tmp___0 = test_and_clear_bit(6, (unsigned long volatile *)(& st->l1.Flags)); if (tmp___0 != 0) { (*(st->l1.l1l2))(st, 305, 0); } else { } tmp___3 = constant_test_bit(2U, (unsigned long const volatile *)(& bcs->Flag)); if (tmp___3 == 0) { tmp___1 = constant_test_bit(3U, (unsigned long const volatile *)(& bcs->Flag)); if (tmp___1 == 0) { tmp___2 = skb_queue_empty((struct sk_buff_head const *)(& bcs->squeue)); if (tmp___2 != 0) { (*(st->l2.l2l1))(st, 273, 0); } else { } } else { } } else { } return; } } static void BChannel_proc_rcv(struct BCState *bcs ) { struct sk_buff *skb ; { if ((bcs->st)->l1.l1m.state == 1) { FsmDelTimer(& (bcs->st)->l1.timer, 4); FsmEvent(& (bcs->st)->l1.l1m, 10, 0); } else { } goto ldv_41066; ldv_41065: (*((bcs->st)->l1.l1l2))(bcs->st, 290, (void *)skb); ldv_41066: skb = skb_dequeue(& bcs->rqueue); if ((unsigned long )skb != (unsigned long )((struct sk_buff *)0)) { goto ldv_41065; } else { } return; } } static void BChannel_proc_ack(struct BCState *bcs ) { u_long flags ; int ack ; raw_spinlock_t *tmp ; { tmp = spinlock_check(& bcs->aclock); flags = _raw_spin_lock_irqsave(tmp); ack = bcs->ackcnt; bcs->ackcnt = 0; spin_unlock_irqrestore(& bcs->aclock, flags); if (ack != 0) { lli_writewakeup(bcs->st, ack); } else { } return; } } void BChannel_bh(struct work_struct *work ) { struct BCState *bcs ; struct work_struct const *__mptr ; int tmp ; int tmp___0 ; int tmp___1 ; { __mptr = (struct work_struct const *)work; bcs = (struct BCState *)__mptr + 0xfffffffffffffe30UL; if ((unsigned long )bcs == (unsigned long )((struct BCState *)0)) { return; } else { } tmp = test_and_clear_bit(0, (unsigned long volatile *)(& bcs->event)); if (tmp != 0) { BChannel_proc_rcv(bcs); } else { } tmp___0 = test_and_clear_bit(1, (unsigned long volatile *)(& bcs->event)); if (tmp___0 != 0) { BChannel_proc_xmt(bcs); } else { } tmp___1 = test_and_clear_bit(2, (unsigned long volatile *)(& bcs->event)); if (tmp___1 != 0) { BChannel_proc_ack(bcs); } else { } return; } } void HiSax_addlist(struct IsdnCardState *cs , struct PStack *st ) { { st->next = cs->stlist; cs->stlist = st; return; } } void HiSax_rmlist(struct IsdnCardState *cs , struct PStack *st ) { struct PStack *p ; { FsmDelTimer(& st->l1.timer, 0); if ((unsigned long )cs->stlist == (unsigned long )st) { cs->stlist = st->next; } else { p = cs->stlist; goto ldv_41092; ldv_41091: ; if ((unsigned long )p->next == (unsigned long )st) { p->next = st->next; return; } else { p = p->next; } ldv_41092: ; if ((unsigned long )p != (unsigned long )((struct PStack *)0)) { goto ldv_41091; } else { } } return; } } void init_bcstate(struct IsdnCardState *cs , int bc ) { struct BCState *bcs ; struct lock_class_key __key ; atomic_long_t __constr_expr_0 ; struct lock_class_key __key___0 ; { bcs = (struct BCState *)(& cs->bcs) + (unsigned long )bc; bcs->cs = cs; bcs->channel = bc; __init_work(& bcs->tqueue, 0); __constr_expr_0.counter = 4195328L; bcs->tqueue.data = __constr_expr_0; lockdep_init_map(& bcs->tqueue.lockdep_map, "(&bcs->tqueue)", & __key, 0); INIT_LIST_HEAD(& bcs->tqueue.entry); bcs->tqueue.func = & BChannel_bh; spinlock_check(& bcs->aclock); __raw_spin_lock_init(& bcs->aclock.ldv_5961.rlock, "&(&bcs->aclock)->rlock", & __key___0); bcs->BC_SetStack = 0; bcs->BC_Close = 0; bcs->Flag = 0UL; return; } } static char *l2cmd(u_char cmd ) { { switch ((int )cmd & -17) { case 1: ; return ((char *)"RR"); case 5: ; return ((char *)"RNR"); case 9: ; return ((char *)"REJ"); case 111: ; return ((char *)"SABME"); case 15: ; return ((char *)"DM"); case 3: ; return ((char *)"UI"); case 67: ; return ((char *)"DISC"); case 99: ; return ((char *)"UA"); case 135: ; return ((char *)"FRMR"); case 175: ; return ((char *)"XID"); default: ; if (((int )cmd & 1) == 0) { return ((char *)"I"); } else { return ((char *)"invalid command"); } } } } static char tmpdeb[32U] ; static char *l2frames(u_char *ptr ) { char *tmp ; char *tmp___0 ; { switch ((int )*(ptr + 2UL) & -17) { case 1: ; case 5: ; case 9: tmp = l2cmd((int )*(ptr + 2UL)); sprintf((char *)(& tmpdeb), "%s[%d](nr %d)", tmp, (int )*(ptr + 3UL) & 1, (int )*(ptr + 3UL) >> 1); goto ldv_41123; case 111: ; case 15: ; case 3: ; case 67: ; case 99: ; case 135: ; case 175: tmp___0 = l2cmd((int )*(ptr + 2UL)); sprintf((char *)(& tmpdeb), "%s[%d]", tmp___0, ((int )*(ptr + 2UL) & 16) >> 4); goto ldv_41123; default: ; if (((int )*(ptr + 2UL) & 1) == 0) { sprintf((char *)(& tmpdeb), "I[%d](ns %d, nr %d)", (int )*(ptr + 3UL) & 1, (int )*(ptr + 2UL) >> 1, (int )*(ptr + 3UL) >> 1); goto ldv_41123; } else { return ((char *)"invalid command"); } } ldv_41123: ; return ((char *)(& tmpdeb)); } } void Logl2Frame(struct IsdnCardState *cs , struct sk_buff *skb , char *buf , int dir ) { u_char *ptr ; char *tmp ; { ptr = skb->data; if ((int )*ptr & 1 || ((int )*(ptr + 1UL) & 1) == 0) { debugl1(cs, (char *)"Address not LAPD"); } else { tmp = l2frames(ptr); debugl1(cs, (char *)"%s %s: %s%c (sapi %d, tei %d)", dir != 0 ? (char *)"<-" : (char *)"->", buf, tmp, ((int )*ptr & 2) >> 1 == dir ? 67 : 82, (int )*ptr >> 2, (int )*(ptr + 1UL) >> 1); } return; } } static void l1_reset(struct FsmInst *fi , int event , void *arg ) { { FsmChangeState(fi, 1); return; } } static void l1_deact_cnf(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; int tmp ; { st = (struct PStack *)fi->userdata; FsmChangeState(fi, 1); tmp = constant_test_bit(1U, (unsigned long const volatile *)(& st->l1.Flags)); if (tmp != 0) { (*(st->l1.l1hw))(st, 0, 0); } else { } return; } } static void l1_deact_req_s(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; { st = (struct PStack *)fi->userdata; FsmChangeState(fi, 1); FsmRestartTimer(& st->l1.timer, 550, 9, 0, 2); test_and_set_bit(3, (unsigned long volatile *)(& st->l1.Flags)); return; } } static void l1_power_up_s(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; int tmp ; { st = (struct PStack *)fi->userdata; tmp = constant_test_bit(1U, (unsigned long const volatile *)(& st->l1.Flags)); if (tmp != 0) { FsmChangeState(fi, 2); (*(st->l1.l1hw))(st, 48, 0); FsmRestartTimer(& st->l1.timer, 7000, 11, 0, 2); test_and_set_bit(5, (unsigned long volatile *)(& st->l1.Flags)); } else { FsmChangeState(fi, 1); } return; } } static void l1_go_F5(struct FsmInst *fi , int event , void *arg ) { { FsmChangeState(fi, 3); return; } } static void l1_go_F8(struct FsmInst *fi , int event , void *arg ) { { FsmChangeState(fi, 6); return; } } static void l1_info2_ind(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; int tmp ; { st = (struct PStack *)fi->userdata; tmp = constant_test_bit(7U, (unsigned long const volatile *)(& st->l1.Flags)); if (tmp != 0) { FsmChangeState(fi, 2); } else { FsmChangeState(fi, 4); } (*(st->l1.l1hw))(st, 48, 0); return; } } static void l1_info4_ind(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; int tmp ; int tmp___0 ; int tmp___1 ; int tmp___2 ; { st = (struct PStack *)fi->userdata; tmp = constant_test_bit(7U, (unsigned long const volatile *)(& st->l1.Flags)); if (tmp != 0) { FsmChangeState(fi, 3); } else { FsmChangeState(fi, 5); } (*(st->l1.l1hw))(st, 48, 0); tmp___0 = test_and_clear_bit(3, (unsigned long volatile *)(& st->l1.Flags)); if (tmp___0 != 0) { FsmDelTimer(& st->l1.timer, 4); } else { } tmp___2 = constant_test_bit(2U, (unsigned long const volatile *)(& st->l1.Flags)); if (tmp___2 == 0) { tmp___1 = test_and_clear_bit(5, (unsigned long volatile *)(& st->l1.Flags)); if (tmp___1 != 0) { FsmDelTimer(& st->l1.timer, 3); } else { } FsmRestartTimer(& st->l1.timer, 110, 10, 0, 2); test_and_set_bit(4, (unsigned long volatile *)(& st->l1.Flags)); } else { } return; } } static void l1_timer3(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; int tmp ; int tmp___0 ; { st = (struct PStack *)fi->userdata; test_and_clear_bit(5, (unsigned long volatile *)(& st->l1.Flags)); tmp = test_and_clear_bit(1, (unsigned long volatile *)(& st->l1.Flags)); if (tmp != 0) { L1deactivated((struct IsdnCardState *)st->l1.hardware); } else { } tmp___0 = constant_test_bit(7U, (unsigned long const volatile *)(& st->l1.Flags)); if (tmp___0 == 0) { if (st->l1.l1m.state != 4) { FsmChangeState(fi, 1); (*(st->l1.l1hw))(st, 0, 0); } else { } } else { } return; } } static void l1_timer_act(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; { st = (struct PStack *)fi->userdata; test_and_clear_bit(4, (unsigned long volatile *)(& st->l1.Flags)); test_and_set_bit(2, (unsigned long volatile *)(& st->l1.Flags)); L1activated((struct IsdnCardState *)st->l1.hardware); return; } } static void l1_timer_deact(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; { st = (struct PStack *)fi->userdata; test_and_clear_bit(3, (unsigned long volatile *)(& st->l1.Flags)); test_and_clear_bit(2, (unsigned long volatile *)(& st->l1.Flags)); L1deactivated((struct IsdnCardState *)st->l1.hardware); (*(st->l1.l1hw))(st, 27, 0); return; } } static void l1_activate_s(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; { st = (struct PStack *)fi->userdata; (*(st->l1.l1hw))(st, 4, 0); return; } } static void l1_activate_no(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; int tmp ; int tmp___0 ; { st = (struct PStack *)fi->userdata; tmp = constant_test_bit(3U, (unsigned long const volatile *)(& st->l1.Flags)); if (tmp == 0) { tmp___0 = constant_test_bit(5U, (unsigned long const volatile *)(& st->l1.Flags)); if (tmp___0 == 0) { test_and_clear_bit(1, (unsigned long volatile *)(& st->l1.Flags)); L1deactivated((struct IsdnCardState *)st->l1.hardware); } else { } } else { } return; } } static struct FsmNode L1SFnList[44U] = { {1, 0, & l1_activate_s}, {4, 0, & l1_activate_no}, {6, 0, & l1_activate_no}, {1, 2, & l1_reset}, {2, 2, & l1_reset}, {3, 2, & l1_reset}, {4, 2, & l1_reset}, {5, 2, & l1_reset}, {6, 2, & l1_reset}, {1, 3, & l1_deact_cnf}, {2, 3, & l1_deact_cnf}, {3, 3, & l1_deact_cnf}, {4, 3, & l1_deact_cnf}, {5, 3, & l1_deact_cnf}, {6, 3, & l1_deact_cnf}, {4, 4, & l1_deact_req_s}, {5, 4, & l1_deact_req_s}, {6, 4, & l1_deact_req_s}, {1, 5, & l1_power_up_s}, {2, 6, & l1_go_F5}, {4, 6, & l1_go_F8}, {5, 6, & l1_go_F8}, {1, 7, & l1_info2_ind}, {2, 7, & l1_info2_ind}, {3, 7, & l1_info2_ind}, {5, 7, & l1_info2_ind}, {6, 7, & l1_info2_ind}, {1, 8, & l1_info4_ind}, {2, 8, & l1_info4_ind}, {3, 8, & l1_info4_ind}, {4, 8, & l1_info4_ind}, {6, 8, & l1_info4_ind}, {1, 11, & l1_timer3}, {2, 11, & l1_timer3}, {3, 11, & l1_timer3}, {4, 11, & l1_timer3}, {6, 11, & l1_timer3}, {5, 10, & l1_timer_act}, {1, 9, & l1_timer_deact}, {2, 9, & l1_timer_deact}, {3, 9, & l1_timer_deact}, {4, 9, & l1_timer_deact}, {5, 9, & l1_timer_deact}, {6, 9, & l1_timer_deact}}; static void l1_deact_req_u(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; { st = (struct PStack *)fi->userdata; FsmChangeState(fi, 0); FsmRestartTimer(& st->l1.timer, 550, 9, 0, 2); test_and_set_bit(3, (unsigned long volatile *)(& st->l1.Flags)); (*(st->l1.l1hw))(st, 0, 0); return; } } static void l1_power_up_u(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; { st = (struct PStack *)fi->userdata; FsmRestartTimer(& st->l1.timer, 7000, 11, 0, 2); test_and_set_bit(5, (unsigned long volatile *)(& st->l1.Flags)); return; } } static void l1_info0_ind(struct FsmInst *fi , int event , void *arg ) { { FsmChangeState(fi, 1); return; } } static void l1_activate_u(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; { st = (struct PStack *)fi->userdata; (*(st->l1.l1hw))(st, 16, 0); return; } } static struct FsmNode L1UFnList[18U] = { {0, 4, & l1_deact_req_u}, {1, 4, & l1_deact_req_u}, {2, 4, & l1_deact_req_u}, {3, 4, & l1_deact_req_u}, {1, 0, & l1_activate_u}, {1, 5, & l1_power_up_u}, {1, 7, & l1_info2_ind}, {3, 7, & l1_info2_ind}, {0, 3, & l1_info0_ind}, {1, 8, & l1_info4_ind}, {2, 8, & l1_info4_ind}, {0, 8, & l1_info4_ind}, {1, 11, & l1_timer3}, {2, 11, & l1_timer3}, {3, 10, & l1_timer_act}, {1, 9, & l1_timer_deact}, {2, 9, & l1_timer_deact}, {0, 9, & l1_timer_deact}}; static void l1b_activate(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; { st = (struct PStack *)fi->userdata; FsmChangeState(fi, 1); FsmRestartTimer(& st->l1.timer, st->l1.delay, 10, 0, 2); return; } } static void l1b_deactivate(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; { st = (struct PStack *)fi->userdata; FsmChangeState(fi, 2); FsmRestartTimer(& st->l1.timer, 10, 9, 0, 2); return; } } static void l1b_timer_act(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; { st = (struct PStack *)fi->userdata; FsmChangeState(fi, 3); (*(st->l1.l1l2))(st, 257, 0); return; } } static void l1b_timer_deact(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; { st = (struct PStack *)fi->userdata; FsmChangeState(fi, 0); (*(st->l2.l2l1))(st, 273, 0); return; } } static struct FsmNode L1BFnList[4U] = { {0, 0, & l1b_activate}, {1, 10, & l1b_timer_act}, {3, 1, & l1b_deactivate}, {2, 9, & l1b_timer_deact}}; int Isdnl1New(void) { int retval ; { l1fsm_s.state_count = 7; l1fsm_s.event_count = 12; l1fsm_s.strEvent = (char **)(& strL1Event); l1fsm_s.strState = (char **)(& strL1SState); retval = FsmNew(& l1fsm_s, (struct FsmNode *)(& L1SFnList), 44); if (retval != 0) { return (retval); } else { } l1fsm_b.state_count = 4; l1fsm_b.event_count = 12; l1fsm_b.strEvent = (char **)(& strL1Event); l1fsm_b.strState = (char **)(& strL1BState); retval = FsmNew(& l1fsm_b, (struct FsmNode *)(& L1BFnList), 4); if (retval != 0) { FsmFree(& l1fsm_s); return (retval); } else { } l1fsm_u.state_count = 4; l1fsm_u.event_count = 12; l1fsm_u.strEvent = (char **)(& strL1Event); l1fsm_u.strState = (char **)(& strL1UState); retval = FsmNew(& l1fsm_u, (struct FsmNode *)(& L1UFnList), 18); if (retval != 0) { FsmFree(& l1fsm_s); FsmFree(& l1fsm_b); return (retval); } else { } return (0); } } void Isdnl1Free(void) { { FsmFree(& l1fsm_u); FsmFree(& l1fsm_s); FsmFree(& l1fsm_b); return; } } static void dch_l2l1(struct PStack *st , int pr , void *arg ) { struct IsdnCardState *cs ; int tmp ; { cs = (struct IsdnCardState *)st->l1.hardware; switch (pr) { case 288: ; case 304: ; case 306: (*(st->l1.l1hw))(st, pr, arg); goto ldv_41286; case 256: ; if (cs->debug != 0) { debugl1(cs, (char *)"PH_ACTIVATE_REQ %s", *((st->l1.l1m.fsm)->strState + (unsigned long )st->l1.l1m.state)); } else { } tmp = constant_test_bit(2U, (unsigned long const volatile *)(& st->l1.Flags)); if (tmp != 0) { (*(st->l1.l1l2))(st, 257, 0); } else { test_and_set_bit(1, (unsigned long volatile *)(& st->l1.Flags)); FsmEvent(& st->l1.l1m, 0, arg); } goto ldv_41286; case 320: ; if ((int )((long )arg) & 1) { debugl1(cs, (char *)"PH_TEST_LOOP B1"); } else { } if (((long )arg & 2L) != 0L) { debugl1(cs, (char *)"PH_TEST_LOOP B2"); } else { } if (((long )arg & 3L) == 0L) { debugl1(cs, (char *)"PH_TEST_LOOP DISABLED"); } else { } (*(st->l1.l1hw))(st, 112, arg); goto ldv_41286; default: ; if (cs->debug != 0) { debugl1(cs, (char *)"dch_l2l1 msg %04X unhandled", pr); } else { } goto ldv_41286; } ldv_41286: ; return; } } void l1_msg(struct IsdnCardState *cs , int pr , void *arg ) { struct PStack *st ; { st = cs->stlist; goto ldv_41307; ldv_41306: ; switch (pr) { case 6: FsmEvent(& st->l1.l1m, 2, arg); goto ldv_41297; case 25: FsmEvent(& st->l1.l1m, 3, arg); goto ldv_41297; case 26: FsmEvent(& st->l1.l1m, 4, arg); goto ldv_41297; case 9: FsmEvent(& st->l1.l1m, 5, arg); goto ldv_41297; case 98: FsmEvent(& st->l1.l1m, 6, arg); goto ldv_41297; case 34: FsmEvent(& st->l1.l1m, 7, arg); goto ldv_41297; case 66: ; case 74: FsmEvent(& st->l1.l1m, 8, arg); goto ldv_41297; default: ; if (cs->debug != 0) { debugl1(cs, (char *)"l1msg %04X unhandled", pr); } else { } goto ldv_41297; } ldv_41297: st = st->next; ldv_41307: ; if ((unsigned long )st != (unsigned long )((struct PStack *)0)) { goto ldv_41306; } else { } return; } } void l1_msg_b(struct PStack *st , int pr , void *arg ) { { switch (pr) { case 256: FsmEvent(& st->l1.l1m, 0, 0); goto ldv_41315; case 272: FsmEvent(& st->l1.l1m, 1, 0); goto ldv_41315; } ldv_41315: ; return; } } void setstack_HiSax(struct PStack *st , struct IsdnCardState *cs ) { int tmp ; { st->l1.hardware = (void *)cs; st->protocol = cs->protocol; st->l1.l1m.fsm = & l1fsm_s; st->l1.l1m.state = 1; st->l1.Flags = 0UL; tmp = constant_test_bit(10U, (unsigned long const volatile *)(& cs->HW_Flags)); if (tmp != 0) { st->l1.l1m.fsm = & l1fsm_u; st->l1.l1m.state = 0; st->l1.Flags = 7UL; } else { } st->l1.l1m.debug = cs->debug; st->l1.l1m.userdata = (void *)st; st->l1.l1m.userint = 0; st->l1.l1m.printdebug = & l1m_debug; FsmInitTimer(& st->l1.l1m, & st->l1.timer); setstack_tei(st); setstack_manager(st); st->l1.stlistp = & cs->stlist; st->l2.l2l1 = & dch_l2l1; if ((unsigned long )cs->setstack_d != (unsigned long )((void (*)(struct PStack * , struct IsdnCardState * ))0)) { (*(cs->setstack_d))(st, cs); } else { } return; } } void setstack_l1_B(struct PStack *st ) { struct IsdnCardState *cs ; { cs = (struct IsdnCardState *)st->l1.hardware; st->l1.l1m.fsm = & l1fsm_b; st->l1.l1m.state = 0; st->l1.l1m.debug = cs->debug; st->l1.l1m.userdata = (void *)st; st->l1.l1m.userint = 0; st->l1.l1m.printdebug = & l1m_debug; st->l1.Flags = 0UL; FsmInitTimer(& st->l1.l1m, & st->l1.timer); return; } } void ldv_mutex_lock_15(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_lock(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_16(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_lock(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_17(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } int ldv_mutex_trylock_18(struct mutex *ldv_func_arg1 ) { ldv_func_ret_type___2 ldv_func_res ; int tmp ; int tmp___0 ; { tmp = mutex_trylock(ldv_func_arg1); ldv_func_res = tmp; tmp___0 = ldv_mutex_trylock_mutex(ldv_func_arg1); return (tmp___0); return (ldv_func_res); } } void ldv_mutex_unlock_19(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_20(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_cred_guard_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_21(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_cred_guard_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } int ldv_mutex_trylock_32(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_30(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_33(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_35(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_29(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_31(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_34(struct mutex *ldv_func_arg1 ) ; extern void get_random_bytes(void * , int ) ; extern struct sk_buff *__alloc_skb(unsigned int , gfp_t , int , int ) ; __inline static struct sk_buff *alloc_skb(unsigned int size , gfp_t priority ) { struct sk_buff *tmp ; { tmp = __alloc_skb(size, priority, 0, -1); return (tmp); } } extern unsigned char *skb_put(struct sk_buff * , unsigned int ) ; extern unsigned char *skb_pull(struct sk_buff * , unsigned int ) ; int FsmAddTimer(struct FsmTimer *ft , int millisec , int event , void *arg , int where ) ; char const *tei_revision = "$Revision: 2.20.2.3 $"; static struct Fsm teifsm ; static char *strTeiState[3U] = { (char *)"ST_TEI_NOP", (char *)"ST_TEI_IDREQ", (char *)"ST_TEI_IDVERIFY"}; static char *strTeiEvent[7U] = { (char *)"EV_IDREQ", (char *)"EV_ASSIGN", (char *)"EV_DENIED", (char *)"EV_CHKREQ", (char *)"EV_REMOVE", (char *)"EV_VERIFY", (char *)"EV_T202"}; static unsigned int random_ri(void) { unsigned int x ; { get_random_bytes((void *)(& x), 4); return (x & 65535U); } } static struct PStack *findtei(struct PStack *st , int tei ) { struct PStack *ptr ; { ptr = *(st->l1.stlistp); if (tei == 127) { return (0); } else { } goto ldv_40970; ldv_40969: ; if (ptr->l2.tei == tei) { return (ptr); } else { ptr = ptr->next; } ldv_40970: ; if ((unsigned long )ptr != (unsigned long )((struct PStack *)0)) { goto ldv_40969; } else { } return (0); } } static void put_tei_msg(struct PStack *st , u_char m_id , unsigned int ri , u_char tei ) { struct sk_buff *skb ; u_char *bp ; unsigned char *tmp ; unsigned char *tmp___0 ; { skb = alloc_skb(8U, 32U); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { printk("\fHiSax: No skb for TEI manager\n"); return; } else { } tmp = skb_put(skb, 3U); bp = tmp; *bp = 252U; *(bp + 1UL) = 255U; *(bp + 2UL) = 3U; tmp___0 = skb_put(skb, 5U); bp = tmp___0; *bp = 15U; *(bp + 1UL) = (u_char )(ri >> 8); *(bp + 2UL) = (u_char )ri; *(bp + 3UL) = m_id; *(bp + 4UL) = (u_char )((int )((signed char )((int )tei << 1)) | 1); (*(st->l2.l2l1))(st, 288, (void *)skb); return; } } static void tei_id_request(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; unsigned int tmp ; { st = (struct PStack *)fi->userdata; if (st->l2.tei != -1) { (*(st->ma.tei_m.printdebug))(& st->ma.tei_m, (char *)"assign request for already assigned tei %d", st->l2.tei); return; } else { } tmp = random_ri(); st->ma.ri = (int )tmp; if (st->ma.debug != 0) { (*(st->ma.tei_m.printdebug))(& st->ma.tei_m, (char *)"assign request ri %d", st->ma.ri); } else { } put_tei_msg(st, 1, (unsigned int )st->ma.ri, 127); FsmChangeState(& st->ma.tei_m, 1); FsmAddTimer(& st->ma.t202, st->ma.T202, 6, 0, 1); st->ma.N202 = 3; return; } } static void tei_id_assign(struct FsmInst *fi , int event , void *arg ) { struct PStack *ost ; struct PStack *st ; struct sk_buff *skb ; struct IsdnCardState *cs ; int ri ; int tei ; { st = (struct PStack *)fi->userdata; skb = (struct sk_buff *)arg; ri = (int )(((unsigned int )*(skb->data + 1UL) << 8) + (unsigned int )*(skb->data + 2UL)); tei = (int )*(skb->data + 4UL) >> 1; if (st->ma.debug != 0) { (*(st->ma.tei_m.printdebug))(& st->ma.tei_m, (char *)"identity assign ri %d tei %d", ri, tei); } else { } ost = findtei(st, tei); if ((unsigned long )ost != (unsigned long )((struct PStack *)0)) { if (ost->ma.ri != ri) { (*(st->ma.tei_m.printdebug))(& st->ma.tei_m, (char *)"possible duplicate assignment tei %d", tei); (*(ost->l2.l2tei))(ost, 651, 0); } else if (st->ma.ri == ri) { FsmDelTimer(& st->ma.t202, 1); FsmChangeState(& st->ma.tei_m, 0); (*(st->l3.l3l2))(st, 640, (void *)((long )tei)); cs = (struct IsdnCardState *)st->l1.hardware; (*(cs->cardmsg))(cs, 640, 0); } else { } } else { } return; } } static void tei_id_test_dup(struct FsmInst *fi , int event , void *arg ) { struct PStack *ost ; struct PStack *st ; struct sk_buff *skb ; int tei ; int ri ; { st = (struct PStack *)fi->userdata; skb = (struct sk_buff *)arg; ri = (int )(((unsigned int )*(skb->data + 1UL) << 8) + (unsigned int )*(skb->data + 2UL)); tei = (int )*(skb->data + 4UL) >> 1; if (st->ma.debug != 0) { (*(st->ma.tei_m.printdebug))(& st->ma.tei_m, (char *)"foreign identity assign ri %d tei %d", ri, tei); } else { } ost = findtei(st, tei); if ((unsigned long )ost != (unsigned long )((struct PStack *)0)) { if (ost->ma.ri != ri) { (*(st->ma.tei_m.printdebug))(& st->ma.tei_m, (char *)"possible duplicate assignment tei %d", tei); FsmEvent(& ost->ma.tei_m, 5, 0); } else { } } else { } return; } } static void tei_id_denied(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; struct sk_buff *skb ; int ri ; int tei ; { st = (struct PStack *)fi->userdata; skb = (struct sk_buff *)arg; ri = (int )(((unsigned int )*(skb->data + 1UL) << 8) + (unsigned int )*(skb->data + 2UL)); tei = (int )*(skb->data + 4UL) >> 1; if (st->ma.debug != 0) { (*(st->ma.tei_m.printdebug))(& st->ma.tei_m, (char *)"identity denied ri %d tei %d", ri, tei); } else { } return; } } static void tei_id_chk_req(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; struct sk_buff *skb ; int tei ; unsigned int tmp ; { st = (struct PStack *)fi->userdata; skb = (struct sk_buff *)arg; tei = (int )*(skb->data + 4UL) >> 1; if (st->ma.debug != 0) { (*(st->ma.tei_m.printdebug))(& st->ma.tei_m, (char *)"identity check req tei %d", tei); } else { } if (st->l2.tei != -1 && (tei == 127 || st->l2.tei == tei)) { FsmDelTimer(& st->ma.t202, 4); FsmChangeState(& st->ma.tei_m, 0); tmp = random_ri(); put_tei_msg(st, 5, tmp, (int )((u_char )st->l2.tei)); } else { } return; } } static void tei_id_remove(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; struct sk_buff *skb ; struct IsdnCardState *cs ; int tei ; { st = (struct PStack *)fi->userdata; skb = (struct sk_buff *)arg; tei = (int )*(skb->data + 4UL) >> 1; if (st->ma.debug != 0) { (*(st->ma.tei_m.printdebug))(& st->ma.tei_m, (char *)"identity remove tei %d", tei); } else { } if (st->l2.tei != -1 && (tei == 127 || st->l2.tei == tei)) { FsmDelTimer(& st->ma.t202, 5); FsmChangeState(& st->ma.tei_m, 0); (*(st->l3.l3l2))(st, 644, 0); cs = (struct IsdnCardState *)st->l1.hardware; (*(cs->cardmsg))(cs, 644, 0); } else { } return; } } static void tei_id_verify(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; { st = (struct PStack *)fi->userdata; if (st->ma.debug != 0) { (*(st->ma.tei_m.printdebug))(& st->ma.tei_m, (char *)"id verify request for tei %d", st->l2.tei); } else { } put_tei_msg(st, 7, 0U, (int )((u_char )st->l2.tei)); FsmChangeState(& st->ma.tei_m, 2); FsmAddTimer(& st->ma.t202, st->ma.T202, 6, 0, 2); st->ma.N202 = 2; return; } } static void tei_id_req_tout(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; struct IsdnCardState *cs ; unsigned int tmp ; { st = (struct PStack *)fi->userdata; st->ma.N202 = st->ma.N202 - 1; if (st->ma.N202 != 0) { tmp = random_ri(); st->ma.ri = (int )tmp; if (st->ma.debug != 0) { (*(st->ma.tei_m.printdebug))(& st->ma.tei_m, (char *)"assign req(%d) ri %d", 4 - st->ma.N202, st->ma.ri); } else { } put_tei_msg(st, 1, (unsigned int )st->ma.ri, 127); FsmAddTimer(& st->ma.t202, st->ma.T202, 6, 0, 3); } else { (*(st->ma.tei_m.printdebug))(& st->ma.tei_m, (char *)"assign req failed"); (*(st->l3.l3l2))(st, 651, 0); cs = (struct IsdnCardState *)st->l1.hardware; (*(cs->cardmsg))(cs, 644, 0); FsmChangeState(fi, 0); } return; } } static void tei_id_ver_tout(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; struct IsdnCardState *cs ; { st = (struct PStack *)fi->userdata; st->ma.N202 = st->ma.N202 - 1; if (st->ma.N202 != 0) { if (st->ma.debug != 0) { (*(st->ma.tei_m.printdebug))(& st->ma.tei_m, (char *)"id verify req(%d) for tei %d", 3 - st->ma.N202, st->l2.tei); } else { } put_tei_msg(st, 7, 0U, (int )((u_char )st->l2.tei)); FsmAddTimer(& st->ma.t202, st->ma.T202, 6, 0, 4); } else { (*(st->ma.tei_m.printdebug))(& st->ma.tei_m, (char *)"verify req for tei %d failed", st->l2.tei); (*(st->l3.l3l2))(st, 644, 0); cs = (struct IsdnCardState *)st->l1.hardware; (*(cs->cardmsg))(cs, 644, 0); FsmChangeState(fi, 0); } return; } } static void tei_l1l2(struct PStack *st , int pr , void *arg ) { struct sk_buff *skb ; int mt ; int tmp ; { skb = (struct sk_buff *)arg; tmp = constant_test_bit(15U, (unsigned long const volatile *)(& st->l2.flag)); if (tmp != 0) { consume_skb(skb); return; } else { } if (pr == 290) { if (skb->len <= 2U) { (*(st->ma.tei_m.printdebug))(& st->ma.tei_m, (char *)"short mgr frame %ld/3", skb->len); } else if ((unsigned int )*(skb->data) != 254U || (unsigned int )*(skb->data + 1UL) != 255U) { (*(st->ma.tei_m.printdebug))(& st->ma.tei_m, (char *)"wrong mgr sapi/tei %x/%x", (int )*(skb->data), (int )*(skb->data + 1UL)); } else if (((int )*(skb->data + 2UL) & 239) != 3) { (*(st->ma.tei_m.printdebug))(& st->ma.tei_m, (char *)"mgr frame is not ui %x", (int )*(skb->data + 2UL)); } else { skb_pull(skb, 3U); if (skb->len <= 4U) { (*(st->ma.tei_m.printdebug))(& st->ma.tei_m, (char *)"short mgr frame %ld/5", skb->len); } else if ((unsigned int )*(skb->data) != 15U) { (*(st->ma.tei_m.printdebug))(& st->ma.tei_m, (char *)"tei handler wrong entity id %x", (int )*(skb->data)); } else { mt = (int )*(skb->data + 3UL); if (mt == 2) { FsmEvent(& st->ma.tei_m, 1, (void *)skb); } else if (mt == 3) { FsmEvent(& st->ma.tei_m, 2, (void *)skb); } else if (mt == 4) { FsmEvent(& st->ma.tei_m, 3, (void *)skb); } else if (mt == 6) { FsmEvent(& st->ma.tei_m, 4, (void *)skb); } else { (*(st->ma.tei_m.printdebug))(& st->ma.tei_m, (char *)"tei handler wrong mt %x\n", mt); } } } } else { (*(st->ma.tei_m.printdebug))(& st->ma.tei_m, (char *)"tei handler wrong pr %x\n", pr); } consume_skb(skb); return; } } static void tei_l2tei(struct PStack *st , int pr , void *arg ) { struct IsdnCardState *cs ; int tmp ; { tmp = constant_test_bit(15U, (unsigned long const volatile *)(& st->l2.flag)); if (tmp != 0) { if (pr == 642) { if (st->ma.debug != 0) { (*(st->ma.tei_m.printdebug))(& st->ma.tei_m, (char *)"fixed assign tei %d", st->l2.tei); } else { } (*(st->l3.l3l2))(st, 640, (void *)((long )st->l2.tei)); cs = (struct IsdnCardState *)st->l1.hardware; (*(cs->cardmsg))(cs, 640, 0); } else { } return; } else { } switch (pr) { case 642: FsmEvent(& st->ma.tei_m, 0, arg); goto ldv_41067; case 648: FsmEvent(& st->ma.tei_m, 5, arg); goto ldv_41067; default: ; goto ldv_41067; } ldv_41067: ; return; } } static void tei_debug(struct FsmInst *fi , char *fmt , ...) { va_list args ; struct PStack *st ; { st = (struct PStack *)fi->userdata; __builtin_va_start((__va_list_tag *)(& args), fmt); VHiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"tei ", fmt, (__va_list_tag *)(& args)); __builtin_va_end((__va_list_tag *)(& args)); return; } } void setstack_tei(struct PStack *st ) { { st->l2.l2tei = & tei_l2tei; st->ma.T202 = 2000; st->l1.l1tei = & tei_l1l2; st->ma.debug = 1; st->ma.tei_m.fsm = & teifsm; st->ma.tei_m.state = 0; st->ma.tei_m.debug = 1; st->ma.tei_m.userdata = (void *)st; st->ma.tei_m.userint = 0; st->ma.tei_m.printdebug = & tei_debug; FsmInitTimer(& st->ma.tei_m, & st->ma.t202); return; } } void init_tei(struct IsdnCardState *cs , int protocol___0 ) { { return; } } void release_tei(struct IsdnCardState *cs ) { struct PStack *st ; { st = cs->stlist; goto ldv_41088; ldv_41087: FsmDelTimer(& st->ma.t202, 1); st = st->next; ldv_41088: ; if ((unsigned long )st != (unsigned long )((struct PStack *)0)) { goto ldv_41087; } else { } return; } } static struct FsmNode TeiFnList[11U] = { {0, 0, & tei_id_request}, {0, 1, & tei_id_test_dup}, {0, 5, & tei_id_verify}, {0, 4, & tei_id_remove}, {0, 3, & tei_id_chk_req}, {1, 6, & tei_id_req_tout}, {1, 1, & tei_id_assign}, {1, 2, & tei_id_denied}, {2, 6, & tei_id_ver_tout}, {2, 4, & tei_id_remove}, {2, 3, & tei_id_chk_req}}; int TeiNew(void) { int tmp ; { teifsm.state_count = 3; teifsm.event_count = 7; teifsm.strEvent = (char **)(& strTeiEvent); teifsm.strState = (char **)(& strTeiState); tmp = FsmNew(& teifsm, (struct FsmNode *)(& TeiFnList), 11); return (tmp); } } void TeiFree(void) { { FsmFree(& teifsm); return; } } void ldv_mutex_lock_29(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_lock(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_30(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_lock(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_31(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } int ldv_mutex_trylock_32(struct mutex *ldv_func_arg1 ) { ldv_func_ret_type___2 ldv_func_res ; int tmp ; int tmp___0 ; { tmp = mutex_trylock(ldv_func_arg1); ldv_func_res = tmp; tmp___0 = ldv_mutex_trylock_mutex(ldv_func_arg1); return (tmp___0); return (ldv_func_res); } } void ldv_mutex_unlock_33(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_34(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_cred_guard_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_35(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_cred_guard_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } int ldv_mutex_trylock_46(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_44(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_47(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_49(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_43(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_45(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_48(struct mutex *ldv_func_arg1 ) ; extern struct sk_buff *skb_realloc_headroom(struct sk_buff * , unsigned int ) ; extern void skb_queue_head(struct sk_buff_head * , struct sk_buff * ) ; extern unsigned char *skb_push(struct sk_buff * , unsigned int ) ; __inline static unsigned int skb_headroom(struct sk_buff const *skb ) { { return ((unsigned int )((long )skb->data) - (unsigned int )((long )skb->head)); } } void setstack_isdnl2(struct PStack *st , char *debug_id ) ; void releasestack_isdnl2(struct PStack *st ) ; void setstack_transl2(struct PStack *st ) ; void releasestack_transl2(struct PStack *st ) ; char const *l2_revision = "$Revision: 2.30.2.4 $"; static void l2m_debug(struct FsmInst *fi , char *fmt , ...) ; static struct Fsm l2fsm ; static char *strL2State[8U] = { (char *)"ST_L2_1", (char *)"ST_L2_2", (char *)"ST_L2_3", (char *)"ST_L2_4", (char *)"ST_L2_5", (char *)"ST_L2_6", (char *)"ST_L2_7", (char *)"ST_L2_8"}; static char *strL2Event[22U] = { (char *)"EV_L2_UI", (char *)"EV_L2_SABME", (char *)"EV_L2_DISC", (char *)"EV_L2_DM", (char *)"EV_L2_UA", (char *)"EV_L2_FRMR", (char *)"EV_L2_SUPER", (char *)"EV_L2_I", (char *)"EV_L2_DL_DATA", (char *)"EV_L2_ACK_PULL", (char *)"EV_L2_DL_UNIT_DATA", (char *)"EV_L2_DL_ESTABLISH_REQ", (char *)"EV_L2_DL_RELEASE_REQ", (char *)"EV_L2_MDL_ASSIGN", (char *)"EV_L2_MDL_REMOVE", (char *)"EV_L2_MDL_ERROR", (char *)"EV_L1_DEACTIVATE", (char *)"EV_L2_T200", (char *)"EV_L2_T203", (char *)"EV_L2_SET_OWN_BUSY", (char *)"EV_L2_CLEAR_OWN_BUSY", (char *)"EV_L2_FRAME_ERROR"}; __inline static int l2addrsize(struct Layer2 *l2 ) ; static void set_peer_busy(struct Layer2 *l2 ) { int tmp ; int tmp___0 ; { test_and_set_bit(10, (unsigned long volatile *)(& l2->flag)); tmp = skb_queue_empty((struct sk_buff_head const *)(& l2->i_queue)); if (tmp == 0) { test_and_set_bit(16, (unsigned long volatile *)(& l2->flag)); } else { tmp___0 = skb_queue_empty((struct sk_buff_head const *)(& l2->ui_queue)); if (tmp___0 == 0) { test_and_set_bit(16, (unsigned long volatile *)(& l2->flag)); } else { } } return; } } static void clear_peer_busy(struct Layer2 *l2 ) { int tmp ; { tmp = test_and_clear_bit(10, (unsigned long volatile *)(& l2->flag)); if (tmp != 0) { test_and_clear_bit(16, (unsigned long volatile *)(& l2->flag)); } else { } return; } } static void InitWin(struct Layer2 *l2 ) { int i ; { i = 0; goto ldv_40992; ldv_40991: l2->windowar[i] = 0; i = i + 1; ldv_40992: ; if (i <= 7) { goto ldv_40991; } else { } return; } } static int freewin1(struct Layer2 *l2 ) { int i ; int cnt ; { cnt = 0; i = 0; goto ldv_41000; ldv_40999: ; if ((unsigned long )l2->windowar[i] != (unsigned long )((struct sk_buff *)0)) { cnt = cnt + 1; consume_skb(l2->windowar[i]); l2->windowar[i] = 0; } else { } i = i + 1; ldv_41000: ; if (i <= 7) { goto ldv_40999; } else { } return (cnt); } } __inline static void freewin(struct PStack *st ) { { freewin1(& st->l2); return; } } static void ReleaseWin(struct Layer2 *l2 ) { int cnt ; { cnt = freewin1(l2); if (cnt != 0) { printk("\fisdl2 freed %d skbuffs in release\n", cnt); } else { } return; } } __inline static unsigned int cansend(struct PStack *st ) { unsigned int p1 ; int tmp ; int tmp___0 ; int tmp___1 ; { tmp = constant_test_bit(3U, (unsigned long const volatile *)(& st->l2.flag)); if (tmp != 0) { p1 = (st->l2.vs - st->l2.va) & 127U; } else { p1 = (st->l2.vs - st->l2.va) & 7U; } if (st->l2.window > p1) { tmp___0 = constant_test_bit(10U, (unsigned long const volatile *)(& st->l2.flag)); if (tmp___0 == 0) { tmp___1 = 1; } else { tmp___1 = 0; } } else { tmp___1 = 0; } return ((unsigned int )tmp___1); } } __inline static void clear_exception(struct Layer2 *l2 ) { { test_and_clear_bit(7, (unsigned long volatile *)(& l2->flag)); test_and_clear_bit(8, (unsigned long volatile *)(& l2->flag)); test_and_clear_bit(9, (unsigned long volatile *)(& l2->flag)); clear_peer_busy(l2); return; } } __inline static int l2headersize(struct Layer2 *l2 , int ui ) { int tmp ; int tmp___0 ; { tmp = constant_test_bit(3U, (unsigned long const volatile *)(& l2->flag)); tmp___0 = constant_test_bit(1U, (unsigned long const volatile *)(& l2->flag)); return ((tmp != 0 && ui == 0 ? 2 : 1) + (tmp___0 != 0 ? 2 : 1)); } } __inline static int l2addrsize(struct Layer2 *l2 ) { int tmp ; { tmp = constant_test_bit(1U, (unsigned long const volatile *)(& l2->flag)); return (tmp != 0 ? 2 : 1); } } static int sethdraddr(struct Layer2 *l2 , u_char *header , int rsp ) { u_char *ptr ; int crbit ; u_char *tmp ; u_char *tmp___0 ; int tmp___1 ; u_char *tmp___2 ; u_char *tmp___3 ; int tmp___4 ; { ptr = header; crbit = rsp; tmp___4 = constant_test_bit(1U, (unsigned long const volatile *)(& l2->flag)); if (tmp___4 != 0) { tmp = ptr; ptr = ptr + 1; *tmp = (u_char )((int )((signed char )(l2->sap << 2)) | (rsp != 0 ? 2 : 0)); tmp___0 = ptr; ptr = ptr + 1; *tmp___0 = (u_char )((int )((signed char )(l2->tei << 1)) | 1); return (2); } else { tmp___1 = constant_test_bit(2U, (unsigned long const volatile *)(& l2->flag)); if (tmp___1 != 0) { crbit = crbit == 0; } else { } if (crbit != 0) { tmp___2 = ptr; ptr = ptr + 1; *tmp___2 = 1U; } else { tmp___3 = ptr; ptr = ptr + 1; *tmp___3 = 3U; } return (1); } } } __inline static void enqueue_super(struct PStack *st , struct sk_buff *skb ) { int tmp ; { tmp = constant_test_bit(0U, (unsigned long const volatile *)(& st->l2.flag)); if (tmp != 0) { (st->l1.bcs)->tx_cnt = (int )((unsigned int )(st->l1.bcs)->tx_cnt + skb->len); } else { } (*(st->l2.l2l1))(st, 288, (void *)skb); return; } } __inline static int IsUI(u_char *data ) { { return (((int )*data & 239) == 3); } } __inline static int IsUA(u_char *data ) { { return (((int )*data & 239) == 99); } } __inline static int IsDM(u_char *data ) { { return (((int )*data & 239) == 15); } } __inline static int IsDISC(u_char *data ) { { return (((int )*data & 239) == 67); } } __inline static int IsSFrame(u_char *data , struct PStack *st ) { register u_char d ; int tmp ; { d = *data; tmp = constant_test_bit(3U, (unsigned long const volatile *)(& st->l2.flag)); if (tmp == 0) { d = (unsigned int )d & 15U; } else { } return (((int )d & 243) == 1 && ((int )d & 12) != 12); } } __inline static int IsSABME(u_char *data , struct PStack *st ) { u_char d ; int tmp ; { d = (unsigned int )*data & 239U; tmp = constant_test_bit(3U, (unsigned long const volatile *)(& st->l2.flag)); return (tmp != 0 ? (unsigned int )d == 111U : (unsigned int )d == 47U); } } __inline static int IsREJ(u_char *data , struct PStack *st ) { int tmp ; { tmp = constant_test_bit(3U, (unsigned long const volatile *)(& st->l2.flag)); return (tmp != 0 ? (unsigned int )*data == 9U : ((int )*data & 15) == 9); } } __inline static int IsFRMR(u_char *data ) { { return (((int )*data & 239) == 135); } } __inline static int IsRNR(u_char *data , struct PStack *st ) { int tmp ; { tmp = constant_test_bit(3U, (unsigned long const volatile *)(& st->l2.flag)); return (tmp != 0 ? (unsigned int )*data == 5U : ((int )*data & 15) == 5); } } static int iframe_error(struct PStack *st , struct sk_buff *skb ) { int i ; int tmp ; int tmp___0 ; int rsp ; int tmp___1 ; { tmp = l2addrsize(& st->l2); tmp___0 = constant_test_bit(3U, (unsigned long const volatile *)(& st->l2.flag)); i = tmp + (tmp___0 != 0 ? 2 : 1); rsp = (int )*(skb->data) & 2; tmp___1 = constant_test_bit(2U, (unsigned long const volatile *)(& st->l2.flag)); if (tmp___1 != 0) { rsp = rsp == 0; } else { } if (rsp != 0) { return (76); } else { } if (skb->len < (unsigned int )i) { return (78); } else { } if (skb->len - (unsigned int )i > (unsigned int )st->l2.maxlen) { return (79); } else { } return (0); } } static int super_error(struct PStack *st , struct sk_buff *skb ) { int tmp ; int tmp___0 ; { tmp = l2addrsize(& st->l2); tmp___0 = constant_test_bit(3U, (unsigned long const volatile *)(& st->l2.flag)); if (skb->len != (unsigned int )(tmp + (tmp___0 != 0 ? 2 : 1))) { return (78); } else { } return (0); } } static int unnum_error(struct PStack *st , struct sk_buff *skb , int wantrsp ) { int rsp ; int tmp ; int tmp___0 ; { rsp = ((int )*(skb->data) & 2) >> 1; tmp = constant_test_bit(2U, (unsigned long const volatile *)(& st->l2.flag)); if (tmp != 0) { rsp = rsp == 0; } else { } if (rsp != wantrsp) { return (76); } else { } tmp___0 = l2addrsize(& st->l2); if (skb->len != (unsigned int )(tmp___0 + 1)) { return (78); } else { } return (0); } } static int UI_error(struct PStack *st , struct sk_buff *skb ) { int rsp ; int tmp ; int tmp___0 ; { rsp = (int )*(skb->data) & 2; tmp = constant_test_bit(2U, (unsigned long const volatile *)(& st->l2.flag)); if (tmp != 0) { rsp = rsp == 0; } else { } if (rsp != 0) { return (76); } else { } tmp___0 = l2addrsize(& st->l2); if (skb->len > (unsigned int )((st->l2.maxlen + tmp___0) + 1)) { return (79); } else { } return (0); } } static int FRMR_error(struct PStack *st , struct sk_buff *skb ) { int headers ; int tmp ; u_char *datap ; int rsp ; int tmp___0 ; int tmp___1 ; { tmp = l2addrsize(& st->l2); headers = tmp + 1; datap = skb->data + (unsigned long )headers; rsp = (int )*(skb->data) & 2; tmp___0 = constant_test_bit(2U, (unsigned long const volatile *)(& st->l2.flag)); if (tmp___0 != 0) { rsp = rsp == 0; } else { } if (rsp == 0) { return (76); } else { } tmp___1 = constant_test_bit(3U, (unsigned long const volatile *)(& st->l2.flag)); if (tmp___1 != 0) { if (skb->len < (unsigned int )(headers + 5)) { return (78); } else { l2m_debug(& st->l2.l2m, (char *)"FRMR information %2x %2x %2x %2x %2x", (int )*datap, (int )*(datap + 1UL), (int )*(datap + 2UL), (int )*(datap + 3UL), (int )*(datap + 4UL)); } } else if (skb->len < (unsigned int )(headers + 3)) { return (78); } else { l2m_debug(& st->l2.l2m, (char *)"FRMR information %2x %2x %2x", (int )*datap, (int )*(datap + 1UL), (int )*(datap + 2UL)); } return (0); } } static unsigned int legalnr(struct PStack *st , unsigned int nr ) { struct Layer2 *l2 ; int tmp ; { l2 = & st->l2; tmp = constant_test_bit(3U, (unsigned long const volatile *)(& l2->flag)); if (tmp != 0) { return (((nr - l2->va) & 127U) <= ((l2->vs - l2->va) & 127U)); } else { return (((nr - l2->va) & 7U) <= ((l2->vs - l2->va) & 7U)); } } } static void setva(struct PStack *st , unsigned int nr ) { struct Layer2 *l2 ; int len ; u_long flags ; raw_spinlock_t *tmp ; int tmp___0 ; int tmp___1 ; raw_spinlock_t *tmp___2 ; { l2 = & st->l2; tmp = spinlock_check(& l2->lock); flags = _raw_spin_lock_irqsave(tmp); goto ldv_41114; ldv_41113: l2->va = l2->va + 1U; tmp___0 = constant_test_bit(3U, (unsigned long const volatile *)(& l2->flag)); if (tmp___0 != 0) { l2->va = l2->va & 127U; } else { l2->va = l2->va & 7U; } len = (int )(l2->windowar[l2->sow])->len; if ((unsigned int )*((unsigned char *)l2->windowar[l2->sow] + 125UL) == 7U) { len = -1; } else { } consume_skb(l2->windowar[l2->sow]); l2->windowar[l2->sow] = 0; l2->sow = (l2->sow + 1U) % l2->window; spin_unlock_irqrestore(& l2->lock, flags); tmp___1 = constant_test_bit(2U, (unsigned long const volatile *)(& st->lli.flag)); if (tmp___1 != 0 && len >= 0) { lli_writewakeup(st, len); } else { } tmp___2 = spinlock_check(& l2->lock); flags = _raw_spin_lock_irqsave(tmp___2); ldv_41114: ; if (l2->va != nr) { goto ldv_41113; } else { } spin_unlock_irqrestore(& l2->lock, flags); return; } } static void send_uframe(struct PStack *st , u_char cmd , u_char cr ) { struct sk_buff *skb ; u_char tmp[4U] ; int i ; int tmp___0 ; size_t __len ; void *__ret ; unsigned char *tmp___2 ; { i = sethdraddr(& st->l2, (u_char *)(& tmp), (int )cr); tmp___0 = i; i = i + 1; tmp[tmp___0] = cmd; skb = alloc_skb((unsigned int )i, 32U); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { printk("\fisdl2 can\'t alloc sbbuff for send_uframe\n"); return; } else { } __len = (size_t )i; tmp___2 = skb_put(skb, (unsigned int )i); __ret = memcpy((void *)tmp___2, (void const *)(& tmp), __len); enqueue_super(st, skb); return; } } __inline static u_char get_PollFlag(struct PStack *st , struct sk_buff *skb ) { int tmp ; { tmp = l2addrsize(& st->l2); return ((unsigned int )*(skb->data + (unsigned long )tmp) & 16U); } } __inline static u_char get_PollFlagFree(struct PStack *st , struct sk_buff *skb ) { u_char PF ; { PF = get_PollFlag(st, skb); consume_skb(skb); return (PF); } } __inline static void start_t200(struct PStack *st , int i ) { { FsmAddTimer(& st->l2.t200, st->l2.T200, 17, 0, i); test_and_set_bit(6, (unsigned long volatile *)(& st->l2.flag)); return; } } __inline static void restart_t200(struct PStack *st , int i ) { { FsmRestartTimer(& st->l2.t200, st->l2.T200, 17, 0, i); test_and_set_bit(6, (unsigned long volatile *)(& st->l2.flag)); return; } } __inline static void stop_t200(struct PStack *st , int i ) { int tmp ; { tmp = test_and_clear_bit(6, (unsigned long volatile *)(& st->l2.flag)); if (tmp != 0) { FsmDelTimer(& st->l2.t200, i); } else { } return; } } __inline static void st5_dl_release_l2l3(struct PStack *st ) { int pr ; int tmp ; { tmp = test_and_clear_bit(4, (unsigned long volatile *)(& st->l2.flag)); if (tmp != 0) { pr = 529; } else { pr = 530; } (*(st->l2.l2l3))(st, pr, 0); return; } } __inline static void lapb_dl_release_l2l3(struct PStack *st , int f ) { int tmp ; { tmp = constant_test_bit(0U, (unsigned long const volatile *)(& st->l2.flag)); if (tmp != 0) { (*(st->l2.l2l1))(st, 272, 0); } else { } (*(st->l2.l2l3))(st, f | 528, 0); return; } } static void establishlink(struct FsmInst *fi ) { struct PStack *st ; u_char cmd ; int tmp ; { st = (struct PStack *)fi->userdata; clear_exception(& st->l2); st->l2.rc = 0; tmp = constant_test_bit(3U, (unsigned long const volatile *)(& st->l2.flag)); cmd = tmp != 0 ? 127U : 63U; send_uframe(st, (int )cmd, 0); FsmDelTimer(& st->l2.t203, 1); restart_t200(st, 1); test_and_clear_bit(4, (unsigned long volatile *)(& st->l2.flag)); freewin(st); FsmChangeState(fi, 4); return; } } static void l2_mdl_error_ua(struct FsmInst *fi , int event , void *arg ) { struct sk_buff *skb ; struct PStack *st ; u_char tmp ; { skb = (struct sk_buff *)arg; st = (struct PStack *)fi->userdata; tmp = get_PollFlagFree(st, skb); if ((unsigned int )tmp != 0U) { (*(st->ma.layer))(st, 650, 67); } else { (*(st->ma.layer))(st, 650, 68); } return; } } static void l2_mdl_error_dm(struct FsmInst *fi , int event , void *arg ) { struct sk_buff *skb ; struct PStack *st ; u_char tmp ; { skb = (struct sk_buff *)arg; st = (struct PStack *)fi->userdata; tmp = get_PollFlagFree(st, skb); if ((unsigned int )tmp != 0U) { (*(st->ma.layer))(st, 650, 66); } else { (*(st->ma.layer))(st, 650, 69); establishlink(fi); test_and_clear_bit(5, (unsigned long volatile *)(& st->l2.flag)); } return; } } static void l2_st8_mdl_error_dm(struct FsmInst *fi , int event , void *arg ) { struct sk_buff *skb ; struct PStack *st ; u_char tmp ; { skb = (struct sk_buff *)arg; st = (struct PStack *)fi->userdata; tmp = get_PollFlagFree(st, skb); if ((unsigned int )tmp != 0U) { (*(st->ma.layer))(st, 650, 66); } else { (*(st->ma.layer))(st, 650, 69); } establishlink(fi); test_and_clear_bit(5, (unsigned long volatile *)(& st->l2.flag)); return; } } static void l2_go_st3(struct FsmInst *fi , int event , void *arg ) { { FsmChangeState(fi, 2); return; } } static void l2_mdl_assign(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; { st = (struct PStack *)fi->userdata; FsmChangeState(fi, 2); (*(st->l2.l2tei))(st, 642, 0); return; } } static void l2_queue_ui_assign(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; struct sk_buff *skb ; { st = (struct PStack *)fi->userdata; skb = (struct sk_buff *)arg; skb_queue_tail(& st->l2.ui_queue, skb); FsmChangeState(fi, 1); (*(st->l2.l2tei))(st, 642, 0); return; } } static void l2_queue_ui(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; struct sk_buff *skb ; { st = (struct PStack *)fi->userdata; skb = (struct sk_buff *)arg; skb_queue_tail(& st->l2.ui_queue, skb); return; } } static void tx_ui(struct PStack *st ) { struct sk_buff *skb ; u_char header[4U] ; int i ; int tmp ; size_t __len ; void *__ret ; unsigned char *tmp___1 ; { i = sethdraddr(& st->l2, (u_char *)(& header), 0); tmp = i; i = i + 1; header[tmp] = 3U; goto ldv_41217; ldv_41216: __len = (size_t )i; tmp___1 = skb_push(skb, (unsigned int )i); __ret = memcpy((void *)tmp___1, (void const *)(& header), __len); enqueue_super(st, skb); ldv_41217: skb = skb_dequeue(& st->l2.ui_queue); if ((unsigned long )skb != (unsigned long )((struct sk_buff *)0)) { goto ldv_41216; } else { } return; } } static void l2_send_ui(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; struct sk_buff *skb ; { st = (struct PStack *)fi->userdata; skb = (struct sk_buff *)arg; skb_queue_tail(& st->l2.ui_queue, skb); tx_ui(st); return; } } static void l2_got_ui(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; struct sk_buff *skb ; int tmp ; { st = (struct PStack *)fi->userdata; skb = (struct sk_buff *)arg; tmp = l2headersize(& st->l2, 1); skb_pull(skb, (unsigned int )tmp); (*(st->l2.l2l3))(st, 562, (void *)skb); return; } } static void l2_establish(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; { st = (struct PStack *)fi->userdata; establishlink(fi); test_and_set_bit(5, (unsigned long volatile *)(& st->l2.flag)); return; } } static void l2_discard_i_setl3(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; { st = (struct PStack *)fi->userdata; skb_queue_purge(& st->l2.i_queue); test_and_set_bit(5, (unsigned long volatile *)(& st->l2.flag)); test_and_clear_bit(4, (unsigned long volatile *)(& st->l2.flag)); return; } } static void l2_l3_reestablish(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; { st = (struct PStack *)fi->userdata; skb_queue_purge(& st->l2.i_queue); establishlink(fi); test_and_set_bit(5, (unsigned long volatile *)(& st->l2.flag)); return; } } static void l2_release(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; { st = (struct PStack *)fi->userdata; (*(st->l2.l2l3))(st, 529, 0); return; } } static void l2_pend_rel(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; { st = (struct PStack *)fi->userdata; test_and_set_bit(4, (unsigned long volatile *)(& st->l2.flag)); return; } } static void l2_disconnect(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; { st = (struct PStack *)fi->userdata; skb_queue_purge(& st->l2.i_queue); freewin(st); FsmChangeState(fi, 5); st->l2.rc = 0; send_uframe(st, 83, 0); FsmDelTimer(& st->l2.t203, 1); restart_t200(st, 2); return; } } static void l2_start_multi(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; struct sk_buff *skb ; u_char tmp ; { st = (struct PStack *)fi->userdata; skb = (struct sk_buff *)arg; tmp = get_PollFlagFree(st, skb); send_uframe(st, (int )((unsigned int )tmp | 99U), 1); clear_exception(& st->l2); st->l2.vs = 0U; st->l2.va = 0U; st->l2.vr = 0U; st->l2.sow = 0U; FsmChangeState(fi, 6); FsmAddTimer(& st->l2.t203, st->l2.T203, 18, 0, 3); (*(st->l2.l2l3))(st, 514, 0); return; } } static void l2_send_UA(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; struct sk_buff *skb ; u_char tmp ; { st = (struct PStack *)fi->userdata; skb = (struct sk_buff *)arg; tmp = get_PollFlagFree(st, skb); send_uframe(st, (int )((unsigned int )tmp | 99U), 1); return; } } static void l2_send_DM(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; struct sk_buff *skb ; u_char tmp ; { st = (struct PStack *)fi->userdata; skb = (struct sk_buff *)arg; tmp = get_PollFlagFree(st, skb); send_uframe(st, (int )((unsigned int )tmp | 15U), 1); return; } } static void l2_restart_multi(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; struct sk_buff *skb ; int est ; int state ; u_char tmp ; int tmp___0 ; unsigned int tmp___1 ; { st = (struct PStack *)fi->userdata; skb = (struct sk_buff *)arg; est = 0; state = fi->state; tmp = get_PollFlagFree(st, skb); send_uframe(st, (int )((unsigned int )tmp | 99U), 1); (*(st->ma.layer))(st, 650, 70); if (st->l2.vs != st->l2.va) { skb_queue_purge(& st->l2.i_queue); est = 1; } else { } clear_exception(& st->l2); st->l2.vs = 0U; st->l2.va = 0U; st->l2.vr = 0U; st->l2.sow = 0U; FsmChangeState(fi, 6); stop_t200(st, 3); FsmRestartTimer(& st->l2.t203, st->l2.T203, 18, 0, 3); if (est != 0) { (*(st->l2.l2l3))(st, 514, 0); } else { } if (state == 6 || state == 7) { tmp___0 = skb_queue_empty((struct sk_buff_head const *)(& st->l2.i_queue)); if (tmp___0 == 0) { tmp___1 = cansend(st); if (tmp___1 != 0U) { (*(st->l2.l2l1))(st, 304, 0); } else { } } else { } } else { } return; } } static void l2_stop_multi(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; struct sk_buff *skb ; u_char tmp ; { st = (struct PStack *)fi->userdata; skb = (struct sk_buff *)arg; FsmChangeState(fi, 3); FsmDelTimer(& st->l2.t203, 3); stop_t200(st, 4); tmp = get_PollFlagFree(st, skb); send_uframe(st, (int )((unsigned int )tmp | 99U), 1); skb_queue_purge(& st->l2.i_queue); freewin(st); lapb_dl_release_l2l3(st, 2); return; } } static void l2_connected(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; struct sk_buff *skb ; int pr ; u_char tmp ; int tmp___0 ; int tmp___1 ; int tmp___2 ; unsigned int tmp___3 ; { st = (struct PStack *)fi->userdata; skb = (struct sk_buff *)arg; pr = -1; tmp = get_PollFlag(st, skb); if ((unsigned int )tmp == 0U) { l2_mdl_error_ua(fi, event, arg); return; } else { } consume_skb(skb); tmp___0 = test_and_clear_bit(4, (unsigned long volatile *)(& st->l2.flag)); if (tmp___0 != 0) { l2_disconnect(fi, event, arg); } else { } tmp___1 = test_and_clear_bit(5, (unsigned long volatile *)(& st->l2.flag)); if (tmp___1 != 0) { pr = 513; } else if (st->l2.vs != st->l2.va) { skb_queue_purge(& st->l2.i_queue); pr = 514; } else { } stop_t200(st, 5); st->l2.vr = 0U; st->l2.vs = 0U; st->l2.va = 0U; st->l2.sow = 0U; FsmChangeState(fi, 6); FsmAddTimer(& st->l2.t203, st->l2.T203, 18, 0, 4); if (pr != -1) { (*(st->l2.l2l3))(st, pr, 0); } else { } tmp___2 = skb_queue_empty((struct sk_buff_head const *)(& st->l2.i_queue)); if (tmp___2 == 0) { tmp___3 = cansend(st); if (tmp___3 != 0U) { (*(st->l2.l2l1))(st, 304, 0); } else { } } else { } return; } } static void l2_released(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; struct sk_buff *skb ; u_char tmp ; { st = (struct PStack *)fi->userdata; skb = (struct sk_buff *)arg; tmp = get_PollFlag(st, skb); if ((unsigned int )tmp == 0U) { l2_mdl_error_ua(fi, event, arg); return; } else { } consume_skb(skb); stop_t200(st, 6); lapb_dl_release_l2l3(st, 1); FsmChangeState(fi, 3); return; } } static void l2_reestablish(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; struct sk_buff *skb ; u_char tmp ; { st = (struct PStack *)fi->userdata; skb = (struct sk_buff *)arg; tmp = get_PollFlagFree(st, skb); if ((unsigned int )tmp == 0U) { establishlink(fi); test_and_set_bit(5, (unsigned long volatile *)(& st->l2.flag)); } else { } return; } } static void l2_st5_dm_release(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; struct sk_buff *skb ; int tmp ; int tmp___0 ; u_char tmp___1 ; { st = (struct PStack *)fi->userdata; skb = (struct sk_buff *)arg; tmp___1 = get_PollFlagFree(st, skb); if ((unsigned int )tmp___1 != 0U) { stop_t200(st, 7); tmp = constant_test_bit(5U, (unsigned long const volatile *)(& st->l2.flag)); if (tmp == 0) { skb_queue_purge(& st->l2.i_queue); } else { } tmp___0 = constant_test_bit(0U, (unsigned long const volatile *)(& st->l2.flag)); if (tmp___0 != 0) { (*(st->l2.l2l1))(st, 272, 0); } else { } st5_dl_release_l2l3(st); FsmChangeState(fi, 3); } else { } return; } } static void l2_st6_dm_release(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; struct sk_buff *skb ; u_char tmp ; { st = (struct PStack *)fi->userdata; skb = (struct sk_buff *)arg; tmp = get_PollFlagFree(st, skb); if ((unsigned int )tmp != 0U) { stop_t200(st, 8); lapb_dl_release_l2l3(st, 1); FsmChangeState(fi, 3); } else { } return; } } __inline static void enquiry_cr(struct PStack *st , u_char typ , u_char cr , u_char pf ) { struct sk_buff *skb ; struct Layer2 *l2 ; u_char tmp[4U] ; int i ; int tmp___0 ; int tmp___1 ; int tmp___2 ; int tmp___3 ; size_t __len ; void *__ret ; unsigned char *tmp___5 ; { l2 = & st->l2; i = sethdraddr(l2, (u_char *)(& tmp), (int )cr); tmp___3 = constant_test_bit(3U, (unsigned long const volatile *)(& l2->flag)); if (tmp___3 != 0) { tmp___0 = i; i = i + 1; tmp[tmp___0] = typ; tmp___1 = i; i = i + 1; tmp[tmp___1] = (unsigned int )((int )((u_char )l2->vr) << 1U) | ((unsigned int )pf != 0U ? 1U : 0U); } else { tmp___2 = i; i = i + 1; tmp[tmp___2] = (unsigned int )(((int )((u_char )l2->vr) << 5U) | (int )typ) | ((unsigned int )pf != 0U ? 16U : 0U); } skb = alloc_skb((unsigned int )i, 32U); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { printk("\fisdl2 can\'t alloc sbbuff for enquiry_cr\n"); return; } else { } __len = (size_t )i; tmp___5 = skb_put(skb, (unsigned int )i); __ret = memcpy((void *)tmp___5, (void const *)(& tmp), __len); enqueue_super(st, skb); return; } } __inline static void enquiry_response(struct PStack *st ) { int tmp ; { tmp = constant_test_bit(9U, (unsigned long const volatile *)(& st->l2.flag)); if (tmp != 0) { enquiry_cr(st, 5, 1, 1); } else { enquiry_cr(st, 1, 1, 1); } test_and_clear_bit(7, (unsigned long volatile *)(& st->l2.flag)); return; } } __inline static void transmit_enquiry(struct PStack *st ) { int tmp ; { tmp = constant_test_bit(9U, (unsigned long const volatile *)(& st->l2.flag)); if (tmp != 0) { enquiry_cr(st, 5, 0, 1); } else { enquiry_cr(st, 1, 0, 1); } test_and_clear_bit(7, (unsigned long volatile *)(& st->l2.flag)); start_t200(st, 9); return; } } static void nrerrorrecovery(struct FsmInst *fi ) { struct PStack *st ; { st = (struct PStack *)fi->userdata; (*(st->ma.layer))(st, 650, 74); establishlink(fi); test_and_clear_bit(5, (unsigned long volatile *)(& st->l2.flag)); return; } } static void invoke_retransmission(struct PStack *st , unsigned int nr ) { struct Layer2 *l2 ; u_int p1 ; u_long flags ; raw_spinlock_t *tmp ; int tmp___0 ; int tmp___1 ; int tmp___2 ; { l2 = & st->l2; tmp = spinlock_check(& l2->lock); flags = _raw_spin_lock_irqsave(tmp); if (l2->vs != nr) { goto ldv_41376; ldv_41375: l2->vs = l2->vs - 1U; tmp___0 = constant_test_bit(3U, (unsigned long const volatile *)(& l2->flag)); if (tmp___0 != 0) { l2->vs = l2->vs & 127U; p1 = (l2->vs - l2->va) & 127U; } else { l2->vs = l2->vs & 7U; p1 = (l2->vs - l2->va) & 7U; } p1 = (l2->sow + p1) % l2->window; tmp___2 = constant_test_bit(0U, (unsigned long const volatile *)(& l2->flag)); if (tmp___2 != 0) { tmp___1 = l2headersize(l2, 0); (st->l1.bcs)->tx_cnt = (int )((unsigned int )(st->l1.bcs)->tx_cnt + ((l2->windowar[p1])->len + (unsigned int )tmp___1)); } else { } skb_queue_head(& l2->i_queue, l2->windowar[p1]); l2->windowar[p1] = 0; ldv_41376: ; if (l2->vs != nr) { goto ldv_41375; } else { } spin_unlock_irqrestore(& l2->lock, flags); (*(st->l2.l2l1))(st, 304, 0); return; } else { } spin_unlock_irqrestore(& l2->lock, flags); return; } } static void l2_st7_got_super(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; struct sk_buff *skb ; int PollFlag ; int rsp ; int typ ; unsigned int nr ; struct Layer2 *l2 ; int tmp ; int tmp___0 ; int tmp___1 ; int tmp___2 ; int tmp___3 ; int tmp___4 ; int tmp___5 ; unsigned int tmp___6 ; { st = (struct PStack *)fi->userdata; skb = (struct sk_buff *)arg; typ = 1; l2 = & st->l2; rsp = (int )*(skb->data) & 2; tmp = constant_test_bit(2U, (unsigned long const volatile *)(& l2->flag)); if (tmp != 0) { rsp = rsp == 0; } else { } tmp___0 = l2addrsize(l2); skb_pull(skb, (unsigned int )tmp___0); tmp___1 = IsRNR(skb->data, st); if (tmp___1 != 0) { set_peer_busy(l2); typ = 5; } else { clear_peer_busy(l2); } tmp___2 = IsREJ(skb->data, st); if (tmp___2 != 0) { typ = 9; } else { } tmp___3 = constant_test_bit(3U, (unsigned long const volatile *)(& l2->flag)); if (tmp___3 != 0) { PollFlag = (int )*(skb->data + 1UL) & 1; nr = (unsigned int )((int )*(skb->data + 1UL) >> 1); } else { PollFlag = (int )*(skb->data) & 16; nr = (unsigned int )((int )*(skb->data) >> 5) & 7U; } consume_skb(skb); if (PollFlag != 0) { if (rsp != 0) { (*(st->ma.layer))(st, 650, 65); } else { enquiry_response(st); } } else { } tmp___6 = legalnr(st, nr); if (tmp___6 != 0U) { if (typ == 9) { setva(st, nr); invoke_retransmission(st, nr); stop_t200(st, 10); tmp___4 = FsmAddTimer(& st->l2.t203, st->l2.T203, 18, 0, 6); if (tmp___4 != 0) { l2m_debug(& st->l2.l2m, (char *)"Restart T203 ST7 REJ"); } else { } } else if (l2->vs == nr && typ == 1) { setva(st, nr); stop_t200(st, 11); FsmRestartTimer(& st->l2.t203, st->l2.T203, 18, 0, 7); } else if (l2->va != nr || typ == 5) { setva(st, nr); if (typ != 1) { FsmDelTimer(& st->l2.t203, 9); } else { } restart_t200(st, 12); } else { } tmp___5 = skb_queue_empty((struct sk_buff_head const *)(& st->l2.i_queue)); if (tmp___5 == 0 && typ == 1) { (*(st->l2.l2l1))(st, 304, 0); } else { } } else { nrerrorrecovery(fi); } return; } } static void l2_feed_i_if_reest(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; struct sk_buff *skb ; int tmp ; int tmp___0 ; int tmp___1 ; { st = (struct PStack *)fi->userdata; skb = (struct sk_buff *)arg; tmp___0 = constant_test_bit(0U, (unsigned long const volatile *)(& st->l2.flag)); if (tmp___0 != 0) { tmp = l2headersize(& st->l2, 0); (st->l1.bcs)->tx_cnt = (int )((unsigned int )(st->l1.bcs)->tx_cnt + (skb->len + (unsigned int )tmp)); } else { } tmp___1 = constant_test_bit(5U, (unsigned long const volatile *)(& st->l2.flag)); if (tmp___1 == 0) { skb_queue_tail(& st->l2.i_queue, skb); } else { consume_skb(skb); } return; } } static void l2_feed_i_pull(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; struct sk_buff *skb ; int tmp ; int tmp___0 ; { st = (struct PStack *)fi->userdata; skb = (struct sk_buff *)arg; tmp___0 = constant_test_bit(0U, (unsigned long const volatile *)(& st->l2.flag)); if (tmp___0 != 0) { tmp = l2headersize(& st->l2, 0); (st->l1.bcs)->tx_cnt = (int )((unsigned int )(st->l1.bcs)->tx_cnt + (skb->len + (unsigned int )tmp)); } else { } skb_queue_tail(& st->l2.i_queue, skb); (*(st->l2.l2l1))(st, 304, 0); return; } } static void l2_feed_iqueue(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; struct sk_buff *skb ; int tmp ; int tmp___0 ; { st = (struct PStack *)fi->userdata; skb = (struct sk_buff *)arg; tmp___0 = constant_test_bit(0U, (unsigned long const volatile *)(& st->l2.flag)); if (tmp___0 != 0) { tmp = l2headersize(& st->l2, 0); (st->l1.bcs)->tx_cnt = (int )((unsigned int )(st->l1.bcs)->tx_cnt + (skb->len + (unsigned int )tmp)); } else { } skb_queue_tail(& st->l2.i_queue, skb); return; } } static void l2_got_iframe(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; struct sk_buff *skb ; struct Layer2 *l2 ; int PollFlag ; int ns ; int i ; unsigned int nr ; int tmp ; int tmp___0 ; int tmp___1 ; int tmp___2 ; int tmp___3 ; int tmp___4 ; unsigned int tmp___5 ; int tmp___6 ; int tmp___7 ; { st = (struct PStack *)fi->userdata; skb = (struct sk_buff *)arg; l2 = & st->l2; i = l2addrsize(l2); tmp = constant_test_bit(3U, (unsigned long const volatile *)(& l2->flag)); if (tmp != 0) { PollFlag = (int )*(skb->data + ((unsigned long )i + 1UL)) & 1; ns = (int )*(skb->data + (unsigned long )i) >> 1; nr = (unsigned int )((int )*(skb->data + ((unsigned long )i + 1UL)) >> 1) & 127U; } else { PollFlag = (int )*(skb->data + (unsigned long )i) & 16; ns = ((int )*(skb->data + (unsigned long )i) >> 1) & 7; nr = (unsigned int )((int )*(skb->data + (unsigned long )i) >> 5) & 7U; } tmp___3 = constant_test_bit(9U, (unsigned long const volatile *)(& l2->flag)); if (tmp___3 != 0) { consume_skb(skb); if (PollFlag != 0) { enquiry_response(st); } else { } } else if (l2->vr == (u_int )ns) { l2->vr = l2->vr + 1U; tmp___0 = constant_test_bit(3U, (unsigned long const volatile *)(& l2->flag)); if (tmp___0 != 0) { l2->vr = l2->vr & 127U; } else { l2->vr = l2->vr & 7U; } test_and_clear_bit(8, (unsigned long volatile *)(& l2->flag)); if (PollFlag != 0) { enquiry_response(st); } else { test_and_set_bit(7, (unsigned long volatile *)(& l2->flag)); } tmp___1 = l2headersize(l2, 0); skb_pull(skb, (unsigned int )tmp___1); (*(st->l2.l2l3))(st, 546, (void *)skb); } else { consume_skb(skb); tmp___2 = test_and_set_bit(8, (unsigned long volatile *)(& l2->flag)); if (tmp___2 != 0) { if (PollFlag != 0) { enquiry_response(st); } else { enquiry_cr(st, 9, 1, (int )((u_char )PollFlag)); test_and_clear_bit(7, (unsigned long volatile *)(& l2->flag)); } } else { } } tmp___5 = legalnr(st, nr); if (tmp___5 != 0U) { tmp___4 = constant_test_bit(10U, (unsigned long const volatile *)(& st->l2.flag)); if (tmp___4 == 0 && fi->state == 6) { if (st->l2.vs == nr) { stop_t200(st, 13); FsmRestartTimer(& st->l2.t203, st->l2.T203, 18, 0, 7); } else if (st->l2.va != nr) { restart_t200(st, 14); } else { } } else { } setva(st, nr); } else { nrerrorrecovery(fi); return; } tmp___6 = skb_queue_empty((struct sk_buff_head const *)(& st->l2.i_queue)); if (tmp___6 == 0 && fi->state == 6) { (*(st->l2.l2l1))(st, 304, 0); } else { } tmp___7 = test_and_clear_bit(7, (unsigned long volatile *)(& st->l2.flag)); if (tmp___7 != 0) { enquiry_cr(st, 1, 1, 0); } else { } return; } } static void l2_got_tei(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; int tmp ; { st = (struct PStack *)fi->userdata; st->l2.tei = (int )((long )arg); if (fi->state == 2) { establishlink(fi); test_and_set_bit(5, (unsigned long volatile *)(& st->l2.flag)); } else { FsmChangeState(fi, 3); } tmp = skb_queue_empty((struct sk_buff_head const *)(& st->l2.ui_queue)); if (tmp == 0) { tx_ui(st); } else { } return; } } static void l2_st5_tout_200(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; int tmp ; int tmp___0 ; int tmp___1 ; int tmp___2 ; { st = (struct PStack *)fi->userdata; tmp___1 = constant_test_bit(1U, (unsigned long const volatile *)(& st->l2.flag)); if (tmp___1 != 0) { tmp___2 = constant_test_bit(11U, (unsigned long const volatile *)(& st->l2.flag)); if (tmp___2 != 0) { FsmAddTimer(& st->l2.t200, st->l2.T200, 17, 0, 9); } else { goto _L; } } else _L: /* CIL Label */ if (st->l2.rc == st->l2.N200) { FsmChangeState(fi, 3); test_and_clear_bit(6, (unsigned long volatile *)(& st->l2.flag)); skb_queue_purge(& st->l2.i_queue); (*(st->ma.layer))(st, 650, 71); tmp = constant_test_bit(0U, (unsigned long const volatile *)(& st->l2.flag)); if (tmp != 0) { (*(st->l2.l2l1))(st, 272, 0); } else { } st5_dl_release_l2l3(st); } else { st->l2.rc = st->l2.rc + 1; FsmAddTimer(& st->l2.t200, st->l2.T200, 17, 0, 9); tmp___0 = constant_test_bit(3U, (unsigned long const volatile *)(& st->l2.flag)); send_uframe(st, tmp___0 != 0 ? 127 : 63, 0); } return; } } static void l2_st6_tout_200(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; int tmp ; int tmp___0 ; { st = (struct PStack *)fi->userdata; tmp = constant_test_bit(1U, (unsigned long const volatile *)(& st->l2.flag)); if (tmp != 0) { tmp___0 = constant_test_bit(11U, (unsigned long const volatile *)(& st->l2.flag)); if (tmp___0 != 0) { FsmAddTimer(& st->l2.t200, st->l2.T200, 17, 0, 9); } else { goto _L; } } else _L: /* CIL Label */ if (st->l2.rc == st->l2.N200) { FsmChangeState(fi, 3); test_and_clear_bit(6, (unsigned long volatile *)(& st->l2.flag)); (*(st->ma.layer))(st, 650, 72); lapb_dl_release_l2l3(st, 1); } else { st->l2.rc = st->l2.rc + 1; FsmAddTimer(& st->l2.t200, st->l2.T200, 17, 0, 9); send_uframe(st, 83, 0); } return; } } static void l2_st7_tout_200(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; int tmp ; int tmp___0 ; { st = (struct PStack *)fi->userdata; tmp = constant_test_bit(1U, (unsigned long const volatile *)(& st->l2.flag)); if (tmp != 0) { tmp___0 = constant_test_bit(11U, (unsigned long const volatile *)(& st->l2.flag)); if (tmp___0 != 0) { FsmAddTimer(& st->l2.t200, st->l2.T200, 17, 0, 9); return; } else { } } else { } test_and_clear_bit(6, (unsigned long volatile *)(& st->l2.flag)); st->l2.rc = 0; FsmChangeState(fi, 7); transmit_enquiry(st); st->l2.rc = st->l2.rc + 1; return; } } static void l2_st8_tout_200(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; int tmp ; int tmp___0 ; { st = (struct PStack *)fi->userdata; tmp = constant_test_bit(1U, (unsigned long const volatile *)(& st->l2.flag)); if (tmp != 0) { tmp___0 = constant_test_bit(11U, (unsigned long const volatile *)(& st->l2.flag)); if (tmp___0 != 0) { FsmAddTimer(& st->l2.t200, st->l2.T200, 17, 0, 9); return; } else { } } else { } test_and_clear_bit(6, (unsigned long volatile *)(& st->l2.flag)); if (st->l2.rc == st->l2.N200) { (*(st->ma.layer))(st, 650, 73); establishlink(fi); test_and_clear_bit(5, (unsigned long volatile *)(& st->l2.flag)); } else { transmit_enquiry(st); st->l2.rc = st->l2.rc + 1; } return; } } static void l2_st7_tout_203(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; int tmp ; int tmp___0 ; { st = (struct PStack *)fi->userdata; tmp = constant_test_bit(1U, (unsigned long const volatile *)(& st->l2.flag)); if (tmp != 0) { tmp___0 = constant_test_bit(11U, (unsigned long const volatile *)(& st->l2.flag)); if (tmp___0 != 0) { FsmAddTimer(& st->l2.t203, st->l2.T203, 18, 0, 9); return; } else { } } else { } FsmChangeState(fi, 7); transmit_enquiry(st); st->l2.rc = 0; return; } } static void l2_pull_iqueue(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; struct sk_buff *skb ; struct Layer2 *l2 ; u_char header[4U] ; int i ; int hdr_space_needed ; unsigned int p1 ; u_long flags ; unsigned int tmp ; struct sk_buff *orig_skb ; unsigned int tmp___0 ; raw_spinlock_t *tmp___1 ; int tmp___2 ; int tmp___3 ; int tmp___4 ; int tmp___5 ; int tmp___6 ; size_t __len ; void *__ret ; unsigned char *tmp___8 ; int tmp___9 ; int tmp___10 ; unsigned int tmp___11 ; { st = (struct PStack *)fi->userdata; l2 = & st->l2; tmp = cansend(st); if (tmp == 0U) { return; } else { } skb = skb_dequeue(& l2->i_queue); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } hdr_space_needed = l2headersize(l2, 0); tmp___0 = skb_headroom((struct sk_buff const *)skb); if ((unsigned int )hdr_space_needed > tmp___0) { orig_skb = skb; skb = skb_realloc_headroom(skb, (unsigned int )hdr_space_needed); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { consume_skb(orig_skb); return; } else { } } else { } tmp___1 = spinlock_check(& l2->lock); flags = _raw_spin_lock_irqsave(tmp___1); tmp___2 = constant_test_bit(3U, (unsigned long const volatile *)(& l2->flag)); if (tmp___2 != 0) { p1 = (l2->vs - l2->va) & 127U; } else { p1 = (l2->vs - l2->va) & 7U; } p1 = (l2->sow + p1) % l2->window; if ((unsigned long )l2->windowar[p1] != (unsigned long )((struct sk_buff *)0)) { printk("\fisdnl2 try overwrite ack queue entry %d\n", p1); consume_skb(l2->windowar[p1]); } else { } l2->windowar[p1] = skb_clone(skb, 32U); i = sethdraddr(& st->l2, (u_char *)(& header), 0); tmp___6 = constant_test_bit(3U, (unsigned long const volatile *)(& l2->flag)); if (tmp___6 != 0) { tmp___3 = i; i = i + 1; header[tmp___3] = (int )((u_char )l2->vs) << 1U; tmp___4 = i; i = i + 1; header[tmp___4] = (int )((u_char )l2->vr) << 1U; l2->vs = (l2->vs + 1U) & 127U; } else { tmp___5 = i; i = i + 1; header[tmp___5] = ((int )((u_char )l2->vr) << 5U) | ((int )((u_char )l2->vs) << 1U); l2->vs = (l2->vs + 1U) & 7U; } spin_unlock_irqrestore(& l2->lock, flags); __len = (size_t )i; tmp___8 = skb_push(skb, (unsigned int )i); __ret = memcpy((void *)tmp___8, (void const *)(& header), __len); (*(st->l2.l2l1))(st, 306, (void *)skb); test_and_clear_bit(7, (unsigned long volatile *)(& st->l2.flag)); tmp___9 = test_and_set_bit(6, (unsigned long volatile *)(& st->l2.flag)); if (tmp___9 == 0) { FsmDelTimer(& st->l2.t203, 13); FsmAddTimer(& st->l2.t200, st->l2.T200, 17, 0, 11); } else { } tmp___10 = skb_queue_empty((struct sk_buff_head const *)(& l2->i_queue)); if (tmp___10 == 0) { tmp___11 = cansend(st); if (tmp___11 != 0U) { (*(st->l2.l2l1))(st, 304, 0); } else { } } else { } return; } } static void l2_st8_got_super(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; struct sk_buff *skb ; int PollFlag ; int rsp ; int rnr ; unsigned int nr ; struct Layer2 *l2 ; int tmp ; int tmp___0 ; int tmp___1 ; int tmp___2 ; int tmp___3 ; unsigned int tmp___4 ; unsigned int tmp___5 ; unsigned int tmp___6 ; { st = (struct PStack *)fi->userdata; skb = (struct sk_buff *)arg; rnr = 0; l2 = & st->l2; rsp = (int )*(skb->data) & 2; tmp = constant_test_bit(2U, (unsigned long const volatile *)(& l2->flag)); if (tmp != 0) { rsp = rsp == 0; } else { } tmp___0 = l2addrsize(l2); skb_pull(skb, (unsigned int )tmp___0); tmp___1 = IsRNR(skb->data, st); if (tmp___1 != 0) { set_peer_busy(l2); rnr = 1; } else { clear_peer_busy(l2); } tmp___2 = constant_test_bit(3U, (unsigned long const volatile *)(& l2->flag)); if (tmp___2 != 0) { PollFlag = (int )*(skb->data + 1UL) & 1; nr = (unsigned int )((int )*(skb->data + 1UL) >> 1); } else { PollFlag = (int )*(skb->data) & 16; nr = (unsigned int )((int )*(skb->data) >> 5) & 7U; } consume_skb(skb); if (rsp != 0 && PollFlag != 0) { tmp___5 = legalnr(st, nr); if (tmp___5 != 0U) { if (rnr != 0) { restart_t200(st, 15); } else { stop_t200(st, 16); FsmAddTimer(& l2->t203, l2->T203, 18, 0, 5); setva(st, nr); } invoke_retransmission(st, nr); FsmChangeState(fi, 6); tmp___3 = skb_queue_empty((struct sk_buff_head const *)(& l2->i_queue)); if (tmp___3 == 0) { tmp___4 = cansend(st); if (tmp___4 != 0U) { (*(st->l2.l2l1))(st, 304, 0); } else { } } else { } } else { nrerrorrecovery(fi); } } else { if (rsp == 0 && PollFlag != 0) { enquiry_response(st); } else { } tmp___6 = legalnr(st, nr); if (tmp___6 != 0U) { setva(st, nr); } else { nrerrorrecovery(fi); } } return; } } static void l2_got_FRMR(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; struct sk_buff *skb ; int tmp ; int tmp___0 ; { st = (struct PStack *)fi->userdata; skb = (struct sk_buff *)arg; tmp = l2addrsize(& st->l2); skb_pull(skb, (unsigned int )(tmp + 1)); if (((int )*(skb->data) & 1) == 0 || ((int )*(skb->data) & 3) == 1) { (*(st->ma.layer))(st, 650, 75); establishlink(fi); test_and_clear_bit(5, (unsigned long volatile *)(& st->l2.flag)); } else { tmp___0 = IsUA(skb->data); if (tmp___0 != 0 && fi->state == 6) { (*(st->ma.layer))(st, 650, 75); establishlink(fi); test_and_clear_bit(5, (unsigned long volatile *)(& st->l2.flag)); } else { } } consume_skb(skb); return; } } static void l2_st24_tei_remove(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; { st = (struct PStack *)fi->userdata; skb_queue_purge(& st->l2.ui_queue); st->l2.tei = -1; FsmChangeState(fi, 0); return; } } static void l2_st3_tei_remove(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; { st = (struct PStack *)fi->userdata; skb_queue_purge(& st->l2.ui_queue); st->l2.tei = -1; (*(st->l2.l2l3))(st, 530, 0); FsmChangeState(fi, 0); return; } } static void l2_st5_tei_remove(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; { st = (struct PStack *)fi->userdata; skb_queue_purge(& st->l2.i_queue); skb_queue_purge(& st->l2.ui_queue); freewin(st); st->l2.tei = -1; stop_t200(st, 17); st5_dl_release_l2l3(st); FsmChangeState(fi, 0); return; } } static void l2_st6_tei_remove(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; { st = (struct PStack *)fi->userdata; skb_queue_purge(& st->l2.ui_queue); st->l2.tei = -1; stop_t200(st, 18); (*(st->l2.l2l3))(st, 529, 0); FsmChangeState(fi, 0); return; } } static void l2_tei_remove(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; { st = (struct PStack *)fi->userdata; skb_queue_purge(& st->l2.i_queue); skb_queue_purge(& st->l2.ui_queue); freewin(st); st->l2.tei = -1; stop_t200(st, 17); FsmDelTimer(& st->l2.t203, 19); (*(st->l2.l2l3))(st, 530, 0); FsmChangeState(fi, 0); return; } } static void l2_st14_persistent_da(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; int tmp ; { st = (struct PStack *)fi->userdata; skb_queue_purge(& st->l2.i_queue); skb_queue_purge(& st->l2.ui_queue); tmp = test_and_clear_bit(13, (unsigned long volatile *)(& st->l2.flag)); if (tmp != 0) { (*(st->l2.l2l3))(st, 530, 0); } else { } return; } } static void l2_st5_persistent_da(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; { st = (struct PStack *)fi->userdata; skb_queue_purge(& st->l2.i_queue); skb_queue_purge(& st->l2.ui_queue); freewin(st); stop_t200(st, 19); st5_dl_release_l2l3(st); FsmChangeState(fi, 3); return; } } static void l2_st6_persistent_da(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; { st = (struct PStack *)fi->userdata; skb_queue_purge(& st->l2.ui_queue); stop_t200(st, 20); (*(st->l2.l2l3))(st, 529, 0); FsmChangeState(fi, 3); return; } } static void l2_persistent_da(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; { st = (struct PStack *)fi->userdata; skb_queue_purge(& st->l2.i_queue); skb_queue_purge(& st->l2.ui_queue); freewin(st); stop_t200(st, 19); FsmDelTimer(& st->l2.t203, 19); (*(st->l2.l2l3))(st, 530, 0); FsmChangeState(fi, 3); return; } } static void l2_set_own_busy(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; int tmp ; { st = (struct PStack *)fi->userdata; tmp = test_and_set_bit(9, (unsigned long volatile *)(& st->l2.flag)); if (tmp == 0) { enquiry_cr(st, 5, 1, 0); test_and_clear_bit(7, (unsigned long volatile *)(& st->l2.flag)); } else { } return; } } static void l2_clear_own_busy(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; int tmp ; { st = (struct PStack *)fi->userdata; tmp = test_and_clear_bit(9, (unsigned long volatile *)(& st->l2.flag)); if (tmp == 0) { enquiry_cr(st, 1, 1, 0); test_and_clear_bit(7, (unsigned long volatile *)(& st->l2.flag)); } else { } return; } } static void l2_frame_error(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; { st = (struct PStack *)fi->userdata; (*(st->ma.layer))(st, 650, arg); return; } } static void l2_frame_error_reest(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; { st = (struct PStack *)fi->userdata; (*(st->ma.layer))(st, 650, arg); establishlink(fi); test_and_clear_bit(5, (unsigned long volatile *)(& st->l2.flag)); return; } } static struct FsmNode L2FnList[88U] = { {0, 11, & l2_mdl_assign}, {1, 11, & l2_go_st3}, {3, 11, & l2_establish}, {4, 11, & l2_discard_i_setl3}, {6, 11, & l2_l3_reestablish}, {7, 11, & l2_l3_reestablish}, {3, 12, & l2_release}, {4, 12, & l2_pend_rel}, {6, 12, & l2_disconnect}, {7, 12, & l2_disconnect}, {4, 8, & l2_feed_i_if_reest}, {6, 8, & l2_feed_i_pull}, {7, 8, & l2_feed_iqueue}, {0, 10, & l2_queue_ui_assign}, {1, 10, & l2_queue_ui}, {2, 10, & l2_queue_ui}, {3, 10, & l2_send_ui}, {4, 10, & l2_send_ui}, {5, 10, & l2_send_ui}, {6, 10, & l2_send_ui}, {7, 10, & l2_send_ui}, {0, 13, & l2_got_tei}, {1, 13, & l2_got_tei}, {2, 13, & l2_got_tei}, {1, 15, & l2_st24_tei_remove}, {2, 15, & l2_st3_tei_remove}, {3, 14, & l2_st24_tei_remove}, {4, 14, & l2_st5_tei_remove}, {5, 14, & l2_st6_tei_remove}, {6, 14, & l2_tei_remove}, {7, 14, & l2_tei_remove}, {3, 1, & l2_start_multi}, {4, 1, & l2_send_UA}, {5, 1, & l2_send_DM}, {6, 1, & l2_restart_multi}, {7, 1, & l2_restart_multi}, {3, 2, & l2_send_DM}, {4, 2, & l2_send_DM}, {5, 2, & l2_send_UA}, {6, 2, & l2_stop_multi}, {7, 2, & l2_stop_multi}, {3, 4, & l2_mdl_error_ua}, {4, 4, & l2_connected}, {5, 4, & l2_released}, {6, 4, & l2_mdl_error_ua}, {7, 4, & l2_mdl_error_ua}, {3, 3, & l2_reestablish}, {4, 3, & l2_st5_dm_release}, {5, 3, & l2_st6_dm_release}, {6, 3, & l2_mdl_error_dm}, {7, 3, & l2_st8_mdl_error_dm}, {0, 0, & l2_got_ui}, {1, 0, & l2_got_ui}, {2, 0, & l2_got_ui}, {3, 0, & l2_got_ui}, {4, 0, & l2_got_ui}, {5, 0, & l2_got_ui}, {6, 0, & l2_got_ui}, {7, 0, & l2_got_ui}, {6, 5, & l2_got_FRMR}, {7, 5, & l2_got_FRMR}, {6, 6, & l2_st7_got_super}, {7, 6, & l2_st8_got_super}, {6, 7, & l2_got_iframe}, {7, 7, & l2_got_iframe}, {4, 17, & l2_st5_tout_200}, {5, 17, & l2_st6_tout_200}, {6, 17, & l2_st7_tout_200}, {7, 17, & l2_st8_tout_200}, {6, 18, & l2_st7_tout_203}, {6, 9, & l2_pull_iqueue}, {6, 19, & l2_set_own_busy}, {7, 19, & l2_set_own_busy}, {6, 20, & l2_clear_own_busy}, {7, 20, & l2_clear_own_busy}, {3, 21, & l2_frame_error}, {4, 21, & l2_frame_error}, {5, 21, & l2_frame_error}, {6, 21, & l2_frame_error_reest}, {7, 21, & l2_frame_error_reest}, {0, 16, & l2_st14_persistent_da}, {1, 16, & l2_st24_tei_remove}, {2, 16, & l2_st3_tei_remove}, {3, 16, & l2_st14_persistent_da}, {4, 16, & l2_st5_persistent_da}, {5, 16, & l2_st6_persistent_da}, {6, 16, & l2_persistent_da}, {7, 16, & l2_persistent_da}}; static void isdnl2_l1l2(struct PStack *st , int pr , void *arg ) { struct sk_buff *skb ; u_char *datap ; int ret ; int len ; int c ; int tmp ; int tmp___0 ; int tmp___1 ; int tmp___2 ; int tmp___3 ; int tmp___4 ; int tmp___5 ; int tmp___6 ; { skb = (struct sk_buff *)arg; ret = 1; c = 0; switch (pr) { case 290: datap = skb->data; len = l2addrsize(& st->l2); if (skb->len > (unsigned int )len) { datap = datap + (unsigned long )len; } else { FsmEvent(& st->l2.l2m, 21, 78); consume_skb(skb); return; } if (((int )*datap & 1) == 0) { c = iframe_error(st, skb); if (c == 0) { ret = FsmEvent(& st->l2.l2m, 7, (void *)skb); } else { tmp___5 = IsSFrame(datap, st); if (tmp___5 != 0) { c = super_error(st, skb); if (c == 0) { ret = FsmEvent(& st->l2.l2m, 6, (void *)skb); } else { tmp___4 = IsUI(datap); if (tmp___4 != 0) { c = UI_error(st, skb); if (c == 0) { ret = FsmEvent(& st->l2.l2m, 0, (void *)skb); } else { tmp___3 = IsSABME(datap, st); if (tmp___3 != 0) { c = unnum_error(st, skb, 0); if (c == 0) { ret = FsmEvent(& st->l2.l2m, 1, (void *)skb); } else { tmp___2 = IsUA(datap); if (tmp___2 != 0) { c = unnum_error(st, skb, 1); if (c == 0) { ret = FsmEvent(& st->l2.l2m, 4, (void *)skb); } else { tmp___1 = IsDISC(datap); if (tmp___1 != 0) { c = unnum_error(st, skb, 0); if (c == 0) { ret = FsmEvent(& st->l2.l2m, 2, (void *)skb); } else { tmp___0 = IsDM(datap); if (tmp___0 != 0) { c = unnum_error(st, skb, 1); if (c == 0) { ret = FsmEvent(& st->l2.l2m, 3, (void *)skb); } else { tmp = IsFRMR(datap); if (tmp != 0) { c = FRMR_error(st, skb); if (c == 0) { ret = FsmEvent(& st->l2.l2m, 5, (void *)skb); } else { FsmEvent(& st->l2.l2m, 21, 76); consume_skb(skb); ret = 0; } } else { } } } else { } } } else { } } } else { } } } else { } } } else { } } } else { } } } else { } if (c != 0) { consume_skb(skb); FsmEvent(& st->l2.l2m, 21, (void *)((long )c)); ret = 0; } else { } if (ret != 0) { consume_skb(skb); } else { } goto ldv_41588; case 305: FsmEvent(& st->l2.l2m, 9, arg); goto ldv_41588; case 338: test_and_set_bit(11, (unsigned long volatile *)(& st->l2.flag)); goto ldv_41588; case 337: test_and_clear_bit(11, (unsigned long volatile *)(& st->l2.flag)); goto ldv_41588; case 257: ; case 258: test_and_set_bit(12, (unsigned long volatile *)(& st->l2.flag)); tmp___6 = test_and_clear_bit(13, (unsigned long volatile *)(& st->l2.flag)); if (tmp___6 != 0) { FsmEvent(& st->l2.l2m, 11, arg); } else { } goto ldv_41588; case 274: ; case 273: test_and_clear_bit(12, (unsigned long volatile *)(& st->l2.flag)); FsmEvent(& st->l2.l2m, 16, arg); goto ldv_41588; default: l2m_debug(& st->l2.l2m, (char *)"l2 unknown pr %04x", pr); goto ldv_41588; } ldv_41588: ; return; } } static void isdnl2_l3l2(struct PStack *st , int pr , void *arg ) { int tmp ; int tmp___0 ; int tmp___1 ; int tmp___2 ; int tmp___3 ; int tmp___4 ; int tmp___5 ; int tmp___6 ; { switch (pr) { case 544: tmp = FsmEvent(& st->l2.l2m, 8, arg); if (tmp != 0) { consume_skb((struct sk_buff *)arg); } else { } goto ldv_41603; case 560: tmp___0 = FsmEvent(& st->l2.l2m, 10, arg); if (tmp___0 != 0) { consume_skb((struct sk_buff *)arg); } else { } goto ldv_41603; case 512: tmp___5 = constant_test_bit(12U, (unsigned long const volatile *)(& st->l2.flag)); if (tmp___5 != 0) { tmp___3 = constant_test_bit(1U, (unsigned long const volatile *)(& st->l2.flag)); if (tmp___3 != 0) { FsmEvent(& st->l2.l2m, 11, arg); } else { tmp___4 = constant_test_bit(2U, (unsigned long const volatile *)(& st->l2.flag)); if (tmp___4 != 0) { FsmEvent(& st->l2.l2m, 11, arg); } else { tmp___1 = constant_test_bit(1U, (unsigned long const volatile *)(& st->l2.flag)); if (tmp___1 != 0) { test_and_set_bit(13, (unsigned long volatile *)(& st->l2.flag)); } else { tmp___2 = constant_test_bit(2U, (unsigned long const volatile *)(& st->l2.flag)); if (tmp___2 != 0) { test_and_set_bit(13, (unsigned long volatile *)(& st->l2.flag)); } else { } } (*(st->l2.l2l1))(st, 256, 0); } } } else { } goto ldv_41603; case 528: tmp___6 = constant_test_bit(0U, (unsigned long const volatile *)(& st->l2.flag)); if (tmp___6 != 0) { (*(st->l2.l2l1))(st, 272, 0); } else { } FsmEvent(& st->l2.l2m, 12, arg); goto ldv_41603; case 640: FsmEvent(& st->l2.l2m, 13, arg); goto ldv_41603; case 644: FsmEvent(& st->l2.l2m, 14, arg); goto ldv_41603; case 651: FsmEvent(& st->l2.l2m, 15, arg); goto ldv_41603; } ldv_41603: ; return; } } void releasestack_isdnl2(struct PStack *st ) { { FsmDelTimer(& st->l2.t200, 21); FsmDelTimer(& st->l2.t203, 16); skb_queue_purge(& st->l2.i_queue); skb_queue_purge(& st->l2.ui_queue); ReleaseWin(& st->l2); return; } } static void l2m_debug(struct FsmInst *fi , char *fmt , ...) { va_list args ; struct PStack *st ; { st = (struct PStack *)fi->userdata; __builtin_va_start((__va_list_tag *)(& args), fmt); VHiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)(& st->l2.debug_id), fmt, (__va_list_tag *)(& args)); __builtin_va_end((__va_list_tag *)(& args)); return; } } void setstack_isdnl2(struct PStack *st , char *debug_id ) { struct lock_class_key __key ; int tmp ; { spinlock_check(& st->l2.lock); __raw_spin_lock_init(& st->l2.lock.ldv_5961.rlock, "&(&st->l2.lock)->rlock", & __key); st->l1.l1l2 = & isdnl2_l1l2; st->l3.l3l2 = & isdnl2_l3l2; skb_queue_head_init(& st->l2.i_queue); skb_queue_head_init(& st->l2.ui_queue); InitWin(& st->l2); st->l2.debug = 0; st->l2.l2m.fsm = & l2fsm; tmp = constant_test_bit(0U, (unsigned long const volatile *)(& st->l2.flag)); if (tmp != 0) { st->l2.l2m.state = 3; } else { st->l2.l2m.state = 0; } st->l2.l2m.debug = 0; st->l2.l2m.userdata = (void *)st; st->l2.l2m.userint = 0; st->l2.l2m.printdebug = & l2m_debug; strcpy((char *)(& st->l2.debug_id), (char const *)debug_id); FsmInitTimer(& st->l2.l2m, & st->l2.t200); FsmInitTimer(& st->l2.l2m, & st->l2.t203); return; } } static void transl2_l3l2(struct PStack *st , int pr , void *arg ) { { switch (pr) { case 544: ; case 560: (*(st->l2.l2l1))(st, 288, arg); goto ldv_41631; case 512: (*(st->l2.l2l1))(st, 256, 0); goto ldv_41631; case 528: (*(st->l2.l2l1))(st, 272, 0); goto ldv_41631; } ldv_41631: ; return; } } void setstack_transl2(struct PStack *st ) { { st->l3.l3l2 = & transl2_l3l2; return; } } void releasestack_transl2(struct PStack *st ) { { return; } } int Isdnl2New(void) { int tmp ; { l2fsm.state_count = 8; l2fsm.event_count = 22; l2fsm.strEvent = (char **)(& strL2Event); l2fsm.strState = (char **)(& strL2State); tmp = FsmNew(& l2fsm, (struct FsmNode *)(& L2FnList), 88); return (tmp); } } void Isdnl2Free(void) { { FsmFree(& l2fsm); return; } } void ldv_mutex_lock_43(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_lock(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_44(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_lock(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_45(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } int ldv_mutex_trylock_46(struct mutex *ldv_func_arg1 ) { ldv_func_ret_type___2 ldv_func_res ; int tmp ; int tmp___0 ; { tmp = mutex_trylock(ldv_func_arg1); ldv_func_res = tmp; tmp___0 = ldv_mutex_trylock_mutex(ldv_func_arg1); return (tmp___0); return (ldv_func_res); } } void ldv_mutex_unlock_47(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_48(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_cred_guard_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_49(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_cred_guard_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } int ldv_mutex_trylock_60(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_58(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_61(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_63(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_57(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_59(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_62(struct mutex *ldv_func_arg1 ) ; extern void init_timer_key(struct timer_list * , unsigned int , char const * , struct lock_class_key * ) ; __inline static int timer_pending(struct timer_list const *timer ) { { return ((unsigned long )timer->entry.next != (unsigned long )((struct list_head */* const */)0)); } } extern void add_timer(struct timer_list * ) ; __inline static void skb_reserve(struct sk_buff *skb , int len ) { { skb->data = skb->data + (unsigned long )len; skb->tail = skb->tail + (sk_buff_data_t )len; return; } } void setstack_l3dc(struct PStack *st , struct Channel *chanp ) ; void setstack_l3bc(struct PStack *st , struct Channel *chanp ) ; void releasestack_isdnl3(struct PStack *st ) ; u_char *findie(u_char *p , int size , u_char ie , int wanted_set ) ; int getcallref(u_char *p ) ; int newcallref(void) ; void newl3state(struct l3_process *pc , int state ) ; void L3InitTimer(struct l3_process *pc , struct L3Timer *t ) ; void L3DelTimer(struct L3Timer *t ) ; int L3AddTimer(struct L3Timer *t , int millisec , int event ) ; void StopAllL3Timer(struct l3_process *pc ) ; struct sk_buff *l3_alloc_skb(int len ) ; struct l3_process *new_l3_process(struct PStack *st , int cr ) ; void release_l3_process(struct l3_process *p ) ; struct l3_process *getl3proc(struct PStack *st , int cr ) ; void l3_msg(struct PStack *st , int pr , void *arg ) ; void setstack_dss1(struct PStack *st ) ; void setstack_ni1(struct PStack *st ) ; void setstack_1tr6(struct PStack *st ) ; char const *l3_revision = "$Revision: 2.22.2.3 $"; static struct Fsm l3fsm ; static char *strL3State[5U] = { (char *)"ST_L3_LC_REL", (char *)"ST_L3_LC_ESTAB_WAIT", (char *)"ST_L3_LC_REL_DELAY", (char *)"ST_L3_LC_REL_WAIT", (char *)"ST_L3_LC_ESTAB"}; static char *strL3Event[7U] = { (char *)"EV_ESTABLISH_REQ", (char *)"EV_ESTABLISH_IND", (char *)"EV_ESTABLISH_CNF", (char *)"EV_RELEASE_REQ", (char *)"EV_RELEASE_CNF", (char *)"EV_RELEASE_IND", (char *)"EV_TIMEOUT"}; static void l3m_debug(struct FsmInst *fi , char *fmt , ...) { va_list args ; struct PStack *st ; { st = (struct PStack *)fi->userdata; __builtin_va_start((__va_list_tag *)(& args), fmt); VHiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)(& st->l3.debug_id), fmt, (__va_list_tag *)(& args)); __builtin_va_end((__va_list_tag *)(& args)); return; } } u_char *findie(u_char *p , int size , u_char ie , int wanted_set ) { int l ; int codeset ; int maincodeset ; u_char *pend ; u_char *tmp ; u_char *tmp___0 ; { pend = p + (unsigned long )size; p = p + 1; tmp = p; p = p + 1; l = (int )*tmp & 15; p = p + (unsigned long )l; p = p + 1; codeset = 0; maincodeset = 0; goto ldv_41016; ldv_41015: ; if (((int )*p & 240) == 144) { codeset = (int )*p & 7; if (((int )*p & 8) == 0) { maincodeset = codeset; } else { } } else { } if ((int )((signed char )*p) < 0) { p = p + 1; } else { if (codeset == wanted_set) { if ((int )*p == (int )ie) { if ((long )pend - (long )p <= 1L) { return (0); } else { } if ((long )*(p + 1UL) > (long )pend - (long )(p + 2UL)) { return (0); } else { } return (p); } else { } if ((int )*p > (int )ie) { return (0); } else { } } else { } p = p + 1; tmp___0 = p; p = p + 1; l = (int )*tmp___0; p = p + (unsigned long )l; codeset = maincodeset; } ldv_41016: ; if ((unsigned long )p < (unsigned long )pend) { goto ldv_41015; } else { } return (0); } } int getcallref(u_char *p ) { int l ; int cr ; u_char *tmp ; u_char *tmp___0 ; { cr = 0; p = p + 1; if (((int )*p & 254) != 0) { return (-2); } else { } tmp = p; p = p + 1; l = (int )*tmp & 15; if (l == 0) { return (-1); } else { } tmp___0 = p; p = p + 1; cr = (int )*tmp___0; return (cr); } } static int OrigCallRef = 0; int newcallref(void) { { if (OrigCallRef == 127) { OrigCallRef = 1; } else { OrigCallRef = OrigCallRef + 1; } return (OrigCallRef); } } void newl3state(struct l3_process *pc , int state ) { { if ((pc->debug & 4) != 0) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"newstate cr %d %d --> %d", pc->callref & 127, pc->state, state); } else { } pc->state = state; return; } } static void L3ExpireTimer(struct L3Timer *t ) { { (*(((t->pc)->st)->lli.l4l3))((t->pc)->st, t->event, (void *)t->pc); return; } } void L3InitTimer(struct l3_process *pc , struct L3Timer *t ) { struct lock_class_key __key ; { t->pc = pc; t->tl.function = (void (*)(unsigned long ))(& L3ExpireTimer); t->tl.data = (unsigned long )t; init_timer_key(& t->tl, 0U, "(&t->tl)", & __key); return; } } void L3DelTimer(struct L3Timer *t ) { { del_timer(& t->tl); return; } } int L3AddTimer(struct L3Timer *t , int millisec , int event ) { int tmp ; struct lock_class_key __key ; { tmp = timer_pending((struct timer_list const *)(& t->tl)); if (tmp != 0) { printk("\fL3AddTimer: timer already active!\n"); return (-1); } else { } init_timer_key(& t->tl, 0U, "(&t->tl)", & __key); t->event = event; t->tl.expires = (unsigned long )((millisec * 250) / 1000) + (unsigned long )jiffies; add_timer(& t->tl); return (0); } } void StopAllL3Timer(struct l3_process *pc ) { { L3DelTimer(& pc->timer); return; } } struct sk_buff *l3_alloc_skb(int len ) { struct sk_buff *skb ; { skb = alloc_skb((unsigned int )(len + 4), 32U); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { printk("\fHiSax: No skb for D-channel\n"); return (0); } else { } skb_reserve(skb, 4); return (skb); } } static void no_l3_proto(struct PStack *st , int pr , void *arg ) { struct sk_buff *skb ; { skb = (struct sk_buff *)arg; HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"L3", (char *)"no D protocol"); if ((unsigned long )skb != (unsigned long )((struct sk_buff *)0)) { consume_skb(skb); } else { } return; } } static int no_l3_proto_spec(struct PStack *st , isdn_ctrl *ic ) { { printk("\fHiSax: no specific protocol handler for proto %lu\n", ic->arg & 255UL); return (-1); } } struct l3_process *getl3proc(struct PStack *st , int cr ) { struct l3_process *p ; { p = st->l3.proc; goto ldv_41071; ldv_41070: ; if (p->callref == cr) { return (p); } else { p = p->next; } ldv_41071: ; if ((unsigned long )p != (unsigned long )((struct l3_process *)0)) { goto ldv_41070; } else { } return (0); } } struct l3_process *new_l3_process(struct PStack *st , int cr ) { struct l3_process *p ; struct l3_process *np ; void *tmp ; { tmp = kmalloc(360UL, 32U); p = (struct l3_process *)tmp; if ((unsigned long )p == (unsigned long )((struct l3_process *)0)) { printk("\vHiSax can\'t get memory for cr %d\n", cr); return (0); } else { } if ((unsigned long )st->l3.proc == (unsigned long )((struct l3_process *)0)) { st->l3.proc = p; } else { np = st->l3.proc; goto ldv_41080; ldv_41079: np = np->next; ldv_41080: ; if ((unsigned long )np->next != (unsigned long )((struct l3_process *)0)) { goto ldv_41079; } else { } np->next = p; } p->next = 0; p->debug = st->l3.debug; p->callref = cr; p->state = 0; p->chan = 0; p->st = st; p->N303 = st->l3.N303; L3InitTimer(p, & p->timer); return (p); } } void release_l3_process(struct l3_process *p ) { struct l3_process *np ; struct l3_process *pp ; int tmp ; struct l3_process *tmp___0 ; int tmp___1 ; { pp = 0; if ((unsigned long )p == (unsigned long )((struct l3_process *)0)) { return; } else { } np = (p->st)->l3.proc; goto ldv_41088; ldv_41087: ; if ((unsigned long )np == (unsigned long )p) { StopAllL3Timer(p); if ((unsigned long )pp != (unsigned long )((struct l3_process *)0)) { pp->next = np->next; } else { tmp___0 = np->next; (p->st)->l3.proc = tmp___0; if ((unsigned long )tmp___0 == (unsigned long )((struct l3_process *)0)) { tmp___1 = constant_test_bit(14U, (unsigned long const volatile *)(& (p->st)->l2.flag)); if (tmp___1 == 0) { if (p->debug != 0) { HiSax_putstatus((struct IsdnCardState *)(p->st)->l1.hardware, (char *)"l3 ", (char *)"release_l3_process: last process"); } else { } tmp = skb_queue_empty((struct sk_buff_head const *)(& (p->st)->l3.squeue)); if (tmp != 0) { if (p->debug != 0) { HiSax_putstatus((struct IsdnCardState *)(p->st)->l1.hardware, (char *)"l3 ", (char *)"release_l3_process: release link"); } else { } if ((p->st)->protocol != 4) { FsmEvent(& (p->st)->l3.l3m, 3, 0); } else { FsmEvent(& (p->st)->l3.l3m, 5, 0); } } else if (p->debug != 0) { HiSax_putstatus((struct IsdnCardState *)(p->st)->l1.hardware, (char *)"l3 ", (char *)"release_l3_process: not release link"); } else { } } else { } } else { } } kfree((void const *)p); return; } else { } pp = np; np = np->next; ldv_41088: ; if ((unsigned long )np != (unsigned long )((struct l3_process *)0)) { goto ldv_41087; } else { } printk("\vHiSax internal L3 error CR(%d) not in list\n", p->callref); HiSax_putstatus((struct IsdnCardState *)(p->st)->l1.hardware, (char *)"l3 ", (char *)"HiSax internal L3 error CR(%d) not in list", p->callref); return; } } static void l3ml3p(struct PStack *st , int pr ) { struct l3_process *p ; struct l3_process *np ; { p = st->l3.proc; goto ldv_41097; ldv_41096: np = p->next; (*(st->l3.l3ml3))(st, pr, (void *)p); p = np; ldv_41097: ; if ((unsigned long )p != (unsigned long )((struct l3_process *)0)) { goto ldv_41096; } else { } return; } } void setstack_l3dc(struct PStack *st , struct Channel *chanp ) { char tmp[64U] ; { st->l3.proc = 0; st->l3.global = 0; skb_queue_head_init(& st->l3.squeue); st->l3.l3m.fsm = & l3fsm; st->l3.l3m.state = 0; st->l3.l3m.debug = 1; st->l3.l3m.userdata = (void *)st; st->l3.l3m.userint = 0; st->l3.l3m.printdebug = & l3m_debug; FsmInitTimer(& st->l3.l3m, & st->l3.l3m_timer); strcpy((char *)(& st->l3.debug_id), "L3DC "); st->lli.l4l3_proto = & no_l3_proto_spec; if (st->protocol == 2) { setstack_dss1(st); } else if (st->protocol == 4) { setstack_ni1(st); } else if (st->protocol == 1) { setstack_1tr6(st); } else if (st->protocol == 3) { st->lli.l4l3 = & no_l3_proto; st->l2.l2l3 = & no_l3_proto; st->l3.l3ml3 = & no_l3_proto; printk("\016HiSax: Leased line mode\n"); } else { st->lli.l4l3 = & no_l3_proto; st->l2.l2l3 = & no_l3_proto; st->l3.l3ml3 = & no_l3_proto; sprintf((char *)(& tmp), "protocol %s not supported", st->protocol != 1 ? (st->protocol != 2 ? (st->protocol == 4 ? (char *)"ni1" : (char *)"unknown") : (char *)"euro") : (char *)"1tr6"); printk("\fHiSax: %s\n", (char *)(& tmp)); st->protocol = -1; } return; } } static void isdnl3_trans(struct PStack *st , int pr , void *arg ) { { (*(st->l3.l3l2))(st, pr, arg); return; } } void releasestack_isdnl3(struct PStack *st ) { { goto ldv_41113; ldv_41112: release_l3_process(st->l3.proc); ldv_41113: ; if ((unsigned long )st->l3.proc != (unsigned long )((struct l3_process *)0)) { goto ldv_41112; } else { } if ((unsigned long )st->l3.global != (unsigned long )((struct l3_process *)0)) { StopAllL3Timer(st->l3.global); kfree((void const *)st->l3.global); st->l3.global = 0; } else { } FsmDelTimer(& st->l3.l3m_timer, 54); skb_queue_purge(& st->l3.squeue); return; } } void setstack_l3bc(struct PStack *st , struct Channel *chanp ) { { st->l3.proc = 0; st->l3.global = 0; skb_queue_head_init(& st->l3.squeue); st->l3.l3m.fsm = & l3fsm; st->l3.l3m.state = 0; st->l3.l3m.debug = 1; st->l3.l3m.userdata = (void *)st; st->l3.l3m.userint = 0; st->l3.l3m.printdebug = & l3m_debug; strcpy((char *)(& st->l3.debug_id), "L3BC "); st->lli.l4l3 = & isdnl3_trans; return; } } static void lc_activate(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; { st = (struct PStack *)fi->userdata; FsmChangeState(fi, 1); (*(st->l3.l3l2))(st, 512, 0); return; } } static void lc_connect(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; struct sk_buff *skb ; int dequeued ; { st = (struct PStack *)fi->userdata; skb = (struct sk_buff *)arg; dequeued = 0; FsmChangeState(fi, 4); goto ldv_41134; ldv_41133: (*(st->l3.l3l2))(st, 544, (void *)skb); dequeued = dequeued + 1; ldv_41134: skb = skb_dequeue(& st->l3.squeue); if ((unsigned long )skb != (unsigned long )((struct sk_buff *)0)) { goto ldv_41133; } else { } if ((unsigned long )st->l3.proc == (unsigned long )((struct l3_process *)0) && dequeued != 0) { if (st->l3.debug != 0) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"lc_connect: release link"); } else { } FsmEvent(& st->l3.l3m, 3, 0); } else { l3ml3p(st, 514); } return; } } static void lc_connected(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; struct sk_buff *skb ; int dequeued ; { st = (struct PStack *)fi->userdata; skb = (struct sk_buff *)arg; dequeued = 0; FsmDelTimer(& st->l3.l3m_timer, 51); FsmChangeState(fi, 4); goto ldv_41145; ldv_41144: (*(st->l3.l3l2))(st, 544, (void *)skb); dequeued = dequeued + 1; ldv_41145: skb = skb_dequeue(& st->l3.squeue); if ((unsigned long )skb != (unsigned long )((struct sk_buff *)0)) { goto ldv_41144; } else { } if ((unsigned long )st->l3.proc == (unsigned long )((struct l3_process *)0) && dequeued != 0) { if (st->l3.debug != 0) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"lc_connected: release link"); } else { } FsmEvent(& st->l3.l3m, 3, 0); } else { l3ml3p(st, 513); } return; } } static void lc_start_delay(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; { st = (struct PStack *)fi->userdata; FsmChangeState(fi, 2); FsmAddTimer(& st->l3.l3m_timer, 40000, 6, 0, 50); return; } } static void lc_start_delay_check(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; { st = (struct PStack *)fi->userdata; FsmChangeState(fi, 2); if (st->protocol != 4) { FsmAddTimer(& st->l3.l3m_timer, 40000, 6, 0, 50); } else { } return; } } static void lc_release_req(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; int tmp ; { st = (struct PStack *)fi->userdata; tmp = constant_test_bit(16U, (unsigned long const volatile *)(& st->l2.flag)); if (tmp != 0) { if (st->l3.debug != 0) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"lc_release_req: l2 blocked"); } else { } FsmAddTimer(& st->l3.l3m_timer, 40000, 6, 0, 51); } else { FsmChangeState(fi, 3); (*(st->l3.l3l2))(st, 528, 0); } return; } } static void lc_release_ind(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; { st = (struct PStack *)fi->userdata; FsmDelTimer(& st->l3.l3m_timer, 52); FsmChangeState(fi, 0); skb_queue_purge(& st->l3.squeue); l3ml3p(st, 530); return; } } static void lc_release_cnf(struct FsmInst *fi , int event , void *arg ) { struct PStack *st ; { st = (struct PStack *)fi->userdata; FsmChangeState(fi, 0); skb_queue_purge(& st->l3.squeue); l3ml3p(st, 529); return; } } static struct FsmNode L3FnList[13U] = { {0, 0, & lc_activate}, {0, 1, & lc_connect}, {0, 2, & lc_connect}, {1, 2, & lc_connected}, {1, 3, & lc_start_delay}, {1, 5, & lc_release_ind}, {4, 5, & lc_release_ind}, {4, 3, & lc_start_delay_check}, {2, 5, & lc_release_ind}, {2, 0, & lc_connected}, {2, 6, & lc_release_req}, {3, 4, & lc_release_cnf}, {3, 0, & lc_activate}}; void l3_msg(struct PStack *st , int pr , void *arg ) { struct sk_buff *skb ; { switch (pr) { case 544: ; if (st->l3.l3m.state == 4) { (*(st->l3.l3l2))(st, pr, arg); } else { skb = (struct sk_buff *)arg; skb_queue_tail(& st->l3.squeue, skb); FsmEvent(& st->l3.l3m, 0, 0); } goto ldv_41185; case 512: FsmEvent(& st->l3.l3m, 0, 0); goto ldv_41185; case 513: FsmEvent(& st->l3.l3m, 2, 0); goto ldv_41185; case 514: FsmEvent(& st->l3.l3m, 1, 0); goto ldv_41185; case 530: FsmEvent(& st->l3.l3m, 5, 0); goto ldv_41185; case 529: FsmEvent(& st->l3.l3m, 4, 0); goto ldv_41185; case 528: FsmEvent(& st->l3.l3m, 3, 0); goto ldv_41185; } ldv_41185: ; return; } } int Isdnl3New(void) { int tmp ; { l3fsm.state_count = 5; l3fsm.event_count = 7; l3fsm.strEvent = (char **)(& strL3Event); l3fsm.strState = (char **)(& strL3State); tmp = FsmNew(& l3fsm, (struct FsmNode *)(& L3FnList), 13); return (tmp); } } void Isdnl3Free(void) { { FsmFree(& l3fsm); return; } } void ldv_mutex_lock_57(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_lock(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_58(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_lock(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_59(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } int ldv_mutex_trylock_60(struct mutex *ldv_func_arg1 ) { ldv_func_ret_type___2 ldv_func_res ; int tmp ; int tmp___0 ; { tmp = mutex_trylock(ldv_func_arg1); ldv_func_res = tmp; tmp___0 = ldv_mutex_trylock_mutex(ldv_func_arg1); return (tmp___0); return (ldv_func_res); } } void ldv_mutex_unlock_61(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_62(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_cred_guard_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_63(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_cred_guard_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } int ldv_mutex_trylock_74(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_72(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_75(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_77(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_71(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_73(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_76(struct mutex *ldv_func_arg1 ) ; static void error_handling_dchan(struct PStack *st , int Error ) { { switch (Error) { case 67: ; case 68: ; case 71: ; case 72: (*(st->l2.l2tei))(st, 648, 0); goto ldv_40948; } ldv_40948: ; return; } } static void hisax_manager(struct PStack *st , int pr , void *arg ) { long Code ; int tmp ; int tmp___0 ; { switch (pr) { case 650: Code = (long )arg; tmp = constant_test_bit(1U, (unsigned long const volatile *)(& st->l2.flag)); HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"manager: MDL_ERROR", (char *)" %c %s", (int )((char )Code), tmp != 0 ? (char *)"D-channel" : (char *)"B-channel"); tmp___0 = constant_test_bit(1U, (unsigned long const volatile *)(& st->l2.flag)); if (tmp___0 != 0) { error_handling_dchan(st, (int )Code); } else { } goto ldv_40956; } ldv_40956: ; return; } } void setstack_manager(struct PStack *st ) { { st->ma.layer = & hisax_manager; return; } } void ldv_mutex_lock_71(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_lock(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_72(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_lock(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_73(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } int ldv_mutex_trylock_74(struct mutex *ldv_func_arg1 ) { ldv_func_ret_type___2 ldv_func_res ; int tmp ; int tmp___0 ; { tmp = mutex_trylock(ldv_func_arg1); ldv_func_res = tmp; tmp___0 = ldv_mutex_trylock_mutex(ldv_func_arg1); return (tmp___0); return (ldv_func_res); } } void ldv_mutex_unlock_75(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_76(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_cred_guard_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_77(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_cred_guard_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } extern char const hex_asc[] ; int ldv_mutex_trylock_88(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_86(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_89(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_91(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_85(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_87(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_90(struct mutex *ldv_func_arg1 ) ; void iecpy(u_char *dest , u_char *iestart , int ieoffset ) ; void iecpy(u_char *dest , u_char *iestart , int ieoffset ) { u_char *p ; int l ; u_char *tmp ; u_char *tmp___0 ; int tmp___1 ; u_char *tmp___2 ; { p = iestart + ((unsigned long )ieoffset + 2UL); l = (int )*(iestart + 1UL) - ieoffset; goto ldv_40948; ldv_40947: tmp = dest; dest = dest + 1; tmp___0 = p; p = p + 1; *tmp = *tmp___0; ldv_40948: tmp___1 = l; l = l - 1; if (tmp___1 != 0) { goto ldv_40947; } else { } tmp___2 = dest; dest = dest + 1; *tmp___2 = 0U; return; } } static struct MessageType mtlist[32U] = { {1U, (char *)"ALERTING"}, {2U, (char *)"CALL PROCEEDING"}, {7U, (char *)"CONNECT"}, {15U, (char *)"CONNECT ACKNOWLEDGE"}, {3U, (char *)"PROGRESS"}, {5U, (char *)"SETUP"}, {13U, (char *)"SETUP ACKNOWLEDGE"}, {36U, (char *)"HOLD"}, {40U, (char *)"HOLD ACKNOWLEDGE"}, {48U, (char *)"HOLD REJECT"}, {49U, (char *)"RETRIEVE"}, {51U, (char *)"RETRIEVE ACKNOWLEDGE"}, {55U, (char *)"RETRIEVE REJECT"}, {38U, (char *)"RESUME"}, {46U, (char *)"RESUME ACKNOWLEDGE"}, {34U, (char *)"RESUME REJECT"}, {37U, (char *)"SUSPEND"}, {45U, (char *)"SUSPEND ACKNOWLEDGE"}, {33U, (char *)"SUSPEND REJECT"}, {32U, (char *)"USER INFORMATION"}, {69U, (char *)"DISCONNECT"}, {77U, (char *)"RELEASE"}, {90U, (char *)"RELEASE COMPLETE"}, {70U, (char *)"RESTART"}, {78U, (char *)"RESTART ACKNOWLEDGE"}, {96U, (char *)"SEGMENT"}, {121U, (char *)"CONGESTION CONTROL"}, {123U, (char *)"INFORMATION"}, {98U, (char *)"FACILITY"}, {110U, (char *)"NOTIFY"}, {125U, (char *)"STATUS"}, {117U, (char *)"STATUS ENQUIRY"}}; static struct MessageType mt_n0[10U] = { {97U, (char *)"REGister INDication"}, {98U, (char *)"CANCel INDication"}, {99U, (char *)"FACility STAtus"}, {100U, (char *)"STAtus ACKnowledge"}, {101U, (char *)"STAtus REJect"}, {102U, (char *)"FACility INFormation"}, {103U, (char *)"INFormation ACKnowledge"}, {104U, (char *)"INFormation REJect"}, {117U, (char *)"CLOSE"}, {119U, (char *)"CLOse ACKnowledge"}}; static struct MessageType mt_n1[30U] = { {0U, (char *)"ESCape"}, {1U, (char *)"ALERT"}, {2U, (char *)"CALL SENT"}, {7U, (char *)"CONNect"}, {15U, (char *)"CONNect ACKnowledge"}, {5U, (char *)"SETUP"}, {13U, (char *)"SETUP ACKnowledge"}, {38U, (char *)"RESume"}, {46U, (char *)"RESume ACKnowledge"}, {34U, (char *)"RESume REJect"}, {37U, (char *)"SUSPend"}, {45U, (char *)"SUSPend ACKnowledge"}, {33U, (char *)"SUSPend REJect"}, {32U, (char *)"USER INFO"}, {64U, (char *)"DETach"}, {69U, (char *)"DISConnect"}, {77U, (char *)"RELease"}, {90U, (char *)"RELease ACKnowledge"}, {110U, (char *)"CANCel ACKnowledge"}, {103U, (char *)"CANCel REJect"}, {105U, (char *)"CONgestion CONtrol"}, {96U, (char *)"FACility"}, {104U, (char *)"FACility ACKnowledge"}, {102U, (char *)"FACility CANcel"}, {100U, (char *)"FACility REGister"}, {101U, (char *)"FACility REJect"}, {109U, (char *)"INFOrmation"}, {108U, (char *)"REGister ACKnowledge"}, {111U, (char *)"REGister REJect"}, {99U, (char *)"STATus"}}; static int prbits(char *dest , u_char b , int start , int len ) { char *dp ; char *tmp ; char *tmp___0 ; int tmp___1 ; { dp = dest; b = (u_char )((int )b << (8 - start)); goto ldv_40964; ldv_40963: ; if ((int )((signed char )b) < 0) { tmp = dp; dp = dp + 1; *tmp = 49; } else { tmp___0 = dp; dp = dp + 1; *tmp___0 = 48; } b = (int )b << 1U; ldv_40964: tmp___1 = len; len = len - 1; if (tmp___1 != 0) { goto ldv_40963; } else { } return ((int )((unsigned int )((long )dp) - (unsigned int )((long )dest))); } } static u_char *skipext(u_char *p ) { u_char *tmp ; { goto ldv_40970; ldv_40969: ; ldv_40970: tmp = p; p = p + 1; if ((int )((signed char )*tmp) >= 0) { goto ldv_40969; } else { } return (p); } } static struct CauseValue cvlist[67U] = { {1U, (char *)"Unallocated (unassigned) number", (char *)"Nummer nicht zugeteilt"}, {2U, (char *)"No route to specified transit network", (char *)""}, {3U, (char *)"No route to destination", (char *)""}, {4U, (char *)"Send special information tone", (char *)""}, {5U, (char *)"Misdialled trunk prefix", (char *)""}, {6U, (char *)"Channel unacceptable", (char *)"Kanal nicht akzeptierbar"}, {7U, (char *)"Channel awarded and being delivered in an established channel", (char *)""}, {8U, (char *)"Preemption", (char *)""}, {9U, (char *)"Preemption - circuit reserved for reuse", (char *)""}, {16U, (char *)"Normal call clearing", (char *)"Normale Ausloesung"}, {17U, (char *)"User busy", (char *)"TNB besetzt"}, {18U, (char *)"No user responding", (char *)""}, {19U, (char *)"No answer from user (user alerted)", (char *)""}, {20U, (char *)"Subscriber absent", (char *)""}, {21U, (char *)"Call rejected", (char *)""}, {22U, (char *)"Number changed", (char *)""}, {26U, (char *)"non-selected user clearing", (char *)""}, {27U, (char *)"Destination out of order", (char *)""}, {28U, (char *)"Invalid number format (address incomplete)", (char *)""}, {29U, (char *)"Facility rejected", (char *)""}, {30U, (char *)"Response to Status enquiry", (char *)""}, {31U, (char *)"Normal, unspecified", (char *)""}, {34U, (char *)"No circuit/channel available", (char *)""}, {38U, (char *)"Network out of order", (char *)""}, {39U, (char *)"Permanent frame mode connection out-of-service", (char *)""}, {40U, (char *)"Permanent frame mode connection operational", (char *)""}, {41U, (char *)"Temporary failure", (char *)""}, {42U, (char *)"Switching equipment congestion", (char *)""}, {43U, (char *)"Access information discarded", (char *)""}, {44U, (char *)"Requested circuit/channel not available", (char *)""}, {46U, (char *)"Precedence call blocked", (char *)""}, {47U, (char *)"Resource unavailable, unspecified", (char *)""}, {49U, (char *)"Quality of service unavailable", (char *)""}, {50U, (char *)"Requested facility not subscribed", (char *)""}, {53U, (char *)"Outgoing calls barred within CUG", (char *)""}, {55U, (char *)"Incoming calls barred within CUG", (char *)""}, {57U, (char *)"Bearer capability not authorized", (char *)""}, {58U, (char *)"Bearer capability not presently available", (char *)""}, {62U, (char *)"Inconsistency in designated outgoing access information and subscriber class ", (char *)" "}, {63U, (char *)"Service or option not available, unspecified", (char *)""}, {65U, (char *)"Bearer capability not implemented", (char *)""}, {66U, (char *)"Channel type not implemented", (char *)""}, {67U, (char *)"Requested facility not implemented", (char *)""}, {68U, (char *)"Only restricted digital information bearer capability is available", (char *)""}, {79U, (char *)"Service or option not implemented", (char *)""}, {81U, (char *)"Invalid call reference value", (char *)""}, {82U, (char *)"Identified channel does not exist", (char *)""}, {83U, (char *)"A suspended call exists, but this call identity does not", (char *)""}, {84U, (char *)"Call identity in use", (char *)""}, {85U, (char *)"No call suspended", (char *)""}, {86U, (char *)"Call having the requested call identity has been cleared", (char *)""}, {87U, (char *)"User not member of CUG", (char *)""}, {88U, (char *)"Incompatible destination", (char *)""}, {90U, (char *)"Non-existent CUG", (char *)""}, {91U, (char *)"Invalid transit network selection", (char *)""}, {95U, (char *)"Invalid message, unspecified", (char *)""}, {96U, (char *)"Mandatory information element is missing", (char *)""}, {97U, (char *)"Message type non-existent or not implemented", (char *)""}, {98U, (char *)"Message not compatible with call state or message type non-existent or not implemented ", (char *)" "}, {99U, (char *)"Information element/parameter non-existent or not implemented", (char *)""}, {100U, (char *)"Invalid information element contents", (char *)""}, {101U, (char *)"Message not compatible with call state", (char *)""}, {102U, (char *)"Recovery on timer expiry", (char *)""}, {103U, (char *)"Parameter non-existent or not implemented - passed on", (char *)""}, {110U, (char *)"Message with unrecognized parameter discarded", (char *)""}, {111U, (char *)"Protocol error, unspecified", (char *)""}, {127U, (char *)"Interworking, unspecified", (char *)""}}; static int prcause(char *dest , u_char *p ) { u_char *end ; char *dp ; int i ; int cause ; int tmp ; int tmp___0 ; int tmp___1 ; int tmp___2 ; char *tmp___3 ; u_char *tmp___4 ; int tmp___5 ; int tmp___6 ; u_char *tmp___7 ; int tmp___8 ; int tmp___9 ; char *tmp___10 ; int tmp___11 ; { dp = dest; end = p + ((unsigned long )*(p + 1UL) + 1UL); p = p + 2UL; tmp = sprintf(dp, " coding "); dp = dp + (unsigned long )tmp; tmp___0 = prbits(dp, (int )*p, 7, 2); dp = dp + (unsigned long )tmp___0; tmp___1 = sprintf(dp, " location "); dp = dp + (unsigned long )tmp___1; tmp___2 = prbits(dp, (int )*p, 4, 4); dp = dp + (unsigned long )tmp___2; tmp___3 = dp; dp = dp + 1; *tmp___3 = 10; p = skipext(p); tmp___4 = p; p = p + 1; cause = (int )*tmp___4 & 127; i = 0; goto ldv_40989; ldv_40988: ; if ((int )cvlist[i].nr == cause) { goto ldv_40987; } else { } i = i + 1; ldv_40989: ; if ((unsigned int )i <= 66U) { goto ldv_40988; } else { } ldv_40987: ; if (i == 67) { tmp___5 = sprintf(dp, "Unknown cause type %x!\n", cause); dp = dp + (unsigned long )tmp___5; } else { tmp___6 = sprintf(dp, " cause value %x : %s \n", cause, cvlist[i].edescr); dp = dp + (unsigned long )tmp___6; } ldv_40993: ; if ((unsigned long )p > (unsigned long )end) { goto ldv_40992; } else { } tmp___7 = p; p = p + 1; tmp___8 = sprintf(dp, " diag attribute %d ", (int )*tmp___7 & 127); dp = dp + (unsigned long )tmp___8; tmp___9 = sprintf(dp, " rej %d ", (int )*p & 127); dp = dp + (unsigned long )tmp___9; if ((int )((signed char )*p) < 0) { tmp___10 = dp; dp = dp + 1; *tmp___10 = 10; goto ldv_40992; } else { p = p + 1; tmp___11 = sprintf(dp, " av %d\n", (int )*p & 127); dp = dp + (unsigned long )tmp___11; } goto ldv_40993; ldv_40992: ; return ((int )((unsigned int )((long )dp) - (unsigned int )((long )dest))); } } static struct MessageType cause_1tr6[26U] = { {1U, (char *)"Invalid Call Reference"}, {3U, (char *)"Bearer Service Not Implemented"}, {7U, (char *)"Caller Identity unknown"}, {8U, (char *)"Caller Identity in Use"}, {10U, (char *)"No Channels available"}, {16U, (char *)"Facility Not Implemented"}, {17U, (char *)"Facility Not Subscribed"}, {32U, (char *)"Outgoing calls barred"}, {33U, (char *)"User Access Busy"}, {34U, (char *)"Negative GBG"}, {35U, (char *)"Unknown GBG"}, {37U, (char *)"No SPV known"}, {53U, (char *)"Destination not obtainable"}, {56U, (char *)"Number changed"}, {57U, (char *)"Out Of Order"}, {58U, (char *)"No User Response"}, {59U, (char *)"User Busy"}, {61U, (char *)"Incoming Barred"}, {62U, (char *)"Call Rejected"}, {89U, (char *)"Network Congestion"}, {90U, (char *)"Remote User initiated"}, {112U, (char *)"Local Procedure Error"}, {113U, (char *)"Remote Procedure Error"}, {114U, (char *)"Remote User Suspend"}, {115U, (char *)"Remote User Resumed"}, {127U, (char *)"User Info Discarded"}}; static int cause_1tr6_len = 26; static int prcause_1tr6(char *dest , u_char *p ) { char *dp ; int i ; int cause ; int tmp ; int tmp___0 ; int tmp___1 ; int tmp___2 ; int tmp___3 ; char *tmp___4 ; int tmp___5 ; int tmp___6 ; { dp = dest; p = p + 1; if ((unsigned int )*p == 0U) { tmp = sprintf(dp, " OK (cause length=0)\n"); dp = dp + (unsigned long )tmp; return ((int )((unsigned int )((long )dp) - (unsigned int )((long )dest))); } else if ((unsigned int )*p > 1U) { tmp___0 = sprintf(dp, " coding "); dp = dp + (unsigned long )tmp___0; tmp___1 = prbits(dp, (int )*(p + 2UL), 7, 2); dp = dp + (unsigned long )tmp___1; tmp___2 = sprintf(dp, " location "); dp = dp + (unsigned long )tmp___2; tmp___3 = prbits(dp, (int )*(p + 2UL), 4, 4); dp = dp + (unsigned long )tmp___3; tmp___4 = dp; dp = dp + 1; *tmp___4 = 10; } else { } p = p + 1; cause = (int )*p & 127; i = 0; goto ldv_41007; ldv_41006: ; if ((int )cause_1tr6[i].nr == cause) { goto ldv_41005; } else { } i = i + 1; ldv_41007: ; if (i < cause_1tr6_len) { goto ldv_41006; } else { } ldv_41005: ; if (i == cause_1tr6_len) { tmp___5 = sprintf(dp, "Unknown cause type %x!\n", cause); dp = dp + (unsigned long )tmp___5; } else { tmp___6 = sprintf(dp, " cause value %x : %s \n", cause, cause_1tr6[i].descr); dp = dp + (unsigned long )tmp___6; } return ((int )((unsigned int )((long )dp) - (unsigned int )((long )dest))); } } static int prchident(char *dest , u_char *p ) { char *dp ; int tmp ; int tmp___0 ; char *tmp___1 ; { dp = dest; p = p + 2UL; tmp = sprintf(dp, " octet 3 "); dp = dp + (unsigned long )tmp; tmp___0 = prbits(dp, (int )*p, 8, 8); dp = dp + (unsigned long )tmp___0; tmp___1 = dp; dp = dp + 1; *tmp___1 = 10; return ((int )((unsigned int )((long )dp) - (unsigned int )((long )dest))); } } static int prcalled(char *dest , u_char *p ) { int l ; char *dp ; u_char *tmp ; int tmp___0 ; u_char *tmp___1 ; int tmp___2 ; char *tmp___3 ; int tmp___4 ; char *tmp___5 ; u_char *tmp___6 ; int tmp___7 ; char *tmp___8 ; { dp = dest; p = p + 1; tmp = p; p = p + 1; l = (int )*tmp + -1; tmp___0 = sprintf(dp, " octet 3 "); dp = dp + (unsigned long )tmp___0; tmp___1 = p; p = p + 1; tmp___2 = prbits(dp, (int )*tmp___1, 8, 8); dp = dp + (unsigned long )tmp___2; tmp___3 = dp; dp = dp + 1; *tmp___3 = 10; tmp___4 = sprintf(dp, " number digits "); dp = dp + (unsigned long )tmp___4; goto ldv_41020; ldv_41019: tmp___5 = dp; dp = dp + 1; tmp___6 = p; p = p + 1; *tmp___5 = (char )*tmp___6; ldv_41020: tmp___7 = l; l = l - 1; if (tmp___7 != 0) { goto ldv_41019; } else { } tmp___8 = dp; dp = dp + 1; *tmp___8 = 10; return ((int )((unsigned int )((long )dp) - (unsigned int )((long )dest))); } } static int prcalling(char *dest , u_char *p ) { int l ; char *dp ; u_char *tmp ; int tmp___0 ; int tmp___1 ; char *tmp___2 ; int tmp___3 ; int tmp___4 ; char *tmp___5 ; int tmp___6 ; char *tmp___7 ; u_char *tmp___8 ; int tmp___9 ; char *tmp___10 ; { dp = dest; p = p + 1; tmp = p; p = p + 1; l = (int )*tmp + -1; tmp___0 = sprintf(dp, " octet 3 "); dp = dp + (unsigned long )tmp___0; tmp___1 = prbits(dp, (int )*p, 8, 8); dp = dp + (unsigned long )tmp___1; tmp___2 = dp; dp = dp + 1; *tmp___2 = 10; if ((int )((signed char )*p) >= 0) { tmp___3 = sprintf(dp, " octet 3a "); dp = dp + (unsigned long )tmp___3; p = p + 1; tmp___4 = prbits(dp, (int )*p, 8, 8); dp = dp + (unsigned long )tmp___4; tmp___5 = dp; dp = dp + 1; *tmp___5 = 10; l = l - 1; } else { } p = p + 1; tmp___6 = sprintf(dp, " number digits "); dp = dp + (unsigned long )tmp___6; goto ldv_41029; ldv_41028: tmp___7 = dp; dp = dp + 1; tmp___8 = p; p = p + 1; *tmp___7 = (char )*tmp___8; ldv_41029: tmp___9 = l; l = l - 1; if (tmp___9 != 0) { goto ldv_41028; } else { } tmp___10 = dp; dp = dp + 1; *tmp___10 = 10; return ((int )((unsigned int )((long )dp) - (unsigned int )((long )dest))); } } static int prbearer(char *dest , u_char *p ) { char *dp ; char ch ; int tmp ; u_char *tmp___0 ; int tmp___1 ; char *tmp___2 ; int tmp___3 ; int tmp___4 ; char *tmp___5 ; int tmp___6 ; u_char *tmp___7 ; int tmp___8 ; char *tmp___9 ; u_char *tmp___10 ; int tmp___11 ; int tmp___12 ; char *tmp___13 ; u_char *tmp___14 ; int tmp___15 ; u_char *tmp___16 ; int tmp___17 ; char *tmp___18 ; int tmp___19 ; u_char *tmp___20 ; int tmp___21 ; char *tmp___22 ; { dp = dest; p = p + 2UL; tmp = sprintf(dp, " octet 3 "); dp = dp + (unsigned long )tmp; tmp___0 = p; p = p + 1; tmp___1 = prbits(dp, (int )*tmp___0, 8, 8); dp = dp + (unsigned long )tmp___1; tmp___2 = dp; dp = dp + 1; *tmp___2 = 10; tmp___3 = sprintf(dp, " octet 4 "); dp = dp + (unsigned long )tmp___3; tmp___4 = prbits(dp, (int )*p, 8, 8); dp = dp + (unsigned long )tmp___4; tmp___5 = dp; dp = dp + 1; *tmp___5 = 10; tmp___10 = p; p = p + 1; if (((int )*tmp___10 & 31) == 24) { tmp___6 = sprintf(dp, " octet 4.1 "); dp = dp + (unsigned long )tmp___6; tmp___7 = p; p = p + 1; tmp___8 = prbits(dp, (int )*tmp___7, 8, 8); dp = dp + (unsigned long )tmp___8; tmp___9 = dp; dp = dp + 1; *tmp___9 = 10; } else { } if (((int )*p & 96) == 32) { ch = 32; ldv_41037: tmp___11 = sprintf(dp, " octet 5%c ", (int )ch); dp = dp + (unsigned long )tmp___11; tmp___12 = prbits(dp, (int )*p, 8, 8); dp = dp + (unsigned long )tmp___12; tmp___13 = dp; dp = dp + 1; *tmp___13 = 10; if ((int )((signed char )ch) == 32) { ch = 97; } else { ch = (char )((int )ch + 1); } tmp___14 = p; p = p + 1; if ((int )((signed char )*tmp___14) >= 0) { goto ldv_41037; } else { } } else { } if (((int )*p & 96) == 64) { tmp___15 = sprintf(dp, " octet 6 "); dp = dp + (unsigned long )tmp___15; tmp___16 = p; p = p + 1; tmp___17 = prbits(dp, (int )*tmp___16, 8, 8); dp = dp + (unsigned long )tmp___17; tmp___18 = dp; dp = dp + 1; *tmp___18 = 10; } else { } if (((int )*p & 96) == 96) { tmp___19 = sprintf(dp, " octet 7 "); dp = dp + (unsigned long )tmp___19; tmp___20 = p; p = p + 1; tmp___21 = prbits(dp, (int )*tmp___20, 8, 8); dp = dp + (unsigned long )tmp___21; tmp___22 = dp; dp = dp + 1; *tmp___22 = 10; } else { } return ((int )((unsigned int )((long )dp) - (unsigned int )((long )dest))); } } static int prbearer_ni1(char *dest , u_char *p ) { char *dp ; u_char len ; u_char *tmp ; int tmp___0 ; int tmp___1 ; u_char *tmp___2 ; int tmp___3 ; int tmp___4 ; int tmp___5 ; int tmp___6 ; char *tmp___7 ; int tmp___8 ; int tmp___9 ; u_char *tmp___10 ; int tmp___11 ; int tmp___12 ; int tmp___13 ; char *tmp___14 ; int tmp___15 ; int tmp___16 ; u_char *tmp___17 ; int tmp___18 ; int tmp___19 ; int tmp___20 ; int tmp___21 ; int tmp___22 ; char *tmp___23 ; { dp = dest; p = p + 1; tmp = p; p = p + 1; len = *tmp; tmp___0 = sprintf(dp, " octet 3 "); dp = dp + (unsigned long )tmp___0; tmp___1 = prbits(dp, (int )*p, 8, 8); dp = dp + (unsigned long )tmp___1; tmp___2 = p; p = p + 1; switch ((int )*tmp___2) { case 128: tmp___3 = sprintf(dp, " Speech"); dp = dp + (unsigned long )tmp___3; goto ldv_41046; case 136: tmp___4 = sprintf(dp, " Unrestricted digital information"); dp = dp + (unsigned long )tmp___4; goto ldv_41046; case 144: tmp___5 = sprintf(dp, " 3.1 kHz audio"); dp = dp + (unsigned long )tmp___5; goto ldv_41046; default: tmp___6 = sprintf(dp, " Unknown information-transfer capability"); dp = dp + (unsigned long )tmp___6; } ldv_41046: tmp___7 = dp; dp = dp + 1; *tmp___7 = 10; tmp___8 = sprintf(dp, " octet 4 "); dp = dp + (unsigned long )tmp___8; tmp___9 = prbits(dp, (int )*p, 8, 8); dp = dp + (unsigned long )tmp___9; tmp___10 = p; p = p + 1; switch ((int )*tmp___10) { case 144: tmp___11 = sprintf(dp, " 64 kbps, circuit mode"); dp = dp + (unsigned long )tmp___11; goto ldv_41051; case 192: tmp___12 = sprintf(dp, " Packet mode"); dp = dp + (unsigned long )tmp___12; goto ldv_41051; default: tmp___13 = sprintf(dp, " Unknown transfer mode"); dp = dp + (unsigned long )tmp___13; } ldv_41051: tmp___14 = dp; dp = dp + 1; *tmp___14 = 10; if ((unsigned int )len > 2U) { tmp___15 = sprintf(dp, " octet 5 "); dp = dp + (unsigned long )tmp___15; tmp___16 = prbits(dp, (int )*p, 8, 8); dp = dp + (unsigned long )tmp___16; tmp___17 = p; p = p + 1; switch ((int )*tmp___17) { case 33: tmp___18 = sprintf(dp, " Rate adaption\n"); dp = dp + (unsigned long )tmp___18; tmp___19 = sprintf(dp, " octet 5a "); dp = dp + (unsigned long )tmp___19; tmp___20 = prbits(dp, (int )*p, 8, 8); dp = dp + (unsigned long )tmp___20; goto ldv_41055; case 162: tmp___21 = sprintf(dp, " u-law"); dp = dp + (unsigned long )tmp___21; goto ldv_41055; default: tmp___22 = sprintf(dp, " Unknown UI layer 1 protocol"); dp = dp + (unsigned long )tmp___22; } ldv_41055: tmp___23 = dp; dp = dp + 1; *tmp___23 = 10; } else { } return ((int )((unsigned int )((long )dp) - (unsigned int )((long )dest))); } } static int general(char *dest , u_char *p ) { char *dp ; char ch ; int l ; int octet ; u_char *tmp ; int tmp___0 ; u_char *tmp___1 ; int tmp___2 ; char *tmp___3 ; int tmp___4 ; { dp = dest; ch = 32; octet = 3; p = p + 1; tmp = p; p = p + 1; l = (int )*tmp; goto ldv_41067; ldv_41066: tmp___0 = sprintf(dp, " octet %d%c ", octet, (int )ch); dp = dp + (unsigned long )tmp___0; tmp___1 = p; p = p + 1; tmp___2 = prbits(dp, (int )*tmp___1, 8, 8); dp = dp + (unsigned long )tmp___2; tmp___3 = dp; dp = dp + 1; *tmp___3 = 10; if ((int )((signed char )*p) < 0) { octet = octet + 1; ch = 32; } else if ((int )((signed char )ch) == 32) { ch = 97; } else { ch = (char )((int )ch + 1); } ldv_41067: tmp___4 = l; l = l - 1; if (tmp___4 != 0) { goto ldv_41066; } else { } return ((int )((unsigned int )((long )dp) - (unsigned int )((long )dest))); } } static int general_ni1(char *dest , u_char *p ) { char *dp ; char ch ; int l ; int octet ; u_char *tmp ; int tmp___0 ; int tmp___1 ; char *tmp___2 ; u_char *tmp___3 ; int tmp___4 ; { dp = dest; ch = 32; octet = 3; p = p + 1; tmp = p; p = p + 1; l = (int )*tmp; goto ldv_41078; ldv_41077: tmp___0 = sprintf(dp, " octet %d%c ", octet, (int )ch); dp = dp + (unsigned long )tmp___0; tmp___1 = prbits(dp, (int )*p, 8, 8); dp = dp + (unsigned long )tmp___1; tmp___2 = dp; dp = dp + 1; *tmp___2 = 10; tmp___3 = p; p = p + 1; if ((int )((signed char )*tmp___3) < 0) { octet = octet + 1; ch = 32; } else if ((int )((signed char )ch) == 32) { ch = 97; } else { ch = (char )((int )ch + 1); } ldv_41078: tmp___4 = l; l = l - 1; if (tmp___4 != 0) { goto ldv_41077; } else { } return ((int )((unsigned int )((long )dp) - (unsigned int )((long )dest))); } } static int prcharge(char *dest , u_char *p ) { char *dp ; int l ; u_char *tmp ; int tmp___0 ; u_char *tmp___1 ; int tmp___2 ; int tmp___3 ; char *tmp___4 ; u_char *tmp___5 ; int tmp___6 ; char *tmp___7 ; { dp = dest; p = p + 1; tmp = p; p = p + 1; l = (int )*tmp + -1; tmp___0 = sprintf(dp, " GEA "); dp = dp + (unsigned long )tmp___0; tmp___1 = p; p = p + 1; tmp___2 = prbits(dp, (int )*tmp___1, 8, 8); dp = dp + (unsigned long )tmp___2; tmp___3 = sprintf(dp, " Anzahl: "); dp = dp + (unsigned long )tmp___3; goto ldv_41087; ldv_41086: tmp___4 = dp; dp = dp + 1; tmp___5 = p; p = p + 1; *tmp___4 = (char )*tmp___5; ldv_41087: tmp___6 = l; l = l - 1; if (tmp___6 != 0) { goto ldv_41086; } else { } tmp___7 = dp; dp = dp + 1; *tmp___7 = 10; return ((int )((unsigned int )((long )dp) - (unsigned int )((long )dest))); } } static int prtext(char *dest , u_char *p ) { char *dp ; int l ; u_char *tmp ; int tmp___0 ; char *tmp___1 ; u_char *tmp___2 ; int tmp___3 ; char *tmp___4 ; { dp = dest; p = p + 1; tmp = p; p = p + 1; l = (int )*tmp; tmp___0 = sprintf(dp, " "); dp = dp + (unsigned long )tmp___0; goto ldv_41096; ldv_41095: tmp___1 = dp; dp = dp + 1; tmp___2 = p; p = p + 1; *tmp___1 = (char )*tmp___2; ldv_41096: tmp___3 = l; l = l - 1; if (tmp___3 != 0) { goto ldv_41095; } else { } tmp___4 = dp; dp = dp + 1; *tmp___4 = 10; return ((int )((unsigned int )((long )dp) - (unsigned int )((long )dest))); } } static int prfeatureind(char *dest , u_char *p ) { char *dp ; int tmp ; int tmp___0 ; char *tmp___1 ; int tmp___2 ; u_char *tmp___3 ; int tmp___4 ; char *tmp___5 ; u_char *tmp___6 ; int tmp___7 ; int tmp___8 ; int tmp___9 ; int tmp___10 ; int tmp___11 ; int tmp___12 ; char *tmp___13 ; { dp = dest; p = p + 2UL; tmp = sprintf(dp, " octet 3 "); dp = dp + (unsigned long )tmp; tmp___0 = prbits(dp, (int )*p, 8, 8); dp = dp + (unsigned long )tmp___0; tmp___1 = dp; dp = dp + 1; *tmp___1 = 10; tmp___6 = p; p = p + 1; if (((int )*tmp___6 & 80) == 0) { tmp___2 = sprintf(dp, " octet 4 "); dp = dp + (unsigned long )tmp___2; tmp___3 = p; p = p + 1; tmp___4 = prbits(dp, (int )*tmp___3, 8, 8); dp = dp + (unsigned long )tmp___4; tmp___5 = dp; dp = dp + 1; *tmp___5 = 10; } else { } tmp___7 = sprintf(dp, " Status: "); dp = dp + (unsigned long )tmp___7; switch ((int )*p) { case 0: tmp___8 = sprintf(dp, "Idle"); dp = dp + (unsigned long )tmp___8; goto ldv_41104; case 1: tmp___9 = sprintf(dp, "Active"); dp = dp + (unsigned long )tmp___9; goto ldv_41104; case 2: tmp___10 = sprintf(dp, "Prompt"); dp = dp + (unsigned long )tmp___10; goto ldv_41104; case 3: tmp___11 = sprintf(dp, "Pending"); dp = dp + (unsigned long )tmp___11; goto ldv_41104; default: tmp___12 = sprintf(dp, "(Reserved)"); dp = dp + (unsigned long )tmp___12; goto ldv_41104; } ldv_41104: tmp___13 = dp; dp = dp + 1; *tmp___13 = 10; return ((int )((unsigned int )((long )dp) - (unsigned int )((long )dest))); } } static struct DTag dtaglist[22U] = { {130U, (char *)"Continuation"}, {131U, (char *)"Called address"}, {132U, (char *)"Cause"}, {133U, (char *)"Progress indicator"}, {134U, (char *)"Notification indicator"}, {135U, (char *)"Prompt"}, {136U, (char *)"Accumlated digits"}, {137U, (char *)"Status"}, {138U, (char *)"Inband"}, {139U, (char *)"Calling address"}, {140U, (char *)"Reason"}, {141U, (char *)"Calling party name"}, {142U, (char *)"Called party name"}, {143U, (char *)"Orignal called name"}, {144U, (char *)"Redirecting name"}, {145U, (char *)"Connected name"}, {146U, (char *)"Originating restrictions"}, {147U, (char *)"Date & time of day"}, {148U, (char *)"Call Appearance ID"}, {149U, (char *)"Feature address"}, {150U, (char *)"Redirection name"}, {158U, (char *)"Text"}}; static int disptext_ni1(char *dest , u_char *p ) { char *dp ; int l ; int tag ; int len ; int i ; u_char *tmp ; int tmp___0 ; u_char *tmp___1 ; u_char *tmp___2 ; u_char *tmp___3 ; int tmp___4 ; char *tmp___5 ; u_char *tmp___6 ; int tmp___7 ; int tmp___8 ; char *tmp___9 ; u_char *tmp___10 ; int tmp___11 ; int tmp___12 ; { dp = dest; p = p + 1; tmp = p; p = p + 1; l = (int )*tmp + -1; tmp___1 = p; p = p + 1; if ((unsigned int )*tmp___1 != 128U) { tmp___0 = sprintf(dp, " Unknown display type\n"); dp = dp + (unsigned long )tmp___0; return ((int )((unsigned int )((long )dp) - (unsigned int )((long )dest))); } else { } goto ldv_41136; ldv_41135: tmp___2 = p; p = p + 1; tag = (int )*tmp___2; tmp___3 = p; p = p + 1; len = (int )*tmp___3; l = (-2 - len) + l; if (tag == 128 || tag == 129) { p = p + 1; } else { i = 0; goto ldv_41126; ldv_41125: ; if ((int )dtaglist[i].nr == tag) { goto ldv_41124; } else { } i = i + 1; ldv_41126: ; if ((unsigned int )i <= 21U) { goto ldv_41125; } else { } ldv_41124: ; if (i != 22) { tmp___4 = sprintf(dp, " %s: ", dtaglist[i].descr); dp = dp + (unsigned long )tmp___4; goto ldv_41130; ldv_41129: tmp___5 = dp; dp = dp + 1; tmp___6 = p; p = p + 1; *tmp___5 = (char )*tmp___6; ldv_41130: tmp___7 = len; len = len - 1; if (tmp___7 != 0) { goto ldv_41129; } else { } } else { tmp___8 = sprintf(dp, " (unknown display tag %2x): ", tag); dp = dp + (unsigned long )tmp___8; goto ldv_41133; ldv_41132: tmp___9 = dp; dp = dp + 1; tmp___10 = p; p = p + 1; *tmp___9 = (char )*tmp___10; ldv_41133: tmp___11 = len; len = len - 1; if (tmp___11 != 0) { goto ldv_41132; } else { } } tmp___12 = sprintf(dp, "\n"); dp = dp + (unsigned long )tmp___12; } ldv_41136: ; if (l > 0) { goto ldv_41135; } else { } return ((int )((unsigned int )((long )dp) - (unsigned int )((long )dest))); } } static int display(char *dest , u_char *p ) { char *dp ; char ch ; int l ; int octet ; u_char *tmp ; int tmp___0 ; u_char *tmp___1 ; int tmp___2 ; int tmp___3 ; char *tmp___4 ; char *tmp___5 ; { dp = dest; ch = 32; octet = 3; p = p + 1; tmp = p; p = p + 1; l = (int )*tmp; tmp___0 = sprintf(dp, " \""); dp = dp + (unsigned long )tmp___0; goto ldv_41147; ldv_41146: tmp___1 = p; p = p + 1; tmp___2 = sprintf(dp, "%c", (int )*tmp___1); dp = dp + (unsigned long )tmp___2; if ((int )((signed char )*p) < 0) { octet = octet + 1; ch = 32; } else if ((int )((signed char )ch) == 32) { ch = 97; } else { ch = (char )((int )ch + 1); } ldv_41147: tmp___3 = l; l = l - 1; if (tmp___3 != 0) { goto ldv_41146; } else { } tmp___4 = dp; dp = dp + 1; *tmp___4 = 34; tmp___5 = dp; dp = dp + 1; *tmp___5 = 10; return ((int )((unsigned int )((long )dp) - (unsigned int )((long )dest))); } } static int prfacility(char *dest , u_char *p ) { char *dp ; int l ; int l2 ; u_char *tmp ; int tmp___0 ; u_char *tmp___1 ; int tmp___2 ; int tmp___3 ; int tmp___4 ; u_char *tmp___5 ; int tmp___6 ; int tmp___7 ; u_char *tmp___8 ; int tmp___9 ; int tmp___10 ; u_char *tmp___11 ; int tmp___12 ; int tmp___13 ; int tmp___14 ; { dp = dest; p = p + 1; tmp = p; p = p + 1; l = (int )*tmp; tmp___0 = sprintf(dp, " octet 3 "); dp = dp + (unsigned long )tmp___0; tmp___1 = p; p = p + 1; tmp___2 = prbits(dp, (int )*tmp___1, 8, 8); dp = dp + (unsigned long )tmp___2; tmp___3 = sprintf(dp, "\n"); dp = dp + (unsigned long )tmp___3; l = l + -1; goto ldv_41160; ldv_41159: tmp___4 = sprintf(dp, " octet 4 "); dp = dp + (unsigned long )tmp___4; tmp___5 = p; p = p + 1; tmp___6 = prbits(dp, (int )*tmp___5, 8, 8); dp = dp + (unsigned long )tmp___6; tmp___7 = sprintf(dp, "\n"); dp = dp + (unsigned long )tmp___7; tmp___8 = p; p = p + 1; l2 = (int )*tmp___8 & 127; tmp___9 = sprintf(dp, " octet 5 %d\n", l2); dp = dp + (unsigned long )tmp___9; l = l + -2; tmp___10 = sprintf(dp, " contents "); dp = dp + (unsigned long )tmp___10; goto ldv_41157; ldv_41156: tmp___11 = p; p = p + 1; tmp___12 = sprintf(dp, "%2x ", (int )*tmp___11); dp = dp + (unsigned long )tmp___12; l = l - 1; ldv_41157: tmp___13 = l2; l2 = l2 - 1; if (tmp___13 != 0) { goto ldv_41156; } else { } tmp___14 = sprintf(dp, "\n"); dp = dp + (unsigned long )tmp___14; ldv_41160: ; if (l > 0) { goto ldv_41159; } else { } return ((int )((unsigned int )((long )dp) - (unsigned int )((long )dest))); } } static struct InformationElement ielist[33U] = { {0U, (char *)"Segmented message", & general}, {4U, (char *)"Bearer capability", & prbearer}, {8U, (char *)"Cause", & prcause}, {16U, (char *)"Call identity", & general}, {20U, (char *)"Call state", & general}, {24U, (char *)"Channel identification", & prchident}, {28U, (char *)"Facility", & prfacility}, {30U, (char *)"Progress indicator", & general}, {32U, (char *)"Network-specific facilities", & general}, {39U, (char *)"Notification indicator", & general}, {40U, (char *)"Display", & display}, {41U, (char *)"Date/Time", & general}, {44U, (char *)"Keypad facility", & general}, {52U, (char *)"Signal", & general}, {64U, (char *)"Information rate", & general}, {66U, (char *)"End-to-end delay", & general}, {67U, (char *)"Transit delay selection and indication", & general}, {68U, (char *)"Packet layer binary parameters", & general}, {69U, (char *)"Packet layer window size", & general}, {70U, (char *)"Packet size", & general}, {71U, (char *)"Closed user group", & general}, {74U, (char *)"Reverse charge indication", & general}, {108U, (char *)"Calling party number", & prcalling}, {109U, (char *)"Calling party subaddress", & general}, {112U, (char *)"Called party number", & prcalled}, {113U, (char *)"Called party subaddress", & general}, {116U, (char *)"Redirecting number", & general}, {120U, (char *)"Transit network selection", & general}, {121U, (char *)"Restart indicator", & general}, {124U, (char *)"Low layer compatibility", & general}, {125U, (char *)"High layer compatibility", & general}, {126U, (char *)"User-user", & general}, {127U, (char *)"Escape for extension", & general}}; static struct InformationElement ielist_ni1[21U] = { {4U, (char *)"Bearer Capability", & prbearer_ni1}, {8U, (char *)"Cause", & prcause}, {20U, (char *)"Call State", & general_ni1}, {24U, (char *)"Channel Identification", & prchident}, {30U, (char *)"Progress Indicator", & general_ni1}, {39U, (char *)"Notification Indicator", & general_ni1}, {44U, (char *)"Keypad Facility", & prtext}, {50U, (char *)"Information Request", & general_ni1}, {52U, (char *)"Signal", & general_ni1}, {56U, (char *)"Feature Activation", & general_ni1}, {57U, (char *)"Feature Indication", & prfeatureind}, {58U, (char *)"Service Profile Identification (SPID)", & prtext}, {59U, (char *)"Endpoint Identifier", & general_ni1}, {108U, (char *)"Calling Party Number", & prcalling}, {109U, (char *)"Calling Party Subaddress", & general_ni1}, {112U, (char *)"Called Party Number", & prcalled}, {113U, (char *)"Called Party Subaddress", & general_ni1}, {116U, (char *)"Redirecting Number", & general_ni1}, {120U, (char *)"Transit Network Selection", & general_ni1}, {124U, (char *)"Low Layer Compatibility", & general_ni1}, {125U, (char *)"High Layer Compatibility", & general_ni1}}; static struct InformationElement ielist_ni1_cs5[2U] = { {29U, (char *)"Operator system access", & general_ni1}, {42U, (char *)"Display text", & disptext_ni1}}; static struct InformationElement ielist_ni1_cs6[1U] = { {123U, (char *)"Call appearance", & general_ni1}}; static struct InformationElement we_0[10U] = { {8U, (char *)"Cause", & prcause_1tr6}, {12U, (char *)"Connecting Address", & prcalled}, {16U, (char *)"Call IDentity", & general}, {24U, (char *)"Channel IDentity", & general}, {32U, (char *)"Network Specific Facility", & general}, {40U, (char *)"Display", & general}, {44U, (char *)"Keypad", & general}, {108U, (char *)"Origination Address", & prcalled}, {112U, (char *)"Destination Address", & prcalled}, {126U, (char *)"User Info", & general}}; static struct InformationElement we_6[7U] = { {1U, (char *)"Service Indicator", & general}, {2U, (char *)"Charging Information", & prcharge}, {3U, (char *)"Date", & prtext}, {5U, (char *)"Facility Select", & general}, {6U, (char *)"Facility Status", & general}, {7U, (char *)"Status Called", & general}, {8U, (char *)"Additional Transmission Attributes", & general}}; int QuickHex(char *txt , u_char *p , int cnt ) { register int i ; register char *t ; char *tmp ; char *tmp___0 ; char *tmp___1 ; char *tmp___2 ; { t = txt; i = 0; goto ldv_41182; ldv_41181: tmp = t; t = t + 1; *tmp = 32; tmp___0 = t; t = t + 1; *tmp___0 = hex_asc[(int )*(p + (unsigned long )i) >> 4]; tmp___1 = t; t = t + 1; *tmp___1 = hex_asc[(int )*(p + (unsigned long )i) & 15]; i = i + 1; ldv_41182: ; if (i < cnt) { goto ldv_41181; } else { } tmp___2 = t; t = t + 1; *tmp___2 = 0; return ((int )((unsigned int )((long )t) - (unsigned int )((long )txt))); } } void LogFrame(struct IsdnCardState *cs , u_char *buf , int size ) { char *dp ; char *tmp ; char *tmp___0 ; char *tmp___1 ; char *tmp___2 ; int tmp___3 ; char *tmp___4 ; { if (size <= 0) { return; } else { } dp = cs->dlog; if (size <= 671) { tmp = dp; dp = dp + 1; *tmp = 72; tmp___0 = dp; dp = dp + 1; *tmp___0 = 69; tmp___1 = dp; dp = dp + 1; *tmp___1 = 88; tmp___2 = dp; dp = dp + 1; *tmp___2 = 58; tmp___3 = QuickHex(dp, buf, size); dp = dp + (unsigned long )tmp___3; dp = dp - 1; tmp___4 = dp; dp = dp + 1; *tmp___4 = 10; *dp = 0; HiSax_putstatus(cs, 0, cs->dlog); } else { HiSax_putstatus(cs, (char *)"LogFrame: ", (char *)"warning Frame too big (%d)", size); } return; } } void dlogframe(struct IsdnCardState *cs , struct sk_buff *skb , int dir ) { u_char *bend ; u_char *buf ; char *dp ; unsigned char pd ; unsigned char cr_l ; unsigned char cr ; unsigned char mt ; unsigned char sapi ; unsigned char tei ; unsigned char ftyp ; int i ; int cset ; int cs_old ; int cs_fest ; int size ; int finish ; int tmp ; char *tmp___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 ; int tmp___9 ; u_char *tmp___10 ; u_char *tmp___11 ; u_char *tmp___12 ; u_char *tmp___13 ; int tmp___14 ; int tmp___15 ; int tmp___16 ; int tmp___17 ; int tmp___18 ; int tmp___19 ; int tmp___20 ; int tmp___21 ; int tmp___22 ; int tmp___23 ; int tmp___24 ; int tmp___25 ; int tmp___26 ; int tmp___27 ; int tmp___28 ; int tmp___29 ; u_char *tmp___30 ; u_char *tmp___31 ; u_char *tmp___32 ; int tmp___33 ; int tmp___34 ; int tmp___35 ; int tmp___36 ; int tmp___37 ; int tmp___38 ; int tmp___39 ; int tmp___40 ; int tmp___41 ; int tmp___42 ; int tmp___43 ; int tmp___44 ; int tmp___45 ; int tmp___46 ; u_char *tmp___47 ; u_char *tmp___48 ; u_char *tmp___49 ; int tmp___50 ; int tmp___51 ; int tmp___52 ; int tmp___53 ; int tmp___54 ; int tmp___55 ; int tmp___56 ; int tmp___57 ; int tmp___58 ; int tmp___59 ; int tmp___60 ; int tmp___61 ; { cset = 0; cs_old = 0; cs_fest = 0; finish = 0; if (skb->len <= 2U) { return; } else { } dp = cs->dlog; tmp = jiftime(dp, (long )jiffies); dp = dp + (unsigned long )tmp; tmp___0 = dp; dp = dp + 1; *tmp___0 = 32; sapi = (int )*(skb->data) >> 2; tei = (int )*(skb->data + 1UL) >> 1; ftyp = *(skb->data + 2UL); buf = skb->data; tmp___1 = sprintf(dp, "frame %s ", dir != 0 ? (char *)"network->user" : (char *)"user->network"); dp = dp + (unsigned long )tmp___1; size = (int )skb->len; if ((unsigned int )tei == 127U) { if ((unsigned int )sapi == 0U) { if ((unsigned int )ftyp == 3U) { tmp___2 = sprintf(dp, "broadcast\n"); dp = dp + (unsigned long )tmp___2; buf = buf + 3UL; size = size + -3; } else { tmp___3 = sprintf(dp, "no UI broadcast\n"); dp = dp + (unsigned long )tmp___3; finish = 1; } } else if ((unsigned int )sapi == 63U) { tmp___4 = sprintf(dp, "tei management\n"); dp = dp + (unsigned long )tmp___4; finish = 1; } else { tmp___5 = sprintf(dp, "unknown sapi %d broadcast\n", (int )sapi); dp = dp + (unsigned long )tmp___5; finish = 1; } } else if ((unsigned int )sapi == 0U) { if (((int )ftyp & 1) == 0) { tmp___6 = sprintf(dp, "with tei %d\n", (int )tei); dp = dp + (unsigned long )tmp___6; buf = buf + 4UL; size = size + -4; } else { tmp___7 = sprintf(dp, "SFrame with tei %d\n", (int )tei); dp = dp + (unsigned long )tmp___7; finish = 1; } } else { tmp___8 = sprintf(dp, "unknown sapi %d tei %d\n", (int )sapi, (int )tei); dp = dp + (unsigned long )tmp___8; finish = 1; } bend = skb->data + (unsigned long )skb->len; if ((unsigned long )buf >= (unsigned long )bend) { tmp___9 = sprintf(dp, "frame too short\n"); dp = dp + (unsigned long )tmp___9; finish = 1; } else { } if (finish != 0) { *dp = 0; HiSax_putstatus(cs, 0, cs->dlog); return; } else { } if (((unsigned int )*buf & 254U) == 64U) { tmp___10 = buf; buf = buf + 1; pd = *tmp___10; tmp___11 = buf; buf = buf + 1; cr_l = *tmp___11; if ((unsigned int )cr_l != 0U) { tmp___12 = buf; buf = buf + 1; cr = *tmp___12; } else { cr = 0U; } tmp___13 = buf; buf = buf + 1; mt = *tmp___13; if ((unsigned int )pd == 64U) { i = 0; goto ldv_41215; ldv_41214: ; if ((int )mt_n0[i].nr == (int )mt) { goto ldv_41213; } else { } i = i + 1; ldv_41215: ; if ((unsigned int )i <= 9U) { goto ldv_41214; } else { } ldv_41213: ; if (i == 10) { tmp___14 = sprintf(dp, "callref %d %s size %d unknown message type N0 %x!\n", (int )cr & 127, (int )((signed char )cr) < 0 ? (char *)"called" : (char *)"caller", size, (int )mt); dp = dp + (unsigned long )tmp___14; } else { tmp___15 = sprintf(dp, "callref %d %s size %d message type %s\n", (int )cr & 127, (int )((signed char )cr) < 0 ? (char *)"called" : (char *)"caller", size, mt_n0[i].descr); dp = dp + (unsigned long )tmp___15; } } else { i = 0; goto ldv_41222; ldv_41221: ; if ((int )mt_n1[i].nr == (int )mt) { goto ldv_41220; } else { } i = i + 1; ldv_41222: ; if ((unsigned int )i <= 29U) { goto ldv_41221; } else { } ldv_41220: ; if (i == 30) { tmp___16 = sprintf(dp, "callref %d %s size %d unknown message type N1 %x!\n", (int )cr & 127, (int )((signed char )cr) < 0 ? (char *)"called" : (char *)"caller", size, (int )mt); dp = dp + (unsigned long )tmp___16; } else { tmp___17 = sprintf(dp, "callref %d %s size %d message type %s\n", (int )cr & 127, (int )((signed char )cr) < 0 ? (char *)"called" : (char *)"caller", size, mt_n1[i].descr); dp = dp + (unsigned long )tmp___17; } } goto ldv_41230; ldv_41245: ; if ((int )((signed char )*buf) < 0) { switch (((int )*buf >> 4) & 7) { case 1: tmp___18 = sprintf(dp, " Shift %x\n", (int )*buf & 15); dp = dp + (unsigned long )tmp___18; cs_old = cset; cset = (int )*buf & 7; cs_fest = (int )*buf & 8; goto ldv_41226; case 3: tmp___19 = sprintf(dp, " Congestion level %x\n", (int )*buf & 15); dp = dp + (unsigned long )tmp___19; goto ldv_41226; case 2: ; if ((unsigned int )*buf == 160U) { tmp___20 = sprintf(dp, " More data\n"); dp = dp + (unsigned long )tmp___20; goto ldv_41226; } else { } if ((unsigned int )*buf == 161U) { tmp___21 = sprintf(dp, " Sending complete\n"); dp = dp + (unsigned long )tmp___21; } else { } goto ldv_41226; default: tmp___22 = sprintf(dp, " Reserved %x\n", (int )*buf); dp = dp + (unsigned long )tmp___22; goto ldv_41226; } ldv_41226: buf = buf + 1; goto ldv_41230; } else { } if (cset == 0) { i = 0; goto ldv_41235; ldv_41234: ; if ((int )*buf == (int )we_0[i].nr) { goto ldv_41233; } else { } i = i + 1; ldv_41235: ; if ((unsigned int )i <= 9U) { goto ldv_41234; } else { } ldv_41233: ; if (i != 10) { tmp___23 = sprintf(dp, " %s\n", we_0[i].descr); dp = dp + (unsigned long )tmp___23; tmp___24 = (*(we_0[i].f))(dp, buf); dp = dp + (unsigned long )tmp___24; } else { tmp___25 = sprintf(dp, " Codeset %d attribute %x attribute size %d\n", cset, (int )*buf, (int )*(buf + 1UL)); dp = dp + (unsigned long )tmp___25; } } else if (cset == 6) { i = 0; goto ldv_41242; ldv_41241: ; if ((int )*buf == (int )we_6[i].nr) { goto ldv_41240; } else { } i = i + 1; ldv_41242: ; if ((unsigned int )i <= 6U) { goto ldv_41241; } else { } ldv_41240: ; if (i != 7) { tmp___26 = sprintf(dp, " %s\n", we_6[i].descr); dp = dp + (unsigned long )tmp___26; tmp___27 = (*(we_6[i].f))(dp, buf); dp = dp + (unsigned long )tmp___27; } else { tmp___28 = sprintf(dp, " Codeset %d attribute %x attribute size %d\n", cset, (int )*buf, (int )*(buf + 1UL)); dp = dp + (unsigned long )tmp___28; } } else { tmp___29 = sprintf(dp, " Unknown Codeset %d attribute %x attribute size %d\n", cset, (int )*buf, (int )*(buf + 1UL)); dp = dp + (unsigned long )tmp___29; } if (cs_fest == 8) { cset = cs_old; cs_old = 0; cs_fest = 0; } else { } buf = buf + ((unsigned long )*(buf + 1UL) + 2UL); ldv_41230: ; if ((unsigned long )buf < (unsigned long )bend) { goto ldv_41245; } else { } } else if ((unsigned int )*buf == 8U && cs->protocol == 4) { buf = buf + 1; tmp___30 = buf; buf = buf + 1; cr_l = *tmp___30; if ((unsigned int )cr_l != 0U) { tmp___31 = buf; buf = buf + 1; cr = *tmp___31; } else { cr = 0U; } tmp___32 = buf; buf = buf + 1; mt = *tmp___32; i = 0; goto ldv_41251; ldv_41250: ; if ((int )mtlist[i].nr == (int )mt) { goto ldv_41249; } else { } i = i + 1; ldv_41251: ; if ((unsigned int )i <= 31U) { goto ldv_41250; } else { } ldv_41249: ; if (i == 32) { tmp___33 = sprintf(dp, "callref %d %s size %d unknown message type %x!\n", (int )cr & 127, (int )((signed char )cr) < 0 ? (char *)"called" : (char *)"caller", size, (int )mt); dp = dp + (unsigned long )tmp___33; } else { tmp___34 = sprintf(dp, "callref %d %s size %d message type %s\n", (int )cr & 127, (int )((signed char )cr) < 0 ? (char *)"called" : (char *)"caller", size, mtlist[i].descr); dp = dp + (unsigned long )tmp___34; } goto ldv_41257; ldv_41279: ; if ((int )((signed char )*buf) < 0) { switch (((int )*buf >> 4) & 7) { case 1: tmp___35 = sprintf(dp, " Shift %x\n", (int )*buf & 15); dp = dp + (unsigned long )tmp___35; cs_old = cset; cset = (int )*buf & 7; cs_fest = (int )*buf & 8; goto ldv_41255; default: tmp___36 = sprintf(dp, " Unknown single-octet IE %x\n", (int )*buf); dp = dp + (unsigned long )tmp___36; goto ldv_41255; } ldv_41255: buf = buf + 1; goto ldv_41257; } else { } if (cset == 0) { i = 0; goto ldv_41262; ldv_41261: ; if ((int )*buf == (int )ielist_ni1[i].nr) { goto ldv_41260; } else { } i = i + 1; ldv_41262: ; if ((unsigned int )i <= 20U) { goto ldv_41261; } else { } ldv_41260: ; if (i != 21) { tmp___37 = sprintf(dp, " %s\n", ielist_ni1[i].descr); dp = dp + (unsigned long )tmp___37; tmp___38 = (*(ielist_ni1[i].f))(dp, buf); dp = dp + (unsigned long )tmp___38; } else { tmp___39 = sprintf(dp, " attribute %x attribute size %d\n", (int )*buf, (int )*(buf + 1UL)); dp = dp + (unsigned long )tmp___39; } } else if (cset == 5) { i = 0; goto ldv_41269; ldv_41268: ; if ((int )*buf == (int )ielist_ni1_cs5[i].nr) { goto ldv_41267; } else { } i = i + 1; ldv_41269: ; if ((unsigned int )i <= 1U) { goto ldv_41268; } else { } ldv_41267: ; if (i != 2) { tmp___40 = sprintf(dp, " %s\n", ielist_ni1_cs5[i].descr); dp = dp + (unsigned long )tmp___40; tmp___41 = (*(ielist_ni1_cs5[i].f))(dp, buf); dp = dp + (unsigned long )tmp___41; } else { tmp___42 = sprintf(dp, " attribute %x attribute size %d\n", (int )*buf, (int )*(buf + 1UL)); dp = dp + (unsigned long )tmp___42; } } else if (cset == 6) { i = 0; goto ldv_41276; ldv_41275: ; if ((int )*buf == (int )ielist_ni1_cs6[i].nr) { goto ldv_41274; } else { } i = i + 1; ldv_41276: ; if (i == 0) { goto ldv_41275; } else { } ldv_41274: ; if (i != 1) { tmp___43 = sprintf(dp, " %s\n", ielist_ni1_cs6[i].descr); dp = dp + (unsigned long )tmp___43; tmp___44 = (*(ielist_ni1_cs6[i].f))(dp, buf); dp = dp + (unsigned long )tmp___44; } else { tmp___45 = sprintf(dp, " attribute %x attribute size %d\n", (int )*buf, (int )*(buf + 1UL)); dp = dp + (unsigned long )tmp___45; } } else { tmp___46 = sprintf(dp, " Unknown Codeset %d attribute %x attribute size %d\n", cset, (int )*buf, (int )*(buf + 1UL)); dp = dp + (unsigned long )tmp___46; } if (cs_fest == 8) { cset = cs_old; cs_old = 0; cs_fest = 0; } else { } buf = buf + ((unsigned long )*(buf + 1UL) + 2UL); ldv_41257: ; if ((unsigned long )buf < (unsigned long )bend) { goto ldv_41279; } else { } } else if ((unsigned int )*buf == 8U && cs->protocol == 2) { buf = buf + 1; tmp___47 = buf; buf = buf + 1; cr_l = *tmp___47; if ((unsigned int )cr_l != 0U) { tmp___48 = buf; buf = buf + 1; cr = *tmp___48; } else { cr = 0U; } tmp___49 = buf; buf = buf + 1; mt = *tmp___49; i = 0; goto ldv_41285; ldv_41284: ; if ((int )mtlist[i].nr == (int )mt) { goto ldv_41283; } else { } i = i + 1; ldv_41285: ; if ((unsigned int )i <= 31U) { goto ldv_41284; } else { } ldv_41283: ; if (i == 32) { tmp___50 = sprintf(dp, "callref %d %s size %d unknown message type %x!\n", (int )cr & 127, (int )((signed char )cr) < 0 ? (char *)"called" : (char *)"caller", size, (int )mt); dp = dp + (unsigned long )tmp___50; } else { tmp___51 = sprintf(dp, "callref %d %s size %d message type %s\n", (int )cr & 127, (int )((signed char )cr) < 0 ? (char *)"called" : (char *)"caller", size, mtlist[i].descr); dp = dp + (unsigned long )tmp___51; } goto ldv_41294; ldv_41302: ; if ((int )((signed char )*buf) < 0) { switch (((int )*buf >> 4) & 7) { case 1: tmp___52 = sprintf(dp, " Shift %x\n", (int )*buf & 15); dp = dp + (unsigned long )tmp___52; goto ldv_41289; case 3: tmp___53 = sprintf(dp, " Congestion level %x\n", (int )*buf & 15); dp = dp + (unsigned long )tmp___53; goto ldv_41289; case 5: tmp___54 = sprintf(dp, " Repeat indicator %x\n", (int )*buf & 15); dp = dp + (unsigned long )tmp___54; goto ldv_41289; case 2: ; if ((unsigned int )*buf == 160U) { tmp___55 = sprintf(dp, " More data\n"); dp = dp + (unsigned long )tmp___55; goto ldv_41289; } else { } if ((unsigned int )*buf == 161U) { tmp___56 = sprintf(dp, " Sending complete\n"); dp = dp + (unsigned long )tmp___56; } else { } goto ldv_41289; default: tmp___57 = sprintf(dp, " Reserved %x\n", (int )*buf); dp = dp + (unsigned long )tmp___57; goto ldv_41289; } ldv_41289: buf = buf + 1; goto ldv_41294; } else { } i = 0; goto ldv_41299; ldv_41298: ; if ((int )*buf == (int )ielist[i].nr) { goto ldv_41297; } else { } i = i + 1; ldv_41299: ; if ((unsigned int )i <= 32U) { goto ldv_41298; } else { } ldv_41297: ; if (i != 33) { tmp___58 = sprintf(dp, " %s\n", ielist[i].descr); dp = dp + (unsigned long )tmp___58; tmp___59 = (*(ielist[i].f))(dp, buf); dp = dp + (unsigned long )tmp___59; } else { tmp___60 = sprintf(dp, " attribute %x attribute size %d\n", (int )*buf, (int )*(buf + 1UL)); dp = dp + (unsigned long )tmp___60; } buf = buf + ((unsigned long )*(buf + 1UL) + 2UL); ldv_41294: ; if ((unsigned long )buf < (unsigned long )bend) { goto ldv_41302; } else { } } else { tmp___61 = sprintf(dp, "Unknown protocol %x!", (int )*buf); dp = dp + (unsigned long )tmp___61; } *dp = 0; HiSax_putstatus(cs, 0, cs->dlog); return; } } void ldv_mutex_lock_85(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_lock(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_86(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_lock(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_87(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } int ldv_mutex_trylock_88(struct mutex *ldv_func_arg1 ) { ldv_func_ret_type___2 ldv_func_res ; int tmp ; int tmp___0 ; { tmp = mutex_trylock(ldv_func_arg1); ldv_func_res = tmp; tmp___0 = ldv_mutex_trylock_mutex(ldv_func_arg1); return (tmp___0); return (ldv_func_res); } } void ldv_mutex_unlock_89(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_90(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_cred_guard_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_91(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_cred_guard_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } extern int strcmp(char const * , char const * ) ; extern char *strncpy(char * , char const * , __kernel_size_t ) ; int ldv_mutex_trylock_102(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_100(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_103(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_105(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_99(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_101(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_104(struct mutex *ldv_func_arg1 ) ; char const *lli_revision = "$Revision: 2.59.2.4 $"; static int init_b_st(struct Channel *chanp , int incoming ) ; static void release_b_st(struct Channel *chanp ) ; static struct Fsm callcfsm ; static int chancount ; __inline static struct IsdnCardState *hisax_findcard___0(int driverid ) { int i ; { i = 0; goto ldv_41739; ldv_41738: ; if ((unsigned long )cards[i].cs != (unsigned long )((IsdnCardState_t *)0)) { if ((cards[i].cs)->myid == driverid) { return (cards[i].cs); } else { } } else { } i = i + 1; ldv_41739: ; if (i < nrcards) { goto ldv_41738; } else { } return (0); } } static void link_debug(struct Channel *chanp , int direction , char *fmt , ...) { va_list args ; char tmp[16U] ; { __builtin_va_start((__va_list_tag *)(& args), fmt); sprintf((char *)(& tmp), "Ch%d %s ", chanp->chan, direction != 0 ? (char *)"LL->HL" : (char *)"HL->LL"); VHiSax_putstatus(chanp->cs, (char *)(& tmp), fmt, (__va_list_tag *)(& args)); __builtin_va_end((__va_list_tag *)(& args)); return; } } static char *strState[13U] = { (char *)"ST_NULL", (char *)"ST_OUT_DIAL", (char *)"ST_IN_WAIT_LL", (char *)"ST_IN_ALERT_SENT", (char *)"ST_IN_WAIT_CONN_ACK", (char *)"ST_WAIT_BCONN", (char *)"ST_ACTIVE", (char *)"ST_WAIT_BRELEASE", (char *)"ST_WAIT_BREL_DISC", (char *)"ST_WAIT_DCOMMAND", (char *)"ST_WAIT_DRELEASE", (char *)"ST_WAIT_D_REL_CNF", (char *)"ST_IN_PROCEED_SEND"}; static char *strEvent[23U] = { (char *)"EV_DIAL", (char *)"EV_SETUP_CNF", (char *)"EV_ACCEPTB", (char *)"EV_DISCONNECT_IND", (char *)"EV_RELEASE", (char *)"EV_LEASED", (char *)"EV_LEASED_REL", (char *)"EV_SETUP_IND", (char *)"EV_ACCEPTD", (char *)"EV_SETUP_CMPL_IND", (char *)"EV_BC_EST", (char *)"EV_WRITEBUF", (char *)"EV_HANGUP", (char *)"EV_BC_REL", (char *)"EV_CINF", (char *)"EV_SUSPEND", (char *)"EV_RESUME", (char *)"EV_NOSETUP_RSP", (char *)"EV_SETUP_ERR", (char *)"EV_CONNECT_ERR", (char *)"EV_PROCEED", (char *)"EV_ALERT", (char *)"EV_REDIR"}; __inline static void HL_LL(struct Channel *chanp , int command ) { isdn_ctrl ic ; { ic.driver = (chanp->cs)->myid; ic.command = command; ic.arg = (ulong )chanp->chan; (*((chanp->cs)->iif.statcallb))(& ic); return; } } __inline static void lli_deliver_cause(struct Channel *chanp ) { isdn_ctrl ic ; { if ((unsigned long )chanp->proc == (unsigned long )((struct l3_process *)0)) { return; } else { } if ((unsigned int )(chanp->proc)->para.cause == 254U) { return; } else { } ic.driver = (chanp->cs)->myid; ic.command = 270; ic.arg = (ulong )chanp->chan; if ((chanp->cs)->protocol == 2) { sprintf((char *)(& ic.parm.num), "E%02X%02X", (int )(chanp->proc)->para.loc & 127, (int )(chanp->proc)->para.cause & 127); } else { sprintf((char *)(& ic.parm.num), "%02X%02X", (int )(chanp->proc)->para.loc & 127, (int )(chanp->proc)->para.cause & 127); } (*((chanp->cs)->iif.statcallb))(& ic); return; } } __inline static void lli_close(struct FsmInst *fi ) { struct Channel *chanp ; { chanp = (struct Channel *)fi->userdata; FsmChangeState(fi, 0); chanp->Flags = 0UL; (*((chanp->cs)->cardmsg))(chanp->cs, 744, (void *)((long )chanp->chan)); return; } } static void lli_leased_in(struct FsmInst *fi , int event , void *arg ) { struct Channel *chanp ; isdn_ctrl ic ; int ret ; { chanp = (struct Channel *)fi->userdata; if (chanp->leased == 0) { return; } else { } (*((chanp->cs)->cardmsg))(chanp->cs, 736, (void *)((long )chanp->chan)); FsmChangeState(fi, 2); if (chanp->debug & 1) { link_debug(chanp, 0, (char *)"STAT_ICALL_LEASED"); } else { } ic.driver = (chanp->cs)->myid; ic.command = chanp->chan <= 1 ? 257 : 271; ic.arg = (ulong )chanp->chan; ic.parm.setup.si1 = 7U; ic.parm.setup.si2 = 0U; ic.parm.setup.plan = 0U; ic.parm.setup.screen = 0U; sprintf((char *)(& ic.parm.setup.eazmsn), "%d", chanp->chan + 1); sprintf((char *)(& ic.parm.setup.phone), "LEASED%d", (chanp->cs)->myid); ret = (*((chanp->cs)->iif.statcallb))(& ic); if (chanp->debug & 1) { link_debug(chanp, 1, (char *)"statcallb ret=%d", ret); } else { } if (ret == 0) { (*((chanp->cs)->cardmsg))(chanp->cs, 744, (void *)((long )chanp->chan)); FsmChangeState(fi, 0); } else { } return; } } static void lli_init_bchan_out(struct FsmInst *fi , int event , void *arg ) { struct Channel *chanp ; { chanp = (struct Channel *)fi->userdata; FsmChangeState(fi, 5); if (chanp->debug & 1) { link_debug(chanp, 0, (char *)"STAT_DCONN"); } else { } HL_LL(chanp, 260); init_b_st(chanp, 0); (*((chanp->b_st)->lli.l4l3))(chanp->b_st, 512, 0); return; } } static void lli_prep_dialout(struct FsmInst *fi , int event , void *arg ) { struct Channel *chanp ; { chanp = (struct Channel *)fi->userdata; FsmDelTimer(& chanp->drel_timer, 60); FsmDelTimer(& chanp->dial_timer, 73); chanp->l2_active_protocol = chanp->l2_protocol; chanp->incoming = 0; (*((chanp->cs)->cardmsg))(chanp->cs, 736, (void *)((long )chanp->chan)); if (chanp->leased != 0) { lli_init_bchan_out(fi, event, arg); } else { FsmChangeState(fi, 1); (*((chanp->d_st)->lli.l4l3))(chanp->d_st, 768, (void *)chanp); } return; } } static void lli_resume(struct FsmInst *fi , int event , void *arg ) { struct Channel *chanp ; { chanp = (struct Channel *)fi->userdata; FsmDelTimer(& chanp->drel_timer, 60); FsmDelTimer(& chanp->dial_timer, 73); chanp->l2_active_protocol = chanp->l2_protocol; chanp->incoming = 0; (*((chanp->cs)->cardmsg))(chanp->cs, 736, (void *)((long )chanp->chan)); if (chanp->leased != 0) { lli_init_bchan_out(fi, event, arg); } else { FsmChangeState(fi, 1); (*((chanp->d_st)->lli.l4l3))(chanp->d_st, 772, (void *)chanp); } return; } } static void lli_go_active(struct FsmInst *fi , int event , void *arg ) { struct Channel *chanp ; isdn_ctrl ic ; { chanp = (struct Channel *)fi->userdata; FsmChangeState(fi, 6); chanp->data_open = 1; if ((unsigned long )(chanp->bcs)->conmsg != (unsigned long )((u_char *)0)) { strcpy((char *)(& ic.parm.num), (char const *)(chanp->bcs)->conmsg); } else { ic.parm.num[0] = 0U; } if (chanp->debug & 1) { link_debug(chanp, 0, (char *)"STAT_BCONN %s", (u_char *)(& ic.parm.num)); } else { } ic.driver = (chanp->cs)->myid; ic.command = 261; ic.arg = (ulong )chanp->chan; (*((chanp->cs)->iif.statcallb))(& ic); (*((chanp->cs)->cardmsg))(chanp->cs, 740, (void *)((long )chanp->chan)); return; } } static void lli_deliver_call(struct FsmInst *fi , int event , void *arg ) { struct Channel *chanp ; isdn_ctrl ic ; int ret ; size_t __len ; void *__ret ; size_t __len___0 ; void *__ret___0 ; { chanp = (struct Channel *)fi->userdata; (*((chanp->cs)->cardmsg))(chanp->cs, 736, (void *)((long )chanp->chan)); FsmChangeState(fi, 2); if (chanp->debug & 1) { link_debug(chanp, 0, chanp->chan <= 1 ? (char *)"STAT_ICALL" : (char *)"STAT_ICALLW"); } else { } ic.driver = (chanp->cs)->myid; ic.command = chanp->chan <= 1 ? 257 : 271; ic.arg = (ulong )chanp->chan; __len = 68UL; if (__len > 63UL) { __ret = memcpy((void *)(& ic.parm.setup), (void const *)(& (chanp->proc)->para.setup), __len); } else { __ret = memcpy((void *)(& ic.parm.setup), (void const *)(& (chanp->proc)->para.setup), __len); } ret = (*((chanp->cs)->iif.statcallb))(& ic); if (chanp->debug & 1) { link_debug(chanp, 1, (char *)"statcallb ret=%d", ret); } else { } switch (ret) { case 1: FsmDelTimer(& chanp->drel_timer, 61); FsmChangeState(fi, 3); (*((chanp->d_st)->lli.l4l3))(chanp->d_st, 836, (void *)chanp->proc); goto ldv_41846; case 5: ; case 4: FsmDelTimer(& chanp->drel_timer, 61); FsmChangeState(fi, 12); (*((chanp->d_st)->lli.l4l3))(chanp->d_st, 884, (void *)chanp->proc); if (ret == 5) { __len___0 = 68UL; if (__len___0 > 63UL) { __ret___0 = memcpy((void *)(& chanp->setup), (void const *)(& ic.parm.setup), __len___0); } else { __ret___0 = memcpy((void *)(& chanp->setup), (void const *)(& ic.parm.setup), __len___0); } (*((chanp->d_st)->lli.l4l3))(chanp->d_st, 888, (void *)chanp->proc); } else { } goto ldv_41846; case 2: ; goto ldv_41846; case 3: FsmDelTimer(& chanp->drel_timer, 61); (*((chanp->d_st)->lli.l4l3))(chanp->d_st, 784, (void *)chanp->proc); goto ldv_41846; case 0: ; default: (*((chanp->d_st)->lli.l4l3))(chanp->d_st, 800, (void *)chanp->proc); (*((chanp->cs)->cardmsg))(chanp->cs, 744, (void *)((long )chanp->chan)); FsmChangeState(fi, 0); goto ldv_41846; } ldv_41846: ; return; } } static void lli_send_dconnect(struct FsmInst *fi , int event , void *arg ) { struct Channel *chanp ; { chanp = (struct Channel *)fi->userdata; FsmChangeState(fi, 4); (*((chanp->d_st)->lli.l4l3))(chanp->d_st, 771, (void *)chanp->proc); return; } } static void lli_send_alert(struct FsmInst *fi , int event , void *arg ) { struct Channel *chanp ; { chanp = (struct Channel *)fi->userdata; FsmChangeState(fi, 3); (*((chanp->d_st)->lli.l4l3))(chanp->d_st, 836, (void *)chanp->proc); return; } } static void lli_send_redir(struct FsmInst *fi , int event , void *arg ) { struct Channel *chanp ; { chanp = (struct Channel *)fi->userdata; (*((chanp->d_st)->lli.l4l3))(chanp->d_st, 888, (void *)chanp->proc); return; } } static void lli_init_bchan_in(struct FsmInst *fi , int event , void *arg ) { struct Channel *chanp ; { chanp = (struct Channel *)fi->userdata; FsmChangeState(fi, 5); if (chanp->debug & 1) { link_debug(chanp, 0, (char *)"STAT_DCONN"); } else { } HL_LL(chanp, 260); chanp->l2_active_protocol = chanp->l2_protocol; chanp->incoming = 1; init_b_st(chanp, 1); (*((chanp->b_st)->lli.l4l3))(chanp->b_st, 512, 0); return; } } static void lli_setup_rsp(struct FsmInst *fi , int event , void *arg ) { struct Channel *chanp ; { chanp = (struct Channel *)fi->userdata; if (chanp->leased != 0) { lli_init_bchan_in(fi, event, arg); } else { FsmChangeState(fi, 4); (*((chanp->d_st)->lli.l4l3))(chanp->d_st, 771, (void *)chanp->proc); } return; } } static void lli_suspend(struct FsmInst *fi , int event , void *arg ) { struct Channel *chanp ; { chanp = (struct Channel *)fi->userdata; (*((chanp->d_st)->lli.l4l3))(chanp->d_st, 880, (void *)chanp->proc); return; } } static void lli_leased_hup(struct FsmInst *fi , struct Channel *chanp ) { isdn_ctrl ic ; { ic.driver = (chanp->cs)->myid; ic.command = 270; ic.arg = (ulong )chanp->chan; sprintf((char *)(& ic.parm.num), "L0010"); (*((chanp->cs)->iif.statcallb))(& ic); if (chanp->debug & 1) { link_debug(chanp, 0, (char *)"STAT_DHUP"); } else { } HL_LL(chanp, 262); lli_close(fi); return; } } static void lli_disconnect_req(struct FsmInst *fi , int event , void *arg ) { struct Channel *chanp ; { chanp = (struct Channel *)fi->userdata; if (chanp->leased != 0) { lli_leased_hup(fi, chanp); } else { FsmChangeState(fi, 10); if ((unsigned long )chanp->proc != (unsigned long )((struct l3_process *)0)) { (chanp->proc)->para.cause = 16U; } else { } (*((chanp->d_st)->lli.l4l3))(chanp->d_st, 864, (void *)chanp->proc); } return; } } static void lli_disconnect_reject(struct FsmInst *fi , int event , void *arg ) { struct Channel *chanp ; { chanp = (struct Channel *)fi->userdata; if (chanp->leased != 0) { lli_leased_hup(fi, chanp); } else { FsmChangeState(fi, 10); if ((unsigned long )chanp->proc != (unsigned long )((struct l3_process *)0)) { (chanp->proc)->para.cause = 21U; } else { } (*((chanp->d_st)->lli.l4l3))(chanp->d_st, 864, (void *)chanp->proc); } return; } } static void lli_dhup_close(struct FsmInst *fi , int event , void *arg ) { struct Channel *chanp ; { chanp = (struct Channel *)fi->userdata; if (chanp->leased != 0) { lli_leased_hup(fi, chanp); } else { if (chanp->debug & 1) { link_debug(chanp, 0, (char *)"STAT_DHUP"); } else { } lli_deliver_cause(chanp); HL_LL(chanp, 262); lli_close(fi); } return; } } static void lli_reject_req(struct FsmInst *fi , int event , void *arg ) { struct Channel *chanp ; { chanp = (struct Channel *)fi->userdata; if (chanp->leased != 0) { lli_leased_hup(fi, chanp); return; } else { } FsmRestartTimer(& chanp->drel_timer, 40, 12, 0, 63); FsmChangeState(fi, 3); (*((chanp->d_st)->lli.l4l3))(chanp->d_st, 836, (void *)chanp->proc); return; } } static void lli_disconn_bchan(struct FsmInst *fi , int event , void *arg ) { struct Channel *chanp ; { chanp = (struct Channel *)fi->userdata; chanp->data_open = 0; FsmChangeState(fi, 7); (*((chanp->b_st)->lli.l4l3))(chanp->b_st, 528, 0); return; } } static void lli_start_disc(struct FsmInst *fi , int event , void *arg ) { struct Channel *chanp ; { chanp = (struct Channel *)fi->userdata; if (chanp->leased != 0) { lli_leased_hup(fi, chanp); } else { lli_disconnect_req(fi, event, arg); } return; } } static void lli_rel_b_disc(struct FsmInst *fi , int event , void *arg ) { struct Channel *chanp ; { chanp = (struct Channel *)fi->userdata; release_b_st(chanp); lli_start_disc(fi, event, arg); return; } } static void lli_bhup_disc(struct FsmInst *fi , int event , void *arg ) { struct Channel *chanp ; { chanp = (struct Channel *)fi->userdata; if (chanp->debug & 1) { link_debug(chanp, 0, (char *)"STAT_BHUP"); } else { } HL_LL(chanp, 263); lli_rel_b_disc(fi, event, arg); return; } } static void lli_bhup_rel_b(struct FsmInst *fi , int event , void *arg ) { struct Channel *chanp ; { chanp = (struct Channel *)fi->userdata; FsmChangeState(fi, 9); chanp->data_open = 0; if (chanp->debug & 1) { link_debug(chanp, 0, (char *)"STAT_BHUP"); } else { } HL_LL(chanp, 263); release_b_st(chanp); return; } } static void lli_release_bchan(struct FsmInst *fi , int event , void *arg ) { struct Channel *chanp ; { chanp = (struct Channel *)fi->userdata; chanp->data_open = 0; FsmChangeState(fi, 8); (*((chanp->b_st)->lli.l4l3))(chanp->b_st, 528, 0); return; } } static void lli_rel_b_dhup(struct FsmInst *fi , int event , void *arg ) { struct Channel *chanp ; { chanp = (struct Channel *)fi->userdata; release_b_st(chanp); lli_dhup_close(fi, event, arg); return; } } static void lli_bhup_dhup(struct FsmInst *fi , int event , void *arg ) { struct Channel *chanp ; { chanp = (struct Channel *)fi->userdata; if (chanp->debug & 1) { link_debug(chanp, 0, (char *)"STAT_BHUP"); } else { } HL_LL(chanp, 263); lli_rel_b_dhup(fi, event, arg); return; } } static void lli_abort(struct FsmInst *fi , int event , void *arg ) { struct Channel *chanp ; { chanp = (struct Channel *)fi->userdata; chanp->data_open = 0; (*((chanp->b_st)->lli.l4l3))(chanp->b_st, 528, 0); lli_bhup_dhup(fi, event, arg); return; } } static void lli_release_req(struct FsmInst *fi , int event , void *arg ) { struct Channel *chanp ; { chanp = (struct Channel *)fi->userdata; if (chanp->leased != 0) { lli_leased_hup(fi, chanp); } else { FsmChangeState(fi, 11); (*((chanp->d_st)->lli.l4l3))(chanp->d_st, 872, (void *)chanp->proc); } return; } } static void lli_rel_b_release_req(struct FsmInst *fi , int event , void *arg ) { struct Channel *chanp ; { chanp = (struct Channel *)fi->userdata; release_b_st(chanp); lli_release_req(fi, event, arg); return; } } static void lli_bhup_release_req(struct FsmInst *fi , int event , void *arg ) { struct Channel *chanp ; { chanp = (struct Channel *)fi->userdata; if (chanp->debug & 1) { link_debug(chanp, 0, (char *)"STAT_BHUP"); } else { } HL_LL(chanp, 263); lli_rel_b_release_req(fi, event, arg); return; } } static void lli_charge_info(struct FsmInst *fi , int event , void *arg ) { struct Channel *chanp ; isdn_ctrl ic ; { chanp = (struct Channel *)fi->userdata; ic.driver = (chanp->cs)->myid; ic.command = 264; ic.arg = (ulong )chanp->chan; sprintf((char *)(& ic.parm.num), "%d", (chanp->proc)->para.chargeinfo); (*((chanp->cs)->iif.statcallb))(& ic); return; } } static void lli_dchan_not_ready(struct FsmInst *fi , int event , void *arg ) { struct Channel *chanp ; { chanp = (struct Channel *)fi->userdata; if (chanp->debug & 1) { link_debug(chanp, 0, (char *)"STAT_DHUP"); } else { } HL_LL(chanp, 262); return; } } static void lli_no_setup_rsp(struct FsmInst *fi , int event , void *arg ) { struct Channel *chanp ; { chanp = (struct Channel *)fi->userdata; if (chanp->debug & 1) { link_debug(chanp, 0, (char *)"STAT_DHUP"); } else { } HL_LL(chanp, 262); lli_close(fi); return; } } static void lli_error(struct FsmInst *fi , int event , void *arg ) { { FsmChangeState(fi, 10); return; } } static void lli_failure_l(struct FsmInst *fi , int event , void *arg ) { struct Channel *chanp ; isdn_ctrl ic ; { chanp = (struct Channel *)fi->userdata; FsmChangeState(fi, 0); ic.driver = (chanp->cs)->myid; ic.command = 270; ic.arg = (ulong )chanp->chan; sprintf((char *)(& ic.parm.num), "L%02X%02X", 0, 47); (*((chanp->cs)->iif.statcallb))(& ic); HL_LL(chanp, 262); chanp->Flags = 0UL; (*((chanp->cs)->cardmsg))(chanp->cs, 744, (void *)((long )chanp->chan)); return; } } static void lli_rel_b_fail(struct FsmInst *fi , int event , void *arg ) { struct Channel *chanp ; { chanp = (struct Channel *)fi->userdata; release_b_st(chanp); lli_failure_l(fi, event, arg); return; } } static void lli_bhup_fail(struct FsmInst *fi , int event , void *arg ) { struct Channel *chanp ; { chanp = (struct Channel *)fi->userdata; if (chanp->debug & 1) { link_debug(chanp, 0, (char *)"STAT_BHUP"); } else { } HL_LL(chanp, 263); lli_rel_b_fail(fi, event, arg); return; } } static void lli_failure_a(struct FsmInst *fi , int event , void *arg ) { struct Channel *chanp ; { chanp = (struct Channel *)fi->userdata; chanp->data_open = 0; (*((chanp->b_st)->lli.l4l3))(chanp->b_st, 528, 0); lli_bhup_fail(fi, event, arg); return; } } static struct FsmNode fnlist[62U] = { {0, 0, & lli_prep_dialout}, {0, 16, & lli_resume}, {0, 7, & lli_deliver_call}, {0, 5, & lli_leased_in}, {1, 1, & lli_init_bchan_out}, {1, 12, & lli_disconnect_req}, {1, 3, & lli_release_req}, {1, 4, & lli_dhup_close}, {1, 17, & lli_no_setup_rsp}, {1, 18, & lli_error}, {2, 6, & lli_failure_l}, {2, 8, & lli_setup_rsp}, {2, 12, & lli_reject_req}, {2, 3, & lli_release_req}, {2, 4, & lli_dhup_close}, {2, 7, & lli_deliver_call}, {2, 18, & lli_error}, {3, 9, & lli_init_bchan_in}, {3, 8, & lli_send_dconnect}, {3, 12, & lli_disconnect_reject}, {3, 3, & lli_release_req}, {3, 4, & lli_dhup_close}, {3, 22, & lli_send_redir}, {12, 22, & lli_send_redir}, {12, 21, & lli_send_alert}, {12, 8, & lli_send_dconnect}, {12, 12, & lli_disconnect_reject}, {12, 3, & lli_dhup_close}, {3, 4, & lli_dhup_close}, {4, 9, & lli_init_bchan_in}, {4, 12, & lli_disconnect_req}, {4, 3, & lli_release_req}, {4, 4, & lli_dhup_close}, {4, 19, & lli_error}, {5, 10, & lli_go_active}, {5, 13, & lli_rel_b_disc}, {5, 12, & lli_rel_b_disc}, {5, 3, & lli_rel_b_release_req}, {5, 4, & lli_rel_b_dhup}, {5, 6, & lli_rel_b_fail}, {5, 14, & lli_charge_info}, {6, 14, & lli_charge_info}, {6, 13, & lli_bhup_rel_b}, {6, 15, & lli_suspend}, {6, 12, & lli_disconn_bchan}, {6, 3, & lli_release_bchan}, {6, 4, & lli_abort}, {6, 6, & lli_failure_a}, {7, 13, & lli_bhup_disc}, {7, 3, & lli_bhup_release_req}, {7, 4, & lli_bhup_dhup}, {7, 6, & lli_bhup_fail}, {8, 13, & lli_bhup_release_req}, {8, 4, & lli_bhup_dhup}, {9, 12, & lli_start_disc}, {9, 3, & lli_release_req}, {9, 4, & lli_dhup_close}, {9, 6, & lli_failure_l}, {10, 4, & lli_dhup_close}, {10, 0, & lli_dchan_not_ready}, {11, 4, & lli_dhup_close}, {11, 0, & lli_dchan_not_ready}}; int CallcNew(void) { int tmp ; { callcfsm.state_count = 13; callcfsm.event_count = 23; callcfsm.strEvent = (char **)(& strEvent); callcfsm.strState = (char **)(& strState); tmp = FsmNew(& callcfsm, (struct FsmNode *)(& fnlist), 62); return (tmp); } } void CallcFree(void) { { FsmFree(& callcfsm); return; } } static void release_b_st(struct Channel *chanp ) { struct PStack *st ; int tmp ; { st = chanp->b_st; tmp = test_and_clear_bit(0, (unsigned long volatile *)(& chanp->Flags)); if (tmp != 0) { (*((chanp->bcs)->BC_Close))(chanp->bcs); switch (chanp->l2_active_protocol) { case 0: releasestack_isdnl2(st); goto ldv_42056; case 3: ; case 12: ; case 4: ; case 10: ; case 11: releasestack_transl2(st); goto ldv_42056; } ldv_42056: ; } else { } return; } } static struct Channel *selectfreechannel(struct PStack *st , int bch ) { struct IsdnCardState *cs ; struct Channel *chanp ; int i ; int tmp ; { cs = (struct IsdnCardState *)st->l1.hardware; chanp = (struct Channel *)st->lli.userdata; tmp = constant_test_bit(4U, (unsigned long const volatile *)(& cs->HW_Flags)); if (tmp != 0) { i = 1; } else { i = 0; } if (bch == 0) { i = 2; chanp = chanp + 2UL; } else { } goto ldv_42070; ldv_42069: ; if (chanp->fi.state == 0) { return (chanp); } else { } chanp = chanp + 1; i = i + 1; ldv_42070: ; if ((bch != 0 ? cs->chanlimit : 4) > i) { goto ldv_42069; } else { } if (bch != 0) { i = 2; chanp = (struct Channel *)st->lli.userdata; chanp = chanp + (unsigned long )i; goto ldv_42073; ldv_42072: ; if (chanp->fi.state == 0) { return (chanp); } else { } chanp = chanp + 1; i = i + 1; ldv_42073: ; if (i <= 3) { goto ldv_42072; } else { } } else { } return (0); } } static void stat_redir_result(struct IsdnCardState *cs , int chan , ulong result ) { isdn_ctrl ic ; { ic.driver = cs->myid; ic.command = 272; ic.arg = (ulong )chan; ic.parm.num[0] = (u_char )result; (*(cs->iif.statcallb))(& ic); return; } } static void dchan_l3l4(struct PStack *st , int pr , void *arg ) { struct l3_process *pc ; struct IsdnCardState *cs ; struct Channel *chanp ; { pc = (struct l3_process *)arg; cs = (struct IsdnCardState *)st->l1.hardware; if ((unsigned long )pc == (unsigned long )((struct l3_process *)0)) { return; } else { } if (pr == 770) { chanp = selectfreechannel(pc->st, pc->para.bchannel); if ((unsigned long )chanp == (unsigned long )((struct Channel *)0)) { pc->para.cause = 17U; (*((pc->st)->lli.l4l3))(pc->st, 804, (void *)pc); } else { chanp->proc = pc; pc->chan = chanp; FsmEvent(& chanp->fi, 7, 0); } return; } else { } chanp = pc->chan; if ((unsigned long )chanp == (unsigned long )((struct Channel *)0)) { return; } else { } switch (pr) { case 786: FsmEvent(& chanp->fi, 7, 0); goto ldv_42090; case 866: FsmEvent(& chanp->fi, 3, 0); goto ldv_42090; case 873: FsmEvent(& chanp->fi, 4, 0); goto ldv_42090; case 881: FsmEvent(& chanp->fi, 4, 0); goto ldv_42090; case 773: FsmEvent(& chanp->fi, 1, 0); goto ldv_42090; case 995: FsmEvent(& chanp->fi, 4, 0); goto ldv_42090; case 874: FsmEvent(& chanp->fi, 4, 0); goto ldv_42090; case 818: FsmEvent(& chanp->fi, 9, 0); goto ldv_42090; case 769: FsmEvent(& chanp->fi, 1, 0); goto ldv_42090; case 854: FsmEvent(& chanp->fi, 14, 0); goto ldv_42090; case 992: FsmEvent(& chanp->fi, 17, 0); goto ldv_42090; case 993: FsmEvent(& chanp->fi, 18, 0); goto ldv_42090; case 996: FsmEvent(& chanp->fi, 19, 0); goto ldv_42090; case 997: FsmEvent(& chanp->fi, 4, 0); goto ldv_42090; case 886: ; case 834: ; case 838: ; case 842: ; case 858: ; goto ldv_42090; case 890: stat_redir_result(cs, chanp->chan, pc->redir_result); goto ldv_42090; default: ; if ((chanp->debug & 2048) != 0) { HiSax_putstatus(chanp->cs, (char *)"Ch", (char *)"%d L3->L4 unknown primitiv %#x", chanp->chan, pr); } else { } } ldv_42090: ; return; } } static void dummy_pstack(struct PStack *st , int pr , void *arg ) { { printk("\fcall to dummy_pstack pr=%04x arg %lx\n", pr, (long )arg); return; } } static int init_PStack(struct PStack **stp ) { void *tmp ; { tmp = kmalloc(1688UL, 32U); *stp = (struct PStack *)tmp; if ((unsigned long )*stp == (unsigned long )((struct PStack *)0)) { return (-12); } else { } (*stp)->next = 0; (*stp)->l1.l1l2 = & dummy_pstack; (*stp)->l1.l1hw = & dummy_pstack; (*stp)->l1.l1tei = & dummy_pstack; (*stp)->l2.l2tei = & dummy_pstack; (*stp)->l2.l2l1 = & dummy_pstack; (*stp)->l2.l2l3 = & dummy_pstack; (*stp)->l3.l3l2 = & dummy_pstack; (*stp)->l3.l3ml3 = & dummy_pstack; (*stp)->l3.l3l4 = & dummy_pstack; (*stp)->lli.l4l3 = & dummy_pstack; (*stp)->ma.layer = & dummy_pstack; return (0); } } static int init_d_st(struct Channel *chanp ) { struct PStack *st ; struct IsdnCardState *cs ; char tmp[16U] ; int err ; int tmp___0 ; { cs = chanp->cs; err = init_PStack(& chanp->d_st); if (err != 0) { return (err); } else { } st = chanp->d_st; st->next = 0; HiSax_addlist(cs, st); setstack_HiSax(st, cs); st->l2.sap = 0; st->l2.tei = -1; st->l2.flag = 0UL; test_and_set_bit(3, (unsigned long volatile *)(& st->l2.flag)); test_and_set_bit(1, (unsigned long volatile *)(& st->l2.flag)); test_and_set_bit(2, (unsigned long volatile *)(& st->l2.flag)); st->l2.maxlen = 260; st->l2.window = 1U; st->l2.T200 = 1000; st->l2.N200 = 3; st->l2.T203 = 10000; tmp___0 = constant_test_bit(4U, (unsigned long const volatile *)(& cs->HW_Flags)); if (tmp___0 != 0) { sprintf((char *)(& tmp), "DCh%d Q.921 ", chanp->chan); } else { sprintf((char *)(& tmp), "DCh Q.921 "); } setstack_isdnl2(st, (char *)(& tmp)); setstack_l3dc(st, chanp); st->lli.userdata = (void *)chanp; st->l3.l3l4 = & dchan_l3l4; return (0); } } static void callc_debug(struct FsmInst *fi , char *fmt , ...) { va_list args ; struct Channel *chanp ; char tmp[16U] ; { chanp = (struct Channel *)fi->userdata; __builtin_va_start((__va_list_tag *)(& args), fmt); sprintf((char *)(& tmp), "Ch%d callc ", chanp->chan); VHiSax_putstatus(chanp->cs, (char *)(& tmp), fmt, (__va_list_tag *)(& args)); __builtin_va_end((__va_list_tag *)(& args)); return; } } static int init_chan(int chan , struct IsdnCardState *csta ) { struct Channel *chanp ; int err ; int tmp ; { chanp = (struct Channel *)(& csta->channel) + (unsigned long )chan; chanp->cs = csta; chanp->bcs = (struct BCState *)(& csta->bcs) + (unsigned long )chan; chanp->chan = chan; chanp->incoming = 0; chanp->debug = 0; chanp->Flags = 0UL; chanp->leased = 0; err = init_PStack(& chanp->b_st); if (err != 0) { return (err); } else { } (chanp->b_st)->l1.delay = 300; chanp->fi.fsm = & callcfsm; chanp->fi.state = 0; chanp->fi.debug = 0; chanp->fi.userdata = (void *)chanp; chanp->fi.printdebug = & callc_debug; FsmInitTimer(& chanp->fi, & chanp->dial_timer); FsmInitTimer(& chanp->fi, & chanp->drel_timer); if (chan == 0) { goto _L; } else { tmp = constant_test_bit(4U, (unsigned long const volatile *)(& csta->HW_Flags)); if (tmp != 0 && chan <= 1) { _L: /* CIL Label */ err = init_d_st(chanp); if (err != 0) { return (err); } else { } } else { chanp->d_st = ((struct Channel *)(& csta->channel))->d_st; } } chanp->data_open = 0; return (0); } } int CallcNewChan(struct IsdnCardState *csta ) { int i ; int err ; int tmp ; { chancount = chancount + 2; err = init_chan(0, csta); if (err != 0) { return (err); } else { } err = init_chan(1, csta); if (err != 0) { return (err); } else { } printk("\016HiSax: 2 channels added\n"); i = 0; goto ldv_42145; ldv_42144: err = init_chan(i + 2, csta); if (err != 0) { return (err); } else { } i = i + 1; ldv_42145: ; if (i <= 1) { goto ldv_42144; } else { } printk("\016HiSax: MAX_WAITING_CALLS added\n"); tmp = constant_test_bit(14U, (unsigned long const volatile *)(& (((struct Channel *)(& csta->channel))->d_st)->l2.flag)); if (tmp != 0) { printk("\016LAYER2 WATCHING ESTABLISH\n"); (*((((struct Channel *)(& csta->channel))->d_st)->lli.l4l3))(((struct Channel *)(& csta->channel))->d_st, 512, 0); } else { } return (0); } } static void release_d_st(struct Channel *chanp ) { struct PStack *st ; { st = chanp->d_st; if ((unsigned long )st == (unsigned long )((struct PStack *)0)) { return; } else { } releasestack_isdnl2(st); releasestack_isdnl3(st); HiSax_rmlist((struct IsdnCardState *)st->l1.hardware, st); kfree((void const *)st); chanp->d_st = 0; return; } } void CallcFreeChan(struct IsdnCardState *csta ) { int i ; int tmp ; int tmp___0 ; { i = 0; goto ldv_42156; ldv_42155: FsmDelTimer(& csta->channel[i].drel_timer, 74); FsmDelTimer(& csta->channel[i].dial_timer, 75); if (i != 0) { release_d_st((struct Channel *)(& csta->channel) + (unsigned long )i); } else { tmp = constant_test_bit(4U, (unsigned long const volatile *)(& csta->HW_Flags)); if (tmp != 0) { release_d_st((struct Channel *)(& csta->channel) + (unsigned long )i); } else { } } if ((unsigned long )csta->channel[i].b_st != (unsigned long )((struct PStack *)0)) { release_b_st((struct Channel *)(& csta->channel) + (unsigned long )i); kfree((void const *)csta->channel[i].b_st); csta->channel[i].b_st = 0; } else { printk("\fCallcFreeChan b_st ch%d already freed\n", i); } if (i != 0) { release_d_st((struct Channel *)(& csta->channel) + (unsigned long )i); } else { tmp___0 = constant_test_bit(4U, (unsigned long const volatile *)(& csta->HW_Flags)); if (tmp___0 != 0) { release_d_st((struct Channel *)(& csta->channel) + (unsigned long )i); } else { csta->channel[i].d_st = 0; } } i = i + 1; ldv_42156: ; if (i <= 1) { goto ldv_42155; } else { } return; } } static void lldata_handler(struct PStack *st , int pr , void *arg ) { struct Channel *chanp ; struct sk_buff *skb ; { chanp = (struct Channel *)st->lli.userdata; skb = (struct sk_buff *)arg; switch (pr) { case 546: ; if (chanp->data_open != 0) { if ((chanp->debug & 2048) != 0) { link_debug(chanp, 0, (char *)"lldata: %d", skb->len); } else { } (*((chanp->cs)->iif.rcvcallb_skb))((chanp->cs)->myid, chanp->chan, skb); } else { link_debug(chanp, 0, (char *)"lldata: channel not open"); consume_skb(skb); } goto ldv_42166; case 514: ; case 513: FsmEvent(& chanp->fi, 10, 0); goto ldv_42166; case 530: ; case 529: FsmEvent(& chanp->fi, 13, 0); goto ldv_42166; default: printk("\flldata_handler unknown primitive %#x\n", pr); goto ldv_42166; } ldv_42166: ; return; } } static void lltrans_handler(struct PStack *st , int pr , void *arg ) { struct Channel *chanp ; struct sk_buff *skb ; { chanp = (struct Channel *)st->lli.userdata; skb = (struct sk_buff *)arg; switch (pr) { case 290: ; if (chanp->data_open != 0) { if ((chanp->debug & 2048) != 0) { link_debug(chanp, 0, (char *)"lltrans: %d", skb->len); } else { } (*((chanp->cs)->iif.rcvcallb_skb))((chanp->cs)->myid, chanp->chan, skb); } else { link_debug(chanp, 0, (char *)"lltrans: channel not open"); consume_skb(skb); } goto ldv_42180; case 258: ; case 257: FsmEvent(& chanp->fi, 10, 0); goto ldv_42180; case 274: ; case 273: FsmEvent(& chanp->fi, 13, 0); goto ldv_42180; default: printk("\flltrans_handler unknown primitive %#x\n", pr); goto ldv_42180; } ldv_42180: ; return; } } void lli_writewakeup(struct PStack *st , int len ) { struct Channel *chanp ; isdn_ctrl ic ; { chanp = (struct Channel *)st->lli.userdata; if ((chanp->debug & 2048) != 0) { link_debug(chanp, 0, (char *)"llwakeup: %d", len); } else { } ic.driver = (chanp->cs)->myid; ic.command = 267; ic.arg = (ulong )chanp->chan; ic.parm.length = len; (*((chanp->cs)->iif.statcallb))(& ic); return; } } static int init_b_st(struct Channel *chanp , int incoming ) { struct PStack *st ; struct IsdnCardState *cs ; char tmp[16U] ; int tmp___0 ; { st = chanp->b_st; cs = chanp->cs; st->l1.hardware = (void *)cs; if (chanp->leased != 0) { st->l1.bc = chanp->chan & 1; } else { st->l1.bc = (chanp->proc)->para.bchannel + -1; } switch (chanp->l2_active_protocol) { case 0: ; case 3: st->l1.mode = 2; goto ldv_42201; case 12: st->l1.mode = 4; goto ldv_42201; case 4: st->l1.mode = 1; goto ldv_42201; case 10: st->l1.mode = 8; goto ldv_42201; case 11: st->l1.mode = 9; goto ldv_42201; } ldv_42201: (chanp->bcs)->conmsg = 0; tmp___0 = (*((chanp->bcs)->BC_SetStack))(st, chanp->bcs); if (tmp___0 != 0) { return (-1); } else { } st->l2.flag = 0UL; test_and_set_bit(0, (unsigned long volatile *)(& st->l2.flag)); st->l2.maxlen = 4092; if (incoming == 0) { test_and_set_bit(2, (unsigned long volatile *)(& st->l2.flag)); } else { } st->l2.T200 = 1000; st->l2.window = 7U; st->l2.N200 = 4; st->l2.T203 = 5000; st->l3.debug = 0; switch (chanp->l2_active_protocol) { case 0: sprintf((char *)(& tmp), "Ch%d X.75", chanp->chan); setstack_isdnl2(st, (char *)(& tmp)); setstack_l3bc(st, chanp); st->l2.l2l3 = & lldata_handler; st->lli.userdata = (void *)chanp; test_and_clear_bit(1, (unsigned long volatile *)(& st->lli.flag)); test_and_set_bit(2, (unsigned long volatile *)(& st->lli.flag)); st->l2.l2m.debug = chanp->debug & 16; st->l2.debug = chanp->debug & 64; goto ldv_42207; case 3: ; case 12: ; case 4: ; case 10: ; case 11: st->l1.l1l2 = & lltrans_handler; st->lli.userdata = (void *)chanp; test_and_set_bit(1, (unsigned long volatile *)(& st->lli.flag)); test_and_clear_bit(2, (unsigned long volatile *)(& st->lli.flag)); setstack_transl2(st); setstack_l3bc(st, chanp); goto ldv_42207; } ldv_42207: test_and_set_bit(0, (unsigned long volatile *)(& chanp->Flags)); return (0); } } static void leased_l4l3(struct PStack *st , int pr , void *arg ) { struct Channel *chanp ; struct sk_buff *skb ; { chanp = (struct Channel *)st->lli.userdata; skb = (struct sk_buff *)arg; switch (pr) { case 544: link_debug(chanp, 0, (char *)"leased line d-channel DATA"); consume_skb(skb); goto ldv_42221; case 512: (*(st->l2.l2l1))(st, 256, 0); goto ldv_42221; case 528: ; goto ldv_42221; default: printk("\ftransd_l4l3 unknown primitive %#x\n", pr); goto ldv_42221; } ldv_42221: ; return; } } static void leased_l1l2(struct PStack *st , int pr , void *arg ) { struct Channel *chanp ; struct sk_buff *skb ; int i ; int event ; int tmp ; { chanp = (struct Channel *)st->lli.userdata; skb = (struct sk_buff *)arg; event = 6; switch (pr) { case 290: link_debug(chanp, 0, (char *)"leased line d-channel DATA"); consume_skb(skb); goto ldv_42235; case 258: ; case 257: event = 5; case 274: ; case 273: tmp = constant_test_bit(4U, (unsigned long const volatile *)(& (chanp->cs)->HW_Flags)); if (tmp != 0) { i = 1; } else { i = 0; } goto ldv_42241; ldv_42240: FsmEvent(& chanp->fi, event, 0); chanp = chanp + 1; i = i + 1; ldv_42241: ; if (i <= 1) { goto ldv_42240; } else { } goto ldv_42235; default: printk("\ftransd_l1l2 unknown primitive %#x\n", pr); goto ldv_42235; } ldv_42235: ; return; } } static void distr_debug(struct IsdnCardState *csta , int debugflags ) { int i ; struct Channel *chanp ; { chanp = (struct Channel *)(& csta->channel); i = 0; goto ldv_42251; ldv_42250: (chanp + (unsigned long )i)->debug = debugflags; (chanp + (unsigned long )i)->fi.debug = debugflags & 2; ((chanp + (unsigned long )i)->d_st)->l2.l2m.debug = debugflags & 8; ((chanp + (unsigned long )i)->b_st)->l2.l2m.debug = debugflags & 16; ((chanp + (unsigned long )i)->d_st)->l2.debug = debugflags & 32; ((chanp + (unsigned long )i)->b_st)->l2.debug = debugflags & 64; ((chanp + (unsigned long )i)->d_st)->l3.l3m.debug = debugflags & 128; ((chanp + (unsigned long )i)->b_st)->l3.l3m.debug = debugflags & 256; ((chanp + (unsigned long )i)->b_st)->ma.tei_m.debug = debugflags & 512; ((chanp + (unsigned long )i)->b_st)->ma.debug = debugflags & 512; ((chanp + (unsigned long )i)->d_st)->l1.l1m.debug = debugflags & 4096; ((chanp + (unsigned long )i)->b_st)->l1.l1m.debug = debugflags & 8192; i = i + 1; ldv_42251: ; if (i <= 3) { goto ldv_42250; } else { } if ((debugflags & 4) != 0) { csta->debug = csta->debug | 1024; } else { csta->debug = csta->debug & -1025; } return; } } static char tmpbuf___0[256U] ; static void capi_debug(struct Channel *chanp , capi_msg *cm ) { char *t ; int tmp ; { t = (char *)(& tmpbuf___0); tmp = QuickHex(t, (u_char *)cm, (unsigned int )cm->Length <= 50U ? (int )cm->Length : 50); t = t + (unsigned long )tmp; t = t - 1; *t = 0; HiSax_putstatus(chanp->cs, (char *)"Ch", (char *)"%d CAPIMSG %s", chanp->chan, (char *)(& tmpbuf___0)); return; } } static void lli_got_fac_req(struct Channel *chanp , capi_msg *cm ) { { if ((unsigned int )cm->para[0] != 3U || (unsigned int )cm->para[1] != 0U) { return; } else { } if ((unsigned int )cm->para[2] <= 2U) { return; } else { } if ((unsigned int )cm->para[4] != 0U) { return; } else { } switch ((int )cm->para[3]) { case 4: strncpy((char *)(& chanp->setup.phone), (char const *)(& cm->para) + 5U, (__kernel_size_t )((int )cm->para[5] + 1)); FsmEvent(& chanp->fi, 15, (void *)cm); goto ldv_42264; case 5: strncpy((char *)(& chanp->setup.phone), (char const *)(& cm->para) + 5U, (__kernel_size_t )((int )cm->para[5] + 1)); if (chanp->fi.state == 0) { FsmEvent(& chanp->fi, 16, (void *)cm); } else { FsmDelTimer(& chanp->dial_timer, 72); FsmAddTimer(& chanp->dial_timer, 80, 16, (void *)cm, 73); } goto ldv_42264; } ldv_42264: ; return; } } static void lli_got_manufacturer(struct Channel *chanp , struct IsdnCardState *cs , capi_msg *cm ) { { if (((unsigned int )cs->typ == 6U || (unsigned int )cs->typ == 7U) || (unsigned int )cs->typ == 18U) { if (cs->hw.elsa.MFlag != 0U) { (*(cs->cardmsg))(cs, 245, (void *)(& cm->para)); } else { } } else { } return; } } static int set_channel_limit(struct IsdnCardState *cs , int chanmax ) { isdn_ctrl ic ; int i ; int ii ; { if (chanmax < 0 || chanmax > 2) { return (-22); } else { } cs->chanlimit = 0; ii = 0; goto ldv_42279; ldv_42278: ic.driver = cs->myid; ic.command = 278; ic.arg = (ulong )ii; if (ii >= chanmax) { ic.parm.num[0] = 0U; } else { ic.parm.num[0] = 1U; } i = (*(cs->iif.statcallb))(& ic); if (i != 0) { return (-22); } else { } if (ii < chanmax) { cs->chanlimit = cs->chanlimit + 1; } else { } ii = ii + 1; ldv_42279: ; if (ii <= 1) { goto ldv_42278; } else { } return (0); } } int HiSax_command(isdn_ctrl *ic ) { struct IsdnCardState *csta ; struct IsdnCardState *tmp ; struct PStack *st ; struct Channel *chanp ; int i ; u_int num ; size_t __len ; void *__ret ; int tmp___0 ; size_t __len___0 ; void *__ret___0 ; int tmp___1 ; int tmp___2 ; int tmp___3 ; size_t __len___1 ; void *__ret___1 ; int tmp___4 ; int tmp___5 ; { tmp = hisax_findcard___0(ic->driver); csta = tmp; if ((unsigned long )csta == (unsigned long )((struct IsdnCardState *)0)) { printk("\vHiSax: if_command %d called with invalid driverId %d!\n", ic->command, ic->driver); return (-19); } else { } switch (ic->command) { case 6: chanp = (struct Channel *)(& csta->channel) + ic->arg; goto ldv_42290; case 10: chanp = (struct Channel *)(& csta->channel) + (ic->arg & 255UL); if (chanp->debug & 1) { link_debug(chanp, 1, (char *)"SETL2 card %d %ld", csta->cardnr + 1, ic->arg >> 8); } else { } chanp->l2_protocol = (int )(ic->arg >> 8); goto ldv_42290; case 12: chanp = (struct Channel *)(& csta->channel) + (ic->arg & 255UL); if (chanp->debug & 1) { link_debug(chanp, 1, (char *)"SETL3 card %d %ld", csta->cardnr + 1, ic->arg >> 8); } else { } chanp->l3_protocol = (int )(ic->arg >> 8); goto ldv_42290; case 1: chanp = (struct Channel *)(& csta->channel) + (ic->arg & 255UL); if (chanp->debug & 1) { link_debug(chanp, 1, (char *)"DIAL %s -> %s (%d,%d)", (unsigned char *)(& ic->parm.setup.eazmsn), (unsigned char *)(& ic->parm.setup.phone), (int )ic->parm.setup.si1, (int )ic->parm.setup.si2); } else { } __len = 68UL; if (__len > 63UL) { __ret = memcpy((void *)(& chanp->setup), (void const *)(& ic->parm.setup), __len); } else { __ret = memcpy((void *)(& chanp->setup), (void const *)(& ic->parm.setup), __len); } tmp___0 = strcmp((char const *)(& chanp->setup.eazmsn), "0"); if (tmp___0 == 0) { chanp->setup.eazmsn[0] = 0U; } else { } if (chanp->fi.state == 0) { FsmEvent(& chanp->fi, 0, 0); } else { FsmDelTimer(& chanp->dial_timer, 70); FsmAddTimer(& chanp->dial_timer, 50, 0, 0, 71); } goto ldv_42290; case 3: chanp = (struct Channel *)(& csta->channel) + ic->arg; if (chanp->debug & 1) { link_debug(chanp, 1, (char *)"ACCEPTB"); } else { } FsmEvent(& chanp->fi, 2, 0); goto ldv_42290; case 2: chanp = (struct Channel *)(& csta->channel) + ic->arg; __len___0 = 68UL; if (__len___0 > 63UL) { __ret___0 = memcpy((void *)(& chanp->setup), (void const *)(& ic->parm.setup), __len___0); } else { __ret___0 = memcpy((void *)(& chanp->setup), (void const *)(& ic->parm.setup), __len___0); } if (chanp->debug & 1) { link_debug(chanp, 1, (char *)"ACCEPTD"); } else { } FsmEvent(& chanp->fi, 8, 0); goto ldv_42290; case 4: chanp = (struct Channel *)(& csta->channel) + ic->arg; if (chanp->debug & 1) { link_debug(chanp, 1, (char *)"HANGUP"); } else { } FsmEvent(& chanp->fi, 12, 0); goto ldv_42290; case 22: chanp = (struct Channel *)(& csta->channel) + ic->arg; if (chanp->debug & 1) { capi_debug(chanp, & ic->parm.cmsg); } else { } if ((unsigned int )ic->parm.cmsg.Length <= 7U) { goto ldv_42290; } else { } switch ((int )ic->parm.cmsg.Command) { case 128: ; if ((unsigned int )ic->parm.cmsg.Subcommand == 128U) { lli_got_fac_req(chanp, & ic->parm.cmsg); } else { } goto ldv_42305; case 255: ; if ((unsigned int )ic->parm.cmsg.Subcommand == 128U) { lli_got_manufacturer(chanp, csta, & ic->parm.cmsg); } else { } goto ldv_42305; default: ; goto ldv_42305; } ldv_42305: ; goto ldv_42290; case 0: ; switch (ic->arg) { case 0UL: num = *((unsigned int *)(& ic->parm.num)); HiSax_reportcard(csta->cardnr, (int )num); goto ldv_42310; case 1UL: num = *((unsigned int *)(& ic->parm.num)); distr_debug(csta, (int )num); printk("\017HiSax: debugging flags card %d set to %x\n", csta->cardnr + 1, num); HiSax_putstatus(csta, (char *)"debugging flags ", (char *)"card %d set to %x", csta->cardnr + 1, num); goto ldv_42310; case 2UL: num = *((unsigned int *)(& ic->parm.num)); (csta->channel[0].b_st)->l1.delay = (int )num; (csta->channel[1].b_st)->l1.delay = (int )num; HiSax_putstatus(csta, (char *)"delay ", (char *)"card %d set to %d ms", csta->cardnr + 1, num); printk("\017HiSax: delay card %d set to %d ms\n", csta->cardnr + 1, num); goto ldv_42310; case 5UL: num = *((unsigned int *)(& ic->parm.num)); if (num == 0U || num > 2U) { HiSax_putstatus(csta, (char *)"Set LEASED ", (char *)"wrong channel %d", num); printk("\fHiSax: Set LEASED wrong channel %d\n", num); } else { num = num - 1U; chanp = (struct Channel *)(& csta->channel) + (unsigned long )num; chanp->leased = 1; HiSax_putstatus(csta, (char *)"Card", (char *)"%d channel %d set leased mode\n", csta->cardnr + 1, num + 1U); (chanp->d_st)->l1.l1l2 = & leased_l1l2; (chanp->d_st)->lli.l4l3 = & leased_l4l3; (*((chanp->d_st)->lli.l4l3))(chanp->d_st, 512, 0); } goto ldv_42310; case 6UL: num = *((unsigned int *)(& ic->parm.num)); if ((unsigned long )csta->stlist != (unsigned long )((struct PStack *)0)) { (*((csta->stlist)->l2.l2l1))(csta->stlist, 320, (void *)((long )num)); } else { } goto ldv_42310; case 7UL: num = *((unsigned int *)(& ic->parm.num)); tmp___1 = constant_test_bit(4U, (unsigned long const volatile *)(& csta->HW_Flags)); if (tmp___1 != 0) { printk("\vHiSax PTP mode only with one TEI possible\n"); } else if (num != 0U) { test_and_set_bit(14, (unsigned long volatile *)(& (csta->channel[0].d_st)->l2.flag)); test_and_set_bit(15, (unsigned long volatile *)(& (csta->channel[0].d_st)->l2.flag)); (csta->channel[0].d_st)->l2.tei = 0; HiSax_putstatus(csta, (char *)"set card ", (char *)"in PTP mode"); printk("\017HiSax: set card in PTP mode\n"); printk("\016LAYER2 WATCHING ESTABLISH\n"); (*((csta->channel[0].d_st)->lli.l4l3))(csta->channel[0].d_st, 512, 0); } else { test_and_clear_bit(14, (unsigned long volatile *)(& (csta->channel[0].d_st)->l2.flag)); test_and_clear_bit(15, (unsigned long volatile *)(& (csta->channel[0].d_st)->l2.flag)); HiSax_putstatus(csta, (char *)"set card ", (char *)"in PTMP mode"); printk("\017HiSax: set card in PTMP mode\n"); } goto ldv_42310; case 8UL: num = *((unsigned int *)(& ic->parm.num)); chanp = (struct Channel *)(& csta->channel) + ((unsigned long )num & 1UL); num = num >> 1; if (num == 127U) { test_and_clear_bit(15, (unsigned long volatile *)(& (chanp->d_st)->l2.flag)); (chanp->d_st)->l2.tei = -1; HiSax_putstatus(csta, (char *)"set card ", (char *)"in VAR TEI mode"); printk("\017HiSax: set card in VAR TEI mode\n"); } else { test_and_set_bit(15, (unsigned long volatile *)(& (chanp->d_st)->l2.flag)); (chanp->d_st)->l2.tei = (int )num; HiSax_putstatus(csta, (char *)"set card ", (char *)"in FIXED TEI (%d) mode", num); printk("\017HiSax: set card in FIXED TEI (%d) mode\n", num); } (*((chanp->d_st)->lli.l4l3))(chanp->d_st, 512, 0); goto ldv_42310; case 11UL: num = (u_int )csta->debug & 1024U; csta->debug = (int )*((unsigned int *)(& ic->parm.num)); csta->debug = (int )((u_int )csta->debug | num); HiSax_putstatus(cards[0].cs, (char *)"l1 debugging ", (char *)"flags card %d set to %x", csta->cardnr + 1, csta->debug); printk("\017HiSax: l1 debugging flags card %d set to %x\n", csta->cardnr + 1, csta->debug); goto ldv_42310; case 13UL: (csta->channel[0].d_st)->l3.debug = (int )*((unsigned int *)(& ic->parm.num)); (csta->channel[1].d_st)->l3.debug = (int )*((unsigned int *)(& ic->parm.num)); HiSax_putstatus(cards[0].cs, (char *)"l3 debugging ", (char *)"flags card %d set to %x\n", csta->cardnr + 1, *((unsigned int *)(& ic->parm.num))); printk("\017HiSax: l3 debugging flags card %d set to %x\n", csta->cardnr + 1, *((unsigned int *)(& ic->parm.num))); goto ldv_42310; case 10UL: i = (int )*((unsigned int *)(& ic->parm.num)); tmp___2 = set_channel_limit(csta, i); return (tmp___2); default: ; if ((unsigned long )csta->auxcmd != (unsigned long )((int (*)(struct IsdnCardState * , isdn_ctrl * ))0)) { tmp___3 = (*(csta->auxcmd))(csta, ic); return (tmp___3); } else { } printk("\017HiSax: invalid ioctl %d\n", (int )ic->arg); return (-22); } ldv_42310: ; goto ldv_42290; case 18: chanp = (struct Channel *)(& csta->channel) + ic->arg; if (chanp->debug & 1) { link_debug(chanp, 1, (char *)"PROCEED"); } else { } FsmEvent(& chanp->fi, 20, 0); goto ldv_42290; case 19: chanp = (struct Channel *)(& csta->channel) + ic->arg; if (chanp->debug & 1) { link_debug(chanp, 1, (char *)"ALERT"); } else { } FsmEvent(& chanp->fi, 21, 0); goto ldv_42290; case 20: chanp = (struct Channel *)(& csta->channel) + ic->arg; if (chanp->debug & 1) { link_debug(chanp, 1, (char *)"REDIR"); } else { } __len___1 = 68UL; if (__len___1 > 63UL) { __ret___1 = memcpy((void *)(& chanp->setup), (void const *)(& ic->parm.setup), __len___1); } else { __ret___1 = memcpy((void *)(& chanp->setup), (void const *)(& ic->parm.setup), __len___1); } FsmEvent(& chanp->fi, 22, 0); goto ldv_42290; case 21: st = csta->stlist; goto ldv_42329; ldv_42328: ; if ((ulong )st->protocol == (ic->arg & 255UL)) { tmp___4 = (*(st->lli.l4l3_proto))(st, ic); return (tmp___4); } else { } st = st->next; ldv_42329: ; if ((unsigned long )st != (unsigned long )((struct PStack *)0)) { goto ldv_42328; } else { } return (-22); default: ; if ((unsigned long )csta->auxcmd != (unsigned long )((int (*)(struct IsdnCardState * , isdn_ctrl * ))0)) { tmp___5 = (*(csta->auxcmd))(csta, ic); return (tmp___5); } else { } return (-22); } ldv_42290: ; return (0); } } int HiSax_writebuf_skb(int id___0 , int chan , int ack , struct sk_buff *skb ) { struct IsdnCardState *csta ; struct IsdnCardState *tmp ; struct Channel *chanp ; struct PStack *st ; int len ; struct sk_buff *nskb ; { tmp = hisax_findcard___0(id___0); csta = tmp; len = (int )skb->len; if ((unsigned long )csta == (unsigned long )((struct IsdnCardState *)0)) { printk("\vHiSax: if_sendbuf called with invalid driverId!\n"); return (-19); } else { } chanp = (struct Channel *)(& csta->channel) + (unsigned long )chan; st = chanp->b_st; if (chanp->data_open == 0) { link_debug(chanp, 1, (char *)"writebuf: channel not open"); return (-5); } else { } if (len > 4092) { link_debug(chanp, 1, (char *)"writebuf: packet too large (%d bytes)", len); printk("\fHiSax_writebuf: packet too large (%d bytes) !\n", len); return (-22); } else { } if (len != 0) { if ((chanp->bcs)->tx_cnt + len > 4160) { if ((chanp->debug & 2048) != 0) { link_debug(chanp, 1, (char *)"writebuf: no buffers for %d bytes", len); } else { } return (0); } else if ((chanp->debug & 2048) != 0) { link_debug(chanp, 1, (char *)"writebuf %d/%d/%d", len, (chanp->bcs)->tx_cnt, 4160); } else { } nskb = skb_clone(skb, 32U); if ((unsigned long )nskb != (unsigned long )((struct sk_buff *)0)) { nskb->truesize = nskb->len; if (ack == 0) { nskb->pkt_type = 7U; } else { } if (chanp->l2_active_protocol == 0) { (*(st->l3.l3l2))(st, 544, (void *)nskb); } else { (chanp->bcs)->tx_cnt = (chanp->bcs)->tx_cnt + len; (*(st->l2.l2l1))(st, 288, (void *)nskb); } consume_skb(skb); } else { len = 0; } } else { } return (len); } } void ldv_mutex_lock_99(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_lock(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_100(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_lock(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_101(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } int ldv_mutex_trylock_102(struct mutex *ldv_func_arg1 ) { ldv_func_ret_type___2 ldv_func_res ; int tmp ; int tmp___0 ; { tmp = mutex_trylock(ldv_func_arg1); ldv_func_res = tmp; tmp___0 = ldv_mutex_trylock_mutex(ldv_func_arg1); return (tmp___0); return (ldv_func_res); } } void ldv_mutex_unlock_103(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_104(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_cred_guard_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_105(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_cred_guard_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } int ldv_mutex_trylock_116(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_114(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_117(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_119(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_113(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_115(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_118(struct mutex *ldv_func_arg1 ) ; int FsmNew(struct Fsm *fsm , struct FsmNode *fnlist___0 , int fncount ) { int i ; void *tmp ; { tmp = kzalloc(((unsigned long )fsm->state_count * (unsigned long )fsm->event_count) * 8UL, 208U); fsm->jumpmatrix = (FSMFNPTR (**)(struct FsmInst * , int , void * ))tmp; if ((unsigned long )fsm->jumpmatrix == (unsigned long )((FSMFNPTR (**)(struct FsmInst * , int , void * ))0)) { return (-12); } else { } i = 0; goto ldv_41732; ldv_41731: ; if ((fnlist___0 + (unsigned long )i)->state >= fsm->state_count || (fnlist___0 + (unsigned long )i)->event >= fsm->event_count) { printk("\vFsmNew Error line %d st(%ld/%ld) ev(%ld/%ld)\n", i, (long )(fnlist___0 + (unsigned long )i)->state, (long )fsm->state_count, (long )(fnlist___0 + (unsigned long )i)->event, (long )fsm->event_count); } else { *(fsm->jumpmatrix + (unsigned long )(fsm->state_count * (fnlist___0 + (unsigned long )i)->event + (fnlist___0 + (unsigned long )i)->state)) = (fnlist___0 + (unsigned long )i)->routine; } i = i + 1; ldv_41732: ; if (i < fncount) { goto ldv_41731; } else { } return (0); } } void FsmFree(struct Fsm *fsm ) { { kfree((void const *)fsm->jumpmatrix); return; } } int FsmEvent(struct FsmInst *fi , int event , void *arg ) { void (*r)(struct FsmInst * , int , void * ) ; { if (fi->state >= (fi->fsm)->state_count || (fi->fsm)->event_count <= event) { printk("\vFsmEvent Error st(%ld/%ld) ev(%d/%ld)\n", (long )fi->state, (long )(fi->fsm)->state_count, event, (long )(fi->fsm)->event_count); return (1); } else { } r = *((fi->fsm)->jumpmatrix + (unsigned long )((fi->fsm)->state_count * event + fi->state)); if ((unsigned long )r != (unsigned long )((void (*)(struct FsmInst * , int , void * ))0)) { if (fi->debug != 0) { (*(fi->printdebug))(fi, (char *)"State %s Event %s", *((fi->fsm)->strState + (unsigned long )fi->state), *((fi->fsm)->strEvent + (unsigned long )event)); } else { } (*r)(fi, event, arg); return (0); } else { if (fi->debug != 0) { (*(fi->printdebug))(fi, (char *)"State %s Event %s no routine", *((fi->fsm)->strState + (unsigned long )fi->state), *((fi->fsm)->strEvent + (unsigned long )event)); } else { } return (1); } } } void FsmChangeState(struct FsmInst *fi , int newstate ) { { fi->state = newstate; if (fi->debug != 0) { (*(fi->printdebug))(fi, (char *)"ChangeState %s", *((fi->fsm)->strState + (unsigned long )newstate)); } else { } return; } } static void FsmExpireTimer(struct FsmTimer *ft ) { { FsmEvent(ft->fi, ft->event, ft->arg); return; } } void FsmInitTimer(struct FsmInst *fi , struct FsmTimer *ft ) { struct lock_class_key __key ; { ft->fi = fi; ft->tl.function = (void (*)(unsigned long ))(& FsmExpireTimer); ft->tl.data = (unsigned long )ft; init_timer_key(& ft->tl, 0U, "(&ft->tl)", & __key); return; } } void FsmDelTimer(struct FsmTimer *ft , int where ) { { del_timer(& ft->tl); return; } } int FsmAddTimer(struct FsmTimer *ft , int millisec , int event , void *arg , int where ) { int tmp ; struct lock_class_key __key ; { tmp = timer_pending((struct timer_list const *)(& ft->tl)); if (tmp != 0) { printk("\fFsmAddTimer: timer already active!\n"); (*((ft->fi)->printdebug))(ft->fi, (char *)"FsmAddTimer already active!"); return (-1); } else { } init_timer_key(& ft->tl, 0U, "(&ft->tl)", & __key); ft->event = event; ft->arg = arg; ft->tl.expires = (unsigned long )((millisec * 250) / 1000) + (unsigned long )jiffies; add_timer(& ft->tl); return (0); } } void FsmRestartTimer(struct FsmTimer *ft , int millisec , int event , void *arg , int where ) { int tmp ; struct lock_class_key __key ; { tmp = timer_pending((struct timer_list const *)(& ft->tl)); if (tmp != 0) { del_timer(& ft->tl); } else { } init_timer_key(& ft->tl, 0U, "(&ft->tl)", & __key); ft->event = event; ft->arg = arg; ft->tl.expires = (unsigned long )((millisec * 250) / 1000) + (unsigned long )jiffies; add_timer(& ft->tl); return; } } void ldv_mutex_lock_113(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_lock(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_114(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_lock(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_115(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } int ldv_mutex_trylock_116(struct mutex *ldv_func_arg1 ) { ldv_func_ret_type___2 ldv_func_res ; int tmp ; int tmp___0 ; { tmp = mutex_trylock(ldv_func_arg1); ldv_func_res = tmp; tmp___0 = ldv_mutex_trylock_mutex(ldv_func_arg1); return (tmp___0); return (ldv_func_res); } } void ldv_mutex_unlock_117(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_118(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_cred_guard_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_119(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_cred_guard_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } extern char *strcat(char * , char const * ) ; int ldv_mutex_trylock_130(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_128(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_131(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_133(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_127(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_129(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_132(struct mutex *ldv_func_arg1 ) ; extern unsigned char const _ctype[] ; static char const *dss1_revision = "$Revision: 2.32.2.3 $"; static unsigned char new_invoke_id(struct PStack *p ) { unsigned char retval ; int i ; { i = 32; retval = (unsigned int )p->prot.dss1.last_invoke_id + 1U; goto ldv_41000; ldv_40999: p->prot.dss1.last_invoke_id = ((unsigned int )retval & 248U) + 8U; i = i - 1; ldv_41000: ; if (i != 0 && (unsigned int )p->prot.dss1.invoke_used[(int )retval >> 3] == 255U) { goto ldv_40999; } else { } if (i != 0) { goto ldv_41003; ldv_41002: retval = (unsigned char )((int )retval + 1); ldv_41003: ; if (((int )p->prot.dss1.invoke_used[(int )retval >> 3] >> ((int )retval & 7)) & 1) { goto ldv_41002; } else { } } else { retval = 0U; } p->prot.dss1.last_invoke_id = retval; p->prot.dss1.invoke_used[(int )retval >> 3] = (unsigned char )((int )((signed char )p->prot.dss1.invoke_used[(int )retval >> 3]) | (int )((signed char )(1 << ((int )retval & 7)))); return (retval); } } static void free_invoke_id(struct PStack *p , unsigned char id___0 ) { { if ((unsigned int )id___0 == 0U) { return; } else { } p->prot.dss1.invoke_used[(int )id___0 >> 3] = (unsigned char )((int )((signed char )p->prot.dss1.invoke_used[(int )id___0 >> 3]) & ~ ((int )((signed char )(1 << ((int )id___0 & 7))))); return; } } static struct l3_process *dss1_new_l3_process(struct PStack *st , int cr ) { struct l3_process *proc ; { proc = new_l3_process(st, cr); if ((unsigned long )proc == (unsigned long )((struct l3_process *)0)) { return (0); } else { } proc->prot.dss1.invoke_id = 0U; proc->prot.dss1.remote_operation = 0U; proc->prot.dss1.uus1_data[0] = 0; return (proc); } } static void dss1_release_l3_process(struct l3_process *p ) { { free_invoke_id(p->st, (int )p->prot.dss1.invoke_id); release_l3_process(p); return; } } static struct l3_process *l3dss1_search_dummy_proc(struct PStack *st , int id___0 ) { struct l3_process *pc ; { pc = st->l3.proc; if (id___0 == 0) { return (0); } else { } goto ldv_41023; ldv_41022: ; if (pc->callref == -1 && (int )pc->prot.dss1.invoke_id == id___0) { return (pc); } else { } pc = pc->next; ldv_41023: ; if ((unsigned long )pc != (unsigned long )((struct l3_process *)0)) { goto ldv_41022; } else { } return (0); } } static void l3dss1_dummy_return_result(struct PStack *st , int id___0 , u_char *p , u_char nlen ) { isdn_ctrl ic ; struct IsdnCardState *cs ; struct l3_process *pc ; { pc = 0; pc = l3dss1_search_dummy_proc(st, id___0); if ((unsigned long )pc != (unsigned long )((struct l3_process *)0)) { L3DelTimer(& pc->timer); cs = (struct IsdnCardState *)(pc->st)->l1.hardware; ic.driver = cs->myid; ic.command = 273; ic.arg = 32770UL; ic.parm.isdn_io.hl_id = (int )pc->prot.dss1.invoke_id; ic.parm.isdn_io.ll_id = pc->prot.dss1.ll_id; ic.parm.isdn_io.proc = pc->prot.dss1.proc; ic.parm.isdn_io.timeout = 0; ic.parm.isdn_io.datalen = (int )nlen; ic.parm.isdn_io.data = p; free_invoke_id(pc->st, (int )pc->prot.dss1.invoke_id); pc->prot.dss1.invoke_id = 0U; (*(cs->iif.statcallb))(& ic); dss1_release_l3_process(pc); } else { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"dummy return result id=0x%x result len=%d", id___0, (int )nlen); } return; } } static void l3dss1_dummy_error_return(struct PStack *st , int id___0 , ulong error ) { isdn_ctrl ic ; struct IsdnCardState *cs ; struct l3_process *pc ; { pc = 0; pc = l3dss1_search_dummy_proc(st, id___0); if ((unsigned long )pc != (unsigned long )((struct l3_process *)0)) { L3DelTimer(& pc->timer); cs = (struct IsdnCardState *)(pc->st)->l1.hardware; ic.driver = cs->myid; ic.command = 273; ic.arg = 33026UL; ic.parm.isdn_io.hl_id = (int )pc->prot.dss1.invoke_id; ic.parm.isdn_io.ll_id = pc->prot.dss1.ll_id; ic.parm.isdn_io.proc = pc->prot.dss1.proc; ic.parm.isdn_io.timeout = (int )error; ic.parm.isdn_io.datalen = 0; ic.parm.isdn_io.data = 0; free_invoke_id(pc->st, (int )pc->prot.dss1.invoke_id); pc->prot.dss1.invoke_id = 0U; (*(cs->iif.statcallb))(& ic); dss1_release_l3_process(pc); } else { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"dummy return error id=0x%x error=0x%lx", id___0, error); } return; } } static void l3dss1_dummy_invoke(struct PStack *st , int cr , int id___0 , int ident , u_char *p , u_char nlen ) { isdn_ctrl ic ; struct IsdnCardState *cs ; { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"dummy invoke %s id=0x%x ident=0x%x datalen=%d", cr == -1 ? (char *)"local" : (char *)"broadcast", id___0, ident, (int )nlen); if (cr >= -1) { return; } else { } cs = (struct IsdnCardState *)st->l1.hardware; ic.driver = cs->myid; ic.command = 273; ic.arg = 33282UL; ic.parm.isdn_io.hl_id = id___0; ic.parm.isdn_io.ll_id = 0UL; ic.parm.isdn_io.proc = ident; ic.parm.isdn_io.timeout = 0; ic.parm.isdn_io.datalen = (int )nlen; ic.parm.isdn_io.data = p; (*(cs->iif.statcallb))(& ic); return; } } static void l3dss1_parse_facility(struct PStack *st , struct l3_process *pc , int cr , u_char *p ) { int qd_len ; unsigned char nlen ; unsigned char ilen ; unsigned char cp_tag ; int ident ; int id___0 ; ulong err_ret ; u_char *tmp ; u_char *tmp___0 ; int tmp___1 ; u_char *tmp___2 ; u_char *tmp___3 ; u_char *tmp___4 ; u_char *tmp___5 ; u_char *tmp___6 ; u_char *tmp___7 ; int ilen___0 ; int nlen___0 ; int ilen___1 ; int nlen___1 ; int ilen___2 ; int nlen___2 ; int ilen___3 ; int nlen___3 ; u_char *tmp___8 ; int ilen___4 ; int nlen___4 ; int ilen___5 ; int nlen___5 ; int ilen___6 ; int nlen___6 ; int ilen___7 ; int nlen___7 ; int ilen___8 ; int nlen___8 ; u_char *tmp___9 ; u_char *tmp___10 ; u_char *tmp___11 ; { qd_len = 0; nlen = 0U; if ((unsigned long )pc != (unsigned long )((struct l3_process *)0)) { st = pc->st; } else if ((unsigned long )st == (unsigned long )((struct PStack *)0) || cr >= 0) { return; } else { } p = p + 1; tmp = p; p = p + 1; qd_len = (int )*tmp; if (qd_len == 0) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"qd_len == 0"); return; } else { } if (((int )*p & 31) != 17) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"supplementary service != 0x11"); return; } else { } goto ldv_41066; ldv_41065: p = p + 1; qd_len = qd_len - 1; ldv_41066: ; if (qd_len > 0 && (int )((signed char )*p) >= 0) { goto ldv_41065; } else { } if (qd_len <= 1) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"qd_len < 2"); return; } else { } p = p + 1; qd_len = qd_len - 1; if (((int )*p & 224) != 160) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"class and form != 0xA0"); return; } else { } cp_tag = (unsigned int )*p & 31U; p = p + 1; qd_len = qd_len - 1; if (qd_len <= 0) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"qd_len < 1"); return; } else { } if ((int )((signed char )*p) < 0) { tmp___0 = p; p = p + 1; nlen = (unsigned int )*tmp___0 & 127U; tmp___1 = qd_len; qd_len = qd_len - 1; if (tmp___1 < ((unsigned int )nlen != 0U ? (int )nlen + 1 : 3) || (unsigned int )nlen > 1U) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"length format error or not implemented"); return; } else { } if ((unsigned int )nlen == 1U) { tmp___2 = p; p = p + 1; nlen = *tmp___2; qd_len = qd_len - 1; } else { qd_len = qd_len + -2; if ((unsigned int )*(p + (unsigned long )qd_len) != 0U || (unsigned int )*(p + ((unsigned long )qd_len + 1UL)) != 0U) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"length format indefinite error"); return; } else { } nlen = (unsigned char )qd_len; } } else { tmp___3 = p; p = p + 1; nlen = *tmp___3; qd_len = qd_len - 1; } if ((int )nlen > qd_len) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"qd_len < nlen"); return; } else { } qd_len = qd_len - (int )nlen; if ((unsigned int )nlen <= 1U) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"nlen < 2"); return; } else { } if ((unsigned int )*p != 2U) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"invoke identifier tag !=0x02"); return; } else { } p = p + 1; nlen = (unsigned char )((int )nlen - 1); if ((int )((signed char )*p) < 0) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"invoke id length format 2"); return; } else { } tmp___4 = p; p = p + 1; ilen = *tmp___4; nlen = (unsigned char )((int )nlen - 1); if ((int )ilen > (int )nlen || (unsigned int )ilen == 0U) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"ilen > nlen || ilen == 0"); return; } else { } nlen = (int )nlen - (int )ilen; id___0 = 0; goto ldv_41069; ldv_41068: tmp___5 = p; p = p + 1; id___0 = (id___0 << 8) | (int )*tmp___5; ilen = (unsigned char )((int )ilen - 1); ldv_41069: ; if ((unsigned int )ilen != 0U) { goto ldv_41068; } else { } switch ((int )cp_tag) { case 1: ; if ((unsigned int )nlen <= 1U) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"nlen < 2 22"); return; } else { } if ((unsigned int )*p != 2U) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"operation value !=0x02"); return; } else { } p = p + 1; nlen = (unsigned char )((int )nlen - 1); tmp___6 = p; p = p + 1; ilen = *tmp___6; nlen = (unsigned char )((int )nlen - 1); if ((int )ilen > (int )nlen || (unsigned int )ilen == 0U) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"ilen > nlen || ilen == 0 22"); return; } else { } nlen = (int )nlen - (int )ilen; ident = 0; goto ldv_41073; ldv_41072: tmp___7 = p; p = p + 1; ident = (ident << 8) | (int )*tmp___7; ilen = (unsigned char )((int )ilen - 1); ldv_41073: ; if ((unsigned int )ilen != 0U) { goto ldv_41072; } else { } if ((unsigned long )pc == (unsigned long )((struct l3_process *)0)) { l3dss1_dummy_invoke(st, cr, id___0, ident, p, (int )nlen); return; } else { } switch (ident) { case 34: ; goto ldv_41097; ldv_41096: ilen___0 = (int )*(p + 1UL); if ((int )nlen < ilen___0 + 2) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"FOO1 nlen < ilen+2"); return; } else { } nlen = (unsigned int )((int )nlen - (int )((unsigned char )ilen___0)) + 254U; if ((unsigned int )*p == 48U) { nlen___0 = ilen___0; p = p + 2UL; goto ldv_41094; ldv_41093: ilen___1 = (int )*(p + 1UL); if (ilen___1 + 2 > nlen___0) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"FOO1 nlen < ilen+2"); return; } else { } nlen___0 = (-2 - ilen___1) + nlen___0; if ((unsigned int )*p == 161U) { nlen___1 = ilen___1; p = p + 2UL; goto ldv_41091; ldv_41090: ilen___2 = (int )*(p + 1UL); if (ilen___2 + 2 > nlen___1) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"FOO1 nlen < ilen+2"); return; } else { } nlen___1 = (-2 - ilen___2) + nlen___1; if ((unsigned int )*p == 48U) { nlen___2 = ilen___2; p = p + 2UL; goto ldv_41088; ldv_41087: ilen___3 = (int )*(p + 1UL); if (ilen___3 + 2 > nlen___2) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"FOO1 nlen < ilen+2"); return; } else { } nlen___2 = (-2 - ilen___3) + nlen___2; if ((unsigned int )*p == 2U) { nlen___3 = ilen___3; p = p + 2UL; ident = 0; nlen___3 = nlen___3; goto ldv_41085; ldv_41084: tmp___8 = p; p = p + 1; ident = (ident << 8) | (int )*tmp___8; ilen___3 = ilen___3 - 1; ldv_41085: ; if (ilen___3 > 0) { goto ldv_41084; } else { } if (pc->para.chargeinfo < ident) { pc->para.chargeinfo = ident; (*(st->l3.l3l4))(st, 854, (void *)pc); } else { } if ((st->l3.debug & 8) != 0) { if ((unsigned int )*(p + 2UL) == 0U) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"charging info during %d", pc->para.chargeinfo); } else { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"charging info final %d", pc->para.chargeinfo); } } else { } } else { p = p + ((unsigned long )ilen___3 + 2UL); } ldv_41088: ; if (nlen___2 > 1) { goto ldv_41087; } else { } } else { p = p + ((unsigned long )ilen___2 + 2UL); } ldv_41091: ; if (nlen___1 > 1) { goto ldv_41090; } else { } } else { p = p + ((unsigned long )ilen___1 + 2UL); } ldv_41094: ; if (nlen___0 > 1) { goto ldv_41093; } else { } } else { p = p + ((unsigned long )ilen___0 + 2UL); } ldv_41097: ; if ((unsigned int )nlen > 1U) { goto ldv_41096; } else { } goto ldv_41099; case 36: ; goto ldv_41127; ldv_41126: ilen___4 = (int )*(p + 1UL); if ((int )nlen < ilen___4 + 2) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"FOO1 nlen < ilen+2"); return; } else { } nlen = (unsigned int )((int )nlen - (int )((unsigned char )ilen___4)) + 254U; if ((unsigned int )*p == 48U) { nlen___4 = ilen___4; p = p + 2UL; goto ldv_41124; ldv_41123: ilen___5 = (int )*(p + 1UL); if (ilen___5 + 2 > nlen___4) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"FOO1 nlen < ilen+2"); return; } else { } nlen___4 = (-2 - ilen___5) + nlen___4; if ((unsigned int )*p == 48U) { nlen___5 = ilen___5; p = p + 2UL; goto ldv_41121; ldv_41120: ilen___6 = (int )*(p + 1UL); if (ilen___6 + 2 > nlen___5) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"FOO1 nlen < ilen+2"); return; } else { } nlen___5 = (-2 - ilen___6) + nlen___5; if ((unsigned int )*p == 161U) { nlen___6 = ilen___6; p = p + 2UL; goto ldv_41118; ldv_41117: ilen___7 = (int )*(p + 1UL); if (ilen___7 + 2 > nlen___6) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"FOO1 nlen < ilen+2"); return; } else { } nlen___6 = (-2 - ilen___7) + nlen___6; if ((unsigned int )*p == 48U) { nlen___7 = ilen___7; p = p + 2UL; goto ldv_41115; ldv_41114: ilen___8 = (int )*(p + 1UL); if (ilen___8 + 2 > nlen___7) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"FOO1 nlen < ilen+2"); return; } else { } nlen___7 = (-2 - ilen___8) + nlen___7; if ((unsigned int )*p == 2U) { nlen___8 = ilen___8; p = p + 2UL; ident = 0; nlen___8 = nlen___8; goto ldv_41112; ldv_41111: tmp___9 = p; p = p + 1; ident = (ident << 8) | (int )*tmp___9; ilen___8 = ilen___8 - 1; ldv_41112: ; if (ilen___8 > 0) { goto ldv_41111; } else { } if (pc->para.chargeinfo < ident) { pc->para.chargeinfo = ident; (*(st->l3.l3l4))(st, 854, (void *)pc); } else { } if ((st->l3.debug & 8) != 0) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"charging info final %d", pc->para.chargeinfo); } else { } } else { p = p + ((unsigned long )ilen___8 + 2UL); } ldv_41115: ; if (nlen___7 > 1) { goto ldv_41114; } else { } } else { p = p + ((unsigned long )ilen___7 + 2UL); } ldv_41118: ; if (nlen___6 > 1) { goto ldv_41117; } else { } } else { p = p + ((unsigned long )ilen___6 + 2UL); } ldv_41121: ; if (nlen___5 > 1) { goto ldv_41120; } else { } } else { p = p + ((unsigned long )ilen___5 + 2UL); } ldv_41124: ; if (nlen___4 > 1) { goto ldv_41123; } else { } } else { p = p + ((unsigned long )ilen___4 + 2UL); } ldv_41127: ; if ((unsigned int )nlen > 1U) { goto ldv_41126; } else { } goto ldv_41099; default: HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"invoke break invalid ident %02x", ident); goto ldv_41099; } ldv_41099: ; goto ldv_41130; case 2: ; if ((unsigned long )pc == (unsigned long )((struct l3_process *)0)) { if (cr == -1) { l3dss1_dummy_return_result(st, id___0, p, (int )nlen); } else { } return; } else { } if ((unsigned int )pc->prot.dss1.invoke_id != 0U && (int )pc->prot.dss1.invoke_id == id___0) { free_invoke_id(st, (int )pc->prot.dss1.invoke_id); pc->prot.dss1.remote_result = 0UL; pc->prot.dss1.invoke_id = 0U; pc->redir_result = pc->prot.dss1.remote_result; (*(st->l3.l3l4))(st, 890, (void *)pc); } else { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"return error unknown identifier"); } goto ldv_41130; case 3: err_ret = 0UL; if ((unsigned int )nlen <= 1U) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"return error nlen < 2"); return; } else { } if ((unsigned int )*p != 2U) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"invoke error tag !=0x02"); return; } else { } p = p + 1; nlen = (unsigned char )((int )nlen - 1); if ((unsigned int )*p > 4U) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"invoke return errlen > 4 "); return; } else { } tmp___10 = p; p = p + 1; ilen = *tmp___10; nlen = (unsigned char )((int )nlen - 1); if ((int )ilen > (int )nlen || (unsigned int )ilen == 0U) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"error return ilen > nlen || ilen == 0"); return; } else { } nlen = (int )nlen - (int )ilen; goto ldv_41134; ldv_41133: tmp___11 = p; p = p + 1; err_ret = (err_ret << 8) | (ulong )*tmp___11; ilen = (unsigned char )((int )ilen - 1); ldv_41134: ; if ((unsigned int )ilen != 0U) { goto ldv_41133; } else { } if ((unsigned long )pc == (unsigned long )((struct l3_process *)0)) { if (cr == -1) { l3dss1_dummy_error_return(st, id___0, err_ret); } else { } return; } else { } if ((unsigned int )pc->prot.dss1.invoke_id != 0U && (int )pc->prot.dss1.invoke_id == id___0) { free_invoke_id(st, (int )pc->prot.dss1.invoke_id); pc->prot.dss1.remote_result = err_ret; pc->prot.dss1.invoke_id = 0U; pc->redir_result = pc->prot.dss1.remote_result; (*(st->l3.l3l4))(st, 890, (void *)pc); } else { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"return result unknown identifier"); } goto ldv_41130; default: HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"facility default break tag=0x%02x", (int )cp_tag); goto ldv_41130; } ldv_41130: ; return; } } static void l3dss1_message(struct l3_process *pc , u_char mt ) { struct sk_buff *skb ; u_char *p ; unsigned char *tmp ; u_char *tmp___0 ; u_char *tmp___1 ; u_char *tmp___2 ; u_char *tmp___3 ; u_char *tmp___4 ; { skb = l3_alloc_skb(4); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } tmp = skb_put(skb, 4U); p = tmp; tmp___0 = p; p = p + 1; *tmp___0 = 8U; if (pc->callref == -1) { tmp___1 = p; p = p + 1; *tmp___1 = 0U; } else { tmp___2 = p; p = p + 1; *tmp___2 = 1U; tmp___3 = p; p = p + 1; *tmp___3 = (u_char )((int )((signed char )pc->callref) ^ -128); } tmp___4 = p; p = p + 1; *tmp___4 = mt; l3_msg(pc->st, 544, (void *)skb); return; } } static void l3dss1_message_cause(struct l3_process *pc , u_char mt , u_char cause ) { struct sk_buff *skb ; u_char tmp[16U] ; u_char *p ; int l ; u_char *tmp___0 ; u_char *tmp___1 ; u_char *tmp___2 ; u_char *tmp___3 ; u_char *tmp___4 ; u_char *tmp___5 ; u_char *tmp___6 ; u_char *tmp___7 ; u_char *tmp___8 ; size_t __len ; void *__ret ; unsigned char *tmp___10 ; { p = (u_char *)(& tmp); tmp___0 = p; p = p + 1; *tmp___0 = 8U; if (pc->callref == -1) { tmp___1 = p; p = p + 1; *tmp___1 = 0U; } else { tmp___2 = p; p = p + 1; *tmp___2 = 1U; tmp___3 = p; p = p + 1; *tmp___3 = (u_char )((int )((signed char )pc->callref) ^ -128); } tmp___4 = p; p = p + 1; *tmp___4 = mt; tmp___5 = p; p = p + 1; *tmp___5 = 8U; tmp___6 = p; p = p + 1; *tmp___6 = 2U; tmp___7 = p; p = p + 1; *tmp___7 = 128U; tmp___8 = p; p = p + 1; *tmp___8 = (u_char )((unsigned int )cause | 128U); l = (int )((unsigned int )((long )p) - (unsigned int )((long )(& tmp))); skb = l3_alloc_skb(l); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } __len = (size_t )l; tmp___10 = skb_put(skb, (unsigned int )l); __ret = memcpy((void *)tmp___10, (void const *)(& tmp), __len); l3_msg(pc->st, 544, (void *)skb); return; } } static void l3dss1_status_send(struct l3_process *pc , u_char pr , void *arg ) { u_char tmp[16U] ; u_char *p ; int l ; struct sk_buff *skb ; u_char *tmp___0 ; u_char *tmp___1 ; u_char *tmp___2 ; u_char *tmp___3 ; u_char *tmp___4 ; u_char *tmp___5 ; u_char *tmp___6 ; u_char *tmp___7 ; u_char *tmp___8 ; u_char *tmp___9 ; u_char *tmp___10 ; u_char *tmp___11 ; size_t __len ; void *__ret ; unsigned char *tmp___13 ; { p = (u_char *)(& tmp); tmp___0 = p; p = p + 1; *tmp___0 = 8U; if (pc->callref == -1) { tmp___1 = p; p = p + 1; *tmp___1 = 0U; } else { tmp___2 = p; p = p + 1; *tmp___2 = 1U; tmp___3 = p; p = p + 1; *tmp___3 = (u_char )((int )((signed char )pc->callref) ^ -128); } tmp___4 = p; p = p + 1; *tmp___4 = 125U; tmp___5 = p; p = p + 1; *tmp___5 = 8U; tmp___6 = p; p = p + 1; *tmp___6 = 2U; tmp___7 = p; p = p + 1; *tmp___7 = 128U; tmp___8 = p; p = p + 1; *tmp___8 = (u_char )((unsigned int )pc->para.cause | 128U); tmp___9 = p; p = p + 1; *tmp___9 = 20U; tmp___10 = p; p = p + 1; *tmp___10 = 1U; tmp___11 = p; p = p + 1; *tmp___11 = (unsigned int )((u_char )pc->state) & 63U; l = (int )((unsigned int )((long )p) - (unsigned int )((long )(& tmp))); skb = l3_alloc_skb(l); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } __len = (size_t )l; tmp___13 = skb_put(skb, (unsigned int )l); __ret = memcpy((void *)tmp___13, (void const *)(& tmp), __len); l3_msg(pc->st, 544, (void *)skb); return; } } static void l3dss1_msg_without_setup(struct l3_process *pc , u_char pr , void *arg ) { u_char tmp[16U] ; u_char *p ; int l ; struct sk_buff *skb ; u_char *tmp___0 ; u_char *tmp___1 ; u_char *tmp___2 ; u_char *tmp___3 ; u_char *tmp___4 ; u_char *tmp___5 ; u_char *tmp___6 ; u_char *tmp___7 ; u_char *tmp___8 ; size_t __len ; void *__ret ; unsigned char *tmp___10 ; { p = (u_char *)(& tmp); switch ((int )pc->para.cause) { case 81: ; case 88: ; case 96: ; case 100: ; case 101: tmp___0 = p; p = p + 1; *tmp___0 = 8U; if (pc->callref == -1) { tmp___1 = p; p = p + 1; *tmp___1 = 0U; } else { tmp___2 = p; p = p + 1; *tmp___2 = 1U; tmp___3 = p; p = p + 1; *tmp___3 = (u_char )((int )((signed char )pc->callref) ^ -128); } tmp___4 = p; p = p + 1; *tmp___4 = 90U; tmp___5 = p; p = p + 1; *tmp___5 = 8U; tmp___6 = p; p = p + 1; *tmp___6 = 2U; tmp___7 = p; p = p + 1; *tmp___7 = 128U; tmp___8 = p; p = p + 1; *tmp___8 = (u_char )((unsigned int )pc->para.cause | 128U); goto ldv_41181; default: printk("\vHiSax l3dss1_msg_without_setup wrong cause %d\n", (int )pc->para.cause); return; } ldv_41181: l = (int )((unsigned int )((long )p) - (unsigned int )((long )(& tmp))); skb = l3_alloc_skb(l); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } __len = (size_t )l; tmp___10 = skb_put(skb, (unsigned int )l); __ret = memcpy((void *)tmp___10, (void const *)(& tmp), __len); l3_msg(pc->st, 544, (void *)skb); dss1_release_l3_process(pc); return; } } static int ie_ALERTING[9U] = { 4, 536, 28, 30, 40, 52, 125, 126, -1}; static int ie_CALL_PROCEEDING[7U] = { 4, 536, 28, 30, 40, 125, -1}; static int ie_CONNECT[13U] = { 4, 536, 28, 30, 40, 41, 52, 76, 77, 124, 125, 126, -1}; static int ie_CONNECT_ACKNOWLEDGE[4U] = { 24, 40, 52, -1}; static int ie_DISCONNECT[7U] = { 264, 28, 30, 40, 52, 126, -1}; static int ie_INFORMATION[6U] = { 161, 40, 44, 52, 112, -1}; static int ie_NOTIFY[4U] = { 4, 295, 40, -1}; static int ie_PROGRESS[8U] = { 4, 8, 28, 286, 40, 125, 126, -1}; static int ie_RELEASE[6U] = { 520, 28, 40, 52, 126, -1}; static int ie_RESUME_ACKNOWLEDGE[4U] = { 280, 28, 40, -1}; static int ie_RESUME_REJECT[3U] = { 264, 40, -1}; static int ie_SETUP[18U] = { 161, 260, 280, 28, 30, 32, 40, 44, 52, 108, 109, 112, 113, 116, 124, 125, 126, -1}; static int ie_SETUP_ACKNOWLEDGE[6U] = { 280, 28, 30, 40, 52, -1}; static int ie_STATUS[4U] = { 264, 276, 40, -1}; static int ie_STATUS_ENQUIRY[2U] = { 40, -1}; static int ie_SUSPEND_ACKNOWLEDGE[3U] = { 40, 28, -1}; static int ie_SUSPEND_REJECT[3U] = { 264, 40, -1}; static int ie_FACILITY[3U] = { 284, 40, -1}; static int comp_required[12U] = { 1, 2, 3, 5, 6, 7, 9, 10, 11, 14, 15, -1}; static int l3_valid_states[17U] = { 0, 1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 12, 15, 17, 19, 25, -1}; static struct ie_len max_ie_len[33U] = { {0, 4}, {4, 12}, {8, 32}, {16, 10}, {20, 3}, {24, 34}, {28, 255}, {30, 4}, {32, 255}, {39, 3}, {40, 82}, {41, 8}, {44, 34}, {52, 3}, {64, 6}, {66, 11}, {67, 5}, {68, 3}, {69, 4}, {70, 4}, {71, 7}, {74, 3}, {108, 24}, {109, 23}, {112, 24}, {113, 23}, {116, 255}, {120, 255}, {121, 3}, {124, 18}, {125, 5}, {126, 131}, {-1, 0}}; static int getmax_ie_len(u_char ie ) { int i ; { i = 0; goto ldv_41215; ldv_41214: ; if (max_ie_len[i].ie == (int )ie) { return (max_ie_len[i].len); } else { } i = i + 1; ldv_41215: ; if (max_ie_len[i].ie != -1) { goto ldv_41214; } else { } return (255); } } static int ie_in_set(struct l3_process *pc , u_char ie , int *checklist ) { int ret ; { ret = 1; goto ldv_41224; ldv_41223: ; if ((*checklist & 255) == (int )ie) { if ((int )((signed char )ie) < 0) { return (- ret); } else { return (ret); } } else { } ret = ret + 1; checklist = checklist + 1; ldv_41224: ; if (*checklist != -1) { goto ldv_41223; } else { } return (0); } } static int check_infoelements(struct l3_process *pc , struct sk_buff *skb , int *checklist ) { int *cl ; u_char mt ; u_char *p ; u_char ie ; int l ; int newpos ; int oldpos ; int err_seq ; int err_len ; int err_compr ; int err_ureg ; u_char codeset ; u_char old_codeset ; u_char codelock ; u_char *tmp ; u_char *tmp___0 ; int tmp___1 ; u_char *tmp___2 ; u_char *tmp___3 ; int tmp___4 ; { cl = checklist; err_seq = 0; err_len = 0; err_compr = 0; err_ureg = 0; codeset = 0U; old_codeset = 0U; codelock = 1U; p = skb->data; p = p + 1; tmp = p; p = p + 1; l = (int )*tmp & 15; p = p + (unsigned long )l; tmp___0 = p; p = p + 1; mt = *tmp___0; oldpos = 0; goto ldv_41245; ldv_41246: ; if (((int )*p & 240) == 144) { old_codeset = codeset; codeset = (unsigned int )*p & 7U; if (((int )*p & 8) != 0) { codelock = 0U; } else { codelock = 1U; } if ((pc->debug & 16) != 0) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"check IE shift%scodeset %d->%d", (unsigned int )codelock != 0U ? (char *)" locking " : (char *)" ", (int )old_codeset, (int )codeset); } else { } p = p + 1; goto ldv_41245; } else { } if ((unsigned int )codeset == 0U) { newpos = ie_in_set(pc, (int )*p, cl); if (newpos != 0) { if (newpos > 0) { if (newpos < oldpos) { err_seq = err_seq + 1; } else { oldpos = newpos; } } else { tmp___1 = ie_in_set(pc, (int )*p, (int *)(& comp_required)); if (tmp___1 != 0) { err_compr = err_compr + 1; } else { err_ureg = err_ureg + 1; } } } else { } } else { } tmp___2 = p; p = p + 1; ie = *tmp___2; if ((int )((signed char )ie) < 0) { l = 1; } else { tmp___3 = p; p = p + 1; l = (int )*tmp___3; p = p + (unsigned long )l; l = l + 2; } if ((unsigned int )codeset == 0U) { tmp___4 = getmax_ie_len((int )ie); if (tmp___4 < l) { err_len = err_len + 1; } else { } } else { } if ((unsigned int )codelock == 0U) { if ((pc->debug & 16) != 0) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"check IE shift back codeset %d->%d", (int )codeset, (int )old_codeset); } else { } codeset = old_codeset; codelock = 1U; } else { } ldv_41245: ; if ((long )p - (long )skb->data < (long )skb->len) { goto ldv_41246; } else { } if ((((err_compr | err_ureg) | err_len) | err_seq) != 0) { if ((pc->debug & 16) != 0) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"check IE MT(%x) %d/%d/%d/%d", (int )mt, err_compr, err_ureg, err_len, err_seq); } else { } if (err_compr != 0) { return (1); } else { } if (err_ureg != 0) { return (-1); } else { } if (err_len != 0) { return (-2); } else { } if (err_seq != 0) { return (-3); } else { } } else { } return (0); } } static int l3dss1_check_messagetype_validity(struct l3_process *pc , int mt , void *arg ) { { switch (mt) { case 1: ; case 2: ; case 7: ; case 15: ; case 69: ; case 123: ; case 98: ; case 110: ; case 3: ; case 77: ; case 90: ; case 5: ; case 13: ; case 46: ; case 34: ; case 45: ; case 33: ; case 32: ; case 70: ; case 78: ; case 121: ; case 125: ; case 117: ; if ((pc->debug & 16) != 0) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"l3dss1_check_messagetype_validity mt(%x) OK", mt); } else { } goto ldv_41276; case 38: ; case 37: ; default: ; if ((pc->debug & 17) != 0) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"l3dss1_check_messagetype_validity mt(%x) fail", mt); } else { } pc->para.cause = 97U; l3dss1_status_send(pc, 0, 0); return (1); } ldv_41276: ; return (0); } } static void l3dss1_std_ie_err(struct l3_process *pc , int ret ) { { if ((pc->debug & 16) != 0) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"check_infoelements ret %d", ret); } else { } switch (ret) { case 0: ; goto ldv_41285; case 1: pc->para.cause = 96U; l3dss1_status_send(pc, 0, 0); goto ldv_41285; case -1: pc->para.cause = 99U; l3dss1_status_send(pc, 0, 0); goto ldv_41285; case -2: pc->para.cause = 100U; l3dss1_status_send(pc, 0, 0); goto ldv_41285; case -3: ; default: ; goto ldv_41285; } ldv_41285: ; return; } } static int l3dss1_get_channel_id(struct l3_process *pc , struct sk_buff *skb ) { u_char *p ; { p = skb->data; p = findie(p, (int )skb->len, 24, 0); if ((unsigned long )p != (unsigned long )((u_char *)0)) { p = p + 1; if ((unsigned int )*p != 1U) { if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"wrong chid len %d", (int )*p); } else { } return (-2); } else { } p = p + 1; if (((int )*p & 96) != 0) { if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"wrong chid %x", (int )*p); } else { } return (-3); } else { } return ((int )*p & 3); } else { return (-1); } } } static int l3dss1_get_cause(struct l3_process *pc , struct sk_buff *skb ) { u_char l ; u_char i ; u_char *p ; u_char *tmp ; u_char *tmp___0 ; u_char *tmp___1 ; u_char tmp___2 ; u_char *tmp___3 ; { i = 0U; p = skb->data; pc->para.cause = 31U; pc->para.loc = 0U; p = findie(p, (int )skb->len, 8, 0); if ((unsigned long )p != (unsigned long )((u_char *)0)) { p = p + 1; tmp = p; p = p + 1; l = *tmp; if ((unsigned int )l > 30U) { return (1); } else { } if ((unsigned int )l != 0U) { tmp___0 = p; p = p + 1; pc->para.loc = *tmp___0; l = (u_char )((int )l - 1); } else { return (2); } if ((unsigned int )l != 0U && (int )((signed char )pc->para.loc) >= 0) { l = (u_char )((int )l - 1); p = p + 1; } else { } if ((unsigned int )l != 0U) { tmp___1 = p; p = p + 1; pc->para.cause = *tmp___1; l = (u_char )((int )l - 1); if ((int )((signed char )pc->para.cause) >= 0) { return (3); } else { } } else { return (4); } goto ldv_41304; ldv_41303: tmp___2 = i; i = (u_char )((int )i + 1); tmp___3 = p; p = p + 1; pc->para.diag[(int )tmp___2] = *tmp___3; l = (u_char )((int )l - 1); ldv_41304: ; if ((unsigned int )l != 0U && (unsigned int )i <= 5U) { goto ldv_41303; } else { } } else { return (-1); } return (0); } } static void l3dss1_msg_with_uus(struct l3_process *pc , u_char cmd ) { struct sk_buff *skb ; u_char tmp[56U] ; u_char *p ; int l ; u_char *tmp___0 ; u_char *tmp___1 ; u_char *tmp___2 ; u_char *tmp___3 ; u_char *tmp___4 ; u_char *tmp___5 ; u_char *tmp___6 ; size_t tmp___7 ; u_char *tmp___8 ; size_t tmp___9 ; size_t __len ; void *__ret ; unsigned char *tmp___11 ; { p = (u_char *)(& tmp); tmp___0 = p; p = p + 1; *tmp___0 = 8U; if (pc->callref == -1) { tmp___1 = p; p = p + 1; *tmp___1 = 0U; } else { tmp___2 = p; p = p + 1; *tmp___2 = 1U; tmp___3 = p; p = p + 1; *tmp___3 = (u_char )((int )((signed char )pc->callref) ^ -128); } tmp___4 = p; p = p + 1; *tmp___4 = cmd; if ((int )((signed char )pc->prot.dss1.uus1_data[0]) != 0) { tmp___5 = p; p = p + 1; *tmp___5 = 126U; tmp___6 = p; p = p + 1; tmp___7 = strlen((char const *)(& pc->prot.dss1.uus1_data)); *tmp___6 = (unsigned int )((u_char )tmp___7) + 1U; tmp___8 = p; p = p + 1; *tmp___8 = 4U; strcpy((char *)p, (char const *)(& pc->prot.dss1.uus1_data)); tmp___9 = strlen((char const *)(& pc->prot.dss1.uus1_data)); p = p + tmp___9; pc->prot.dss1.uus1_data[0] = 0; } else { } l = (int )((unsigned int )((long )p) - (unsigned int )((long )(& tmp))); skb = l3_alloc_skb(l); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } __len = (size_t )l; tmp___11 = skb_put(skb, (unsigned int )l); __ret = memcpy((void *)tmp___11, (void const *)(& tmp), __len); l3_msg(pc->st, 544, (void *)skb); return; } } static void l3dss1_release_req(struct l3_process *pc , u_char pr , void *arg ) { { StopAllL3Timer(pc); newl3state(pc, 19); if ((int )((signed char )pc->prot.dss1.uus1_data[0]) == 0) { l3dss1_message(pc, 77); } else { l3dss1_msg_with_uus(pc, 77); } L3AddTimer(& pc->timer, 4000, 904); return; } } static void l3dss1_release_cmpl(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; int ret ; { skb = (struct sk_buff *)arg; ret = l3dss1_get_cause(pc, skb); if (ret > 0) { if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"RELCMPL get_cause ret(%d)", ret); } else if (ret < 0) { pc->para.cause = 254U; } else { } } else { } StopAllL3Timer(pc); newl3state(pc, 0); (*((pc->st)->l3.l3l4))(pc->st, 873, (void *)pc); dss1_release_l3_process(pc); return; } } static u_char *EncodeASyncParams(u_char *p , u_char si2 ) { { *p = 0U; *(p + 1UL) = 64U; *(p + 2UL) = 128U; if (((int )si2 & 32) != 0) { *(p + 2UL) = (unsigned int )*(p + 2UL) + 16U; } else { *(p + 2UL) = (unsigned int )*(p + 2UL) + 24U; } if (((int )si2 & 16) != 0) { *(p + 2UL) = (unsigned int )*(p + 2UL) + 96U; } else { *(p + 2UL) = (unsigned int )*(p + 2UL) + 32U; } if (((int )si2 & 8) != 0) { *(p + 2UL) = (unsigned int )*(p + 2UL) + 2U; } else { *(p + 2UL) = (unsigned int )*(p + 2UL) + 3U; } switch ((int )si2 & 7) { case 0: *p = 66U; goto ldv_41334; case 1: *p = 88U; goto ldv_41334; case 2: *p = 87U; goto ldv_41334; case 3: *p = 67U; goto ldv_41334; case 4: *p = 69U; goto ldv_41334; case 5: *p = 72U; goto ldv_41334; case 6: *p = 73U; goto ldv_41334; case 7: *p = 75U; goto ldv_41334; } ldv_41334: ; return (p + 3UL); } } static u_char EncodeSyncParams(u_char si2 , u_char ai ) { { switch ((int )si2) { case 0: ; return ((unsigned int )ai + 2U); case 1: ; return ((unsigned int )ai + 24U); case 2: ; return ((unsigned int )ai + 23U); case 3: ; return ((unsigned int )ai + 3U); case 4: ; return ((unsigned int )ai + 5U); case 5: ; return ((unsigned int )ai + 8U); case 6: ; return ((unsigned int )ai + 9U); case 7: ; return ((unsigned int )ai + 11U); case 8: ; return ((unsigned int )ai + 14U); case 9: ; return ((unsigned int )ai + 15U); case 15: ; return ((unsigned int )ai + 40U); default: ; goto ldv_41358; } ldv_41358: ; return (ai); } } static u_char DecodeASyncParams(u_char si2 , u_char *p ) { u_char info ; { switch ((int )*(p + 5UL)) { case 66: ; goto ldv_41365; case 88: si2 = (unsigned int )si2 + 1U; goto ldv_41365; case 87: si2 = (unsigned int )si2 + 2U; goto ldv_41365; case 67: si2 = (unsigned int )si2 + 3U; goto ldv_41365; case 69: si2 = (unsigned int )si2 + 4U; goto ldv_41365; case 72: si2 = (unsigned int )si2 + 5U; goto ldv_41365; case 73: si2 = (unsigned int )si2 + 6U; goto ldv_41365; case 75: si2 = (unsigned int )si2 + 7U; goto ldv_41365; } ldv_41365: info = (unsigned int )*(p + 7UL) & 127U; if (((int )info & 16) != 0 && ((int )info & 8) == 0) { si2 = (unsigned int )si2 + 32U; } else { } if (((int )info & 96) == 96) { si2 = (unsigned int )si2 + 16U; } else { } if (((int )info & 2) != 0 && ((int )info & 1) == 0) { si2 = (unsigned int )si2 + 8U; } else { } return (si2); } } static u_char DecodeSyncParams(u_char si2 , u_char info ) { { info = (unsigned int )info & 127U; switch ((int )info) { case 40: ; return ((unsigned int )si2 + 15U); case 15: ; return ((unsigned int )si2 + 9U); case 14: ; return ((unsigned int )si2 + 8U); case 11: ; return ((unsigned int )si2 + 7U); case 9: ; return ((unsigned int )si2 + 6U); case 8: ; return ((unsigned int )si2 + 5U); case 5: ; return ((unsigned int )si2 + 4U); case 3: ; return ((unsigned int )si2 + 3U); case 23: ; return ((unsigned int )si2 + 2U); case 24: ; return ((unsigned int )si2 + 1U); default: ; return (si2); } } } static u_char DecodeSI2(struct sk_buff *skb ) { u_char *p ; u_char tmp ; u_char tmp___0 ; u_char tmp___1 ; { p = findie(skb->data, (int )skb->len, 124, 0); if ((unsigned long )p != (unsigned long )((u_char *)0)) { switch ((int )*(p + 4UL) & 15) { case 1: ; if ((unsigned int )*(p + 1UL) == 4U) { tmp = DecodeSyncParams(160, (int )*(p + 5UL)); return (tmp); } else if ((unsigned int )*(p + 1UL) == 6U) { tmp___0 = DecodeASyncParams(192, p); return (tmp___0); } else { } goto ldv_41393; case 8: ; if ((unsigned int )*(p + 1UL) > 3U) { tmp___1 = DecodeSyncParams(176, (int )*(p + 5UL)); return (tmp___1); } else { } goto ldv_41393; } ldv_41393: ; } else { } return (0U); } } static void l3dss1_setup_req(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; u_char tmp[128U] ; u_char *p ; u_char channel ; u_char send_keypad ; u_char screen ; u_char *teln ; u_char *msn ; u_char *sub ; u_char *sp ; int l ; u_char *tmp___0 ; u_char *tmp___1 ; u_char *tmp___2 ; u_char *tmp___3 ; u_char *tmp___4 ; u_char *tmp___5 ; u_char *tmp___6 ; u_char *tmp___7 ; u_char *tmp___8 ; u_char *tmp___9 ; u_char *tmp___10 ; u_char *tmp___11 ; u_char *tmp___12 ; u_char *tmp___13 ; u_char *tmp___14 ; u_char *tmp___15 ; size_t tmp___16 ; u_char *tmp___17 ; u_char *tmp___18 ; u_char *tmp___19 ; u_char *tmp___20 ; u_char *tmp___21 ; u_char *tmp___22 ; u_char *tmp___23 ; size_t tmp___24 ; u_char *tmp___25 ; u_char *tmp___26 ; u_char *tmp___27 ; u_char *tmp___28 ; u_char *tmp___29 ; u_char *tmp___30 ; u_char *tmp___31 ; u_char *tmp___32 ; size_t tmp___33 ; u_char *tmp___34 ; u_char *tmp___35 ; u_char *tmp___36 ; u_char *tmp___37 ; u_char *tmp___38 ; u_char *tmp___39 ; size_t tmp___40 ; u_char *tmp___41 ; u_char *tmp___42 ; u_char *tmp___43 ; u_char *tmp___44 ; u_char *tmp___45 ; u_char *tmp___46 ; size_t tmp___47 ; u_char *tmp___48 ; u_char *tmp___49 ; u_char *tmp___50 ; u_char *tmp___51 ; u_char *tmp___52 ; u_char *tmp___53 ; u_char *tmp___54 ; u_char *tmp___55 ; u_char *tmp___56 ; u_char *tmp___57 ; u_char *tmp___58 ; u_char *tmp___59 ; u_char *tmp___60 ; u_char *tmp___61 ; u_char *tmp___62 ; u_char *tmp___63 ; u_char *tmp___64 ; u_char *tmp___65 ; u_char *tmp___66 ; u_char *tmp___67 ; u_char *tmp___68 ; u_char *tmp___69 ; size_t __len ; void *__ret ; unsigned char *tmp___71 ; { p = (u_char *)(& tmp); channel = 0U; screen = 128U; tmp___0 = p; p = p + 1; *tmp___0 = 8U; if (pc->callref == -1) { tmp___1 = p; p = p + 1; *tmp___1 = 0U; } else { tmp___2 = p; p = p + 1; *tmp___2 = 1U; tmp___3 = p; p = p + 1; *tmp___3 = (u_char )((int )((signed char )pc->callref) ^ -128); } tmp___4 = p; p = p + 1; *tmp___4 = 5U; teln = (u_char *)(& pc->para.setup.phone); send_keypad = 0U; switch ((int )pc->para.setup.si1) { case 1: tmp___5 = p; p = p + 1; *tmp___5 = 4U; tmp___6 = p; p = p + 1; *tmp___6 = 3U; tmp___7 = p; p = p + 1; *tmp___7 = 144U; tmp___8 = p; p = p + 1; *tmp___8 = 144U; tmp___9 = p; p = p + 1; *tmp___9 = 163U; goto ldv_41412; case 5: ; case 7: ; default: tmp___10 = p; p = p + 1; *tmp___10 = 4U; tmp___11 = p; p = p + 1; *tmp___11 = 2U; tmp___12 = p; p = p + 1; *tmp___12 = 136U; tmp___13 = p; p = p + 1; *tmp___13 = 144U; goto ldv_41412; } ldv_41412: ; if ((unsigned int )send_keypad != 0U) { tmp___14 = p; p = p + 1; *tmp___14 = 44U; tmp___15 = p; p = p + 1; tmp___16 = strlen((char const *)teln); *tmp___15 = (u_char )tmp___16; goto ldv_41417; ldv_41416: tmp___17 = p; p = p + 1; tmp___18 = teln; teln = teln + 1; *tmp___17 = (unsigned int )*tmp___18 & 127U; ldv_41417: ; if ((unsigned int )*teln != 0U) { goto ldv_41416; } else { } } else { } if ((unsigned int )*teln != 0U && (unsigned int )send_keypad == 0U) { if (((int )_ctype[(int )*teln] & 4) == 0) { switch ((int )*teln & 95) { case 67: channel = 8U; case 80: channel = (u_char )((unsigned int )channel | 128U); teln = teln + 1; if ((unsigned int )*teln == 49U) { channel = (u_char )((unsigned int )channel | 1U); } else { channel = (u_char )((unsigned int )channel | 2U); } goto ldv_41421; case 82: screen = 160U; goto ldv_41421; case 68: screen = 128U; goto ldv_41421; default: ; if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"Wrong MSN Code"); } else { } goto ldv_41421; } ldv_41421: teln = teln + 1; } else { } } else { } if ((unsigned int )channel != 0U) { tmp___19 = p; p = p + 1; *tmp___19 = 24U; tmp___20 = p; p = p + 1; *tmp___20 = 1U; tmp___21 = p; p = p + 1; *tmp___21 = channel; } else { } msn = (u_char *)(& pc->para.setup.eazmsn); sub = 0; sp = msn; goto ldv_41426; ldv_41425: ; if ((unsigned int )*sp == 46U) { sub = sp; *sp = 0U; } else { sp = sp + 1; } ldv_41426: ; if ((unsigned int )*sp != 0U) { goto ldv_41425; } else { } if ((unsigned int )*msn != 0U) { tmp___22 = p; p = p + 1; *tmp___22 = 108U; tmp___23 = p; p = p + 1; tmp___24 = strlen((char const *)msn); *tmp___23 = (unsigned int )((u_char )tmp___24) + ((unsigned int )screen != 0U ? 2U : 1U); if ((unsigned int )screen != 0U) { tmp___25 = p; p = p + 1; *tmp___25 = 1U; tmp___26 = p; p = p + 1; *tmp___26 = screen; } else { tmp___27 = p; p = p + 1; *tmp___27 = 129U; } goto ldv_41429; ldv_41428: tmp___28 = p; p = p + 1; tmp___29 = msn; msn = msn + 1; *tmp___28 = (unsigned int )*tmp___29 & 127U; ldv_41429: ; if ((unsigned int )*msn != 0U) { goto ldv_41428; } else { } } else { } if ((unsigned long )sub != (unsigned long )((u_char *)0)) { tmp___30 = sub; sub = sub + 1; *tmp___30 = 46U; tmp___31 = p; p = p + 1; *tmp___31 = 109U; tmp___32 = p; p = p + 1; tmp___33 = strlen((char const *)sub); *tmp___32 = (unsigned int )((u_char )tmp___33) + 2U; tmp___34 = p; p = p + 1; *tmp___34 = 128U; tmp___35 = p; p = p + 1; *tmp___35 = 80U; goto ldv_41432; ldv_41431: tmp___36 = p; p = p + 1; tmp___37 = sub; sub = sub + 1; *tmp___36 = (unsigned int )*tmp___37 & 127U; ldv_41432: ; if ((unsigned int )*sub != 0U) { goto ldv_41431; } else { } } else { } sub = 0; sp = teln; goto ldv_41435; ldv_41434: ; if ((unsigned int )*sp == 46U) { sub = sp; *sp = 0U; } else { sp = sp + 1; } ldv_41435: ; if ((unsigned int )*sp != 0U) { goto ldv_41434; } else { } if ((unsigned int )send_keypad == 0U) { tmp___38 = p; p = p + 1; *tmp___38 = 112U; tmp___39 = p; p = p + 1; tmp___40 = strlen((char const *)teln); *tmp___39 = (unsigned int )((u_char )tmp___40) + 1U; tmp___41 = p; p = p + 1; *tmp___41 = 129U; goto ldv_41438; ldv_41437: tmp___42 = p; p = p + 1; tmp___43 = teln; teln = teln + 1; *tmp___42 = (unsigned int )*tmp___43 & 127U; ldv_41438: ; if ((unsigned int )*teln != 0U) { goto ldv_41437; } else { } if ((unsigned long )sub != (unsigned long )((u_char *)0)) { tmp___44 = sub; sub = sub + 1; *tmp___44 = 46U; tmp___45 = p; p = p + 1; *tmp___45 = 113U; tmp___46 = p; p = p + 1; tmp___47 = strlen((char const *)sub); *tmp___46 = (unsigned int )((u_char )tmp___47) + 2U; tmp___48 = p; p = p + 1; *tmp___48 = 128U; tmp___49 = p; p = p + 1; *tmp___49 = 80U; goto ldv_41441; ldv_41440: tmp___50 = p; p = p + 1; tmp___51 = sub; sub = sub + 1; *tmp___50 = (unsigned int )*tmp___51 & 127U; ldv_41441: ; if ((unsigned int )*sub != 0U) { goto ldv_41440; } else { } } else { } } else { } if ((unsigned int )pc->para.setup.si2 > 159U && (unsigned int )pc->para.setup.si2 <= 175U) { tmp___52 = p; p = p + 1; *tmp___52 = 124U; tmp___53 = p; p = p + 1; *tmp___53 = 4U; tmp___54 = p; p = p + 1; *tmp___54 = 136U; tmp___55 = p; p = p + 1; *tmp___55 = 144U; tmp___56 = p; p = p + 1; *tmp___56 = 33U; tmp___57 = p; p = p + 1; *tmp___57 = EncodeSyncParams((int )((unsigned int )pc->para.setup.si2 + 96U), 128); } else if ((unsigned int )pc->para.setup.si2 > 175U && (unsigned int )pc->para.setup.si2 <= 191U) { tmp___58 = p; p = p + 1; *tmp___58 = 124U; tmp___59 = p; p = p + 1; *tmp___59 = 5U; tmp___60 = p; p = p + 1; *tmp___60 = 136U; tmp___61 = p; p = p + 1; *tmp___61 = 144U; tmp___62 = p; p = p + 1; *tmp___62 = 40U; tmp___63 = p; p = p + 1; *tmp___63 = EncodeSyncParams((int )((unsigned int )pc->para.setup.si2 + 80U), 0); tmp___64 = p; p = p + 1; *tmp___64 = 130U; } else if ((unsigned int )pc->para.setup.si2 > 191U) { tmp___65 = p; p = p + 1; *tmp___65 = 124U; tmp___66 = p; p = p + 1; *tmp___66 = 6U; tmp___67 = p; p = p + 1; *tmp___67 = 136U; tmp___68 = p; p = p + 1; *tmp___68 = 144U; tmp___69 = p; p = p + 1; *tmp___69 = 33U; p = EncodeASyncParams(p, (int )((unsigned int )pc->para.setup.si2 + 64U)); } else { } l = (int )((unsigned int )((long )p) - (unsigned int )((long )(& tmp))); skb = l3_alloc_skb(l); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } __len = (size_t )l; tmp___71 = skb_put(skb, (unsigned int )l); __ret = memcpy((void *)tmp___71, (void const *)(& tmp), __len); L3DelTimer(& pc->timer); L3AddTimer(& pc->timer, 4000, 899); newl3state(pc, 1); l3_msg(pc->st, 544, (void *)skb); return; } } static void l3dss1_call_proc(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; int id___0 ; int ret ; { skb = (struct sk_buff *)arg; id___0 = l3dss1_get_channel_id(pc, skb); if (id___0 >= 0) { if (id___0 == 0 || (id___0 == 3 && (unsigned int )pc->para.moderate == 16U)) { if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"setup answer with wrong chid %x", id___0); } else { } pc->para.cause = 100U; l3dss1_status_send(pc, (int )pr, 0); return; } else { } pc->para.bchannel = id___0; } else if (pc->state == 1) { if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"setup answer wrong chid (ret %d)", id___0); } else { } if (id___0 == -1) { pc->para.cause = 96U; } else { pc->para.cause = 100U; } l3dss1_status_send(pc, (int )pr, 0); return; } else { } ret = check_infoelements(pc, skb, (int *)(& ie_CALL_PROCEEDING)); if (ret == 1) { l3dss1_std_ie_err(pc, ret); return; } else { } L3DelTimer(& pc->timer); newl3state(pc, 3); L3AddTimer(& pc->timer, 30000, 912); if (ret != 0) { l3dss1_std_ie_err(pc, ret); } else { } (*((pc->st)->l3.l3l4))(pc->st, 834, (void *)pc); return; } } static void l3dss1_setup_ack(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; int id___0 ; int ret ; { skb = (struct sk_buff *)arg; id___0 = l3dss1_get_channel_id(pc, skb); if (id___0 >= 0) { if (id___0 == 0 || (id___0 == 3 && (unsigned int )pc->para.moderate == 16U)) { if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"setup answer with wrong chid %x", id___0); } else { } pc->para.cause = 100U; l3dss1_status_send(pc, (int )pr, 0); return; } else { } pc->para.bchannel = id___0; } else { if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"setup answer wrong chid (ret %d)", id___0); } else { } if (id___0 == -1) { pc->para.cause = 96U; } else { pc->para.cause = 100U; } l3dss1_status_send(pc, (int )pr, 0); return; } ret = check_infoelements(pc, skb, (int *)(& ie_SETUP_ACKNOWLEDGE)); if (ret == 1) { l3dss1_std_ie_err(pc, ret); return; } else { } L3DelTimer(& pc->timer); newl3state(pc, 2); L3AddTimer(& pc->timer, 30000, 900); if (ret != 0) { l3dss1_std_ie_err(pc, ret); } else { } (*((pc->st)->l3.l3l4))(pc->st, 786, (void *)pc); return; } } static void l3dss1_disconnect(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; u_char *p ; int ret ; u_char cause ; { skb = (struct sk_buff *)arg; cause = 0U; StopAllL3Timer(pc); ret = l3dss1_get_cause(pc, skb); if (ret != 0) { if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"DISC get_cause ret(%d)", ret); } else { } if (ret < 0) { cause = 96U; } else if (ret > 0) { cause = 100U; } else { } } else { } p = findie(skb->data, (int )skb->len, 28, 0); if ((unsigned long )p != (unsigned long )((u_char *)0)) { l3dss1_parse_facility(pc->st, pc, pc->callref, p); } else { } ret = check_infoelements(pc, skb, (int *)(& ie_DISCONNECT)); if (ret == 1) { cause = 96U; } else if ((unsigned int )cause == 0U && ret == -1) { cause = 99U; } else { } ret = pc->state; newl3state(pc, 12); if ((unsigned int )cause != 0U) { newl3state(pc, 19); } else { } if (ret != 11) { (*((pc->st)->l3.l3l4))(pc->st, 866, (void *)pc); } else if ((unsigned int )cause == 0U) { l3dss1_release_req(pc, (int )pr, 0); } else { } if ((unsigned int )cause != 0U) { l3dss1_message_cause(pc, 77, (int )cause); L3AddTimer(& pc->timer, 4000, 904); } else { } return; } } static void l3dss1_connect(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; int ret ; { skb = (struct sk_buff *)arg; ret = check_infoelements(pc, skb, (int *)(& ie_CONNECT)); if (ret == 1) { l3dss1_std_ie_err(pc, ret); return; } else { } L3DelTimer(& pc->timer); newl3state(pc, 10); pc->para.chargeinfo = 0; if (ret != 0) { l3dss1_std_ie_err(pc, ret); } else { } (*((pc->st)->l3.l3l4))(pc->st, 769, (void *)pc); return; } } static void l3dss1_alerting(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; int ret ; { skb = (struct sk_buff *)arg; ret = check_infoelements(pc, skb, (int *)(& ie_ALERTING)); if (ret == 1) { l3dss1_std_ie_err(pc, ret); return; } else { } L3DelTimer(& pc->timer); newl3state(pc, 4); if (ret != 0) { l3dss1_std_ie_err(pc, ret); } else { } (*((pc->st)->l3.l3l4))(pc->st, 838, (void *)pc); return; } } static void l3dss1_setup(struct l3_process *pc , u_char pr , void *arg ) { u_char *p ; int bcfound ; char tmp[80U] ; struct sk_buff *skb ; int id___0 ; int err ; int tmp___0 ; { bcfound = 0; skb = (struct sk_buff *)arg; err = 0; p = skb->data; p = findie(p, (int )skb->len, 4, 0); if ((unsigned long )p != (unsigned long )((u_char *)0)) { if ((unsigned int )*(p + 1UL) <= 1U || (unsigned int )*(p + 1UL) > 11U) { err = 1; } else { pc->para.setup.si2 = 0U; switch ((int )*(p + 2UL) & 127) { case 0: ; case 16: pc->para.setup.si1 = 1U; goto ldv_41498; case 8: pc->para.setup.si1 = 7U; pc->para.setup.si2 = DecodeSI2(skb); goto ldv_41498; case 9: pc->para.setup.si1 = 2U; goto ldv_41498; case 17: pc->para.setup.si1 = 3U; goto ldv_41498; case 24: pc->para.setup.si1 = 4U; goto ldv_41498; default: err = 2; goto ldv_41498; } ldv_41498: ; switch ((int )*(p + 3UL) & 127) { case 64: pc->para.setup.si1 = 8U; goto ldv_41505; case 16: ; case 17: ; case 19: ; case 21: ; case 23: pc->para.moderate = (unsigned int )*(p + 3UL) & 127U; goto ldv_41505; default: err = 3; goto ldv_41505; } ldv_41505: ; } if ((pc->debug & 32) != 0) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"SI=%d, AI=%d", (int )pc->para.setup.si1, (int )pc->para.setup.si2); } else { } if (err != 0) { if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"setup with wrong bearer(l=%d:%x,%x)", (int )*(p + 1UL), (int )*(p + 2UL), (int )*(p + 3UL)); } else { } pc->para.cause = 100U; l3dss1_msg_without_setup(pc, (int )pr, 0); return; } else { } } else { if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"setup without bearer capabilities"); } else { } pc->para.cause = 96U; l3dss1_msg_without_setup(pc, (int )pr, 0); return; } id___0 = l3dss1_get_channel_id(pc, skb); if (id___0 >= 0) { tmp___0 = id___0; pc->para.bchannel = tmp___0; if (tmp___0 != 0) { if (id___0 == 3 && (unsigned int )pc->para.moderate == 16U) { if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"setup with wrong chid %x", id___0); } else { } pc->para.cause = 100U; l3dss1_msg_without_setup(pc, (int )pr, 0); return; } else { } bcfound = bcfound + 1; } else { if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"setup without bchannel, call waiting"); } else { } bcfound = bcfound + 1; } } else { if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"setup with wrong chid ret %d", id___0); } else { } if (id___0 == -1) { pc->para.cause = 96U; } else { pc->para.cause = 100U; } l3dss1_msg_without_setup(pc, (int )pr, 0); return; } err = check_infoelements(pc, skb, (int *)(& ie_SETUP)); if (err == 1) { pc->para.cause = 96U; l3dss1_msg_without_setup(pc, (int )pr, 0); return; } else { } p = skb->data; p = findie(p, (int )skb->len, 112, 0); if ((unsigned long )p != (unsigned long )((u_char *)0)) { iecpy((u_char *)(& pc->para.setup.eazmsn), p, 1); } else { pc->para.setup.eazmsn[0] = 0U; } p = skb->data; p = findie(p, (int )skb->len, 113, 0); if ((unsigned long )p != (unsigned long )((u_char *)0)) { if (((unsigned int )*(p + 1UL) > 1U && (unsigned int )*(p + 2UL) == 128U) && (unsigned int )*(p + 3UL) == 80U) { tmp[0] = 46; iecpy((u_char *)(& tmp) + 1U, p, 2); strcat((char *)(& pc->para.setup.eazmsn), (char const *)(& tmp)); } else if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"wrong called subaddress"); } else { } } else { } p = skb->data; p = findie(p, (int )skb->len, 108, 0); if ((unsigned long )p != (unsigned long )((u_char *)0)) { pc->para.setup.plan = *(p + 2UL); if ((int )((signed char )*(p + 2UL)) < 0) { iecpy((u_char *)(& pc->para.setup.phone), p, 1); pc->para.setup.screen = 0U; } else { iecpy((u_char *)(& pc->para.setup.phone), p, 2); pc->para.setup.screen = *(p + 3UL); } } else { pc->para.setup.phone[0] = 0U; pc->para.setup.plan = 0U; pc->para.setup.screen = 0U; } p = skb->data; p = findie(p, (int )skb->len, 109, 0); if ((unsigned long )p != (unsigned long )((u_char *)0)) { if (((unsigned int )*(p + 1UL) > 1U && (unsigned int )*(p + 2UL) == 128U) && (unsigned int )*(p + 3UL) == 80U) { tmp[0] = 46; iecpy((u_char *)(& tmp) + 1U, p, 2); strcat((char *)(& pc->para.setup.phone), (char const *)(& tmp)); } else if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"wrong calling subaddress"); } else { } } else { } newl3state(pc, 6); if (err != 0) { l3dss1_std_ie_err(pc, err); } else { } (*((pc->st)->l3.l3l4))(pc->st, 770, (void *)pc); return; } } static void l3dss1_reset(struct l3_process *pc , u_char pr , void *arg ) { { dss1_release_l3_process(pc); return; } } static void l3dss1_disconnect_req(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; u_char tmp[56U] ; u_char *p ; int l ; u_char cause ; u_char *tmp___0 ; u_char *tmp___1 ; u_char *tmp___2 ; u_char *tmp___3 ; u_char *tmp___4 ; u_char *tmp___5 ; u_char *tmp___6 ; u_char *tmp___7 ; u_char *tmp___8 ; u_char *tmp___9 ; u_char *tmp___10 ; size_t tmp___11 ; u_char *tmp___12 ; size_t tmp___13 ; size_t __len ; void *__ret ; unsigned char *tmp___15 ; { p = (u_char *)(& tmp); cause = 16U; if ((unsigned int )pc->para.cause != 254U) { cause = pc->para.cause; } else { } StopAllL3Timer(pc); tmp___0 = p; p = p + 1; *tmp___0 = 8U; if (pc->callref == -1) { tmp___1 = p; p = p + 1; *tmp___1 = 0U; } else { tmp___2 = p; p = p + 1; *tmp___2 = 1U; tmp___3 = p; p = p + 1; *tmp___3 = (u_char )((int )((signed char )pc->callref) ^ -128); } tmp___4 = p; p = p + 1; *tmp___4 = 69U; tmp___5 = p; p = p + 1; *tmp___5 = 8U; tmp___6 = p; p = p + 1; *tmp___6 = 2U; tmp___7 = p; p = p + 1; *tmp___7 = 128U; tmp___8 = p; p = p + 1; *tmp___8 = (u_char )((unsigned int )cause | 128U); if ((int )((signed char )pc->prot.dss1.uus1_data[0]) != 0) { tmp___9 = p; p = p + 1; *tmp___9 = 126U; tmp___10 = p; p = p + 1; tmp___11 = strlen((char const *)(& pc->prot.dss1.uus1_data)); *tmp___10 = (unsigned int )((u_char )tmp___11) + 1U; tmp___12 = p; p = p + 1; *tmp___12 = 4U; strcpy((char *)p, (char const *)(& pc->prot.dss1.uus1_data)); tmp___13 = strlen((char const *)(& pc->prot.dss1.uus1_data)); p = p + tmp___13; pc->prot.dss1.uus1_data[0] = 0; } else { } l = (int )((unsigned int )((long )p) - (unsigned int )((long )(& tmp))); skb = l3_alloc_skb(l); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } __len = (size_t )l; tmp___15 = skb_put(skb, (unsigned int )l); __ret = memcpy((void *)tmp___15, (void const *)(& tmp), __len); newl3state(pc, 11); l3_msg(pc->st, 544, (void *)skb); L3AddTimer(& pc->timer, 30000, 901); return; } } static void l3dss1_setup_rsp(struct l3_process *pc , u_char pr , void *arg ) { { if (pc->para.bchannel == 0) { if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"D-chan connect for waiting call"); } else { } l3dss1_disconnect_req(pc, (int )pr, arg); return; } else { } newl3state(pc, 8); l3dss1_message(pc, 7); L3DelTimer(& pc->timer); L3AddTimer(& pc->timer, 4000, 915); return; } } static void l3dss1_connect_ack(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; int ret ; { skb = (struct sk_buff *)arg; ret = check_infoelements(pc, skb, (int *)(& ie_CONNECT_ACKNOWLEDGE)); if (ret == 1) { l3dss1_std_ie_err(pc, ret); return; } else { } newl3state(pc, 10); L3DelTimer(& pc->timer); if (ret != 0) { l3dss1_std_ie_err(pc, ret); } else { } (*((pc->st)->l3.l3l4))(pc->st, 818, (void *)pc); return; } } static void l3dss1_reject_req(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; u_char tmp[16U] ; u_char *p ; int l ; u_char cause ; u_char *tmp___0 ; u_char *tmp___1 ; u_char *tmp___2 ; u_char *tmp___3 ; u_char *tmp___4 ; u_char *tmp___5 ; u_char *tmp___6 ; u_char *tmp___7 ; u_char *tmp___8 ; size_t __len ; void *__ret ; unsigned char *tmp___10 ; { p = (u_char *)(& tmp); cause = 21U; if ((unsigned int )pc->para.cause != 254U) { cause = pc->para.cause; } else { } tmp___0 = p; p = p + 1; *tmp___0 = 8U; if (pc->callref == -1) { tmp___1 = p; p = p + 1; *tmp___1 = 0U; } else { tmp___2 = p; p = p + 1; *tmp___2 = 1U; tmp___3 = p; p = p + 1; *tmp___3 = (u_char )((int )((signed char )pc->callref) ^ -128); } tmp___4 = p; p = p + 1; *tmp___4 = 90U; tmp___5 = p; p = p + 1; *tmp___5 = 8U; tmp___6 = p; p = p + 1; *tmp___6 = 2U; tmp___7 = p; p = p + 1; *tmp___7 = 128U; tmp___8 = p; p = p + 1; *tmp___8 = (u_char )((unsigned int )cause | 128U); l = (int )((unsigned int )((long )p) - (unsigned int )((long )(& tmp))); skb = l3_alloc_skb(l); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } __len = (size_t )l; tmp___10 = skb_put(skb, (unsigned int )l); __ret = memcpy((void *)tmp___10, (void const *)(& tmp), __len); l3_msg(pc->st, 544, (void *)skb); (*((pc->st)->l3.l3l4))(pc->st, 874, (void *)pc); newl3state(pc, 0); dss1_release_l3_process(pc); return; } } static void l3dss1_release(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; u_char *p ; int ret ; int cause ; { skb = (struct sk_buff *)arg; cause = 0; StopAllL3Timer(pc); ret = l3dss1_get_cause(pc, skb); if (ret > 0) { if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"REL get_cause ret(%d)", ret); } else if (ret < 0) { pc->para.cause = 254U; } else { } } else { } p = findie(skb->data, (int )skb->len, 28, 0); if ((unsigned long )p != (unsigned long )((u_char *)0)) { l3dss1_parse_facility(pc->st, pc, pc->callref, p); } else { } if (ret < 0 && pc->state != 11) { cause = 96; } else if (ret > 0) { cause = 100; } else { } ret = check_infoelements(pc, skb, (int *)(& ie_RELEASE)); if (ret == 1) { cause = 96; } else if (ret == -1 && cause == 0) { cause = 99; } else { } if (cause != 0) { l3dss1_message_cause(pc, 90, (int )((u_char )cause)); } else { l3dss1_message(pc, 90); } (*((pc->st)->l3.l3l4))(pc->st, 874, (void *)pc); newl3state(pc, 0); dss1_release_l3_process(pc); return; } } static void l3dss1_alert_req(struct l3_process *pc , u_char pr , void *arg ) { { newl3state(pc, 7); if ((int )((signed char )pc->prot.dss1.uus1_data[0]) == 0) { l3dss1_message(pc, 1); } else { l3dss1_msg_with_uus(pc, 1); } return; } } static void l3dss1_proceed_req(struct l3_process *pc , u_char pr , void *arg ) { { newl3state(pc, 9); l3dss1_message(pc, 2); (*((pc->st)->l3.l3l4))(pc->st, 886, (void *)pc); return; } } static void l3dss1_setup_ack_req(struct l3_process *pc , u_char pr , void *arg ) { { newl3state(pc, 25); L3DelTimer(& pc->timer); L3AddTimer(& pc->timer, 15000, 898); l3dss1_message(pc, 13); return; } } static void l3dss1_deliver_display(struct l3_process *pc , int pr , u_char *infp ) { u_char len ; isdn_ctrl ic ; struct IsdnCardState *cs ; char *p ; u_char *tmp ; u_char *tmp___0 ; char *tmp___1 ; u_char *tmp___2 ; u_char tmp___3 ; { tmp = infp; infp = infp + 1; if ((unsigned int )*tmp != 40U) { return; } else { } tmp___0 = infp; infp = infp + 1; len = *tmp___0; if ((unsigned int )len > 80U) { return; } else { } if ((unsigned long )pc->chan == (unsigned long )((struct Channel *)0)) { return; } else { } p = (char *)(& ic.parm.display); goto ldv_41589; ldv_41588: tmp___1 = p; p = p + 1; tmp___2 = infp; infp = infp + 1; *tmp___1 = (char )*tmp___2; ldv_41589: tmp___3 = len; len = (u_char )((int )len - 1); if ((unsigned int )tmp___3 != 0U) { goto ldv_41588; } else { } *p = 0; ic.command = 274; cs = (struct IsdnCardState *)(pc->st)->l1.hardware; ic.driver = cs->myid; ic.arg = (ulong )(pc->chan)->chan; (*(cs->iif.statcallb))(& ic); return; } } static void l3dss1_progress(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; int err ; u_char *p ; { skb = (struct sk_buff *)arg; err = 0; p = findie(skb->data, (int )skb->len, 30, 0); if ((unsigned long )p != (unsigned long )((u_char *)0)) { if ((unsigned int )*(p + 1UL) != 2U) { err = 1; pc->para.cause = 100U; } else if (((int )*(p + 2UL) & 112) == 0) { switch ((int )*(p + 2UL)) { case 128: ; case 129: ; case 130: ; case 132: ; case 133: ; case 135: ; case 138: ; switch ((int )*(p + 3UL)) { case 129: ; case 130: ; case 131: ; case 132: ; case 136: ; goto ldv_41611; default: err = 2; pc->para.cause = 100U; goto ldv_41611; } ldv_41611: ; goto ldv_41613; default: err = 3; pc->para.cause = 100U; goto ldv_41613; } ldv_41613: ; } else { pc->para.cause = 96U; err = 4; } } else { } if (err != 0) { if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"progress error %d", err); } else { } l3dss1_status_send(pc, (int )pr, 0); return; } else { } err = check_infoelements(pc, skb, (int *)(& ie_PROGRESS)); if (err != 0) { l3dss1_std_ie_err(pc, err); } else { } if (err != 1) { (*((pc->st)->l3.l3l4))(pc->st, 842, (void *)pc); } else { } return; } } static void l3dss1_notify(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; int err ; u_char *p ; { skb = (struct sk_buff *)arg; err = 0; p = findie(skb->data, (int )skb->len, 39, 0); if ((unsigned long )p != (unsigned long )((u_char *)0)) { if ((unsigned int )*(p + 1UL) != 1U) { err = 1; pc->para.cause = 100U; } else { switch ((int )*(p + 2UL)) { case 128: ; case 129: ; case 130: ; goto ldv_41626; default: pc->para.cause = 100U; err = 2; goto ldv_41626; } ldv_41626: ; } } else { pc->para.cause = 96U; err = 3; } if (err != 0) { if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"notify error %d", err); } else { } l3dss1_status_send(pc, (int )pr, 0); return; } else { } err = check_infoelements(pc, skb, (int *)(& ie_NOTIFY)); if (err != 0) { l3dss1_std_ie_err(pc, err); } else { } if (err != 1) { (*((pc->st)->l3.l3l4))(pc->st, 858, (void *)pc); } else { } return; } } static void l3dss1_status_enq(struct l3_process *pc , u_char pr , void *arg ) { int ret ; struct sk_buff *skb ; { skb = (struct sk_buff *)arg; ret = check_infoelements(pc, skb, (int *)(& ie_STATUS_ENQUIRY)); l3dss1_std_ie_err(pc, ret); pc->para.cause = 30U; l3dss1_status_send(pc, (int )pr, 0); return; } } static void l3dss1_information(struct l3_process *pc , u_char pr , void *arg ) { int ret ; struct sk_buff *skb ; u_char *p ; char tmp[32U] ; { skb = (struct sk_buff *)arg; ret = check_infoelements(pc, skb, (int *)(& ie_INFORMATION)); if (ret != 0) { l3dss1_std_ie_err(pc, ret); } else { } if (pc->state == 25) { L3DelTimer(& pc->timer); p = skb->data; p = findie(p, (int )skb->len, 112, 0); if ((unsigned long )p != (unsigned long )((u_char *)0)) { iecpy((u_char *)(& tmp), p, 1); strcat((char *)(& pc->para.setup.eazmsn), (char const *)(& tmp)); (*((pc->st)->l3.l3l4))(pc->st, 786, (void *)pc); } else { } L3AddTimer(& pc->timer, 15000, 898); } else { } return; } } static void l3dss1_redir_req(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; u_char tmp[128U] ; u_char *p ; u_char *subp ; u_char len_phone ; u_char len_sub ; int l ; unsigned char tmp___0 ; u_char *tmp___1 ; u_char *tmp___2 ; u_char *tmp___3 ; u_char *tmp___4 ; u_char *tmp___5 ; size_t tmp___6 ; u_char *tmp___7 ; u_char *tmp___8 ; u_char *tmp___9 ; u_char *tmp___10 ; u_char *tmp___11 ; u_char *tmp___12 ; u_char *tmp___13 ; u_char *tmp___14 ; u_char *tmp___15 ; u_char *tmp___16 ; u_char *tmp___17 ; u_char *tmp___18 ; u_char *tmp___19 ; u_char *tmp___20 ; u_char *tmp___21 ; u_char *tmp___22 ; u_char *tmp___23 ; u_char *tmp___24 ; u_char *tmp___25 ; u_char *tmp___26 ; u_char *tmp___27 ; u_char *tmp___28 ; u_char *tmp___29 ; u_char *tmp___30 ; u_char *tmp___31 ; u_char *tmp___32 ; size_t __len ; void *__ret ; unsigned char *tmp___34 ; { p = (u_char *)(& tmp); len_phone = 0U; len_sub = 0U; strcpy((char *)(& pc->prot.dss1.uus1_data), (char const *)(& (pc->chan)->setup.eazmsn)); if ((unsigned int )(pc->chan)->setup.phone[0] == 0U) { pc->para.cause = 255U; l3dss1_disconnect_req(pc, (int )pr, arg); return; } else { } if ((unsigned int )pc->prot.dss1.invoke_id != 0U) { free_invoke_id(pc->st, (int )pc->prot.dss1.invoke_id); } else { } tmp___0 = new_invoke_id(pc->st); pc->prot.dss1.invoke_id = tmp___0; if ((unsigned int )tmp___0 == 0U) { return; } else { } tmp___1 = p; p = p + 1; *tmp___1 = 8U; if (pc->callref == -1) { tmp___2 = p; p = p + 1; *tmp___2 = 0U; } else { tmp___3 = p; p = p + 1; *tmp___3 = 1U; tmp___4 = p; p = p + 1; *tmp___4 = (u_char )((int )((signed char )pc->callref) ^ -128); } tmp___5 = p; p = p + 1; *tmp___5 = 98U; subp = (u_char *)(& (pc->chan)->setup.phone); goto ldv_41657; ldv_41656: len_phone = (u_char )((int )len_phone + 1); subp = subp + 1; ldv_41657: ; if ((unsigned int )*subp != 0U && (unsigned int )*subp != 46U) { goto ldv_41656; } else { } tmp___7 = subp; subp = subp + 1; if ((unsigned int )*tmp___7 == 46U) { tmp___6 = strlen((char const *)subp); len_sub = (unsigned int )((u_char )tmp___6) + 2U; } else { } tmp___8 = p; p = p + 1; *tmp___8 = 28U; tmp___9 = p; p = p + 1; *tmp___9 = (unsigned int )((int )len_phone + (int )len_sub) + 18U; tmp___10 = p; p = p + 1; *tmp___10 = 145U; tmp___11 = p; p = p + 1; *tmp___11 = 161U; tmp___12 = p; p = p + 1; *tmp___12 = (unsigned int )((int )len_phone + (int )len_sub) + 15U; tmp___13 = p; p = p + 1; *tmp___13 = 2U; tmp___14 = p; p = p + 1; *tmp___14 = 1U; tmp___15 = p; p = p + 1; *tmp___15 = pc->prot.dss1.invoke_id; tmp___16 = p; p = p + 1; *tmp___16 = 2U; tmp___17 = p; p = p + 1; *tmp___17 = 1U; tmp___18 = p; p = p + 1; *tmp___18 = 13U; tmp___19 = p; p = p + 1; *tmp___19 = 48U; tmp___20 = p; p = p + 1; *tmp___20 = (unsigned int )((int )len_phone + (int )len_sub) + 7U; tmp___21 = p; p = p + 1; *tmp___21 = 48U; tmp___22 = p; p = p + 1; *tmp___22 = (unsigned int )((int )len_phone + (int )len_sub) + 2U; tmp___23 = p; p = p + 1; *tmp___23 = 128U; tmp___24 = p; p = p + 1; *tmp___24 = len_phone; l = 0; goto ldv_41660; ldv_41659: tmp___25 = p; p = p + 1; *tmp___25 = (pc->chan)->setup.phone[l]; l = l + 1; ldv_41660: ; if ((int )len_phone > l) { goto ldv_41659; } else { } if ((unsigned int )len_sub != 0U) { tmp___26 = p; p = p + 1; *tmp___26 = 4U; tmp___27 = p; p = p + 1; *tmp___27 = (unsigned int )len_sub + 254U; goto ldv_41663; ldv_41662: tmp___28 = p; p = p + 1; tmp___29 = subp; subp = subp + 1; *tmp___28 = *tmp___29; ldv_41663: ; if ((unsigned int )*subp != 0U) { goto ldv_41662; } else { } } else { } tmp___30 = p; p = p + 1; *tmp___30 = 1U; tmp___31 = p; p = p + 1; *tmp___31 = 1U; tmp___32 = p; p = p + 1; *tmp___32 = (pc->chan)->setup.screen; l = (int )((unsigned int )((long )p) - (unsigned int )((long )(& tmp))); skb = l3_alloc_skb(l); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } __len = (size_t )l; tmp___34 = skb_put(skb, (unsigned int )l); __ret = memcpy((void *)tmp___34, (void const *)(& tmp), __len); l3_msg(pc->st, 544, (void *)skb); return; } } static void l3dss1_redir_req_early(struct l3_process *pc , u_char pr , void *arg ) { { l3dss1_proceed_req(pc, (int )pr, arg); l3dss1_redir_req(pc, (int )pr, arg); return; } } static int l3dss1_cmd_global(struct PStack *st , isdn_ctrl *ic ) { u_char id___0 ; u_char temp[265U] ; u_char *p ; int i ; int l ; int proc_len ; struct sk_buff *skb ; struct l3_process *pc ; u_char *tmp ; u_char *tmp___0 ; u_char *tmp___1 ; u_char *tmp___2 ; u_char *tmp___3 ; u_char *tmp___4 ; u_char *tmp___5 ; u_char *tmp___6 ; u_char *tmp___7 ; u_char *tmp___8 ; u_char *tmp___9 ; u_char *tmp___10 ; u_char *tmp___11 ; u_char *tmp___12 ; u_char *tmp___13 ; u_char *tmp___14 ; size_t __len ; void *__ret ; size_t __len___0 ; void *__ret___0 ; unsigned char *tmp___16 ; { p = (u_char *)(& temp); pc = 0; switch (ic->arg) { case 2UL: ; if (ic->parm.isdn_io.datalen < 0) { return (-2); } else { } proc_len = 1; i = ic->parm.isdn_io.proc >> 8; goto ldv_41687; ldv_41686: i = i >> 8; i = i + 1; ldv_41687: ; if (i != 0) { goto ldv_41686; } else { } l = (ic->parm.isdn_io.datalen + proc_len) + 8; if (l > 255) { return (-2); } else { } id___0 = new_invoke_id(st); if ((unsigned int )id___0 == 0U) { return (0); } else { } i = -1; tmp = p; p = p + 1; *tmp = 8U; if (i == -1) { tmp___0 = p; p = p + 1; *tmp___0 = 0U; } else { tmp___1 = p; p = p + 1; *tmp___1 = 1U; tmp___2 = p; p = p + 1; *tmp___2 = (u_char )((int )((signed char )i) ^ -128); } tmp___3 = p; p = p + 1; *tmp___3 = 98U; tmp___4 = p; p = p + 1; *tmp___4 = 28U; tmp___5 = p; p = p + 1; *tmp___5 = (u_char )l; tmp___6 = p; p = p + 1; *tmp___6 = 145U; tmp___7 = p; p = p + 1; *tmp___7 = 161U; tmp___8 = p; p = p + 1; *tmp___8 = (unsigned int )((u_char )l) + 253U; tmp___9 = p; p = p + 1; *tmp___9 = 2U; tmp___10 = p; p = p + 1; *tmp___10 = 1U; tmp___11 = p; p = p + 1; *tmp___11 = id___0; tmp___12 = p; p = p + 1; *tmp___12 = 2U; tmp___13 = p; p = p + 1; *tmp___13 = (u_char )proc_len; i = proc_len; goto ldv_41690; ldv_41689: tmp___14 = p; p = p + 1; *tmp___14 = (u_char )(ic->parm.isdn_io.proc >> (i + -1)); i = i - 1; ldv_41690: ; if (i != 0) { goto ldv_41689; } else { } __len = (size_t )ic->parm.isdn_io.datalen; __ret = memcpy((void *)p, (void const *)ic->parm.isdn_io.data, __len); l = (int )(((unsigned int )((long )p) - (unsigned int )((long )(& temp))) + (unsigned int )ic->parm.isdn_io.datalen); if (ic->parm.isdn_io.timeout > 0) { pc = dss1_new_l3_process(st, -1); if ((unsigned long )pc == (unsigned long )((struct l3_process *)0)) { free_invoke_id(st, (int )id___0); return (-2); } else { } } else { } pc->prot.dss1.ll_id = ic->parm.isdn_io.ll_id; pc->prot.dss1.proc = ic->parm.isdn_io.proc; skb = l3_alloc_skb(l); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { free_invoke_id(st, (int )id___0); if ((unsigned long )pc != (unsigned long )((struct l3_process *)0)) { dss1_release_l3_process(pc); } else { } return (-2); } else { } __len___0 = (size_t )l; tmp___16 = skb_put(skb, (unsigned int )l); __ret___0 = memcpy((void *)tmp___16, (void const *)(& temp), __len___0); if ((unsigned long )pc != (unsigned long )((struct l3_process *)0)) { pc->prot.dss1.invoke_id = id___0; L3AddTimer(& pc->timer, ic->parm.isdn_io.timeout, 5108); } else { } l3_msg(st, 544, (void *)skb); ic->parm.isdn_io.hl_id = (int )id___0; return (0); case 258UL: pc = l3dss1_search_dummy_proc(st, ic->parm.isdn_io.hl_id); if ((unsigned long )pc != (unsigned long )((struct l3_process *)0)) { L3DelTimer(& pc->timer); dss1_release_l3_process(pc); return (0); } else { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"l3dss1_cmd_global abort unknown id"); return (-2); } default: HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"l3dss1_cmd_global unknown cmd 0x%lx", ic->arg); return (-1); } return (-1); } } static void l3dss1_io_timer(struct l3_process *pc ) { isdn_ctrl ic ; struct IsdnCardState *cs ; { cs = (struct IsdnCardState *)(pc->st)->l1.hardware; L3DelTimer(& pc->timer); ic.driver = cs->myid; ic.command = 273; ic.arg = 33026UL; ic.parm.isdn_io.hl_id = (int )pc->prot.dss1.invoke_id; ic.parm.isdn_io.ll_id = pc->prot.dss1.ll_id; ic.parm.isdn_io.proc = pc->prot.dss1.proc; ic.parm.isdn_io.timeout = -1; ic.parm.isdn_io.datalen = 0; ic.parm.isdn_io.data = 0; free_invoke_id(pc->st, (int )pc->prot.dss1.invoke_id); pc->prot.dss1.invoke_id = 0U; (*(cs->iif.statcallb))(& ic); dss1_release_l3_process(pc); return; } } static void l3dss1_release_ind(struct l3_process *pc , u_char pr , void *arg ) { u_char *p ; struct sk_buff *skb ; int callState ; u_char *tmp ; { skb = (struct sk_buff *)arg; callState = 0; p = skb->data; p = findie(p, (int )skb->len, 20, 0); if ((unsigned long )p != (unsigned long )((u_char *)0)) { p = p + 1; tmp = p; p = p + 1; if ((unsigned int )*tmp == 1U) { callState = (int )*p; } else { } } else { } if (callState == 0) { (*((pc->st)->l3.l3l4))(pc->st, 874, (void *)pc); newl3state(pc, 0); dss1_release_l3_process(pc); } else { (*((pc->st)->l3.l3l4))(pc->st, 802, (void *)pc); } return; } } static void l3dss1_dummy(struct l3_process *pc , u_char pr , void *arg ) { { return; } } static void l3dss1_t302(struct l3_process *pc , u_char pr , void *arg ) { { L3DelTimer(& pc->timer); pc->para.loc = 0U; pc->para.cause = 28U; l3dss1_disconnect_req(pc, (int )pr, 0); (*((pc->st)->l3.l3l4))(pc->st, 993, (void *)pc); return; } } static void l3dss1_t303(struct l3_process *pc , u_char pr , void *arg ) { { if (pc->N303 > 0) { pc->N303 = pc->N303 - 1; L3DelTimer(& pc->timer); l3dss1_setup_req(pc, (int )pr, arg); } else { L3DelTimer(& pc->timer); l3dss1_message_cause(pc, 90, 102); (*((pc->st)->l3.l3l4))(pc->st, 992, (void *)pc); dss1_release_l3_process(pc); } return; } } static void l3dss1_t304(struct l3_process *pc , u_char pr , void *arg ) { { L3DelTimer(& pc->timer); pc->para.loc = 0U; pc->para.cause = 102U; l3dss1_disconnect_req(pc, (int )pr, 0); (*((pc->st)->l3.l3l4))(pc->st, 993, (void *)pc); return; } } static void l3dss1_t305(struct l3_process *pc , u_char pr , void *arg ) { u_char tmp[16U] ; u_char *p ; int l ; struct sk_buff *skb ; u_char cause ; u_char *tmp___0 ; u_char *tmp___1 ; u_char *tmp___2 ; u_char *tmp___3 ; u_char *tmp___4 ; u_char *tmp___5 ; u_char *tmp___6 ; u_char *tmp___7 ; u_char *tmp___8 ; size_t __len ; void *__ret ; unsigned char *tmp___10 ; { p = (u_char *)(& tmp); cause = 16U; L3DelTimer(& pc->timer); if ((unsigned int )pc->para.cause != 254U) { cause = pc->para.cause; } else { } tmp___0 = p; p = p + 1; *tmp___0 = 8U; if (pc->callref == -1) { tmp___1 = p; p = p + 1; *tmp___1 = 0U; } else { tmp___2 = p; p = p + 1; *tmp___2 = 1U; tmp___3 = p; p = p + 1; *tmp___3 = (u_char )((int )((signed char )pc->callref) ^ -128); } tmp___4 = p; p = p + 1; *tmp___4 = 77U; tmp___5 = p; p = p + 1; *tmp___5 = 8U; tmp___6 = p; p = p + 1; *tmp___6 = 2U; tmp___7 = p; p = p + 1; *tmp___7 = 128U; tmp___8 = p; p = p + 1; *tmp___8 = (u_char )((unsigned int )cause | 128U); l = (int )((unsigned int )((long )p) - (unsigned int )((long )(& tmp))); skb = l3_alloc_skb(l); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } __len = (size_t )l; tmp___10 = skb_put(skb, (unsigned int )l); __ret = memcpy((void *)tmp___10, (void const *)(& tmp), __len); newl3state(pc, 19); l3_msg(pc->st, 544, (void *)skb); L3AddTimer(& pc->timer, 4000, 904); return; } } static void l3dss1_t310(struct l3_process *pc , u_char pr , void *arg ) { { L3DelTimer(& pc->timer); pc->para.loc = 0U; pc->para.cause = 102U; l3dss1_disconnect_req(pc, (int )pr, 0); (*((pc->st)->l3.l3l4))(pc->st, 993, (void *)pc); return; } } static void l3dss1_t313(struct l3_process *pc , u_char pr , void *arg ) { { L3DelTimer(& pc->timer); pc->para.loc = 0U; pc->para.cause = 102U; l3dss1_disconnect_req(pc, (int )pr, 0); (*((pc->st)->l3.l3l4))(pc->st, 996, (void *)pc); return; } } static void l3dss1_t308_1(struct l3_process *pc , u_char pr , void *arg ) { { newl3state(pc, 19); L3DelTimer(& pc->timer); l3dss1_message(pc, 77); L3AddTimer(& pc->timer, 4000, 906); return; } } static void l3dss1_t308_2(struct l3_process *pc , u_char pr , void *arg ) { { L3DelTimer(& pc->timer); (*((pc->st)->l3.l3l4))(pc->st, 997, (void *)pc); dss1_release_l3_process(pc); return; } } static void l3dss1_t318(struct l3_process *pc , u_char pr , void *arg ) { { L3DelTimer(& pc->timer); pc->para.cause = 102U; pc->para.loc = 0U; (*((pc->st)->l3.l3l4))(pc->st, 995, (void *)pc); newl3state(pc, 19); l3dss1_message(pc, 77); L3AddTimer(& pc->timer, 4000, 904); return; } } static void l3dss1_t319(struct l3_process *pc , u_char pr , void *arg ) { { L3DelTimer(& pc->timer); pc->para.cause = 102U; pc->para.loc = 0U; (*((pc->st)->l3.l3l4))(pc->st, 994, (void *)pc); newl3state(pc, 10); return; } } static void l3dss1_restart(struct l3_process *pc , u_char pr , void *arg ) { { L3DelTimer(& pc->timer); (*((pc->st)->l3.l3l4))(pc->st, 874, (void *)pc); dss1_release_l3_process(pc); return; } } static void l3dss1_status(struct l3_process *pc , u_char pr , void *arg ) { u_char *p ; struct sk_buff *skb ; int ret ; u_char cause ; u_char callState ; int tmp ; u_char *tmp___0 ; u_char tmp___1 ; { skb = (struct sk_buff *)arg; cause = 0U; callState = 0U; ret = l3dss1_get_cause(pc, skb); if (ret != 0) { if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"STATUS get_cause ret(%d)", ret); } else { } if (ret < 0) { cause = 96U; } else if (ret > 0) { cause = 100U; } else { } } else { } p = findie(skb->data, (int )skb->len, 20, 0); if ((unsigned long )p != (unsigned long )((u_char *)0)) { p = p + 1; tmp___0 = p; p = p + 1; if ((unsigned int )*tmp___0 == 1U) { callState = *p; tmp = ie_in_set(pc, (int )*p, (int *)(& l3_valid_states)); if (tmp == 0) { cause = 100U; } else { } } else { cause = 100U; } } else { cause = 96U; } if ((unsigned int )cause == 0U) { ret = check_infoelements(pc, skb, (int *)(& ie_STATUS)); if (ret == 1) { cause = 96U; } else if (ret == -1) { cause = 99U; } else { } } else { } if ((unsigned int )cause != 0U) { if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"STATUS error(%d/%d)", ret, (int )cause); } else { } tmp___1 = pc->para.cause; pc->para.cause = cause; l3dss1_status_send(pc, 0, 0); if ((unsigned int )cause == 99U) { pc->para.cause = tmp___1; } else { return; } } else { } cause = pc->para.cause; if (((int )cause & 127) == 111 && (unsigned int )callState == 0U) { (*((pc->st)->l3.l3l4))(pc->st, 874, (void *)pc); newl3state(pc, 0); dss1_release_l3_process(pc); } else { } return; } } static void l3dss1_facility(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; int ret ; u_char *p ; { skb = (struct sk_buff *)arg; ret = check_infoelements(pc, skb, (int *)(& ie_FACILITY)); l3dss1_std_ie_err(pc, ret); p = findie(skb->data, (int )skb->len, 28, 0); if ((unsigned long )p != (unsigned long )((u_char *)0)) { l3dss1_parse_facility(pc->st, pc, pc->callref, p); } else { } return; } } static void l3dss1_suspend_req(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; u_char tmp[32U] ; u_char *p ; u_char i ; u_char l ; u_char *msg ; u_char *tmp___0 ; u_char *tmp___1 ; u_char *tmp___2 ; u_char *tmp___3 ; u_char *tmp___4 ; u_char *tmp___5 ; u_char *tmp___6 ; u_char *tmp___7 ; u_char *tmp___8 ; u_char *tmp___9 ; size_t __len ; void *__ret ; unsigned char *tmp___11 ; { p = (u_char *)(& tmp); msg = (u_char *)(& (pc->chan)->setup.phone); tmp___0 = p; p = p + 1; *tmp___0 = 8U; if (pc->callref == -1) { tmp___1 = p; p = p + 1; *tmp___1 = 0U; } else { tmp___2 = p; p = p + 1; *tmp___2 = 1U; tmp___3 = p; p = p + 1; *tmp___3 = (u_char )((int )((signed char )pc->callref) ^ -128); } tmp___4 = p; p = p + 1; *tmp___4 = 37U; tmp___5 = msg; msg = msg + 1; l = *tmp___5; if ((unsigned int )l != 0U && (unsigned int )l <= 10U) { tmp___6 = p; p = p + 1; *tmp___6 = 16U; tmp___7 = p; p = p + 1; *tmp___7 = l; i = 0U; goto ldv_41812; ldv_41811: tmp___8 = p; p = p + 1; tmp___9 = msg; msg = msg + 1; *tmp___8 = *tmp___9; i = (u_char )((int )i + 1); ldv_41812: ; if ((int )i < (int )l) { goto ldv_41811; } else { } } else if ((unsigned int )l != 0U) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"SUS wrong CALL_ID len %d", (int )l); return; } else { } l = (int )((u_char )((long )p)) - (int )((u_char )((long )(& tmp))); skb = l3_alloc_skb((int )l); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } __len = (size_t )l; tmp___11 = skb_put(skb, (unsigned int )l); __ret = memcpy((void *)tmp___11, (void const *)(& tmp), __len); l3_msg(pc->st, 544, (void *)skb); newl3state(pc, 15); L3AddTimer(& pc->timer, 4000, 921); return; } } static void l3dss1_suspend_ack(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; int ret ; { skb = (struct sk_buff *)arg; L3DelTimer(& pc->timer); newl3state(pc, 0); pc->para.cause = 254U; (*((pc->st)->l3.l3l4))(pc->st, 881, (void *)pc); ret = check_infoelements(pc, skb, (int *)(& ie_SUSPEND_ACKNOWLEDGE)); if (ret != 0) { if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"SUSPACK check ie(%d)", ret); } else { } } else { } dss1_release_l3_process(pc); return; } } static void l3dss1_suspend_rej(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; int ret ; { skb = (struct sk_buff *)arg; ret = l3dss1_get_cause(pc, skb); if (ret != 0) { if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"SUSP_REJ get_cause ret(%d)", ret); } else { } if (ret < 0) { pc->para.cause = 96U; } else { pc->para.cause = 100U; } l3dss1_status_send(pc, (int )pr, 0); return; } else { } ret = check_infoelements(pc, skb, (int *)(& ie_SUSPEND_REJECT)); if (ret == 1) { l3dss1_std_ie_err(pc, ret); return; } else { } L3DelTimer(& pc->timer); (*((pc->st)->l3.l3l4))(pc->st, 994, (void *)pc); newl3state(pc, 10); if (ret != 0) { l3dss1_std_ie_err(pc, ret); } else { } return; } } static void l3dss1_resume_req(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; u_char tmp[32U] ; u_char *p ; u_char i ; u_char l ; u_char *msg ; u_char *tmp___0 ; u_char *tmp___1 ; u_char *tmp___2 ; u_char *tmp___3 ; u_char *tmp___4 ; u_char *tmp___5 ; u_char *tmp___6 ; u_char *tmp___7 ; u_char *tmp___8 ; u_char *tmp___9 ; size_t __len ; void *__ret ; unsigned char *tmp___11 ; { p = (u_char *)(& tmp); msg = (u_char *)(& pc->para.setup.phone); tmp___0 = p; p = p + 1; *tmp___0 = 8U; if (pc->callref == -1) { tmp___1 = p; p = p + 1; *tmp___1 = 0U; } else { tmp___2 = p; p = p + 1; *tmp___2 = 1U; tmp___3 = p; p = p + 1; *tmp___3 = (u_char )((int )((signed char )pc->callref) ^ -128); } tmp___4 = p; p = p + 1; *tmp___4 = 38U; tmp___5 = msg; msg = msg + 1; l = *tmp___5; if ((unsigned int )l != 0U && (unsigned int )l <= 10U) { tmp___6 = p; p = p + 1; *tmp___6 = 16U; tmp___7 = p; p = p + 1; *tmp___7 = l; i = 0U; goto ldv_41843; ldv_41842: tmp___8 = p; p = p + 1; tmp___9 = msg; msg = msg + 1; *tmp___8 = *tmp___9; i = (u_char )((int )i + 1); ldv_41843: ; if ((int )i < (int )l) { goto ldv_41842; } else { } } else if ((unsigned int )l != 0U) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"RES wrong CALL_ID len %d", (int )l); return; } else { } l = (int )((u_char )((long )p)) - (int )((u_char )((long )(& tmp))); skb = l3_alloc_skb((int )l); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } __len = (size_t )l; tmp___11 = skb_put(skb, (unsigned int )l); __ret = memcpy((void *)tmp___11, (void const *)(& tmp), __len); l3_msg(pc->st, 544, (void *)skb); newl3state(pc, 17); L3AddTimer(& pc->timer, 4000, 920); return; } } static void l3dss1_resume_ack(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; int id___0 ; int ret ; { skb = (struct sk_buff *)arg; id___0 = l3dss1_get_channel_id(pc, skb); if (id___0 > 0) { if (id___0 == 0 || (id___0 == 3 && (unsigned int )pc->para.moderate == 16U)) { if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"resume ack with wrong chid %x", id___0); } else { } pc->para.cause = 100U; l3dss1_status_send(pc, (int )pr, 0); return; } else { } pc->para.bchannel = id___0; } else if (pc->state == 1) { if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"resume ack without chid (ret %d)", id___0); } else { } pc->para.cause = 96U; l3dss1_status_send(pc, (int )pr, 0); return; } else { } ret = check_infoelements(pc, skb, (int *)(& ie_RESUME_ACKNOWLEDGE)); if (ret == 1) { l3dss1_std_ie_err(pc, ret); return; } else { } L3DelTimer(& pc->timer); (*((pc->st)->l3.l3l4))(pc->st, 773, (void *)pc); newl3state(pc, 10); if (ret != 0) { l3dss1_std_ie_err(pc, ret); } else { } return; } } static void l3dss1_resume_rej(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; int ret ; { skb = (struct sk_buff *)arg; ret = l3dss1_get_cause(pc, skb); if (ret != 0) { if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"RES_REJ get_cause ret(%d)", ret); } else { } if (ret < 0) { pc->para.cause = 96U; } else { pc->para.cause = 100U; } l3dss1_status_send(pc, (int )pr, 0); return; } else { } ret = check_infoelements(pc, skb, (int *)(& ie_RESUME_REJECT)); if (ret == 1) { l3dss1_std_ie_err(pc, ret); return; } else { } L3DelTimer(& pc->timer); (*((pc->st)->l3.l3l4))(pc->st, 995, (void *)pc); newl3state(pc, 0); if (ret != 0) { l3dss1_std_ie_err(pc, ret); } else { } dss1_release_l3_process(pc); return; } } static void l3dss1_global_restart(struct l3_process *pc , u_char pr , void *arg ) { u_char tmp[32U] ; u_char *p ; u_char ri ; u_char ch ; u_char chan ; int l ; struct sk_buff *skb ; struct l3_process *up___0 ; u_char *tmp___0 ; u_char *tmp___1 ; u_char *tmp___2 ; u_char *tmp___3 ; u_char *tmp___4 ; u_char *tmp___5 ; u_char *tmp___6 ; u_char *tmp___7 ; u_char *tmp___8 ; u_char *tmp___9 ; u_char *tmp___10 ; size_t __len ; void *__ret ; unsigned char *tmp___12 ; { ch = 0U; chan = 0U; skb = (struct sk_buff *)arg; newl3state(pc, 2); L3DelTimer(& pc->timer); p = skb->data; p = findie(p, (int )skb->len, 121, 0); if ((unsigned long )p != (unsigned long )((u_char *)0)) { ri = *(p + 2UL); HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"Restart %x", (int )ri); } else { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"Restart without restart IE"); ri = 134U; } p = skb->data; p = findie(p, (int )skb->len, 24, 0); if ((unsigned long )p != (unsigned long )((u_char *)0)) { chan = (unsigned int )*(p + 2UL) & 3U; ch = *(p + 2UL); if ((pc->st)->l3.debug != 0) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"Restart for channel %d", (int )chan); } else { } } else { } newl3state(pc, 2); up___0 = (pc->st)->l3.proc; goto ldv_41877; ldv_41876: ; if (((int )ri & 7) == 7) { (*((up___0->st)->lli.l4l3))(up___0->st, 1012, (void *)up___0); } else if (up___0->para.bchannel == (int )chan) { (*((up___0->st)->lli.l4l3))(up___0->st, 1012, (void *)up___0); } else { } up___0 = up___0->next; ldv_41877: ; if ((unsigned long )up___0 != (unsigned long )((struct l3_process *)0)) { goto ldv_41876; } else { } p = (u_char *)(& tmp); tmp___0 = p; p = p + 1; *tmp___0 = 8U; if (pc->callref == -1) { tmp___1 = p; p = p + 1; *tmp___1 = 0U; } else { tmp___2 = p; p = p + 1; *tmp___2 = 1U; tmp___3 = p; p = p + 1; *tmp___3 = (u_char )((int )((signed char )pc->callref) ^ -128); } tmp___4 = p; p = p + 1; *tmp___4 = 78U; if ((unsigned int )chan != 0U) { tmp___5 = p; p = p + 1; *tmp___5 = 24U; tmp___6 = p; p = p + 1; *tmp___6 = 1U; tmp___7 = p; p = p + 1; *tmp___7 = (u_char )((unsigned int )ch | 128U); } else { } tmp___8 = p; p = p + 1; *tmp___8 = 121U; tmp___9 = p; p = p + 1; *tmp___9 = 1U; tmp___10 = p; p = p + 1; *tmp___10 = ri; l = (int )((unsigned int )((long )p) - (unsigned int )((long )(& tmp))); skb = l3_alloc_skb(l); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } __len = (size_t )l; tmp___12 = skb_put(skb, (unsigned int )l); __ret = memcpy((void *)tmp___12, (void const *)(& tmp), __len); newl3state(pc, 0); l3_msg(pc->st, 544, (void *)skb); return; } } static void l3dss1_dl_reset(struct l3_process *pc , u_char pr , void *arg ) { { pc->para.cause = 41U; pc->para.loc = 0U; l3dss1_disconnect_req(pc, (int )pr, 0); (*((pc->st)->l3.l3l4))(pc->st, 993, (void *)pc); return; } } static void l3dss1_dl_release(struct l3_process *pc , u_char pr , void *arg ) { { newl3state(pc, 0); pc->para.cause = 27U; pc->para.loc = 0U; (*((pc->st)->l3.l3l4))(pc->st, 874, (void *)pc); release_l3_process(pc); return; } } static void l3dss1_dl_reestablish(struct l3_process *pc , u_char pr , void *arg ) { { L3DelTimer(& pc->timer); L3AddTimer(& pc->timer, 40000, 777); l3_msg(pc->st, 512, 0); return; } } static void l3dss1_dl_reest_status(struct l3_process *pc , u_char pr , void *arg ) { { L3DelTimer(& pc->timer); pc->para.cause = 31U; l3dss1_status_send(pc, 0, 0); return; } } static struct stateentry downstatelist[27U] = { {1, 768, & l3dss1_setup_req}, {1, 772, & l3dss1_resume_req}, {33556446, 864, & l3dss1_disconnect_req}, {4096, 872, & l3dss1_release_req}, {67108863, 1012, & l3dss1_restart}, {33554496, 800, & l3dss1_reset}, {33554496, 804, & l3dss1_reject_req}, {33554496, 884, & l3dss1_proceed_req}, {64, 784, & l3dss1_setup_ack_req}, {33554432, 784, & l3dss1_dummy}, {33555008, 836, & l3dss1_alert_req}, {33555136, 771, & l3dss1_setup_rsp}, {1024, 880, & l3dss1_suspend_req}, {33555072, 888, & l3dss1_redir_req}, {64, 888, & l3dss1_redir_req_early}, {33554944, 864, & l3dss1_disconnect_req}, {33554432, 898, & l3dss1_t302}, {2, 899, & l3dss1_t303}, {4, 900, & l3dss1_t304}, {8, 912, & l3dss1_t310}, {256, 915, & l3dss1_t313}, {2048, 901, & l3dss1_t305}, {32768, 921, & l3dss1_t319}, {131072, 920, & l3dss1_t318}, {524288, 904, & l3dss1_t308_1}, {524288, 906, & l3dss1_t308_2}, {1024, 777, & l3dss1_dl_release}}; static struct stateentry datastatelist[23U] = { {67108863, 117, & l3dss1_status_enq}, {67108863, 98, & l3dss1_facility}, {524288, 125, & l3dss1_release_ind}, {67108863, 125, & l3dss1_status}, {1, 5, & l3dss1_setup}, {34250688, 5, & l3dss1_dummy}, {6, 2, & l3dss1_call_proc}, {2, 13, & l3dss1_setup_ack}, {12, 1, & l3dss1_alerting}, {12, 3, & l3dss1_progress}, {34250652, 123, & l3dss1_information}, {35840, 110, & l3dss1_notify}, {34250143, 90, & l3dss1_release_cmpl}, {33726366, 77, & l3dss1_release}, {524288, 77, & l3dss1_release_ind}, {33722270, 69, & l3dss1_disconnect}, {524288, 69, & l3dss1_dummy}, {30, 7, & l3dss1_connect}, {256, 15, & l3dss1_connect_ack}, {32768, 45, & l3dss1_suspend_ack}, {32768, 33, & l3dss1_suspend_rej}, {131072, 46, & l3dss1_resume_ack}, {131072, 34, & l3dss1_resume_rej}}; static struct stateentry globalmes_list[2U] = { {67108863, 125, & l3dss1_status}, {1, 70, & l3dss1_global_restart}}; static struct stateentry manstatelist[4U] = { {4, 514, & l3dss1_dl_reset}, {1024, 513, & l3dss1_dl_reest_status}, {1024, 530, & l3dss1_dl_reestablish}, {67108863, 530, & l3dss1_dl_release}}; static void global_handler(struct PStack *st , int mt , struct sk_buff *skb ) { u_char tmp[16U] ; u_char *p ; int l ; int i ; struct l3_process *proc ; u_char *tmp___0 ; u_char *tmp___1 ; u_char *tmp___2 ; u_char *tmp___3 ; u_char *tmp___4 ; u_char *tmp___5 ; u_char *tmp___6 ; u_char *tmp___7 ; u_char *tmp___8 ; u_char *tmp___9 ; u_char *tmp___10 ; u_char *tmp___11 ; size_t __len ; void *__ret ; unsigned char *tmp___13 ; { p = (u_char *)(& tmp); proc = st->l3.global; proc->callref = (int )*(skb->data + 2UL); i = 0; goto ldv_41920; ldv_41919: ; if (globalmes_list[i].primitive == mt && (globalmes_list[i].state >> proc->state) & 1) { goto ldv_41918; } else { } i = i + 1; ldv_41920: ; if ((unsigned int )i <= 1U) { goto ldv_41919; } else { } ldv_41918: ; if (i == 2) { if ((st->l3.debug & 4) != 0) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"dss1 global state %d mt %x unhandled", proc->state, mt); } else { } tmp___0 = p; p = p + 1; *tmp___0 = 8U; if (proc->callref == -1) { tmp___1 = p; p = p + 1; *tmp___1 = 0U; } else { tmp___2 = p; p = p + 1; *tmp___2 = 1U; tmp___3 = p; p = p + 1; *tmp___3 = (u_char )((int )((signed char )proc->callref) ^ -128); } tmp___4 = p; p = p + 1; *tmp___4 = 125U; tmp___5 = p; p = p + 1; *tmp___5 = 8U; tmp___6 = p; p = p + 1; *tmp___6 = 2U; tmp___7 = p; p = p + 1; *tmp___7 = 128U; tmp___8 = p; p = p + 1; *tmp___8 = 209U; tmp___9 = p; p = p + 1; *tmp___9 = 20U; tmp___10 = p; p = p + 1; *tmp___10 = 1U; tmp___11 = p; p = p + 1; *tmp___11 = (unsigned int )((u_char )proc->state) & 63U; l = (int )((unsigned int )((long )p) - (unsigned int )((long )(& tmp))); skb = l3_alloc_skb(l); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } __len = (size_t )l; tmp___13 = skb_put(skb, (unsigned int )l); __ret = memcpy((void *)tmp___13, (void const *)(& tmp), __len); l3_msg(proc->st, 544, (void *)skb); } else { if ((st->l3.debug & 4) != 0) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"dss1 global %d mt %x", proc->state, mt); } else { } (*(globalmes_list[i].rout))(proc, (int )((u8 )mt), (void *)skb); } return; } } static void dss1up(struct PStack *st , int pr , void *arg ) { int i ; int mt ; int cr ; int callState ; char *ptr ; u_char *p ; struct sk_buff *skb ; struct l3_process *proc ; char *tmp ; u_char *tmp___0 ; char *tmp___1 ; u_char *tmp___2 ; int tmp___3 ; { skb = (struct sk_buff *)arg; switch (pr) { case 546: ; case 562: ; goto ldv_41941; case 513: ; case 514: ; case 530: ; case 529: l3_msg(st, pr, arg); return; default: printk("\vHiSax dss1up unknown pr=%04x\n", pr); return; } ldv_41941: ; if (skb->len <= 2U) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"dss1up frame too short(%d)", skb->len); consume_skb(skb); return; } else { } if ((unsigned int )*(skb->data) != 8U) { if ((st->l3.debug & 2) != 0) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"dss1up%sunexpected discriminator %x message len %d", pr == 546 ? (char *)" " : (char *)"(broadcast) ", (int )*(skb->data), skb->len); } else { } consume_skb(skb); return; } else { } cr = getcallref(skb->data); if (skb->len < (unsigned int )(((int )*(skb->data + 1UL) & 15) + 3)) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"dss1up frame too short(%d)", skb->len); consume_skb(skb); return; } else { } mt = (int )*(skb->data + ((unsigned long )*(skb->data + 1UL) + 2UL)); if ((st->l3.debug & 4) != 0) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"dss1up cr %d", cr); } else { } if (cr == -2) { if (st->l3.debug & 1) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"dss1up wrong Callref"); } else { } consume_skb(skb); return; } else if (cr == -1) { if (mt == 98) { p = findie(skb->data, (int )skb->len, 28, 0); if ((unsigned long )p != (unsigned long )((u_char *)0)) { l3dss1_parse_facility(st, 0, pr == 546 ? -1 : -2, p); consume_skb(skb); return; } else { } } else { } if (st->l3.debug & 1) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"dss1up dummy Callref (no facility msg or ie)"); } else { } consume_skb(skb); return; } else if ((((int )*(skb->data + 1UL) & 15) == 1 && (cr & 127) == 0) || (((int )*(skb->data + 1UL) & 15) == 2 && (cr & 32767) == 0)) { if ((st->l3.debug & 4) != 0) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"dss1up Global CallRef"); } else { } global_handler(st, mt, skb); consume_skb(skb); return; } else { proc = getl3proc(st, cr); if ((unsigned long )proc == (unsigned long )((struct l3_process *)0)) { if (mt == 5) { if ((int )((signed char )*(skb->data + 2UL)) < 0) { if ((st->l3.debug & 4) != 0) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"dss1up wrong CRef flag"); } else { } consume_skb(skb); return; } else { } proc = dss1_new_l3_process(st, cr); if ((unsigned long )proc == (unsigned long )((struct l3_process *)0)) { consume_skb(skb); return; } else { } } else if (mt == 125) { tmp___0 = findie(skb->data, (int )skb->len, 8, 0); ptr = (char *)tmp___0; if ((unsigned long )ptr != (unsigned long )((char *)0)) { ptr = ptr + 1; tmp = ptr; ptr = ptr + 1; if ((int )((signed char )*tmp) == 2) { ptr = ptr + 1; } else { } } else { } callState = 0; tmp___2 = findie(skb->data, (int )skb->len, 20, 0); ptr = (char *)tmp___2; if ((unsigned long )ptr != (unsigned long )((char *)0)) { ptr = ptr + 1; tmp___1 = ptr; ptr = ptr + 1; if ((int )((signed char )*tmp___1) == 2) { ptr = ptr + 1; } else { } callState = (int )*ptr; } else { } if (callState != 0) { proc = dss1_new_l3_process(st, cr); if ((unsigned long )proc != (unsigned long )((struct l3_process *)0)) { proc->para.cause = 101U; l3dss1_msg_without_setup(proc, 0, 0); } else { } } else { } consume_skb(skb); return; } else if (mt == 90) { consume_skb(skb); return; } else { consume_skb(skb); proc = dss1_new_l3_process(st, cr); if ((unsigned long )proc != (unsigned long )((struct l3_process *)0)) { proc->para.cause = 81U; l3dss1_msg_without_setup(proc, 0, 0); } else { } return; } } else { } } tmp___3 = l3dss1_check_messagetype_validity(proc, mt, (void *)skb); if (tmp___3 != 0) { consume_skb(skb); return; } else { } p = findie(skb->data, (int )skb->len, 40, 0); if ((unsigned long )p != (unsigned long )((u_char *)0)) { l3dss1_deliver_display(proc, pr, p); } else { } i = 0; goto ldv_41951; ldv_41950: ; if (datastatelist[i].primitive == mt && (datastatelist[i].state >> proc->state) & 1) { goto ldv_41949; } else { } i = i + 1; ldv_41951: ; if ((unsigned int )i <= 22U) { goto ldv_41950; } else { } ldv_41949: ; if (i == 23) { if ((st->l3.debug & 4) != 0) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"dss1up%sstate %d mt %#x unhandled", pr == 546 ? (char *)" " : (char *)"(broadcast) ", proc->state, mt); } else { } if (mt != 90 && mt != 77) { proc->para.cause = 101U; l3dss1_status_send(proc, (int )((u_char )pr), (void *)skb); } else { } } else { if ((st->l3.debug & 4) != 0) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"dss1up%sstate %d mt %x", pr == 546 ? (char *)" " : (char *)"(broadcast) ", proc->state, mt); } else { } (*(datastatelist[i].rout))(proc, (int )((u8 )pr), (void *)skb); } consume_skb(skb); return; } } static void dss1down(struct PStack *st , int pr , void *arg ) { int i ; int cr ; struct l3_process *proc ; struct Channel *chan ; size_t __len ; void *__ret ; { if (pr == 512) { l3_msg(st, pr, 0); return; } else if (pr == 768 || pr == 772) { chan = (struct Channel *)arg; cr = newcallref(); cr = cr | 128; proc = dss1_new_l3_process(st, cr); if ((unsigned long )proc != (unsigned long )((struct l3_process *)0)) { proc->chan = chan; chan->proc = proc; __len = 68UL; if (__len > 63UL) { __ret = memcpy((void *)(& proc->para.setup), (void const *)(& chan->setup), __len); } else { __ret = memcpy((void *)(& proc->para.setup), (void const *)(& chan->setup), __len); } proc->callref = cr; } else { } } else { proc = (struct l3_process *)arg; } if ((unsigned long )proc == (unsigned long )((struct l3_process *)0)) { printk("\vHiSax dss1down without proc pr=%04x\n", pr); return; } else { } if (pr == 5108) { l3dss1_io_timer(proc); return; } else { } i = 0; goto ldv_41970; ldv_41969: ; if (downstatelist[i].primitive == pr && (downstatelist[i].state >> proc->state) & 1) { goto ldv_41968; } else { } i = i + 1; ldv_41970: ; if ((unsigned int )i <= 26U) { goto ldv_41969; } else { } ldv_41968: ; if (i == 27) { if ((st->l3.debug & 4) != 0) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"dss1down state %d prim %#x unhandled", proc->state, pr); } else { if ((st->l3.debug & 4) != 0) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"dss1down state %d prim %#x", proc->state, pr); } else { } (*(downstatelist[i].rout))(proc, (int )((u8 )pr), arg); } } else { } return; } } static void dss1man(struct PStack *st , int pr , void *arg ) { int i ; struct l3_process *proc ; { proc = (struct l3_process *)arg; if ((unsigned long )proc == (unsigned long )((struct l3_process *)0)) { printk("\vHiSax dss1man without proc pr=%04x\n", pr); return; } else { } i = 0; goto ldv_41984; ldv_41983: ; if (manstatelist[i].primitive == pr && (manstatelist[i].state >> proc->state) & 1) { goto ldv_41982; } else { } i = i + 1; ldv_41984: ; if ((unsigned int )i <= 3U) { goto ldv_41983; } else { } ldv_41982: ; if (i == 4) { if ((st->l3.debug & 4) != 0) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"cr %d dss1man state %d prim %#x unhandled", proc->callref & 127, proc->state, pr); } else { if ((st->l3.debug & 4) != 0) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"cr %d dss1man state %d prim %#x", proc->callref & 127, proc->state, pr); } else { } (*(manstatelist[i].rout))(proc, (int )((u8 )pr), arg); } } else { } return; } } void setstack_dss1(struct PStack *st ) { char tmp[64U] ; int i ; int tmp___0 ; struct l3_process *tmp___1 ; void *tmp___2 ; char *tmp___3 ; { st->lli.l4l3 = & dss1down; st->lli.l4l3_proto = & l3dss1_cmd_global; st->l2.l2l3 = & dss1up; st->l3.l3ml3 = & dss1man; st->l3.N303 = 1; st->prot.dss1.last_invoke_id = 0U; st->prot.dss1.invoke_used[0] = 1U; i = 1; goto ldv_41993; ldv_41992: tmp___0 = i; i = i + 1; st->prot.dss1.invoke_used[tmp___0] = 0U; ldv_41993: ; if (i <= 31) { goto ldv_41992; } else { } tmp___2 = kmalloc(360UL, 32U); tmp___1 = (struct l3_process *)tmp___2; st->l3.global = tmp___1; if ((unsigned long )tmp___1 == (unsigned long )((struct l3_process *)0)) { printk("\vHiSax can\'t get memory for dss1 global CR\n"); } else { (st->l3.global)->state = 0; (st->l3.global)->callref = 0; (st->l3.global)->next = 0; (st->l3.global)->debug = 1; (st->l3.global)->st = st; (st->l3.global)->N303 = 1; (st->l3.global)->prot.dss1.invoke_id = 0U; L3InitTimer(st->l3.global, & (st->l3.global)->timer); } strcpy((char *)(& tmp), dss1_revision); tmp___3 = HiSax_getrev((char const *)(& tmp)); printk("\016HiSax: DSS1 Rev. %s\n", tmp___3); return; } } void ldv_mutex_lock_127(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_lock(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_128(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_lock(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_129(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } int ldv_mutex_trylock_130(struct mutex *ldv_func_arg1 ) { ldv_func_ret_type___2 ldv_func_res ; int tmp ; int tmp___0 ; { tmp = mutex_trylock(ldv_func_arg1); ldv_func_res = tmp; tmp___0 = ldv_mutex_trylock_mutex(ldv_func_arg1); return (tmp___0); return (ldv_func_res); } } void ldv_mutex_unlock_131(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_132(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_cred_guard_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_133(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_cred_guard_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } int ldv_mutex_trylock_144(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_142(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_145(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_147(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_141(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_143(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_146(struct mutex *ldv_func_arg1 ) ; static char const *ni1_revision = "$Revision: 2.8.2.3 $"; static unsigned char new_invoke_id___0(struct PStack *p ) { unsigned char retval ; int i ; { i = 32; retval = (unsigned int )p->prot.ni1.last_invoke_id + 1U; goto ldv_41000; ldv_40999: p->prot.ni1.last_invoke_id = ((unsigned int )retval & 248U) + 8U; i = i - 1; ldv_41000: ; if (i != 0 && (unsigned int )p->prot.ni1.invoke_used[(int )retval >> 3] == 255U) { goto ldv_40999; } else { } if (i != 0) { goto ldv_41003; ldv_41002: retval = (unsigned char )((int )retval + 1); ldv_41003: ; if (((int )p->prot.ni1.invoke_used[(int )retval >> 3] >> ((int )retval & 7)) & 1) { goto ldv_41002; } else { } } else { retval = 0U; } p->prot.ni1.last_invoke_id = retval; p->prot.ni1.invoke_used[(int )retval >> 3] = (unsigned char )((int )((signed char )p->prot.ni1.invoke_used[(int )retval >> 3]) | (int )((signed char )(1 << ((int )retval & 7)))); return (retval); } } static void free_invoke_id___0(struct PStack *p , unsigned char id___0 ) { { if ((unsigned int )id___0 == 0U) { return; } else { } p->prot.ni1.invoke_used[(int )id___0 >> 3] = (unsigned char )((int )((signed char )p->prot.ni1.invoke_used[(int )id___0 >> 3]) & ~ ((int )((signed char )(1 << ((int )id___0 & 7))))); return; } } static struct l3_process *ni1_new_l3_process(struct PStack *st , int cr ) { struct l3_process *proc ; { proc = new_l3_process(st, cr); if ((unsigned long )proc == (unsigned long )((struct l3_process *)0)) { return (0); } else { } proc->prot.ni1.invoke_id = 0U; proc->prot.ni1.remote_operation = 0U; proc->prot.ni1.uus1_data[0] = 0; return (proc); } } static void ni1_release_l3_process(struct l3_process *p ) { { free_invoke_id___0(p->st, (int )p->prot.ni1.invoke_id); release_l3_process(p); return; } } static struct l3_process *l3ni1_search_dummy_proc(struct PStack *st , int id___0 ) { struct l3_process *pc ; { pc = st->l3.proc; if (id___0 == 0) { return (0); } else { } goto ldv_41023; ldv_41022: ; if (pc->callref == -1 && (int )pc->prot.ni1.invoke_id == id___0) { return (pc); } else { } pc = pc->next; ldv_41023: ; if ((unsigned long )pc != (unsigned long )((struct l3_process *)0)) { goto ldv_41022; } else { } return (0); } } static void l3ni1_dummy_return_result(struct PStack *st , int id___0 , u_char *p , u_char nlen ) { isdn_ctrl ic ; struct IsdnCardState *cs ; struct l3_process *pc ; { pc = 0; pc = l3ni1_search_dummy_proc(st, id___0); if ((unsigned long )pc != (unsigned long )((struct l3_process *)0)) { L3DelTimer(& pc->timer); cs = (struct IsdnCardState *)(pc->st)->l1.hardware; ic.driver = cs->myid; ic.command = 273; ic.arg = 32772UL; ic.parm.isdn_io.hl_id = (int )pc->prot.ni1.invoke_id; ic.parm.isdn_io.ll_id = pc->prot.ni1.ll_id; ic.parm.isdn_io.proc = pc->prot.ni1.proc; ic.parm.isdn_io.timeout = 0; ic.parm.isdn_io.datalen = (int )nlen; ic.parm.isdn_io.data = p; free_invoke_id___0(pc->st, (int )pc->prot.ni1.invoke_id); pc->prot.ni1.invoke_id = 0U; (*(cs->iif.statcallb))(& ic); ni1_release_l3_process(pc); } else { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"dummy return result id=0x%x result len=%d", id___0, (int )nlen); } return; } } static void l3ni1_dummy_error_return(struct PStack *st , int id___0 , ulong error ) { isdn_ctrl ic ; struct IsdnCardState *cs ; struct l3_process *pc ; { pc = 0; pc = l3ni1_search_dummy_proc(st, id___0); if ((unsigned long )pc != (unsigned long )((struct l3_process *)0)) { L3DelTimer(& pc->timer); cs = (struct IsdnCardState *)(pc->st)->l1.hardware; ic.driver = cs->myid; ic.command = 273; ic.arg = 33028UL; ic.parm.isdn_io.hl_id = (int )pc->prot.ni1.invoke_id; ic.parm.isdn_io.ll_id = pc->prot.ni1.ll_id; ic.parm.isdn_io.proc = pc->prot.ni1.proc; ic.parm.isdn_io.timeout = (int )error; ic.parm.isdn_io.datalen = 0; ic.parm.isdn_io.data = 0; free_invoke_id___0(pc->st, (int )pc->prot.ni1.invoke_id); pc->prot.ni1.invoke_id = 0U; (*(cs->iif.statcallb))(& ic); ni1_release_l3_process(pc); } else { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"dummy return error id=0x%x error=0x%lx", id___0, error); } return; } } static void l3ni1_dummy_invoke(struct PStack *st , int cr , int id___0 , int ident , u_char *p , u_char nlen ) { isdn_ctrl ic ; struct IsdnCardState *cs ; { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"dummy invoke %s id=0x%x ident=0x%x datalen=%d", cr == -1 ? (char *)"local" : (char *)"broadcast", id___0, ident, (int )nlen); if (cr >= -1) { return; } else { } cs = (struct IsdnCardState *)st->l1.hardware; ic.driver = cs->myid; ic.command = 273; ic.arg = 33284UL; ic.parm.isdn_io.hl_id = id___0; ic.parm.isdn_io.ll_id = 0UL; ic.parm.isdn_io.proc = ident; ic.parm.isdn_io.timeout = 0; ic.parm.isdn_io.datalen = (int )nlen; ic.parm.isdn_io.data = p; (*(cs->iif.statcallb))(& ic); return; } } static void l3ni1_parse_facility(struct PStack *st , struct l3_process *pc , int cr , u_char *p ) { int qd_len ; unsigned char nlen ; unsigned char ilen ; unsigned char cp_tag ; int ident ; int id___0 ; ulong err_ret ; u_char *tmp ; u_char *tmp___0 ; int tmp___1 ; u_char *tmp___2 ; u_char *tmp___3 ; u_char *tmp___4 ; u_char *tmp___5 ; u_char *tmp___6 ; u_char *tmp___7 ; u_char *tmp___8 ; u_char *tmp___9 ; { qd_len = 0; nlen = 0U; if ((unsigned long )pc != (unsigned long )((struct l3_process *)0)) { st = pc->st; } else if ((unsigned long )st == (unsigned long )((struct PStack *)0) || cr >= 0) { return; } else { } p = p + 1; tmp = p; p = p + 1; qd_len = (int )*tmp; if (qd_len == 0) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"qd_len == 0"); return; } else { } if (((int )*p & 31) != 17) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"supplementary service != 0x11"); return; } else { } goto ldv_41066; ldv_41065: p = p + 1; qd_len = qd_len - 1; ldv_41066: ; if (qd_len > 0 && (int )((signed char )*p) >= 0) { goto ldv_41065; } else { } if (qd_len <= 1) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"qd_len < 2"); return; } else { } p = p + 1; qd_len = qd_len - 1; if (((int )*p & 224) != 160) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"class and form != 0xA0"); return; } else { } cp_tag = (unsigned int )*p & 31U; p = p + 1; qd_len = qd_len - 1; if (qd_len <= 0) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"qd_len < 1"); return; } else { } if ((int )((signed char )*p) < 0) { tmp___0 = p; p = p + 1; nlen = (unsigned int )*tmp___0 & 127U; tmp___1 = qd_len; qd_len = qd_len - 1; if (tmp___1 < ((unsigned int )nlen != 0U ? (int )nlen + 1 : 3) || (unsigned int )nlen > 1U) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"length format error or not implemented"); return; } else { } if ((unsigned int )nlen == 1U) { tmp___2 = p; p = p + 1; nlen = *tmp___2; qd_len = qd_len - 1; } else { qd_len = qd_len + -2; if ((unsigned int )*(p + (unsigned long )qd_len) != 0U || (unsigned int )*(p + ((unsigned long )qd_len + 1UL)) != 0U) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"length format indefinite error"); return; } else { } nlen = (unsigned char )qd_len; } } else { tmp___3 = p; p = p + 1; nlen = *tmp___3; qd_len = qd_len - 1; } if ((int )nlen > qd_len) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"qd_len < nlen"); return; } else { } qd_len = qd_len - (int )nlen; if ((unsigned int )nlen <= 1U) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"nlen < 2"); return; } else { } if ((unsigned int )*p != 2U) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"invoke identifier tag !=0x02"); return; } else { } p = p + 1; nlen = (unsigned char )((int )nlen - 1); if ((int )((signed char )*p) < 0) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"invoke id length format 2"); return; } else { } tmp___4 = p; p = p + 1; ilen = *tmp___4; nlen = (unsigned char )((int )nlen - 1); if ((int )ilen > (int )nlen || (unsigned int )ilen == 0U) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"ilen > nlen || ilen == 0"); return; } else { } nlen = (int )nlen - (int )ilen; id___0 = 0; goto ldv_41069; ldv_41068: tmp___5 = p; p = p + 1; id___0 = (id___0 << 8) | (int )*tmp___5; ilen = (unsigned char )((int )ilen - 1); ldv_41069: ; if ((unsigned int )ilen != 0U) { goto ldv_41068; } else { } switch ((int )cp_tag) { case 1: ; if ((unsigned int )nlen <= 1U) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"nlen < 2 22"); return; } else { } if ((unsigned int )*p != 2U) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"operation value !=0x02"); return; } else { } p = p + 1; nlen = (unsigned char )((int )nlen - 1); tmp___6 = p; p = p + 1; ilen = *tmp___6; nlen = (unsigned char )((int )nlen - 1); if ((int )ilen > (int )nlen || (unsigned int )ilen == 0U) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"ilen > nlen || ilen == 0 22"); return; } else { } nlen = (int )nlen - (int )ilen; ident = 0; goto ldv_41073; ldv_41072: tmp___7 = p; p = p + 1; ident = (ident << 8) | (int )*tmp___7; ilen = (unsigned char )((int )ilen - 1); ldv_41073: ; if ((unsigned int )ilen != 0U) { goto ldv_41072; } else { } if ((unsigned long )pc == (unsigned long )((struct l3_process *)0)) { l3ni1_dummy_invoke(st, cr, id___0, ident, p, (int )nlen); return; } else { } HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"invoke break"); goto ldv_41075; case 2: ; if ((unsigned long )pc == (unsigned long )((struct l3_process *)0)) { if (cr == -1) { l3ni1_dummy_return_result(st, id___0, p, (int )nlen); } else { } return; } else { } if ((unsigned int )pc->prot.ni1.invoke_id != 0U && (int )pc->prot.ni1.invoke_id == id___0) { free_invoke_id___0(st, (int )pc->prot.ni1.invoke_id); pc->prot.ni1.remote_result = 0UL; pc->prot.ni1.invoke_id = 0U; pc->redir_result = pc->prot.ni1.remote_result; (*(st->l3.l3l4))(st, 890, (void *)pc); } else { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"return error unknown identifier"); } goto ldv_41075; case 3: err_ret = 0UL; if ((unsigned int )nlen <= 1U) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"return error nlen < 2"); return; } else { } if ((unsigned int )*p != 2U) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"invoke error tag !=0x02"); return; } else { } p = p + 1; nlen = (unsigned char )((int )nlen - 1); if ((unsigned int )*p > 4U) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"invoke return errlen > 4 "); return; } else { } tmp___8 = p; p = p + 1; ilen = *tmp___8; nlen = (unsigned char )((int )nlen - 1); if ((int )ilen > (int )nlen || (unsigned int )ilen == 0U) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"error return ilen > nlen || ilen == 0"); return; } else { } nlen = (int )nlen - (int )ilen; goto ldv_41079; ldv_41078: tmp___9 = p; p = p + 1; err_ret = (err_ret << 8) | (ulong )*tmp___9; ilen = (unsigned char )((int )ilen - 1); ldv_41079: ; if ((unsigned int )ilen != 0U) { goto ldv_41078; } else { } if ((unsigned long )pc == (unsigned long )((struct l3_process *)0)) { if (cr == -1) { l3ni1_dummy_error_return(st, id___0, err_ret); } else { } return; } else { } if ((unsigned int )pc->prot.ni1.invoke_id != 0U && (int )pc->prot.ni1.invoke_id == id___0) { free_invoke_id___0(st, (int )pc->prot.ni1.invoke_id); pc->prot.ni1.remote_result = err_ret; pc->prot.ni1.invoke_id = 0U; pc->redir_result = pc->prot.ni1.remote_result; (*(st->l3.l3l4))(st, 890, (void *)pc); } else { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"return result unknown identifier"); } goto ldv_41075; default: HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"facility default break tag=0x%02x", (int )cp_tag); goto ldv_41075; } ldv_41075: ; return; } } static void l3ni1_message(struct l3_process *pc , u_char mt ) { struct sk_buff *skb ; u_char *p ; unsigned char *tmp ; u_char *tmp___0 ; u_char *tmp___1 ; u_char *tmp___2 ; u_char *tmp___3 ; u_char *tmp___4 ; { skb = l3_alloc_skb(4); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } tmp = skb_put(skb, 4U); p = tmp; tmp___0 = p; p = p + 1; *tmp___0 = 8U; if (pc->callref == -1) { tmp___1 = p; p = p + 1; *tmp___1 = 0U; } else { tmp___2 = p; p = p + 1; *tmp___2 = 1U; tmp___3 = p; p = p + 1; *tmp___3 = (u_char )((int )((signed char )pc->callref) ^ -128); } tmp___4 = p; p = p + 1; *tmp___4 = mt; l3_msg(pc->st, 544, (void *)skb); return; } } static void l3ni1_message_plus_chid(struct l3_process *pc , u_char mt ) { struct sk_buff *skb ; u_char tmp[16U] ; u_char *p ; u_char chid ; u_char *tmp___0 ; u_char *tmp___1 ; u_char *tmp___2 ; u_char *tmp___3 ; u_char *tmp___4 ; u_char *tmp___5 ; u_char *tmp___6 ; u_char *tmp___7 ; size_t __len ; void *__ret ; unsigned char *tmp___8 ; unsigned char *tmp___9 ; { p = (u_char *)(& tmp); chid = (u_char )(((int )((signed char )pc->para.bchannel) & 3) | -120); tmp___0 = p; p = p + 1; *tmp___0 = 8U; if (pc->callref == -1) { tmp___1 = p; p = p + 1; *tmp___1 = 0U; } else { tmp___2 = p; p = p + 1; *tmp___2 = 1U; tmp___3 = p; p = p + 1; *tmp___3 = (u_char )((int )((signed char )pc->callref) ^ -128); } tmp___4 = p; p = p + 1; *tmp___4 = mt; tmp___5 = p; p = p + 1; *tmp___5 = 24U; tmp___6 = p; p = p + 1; *tmp___6 = 1U; tmp___7 = p; p = p + 1; *tmp___7 = chid; skb = l3_alloc_skb(7); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } __len = 7UL; if (__len > 63UL) { tmp___8 = skb_put(skb, 7U); __ret = memcpy((void *)tmp___8, (void const *)(& tmp), __len); } else { tmp___9 = skb_put(skb, 7U); __ret = memcpy((void *)tmp___9, (void const *)(& tmp), __len); } l3_msg(pc->st, 544, (void *)skb); return; } } static void l3ni1_message_cause(struct l3_process *pc , u_char mt , u_char cause ) { struct sk_buff *skb ; u_char tmp[16U] ; u_char *p ; int l ; u_char *tmp___0 ; u_char *tmp___1 ; u_char *tmp___2 ; u_char *tmp___3 ; u_char *tmp___4 ; u_char *tmp___5 ; u_char *tmp___6 ; u_char *tmp___7 ; u_char *tmp___8 ; size_t __len ; void *__ret ; unsigned char *tmp___10 ; { p = (u_char *)(& tmp); tmp___0 = p; p = p + 1; *tmp___0 = 8U; if (pc->callref == -1) { tmp___1 = p; p = p + 1; *tmp___1 = 0U; } else { tmp___2 = p; p = p + 1; *tmp___2 = 1U; tmp___3 = p; p = p + 1; *tmp___3 = (u_char )((int )((signed char )pc->callref) ^ -128); } tmp___4 = p; p = p + 1; *tmp___4 = mt; tmp___5 = p; p = p + 1; *tmp___5 = 8U; tmp___6 = p; p = p + 1; *tmp___6 = 2U; tmp___7 = p; p = p + 1; *tmp___7 = 128U; tmp___8 = p; p = p + 1; *tmp___8 = (u_char )((unsigned int )cause | 128U); l = (int )((unsigned int )((long )p) - (unsigned int )((long )(& tmp))); skb = l3_alloc_skb(l); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } __len = (size_t )l; tmp___10 = skb_put(skb, (unsigned int )l); __ret = memcpy((void *)tmp___10, (void const *)(& tmp), __len); l3_msg(pc->st, 544, (void *)skb); return; } } static void l3ni1_status_send(struct l3_process *pc , u_char pr , void *arg ) { u_char tmp[16U] ; u_char *p ; int l ; struct sk_buff *skb ; u_char *tmp___0 ; u_char *tmp___1 ; u_char *tmp___2 ; u_char *tmp___3 ; u_char *tmp___4 ; u_char *tmp___5 ; u_char *tmp___6 ; u_char *tmp___7 ; u_char *tmp___8 ; u_char *tmp___9 ; u_char *tmp___10 ; u_char *tmp___11 ; size_t __len ; void *__ret ; unsigned char *tmp___13 ; { p = (u_char *)(& tmp); tmp___0 = p; p = p + 1; *tmp___0 = 8U; if (pc->callref == -1) { tmp___1 = p; p = p + 1; *tmp___1 = 0U; } else { tmp___2 = p; p = p + 1; *tmp___2 = 1U; tmp___3 = p; p = p + 1; *tmp___3 = (u_char )((int )((signed char )pc->callref) ^ -128); } tmp___4 = p; p = p + 1; *tmp___4 = 125U; tmp___5 = p; p = p + 1; *tmp___5 = 8U; tmp___6 = p; p = p + 1; *tmp___6 = 2U; tmp___7 = p; p = p + 1; *tmp___7 = 128U; tmp___8 = p; p = p + 1; *tmp___8 = (u_char )((unsigned int )pc->para.cause | 128U); tmp___9 = p; p = p + 1; *tmp___9 = 20U; tmp___10 = p; p = p + 1; *tmp___10 = 1U; tmp___11 = p; p = p + 1; *tmp___11 = (unsigned int )((u_char )pc->state) & 63U; l = (int )((unsigned int )((long )p) - (unsigned int )((long )(& tmp))); skb = l3_alloc_skb(l); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } __len = (size_t )l; tmp___13 = skb_put(skb, (unsigned int )l); __ret = memcpy((void *)tmp___13, (void const *)(& tmp), __len); l3_msg(pc->st, 544, (void *)skb); return; } } static void l3ni1_msg_without_setup(struct l3_process *pc , u_char pr , void *arg ) { u_char tmp[16U] ; u_char *p ; int l ; struct sk_buff *skb ; u_char *tmp___0 ; u_char *tmp___1 ; u_char *tmp___2 ; u_char *tmp___3 ; u_char *tmp___4 ; u_char *tmp___5 ; u_char *tmp___6 ; u_char *tmp___7 ; u_char *tmp___8 ; size_t __len ; void *__ret ; unsigned char *tmp___10 ; { p = (u_char *)(& tmp); switch ((int )pc->para.cause) { case 81: ; case 88: ; case 96: ; case 100: ; case 101: tmp___0 = p; p = p + 1; *tmp___0 = 8U; if (pc->callref == -1) { tmp___1 = p; p = p + 1; *tmp___1 = 0U; } else { tmp___2 = p; p = p + 1; *tmp___2 = 1U; tmp___3 = p; p = p + 1; *tmp___3 = (u_char )((int )((signed char )pc->callref) ^ -128); } tmp___4 = p; p = p + 1; *tmp___4 = 90U; tmp___5 = p; p = p + 1; *tmp___5 = 8U; tmp___6 = p; p = p + 1; *tmp___6 = 2U; tmp___7 = p; p = p + 1; *tmp___7 = 128U; tmp___8 = p; p = p + 1; *tmp___8 = (u_char )((unsigned int )pc->para.cause | 128U); goto ldv_41137; default: printk("\vHiSax l3ni1_msg_without_setup wrong cause %d\n", (int )pc->para.cause); return; } ldv_41137: l = (int )((unsigned int )((long )p) - (unsigned int )((long )(& tmp))); skb = l3_alloc_skb(l); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } __len = (size_t )l; tmp___10 = skb_put(skb, (unsigned int )l); __ret = memcpy((void *)tmp___10, (void const *)(& tmp), __len); l3_msg(pc->st, 544, (void *)skb); ni1_release_l3_process(pc); return; } } static int ie_ALERTING___0[9U] = { 4, 536, 28, 30, 40, 52, 125, 126, -1}; static int ie_CALL_PROCEEDING___0[7U] = { 4, 536, 28, 30, 40, 125, -1}; static int ie_CONNECT___0[13U] = { 4, 536, 28, 30, 40, 41, 52, 76, 77, 124, 125, 126, -1}; static int ie_CONNECT_ACKNOWLEDGE___0[4U] = { 24, 40, 52, -1}; static int ie_DISCONNECT___0[7U] = { 264, 28, 30, 40, 52, 126, -1}; static int ie_INFORMATION___0[6U] = { 161, 40, 44, 52, 112, -1}; static int ie_NOTIFY___0[4U] = { 4, 295, 40, -1}; static int ie_PROGRESS___0[8U] = { 4, 8, 28, 286, 40, 125, 126, -1}; static int ie_RELEASE___0[6U] = { 520, 28, 40, 52, 126, -1}; static int ie_RESUME_ACKNOWLEDGE___0[4U] = { 280, 28, 40, -1}; static int ie_RESUME_REJECT___0[3U] = { 264, 40, -1}; static int ie_SETUP___0[18U] = { 161, 260, 280, 28, 30, 32, 40, 44, 52, 108, 109, 112, 113, 116, 124, 125, 126, -1}; static int ie_SETUP_ACKNOWLEDGE___0[6U] = { 280, 28, 30, 40, 52, -1}; static int ie_STATUS___0[4U] = { 264, 276, 40, -1}; static int ie_STATUS_ENQUIRY___0[2U] = { 40, -1}; static int ie_SUSPEND_ACKNOWLEDGE___0[3U] = { 40, 28, -1}; static int ie_SUSPEND_REJECT___0[3U] = { 264, 40, -1}; static int ie_FACILITY___0[3U] = { 284, 40, -1}; static int comp_required___0[12U] = { 1, 2, 3, 5, 6, 7, 9, 10, 11, 14, 15, -1}; static int l3_valid_states___0[17U] = { 0, 1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 12, 15, 17, 19, 25, -1}; static struct ie_len max_ie_len___0[33U] = { {0, 4}, {4, 12}, {8, 32}, {16, 10}, {20, 3}, {24, 34}, {28, 255}, {30, 4}, {32, 255}, {39, 3}, {40, 82}, {41, 8}, {44, 34}, {52, 3}, {64, 6}, {66, 11}, {67, 5}, {68, 3}, {69, 4}, {70, 4}, {71, 7}, {74, 3}, {108, 24}, {109, 23}, {112, 24}, {113, 23}, {116, 255}, {120, 255}, {121, 3}, {124, 18}, {125, 5}, {126, 131}, {-1, 0}}; static int getmax_ie_len___0(u_char ie ) { int i ; { i = 0; goto ldv_41171; ldv_41170: ; if (max_ie_len___0[i].ie == (int )ie) { return (max_ie_len___0[i].len); } else { } i = i + 1; ldv_41171: ; if (max_ie_len___0[i].ie != -1) { goto ldv_41170; } else { } return (255); } } static int ie_in_set___0(struct l3_process *pc , u_char ie , int *checklist ) { int ret ; { ret = 1; goto ldv_41180; ldv_41179: ; if ((*checklist & 255) == (int )ie) { if ((int )((signed char )ie) < 0) { return (- ret); } else { return (ret); } } else { } ret = ret + 1; checklist = checklist + 1; ldv_41180: ; if (*checklist != -1) { goto ldv_41179; } else { } return (0); } } static int check_infoelements___0(struct l3_process *pc , struct sk_buff *skb , int *checklist ) { int *cl ; u_char mt ; u_char *p ; u_char ie ; int l ; int newpos ; int oldpos ; int err_seq ; int err_len ; int err_compr ; int err_ureg ; u_char codeset ; u_char old_codeset ; u_char codelock ; u_char *tmp ; u_char *tmp___0 ; int tmp___1 ; u_char *tmp___2 ; u_char *tmp___3 ; int tmp___4 ; { cl = checklist; err_seq = 0; err_len = 0; err_compr = 0; err_ureg = 0; codeset = 0U; old_codeset = 0U; codelock = 1U; p = skb->data; p = p + 1; tmp = p; p = p + 1; l = (int )*tmp & 15; p = p + (unsigned long )l; tmp___0 = p; p = p + 1; mt = *tmp___0; oldpos = 0; goto ldv_41201; ldv_41202: ; if (((int )*p & 240) == 144) { old_codeset = codeset; codeset = (unsigned int )*p & 7U; if (((int )*p & 8) != 0) { codelock = 0U; } else { codelock = 1U; } if ((pc->debug & 16) != 0) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"check IE shift%scodeset %d->%d", (unsigned int )codelock != 0U ? (char *)" locking " : (char *)" ", (int )old_codeset, (int )codeset); } else { } p = p + 1; goto ldv_41201; } else { } if ((unsigned int )codeset == 0U) { newpos = ie_in_set___0(pc, (int )*p, cl); if (newpos != 0) { if (newpos > 0) { if (newpos < oldpos) { err_seq = err_seq + 1; } else { oldpos = newpos; } } else { tmp___1 = ie_in_set___0(pc, (int )*p, (int *)(& comp_required___0)); if (tmp___1 != 0) { err_compr = err_compr + 1; } else { err_ureg = err_ureg + 1; } } } else { } } else { } tmp___2 = p; p = p + 1; ie = *tmp___2; if ((int )((signed char )ie) < 0) { l = 1; } else { tmp___3 = p; p = p + 1; l = (int )*tmp___3; p = p + (unsigned long )l; l = l + 2; } if ((unsigned int )codeset == 0U) { tmp___4 = getmax_ie_len___0((int )ie); if (tmp___4 < l) { err_len = err_len + 1; } else { } } else { } if ((unsigned int )codelock == 0U) { if ((pc->debug & 16) != 0) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"check IE shift back codeset %d->%d", (int )codeset, (int )old_codeset); } else { } codeset = old_codeset; codelock = 1U; } else { } ldv_41201: ; if ((long )p - (long )skb->data < (long )skb->len) { goto ldv_41202; } else { } if ((((err_compr | err_ureg) | err_len) | err_seq) != 0) { if ((pc->debug & 16) != 0) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"check IE MT(%x) %d/%d/%d/%d", (int )mt, err_compr, err_ureg, err_len, err_seq); } else { } if (err_compr != 0) { return (1); } else { } if (err_ureg != 0) { return (-1); } else { } if (err_len != 0) { return (-2); } else { } if (err_seq != 0) { return (-3); } else { } } else { } return (0); } } static int l3ni1_check_messagetype_validity(struct l3_process *pc , int mt , void *arg ) { { switch (mt) { case 1: ; case 2: ; case 7: ; case 15: ; case 69: ; case 123: ; case 98: ; case 110: ; case 3: ; case 77: ; case 90: ; case 5: ; case 13: ; case 46: ; case 34: ; case 45: ; case 33: ; case 32: ; case 70: ; case 78: ; case 121: ; case 125: ; case 117: ; if ((pc->debug & 16) != 0) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"l3ni1_check_messagetype_validity mt(%x) OK", mt); } else { } goto ldv_41232; case 38: ; case 37: ; default: ; if ((pc->debug & 17) != 0) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"l3ni1_check_messagetype_validity mt(%x) fail", mt); } else { } pc->para.cause = 97U; l3ni1_status_send(pc, 0, 0); return (1); } ldv_41232: ; return (0); } } static void l3ni1_std_ie_err(struct l3_process *pc , int ret ) { { if ((pc->debug & 16) != 0) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"check_infoelements ret %d", ret); } else { } switch (ret) { case 0: ; goto ldv_41241; case 1: pc->para.cause = 96U; l3ni1_status_send(pc, 0, 0); goto ldv_41241; case -1: pc->para.cause = 99U; l3ni1_status_send(pc, 0, 0); goto ldv_41241; case -2: pc->para.cause = 100U; l3ni1_status_send(pc, 0, 0); goto ldv_41241; case -3: ; default: ; goto ldv_41241; } ldv_41241: ; return; } } static int l3ni1_get_channel_id(struct l3_process *pc , struct sk_buff *skb ) { u_char *p ; { p = skb->data; p = findie(p, (int )skb->len, 24, 0); if ((unsigned long )p != (unsigned long )((u_char *)0)) { p = p + 1; if ((unsigned int )*p != 1U) { if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"wrong chid len %d", (int )*p); } else { } return (-2); } else { } p = p + 1; if (((int )*p & 96) != 0) { if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"wrong chid %x", (int )*p); } else { } return (-3); } else { } return ((int )*p & 3); } else { return (-1); } } } static int l3ni1_get_cause(struct l3_process *pc , struct sk_buff *skb ) { u_char l ; u_char i ; u_char *p ; u_char *tmp ; u_char *tmp___0 ; u_char *tmp___1 ; u_char tmp___2 ; u_char *tmp___3 ; { i = 0U; p = skb->data; pc->para.cause = 31U; pc->para.loc = 0U; p = findie(p, (int )skb->len, 8, 0); if ((unsigned long )p != (unsigned long )((u_char *)0)) { p = p + 1; tmp = p; p = p + 1; l = *tmp; if ((unsigned int )l > 30U) { return (1); } else { } if ((unsigned int )l != 0U) { tmp___0 = p; p = p + 1; pc->para.loc = *tmp___0; l = (u_char )((int )l - 1); } else { return (2); } if ((unsigned int )l != 0U && (int )((signed char )pc->para.loc) >= 0) { l = (u_char )((int )l - 1); p = p + 1; } else { } if ((unsigned int )l != 0U) { tmp___1 = p; p = p + 1; pc->para.cause = *tmp___1; l = (u_char )((int )l - 1); if ((int )((signed char )pc->para.cause) >= 0) { return (3); } else { } } else { return (4); } goto ldv_41260; ldv_41259: tmp___2 = i; i = (u_char )((int )i + 1); tmp___3 = p; p = p + 1; pc->para.diag[(int )tmp___2] = *tmp___3; l = (u_char )((int )l - 1); ldv_41260: ; if ((unsigned int )l != 0U && (unsigned int )i <= 5U) { goto ldv_41259; } else { } } else { return (-1); } return (0); } } static void l3ni1_msg_with_uus(struct l3_process *pc , u_char cmd ) { struct sk_buff *skb ; u_char tmp[56U] ; u_char *p ; int l ; u_char *tmp___0 ; u_char *tmp___1 ; u_char *tmp___2 ; u_char *tmp___3 ; u_char *tmp___4 ; u_char *tmp___5 ; u_char *tmp___6 ; size_t tmp___7 ; u_char *tmp___8 ; size_t tmp___9 ; size_t __len ; void *__ret ; unsigned char *tmp___11 ; { p = (u_char *)(& tmp); tmp___0 = p; p = p + 1; *tmp___0 = 8U; if (pc->callref == -1) { tmp___1 = p; p = p + 1; *tmp___1 = 0U; } else { tmp___2 = p; p = p + 1; *tmp___2 = 1U; tmp___3 = p; p = p + 1; *tmp___3 = (u_char )((int )((signed char )pc->callref) ^ -128); } tmp___4 = p; p = p + 1; *tmp___4 = cmd; if ((int )((signed char )pc->prot.ni1.uus1_data[0]) != 0) { tmp___5 = p; p = p + 1; *tmp___5 = 126U; tmp___6 = p; p = p + 1; tmp___7 = strlen((char const *)(& pc->prot.ni1.uus1_data)); *tmp___6 = (unsigned int )((u_char )tmp___7) + 1U; tmp___8 = p; p = p + 1; *tmp___8 = 4U; strcpy((char *)p, (char const *)(& pc->prot.ni1.uus1_data)); tmp___9 = strlen((char const *)(& pc->prot.ni1.uus1_data)); p = p + tmp___9; pc->prot.ni1.uus1_data[0] = 0; } else { } l = (int )((unsigned int )((long )p) - (unsigned int )((long )(& tmp))); skb = l3_alloc_skb(l); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } __len = (size_t )l; tmp___11 = skb_put(skb, (unsigned int )l); __ret = memcpy((void *)tmp___11, (void const *)(& tmp), __len); l3_msg(pc->st, 544, (void *)skb); return; } } static void l3ni1_release_req(struct l3_process *pc , u_char pr , void *arg ) { { StopAllL3Timer(pc); newl3state(pc, 19); if ((int )((signed char )pc->prot.ni1.uus1_data[0]) == 0) { l3ni1_message(pc, 77); } else { l3ni1_msg_with_uus(pc, 77); } L3AddTimer(& pc->timer, 4000, 904); return; } } static void l3ni1_release_cmpl(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; int ret ; { skb = (struct sk_buff *)arg; ret = l3ni1_get_cause(pc, skb); if (ret > 0) { if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"RELCMPL get_cause ret(%d)", ret); } else if (ret < 0) { pc->para.cause = 254U; } else { } } else { } StopAllL3Timer(pc); newl3state(pc, 0); (*((pc->st)->l3.l3l4))(pc->st, 873, (void *)pc); ni1_release_l3_process(pc); return; } } static u_char *EncodeASyncParams___0(u_char *p , u_char si2 ) { { *p = 0U; *(p + 1UL) = 64U; *(p + 2UL) = 128U; if (((int )si2 & 32) != 0) { *(p + 2UL) = (unsigned int )*(p + 2UL) + 16U; } else { *(p + 2UL) = (unsigned int )*(p + 2UL) + 24U; } if (((int )si2 & 16) != 0) { *(p + 2UL) = (unsigned int )*(p + 2UL) + 96U; } else { *(p + 2UL) = (unsigned int )*(p + 2UL) + 32U; } if (((int )si2 & 8) != 0) { *(p + 2UL) = (unsigned int )*(p + 2UL) + 2U; } else { *(p + 2UL) = (unsigned int )*(p + 2UL) + 3U; } switch ((int )si2 & 7) { case 0: *p = 66U; goto ldv_41290; case 1: *p = 88U; goto ldv_41290; case 2: *p = 87U; goto ldv_41290; case 3: *p = 67U; goto ldv_41290; case 4: *p = 69U; goto ldv_41290; case 5: *p = 72U; goto ldv_41290; case 6: *p = 73U; goto ldv_41290; case 7: *p = 75U; goto ldv_41290; } ldv_41290: ; return (p + 3UL); } } static u_char EncodeSyncParams___0(u_char si2 , u_char ai ) { { switch ((int )si2) { case 0: ; return ((unsigned int )ai + 2U); case 1: ; return ((unsigned int )ai + 24U); case 2: ; return ((unsigned int )ai + 23U); case 3: ; return ((unsigned int )ai + 3U); case 4: ; return ((unsigned int )ai + 5U); case 5: ; return ((unsigned int )ai + 8U); case 6: ; return ((unsigned int )ai + 9U); case 7: ; return ((unsigned int )ai + 11U); case 8: ; return ((unsigned int )ai + 14U); case 9: ; return ((unsigned int )ai + 15U); case 15: ; return ((unsigned int )ai + 40U); default: ; goto ldv_41314; } ldv_41314: ; return (ai); } } static u_char DecodeASyncParams___0(u_char si2 , u_char *p ) { u_char info ; { switch ((int )*(p + 5UL)) { case 66: ; goto ldv_41321; case 88: si2 = (unsigned int )si2 + 1U; goto ldv_41321; case 87: si2 = (unsigned int )si2 + 2U; goto ldv_41321; case 67: si2 = (unsigned int )si2 + 3U; goto ldv_41321; case 69: si2 = (unsigned int )si2 + 4U; goto ldv_41321; case 72: si2 = (unsigned int )si2 + 5U; goto ldv_41321; case 73: si2 = (unsigned int )si2 + 6U; goto ldv_41321; case 75: si2 = (unsigned int )si2 + 7U; goto ldv_41321; } ldv_41321: info = (unsigned int )*(p + 7UL) & 127U; if (((int )info & 16) != 0 && ((int )info & 8) == 0) { si2 = (unsigned int )si2 + 32U; } else { } if (((int )info & 96) == 96) { si2 = (unsigned int )si2 + 16U; } else { } if (((int )info & 2) != 0 && ((int )info & 1) == 0) { si2 = (unsigned int )si2 + 8U; } else { } return (si2); } } static u_char DecodeSyncParams___0(u_char si2 , u_char info ) { { info = (unsigned int )info & 127U; switch ((int )info) { case 40: ; return ((unsigned int )si2 + 15U); case 15: ; return ((unsigned int )si2 + 9U); case 14: ; return ((unsigned int )si2 + 8U); case 11: ; return ((unsigned int )si2 + 7U); case 9: ; return ((unsigned int )si2 + 6U); case 8: ; return ((unsigned int )si2 + 5U); case 5: ; return ((unsigned int )si2 + 4U); case 3: ; return ((unsigned int )si2 + 3U); case 23: ; return ((unsigned int )si2 + 2U); case 24: ; return ((unsigned int )si2 + 1U); default: ; return (si2); } } } static u_char DecodeSI2___0(struct sk_buff *skb ) { u_char *p ; u_char tmp ; u_char tmp___0 ; u_char tmp___1 ; { p = findie(skb->data, (int )skb->len, 124, 0); if ((unsigned long )p != (unsigned long )((u_char *)0)) { switch ((int )*(p + 4UL) & 15) { case 1: ; if ((unsigned int )*(p + 1UL) == 4U) { tmp = DecodeSyncParams___0(160, (int )*(p + 5UL)); return (tmp); } else if ((unsigned int )*(p + 1UL) == 6U) { tmp___0 = DecodeASyncParams___0(192, p); return (tmp___0); } else { } goto ldv_41349; case 8: ; if ((unsigned int )*(p + 1UL) > 3U) { tmp___1 = DecodeSyncParams___0(176, (int )*(p + 5UL)); return (tmp___1); } else { } goto ldv_41349; } ldv_41349: ; } else { } return (0U); } } static void l3ni1_setup_req(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; u_char tmp[128U] ; u_char *p ; u_char *teln ; u_char *sub ; u_char *sp ; int l ; u_char *tmp___0 ; u_char *tmp___1 ; u_char *tmp___2 ; u_char *tmp___3 ; u_char *tmp___4 ; u_char *tmp___5 ; u_char *tmp___6 ; u_char *tmp___7 ; u_char *tmp___8 ; u_char *tmp___9 ; u_char *tmp___10 ; u_char *tmp___11 ; u_char *tmp___12 ; u_char *tmp___13 ; u_char *tmp___14 ; u_char *tmp___15 ; u_char *tmp___16 ; size_t tmp___17 ; u_char *tmp___18 ; u_char *tmp___19 ; u_char *tmp___20 ; u_char *tmp___21 ; u_char *tmp___22 ; u_char *tmp___23 ; u_char *tmp___24 ; u_char *tmp___25 ; u_char *tmp___26 ; u_char *tmp___27 ; u_char *tmp___28 ; u_char *tmp___29 ; u_char *tmp___30 ; u_char *tmp___31 ; u_char *tmp___32 ; u_char *tmp___33 ; u_char *tmp___34 ; u_char *tmp___35 ; u_char *tmp___36 ; u_char *tmp___37 ; u_char *tmp___38 ; u_char *tmp___39 ; u_char *tmp___40 ; u_char *tmp___41 ; u_char *tmp___42 ; u_char *tmp___43 ; u_char *tmp___44 ; u_char *tmp___45 ; u_char *tmp___46 ; u_char *tmp___47 ; size_t __len ; void *__ret ; unsigned char *tmp___49 ; { p = (u_char *)(& tmp); tmp___0 = p; p = p + 1; *tmp___0 = 8U; if (pc->callref == -1) { tmp___1 = p; p = p + 1; *tmp___1 = 0U; } else { tmp___2 = p; p = p + 1; *tmp___2 = 1U; tmp___3 = p; p = p + 1; *tmp___3 = (u_char )((int )((signed char )pc->callref) ^ -128); } tmp___4 = p; p = p + 1; *tmp___4 = 5U; teln = (u_char *)(& pc->para.setup.phone); tmp___5 = p; p = p + 1; *tmp___5 = 161U; switch ((int )pc->para.setup.si1) { case 1: tmp___6 = p; p = p + 1; *tmp___6 = 4U; tmp___7 = p; p = p + 1; *tmp___7 = 3U; tmp___8 = p; p = p + 1; *tmp___8 = 144U; tmp___9 = p; p = p + 1; *tmp___9 = 144U; tmp___10 = p; p = p + 1; *tmp___10 = 162U; goto ldv_41364; case 5: ; case 7: ; default: tmp___11 = p; p = p + 1; *tmp___11 = 4U; tmp___12 = p; p = p + 1; *tmp___12 = 2U; tmp___13 = p; p = p + 1; *tmp___13 = 136U; tmp___14 = p; p = p + 1; *tmp___14 = 144U; goto ldv_41364; } ldv_41364: sub = 0; sp = teln; goto ldv_41369; ldv_41368: ; if ((unsigned int )*sp == 46U) { sub = sp; *sp = 0U; } else { sp = sp + 1; } ldv_41369: ; if ((unsigned int )*sp != 0U) { goto ldv_41368; } else { } tmp___15 = p; p = p + 1; *tmp___15 = 44U; tmp___16 = p; p = p + 1; tmp___17 = strlen((char const *)teln); *tmp___16 = (u_char )tmp___17; goto ldv_41372; ldv_41371: tmp___18 = p; p = p + 1; tmp___19 = teln; teln = teln + 1; *tmp___18 = (unsigned int )*tmp___19 & 127U; ldv_41372: ; if ((unsigned int )*teln != 0U) { goto ldv_41371; } else { } if ((unsigned long )sub != (unsigned long )((u_char *)0)) { tmp___20 = sub; sub = sub + 1; *tmp___20 = 46U; } else { } if ((unsigned int )pc->para.setup.si2 > 159U && (unsigned int )pc->para.setup.si2 <= 175U) { tmp___21 = p; p = p + 1; *tmp___21 = 124U; tmp___22 = p; p = p + 1; *tmp___22 = 4U; tmp___23 = p; p = p + 1; *tmp___23 = 136U; tmp___24 = p; p = p + 1; *tmp___24 = 144U; tmp___25 = p; p = p + 1; *tmp___25 = 33U; tmp___26 = p; p = p + 1; *tmp___26 = EncodeSyncParams___0((int )((unsigned int )pc->para.setup.si2 + 96U), 128); } else if ((unsigned int )pc->para.setup.si2 > 175U && (unsigned int )pc->para.setup.si2 <= 191U) { tmp___27 = p; p = p + 1; *tmp___27 = 124U; tmp___28 = p; p = p + 1; *tmp___28 = 5U; tmp___29 = p; p = p + 1; *tmp___29 = 136U; tmp___30 = p; p = p + 1; *tmp___30 = 144U; tmp___31 = p; p = p + 1; *tmp___31 = 40U; tmp___32 = p; p = p + 1; *tmp___32 = EncodeSyncParams___0((int )((unsigned int )pc->para.setup.si2 + 80U), 0); tmp___33 = p; p = p + 1; *tmp___33 = 130U; } else if ((unsigned int )pc->para.setup.si2 > 191U) { tmp___34 = p; p = p + 1; *tmp___34 = 124U; tmp___35 = p; p = p + 1; *tmp___35 = 6U; tmp___36 = p; p = p + 1; *tmp___36 = 136U; tmp___37 = p; p = p + 1; *tmp___37 = 144U; tmp___38 = p; p = p + 1; *tmp___38 = 33U; p = EncodeASyncParams___0(p, (int )((unsigned int )pc->para.setup.si2 + 64U)); } else { switch ((int )pc->para.setup.si1) { case 1: tmp___39 = p; p = p + 1; *tmp___39 = 124U; tmp___40 = p; p = p + 1; *tmp___40 = 3U; tmp___41 = p; p = p + 1; *tmp___41 = 144U; tmp___42 = p; p = p + 1; *tmp___42 = 144U; tmp___43 = p; p = p + 1; *tmp___43 = 162U; goto ldv_41375; case 5: ; case 7: ; default: tmp___44 = p; p = p + 1; *tmp___44 = 124U; tmp___45 = p; p = p + 1; *tmp___45 = 2U; tmp___46 = p; p = p + 1; *tmp___46 = 136U; tmp___47 = p; p = p + 1; *tmp___47 = 144U; goto ldv_41375; } ldv_41375: ; } l = (int )((unsigned int )((long )p) - (unsigned int )((long )(& tmp))); skb = l3_alloc_skb(l); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } __len = (size_t )l; tmp___49 = skb_put(skb, (unsigned int )l); __ret = memcpy((void *)tmp___49, (void const *)(& tmp), __len); L3DelTimer(& pc->timer); L3AddTimer(& pc->timer, 4000, 899); newl3state(pc, 1); l3_msg(pc->st, 544, (void *)skb); return; } } static void l3ni1_call_proc(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; int id___0 ; int ret ; { skb = (struct sk_buff *)arg; id___0 = l3ni1_get_channel_id(pc, skb); if (id___0 >= 0) { if (id___0 == 0 || (id___0 == 3 && (unsigned int )pc->para.moderate == 16U)) { if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"setup answer with wrong chid %x", id___0); } else { } pc->para.cause = 100U; l3ni1_status_send(pc, (int )pr, 0); return; } else { } pc->para.bchannel = id___0; } else if (pc->state == 1) { if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"setup answer wrong chid (ret %d)", id___0); } else { } if (id___0 == -1) { pc->para.cause = 96U; } else { pc->para.cause = 100U; } l3ni1_status_send(pc, (int )pr, 0); return; } else { } ret = check_infoelements___0(pc, skb, (int *)(& ie_CALL_PROCEEDING___0)); if (ret == 1) { l3ni1_std_ie_err(pc, ret); return; } else { } L3DelTimer(& pc->timer); newl3state(pc, 3); L3AddTimer(& pc->timer, 30000, 912); if (ret != 0) { l3ni1_std_ie_err(pc, ret); } else { } (*((pc->st)->l3.l3l4))(pc->st, 834, (void *)pc); return; } } static void l3ni1_setup_ack(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; int id___0 ; int ret ; { skb = (struct sk_buff *)arg; id___0 = l3ni1_get_channel_id(pc, skb); if (id___0 >= 0) { if (id___0 == 0 || (id___0 == 3 && (unsigned int )pc->para.moderate == 16U)) { if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"setup answer with wrong chid %x", id___0); } else { } pc->para.cause = 100U; l3ni1_status_send(pc, (int )pr, 0); return; } else { } pc->para.bchannel = id___0; } else { if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"setup answer wrong chid (ret %d)", id___0); } else { } if (id___0 == -1) { pc->para.cause = 96U; } else { pc->para.cause = 100U; } l3ni1_status_send(pc, (int )pr, 0); return; } ret = check_infoelements___0(pc, skb, (int *)(& ie_SETUP_ACKNOWLEDGE___0)); if (ret == 1) { l3ni1_std_ie_err(pc, ret); return; } else { } L3DelTimer(& pc->timer); newl3state(pc, 2); L3AddTimer(& pc->timer, 30000, 900); if (ret != 0) { l3ni1_std_ie_err(pc, ret); } else { } (*((pc->st)->l3.l3l4))(pc->st, 786, (void *)pc); return; } } static void l3ni1_disconnect(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; u_char *p ; int ret ; u_char cause ; { skb = (struct sk_buff *)arg; cause = 0U; StopAllL3Timer(pc); ret = l3ni1_get_cause(pc, skb); if (ret != 0) { if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"DISC get_cause ret(%d)", ret); } else { } if (ret < 0) { cause = 96U; } else if (ret > 0) { cause = 100U; } else { } } else { } p = findie(skb->data, (int )skb->len, 28, 0); if ((unsigned long )p != (unsigned long )((u_char *)0)) { l3ni1_parse_facility(pc->st, pc, pc->callref, p); } else { } ret = check_infoelements___0(pc, skb, (int *)(& ie_DISCONNECT___0)); if (ret == 1) { cause = 96U; } else if ((unsigned int )cause == 0U && ret == -1) { cause = 99U; } else { } ret = pc->state; newl3state(pc, 12); if ((unsigned int )cause != 0U) { newl3state(pc, 19); } else { } if (ret != 11) { (*((pc->st)->l3.l3l4))(pc->st, 866, (void *)pc); } else if ((unsigned int )cause == 0U) { l3ni1_release_req(pc, (int )pr, 0); } else { } if ((unsigned int )cause != 0U) { l3ni1_message_cause(pc, 77, (int )cause); L3AddTimer(& pc->timer, 4000, 904); } else { } return; } } static void l3ni1_connect(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; int ret ; { skb = (struct sk_buff *)arg; ret = check_infoelements___0(pc, skb, (int *)(& ie_CONNECT___0)); if (ret == 1) { l3ni1_std_ie_err(pc, ret); return; } else { } L3DelTimer(& pc->timer); newl3state(pc, 10); pc->para.chargeinfo = 0; if (ret != 0) { l3ni1_std_ie_err(pc, ret); } else { } (*((pc->st)->l3.l3l4))(pc->st, 769, (void *)pc); return; } } static void l3ni1_alerting(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; int ret ; { skb = (struct sk_buff *)arg; ret = check_infoelements___0(pc, skb, (int *)(& ie_ALERTING___0)); if (ret == 1) { l3ni1_std_ie_err(pc, ret); return; } else { } L3DelTimer(& pc->timer); newl3state(pc, 4); if (ret != 0) { l3ni1_std_ie_err(pc, ret); } else { } (*((pc->st)->l3.l3l4))(pc->st, 838, (void *)pc); return; } } static void l3ni1_setup(struct l3_process *pc , u_char pr , void *arg ) { u_char *p ; int bcfound ; char tmp[80U] ; struct sk_buff *skb ; int id___0 ; int err ; int tmp___0 ; { bcfound = 0; skb = (struct sk_buff *)arg; err = 0; p = skb->data; p = findie(p, (int )skb->len, 4, 0); if ((unsigned long )p != (unsigned long )((u_char *)0)) { if ((unsigned int )*(p + 1UL) <= 1U || (unsigned int )*(p + 1UL) > 11U) { err = 1; } else { pc->para.setup.si2 = 0U; switch ((int )*(p + 2UL) & 127) { case 0: ; case 16: pc->para.setup.si1 = 1U; goto ldv_41434; case 8: pc->para.setup.si1 = 7U; pc->para.setup.si2 = DecodeSI2___0(skb); goto ldv_41434; case 9: pc->para.setup.si1 = 2U; goto ldv_41434; case 17: pc->para.setup.si1 = 3U; goto ldv_41434; case 24: pc->para.setup.si1 = 4U; goto ldv_41434; default: err = 2; goto ldv_41434; } ldv_41434: ; switch ((int )*(p + 3UL) & 127) { case 64: pc->para.setup.si1 = 8U; goto ldv_41441; case 16: ; case 17: ; case 19: ; case 21: ; case 23: pc->para.moderate = (unsigned int )*(p + 3UL) & 127U; goto ldv_41441; default: err = 3; goto ldv_41441; } ldv_41441: ; } if ((pc->debug & 32) != 0) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"SI=%d, AI=%d", (int )pc->para.setup.si1, (int )pc->para.setup.si2); } else { } if (err != 0) { if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"setup with wrong bearer(l=%d:%x,%x)", (int )*(p + 1UL), (int )*(p + 2UL), (int )*(p + 3UL)); } else { } pc->para.cause = 100U; l3ni1_msg_without_setup(pc, (int )pr, 0); return; } else { } } else { if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"setup without bearer capabilities"); } else { } pc->para.cause = 96U; l3ni1_msg_without_setup(pc, (int )pr, 0); return; } id___0 = l3ni1_get_channel_id(pc, skb); if (id___0 >= 0) { tmp___0 = id___0; pc->para.bchannel = tmp___0; if (tmp___0 != 0) { if (id___0 == 3 && (unsigned int )pc->para.moderate == 16U) { if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"setup with wrong chid %x", id___0); } else { } pc->para.cause = 100U; l3ni1_msg_without_setup(pc, (int )pr, 0); return; } else { } bcfound = bcfound + 1; } else { if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"setup without bchannel, call waiting"); } else { } bcfound = bcfound + 1; } } else { if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"setup with wrong chid ret %d", id___0); } else { } if (id___0 == -1) { pc->para.cause = 96U; } else { pc->para.cause = 100U; } l3ni1_msg_without_setup(pc, (int )pr, 0); return; } err = check_infoelements___0(pc, skb, (int *)(& ie_SETUP___0)); if (err == 1) { pc->para.cause = 96U; l3ni1_msg_without_setup(pc, (int )pr, 0); return; } else { } p = skb->data; p = findie(p, (int )skb->len, 112, 0); if ((unsigned long )p != (unsigned long )((u_char *)0)) { iecpy((u_char *)(& pc->para.setup.eazmsn), p, 1); } else { pc->para.setup.eazmsn[0] = 0U; } p = skb->data; p = findie(p, (int )skb->len, 113, 0); if ((unsigned long )p != (unsigned long )((u_char *)0)) { if (((unsigned int )*(p + 1UL) > 1U && (unsigned int )*(p + 2UL) == 128U) && (unsigned int )*(p + 3UL) == 80U) { tmp[0] = 46; iecpy((u_char *)(& tmp) + 1U, p, 2); strcat((char *)(& pc->para.setup.eazmsn), (char const *)(& tmp)); } else if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"wrong called subaddress"); } else { } } else { } p = skb->data; p = findie(p, (int )skb->len, 108, 0); if ((unsigned long )p != (unsigned long )((u_char *)0)) { pc->para.setup.plan = *(p + 2UL); if ((int )((signed char )*(p + 2UL)) < 0) { iecpy((u_char *)(& pc->para.setup.phone), p, 1); pc->para.setup.screen = 0U; } else { iecpy((u_char *)(& pc->para.setup.phone), p, 2); pc->para.setup.screen = *(p + 3UL); } } else { pc->para.setup.phone[0] = 0U; pc->para.setup.plan = 0U; pc->para.setup.screen = 0U; } p = skb->data; p = findie(p, (int )skb->len, 109, 0); if ((unsigned long )p != (unsigned long )((u_char *)0)) { if (((unsigned int )*(p + 1UL) > 1U && (unsigned int )*(p + 2UL) == 128U) && (unsigned int )*(p + 3UL) == 80U) { tmp[0] = 46; iecpy((u_char *)(& tmp) + 1U, p, 2); strcat((char *)(& pc->para.setup.phone), (char const *)(& tmp)); } else if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"wrong calling subaddress"); } else { } } else { } newl3state(pc, 6); if (err != 0) { l3ni1_std_ie_err(pc, err); } else { } (*((pc->st)->l3.l3l4))(pc->st, 770, (void *)pc); return; } } static void l3ni1_reset(struct l3_process *pc , u_char pr , void *arg ) { { ni1_release_l3_process(pc); return; } } static void l3ni1_disconnect_req(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; u_char tmp[56U] ; u_char *p ; int l ; u_char cause ; u_char *tmp___0 ; u_char *tmp___1 ; u_char *tmp___2 ; u_char *tmp___3 ; u_char *tmp___4 ; u_char *tmp___5 ; u_char *tmp___6 ; u_char *tmp___7 ; u_char *tmp___8 ; u_char *tmp___9 ; u_char *tmp___10 ; size_t tmp___11 ; u_char *tmp___12 ; size_t tmp___13 ; size_t __len ; void *__ret ; unsigned char *tmp___15 ; { p = (u_char *)(& tmp); cause = 16U; if ((unsigned int )pc->para.cause != 254U) { cause = pc->para.cause; } else { } StopAllL3Timer(pc); tmp___0 = p; p = p + 1; *tmp___0 = 8U; if (pc->callref == -1) { tmp___1 = p; p = p + 1; *tmp___1 = 0U; } else { tmp___2 = p; p = p + 1; *tmp___2 = 1U; tmp___3 = p; p = p + 1; *tmp___3 = (u_char )((int )((signed char )pc->callref) ^ -128); } tmp___4 = p; p = p + 1; *tmp___4 = 69U; tmp___5 = p; p = p + 1; *tmp___5 = 8U; tmp___6 = p; p = p + 1; *tmp___6 = 2U; tmp___7 = p; p = p + 1; *tmp___7 = 128U; tmp___8 = p; p = p + 1; *tmp___8 = (u_char )((unsigned int )cause | 128U); if ((int )((signed char )pc->prot.ni1.uus1_data[0]) != 0) { tmp___9 = p; p = p + 1; *tmp___9 = 126U; tmp___10 = p; p = p + 1; tmp___11 = strlen((char const *)(& pc->prot.ni1.uus1_data)); *tmp___10 = (unsigned int )((u_char )tmp___11) + 1U; tmp___12 = p; p = p + 1; *tmp___12 = 4U; strcpy((char *)p, (char const *)(& pc->prot.ni1.uus1_data)); tmp___13 = strlen((char const *)(& pc->prot.ni1.uus1_data)); p = p + tmp___13; pc->prot.ni1.uus1_data[0] = 0; } else { } l = (int )((unsigned int )((long )p) - (unsigned int )((long )(& tmp))); skb = l3_alloc_skb(l); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } __len = (size_t )l; tmp___15 = skb_put(skb, (unsigned int )l); __ret = memcpy((void *)tmp___15, (void const *)(& tmp), __len); newl3state(pc, 11); l3_msg(pc->st, 544, (void *)skb); L3AddTimer(& pc->timer, 30000, 901); return; } } static void l3ni1_setup_rsp(struct l3_process *pc , u_char pr , void *arg ) { { if (pc->para.bchannel == 0) { if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"D-chan connect for waiting call"); } else { } l3ni1_disconnect_req(pc, (int )pr, arg); return; } else { } newl3state(pc, 8); if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"D-chan connect for waiting call"); } else { } l3ni1_message_plus_chid(pc, 7); L3DelTimer(& pc->timer); L3AddTimer(& pc->timer, 4000, 915); return; } } static void l3ni1_connect_ack(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; int ret ; { skb = (struct sk_buff *)arg; ret = check_infoelements___0(pc, skb, (int *)(& ie_CONNECT_ACKNOWLEDGE___0)); if (ret == 1) { l3ni1_std_ie_err(pc, ret); return; } else { } newl3state(pc, 10); L3DelTimer(& pc->timer); if (ret != 0) { l3ni1_std_ie_err(pc, ret); } else { } (*((pc->st)->l3.l3l4))(pc->st, 818, (void *)pc); return; } } static void l3ni1_reject_req(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; u_char tmp[16U] ; u_char *p ; int l ; u_char cause ; u_char *tmp___0 ; u_char *tmp___1 ; u_char *tmp___2 ; u_char *tmp___3 ; u_char *tmp___4 ; u_char *tmp___5 ; u_char *tmp___6 ; u_char *tmp___7 ; u_char *tmp___8 ; size_t __len ; void *__ret ; unsigned char *tmp___10 ; { p = (u_char *)(& tmp); cause = 21U; if ((unsigned int )pc->para.cause != 254U) { cause = pc->para.cause; } else { } tmp___0 = p; p = p + 1; *tmp___0 = 8U; if (pc->callref == -1) { tmp___1 = p; p = p + 1; *tmp___1 = 0U; } else { tmp___2 = p; p = p + 1; *tmp___2 = 1U; tmp___3 = p; p = p + 1; *tmp___3 = (u_char )((int )((signed char )pc->callref) ^ -128); } tmp___4 = p; p = p + 1; *tmp___4 = 90U; tmp___5 = p; p = p + 1; *tmp___5 = 8U; tmp___6 = p; p = p + 1; *tmp___6 = 2U; tmp___7 = p; p = p + 1; *tmp___7 = 128U; tmp___8 = p; p = p + 1; *tmp___8 = (u_char )((unsigned int )cause | 128U); l = (int )((unsigned int )((long )p) - (unsigned int )((long )(& tmp))); skb = l3_alloc_skb(l); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } __len = (size_t )l; tmp___10 = skb_put(skb, (unsigned int )l); __ret = memcpy((void *)tmp___10, (void const *)(& tmp), __len); l3_msg(pc->st, 544, (void *)skb); (*((pc->st)->l3.l3l4))(pc->st, 874, (void *)pc); newl3state(pc, 0); ni1_release_l3_process(pc); return; } } static void l3ni1_release(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; u_char *p ; int ret ; int cause ; { skb = (struct sk_buff *)arg; cause = 0; StopAllL3Timer(pc); ret = l3ni1_get_cause(pc, skb); if (ret > 0) { if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"REL get_cause ret(%d)", ret); } else if (ret < 0) { pc->para.cause = 254U; } else { } } else { } p = findie(skb->data, (int )skb->len, 28, 0); if ((unsigned long )p != (unsigned long )((u_char *)0)) { l3ni1_parse_facility(pc->st, pc, pc->callref, p); } else { } if (ret < 0 && pc->state != 11) { cause = 96; } else if (ret > 0) { cause = 100; } else { } ret = check_infoelements___0(pc, skb, (int *)(& ie_RELEASE___0)); if (ret == 1) { cause = 96; } else if (ret == -1 && cause == 0) { cause = 99; } else { } if (cause != 0) { l3ni1_message_cause(pc, 90, (int )((u_char )cause)); } else { l3ni1_message(pc, 90); } (*((pc->st)->l3.l3l4))(pc->st, 874, (void *)pc); newl3state(pc, 0); ni1_release_l3_process(pc); return; } } static void l3ni1_alert_req(struct l3_process *pc , u_char pr , void *arg ) { { newl3state(pc, 7); if ((int )((signed char )pc->prot.ni1.uus1_data[0]) == 0) { l3ni1_message(pc, 1); } else { l3ni1_msg_with_uus(pc, 1); } return; } } static void l3ni1_proceed_req(struct l3_process *pc , u_char pr , void *arg ) { { newl3state(pc, 9); l3ni1_message(pc, 2); (*((pc->st)->l3.l3l4))(pc->st, 886, (void *)pc); return; } } static void l3ni1_setup_ack_req(struct l3_process *pc , u_char pr , void *arg ) { { newl3state(pc, 25); L3DelTimer(& pc->timer); L3AddTimer(& pc->timer, 15000, 898); l3ni1_message(pc, 13); return; } } static void l3ni1_deliver_display(struct l3_process *pc , int pr , u_char *infp ) { u_char len ; isdn_ctrl ic ; struct IsdnCardState *cs ; char *p ; u_char *tmp ; u_char *tmp___0 ; char *tmp___1 ; u_char *tmp___2 ; u_char tmp___3 ; { tmp = infp; infp = infp + 1; if ((unsigned int )*tmp != 40U) { return; } else { } tmp___0 = infp; infp = infp + 1; len = *tmp___0; if ((unsigned int )len > 80U) { return; } else { } if ((unsigned long )pc->chan == (unsigned long )((struct Channel *)0)) { return; } else { } p = (char *)(& ic.parm.display); goto ldv_41525; ldv_41524: tmp___1 = p; p = p + 1; tmp___2 = infp; infp = infp + 1; *tmp___1 = (char )*tmp___2; ldv_41525: tmp___3 = len; len = (u_char )((int )len - 1); if ((unsigned int )tmp___3 != 0U) { goto ldv_41524; } else { } *p = 0; ic.command = 274; cs = (struct IsdnCardState *)(pc->st)->l1.hardware; ic.driver = cs->myid; ic.arg = (ulong )(pc->chan)->chan; (*(cs->iif.statcallb))(& ic); return; } } static void l3ni1_progress(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; int err ; u_char *p ; { skb = (struct sk_buff *)arg; err = 0; p = findie(skb->data, (int )skb->len, 30, 0); if ((unsigned long )p != (unsigned long )((u_char *)0)) { if ((unsigned int )*(p + 1UL) != 2U) { err = 1; pc->para.cause = 100U; } else if (((int )*(p + 2UL) & 112) == 0) { switch ((int )*(p + 2UL)) { case 128: ; case 129: ; case 130: ; case 132: ; case 133: ; case 135: ; case 138: ; switch ((int )*(p + 3UL)) { case 129: ; case 130: ; case 131: ; case 132: ; case 136: ; goto ldv_41547; default: err = 2; pc->para.cause = 100U; goto ldv_41547; } ldv_41547: ; goto ldv_41549; default: err = 3; pc->para.cause = 100U; goto ldv_41549; } ldv_41549: ; } else { pc->para.cause = 96U; err = 4; } } else { } if (err != 0) { if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"progress error %d", err); } else { } l3ni1_status_send(pc, (int )pr, 0); return; } else { } err = check_infoelements___0(pc, skb, (int *)(& ie_PROGRESS___0)); if (err != 0) { l3ni1_std_ie_err(pc, err); } else { } if (err != 1) { (*((pc->st)->l3.l3l4))(pc->st, 842, (void *)pc); } else { } return; } } static void l3ni1_notify(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; int err ; u_char *p ; { skb = (struct sk_buff *)arg; err = 0; p = findie(skb->data, (int )skb->len, 39, 0); if ((unsigned long )p != (unsigned long )((u_char *)0)) { if ((unsigned int )*(p + 1UL) != 1U) { err = 1; pc->para.cause = 100U; } else { switch ((int )*(p + 2UL)) { case 128: ; case 129: ; case 130: ; goto ldv_41562; default: pc->para.cause = 100U; err = 2; goto ldv_41562; } ldv_41562: ; } } else { pc->para.cause = 96U; err = 3; } if (err != 0) { if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"notify error %d", err); } else { } l3ni1_status_send(pc, (int )pr, 0); return; } else { } err = check_infoelements___0(pc, skb, (int *)(& ie_NOTIFY___0)); if (err != 0) { l3ni1_std_ie_err(pc, err); } else { } if (err != 1) { (*((pc->st)->l3.l3l4))(pc->st, 858, (void *)pc); } else { } return; } } static void l3ni1_status_enq(struct l3_process *pc , u_char pr , void *arg ) { int ret ; struct sk_buff *skb ; { skb = (struct sk_buff *)arg; ret = check_infoelements___0(pc, skb, (int *)(& ie_STATUS_ENQUIRY___0)); l3ni1_std_ie_err(pc, ret); pc->para.cause = 30U; l3ni1_status_send(pc, (int )pr, 0); return; } } static void l3ni1_information(struct l3_process *pc , u_char pr , void *arg ) { int ret ; struct sk_buff *skb ; u_char *p ; char tmp[32U] ; { skb = (struct sk_buff *)arg; ret = check_infoelements___0(pc, skb, (int *)(& ie_INFORMATION___0)); if (ret != 0) { l3ni1_std_ie_err(pc, ret); } else { } if (pc->state == 25) { L3DelTimer(& pc->timer); p = skb->data; p = findie(p, (int )skb->len, 112, 0); if ((unsigned long )p != (unsigned long )((u_char *)0)) { iecpy((u_char *)(& tmp), p, 1); strcat((char *)(& pc->para.setup.eazmsn), (char const *)(& tmp)); (*((pc->st)->l3.l3l4))(pc->st, 786, (void *)pc); } else { } L3AddTimer(& pc->timer, 15000, 898); } else { } return; } } static void l3ni1_redir_req(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; u_char tmp[128U] ; u_char *p ; u_char *subp ; u_char len_phone ; u_char len_sub ; int l ; unsigned char tmp___0 ; u_char *tmp___1 ; u_char *tmp___2 ; u_char *tmp___3 ; u_char *tmp___4 ; u_char *tmp___5 ; size_t tmp___6 ; u_char *tmp___7 ; u_char *tmp___8 ; u_char *tmp___9 ; u_char *tmp___10 ; u_char *tmp___11 ; u_char *tmp___12 ; u_char *tmp___13 ; u_char *tmp___14 ; u_char *tmp___15 ; u_char *tmp___16 ; u_char *tmp___17 ; u_char *tmp___18 ; u_char *tmp___19 ; u_char *tmp___20 ; u_char *tmp___21 ; u_char *tmp___22 ; u_char *tmp___23 ; u_char *tmp___24 ; u_char *tmp___25 ; u_char *tmp___26 ; u_char *tmp___27 ; u_char *tmp___28 ; u_char *tmp___29 ; u_char *tmp___30 ; u_char *tmp___31 ; u_char *tmp___32 ; size_t __len ; void *__ret ; unsigned char *tmp___34 ; { p = (u_char *)(& tmp); len_phone = 0U; len_sub = 0U; strcpy((char *)(& pc->prot.ni1.uus1_data), (char const *)(& (pc->chan)->setup.eazmsn)); if ((unsigned int )(pc->chan)->setup.phone[0] == 0U) { pc->para.cause = 255U; l3ni1_disconnect_req(pc, (int )pr, arg); return; } else { } if ((unsigned int )pc->prot.ni1.invoke_id != 0U) { free_invoke_id___0(pc->st, (int )pc->prot.ni1.invoke_id); } else { } tmp___0 = new_invoke_id___0(pc->st); pc->prot.ni1.invoke_id = tmp___0; if ((unsigned int )tmp___0 == 0U) { return; } else { } tmp___1 = p; p = p + 1; *tmp___1 = 8U; if (pc->callref == -1) { tmp___2 = p; p = p + 1; *tmp___2 = 0U; } else { tmp___3 = p; p = p + 1; *tmp___3 = 1U; tmp___4 = p; p = p + 1; *tmp___4 = (u_char )((int )((signed char )pc->callref) ^ -128); } tmp___5 = p; p = p + 1; *tmp___5 = 98U; subp = (u_char *)(& (pc->chan)->setup.phone); goto ldv_41593; ldv_41592: len_phone = (u_char )((int )len_phone + 1); subp = subp + 1; ldv_41593: ; if ((unsigned int )*subp != 0U && (unsigned int )*subp != 46U) { goto ldv_41592; } else { } tmp___7 = subp; subp = subp + 1; if ((unsigned int )*tmp___7 == 46U) { tmp___6 = strlen((char const *)subp); len_sub = (unsigned int )((u_char )tmp___6) + 2U; } else { } tmp___8 = p; p = p + 1; *tmp___8 = 28U; tmp___9 = p; p = p + 1; *tmp___9 = (unsigned int )((int )len_phone + (int )len_sub) + 18U; tmp___10 = p; p = p + 1; *tmp___10 = 145U; tmp___11 = p; p = p + 1; *tmp___11 = 161U; tmp___12 = p; p = p + 1; *tmp___12 = (unsigned int )((int )len_phone + (int )len_sub) + 15U; tmp___13 = p; p = p + 1; *tmp___13 = 2U; tmp___14 = p; p = p + 1; *tmp___14 = 1U; tmp___15 = p; p = p + 1; *tmp___15 = pc->prot.ni1.invoke_id; tmp___16 = p; p = p + 1; *tmp___16 = 2U; tmp___17 = p; p = p + 1; *tmp___17 = 1U; tmp___18 = p; p = p + 1; *tmp___18 = 13U; tmp___19 = p; p = p + 1; *tmp___19 = 48U; tmp___20 = p; p = p + 1; *tmp___20 = (unsigned int )((int )len_phone + (int )len_sub) + 7U; tmp___21 = p; p = p + 1; *tmp___21 = 48U; tmp___22 = p; p = p + 1; *tmp___22 = (unsigned int )((int )len_phone + (int )len_sub) + 2U; tmp___23 = p; p = p + 1; *tmp___23 = 128U; tmp___24 = p; p = p + 1; *tmp___24 = len_phone; l = 0; goto ldv_41596; ldv_41595: tmp___25 = p; p = p + 1; *tmp___25 = (pc->chan)->setup.phone[l]; l = l + 1; ldv_41596: ; if ((int )len_phone > l) { goto ldv_41595; } else { } if ((unsigned int )len_sub != 0U) { tmp___26 = p; p = p + 1; *tmp___26 = 4U; tmp___27 = p; p = p + 1; *tmp___27 = (unsigned int )len_sub + 254U; goto ldv_41599; ldv_41598: tmp___28 = p; p = p + 1; tmp___29 = subp; subp = subp + 1; *tmp___28 = *tmp___29; ldv_41599: ; if ((unsigned int )*subp != 0U) { goto ldv_41598; } else { } } else { } tmp___30 = p; p = p + 1; *tmp___30 = 1U; tmp___31 = p; p = p + 1; *tmp___31 = 1U; tmp___32 = p; p = p + 1; *tmp___32 = (pc->chan)->setup.screen; l = (int )((unsigned int )((long )p) - (unsigned int )((long )(& tmp))); skb = l3_alloc_skb(l); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } __len = (size_t )l; tmp___34 = skb_put(skb, (unsigned int )l); __ret = memcpy((void *)tmp___34, (void const *)(& tmp), __len); l3_msg(pc->st, 544, (void *)skb); return; } } static void l3ni1_redir_req_early(struct l3_process *pc , u_char pr , void *arg ) { { l3ni1_proceed_req(pc, (int )pr, arg); l3ni1_redir_req(pc, (int )pr, arg); return; } } static int l3ni1_cmd_global(struct PStack *st , isdn_ctrl *ic ) { u_char id___0 ; u_char temp[265U] ; u_char *p ; int i ; int l ; int proc_len ; struct sk_buff *skb ; struct l3_process *pc ; u_char *tmp ; u_char *tmp___0 ; u_char *tmp___1 ; u_char *tmp___2 ; u_char *tmp___3 ; u_char *tmp___4 ; u_char *tmp___5 ; u_char *tmp___6 ; u_char *tmp___7 ; u_char *tmp___8 ; u_char *tmp___9 ; u_char *tmp___10 ; u_char *tmp___11 ; u_char *tmp___12 ; u_char *tmp___13 ; u_char *tmp___14 ; size_t __len ; void *__ret ; size_t __len___0 ; void *__ret___0 ; unsigned char *tmp___16 ; { p = (u_char *)(& temp); pc = 0; switch (ic->arg) { case 4UL: ; if (ic->parm.isdn_io.datalen < 0) { return (-2); } else { } proc_len = 1; i = ic->parm.isdn_io.proc >> 8; goto ldv_41623; ldv_41622: i = i >> 8; i = i + 1; ldv_41623: ; if (i != 0) { goto ldv_41622; } else { } l = (ic->parm.isdn_io.datalen + proc_len) + 8; if (l > 255) { return (-2); } else { } id___0 = new_invoke_id___0(st); if ((unsigned int )id___0 == 0U) { return (0); } else { } i = -1; tmp = p; p = p + 1; *tmp = 8U; if (i == -1) { tmp___0 = p; p = p + 1; *tmp___0 = 0U; } else { tmp___1 = p; p = p + 1; *tmp___1 = 1U; tmp___2 = p; p = p + 1; *tmp___2 = (u_char )((int )((signed char )i) ^ -128); } tmp___3 = p; p = p + 1; *tmp___3 = 98U; tmp___4 = p; p = p + 1; *tmp___4 = 28U; tmp___5 = p; p = p + 1; *tmp___5 = (u_char )l; tmp___6 = p; p = p + 1; *tmp___6 = 145U; tmp___7 = p; p = p + 1; *tmp___7 = 161U; tmp___8 = p; p = p + 1; *tmp___8 = (unsigned int )((u_char )l) + 253U; tmp___9 = p; p = p + 1; *tmp___9 = 2U; tmp___10 = p; p = p + 1; *tmp___10 = 1U; tmp___11 = p; p = p + 1; *tmp___11 = id___0; tmp___12 = p; p = p + 1; *tmp___12 = 2U; tmp___13 = p; p = p + 1; *tmp___13 = (u_char )proc_len; i = proc_len; goto ldv_41626; ldv_41625: tmp___14 = p; p = p + 1; *tmp___14 = (u_char )(ic->parm.isdn_io.proc >> (i + -1)); i = i - 1; ldv_41626: ; if (i != 0) { goto ldv_41625; } else { } __len = (size_t )ic->parm.isdn_io.datalen; __ret = memcpy((void *)p, (void const *)ic->parm.isdn_io.data, __len); l = (int )(((unsigned int )((long )p) - (unsigned int )((long )(& temp))) + (unsigned int )ic->parm.isdn_io.datalen); if (ic->parm.isdn_io.timeout > 0) { pc = ni1_new_l3_process(st, -1); if ((unsigned long )pc == (unsigned long )((struct l3_process *)0)) { free_invoke_id___0(st, (int )id___0); return (-2); } else { } } else { } pc->prot.ni1.ll_id = ic->parm.isdn_io.ll_id; pc->prot.ni1.proc = ic->parm.isdn_io.proc; skb = l3_alloc_skb(l); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { free_invoke_id___0(st, (int )id___0); if ((unsigned long )pc != (unsigned long )((struct l3_process *)0)) { ni1_release_l3_process(pc); } else { } return (-2); } else { } __len___0 = (size_t )l; tmp___16 = skb_put(skb, (unsigned int )l); __ret___0 = memcpy((void *)tmp___16, (void const *)(& temp), __len___0); if ((unsigned long )pc != (unsigned long )((struct l3_process *)0)) { pc->prot.ni1.invoke_id = id___0; L3AddTimer(& pc->timer, ic->parm.isdn_io.timeout, 5109); } else { } l3_msg(st, 544, (void *)skb); ic->parm.isdn_io.hl_id = (int )id___0; return (0); case 260UL: pc = l3ni1_search_dummy_proc(st, ic->parm.isdn_io.hl_id); if ((unsigned long )pc != (unsigned long )((struct l3_process *)0)) { L3DelTimer(& pc->timer); ni1_release_l3_process(pc); return (0); } else { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"l3ni1_cmd_global abort unknown id"); return (-2); } default: HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"l3ni1_cmd_global unknown cmd 0x%lx", ic->arg); return (-1); } return (-1); } } static void l3ni1_io_timer(struct l3_process *pc ) { isdn_ctrl ic ; struct IsdnCardState *cs ; { cs = (struct IsdnCardState *)(pc->st)->l1.hardware; L3DelTimer(& pc->timer); ic.driver = cs->myid; ic.command = 273; ic.arg = 33028UL; ic.parm.isdn_io.hl_id = (int )pc->prot.ni1.invoke_id; ic.parm.isdn_io.ll_id = pc->prot.ni1.ll_id; ic.parm.isdn_io.proc = pc->prot.ni1.proc; ic.parm.isdn_io.timeout = -1; ic.parm.isdn_io.datalen = 0; ic.parm.isdn_io.data = 0; free_invoke_id___0(pc->st, (int )pc->prot.ni1.invoke_id); pc->prot.ni1.invoke_id = 0U; (*(cs->iif.statcallb))(& ic); ni1_release_l3_process(pc); return; } } static void l3ni1_release_ind(struct l3_process *pc , u_char pr , void *arg ) { u_char *p ; struct sk_buff *skb ; int callState ; u_char *tmp ; { skb = (struct sk_buff *)arg; callState = 0; p = skb->data; p = findie(p, (int )skb->len, 20, 0); if ((unsigned long )p != (unsigned long )((u_char *)0)) { p = p + 1; tmp = p; p = p + 1; if ((unsigned int )*tmp == 1U) { callState = (int )*p; } else { } } else { } if (callState == 0) { (*((pc->st)->l3.l3l4))(pc->st, 874, (void *)pc); newl3state(pc, 0); ni1_release_l3_process(pc); } else { (*((pc->st)->l3.l3l4))(pc->st, 802, (void *)pc); } return; } } static void l3ni1_dummy(struct l3_process *pc , u_char pr , void *arg ) { { return; } } static void l3ni1_t302(struct l3_process *pc , u_char pr , void *arg ) { { L3DelTimer(& pc->timer); pc->para.loc = 0U; pc->para.cause = 28U; l3ni1_disconnect_req(pc, (int )pr, 0); (*((pc->st)->l3.l3l4))(pc->st, 993, (void *)pc); return; } } static void l3ni1_t303(struct l3_process *pc , u_char pr , void *arg ) { { if (pc->N303 > 0) { pc->N303 = pc->N303 - 1; L3DelTimer(& pc->timer); l3ni1_setup_req(pc, (int )pr, arg); } else { L3DelTimer(& pc->timer); l3ni1_message_cause(pc, 90, 102); (*((pc->st)->l3.l3l4))(pc->st, 992, (void *)pc); ni1_release_l3_process(pc); } return; } } static void l3ni1_t304(struct l3_process *pc , u_char pr , void *arg ) { { L3DelTimer(& pc->timer); pc->para.loc = 0U; pc->para.cause = 102U; l3ni1_disconnect_req(pc, (int )pr, 0); (*((pc->st)->l3.l3l4))(pc->st, 993, (void *)pc); return; } } static void l3ni1_t305(struct l3_process *pc , u_char pr , void *arg ) { u_char tmp[16U] ; u_char *p ; int l ; struct sk_buff *skb ; u_char cause ; u_char *tmp___0 ; u_char *tmp___1 ; u_char *tmp___2 ; u_char *tmp___3 ; u_char *tmp___4 ; u_char *tmp___5 ; u_char *tmp___6 ; u_char *tmp___7 ; u_char *tmp___8 ; size_t __len ; void *__ret ; unsigned char *tmp___10 ; { p = (u_char *)(& tmp); cause = 16U; L3DelTimer(& pc->timer); if ((unsigned int )pc->para.cause != 254U) { cause = pc->para.cause; } else { } tmp___0 = p; p = p + 1; *tmp___0 = 8U; if (pc->callref == -1) { tmp___1 = p; p = p + 1; *tmp___1 = 0U; } else { tmp___2 = p; p = p + 1; *tmp___2 = 1U; tmp___3 = p; p = p + 1; *tmp___3 = (u_char )((int )((signed char )pc->callref) ^ -128); } tmp___4 = p; p = p + 1; *tmp___4 = 77U; tmp___5 = p; p = p + 1; *tmp___5 = 8U; tmp___6 = p; p = p + 1; *tmp___6 = 2U; tmp___7 = p; p = p + 1; *tmp___7 = 128U; tmp___8 = p; p = p + 1; *tmp___8 = (u_char )((unsigned int )cause | 128U); l = (int )((unsigned int )((long )p) - (unsigned int )((long )(& tmp))); skb = l3_alloc_skb(l); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } __len = (size_t )l; tmp___10 = skb_put(skb, (unsigned int )l); __ret = memcpy((void *)tmp___10, (void const *)(& tmp), __len); newl3state(pc, 19); l3_msg(pc->st, 544, (void *)skb); L3AddTimer(& pc->timer, 4000, 904); return; } } static void l3ni1_t310(struct l3_process *pc , u_char pr , void *arg ) { { L3DelTimer(& pc->timer); pc->para.loc = 0U; pc->para.cause = 102U; l3ni1_disconnect_req(pc, (int )pr, 0); (*((pc->st)->l3.l3l4))(pc->st, 993, (void *)pc); return; } } static void l3ni1_t313(struct l3_process *pc , u_char pr , void *arg ) { { L3DelTimer(& pc->timer); pc->para.loc = 0U; pc->para.cause = 102U; l3ni1_disconnect_req(pc, (int )pr, 0); (*((pc->st)->l3.l3l4))(pc->st, 996, (void *)pc); return; } } static void l3ni1_t308_1(struct l3_process *pc , u_char pr , void *arg ) { { newl3state(pc, 19); L3DelTimer(& pc->timer); l3ni1_message(pc, 77); L3AddTimer(& pc->timer, 4000, 906); return; } } static void l3ni1_t308_2(struct l3_process *pc , u_char pr , void *arg ) { { L3DelTimer(& pc->timer); (*((pc->st)->l3.l3l4))(pc->st, 997, (void *)pc); ni1_release_l3_process(pc); return; } } static void l3ni1_t318(struct l3_process *pc , u_char pr , void *arg ) { { L3DelTimer(& pc->timer); pc->para.cause = 102U; pc->para.loc = 0U; (*((pc->st)->l3.l3l4))(pc->st, 995, (void *)pc); newl3state(pc, 19); l3ni1_message(pc, 77); L3AddTimer(& pc->timer, 4000, 904); return; } } static void l3ni1_t319(struct l3_process *pc , u_char pr , void *arg ) { { L3DelTimer(& pc->timer); pc->para.cause = 102U; pc->para.loc = 0U; (*((pc->st)->l3.l3l4))(pc->st, 994, (void *)pc); newl3state(pc, 10); return; } } static void l3ni1_restart(struct l3_process *pc , u_char pr , void *arg ) { { L3DelTimer(& pc->timer); (*((pc->st)->l3.l3l4))(pc->st, 874, (void *)pc); ni1_release_l3_process(pc); return; } } static void l3ni1_status(struct l3_process *pc , u_char pr , void *arg ) { u_char *p ; struct sk_buff *skb ; int ret ; u_char cause ; u_char callState ; int tmp ; u_char *tmp___0 ; u_char tmp___1 ; { skb = (struct sk_buff *)arg; cause = 0U; callState = 0U; ret = l3ni1_get_cause(pc, skb); if (ret != 0) { if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"STATUS get_cause ret(%d)", ret); } else { } if (ret < 0) { cause = 96U; } else if (ret > 0) { cause = 100U; } else { } } else { } p = findie(skb->data, (int )skb->len, 20, 0); if ((unsigned long )p != (unsigned long )((u_char *)0)) { p = p + 1; tmp___0 = p; p = p + 1; if ((unsigned int )*tmp___0 == 1U) { callState = *p; tmp = ie_in_set___0(pc, (int )*p, (int *)(& l3_valid_states___0)); if (tmp == 0) { cause = 100U; } else { } } else { cause = 100U; } } else { cause = 96U; } if ((unsigned int )cause == 0U) { ret = check_infoelements___0(pc, skb, (int *)(& ie_STATUS___0)); if (ret == 1) { cause = 96U; } else if (ret == -1) { cause = 99U; } else { } } else { } if ((unsigned int )cause != 0U) { if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"STATUS error(%d/%d)", ret, (int )cause); } else { } tmp___1 = pc->para.cause; pc->para.cause = cause; l3ni1_status_send(pc, 0, 0); if ((unsigned int )cause == 99U) { pc->para.cause = tmp___1; } else { return; } } else { } cause = pc->para.cause; if (((int )cause & 127) == 111 && (unsigned int )callState == 0U) { (*((pc->st)->l3.l3l4))(pc->st, 874, (void *)pc); newl3state(pc, 0); ni1_release_l3_process(pc); } else { } return; } } static void l3ni1_facility(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; int ret ; u_char *p ; { skb = (struct sk_buff *)arg; ret = check_infoelements___0(pc, skb, (int *)(& ie_FACILITY___0)); l3ni1_std_ie_err(pc, ret); p = findie(skb->data, (int )skb->len, 28, 0); if ((unsigned long )p != (unsigned long )((u_char *)0)) { l3ni1_parse_facility(pc->st, pc, pc->callref, p); } else { } return; } } static void l3ni1_suspend_req(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; u_char tmp[32U] ; u_char *p ; u_char i ; u_char l ; u_char *msg ; u_char *tmp___0 ; u_char *tmp___1 ; u_char *tmp___2 ; u_char *tmp___3 ; u_char *tmp___4 ; u_char *tmp___5 ; u_char *tmp___6 ; u_char *tmp___7 ; u_char *tmp___8 ; u_char *tmp___9 ; size_t __len ; void *__ret ; unsigned char *tmp___11 ; { p = (u_char *)(& tmp); msg = (u_char *)(& (pc->chan)->setup.phone); tmp___0 = p; p = p + 1; *tmp___0 = 8U; if (pc->callref == -1) { tmp___1 = p; p = p + 1; *tmp___1 = 0U; } else { tmp___2 = p; p = p + 1; *tmp___2 = 1U; tmp___3 = p; p = p + 1; *tmp___3 = (u_char )((int )((signed char )pc->callref) ^ -128); } tmp___4 = p; p = p + 1; *tmp___4 = 37U; tmp___5 = msg; msg = msg + 1; l = *tmp___5; if ((unsigned int )l != 0U && (unsigned int )l <= 10U) { tmp___6 = p; p = p + 1; *tmp___6 = 16U; tmp___7 = p; p = p + 1; *tmp___7 = l; i = 0U; goto ldv_41748; ldv_41747: tmp___8 = p; p = p + 1; tmp___9 = msg; msg = msg + 1; *tmp___8 = *tmp___9; i = (u_char )((int )i + 1); ldv_41748: ; if ((int )i < (int )l) { goto ldv_41747; } else { } } else if ((unsigned int )l != 0U) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"SUS wrong CALL_ID len %d", (int )l); return; } else { } l = (int )((u_char )((long )p)) - (int )((u_char )((long )(& tmp))); skb = l3_alloc_skb((int )l); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } __len = (size_t )l; tmp___11 = skb_put(skb, (unsigned int )l); __ret = memcpy((void *)tmp___11, (void const *)(& tmp), __len); l3_msg(pc->st, 544, (void *)skb); newl3state(pc, 15); L3AddTimer(& pc->timer, 4000, 921); return; } } static void l3ni1_suspend_ack(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; int ret ; { skb = (struct sk_buff *)arg; L3DelTimer(& pc->timer); newl3state(pc, 0); pc->para.cause = 254U; (*((pc->st)->l3.l3l4))(pc->st, 881, (void *)pc); ret = check_infoelements___0(pc, skb, (int *)(& ie_SUSPEND_ACKNOWLEDGE___0)); if (ret != 0) { if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"SUSPACK check ie(%d)", ret); } else { } } else { } ni1_release_l3_process(pc); return; } } static void l3ni1_suspend_rej(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; int ret ; { skb = (struct sk_buff *)arg; ret = l3ni1_get_cause(pc, skb); if (ret != 0) { if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"SUSP_REJ get_cause ret(%d)", ret); } else { } if (ret < 0) { pc->para.cause = 96U; } else { pc->para.cause = 100U; } l3ni1_status_send(pc, (int )pr, 0); return; } else { } ret = check_infoelements___0(pc, skb, (int *)(& ie_SUSPEND_REJECT___0)); if (ret == 1) { l3ni1_std_ie_err(pc, ret); return; } else { } L3DelTimer(& pc->timer); (*((pc->st)->l3.l3l4))(pc->st, 994, (void *)pc); newl3state(pc, 10); if (ret != 0) { l3ni1_std_ie_err(pc, ret); } else { } return; } } static void l3ni1_resume_req(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; u_char tmp[32U] ; u_char *p ; u_char i ; u_char l ; u_char *msg ; u_char *tmp___0 ; u_char *tmp___1 ; u_char *tmp___2 ; u_char *tmp___3 ; u_char *tmp___4 ; u_char *tmp___5 ; u_char *tmp___6 ; u_char *tmp___7 ; u_char *tmp___8 ; u_char *tmp___9 ; size_t __len ; void *__ret ; unsigned char *tmp___11 ; { p = (u_char *)(& tmp); msg = (u_char *)(& pc->para.setup.phone); tmp___0 = p; p = p + 1; *tmp___0 = 8U; if (pc->callref == -1) { tmp___1 = p; p = p + 1; *tmp___1 = 0U; } else { tmp___2 = p; p = p + 1; *tmp___2 = 1U; tmp___3 = p; p = p + 1; *tmp___3 = (u_char )((int )((signed char )pc->callref) ^ -128); } tmp___4 = p; p = p + 1; *tmp___4 = 38U; tmp___5 = msg; msg = msg + 1; l = *tmp___5; if ((unsigned int )l != 0U && (unsigned int )l <= 10U) { tmp___6 = p; p = p + 1; *tmp___6 = 16U; tmp___7 = p; p = p + 1; *tmp___7 = l; i = 0U; goto ldv_41779; ldv_41778: tmp___8 = p; p = p + 1; tmp___9 = msg; msg = msg + 1; *tmp___8 = *tmp___9; i = (u_char )((int )i + 1); ldv_41779: ; if ((int )i < (int )l) { goto ldv_41778; } else { } } else if ((unsigned int )l != 0U) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"RES wrong CALL_ID len %d", (int )l); return; } else { } l = (int )((u_char )((long )p)) - (int )((u_char )((long )(& tmp))); skb = l3_alloc_skb((int )l); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } __len = (size_t )l; tmp___11 = skb_put(skb, (unsigned int )l); __ret = memcpy((void *)tmp___11, (void const *)(& tmp), __len); l3_msg(pc->st, 544, (void *)skb); newl3state(pc, 17); L3AddTimer(& pc->timer, 4000, 920); return; } } static void l3ni1_resume_ack(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; int id___0 ; int ret ; { skb = (struct sk_buff *)arg; id___0 = l3ni1_get_channel_id(pc, skb); if (id___0 > 0) { if (id___0 == 0 || (id___0 == 3 && (unsigned int )pc->para.moderate == 16U)) { if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"resume ack with wrong chid %x", id___0); } else { } pc->para.cause = 100U; l3ni1_status_send(pc, (int )pr, 0); return; } else { } pc->para.bchannel = id___0; } else if (pc->state == 1) { if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"resume ack without chid (ret %d)", id___0); } else { } pc->para.cause = 96U; l3ni1_status_send(pc, (int )pr, 0); return; } else { } ret = check_infoelements___0(pc, skb, (int *)(& ie_RESUME_ACKNOWLEDGE___0)); if (ret == 1) { l3ni1_std_ie_err(pc, ret); return; } else { } L3DelTimer(& pc->timer); (*((pc->st)->l3.l3l4))(pc->st, 773, (void *)pc); newl3state(pc, 10); if (ret != 0) { l3ni1_std_ie_err(pc, ret); } else { } return; } } static void l3ni1_resume_rej(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; int ret ; { skb = (struct sk_buff *)arg; ret = l3ni1_get_cause(pc, skb); if (ret != 0) { if (pc->debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"RES_REJ get_cause ret(%d)", ret); } else { } if (ret < 0) { pc->para.cause = 96U; } else { pc->para.cause = 100U; } l3ni1_status_send(pc, (int )pr, 0); return; } else { } ret = check_infoelements___0(pc, skb, (int *)(& ie_RESUME_REJECT___0)); if (ret == 1) { l3ni1_std_ie_err(pc, ret); return; } else { } L3DelTimer(& pc->timer); (*((pc->st)->l3.l3l4))(pc->st, 995, (void *)pc); newl3state(pc, 0); if (ret != 0) { l3ni1_std_ie_err(pc, ret); } else { } ni1_release_l3_process(pc); return; } } static void l3ni1_global_restart(struct l3_process *pc , u_char pr , void *arg ) { u_char tmp[32U] ; u_char *p ; u_char ri ; u_char ch ; u_char chan ; int l ; struct sk_buff *skb ; struct l3_process *up___0 ; u_char *tmp___0 ; u_char *tmp___1 ; u_char *tmp___2 ; u_char *tmp___3 ; u_char *tmp___4 ; u_char *tmp___5 ; u_char *tmp___6 ; u_char *tmp___7 ; u_char *tmp___8 ; u_char *tmp___9 ; u_char *tmp___10 ; size_t __len ; void *__ret ; unsigned char *tmp___12 ; { ch = 0U; chan = 0U; skb = (struct sk_buff *)arg; newl3state(pc, 2); L3DelTimer(& pc->timer); p = skb->data; p = findie(p, (int )skb->len, 121, 0); if ((unsigned long )p != (unsigned long )((u_char *)0)) { ri = *(p + 2UL); HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"Restart %x", (int )ri); } else { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"Restart without restart IE"); ri = 134U; } p = skb->data; p = findie(p, (int )skb->len, 24, 0); if ((unsigned long )p != (unsigned long )((u_char *)0)) { chan = (unsigned int )*(p + 2UL) & 3U; ch = *(p + 2UL); if ((pc->st)->l3.debug != 0) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"Restart for channel %d", (int )chan); } else { } } else { } newl3state(pc, 2); up___0 = (pc->st)->l3.proc; goto ldv_41813; ldv_41812: ; if (((int )ri & 7) == 7) { (*((up___0->st)->lli.l4l3))(up___0->st, 1012, (void *)up___0); } else if (up___0->para.bchannel == (int )chan) { (*((up___0->st)->lli.l4l3))(up___0->st, 1012, (void *)up___0); } else { } up___0 = up___0->next; ldv_41813: ; if ((unsigned long )up___0 != (unsigned long )((struct l3_process *)0)) { goto ldv_41812; } else { } p = (u_char *)(& tmp); tmp___0 = p; p = p + 1; *tmp___0 = 8U; if (pc->callref == -1) { tmp___1 = p; p = p + 1; *tmp___1 = 0U; } else { tmp___2 = p; p = p + 1; *tmp___2 = 1U; tmp___3 = p; p = p + 1; *tmp___3 = (u_char )((int )((signed char )pc->callref) ^ -128); } tmp___4 = p; p = p + 1; *tmp___4 = 78U; if ((unsigned int )chan != 0U) { tmp___5 = p; p = p + 1; *tmp___5 = 24U; tmp___6 = p; p = p + 1; *tmp___6 = 1U; tmp___7 = p; p = p + 1; *tmp___7 = (u_char )((unsigned int )ch | 128U); } else { } tmp___8 = p; p = p + 1; *tmp___8 = 121U; tmp___9 = p; p = p + 1; *tmp___9 = 1U; tmp___10 = p; p = p + 1; *tmp___10 = ri; l = (int )((unsigned int )((long )p) - (unsigned int )((long )(& tmp))); skb = l3_alloc_skb(l); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } __len = (size_t )l; tmp___12 = skb_put(skb, (unsigned int )l); __ret = memcpy((void *)tmp___12, (void const *)(& tmp), __len); newl3state(pc, 0); l3_msg(pc->st, 544, (void *)skb); return; } } static void l3ni1_dl_reset(struct l3_process *pc , u_char pr , void *arg ) { { pc->para.cause = 41U; pc->para.loc = 0U; l3ni1_disconnect_req(pc, (int )pr, 0); (*((pc->st)->l3.l3l4))(pc->st, 993, (void *)pc); return; } } static void l3ni1_dl_release(struct l3_process *pc , u_char pr , void *arg ) { { newl3state(pc, 0); pc->para.cause = 27U; pc->para.loc = 0U; (*((pc->st)->l3.l3l4))(pc->st, 874, (void *)pc); release_l3_process(pc); return; } } static void l3ni1_dl_reestablish(struct l3_process *pc , u_char pr , void *arg ) { { L3DelTimer(& pc->timer); L3AddTimer(& pc->timer, 40000, 777); l3_msg(pc->st, 512, 0); return; } } static void l3ni1_dl_reest_status(struct l3_process *pc , u_char pr , void *arg ) { { L3DelTimer(& pc->timer); pc->para.cause = 31U; l3ni1_status_send(pc, 0, 0); return; } } static void l3ni1_SendSpid(struct l3_process *pc , u_char pr , struct sk_buff *skb , int iNewState ) { u_char *p ; char *pSPID ; struct Channel *pChan ; int l ; size_t tmp ; unsigned char *tmp___0 ; u_char *tmp___1 ; u_char *tmp___2 ; u_char *tmp___3 ; u_char *tmp___4 ; u_char *tmp___5 ; size_t __len ; void *__ret ; unsigned char *tmp___7 ; { pChan = (struct Channel *)(pc->st)->lli.userdata; if ((unsigned long )skb != (unsigned long )((struct sk_buff *)0)) { consume_skb(skb); } else { } pSPID = strchr((char const *)(& pChan->setup.eazmsn), 58); if ((unsigned long )pSPID == (unsigned long )((char *)0)) { printk("\vSPID not supplied in EAZMSN %s\n", (unsigned char *)(& pChan->setup.eazmsn)); newl3state(pc, 0); (*((pc->st)->l3.l3l2))(pc->st, 528, 0); return; } else { } pSPID = pSPID + 1; tmp = strlen((char const *)pSPID); l = (int )tmp; skb = l3_alloc_skb(l + 5); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { printk("\vHiSax can\'t get memory to send SPID\n"); return; } else { } tmp___0 = skb_put(skb, 5U); p = tmp___0; tmp___1 = p; p = p + 1; *tmp___1 = 8U; tmp___2 = p; p = p + 1; *tmp___2 = 0U; tmp___3 = p; p = p + 1; *tmp___3 = 123U; tmp___4 = p; p = p + 1; *tmp___4 = 58U; tmp___5 = p; p = p + 1; *tmp___5 = (u_char )l; __len = (size_t )l; tmp___7 = skb_put(skb, (unsigned int )l); __ret = memcpy((void *)tmp___7, (void const *)pSPID, __len); newl3state(pc, iNewState); L3DelTimer(& pc->timer); L3AddTimer(& pc->timer, 5000, 928); (*((pc->st)->l3.l3l2))(pc->st, 544, (void *)skb); return; } } static void l3ni1_spid_send(struct l3_process *pc , u_char pr , void *arg ) { { l3ni1_SendSpid(pc, (int )pr, (struct sk_buff *)arg, 20); return; } } static void l3ni1_spid_epid(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; { skb = (struct sk_buff *)arg; if ((unsigned int )*(skb->data + 1UL) == 0U) { if ((unsigned int )*(skb->data + 3UL) == 59U) { L3DelTimer(& pc->timer); newl3state(pc, 0); l3_msg(pc->st, 513, 0); } else { } } else { } consume_skb(skb); return; } } static void l3ni1_spid_tout(struct l3_process *pc , u_char pr , void *arg ) { { if (pc->state <= 21) { l3ni1_SendSpid(pc, (int )pr, (struct sk_buff *)arg, pc->state + 1); } else { L3DelTimer(& pc->timer); consume_skb((struct sk_buff *)arg); printk("\vSPID not accepted\n"); newl3state(pc, 0); (*((pc->st)->l3.l3l2))(pc->st, 528, 0); } return; } } static struct stateentry downstatelist___0[28U] = { {1, 768, & l3ni1_setup_req}, {1, 772, & l3ni1_resume_req}, {33556446, 864, & l3ni1_disconnect_req}, {4096, 872, & l3ni1_release_req}, {67108863, 1012, & l3ni1_restart}, {33554496, 800, & l3ni1_reset}, {33554496, 804, & l3ni1_reject_req}, {33554496, 884, & l3ni1_proceed_req}, {64, 784, & l3ni1_setup_ack_req}, {33554432, 784, & l3ni1_dummy}, {33555008, 836, & l3ni1_alert_req}, {33555136, 771, & l3ni1_setup_rsp}, {1024, 880, & l3ni1_suspend_req}, {33555072, 888, & l3ni1_redir_req}, {64, 888, & l3ni1_redir_req_early}, {33554944, 864, & l3ni1_disconnect_req}, {33554432, 898, & l3ni1_t302}, {2, 899, & l3ni1_t303}, {4, 900, & l3ni1_t304}, {8, 912, & l3ni1_t310}, {256, 915, & l3ni1_t313}, {2048, 901, & l3ni1_t305}, {32768, 921, & l3ni1_t319}, {131072, 920, & l3ni1_t318}, {524288, 904, & l3ni1_t308_1}, {524288, 906, & l3ni1_t308_2}, {1024, 777, & l3ni1_dl_release}, {7340032, 928, & l3ni1_spid_tout}}; static struct stateentry datastatelist___0[23U] = { {67108863, 117, & l3ni1_status_enq}, {67108863, 98, & l3ni1_facility}, {524288, 125, & l3ni1_release_ind}, {67108863, 125, & l3ni1_status}, {1, 5, & l3ni1_setup}, {34250688, 5, & l3ni1_dummy}, {6, 2, & l3ni1_call_proc}, {2, 13, & l3ni1_setup_ack}, {12, 1, & l3ni1_alerting}, {12, 3, & l3ni1_progress}, {34250652, 123, & l3ni1_information}, {35840, 110, & l3ni1_notify}, {34250143, 90, & l3ni1_release_cmpl}, {33726366, 77, & l3ni1_release}, {524288, 77, & l3ni1_release_ind}, {33722270, 69, & l3ni1_disconnect}, {524288, 69, & l3ni1_dummy}, {30, 7, & l3ni1_connect}, {256, 15, & l3ni1_connect_ack}, {32768, 45, & l3ni1_suspend_ack}, {32768, 33, & l3ni1_suspend_rej}, {131072, 46, & l3ni1_resume_ack}, {131072, 34, & l3ni1_resume_rej}}; static struct stateentry globalmes_list___0[4U] = { {67108863, 125, & l3ni1_status}, {1, 70, & l3ni1_global_restart}, {1, 254, & l3ni1_spid_send}, {7340032, 123, & l3ni1_spid_epid}}; static struct stateentry manstatelist___0[4U] = { {4, 514, & l3ni1_dl_reset}, {1024, 513, & l3ni1_dl_reest_status}, {1024, 530, & l3ni1_dl_reestablish}, {67108863, 530, & l3ni1_dl_release}}; static void global_handler___0(struct PStack *st , int mt , struct sk_buff *skb ) { u_char tmp[16U] ; u_char *p ; int l ; int i ; struct l3_process *proc ; u_char *tmp___0 ; u_char *tmp___1 ; u_char *tmp___2 ; u_char *tmp___3 ; u_char *tmp___4 ; u_char *tmp___5 ; u_char *tmp___6 ; u_char *tmp___7 ; u_char *tmp___8 ; u_char *tmp___9 ; u_char *tmp___10 ; u_char *tmp___11 ; size_t __len ; void *__ret ; unsigned char *tmp___13 ; { p = (u_char *)(& tmp); proc = st->l3.global; if ((unsigned long )skb != (unsigned long )((struct sk_buff *)0)) { proc->callref = (int )*(skb->data + 2UL); } else { proc->callref = 0; } i = 0; goto ldv_41885; ldv_41884: ; if (globalmes_list___0[i].primitive == mt && (globalmes_list___0[i].state >> proc->state) & 1) { goto ldv_41883; } else { } i = i + 1; ldv_41885: ; if ((unsigned int )i <= 3U) { goto ldv_41884; } else { } ldv_41883: ; if (i == 4) { if ((st->l3.debug & 4) != 0) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"ni1 global state %d mt %x unhandled", proc->state, mt); } else { } tmp___0 = p; p = p + 1; *tmp___0 = 8U; if (proc->callref == -1) { tmp___1 = p; p = p + 1; *tmp___1 = 0U; } else { tmp___2 = p; p = p + 1; *tmp___2 = 1U; tmp___3 = p; p = p + 1; *tmp___3 = (u_char )((int )((signed char )proc->callref) ^ -128); } tmp___4 = p; p = p + 1; *tmp___4 = 125U; tmp___5 = p; p = p + 1; *tmp___5 = 8U; tmp___6 = p; p = p + 1; *tmp___6 = 2U; tmp___7 = p; p = p + 1; *tmp___7 = 128U; tmp___8 = p; p = p + 1; *tmp___8 = 209U; tmp___9 = p; p = p + 1; *tmp___9 = 20U; tmp___10 = p; p = p + 1; *tmp___10 = 1U; tmp___11 = p; p = p + 1; *tmp___11 = (unsigned int )((u_char )proc->state) & 63U; l = (int )((unsigned int )((long )p) - (unsigned int )((long )(& tmp))); skb = l3_alloc_skb(l); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } __len = (size_t )l; tmp___13 = skb_put(skb, (unsigned int )l); __ret = memcpy((void *)tmp___13, (void const *)(& tmp), __len); l3_msg(proc->st, 544, (void *)skb); } else { if ((st->l3.debug & 4) != 0) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"ni1 global %d mt %x", proc->state, mt); } else { } (*(globalmes_list___0[i].rout))(proc, (int )((u8 )mt), (void *)skb); } return; } } static void ni1up(struct PStack *st , int pr , void *arg ) { int i ; int mt ; int cr ; int callState ; char *ptr ; u_char *p ; struct sk_buff *skb ; struct l3_process *proc ; char *tmp ; u_char *tmp___0 ; char *tmp___1 ; u_char *tmp___2 ; int tmp___3 ; { skb = (struct sk_buff *)arg; switch (pr) { case 546: ; case 562: ; goto ldv_41906; case 514: ; case 530: ; case 529: l3_msg(st, pr, arg); return; case 513: global_handler___0(st, 254, 0); return; default: printk("\vHiSax ni1up unknown pr=%04x\n", pr); return; } ldv_41906: ; if (skb->len <= 2U) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"ni1up frame too short(%d)", skb->len); consume_skb(skb); return; } else { } if ((unsigned int )*(skb->data) != 8U) { if ((st->l3.debug & 2) != 0) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"ni1up%sunexpected discriminator %x message len %d", pr == 546 ? (char *)" " : (char *)"(broadcast) ", (int )*(skb->data), skb->len); } else { } consume_skb(skb); return; } else { } cr = getcallref(skb->data); if (skb->len < (unsigned int )(((int )*(skb->data + 1UL) & 15) + 3)) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"ni1up frame too short(%d)", skb->len); consume_skb(skb); return; } else { } mt = (int )*(skb->data + ((unsigned long )*(skb->data + 1UL) + 2UL)); if ((st->l3.debug & 4) != 0) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"ni1up cr %d", cr); } else { } if (cr == -2) { if (st->l3.debug & 1) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"ni1up wrong Callref"); } else { } consume_skb(skb); return; } else if (cr == -1) { if (mt == 98) { p = findie(skb->data, (int )skb->len, 28, 0); if ((unsigned long )p != (unsigned long )((u_char *)0)) { l3ni1_parse_facility(st, 0, pr == 546 ? -1 : -2, p); consume_skb(skb); return; } else { global_handler___0(st, mt, skb); return; } } else { } if (st->l3.debug & 1) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"ni1up dummy Callref (no facility msg or ie)"); } else { } consume_skb(skb); return; } else if ((((int )*(skb->data + 1UL) & 15) == 1 && (cr & 127) == 0) || (((int )*(skb->data + 1UL) & 15) == 2 && (cr & 32767) == 0)) { if ((st->l3.debug & 4) != 0) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"ni1up Global CallRef"); } else { } global_handler___0(st, mt, skb); consume_skb(skb); return; } else { proc = getl3proc(st, cr); if ((unsigned long )proc == (unsigned long )((struct l3_process *)0)) { if (mt == 5) { if ((int )((signed char )*(skb->data + 2UL)) < 0) { if ((st->l3.debug & 4) != 0) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"ni1up wrong CRef flag"); } else { } consume_skb(skb); return; } else { } proc = ni1_new_l3_process(st, cr); if ((unsigned long )proc == (unsigned long )((struct l3_process *)0)) { consume_skb(skb); return; } else { } } else if (mt == 125) { tmp___0 = findie(skb->data, (int )skb->len, 8, 0); ptr = (char *)tmp___0; if ((unsigned long )ptr != (unsigned long )((char *)0)) { ptr = ptr + 1; tmp = ptr; ptr = ptr + 1; if ((int )((signed char )*tmp) == 2) { ptr = ptr + 1; } else { } } else { } callState = 0; tmp___2 = findie(skb->data, (int )skb->len, 20, 0); ptr = (char *)tmp___2; if ((unsigned long )ptr != (unsigned long )((char *)0)) { ptr = ptr + 1; tmp___1 = ptr; ptr = ptr + 1; if ((int )((signed char )*tmp___1) == 2) { ptr = ptr + 1; } else { } callState = (int )*ptr; } else { } if (callState != 0) { proc = ni1_new_l3_process(st, cr); if ((unsigned long )proc != (unsigned long )((struct l3_process *)0)) { proc->para.cause = 101U; l3ni1_msg_without_setup(proc, 0, 0); } else { } } else { } consume_skb(skb); return; } else if (mt == 90) { consume_skb(skb); return; } else { consume_skb(skb); proc = ni1_new_l3_process(st, cr); if ((unsigned long )proc != (unsigned long )((struct l3_process *)0)) { proc->para.cause = 81U; l3ni1_msg_without_setup(proc, 0, 0); } else { } return; } } else { } } tmp___3 = l3ni1_check_messagetype_validity(proc, mt, (void *)skb); if (tmp___3 != 0) { consume_skb(skb); return; } else { } p = findie(skb->data, (int )skb->len, 40, 0); if ((unsigned long )p != (unsigned long )((u_char *)0)) { l3ni1_deliver_display(proc, pr, p); } else { } i = 0; goto ldv_41916; ldv_41915: ; if (datastatelist___0[i].primitive == mt && (datastatelist___0[i].state >> proc->state) & 1) { goto ldv_41914; } else { } i = i + 1; ldv_41916: ; if ((unsigned int )i <= 22U) { goto ldv_41915; } else { } ldv_41914: ; if (i == 23) { if ((st->l3.debug & 4) != 0) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"ni1up%sstate %d mt %#x unhandled", pr == 546 ? (char *)" " : (char *)"(broadcast) ", proc->state, mt); } else { } if (mt != 90 && mt != 77) { proc->para.cause = 101U; l3ni1_status_send(proc, (int )((u_char )pr), (void *)skb); } else { } } else { if ((st->l3.debug & 4) != 0) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"ni1up%sstate %d mt %x", pr == 546 ? (char *)" " : (char *)"(broadcast) ", proc->state, mt); } else { } (*(datastatelist___0[i].rout))(proc, (int )((u8 )pr), (void *)skb); } consume_skb(skb); return; } } static void ni1down(struct PStack *st , int pr , void *arg ) { int i ; int cr ; struct l3_process *proc ; struct Channel *chan ; size_t __len ; void *__ret ; { if (pr == 512) { l3_msg(st, pr, 0); return; } else if (pr == 768 || pr == 772) { chan = (struct Channel *)arg; cr = newcallref(); cr = cr | 128; proc = ni1_new_l3_process(st, cr); if ((unsigned long )proc != (unsigned long )((struct l3_process *)0)) { proc->chan = chan; chan->proc = proc; __len = 68UL; if (__len > 63UL) { __ret = memcpy((void *)(& proc->para.setup), (void const *)(& chan->setup), __len); } else { __ret = memcpy((void *)(& proc->para.setup), (void const *)(& chan->setup), __len); } proc->callref = cr; } else { } } else { proc = (struct l3_process *)arg; } if ((unsigned long )proc == (unsigned long )((struct l3_process *)0)) { printk("\vHiSax ni1down without proc pr=%04x\n", pr); return; } else { } if (pr == 5109) { l3ni1_io_timer(proc); return; } else { } i = 0; goto ldv_41935; ldv_41934: ; if (downstatelist___0[i].primitive == pr && (downstatelist___0[i].state >> proc->state) & 1) { goto ldv_41933; } else { } i = i + 1; ldv_41935: ; if ((unsigned int )i <= 27U) { goto ldv_41934; } else { } ldv_41933: ; if (i == 28) { if ((st->l3.debug & 4) != 0) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"ni1down state %d prim %#x unhandled", proc->state, pr); } else { if ((st->l3.debug & 4) != 0) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"ni1down state %d prim %#x", proc->state, pr); } else { } (*(downstatelist___0[i].rout))(proc, (int )((u8 )pr), arg); } } else { } return; } } static void ni1man(struct PStack *st , int pr , void *arg ) { int i ; struct l3_process *proc ; { proc = (struct l3_process *)arg; if ((unsigned long )proc == (unsigned long )((struct l3_process *)0)) { printk("\vHiSax ni1man without proc pr=%04x\n", pr); return; } else { } i = 0; goto ldv_41949; ldv_41948: ; if (manstatelist___0[i].primitive == pr && (manstatelist___0[i].state >> proc->state) & 1) { goto ldv_41947; } else { } i = i + 1; ldv_41949: ; if ((unsigned int )i <= 3U) { goto ldv_41948; } else { } ldv_41947: ; if (i == 4) { if ((st->l3.debug & 4) != 0) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"cr %d ni1man state %d prim %#x unhandled", proc->callref & 127, proc->state, pr); } else { if ((st->l3.debug & 4) != 0) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"cr %d ni1man state %d prim %#x", proc->callref & 127, proc->state, pr); } else { } (*(manstatelist___0[i].rout))(proc, (int )((u8 )pr), arg); } } else { } return; } } void setstack_ni1(struct PStack *st ) { char tmp[64U] ; int i ; int tmp___0 ; struct l3_process *tmp___1 ; void *tmp___2 ; char *tmp___3 ; { st->lli.l4l3 = & ni1down; st->lli.l4l3_proto = & l3ni1_cmd_global; st->l2.l2l3 = & ni1up; st->l3.l3ml3 = & ni1man; st->l3.N303 = 1; st->prot.ni1.last_invoke_id = 0U; st->prot.ni1.invoke_used[0] = 1U; i = 1; goto ldv_41958; ldv_41957: tmp___0 = i; i = i + 1; st->prot.ni1.invoke_used[tmp___0] = 0U; ldv_41958: ; if (i <= 31) { goto ldv_41957; } else { } tmp___2 = kmalloc(360UL, 32U); tmp___1 = (struct l3_process *)tmp___2; st->l3.global = tmp___1; if ((unsigned long )tmp___1 == (unsigned long )((struct l3_process *)0)) { printk("\vHiSax can\'t get memory for ni1 global CR\n"); } else { (st->l3.global)->state = 0; (st->l3.global)->callref = 0; (st->l3.global)->next = 0; (st->l3.global)->debug = 1; (st->l3.global)->st = st; (st->l3.global)->N303 = 1; (st->l3.global)->prot.ni1.invoke_id = 0U; L3InitTimer(st->l3.global, & (st->l3.global)->timer); } strcpy((char *)(& tmp), ni1_revision); tmp___3 = HiSax_getrev((char const *)(& tmp)); printk("\016HiSax: National ISDN-1 Rev. %s\n", tmp___3); return; } } void ldv_mutex_lock_141(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_lock(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_142(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_lock(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_143(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } int ldv_mutex_trylock_144(struct mutex *ldv_func_arg1 ) { ldv_func_ret_type___2 ldv_func_res ; int tmp ; int tmp___0 ; { tmp = mutex_trylock(ldv_func_arg1); ldv_func_res = tmp; tmp___0 = ldv_mutex_trylock_mutex(ldv_func_arg1); return (tmp___0); return (ldv_func_res); } } void ldv_mutex_unlock_145(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_146(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_cred_guard_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_147(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_cred_guard_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } int ldv_mutex_trylock_158(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_156(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_159(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_161(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_155(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_157(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_160(struct mutex *ldv_func_arg1 ) ; static char const *l3_1tr6_revision = "$Revision: 2.15.2.3 $"; static void l3_1TR6_message(struct l3_process *pc , u_char mt , u_char pd ) { struct sk_buff *skb ; u_char *p ; unsigned char *tmp ; u_char *tmp___0 ; u_char *tmp___1 ; u_char *tmp___2 ; u_char *tmp___3 ; { skb = l3_alloc_skb(4); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } tmp = skb_put(skb, 4U); p = tmp; tmp___0 = p; p = p + 1; *tmp___0 = pd; tmp___1 = p; p = p + 1; *tmp___1 = 1U; tmp___2 = p; p = p + 1; *tmp___2 = (u_char )((int )((signed char )pc->callref) ^ -128); tmp___3 = p; p = p + 1; *tmp___3 = mt; l3_msg(pc->st, 544, (void *)skb); return; } } static void l3_1tr6_release_req(struct l3_process *pc , u_char pr , void *arg ) { { StopAllL3Timer(pc); newl3state(pc, 19); l3_1TR6_message(pc, 77, 65); L3AddTimer(& pc->timer, 4000, 904); return; } } static void l3_1tr6_invalid(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; { skb = (struct sk_buff *)arg; consume_skb(skb); l3_1tr6_release_req(pc, 0, 0); return; } } static void l3_1tr6_error(struct l3_process *pc , u_char *msg , struct sk_buff *skb ) { { consume_skb(skb); if ((pc->st)->l3.debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)msg); } else { } l3_1tr6_release_req(pc, 0, 0); return; } } static void l3_1tr6_setup_req(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; u_char tmp[128U] ; u_char *p ; u_char *teln ; u_char *eaz ; u_char channel ; int l ; u_char *tmp___0 ; u_char *tmp___1 ; u_char *tmp___2 ; u_char *tmp___3 ; u_char *tmp___4 ; u_char *tmp___5 ; u_char *tmp___6 ; u_char *tmp___7 ; u_char *tmp___8 ; u_char *tmp___9 ; u_char *tmp___10 ; u_char *tmp___11 ; u_char *tmp___12 ; u_char *tmp___13 ; u_char *tmp___14 ; u_char *tmp___15 ; u_char *tmp___16 ; u_char *tmp___17 ; u_char *tmp___18 ; u_char *tmp___19 ; u_char *tmp___20 ; size_t tmp___21 ; u_char *tmp___22 ; u_char *tmp___23 ; u_char *tmp___24 ; u_char *tmp___25 ; u_char *tmp___26 ; size_t tmp___27 ; u_char *tmp___28 ; u_char *tmp___29 ; u_char *tmp___30 ; u_char *tmp___31 ; u_char *tmp___32 ; u_char *tmp___33 ; u_char *tmp___34 ; u_char *tmp___35 ; size_t __len ; void *__ret ; unsigned char *tmp___37 ; { p = (u_char *)(& tmp); channel = 0U; tmp___0 = p; p = p + 1; *tmp___0 = 65U; tmp___1 = p; p = p + 1; *tmp___1 = 1U; tmp___2 = p; p = p + 1; *tmp___2 = (u_char )((int )((signed char )pc->callref) ^ -128); tmp___3 = p; p = p + 1; *tmp___3 = 5U; teln = (u_char *)(& pc->para.setup.phone); pc->para.spv = 0; if (((int )_ctype[(int )*teln] & 4) == 0) { switch ((int )*teln & 95) { case 83: pc->para.spv = 1; goto ldv_41030; case 67: channel = 8U; case 80: channel = (u_char )((unsigned int )channel | 128U); teln = teln + 1; if ((unsigned int )*teln == 49U) { channel = (u_char )((unsigned int )channel | 1U); } else { channel = (u_char )((unsigned int )channel | 2U); } goto ldv_41030; default: ; if ((pc->st)->l3.debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"Wrong MSN Code"); } else { } goto ldv_41030; } ldv_41030: teln = teln + 1; } else { } if ((unsigned int )channel != 0U) { tmp___4 = p; p = p + 1; *tmp___4 = 24U; tmp___5 = p; p = p + 1; *tmp___5 = 1U; tmp___6 = p; p = p + 1; *tmp___6 = channel; } else { } if (pc->para.spv != 0) { tmp___7 = p; p = p + 1; *tmp___7 = 32U; tmp___8 = p; p = p + 1; *tmp___8 = 4U; tmp___9 = p; p = p + 1; *tmp___9 = 0U; tmp___10 = p; p = p + 1; *tmp___10 = 31U; tmp___11 = p; p = p + 1; *tmp___11 = pc->para.setup.si1; tmp___12 = p; p = p + 1; *tmp___12 = pc->para.setup.si2; tmp___13 = p; p = p + 1; *tmp___13 = 32U; tmp___14 = p; p = p + 1; *tmp___14 = 4U; tmp___15 = p; p = p + 1; *tmp___15 = 0U; tmp___16 = p; p = p + 1; *tmp___16 = 29U; tmp___17 = p; p = p + 1; *tmp___17 = pc->para.setup.si1; tmp___18 = p; p = p + 1; *tmp___18 = pc->para.setup.si2; } else { } eaz = (u_char *)(& pc->para.setup.eazmsn); if ((unsigned int )*eaz != 0U) { tmp___19 = p; p = p + 1; *tmp___19 = 108U; tmp___20 = p; p = p + 1; tmp___21 = strlen((char const *)eaz); *tmp___20 = (unsigned int )((u_char )tmp___21) + 1U; tmp___22 = p; p = p + 1; *tmp___22 = 129U; goto ldv_41035; ldv_41034: tmp___23 = p; p = p + 1; tmp___24 = eaz; eaz = eaz + 1; *tmp___23 = (unsigned int )*tmp___24 & 127U; ldv_41035: ; if ((unsigned int )*eaz != 0U) { goto ldv_41034; } else { } } else { } tmp___25 = p; p = p + 1; *tmp___25 = 112U; tmp___26 = p; p = p + 1; tmp___27 = strlen((char const *)teln); *tmp___26 = (unsigned int )((u_char )tmp___27) + 1U; tmp___28 = p; p = p + 1; *tmp___28 = 129U; goto ldv_41038; ldv_41037: tmp___29 = p; p = p + 1; tmp___30 = teln; teln = teln + 1; *tmp___29 = (unsigned int )*tmp___30 & 127U; ldv_41038: ; if ((unsigned int )*teln != 0U) { goto ldv_41037; } else { } tmp___31 = p; p = p + 1; *tmp___31 = 150U; tmp___32 = p; p = p + 1; *tmp___32 = 1U; tmp___33 = p; p = p + 1; *tmp___33 = 2U; tmp___34 = p; p = p + 1; *tmp___34 = pc->para.setup.si1; tmp___35 = p; p = p + 1; *tmp___35 = pc->para.setup.si2; l = (int )((unsigned int )((long )p) - (unsigned int )((long )(& tmp))); skb = l3_alloc_skb(l); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } __len = (size_t )l; tmp___37 = skb_put(skb, (unsigned int )l); __ret = memcpy((void *)tmp___37, (void const *)(& tmp), __len); L3DelTimer(& pc->timer); L3AddTimer(& pc->timer, 4000, 899); newl3state(pc, 1); l3_msg(pc->st, 544, (void *)skb); return; } } static void l3_1tr6_setup(struct l3_process *pc , u_char pr , void *arg ) { u_char *p ; int bcfound ; char tmp[80U] ; struct sk_buff *skb ; int tmp___0 ; { bcfound = 0; skb = (struct sk_buff *)arg; p = findie(skb->data, (int )skb->len, 24, 0); if ((unsigned long )p != (unsigned long )((u_char *)0)) { if ((unsigned int )*(p + 1UL) != 1U) { l3_1tr6_error(pc, (u_char *)"setup wrong chanID len", skb); return; } else { } if (((int )*(p + 2UL) & 244) != 128) { l3_1tr6_error(pc, (u_char *)"setup wrong WE0_chanID", skb); return; } else { } tmp___0 = (int )*(p + 2UL) & 3; pc->para.bchannel = tmp___0; if (tmp___0 != 0) { bcfound = bcfound + 1; } else { } } else { l3_1tr6_error(pc, (u_char *)"missing setup chanID", skb); return; } p = skb->data; p = findie(p, (int )skb->len, 1, 6); if ((unsigned long )p != (unsigned long )((u_char *)0)) { pc->para.setup.si1 = *(p + 2UL); pc->para.setup.si2 = *(p + 3UL); } else { l3_1tr6_error(pc, (u_char *)"missing setup SI", skb); return; } p = skb->data; p = findie(p, (int )skb->len, 112, 0); if ((unsigned long )p != (unsigned long )((u_char *)0)) { iecpy((u_char *)(& pc->para.setup.eazmsn), p, 1); } else { pc->para.setup.eazmsn[0] = 0U; } p = skb->data; p = findie(p, (int )skb->len, 108, 0); if ((unsigned long )p != (unsigned long )((u_char *)0)) { iecpy((u_char *)(& pc->para.setup.phone), p, 1); } else { pc->para.setup.phone[0] = 0U; } p = skb->data; pc->para.spv = 0; p = findie(p, (int )skb->len, 32, 0); if ((unsigned long )p != (unsigned long )((u_char *)0)) { if ((unsigned int )*(p + 3UL) == 31U || (unsigned int )*(p + 3UL) == 29U) { pc->para.spv = 1; } else { } } else { } consume_skb(skb); if (bcfound != 0) { if ((unsigned int )pc->para.setup.si1 != 7U && (pc->st)->l3.debug & 1) { sprintf((char *)(& tmp), "non-digital call: %s -> %s", (unsigned char *)(& pc->para.setup.phone), (unsigned char *)(& pc->para.setup.eazmsn)); HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)(& tmp)); } else { } newl3state(pc, 6); (*((pc->st)->l3.l3l4))(pc->st, 770, (void *)pc); } else { release_l3_process(pc); } return; } } static void l3_1tr6_setup_ack(struct l3_process *pc , u_char pr , void *arg ) { u_char *p ; struct sk_buff *skb ; { skb = (struct sk_buff *)arg; L3DelTimer(& pc->timer); p = skb->data; newl3state(pc, 2); p = findie(p, (int )skb->len, 24, 0); if ((unsigned long )p != (unsigned long )((u_char *)0)) { if ((unsigned int )*(p + 1UL) != 1U) { l3_1tr6_error(pc, (u_char *)"setup_ack wrong chanID len", skb); return; } else { } if (((int )*(p + 2UL) & 244) != 128) { l3_1tr6_error(pc, (u_char *)"setup_ack wrong WE0_chanID", skb); return; } else { } pc->para.bchannel = (int )*(p + 2UL) & 3; } else { l3_1tr6_error(pc, (u_char *)"missing setup_ack WE0_chanID", skb); return; } consume_skb(skb); L3AddTimer(& pc->timer, 20000, 900); (*((pc->st)->l3.l3l4))(pc->st, 786, (void *)pc); return; } } static void l3_1tr6_call_sent(struct l3_process *pc , u_char pr , void *arg ) { u_char *p ; struct sk_buff *skb ; { skb = (struct sk_buff *)arg; L3DelTimer(& pc->timer); p = skb->data; p = findie(p, (int )skb->len, 24, 0); if ((unsigned long )p != (unsigned long )((u_char *)0)) { if ((unsigned int )*(p + 1UL) != 1U) { l3_1tr6_error(pc, (u_char *)"call sent wrong chanID len", skb); return; } else { } if (((int )*(p + 2UL) & 244) != 128) { l3_1tr6_error(pc, (u_char *)"call sent wrong WE0_chanID", skb); return; } else { } if (pc->state == 2 && pc->para.bchannel != ((int )*(p + 2UL) & 3)) { l3_1tr6_error(pc, (u_char *)"call sent wrong chanID value", skb); return; } else { } pc->para.bchannel = (int )*(p + 2UL) & 3; } else { l3_1tr6_error(pc, (u_char *)"missing call sent WE0_chanID", skb); return; } consume_skb(skb); L3AddTimer(& pc->timer, 120000, 912); newl3state(pc, 3); (*((pc->st)->l3.l3l4))(pc->st, 834, (void *)pc); return; } } static void l3_1tr6_alert(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; { skb = (struct sk_buff *)arg; consume_skb(skb); L3DelTimer(& pc->timer); newl3state(pc, 4); (*((pc->st)->l3.l3l4))(pc->st, 838, (void *)pc); return; } } static void l3_1tr6_info(struct l3_process *pc , u_char pr , void *arg ) { u_char *p ; int i ; int tmpcharge ; char a_charge[8U] ; char tmp[32U] ; struct sk_buff *skb ; size_t tmp___0 ; { tmpcharge = 0; skb = (struct sk_buff *)arg; p = skb->data; p = findie(p, (int )skb->len, 2, 6); if ((unsigned long )p != (unsigned long )((u_char *)0)) { iecpy((u_char *)(& a_charge), p, 1); i = 0; goto ldv_41084; ldv_41083: tmpcharge = tmpcharge * 10; tmpcharge = ((int )a_charge[i] & 15) + tmpcharge; i = i + 1; ldv_41084: tmp___0 = strlen((char const *)(& a_charge)); if ((size_t )i < tmp___0) { goto ldv_41083; } else { } if (pc->para.chargeinfo < tmpcharge) { pc->para.chargeinfo = tmpcharge; (*((pc->st)->l3.l3l4))(pc->st, 854, (void *)pc); } else { } if (((pc->st)->l3.debug & 8) != 0) { sprintf((char *)(& tmp), "charging info %d", pc->para.chargeinfo); HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)(& tmp)); } else { } } else if (((pc->st)->l3.debug & 8) != 0) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"charging info not found"); } else { } consume_skb(skb); return; } } static void l3_1tr6_info_s2(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; { skb = (struct sk_buff *)arg; consume_skb(skb); return; } } static void l3_1tr6_connect(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; u_char *tmp ; { skb = (struct sk_buff *)arg; L3DelTimer(& pc->timer); tmp = findie(skb->data, (int )skb->len, 3, 6); if ((unsigned long )tmp == (unsigned long )((u_char *)0)) { l3_1tr6_error(pc, (u_char *)"missing connect date", skb); return; } else { } newl3state(pc, 10); consume_skb(skb); pc->para.chargeinfo = 0; (*((pc->st)->l3.l3l4))(pc->st, 769, (void *)pc); return; } } static void l3_1tr6_rel(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; u_char *p ; { skb = (struct sk_buff *)arg; p = skb->data; p = findie(p, (int )skb->len, 8, 0); if ((unsigned long )p != (unsigned long )((u_char *)0)) { if ((unsigned int )*(p + 1UL) != 0U) { pc->para.cause = *(p + 2UL); if ((unsigned int )*(p + 1UL) > 1U) { pc->para.loc = *(p + 3UL); } else { pc->para.loc = 0U; } } else { pc->para.cause = 0U; pc->para.loc = 0U; } } else { pc->para.cause = 254U; l3_1tr6_error(pc, (u_char *)"missing REL cause", skb); return; } consume_skb(skb); StopAllL3Timer(pc); newl3state(pc, 0); l3_1TR6_message(pc, 90, 65); (*((pc->st)->l3.l3l4))(pc->st, 874, (void *)pc); release_l3_process(pc); return; } } static void l3_1tr6_rel_ack(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; { skb = (struct sk_buff *)arg; consume_skb(skb); StopAllL3Timer(pc); newl3state(pc, 0); pc->para.cause = 254U; (*((pc->st)->l3.l3l4))(pc->st, 873, (void *)pc); release_l3_process(pc); return; } } static void l3_1tr6_disc(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; u_char *p ; int i ; int tmpcharge ; char a_charge[8U] ; char tmp[32U] ; size_t tmp___0 ; u_char *tmp___1 ; { skb = (struct sk_buff *)arg; tmpcharge = 0; StopAllL3Timer(pc); p = skb->data; p = findie(p, (int )skb->len, 2, 6); if ((unsigned long )p != (unsigned long )((u_char *)0)) { iecpy((u_char *)(& a_charge), p, 1); i = 0; goto ldv_41123; ldv_41122: tmpcharge = tmpcharge * 10; tmpcharge = ((int )a_charge[i] & 15) + tmpcharge; i = i + 1; ldv_41123: tmp___0 = strlen((char const *)(& a_charge)); if ((size_t )i < tmp___0) { goto ldv_41122; } else { } if (pc->para.chargeinfo < tmpcharge) { pc->para.chargeinfo = tmpcharge; (*((pc->st)->l3.l3l4))(pc->st, 854, (void *)pc); } else { } if (((pc->st)->l3.debug & 8) != 0) { sprintf((char *)(& tmp), "charging info %d", pc->para.chargeinfo); HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)(& tmp)); } else { } } else if (((pc->st)->l3.debug & 8) != 0) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"charging info not found"); } else { } p = skb->data; p = findie(p, (int )skb->len, 8, 0); if ((unsigned long )p != (unsigned long )((u_char *)0)) { if ((unsigned int )*(p + 1UL) != 0U) { pc->para.cause = *(p + 2UL); if ((unsigned int )*(p + 1UL) > 1U) { pc->para.loc = *(p + 3UL); } else { pc->para.loc = 0U; } } else { pc->para.cause = 0U; pc->para.loc = 0U; } } else { if ((pc->st)->l3.debug & 1) { HiSax_putstatus((struct IsdnCardState *)(pc->st)->l1.hardware, (char *)"l3 ", (char *)"cause not found"); } else { } pc->para.cause = 254U; } tmp___1 = findie(skb->data, (int )skb->len, 3, 6); if ((unsigned long )tmp___1 == (unsigned long )((u_char *)0)) { l3_1tr6_error(pc, (u_char *)"missing connack date", skb); return; } else { } consume_skb(skb); newl3state(pc, 12); (*((pc->st)->l3.l3l4))(pc->st, 866, (void *)pc); return; } } static void l3_1tr6_connect_ack(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; u_char *tmp ; { skb = (struct sk_buff *)arg; tmp = findie(skb->data, (int )skb->len, 3, 6); if ((unsigned long )tmp == (unsigned long )((u_char *)0)) { l3_1tr6_error(pc, (u_char *)"missing connack date", skb); return; } else { } consume_skb(skb); newl3state(pc, 10); pc->para.chargeinfo = 0; L3DelTimer(& pc->timer); (*((pc->st)->l3.l3l4))(pc->st, 818, (void *)pc); return; } } static void l3_1tr6_alert_req(struct l3_process *pc , u_char pr , void *arg ) { { newl3state(pc, 7); l3_1TR6_message(pc, 1, 65); return; } } static void l3_1tr6_setup_rsp(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; u_char tmp[24U] ; u_char *p ; int l ; u_char *tmp___0 ; u_char *tmp___1 ; u_char *tmp___2 ; u_char *tmp___3 ; u_char *tmp___4 ; u_char *tmp___5 ; u_char *tmp___6 ; u_char *tmp___7 ; u_char *tmp___8 ; u_char *tmp___9 ; u_char *tmp___10 ; u_char *tmp___11 ; u_char *tmp___12 ; u_char *tmp___13 ; u_char *tmp___14 ; u_char *tmp___15 ; size_t __len ; void *__ret ; unsigned char *tmp___17 ; { p = (u_char *)(& tmp); tmp___0 = p; p = p + 1; *tmp___0 = 65U; tmp___1 = p; p = p + 1; *tmp___1 = 1U; tmp___2 = p; p = p + 1; *tmp___2 = (u_char )((int )((signed char )pc->callref) ^ -128); tmp___3 = p; p = p + 1; *tmp___3 = 7U; if (pc->para.spv != 0) { tmp___4 = p; p = p + 1; *tmp___4 = 32U; tmp___5 = p; p = p + 1; *tmp___5 = 4U; tmp___6 = p; p = p + 1; *tmp___6 = 0U; tmp___7 = p; p = p + 1; *tmp___7 = 31U; tmp___8 = p; p = p + 1; *tmp___8 = pc->para.setup.si1; tmp___9 = p; p = p + 1; *tmp___9 = pc->para.setup.si2; tmp___10 = p; p = p + 1; *tmp___10 = 32U; tmp___11 = p; p = p + 1; *tmp___11 = 4U; tmp___12 = p; p = p + 1; *tmp___12 = 0U; tmp___13 = p; p = p + 1; *tmp___13 = 29U; tmp___14 = p; p = p + 1; *tmp___14 = pc->para.setup.si1; tmp___15 = p; p = p + 1; *tmp___15 = pc->para.setup.si2; } else { } newl3state(pc, 8); l = (int )((unsigned int )((long )p) - (unsigned int )((long )(& tmp))); skb = l3_alloc_skb(l); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } __len = (size_t )l; tmp___17 = skb_put(skb, (unsigned int )l); __ret = memcpy((void *)tmp___17, (void const *)(& tmp), __len); l3_msg(pc->st, 544, (void *)skb); L3DelTimer(& pc->timer); L3AddTimer(& pc->timer, 4000, 915); return; } } static void l3_1tr6_reset(struct l3_process *pc , u_char pr , void *arg ) { { release_l3_process(pc); return; } } static void l3_1tr6_disconnect_req(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; u_char tmp[16U] ; u_char *p ; int l ; u_char cause ; u_char clen ; u_char *tmp___0 ; u_char *tmp___1 ; u_char *tmp___2 ; u_char *tmp___3 ; u_char *tmp___4 ; u_char *tmp___5 ; u_char *tmp___6 ; size_t __len ; void *__ret ; unsigned char *tmp___8 ; { p = (u_char *)(& tmp); cause = 16U; clen = 1U; if ((unsigned int )pc->para.cause != 0U) { cause = pc->para.cause; } else { } switch ((int )cause & 127) { case 16: clen = 0U; goto ldv_41165; case 17: cause = 59U; goto ldv_41165; case 21: cause = 62U; goto ldv_41165; } ldv_41165: StopAllL3Timer(pc); tmp___0 = p; p = p + 1; *tmp___0 = 65U; tmp___1 = p; p = p + 1; *tmp___1 = 1U; tmp___2 = p; p = p + 1; *tmp___2 = (u_char )((int )((signed char )pc->callref) ^ -128); tmp___3 = p; p = p + 1; *tmp___3 = 69U; tmp___4 = p; p = p + 1; *tmp___4 = 8U; tmp___5 = p; p = p + 1; *tmp___5 = clen; if ((unsigned int )clen != 0U) { tmp___6 = p; p = p + 1; *tmp___6 = (u_char )((unsigned int )cause | 128U); } else { } newl3state(pc, 11); l = (int )((unsigned int )((long )p) - (unsigned int )((long )(& tmp))); skb = l3_alloc_skb(l); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } __len = (size_t )l; tmp___8 = skb_put(skb, (unsigned int )l); __ret = memcpy((void *)tmp___8, (void const *)(& tmp), __len); l3_msg(pc->st, 544, (void *)skb); L3AddTimer(& pc->timer, 4000, 901); return; } } static void l3_1tr6_t303(struct l3_process *pc , u_char pr , void *arg ) { { if (pc->N303 > 0) { pc->N303 = pc->N303 - 1; L3DelTimer(& pc->timer); l3_1tr6_setup_req(pc, (int )pr, arg); } else { L3DelTimer(& pc->timer); pc->para.cause = 0U; l3_1tr6_disconnect_req(pc, 0, 0); } return; } } static void l3_1tr6_t304(struct l3_process *pc , u_char pr , void *arg ) { { L3DelTimer(& pc->timer); pc->para.cause = 230U; l3_1tr6_disconnect_req(pc, (int )pr, 0); (*((pc->st)->l3.l3l4))(pc->st, 993, (void *)pc); return; } } static void l3_1tr6_t305(struct l3_process *pc , u_char pr , void *arg ) { struct sk_buff *skb ; u_char tmp[16U] ; u_char *p ; int l ; u_char cause ; u_char clen ; u_char *tmp___0 ; u_char *tmp___1 ; u_char *tmp___2 ; u_char *tmp___3 ; u_char *tmp___4 ; u_char *tmp___5 ; u_char *tmp___6 ; size_t __len ; void *__ret ; unsigned char *tmp___8 ; { p = (u_char *)(& tmp); cause = 144U; clen = 1U; L3DelTimer(& pc->timer); if ((unsigned int )pc->para.cause != 254U) { cause = pc->para.cause; } else { } switch ((int )cause & 127) { case 16: clen = 0U; goto ldv_41193; case 21: cause = 62U; goto ldv_41193; } ldv_41193: tmp___0 = p; p = p + 1; *tmp___0 = 65U; tmp___1 = p; p = p + 1; *tmp___1 = 1U; tmp___2 = p; p = p + 1; *tmp___2 = (u_char )((int )((signed char )pc->callref) ^ -128); tmp___3 = p; p = p + 1; *tmp___3 = 77U; tmp___4 = p; p = p + 1; *tmp___4 = 8U; tmp___5 = p; p = p + 1; *tmp___5 = clen; if ((unsigned int )clen != 0U) { tmp___6 = p; p = p + 1; *tmp___6 = cause; } else { } newl3state(pc, 19); l = (int )((unsigned int )((long )p) - (unsigned int )((long )(& tmp))); skb = l3_alloc_skb(l); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } __len = (size_t )l; tmp___8 = skb_put(skb, (unsigned int )l); __ret = memcpy((void *)tmp___8, (void const *)(& tmp), __len); l3_msg(pc->st, 544, (void *)skb); L3AddTimer(& pc->timer, 4000, 904); return; } } static void l3_1tr6_t310(struct l3_process *pc , u_char pr , void *arg ) { { L3DelTimer(& pc->timer); pc->para.cause = 230U; l3_1tr6_disconnect_req(pc, (int )pr, 0); (*((pc->st)->l3.l3l4))(pc->st, 993, (void *)pc); return; } } static void l3_1tr6_t313(struct l3_process *pc , u_char pr , void *arg ) { { L3DelTimer(& pc->timer); pc->para.cause = 230U; l3_1tr6_disconnect_req(pc, (int )pr, 0); (*((pc->st)->l3.l3l4))(pc->st, 996, (void *)pc); return; } } static void l3_1tr6_t308_1(struct l3_process *pc , u_char pr , void *arg ) { { L3DelTimer(& pc->timer); l3_1TR6_message(pc, 77, 65); L3AddTimer(& pc->timer, 4000, 906); newl3state(pc, 19); return; } } static void l3_1tr6_t308_2(struct l3_process *pc , u_char pr , void *arg ) { { L3DelTimer(& pc->timer); (*((pc->st)->l3.l3l4))(pc->st, 997, (void *)pc); release_l3_process(pc); return; } } static void l3_1tr6_dl_reset(struct l3_process *pc , u_char pr , void *arg ) { { pc->para.cause = 112U; l3_1tr6_disconnect_req(pc, (int )pr, 0); (*((pc->st)->l3.l3l4))(pc->st, 993, (void *)pc); return; } } static void l3_1tr6_dl_release(struct l3_process *pc , u_char pr , void *arg ) { { newl3state(pc, 0); pc->para.cause = 27U; pc->para.loc = 0U; (*((pc->st)->l3.l3l4))(pc->st, 874, (void *)pc); release_l3_process(pc); return; } } static struct stateentry downstl[14U] = { {1, 768, & l3_1tr6_setup_req}, {1502, 864, & l3_1tr6_disconnect_req}, {4096, 872, & l3_1tr6_release_req}, {64, 800, & l3_1tr6_reset}, {64, 804, & l3_1tr6_disconnect_req}, {64, 836, & l3_1tr6_alert_req}, {192, 771, & l3_1tr6_setup_rsp}, {2, 899, & l3_1tr6_t303}, {4, 900, & l3_1tr6_t304}, {8, 912, & l3_1tr6_t310}, {256, 915, & l3_1tr6_t313}, {2048, 901, & l3_1tr6_t305}, {524288, 904, & l3_1tr6_t308_1}, {524288, 906, & l3_1tr6_t308_2}}; static struct stateentry datastln1[14U] = { {1, 0, & l3_1tr6_invalid}, {1, 5, & l3_1tr6_setup}, {2, 13, & l3_1tr6_setup_ack}, {6, 2, & l3_1tr6_call_sent}, {1438, 69, & l3_1tr6_disc}, {28, 1, & l3_1tr6_alert}, {28, 7, & l3_1tr6_connect}, {4, 109, & l3_1tr6_info_s2}, {256, 15, & l3_1tr6_connect_ack}, {1024, 109, & l3_1tr6_info}, {171423, 77, & l3_1tr6_rel}, {524288, 77, & l3_1tr6_rel_ack}, {171423, 90, & l3_1tr6_invalid}, {524288, 90, & l3_1tr6_rel_ack}}; static struct stateentry manstatelist___1[2U] = { {4, 514, & l3_1tr6_dl_reset}, {67108863, 530, & l3_1tr6_dl_release}}; static void up1tr6(struct PStack *st , int pr , void *arg ) { int i ; int mt ; int cr ; struct l3_process *proc ; struct sk_buff *skb ; char tmp[80U] ; { skb = (struct sk_buff *)arg; switch (pr) { case 546: ; case 562: ; goto ldv_41244; case 513: ; case 514: ; case 530: ; case 529: l3_msg(st, pr, arg); return; } ldv_41244: ; if (skb->len <= 3U) { if ((st->l3.debug & 2) != 0) { sprintf((char *)(& tmp), "up1tr6 len only %d", skb->len); HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)(& tmp)); } else { } consume_skb(skb); return; } else { } if (((int )*(skb->data) & 254) != 64) { if ((st->l3.debug & 2) != 0) { sprintf((char *)(& tmp), "up1tr6%sunexpected discriminator %x message len %d", pr == 546 ? (char *)" " : (char *)"(broadcast) ", (int )*(skb->data), skb->len); HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)(& tmp)); } else { } consume_skb(skb); return; } else { } if ((unsigned int )*(skb->data + 1UL) != 1U) { if ((st->l3.debug & 2) != 0) { sprintf((char *)(& tmp), "up1tr6 CR len not 1"); HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)(& tmp)); } else { } consume_skb(skb); return; } else { } cr = (int )*(skb->data + 2UL); mt = (int )*(skb->data + 3UL); if ((unsigned int )*(skb->data) == 64U) { consume_skb(skb); if ((st->l3.debug & 4) != 0) { sprintf((char *)(& tmp), "up1tr6%s N0 mt %x unhandled", pr == 546 ? (char *)" " : (char *)"(broadcast) ", mt); HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)(& tmp)); } else { } } else if ((unsigned int )*(skb->data) == 65U) { proc = getl3proc(st, cr); if ((unsigned long )proc == (unsigned long )((struct l3_process *)0)) { if (mt == 5) { if (cr <= 127) { proc = new_l3_process(st, cr); if ((unsigned long )proc == (unsigned long )((struct l3_process *)0)) { if ((st->l3.debug & 2) != 0) { sprintf((char *)(& tmp), "up1tr6 no roc mem"); HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)(& tmp)); } else { } consume_skb(skb); return; } else { consume_skb(skb); return; } } else if ((((((((mt == 77 || mt == 90) || mt == 110) || mt == 103) || mt == 108) || mt == 111) || mt == 45) || mt == 34) || mt == 109) { consume_skb(skb); return; } else { proc = new_l3_process(st, cr); if ((unsigned long )proc == (unsigned long )((struct l3_process *)0)) { if ((st->l3.debug & 2) != 0) { sprintf((char *)(& tmp), "up1tr6 no roc mem"); HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)(& tmp)); } else { } consume_skb(skb); return; } else { } mt = 0; } } else { } } else { } i = 0; goto ldv_41253; ldv_41252: ; if (datastln1[i].primitive == mt && (datastln1[i].state >> proc->state) & 1) { goto ldv_41251; } else { } i = i + 1; ldv_41253: ; if ((unsigned int )i <= 13U) { goto ldv_41252; } else { } ldv_41251: ; if (i == 14) { consume_skb(skb); if ((st->l3.debug & 4) != 0) { sprintf((char *)(& tmp), "up1tr6%sstate %d mt %x unhandled", pr == 546 ? (char *)" " : (char *)"(broadcast) ", proc->state, mt); HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)(& tmp)); } else { } return; } else { if ((st->l3.debug & 4) != 0) { sprintf((char *)(& tmp), "up1tr6%sstate %d mt %x", pr == 546 ? (char *)" " : (char *)"(broadcast) ", proc->state, mt); HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)(& tmp)); } else { } (*(datastln1[i].rout))(proc, (int )((u8 )pr), (void *)skb); } } else { } return; } } static void down1tr6(struct PStack *st , int pr , void *arg ) { int i ; int cr ; struct l3_process *proc ; struct Channel *chan ; char tmp[80U] ; size_t __len ; void *__ret ; { if (pr == 512) { l3_msg(st, pr, 0); return; } else if (pr == 768) { chan = (struct Channel *)arg; cr = newcallref(); cr = cr | 128; proc = new_l3_process(st, cr); if ((unsigned long )proc == (unsigned long )((struct l3_process *)0)) { return; } else { proc->chan = chan; chan->proc = proc; __len = 68UL; if (__len > 63UL) { __ret = memcpy((void *)(& proc->para.setup), (void const *)(& chan->setup), __len); } else { __ret = memcpy((void *)(& proc->para.setup), (void const *)(& chan->setup), __len); } proc->callref = cr; } } else { proc = (struct l3_process *)arg; } i = 0; goto ldv_41273; ldv_41272: ; if (downstl[i].primitive == pr && (downstl[i].state >> proc->state) & 1) { goto ldv_41271; } else { } i = i + 1; ldv_41273: ; if ((unsigned int )i <= 13U) { goto ldv_41272; } else { } ldv_41271: ; if (i == 14) { if ((st->l3.debug & 4) != 0) { sprintf((char *)(& tmp), "down1tr6 state %d prim %d unhandled", proc->state, pr); HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)(& tmp)); } else { if ((st->l3.debug & 4) != 0) { sprintf((char *)(& tmp), "down1tr6 state %d prim %d", proc->state, pr); HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)(& tmp)); } else { } (*(downstl[i].rout))(proc, (int )((u8 )pr), arg); } } else { } return; } } static void man1tr6(struct PStack *st , int pr , void *arg ) { int i ; struct l3_process *proc ; { proc = (struct l3_process *)arg; if ((unsigned long )proc == (unsigned long )((struct l3_process *)0)) { printk("\vHiSax man1tr6 without proc pr=%04x\n", pr); return; } else { } i = 0; goto ldv_41287; ldv_41286: ; if (manstatelist___1[i].primitive == pr && (manstatelist___1[i].state >> proc->state) & 1) { goto ldv_41285; } else { } i = i + 1; ldv_41287: ; if ((unsigned int )i <= 1U) { goto ldv_41286; } else { } ldv_41285: ; if (i == 2) { if ((st->l3.debug & 4) != 0) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"cr %d man1tr6 state %d prim %d unhandled", proc->callref & 127, proc->state, pr); } else { if ((st->l3.debug & 4) != 0) { HiSax_putstatus((struct IsdnCardState *)st->l1.hardware, (char *)"l3 ", (char *)"cr %d man1tr6 state %d prim %d", proc->callref & 127, proc->state, pr); } else { } (*(manstatelist___1[i].rout))(proc, (int )((u8 )pr), arg); } } else { } return; } } void setstack_1tr6(struct PStack *st ) { char tmp[64U] ; char *tmp___0 ; { st->lli.l4l3 = & down1tr6; st->l2.l2l3 = & up1tr6; st->l3.l3ml3 = & man1tr6; st->l3.N303 = 0; strcpy((char *)(& tmp), l3_1tr6_revision); tmp___0 = HiSax_getrev((char const *)(& tmp)); printk("\016HiSax: 1TR6 Rev. %s\n", tmp___0); return; } } void ldv_mutex_lock_155(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_lock(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_156(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_lock(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_157(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } int ldv_mutex_trylock_158(struct mutex *ldv_func_arg1 ) { ldv_func_ret_type___2 ldv_func_res ; int tmp ; int tmp___0 ; { tmp = mutex_trylock(ldv_func_arg1); ldv_func_res = tmp; tmp___0 = ldv_mutex_trylock_mutex(ldv_func_arg1); return (tmp___0); return (ldv_func_res); } } void ldv_mutex_unlock_159(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_160(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_cred_guard_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_161(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_cred_guard_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } int ldv_mutex_trylock_172(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_170(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_173(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_175(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_169(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_171(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_174(struct mutex *ldv_func_arg1 ) ; extern struct resource ioport_resource ; extern struct resource *__request_region(struct resource * , resource_size_t , resource_size_t , char const * , int ) ; extern void __release_region(struct resource * , resource_size_t , resource_size_t ) ; __inline static void outb(unsigned char value , int port ) { { __asm__ volatile ("outb %b0, %w1": : "a" (value), "Nd" (port)); return; } } __inline static unsigned char inb(int port ) { unsigned char value ; { __asm__ volatile ("inb %w1, %b0": "=a" (value): "Nd" (port)); return (value); } } __inline static void outsb(int port , void const *addr , unsigned long count ) { { __asm__ volatile ("rep; outsb": "+S" (addr), "+c" (count): "d" (port)); return; } } __inline static void insb(int port , void *addr , unsigned long count ) { { __asm__ volatile ("rep; insb": "+D" (addr), "+c" (count): "d" (port)); return; } } extern void __const_udelay(unsigned long ) ; extern struct sk_buff *__netdev_alloc_skb(struct net_device * , unsigned int , gfp_t ) ; __inline static struct sk_buff *netdev_alloc_skb(struct net_device *dev , unsigned int length ) { struct sk_buff *tmp ; { tmp = __netdev_alloc_skb(dev, length, 32U); return (tmp); } } __inline static struct sk_buff *dev_alloc_skb(unsigned int length ) { struct sk_buff *tmp ; { tmp = netdev_alloc_skb(0, length); return (tmp); } } extern void dev_kfree_skb_irq(struct sk_buff * ) ; void ISACVersion(struct IsdnCardState *cs , char *s ) ; void setup_isac(struct IsdnCardState *cs ) ; void isac_interrupt(struct IsdnCardState *cs , u_char val ) ; int HscxVersion(struct IsdnCardState *cs , char *s ) ; void inithscxisac(struct IsdnCardState *cs , int part ) ; static char const *teles3_revision = "$Revision: 2.19.2.4 $"; __inline static u_char readreg(unsigned int adr , u_char off ) { unsigned char tmp ; { tmp = inb((int )((unsigned int )off + adr)); return (tmp); } } __inline static void writereg(unsigned int adr , u_char off , u_char data ) { { outb((int )data, (int )((unsigned int )off + adr)); return; } } __inline static void read_fifo(unsigned int adr , u_char *data , int size ) { { insb((int )adr, (void *)data, (unsigned long )size); return; } } static void write_fifo(unsigned int adr , u_char *data , int size ) { { outsb((int )adr, (void const *)data, (unsigned long )size); return; } } static u_char ReadISAC(struct IsdnCardState *cs , u_char offset ) { u_char tmp ; { tmp = readreg((unsigned int )cs->hw.teles3.isac, (int )offset); return (tmp); } } static void WriteISAC(struct IsdnCardState *cs , u_char offset , u_char value ) { { writereg((unsigned int )cs->hw.teles3.isac, (int )offset, (int )value); return; } } static void ReadISACfifo(struct IsdnCardState *cs , u_char *data , int size ) { { read_fifo((unsigned int )cs->hw.teles3.isacfifo, data, size); return; } } static void WriteISACfifo(struct IsdnCardState *cs , u_char *data , int size ) { { write_fifo((unsigned int )cs->hw.teles3.isacfifo, data, size); return; } } static u_char ReadHSCX(struct IsdnCardState *cs , int hscx , u_char offset ) { u_char tmp ; { tmp = readreg((unsigned int )cs->hw.teles3.hscx[hscx], (int )offset); return (tmp); } } static void WriteHSCX(struct IsdnCardState *cs , int hscx , u_char offset , u_char value ) { { writereg((unsigned int )cs->hw.teles3.hscx[hscx], (int )offset, (int )value); return; } } __inline static void waitforCEC(struct IsdnCardState *cs , int hscx ) { int to ; u_char tmp ; { to = 50; goto ldv_41336; ldv_41335: __const_udelay(4295UL); to = to - 1; ldv_41336: tmp = readreg((unsigned int )cs->hw.teles3.hscx[hscx], 33); if (((int )tmp & 4) != 0 && to != 0) { goto ldv_41335; } else { } if (to == 0) { printk("\fHiSax: waitforCEC timeout\n"); } else { } return; } } __inline static void waitforXFW(struct IsdnCardState *cs , int hscx ) { int to ; u_char tmp ; { to = 50; goto ldv_41344; ldv_41343: __const_udelay(4295UL); to = to - 1; ldv_41344: tmp = readreg((unsigned int )cs->hw.teles3.hscx[hscx], 33); if (((int )tmp & 68) != 64 && to != 0) { goto ldv_41343; } else { } if (to == 0) { printk("\fHiSax: waitforXFW timeout\n"); } else { } return; } } __inline static void WriteHSCXCMDR(struct IsdnCardState *cs , int hscx , u_char data ) { { waitforCEC(cs, hscx); writereg((unsigned int )cs->hw.teles3.hscx[hscx], 33, (int )data); return; } } static void hscx_empty_fifo(struct BCState *bcs , int count ) { u_char *ptr ; struct IsdnCardState *cs ; char *t ; int tmp ; { cs = bcs->cs; if ((cs->debug & 16) != 0 && (cs->debug & 32) == 0) { debugl1(cs, (char *)"hscx_empty_fifo"); } else { } if (bcs->hw.hscx.rcvidx + count > 4096) { if (cs->debug & 1) { debugl1(cs, (char *)"hscx_empty_fifo: incoming packet too large"); } else { } WriteHSCXCMDR(cs, bcs->hw.hscx.hscx, 128); bcs->hw.hscx.rcvidx = 0; return; } else { } ptr = bcs->hw.hscx.rcvbuf + (unsigned long )bcs->hw.hscx.rcvidx; bcs->hw.hscx.rcvidx = bcs->hw.hscx.rcvidx + count; read_fifo((unsigned int )cs->hw.teles3.hscxfifo[bcs->hw.hscx.hscx], ptr, count); WriteHSCXCMDR(cs, bcs->hw.hscx.hscx, 128); if ((cs->debug & 32) != 0) { t = (char *)bcs->blog; tmp = sprintf(t, "hscx_empty_fifo %c cnt %d", bcs->hw.hscx.hscx != 0 ? 66 : 65, count); t = t + (unsigned long )tmp; QuickHex(t, ptr, count); debugl1(cs, (char *)bcs->blog); } else { } return; } } static void hscx_fill_fifo(struct BCState *bcs ) { struct IsdnCardState *cs ; int more ; int count ; int fifo_size ; int tmp ; u_char *ptr ; char *t ; int tmp___0 ; { cs = bcs->cs; tmp = constant_test_bit(1U, (unsigned long const volatile *)(& cs->HW_Flags)); fifo_size = tmp != 0 ? 64 : 32; if ((cs->debug & 16) != 0 && (cs->debug & 32) == 0) { debugl1(cs, (char *)"hscx_fill_fifo"); } else { } if ((unsigned long )bcs->tx_skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } if ((bcs->tx_skb)->len == 0U) { return; } else { } more = bcs->mode == 1; if ((bcs->tx_skb)->len > (unsigned int )fifo_size) { more = 1; count = fifo_size; } else { count = (int )(bcs->tx_skb)->len; } waitforXFW(cs, bcs->hw.hscx.hscx); ptr = (bcs->tx_skb)->data; skb_pull(bcs->tx_skb, (unsigned int )count); bcs->tx_cnt = bcs->tx_cnt - count; bcs->hw.hscx.count = bcs->hw.hscx.count + count; write_fifo((unsigned int )cs->hw.teles3.hscxfifo[bcs->hw.hscx.hscx], ptr, count); WriteHSCXCMDR(cs, bcs->hw.hscx.hscx, more != 0 ? 8 : 10); if ((cs->debug & 32) != 0) { t = (char *)bcs->blog; tmp___0 = sprintf(t, "hscx_fill_fifo %c cnt %d", bcs->hw.hscx.hscx != 0 ? 66 : 65, count); t = t + (unsigned long )tmp___0; QuickHex(t, ptr, count); debugl1(cs, (char *)bcs->blog); } else { } return; } } static void hscx_interrupt(struct IsdnCardState *cs , u_char val , u_char hscx ) { u_char r ; struct BCState *bcs ; struct sk_buff *skb ; int fifo_size ; int tmp ; int count ; int tmp___0 ; u_char tmp___1 ; int tmp___2 ; size_t __len ; void *__ret ; unsigned char *tmp___4 ; size_t __len___0 ; void *__ret___0 ; unsigned char *tmp___6 ; u_long flags ; raw_spinlock_t *tmp___7 ; int tmp___8 ; struct sk_buff *tmp___9 ; { bcs = (struct BCState *)(& cs->bcs) + (unsigned long )hscx; tmp = constant_test_bit(1U, (unsigned long const volatile *)(& cs->HW_Flags)); fifo_size = tmp != 0 ? 64 : 32; tmp___0 = constant_test_bit(1U, (unsigned long const volatile *)(& bcs->Flag)); if (tmp___0 == 0) { return; } else { } if ((int )((signed char )val) < 0) { r = readreg((unsigned int )cs->hw.teles3.hscx[(int )hscx], 39); if (((int )r & 240) != 160) { if ((int )((signed char )r) >= 0) { if (cs->debug & 1) { debugl1(cs, (char *)"HSCX invalid frame"); } else { } bcs->err_inv = bcs->err_inv + 1; } else { } if (((int )r & 64) != 0 && bcs->mode != 0) { if (cs->debug & 1) { debugl1(cs, (char *)"HSCX RDO mode=%d", bcs->mode); } else { } bcs->err_rdo = bcs->err_rdo + 1; } else { } if (((int )r & 32) == 0) { if (cs->debug & 1) { debugl1(cs, (char *)"HSCX CRC error"); } else { } bcs->err_crc = bcs->err_crc + 1; } else { } WriteHSCXCMDR(cs, (int )hscx, 128); } else { tmp___1 = readreg((unsigned int )cs->hw.teles3.hscx[(int )hscx], 37); tmp___2 = constant_test_bit(1U, (unsigned long const volatile *)(& cs->HW_Flags)); count = (int )tmp___1 & (tmp___2 != 0 ? 63 : 31); if (count == 0) { count = fifo_size; } else { } hscx_empty_fifo(bcs, count); count = bcs->hw.hscx.rcvidx + -1; if (count > 0) { if ((cs->debug & 32) != 0) { debugl1(cs, (char *)"HX Frame %d", count); } else { } skb = dev_alloc_skb((unsigned int )count); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { printk("\fHSCX: receive out of memory\n"); } else { __len = (size_t )count; tmp___4 = skb_put(skb, (unsigned int )count); __ret = memcpy((void *)tmp___4, (void const *)bcs->hw.hscx.rcvbuf, __len); skb_queue_tail(& bcs->rqueue, skb); } } else { } } bcs->hw.hscx.rcvidx = 0; test_and_set_bit(0, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } if (((int )val & 64) != 0) { hscx_empty_fifo(bcs, fifo_size); if (bcs->mode == 1) { skb = dev_alloc_skb((unsigned int )fifo_size); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { printk("\fHiSax: receive out of memory\n"); } else { __len___0 = (size_t )fifo_size; tmp___6 = skb_put(skb, (unsigned int )fifo_size); __ret___0 = memcpy((void *)tmp___6, (void const *)bcs->hw.hscx.rcvbuf, __len___0); skb_queue_tail(& bcs->rqueue, skb); } bcs->hw.hscx.rcvidx = 0; test_and_set_bit(0, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } } else { } if (((int )val & 16) != 0) { if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { if ((bcs->tx_skb)->len != 0U) { hscx_fill_fifo(bcs); return; } else { tmp___8 = constant_test_bit(1U, (unsigned long const volatile *)(& (bcs->st)->lli.flag)); if (tmp___8 != 0 && (unsigned int )*((unsigned char *)bcs->tx_skb + 125UL) != 7U) { tmp___7 = spinlock_check(& bcs->aclock); flags = _raw_spin_lock_irqsave(tmp___7); bcs->ackcnt = bcs->ackcnt + bcs->hw.hscx.count; spin_unlock_irqrestore(& bcs->aclock, flags); test_and_set_bit(2, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } dev_kfree_skb_irq(bcs->tx_skb); bcs->hw.hscx.count = 0; bcs->tx_skb = 0; } } else { } tmp___9 = skb_dequeue(& bcs->squeue); bcs->tx_skb = tmp___9; if ((unsigned long )tmp___9 != (unsigned long )((struct sk_buff *)0)) { bcs->hw.hscx.count = 0; test_and_set_bit(3, (unsigned long volatile *)(& bcs->Flag)); hscx_fill_fifo(bcs); } else { test_and_clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); test_and_set_bit(1, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } } else { } return; } } static void hscx_int_main(struct IsdnCardState *cs , u_char val ) { u_char exval ; struct BCState *bcs ; { if ((int )val & 1) { bcs = (struct BCState *)(& cs->bcs) + 1UL; exval = readreg((unsigned int )cs->hw.teles3.hscx[1], 36); if (((int )exval & 64) != 0) { if (bcs->mode == 1) { hscx_fill_fifo(bcs); } else { bcs->err_tx = bcs->err_tx + 1; if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { skb_push(bcs->tx_skb, (unsigned int )bcs->hw.hscx.count); bcs->tx_cnt = bcs->tx_cnt + bcs->hw.hscx.count; bcs->hw.hscx.count = 0; } else { } WriteHSCXCMDR(cs, bcs->hw.hscx.hscx, 1); if (cs->debug & 1) { debugl1(cs, (char *)"HSCX B EXIR %x Lost TX", (int )exval); } else { } } } else if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HSCX B EXIR %x", (int )exval); } else { } } else { } if (((int )val & 248) != 0) { if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HSCX B interrupt %x", (int )val); } else { } hscx_interrupt(cs, (int )val, 1); } else { } if (((int )val & 2) != 0) { bcs = (struct BCState *)(& cs->bcs); exval = readreg((unsigned int )cs->hw.teles3.hscx[0], 36); if (((int )exval & 64) != 0) { if (bcs->mode == 1) { hscx_fill_fifo(bcs); } else { bcs->err_tx = bcs->err_tx + 1; if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { skb_push(bcs->tx_skb, (unsigned int )bcs->hw.hscx.count); bcs->tx_cnt = bcs->tx_cnt + bcs->hw.hscx.count; bcs->hw.hscx.count = 0; } else { } WriteHSCXCMDR(cs, bcs->hw.hscx.hscx, 1); if (cs->debug & 1) { debugl1(cs, (char *)"HSCX A EXIR %x Lost TX", (int )exval); } else { } } } else if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HSCX A EXIR %x", (int )exval); } else { } } else { } if (((int )val & 4) != 0) { exval = readreg((unsigned int )cs->hw.teles3.hscx[0], 32); if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HSCX A interrupt %x", (int )exval); } else { } hscx_interrupt(cs, (int )exval, 0); } else { } return; } } static irqreturn_t teles3_interrupt(int intno , void *dev_id ) { struct IsdnCardState *cs ; u_char val ; u_long flags ; int count ; raw_spinlock_t *tmp ; { cs = (struct IsdnCardState *)dev_id; count = 0; tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); val = readreg((unsigned int )cs->hw.teles3.hscx[1], 32); Start_HSCX: ; if ((unsigned int )val != 0U) { hscx_int_main(cs, (int )val); } else { } val = readreg((unsigned int )cs->hw.teles3.isac, 32); Start_ISAC: ; if ((unsigned int )val != 0U) { isac_interrupt(cs, (int )val); } else { } count = count + 1; val = readreg((unsigned int )cs->hw.teles3.hscx[1], 32); if ((unsigned int )val != 0U && count <= 4) { if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HSCX IntStat after IntRoutine"); } else { } goto Start_HSCX; } else { } val = readreg((unsigned int )cs->hw.teles3.isac, 32); if ((unsigned int )val != 0U && count <= 4) { if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"ISAC IntStat after IntRoutine"); } else { } goto Start_ISAC; } else { } if (count > 4) { printk("\fTeles3: more than %d loops in teles3_interrupt\n", count); } else { } writereg((unsigned int )cs->hw.teles3.hscx[0], 32, 255); writereg((unsigned int )cs->hw.teles3.hscx[1], 32, 255); writereg((unsigned int )cs->hw.teles3.isac, 32, 255); writereg((unsigned int )cs->hw.teles3.isac, 32, 0); writereg((unsigned int )cs->hw.teles3.hscx[0], 32, 0); writereg((unsigned int )cs->hw.teles3.hscx[1], 32, 0); spin_unlock_irqrestore(& cs->lock, flags); return (1); } } __inline static void release_ioregs(struct IsdnCardState *cs , int mask ) { { if (mask & 1) { __release_region(& ioport_resource, (resource_size_t )(cs->hw.teles3.isac + 32), 32ULL); } else { } if ((mask & 2) != 0) { __release_region(& ioport_resource, (resource_size_t )(cs->hw.teles3.hscx[0] + 32), 32ULL); } else { } if ((mask & 4) != 0) { __release_region(& ioport_resource, (resource_size_t )(cs->hw.teles3.hscx[1] + 32), 32ULL); } else { } return; } } static void release_io_teles3(struct IsdnCardState *cs ) { { if ((unsigned int )cs->typ == 8U) { __release_region(& ioport_resource, (resource_size_t )cs->hw.teles3.hscx[1], 96ULL); } else { if (cs->hw.teles3.cfg_reg != 0U) { if ((unsigned int )cs->typ == 19U) { __release_region(& ioport_resource, (resource_size_t )cs->hw.teles3.cfg_reg, 1ULL); } else { __release_region(& ioport_resource, (resource_size_t )cs->hw.teles3.cfg_reg, 8ULL); } } else { } release_ioregs(cs, 7); } return; } } static int reset_teles3(struct IsdnCardState *cs ) { u_char irqcfg ; int tout ; int loops ; int tmp ; int tmp___0 ; int tout___0 ; int loops___0 ; int tmp___1 ; int tmp___2 ; int tout___1 ; int loops___1 ; int tmp___3 ; int tmp___4 ; int tout___2 ; int loops___2 ; int tmp___5 ; int tmp___6 ; int tout___3 ; int loops___3 ; int tmp___7 ; int tmp___8 ; int tout___4 ; int loops___4 ; int tmp___9 ; int tmp___10 ; { if ((unsigned int )cs->typ != 8U) { if (cs->hw.teles3.cfg_reg != 0U && (unsigned int )cs->typ != 19U) { switch (cs->irq) { case 2U: ; case 9U: irqcfg = 0U; goto ldv_41419; case 3U: irqcfg = 2U; goto ldv_41419; case 4U: irqcfg = 4U; goto ldv_41419; case 5U: irqcfg = 6U; goto ldv_41419; case 10U: irqcfg = 8U; goto ldv_41419; case 11U: irqcfg = 10U; goto ldv_41419; case 12U: irqcfg = 12U; goto ldv_41419; case 15U: irqcfg = 14U; goto ldv_41419; default: ; return (1); } ldv_41419: outb((int )irqcfg, (int )(cs->hw.teles3.cfg_reg + 4U)); tout = 26; goto ldv_41434; ldv_41433: loops = 4000; goto ldv_41431; ldv_41430: __const_udelay(4295UL); ldv_41431: tmp = loops; loops = loops - 1; if (tmp != 0) { goto ldv_41430; } else { } ldv_41434: tmp___0 = tout; tout = tout - 1; if (tmp___0 != 0) { goto ldv_41433; } else { } outb((int )((unsigned int )irqcfg | 1U), (int )(cs->hw.teles3.cfg_reg + 4U)); tout___0 = 26; goto ldv_41442; ldv_41441: loops___0 = 4000; goto ldv_41439; ldv_41438: __const_udelay(4295UL); ldv_41439: tmp___1 = loops___0; loops___0 = loops___0 - 1; if (tmp___1 != 0) { goto ldv_41438; } else { } ldv_41442: tmp___2 = tout___0; tout___0 = tout___0 - 1; if (tmp___2 != 0) { goto ldv_41441; } else { } } else if ((unsigned int )cs->typ == 19U) { outb(255, (int )cs->hw.teles3.cfg_reg); tout___1 = 2; goto ldv_41450; ldv_41449: loops___1 = 4000; goto ldv_41447; ldv_41446: __const_udelay(4295UL); ldv_41447: tmp___3 = loops___1; loops___1 = loops___1 - 1; if (tmp___3 != 0) { goto ldv_41446; } else { } ldv_41450: tmp___4 = tout___1; tout___1 = tout___1 - 1; if (tmp___4 != 0) { goto ldv_41449; } else { } outb(0, (int )cs->hw.teles3.cfg_reg); tout___2 = 2; goto ldv_41458; ldv_41457: loops___2 = 4000; goto ldv_41455; ldv_41454: __const_udelay(4295UL); ldv_41455: tmp___5 = loops___2; loops___2 = loops___2 - 1; if (tmp___5 != 0) { goto ldv_41454; } else { } ldv_41458: tmp___6 = tout___2; tout___2 = tout___2 - 1; if (tmp___6 != 0) { goto ldv_41457; } else { } } else { outb(0, cs->hw.teles3.isac + 60); tout___3 = 2; goto ldv_41466; ldv_41465: loops___3 = 4000; goto ldv_41463; ldv_41462: __const_udelay(4295UL); ldv_41463: tmp___7 = loops___3; loops___3 = loops___3 - 1; if (tmp___7 != 0) { goto ldv_41462; } else { } ldv_41466: tmp___8 = tout___3; tout___3 = tout___3 - 1; if (tmp___8 != 0) { goto ldv_41465; } else { } outb(1, cs->hw.teles3.isac + 60); tout___4 = 2; goto ldv_41474; ldv_41473: loops___4 = 4000; goto ldv_41471; ldv_41470: __const_udelay(4295UL); ldv_41471: tmp___9 = loops___4; loops___4 = loops___4 - 1; if (tmp___9 != 0) { goto ldv_41470; } else { } ldv_41474: tmp___10 = tout___4; tout___4 = tout___4 - 1; if (tmp___10 != 0) { goto ldv_41473; } else { } } } else { } return (0); } } static int Teles_card_msg(struct IsdnCardState *cs , int mt , void *arg ) { u_long flags ; raw_spinlock_t *tmp ; raw_spinlock_t *tmp___0 ; { switch (mt) { case 240: tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); reset_teles3(cs); spin_unlock_irqrestore(& cs->lock, flags); return (0); case 243: release_io_teles3(cs); return (0); case 242: tmp___0 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___0); inithscxisac(cs, 3); spin_unlock_irqrestore(& cs->lock, flags); return (0); case 244: ; return (0); } return (0); } } int setup_teles3(struct IsdnCard *card ) { u_char val ; struct IsdnCardState *cs ; char tmp[64U] ; char *tmp___0 ; struct resource *tmp___1 ; struct resource *tmp___2 ; struct resource *tmp___3 ; struct resource *tmp___4 ; struct resource *tmp___5 ; struct resource *tmp___6 ; int tmp___7 ; int tmp___8 ; { cs = card->cs; strcpy((char *)(& tmp), teles3_revision); tmp___0 = HiSax_getrev((char const *)(& tmp)); printk("\016HiSax: Teles IO driver Rev. %s\n", tmp___0); if ((((unsigned int )cs->typ != 3U && (unsigned int )cs->typ != 4U) && (unsigned int )cs->typ != 8U) && (unsigned int )cs->typ != 19U) { return (0); } else { } if ((unsigned int )cs->typ == 3U) { cs->hw.teles3.cfg_reg = (unsigned int )card->para[1]; switch (cs->hw.teles3.cfg_reg) { case 384U: ; case 640U: ; case 896U: cs->hw.teles3.cfg_reg = cs->hw.teles3.cfg_reg | 3072U; goto ldv_41501; } ldv_41501: cs->hw.teles3.isac = (int )(cs->hw.teles3.cfg_reg - 1056U); cs->hw.teles3.hscx[0] = (int )(cs->hw.teles3.cfg_reg - 3104U); cs->hw.teles3.hscx[1] = (int )(cs->hw.teles3.cfg_reg - 2080U); } else if ((unsigned int )cs->typ == 8U) { cs->hw.teles3.cfg_reg = 0U; cs->hw.teles3.hscx[0] = (int )((unsigned int )card->para[1] - 32U); cs->hw.teles3.hscx[1] = (int )card->para[1]; cs->hw.teles3.isac = (int )((unsigned int )card->para[1] + 32U); } else if ((unsigned int )cs->typ == 19U) { cs->hw.teles3.cfg_reg = (unsigned int )card->para[3]; cs->hw.teles3.isac = (int )((unsigned int )card->para[2] - 32U); cs->hw.teles3.hscx[0] = (int )((unsigned int )card->para[1] - 32U); cs->hw.teles3.hscx[1] = (int )card->para[1]; } else { cs->hw.teles3.cfg_reg = 0U; cs->hw.teles3.isac = (int )((unsigned int )card->para[1] - 32U); cs->hw.teles3.hscx[0] = (int )((unsigned int )card->para[2] - 32U); cs->hw.teles3.hscx[1] = (int )card->para[2]; } cs->irq = (u_int )card->para[0]; cs->hw.teles3.isacfifo = cs->hw.teles3.isac + 62; cs->hw.teles3.hscxfifo[0] = cs->hw.teles3.hscx[0] + 62; cs->hw.teles3.hscxfifo[1] = cs->hw.teles3.hscx[1] + 62; if ((unsigned int )cs->typ == 8U) { tmp___1 = __request_region(& ioport_resource, (resource_size_t )cs->hw.teles3.hscx[1], 96ULL, "HiSax Teles PCMCIA", 0); if ((unsigned long )tmp___1 == (unsigned long )((struct resource *)0)) { printk("\fHiSax: %s ports %x-%x already in use\n", CardType[(int )cs->typ], cs->hw.teles3.hscx[1], cs->hw.teles3.hscx[1] + 96); return (0); } else { } cs->irq_flags = cs->irq_flags | 128UL; } else { if (cs->hw.teles3.cfg_reg != 0U) { if ((unsigned int )cs->typ == 19U) { tmp___3 = __request_region(& ioport_resource, (resource_size_t )cs->hw.teles3.cfg_reg, 1ULL, "teles3 cfg", 0); if ((unsigned long )tmp___3 == (unsigned long )((struct resource *)0)) { printk("\fHiSax: %s config port %x already in use\n", CardType[card->typ], cs->hw.teles3.cfg_reg); return (0); } else { tmp___2 = __request_region(& ioport_resource, (resource_size_t )cs->hw.teles3.cfg_reg, 8ULL, "teles3 cfg", 0); if ((unsigned long )tmp___2 == (unsigned long )((struct resource *)0)) { printk("\fHiSax: %s config port %x-%x already in use\n", CardType[card->typ], cs->hw.teles3.cfg_reg, cs->hw.teles3.cfg_reg + 8U); return (0); } else { } } } else { } } else { } tmp___4 = __request_region(& ioport_resource, (resource_size_t )(cs->hw.teles3.isac + 32), 32ULL, "HiSax isac", 0); if ((unsigned long )tmp___4 == (unsigned long )((struct resource *)0)) { printk("\fHiSax: %s isac ports %x-%x already in use\n", CardType[(int )cs->typ], cs->hw.teles3.isac + 32, cs->hw.teles3.isac + 64); if (cs->hw.teles3.cfg_reg != 0U) { if ((unsigned int )cs->typ == 19U) { __release_region(& ioport_resource, (resource_size_t )cs->hw.teles3.cfg_reg, 1ULL); } else { __release_region(& ioport_resource, (resource_size_t )cs->hw.teles3.cfg_reg, 8ULL); } } else { } return (0); } else { } tmp___5 = __request_region(& ioport_resource, (resource_size_t )(cs->hw.teles3.hscx[0] + 32), 32ULL, "HiSax hscx A", 0); if ((unsigned long )tmp___5 == (unsigned long )((struct resource *)0)) { printk("\fHiSax: %s hscx A ports %x-%x already in use\n", CardType[(int )cs->typ], cs->hw.teles3.hscx[0] + 32, cs->hw.teles3.hscx[0] + 64); if (cs->hw.teles3.cfg_reg != 0U) { if ((unsigned int )cs->typ == 19U) { __release_region(& ioport_resource, (resource_size_t )cs->hw.teles3.cfg_reg, 1ULL); } else { __release_region(& ioport_resource, (resource_size_t )cs->hw.teles3.cfg_reg, 8ULL); } } else { } release_ioregs(cs, 1); return (0); } else { } tmp___6 = __request_region(& ioport_resource, (resource_size_t )(cs->hw.teles3.hscx[1] + 32), 32ULL, "HiSax hscx B", 0); if ((unsigned long )tmp___6 == (unsigned long )((struct resource *)0)) { printk("\fHiSax: %s hscx B ports %x-%x already in use\n", CardType[(int )cs->typ], cs->hw.teles3.hscx[1] + 32, cs->hw.teles3.hscx[1] + 64); if (cs->hw.teles3.cfg_reg != 0U) { if ((unsigned int )cs->typ == 19U) { __release_region(& ioport_resource, (resource_size_t )cs->hw.teles3.cfg_reg, 1ULL); } else { __release_region(& ioport_resource, (resource_size_t )cs->hw.teles3.cfg_reg, 8ULL); } } else { } release_ioregs(cs, 3); return (0); } else { } } if (cs->hw.teles3.cfg_reg != 0U && (unsigned int )cs->typ != 19U) { val = inb((int )cs->hw.teles3.cfg_reg); if ((unsigned int )val != 81U) { printk("\fTeles: 16.3 Byte at %x is %x\n", cs->hw.teles3.cfg_reg, (int )val); release_io_teles3(cs); return (0); } else { } val = inb((int )(cs->hw.teles3.cfg_reg + 1U)); if ((unsigned int )val != 147U) { printk("\fTeles: 16.3 Byte at %x is %x\n", cs->hw.teles3.cfg_reg + 1U, (int )val); release_io_teles3(cs); return (0); } else { } val = inb((int )(cs->hw.teles3.cfg_reg + 2U)); if ((((((unsigned int )val != 70U && (unsigned int )val != 57U) && (unsigned int )val != 56U) && (unsigned int )val != 28U) && (unsigned int )val != 30U) && (unsigned int )val != 31U) { printk("\fTeles: 16.3 Byte at %x is %x\n", cs->hw.teles3.cfg_reg + 2U, (int )val); release_io_teles3(cs); return (0); } else { } } else { } printk("\016HiSax: %s config irq:%d isac:0x%X cfg:0x%X\n", CardType[(int )cs->typ], cs->irq, cs->hw.teles3.isac + 32, cs->hw.teles3.cfg_reg); printk("\016HiSax: hscx A:0x%X hscx B:0x%X\n", cs->hw.teles3.hscx[0] + 32, cs->hw.teles3.hscx[1] + 32); setup_isac(cs); tmp___7 = reset_teles3(cs); if (tmp___7 != 0) { printk("\fTeles3: wrong IRQ\n"); release_io_teles3(cs); return (0); } else { } cs->readisac = & ReadISAC; cs->writeisac = & WriteISAC; cs->readisacfifo = & ReadISACfifo; cs->writeisacfifo = & WriteISACfifo; cs->BC_Read_Reg = & ReadHSCX; cs->BC_Write_Reg = & WriteHSCX; cs->BC_Send_Data = & hscx_fill_fifo; cs->cardmsg = & Teles_card_msg; cs->irq_func = & teles3_interrupt; ISACVersion(cs, (char *)"Teles3:"); tmp___8 = HscxVersion(cs, (char *)"Teles3:"); if (tmp___8 != 0) { printk("\fTeles3: wrong HSCX versions check IO address\n"); release_io_teles3(cs); return (0); } else { } return (1); } } void ldv_mutex_lock_169(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_lock(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_170(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_lock(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_171(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } int ldv_mutex_trylock_172(struct mutex *ldv_func_arg1 ) { ldv_func_ret_type___2 ldv_func_res ; int tmp ; int tmp___0 ; { tmp = mutex_trylock(ldv_func_arg1); ldv_func_res = tmp; tmp___0 = ldv_mutex_trylock_mutex(ldv_func_arg1); return (tmp___0); return (ldv_func_res); } } void ldv_mutex_unlock_173(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_174(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_cred_guard_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_175(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_cred_guard_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } int ldv_mutex_trylock_186(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_184(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_187(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_189(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_183(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_185(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_188(struct mutex *ldv_func_arg1 ) ; void initisac(struct IsdnCardState *cs ) ; void clear_pending_isac_ints(struct IsdnCardState *cs ) ; int arcofi_fsm(struct IsdnCardState *cs , int event , void *data ) ; static char *ISACVer[4U] = { (char *)"2086/2186 V1.1", (char *)"2085 B1", (char *)"2085 B2", (char *)"2085 V2.3"}; void ISACVersion(struct IsdnCardState *cs , char *s ) { int val ; u_char tmp ; { tmp = (*(cs->readisac))(cs, 42); val = (int )tmp; printk("\016%s ISAC version (%x): %s\n", s, val, ISACVer[(val >> 5) & 3]); return; } } static void ph_command(struct IsdnCardState *cs , unsigned int command ) { { if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"ph_command %x", command); } else { } (*(cs->writeisac))(cs, 49, (int )((unsigned int )((int )((u_char )command) << 2U) | 3U)); return; } } static void isac_new_ph(struct IsdnCardState *cs ) { { switch (cs->dc.isac.ph_state) { case 1: ; case 6: ph_command(cs, 15U); l1_msg(cs, 6, 0); goto ldv_40997; case 15: l1_msg(cs, 25, 0); goto ldv_40997; case 0: l1_msg(cs, 26, 0); goto ldv_40997; case 7: l1_msg(cs, 9, 0); goto ldv_40997; case 4: l1_msg(cs, 98, 0); goto ldv_40997; case 8: l1_msg(cs, 34, 0); goto ldv_40997; case 12: l1_msg(cs, 66, 0); goto ldv_40997; case 13: l1_msg(cs, 74, 0); goto ldv_40997; default: ; goto ldv_40997; } ldv_40997: ; return; } } static void isac_bh(struct work_struct *work ) { struct IsdnCardState *cs ; struct work_struct const *__mptr ; struct PStack *stptr ; int tmp ; int tmp___0 ; int tmp___1 ; int tmp___2 ; int tmp___3 ; int tmp___4 ; int tmp___5 ; { __mptr = (struct work_struct const *)work; cs = (struct IsdnCardState *)__mptr + 0xffffffffffffe728UL; tmp = test_and_clear_bit(3, (unsigned long volatile *)(& cs->event)); if (tmp != 0) { if (cs->debug != 0) { debugl1(cs, (char *)"D-Channel Busy cleared"); } else { } stptr = cs->stlist; goto ldv_41014; ldv_41013: (*(stptr->l1.l1l2))(stptr, 337, 0); stptr = stptr->next; ldv_41014: ; if ((unsigned long )stptr != (unsigned long )((struct PStack *)0)) { goto ldv_41013; } else { } } else { } tmp___0 = test_and_clear_bit(2, (unsigned long volatile *)(& cs->event)); if (tmp___0 != 0) { isac_new_ph(cs); } else { } tmp___1 = test_and_clear_bit(0, (unsigned long volatile *)(& cs->event)); if (tmp___1 != 0) { DChannel_proc_rcv(cs); } else { } tmp___2 = test_and_clear_bit(1, (unsigned long volatile *)(& cs->event)); if (tmp___2 != 0) { DChannel_proc_xmt(cs); } else { } tmp___3 = constant_test_bit(3U, (unsigned long const volatile *)(& cs->HW_Flags)); if (tmp___3 == 0) { return; } else { } tmp___4 = test_and_clear_bit(5, (unsigned long volatile *)(& cs->event)); if (tmp___4 != 0) { arcofi_fsm(cs, 3, 0); } else { } tmp___5 = test_and_clear_bit(7, (unsigned long volatile *)(& cs->event)); if (tmp___5 != 0) { arcofi_fsm(cs, 2, 0); } else { } return; } } static void isac_empty_fifo(struct IsdnCardState *cs , int count ) { u_char *ptr ; char *t ; int tmp ; { if ((cs->debug & 4) != 0 && (cs->debug & 8) == 0) { debugl1(cs, (char *)"isac_empty_fifo"); } else { } if (cs->rcvidx + count > 299) { if (cs->debug & 1) { debugl1(cs, (char *)"isac_empty_fifo overrun %d", cs->rcvidx + count); } else { } (*(cs->writeisac))(cs, 33, 128); cs->rcvidx = 0; return; } else { } ptr = cs->rcvbuf + (unsigned long )cs->rcvidx; cs->rcvidx = cs->rcvidx + count; (*(cs->readisacfifo))(cs, ptr, count); (*(cs->writeisac))(cs, 33, 128); if ((cs->debug & 8) != 0) { t = cs->dlog; tmp = sprintf(t, "isac_empty_fifo cnt %d", count); t = t + (unsigned long )tmp; QuickHex(t, ptr, count); debugl1(cs, cs->dlog); } else { } return; } } static void isac_fill_fifo(struct IsdnCardState *cs ) { int count ; int more ; u_char *ptr ; int tmp ; struct lock_class_key __key ; char *t ; int tmp___0 ; { if ((cs->debug & 4) != 0 && (cs->debug & 8) == 0) { debugl1(cs, (char *)"isac_fill_fifo"); } else { } if ((unsigned long )cs->tx_skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } count = (int )(cs->tx_skb)->len; if (count <= 0) { return; } else { } more = 0; if (count > 32) { more = 1; count = 32; } else { } ptr = (cs->tx_skb)->data; skb_pull(cs->tx_skb, (unsigned int )count); cs->tx_cnt = cs->tx_cnt + count; (*(cs->writeisacfifo))(cs, ptr, count); (*(cs->writeisac))(cs, 33, more != 0 ? 8 : 10); tmp = test_and_set_bit(6, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp != 0) { debugl1(cs, (char *)"isac_fill_fifo dbusytimer running"); del_timer(& cs->dbusytimer); } else { } init_timer_key(& cs->dbusytimer, 0U, "(&cs->dbusytimer)", & __key); cs->dbusytimer.expires = (unsigned long )jiffies + 20UL; add_timer(& cs->dbusytimer); if ((cs->debug & 8) != 0) { t = cs->dlog; tmp___0 = sprintf(t, "isac_fill_fifo cnt %d", count); t = t + (unsigned long )tmp___0; QuickHex(t, ptr, count); debugl1(cs, cs->dlog); } else { } return; } } void isac_interrupt(struct IsdnCardState *cs , u_char val ) { u_char exval ; u_char v1 ; struct sk_buff *skb ; unsigned int count ; u_char tmp ; size_t __len ; void *__ret ; unsigned char *tmp___1 ; int tmp___2 ; int tmp___3 ; struct sk_buff *tmp___4 ; int tmp___5 ; int tmp___6 ; u_char *tmp___7 ; void *tmp___8 ; int tmp___9 ; u_char *tmp___10 ; void *tmp___11 ; int tmp___12 ; int tmp___13 ; int tmp___14 ; { if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"ISAC interrupt %x", (int )val); } else { } if ((int )((signed char )val) < 0) { exval = (*(cs->readisac))(cs, 39); if (((int )exval & 112) != 32) { if (((int )exval & 64) != 0) { if (cs->debug & 1) { debugl1(cs, (char *)"ISAC RDO"); } else { } cs->err_rx = cs->err_rx + 1; } else { } if (((int )exval & 32) == 0) { if (cs->debug & 1) { debugl1(cs, (char *)"ISAC CRC error"); } else { } cs->err_crc = cs->err_crc + 1; } else { } (*(cs->writeisac))(cs, 33, 128); } else { tmp = (*(cs->readisac))(cs, 37); count = (unsigned int )tmp & 31U; if (count == 0U) { count = 32U; } else { } isac_empty_fifo(cs, (int )count); count = (unsigned int )cs->rcvidx; if (count != 0U) { cs->rcvidx = 0; skb = alloc_skb(count, 32U); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { printk("\fHiSax: D receive out of memory\n"); } else { __len = (size_t )count; tmp___1 = skb_put(skb, count); __ret = memcpy((void *)tmp___1, (void const *)cs->rcvbuf, __len); skb_queue_tail(& cs->rq, skb); } } else { } } cs->rcvidx = 0; test_and_set_bit(0, (unsigned long volatile *)(& cs->event)); schedule_work(& cs->tqueue); } else { } if (((int )val & 64) != 0) { isac_empty_fifo(cs, 32); } else { } if (((int )val & 32) != 0) { if (cs->debug & 1) { debugl1(cs, (char *)"ISAC RSC interrupt"); } else { } } else { } if (((int )val & 16) != 0) { tmp___2 = test_and_clear_bit(6, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___2 != 0) { del_timer(& cs->dbusytimer); } else { } tmp___3 = test_and_clear_bit(5, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___3 != 0) { test_and_set_bit(3, (unsigned long volatile *)(& cs->event)); schedule_work(& cs->tqueue); } else { } if ((unsigned long )cs->tx_skb != (unsigned long )((struct sk_buff *)0)) { if ((cs->tx_skb)->len != 0U) { isac_fill_fifo(cs); goto afterXPR; } else { dev_kfree_skb_irq(cs->tx_skb); cs->tx_cnt = 0; cs->tx_skb = 0; } } else { } tmp___4 = skb_dequeue(& cs->sq); cs->tx_skb = tmp___4; if ((unsigned long )tmp___4 != (unsigned long )((struct sk_buff *)0)) { cs->tx_cnt = 0; isac_fill_fifo(cs); } else { test_and_set_bit(1, (unsigned long volatile *)(& cs->event)); schedule_work(& cs->tqueue); } } else { } afterXPR: ; if (((int )val & 4) != 0) { exval = (*(cs->readisac))(cs, 49); if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"ISAC CIR0 %02X", (int )exval); } else { } if (((int )exval & 2) != 0) { cs->dc.isac.ph_state = ((int )exval >> 2) & 15; if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"ph_state change %x", cs->dc.isac.ph_state); } else { } test_and_set_bit(2, (unsigned long volatile *)(& cs->event)); schedule_work(& cs->tqueue); } else { } if ((int )exval & 1) { exval = (*(cs->readisac))(cs, 51); if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"ISAC CIR1 %02X", (int )exval); } else { } } else { } } else { } if (((int )val & 2) != 0) { if (cs->debug & 1) { debugl1(cs, (char *)"ISAC SIN interrupt"); } else { } } else { } if ((int )val & 1) { exval = (*(cs->readisac))(cs, 36); if (cs->debug & 1) { debugl1(cs, (char *)"ISAC EXIR %02x", (int )exval); } else { } if ((int )((signed char )exval) < 0) { debugl1(cs, (char *)"ISAC XMR"); printk("\fHiSax: ISAC XMR\n"); } else { } if (((int )exval & 64) != 0) { debugl1(cs, (char *)"ISAC XDU"); printk("\fHiSax: ISAC XDU\n"); cs->err_tx = cs->err_tx + 1; tmp___5 = test_and_clear_bit(6, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___5 != 0) { del_timer(& cs->dbusytimer); } else { } tmp___6 = test_and_clear_bit(5, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___6 != 0) { test_and_set_bit(3, (unsigned long volatile *)(& cs->event)); schedule_work(& cs->tqueue); } else { } if ((unsigned long )cs->tx_skb != (unsigned long )((struct sk_buff *)0)) { skb_push(cs->tx_skb, (unsigned int )cs->tx_cnt); cs->tx_cnt = 0; isac_fill_fifo(cs); } else { printk("\fHiSax: ISAC XDU no skb\n"); debugl1(cs, (char *)"ISAC XDU no skb"); } } else { } if (((int )exval & 4) != 0) { v1 = (*(cs->readisac))(cs, 58); if ((cs->debug & 512) != 0) { debugl1(cs, (char *)"ISAC MOSR %02x", (int )v1); } else { } if (((int )v1 & 8) != 0) { if ((unsigned long )cs->dc.isac.mon_rx == (unsigned long )((u_char *)0)) { tmp___8 = kmalloc(32UL, 32U); tmp___7 = (u_char *)tmp___8; cs->dc.isac.mon_rx = tmp___7; if ((unsigned long )tmp___7 == (unsigned long )((u_char *)0)) { if (cs->debug & 1) { debugl1(cs, (char *)"ISAC MON RX out of memory!"); } else { } cs->dc.isac.mocr = (unsigned int )cs->dc.isac.mocr & 240U; cs->dc.isac.mocr = (u_char )((unsigned int )cs->dc.isac.mocr | 10U); (*(cs->writeisac))(cs, 58, (int )cs->dc.isac.mocr); goto afterMONR0; } else { cs->dc.isac.mon_rxp = 0; } } else { } if (cs->dc.isac.mon_rxp > 31) { cs->dc.isac.mocr = (unsigned int )cs->dc.isac.mocr & 240U; cs->dc.isac.mocr = (u_char )((unsigned int )cs->dc.isac.mocr | 10U); (*(cs->writeisac))(cs, 58, (int )cs->dc.isac.mocr); cs->dc.isac.mon_rxp = 0; if (cs->debug & 1) { debugl1(cs, (char *)"ISAC MON RX overflow!"); } else { } goto afterMONR0; } else { } tmp___9 = cs->dc.isac.mon_rxp; cs->dc.isac.mon_rxp = cs->dc.isac.mon_rxp + 1; *(cs->dc.isac.mon_rx + (unsigned long )tmp___9) = (*(cs->readisac))(cs, 50); if ((cs->debug & 512) != 0) { debugl1(cs, (char *)"ISAC MOR0 %02x", (int )*(cs->dc.isac.mon_rx + ((unsigned long )cs->dc.isac.mon_rxp + 0xffffffffffffffffUL))); } else { } if (cs->dc.isac.mon_rxp == 1) { cs->dc.isac.mocr = (u_char )((unsigned int )cs->dc.isac.mocr | 4U); (*(cs->writeisac))(cs, 58, (int )cs->dc.isac.mocr); } else { } } else { } afterMONR0: ; if ((int )((signed char )v1) < 0) { if ((unsigned long )cs->dc.isac.mon_rx == (unsigned long )((u_char *)0)) { tmp___11 = kmalloc(32UL, 32U); tmp___10 = (u_char *)tmp___11; cs->dc.isac.mon_rx = tmp___10; if ((unsigned long )tmp___10 == (unsigned long )((u_char *)0)) { if (cs->debug & 1) { debugl1(cs, (char *)"ISAC MON RX out of memory!"); } else { } cs->dc.isac.mocr = (unsigned int )cs->dc.isac.mocr & 15U; cs->dc.isac.mocr = (u_char )((unsigned int )cs->dc.isac.mocr | 160U); (*(cs->writeisac))(cs, 58, (int )cs->dc.isac.mocr); goto afterMONR1; } else { cs->dc.isac.mon_rxp = 0; } } else { } if (cs->dc.isac.mon_rxp > 31) { cs->dc.isac.mocr = (unsigned int )cs->dc.isac.mocr & 15U; cs->dc.isac.mocr = (u_char )((unsigned int )cs->dc.isac.mocr | 160U); (*(cs->writeisac))(cs, 58, (int )cs->dc.isac.mocr); cs->dc.isac.mon_rxp = 0; if (cs->debug & 1) { debugl1(cs, (char *)"ISAC MON RX overflow!"); } else { } goto afterMONR1; } else { } tmp___12 = cs->dc.isac.mon_rxp; cs->dc.isac.mon_rxp = cs->dc.isac.mon_rxp + 1; *(cs->dc.isac.mon_rx + (unsigned long )tmp___12) = (*(cs->readisac))(cs, 52); if ((cs->debug & 512) != 0) { debugl1(cs, (char *)"ISAC MOR1 %02x", (int )*(cs->dc.isac.mon_rx + ((unsigned long )cs->dc.isac.mon_rxp + 0xffffffffffffffffUL))); } else { } cs->dc.isac.mocr = (u_char )((unsigned int )cs->dc.isac.mocr | 64U); (*(cs->writeisac))(cs, 58, (int )cs->dc.isac.mocr); } else { } afterMONR1: ; if (((int )v1 & 4) != 0) { cs->dc.isac.mocr = (unsigned int )cs->dc.isac.mocr & 240U; (*(cs->writeisac))(cs, 58, (int )cs->dc.isac.mocr); cs->dc.isac.mocr = (u_char )((unsigned int )cs->dc.isac.mocr | 10U); (*(cs->writeisac))(cs, 58, (int )cs->dc.isac.mocr); test_and_set_bit(4, (unsigned long volatile *)(& cs->event)); schedule_work(& cs->tqueue); } else { } if (((int )v1 & 64) != 0) { cs->dc.isac.mocr = (unsigned int )cs->dc.isac.mocr & 15U; (*(cs->writeisac))(cs, 58, (int )cs->dc.isac.mocr); cs->dc.isac.mocr = (u_char )((unsigned int )cs->dc.isac.mocr | 160U); (*(cs->writeisac))(cs, 58, (int )cs->dc.isac.mocr); test_and_set_bit(5, (unsigned long volatile *)(& cs->event)); schedule_work(& cs->tqueue); } else { } if (((int )v1 & 2) != 0) { if ((unsigned long )cs->dc.isac.mon_tx == (unsigned long )((u_char *)0) || ((cs->dc.isac.mon_txc != 0 && cs->dc.isac.mon_txp >= cs->dc.isac.mon_txc) && ((int )v1 & 8) == 0)) { cs->dc.isac.mocr = (unsigned int )cs->dc.isac.mocr & 240U; (*(cs->writeisac))(cs, 58, (int )cs->dc.isac.mocr); cs->dc.isac.mocr = (u_char )((unsigned int )cs->dc.isac.mocr | 10U); (*(cs->writeisac))(cs, 58, (int )cs->dc.isac.mocr); if (cs->dc.isac.mon_txc != 0 && cs->dc.isac.mon_txp >= cs->dc.isac.mon_txc) { test_and_set_bit(6, (unsigned long volatile *)(& cs->event)); schedule_work(& cs->tqueue); } else { } goto AfterMOX0; } else { } if (cs->dc.isac.mon_txc != 0 && cs->dc.isac.mon_txp >= cs->dc.isac.mon_txc) { test_and_set_bit(6, (unsigned long volatile *)(& cs->event)); schedule_work(& cs->tqueue); goto AfterMOX0; } else { } tmp___13 = cs->dc.isac.mon_txp; cs->dc.isac.mon_txp = cs->dc.isac.mon_txp + 1; (*(cs->writeisac))(cs, 50, (int )*(cs->dc.isac.mon_tx + (unsigned long )tmp___13)); if ((cs->debug & 512) != 0) { debugl1(cs, (char *)"ISAC %02x -> MOX0", (int )*(cs->dc.isac.mon_tx + ((unsigned long )cs->dc.isac.mon_txp + 0xffffffffffffffffUL))); } else { } } else { } AfterMOX0: ; if (((int )v1 & 32) != 0) { if ((unsigned long )cs->dc.isac.mon_tx == (unsigned long )((u_char *)0) || ((cs->dc.isac.mon_txc != 0 && cs->dc.isac.mon_txp >= cs->dc.isac.mon_txc) && (int )((signed char )v1) >= 0)) { cs->dc.isac.mocr = (unsigned int )cs->dc.isac.mocr & 15U; (*(cs->writeisac))(cs, 58, (int )cs->dc.isac.mocr); cs->dc.isac.mocr = (u_char )((unsigned int )cs->dc.isac.mocr | 160U); (*(cs->writeisac))(cs, 58, (int )cs->dc.isac.mocr); if (cs->dc.isac.mon_txc != 0 && cs->dc.isac.mon_txp >= cs->dc.isac.mon_txc) { test_and_set_bit(7, (unsigned long volatile *)(& cs->event)); schedule_work(& cs->tqueue); } else { } goto AfterMOX1; } else { } if (cs->dc.isac.mon_txc != 0 && cs->dc.isac.mon_txp >= cs->dc.isac.mon_txc) { test_and_set_bit(7, (unsigned long volatile *)(& cs->event)); schedule_work(& cs->tqueue); goto AfterMOX1; } else { } tmp___14 = cs->dc.isac.mon_txp; cs->dc.isac.mon_txp = cs->dc.isac.mon_txp + 1; (*(cs->writeisac))(cs, 52, (int )*(cs->dc.isac.mon_tx + (unsigned long )tmp___14)); if ((cs->debug & 512) != 0) { debugl1(cs, (char *)"ISAC %02x -> MOX1", (int )*(cs->dc.isac.mon_tx + ((unsigned long )cs->dc.isac.mon_txp + 0xffffffffffffffffUL))); } else { } } else { } AfterMOX1: ; } else { } } else { } return; } } static void ISAC_l1hw(struct PStack *st , int pr , void *arg ) { struct IsdnCardState *cs ; struct sk_buff *skb ; u_long flags ; int val ; raw_spinlock_t *tmp ; raw_spinlock_t *tmp___0 ; raw_spinlock_t *tmp___1 ; raw_spinlock_t *tmp___2 ; raw_spinlock_t *tmp___3 ; raw_spinlock_t *tmp___4 ; int tmp___5 ; int tmp___6 ; int tmp___7 ; { cs = (struct IsdnCardState *)st->l1.hardware; skb = (struct sk_buff *)arg; switch (pr) { case 288: ; if ((cs->debug & 1024) != 0) { LogFrame(cs, skb->data, (int )skb->len); } else { } if ((cs->debug & 2048) != 0) { dlogframe(cs, skb, 0); } else { } tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); if ((unsigned long )cs->tx_skb != (unsigned long )((struct sk_buff *)0)) { skb_queue_tail(& cs->sq, skb); if ((cs->debug & 64) != 0) { Logl2Frame(cs, skb, (char *)"PH_DATA Queued", 0); } else { } } else { cs->tx_skb = skb; cs->tx_cnt = 0; if ((cs->debug & 64) != 0) { Logl2Frame(cs, skb, (char *)"PH_DATA", 0); } else { } isac_fill_fifo(cs); } spin_unlock_irqrestore(& cs->lock, flags); goto ldv_41059; case 306: tmp___0 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___0); if ((unsigned long )cs->tx_skb != (unsigned long )((struct sk_buff *)0)) { if (cs->debug & 1) { debugl1(cs, (char *)" l2l1 tx_skb exist this shouldn\'t happen"); } else { } skb_queue_tail(& cs->sq, skb); } else { if ((cs->debug & 1024) != 0) { LogFrame(cs, skb->data, (int )skb->len); } else { } if ((cs->debug & 2048) != 0) { dlogframe(cs, skb, 0); } else { } cs->tx_skb = skb; cs->tx_cnt = 0; if ((cs->debug & 64) != 0) { Logl2Frame(cs, skb, (char *)"PH_DATA_PULLED", 0); } else { } isac_fill_fifo(cs); } spin_unlock_irqrestore(& cs->lock, flags); goto ldv_41059; case 304: ; if ((cs->debug & 64) != 0) { debugl1(cs, (char *)"-> PH_REQUEST_PULL"); } else { } if ((unsigned long )cs->tx_skb == (unsigned long )((struct sk_buff *)0)) { test_and_clear_bit(6, (unsigned long volatile *)(& st->l1.Flags)); (*(st->l1.l1l2))(st, 305, 0); } else { test_and_set_bit(6, (unsigned long volatile *)(& st->l1.Flags)); } goto ldv_41059; case 4: tmp___1 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___1); if ((cs->dc.isac.ph_state == 6 || cs->dc.isac.ph_state == 0) || cs->dc.isac.ph_state == 1) { ph_command(cs, 0U); } else { ph_command(cs, 1U); } spin_unlock_irqrestore(& cs->lock, flags); goto ldv_41059; case 0: tmp___2 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___2); ph_command(cs, 0U); spin_unlock_irqrestore(& cs->lock, flags); goto ldv_41059; case 48: tmp___3 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___3); ph_command(cs, 8U); spin_unlock_irqrestore(& cs->lock, flags); goto ldv_41059; case 112: tmp___4 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___4); val = 0; if ((int )((long )arg) & 1) { val = val | 12; } else { } if (((long )arg & 2L) != 0L) { val = val | 3; } else { } tmp___5 = constant_test_bit(0U, (unsigned long const volatile *)(& cs->HW_Flags)); if (tmp___5 != 0) { if (val == 0) { (*(cs->writeisac))(cs, 48, 10); (*(cs->writeisac))(cs, 56, 2); } else { (*(cs->writeisac))(cs, 48, (int )((u_char )val)); (*(cs->writeisac))(cs, 56, 10); } } else { (*(cs->writeisac))(cs, 48, (int )((u_char )val)); if (val != 0) { (*(cs->writeisac))(cs, 56, 8); } else { (*(cs->writeisac))(cs, 56, 0); } } spin_unlock_irqrestore(& cs->lock, flags); goto ldv_41059; case 27: skb_queue_purge(& cs->rq); skb_queue_purge(& cs->sq); if ((unsigned long )cs->tx_skb != (unsigned long )((struct sk_buff *)0)) { dev_kfree_skb_any(cs->tx_skb); cs->tx_skb = 0; } else { } tmp___6 = test_and_clear_bit(6, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___6 != 0) { del_timer(& cs->dbusytimer); } else { } tmp___7 = test_and_clear_bit(5, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___7 != 0) { test_and_set_bit(3, (unsigned long volatile *)(& cs->event)); schedule_work(& cs->tqueue); } else { } goto ldv_41059; default: ; if (cs->debug & 1) { debugl1(cs, (char *)"isac_l1hw unknown %04x", pr); } else { } goto ldv_41059; } ldv_41059: ; return; } } static void setstack_isac(struct PStack *st , struct IsdnCardState *cs ) { { st->l1.l1hw = & ISAC_l1hw; return; } } static void DC_Close_isac(struct IsdnCardState *cs ) { { kfree((void const *)cs->dc.isac.mon_rx); cs->dc.isac.mon_rx = 0; kfree((void const *)cs->dc.isac.mon_tx); cs->dc.isac.mon_tx = 0; return; } } static void dbusy_timer_handler(struct IsdnCardState *cs ) { struct PStack *stptr ; int rbch ; int star ; u_char tmp ; u_char tmp___0 ; int tmp___1 ; { tmp___1 = constant_test_bit(6U, (unsigned long const volatile *)(& cs->HW_Flags)); if (tmp___1 != 0) { tmp = (*(cs->readisac))(cs, 42); rbch = (int )tmp; tmp___0 = (*(cs->readisac))(cs, 33); star = (int )tmp___0; if (cs->debug != 0) { debugl1(cs, (char *)"D-Channel Busy RBCH %02x STAR %02x", rbch, star); } else { } if ((rbch & 128) != 0) { test_and_set_bit(5, (unsigned long volatile *)(& cs->HW_Flags)); stptr = cs->stlist; goto ldv_41097; ldv_41096: (*(stptr->l1.l1l2))(stptr, 338, 0); stptr = stptr->next; ldv_41097: ; if ((unsigned long )stptr != (unsigned long )((struct PStack *)0)) { goto ldv_41096; } else { } } else { test_and_clear_bit(6, (unsigned long volatile *)(& cs->HW_Flags)); if ((unsigned long )cs->tx_skb != (unsigned long )((struct sk_buff *)0)) { dev_kfree_skb_any(cs->tx_skb); cs->tx_cnt = 0; cs->tx_skb = 0; } else { printk("\fHiSax: ISAC D-Channel Busy no skb\n"); debugl1(cs, (char *)"D-Channel Busy no skb"); } (*(cs->writeisac))(cs, 33, 1); (*(cs->irq_func))((int )cs->irq, (void *)cs); } } else { } return; } } void initisac(struct IsdnCardState *cs ) { int tmp ; { cs->setstack_d = & setstack_isac; cs->DC_Close = & DC_Close_isac; cs->dc.isac.mon_tx = 0; cs->dc.isac.mon_rx = 0; (*(cs->writeisac))(cs, 32, 255); cs->dc.isac.mocr = 170U; tmp = constant_test_bit(0U, (unsigned long const volatile *)(& cs->HW_Flags)); if (tmp != 0) { (*(cs->writeisac))(cs, 57, 0); (*(cs->writeisac))(cs, 48, 10); (*(cs->writeisac))(cs, 56, 2); (*(cs->writeisac))(cs, 55, 112); (*(cs->writeisac))(cs, 34, 201); } else { if ((unsigned int )cs->dc.isac.adf2 == 0U) { cs->dc.isac.adf2 = 128U; } else { } (*(cs->writeisac))(cs, 57, (int )cs->dc.isac.adf2); (*(cs->writeisac))(cs, 59, 47); (*(cs->writeisac))(cs, 48, 0); (*(cs->writeisac))(cs, 55, 112); (*(cs->writeisac))(cs, 34, 201); (*(cs->writeisac))(cs, 35, 0); (*(cs->writeisac))(cs, 56, 0); } ph_command(cs, 1U); (*(cs->writeisac))(cs, 32, 0); return; } } void clear_pending_isac_ints(struct IsdnCardState *cs ) { int val ; int eval ; u_char tmp ; u_char tmp___0 ; u_char tmp___1 ; u_char tmp___2 ; u_char tmp___3 ; u_char tmp___4 ; { tmp = (*(cs->readisac))(cs, 33); val = (int )tmp; debugl1(cs, (char *)"ISAC STAR %x", val); tmp___0 = (*(cs->readisac))(cs, 34); val = (int )tmp___0; debugl1(cs, (char *)"ISAC MODE %x", val); tmp___1 = (*(cs->readisac))(cs, 57); val = (int )tmp___1; debugl1(cs, (char *)"ISAC ADF2 %x", val); tmp___2 = (*(cs->readisac))(cs, 32); val = (int )tmp___2; debugl1(cs, (char *)"ISAC ISTA %x", val); if (val & 1) { tmp___3 = (*(cs->readisac))(cs, 36); eval = (int )tmp___3; debugl1(cs, (char *)"ISAC EXIR %x", eval); } else { } tmp___4 = (*(cs->readisac))(cs, 49); val = (int )tmp___4; debugl1(cs, (char *)"ISAC CIR0 %x", val); cs->dc.isac.ph_state = (val >> 2) & 15; test_and_set_bit(2, (unsigned long volatile *)(& cs->event)); schedule_work(& cs->tqueue); (*(cs->writeisac))(cs, 32, 255); return; } } void setup_isac(struct IsdnCardState *cs ) { struct lock_class_key __key ; atomic_long_t __constr_expr_0 ; struct lock_class_key __key___0 ; { __init_work(& cs->tqueue, 0); __constr_expr_0.counter = 4195328L; cs->tqueue.data = __constr_expr_0; lockdep_init_map(& cs->tqueue.lockdep_map, "(&cs->tqueue)", & __key, 0); INIT_LIST_HEAD(& cs->tqueue.entry); cs->tqueue.func = & isac_bh; cs->dbusytimer.function = (void (*)(unsigned long ))(& dbusy_timer_handler); cs->dbusytimer.data = (unsigned long )cs; init_timer_key(& cs->dbusytimer, 0U, "(&cs->dbusytimer)", & __key___0); return; } } void ldv_mutex_lock_183(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_lock(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_184(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_lock(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_185(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } int ldv_mutex_trylock_186(struct mutex *ldv_func_arg1 ) { ldv_func_ret_type___2 ldv_func_res ; int tmp ; int tmp___0 ; { tmp = mutex_trylock(ldv_func_arg1); ldv_func_res = tmp; tmp___0 = ldv_mutex_trylock_mutex(ldv_func_arg1); return (tmp___0); return (ldv_func_res); } } void ldv_mutex_unlock_187(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_188(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_cred_guard_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_189(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_cred_guard_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } int ldv_mutex_trylock_202(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_198(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_200(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_203(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_197(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_199(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_201(struct mutex *ldv_func_arg1 ) ; extern void __init_waitqueue_head(wait_queue_head_t * , char const * , struct lock_class_key * ) ; extern void __wake_up(wait_queue_head_t * , unsigned int , int , void * ) ; void init_arcofi(struct IsdnCardState *cs ) ; void clear_arcofi(struct IsdnCardState *cs ) ; static void add_arcofi_timer(struct IsdnCardState *cs ) { int tmp ; struct lock_class_key __key ; { tmp = test_and_set_bit(8, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp != 0) { del_timer(& cs->dc.isac.arcofitimer); } else { } init_timer_key(& cs->dc.isac.arcofitimer, 0U, "(&cs->dc.isac.arcofitimer)", & __key); cs->dc.isac.arcofitimer.expires = (unsigned long )jiffies + 5UL; add_timer(& cs->dc.isac.arcofitimer); return; } } static void send_arcofi(struct IsdnCardState *cs ) { size_t __len ; void *__ret ; int tmp ; { add_arcofi_timer(cs); cs->dc.isac.mon_txp = 0; cs->dc.isac.mon_txc = (int )(cs->dc.isac.arcofi_list)->len; __len = (size_t )cs->dc.isac.mon_txc; __ret = memcpy((void *)cs->dc.isac.mon_tx, (void const *)(& (cs->dc.isac.arcofi_list)->msg), __len); switch ((int )cs->dc.isac.arcofi_bc) { case 0: ; goto ldv_40993; case 1: *(cs->dc.isac.mon_tx + 1UL) = (u_char )((unsigned int )*(cs->dc.isac.mon_tx + 1UL) | 64U); goto ldv_40993; default: ; goto ldv_40993; } ldv_40993: cs->dc.isac.mocr = (unsigned int )cs->dc.isac.mocr & 15U; cs->dc.isac.mocr = (u_char )((unsigned int )cs->dc.isac.mocr | 160U); (*(cs->writeisac))(cs, 58, (int )cs->dc.isac.mocr); (*(cs->readisac))(cs, 58); tmp = cs->dc.isac.mon_txp; cs->dc.isac.mon_txp = cs->dc.isac.mon_txp + 1; (*(cs->writeisac))(cs, 52, (int )*(cs->dc.isac.mon_tx + (unsigned long )tmp)); cs->dc.isac.mocr = (u_char )((unsigned int )cs->dc.isac.mocr | 16U); (*(cs->writeisac))(cs, 58, (int )cs->dc.isac.mocr); return; } } int arcofi_fsm(struct IsdnCardState *cs , int event , void *data ) { int tmp ; int tmp___0 ; { if ((cs->debug & 512) != 0) { debugl1(cs, (char *)"arcofi state %d event %d", (int )cs->dc.isac.arcofi_state, event); } else { } if (event == 4) { cs->dc.isac.arcofi_state = 0U; test_and_set_bit(9, (unsigned long volatile *)(& cs->HW_Flags)); __wake_up(& cs->dc.isac.arcofi_wait, 3U, 1, 0); return (1); } else { } switch ((int )cs->dc.isac.arcofi_state) { case 0: ; if (event == 1) { cs->dc.isac.arcofi_list = (struct arcofi_msg *)data; cs->dc.isac.arcofi_state = 1U; send_arcofi(cs); } else { } goto ldv_41002; case 1: ; if (event == 2) { if ((unsigned int )(cs->dc.isac.arcofi_list)->receive != 0U) { add_arcofi_timer(cs); cs->dc.isac.arcofi_state = 2U; } else if ((unsigned long )(cs->dc.isac.arcofi_list)->next != (unsigned long )((struct arcofi_msg *)0)) { cs->dc.isac.arcofi_list = (cs->dc.isac.arcofi_list)->next; send_arcofi(cs); } else { tmp = test_and_clear_bit(8, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp != 0) { del_timer(& cs->dc.isac.arcofitimer); } else { } cs->dc.isac.arcofi_state = 0U; __wake_up(& cs->dc.isac.arcofi_wait, 3U, 1, 0); } } else { } goto ldv_41002; case 2: ; if (event == 3) { if ((unsigned long )(cs->dc.isac.arcofi_list)->next != (unsigned long )((struct arcofi_msg *)0)) { cs->dc.isac.arcofi_list = (cs->dc.isac.arcofi_list)->next; cs->dc.isac.arcofi_state = 1U; send_arcofi(cs); } else { tmp___0 = test_and_clear_bit(8, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___0 != 0) { del_timer(& cs->dc.isac.arcofitimer); } else { } cs->dc.isac.arcofi_state = 0U; __wake_up(& cs->dc.isac.arcofi_wait, 3U, 1, 0); } } else { } goto ldv_41002; default: debugl1(cs, (char *)"Arcofi unknown state %x", (int )cs->dc.isac.arcofi_state); return (2); } ldv_41002: ; return (0); } } static void arcofi_timer(struct IsdnCardState *cs ) { { arcofi_fsm(cs, 4, 0); return; } } void clear_arcofi(struct IsdnCardState *cs ) { int tmp ; { tmp = test_and_clear_bit(8, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp != 0) { del_timer(& cs->dc.isac.arcofitimer); } else { } return; } } void init_arcofi(struct IsdnCardState *cs ) { struct lock_class_key __key ; struct lock_class_key __key___0 ; { cs->dc.isac.arcofitimer.function = (void (*)(unsigned long ))(& arcofi_timer); cs->dc.isac.arcofitimer.data = (unsigned long )cs; init_timer_key(& cs->dc.isac.arcofitimer, 0U, "(&cs->dc.isac.arcofitimer)", & __key); __init_waitqueue_head(& cs->dc.isac.arcofi_wait, "&cs->dc.isac.arcofi_wait", & __key___0); test_and_set_bit(3, (unsigned long volatile *)(& cs->HW_Flags)); return; } } void ldv_mutex_lock_197(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_cred_guard_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_198(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_cred_guard_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_199(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_lock(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_200(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_lock(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_201(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } int ldv_mutex_trylock_202(struct mutex *ldv_func_arg1 ) { ldv_func_ret_type___4 ldv_func_res ; int tmp ; int tmp___0 ; { tmp = mutex_trylock(ldv_func_arg1); ldv_func_res = tmp; tmp___0 = ldv_mutex_trylock_mutex(ldv_func_arg1); return (tmp___0); return (ldv_func_res); } } void ldv_mutex_unlock_203(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } int ldv_mutex_trylock_214(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_212(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_215(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_217(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_211(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_213(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_216(struct mutex *ldv_func_arg1 ) ; void modehscx(struct BCState *bcs , int mode , int bc ) ; void clear_pending_hscx_ints(struct IsdnCardState *cs ) ; void inithscx(struct IsdnCardState *cs ) ; static char *HSCXVer[16U] = { (char *)"A1", (char *)"?1", (char *)"A2", (char *)"?3", (char *)"A3", (char *)"V2.1", (char *)"?6", (char *)"?7", (char *)"?8", (char *)"?9", (char *)"?10", (char *)"?11", (char *)"?12", (char *)"?13", (char *)"?14", (char *)"???"}; int HscxVersion(struct IsdnCardState *cs , char *s ) { int verA ; int verB ; u_char tmp ; u_char tmp___0 ; { tmp = (*(cs->BC_Read_Reg))(cs, 0, 46); verA = (int )tmp & 15; tmp___0 = (*(cs->BC_Read_Reg))(cs, 1, 46); verB = (int )tmp___0 & 15; printk("\016%s HSCX version A: %s B: %s\n", s, HSCXVer[verA], HSCXVer[verB]); if ((((verA == 0 || verA == 15) | (verB == 0)) | (verB == 15)) != 0) { return (1); } else { return (0); } } } void modehscx(struct BCState *bcs , int mode , int bc ) { struct IsdnCardState *cs ; int hscx ; int tmp ; int tmp___0 ; int tmp___1 ; int tmp___2 ; int tmp___3 ; { cs = bcs->cs; hscx = bcs->hw.hscx.hscx; if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"hscx %c mode %d ichan %d", hscx + 65, mode, bc); } else { } bcs->mode = mode; bcs->channel = bc; (*(cs->BC_Write_Reg))(cs, hscx, 36, 255); (*(cs->BC_Write_Reg))(cs, hscx, 37, 255); (*(cs->BC_Write_Reg))(cs, hscx, 39, 255); (*(cs->BC_Write_Reg))(cs, hscx, 45, 0); (*(cs->BC_Write_Reg))(cs, hscx, 46, 0); tmp = constant_test_bit(1U, (unsigned long const volatile *)(& cs->HW_Flags)); (*(cs->BC_Write_Reg))(cs, hscx, 47, tmp != 0 ? 130 : 133); (*(cs->BC_Write_Reg))(cs, hscx, 44, 48); (*(cs->BC_Write_Reg))(cs, hscx, 50, 7); (*(cs->BC_Write_Reg))(cs, hscx, 51, 7); tmp___0 = constant_test_bit(0U, (unsigned long const volatile *)(& cs->HW_Flags)); if (tmp___0 != 0 && hscx == 0) { bc = 1 - bc; } else { } if (bc == 0) { tmp___1 = constant_test_bit(0U, (unsigned long const volatile *)(& cs->HW_Flags)); (*(cs->BC_Write_Reg))(cs, hscx, 48, tmp___1 == 0 ? (int )bcs->hw.hscx.tsaxr0 : 7); tmp___2 = constant_test_bit(0U, (unsigned long const volatile *)(& cs->HW_Flags)); (*(cs->BC_Write_Reg))(cs, hscx, 49, tmp___2 == 0 ? (int )bcs->hw.hscx.tsaxr0 : 7); } else { (*(cs->BC_Write_Reg))(cs, hscx, 48, (int )bcs->hw.hscx.tsaxr1); (*(cs->BC_Write_Reg))(cs, hscx, 49, (int )bcs->hw.hscx.tsaxr1); } switch (mode) { case 0: (*(cs->BC_Write_Reg))(cs, hscx, 48, 31); (*(cs->BC_Write_Reg))(cs, hscx, 49, 31); (*(cs->BC_Write_Reg))(cs, hscx, 34, 132); goto ldv_41003; case 1: (*(cs->BC_Write_Reg))(cs, hscx, 34, 228); goto ldv_41003; case 2: tmp___3 = constant_test_bit(1U, (unsigned long const volatile *)(& cs->HW_Flags)); (*(cs->BC_Write_Reg))(cs, hscx, 47, tmp___3 != 0 ? 138 : 141); (*(cs->BC_Write_Reg))(cs, hscx, 34, 140); goto ldv_41003; } ldv_41003: ; if (mode != 0) { (*(cs->BC_Write_Reg))(cs, hscx, 33, 65); } else { } (*(cs->BC_Write_Reg))(cs, hscx, 32, 0); return; } } void hscx_l2l1(struct PStack *st , int pr , void *arg ) { struct BCState *bcs ; u_long flags ; struct sk_buff *skb ; raw_spinlock_t *tmp ; raw_spinlock_t *tmp___0 ; raw_spinlock_t *tmp___1 ; raw_spinlock_t *tmp___2 ; { bcs = st->l1.bcs; skb = (struct sk_buff *)arg; switch (pr) { case 288: tmp = spinlock_check(& (bcs->cs)->lock); flags = _raw_spin_lock_irqsave(tmp); if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { skb_queue_tail(& bcs->squeue, skb); } else { bcs->tx_skb = skb; test_and_set_bit(3, (unsigned long volatile *)(& bcs->Flag)); bcs->hw.hscx.count = 0; (*((bcs->cs)->BC_Send_Data))(bcs); } spin_unlock_irqrestore(& (bcs->cs)->lock, flags); goto ldv_41018; case 306: tmp___0 = spinlock_check(& (bcs->cs)->lock); flags = _raw_spin_lock_irqsave(tmp___0); if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { printk("\fhscx_l2l1: this shouldn\'t happen\n"); } else { test_and_set_bit(3, (unsigned long volatile *)(& bcs->Flag)); bcs->tx_skb = skb; bcs->hw.hscx.count = 0; (*((bcs->cs)->BC_Send_Data))(bcs); } spin_unlock_irqrestore(& (bcs->cs)->lock, flags); goto ldv_41018; case 304: ; if ((unsigned long )bcs->tx_skb == (unsigned long )((struct sk_buff *)0)) { test_and_clear_bit(6, (unsigned long volatile *)(& st->l1.Flags)); (*(st->l1.l1l2))(st, 305, 0); } else { test_and_set_bit(6, (unsigned long volatile *)(& st->l1.Flags)); } goto ldv_41018; case 256: tmp___1 = spinlock_check(& (bcs->cs)->lock); flags = _raw_spin_lock_irqsave(tmp___1); test_and_set_bit(2, (unsigned long volatile *)(& bcs->Flag)); modehscx(bcs, st->l1.mode, st->l1.bc); spin_unlock_irqrestore(& (bcs->cs)->lock, flags); l1_msg_b(st, pr, arg); goto ldv_41018; case 272: l1_msg_b(st, pr, arg); goto ldv_41018; case 273: tmp___2 = spinlock_check(& (bcs->cs)->lock); flags = _raw_spin_lock_irqsave(tmp___2); test_and_clear_bit(2, (unsigned long volatile *)(& bcs->Flag)); test_and_clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); modehscx(bcs, 0, st->l1.bc); spin_unlock_irqrestore(& (bcs->cs)->lock, flags); (*(st->l1.l1l2))(st, 273, 0); goto ldv_41018; } ldv_41018: ; return; } } static void close_hscxstate(struct BCState *bcs ) { int tmp ; { modehscx(bcs, 0, bcs->channel); tmp = test_and_clear_bit(1, (unsigned long volatile *)(& bcs->Flag)); if (tmp != 0) { kfree((void const *)bcs->hw.hscx.rcvbuf); bcs->hw.hscx.rcvbuf = 0; kfree((void const *)bcs->blog); bcs->blog = 0; skb_queue_purge(& bcs->rqueue); skb_queue_purge(& bcs->squeue); if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { dev_kfree_skb_any(bcs->tx_skb); bcs->tx_skb = 0; test_and_clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); } else { } } else { } return; } } int open_hscxstate(struct IsdnCardState *cs , struct BCState *bcs ) { u_char *tmp ; void *tmp___0 ; u_char *tmp___1 ; void *tmp___2 ; int tmp___3 ; { tmp___3 = test_and_set_bit(1, (unsigned long volatile *)(& bcs->Flag)); if (tmp___3 == 0) { tmp___0 = kmalloc(4096UL, 32U); tmp = (u_char *)tmp___0; bcs->hw.hscx.rcvbuf = tmp; if ((unsigned long )tmp == (unsigned long )((u_char *)0)) { printk("\fHiSax: No memory for hscx.rcvbuf\n"); test_and_clear_bit(1, (unsigned long volatile *)(& bcs->Flag)); return (1); } else { } tmp___2 = kmalloc(256UL, 32U); tmp___1 = (u_char *)tmp___2; bcs->blog = tmp___1; if ((unsigned long )tmp___1 == (unsigned long )((u_char *)0)) { printk("\fHiSax: No memory for bcs->blog\n"); test_and_clear_bit(1, (unsigned long volatile *)(& bcs->Flag)); kfree((void const *)bcs->hw.hscx.rcvbuf); bcs->hw.hscx.rcvbuf = 0; return (2); } else { } skb_queue_head_init(& bcs->rqueue); skb_queue_head_init(& bcs->squeue); } else { } bcs->tx_skb = 0; test_and_clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); bcs->event = 0UL; bcs->hw.hscx.rcvidx = 0; bcs->tx_cnt = 0; return (0); } } static int setstack_hscx(struct PStack *st , struct BCState *bcs ) { int tmp ; { bcs->channel = st->l1.bc; tmp = open_hscxstate((struct IsdnCardState *)st->l1.hardware, bcs); if (tmp != 0) { return (-1); } else { } st->l1.bcs = bcs; st->l2.l2l1 = & hscx_l2l1; setstack_manager(st); bcs->st = st; setstack_l1_B(st); return (0); } } void clear_pending_hscx_ints(struct IsdnCardState *cs ) { int val ; int eval ; u_char tmp ; u_char tmp___0 ; u_char tmp___1 ; u_char tmp___2 ; u_char tmp___3 ; u_char tmp___4 ; { tmp = (*(cs->BC_Read_Reg))(cs, 1, 32); val = (int )tmp; debugl1(cs, (char *)"HSCX B ISTA %x", val); if (val & 1) { tmp___0 = (*(cs->BC_Read_Reg))(cs, 1, 36); eval = (int )tmp___0; debugl1(cs, (char *)"HSCX B EXIR %x", eval); } else { } if ((val & 2) != 0) { tmp___1 = (*(cs->BC_Read_Reg))(cs, 0, 36); eval = (int )tmp___1; debugl1(cs, (char *)"HSCX A EXIR %x", eval); } else { } tmp___2 = (*(cs->BC_Read_Reg))(cs, 0, 32); val = (int )tmp___2; debugl1(cs, (char *)"HSCX A ISTA %x", val); tmp___3 = (*(cs->BC_Read_Reg))(cs, 1, 33); val = (int )tmp___3; debugl1(cs, (char *)"HSCX B STAR %x", val); tmp___4 = (*(cs->BC_Read_Reg))(cs, 0, 33); val = (int )tmp___4; debugl1(cs, (char *)"HSCX A STAR %x", val); (*(cs->BC_Write_Reg))(cs, 0, 32, 255); (*(cs->BC_Write_Reg))(cs, 1, 32, 255); return; } } void inithscx(struct IsdnCardState *cs ) { { cs->bcs[0].BC_SetStack = & setstack_hscx; cs->bcs[1].BC_SetStack = & setstack_hscx; cs->bcs[0].BC_Close = & close_hscxstate; cs->bcs[1].BC_Close = & close_hscxstate; cs->bcs[0].hw.hscx.hscx = 0; cs->bcs[1].hw.hscx.hscx = 1; cs->bcs[0].hw.hscx.tsaxr0 = 47U; cs->bcs[0].hw.hscx.tsaxr1 = 3U; cs->bcs[1].hw.hscx.tsaxr0 = 47U; cs->bcs[1].hw.hscx.tsaxr1 = 3U; modehscx((struct BCState *)(& cs->bcs), 0, 0); modehscx((struct BCState *)(& cs->bcs) + 1UL, 0, 0); return; } } void inithscxisac(struct IsdnCardState *cs , int part ) { { if (part & 1) { clear_pending_isac_ints(cs); clear_pending_hscx_ints(cs); initisac(cs); inithscx(cs); } else { } if ((part & 2) != 0) { (*(cs->writeisac))(cs, 32, 0); (*(cs->BC_Write_Reg))(cs, 0, 32, 0); (*(cs->BC_Write_Reg))(cs, 1, 32, 0); (*(cs->writeisac))(cs, 33, 65); } else { } return; } } void ldv_mutex_lock_211(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_lock(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_212(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_lock(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_213(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } int ldv_mutex_trylock_214(struct mutex *ldv_func_arg1 ) { ldv_func_ret_type___2 ldv_func_res ; int tmp ; int tmp___0 ; { tmp = mutex_trylock(ldv_func_arg1); ldv_func_res = tmp; tmp___0 = ldv_mutex_trylock_mutex(ldv_func_arg1); return (tmp___0); return (ldv_func_res); } } void ldv_mutex_unlock_215(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_216(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_cred_guard_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_217(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_cred_guard_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } int ldv_mutex_trylock_228(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_226(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_229(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_231(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_225(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_227(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_230(struct mutex *ldv_func_arg1 ) ; __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; } } extern void *ioremap_nocache(resource_size_t , unsigned long ) ; __inline static void *ioremap(resource_size_t offset , unsigned long size ) { void *tmp ; { tmp = ioremap_nocache(offset, size); return (tmp); } } extern void iounmap(void volatile * ) ; extern struct pci_dev *pci_dev_get(struct pci_dev * ) ; extern void pci_dev_put(struct pci_dev * ) ; extern struct pci_dev *pci_get_subsys(unsigned int , unsigned int , unsigned int , unsigned int , struct pci_dev * ) ; extern int pci_enable_device(struct pci_dev * ) ; __inline static struct pci_dev *hisax_find_pci_device(unsigned int vendor , unsigned int device , struct pci_dev *from ) { struct pci_dev *pdev ; { pci_dev_get(from); pdev = pci_get_subsys(vendor, device, 4294967295U, 4294967295U, from); pci_dev_put(pdev); return (pdev); } } static char const *telespci_revision = "$Revision: 2.23.2.3 $"; __inline static u_char readisac(void *adr , u_char off ) { register unsigned int portdata ; { ldv_40994: portdata = readl((void const volatile *)adr + 512U); if ((portdata & 33554432U) != 0U) { goto ldv_40994; } else { } writel((unsigned int )((int )off | 8388608), (void volatile *)adr + 512U); ldv_40996: portdata = readl((void const volatile *)adr + 512U); if ((portdata & 33554432U) != 0U) { goto ldv_40996; } else { } writel(65536U, (void volatile *)adr + 512U); ldv_40998: portdata = readl((void const volatile *)adr + 512U); if ((portdata & 33554432U) != 0U) { goto ldv_40998; } else { } return ((u_char )portdata); } } __inline static void writeisac(void *adr , u_char off , u_char data ) { register unsigned int portdata ; { ldv_41006: portdata = readl((void const volatile *)adr + 512U); if ((portdata & 33554432U) != 0U) { goto ldv_41006; } else { } writel((unsigned int )((int )off | 8388608), (void volatile *)adr + 512U); ldv_41008: portdata = readl((void const volatile *)adr + 512U); if ((portdata & 33554432U) != 0U) { goto ldv_41008; } else { } writel((unsigned int )((int )data | 8454144), (void volatile *)adr + 512U); ldv_41010: portdata = readl((void const volatile *)adr + 512U); if ((portdata & 33554432U) != 0U) { goto ldv_41010; } else { } return; } } __inline static u_char readhscx(void *adr , int hscx , u_char off ) { register unsigned int portdata ; { ldv_41018: portdata = readl((void const volatile *)adr + 512U); if ((portdata & 33554432U) != 0U) { goto ldv_41018; } else { } writel((unsigned int )(((hscx != 0 ? 64 : 0) + (int )off) | 9437184), (void volatile *)adr + 512U); ldv_41020: portdata = readl((void const volatile *)adr + 512U); if ((portdata & 33554432U) != 0U) { goto ldv_41020; } else { } writel(1114112U, (void volatile *)adr + 512U); ldv_41022: portdata = readl((void const volatile *)adr + 512U); if ((portdata & 33554432U) != 0U) { goto ldv_41022; } else { } return ((u_char )portdata); } } __inline static void writehscx(void *adr , int hscx , u_char off , u_char data ) { register unsigned int portdata ; { ldv_41031: portdata = readl((void const volatile *)adr + 512U); if ((portdata & 33554432U) != 0U) { goto ldv_41031; } else { } writel((unsigned int )(((hscx != 0 ? 64 : 0) + (int )off) | 9437184), (void volatile *)adr + 512U); ldv_41033: portdata = readl((void const volatile *)adr + 512U); if ((portdata & 33554432U) != 0U) { goto ldv_41033; } else { } writel((unsigned int )((int )data | 9502720), (void volatile *)adr + 512U); ldv_41035: portdata = readl((void const volatile *)adr + 512U); if ((portdata & 33554432U) != 0U) { goto ldv_41035; } else { } return; } } __inline static void read_fifo_isac(void *adr , u_char *data , int size ) { register unsigned int portdata ; register int i ; { ldv_41044: portdata = readl((void const volatile *)adr + 512U); if ((portdata & 33554432U) != 0U) { goto ldv_41044; } else { } i = 0; goto ldv_41051; ldv_41050: writel(8388638U, (void volatile *)adr + 512U); ldv_41046: portdata = readl((void const volatile *)adr + 512U); if ((portdata & 33554432U) != 0U) { goto ldv_41046; } else { } writel(65536U, (void volatile *)adr + 512U); ldv_41048: portdata = readl((void const volatile *)adr + 512U); if ((portdata & 33554432U) != 0U) { goto ldv_41048; } else { } *(data + (unsigned long )i) = (unsigned char )portdata; i = i + 1; ldv_41051: ; if (i < size) { goto ldv_41050; } else { } return; } } static void write_fifo_isac(void *adr , u_char *data , int size ) { register unsigned int portdata ; register int i ; { ldv_41060: portdata = readl((void const volatile *)adr + 512U); if ((portdata & 33554432U) != 0U) { goto ldv_41060; } else { } i = 0; goto ldv_41067; ldv_41066: writel(8388638U, (void volatile *)adr + 512U); ldv_41062: portdata = readl((void const volatile *)adr + 512U); if ((portdata & 33554432U) != 0U) { goto ldv_41062; } else { } writel((unsigned int )((int )*(data + (unsigned long )i) | 8454144), (void volatile *)adr + 512U); ldv_41064: portdata = readl((void const volatile *)adr + 512U); if ((portdata & 33554432U) != 0U) { goto ldv_41064; } else { } i = i + 1; ldv_41067: ; if (i < size) { goto ldv_41066; } else { } return; } } __inline static void read_fifo_hscx(void *adr , int hscx , u_char *data , int size ) { register unsigned int portdata ; register int i ; { ldv_41077: portdata = readl((void const volatile *)adr + 512U); if ((portdata & 33554432U) != 0U) { goto ldv_41077; } else { } i = 0; goto ldv_41084; ldv_41083: writel(hscx != 0 ? 9437279U : 9437215U, (void volatile *)adr + 512U); ldv_41079: portdata = readl((void const volatile *)adr + 512U); if ((portdata & 33554432U) != 0U) { goto ldv_41079; } else { } writel(1114112U, (void volatile *)adr + 512U); ldv_41081: portdata = readl((void const volatile *)adr + 512U); if ((portdata & 33554432U) != 0U) { goto ldv_41081; } else { } *(data + (unsigned long )i) = (unsigned char )portdata; i = i + 1; ldv_41084: ; if (i < size) { goto ldv_41083; } else { } return; } } __inline static void write_fifo_hscx(void *adr , int hscx , u_char *data , int size ) { unsigned int portdata ; register int i ; { ldv_41094: portdata = readl((void const volatile *)adr + 512U); if ((portdata & 33554432U) != 0U) { goto ldv_41094; } else { } i = 0; goto ldv_41101; ldv_41100: writel(hscx != 0 ? 9437279U : 9437215U, (void volatile *)adr + 512U); ldv_41096: portdata = readl((void const volatile *)adr + 512U); if ((portdata & 33554432U) != 0U) { goto ldv_41096; } else { } writel((unsigned int )((int )*(data + (unsigned long )i) | 9502720), (void volatile *)adr + 512U); ldv_41098: portdata = readl((void const volatile *)adr + 512U); if ((portdata & 33554432U) != 0U) { goto ldv_41098; } else { } __const_udelay(42950UL); i = i + 1; ldv_41101: ; if (i < size) { goto ldv_41100; } else { } return; } } static u_char ReadISAC___0(struct IsdnCardState *cs , u_char offset ) { u_char tmp ; { tmp = readisac(cs->hw.teles0.membase, (int )offset); return (tmp); } } static void WriteISAC___0(struct IsdnCardState *cs , u_char offset , u_char value ) { { writeisac(cs->hw.teles0.membase, (int )offset, (int )value); return; } } static void ReadISACfifo___0(struct IsdnCardState *cs , u_char *data , int size ) { { read_fifo_isac(cs->hw.teles0.membase, data, size); return; } } static void WriteISACfifo___0(struct IsdnCardState *cs , u_char *data , int size ) { { write_fifo_isac(cs->hw.teles0.membase, data, size); return; } } static u_char ReadHSCX___0(struct IsdnCardState *cs , int hscx , u_char offset ) { u_char tmp ; { tmp = readhscx(cs->hw.teles0.membase, hscx, (int )offset); return (tmp); } } static void WriteHSCX___0(struct IsdnCardState *cs , int hscx , u_char offset , u_char value ) { { writehscx(cs->hw.teles0.membase, hscx, (int )offset, (int )value); return; } } __inline static void waitforCEC___0(struct IsdnCardState *cs , int hscx ) { int to ; u_char tmp ; { to = 50; goto ldv_41139; ldv_41138: __const_udelay(4295UL); to = to - 1; ldv_41139: tmp = readhscx(cs->hw.teles0.membase, hscx, 33); if (((int )tmp & 4) != 0 && to != 0) { goto ldv_41138; } else { } if (to == 0) { printk("\fHiSax: waitforCEC timeout\n"); } else { } return; } } __inline static void waitforXFW___0(struct IsdnCardState *cs , int hscx ) { int to ; u_char tmp ; { to = 50; goto ldv_41147; ldv_41146: __const_udelay(4295UL); to = to - 1; ldv_41147: tmp = readhscx(cs->hw.teles0.membase, hscx, 33); if (((int )tmp & 68) != 64 && to != 0) { goto ldv_41146; } else { } if (to == 0) { printk("\fHiSax: waitforXFW timeout\n"); } else { } return; } } __inline static void WriteHSCXCMDR___0(struct IsdnCardState *cs , int hscx , u_char data ) { { waitforCEC___0(cs, hscx); writehscx(cs->hw.teles0.membase, hscx, 33, (int )data); return; } } static void hscx_empty_fifo___0(struct BCState *bcs , int count ) { u_char *ptr ; struct IsdnCardState *cs ; char *t ; int tmp ; { cs = bcs->cs; if ((cs->debug & 16) != 0 && (cs->debug & 32) == 0) { debugl1(cs, (char *)"hscx_empty_fifo"); } else { } if (bcs->hw.hscx.rcvidx + count > 4096) { if (cs->debug & 1) { debugl1(cs, (char *)"hscx_empty_fifo: incoming packet too large"); } else { } WriteHSCXCMDR___0(cs, bcs->hw.hscx.hscx, 128); bcs->hw.hscx.rcvidx = 0; return; } else { } ptr = bcs->hw.hscx.rcvbuf + (unsigned long )bcs->hw.hscx.rcvidx; bcs->hw.hscx.rcvidx = bcs->hw.hscx.rcvidx + count; read_fifo_hscx(cs->hw.teles0.membase, bcs->hw.hscx.hscx, ptr, count); WriteHSCXCMDR___0(cs, bcs->hw.hscx.hscx, 128); if ((cs->debug & 32) != 0) { t = (char *)bcs->blog; tmp = sprintf(t, "hscx_empty_fifo %c cnt %d", bcs->hw.hscx.hscx != 0 ? 66 : 65, count); t = t + (unsigned long )tmp; QuickHex(t, ptr, count); debugl1(cs, (char *)bcs->blog); } else { } return; } } static void hscx_fill_fifo___0(struct BCState *bcs ) { struct IsdnCardState *cs ; int more ; int count ; int fifo_size ; int tmp ; u_char *ptr ; char *t ; int tmp___0 ; { cs = bcs->cs; tmp = constant_test_bit(1U, (unsigned long const volatile *)(& cs->HW_Flags)); fifo_size = tmp != 0 ? 64 : 32; if ((cs->debug & 16) != 0 && (cs->debug & 32) == 0) { debugl1(cs, (char *)"hscx_fill_fifo"); } else { } if ((unsigned long )bcs->tx_skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } if ((bcs->tx_skb)->len == 0U) { return; } else { } more = bcs->mode == 1; if ((bcs->tx_skb)->len > (unsigned int )fifo_size) { more = 1; count = fifo_size; } else { count = (int )(bcs->tx_skb)->len; } waitforXFW___0(cs, bcs->hw.hscx.hscx); ptr = (bcs->tx_skb)->data; skb_pull(bcs->tx_skb, (unsigned int )count); bcs->tx_cnt = bcs->tx_cnt - count; bcs->hw.hscx.count = bcs->hw.hscx.count + count; write_fifo_hscx(cs->hw.teles0.membase, bcs->hw.hscx.hscx, ptr, count); WriteHSCXCMDR___0(cs, bcs->hw.hscx.hscx, more != 0 ? 8 : 10); if ((cs->debug & 32) != 0) { t = (char *)bcs->blog; tmp___0 = sprintf(t, "hscx_fill_fifo %c cnt %d", bcs->hw.hscx.hscx != 0 ? 66 : 65, count); t = t + (unsigned long )tmp___0; QuickHex(t, ptr, count); debugl1(cs, (char *)bcs->blog); } else { } return; } } static void hscx_interrupt___0(struct IsdnCardState *cs , u_char val , u_char hscx ) { u_char r ; struct BCState *bcs ; struct sk_buff *skb ; int fifo_size ; int tmp ; int count ; int tmp___0 ; u_char tmp___1 ; int tmp___2 ; size_t __len ; void *__ret ; unsigned char *tmp___4 ; size_t __len___0 ; void *__ret___0 ; unsigned char *tmp___6 ; u_long flags ; raw_spinlock_t *tmp___7 ; int tmp___8 ; struct sk_buff *tmp___9 ; { bcs = (struct BCState *)(& cs->bcs) + (unsigned long )hscx; tmp = constant_test_bit(1U, (unsigned long const volatile *)(& cs->HW_Flags)); fifo_size = tmp != 0 ? 64 : 32; tmp___0 = constant_test_bit(1U, (unsigned long const volatile *)(& bcs->Flag)); if (tmp___0 == 0) { return; } else { } if ((int )((signed char )val) < 0) { r = readhscx(cs->hw.teles0.membase, (int )hscx, 39); if (((int )r & 240) != 160) { if ((int )((signed char )r) >= 0) { if (cs->debug & 1) { debugl1(cs, (char *)"HSCX invalid frame"); } else { } bcs->err_inv = bcs->err_inv + 1; } else { } if (((int )r & 64) != 0 && bcs->mode != 0) { if (cs->debug & 1) { debugl1(cs, (char *)"HSCX RDO mode=%d", bcs->mode); } else { } bcs->err_rdo = bcs->err_rdo + 1; } else { } if (((int )r & 32) == 0) { if (cs->debug & 1) { debugl1(cs, (char *)"HSCX CRC error"); } else { } bcs->err_crc = bcs->err_crc + 1; } else { } WriteHSCXCMDR___0(cs, (int )hscx, 128); } else { tmp___1 = readhscx(cs->hw.teles0.membase, (int )hscx, 37); tmp___2 = constant_test_bit(1U, (unsigned long const volatile *)(& cs->HW_Flags)); count = (int )tmp___1 & (tmp___2 != 0 ? 63 : 31); if (count == 0) { count = fifo_size; } else { } hscx_empty_fifo___0(bcs, count); count = bcs->hw.hscx.rcvidx + -1; if (count > 0) { if ((cs->debug & 32) != 0) { debugl1(cs, (char *)"HX Frame %d", count); } else { } skb = dev_alloc_skb((unsigned int )count); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { printk("\fHSCX: receive out of memory\n"); } else { __len = (size_t )count; tmp___4 = skb_put(skb, (unsigned int )count); __ret = memcpy((void *)tmp___4, (void const *)bcs->hw.hscx.rcvbuf, __len); skb_queue_tail(& bcs->rqueue, skb); } } else { } } bcs->hw.hscx.rcvidx = 0; test_and_set_bit(0, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } if (((int )val & 64) != 0) { hscx_empty_fifo___0(bcs, fifo_size); if (bcs->mode == 1) { skb = dev_alloc_skb((unsigned int )fifo_size); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { printk("\fHiSax: receive out of memory\n"); } else { __len___0 = (size_t )fifo_size; tmp___6 = skb_put(skb, (unsigned int )fifo_size); __ret___0 = memcpy((void *)tmp___6, (void const *)bcs->hw.hscx.rcvbuf, __len___0); skb_queue_tail(& bcs->rqueue, skb); } bcs->hw.hscx.rcvidx = 0; test_and_set_bit(0, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } } else { } if (((int )val & 16) != 0) { if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { if ((bcs->tx_skb)->len != 0U) { hscx_fill_fifo___0(bcs); return; } else { tmp___8 = constant_test_bit(1U, (unsigned long const volatile *)(& (bcs->st)->lli.flag)); if (tmp___8 != 0 && (unsigned int )*((unsigned char *)bcs->tx_skb + 125UL) != 7U) { tmp___7 = spinlock_check(& bcs->aclock); flags = _raw_spin_lock_irqsave(tmp___7); bcs->ackcnt = bcs->ackcnt + bcs->hw.hscx.count; spin_unlock_irqrestore(& bcs->aclock, flags); test_and_set_bit(2, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } dev_kfree_skb_irq(bcs->tx_skb); bcs->hw.hscx.count = 0; bcs->tx_skb = 0; } } else { } tmp___9 = skb_dequeue(& bcs->squeue); bcs->tx_skb = tmp___9; if ((unsigned long )tmp___9 != (unsigned long )((struct sk_buff *)0)) { bcs->hw.hscx.count = 0; test_and_set_bit(3, (unsigned long volatile *)(& bcs->Flag)); hscx_fill_fifo___0(bcs); } else { test_and_clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); test_and_set_bit(1, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } } else { } return; } } static void hscx_int_main___0(struct IsdnCardState *cs , u_char val ) { u_char exval ; struct BCState *bcs ; { if ((int )val & 1) { bcs = (struct BCState *)(& cs->bcs) + 1UL; exval = readhscx(cs->hw.teles0.membase, 1, 36); if (((int )exval & 64) != 0) { if (bcs->mode == 1) { hscx_fill_fifo___0(bcs); } else { bcs->err_tx = bcs->err_tx + 1; if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { skb_push(bcs->tx_skb, (unsigned int )bcs->hw.hscx.count); bcs->tx_cnt = bcs->tx_cnt + bcs->hw.hscx.count; bcs->hw.hscx.count = 0; } else { } WriteHSCXCMDR___0(cs, bcs->hw.hscx.hscx, 1); if (cs->debug & 1) { debugl1(cs, (char *)"HSCX B EXIR %x Lost TX", (int )exval); } else { } } } else if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HSCX B EXIR %x", (int )exval); } else { } } else { } if (((int )val & 248) != 0) { if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HSCX B interrupt %x", (int )val); } else { } hscx_interrupt___0(cs, (int )val, 1); } else { } if (((int )val & 2) != 0) { bcs = (struct BCState *)(& cs->bcs); exval = readhscx(cs->hw.teles0.membase, 0, 36); if (((int )exval & 64) != 0) { if (bcs->mode == 1) { hscx_fill_fifo___0(bcs); } else { bcs->err_tx = bcs->err_tx + 1; if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { skb_push(bcs->tx_skb, (unsigned int )bcs->hw.hscx.count); bcs->tx_cnt = bcs->tx_cnt + bcs->hw.hscx.count; bcs->hw.hscx.count = 0; } else { } WriteHSCXCMDR___0(cs, bcs->hw.hscx.hscx, 1); if (cs->debug & 1) { debugl1(cs, (char *)"HSCX A EXIR %x Lost TX", (int )exval); } else { } } } else if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HSCX A EXIR %x", (int )exval); } else { } } else { } if (((int )val & 4) != 0) { exval = readhscx(cs->hw.teles0.membase, 0, 32); if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HSCX A interrupt %x", (int )exval); } else { } hscx_interrupt___0(cs, (int )exval, 0); } else { } return; } } static irqreturn_t telespci_interrupt(int intno , void *dev_id ) { struct IsdnCardState *cs ; u_char hval ; u_char ival ; u_long flags ; raw_spinlock_t *tmp ; { cs = (struct IsdnCardState *)dev_id; tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); hval = readhscx(cs->hw.teles0.membase, 1, 32); if ((unsigned int )hval != 0U) { hscx_int_main___0(cs, (int )hval); } else { } ival = readisac(cs->hw.teles0.membase, 32); if ((unsigned int )((int )hval | (int )ival) == 0U) { spin_unlock_irqrestore(& cs->lock, flags); return (0); } else { } if ((unsigned int )ival != 0U) { isac_interrupt(cs, (int )ival); } else { } writel(1879048192U, (void volatile *)cs->hw.teles0.membase + 60U); writehscx(cs->hw.teles0.membase, 0, 32, 255); writehscx(cs->hw.teles0.membase, 1, 32, 255); writeisac(cs->hw.teles0.membase, 32, 255); writeisac(cs->hw.teles0.membase, 32, 0); writehscx(cs->hw.teles0.membase, 0, 32, 0); writehscx(cs->hw.teles0.membase, 1, 32, 0); spin_unlock_irqrestore(& cs->lock, flags); return (1); } } static void release_io_telespci(struct IsdnCardState *cs ) { { iounmap((void volatile *)cs->hw.teles0.membase); return; } } static int TelesPCI_card_msg(struct IsdnCardState *cs , int mt , void *arg ) { u_long flags ; raw_spinlock_t *tmp ; { switch (mt) { case 240: ; return (0); case 243: release_io_telespci(cs); return (0); case 242: tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); inithscxisac(cs, 3); spin_unlock_irqrestore(& cs->lock, flags); return (0); case 244: ; return (0); } return (0); } } static struct pci_dev *dev_tel = 0; int setup_telespci(struct IsdnCard *card ) { struct IsdnCardState *cs ; char tmp[64U] ; char *tmp___0 ; int tmp___1 ; int tmp___2 ; { cs = card->cs; strcpy((char *)(& tmp), telespci_revision); tmp___0 = HiSax_getrev((char const *)(& tmp)); printk("\016HiSax: Teles/PCI driver Rev. %s\n", tmp___0); if ((unsigned int )cs->typ != 21U) { return (0); } else { } dev_tel = hisax_find_pci_device(4574U, 24864U, dev_tel); if ((unsigned long )dev_tel != (unsigned long )((struct pci_dev *)0)) { tmp___1 = pci_enable_device(dev_tel); if (tmp___1 != 0) { return (0); } else { } cs->irq = dev_tel->irq; if (cs->irq == 0U) { printk("\fTeles: No IRQ for PCI card found\n"); return (0); } else { } cs->hw.teles0.membase = ioremap(dev_tel->resource[0].start, 4096UL); printk("\016Found: Zoran, base-address: 0x%llx, irq: 0x%x\n", dev_tel->resource[0].start, dev_tel->irq); } else { printk("\fTelesPCI: No PCI card found\n"); return (0); } writel(0U, (void volatile *)cs->hw.teles0.membase + 40U); writel(16777216U, (void volatile *)cs->hw.teles0.membase + 40U); writel(16777216U, (void volatile *)cs->hw.teles0.membase + 40U); writel(2080374783U, (void volatile *)cs->hw.teles0.membase + 44U); writel(1879048192U, (void volatile *)cs->hw.teles0.membase + 60U); writel(1627389952U, (void volatile *)cs->hw.teles0.membase + 64U); printk("\016HiSax: Teles PCI config irq:%d mem:%p\n", cs->irq, cs->hw.teles0.membase); setup_isac(cs); cs->readisac = & ReadISAC___0; cs->writeisac = & WriteISAC___0; cs->readisacfifo = & ReadISACfifo___0; cs->writeisacfifo = & WriteISACfifo___0; cs->BC_Read_Reg = & ReadHSCX___0; cs->BC_Write_Reg = & WriteHSCX___0; cs->BC_Send_Data = & hscx_fill_fifo___0; cs->cardmsg = & TelesPCI_card_msg; cs->irq_func = & telespci_interrupt; cs->irq_flags = cs->irq_flags | 128UL; ISACVersion(cs, (char *)"TelesPCI:"); tmp___2 = HscxVersion(cs, (char *)"TelesPCI:"); if (tmp___2 != 0) { printk("\fTelesPCI: wrong HSCX versions check IO/MEM addresses\n"); release_io_telespci(cs); return (0); } else { } return (1); } } void ldv_mutex_lock_225(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_lock(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_226(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_lock(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_227(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } int ldv_mutex_trylock_228(struct mutex *ldv_func_arg1 ) { ldv_func_ret_type___2 ldv_func_res ; int tmp ; int tmp___0 ; { tmp = mutex_trylock(ldv_func_arg1); ldv_func_res = tmp; tmp___0 = ldv_mutex_trylock_mutex(ldv_func_arg1); return (tmp___0); return (ldv_func_res); } } void ldv_mutex_unlock_229(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_230(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_cred_guard_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_231(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_cred_guard_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } extern struct pv_cpu_ops pv_cpu_ops ; __inline static void slow_down_io(void) { { (*(pv_cpu_ops.io_delay))(); return; } } int ldv_mutex_trylock_242(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_240(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_243(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_245(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_239(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_241(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_244(struct mutex *ldv_func_arg1 ) ; __inline static void outb_p(unsigned char value , int port ) { { outb((int )value, port); slow_down_io(); return; } } __inline static unsigned char inb_p(int port ) { unsigned char value ; unsigned char tmp ; { tmp = inb(port); value = tmp; slow_down_io(); return (value); } } static char const *s0box_revision = "$Revision: 2.6.2.4 $"; __inline static void writereg___0(unsigned int padr , int addr , u_char off , u_char val ) { { outb_p(28, (int )(padr + 2U)); outb_p(20, (int )(padr + 2U)); outb_p(((int )((unsigned char )addr) + (int )off) & 127, (int )padr); outb_p(22, (int )(padr + 2U)); outb_p((int )val, (int )padr); outb_p(23, (int )(padr + 2U)); outb_p(20, (int )(padr + 2U)); outb_p(28, (int )(padr + 2U)); return; } } static u_char nibtab[24U] = { 1U, 9U, 5U, 13U, 3U, 11U, 7U, 15U, 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U, 8U, 4U, 12U, 2U, 10U, 6U, 14U}; __inline static u_char readreg___0(unsigned int padr , int addr , u_char off ) { register u_char n1 ; register u_char n2 ; unsigned char tmp ; unsigned char tmp___0 ; { outb_p(28, (int )(padr + 2U)); outb_p(20, (int )(padr + 2U)); outb_p((int )((unsigned char )((int )((signed char )((int )((unsigned char )addr) + (int )off)) | -128)), (int )padr); outb_p(22, (int )(padr + 2U)); outb_p(23, (int )(padr + 2U)); tmp = inb_p((int )(padr + 1U)); n1 = (unsigned int )((u_char )((int )tmp >> 3)) & 23U; outb_p(22, (int )(padr + 2U)); tmp___0 = inb_p((int )(padr + 1U)); n2 = (unsigned int )((u_char )((int )tmp___0 >> 3)) & 23U; outb_p(20, (int )(padr + 2U)); outb_p(28, (int )(padr + 2U)); return ((u_char )((int )((signed char )nibtab[(int )n1]) | (int )((signed char )((int )nibtab[(int )n2] << 4)))); } } __inline static void read_fifo___0(unsigned int padr , int adr , u_char *data , int size ) { int i ; register u_char n1 ; register u_char n2 ; unsigned char tmp ; unsigned char tmp___0 ; u_char *tmp___1 ; { outb_p(28, (int )(padr + 2U)); outb_p(20, (int )(padr + 2U)); outb_p((int )((unsigned char )((int )((signed char )adr) | -128)), (int )padr); outb_p(22, (int )(padr + 2U)); i = 0; goto ldv_41013; ldv_41012: outb_p(23, (int )(padr + 2U)); tmp = inb_p((int )(padr + 1U)); n1 = (unsigned int )((u_char )((int )tmp >> 3)) & 23U; outb_p(22, (int )(padr + 2U)); tmp___0 = inb_p((int )(padr + 1U)); n2 = (unsigned int )((u_char )((int )tmp___0 >> 3)) & 23U; tmp___1 = data; data = data + 1; *tmp___1 = (u_char )((int )((signed char )nibtab[(int )n1]) | (int )((signed char )((int )nibtab[(int )n2] << 4))); i = i + 1; ldv_41013: ; if (i < size) { goto ldv_41012; } else { } outb_p(20, (int )(padr + 2U)); outb_p(28, (int )(padr + 2U)); return; } } __inline static void write_fifo___0(unsigned int padr , int adr , u_char *data , int size ) { int i ; u_char *tmp ; { outb_p(28, (int )(padr + 2U)); outb_p(20, (int )(padr + 2U)); outb_p((int )((unsigned char )adr) & 127, (int )padr); i = 0; goto ldv_41023; ldv_41022: outb_p(22, (int )(padr + 2U)); tmp = data; data = data + 1; outb_p((int )*tmp, (int )padr); outb_p(23, (int )(padr + 2U)); i = i + 1; ldv_41023: ; if (i < size) { goto ldv_41022; } else { } outb_p(20, (int )(padr + 2U)); outb_p(28, (int )(padr + 2U)); return; } } static u_char ReadISAC___1(struct IsdnCardState *cs , u_char offset ) { u_char tmp ; { tmp = readreg___0(cs->hw.teles3.cfg_reg, cs->hw.teles3.isac, (int )offset); return (tmp); } } static void WriteISAC___1(struct IsdnCardState *cs , u_char offset , u_char value ) { { writereg___0(cs->hw.teles3.cfg_reg, cs->hw.teles3.isac, (int )offset, (int )value); return; } } static void ReadISACfifo___1(struct IsdnCardState *cs , u_char *data , int size ) { { read_fifo___0(cs->hw.teles3.cfg_reg, cs->hw.teles3.isacfifo, data, size); return; } } static void WriteISACfifo___1(struct IsdnCardState *cs , u_char *data , int size ) { { write_fifo___0(cs->hw.teles3.cfg_reg, cs->hw.teles3.isacfifo, data, size); return; } } static u_char ReadHSCX___1(struct IsdnCardState *cs , int hscx , u_char offset ) { u_char tmp ; { tmp = readreg___0(cs->hw.teles3.cfg_reg, cs->hw.teles3.hscx[hscx], (int )offset); return (tmp); } } static void WriteHSCX___1(struct IsdnCardState *cs , int hscx , u_char offset , u_char value ) { { writereg___0(cs->hw.teles3.cfg_reg, cs->hw.teles3.hscx[hscx], (int )offset, (int )value); return; } } __inline static void waitforCEC___1(struct IsdnCardState *cs , int hscx ) { int to ; u_char tmp ; { to = 50; goto ldv_41061; ldv_41060: __const_udelay(4295UL); to = to - 1; ldv_41061: tmp = readreg___0(cs->hw.teles3.cfg_reg, cs->hw.teles3.hscx[hscx], 33); if (((int )tmp & 4) != 0 && to != 0) { goto ldv_41060; } else { } if (to == 0) { printk("\fHiSax: waitforCEC timeout\n"); } else { } return; } } __inline static void waitforXFW___1(struct IsdnCardState *cs , int hscx ) { int to ; u_char tmp ; { to = 50; goto ldv_41069; ldv_41068: __const_udelay(4295UL); to = to - 1; ldv_41069: tmp = readreg___0(cs->hw.teles3.cfg_reg, cs->hw.teles3.hscx[hscx], 33); if (((int )tmp & 68) != 64 && to != 0) { goto ldv_41068; } else { } if (to == 0) { printk("\fHiSax: waitforXFW timeout\n"); } else { } return; } } __inline static void WriteHSCXCMDR___1(struct IsdnCardState *cs , int hscx , u_char data ) { { waitforCEC___1(cs, hscx); writereg___0(cs->hw.teles3.cfg_reg, cs->hw.teles3.hscx[hscx], 33, (int )data); return; } } static void hscx_empty_fifo___1(struct BCState *bcs , int count ) { u_char *ptr ; struct IsdnCardState *cs ; char *t ; int tmp ; { cs = bcs->cs; if ((cs->debug & 16) != 0 && (cs->debug & 32) == 0) { debugl1(cs, (char *)"hscx_empty_fifo"); } else { } if (bcs->hw.hscx.rcvidx + count > 4096) { if (cs->debug & 1) { debugl1(cs, (char *)"hscx_empty_fifo: incoming packet too large"); } else { } WriteHSCXCMDR___1(cs, bcs->hw.hscx.hscx, 128); bcs->hw.hscx.rcvidx = 0; return; } else { } ptr = bcs->hw.hscx.rcvbuf + (unsigned long )bcs->hw.hscx.rcvidx; bcs->hw.hscx.rcvidx = bcs->hw.hscx.rcvidx + count; read_fifo___0(cs->hw.teles3.cfg_reg, cs->hw.teles3.hscxfifo[bcs->hw.hscx.hscx], ptr, count); WriteHSCXCMDR___1(cs, bcs->hw.hscx.hscx, 128); if ((cs->debug & 32) != 0) { t = (char *)bcs->blog; tmp = sprintf(t, "hscx_empty_fifo %c cnt %d", bcs->hw.hscx.hscx != 0 ? 66 : 65, count); t = t + (unsigned long )tmp; QuickHex(t, ptr, count); debugl1(cs, (char *)bcs->blog); } else { } return; } } static void hscx_fill_fifo___1(struct BCState *bcs ) { struct IsdnCardState *cs ; int more ; int count ; int fifo_size ; int tmp ; u_char *ptr ; char *t ; int tmp___0 ; { cs = bcs->cs; tmp = constant_test_bit(1U, (unsigned long const volatile *)(& cs->HW_Flags)); fifo_size = tmp != 0 ? 64 : 32; if ((cs->debug & 16) != 0 && (cs->debug & 32) == 0) { debugl1(cs, (char *)"hscx_fill_fifo"); } else { } if ((unsigned long )bcs->tx_skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } if ((bcs->tx_skb)->len == 0U) { return; } else { } more = bcs->mode == 1; if ((bcs->tx_skb)->len > (unsigned int )fifo_size) { more = 1; count = fifo_size; } else { count = (int )(bcs->tx_skb)->len; } waitforXFW___1(cs, bcs->hw.hscx.hscx); ptr = (bcs->tx_skb)->data; skb_pull(bcs->tx_skb, (unsigned int )count); bcs->tx_cnt = bcs->tx_cnt - count; bcs->hw.hscx.count = bcs->hw.hscx.count + count; write_fifo___0(cs->hw.teles3.cfg_reg, cs->hw.teles3.hscxfifo[bcs->hw.hscx.hscx], ptr, count); WriteHSCXCMDR___1(cs, bcs->hw.hscx.hscx, more != 0 ? 8 : 10); if ((cs->debug & 32) != 0) { t = (char *)bcs->blog; tmp___0 = sprintf(t, "hscx_fill_fifo %c cnt %d", bcs->hw.hscx.hscx != 0 ? 66 : 65, count); t = t + (unsigned long )tmp___0; QuickHex(t, ptr, count); debugl1(cs, (char *)bcs->blog); } else { } return; } } static void hscx_interrupt___1(struct IsdnCardState *cs , u_char val , u_char hscx ) { u_char r ; struct BCState *bcs ; struct sk_buff *skb ; int fifo_size ; int tmp ; int count ; int tmp___0 ; u_char tmp___1 ; int tmp___2 ; size_t __len ; void *__ret ; unsigned char *tmp___4 ; size_t __len___0 ; void *__ret___0 ; unsigned char *tmp___6 ; u_long flags ; raw_spinlock_t *tmp___7 ; int tmp___8 ; struct sk_buff *tmp___9 ; { bcs = (struct BCState *)(& cs->bcs) + (unsigned long )hscx; tmp = constant_test_bit(1U, (unsigned long const volatile *)(& cs->HW_Flags)); fifo_size = tmp != 0 ? 64 : 32; tmp___0 = constant_test_bit(1U, (unsigned long const volatile *)(& bcs->Flag)); if (tmp___0 == 0) { return; } else { } if ((int )((signed char )val) < 0) { r = readreg___0(cs->hw.teles3.cfg_reg, cs->hw.teles3.hscx[(int )hscx], 39); if (((int )r & 240) != 160) { if ((int )((signed char )r) >= 0) { if (cs->debug & 1) { debugl1(cs, (char *)"HSCX invalid frame"); } else { } bcs->err_inv = bcs->err_inv + 1; } else { } if (((int )r & 64) != 0 && bcs->mode != 0) { if (cs->debug & 1) { debugl1(cs, (char *)"HSCX RDO mode=%d", bcs->mode); } else { } bcs->err_rdo = bcs->err_rdo + 1; } else { } if (((int )r & 32) == 0) { if (cs->debug & 1) { debugl1(cs, (char *)"HSCX CRC error"); } else { } bcs->err_crc = bcs->err_crc + 1; } else { } WriteHSCXCMDR___1(cs, (int )hscx, 128); } else { tmp___1 = readreg___0(cs->hw.teles3.cfg_reg, cs->hw.teles3.hscx[(int )hscx], 37); tmp___2 = constant_test_bit(1U, (unsigned long const volatile *)(& cs->HW_Flags)); count = (int )tmp___1 & (tmp___2 != 0 ? 63 : 31); if (count == 0) { count = fifo_size; } else { } hscx_empty_fifo___1(bcs, count); count = bcs->hw.hscx.rcvidx + -1; if (count > 0) { if ((cs->debug & 32) != 0) { debugl1(cs, (char *)"HX Frame %d", count); } else { } skb = dev_alloc_skb((unsigned int )count); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { printk("\fHSCX: receive out of memory\n"); } else { __len = (size_t )count; tmp___4 = skb_put(skb, (unsigned int )count); __ret = memcpy((void *)tmp___4, (void const *)bcs->hw.hscx.rcvbuf, __len); skb_queue_tail(& bcs->rqueue, skb); } } else { } } bcs->hw.hscx.rcvidx = 0; test_and_set_bit(0, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } if (((int )val & 64) != 0) { hscx_empty_fifo___1(bcs, fifo_size); if (bcs->mode == 1) { skb = dev_alloc_skb((unsigned int )fifo_size); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { printk("\fHiSax: receive out of memory\n"); } else { __len___0 = (size_t )fifo_size; tmp___6 = skb_put(skb, (unsigned int )fifo_size); __ret___0 = memcpy((void *)tmp___6, (void const *)bcs->hw.hscx.rcvbuf, __len___0); skb_queue_tail(& bcs->rqueue, skb); } bcs->hw.hscx.rcvidx = 0; test_and_set_bit(0, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } } else { } if (((int )val & 16) != 0) { if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { if ((bcs->tx_skb)->len != 0U) { hscx_fill_fifo___1(bcs); return; } else { tmp___8 = constant_test_bit(1U, (unsigned long const volatile *)(& (bcs->st)->lli.flag)); if (tmp___8 != 0 && (unsigned int )*((unsigned char *)bcs->tx_skb + 125UL) != 7U) { tmp___7 = spinlock_check(& bcs->aclock); flags = _raw_spin_lock_irqsave(tmp___7); bcs->ackcnt = bcs->ackcnt + bcs->hw.hscx.count; spin_unlock_irqrestore(& bcs->aclock, flags); test_and_set_bit(2, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } dev_kfree_skb_irq(bcs->tx_skb); bcs->hw.hscx.count = 0; bcs->tx_skb = 0; } } else { } tmp___9 = skb_dequeue(& bcs->squeue); bcs->tx_skb = tmp___9; if ((unsigned long )tmp___9 != (unsigned long )((struct sk_buff *)0)) { bcs->hw.hscx.count = 0; test_and_set_bit(3, (unsigned long volatile *)(& bcs->Flag)); hscx_fill_fifo___1(bcs); } else { test_and_clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); test_and_set_bit(1, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } } else { } return; } } static void hscx_int_main___1(struct IsdnCardState *cs , u_char val ) { u_char exval ; struct BCState *bcs ; { if ((int )val & 1) { bcs = (struct BCState *)(& cs->bcs) + 1UL; exval = readreg___0(cs->hw.teles3.cfg_reg, cs->hw.teles3.hscx[1], 36); if (((int )exval & 64) != 0) { if (bcs->mode == 1) { hscx_fill_fifo___1(bcs); } else { bcs->err_tx = bcs->err_tx + 1; if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { skb_push(bcs->tx_skb, (unsigned int )bcs->hw.hscx.count); bcs->tx_cnt = bcs->tx_cnt + bcs->hw.hscx.count; bcs->hw.hscx.count = 0; } else { } WriteHSCXCMDR___1(cs, bcs->hw.hscx.hscx, 1); if (cs->debug & 1) { debugl1(cs, (char *)"HSCX B EXIR %x Lost TX", (int )exval); } else { } } } else if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HSCX B EXIR %x", (int )exval); } else { } } else { } if (((int )val & 248) != 0) { if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HSCX B interrupt %x", (int )val); } else { } hscx_interrupt___1(cs, (int )val, 1); } else { } if (((int )val & 2) != 0) { bcs = (struct BCState *)(& cs->bcs); exval = readreg___0(cs->hw.teles3.cfg_reg, cs->hw.teles3.hscx[0], 36); if (((int )exval & 64) != 0) { if (bcs->mode == 1) { hscx_fill_fifo___1(bcs); } else { bcs->err_tx = bcs->err_tx + 1; if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { skb_push(bcs->tx_skb, (unsigned int )bcs->hw.hscx.count); bcs->tx_cnt = bcs->tx_cnt + bcs->hw.hscx.count; bcs->hw.hscx.count = 0; } else { } WriteHSCXCMDR___1(cs, bcs->hw.hscx.hscx, 1); if (cs->debug & 1) { debugl1(cs, (char *)"HSCX A EXIR %x Lost TX", (int )exval); } else { } } } else if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HSCX A EXIR %x", (int )exval); } else { } } else { } if (((int )val & 4) != 0) { exval = readreg___0(cs->hw.teles3.cfg_reg, cs->hw.teles3.hscx[0], 32); if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HSCX A interrupt %x", (int )exval); } else { } hscx_interrupt___1(cs, (int )exval, 0); } else { } return; } } static irqreturn_t s0box_interrupt(int intno , void *dev_id ) { struct IsdnCardState *cs ; u_char val ; u_long flags ; int count ; raw_spinlock_t *tmp ; { cs = (struct IsdnCardState *)dev_id; count = 0; tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); val = readreg___0(cs->hw.teles3.cfg_reg, cs->hw.teles3.hscx[1], 32); Start_HSCX: ; if ((unsigned int )val != 0U) { hscx_int_main___1(cs, (int )val); } else { } val = readreg___0(cs->hw.teles3.cfg_reg, cs->hw.teles3.isac, 32); Start_ISAC: ; if ((unsigned int )val != 0U) { isac_interrupt(cs, (int )val); } else { } count = count + 1; val = readreg___0(cs->hw.teles3.cfg_reg, cs->hw.teles3.hscx[1], 32); if ((unsigned int )val != 0U && count <= 4) { if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HSCX IntStat after IntRoutine"); } else { } goto Start_HSCX; } else { } val = readreg___0(cs->hw.teles3.cfg_reg, cs->hw.teles3.isac, 32); if ((unsigned int )val != 0U && count <= 4) { if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"ISAC IntStat after IntRoutine"); } else { } goto Start_ISAC; } else { } if (count > 4) { printk("\fS0Box: more than %d loops in s0box_interrupt\n", count); } else { } writereg___0(cs->hw.teles3.cfg_reg, cs->hw.teles3.hscx[0], 32, 255); writereg___0(cs->hw.teles3.cfg_reg, cs->hw.teles3.hscx[1], 32, 255); writereg___0(cs->hw.teles3.cfg_reg, cs->hw.teles3.isac, 32, 255); writereg___0(cs->hw.teles3.cfg_reg, cs->hw.teles3.isac, 32, 0); writereg___0(cs->hw.teles3.cfg_reg, cs->hw.teles3.hscx[0], 32, 0); writereg___0(cs->hw.teles3.cfg_reg, cs->hw.teles3.hscx[1], 32, 0); spin_unlock_irqrestore(& cs->lock, flags); return (1); } } static void release_io_s0box(struct IsdnCardState *cs ) { { __release_region(& ioport_resource, (resource_size_t )cs->hw.teles3.cfg_reg, 8ULL); return; } } static int S0Box_card_msg(struct IsdnCardState *cs , int mt , void *arg ) { u_long flags ; raw_spinlock_t *tmp ; { switch (mt) { case 240: ; goto ldv_41141; case 243: release_io_s0box(cs); goto ldv_41141; case 242: tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); inithscxisac(cs, 3); spin_unlock_irqrestore(& cs->lock, flags); goto ldv_41141; case 244: ; goto ldv_41141; } ldv_41141: ; return (0); } } int setup_s0box(struct IsdnCard *card ) { struct IsdnCardState *cs ; char tmp[64U] ; char *tmp___0 ; struct resource *tmp___1 ; int tmp___2 ; { cs = card->cs; strcpy((char *)(& tmp), s0box_revision); tmp___0 = HiSax_getrev((char const *)(& tmp)); printk("\016HiSax: S0Box IO driver Rev. %s\n", tmp___0); if ((unsigned int )cs->typ != 25U) { return (0); } else { } cs->hw.teles3.cfg_reg = (unsigned int )card->para[1]; cs->hw.teles3.hscx[0] = -32; cs->hw.teles3.hscx[1] = 0; cs->hw.teles3.isac = 32; cs->hw.teles3.isacfifo = cs->hw.teles3.isac + 62; cs->hw.teles3.hscxfifo[0] = cs->hw.teles3.hscx[0] + 62; cs->hw.teles3.hscxfifo[1] = cs->hw.teles3.hscx[1] + 62; cs->irq = (u_int )card->para[0]; tmp___1 = __request_region(& ioport_resource, (resource_size_t )cs->hw.teles3.cfg_reg, 8ULL, "S0Box parallel I/O", 0); if ((unsigned long )tmp___1 == (unsigned long )((struct resource *)0)) { printk("\fHiSax: S0Box ports %x-%x already in use\n", cs->hw.teles3.cfg_reg, cs->hw.teles3.cfg_reg + 7U); return (0); } else { } printk("\016HiSax: S0Box config irq:%d isac:0x%x cfg:0x%x\n", cs->irq, cs->hw.teles3.isac, cs->hw.teles3.cfg_reg); printk("\016HiSax: hscx A:0x%x hscx B:0x%x\n", cs->hw.teles3.hscx[0], cs->hw.teles3.hscx[1]); setup_isac(cs); cs->readisac = & ReadISAC___1; cs->writeisac = & WriteISAC___1; cs->readisacfifo = & ReadISACfifo___1; cs->writeisacfifo = & WriteISACfifo___1; cs->BC_Read_Reg = & ReadHSCX___1; cs->BC_Write_Reg = & WriteHSCX___1; cs->BC_Send_Data = & hscx_fill_fifo___1; cs->cardmsg = & S0Box_card_msg; cs->irq_func = & s0box_interrupt; ISACVersion(cs, (char *)"S0Box:"); tmp___2 = HscxVersion(cs, (char *)"S0Box:"); if (tmp___2 != 0) { printk("\fS0Box: wrong HSCX versions check IO address\n"); release_io_s0box(cs); return (0); } else { } return (1); } } void ldv_mutex_lock_239(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_lock(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_240(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_lock(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_241(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } int ldv_mutex_trylock_242(struct mutex *ldv_func_arg1 ) { ldv_func_ret_type___2 ldv_func_res ; int tmp ; int tmp___0 ; { tmp = mutex_trylock(ldv_func_arg1); ldv_func_res = tmp; tmp___0 = ldv_mutex_trylock_mutex(ldv_func_arg1); return (tmp___0); return (ldv_func_res); } } void ldv_mutex_unlock_243(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_244(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_cred_guard_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_245(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_cred_guard_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } int ldv_mutex_trylock_256(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_254(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_257(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_259(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_253(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_255(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_258(struct mutex *ldv_func_arg1 ) ; static char const *avm_revision = "$Revision: 2.9.2.5 $"; __inline static u_char ReadISAC___2(struct IsdnCardState *cs , u_char offset ) { u_char ret ; { offset = (unsigned int )offset + 224U; outb((int )((unsigned int )offset + 32U), (int )(cs->hw.avm.cfg_reg + 2U)); ret = inb((int )(cs->hw.avm.cfg_reg + 3U)); return (ret); } } __inline static void WriteISAC___2(struct IsdnCardState *cs , u_char offset , u_char value ) { { offset = (unsigned int )offset + 224U; outb((int )((unsigned int )offset + 32U), (int )(cs->hw.avm.cfg_reg + 2U)); outb((int )value, (int )(cs->hw.avm.cfg_reg + 3U)); return; } } __inline static void ReadISACfifo___2(struct IsdnCardState *cs , u_char *data , int size ) { { outb(0, (int )(cs->hw.avm.cfg_reg + 2U)); insb((int )(cs->hw.avm.cfg_reg + 3U), (void *)data, (unsigned long )size); return; } } __inline static void WriteISACfifo___2(struct IsdnCardState *cs , u_char *data , int size ) { { outb(0, (int )(cs->hw.avm.cfg_reg + 2U)); outsb((int )(cs->hw.avm.cfg_reg + 3U), (void const *)data, (unsigned long )size); return; } } __inline static u_char ReadHSCX___2(struct IsdnCardState *cs , int hscx , u_char offset ) { u_char ret ; { offset = (unsigned int )offset + 224U; outb((int )(((unsigned int )((unsigned char )hscx) * 64U + (unsigned int )offset) + 160U), (int )(cs->hw.avm.cfg_reg + 2U)); ret = inb((int )(cs->hw.avm.cfg_reg + 3U)); return (ret); } } __inline static void WriteHSCX___2(struct IsdnCardState *cs , int hscx , u_char offset , u_char value ) { { offset = (unsigned int )offset + 224U; outb((int )(((unsigned int )((unsigned char )hscx) * 64U + (unsigned int )offset) + 160U), (int )(cs->hw.avm.cfg_reg + 2U)); outb((int )value, (int )(cs->hw.avm.cfg_reg + 3U)); return; } } __inline static void ReadHSCXfifo(struct IsdnCardState *cs , int hscx , u_char *data , int size ) { { outb((int )((unsigned int )((unsigned char )(hscx + 2)) * 64U), (int )(cs->hw.avm.cfg_reg + 2U)); insb((int )(cs->hw.avm.cfg_reg + 3U), (void *)data, (unsigned long )size); return; } } __inline static void WriteHSCXfifo(struct IsdnCardState *cs , int hscx , u_char *data , int size ) { { outb((int )((unsigned int )((unsigned char )(hscx + 2)) * 64U), (int )(cs->hw.avm.cfg_reg + 2U)); outsb((int )(cs->hw.avm.cfg_reg + 3U), (void const *)data, (unsigned long )size); return; } } __inline static void waitforCEC___2(struct IsdnCardState *cs , int hscx ) { int to ; u_char tmp ; { to = 50; goto ldv_41039; ldv_41038: __const_udelay(4295UL); to = to - 1; ldv_41039: tmp = ReadHSCX___2(cs, hscx, 33); if (((int )tmp & 4) != 0 && to != 0) { goto ldv_41038; } else { } if (to == 0) { printk("\fHiSax: waitforCEC timeout\n"); } else { } return; } } __inline static void waitforXFW___2(struct IsdnCardState *cs , int hscx ) { int to ; u_char tmp ; { to = 50; goto ldv_41047; ldv_41046: __const_udelay(4295UL); to = to - 1; ldv_41047: tmp = ReadHSCX___2(cs, hscx, 33); if (((int )tmp & 68) != 64 && to != 0) { goto ldv_41046; } else { } if (to == 0) { printk("\fHiSax: waitforXFW timeout\n"); } else { } return; } } __inline static void WriteHSCXCMDR___2(struct IsdnCardState *cs , int hscx , u_char data ) { { waitforCEC___2(cs, hscx); WriteHSCX___2(cs, hscx, 33, (int )data); return; } } static void hscx_empty_fifo___2(struct BCState *bcs , int count ) { u_char *ptr ; struct IsdnCardState *cs ; char *t ; int tmp ; { cs = bcs->cs; if ((cs->debug & 16) != 0 && (cs->debug & 32) == 0) { debugl1(cs, (char *)"hscx_empty_fifo"); } else { } if (bcs->hw.hscx.rcvidx + count > 4096) { if (cs->debug & 1) { debugl1(cs, (char *)"hscx_empty_fifo: incoming packet too large"); } else { } WriteHSCXCMDR___2(cs, bcs->hw.hscx.hscx, 128); bcs->hw.hscx.rcvidx = 0; return; } else { } ptr = bcs->hw.hscx.rcvbuf + (unsigned long )bcs->hw.hscx.rcvidx; bcs->hw.hscx.rcvidx = bcs->hw.hscx.rcvidx + count; ReadHSCXfifo(cs, bcs->hw.hscx.hscx, ptr, count); WriteHSCXCMDR___2(cs, bcs->hw.hscx.hscx, 128); if ((cs->debug & 32) != 0) { t = (char *)bcs->blog; tmp = sprintf(t, "hscx_empty_fifo %c cnt %d", bcs->hw.hscx.hscx != 0 ? 66 : 65, count); t = t + (unsigned long )tmp; QuickHex(t, ptr, count); debugl1(cs, (char *)bcs->blog); } else { } return; } } static void hscx_fill_fifo___2(struct BCState *bcs ) { struct IsdnCardState *cs ; int more ; int count ; int fifo_size ; int tmp ; u_char *ptr ; char *t ; int tmp___0 ; { cs = bcs->cs; tmp = constant_test_bit(1U, (unsigned long const volatile *)(& cs->HW_Flags)); fifo_size = tmp != 0 ? 64 : 32; if ((cs->debug & 16) != 0 && (cs->debug & 32) == 0) { debugl1(cs, (char *)"hscx_fill_fifo"); } else { } if ((unsigned long )bcs->tx_skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } if ((bcs->tx_skb)->len == 0U) { return; } else { } more = bcs->mode == 1; if ((bcs->tx_skb)->len > (unsigned int )fifo_size) { more = 1; count = fifo_size; } else { count = (int )(bcs->tx_skb)->len; } waitforXFW___2(cs, bcs->hw.hscx.hscx); ptr = (bcs->tx_skb)->data; skb_pull(bcs->tx_skb, (unsigned int )count); bcs->tx_cnt = bcs->tx_cnt - count; bcs->hw.hscx.count = bcs->hw.hscx.count + count; WriteHSCXfifo(cs, bcs->hw.hscx.hscx, ptr, count); WriteHSCXCMDR___2(cs, bcs->hw.hscx.hscx, more != 0 ? 8 : 10); if ((cs->debug & 32) != 0) { t = (char *)bcs->blog; tmp___0 = sprintf(t, "hscx_fill_fifo %c cnt %d", bcs->hw.hscx.hscx != 0 ? 66 : 65, count); t = t + (unsigned long )tmp___0; QuickHex(t, ptr, count); debugl1(cs, (char *)bcs->blog); } else { } return; } } static void hscx_interrupt___2(struct IsdnCardState *cs , u_char val , u_char hscx ) { u_char r ; struct BCState *bcs ; struct sk_buff *skb ; int fifo_size ; int tmp ; int count ; int tmp___0 ; u_char tmp___1 ; int tmp___2 ; size_t __len ; void *__ret ; unsigned char *tmp___4 ; size_t __len___0 ; void *__ret___0 ; unsigned char *tmp___6 ; u_long flags ; raw_spinlock_t *tmp___7 ; int tmp___8 ; struct sk_buff *tmp___9 ; { bcs = (struct BCState *)(& cs->bcs) + (unsigned long )hscx; tmp = constant_test_bit(1U, (unsigned long const volatile *)(& cs->HW_Flags)); fifo_size = tmp != 0 ? 64 : 32; tmp___0 = constant_test_bit(1U, (unsigned long const volatile *)(& bcs->Flag)); if (tmp___0 == 0) { return; } else { } if ((int )((signed char )val) < 0) { r = ReadHSCX___2(cs, (int )hscx, 39); if (((int )r & 240) != 160) { if ((int )((signed char )r) >= 0) { if (cs->debug & 1) { debugl1(cs, (char *)"HSCX invalid frame"); } else { } bcs->err_inv = bcs->err_inv + 1; } else { } if (((int )r & 64) != 0 && bcs->mode != 0) { if (cs->debug & 1) { debugl1(cs, (char *)"HSCX RDO mode=%d", bcs->mode); } else { } bcs->err_rdo = bcs->err_rdo + 1; } else { } if (((int )r & 32) == 0) { if (cs->debug & 1) { debugl1(cs, (char *)"HSCX CRC error"); } else { } bcs->err_crc = bcs->err_crc + 1; } else { } WriteHSCXCMDR___2(cs, (int )hscx, 128); } else { tmp___1 = ReadHSCX___2(cs, (int )hscx, 37); tmp___2 = constant_test_bit(1U, (unsigned long const volatile *)(& cs->HW_Flags)); count = (int )tmp___1 & (tmp___2 != 0 ? 63 : 31); if (count == 0) { count = fifo_size; } else { } hscx_empty_fifo___2(bcs, count); count = bcs->hw.hscx.rcvidx + -1; if (count > 0) { if ((cs->debug & 32) != 0) { debugl1(cs, (char *)"HX Frame %d", count); } else { } skb = dev_alloc_skb((unsigned int )count); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { printk("\fHSCX: receive out of memory\n"); } else { __len = (size_t )count; tmp___4 = skb_put(skb, (unsigned int )count); __ret = memcpy((void *)tmp___4, (void const *)bcs->hw.hscx.rcvbuf, __len); skb_queue_tail(& bcs->rqueue, skb); } } else { } } bcs->hw.hscx.rcvidx = 0; test_and_set_bit(0, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } if (((int )val & 64) != 0) { hscx_empty_fifo___2(bcs, fifo_size); if (bcs->mode == 1) { skb = dev_alloc_skb((unsigned int )fifo_size); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { printk("\fHiSax: receive out of memory\n"); } else { __len___0 = (size_t )fifo_size; tmp___6 = skb_put(skb, (unsigned int )fifo_size); __ret___0 = memcpy((void *)tmp___6, (void const *)bcs->hw.hscx.rcvbuf, __len___0); skb_queue_tail(& bcs->rqueue, skb); } bcs->hw.hscx.rcvidx = 0; test_and_set_bit(0, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } } else { } if (((int )val & 16) != 0) { if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { if ((bcs->tx_skb)->len != 0U) { hscx_fill_fifo___2(bcs); return; } else { tmp___8 = constant_test_bit(1U, (unsigned long const volatile *)(& (bcs->st)->lli.flag)); if (tmp___8 != 0 && (unsigned int )*((unsigned char *)bcs->tx_skb + 125UL) != 7U) { tmp___7 = spinlock_check(& bcs->aclock); flags = _raw_spin_lock_irqsave(tmp___7); bcs->ackcnt = bcs->ackcnt + bcs->hw.hscx.count; spin_unlock_irqrestore(& bcs->aclock, flags); test_and_set_bit(2, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } dev_kfree_skb_irq(bcs->tx_skb); bcs->hw.hscx.count = 0; bcs->tx_skb = 0; } } else { } tmp___9 = skb_dequeue(& bcs->squeue); bcs->tx_skb = tmp___9; if ((unsigned long )tmp___9 != (unsigned long )((struct sk_buff *)0)) { bcs->hw.hscx.count = 0; test_and_set_bit(3, (unsigned long volatile *)(& bcs->Flag)); hscx_fill_fifo___2(bcs); } else { test_and_clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); test_and_set_bit(1, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } } else { } return; } } static void hscx_int_main___2(struct IsdnCardState *cs , u_char val ) { u_char exval ; struct BCState *bcs ; { if ((int )val & 1) { bcs = (struct BCState *)(& cs->bcs) + 1UL; exval = ReadHSCX___2(cs, 1, 36); if (((int )exval & 64) != 0) { if (bcs->mode == 1) { hscx_fill_fifo___2(bcs); } else { bcs->err_tx = bcs->err_tx + 1; if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { skb_push(bcs->tx_skb, (unsigned int )bcs->hw.hscx.count); bcs->tx_cnt = bcs->tx_cnt + bcs->hw.hscx.count; bcs->hw.hscx.count = 0; } else { } WriteHSCXCMDR___2(cs, bcs->hw.hscx.hscx, 1); if (cs->debug & 1) { debugl1(cs, (char *)"HSCX B EXIR %x Lost TX", (int )exval); } else { } } } else if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HSCX B EXIR %x", (int )exval); } else { } } else { } if (((int )val & 248) != 0) { if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HSCX B interrupt %x", (int )val); } else { } hscx_interrupt___2(cs, (int )val, 1); } else { } if (((int )val & 2) != 0) { bcs = (struct BCState *)(& cs->bcs); exval = ReadHSCX___2(cs, 0, 36); if (((int )exval & 64) != 0) { if (bcs->mode == 1) { hscx_fill_fifo___2(bcs); } else { bcs->err_tx = bcs->err_tx + 1; if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { skb_push(bcs->tx_skb, (unsigned int )bcs->hw.hscx.count); bcs->tx_cnt = bcs->tx_cnt + bcs->hw.hscx.count; bcs->hw.hscx.count = 0; } else { } WriteHSCXCMDR___2(cs, bcs->hw.hscx.hscx, 1); if (cs->debug & 1) { debugl1(cs, (char *)"HSCX A EXIR %x Lost TX", (int )exval); } else { } } } else if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HSCX A EXIR %x", (int )exval); } else { } } else { } if (((int )val & 4) != 0) { exval = ReadHSCX___2(cs, 0, 32); if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HSCX A interrupt %x", (int )exval); } else { } hscx_interrupt___2(cs, (int )exval, 0); } else { } return; } } static irqreturn_t avm_a1p_interrupt(int intno , void *dev_id ) { struct IsdnCardState *cs ; u_char val ; u_char sval ; u_long flags ; raw_spinlock_t *tmp ; unsigned char tmp___0 ; { cs = (struct IsdnCardState *)dev_id; tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); goto ldv_41108; ldv_41107: ; if ((cs->debug & 2) != 0) { debugl1(cs, (char *)"avm IntStatus %x", (int )sval); } else { } if (((int )sval & 64) != 0) { val = ReadHSCX___2(cs, 1, 32); if ((unsigned int )val != 0U) { hscx_int_main___2(cs, (int )val); } else { } } else { } if (((int )sval & 32) != 0) { val = ReadISAC___2(cs, 32); if ((unsigned int )val != 0U) { isac_interrupt(cs, (int )val); } else { } } else { } ldv_41108: tmp___0 = inb((int )(cs->hw.avm.cfg_reg + 4U)); sval = (unsigned int )((u_char )(~ ((int )tmp___0))) & 112U; if ((unsigned int )sval != 0U) { goto ldv_41107; } else { } WriteHSCX___2(cs, 0, 32, 255); WriteHSCX___2(cs, 1, 32, 255); WriteISAC___2(cs, 32, 255); WriteISAC___2(cs, 32, 0); WriteHSCX___2(cs, 0, 32, 0); WriteHSCX___2(cs, 1, 32, 0); spin_unlock_irqrestore(& cs->lock, flags); return (1); } } static int AVM_card_msg(struct IsdnCardState *cs , int mt , void *arg ) { u_long flags ; raw_spinlock_t *tmp ; int tout ; int loops ; int tmp___0 ; int tmp___1 ; int tout___0 ; int loops___0 ; int tmp___2 ; int tmp___3 ; raw_spinlock_t *tmp___4 ; { switch (mt) { case 240: tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); outb(0, (int )(cs->hw.avm.cfg_reg + 4U)); tout = 51; goto ldv_41126; ldv_41125: loops = 4000; goto ldv_41123; ldv_41122: __const_udelay(4295UL); ldv_41123: tmp___0 = loops; loops = loops - 1; if (tmp___0 != 0) { goto ldv_41122; } else { } ldv_41126: tmp___1 = tout; tout = tout - 1; if (tmp___1 != 0) { goto ldv_41125; } else { } outb(1, (int )(cs->hw.avm.cfg_reg + 4U)); tout___0 = 51; goto ldv_41134; ldv_41133: loops___0 = 4000; goto ldv_41131; ldv_41130: __const_udelay(4295UL); ldv_41131: tmp___2 = loops___0; loops___0 = loops___0 - 1; if (tmp___2 != 0) { goto ldv_41130; } else { } ldv_41134: tmp___3 = tout___0; tout___0 = tout___0 - 1; if (tmp___3 != 0) { goto ldv_41133; } else { } outb(0, (int )(cs->hw.avm.cfg_reg + 4U)); spin_unlock_irqrestore(& cs->lock, flags); return (0); case 243: ; return (0); case 242: tmp___4 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___4); outb(14, (int )(cs->hw.avm.cfg_reg + 4U)); clear_pending_isac_ints(cs); clear_pending_hscx_ints(cs); inithscxisac(cs, 1); inithscxisac(cs, 2); spin_unlock_irqrestore(& cs->lock, flags); return (0); case 244: ; return (0); default: ; return (0); } return (0); } } int setup_avm_a1_pcmcia(struct IsdnCard *card ) { u_char model ; u_char vers ; struct IsdnCardState *cs ; char tmp[64U] ; char *tmp___0 ; int tout ; int loops ; int tmp___1 ; int tmp___2 ; int tout___0 ; int loops___0 ; int tmp___3 ; int tmp___4 ; int tmp___5 ; { cs = card->cs; strcpy((char *)(& tmp), avm_revision); tmp___0 = HiSax_getrev((char const *)(& tmp)); printk("\016HiSax: AVM A1 PCMCIA driver Rev. %s\n", tmp___0); if ((unsigned int )cs->typ != 26U) { return (0); } else { } cs->hw.avm.cfg_reg = (unsigned int )card->para[1]; cs->irq = (u_int )card->para[0]; outb(192, (int )(cs->hw.avm.cfg_reg + 5U)); outb(0, (int )(cs->hw.avm.cfg_reg + 4U)); tout = 51; goto ldv_41156; ldv_41155: loops = 4000; goto ldv_41153; ldv_41152: __const_udelay(4295UL); ldv_41153: tmp___1 = loops; loops = loops - 1; if (tmp___1 != 0) { goto ldv_41152; } else { } ldv_41156: tmp___2 = tout; tout = tout - 1; if (tmp___2 != 0) { goto ldv_41155; } else { } outb(1, (int )(cs->hw.avm.cfg_reg + 4U)); tout___0 = 51; goto ldv_41164; ldv_41163: loops___0 = 4000; goto ldv_41161; ldv_41160: __const_udelay(4295UL); ldv_41161: tmp___3 = loops___0; loops___0 = loops___0 - 1; if (tmp___3 != 0) { goto ldv_41160; } else { } ldv_41164: tmp___4 = tout___0; tout___0 = tout___0 - 1; if (tmp___4 != 0) { goto ldv_41163; } else { } outb(0, (int )(cs->hw.avm.cfg_reg + 4U)); outb(6, (int )(cs->hw.avm.cfg_reg + 4U)); model = inb((int )(cs->hw.avm.cfg_reg + 6U)); vers = inb((int )(cs->hw.avm.cfg_reg + 7U)); printk("\016AVM A1 PCMCIA: io 0x%x irq %d model %d version %d\n", cs->hw.avm.cfg_reg, cs->irq, (int )model, (int )vers); setup_isac(cs); cs->readisac = & ReadISAC___2; cs->writeisac = & WriteISAC___2; cs->readisacfifo = & ReadISACfifo___2; cs->writeisacfifo = & WriteISACfifo___2; cs->BC_Read_Reg = & ReadHSCX___2; cs->BC_Write_Reg = & WriteHSCX___2; cs->BC_Send_Data = & hscx_fill_fifo___2; cs->cardmsg = & AVM_card_msg; cs->irq_flags = 128UL; cs->irq_func = & avm_a1p_interrupt; ISACVersion(cs, (char *)"AVM A1 PCMCIA:"); tmp___5 = HscxVersion(cs, (char *)"AVM A1 PCMCIA:"); if (tmp___5 != 0) { printk("\fAVM A1 PCMCIA: wrong HSCX versions check IO address\n"); return (0); } else { } return (1); } } void ldv_mutex_lock_253(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_lock(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_254(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_lock(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_255(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } int ldv_mutex_trylock_256(struct mutex *ldv_func_arg1 ) { ldv_func_ret_type___2 ldv_func_res ; int tmp ; int tmp___0 ; { tmp = mutex_trylock(ldv_func_arg1); ldv_func_res = tmp; tmp___0 = ldv_mutex_trylock_mutex(ldv_func_arg1); return (tmp___0); return (ldv_func_res); } } void ldv_mutex_unlock_257(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_258(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_cred_guard_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_259(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_cred_guard_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } int ldv_mutex_trylock_270(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_268(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_271(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_273(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_267(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_269(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_272(struct mutex *ldv_func_arg1 ) ; __inline static void outl(unsigned int value , int port ) { { __asm__ volatile ("outl %0, %w1": : "a" (value), "Nd" (port)); return; } } __inline static unsigned int inl(int port ) { unsigned int value ; { __asm__ volatile ("inl %w1, %0": "=a" (value): "Nd" (port)); return (value); } } static char const *avm_pci_rev = "$Revision: 1.29.2.4 $"; static u_char ReadISAC___3(struct IsdnCardState *cs , u_char offset ) { register u_char idx ; register u_char val ; { idx = (unsigned int )offset > 47U ? 6U : 4U; outb((int )idx, (int )(cs->hw.avm.cfg_reg + 4U)); val = inb((int )(cs->hw.avm.isac + ((unsigned int )offset & 15U))); return (val); } } static void WriteISAC___3(struct IsdnCardState *cs , u_char offset , u_char value ) { register u_char idx ; { idx = (unsigned int )offset > 47U ? 6U : 4U; outb((int )idx, (int )(cs->hw.avm.cfg_reg + 4U)); outb((int )value, (int )(cs->hw.avm.isac + ((unsigned int )offset & 15U))); return; } } static void ReadISACfifo___3(struct IsdnCardState *cs , u_char *data , int size ) { { outb(2, (int )(cs->hw.avm.cfg_reg + 4U)); insb((int )cs->hw.avm.isac, (void *)data, (unsigned long )size); return; } } static void WriteISACfifo___3(struct IsdnCardState *cs , u_char *data , int size ) { { outb(2, (int )(cs->hw.avm.cfg_reg + 4U)); outsb((int )cs->hw.avm.isac, (void const *)data, (unsigned long )size); return; } } __inline static u_int ReadHDLCPCI(struct IsdnCardState *cs , int chan , u_char offset ) { register u_int idx ; register u_int val ; { idx = chan != 0; outl(idx, (int )(cs->hw.avm.cfg_reg + 4U)); val = inl((int )(cs->hw.avm.isac + (unsigned int )offset)); return (val); } } __inline static void WriteHDLCPCI(struct IsdnCardState *cs , int chan , u_char offset , u_int value ) { register u_int idx ; { idx = chan != 0; outl(idx, (int )(cs->hw.avm.cfg_reg + 4U)); outl(value, (int )(cs->hw.avm.isac + (unsigned int )offset)); return; } } __inline static u_char ReadHDLCPnP(struct IsdnCardState *cs , int chan , u_char offset ) { register u_char idx ; register u_char val ; { idx = chan != 0; outb((int )idx, (int )(cs->hw.avm.cfg_reg + 4U)); val = inb((int )(cs->hw.avm.isac + (unsigned int )offset)); return (val); } } __inline static void WriteHDLCPnP(struct IsdnCardState *cs , int chan , u_char offset , u_char value ) { register u_char idx ; { idx = chan != 0; outb((int )idx, (int )(cs->hw.avm.cfg_reg + 4U)); outb((int )value, (int )(cs->hw.avm.isac + (unsigned int )offset)); return; } } static u_char ReadHDLC_s(struct IsdnCardState *cs , int chan , u_char offset ) { u_int tmp ; { tmp = ReadHDLCPCI(cs, chan, (int )offset); return ((u_char )tmp); } } static void WriteHDLC_s(struct IsdnCardState *cs , int chan , u_char offset , u_char value ) { { WriteHDLCPCI(cs, chan, (int )offset, (u_int )value); return; } } __inline static struct BCState *Sel_BCS(struct IsdnCardState *cs , int channel ) { { if (cs->bcs[0].mode != 0 && cs->bcs[0].channel == channel) { return ((struct BCState *)(& cs->bcs)); } else if (cs->bcs[1].mode != 0 && cs->bcs[1].channel == channel) { return ((struct BCState *)(& cs->bcs) + 1UL); } else { return (0); } } } static void write_ctrl(struct BCState *bcs , int which ) { { if (((bcs->cs)->debug & 16) != 0) { debugl1(bcs->cs, (char *)"hdlc %c wr%x ctrl %x", bcs->channel + 65, which, bcs->hw.hdlc.ctrl.ctrl); } else { } if ((unsigned int )(bcs->cs)->subtyp == 1U) { WriteHDLCPCI(bcs->cs, bcs->channel, 4, bcs->hw.hdlc.ctrl.ctrl); } else { if ((which & 4) != 0) { WriteHDLCPnP(bcs->cs, bcs->channel, 6, (int )bcs->hw.hdlc.ctrl.sr.mode); } else { } if ((which & 2) != 0) { WriteHDLCPnP(bcs->cs, bcs->channel, 5, (int )bcs->hw.hdlc.ctrl.sr.xml); } else { } if (which & 1) { WriteHDLCPnP(bcs->cs, bcs->channel, 4, (int )bcs->hw.hdlc.ctrl.sr.cmd); } else { } } return; } } static void modehdlc(struct BCState *bcs , int mode , int bc ) { struct IsdnCardState *cs ; int hdlc ; { cs = bcs->cs; hdlc = bcs->channel; if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"hdlc %c mode %d --> %d ichan %d --> %d", hdlc + 65, bcs->mode, mode, hdlc, bc); } else { } bcs->hw.hdlc.ctrl.ctrl = 0U; switch (mode) { case -1: bcs->mode = 1; bcs->channel = bc; bc = 0; case 0: ; if (bcs->mode == 0) { return; } else { } bcs->hw.hdlc.ctrl.sr.cmd = 160U; bcs->hw.hdlc.ctrl.sr.mode = 2U; write_ctrl(bcs, 5); bcs->mode = 0; bcs->channel = bc; goto ldv_41345; case 1: bcs->mode = mode; bcs->channel = bc; bcs->hw.hdlc.ctrl.sr.cmd = 160U; bcs->hw.hdlc.ctrl.sr.mode = 2U; write_ctrl(bcs, 5); bcs->hw.hdlc.ctrl.sr.cmd = 128U; write_ctrl(bcs, 1); bcs->hw.hdlc.ctrl.sr.cmd = 0U; test_and_set_bit(1, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); goto ldv_41345; case 2: bcs->mode = mode; bcs->channel = bc; bcs->hw.hdlc.ctrl.sr.cmd = 160U; bcs->hw.hdlc.ctrl.sr.mode = 1U; write_ctrl(bcs, 5); bcs->hw.hdlc.ctrl.sr.cmd = 128U; write_ctrl(bcs, 1); bcs->hw.hdlc.ctrl.sr.cmd = 0U; test_and_set_bit(1, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); goto ldv_41345; } ldv_41345: ; return; } } __inline static void hdlc_empty_fifo(struct BCState *bcs , int count ) { register u_int *ptr ; u_char *p ; u_char idx ; int cnt ; struct IsdnCardState *cs ; u_int *tmp ; u_char *tmp___0 ; char *t ; int tmp___1 ; { idx = bcs->channel != 0; cnt = 0; cs = bcs->cs; if ((cs->debug & 16) != 0 && (cs->debug & 32) == 0) { debugl1(cs, (char *)"hdlc_empty_fifo %d", count); } else { } if (bcs->hw.hdlc.rcvidx + count > 4096) { if (cs->debug & 1) { debugl1(cs, (char *)"hdlc_empty_fifo: incoming packet too large"); } else { } return; } else { } p = bcs->hw.hdlc.rcvbuf + (unsigned long )bcs->hw.hdlc.rcvidx; ptr = (u_int *)p; bcs->hw.hdlc.rcvidx = bcs->hw.hdlc.rcvidx + count; if ((unsigned int )cs->subtyp == 1U) { outl((unsigned int )idx, (int )(cs->hw.avm.cfg_reg + 4U)); goto ldv_41358; ldv_41357: tmp = ptr; ptr = ptr + 1; *tmp = inl((int )cs->hw.avm.isac); cnt = cnt + 4; ldv_41358: ; if (cnt < count) { goto ldv_41357; } else { } } else { outb((int )idx, (int )(cs->hw.avm.cfg_reg + 4U)); goto ldv_41361; ldv_41360: tmp___0 = p; p = p + 1; *tmp___0 = inb((int )cs->hw.avm.isac); cnt = cnt + 1; ldv_41361: ; if (cnt < count) { goto ldv_41360; } else { } } if ((cs->debug & 32) != 0) { t = (char *)bcs->blog; if ((unsigned int )cs->subtyp == 2U) { p = (u_char *)ptr; } else { } tmp___1 = sprintf(t, "hdlc_empty_fifo %c cnt %d", bcs->channel != 0 ? 66 : 65, count); t = t + (unsigned long )tmp___1; QuickHex(t, p, count); debugl1(cs, (char *)bcs->blog); } else { } return; } } __inline static void hdlc_fill_fifo(struct BCState *bcs ) { struct IsdnCardState *cs ; int count ; int cnt ; int fifo_size ; u_char *p ; u_int *ptr ; u_int *tmp ; u_char *tmp___0 ; char *t ; int tmp___1 ; { cs = bcs->cs; cnt = 0; fifo_size = 32; if ((cs->debug & 16) != 0 && (cs->debug & 32) == 0) { debugl1(cs, (char *)"hdlc_fill_fifo"); } else { } if ((unsigned long )bcs->tx_skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } if ((bcs->tx_skb)->len == 0U) { return; } else { } bcs->hw.hdlc.ctrl.sr.cmd = (unsigned int )bcs->hw.hdlc.ctrl.sr.cmd & 254U; if ((bcs->tx_skb)->len > (unsigned int )fifo_size) { count = fifo_size; } else { count = (int )(bcs->tx_skb)->len; if (bcs->mode != 1) { bcs->hw.hdlc.ctrl.sr.cmd = (u_char )((unsigned int )bcs->hw.hdlc.ctrl.sr.cmd | 1U); } else { } } if ((cs->debug & 16) != 0 && (cs->debug & 32) == 0) { debugl1(cs, (char *)"hdlc_fill_fifo %d/%u", count, (bcs->tx_skb)->len); } else { } p = (bcs->tx_skb)->data; ptr = (u_int *)p; skb_pull(bcs->tx_skb, (unsigned int )count); bcs->tx_cnt = bcs->tx_cnt - count; bcs->hw.hdlc.count = bcs->hw.hdlc.count + count; bcs->hw.hdlc.ctrl.sr.xml = count != fifo_size ? (u_char )count : 0U; write_ctrl(bcs, 3); if ((unsigned int )cs->subtyp == 1U) { goto ldv_41374; ldv_41373: tmp = ptr; ptr = ptr + 1; outl(*tmp, (int )cs->hw.avm.isac); cnt = cnt + 4; ldv_41374: ; if (cnt < count) { goto ldv_41373; } else { } } else { goto ldv_41377; ldv_41376: tmp___0 = p; p = p + 1; outb((int )*tmp___0, (int )cs->hw.avm.isac); cnt = cnt + 1; ldv_41377: ; if (cnt < count) { goto ldv_41376; } else { } } if ((cs->debug & 32) != 0) { t = (char *)bcs->blog; if ((unsigned int )cs->subtyp == 2U) { p = (u_char *)ptr; } else { } tmp___1 = sprintf(t, "hdlc_fill_fifo %c cnt %d", bcs->channel != 0 ? 66 : 65, count); t = t + (unsigned long )tmp___1; QuickHex(t, p, count); debugl1(cs, (char *)bcs->blog); } else { } return; } } static void HDLC_irq(struct BCState *bcs , u_int stat ) { int len ; struct sk_buff *skb ; size_t __len ; void *__ret ; unsigned char *tmp___0 ; u_long flags ; raw_spinlock_t *tmp___1 ; int tmp___2 ; struct sk_buff *tmp___3 ; { if (((bcs->cs)->debug & 16) != 0) { debugl1(bcs->cs, (char *)"ch%d stat %#x", bcs->channel, stat); } else { } if ((stat & 32U) != 0U) { if ((stat & 16U) != 0U) { if (((bcs->cs)->debug & 16) != 0) { debugl1(bcs->cs, (char *)"RDO"); } else { debugl1(bcs->cs, (char *)"ch%d stat %#x", bcs->channel, stat); } bcs->hw.hdlc.ctrl.sr.xml = 0U; bcs->hw.hdlc.ctrl.sr.cmd = (u_char )((unsigned int )bcs->hw.hdlc.ctrl.sr.cmd | 32U); write_ctrl(bcs, 1); bcs->hw.hdlc.ctrl.sr.cmd = (unsigned int )bcs->hw.hdlc.ctrl.sr.cmd & 223U; write_ctrl(bcs, 1); bcs->hw.hdlc.rcvidx = 0; } else { len = (int )((stat & 16128U) >> 8); if (len == 0) { len = 32; } else { } hdlc_empty_fifo(bcs, len); if ((int )stat & 1 || bcs->mode == 1) { if ((stat & 14U) == 6U || bcs->mode == 1) { skb = dev_alloc_skb((unsigned int )bcs->hw.hdlc.rcvidx); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { printk("\fHDLC: receive out of memory\n"); } else { __len = (size_t )bcs->hw.hdlc.rcvidx; tmp___0 = skb_put(skb, (unsigned int )bcs->hw.hdlc.rcvidx); __ret = memcpy((void *)tmp___0, (void const *)bcs->hw.hdlc.rcvbuf, __len); skb_queue_tail(& bcs->rqueue, skb); } bcs->hw.hdlc.rcvidx = 0; test_and_set_bit(0, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { if (((bcs->cs)->debug & 16) != 0) { debugl1(bcs->cs, (char *)"invalid frame"); } else { debugl1(bcs->cs, (char *)"ch%d invalid frame %#x", bcs->channel, stat); } bcs->hw.hdlc.rcvidx = 0; } } else { } } } else { } if ((stat & 64U) != 0U) { if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { skb_push(bcs->tx_skb, (unsigned int )bcs->hw.hdlc.count); bcs->tx_cnt = bcs->tx_cnt + bcs->hw.hdlc.count; bcs->hw.hdlc.count = 0; if ((bcs->cs)->debug & 1) { debugl1(bcs->cs, (char *)"ch%d XDU", bcs->channel); } else { } } else if ((bcs->cs)->debug & 1) { debugl1(bcs->cs, (char *)"ch%d XDU without skb", bcs->channel); } else { } bcs->hw.hdlc.ctrl.sr.xml = 0U; bcs->hw.hdlc.ctrl.sr.cmd = (u_char )((unsigned int )bcs->hw.hdlc.ctrl.sr.cmd | 128U); write_ctrl(bcs, 1); bcs->hw.hdlc.ctrl.sr.cmd = (unsigned int )bcs->hw.hdlc.ctrl.sr.cmd & 127U; write_ctrl(bcs, 1); hdlc_fill_fifo(bcs); } else if ((stat & 128U) != 0U) { if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { if ((bcs->tx_skb)->len != 0U) { hdlc_fill_fifo(bcs); return; } else { tmp___2 = constant_test_bit(1U, (unsigned long const volatile *)(& (bcs->st)->lli.flag)); if (tmp___2 != 0 && (unsigned int )*((unsigned char *)bcs->tx_skb + 125UL) != 7U) { tmp___1 = spinlock_check(& bcs->aclock); flags = _raw_spin_lock_irqsave(tmp___1); bcs->ackcnt = bcs->ackcnt + bcs->hw.hdlc.count; spin_unlock_irqrestore(& bcs->aclock, flags); test_and_set_bit(2, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } dev_kfree_skb_irq(bcs->tx_skb); bcs->hw.hdlc.count = 0; bcs->tx_skb = 0; } } else { } tmp___3 = skb_dequeue(& bcs->squeue); bcs->tx_skb = tmp___3; if ((unsigned long )tmp___3 != (unsigned long )((struct sk_buff *)0)) { bcs->hw.hdlc.count = 0; test_and_set_bit(3, (unsigned long volatile *)(& bcs->Flag)); hdlc_fill_fifo(bcs); } else { test_and_clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); test_and_set_bit(1, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } } else { } return; } } __inline static void HDLC_irq_main(struct IsdnCardState *cs ) { u_int stat ; struct BCState *bcs ; u_char tmp ; u_char tmp___0 ; u_char tmp___1 ; u_char tmp___2 ; { if ((unsigned int )cs->subtyp == 1U) { stat = ReadHDLCPCI(cs, 0, 4); } else { tmp = ReadHDLCPnP(cs, 0, 4); stat = (u_int )tmp; if ((stat & 32U) != 0U) { tmp___0 = ReadHDLCPnP(cs, 0, 5); stat = (u_int )((int )tmp___0 << 8) | stat; } else { } } if ((stat & 224U) != 0U) { bcs = Sel_BCS(cs, 0); if ((unsigned long )bcs == (unsigned long )((struct BCState *)0)) { if (cs->debug != 0) { debugl1(cs, (char *)"hdlc spurious channel 0 IRQ"); } else { HDLC_irq(bcs, stat); } } else { } } else { } if ((unsigned int )cs->subtyp == 1U) { stat = ReadHDLCPCI(cs, 1, 4); } else { tmp___1 = ReadHDLCPnP(cs, 1, 4); stat = (u_int )tmp___1; if ((stat & 32U) != 0U) { tmp___2 = ReadHDLCPnP(cs, 1, 5); stat = (u_int )((int )tmp___2 << 8) | stat; } else { } } if ((stat & 224U) != 0U) { bcs = Sel_BCS(cs, 1); if ((unsigned long )bcs == (unsigned long )((struct BCState *)0)) { if (cs->debug != 0) { debugl1(cs, (char *)"hdlc spurious channel 1 IRQ"); } else { HDLC_irq(bcs, stat); } } else { } } else { } return; } } static void hdlc_l2l1(struct PStack *st , int pr , void *arg ) { struct BCState *bcs ; struct sk_buff *skb ; u_long flags ; raw_spinlock_t *tmp ; raw_spinlock_t *tmp___0 ; raw_spinlock_t *tmp___1 ; raw_spinlock_t *tmp___2 ; { bcs = st->l1.bcs; skb = (struct sk_buff *)arg; switch (pr) { case 288: tmp = spinlock_check(& (bcs->cs)->lock); flags = _raw_spin_lock_irqsave(tmp); if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { skb_queue_tail(& bcs->squeue, skb); } else { bcs->tx_skb = skb; test_and_set_bit(3, (unsigned long volatile *)(& bcs->Flag)); bcs->hw.hdlc.count = 0; (*((bcs->cs)->BC_Send_Data))(bcs); } spin_unlock_irqrestore(& (bcs->cs)->lock, flags); goto ldv_41410; case 306: tmp___0 = spinlock_check(& (bcs->cs)->lock); flags = _raw_spin_lock_irqsave(tmp___0); if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { printk("\fhdlc_l2l1: this shouldn\'t happen\n"); } else { test_and_set_bit(3, (unsigned long volatile *)(& bcs->Flag)); bcs->tx_skb = skb; bcs->hw.hdlc.count = 0; (*((bcs->cs)->BC_Send_Data))(bcs); } spin_unlock_irqrestore(& (bcs->cs)->lock, flags); goto ldv_41410; case 304: ; if ((unsigned long )bcs->tx_skb == (unsigned long )((struct sk_buff *)0)) { test_and_clear_bit(6, (unsigned long volatile *)(& st->l1.Flags)); (*(st->l1.l1l2))(st, 305, 0); } else { test_and_set_bit(6, (unsigned long volatile *)(& st->l1.Flags)); } goto ldv_41410; case 256: tmp___1 = spinlock_check(& (bcs->cs)->lock); flags = _raw_spin_lock_irqsave(tmp___1); test_and_set_bit(2, (unsigned long volatile *)(& bcs->Flag)); modehdlc(bcs, st->l1.mode, st->l1.bc); spin_unlock_irqrestore(& (bcs->cs)->lock, flags); l1_msg_b(st, pr, arg); goto ldv_41410; case 272: l1_msg_b(st, pr, arg); goto ldv_41410; case 273: tmp___2 = spinlock_check(& (bcs->cs)->lock); flags = _raw_spin_lock_irqsave(tmp___2); test_and_clear_bit(2, (unsigned long volatile *)(& bcs->Flag)); test_and_clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); modehdlc(bcs, 0, st->l1.bc); spin_unlock_irqrestore(& (bcs->cs)->lock, flags); (*(st->l1.l1l2))(st, 273, 0); goto ldv_41410; } ldv_41410: ; return; } } static void close_hdlcstate(struct BCState *bcs ) { int tmp ; { modehdlc(bcs, 0, 0); tmp = test_and_clear_bit(1, (unsigned long volatile *)(& bcs->Flag)); if (tmp != 0) { kfree((void const *)bcs->hw.hdlc.rcvbuf); bcs->hw.hdlc.rcvbuf = 0; kfree((void const *)bcs->blog); bcs->blog = 0; skb_queue_purge(& bcs->rqueue); skb_queue_purge(& bcs->squeue); if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { dev_kfree_skb_any(bcs->tx_skb); bcs->tx_skb = 0; test_and_clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); } else { } } else { } return; } } static int open_hdlcstate(struct IsdnCardState *cs , struct BCState *bcs ) { u_char *tmp ; void *tmp___0 ; u_char *tmp___1 ; void *tmp___2 ; int tmp___3 ; { tmp___3 = test_and_set_bit(1, (unsigned long volatile *)(& bcs->Flag)); if (tmp___3 == 0) { tmp___0 = kmalloc(4096UL, 32U); tmp = (u_char *)tmp___0; bcs->hw.hdlc.rcvbuf = tmp; if ((unsigned long )tmp == (unsigned long )((u_char *)0)) { printk("\fHiSax: No memory for hdlc.rcvbuf\n"); return (1); } else { } tmp___2 = kmalloc(256UL, 32U); tmp___1 = (u_char *)tmp___2; bcs->blog = tmp___1; if ((unsigned long )tmp___1 == (unsigned long )((u_char *)0)) { printk("\fHiSax: No memory for bcs->blog\n"); test_and_clear_bit(1, (unsigned long volatile *)(& bcs->Flag)); kfree((void const *)bcs->hw.hdlc.rcvbuf); bcs->hw.hdlc.rcvbuf = 0; return (2); } else { } skb_queue_head_init(& bcs->rqueue); skb_queue_head_init(& bcs->squeue); } else { } bcs->tx_skb = 0; test_and_clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); bcs->event = 0UL; bcs->hw.hdlc.rcvidx = 0; bcs->tx_cnt = 0; return (0); } } static int setstack_hdlc(struct PStack *st , struct BCState *bcs ) { int tmp ; { bcs->channel = st->l1.bc; tmp = open_hdlcstate((struct IsdnCardState *)st->l1.hardware, bcs); if (tmp != 0) { return (-1); } else { } st->l1.bcs = bcs; st->l2.l2l1 = & hdlc_l2l1; setstack_manager(st); bcs->st = st; setstack_l1_B(st); return (0); } } static void inithdlc(struct IsdnCardState *cs ) { { cs->bcs[0].BC_SetStack = & setstack_hdlc; cs->bcs[1].BC_SetStack = & setstack_hdlc; cs->bcs[0].BC_Close = & close_hdlcstate; cs->bcs[1].BC_Close = & close_hdlcstate; modehdlc((struct BCState *)(& cs->bcs), -1, 0); modehdlc((struct BCState *)(& cs->bcs) + 1UL, -1, 1); return; } } static irqreturn_t avm_pcipnp_interrupt(int intno , void *dev_id ) { struct IsdnCardState *cs ; u_long flags ; u_char val ; u_char sval ; raw_spinlock_t *tmp ; { cs = (struct IsdnCardState *)dev_id; tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); sval = inb((int )(cs->hw.avm.cfg_reg + 2U)); if (((int )sval & 7) == 7) { spin_unlock_irqrestore(& cs->lock, flags); return (0); } else { } if (((int )sval & 1) == 0) { val = ReadISAC___3(cs, 32); isac_interrupt(cs, (int )val); } else { } if (((int )sval & 2) == 0) { HDLC_irq_main(cs); } else { } WriteISAC___3(cs, 32, 255); WriteISAC___3(cs, 32, 0); spin_unlock_irqrestore(& cs->lock, flags); return (1); } } static void reset_avmpcipnp(struct IsdnCardState *cs ) { unsigned long __ms ; unsigned long tmp ; unsigned long __ms___0 ; unsigned long tmp___0 ; unsigned char tmp___1 ; { printk("\016AVM PCI/PnP: reset\n"); outb(3, (int )(cs->hw.avm.cfg_reg + 2U)); __ms = 10UL; goto ldv_41455; ldv_41454: __const_udelay(4295000UL); ldv_41455: tmp = __ms; __ms = __ms - 1UL; if (tmp != 0UL) { goto ldv_41454; } else { } outb(14, (int )(cs->hw.avm.cfg_reg + 2U)); outb((int )((unsigned int )((unsigned char )cs->irq) | 128U), (int )(cs->hw.avm.cfg_reg + 3U)); __ms___0 = 10UL; goto ldv_41459; ldv_41458: __const_udelay(4295000UL); ldv_41459: tmp___0 = __ms___0; __ms___0 = __ms___0 - 1UL; if (tmp___0 != 0UL) { goto ldv_41458; } else { } tmp___1 = inb((int )(cs->hw.avm.cfg_reg + 3U)); printk("\016AVM PCI/PnP: S1 %x\n", (int )tmp___1); return; } } static int AVM_card_msg___0(struct IsdnCardState *cs , int mt , void *arg ) { u_long flags ; raw_spinlock_t *tmp ; raw_spinlock_t *tmp___0 ; { switch (mt) { case 240: tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); reset_avmpcipnp(cs); spin_unlock_irqrestore(& cs->lock, flags); return (0); case 243: outb(0, (int )(cs->hw.avm.cfg_reg + 2U)); __release_region(& ioport_resource, (resource_size_t )cs->hw.avm.cfg_reg, 32ULL); return (0); case 242: tmp___0 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___0); reset_avmpcipnp(cs); clear_pending_isac_ints(cs); initisac(cs); inithdlc(cs); outb(6, (int )(cs->hw.avm.cfg_reg + 2U)); WriteISAC___3(cs, 32, 0); outb(14, (int )(cs->hw.avm.cfg_reg + 2U)); WriteISAC___3(cs, 33, 65); spin_unlock_irqrestore(& cs->lock, flags); return (0); case 244: ; return (0); } return (0); } } static int avm_setup_rest(struct IsdnCardState *cs ) { u_int val ; u_int ver ; struct resource *tmp ; unsigned char tmp___0 ; unsigned char tmp___1 ; { cs->hw.avm.isac = cs->hw.avm.cfg_reg + 16U; tmp = __request_region(& ioport_resource, (resource_size_t )cs->hw.avm.cfg_reg, 32ULL, (unsigned int )cs->subtyp == 1U ? "avm PCI" : "avm PnP", 0); if ((unsigned long )tmp == (unsigned long )((struct resource *)0)) { printk("\fHiSax: Fritz!PCI/PNP config port %x-%x already in use\n", cs->hw.avm.cfg_reg, cs->hw.avm.cfg_reg + 31U); return (0); } else { } switch ((int )cs->subtyp) { case 1: val = inl((int )cs->hw.avm.cfg_reg); printk("\016AVM PCI: stat %#x\n", val); printk("\016AVM PCI: Class %X Rev %d\n", val & 255U, (val >> 8) & 255U); cs->BC_Read_Reg = & ReadHDLC_s; cs->BC_Write_Reg = & WriteHDLC_s; goto ldv_41483; case 2: tmp___0 = inb((int )cs->hw.avm.cfg_reg); val = (u_int )tmp___0; tmp___1 = inb((int )(cs->hw.avm.cfg_reg + 1U)); ver = (u_int )tmp___1; printk("\016AVM PnP: Class %X Rev %d\n", val, ver); cs->BC_Read_Reg = & ReadHDLCPnP; cs->BC_Write_Reg = & WriteHDLCPnP; goto ldv_41483; default: printk("\fAVM unknown subtype %d\n", (int )cs->subtyp); return (0); } ldv_41483: printk("\016HiSax: %s config irq:%d base:0x%X\n", (unsigned int )cs->subtyp == 1U ? (char *)"AVM Fritz!PCI" : (char *)"AVM Fritz!PnP", cs->irq, cs->hw.avm.cfg_reg); setup_isac(cs); cs->readisac = & ReadISAC___3; cs->writeisac = & WriteISAC___3; cs->readisacfifo = & ReadISACfifo___3; cs->writeisacfifo = & WriteISACfifo___3; cs->BC_Send_Data = & hdlc_fill_fifo; cs->cardmsg = & AVM_card_msg___0; cs->irq_func = & avm_pcipnp_interrupt; (*(cs->writeisac))(cs, 32, 255); ISACVersion(cs, (unsigned int )cs->subtyp == 1U ? (char *)"AVM PCI:" : (char *)"AVM PnP:"); return (1); } } static int avm_pnp_setup(struct IsdnCardState *cs ) { { return (1); } } static struct pci_dev *dev_avm = 0; static int avm_pci_setup(struct IsdnCardState *cs ) { int tmp ; { dev_avm = hisax_find_pci_device(4676U, 2560U, dev_avm); if ((unsigned long )dev_avm != (unsigned long )((struct pci_dev *)0)) { tmp = pci_enable_device(dev_avm); if (tmp != 0) { return (0); } else { } cs->irq = dev_avm->irq; if (cs->irq == 0U) { printk("\vFritzPCI: No IRQ for PCI card found\n"); return (0); } else { } cs->hw.avm.cfg_reg = (unsigned int )dev_avm->resource[1].start; if (cs->hw.avm.cfg_reg == 0U) { printk("\vFritzPCI: No IO-Adr for PCI card found\n"); return (0); } else { } cs->subtyp = 1U; } else { printk("\fFritzPCI: No PCI card found\n"); return (0); } cs->irq_flags = cs->irq_flags | 128UL; return (1); } } int setup_avm_pcipnp(struct IsdnCard *card ) { struct IsdnCardState *cs ; char tmp[64U] ; int rc ; char *tmp___0 ; int tmp___1 ; { cs = card->cs; strcpy((char *)(& tmp), avm_pci_rev); tmp___0 = HiSax_getrev((char const *)(& tmp)); printk("\016HiSax: AVM PCI driver Rev. %s\n", tmp___0); if ((unsigned int )cs->typ != 27U) { return (0); } else { } if (card->para[1] != 0UL) { cs->hw.avm.cfg_reg = (unsigned int )card->para[1]; cs->irq = (u_int )card->para[0]; cs->subtyp = 2U; goto ready; } else { } rc = avm_pnp_setup(cs); if (rc <= 0) { return (0); } else { } if (rc == 2) { goto ready; } else { } rc = avm_pci_setup(cs); if (rc <= 0) { return (0); } else { } ready: tmp___1 = avm_setup_rest(cs); return (tmp___1); } } void ldv_mutex_lock_267(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_lock(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_268(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_lock(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_269(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } int ldv_mutex_trylock_270(struct mutex *ldv_func_arg1 ) { ldv_func_ret_type___2 ldv_func_res ; int tmp ; int tmp___0 ; { tmp = mutex_trylock(ldv_func_arg1); ldv_func_res = tmp; tmp___0 = ldv_mutex_trylock_mutex(ldv_func_arg1); return (tmp___0); return (ldv_func_res); } } void ldv_mutex_unlock_271(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_272(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_cred_guard_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_273(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_cred_guard_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } int ldv_mutex_trylock_284(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_282(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_285(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_287(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_281(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_283(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_286(struct mutex *ldv_func_arg1 ) ; extern void interruptible_sleep_on(wait_queue_head_t * ) ; __inline static void skb_copy_from_linear_data(struct sk_buff const *skb , void *to , unsigned int const len ) { size_t __len ; void *__ret ; { __len = (size_t )len; __ret = memcpy(to, (void const *)skb->data, __len); return; } } static char const *Elsa_revision = "$Revision: 2.32.2.4 $"; static char const *Elsa_Types[12U] = { "None", "PC", "PCC-8", "PCC-16", "PCF", "PCF-Pro", "PCMCIA", "QS 1000", "QS 3000", "Microlink PCI", "QS 3000 PCI", "PCMCIA-IPAC"}; static char const *ITACVer[8U] = { "?0?", "?1?", "?2?", "?3?", "?4?", "V2.2", "B1", "A1"}; static struct arcofi_msg ARCOFI_XOP_F = {0, 0U, 2U, {161U, 63U, 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U}}; static struct arcofi_msg ARCOFI_XOP_1 = {& ARCOFI_XOP_F, 0U, 2U, {161U, 49U, 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U}}; static struct arcofi_msg ARCOFI_SOP_F = {& ARCOFI_XOP_1, 0U, 10U, {161U, 31U, 0U, 80U, 16U, 0U, 0U, 128U, 2U, 18U}}; static struct arcofi_msg ARCOFI_COP_9 = {& ARCOFI_SOP_F, 0U, 10U, {161U, 41U, 128U, 203U, 233U, 136U, 0U, 200U, 216U, 128U}}; static struct arcofi_msg ARCOFI_COP_8 = {& ARCOFI_COP_9, 0U, 10U, {161U, 40U, 73U, 49U, 8U, 19U, 110U, 136U, 42U, 97U}}; static struct arcofi_msg ARCOFI_COP_7 = {& ARCOFI_COP_8, 0U, 4U, {161U, 39U, 128U, 128U, 0U, 0U, 0U, 0U, 0U, 0U}}; static struct arcofi_msg ARCOFI_COP_6 = {& ARCOFI_COP_7, 0U, 6U, {161U, 38U, 0U, 0U, 130U, 124U, 0U, 0U, 0U, 0U}}; static struct arcofi_msg ARCOFI_COP_5 = {& ARCOFI_COP_6, 0U, 4U, {161U, 37U, 187U, 74U, 0U, 0U, 0U, 0U, 0U, 0U}}; static struct arcofi_msg ARCOFI_VERSION = {0, 1U, 2U, {160U, 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U}}; static struct arcofi_msg ARCOFI_XOP_0 = {0, 0U, 2U, {161U, 48U, 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U}}; static void set_arcofi(struct IsdnCardState *cs , int bc ) ; static char *MInit_1 = (char *)"AT&F&C1E0&D2\r"; static char *MInit_2 = (char *)"ATL2M1S64=13\r"; static char *MInit_3 = (char *)"AT+FCLASS=0\r"; static char *MInit_4 = (char *)"ATV1S2=128X1\r"; static char *MInit_5 = (char *)"AT\\V8\\N3\r"; static char *MInit_6 = (char *)"ATL0M0&G0%E1\r"; static char *MInit_7 = (char *)"AT%L1%M0%C3\r"; static char *MInit_speed28800 = (char *)"AT%G0%B28800\r"; static char *MInit_dialout = (char *)"ATs7=60 x1 d\r"; static char *MInit_dialin = (char *)"ATs7=60 x1 a\r"; __inline static unsigned int serial_in(struct IsdnCardState *cs , int offset ) { unsigned char tmp ; { tmp = inb((int )(((unsigned int )cs->hw.elsa.base + (unsigned int )offset) + 8U)); return ((unsigned int )tmp); } } __inline static unsigned int serial_inp(struct IsdnCardState *cs , int offset ) { unsigned char tmp ; { tmp = inb_p((int )(((unsigned int )cs->hw.elsa.base + (unsigned int )offset) + 8U)); return ((unsigned int )tmp); } } __inline static void serial_out(struct IsdnCardState *cs , int offset , int value ) { { outb((int )((unsigned char )value), (int )(((unsigned int )cs->hw.elsa.base + (unsigned int )offset) + 8U)); return; } } __inline static void serial_outp(struct IsdnCardState *cs , int offset , int value ) { { outb_p((int )((unsigned char )value), (int )(((unsigned int )cs->hw.elsa.base + (unsigned int )offset) + 8U)); return; } } static void change_speed(struct IsdnCardState *cs , int baud ) { int quot ; int baud_base ; unsigned int cval ; unsigned int fcr ; { quot = 0; fcr = 0U; cval = 3U; baud_base = 115200; quot = baud_base / baud; if (quot == 0) { quot = baud_base / 9600; } else { } if (baud_base / quot <= 2399) { fcr = 1U; } else { fcr = 129U; } serial_outp(cs, 2, (int )fcr); cs->hw.elsa.IER = (unsigned int )cs->hw.elsa.IER & 247U; cs->hw.elsa.IER = (u_char )((unsigned int )cs->hw.elsa.IER | 8U); serial_outp(cs, 1, (int )cs->hw.elsa.IER); debugl1(cs, (char *)"modem quot=0x%x", quot); serial_outp(cs, 3, (int )(cval | 128U)); serial_outp(cs, 0, quot & 255); serial_outp(cs, 1, quot >> 8); serial_outp(cs, 3, (int )cval); serial_inp(cs, 0); return; } } static int mstartup(struct IsdnCardState *cs ) { int retval ; unsigned int tmp ; unsigned int tmp___0 ; unsigned int tmp___1 ; { retval = 0; serial_outp(cs, 2, 6); tmp = serial_inp(cs, 5); if (tmp == 255U) { retval = -19; goto errout; } else { } serial_inp(cs, 0); serial_inp(cs, 2); serial_inp(cs, 6); serial_outp(cs, 3, 3); cs->hw.elsa.MCR = 0U; cs->hw.elsa.MCR = 11U; serial_outp(cs, 4, (int )cs->hw.elsa.MCR); cs->hw.elsa.IER = 13U; serial_outp(cs, 1, (int )cs->hw.elsa.IER); serial_inp(cs, 5); serial_inp(cs, 0); serial_inp(cs, 2); serial_inp(cs, 6); tmp___0 = 0U; cs->hw.elsa.transp = tmp___0; cs->hw.elsa.transcnt = tmp___0; tmp___1 = 0U; cs->hw.elsa.rcvp = tmp___1; cs->hw.elsa.rcvcnt = tmp___1; change_speed(cs, 115200); cs->hw.elsa.MFlag = 1U; errout: ; return (retval); } } static void mshutdown(struct IsdnCardState *cs ) { unsigned int tmp ; { cs->hw.elsa.IER = 0U; serial_outp(cs, 1, 0); cs->hw.elsa.MCR = (unsigned int )cs->hw.elsa.MCR & 247U; tmp = serial_inp(cs, 3); serial_outp(cs, 3, (int )tmp & -65); cs->hw.elsa.MCR = (unsigned int )cs->hw.elsa.MCR & 252U; serial_outp(cs, 4, (int )cs->hw.elsa.MCR); serial_outp(cs, 2, 6); serial_inp(cs, 0); return; } } __inline static int write_modem(struct BCState *bcs ) { int ret ; struct IsdnCardState *cs ; int count ; int len ; int fp ; { ret = 0; cs = bcs->cs; if ((unsigned long )bcs->tx_skb == (unsigned long )((struct sk_buff *)0)) { return (0); } else { } if ((bcs->tx_skb)->len == 0U) { return (0); } else { } len = (int )(bcs->tx_skb)->len; if ((unsigned int )len > 256U - cs->hw.elsa.transcnt) { len = (int )(256U - cs->hw.elsa.transcnt); } else { } fp = (int )(cs->hw.elsa.transcnt + cs->hw.elsa.transp); fp = fp & 255; count = len; if (256 - fp < count) { count = 256 - fp; skb_copy_from_linear_data((struct sk_buff const *)bcs->tx_skb, (void *)cs->hw.elsa.transbuf + (unsigned long )fp, (unsigned int const )count); skb_pull(bcs->tx_skb, (unsigned int )count); cs->hw.elsa.transcnt = cs->hw.elsa.transcnt + (unsigned int )count; ret = count; count = len - count; fp = 0; } else { } skb_copy_from_linear_data((struct sk_buff const *)bcs->tx_skb, (void *)cs->hw.elsa.transbuf + (unsigned long )fp, (unsigned int const )count); skb_pull(bcs->tx_skb, (unsigned int )count); cs->hw.elsa.transcnt = cs->hw.elsa.transcnt + (unsigned int )count; ret = ret + count; if (cs->hw.elsa.transcnt != 0U && ((int )cs->hw.elsa.IER & 2) == 0) { cs->hw.elsa.IER = (u_char )((unsigned int )cs->hw.elsa.IER | 2U); serial_outp(cs, 1, (int )cs->hw.elsa.IER); } else { } return (ret); } } __inline static void modem_fill(struct BCState *bcs ) { u_long flags ; raw_spinlock_t *tmp ; int tmp___0 ; struct sk_buff *tmp___1 ; { if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { if ((bcs->tx_skb)->len != 0U) { write_modem(bcs); return; } else { tmp___0 = constant_test_bit(1U, (unsigned long const volatile *)(& (bcs->st)->lli.flag)); if (tmp___0 != 0 && (unsigned int )*((unsigned char *)bcs->tx_skb + 125UL) != 7U) { tmp = spinlock_check(& bcs->aclock); flags = _raw_spin_lock_irqsave(tmp); bcs->ackcnt = bcs->ackcnt + bcs->hw.hscx.count; spin_unlock_irqrestore(& bcs->aclock, flags); test_and_set_bit(2, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } dev_kfree_skb_any(bcs->tx_skb); bcs->tx_skb = 0; } } else { } tmp___1 = skb_dequeue(& bcs->squeue); bcs->tx_skb = tmp___1; if ((unsigned long )tmp___1 != (unsigned long )((struct sk_buff *)0)) { bcs->hw.hscx.count = 0; test_and_set_bit(3, (unsigned long volatile *)(& bcs->Flag)); write_modem(bcs); } else { test_and_clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); test_and_set_bit(1, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } return; } } __inline static void receive_chars(struct IsdnCardState *cs , int *status ) { unsigned char ch ; struct sk_buff *skb ; unsigned int tmp ; unsigned int tmp___0 ; unsigned int tmp___1 ; size_t __len ; void *__ret ; unsigned char *tmp___3 ; char tmp___4[128U] ; char *t ; int tmp___5 ; { ldv_41434: tmp = serial_in(cs, 0); ch = (unsigned char )tmp; if (cs->hw.elsa.rcvcnt > 255U) { goto ldv_41433; } else { } tmp___0 = cs->hw.elsa.rcvcnt; cs->hw.elsa.rcvcnt = cs->hw.elsa.rcvcnt + 1U; *(cs->hw.elsa.rcvbuf + (unsigned long )tmp___0) = ch; tmp___1 = serial_inp(cs, 5); *status = (int )tmp___1; if (*status & 1) { goto ldv_41434; } else { } ldv_41433: ; if (cs->hw.elsa.MFlag == 2U) { skb = dev_alloc_skb(cs->hw.elsa.rcvcnt); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { printk("\fElsaSER: receive out of memory\n"); } else { __len = (size_t )cs->hw.elsa.rcvcnt; tmp___3 = skb_put(skb, cs->hw.elsa.rcvcnt); __ret = memcpy((void *)tmp___3, (void const *)cs->hw.elsa.rcvbuf, __len); skb_queue_tail(& (cs->hw.elsa.bcs)->rqueue, skb); } test_and_set_bit(0, (unsigned long volatile *)(& (cs->hw.elsa.bcs)->event)); schedule_work(& (cs->hw.elsa.bcs)->tqueue); } else { t = (char *)(& tmp___4); tmp___5 = sprintf(t, "modem read cnt %d", cs->hw.elsa.rcvcnt); t = t + (unsigned long )tmp___5; QuickHex(t, cs->hw.elsa.rcvbuf, (int )cs->hw.elsa.rcvcnt); debugl1(cs, (char *)(& tmp___4)); } cs->hw.elsa.rcvcnt = 0U; return; } } __inline static void transmit_chars(struct IsdnCardState *cs , int *intr_done ) { int count ; unsigned int tmp ; { debugl1(cs, (char *)"transmit_chars: p(%x) cnt(%x)", cs->hw.elsa.transp, cs->hw.elsa.transcnt); if (cs->hw.elsa.transcnt == 0U) { cs->hw.elsa.IER = (unsigned int )cs->hw.elsa.IER & 253U; serial_out(cs, 1, (int )cs->hw.elsa.IER); return; } else { } count = 16; ldv_41446: tmp = cs->hw.elsa.transp; cs->hw.elsa.transp = cs->hw.elsa.transp + 1U; serial_outp(cs, 0, (int )*(cs->hw.elsa.transbuf + (unsigned long )tmp)); if (cs->hw.elsa.transp > 255U) { cs->hw.elsa.transp = 0U; } else { } cs->hw.elsa.transcnt = cs->hw.elsa.transcnt - 1U; if (cs->hw.elsa.transcnt == 0U) { goto ldv_41445; } else { } count = count - 1; if (count > 0) { goto ldv_41446; } else { } ldv_41445: ; if (cs->hw.elsa.transcnt <= 127U && cs->hw.elsa.MFlag == 2U) { modem_fill(cs->hw.elsa.bcs); } else { } if ((unsigned long )intr_done != (unsigned long )((int *)0)) { *intr_done = 0; } else { } if (cs->hw.elsa.transcnt == 0U) { cs->hw.elsa.IER = (unsigned int )cs->hw.elsa.IER & 253U; serial_outp(cs, 1, (int )cs->hw.elsa.IER); } else { } return; } } static void rs_interrupt_elsa(struct IsdnCardState *cs ) { int status ; int iir ; int msr ; int pass_counter ; unsigned int tmp ; int tmp___0 ; unsigned int tmp___1 ; unsigned int tmp___2 ; { pass_counter = 0; ldv_41455: tmp = serial_inp(cs, 5); status = (int )tmp; debugl1(cs, (char *)"rs LSR %02x", status); if (status & 1) { receive_chars(cs, & status); } else { } if ((status & 32) != 0) { transmit_chars(cs, 0); } else { } tmp___0 = pass_counter; pass_counter = pass_counter + 1; if (tmp___0 > 256) { printk("rs_single loop break.\n"); goto ldv_41454; } else { } tmp___1 = serial_inp(cs, 2); iir = (int )tmp___1; debugl1(cs, (char *)"rs IIR %02x", iir); if ((iir & 15) == 0) { tmp___2 = serial_inp(cs, 6); msr = (int )tmp___2; debugl1(cs, (char *)"rs MSR %02x", msr); } else { } if ((iir & 1) == 0) { goto ldv_41455; } else { } ldv_41454: ; return; } } static void close_elsastate(struct BCState *bcs ) { int tmp ; { modehscx(bcs, 0, bcs->channel); tmp = test_and_clear_bit(1, (unsigned long volatile *)(& bcs->Flag)); if (tmp != 0) { if ((unsigned long )bcs->hw.hscx.rcvbuf != (unsigned long )((u_char *)0)) { if (bcs->mode != 7) { kfree((void const *)bcs->hw.hscx.rcvbuf); } else { } bcs->hw.hscx.rcvbuf = 0; } else { } skb_queue_purge(& bcs->rqueue); skb_queue_purge(& bcs->squeue); if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { dev_kfree_skb_any(bcs->tx_skb); bcs->tx_skb = 0; test_and_clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); } else { } } else { } return; } } static void modem_write_cmd(struct IsdnCardState *cs , u_char *buf , int len ) { int count ; int fp ; u_char *msg ; size_t __len ; void *__ret ; size_t __len___0 ; void *__ret___0 ; { msg = buf; if (len == 0) { return; } else { } if ((unsigned int )len > 256U - cs->hw.elsa.transcnt) { return; } else { } fp = (int )(cs->hw.elsa.transcnt + cs->hw.elsa.transp); fp = fp & 255; count = len; if (256 - fp < count) { count = 256 - fp; __len = (size_t )count; __ret = memcpy((void *)cs->hw.elsa.transbuf + (unsigned long )fp, (void const *)msg, __len); cs->hw.elsa.transcnt = cs->hw.elsa.transcnt + (unsigned int )count; msg = msg + (unsigned long )count; count = len - count; fp = 0; } else { } __len___0 = (size_t )count; __ret___0 = memcpy((void *)cs->hw.elsa.transbuf + (unsigned long )fp, (void const *)msg, __len___0); cs->hw.elsa.transcnt = cs->hw.elsa.transcnt + (unsigned int )count; if (cs->hw.elsa.transcnt != 0U && ((int )cs->hw.elsa.IER & 2) == 0) { cs->hw.elsa.IER = (u_char )((unsigned int )cs->hw.elsa.IER | 2U); serial_outp(cs, 1, (int )cs->hw.elsa.IER); } else { } return; } } static void modem_set_init(struct IsdnCardState *cs ) { int timeout ; size_t tmp ; int tmp___0 ; unsigned long __ms ; unsigned long tmp___1 ; size_t tmp___2 ; int tmp___3 ; unsigned long __ms___0 ; unsigned long tmp___4 ; size_t tmp___5 ; int tmp___6 ; unsigned long __ms___1 ; unsigned long tmp___7 ; size_t tmp___8 ; int tmp___9 ; unsigned long __ms___2 ; unsigned long tmp___10 ; size_t tmp___11 ; int tmp___12 ; unsigned long __ms___3 ; unsigned long tmp___13 ; size_t tmp___14 ; int tmp___15 ; unsigned long __ms___4 ; unsigned long tmp___16 ; size_t tmp___17 ; int tmp___18 ; unsigned long __ms___5 ; unsigned long tmp___19 ; { tmp = strlen((char const *)MInit_1); modem_write_cmd(cs, (u_char *)MInit_1, (int )tmp); timeout = 1000; goto ldv_41489; ldv_41488: __const_udelay(4295000UL); ldv_41489: tmp___0 = timeout; timeout = timeout - 1; if (tmp___0 != 0 && cs->hw.elsa.transcnt != 0U) { goto ldv_41488; } else { } debugl1(cs, (char *)"msi tout=%d", timeout); __ms = 20UL; goto ldv_41493; ldv_41492: __const_udelay(4295000UL); ldv_41493: tmp___1 = __ms; __ms = __ms - 1UL; if (tmp___1 != 0UL) { goto ldv_41492; } else { } tmp___2 = strlen((char const *)MInit_2); modem_write_cmd(cs, (u_char *)MInit_2, (int )tmp___2); timeout = 1000; goto ldv_41496; ldv_41495: __const_udelay(4295000UL); ldv_41496: tmp___3 = timeout; timeout = timeout - 1; if (tmp___3 != 0 && cs->hw.elsa.transcnt != 0U) { goto ldv_41495; } else { } debugl1(cs, (char *)"msi tout=%d", timeout); __ms___0 = 20UL; goto ldv_41500; ldv_41499: __const_udelay(4295000UL); ldv_41500: tmp___4 = __ms___0; __ms___0 = __ms___0 - 1UL; if (tmp___4 != 0UL) { goto ldv_41499; } else { } tmp___5 = strlen((char const *)MInit_3); modem_write_cmd(cs, (u_char *)MInit_3, (int )tmp___5); timeout = 1000; goto ldv_41503; ldv_41502: __const_udelay(4295000UL); ldv_41503: tmp___6 = timeout; timeout = timeout - 1; if (tmp___6 != 0 && cs->hw.elsa.transcnt != 0U) { goto ldv_41502; } else { } debugl1(cs, (char *)"msi tout=%d", timeout); __ms___1 = 20UL; goto ldv_41507; ldv_41506: __const_udelay(4295000UL); ldv_41507: tmp___7 = __ms___1; __ms___1 = __ms___1 - 1UL; if (tmp___7 != 0UL) { goto ldv_41506; } else { } tmp___8 = strlen((char const *)MInit_4); modem_write_cmd(cs, (u_char *)MInit_4, (int )tmp___8); timeout = 1000; goto ldv_41510; ldv_41509: __const_udelay(4295000UL); ldv_41510: tmp___9 = timeout; timeout = timeout - 1; if (tmp___9 != 0 && cs->hw.elsa.transcnt != 0U) { goto ldv_41509; } else { } debugl1(cs, (char *)"msi tout=%d", timeout); __ms___2 = 20UL; goto ldv_41514; ldv_41513: __const_udelay(4295000UL); ldv_41514: tmp___10 = __ms___2; __ms___2 = __ms___2 - 1UL; if (tmp___10 != 0UL) { goto ldv_41513; } else { } tmp___11 = strlen((char const *)MInit_5); modem_write_cmd(cs, (u_char *)MInit_5, (int )tmp___11); timeout = 1000; goto ldv_41517; ldv_41516: __const_udelay(4295000UL); ldv_41517: tmp___12 = timeout; timeout = timeout - 1; if (tmp___12 != 0 && cs->hw.elsa.transcnt != 0U) { goto ldv_41516; } else { } debugl1(cs, (char *)"msi tout=%d", timeout); __ms___3 = 20UL; goto ldv_41521; ldv_41520: __const_udelay(4295000UL); ldv_41521: tmp___13 = __ms___3; __ms___3 = __ms___3 - 1UL; if (tmp___13 != 0UL) { goto ldv_41520; } else { } tmp___14 = strlen((char const *)MInit_6); modem_write_cmd(cs, (u_char *)MInit_6, (int )tmp___14); timeout = 1000; goto ldv_41524; ldv_41523: __const_udelay(4295000UL); ldv_41524: tmp___15 = timeout; timeout = timeout - 1; if (tmp___15 != 0 && cs->hw.elsa.transcnt != 0U) { goto ldv_41523; } else { } debugl1(cs, (char *)"msi tout=%d", timeout); __ms___4 = 20UL; goto ldv_41528; ldv_41527: __const_udelay(4295000UL); ldv_41528: tmp___16 = __ms___4; __ms___4 = __ms___4 - 1UL; if (tmp___16 != 0UL) { goto ldv_41527; } else { } tmp___17 = strlen((char const *)MInit_7); modem_write_cmd(cs, (u_char *)MInit_7, (int )tmp___17); timeout = 1000; goto ldv_41531; ldv_41530: __const_udelay(4295000UL); ldv_41531: tmp___18 = timeout; timeout = timeout - 1; if (tmp___18 != 0 && cs->hw.elsa.transcnt != 0U) { goto ldv_41530; } else { } debugl1(cs, (char *)"msi tout=%d", timeout); __ms___5 = 20UL; goto ldv_41535; ldv_41534: __const_udelay(4295000UL); ldv_41535: tmp___19 = __ms___5; __ms___5 = __ms___5 - 1UL; if (tmp___19 != 0UL) { goto ldv_41534; } else { } return; } } static void modem_set_dial(struct IsdnCardState *cs , int outgoing ) { int timeout ; size_t tmp ; int tmp___0 ; unsigned long __ms ; unsigned long tmp___1 ; size_t tmp___2 ; size_t tmp___3 ; int tmp___4 ; unsigned long __ms___0 ; unsigned long tmp___5 ; { tmp = strlen((char const *)MInit_speed28800); modem_write_cmd(cs, (u_char *)MInit_speed28800, (int )tmp); timeout = 1000; goto ldv_41543; ldv_41542: __const_udelay(4295000UL); ldv_41543: tmp___0 = timeout; timeout = timeout - 1; if (tmp___0 != 0 && cs->hw.elsa.transcnt != 0U) { goto ldv_41542; } else { } debugl1(cs, (char *)"msi tout=%d", timeout); __ms = 20UL; goto ldv_41547; ldv_41546: __const_udelay(4295000UL); ldv_41547: tmp___1 = __ms; __ms = __ms - 1UL; if (tmp___1 != 0UL) { goto ldv_41546; } else { } if (outgoing != 0) { tmp___2 = strlen((char const *)MInit_dialout); modem_write_cmd(cs, (u_char *)MInit_dialout, (int )tmp___2); } else { tmp___3 = strlen((char const *)MInit_dialin); modem_write_cmd(cs, (u_char *)MInit_dialin, (int )tmp___3); } timeout = 1000; goto ldv_41550; ldv_41549: __const_udelay(4295000UL); ldv_41550: tmp___4 = timeout; timeout = timeout - 1; if (tmp___4 != 0 && cs->hw.elsa.transcnt != 0U) { goto ldv_41549; } else { } debugl1(cs, (char *)"msi tout=%d", timeout); __ms___0 = 20UL; goto ldv_41554; ldv_41553: __const_udelay(4295000UL); ldv_41554: tmp___5 = __ms___0; __ms___0 = __ms___0 - 1UL; if (tmp___5 != 0UL) { goto ldv_41553; } else { } return; } } static void modem_l2l1(struct PStack *st , int pr , void *arg ) { struct BCState *bcs ; struct sk_buff *skb ; u_long flags ; raw_spinlock_t *tmp ; int tmp___0 ; { bcs = st->l1.bcs; skb = (struct sk_buff *)arg; if (pr == 288) { tmp = spinlock_check(& (bcs->cs)->lock); flags = _raw_spin_lock_irqsave(tmp); if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { skb_queue_tail(& bcs->squeue, skb); } else { bcs->tx_skb = skb; test_and_set_bit(3, (unsigned long volatile *)(& bcs->Flag)); bcs->hw.hscx.count = 0; write_modem(bcs); } spin_unlock_irqrestore(& (bcs->cs)->lock, flags); } else if (pr == 256) { test_and_set_bit(2, (unsigned long volatile *)(& bcs->Flag)); (*(st->l1.l1l2))(st, 257, 0); set_arcofi(bcs->cs, st->l1.bc); mstartup(bcs->cs); tmp___0 = constant_test_bit(2U, (unsigned long const volatile *)(& st->l2.flag)); modem_set_dial(bcs->cs, tmp___0); (bcs->cs)->hw.elsa.MFlag = 2U; } else if (pr == 272) { test_and_clear_bit(2, (unsigned long volatile *)(& bcs->Flag)); (bcs->cs)->dc.isac.arcofi_bc = (u_char )st->l1.bc; arcofi_fsm(bcs->cs, 1, (void *)(& ARCOFI_XOP_0)); interruptible_sleep_on(& (bcs->cs)->dc.isac.arcofi_wait); (bcs->cs)->hw.elsa.MFlag = 1U; } else { printk("\fElsaSer: unknown pr %x\n", pr); } return; } } static int setstack_elsa(struct PStack *st , struct BCState *bcs ) { int tmp ; int tmp___0 ; { bcs->channel = st->l1.bc; switch (st->l1.mode) { case 2: ; case 1: tmp = open_hscxstate((struct IsdnCardState *)st->l1.hardware, bcs); if (tmp != 0) { return (-1); } else { } st->l2.l2l1 = & hscx_l2l1; goto ldv_41573; case 7: bcs->mode = 7; tmp___0 = test_and_set_bit(1, (unsigned long volatile *)(& bcs->Flag)); if (tmp___0 == 0) { bcs->hw.hscx.rcvbuf = (bcs->cs)->hw.elsa.rcvbuf; skb_queue_head_init(& bcs->rqueue); skb_queue_head_init(& bcs->squeue); } else { } bcs->tx_skb = 0; test_and_clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); bcs->event = 0UL; bcs->hw.hscx.rcvidx = 0; bcs->tx_cnt = 0; (bcs->cs)->hw.elsa.bcs = bcs; st->l2.l2l1 = & modem_l2l1; goto ldv_41573; } ldv_41573: st->l1.bcs = bcs; setstack_manager(st); bcs->st = st; setstack_l1_B(st); return (0); } } static void init_modem(struct IsdnCardState *cs ) { u_char *tmp ; void *tmp___0 ; u_char *tmp___1 ; void *tmp___2 ; int tmp___3 ; { cs->bcs[0].BC_SetStack = & setstack_elsa; cs->bcs[1].BC_SetStack = & setstack_elsa; cs->bcs[0].BC_Close = & close_elsastate; cs->bcs[1].BC_Close = & close_elsastate; tmp___0 = kmalloc(256UL, 32U); tmp = (u_char *)tmp___0; cs->hw.elsa.rcvbuf = tmp; if ((unsigned long )tmp == (unsigned long )((u_char *)0)) { printk("\fElsa: No modem mem hw.elsa.rcvbuf\n"); return; } else { } tmp___2 = kmalloc(256UL, 32U); tmp___1 = (u_char *)tmp___2; cs->hw.elsa.transbuf = tmp___1; if ((unsigned long )tmp___1 == (unsigned long )((u_char *)0)) { printk("\fElsa: No modem mem hw.elsa.transbuf\n"); kfree((void const *)cs->hw.elsa.rcvbuf); cs->hw.elsa.rcvbuf = 0; return; } else { } tmp___3 = mstartup(cs); if (tmp___3 != 0) { printk("\fElsa: problem startup modem\n"); } else { } modem_set_init(cs); return; } } static void release_modem(struct IsdnCardState *cs ) { { cs->hw.elsa.MFlag = 0U; if ((unsigned long )cs->hw.elsa.transbuf != (unsigned long )((u_char *)0)) { if ((unsigned long )cs->hw.elsa.rcvbuf != (unsigned long )((u_char *)0)) { mshutdown(cs); kfree((void const *)cs->hw.elsa.rcvbuf); cs->hw.elsa.rcvbuf = 0; } else { } kfree((void const *)cs->hw.elsa.transbuf); cs->hw.elsa.transbuf = 0; } else { } return; } } __inline static u_char readreg___1(unsigned int ale , unsigned int adr , u_char off ) { register u_char ret ; { outb((int )off, (int )ale); ret = inb((int )adr); return (ret); } } __inline static void readfifo(unsigned int ale , unsigned int adr , u_char off , u_char *data , int size ) { { outb((int )off, (int )ale); insb((int )adr, (void *)data, (unsigned long )size); return; } } __inline static void writereg___1(unsigned int ale , unsigned int adr , u_char off , u_char data ) { { outb((int )off, (int )ale); outb((int )data, (int )adr); return; } } __inline static void writefifo(unsigned int ale , unsigned int adr , u_char off , u_char *data , int size ) { { outb((int )off, (int )ale); outsb((int )adr, (void const *)data, (unsigned long )size); return; } } static u_char ReadISAC___4(struct IsdnCardState *cs , u_char offset ) { u_char tmp ; { tmp = readreg___1(cs->hw.elsa.ale, cs->hw.elsa.isac, (int )offset); return (tmp); } } static void WriteISAC___4(struct IsdnCardState *cs , u_char offset , u_char value ) { { writereg___1(cs->hw.elsa.ale, cs->hw.elsa.isac, (int )offset, (int )value); return; } } static void ReadISACfifo___4(struct IsdnCardState *cs , u_char *data , int size ) { { readfifo(cs->hw.elsa.ale, cs->hw.elsa.isac, 0, data, size); return; } } static void WriteISACfifo___4(struct IsdnCardState *cs , u_char *data , int size ) { { writefifo(cs->hw.elsa.ale, cs->hw.elsa.isac, 0, data, size); return; } } static u_char ReadISAC_IPAC(struct IsdnCardState *cs , u_char offset ) { u_char tmp ; { tmp = readreg___1(cs->hw.elsa.ale, cs->hw.elsa.isac, (int )((unsigned int )offset + 128U)); return (tmp); } } static void WriteISAC_IPAC(struct IsdnCardState *cs , u_char offset , u_char value ) { { writereg___1(cs->hw.elsa.ale, cs->hw.elsa.isac, (int )((unsigned int )offset | 128U), (int )value); return; } } static void ReadISACfifo_IPAC(struct IsdnCardState *cs , u_char *data , int size ) { { readfifo(cs->hw.elsa.ale, cs->hw.elsa.isac, 128, data, size); return; } } static void WriteISACfifo_IPAC(struct IsdnCardState *cs , u_char *data , int size ) { { writefifo(cs->hw.elsa.ale, cs->hw.elsa.isac, 128, data, size); return; } } static u_char ReadHSCX___3(struct IsdnCardState *cs , int hscx , u_char offset ) { u_char tmp ; { tmp = readreg___1(cs->hw.elsa.ale, cs->hw.elsa.hscx, (int )((hscx != 0 ? 64U : 0U) + (unsigned int )offset)); return (tmp); } } static void WriteHSCX___3(struct IsdnCardState *cs , int hscx , u_char offset , u_char value ) { { writereg___1(cs->hw.elsa.ale, cs->hw.elsa.hscx, (int )((hscx != 0 ? 64U : 0U) + (unsigned int )offset), (int )value); return; } } __inline static u_char readitac(struct IsdnCardState *cs , u_char off ) { register u_char ret ; { outb((int )off, (int )cs->hw.elsa.ale); ret = inb((int )cs->hw.elsa.itac); return (ret); } } __inline static void writeitac(struct IsdnCardState *cs , u_char off , u_char data ) { { outb((int )off, (int )cs->hw.elsa.ale); outb((int )data, (int )cs->hw.elsa.itac); return; } } __inline static int TimerRun(struct IsdnCardState *cs ) { register u_char v ; { v = inb((int )cs->hw.elsa.cfg); if ((unsigned int )cs->subtyp == 7U || (unsigned int )cs->subtyp == 8U) { return (((int )v & 2) == 0); } else if ((unsigned int )cs->subtyp == 2U) { return ((int )v & 1); } else { } return ((int )v & 2); } } __inline static void waitforCEC___3(struct IsdnCardState *cs , int hscx ) { int to ; u_char tmp ; { to = 50; goto ldv_41676; ldv_41675: __const_udelay(4295UL); to = to - 1; ldv_41676: tmp = readreg___1(cs->hw.elsa.ale, cs->hw.elsa.hscx, hscx != 0 ? 97 : 33); if (((int )tmp & 4) != 0 && to != 0) { goto ldv_41675; } else { } if (to == 0) { printk("\fHiSax: waitforCEC timeout\n"); } else { } return; } } __inline static void waitforXFW___3(struct IsdnCardState *cs , int hscx ) { int to ; u_char tmp ; { to = 50; goto ldv_41684; ldv_41683: __const_udelay(4295UL); to = to - 1; ldv_41684: tmp = readreg___1(cs->hw.elsa.ale, cs->hw.elsa.hscx, hscx != 0 ? 97 : 33); if (((int )tmp & 68) != 64 && to != 0) { goto ldv_41683; } else { } if (to == 0) { printk("\fHiSax: waitforXFW timeout\n"); } else { } return; } } __inline static void WriteHSCXCMDR___3(struct IsdnCardState *cs , int hscx , u_char data ) { { waitforCEC___3(cs, hscx); writereg___1(cs->hw.elsa.ale, cs->hw.elsa.hscx, hscx != 0 ? 97 : 33, (int )data); return; } } static void hscx_empty_fifo___3(struct BCState *bcs , int count ) { u_char *ptr ; struct IsdnCardState *cs ; char *t ; int tmp ; { cs = bcs->cs; if ((cs->debug & 16) != 0 && (cs->debug & 32) == 0) { debugl1(cs, (char *)"hscx_empty_fifo"); } else { } if (bcs->hw.hscx.rcvidx + count > 4096) { if (cs->debug & 1) { debugl1(cs, (char *)"hscx_empty_fifo: incoming packet too large"); } else { } WriteHSCXCMDR___3(cs, bcs->hw.hscx.hscx, 128); bcs->hw.hscx.rcvidx = 0; return; } else { } ptr = bcs->hw.hscx.rcvbuf + (unsigned long )bcs->hw.hscx.rcvidx; bcs->hw.hscx.rcvidx = bcs->hw.hscx.rcvidx + count; readfifo(cs->hw.elsa.ale, cs->hw.elsa.hscx, bcs->hw.hscx.hscx != 0 ? 64 : 0, ptr, count); WriteHSCXCMDR___3(cs, bcs->hw.hscx.hscx, 128); if ((cs->debug & 32) != 0) { t = (char *)bcs->blog; tmp = sprintf(t, "hscx_empty_fifo %c cnt %d", bcs->hw.hscx.hscx != 0 ? 66 : 65, count); t = t + (unsigned long )tmp; QuickHex(t, ptr, count); debugl1(cs, (char *)bcs->blog); } else { } return; } } static void hscx_fill_fifo___3(struct BCState *bcs ) { struct IsdnCardState *cs ; int more ; int count ; int fifo_size ; int tmp ; u_char *ptr ; char *t ; int tmp___0 ; { cs = bcs->cs; tmp = constant_test_bit(1U, (unsigned long const volatile *)(& cs->HW_Flags)); fifo_size = tmp != 0 ? 64 : 32; if ((cs->debug & 16) != 0 && (cs->debug & 32) == 0) { debugl1(cs, (char *)"hscx_fill_fifo"); } else { } if ((unsigned long )bcs->tx_skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } if ((bcs->tx_skb)->len == 0U) { return; } else { } more = bcs->mode == 1; if ((bcs->tx_skb)->len > (unsigned int )fifo_size) { more = 1; count = fifo_size; } else { count = (int )(bcs->tx_skb)->len; } waitforXFW___3(cs, bcs->hw.hscx.hscx); ptr = (bcs->tx_skb)->data; skb_pull(bcs->tx_skb, (unsigned int )count); bcs->tx_cnt = bcs->tx_cnt - count; bcs->hw.hscx.count = bcs->hw.hscx.count + count; writefifo(cs->hw.elsa.ale, cs->hw.elsa.hscx, bcs->hw.hscx.hscx != 0 ? 64 : 0, ptr, count); WriteHSCXCMDR___3(cs, bcs->hw.hscx.hscx, more != 0 ? 8 : 10); if ((cs->debug & 32) != 0) { t = (char *)bcs->blog; tmp___0 = sprintf(t, "hscx_fill_fifo %c cnt %d", bcs->hw.hscx.hscx != 0 ? 66 : 65, count); t = t + (unsigned long )tmp___0; QuickHex(t, ptr, count); debugl1(cs, (char *)bcs->blog); } else { } return; } } static void hscx_interrupt___3(struct IsdnCardState *cs , u_char val , u_char hscx ) { u_char r ; struct BCState *bcs ; struct sk_buff *skb ; int fifo_size ; int tmp ; int count ; int tmp___0 ; u_char tmp___1 ; int tmp___2 ; size_t __len ; void *__ret ; unsigned char *tmp___4 ; size_t __len___0 ; void *__ret___0 ; unsigned char *tmp___6 ; u_long flags ; raw_spinlock_t *tmp___7 ; int tmp___8 ; struct sk_buff *tmp___9 ; { bcs = (struct BCState *)(& cs->bcs) + (unsigned long )hscx; tmp = constant_test_bit(1U, (unsigned long const volatile *)(& cs->HW_Flags)); fifo_size = tmp != 0 ? 64 : 32; tmp___0 = constant_test_bit(1U, (unsigned long const volatile *)(& bcs->Flag)); if (tmp___0 == 0) { return; } else { } if ((int )((signed char )val) < 0) { r = readreg___1(cs->hw.elsa.ale, cs->hw.elsa.hscx, (unsigned int )hscx != 0U ? 103 : 39); if (((int )r & 240) != 160) { if ((int )((signed char )r) >= 0) { if (cs->debug & 1) { debugl1(cs, (char *)"HSCX invalid frame"); } else { } bcs->err_inv = bcs->err_inv + 1; } else { } if (((int )r & 64) != 0 && bcs->mode != 0) { if (cs->debug & 1) { debugl1(cs, (char *)"HSCX RDO mode=%d", bcs->mode); } else { } bcs->err_rdo = bcs->err_rdo + 1; } else { } if (((int )r & 32) == 0) { if (cs->debug & 1) { debugl1(cs, (char *)"HSCX CRC error"); } else { } bcs->err_crc = bcs->err_crc + 1; } else { } WriteHSCXCMDR___3(cs, (int )hscx, 128); } else { tmp___1 = readreg___1(cs->hw.elsa.ale, cs->hw.elsa.hscx, (unsigned int )hscx != 0U ? 101 : 37); tmp___2 = constant_test_bit(1U, (unsigned long const volatile *)(& cs->HW_Flags)); count = (int )tmp___1 & (tmp___2 != 0 ? 63 : 31); if (count == 0) { count = fifo_size; } else { } hscx_empty_fifo___3(bcs, count); count = bcs->hw.hscx.rcvidx + -1; if (count > 0) { if ((cs->debug & 32) != 0) { debugl1(cs, (char *)"HX Frame %d", count); } else { } skb = dev_alloc_skb((unsigned int )count); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { printk("\fHSCX: receive out of memory\n"); } else { __len = (size_t )count; tmp___4 = skb_put(skb, (unsigned int )count); __ret = memcpy((void *)tmp___4, (void const *)bcs->hw.hscx.rcvbuf, __len); skb_queue_tail(& bcs->rqueue, skb); } } else { } } bcs->hw.hscx.rcvidx = 0; test_and_set_bit(0, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } if (((int )val & 64) != 0) { hscx_empty_fifo___3(bcs, fifo_size); if (bcs->mode == 1) { skb = dev_alloc_skb((unsigned int )fifo_size); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { printk("\fHiSax: receive out of memory\n"); } else { __len___0 = (size_t )fifo_size; tmp___6 = skb_put(skb, (unsigned int )fifo_size); __ret___0 = memcpy((void *)tmp___6, (void const *)bcs->hw.hscx.rcvbuf, __len___0); skb_queue_tail(& bcs->rqueue, skb); } bcs->hw.hscx.rcvidx = 0; test_and_set_bit(0, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } } else { } if (((int )val & 16) != 0) { if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { if ((bcs->tx_skb)->len != 0U) { hscx_fill_fifo___3(bcs); return; } else { tmp___8 = constant_test_bit(1U, (unsigned long const volatile *)(& (bcs->st)->lli.flag)); if (tmp___8 != 0 && (unsigned int )*((unsigned char *)bcs->tx_skb + 125UL) != 7U) { tmp___7 = spinlock_check(& bcs->aclock); flags = _raw_spin_lock_irqsave(tmp___7); bcs->ackcnt = bcs->ackcnt + bcs->hw.hscx.count; spin_unlock_irqrestore(& bcs->aclock, flags); test_and_set_bit(2, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } dev_kfree_skb_irq(bcs->tx_skb); bcs->hw.hscx.count = 0; bcs->tx_skb = 0; } } else { } tmp___9 = skb_dequeue(& bcs->squeue); bcs->tx_skb = tmp___9; if ((unsigned long )tmp___9 != (unsigned long )((struct sk_buff *)0)) { bcs->hw.hscx.count = 0; test_and_set_bit(3, (unsigned long volatile *)(& bcs->Flag)); hscx_fill_fifo___3(bcs); } else { test_and_clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); test_and_set_bit(1, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } } else { } return; } } static void hscx_int_main___3(struct IsdnCardState *cs , u_char val ) { u_char exval ; struct BCState *bcs ; { if ((int )val & 1) { bcs = (struct BCState *)(& cs->bcs) + 1UL; exval = readreg___1(cs->hw.elsa.ale, cs->hw.elsa.hscx, 100); if (((int )exval & 64) != 0) { if (bcs->mode == 1) { hscx_fill_fifo___3(bcs); } else { bcs->err_tx = bcs->err_tx + 1; if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { skb_push(bcs->tx_skb, (unsigned int )bcs->hw.hscx.count); bcs->tx_cnt = bcs->tx_cnt + bcs->hw.hscx.count; bcs->hw.hscx.count = 0; } else { } WriteHSCXCMDR___3(cs, bcs->hw.hscx.hscx, 1); if (cs->debug & 1) { debugl1(cs, (char *)"HSCX B EXIR %x Lost TX", (int )exval); } else { } } } else if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HSCX B EXIR %x", (int )exval); } else { } } else { } if (((int )val & 248) != 0) { if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HSCX B interrupt %x", (int )val); } else { } hscx_interrupt___3(cs, (int )val, 1); } else { } if (((int )val & 2) != 0) { bcs = (struct BCState *)(& cs->bcs); exval = readreg___1(cs->hw.elsa.ale, cs->hw.elsa.hscx, 36); if (((int )exval & 64) != 0) { if (bcs->mode == 1) { hscx_fill_fifo___3(bcs); } else { bcs->err_tx = bcs->err_tx + 1; if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { skb_push(bcs->tx_skb, (unsigned int )bcs->hw.hscx.count); bcs->tx_cnt = bcs->tx_cnt + bcs->hw.hscx.count; bcs->hw.hscx.count = 0; } else { } WriteHSCXCMDR___3(cs, bcs->hw.hscx.hscx, 1); if (cs->debug & 1) { debugl1(cs, (char *)"HSCX A EXIR %x Lost TX", (int )exval); } else { } } } else if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HSCX A EXIR %x", (int )exval); } else { } } else { } if (((int )val & 4) != 0) { exval = readreg___1(cs->hw.elsa.ale, cs->hw.elsa.hscx, 32); if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HSCX A interrupt %x", (int )exval); } else { } hscx_interrupt___3(cs, (int )exval, 0); } else { } return; } } static irqreturn_t elsa_interrupt(int intno , void *dev_id ) { struct IsdnCardState *cs ; u_long flags ; u_char val ; int icnt ; raw_spinlock_t *tmp ; unsigned int tmp___0 ; int tmp___1 ; unsigned int tmp___2 ; unsigned int tmp___3 ; { cs = (struct IsdnCardState *)dev_id; icnt = 5; if ((unsigned int )cs->typ == 10U && *(cs->busy_flag) == 1) { printk("\fElsa: card not available!\n"); return (0); } else { } tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); if (cs->hw.elsa.MFlag != 0U) { tmp___0 = serial_inp(cs, 2); val = (u_char )tmp___0; if (((int )val & 1) == 0) { debugl1(cs, (char *)"IIR %02x", (int )val); rs_interrupt_elsa(cs); } else { } } else { } val = readreg___1(cs->hw.elsa.ale, cs->hw.elsa.hscx, 96); Start_HSCX: ; if ((unsigned int )val != 0U) { hscx_int_main___3(cs, (int )val); } else { } val = readreg___1(cs->hw.elsa.ale, cs->hw.elsa.isac, 32); Start_ISAC: ; if ((unsigned int )val != 0U) { isac_interrupt(cs, (int )val); } else { } val = readreg___1(cs->hw.elsa.ale, cs->hw.elsa.hscx, 96); if ((unsigned int )val != 0U && icnt != 0) { if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HSCX IntStat after IntRoutine"); } else { } icnt = icnt - 1; goto Start_HSCX; } else { } val = readreg___1(cs->hw.elsa.ale, cs->hw.elsa.isac, 32); if ((unsigned int )val != 0U && icnt != 0) { if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"ISAC IntStat after IntRoutine"); } else { } icnt = icnt - 1; goto Start_ISAC; } else { } if (icnt == 0) { printk("\fELSA IRQ LOOP\n"); } else { } writereg___1(cs->hw.elsa.ale, cs->hw.elsa.hscx, 32, 255); writereg___1(cs->hw.elsa.ale, cs->hw.elsa.hscx, 96, 255); writereg___1(cs->hw.elsa.ale, cs->hw.elsa.isac, 32, 255); if ((int )cs->hw.elsa.status & 1) { tmp___1 = TimerRun(cs); if (tmp___1 == 0) { outb(0, (int )cs->hw.elsa.timer); cs->hw.elsa.counter = cs->hw.elsa.counter + 1U; } else { } } else { } if (cs->hw.elsa.MFlag != 0U) { tmp___2 = serial_inp(cs, 4); val = (u_char )tmp___2; val = (u_char )((unsigned int )val ^ 8U); serial_outp(cs, 4, (int )val); tmp___3 = serial_inp(cs, 4); val = (u_char )tmp___3; val = (u_char )((unsigned int )val ^ 8U); serial_outp(cs, 4, (int )val); } else { } if (cs->hw.elsa.trig != 0U) { outb(0, (int )cs->hw.elsa.trig); } else { } writereg___1(cs->hw.elsa.ale, cs->hw.elsa.hscx, 32, 0); writereg___1(cs->hw.elsa.ale, cs->hw.elsa.hscx, 96, 0); writereg___1(cs->hw.elsa.ale, cs->hw.elsa.isac, 32, 0); spin_unlock_irqrestore(& cs->lock, flags); return (1); } } static irqreturn_t elsa_interrupt_ipac(int intno , void *dev_id ) { struct IsdnCardState *cs ; u_long flags ; u_char ista ; u_char val ; int icnt ; raw_spinlock_t *tmp ; unsigned int tmp___0 ; u_char tmp___1 ; { cs = (struct IsdnCardState *)dev_id; icnt = 5; tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); if ((unsigned int )cs->subtyp == 9U || (unsigned int )cs->subtyp == 10U) { val = inb((int )(cs->hw.elsa.cfg + 76U)); if (((int )val & 4) == 0) { spin_unlock_irqrestore(& cs->lock, flags); return (0); } else { } } else { } if (cs->hw.elsa.MFlag != 0U) { tmp___0 = serial_inp(cs, 2); val = (u_char )tmp___0; if (((int )val & 1) == 0) { debugl1(cs, (char *)"IIR %02x", (int )val); rs_interrupt_elsa(cs); } else { } } else { } ista = readreg___1(cs->hw.elsa.ale, cs->hw.elsa.isac, 193); Start_IPAC: ; if ((cs->debug & 128) != 0) { debugl1(cs, (char *)"IPAC ISTA %02X", (int )ista); } else { } if (((int )ista & 15) != 0) { val = readreg___1(cs->hw.elsa.ale, cs->hw.elsa.hscx, 96); if ((int )ista & 1) { val = (u_char )((unsigned int )val | 1U); } else { } if (((int )ista & 4) != 0) { val = (u_char )((unsigned int )val | 2U); } else { } if (((int )ista & 8) != 0) { val = (u_char )((unsigned int )val | 4U); } else { } if ((unsigned int )val != 0U) { hscx_int_main___3(cs, (int )val); } else { } } else { } if (((int )ista & 32) != 0) { tmp___1 = readreg___1(cs->hw.elsa.ale, cs->hw.elsa.isac, 160); val = (unsigned int )tmp___1 & 254U; if ((unsigned int )val != 0U) { isac_interrupt(cs, (int )val); } else { } } else { } if (((int )ista & 16) != 0) { val = 1U; isac_interrupt(cs, (int )val); } else { } ista = readreg___1(cs->hw.elsa.ale, cs->hw.elsa.isac, 193); if (((int )ista & 63) != 0 && icnt != 0) { icnt = icnt - 1; goto Start_IPAC; } else { } if (icnt == 0) { printk("\fELSA IRQ LOOP\n"); } else { } writereg___1(cs->hw.elsa.ale, cs->hw.elsa.isac, 193, 255); writereg___1(cs->hw.elsa.ale, cs->hw.elsa.isac, 193, 192); spin_unlock_irqrestore(& cs->lock, flags); return (1); } } static void release_io_elsa(struct IsdnCardState *cs ) { int bytecnt ; { bytecnt = 8; del_timer(& cs->hw.elsa.tl); clear_arcofi(cs); if (cs->hw.elsa.ctrl != 0U) { outb(0, (int )cs->hw.elsa.ctrl); } else { } if ((unsigned int )cs->subtyp == 9U) { outb(1, (int )(cs->hw.elsa.cfg + 76U)); writereg___1(cs->hw.elsa.ale, cs->hw.elsa.isac, 197, 255); bytecnt = 2; __release_region(& ioport_resource, (resource_size_t )cs->hw.elsa.cfg, 128ULL); } else { } if ((unsigned int )cs->subtyp == 10U) { outb(3, (int )(cs->hw.elsa.cfg + 76U)); writereg___1(cs->hw.elsa.ale, cs->hw.elsa.isac, 197, 255); __release_region(& ioport_resource, (resource_size_t )cs->hw.elsa.cfg, 128ULL); } else { } if ((unsigned int )cs->subtyp == 11U) { writereg___1(cs->hw.elsa.ale, cs->hw.elsa.isac, 197, 255); } else { } if ((((unsigned int )cs->subtyp == 5U || (unsigned int )cs->subtyp == 8U) || (unsigned int )cs->subtyp == 4U) || (unsigned int )cs->subtyp == 10U) { bytecnt = 16; release_modem(cs); } else { } if (cs->hw.elsa.base != 0UL) { __release_region(& ioport_resource, (resource_size_t )cs->hw.elsa.base, (resource_size_t )bytecnt); } else { } return; } } static void reset_elsa(struct IsdnCardState *cs ) { int tmp ; int tmp___0 ; int tmp___1 ; unsigned long __ms ; unsigned long tmp___2 ; unsigned long __ms___0 ; unsigned long tmp___3 ; { if (cs->hw.elsa.timer != 0U) { outb(0, (int )cs->hw.elsa.timer); goto ldv_41767; ldv_41766: ; ldv_41767: tmp = TimerRun(cs); if (tmp != 0) { goto ldv_41766; } else { } cs->hw.elsa.ctrl_reg = (u_char )((unsigned int )cs->hw.elsa.ctrl_reg | 80U); cs->hw.elsa.ctrl_reg = (unsigned int )cs->hw.elsa.ctrl_reg & 223U; outb((int )cs->hw.elsa.ctrl_reg, (int )cs->hw.elsa.ctrl); outb(0, (int )cs->hw.elsa.timer); goto ldv_41770; ldv_41769: ; ldv_41770: tmp___0 = TimerRun(cs); if (tmp___0 != 0) { goto ldv_41769; } else { } cs->hw.elsa.ctrl_reg = (u_char )((unsigned int )cs->hw.elsa.ctrl_reg | 32U); outb((int )cs->hw.elsa.ctrl_reg, (int )cs->hw.elsa.ctrl); outb(0, (int )cs->hw.elsa.timer); goto ldv_41773; ldv_41772: ; ldv_41773: tmp___1 = TimerRun(cs); if (tmp___1 != 0) { goto ldv_41772; } else { } if (cs->hw.elsa.trig != 0U) { outb(255, (int )cs->hw.elsa.trig); } else { } } else { } if (((unsigned int )cs->subtyp == 9U || (unsigned int )cs->subtyp == 10U) || (unsigned int )cs->subtyp == 11U) { writereg___1(cs->hw.elsa.ale, cs->hw.elsa.isac, 201, 32); __ms = 10UL; goto ldv_41777; ldv_41776: __const_udelay(4295000UL); ldv_41777: tmp___2 = __ms; __ms = __ms - 1UL; if (tmp___2 != 0UL) { goto ldv_41776; } else { } writereg___1(cs->hw.elsa.ale, cs->hw.elsa.isac, 201, 0); writereg___1(cs->hw.elsa.ale, cs->hw.elsa.isac, 193, 192); __ms___0 = 10UL; goto ldv_41781; ldv_41780: __const_udelay(4295000UL); ldv_41781: tmp___3 = __ms___0; __ms___0 = __ms___0 - 1UL; if (tmp___3 != 0UL) { goto ldv_41780; } else { } if ((unsigned int )cs->subtyp != 11U) { writereg___1(cs->hw.elsa.ale, cs->hw.elsa.isac, 195, 0); writereg___1(cs->hw.elsa.ale, cs->hw.elsa.isac, 196, 60); } else { writereg___1(cs->hw.elsa.ale, cs->hw.elsa.isac, 202, 16); writereg___1(cs->hw.elsa.ale, cs->hw.elsa.isac, 195, 4); writereg___1(cs->hw.elsa.ale, cs->hw.elsa.isac, 196, 248); } writereg___1(cs->hw.elsa.ale, cs->hw.elsa.isac, 197, 255); if ((unsigned int )cs->subtyp == 9U) { outb(65, (int )(cs->hw.elsa.cfg + 76U)); } else if ((unsigned int )cs->subtyp == 10U) { outb(67, (int )(cs->hw.elsa.cfg + 76U)); } else { } } else { } return; } } static void set_arcofi(struct IsdnCardState *cs , int bc ) { { cs->dc.isac.arcofi_bc = (u_char )bc; arcofi_fsm(cs, 1, (void *)(& ARCOFI_COP_5)); interruptible_sleep_on(& cs->dc.isac.arcofi_wait); return; } } static int check_arcofi(struct IsdnCardState *cs ) { int arcofi_present ; char tmp[40U] ; char *t ; u_char *p ; u_char *tmp___0 ; void *tmp___1 ; int tmp___2 ; int tmp___3 ; struct resource *tmp___4 ; struct resource *tmp___5 ; { arcofi_present = 0; if ((unsigned long )cs->dc.isac.mon_tx == (unsigned long )((u_char *)0)) { tmp___1 = kmalloc(32UL, 32U); tmp___0 = (u_char *)tmp___1; cs->dc.isac.mon_tx = tmp___0; if ((unsigned long )tmp___0 == (unsigned long )((u_char *)0)) { if (cs->debug & 1) { debugl1(cs, (char *)"ISAC MON TX out of buffers!"); } else { } return (0); } else { } } else { } cs->dc.isac.arcofi_bc = 0U; arcofi_fsm(cs, 1, (void *)(& ARCOFI_VERSION)); interruptible_sleep_on(& cs->dc.isac.arcofi_wait); tmp___3 = test_and_clear_bit(9, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___3 == 0) { debugl1(cs, (char *)"Arcofi response received %d bytes", cs->dc.isac.mon_rxp); p = cs->dc.isac.mon_rx; t = (char *)(& tmp); tmp___2 = sprintf((char *)(& tmp), "Arcofi data"); t = t + (unsigned long )tmp___2; QuickHex(t, p, cs->dc.isac.mon_rxp); debugl1(cs, (char *)(& tmp)); if (cs->dc.isac.mon_rxp == 2 && (unsigned int )*(cs->dc.isac.mon_rx) == 160U) { switch ((int )*(cs->dc.isac.mon_rx + 1UL)) { case 128: debugl1(cs, (char *)"Arcofi 2160 detected"); arcofi_present = 1; goto ldv_41795; case 130: debugl1(cs, (char *)"Arcofi 2165 detected"); arcofi_present = 2; goto ldv_41795; case 132: debugl1(cs, (char *)"Arcofi 2163 detected"); arcofi_present = 3; goto ldv_41795; default: debugl1(cs, (char *)"unknown Arcofi response"); goto ldv_41795; } ldv_41795: ; } else { debugl1(cs, (char *)"undefined Monitor response"); } cs->dc.isac.mon_rxp = 0; } else if ((unsigned long )cs->dc.isac.mon_tx != (unsigned long )((u_char *)0)) { debugl1(cs, (char *)"Arcofi not detected"); } else { } if (arcofi_present != 0) { if ((unsigned int )cs->subtyp == 7U) { cs->subtyp = 8U; printk("\016Elsa: %s detected modem at 0x%lx\n", Elsa_Types[(int )cs->subtyp], cs->hw.elsa.base + 8UL); __release_region(& ioport_resource, (resource_size_t )cs->hw.elsa.base, 8ULL); tmp___4 = __request_region(& ioport_resource, (resource_size_t )cs->hw.elsa.base, 16ULL, "elsa isdn modem", 0); if ((unsigned long )tmp___4 == (unsigned long )((struct resource *)0)) { printk("\fHiSax: %s config port %lx-%lx already in use\n", Elsa_Types[(int )cs->subtyp], cs->hw.elsa.base + 8UL, cs->hw.elsa.base + 16UL); } else { } } else if ((unsigned int )cs->subtyp == 3U) { cs->subtyp = 4U; printk("\016Elsa: %s detected modem at 0x%lx\n", Elsa_Types[(int )cs->subtyp], cs->hw.elsa.base + 8UL); __release_region(& ioport_resource, (resource_size_t )cs->hw.elsa.base, 8ULL); tmp___5 = __request_region(& ioport_resource, (resource_size_t )cs->hw.elsa.base, 16ULL, "elsa isdn modem", 0); if ((unsigned long )tmp___5 == (unsigned long )((struct resource *)0)) { printk("\fHiSax: %s config port %lx-%lx already in use\n", Elsa_Types[(int )cs->subtyp], cs->hw.elsa.base + 8UL, cs->hw.elsa.base + 16UL); } else { } } else { printk("\016Elsa: %s detected modem at 0x%lx\n", Elsa_Types[(int )cs->subtyp], cs->hw.elsa.base + 8UL); } arcofi_fsm(cs, 1, (void *)(& ARCOFI_XOP_0)); interruptible_sleep_on(& cs->dc.isac.arcofi_wait); return (1); } else { } return (0); } } static void elsa_led_handler(struct IsdnCardState *cs ) { int blink ; u_char led ; struct lock_class_key __key ; { blink = 0; if ((unsigned int )cs->subtyp == 6U || (unsigned int )cs->subtyp == 11U) { return; } else { } del_timer(& cs->hw.elsa.tl); if ((cs->hw.elsa.status & 4U) != 0U) { cs->hw.elsa.ctrl_reg = (u_char )((unsigned int )cs->hw.elsa.ctrl_reg | 8U); } else if ((cs->hw.elsa.status & 2U) != 0U) { cs->hw.elsa.ctrl_reg = (unsigned int )cs->hw.elsa.ctrl_reg & 247U; } else { cs->hw.elsa.ctrl_reg = (u_char )((unsigned int )cs->hw.elsa.ctrl_reg ^ 8U); blink = 250; } if ((cs->hw.elsa.status & 61440U) != 0U) { cs->hw.elsa.ctrl_reg = (u_char )((unsigned int )cs->hw.elsa.ctrl_reg | 2U); } else if ((cs->hw.elsa.status & 3840U) != 0U) { cs->hw.elsa.ctrl_reg = (u_char )((unsigned int )cs->hw.elsa.ctrl_reg ^ 2U); blink = 500; } else { cs->hw.elsa.ctrl_reg = (unsigned int )cs->hw.elsa.ctrl_reg & 253U; } if ((unsigned int )cs->subtyp == 9U || (unsigned int )cs->subtyp == 10U) { led = 255U; if (((int )cs->hw.elsa.ctrl_reg & 2) != 0) { led = (u_char )((unsigned int )led ^ 64U); } else { } if (((int )cs->hw.elsa.ctrl_reg & 8) != 0) { led = (u_char )((unsigned int )led ^ 128U); } else { } writereg___1(cs->hw.elsa.ale, cs->hw.elsa.isac, 197, (int )led); } else { outb((int )cs->hw.elsa.ctrl_reg, (int )cs->hw.elsa.ctrl); } if (blink != 0) { init_timer_key(& cs->hw.elsa.tl, 0U, "(&cs->hw.elsa.tl)", & __key); cs->hw.elsa.tl.expires = (unsigned long )((blink * 250) / 1000) + (unsigned long )jiffies; add_timer(& cs->hw.elsa.tl); } else { } return; } } static int Elsa_card_msg(struct IsdnCardState *cs , int mt , void *arg ) { int ret ; u_long flags ; raw_spinlock_t *tmp ; raw_spinlock_t *tmp___0 ; raw_spinlock_t *tmp___1 ; raw_spinlock_t *tmp___2 ; int tmp___3 ; int len ; u_char *msg ; int pwr ; unsigned char tmp___4 ; { ret = 0; switch (mt) { case 240: tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); reset_elsa(cs); spin_unlock_irqrestore(& cs->lock, flags); return (0); case 243: release_io_elsa(cs); return (0); case 242: tmp___0 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___0); cs->debug = cs->debug | 128; reset_elsa(cs); inithscxisac(cs, 1); if ((unsigned int )cs->subtyp == 7U || (unsigned int )cs->subtyp == 8U) { outb(0, (int )cs->hw.elsa.timer); } else { } if (cs->hw.elsa.trig != 0U) { outb(255, (int )cs->hw.elsa.trig); } else { } inithscxisac(cs, 2); spin_unlock_irqrestore(& cs->lock, flags); return (0); case 244: ; if (((unsigned int )cs->subtyp == 6U || (unsigned int )cs->subtyp == 11U) || (unsigned int )cs->subtyp == 9U) { return (0); } else if ((unsigned int )cs->subtyp == 10U) { ret = 0; } else { tmp___1 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___1); cs->hw.elsa.counter = 0U; cs->hw.elsa.ctrl_reg = (u_char )((unsigned int )cs->hw.elsa.ctrl_reg | 128U); cs->hw.elsa.status = cs->hw.elsa.status | 1U; outb((int )cs->hw.elsa.ctrl_reg, (int )cs->hw.elsa.ctrl); outb(0, (int )cs->hw.elsa.timer); spin_unlock_irqrestore(& cs->lock, flags); msleep(110U); tmp___2 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___2); cs->hw.elsa.ctrl_reg = (unsigned int )cs->hw.elsa.ctrl_reg & 127U; outb((int )cs->hw.elsa.ctrl_reg, (int )cs->hw.elsa.ctrl); cs->hw.elsa.status = cs->hw.elsa.status & 4294967294U; spin_unlock_irqrestore(& cs->lock, flags); printk("\016Elsa: %d timer tics in 110 msek\n", cs->hw.elsa.counter); if (cs->hw.elsa.counter > 10U && cs->hw.elsa.counter <= 15U) { printk("\016Elsa: timer and irq OK\n"); ret = 0; } else { printk("\fElsa: timer tic problem (%d/12) maybe an IRQ(%d) conflict\n", cs->hw.elsa.counter, cs->irq); ret = 1; } } tmp___3 = check_arcofi(cs); if (tmp___3 != 0) { init_modem(cs); } else { } elsa_led_handler(cs); return (ret); case 644: cs->hw.elsa.status = 0U; goto ldv_41829; case 640: cs->hw.elsa.status = cs->hw.elsa.status | 4U; goto ldv_41829; case 736: ; if ((unsigned long )arg != (unsigned long )((void *)0)) { cs->hw.elsa.status = cs->hw.elsa.status | 512U; } else { cs->hw.elsa.status = cs->hw.elsa.status | 256U; } goto ldv_41829; case 740: ; if ((unsigned long )arg != (unsigned long )((void *)0)) { cs->hw.elsa.status = cs->hw.elsa.status | 8192U; } else { cs->hw.elsa.status = cs->hw.elsa.status | 4096U; } goto ldv_41829; case 744: ; if ((unsigned long )arg != (unsigned long )((void *)0)) { cs->hw.elsa.status = cs->hw.elsa.status & 4294959103U; cs->hw.elsa.status = cs->hw.elsa.status & 4294966783U; } else { cs->hw.elsa.status = cs->hw.elsa.status & 4294963199U; cs->hw.elsa.status = cs->hw.elsa.status & 4294967039U; } goto ldv_41829; case 245: ; if (cs->hw.elsa.MFlag != 0U) { if ((unsigned long )arg == (unsigned long )((void *)0)) { return (0); } else { } msg = (u_char *)arg; len = (int )*msg; msg = msg + 1; modem_write_cmd(cs, msg, len); } else { } goto ldv_41829; } ldv_41829: ; if ((unsigned int )cs->typ == 6U) { tmp___4 = inb((int )cs->hw.elsa.ale); pwr = (int )tmp___4; if ((pwr & 8) != 0) { cs->hw.elsa.status = cs->hw.elsa.status | 2U; } else { cs->hw.elsa.status = cs->hw.elsa.status & 4294967293U; } } else { } elsa_led_handler(cs); return (ret); } } static unsigned char probe_elsa_adr(unsigned int adr , int typ ) { int i ; int in1 ; int in2 ; int p16_1 ; int p16_2 ; int p8_1 ; int p8_2 ; int pc_1 ; int pc_2 ; int pfp_1 ; int pfp_2 ; struct resource *tmp ; unsigned char tmp___0 ; unsigned char tmp___1 ; { p16_1 = 0; p16_2 = 0; p8_1 = 0; p8_2 = 0; pc_1 = 0; pc_2 = 0; pfp_1 = 0; pfp_2 = 0; if (typ != 10) { tmp = __request_region(& ioport_resource, (resource_size_t )adr, 8ULL, "elsa card", 0); if ((unsigned long )tmp != (unsigned long )((struct resource *)0)) { __release_region(& ioport_resource, (resource_size_t )adr, 8ULL); } else { printk("\fElsa: Probing Port 0x%x: already in use\n", adr); return (0U); } } else { } i = 0; goto ldv_41854; ldv_41853: tmp___0 = inb((int )(adr + 5U)); in1 = (int )tmp___0; tmp___1 = inb((int )(adr + 5U)); in2 = (int )tmp___1; p16_1 = (in1 & 4) + p16_1; p16_2 = (in2 & 4) + p16_2; p8_1 = (in1 & 2) + p8_1; p8_2 = (in2 & 2) + p8_2; pc_1 = (in1 & 1) + pc_1; pc_2 = (in2 & 1) + pc_2; pfp_1 = (in1 & 64) + pfp_1; pfp_2 = (in2 & 64) + pfp_2; i = i + 1; ldv_41854: ; if (i <= 15) { goto ldv_41853; } else { } printk("\016Elsa: Probing IO 0x%x", adr); p16_1 = p16_1 + 1; p16_2 = p16_2 + 1; if (p16_1 * p16_2 == 65) { printk(" PCC-16/PCF found\n"); return (3U); } else { pfp_1 = pfp_1 + 1; pfp_2 = pfp_2 + 1; if (pfp_1 * pfp_2 == 1025) { printk(" PCF-Pro found\n"); return (5U); } else { p8_1 = p8_1 + 1; p8_2 = p8_2 + 1; if (p8_1 * p8_2 == 33) { printk(" PCC8 found\n"); return (2U); } else { pc_1 = pc_1 + 1; pc_2 = pc_2 + 1; if (pc_1 * pc_2 == 17) { printk(" PC found\n"); return (1U); } else { printk(" failed\n"); return (0U); } } } } } } static unsigned int probe_elsa(struct IsdnCardState *cs ) { int i ; unsigned int CARD_portlist[5U] ; u_char tmp ; { CARD_portlist[0] = 352U; CARD_portlist[1] = 368U; CARD_portlist[2] = 608U; CARD_portlist[3] = 864U; CARD_portlist[4] = 0U; i = 0; goto ldv_41863; ldv_41862: tmp = probe_elsa_adr(CARD_portlist[i], (int )cs->typ); cs->subtyp = tmp; if ((unsigned int )tmp != 0U) { goto ldv_41861; } else { } i = i + 1; ldv_41863: ; if (CARD_portlist[i] != 0U) { goto ldv_41862; } else { } ldv_41861: ; return (CARD_portlist[i]); } } static int setup_elsa_isa(struct IsdnCard *card ) { struct IsdnCardState *cs ; u_char val ; unsigned int tmp ; u_char tmp___0 ; u_char CARD_IrqTab[8U] ; u_char CARD_IrqTab___0[8U] ; u_char CARD_IrqTab___1[8U] ; unsigned char tmp___1 ; unsigned char tmp___2 ; { cs = card->cs; cs->hw.elsa.base = card->para[0]; printk("\016Elsa: Microlink IO probing\n"); if (cs->hw.elsa.base != 0UL) { tmp___0 = probe_elsa_adr((unsigned int )cs->hw.elsa.base, (int )cs->typ); cs->subtyp = tmp___0; if ((unsigned int )tmp___0 == 0U) { printk("\fElsa: no Elsa Microlink at %#lx\n", cs->hw.elsa.base); return (0); } else { tmp = probe_elsa(cs); cs->hw.elsa.base = (unsigned long )tmp; } } else { } if (cs->hw.elsa.base == 0UL) { printk("\fNo Elsa Microlink found\n"); return (0); } else { } cs->hw.elsa.cfg = (unsigned int )cs->hw.elsa.base + 5U; cs->hw.elsa.ctrl = (unsigned int )cs->hw.elsa.base + 4U; cs->hw.elsa.ale = (unsigned int )cs->hw.elsa.base + 3U; cs->hw.elsa.isac = (unsigned int )cs->hw.elsa.base; cs->hw.elsa.itac = (unsigned int )cs->hw.elsa.base + 1U; cs->hw.elsa.hscx = (unsigned int )cs->hw.elsa.base + 2U; cs->hw.elsa.trig = (unsigned int )cs->hw.elsa.base + 7U; cs->hw.elsa.timer = (unsigned int )cs->hw.elsa.base + 6U; val = inb((int )cs->hw.elsa.cfg); if ((unsigned int )cs->subtyp == 1U) { CARD_IrqTab[0] = 7U; CARD_IrqTab[1] = 3U; CARD_IrqTab[2] = 5U; CARD_IrqTab[3] = 9U; CARD_IrqTab[4] = 0U; CARD_IrqTab[5] = 0U; CARD_IrqTab[6] = 0U; CARD_IrqTab[7] = 0U; cs->irq = (u_int )CARD_IrqTab[((int )val & 12) >> 2]; } else if ((unsigned int )cs->subtyp == 2U) { CARD_IrqTab___0[0] = 7U; CARD_IrqTab___0[1] = 3U; CARD_IrqTab___0[2] = 5U; CARD_IrqTab___0[3] = 9U; CARD_IrqTab___0[4] = 0U; CARD_IrqTab___0[5] = 0U; CARD_IrqTab___0[6] = 0U; CARD_IrqTab___0[7] = 0U; cs->irq = (u_int )CARD_IrqTab___0[((int )val & 48) >> 4]; } else { CARD_IrqTab___1[0] = 15U; CARD_IrqTab___1[1] = 10U; CARD_IrqTab___1[2] = 15U; CARD_IrqTab___1[3] = 3U; CARD_IrqTab___1[4] = 11U; CARD_IrqTab___1[5] = 5U; CARD_IrqTab___1[6] = 11U; CARD_IrqTab___1[7] = 9U; cs->irq = (u_int )CARD_IrqTab___1[((int )val & 56) >> 3]; } tmp___1 = inb((int )cs->hw.elsa.ale); val = (unsigned int )tmp___1 & 7U; if ((unsigned int )val <= 2U) { val = (u_char )((unsigned int )val | 8U); } else { } val = (unsigned int )val + 62U; if ((unsigned int )val == 66U || (unsigned int )val == 67U) { val = (u_char )((unsigned int )val ^ 1U); } else { } if ((unsigned int )cs->subtyp == 5U && (unsigned int )val == 71U) { val = 67U; } else { } printk("\016Elsa: %s found at %#lx Rev.:%c IRQ %d\n", Elsa_Types[(int )cs->subtyp], cs->hw.elsa.base, (int )val, cs->irq); tmp___2 = inb((int )cs->hw.elsa.ale); val = (unsigned int )tmp___2 & 8U; if ((unsigned int )val != 0U) { printk("\fElsa: Microlink S0 bus power bad\n"); cs->hw.elsa.status = cs->hw.elsa.status | 2U; } else { } return (1); } } static int setup_elsa_isapnp(struct IsdnCard *card ) { struct IsdnCardState *cs ; { cs = card->cs; if (card->para[1] != 0UL && card->para[0] != 0UL) { cs->hw.elsa.base = card->para[1]; cs->irq = (u_int )card->para[0]; if ((unsigned int )cs->subtyp == 0U) { cs->subtyp = 7U; } else { } } else { printk("\vElsa PnP: no parameter\n"); } cs->hw.elsa.cfg = (unsigned int )cs->hw.elsa.base + 5U; cs->hw.elsa.ale = (unsigned int )cs->hw.elsa.base + 3U; cs->hw.elsa.isac = (unsigned int )cs->hw.elsa.base; cs->hw.elsa.hscx = (unsigned int )cs->hw.elsa.base + 2U; cs->hw.elsa.trig = (unsigned int )cs->hw.elsa.base + 7U; cs->hw.elsa.timer = (unsigned int )cs->hw.elsa.base + 6U; cs->hw.elsa.ctrl = (unsigned int )cs->hw.elsa.base + 4U; printk("\016Elsa: %s defined at %#lx IRQ %d\n", Elsa_Types[(int )cs->subtyp], cs->hw.elsa.base, cs->irq); return (1); } } static void setup_elsa_pcmcia(struct IsdnCard *card ) { struct IsdnCardState *cs ; u_char val ; { cs = card->cs; cs->hw.elsa.base = card->para[1]; cs->irq = (u_int )card->para[0]; val = readreg___1((unsigned int )cs->hw.elsa.base, (unsigned int )cs->hw.elsa.base + 2U, 194); if ((unsigned int )val == 1U || (unsigned int )val == 2U) { cs->subtyp = 11U; cs->hw.elsa.ale = (unsigned int )cs->hw.elsa.base; cs->hw.elsa.isac = (unsigned int )cs->hw.elsa.base + 2U; cs->hw.elsa.hscx = (unsigned int )cs->hw.elsa.base + 2U; test_and_set_bit(1, (unsigned long volatile *)(& cs->HW_Flags)); } else { cs->subtyp = 6U; cs->hw.elsa.ale = (unsigned int )cs->hw.elsa.base + 4U; cs->hw.elsa.isac = (unsigned int )cs->hw.elsa.base + 1U; cs->hw.elsa.hscx = (unsigned int )cs->hw.elsa.base + 2U; } cs->hw.elsa.timer = 0U; cs->hw.elsa.trig = 0U; cs->hw.elsa.ctrl = 0U; cs->irq_flags = cs->irq_flags | 128UL; printk("\016Elsa: %s defined at %#lx IRQ %d\n", Elsa_Types[(int )cs->subtyp], cs->hw.elsa.base, cs->irq); return; } } static struct pci_dev *dev_qs1000 = 0; static struct pci_dev *dev_qs3000 = 0; static int setup_elsa_pci(struct IsdnCard *card ) { struct IsdnCardState *cs ; int tmp ; int tmp___0 ; { cs = card->cs; cs->subtyp = 0U; dev_qs1000 = hisax_find_pci_device(4168U, 4096U, dev_qs1000); if ((unsigned long )dev_qs1000 != (unsigned long )((struct pci_dev *)0)) { tmp = pci_enable_device(dev_qs1000); if (tmp != 0) { return (0); } else { } cs->subtyp = 9U; cs->irq = dev_qs1000->irq; cs->hw.elsa.cfg = (unsigned int )dev_qs1000->resource[1].start; cs->hw.elsa.base = (unsigned long )dev_qs1000->resource[3].start; } else { dev_qs3000 = hisax_find_pci_device(4168U, 12288U, dev_qs3000); if ((unsigned long )dev_qs3000 != (unsigned long )((struct pci_dev *)0)) { tmp___0 = pci_enable_device(dev_qs3000); if (tmp___0 != 0) { return (0); } else { } cs->subtyp = 10U; cs->irq = dev_qs3000->irq; cs->hw.elsa.cfg = (unsigned int )dev_qs3000->resource[1].start; cs->hw.elsa.base = (unsigned long )dev_qs3000->resource[3].start; } else { printk("\fElsa: No PCI card found\n"); return (0); } } if (cs->irq == 0U) { printk("\fElsa: No IRQ for PCI card found\n"); return (0); } else { } if (cs->hw.elsa.base == 0UL || cs->hw.elsa.cfg == 0U) { printk("\fElsa: No IO-Adr for PCI card found\n"); return (0); } else { } if ((cs->hw.elsa.cfg & 255U) != 0U || (cs->hw.elsa.base & 15UL) != 0UL) { printk("\fElsa: You may have a wrong PCI bios\n"); printk("\fElsa: If your system hangs now, read\n"); printk("\fElsa: Documentation/isdn/README.HiSax\n"); } else { } cs->hw.elsa.ale = (unsigned int )cs->hw.elsa.base; cs->hw.elsa.isac = (unsigned int )cs->hw.elsa.base + 1U; cs->hw.elsa.hscx = (unsigned int )cs->hw.elsa.base + 1U; test_and_set_bit(1, (unsigned long volatile *)(& cs->HW_Flags)); cs->hw.elsa.timer = 0U; cs->hw.elsa.trig = 0U; cs->irq_flags = cs->irq_flags | 128UL; printk("\016Elsa: %s defined at %#lx/0x%x IRQ %d\n", Elsa_Types[(int )cs->subtyp], cs->hw.elsa.base, cs->hw.elsa.cfg, cs->irq); return (1); } } static int setup_elsa_common(struct IsdnCard *card ) { struct IsdnCardState *cs ; u_char val ; int bytecnt ; struct resource *tmp ; struct resource *tmp___0 ; struct lock_class_key __key ; int tmp___1 ; int tmp___2 ; int tout ; int loops ; int tmp___3 ; int tmp___4 ; int tmp___5 ; int tmp___6 ; { cs = card->cs; switch ((int )cs->subtyp) { case 1: ; case 2: ; case 3: ; case 7: ; case 6: ; case 11: bytecnt = 8; goto ldv_41899; case 5: ; case 4: ; case 8: ; case 10: bytecnt = 16; goto ldv_41899; case 9: bytecnt = 2; goto ldv_41899; default: printk("\fUnknown ELSA subtype %d\n", (int )cs->subtyp); return (0); } ldv_41899: ; if ((unsigned int )cs->typ != 10U) { tmp = __request_region(& ioport_resource, (resource_size_t )cs->hw.elsa.base, (resource_size_t )bytecnt, "elsa isdn", 0); if ((unsigned long )tmp == (unsigned long )((struct resource *)0)) { printk("\fHiSax: ELSA config port %#lx-%#lx already in use\n", cs->hw.elsa.base, cs->hw.elsa.base + (unsigned long )bytecnt); return (0); } else { } } else { } if ((unsigned int )cs->subtyp == 9U || (unsigned int )cs->subtyp == 10U) { tmp___0 = __request_region(& ioport_resource, (resource_size_t )cs->hw.elsa.cfg, 128ULL, "elsa isdn pci", 0); if ((unsigned long )tmp___0 == (unsigned long )((struct resource *)0)) { printk("\fHiSax: ELSA pci port %x-%x already in use\n", cs->hw.elsa.cfg, cs->hw.elsa.cfg + 128U); __release_region(& ioport_resource, (resource_size_t )cs->hw.elsa.base, (resource_size_t )bytecnt); return (0); } else { } } else { } init_arcofi(cs); setup_isac(cs); cs->hw.elsa.tl.function = (void (*)(unsigned long ))(& elsa_led_handler); cs->hw.elsa.tl.data = (unsigned long )cs; init_timer_key(& cs->hw.elsa.tl, 0U, "(&cs->hw.elsa.tl)", & __key); if (cs->hw.elsa.timer != 0U) { outb(255, (int )cs->hw.elsa.trig); outb(0, (int )cs->hw.elsa.timer); tmp___2 = TimerRun(cs); if (tmp___2 == 0) { outb(0, (int )cs->hw.elsa.timer); tmp___1 = TimerRun(cs); if (tmp___1 == 0) { printk("\fElsa: timer do not start\n"); release_io_elsa(cs); return (0); } else { } } else { } tout = 3; goto ldv_41913; ldv_41912: loops = 4000; goto ldv_41910; ldv_41909: __const_udelay(4295UL); ldv_41910: tmp___3 = loops; loops = loops - 1; if (tmp___3 != 0) { goto ldv_41909; } else { } ldv_41913: tmp___4 = tout; tout = tout - 1; if (tmp___4 != 0) { goto ldv_41912; } else { } tmp___5 = TimerRun(cs); if (tmp___5 != 0) { printk("\fElsa: timer do not run down\n"); release_io_elsa(cs); return (0); } else { } printk("\016Elsa: timer OK; resetting card\n"); } else { } cs->BC_Read_Reg = & ReadHSCX___3; cs->BC_Write_Reg = & WriteHSCX___3; cs->BC_Send_Data = & hscx_fill_fifo___3; cs->cardmsg = & Elsa_card_msg; if (((unsigned int )cs->subtyp == 9U || (unsigned int )cs->subtyp == 10U) || (unsigned int )cs->subtyp == 11U) { cs->readisac = & ReadISAC_IPAC; cs->writeisac = & WriteISAC_IPAC; cs->readisacfifo = & ReadISACfifo_IPAC; cs->writeisacfifo = & WriteISACfifo_IPAC; cs->irq_func = & elsa_interrupt_ipac; val = readreg___1(cs->hw.elsa.ale, cs->hw.elsa.isac, 194); printk("\016Elsa: IPAC version %x\n", (int )val); } else { cs->readisac = & ReadISAC___4; cs->writeisac = & WriteISAC___4; cs->readisacfifo = & ReadISACfifo___4; cs->writeisacfifo = & WriteISACfifo___4; cs->irq_func = & elsa_interrupt; ISACVersion(cs, (char *)"Elsa:"); tmp___6 = HscxVersion(cs, (char *)"Elsa:"); if (tmp___6 != 0) { printk("\fElsa: wrong HSCX versions check IO address\n"); release_io_elsa(cs); return (0); } else { } } if ((unsigned int )cs->subtyp == 1U) { val = readitac(cs, 52); printk("\016Elsa: ITAC version %s\n", ITACVer[(int )val & 7]); writeitac(cs, 72, 0); writeitac(cs, 74, 0); writeitac(cs, 76, 0); writeitac(cs, 78, 0); writeitac(cs, 70, 0); } else { } return (1); } } int setup_elsa(struct IsdnCard *card ) { int rc ; struct IsdnCardState *cs ; char tmp[64U] ; char *tmp___0 ; int tmp___1 ; { cs = card->cs; strcpy((char *)(& tmp), Elsa_revision); tmp___0 = HiSax_getrev((char const *)(& tmp)); printk("\016HiSax: Elsa driver Rev. %s\n", tmp___0); cs->hw.elsa.ctrl_reg = 0U; cs->hw.elsa.status = 0U; cs->hw.elsa.MFlag = 0U; cs->subtyp = 0U; if ((unsigned int )cs->typ == 6U) { rc = setup_elsa_isa(card); if (rc == 0) { return (0); } else { } } else if ((unsigned int )cs->typ == 7U) { rc = setup_elsa_isapnp(card); if (rc == 0) { return (0); } else { } } else if ((unsigned int )cs->typ == 10U) { setup_elsa_pcmcia(card); } else if ((unsigned int )cs->typ == 18U) { rc = setup_elsa_pci(card); if (rc == 0) { return (0); } else { } } else { return (0); } tmp___1 = setup_elsa_common(card); return (tmp___1); } } void ldv_mutex_lock_281(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_lock(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_282(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_lock(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_283(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } int ldv_mutex_trylock_284(struct mutex *ldv_func_arg1 ) { ldv_func_ret_type___2 ldv_func_res ; int tmp ; int tmp___0 ; { tmp = mutex_trylock(ldv_func_arg1); ldv_func_res = tmp; tmp___0 = ldv_mutex_trylock_mutex(ldv_func_arg1); return (tmp___0); return (ldv_func_res); } } void ldv_mutex_unlock_285(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_286(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_cred_guard_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_287(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_cred_guard_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } int ldv_mutex_trylock_298(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_296(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_299(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_301(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_295(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_297(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_300(struct mutex *ldv_func_arg1 ) ; void init_ipacx(struct IsdnCardState *cs , int part ) ; void interrupt_ipacx(struct IsdnCardState *cs ) ; static char const *Diva_revision = "$Revision: 1.33.2.6 $"; __inline static u_char memreadreg(unsigned long adr , u_char off ) { { return (*((unsigned char *)((unsigned long )off + adr))); } } __inline static void memwritereg(unsigned long adr , u_char off , u_char data ) { register u_char *p ; { p = (u_char *)((unsigned long )off + adr); *p = data; return; } } static u_char ReadISAC___5(struct IsdnCardState *cs , u_char offset ) { u_char tmp ; { tmp = readreg___1((unsigned int )cs->hw.diva.isac_adr, cs->hw.diva.isac, (int )offset); return (tmp); } } static void WriteISAC___5(struct IsdnCardState *cs , u_char offset , u_char value ) { { writereg___1((unsigned int )cs->hw.diva.isac_adr, cs->hw.diva.isac, (int )offset, (int )value); return; } } static void ReadISACfifo___5(struct IsdnCardState *cs , u_char *data , int size ) { { readfifo((unsigned int )cs->hw.diva.isac_adr, cs->hw.diva.isac, 0, data, size); return; } } static void WriteISACfifo___5(struct IsdnCardState *cs , u_char *data , int size ) { { writefifo((unsigned int )cs->hw.diva.isac_adr, cs->hw.diva.isac, 0, data, size); return; } } static u_char ReadISAC_IPAC___0(struct IsdnCardState *cs , u_char offset ) { u_char tmp ; { tmp = readreg___1((unsigned int )cs->hw.diva.isac_adr, cs->hw.diva.isac, (int )((unsigned int )offset + 128U)); return (tmp); } } static void WriteISAC_IPAC___0(struct IsdnCardState *cs , u_char offset , u_char value ) { { writereg___1((unsigned int )cs->hw.diva.isac_adr, cs->hw.diva.isac, (int )((unsigned int )offset | 128U), (int )value); return; } } static void ReadISACfifo_IPAC___0(struct IsdnCardState *cs , u_char *data , int size ) { { readfifo((unsigned int )cs->hw.diva.isac_adr, cs->hw.diva.isac, 128, data, size); return; } } static void WriteISACfifo_IPAC___0(struct IsdnCardState *cs , u_char *data , int size ) { { writefifo((unsigned int )cs->hw.diva.isac_adr, cs->hw.diva.isac, 128, data, size); return; } } static u_char ReadHSCX___4(struct IsdnCardState *cs , int hscx , u_char offset ) { u_char tmp ; { tmp = readreg___1((unsigned int )cs->hw.diva.hscx_adr, cs->hw.diva.hscx, (int )((hscx != 0 ? 64U : 0U) + (unsigned int )offset)); return (tmp); } } static void WriteHSCX___4(struct IsdnCardState *cs , int hscx , u_char offset , u_char value ) { { writereg___1((unsigned int )cs->hw.diva.hscx_adr, cs->hw.diva.hscx, (int )((hscx != 0 ? 64U : 0U) + (unsigned int )offset), (int )value); return; } } static u_char MemReadISAC_IPAC(struct IsdnCardState *cs , u_char offset ) { u_char tmp ; { tmp = memreadreg(cs->hw.diva.cfg_reg, (int )((unsigned int )offset + 128U)); return (tmp); } } static void MemWriteISAC_IPAC(struct IsdnCardState *cs , u_char offset , u_char value ) { { memwritereg(cs->hw.diva.cfg_reg, (int )((unsigned int )offset | 128U), (int )value); return; } } static void MemReadISACfifo_IPAC(struct IsdnCardState *cs , u_char *data , int size ) { u_char *tmp ; int tmp___0 ; { goto ldv_41388; ldv_41387: tmp = data; data = data + 1; *tmp = memreadreg(cs->hw.diva.cfg_reg, 128); ldv_41388: tmp___0 = size; size = size - 1; if (tmp___0 != 0) { goto ldv_41387; } else { } return; } } static void MemWriteISACfifo_IPAC(struct IsdnCardState *cs , u_char *data , int size ) { u_char *tmp ; int tmp___0 ; { goto ldv_41396; ldv_41395: tmp = data; data = data + 1; memwritereg(cs->hw.diva.cfg_reg, 128, (int )*tmp); ldv_41396: tmp___0 = size; size = size - 1; if (tmp___0 != 0) { goto ldv_41395; } else { } return; } } static u_char MemReadHSCX(struct IsdnCardState *cs , int hscx , u_char offset ) { u_char tmp ; { tmp = memreadreg(cs->hw.diva.cfg_reg, (int )((hscx != 0 ? 64U : 0U) + (unsigned int )offset)); return (tmp); } } static void MemWriteHSCX(struct IsdnCardState *cs , int hscx , u_char offset , u_char value ) { { memwritereg(cs->hw.diva.cfg_reg, (int )((hscx != 0 ? 64U : 0U) + (unsigned int )offset), (int )value); return; } } static u_char MemReadISAC_IPACX(struct IsdnCardState *cs , u_char offset ) { u_char tmp ; { tmp = memreadreg(cs->hw.diva.cfg_reg, (int )offset); return (tmp); } } static void MemWriteISAC_IPACX(struct IsdnCardState *cs , u_char offset , u_char value ) { { memwritereg(cs->hw.diva.cfg_reg, (int )offset, (int )value); return; } } static void MemReadISACfifo_IPACX(struct IsdnCardState *cs , u_char *data , int size ) { u_char *tmp ; int tmp___0 ; { goto ldv_41424; ldv_41423: tmp = data; data = data + 1; *tmp = memreadreg(cs->hw.diva.cfg_reg, 0); ldv_41424: tmp___0 = size; size = size - 1; if (tmp___0 != 0) { goto ldv_41423; } else { } return; } } static void MemWriteISACfifo_IPACX(struct IsdnCardState *cs , u_char *data , int size ) { u_char *tmp ; int tmp___0 ; { goto ldv_41432; ldv_41431: tmp = data; data = data + 1; memwritereg(cs->hw.diva.cfg_reg, 0, (int )*tmp); ldv_41432: tmp___0 = size; size = size - 1; if (tmp___0 != 0) { goto ldv_41431; } else { } return; } } static u_char MemReadHSCX_IPACX(struct IsdnCardState *cs , int hscx , u_char offset ) { u_char tmp ; { tmp = memreadreg(cs->hw.diva.cfg_reg, (int )((hscx != 0 ? 128U : 112U) + (unsigned int )offset)); return (tmp); } } static void MemWriteHSCX_IPACX(struct IsdnCardState *cs , int hscx , u_char offset , u_char value ) { { memwritereg(cs->hw.diva.cfg_reg, (int )((hscx != 0 ? 128U : 112U) + (unsigned int )offset), (int )value); return; } } __inline static void waitforCEC___4(struct IsdnCardState *cs , int hscx ) { int to ; u_char tmp ; { to = 50; goto ldv_41451; ldv_41450: __const_udelay(4295UL); to = to - 1; ldv_41451: tmp = readreg___1((unsigned int )cs->hw.diva.hscx_adr, cs->hw.diva.hscx, hscx != 0 ? 97 : 33); if (((int )tmp & 4) != 0 && to != 0) { goto ldv_41450; } else { } if (to == 0) { printk("\fHiSax: waitforCEC timeout\n"); } else { } return; } } __inline static void waitforXFW___4(struct IsdnCardState *cs , int hscx ) { int to ; u_char tmp ; { to = 50; goto ldv_41459; ldv_41458: __const_udelay(4295UL); to = to - 1; ldv_41459: tmp = readreg___1((unsigned int )cs->hw.diva.hscx_adr, cs->hw.diva.hscx, hscx != 0 ? 97 : 33); if (((int )tmp & 68) != 64 && to != 0) { goto ldv_41458; } else { } if (to == 0) { printk("\fHiSax: waitforXFW timeout\n"); } else { } return; } } __inline static void WriteHSCXCMDR___4(struct IsdnCardState *cs , int hscx , u_char data ) { { waitforCEC___4(cs, hscx); writereg___1((unsigned int )cs->hw.diva.hscx_adr, cs->hw.diva.hscx, hscx != 0 ? 97 : 33, (int )data); return; } } static void hscx_empty_fifo___4(struct BCState *bcs , int count ) { u_char *ptr ; struct IsdnCardState *cs ; char *t ; int tmp ; { cs = bcs->cs; if ((cs->debug & 16) != 0 && (cs->debug & 32) == 0) { debugl1(cs, (char *)"hscx_empty_fifo"); } else { } if (bcs->hw.hscx.rcvidx + count > 4096) { if (cs->debug & 1) { debugl1(cs, (char *)"hscx_empty_fifo: incoming packet too large"); } else { } WriteHSCXCMDR___4(cs, bcs->hw.hscx.hscx, 128); bcs->hw.hscx.rcvidx = 0; return; } else { } ptr = bcs->hw.hscx.rcvbuf + (unsigned long )bcs->hw.hscx.rcvidx; bcs->hw.hscx.rcvidx = bcs->hw.hscx.rcvidx + count; readfifo((unsigned int )cs->hw.diva.hscx_adr, cs->hw.diva.hscx, bcs->hw.hscx.hscx != 0 ? 64 : 0, ptr, count); WriteHSCXCMDR___4(cs, bcs->hw.hscx.hscx, 128); if ((cs->debug & 32) != 0) { t = (char *)bcs->blog; tmp = sprintf(t, "hscx_empty_fifo %c cnt %d", bcs->hw.hscx.hscx != 0 ? 66 : 65, count); t = t + (unsigned long )tmp; QuickHex(t, ptr, count); debugl1(cs, (char *)bcs->blog); } else { } return; } } static void hscx_fill_fifo___4(struct BCState *bcs ) { struct IsdnCardState *cs ; int more ; int count ; int fifo_size ; int tmp ; u_char *ptr ; char *t ; int tmp___0 ; { cs = bcs->cs; tmp = constant_test_bit(1U, (unsigned long const volatile *)(& cs->HW_Flags)); fifo_size = tmp != 0 ? 64 : 32; if ((cs->debug & 16) != 0 && (cs->debug & 32) == 0) { debugl1(cs, (char *)"hscx_fill_fifo"); } else { } if ((unsigned long )bcs->tx_skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } if ((bcs->tx_skb)->len == 0U) { return; } else { } more = bcs->mode == 1; if ((bcs->tx_skb)->len > (unsigned int )fifo_size) { more = 1; count = fifo_size; } else { count = (int )(bcs->tx_skb)->len; } waitforXFW___4(cs, bcs->hw.hscx.hscx); ptr = (bcs->tx_skb)->data; skb_pull(bcs->tx_skb, (unsigned int )count); bcs->tx_cnt = bcs->tx_cnt - count; bcs->hw.hscx.count = bcs->hw.hscx.count + count; writefifo((unsigned int )cs->hw.diva.hscx_adr, cs->hw.diva.hscx, bcs->hw.hscx.hscx != 0 ? 64 : 0, ptr, count); WriteHSCXCMDR___4(cs, bcs->hw.hscx.hscx, more != 0 ? 8 : 10); if ((cs->debug & 32) != 0) { t = (char *)bcs->blog; tmp___0 = sprintf(t, "hscx_fill_fifo %c cnt %d", bcs->hw.hscx.hscx != 0 ? 66 : 65, count); t = t + (unsigned long )tmp___0; QuickHex(t, ptr, count); debugl1(cs, (char *)bcs->blog); } else { } return; } } static void hscx_interrupt___4(struct IsdnCardState *cs , u_char val , u_char hscx ) { u_char r ; struct BCState *bcs ; struct sk_buff *skb ; int fifo_size ; int tmp ; int count ; int tmp___0 ; u_char tmp___1 ; int tmp___2 ; size_t __len ; void *__ret ; unsigned char *tmp___4 ; size_t __len___0 ; void *__ret___0 ; unsigned char *tmp___6 ; u_long flags ; raw_spinlock_t *tmp___7 ; int tmp___8 ; struct sk_buff *tmp___9 ; { bcs = (struct BCState *)(& cs->bcs) + (unsigned long )hscx; tmp = constant_test_bit(1U, (unsigned long const volatile *)(& cs->HW_Flags)); fifo_size = tmp != 0 ? 64 : 32; tmp___0 = constant_test_bit(1U, (unsigned long const volatile *)(& bcs->Flag)); if (tmp___0 == 0) { return; } else { } if ((int )((signed char )val) < 0) { r = readreg___1((unsigned int )cs->hw.diva.hscx_adr, cs->hw.diva.hscx, (unsigned int )hscx != 0U ? 103 : 39); if (((int )r & 240) != 160) { if ((int )((signed char )r) >= 0) { if (cs->debug & 1) { debugl1(cs, (char *)"HSCX invalid frame"); } else { } bcs->err_inv = bcs->err_inv + 1; } else { } if (((int )r & 64) != 0 && bcs->mode != 0) { if (cs->debug & 1) { debugl1(cs, (char *)"HSCX RDO mode=%d", bcs->mode); } else { } bcs->err_rdo = bcs->err_rdo + 1; } else { } if (((int )r & 32) == 0) { if (cs->debug & 1) { debugl1(cs, (char *)"HSCX CRC error"); } else { } bcs->err_crc = bcs->err_crc + 1; } else { } WriteHSCXCMDR___4(cs, (int )hscx, 128); } else { tmp___1 = readreg___1((unsigned int )cs->hw.diva.hscx_adr, cs->hw.diva.hscx, (unsigned int )hscx != 0U ? 101 : 37); tmp___2 = constant_test_bit(1U, (unsigned long const volatile *)(& cs->HW_Flags)); count = (int )tmp___1 & (tmp___2 != 0 ? 63 : 31); if (count == 0) { count = fifo_size; } else { } hscx_empty_fifo___4(bcs, count); count = bcs->hw.hscx.rcvidx + -1; if (count > 0) { if ((cs->debug & 32) != 0) { debugl1(cs, (char *)"HX Frame %d", count); } else { } skb = dev_alloc_skb((unsigned int )count); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { printk("\fHSCX: receive out of memory\n"); } else { __len = (size_t )count; tmp___4 = skb_put(skb, (unsigned int )count); __ret = memcpy((void *)tmp___4, (void const *)bcs->hw.hscx.rcvbuf, __len); skb_queue_tail(& bcs->rqueue, skb); } } else { } } bcs->hw.hscx.rcvidx = 0; test_and_set_bit(0, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } if (((int )val & 64) != 0) { hscx_empty_fifo___4(bcs, fifo_size); if (bcs->mode == 1) { skb = dev_alloc_skb((unsigned int )fifo_size); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { printk("\fHiSax: receive out of memory\n"); } else { __len___0 = (size_t )fifo_size; tmp___6 = skb_put(skb, (unsigned int )fifo_size); __ret___0 = memcpy((void *)tmp___6, (void const *)bcs->hw.hscx.rcvbuf, __len___0); skb_queue_tail(& bcs->rqueue, skb); } bcs->hw.hscx.rcvidx = 0; test_and_set_bit(0, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } } else { } if (((int )val & 16) != 0) { if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { if ((bcs->tx_skb)->len != 0U) { hscx_fill_fifo___4(bcs); return; } else { tmp___8 = constant_test_bit(1U, (unsigned long const volatile *)(& (bcs->st)->lli.flag)); if (tmp___8 != 0 && (unsigned int )*((unsigned char *)bcs->tx_skb + 125UL) != 7U) { tmp___7 = spinlock_check(& bcs->aclock); flags = _raw_spin_lock_irqsave(tmp___7); bcs->ackcnt = bcs->ackcnt + bcs->hw.hscx.count; spin_unlock_irqrestore(& bcs->aclock, flags); test_and_set_bit(2, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } dev_kfree_skb_irq(bcs->tx_skb); bcs->hw.hscx.count = 0; bcs->tx_skb = 0; } } else { } tmp___9 = skb_dequeue(& bcs->squeue); bcs->tx_skb = tmp___9; if ((unsigned long )tmp___9 != (unsigned long )((struct sk_buff *)0)) { bcs->hw.hscx.count = 0; test_and_set_bit(3, (unsigned long volatile *)(& bcs->Flag)); hscx_fill_fifo___4(bcs); } else { test_and_clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); test_and_set_bit(1, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } } else { } return; } } static void hscx_int_main___4(struct IsdnCardState *cs , u_char val ) { u_char exval ; struct BCState *bcs ; { if ((int )val & 1) { bcs = (struct BCState *)(& cs->bcs) + 1UL; exval = readreg___1((unsigned int )cs->hw.diva.hscx_adr, cs->hw.diva.hscx, 100); if (((int )exval & 64) != 0) { if (bcs->mode == 1) { hscx_fill_fifo___4(bcs); } else { bcs->err_tx = bcs->err_tx + 1; if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { skb_push(bcs->tx_skb, (unsigned int )bcs->hw.hscx.count); bcs->tx_cnt = bcs->tx_cnt + bcs->hw.hscx.count; bcs->hw.hscx.count = 0; } else { } WriteHSCXCMDR___4(cs, bcs->hw.hscx.hscx, 1); if (cs->debug & 1) { debugl1(cs, (char *)"HSCX B EXIR %x Lost TX", (int )exval); } else { } } } else if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HSCX B EXIR %x", (int )exval); } else { } } else { } if (((int )val & 248) != 0) { if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HSCX B interrupt %x", (int )val); } else { } hscx_interrupt___4(cs, (int )val, 1); } else { } if (((int )val & 2) != 0) { bcs = (struct BCState *)(& cs->bcs); exval = readreg___1((unsigned int )cs->hw.diva.hscx_adr, cs->hw.diva.hscx, 36); if (((int )exval & 64) != 0) { if (bcs->mode == 1) { hscx_fill_fifo___4(bcs); } else { bcs->err_tx = bcs->err_tx + 1; if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { skb_push(bcs->tx_skb, (unsigned int )bcs->hw.hscx.count); bcs->tx_cnt = bcs->tx_cnt + bcs->hw.hscx.count; bcs->hw.hscx.count = 0; } else { } WriteHSCXCMDR___4(cs, bcs->hw.hscx.hscx, 1); if (cs->debug & 1) { debugl1(cs, (char *)"HSCX A EXIR %x Lost TX", (int )exval); } else { } } } else if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HSCX A EXIR %x", (int )exval); } else { } } else { } if (((int )val & 4) != 0) { exval = readreg___1((unsigned int )cs->hw.diva.hscx_adr, cs->hw.diva.hscx, 32); if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HSCX A interrupt %x", (int )exval); } else { } hscx_interrupt___4(cs, (int )exval, 0); } else { } return; } } static irqreturn_t diva_interrupt(int intno , void *dev_id ) { struct IsdnCardState *cs ; u_char val ; u_char sval ; u_long flags ; int cnt ; raw_spinlock_t *tmp ; { cs = (struct IsdnCardState *)dev_id; cnt = 5; tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); goto ldv_41521; ldv_41520: val = readreg___1((unsigned int )cs->hw.diva.hscx_adr, cs->hw.diva.hscx, 96); if ((unsigned int )val != 0U) { hscx_int_main___4(cs, (int )val); } else { } val = readreg___1((unsigned int )cs->hw.diva.isac_adr, cs->hw.diva.isac, 32); if ((unsigned int )val != 0U) { isac_interrupt(cs, (int )val); } else { } cnt = cnt - 1; ldv_41521: sval = inb((int )cs->hw.diva.ctrl); if ((int )sval & 1 && cnt != 0) { goto ldv_41520; } else { } if (cnt == 0) { printk("\fDiva: IRQ LOOP\n"); } else { } writereg___1((unsigned int )cs->hw.diva.hscx_adr, cs->hw.diva.hscx, 32, 255); writereg___1((unsigned int )cs->hw.diva.hscx_adr, cs->hw.diva.hscx, 96, 255); writereg___1((unsigned int )cs->hw.diva.isac_adr, cs->hw.diva.isac, 32, 255); writereg___1((unsigned int )cs->hw.diva.isac_adr, cs->hw.diva.isac, 32, 0); writereg___1((unsigned int )cs->hw.diva.hscx_adr, cs->hw.diva.hscx, 32, 0); writereg___1((unsigned int )cs->hw.diva.hscx_adr, cs->hw.diva.hscx, 96, 0); spin_unlock_irqrestore(& cs->lock, flags); return (1); } } static irqreturn_t diva_irq_ipac_isa(int intno , void *dev_id ) { struct IsdnCardState *cs ; u_char ista ; u_char val ; u_long flags ; int icnt ; raw_spinlock_t *tmp ; u_char tmp___0 ; { cs = (struct IsdnCardState *)dev_id; icnt = 5; tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); ista = readreg___1((unsigned int )cs->hw.diva.isac_adr, cs->hw.diva.isac, 193); Start_IPACISA: ; if ((cs->debug & 128) != 0) { debugl1(cs, (char *)"IPAC ISTA %02X", (int )ista); } else { } if (((int )ista & 15) != 0) { val = readreg___1((unsigned int )cs->hw.diva.isac_adr, cs->hw.diva.isac, 96); if ((int )ista & 1) { val = (u_char )((unsigned int )val | 1U); } else { } if (((int )ista & 4) != 0) { val = (u_char )((unsigned int )val | 2U); } else { } if (((int )ista & 8) != 0) { val = (u_char )((unsigned int )val | 4U); } else { } if ((unsigned int )val != 0U) { hscx_int_main___4(cs, (int )val); } else { } } else { } if (((int )ista & 32) != 0) { tmp___0 = readreg___1((unsigned int )cs->hw.diva.isac_adr, cs->hw.diva.isac, 160); val = (unsigned int )tmp___0 & 254U; if ((unsigned int )val != 0U) { isac_interrupt(cs, (int )val); } else { } } else { } if (((int )ista & 16) != 0) { val = 1U; isac_interrupt(cs, (int )val); } else { } ista = readreg___1((unsigned int )cs->hw.diva.isac_adr, cs->hw.diva.isac, 193); if (((int )ista & 63) != 0 && icnt != 0) { icnt = icnt - 1; goto Start_IPACISA; } else { } if (icnt == 0) { printk("\fDIVA IPAC IRQ LOOP\n"); } else { } writereg___1((unsigned int )cs->hw.diva.isac_adr, cs->hw.diva.isac, 193, 255); writereg___1((unsigned int )cs->hw.diva.isac_adr, cs->hw.diva.isac, 193, 192); spin_unlock_irqrestore(& cs->lock, flags); return (1); } } __inline static void MemwaitforCEC(struct IsdnCardState *cs , int hscx ) { int to ; u_char tmp ; { to = 50; goto ldv_41542; ldv_41541: __const_udelay(4295UL); to = to - 1; ldv_41542: tmp = MemReadHSCX(cs, hscx, 33); if (((int )tmp & 4) != 0 && to != 0) { goto ldv_41541; } else { } if (to == 0) { printk("\fHiSax: waitforCEC timeout\n"); } else { } return; } } __inline static void MemwaitforXFW(struct IsdnCardState *cs , int hscx ) { int to ; u_char tmp ; { to = 50; goto ldv_41550; ldv_41549: __const_udelay(4295UL); to = to - 1; ldv_41550: tmp = MemReadHSCX(cs, hscx, 33); if (((int )tmp & 68) != 64 && to != 0) { goto ldv_41549; } else { } if (to == 0) { printk("\fHiSax: waitforXFW timeout\n"); } else { } return; } } __inline static void MemWriteHSCXCMDR(struct IsdnCardState *cs , int hscx , u_char data ) { { MemwaitforCEC(cs, hscx); MemWriteHSCX(cs, hscx, 33, (int )data); return; } } static void Memhscx_empty_fifo(struct BCState *bcs , int count ) { u_char *ptr ; struct IsdnCardState *cs ; int cnt ; u_char *tmp ; int tmp___0 ; char *t ; int tmp___1 ; { cs = bcs->cs; if ((cs->debug & 16) != 0 && (cs->debug & 32) == 0) { debugl1(cs, (char *)"hscx_empty_fifo"); } else { } if (bcs->hw.hscx.rcvidx + count > 4096) { if (cs->debug & 1) { debugl1(cs, (char *)"hscx_empty_fifo: incoming packet too large"); } else { } MemWriteHSCXCMDR(cs, bcs->hw.hscx.hscx, 128); bcs->hw.hscx.rcvidx = 0; return; } else { } ptr = bcs->hw.hscx.rcvbuf + (unsigned long )bcs->hw.hscx.rcvidx; cnt = count; goto ldv_41565; ldv_41564: tmp = ptr; ptr = ptr + 1; *tmp = memreadreg(cs->hw.diva.cfg_reg, bcs->hw.hscx.hscx != 0 ? 64 : 0); ldv_41565: tmp___0 = cnt; cnt = cnt - 1; if (tmp___0 != 0) { goto ldv_41564; } else { } MemWriteHSCXCMDR(cs, bcs->hw.hscx.hscx, 128); ptr = bcs->hw.hscx.rcvbuf + (unsigned long )bcs->hw.hscx.rcvidx; bcs->hw.hscx.rcvidx = bcs->hw.hscx.rcvidx + count; if ((cs->debug & 32) != 0) { t = (char *)bcs->blog; tmp___1 = sprintf(t, "hscx_empty_fifo %c cnt %d", bcs->hw.hscx.hscx != 0 ? 66 : 65, count); t = t + (unsigned long )tmp___1; QuickHex(t, ptr, count); debugl1(cs, (char *)bcs->blog); } else { } return; } } static void Memhscx_fill_fifo(struct BCState *bcs ) { struct IsdnCardState *cs ; int more ; int count ; int cnt ; int fifo_size ; int tmp ; u_char *ptr ; u_char *p ; u_char *tmp___0 ; int tmp___1 ; char *t ; int tmp___2 ; { cs = bcs->cs; tmp = constant_test_bit(1U, (unsigned long const volatile *)(& cs->HW_Flags)); fifo_size = tmp != 0 ? 64 : 32; if ((cs->debug & 16) != 0 && (cs->debug & 32) == 0) { debugl1(cs, (char *)"hscx_fill_fifo"); } else { } if ((unsigned long )bcs->tx_skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } if ((bcs->tx_skb)->len == 0U) { return; } else { } more = bcs->mode == 1; if ((bcs->tx_skb)->len > (unsigned int )fifo_size) { more = 1; count = fifo_size; } else { count = (int )(bcs->tx_skb)->len; } cnt = count; MemwaitforXFW(cs, bcs->hw.hscx.hscx); ptr = (bcs->tx_skb)->data; p = ptr; skb_pull(bcs->tx_skb, (unsigned int )count); bcs->tx_cnt = bcs->tx_cnt - count; bcs->hw.hscx.count = bcs->hw.hscx.count + count; goto ldv_41579; ldv_41578: tmp___0 = p; p = p + 1; memwritereg(cs->hw.diva.cfg_reg, bcs->hw.hscx.hscx != 0 ? 64 : 0, (int )*tmp___0); ldv_41579: tmp___1 = cnt; cnt = cnt - 1; if (tmp___1 != 0) { goto ldv_41578; } else { } MemWriteHSCXCMDR(cs, bcs->hw.hscx.hscx, more != 0 ? 8 : 10); if ((cs->debug & 32) != 0) { t = (char *)bcs->blog; tmp___2 = sprintf(t, "hscx_fill_fifo %c cnt %d", bcs->hw.hscx.hscx != 0 ? 66 : 65, count); t = t + (unsigned long )tmp___2; QuickHex(t, ptr, count); debugl1(cs, (char *)bcs->blog); } else { } return; } } static void Memhscx_interrupt(struct IsdnCardState *cs , u_char val , u_char hscx ) { u_char r ; struct BCState *bcs ; struct sk_buff *skb ; int fifo_size ; int tmp ; int count ; int tmp___0 ; u_char tmp___1 ; int tmp___2 ; size_t __len ; void *__ret ; unsigned char *tmp___4 ; size_t __len___0 ; void *__ret___0 ; unsigned char *tmp___6 ; u_long flags ; raw_spinlock_t *tmp___7 ; int tmp___8 ; struct sk_buff *tmp___9 ; { bcs = (struct BCState *)(& cs->bcs) + (unsigned long )hscx; tmp = constant_test_bit(1U, (unsigned long const volatile *)(& cs->HW_Flags)); fifo_size = tmp != 0 ? 64 : 32; tmp___0 = constant_test_bit(1U, (unsigned long const volatile *)(& bcs->Flag)); if (tmp___0 == 0) { return; } else { } if ((int )((signed char )val) < 0) { r = MemReadHSCX(cs, (int )hscx, 39); if (((int )r & 240) != 160) { if ((int )((signed char )r) >= 0) { if (cs->debug & 1) { debugl1(cs, (char *)"HSCX invalid frame"); } else { } } else { } if (((int )r & 64) != 0 && bcs->mode != 0) { if (cs->debug & 1) { debugl1(cs, (char *)"HSCX RDO mode=%d", bcs->mode); } else { } } else { } if (((int )r & 32) == 0) { if (cs->debug & 1) { debugl1(cs, (char *)"HSCX CRC error"); } else { } } else { } MemWriteHSCXCMDR(cs, (int )hscx, 128); } else { tmp___1 = MemReadHSCX(cs, (int )hscx, 37); tmp___2 = constant_test_bit(1U, (unsigned long const volatile *)(& cs->HW_Flags)); count = (int )tmp___1 & (tmp___2 != 0 ? 63 : 31); if (count == 0) { count = fifo_size; } else { } Memhscx_empty_fifo(bcs, count); count = bcs->hw.hscx.rcvidx + -1; if (count > 0) { if ((cs->debug & 32) != 0) { debugl1(cs, (char *)"HX Frame %d", count); } else { } skb = dev_alloc_skb((unsigned int )count); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { printk("\fHSCX: receive out of memory\n"); } else { __len = (size_t )count; tmp___4 = skb_put(skb, (unsigned int )count); __ret = memcpy((void *)tmp___4, (void const *)bcs->hw.hscx.rcvbuf, __len); skb_queue_tail(& bcs->rqueue, skb); } } else { } } bcs->hw.hscx.rcvidx = 0; test_and_set_bit(0, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } if (((int )val & 64) != 0) { Memhscx_empty_fifo(bcs, fifo_size); if (bcs->mode == 1) { skb = dev_alloc_skb((unsigned int )fifo_size); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { printk("\fHiSax: receive out of memory\n"); } else { __len___0 = (size_t )fifo_size; tmp___6 = skb_put(skb, (unsigned int )fifo_size); __ret___0 = memcpy((void *)tmp___6, (void const *)bcs->hw.hscx.rcvbuf, __len___0); skb_queue_tail(& bcs->rqueue, skb); } bcs->hw.hscx.rcvidx = 0; test_and_set_bit(0, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } } else { } if (((int )val & 16) != 0) { if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { if ((bcs->tx_skb)->len != 0U) { Memhscx_fill_fifo(bcs); return; } else { tmp___8 = constant_test_bit(1U, (unsigned long const volatile *)(& (bcs->st)->lli.flag)); if (tmp___8 != 0 && (unsigned int )*((unsigned char *)bcs->tx_skb + 125UL) != 7U) { tmp___7 = spinlock_check(& bcs->aclock); flags = _raw_spin_lock_irqsave(tmp___7); bcs->ackcnt = bcs->ackcnt + bcs->hw.hscx.count; spin_unlock_irqrestore(& bcs->aclock, flags); test_and_set_bit(2, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } dev_kfree_skb_irq(bcs->tx_skb); bcs->hw.hscx.count = 0; bcs->tx_skb = 0; } } else { } tmp___9 = skb_dequeue(& bcs->squeue); bcs->tx_skb = tmp___9; if ((unsigned long )tmp___9 != (unsigned long )((struct sk_buff *)0)) { bcs->hw.hscx.count = 0; test_and_set_bit(3, (unsigned long volatile *)(& bcs->Flag)); Memhscx_fill_fifo(bcs); } else { test_and_clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); test_and_set_bit(1, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } } else { } return; } } __inline static void Memhscx_int_main(struct IsdnCardState *cs , u_char val ) { u_char exval ; struct BCState *bcs ; { if ((int )val & 1) { bcs = (struct BCState *)(& cs->bcs) + 1UL; exval = MemReadHSCX(cs, 1, 36); if (((int )exval & 64) != 0) { if (bcs->mode == 1) { Memhscx_fill_fifo(bcs); } else { if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { skb_push(bcs->tx_skb, (unsigned int )bcs->hw.hscx.count); bcs->tx_cnt = bcs->tx_cnt + bcs->hw.hscx.count; bcs->hw.hscx.count = 0; } else { } MemWriteHSCXCMDR(cs, bcs->hw.hscx.hscx, 1); if (cs->debug & 1) { debugl1(cs, (char *)"HSCX B EXIR %x Lost TX", (int )exval); } else { } } } else if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HSCX B EXIR %x", (int )exval); } else { } } else { } if (((int )val & 248) != 0) { if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HSCX B interrupt %x", (int )val); } else { } Memhscx_interrupt(cs, (int )val, 1); } else { } if (((int )val & 2) != 0) { bcs = (struct BCState *)(& cs->bcs); exval = MemReadHSCX(cs, 0, 36); if (((int )exval & 64) != 0) { if (bcs->mode == 1) { Memhscx_fill_fifo(bcs); } else { if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { skb_push(bcs->tx_skb, (unsigned int )bcs->hw.hscx.count); bcs->tx_cnt = bcs->tx_cnt + bcs->hw.hscx.count; bcs->hw.hscx.count = 0; } else { } MemWriteHSCXCMDR(cs, bcs->hw.hscx.hscx, 1); if (cs->debug & 1) { debugl1(cs, (char *)"HSCX A EXIR %x Lost TX", (int )exval); } else { } } } else if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HSCX A EXIR %x", (int )exval); } else { } } else { } if (((int )val & 4) != 0) { exval = MemReadHSCX(cs, 0, 32); if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HSCX A interrupt %x", (int )exval); } else { } Memhscx_interrupt(cs, (int )exval, 0); } else { } return; } } static irqreturn_t diva_irq_ipac_pci(int intno , void *dev_id ) { struct IsdnCardState *cs ; u_char ista ; u_char val ; int icnt ; u_char *cfg ; u_long flags ; raw_spinlock_t *tmp ; u_char tmp___0 ; { cs = (struct IsdnCardState *)dev_id; icnt = 5; tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); cfg = (u_char *)cs->hw.diva.pci_cfg; val = *cfg; if (((int )val & 2) == 0) { spin_unlock_irqrestore(& cs->lock, flags); return (0); } else { } *cfg = 2U; ista = memreadreg(cs->hw.diva.cfg_reg, 193); Start_IPACPCI: ; if ((cs->debug & 128) != 0) { debugl1(cs, (char *)"IPAC ISTA %02X", (int )ista); } else { } if (((int )ista & 15) != 0) { val = memreadreg(cs->hw.diva.cfg_reg, 96); if ((int )ista & 1) { val = (u_char )((unsigned int )val | 1U); } else { } if (((int )ista & 4) != 0) { val = (u_char )((unsigned int )val | 2U); } else { } if (((int )ista & 8) != 0) { val = (u_char )((unsigned int )val | 4U); } else { } if ((unsigned int )val != 0U) { Memhscx_int_main(cs, (int )val); } else { } } else { } if (((int )ista & 32) != 0) { tmp___0 = memreadreg(cs->hw.diva.cfg_reg, 160); val = (unsigned int )tmp___0 & 254U; if ((unsigned int )val != 0U) { isac_interrupt(cs, (int )val); } else { } } else { } if (((int )ista & 16) != 0) { val = 1U; isac_interrupt(cs, (int )val); } else { } ista = memreadreg(cs->hw.diva.cfg_reg, 193); if (((int )ista & 63) != 0 && icnt != 0) { icnt = icnt - 1; goto Start_IPACPCI; } else { } if (icnt == 0) { printk("\fDIVA IPAC PCI IRQ LOOP\n"); } else { } memwritereg(cs->hw.diva.cfg_reg, 193, 255); memwritereg(cs->hw.diva.cfg_reg, 193, 192); spin_unlock_irqrestore(& cs->lock, flags); return (1); } } static irqreturn_t diva_irq_ipacx_pci(int intno , void *dev_id ) { struct IsdnCardState *cs ; u_char val ; u_char *cfg ; u_long flags ; raw_spinlock_t *tmp ; { cs = (struct IsdnCardState *)dev_id; tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); cfg = (u_char *)cs->hw.diva.pci_cfg; val = *cfg; if (((int )val & 2) == 0) { spin_unlock_irqrestore(& cs->lock, flags); return (0); } else { } interrupt_ipacx(cs); *cfg = 2U; spin_unlock_irqrestore(& cs->lock, flags); return (1); } } static void release_io_diva(struct IsdnCardState *cs ) { int bytecnt ; u_int *cfg ; { if ((unsigned int )cs->subtyp == 4U || (unsigned int )cs->subtyp == 5U) { cfg = (u_int *)cs->hw.diva.pci_cfg; *cfg = 0U; *cfg = 2U; if (cs->hw.diva.cfg_reg != 0UL) { iounmap((void volatile *)cs->hw.diva.cfg_reg); } else { } if (cs->hw.diva.pci_cfg != 0UL) { iounmap((void volatile *)cs->hw.diva.pci_cfg); } else { } return; } else if ((unsigned int )cs->subtyp != 3U) { del_timer(& cs->hw.diva.tl); if (cs->hw.diva.cfg_reg != 0UL) { outb(0, (int )cs->hw.diva.ctrl); } else { } } else { } if ((unsigned int )cs->subtyp == 1U || (unsigned int )cs->subtyp == 3U) { bytecnt = 8; } else { bytecnt = 32; } if (cs->hw.diva.cfg_reg != 0UL) { __release_region(& ioport_resource, (resource_size_t )cs->hw.diva.cfg_reg, (resource_size_t )bytecnt); } else { } return; } } static void iounmap_diva(struct IsdnCardState *cs ) { { if ((unsigned int )cs->subtyp == 4U || (unsigned int )cs->subtyp == 5U) { if (cs->hw.diva.cfg_reg != 0UL) { iounmap((void volatile *)cs->hw.diva.cfg_reg); cs->hw.diva.cfg_reg = 0UL; } else { } if (cs->hw.diva.pci_cfg != 0UL) { iounmap((void volatile *)cs->hw.diva.pci_cfg); cs->hw.diva.pci_cfg = 0UL; } else { } } else { } return; } } static void reset_diva(struct IsdnCardState *cs ) { unsigned long __ms ; unsigned long tmp ; unsigned long __ms___0 ; unsigned long tmp___0 ; unsigned int *ireg ; unsigned long __ms___1 ; unsigned long tmp___1 ; unsigned long __ms___2 ; unsigned long tmp___2 ; unsigned int *ireg___0 ; unsigned long __ms___3 ; unsigned long tmp___3 ; unsigned long __ms___4 ; unsigned long tmp___4 ; unsigned long __ms___5 ; unsigned long tmp___5 ; unsigned long __ms___6 ; unsigned long tmp___6 ; { if ((unsigned int )cs->subtyp == 3U) { writereg___1((unsigned int )cs->hw.diva.isac_adr, cs->hw.diva.isac, 201, 32); __ms = 10UL; goto ldv_41646; ldv_41645: __const_udelay(4295000UL); ldv_41646: tmp = __ms; __ms = __ms - 1UL; if (tmp != 0UL) { goto ldv_41645; } else { } writereg___1((unsigned int )cs->hw.diva.isac_adr, cs->hw.diva.isac, 201, 0); __ms___0 = 10UL; goto ldv_41650; ldv_41649: __const_udelay(4295000UL); ldv_41650: tmp___0 = __ms___0; __ms___0 = __ms___0 - 1UL; if (tmp___0 != 0UL) { goto ldv_41649; } else { } writereg___1((unsigned int )cs->hw.diva.isac_adr, cs->hw.diva.isac, 193, 192); } else if ((unsigned int )cs->subtyp == 4U) { ireg = (unsigned int *)(cs->hw.diva.pci_cfg + 28UL); *ireg = 83886080U; __ms___1 = 10UL; goto ldv_41655; ldv_41654: __const_udelay(4295000UL); ldv_41655: tmp___1 = __ms___1; __ms___1 = __ms___1 - 1UL; if (tmp___1 != 0UL) { goto ldv_41654; } else { } *ireg = 67108864U; __ms___2 = 10UL; goto ldv_41659; ldv_41658: __const_udelay(4295000UL); ldv_41659: tmp___2 = __ms___2; __ms___2 = __ms___2 - 1UL; if (tmp___2 != 0UL) { goto ldv_41658; } else { } memwritereg(cs->hw.diva.cfg_reg, 193, 192); } else if ((unsigned int )cs->subtyp == 5U) { ireg___0 = (unsigned int *)(cs->hw.diva.pci_cfg + 28UL); *ireg___0 = 83886080U; __ms___3 = 10UL; goto ldv_41664; ldv_41663: __const_udelay(4295000UL); ldv_41664: tmp___3 = __ms___3; __ms___3 = __ms___3 - 1UL; if (tmp___3 != 0UL) { goto ldv_41663; } else { } *ireg___0 = 100663296U; __ms___4 = 10UL; goto ldv_41668; ldv_41667: __const_udelay(4295000UL); ldv_41668: tmp___4 = __ms___4; __ms___4 = __ms___4 - 1UL; if (tmp___4 != 0UL) { goto ldv_41667; } else { } MemWriteISAC_IPACX(cs, 96, 255); } else { cs->hw.diva.ctrl_reg = 0U; outb((int )cs->hw.diva.ctrl_reg, (int )cs->hw.diva.ctrl); __ms___5 = 10UL; goto ldv_41672; ldv_41671: __const_udelay(4295000UL); ldv_41672: tmp___5 = __ms___5; __ms___5 = __ms___5 - 1UL; if (tmp___5 != 0UL) { goto ldv_41671; } else { } cs->hw.diva.ctrl_reg = (u_char )((unsigned int )cs->hw.diva.ctrl_reg | 8U); outb((int )cs->hw.diva.ctrl_reg, (int )cs->hw.diva.ctrl); __ms___6 = 10UL; goto ldv_41676; ldv_41675: __const_udelay(4295000UL); ldv_41676: tmp___6 = __ms___6; __ms___6 = __ms___6 - 1UL; if (tmp___6 != 0UL) { goto ldv_41675; } else { } if ((unsigned int )cs->subtyp == 1U) { cs->hw.diva.ctrl_reg = (u_char )((unsigned int )cs->hw.diva.ctrl_reg | 32U); } else { outb(9, (int )((unsigned int )cs->hw.diva.pci_cfg + 105U)); cs->hw.diva.ctrl_reg = (u_char )((unsigned int )cs->hw.diva.ctrl_reg | 16U); } outb((int )cs->hw.diva.ctrl_reg, (int )cs->hw.diva.ctrl); } return; } } static void diva_led_handler(struct IsdnCardState *cs ) { int blink ; struct lock_class_key __key ; { blink = 0; if (((unsigned int )cs->subtyp == 3U || (unsigned int )cs->subtyp == 4U) || (unsigned int )cs->subtyp == 5U) { return; } else { } del_timer(& cs->hw.diva.tl); if ((int )cs->hw.diva.status & 1) { cs->hw.diva.ctrl_reg = (u_char )((int )((signed char )cs->hw.diva.ctrl_reg) | ((unsigned int )cs->subtyp == 1U ? 32 : 16)); } else { cs->hw.diva.ctrl_reg = (u_char )((int )((signed char )cs->hw.diva.ctrl_reg) ^ ((unsigned int )cs->subtyp == 1U ? 32 : 16)); blink = 250; } if ((cs->hw.diva.status & 61440U) != 0U) { cs->hw.diva.ctrl_reg = (u_char )((int )((signed char )cs->hw.diva.ctrl_reg) | ((unsigned int )cs->subtyp == 1U ? 64 : 32)); } else if ((cs->hw.diva.status & 3840U) != 0U) { cs->hw.diva.ctrl_reg = (u_char )((int )((signed char )cs->hw.diva.ctrl_reg) ^ ((unsigned int )cs->subtyp == 1U ? 64 : 32)); blink = 500; } else { cs->hw.diva.ctrl_reg = (u_char )((int )((signed char )cs->hw.diva.ctrl_reg) & ((unsigned int )cs->subtyp == 1U ? -65 : -33)); } outb((int )cs->hw.diva.ctrl_reg, (int )cs->hw.diva.ctrl); if (blink != 0) { init_timer_key(& cs->hw.diva.tl, 0U, "(&cs->hw.diva.tl)", & __key); cs->hw.diva.tl.expires = (unsigned long )((blink * 250) / 1000) + (unsigned long )jiffies; add_timer(& cs->hw.diva.tl); } else { } return; } } static int Diva_card_msg(struct IsdnCardState *cs , int mt , void *arg ) { u_int *ireg ; u_long flags ; raw_spinlock_t *tmp ; raw_spinlock_t *tmp___0 ; raw_spinlock_t *tmp___1 ; { switch (mt) { case 240: tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); reset_diva(cs); spin_unlock_irqrestore(& cs->lock, flags); return (0); case 243: release_io_diva(cs); return (0); case 242: tmp___0 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___0); reset_diva(cs); if ((unsigned int )cs->subtyp == 5U) { ireg = (u_int *)cs->hw.diva.pci_cfg; *ireg = 131072U; init_ipacx(cs, 3); spin_unlock_irqrestore(& cs->lock, flags); return (0); } else { } if ((unsigned int )cs->subtyp == 4U) { ireg = (u_int *)cs->hw.diva.pci_cfg; *ireg = 131072U; } else { } inithscxisac(cs, 3); spin_unlock_irqrestore(& cs->lock, flags); return (0); case 244: ; return (0); case 644: cs->hw.diva.status = 0U; goto ldv_41701; case 640: cs->hw.diva.status = cs->hw.diva.status | 1U; goto ldv_41701; case 736: ; if ((unsigned long )arg != (unsigned long )((void *)0)) { cs->hw.diva.status = cs->hw.diva.status | 512U; } else { cs->hw.diva.status = cs->hw.diva.status | 256U; } goto ldv_41701; case 740: ; if ((unsigned long )arg != (unsigned long )((void *)0)) { cs->hw.diva.status = cs->hw.diva.status | 8192U; } else { cs->hw.diva.status = cs->hw.diva.status | 4096U; } goto ldv_41701; case 744: ; if ((unsigned long )arg != (unsigned long )((void *)0)) { cs->hw.diva.status = cs->hw.diva.status & 4294959103U; cs->hw.diva.status = cs->hw.diva.status & 4294966783U; } else { cs->hw.diva.status = cs->hw.diva.status & 4294963199U; cs->hw.diva.status = cs->hw.diva.status & 4294967039U; } goto ldv_41701; } ldv_41701: ; if (((unsigned int )cs->subtyp != 3U && (unsigned int )cs->subtyp != 4U) && (unsigned int )cs->subtyp != 5U) { tmp___1 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___1); diva_led_handler(cs); spin_unlock_irqrestore(& cs->lock, flags); } else { } return (0); } } static int setup_diva_common(struct IsdnCardState *cs ) { int bytecnt ; u_char val ; struct resource *tmp ; u_char tmp___0 ; struct lock_class_key __key ; int tmp___1 ; { if ((unsigned int )cs->subtyp == 1U || (unsigned int )cs->subtyp == 3U) { bytecnt = 8; } else { bytecnt = 32; } printk("\016Diva: %s card configured at %#lx IRQ %d\n", (unsigned int )cs->subtyp != 2U ? ((unsigned int )cs->subtyp != 1U ? ((unsigned int )cs->subtyp != 3U ? ((unsigned int )cs->subtyp == 4U ? (char *)"IPAC PCI" : (char *)"IPACX PCI") : (char *)"IPAC ISA") : (char *)"ISA") : (char *)"PCI", cs->hw.diva.cfg_reg, cs->irq); if (((unsigned int )cs->subtyp == 4U || (unsigned int )cs->subtyp == 5U) || (unsigned int )cs->subtyp == 2U) { printk("\016Diva: %s space at %#lx\n", (unsigned int )cs->subtyp != 2U ? ((unsigned int )cs->subtyp == 4U ? (char *)"IPAC PCI" : (char *)"IPACX PCI") : (char *)"PCI", cs->hw.diva.pci_cfg); } else { } if ((unsigned int )cs->subtyp != 4U && (unsigned int )cs->subtyp != 5U) { tmp = __request_region(& ioport_resource, (resource_size_t )cs->hw.diva.cfg_reg, (resource_size_t )bytecnt, "diva isdn", 0); if ((unsigned long )tmp == (unsigned long )((struct resource *)0)) { printk("\fHiSax: %s config port %lx-%lx already in use\n", (char *)"diva", cs->hw.diva.cfg_reg, cs->hw.diva.cfg_reg + (unsigned long )bytecnt); iounmap_diva(cs); return (0); } else { } } else { } cs->BC_Read_Reg = & ReadHSCX___4; cs->BC_Write_Reg = & WriteHSCX___4; cs->BC_Send_Data = & hscx_fill_fifo___4; cs->cardmsg = & Diva_card_msg; setup_isac(cs); if ((unsigned int )cs->subtyp == 3U) { cs->readisac = & ReadISAC_IPAC___0; cs->writeisac = & WriteISAC_IPAC___0; cs->readisacfifo = & ReadISACfifo_IPAC___0; cs->writeisacfifo = & WriteISACfifo_IPAC___0; cs->irq_func = & diva_irq_ipac_isa; val = readreg___1((unsigned int )cs->hw.diva.isac_adr, cs->hw.diva.isac, 194); printk("\016Diva: IPAC version %x\n", (int )val); } else if ((unsigned int )cs->subtyp == 4U) { cs->readisac = & MemReadISAC_IPAC; cs->writeisac = & MemWriteISAC_IPAC; cs->readisacfifo = & MemReadISACfifo_IPAC; cs->writeisacfifo = & MemWriteISACfifo_IPAC; cs->BC_Read_Reg = & MemReadHSCX; cs->BC_Write_Reg = & MemWriteHSCX; cs->BC_Send_Data = & Memhscx_fill_fifo; cs->irq_func = & diva_irq_ipac_pci; val = memreadreg(cs->hw.diva.cfg_reg, 194); printk("\016Diva: IPAC version %x\n", (int )val); } else if ((unsigned int )cs->subtyp == 5U) { cs->readisac = & MemReadISAC_IPACX; cs->writeisac = & MemWriteISAC_IPACX; cs->readisacfifo = & MemReadISACfifo_IPACX; cs->writeisacfifo = & MemWriteISACfifo_IPACX; cs->BC_Read_Reg = & MemReadHSCX_IPACX; cs->BC_Write_Reg = & MemWriteHSCX_IPACX; cs->BC_Send_Data = 0; cs->irq_func = & diva_irq_ipacx_pci; tmp___0 = MemReadISAC_IPACX(cs, 100); printk("\016Diva: IPACX Design Id: %x\n", (int )tmp___0 & 63); } else { cs->hw.diva.tl.function = (void (*)(unsigned long ))(& diva_led_handler); cs->hw.diva.tl.data = (unsigned long )cs; init_timer_key(& cs->hw.diva.tl, 0U, "(&cs->hw.diva.tl)", & __key); cs->readisac = & ReadISAC___5; cs->writeisac = & WriteISAC___5; cs->readisacfifo = & ReadISACfifo___5; cs->writeisacfifo = & WriteISACfifo___5; cs->irq_func = & diva_interrupt; ISACVersion(cs, (char *)"Diva:"); tmp___1 = HscxVersion(cs, (char *)"Diva:"); if (tmp___1 != 0) { printk("\fDiva: wrong HSCX versions check IO address\n"); release_io_diva(cs); return (0); } else { } } return (1); } } static int setup_diva_isa(struct IsdnCard *card ) { { return (-1); } } static int setup_diva_isapnp(struct IsdnCard *card ) { { return (-1); } } static struct pci_dev *dev_diva = 0; static struct pci_dev *dev_diva_u = 0; static struct pci_dev *dev_diva201 = 0; static struct pci_dev *dev_diva202 = 0; static int setup_diva_pci(struct IsdnCard *card ) { struct IsdnCardState *cs ; int tmp ; int tmp___0 ; int tmp___1 ; void *tmp___2 ; void *tmp___3 ; int tmp___4 ; void *tmp___5 ; void *tmp___6 ; { cs = card->cs; cs->subtyp = 0U; dev_diva = hisax_find_pci_device(4403U, 57346U, dev_diva); if ((unsigned long )dev_diva != (unsigned long )((struct pci_dev *)0)) { tmp = pci_enable_device(dev_diva); if (tmp != 0) { return (0); } else { } cs->subtyp = 2U; cs->irq = dev_diva->irq; cs->hw.diva.cfg_reg = (unsigned long )dev_diva->resource[2].start; } else { dev_diva_u = hisax_find_pci_device(4403U, 57348U, dev_diva_u); if ((unsigned long )dev_diva_u != (unsigned long )((struct pci_dev *)0)) { tmp___0 = pci_enable_device(dev_diva_u); if (tmp___0 != 0) { return (0); } else { } cs->subtyp = 2U; cs->irq = dev_diva_u->irq; cs->hw.diva.cfg_reg = (unsigned long )dev_diva_u->resource[2].start; } else { dev_diva201 = hisax_find_pci_device(4403U, 57349U, dev_diva201); if ((unsigned long )dev_diva201 != (unsigned long )((struct pci_dev *)0)) { tmp___1 = pci_enable_device(dev_diva201); if (tmp___1 != 0) { return (0); } else { } cs->subtyp = 4U; cs->irq = dev_diva201->irq; tmp___2 = ioremap(dev_diva201->resource[0].start, 4096UL); cs->hw.diva.pci_cfg = (unsigned long )tmp___2; tmp___3 = ioremap(dev_diva201->resource[1].start, 4096UL); cs->hw.diva.cfg_reg = (unsigned long )tmp___3; } else { dev_diva202 = hisax_find_pci_device(4403U, 57355U, dev_diva202); if ((unsigned long )dev_diva202 != (unsigned long )((struct pci_dev *)0)) { tmp___4 = pci_enable_device(dev_diva202); if (tmp___4 != 0) { return (0); } else { } cs->subtyp = 5U; cs->irq = dev_diva202->irq; tmp___5 = ioremap(dev_diva202->resource[0].start, 4096UL); cs->hw.diva.pci_cfg = (unsigned long )tmp___5; tmp___6 = ioremap(dev_diva202->resource[1].start, 4096UL); cs->hw.diva.cfg_reg = (unsigned long )tmp___6; } else { return (-1); } } } } if (cs->irq == 0U) { printk("\fDiva: No IRQ for PCI card found\n"); iounmap_diva(cs); return (0); } else { } if (cs->hw.diva.cfg_reg == 0UL) { printk("\fDiva: No IO-Adr for PCI card found\n"); iounmap_diva(cs); return (0); } else { } cs->irq_flags = cs->irq_flags | 128UL; if ((unsigned int )cs->subtyp == 4U || (unsigned int )cs->subtyp == 5U) { cs->hw.diva.ctrl = 0U; cs->hw.diva.isac = 0U; cs->hw.diva.hscx = 0U; cs->hw.diva.isac_adr = 0UL; cs->hw.diva.hscx_adr = 0UL; test_and_set_bit(1, (unsigned long volatile *)(& cs->HW_Flags)); } else { cs->hw.diva.ctrl = (unsigned int )cs->hw.diva.cfg_reg + 16U; cs->hw.diva.isac = (unsigned int )cs->hw.diva.cfg_reg + 8U; cs->hw.diva.hscx = (unsigned int )cs->hw.diva.cfg_reg; cs->hw.diva.isac_adr = cs->hw.diva.cfg_reg + 12UL; cs->hw.diva.hscx_adr = cs->hw.diva.cfg_reg + 4UL; } return (1); } } int setup_diva(struct IsdnCard *card ) { int rc ; int have_card ; struct IsdnCardState *cs ; char tmp[64U] ; char *tmp___0 ; int tmp___1 ; { have_card = 0; cs = card->cs; strcpy((char *)(& tmp), Diva_revision); tmp___0 = HiSax_getrev((char const *)(& tmp)); printk("\016HiSax: Eicon.Diehl Diva driver Rev. %s\n", tmp___0); if ((unsigned int )cs->typ != 11U) { return (0); } else { } cs->hw.diva.status = 0U; rc = setup_diva_isa(card); if (rc == 0) { return (rc); } else { } if (rc > 0) { have_card = 1; goto ready; } else { } rc = setup_diva_isapnp(card); if (rc == 0) { return (rc); } else { } if (rc > 0) { have_card = 1; goto ready; } else { } rc = setup_diva_pci(card); if (rc == 0) { return (rc); } else { } if (rc > 0) { have_card = 1; } else { } ready: ; if (have_card == 0) { printk("\fDiva: No ISA, ISAPNP or PCI card found\n"); return (0); } else { } tmp___1 = setup_diva_common(card->cs); return (tmp___1); } } void ldv_mutex_lock_295(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_lock(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_296(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_lock(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_297(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } int ldv_mutex_trylock_298(struct mutex *ldv_func_arg1 ) { ldv_func_ret_type___2 ldv_func_res ; int tmp ; int tmp___0 ; { tmp = mutex_trylock(ldv_func_arg1); ldv_func_res = tmp; tmp___0 = ldv_mutex_trylock_mutex(ldv_func_arg1); return (tmp___0); return (ldv_func_res); } } void ldv_mutex_unlock_299(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_300(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_cred_guard_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_301(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_cred_guard_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } int ldv_mutex_trylock_312(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_310(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_313(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_315(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_309(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_311(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_314(struct mutex *ldv_func_arg1 ) ; static void ph_command___0(struct IsdnCardState *cs , unsigned int command ) ; __inline static void cic_int(struct IsdnCardState *cs ) ; static void dch_l2l1___0(struct PStack *st , int pr , void *arg ) ; static void dbusy_timer_handler___0(struct IsdnCardState *cs ) ; static void dch_empty_fifo(struct IsdnCardState *cs , int count ) ; static void dch_fill_fifo(struct IsdnCardState *cs ) ; __inline static void dch_int(struct IsdnCardState *cs ) ; static void dch_setstack(struct PStack *st , struct IsdnCardState *cs ) ; static void dch_init(struct IsdnCardState *cs ) ; static void bch_l2l1(struct PStack *st , int pr , void *arg ) ; static void bch_empty_fifo(struct BCState *bcs , int count ) ; static void bch_fill_fifo(struct BCState *bcs ) ; static void bch_int(struct IsdnCardState *cs , u_char hscx ) ; static void bch_mode(struct BCState *bcs , int mode , int bc ) ; static void bch_close_state(struct BCState *bcs ) ; static int bch_open_state(struct IsdnCardState *cs , struct BCState *bcs ) ; static int bch_setstack(struct PStack *st , struct BCState *bcs ) ; static void bch_init(struct IsdnCardState *cs , int hscx ) ; static void clear_pending_ints(struct IsdnCardState *cs ) ; static void ph_command___0(struct IsdnCardState *cs , unsigned int command ) { { if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"ph_command (%#x) in (%#x)", command, cs->dc.isac.ph_state); } else { } (*(cs->writeisac))(cs, 46, (int )((unsigned int )((int )((u_char )command) << 4U) | 14U)); return; } } __inline static void cic_int(struct IsdnCardState *cs ) { u_char event ; u_char tmp ; { tmp = (*(cs->readisac))(cs, 46); event = (u_char )((int )tmp >> 4); if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"cic_int(event=%#x)", (int )event); } else { } cs->dc.isac.ph_state = (int )event; test_and_set_bit(2, (unsigned long volatile *)(& cs->event)); schedule_work(& cs->tqueue); return; } } static void dch_l2l1___0(struct PStack *st , int pr , void *arg ) { struct IsdnCardState *cs ; struct sk_buff *skb ; u_char cda1_cr ; int tmp ; { cs = (struct IsdnCardState *)st->l1.hardware; skb = (struct sk_buff *)arg; switch (pr) { case 288: ; if ((cs->debug & 1024) != 0) { LogFrame(cs, skb->data, (int )skb->len); } else { } if ((cs->debug & 2048) != 0) { dlogframe(cs, skb, 0); } else { } if ((unsigned long )cs->tx_skb != (unsigned long )((struct sk_buff *)0)) { skb_queue_tail(& cs->sq, skb); if ((cs->debug & 64) != 0) { Logl2Frame(cs, skb, (char *)"PH_DATA Queued", 0); } else { } } else { cs->tx_skb = skb; cs->tx_cnt = 0; if ((cs->debug & 64) != 0) { Logl2Frame(cs, skb, (char *)"PH_DATA", 0); } else { } dch_fill_fifo(cs); } goto ldv_41063; case 306: ; if ((unsigned long )cs->tx_skb != (unsigned long )((struct sk_buff *)0)) { if (cs->debug & 1) { debugl1(cs, (char *)" l2l1 tx_skb exist this shouldn\'t happen"); } else { } skb_queue_tail(& cs->sq, skb); goto ldv_41063; } else { } if ((cs->debug & 1024) != 0) { LogFrame(cs, skb->data, (int )skb->len); } else { } if ((cs->debug & 2048) != 0) { dlogframe(cs, skb, 0); } else { } cs->tx_skb = skb; cs->tx_cnt = 0; if ((cs->debug & 64) != 0) { Logl2Frame(cs, skb, (char *)"PH_DATA_PULLED", 0); } else { } dch_fill_fifo(cs); goto ldv_41063; case 304: ; if ((cs->debug & 64) != 0) { debugl1(cs, (char *)"-> PH_REQUEST_PULL"); } else { } if ((unsigned long )cs->tx_skb == (unsigned long )((struct sk_buff *)0)) { clear_bit(6, (unsigned long volatile *)(& st->l1.Flags)); (*(st->l1.l1l2))(st, 305, 0); } else { set_bit(6U, (unsigned long volatile *)(& st->l1.Flags)); } goto ldv_41063; case 4: ; case 0: ; if ((cs->dc.isac.ph_state == 1 || cs->dc.isac.ph_state == 0) || cs->dc.isac.ph_state == 15) { ph_command___0(cs, 0U); } else { ph_command___0(cs, 1U); } goto ldv_41063; case 48: ph_command___0(cs, 8U); goto ldv_41063; case 112: (*(cs->writeisac))(cs, 68, 128); (*(cs->writeisac))(cs, 69, 129); cda1_cr = (*(cs->readisac))(cs, 78); (*(cs->readisac))(cs, 79); if ((int )((long )arg) & 1) { (*(cs->writeisac))(cs, 78, (int )((unsigned int )cda1_cr | 10U)); } else { (*(cs->writeisac))(cs, 78, (int )cda1_cr & 245); } if (((long )arg & 2L) != 0L) { (*(cs->writeisac))(cs, 78, (int )((unsigned int )cda1_cr | 20U)); } else { (*(cs->writeisac))(cs, 78, (int )cda1_cr & 235); } goto ldv_41063; case 27: skb_queue_purge(& cs->rq); skb_queue_purge(& cs->sq); if ((unsigned long )cs->tx_skb != (unsigned long )((struct sk_buff *)0)) { dev_kfree_skb_any(cs->tx_skb); cs->tx_skb = 0; } else { } tmp = test_and_clear_bit(6, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp != 0) { del_timer(& cs->dbusytimer); } else { } goto ldv_41063; default: ; if (cs->debug & 1) { debugl1(cs, (char *)"dch_l2l1 unknown %04x", pr); } else { } goto ldv_41063; } ldv_41063: ; return; } } static void dbusy_timer_handler___0(struct IsdnCardState *cs ) { struct PStack *st ; int rbchd ; int stard ; u_char tmp ; u_char tmp___0 ; int tmp___1 ; { tmp___1 = constant_test_bit(6U, (unsigned long const volatile *)(& cs->HW_Flags)); if (tmp___1 != 0) { tmp = (*(cs->readisac))(cs, 39); rbchd = (int )tmp; tmp___0 = (*(cs->readisac))(cs, 33); stard = (int )tmp___0; if (cs->debug != 0) { debugl1(cs, (char *)"D-Channel Busy RBCHD %02x STARD %02x", rbchd, stard); } else { } if ((stard & 64) == 0) { set_bit(5U, (unsigned long volatile *)(& cs->HW_Flags)); st = cs->stlist; goto ldv_41079; ldv_41078: (*(st->l1.l1l2))(st, 338, 0); st = st->next; ldv_41079: ; if ((unsigned long )st != (unsigned long )((struct PStack *)0)) { goto ldv_41078; } else { } } else { clear_bit(6, (unsigned long volatile *)(& cs->HW_Flags)); if ((unsigned long )cs->tx_skb != (unsigned long )((struct sk_buff *)0)) { dev_kfree_skb_any(cs->tx_skb); cs->tx_cnt = 0; cs->tx_skb = 0; } else { printk("\fHiSax: ISAC D-Channel Busy no skb\n"); debugl1(cs, (char *)"D-Channel Busy no skb"); } (*(cs->writeisac))(cs, 33, 1); } } else { } return; } } static void dch_empty_fifo(struct IsdnCardState *cs , int count ) { u_char *ptr ; char *t ; int tmp ; { if ((cs->debug & 4) != 0 && (cs->debug & 8) == 0) { debugl1(cs, (char *)"dch_empty_fifo()"); } else { } if (cs->rcvidx + count > 299) { if (cs->debug & 1) { debugl1(cs, (char *)"dch_empty_fifo() incoming message too large"); } else { } (*(cs->writeisac))(cs, 33, 128); cs->rcvidx = 0; return; } else { } ptr = cs->rcvbuf + (unsigned long )cs->rcvidx; cs->rcvidx = cs->rcvidx + count; (*(cs->readisacfifo))(cs, ptr, count); (*(cs->writeisac))(cs, 33, 128); if ((cs->debug & 8) != 0) { t = cs->dlog; tmp = sprintf(t, "dch_empty_fifo() cnt %d", count); t = t + (unsigned long )tmp; QuickHex(t, ptr, count); debugl1(cs, cs->dlog); } else { } return; } } static void dch_fill_fifo(struct IsdnCardState *cs ) { int count ; u_char cmd ; u_char *ptr ; int tmp ; struct lock_class_key __key ; char *t ; int tmp___0 ; { if ((cs->debug & 4) != 0 && (cs->debug & 8) == 0) { debugl1(cs, (char *)"dch_fill_fifo()"); } else { } if ((unsigned long )cs->tx_skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } count = (int )(cs->tx_skb)->len; if (count <= 0) { return; } else { } if (count > 32) { count = 32; cmd = 8U; } else { cmd = 10U; } ptr = (cs->tx_skb)->data; skb_pull(cs->tx_skb, (unsigned int )count); cs->tx_cnt = cs->tx_cnt + count; (*(cs->writeisacfifo))(cs, ptr, count); (*(cs->writeisac))(cs, 33, (int )cmd); tmp = test_and_set_bit(6, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp != 0) { debugl1(cs, (char *)"dch_fill_fifo dbusytimer running"); del_timer(& cs->dbusytimer); } else { } init_timer_key(& cs->dbusytimer, 0U, "(&cs->dbusytimer)", & __key); cs->dbusytimer.expires = (unsigned long )jiffies + 20UL; add_timer(& cs->dbusytimer); if ((cs->debug & 8) != 0) { t = cs->dlog; tmp___0 = sprintf(t, "dch_fill_fifo() cnt %d", count); t = t + (unsigned long )tmp___0; QuickHex(t, ptr, count); debugl1(cs, cs->dlog); } else { } return; } } __inline static void dch_int(struct IsdnCardState *cs ) { struct sk_buff *skb ; u_char istad ; u_char rstad ; int count ; u_char tmp ; size_t __len ; void *__ret ; unsigned char *tmp___1 ; int tmp___2 ; int tmp___3 ; struct sk_buff *tmp___4 ; { istad = (*(cs->readisac))(cs, 32); if ((int )((signed char )istad) < 0) { rstad = (*(cs->readisac))(cs, 40); if (((int )rstad & 240) != 160) { if ((int )((signed char )rstad) >= 0) { if (cs->debug & 1) { debugl1(cs, (char *)"dch_int(): invalid frame"); } else { } } else { } if (((int )rstad & 64) != 0) { if (cs->debug & 1) { debugl1(cs, (char *)"dch_int(): RDO"); } else { } } else { } if (((int )rstad & 32) == 0) { if (cs->debug & 1) { debugl1(cs, (char *)"dch_int(): CRC error"); } else { } } else { } (*(cs->writeisac))(cs, 33, 128); } else { tmp = (*(cs->readisac))(cs, 38); count = (int )tmp; if (count != 0) { count = count - 1; } else { } count = count & 31; if (count == 0) { count = 32; } else { } dch_empty_fifo(cs, count); count = cs->rcvidx; if (count > 0) { cs->rcvidx = 0; skb = dev_alloc_skb((unsigned int )count); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { printk("\fHiSax dch_int(): receive out of memory\n"); } else { __len = (size_t )count; tmp___1 = skb_put(skb, (unsigned int )count); __ret = memcpy((void *)tmp___1, (void const *)cs->rcvbuf, __len); skb_queue_tail(& cs->rq, skb); } } else { } } cs->rcvidx = 0; test_and_set_bit(0, (unsigned long volatile *)(& cs->event)); schedule_work(& cs->tqueue); } else { } if (((int )istad & 64) != 0) { dch_empty_fifo(cs, 32); } else { } if (((int )istad & 32) != 0) { if (cs->debug & 1) { debugl1(cs, (char *)"dch_int(): RFO"); } else { } (*(cs->writeisac))(cs, 33, 64); } else { } if (((int )istad & 16) != 0) { tmp___2 = test_and_clear_bit(6, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___2 != 0) { del_timer(& cs->dbusytimer); } else { } tmp___3 = test_and_clear_bit(5, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___3 != 0) { test_and_set_bit(3, (unsigned long volatile *)(& cs->event)); schedule_work(& cs->tqueue); } else { } if ((unsigned long )cs->tx_skb != (unsigned long )((struct sk_buff *)0)) { if ((cs->tx_skb)->len != 0U) { dch_fill_fifo(cs); goto afterXPR; } else { dev_kfree_skb_irq(cs->tx_skb); cs->tx_skb = 0; cs->tx_cnt = 0; } } else { } tmp___4 = skb_dequeue(& cs->sq); cs->tx_skb = tmp___4; if ((unsigned long )tmp___4 != (unsigned long )((struct sk_buff *)0)) { cs->tx_cnt = 0; dch_fill_fifo(cs); } else { test_and_set_bit(1, (unsigned long volatile *)(& cs->event)); schedule_work(& cs->tqueue); } } else { } afterXPR: ; if (((int )istad & 12) != 0) { if (cs->debug & 1) { debugl1(cs, (char *)"dch_int(): XDU"); } else { } if ((unsigned long )cs->tx_skb != (unsigned long )((struct sk_buff *)0)) { skb_push(cs->tx_skb, (unsigned int )cs->tx_cnt); cs->tx_cnt = 0; dch_fill_fifo(cs); } else { printk("\fHiSax: ISAC XDU no skb\n"); debugl1(cs, (char *)"ISAC XDU no skb"); } } else { } return; } } static void dch_setstack(struct PStack *st , struct IsdnCardState *cs ) { { st->l1.l1hw = & dch_l2l1___0; return; } } static void dch_init(struct IsdnCardState *cs ) { struct lock_class_key __key ; { printk("\016HiSax: IPACX ISDN driver v0.1.0\n"); cs->setstack_d = & dch_setstack; cs->dbusytimer.function = (void (*)(unsigned long ))(& dbusy_timer_handler___0); cs->dbusytimer.data = (unsigned long )cs; init_timer_key(& cs->dbusytimer, 0U, "(&cs->dbusytimer)", & __key); (*(cs->writeisac))(cs, 48, 0); (*(cs->writeisac))(cs, 50, 0); (*(cs->writeisac))(cs, 34, 201); (*(cs->writeisac))(cs, 84, 0); return; } } static void bch_l2l1(struct PStack *st , int pr , void *arg ) { struct BCState *bcs ; struct sk_buff *skb ; u_long flags ; raw_spinlock_t *tmp ; raw_spinlock_t *tmp___0 ; raw_spinlock_t *tmp___1 ; raw_spinlock_t *tmp___2 ; { bcs = st->l1.bcs; skb = (struct sk_buff *)arg; switch (pr) { case 288: tmp = spinlock_check(& (bcs->cs)->lock); flags = _raw_spin_lock_irqsave(tmp); if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { skb_queue_tail(& bcs->squeue, skb); } else { bcs->tx_skb = skb; set_bit(3U, (unsigned long volatile *)(& bcs->Flag)); bcs->hw.hscx.count = 0; bch_fill_fifo(bcs); } spin_unlock_irqrestore(& (bcs->cs)->lock, flags); goto ldv_41126; case 306: tmp___0 = spinlock_check(& (bcs->cs)->lock); flags = _raw_spin_lock_irqsave(tmp___0); if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { printk("\fHiSax bch_l2l1(): this shouldn\'t happen\n"); } else { set_bit(3U, (unsigned long volatile *)(& bcs->Flag)); bcs->tx_skb = skb; bcs->hw.hscx.count = 0; bch_fill_fifo(bcs); } spin_unlock_irqrestore(& (bcs->cs)->lock, flags); goto ldv_41126; case 304: ; if ((unsigned long )bcs->tx_skb == (unsigned long )((struct sk_buff *)0)) { clear_bit(6, (unsigned long volatile *)(& st->l1.Flags)); (*(st->l1.l1l2))(st, 305, 0); } else { set_bit(6U, (unsigned long volatile *)(& st->l1.Flags)); } goto ldv_41126; case 256: tmp___1 = spinlock_check(& (bcs->cs)->lock); flags = _raw_spin_lock_irqsave(tmp___1); set_bit(2U, (unsigned long volatile *)(& bcs->Flag)); bch_mode(bcs, st->l1.mode, st->l1.bc); spin_unlock_irqrestore(& (bcs->cs)->lock, flags); l1_msg_b(st, pr, arg); goto ldv_41126; case 272: l1_msg_b(st, pr, arg); goto ldv_41126; case 273: tmp___2 = spinlock_check(& (bcs->cs)->lock); flags = _raw_spin_lock_irqsave(tmp___2); clear_bit(2, (unsigned long volatile *)(& bcs->Flag)); clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); bch_mode(bcs, 0, st->l1.bc); spin_unlock_irqrestore(& (bcs->cs)->lock, flags); (*(st->l1.l1l2))(st, 273, 0); goto ldv_41126; } ldv_41126: ; return; } } static void bch_empty_fifo(struct BCState *bcs , int count ) { u_char *ptr ; u_char hscx ; struct IsdnCardState *cs ; int cnt ; u_char *tmp ; int tmp___0 ; char *t ; int tmp___1 ; { cs = bcs->cs; hscx = (u_char )bcs->hw.hscx.hscx; if ((cs->debug & 16) != 0 && (cs->debug & 32) == 0) { debugl1(cs, (char *)"bch_empty_fifo()"); } else { } if (bcs->hw.hscx.rcvidx + count > 4096) { if (cs->debug & 1) { debugl1(cs, (char *)"bch_empty_fifo() incoming packet too large"); } else { } (*(cs->BC_Write_Reg))(cs, (int )hscx, 1, 128); bcs->hw.hscx.rcvidx = 0; return; } else { } ptr = bcs->hw.hscx.rcvbuf + (unsigned long )bcs->hw.hscx.rcvidx; cnt = count; goto ldv_41150; ldv_41149: tmp = ptr; ptr = ptr + 1; *tmp = (*(cs->BC_Read_Reg))(cs, (int )hscx, 10); ldv_41150: tmp___0 = cnt; cnt = cnt - 1; if (tmp___0 != 0) { goto ldv_41149; } else { } (*(cs->BC_Write_Reg))(cs, (int )hscx, 1, 128); ptr = bcs->hw.hscx.rcvbuf + (unsigned long )bcs->hw.hscx.rcvidx; bcs->hw.hscx.rcvidx = bcs->hw.hscx.rcvidx + count; if ((cs->debug & 32) != 0) { t = (char *)bcs->blog; tmp___1 = sprintf(t, "bch_empty_fifo() B-%d cnt %d", (int )hscx, count); t = t + (unsigned long )tmp___1; QuickHex(t, ptr, count); debugl1(cs, (char *)bcs->blog); } else { } return; } } static void bch_fill_fifo(struct BCState *bcs ) { struct IsdnCardState *cs ; int more ; int count ; int cnt ; u_char *ptr ; u_char *p ; u_char hscx ; u_char *tmp ; int tmp___0 ; char *t ; int tmp___1 ; { cs = bcs->cs; if ((cs->debug & 16) != 0 && (cs->debug & 32) == 0) { debugl1(cs, (char *)"bch_fill_fifo()"); } else { } if ((unsigned long )bcs->tx_skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } if ((bcs->tx_skb)->len == 0U) { return; } else { } hscx = (u_char )bcs->hw.hscx.hscx; more = bcs->mode == 1; if ((bcs->tx_skb)->len > 64U) { more = 1; count = 64; } else { count = (int )(bcs->tx_skb)->len; } cnt = count; ptr = (bcs->tx_skb)->data; p = ptr; skb_pull(bcs->tx_skb, (unsigned int )count); bcs->tx_cnt = bcs->tx_cnt - count; bcs->hw.hscx.count = bcs->hw.hscx.count + count; goto ldv_41164; ldv_41163: tmp = p; p = p + 1; (*(cs->BC_Write_Reg))(cs, (int )hscx, 10, (int )*tmp); ldv_41164: tmp___0 = cnt; cnt = cnt - 1; if (tmp___0 != 0) { goto ldv_41163; } else { } (*(cs->BC_Write_Reg))(cs, (int )hscx, 1, more != 0 ? 8 : 10); if ((cs->debug & 32) != 0) { t = (char *)bcs->blog; tmp___1 = sprintf(t, "chb_fill_fifo() B-%d cnt %d", (int )hscx, count); t = t + (unsigned long )tmp___1; QuickHex(t, ptr, count); debugl1(cs, (char *)bcs->blog); } else { } return; } } static void bch_int(struct IsdnCardState *cs , u_char hscx ) { u_char istab ; struct BCState *bcs ; struct sk_buff *skb ; int count ; u_char rstab ; int tmp ; u_char tmp___0 ; size_t __len ; void *__ret ; unsigned char *tmp___2 ; size_t __len___0 ; void *__ret___0 ; unsigned char *tmp___3 ; unsigned char *tmp___4 ; u_long flags ; raw_spinlock_t *tmp___5 ; int tmp___6 ; struct sk_buff *tmp___7 ; { bcs = (struct BCState *)(& cs->bcs) + (unsigned long )hscx; istab = (*(cs->BC_Read_Reg))(cs, (int )hscx, 0); tmp = constant_test_bit(1U, (unsigned long const volatile *)(& bcs->Flag)); if (tmp == 0) { return; } else { } if ((int )((signed char )istab) < 0) { rstab = (*(cs->BC_Read_Reg))(cs, (int )hscx, 8); if (((int )rstab & 240) != 160) { if ((int )((signed char )rstab) >= 0) { if (cs->debug & 1) { debugl1(cs, (char *)"bch_int() B-%d: invalid frame", (int )hscx); } else { } } else { } if (((int )rstab & 64) != 0 && bcs->mode != 0) { if (cs->debug & 1) { debugl1(cs, (char *)"bch_int() B-%d: RDO mode=%d", (int )hscx, bcs->mode); } else { } } else { } if (((int )rstab & 32) == 0) { if (cs->debug & 1) { debugl1(cs, (char *)"bch_int() B-%d: CRC error", (int )hscx); } else { } } else { } (*(cs->BC_Write_Reg))(cs, (int )hscx, 1, 128); } else { tmp___0 = (*(cs->BC_Read_Reg))(cs, (int )hscx, 6); count = (int )tmp___0 & 63; if (count == 0) { count = 64; } else { } bch_empty_fifo(bcs, count); count = bcs->hw.hscx.rcvidx + -1; if (count > 0) { if ((cs->debug & 32) != 0) { debugl1(cs, (char *)"bch_int Frame %d", count); } else { } skb = dev_alloc_skb((unsigned int )count); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { printk("\fHiSax bch_int(): receive frame out of memory\n"); } else { __len = (size_t )count; tmp___2 = skb_put(skb, (unsigned int )count); __ret = memcpy((void *)tmp___2, (void const *)bcs->hw.hscx.rcvbuf, __len); skb_queue_tail(& bcs->rqueue, skb); } } else { } } bcs->hw.hscx.rcvidx = 0; test_and_set_bit(0, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } if (((int )istab & 64) != 0) { bch_empty_fifo(bcs, 64); if (bcs->mode == 1) { skb = dev_alloc_skb(64U); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { printk("\fHiSax bch_int(): receive transparent out of memory\n"); } else { __len___0 = 64UL; if (__len___0 > 63UL) { tmp___3 = skb_put(skb, 64U); __ret___0 = memcpy((void *)tmp___3, (void const *)bcs->hw.hscx.rcvbuf, __len___0); } else { tmp___4 = skb_put(skb, 64U); __ret___0 = memcpy((void *)tmp___4, (void const *)bcs->hw.hscx.rcvbuf, __len___0); } skb_queue_tail(& bcs->rqueue, skb); } bcs->hw.hscx.rcvidx = 0; test_and_set_bit(0, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } } else { } if (((int )istab & 32) != 0) { if (cs->debug & 1) { debugl1(cs, (char *)"bch_int() B-%d: RFO error", (int )hscx); } else { } (*(cs->BC_Write_Reg))(cs, (int )hscx, 1, 64); } else { } if (((int )istab & 16) != 0) { if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { if ((bcs->tx_skb)->len != 0U) { bch_fill_fifo(bcs); goto afterXPR; } else { tmp___6 = constant_test_bit(1U, (unsigned long const volatile *)(& (bcs->st)->lli.flag)); if (tmp___6 != 0 && (unsigned int )*((unsigned char *)bcs->tx_skb + 125UL) != 7U) { tmp___5 = spinlock_check(& bcs->aclock); flags = _raw_spin_lock_irqsave(tmp___5); bcs->ackcnt = bcs->ackcnt + bcs->hw.hscx.count; spin_unlock_irqrestore(& bcs->aclock, flags); test_and_set_bit(2, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } } dev_kfree_skb_irq(bcs->tx_skb); bcs->hw.hscx.count = 0; bcs->tx_skb = 0; } else { } tmp___7 = skb_dequeue(& bcs->squeue); bcs->tx_skb = tmp___7; if ((unsigned long )tmp___7 != (unsigned long )((struct sk_buff *)0)) { bcs->hw.hscx.count = 0; set_bit(3U, (unsigned long volatile *)(& bcs->Flag)); bch_fill_fifo(bcs); } else { clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); test_and_set_bit(1, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } } else { } afterXPR: ; if (((int )istab & 4) != 0) { if (bcs->mode == 1) { bch_fill_fifo(bcs); } else { if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { skb_push(bcs->tx_skb, (unsigned int )bcs->hw.hscx.count); bcs->tx_cnt = bcs->tx_cnt + bcs->hw.hscx.count; bcs->hw.hscx.count = 0; } else { } (*(cs->BC_Write_Reg))(cs, (int )hscx, 1, 1); if (cs->debug & 1) { debugl1(cs, (char *)"bch_int() B-%d XDU error", (int )hscx); } else { } } } else { } return; } } static void bch_mode(struct BCState *bcs , int mode , int bc ) { struct IsdnCardState *cs ; int hscx ; { cs = bcs->cs; hscx = bcs->hw.hscx.hscx; bc = bc != 0; if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"mode_bch() switch B-%d mode %d chan %d", hscx, mode, bc); } else { } bcs->mode = mode; bcs->channel = bc; if (hscx == 0) { (*(cs->writeisac))(cs, 72, (int )((u_char )((int )((signed char )bc) | -128))); (*(cs->writeisac))(cs, 81, 136); } else { (*(cs->writeisac))(cs, 74, (int )((u_char )((int )((signed char )bc) | -128))); (*(cs->writeisac))(cs, 82, 136); } switch (mode) { case 0: (*(cs->BC_Write_Reg))(cs, hscx, 2, 192); (*(cs->BC_Write_Reg))(cs, hscx, 3, 48); (*(cs->BC_Write_Reg))(cs, hscx, 0, 255); (*(cs->BC_Write_Reg))(cs, hscx, 1, 65); goto ldv_41195; case 1: (*(cs->BC_Write_Reg))(cs, hscx, 2, 136); (*(cs->BC_Write_Reg))(cs, hscx, 3, 0); (*(cs->BC_Write_Reg))(cs, hscx, 1, 65); (*(cs->BC_Write_Reg))(cs, hscx, 0, 11); goto ldv_41195; case 2: (*(cs->BC_Write_Reg))(cs, hscx, 2, 200); (*(cs->BC_Write_Reg))(cs, hscx, 3, 1); (*(cs->BC_Write_Reg))(cs, hscx, 1, 65); (*(cs->BC_Write_Reg))(cs, hscx, 0, 11); goto ldv_41195; } ldv_41195: ; return; } } static void bch_close_state(struct BCState *bcs ) { int tmp ; { bch_mode(bcs, 0, bcs->channel); tmp = test_and_clear_bit(1, (unsigned long volatile *)(& bcs->Flag)); if (tmp != 0) { kfree((void const *)bcs->hw.hscx.rcvbuf); bcs->hw.hscx.rcvbuf = 0; kfree((void const *)bcs->blog); bcs->blog = 0; skb_queue_purge(& bcs->rqueue); skb_queue_purge(& bcs->squeue); if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { dev_kfree_skb_any(bcs->tx_skb); bcs->tx_skb = 0; clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); } else { } } else { } return; } } static int bch_open_state(struct IsdnCardState *cs , struct BCState *bcs ) { u_char *tmp ; void *tmp___0 ; u_char *tmp___1 ; void *tmp___2 ; int tmp___3 ; { tmp___3 = test_and_set_bit(1, (unsigned long volatile *)(& bcs->Flag)); if (tmp___3 == 0) { tmp___0 = kmalloc(4096UL, 32U); tmp = (u_char *)tmp___0; bcs->hw.hscx.rcvbuf = tmp; if ((unsigned long )tmp == (unsigned long )((u_char *)0)) { printk("\fHiSax open_bchstate(): No memory for hscx.rcvbuf\n"); clear_bit(1, (unsigned long volatile *)(& bcs->Flag)); return (1); } else { } tmp___2 = kmalloc(256UL, 32U); tmp___1 = (u_char *)tmp___2; bcs->blog = tmp___1; if ((unsigned long )tmp___1 == (unsigned long )((u_char *)0)) { printk("\fHiSax open_bchstate: No memory for bcs->blog\n"); clear_bit(1, (unsigned long volatile *)(& bcs->Flag)); kfree((void const *)bcs->hw.hscx.rcvbuf); bcs->hw.hscx.rcvbuf = 0; return (2); } else { } skb_queue_head_init(& bcs->rqueue); skb_queue_head_init(& bcs->squeue); } else { } bcs->tx_skb = 0; clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); bcs->event = 0UL; bcs->hw.hscx.rcvidx = 0; bcs->tx_cnt = 0; return (0); } } static int bch_setstack(struct PStack *st , struct BCState *bcs ) { int tmp ; { bcs->channel = st->l1.bc; tmp = bch_open_state((struct IsdnCardState *)st->l1.hardware, bcs); if (tmp != 0) { return (-1); } else { } st->l1.bcs = bcs; st->l2.l2l1 = & bch_l2l1; setstack_manager(st); bcs->st = st; setstack_l1_B(st); return (0); } } static void bch_init(struct IsdnCardState *cs , int hscx ) { { cs->bcs[hscx].BC_SetStack = & bch_setstack; cs->bcs[hscx].BC_Close = & bch_close_state; cs->bcs[hscx].hw.hscx.hscx = hscx; cs->bcs[hscx].cs = cs; bch_mode((struct BCState *)(& cs->bcs) + (unsigned long )hscx, 0, hscx); return; } } void interrupt_ipacx(struct IsdnCardState *cs ) { u_char ista ; { goto ldv_41218; ldv_41217: ; if ((int )((signed char )ista) < 0) { bch_int(cs, 0); } else { } if (((int )ista & 64) != 0) { bch_int(cs, 1); } else { } if ((int )ista & 1) { dch_int(cs); } else { } if (((int )ista & 16) != 0) { cic_int(cs); } else { } ldv_41218: ista = (*(cs->readisac))(cs, 96); if ((unsigned int )ista != 0U) { goto ldv_41217; } else { } return; } } static void clear_pending_ints(struct IsdnCardState *cs ) { int ista ; u_char tmp ; { (*(cs->writeisac))(cs, 96, 255); (*(cs->writeisac))(cs, 32, 255); (*(cs->BC_Write_Reg))(cs, 0, 0, 255); (*(cs->BC_Write_Reg))(cs, 1, 0, 255); tmp = (*(cs->readisac))(cs, 96); ista = (int )tmp; if ((ista & 128) != 0) { (*(cs->BC_Read_Reg))(cs, 0, 0); } else { } if ((ista & 64) != 0) { (*(cs->BC_Read_Reg))(cs, 1, 0); } else { } if ((ista & 16) != 0) { (*(cs->readisac))(cs, 46); } else { } if (ista & 1) { (*(cs->readisac))(cs, 32); } else { } return; } } void init_ipacx(struct IsdnCardState *cs , int part ) { { if (part & 1) { clear_pending_ints(cs); bch_init(cs, 0); bch_init(cs, 1); dch_init(cs); } else { } if ((part & 2) != 0) { (*(cs->BC_Write_Reg))(cs, 0, 0, 11); (*(cs->BC_Write_Reg))(cs, 1, 0, 11); (*(cs->writeisac))(cs, 32, 3); (*(cs->writeisac))(cs, 96, 46); (*(cs->writeisac))(cs, 33, 65); (*(cs->BC_Write_Reg))(cs, 0, 1, 65); (*(cs->BC_Write_Reg))(cs, 1, 1, 65); ph_command___0(cs, 1U); } else { } return; } } void ldv_mutex_lock_309(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_lock(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_310(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_lock(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_311(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } int ldv_mutex_trylock_312(struct mutex *ldv_func_arg1 ) { ldv_func_ret_type___2 ldv_func_res ; int tmp ; int tmp___0 ; { tmp = mutex_trylock(ldv_func_arg1); ldv_func_res = tmp; tmp___0 = ldv_mutex_trylock_mutex(ldv_func_arg1); return (tmp___0); return (ldv_func_res); } } void ldv_mutex_unlock_313(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_314(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_cred_guard_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_315(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_cred_guard_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } int ldv_mutex_trylock_326(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_324(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_327(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_329(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_323(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_325(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_328(struct mutex *ldv_func_arg1 ) ; int ISARVersion(struct IsdnCardState *cs , char *s ) ; void isar_int_main(struct IsdnCardState *cs ) ; void initisar(struct IsdnCardState *cs ) ; void isar_fill_fifo(struct BCState *bcs ) ; int isar_auxcmd(struct IsdnCardState *cs , isdn_ctrl *ic ) ; static char const *Sedlbauer_revision = "$Revision: 1.34.2.6 $"; static char const *Sedlbauer_Types[10U] = { "None", "speed card/win", "speed star", "speed fax+", "speed win II / ISDN PC/104", "speed star II", "speed pci", "speed fax+ pyramid", "speed fax+ pci", "HST Saphir III"}; static u_char ReadISAC___6(struct IsdnCardState *cs , u_char offset ) { u_char tmp ; { tmp = readreg___1(cs->hw.sedl.adr, cs->hw.sedl.isac, (int )offset); return (tmp); } } static void WriteISAC___6(struct IsdnCardState *cs , u_char offset , u_char value ) { { writereg___1(cs->hw.sedl.adr, cs->hw.sedl.isac, (int )offset, (int )value); return; } } static void ReadISACfifo___6(struct IsdnCardState *cs , u_char *data , int size ) { { readfifo(cs->hw.sedl.adr, cs->hw.sedl.isac, 0, data, size); return; } } static void WriteISACfifo___6(struct IsdnCardState *cs , u_char *data , int size ) { { writefifo(cs->hw.sedl.adr, cs->hw.sedl.isac, 0, data, size); return; } } static u_char ReadISAC_IPAC___1(struct IsdnCardState *cs , u_char offset ) { u_char tmp ; { tmp = readreg___1(cs->hw.sedl.adr, cs->hw.sedl.isac, (int )((unsigned int )offset | 128U)); return (tmp); } } static void WriteISAC_IPAC___1(struct IsdnCardState *cs , u_char offset , u_char value ) { { writereg___1(cs->hw.sedl.adr, cs->hw.sedl.isac, (int )((unsigned int )offset | 128U), (int )value); return; } } static void ReadISACfifo_IPAC___1(struct IsdnCardState *cs , u_char *data , int size ) { { readfifo(cs->hw.sedl.adr, cs->hw.sedl.isac, 128, data, size); return; } } static void WriteISACfifo_IPAC___1(struct IsdnCardState *cs , u_char *data , int size ) { { writefifo(cs->hw.sedl.adr, cs->hw.sedl.isac, 128, data, size); return; } } static u_char ReadHSCX___5(struct IsdnCardState *cs , int hscx , u_char offset ) { u_char tmp ; { tmp = readreg___1(cs->hw.sedl.adr, cs->hw.sedl.hscx, (int )((hscx != 0 ? 64U : 0U) + (unsigned int )offset)); return (tmp); } } static void WriteHSCX___5(struct IsdnCardState *cs , int hscx , u_char offset , u_char value ) { { writereg___1(cs->hw.sedl.adr, cs->hw.sedl.hscx, (int )((hscx != 0 ? 64U : 0U) + (unsigned int )offset), (int )value); return; } } static u_char ReadISAR(struct IsdnCardState *cs , int mode , u_char offset ) { u_char tmp ; unsigned char tmp___0 ; { if (mode == 0) { tmp = readreg___1(cs->hw.sedl.adr, cs->hw.sedl.hscx, (int )offset); return (tmp); } else if (mode == 1) { outb((int )offset, (int )cs->hw.sedl.adr); } else { } tmp___0 = inb((int )cs->hw.sedl.hscx); return (tmp___0); } } static void WriteISAR(struct IsdnCardState *cs , int mode , u_char offset , u_char value ) { { if (mode == 0) { writereg___1(cs->hw.sedl.adr, cs->hw.sedl.hscx, (int )offset, (int )value); } else { if (mode == 1) { outb((int )offset, (int )cs->hw.sedl.adr); } else { } outb((int )value, (int )cs->hw.sedl.hscx); } return; } } __inline static void waitforCEC___5(struct IsdnCardState *cs , int hscx ) { int to ; u_char tmp ; { to = 50; goto ldv_41386; ldv_41385: __const_udelay(4295UL); to = to - 1; ldv_41386: tmp = readreg___1(cs->hw.sedl.adr, cs->hw.sedl.hscx, hscx != 0 ? 97 : 33); if (((int )tmp & 4) != 0 && to != 0) { goto ldv_41385; } else { } if (to == 0) { printk("\fHiSax: waitforCEC timeout\n"); } else { } return; } } __inline static void waitforXFW___5(struct IsdnCardState *cs , int hscx ) { int to ; u_char tmp ; { to = 50; goto ldv_41394; ldv_41393: __const_udelay(4295UL); to = to - 1; ldv_41394: tmp = readreg___1(cs->hw.sedl.adr, cs->hw.sedl.hscx, hscx != 0 ? 97 : 33); if (((int )tmp & 68) != 64 && to != 0) { goto ldv_41393; } else { } if (to == 0) { printk("\fHiSax: waitforXFW timeout\n"); } else { } return; } } __inline static void WriteHSCXCMDR___5(struct IsdnCardState *cs , int hscx , u_char data ) { { waitforCEC___5(cs, hscx); writereg___1(cs->hw.sedl.adr, cs->hw.sedl.hscx, hscx != 0 ? 97 : 33, (int )data); return; } } static void hscx_empty_fifo___5(struct BCState *bcs , int count ) { u_char *ptr ; struct IsdnCardState *cs ; char *t ; int tmp ; { cs = bcs->cs; if ((cs->debug & 16) != 0 && (cs->debug & 32) == 0) { debugl1(cs, (char *)"hscx_empty_fifo"); } else { } if (bcs->hw.hscx.rcvidx + count > 4096) { if (cs->debug & 1) { debugl1(cs, (char *)"hscx_empty_fifo: incoming packet too large"); } else { } WriteHSCXCMDR___5(cs, bcs->hw.hscx.hscx, 128); bcs->hw.hscx.rcvidx = 0; return; } else { } ptr = bcs->hw.hscx.rcvbuf + (unsigned long )bcs->hw.hscx.rcvidx; bcs->hw.hscx.rcvidx = bcs->hw.hscx.rcvidx + count; readfifo(cs->hw.sedl.adr, cs->hw.sedl.hscx, bcs->hw.hscx.hscx != 0 ? 64 : 0, ptr, count); WriteHSCXCMDR___5(cs, bcs->hw.hscx.hscx, 128); if ((cs->debug & 32) != 0) { t = (char *)bcs->blog; tmp = sprintf(t, "hscx_empty_fifo %c cnt %d", bcs->hw.hscx.hscx != 0 ? 66 : 65, count); t = t + (unsigned long )tmp; QuickHex(t, ptr, count); debugl1(cs, (char *)bcs->blog); } else { } return; } } static void hscx_fill_fifo___5(struct BCState *bcs ) { struct IsdnCardState *cs ; int more ; int count ; int fifo_size ; int tmp ; u_char *ptr ; char *t ; int tmp___0 ; { cs = bcs->cs; tmp = constant_test_bit(1U, (unsigned long const volatile *)(& cs->HW_Flags)); fifo_size = tmp != 0 ? 64 : 32; if ((cs->debug & 16) != 0 && (cs->debug & 32) == 0) { debugl1(cs, (char *)"hscx_fill_fifo"); } else { } if ((unsigned long )bcs->tx_skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } if ((bcs->tx_skb)->len == 0U) { return; } else { } more = bcs->mode == 1; if ((bcs->tx_skb)->len > (unsigned int )fifo_size) { more = 1; count = fifo_size; } else { count = (int )(bcs->tx_skb)->len; } waitforXFW___5(cs, bcs->hw.hscx.hscx); ptr = (bcs->tx_skb)->data; skb_pull(bcs->tx_skb, (unsigned int )count); bcs->tx_cnt = bcs->tx_cnt - count; bcs->hw.hscx.count = bcs->hw.hscx.count + count; writefifo(cs->hw.sedl.adr, cs->hw.sedl.hscx, bcs->hw.hscx.hscx != 0 ? 64 : 0, ptr, count); WriteHSCXCMDR___5(cs, bcs->hw.hscx.hscx, more != 0 ? 8 : 10); if ((cs->debug & 32) != 0) { t = (char *)bcs->blog; tmp___0 = sprintf(t, "hscx_fill_fifo %c cnt %d", bcs->hw.hscx.hscx != 0 ? 66 : 65, count); t = t + (unsigned long )tmp___0; QuickHex(t, ptr, count); debugl1(cs, (char *)bcs->blog); } else { } return; } } static void hscx_interrupt___5(struct IsdnCardState *cs , u_char val , u_char hscx ) { u_char r ; struct BCState *bcs ; struct sk_buff *skb ; int fifo_size ; int tmp ; int count ; int tmp___0 ; u_char tmp___1 ; int tmp___2 ; size_t __len ; void *__ret ; unsigned char *tmp___4 ; size_t __len___0 ; void *__ret___0 ; unsigned char *tmp___6 ; u_long flags ; raw_spinlock_t *tmp___7 ; int tmp___8 ; struct sk_buff *tmp___9 ; { bcs = (struct BCState *)(& cs->bcs) + (unsigned long )hscx; tmp = constant_test_bit(1U, (unsigned long const volatile *)(& cs->HW_Flags)); fifo_size = tmp != 0 ? 64 : 32; tmp___0 = constant_test_bit(1U, (unsigned long const volatile *)(& bcs->Flag)); if (tmp___0 == 0) { return; } else { } if ((int )((signed char )val) < 0) { r = readreg___1(cs->hw.sedl.adr, cs->hw.sedl.hscx, (unsigned int )hscx != 0U ? 103 : 39); if (((int )r & 240) != 160) { if ((int )((signed char )r) >= 0) { if (cs->debug & 1) { debugl1(cs, (char *)"HSCX invalid frame"); } else { } bcs->err_inv = bcs->err_inv + 1; } else { } if (((int )r & 64) != 0 && bcs->mode != 0) { if (cs->debug & 1) { debugl1(cs, (char *)"HSCX RDO mode=%d", bcs->mode); } else { } bcs->err_rdo = bcs->err_rdo + 1; } else { } if (((int )r & 32) == 0) { if (cs->debug & 1) { debugl1(cs, (char *)"HSCX CRC error"); } else { } bcs->err_crc = bcs->err_crc + 1; } else { } WriteHSCXCMDR___5(cs, (int )hscx, 128); } else { tmp___1 = readreg___1(cs->hw.sedl.adr, cs->hw.sedl.hscx, (unsigned int )hscx != 0U ? 101 : 37); tmp___2 = constant_test_bit(1U, (unsigned long const volatile *)(& cs->HW_Flags)); count = (int )tmp___1 & (tmp___2 != 0 ? 63 : 31); if (count == 0) { count = fifo_size; } else { } hscx_empty_fifo___5(bcs, count); count = bcs->hw.hscx.rcvidx + -1; if (count > 0) { if ((cs->debug & 32) != 0) { debugl1(cs, (char *)"HX Frame %d", count); } else { } skb = dev_alloc_skb((unsigned int )count); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { printk("\fHSCX: receive out of memory\n"); } else { __len = (size_t )count; tmp___4 = skb_put(skb, (unsigned int )count); __ret = memcpy((void *)tmp___4, (void const *)bcs->hw.hscx.rcvbuf, __len); skb_queue_tail(& bcs->rqueue, skb); } } else { } } bcs->hw.hscx.rcvidx = 0; test_and_set_bit(0, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } if (((int )val & 64) != 0) { hscx_empty_fifo___5(bcs, fifo_size); if (bcs->mode == 1) { skb = dev_alloc_skb((unsigned int )fifo_size); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { printk("\fHiSax: receive out of memory\n"); } else { __len___0 = (size_t )fifo_size; tmp___6 = skb_put(skb, (unsigned int )fifo_size); __ret___0 = memcpy((void *)tmp___6, (void const *)bcs->hw.hscx.rcvbuf, __len___0); skb_queue_tail(& bcs->rqueue, skb); } bcs->hw.hscx.rcvidx = 0; test_and_set_bit(0, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } } else { } if (((int )val & 16) != 0) { if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { if ((bcs->tx_skb)->len != 0U) { hscx_fill_fifo___5(bcs); return; } else { tmp___8 = constant_test_bit(1U, (unsigned long const volatile *)(& (bcs->st)->lli.flag)); if (tmp___8 != 0 && (unsigned int )*((unsigned char *)bcs->tx_skb + 125UL) != 7U) { tmp___7 = spinlock_check(& bcs->aclock); flags = _raw_spin_lock_irqsave(tmp___7); bcs->ackcnt = bcs->ackcnt + bcs->hw.hscx.count; spin_unlock_irqrestore(& bcs->aclock, flags); test_and_set_bit(2, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } dev_kfree_skb_irq(bcs->tx_skb); bcs->hw.hscx.count = 0; bcs->tx_skb = 0; } } else { } tmp___9 = skb_dequeue(& bcs->squeue); bcs->tx_skb = tmp___9; if ((unsigned long )tmp___9 != (unsigned long )((struct sk_buff *)0)) { bcs->hw.hscx.count = 0; test_and_set_bit(3, (unsigned long volatile *)(& bcs->Flag)); hscx_fill_fifo___5(bcs); } else { test_and_clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); test_and_set_bit(1, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } } else { } return; } } static void hscx_int_main___5(struct IsdnCardState *cs , u_char val ) { u_char exval ; struct BCState *bcs ; { if ((int )val & 1) { bcs = (struct BCState *)(& cs->bcs) + 1UL; exval = readreg___1(cs->hw.sedl.adr, cs->hw.sedl.hscx, 100); if (((int )exval & 64) != 0) { if (bcs->mode == 1) { hscx_fill_fifo___5(bcs); } else { bcs->err_tx = bcs->err_tx + 1; if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { skb_push(bcs->tx_skb, (unsigned int )bcs->hw.hscx.count); bcs->tx_cnt = bcs->tx_cnt + bcs->hw.hscx.count; bcs->hw.hscx.count = 0; } else { } WriteHSCXCMDR___5(cs, bcs->hw.hscx.hscx, 1); if (cs->debug & 1) { debugl1(cs, (char *)"HSCX B EXIR %x Lost TX", (int )exval); } else { } } } else if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HSCX B EXIR %x", (int )exval); } else { } } else { } if (((int )val & 248) != 0) { if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HSCX B interrupt %x", (int )val); } else { } hscx_interrupt___5(cs, (int )val, 1); } else { } if (((int )val & 2) != 0) { bcs = (struct BCState *)(& cs->bcs); exval = readreg___1(cs->hw.sedl.adr, cs->hw.sedl.hscx, 36); if (((int )exval & 64) != 0) { if (bcs->mode == 1) { hscx_fill_fifo___5(bcs); } else { bcs->err_tx = bcs->err_tx + 1; if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { skb_push(bcs->tx_skb, (unsigned int )bcs->hw.hscx.count); bcs->tx_cnt = bcs->tx_cnt + bcs->hw.hscx.count; bcs->hw.hscx.count = 0; } else { } WriteHSCXCMDR___5(cs, bcs->hw.hscx.hscx, 1); if (cs->debug & 1) { debugl1(cs, (char *)"HSCX A EXIR %x Lost TX", (int )exval); } else { } } } else if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HSCX A EXIR %x", (int )exval); } else { } } else { } if (((int )val & 4) != 0) { exval = readreg___1(cs->hw.sedl.adr, cs->hw.sedl.hscx, 32); if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HSCX A interrupt %x", (int )exval); } else { } hscx_interrupt___5(cs, (int )exval, 0); } else { } return; } } static irqreturn_t sedlbauer_interrupt(int intno , void *dev_id ) { struct IsdnCardState *cs ; u_char val ; u_long flags ; raw_spinlock_t *tmp ; { cs = (struct IsdnCardState *)dev_id; tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); if (cs->hw.sedl.bus == 3U && *(cs->busy_flag) == 1) { spin_unlock_irqrestore(& cs->lock, flags); printk("\fSedlbauer: card not available!\n"); return (0); } else { } val = readreg___1(cs->hw.sedl.adr, cs->hw.sedl.hscx, 96); Start_HSCX: ; if ((unsigned int )val != 0U) { hscx_int_main___5(cs, (int )val); } else { } val = readreg___1(cs->hw.sedl.adr, cs->hw.sedl.isac, 32); Start_ISAC: ; if ((unsigned int )val != 0U) { isac_interrupt(cs, (int )val); } else { } val = readreg___1(cs->hw.sedl.adr, cs->hw.sedl.hscx, 96); if ((unsigned int )val != 0U) { if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HSCX IntStat after IntRoutine"); } else { } goto Start_HSCX; } else { } val = readreg___1(cs->hw.sedl.adr, cs->hw.sedl.isac, 32); if ((unsigned int )val != 0U) { if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"ISAC IntStat after IntRoutine"); } else { } goto Start_ISAC; } else { } writereg___1(cs->hw.sedl.adr, cs->hw.sedl.hscx, 32, 255); writereg___1(cs->hw.sedl.adr, cs->hw.sedl.hscx, 96, 255); writereg___1(cs->hw.sedl.adr, cs->hw.sedl.isac, 32, 255); writereg___1(cs->hw.sedl.adr, cs->hw.sedl.isac, 32, 0); writereg___1(cs->hw.sedl.adr, cs->hw.sedl.hscx, 32, 0); writereg___1(cs->hw.sedl.adr, cs->hw.sedl.hscx, 96, 0); spin_unlock_irqrestore(& cs->lock, flags); return (1); } } static irqreturn_t sedlbauer_interrupt_ipac(int intno , void *dev_id ) { struct IsdnCardState *cs ; u_char ista ; u_char val ; u_char icnt ; u_long flags ; raw_spinlock_t *tmp ; u_char tmp___0 ; { cs = (struct IsdnCardState *)dev_id; icnt = 5U; tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); ista = readreg___1(cs->hw.sedl.adr, cs->hw.sedl.isac, 193); Start_IPAC: ; if ((cs->debug & 128) != 0) { debugl1(cs, (char *)"IPAC ISTA %02X", (int )ista); } else { } if (((int )ista & 15) != 0) { val = readreg___1(cs->hw.sedl.adr, cs->hw.sedl.hscx, 96); if ((int )ista & 1) { val = (u_char )((unsigned int )val | 1U); } else { } if (((int )ista & 4) != 0) { val = (u_char )((unsigned int )val | 2U); } else { } if (((int )ista & 8) != 0) { val = (u_char )((unsigned int )val | 4U); } else { } if ((unsigned int )val != 0U) { hscx_int_main___5(cs, (int )val); } else { } } else { } if (((int )ista & 32) != 0) { tmp___0 = readreg___1(cs->hw.sedl.adr, cs->hw.sedl.isac, 160); val = (unsigned int )tmp___0 & 254U; if ((unsigned int )val != 0U) { isac_interrupt(cs, (int )val); } else { } } else { } if (((int )ista & 16) != 0) { val = 1U; isac_interrupt(cs, (int )val); } else { } ista = readreg___1(cs->hw.sedl.adr, cs->hw.sedl.isac, 193); if (((int )ista & 63) != 0 && (unsigned int )icnt != 0U) { icnt = (u_char )((int )icnt - 1); goto Start_IPAC; } else { } if ((unsigned int )icnt == 0U) { if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"Sedlbauer IRQ LOOP"); } else { } } else { } writereg___1(cs->hw.sedl.adr, cs->hw.sedl.isac, 193, 255); writereg___1(cs->hw.sedl.adr, cs->hw.sedl.isac, 193, 192); spin_unlock_irqrestore(& cs->lock, flags); return (1); } } static irqreturn_t sedlbauer_interrupt_isar(int intno , void *dev_id ) { struct IsdnCardState *cs ; u_char val ; int cnt ; u_long flags ; raw_spinlock_t *tmp ; { cs = (struct IsdnCardState *)dev_id; cnt = 5; tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); val = readreg___1(cs->hw.sedl.adr, cs->hw.sedl.hscx, 117); Start_ISAR: ; if (((int )val & 4) != 0) { isar_int_main(cs); } else { } val = readreg___1(cs->hw.sedl.adr, cs->hw.sedl.isac, 32); Start_ISAC: ; if ((unsigned int )val != 0U) { isac_interrupt(cs, (int )val); } else { } val = readreg___1(cs->hw.sedl.adr, cs->hw.sedl.hscx, 117); if (((int )val & 4) != 0) { cnt = cnt - 1; if (cnt != 0) { if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"ISAR IntStat after IntRoutine"); } else { } goto Start_ISAR; } else { } } else { } val = readreg___1(cs->hw.sedl.adr, cs->hw.sedl.isac, 32); if ((unsigned int )val != 0U) { cnt = cnt - 1; if (cnt != 0) { if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"ISAC IntStat after IntRoutine"); } else { } goto Start_ISAC; } else { } } else { } if (cnt == 0) { if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"Sedlbauer IRQ LOOP"); } else { } } else { } writereg___1(cs->hw.sedl.adr, cs->hw.sedl.hscx, 117, 0); writereg___1(cs->hw.sedl.adr, cs->hw.sedl.isac, 32, 255); writereg___1(cs->hw.sedl.adr, cs->hw.sedl.isac, 32, 0); writereg___1(cs->hw.sedl.adr, cs->hw.sedl.hscx, 117, 4); spin_unlock_irqrestore(& cs->lock, flags); return (1); } } static void release_io_sedlbauer(struct IsdnCardState *cs ) { int bytecnt ; { bytecnt = 8; if ((unsigned int )cs->subtyp == 3U) { bytecnt = 16; } else if (cs->hw.sedl.bus == 2U) { bytecnt = 256; } else { } if (cs->hw.sedl.cfg_reg != 0U) { __release_region(& ioport_resource, (resource_size_t )cs->hw.sedl.cfg_reg, (resource_size_t )bytecnt); } else { } return; } } static void reset_sedlbauer(struct IsdnCardState *cs ) { unsigned long __ms ; unsigned long tmp ; unsigned long __ms___0 ; unsigned long tmp___0 ; unsigned long __ms___1 ; unsigned long tmp___1 ; unsigned long __ms___2 ; unsigned long tmp___2 ; unsigned long __ms___3 ; unsigned long tmp___3 ; unsigned long __ms___4 ; unsigned long tmp___4 ; { printk("\016Sedlbauer: resetting card\n"); if (cs->hw.sedl.bus != 3U || cs->hw.sedl.chip != 1U) { if (cs->hw.sedl.chip == 3U) { writereg___1(cs->hw.sedl.adr, cs->hw.sedl.isac, 201, 32); if (1) { __const_udelay(8590000UL); } else { __ms = 2UL; goto ldv_41490; ldv_41489: __const_udelay(4295000UL); ldv_41490: tmp = __ms; __ms = __ms - 1UL; if (tmp != 0UL) { goto ldv_41489; } else { } } writereg___1(cs->hw.sedl.adr, cs->hw.sedl.isac, 201, 0); __ms___0 = 10UL; goto ldv_41494; ldv_41493: __const_udelay(4295000UL); ldv_41494: tmp___0 = __ms___0; __ms___0 = __ms___0 - 1UL; if (tmp___0 != 0UL) { goto ldv_41493; } else { } writereg___1(cs->hw.sedl.adr, cs->hw.sedl.isac, 192, 0); writereg___1(cs->hw.sedl.adr, cs->hw.sedl.isac, 195, 255); writereg___1(cs->hw.sedl.adr, cs->hw.sedl.isac, 196, 0); writereg___1(cs->hw.sedl.adr, cs->hw.sedl.isac, 193, 192); writereg___1(cs->hw.sedl.adr, cs->hw.sedl.isac, 202, 18); } else if (cs->hw.sedl.chip == 2U && cs->hw.sedl.bus == 2U) { outb((int )((unsigned char )cs->hw.sedl.reset_on), (int )(cs->hw.sedl.cfg_reg + 3U)); if (1) { __const_udelay(8590000UL); } else { __ms___1 = 2UL; goto ldv_41498; ldv_41497: __const_udelay(4295000UL); ldv_41498: tmp___1 = __ms___1; __ms___1 = __ms___1 - 1UL; if (tmp___1 != 0UL) { goto ldv_41497; } else { } } outb((int )((unsigned char )cs->hw.sedl.reset_off), (int )(cs->hw.sedl.cfg_reg + 3U)); __ms___2 = 10UL; goto ldv_41502; ldv_41501: __const_udelay(4295000UL); ldv_41502: tmp___2 = __ms___2; __ms___2 = __ms___2 - 1UL; if (tmp___2 != 0UL) { goto ldv_41501; } else { } } else { outb(3, (int )cs->hw.sedl.reset_on); if (1) { __const_udelay(8590000UL); } else { __ms___3 = 2UL; goto ldv_41506; ldv_41505: __const_udelay(4295000UL); ldv_41506: tmp___3 = __ms___3; __ms___3 = __ms___3 - 1UL; if (tmp___3 != 0UL) { goto ldv_41505; } else { } } outb(0, (int )cs->hw.sedl.reset_off); __ms___4 = 10UL; goto ldv_41510; ldv_41509: __const_udelay(4295000UL); ldv_41510: tmp___4 = __ms___4; __ms___4 = __ms___4 - 1UL; if (tmp___4 != 0UL) { goto ldv_41509; } else { } } } else { } return; } } static int Sedl_card_msg(struct IsdnCardState *cs , int mt , void *arg ) { u_long flags ; raw_spinlock_t *tmp ; raw_spinlock_t *tmp___0 ; raw_spinlock_t *tmp___1 ; raw_spinlock_t *tmp___2 ; raw_spinlock_t *tmp___3 ; { switch (mt) { case 240: tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); reset_sedlbauer(cs); spin_unlock_irqrestore(& cs->lock, flags); return (0); case 243: ; if (cs->hw.sedl.bus == 2U) { outb(0, (int )(cs->hw.sedl.cfg_reg + 5U)); } else { } if (cs->hw.sedl.chip == 2U) { tmp___0 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___0); writereg___1(cs->hw.sedl.adr, cs->hw.sedl.hscx, 117, 0); writereg___1(cs->hw.sedl.adr, cs->hw.sedl.isac, 32, 255); reset_sedlbauer(cs); writereg___1(cs->hw.sedl.adr, cs->hw.sedl.hscx, 117, 0); writereg___1(cs->hw.sedl.adr, cs->hw.sedl.isac, 32, 255); spin_unlock_irqrestore(& cs->lock, flags); } else { } release_io_sedlbauer(cs); return (0); case 242: tmp___1 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___1); if (cs->hw.sedl.bus == 2U) { outb(2, (int )(cs->hw.sedl.cfg_reg + 5U)); } else { } reset_sedlbauer(cs); if (cs->hw.sedl.chip == 2U) { clear_pending_isac_ints(cs); writereg___1(cs->hw.sedl.adr, cs->hw.sedl.hscx, 117, 0); initisac(cs); initisar(cs); (*(cs->writeisac))(cs, 32, 0); (*(cs->writeisac))(cs, 33, 65); } else { inithscxisac(cs, 3); } spin_unlock_irqrestore(& cs->lock, flags); return (0); case 244: ; return (0); case 740: ; if ((unsigned int )cs->subtyp != 7U) { return (0); } else { } tmp___2 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___2); if ((unsigned long )arg != (unsigned long )((void *)0)) { cs->hw.sedl.reset_off = cs->hw.sedl.reset_off & 4294967279U; } else { cs->hw.sedl.reset_off = cs->hw.sedl.reset_off & 4294967287U; } outb((int )((unsigned char )cs->hw.sedl.reset_off), (int )(cs->hw.sedl.cfg_reg + 3U)); spin_unlock_irqrestore(& cs->lock, flags); goto ldv_41535; case 744: ; if ((unsigned int )cs->subtyp != 7U) { return (0); } else { } tmp___3 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___3); if ((unsigned long )arg != (unsigned long )((void *)0)) { cs->hw.sedl.reset_off = cs->hw.sedl.reset_off | 16U; } else { cs->hw.sedl.reset_off = cs->hw.sedl.reset_off | 8U; } outb((int )((unsigned char )cs->hw.sedl.reset_off), (int )(cs->hw.sedl.cfg_reg + 3U)); spin_unlock_irqrestore(& cs->lock, flags); goto ldv_41535; } ldv_41535: ; return (0); } } static int setup_sedlbauer_isapnp(struct IsdnCard *card , int *bytecnt ) { { return (-1); } } static struct pci_dev *dev_sedl = 0; static int setup_sedlbauer_pci(struct IsdnCard *card ) { struct IsdnCardState *cs ; u16 sub_vendor_id___0 ; u16 sub_id ; int tmp ; unsigned long __ms ; unsigned long tmp___0 ; unsigned long __ms___0 ; unsigned long tmp___1 ; { cs = card->cs; dev_sedl = hisax_find_pci_device(57689U, 2U, dev_sedl); if ((unsigned long )dev_sedl != (unsigned long )((struct pci_dev *)0)) { tmp = pci_enable_device(dev_sedl); if (tmp != 0) { return (0); } else { } cs->irq = dev_sedl->irq; if (cs->irq == 0U) { printk("\fSedlbauer: No IRQ for PCI card found\n"); return (0); } else { } cs->hw.sedl.cfg_reg = (unsigned int )dev_sedl->resource[0].start; } else { printk("\fSedlbauer: No PCI card found\n"); return (0); } cs->irq_flags = cs->irq_flags | 128UL; cs->hw.sedl.bus = 2U; sub_vendor_id___0 = dev_sedl->subsystem_vendor; sub_id = dev_sedl->subsystem_device; printk("\016Sedlbauer: PCI subvendor:%x subid %x\n", (int )sub_vendor_id___0, (int )sub_id); printk("\016Sedlbauer: PCI base adr %#x\n", cs->hw.sedl.cfg_reg); if ((unsigned int )sub_id != 1U) { printk("\vSedlbauer: unknown sub id %#x\n", (int )sub_id); return (0); } else { } if ((unsigned int )sub_vendor_id___0 == 81U) { cs->hw.sedl.chip = 2U; cs->subtyp = 7U; } else if ((unsigned int )sub_vendor_id___0 == 84U) { cs->hw.sedl.chip = 2U; cs->subtyp = 8U; } else if ((unsigned int )sub_vendor_id___0 == 82U) { cs->hw.sedl.chip = 3U; cs->subtyp = 9U; } else if ((unsigned int )sub_vendor_id___0 == 83U) { cs->hw.sedl.chip = 3U; cs->subtyp = 6U; } else { printk("\vSedlbauer: unknown sub vendor id %#x\n", (int )sub_vendor_id___0); return (0); } cs->hw.sedl.reset_on = 1U; cs->hw.sedl.reset_off = 24U; outb(255, (int )cs->hw.sedl.cfg_reg); outb(0, (int )cs->hw.sedl.cfg_reg); outb(221, (int )(cs->hw.sedl.cfg_reg + 2U)); outb(0, (int )(cs->hw.sedl.cfg_reg + 5U)); outb((int )((unsigned char )cs->hw.sedl.reset_on), (int )(cs->hw.sedl.cfg_reg + 3U)); if (1) { __const_udelay(8590000UL); } else { __ms = 2UL; goto ldv_41553; ldv_41552: __const_udelay(4295000UL); ldv_41553: tmp___0 = __ms; __ms = __ms - 1UL; if (tmp___0 != 0UL) { goto ldv_41552; } else { } } outb((int )((unsigned char )cs->hw.sedl.reset_off), (int )(cs->hw.sedl.cfg_reg + 3U)); __ms___0 = 10UL; goto ldv_41557; ldv_41556: __const_udelay(4295000UL); ldv_41557: tmp___1 = __ms___0; __ms___0 = __ms___0 - 1UL; if (tmp___1 != 0UL) { goto ldv_41556; } else { } return (1); } } int setup_sedlbauer(struct IsdnCard *card ) { int bytecnt ; int ver ; int val ; int rc ; struct IsdnCardState *cs ; char tmp[64U] ; char *tmp___0 ; struct resource *tmp___1 ; u_char tmp___2 ; u_char tmp___3 ; int tmp___4 ; { bytecnt = 8; cs = card->cs; strcpy((char *)(& tmp), Sedlbauer_revision); tmp___0 = HiSax_getrev((char const *)(& tmp)); printk("\016HiSax: Sedlbauer driver Rev. %s\n", tmp___0); if ((unsigned int )cs->typ == 15U) { cs->subtyp = 1U; cs->hw.sedl.bus = 1U; cs->hw.sedl.chip = 0U; } else if ((unsigned int )cs->typ == 22U) { cs->subtyp = 2U; cs->hw.sedl.bus = 3U; cs->hw.sedl.chip = 0U; } else if ((unsigned int )cs->typ == 28U) { cs->subtyp = 3U; cs->hw.sedl.bus = 1U; cs->hw.sedl.chip = 2U; } else { return (0); } bytecnt = 8; if (card->para[1] != 0UL) { cs->hw.sedl.cfg_reg = (unsigned int )card->para[1]; cs->irq = (u_int )card->para[0]; if (cs->hw.sedl.chip == 2U) { bytecnt = 16; } else { } } else { rc = setup_sedlbauer_isapnp(card, & bytecnt); if (rc == 0) { return (0); } else { } if (rc > 0) { goto ready; } else { } rc = setup_sedlbauer_pci(card); if (rc == 0) { return (0); } else { } bytecnt = 256; } ready: ; if (cs->hw.sedl.bus != 3U) { tmp___1 = __request_region(& ioport_resource, (resource_size_t )cs->hw.sedl.cfg_reg, (resource_size_t )bytecnt, "sedlbauer isdn", 0); if ((unsigned long )tmp___1 == (unsigned long )((struct resource *)0)) { printk("\fHiSax: %s config port %x-%x already in use\n", CardType[card->typ], cs->hw.sedl.cfg_reg, cs->hw.sedl.cfg_reg + (unsigned int )bytecnt); return (0); } else { } } else { } printk("\016Sedlbauer: defined at 0x%x-0x%x IRQ %d\n", cs->hw.sedl.cfg_reg, cs->hw.sedl.cfg_reg + (unsigned int )bytecnt, cs->irq); cs->BC_Read_Reg = & ReadHSCX___5; cs->BC_Write_Reg = & WriteHSCX___5; cs->BC_Send_Data = & hscx_fill_fifo___5; cs->cardmsg = & Sedl_card_msg; if (cs->hw.sedl.bus != 2U) { tmp___2 = readreg___1(cs->hw.sedl.cfg_reg, cs->hw.sedl.cfg_reg + 2U, 194); val = (int )tmp___2; printk("\017Sedlbauer: testing IPAC version %x\n", val); if (val == 1 || val == 2) { cs->subtyp = 4U; if (cs->hw.sedl.bus == 3U) { cs->subtyp = 5U; } else { } cs->hw.sedl.chip = 3U; } else if (cs->hw.sedl.chip == 0U) { cs->hw.sedl.chip = 1U; } else { } } else { } printk("\016Sedlbauer: %s detected\n", Sedlbauer_Types[(int )cs->subtyp]); setup_isac(cs); if (cs->hw.sedl.chip == 3U) { if (cs->hw.sedl.bus == 2U) { cs->hw.sedl.adr = cs->hw.sedl.cfg_reg + 192U; cs->hw.sedl.isac = cs->hw.sedl.cfg_reg + 200U; cs->hw.sedl.hscx = cs->hw.sedl.cfg_reg + 200U; } else { cs->hw.sedl.adr = cs->hw.sedl.cfg_reg; cs->hw.sedl.isac = cs->hw.sedl.cfg_reg + 2U; cs->hw.sedl.hscx = cs->hw.sedl.cfg_reg + 2U; } test_and_set_bit(1, (unsigned long volatile *)(& cs->HW_Flags)); cs->readisac = & ReadISAC_IPAC___1; cs->writeisac = & WriteISAC_IPAC___1; cs->readisacfifo = & ReadISACfifo_IPAC___1; cs->writeisacfifo = & WriteISACfifo_IPAC___1; cs->irq_func = & sedlbauer_interrupt_ipac; tmp___3 = readreg___1(cs->hw.sedl.adr, cs->hw.sedl.isac, 194); val = (int )tmp___3; printk("\016Sedlbauer: IPAC version %x\n", val); } else { cs->readisac = & ReadISAC___6; cs->writeisac = & WriteISAC___6; cs->readisacfifo = & ReadISACfifo___6; cs->writeisacfifo = & WriteISACfifo___6; if (cs->hw.sedl.chip == 2U) { if (cs->hw.sedl.bus == 2U) { cs->hw.sedl.adr = cs->hw.sedl.cfg_reg + 200U; cs->hw.sedl.isac = cs->hw.sedl.cfg_reg + 208U; cs->hw.sedl.hscx = cs->hw.sedl.cfg_reg + 224U; } else { cs->hw.sedl.adr = cs->hw.sedl.cfg_reg + 8U; cs->hw.sedl.isac = cs->hw.sedl.cfg_reg + 4U; cs->hw.sedl.hscx = cs->hw.sedl.cfg_reg + 6U; cs->hw.sedl.reset_on = cs->hw.sedl.cfg_reg + 10U; cs->hw.sedl.reset_off = cs->hw.sedl.cfg_reg + 12U; } cs->bcs[0].hw.isar.reg = & cs->hw.sedl.isar; cs->bcs[1].hw.isar.reg = & cs->hw.sedl.isar; test_and_set_bit(2, (unsigned long volatile *)(& cs->HW_Flags)); cs->irq_func = & sedlbauer_interrupt_isar; cs->auxcmd = & isar_auxcmd; ISACVersion(cs, (char *)"Sedlbauer:"); cs->BC_Read_Reg = & ReadISAR; cs->BC_Write_Reg = & WriteISAR; cs->BC_Send_Data = & isar_fill_fifo; bytecnt = 3; goto ldv_41571; ldv_41570: ver = ISARVersion(cs, (char *)"Sedlbauer:"); if (ver < 0) { printk("\fSedlbauer: wrong ISAR version (ret = %d)\n", ver); } else { goto ldv_41569; } reset_sedlbauer(cs); bytecnt = bytecnt - 1; ldv_41571: ; if (bytecnt != 0) { goto ldv_41570; } else { } ldv_41569: ; if (bytecnt == 0) { release_io_sedlbauer(cs); return (0); } else { } } else { if (cs->hw.sedl.bus == 3U) { cs->hw.sedl.adr = cs->hw.sedl.cfg_reg + 4U; cs->hw.sedl.isac = cs->hw.sedl.cfg_reg + 1U; cs->hw.sedl.hscx = cs->hw.sedl.cfg_reg + 2U; cs->hw.sedl.reset_on = cs->hw.sedl.cfg_reg; cs->hw.sedl.reset_off = cs->hw.sedl.cfg_reg; cs->irq_flags = cs->irq_flags | 128UL; } else { cs->hw.sedl.adr = cs->hw.sedl.cfg_reg + 4U; cs->hw.sedl.isac = cs->hw.sedl.cfg_reg + 2U; cs->hw.sedl.hscx = cs->hw.sedl.cfg_reg + 3U; cs->hw.sedl.reset_on = cs->hw.sedl.cfg_reg; cs->hw.sedl.reset_off = cs->hw.sedl.cfg_reg + 1U; } cs->irq_func = & sedlbauer_interrupt; ISACVersion(cs, (char *)"Sedlbauer:"); tmp___4 = HscxVersion(cs, (char *)"Sedlbauer:"); if (tmp___4 != 0) { printk("\fSedlbauer: wrong HSCX versions check IO address\n"); release_io_sedlbauer(cs); return (0); } else { } } } return (1); } } void ldv_mutex_lock_323(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_lock(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_324(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_lock(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_325(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } int ldv_mutex_trylock_326(struct mutex *ldv_func_arg1 ) { ldv_func_ret_type___2 ldv_func_res ; int tmp ; int tmp___0 ; { tmp = mutex_trylock(ldv_func_arg1); ldv_func_res = tmp; tmp___0 = ldv_mutex_trylock_mutex(ldv_func_arg1); return (tmp___0); return (ldv_func_res); } } void ldv_mutex_unlock_327(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_328(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_cred_guard_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_329(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_cred_guard_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } long ldv__builtin_expect(long exp , long c ) ; extern void warn_slowpath_fmt(char const * , int const , char const * , ...) ; int ldv_mutex_trylock_340(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_338(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_341(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_343(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_337(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_339(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_342(struct mutex *ldv_func_arg1 ) ; extern unsigned long _copy_from_user(void * , void const * , unsigned int ) ; __inline static unsigned long copy_from_user(void *to , void const *from , unsigned long n ) { int sz ; unsigned long tmp ; int __ret_warn_on ; long tmp___0 ; long tmp___1 ; long tmp___2 ; { tmp = __builtin_object_size((void const *)to, 0); sz = (int )tmp; might_fault(); tmp___1 = ldv__builtin_expect(sz == -1, 1L); if (tmp___1 != 0L) { n = _copy_from_user(to, from, (unsigned int )n); } else { tmp___2 = ldv__builtin_expect((unsigned long )sz >= n, 1L); if (tmp___2 != 0L) { n = _copy_from_user(to, from, (unsigned int )n); } else { __ret_warn_on = 1; tmp___0 = ldv__builtin_expect(__ret_warn_on != 0, 0L); if (tmp___0 != 0L) { warn_slowpath_fmt("/home/mikhail/launches/cpachecker-regression2/launcher-working-dir/ldv-manager-work-dir/inst/current/envs/linux-3.8-rc1/linux-3.8-rc1/arch/x86/include/asm/uaccess_64.h", 66, "Buffer overflow detected!\n"); } else { } ldv__builtin_expect(__ret_warn_on != 0, 0L); } } return (n); } } static u_char const faxmodulation[13U] = { 3U, 24U, 48U, 72U, 73U, 74U, 96U, 97U, 98U, 121U, 122U, 145U, 146U}; static u_int modmask = 8191U; static int frm_extra_delay = 2; static int para_TOA = 6; static u_char const *FC1_CMD[8U] = { (u_char const *)"FAE", (u_char const *)"FTS", (u_char const *)"FRS", (u_char const *)"FTM", (u_char const *)"FRM", (u_char const *)"FTH", (u_char const *)"FRH", (u_char const *)"CTRL"}; static void isar_setup(struct IsdnCardState *cs ) ; static void isar_pump_cmd(struct BCState *bcs , u_char cmd , u_char para ) ; static void ll_deliver_faxstat(struct BCState *bcs , u_char status ) ; __inline static int waitforHIA(struct IsdnCardState *cs , int timeout ) { u_char tmp ; { goto ldv_40993; ldv_40992: __const_udelay(4295UL); timeout = timeout - 1; ldv_40993: tmp = (*(cs->BC_Read_Reg))(cs, 0, 80); if ((int )tmp & 1 && timeout != 0) { goto ldv_40992; } else { } if (timeout == 0) { printk("\fHiSax: ISAR waitforHIA timeout\n"); } else { } return (timeout); } } static int sendmsg(struct IsdnCardState *cs , u_char his , u_char creg , u_char len , u_char *msg ) { int i ; int tmp ; char tmp___0[256U] ; char *t ; int tmp___1 ; { tmp = waitforHIA(cs, 4000); if (tmp == 0) { return (0); } else { } if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"sendmsg(%02x,%02x,%d)", (int )his, (int )creg, (int )len); } else { } (*(cs->BC_Write_Reg))(cs, 0, 97, (int )creg); (*(cs->BC_Write_Reg))(cs, 0, 96, (int )len); (*(cs->BC_Write_Reg))(cs, 0, 74, 0); if ((unsigned long )msg != (unsigned long )((u_char *)0) && (unsigned int )len != 0U) { (*(cs->BC_Write_Reg))(cs, 1, 76, (int )*msg); i = 1; goto ldv_41004; ldv_41003: (*(cs->BC_Write_Reg))(cs, 2, 76, (int )*(msg + (unsigned long )i)); i = i + 1; ldv_41004: ; if ((int )len > i) { goto ldv_41003; } else { } if ((cs->debug & 32) != 0) { i = (int )len; goto ldv_41009; ldv_41008: t = (char *)(& tmp___0); tmp___1 = sprintf(t, "sendmbox cnt %d", (int )len); t = t + (unsigned long )tmp___1; QuickHex(t, msg + (unsigned long )((int )len - i), 64 < i ? 64 : i); debugl1(cs, (char *)(& tmp___0)); i = i + -64; ldv_41009: ; if (i > 0) { goto ldv_41008; } else { } } else { } } else { } (*(cs->BC_Write_Reg))(cs, 1, 80, (int )his); waitforHIA(cs, 10000); return (1); } } __inline static void rcv_mbox(struct IsdnCardState *cs , struct isar_reg *ireg , u_char *msg ) { int i ; char tmp[256U] ; char *t ; int tmp___0 ; { (*(cs->BC_Write_Reg))(cs, 1, 72, 0); if ((unsigned long )msg != (unsigned long )((u_char *)0) && (unsigned int )((unsigned char )ireg->clsb) != 0U) { *msg = (*(cs->BC_Read_Reg))(cs, 1, 76); i = 1; goto ldv_41018; ldv_41017: *(msg + (unsigned long )i) = (*(cs->BC_Read_Reg))(cs, 2, 76); i = i + 1; ldv_41018: ; if ((int )ireg->clsb > i) { goto ldv_41017; } else { } if ((cs->debug & 32) != 0) { i = (int )ireg->clsb; goto ldv_41023; ldv_41022: t = (char *)(& tmp); tmp___0 = sprintf(t, "rcv_mbox cnt %d", (int )ireg->clsb); t = t + (unsigned long )tmp___0; QuickHex(t, msg + (unsigned long )((int )ireg->clsb - i), 64 < i ? 64 : i); debugl1(cs, (char *)(& tmp)); i = i + -64; ldv_41023: ; if (i > 0) { goto ldv_41022; } else { } } else { } } else { } (*(cs->BC_Write_Reg))(cs, 1, 88, 0); return; } } __inline static void get_irq_infos(struct IsdnCardState *cs , struct isar_reg *ireg ) { u_char tmp ; u_char tmp___0 ; u_char tmp___1 ; { tmp = (*(cs->BC_Read_Reg))(cs, 1, 88); ireg->iis = tmp; tmp___0 = (*(cs->BC_Read_Reg))(cs, 1, 97); ireg->cmsb = tmp___0; tmp___1 = (*(cs->BC_Read_Reg))(cs, 1, 96); ireg->clsb = tmp___1; if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"irq_stat(%02x,%02x,%d)", (int )ireg->iis, (int )ireg->cmsb, (int )ireg->clsb); } else { } return; } } static int waitrecmsg(struct IsdnCardState *cs , u_char *len , u_char *msg , int maxdelay ) { int timeout ; struct isar_reg *ir ; u_char tmp ; int tmp___0 ; { timeout = 0; ir = cs->bcs[0].hw.isar.reg; goto ldv_41038; ldv_41037: __const_udelay(4295UL); ldv_41038: tmp = (*(cs->BC_Read_Reg))(cs, 0, 117); if (((int )tmp & 4) == 0) { tmp___0 = timeout; timeout = timeout + 1; if (tmp___0 < maxdelay) { goto ldv_41037; } else { goto ldv_41039; } } else { } ldv_41039: ; if (timeout > maxdelay) { printk("\fisar recmsg IRQSTA timeout\n"); return (0); } else { } get_irq_infos(cs, ir); rcv_mbox(cs, ir, msg); *len = ir->clsb; return (1); } } int ISARVersion(struct IsdnCardState *cs , char *s ) { int ver ; u_char msg[3U] ; u_char tmp[64U] ; u_char len ; u_long flags ; int debug ; raw_spinlock_t *tmp___0 ; int tmp___1 ; int tmp___2 ; { msg[0] = 32U; msg[1] = 0U; msg[2] = 1U; (*(cs->cardmsg))(cs, 240, 0); tmp___0 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___0); (*(cs->BC_Write_Reg))(cs, 0, 117, 0); debug = cs->debug; cs->debug = cs->debug & -49; tmp___1 = sendmsg(cs, 20, 0, 3, (u_char *)(& msg)); if (tmp___1 == 0) { spin_unlock_irqrestore(& cs->lock, flags); return (-1); } else { } tmp___2 = waitrecmsg(cs, & len, (u_char *)(& tmp), 100000); if (tmp___2 == 0) { spin_unlock_irqrestore(& cs->lock, flags); return (-2); } else { } cs->debug = debug; if ((unsigned int )((unsigned char )(cs->bcs[0].hw.isar.reg)->iis) == 21U) { if ((unsigned int )len == 1U) { ver = (int )tmp[0] & 15; printk("\016%s ISAR version %d\n", s, ver); } else { ver = -3; } } else { ver = -4; } spin_unlock_irqrestore(& cs->lock, flags); return (ver); } } static int isar_load_firmware(struct IsdnCardState *cs , u_char *buf ) { int cfu_ret ; int ret ; int size ; int cnt ; int debug ; u_char len ; u_char nom ; u_char noc ; u_short sadr ; u_short left ; u_short *sp ; u_char *p ; u_char *msg ; u_char *tmpmsg ; u_char *mp ; u_char tmp[64U] ; u_long flags ; struct isar_reg *ireg ; struct __anonstruct_blk_head_237 blk_head ; unsigned long tmp___0 ; void *tmp___1 ; void *tmp___2 ; raw_spinlock_t *tmp___3 ; unsigned long tmp___4 ; raw_spinlock_t *tmp___5 ; int tmp___6 ; int tmp___7 ; u_char *tmp___8 ; u_char *tmp___9 ; u_char *tmp___10 ; unsigned long tmp___11 ; u_char *tmp___12 ; u_char *tmp___13 ; raw_spinlock_t *tmp___14 ; int tmp___15 ; int tmp___16 ; int tmp___17 ; raw_spinlock_t *tmp___18 ; int tmp___19 ; int tmp___20 ; int tmp___21 ; raw_spinlock_t *tmp___22 ; int tmp___23 ; raw_spinlock_t *tmp___24 ; int tmp___25 ; raw_spinlock_t *tmp___26 ; { p = buf; ireg = cs->bcs[0].hw.isar.reg; ret = ISARVersion(cs, (char *)"Testing"); if (ret != 1) { printk("\visar_load_firmware wrong isar version %d\n", ret); return (1); } else { } debug = cs->debug; cs->debug = cs->debug & -49; tmp___0 = copy_from_user((void *)(& size), (void const *)p, 4UL); cfu_ret = (int )tmp___0; if (cfu_ret != 0) { printk("\visar_load_firmware copy_from_user ret %d\n", cfu_ret); return (-14); } else { } p = p + 4UL; printk("\017isar_load_firmware size: %d\n", size); cnt = 0; (*(cs->BC_Write_Reg))(cs, 0, 117, 0); tmp___1 = kmalloc(256UL, 208U); msg = (u_char *)tmp___1; if ((unsigned long )msg == (unsigned long )((u_char *)0)) { printk("\visar_load_firmware no buffer\n"); return (1); } else { } tmp___2 = kmalloc(256UL, 208U); tmpmsg = (u_char *)tmp___2; if ((unsigned long )tmpmsg == (unsigned long )((u_char *)0)) { printk("\visar_load_firmware no tmp buffer\n"); kfree((void const *)msg); return (1); } else { } tmp___3 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___3); (*(cs->BC_Write_Reg))(cs, 0, 117, 0); spin_unlock_irqrestore(& cs->lock, flags); goto ldv_41098; ldv_41097: tmp___4 = copy_from_user((void *)(& blk_head), (void const *)p, 6UL); ret = (int )tmp___4; if (ret != 0) { printk("\visar_load_firmware copy_from_user ret %d\n", ret); goto reterror; } else { } cnt = cnt + 6; p = p + 6UL; printk("\017isar firmware block (%#x,%5d,%#x)\n", (int )blk_head.sadr, (int )blk_head.len, (int )blk_head.d_key & 255); sadr = blk_head.sadr; left = blk_head.len; tmp___5 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___5); tmp___6 = sendmsg(cs, 2, (int )((u_char )blk_head.d_key), 0, 0); if (tmp___6 == 0) { printk("\visar sendmsg dkey failed\n"); ret = 1; goto reterr_unlock; } else { } tmp___7 = waitrecmsg(cs, & len, (u_char *)(& tmp), 100000); if (tmp___7 == 0) { printk("\visar waitrecmsg dkey failed\n"); ret = 1; goto reterr_unlock; } else { } if (((unsigned int )((unsigned char )ireg->iis) != 3U || (unsigned int )((unsigned char )ireg->cmsb) != 0U) || (unsigned int )len != 0U) { printk("\visar wrong dkey response (%x,%x,%x)\n", (int )ireg->iis, (int )ireg->cmsb, (int )len); ret = 1; goto reterr_unlock; } else { } spin_unlock_irqrestore(& cs->lock, flags); goto ldv_41095; ldv_41094: ; if ((unsigned int )left > 126U) { noc = 126U; } else { noc = (u_char )left; } nom = (unsigned int )noc * 2U; mp = msg; tmp___8 = mp; mp = mp + 1; *tmp___8 = (u_char )((unsigned int )sadr / 256U); tmp___9 = mp; mp = mp + 1; *tmp___9 = (u_char )sadr; left = (int )left - (int )((u_short )noc); tmp___10 = mp; mp = mp + 1; *tmp___10 = noc; tmp___11 = copy_from_user((void *)tmpmsg, (void const *)p, (unsigned long )nom); ret = (int )tmp___11; if (ret != 0) { printk("\visar_load_firmware copy_from_user ret %d\n", ret); goto reterror; } else { } p = p + (unsigned long )nom; cnt = (int )nom + cnt; nom = (unsigned int )nom + 3U; sp = (u_short *)tmpmsg; sadr = (int )((u_short )noc) + (int )sadr; goto ldv_41089; ldv_41088: tmp___12 = mp; mp = mp + 1; *tmp___12 = (u_char )((unsigned int )*sp / 256U); tmp___13 = mp; mp = mp + 1; *tmp___13 = (u_char )*sp; sp = sp + 1; noc = (u_char )((int )noc - 1); ldv_41089: ; if ((unsigned int )noc != 0U) { goto ldv_41088; } else { } tmp___14 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___14); tmp___15 = sendmsg(cs, 30, 0, (int )nom, msg); if (tmp___15 == 0) { printk("\visar sendmsg prog failed\n"); ret = 1; goto reterr_unlock; } else { } tmp___16 = waitrecmsg(cs, & len, (u_char *)(& tmp), 100000); if (tmp___16 == 0) { printk("\visar waitrecmsg prog failed\n"); ret = 1; goto reterr_unlock; } else { } if (((unsigned int )((unsigned char )ireg->iis) != 31U || (unsigned int )((unsigned char )ireg->cmsb) != 0U) || (unsigned int )len != 0U) { printk("\visar wrong prog response (%x,%x,%x)\n", (int )ireg->iis, (int )ireg->cmsb, (int )len); ret = 1; goto reterr_unlock; } else { } spin_unlock_irqrestore(& cs->lock, flags); ldv_41095: ; if ((unsigned int )left != 0U) { goto ldv_41094; } else { } printk("\017isar firmware block %5d words loaded\n", (int )blk_head.len); ldv_41098: ; if (cnt < size) { goto ldv_41097; } else { } cnt = 10; goto ldv_41101; ldv_41100: __const_udelay(4295000UL); ldv_41101: tmp___17 = cnt; cnt = cnt - 1; if (tmp___17 != 0) { goto ldv_41100; } else { } *msg = 255U; *(msg + 1UL) = 254U; ireg->bstat = 0U; tmp___18 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___18); tmp___19 = sendmsg(cs, 8, 0, 2, msg); if (tmp___19 == 0) { printk("\visar sendmsg start dsp failed\n"); ret = 1; goto reterr_unlock; } else { } tmp___20 = waitrecmsg(cs, & len, (u_char *)(& tmp), 100000); if (tmp___20 == 0) { printk("\visar waitrecmsg start dsp failed\n"); ret = 1; goto reterr_unlock; } else { } if (((unsigned int )((unsigned char )ireg->iis) != 9U || (unsigned int )((unsigned char )ireg->cmsb) != 0U) || (unsigned int )len != 0U) { printk("\visar wrong start dsp response (%x,%x,%x)\n", (int )ireg->iis, (int )ireg->cmsb, (int )len); ret = 1; goto reterr_unlock; } else { printk("\017isar start dsp success\n"); } (*(cs->BC_Write_Reg))(cs, 0, 117, 4); spin_unlock_irqrestore(& cs->lock, flags); cnt = 1000; goto ldv_41107; ldv_41106: __const_udelay(4295000UL); cnt = cnt - 1; ldv_41107: ; if ((unsigned int )((unsigned char )ireg->bstat) == 0U && cnt != 0) { goto ldv_41106; } else { } if (cnt == 0) { printk("\visar no general status event received\n"); ret = 1; goto reterror; } else { printk("\017isar general status event %x\n", (int )ireg->bstat); } cnt = 10; goto ldv_41110; ldv_41109: __const_udelay(4295000UL); ldv_41110: tmp___21 = cnt; cnt = cnt - 1; if (tmp___21 != 0) { goto ldv_41109; } else { } tmp___22 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___22); ireg->iis = 0U; tmp___23 = sendmsg(cs, 5, 64, 0, 0); if (tmp___23 == 0) { printk("\visar sendmsg self tst failed\n"); ret = 1; goto reterr_unlock; } else { } cnt = 10000; spin_unlock_irqrestore(& cs->lock, flags); goto ldv_41116; ldv_41115: __const_udelay(42950UL); cnt = cnt - 1; ldv_41116: ; if ((unsigned int )((unsigned char )ireg->iis) != 37U && cnt != 0) { goto ldv_41115; } else { } __const_udelay(4295000UL); if (cnt == 0) { printk("\visar no self tst response\n"); ret = 1; goto reterror; } else { } if (((unsigned int )((unsigned char )ireg->cmsb) == 64U && (unsigned int )((unsigned char )ireg->clsb) == 1U) && (unsigned int )((unsigned char )ireg->par[0]) == 0U) { printk("\017isar selftest OK\n"); } else { printk("\017isar selftest not OK %x/%x/%x\n", (int )ireg->cmsb, (int )ireg->clsb, (int )ireg->par[0]); ret = 1; goto reterror; } tmp___24 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___24); ireg->iis = 0U; tmp___25 = sendmsg(cs, 5, 16, 0, 0); if (tmp___25 == 0) { printk("\visar RQST SVN failed\n"); ret = 1; goto reterr_unlock; } else { } spin_unlock_irqrestore(& cs->lock, flags); cnt = 30000; goto ldv_41122; ldv_41121: __const_udelay(42950UL); cnt = cnt - 1; ldv_41122: ; if ((unsigned int )((unsigned char )ireg->iis) != 37U && cnt != 0) { goto ldv_41121; } else { } __const_udelay(4295000UL); if (cnt == 0) { printk("\visar no SVN response\n"); ret = 1; goto reterror; } else if ((unsigned int )((unsigned char )ireg->cmsb) == 16U && (unsigned int )((unsigned char )ireg->clsb) == 1U) { printk("\017isar software version %#x\n", (int )ireg->par[0]); } else { printk("\visar wrong swver response (%x,%x) cnt(%d)\n", (int )ireg->cmsb, (int )ireg->clsb, cnt); ret = 1; goto reterror; } tmp___26 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___26); cs->debug = debug; isar_setup(cs); ret = 0; reterr_unlock: spin_unlock_irqrestore(& cs->lock, flags); reterror: cs->debug = debug; if (ret != 0) { (*(cs->BC_Write_Reg))(cs, 0, 117, 0); } else { } kfree((void const *)msg); kfree((void const *)tmpmsg); return (ret); } } static void isar_bh(struct work_struct *work ) { struct BCState *bcs ; struct work_struct const *__mptr ; int tmp ; int tmp___0 ; int tmp___1 ; { __mptr = (struct work_struct const *)work; bcs = (struct BCState *)__mptr + 0xfffffffffffffe30UL; BChannel_bh(work); tmp = test_and_clear_bit(8, (unsigned long volatile *)(& bcs->event)); if (tmp != 0) { ll_deliver_faxstat(bcs, 2); } else { } tmp___0 = test_and_clear_bit(9, (unsigned long volatile *)(& bcs->event)); if (tmp___0 != 0) { ll_deliver_faxstat(bcs, 1); } else { } tmp___1 = test_and_clear_bit(10, (unsigned long volatile *)(& bcs->event)); if (tmp___1 != 0) { ll_deliver_faxstat(bcs, 0); } else { } return; } } static void send_DLE_ETX(struct BCState *bcs ) { u_char dleetx[2U] ; struct sk_buff *skb ; size_t __len ; void *__ret ; unsigned char *tmp ; unsigned char *tmp___0 ; { dleetx[0] = 16U; dleetx[1] = 3U; skb = dev_alloc_skb(2U); if ((unsigned long )skb != (unsigned long )((struct sk_buff *)0)) { __len = 2UL; if (__len > 63UL) { tmp = skb_put(skb, 2U); __ret = memcpy((void *)tmp, (void const *)(& dleetx), __len); } else { tmp___0 = skb_put(skb, 2U); __ret = memcpy((void *)tmp___0, (void const *)(& dleetx), __len); } skb_queue_tail(& bcs->rqueue, skb); test_and_set_bit(0, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { printk("\fHiSax: skb out of memory\n"); } return; } } __inline static int dle_count(unsigned char *buf , int len ) { int count ; unsigned char *tmp ; int tmp___0 ; { count = 0; goto ldv_41147; ldv_41146: tmp = buf; buf = buf + 1; if ((unsigned int )*tmp == 16U) { count = count + 1; } else { } ldv_41147: tmp___0 = len; len = len - 1; if (tmp___0 != 0) { goto ldv_41146; } else { } return (count); } } __inline static void insert_dle(unsigned char *dest , unsigned char *src , int count ) { unsigned char *tmp ; unsigned char *tmp___0 ; unsigned char *tmp___1 ; int tmp___2 ; { goto ldv_41155; ldv_41154: tmp = dest; dest = dest + 1; *tmp = *src; tmp___1 = src; src = src + 1; if ((unsigned int )*tmp___1 == 16U) { tmp___0 = dest; dest = dest + 1; *tmp___0 = 16U; } else { } ldv_41155: tmp___2 = count; count = count - 1; if (tmp___2 != 0) { goto ldv_41154; } else { } return; } } static void isar_rcv_frame(struct IsdnCardState *cs , struct BCState *bcs ) { u_char *ptr ; struct sk_buff *skb ; struct isar_reg *ireg ; unsigned char *tmp ; size_t __len ; void *__ret ; unsigned char *tmp___1 ; int tmp___2 ; unsigned char *tmp___3 ; int len ; int tmp___4 ; unsigned char *tmp___5 ; int tmp___6 ; { ireg = bcs->hw.isar.reg; if ((unsigned int )((unsigned char )ireg->clsb) == 0U) { debugl1(cs, (char *)"isar zero len frame"); (*(cs->BC_Write_Reg))(cs, 1, 88, 0); return; } else { } switch (bcs->mode) { case 0: debugl1(cs, (char *)"isar mode 0 spurious IIS_RDATA %x/%x/%x", (int )ireg->iis, (int )ireg->cmsb, (int )ireg->clsb); printk("\fisar mode 0 spurious IIS_RDATA %x/%x/%x\n", (int )ireg->iis, (int )ireg->cmsb, (int )ireg->clsb); (*(cs->BC_Write_Reg))(cs, 1, 88, 0); goto ldv_41165; case 1: ; case 8: skb = dev_alloc_skb((unsigned int )ireg->clsb); if ((unsigned long )skb != (unsigned long )((struct sk_buff *)0)) { tmp = skb_put(skb, (unsigned int )ireg->clsb); rcv_mbox(cs, ireg, tmp); skb_queue_tail(& bcs->rqueue, skb); test_and_set_bit(0, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { printk("\fHiSax: skb out of memory\n"); (*(cs->BC_Write_Reg))(cs, 1, 88, 0); } goto ldv_41165; case 2: ; if (bcs->hw.isar.rcvidx + (int )ireg->clsb > 4096) { if (cs->debug & 1) { debugl1(cs, (char *)"isar_rcv_frame: incoming packet too large"); } else { } (*(cs->BC_Write_Reg))(cs, 1, 88, 0); bcs->hw.isar.rcvidx = 0; } else if (((int )ireg->cmsb & 28) != 0) { if (cs->debug & 1) { debugl1(cs, (char *)"isar frame error %x len %d", (int )ireg->cmsb, (int )ireg->clsb); } else { } if (((int )ireg->cmsb & 8) != 0) { bcs->err_inv = bcs->err_inv + 1; } else { } if (((int )ireg->cmsb & 4) != 0) { bcs->err_crc = bcs->err_crc + 1; } else { } bcs->hw.isar.rcvidx = 0; (*(cs->BC_Write_Reg))(cs, 1, 88, 0); } else { if (((int )ireg->cmsb & 32) != 0) { bcs->hw.isar.rcvidx = 0; } else { } ptr = bcs->hw.isar.rcvbuf + (unsigned long )bcs->hw.isar.rcvidx; bcs->hw.isar.rcvidx = bcs->hw.isar.rcvidx + (int )ireg->clsb; rcv_mbox(cs, ireg, ptr); if (((int )ireg->cmsb & 64) != 0) { if (bcs->hw.isar.rcvidx <= 2) { if (cs->debug & 1) { debugl1(cs, (char *)"isar frame to short %d", bcs->hw.isar.rcvidx); } else { skb = dev_alloc_skb((unsigned int )(bcs->hw.isar.rcvidx + -2)); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { printk("\fISAR: receive out of memory\n"); } else { __len = (size_t )(bcs->hw.isar.rcvidx + -2); tmp___1 = skb_put(skb, (unsigned int )(bcs->hw.isar.rcvidx + -2)); __ret = memcpy((void *)tmp___1, (void const *)bcs->hw.isar.rcvbuf, __len); skb_queue_tail(& bcs->rqueue, skb); test_and_set_bit(0, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } } } else { } bcs->hw.isar.rcvidx = 0; } else { } } goto ldv_41165; case 9: ; if ((unsigned int )bcs->hw.isar.state != 4U) { if (cs->debug & 1) { debugl1(cs, (char *)"isar_rcv_frame: not ACTIV"); } else { } (*(cs->BC_Write_Reg))(cs, 1, 88, 0); bcs->hw.isar.rcvidx = 0; goto ldv_41165; } else { } if ((unsigned int )bcs->hw.isar.cmd == 166U) { rcv_mbox(cs, ireg, bcs->hw.isar.rcvbuf); tmp___2 = dle_count(bcs->hw.isar.rcvbuf, (int )ireg->clsb); bcs->hw.isar.rcvidx = (int )ireg->clsb + tmp___2; if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"isar_rcv_frame: raw(%d) dle(%d)", (int )ireg->clsb, bcs->hw.isar.rcvidx); } else { } skb = dev_alloc_skb((unsigned int )bcs->hw.isar.rcvidx); if ((unsigned long )skb != (unsigned long )((struct sk_buff *)0)) { tmp___3 = skb_put(skb, (unsigned int )bcs->hw.isar.rcvidx); insert_dle(tmp___3, bcs->hw.isar.rcvbuf, (int )ireg->clsb); skb_queue_tail(& bcs->rqueue, skb); test_and_set_bit(0, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); if ((int )ireg->cmsb & 1) { if (cs->debug & 1) { debugl1(cs, (char *)"isar_rcv_frame: no more data"); } else { } bcs->hw.isar.rcvidx = 0; send_DLE_ETX(bcs); sendmsg(cs, (int )((u_char )((int )((signed char )(bcs->hw.isar.dpath << 6)) | 42)), 164, 0, 0); bcs->hw.isar.state = 5U; test_and_set_bit(8, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } } else { printk("\fHiSax: skb out of memory\n"); } goto ldv_41165; } else { } if ((unsigned int )bcs->hw.isar.cmd != 165U) { if (cs->debug & 1) { debugl1(cs, (char *)"isar_rcv_frame: unknown fax mode %x", (int )bcs->hw.isar.cmd); } else { } (*(cs->BC_Write_Reg))(cs, 1, 88, 0); bcs->hw.isar.rcvidx = 0; goto ldv_41165; } else { } if (bcs->hw.isar.rcvidx + (int )ireg->clsb > 4096) { if (cs->debug & 1) { debugl1(cs, (char *)"isar_rcv_frame: incoming packet too large"); } else { } (*(cs->BC_Write_Reg))(cs, 1, 88, 0); bcs->hw.isar.rcvidx = 0; } else if (((int )ireg->cmsb & 28) != 0) { if (cs->debug & 1) { debugl1(cs, (char *)"isar frame error %x len %d", (int )ireg->cmsb, (int )ireg->clsb); } else { } bcs->hw.isar.rcvidx = 0; (*(cs->BC_Write_Reg))(cs, 1, 88, 0); } else { if (((int )ireg->cmsb & 32) != 0) { bcs->hw.isar.rcvidx = 0; } else { } ptr = bcs->hw.isar.rcvbuf + (unsigned long )bcs->hw.isar.rcvidx; bcs->hw.isar.rcvidx = bcs->hw.isar.rcvidx + (int )ireg->clsb; rcv_mbox(cs, ireg, ptr); if (((int )ireg->cmsb & 64) != 0) { tmp___4 = dle_count(bcs->hw.isar.rcvbuf, bcs->hw.isar.rcvidx); len = bcs->hw.isar.rcvidx + tmp___4; if (bcs->hw.isar.rcvidx <= 2) { if (cs->debug & 1) { debugl1(cs, (char *)"isar frame to short %d", bcs->hw.isar.rcvidx); } else { } printk("\fISAR: frame to short %d\n", bcs->hw.isar.rcvidx); } else { skb = dev_alloc_skb((unsigned int )len); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { printk("\fISAR: receive out of memory\n"); } else { tmp___5 = skb_put(skb, (unsigned int )len); insert_dle(tmp___5, bcs->hw.isar.rcvbuf, bcs->hw.isar.rcvidx); skb_queue_tail(& bcs->rqueue, skb); test_and_set_bit(0, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); send_DLE_ETX(bcs); test_and_set_bit(10, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); test_and_clear_bit(17, (unsigned long volatile *)(& bcs->Flag)); } } bcs->hw.isar.rcvidx = 0; } else { } } if ((int )ireg->cmsb & 1) { if (cs->debug & 1) { debugl1(cs, (char *)"isar_rcv_frame: no more data"); } else { } bcs->hw.isar.rcvidx = 0; sendmsg(cs, (int )((u_char )((int )((signed char )(bcs->hw.isar.dpath << 6)) | 42)), 164, 0, 0); bcs->hw.isar.state = 5U; tmp___6 = test_and_clear_bit(17, (unsigned long volatile *)(& bcs->Flag)); if (tmp___6 != 0) { send_DLE_ETX(bcs); test_and_set_bit(8, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } } else { } goto ldv_41165; default: printk("\visar_rcv_frame mode (%x)error\n", bcs->mode); (*(cs->BC_Write_Reg))(cs, 1, 88, 0); goto ldv_41165; } ldv_41165: ; return; } } void isar_fill_fifo(struct BCState *bcs ) { struct IsdnCardState *cs ; int count ; u_char msb ; u_char *ptr ; { cs = bcs->cs; if ((cs->debug & 16) != 0 && (cs->debug & 32) == 0) { debugl1(cs, (char *)"isar_fill_fifo"); } else { } if ((unsigned long )bcs->tx_skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } if ((bcs->tx_skb)->len == 0U) { return; } else { } if (((int )(bcs->hw.isar.reg)->bstat & (bcs->hw.isar.dpath == 1 ? 2 : 4)) == 0) { return; } else { } if ((bcs->tx_skb)->len > (unsigned int )bcs->hw.isar.mml) { msb = 0U; count = bcs->hw.isar.mml; } else { count = (int )(bcs->tx_skb)->len; msb = 64U; } ptr = (bcs->tx_skb)->data; if (bcs->hw.isar.txcnt == 0) { msb = (u_char )((unsigned int )msb | 32U); if (bcs->mode == 9 && (unsigned int )bcs->hw.isar.cmd == 167U) { if ((bcs->tx_skb)->len > 1U) { if ((unsigned int )*ptr == 255U && (unsigned int )*(ptr + 1UL) == 19U) { test_and_set_bit(11, (unsigned long volatile *)(& bcs->Flag)); } else { } } else { } } else { } } else { } skb_pull(bcs->tx_skb, (unsigned int )count); bcs->tx_cnt = bcs->tx_cnt - count; bcs->hw.isar.txcnt = bcs->hw.isar.txcnt + count; switch (bcs->mode) { case 0: printk("\visar_fill_fifo wrong mode 0\n"); goto ldv_41183; case 1: ; case 8: sendmsg(cs, (int )((u_char )((int )((signed char )(bcs->hw.isar.dpath << 6)) | 32)), 0, (int )((u_char )count), ptr); goto ldv_41183; case 2: sendmsg(cs, (int )((u_char )((int )((signed char )(bcs->hw.isar.dpath << 6)) | 32)), (int )msb, (int )((u_char )count), ptr); goto ldv_41183; case 9: ; if ((unsigned int )bcs->hw.isar.state != 4U) { if (cs->debug & 1) { debugl1(cs, (char *)"isar_fill_fifo: not ACTIV"); } else if ((unsigned int )bcs->hw.isar.cmd == 167U) { sendmsg(cs, (int )((u_char )((int )((signed char )(bcs->hw.isar.dpath << 6)) | 32)), (int )msb, (int )((u_char )count), ptr); } else if ((unsigned int )bcs->hw.isar.cmd == 168U) { sendmsg(cs, (int )((u_char )((int )((signed char )(bcs->hw.isar.dpath << 6)) | 32)), 0, (int )((u_char )count), ptr); } else if (cs->debug & 1) { debugl1(cs, (char *)"isar_fill_fifo: not FTH/FTM"); } else { } } else { } goto ldv_41183; default: ; if (cs->debug != 0) { debugl1(cs, (char *)"isar_fill_fifo mode(%x) error", bcs->mode); } else { } printk("\visar_fill_fifo mode(%x) error\n", bcs->mode); goto ldv_41183; } ldv_41183: ; return; } } __inline static struct BCState *sel_bcs_isar(struct IsdnCardState *cs , u_char dpath ) { { if ((unsigned int )dpath == 0U || (unsigned int )dpath == 3U) { return (0); } else { } if (cs->bcs[0].hw.isar.dpath == (int )dpath) { return ((struct BCState *)(& cs->bcs)); } else { } if (cs->bcs[1].hw.isar.dpath == (int )dpath) { return ((struct BCState *)(& cs->bcs) + 1UL); } else { } return (0); } } static void send_frames(struct BCState *bcs ) { u_long flags ; raw_spinlock_t *tmp ; int tmp___0 ; int tmp___1 ; int tmp___2 ; u_char dummy ; int tmp___3 ; int tmp___4 ; int tmp___5 ; struct sk_buff *tmp___6 ; { if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { if ((bcs->tx_skb)->len != 0U) { isar_fill_fifo(bcs); return; } else { tmp___0 = constant_test_bit(1U, (unsigned long const volatile *)(& (bcs->st)->lli.flag)); if (tmp___0 != 0 && (unsigned int )*((unsigned char *)bcs->tx_skb + 125UL) != 7U) { tmp = spinlock_check(& bcs->aclock); flags = _raw_spin_lock_irqsave(tmp); bcs->ackcnt = bcs->ackcnt + bcs->hw.isar.txcnt; spin_unlock_irqrestore(& bcs->aclock, flags); test_and_set_bit(2, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } if (bcs->mode == 9) { if ((unsigned int )bcs->hw.isar.cmd == 167U) { tmp___2 = constant_test_bit(11U, (unsigned long const volatile *)(& bcs->Flag)); if (tmp___2 != 0) { test_and_set_bit(12, (unsigned long volatile *)(& bcs->Flag)); } else if ((unsigned int )bcs->hw.isar.cmd == 168U) { tmp___1 = constant_test_bit(8U, (unsigned long const volatile *)(& bcs->Flag)); if (tmp___1 != 0) { test_and_set_bit(11, (unsigned long volatile *)(& bcs->Flag)); test_and_set_bit(12, (unsigned long volatile *)(& bcs->Flag)); } else { } } else { } } else { } } else { } dev_kfree_skb_any(bcs->tx_skb); bcs->hw.isar.txcnt = 0; bcs->tx_skb = 0; } } else { } tmp___6 = skb_dequeue(& bcs->squeue); bcs->tx_skb = tmp___6; if ((unsigned long )tmp___6 != (unsigned long )((struct sk_buff *)0)) { bcs->hw.isar.txcnt = 0; test_and_set_bit(3, (unsigned long volatile *)(& bcs->Flag)); isar_fill_fifo(bcs); } else { tmp___5 = test_and_clear_bit(8, (unsigned long volatile *)(& bcs->Flag)); if (tmp___5 != 0) { tmp___4 = test_and_clear_bit(11, (unsigned long volatile *)(& bcs->Flag)); if (tmp___4 != 0) { tmp___3 = test_and_clear_bit(12, (unsigned long volatile *)(& bcs->Flag)); if (tmp___3 != 0) { dummy = 0U; sendmsg(bcs->cs, (int )((u_char )((int )((signed char )(bcs->hw.isar.dpath << 6)) | 32)), 1, 1, & dummy); } else { } test_and_set_bit(14, (unsigned long volatile *)(& bcs->Flag)); } else { test_and_set_bit(9, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } } else { } test_and_clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); test_and_set_bit(1, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } return; } } __inline static void check_send(struct IsdnCardState *cs , u_char rdm ) { struct BCState *bcs ; { if (((int )rdm & 2) != 0) { bcs = sel_bcs_isar(cs, 1); if ((unsigned long )bcs != (unsigned long )((struct BCState *)0)) { if (bcs->mode != 0) { send_frames(bcs); } else { } } else { } } else { } if (((int )rdm & 4) != 0) { bcs = sel_bcs_isar(cs, 2); if ((unsigned long )bcs != (unsigned long )((struct BCState *)0)) { if (bcs->mode != 0) { send_frames(bcs); } else { } } else { } } else { } return; } } static char const *dmril[16U] = { "NO SPEED", "1200/75", "NODEF2", "75/1200", "NODEF4", "300", "600", "1200", "2400", "4800", "7200", "9600nt", "9600t", "12000", "14400", "WRONG"}; static char const *dmrim[11U] = { "NO MOD", "NO DEF", "V32/V32b", "V22", "V21", "Bell103", "V23", "Bell202", "V17", "V29", "V27ter"}; static void isar_pump_status_rsp(struct BCState *bcs , struct isar_reg *ireg ) { struct IsdnCardState *cs ; u_char ril ; u_char rim ; int tmp ; { cs = bcs->cs; ril = ireg->par[0]; tmp = test_and_clear_bit(3, (unsigned long volatile *)(& (bcs->hw.isar.reg)->Flags)); if (tmp == 0) { return; } else { } if ((unsigned int )ril > 14U) { if (cs->debug & 1) { debugl1(cs, (char *)"wrong pstrsp ril=%d", (int )ril); } else { } ril = 15U; } else { } switch ((int )ireg->par[1]) { case 0: rim = 0U; goto ldv_41216; case 32: rim = 2U; goto ldv_41216; case 64: rim = 3U; goto ldv_41216; case 65: rim = 4U; goto ldv_41216; case 81: rim = 5U; goto ldv_41216; case 97: rim = 6U; goto ldv_41216; case 113: rim = 7U; goto ldv_41216; case 130: rim = 8U; goto ldv_41216; case 146: rim = 9U; goto ldv_41216; case 162: rim = 10U; goto ldv_41216; default: rim = 1U; goto ldv_41216; } ldv_41216: sprintf((char *)(& bcs->hw.isar.conmsg), "%s %s", dmril[(int )ril], dmrim[(int )rim]); bcs->conmsg = (u_char *)(& bcs->hw.isar.conmsg); if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"pump strsp %s", bcs->conmsg); } else { } return; } } static void isar_pump_statev_modem(struct BCState *bcs , u_char devt ) { struct IsdnCardState *cs ; u_char dps ; { cs = bcs->cs; dps = (u_char )(bcs->hw.isar.dpath << 6); switch ((int )devt) { case 2: ; if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"pump stev TIMER"); } else { } goto ldv_41234; case 24: ; if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"pump stev CONNECT"); } else { } l1_msg_b(bcs->st, 256, 0); goto ldv_41234; case 25: ; if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"pump stev NO CONNECT"); } else { } sendmsg(cs, (int )((unsigned int )dps | 14U), 0, 0, 0); l1_msg_b(bcs->st, 272, 0); goto ldv_41234; case 32: ; if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"pump stev V24 OFF"); } else { } goto ldv_41234; case 33: ; if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"pump stev CTS ON"); } else { } goto ldv_41234; case 34: ; if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"pump stev CTS OFF"); } else { } goto ldv_41234; case 35: ; if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"pump stev CARRIER ON"); } else { } test_and_set_bit(3, (unsigned long volatile *)(& (bcs->hw.isar.reg)->Flags)); sendmsg(cs, (int )((unsigned int )dps | 14U), 0, 0, 0); goto ldv_41234; case 36: ; if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"pump stev CARRIER OFF"); } else { } goto ldv_41234; case 37: ; if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"pump stev DSR ON"); } else { } goto ldv_41234; case 38: ; if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"pump stev DSR_OFF"); } else { } goto ldv_41234; case 204: ; if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"pump stev REMOTE RETRAIN"); } else { } goto ldv_41234; case 205: ; if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"pump stev REMOTE RENEGOTIATE"); } else { } goto ldv_41234; case 212: ; if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"pump stev GSTN CLEAR"); } else { } goto ldv_41234; default: ; if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"unknown pump stev %x", (int )devt); } else { } goto ldv_41234; } ldv_41234: ; return; } } static void ll_deliver_faxstat(struct BCState *bcs , u_char status ) { isdn_ctrl ic ; struct Channel *chanp ; { chanp = (struct Channel *)(bcs->st)->lli.userdata; if (((bcs->cs)->debug & 16) != 0) { debugl1(bcs->cs, (char *)"HL->LL FAXIND %x", (int )status); } else { } ic.driver = (bcs->cs)->myid; ic.command = 276; ic.arg = (ulong )chanp->chan; ic.parm.aux.cmd = status; (*((bcs->cs)->iif.statcallb))(& ic); return; } } static void isar_pump_statev_fax(struct BCState *bcs , u_char devt ) { struct IsdnCardState *cs ; u_char dps ; u_char p1 ; int tmp ; int tmp___0 ; unsigned long __ms ; unsigned long tmp___1 ; u_char tmp___2 ; int tmp___3 ; u_char tmp___4 ; char tmp___5 ; { cs = bcs->cs; dps = (u_char )(bcs->hw.isar.dpath << 6); switch ((int )devt) { case 2: ; if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"pump stev TIMER"); } else { } goto ldv_41262; case 188: ; if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"pump stev RSP_READY"); } else { } bcs->hw.isar.state = 1U; l1_msg_b(bcs->st, 256, 0); tmp = constant_test_bit(7U, (unsigned long const volatile *)(& bcs->Flag)); if (tmp != 0) { isar_pump_cmd(bcs, 6, 3); } else { isar_pump_cmd(bcs, 5, 3); } goto ldv_41262; case 179: ; if ((unsigned int )bcs->hw.isar.state == 2U) { if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"pump stev LINE_TX_H"); } else { } bcs->hw.isar.state = 3U; sendmsg(cs, (int )((unsigned int )dps | 42U), 162, 0, 0); } else if (cs->debug & 1) { debugl1(cs, (char *)"pump stev LINE_TX_H wrong st %x", (int )bcs->hw.isar.state); } else { } goto ldv_41262; case 177: ; if ((unsigned int )bcs->hw.isar.state == 2U) { if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"pump stev LINE_RX_H"); } else { } bcs->hw.isar.state = 3U; sendmsg(cs, (int )((unsigned int )dps | 42U), 162, 0, 0); } else if (cs->debug & 1) { debugl1(cs, (char *)"pump stev LINE_RX_H wrong st %x", (int )bcs->hw.isar.state); } else { } goto ldv_41262; case 178: ; if ((unsigned int )bcs->hw.isar.state == 2U) { if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"pump stev LINE_TX_B"); } else { } bcs->hw.isar.state = 3U; sendmsg(cs, (int )((unsigned int )dps | 42U), 162, 0, 0); } else if (cs->debug & 1) { debugl1(cs, (char *)"pump stev LINE_TX_B wrong st %x", (int )bcs->hw.isar.state); } else { } goto ldv_41262; case 176: ; if ((unsigned int )bcs->hw.isar.state == 2U) { if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"pump stev LINE_RX_B"); } else { } bcs->hw.isar.state = 3U; sendmsg(cs, (int )((unsigned int )dps | 42U), 162, 0, 0); } else if (cs->debug & 1) { debugl1(cs, (char *)"pump stev LINE_RX_B wrong st %x", (int )bcs->hw.isar.state); } else { } goto ldv_41262; case 181: ; if ((unsigned int )bcs->hw.isar.state == 3U) { if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"pump stev RSP_CONN"); } else { } bcs->hw.isar.state = 4U; test_and_set_bit(3, (unsigned long volatile *)(& (bcs->hw.isar.reg)->Flags)); sendmsg(cs, (int )((unsigned int )dps | 14U), 0, 0, 0); if ((unsigned int )bcs->hw.isar.cmd == 167U) { tmp___0 = test_and_set_bit(13, (unsigned long volatile *)(& bcs->Flag)); if (tmp___0 != 0) { del_timer(& bcs->hw.isar.ftimer); } else { } bcs->hw.isar.ftimer.expires = (unsigned long )jiffies + 250UL; test_and_set_bit(15, (unsigned long volatile *)(& bcs->Flag)); add_timer(& bcs->hw.isar.ftimer); } else { test_and_set_bit(9, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } } else if (cs->debug & 1) { debugl1(cs, (char *)"pump stev RSP_CONN wrong st %x", (int )bcs->hw.isar.state); } else { } goto ldv_41262; case 186: ; if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"pump stev FLAGS_DET"); } else { } goto ldv_41262; case 183: ; if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"pump stev RSP_DISC"); } else { } if ((unsigned int )bcs->hw.isar.state == 5U) { p1 = 5U; switch ((int )bcs->hw.isar.newcmd) { case 0: bcs->hw.isar.state = 1U; goto ldv_41272; case 168: p1 = 2U; case 167: sendmsg(cs, (int )((unsigned int )dps | 42U), 172, 1, & p1); bcs->hw.isar.state = 6U; goto ldv_41272; case 166: ; if (frm_extra_delay != 0) { __ms = (unsigned long )frm_extra_delay; goto ldv_41278; ldv_41277: __const_udelay(4295000UL); ldv_41278: tmp___1 = __ms; __ms = __ms - 1UL; if (tmp___1 != 0UL) { goto ldv_41277; } else { } } else { } case 165: tmp___2 = bcs->hw.isar.newmod; bcs->hw.isar.mod = tmp___2; p1 = tmp___2; bcs->hw.isar.newmod = 0U; bcs->hw.isar.cmd = bcs->hw.isar.newcmd; bcs->hw.isar.newcmd = 0U; sendmsg(cs, (int )((unsigned int )dps | 42U), (int )bcs->hw.isar.cmd, 1, & p1); bcs->hw.isar.state = 2U; bcs->hw.isar.try_mod = 3; goto ldv_41272; default: ; if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"RSP_DISC unknown newcmd %x", (int )bcs->hw.isar.newcmd); } else { } goto ldv_41272; } ldv_41272: ; } else if ((unsigned int )bcs->hw.isar.state == 4U) { tmp___3 = test_and_clear_bit(14, (unsigned long volatile *)(& bcs->Flag)); if (tmp___3 != 0) { test_and_set_bit(10, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else if ((unsigned int )bcs->hw.isar.cmd == 166U) { send_DLE_ETX(bcs); test_and_set_bit(8, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { ll_deliver_faxstat(bcs, 4); } bcs->hw.isar.state = 1U; } else { bcs->hw.isar.state = 1U; ll_deliver_faxstat(bcs, 4); } goto ldv_41262; case 190: ; if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"pump stev RSP_SILDET"); } else { } if ((unsigned int )bcs->hw.isar.state == 6U) { tmp___4 = bcs->hw.isar.newmod; bcs->hw.isar.mod = tmp___4; p1 = tmp___4; bcs->hw.isar.newmod = 0U; bcs->hw.isar.cmd = bcs->hw.isar.newcmd; bcs->hw.isar.newcmd = 0U; sendmsg(cs, (int )((unsigned int )dps | 42U), (int )bcs->hw.isar.cmd, 1, & p1); bcs->hw.isar.state = 2U; bcs->hw.isar.try_mod = 3; } else { } goto ldv_41262; case 171: ; if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"pump stev RSP_SILOFF"); } else { } goto ldv_41262; case 185: ; if ((unsigned int )bcs->hw.isar.state == 2U) { if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"pump stev RSP_FCERR try %d", (int )bcs->hw.isar.try_mod); } else { } tmp___5 = bcs->hw.isar.try_mod; bcs->hw.isar.try_mod = (char )((int )bcs->hw.isar.try_mod - 1); if ((int )((signed char )tmp___5) != 0) { sendmsg(cs, (int )((unsigned int )dps | 42U), (int )bcs->hw.isar.cmd, 1, & bcs->hw.isar.mod); goto ldv_41262; } else { } } else { } if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"pump stev RSP_FCERR"); } else { } bcs->hw.isar.state = 5U; sendmsg(cs, (int )((unsigned int )dps | 42U), 164, 0, 0); ll_deliver_faxstat(bcs, 4); goto ldv_41262; default: ; goto ldv_41262; } ldv_41262: ; return; } } static char debbuf[128U] ; void isar_int_main(struct IsdnCardState *cs ) { struct isar_reg *ireg ; struct BCState *bcs ; u_char *tp ; int tmp ; { ireg = cs->bcs[0].hw.isar.reg; get_irq_infos(cs, ireg); switch ((int )ireg->iis & 63) { case 32: bcs = sel_bcs_isar(cs, (int )((unsigned char )ireg->iis) >> 6); if ((unsigned long )bcs != (unsigned long )((struct BCState *)0)) { isar_rcv_frame(cs, bcs); } else { debugl1(cs, (char *)"isar spurious IIS_RDATA %x/%x/%x", (int )ireg->iis, (int )ireg->cmsb, (int )ireg->clsb); (*(cs->BC_Write_Reg))(cs, 1, 88, 0); } goto ldv_41293; case 0: (*(cs->BC_Write_Reg))(cs, 1, 88, 0); ireg->bstat = (u_char volatile )((int )((unsigned char )ireg->bstat) | (int )((unsigned char )ireg->cmsb)); check_send(cs, (int )ireg->cmsb); goto ldv_41293; case 40: bcs = sel_bcs_isar(cs, (int )((unsigned char )ireg->iis) >> 6); if ((unsigned long )bcs != (unsigned long )((struct BCState *)0)) { if ((unsigned int )((unsigned char )ireg->cmsb) == 31U) { bcs->err_tx = bcs->err_tx + 1; } else { } if ((unsigned int )((unsigned char )ireg->cmsb) == 47U) { bcs->err_rdo = bcs->err_rdo + 1; } else { } } else { } if (cs->debug & 1) { debugl1(cs, (char *)"Buffer STEV dpath%d msb(%x)", (int )((unsigned char )ireg->iis) >> 6, (int )ireg->cmsb); } else { } (*(cs->BC_Write_Reg))(cs, 1, 88, 0); goto ldv_41293; case 42: bcs = sel_bcs_isar(cs, (int )((unsigned char )ireg->iis) >> 6); if ((unsigned long )bcs != (unsigned long )((struct BCState *)0)) { rcv_mbox(cs, ireg, (u_char *)(& ireg->par)); if (bcs->mode == 8) { isar_pump_statev_modem(bcs, (int )ireg->cmsb); } else if (bcs->mode == 9) { isar_pump_statev_fax(bcs, (int )ireg->cmsb); } else if ((unsigned int )((unsigned char )ireg->cmsb) == 2U) { if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"pump stev TIMER"); } else if (cs->debug & 1) { debugl1(cs, (char *)"isar IIS_PSTEV pmode %d stat %x", bcs->mode, (int )ireg->cmsb); } else { } } else { } } else { debugl1(cs, (char *)"isar spurious IIS_PSTEV %x/%x/%x", (int )ireg->iis, (int )ireg->cmsb, (int )ireg->clsb); (*(cs->BC_Write_Reg))(cs, 1, 88, 0); } goto ldv_41293; case 46: bcs = sel_bcs_isar(cs, (int )((unsigned char )ireg->iis) >> 6); if ((unsigned long )bcs != (unsigned long )((struct BCState *)0)) { rcv_mbox(cs, ireg, (u_char *)(& ireg->par)); isar_pump_status_rsp(bcs, ireg); } else { debugl1(cs, (char *)"isar spurious IIS_PSTRSP %x/%x/%x", (int )ireg->iis, (int )ireg->cmsb, (int )ireg->clsb); (*(cs->BC_Write_Reg))(cs, 1, 88, 0); } goto ldv_41293; case 37: ; case 44: ; case 39: rcv_mbox(cs, ireg, (u_char *)(& ireg->par)); if ((cs->debug & 48) == 16) { tp = (u_char *)(& debbuf); tmp = sprintf((char *)(& debbuf), "msg iis(%x) msb(%x)", (int )ireg->iis, (int )ireg->cmsb); tp = tp + (unsigned long )tmp; QuickHex((char *)tp, (u_char *)(& ireg->par), (int )ireg->clsb); debugl1(cs, (char *)(& debbuf)); } else { } goto ldv_41293; case 63: rcv_mbox(cs, ireg, (u_char *)(& debbuf)); if (cs->debug & 1) { debugl1(cs, (char *)"invalid msg his:%x", (int )ireg->cmsb); } else { } goto ldv_41293; default: rcv_mbox(cs, ireg, (u_char *)(& debbuf)); if (cs->debug & 1) { debugl1(cs, (char *)"unhandled msg iis(%x) ctrl(%x/%x)", (int )ireg->iis, (int )ireg->cmsb, (int )ireg->clsb); } else { } goto ldv_41293; } ldv_41293: ; return; } } static void ftimer_handler(struct BCState *bcs ) { int tmp ; int tmp___0 ; { if ((bcs->cs)->debug != 0) { debugl1(bcs->cs, (char *)"ftimer flags %04lx", bcs->Flag); } else { } test_and_clear_bit(13, (unsigned long volatile *)(& bcs->Flag)); tmp = test_and_clear_bit(15, (unsigned long volatile *)(& bcs->Flag)); if (tmp != 0) { test_and_set_bit(9, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } tmp___0 = test_and_clear_bit(16, (unsigned long volatile *)(& bcs->Flag)); if (tmp___0 != 0) { test_and_set_bit(10, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } return; } } static void setup_pump(struct BCState *bcs ) { struct IsdnCardState *cs ; u_char dps ; u_char ctrl ; u_char param[6U] ; int tmp ; int tmp___0 ; { cs = bcs->cs; dps = (u_char )(bcs->hw.isar.dpath << 6); switch (bcs->mode) { case 0: ; case 1: ; case 2: sendmsg(cs, (int )((unsigned int )dps | 38U), 7, 0, 0); goto ldv_41317; case 8: ctrl = 2U; tmp = constant_test_bit(7U, (unsigned long const volatile *)(& bcs->Flag)); if (tmp != 0) { ctrl = (u_char )((unsigned int )ctrl | 128U); param[5] = 1U; } else { param[5] = 2U; } param[0] = (u_char )para_TOA; param[1] = 123U; param[2] = 131U; param[3] = 249U; param[4] = 15U; sendmsg(cs, (int )((unsigned int )dps | 38U), (int )ctrl, 6, (u_char *)(& param)); goto ldv_41317; case 9: ctrl = 1U; tmp___0 = constant_test_bit(7U, (unsigned long const volatile *)(& bcs->Flag)); if (tmp___0 != 0) { ctrl = (u_char )((unsigned int )ctrl | 128U); param[1] = 1U; } else { param[1] = 4U; } param[0] = (u_char )para_TOA; sendmsg(cs, (int )((unsigned int )dps | 38U), (int )ctrl, 2, (u_char *)(& param)); bcs->hw.isar.state = 0U; bcs->hw.isar.newcmd = 0U; bcs->hw.isar.newmod = 0U; test_and_set_bit(13, (unsigned long volatile *)(& bcs->Flag)); goto ldv_41317; } ldv_41317: __const_udelay(4295000UL); sendmsg(cs, (int )((unsigned int )dps | 14U), 0, 0, 0); __const_udelay(4295000UL); return; } } static void setup_sart(struct BCState *bcs ) { struct IsdnCardState *cs ; u_char dps ; u_char ctrl ; u_char param[2U] ; { cs = bcs->cs; dps = (u_char )(bcs->hw.isar.dpath << 6); switch (bcs->mode) { case 0: sendmsg(cs, (int )((unsigned int )dps | 37U), 0, 0, 0); goto ldv_41328; case 1: sendmsg(cs, (int )((unsigned int )dps | 37U), 4, 2, (u_char *)""); goto ldv_41328; case 2: param[0] = 0U; sendmsg(cs, (int )((unsigned int )dps | 37U), 3, 1, (u_char *)(& param)); goto ldv_41328; case 8: ctrl = 2U; param[0] = 3U; param[1] = 16U; sendmsg(cs, (int )((unsigned int )dps | 37U), (int )ctrl, 2, (u_char *)(& param)); goto ldv_41328; case 9: ; goto ldv_41328; } ldv_41328: __const_udelay(4295000UL); sendmsg(cs, (int )((unsigned int )dps | 12U), 0, 0, 0); __const_udelay(4295000UL); return; } } static void setup_iom2(struct BCState *bcs ) { struct IsdnCardState *cs ; u_char dps ; u_char cmsb ; u_char msg[5U] ; { cs = bcs->cs; dps = (u_char )(bcs->hw.isar.dpath << 6); cmsb = 128U; msg[0] = 16U; msg[1] = 0U; msg[2] = 0U; msg[3] = 0U; msg[4] = 0U; if (bcs->channel != 0) { msg[3] = 1U; msg[1] = msg[3]; } else { } switch (bcs->mode) { case 0: cmsb = 0U; msg[3] = (unsigned int )((u_char )bcs->hw.isar.dpath) + 2U; msg[1] = msg[3]; goto ldv_41341; case 1: ; case 2: ; goto ldv_41341; case 8: ; case 9: cmsb = (u_char )((unsigned int )cmsb | 3U); goto ldv_41341; } ldv_41341: sendmsg(cs, (int )((unsigned int )dps | 39U), (int )cmsb, 5, (u_char *)(& msg)); __const_udelay(4295000UL); sendmsg(cs, (int )((unsigned int )dps | 7U), 0, 0, 0); __const_udelay(4295000UL); return; } } static int modeisar(struct BCState *bcs , int mode , int bc ) { struct IsdnCardState *cs ; int tmp ; int tmp___0 ; int tmp___1 ; { cs = bcs->cs; if (bcs->mode == 0) { bcs->channel = bc; switch (mode) { case 0: ; if (bcs->hw.isar.dpath == 0) { return (0); } else { } goto ldv_41353; case 1: ; case 2: tmp___0 = test_and_set_bit(2, (unsigned long volatile *)(& (bcs->hw.isar.reg)->Flags)); if (tmp___0 == 0) { bcs->hw.isar.dpath = 2; } else { tmp = test_and_set_bit(1, (unsigned long volatile *)(& (bcs->hw.isar.reg)->Flags)); if (tmp == 0) { bcs->hw.isar.dpath = 1; } else { printk("\fisar modeisar both paths in use\n"); return (1); } } goto ldv_41353; case 8: ; case 9: tmp___1 = test_and_set_bit(1, (unsigned long volatile *)(& (bcs->hw.isar.reg)->Flags)); if (tmp___1 == 0) { bcs->hw.isar.dpath = 1; } else { printk("\fisar modeisar analog functions only with DP1\n"); debugl1(cs, (char *)"isar modeisar analog functions only with DP1"); return (1); } goto ldv_41353; } ldv_41353: ; } else { } if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"isar dp%d mode %d->%d ichan %d", bcs->hw.isar.dpath, bcs->mode, mode, bc); } else { } bcs->mode = mode; setup_pump(bcs); setup_iom2(bcs); setup_sart(bcs); if (bcs->mode == 0) { if (bcs->hw.isar.dpath == 1) { test_and_clear_bit(1, (unsigned long volatile *)(& (bcs->hw.isar.reg)->Flags)); } else if (bcs->hw.isar.dpath == 2) { test_and_clear_bit(2, (unsigned long volatile *)(& (bcs->hw.isar.reg)->Flags)); } else { } bcs->hw.isar.dpath = 0; } else { } return (0); } } static void isar_pump_cmd(struct BCState *bcs , u_char cmd , u_char para ) { struct IsdnCardState *cs ; u_char dps ; u_char ctrl ; u_char nom ; u_char p1 ; { cs = bcs->cs; dps = (u_char )(bcs->hw.isar.dpath << 6); ctrl = 0U; nom = 0U; p1 = 0U; switch ((int )cmd) { case 3: test_and_clear_bit(17, (unsigned long volatile *)(& bcs->Flag)); if ((unsigned int )bcs->hw.isar.state == 1U) { p1 = para; ctrl = 168U; nom = 1U; bcs->hw.isar.state = 2U; bcs->hw.isar.cmd = ctrl; bcs->hw.isar.mod = para; bcs->hw.isar.newmod = 0U; bcs->hw.isar.newcmd = 0U; bcs->hw.isar.try_mod = 3; } else if (((unsigned int )bcs->hw.isar.state == 4U && (unsigned int )bcs->hw.isar.cmd == 168U) && (int )bcs->hw.isar.mod == (int )para) { ll_deliver_faxstat(bcs, 1); } else { bcs->hw.isar.newmod = para; bcs->hw.isar.newcmd = 168U; nom = 0U; ctrl = 164U; bcs->hw.isar.state = 5U; } goto ldv_41369; case 5: test_and_clear_bit(17, (unsigned long volatile *)(& bcs->Flag)); if ((unsigned int )bcs->hw.isar.state == 1U) { p1 = para; ctrl = 167U; nom = 1U; bcs->hw.isar.state = 2U; bcs->hw.isar.cmd = ctrl; bcs->hw.isar.mod = para; bcs->hw.isar.newmod = 0U; bcs->hw.isar.newcmd = 0U; bcs->hw.isar.try_mod = 3; } else if (((unsigned int )bcs->hw.isar.state == 4U && (unsigned int )bcs->hw.isar.cmd == 167U) && (int )bcs->hw.isar.mod == (int )para) { ll_deliver_faxstat(bcs, 1); } else { bcs->hw.isar.newmod = para; bcs->hw.isar.newcmd = 167U; nom = 0U; ctrl = 164U; bcs->hw.isar.state = 5U; } goto ldv_41369; case 4: test_and_clear_bit(17, (unsigned long volatile *)(& bcs->Flag)); if ((unsigned int )bcs->hw.isar.state == 1U) { p1 = para; ctrl = 166U; nom = 1U; bcs->hw.isar.state = 2U; bcs->hw.isar.cmd = ctrl; bcs->hw.isar.mod = para; bcs->hw.isar.newmod = 0U; bcs->hw.isar.newcmd = 0U; bcs->hw.isar.try_mod = 3; } else if (((unsigned int )bcs->hw.isar.state == 4U && (unsigned int )bcs->hw.isar.cmd == 166U) && (int )bcs->hw.isar.mod == (int )para) { ll_deliver_faxstat(bcs, 1); } else { bcs->hw.isar.newmod = para; bcs->hw.isar.newcmd = 166U; nom = 0U; ctrl = 164U; bcs->hw.isar.state = 5U; } goto ldv_41369; case 6: test_and_set_bit(17, (unsigned long volatile *)(& bcs->Flag)); if ((unsigned int )bcs->hw.isar.state == 1U) { p1 = para; ctrl = 165U; nom = 1U; bcs->hw.isar.state = 2U; bcs->hw.isar.cmd = ctrl; bcs->hw.isar.mod = para; bcs->hw.isar.newmod = 0U; bcs->hw.isar.newcmd = 0U; bcs->hw.isar.try_mod = 3; } else if (((unsigned int )bcs->hw.isar.state == 4U && (unsigned int )bcs->hw.isar.cmd == 165U) && (int )bcs->hw.isar.mod == (int )para) { ll_deliver_faxstat(bcs, 1); } else { bcs->hw.isar.newmod = para; bcs->hw.isar.newcmd = 165U; nom = 0U; ctrl = 164U; bcs->hw.isar.state = 5U; } goto ldv_41369; case 100: bcs->hw.isar.state = 0U; nom = 0U; ctrl = 169U; goto ldv_41369; } ldv_41369: ; if ((unsigned int )ctrl != 0U) { sendmsg(cs, (int )((unsigned int )dps | 42U), (int )ctrl, (int )nom, & p1); } else { } return; } } static void isar_setup(struct IsdnCardState *cs ) { u_char msg ; int i ; struct lock_class_key __key ; atomic_long_t __constr_expr_0 ; { msg = 61U; i = 0; goto ldv_41382; ldv_41381: sendmsg(cs, i != 0 ? 164 : 100, 4, 1, & msg); cs->bcs[i].hw.isar.mml = (int )msg; cs->bcs[i].mode = 0; cs->bcs[i].hw.isar.dpath = i + 1; modeisar((struct BCState *)(& cs->bcs) + (unsigned long )i, 0, 0); __init_work(& cs->bcs[i].tqueue, 0); __constr_expr_0.counter = 4195328L; cs->bcs[i].tqueue.data = __constr_expr_0; lockdep_init_map(& cs->bcs[i].tqueue.lockdep_map, "(&cs->bcs[i].tqueue)", & __key, 0); INIT_LIST_HEAD(& cs->bcs[i].tqueue.entry); cs->bcs[i].tqueue.func = & isar_bh; i = i + 1; ldv_41382: ; if (i <= 1) { goto ldv_41381; } else { } return; } } static void isar_l2l1(struct PStack *st , int pr , void *arg ) { struct BCState *bcs ; struct sk_buff *skb ; int ret ; u_long flags ; raw_spinlock_t *tmp ; raw_spinlock_t *tmp___0 ; raw_spinlock_t *tmp___1 ; int tmp___2 ; raw_spinlock_t *tmp___3 ; { bcs = st->l1.bcs; skb = (struct sk_buff *)arg; switch (pr) { case 288: tmp = spinlock_check(& (bcs->cs)->lock); flags = _raw_spin_lock_irqsave(tmp); if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { skb_queue_tail(& bcs->squeue, skb); } else { bcs->tx_skb = skb; test_and_set_bit(3, (unsigned long volatile *)(& bcs->Flag)); if (((bcs->cs)->debug & 16) != 0) { debugl1(bcs->cs, (char *)"DRQ set BC_FLG_BUSY"); } else { } bcs->hw.isar.txcnt = 0; (*((bcs->cs)->BC_Send_Data))(bcs); } spin_unlock_irqrestore(& (bcs->cs)->lock, flags); goto ldv_41397; case 306: tmp___0 = spinlock_check(& (bcs->cs)->lock); flags = _raw_spin_lock_irqsave(tmp___0); if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { printk("\fisar_l2l1: this shouldn\'t happen\n"); } else { test_and_set_bit(3, (unsigned long volatile *)(& bcs->Flag)); if (((bcs->cs)->debug & 16) != 0) { debugl1(bcs->cs, (char *)"PUI set BC_FLG_BUSY"); } else { } bcs->tx_skb = skb; bcs->hw.isar.txcnt = 0; (*((bcs->cs)->BC_Send_Data))(bcs); } spin_unlock_irqrestore(& (bcs->cs)->lock, flags); goto ldv_41397; case 304: ; if ((unsigned long )bcs->tx_skb == (unsigned long )((struct sk_buff *)0)) { test_and_clear_bit(6, (unsigned long volatile *)(& st->l1.Flags)); (*(st->l1.l1l2))(st, 305, 0); } else { test_and_set_bit(6, (unsigned long volatile *)(& st->l1.Flags)); } goto ldv_41397; case 256: tmp___1 = spinlock_check(& (bcs->cs)->lock); flags = _raw_spin_lock_irqsave(tmp___1); test_and_set_bit(2, (unsigned long volatile *)(& bcs->Flag)); bcs->hw.isar.conmsg[0] = 0U; tmp___2 = constant_test_bit(2U, (unsigned long const volatile *)(& st->l2.flag)); if (tmp___2 != 0) { test_and_set_bit(7, (unsigned long volatile *)(& bcs->Flag)); } else { test_and_clear_bit(7, (unsigned long volatile *)(& bcs->Flag)); } switch (st->l1.mode) { case 1: ; case 2: ret = modeisar(bcs, st->l1.mode, st->l1.bc); spin_unlock_irqrestore(& (bcs->cs)->lock, flags); if (ret != 0) { l1_msg_b(st, 272, arg); } else { l1_msg_b(st, 256, arg); } goto ldv_41409; case 8: ; case 9: ret = modeisar(bcs, st->l1.mode, st->l1.bc); spin_unlock_irqrestore(& (bcs->cs)->lock, flags); if (ret != 0) { l1_msg_b(st, 272, arg); } else { } goto ldv_41409; default: spin_unlock_irqrestore(& (bcs->cs)->lock, flags); goto ldv_41409; } ldv_41409: ; goto ldv_41397; case 272: l1_msg_b(st, pr, arg); goto ldv_41397; case 273: tmp___3 = spinlock_check(& (bcs->cs)->lock); flags = _raw_spin_lock_irqsave(tmp___3); switch (st->l1.mode) { case 1: ; case 2: ; case 8: ; goto ldv_41421; case 9: isar_pump_cmd(bcs, 100, 0); goto ldv_41421; } ldv_41421: test_and_clear_bit(2, (unsigned long volatile *)(& bcs->Flag)); test_and_clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); if (((bcs->cs)->debug & 16) != 0) { debugl1(bcs->cs, (char *)"PDAC clear BC_FLG_BUSY"); } else { } modeisar(bcs, 0, st->l1.bc); spin_unlock_irqrestore(& (bcs->cs)->lock, flags); (*(st->l1.l1l2))(st, 273, 0); goto ldv_41397; } ldv_41397: ; return; } } static void close_isarstate(struct BCState *bcs ) { int tmp ; { modeisar(bcs, 0, bcs->channel); tmp = test_and_clear_bit(1, (unsigned long volatile *)(& bcs->Flag)); if (tmp != 0) { kfree((void const *)bcs->hw.isar.rcvbuf); bcs->hw.isar.rcvbuf = 0; skb_queue_purge(& bcs->rqueue); skb_queue_purge(& bcs->squeue); if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { dev_kfree_skb_any(bcs->tx_skb); bcs->tx_skb = 0; test_and_clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); if (((bcs->cs)->debug & 16) != 0) { debugl1(bcs->cs, (char *)"closeisar clear BC_FLG_BUSY"); } else { } } else { } } else { } del_timer(& bcs->hw.isar.ftimer); return; } } static int open_isarstate(struct IsdnCardState *cs , struct BCState *bcs ) { u_char *tmp ; void *tmp___0 ; int tmp___1 ; { tmp___1 = test_and_set_bit(1, (unsigned long volatile *)(& bcs->Flag)); if (tmp___1 == 0) { tmp___0 = kmalloc(4096UL, 32U); tmp = (u_char *)tmp___0; bcs->hw.isar.rcvbuf = tmp; if ((unsigned long )tmp == (unsigned long )((u_char *)0)) { printk("\fHiSax: No memory for isar.rcvbuf\n"); return (1); } else { } skb_queue_head_init(& bcs->rqueue); skb_queue_head_init(& bcs->squeue); } else { } bcs->tx_skb = 0; test_and_clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"openisar clear BC_FLG_BUSY"); } else { } bcs->event = 0UL; bcs->hw.isar.rcvidx = 0; bcs->tx_cnt = 0; return (0); } } static int setstack_isar(struct PStack *st , struct BCState *bcs ) { int tmp ; { bcs->channel = st->l1.bc; tmp = open_isarstate((struct IsdnCardState *)st->l1.hardware, bcs); if (tmp != 0) { return (-1); } else { } st->l1.bcs = bcs; st->l2.l2l1 = & isar_l2l1; setstack_manager(st); bcs->st = st; setstack_l1_B(st); return (0); } } int isar_auxcmd(struct IsdnCardState *cs , isdn_ctrl *ic ) { u_long adr ; int features ; int i ; struct BCState *bcs ; int tmp ; char *p ; int tmp___0 ; int tmp___1 ; size_t __len ; void *__ret ; int tmp___2 ; { if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"isar_auxcmd cmd/ch %x/%ld", ic->command, ic->arg); } else { } switch (ic->command) { case 23: bcs = cs->channel[ic->arg].bcs; if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"isar_auxcmd cmd/subcmd %d/%d", (int )ic->parm.aux.cmd, (int )ic->parm.aux.subcmd); } else { } switch ((int )ic->parm.aux.cmd) { case 7: ; if ((unsigned int )ic->parm.aux.subcmd == 3U) { test_and_set_bit(8, (unsigned long volatile *)(& bcs->Flag)); } else { } goto ldv_41444; case 1: ; if ((unsigned int )ic->parm.aux.subcmd == 2U) { ic->command = 276; ic->parm.aux.cmd = 0U; (*(cs->iif.statcallb))(ic); return (0); } else if ((unsigned int )ic->parm.aux.subcmd == 3U) { strcpy((char *)(& ic->parm.aux.para), "0-255"); ic->command = 276; ic->parm.aux.cmd = 5U; (*(cs->iif.statcallb))(ic); return (0); } else if ((unsigned int )ic->parm.aux.subcmd == 1U) { if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"isar_auxcmd %s=%d", FC1_CMD[(int )ic->parm.aux.cmd], (int )ic->parm.aux.para[0]); } else { } if ((unsigned int )bcs->hw.isar.state == 1U) { if ((unsigned int )ic->parm.aux.para[0] == 0U) { ic->command = 276; ic->parm.aux.cmd = 0U; (*(cs->iif.statcallb))(ic); return (0); } else { } tmp = test_and_set_bit(13, (unsigned long volatile *)(& bcs->Flag)); if (tmp == 0) { bcs->hw.isar.ftimer.expires = (unsigned long )(((int )ic->parm.aux.para[0] * 2500) / 1000) + (unsigned long )jiffies; test_and_set_bit(16, (unsigned long volatile *)(& bcs->Flag)); add_timer(& bcs->hw.isar.ftimer); return (0); } else if (cs->debug != 0) { debugl1(cs, (char *)"isar FTS=%d and FTI busy", (int )ic->parm.aux.para[0]); } else { } } else if (cs->debug != 0) { debugl1(cs, (char *)"isar FTS=%d and isar.state not ready(%x)", (int )ic->parm.aux.para[0], (int )bcs->hw.isar.state); } else { } ic->command = 276; ic->parm.aux.cmd = 3U; (*(cs->iif.statcallb))(ic); } else { } goto ldv_41444; case 4: ; case 6: ; case 3: ; case 5: ; if ((unsigned int )ic->parm.aux.subcmd == 2U) { sprintf((char *)(& ic->parm.aux.para), "%d", (int )bcs->hw.isar.mod); ic->command = 276; ic->parm.aux.cmd = 5U; (*(cs->iif.statcallb))(ic); return (0); } else if ((unsigned int )ic->parm.aux.subcmd == 3U) { p = (char *)(& ic->parm.aux.para); i = 0; goto ldv_41452; ldv_41451: ; if (((u_int )(1 << i) & modmask) != 0U) { tmp___0 = sprintf(p, "%d,", (int )faxmodulation[i]); p = p + (unsigned long )tmp___0; } else { } i = i + 1; ldv_41452: ; if (i <= 12) { goto ldv_41451; } else { } p = p - 1; *p = 0; ic->command = 276; ic->parm.aux.cmd = 5U; (*(cs->iif.statcallb))(ic); return (0); } else if ((unsigned int )ic->parm.aux.subcmd == 1U) { if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"isar_auxcmd %s=%d", FC1_CMD[(int )ic->parm.aux.cmd], (int )ic->parm.aux.para[0]); } else { } i = 0; goto ldv_41456; ldv_41455: ; if ((int )((unsigned char )faxmodulation[i]) == (int )ic->parm.aux.para[0]) { goto ldv_41454; } else { } i = i + 1; ldv_41456: ; if (i <= 12) { goto ldv_41455; } else { } ldv_41454: ; if (i <= 12 && ((u_int )(1 << i) & modmask) != 0U) { tmp___1 = constant_test_bit(1U, (unsigned long const volatile *)(& bcs->Flag)); if (tmp___1 != 0) { isar_pump_cmd(bcs, (int )ic->parm.aux.cmd, (int )ic->parm.aux.para[0]); return (0); } else { } } else { } } else { } default: ic->command = 276; ic->parm.aux.cmd = 3U; (*(cs->iif.statcallb))(ic); } ldv_41444: ; goto ldv_41458; case 0: ; switch (ic->arg) { case 9UL: features = 527360; __len = 8UL; if (__len > 63UL) { __ret = memcpy((void *)(& adr), (void const *)(& ic->parm.num), __len); } else { __ret = memcpy((void *)(& adr), (void const *)(& ic->parm.num), __len); } tmp___2 = isar_load_firmware(cs, (u_char *)adr); if (tmp___2 != 0) { return (1); } else { ll_run(cs, features); } goto ldv_41464; case 20UL: features = (int )*((unsigned int *)(& ic->parm.num)); printk("\017HiSax: max modulation old(%04x) new(%04x)\n", modmask, features); modmask = (u_int )features; goto ldv_41464; case 21UL: features = (int )*((unsigned int *)(& ic->parm.num)); printk("\017HiSax: FRM extra delay old(%d) new(%d) ms\n", frm_extra_delay, features); if (features >= 0) { frm_extra_delay = features; } else { } goto ldv_41464; case 22UL: features = (int )*((unsigned int *)(& ic->parm.num)); printk("\017HiSax: TOA old(%d) new(%d) db\n", para_TOA, features); if (features >= 0 && features <= 31) { para_TOA = features; } else { } goto ldv_41464; default: printk("\017HiSax: invalid ioctl %d\n", (int )ic->arg); return (-22); } ldv_41464: ; goto ldv_41458; default: ; return (-22); } ldv_41458: ; return (0); } } void initisar(struct IsdnCardState *cs ) { struct lock_class_key __key ; struct lock_class_key __key___0 ; { cs->bcs[0].BC_SetStack = & setstack_isar; cs->bcs[1].BC_SetStack = & setstack_isar; cs->bcs[0].BC_Close = & close_isarstate; cs->bcs[1].BC_Close = & close_isarstate; cs->bcs[0].hw.isar.ftimer.function = (void (*)(unsigned long ))(& ftimer_handler); cs->bcs[0].hw.isar.ftimer.data = (unsigned long )(& cs->bcs); init_timer_key(& cs->bcs[0].hw.isar.ftimer, 0U, "(&cs->bcs[0].hw.isar.ftimer)", & __key); cs->bcs[1].hw.isar.ftimer.function = (void (*)(unsigned long ))(& ftimer_handler); cs->bcs[1].hw.isar.ftimer.data = (unsigned long )((struct BCState *)(& cs->bcs) + 1UL); init_timer_key(& cs->bcs[1].hw.isar.ftimer, 0U, "(&cs->bcs[1].hw.isar.ftimer)", & __key___0); return; } } void ldv_mutex_lock_337(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_lock(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_338(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_lock(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_339(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } int ldv_mutex_trylock_340(struct mutex *ldv_func_arg1 ) { ldv_func_ret_type___2 ldv_func_res ; int tmp ; int tmp___0 ; { tmp = mutex_trylock(ldv_func_arg1); ldv_func_res = tmp; tmp___0 = ldv_mutex_trylock_mutex(ldv_func_arg1); return (tmp___0); return (ldv_func_res); } } void ldv_mutex_unlock_341(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_342(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_cred_guard_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_343(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_cred_guard_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } int ldv_mutex_trylock_354(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_352(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_355(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_357(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_351(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_353(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_356(struct mutex *ldv_func_arg1 ) ; extern int pci_bus_read_config_dword(struct pci_bus * , unsigned int , int , u32 * ) ; __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); } } extern void pci_set_master(struct pci_dev * ) ; u_char NETjet_ReadIC(struct IsdnCardState *cs , u_char offset ) ; void NETjet_WriteIC(struct IsdnCardState *cs , u_char offset , u_char value ) ; void NETjet_ReadICfifo(struct IsdnCardState *cs , u_char *data , int size ) ; void NETjet_WriteICfifo(struct IsdnCardState *cs , u_char *data , int size ) ; void read_tiger(struct IsdnCardState *cs ) ; void write_tiger(struct IsdnCardState *cs ) ; void netjet_fill_dma(struct BCState *bcs ) ; void inittiger(struct IsdnCardState *cs ) ; void release_io_netjet(struct IsdnCardState *cs ) ; static char const *NETjet_S_revision = "$Revision: 2.13.2.4 $"; static u_char dummyrr(struct IsdnCardState *cs , int chan , u_char off ) { { return (5U); } } static void dummywr(struct IsdnCardState *cs , int chan , u_char off , u_char value ) { { return; } } static irqreturn_t netjet_s_interrupt(int intno , void *dev_id ) { struct IsdnCardState *cs ; u_char val ; u_char s1val ; u_char s0val ; u_long flags ; raw_spinlock_t *tmp ; unsigned int tmp___0 ; unsigned int tmp___1 ; unsigned int tmp___2 ; unsigned int tmp___3 ; int tmp___4 ; { cs = (struct IsdnCardState *)dev_id; tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); s1val = inb((int )((unsigned int )cs->hw.njet.base + 7U)); if (((int )s1val & 16) == 0) { val = NETjet_ReadIC(cs, 32); if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"tiger: i1 %x %x", (int )s1val, (int )val); } else { } if ((unsigned int )val != 0U) { isac_interrupt(cs, (int )val); NETjet_WriteIC(cs, 32, 255); NETjet_WriteIC(cs, 32, 0); } else { } s1val = 1U; } else { s1val = 0U; } s0val = inb((int )((unsigned int )cs->hw.njet.base + 6U)); if ((unsigned int )((int )s0val | (int )s1val) == 0U) { spin_unlock_irqrestore(& cs->lock, flags); return (0); } else { } if ((unsigned int )s0val != 0U) { outb((int )s0val, (int )((unsigned int )cs->hw.njet.base + 6U)); } else { } tmp___0 = inl((int )((unsigned int )cs->hw.njet.base + 36U)); tmp___1 = inl((int )((unsigned int )cs->hw.njet.base + 28U)); if (tmp___0 < tmp___1) { s0val = 8U; } else { s0val = 4U; } tmp___2 = inl((int )((unsigned int )cs->hw.njet.base + 20U)); tmp___3 = inl((int )((unsigned int )cs->hw.njet.base + 12U)); if (tmp___2 < tmp___3) { s0val = (u_char )((unsigned int )s0val | 2U); } else { s0val = (u_char )((unsigned int )s0val | 1U); } if ((int )cs->hw.njet.last_is0 != (int )s0val) { tmp___4 = test_and_set_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___4 != 0) { printk("\fnj LOCK_ATOMIC s0val %x->%x\n", (int )cs->hw.njet.last_is0, (int )s0val); spin_unlock_irqrestore(& cs->lock, flags); return (1); } else { } cs->hw.njet.irqstat0 = s0val; if ((((int )cs->hw.njet.irqstat0 ^ (int )cs->hw.njet.last_is0) & 12) != 0) { read_tiger(cs); } else { } if ((((int )cs->hw.njet.irqstat0 ^ (int )cs->hw.njet.last_is0) & 3) != 0) { write_tiger(cs); } else { } test_and_clear_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); } else { } spin_unlock_irqrestore(& cs->lock, flags); return (1); } } static void reset_netjet_s(struct IsdnCardState *cs ) { unsigned long __ms ; unsigned long tmp ; unsigned long __ms___0 ; unsigned long tmp___0 ; { cs->hw.njet.ctrl_reg = 255U; outb((int )cs->hw.njet.ctrl_reg, (int )cs->hw.njet.base); __ms = 10UL; goto ldv_41086; ldv_41085: __const_udelay(4295000UL); ldv_41086: tmp = __ms; __ms = __ms - 1UL; if (tmp != 0UL) { goto ldv_41085; } else { } if ((unsigned int )cs->subtyp != 0U) { cs->hw.njet.ctrl_reg = 64U; } else { cs->hw.njet.ctrl_reg = 0U; } outb((int )cs->hw.njet.ctrl_reg, (int )cs->hw.njet.base); __ms___0 = 10UL; goto ldv_41090; ldv_41089: __const_udelay(4295000UL); ldv_41090: tmp___0 = __ms___0; __ms___0 = __ms___0 - 1UL; if (tmp___0 != 0UL) { goto ldv_41089; } else { } cs->hw.njet.auxd = 0U; cs->hw.njet.dmactrl = 0U; outb(239, (int )((unsigned int )cs->hw.njet.base + 2U)); outb(16, (int )((unsigned int )cs->hw.njet.base + 5U)); outb((int )cs->hw.njet.auxd, (int )cs->hw.njet.auxa); return; } } static int NETjet_S_card_msg(struct IsdnCardState *cs , int mt , void *arg ) { u_long flags ; raw_spinlock_t *tmp ; raw_spinlock_t *tmp___0 ; { switch (mt) { case 240: tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); reset_netjet_s(cs); spin_unlock_irqrestore(& cs->lock, flags); return (0); case 243: release_io_netjet(cs); return (0); case 242: reset_netjet_s(cs); inittiger(cs); tmp___0 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___0); clear_pending_isac_ints(cs); initisac(cs); (*(cs->writeisac))(cs, 32, 0); spin_unlock_irqrestore(& cs->lock, flags); return (0); case 244: ; return (0); } return (0); } } static int njs_pci_probe(struct pci_dev *dev_netjet___2 , struct IsdnCardState *cs ) { u32 cfg ; int tmp ; { tmp = pci_enable_device(dev_netjet___2); if (tmp != 0) { return (0); } else { } pci_set_master(dev_netjet___2); cs->irq = dev_netjet___2->irq; if (cs->irq == 0U) { printk("\fNETjet-S: No IRQ for PCI card found\n"); return (0); } else { } cs->hw.njet.base = (unsigned long )dev_netjet___2->resource[0].start; if (cs->hw.njet.base == 0UL) { printk("\fNETjet-S: No IO-Adr for PCI card found\n"); return (0); } else { } pci_read_config_dword((struct pci_dev const *)dev_netjet___2, 4, & cfg); if ((cfg & 1048576U) != 0U) { cs->subtyp = 1U; } else { cs->subtyp = 0U; } if ((unsigned int )dev_netjet___2->subsystem_vendor == 85U && (unsigned int )dev_netjet___2->subsystem_device == 2U) { printk("\fNetjet: You tried to load this driver with an incompatible TigerJet-card\n"); printk("\fUse type=41 for Formula-n enter:now ISDN PCI and compatible\n"); return (0); } else { } return (1); } } static int njs_cs_init(struct IsdnCard *card , struct IsdnCardState *cs ) { unsigned long __ms ; unsigned long tmp ; unsigned long __ms___0 ; unsigned long tmp___0 ; u_char tmp___1 ; { cs->hw.njet.auxa = (unsigned int )cs->hw.njet.base + 3U; cs->hw.njet.isac = (unsigned int )cs->hw.njet.base | 192U; cs->hw.njet.ctrl_reg = 255U; outb((int )cs->hw.njet.ctrl_reg, (int )cs->hw.njet.base); __ms = 10UL; goto ldv_41119; ldv_41118: __const_udelay(4295000UL); ldv_41119: tmp = __ms; __ms = __ms - 1UL; if (tmp != 0UL) { goto ldv_41118; } else { } cs->hw.njet.ctrl_reg = 0U; outb((int )cs->hw.njet.ctrl_reg, (int )cs->hw.njet.base); __ms___0 = 10UL; goto ldv_41123; ldv_41122: __const_udelay(4295000UL); ldv_41123: tmp___0 = __ms___0; __ms___0 = __ms___0 - 1UL; if (tmp___0 != 0UL) { goto ldv_41122; } else { } cs->hw.njet.auxd = 192U; cs->hw.njet.dmactrl = 0U; outb(239, (int )((unsigned int )cs->hw.njet.base + 2U)); outb(16, (int )((unsigned int )cs->hw.njet.base + 5U)); outb((int )cs->hw.njet.auxd, (int )cs->hw.njet.auxa); tmp___1 = NETjet_ReadIC(cs, 42); switch (((int )tmp___1 >> 5) & 3) { case 0: ; return (1); case 3: printk("\fNETjet-S: NETspider-U PCI card found\n"); return (-1); default: printk("\fNETjet-S: No PCI card found\n"); return (0); } return (1); } } static int njs_cs_init_rest(struct IsdnCard *card , struct IsdnCardState *cs ) { int bytecnt ; struct resource *tmp ; { bytecnt = 256; printk("\016NETjet-S: %s card configured at %#lx IRQ %d\n", (unsigned int )cs->subtyp != 0U ? (char *)"TJ320" : (char *)"TJ300", cs->hw.njet.base, cs->irq); tmp = __request_region(& ioport_resource, (resource_size_t )cs->hw.njet.base, (resource_size_t )bytecnt, "netjet-s isdn", 0); if ((unsigned long )tmp == (unsigned long )((struct resource *)0)) { printk("\fHiSax: NETjet-S config port %#lx-%#lx already in use\n", cs->hw.njet.base, cs->hw.njet.base + (unsigned long )bytecnt); return (0); } else { } cs->readisac = & NETjet_ReadIC; cs->writeisac = & NETjet_WriteIC; cs->readisacfifo = & NETjet_ReadICfifo; cs->writeisacfifo = & NETjet_WriteICfifo; cs->BC_Read_Reg = & dummyrr; cs->BC_Write_Reg = & dummywr; cs->BC_Send_Data = & netjet_fill_dma; setup_isac(cs); cs->cardmsg = & NETjet_S_card_msg; cs->irq_func = & netjet_s_interrupt; cs->irq_flags = cs->irq_flags | 128UL; ISACVersion(cs, (char *)"NETjet-S:"); return (1); } } static struct pci_dev *dev_netjet = 0; int setup_netjet_s(struct IsdnCard *card ) { int ret ; struct IsdnCardState *cs ; char tmp[64U] ; char *tmp___0 ; int tmp___1 ; { cs = card->cs; strcpy((char *)(& tmp), NETjet_S_revision); tmp___0 = HiSax_getrev((char const *)(& tmp)); printk("\016HiSax: Traverse Tech. NETjet-S driver Rev. %s\n", tmp___0); if ((unsigned int )cs->typ != 20U) { return (0); } else { } test_and_clear_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); ldv_41141: dev_netjet = hisax_find_pci_device(57689U, 1U, dev_netjet); if ((unsigned long )dev_netjet != (unsigned long )((struct pci_dev *)0)) { ret = njs_pci_probe(dev_netjet, cs); if (ret == 0) { return (0); } else { } } else { printk("\fNETjet-S: No PCI card found\n"); return (0); } ret = njs_cs_init(card, cs); if (ret == 0) { return (0); } else { } if (ret > 0) { goto ldv_41140; } else { } goto ldv_41141; ldv_41140: tmp___1 = njs_cs_init_rest(card, cs); return (tmp___1); } } void ldv_mutex_lock_351(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_lock(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_352(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_lock(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_353(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } int ldv_mutex_trylock_354(struct mutex *ldv_func_arg1 ) { ldv_func_ret_type___2 ldv_func_res ; int tmp ; int tmp___0 ; { tmp = mutex_trylock(ldv_func_arg1); ldv_func_res = tmp; tmp___0 = ldv_mutex_trylock_mutex(ldv_func_arg1); return (tmp___0); return (ldv_func_res); } } void ldv_mutex_unlock_355(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_356(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_cred_guard_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_357(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_cred_guard_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } extern unsigned long __phys_addr(unsigned long ) ; extern void *memset(void * , int , size_t ) ; int ldv_mutex_trylock_368(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_366(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_369(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_371(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_365(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_367(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_370(struct mutex *ldv_func_arg1 ) ; __inline static phys_addr_t virt_to_phys(void volatile *address ) { unsigned long tmp ; { tmp = __phys_addr((unsigned long )address); return ((phys_addr_t )tmp); } } __inline static void *phys_to_virt(phys_addr_t address ) { { return ((void *)((unsigned long )address + 0xffff880000000000UL)); } } extern u16 const crc_ccitt_table[256U] ; __inline static u16 crc_ccitt_byte(u16 crc , u8 const c ) { { return ((u16 )(((int )crc >> 8) ^ (int )((unsigned short )crc_ccitt_table[((int )crc ^ (int )c) & 255]))); } } u_char NETjet_ReadIC(struct IsdnCardState *cs , u_char offset ) { u_char ret ; { cs->hw.njet.auxd = (unsigned int )cs->hw.njet.auxd & 252U; cs->hw.njet.auxd = (unsigned char )((int )((signed char )cs->hw.njet.auxd) | ((int )((signed char )((int )offset >> 4)) & 3)); outb((int )cs->hw.njet.auxd, (int )cs->hw.njet.auxa); ret = inb((int )(cs->hw.njet.isac + (unsigned int )(((int )offset & 15) << 2))); return (ret); } } void NETjet_WriteIC(struct IsdnCardState *cs , u_char offset , u_char value ) { { cs->hw.njet.auxd = (unsigned int )cs->hw.njet.auxd & 252U; cs->hw.njet.auxd = (unsigned char )((int )((signed char )cs->hw.njet.auxd) | ((int )((signed char )((int )offset >> 4)) & 3)); outb((int )cs->hw.njet.auxd, (int )cs->hw.njet.auxa); outb((int )value, (int )(cs->hw.njet.isac + (unsigned int )(((int )offset & 15) << 2))); return; } } void NETjet_ReadICfifo(struct IsdnCardState *cs , u_char *data , int size ) { { cs->hw.njet.auxd = (unsigned int )cs->hw.njet.auxd & 252U; outb((int )cs->hw.njet.auxd, (int )cs->hw.njet.auxa); insb((int )cs->hw.njet.isac, (void *)data, (unsigned long )size); return; } } void NETjet_WriteICfifo(struct IsdnCardState *cs , u_char *data , int size ) { { cs->hw.njet.auxd = (unsigned int )cs->hw.njet.auxd & 252U; outb((int )cs->hw.njet.auxd, (int )cs->hw.njet.auxa); outsb((int )cs->hw.njet.isac, (void const *)data, (unsigned long )size); return; } } static void fill_mem(struct BCState *bcs , u_int *pos , u_int cnt , int chan , u_char fill ) { u_int mask ; u_int val ; u_int *p ; u_int i ; u_int *tmp ; { mask = 255U; val = 0U; p = pos; val = (u_int )fill | val; if (chan != 0) { val = val << 8; mask = mask << 8; } else { } mask = ~ mask; i = 0U; goto ldv_41103; ldv_41102: *p = *p & mask; tmp = p; p = p + 1; *tmp = *tmp | val; if ((unsigned long )bcs->hw.tiger.s_end < (unsigned long )p) { p = bcs->hw.tiger.send; } else { } i = i + 1U; ldv_41103: ; if (i < cnt) { goto ldv_41102; } else { } return; } } static void mode_tiger(struct BCState *bcs , int mode , int bc ) { struct IsdnCardState *cs ; u_char led ; unsigned char tmp ; unsigned int tmp___0 ; unsigned int tmp___1 ; unsigned char tmp___2 ; unsigned char tmp___3 ; unsigned char tmp___4 ; { cs = bcs->cs; if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"Tiger mode %d bchan %d/%d", mode, bc, bcs->channel); } else { } bcs->mode = mode; bcs->channel = bc; switch (mode) { case 0: fill_mem(bcs, bcs->hw.tiger.send, 512U, bc, 255); if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"Tiger stat rec %d/%d send %d", bcs->hw.tiger.r_tot, bcs->hw.tiger.r_err, bcs->hw.tiger.s_tot); } else { } if (cs->bcs[0].mode == 0 && cs->bcs[1].mode == 0) { cs->hw.njet.dmactrl = 0U; outb((int )cs->hw.njet.dmactrl, (int )((unsigned int )cs->hw.njet.base + 1U)); outb(0, (int )((unsigned int )cs->hw.njet.base + 4U)); } else { } if ((unsigned int )cs->typ == 20U) { led = (unsigned int )((u_char )bc) & 1U; led = (u_char )(1 << ((int )led + 6)); led = ~ ((int )led); cs->hw.njet.auxd = (int )cs->hw.njet.auxd & (int )led; outb((int )cs->hw.njet.auxd, (int )cs->hw.njet.auxa); } else { } goto ldv_41113; case 1: ; goto ldv_41113; case 4: ; case 2: fill_mem(bcs, bcs->hw.tiger.send, 512U, bc, 255); bcs->hw.tiger.r_state = 0U; bcs->hw.tiger.r_tot = 0U; bcs->hw.tiger.r_bitcnt = 0U; bcs->hw.tiger.r_one = 0U; bcs->hw.tiger.r_err = 0U; bcs->hw.tiger.s_tot = 0U; if ((unsigned int )cs->hw.njet.dmactrl == 0U) { fill_mem(bcs, bcs->hw.tiger.send, 512U, bc == 0, 255); cs->hw.njet.dmactrl = 1U; outb((int )cs->hw.njet.dmactrl, (int )((unsigned int )cs->hw.njet.base + 1U)); outb(15, (int )((unsigned int )cs->hw.njet.base + 4U)); } else { } bcs->hw.tiger.sendp = bcs->hw.tiger.send; bcs->hw.tiger.free = 512; test_and_set_bit(6, (unsigned long volatile *)(& bcs->Flag)); if ((unsigned int )cs->typ == 20U) { led = (unsigned int )((u_char )bc) & 1U; led = (u_char )(1 << ((int )led + 6)); cs->hw.njet.auxd = (int )cs->hw.njet.auxd | (int )led; outb((int )cs->hw.njet.auxd, (int )cs->hw.njet.auxa); } else { } goto ldv_41113; } ldv_41113: ; if ((cs->debug & 16) != 0) { tmp = inb((int )((unsigned int )cs->hw.njet.base + 40U)); tmp___0 = inl((int )((unsigned int )cs->hw.njet.base + 36U)); tmp___1 = inl((int )((unsigned int )cs->hw.njet.base + 20U)); tmp___2 = inb((int )((unsigned int )cs->hw.njet.base + 6U)); tmp___3 = inb((int )((unsigned int )cs->hw.njet.base + 4U)); tmp___4 = inb((int )((unsigned int )cs->hw.njet.base + 1U)); debugl1(cs, (char *)"tiger: set %x %x %x %x/%x pulse=%d", (int )tmp___4, (int )tmp___3, (int )tmp___2, tmp___1, tmp___0, (int )tmp); } else { } return; } } static void printframe(struct IsdnCardState *cs , u_char *buf , int count , char *s ) { char tmp[128U] ; char *t ; int i ; int j ; u_char *p ; int tmp___0 ; int tmp___1 ; { t = (char *)(& tmp); i = count; p = buf; tmp___0 = sprintf(t, "tiger %s(%4d)", s, count); t = t + (unsigned long )tmp___0; goto ldv_41129; ldv_41128: ; if (i > 16) { j = 16; } else { j = i; } QuickHex(t, p, j); debugl1(cs, (char *)(& tmp)); p = p + (unsigned long )j; i = i - j; t = (char *)(& tmp); tmp___1 = sprintf(t, "tiger %s ", s); t = t + (unsigned long )tmp___1; ldv_41129: ; if (i > 0) { goto ldv_41128; } else { } return; } } static int make_raw_data(struct BCState *bcs ) { register u_int i ; register u_int s_cnt ; register u_char j ; register u_char val ; register u_char s_one ; register u_char s_val ; register u_char bitcnt ; u_int fcs ; u_int tmp ; u16 tmp___0 ; u_int tmp___1 ; u_int tmp___2 ; u_int tmp___3 ; u_int tmp___4 ; u_int tmp___5 ; u_int tmp___6 ; u_int tmp___7 ; u_char tmp___8 ; u_int tmp___9 ; u_int tmp___10 ; { s_cnt = 0U; s_one = 0U; s_val = 0U; bitcnt = 0U; if ((unsigned long )bcs->tx_skb == (unsigned long )((struct sk_buff *)0)) { debugl1(bcs->cs, (char *)"tiger make_raw: NULL skb"); return (1); } else { } tmp = s_cnt; s_cnt = s_cnt + 1U; *(bcs->hw.tiger.sendbuf + (unsigned long )tmp) = 126U; fcs = 65535U; i = 0U; goto ldv_41146; ldv_41145: val = *((bcs->tx_skb)->data + (unsigned long )i); tmp___0 = crc_ccitt_byte((int )((u16 )fcs), (int )val); fcs = (u_int )tmp___0; j = 0U; goto ldv_41143; ldv_41142: bitcnt = (u_char )((int )bitcnt + 1); s_val = (u_char )((int )s_val >> 1); if ((int )val & 1) { s_one = (u_char )((int )s_one + 1); s_val = (u_char )((unsigned int )s_val | 128U); } else { s_one = 0U; s_val = (unsigned int )s_val & 127U; } if ((unsigned int )bitcnt == 8U) { tmp___1 = s_cnt; s_cnt = s_cnt + 1U; *(bcs->hw.tiger.sendbuf + (unsigned long )tmp___1) = s_val; bitcnt = 0U; } else { } if ((unsigned int )s_one == 5U) { s_val = (u_char )((int )s_val >> 1); s_val = (unsigned int )s_val & 127U; bitcnt = (u_char )((int )bitcnt + 1); s_one = 0U; } else { } if ((unsigned int )bitcnt == 8U) { tmp___2 = s_cnt; s_cnt = s_cnt + 1U; *(bcs->hw.tiger.sendbuf + (unsigned long )tmp___2) = s_val; bitcnt = 0U; } else { } val = (u_char )((int )val >> 1); j = (u_char )((int )j + 1); ldv_41143: ; if ((unsigned int )j <= 7U) { goto ldv_41142; } else { } i = i + 1U; ldv_41146: ; if ((bcs->tx_skb)->len > i) { goto ldv_41145; } else { } fcs = fcs ^ 65535U; val = (u_char )fcs; j = 0U; goto ldv_41149; ldv_41148: bitcnt = (u_char )((int )bitcnt + 1); s_val = (u_char )((int )s_val >> 1); if ((int )val & 1) { s_one = (u_char )((int )s_one + 1); s_val = (u_char )((unsigned int )s_val | 128U); } else { s_one = 0U; s_val = (unsigned int )s_val & 127U; } if ((unsigned int )bitcnt == 8U) { tmp___3 = s_cnt; s_cnt = s_cnt + 1U; *(bcs->hw.tiger.sendbuf + (unsigned long )tmp___3) = s_val; bitcnt = 0U; } else { } if ((unsigned int )s_one == 5U) { s_val = (u_char )((int )s_val >> 1); s_val = (unsigned int )s_val & 127U; bitcnt = (u_char )((int )bitcnt + 1); s_one = 0U; } else { } if ((unsigned int )bitcnt == 8U) { tmp___4 = s_cnt; s_cnt = s_cnt + 1U; *(bcs->hw.tiger.sendbuf + (unsigned long )tmp___4) = s_val; bitcnt = 0U; } else { } val = (u_char )((int )val >> 1); j = (u_char )((int )j + 1); ldv_41149: ; if ((unsigned int )j <= 7U) { goto ldv_41148; } else { } val = (u_char )(fcs >> 8); j = 0U; goto ldv_41152; ldv_41151: bitcnt = (u_char )((int )bitcnt + 1); s_val = (u_char )((int )s_val >> 1); if ((int )val & 1) { s_one = (u_char )((int )s_one + 1); s_val = (u_char )((unsigned int )s_val | 128U); } else { s_one = 0U; s_val = (unsigned int )s_val & 127U; } if ((unsigned int )bitcnt == 8U) { tmp___5 = s_cnt; s_cnt = s_cnt + 1U; *(bcs->hw.tiger.sendbuf + (unsigned long )tmp___5) = s_val; bitcnt = 0U; } else { } if ((unsigned int )s_one == 5U) { s_val = (u_char )((int )s_val >> 1); s_val = (unsigned int )s_val & 127U; bitcnt = (u_char )((int )bitcnt + 1); s_one = 0U; } else { } if ((unsigned int )bitcnt == 8U) { tmp___6 = s_cnt; s_cnt = s_cnt + 1U; *(bcs->hw.tiger.sendbuf + (unsigned long )tmp___6) = s_val; bitcnt = 0U; } else { } val = (u_char )((int )val >> 1); j = (u_char )((int )j + 1); ldv_41152: ; if ((unsigned int )j <= 7U) { goto ldv_41151; } else { } val = 126U; j = 0U; goto ldv_41155; ldv_41154: bitcnt = (u_char )((int )bitcnt + 1); s_val = (u_char )((int )s_val >> 1); if ((int )val & 1) { s_val = (u_char )((unsigned int )s_val | 128U); } else { s_val = (unsigned int )s_val & 127U; } if ((unsigned int )bitcnt == 8U) { tmp___7 = s_cnt; s_cnt = s_cnt + 1U; *(bcs->hw.tiger.sendbuf + (unsigned long )tmp___7) = s_val; bitcnt = 0U; } else { } val = (u_char )((int )val >> 1); j = (u_char )((int )j + 1); ldv_41155: ; if ((unsigned int )j <= 7U) { goto ldv_41154; } else { } if (((bcs->cs)->debug & 16) != 0) { debugl1(bcs->cs, (char *)"tiger make_raw: in %u out %d.%d", (bcs->tx_skb)->len, s_cnt, (int )bitcnt); } else { } if ((unsigned int )bitcnt != 0U) { goto ldv_41158; ldv_41157: s_val = (u_char )((int )s_val >> 1); s_val = (u_char )((unsigned int )s_val | 128U); ldv_41158: tmp___8 = bitcnt; bitcnt = (u_char )((int )bitcnt + 1); if ((unsigned int )tmp___8 <= 7U) { goto ldv_41157; } else { } tmp___9 = s_cnt; s_cnt = s_cnt + 1U; *(bcs->hw.tiger.sendbuf + (unsigned long )tmp___9) = s_val; tmp___10 = s_cnt; s_cnt = s_cnt + 1U; *(bcs->hw.tiger.sendbuf + (unsigned long )tmp___10) = 255U; } else { } bcs->hw.tiger.sendcnt = (int )s_cnt; bcs->tx_cnt = (int )((unsigned int )bcs->tx_cnt - (bcs->tx_skb)->len); bcs->hw.tiger.sp = bcs->hw.tiger.sendbuf; return (0); } } static int make_raw_data_56k(struct BCState *bcs ) { register u_int i ; register u_int s_cnt ; register u_char j ; register u_char val ; register u_char s_one ; register u_char s_val ; register u_char bitcnt ; u_int fcs ; u_int tmp ; u16 tmp___0 ; u_int tmp___1 ; u_int tmp___2 ; u_int tmp___3 ; u_int tmp___4 ; u_int tmp___5 ; u_int tmp___6 ; u_int tmp___7 ; u_char tmp___8 ; u_int tmp___9 ; u_int tmp___10 ; { s_cnt = 0U; s_one = 0U; s_val = 0U; bitcnt = 0U; if ((unsigned long )bcs->tx_skb == (unsigned long )((struct sk_buff *)0)) { debugl1(bcs->cs, (char *)"tiger make_raw_56k: NULL skb"); return (1); } else { } val = 126U; j = 0U; goto ldv_41172; ldv_41171: bitcnt = (u_char )((int )bitcnt + 1); s_val = (u_char )((int )s_val >> 1); if ((int )val & 1) { s_val = (u_char )((unsigned int )s_val | 128U); } else { s_val = (unsigned int )s_val & 127U; } if ((unsigned int )bitcnt == 7U) { s_val = (u_char )((int )s_val >> 1); s_val = (u_char )((unsigned int )s_val | 128U); tmp = s_cnt; s_cnt = s_cnt + 1U; *(bcs->hw.tiger.sendbuf + (unsigned long )tmp) = s_val; bitcnt = 0U; } else { } val = (u_char )((int )val >> 1); j = (u_char )((int )j + 1); ldv_41172: ; if ((unsigned int )j <= 7U) { goto ldv_41171; } else { } fcs = 65535U; i = 0U; goto ldv_41178; ldv_41177: val = *((bcs->tx_skb)->data + (unsigned long )i); tmp___0 = crc_ccitt_byte((int )((u16 )fcs), (int )val); fcs = (u_int )tmp___0; j = 0U; goto ldv_41175; ldv_41174: bitcnt = (u_char )((int )bitcnt + 1); s_val = (u_char )((int )s_val >> 1); if ((int )val & 1) { s_one = (u_char )((int )s_one + 1); s_val = (u_char )((unsigned int )s_val | 128U); } else { s_one = 0U; s_val = (unsigned int )s_val & 127U; } if ((unsigned int )bitcnt == 7U) { s_val = (u_char )((int )s_val >> 1); s_val = (u_char )((unsigned int )s_val | 128U); tmp___1 = s_cnt; s_cnt = s_cnt + 1U; *(bcs->hw.tiger.sendbuf + (unsigned long )tmp___1) = s_val; bitcnt = 0U; } else { } if ((unsigned int )s_one == 5U) { s_val = (u_char )((int )s_val >> 1); s_val = (unsigned int )s_val & 127U; bitcnt = (u_char )((int )bitcnt + 1); s_one = 0U; } else { } if ((unsigned int )bitcnt == 7U) { s_val = (u_char )((int )s_val >> 1); s_val = (u_char )((unsigned int )s_val | 128U); tmp___2 = s_cnt; s_cnt = s_cnt + 1U; *(bcs->hw.tiger.sendbuf + (unsigned long )tmp___2) = s_val; bitcnt = 0U; } else { } val = (u_char )((int )val >> 1); j = (u_char )((int )j + 1); ldv_41175: ; if ((unsigned int )j <= 7U) { goto ldv_41174; } else { } i = i + 1U; ldv_41178: ; if ((bcs->tx_skb)->len > i) { goto ldv_41177; } else { } fcs = fcs ^ 65535U; val = (u_char )fcs; j = 0U; goto ldv_41181; ldv_41180: bitcnt = (u_char )((int )bitcnt + 1); s_val = (u_char )((int )s_val >> 1); if ((int )val & 1) { s_one = (u_char )((int )s_one + 1); s_val = (u_char )((unsigned int )s_val | 128U); } else { s_one = 0U; s_val = (unsigned int )s_val & 127U; } if ((unsigned int )bitcnt == 7U) { s_val = (u_char )((int )s_val >> 1); s_val = (u_char )((unsigned int )s_val | 128U); tmp___3 = s_cnt; s_cnt = s_cnt + 1U; *(bcs->hw.tiger.sendbuf + (unsigned long )tmp___3) = s_val; bitcnt = 0U; } else { } if ((unsigned int )s_one == 5U) { s_val = (u_char )((int )s_val >> 1); s_val = (unsigned int )s_val & 127U; bitcnt = (u_char )((int )bitcnt + 1); s_one = 0U; } else { } if ((unsigned int )bitcnt == 7U) { s_val = (u_char )((int )s_val >> 1); s_val = (u_char )((unsigned int )s_val | 128U); tmp___4 = s_cnt; s_cnt = s_cnt + 1U; *(bcs->hw.tiger.sendbuf + (unsigned long )tmp___4) = s_val; bitcnt = 0U; } else { } val = (u_char )((int )val >> 1); j = (u_char )((int )j + 1); ldv_41181: ; if ((unsigned int )j <= 7U) { goto ldv_41180; } else { } val = (u_char )(fcs >> 8); j = 0U; goto ldv_41184; ldv_41183: bitcnt = (u_char )((int )bitcnt + 1); s_val = (u_char )((int )s_val >> 1); if ((int )val & 1) { s_one = (u_char )((int )s_one + 1); s_val = (u_char )((unsigned int )s_val | 128U); } else { s_one = 0U; s_val = (unsigned int )s_val & 127U; } if ((unsigned int )bitcnt == 7U) { s_val = (u_char )((int )s_val >> 1); s_val = (u_char )((unsigned int )s_val | 128U); tmp___5 = s_cnt; s_cnt = s_cnt + 1U; *(bcs->hw.tiger.sendbuf + (unsigned long )tmp___5) = s_val; bitcnt = 0U; } else { } if ((unsigned int )s_one == 5U) { s_val = (u_char )((int )s_val >> 1); s_val = (unsigned int )s_val & 127U; bitcnt = (u_char )((int )bitcnt + 1); s_one = 0U; } else { } if ((unsigned int )bitcnt == 7U) { s_val = (u_char )((int )s_val >> 1); s_val = (u_char )((unsigned int )s_val | 128U); tmp___6 = s_cnt; s_cnt = s_cnt + 1U; *(bcs->hw.tiger.sendbuf + (unsigned long )tmp___6) = s_val; bitcnt = 0U; } else { } val = (u_char )((int )val >> 1); j = (u_char )((int )j + 1); ldv_41184: ; if ((unsigned int )j <= 7U) { goto ldv_41183; } else { } val = 126U; j = 0U; goto ldv_41187; ldv_41186: bitcnt = (u_char )((int )bitcnt + 1); s_val = (u_char )((int )s_val >> 1); if ((int )val & 1) { s_val = (u_char )((unsigned int )s_val | 128U); } else { s_val = (unsigned int )s_val & 127U; } if ((unsigned int )bitcnt == 7U) { s_val = (u_char )((int )s_val >> 1); s_val = (u_char )((unsigned int )s_val | 128U); tmp___7 = s_cnt; s_cnt = s_cnt + 1U; *(bcs->hw.tiger.sendbuf + (unsigned long )tmp___7) = s_val; bitcnt = 0U; } else { } val = (u_char )((int )val >> 1); j = (u_char )((int )j + 1); ldv_41187: ; if ((unsigned int )j <= 7U) { goto ldv_41186; } else { } if (((bcs->cs)->debug & 16) != 0) { debugl1(bcs->cs, (char *)"tiger make_raw_56k: in %u out %d.%d", (bcs->tx_skb)->len, s_cnt, (int )bitcnt); } else { } if ((unsigned int )bitcnt != 0U) { goto ldv_41190; ldv_41189: s_val = (u_char )((int )s_val >> 1); s_val = (u_char )((unsigned int )s_val | 128U); ldv_41190: tmp___8 = bitcnt; bitcnt = (u_char )((int )bitcnt + 1); if ((unsigned int )tmp___8 <= 7U) { goto ldv_41189; } else { } tmp___9 = s_cnt; s_cnt = s_cnt + 1U; *(bcs->hw.tiger.sendbuf + (unsigned long )tmp___9) = s_val; tmp___10 = s_cnt; s_cnt = s_cnt + 1U; *(bcs->hw.tiger.sendbuf + (unsigned long )tmp___10) = 255U; } else { } bcs->hw.tiger.sendcnt = (int )s_cnt; bcs->tx_cnt = (int )((unsigned int )bcs->tx_cnt - (bcs->tx_skb)->len); bcs->hw.tiger.sp = bcs->hw.tiger.sendbuf; return (0); } } static void got_frame(struct BCState *bcs , int count ) { struct sk_buff *skb ; size_t __len ; void *__ret ; unsigned char *tmp___0 ; { skb = dev_alloc_skb((unsigned int )count); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { printk("\fTIGER: receive out of memory\n"); } else { __len = (size_t )count; tmp___0 = skb_put(skb, (unsigned int )count); __ret = memcpy((void *)tmp___0, (void const *)bcs->hw.tiger.rcvbuf, __len); skb_queue_tail(& bcs->rqueue, skb); } test_and_set_bit(0, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); if (((bcs->cs)->debug & 256) != 0) { printframe(bcs->cs, bcs->hw.tiger.rcvbuf, count, (char *)"rec"); } else { } return; } } static void read_raw(struct BCState *bcs , u_int *buf , int cnt ) { int i ; register u_char j ; register u_char val ; u_int *pend ; register u_char state ; register u_char r_one ; register u_char r_val ; register u_int bitcnt ; u_int *p ; int bits ; u_char mask ; u16 tmp ; u16 tmp___0 ; { pend = bcs->hw.tiger.rec + 127U; state = bcs->hw.tiger.r_state; r_one = bcs->hw.tiger.r_one; r_val = bcs->hw.tiger.r_val; bitcnt = bcs->hw.tiger.r_bitcnt; p = buf; if (bcs->mode == 2) { mask = 255U; bits = 8; } else { mask = 127U; bits = 7; } i = 0; goto ldv_41222; ldv_41221: val = bcs->channel != 0 ? (u_char )(*p >> 8) : (u_char )*p; p = p + 1; if ((unsigned long )p > (unsigned long )pend) { p = bcs->hw.tiger.rec; } else { } if (((int )val & (int )mask) == (int )mask) { state = 0U; bcs->hw.tiger.r_tot = bcs->hw.tiger.r_tot + 1U; bitcnt = 0U; r_one = 0U; goto ldv_41216; } else { } j = 0U; goto ldv_41219; ldv_41218: ; if ((unsigned int )state == 0U) { if ((int )val & 1) { r_one = (u_char )((int )r_one + 1); } else { r_one = 0U; state = 1U; if (((bcs->cs)->debug & 16) != 0) { debugl1(bcs->cs, (char *)"tiger read_raw: zBit(%d,%d,%d) %x", bcs->hw.tiger.r_tot, i, (int )j, (int )val); } else { } } } else if ((unsigned int )state == 1U) { if ((int )val & 1) { r_one = (u_char )((int )r_one + 1); if ((unsigned int )r_one > 6U) { state = 0U; } else { } } else { if ((unsigned int )r_one == 6U) { bitcnt = 0U; r_val = 0U; state = 2U; if (((bcs->cs)->debug & 16) != 0) { debugl1(bcs->cs, (char *)"tiger read_raw: flag(%d,%d,%d) %x", bcs->hw.tiger.r_tot, i, (int )j, (int )val); } else { } } else { } r_one = 0U; } } else if ((unsigned int )state == 2U) { if ((int )val & 1) { r_one = (u_char )((int )r_one + 1); if ((unsigned int )r_one > 6U) { state = 0U; } else { r_val = (u_char )((int )r_val >> 1); r_val = (u_char )((unsigned int )r_val | 128U); bitcnt = bitcnt + 1U; } } else { if ((unsigned int )r_one == 6U) { bitcnt = 0U; r_val = 0U; r_one = 0U; val = (u_char )((int )val >> 1); goto ldv_41217; } else if ((unsigned int )r_one != 5U) { r_val = (u_char )((int )r_val >> 1); r_val = (unsigned int )r_val & 127U; bitcnt = bitcnt + 1U; } else { } r_one = 0U; } if ((unsigned int )state != 0U && (bitcnt & 7U) == 0U) { state = 3U; bcs->hw.tiger.r_fcs = 65535U; *(bcs->hw.tiger.rcvbuf) = r_val; tmp = crc_ccitt_byte((int )((u16 )bcs->hw.tiger.r_fcs), (int )r_val); bcs->hw.tiger.r_fcs = (u_int )tmp; if (((bcs->cs)->debug & 16) != 0) { debugl1(bcs->cs, (char *)"tiger read_raw: byte1(%d,%d,%d) rval %x val %x i %x", bcs->hw.tiger.r_tot, i, (int )j, (int )r_val, (int )val, (int )(bcs->cs)->hw.njet.irqstat0); } else { } } else { } } else if ((unsigned int )state == 3U) { if ((int )val & 1) { r_one = (u_char )((int )r_one + 1); if ((unsigned int )r_one > 6U) { state = 0U; bitcnt = 0U; } else { r_val = (u_char )((int )r_val >> 1); r_val = (u_char )((unsigned int )r_val | 128U); bitcnt = bitcnt + 1U; } } else { if ((unsigned int )r_one == 6U) { r_val = 0U; r_one = 0U; bitcnt = bitcnt + 1U; if ((bitcnt & 7U) != 0U) { debugl1(bcs->cs, (char *)"tiger: frame not byte aligned"); state = 1U; bcs->hw.tiger.r_err = bcs->hw.tiger.r_err + 1U; bcs->err_inv = bcs->err_inv + 1; } else { if (((bcs->cs)->debug & 16) != 0) { debugl1(bcs->cs, (char *)"tiger frame end(%d,%d): fcs(%x) i %x", i, (int )j, bcs->hw.tiger.r_fcs, (int )(bcs->cs)->hw.njet.irqstat0); } else { } if (bcs->hw.tiger.r_fcs == 61624U) { got_frame(bcs, (int )((bitcnt >> 3) - 3U)); } else { if ((bcs->cs)->debug != 0) { debugl1(bcs->cs, (char *)"tiger FCS error"); printframe(bcs->cs, bcs->hw.tiger.rcvbuf, (int )((bitcnt >> 3) - 1U), (char *)"rec"); bcs->hw.tiger.r_err = bcs->hw.tiger.r_err + 1U; } else { } bcs->err_crc = bcs->err_crc + 1; } state = 2U; } bitcnt = 0U; } else if ((unsigned int )r_one == 5U) { val = (u_char )((int )val >> 1); r_one = 0U; goto ldv_41217; } else { r_val = (u_char )((int )r_val >> 1); r_val = (unsigned int )r_val & 127U; bitcnt = bitcnt + 1U; } r_one = 0U; } if ((unsigned int )state == 3U && (bitcnt & 7U) == 0U) { if (bitcnt >> 3 > 4095U) { debugl1(bcs->cs, (char *)"tiger: frame too big"); r_val = 0U; state = 1U; bcs->hw.tiger.r_err = bcs->hw.tiger.r_err + 1U; bcs->err_inv = bcs->err_inv + 1; } else { *(bcs->hw.tiger.rcvbuf + (unsigned long )((bitcnt >> 3) - 1U)) = r_val; tmp___0 = crc_ccitt_byte((int )((u16 )bcs->hw.tiger.r_fcs), (int )r_val); bcs->hw.tiger.r_fcs = (u_int )tmp___0; } } else { } } else { } val = (u_char )((int )val >> 1); ldv_41217: j = (u_char )((int )j + 1); ldv_41219: ; if ((int )j < bits) { goto ldv_41218; } else { } bcs->hw.tiger.r_tot = bcs->hw.tiger.r_tot + 1U; ldv_41216: i = i + 1; ldv_41222: ; if (i < cnt) { goto ldv_41221; } else { } bcs->hw.tiger.r_state = state; bcs->hw.tiger.r_one = r_one; bcs->hw.tiger.r_val = r_val; bcs->hw.tiger.r_bitcnt = bitcnt; return; } } void read_tiger(struct IsdnCardState *cs ) { u_int *p ; int cnt ; { cnt = 64; if ((((int )cs->hw.njet.irqstat0 & (int )cs->hw.njet.last_is0) & 12) != 0) { debugl1(cs, (char *)"tiger warn read double dma %x/%x", (int )cs->hw.njet.irqstat0, (int )cs->hw.njet.last_is0); if (cs->bcs[0].mode != 0) { cs->bcs[0].err_rdo = cs->bcs[0].err_rdo + 1; } else { } if (cs->bcs[1].mode != 0) { cs->bcs[1].err_rdo = cs->bcs[1].err_rdo + 1; } else { } return; } else { cs->hw.njet.last_is0 = (unsigned int )cs->hw.njet.last_is0 & 243U; cs->hw.njet.last_is0 = (unsigned char )((int )((signed char )cs->hw.njet.last_is0) | ((int )((signed char )cs->hw.njet.irqstat0) & 12)); } if (((int )cs->hw.njet.irqstat0 & 4) != 0) { p = cs->bcs[0].hw.tiger.rec + 127U; } else { p = cs->bcs[0].hw.tiger.rec + ((unsigned long )cnt + 0xffffffffffffffffUL); } if (cs->bcs[0].mode == 2 || cs->bcs[0].mode == 4) { read_raw((struct BCState *)(& cs->bcs), p, cnt); } else { } if (cs->bcs[1].mode == 2 || cs->bcs[1].mode == 4) { read_raw((struct BCState *)(& cs->bcs) + 1UL, p, cnt); } else { } cs->hw.njet.irqstat0 = (unsigned int )cs->hw.njet.irqstat0 & 243U; return; } } static void write_raw(struct BCState *bcs , u_int *buf , int cnt ) ; void netjet_fill_dma(struct BCState *bcs ) { register u_int *p ; register u_int *sp ; register int cnt ; int tmp ; int tmp___0 ; int tmp___1 ; unsigned int tmp___2 ; void *tmp___3 ; unsigned int tmp___4 ; void *tmp___5 ; int tmp___6 ; int tmp___7 ; int tmp___8 ; { if ((unsigned long )bcs->tx_skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } if (((bcs->cs)->debug & 16) != 0) { debugl1(bcs->cs, (char *)"tiger fill_dma1: c%d %4lx", bcs->channel, bcs->Flag); } else { } tmp = test_and_set_bit(3, (unsigned long volatile *)(& bcs->Flag)); if (tmp != 0) { return; } else { } if (bcs->mode == 2) { tmp___1 = make_raw_data(bcs); if (tmp___1 != 0) { return; } else { tmp___0 = make_raw_data_56k(bcs); if (tmp___0 != 0) { return; } else { } } } else { } if (((bcs->cs)->debug & 16) != 0) { debugl1(bcs->cs, (char *)"tiger fill_dma2: c%d %4lx", bcs->channel, bcs->Flag); } else { } tmp___8 = test_and_clear_bit(4, (unsigned long volatile *)(& bcs->Flag)); if (tmp___8 != 0) { write_raw(bcs, bcs->hw.tiger.sendp, bcs->hw.tiger.free); } else { tmp___7 = test_and_clear_bit(5, (unsigned long volatile *)(& bcs->Flag)); if (tmp___7 != 0) { tmp___2 = inl((int )((unsigned int )(bcs->cs)->hw.njet.base + 20U)); tmp___3 = phys_to_virt((phys_addr_t )tmp___2); p = (u_int *)tmp___3; sp = bcs->hw.tiger.sendp; if ((unsigned long )bcs->hw.tiger.s_end == (unsigned long )p) { p = bcs->hw.tiger.send + 0xffffffffffffffffUL; } else { } if ((unsigned long )bcs->hw.tiger.s_end == (unsigned long )sp) { sp = bcs->hw.tiger.send + 0xffffffffffffffffUL; } else { } cnt = (int )(((long )p - (long )sp) / 4L); if (cnt < 0) { write_raw(bcs, bcs->hw.tiger.sendp, bcs->hw.tiger.free); } else { p = p + 1; cnt = cnt + 1; if ((unsigned long )bcs->hw.tiger.s_end < (unsigned long )p) { p = bcs->hw.tiger.send; } else { } p = p + 1; cnt = cnt + 1; if ((unsigned long )bcs->hw.tiger.s_end < (unsigned long )p) { p = bcs->hw.tiger.send; } else { } write_raw(bcs, p, bcs->hw.tiger.free - cnt); } } else { tmp___6 = test_and_clear_bit(6, (unsigned long volatile *)(& bcs->Flag)); if (tmp___6 != 0) { tmp___4 = inl((int )((unsigned int )(bcs->cs)->hw.njet.base + 20U)); tmp___5 = phys_to_virt((phys_addr_t )tmp___4); p = (u_int *)tmp___5; cnt = (int )(((long )bcs->hw.tiger.s_end - (long )p) / 4L); if (cnt <= 1) { p = bcs->hw.tiger.send + 1UL; cnt = 254; } else { p = p + 1; p = p + 1; if (cnt <= 256) { cnt = cnt + 256; } else { } cnt = cnt - 1; cnt = cnt - 1; } write_raw(bcs, p, cnt); } else { } } } if (((bcs->cs)->debug & 16) != 0) { debugl1(bcs->cs, (char *)"tiger fill_dma3: c%d %4lx", bcs->channel, bcs->Flag); } else { } return; } } static void write_raw(struct BCState *bcs , u_int *buf , int cnt ) { u_int mask ; u_int val ; u_int *p ; u_int i ; u_int s_cnt ; u_int *tmp ; u_long flags ; raw_spinlock_t *tmp___0 ; int tmp___1 ; u_int *tmp___2 ; struct sk_buff *tmp___3 ; int tmp___4 ; int tmp___5 ; int tmp___6 ; { p = buf; if (cnt <= 0) { return; } else { } tmp___6 = constant_test_bit(3U, (unsigned long const volatile *)(& bcs->Flag)); if (tmp___6 != 0) { if (bcs->hw.tiger.sendcnt > cnt) { s_cnt = (u_int )cnt; bcs->hw.tiger.sendcnt = bcs->hw.tiger.sendcnt - cnt; } else { s_cnt = (u_int )bcs->hw.tiger.sendcnt; bcs->hw.tiger.sendcnt = 0; } if (bcs->channel != 0) { mask = 4294902015U; } else { mask = 4294967040U; } i = 0U; goto ldv_41250; ldv_41249: val = bcs->channel != 0 ? (u_int )((int )*(bcs->hw.tiger.sp + (unsigned long )i) << 8) & 65535U : (u_int )*(bcs->hw.tiger.sp + (unsigned long )i); *p = *p & mask; tmp = p; p = p + 1; *tmp = *tmp | val; if ((unsigned long )bcs->hw.tiger.s_end < (unsigned long )p) { p = bcs->hw.tiger.send; } else { } i = i + 1U; ldv_41250: ; if (i < s_cnt) { goto ldv_41249; } else { } bcs->hw.tiger.s_tot = bcs->hw.tiger.s_tot + s_cnt; if (((bcs->cs)->debug & 16) != 0) { debugl1(bcs->cs, (char *)"tiger write_raw: c%d %p-%p %d/%d %d %x", bcs->channel, buf, p, s_cnt, cnt, bcs->hw.tiger.sendcnt, (int )(bcs->cs)->hw.njet.irqstat0); } else { } if (((bcs->cs)->debug & 32) != 0) { printframe(bcs->cs, bcs->hw.tiger.sp, (int )s_cnt, (char *)"snd"); } else { } bcs->hw.tiger.sp = bcs->hw.tiger.sp + (unsigned long )s_cnt; bcs->hw.tiger.sendp = p; if (bcs->hw.tiger.sendcnt == 0) { if ((unsigned long )bcs->tx_skb == (unsigned long )((struct sk_buff *)0)) { debugl1(bcs->cs, (char *)"tiger write_raw: NULL skb s_cnt %d", s_cnt); } else { tmp___1 = constant_test_bit(1U, (unsigned long const volatile *)(& (bcs->st)->lli.flag)); if (tmp___1 != 0 && (unsigned int )*((unsigned char *)bcs->tx_skb + 125UL) != 7U) { tmp___0 = spinlock_check(& bcs->aclock); flags = _raw_spin_lock_irqsave(tmp___0); bcs->ackcnt = (int )((unsigned int )bcs->ackcnt + (bcs->tx_skb)->len); spin_unlock_irqrestore(& bcs->aclock, flags); test_and_set_bit(2, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } dev_kfree_skb_any(bcs->tx_skb); bcs->tx_skb = 0; } test_and_clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); bcs->hw.tiger.free = (int )((u_int )cnt - s_cnt); if (bcs->hw.tiger.free > 256) { test_and_set_bit(5, (unsigned long volatile *)(& bcs->Flag)); } else { test_and_clear_bit(5, (unsigned long volatile *)(& bcs->Flag)); test_and_set_bit(4, (unsigned long volatile *)(& bcs->Flag)); } tmp___3 = skb_dequeue(& bcs->squeue); bcs->tx_skb = tmp___3; if ((unsigned long )tmp___3 != (unsigned long )((struct sk_buff *)0)) { netjet_fill_dma(bcs); } else { mask = ~ mask; if ((u_int )cnt > s_cnt) { i = s_cnt; goto ldv_41257; ldv_41256: tmp___2 = p; p = p + 1; *tmp___2 = *tmp___2 | mask; if ((unsigned long )bcs->hw.tiger.s_end < (unsigned long )p) { p = bcs->hw.tiger.send; } else { } i = i + 1U; ldv_41257: ; if ((u_int )cnt > i) { goto ldv_41256; } else { } if (((bcs->cs)->debug & 16) != 0) { debugl1(bcs->cs, (char *)"tiger write_raw: fill rest %d", (u_int )cnt - s_cnt); } else { } } else { } test_and_set_bit(1, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } } else { } } else { tmp___5 = test_and_clear_bit(4, (unsigned long volatile *)(& bcs->Flag)); if (tmp___5 != 0) { test_and_set_bit(5, (unsigned long volatile *)(& bcs->Flag)); fill_mem(bcs, buf, (u_int )cnt, bcs->channel, 255); bcs->hw.tiger.free = bcs->hw.tiger.free + cnt; if (((bcs->cs)->debug & 16) != 0) { debugl1(bcs->cs, (char *)"tiger write_raw: fill half"); } else { } } else { tmp___4 = test_and_clear_bit(5, (unsigned long volatile *)(& bcs->Flag)); if (tmp___4 != 0) { test_and_set_bit(6, (unsigned long volatile *)(& bcs->Flag)); fill_mem(bcs, buf, (u_int )cnt, bcs->channel, 255); if (((bcs->cs)->debug & 16) != 0) { debugl1(bcs->cs, (char *)"tiger write_raw: fill full"); } else { } } else { } } } return; } } void write_tiger(struct IsdnCardState *cs ) { u_int *p ; u_int cnt ; { cnt = 256U; if ((((int )cs->hw.njet.irqstat0 & (int )cs->hw.njet.last_is0) & 3) != 0) { debugl1(cs, (char *)"tiger warn write double dma %x/%x", (int )cs->hw.njet.irqstat0, (int )cs->hw.njet.last_is0); if (cs->bcs[0].mode != 0) { cs->bcs[0].err_tx = cs->bcs[0].err_tx + 1; } else { } if (cs->bcs[1].mode != 0) { cs->bcs[1].err_tx = cs->bcs[1].err_tx + 1; } else { } return; } else { cs->hw.njet.last_is0 = (unsigned int )cs->hw.njet.last_is0 & 252U; cs->hw.njet.last_is0 = (unsigned char )((int )((signed char )cs->hw.njet.last_is0) | ((int )((signed char )cs->hw.njet.irqstat0) & 3)); } if ((int )cs->hw.njet.irqstat0 & 1) { p = cs->bcs[0].hw.tiger.send + 511U; } else { p = cs->bcs[0].hw.tiger.send + ((unsigned long )cnt + 0xffffffffffffffffUL); } if (cs->bcs[0].mode == 2 || cs->bcs[0].mode == 4) { write_raw((struct BCState *)(& cs->bcs), p, (int )cnt); } else { } if (cs->bcs[1].mode == 2 || cs->bcs[1].mode == 4) { write_raw((struct BCState *)(& cs->bcs) + 1UL, p, (int )cnt); } else { } cs->hw.njet.irqstat0 = (unsigned int )cs->hw.njet.irqstat0 & 252U; return; } } static void tiger_l2l1(struct PStack *st , int pr , void *arg ) { struct BCState *bcs ; struct sk_buff *skb ; u_long flags ; raw_spinlock_t *tmp ; raw_spinlock_t *tmp___0 ; raw_spinlock_t *tmp___1 ; raw_spinlock_t *tmp___2 ; { bcs = st->l1.bcs; skb = (struct sk_buff *)arg; switch (pr) { case 288: tmp = spinlock_check(& (bcs->cs)->lock); flags = _raw_spin_lock_irqsave(tmp); if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { skb_queue_tail(& bcs->squeue, skb); } else { bcs->tx_skb = skb; (*((bcs->cs)->BC_Send_Data))(bcs); } spin_unlock_irqrestore(& (bcs->cs)->lock, flags); goto ldv_41276; case 306: tmp___0 = spinlock_check(& (bcs->cs)->lock); flags = _raw_spin_lock_irqsave(tmp___0); if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { printk("\ftiger_l2l1: this shouldn\'t happen\n"); } else { bcs->tx_skb = skb; (*((bcs->cs)->BC_Send_Data))(bcs); } spin_unlock_irqrestore(& (bcs->cs)->lock, flags); goto ldv_41276; case 304: ; if ((unsigned long )bcs->tx_skb == (unsigned long )((struct sk_buff *)0)) { test_and_clear_bit(6, (unsigned long volatile *)(& st->l1.Flags)); (*(st->l1.l1l2))(st, 305, 0); } else { test_and_set_bit(6, (unsigned long volatile *)(& st->l1.Flags)); } goto ldv_41276; case 256: tmp___1 = spinlock_check(& (bcs->cs)->lock); flags = _raw_spin_lock_irqsave(tmp___1); test_and_set_bit(2, (unsigned long volatile *)(& bcs->Flag)); mode_tiger(bcs, st->l1.mode, st->l1.bc); spin_unlock_irqrestore(& (bcs->cs)->lock, flags); (*((bcs->cs)->cardmsg))(bcs->cs, 636, (void *)(& st->l1.bc)); l1_msg_b(st, pr, arg); goto ldv_41276; case 272: (*((bcs->cs)->cardmsg))(bcs->cs, 632, (void *)(& st->l1.bc)); l1_msg_b(st, pr, arg); goto ldv_41276; case 273: tmp___2 = spinlock_check(& (bcs->cs)->lock); flags = _raw_spin_lock_irqsave(tmp___2); test_and_clear_bit(2, (unsigned long volatile *)(& bcs->Flag)); test_and_clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); mode_tiger(bcs, 0, st->l1.bc); spin_unlock_irqrestore(& (bcs->cs)->lock, flags); (*(st->l1.l1l2))(st, 273, 0); goto ldv_41276; } ldv_41276: ; return; } } static void close_tigerstate(struct BCState *bcs ) { int tmp ; { mode_tiger(bcs, 0, bcs->channel); tmp = test_and_clear_bit(1, (unsigned long volatile *)(& bcs->Flag)); if (tmp != 0) { kfree((void const *)bcs->hw.tiger.rcvbuf); bcs->hw.tiger.rcvbuf = 0; kfree((void const *)bcs->hw.tiger.sendbuf); bcs->hw.tiger.sendbuf = 0; skb_queue_purge(& bcs->rqueue); skb_queue_purge(& bcs->squeue); if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { dev_kfree_skb_any(bcs->tx_skb); bcs->tx_skb = 0; test_and_clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); } else { } } else { } return; } } static int open_tigerstate(struct IsdnCardState *cs , struct BCState *bcs ) { u_char *tmp ; void *tmp___0 ; u_char *tmp___1 ; void *tmp___2 ; int tmp___3 ; { tmp___3 = test_and_set_bit(1, (unsigned long volatile *)(& bcs->Flag)); if (tmp___3 == 0) { tmp___0 = kmalloc(4096UL, 32U); tmp = (u_char *)tmp___0; bcs->hw.tiger.rcvbuf = tmp; if ((unsigned long )tmp == (unsigned long )((u_char *)0)) { printk("\fHiSax: No memory for tiger.rcvbuf\n"); return (1); } else { } tmp___2 = kmalloc(4920UL, 32U); tmp___1 = (u_char *)tmp___2; bcs->hw.tiger.sendbuf = tmp___1; if ((unsigned long )tmp___1 == (unsigned long )((u_char *)0)) { printk("\fHiSax: No memory for tiger.sendbuf\n"); return (1); } else { } skb_queue_head_init(& bcs->rqueue); skb_queue_head_init(& bcs->squeue); } else { } bcs->tx_skb = 0; bcs->hw.tiger.sendcnt = 0; test_and_clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); bcs->event = 0UL; bcs->tx_cnt = 0; return (0); } } static int setstack_tiger(struct PStack *st , struct BCState *bcs ) { int tmp ; { bcs->channel = st->l1.bc; tmp = open_tigerstate((struct IsdnCardState *)st->l1.hardware, bcs); if (tmp != 0) { return (-1); } else { } st->l1.bcs = bcs; st->l2.l2l1 = & tiger_l2l1; setstack_manager(st); bcs->st = st; setstack_l1_B(st); return (0); } } void inittiger(struct IsdnCardState *cs ) { u_int *tmp ; void *tmp___0 ; phys_addr_t tmp___1 ; phys_addr_t tmp___2 ; phys_addr_t tmp___3 ; u_int *tmp___4 ; void *tmp___5 ; phys_addr_t tmp___6 ; phys_addr_t tmp___7 ; phys_addr_t tmp___8 ; unsigned char tmp___9 ; unsigned int tmp___10 ; unsigned int tmp___11 ; { tmp___0 = kmalloc(2048UL, 209U); tmp = (u_int *)tmp___0; cs->bcs[0].hw.tiger.send = tmp; if ((unsigned long )tmp == (unsigned long )((u_int *)0)) { printk("\fHiSax: No memory for tiger.send\n"); return; } else { } cs->bcs[0].hw.tiger.s_irq = cs->bcs[0].hw.tiger.send + 255U; cs->bcs[0].hw.tiger.s_end = cs->bcs[0].hw.tiger.send + 511U; cs->bcs[1].hw.tiger.send = cs->bcs[0].hw.tiger.send; cs->bcs[1].hw.tiger.s_irq = cs->bcs[0].hw.tiger.s_irq; cs->bcs[1].hw.tiger.s_end = cs->bcs[0].hw.tiger.s_end; memset((void *)cs->bcs[0].hw.tiger.send, 255, 2048UL); debugl1(cs, (char *)"tiger: send buf %p - %p", cs->bcs[0].hw.tiger.send, cs->bcs[0].hw.tiger.send + 511U); tmp___1 = virt_to_phys((void volatile *)cs->bcs[0].hw.tiger.send); outl((unsigned int )tmp___1, (int )((unsigned int )cs->hw.njet.base + 8U)); tmp___2 = virt_to_phys((void volatile *)cs->bcs[0].hw.tiger.s_irq); outl((unsigned int )tmp___2, (int )((unsigned int )cs->hw.njet.base + 12U)); tmp___3 = virt_to_phys((void volatile *)cs->bcs[0].hw.tiger.s_end); outl((unsigned int )tmp___3, (int )((unsigned int )cs->hw.njet.base + 16U)); tmp___5 = kmalloc(512UL, 209U); tmp___4 = (u_int *)tmp___5; cs->bcs[0].hw.tiger.rec = tmp___4; if ((unsigned long )tmp___4 == (unsigned long )((u_int *)0)) { printk("\fHiSax: No memory for tiger.rec\n"); return; } else { } debugl1(cs, (char *)"tiger: rec buf %p - %p", cs->bcs[0].hw.tiger.rec, cs->bcs[0].hw.tiger.rec + 127U); cs->bcs[1].hw.tiger.rec = cs->bcs[0].hw.tiger.rec; memset((void *)cs->bcs[0].hw.tiger.rec, 255, 512UL); tmp___6 = virt_to_phys((void volatile *)cs->bcs[0].hw.tiger.rec); outl((unsigned int )tmp___6, (int )((unsigned int )cs->hw.njet.base + 24U)); tmp___7 = virt_to_phys((void volatile *)cs->bcs[0].hw.tiger.rec + 63U); outl((unsigned int )tmp___7, (int )((unsigned int )cs->hw.njet.base + 28U)); tmp___8 = virt_to_phys((void volatile *)cs->bcs[0].hw.tiger.rec + 127U); outl((unsigned int )tmp___8, (int )((unsigned int )cs->hw.njet.base + 32U)); tmp___9 = inb((int )((unsigned int )cs->hw.njet.base + 40U)); tmp___10 = inl((int )((unsigned int )cs->hw.njet.base + 20U)); tmp___11 = inl((int )((unsigned int )cs->hw.njet.base + 36U)); debugl1(cs, (char *)"tiger: dmacfg %x/%x pulse=%d", tmp___11, tmp___10, (int )tmp___9); cs->hw.njet.last_is0 = 0U; cs->bcs[0].BC_SetStack = & setstack_tiger; cs->bcs[1].BC_SetStack = & setstack_tiger; cs->bcs[0].BC_Close = & close_tigerstate; cs->bcs[1].BC_Close = & close_tigerstate; return; } } static void releasetiger(struct IsdnCardState *cs ) { { kfree((void const *)cs->bcs[0].hw.tiger.send); cs->bcs[0].hw.tiger.send = 0; cs->bcs[1].hw.tiger.send = 0; kfree((void const *)cs->bcs[0].hw.tiger.rec); cs->bcs[0].hw.tiger.rec = 0; cs->bcs[1].hw.tiger.rec = 0; return; } } void release_io_netjet(struct IsdnCardState *cs ) { { outb(0, (int )((unsigned int )cs->hw.njet.base + 4U)); outb(0, (int )((unsigned int )cs->hw.njet.base + 5U)); releasetiger(cs); __release_region(& ioport_resource, (resource_size_t )cs->hw.njet.base, 256ULL); return; } } void ldv_mutex_lock_365(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_lock(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_366(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_lock(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_367(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } int ldv_mutex_trylock_368(struct mutex *ldv_func_arg1 ) { ldv_func_ret_type___2 ldv_func_res ; int tmp ; int tmp___0 ; { tmp = mutex_trylock(ldv_func_arg1); ldv_func_res = tmp; tmp___0 = ldv_mutex_trylock_mutex(ldv_func_arg1); return (tmp___0); return (ldv_func_res); } } void ldv_mutex_unlock_369(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_370(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_cred_guard_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_371(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_cred_guard_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } int ldv_mutex_trylock_382(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_380(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_383(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_385(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_379(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_381(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_384(struct mutex *ldv_func_arg1 ) ; void ICCVersion(struct IsdnCardState *cs , char *s ) ; void initicc(struct IsdnCardState *cs ) ; void icc_interrupt(struct IsdnCardState *cs , u_char val ) ; void clear_pending_icc_ints(struct IsdnCardState *cs ) ; void setup_icc(struct IsdnCardState *cs ) ; static char const *NETjet_U_revision = "$Revision: 2.14.2.3 $"; static u_char dummyrr___0(struct IsdnCardState *cs , int chan , u_char off ) { { return (5U); } } static void dummywr___0(struct IsdnCardState *cs , int chan , u_char off , u_char value ) { { return; } } static irqreturn_t netjet_u_interrupt(int intno , void *dev_id ) { struct IsdnCardState *cs ; u_char val ; u_char sval ; u_long flags ; raw_spinlock_t *tmp ; unsigned int tmp___0 ; unsigned int tmp___1 ; unsigned int tmp___2 ; unsigned int tmp___3 ; int tmp___4 ; { cs = (struct IsdnCardState *)dev_id; tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); sval = inb((int )((unsigned int )cs->hw.njet.base + 7U)); if (((int )sval & 16) == 0) { val = NETjet_ReadIC(cs, 32); if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"tiger: i1 %x %x", (int )sval, (int )val); } else { } if ((unsigned int )val != 0U) { icc_interrupt(cs, (int )val); NETjet_WriteIC(cs, 32, 255); NETjet_WriteIC(cs, 32, 0); } else { } } else { } tmp___0 = inl((int )((unsigned int )cs->hw.njet.base + 36U)); tmp___1 = inl((int )((unsigned int )cs->hw.njet.base + 28U)); if (tmp___0 < tmp___1) { sval = 8U; } else { sval = 4U; } tmp___2 = inl((int )((unsigned int )cs->hw.njet.base + 20U)); tmp___3 = inl((int )((unsigned int )cs->hw.njet.base + 12U)); if (tmp___2 < tmp___3) { sval = (u_char )((unsigned int )sval | 2U); } else { sval = (u_char )((unsigned int )sval | 1U); } if ((int )cs->hw.njet.last_is0 != (int )sval) { tmp___4 = test_and_set_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___4 != 0) { spin_unlock_irqrestore(& cs->lock, flags); return (1); } else { } cs->hw.njet.irqstat0 = sval; if ((((int )cs->hw.njet.irqstat0 ^ (int )cs->hw.njet.last_is0) & 12) != 0) { read_tiger(cs); } else { } if ((((int )cs->hw.njet.irqstat0 ^ (int )cs->hw.njet.last_is0) & 3) != 0) { write_tiger(cs); } else { } test_and_clear_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); } else { } spin_unlock_irqrestore(& cs->lock, flags); return (1); } } static void reset_netjet_u(struct IsdnCardState *cs ) { unsigned long __ms ; unsigned long tmp ; unsigned long __ms___0 ; unsigned long tmp___0 ; { cs->hw.njet.ctrl_reg = 255U; outb((int )cs->hw.njet.ctrl_reg, (int )cs->hw.njet.base); __ms = 10UL; goto ldv_41085; ldv_41084: __const_udelay(4295000UL); ldv_41085: tmp = __ms; __ms = __ms - 1UL; if (tmp != 0UL) { goto ldv_41084; } else { } cs->hw.njet.ctrl_reg = 64U; outb((int )cs->hw.njet.ctrl_reg, (int )cs->hw.njet.base); __ms___0 = 10UL; goto ldv_41089; ldv_41088: __const_udelay(4295000UL); ldv_41089: tmp___0 = __ms___0; __ms___0 = __ms___0 - 1UL; if (tmp___0 != 0UL) { goto ldv_41088; } else { } cs->hw.njet.auxd = 192U; cs->hw.njet.dmactrl = 0U; outb(0, (int )cs->hw.njet.auxa); outb(239, (int )((unsigned int )cs->hw.njet.base + 2U)); outb(16, (int )((unsigned int )cs->hw.njet.base + 5U)); outb((int )cs->hw.njet.auxd, (int )cs->hw.njet.auxa); return; } } static int NETjet_U_card_msg(struct IsdnCardState *cs , int mt , void *arg ) { u_long flags ; raw_spinlock_t *tmp ; raw_spinlock_t *tmp___0 ; { switch (mt) { case 240: tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); reset_netjet_u(cs); spin_unlock_irqrestore(& cs->lock, flags); return (0); case 243: release_io_netjet(cs); return (0); case 242: tmp___0 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___0); inittiger(cs); reset_netjet_u(cs); clear_pending_icc_ints(cs); initicc(cs); (*(cs->writeisac))(cs, 32, 0); spin_unlock_irqrestore(& cs->lock, flags); return (0); case 244: ; return (0); } return (0); } } static int nju_pci_probe(struct pci_dev *dev_netjet___2 , struct IsdnCardState *cs ) { int tmp ; { tmp = pci_enable_device(dev_netjet___2); if (tmp != 0) { return (0); } else { } pci_set_master(dev_netjet___2); cs->irq = dev_netjet___2->irq; if (cs->irq == 0U) { printk("\fNETspider-U: No IRQ for PCI card found\n"); return (0); } else { } cs->hw.njet.base = (unsigned long )dev_netjet___2->resource[0].start; if (cs->hw.njet.base == 0UL) { printk("\fNETspider-U: No IO-Adr for PCI card found\n"); return (0); } else { } return (1); } } static int nju_cs_init(struct IsdnCard *card , struct IsdnCardState *cs ) { unsigned long __ms ; unsigned long tmp ; unsigned long __ms___0 ; unsigned long tmp___0 ; unsigned long __ms___1 ; unsigned long tmp___1 ; u_char tmp___2 ; { cs->hw.njet.auxa = (unsigned int )cs->hw.njet.base + 3U; cs->hw.njet.isac = (unsigned int )cs->hw.njet.base | 192U; __ms = 10UL; goto ldv_41117; ldv_41116: __const_udelay(4295000UL); ldv_41117: tmp = __ms; __ms = __ms - 1UL; if (tmp != 0UL) { goto ldv_41116; } else { } cs->hw.njet.ctrl_reg = 255U; outb((int )cs->hw.njet.ctrl_reg, (int )cs->hw.njet.base); __ms___0 = 10UL; goto ldv_41121; ldv_41120: __const_udelay(4295000UL); ldv_41121: tmp___0 = __ms___0; __ms___0 = __ms___0 - 1UL; if (tmp___0 != 0UL) { goto ldv_41120; } else { } cs->hw.njet.ctrl_reg = 0U; outb((int )cs->hw.njet.ctrl_reg, (int )cs->hw.njet.base); __ms___1 = 10UL; goto ldv_41125; ldv_41124: __const_udelay(4295000UL); ldv_41125: tmp___1 = __ms___1; __ms___1 = __ms___1 - 1UL; if (tmp___1 != 0UL) { goto ldv_41124; } else { } cs->hw.njet.auxd = 192U; cs->hw.njet.dmactrl = 0U; outb(0, (int )cs->hw.njet.auxa); outb(239, (int )((unsigned int )cs->hw.njet.base + 2U)); outb(16, (int )((unsigned int )cs->hw.njet.base + 5U)); outb((int )cs->hw.njet.auxd, (int )cs->hw.njet.auxa); tmp___2 = NETjet_ReadIC(cs, 42); switch (((int )tmp___2 >> 5) & 3) { case 3: ; return (1); case 0: printk("\fNETspider-U: NETjet-S PCI card found\n"); return (-1); default: printk("\fNETspider-U: No PCI card found\n"); return (0); } return (1); } } static int nju_cs_init_rest(struct IsdnCard *card , struct IsdnCardState *cs ) { int bytecnt ; struct resource *tmp ; { bytecnt = 256; printk("\016NETspider-U: PCI card configured at %#lx IRQ %d\n", cs->hw.njet.base, cs->irq); tmp = __request_region(& ioport_resource, (resource_size_t )cs->hw.njet.base, (resource_size_t )bytecnt, "netspider-u isdn", 0); if ((unsigned long )tmp == (unsigned long )((struct resource *)0)) { printk("\fHiSax: NETspider-U config port %#lx-%#lx already in use\n", cs->hw.njet.base, cs->hw.njet.base + (unsigned long )bytecnt); return (0); } else { } setup_icc(cs); cs->readisac = & NETjet_ReadIC; cs->writeisac = & NETjet_WriteIC; cs->readisacfifo = & NETjet_ReadICfifo; cs->writeisacfifo = & NETjet_WriteICfifo; cs->BC_Read_Reg = & dummyrr___0; cs->BC_Write_Reg = & dummywr___0; cs->BC_Send_Data = & netjet_fill_dma; cs->cardmsg = & NETjet_U_card_msg; cs->irq_func = & netjet_u_interrupt; cs->irq_flags = cs->irq_flags | 128UL; ICCVersion(cs, (char *)"NETspider-U:"); return (1); } } static struct pci_dev *dev_netjet___0 = 0; int setup_netjet_u(struct IsdnCard *card ) { int ret ; struct IsdnCardState *cs ; char tmp[64U] ; char *tmp___0 ; int tmp___1 ; { cs = card->cs; strcpy((char *)(& tmp), NETjet_U_revision); tmp___0 = HiSax_getrev((char const *)(& tmp)); printk("\016HiSax: Traverse Tech. NETspider-U driver Rev. %s\n", tmp___0); if ((unsigned int )cs->typ != 38U) { return (0); } else { } test_and_clear_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); ldv_41143: dev_netjet___0 = hisax_find_pci_device(57689U, 1U, dev_netjet___0); if ((unsigned long )dev_netjet___0 != (unsigned long )((struct pci_dev *)0)) { ret = nju_pci_probe(dev_netjet___0, cs); if (ret == 0) { return (0); } else { } } else { printk("\fNETspider-U: No PCI card found\n"); return (0); } ret = nju_cs_init(card, cs); if (ret == 0) { return (0); } else { } if (ret > 0) { goto ldv_41142; } else { } goto ldv_41143; ldv_41142: tmp___1 = nju_cs_init_rest(card, cs); return (tmp___1); } } void ldv_mutex_lock_379(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_lock(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_380(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_lock(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_381(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } int ldv_mutex_trylock_382(struct mutex *ldv_func_arg1 ) { ldv_func_ret_type___2 ldv_func_res ; int tmp ; int tmp___0 ; { tmp = mutex_trylock(ldv_func_arg1); ldv_func_res = tmp; tmp___0 = ldv_mutex_trylock_mutex(ldv_func_arg1); return (tmp___0); return (ldv_func_res); } } void ldv_mutex_unlock_383(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_384(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_cred_guard_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_385(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_cred_guard_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } int ldv_mutex_trylock_396(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_394(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_397(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_399(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_393(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_395(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_398(struct mutex *ldv_func_arg1 ) ; static char *ICCVer[4U] = { (char *)"2070 A1/A3", (char *)"2070 B1", (char *)"2070 B2/B3", (char *)"2070 V2.4"}; void ICCVersion(struct IsdnCardState *cs , char *s ) { int val ; u_char tmp ; { tmp = (*(cs->readisac))(cs, 42); val = (int )tmp; printk("\016%s ICC version (%x): %s\n", s, val, ICCVer[(val >> 5) & 3]); return; } } static void ph_command___1(struct IsdnCardState *cs , unsigned int command ) { { if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"ph_command %x", command); } else { } (*(cs->writeisac))(cs, 49, (int )((unsigned int )((int )((u_char )command) << 2U) | 3U)); return; } } static void icc_new_ph(struct IsdnCardState *cs ) { { switch (cs->dc.icc.ph_state) { case 4: ph_command___1(cs, 15U); l1_msg(cs, 6, 0); goto ldv_40988; case 15: l1_msg(cs, 25, 0); goto ldv_40988; case 0: l1_msg(cs, 26, 0); goto ldv_40988; case 7: l1_msg(cs, 9, 0); goto ldv_40988; case 2: l1_msg(cs, 98, 0); goto ldv_40988; case 8: l1_msg(cs, 34, 0); goto ldv_40988; case 12: l1_msg(cs, 66, 0); goto ldv_40988; default: ; goto ldv_40988; } ldv_40988: ; return; } } static void icc_bh(struct work_struct *work ) { struct IsdnCardState *cs ; struct work_struct const *__mptr ; struct PStack *stptr ; int tmp ; int tmp___0 ; int tmp___1 ; int tmp___2 ; { __mptr = (struct work_struct const *)work; cs = (struct IsdnCardState *)__mptr + 0xffffffffffffe728UL; tmp = test_and_clear_bit(3, (unsigned long volatile *)(& cs->event)); if (tmp != 0) { if (cs->debug != 0) { debugl1(cs, (char *)"D-Channel Busy cleared"); } else { } stptr = cs->stlist; goto ldv_41004; ldv_41003: (*(stptr->l1.l1l2))(stptr, 337, 0); stptr = stptr->next; ldv_41004: ; if ((unsigned long )stptr != (unsigned long )((struct PStack *)0)) { goto ldv_41003; } else { } } else { } tmp___0 = test_and_clear_bit(2, (unsigned long volatile *)(& cs->event)); if (tmp___0 != 0) { icc_new_ph(cs); } else { } tmp___1 = test_and_clear_bit(0, (unsigned long volatile *)(& cs->event)); if (tmp___1 != 0) { DChannel_proc_rcv(cs); } else { } tmp___2 = test_and_clear_bit(1, (unsigned long volatile *)(& cs->event)); if (tmp___2 != 0) { DChannel_proc_xmt(cs); } else { } return; } } static void icc_empty_fifo(struct IsdnCardState *cs , int count ) { u_char *ptr ; char *t ; int tmp ; { if ((cs->debug & 4) != 0 && (cs->debug & 8) == 0) { debugl1(cs, (char *)"icc_empty_fifo"); } else { } if (cs->rcvidx + count > 299) { if (cs->debug & 1) { debugl1(cs, (char *)"icc_empty_fifo overrun %d", cs->rcvidx + count); } else { } (*(cs->writeisac))(cs, 33, 128); cs->rcvidx = 0; return; } else { } ptr = cs->rcvbuf + (unsigned long )cs->rcvidx; cs->rcvidx = cs->rcvidx + count; (*(cs->readisacfifo))(cs, ptr, count); (*(cs->writeisac))(cs, 33, 128); if ((cs->debug & 8) != 0) { t = cs->dlog; tmp = sprintf(t, "icc_empty_fifo cnt %d", count); t = t + (unsigned long )tmp; QuickHex(t, ptr, count); debugl1(cs, cs->dlog); } else { } return; } } static void icc_fill_fifo(struct IsdnCardState *cs ) { int count ; int more ; u_char *ptr ; int tmp ; struct lock_class_key __key ; char *t ; int tmp___0 ; { if ((cs->debug & 4) != 0 && (cs->debug & 8) == 0) { debugl1(cs, (char *)"icc_fill_fifo"); } else { } if ((unsigned long )cs->tx_skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } count = (int )(cs->tx_skb)->len; if (count <= 0) { return; } else { } more = 0; if (count > 32) { more = 1; count = 32; } else { } ptr = (cs->tx_skb)->data; skb_pull(cs->tx_skb, (unsigned int )count); cs->tx_cnt = cs->tx_cnt + count; (*(cs->writeisacfifo))(cs, ptr, count); (*(cs->writeisac))(cs, 33, more != 0 ? 8 : 10); tmp = test_and_set_bit(6, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp != 0) { debugl1(cs, (char *)"icc_fill_fifo dbusytimer running"); del_timer(& cs->dbusytimer); } else { } init_timer_key(& cs->dbusytimer, 0U, "(&cs->dbusytimer)", & __key); cs->dbusytimer.expires = (unsigned long )jiffies + 20UL; add_timer(& cs->dbusytimer); if ((cs->debug & 8) != 0) { t = cs->dlog; tmp___0 = sprintf(t, "icc_fill_fifo cnt %d", count); t = t + (unsigned long )tmp___0; QuickHex(t, ptr, count); debugl1(cs, cs->dlog); } else { } return; } } void icc_interrupt(struct IsdnCardState *cs , u_char val ) { u_char exval ; u_char v1 ; struct sk_buff *skb ; unsigned int count ; u_char tmp ; size_t __len ; void *__ret ; unsigned char *tmp___1 ; int tmp___2 ; int tmp___3 ; struct sk_buff *tmp___4 ; int tmp___5 ; int tmp___6 ; { if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"ICC interrupt %x", (int )val); } else { } if ((int )((signed char )val) < 0) { exval = (*(cs->readisac))(cs, 39); if (((int )exval & 112) != 32) { if (((int )exval & 64) != 0) { if (cs->debug & 1) { debugl1(cs, (char *)"ICC RDO"); } else { } cs->err_rx = cs->err_rx + 1; } else { } if (((int )exval & 32) == 0) { if (cs->debug & 1) { debugl1(cs, (char *)"ICC CRC error"); } else { } cs->err_crc = cs->err_crc + 1; } else { } (*(cs->writeisac))(cs, 33, 128); } else { tmp = (*(cs->readisac))(cs, 37); count = (unsigned int )tmp & 31U; if (count == 0U) { count = 32U; } else { } icc_empty_fifo(cs, (int )count); count = (unsigned int )cs->rcvidx; if (count != 0U) { cs->rcvidx = 0; skb = alloc_skb(count, 32U); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { printk("\fHiSax: D receive out of memory\n"); } else { __len = (size_t )count; tmp___1 = skb_put(skb, count); __ret = memcpy((void *)tmp___1, (void const *)cs->rcvbuf, __len); skb_queue_tail(& cs->rq, skb); } } else { } } cs->rcvidx = 0; test_and_set_bit(0, (unsigned long volatile *)(& cs->event)); schedule_work(& cs->tqueue); } else { } if (((int )val & 64) != 0) { icc_empty_fifo(cs, 32); } else { } if (((int )val & 32) != 0) { if (cs->debug & 1) { debugl1(cs, (char *)"ICC RSC interrupt"); } else { } } else { } if (((int )val & 16) != 0) { tmp___2 = test_and_clear_bit(6, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___2 != 0) { del_timer(& cs->dbusytimer); } else { } tmp___3 = test_and_clear_bit(5, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___3 != 0) { test_and_set_bit(3, (unsigned long volatile *)(& cs->event)); schedule_work(& cs->tqueue); } else { } if ((unsigned long )cs->tx_skb != (unsigned long )((struct sk_buff *)0)) { if ((cs->tx_skb)->len != 0U) { icc_fill_fifo(cs); goto afterXPR; } else { dev_kfree_skb_irq(cs->tx_skb); cs->tx_cnt = 0; cs->tx_skb = 0; } } else { } tmp___4 = skb_dequeue(& cs->sq); cs->tx_skb = tmp___4; if ((unsigned long )tmp___4 != (unsigned long )((struct sk_buff *)0)) { cs->tx_cnt = 0; icc_fill_fifo(cs); } else { test_and_set_bit(1, (unsigned long volatile *)(& cs->event)); schedule_work(& cs->tqueue); } } else { } afterXPR: ; if (((int )val & 4) != 0) { exval = (*(cs->readisac))(cs, 49); if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"ICC CIR0 %02X", (int )exval); } else { } if (((int )exval & 2) != 0) { cs->dc.icc.ph_state = ((int )exval >> 2) & 15; if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"ph_state change %x", cs->dc.icc.ph_state); } else { } test_and_set_bit(2, (unsigned long volatile *)(& cs->event)); schedule_work(& cs->tqueue); } else { } if ((int )exval & 1) { exval = (*(cs->readisac))(cs, 51); if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"ICC CIR1 %02X", (int )exval); } else { } } else { } } else { } if (((int )val & 2) != 0) { if (cs->debug & 1) { debugl1(cs, (char *)"ICC SIN interrupt"); } else { } } else { } if ((int )val & 1) { exval = (*(cs->readisac))(cs, 36); if (cs->debug & 1) { debugl1(cs, (char *)"ICC EXIR %02x", (int )exval); } else { } if ((int )((signed char )exval) < 0) { debugl1(cs, (char *)"ICC XMR"); printk("\fHiSax: ICC XMR\n"); } else { } if (((int )exval & 64) != 0) { debugl1(cs, (char *)"ICC XDU"); printk("\fHiSax: ICC XDU\n"); cs->err_tx = cs->err_tx + 1; tmp___5 = test_and_clear_bit(6, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___5 != 0) { del_timer(& cs->dbusytimer); } else { } tmp___6 = test_and_clear_bit(5, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___6 != 0) { test_and_set_bit(3, (unsigned long volatile *)(& cs->event)); schedule_work(& cs->tqueue); } else { } if ((unsigned long )cs->tx_skb != (unsigned long )((struct sk_buff *)0)) { skb_push(cs->tx_skb, (unsigned int )cs->tx_cnt); cs->tx_cnt = 0; icc_fill_fifo(cs); } else { printk("\fHiSax: ICC XDU no skb\n"); debugl1(cs, (char *)"ICC XDU no skb"); } } else { } if (((int )exval & 4) != 0) { v1 = (*(cs->readisac))(cs, 58); if ((cs->debug & 512) != 0) { debugl1(cs, (char *)"ICC MOSR %02x", (int )v1); } else { } } else { } } else { } return; } } static void ICC_l1hw(struct PStack *st , int pr , void *arg ) { struct IsdnCardState *cs ; struct sk_buff *skb ; u_long flags ; int val ; raw_spinlock_t *tmp ; raw_spinlock_t *tmp___0 ; raw_spinlock_t *tmp___1 ; raw_spinlock_t *tmp___2 ; raw_spinlock_t *tmp___3 ; raw_spinlock_t *tmp___4 ; raw_spinlock_t *tmp___5 ; int tmp___6 ; int tmp___7 ; int tmp___8 ; { cs = (struct IsdnCardState *)st->l1.hardware; skb = (struct sk_buff *)arg; switch (pr) { case 288: ; if ((cs->debug & 1024) != 0) { LogFrame(cs, skb->data, (int )skb->len); } else { } if ((cs->debug & 2048) != 0) { dlogframe(cs, skb, 0); } else { } tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); if ((unsigned long )cs->tx_skb != (unsigned long )((struct sk_buff *)0)) { skb_queue_tail(& cs->sq, skb); if ((cs->debug & 64) != 0) { Logl2Frame(cs, skb, (char *)"PH_DATA Queued", 0); } else { } } else { cs->tx_skb = skb; cs->tx_cnt = 0; if ((cs->debug & 64) != 0) { Logl2Frame(cs, skb, (char *)"PH_DATA", 0); } else { } icc_fill_fifo(cs); } spin_unlock_irqrestore(& cs->lock, flags); goto ldv_41045; case 306: tmp___0 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___0); if ((unsigned long )cs->tx_skb != (unsigned long )((struct sk_buff *)0)) { if (cs->debug & 1) { debugl1(cs, (char *)" l2l1 tx_skb exist this shouldn\'t happen"); } else { } skb_queue_tail(& cs->sq, skb); spin_unlock_irqrestore(& cs->lock, flags); goto ldv_41045; } else { } if ((cs->debug & 1024) != 0) { LogFrame(cs, skb->data, (int )skb->len); } else { } if ((cs->debug & 2048) != 0) { dlogframe(cs, skb, 0); } else { } cs->tx_skb = skb; cs->tx_cnt = 0; if ((cs->debug & 64) != 0) { Logl2Frame(cs, skb, (char *)"PH_DATA_PULLED", 0); } else { } icc_fill_fifo(cs); spin_unlock_irqrestore(& cs->lock, flags); goto ldv_41045; case 304: ; if ((cs->debug & 64) != 0) { debugl1(cs, (char *)"-> PH_REQUEST_PULL"); } else { } if ((unsigned long )cs->tx_skb == (unsigned long )((struct sk_buff *)0)) { test_and_clear_bit(6, (unsigned long volatile *)(& st->l1.Flags)); (*(st->l1.l1l2))(st, 305, 0); } else { test_and_set_bit(6, (unsigned long volatile *)(& st->l1.Flags)); } goto ldv_41045; case 4: tmp___1 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___1); if (cs->dc.icc.ph_state == 4 || cs->dc.icc.ph_state == 0) { ph_command___1(cs, 15U); } else { ph_command___1(cs, 1U); } spin_unlock_irqrestore(& cs->lock, flags); goto ldv_41045; case 0: tmp___2 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___2); ph_command___1(cs, 15U); spin_unlock_irqrestore(& cs->lock, flags); goto ldv_41045; case 16: tmp___3 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___3); ph_command___1(cs, 8U); spin_unlock_irqrestore(& cs->lock, flags); goto ldv_41045; case 48: tmp___4 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___4); ph_command___1(cs, 12U); spin_unlock_irqrestore(& cs->lock, flags); goto ldv_41045; case 112: tmp___5 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___5); val = 0; if ((int )((long )arg) & 1) { val = val | 12; } else { } if (((long )arg & 2L) != 0L) { val = val | 3; } else { } tmp___6 = constant_test_bit(0U, (unsigned long const volatile *)(& cs->HW_Flags)); if (tmp___6 != 0) { if (val == 0) { (*(cs->writeisac))(cs, 48, 10); (*(cs->writeisac))(cs, 56, 2); } else { (*(cs->writeisac))(cs, 48, (int )((u_char )val)); (*(cs->writeisac))(cs, 56, 10); } } else { (*(cs->writeisac))(cs, 48, (int )((u_char )val)); if (val != 0) { (*(cs->writeisac))(cs, 56, 8); } else { (*(cs->writeisac))(cs, 56, 0); } } spin_unlock_irqrestore(& cs->lock, flags); goto ldv_41045; case 27: skb_queue_purge(& cs->rq); skb_queue_purge(& cs->sq); if ((unsigned long )cs->tx_skb != (unsigned long )((struct sk_buff *)0)) { dev_kfree_skb_any(cs->tx_skb); cs->tx_skb = 0; } else { } tmp___7 = test_and_clear_bit(6, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___7 != 0) { del_timer(& cs->dbusytimer); } else { } tmp___8 = test_and_clear_bit(5, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___8 != 0) { test_and_set_bit(3, (unsigned long volatile *)(& cs->event)); schedule_work(& cs->tqueue); } else { } goto ldv_41045; default: ; if (cs->debug & 1) { debugl1(cs, (char *)"icc_l1hw unknown %04x", pr); } else { } goto ldv_41045; } ldv_41045: ; return; } } static void setstack_icc(struct PStack *st , struct IsdnCardState *cs ) { { st->l1.l1hw = & ICC_l1hw; return; } } static void DC_Close_icc(struct IsdnCardState *cs ) { { kfree((void const *)cs->dc.icc.mon_rx); cs->dc.icc.mon_rx = 0; kfree((void const *)cs->dc.icc.mon_tx); cs->dc.icc.mon_tx = 0; return; } } static void dbusy_timer_handler___1(struct IsdnCardState *cs ) { struct PStack *stptr ; int rbch ; int star ; u_char tmp ; u_char tmp___0 ; int tmp___1 ; { tmp___1 = constant_test_bit(6U, (unsigned long const volatile *)(& cs->HW_Flags)); if (tmp___1 != 0) { tmp = (*(cs->readisac))(cs, 42); rbch = (int )tmp; tmp___0 = (*(cs->readisac))(cs, 33); star = (int )tmp___0; if (cs->debug != 0) { debugl1(cs, (char *)"D-Channel Busy RBCH %02x STAR %02x", rbch, star); } else { } if ((rbch & 128) != 0) { test_and_set_bit(5, (unsigned long volatile *)(& cs->HW_Flags)); stptr = cs->stlist; goto ldv_41087; ldv_41086: (*(stptr->l1.l1l2))(stptr, 338, 0); stptr = stptr->next; ldv_41087: ; if ((unsigned long )stptr != (unsigned long )((struct PStack *)0)) { goto ldv_41086; } else { } } else { test_and_clear_bit(6, (unsigned long volatile *)(& cs->HW_Flags)); if ((unsigned long )cs->tx_skb != (unsigned long )((struct sk_buff *)0)) { dev_kfree_skb_any(cs->tx_skb); cs->tx_cnt = 0; cs->tx_skb = 0; } else { printk("\fHiSax: ICC D-Channel Busy no skb\n"); debugl1(cs, (char *)"D-Channel Busy no skb"); } (*(cs->writeisac))(cs, 33, 1); (*(cs->irq_func))((int )cs->irq, (void *)cs); } } else { } return; } } void initicc(struct IsdnCardState *cs ) { int tmp ; { cs->setstack_d = & setstack_icc; cs->DC_Close = & DC_Close_icc; cs->dc.icc.mon_tx = 0; cs->dc.icc.mon_rx = 0; (*(cs->writeisac))(cs, 32, 255); cs->dc.icc.mocr = 170U; tmp = constant_test_bit(0U, (unsigned long const volatile *)(& cs->HW_Flags)); if (tmp != 0) { (*(cs->writeisac))(cs, 57, 0); (*(cs->writeisac))(cs, 48, 10); (*(cs->writeisac))(cs, 56, 2); (*(cs->writeisac))(cs, 55, 112); (*(cs->writeisac))(cs, 34, 201); } else { if ((unsigned int )cs->dc.icc.adf2 == 0U) { cs->dc.icc.adf2 = 128U; } else { } (*(cs->writeisac))(cs, 57, (int )cs->dc.icc.adf2); (*(cs->writeisac))(cs, 59, 160); (*(cs->writeisac))(cs, 48, 32); (*(cs->writeisac))(cs, 55, 112); (*(cs->writeisac))(cs, 34, 202); (*(cs->writeisac))(cs, 35, 0); (*(cs->writeisac))(cs, 56, 32); } ph_command___1(cs, 1U); (*(cs->writeisac))(cs, 32, 0); ph_command___1(cs, 15U); return; } } void clear_pending_icc_ints(struct IsdnCardState *cs ) { int val ; int eval ; u_char tmp ; u_char tmp___0 ; u_char tmp___1 ; u_char tmp___2 ; u_char tmp___3 ; u_char tmp___4 ; { tmp = (*(cs->readisac))(cs, 33); val = (int )tmp; debugl1(cs, (char *)"ICC STAR %x", val); tmp___0 = (*(cs->readisac))(cs, 34); val = (int )tmp___0; debugl1(cs, (char *)"ICC MODE %x", val); tmp___1 = (*(cs->readisac))(cs, 57); val = (int )tmp___1; debugl1(cs, (char *)"ICC ADF2 %x", val); tmp___2 = (*(cs->readisac))(cs, 32); val = (int )tmp___2; debugl1(cs, (char *)"ICC ISTA %x", val); if (val & 1) { tmp___3 = (*(cs->readisac))(cs, 36); eval = (int )tmp___3; debugl1(cs, (char *)"ICC EXIR %x", eval); } else { } tmp___4 = (*(cs->readisac))(cs, 49); val = (int )tmp___4; debugl1(cs, (char *)"ICC CIR0 %x", val); cs->dc.icc.ph_state = (val >> 2) & 15; test_and_set_bit(2, (unsigned long volatile *)(& cs->event)); schedule_work(& cs->tqueue); (*(cs->writeisac))(cs, 32, 255); return; } } void setup_icc(struct IsdnCardState *cs ) { struct lock_class_key __key ; atomic_long_t __constr_expr_0 ; struct lock_class_key __key___0 ; { __init_work(& cs->tqueue, 0); __constr_expr_0.counter = 4195328L; cs->tqueue.data = __constr_expr_0; lockdep_init_map(& cs->tqueue.lockdep_map, "(&cs->tqueue)", & __key, 0); INIT_LIST_HEAD(& cs->tqueue.entry); cs->tqueue.func = & icc_bh; cs->dbusytimer.function = (void (*)(unsigned long ))(& dbusy_timer_handler___1); cs->dbusytimer.data = (unsigned long )cs; init_timer_key(& cs->dbusytimer, 0U, "(&cs->dbusytimer)", & __key___0); return; } } void ldv_mutex_lock_393(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_lock(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_394(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_lock(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_395(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } int ldv_mutex_trylock_396(struct mutex *ldv_func_arg1 ) { ldv_func_ret_type___2 ldv_func_res ; int tmp ; int tmp___0 ; { tmp = mutex_trylock(ldv_func_arg1); ldv_func_res = tmp; tmp___0 = ldv_mutex_trylock_mutex(ldv_func_arg1); return (tmp___0); return (ldv_func_res); } } void ldv_mutex_unlock_397(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_398(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_cred_guard_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_399(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_cred_guard_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } extern struct pv_irq_ops pv_irq_ops ; extern void __bad_percpu_size(void) ; extern struct task_struct *current_task ; __inline static struct task_struct *get_current(void) { struct task_struct *pfo_ret__ ; { switch (8UL) { case 1UL: __asm__ ("movb %%gs:%P1,%0": "=q" (pfo_ret__): "p" (& current_task)); goto ldv_2861; case 2UL: __asm__ ("movw %%gs:%P1,%0": "=r" (pfo_ret__): "p" (& current_task)); goto ldv_2861; case 4UL: __asm__ ("movl %%gs:%P1,%0": "=r" (pfo_ret__): "p" (& current_task)); goto ldv_2861; case 8UL: __asm__ ("movq %%gs:%P1,%0": "=r" (pfo_ret__): "p" (& current_task)); goto ldv_2861; default: __bad_percpu_size(); } ldv_2861: ; return (pfo_ret__); } } 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 *)"/home/mikhail/launches/cpachecker-regression2/launcher-working-dir/ldv-manager-work-dir/inst/current/envs/linux-3.8-rc1/linux-3.8-rc1/arch/x86/include/asm/paravirt.h"), "i" (825), "i" (12UL)); ldv_4725: ; goto ldv_4725; } 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" (45UL), [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); } } int ldv_mutex_trylock_410(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_408(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_411(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_413(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_407(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_409(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_412(struct mutex *ldv_func_arg1 ) ; __inline static int is_device_dma_capable(struct device *dev ) { { return ((unsigned long )dev->dma_mask != (unsigned long )((u64 *)0) && *(dev->dma_mask) != 0ULL); } } extern void debug_dma_alloc_coherent(struct device * , size_t , dma_addr_t , void * ) ; extern void debug_dma_free_coherent(struct device * , size_t , void * , dma_addr_t ) ; extern struct device x86_dma_fallback_dev ; 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 unsigned long dma_alloc_coherent_mask(struct device *dev , gfp_t gfp ) { unsigned long dma_mask ; { dma_mask = 0UL; dma_mask = (unsigned long )dev->coherent_dma_mask; if (dma_mask == 0UL) { dma_mask = (int )gfp & 1 ? 16777215UL : 4294967295UL; } else { } return (dma_mask); } } __inline static gfp_t dma_alloc_coherent_gfp_flags(struct device *dev , gfp_t gfp ) { unsigned long dma_mask ; unsigned long tmp ; { tmp = dma_alloc_coherent_mask(dev, gfp); dma_mask = tmp; if ((unsigned long long )dma_mask <= 16777215ULL) { gfp = gfp | 1U; } else { } if ((unsigned long long )dma_mask <= 4294967295ULL && (gfp & 1U) == 0U) { gfp = gfp | 4U; } else { } return (gfp); } } __inline static void *dma_alloc_attrs(struct device *dev , size_t size , dma_addr_t *dma_handle , gfp_t gfp , struct dma_attrs *attrs ) { struct dma_map_ops *ops ; struct dma_map_ops *tmp ; void *memory ; int tmp___0 ; gfp_t tmp___1 ; { tmp = get_dma_ops(dev); ops = tmp; gfp = gfp & 4294967288U; if ((unsigned long )dev == (unsigned long )((struct device *)0)) { dev = & x86_dma_fallback_dev; } else { } tmp___0 = is_device_dma_capable(dev); if (tmp___0 == 0) { return (0); } else { } if ((unsigned long )ops->alloc == (unsigned long )((void *(*)(struct device * , size_t , dma_addr_t * , gfp_t , struct dma_attrs * ))0)) { return (0); } else { } tmp___1 = dma_alloc_coherent_gfp_flags(dev, gfp); memory = (*(ops->alloc))(dev, size, dma_handle, tmp___1, attrs); debug_dma_alloc_coherent(dev, size, *dma_handle, memory); return (memory); } } __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("/home/mikhail/launches/cpachecker-regression2/launcher-working-dir/ldv-manager-work-dir/inst/current/envs/linux-3.8-rc1/linux-3.8-rc1/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); } } extern int pci_bus_write_config_word(struct pci_bus * , unsigned int , int , u16 ) ; extern int pci_bus_write_config_dword(struct pci_bus * , unsigned int , int , u32 ) ; __inline static int pci_write_config_word(struct pci_dev const *dev , int where , u16 val ) { int tmp ; { tmp = pci_bus_write_config_word(dev->bus, dev->devfn, where, (int )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); } } __inline static void *pci_alloc_consistent(struct pci_dev *hwdev , size_t size , dma_addr_t *dma_handle ) { void *tmp ; { tmp = dma_alloc_attrs((unsigned long )hwdev != (unsigned long )((struct pci_dev *)0) ? & hwdev->dev : 0, size, dma_handle, 32U, 0); return (tmp); } } __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 : 0, size, vaddr, dma_handle, 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); } } static char const *hfcpci_revision = "$Revision: 1.48.2.4 $"; static PCI_ENTRY const id_list[24U] = { {5015, 11216, (char *)"CCD/Billion/Asuscom", (char *)"2BD0"}, {5015, 45056, (char *)"Billion", (char *)"B000"}, {5015, 45062, (char *)"Billion", (char *)"B006"}, {5015, 45063, (char *)"Billion", (char *)"B007"}, {5015, 45064, (char *)"Billion", (char *)"B008"}, {5015, 45065, (char *)"Billion", (char *)"B009"}, {5015, 45066, (char *)"Billion", (char *)"B00A"}, {5015, 45067, (char *)"Billion", (char *)"B00B"}, {5015, 45068, (char *)"Billion", (char *)"B00C"}, {5015, 45312, (char *)"Seyeon", (char *)"B100"}, {5015, 46848, (char *)"Primux II S0", (char *)"B700"}, {5015, 46849, (char *)"Primux II S0 NT", (char *)"B701"}, {5073, 11217, (char *)"Abocom/Magitek", (char *)"2BD1"}, {4163, 1653, (char *)"Asuscom/Askey", (char *)"675"}, {2161, 65442, (char *)"German telekom", (char *)"T-Concept"}, {2161, 65441, (char *)"German telekom", (char *)"A1T"}, {4177, 256, (char *)"Motorola MC145575", (char *)"MC145575"}, {5552, 11216, (char *)"Zoltrix", (char *)"2BD0"}, {4431, 112, (char *)"Digi International", (char *)"Digi DataFire Micro V IOM2 (Europe)"}, {4431, 113, (char *)"Digi International", (char *)"Digi DataFire Micro V (Europe)"}, {4431, 114, (char *)"Digi International", (char *)"Digi DataFire Micro V IOM2 (North America)"}, {4431, 115, (char *)"Digi International", (char *)"Digi DataFire Micro V (North America)"}, {6189, 12393, (char *)"Sitecom Europe", (char *)"DC-105 ISDN PCI"}, {0, 0, 0, 0}}; static void release_io_hfcpci(struct IsdnCardState *cs ) { unsigned long __ms ; unsigned long tmp ; unsigned long __ms___0 ; unsigned long tmp___0 ; { printk("\016HiSax: release hfcpci at %p\n", cs->hw.hfcpci.pci_io); cs->hw.hfcpci.int_m2 = 0U; *(cs->hw.hfcpci.pci_io + 108UL) = cs->hw.hfcpci.int_m2; *(cs->hw.hfcpci.pci_io + 96UL) = 8U; __ms = 10UL; goto ldv_41017; ldv_41016: __const_udelay(4295000UL); ldv_41017: tmp = __ms; __ms = __ms - 1UL; if (tmp != 0UL) { goto ldv_41016; } else { } *(cs->hw.hfcpci.pci_io + 96UL) = 0U; __ms___0 = 10UL; goto ldv_41021; ldv_41020: __const_udelay(4295000UL); ldv_41021: tmp___0 = __ms___0; __ms___0 = __ms___0 - 1UL; if (tmp___0 != 0UL) { goto ldv_41020; } else { } *(cs->hw.hfcpci.pci_io + 108UL) = cs->hw.hfcpci.int_m2; pci_write_config_word((struct pci_dev const *)cs->hw.hfcpci.dev, 4, 0); del_timer(& cs->hw.hfcpci.timer); pci_free_consistent(cs->hw.hfcpci.dev, 32768UL, cs->hw.hfcpci.fifos, cs->hw.hfcpci.dma); cs->hw.hfcpci.fifos = 0; iounmap((void volatile *)cs->hw.hfcpci.pci_io); return; } } static void reset_hfcpci(struct IsdnCardState *cs ) { unsigned long __ms ; unsigned long tmp ; unsigned long __ms___0 ; unsigned long tmp___0 ; { pci_write_config_word((struct pci_dev const *)cs->hw.hfcpci.dev, 4, 2); cs->hw.hfcpci.int_m2 = 0U; *(cs->hw.hfcpci.pci_io + 108UL) = cs->hw.hfcpci.int_m2; printk("\016HFC_PCI: resetting card\n"); pci_write_config_word((struct pci_dev const *)cs->hw.hfcpci.dev, 4, 6); *(cs->hw.hfcpci.pci_io + 96UL) = 8U; __ms = 10UL; goto ldv_41028; ldv_41027: __const_udelay(4295000UL); ldv_41028: tmp = __ms; __ms = __ms - 1UL; if (tmp != 0UL) { goto ldv_41027; } else { } *(cs->hw.hfcpci.pci_io + 96UL) = 0U; __ms___0 = 10UL; goto ldv_41032; ldv_41031: __const_udelay(4295000UL); ldv_41032: tmp___0 = __ms___0; __ms___0 = __ms___0 - 1UL; if (tmp___0 != 0UL) { goto ldv_41031; } else { } if (((int )*(cs->hw.hfcpci.pci_io + 112UL) & 2) != 0) { printk("\fHFC-PCI init bit busy\n"); } else { } cs->hw.hfcpci.fifo_en = 48U; *(cs->hw.hfcpci.pci_io + 68UL) = cs->hw.hfcpci.fifo_en; cs->hw.hfcpci.trm = 0U; *(cs->hw.hfcpci.pci_io + 72UL) = cs->hw.hfcpci.trm; *(cs->hw.hfcpci.pci_io + 220UL) = 14U; cs->hw.hfcpci.sctrl_e = 1U; *(cs->hw.hfcpci.pci_io + 200UL) = cs->hw.hfcpci.sctrl_e; cs->hw.hfcpci.bswapped = 0U; cs->hw.hfcpci.nt_mode = 0U; cs->hw.hfcpci.ctmt = 36U; *(cs->hw.hfcpci.pci_io + 100UL) = cs->hw.hfcpci.ctmt; cs->hw.hfcpci.int_m1 = 228U; *(cs->hw.hfcpci.pci_io + 104UL) = cs->hw.hfcpci.int_m1; *(cs->hw.hfcpci.pci_io + 192UL) = 18U; __const_udelay(42950UL); *(cs->hw.hfcpci.pci_io + 192UL) = 2U; cs->hw.hfcpci.mst_m = 1U; *(cs->hw.hfcpci.pci_io + 184UL) = cs->hw.hfcpci.mst_m; cs->hw.hfcpci.sctrl = 64U; *(cs->hw.hfcpci.pci_io + 196UL) = cs->hw.hfcpci.sctrl; cs->hw.hfcpci.sctrl_r = 0U; *(cs->hw.hfcpci.pci_io + 204UL) = cs->hw.hfcpci.sctrl_r; cs->hw.hfcpci.conn = 54U; *(cs->hw.hfcpci.pci_io + 188UL) = cs->hw.hfcpci.conn; *(cs->hw.hfcpci.pci_io + 128UL) = 128U; *(cs->hw.hfcpci.pci_io + 132UL) = 129U; *(cs->hw.hfcpci.pci_io + 144UL) = 128U; *(cs->hw.hfcpci.pci_io + 148UL) = 129U; cs->hw.hfcpci.int_m2 = 8U; *(cs->hw.hfcpci.pci_io + 108UL) = cs->hw.hfcpci.int_m2; return; } } static void hfcpci_Timer(struct IsdnCardState *cs ) { { cs->hw.hfcpci.timer.expires = (unsigned long )jiffies + 75UL; return; } } static void sched_event_D_pci(struct IsdnCardState *cs , int event ) { { test_and_set_bit(event, (unsigned long volatile *)(& cs->event)); schedule_work(& cs->tqueue); return; } } static void hfcpci_sched_event(struct BCState *bcs , int event ) { { test_and_set_bit(event, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); return; } } static struct BCState *Sel_BCS___0(struct IsdnCardState *cs , int channel ) { { if (cs->bcs[0].mode != 0 && cs->bcs[0].channel == channel) { return ((struct BCState *)(& cs->bcs)); } else if (cs->bcs[1].mode != 0 && cs->bcs[1].channel == channel) { return ((struct BCState *)(& cs->bcs) + 1UL); } else { return (0); } } } static void hfcpci_clear_fifo_rx(struct IsdnCardState *cs , int fifo ) { u_char fifo_state ; bzfifo_type *bzr ; { if (fifo != 0) { bzr = & ((fifo_area *)cs->hw.hfcpci.fifos)->b_chans.rxbz_b2; fifo_state = (unsigned int )cs->hw.hfcpci.fifo_en & 8U; } else { bzr = & ((fifo_area *)cs->hw.hfcpci.fifos)->b_chans.rxbz_b1; fifo_state = (unsigned int )cs->hw.hfcpci.fifo_en & 2U; } if ((unsigned int )fifo_state != 0U) { cs->hw.hfcpci.fifo_en = (int )cs->hw.hfcpci.fifo_en ^ (int )fifo_state; } else { } *(cs->hw.hfcpci.pci_io + 68UL) = cs->hw.hfcpci.fifo_en; cs->hw.hfcpci.last_bfifo_cnt[fifo] = 0; bzr->za[31].z1 = 8191U; bzr->za[31].z2 = bzr->za[31].z1; bzr->f1 = 31U; bzr->f2 = bzr->f1; if ((unsigned int )fifo_state != 0U) { cs->hw.hfcpci.fifo_en = (int )cs->hw.hfcpci.fifo_en | (int )fifo_state; } else { } *(cs->hw.hfcpci.pci_io + 68UL) = cs->hw.hfcpci.fifo_en; return; } } static void hfcpci_clear_fifo_tx(struct IsdnCardState *cs , int fifo ) { u_char fifo_state ; bzfifo_type *bzt ; { if (fifo != 0) { bzt = & ((fifo_area *)cs->hw.hfcpci.fifos)->b_chans.txbz_b2; fifo_state = (unsigned int )cs->hw.hfcpci.fifo_en & 4U; } else { bzt = & ((fifo_area *)cs->hw.hfcpci.fifos)->b_chans.txbz_b1; fifo_state = (unsigned int )cs->hw.hfcpci.fifo_en & 1U; } if ((unsigned int )fifo_state != 0U) { cs->hw.hfcpci.fifo_en = (int )cs->hw.hfcpci.fifo_en ^ (int )fifo_state; } else { } *(cs->hw.hfcpci.pci_io + 68UL) = cs->hw.hfcpci.fifo_en; bzt->za[31].z1 = 8191U; bzt->za[31].z2 = bzt->za[31].z1; bzt->f1 = 31U; bzt->f2 = bzt->f1; if ((unsigned int )fifo_state != 0U) { cs->hw.hfcpci.fifo_en = (int )cs->hw.hfcpci.fifo_en | (int )fifo_state; } else { } *(cs->hw.hfcpci.pci_io + 68UL) = cs->hw.hfcpci.fifo_en; return; } } static struct sk_buff *hfcpci_empty_fifo(struct BCState *bcs , bzfifo_type *bz , u_char *bdata , int count ) { u_char *ptr ; u_char *ptr1 ; u_char new_f2 ; struct sk_buff *skb ; struct IsdnCardState *cs ; int total ; int maxlen ; int new_z2 ; z_type *zp ; unsigned char *tmp ; size_t __len ; void *__ret ; size_t __len___0 ; void *__ret___0 ; { cs = bcs->cs; if ((cs->debug & 16) != 0 && (cs->debug & 32) == 0) { debugl1(cs, (char *)"hfcpci_empty_fifo"); } else { } zp = (z_type *)(& bz->za) + (unsigned long )bz->f2; new_z2 = (int )zp->z2 + count; if (new_z2 > 8191) { new_z2 = new_z2 + -7680; } else { } new_f2 = (unsigned int )((u_char )((unsigned int )bz->f2 + 1U)) & 31U; if ((count > 4099 || count <= 3) || (unsigned int )*(bdata + ((unsigned long )zp->z1 + 0xfffffffffffffe00UL)) != 0U) { if (cs->debug & 1) { debugl1(cs, (char *)"hfcpci_empty_fifo: incoming packet invalid length %d or crc", count); } else { } bcs->err_inv = bcs->err_inv + 1; bz->za[(int )new_f2].z2 = (unsigned short )new_z2; bz->f2 = new_f2; skb = 0; } else { skb = dev_alloc_skb((unsigned int )(count + -3)); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { printk("\fHFCPCI: receive out of memory\n"); } else { total = count; count = count + -3; tmp = skb_put(skb, (unsigned int )count); ptr = tmp; if ((int )zp->z2 + count <= 8192) { maxlen = count; } else { maxlen = 8192 - (int )zp->z2; } ptr1 = bdata + ((unsigned long )zp->z2 + 0xfffffffffffffe00UL); __len = (size_t )maxlen; __ret = memcpy((void *)ptr, (void const *)ptr1, __len); count = count - maxlen; if (count != 0) { ptr = ptr + (unsigned long )maxlen; ptr1 = bdata; __len___0 = (size_t )count; __ret___0 = memcpy((void *)ptr, (void const *)ptr1, __len___0); } else { } bz->za[(int )new_f2].z2 = (unsigned short )new_z2; bz->f2 = new_f2; } } return (skb); } } static int receive_dmsg(struct IsdnCardState *cs ) { struct sk_buff *skb ; int maxlen ; int rcnt ; int total ; int count ; u_char *ptr ; u_char *ptr1 ; dfifo_type *df ; z_type *zp ; int tmp ; unsigned char *tmp___0 ; size_t __len ; void *__ret ; size_t __len___0 ; void *__ret___0 ; int tmp___1 ; { count = 5; df = & ((fifo_area *)cs->hw.hfcpci.fifos)->d_chan.d_rx; tmp = test_and_set_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp != 0) { debugl1(cs, (char *)"rec_dmsg blocked"); return (1); } else { } goto ldv_41101; ldv_41100: zp = (z_type *)(& df->za) + ((unsigned long )df->f2 & 15UL); rcnt = (int )zp->z1 - (int )zp->z2; if (rcnt < 0) { rcnt = rcnt + 512; } else { } rcnt = rcnt + 1; if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"hfcpci recd f1(%d) f2(%d) z1(%x) z2(%x) cnt(%d)", (int )df->f1, (int )df->f2, (int )zp->z1, (int )zp->z2, rcnt); } else { } if ((rcnt > 263 || rcnt <= 3) || (unsigned int )df->data[(int )zp->z1] != 0U) { if (cs->debug & 1) { debugl1(cs, (char *)"empty_fifo hfcpci packet inv. len %d or crc %d", rcnt, (int )df->data[(int )zp->z1]); } else { } cs->err_rx = cs->err_rx + 1; df->f2 = (u_char )(((int )((signed char )((unsigned int )df->f2 + 1U)) & 15) | 16); df->za[(int )df->f2 & 15].z2 = (unsigned int )((int )zp->z2 + (int )((unsigned short )rcnt)) & 511U; } else { skb = dev_alloc_skb((unsigned int )(rcnt + -3)); if ((unsigned long )skb != (unsigned long )((struct sk_buff *)0)) { total = rcnt; rcnt = rcnt + -3; tmp___0 = skb_put(skb, (unsigned int )rcnt); ptr = tmp___0; if ((int )zp->z2 + rcnt <= 512) { maxlen = rcnt; } else { maxlen = 512 - (int )zp->z2; } ptr1 = (u_char *)(& df->data) + (unsigned long )zp->z2; __len = (size_t )maxlen; __ret = memcpy((void *)ptr, (void const *)ptr1, __len); rcnt = rcnt - maxlen; if (rcnt != 0) { ptr = ptr + (unsigned long )maxlen; ptr1 = (u_char *)(& df->data); __len___0 = (size_t )rcnt; __ret___0 = memcpy((void *)ptr, (void const *)ptr1, __len___0); } else { } df->f2 = (u_char )(((int )((signed char )((unsigned int )df->f2 + 1U)) & 15) | 16); df->za[(int )df->f2 & 15].z2 = (unsigned int )((int )zp->z2 + (int )((unsigned short )total)) & 511U; skb_queue_tail(& cs->rq, skb); sched_event_D_pci(cs, 0); } else { printk("\fHFC-PCI: D receive out of memory\n"); } } ldv_41101: ; if ((((int )df->f1 ^ (int )df->f2) & 15) != 0) { tmp___1 = count; count = count - 1; if (tmp___1 != 0) { goto ldv_41100; } else { goto ldv_41102; } } else { } ldv_41102: test_and_clear_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); return (1); } } static int hfcpci_empty_fifo_trans(struct BCState *bcs , bzfifo_type *bz , u_char *bdata ) { unsigned short *z1r ; unsigned short *z2r ; int new_z2 ; int fcnt ; int maxlen ; struct sk_buff *skb ; u_char *ptr ; u_char *ptr1 ; unsigned char *tmp ; size_t __len ; void *__ret ; size_t __len___0 ; void *__ret___0 ; { z1r = & bz->za[31].z1; z2r = z1r + 1UL; fcnt = (int )*z1r - (int )*z2r; if (fcnt == 0) { return (0); } else { } if (fcnt <= 0) { fcnt = fcnt + 7680; } else { } if (fcnt > 128) { fcnt = 128; } else { } new_z2 = (int )*z2r + fcnt; if (new_z2 > 8191) { new_z2 = new_z2 + -7680; } else { } skb = dev_alloc_skb((unsigned int )fcnt); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { printk("\fHFCPCI: receive out of memory\n"); } else { tmp = skb_put(skb, (unsigned int )fcnt); ptr = tmp; if ((int )*z2r + fcnt <= 8192) { maxlen = fcnt; } else { maxlen = 8192 - (int )*z2r; } ptr1 = bdata + ((unsigned long )*z2r + 0xfffffffffffffe00UL); __len = (size_t )maxlen; __ret = memcpy((void *)ptr, (void const *)ptr1, __len); fcnt = fcnt - maxlen; if (fcnt != 0) { ptr = ptr + (unsigned long )maxlen; ptr1 = bdata; __len___0 = (size_t )fcnt; __ret___0 = memcpy((void *)ptr, (void const *)ptr1, __len___0); } else { } skb_queue_tail(& bcs->rqueue, skb); hfcpci_sched_event(bcs, 0); } *z2r = (unsigned short )new_z2; return (1); } } static void main_rec_hfcpci(struct BCState *bcs ) { struct IsdnCardState *cs ; int rcnt ; int real_fifo ; int receive ; int count ; struct sk_buff *skb ; bzfifo_type *bz ; u_char *bdata ; z_type *zp ; int tmp ; { cs = bcs->cs; count = 5; if (bcs->channel != 0 && (unsigned int )cs->hw.hfcpci.bswapped == 0U) { bz = & ((fifo_area *)cs->hw.hfcpci.fifos)->b_chans.rxbz_b2; bdata = (u_char *)(& ((fifo_area *)cs->hw.hfcpci.fifos)->b_chans.rxdat_b2); real_fifo = 1; } else { bz = & ((fifo_area *)cs->hw.hfcpci.fifos)->b_chans.rxbz_b1; bdata = (u_char *)(& ((fifo_area *)cs->hw.hfcpci.fifos)->b_chans.rxdat_b1); real_fifo = 0; } Begin: count = count - 1; tmp = test_and_set_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp != 0) { debugl1(cs, (char *)"rec_data %d blocked", bcs->channel); return; } else { } if ((int )bz->f1 != (int )bz->f2) { if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"hfcpci rec %d f1(%d) f2(%d)", bcs->channel, (int )bz->f1, (int )bz->f2); } else { } zp = (z_type *)(& bz->za) + (unsigned long )bz->f2; rcnt = (int )zp->z1 - (int )zp->z2; if (rcnt < 0) { rcnt = rcnt + 7680; } else { } rcnt = rcnt + 1; if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"hfcpci rec %d z1(%x) z2(%x) cnt(%d)", bcs->channel, (int )zp->z1, (int )zp->z2, rcnt); } else { } skb = hfcpci_empty_fifo(bcs, bz, bdata, rcnt); if ((unsigned long )skb != (unsigned long )((struct sk_buff *)0)) { skb_queue_tail(& bcs->rqueue, skb); hfcpci_sched_event(bcs, 0); } else { } rcnt = (int )bz->f1 - (int )bz->f2; if (rcnt < 0) { rcnt = rcnt + 32; } else { } if (cs->hw.hfcpci.last_bfifo_cnt[real_fifo] > rcnt + 1) { rcnt = 0; hfcpci_clear_fifo_rx(cs, real_fifo); } else { } cs->hw.hfcpci.last_bfifo_cnt[real_fifo] = rcnt; if (rcnt > 1) { receive = 1; } else { receive = 0; } } else if (bcs->mode == 1) { receive = hfcpci_empty_fifo_trans(bcs, bz, bdata); } else { receive = 0; } test_and_clear_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); if (count != 0 && receive != 0) { goto Begin; } else { } return; } } static void hfcpci_fill_dfifo(struct IsdnCardState *cs ) { int fcnt ; int count ; int new_z1 ; int maxlen ; dfifo_type *df ; u_char *src ; u_char *dst ; u_char new_f1 ; size_t __len ; void *__ret ; size_t __len___0 ; void *__ret___0 ; { if ((unsigned long )cs->tx_skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } if ((cs->tx_skb)->len == 0U) { return; } else { } df = & ((fifo_area *)cs->hw.hfcpci.fifos)->d_chan.d_tx; if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"hfcpci_fill_Dfifo f1(%d) f2(%d) z1(f1)(%x)", (int )df->f1, (int )df->f2, (int )df->za[(int )df->f1 & 15].z1); } else { } fcnt = (int )df->f1 - (int )df->f2; if (fcnt < 0) { fcnt = fcnt + 16; } else { } if (fcnt > 14) { if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"hfcpci_fill_Dfifo more as 14 frames"); } else { } cs->err_tx = cs->err_tx + 1; return; } else { } count = ((int )df->za[(int )df->f2 & 15].z2 - (int )df->za[(int )df->f1 & 15].z1) + -1; if (count <= 0) { count = count + 512; } else { } if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"hfcpci_fill_Dfifo count(%u/%d)", (cs->tx_skb)->len, count); } else { } if ((unsigned int )count < (cs->tx_skb)->len) { if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"hfcpci_fill_Dfifo no fifo mem"); } else { } return; } else { } count = (int )(cs->tx_skb)->len; new_z1 = ((int )df->za[(int )df->f1 & 15].z1 + count) & 511; new_f1 = (u_char )(((int )((signed char )((unsigned int )df->f1 + 1U)) & 15) | 16); src = (cs->tx_skb)->data; dst = (u_char *)(& df->data) + (unsigned long )df->za[(int )df->f1 & 15].z1; maxlen = 512 - (int )df->za[(int )df->f1 & 15].z1; if (maxlen > count) { maxlen = count; } else { } __len = (size_t )maxlen; __ret = memcpy((void *)dst, (void const *)src, __len); count = count - maxlen; if (count != 0) { dst = (u_char *)(& df->data); src = src + (unsigned long )maxlen; __len___0 = (size_t )count; __ret___0 = memcpy((void *)dst, (void const *)src, __len___0); } else { } df->za[(int )new_f1 & 15].z1 = (unsigned short )new_z1; df->za[(int )df->f1 & 15].z1 = (unsigned short )new_z1; df->f1 = new_f1; dev_kfree_skb_any(cs->tx_skb); cs->tx_skb = 0; return; } } static void hfcpci_fill_fifo(struct BCState *bcs ) { struct IsdnCardState *cs ; int maxlen ; int fcnt ; int count ; int new_z1 ; bzfifo_type *bz ; u_char *bdata ; u_char new_f1 ; u_char *src ; u_char *dst ; unsigned short *z1t ; unsigned short *z2t ; size_t __len ; void *__ret ; size_t __len___0 ; void *__ret___0 ; u_long flags ; raw_spinlock_t *tmp ; int tmp___0 ; struct task_struct *tmp___1 ; size_t __len___1 ; void *__ret___1 ; size_t __len___2 ; void *__ret___2 ; u_long flags___0 ; raw_spinlock_t *tmp___2 ; int tmp___3 ; { cs = bcs->cs; if ((unsigned long )bcs->tx_skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } if ((bcs->tx_skb)->len == 0U) { return; } else { } if (bcs->channel != 0 && (unsigned int )cs->hw.hfcpci.bswapped == 0U) { bz = & ((fifo_area *)cs->hw.hfcpci.fifos)->b_chans.txbz_b2; bdata = (u_char *)(& ((fifo_area *)cs->hw.hfcpci.fifos)->b_chans.txdat_b2); } else { bz = & ((fifo_area *)cs->hw.hfcpci.fifos)->b_chans.txbz_b1; bdata = (u_char *)(& ((fifo_area *)cs->hw.hfcpci.fifos)->b_chans.txdat_b1); } if (bcs->mode == 1) { z1t = & bz->za[31].z1; z2t = z1t + 1UL; if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"hfcpci_fill_fifo_trans %d z1(%x) z2(%x)", bcs->channel, (int )*z1t, (int )*z2t); } else { } fcnt = (int )*z2t - (int )*z1t; if (fcnt <= 0) { fcnt = fcnt + 7680; } else { } fcnt = 7680 - fcnt; goto ldv_41178; ldv_41177: ; if ((bcs->tx_skb)->len < (unsigned int )(7680 - fcnt)) { count = (int )(bcs->tx_skb)->len; new_z1 = (int )*z1t + count; if (new_z1 > 8191) { new_z1 = new_z1 + -7680; } else { } src = (bcs->tx_skb)->data; dst = bdata + ((unsigned long )*z1t + 0xfffffffffffffe00UL); maxlen = 8192 - (int )*z1t; if (maxlen > count) { maxlen = count; } else { } __len = (size_t )maxlen; __ret = memcpy((void *)dst, (void const *)src, __len); count = count - maxlen; if (count != 0) { dst = bdata; src = src + (unsigned long )maxlen; __len___0 = (size_t )count; __ret___0 = memcpy((void *)dst, (void const *)src, __len___0); } else { } bcs->tx_cnt = (int )((unsigned int )bcs->tx_cnt - (bcs->tx_skb)->len); fcnt = (int )((bcs->tx_skb)->len + (unsigned int )fcnt); *z1t = (unsigned short )new_z1; } else if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"hfcpci_fill_fifo_trans %d frame length %d discarded", bcs->channel, (bcs->tx_skb)->len); } else { } tmp___0 = constant_test_bit(1U, (unsigned long const volatile *)(& (bcs->st)->lli.flag)); if (tmp___0 != 0 && (unsigned int )*((unsigned char *)bcs->tx_skb + 125UL) != 7U) { tmp = spinlock_check(& bcs->aclock); flags = _raw_spin_lock_irqsave(tmp); bcs->ackcnt = (int )((unsigned int )bcs->ackcnt + (bcs->tx_skb)->len); spin_unlock_irqrestore(& bcs->aclock, flags); test_and_set_bit(2, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } dev_kfree_skb_any(bcs->tx_skb); bcs->tx_skb = skb_dequeue(& bcs->squeue); ldv_41178: ; if (fcnt <= 255 && (unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { goto ldv_41177; } else { } test_and_clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); return; } else { } if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"hfcpci_fill_fifo_hdlc %d f1(%d) f2(%d) z1(f1)(%x)", bcs->channel, (int )bz->f1, (int )bz->f2, (int )bz->za[(int )bz->f1].z1); } else { } fcnt = (int )bz->f1 - (int )bz->f2; if (fcnt < 0) { fcnt = fcnt + 32; } else { } if (fcnt > 30) { if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"hfcpci_fill_Bfifo more as 14 frames"); } else { } return; } else { } count = ((int )bz->za[(int )bz->f2].z2 - (int )bz->za[(int )bz->f1].z1) + -1; if (count <= 0) { count = count + 7680; } else { } if ((cs->debug & 16) != 0) { tmp___1 = get_current(); debugl1(cs, (char *)"hfcpci_fill_fifo %d count(%u/%d),%lx", bcs->channel, (bcs->tx_skb)->len, count, tmp___1->state); } else { } if ((unsigned int )count < (bcs->tx_skb)->len) { if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"hfcpci_fill_fifo no fifo mem"); } else { } return; } else { } count = (int )(bcs->tx_skb)->len; new_z1 = (int )bz->za[(int )bz->f1].z1 + count; if (new_z1 > 8191) { new_z1 = new_z1 + -7680; } else { } new_f1 = (unsigned int )((u_char )((unsigned int )bz->f1 + 1U)) & 31U; src = (bcs->tx_skb)->data; dst = bdata + ((unsigned long )bz->za[(int )bz->f1].z1 + 0xfffffffffffffe00UL); maxlen = 8192 - (int )bz->za[(int )bz->f1].z1; if (maxlen > count) { maxlen = count; } else { } __len___1 = (size_t )maxlen; __ret___1 = memcpy((void *)dst, (void const *)src, __len___1); count = count - maxlen; if (count != 0) { dst = bdata; src = src + (unsigned long )maxlen; __len___2 = (size_t )count; __ret___2 = memcpy((void *)dst, (void const *)src, __len___2); } else { } bcs->tx_cnt = (int )((unsigned int )bcs->tx_cnt - (bcs->tx_skb)->len); tmp___3 = constant_test_bit(1U, (unsigned long const volatile *)(& (bcs->st)->lli.flag)); if (tmp___3 != 0 && (unsigned int )*((unsigned char *)bcs->tx_skb + 125UL) != 7U) { tmp___2 = spinlock_check(& bcs->aclock); flags___0 = _raw_spin_lock_irqsave(tmp___2); bcs->ackcnt = (int )((unsigned int )bcs->ackcnt + (bcs->tx_skb)->len); spin_unlock_irqrestore(& bcs->aclock, flags___0); test_and_set_bit(2, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } bz->za[(int )new_f1].z1 = (unsigned short )new_z1; bz->f1 = new_f1; dev_kfree_skb_any(bcs->tx_skb); bcs->tx_skb = 0; test_and_clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); return; } } static void dch_nt_l2l1(struct PStack *st , int pr , void *arg ) { struct IsdnCardState *cs ; { cs = (struct IsdnCardState *)st->l1.hardware; switch (pr) { case 288: ; case 304: ; case 306: (*(st->l1.l1hw))(st, pr, arg); goto ldv_41199; case 256: (*(st->l1.l1l2))(st, 257, 0); goto ldv_41199; case 320: ; if ((int )((long )arg) & 1) { debugl1(cs, (char *)"PH_TEST_LOOP B1"); } else { } if (((long )arg & 2L) != 0L) { debugl1(cs, (char *)"PH_TEST_LOOP B2"); } else { } if (((long )arg & 3L) == 0L) { debugl1(cs, (char *)"PH_TEST_LOOP DISABLED"); } else { } (*(st->l1.l1hw))(st, 112, arg); goto ldv_41199; default: ; if (cs->debug != 0) { debugl1(cs, (char *)"dch_nt_l2l1 msg %04X unhandled", pr); } else { } goto ldv_41199; } ldv_41199: ; return; } } static int hfcpci_auxcmd(struct IsdnCardState *cs , isdn_ctrl *ic ) { u_long flags ; int i ; raw_spinlock_t *tmp ; raw_spinlock_t *tmp___0 ; { i = (int )*((unsigned int *)(& ic->parm.num)); if (ic->arg == 98UL && ((int )cs->hw.hfcpci.int_m1 & 27) == 0) { tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); *(cs->hw.hfcpci.pci_io + 220UL) = 108U; *(cs->hw.hfcpci.pci_io + 192UL) = 16U; __const_udelay(42950UL); cs->hw.hfcpci.sctrl = (unsigned int )cs->hw.hfcpci.sctrl | 4U; *(cs->hw.hfcpci.pci_io + 196UL) = cs->hw.hfcpci.sctrl; __const_udelay(42950UL); *(cs->hw.hfcpci.pci_io + 192UL) = 17U; __const_udelay(42950UL); *(cs->hw.hfcpci.pci_io + 192UL) = 97U; cs->dc.hfcpci.ph_state = 1; cs->hw.hfcpci.nt_mode = 1U; cs->hw.hfcpci.nt_timer = 0; (cs->stlist)->l2.l2l1 = & dch_nt_l2l1; spin_unlock_irqrestore(& cs->lock, flags); debugl1(cs, (char *)"NT mode activated"); return (0); } else { } if (((cs->chanlimit > 1 || (unsigned int )cs->hw.hfcpci.bswapped != 0U) || (unsigned int )cs->hw.hfcpci.nt_mode != 0U) || ic->arg != 12UL) { return (-22); } else { } tmp___0 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___0); if (i != 0) { cs->logecho = 1; cs->hw.hfcpci.trm = (unsigned int )cs->hw.hfcpci.trm | 32U; cs->hw.hfcpci.int_m1 = (unsigned int )cs->hw.hfcpci.int_m1 | 16U; cs->hw.hfcpci.fifo_en = (unsigned int )cs->hw.hfcpci.fifo_en | 8U; } else { cs->logecho = 0; cs->hw.hfcpci.trm = (unsigned int )cs->hw.hfcpci.trm & 223U; cs->hw.hfcpci.int_m1 = (unsigned int )cs->hw.hfcpci.int_m1 & 239U; cs->hw.hfcpci.fifo_en = (unsigned int )cs->hw.hfcpci.fifo_en & 247U; } cs->hw.hfcpci.sctrl_r = (unsigned int )cs->hw.hfcpci.sctrl_r & 253U; cs->hw.hfcpci.sctrl = (unsigned int )cs->hw.hfcpci.sctrl & 253U; cs->hw.hfcpci.conn = (unsigned int )cs->hw.hfcpci.conn | 16U; cs->hw.hfcpci.ctmt = (unsigned int )cs->hw.hfcpci.ctmt & 253U; *(cs->hw.hfcpci.pci_io + 100UL) = cs->hw.hfcpci.ctmt; *(cs->hw.hfcpci.pci_io + 204UL) = cs->hw.hfcpci.sctrl_r; *(cs->hw.hfcpci.pci_io + 196UL) = cs->hw.hfcpci.sctrl; *(cs->hw.hfcpci.pci_io + 188UL) = cs->hw.hfcpci.conn; *(cs->hw.hfcpci.pci_io + 72UL) = cs->hw.hfcpci.trm; *(cs->hw.hfcpci.pci_io + 68UL) = cs->hw.hfcpci.fifo_en; *(cs->hw.hfcpci.pci_io + 104UL) = cs->hw.hfcpci.int_m1; spin_unlock_irqrestore(& cs->lock, flags); return (0); } } static void receive_emsg(struct IsdnCardState *cs ) { int rcnt ; int receive ; int count ; bzfifo_type *bz ; u_char *bdata ; z_type *zp ; u_char *ptr ; u_char *ptr1 ; u_char new_f2 ; int total ; int maxlen ; int new_z2 ; u_char e_buffer[256U] ; int tmp ; size_t __len ; void *__ret ; size_t __len___0 ; void *__ret___0 ; u_char *tmp___0 ; u_char *tmp___1 ; u_char *tmp___2 ; u_char *tmp___3 ; u_char *tmp___4 ; int tmp___5 ; u_char *tmp___6 ; { count = 5; bz = & ((fifo_area *)cs->hw.hfcpci.fifos)->b_chans.rxbz_b2; bdata = (u_char *)(& ((fifo_area *)cs->hw.hfcpci.fifos)->b_chans.rxdat_b2); Begin: count = count - 1; tmp = test_and_set_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp != 0) { debugl1(cs, (char *)"echo_rec_data blocked"); return; } else { } if ((int )bz->f1 != (int )bz->f2) { if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"hfcpci e_rec f1(%d) f2(%d)", (int )bz->f1, (int )bz->f2); } else { } zp = (z_type *)(& bz->za) + (unsigned long )bz->f2; rcnt = (int )zp->z1 - (int )zp->z2; if (rcnt < 0) { rcnt = rcnt + 7680; } else { } rcnt = rcnt + 1; if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"hfcpci e_rec z1(%x) z2(%x) cnt(%d)", (int )zp->z1, (int )zp->z2, rcnt); } else { } new_z2 = (int )zp->z2 + rcnt; if (new_z2 > 8191) { new_z2 = new_z2 + -7680; } else { } new_f2 = (unsigned int )((u_char )((unsigned int )bz->f2 + 1U)) & 31U; if ((rcnt > 259 || count <= 3) || (unsigned int )*(bdata + ((unsigned long )zp->z1 + 0xfffffffffffffe00UL)) != 0U) { if (cs->debug & 1) { debugl1(cs, (char *)"hfcpci_empty_echan: incoming packet invalid length %d or crc", rcnt); } else { } bz->za[(int )new_f2].z2 = (unsigned short )new_z2; bz->f2 = new_f2; } else { total = rcnt; rcnt = rcnt + -3; ptr = (u_char *)(& e_buffer); if ((unsigned int )zp->z2 <= 8192U) { maxlen = rcnt; } else { maxlen = 8192 - (int )zp->z2; } ptr1 = bdata + ((unsigned long )zp->z2 + 0xfffffffffffffe00UL); __len = (size_t )maxlen; __ret = memcpy((void *)ptr, (void const *)ptr1, __len); rcnt = rcnt - maxlen; if (rcnt != 0) { ptr = ptr + (unsigned long )maxlen; ptr1 = bdata; __len___0 = (size_t )rcnt; __ret___0 = memcpy((void *)ptr, (void const *)ptr1, __len___0); } else { } bz->za[(int )new_f2].z2 = (unsigned short )new_z2; bz->f2 = new_f2; if ((cs->debug & 1024) != 0) { ptr = (u_char *)cs->dlog; if (total + -3 <= 671) { tmp___0 = ptr; ptr = ptr + 1; *tmp___0 = 69U; tmp___1 = ptr; ptr = ptr + 1; *tmp___1 = 67U; tmp___2 = ptr; ptr = ptr + 1; *tmp___2 = 72U; tmp___3 = ptr; ptr = ptr + 1; *tmp___3 = 79U; tmp___4 = ptr; ptr = ptr + 1; *tmp___4 = 58U; tmp___5 = QuickHex((char *)ptr, (u_char *)(& e_buffer), total + -3); ptr = ptr + (unsigned long )tmp___5; ptr = ptr - 1; tmp___6 = ptr; ptr = ptr + 1; *tmp___6 = 10U; *ptr = 0U; HiSax_putstatus(cs, 0, cs->dlog); } else { HiSax_putstatus(cs, (char *)"LogEcho: ", (char *)"warning Frame too big (%d)", total + -3); } } else { } } rcnt = (int )bz->f1 - (int )bz->f2; if (rcnt < 0) { rcnt = rcnt + 32; } else { } if (rcnt > 1) { receive = 1; } else { receive = 0; } } else { receive = 0; } test_and_clear_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); if (count != 0 && receive != 0) { goto Begin; } else { } return; } } static irqreturn_t hfcpci_interrupt(int intno , void *dev_id ) { u_long flags ; struct IsdnCardState *cs ; u_char exval ; struct BCState *bcs ; int count ; u_char val ; u_char stat ; raw_spinlock_t *tmp ; int tmp___0 ; int tmp___1 ; int tmp___2 ; int tmp___3 ; struct sk_buff *tmp___4 ; int tmp___5 ; int tmp___6 ; struct sk_buff *tmp___7 ; int tmp___8 ; int tmp___9 ; int tmp___10 ; int tmp___11 ; struct sk_buff *tmp___12 ; int tmp___13 ; { cs = (struct IsdnCardState *)dev_id; count = 15; if (((int )cs->hw.hfcpci.int_m2 & 8) == 0) { debugl1(cs, (char *)"HFC-PCI: int_m2 %x not initialised", (int )cs->hw.hfcpci.int_m2); return (0); } else { } tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); stat = *(cs->hw.hfcpci.pci_io + 112UL); if ((int )((signed char )stat) < 0) { val = *(cs->hw.hfcpci.pci_io + 120UL); if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"HFC-PCI: stat(%02x) s1(%02x)", (int )stat, (int )val); } else { } } else { spin_unlock_irqrestore(& cs->lock, flags); return (0); } if ((cs->debug & 4) != 0) { tmp___0 = constant_test_bit(7U, (unsigned long const volatile *)(& cs->HW_Flags)); debugl1(cs, (char *)"HFC-PCI irq %x %s", (int )val, tmp___0 != 0 ? (char *)"locked" : (char *)"unlocked"); } else { } val = (u_char )((int )cs->hw.hfcpci.int_m1 & (int )val); if (((int )val & 64) != 0) { exval = (unsigned int )*(cs->hw.hfcpci.pci_io + 192UL) & 15U; if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"ph_state chg %d->%d", cs->dc.hfcpci.ph_state, (int )exval); } else { } cs->dc.hfcpci.ph_state = (int )exval; sched_event_D_pci(cs, 2); val = (unsigned int )val & 191U; } else { } if ((int )((signed char )val) < 0) { if ((unsigned int )cs->hw.hfcpci.nt_mode != 0U) { cs->hw.hfcpci.nt_timer = cs->hw.hfcpci.nt_timer - 1; if (cs->hw.hfcpci.nt_timer < 0) { sched_event_D_pci(cs, 2); } else { } } else { } val = (unsigned int )val & 127U; *(cs->hw.hfcpci.pci_io + 100UL) = (u_char )((unsigned int )cs->hw.hfcpci.ctmt | 128U); } else { } goto ldv_41254; ldv_41253: tmp___1 = constant_test_bit(7U, (unsigned long const volatile *)(& cs->HW_Flags)); if (tmp___1 != 0) { cs->hw.hfcpci.int_s1 = (int )cs->hw.hfcpci.int_s1 | (int )val; spin_unlock_irqrestore(& cs->lock, flags); return (1); } else { } if (((int )cs->hw.hfcpci.int_s1 & 24) != 0) { exval = val; val = cs->hw.hfcpci.int_s1; cs->hw.hfcpci.int_s1 = exval; } else { } if (((int )val & 8) != 0) { bcs = Sel_BCS___0(cs, (unsigned int )cs->hw.hfcpci.bswapped != 0U); if ((unsigned long )bcs == (unsigned long )((struct BCState *)0)) { if (cs->debug != 0) { debugl1(cs, (char *)"hfcpci spurious 0x08 IRQ"); } else { main_rec_hfcpci(bcs); } } else { } } else { } if (((int )val & 16) != 0) { if (cs->logecho != 0) { receive_emsg(cs); } else { bcs = Sel_BCS___0(cs, 1); if ((unsigned long )bcs == (unsigned long )((struct BCState *)0)) { if (cs->debug != 0) { debugl1(cs, (char *)"hfcpci spurious 0x10 IRQ"); } else { main_rec_hfcpci(bcs); } } else { } } } else { } if ((int )val & 1) { bcs = Sel_BCS___0(cs, (unsigned int )cs->hw.hfcpci.bswapped != 0U); if ((unsigned long )bcs == (unsigned long )((struct BCState *)0)) { if (cs->debug != 0) { debugl1(cs, (char *)"hfcpci spurious 0x01 IRQ"); } else if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { tmp___2 = test_and_set_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___2 == 0) { hfcpci_fill_fifo(bcs); test_and_clear_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); } else { debugl1(cs, (char *)"fill_data %d blocked", bcs->channel); } } else { tmp___4 = skb_dequeue(& bcs->squeue); bcs->tx_skb = tmp___4; if ((unsigned long )tmp___4 != (unsigned long )((struct sk_buff *)0)) { tmp___3 = test_and_set_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___3 == 0) { hfcpci_fill_fifo(bcs); test_and_clear_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); } else { debugl1(cs, (char *)"fill_data %d blocked", bcs->channel); } } else { hfcpci_sched_event(bcs, 1); } } } else { } } else { } if (((int )val & 2) != 0) { bcs = Sel_BCS___0(cs, 1); if ((unsigned long )bcs == (unsigned long )((struct BCState *)0)) { if (cs->debug != 0) { debugl1(cs, (char *)"hfcpci spurious 0x02 IRQ"); } else if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { tmp___5 = test_and_set_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___5 == 0) { hfcpci_fill_fifo(bcs); test_and_clear_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); } else { debugl1(cs, (char *)"fill_data %d blocked", bcs->channel); } } else { tmp___7 = skb_dequeue(& bcs->squeue); bcs->tx_skb = tmp___7; if ((unsigned long )tmp___7 != (unsigned long )((struct sk_buff *)0)) { tmp___6 = test_and_set_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___6 == 0) { hfcpci_fill_fifo(bcs); test_and_clear_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); } else { debugl1(cs, (char *)"fill_data %d blocked", bcs->channel); } } else { hfcpci_sched_event(bcs, 1); } } } else { } } else { } if (((int )val & 32) != 0) { receive_dmsg(cs); } else { } if (((int )val & 4) != 0) { tmp___8 = test_and_clear_bit(6, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___8 != 0) { del_timer(& cs->dbusytimer); } else { } tmp___9 = test_and_clear_bit(5, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___9 != 0) { sched_event_D_pci(cs, 3); } else { } if ((unsigned long )cs->tx_skb != (unsigned long )((struct sk_buff *)0)) { if ((cs->tx_skb)->len != 0U) { tmp___10 = test_and_set_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___10 == 0) { hfcpci_fill_dfifo(cs); test_and_clear_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); } else { debugl1(cs, (char *)"hfcpci_fill_dfifo irq blocked"); } goto afterXPR; } else { dev_kfree_skb_irq(cs->tx_skb); cs->tx_cnt = 0; cs->tx_skb = 0; } } else { } tmp___12 = skb_dequeue(& cs->sq); cs->tx_skb = tmp___12; if ((unsigned long )tmp___12 != (unsigned long )((struct sk_buff *)0)) { cs->tx_cnt = 0; tmp___11 = test_and_set_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___11 == 0) { hfcpci_fill_dfifo(cs); test_and_clear_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); } else { debugl1(cs, (char *)"hfcpci_fill_dfifo irq blocked"); } } else { sched_event_D_pci(cs, 1); } } else { } afterXPR: ; if ((unsigned int )cs->hw.hfcpci.int_s1 != 0U) { tmp___13 = count; count = count - 1; if (tmp___13 != 0) { val = cs->hw.hfcpci.int_s1; cs->hw.hfcpci.int_s1 = 0U; if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"HFC-PCI irq %x loop %d", (int )val, 15 - count); } else { } } else { val = 0U; } } else { val = 0U; } ldv_41254: ; if ((unsigned int )val != 0U) { goto ldv_41253; } else { } spin_unlock_irqrestore(& cs->lock, flags); return (1); } } static void hfcpci_dbusy_timer(struct IsdnCardState *cs ) { { return; } } static void HFCPCI_l1hw(struct PStack *st , int pr , void *arg ) { u_long flags ; struct IsdnCardState *cs ; struct sk_buff *skb ; raw_spinlock_t *tmp ; int tmp___0 ; raw_spinlock_t *tmp___1 ; int tmp___2 ; raw_spinlock_t *tmp___3 ; raw_spinlock_t *tmp___4 ; raw_spinlock_t *tmp___5 ; raw_spinlock_t *tmp___6 ; raw_spinlock_t *tmp___7 ; { cs = (struct IsdnCardState *)st->l1.hardware; skb = (struct sk_buff *)arg; switch (pr) { case 288: ; if ((cs->debug & 1024) != 0) { LogFrame(cs, skb->data, (int )skb->len); } else { } if ((cs->debug & 2048) != 0) { dlogframe(cs, skb, 0); } else { } tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); if ((unsigned long )cs->tx_skb != (unsigned long )((struct sk_buff *)0)) { skb_queue_tail(& cs->sq, skb); if ((cs->debug & 64) != 0) { Logl2Frame(cs, skb, (char *)"PH_DATA Queued", 0); } else { } } else { cs->tx_skb = skb; cs->tx_cnt = 0; if ((cs->debug & 64) != 0) { Logl2Frame(cs, skb, (char *)"PH_DATA", 0); } else { } tmp___0 = test_and_set_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___0 == 0) { hfcpci_fill_dfifo(cs); test_and_clear_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); } else { debugl1(cs, (char *)"hfcpci_fill_dfifo blocked"); } } spin_unlock_irqrestore(& cs->lock, flags); goto ldv_41271; case 306: tmp___1 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___1); if ((unsigned long )cs->tx_skb != (unsigned long )((struct sk_buff *)0)) { if (cs->debug & 1) { debugl1(cs, (char *)" l2l1 tx_skb exist this shouldn\'t happen"); } else { } skb_queue_tail(& cs->sq, skb); spin_unlock_irqrestore(& cs->lock, flags); goto ldv_41271; } else { } if ((cs->debug & 1024) != 0) { LogFrame(cs, skb->data, (int )skb->len); } else { } if ((cs->debug & 2048) != 0) { dlogframe(cs, skb, 0); } else { } cs->tx_skb = skb; cs->tx_cnt = 0; if ((cs->debug & 64) != 0) { Logl2Frame(cs, skb, (char *)"PH_DATA_PULLED", 0); } else { } tmp___2 = test_and_set_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___2 == 0) { hfcpci_fill_dfifo(cs); test_and_clear_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); } else { debugl1(cs, (char *)"hfcpci_fill_dfifo blocked"); } spin_unlock_irqrestore(& cs->lock, flags); goto ldv_41271; case 304: ; if ((cs->debug & 64) != 0) { debugl1(cs, (char *)"-> PH_REQUEST_PULL"); } else { } if ((unsigned long )cs->tx_skb == (unsigned long )((struct sk_buff *)0)) { test_and_clear_bit(6, (unsigned long volatile *)(& st->l1.Flags)); (*(st->l1.l1l2))(st, 305, 0); } else { test_and_set_bit(6, (unsigned long volatile *)(& st->l1.Flags)); } goto ldv_41271; case 4: tmp___3 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___3); *(cs->hw.hfcpci.pci_io + 192UL) = 19U; __const_udelay(25770UL); *(cs->hw.hfcpci.pci_io + 192UL) = 3U; cs->hw.hfcpci.mst_m = (unsigned int )cs->hw.hfcpci.mst_m | 1U; *(cs->hw.hfcpci.pci_io + 184UL) = cs->hw.hfcpci.mst_m; *(cs->hw.hfcpci.pci_io + 192UL) = 96U; spin_unlock_irqrestore(& cs->lock, flags); l1_msg(cs, 9, 0); goto ldv_41271; case 0: tmp___4 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___4); *(cs->hw.hfcpci.pci_io + 192UL) = 64U; spin_unlock_irqrestore(& cs->lock, flags); goto ldv_41271; case 24: tmp___5 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___5); cs->hw.hfcpci.mst_m = (unsigned int )cs->hw.hfcpci.mst_m & 254U; *(cs->hw.hfcpci.pci_io + 184UL) = cs->hw.hfcpci.mst_m; spin_unlock_irqrestore(& cs->lock, flags); goto ldv_41271; case 48: tmp___6 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___6); cs->hw.hfcpci.mst_m = (unsigned int )cs->hw.hfcpci.mst_m | 1U; *(cs->hw.hfcpci.pci_io + 184UL) = cs->hw.hfcpci.mst_m; spin_unlock_irqrestore(& cs->lock, flags); goto ldv_41271; case 112: tmp___7 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___7); switch ((long )arg) { case 1L: *(cs->hw.hfcpci.pci_io + 128UL) = 128U; *(cs->hw.hfcpci.pci_io + 144UL) = 128U; cs->hw.hfcpci.conn = (unsigned char )(((int )((signed char )cs->hw.hfcpci.conn) & -8) | 1); *(cs->hw.hfcpci.pci_io + 188UL) = cs->hw.hfcpci.conn; goto ldv_41298; case 2L: *(cs->hw.hfcpci.pci_io + 132UL) = 129U; *(cs->hw.hfcpci.pci_io + 148UL) = 129U; cs->hw.hfcpci.conn = (unsigned char )(((int )((signed char )cs->hw.hfcpci.conn) & -57) | 8); *(cs->hw.hfcpci.pci_io + 188UL) = cs->hw.hfcpci.conn; goto ldv_41298; default: spin_unlock_irqrestore(& cs->lock, flags); if (cs->debug & 1) { debugl1(cs, (char *)"hfcpci_l1hw loop invalid %4lx", (long )arg); } else { } return; } ldv_41298: cs->hw.hfcpci.trm = (unsigned int )cs->hw.hfcpci.trm | 128U; *(cs->hw.hfcpci.pci_io + 72UL) = cs->hw.hfcpci.trm; spin_unlock_irqrestore(& cs->lock, flags); goto ldv_41271; default: ; if (cs->debug & 1) { debugl1(cs, (char *)"hfcpci_l1hw unknown pr %4x", pr); } else { } goto ldv_41271; } ldv_41271: ; return; } } static void setstack_hfcpci(struct PStack *st , struct IsdnCardState *cs ) { { st->l1.l1hw = & HFCPCI_l1hw; return; } } static void hfcpci_send_data(struct BCState *bcs ) { struct IsdnCardState *cs ; int tmp ; { cs = bcs->cs; tmp = test_and_set_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp == 0) { hfcpci_fill_fifo(bcs); test_and_clear_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); } else { debugl1(cs, (char *)"send_data %d blocked", bcs->channel); } return; } } static void mode_hfcpci(struct BCState *bcs , int mode , int bc ) { struct IsdnCardState *cs ; int fifo2 ; { cs = bcs->cs; if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HFCPCI bchannel mode %d bchan %d/%d", mode, bc, bcs->channel); } else { } bcs->mode = mode; bcs->channel = bc; fifo2 = bc; if (cs->chanlimit > 1) { cs->hw.hfcpci.bswapped = 0U; cs->hw.hfcpci.sctrl_e = (unsigned int )cs->hw.hfcpci.sctrl_e & 127U; } else if (bc != 0) { if (mode != 0) { cs->hw.hfcpci.bswapped = 1U; cs->hw.hfcpci.sctrl_e = (unsigned int )cs->hw.hfcpci.sctrl_e | 128U; } else { cs->hw.hfcpci.bswapped = 0U; cs->hw.hfcpci.sctrl_e = (unsigned int )cs->hw.hfcpci.sctrl_e & 127U; } fifo2 = 0; } else { cs->hw.hfcpci.bswapped = 0U; cs->hw.hfcpci.sctrl_e = (unsigned int )cs->hw.hfcpci.sctrl_e & 127U; } switch (mode) { case 0: ; if (bc != 0) { cs->hw.hfcpci.sctrl = (unsigned int )cs->hw.hfcpci.sctrl & 253U; cs->hw.hfcpci.sctrl_r = (unsigned int )cs->hw.hfcpci.sctrl_r & 253U; } else { cs->hw.hfcpci.sctrl = (unsigned int )cs->hw.hfcpci.sctrl & 254U; cs->hw.hfcpci.sctrl_r = (unsigned int )cs->hw.hfcpci.sctrl_r & 254U; } if (fifo2 != 0) { cs->hw.hfcpci.fifo_en = (unsigned int )cs->hw.hfcpci.fifo_en & 243U; cs->hw.hfcpci.int_m1 = (unsigned int )cs->hw.hfcpci.int_m1 & 237U; } else { cs->hw.hfcpci.fifo_en = (unsigned int )cs->hw.hfcpci.fifo_en & 252U; cs->hw.hfcpci.int_m1 = (unsigned int )cs->hw.hfcpci.int_m1 & 246U; } goto ldv_41318; case 1: hfcpci_clear_fifo_rx(cs, fifo2); hfcpci_clear_fifo_tx(cs, fifo2); if (bc != 0) { cs->hw.hfcpci.sctrl = (unsigned int )cs->hw.hfcpci.sctrl | 2U; cs->hw.hfcpci.sctrl_r = (unsigned int )cs->hw.hfcpci.sctrl_r | 2U; } else { cs->hw.hfcpci.sctrl = (unsigned int )cs->hw.hfcpci.sctrl | 1U; cs->hw.hfcpci.sctrl_r = (unsigned int )cs->hw.hfcpci.sctrl_r | 1U; } if (fifo2 != 0) { cs->hw.hfcpci.fifo_en = (unsigned int )cs->hw.hfcpci.fifo_en | 12U; cs->hw.hfcpci.int_m1 = (unsigned int )cs->hw.hfcpci.int_m1 | 18U; cs->hw.hfcpci.ctmt = (unsigned int )cs->hw.hfcpci.ctmt | 2U; cs->hw.hfcpci.conn = (unsigned int )cs->hw.hfcpci.conn & 231U; } else { cs->hw.hfcpci.fifo_en = (unsigned int )cs->hw.hfcpci.fifo_en | 3U; cs->hw.hfcpci.int_m1 = (unsigned int )cs->hw.hfcpci.int_m1 | 9U; cs->hw.hfcpci.ctmt = (unsigned int )cs->hw.hfcpci.ctmt | 1U; cs->hw.hfcpci.conn = (unsigned int )cs->hw.hfcpci.conn & 252U; } goto ldv_41318; case 2: hfcpci_clear_fifo_rx(cs, fifo2); hfcpci_clear_fifo_tx(cs, fifo2); if (bc != 0) { cs->hw.hfcpci.sctrl = (unsigned int )cs->hw.hfcpci.sctrl | 2U; cs->hw.hfcpci.sctrl_r = (unsigned int )cs->hw.hfcpci.sctrl_r | 2U; } else { cs->hw.hfcpci.sctrl = (unsigned int )cs->hw.hfcpci.sctrl | 1U; cs->hw.hfcpci.sctrl_r = (unsigned int )cs->hw.hfcpci.sctrl_r | 1U; } if (fifo2 != 0) { cs->hw.hfcpci.last_bfifo_cnt[1] = 0; cs->hw.hfcpci.fifo_en = (unsigned int )cs->hw.hfcpci.fifo_en | 12U; cs->hw.hfcpci.int_m1 = (unsigned int )cs->hw.hfcpci.int_m1 | 18U; cs->hw.hfcpci.ctmt = (unsigned int )cs->hw.hfcpci.ctmt & 253U; cs->hw.hfcpci.conn = (unsigned int )cs->hw.hfcpci.conn & 231U; } else { cs->hw.hfcpci.last_bfifo_cnt[0] = 0; cs->hw.hfcpci.fifo_en = (unsigned int )cs->hw.hfcpci.fifo_en | 3U; cs->hw.hfcpci.int_m1 = (unsigned int )cs->hw.hfcpci.int_m1 | 9U; cs->hw.hfcpci.ctmt = (unsigned int )cs->hw.hfcpci.ctmt & 254U; cs->hw.hfcpci.conn = (unsigned int )cs->hw.hfcpci.conn & 252U; } goto ldv_41318; case 3: ; if (bc != 0) { cs->hw.hfcpci.conn = (unsigned int )cs->hw.hfcpci.conn | 16U; cs->hw.hfcpci.sctrl = (unsigned int )cs->hw.hfcpci.sctrl | 2U; cs->hw.hfcpci.sctrl_r = (unsigned int )cs->hw.hfcpci.sctrl_r | 2U; cs->hw.hfcpci.fifo_en = (unsigned int )cs->hw.hfcpci.fifo_en & 243U; cs->hw.hfcpci.int_m1 = (unsigned int )cs->hw.hfcpci.int_m1 & 237U; } else { cs->hw.hfcpci.conn = (unsigned int )cs->hw.hfcpci.conn | 2U; cs->hw.hfcpci.sctrl = (unsigned int )cs->hw.hfcpci.sctrl | 1U; cs->hw.hfcpci.sctrl_r = (unsigned int )cs->hw.hfcpci.sctrl_r | 1U; cs->hw.hfcpci.fifo_en = (unsigned int )cs->hw.hfcpci.fifo_en & 252U; cs->hw.hfcpci.int_m1 = (unsigned int )cs->hw.hfcpci.int_m1 & 246U; } goto ldv_41318; } ldv_41318: *(cs->hw.hfcpci.pci_io + 200UL) = cs->hw.hfcpci.sctrl_e; *(cs->hw.hfcpci.pci_io + 104UL) = cs->hw.hfcpci.int_m1; *(cs->hw.hfcpci.pci_io + 68UL) = cs->hw.hfcpci.fifo_en; *(cs->hw.hfcpci.pci_io + 196UL) = cs->hw.hfcpci.sctrl; *(cs->hw.hfcpci.pci_io + 204UL) = cs->hw.hfcpci.sctrl_r; *(cs->hw.hfcpci.pci_io + 100UL) = cs->hw.hfcpci.ctmt; *(cs->hw.hfcpci.pci_io + 188UL) = cs->hw.hfcpci.conn; return; } } static void hfcpci_l2l1(struct PStack *st , int pr , void *arg ) { struct BCState *bcs ; u_long flags ; struct sk_buff *skb ; raw_spinlock_t *tmp ; raw_spinlock_t *tmp___0 ; raw_spinlock_t *tmp___1 ; raw_spinlock_t *tmp___2 ; { bcs = st->l1.bcs; skb = (struct sk_buff *)arg; switch (pr) { case 288: tmp = spinlock_check(& (bcs->cs)->lock); flags = _raw_spin_lock_irqsave(tmp); if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { skb_queue_tail(& bcs->squeue, skb); } else { bcs->tx_skb = skb; (*((bcs->cs)->BC_Send_Data))(bcs); } spin_unlock_irqrestore(& (bcs->cs)->lock, flags); goto ldv_41334; case 306: tmp___0 = spinlock_check(& (bcs->cs)->lock); flags = _raw_spin_lock_irqsave(tmp___0); if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { spin_unlock_irqrestore(& (bcs->cs)->lock, flags); printk("\fhfc_l2l1: this shouldn\'t happen\n"); goto ldv_41334; } else { } bcs->tx_skb = skb; (*((bcs->cs)->BC_Send_Data))(bcs); spin_unlock_irqrestore(& (bcs->cs)->lock, flags); goto ldv_41334; case 304: ; if ((unsigned long )bcs->tx_skb == (unsigned long )((struct sk_buff *)0)) { test_and_clear_bit(6, (unsigned long volatile *)(& st->l1.Flags)); (*(st->l1.l1l2))(st, 305, 0); } else { test_and_set_bit(6, (unsigned long volatile *)(& st->l1.Flags)); } goto ldv_41334; case 256: tmp___1 = spinlock_check(& (bcs->cs)->lock); flags = _raw_spin_lock_irqsave(tmp___1); test_and_set_bit(2, (unsigned long volatile *)(& bcs->Flag)); mode_hfcpci(bcs, st->l1.mode, st->l1.bc); spin_unlock_irqrestore(& (bcs->cs)->lock, flags); l1_msg_b(st, pr, arg); goto ldv_41334; case 272: l1_msg_b(st, pr, arg); goto ldv_41334; case 273: tmp___2 = spinlock_check(& (bcs->cs)->lock); flags = _raw_spin_lock_irqsave(tmp___2); test_and_clear_bit(2, (unsigned long volatile *)(& bcs->Flag)); test_and_clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); mode_hfcpci(bcs, 0, st->l1.bc); spin_unlock_irqrestore(& (bcs->cs)->lock, flags); (*(st->l1.l1l2))(st, 273, 0); goto ldv_41334; } ldv_41334: ; return; } } static void close_hfcpci(struct BCState *bcs ) { int tmp ; { mode_hfcpci(bcs, 0, bcs->channel); tmp = test_and_clear_bit(1, (unsigned long volatile *)(& bcs->Flag)); if (tmp != 0) { skb_queue_purge(& bcs->rqueue); skb_queue_purge(& bcs->squeue); if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { dev_kfree_skb_any(bcs->tx_skb); bcs->tx_skb = 0; test_and_clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); } else { } } else { } return; } } static int open_hfcpcistate(struct IsdnCardState *cs , struct BCState *bcs ) { int tmp ; { tmp = test_and_set_bit(1, (unsigned long volatile *)(& bcs->Flag)); if (tmp == 0) { skb_queue_head_init(& bcs->rqueue); skb_queue_head_init(& bcs->squeue); } else { } bcs->tx_skb = 0; test_and_clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); bcs->event = 0UL; bcs->tx_cnt = 0; return (0); } } static int setstack_2b(struct PStack *st , struct BCState *bcs ) { int tmp ; { bcs->channel = st->l1.bc; tmp = open_hfcpcistate((struct IsdnCardState *)st->l1.hardware, bcs); if (tmp != 0) { return (-1); } else { } st->l1.bcs = bcs; st->l2.l2l1 = & hfcpci_l2l1; setstack_manager(st); bcs->st = st; setstack_l1_B(st); return (0); } } static void hfcpci_bh(struct work_struct *work ) { struct IsdnCardState *cs ; struct work_struct const *__mptr ; u_long flags ; raw_spinlock_t *tmp ; int tmp___0 ; int tmp___1 ; int tmp___2 ; { __mptr = (struct work_struct const *)work; cs = (struct IsdnCardState *)__mptr + 0xffffffffffffe728UL; tmp___0 = test_and_clear_bit(2, (unsigned long volatile *)(& cs->event)); if (tmp___0 != 0) { if ((unsigned int )cs->hw.hfcpci.nt_mode == 0U) { switch (cs->dc.hfcpci.ph_state) { case 0: l1_msg(cs, 6, 0); goto ldv_41368; case 3: l1_msg(cs, 26, 0); goto ldv_41368; case 8: l1_msg(cs, 98, 0); goto ldv_41368; case 6: l1_msg(cs, 34, 0); goto ldv_41368; case 7: l1_msg(cs, 66, 0); goto ldv_41368; default: ; goto ldv_41368; } ldv_41368: ; } else { tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); switch (cs->dc.hfcpci.ph_state) { case 2: ; if (cs->hw.hfcpci.nt_timer < 0) { cs->hw.hfcpci.nt_timer = 0; cs->hw.hfcpci.int_m1 = (unsigned int )cs->hw.hfcpci.int_m1 & 127U; *(cs->hw.hfcpci.pci_io + 104UL) = cs->hw.hfcpci.int_m1; *(cs->hw.hfcpci.pci_io + 192UL) = 20U; __const_udelay(42950UL); *(cs->hw.hfcpci.pci_io + 192UL) = 4U; cs->dc.hfcpci.ph_state = 4; } else { cs->hw.hfcpci.int_m1 = (unsigned int )cs->hw.hfcpci.int_m1 | 128U; *(cs->hw.hfcpci.pci_io + 104UL) = cs->hw.hfcpci.int_m1; cs->hw.hfcpci.ctmt = (unsigned int )cs->hw.hfcpci.ctmt & 223U; cs->hw.hfcpci.ctmt = (unsigned int )cs->hw.hfcpci.ctmt | 4U; *(cs->hw.hfcpci.pci_io + 100UL) = (u_char )((unsigned int )cs->hw.hfcpci.ctmt | 128U); *(cs->hw.hfcpci.pci_io + 100UL) = (u_char )((unsigned int )cs->hw.hfcpci.ctmt | 128U); cs->hw.hfcpci.nt_timer = 20; *(cs->hw.hfcpci.pci_io + 192UL) = 130U; } goto ldv_41378; case 1: ; case 3: ; case 4: cs->hw.hfcpci.nt_timer = 0; cs->hw.hfcpci.int_m1 = (unsigned int )cs->hw.hfcpci.int_m1 & 127U; *(cs->hw.hfcpci.pci_io + 104UL) = cs->hw.hfcpci.int_m1; goto ldv_41378; default: ; goto ldv_41378; } ldv_41378: spin_unlock_irqrestore(& cs->lock, flags); } } else { } tmp___1 = test_and_clear_bit(0, (unsigned long volatile *)(& cs->event)); if (tmp___1 != 0) { DChannel_proc_rcv(cs); } else { } tmp___2 = test_and_clear_bit(1, (unsigned long volatile *)(& cs->event)); if (tmp___2 != 0) { DChannel_proc_xmt(cs); } else { } return; } } static void inithfcpci(struct IsdnCardState *cs ) { struct lock_class_key __key ; { cs->bcs[0].BC_SetStack = & setstack_2b; cs->bcs[1].BC_SetStack = & setstack_2b; cs->bcs[0].BC_Close = & close_hfcpci; cs->bcs[1].BC_Close = & close_hfcpci; cs->dbusytimer.function = (void (*)(unsigned long ))(& hfcpci_dbusy_timer); cs->dbusytimer.data = (unsigned long )cs; init_timer_key(& cs->dbusytimer, 0U, "(&cs->dbusytimer)", & __key); mode_hfcpci((struct BCState *)(& cs->bcs), 0, 0); mode_hfcpci((struct BCState *)(& cs->bcs) + 1UL, 0, 1); return; } } static int hfcpci_card_msg(struct IsdnCardState *cs , int mt , void *arg ) { u_long flags ; raw_spinlock_t *tmp ; raw_spinlock_t *tmp___0 ; raw_spinlock_t *tmp___1 ; { if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"HFCPCI: card_msg %x", mt); } else { } switch (mt) { case 240: tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); reset_hfcpci(cs); spin_unlock_irqrestore(& cs->lock, flags); return (0); case 243: release_io_hfcpci(cs); return (0); case 242: tmp___0 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___0); inithfcpci(cs); reset_hfcpci(cs); spin_unlock_irqrestore(& cs->lock, flags); msleep(80U); tmp___1 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___1); cs->hw.hfcpci.int_m1 = (unsigned int )cs->hw.hfcpci.int_m1 & 127U; *(cs->hw.hfcpci.pci_io + 104UL) = cs->hw.hfcpci.int_m1; *(cs->hw.hfcpci.pci_io + 184UL) = cs->hw.hfcpci.mst_m; spin_unlock_irqrestore(& cs->lock, flags); return (0); case 244: ; return (0); } return (0); } } static struct pci_dev *dev_hfcpci = 0; int setup_hfcpci(struct IsdnCard *card ) { u_long flags ; struct IsdnCardState *cs ; char tmp[64U] ; int i ; struct pci_dev *tmp_hfcpci ; char *tmp___0 ; dma_addr_t dma_mask ; int tmp___1 ; int tmp___2 ; int tmp___3 ; void *tmp___4 ; raw_spinlock_t *tmp___5 ; struct lock_class_key __key ; atomic_long_t __constr_expr_0 ; struct lock_class_key __key___0 ; { cs = card->cs; tmp_hfcpci = 0; strcpy((char *)(& tmp), hfcpci_revision); tmp___0 = HiSax_getrev((char const *)(& tmp)); printk("\016HiSax: HFC-PCI driver Rev. %s\n", tmp___0); cs->hw.hfcpci.int_s1 = 0U; cs->dc.hfcpci.ph_state = 0; cs->hw.hfcpci.fifo = 255U; if ((unsigned int )cs->typ != 35U) { return (0); } else { } i = 0; goto ldv_41416; ldv_41418: tmp_hfcpci = hisax_find_pci_device((unsigned int )id_list[i].vendor_id, (unsigned int )id_list[i].device_id, dev_hfcpci); i = i + 1; if ((unsigned long )tmp_hfcpci != (unsigned long )((struct pci_dev *)0)) { dma_mask = 4294934528ULL; tmp___1 = pci_enable_device(tmp_hfcpci); if (tmp___1 != 0) { goto ldv_41416; } else { } tmp___2 = pci_set_dma_mask(tmp_hfcpci, dma_mask); if (tmp___2 != 0) { printk("\fHiSax hfc_pci: No suitable DMA available.\n"); goto ldv_41416; } else { } tmp___3 = pci_set_consistent_dma_mask(tmp_hfcpci, dma_mask); if (tmp___3 != 0) { printk("\fHiSax hfc_pci: No suitable consistent DMA available.\n"); goto ldv_41416; } else { } pci_set_master(tmp_hfcpci); if (card->para[0] != 0UL && (unsigned long long )card->para[0] != (tmp_hfcpci->resource[0].start & 0xfffffffffffffffcULL)) { goto ldv_41416; } else { goto ldv_41417; } } else { } ldv_41416: ; if ((int )id_list[i].vendor_id != 0) { goto ldv_41418; } else { } ldv_41417: ; if ((unsigned long )tmp_hfcpci == (unsigned long )((struct pci_dev *)0)) { printk("\fHFC-PCI: No PCI card found\n"); return (0); } else { } i = i - 1; dev_hfcpci = tmp_hfcpci; cs->hw.hfcpci.dev = dev_hfcpci; cs->irq = dev_hfcpci->irq; if (cs->irq == 0U) { printk("\fHFC-PCI: No IRQ for PCI card found\n"); return (0); } else { } cs->hw.hfcpci.pci_io = (unsigned char *)dev_hfcpci->resource[1].start; printk("\016HiSax: HFC-PCI card manufacturer: %s card name: %s\n", id_list[i].vendor_name, id_list[i].card_name); if ((unsigned long )cs->hw.hfcpci.pci_io == (unsigned long )((unsigned char *)0)) { printk("\fHFC-PCI: No IO-Mem for PCI card found\n"); return (0); } else { } cs->hw.hfcpci.fifos = pci_alloc_consistent(cs->hw.hfcpci.dev, 32768UL, & cs->hw.hfcpci.dma); if ((unsigned long )cs->hw.hfcpci.fifos == (unsigned long )((void *)0)) { printk("\fHFC-PCI: Error allocating FIFO memory!\n"); return (0); } else { } if ((cs->hw.hfcpci.dma & 32767ULL) != 0ULL) { printk("\fHFC-PCI: Error DMA memory not on 32K boundary (%lx)\n", (unsigned long )cs->hw.hfcpci.dma); pci_free_consistent(cs->hw.hfcpci.dev, 32768UL, cs->hw.hfcpci.fifos, cs->hw.hfcpci.dma); return (0); } else { } pci_write_config_dword((struct pci_dev const *)cs->hw.hfcpci.dev, 128, (unsigned int )cs->hw.hfcpci.dma); tmp___4 = ioremap((resource_size_t )cs->hw.hfcpci.pci_io, 256UL); cs->hw.hfcpci.pci_io = (unsigned char *)tmp___4; printk("\016HFC-PCI: defined at mem %p fifo %p(%lx) IRQ %d HZ %d\n", cs->hw.hfcpci.pci_io, cs->hw.hfcpci.fifos, (unsigned long )cs->hw.hfcpci.dma, cs->irq, 250); tmp___5 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___5); pci_write_config_word((struct pci_dev const *)cs->hw.hfcpci.dev, 4, 2); cs->hw.hfcpci.int_m2 = 0U; cs->hw.hfcpci.int_m1 = 0U; *(cs->hw.hfcpci.pci_io + 104UL) = cs->hw.hfcpci.int_m1; *(cs->hw.hfcpci.pci_io + 108UL) = cs->hw.hfcpci.int_m2; __init_work(& cs->tqueue, 0); __constr_expr_0.counter = 4195328L; cs->tqueue.data = __constr_expr_0; lockdep_init_map(& cs->tqueue.lockdep_map, "(&cs->tqueue)", & __key, 0); INIT_LIST_HEAD(& cs->tqueue.entry); cs->tqueue.func = & hfcpci_bh; cs->setstack_d = & setstack_hfcpci; cs->BC_Send_Data = & hfcpci_send_data; cs->readisac = 0; cs->writeisac = 0; cs->readisacfifo = 0; cs->writeisacfifo = 0; cs->BC_Read_Reg = 0; cs->BC_Write_Reg = 0; cs->irq_func = & hfcpci_interrupt; cs->irq_flags = cs->irq_flags | 128UL; cs->hw.hfcpci.timer.function = (void (*)(unsigned long ))(& hfcpci_Timer); cs->hw.hfcpci.timer.data = (unsigned long )cs; init_timer_key(& cs->hw.hfcpci.timer, 0U, "(&cs->hw.hfcpci.timer)", & __key___0); cs->cardmsg = & hfcpci_card_msg; cs->auxcmd = & hfcpci_auxcmd; spin_unlock_irqrestore(& cs->lock, flags); return (1); } } void ldv_mutex_lock_407(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_lock(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_408(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_lock(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_409(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } int ldv_mutex_trylock_410(struct mutex *ldv_func_arg1 ) { ldv_func_ret_type___2 ldv_func_res ; int tmp ; int tmp___0 ; { tmp = mutex_trylock(ldv_func_arg1); ldv_func_res = tmp; tmp___0 = ldv_mutex_trylock_mutex(ldv_func_arg1); return (tmp___0); return (ldv_func_res); } } void ldv_mutex_unlock_411(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_412(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_cred_guard_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_413(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_cred_guard_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } int ldv_mutex_trylock_424(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_422(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_425(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_427(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_421(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_423(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_426(struct mutex *ldv_func_arg1 ) ; static char const *hfcsx_revision = "$Revision: 1.12.2.5 $"; static u_char ccd_sp_irqtab[16U] = { 0U, 0U, 0U, 7U, 0U, 1U, 0U, 0U, 0U, 2U, 3U, 4U, 5U, 0U, 0U, 6U}; __inline static void Write_hfc(struct IsdnCardState *cs , u_char regnum , u_char val ) { { outb((int )regnum, (int )((unsigned int )cs->hw.hfcsx.base + 1U)); outb((int )val, (int )cs->hw.hfcsx.base); return; } } __inline static u_char Read_hfc(struct IsdnCardState *cs , u_char regnum ) { u_char ret ; { outb((int )regnum, (int )((unsigned int )cs->hw.hfcsx.base + 1U)); ret = inb((int )cs->hw.hfcsx.base); return (ret); } } static void fifo_select(struct IsdnCardState *cs , u_char fifo ) { unsigned char tmp ; unsigned char tmp___0 ; { if ((int )cs->hw.hfcsx.last_fifo == (int )fifo) { return; } else { } outb(16, (int )((unsigned int )cs->hw.hfcsx.base + 1U)); outb((int )fifo, (int )cs->hw.hfcsx.base); goto ldv_41277; ldv_41276: ; ldv_41277: tmp = inb((int )((unsigned int )cs->hw.hfcsx.base + 1U)); if ((int )tmp & 1) { goto ldv_41276; } else { } __const_udelay(17180UL); outb((int )fifo, (int )cs->hw.hfcsx.base); goto ldv_41280; ldv_41279: ; ldv_41280: tmp___0 = inb((int )((unsigned int )cs->hw.hfcsx.base + 1U)); if ((int )tmp___0 & 1) { goto ldv_41279; } else { } return; } } static void reset_fifo(struct IsdnCardState *cs , u_char fifo ) { unsigned char tmp ; { fifo_select(cs, (int )fifo); outb(24, (int )((unsigned int )cs->hw.hfcsx.base + 1U)); outb((int )((unsigned int )cs->hw.hfcsx.cirm | 128U), (int )cs->hw.hfcsx.base); __const_udelay(4295UL); goto ldv_41287; ldv_41286: ; ldv_41287: tmp = inb((int )((unsigned int )cs->hw.hfcsx.base + 1U)); if ((int )tmp & 1) { goto ldv_41286; } else { } return; } } static int write_fifo___1(struct IsdnCardState *cs , struct sk_buff *skb , u_char fifo , int trans_max ) { unsigned short *msp ; int fifo_size ; int count ; int z1 ; int z2 ; u_char f_msk ; u_char f1 ; u_char f2 ; u_char *src ; u_char tmp ; u_char tmp___0 ; u_char tmp___1 ; u_char tmp___2 ; u_char *tmp___3 ; int tmp___4 ; u_char tmp___5 ; u_char tmp___6 ; u_char *tmp___7 ; int tmp___8 ; unsigned char tmp___9 ; { if (skb->len == 0U) { return (0); } else { } if ((int )fifo & 1) { return (0); } else { } fifo_select(cs, (int )fifo); if (((int )fifo & 4) != 0) { fifo_size = 512; f_msk = 15U; if (trans_max != 0) { return (0); } else { } } else { fifo_size = cs->hw.hfcsx.b_fifo_size; f_msk = 31U; } tmp = Read_hfc(cs, 132); z1 = (int )tmp; tmp___0 = Read_hfc(cs, 128); z1 = (z1 << 8) | (int )tmp___0; if (trans_max != 0) { tmp___1 = Read_hfc(cs, 140); z2 = (int )tmp___1; tmp___2 = Read_hfc(cs, 136); z2 = (z2 << 8) | (int )tmp___2; count = z2 - z1; if (count <= 0) { count = count + fifo_size; } else { } if ((unsigned int )count < skb->len + 1U) { return (0); } else { } count = fifo_size - count; if (trans_max * 2 < count) { return (0); } else { } count = (int )skb->len; src = skb->data; goto ldv_41305; ldv_41304: tmp___3 = src; src = src + 1; Write_hfc(cs, 172, (int )*tmp___3); ldv_41305: tmp___4 = count; count = count - 1; if (tmp___4 != 0) { goto ldv_41304; } else { } return (1); } else { } msp = (unsigned short *)(& ((struct hfcsx_extra *)cs->hw.hfcsx.extra)->marker); msp = msp + (unsigned long )((((int )fifo >> 1) & 3) * 32); tmp___5 = Read_hfc(cs, 176); f1 = (u_char )((int )tmp___5 & (int )f_msk); tmp___6 = Read_hfc(cs, 180); f2 = (u_char )((int )tmp___6 & (int )f_msk); count = (int )f1 - (int )f2; if (count < 0) { count = ((int )f_msk + 1) + count; } else { } if ((int )f_msk + -1 < count) { if ((cs->debug & 8) != 0) { debugl1(cs, (char *)"hfcsx_write_fifo %d more as %d frames", (int )fifo, (int )f_msk + -1); } else { } return (0); } else { } *(msp + (unsigned long )f1) = (unsigned short )z1; if ((cs->debug & 8) != 0) { debugl1(cs, (char *)"hfcsx_write_fifo %d f1(%x) f2(%x) z1(f1)(%x)", (int )fifo, (int )f1, (int )f2, z1); } else { } count = (int )*(msp + (unsigned long )f2) - z1; if (count <= 0) { count = count + fifo_size; } else { } if ((cs->debug & 8) != 0) { debugl1(cs, (char *)"hfcsx_write_fifo %d count(%u/%d)", (int )fifo, skb->len, count); } else { } if ((unsigned int )count < skb->len) { if ((cs->debug & 8) != 0) { debugl1(cs, (char *)"hfcsx_write_fifo %d no fifo mem", (int )fifo); } else { } return (0); } else { } count = (int )skb->len; src = skb->data; goto ldv_41308; ldv_41307: tmp___7 = src; src = src + 1; Write_hfc(cs, 172, (int )*tmp___7); ldv_41308: tmp___8 = count; count = count - 1; if (tmp___8 != 0) { goto ldv_41307; } else { } Read_hfc(cs, 168); __const_udelay(4295UL); goto ldv_41311; ldv_41310: ; ldv_41311: tmp___9 = inb((int )((unsigned int )cs->hw.hfcsx.base + 1U)); if ((int )tmp___9 & 1) { goto ldv_41310; } else { } return (1); } } static struct sk_buff *read_fifo___1(struct IsdnCardState *cs , u_char fifo , int trans_max ) { int fifo_size ; int count ; int z1 ; int z2 ; u_char f_msk ; u_char f1 ; u_char f2 ; u_char *dst ; struct sk_buff *skb ; u_char tmp ; u_char tmp___0 ; u_char tmp___1 ; u_char tmp___2 ; unsigned char *tmp___3 ; u_char *tmp___4 ; int tmp___5 ; u_char tmp___6 ; u_char tmp___7 ; u_char tmp___8 ; u_char tmp___9 ; u_char tmp___10 ; u_char tmp___11 ; unsigned char *tmp___12 ; u_char *tmp___13 ; int tmp___14 ; u_char tmp___15 ; unsigned char tmp___16 ; { if (((int )fifo & 1) == 0) { return (0); } else { } fifo_select(cs, (int )fifo); if (((int )fifo & 4) != 0) { fifo_size = 512; f_msk = 15U; if (trans_max != 0) { return (0); } else { } } else { fifo_size = cs->hw.hfcsx.b_fifo_size; f_msk = 31U; } if (trans_max != 0) { tmp = Read_hfc(cs, 132); z1 = (int )tmp; tmp___0 = Read_hfc(cs, 128); z1 = (z1 << 8) | (int )tmp___0; tmp___1 = Read_hfc(cs, 140); z2 = (int )tmp___1; tmp___2 = Read_hfc(cs, 136); z2 = (z2 << 8) | (int )tmp___2; count = z1 - z2; if (count <= 0) { count = count + fifo_size; } else { } count = count + 1; if (count > trans_max) { count = trans_max; } else { } skb = dev_alloc_skb((unsigned int )count); if ((unsigned long )skb != (unsigned long )((struct sk_buff *)0)) { tmp___3 = skb_put(skb, (unsigned int )count); dst = tmp___3; goto ldv_41328; ldv_41327: tmp___4 = dst; dst = dst + 1; *tmp___4 = Read_hfc(cs, 188); ldv_41328: tmp___5 = count; count = count - 1; if (tmp___5 != 0) { goto ldv_41327; } else { } return (skb); } else { return (0); } } else { } ldv_41339: tmp___6 = Read_hfc(cs, 176); f1 = (u_char )((int )tmp___6 & (int )f_msk); tmp___7 = Read_hfc(cs, 180); f2 = (u_char )((int )tmp___7 & (int )f_msk); if ((int )f1 == (int )f2) { return (0); } else { } tmp___8 = Read_hfc(cs, 132); z1 = (int )tmp___8; tmp___9 = Read_hfc(cs, 128); z1 = (z1 << 8) | (int )tmp___9; tmp___10 = Read_hfc(cs, 140); z2 = (int )tmp___10; tmp___11 = Read_hfc(cs, 136); z2 = (z2 << 8) | (int )tmp___11; if ((cs->debug & 8) != 0) { debugl1(cs, (char *)"hfcsx_read_fifo %d f1(%x) f2(%x) z1(f2)(%x) z2(f2)(%x)", (int )fifo, (int )f1, (int )f2, z1, z2); } else { } count = z1 - z2; if (count <= 0) { count = count + fifo_size; } else { } count = count + 1; if ((cs->debug & 8) != 0) { debugl1(cs, (char *)"hfcsx_read_fifo %d count %u)", (int )fifo, count); } else { } if (count > fifo_size || count <= 3) { if (cs->debug & 1) { debugl1(cs, (char *)"hfcsx_read_fifo %d packet inv. len %d ", (int )fifo, count); } else { } goto ldv_41331; ldv_41330: count = count - 1; Read_hfc(cs, 188); ldv_41331: ; if (count != 0) { goto ldv_41330; } else { } skb = 0; } else { skb = dev_alloc_skb((unsigned int )(count + -3)); if ((unsigned long )skb != (unsigned long )((struct sk_buff *)0)) { count = count + -3; tmp___12 = skb_put(skb, (unsigned int )count); dst = tmp___12; goto ldv_41334; ldv_41333: tmp___13 = dst; dst = dst + 1; *tmp___13 = Read_hfc(cs, 188); ldv_41334: tmp___14 = count; count = count - 1; if (tmp___14 != 0) { goto ldv_41333; } else { } Read_hfc(cs, 188); Read_hfc(cs, 188); tmp___15 = Read_hfc(cs, 188); if ((unsigned int )tmp___15 != 0U) { dev_kfree_skb_irq(skb); if ((cs->debug & 8) != 0) { debugl1(cs, (char *)"hfcsx_read_fifo %d crc error", (int )fifo); } else { } skb = 0; } else { } } else { printk("\fHFC-SX: receive out of memory\n"); return (0); } } Read_hfc(cs, 184); __const_udelay(4295UL); goto ldv_41337; ldv_41336: ; ldv_41337: tmp___16 = inb((int )((unsigned int )cs->hw.hfcsx.base + 1U)); if ((int )tmp___16 & 1) { goto ldv_41336; } else { } __const_udelay(4295UL); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { goto ldv_41339; } else { } return (skb); } } static void release_io_hfcsx(struct IsdnCardState *cs ) { { cs->hw.hfcsx.int_m2 = 0U; Write_hfc(cs, 27, (int )cs->hw.hfcsx.int_m2); Write_hfc(cs, 24, 8); msleep(30U); Write_hfc(cs, 24, 0); del_timer(& cs->hw.hfcsx.timer); __release_region(& ioport_resource, (resource_size_t )cs->hw.hfcsx.base, 2ULL); kfree((void const *)cs->hw.hfcsx.extra); cs->hw.hfcsx.extra = 0; return; } } static int set_fifo_size(struct IsdnCardState *cs ) { { if (cs->hw.hfcsx.b_fifo_size != 0) { return (1); } else { } if ((unsigned int )((int )cs->hw.hfcsx.chip >> 4) == 9U) { cs->hw.hfcsx.b_fifo_size = 7680; return (1); } else { } cs->hw.hfcsx.b_fifo_size = 1536; cs->hw.hfcsx.cirm = (unsigned int )cs->hw.hfcsx.cirm | 16U; return (0); } } static void reset_hfcsx(struct IsdnCardState *cs ) { unsigned long __ms ; unsigned long tmp ; unsigned long __ms___0 ; unsigned long tmp___0 ; u_char tmp___1 ; int tmp___2 ; u_char tmp___3 ; u_char tmp___4 ; { cs->hw.hfcsx.int_m2 = 0U; Write_hfc(cs, 27, (int )cs->hw.hfcsx.int_m2); printk("\016HFC_SX: resetting card\n"); ldv_41360: Write_hfc(cs, 24, (int )((unsigned int )cs->hw.hfcsx.cirm | 8U)); __ms = 30UL; goto ldv_41352; ldv_41351: __const_udelay(4295000UL); ldv_41352: tmp = __ms; __ms = __ms - 1UL; if (tmp != 0UL) { goto ldv_41351; } else { } Write_hfc(cs, 24, (int )cs->hw.hfcsx.cirm); __ms___0 = 20UL; goto ldv_41356; ldv_41355: __const_udelay(4295000UL); ldv_41356: tmp___0 = __ms___0; __ms___0 = __ms___0 - 1UL; if (tmp___0 != 0UL) { goto ldv_41355; } else { } tmp___1 = Read_hfc(cs, 28); if (((int )tmp___1 & 2) != 0) { printk("\fHFC-SX init bit busy\n"); } else { } cs->hw.hfcsx.last_fifo = 255U; tmp___2 = set_fifo_size(cs); if (tmp___2 == 0) { goto ldv_41358; } else { } goto ldv_41359; ldv_41358: ; goto ldv_41360; ldv_41359: cs->hw.hfcsx.trm = 0U; Write_hfc(cs, 18, (int )cs->hw.hfcsx.trm); Write_hfc(cs, 55, 14); cs->hw.hfcsx.sctrl_e = 1U; Write_hfc(cs, 50, (int )cs->hw.hfcsx.sctrl_e); cs->hw.hfcsx.bswapped = 0U; cs->hw.hfcsx.nt_mode = 0U; cs->hw.hfcsx.ctmt = 36U; Write_hfc(cs, 25, (int )cs->hw.hfcsx.ctmt); cs->hw.hfcsx.int_m1 = 228U; Write_hfc(cs, 26, (int )cs->hw.hfcsx.int_m1); tmp___3 = Read_hfc(cs, 30); Write_hfc(cs, 48, 18); __const_udelay(42950UL); Write_hfc(cs, 48, 2); cs->hw.hfcsx.mst_m = 1U; Write_hfc(cs, 46, (int )cs->hw.hfcsx.mst_m); cs->hw.hfcsx.sctrl = 64U; Write_hfc(cs, 49, (int )cs->hw.hfcsx.sctrl); cs->hw.hfcsx.sctrl_r = 0U; Write_hfc(cs, 51, (int )cs->hw.hfcsx.sctrl_r); cs->hw.hfcsx.conn = 54U; Write_hfc(cs, 47, (int )cs->hw.hfcsx.conn); Write_hfc(cs, 32, 128); Write_hfc(cs, 33, 129); Write_hfc(cs, 36, 128); Write_hfc(cs, 37, 129); cs->hw.hfcsx.int_m2 = 8U; Write_hfc(cs, 27, (int )cs->hw.hfcsx.int_m2); tmp___4 = Read_hfc(cs, 31); return; } } static void hfcsx_Timer(struct IsdnCardState *cs ) { { cs->hw.hfcsx.timer.expires = (unsigned long )jiffies + 75UL; return; } } static struct BCState *Sel_BCS___1(struct IsdnCardState *cs , int channel ) { { if (cs->bcs[0].mode != 0 && cs->bcs[0].channel == channel) { return ((struct BCState *)(& cs->bcs)); } else if (cs->bcs[1].mode != 0 && cs->bcs[1].channel == channel) { return ((struct BCState *)(& cs->bcs) + 1UL); } else { return (0); } } } static int receive_dmsg___0(struct IsdnCardState *cs ) { struct sk_buff *skb ; int count ; int tmp ; { count = 5; tmp = test_and_set_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp != 0) { debugl1(cs, (char *)"rec_dmsg blocked"); return (1); } else { } ldv_41373: skb = read_fifo___1(cs, 5, 0); if ((unsigned long )skb != (unsigned long )((struct sk_buff *)0)) { skb_queue_tail(& cs->rq, skb); test_and_set_bit(0, (unsigned long volatile *)(& cs->event)); schedule_work(& cs->tqueue); } else { } count = count - 1; if (count != 0 && (unsigned long )skb != (unsigned long )((struct sk_buff *)0)) { goto ldv_41373; } else { } test_and_clear_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); return (1); } } static void main_rec_hfcsx(struct BCState *bcs ) { struct IsdnCardState *cs ; int count ; struct sk_buff *skb ; int tmp ; { cs = bcs->cs; count = 5; Begin: count = count - 1; tmp = test_and_set_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp != 0) { debugl1(cs, (char *)"rec_data %d blocked", bcs->channel); return; } else { } skb = read_fifo___1(cs, bcs->channel != 0 && (unsigned int )cs->hw.hfcsx.bswapped == 0U ? 3 : 1, bcs->mode == 1 ? 128 : 0); if ((unsigned long )skb != (unsigned long )((struct sk_buff *)0)) { skb_queue_tail(& bcs->rqueue, skb); test_and_set_bit(0, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } test_and_clear_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); if (count != 0 && (unsigned long )skb != (unsigned long )((struct sk_buff *)0)) { goto Begin; } else { } return; } } static void hfcsx_fill_dfifo(struct IsdnCardState *cs ) { int tmp ; { if ((unsigned long )cs->tx_skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } if ((cs->tx_skb)->len == 0U) { return; } else { } tmp = write_fifo___1(cs, cs->tx_skb, 4, 0); if (tmp != 0) { dev_kfree_skb_any(cs->tx_skb); cs->tx_skb = 0; } else { } return; } } static void hfcsx_fill_fifo(struct BCState *bcs ) { struct IsdnCardState *cs ; u_long flags ; raw_spinlock_t *tmp ; int tmp___0 ; int tmp___1 ; { cs = bcs->cs; if ((unsigned long )bcs->tx_skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } if ((bcs->tx_skb)->len == 0U) { return; } else { } tmp___1 = write_fifo___1(cs, bcs->tx_skb, bcs->channel != 0 && (unsigned int )cs->hw.hfcsx.bswapped == 0U ? 2 : 0, bcs->mode == 1 ? 128 : 0); if (tmp___1 != 0) { bcs->tx_cnt = (int )((unsigned int )bcs->tx_cnt - (bcs->tx_skb)->len); tmp___0 = constant_test_bit(1U, (unsigned long const volatile *)(& (bcs->st)->lli.flag)); if (tmp___0 != 0 && (unsigned int )*((unsigned char *)bcs->tx_skb + 125UL) != 7U) { tmp = spinlock_check(& bcs->aclock); flags = _raw_spin_lock_irqsave(tmp); bcs->ackcnt = (int )((unsigned int )bcs->ackcnt + (bcs->tx_skb)->len); spin_unlock_irqrestore(& bcs->aclock, flags); test_and_set_bit(2, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } dev_kfree_skb_any(bcs->tx_skb); bcs->tx_skb = 0; test_and_clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); } else { } return; } } static void dch_nt_l2l1___0(struct PStack *st , int pr , void *arg ) { struct IsdnCardState *cs ; { cs = (struct IsdnCardState *)st->l1.hardware; switch (pr) { case 288: ; case 304: ; case 306: (*(st->l1.l1hw))(st, pr, arg); goto ldv_41402; case 256: (*(st->l1.l1l2))(st, 257, 0); goto ldv_41402; case 320: ; if ((int )((long )arg) & 1) { debugl1(cs, (char *)"PH_TEST_LOOP B1"); } else { } if (((long )arg & 2L) != 0L) { debugl1(cs, (char *)"PH_TEST_LOOP B2"); } else { } if (((long )arg & 3L) == 0L) { debugl1(cs, (char *)"PH_TEST_LOOP DISABLED"); } else { } (*(st->l1.l1hw))(st, 112, arg); goto ldv_41402; default: ; if (cs->debug != 0) { debugl1(cs, (char *)"dch_nt_l2l1 msg %04X unhandled", pr); } else { } goto ldv_41402; } ldv_41402: ; return; } } static int hfcsx_auxcmd(struct IsdnCardState *cs , isdn_ctrl *ic ) { unsigned long flags ; int i ; raw_spinlock_t *tmp ; raw_spinlock_t *tmp___0 ; { i = (int )*((unsigned int *)(& ic->parm.num)); if (ic->arg == 98UL && ((int )cs->hw.hfcsx.int_m1 & 27) == 0) { tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); Write_hfc(cs, 48, 16); __const_udelay(42950UL); cs->hw.hfcsx.sctrl = (unsigned int )cs->hw.hfcsx.sctrl | 4U; Write_hfc(cs, 49, (int )cs->hw.hfcsx.sctrl); __const_udelay(42950UL); Write_hfc(cs, 48, 17); __const_udelay(42950UL); Write_hfc(cs, 48, 97); cs->dc.hfcsx.ph_state = 1; cs->hw.hfcsx.nt_mode = 1U; cs->hw.hfcsx.nt_timer = 0; spin_unlock_irqrestore(& cs->lock, flags); (cs->stlist)->l2.l2l1 = & dch_nt_l2l1___0; debugl1(cs, (char *)"NT mode activated"); return (0); } else { } if (((cs->chanlimit > 1 || (unsigned int )cs->hw.hfcsx.bswapped != 0U) || (unsigned int )cs->hw.hfcsx.nt_mode != 0U) || ic->arg != 12UL) { return (-22); } else { } if (i != 0) { cs->logecho = 1; cs->hw.hfcsx.trm = (unsigned int )cs->hw.hfcsx.trm | 32U; cs->hw.hfcsx.int_m1 = (unsigned int )cs->hw.hfcsx.int_m1 | 16U; } else { cs->logecho = 0; cs->hw.hfcsx.trm = (unsigned int )cs->hw.hfcsx.trm & 223U; cs->hw.hfcsx.int_m1 = (unsigned int )cs->hw.hfcsx.int_m1 & 239U; } cs->hw.hfcsx.sctrl_r = (unsigned int )cs->hw.hfcsx.sctrl_r & 253U; cs->hw.hfcsx.sctrl = (unsigned int )cs->hw.hfcsx.sctrl & 253U; cs->hw.hfcsx.conn = (unsigned int )cs->hw.hfcsx.conn | 16U; cs->hw.hfcsx.ctmt = (unsigned int )cs->hw.hfcsx.ctmt & 253U; tmp___0 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___0); Write_hfc(cs, 25, (int )cs->hw.hfcsx.ctmt); Write_hfc(cs, 51, (int )cs->hw.hfcsx.sctrl_r); Write_hfc(cs, 49, (int )cs->hw.hfcsx.sctrl); Write_hfc(cs, 47, (int )cs->hw.hfcsx.conn); Write_hfc(cs, 18, (int )cs->hw.hfcsx.trm); Write_hfc(cs, 26, (int )cs->hw.hfcsx.int_m1); spin_unlock_irqrestore(& cs->lock, flags); return (0); } } static void receive_emsg___0(struct IsdnCardState *cs ) { int count ; u_char *ptr ; struct sk_buff *skb ; int tmp ; u_char *tmp___0 ; u_char *tmp___1 ; u_char *tmp___2 ; u_char *tmp___3 ; u_char *tmp___4 ; int tmp___5 ; u_char *tmp___6 ; { count = 5; tmp = test_and_set_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp != 0) { debugl1(cs, (char *)"echo_rec_data blocked"); return; } else { } ldv_41424: skb = read_fifo___1(cs, 3, 0); if ((unsigned long )skb != (unsigned long )((struct sk_buff *)0)) { if ((cs->debug & 1024) != 0) { ptr = (u_char *)cs->dlog; if (skb->len <= 671U) { tmp___0 = ptr; ptr = ptr + 1; *tmp___0 = 69U; tmp___1 = ptr; ptr = ptr + 1; *tmp___1 = 67U; tmp___2 = ptr; ptr = ptr + 1; *tmp___2 = 72U; tmp___3 = ptr; ptr = ptr + 1; *tmp___3 = 79U; tmp___4 = ptr; ptr = ptr + 1; *tmp___4 = 58U; tmp___5 = QuickHex((char *)ptr, skb->data, (int )skb->len); ptr = ptr + (unsigned long )tmp___5; ptr = ptr - 1; tmp___6 = ptr; ptr = ptr + 1; *tmp___6 = 10U; *ptr = 0U; HiSax_putstatus(cs, 0, cs->dlog); } else { HiSax_putstatus(cs, (char *)"LogEcho: ", (char *)"warning Frame too big (%d)", skb->len); } } else { } dev_kfree_skb_any(skb); } else { } count = count - 1; if (count != 0 && (unsigned long )skb != (unsigned long )((struct sk_buff *)0)) { goto ldv_41424; } else { } test_and_clear_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); return; } } static irqreturn_t hfcsx_interrupt(int intno , void *dev_id ) { struct IsdnCardState *cs ; u_char exval ; struct BCState *bcs ; int count ; u_long flags ; u_char val ; u_char stat ; raw_spinlock_t *tmp ; int tmp___0 ; u_char tmp___1 ; int tmp___2 ; int tmp___3 ; int tmp___4 ; struct sk_buff *tmp___5 ; int tmp___6 ; int tmp___7 ; struct sk_buff *tmp___8 ; int tmp___9 ; int tmp___10 ; int tmp___11 ; int tmp___12 ; struct sk_buff *tmp___13 ; int tmp___14 ; { cs = (struct IsdnCardState *)dev_id; count = 15; if (((int )cs->hw.hfcsx.int_m2 & 8) == 0) { return (0); } else { } tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); stat = Read_hfc(cs, 28); if ((int )((signed char )stat) < 0) { val = Read_hfc(cs, 30); if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"HFC-SX: stat(%02x) s1(%02x)", (int )stat, (int )val); } else { } } else { spin_unlock_irqrestore(& cs->lock, flags); return (0); } if ((cs->debug & 4) != 0) { tmp___0 = constant_test_bit(7U, (unsigned long const volatile *)(& cs->HW_Flags)); debugl1(cs, (char *)"HFC-SX irq %x %s", (int )val, tmp___0 != 0 ? (char *)"locked" : (char *)"unlocked"); } else { } val = (u_char )((int )cs->hw.hfcsx.int_m1 & (int )val); if (((int )val & 64) != 0) { tmp___1 = Read_hfc(cs, 48); exval = (unsigned int )tmp___1 & 15U; if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"ph_state chg %d->%d", cs->dc.hfcsx.ph_state, (int )exval); } else { } cs->dc.hfcsx.ph_state = (int )exval; test_and_set_bit(2, (unsigned long volatile *)(& cs->event)); schedule_work(& cs->tqueue); val = (unsigned int )val & 191U; } else { } if ((int )((signed char )val) < 0) { if ((unsigned int )cs->hw.hfcsx.nt_mode != 0U) { cs->hw.hfcsx.nt_timer = cs->hw.hfcsx.nt_timer - 1; if (cs->hw.hfcsx.nt_timer < 0) { test_and_set_bit(2, (unsigned long volatile *)(& cs->event)); schedule_work(& cs->tqueue); } else { } } else { } val = (unsigned int )val & 127U; Write_hfc(cs, 25, (int )((unsigned int )cs->hw.hfcsx.ctmt | 128U)); } else { } goto ldv_41442; ldv_41441: tmp___2 = constant_test_bit(7U, (unsigned long const volatile *)(& cs->HW_Flags)); if (tmp___2 != 0) { cs->hw.hfcsx.int_s1 = (int )cs->hw.hfcsx.int_s1 | (int )val; spin_unlock_irqrestore(& cs->lock, flags); return (1); } else { } if (((int )cs->hw.hfcsx.int_s1 & 24) != 0) { exval = val; val = cs->hw.hfcsx.int_s1; cs->hw.hfcsx.int_s1 = exval; } else { } if (((int )val & 8) != 0) { bcs = Sel_BCS___1(cs, (unsigned int )cs->hw.hfcsx.bswapped != 0U); if ((unsigned long )bcs == (unsigned long )((struct BCState *)0)) { if (cs->debug != 0) { debugl1(cs, (char *)"hfcsx spurious 0x08 IRQ"); } else { main_rec_hfcsx(bcs); } } else { } } else { } if (((int )val & 16) != 0) { if (cs->logecho != 0) { receive_emsg___0(cs); } else { bcs = Sel_BCS___1(cs, 1); if ((unsigned long )bcs == (unsigned long )((struct BCState *)0)) { if (cs->debug != 0) { debugl1(cs, (char *)"hfcsx spurious 0x10 IRQ"); } else { main_rec_hfcsx(bcs); } } else { } } } else { } if ((int )val & 1) { bcs = Sel_BCS___1(cs, (unsigned int )cs->hw.hfcsx.bswapped != 0U); if ((unsigned long )bcs == (unsigned long )((struct BCState *)0)) { if (cs->debug != 0) { debugl1(cs, (char *)"hfcsx spurious 0x01 IRQ"); } else if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { tmp___3 = test_and_set_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___3 == 0) { hfcsx_fill_fifo(bcs); test_and_clear_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); } else { debugl1(cs, (char *)"fill_data %d blocked", bcs->channel); } } else { tmp___5 = skb_dequeue(& bcs->squeue); bcs->tx_skb = tmp___5; if ((unsigned long )tmp___5 != (unsigned long )((struct sk_buff *)0)) { tmp___4 = test_and_set_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___4 == 0) { hfcsx_fill_fifo(bcs); test_and_clear_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); } else { debugl1(cs, (char *)"fill_data %d blocked", bcs->channel); } } else { test_and_set_bit(1, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } } } else { } } else { } if (((int )val & 2) != 0) { bcs = Sel_BCS___1(cs, 1); if ((unsigned long )bcs == (unsigned long )((struct BCState *)0)) { if (cs->debug != 0) { debugl1(cs, (char *)"hfcsx spurious 0x02 IRQ"); } else if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { tmp___6 = test_and_set_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___6 == 0) { hfcsx_fill_fifo(bcs); test_and_clear_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); } else { debugl1(cs, (char *)"fill_data %d blocked", bcs->channel); } } else { tmp___8 = skb_dequeue(& bcs->squeue); bcs->tx_skb = tmp___8; if ((unsigned long )tmp___8 != (unsigned long )((struct sk_buff *)0)) { tmp___7 = test_and_set_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___7 == 0) { hfcsx_fill_fifo(bcs); test_and_clear_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); } else { debugl1(cs, (char *)"fill_data %d blocked", bcs->channel); } } else { test_and_set_bit(1, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } } } else { } } else { } if (((int )val & 32) != 0) { receive_dmsg___0(cs); } else { } if (((int )val & 4) != 0) { tmp___9 = test_and_clear_bit(6, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___9 != 0) { del_timer(& cs->dbusytimer); } else { } tmp___10 = test_and_clear_bit(5, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___10 != 0) { test_and_set_bit(3, (unsigned long volatile *)(& cs->event)); schedule_work(& cs->tqueue); } else { } if ((unsigned long )cs->tx_skb != (unsigned long )((struct sk_buff *)0)) { if ((cs->tx_skb)->len != 0U) { tmp___11 = test_and_set_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___11 == 0) { hfcsx_fill_dfifo(cs); test_and_clear_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); } else { debugl1(cs, (char *)"hfcsx_fill_dfifo irq blocked"); } goto afterXPR; } else { dev_kfree_skb_irq(cs->tx_skb); cs->tx_cnt = 0; cs->tx_skb = 0; } } else { } tmp___13 = skb_dequeue(& cs->sq); cs->tx_skb = tmp___13; if ((unsigned long )tmp___13 != (unsigned long )((struct sk_buff *)0)) { cs->tx_cnt = 0; tmp___12 = test_and_set_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___12 == 0) { hfcsx_fill_dfifo(cs); test_and_clear_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); } else { debugl1(cs, (char *)"hfcsx_fill_dfifo irq blocked"); } } else { test_and_set_bit(1, (unsigned long volatile *)(& cs->event)); schedule_work(& cs->tqueue); } } else { } afterXPR: ; if ((unsigned int )cs->hw.hfcsx.int_s1 != 0U) { tmp___14 = count; count = count - 1; if (tmp___14 != 0) { val = cs->hw.hfcsx.int_s1; cs->hw.hfcsx.int_s1 = 0U; if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"HFC-SX irq %x loop %d", (int )val, 15 - count); } else { } } else { val = 0U; } } else { val = 0U; } ldv_41442: ; if ((unsigned int )val != 0U) { goto ldv_41441; } else { } spin_unlock_irqrestore(& cs->lock, flags); return (1); } } static void hfcsx_dbusy_timer(struct IsdnCardState *cs ) { { return; } } static void HFCSX_l1hw(struct PStack *st , int pr , void *arg ) { struct IsdnCardState *cs ; struct sk_buff *skb ; u_long flags ; raw_spinlock_t *tmp ; int tmp___0 ; raw_spinlock_t *tmp___1 ; int tmp___2 ; raw_spinlock_t *tmp___3 ; raw_spinlock_t *tmp___4 ; raw_spinlock_t *tmp___5 ; raw_spinlock_t *tmp___6 ; raw_spinlock_t *tmp___7 ; { cs = (struct IsdnCardState *)st->l1.hardware; skb = (struct sk_buff *)arg; switch (pr) { case 288: ; if ((cs->debug & 1024) != 0) { LogFrame(cs, skb->data, (int )skb->len); } else { } if ((cs->debug & 2048) != 0) { dlogframe(cs, skb, 0); } else { } tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); if ((unsigned long )cs->tx_skb != (unsigned long )((struct sk_buff *)0)) { skb_queue_tail(& cs->sq, skb); if ((cs->debug & 64) != 0) { Logl2Frame(cs, skb, (char *)"PH_DATA Queued", 0); } else { } } else { cs->tx_skb = skb; cs->tx_cnt = 0; if ((cs->debug & 64) != 0) { Logl2Frame(cs, skb, (char *)"PH_DATA", 0); } else { } tmp___0 = test_and_set_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___0 == 0) { hfcsx_fill_dfifo(cs); test_and_clear_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); } else { debugl1(cs, (char *)"hfcsx_fill_dfifo blocked"); } } spin_unlock_irqrestore(& cs->lock, flags); goto ldv_41459; case 306: tmp___1 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___1); if ((unsigned long )cs->tx_skb != (unsigned long )((struct sk_buff *)0)) { if (cs->debug & 1) { debugl1(cs, (char *)" l2l1 tx_skb exist this shouldn\'t happen"); } else { } skb_queue_tail(& cs->sq, skb); spin_unlock_irqrestore(& cs->lock, flags); goto ldv_41459; } else { } if ((cs->debug & 1024) != 0) { LogFrame(cs, skb->data, (int )skb->len); } else { } if ((cs->debug & 2048) != 0) { dlogframe(cs, skb, 0); } else { } cs->tx_skb = skb; cs->tx_cnt = 0; if ((cs->debug & 64) != 0) { Logl2Frame(cs, skb, (char *)"PH_DATA_PULLED", 0); } else { } tmp___2 = test_and_set_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___2 == 0) { hfcsx_fill_dfifo(cs); test_and_clear_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); } else { debugl1(cs, (char *)"hfcsx_fill_dfifo blocked"); } spin_unlock_irqrestore(& cs->lock, flags); goto ldv_41459; case 304: ; if ((cs->debug & 64) != 0) { debugl1(cs, (char *)"-> PH_REQUEST_PULL"); } else { } if ((unsigned long )cs->tx_skb == (unsigned long )((struct sk_buff *)0)) { test_and_clear_bit(6, (unsigned long volatile *)(& st->l1.Flags)); (*(st->l1.l1l2))(st, 305, 0); } else { test_and_set_bit(6, (unsigned long volatile *)(& st->l1.Flags)); } goto ldv_41459; case 4: tmp___3 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___3); Write_hfc(cs, 48, 19); __const_udelay(25770UL); Write_hfc(cs, 48, 3); cs->hw.hfcsx.mst_m = (unsigned int )cs->hw.hfcsx.mst_m | 1U; Write_hfc(cs, 46, (int )cs->hw.hfcsx.mst_m); Write_hfc(cs, 48, 96); spin_unlock_irqrestore(& cs->lock, flags); l1_msg(cs, 9, 0); goto ldv_41459; case 0: tmp___4 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___4); Write_hfc(cs, 48, 96); spin_unlock_irqrestore(& cs->lock, flags); goto ldv_41459; case 24: tmp___5 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___5); cs->hw.hfcsx.mst_m = (unsigned int )cs->hw.hfcsx.mst_m & 254U; Write_hfc(cs, 46, (int )cs->hw.hfcsx.mst_m); spin_unlock_irqrestore(& cs->lock, flags); goto ldv_41459; case 48: tmp___6 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___6); cs->hw.hfcsx.mst_m = (unsigned int )cs->hw.hfcsx.mst_m | 1U; Write_hfc(cs, 46, (int )cs->hw.hfcsx.mst_m); spin_unlock_irqrestore(& cs->lock, flags); goto ldv_41459; case 112: tmp___7 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___7); switch ((long )arg) { case 1L: Write_hfc(cs, 32, 128); Write_hfc(cs, 36, 128); cs->hw.hfcsx.conn = (unsigned char )(((int )((signed char )cs->hw.hfcsx.conn) & -8) | 1); Write_hfc(cs, 47, (int )cs->hw.hfcsx.conn); goto ldv_41486; case 2L: Write_hfc(cs, 33, 129); Write_hfc(cs, 37, 129); cs->hw.hfcsx.conn = (unsigned char )(((int )((signed char )cs->hw.hfcsx.conn) & -57) | 8); Write_hfc(cs, 47, (int )cs->hw.hfcsx.conn); goto ldv_41486; default: spin_unlock_irqrestore(& cs->lock, flags); if (cs->debug & 1) { debugl1(cs, (char *)"hfcsx_l1hw loop invalid %4lx", (unsigned long )arg); } else { } return; } ldv_41486: cs->hw.hfcsx.trm = (unsigned int )cs->hw.hfcsx.trm | 128U; Write_hfc(cs, 18, (int )cs->hw.hfcsx.trm); spin_unlock_irqrestore(& cs->lock, flags); goto ldv_41459; default: ; if (cs->debug & 1) { debugl1(cs, (char *)"hfcsx_l1hw unknown pr %4x", pr); } else { } goto ldv_41459; } ldv_41459: ; return; } } static void setstack_hfcsx(struct PStack *st , struct IsdnCardState *cs ) { { st->l1.l1hw = & HFCSX_l1hw; return; } } static void hfcsx_send_data(struct BCState *bcs ) { struct IsdnCardState *cs ; int tmp ; { cs = bcs->cs; tmp = test_and_set_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp == 0) { hfcsx_fill_fifo(bcs); test_and_clear_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); } else { debugl1(cs, (char *)"send_data %d blocked", bcs->channel); } return; } } static void mode_hfcsx(struct BCState *bcs , int mode , int bc ) { struct IsdnCardState *cs ; int fifo2 ; { cs = bcs->cs; if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HFCSX bchannel mode %d bchan %d/%d", mode, bc, bcs->channel); } else { } bcs->mode = mode; bcs->channel = bc; fifo2 = bc; if (cs->chanlimit > 1) { cs->hw.hfcsx.bswapped = 0U; cs->hw.hfcsx.sctrl_e = (unsigned int )cs->hw.hfcsx.sctrl_e & 127U; } else if (bc != 0) { if (mode != 0) { cs->hw.hfcsx.bswapped = 1U; cs->hw.hfcsx.sctrl_e = (unsigned int )cs->hw.hfcsx.sctrl_e | 128U; } else { cs->hw.hfcsx.bswapped = 0U; cs->hw.hfcsx.sctrl_e = (unsigned int )cs->hw.hfcsx.sctrl_e & 127U; } fifo2 = 0; } else { cs->hw.hfcsx.bswapped = 0U; cs->hw.hfcsx.sctrl_e = (unsigned int )cs->hw.hfcsx.sctrl_e & 127U; } switch (mode) { case 0: ; if (bc != 0) { cs->hw.hfcsx.sctrl = (unsigned int )cs->hw.hfcsx.sctrl & 253U; cs->hw.hfcsx.sctrl_r = (unsigned int )cs->hw.hfcsx.sctrl_r & 253U; } else { cs->hw.hfcsx.sctrl = (unsigned int )cs->hw.hfcsx.sctrl & 254U; cs->hw.hfcsx.sctrl_r = (unsigned int )cs->hw.hfcsx.sctrl_r & 254U; } if (fifo2 != 0) { cs->hw.hfcsx.int_m1 = (unsigned int )cs->hw.hfcsx.int_m1 & 237U; } else { cs->hw.hfcsx.int_m1 = (unsigned int )cs->hw.hfcsx.int_m1 & 246U; } goto ldv_41506; case 1: ; if (bc != 0) { cs->hw.hfcsx.sctrl = (unsigned int )cs->hw.hfcsx.sctrl | 2U; cs->hw.hfcsx.sctrl_r = (unsigned int )cs->hw.hfcsx.sctrl_r | 2U; } else { cs->hw.hfcsx.sctrl = (unsigned int )cs->hw.hfcsx.sctrl | 1U; cs->hw.hfcsx.sctrl_r = (unsigned int )cs->hw.hfcsx.sctrl_r | 1U; } if (fifo2 != 0) { cs->hw.hfcsx.int_m1 = (unsigned int )cs->hw.hfcsx.int_m1 | 18U; cs->hw.hfcsx.ctmt = (unsigned int )cs->hw.hfcsx.ctmt | 2U; cs->hw.hfcsx.conn = (unsigned int )cs->hw.hfcsx.conn & 231U; } else { cs->hw.hfcsx.int_m1 = (unsigned int )cs->hw.hfcsx.int_m1 | 9U; cs->hw.hfcsx.ctmt = (unsigned int )cs->hw.hfcsx.ctmt | 1U; cs->hw.hfcsx.conn = (unsigned int )cs->hw.hfcsx.conn & 252U; } goto ldv_41506; case 2: ; if (bc != 0) { cs->hw.hfcsx.sctrl = (unsigned int )cs->hw.hfcsx.sctrl | 2U; cs->hw.hfcsx.sctrl_r = (unsigned int )cs->hw.hfcsx.sctrl_r | 2U; } else { cs->hw.hfcsx.sctrl = (unsigned int )cs->hw.hfcsx.sctrl | 1U; cs->hw.hfcsx.sctrl_r = (unsigned int )cs->hw.hfcsx.sctrl_r | 1U; } if (fifo2 != 0) { cs->hw.hfcsx.int_m1 = (unsigned int )cs->hw.hfcsx.int_m1 | 18U; cs->hw.hfcsx.ctmt = (unsigned int )cs->hw.hfcsx.ctmt & 253U; cs->hw.hfcsx.conn = (unsigned int )cs->hw.hfcsx.conn & 231U; } else { cs->hw.hfcsx.int_m1 = (unsigned int )cs->hw.hfcsx.int_m1 | 9U; cs->hw.hfcsx.ctmt = (unsigned int )cs->hw.hfcsx.ctmt & 254U; cs->hw.hfcsx.conn = (unsigned int )cs->hw.hfcsx.conn & 252U; } goto ldv_41506; case 3: ; if (bc != 0) { cs->hw.hfcsx.conn = (unsigned int )cs->hw.hfcsx.conn | 16U; cs->hw.hfcsx.sctrl = (unsigned int )cs->hw.hfcsx.sctrl | 2U; cs->hw.hfcsx.sctrl_r = (unsigned int )cs->hw.hfcsx.sctrl_r | 2U; cs->hw.hfcsx.int_m1 = (unsigned int )cs->hw.hfcsx.int_m1 & 237U; } else { cs->hw.hfcsx.conn = (unsigned int )cs->hw.hfcsx.conn | 2U; cs->hw.hfcsx.sctrl = (unsigned int )cs->hw.hfcsx.sctrl | 1U; cs->hw.hfcsx.sctrl_r = (unsigned int )cs->hw.hfcsx.sctrl_r | 1U; cs->hw.hfcsx.int_m1 = (unsigned int )cs->hw.hfcsx.int_m1 & 246U; } goto ldv_41506; } ldv_41506: Write_hfc(cs, 50, (int )cs->hw.hfcsx.sctrl_e); Write_hfc(cs, 26, (int )cs->hw.hfcsx.int_m1); Write_hfc(cs, 49, (int )cs->hw.hfcsx.sctrl); Write_hfc(cs, 51, (int )cs->hw.hfcsx.sctrl_r); Write_hfc(cs, 25, (int )cs->hw.hfcsx.ctmt); Write_hfc(cs, 47, (int )cs->hw.hfcsx.conn); if (mode != 3) { reset_fifo(cs, fifo2 != 0 ? 3 : 1); reset_fifo(cs, fifo2 != 0 ? 2 : 0); } else { } return; } } static void hfcsx_l2l1(struct PStack *st , int pr , void *arg ) { struct BCState *bcs ; struct sk_buff *skb ; u_long flags ; raw_spinlock_t *tmp ; raw_spinlock_t *tmp___0 ; raw_spinlock_t *tmp___1 ; raw_spinlock_t *tmp___2 ; { bcs = st->l1.bcs; skb = (struct sk_buff *)arg; switch (pr) { case 288: tmp = spinlock_check(& (bcs->cs)->lock); flags = _raw_spin_lock_irqsave(tmp); if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { skb_queue_tail(& bcs->squeue, skb); } else { bcs->tx_skb = skb; (*((bcs->cs)->BC_Send_Data))(bcs); } spin_unlock_irqrestore(& (bcs->cs)->lock, flags); goto ldv_41522; case 306: tmp___0 = spinlock_check(& (bcs->cs)->lock); flags = _raw_spin_lock_irqsave(tmp___0); if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { printk("\fhfc_l2l1: this shouldn\'t happen\n"); } else { bcs->tx_skb = skb; (*((bcs->cs)->BC_Send_Data))(bcs); } spin_unlock_irqrestore(& (bcs->cs)->lock, flags); goto ldv_41522; case 304: ; if ((unsigned long )bcs->tx_skb == (unsigned long )((struct sk_buff *)0)) { test_and_clear_bit(6, (unsigned long volatile *)(& st->l1.Flags)); (*(st->l1.l1l2))(st, 305, 0); } else { test_and_set_bit(6, (unsigned long volatile *)(& st->l1.Flags)); } goto ldv_41522; case 256: tmp___1 = spinlock_check(& (bcs->cs)->lock); flags = _raw_spin_lock_irqsave(tmp___1); test_and_set_bit(2, (unsigned long volatile *)(& bcs->Flag)); mode_hfcsx(bcs, st->l1.mode, st->l1.bc); spin_unlock_irqrestore(& (bcs->cs)->lock, flags); l1_msg_b(st, pr, arg); goto ldv_41522; case 272: l1_msg_b(st, pr, arg); goto ldv_41522; case 273: tmp___2 = spinlock_check(& (bcs->cs)->lock); flags = _raw_spin_lock_irqsave(tmp___2); test_and_clear_bit(2, (unsigned long volatile *)(& bcs->Flag)); test_and_clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); mode_hfcsx(bcs, 0, st->l1.bc); spin_unlock_irqrestore(& (bcs->cs)->lock, flags); (*(st->l1.l1l2))(st, 273, 0); goto ldv_41522; } ldv_41522: ; return; } } static void close_hfcsx(struct BCState *bcs ) { int tmp ; { mode_hfcsx(bcs, 0, bcs->channel); tmp = test_and_clear_bit(1, (unsigned long volatile *)(& bcs->Flag)); if (tmp != 0) { skb_queue_purge(& bcs->rqueue); skb_queue_purge(& bcs->squeue); if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { dev_kfree_skb_any(bcs->tx_skb); bcs->tx_skb = 0; test_and_clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); } else { } } else { } return; } } static int open_hfcsxstate(struct IsdnCardState *cs , struct BCState *bcs ) { int tmp ; { tmp = test_and_set_bit(1, (unsigned long volatile *)(& bcs->Flag)); if (tmp == 0) { skb_queue_head_init(& bcs->rqueue); skb_queue_head_init(& bcs->squeue); } else { } bcs->tx_skb = 0; test_and_clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); bcs->event = 0UL; bcs->tx_cnt = 0; return (0); } } static int setstack_2b___0(struct PStack *st , struct BCState *bcs ) { int tmp ; { bcs->channel = st->l1.bc; tmp = open_hfcsxstate((struct IsdnCardState *)st->l1.hardware, bcs); if (tmp != 0) { return (-1); } else { } st->l1.bcs = bcs; st->l2.l2l1 = & hfcsx_l2l1; setstack_manager(st); bcs->st = st; setstack_l1_B(st); return (0); } } static void hfcsx_bh(struct work_struct *work ) { struct IsdnCardState *cs ; struct work_struct const *__mptr ; u_long flags ; raw_spinlock_t *tmp ; u_char tmp___0 ; raw_spinlock_t *tmp___1 ; int tmp___2 ; int tmp___3 ; int tmp___4 ; { __mptr = (struct work_struct const *)work; cs = (struct IsdnCardState *)__mptr + 0xffffffffffffe728UL; tmp___2 = test_and_clear_bit(2, (unsigned long volatile *)(& cs->event)); if (tmp___2 != 0) { if ((unsigned int )cs->hw.hfcsx.nt_mode == 0U) { switch (cs->dc.hfcsx.ph_state) { case 0: l1_msg(cs, 6, 0); goto ldv_41556; case 3: l1_msg(cs, 26, 0); goto ldv_41556; case 8: l1_msg(cs, 98, 0); goto ldv_41556; case 6: l1_msg(cs, 34, 0); goto ldv_41556; case 7: l1_msg(cs, 66, 0); goto ldv_41556; default: ; goto ldv_41556; } ldv_41556: ; } else { switch (cs->dc.hfcsx.ph_state) { case 2: tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); if (cs->hw.hfcsx.nt_timer < 0) { cs->hw.hfcsx.nt_timer = 0; cs->hw.hfcsx.int_m1 = (unsigned int )cs->hw.hfcsx.int_m1 & 127U; Write_hfc(cs, 26, (int )cs->hw.hfcsx.int_m1); tmp___0 = Read_hfc(cs, 30); Write_hfc(cs, 48, 20); __const_udelay(42950UL); Write_hfc(cs, 48, 4); cs->dc.hfcsx.ph_state = 4; } else { cs->hw.hfcsx.int_m1 = (unsigned int )cs->hw.hfcsx.int_m1 | 128U; Write_hfc(cs, 26, (int )cs->hw.hfcsx.int_m1); cs->hw.hfcsx.ctmt = (unsigned int )cs->hw.hfcsx.ctmt & 223U; cs->hw.hfcsx.ctmt = (unsigned int )cs->hw.hfcsx.ctmt | 4U; Write_hfc(cs, 25, (int )((unsigned int )cs->hw.hfcsx.ctmt | 128U)); Write_hfc(cs, 25, (int )((unsigned int )cs->hw.hfcsx.ctmt | 128U)); cs->hw.hfcsx.nt_timer = 20; Write_hfc(cs, 48, 130); } spin_unlock_irqrestore(& cs->lock, flags); goto ldv_41566; case 1: ; case 3: ; case 4: tmp___1 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___1); cs->hw.hfcsx.nt_timer = 0; cs->hw.hfcsx.int_m1 = (unsigned int )cs->hw.hfcsx.int_m1 & 127U; Write_hfc(cs, 26, (int )cs->hw.hfcsx.int_m1); spin_unlock_irqrestore(& cs->lock, flags); goto ldv_41566; default: ; goto ldv_41566; } ldv_41566: ; } } else { } tmp___3 = test_and_clear_bit(0, (unsigned long volatile *)(& cs->event)); if (tmp___3 != 0) { DChannel_proc_rcv(cs); } else { } tmp___4 = test_and_clear_bit(1, (unsigned long volatile *)(& cs->event)); if (tmp___4 != 0) { DChannel_proc_xmt(cs); } else { } return; } } static void inithfcsx(struct IsdnCardState *cs ) { { cs->setstack_d = & setstack_hfcsx; cs->BC_Send_Data = & hfcsx_send_data; cs->bcs[0].BC_SetStack = & setstack_2b___0; cs->bcs[1].BC_SetStack = & setstack_2b___0; cs->bcs[0].BC_Close = & close_hfcsx; cs->bcs[1].BC_Close = & close_hfcsx; mode_hfcsx((struct BCState *)(& cs->bcs), 0, 0); mode_hfcsx((struct BCState *)(& cs->bcs) + 1UL, 0, 1); return; } } static int hfcsx_card_msg(struct IsdnCardState *cs , int mt , void *arg ) { u_long flags ; raw_spinlock_t *tmp ; raw_spinlock_t *tmp___0 ; raw_spinlock_t *tmp___1 ; { if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"HFCSX: card_msg %x", mt); } else { } switch (mt) { case 240: tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); reset_hfcsx(cs); spin_unlock_irqrestore(& cs->lock, flags); return (0); case 243: release_io_hfcsx(cs); return (0); case 242: tmp___0 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___0); inithfcsx(cs); spin_unlock_irqrestore(& cs->lock, flags); msleep(80U); tmp___1 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___1); cs->hw.hfcsx.int_m1 = (unsigned int )cs->hw.hfcsx.int_m1 & 127U; Write_hfc(cs, 26, (int )cs->hw.hfcsx.int_m1); Write_hfc(cs, 46, (int )cs->hw.hfcsx.mst_m); spin_unlock_irqrestore(& cs->lock, flags); return (0); case 244: ; return (0); } return (0); } } int setup_hfcsx(struct IsdnCard *card ) { struct IsdnCardState *cs ; char tmp[64U] ; char *tmp___0 ; struct resource *tmp___1 ; void *tmp___2 ; struct lock_class_key __key ; struct lock_class_key __key___0 ; atomic_long_t __constr_expr_0 ; struct lock_class_key __key___1 ; { cs = card->cs; strcpy((char *)(& tmp), hfcsx_revision); tmp___0 = HiSax_getrev((char const *)(& tmp)); printk("\016HiSax: HFC-SX driver Rev. %s\n", tmp___0); cs->hw.hfcsx.base = card->para[1] & 65534UL; cs->irq = (u_int )card->para[0]; cs->hw.hfcsx.int_s1 = 0U; cs->dc.hfcsx.ph_state = 0; cs->hw.hfcsx.fifo = 255U; if ((unsigned int )cs->typ == 37U || (unsigned int )cs->typ == 39U) { if (cs->hw.hfcsx.base == 0UL) { printk("\fHiSax: HFC-SX io-base %#lx already in use\n", cs->hw.hfcsx.base); return (0); } else { tmp___1 = __request_region(& ioport_resource, (resource_size_t )cs->hw.hfcsx.base, 2ULL, "HFCSX isdn", 0); if ((unsigned long )tmp___1 == (unsigned long )((struct resource *)0)) { printk("\fHiSax: HFC-SX io-base %#lx already in use\n", cs->hw.hfcsx.base); return (0); } else { } } outb((int )((unsigned char )cs->hw.hfcsx.base), (int )cs->hw.hfcsx.base); outb((int )(((unsigned int )((unsigned char )(cs->hw.hfcsx.base >> 8)) & 3U) | 84U), (int )((unsigned int )cs->hw.hfcsx.base + 1U)); __const_udelay(42950UL); cs->hw.hfcsx.chip = Read_hfc(cs, 22); switch ((int )cs->hw.hfcsx.chip >> 4) { case 1: tmp[0] = 43; goto ldv_41602; case 9: tmp[0] = 80; goto ldv_41602; default: printk("\fHFC-SX: invalid chip id 0x%x\n", (int )cs->hw.hfcsx.chip >> 4); __release_region(& ioport_resource, (resource_size_t )cs->hw.hfcsx.base, 2ULL); return (0); } ldv_41602: ; if ((unsigned int )ccd_sp_irqtab[cs->irq & 15U] == 0U) { printk("\fHFC_SX: invalid irq %d specified\n", cs->irq & 15U); __release_region(& ioport_resource, (resource_size_t )cs->hw.hfcsx.base, 2ULL); return (0); } else { } tmp___2 = kmalloc(160UL, 32U); cs->hw.hfcsx.extra = tmp___2; if ((unsigned long )tmp___2 == (unsigned long )((void *)0)) { __release_region(& ioport_resource, (resource_size_t )cs->hw.hfcsx.base, 2ULL); printk("\fHFC-SX: unable to allocate memory\n"); return (0); } else { } printk("\016HFC-S%c chip detected at base 0x%x IRQ %d HZ %d\n", (int )tmp[0], (unsigned int )cs->hw.hfcsx.base, cs->irq, 250); cs->hw.hfcsx.int_m2 = 0U; cs->hw.hfcsx.int_m1 = 0U; Write_hfc(cs, 26, (int )cs->hw.hfcsx.int_m1); Write_hfc(cs, 27, (int )cs->hw.hfcsx.int_m2); } else { return (0); } cs->dbusytimer.function = (void (*)(unsigned long ))(& hfcsx_dbusy_timer); cs->dbusytimer.data = (unsigned long )cs; init_timer_key(& cs->dbusytimer, 0U, "(&cs->dbusytimer)", & __key); __init_work(& cs->tqueue, 0); __constr_expr_0.counter = 4195328L; cs->tqueue.data = __constr_expr_0; lockdep_init_map(& cs->tqueue.lockdep_map, "(&cs->tqueue)", & __key___0, 0); INIT_LIST_HEAD(& cs->tqueue.entry); cs->tqueue.func = & hfcsx_bh; cs->readisac = 0; cs->writeisac = 0; cs->readisacfifo = 0; cs->writeisacfifo = 0; cs->BC_Read_Reg = 0; cs->BC_Write_Reg = 0; cs->irq_func = & hfcsx_interrupt; cs->hw.hfcsx.timer.function = (void (*)(unsigned long ))(& hfcsx_Timer); cs->hw.hfcsx.timer.data = (unsigned long )cs; cs->hw.hfcsx.b_fifo_size = 0; cs->hw.hfcsx.cirm = ccd_sp_irqtab[cs->irq & 15U]; init_timer_key(& cs->hw.hfcsx.timer, 0U, "(&cs->hw.hfcsx.timer)", & __key___1); reset_hfcsx(cs); cs->cardmsg = & hfcsx_card_msg; cs->auxcmd = & hfcsx_auxcmd; return (1); } } void ldv_mutex_lock_421(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_lock(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_422(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_lock(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_423(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } int ldv_mutex_trylock_424(struct mutex *ldv_func_arg1 ) { ldv_func_ret_type___2 ldv_func_res ; int tmp ; int tmp___0 ; { tmp = mutex_trylock(ldv_func_arg1); ldv_func_res = tmp; tmp___0 = ldv_mutex_trylock_mutex(ldv_func_arg1); return (tmp___0); return (ldv_func_res); } } void ldv_mutex_unlock_425(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_426(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_cred_guard_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_427(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_cred_guard_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } int ldv_mutex_trylock_438(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_436(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_439(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_441(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_435(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_437(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_440(struct mutex *ldv_func_arg1 ) ; static char const *niccy_revision = "$Revision: 1.21.2.4 $"; static u_char ReadISAC___7(struct IsdnCardState *cs , u_char offset ) { u_char tmp ; { tmp = readreg___1(cs->hw.niccy.isac_ale, cs->hw.niccy.isac, (int )offset); return (tmp); } } static void WriteISAC___7(struct IsdnCardState *cs , u_char offset , u_char value ) { { writereg___1(cs->hw.niccy.isac_ale, cs->hw.niccy.isac, (int )offset, (int )value); return; } } static void ReadISACfifo___7(struct IsdnCardState *cs , u_char *data , int size ) { { readfifo(cs->hw.niccy.isac_ale, cs->hw.niccy.isac, 0, data, size); return; } } static void WriteISACfifo___7(struct IsdnCardState *cs , u_char *data , int size ) { { writefifo(cs->hw.niccy.isac_ale, cs->hw.niccy.isac, 0, data, size); return; } } static u_char ReadHSCX___6(struct IsdnCardState *cs , int hscx , u_char offset ) { u_char tmp ; { tmp = readreg___1(cs->hw.niccy.hscx_ale, cs->hw.niccy.hscx, (int )((hscx != 0 ? 64U : 0U) + (unsigned int )offset)); return (tmp); } } static void WriteHSCX___6(struct IsdnCardState *cs , int hscx , u_char offset , u_char value ) { { writereg___1(cs->hw.niccy.hscx_ale, cs->hw.niccy.hscx, (int )((hscx != 0 ? 64U : 0U) + (unsigned int )offset), (int )value); return; } } __inline static void waitforCEC___6(struct IsdnCardState *cs , int hscx ) { int to ; u_char tmp ; { to = 50; goto ldv_41343; ldv_41342: __const_udelay(4295UL); to = to - 1; ldv_41343: tmp = readreg___1(cs->hw.niccy.hscx_ale, cs->hw.niccy.hscx, hscx != 0 ? 97 : 33); if (((int )tmp & 4) != 0 && to != 0) { goto ldv_41342; } else { } if (to == 0) { printk("\fHiSax: waitforCEC timeout\n"); } else { } return; } } __inline static void waitforXFW___6(struct IsdnCardState *cs , int hscx ) { int to ; u_char tmp ; { to = 50; goto ldv_41351; ldv_41350: __const_udelay(4295UL); to = to - 1; ldv_41351: tmp = readreg___1(cs->hw.niccy.hscx_ale, cs->hw.niccy.hscx, hscx != 0 ? 97 : 33); if (((int )tmp & 68) != 64 && to != 0) { goto ldv_41350; } else { } if (to == 0) { printk("\fHiSax: waitforXFW timeout\n"); } else { } return; } } __inline static void WriteHSCXCMDR___6(struct IsdnCardState *cs , int hscx , u_char data ) { { waitforCEC___6(cs, hscx); writereg___1(cs->hw.niccy.hscx_ale, cs->hw.niccy.hscx, hscx != 0 ? 97 : 33, (int )data); return; } } static void hscx_empty_fifo___6(struct BCState *bcs , int count ) { u_char *ptr ; struct IsdnCardState *cs ; char *t ; int tmp ; { cs = bcs->cs; if ((cs->debug & 16) != 0 && (cs->debug & 32) == 0) { debugl1(cs, (char *)"hscx_empty_fifo"); } else { } if (bcs->hw.hscx.rcvidx + count > 4096) { if (cs->debug & 1) { debugl1(cs, (char *)"hscx_empty_fifo: incoming packet too large"); } else { } WriteHSCXCMDR___6(cs, bcs->hw.hscx.hscx, 128); bcs->hw.hscx.rcvidx = 0; return; } else { } ptr = bcs->hw.hscx.rcvbuf + (unsigned long )bcs->hw.hscx.rcvidx; bcs->hw.hscx.rcvidx = bcs->hw.hscx.rcvidx + count; readfifo(cs->hw.niccy.hscx_ale, cs->hw.niccy.hscx, bcs->hw.hscx.hscx != 0 ? 64 : 0, ptr, count); WriteHSCXCMDR___6(cs, bcs->hw.hscx.hscx, 128); if ((cs->debug & 32) != 0) { t = (char *)bcs->blog; tmp = sprintf(t, "hscx_empty_fifo %c cnt %d", bcs->hw.hscx.hscx != 0 ? 66 : 65, count); t = t + (unsigned long )tmp; QuickHex(t, ptr, count); debugl1(cs, (char *)bcs->blog); } else { } return; } } static void hscx_fill_fifo___6(struct BCState *bcs ) { struct IsdnCardState *cs ; int more ; int count ; int fifo_size ; int tmp ; u_char *ptr ; char *t ; int tmp___0 ; { cs = bcs->cs; tmp = constant_test_bit(1U, (unsigned long const volatile *)(& cs->HW_Flags)); fifo_size = tmp != 0 ? 64 : 32; if ((cs->debug & 16) != 0 && (cs->debug & 32) == 0) { debugl1(cs, (char *)"hscx_fill_fifo"); } else { } if ((unsigned long )bcs->tx_skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } if ((bcs->tx_skb)->len == 0U) { return; } else { } more = bcs->mode == 1; if ((bcs->tx_skb)->len > (unsigned int )fifo_size) { more = 1; count = fifo_size; } else { count = (int )(bcs->tx_skb)->len; } waitforXFW___6(cs, bcs->hw.hscx.hscx); ptr = (bcs->tx_skb)->data; skb_pull(bcs->tx_skb, (unsigned int )count); bcs->tx_cnt = bcs->tx_cnt - count; bcs->hw.hscx.count = bcs->hw.hscx.count + count; writefifo(cs->hw.niccy.hscx_ale, cs->hw.niccy.hscx, bcs->hw.hscx.hscx != 0 ? 64 : 0, ptr, count); WriteHSCXCMDR___6(cs, bcs->hw.hscx.hscx, more != 0 ? 8 : 10); if ((cs->debug & 32) != 0) { t = (char *)bcs->blog; tmp___0 = sprintf(t, "hscx_fill_fifo %c cnt %d", bcs->hw.hscx.hscx != 0 ? 66 : 65, count); t = t + (unsigned long )tmp___0; QuickHex(t, ptr, count); debugl1(cs, (char *)bcs->blog); } else { } return; } } static void hscx_interrupt___6(struct IsdnCardState *cs , u_char val , u_char hscx ) { u_char r ; struct BCState *bcs ; struct sk_buff *skb ; int fifo_size ; int tmp ; int count ; int tmp___0 ; u_char tmp___1 ; int tmp___2 ; size_t __len ; void *__ret ; unsigned char *tmp___4 ; size_t __len___0 ; void *__ret___0 ; unsigned char *tmp___6 ; u_long flags ; raw_spinlock_t *tmp___7 ; int tmp___8 ; struct sk_buff *tmp___9 ; { bcs = (struct BCState *)(& cs->bcs) + (unsigned long )hscx; tmp = constant_test_bit(1U, (unsigned long const volatile *)(& cs->HW_Flags)); fifo_size = tmp != 0 ? 64 : 32; tmp___0 = constant_test_bit(1U, (unsigned long const volatile *)(& bcs->Flag)); if (tmp___0 == 0) { return; } else { } if ((int )((signed char )val) < 0) { r = readreg___1(cs->hw.niccy.hscx_ale, cs->hw.niccy.hscx, (unsigned int )hscx != 0U ? 103 : 39); if (((int )r & 240) != 160) { if ((int )((signed char )r) >= 0) { if (cs->debug & 1) { debugl1(cs, (char *)"HSCX invalid frame"); } else { } bcs->err_inv = bcs->err_inv + 1; } else { } if (((int )r & 64) != 0 && bcs->mode != 0) { if (cs->debug & 1) { debugl1(cs, (char *)"HSCX RDO mode=%d", bcs->mode); } else { } bcs->err_rdo = bcs->err_rdo + 1; } else { } if (((int )r & 32) == 0) { if (cs->debug & 1) { debugl1(cs, (char *)"HSCX CRC error"); } else { } bcs->err_crc = bcs->err_crc + 1; } else { } WriteHSCXCMDR___6(cs, (int )hscx, 128); } else { tmp___1 = readreg___1(cs->hw.niccy.hscx_ale, cs->hw.niccy.hscx, (unsigned int )hscx != 0U ? 101 : 37); tmp___2 = constant_test_bit(1U, (unsigned long const volatile *)(& cs->HW_Flags)); count = (int )tmp___1 & (tmp___2 != 0 ? 63 : 31); if (count == 0) { count = fifo_size; } else { } hscx_empty_fifo___6(bcs, count); count = bcs->hw.hscx.rcvidx + -1; if (count > 0) { if ((cs->debug & 32) != 0) { debugl1(cs, (char *)"HX Frame %d", count); } else { } skb = dev_alloc_skb((unsigned int )count); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { printk("\fHSCX: receive out of memory\n"); } else { __len = (size_t )count; tmp___4 = skb_put(skb, (unsigned int )count); __ret = memcpy((void *)tmp___4, (void const *)bcs->hw.hscx.rcvbuf, __len); skb_queue_tail(& bcs->rqueue, skb); } } else { } } bcs->hw.hscx.rcvidx = 0; test_and_set_bit(0, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } if (((int )val & 64) != 0) { hscx_empty_fifo___6(bcs, fifo_size); if (bcs->mode == 1) { skb = dev_alloc_skb((unsigned int )fifo_size); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { printk("\fHiSax: receive out of memory\n"); } else { __len___0 = (size_t )fifo_size; tmp___6 = skb_put(skb, (unsigned int )fifo_size); __ret___0 = memcpy((void *)tmp___6, (void const *)bcs->hw.hscx.rcvbuf, __len___0); skb_queue_tail(& bcs->rqueue, skb); } bcs->hw.hscx.rcvidx = 0; test_and_set_bit(0, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } } else { } if (((int )val & 16) != 0) { if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { if ((bcs->tx_skb)->len != 0U) { hscx_fill_fifo___6(bcs); return; } else { tmp___8 = constant_test_bit(1U, (unsigned long const volatile *)(& (bcs->st)->lli.flag)); if (tmp___8 != 0 && (unsigned int )*((unsigned char *)bcs->tx_skb + 125UL) != 7U) { tmp___7 = spinlock_check(& bcs->aclock); flags = _raw_spin_lock_irqsave(tmp___7); bcs->ackcnt = bcs->ackcnt + bcs->hw.hscx.count; spin_unlock_irqrestore(& bcs->aclock, flags); test_and_set_bit(2, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } dev_kfree_skb_irq(bcs->tx_skb); bcs->hw.hscx.count = 0; bcs->tx_skb = 0; } } else { } tmp___9 = skb_dequeue(& bcs->squeue); bcs->tx_skb = tmp___9; if ((unsigned long )tmp___9 != (unsigned long )((struct sk_buff *)0)) { bcs->hw.hscx.count = 0; test_and_set_bit(3, (unsigned long volatile *)(& bcs->Flag)); hscx_fill_fifo___6(bcs); } else { test_and_clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); test_and_set_bit(1, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } } else { } return; } } static void hscx_int_main___6(struct IsdnCardState *cs , u_char val ) { u_char exval ; struct BCState *bcs ; { if ((int )val & 1) { bcs = (struct BCState *)(& cs->bcs) + 1UL; exval = readreg___1(cs->hw.niccy.hscx_ale, cs->hw.niccy.hscx, 100); if (((int )exval & 64) != 0) { if (bcs->mode == 1) { hscx_fill_fifo___6(bcs); } else { bcs->err_tx = bcs->err_tx + 1; if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { skb_push(bcs->tx_skb, (unsigned int )bcs->hw.hscx.count); bcs->tx_cnt = bcs->tx_cnt + bcs->hw.hscx.count; bcs->hw.hscx.count = 0; } else { } WriteHSCXCMDR___6(cs, bcs->hw.hscx.hscx, 1); if (cs->debug & 1) { debugl1(cs, (char *)"HSCX B EXIR %x Lost TX", (int )exval); } else { } } } else if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HSCX B EXIR %x", (int )exval); } else { } } else { } if (((int )val & 248) != 0) { if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HSCX B interrupt %x", (int )val); } else { } hscx_interrupt___6(cs, (int )val, 1); } else { } if (((int )val & 2) != 0) { bcs = (struct BCState *)(& cs->bcs); exval = readreg___1(cs->hw.niccy.hscx_ale, cs->hw.niccy.hscx, 36); if (((int )exval & 64) != 0) { if (bcs->mode == 1) { hscx_fill_fifo___6(bcs); } else { bcs->err_tx = bcs->err_tx + 1; if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { skb_push(bcs->tx_skb, (unsigned int )bcs->hw.hscx.count); bcs->tx_cnt = bcs->tx_cnt + bcs->hw.hscx.count; bcs->hw.hscx.count = 0; } else { } WriteHSCXCMDR___6(cs, bcs->hw.hscx.hscx, 1); if (cs->debug & 1) { debugl1(cs, (char *)"HSCX A EXIR %x Lost TX", (int )exval); } else { } } } else if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HSCX A EXIR %x", (int )exval); } else { } } else { } if (((int )val & 4) != 0) { exval = readreg___1(cs->hw.niccy.hscx_ale, cs->hw.niccy.hscx, 32); if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HSCX A interrupt %x", (int )exval); } else { } hscx_interrupt___6(cs, (int )exval, 0); } else { } return; } } static irqreturn_t niccy_interrupt(int intno , void *dev_id ) { struct IsdnCardState *cs ; u_char val ; u_long flags ; raw_spinlock_t *tmp ; int ival ; unsigned int tmp___0 ; { cs = (struct IsdnCardState *)dev_id; tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); if ((unsigned int )cs->subtyp == 2U) { tmp___0 = inl((int )(cs->hw.niccy.cfg_reg + 56U)); ival = (int )tmp___0; if ((ival & 8388608) == 0) { spin_unlock_irqrestore(& cs->lock, flags); return (0); } else { } outl((unsigned int )ival, (int )(cs->hw.niccy.cfg_reg + 56U)); } else { } val = readreg___1(cs->hw.niccy.hscx_ale, cs->hw.niccy.hscx, 96); Start_HSCX: ; if ((unsigned int )val != 0U) { hscx_int_main___6(cs, (int )val); } else { } val = readreg___1(cs->hw.niccy.isac_ale, cs->hw.niccy.isac, 32); Start_ISAC: ; if ((unsigned int )val != 0U) { isac_interrupt(cs, (int )val); } else { } val = readreg___1(cs->hw.niccy.hscx_ale, cs->hw.niccy.hscx, 96); if ((unsigned int )val != 0U) { if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HSCX IntStat after IntRoutine"); } else { } goto Start_HSCX; } else { } val = readreg___1(cs->hw.niccy.isac_ale, cs->hw.niccy.isac, 32); if ((unsigned int )val != 0U) { if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"ISAC IntStat after IntRoutine"); } else { } goto Start_ISAC; } else { } writereg___1(cs->hw.niccy.hscx_ale, cs->hw.niccy.hscx, 32, 255); writereg___1(cs->hw.niccy.hscx_ale, cs->hw.niccy.hscx, 96, 255); writereg___1(cs->hw.niccy.isac_ale, cs->hw.niccy.isac, 32, 255); writereg___1(cs->hw.niccy.isac_ale, cs->hw.niccy.isac, 32, 0); writereg___1(cs->hw.niccy.hscx_ale, cs->hw.niccy.hscx, 32, 0); writereg___1(cs->hw.niccy.hscx_ale, cs->hw.niccy.hscx, 96, 0); spin_unlock_irqrestore(& cs->lock, flags); return (1); } } static void release_io_niccy(struct IsdnCardState *cs ) { int val ; unsigned int tmp ; { if ((unsigned int )cs->subtyp == 2U) { tmp = inl((int )(cs->hw.niccy.cfg_reg + 56U)); val = (int )tmp; val = val & 16711680; outl((unsigned int )val, (int )(cs->hw.niccy.cfg_reg + 56U)); __release_region(& ioport_resource, (resource_size_t )cs->hw.niccy.cfg_reg, 64ULL); __release_region(& ioport_resource, (resource_size_t )cs->hw.niccy.isac, 4ULL); } else { __release_region(& ioport_resource, (resource_size_t )cs->hw.niccy.isac, 2ULL); __release_region(& ioport_resource, (resource_size_t )cs->hw.niccy.isac_ale, 2ULL); } return; } } static void niccy_reset(struct IsdnCardState *cs ) { int val ; unsigned int tmp ; { if ((unsigned int )cs->subtyp == 2U) { tmp = inl((int )(cs->hw.niccy.cfg_reg + 56U)); val = (int )tmp; val = val | 7936; outl((unsigned int )val, (int )(cs->hw.niccy.cfg_reg + 56U)); } else { } inithscxisac(cs, 3); return; } } static int niccy_card_msg(struct IsdnCardState *cs , int mt , void *arg ) { u_long flags ; raw_spinlock_t *tmp ; raw_spinlock_t *tmp___0 ; { switch (mt) { case 240: tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); niccy_reset(cs); spin_unlock_irqrestore(& cs->lock, flags); return (0); case 243: release_io_niccy(cs); return (0); case 242: tmp___0 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___0); niccy_reset(cs); spin_unlock_irqrestore(& cs->lock, flags); return (0); case 244: ; return (0); } return (0); } } int setup_niccy(struct IsdnCard *card ) { struct IsdnCardState *cs ; char tmp[64U] ; char *tmp___0 ; struct resource *tmp___1 ; struct resource *tmp___2 ; struct pci_dev *niccy_dev ; u_int pci_ioaddr ; int tmp___3 ; struct resource *tmp___4 ; struct resource *tmp___5 ; int tmp___6 ; { cs = card->cs; strcpy((char *)(& tmp), niccy_revision); tmp___0 = HiSax_getrev((char const *)(& tmp)); printk("\016HiSax: Niccy driver Rev. %s\n", tmp___0); if ((unsigned int )cs->typ != 24U) { return (0); } else { } if (card->para[1] != 0UL) { cs->hw.niccy.isac = (unsigned int )card->para[1]; cs->hw.niccy.hscx = (unsigned int )card->para[1] + 1U; cs->hw.niccy.isac_ale = (unsigned int )card->para[2]; cs->hw.niccy.hscx_ale = (unsigned int )card->para[2] + 1U; cs->hw.niccy.cfg_reg = 0U; cs->subtyp = 1U; cs->irq = (u_int )card->para[0]; tmp___1 = __request_region(& ioport_resource, (resource_size_t )cs->hw.niccy.isac, 2ULL, "niccy data", 0); if ((unsigned long )tmp___1 == (unsigned long )((struct resource *)0)) { printk("\fHiSax: NICCY data port %x-%x already in use\n", cs->hw.niccy.isac, cs->hw.niccy.isac + 1U); return (0); } else { } tmp___2 = __request_region(& ioport_resource, (resource_size_t )cs->hw.niccy.isac_ale, 2ULL, "niccy addr", 0); if ((unsigned long )tmp___2 == (unsigned long )((struct resource *)0)) { printk("\fHiSax: NICCY address port %x-%x already in use\n", cs->hw.niccy.isac_ale, cs->hw.niccy.isac_ale + 1U); __release_region(& ioport_resource, (resource_size_t )cs->hw.niccy.isac, 2ULL); return (0); } else { } } else { cs->subtyp = 0U; niccy_dev = hisax_find_pci_device(4711U, 4118U, niccy_dev); if ((unsigned long )niccy_dev != (unsigned long )((struct pci_dev *)0)) { tmp___3 = pci_enable_device(niccy_dev); if (tmp___3 != 0) { return (0); } else { } if (niccy_dev->irq == 0U) { printk("\fNiccy: No IRQ for PCI card found\n"); return (0); } else { } cs->irq = niccy_dev->irq; cs->hw.niccy.cfg_reg = (unsigned int )niccy_dev->resource[0].start; if (cs->hw.niccy.cfg_reg == 0U) { printk("\fNiccy: No IO-Adr for PCI cfg found\n"); return (0); } else { } pci_ioaddr = (u_int )niccy_dev->resource[1].start; if (pci_ioaddr == 0U) { printk("\fNiccy: No IO-Adr for PCI card found\n"); return (0); } else { } cs->subtyp = 2U; } else { printk("\fNiccy: No PCI card found\n"); return (0); } cs->irq_flags = cs->irq_flags | 128UL; cs->hw.niccy.isac = pci_ioaddr; cs->hw.niccy.isac_ale = pci_ioaddr + 2U; cs->hw.niccy.hscx = pci_ioaddr + 1U; cs->hw.niccy.hscx_ale = pci_ioaddr + 3U; tmp___4 = __request_region(& ioport_resource, (resource_size_t )cs->hw.niccy.isac, 4ULL, "niccy", 0); if ((unsigned long )tmp___4 == (unsigned long )((struct resource *)0)) { printk("\fHiSax: NICCY data port %x-%x already in use\n", cs->hw.niccy.isac, cs->hw.niccy.isac + 4U); return (0); } else { } tmp___5 = __request_region(& ioport_resource, (resource_size_t )cs->hw.niccy.cfg_reg, 64ULL, "niccy pci", 0); if ((unsigned long )tmp___5 == (unsigned long )((struct resource *)0)) { printk("\fHiSax: NICCY pci port %x-%x already in use\n", cs->hw.niccy.cfg_reg, cs->hw.niccy.cfg_reg + 64U); __release_region(& ioport_resource, (resource_size_t )cs->hw.niccy.isac, 4ULL); return (0); } else { } } printk("\016HiSax: NICCY %s config irq:%d data:0x%X ale:0x%X\n", (unsigned int )cs->subtyp == 1U ? (char *)"PnP" : (char *)"PCI", cs->irq, cs->hw.niccy.isac, cs->hw.niccy.isac_ale); setup_isac(cs); cs->readisac = & ReadISAC___7; cs->writeisac = & WriteISAC___7; cs->readisacfifo = & ReadISACfifo___7; cs->writeisacfifo = & WriteISACfifo___7; cs->BC_Read_Reg = & ReadHSCX___6; cs->BC_Write_Reg = & WriteHSCX___6; cs->BC_Send_Data = & hscx_fill_fifo___6; cs->cardmsg = & niccy_card_msg; cs->irq_func = & niccy_interrupt; ISACVersion(cs, (char *)"Niccy:"); tmp___6 = HscxVersion(cs, (char *)"Niccy:"); if (tmp___6 != 0) { printk("\fNiccy: wrong HSCX versions check IO address\n"); release_io_niccy(cs); return (0); } else { } return (1); } } void ldv_mutex_lock_435(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_lock(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_436(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_lock(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_437(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } int ldv_mutex_trylock_438(struct mutex *ldv_func_arg1 ) { ldv_func_ret_type___2 ldv_func_res ; int tmp ; int tmp___0 ; { tmp = mutex_trylock(ldv_func_arg1); ldv_func_res = tmp; tmp___0 = ldv_mutex_trylock_mutex(ldv_func_arg1); return (tmp___0); return (ldv_func_res); } } void ldv_mutex_unlock_439(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_440(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_cred_guard_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_441(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_cred_guard_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } int ldv_mutex_trylock_452(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_450(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_453(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_455(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_449(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_451(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_454(struct mutex *ldv_func_arg1 ) ; int JadeVersion(struct IsdnCardState *cs , char *s ) ; void clear_pending_jade_ints(struct IsdnCardState *cs ) ; void initjade(struct IsdnCardState *cs ) ; static char const *bkm_a4t_revision = "$Revision: 1.22.2.4 $"; __inline static u_char readreg___5(unsigned int ale , unsigned long adr , u_char off ) { register u_int ret ; unsigned int *po ; { po = (unsigned int *)adr; *po = (unsigned int )((int )off | 10485760); goto ldv_41025; ldv_41024: ; ldv_41025: ; if (((unsigned int )*((unsigned int volatile *)po) & 33554432U) != 0U) { goto ldv_41024; } else { } *po = ale; goto ldv_41028; ldv_41027: ; ldv_41028: ; if (((unsigned int )*((unsigned int volatile *)po) & 33554432U) != 0U) { goto ldv_41027; } else { } ret = *po; return ((u_char )ret); } } __inline static void readfifo___3(unsigned int ale , unsigned long adr , u_char off , u_char *data , int size ) { int i ; u_char *tmp ; { i = 0; goto ldv_41039; ldv_41038: tmp = data; data = data + 1; *tmp = readreg___5(ale, adr, (int )off); i = i + 1; ldv_41039: ; if (i < size) { goto ldv_41038; } else { } return; } } __inline static void writereg___5(unsigned int ale , unsigned long adr , u_char off , u_char data ) { unsigned int *po ; { po = (unsigned int *)adr; *po = (unsigned int )((int )off | 10485760); goto ldv_41049; ldv_41048: ; ldv_41049: ; if (((unsigned int )*((unsigned int volatile *)po) & 33554432U) != 0U) { goto ldv_41048; } else { } *po = ((unsigned int )data | ale) | 8388608U; goto ldv_41052; ldv_41051: ; ldv_41052: ; if (((unsigned int )*((unsigned int volatile *)po) & 33554432U) != 0U) { goto ldv_41051; } else { } return; } } __inline static void writefifo___3(unsigned int ale , unsigned long adr , u_char off , u_char *data , int size ) { int i ; u_char *tmp ; { i = 0; goto ldv_41063; ldv_41062: tmp = data; data = data + 1; writereg___5(ale, adr, (int )off, (int )*tmp); i = i + 1; ldv_41063: ; if (i < size) { goto ldv_41062; } else { } return; } } static u_char ReadISAC___8(struct IsdnCardState *cs , u_char offset ) { u_char tmp ; { tmp = readreg___5(cs->hw.ax.isac_ale, cs->hw.ax.isac_adr, (int )offset); return (tmp); } } static void WriteISAC___8(struct IsdnCardState *cs , u_char offset , u_char value ) { { writereg___5(cs->hw.ax.isac_ale, cs->hw.ax.isac_adr, (int )offset, (int )value); return; } } static void ReadISACfifo___8(struct IsdnCardState *cs , u_char *data , int size ) { { readfifo___3(cs->hw.ax.isac_ale, cs->hw.ax.isac_adr, 0, data, size); return; } } static void WriteISACfifo___8(struct IsdnCardState *cs , u_char *data , int size ) { { writefifo___3(cs->hw.ax.isac_ale, cs->hw.ax.isac_adr, 0, data, size); return; } } static u_char ReadJADE(struct IsdnCardState *cs , int jade , u_char offset ) { u_char tmp ; { tmp = readreg___5(cs->hw.ax.jade_ale, cs->hw.ax.jade_adr, (int )((jade != -1 ? (jade != 0 ? 192U : 128U) : 0U) + (unsigned int )offset)); return (tmp); } } static void WriteJADE(struct IsdnCardState *cs , int jade , u_char offset , u_char value ) { { writereg___5(cs->hw.ax.jade_ale, cs->hw.ax.jade_adr, (int )((jade != -1 ? (jade != 0 ? 192U : 128U) : 0U) + (unsigned int )offset), (int )value); return; } } __inline static void waitforCEC___7(struct IsdnCardState *cs , int jade , int reg ) { int to ; int mask ; u_char tmp ; { to = 50; mask = reg == 32 ? 32 : 16; goto ldv_41103; ldv_41102: __const_udelay(4295UL); to = to - 1; ldv_41103: tmp = readreg___5(cs->hw.ax.jade_ale, cs->hw.ax.jade_adr, jade != -1 ? (jade != 0 ? 224 : 160) : 32); if (((int )tmp & mask) != 0 && to != 0) { goto ldv_41102; } else { } if (to == 0) { printk("\fHiSax: waitforCEC (jade) timeout\n"); } else { } return; } } __inline static void waitforXFW___7(struct IsdnCardState *cs , int jade ) { { return; } } __inline static void WriteJADECMDR(struct IsdnCardState *cs , int jade , int reg , u_char data ) { { waitforCEC___7(cs, jade, reg); writereg___5(cs->hw.ax.jade_ale, cs->hw.ax.jade_adr, (int )((jade != -1 ? (jade != 0 ? 192U : 128U) : 0U) + (unsigned int )((u_char )reg)), (int )data); return; } } static void jade_empty_fifo(struct BCState *bcs , int count ) { u_char *ptr ; struct IsdnCardState *cs ; char *t ; int tmp ; { cs = bcs->cs; if ((cs->debug & 16) != 0 && (cs->debug & 32) == 0) { debugl1(cs, (char *)"jade_empty_fifo"); } else { } if (bcs->hw.hscx.rcvidx + count > 4096) { if (cs->debug & 1) { debugl1(cs, (char *)"jade_empty_fifo: incoming packet too large"); } else { } WriteJADECMDR(cs, bcs->hw.hscx.hscx, 37, 128); bcs->hw.hscx.rcvidx = 0; return; } else { } ptr = bcs->hw.hscx.rcvbuf + (unsigned long )bcs->hw.hscx.rcvidx; bcs->hw.hscx.rcvidx = bcs->hw.hscx.rcvidx + count; readfifo___3(cs->hw.ax.jade_ale, cs->hw.ax.jade_adr, bcs->hw.hscx.hscx != -1 ? (bcs->hw.hscx.hscx != 0 ? 192 : 128) : 0, ptr, count); WriteJADECMDR(cs, bcs->hw.hscx.hscx, 37, 128); if ((cs->debug & 32) != 0) { t = (char *)bcs->blog; tmp = sprintf(t, "jade_empty_fifo %c cnt %d", bcs->hw.hscx.hscx != 0 ? 66 : 65, count); t = t + (unsigned long )tmp; QuickHex(t, ptr, count); debugl1(cs, (char *)bcs->blog); } else { } return; } } static void jade_fill_fifo(struct BCState *bcs ) { struct IsdnCardState *cs ; int more ; int count ; int fifo_size ; u_char *ptr ; char *t ; int tmp ; { cs = bcs->cs; fifo_size = 32; if ((cs->debug & 16) != 0 && (cs->debug & 32) == 0) { debugl1(cs, (char *)"jade_fill_fifo"); } else { } if ((unsigned long )bcs->tx_skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } if ((bcs->tx_skb)->len == 0U) { return; } else { } more = bcs->mode == 1; if ((bcs->tx_skb)->len > (unsigned int )fifo_size) { more = 1; count = fifo_size; } else { count = (int )(bcs->tx_skb)->len; } waitforXFW___7(cs, bcs->hw.hscx.hscx); ptr = (bcs->tx_skb)->data; skb_pull(bcs->tx_skb, (unsigned int )count); bcs->tx_cnt = bcs->tx_cnt - count; bcs->hw.hscx.count = bcs->hw.hscx.count + count; writefifo___3(cs->hw.ax.jade_ale, cs->hw.ax.jade_adr, bcs->hw.hscx.hscx != -1 ? (bcs->hw.hscx.hscx != 0 ? 192 : 128) : 0, ptr, count); WriteJADECMDR(cs, bcs->hw.hscx.hscx, 32, more != 0 ? 128 : 192); if ((cs->debug & 32) != 0) { t = (char *)bcs->blog; tmp = sprintf(t, "jade_fill_fifo %c cnt %d", bcs->hw.hscx.hscx != 0 ? 66 : 65, count); t = t + (unsigned long )tmp; QuickHex(t, ptr, count); debugl1(cs, (char *)bcs->blog); } else { } return; } } static void jade_interrupt(struct IsdnCardState *cs , u_char val , u_char jade ) { u_char r ; struct BCState *bcs ; struct sk_buff *skb ; int fifo_size ; int count ; int i_jade ; int tmp ; u_char tmp___0 ; size_t __len ; void *__ret ; unsigned char *tmp___2 ; size_t __len___0 ; void *__ret___0 ; unsigned char *tmp___4 ; u_long flags ; raw_spinlock_t *tmp___5 ; int tmp___6 ; struct sk_buff *tmp___7 ; { bcs = (struct BCState *)(& cs->bcs) + (unsigned long )jade; fifo_size = 32; i_jade = (int )jade; tmp = constant_test_bit(1U, (unsigned long const volatile *)(& bcs->Flag)); if (tmp == 0) { return; } else { } if ((int )((signed char )val) < 0) { r = readreg___5(cs->hw.ax.jade_ale, cs->hw.ax.jade_adr, i_jade != -1 ? (i_jade != 0 ? 225 : 161) : 33); if (((int )r & 240) != 160) { if ((int )((signed char )r) >= 0) { if (cs->debug & 1) { debugl1(cs, (char *)"JADE %s invalid frame", (unsigned int )jade != 0U ? (char *)"B" : (char *)"A"); } else { } } else { } if (((int )r & 64) != 0 && bcs->mode != 0) { if (cs->debug & 1) { debugl1(cs, (char *)"JADE %c RDO mode=%d", (int )jade + 65, bcs->mode); } else { } } else { } if (((int )r & 32) == 0) { if (cs->debug & 1) { debugl1(cs, (char *)"JADE %c CRC error", (int )jade + 65); } else { } } else { } WriteJADECMDR(cs, (int )jade, 37, 128); } else { tmp___0 = readreg___5(cs->hw.ax.jade_ale, cs->hw.ax.jade_adr, i_jade != -1 ? (i_jade != 0 ? 229 : 165) : 37); count = (int )tmp___0 & 31; if (count == 0) { count = fifo_size; } else { } jade_empty_fifo(bcs, count); count = bcs->hw.hscx.rcvidx + -1; if (count > 0) { if ((cs->debug & 32) != 0) { debugl1(cs, (char *)"HX Frame %d", count); } else { } skb = dev_alloc_skb((unsigned int )count); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { printk("\fJADE %s receive out of memory\n", (unsigned int )jade != 0U ? (char *)"B" : (char *)"A"); } else { __len = (size_t )count; tmp___2 = skb_put(skb, (unsigned int )count); __ret = memcpy((void *)tmp___2, (void const *)bcs->hw.hscx.rcvbuf, __len); skb_queue_tail(& bcs->rqueue, skb); } } else { } } bcs->hw.hscx.rcvidx = 0; test_and_set_bit(0, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } if (((int )val & 64) != 0) { jade_empty_fifo(bcs, fifo_size); if (bcs->mode == 1) { skb = dev_alloc_skb((unsigned int )fifo_size); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { printk("\fHiSax: receive out of memory\n"); } else { __len___0 = (size_t )fifo_size; tmp___4 = skb_put(skb, (unsigned int )fifo_size); __ret___0 = memcpy((void *)tmp___4, (void const *)bcs->hw.hscx.rcvbuf, __len___0); skb_queue_tail(& bcs->rqueue, skb); } bcs->hw.hscx.rcvidx = 0; test_and_set_bit(0, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } } else { } if (((int )val & 16) != 0) { if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { if ((bcs->tx_skb)->len != 0U) { jade_fill_fifo(bcs); return; } else { tmp___6 = constant_test_bit(1U, (unsigned long const volatile *)(& (bcs->st)->lli.flag)); if (tmp___6 != 0 && (unsigned int )*((unsigned char *)bcs->tx_skb + 125UL) != 7U) { tmp___5 = spinlock_check(& bcs->aclock); flags = _raw_spin_lock_irqsave(tmp___5); bcs->ackcnt = bcs->ackcnt + bcs->hw.hscx.count; spin_unlock_irqrestore(& bcs->aclock, flags); test_and_set_bit(2, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } dev_kfree_skb_irq(bcs->tx_skb); bcs->hw.hscx.count = 0; bcs->tx_skb = 0; } } else { } tmp___7 = skb_dequeue(& bcs->squeue); bcs->tx_skb = tmp___7; if ((unsigned long )tmp___7 != (unsigned long )((struct sk_buff *)0)) { bcs->hw.hscx.count = 0; test_and_set_bit(3, (unsigned long volatile *)(& bcs->Flag)); jade_fill_fifo(bcs); } else { test_and_clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); test_and_set_bit(1, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } } else { } return; } } __inline static void jade_int_main(struct IsdnCardState *cs , u_char val , int jade ) { struct BCState *bcs ; { bcs = (struct BCState *)(& cs->bcs) + (unsigned long )jade; if (((int )val & 32) != 0) { val = (unsigned int )val & 223U; } else { } if (((int )val & 8) != 0) { if (bcs->mode == 1) { jade_fill_fifo(bcs); } else { if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { skb_push(bcs->tx_skb, (unsigned int )bcs->hw.hscx.count); bcs->tx_cnt = bcs->tx_cnt + bcs->hw.hscx.count; bcs->hw.hscx.count = 0; } else { } WriteJADECMDR(cs, bcs->hw.hscx.hscx, 32, 32); if (cs->debug & 1) { debugl1(cs, (char *)"JADE %c EXIR %x Lost TX", jade + 65, (int )val); } else { } } } else { } if (((int )val & 208) != 0) { if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"JADE %c interrupt %x", jade + 65, (int )val); } else { } jade_interrupt(cs, (int )val, (int )((u_char )jade)); } else { } return; } } static irqreturn_t bkm_interrupt(int intno , void *dev_id ) { struct IsdnCardState *cs ; u_char val ; u_long flags ; I20_REGISTER_FILE *pI20_Regs ; raw_spinlock_t *tmp ; { cs = (struct IsdnCardState *)dev_id; val = 0U; tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); pI20_Regs = (I20_REGISTER_FILE *)cs->hw.ax.base; if (((unsigned int )pI20_Regs->i20IntStatus & 1073741824U) != 0U) { pI20_Regs->i20IntStatus = 1073741824U; pI20_Regs->i20IntCtrl = (unsigned int )pI20_Regs->i20IntCtrl & 3221225471U; val = readreg___5(cs->hw.ax.jade_ale, cs->hw.ax.jade_adr, 172); if ((unsigned int )val != 0U) { jade_int_main(cs, (int )val, 0); } else { } val = readreg___5(cs->hw.ax.jade_ale, cs->hw.ax.jade_adr, 236); if ((unsigned int )val != 0U) { jade_int_main(cs, (int )val, 1); } else { } val = readreg___5(cs->hw.ax.isac_ale, cs->hw.ax.isac_adr, 32); if ((unsigned int )val != 0U) { isac_interrupt(cs, (int )val); } else { } pI20_Regs->i20IntCtrl = (unsigned int )pI20_Regs->i20IntCtrl | 1073741824U; spin_unlock_irqrestore(& cs->lock, flags); return (1); } else { spin_unlock_irqrestore(& cs->lock, flags); return (0); } } } static void release_io_bkm(struct IsdnCardState *cs ) { { if (cs->hw.ax.base != 0UL) { iounmap((void volatile *)cs->hw.ax.base); cs->hw.ax.base = 0UL; } else { } return; } } static void enable_bkm_int(struct IsdnCardState *cs , unsigned int bEnable ) { I20_REGISTER_FILE *pI20_Regs ; { if ((unsigned int )cs->typ == 32U) { pI20_Regs = (I20_REGISTER_FILE *)cs->hw.ax.base; if (bEnable != 0U) { pI20_Regs->i20IntCtrl = (unsigned int )pI20_Regs->i20IntCtrl | 1090519040U; } else { pI20_Regs->i20IntCtrl = (unsigned int )pI20_Regs->i20IntCtrl & 3204448255U; } } else { } return; } } static void reset_bkm(struct IsdnCardState *cs ) { I20_REGISTER_FILE *pI20_Regs ; unsigned long __ms ; unsigned long tmp ; unsigned long __ms___0 ; unsigned long tmp___0 ; unsigned long __ms___1 ; unsigned long tmp___1 ; unsigned long __ms___2 ; unsigned long tmp___2 ; { if ((unsigned int )cs->typ == 32U) { pI20_Regs = (I20_REGISTER_FILE *)cs->hw.ax.base; pI20_Regs->i20SysControl = 255U; __ms = 10UL; goto ldv_41183; ldv_41182: __const_udelay(4295000UL); ldv_41183: tmp = __ms; __ms = __ms - 1UL; if (tmp != 0UL) { goto ldv_41182; } else { } pI20_Regs->i20SysControl = 16777471U; __ms___0 = 10UL; goto ldv_41187; ldv_41186: __const_udelay(4295000UL); ldv_41187: tmp___0 = __ms___0; __ms___0 = __ms___0 - 1UL; if (tmp___0 != 0UL) { goto ldv_41186; } else { } pI20_Regs->i20SysControl = 16777440U; pI20_Regs->i20GuestControl = 520115541U; __ms___1 = 10UL; goto ldv_41191; ldv_41190: __const_udelay(4295000UL); ldv_41191: tmp___1 = __ms___1; __ms___1 = __ms___1 - 1UL; if (tmp___1 != 0UL) { goto ldv_41190; } else { } pI20_Regs->i20GuestControl = (unsigned int )pI20_Regs->i20GuestControl & 4177526783U; __ms___2 = 10UL; goto ldv_41195; ldv_41194: __const_udelay(4295000UL); ldv_41195: tmp___2 = __ms___2; __ms___2 = __ms___2 - 1UL; if (tmp___2 != 0UL) { goto ldv_41194; } else { } } else { } return; } } static int BKM_card_msg(struct IsdnCardState *cs , int mt , void *arg ) { u_long flags ; raw_spinlock_t *tmp ; raw_spinlock_t *tmp___0 ; raw_spinlock_t *tmp___1 ; { switch (mt) { case 240: tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); enable_bkm_int(cs, 0U); reset_bkm(cs); spin_unlock_irqrestore(& cs->lock, flags); return (0); case 243: tmp___0 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___0); enable_bkm_int(cs, 0U); reset_bkm(cs); spin_unlock_irqrestore(& cs->lock, flags); release_io_bkm(cs); return (0); case 242: tmp___1 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___1); clear_pending_isac_ints(cs); clear_pending_jade_ints(cs); initisac(cs); initjade(cs); enable_bkm_int(cs, 1U); spin_unlock_irqrestore(& cs->lock, flags); return (0); case 244: ; return (0); } return (0); } } static int a4t_pci_probe(struct pci_dev *dev_a4t___0 , struct IsdnCardState *cs , u_int *found , u_int *pci_memaddr ) { u16 sub_sys ; u16 sub_vendor ; int tmp ; { sub_vendor = dev_a4t___0->subsystem_vendor; sub_sys = dev_a4t___0->subsystem_device; if ((unsigned int )sub_sys == 65444U && (unsigned int )sub_vendor == 2161U) { tmp = pci_enable_device(dev_a4t___0); if (tmp != 0) { return (0); } else { } *found = 1U; *pci_memaddr = (u_int )dev_a4t___0->resource[0].start; cs->irq = dev_a4t___0->irq; return (1); } else { } return (-1); } } static int a4t_cs_init(struct IsdnCard *card , struct IsdnCardState *cs , u_int pci_memaddr ) { I20_REGISTER_FILE *pI20_Regs ; void *tmp ; { if (cs->irq == 0U) { printk("\fHiSax: Telekom A4T: No IRQ\n"); return (0); } else { } tmp = ioremap((resource_size_t )pci_memaddr, 4096UL); cs->hw.ax.base = (unsigned long )tmp; pI20_Regs = (I20_REGISTER_FILE *)cs->hw.ax.base; if (((unsigned int )pI20_Regs->i20IntStatus & 2399141887U) != 0U) { printk("\fHiSax: Telekom A4T address %lx-%lx suspicious\n", cs->hw.ax.base, cs->hw.ax.base + 4096UL); iounmap((void volatile *)cs->hw.ax.base); cs->hw.ax.base = 0UL; return (0); } else { } cs->hw.ax.isac_adr = cs->hw.ax.base + 512UL; cs->hw.ax.jade_adr = cs->hw.ax.base + 512UL; cs->hw.ax.isac_ale = 1048576U; cs->hw.ax.jade_ale = 3145728U; printk("\016HiSax: Telekom A4T: Card configured at 0x%lX IRQ %d\n", cs->hw.ax.base, cs->irq); setup_isac(cs); cs->readisac = & ReadISAC___8; cs->writeisac = & WriteISAC___8; cs->readisacfifo = & ReadISACfifo___8; cs->writeisacfifo = & WriteISACfifo___8; cs->BC_Read_Reg = & ReadJADE; cs->BC_Write_Reg = & WriteJADE; cs->BC_Send_Data = & jade_fill_fifo; cs->cardmsg = & BKM_card_msg; cs->irq_func = & bkm_interrupt; cs->irq_flags = cs->irq_flags | 128UL; ISACVersion(cs, (char *)"Telekom A4T:"); JadeVersion(cs, (char *)"Telekom A4T:"); return (1); } } static struct pci_dev *dev_a4t = 0; int setup_bkm_a4t(struct IsdnCard *card ) { struct IsdnCardState *cs ; char tmp[64U] ; u_int pci_memaddr ; u_int found ; int ret ; char *tmp___0 ; int tmp___1 ; { cs = card->cs; pci_memaddr = 0U; found = 0U; strcpy((char *)(& tmp), bkm_a4t_revision); tmp___0 = HiSax_getrev((char const *)(& tmp)); printk("\016HiSax: T-Berkom driver Rev. %s\n", tmp___0); if ((unsigned int )cs->typ == 32U) { cs->subtyp = 5U; } else { return (0); } goto ldv_41241; ldv_41240: ret = a4t_pci_probe(dev_a4t, cs, & found, & pci_memaddr); if (ret == 0) { return (0); } else { } if (ret > 0) { goto ldv_41239; } else { } ldv_41241: dev_a4t = hisax_find_pci_device(4574U, 24864U, dev_a4t); if ((unsigned long )dev_a4t != (unsigned long )((struct pci_dev *)0)) { goto ldv_41240; } else { } ldv_41239: ; if (found == 0U) { printk("\fHiSax: Telekom A4T: Card not found\n"); return (0); } else { } if (pci_memaddr == 0U) { printk("\fHiSax: Telekom A4T: No Memory base address\n"); return (0); } else { } tmp___1 = a4t_cs_init(card, cs, pci_memaddr); return (tmp___1); } } void ldv_mutex_lock_449(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_lock(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_450(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_lock(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_451(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } int ldv_mutex_trylock_452(struct mutex *ldv_func_arg1 ) { ldv_func_ret_type___2 ldv_func_res ; int tmp ; int tmp___0 ; { tmp = mutex_trylock(ldv_func_arg1); ldv_func_res = tmp; tmp___0 = ldv_mutex_trylock_mutex(ldv_func_arg1); return (tmp___0); return (ldv_func_res); } } void ldv_mutex_unlock_453(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_454(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_cred_guard_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_455(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_cred_guard_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } int ldv_mutex_trylock_466(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_464(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_467(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_469(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_463(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_465(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_468(struct mutex *ldv_func_arg1 ) ; int JadeVersion(struct IsdnCardState *cs , char *s ) { int ver ; int to ; u_char tmp ; u_char tmp___0 ; { to = 50; (*(cs->BC_Write_Reg))(cs, -1, 80, 25); goto ldv_40991; ldv_40990: __const_udelay(4295UL); tmp = (*(cs->BC_Read_Reg))(cs, -1, 96); ver = (int )tmp; to = to - 1; if (ver != 0) { goto ldv_40989; } else { } if (to == 0) { printk("\016%s JADE version not obtainable\n", s); return (0); } else { } ldv_40991: ; if (to != 0) { goto ldv_40990; } else { } ldv_40989: __const_udelay(42950UL); tmp___0 = (*(cs->BC_Read_Reg))(cs, -1, 96); ver = (int )tmp___0; printk("\016%s JADE version: %d\n", s, ver); return (1); } } static void jade_write_indirect(struct IsdnCardState *cs , u_char reg , u_char value ) { int to ; u_char ret ; { to = 50; (*(cs->BC_Write_Reg))(cs, -1, 65, (int )value); (*(cs->BC_Write_Reg))(cs, -1, 64, (int )reg); to = 50; goto ldv_41001; ldv_41000: __const_udelay(4295UL); ret = (*(cs->BC_Read_Reg))(cs, -1, 64); to = to - 1; if ((int )ret & 1) { goto ldv_40999; } else { } if (to == 0) { printk("\016Can not see ready bit from JADE DSP (reg=0x%X, value=0x%X)\n", (int )reg, (int )value); return; } else { } ldv_41001: ; if (to != 0) { goto ldv_41000; } else { } ldv_40999: ; return; } } static void modejade(struct BCState *bcs , int mode , int bc ) { struct IsdnCardState *cs ; int jade ; char tmp[40U] ; { cs = bcs->cs; jade = bcs->hw.hscx.hscx; if ((cs->debug & 16) != 0) { sprintf((char *)(& tmp), "jade %c mode %d ichan %d", jade + 65, mode, bc); debugl1(cs, (char *)(& tmp)); } else { } bcs->mode = mode; bcs->channel = bc; (*(cs->BC_Write_Reg))(cs, jade, 34, mode == 1 ? 128 : 0); (*(cs->BC_Write_Reg))(cs, jade, 38, 192); (*(cs->BC_Write_Reg))(cs, jade, 39, 0); jade_write_indirect(cs, 29, 8); jade_write_indirect(cs, 31, 8); jade_write_indirect(cs, 30, 0); jade_write_indirect(cs, 32, 0); (*(cs->BC_Write_Reg))(cs, jade, 43, 7); (*(cs->BC_Write_Reg))(cs, jade, 42, 7); if (bc == 0) { (*(cs->BC_Write_Reg))(cs, jade, 41, 0); (*(cs->BC_Write_Reg))(cs, jade, 40, 0); } else { (*(cs->BC_Write_Reg))(cs, jade, 41, 4); (*(cs->BC_Write_Reg))(cs, jade, 40, 4); } switch (mode) { case 0: (*(cs->BC_Write_Reg))(cs, jade, 34, 128); goto ldv_41011; case 1: (*(cs->BC_Write_Reg))(cs, jade, 34, 224); goto ldv_41011; case 2: (*(cs->BC_Write_Reg))(cs, jade, 34, 96); goto ldv_41011; } ldv_41011: ; if (mode != 0) { (*(cs->BC_Write_Reg))(cs, jade, 37, 192); (*(cs->BC_Write_Reg))(cs, jade, 32, 32); (*(cs->BC_Write_Reg))(cs, jade, 44, 248); } else { (*(cs->BC_Write_Reg))(cs, jade, 44, 0); } return; } } static void jade_l2l1(struct PStack *st , int pr , void *arg ) { struct BCState *bcs ; struct sk_buff *skb ; u_long flags ; raw_spinlock_t *tmp ; raw_spinlock_t *tmp___0 ; raw_spinlock_t *tmp___1 ; raw_spinlock_t *tmp___2 ; { bcs = st->l1.bcs; skb = (struct sk_buff *)arg; switch (pr) { case 288: tmp = spinlock_check(& (bcs->cs)->lock); flags = _raw_spin_lock_irqsave(tmp); if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { skb_queue_tail(& bcs->squeue, skb); } else { bcs->tx_skb = skb; test_and_set_bit(3, (unsigned long volatile *)(& bcs->Flag)); bcs->hw.hscx.count = 0; (*((bcs->cs)->BC_Send_Data))(bcs); } spin_unlock_irqrestore(& (bcs->cs)->lock, flags); goto ldv_41026; case 306: tmp___0 = spinlock_check(& (bcs->cs)->lock); flags = _raw_spin_lock_irqsave(tmp___0); if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { printk("\fjade_l2l1: this shouldn\'t happen\n"); } else { test_and_set_bit(3, (unsigned long volatile *)(& bcs->Flag)); bcs->tx_skb = skb; bcs->hw.hscx.count = 0; (*((bcs->cs)->BC_Send_Data))(bcs); } spin_unlock_irqrestore(& (bcs->cs)->lock, flags); goto ldv_41026; case 304: ; if ((unsigned long )bcs->tx_skb == (unsigned long )((struct sk_buff *)0)) { test_and_clear_bit(6, (unsigned long volatile *)(& st->l1.Flags)); (*(st->l1.l1l2))(st, 305, 0); } else { test_and_set_bit(6, (unsigned long volatile *)(& st->l1.Flags)); } goto ldv_41026; case 256: tmp___1 = spinlock_check(& (bcs->cs)->lock); flags = _raw_spin_lock_irqsave(tmp___1); test_and_set_bit(2, (unsigned long volatile *)(& bcs->Flag)); modejade(bcs, st->l1.mode, st->l1.bc); spin_unlock_irqrestore(& (bcs->cs)->lock, flags); l1_msg_b(st, pr, arg); goto ldv_41026; case 272: l1_msg_b(st, pr, arg); goto ldv_41026; case 273: tmp___2 = spinlock_check(& (bcs->cs)->lock); flags = _raw_spin_lock_irqsave(tmp___2); test_and_clear_bit(2, (unsigned long volatile *)(& bcs->Flag)); test_and_clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); modejade(bcs, 0, st->l1.bc); spin_unlock_irqrestore(& (bcs->cs)->lock, flags); (*(st->l1.l1l2))(st, 273, 0); goto ldv_41026; } ldv_41026: ; return; } } static void close_jadestate(struct BCState *bcs ) { int tmp ; { modejade(bcs, 0, bcs->channel); tmp = test_and_clear_bit(1, (unsigned long volatile *)(& bcs->Flag)); if (tmp != 0) { kfree((void const *)bcs->hw.hscx.rcvbuf); bcs->hw.hscx.rcvbuf = 0; kfree((void const *)bcs->blog); bcs->blog = 0; skb_queue_purge(& bcs->rqueue); skb_queue_purge(& bcs->squeue); if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { dev_kfree_skb_any(bcs->tx_skb); bcs->tx_skb = 0; test_and_clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); } else { } } else { } return; } } static int open_jadestate(struct IsdnCardState *cs , struct BCState *bcs ) { u_char *tmp ; void *tmp___0 ; u_char *tmp___1 ; void *tmp___2 ; int tmp___3 ; { tmp___3 = test_and_set_bit(1, (unsigned long volatile *)(& bcs->Flag)); if (tmp___3 == 0) { tmp___0 = kmalloc(4096UL, 32U); tmp = (u_char *)tmp___0; bcs->hw.hscx.rcvbuf = tmp; if ((unsigned long )tmp == (unsigned long )((u_char *)0)) { printk("\fHiSax: No memory for hscx.rcvbuf\n"); test_and_clear_bit(1, (unsigned long volatile *)(& bcs->Flag)); return (1); } else { } tmp___2 = kmalloc(256UL, 32U); tmp___1 = (u_char *)tmp___2; bcs->blog = tmp___1; if ((unsigned long )tmp___1 == (unsigned long )((u_char *)0)) { printk("\fHiSax: No memory for bcs->blog\n"); test_and_clear_bit(1, (unsigned long volatile *)(& bcs->Flag)); kfree((void const *)bcs->hw.hscx.rcvbuf); bcs->hw.hscx.rcvbuf = 0; return (2); } else { } skb_queue_head_init(& bcs->rqueue); skb_queue_head_init(& bcs->squeue); } else { } bcs->tx_skb = 0; test_and_clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); bcs->event = 0UL; bcs->hw.hscx.rcvidx = 0; bcs->tx_cnt = 0; return (0); } } static int setstack_jade(struct PStack *st , struct BCState *bcs ) { int tmp ; { bcs->channel = st->l1.bc; tmp = open_jadestate((struct IsdnCardState *)st->l1.hardware, bcs); if (tmp != 0) { return (-1); } else { } st->l1.bcs = bcs; st->l2.l2l1 = & jade_l2l1; setstack_manager(st); bcs->st = st; setstack_l1_B(st); return (0); } } void clear_pending_jade_ints(struct IsdnCardState *cs ) { int val ; char tmp[64U] ; u_char tmp___0 ; u_char tmp___1 ; u_char tmp___2 ; u_char tmp___3 ; { (*(cs->BC_Write_Reg))(cs, 0, 44, 0); (*(cs->BC_Write_Reg))(cs, 1, 44, 0); tmp___0 = (*(cs->BC_Read_Reg))(cs, 1, 44); val = (int )tmp___0; sprintf((char *)(& tmp), "jade B ISTA %x", val); debugl1(cs, (char *)(& tmp)); tmp___1 = (*(cs->BC_Read_Reg))(cs, 0, 44); val = (int )tmp___1; sprintf((char *)(& tmp), "jade A ISTA %x", val); debugl1(cs, (char *)(& tmp)); tmp___2 = (*(cs->BC_Read_Reg))(cs, 1, 32); val = (int )tmp___2; sprintf((char *)(& tmp), "jade B STAR %x", val); debugl1(cs, (char *)(& tmp)); tmp___3 = (*(cs->BC_Read_Reg))(cs, 0, 32); val = (int )tmp___3; sprintf((char *)(& tmp), "jade A STAR %x", val); debugl1(cs, (char *)(& tmp)); (*(cs->BC_Write_Reg))(cs, 0, 44, 248); (*(cs->BC_Write_Reg))(cs, 1, 44, 248); return; } } void initjade(struct IsdnCardState *cs ) { { cs->bcs[0].BC_SetStack = & setstack_jade; cs->bcs[1].BC_SetStack = & setstack_jade; cs->bcs[0].BC_Close = & close_jadestate; cs->bcs[1].BC_Close = & close_jadestate; cs->bcs[0].hw.hscx.hscx = 0; cs->bcs[1].hw.hscx.hscx = 1; jade_write_indirect(cs, 17, 15); jade_write_indirect(cs, 23, 47); (*(cs->BC_Write_Reg))(cs, 0, 34, 128); (*(cs->BC_Write_Reg))(cs, 1, 34, 128); (*(cs->BC_Write_Reg))(cs, 0, 38, 0); (*(cs->BC_Write_Reg))(cs, 1, 38, 0); (*(cs->BC_Write_Reg))(cs, 0, 44, 0); (*(cs->BC_Write_Reg))(cs, 1, 44, 0); jade_write_indirect(cs, 16, 3); (*(cs->BC_Write_Reg))(cs, -1, 117, 3); modejade((struct BCState *)(& cs->bcs), 0, 0); modejade((struct BCState *)(& cs->bcs) + 1UL, 0, 0); return; } } void ldv_mutex_lock_463(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_lock(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_464(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_lock(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_465(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } int ldv_mutex_trylock_466(struct mutex *ldv_func_arg1 ) { ldv_func_ret_type___2 ldv_func_res ; int tmp ; int tmp___0 ; { tmp = mutex_trylock(ldv_func_arg1); ldv_func_res = tmp; tmp___0 = ldv_mutex_trylock_mutex(ldv_func_arg1); return (tmp___0); return (ldv_func_res); } } void ldv_mutex_unlock_467(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_468(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_cred_guard_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_469(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_cred_guard_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } int ldv_mutex_trylock_480(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_478(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_481(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_483(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_477(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_479(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_482(struct mutex *ldv_func_arg1 ) ; __inline static void outw(unsigned short value , int port ) { { __asm__ volatile ("outw %w0, %w1": : "a" (value), "Nd" (port)); return; } } __inline static unsigned short inw(int port ) { unsigned short value ; { __asm__ volatile ("inw %w1, %w0": "=a" (value): "Nd" (port)); return (value); } } static char const sct_quadro_revision[22U] = { '$', 'R', 'e', 'v', 'i', 's', 'i', 'o', 'n', ':', ' ', '1', '.', '2', '2', '.', '2', '.', '4', ' ', '$', '\000'}; static char const *sct_quadro_subtypes[5U] = { "", "#1", "#2", "#3", "#4"}; __inline static u_char readreg___6(unsigned int ale , unsigned int adr , u_char off ) { register u_char ret ; unsigned short tmp ; { outw((int )off, (int )ale); tmp = inw((int )adr); ret = (u_char )tmp; return (ret); } } __inline static void readfifo___4(unsigned int ale , unsigned int adr , u_char off , u_char *data , int size ) { int i ; unsigned short tmp ; { outw((int )off, (int )ale); i = 0; goto ldv_41026; ldv_41025: tmp = inw((int )adr); *(data + (unsigned long )i) = (u_char )tmp; i = i + 1; ldv_41026: ; if (i < size) { goto ldv_41025; } else { } return; } } __inline static void writereg___6(unsigned int ale , unsigned int adr , u_char off , u_char data ) { { outw((int )off, (int )ale); outw((int )data, (int )adr); return; } } __inline static void writefifo___4(unsigned int ale , unsigned int adr , u_char off , u_char *data , int size ) { int i ; { outw((int )off, (int )ale); i = 0; goto ldv_41043; ldv_41042: outw((int )*(data + (unsigned long )i), (int )adr); i = i + 1; ldv_41043: ; if (i < size) { goto ldv_41042; } else { } return; } } static u_char ReadISAC___9(struct IsdnCardState *cs , u_char offset ) { u_char tmp ; { tmp = readreg___6((unsigned int )cs->hw.ax.base, (unsigned int )cs->hw.ax.data_adr, (int )((unsigned int )offset | 128U)); return (tmp); } } static void WriteISAC___9(struct IsdnCardState *cs , u_char offset , u_char value ) { { writereg___6((unsigned int )cs->hw.ax.base, (unsigned int )cs->hw.ax.data_adr, (int )((unsigned int )offset | 128U), (int )value); return; } } static void ReadISACfifo___9(struct IsdnCardState *cs , u_char *data , int size ) { { readfifo___4((unsigned int )cs->hw.ax.base, (unsigned int )cs->hw.ax.data_adr, 128, data, size); return; } } static void WriteISACfifo___9(struct IsdnCardState *cs , u_char *data , int size ) { { writefifo___4((unsigned int )cs->hw.ax.base, (unsigned int )cs->hw.ax.data_adr, 128, data, size); return; } } static u_char ReadHSCX___7(struct IsdnCardState *cs , int hscx , u_char offset ) { u_char tmp ; { tmp = readreg___6((unsigned int )cs->hw.ax.base, (unsigned int )cs->hw.ax.data_adr, (int )((hscx != 0 ? 64U : 0U) + (unsigned int )offset)); return (tmp); } } static void WriteHSCX___7(struct IsdnCardState *cs , int hscx , u_char offset , u_char value ) { { writereg___6((unsigned int )cs->hw.ax.base, (unsigned int )cs->hw.ax.data_adr, (int )((hscx != 0 ? 64U : 0U) + (unsigned int )offset), (int )value); return; } } static void set_ipac_active(struct IsdnCardState *cs , u_int active ) { { writereg___6((unsigned int )cs->hw.ax.base, (unsigned int )cs->hw.ax.data_adr, 193, active != 0U ? 192 : 255); return; } } __inline static void waitforCEC___8(struct IsdnCardState *cs , int hscx ) { int to ; u_char tmp ; { to = 50; goto ldv_41085; ldv_41084: __const_udelay(4295UL); to = to - 1; ldv_41085: tmp = readreg___6((unsigned int )cs->hw.ax.base, (unsigned int )cs->hw.ax.data_adr, hscx != 0 ? 97 : 33); if (((int )tmp & 4) != 0 && to != 0) { goto ldv_41084; } else { } if (to == 0) { printk("\fHiSax: waitforCEC timeout\n"); } else { } return; } } __inline static void waitforXFW___8(struct IsdnCardState *cs , int hscx ) { int to ; u_char tmp ; { to = 50; goto ldv_41093; ldv_41092: __const_udelay(4295UL); to = to - 1; ldv_41093: tmp = readreg___6((unsigned int )cs->hw.ax.base, (unsigned int )cs->hw.ax.data_adr, hscx != 0 ? 97 : 33); if (((int )tmp & 68) != 64 && to != 0) { goto ldv_41092; } else { } if (to == 0) { printk("\fHiSax: waitforXFW timeout\n"); } else { } return; } } __inline static void WriteHSCXCMDR___7(struct IsdnCardState *cs , int hscx , u_char data ) { { waitforCEC___8(cs, hscx); writereg___6((unsigned int )cs->hw.ax.base, (unsigned int )cs->hw.ax.data_adr, hscx != 0 ? 97 : 33, (int )data); return; } } static void hscx_empty_fifo___7(struct BCState *bcs , int count ) { u_char *ptr ; struct IsdnCardState *cs ; char *t ; int tmp ; { cs = bcs->cs; if ((cs->debug & 16) != 0 && (cs->debug & 32) == 0) { debugl1(cs, (char *)"hscx_empty_fifo"); } else { } if (bcs->hw.hscx.rcvidx + count > 4096) { if (cs->debug & 1) { debugl1(cs, (char *)"hscx_empty_fifo: incoming packet too large"); } else { } WriteHSCXCMDR___7(cs, bcs->hw.hscx.hscx, 128); bcs->hw.hscx.rcvidx = 0; return; } else { } ptr = bcs->hw.hscx.rcvbuf + (unsigned long )bcs->hw.hscx.rcvidx; bcs->hw.hscx.rcvidx = bcs->hw.hscx.rcvidx + count; readfifo___4((unsigned int )cs->hw.ax.base, (unsigned int )cs->hw.ax.data_adr, bcs->hw.hscx.hscx != 0 ? 64 : 0, ptr, count); WriteHSCXCMDR___7(cs, bcs->hw.hscx.hscx, 128); if ((cs->debug & 32) != 0) { t = (char *)bcs->blog; tmp = sprintf(t, "hscx_empty_fifo %c cnt %d", bcs->hw.hscx.hscx != 0 ? 66 : 65, count); t = t + (unsigned long )tmp; QuickHex(t, ptr, count); debugl1(cs, (char *)bcs->blog); } else { } return; } } static void hscx_fill_fifo___7(struct BCState *bcs ) { struct IsdnCardState *cs ; int more ; int count ; int fifo_size ; int tmp ; u_char *ptr ; char *t ; int tmp___0 ; { cs = bcs->cs; tmp = constant_test_bit(1U, (unsigned long const volatile *)(& cs->HW_Flags)); fifo_size = tmp != 0 ? 64 : 32; if ((cs->debug & 16) != 0 && (cs->debug & 32) == 0) { debugl1(cs, (char *)"hscx_fill_fifo"); } else { } if ((unsigned long )bcs->tx_skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } if ((bcs->tx_skb)->len == 0U) { return; } else { } more = bcs->mode == 1; if ((bcs->tx_skb)->len > (unsigned int )fifo_size) { more = 1; count = fifo_size; } else { count = (int )(bcs->tx_skb)->len; } waitforXFW___8(cs, bcs->hw.hscx.hscx); ptr = (bcs->tx_skb)->data; skb_pull(bcs->tx_skb, (unsigned int )count); bcs->tx_cnt = bcs->tx_cnt - count; bcs->hw.hscx.count = bcs->hw.hscx.count + count; writefifo___4((unsigned int )cs->hw.ax.base, (unsigned int )cs->hw.ax.data_adr, bcs->hw.hscx.hscx != 0 ? 64 : 0, ptr, count); WriteHSCXCMDR___7(cs, bcs->hw.hscx.hscx, more != 0 ? 8 : 10); if ((cs->debug & 32) != 0) { t = (char *)bcs->blog; tmp___0 = sprintf(t, "hscx_fill_fifo %c cnt %d", bcs->hw.hscx.hscx != 0 ? 66 : 65, count); t = t + (unsigned long )tmp___0; QuickHex(t, ptr, count); debugl1(cs, (char *)bcs->blog); } else { } return; } } static void hscx_interrupt___7(struct IsdnCardState *cs , u_char val , u_char hscx ) { u_char r ; struct BCState *bcs ; struct sk_buff *skb ; int fifo_size ; int tmp ; int count ; int tmp___0 ; u_char tmp___1 ; int tmp___2 ; size_t __len ; void *__ret ; unsigned char *tmp___4 ; size_t __len___0 ; void *__ret___0 ; unsigned char *tmp___6 ; u_long flags ; raw_spinlock_t *tmp___7 ; int tmp___8 ; struct sk_buff *tmp___9 ; { bcs = (struct BCState *)(& cs->bcs) + (unsigned long )hscx; tmp = constant_test_bit(1U, (unsigned long const volatile *)(& cs->HW_Flags)); fifo_size = tmp != 0 ? 64 : 32; tmp___0 = constant_test_bit(1U, (unsigned long const volatile *)(& bcs->Flag)); if (tmp___0 == 0) { return; } else { } if ((int )((signed char )val) < 0) { r = readreg___6((unsigned int )cs->hw.ax.base, (unsigned int )cs->hw.ax.data_adr, (unsigned int )hscx != 0U ? 103 : 39); if (((int )r & 240) != 160) { if ((int )((signed char )r) >= 0) { if (cs->debug & 1) { debugl1(cs, (char *)"HSCX invalid frame"); } else { } bcs->err_inv = bcs->err_inv + 1; } else { } if (((int )r & 64) != 0 && bcs->mode != 0) { if (cs->debug & 1) { debugl1(cs, (char *)"HSCX RDO mode=%d", bcs->mode); } else { } bcs->err_rdo = bcs->err_rdo + 1; } else { } if (((int )r & 32) == 0) { if (cs->debug & 1) { debugl1(cs, (char *)"HSCX CRC error"); } else { } bcs->err_crc = bcs->err_crc + 1; } else { } WriteHSCXCMDR___7(cs, (int )hscx, 128); } else { tmp___1 = readreg___6((unsigned int )cs->hw.ax.base, (unsigned int )cs->hw.ax.data_adr, (unsigned int )hscx != 0U ? 101 : 37); tmp___2 = constant_test_bit(1U, (unsigned long const volatile *)(& cs->HW_Flags)); count = (int )tmp___1 & (tmp___2 != 0 ? 63 : 31); if (count == 0) { count = fifo_size; } else { } hscx_empty_fifo___7(bcs, count); count = bcs->hw.hscx.rcvidx + -1; if (count > 0) { if ((cs->debug & 32) != 0) { debugl1(cs, (char *)"HX Frame %d", count); } else { } skb = dev_alloc_skb((unsigned int )count); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { printk("\fHSCX: receive out of memory\n"); } else { __len = (size_t )count; tmp___4 = skb_put(skb, (unsigned int )count); __ret = memcpy((void *)tmp___4, (void const *)bcs->hw.hscx.rcvbuf, __len); skb_queue_tail(& bcs->rqueue, skb); } } else { } } bcs->hw.hscx.rcvidx = 0; test_and_set_bit(0, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } if (((int )val & 64) != 0) { hscx_empty_fifo___7(bcs, fifo_size); if (bcs->mode == 1) { skb = dev_alloc_skb((unsigned int )fifo_size); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { printk("\fHiSax: receive out of memory\n"); } else { __len___0 = (size_t )fifo_size; tmp___6 = skb_put(skb, (unsigned int )fifo_size); __ret___0 = memcpy((void *)tmp___6, (void const *)bcs->hw.hscx.rcvbuf, __len___0); skb_queue_tail(& bcs->rqueue, skb); } bcs->hw.hscx.rcvidx = 0; test_and_set_bit(0, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } } else { } if (((int )val & 16) != 0) { if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { if ((bcs->tx_skb)->len != 0U) { hscx_fill_fifo___7(bcs); return; } else { tmp___8 = constant_test_bit(1U, (unsigned long const volatile *)(& (bcs->st)->lli.flag)); if (tmp___8 != 0 && (unsigned int )*((unsigned char *)bcs->tx_skb + 125UL) != 7U) { tmp___7 = spinlock_check(& bcs->aclock); flags = _raw_spin_lock_irqsave(tmp___7); bcs->ackcnt = bcs->ackcnt + bcs->hw.hscx.count; spin_unlock_irqrestore(& bcs->aclock, flags); test_and_set_bit(2, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } dev_kfree_skb_irq(bcs->tx_skb); bcs->hw.hscx.count = 0; bcs->tx_skb = 0; } } else { } tmp___9 = skb_dequeue(& bcs->squeue); bcs->tx_skb = tmp___9; if ((unsigned long )tmp___9 != (unsigned long )((struct sk_buff *)0)) { bcs->hw.hscx.count = 0; test_and_set_bit(3, (unsigned long volatile *)(& bcs->Flag)); hscx_fill_fifo___7(bcs); } else { test_and_clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); test_and_set_bit(1, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } } else { } return; } } static void hscx_int_main___7(struct IsdnCardState *cs , u_char val ) { u_char exval ; struct BCState *bcs ; { if ((int )val & 1) { bcs = (struct BCState *)(& cs->bcs) + 1UL; exval = readreg___6((unsigned int )cs->hw.ax.base, (unsigned int )cs->hw.ax.data_adr, 100); if (((int )exval & 64) != 0) { if (bcs->mode == 1) { hscx_fill_fifo___7(bcs); } else { bcs->err_tx = bcs->err_tx + 1; if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { skb_push(bcs->tx_skb, (unsigned int )bcs->hw.hscx.count); bcs->tx_cnt = bcs->tx_cnt + bcs->hw.hscx.count; bcs->hw.hscx.count = 0; } else { } WriteHSCXCMDR___7(cs, bcs->hw.hscx.hscx, 1); if (cs->debug & 1) { debugl1(cs, (char *)"HSCX B EXIR %x Lost TX", (int )exval); } else { } } } else if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HSCX B EXIR %x", (int )exval); } else { } } else { } if (((int )val & 248) != 0) { if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HSCX B interrupt %x", (int )val); } else { } hscx_interrupt___7(cs, (int )val, 1); } else { } if (((int )val & 2) != 0) { bcs = (struct BCState *)(& cs->bcs); exval = readreg___6((unsigned int )cs->hw.ax.base, (unsigned int )cs->hw.ax.data_adr, 36); if (((int )exval & 64) != 0) { if (bcs->mode == 1) { hscx_fill_fifo___7(bcs); } else { bcs->err_tx = bcs->err_tx + 1; if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { skb_push(bcs->tx_skb, (unsigned int )bcs->hw.hscx.count); bcs->tx_cnt = bcs->tx_cnt + bcs->hw.hscx.count; bcs->hw.hscx.count = 0; } else { } WriteHSCXCMDR___7(cs, bcs->hw.hscx.hscx, 1); if (cs->debug & 1) { debugl1(cs, (char *)"HSCX A EXIR %x Lost TX", (int )exval); } else { } } } else if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HSCX A EXIR %x", (int )exval); } else { } } else { } if (((int )val & 4) != 0) { exval = readreg___6((unsigned int )cs->hw.ax.base, (unsigned int )cs->hw.ax.data_adr, 32); if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HSCX A interrupt %x", (int )exval); } else { } hscx_interrupt___7(cs, (int )exval, 0); } else { } return; } } static irqreturn_t bkm_interrupt_ipac(int intno , void *dev_id ) { struct IsdnCardState *cs ; u_char ista ; u_char val ; u_char icnt ; u_long flags ; raw_spinlock_t *tmp ; u_char tmp___0 ; { cs = (struct IsdnCardState *)dev_id; icnt = 5U; tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); ista = readreg___6((unsigned int )cs->hw.ax.base, (unsigned int )cs->hw.ax.data_adr, 193); if (((int )ista & 63) == 0) { spin_unlock_irqrestore(& cs->lock, flags); return (0); } else { } Start_IPAC: ; if ((cs->debug & 128) != 0) { debugl1(cs, (char *)"IPAC ISTA %02X", (int )ista); } else { } if (((int )ista & 15) != 0) { val = readreg___6((unsigned int )cs->hw.ax.base, (unsigned int )cs->hw.ax.data_adr, 96); if ((int )ista & 1) { val = (u_char )((unsigned int )val | 1U); } else { } if (((int )ista & 4) != 0) { val = (u_char )((unsigned int )val | 2U); } else { } if (((int )ista & 8) != 0) { val = (u_char )((unsigned int )val | 4U); } else { } if ((unsigned int )val != 0U) { hscx_int_main___7(cs, (int )val); } else { } } else { } if (((int )ista & 32) != 0) { tmp___0 = readreg___6((unsigned int )cs->hw.ax.base, (unsigned int )cs->hw.ax.data_adr, 160); val = (unsigned int )tmp___0 & 254U; if ((unsigned int )val != 0U) { isac_interrupt(cs, (int )val); } else { } } else { } if (((int )ista & 16) != 0) { val = 1U; isac_interrupt(cs, (int )val); } else { } ista = readreg___6((unsigned int )cs->hw.ax.base, (unsigned int )cs->hw.ax.data_adr, 193); if (((int )ista & 63) != 0 && (unsigned int )icnt != 0U) { icnt = (u_char )((int )icnt - 1); goto Start_IPAC; } else { } if ((unsigned int )icnt == 0U) { printk("\fHiSax: Scitel Quadro (%s) IRQ LOOP\n", sct_quadro_subtypes[(int )cs->subtyp]); } else { } writereg___6((unsigned int )cs->hw.ax.base, (unsigned int )cs->hw.ax.data_adr, 193, 255); writereg___6((unsigned int )cs->hw.ax.base, (unsigned int )cs->hw.ax.data_adr, 193, 192); spin_unlock_irqrestore(& cs->lock, flags); return (1); } } static void release_io_sct_quadro(struct IsdnCardState *cs ) { { __release_region(& ioport_resource, (resource_size_t )cs->hw.ax.base & 4294967232ULL, 128ULL); if ((unsigned int )cs->subtyp == 1U) { __release_region(& ioport_resource, (resource_size_t )cs->hw.ax.plx_adr, 64ULL); } else { } return; } } static void enable_bkm_int___0(struct IsdnCardState *cs , unsigned int bEnable ) { unsigned short tmp ; unsigned short tmp___0 ; { if ((unsigned int )cs->typ == 33U) { if (bEnable != 0U) { tmp = inw((int )((unsigned int )cs->hw.ax.plx_adr + 76U)); outw((int )((unsigned int )tmp | 65U), (int )((unsigned int )cs->hw.ax.plx_adr + 76U)); } else { tmp___0 = inw((int )((unsigned int )cs->hw.ax.plx_adr + 76U)); outw((int )tmp___0 & 65470, (int )((unsigned int )cs->hw.ax.plx_adr + 76U)); } } else { } return; } } static void reset_bkm___0(struct IsdnCardState *cs ) { unsigned short tmp ; unsigned long __ms ; unsigned long tmp___0 ; unsigned short tmp___1 ; unsigned long __ms___0 ; unsigned long tmp___2 ; { if ((unsigned int )cs->subtyp == 1U) { tmp = inw((int )((unsigned int )cs->hw.ax.plx_adr + 80U)); outw((int )tmp & 65531, (int )((unsigned int )cs->hw.ax.plx_adr + 80U)); __ms = 10UL; goto ldv_41167; ldv_41166: __const_udelay(4295000UL); ldv_41167: tmp___0 = __ms; __ms = __ms - 1UL; if (tmp___0 != 0UL) { goto ldv_41166; } else { } tmp___1 = inw((int )((unsigned int )cs->hw.ax.plx_adr + 80U)); outw((int )((unsigned int )tmp___1 | 4U), (int )((unsigned int )cs->hw.ax.plx_adr + 80U)); __ms___0 = 10UL; goto ldv_41171; ldv_41170: __const_udelay(4295000UL); ldv_41171: tmp___2 = __ms___0; __ms___0 = __ms___0 - 1UL; if (tmp___2 != 0UL) { goto ldv_41170; } else { } } else { } return; } } static int BKM_card_msg___0(struct IsdnCardState *cs , int mt , void *arg ) { u_long flags ; raw_spinlock_t *tmp ; raw_spinlock_t *tmp___0 ; raw_spinlock_t *tmp___1 ; { switch (mt) { case 240: tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); set_ipac_active(cs, 0U); enable_bkm_int___0(cs, 0U); reset_bkm___0(cs); spin_unlock_irqrestore(& cs->lock, flags); return (0); case 243: tmp___0 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___0); set_ipac_active(cs, 0U); enable_bkm_int___0(cs, 0U); spin_unlock_irqrestore(& cs->lock, flags); release_io_sct_quadro(cs); return (0); case 242: tmp___1 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___1); cs->debug = cs->debug | 128; set_ipac_active(cs, 1U); inithscxisac(cs, 3); enable_bkm_int___0(cs, 1U); spin_unlock_irqrestore(& cs->lock, flags); return (0); case 244: ; return (0); } return (0); } } static int sct_alloc_io(u_int adr , u_int len ) { struct resource *tmp ; { tmp = __request_region(& ioport_resource, (resource_size_t )adr, (resource_size_t )len, "scitel", 0); if ((unsigned long )tmp == (unsigned long )((struct resource *)0)) { printk("\fHiSax: Scitel port %#x-%#x already in use\n", adr, adr + len); return (1); } else { } return (0); } } static struct pci_dev *dev_a8 = 0; static u16 sub_vendor_id = 0U; static u16 sub_sys_id = 0U; static u_char pci_bus = 0U; static u_char pci_device_fn = 0U; static u_char pci_irq = 0U; int setup_sct_quadro(struct IsdnCard *card ) { struct IsdnCardState *cs ; char tmp[64U] ; u_int found ; u_int pci_ioaddr1 ; u_int pci_ioaddr2 ; u_int pci_ioaddr3 ; u_int pci_ioaddr4 ; u_int pci_ioaddr5 ; char *tmp___0 ; int tmp___1 ; int tmp___2 ; int tmp___3 ; int tmp___4 ; int tmp___5 ; int tmp___6 ; u_char tmp___7 ; { cs = card->cs; found = 0U; strcpy((char *)(& tmp), (char const *)(& sct_quadro_revision)); tmp___0 = HiSax_getrev((char const *)(& tmp)); printk("\016HiSax: T-Berkom driver Rev. %s\n", tmp___0); if ((unsigned int )cs->typ == 33U) { cs->subtyp = 1U; } else { return (0); } if (card->para[0] != 0UL && card->para[0] <= 4UL) { cs->subtyp = (u_char )card->para[0]; } else { printk("\fHiSax: Scitel Quadro: Invalid subcontroller in configuration, default to 1\n"); return (0); } if ((unsigned int )cs->subtyp != 1U && ((unsigned int )sub_sys_id != 65448U || (unsigned int )sub_vendor_id != 2161U)) { return (0); } else { } if ((unsigned int )cs->subtyp == 1U) { goto ldv_41215; ldv_41214: sub_vendor_id = dev_a8->subsystem_vendor; sub_sys_id = dev_a8->subsystem_device; if ((unsigned int )sub_sys_id == 65448U && (unsigned int )sub_vendor_id == 2161U) { tmp___1 = pci_enable_device(dev_a8); if (tmp___1 != 0) { return (0); } else { } pci_ioaddr1 = (u_int )dev_a8->resource[1].start; pci_irq = (u_char )dev_a8->irq; pci_bus = (dev_a8->bus)->number; pci_device_fn = (u_char )dev_a8->devfn; found = 1U; goto ldv_41213; } else { } ldv_41215: dev_a8 = hisax_find_pci_device(4277U, 36944U, dev_a8); if ((unsigned long )dev_a8 != (unsigned long )((struct pci_dev *)0)) { goto ldv_41214; } else { } ldv_41213: ; if (found == 0U) { printk("\fHiSax: Scitel Quadro (%s): Card not found\n", sct_quadro_subtypes[(int )cs->subtyp]); return (0); } else { } if ((pci_ioaddr1 & 128U) != 0U && (unsigned int )dev_a8->revision == 1U) { printk("\fHiSax: Scitel Quadro (%s): PLX rev 1, remapping required!\n", sct_quadro_subtypes[(int )cs->subtyp]); pci_write_config_dword((struct pci_dev const *)dev_a8, 20, 4294967295U); pci_ioaddr1 = pci_ioaddr1 + 128U; pci_ioaddr1 = pci_ioaddr1 & 4294967292U; pci_write_config_dword((struct pci_dev const *)dev_a8, 20, pci_ioaddr1); dev_a8->resource[1].start = (resource_size_t )pci_ioaddr1; } else { } } else { } if ((unsigned int )pci_irq == 0U) { printk("\fHiSax: Scitel Quadro (%s): No IRQ\n", sct_quadro_subtypes[(int )cs->subtyp]); return (0); } else { } pci_read_config_dword((struct pci_dev const *)dev_a8, 20, & pci_ioaddr1); pci_read_config_dword((struct pci_dev const *)dev_a8, 24, & pci_ioaddr2); pci_read_config_dword((struct pci_dev const *)dev_a8, 28, & pci_ioaddr3); pci_read_config_dword((struct pci_dev const *)dev_a8, 32, & pci_ioaddr4); pci_read_config_dword((struct pci_dev const *)dev_a8, 36, & pci_ioaddr5); if ((((pci_ioaddr1 == 0U || pci_ioaddr2 == 0U) || pci_ioaddr3 == 0U) || pci_ioaddr4 == 0U) || pci_ioaddr5 == 0U) { printk("\fHiSax: Scitel Quadro (%s): No IO base address(es)\n", sct_quadro_subtypes[(int )cs->subtyp]); return (0); } else { } pci_ioaddr1 = pci_ioaddr1 & 4294967292U; pci_ioaddr2 = pci_ioaddr2 & 4294967292U; pci_ioaddr3 = pci_ioaddr3 & 4294967292U; pci_ioaddr4 = pci_ioaddr4 & 4294967292U; pci_ioaddr5 = pci_ioaddr5 & 4294967292U; cs->irq = (u_int )pci_irq; cs->irq_flags = cs->irq_flags | 128UL; cs->hw.ax.plx_adr = (unsigned long )pci_ioaddr1; switch ((int )cs->subtyp) { case 1: cs->hw.ax.base = (unsigned long )pci_ioaddr5; tmp___2 = sct_alloc_io(pci_ioaddr1, 128U); if (tmp___2 != 0) { return (0); } else { } tmp___3 = sct_alloc_io(pci_ioaddr5, 64U); if (tmp___3 != 0) { return (0); } else { } writereg___6(pci_ioaddr5, pci_ioaddr5 + 4U, 193, 255); writereg___6(pci_ioaddr4 + 8U, pci_ioaddr4 + 12U, 193, 255); writereg___6(pci_ioaddr3 + 16U, pci_ioaddr3 + 20U, 193, 255); writereg___6(pci_ioaddr2 + 32U, pci_ioaddr2 + 36U, 193, 255); goto ldv_41217; case 2: cs->hw.ax.base = (unsigned long )(pci_ioaddr4 + 8U); tmp___4 = sct_alloc_io(pci_ioaddr4, 64U); if (tmp___4 != 0) { return (0); } else { } goto ldv_41217; case 3: cs->hw.ax.base = (unsigned long )(pci_ioaddr3 + 16U); tmp___5 = sct_alloc_io(pci_ioaddr3, 64U); if (tmp___5 != 0) { return (0); } else { } goto ldv_41217; case 4: cs->hw.ax.base = (unsigned long )(pci_ioaddr2 + 32U); tmp___6 = sct_alloc_io(pci_ioaddr2, 64U); if (tmp___6 != 0) { return (0); } else { } goto ldv_41217; } ldv_41217: cs->hw.ax.data_adr = cs->hw.ax.base + 4UL; printk("\016HiSax: Scitel Quadro (%s) configured at 0x%.4lX, 0x%.4lX, 0x%.4lX and IRQ %d\n", sct_quadro_subtypes[(int )cs->subtyp], cs->hw.ax.plx_adr, cs->hw.ax.base, cs->hw.ax.data_adr, cs->irq); test_and_set_bit(1, (unsigned long volatile *)(& cs->HW_Flags)); cs->readisac = & ReadISAC___9; cs->writeisac = & WriteISAC___9; cs->readisacfifo = & ReadISACfifo___9; cs->writeisacfifo = & WriteISACfifo___9; cs->BC_Read_Reg = & ReadHSCX___7; cs->BC_Write_Reg = & WriteHSCX___7; cs->BC_Send_Data = & hscx_fill_fifo___7; cs->cardmsg = & BKM_card_msg___0; cs->irq_func = & bkm_interrupt_ipac; tmp___7 = readreg___6((unsigned int )cs->hw.ax.base, (unsigned int )cs->hw.ax.data_adr, 194); printk("\016HiSax: Scitel Quadro (%s): IPAC Version %d\n", sct_quadro_subtypes[(int )cs->subtyp], (int )tmp___7); return (1); } } void ldv_mutex_lock_477(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_lock(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_478(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_lock(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_479(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } int ldv_mutex_trylock_480(struct mutex *ldv_func_arg1 ) { ldv_func_ret_type___2 ldv_func_res ; int tmp ; int tmp___0 ; { tmp = mutex_trylock(ldv_func_arg1); ldv_func_res = tmp; tmp___0 = ldv_mutex_trylock_mutex(ldv_func_arg1); return (tmp___0); return (ldv_func_res); } } void ldv_mutex_unlock_481(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_482(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_cred_guard_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_483(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_cred_guard_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } int ldv_mutex_trylock_494(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_492(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_495(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_497(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_491(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_493(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_496(struct mutex *ldv_func_arg1 ) ; static char const *gazel_revision = "$Revision: 2.19.2.4 $"; __inline static u_char readreg___7(unsigned int adr , u_short off ) { unsigned char tmp ; { tmp = inb((int )((unsigned int )off + adr)); return (tmp); } } __inline static void writereg___7(unsigned int adr , u_short off , u_char data ) { { outb((int )data, (int )((unsigned int )off + adr)); return; } } static void write_fifo___2(unsigned int adr , u_char *data , int size ) { { outsb((int )adr, (void const *)data, (unsigned long )size); return; } } __inline static u_char readreg_ipac(unsigned int adr , u_short off ) { register u_char ret ; { outb((int )((unsigned char )off), (int )adr); ret = inb((int )(adr + 4U)); return (ret); } } __inline static void writereg_ipac(unsigned int adr , u_short off , u_char data ) { { outb((int )((unsigned char )off), (int )adr); outb((int )data, (int )(adr + 4U)); return; } } __inline static void read_fifo_ipac(unsigned int adr , u_short off , u_char *data , int size ) { { outb((int )((unsigned char )off), (int )adr); insb((int )(adr + 4U), (void *)data, (unsigned long )size); return; } } static void write_fifo_ipac(unsigned int adr , u_short off , u_char *data , int size ) { { outb((int )((unsigned char )off), (int )adr); outsb((int )(adr + 4U), (void const *)data, (unsigned long )size); return; } } static u_char ReadISAC___10(struct IsdnCardState *cs , u_char offset ) { u_short off2 ; u_char tmp ; u_char tmp___0 ; { off2 = (u_short )offset; switch ((int )cs->subtyp) { case 1: off2 = (u_short )(((int )((short )((int )off2 << 8)) & -4096) | ((int )((short )off2) & 15)); case 2: tmp = readreg___7((unsigned int )cs->hw.gazel.isac, (int )off2); return (tmp); case 3: ; case 4: tmp___0 = readreg_ipac((unsigned int )cs->hw.gazel.ipac, (int )((unsigned int )off2 + 128U)); return (tmp___0); } return (0U); } } static void WriteISAC___10(struct IsdnCardState *cs , u_char offset , u_char value ) { u_short off2 ; { off2 = (u_short )offset; switch ((int )cs->subtyp) { case 1: off2 = (u_short )(((int )((short )((int )off2 << 8)) & -4096) | ((int )((short )off2) & 15)); case 2: writereg___7((unsigned int )cs->hw.gazel.isac, (int )off2, (int )value); goto ldv_41047; case 3: ; case 4: writereg_ipac((unsigned int )cs->hw.gazel.ipac, (int )((unsigned int )off2 + 128U), (int )value); goto ldv_41047; } ldv_41047: ; return; } } static void ReadISACfifo___10(struct IsdnCardState *cs , u_char *data , int size ) { { switch ((int )cs->subtyp) { case 1: ; case 2: read_fifo((unsigned int )cs->hw.gazel.isacfifo, data, size); goto ldv_41057; case 3: ; case 4: read_fifo_ipac((unsigned int )cs->hw.gazel.ipac, 128, data, size); goto ldv_41057; } ldv_41057: ; return; } } static void WriteISACfifo___10(struct IsdnCardState *cs , u_char *data , int size ) { { switch ((int )cs->subtyp) { case 1: ; case 2: write_fifo___2((unsigned int )cs->hw.gazel.isacfifo, data, size); goto ldv_41067; case 3: ; case 4: write_fifo_ipac((unsigned int )cs->hw.gazel.ipac, 128, data, size); goto ldv_41067; } ldv_41067: ; return; } } static void ReadHSCXfifo___0(struct IsdnCardState *cs , int hscx , u_char *data , int size ) { { switch ((int )cs->subtyp) { case 1: ; case 2: read_fifo((unsigned int )cs->hw.gazel.hscxfifo[hscx], data, size); goto ldv_41078; case 3: ; case 4: read_fifo_ipac((unsigned int )cs->hw.gazel.ipac, (int )((unsigned int )((u_short )hscx) * 64U), data, size); goto ldv_41078; } ldv_41078: ; return; } } static void WriteHSCXfifo___0(struct IsdnCardState *cs , int hscx , u_char *data , int size ) { { switch ((int )cs->subtyp) { case 1: ; case 2: write_fifo___2((unsigned int )cs->hw.gazel.hscxfifo[hscx], data, size); goto ldv_41089; case 3: ; case 4: write_fifo_ipac((unsigned int )cs->hw.gazel.ipac, (int )((unsigned int )((u_short )hscx) * 64U), data, size); goto ldv_41089; } ldv_41089: ; return; } } static u_char ReadHSCX___8(struct IsdnCardState *cs , int hscx , u_char offset ) { u_short off2 ; u_char tmp ; u_char tmp___0 ; { off2 = (u_short )offset; switch ((int )cs->subtyp) { case 1: off2 = (u_short )(((int )((short )((int )off2 << 8)) & -4096) | ((int )((short )off2) & 15)); case 2: tmp = readreg___7((unsigned int )cs->hw.gazel.hscx[hscx], (int )off2); return (tmp); case 3: ; case 4: tmp___0 = readreg_ipac((unsigned int )cs->hw.gazel.ipac, (int )((unsigned int )((u_short )hscx) * 64U + (unsigned int )off2)); return (tmp___0); } return (0U); } } static void WriteHSCX___8(struct IsdnCardState *cs , int hscx , u_char offset , u_char value ) { u_short off2 ; { off2 = (u_short )offset; switch ((int )cs->subtyp) { case 1: off2 = (u_short )(((int )((short )((int )off2 << 8)) & -4096) | ((int )((short )off2) & 15)); case 2: writereg___7((unsigned int )cs->hw.gazel.hscx[hscx], (int )off2, (int )value); goto ldv_41111; case 3: ; case 4: writereg_ipac((unsigned int )cs->hw.gazel.ipac, (int )((unsigned int )((u_short )hscx) * 64U + (unsigned int )off2), (int )value); goto ldv_41111; } ldv_41111: ; return; } } __inline static void waitforCEC___9(struct IsdnCardState *cs , int hscx ) { int to ; u_char tmp ; { to = 50; goto ldv_41120; ldv_41119: __const_udelay(4295UL); to = to - 1; ldv_41120: tmp = ReadHSCX___8(cs, hscx, 33); if (((int )tmp & 4) != 0 && to != 0) { goto ldv_41119; } else { } if (to == 0) { printk("\fHiSax: waitforCEC timeout\n"); } else { } return; } } __inline static void waitforXFW___9(struct IsdnCardState *cs , int hscx ) { int to ; u_char tmp ; { to = 50; goto ldv_41128; ldv_41127: __const_udelay(4295UL); to = to - 1; ldv_41128: tmp = ReadHSCX___8(cs, hscx, 33); if (((int )tmp & 68) != 64 && to != 0) { goto ldv_41127; } else { } if (to == 0) { printk("\fHiSax: waitforXFW timeout\n"); } else { } return; } } __inline static void WriteHSCXCMDR___8(struct IsdnCardState *cs , int hscx , u_char data ) { { waitforCEC___9(cs, hscx); WriteHSCX___8(cs, hscx, 33, (int )data); return; } } static void hscx_empty_fifo___8(struct BCState *bcs , int count ) { u_char *ptr ; struct IsdnCardState *cs ; char *t ; int tmp ; { cs = bcs->cs; if ((cs->debug & 16) != 0 && (cs->debug & 32) == 0) { debugl1(cs, (char *)"hscx_empty_fifo"); } else { } if (bcs->hw.hscx.rcvidx + count > 4096) { if (cs->debug & 1) { debugl1(cs, (char *)"hscx_empty_fifo: incoming packet too large"); } else { } WriteHSCXCMDR___8(cs, bcs->hw.hscx.hscx, 128); bcs->hw.hscx.rcvidx = 0; return; } else { } ptr = bcs->hw.hscx.rcvbuf + (unsigned long )bcs->hw.hscx.rcvidx; bcs->hw.hscx.rcvidx = bcs->hw.hscx.rcvidx + count; ReadHSCXfifo___0(cs, bcs->hw.hscx.hscx, ptr, count); WriteHSCXCMDR___8(cs, bcs->hw.hscx.hscx, 128); if ((cs->debug & 32) != 0) { t = (char *)bcs->blog; tmp = sprintf(t, "hscx_empty_fifo %c cnt %d", bcs->hw.hscx.hscx != 0 ? 66 : 65, count); t = t + (unsigned long )tmp; QuickHex(t, ptr, count); debugl1(cs, (char *)bcs->blog); } else { } return; } } static void hscx_fill_fifo___8(struct BCState *bcs ) { struct IsdnCardState *cs ; int more ; int count ; int fifo_size ; int tmp ; u_char *ptr ; char *t ; int tmp___0 ; { cs = bcs->cs; tmp = constant_test_bit(1U, (unsigned long const volatile *)(& cs->HW_Flags)); fifo_size = tmp != 0 ? 64 : 32; if ((cs->debug & 16) != 0 && (cs->debug & 32) == 0) { debugl1(cs, (char *)"hscx_fill_fifo"); } else { } if ((unsigned long )bcs->tx_skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } if ((bcs->tx_skb)->len == 0U) { return; } else { } more = bcs->mode == 1; if ((bcs->tx_skb)->len > (unsigned int )fifo_size) { more = 1; count = fifo_size; } else { count = (int )(bcs->tx_skb)->len; } waitforXFW___9(cs, bcs->hw.hscx.hscx); ptr = (bcs->tx_skb)->data; skb_pull(bcs->tx_skb, (unsigned int )count); bcs->tx_cnt = bcs->tx_cnt - count; bcs->hw.hscx.count = bcs->hw.hscx.count + count; WriteHSCXfifo___0(cs, bcs->hw.hscx.hscx, ptr, count); WriteHSCXCMDR___8(cs, bcs->hw.hscx.hscx, more != 0 ? 8 : 10); if ((cs->debug & 32) != 0) { t = (char *)bcs->blog; tmp___0 = sprintf(t, "hscx_fill_fifo %c cnt %d", bcs->hw.hscx.hscx != 0 ? 66 : 65, count); t = t + (unsigned long )tmp___0; QuickHex(t, ptr, count); debugl1(cs, (char *)bcs->blog); } else { } return; } } static void hscx_interrupt___8(struct IsdnCardState *cs , u_char val , u_char hscx ) { u_char r ; struct BCState *bcs ; struct sk_buff *skb ; int fifo_size ; int tmp ; int count ; int tmp___0 ; u_char tmp___1 ; int tmp___2 ; size_t __len ; void *__ret ; unsigned char *tmp___4 ; size_t __len___0 ; void *__ret___0 ; unsigned char *tmp___6 ; u_long flags ; raw_spinlock_t *tmp___7 ; int tmp___8 ; struct sk_buff *tmp___9 ; { bcs = (struct BCState *)(& cs->bcs) + (unsigned long )hscx; tmp = constant_test_bit(1U, (unsigned long const volatile *)(& cs->HW_Flags)); fifo_size = tmp != 0 ? 64 : 32; tmp___0 = constant_test_bit(1U, (unsigned long const volatile *)(& bcs->Flag)); if (tmp___0 == 0) { return; } else { } if ((int )((signed char )val) < 0) { r = ReadHSCX___8(cs, (int )hscx, 39); if (((int )r & 240) != 160) { if ((int )((signed char )r) >= 0) { if (cs->debug & 1) { debugl1(cs, (char *)"HSCX invalid frame"); } else { } bcs->err_inv = bcs->err_inv + 1; } else { } if (((int )r & 64) != 0 && bcs->mode != 0) { if (cs->debug & 1) { debugl1(cs, (char *)"HSCX RDO mode=%d", bcs->mode); } else { } bcs->err_rdo = bcs->err_rdo + 1; } else { } if (((int )r & 32) == 0) { if (cs->debug & 1) { debugl1(cs, (char *)"HSCX CRC error"); } else { } bcs->err_crc = bcs->err_crc + 1; } else { } WriteHSCXCMDR___8(cs, (int )hscx, 128); } else { tmp___1 = ReadHSCX___8(cs, (int )hscx, 37); tmp___2 = constant_test_bit(1U, (unsigned long const volatile *)(& cs->HW_Flags)); count = (int )tmp___1 & (tmp___2 != 0 ? 63 : 31); if (count == 0) { count = fifo_size; } else { } hscx_empty_fifo___8(bcs, count); count = bcs->hw.hscx.rcvidx + -1; if (count > 0) { if ((cs->debug & 32) != 0) { debugl1(cs, (char *)"HX Frame %d", count); } else { } skb = dev_alloc_skb((unsigned int )count); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { printk("\fHSCX: receive out of memory\n"); } else { __len = (size_t )count; tmp___4 = skb_put(skb, (unsigned int )count); __ret = memcpy((void *)tmp___4, (void const *)bcs->hw.hscx.rcvbuf, __len); skb_queue_tail(& bcs->rqueue, skb); } } else { } } bcs->hw.hscx.rcvidx = 0; test_and_set_bit(0, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } if (((int )val & 64) != 0) { hscx_empty_fifo___8(bcs, fifo_size); if (bcs->mode == 1) { skb = dev_alloc_skb((unsigned int )fifo_size); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { printk("\fHiSax: receive out of memory\n"); } else { __len___0 = (size_t )fifo_size; tmp___6 = skb_put(skb, (unsigned int )fifo_size); __ret___0 = memcpy((void *)tmp___6, (void const *)bcs->hw.hscx.rcvbuf, __len___0); skb_queue_tail(& bcs->rqueue, skb); } bcs->hw.hscx.rcvidx = 0; test_and_set_bit(0, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } } else { } if (((int )val & 16) != 0) { if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { if ((bcs->tx_skb)->len != 0U) { hscx_fill_fifo___8(bcs); return; } else { tmp___8 = constant_test_bit(1U, (unsigned long const volatile *)(& (bcs->st)->lli.flag)); if (tmp___8 != 0 && (unsigned int )*((unsigned char *)bcs->tx_skb + 125UL) != 7U) { tmp___7 = spinlock_check(& bcs->aclock); flags = _raw_spin_lock_irqsave(tmp___7); bcs->ackcnt = bcs->ackcnt + bcs->hw.hscx.count; spin_unlock_irqrestore(& bcs->aclock, flags); test_and_set_bit(2, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } dev_kfree_skb_irq(bcs->tx_skb); bcs->hw.hscx.count = 0; bcs->tx_skb = 0; } } else { } tmp___9 = skb_dequeue(& bcs->squeue); bcs->tx_skb = tmp___9; if ((unsigned long )tmp___9 != (unsigned long )((struct sk_buff *)0)) { bcs->hw.hscx.count = 0; test_and_set_bit(3, (unsigned long volatile *)(& bcs->Flag)); hscx_fill_fifo___8(bcs); } else { test_and_clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); test_and_set_bit(1, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } } else { } return; } } static void hscx_int_main___8(struct IsdnCardState *cs , u_char val ) { u_char exval ; struct BCState *bcs ; { if ((int )val & 1) { bcs = (struct BCState *)(& cs->bcs) + 1UL; exval = ReadHSCX___8(cs, 1, 36); if (((int )exval & 64) != 0) { if (bcs->mode == 1) { hscx_fill_fifo___8(bcs); } else { bcs->err_tx = bcs->err_tx + 1; if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { skb_push(bcs->tx_skb, (unsigned int )bcs->hw.hscx.count); bcs->tx_cnt = bcs->tx_cnt + bcs->hw.hscx.count; bcs->hw.hscx.count = 0; } else { } WriteHSCXCMDR___8(cs, bcs->hw.hscx.hscx, 1); if (cs->debug & 1) { debugl1(cs, (char *)"HSCX B EXIR %x Lost TX", (int )exval); } else { } } } else if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HSCX B EXIR %x", (int )exval); } else { } } else { } if (((int )val & 248) != 0) { if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HSCX B interrupt %x", (int )val); } else { } hscx_interrupt___8(cs, (int )val, 1); } else { } if (((int )val & 2) != 0) { bcs = (struct BCState *)(& cs->bcs); exval = ReadHSCX___8(cs, 0, 36); if (((int )exval & 64) != 0) { if (bcs->mode == 1) { hscx_fill_fifo___8(bcs); } else { bcs->err_tx = bcs->err_tx + 1; if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { skb_push(bcs->tx_skb, (unsigned int )bcs->hw.hscx.count); bcs->tx_cnt = bcs->tx_cnt + bcs->hw.hscx.count; bcs->hw.hscx.count = 0; } else { } WriteHSCXCMDR___8(cs, bcs->hw.hscx.hscx, 1); if (cs->debug & 1) { debugl1(cs, (char *)"HSCX A EXIR %x Lost TX", (int )exval); } else { } } } else if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HSCX A EXIR %x", (int )exval); } else { } } else { } if (((int )val & 4) != 0) { exval = ReadHSCX___8(cs, 0, 32); if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"HSCX A interrupt %x", (int )exval); } else { } hscx_interrupt___8(cs, (int )exval, 0); } else { } return; } } static irqreturn_t gazel_interrupt(int intno , void *dev_id ) { struct IsdnCardState *cs ; u_char valisac ; u_char valhscx ; int count ; u_long flags ; raw_spinlock_t *tmp ; { cs = (struct IsdnCardState *)dev_id; count = 0; tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); ldv_41189: valhscx = ReadHSCX___8(cs, 1, 32); if ((unsigned int )valhscx != 0U) { hscx_int_main___8(cs, (int )valhscx); } else { } valisac = ReadISAC___10(cs, 32); if ((unsigned int )valisac != 0U) { isac_interrupt(cs, (int )valisac); } else { } count = count + 1; if (((unsigned int )valhscx != 0U || (unsigned int )valisac != 0U) && count <= 4) { goto ldv_41189; } else { } WriteHSCX___8(cs, 0, 32, 255); WriteHSCX___8(cs, 1, 32, 255); WriteISAC___10(cs, 32, 255); WriteISAC___10(cs, 32, 0); WriteHSCX___8(cs, 0, 32, 0); WriteHSCX___8(cs, 1, 32, 0); spin_unlock_irqrestore(& cs->lock, flags); return (1); } } static irqreturn_t gazel_interrupt_ipac(int intno , void *dev_id ) { struct IsdnCardState *cs ; u_char ista ; u_char val ; int count ; u_long flags ; raw_spinlock_t *tmp ; u_char tmp___0 ; { cs = (struct IsdnCardState *)dev_id; count = 0; tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); ista = ReadISAC___10(cs, 65); ldv_41203: ; if (((int )ista & 15) != 0) { val = ReadHSCX___8(cs, 1, 32); if ((int )ista & 1) { val = (u_char )((unsigned int )val | 1U); } else { } if (((int )ista & 4) != 0) { val = (u_char )((unsigned int )val | 2U); } else { } if (((int )ista & 8) != 0) { val = (u_char )((unsigned int )val | 4U); } else { } if ((unsigned int )val != 0U) { hscx_int_main___8(cs, (int )val); } else { } } else { } if (((int )ista & 32) != 0) { tmp___0 = ReadISAC___10(cs, 32); val = (unsigned int )tmp___0 & 254U; if ((unsigned int )val != 0U) { isac_interrupt(cs, (int )val); } else { } } else { } if (((int )ista & 16) != 0) { val = 1U; isac_interrupt(cs, (int )val); } else { } ista = ReadISAC___10(cs, 65); count = count + 1; if (((int )ista & 63) != 0 && count <= 4) { goto ldv_41203; } else { } WriteISAC___10(cs, 65, 255); WriteISAC___10(cs, 65, 192); spin_unlock_irqrestore(& cs->lock, flags); return (1); } } static void release_io_gazel(struct IsdnCardState *cs ) { unsigned int i ; { switch ((int )cs->subtyp) { case 1: i = 0U; goto ldv_41211; ldv_41210: __release_region(& ioport_resource, (resource_size_t )((unsigned int )cs->hw.gazel.hscx[0] + i), 16ULL); i = i + 4096U; ldv_41211: ; if (i <= 49151U) { goto ldv_41210; } else { } __release_region(& ioport_resource, (resource_size_t )(cs->hw.gazel.hscx[0] + 49152), 1ULL); goto ldv_41213; case 2: __release_region(& ioport_resource, (resource_size_t )cs->hw.gazel.hscx[0], 256ULL); __release_region(& ioport_resource, (resource_size_t )cs->hw.gazel.cfg_reg, 128ULL); goto ldv_41213; case 3: __release_region(& ioport_resource, (resource_size_t )cs->hw.gazel.ipac, 8ULL); __release_region(& ioport_resource, (resource_size_t )cs->hw.gazel.cfg_reg, 128ULL); goto ldv_41213; case 4: __release_region(& ioport_resource, (resource_size_t )cs->hw.gazel.ipac, 8ULL); goto ldv_41213; } ldv_41213: ; return; } } static int reset_gazel(struct IsdnCardState *cs ) { unsigned long plxcntrl ; unsigned long addr ; int tout ; int loops ; int tmp ; int tmp___0 ; int tout___0 ; int loops___0 ; int tmp___1 ; int tmp___2 ; unsigned int tmp___3 ; int tout___1 ; int loops___1 ; int tmp___4 ; int tmp___5 ; int tout___2 ; int loops___2 ; int tmp___6 ; int tmp___7 ; unsigned int tmp___8 ; int tout___3 ; int loops___3 ; int tmp___9 ; int tmp___10 ; int tout___4 ; int loops___4 ; int tmp___11 ; int tmp___12 ; int tout___5 ; int loops___5 ; int tmp___13 ; int tmp___14 ; { addr = (unsigned long )cs->hw.gazel.cfg_reg; switch ((int )cs->subtyp) { case 1: writereg___7((unsigned int )addr, 0, 0); tout = 10; goto ldv_41229; ldv_41228: loops = 4000; goto ldv_41226; ldv_41225: __const_udelay(4295UL); ldv_41226: tmp = loops; loops = loops - 1; if (tmp != 0) { goto ldv_41225; } else { } ldv_41229: tmp___0 = tout; tout = tout - 1; if (tmp___0 != 0) { goto ldv_41228; } else { } writereg___7((unsigned int )addr, 0, 1); tout___0 = 2; goto ldv_41237; ldv_41236: loops___0 = 4000; goto ldv_41234; ldv_41233: __const_udelay(4295UL); ldv_41234: tmp___1 = loops___0; loops___0 = loops___0 - 1; if (tmp___1 != 0) { goto ldv_41233; } else { } ldv_41237: tmp___2 = tout___0; tout___0 = tout___0 - 1; if (tmp___2 != 0) { goto ldv_41236; } else { } goto ldv_41239; case 2: tmp___3 = inl((int )((unsigned int )addr + 80U)); plxcntrl = (unsigned long )tmp___3; plxcntrl = plxcntrl | 1073741828UL; outl((unsigned int )plxcntrl, (int )((unsigned int )addr + 80U)); plxcntrl = plxcntrl & 0xffffffffbffffffbUL; tout___1 = 4; goto ldv_41247; ldv_41246: loops___1 = 4000; goto ldv_41244; ldv_41243: __const_udelay(4295UL); ldv_41244: tmp___4 = loops___1; loops___1 = loops___1 - 1; if (tmp___4 != 0) { goto ldv_41243; } else { } ldv_41247: tmp___5 = tout___1; tout___1 = tout___1 - 1; if (tmp___5 != 0) { goto ldv_41246; } else { } outl((unsigned int )plxcntrl, (int )((unsigned int )addr + 80U)); tout___2 = 10; goto ldv_41255; ldv_41254: loops___2 = 4000; goto ldv_41252; ldv_41251: __const_udelay(4295UL); ldv_41252: tmp___6 = loops___2; loops___2 = loops___2 - 1; if (tmp___6 != 0) { goto ldv_41251; } else { } ldv_41255: tmp___7 = tout___2; tout___2 = tout___2 - 1; if (tmp___7 != 0) { goto ldv_41254; } else { } outb(73, (int )((unsigned int )addr + 76U)); goto ldv_41239; case 3: tmp___8 = inl((int )((unsigned int )addr + 80U)); plxcntrl = (unsigned long )tmp___8; plxcntrl = plxcntrl | 1073741828UL; outl((unsigned int )plxcntrl, (int )((unsigned int )addr + 80U)); plxcntrl = plxcntrl & 0xffffffffbffffffbUL; WriteISAC___10(cs, 73, 32); tout___3 = 4; goto ldv_41264; ldv_41263: loops___3 = 4000; goto ldv_41261; ldv_41260: __const_udelay(4295UL); ldv_41261: tmp___9 = loops___3; loops___3 = loops___3 - 1; if (tmp___9 != 0) { goto ldv_41260; } else { } ldv_41264: tmp___10 = tout___3; tout___3 = tout___3 - 1; if (tmp___10 != 0) { goto ldv_41263; } else { } outl((unsigned int )plxcntrl, (int )((unsigned int )addr + 80U)); tout___4 = 10; goto ldv_41272; ldv_41271: loops___4 = 4000; goto ldv_41269; ldv_41268: __const_udelay(4295UL); ldv_41269: tmp___11 = loops___4; loops___4 = loops___4 - 1; if (tmp___11 != 0) { goto ldv_41268; } else { } ldv_41272: tmp___12 = tout___4; tout___4 = tout___4 - 1; if (tmp___12 != 0) { goto ldv_41271; } else { } WriteISAC___10(cs, 73, 0); WriteISAC___10(cs, 67, 255); WriteISAC___10(cs, 68, 0); WriteISAC___10(cs, 65, 255); WriteISAC___10(cs, 64, 1); outb(67, (int )((unsigned int )addr + 76U)); WriteISAC___10(cs, 65, 192); goto ldv_41239; case 4: WriteISAC___10(cs, 73, 32); tout___5 = 4; goto ldv_41281; ldv_41280: loops___5 = 4000; goto ldv_41278; ldv_41277: __const_udelay(4295UL); ldv_41278: tmp___13 = loops___5; loops___5 = loops___5 - 1; if (tmp___13 != 0) { goto ldv_41277; } else { } ldv_41281: tmp___14 = tout___5; tout___5 = tout___5 - 1; if (tmp___14 != 0) { goto ldv_41280; } else { } WriteISAC___10(cs, 73, 0); WriteISAC___10(cs, 67, 255); WriteISAC___10(cs, 68, 0); WriteISAC___10(cs, 65, 255); WriteISAC___10(cs, 64, 1); WriteISAC___10(cs, 65, 192); goto ldv_41239; } ldv_41239: ; return (0); } } static int Gazel_card_msg(struct IsdnCardState *cs , int mt , void *arg ) { u_long flags ; raw_spinlock_t *tmp ; raw_spinlock_t *tmp___0 ; int i ; { switch (mt) { case 240: tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); reset_gazel(cs); spin_unlock_irqrestore(& cs->lock, flags); return (0); case 243: release_io_gazel(cs); return (0); case 242: tmp___0 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___0); inithscxisac(cs, 1); if ((unsigned int )cs->subtyp == 1U || (unsigned int )cs->subtyp == 2U) { i = 0; goto ldv_41300; ldv_41299: cs->bcs[i].hw.hscx.tsaxr0 = 31U; cs->bcs[i].hw.hscx.tsaxr1 = 35U; i = i + 1; ldv_41300: ; if (i <= 3) { goto ldv_41299; } else { } } else { } spin_unlock_irqrestore(& cs->lock, flags); return (0); case 244: ; return (0); } return (0); } } static int reserve_regions(struct IsdnCard *card , struct IsdnCardState *cs ) { unsigned int i ; unsigned int j ; unsigned int base ; unsigned int adr ; unsigned int len ; struct resource *tmp ; struct resource *tmp___0 ; struct resource *tmp___1 ; struct resource *tmp___2 ; struct resource *tmp___3 ; struct resource *tmp___4 ; struct resource *tmp___5 ; { base = 0U; adr = 0U; len = 0U; switch ((int )cs->subtyp) { case 1: base = (unsigned int )cs->hw.gazel.hscx[0]; len = 1U; adr = base + 49152U; tmp = __request_region(& ioport_resource, (resource_size_t )adr, 1ULL, "gazel", 0); if ((unsigned long )tmp == (unsigned long )((struct resource *)0)) { goto error; } else { } i = 0U; goto ldv_41315; ldv_41314: len = 16U; adr = i + base; tmp___0 = __request_region(& ioport_resource, (resource_size_t )adr, 16ULL, "gazel", 0); if ((unsigned long )tmp___0 == (unsigned long )((struct resource *)0)) { goto error; } else { } i = i + 4096U; ldv_41315: ; if (i <= 49151U) { goto ldv_41314; } else { } if (i != 49152U) { j = 0U; goto ldv_41318; ldv_41317: __release_region(& ioport_resource, (resource_size_t )(j + base), 16ULL); j = j + 4096U; ldv_41318: ; if (j < i) { goto ldv_41317; } else { } __release_region(& ioport_resource, (resource_size_t )(base + 49152U), 1ULL); goto error; } else { } goto ldv_41320; case 2: len = 256U; adr = (unsigned int )cs->hw.gazel.hscx[0]; tmp___1 = __request_region(& ioport_resource, (resource_size_t )adr, 256ULL, "gazel", 0); if ((unsigned long )tmp___1 == (unsigned long )((struct resource *)0)) { goto error; } else { } len = 128U; adr = cs->hw.gazel.cfg_reg; tmp___2 = __request_region(& ioport_resource, (resource_size_t )adr, 128ULL, "gazel", 0); if ((unsigned long )tmp___2 == (unsigned long )((struct resource *)0)) { __release_region(& ioport_resource, (resource_size_t )cs->hw.gazel.hscx[0], 256ULL); goto error; } else { } goto ldv_41320; case 3: len = 8U; adr = (unsigned int )cs->hw.gazel.ipac; tmp___3 = __request_region(& ioport_resource, (resource_size_t )adr, 8ULL, "gazel", 0); if ((unsigned long )tmp___3 == (unsigned long )((struct resource *)0)) { goto error; } else { } len = 128U; adr = cs->hw.gazel.cfg_reg; tmp___4 = __request_region(& ioport_resource, (resource_size_t )adr, 128ULL, "gazel", 0); if ((unsigned long )tmp___4 == (unsigned long )((struct resource *)0)) { __release_region(& ioport_resource, (resource_size_t )cs->hw.gazel.ipac, 8ULL); goto error; } else { } goto ldv_41320; case 4: len = 8U; adr = (unsigned int )cs->hw.gazel.ipac; tmp___5 = __request_region(& ioport_resource, (resource_size_t )adr, 8ULL, "gazel", 0); if ((unsigned long )tmp___5 == (unsigned long )((struct resource *)0)) { goto error; } else { } goto ldv_41320; } ldv_41320: ; return (0); error: printk("\fGazel: io ports 0x%x-0x%x already in use\n", adr, adr + len); return (1); } } static int setup_gazelisa(struct IsdnCard *card , struct IsdnCardState *cs ) { u_char tmp ; { printk("\016Gazel: ISA PnP card automatic recognition\n"); tmp = readreg_ipac((unsigned int )card->para[1], 194); if ((unsigned int )tmp == 1U) { cs->subtyp = 4U; } else { cs->subtyp = 1U; } setup_isac(cs); cs->hw.gazel.cfg_reg = (unsigned int )card->para[1] + 49152U; cs->hw.gazel.ipac = (int )card->para[1]; cs->hw.gazel.isac = (int )((unsigned int )card->para[1] + 32768U); cs->hw.gazel.hscx[0] = (int )card->para[1]; cs->hw.gazel.hscx[1] = (int )((unsigned int )card->para[1] + 16384U); cs->irq = (u_int )card->para[0]; cs->hw.gazel.isacfifo = cs->hw.gazel.isac; cs->hw.gazel.hscxfifo[0] = cs->hw.gazel.hscx[0]; cs->hw.gazel.hscxfifo[1] = cs->hw.gazel.hscx[1]; switch ((int )cs->subtyp) { case 1: printk("\016Gazel: Card ISA R647/R648 found\n"); cs->dc.isac.adf2 = 135U; printk("\016Gazel: config irq:%d isac:0x%X cfg:0x%X\n", cs->irq, cs->hw.gazel.isac, cs->hw.gazel.cfg_reg); printk("\016Gazel: hscx A:0x%X hscx B:0x%X\n", cs->hw.gazel.hscx[0], cs->hw.gazel.hscx[1]); goto ldv_41329; case 4: printk("\016Gazel: Card ISA R742 found\n"); test_and_set_bit(1, (unsigned long volatile *)(& cs->HW_Flags)); printk("\016Gazel: config irq:%d ipac:0x%X\n", cs->irq, cs->hw.gazel.ipac); goto ldv_41329; } ldv_41329: ; return (0); } } static struct pci_dev *dev_tel___0 = 0; static int setup_gazelpci(struct IsdnCardState *cs ) { u_int pci_ioaddr0 ; u_int pci_ioaddr1 ; u_char pci_irq___0 ; u_char found ; u_int nbseek ; u_int seekcard ; int tmp ; { pci_ioaddr0 = 0U; pci_ioaddr1 = 0U; pci_irq___0 = 0U; printk("\fGazel: PCI card automatic recognition\n"); found = 0U; seekcard = 4144U; nbseek = 0U; goto ldv_41347; ldv_41346: dev_tel___0 = hisax_find_pci_device(4277U, seekcard, dev_tel___0); if ((unsigned long )dev_tel___0 != (unsigned long )((struct pci_dev *)0)) { tmp = pci_enable_device(dev_tel___0); if (tmp != 0) { return (1); } else { } pci_irq___0 = (u_char )dev_tel___0->irq; pci_ioaddr0 = (u_int )dev_tel___0->resource[1].start; pci_ioaddr1 = (u_int )dev_tel___0->resource[2].start; found = 1U; } else { } if ((unsigned int )found != 0U) { goto ldv_41341; } else { switch (seekcard) { case 4144U: seekcard = 4434U; goto ldv_41343; case 4434U: seekcard = 4433U; goto ldv_41343; case 4433U: seekcard = 4487U; goto ldv_41343; } ldv_41343: ; } nbseek = nbseek + 1U; ldv_41347: ; if (nbseek <= 3U) { goto ldv_41346; } else { } ldv_41341: ; if ((unsigned int )found == 0U) { printk("\fGazel: No PCI card found\n"); return (1); } else { } if ((unsigned int )pci_irq___0 == 0U) { printk("\fGazel: No IRQ for PCI card found\n"); return (1); } else { } cs->hw.gazel.pciaddr[0] = pci_ioaddr0; cs->hw.gazel.pciaddr[1] = pci_ioaddr1; setup_isac(cs); pci_ioaddr1 = pci_ioaddr1 & 65534U; cs->hw.gazel.cfg_reg = pci_ioaddr0 & 65534U; cs->hw.gazel.ipac = (int )pci_ioaddr1; cs->hw.gazel.isac = (int )(pci_ioaddr1 + 128U); cs->hw.gazel.hscx[0] = (int )pci_ioaddr1; cs->hw.gazel.hscx[1] = (int )(pci_ioaddr1 + 64U); cs->hw.gazel.isacfifo = cs->hw.gazel.isac; cs->hw.gazel.hscxfifo[0] = cs->hw.gazel.hscx[0]; cs->hw.gazel.hscxfifo[1] = cs->hw.gazel.hscx[1]; cs->irq = (u_int )pci_irq___0; cs->irq_flags = cs->irq_flags | 128UL; switch (seekcard) { case 4144U: printk("\016Gazel: Card PCI R685 found\n"); cs->subtyp = 2U; cs->dc.isac.adf2 = 135U; printk("\016Gazel: config irq:%d isac:0x%X cfg:0x%X\n", cs->irq, cs->hw.gazel.isac, cs->hw.gazel.cfg_reg); printk("\016Gazel: hscx A:0x%X hscx B:0x%X\n", cs->hw.gazel.hscx[0], cs->hw.gazel.hscx[1]); goto ldv_41349; case 4434U: ; case 4433U: ; case 4487U: printk("\016Gazel: Card PCI R753 found\n"); cs->subtyp = 3U; test_and_set_bit(1, (unsigned long volatile *)(& cs->HW_Flags)); printk("\016Gazel: config irq:%d ipac:0x%X cfg:0x%X\n", cs->irq, cs->hw.gazel.ipac, cs->hw.gazel.cfg_reg); goto ldv_41349; } ldv_41349: ; return (0); } } int setup_gazel(struct IsdnCard *card ) { struct IsdnCardState *cs ; char tmp[64U] ; u_char val ; char *tmp___0 ; int tmp___1 ; int tmp___2 ; int tmp___3 ; int tmp___4 ; int tmp___5 ; { cs = card->cs; strcpy((char *)(& tmp), gazel_revision); tmp___0 = HiSax_getrev((char const *)(& tmp)); printk("\016Gazel: Driver Revision %s\n", tmp___0); if ((unsigned int )cs->typ != 34U) { return (0); } else { } if (card->para[0] != 0UL) { tmp___2 = setup_gazelisa(card, cs); if (tmp___2 != 0) { return (0); } else { tmp___1 = setup_gazelpci(cs); if (tmp___1 != 0) { return (0); } else { } } } else { } tmp___3 = reserve_regions(card, cs); if (tmp___3 != 0) { return (0); } else { } tmp___4 = reset_gazel(cs); if (tmp___4 != 0) { printk("\fGazel: wrong IRQ\n"); release_io_gazel(cs); return (0); } else { } cs->readisac = & ReadISAC___10; cs->writeisac = & WriteISAC___10; cs->readisacfifo = & ReadISACfifo___10; cs->writeisacfifo = & WriteISACfifo___10; cs->BC_Read_Reg = & ReadHSCX___8; cs->BC_Write_Reg = & WriteHSCX___8; cs->BC_Send_Data = & hscx_fill_fifo___8; cs->cardmsg = & Gazel_card_msg; switch ((int )cs->subtyp) { case 1: ; case 2: cs->irq_func = & gazel_interrupt; ISACVersion(cs, (char *)"Gazel:"); tmp___5 = HscxVersion(cs, (char *)"Gazel:"); if (tmp___5 != 0) { printk("\fGazel: wrong HSCX versions check IO address\n"); release_io_gazel(cs); return (0); } else { } goto ldv_41361; case 4: ; case 3: cs->irq_func = & gazel_interrupt_ipac; val = ReadISAC___10(cs, 66); printk("\016Gazel: IPAC version %x\n", (int )val); goto ldv_41361; } ldv_41361: ; return (1); } } void ldv_mutex_lock_491(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_lock(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_492(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_lock(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_493(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } int ldv_mutex_trylock_494(struct mutex *ldv_func_arg1 ) { ldv_func_ret_type___2 ldv_func_res ; int tmp ; int tmp___0 ; { tmp = mutex_trylock(ldv_func_arg1); ldv_func_res = tmp; tmp___0 = ldv_mutex_trylock_mutex(ldv_func_arg1); return (tmp___0); return (ldv_func_res); } } void ldv_mutex_unlock_495(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_496(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_cred_guard_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_497(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_cred_guard_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } int ldv_mutex_trylock_508(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_506(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_509(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_511(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_505(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_507(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_510(struct mutex *ldv_func_arg1 ) ; static PCI_ENTRY const id_list___0[3U] = { {4176, 26258, (char *)"Winbond", (char *)"W6692"}, {1653, 5890, (char *)"Dynalink/AsusCom", (char *)"IS64PH"}, {0, 0, (char *)"U.S.Robotics", (char *)"ISDN PCI Card TA"}}; static char const *w6692_revision = "$Revision: 1.18.2.4 $"; static char *W6692Ver[4U] = { (char *)"W6692 V00", (char *)"W6692 V01", (char *)"W6692 V10", (char *)"W6692 V11"}; static void W6692Version(struct IsdnCardState *cs , char *s ) { int val ; u_char tmp ; { tmp = (*(cs->readisac))(cs, 68); val = (int )tmp; printk("\016%s Winbond W6692 version (%x): %s\n", s, val, W6692Ver[(val >> 6) & 3]); return; } } static void ph_command___2(struct IsdnCardState *cs , unsigned int command ) { { if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"ph_command %x", command); } else { } (*(cs->writeisac))(cs, 92, (int )((u_char )command)); return; } } static void W6692_new_ph(struct IsdnCardState *cs ) { { switch (cs->dc.w6692.ph_state) { case 1: ph_command___2(cs, 15U); l1_msg(cs, 6, 0); case 15: l1_msg(cs, 25, 0); goto ldv_40985; case 0: l1_msg(cs, 26, 0); goto ldv_40985; case 7: l1_msg(cs, 9, 0); goto ldv_40985; case 4: l1_msg(cs, 98, 0); goto ldv_40985; case 8: l1_msg(cs, 34, 0); goto ldv_40985; case 12: l1_msg(cs, 66, 0); goto ldv_40985; case 13: l1_msg(cs, 74, 0); goto ldv_40985; default: ; goto ldv_40985; } ldv_40985: ; return; } } static void W6692_bh(struct work_struct *work ) { struct IsdnCardState *cs ; struct work_struct const *__mptr ; struct PStack *stptr ; int tmp ; int tmp___0 ; int tmp___1 ; int tmp___2 ; { __mptr = (struct work_struct const *)work; cs = (struct IsdnCardState *)__mptr + 0xffffffffffffe728UL; tmp = test_and_clear_bit(3, (unsigned long volatile *)(& cs->event)); if (tmp != 0) { if (cs->debug != 0) { debugl1(cs, (char *)"D-Channel Busy cleared"); } else { } stptr = cs->stlist; goto ldv_41001; ldv_41000: (*(stptr->l1.l1l2))(stptr, 337, 0); stptr = stptr->next; ldv_41001: ; if ((unsigned long )stptr != (unsigned long )((struct PStack *)0)) { goto ldv_41000; } else { } } else { } tmp___0 = test_and_clear_bit(2, (unsigned long volatile *)(& cs->event)); if (tmp___0 != 0) { W6692_new_ph(cs); } else { } tmp___1 = test_and_clear_bit(0, (unsigned long volatile *)(& cs->event)); if (tmp___1 != 0) { DChannel_proc_rcv(cs); } else { } tmp___2 = test_and_clear_bit(1, (unsigned long volatile *)(& cs->event)); if (tmp___2 != 0) { DChannel_proc_xmt(cs); } else { } return; } } static void W6692_empty_fifo(struct IsdnCardState *cs , int count ) { u_char *ptr ; char *t ; int tmp ; { if ((cs->debug & 4) != 0 && (cs->debug & 8) == 0) { debugl1(cs, (char *)"W6692_empty_fifo"); } else { } if (cs->rcvidx + count > 299) { if (cs->debug & 1) { debugl1(cs, (char *)"W6692_empty_fifo overrun %d", cs->rcvidx + count); } else { } (*(cs->writeisac))(cs, 8, 128); cs->rcvidx = 0; return; } else { } ptr = cs->rcvbuf + (unsigned long )cs->rcvidx; cs->rcvidx = cs->rcvidx + count; (*(cs->readisacfifo))(cs, ptr, count); (*(cs->writeisac))(cs, 8, 128); if ((cs->debug & 8) != 0) { t = cs->dlog; tmp = sprintf(t, "W6692_empty_fifo cnt %d", count); t = t + (unsigned long )tmp; QuickHex(t, ptr, count); debugl1(cs, cs->dlog); } else { } return; } } static void W6692_fill_fifo(struct IsdnCardState *cs ) { int count ; int more ; u_char *ptr ; int tmp ; struct lock_class_key __key ; char *t ; int tmp___0 ; { if ((cs->debug & 4) != 0 && (cs->debug & 8) == 0) { debugl1(cs, (char *)"W6692_fill_fifo"); } else { } if ((unsigned long )cs->tx_skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } count = (int )(cs->tx_skb)->len; if (count <= 0) { return; } else { } more = 0; if (count > 64) { more = 1; count = 64; } else { } ptr = (cs->tx_skb)->data; skb_pull(cs->tx_skb, (unsigned int )count); cs->tx_cnt = cs->tx_cnt + count; (*(cs->writeisacfifo))(cs, ptr, count); (*(cs->writeisac))(cs, 8, more != 0 ? 8 : 10); tmp = test_and_set_bit(6, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp != 0) { debugl1(cs, (char *)"W6692_fill_fifo dbusytimer running"); del_timer(& cs->dbusytimer); } else { } init_timer_key(& cs->dbusytimer, 0U, "(&cs->dbusytimer)", & __key); cs->dbusytimer.expires = (unsigned long )jiffies + 20UL; add_timer(& cs->dbusytimer); if ((cs->debug & 8) != 0) { t = cs->dlog; tmp___0 = sprintf(t, "W6692_fill_fifo cnt %d", count); t = t + (unsigned long )tmp___0; QuickHex(t, ptr, count); debugl1(cs, cs->dlog); } else { } return; } } static void W6692B_empty_fifo(struct BCState *bcs , int count ) { u_char *ptr ; struct IsdnCardState *cs ; char *t ; int tmp ; { cs = bcs->cs; if ((cs->debug & 16) != 0 && (cs->debug & 32) == 0) { debugl1(cs, (char *)"W6692B_empty_fifo"); } else { } if (bcs->hw.w6692.rcvidx + count > 4096) { if (cs->debug & 1) { debugl1(cs, (char *)"W6692B_empty_fifo: incoming packet too large"); } else { } (*(cs->BC_Write_Reg))(cs, bcs->channel, 136, 160); bcs->hw.w6692.rcvidx = 0; return; } else { } ptr = bcs->hw.w6692.rcvbuf + (unsigned long )bcs->hw.w6692.rcvidx; bcs->hw.w6692.rcvidx = bcs->hw.w6692.rcvidx + count; insb((int )((cs->hw.w6692.iobase + (bcs->channel != 0 ? 64U : 0U)) + 128U), (void *)ptr, (unsigned long )count); (*(cs->BC_Write_Reg))(cs, bcs->channel, 136, 160); if ((cs->debug & 32) != 0) { t = (char *)bcs->blog; tmp = sprintf(t, "W6692B_empty_fifo %c cnt %d", bcs->channel + 49, count); t = t + (unsigned long )tmp; QuickHex(t, ptr, count); debugl1(cs, (char *)bcs->blog); } else { } return; } } static void W6692B_fill_fifo(struct BCState *bcs ) { struct IsdnCardState *cs ; int more ; int count ; u_char *ptr ; char *t ; int tmp ; { cs = bcs->cs; if ((unsigned long )bcs->tx_skb == (unsigned long )((struct sk_buff *)0)) { return; } else { } if ((bcs->tx_skb)->len == 0U) { return; } else { } more = bcs->mode == 1; if ((bcs->tx_skb)->len > 64U) { more = 1; count = 64; } else { count = (int )(bcs->tx_skb)->len; } if ((cs->debug & 16) != 0 && (cs->debug & 32) == 0) { debugl1(cs, (char *)"W6692B_fill_fifo%s%d", more != 0 ? (char *)" " : (char *)" last ", count); } else { } ptr = (bcs->tx_skb)->data; skb_pull(bcs->tx_skb, (unsigned int )count); bcs->tx_cnt = bcs->tx_cnt - count; bcs->hw.w6692.count = bcs->hw.w6692.count + count; outsb((int )((cs->hw.w6692.iobase + (bcs->channel != 0 ? 64U : 0U)) + 132U), (void const *)ptr, (unsigned long )count); (*(cs->BC_Write_Reg))(cs, bcs->channel, 136, more != 0 ? 36 : 38); if ((cs->debug & 32) != 0) { t = (char *)bcs->blog; tmp = sprintf(t, "W6692B_fill_fifo %c cnt %d", bcs->channel + 49, count); t = t + (unsigned long )tmp; QuickHex(t, ptr, count); debugl1(cs, (char *)bcs->blog); } else { } return; } } static void W6692B_interrupt(struct IsdnCardState *cs , u_char bchan ) { u_char val ; u_char r ; struct BCState *bcs ; struct sk_buff *skb ; int count ; int tmp ; u_char tmp___0 ; size_t __len ; void *__ret ; unsigned char *tmp___2 ; size_t __len___0 ; void *__ret___0 ; unsigned char *tmp___3 ; unsigned char *tmp___4 ; u_long flags ; raw_spinlock_t *tmp___5 ; int tmp___6 ; struct sk_buff *tmp___7 ; { bcs = ((struct BCState *)(& cs->bcs))->channel == (int )bchan ? (struct BCState *)(& cs->bcs) : (struct BCState *)(& cs->bcs) + 1UL; val = (*(cs->BC_Read_Reg))(cs, (int )bchan, 144); debugl1(cs, (char *)"W6692B chan %d B_EXIR 0x%02X", (int )bchan, (int )val); tmp = constant_test_bit(1U, (unsigned long const volatile *)(& bcs->Flag)); if (tmp == 0) { debugl1(cs, (char *)"W6692B not INIT yet"); return; } else { } if (((int )val & 32) != 0) { r = (*(cs->BC_Read_Reg))(cs, (int )bchan, 152); if (((int )r & 112) != 0) { if (cs->debug & 1) { debugl1(cs, (char *)"W6692 B STAR %x", (int )r); } else { } if (((int )r & 64) != 0 && bcs->mode != 0) { if (cs->debug & 1) { debugl1(cs, (char *)"W6692 B RDOV mode=%d", bcs->mode); } else { } } else { } if (((int )r & 32) != 0) { if (cs->debug & 1) { debugl1(cs, (char *)"W6692 B CRC error"); } else { } } else { } (*(cs->BC_Write_Reg))(cs, (int )bchan, 136, 224); } else { tmp___0 = (*(cs->BC_Read_Reg))(cs, (int )bchan, 172); count = (int )tmp___0 & 63; if (count == 0) { count = 64; } else { } W6692B_empty_fifo(bcs, count); count = bcs->hw.w6692.rcvidx; if (count > 0) { if ((cs->debug & 32) != 0) { debugl1(cs, (char *)"W6692 Bchan Frame %d", count); } else { } skb = dev_alloc_skb((unsigned int )count); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { printk("\fW6692: Bchan receive out of memory\n"); } else { __len = (size_t )count; tmp___2 = skb_put(skb, (unsigned int )count); __ret = memcpy((void *)tmp___2, (void const *)bcs->hw.w6692.rcvbuf, __len); skb_queue_tail(& bcs->rqueue, skb); } } else { } } bcs->hw.w6692.rcvidx = 0; test_and_set_bit(0, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } if (((int )val & 64) != 0) { W6692B_empty_fifo(bcs, 64); r = (*(cs->BC_Read_Reg))(cs, (int )bchan, 152); if (((int )r & 64) != 0) { if (cs->debug & 1) { debugl1(cs, (char *)"W6692 B RDOV(RMR) mode=%d", bcs->mode); } else { } (*(cs->BC_Write_Reg))(cs, (int )bchan, 136, 224); if (bcs->mode != 1) { bcs->hw.w6692.rcvidx = 0; } else { } } else { } if (bcs->mode == 1) { skb = dev_alloc_skb(64U); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { printk("\fHiSax: receive out of memory\n"); } else { __len___0 = 64UL; if (__len___0 > 63UL) { tmp___3 = skb_put(skb, 64U); __ret___0 = memcpy((void *)tmp___3, (void const *)bcs->hw.w6692.rcvbuf, __len___0); } else { tmp___4 = skb_put(skb, 64U); __ret___0 = memcpy((void *)tmp___4, (void const *)bcs->hw.w6692.rcvbuf, __len___0); } skb_queue_tail(& bcs->rqueue, skb); } bcs->hw.w6692.rcvidx = 0; test_and_set_bit(0, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } } else { } if ((int )val & 1) { (*(cs->BC_Write_Reg))(cs, (int )bchan, 136, 33); if (cs->debug & 1) { debugl1(cs, (char *)"W6692 B EXIR %x Lost TX", (int )val); } else { } if (bcs->mode == 1) { W6692B_fill_fifo(bcs); } else if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { skb_push(bcs->tx_skb, (unsigned int )bcs->hw.w6692.count); bcs->tx_cnt = bcs->tx_cnt + bcs->hw.w6692.count; bcs->hw.w6692.count = 0; } else { } return; } else { } if (((int )val & 2) != 0) { r = (*(cs->BC_Read_Reg))(cs, (int )bchan, 152); if (((int )r & 4) != 0) { if (cs->debug & 1) { debugl1(cs, (char *)"W6692 B STAR %x XDOW", (int )r); } else { } (*(cs->BC_Write_Reg))(cs, (int )bchan, 136, 33); if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0) && bcs->mode != 1) { skb_push(bcs->tx_skb, (unsigned int )bcs->hw.w6692.count); bcs->tx_cnt = bcs->tx_cnt + bcs->hw.w6692.count; bcs->hw.w6692.count = 0; } else { } } else { } if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { if ((bcs->tx_skb)->len != 0U) { W6692B_fill_fifo(bcs); return; } else { tmp___6 = constant_test_bit(1U, (unsigned long const volatile *)(& (bcs->st)->lli.flag)); if (tmp___6 != 0 && (unsigned int )*((unsigned char *)bcs->tx_skb + 125UL) != 7U) { tmp___5 = spinlock_check(& bcs->aclock); flags = _raw_spin_lock_irqsave(tmp___5); bcs->ackcnt = bcs->ackcnt + bcs->hw.w6692.count; spin_unlock_irqrestore(& bcs->aclock, flags); test_and_set_bit(2, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } else { } dev_kfree_skb_irq(bcs->tx_skb); bcs->hw.w6692.count = 0; bcs->tx_skb = 0; } } else { } tmp___7 = skb_dequeue(& bcs->squeue); bcs->tx_skb = tmp___7; if ((unsigned long )tmp___7 != (unsigned long )((struct sk_buff *)0)) { bcs->hw.w6692.count = 0; test_and_set_bit(3, (unsigned long volatile *)(& bcs->Flag)); W6692B_fill_fifo(bcs); } else { test_and_clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); test_and_set_bit(1, (unsigned long volatile *)(& bcs->event)); schedule_work(& bcs->tqueue); } } else { } return; } } static irqreturn_t W6692_interrupt(int intno , void *dev_id ) { struct IsdnCardState *cs ; u_char val ; u_char exval ; u_char v1 ; struct sk_buff *skb ; u_int count ; u_long flags ; int icnt ; raw_spinlock_t *tmp ; u_char tmp___0 ; size_t __len ; void *__ret ; unsigned char *tmp___2 ; int tmp___3 ; int tmp___4 ; struct sk_buff *tmp___5 ; int tmp___6 ; int tmp___7 ; { cs = (struct IsdnCardState *)dev_id; icnt = 5; tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); val = (*(cs->readisac))(cs, 20); if ((unsigned int )val == 0U) { spin_unlock_irqrestore(& cs->lock, flags); return (0); } else { } StartW6692: ; if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"W6692 ISTA %x", (int )val); } else { } if (((int )val & 64) != 0) { exval = (*(cs->readisac))(cs, 40); if (((int )exval & 112) != 0) { if (((int )exval & 64) != 0) { if (cs->debug & 1) { debugl1(cs, (char *)"W6692 RDOV"); } else { } } else { } if (((int )exval & 32) != 0) { if (cs->debug & 1) { debugl1(cs, (char *)"W6692 D-channel CRC error"); } else { } } else { } if (((int )exval & 16) != 0) { if (cs->debug & 1) { debugl1(cs, (char *)"W6692 D-channel ABORT"); } else { } } else { } (*(cs->writeisac))(cs, 8, 192); } else { tmp___0 = (*(cs->readisac))(cs, 72); count = (u_int )tmp___0 & 63U; if (count == 0U) { count = 64U; } else { } W6692_empty_fifo(cs, (int )count); count = (u_int )cs->rcvidx; if (count != 0U) { cs->rcvidx = 0; skb = alloc_skb(count, 32U); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { printk("\fHiSax: D receive out of memory\n"); } else { __len = (size_t )count; tmp___2 = skb_put(skb, count); __ret = memcpy((void *)tmp___2, (void const *)cs->rcvbuf, __len); skb_queue_tail(& cs->rq, skb); } } else { } } cs->rcvidx = 0; test_and_set_bit(0, (unsigned long volatile *)(& cs->event)); schedule_work(& cs->tqueue); } else { } if ((int )((signed char )val) < 0) { W6692_empty_fifo(cs, 64); } else { } if (((int )val & 32) != 0) { tmp___3 = test_and_clear_bit(6, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___3 != 0) { del_timer(& cs->dbusytimer); } else { } tmp___4 = test_and_clear_bit(5, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___4 != 0) { test_and_set_bit(3, (unsigned long volatile *)(& cs->event)); schedule_work(& cs->tqueue); } else { } if ((unsigned long )cs->tx_skb != (unsigned long )((struct sk_buff *)0)) { if ((cs->tx_skb)->len != 0U) { W6692_fill_fifo(cs); goto afterXFR; } else { dev_kfree_skb_irq(cs->tx_skb); cs->tx_cnt = 0; cs->tx_skb = 0; } } else { } tmp___5 = skb_dequeue(& cs->sq); cs->tx_skb = tmp___5; if ((unsigned long )tmp___5 != (unsigned long )((struct sk_buff *)0)) { cs->tx_cnt = 0; W6692_fill_fifo(cs); } else { test_and_set_bit(1, (unsigned long volatile *)(& cs->event)); schedule_work(& cs->tqueue); } } else { } afterXFR: ; if (((int )val & 24) != 0) { if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"W6692 spurious XINT!"); } else { } } else { } if (((int )val & 4) != 0) { exval = (*(cs->readisac))(cs, 28); if (cs->debug & 1) { debugl1(cs, (char *)"W6692 D_EXIR %02x", (int )exval); } else { } if (((int )exval & 96) != 0) { debugl1(cs, (char *)"W6692 D-chan underrun/collision"); printk("\fHiSax: W6692 XDUN/XCOL\n"); tmp___6 = test_and_clear_bit(6, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___6 != 0) { del_timer(& cs->dbusytimer); } else { } tmp___7 = test_and_clear_bit(5, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___7 != 0) { test_and_set_bit(3, (unsigned long volatile *)(& cs->event)); schedule_work(& cs->tqueue); } else { } if ((unsigned long )cs->tx_skb != (unsigned long )((struct sk_buff *)0)) { skb_push(cs->tx_skb, (unsigned int )cs->tx_cnt); cs->tx_cnt = 0; W6692_fill_fifo(cs); } else { printk("\fHiSax: W6692 XDUN/XCOL no skb\n"); debugl1(cs, (char *)"W6692 XDUN/XCOL no skb"); (*(cs->writeisac))(cs, 8, 1); } } else { } if ((int )((signed char )exval) < 0) { debugl1(cs, (char *)"W6692 D-channel RDOV"); printk("\fHiSax: W6692 D-RDOV\n"); (*(cs->writeisac))(cs, 8, 64); } else { } if (((int )exval & 16) != 0) { debugl1(cs, (char *)"W6692 spurious TIN2 interrupt"); } else { } if (((int )exval & 8) != 0) { debugl1(cs, (char *)"W6692 spurious MOC interrupt"); v1 = (*(cs->readisac))(cs, 116); debugl1(cs, (char *)"W6692 MOSR %02x", (int )v1); } else { } if (((int )exval & 4) != 0) { v1 = (*(cs->readisac))(cs, 88); if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"W6692 ISC CIR=0x%02X", (int )v1); } else { } if (((int )v1 & 64) != 0) { cs->dc.w6692.ph_state = (int )v1 & 15; if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"ph_state_change %x", cs->dc.w6692.ph_state); } else { } test_and_set_bit(2, (unsigned long volatile *)(& cs->event)); schedule_work(& cs->tqueue); } else { } if ((int )((signed char )v1) < 0) { v1 = (*(cs->readisac))(cs, 96); debugl1(cs, (char *)"W6692 SCC SQR=0x%02X", (int )v1); } else { } } else { } if ((int )exval & 1) { debugl1(cs, (char *)"W6692 spurious WEXP interrupt!"); } else { } if (((int )exval & 2) != 0) { debugl1(cs, (char *)"W6692 spurious TEXP interrupt!"); } else { } } else { } if (((int )val & 2) != 0) { debugl1(cs, (char *)"W6692 B channel 1 interrupt"); W6692B_interrupt(cs, 0); } else { } if ((int )val & 1) { debugl1(cs, (char *)"W6692 B channel 2 interrupt"); W6692B_interrupt(cs, 1); } else { } val = (*(cs->readisac))(cs, 20); if ((unsigned int )val != 0U && icnt != 0) { icnt = icnt - 1; goto StartW6692; } else { } if (icnt == 0) { printk("\fW6692 IRQ LOOP\n"); (*(cs->writeisac))(cs, 24, 255); } else { } spin_unlock_irqrestore(& cs->lock, flags); return (1); } } static void W6692_l1hw(struct PStack *st , int pr , void *arg ) { struct IsdnCardState *cs ; struct sk_buff *skb ; u_long flags ; int val ; raw_spinlock_t *tmp ; raw_spinlock_t *tmp___0 ; raw_spinlock_t *tmp___1 ; raw_spinlock_t *tmp___2 ; raw_spinlock_t *tmp___3 ; int tmp___4 ; int tmp___5 ; { cs = (struct IsdnCardState *)st->l1.hardware; skb = (struct sk_buff *)arg; switch (pr) { case 288: ; if ((cs->debug & 1024) != 0) { LogFrame(cs, skb->data, (int )skb->len); } else { } if ((cs->debug & 2048) != 0) { dlogframe(cs, skb, 0); } else { } tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); if ((unsigned long )cs->tx_skb != (unsigned long )((struct sk_buff *)0)) { skb_queue_tail(& cs->sq, skb); if ((cs->debug & 64) != 0) { Logl2Frame(cs, skb, (char *)"PH_DATA Queued", 0); } else { } } else { cs->tx_skb = skb; cs->tx_cnt = 0; if ((cs->debug & 64) != 0) { Logl2Frame(cs, skb, (char *)"PH_DATA", 0); } else { } W6692_fill_fifo(cs); } spin_unlock_irqrestore(& cs->lock, flags); goto ldv_41084; case 306: tmp___0 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___0); if ((unsigned long )cs->tx_skb != (unsigned long )((struct sk_buff *)0)) { if (cs->debug & 1) { debugl1(cs, (char *)" l2l1 tx_skb exist this shouldn\'t happen"); } else { } skb_queue_tail(& cs->sq, skb); spin_unlock_irqrestore(& cs->lock, flags); goto ldv_41084; } else { } if ((cs->debug & 1024) != 0) { LogFrame(cs, skb->data, (int )skb->len); } else { } if ((cs->debug & 2048) != 0) { dlogframe(cs, skb, 0); } else { } cs->tx_skb = skb; cs->tx_cnt = 0; if ((cs->debug & 64) != 0) { Logl2Frame(cs, skb, (char *)"PH_DATA_PULLED", 0); } else { } W6692_fill_fifo(cs); spin_unlock_irqrestore(& cs->lock, flags); goto ldv_41084; case 304: ; if ((cs->debug & 64) != 0) { debugl1(cs, (char *)"-> PH_REQUEST_PULL"); } else { } if ((unsigned long )cs->tx_skb == (unsigned long )((struct sk_buff *)0)) { test_and_clear_bit(6, (unsigned long volatile *)(& st->l1.Flags)); (*(st->l1.l1l2))(st, 305, 0); } else { test_and_set_bit(6, (unsigned long volatile *)(& st->l1.Flags)); } goto ldv_41084; case 4: tmp___1 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___1); if (cs->dc.w6692.ph_state == 0) { ph_command___2(cs, 0U); spin_unlock_irqrestore(& cs->lock, flags); } else { ph_command___2(cs, 1U); cs->dc.w6692.ph_state = 1; spin_unlock_irqrestore(& cs->lock, flags); W6692_new_ph(cs); } goto ldv_41084; case 0: tmp___2 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___2); ph_command___2(cs, 0U); spin_unlock_irqrestore(& cs->lock, flags); goto ldv_41084; case 48: tmp___3 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___3); ph_command___2(cs, 8U); spin_unlock_irqrestore(& cs->lock, flags); goto ldv_41084; case 112: val = 0; if ((int )((long )arg) & 1) { val = val | 12; } else { } if (((long )arg & 2L) != 0L) { val = val | 3; } else { } goto ldv_41084; case 27: skb_queue_purge(& cs->rq); skb_queue_purge(& cs->sq); if ((unsigned long )cs->tx_skb != (unsigned long )((struct sk_buff *)0)) { dev_kfree_skb_any(cs->tx_skb); cs->tx_skb = 0; } else { } tmp___4 = test_and_clear_bit(6, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___4 != 0) { del_timer(& cs->dbusytimer); } else { } tmp___5 = test_and_clear_bit(5, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___5 != 0) { test_and_set_bit(3, (unsigned long volatile *)(& cs->event)); schedule_work(& cs->tqueue); } else { } goto ldv_41084; default: ; if (cs->debug & 1) { debugl1(cs, (char *)"W6692_l1hw unknown %04x", pr); } else { } goto ldv_41084; } ldv_41084: ; return; } } static void setstack_W6692(struct PStack *st , struct IsdnCardState *cs ) { { st->l1.l1hw = & W6692_l1hw; return; } } static void DC_Close_W6692(struct IsdnCardState *cs ) { { return; } } static void dbusy_timer_handler___2(struct IsdnCardState *cs ) { struct PStack *stptr ; int rbch ; int star ; u_long flags ; raw_spinlock_t *tmp ; u_char tmp___0 ; u_char tmp___1 ; int tmp___2 ; { tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); tmp___2 = constant_test_bit(6U, (unsigned long const volatile *)(& cs->HW_Flags)); if (tmp___2 != 0) { tmp___0 = (*(cs->readisac))(cs, 68); rbch = (int )tmp___0; tmp___1 = (*(cs->readisac))(cs, 36); star = (int )tmp___1; if (cs->debug != 0) { debugl1(cs, (char *)"D-Channel Busy D_RBCH %02x D_STAR %02x", rbch, star); } else { } if ((star & 32) != 0) { test_and_set_bit(5, (unsigned long volatile *)(& cs->HW_Flags)); stptr = cs->stlist; goto ldv_41123; ldv_41122: (*(stptr->l1.l1l2))(stptr, 338, 0); stptr = stptr->next; ldv_41123: ; if ((unsigned long )stptr != (unsigned long )((struct PStack *)0)) { goto ldv_41122; } else { } } else { test_and_clear_bit(6, (unsigned long volatile *)(& cs->HW_Flags)); if ((unsigned long )cs->tx_skb != (unsigned long )((struct sk_buff *)0)) { dev_kfree_skb_any(cs->tx_skb); cs->tx_cnt = 0; cs->tx_skb = 0; } else { printk("\fHiSax: W6692 D-Channel Busy no skb\n"); debugl1(cs, (char *)"D-Channel Busy no skb"); } (*(cs->writeisac))(cs, 8, 1); spin_unlock_irqrestore(& cs->lock, flags); (*(cs->irq_func))((int )cs->irq, (void *)cs); return; } } else { } spin_unlock_irqrestore(& cs->lock, flags); return; } } static void W6692Bmode(struct BCState *bcs , int mode , int bchan ) { struct IsdnCardState *cs ; { cs = bcs->cs; if ((cs->debug & 16) != 0) { debugl1(cs, (char *)"w6692 %c mode %d ichan %d", bchan + 49, mode, bchan); } else { } bcs->mode = mode; bcs->channel = bchan; bcs->hw.w6692.bchan = bchan; switch (mode) { case 0: (*(cs->BC_Write_Reg))(cs, bchan, 140, 0); goto ldv_41132; case 1: (*(cs->BC_Write_Reg))(cs, bchan, 140, 128); goto ldv_41132; case 2: (*(cs->BC_Write_Reg))(cs, bchan, 140, 64); (*(cs->BC_Write_Reg))(cs, bchan, 156, 255); (*(cs->BC_Write_Reg))(cs, bchan, 160, 255); goto ldv_41132; } ldv_41132: ; if (mode != 0) { (*(cs->BC_Write_Reg))(cs, bchan, 136, 97); } else { } (*(cs->BC_Write_Reg))(cs, bchan, 148, 0); return; } } static void W6692_l2l1(struct PStack *st , int pr , void *arg ) { struct sk_buff *skb ; struct BCState *bcs ; u_long flags ; raw_spinlock_t *tmp ; raw_spinlock_t *tmp___0 ; raw_spinlock_t *tmp___1 ; raw_spinlock_t *tmp___2 ; { skb = (struct sk_buff *)arg; bcs = st->l1.bcs; switch (pr) { case 288: tmp = spinlock_check(& (bcs->cs)->lock); flags = _raw_spin_lock_irqsave(tmp); if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { skb_queue_tail(& bcs->squeue, skb); } else { bcs->tx_skb = skb; test_and_set_bit(3, (unsigned long volatile *)(& bcs->Flag)); bcs->hw.w6692.count = 0; (*((bcs->cs)->BC_Send_Data))(bcs); } spin_unlock_irqrestore(& (bcs->cs)->lock, flags); goto ldv_41147; case 306: ; if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { printk("\fW6692_l2l1: this shouldn\'t happen\n"); goto ldv_41147; } else { } tmp___0 = spinlock_check(& (bcs->cs)->lock); flags = _raw_spin_lock_irqsave(tmp___0); test_and_set_bit(3, (unsigned long volatile *)(& bcs->Flag)); bcs->tx_skb = skb; bcs->hw.w6692.count = 0; (*((bcs->cs)->BC_Send_Data))(bcs); spin_unlock_irqrestore(& (bcs->cs)->lock, flags); goto ldv_41147; case 304: ; if ((unsigned long )bcs->tx_skb == (unsigned long )((struct sk_buff *)0)) { test_and_clear_bit(6, (unsigned long volatile *)(& st->l1.Flags)); (*(st->l1.l1l2))(st, 305, 0); } else { test_and_set_bit(6, (unsigned long volatile *)(& st->l1.Flags)); } goto ldv_41147; case 256: tmp___1 = spinlock_check(& (bcs->cs)->lock); flags = _raw_spin_lock_irqsave(tmp___1); test_and_set_bit(2, (unsigned long volatile *)(& bcs->Flag)); W6692Bmode(bcs, st->l1.mode, st->l1.bc); spin_unlock_irqrestore(& (bcs->cs)->lock, flags); l1_msg_b(st, pr, arg); goto ldv_41147; case 272: l1_msg_b(st, pr, arg); goto ldv_41147; case 273: tmp___2 = spinlock_check(& (bcs->cs)->lock); flags = _raw_spin_lock_irqsave(tmp___2); test_and_clear_bit(2, (unsigned long volatile *)(& bcs->Flag)); test_and_clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); W6692Bmode(bcs, 0, st->l1.bc); spin_unlock_irqrestore(& (bcs->cs)->lock, flags); (*(st->l1.l1l2))(st, 273, 0); goto ldv_41147; } ldv_41147: ; return; } } static void close_w6692state(struct BCState *bcs ) { int tmp ; { W6692Bmode(bcs, 0, bcs->channel); tmp = test_and_clear_bit(1, (unsigned long volatile *)(& bcs->Flag)); if (tmp != 0) { kfree((void const *)bcs->hw.w6692.rcvbuf); bcs->hw.w6692.rcvbuf = 0; kfree((void const *)bcs->blog); bcs->blog = 0; skb_queue_purge(& bcs->rqueue); skb_queue_purge(& bcs->squeue); if ((unsigned long )bcs->tx_skb != (unsigned long )((struct sk_buff *)0)) { dev_kfree_skb_any(bcs->tx_skb); bcs->tx_skb = 0; test_and_clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); } else { } } else { } return; } } static int open_w6692state(struct IsdnCardState *cs , struct BCState *bcs ) { u_char *tmp ; void *tmp___0 ; u_char *tmp___1 ; void *tmp___2 ; int tmp___3 ; { tmp___3 = test_and_set_bit(1, (unsigned long volatile *)(& bcs->Flag)); if (tmp___3 == 0) { tmp___0 = kmalloc(4096UL, 32U); tmp = (u_char *)tmp___0; bcs->hw.w6692.rcvbuf = tmp; if ((unsigned long )tmp == (unsigned long )((u_char *)0)) { printk("\fHiSax: No memory for w6692.rcvbuf\n"); test_and_clear_bit(1, (unsigned long volatile *)(& bcs->Flag)); return (1); } else { } tmp___2 = kmalloc(256UL, 32U); tmp___1 = (u_char *)tmp___2; bcs->blog = tmp___1; if ((unsigned long )tmp___1 == (unsigned long )((u_char *)0)) { printk("\fHiSax: No memory for bcs->blog\n"); test_and_clear_bit(1, (unsigned long volatile *)(& bcs->Flag)); kfree((void const *)bcs->hw.w6692.rcvbuf); bcs->hw.w6692.rcvbuf = 0; return (2); } else { } skb_queue_head_init(& bcs->rqueue); skb_queue_head_init(& bcs->squeue); } else { } bcs->tx_skb = 0; test_and_clear_bit(3, (unsigned long volatile *)(& bcs->Flag)); bcs->event = 0UL; bcs->hw.w6692.rcvidx = 0; bcs->tx_cnt = 0; return (0); } } static int setstack_w6692(struct PStack *st , struct BCState *bcs ) { int tmp ; { bcs->channel = st->l1.bc; tmp = open_w6692state((struct IsdnCardState *)st->l1.hardware, bcs); if (tmp != 0) { return (-1); } else { } st->l1.bcs = bcs; st->l2.l2l1 = & W6692_l2l1; setstack_manager(st); bcs->st = st; setstack_l1_B(st); return (0); } } static void resetW6692(struct IsdnCardState *cs ) { unsigned long __ms ; unsigned long tmp ; unsigned long __ms___0 ; unsigned long tmp___0 ; { (*(cs->writeisac))(cs, 84, 32); __ms = 10UL; goto ldv_41178; ldv_41177: __const_udelay(4295000UL); ldv_41178: tmp = __ms; __ms = __ms - 1UL; if (tmp != 0UL) { goto ldv_41177; } else { } (*(cs->writeisac))(cs, 84, 0); __ms___0 = 10UL; goto ldv_41182; ldv_41181: __const_udelay(4295000UL); ldv_41182: tmp___0 = __ms___0; __ms___0 = __ms___0 - 1UL; if (tmp___0 != 0UL) { goto ldv_41181; } else { } (*(cs->writeisac))(cs, 24, 255); (*(cs->writeisac))(cs, 44, 255); (*(cs->writeisac))(cs, 56, 255); (*(cs->writeisac))(cs, 32, 0); (*(cs->writeisac))(cs, 12, 64); (*(cs->writeisac))(cs, 24, 24); if ((unsigned int )cs->subtyp == 2U) { (*(cs->writeisac))(cs, 104, 128); (*(cs->writeisac))(cs, 248, 0); } else { } return; } } static void initW6692(struct IsdnCardState *cs , int part ) { struct lock_class_key __key ; { if (part & 1) { cs->setstack_d = & setstack_W6692; cs->DC_Close = & DC_Close_W6692; cs->dbusytimer.function = (void (*)(unsigned long ))(& dbusy_timer_handler___2); cs->dbusytimer.data = (unsigned long )cs; init_timer_key(& cs->dbusytimer, 0U, "(&cs->dbusytimer)", & __key); resetW6692(cs); ph_command___2(cs, 1U); cs->dc.w6692.ph_state = 1; W6692_new_ph(cs); ph_command___2(cs, 0U); cs->bcs[0].BC_SetStack = & setstack_w6692; cs->bcs[1].BC_SetStack = & setstack_w6692; cs->bcs[0].BC_Close = & close_w6692state; cs->bcs[1].BC_Close = & close_w6692state; W6692Bmode((struct BCState *)(& cs->bcs), 0, 0); W6692Bmode((struct BCState *)(& cs->bcs) + 1UL, 0, 0); } else { } if ((part & 2) != 0) { (*(cs->writeisac))(cs, 24, 24); (*(cs->writeisac))(cs, 32, 0); (*(cs->BC_Write_Reg))(cs, 0, 148, 0); (*(cs->BC_Write_Reg))(cs, 1, 148, 0); (*(cs->writeisac))(cs, 8, 65); } else { } return; } } static u_char ReadW6692(struct IsdnCardState *cs , u_char offset ) { unsigned char tmp ; { tmp = inb((int )(cs->hw.w6692.iobase + (unsigned int )offset)); return (tmp); } } static void WriteW6692(struct IsdnCardState *cs , u_char offset , u_char value ) { { outb((int )value, (int )(cs->hw.w6692.iobase + (unsigned int )offset)); return; } } static void ReadISACfifo___11(struct IsdnCardState *cs , u_char *data , int size ) { { insb((int )cs->hw.w6692.iobase, (void *)data, (unsigned long )size); return; } } static void WriteISACfifo___11(struct IsdnCardState *cs , u_char *data , int size ) { { outsb((int )(cs->hw.w6692.iobase + 4U), (void const *)data, (unsigned long )size); return; } } static u_char ReadW6692B(struct IsdnCardState *cs , int bchan , u_char offset ) { unsigned char tmp ; { tmp = inb((int )((cs->hw.w6692.iobase + (bchan != 0 ? 64U : 0U)) + (unsigned int )offset)); return (tmp); } } static void WriteW6692B(struct IsdnCardState *cs , int bchan , u_char offset , u_char value ) { { outb((int )value, (int )((cs->hw.w6692.iobase + (bchan != 0 ? 64U : 0U)) + (unsigned int )offset)); return; } } static int w6692_card_msg(struct IsdnCardState *cs , int mt , void *arg ) { { switch (mt) { case 240: resetW6692(cs); return (0); case 243: (*(cs->writeisac))(cs, 24, 255); __release_region(& ioport_resource, (resource_size_t )cs->hw.w6692.iobase, 256ULL); if ((unsigned int )cs->subtyp == 2U) { (*(cs->writeisac))(cs, 248, 4); } else { } return (0); case 242: initW6692(cs, 3); return (0); case 244: ; return (0); } return (0); } } static int id_idx ; static struct pci_dev *dev_w6692 = 0; int setup_w6692(struct IsdnCard *card ) { struct IsdnCardState *cs ; char tmp[64U] ; u_char found ; u_char pci_irq___0 ; u_int pci_ioaddr ; char *tmp___0 ; int tmp___1 ; struct resource *tmp___2 ; struct lock_class_key __key ; atomic_long_t __constr_expr_0 ; u_char tmp___3 ; u_char tmp___4 ; u_char tmp___5 ; u_char tmp___6 ; u_char tmp___7 ; { cs = card->cs; found = 0U; pci_irq___0 = 0U; pci_ioaddr = 0U; strcpy((char *)(& tmp), w6692_revision); tmp___0 = HiSax_getrev((char const *)(& tmp)); printk("\016HiSax: W6692 driver Rev. %s\n", tmp___0); if ((unsigned int )cs->typ != 36U) { return (0); } else { } goto ldv_41238; ldv_41240: dev_w6692 = hisax_find_pci_device((unsigned int )id_list___0[id_idx].vendor_id, (unsigned int )id_list___0[id_idx].device_id, dev_w6692); if ((unsigned long )dev_w6692 != (unsigned long )((struct pci_dev *)0)) { tmp___1 = pci_enable_device(dev_w6692); if (tmp___1 != 0) { goto ldv_41238; } else { } cs->subtyp = (u_char )id_idx; goto ldv_41239; } else { } id_idx = id_idx + 1; ldv_41238: ; if ((int )id_list___0[id_idx].vendor_id != 0) { goto ldv_41240; } else { } ldv_41239: ; if ((unsigned long )dev_w6692 != (unsigned long )((struct pci_dev *)0)) { found = 1U; pci_irq___0 = (u_char )dev_w6692->irq; pci_ioaddr = (u_int )dev_w6692->resource[1].start; if ((unsigned int )cs->subtyp == 0U) { if ((unsigned int )dev_w6692->subsystem_vendor == 5868U && (unsigned int )dev_w6692->subsystem_device == 13321U) { cs->subtyp = 2U; } else { } } else { } } else { } if ((unsigned int )found == 0U) { printk("\fW6692: No PCI card found\n"); return (0); } else { } cs->irq = (u_int )pci_irq___0; if (cs->irq == 0U) { printk("\fW6692: No IRQ for PCI card found\n"); return (0); } else { } if (pci_ioaddr == 0U) { printk("\fW6692: NO I/O Base Address found\n"); return (0); } else { } cs->hw.w6692.iobase = pci_ioaddr; printk("\016Found: %s %s, I/O base: 0x%x, irq: %d\n", id_list___0[(int )cs->subtyp].vendor_name, id_list___0[(int )cs->subtyp].card_name, pci_ioaddr, (int )pci_irq___0); tmp___2 = __request_region(& ioport_resource, (resource_size_t )cs->hw.w6692.iobase, 256ULL, (char const *)id_list___0[(int )cs->subtyp].card_name, 0); if ((unsigned long )tmp___2 == (unsigned long )((struct resource *)0)) { printk("\fHiSax: %s I/O ports %x-%x already in use\n", id_list___0[(int )cs->subtyp].card_name, cs->hw.w6692.iobase, cs->hw.w6692.iobase + 255U); return (0); } else { } printk("\016HiSax: %s config irq:%d I/O:%x\n", id_list___0[(int )cs->subtyp].card_name, cs->irq, cs->hw.w6692.iobase); __init_work(& cs->tqueue, 0); __constr_expr_0.counter = 4195328L; cs->tqueue.data = __constr_expr_0; lockdep_init_map(& cs->tqueue.lockdep_map, "(&cs->tqueue)", & __key, 0); INIT_LIST_HEAD(& cs->tqueue.entry); cs->tqueue.func = & W6692_bh; cs->readisac = & ReadW6692; cs->writeisac = & WriteW6692; cs->readisacfifo = & ReadISACfifo___11; cs->writeisacfifo = & WriteISACfifo___11; cs->BC_Read_Reg = & ReadW6692B; cs->BC_Write_Reg = & WriteW6692B; cs->BC_Send_Data = & W6692B_fill_fifo; cs->cardmsg = & w6692_card_msg; cs->irq_func = & W6692_interrupt; cs->irq_flags = cs->irq_flags | 128UL; W6692Version(cs, (char *)"W6692:"); tmp___3 = ReadW6692(cs, 20); printk("\016W6692 ISTA=0x%X\n", (int )tmp___3); tmp___4 = ReadW6692(cs, 24); printk("\016W6692 IMASK=0x%X\n", (int )tmp___4); tmp___5 = ReadW6692(cs, 28); printk("\016W6692 D_EXIR=0x%X\n", (int )tmp___5); tmp___6 = ReadW6692(cs, 32); printk("\016W6692 D_EXIM=0x%X\n", (int )tmp___6); tmp___7 = ReadW6692(cs, 40); printk("\016W6692 D_RSTA=0x%X\n", (int )tmp___7); return (1); } } void ldv_mutex_lock_505(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_lock(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_506(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_lock(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_507(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } int ldv_mutex_trylock_508(struct mutex *ldv_func_arg1 ) { ldv_func_ret_type___2 ldv_func_res ; int tmp ; int tmp___0 ; { tmp = mutex_trylock(ldv_func_arg1); ldv_func_res = tmp; tmp___0 = ldv_mutex_trylock_mutex(ldv_func_arg1); return (tmp___0); return (ldv_func_res); } } void ldv_mutex_unlock_509(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_510(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_cred_guard_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_511(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_cred_guard_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } int ldv_mutex_trylock_522(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_520(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_523(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_525(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_519(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_521(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_524(struct mutex *ldv_func_arg1 ) ; void Amd7930_interrupt(struct IsdnCardState *cs , unsigned char irflags ) ; void Amd7930_init(struct IsdnCardState *cs ) ; void setup_Amd7930(struct IsdnCardState *cs ) ; static char const *enternow_pci_rev = "$Revision: 1.1.4.5 $"; static unsigned char ReadByteAmd7930(struct IsdnCardState *cs , unsigned char offset ) { unsigned char tmp ; unsigned char tmp___0 ; { if ((unsigned int )offset <= 7U) { tmp = inb((int )(cs->hw.njet.isac + (unsigned int )((int )offset * 4))); return (tmp); } else { outb((int )offset, (int )cs->hw.njet.isac); tmp___0 = inb((int )(cs->hw.njet.isac + 4U)); return (tmp___0); } } } static void WriteByteAmd7930(struct IsdnCardState *cs , unsigned char offset , unsigned char value ) { { if ((unsigned int )offset <= 7U) { outb((int )value, (int )(cs->hw.njet.isac + (unsigned int )((int )offset * 4))); } else { outb((int )offset, (int )cs->hw.njet.isac); outb((int )value, (int )(cs->hw.njet.isac + 4U)); } return; } } static void enpci_setIrqMask(struct IsdnCardState *cs , unsigned char val ) { { if ((unsigned int )val == 0U) { outb(0, (int )((unsigned int )cs->hw.njet.base + 5U)); } else { outb(32, (int )((unsigned int )cs->hw.njet.base + 5U)); } return; } } static unsigned char dummyrr___1(struct IsdnCardState *cs , int chan , unsigned char off ) { { return (5U); } } static void dummywr___1(struct IsdnCardState *cs , int chan , unsigned char off , unsigned char value ) { { return; } } static void reset_enpci(struct IsdnCardState *cs ) { unsigned long __ms ; unsigned long tmp ; unsigned long __ms___0 ; unsigned long tmp___0 ; { if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"enter:now PCI: reset"); } else { } cs->hw.njet.ctrl_reg = 7U; outb((int )cs->hw.njet.ctrl_reg, (int )cs->hw.njet.base); __ms = 20UL; goto ldv_41094; ldv_41093: __const_udelay(4295000UL); ldv_41094: tmp = __ms; __ms = __ms - 1UL; if (tmp != 0UL) { goto ldv_41093; } else { } cs->hw.njet.ctrl_reg = 48U; outb((int )cs->hw.njet.ctrl_reg, (int )cs->hw.njet.base); __ms___0 = 20UL; goto ldv_41098; ldv_41097: __const_udelay(4295000UL); ldv_41098: tmp___0 = __ms___0; __ms___0 = __ms___0 - 1UL; if (tmp___0 != 0UL) { goto ldv_41097; } else { } cs->hw.njet.auxd = 0U; cs->hw.njet.dmactrl = 0U; outb(223, (int )((unsigned int )cs->hw.njet.base + 2U)); outb(32, (int )((unsigned int )cs->hw.njet.base + 5U)); outb((int )cs->hw.njet.auxd, (int )cs->hw.njet.auxa); return; } } static int enpci_card_msg(struct IsdnCardState *cs , int mt , void *arg ) { u_long flags ; unsigned char *chan ; raw_spinlock_t *tmp ; { if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"enter:now PCI: card_msg: 0x%04X", mt); } else { } switch (mt) { case 240: tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); reset_enpci(cs); Amd7930_init(cs); spin_unlock_irqrestore(& cs->lock, flags); goto ldv_41111; case 243: release_io_netjet(cs); goto ldv_41111; case 242: reset_enpci(cs); inittiger(cs); Amd7930_init(cs); goto ldv_41111; case 244: ; goto ldv_41111; case 640: cs->hw.njet.auxd = 64U; outb((int )cs->hw.njet.auxd, (int )((unsigned int )cs->hw.njet.base + 3U)); goto ldv_41111; case 644: cs->hw.njet.auxd = 0U; outb(0, (int )((unsigned int )cs->hw.njet.base + 3U)); goto ldv_41111; case 636: chan = (unsigned char *)arg; if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"enter:now PCI: assign phys. BC %d in AMD LMR1", (int )*chan); } else { } (*(cs->dc.amd7930.ph_command))(cs, (int )((u_char )((int )((signed char )cs->dc.amd7930.lmr1) | (int )((signed char )((unsigned int )*chan + 1U)))), (char *)"MDL_BC_ASSIGN"); cs->hw.njet.auxd = (unsigned int )cs->hw.njet.auxd | 128U; outb((int )cs->hw.njet.auxd, (int )((unsigned int )cs->hw.njet.base + 3U)); goto ldv_41111; case 632: chan = (unsigned char *)arg; if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"enter:now PCI: release phys. BC %d in Amd LMR1", (int )*chan); } else { } (*(cs->dc.amd7930.ph_command))(cs, (int )((u_char )((int )((signed char )cs->dc.amd7930.lmr1) & (int )((signed char )(~ ((unsigned int )*chan + 1U))))), (char *)"MDL_BC_RELEASE"); if (((int )cs->dc.amd7930.lmr1 & 3) == 0) { cs->hw.njet.auxd = (unsigned int )cs->hw.njet.auxd & 127U; outb((int )cs->hw.njet.auxd, (int )((unsigned int )cs->hw.njet.base + 3U)); } else { } goto ldv_41111; default: ; goto ldv_41111; } ldv_41111: ; return (0); } } static irqreturn_t enpci_interrupt(int intno , void *dev_id ) { struct IsdnCardState *cs ; unsigned char s0val ; unsigned char s1val ; unsigned char ir ; u_long flags ; raw_spinlock_t *tmp ; unsigned int tmp___0 ; unsigned int tmp___1 ; unsigned int tmp___2 ; unsigned int tmp___3 ; int tmp___4 ; { cs = (struct IsdnCardState *)dev_id; tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); s1val = inb((int )((unsigned int )cs->hw.njet.base + 7U)); if (((int )s1val & 32) == 0) { ir = ReadByteAmd7930(cs, 0); Amd7930_interrupt(cs, (int )ir); s1val = 1U; } else { s1val = 0U; } s0val = inb((int )((unsigned int )cs->hw.njet.base + 6U)); if ((unsigned int )((int )s0val | (int )s1val) == 0U) { spin_unlock_irqrestore(& cs->lock, flags); return (0); } else { } if ((unsigned int )s0val != 0U) { outb((int )s0val, (int )((unsigned int )cs->hw.njet.base + 6U)); } else { } tmp___0 = inl((int )((unsigned int )cs->hw.njet.base + 36U)); tmp___1 = inl((int )((unsigned int )cs->hw.njet.base + 28U)); if (tmp___0 < tmp___1) { s0val = 8U; } else { s0val = 4U; } tmp___2 = inl((int )((unsigned int )cs->hw.njet.base + 20U)); tmp___3 = inl((int )((unsigned int )cs->hw.njet.base + 12U)); if (tmp___2 < tmp___3) { s0val = (unsigned int )s0val | 2U; } else { s0val = (unsigned int )s0val | 1U; } if ((int )cs->hw.njet.last_is0 != (int )s0val) { tmp___4 = test_and_set_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___4 != 0) { spin_unlock_irqrestore(& cs->lock, flags); return (1); } else { } cs->hw.njet.irqstat0 = s0val; if ((((int )cs->hw.njet.irqstat0 ^ (int )cs->hw.njet.last_is0) & 12) != 0) { read_tiger(cs); } else { } if ((((int )cs->hw.njet.irqstat0 ^ (int )cs->hw.njet.last_is0) & 3) != 0) { write_tiger(cs); } else { } test_and_clear_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); } else { } spin_unlock_irqrestore(& cs->lock, flags); return (1); } } static int en_pci_probe(struct pci_dev *dev_netjet___2 , struct IsdnCardState *cs ) { int tmp ; { tmp = pci_enable_device(dev_netjet___2); if (tmp != 0) { return (0); } else { } cs->irq = dev_netjet___2->irq; if (cs->irq == 0U) { printk("\fenter:now PCI: No IRQ for PCI card found\n"); return (0); } else { } cs->hw.njet.base = (unsigned long )dev_netjet___2->resource[0].start; if (cs->hw.njet.base == 0UL) { printk("\fenter:now PCI: No IO-Adr for PCI card found\n"); return (0); } else { } if ((unsigned int )dev_netjet___2->subsystem_vendor != 85U || (unsigned int )dev_netjet___2->subsystem_device != 2U) { printk("\fenter:now: You tried to load this driver with an incompatible TigerJet-card\n"); printk("\fUse type=20 for Traverse NetJet PCI Card.\n"); return (0); } else { } return (1); } } static void en_cs_init(struct IsdnCard *card , struct IsdnCardState *cs ) { unsigned long __ms ; unsigned long tmp ; unsigned long __ms___0 ; unsigned long tmp___0 ; { cs->hw.njet.auxa = (unsigned int )cs->hw.njet.base + 3U; cs->hw.njet.isac = (unsigned int )cs->hw.njet.base + 192U; cs->hw.njet.ctrl_reg = 7U; outb((int )cs->hw.njet.ctrl_reg, (int )cs->hw.njet.base); __ms = 20UL; goto ldv_41142; ldv_41141: __const_udelay(4295000UL); ldv_41142: tmp = __ms; __ms = __ms - 1UL; if (tmp != 0UL) { goto ldv_41141; } else { } cs->hw.njet.ctrl_reg = 48U; outb((int )cs->hw.njet.ctrl_reg, (int )cs->hw.njet.base); __ms___0 = 10UL; goto ldv_41146; ldv_41145: __const_udelay(4295000UL); ldv_41146: tmp___0 = __ms___0; __ms___0 = __ms___0 - 1UL; if (tmp___0 != 0UL) { goto ldv_41145; } else { } cs->hw.njet.auxd = 0U; cs->hw.njet.dmactrl = 0U; outb(223, (int )((unsigned int )cs->hw.njet.base + 2U)); outb(32, (int )((unsigned int )cs->hw.njet.base + 5U)); outb((int )cs->hw.njet.auxd, (int )cs->hw.njet.auxa); return; } } static int en_cs_init_rest(struct IsdnCard *card , struct IsdnCardState *cs ) { int bytecnt ; struct resource *tmp ; { bytecnt = 256; printk("\016enter:now PCI: PCI card configured at 0x%lx IRQ %d\n", cs->hw.njet.base, cs->irq); tmp = __request_region(& ioport_resource, (resource_size_t )cs->hw.njet.base, (resource_size_t )bytecnt, "Fn_ISDN", 0); if ((unsigned long )tmp == (unsigned long )((struct resource *)0)) { printk("\fHiSax: enter:now config port %lx-%lx already in use\n", cs->hw.njet.base, cs->hw.njet.base + (unsigned long )bytecnt); return (0); } else { } setup_Amd7930(cs); cs->hw.njet.last_is0 = 0U; cs->readisac = & ReadByteAmd7930; cs->writeisac = & WriteByteAmd7930; cs->dc.amd7930.setIrqMask = & enpci_setIrqMask; cs->BC_Read_Reg = & dummyrr___1; cs->BC_Write_Reg = & dummywr___1; cs->BC_Send_Data = & netjet_fill_dma; cs->cardmsg = & enpci_card_msg; cs->irq_func = & enpci_interrupt; cs->irq_flags = cs->irq_flags | 128UL; return (1); } } static struct pci_dev *dev_netjet___1 = 0; int setup_enternow_pci(struct IsdnCard *card ) { int ret ; struct IsdnCardState *cs ; char tmp[64U] ; char *tmp___0 ; int tmp___1 ; { cs = card->cs; strcpy((char *)(& tmp), enternow_pci_rev); tmp___0 = HiSax_getrev((char const *)(& tmp)); printk("\016HiSax: Formula-n Europe AG enter:now ISDN PCI driver Rev. %s\n", tmp___0); if ((unsigned int )cs->typ != 41U) { return (0); } else { } test_and_clear_bit(7, (unsigned long volatile *)(& cs->HW_Flags)); ldv_41161: dev_netjet___1 = hisax_find_pci_device(57689U, 1U, dev_netjet___1); if ((unsigned long )dev_netjet___1 != (unsigned long )((struct pci_dev *)0)) { ret = en_pci_probe(dev_netjet___1, cs); if (ret == 0) { return (0); } else { } } else { printk("\fenter:now PCI: No PCI card found\n"); return (0); } en_cs_init(card, cs); goto ldv_41160; goto ldv_41161; ldv_41160: tmp___1 = en_cs_init_rest(card, cs); return (tmp___1); } } void ldv_mutex_lock_519(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_lock(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_520(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_lock(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_521(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } int ldv_mutex_trylock_522(struct mutex *ldv_func_arg1 ) { ldv_func_ret_type___2 ldv_func_res ; int tmp ; int tmp___0 ; { tmp = mutex_trylock(ldv_func_arg1); ldv_func_res = tmp; tmp___0 = ldv_mutex_trylock_mutex(ldv_func_arg1); return (tmp___0); return (ldv_func_res); } } void ldv_mutex_unlock_523(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_524(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_cred_guard_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_525(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_cred_guard_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } int ldv_mutex_trylock_536(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_534(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_537(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_unlock_539(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_533(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_535(struct mutex *ldv_func_arg1 ) ; void ldv_mutex_lock_538(struct mutex *ldv_func_arg1 ) ; static void Amd7930_new_ph(struct IsdnCardState *cs ) ; static unsigned int initAMD[85U] = { 256U, 165U, 3U, 1U, 64U, 88U, 134U, 1U, 11U, 135U, 1U, 255U, 146U, 1U, 3U, 144U, 4U, 254U, 255U, 2U, 15U, 132U, 2U, 128U, 0U, 192U, 1U, 71U, 200U, 1U, 1U, 258U, 263U, 417U, 1U, 289U, 1U, 393U, 2U, 69U, 4U, 97U, 114U, 0U, 0U, 99U, 2U, 8U, 8U, 100U, 2U, 8U, 8U, 101U, 2U, 153U, 0U, 102U, 2U, 124U, 139U, 103U, 2U, 0U, 0U, 104U, 2U, 32U, 32U, 105U, 1U, 79U, 106U, 1U, 0U, 108U, 1U, 64U, 33U, 1U, 2U, 163U, 1U, 64U, 65535U}; static void WriteWordAmd7930(struct IsdnCardState *cs , unsigned char reg , unsigned int val ) { { (*(cs->writeisac))(cs, 0, (int )reg); (*(cs->writeisac))(cs, 1, (int )((unsigned char )val)); (*(cs->writeisac))(cs, 1, (int )((unsigned char )((val & 65280U) / 256U))); return; } } static unsigned int ReadWordAmd7930(struct IsdnCardState *cs , unsigned char reg ) { unsigned int res ; u_char tmp ; u_char tmp___0 ; u_char tmp___1 ; u_char tmp___2 ; { if ((unsigned int )reg <= 7U) { tmp = (*(cs->readisac))(cs, (int )reg); res = (unsigned int )tmp; tmp___0 = (*(cs->readisac))(cs, (int )reg); res = (unsigned int )((int )tmp___0 * 256) + res; } else { (*(cs->writeisac))(cs, 0, (int )reg); tmp___1 = (*(cs->readisac))(cs, 1); res = (unsigned int )tmp___1; tmp___2 = (*(cs->readisac))(cs, 1); res = (unsigned int )((int )tmp___2 * 256) + res; } return (res); } } static void Amd7930_ph_command(struct IsdnCardState *cs , u_char command , char *s ) { { if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"AMD7930: %s: ph_command 0x%02X", s, (int )command); } else { } cs->dc.amd7930.lmr1 = command; (*(cs->writeisac))(cs, 163, (int )command); return; } } static unsigned char i430States[72U] = { 1U, 2U, 0U, 0U, 0U, 7U, 5U, 0U, 1U, 2U, 0U, 0U, 0U, 7U, 5U, 0U, 1U, 2U, 0U, 0U, 0U, 9U, 5U, 4U, 1U, 2U, 0U, 0U, 27U, 0U, 0U, 0U, 1U, 2U, 0U, 0U, 27U, 0U, 0U, 0U, 1U, 3U, 0U, 0U, 0U, 6U, 5U, 0U, 17U, 19U, 0U, 0U, 27U, 0U, 21U, 0U, 1U, 3U, 0U, 0U, 0U, 6U, 0U, 0U, 1U, 3U, 0U, 0U, 0U, 9U, 0U, 10U}; static unsigned char stateHelper[10U] = { 0U, 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 8U}; static void Amd7930_get_state(struct IsdnCardState *cs ) { unsigned char lsr ; u_char tmp ; { tmp = (*(cs->readisac))(cs, 161); lsr = tmp; cs->dc.amd7930.ph_state = ((unsigned int )lsr & 7U) + 2U; Amd7930_new_ph(cs); return; } } static void Amd7930_new_ph(struct IsdnCardState *cs ) { u_char index ; u_char message ; { index = ((unsigned int )stateHelper[(int )cs->dc.amd7930.old_state] * 8U + (unsigned int )stateHelper[(int )cs->dc.amd7930.ph_state]) + 255U; message = i430States[(int )index]; if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"AMD7930: new_ph %d, old_ph %d, message %d, index %d", (int )cs->dc.amd7930.ph_state, (int )cs->dc.amd7930.old_state, (int )message & 15, (int )index); } else { } cs->dc.amd7930.old_state = cs->dc.amd7930.ph_state; if (((int )message & 240) != 0 && (unsigned long )cs->tx_skb != (unsigned long )((struct sk_buff *)0)) { (*(cs->writeisac))(cs, 33, 194); (*(cs->writeisac))(cs, 33, 2); } else { } switch ((int )message & 15) { case 1: l1_msg(cs, 6, 0); Amd7930_get_state(cs); goto ldv_41011; case 2: l1_msg(cs, 25, 0); goto ldv_41011; case 3: l1_msg(cs, 26, 0); goto ldv_41011; case 4: l1_msg(cs, 9, 0); Amd7930_ph_command(cs, 80, (char *)"HW_ENABLE REQUEST"); goto ldv_41011; case 5: l1_msg(cs, 98, 0); goto ldv_41011; case 6: l1_msg(cs, 66, 0); goto ldv_41011; case 7: l1_msg(cs, 98, 0); l1_msg(cs, 66, 0); goto ldv_41011; case 8: l1_msg(cs, 9, 0); case 9: Amd7930_ph_command(cs, 64, (char *)"HW_ENABLE REQ cleared if set"); l1_msg(cs, 98, 0); l1_msg(cs, 34, 0); l1_msg(cs, 66, 0); goto ldv_41011; case 10: Amd7930_ph_command(cs, 64, (char *)"T3 expired, HW_ENABLE REQ cleared"); cs->dc.amd7930.old_state = 3U; goto ldv_41011; case 11: l1_msg(cs, 34, 0); goto ldv_41011; default: ; goto ldv_41011; } ldv_41011: ; return; } } static void Amd7930_bh(struct work_struct *work ) { struct IsdnCardState *cs ; struct work_struct const *__mptr ; struct PStack *stptr ; int tmp ; int tmp___0 ; int tmp___1 ; int tmp___2 ; { __mptr = (struct work_struct const *)work; cs = (struct IsdnCardState *)__mptr + 0xffffffffffffe728UL; tmp = test_and_clear_bit(3, (unsigned long volatile *)(& cs->event)); if (tmp != 0) { if (cs->debug != 0) { debugl1(cs, (char *)"Amd7930: bh, D-Channel Busy cleared"); } else { } stptr = cs->stlist; goto ldv_41031; ldv_41030: (*(stptr->l1.l1l2))(stptr, 337, 0); stptr = stptr->next; ldv_41031: ; if ((unsigned long )stptr != (unsigned long )((struct PStack *)0)) { goto ldv_41030; } else { } } else { } tmp___0 = test_and_clear_bit(2, (unsigned long volatile *)(& cs->event)); if (tmp___0 != 0) { if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"AMD7930: bh, D_L1STATECHANGE"); } else { } Amd7930_new_ph(cs); } else { } tmp___1 = test_and_clear_bit(0, (unsigned long volatile *)(& cs->event)); if (tmp___1 != 0) { if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"AMD7930: bh, D_RCVBUFREADY"); } else { } DChannel_proc_rcv(cs); } else { } tmp___2 = test_and_clear_bit(1, (unsigned long volatile *)(& cs->event)); if (tmp___2 != 0) { if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"AMD7930: bh, D_XMTBUFREADY"); } else { } DChannel_proc_xmt(cs); } else { } return; } } static void Amd7930_empty_Dfifo(struct IsdnCardState *cs , int flag ) { unsigned char stat ; unsigned char der ; unsigned char *ptr ; struct sk_buff *skb ; unsigned int tmp ; char *t ; int tmp___0 ; size_t __len ; void *__ret ; unsigned char *tmp___2 ; { if ((cs->debug & 4) != 0 && (cs->debug & 8) == 0) { debugl1(cs, (char *)"Amd7930: empty_Dfifo"); } else { } ptr = cs->rcvbuf + (unsigned long )cs->rcvidx; (*(cs->dc.amd7930.setIrqMask))(cs, 0); stat = (*(cs->readisac))(cs, 7); goto ldv_41046; ldv_41045: *ptr = (*(cs->readisac))(cs, 4); ptr = ptr + 1; stat = (*(cs->readisac))(cs, 7); cs->rcvidx = (int )((unsigned int )((long )ptr) - (unsigned int )((long )cs->rcvbuf)); if ((int )stat & 1) { tmp = ReadWordAmd7930(cs, 3); der = (unsigned char )tmp; if ((unsigned int )der == 0U && flag == 0) { ReadWordAmd7930(cs, 137); if (cs->rcvidx > 0) { skb = alloc_skb((unsigned int )cs->rcvidx, 32U); if ((unsigned long )skb == (unsigned long )((struct sk_buff *)0)) { printk("\fHiSax: Amd7930: empty_Dfifo, D receive out of memory!\n"); } else { if ((cs->debug & 8) != 0) { t = cs->dlog; tmp___0 = sprintf(t, "Amd7930: empty_Dfifo cnt: %d |", cs->rcvidx); t = t + (unsigned long )tmp___0; QuickHex(t, cs->rcvbuf, cs->rcvidx); debugl1(cs, cs->dlog); } else { } __len = (size_t )cs->rcvidx; tmp___2 = skb_put(skb, (unsigned int )cs->rcvidx); __ret = memcpy((void *)tmp___2, (void const *)cs->rcvbuf, __len); skb_queue_tail(& cs->rq, skb); } } else { } } else { } ptr = cs->rcvbuf; cs->rcvidx = 0; test_and_set_bit(0, (unsigned long volatile *)(& cs->event)); schedule_work(& cs->tqueue); } else { } ldv_41046: ; if (((int )stat & 2) != 0 && (long )ptr - (long )cs->rcvbuf <= 299L) { goto ldv_41045; } else { } if (cs->rcvidx > 299) { if (cs->debug & 1) { debugl1(cs, (char *)"AMD7930: empty_Dfifo L2-Framelength overrun"); } else { } cs->rcvidx = 0; return; } else { } (*(cs->dc.amd7930.setIrqMask))(cs, 1); return; } } static void Amd7930_fill_Dfifo(struct IsdnCardState *cs ) { unsigned int dtcrr ; unsigned int dtcrw ; unsigned int len ; unsigned int count ; unsigned char txstat ; unsigned char dmr3 ; unsigned char *ptr ; unsigned char *deb_ptr ; int tmp ; struct lock_class_key __key ; char *t ; int tmp___0 ; { if ((cs->debug & 4) != 0 && (cs->debug & 8) == 0) { debugl1(cs, (char *)"Amd7930: fill_Dfifo"); } else { } if ((unsigned long )cs->tx_skb == (unsigned long )((struct sk_buff *)0) || (cs->tx_skb)->len == 0U) { return; } else { } dtcrw = 0U; if (cs->dc.amd7930.tx_xmtlen == 0U) { dtcrw = (cs->tx_skb)->len; len = dtcrw; } else { len = cs->dc.amd7930.tx_xmtlen; } (*(cs->dc.amd7930.setIrqMask))(cs, 0); ptr = (cs->tx_skb)->data; deb_ptr = ptr; txstat = 16U; goto ldv_41060; ldv_41059: (*(cs->writeisac))(cs, 4, (int )*ptr); ptr = ptr + 1; cs->tx_cnt = cs->tx_cnt + 1; txstat = (*(cs->readisac))(cs, 7); ldv_41060: ; if (((int )txstat & 16) != 0 && (unsigned int )cs->tx_cnt < len) { goto ldv_41059; } else { } count = (unsigned int )((long )ptr) - (unsigned int )((long )(cs->tx_skb)->data); skb_pull(cs->tx_skb, count); dtcrr = ReadWordAmd7930(cs, 133); dmr3 = (*(cs->readisac))(cs, 142); if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"Amd7930: fill_Dfifo, DMR3: 0x%02X, DTCR read: 0x%04X write: 0x%02X 0x%02X", (int )dmr3, dtcrr, (int )((unsigned char )dtcrw), (int )((unsigned char )((dtcrw & 65280U) / 256U))); } else { } if (cs->dc.amd7930.tx_xmtlen == 0U) { WriteWordAmd7930(cs, 133, dtcrw); cs->dc.amd7930.tx_xmtlen = dtcrw; } else { } tmp = test_and_set_bit(6, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp != 0) { debugl1(cs, (char *)"Amd7930: fill_Dfifo dbusytimer running"); del_timer(& cs->dbusytimer); } else { } init_timer_key(& cs->dbusytimer, 0U, "(&cs->dbusytimer)", & __key); cs->dbusytimer.expires = (unsigned long )jiffies + 20UL; add_timer(& cs->dbusytimer); if ((cs->debug & 8) != 0) { t = cs->dlog; tmp___0 = sprintf(t, "Amd7930: fill_Dfifo cnt: %d |", count); t = t + (unsigned long )tmp___0; QuickHex(t, deb_ptr, (int )count); debugl1(cs, cs->dlog); } else { } (*(cs->dc.amd7930.setIrqMask))(cs, 1); return; } } void Amd7930_interrupt(struct IsdnCardState *cs , unsigned char irflags ) { unsigned char dsr1 ; unsigned char dsr2 ; unsigned char lsr ; unsigned int der ; int tmp ; int tmp___0 ; int tmp___1 ; int tmp___2 ; int tmp___3 ; int tmp___4 ; int tmp___5 ; int tmp___6 ; struct sk_buff *tmp___7 ; { goto ldv_41073; ldv_41072: dsr1 = (*(cs->readisac))(cs, 2); der = ReadWordAmd7930(cs, 3); dsr2 = (*(cs->readisac))(cs, 7); lsr = (*(cs->readisac))(cs, 161); if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"Amd7930: interrupt: flags: 0x%02X, DSR1: 0x%02X, DSR2: 0x%02X, LSR: 0x%02X, DER=0x%04X", (int )irflags, (int )dsr1, (int )dsr2, (int )lsr, der); } else { } if (der != 0U || ((int )dsr2 & 4) != 0) { if (cs->debug & 1) { debugl1(cs, (char *)"Amd7930: interrupt: D error DER=0x%04X", der); } else { } if ((der & 2U) != 0U) { (*(cs->writeisac))(cs, 33, 194); (*(cs->writeisac))(cs, 33, 2); tmp = test_and_clear_bit(6, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp != 0) { del_timer(& cs->dbusytimer); } else { } tmp___0 = test_and_clear_bit(5, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___0 != 0) { test_and_set_bit(3, (unsigned long volatile *)(& cs->event)); schedule_work(& cs->tqueue); } else { } if ((unsigned long )cs->tx_skb != (unsigned long )((struct sk_buff *)0)) { skb_push(cs->tx_skb, (unsigned int )cs->tx_cnt); cs->tx_cnt = 0; cs->dc.amd7930.tx_xmtlen = 0U; Amd7930_fill_Dfifo(cs); } else { printk("\fHiSax: Amd7930 D-Collision, no skb\n"); debugl1(cs, (char *)"Amd7930: interrupt: D-Collision, no skb"); } } else { } Amd7930_empty_Dfifo(cs, 1); tmp___1 = test_and_clear_bit(6, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___1 != 0) { del_timer(& cs->dbusytimer); } else { } tmp___2 = test_and_clear_bit(5, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___2 != 0) { test_and_set_bit(3, (unsigned long volatile *)(& cs->event)); schedule_work(& cs->tqueue); } else { } if ((unsigned long )cs->tx_skb != (unsigned long )((struct sk_buff *)0)) { skb_push(cs->tx_skb, (unsigned int )cs->tx_cnt); cs->tx_cnt = 0; cs->dc.amd7930.tx_xmtlen = 0U; Amd7930_fill_Dfifo(cs); } else { } } else { } if ((int )irflags & 1) { if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"Amd7930: interrupt: clear Timer and fill D-TX-FIFO if data"); } else { } (*(cs->dc.amd7930.setIrqMask))(cs, 0); tmp___3 = test_and_clear_bit(6, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___3 != 0) { del_timer(& cs->dbusytimer); } else { } tmp___4 = test_and_clear_bit(5, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___4 != 0) { test_and_set_bit(3, (unsigned long volatile *)(& cs->event)); schedule_work(& cs->tqueue); } else { } if ((unsigned long )cs->tx_skb != (unsigned long )((struct sk_buff *)0)) { if ((cs->tx_skb)->len != 0U) { Amd7930_fill_Dfifo(cs); } else { } } else { } (*(cs->dc.amd7930.setIrqMask))(cs, 1); } else { } if (((int )irflags & 2) != 0 || ((int )dsr1 & 2) != 0) { if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"Amd7930: interrupt: empty D-FIFO"); } else { } Amd7930_empty_Dfifo(cs, 0); } else { } if (((int )dsr1 & 64) != 0) { if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"Amd7930: interrupt: transmit packet ready"); } else { } (*(cs->dc.amd7930.setIrqMask))(cs, 0); tmp___5 = test_and_clear_bit(6, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___5 != 0) { del_timer(& cs->dbusytimer); } else { } tmp___6 = test_and_clear_bit(5, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___6 != 0) { test_and_set_bit(3, (unsigned long volatile *)(& cs->event)); schedule_work(& cs->tqueue); } else { } if ((unsigned long )cs->tx_skb != (unsigned long )((struct sk_buff *)0)) { if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"Amd7930: interrupt: TX-Packet ready, freeing skb"); } else { } dev_kfree_skb_irq(cs->tx_skb); cs->tx_cnt = 0; cs->dc.amd7930.tx_xmtlen = 0U; cs->tx_skb = 0; } else { } tmp___7 = skb_dequeue(& cs->sq); cs->tx_skb = tmp___7; if ((unsigned long )tmp___7 != (unsigned long )((struct sk_buff *)0)) { if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"Amd7930: interrupt: TX-Packet ready, next packet dequeued"); } else { } cs->tx_cnt = 0; cs->dc.amd7930.tx_xmtlen = 0U; Amd7930_fill_Dfifo(cs); } else { test_and_set_bit(1, (unsigned long volatile *)(& cs->event)); schedule_work(& cs->tqueue); } (*(cs->dc.amd7930.setIrqMask))(cs, 1); } else { } if (((int )lsr & 56) != 0) { (*(cs->dc.amd7930.setIrqMask))(cs, 0); if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"Amd: interrupt: LSR=0x%02X, LIU is in state %d", (int )lsr, ((int )lsr & 7) + 2); } else { } cs->dc.amd7930.ph_state = ((unsigned int )lsr & 7U) + 2U; test_and_set_bit(2, (unsigned long volatile *)(& cs->event)); schedule_work(& cs->tqueue); (*(cs->dc.amd7930.setIrqMask))(cs, 1); } else { } irflags = (*(cs->readisac))(cs, 0); ldv_41073: ; if ((unsigned int )irflags != 0U) { goto ldv_41072; } else { } return; } } static void Amd7930_l1hw(struct PStack *st , int pr , void *arg ) { struct IsdnCardState *cs ; struct sk_buff *skb ; u_long flags ; raw_spinlock_t *tmp ; raw_spinlock_t *tmp___0 ; raw_spinlock_t *tmp___1 ; int tmp___2 ; int tmp___3 ; { cs = (struct IsdnCardState *)st->l1.hardware; skb = (struct sk_buff *)arg; if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"Amd7930: l1hw called, pr: 0x%04X", pr); } else { } switch (pr) { case 288: ; if ((cs->debug & 1024) != 0) { LogFrame(cs, skb->data, (int )skb->len); } else { } if ((cs->debug & 2048) != 0) { dlogframe(cs, skb, 0); } else { } tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); if ((unsigned long )cs->tx_skb != (unsigned long )((struct sk_buff *)0)) { skb_queue_tail(& cs->sq, skb); if ((cs->debug & 64) != 0) { Logl2Frame(cs, skb, (char *)"Amd7930: l1hw: PH_DATA Queued", 0); } else { } } else { cs->tx_skb = skb; cs->tx_cnt = 0; cs->dc.amd7930.tx_xmtlen = 0U; if ((cs->debug & 64) != 0) { Logl2Frame(cs, skb, (char *)"Amd7930: l1hw: PH_DATA", 0); } else { } Amd7930_fill_Dfifo(cs); } spin_unlock_irqrestore(& cs->lock, flags); goto ldv_41087; case 306: tmp___0 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___0); if ((unsigned long )cs->tx_skb != (unsigned long )((struct sk_buff *)0)) { if (cs->debug & 1) { debugl1(cs, (char *)"Amd7930: l1hw: l2l1 tx_skb exist this shouldn\'t happen"); } else { } skb_queue_tail(& cs->sq, skb); spin_unlock_irqrestore(& cs->lock, flags); goto ldv_41087; } else { } if ((cs->debug & 1024) != 0) { LogFrame(cs, skb->data, (int )skb->len); } else { } if ((cs->debug & 2048) != 0) { dlogframe(cs, skb, 0); } else { } cs->tx_skb = skb; cs->tx_cnt = 0; cs->dc.amd7930.tx_xmtlen = 0U; if ((cs->debug & 64) != 0) { Logl2Frame(cs, skb, (char *)"Amd7930: l1hw: PH_DATA_PULLED", 0); } else { } Amd7930_fill_Dfifo(cs); spin_unlock_irqrestore(& cs->lock, flags); goto ldv_41087; case 304: ; if ((cs->debug & 64) != 0) { debugl1(cs, (char *)"Amd7930: l1hw: -> PH_REQUEST_PULL, skb: %s", (unsigned long )cs->tx_skb != (unsigned long )((struct sk_buff *)0) ? (char *)"yes" : (char *)"no"); } else { } if ((unsigned long )cs->tx_skb == (unsigned long )((struct sk_buff *)0)) { test_and_clear_bit(6, (unsigned long volatile *)(& st->l1.Flags)); (*(st->l1.l1l2))(st, 305, 0); } else { test_and_set_bit(6, (unsigned long volatile *)(& st->l1.Flags)); } goto ldv_41087; case 4: tmp___1 = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp___1); if ((unsigned int )cs->dc.amd7930.ph_state == 8U) { Amd7930_ph_command(cs, 32, (char *)"HW_RESET REQUEST"); spin_unlock_irqrestore(& cs->lock, flags); } else { Amd7930_ph_command(cs, 64, (char *)"HW_RESET REQUEST"); cs->dc.amd7930.ph_state = 2U; spin_unlock_irqrestore(& cs->lock, flags); Amd7930_new_ph(cs); } goto ldv_41087; case 0: cs->dc.amd7930.ph_state = 9U; Amd7930_new_ph(cs); goto ldv_41087; case 48: ; goto ldv_41087; case 112: ; goto ldv_41087; case 27: skb_queue_purge(& cs->rq); skb_queue_purge(& cs->sq); if ((unsigned long )cs->tx_skb != (unsigned long )((struct sk_buff *)0)) { consume_skb(cs->tx_skb); cs->tx_skb = 0; } else { } tmp___2 = test_and_clear_bit(6, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___2 != 0) { del_timer(& cs->dbusytimer); } else { } tmp___3 = test_and_clear_bit(5, (unsigned long volatile *)(& cs->HW_Flags)); if (tmp___3 != 0) { test_and_set_bit(3, (unsigned long volatile *)(& cs->event)); schedule_work(& cs->tqueue); } else { } goto ldv_41087; default: ; if (cs->debug & 1) { debugl1(cs, (char *)"Amd7930: l1hw: unknown %04x", pr); } else { } goto ldv_41087; } ldv_41087: ; return; } } static void setstack_Amd7930(struct PStack *st , struct IsdnCardState *cs ) { { if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"Amd7930: setstack called"); } else { } st->l1.l1hw = & Amd7930_l1hw; return; } } static void DC_Close_Amd7930(struct IsdnCardState *cs ) { { if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"Amd7930: DC_Close called"); } else { } return; } } static void dbusy_timer_handler___3(struct IsdnCardState *cs ) { u_long flags ; struct PStack *stptr ; unsigned int dtcr ; unsigned int der ; unsigned char dsr1 ; unsigned char dsr2 ; raw_spinlock_t *tmp ; int tmp___0 ; { if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"Amd7930: dbusy_timer expired!"); } else { } tmp___0 = constant_test_bit(6U, (unsigned long const volatile *)(& cs->HW_Flags)); if (tmp___0 != 0) { tmp = spinlock_check(& cs->lock); flags = _raw_spin_lock_irqsave(tmp); dtcr = ReadWordAmd7930(cs, 133); dsr1 = (*(cs->readisac))(cs, 2); dsr2 = (*(cs->readisac))(cs, 7); der = ReadWordAmd7930(cs, 3); if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"Amd7930: dbusy_timer_handler: DSR1=0x%02X, DSR2=0x%02X, DER=0x%04X, cs->tx_skb->len=%u, tx_stat=%u, dtcr=%u, cs->tx_cnt=%u", (int )dsr1, (int )dsr2, der, (cs->tx_skb)->len, cs->dc.amd7930.tx_xmtlen, dtcr, cs->tx_cnt); } else { } if (cs->dc.amd7930.tx_xmtlen - dtcr < (unsigned int )cs->tx_cnt) { test_and_set_bit(5, (unsigned long volatile *)(& cs->HW_Flags)); stptr = cs->stlist; spin_unlock_irqrestore(& cs->lock, flags); goto ldv_41122; ldv_41121: (*(stptr->l1.l1l2))(stptr, 338, 0); stptr = stptr->next; ldv_41122: ; if ((unsigned long )stptr != (unsigned long )((struct PStack *)0)) { goto ldv_41121; } else { } } else { test_and_clear_bit(6, (unsigned long volatile *)(& cs->HW_Flags)); if ((unsigned long )cs->tx_skb != (unsigned long )((struct sk_buff *)0)) { dev_kfree_skb_any(cs->tx_skb); cs->tx_cnt = 0; cs->tx_skb = 0; cs->dc.amd7930.tx_xmtlen = 0U; } else { printk("\fHiSax: Amd7930: D-Channel Busy no skb\n"); debugl1(cs, (char *)"Amd7930: D-Channel Busy no skb"); } (*(cs->writeisac))(cs, 33, 130); (*(cs->writeisac))(cs, 33, 2); spin_unlock_irqrestore(& cs->lock, flags); (*(cs->irq_func))((int )cs->irq, (void *)cs); if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"Amd7930: dbusy_timer_handler: Transmitter reset"); } else { } } } else { } return; } } void Amd7930_init(struct IsdnCardState *cs ) { unsigned int *ptr ; unsigned char cmd ; unsigned char cnt ; unsigned int *tmp ; unsigned int *tmp___0 ; unsigned int *tmp___1 ; unsigned int *tmp___2 ; unsigned int *tmp___3 ; { if ((cs->debug & 4) != 0) { debugl1(cs, (char *)"Amd7930: initamd called"); } else { } cs->dc.amd7930.tx_xmtlen = 0U; cs->dc.amd7930.old_state = 0U; cs->dc.amd7930.lmr1 = 64U; cs->dc.amd7930.ph_command = & Amd7930_ph_command; cs->setstack_d = & setstack_Amd7930; cs->DC_Close = & DC_Close_Amd7930; ptr = (unsigned int *)(& initAMD); goto ldv_41137; ldv_41136: cmd = (unsigned char )*ptr; tmp___3 = ptr; ptr = ptr + 1; if (*tmp___3 > 255U) { if ((unsigned int )cmd <= 7U) { (*(cs->readisac))(cs, (int )cmd); } else { (*(cs->writeisac))(cs, 0, (int )cmd); tmp = ptr; ptr = ptr + 1; cnt = (unsigned char )*tmp; goto ldv_41131; ldv_41130: (*(cs->readisac))(cs, 1); cnt = (unsigned char )((int )cnt - 1); ldv_41131: ; if ((unsigned int )cnt != 0U) { goto ldv_41130; } else { } } } else if ((unsigned int )cmd <= 7U) { tmp___0 = ptr; ptr = ptr + 1; (*(cs->writeisac))(cs, (int )cmd, (int )((unsigned char )*tmp___0)); } else { (*(cs->writeisac))(cs, 0, (int )cmd); tmp___1 = ptr; ptr = ptr + 1; cnt = (unsigned char )*tmp___1; goto ldv_41134; ldv_41133: tmp___2 = ptr; ptr = ptr + 1; (*(cs->writeisac))(cs, 1, (int )((unsigned char )*tmp___2)); cnt = (unsigned char )((int )cnt - 1); ldv_41134: ; if ((unsigned int )cnt != 0U) { goto ldv_41133; } else { } } ldv_41137: ; if (*ptr != 65535U) { goto ldv_41136; } else { } return; } } void setup_Amd7930(struct IsdnCardState *cs ) { struct lock_class_key __key ; atomic_long_t __constr_expr_0 ; struct lock_class_key __key___0 ; { __init_work(& cs->tqueue, 0); __constr_expr_0.counter = 4195328L; cs->tqueue.data = __constr_expr_0; lockdep_init_map(& cs->tqueue.lockdep_map, "(&cs->tqueue)", & __key, 0); INIT_LIST_HEAD(& cs->tqueue.entry); cs->tqueue.func = & Amd7930_bh; cs->dbusytimer.function = (void (*)(unsigned long ))(& dbusy_timer_handler___3); cs->dbusytimer.data = (unsigned long )cs; init_timer_key(& cs->dbusytimer, 0U, "(&cs->dbusytimer)", & __key___0); return; } } void ldv_mutex_lock_533(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_lock(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_534(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_lock(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_535(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } int ldv_mutex_trylock_536(struct mutex *ldv_func_arg1 ) { ldv_func_ret_type___2 ldv_func_res ; int tmp ; int tmp___0 ; { tmp = mutex_trylock(ldv_func_arg1); ldv_func_res = tmp; tmp___0 = ldv_mutex_trylock_mutex(ldv_func_arg1); return (tmp___0); return (ldv_func_res); } } void ldv_mutex_unlock_537(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } void ldv_mutex_lock_538(struct mutex *ldv_func_arg1 ) { { ldv_mutex_lock_cred_guard_mutex(ldv_func_arg1); mutex_lock(ldv_func_arg1); return; } } void ldv_mutex_unlock_539(struct mutex *ldv_func_arg1 ) { { ldv_mutex_unlock_cred_guard_mutex(ldv_func_arg1); mutex_unlock(ldv_func_arg1); return; } } __inline static void ldv_error(void) __attribute__((__no_instrument_function__)) ; __inline static void ldv_error(void) { { ERROR: {reach_error();abort();} } } extern int __VERIFIER_nondet_int(void) ; long ldv__builtin_expect(long exp , long c ) { { return (exp); } } static int ldv_mutex_cred_guard_mutex ; int ldv_mutex_lock_interruptible_cred_guard_mutex(struct mutex *lock ) { int nondetermined ; { if (ldv_mutex_cred_guard_mutex == 1) { } else { ldv_error(); } nondetermined = __VERIFIER_nondet_int(); if (nondetermined) { ldv_mutex_cred_guard_mutex = 2; return (0); } else { return (-4); } } } int ldv_mutex_lock_killable_cred_guard_mutex(struct mutex *lock ) { int nondetermined ; { if (ldv_mutex_cred_guard_mutex == 1) { } else { ldv_error(); } nondetermined = __VERIFIER_nondet_int(); if (nondetermined) { ldv_mutex_cred_guard_mutex = 2; return (0); } else { return (-4); } } } void ldv_mutex_lock_cred_guard_mutex(struct mutex *lock ) { { if (ldv_mutex_cred_guard_mutex == 1) { } else { ldv_error(); } ldv_mutex_cred_guard_mutex = 2; return; } } int ldv_mutex_trylock_cred_guard_mutex(struct mutex *lock ) { int is_mutex_held_by_another_thread ; { if (ldv_mutex_cred_guard_mutex == 1) { } else { ldv_error(); } is_mutex_held_by_another_thread = __VERIFIER_nondet_int(); if (is_mutex_held_by_another_thread) { return (0); } else { ldv_mutex_cred_guard_mutex = 2; return (1); } } } int ldv_atomic_dec_and_mutex_lock_cred_guard_mutex(atomic_t *cnt , struct mutex *lock ) { int atomic_value_after_dec ; { if (ldv_mutex_cred_guard_mutex == 1) { } else { ldv_error(); } atomic_value_after_dec = __VERIFIER_nondet_int(); if (atomic_value_after_dec == 0) { ldv_mutex_cred_guard_mutex = 2; return (1); } else { } return (0); } } int ldv_mutex_is_locked_cred_guard_mutex(struct mutex *lock ) { int nondetermined ; { if (ldv_mutex_cred_guard_mutex == 1) { nondetermined = __VERIFIER_nondet_int(); if (nondetermined) { return (0); } else { return (1); } } else { return (1); } } } void ldv_mutex_unlock_cred_guard_mutex(struct mutex *lock ) { { if (ldv_mutex_cred_guard_mutex == 2) { } else { ldv_error(); } ldv_mutex_cred_guard_mutex = 1; return; } } static int ldv_mutex_lock ; int ldv_mutex_lock_interruptible_lock(struct mutex *lock ) { int nondetermined ; { if (ldv_mutex_lock == 1) { } else { ldv_error(); } nondetermined = __VERIFIER_nondet_int(); if (nondetermined) { ldv_mutex_lock = 2; return (0); } else { return (-4); } } } int ldv_mutex_lock_killable_lock(struct mutex *lock ) { int nondetermined ; { if (ldv_mutex_lock == 1) { } else { ldv_error(); } nondetermined = __VERIFIER_nondet_int(); if (nondetermined) { ldv_mutex_lock = 2; return (0); } else { return (-4); } } } void ldv_mutex_lock_lock(struct mutex *lock ) { { if (ldv_mutex_lock == 1) { } else { ldv_error(); } ldv_mutex_lock = 2; return; } } int ldv_mutex_trylock_lock(struct mutex *lock ) { int is_mutex_held_by_another_thread ; { if (ldv_mutex_lock == 1) { } else { ldv_error(); } is_mutex_held_by_another_thread = __VERIFIER_nondet_int(); if (is_mutex_held_by_another_thread) { return (0); } else { ldv_mutex_lock = 2; return (1); } } } int ldv_atomic_dec_and_mutex_lock_lock(atomic_t *cnt , struct mutex *lock ) { int atomic_value_after_dec ; { if (ldv_mutex_lock == 1) { } else { ldv_error(); } atomic_value_after_dec = __VERIFIER_nondet_int(); if (atomic_value_after_dec == 0) { ldv_mutex_lock = 2; return (1); } else { } return (0); } } int ldv_mutex_is_locked_lock(struct mutex *lock ) { int nondetermined ; { if (ldv_mutex_lock == 1) { nondetermined = __VERIFIER_nondet_int(); if (nondetermined) { return (0); } else { return (1); } } else { return (1); } } } void ldv_mutex_unlock_lock(struct mutex *lock ) { { if (ldv_mutex_lock == 2) { } else { ldv_error(); } ldv_mutex_lock = 1; return; } } static int ldv_mutex_mutex ; int ldv_mutex_lock_interruptible_mutex(struct mutex *lock ) { int nondetermined ; { if (ldv_mutex_mutex == 1) { } else { ldv_error(); } nondetermined = __VERIFIER_nondet_int(); if (nondetermined) { ldv_mutex_mutex = 2; return (0); } else { return (-4); } } } int ldv_mutex_lock_killable_mutex(struct mutex *lock ) { int nondetermined ; { if (ldv_mutex_mutex == 1) { } else { ldv_error(); } nondetermined = __VERIFIER_nondet_int(); if (nondetermined) { ldv_mutex_mutex = 2; return (0); } else { return (-4); } } } void ldv_mutex_lock_mutex(struct mutex *lock ) { { if (ldv_mutex_mutex == 1) { } else { ldv_error(); } ldv_mutex_mutex = 2; return; } } int ldv_mutex_trylock_mutex(struct mutex *lock ) { int is_mutex_held_by_another_thread ; { if (ldv_mutex_mutex == 1) { } else { ldv_error(); } is_mutex_held_by_another_thread = __VERIFIER_nondet_int(); if (is_mutex_held_by_another_thread) { return (0); } else { ldv_mutex_mutex = 2; return (1); } } } int ldv_atomic_dec_and_mutex_lock_mutex(atomic_t *cnt , struct mutex *lock ) { int atomic_value_after_dec ; { if (ldv_mutex_mutex == 1) { } else { ldv_error(); } atomic_value_after_dec = __VERIFIER_nondet_int(); if (atomic_value_after_dec == 0) { ldv_mutex_mutex = 2; return (1); } else { } return (0); } } int ldv_mutex_is_locked_mutex(struct mutex *lock ) { int nondetermined ; { if (ldv_mutex_mutex == 1) { nondetermined = __VERIFIER_nondet_int(); if (nondetermined) { return (0); } else { return (1); } } else { return (1); } } } void ldv_mutex_unlock_mutex(struct mutex *lock ) { { if (ldv_mutex_mutex == 2) { } else { ldv_error(); } ldv_mutex_mutex = 1; return; } } void ldv_initialize(void) { { ldv_mutex_cred_guard_mutex = 1; ldv_mutex_lock = 1; ldv_mutex_mutex = 1; return; } } void ldv_check_final_state(void) { { if (ldv_mutex_cred_guard_mutex == 1) { } else { ldv_error(); } if (ldv_mutex_lock == 1) { } else { ldv_error(); } if (ldv_mutex_mutex == 1) { } else { ldv_error(); } return; } } #include "model/32_7a_cilled_true-unreach-call_linux-3.8-rc1-32_7a-drivers--isdn--hisax--hisax.ko-ldv_main0_sequence_infinite_withcheck_stateful.env.c" #include "model/common.env.c"