开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
chandev.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：88k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

chandev.c：源码内容
  1. /*
  2.  *  drivers/s390/misc/chandev.c
  3.  *
  4.  *    Copyright (C) 2000 IBM Deutschland Entwicklung GmbH, IBM Corporation
  5.  *    Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
  6.  * 
  7.  *  Generic channel device initialisation support. 
  8.  */
  9. #define TRUE 1
  10. #define FALSE 0
  11. #define __KERNEL_SYSCALLS__
  12. #include <linux/module.h>
  13. #include <linux/config.h>
  14. #include <linux/types.h>
  15. #include <linux/ctype.h>
  16. #include <asm/uaccess.h>
  17. #include <linux/slab.h>
  18. #include <asm/irq.h>
  19. #include <linux/init.h>
  20. #include <linux/unistd.h>
  21. #include <asm/chandev.h>
  22. #include <linux/proc_fs.h>
  23. #include <linux/vmalloc.h>
  24. #include <asm/s390dyn.h>
  25. #include <asm/queue.h>
  26. #include <linux/kmod.h>
  27. #ifndef MIN
  28. #define MIN(a,b) ((a<b)?a:b)
  29. #endif
  30. #ifndef MAX
  31. #define MAX(a,b) ((a>b)?a:b)
  32. #endif
  36. typedef struct chandev_model_info chandev_model_info;
  37. struct chandev_model_info
  38. {
  39. struct chandev_model_info *next;
  40. chandev_type chan_type;
  41. s32 cu_type;      /* control unit type  -1 = don't care */
  42. s16 cu_model;     /* control unit model -1 = don't care */
  43. s32 dev_type;     /* device type -1 = don't care */
  44. s16 dev_model;    /* device model -1 = don't care */
  45. u8  max_port_no;
  46. int auto_msck_recovery;
  47. u8  default_checksum_received_ip_pkts;
  48. u8  default_use_hw_stats; /* where available e.g. lcs */
  49. devreg_t drinfo;
  50. };
  52. typedef struct chandev chandev;
  53. struct chandev
  54. {
  55. struct chandev *next;
  56. chandev_model_info *model_info;
  57. chandev_subchannel_info sch;
  58. int owned;
  59. };
  61. typedef struct chandev_noauto_range chandev_noauto_range;
  62. struct chandev_noauto_range
  63. {
  64. struct chandev_noauto_range *next;
  65. u16     lo_devno;
  66. u16     hi_devno;
  67. };
  69. typedef struct chandev_force chandev_force;
  70. struct chandev_force
  71. {
  72. struct chandev_force *next;
  73. chandev_type chan_type;
  74. s32     devif_num; /* -1 don't care, -2 we are forcing a range e.g. tr0 implies 0 */
  75.         u16     read_lo_devno;
  76. u16     write_hi_devno;
  77. u16     data_devno; /* only used by gigabit ethernet */
  78. s32     memory_usage_in_k;
  79.         s16     port_protocol_no; /* where available e.g. lcs,-1 don't care */
  80. u8      checksum_received_ip_pkts;
  81. u8      use_hw_stats; /* where available e.g. lcs */
  82. /* claw specific stuff */
  83. chandev_claw_info  claw;
  84. };
  86. typedef struct chandev_probelist chandev_probelist;
  87. struct chandev_probelist
  88. {
  89. struct chandev_probelist            *next;
  90. chandev_probefunc                   probefunc;
  91. chandev_shutdownfunc                shutdownfunc;
  92. chandev_msck_notification_func      msck_notfunc;
  93. chandev_type                        chan_type;
  94. int                                 devices_found;
  95. };
  99. #define default_msck_bits ((1<<(chandev_status_not_oper-1))|(1<<(chandev_status_no_path-1))|(1<<(chandev_status_revalidate-1))|(1<<(chandev_status_gone-1)))
  102. static char *msck_status_strs[]=
  103. {
  104. "good",
  105. "not_operational",
  106. "no_path",
  107. "revalidate",
  108. "device_gone"
  109. };
  111. typedef struct chandev_msck_range chandev_msck_range;
  112. struct chandev_msck_range
  113. {
  114. struct chandev_msck_range *next;
  115. u16     lo_devno;
  116. u16     hi_devno;
  117. int      auto_msck_recovery;
  118. };
  120. static chandev_msck_range *chandev_msck_range_head=NULL;
  122. typedef struct chandev_irqinfo chandev_irqinfo;
  123. struct chandev_irqinfo
  124. {
  125. chandev_irqinfo         *next;
  126. chandev_subchannel_info sch;
  127. chandev_msck_status     msck_status;
  128. void                    (*handler)(int, void *, struct pt_regs *);
  129. unsigned long           irqflags;
  130. void                    *dev_id;
  131. char                    devname[0];
  132. };
  135. chandev_irqinfo *chandev_irqinfo_head=NULL;
  137. typedef struct chandev_parms chandev_parms;
  138. struct chandev_parms
  139. {
  140. chandev_parms      *next;
  141. chandev_type       chan_type;
  142. u16                lo_devno;
  143. u16                hi_devno;
  144. char               parmstr[0];
  145. };
  147. static chandev_type chandev_persistent=0; 
  149. chandev_parms *chandev_parms_head=NULL;
  152. typedef struct chandev_activelist chandev_activelist;
  153. struct chandev_activelist
  154. {
  155. struct chandev_activelist        *next;
  156. chandev_irqinfo                  *read_irqinfo;
  157. chandev_irqinfo                  *write_irqinfo;
  158. chandev_irqinfo                  *data_irqinfo;
  159. chandev_probefunc                probefunc;
  160. chandev_shutdownfunc             shutdownfunc;
  161. chandev_msck_notification_func   msck_notfunc;
  162. chandev_unregfunc                unreg_dev;
  163. chandev_type                     chan_type;
  164. u8                               port_no;
  165. chandev_category                 category;
  166. s32                              memory_usage_in_k;
  167. void                             *dev_ptr;
  168. char                             devname[0];
  169. };
  173. static chandev_model_info *chandev_models_head=NULL;
  174. /* The only reason chandev_head is a queue is so that net devices */
  175. /* will be by default named in the order of their irqs */
  176. static qheader chandev_head={NULL,NULL};
  177. static chandev_noauto_range *chandev_noauto_head=NULL;
  178. static chandev_force *chandev_force_head=NULL;
  179. static chandev_probelist *chandev_probelist_head=NULL;
  180. static chandev_activelist *chandev_activelist_head=NULL;
  181. #if LINUX_VERSION_CODE>=KERNEL_VERSION(2,3,0)
  182. int chandev_use_devno_names=FALSE;
  183. #endif
  184. static int chandev_cautious_auto_detect=TRUE;
  185. static atomic_t chandev_conf_read=ATOMIC_INIT(FALSE);
  186. static atomic_t chandev_initialised=ATOMIC_INIT(FALSE);
  189. static unsigned long chandev_last_machine_check;
  192. static struct tq_struct chandev_msck_task_tq;
  193. static atomic_t chandev_msck_thread_lock;
  194. static atomic_t chandev_new_msck;
  195. static unsigned long chandev_last_startmsck_list_update;
  198. typedef enum
  199. {
  200. chandev_start,
  201. chandev_first_tag=chandev_start,
  202. chandev_msck,
  203. chandev_num_notify_tags
  204. } chandev_userland_notify_tag;
  206. static char *userland_notify_strs[]=
  207. {
  208. "start",
  209. "machine_check"
  210. };
  212. typedef struct chandev_userland_notify_list chandev_userland_notify_list;
  213. struct chandev_userland_notify_list
  214. {
  215. chandev_userland_notify_list    *next;
  216. chandev_userland_notify_tag      tag;
  217. chandev_msck_status              prev_status;
  218. chandev_msck_status              curr_status;
  219. char                      devname[0];
  220. };
  223. static chandev_userland_notify_list *chandev_userland_notify_head=NULL;
  228. static void chandev_read_conf_if_necessary(void);
  229. static void chandev_read_conf(void);
  231. #if LINUX_VERSION_CODE >=KERNEL_VERSION(2,3,0)
  232. typedef struct net_device  net_device;
  233. #else
  234. typedef struct device  net_device;
  236. static inline void init_waitqueue_head(wait_queue_head_t *q)
  237. {
  238. *q=NULL;
  239. }
  240. #endif
  242. #if LINUX_VERSION_CODE<KERNEL_VERSION(2,3,45)
  243. static __inline__ void netif_stop_queue(net_device *dev)
  244. {
  245. dev->tbusy=1;
  246. }
  248. static __inline__ void netif_start_queue(net_device *dev)
  249. {
  250. dev->tbusy=0;
  251. }
  252. #endif
  256. #define CHANDEV_INVALID_LOCK_OWNER            -1
  257. static long                 chandev_lock_owner;
  258. static int                  chandev_lock_cnt; 
  259. static spinlock_t           chandev_spinlock;
  260. #define CHANDEV_LOCK_DEBUG 0
  261. #if CHANDEV_LOCK_DEBUG && !defined(CONFIG_ARCH_S390X)
  262. #define CHANDEV_BACKTRACE_LOOPCNT 10
  263. void                        *chandev_first_lock_addr[CHANDEV_BACKTRACE_LOOPCNT],
  264.                     *chandev_last_lock_addr[CHANDEV_BACKTRACE_LOOPCNT],
  265.                     *chandev_last_unlock_addr[CHANDEV_BACKTRACE_LOOPCNT];
  266. #define CHANDEV_BACKTRACE(variable) 
  267. memset((variable),0,sizeof(void *)*CHANDEV_BACKTRACE_LOOPCNT); 
  268. (variable)[0]=__builtin_return_address(0); 
  269. if(((long)variable[0])&0x80000000)         
  270. {                                          
  271. (variable)[1]=__builtin_return_address(1); 
  272. if(((long)variable[1])&0x80000000)         
  273. {                                          
  274. (variable)[2]=__builtin_return_address(2); 
  275. if(((long)variable[2])&0x80000000)         
  276. {                                          
  277. (variable)[3]=__builtin_return_address(3); 
  278. if(((long)variable[3])&0x80000000)         
  279. {                                          
  280. (variable)[4]=__builtin_return_address(4); 
  281. if(((long)variable[4])&0x80000000)         
  282. {                                          
  283. (variable)[5]=__builtin_return_address(5); 
  284. if(((long)variable[5])&0x80000000)         
  285. {                                          
  286. (variable)[6]=__builtin_return_address(6); 
  287. if(((long)variable[6])&0x80000000)         
  288. {                                          
  289. (variable)[7]=__builtin_return_address(7); 
  290. if(((long)variable[7])&0x80000000)         
  291. {                                          
  292. (variable)[8]=__builtin_return_address(8); 
  293. if(((long)variable[8])&0x80000000)         
  294. {                                          
  295. (variable)[9]=__builtin_return_address(9); 
  296. } 
  297. } 
  298. } 
  299. } 
  300. } 
  301. } 
  302. } 
  303. } 
  304. }
  305. #else
  306. #define CHANDEV_BACKTRACE(variable)
  307. #endif
  311. typedef struct chandev_not_oper_struct chandev_not_oper_struct;
  313. struct  chandev_not_oper_struct
  314. {
  315. chandev_not_oper_struct *next;
  316. int irq;
  317. int status;
  318. };
  321. /* May as well try to keep machine checks in the order they happen so
  322.  * we use qheader for chandev_not_oper_head instead of list.
  323.  */
  324. static qheader chandev_not_oper_head={NULL,NULL};
  325. static spinlock_t           chandev_not_oper_spinlock;
  327. #define chandev_interrupt_check() 
  328. if(in_interrupt())                
  329.      printk(KERN_WARNING __FUNCTION__ " called under interrupt this shouldn't happenn")
  332. #define for_each(variable,head) 
  333. for((variable)=(head);(variable)!=NULL;(variable)=(variable)->next)
  335. #define for_each_allow_delete(variable,nextmember,head) 
  336. for((variable)=(head),(nextmember)=((head) ? (head)->next:NULL); 
  337. (variable)!=NULL; (variable)=(nextmember),(nextmember)=((nextmember) ? (nextmember->next) : NULL))
  339. #define for_each_allow_delete2(variable,nextmember,head) 
  340. for((variable)=(head);(variable)!=NULL;(variable)=(nextmember))
  343. static void chandev_lock(void)
  344. {
  345. eieio();
  346. chandev_interrupt_check();
  347. if(chandev_lock_owner!=(long)current)
  348. {
  349. while(!spin_trylock(&chandev_spinlock))
  350. schedule();
  351. chandev_lock_cnt=1;
  352. chandev_lock_owner=(long)current;
  353. CHANDEV_BACKTRACE(chandev_first_lock_addr)
  354. }
  355. else
  356. {
  357. chandev_lock_cnt++;
  358. CHANDEV_BACKTRACE(chandev_last_lock_addr)
  359. }
  360. if(chandev_lock_cnt<0||chandev_lock_cnt>100)
  361. {
  362. printk("odd lock_cnt %d lcs_chan_lock",chandev_lock_cnt);
  363. chandev_lock_cnt=1;
  364. }
  365. }
  367. static int chandev_full_unlock(void)
  368. {
  369. int ret_lock_cnt=chandev_lock_cnt;
  370. chandev_lock_cnt=0;
  371. chandev_lock_owner=CHANDEV_INVALID_LOCK_OWNER;
  372. spin_unlock(&chandev_spinlock);
  373. return(ret_lock_cnt);
  374. }
  376. static void chandev_unlock(void)
  377. {
  378. if(chandev_lock_owner!=(long)current)
  379. printk("chandev_unlock: current=%lx"
  380.       " chandev_lock_owner=%lx chandev_lock_cnt=%dn",
  381.       (long)current,
  382.       chandev_lock_owner,
  383.       chandev_lock_cnt);
  384. CHANDEV_BACKTRACE(chandev_last_unlock_addr)
  385. if(--chandev_lock_cnt==0)
  386. {
  387. chandev_lock_owner=CHANDEV_INVALID_LOCK_OWNER;
  388. spin_unlock(&chandev_spinlock);
  389. }
  390. if(chandev_lock_cnt<0)
  391. {
  392. printk("odd lock_cnt=%d in chan_unlock",chandev_lock_cnt);
  393. chandev_full_unlock();
  394. }
  396. }
  400. void *chandev_alloc(size_t size)
  401. {
  402. void *mem=kmalloc(size,GFP_ATOMIC);
  403. if(mem)
  404. memset(mem,0,size);
  405. return(mem);
  406. }
  408. static void chandev_add_to_list(list **listhead,void *member)
  409. {
  410. chandev_lock();
  411. add_to_list(listhead,member);
  412. chandev_unlock();
  413. }
  415. static void chandev_queuemember(qheader *qhead,void *member)
  416. {
  417. chandev_lock();
  418. enqueue_tail(qhead,(queue *)member);
  419. chandev_unlock();
  420. }
  422. static int chandev_remove_from_list(list **listhead,list *member)
  423. {
  424. int retval;
  426. chandev_lock();
  427. retval=remove_from_list(listhead,member);
  428. chandev_unlock();
  429. return(retval);
  430. }
  432. static int chandev_remove_from_queue(qheader *qhead,queue *member)
  433. {
  434. int retval;
  436. chandev_lock();
  437. retval=remove_from_queue(qhead,member);
  438. chandev_unlock();
  439. return(retval);
  440. }
  444. void chandev_free_listmember(list **listhead,list *member)
  445. {
  446. chandev_lock();
  447. if(member)
  448. {
  449. if(chandev_remove_from_list(listhead,member))
  450. kfree(member);
  451. else
  452. printk(KERN_CRIT"chandev_free_listmember detected nonexistant"
  453.        "listmember listhead=%p member %pn",listhead,member);
  454. }
  455. chandev_unlock();
  456. }
  458. void chandev_free_queuemember(qheader *qhead,queue *member)
  459. {
  460. chandev_lock();
  461. if(member)
  462. {
  463. if(chandev_remove_from_queue(qhead,member))
  464. kfree(member);
  465. else
  466. printk(KERN_CRIT"chandev_free_queuemember detected nonexistant"
  467.        "queuemember qhead=%p member %pn",qhead,member);
  468. }
  469. chandev_unlock();
  470. }
  474. void chandev_free_all_list(list **listhead)
  475. {
  476. list *head;
  478. chandev_lock();
  479. while((head=remove_listhead(listhead)))
  480. kfree(head);
  481. chandev_unlock();
  482. }
  484. void chandev_free_all_queue(qheader *qhead)
  485. {
  486. chandev_lock();
  487. while(qhead->head)
  488. chandev_free_queuemember(qhead,qhead->head);
  489. chandev_unlock();
  490. }
  492. static void chandev_wait_for_root_fs(void)
  493. {
  494. wait_queue_head_t      wait;
  496. init_waitqueue_head(&wait);
  497. /* We need to wait till there is a root filesystem */
  498. while(init_task.fs->root==NULL)
  499. {
  500. sleep_on_timeout(&wait,HZ);
  501. }
  502. }
  504. /* We are now hotplug compliant i.e. */
  505. /* we typically get called in /sbin/hotplug chandev our parameters */
  506. static int chandev_exec_start_script(void *unused)
  507. {
  509. char **argv,*tempname;
  510. int retval=-ENOMEM;
  511. int argc,loopcnt;
  512. size_t allocsize;
  513. chandev_userland_notify_list *member;
  514. wait_queue_head_t      wait;
  515. int                    have_tag[chandev_num_notify_tags]={FALSE,};
  516. chandev_userland_notify_tag tagidx;
  517. static char * envp[] = { "HOME=/", "TERM=linux", "PATH=/sbin:/usr/sbin:/bin:/usr/bin", NULL };
  519. init_waitqueue_head(&wait);
  520. strcpy(current->comm,"chandev_script");
  522. for(loopcnt=0;loopcnt<10&&(jiffies-chandev_last_startmsck_list_update)<HZ;loopcnt++)
  523. {
  524. sleep_on_timeout(&wait,HZ);
  525. }
  526. if(!chandev_userland_notify_head)
  527. return(0);
  528. chandev_lock();
  529. argc=2;
  530. for(tagidx=chandev_first_tag;tagidx<chandev_num_notify_tags;tagidx++)
  531. {
  532. for_each(member,chandev_userland_notify_head)
  533. {
  534. if(member->tag==tagidx)
  535. {
  536. switch(tagidx)
  537. {
  538. case chandev_start:
  539. argc++;
  540. break;
  541. case chandev_msck:
  542. argc+=3;
  543. break;
  544. default:
  545. }
  546. if(have_tag[tagidx]==FALSE)
  547. argc++;
  548. have_tag[tagidx]=TRUE;
  550. }
  551. }
  552. }
  553. allocsize=(argc+1)*sizeof(char *);
  554.         /* Warning possible stack overflow */
  555. /* We can't kmalloc the parameters here as execve will */
  556. /* not return if successful */
  557. argv=alloca(allocsize);
  558. if(argv)
  559. {
  560. memset(argv,0,allocsize);
  561. argv[0]=hotplug_path;
  562. argv[1]="chandev";
  563. argc=2;
  564. for(tagidx=chandev_first_tag;tagidx<chandev_num_notify_tags;tagidx++)
  565. {
  566. if(have_tag[tagidx])
  567. {
  568. argv[argc++]=userland_notify_strs[tagidx];
  569. for_each(member,chandev_userland_notify_head)
  570. {
  571. if(member->tag==tagidx)
  572. {
  573. tempname=alloca(strlen(member->devname)+1);
  574. if(tempname)
  575. {
  576. strcpy(tempname,member->devname);
  577. argv[argc++]=tempname;
  578. }
  579. else
  580. goto Fail;
  581. if(member->tag==chandev_msck)
  582. {
  583. argv[argc++]=msck_status_strs[member->prev_status];
  584. argv[argc++]=msck_status_strs[member->curr_status];
  585. }
  586. }
  587. }
  588. }
  589. }
  590. chandev_free_all_list((list **)&chandev_userland_notify_head);
  591. chandev_unlock();
  592. chandev_wait_for_root_fs();
  593. /* We are basically execve'ing here there normally is no */
  594. /* return */
  595. retval=exec_usermodehelper(hotplug_path, argv, envp);
  596. goto Fail2;
  597. }
  598.  Fail:
  600. chandev_unlock();
  601.  Fail2:
  602. return(retval);
  603. }
  606. void *chandev_allocstr(const char *str,size_t offset)
  607. {
  608. char *member;
  610. if((member=chandev_alloc(offset+strlen(str)+1)))
  611. {
  612. strcpy(&member[offset],str);
  613. }
  614. return((void *)member);
  615. }
  618. static int chandev_add_to_userland_notify_list(chandev_userland_notify_tag tag,
  619. char *devname, chandev_msck_status prev_status,chandev_msck_status curr_status)
  620. {
  621. chandev_userland_notify_list *member,*nextmember;
  622. int pid;
  624. chandev_lock();
  625. /* remove operations still outstanding for this device */
  626. for_each_allow_delete(member,nextmember,chandev_userland_notify_head)
  627. if(strcmp(member->devname,devname)==0)
  628. chandev_free_listmember((list **)&chandev_userland_notify_head,(list *)member);
  631. if((member=chandev_allocstr(devname,offsetof(chandev_userland_notify_list,devname))))
  632. {
  633. member->tag=tag;
  634. member->prev_status=prev_status;
  635. member->curr_status=curr_status;
  636. add_to_list((list **)&chandev_userland_notify_head,(list *)member);
  637. chandev_last_startmsck_list_update=jiffies;
  638. chandev_unlock();
  639. pid = kernel_thread(chandev_exec_start_script,NULL,SIGCHLD);
  640. if(pid<0)
  641. {
  642. printk("error making kernel thread for chandev_exec_start_scriptn");
  643. return(pid);
  644. }
  645. else
  646. return(0);
  648. }
  649. else
  650. {
  651. chandev_unlock();
  652. printk("chandev_add_to_startmscklist memory allocation failed devname=%sn",devname);
  653. return(-ENOMEM);
  654. }
  655. }
  661. int chandev_oper_func(int irq,devreg_t *dreg)
  662. {
  663. chandev_last_machine_check=jiffies;
  664. if(atomic_dec_and_test(&chandev_msck_thread_lock))
  665. {
  666. schedule_task(&chandev_msck_task_tq);
  667. }
  668. atomic_set(&chandev_new_msck,TRUE);
  669. return(0);
  670. }
  672. static void chandev_not_oper_handler(int irq,int status )
  673. {
  674. chandev_not_oper_struct *new_not_oper;
  676. chandev_last_machine_check=jiffies;
  677. if((new_not_oper=kmalloc(sizeof(chandev_not_oper_struct),GFP_ATOMIC)))
  678. {
  679. new_not_oper->irq=irq;
  680. new_not_oper->status=status;
  681. spin_lock(&chandev_not_oper_spinlock);
  682. enqueue_tail(&chandev_not_oper_head,(queue *)new_not_oper);
  683. spin_unlock(&chandev_not_oper_spinlock);
  684. if(atomic_dec_and_test(&chandev_msck_thread_lock))
  685. {
  686. schedule_task(&chandev_msck_task_tq);
  687. }
  688. }
  689. else
  690. printk("chandev_not_oper_handler failed to allocate memory & "
  691.        "lost a not operational interrupt %d %x",
  692.        irq,status);
  693. }
  695. chandev_irqinfo *chandev_get_irqinfo_by_irq(int irq)
  696. {
  697. chandev_irqinfo *curr_irqinfo;
  698. for_each(curr_irqinfo,chandev_irqinfo_head)
  699. if(irq==curr_irqinfo->sch.irq)
  700. return(curr_irqinfo);
  701. return(NULL);
  702. }
  704. chandev *chandev_get_by_irq(int irq)
  705. {
  706. chandev *curr_chandev;
  708. for_each(curr_chandev,(chandev *)chandev_head.head)
  709. if(curr_chandev->sch.irq==irq)
  710. {
  711. return(curr_chandev);
  712. }
  713. return(NULL);
  714. }
  716. chandev_activelist *chandev_get_activelist_by_irq(int irq)
  717. {
  718. chandev_activelist *curr_device;
  720. for_each(curr_device,chandev_activelist_head)
  721. {
  722. if(curr_device->read_irqinfo->sch.irq==irq||
  723.    curr_device->write_irqinfo->sch.irq==irq||
  724.    (curr_device->data_irqinfo&&curr_device->data_irqinfo->sch.irq==irq))
  725. return(curr_device);
  726. }
  727. return(NULL);
  728. }
  731. void chandev_remove_irqinfo_by_irq(unsigned int irq)
  732. {
  733. chandev_irqinfo *remove_irqinfo;
  734. chandev_activelist *curr_device;
  736. chandev_lock();
  737. /* remove any orphan irqinfo left lying around. */
  738.         if((remove_irqinfo=chandev_get_irqinfo_by_irq(irq)))
  739. {
  740. for_each(curr_device,chandev_activelist_head)
  741. {
  742. if(curr_device->read_irqinfo==remove_irqinfo)
  743. {
  744. curr_device->read_irqinfo=NULL;
  745. break;
  746. }
  747. if(curr_device->write_irqinfo==remove_irqinfo)
  748. {
  749. curr_device->write_irqinfo=NULL;
  750. break;
  751. }
  752. if(curr_device->data_irqinfo&&curr_device->data_irqinfo==remove_irqinfo)
  753. {
  754. curr_device->data_irqinfo=NULL;
  755. break;
  756. }
  757. }
  758. chandev_free_listmember((list **)&chandev_irqinfo_head,
  759.  (list *)remove_irqinfo);
  760. }
  761. chandev_unlock();
  763. }
  765. int chandev_add_schib_info(int irq,chandev_subchannel_info *sch)
  766. {
  767. schib_t *new_schib;
  769. if((new_schib=s390_get_schib(irq)))
  770. {
  771. sch->pim=new_schib->pmcw.pim;
  772. memcpy(&sch->chpid,&new_schib->pmcw.chpid,sizeof(sch->chpid));
  773. return(0);
  774. }
  775. return(-ENODEV);
  776. }
  778. int chandev_request_irq(unsigned int   irq,
  779.                       void           (*handler)(int, void *, struct pt_regs *),
  780.                       unsigned long  irqflags,
  781.                       const char    *devname,
  782.                       void          *dev_id)
  783. {
  784. chandev_irqinfo *new_irqinfo;
  785. chandev_activelist *curr_device;
  786. s390_dev_info_t         devinfo;
  787. int          retval;
  790. chandev_lock();
  791. if((curr_device=chandev_get_activelist_by_irq(irq)))
  792. {
  793. printk("chandev_request_irq failed devname=%s irq=%d "
  794.        "it already belongs to %s shutdown this device first.n",
  795.        devname,irq,curr_device->devname);
  796. chandev_unlock();
  797. return(-EPERM);
  798. }
  799. /* remove any orphan irqinfo left lying around. */
  800. chandev_remove_irqinfo_by_irq(irq);
  801. chandev_unlock();
  802. if((new_irqinfo=chandev_allocstr(devname,offsetof(chandev_irqinfo,devname))))
  803. {
  805. if((retval=get_dev_info_by_irq(irq,&devinfo))||
  806.    (retval=s390_request_irq_special(irq,handler,
  807. chandev_not_oper_handler,
  808. irqflags,devname,dev_id)))
  809. kfree(new_irqinfo);
  810. else
  811. {
  812. new_irqinfo->msck_status=chandev_status_good;
  813. new_irqinfo->sch.devno=devinfo.devno;
  814. new_irqinfo->sch.irq=irq;
  815. new_irqinfo->sch.cu_type=devinfo.sid_data.cu_type; /* control unit type */
  816. new_irqinfo->sch.cu_model=devinfo.sid_data.cu_model; /* control unit model */
  817. new_irqinfo->sch.dev_type=devinfo.sid_data.dev_type; /* device type */
  818. new_irqinfo->sch.dev_model=devinfo.sid_data.dev_model; /* device model */
  819. chandev_add_schib_info(irq,&new_irqinfo->sch);
  820. new_irqinfo->handler=handler;
  821. new_irqinfo->dev_id=dev_id;
  822. chandev_add_to_list((list **)&chandev_irqinfo_head,new_irqinfo);
  823. }
  824. }
  825. else
  826. {
  827. printk("chandev_request_irq memory allocation failed devname=%s irq=%dn",devname,irq);
  828. retval=-ENOMEM;
  829. }
  830. return(retval);
  831. }
  833. /* This should be safe to call even multiple times. */
  834. void chandev_free_irq(unsigned int irq, void *dev_id)
  835. {
  836. s390_dev_info_t devinfo;
  837. int err;
  839. /* remove any orphan irqinfo left lying around. */
  840. chandev_remove_irqinfo_by_irq(irq);
  841. if((err=get_dev_info_by_irq(irq,&devinfo)))
  842. {
  843. printk("chandev_free_irq get_dev_info_by_irq reported err=%X on irq %dn"
  844.        "should not happenn",err,irq);
  845. return;
  846.  }
  847. if(devinfo.status&DEVSTAT_DEVICE_OWNED)
  848.    free_irq(irq,dev_id);
  849. }
  851. /* This should be safe even if chandev_free_irq is already called by the device */
  852. void chandev_free_irq_by_irqinfo(chandev_irqinfo *irqinfo)
  853. {
  854. if(irqinfo)
  855. chandev_free_irq(irqinfo->sch.irq,irqinfo->dev_id);
  856. }
  860. void chandev_sprint_type_model(char *buff,s32 type,s16 model)
  861. {
  862. if(type==-1)
  863. strcpy(buff,"    *    ");
  864. else
  865. sprintf(buff," 0x%04x  ",(int)type);
  866. buff+=strlen(buff);
  867. if(model==-1)
  868. strcpy(buff,"    *   ");
  869. else
  870. sprintf(buff," 0x%02x  ",(int)model);
  871. }
  873. void chandev_sprint_devinfo(char *buff,s32 cu_type,s16 cu_model,s32 dev_type,s16 dev_model)
  874. {
  875. chandev_sprint_type_model(buff,cu_type,cu_model);
  876. chandev_sprint_type_model(&buff[strlen(buff)],dev_type,dev_model);
  877. }
  879. void chandev_remove_parms(chandev_type chan_type,int exact_match,int lo_devno)
  880. {
  881. chandev_parms      *curr_parms,*next_parms;
  883. chandev_lock();
  884. for_each_allow_delete(curr_parms,next_parms,chandev_parms_head)
  885. {
  886. if(((chan_type&(curr_parms->chan_type)&&!exact_match)||
  887.    (chan_type==(curr_parms->chan_type)&&exact_match))&&
  888.    (lo_devno==-1||lo_devno==curr_parms->lo_devno))
  889. chandev_free_listmember((list **)&chandev_parms_head,(list *)curr_parms);
  890. }
  891. chandev_unlock();
  892. }
  895. void chandev_add_parms(chandev_type chan_type,u16 lo_devno,u16 hi_devno,char *parmstr)
  896. {
  897. chandev_parms      *parms;
  899. if(lo_devno>hi_devno)
  900. {
  901. printk("chandev_add_parms detected bad device range lo_devno=0x%04x  hi_devno=0x%04xn,",
  902.        (int)lo_devno,(int)hi_devno);
  903. return;
  904. }
  905. chandev_lock();
  906. for_each(parms,chandev_parms_head)
  907. {
  908. if(chan_type&(parms->chan_type))
  909. {
  910. u16 lomax=MAX(parms->lo_devno,lo_devno),
  911. himin=MIN(parms->hi_devno,lo_devno);
  912. if(lomax<=himin)
  913. {
  914. chandev_unlock();
  915. printk("chandev_add_parms detected overlapping "
  916.        "parameter definitions for chan_type=0x%02x"
  917.        " lo_devno=0x%04x  hi_devno=0x%04xn,"
  918.        " do a del_parms.",chan_type,(int)lo_devno,(int)hi_devno);
  919. return;
  920. }
  921. }
  922. }
  923. chandev_unlock();
  924. if((parms=chandev_allocstr(parmstr,offsetof(chandev_parms,parmstr))))
  925. {
  926. parms->chan_type=chan_type;
  927. parms->lo_devno=lo_devno;
  928. parms->hi_devno=hi_devno;
  929. chandev_add_to_list((list **)&chandev_parms_head,(void *)parms);
  930. }
  931. else
  932. printk("chandev_add_parms memory request failedn");
  933. }
  936. void chandev_add_model(chandev_type chan_type,s32 cu_type,s16 cu_model,
  937.        s32 dev_type,s16 dev_model,u8 max_port_no,int auto_msck_recovery,
  938.        u8 default_checksum_received_ip_pkts,u8 default_use_hw_stats)
  939. {
  940. chandev_model_info *newmodel;
  941. int                err;
  942. char buff[40];
  944. if((newmodel=chandev_alloc(sizeof(chandev_model_info))))
  945. {
  946. devreg_t *drinfo=&newmodel->drinfo;
  947. newmodel->chan_type=chan_type;
  948. newmodel->cu_type=cu_type;
  949. newmodel->cu_model=cu_model;
  950. newmodel->dev_type=dev_type;
  951. newmodel->dev_model=dev_model;
  952. newmodel->max_port_no=max_port_no;
  953. newmodel->auto_msck_recovery=auto_msck_recovery;
  954. newmodel->default_checksum_received_ip_pkts=default_checksum_received_ip_pkts;
  955. newmodel->default_use_hw_stats=default_use_hw_stats; /* where available e.g. lcs */
  956. if(cu_type==-1&&dev_type==-1)
  957. {
  958. chandev_sprint_devinfo(buff,newmodel->cu_type,newmodel->cu_model,
  959.        newmodel->dev_type,newmodel->dev_model);
  960. printk(KERN_INFO"can't call s390_device_register for this device chan_type/chan_model/dev_type/dev_model %sn",buff);
  961. kfree(newmodel);
  962. return;
  963. }
  964. drinfo->flag=DEVREG_TYPE_DEVCHARS;
  965. if(cu_type!=-1)
  966. drinfo->flag|=DEVREG_MATCH_CU_TYPE;
  967. if(cu_model!=-1)
  968. drinfo->flag|=DEVREG_MATCH_CU_MODEL;
  969. if(dev_type!=-1)
  970. drinfo->flag|=DEVREG_MATCH_DEV_TYPE;
  971. if(dev_model!=-1)
  972. drinfo->flag|=DEVREG_MATCH_DEV_MODEL;
  973. drinfo->ci.hc.ctype=cu_type;
  974. drinfo->ci.hc.cmode=cu_model;
  975. drinfo->ci.hc.dtype=dev_type;
  976. drinfo->ci.hc.dmode=dev_model;
  977. drinfo->oper_func=chandev_oper_func;
  978. if((err=s390_device_register(&newmodel->drinfo)))
  979. {
  980. chandev_sprint_devinfo(buff,newmodel->cu_type,newmodel->cu_model,
  981.        newmodel->dev_type,newmodel->dev_model);
  982. printk("s390_device_register failed in chandev_add_model"
  983.        " this is nothing to worry about chan_type/chan_model/dev_type/dev_model %sn",buff);
  984. drinfo->oper_func=NULL;
  985. }
  986. chandev_add_to_list((list **)&chandev_models_head,newmodel);
  987. }
  988. }
  991. void chandev_remove(chandev *member)
  992. {
  993. chandev_free_queuemember(&chandev_head,(queue *)member);
  994. }
  997. void chandev_remove_all(void)
  998. {
  999. chandev_free_all_queue(&chandev_head);
  1000. }
  1002. void chandev_remove_model(chandev_model_info *model)
  1003. {
  1004. chandev *curr_chandev,*next_chandev;
  1006. chandev_lock();
  1007. for_each_allow_delete(curr_chandev,next_chandev,(chandev *)chandev_head.head)
  1008. if(curr_chandev->model_info==model)
  1009. chandev_remove(curr_chandev);
  1010. if(model->drinfo.oper_func)
  1011. s390_device_unregister(&model->drinfo);
  1012. chandev_free_listmember((list **)&chandev_models_head,(list *)model);
  1013. chandev_unlock();
  1014. }
  1016. void chandev_remove_all_models(void)
  1017. {
  1018. chandev_lock();
  1019. while(chandev_models_head)
  1020. chandev_remove_model(chandev_models_head);
  1021. chandev_unlock();
  1022. }
  1024. void chandev_del_model(s32 cu_type,s16 cu_model,s32 dev_type,s16 dev_model)
  1025. {
  1026. chandev_model_info *curr_model,*next_model;
  1028. chandev_lock();
  1029. for_each_allow_delete(curr_model,next_model,chandev_models_head)
  1030. if((curr_model->cu_type==cu_type||cu_type==-1)&&
  1031.    (curr_model->cu_model==cu_model||cu_model==-1)&&
  1032.    (curr_model->dev_type==dev_type||dev_type==-1)&&
  1033.    (curr_model->dev_model==dev_model||dev_model==-1))
  1034. chandev_remove_model(curr_model);
  1035. chandev_unlock();
  1036. }
  1038. static void chandev_init_default_models(void)
  1039. {
  1040. /* Usually P390/Planter 3172 emulation assume maximum 16 to be safe. */
  1041. chandev_add_model(chandev_type_lcs,0x3088,0x1,-1,-1,15,default_msck_bits,FALSE,FALSE);
  1043. /* 3172/2216 Paralell the 2216 allows 16 ports per card the */
  1044. /* the original 3172 only allows 4 we will assume the max of 16 */
  1045. chandev_add_model(chandev_type_lcs|chandev_type_ctc,0x3088,0x8,-1,-1,15,default_msck_bits,FALSE,FALSE);
  1047. /* 3172/2216 Escon serial the 2216 allows 16 ports per card the */
  1048. /* the original 3172 only allows 4 we will assume the max of 16 */
  1049. chandev_add_model(chandev_type_lcs|chandev_type_escon,0x3088,0x1F,-1,-1,15,default_msck_bits,FALSE,FALSE);
  1051. /* Only 2 ports allowed on OSA2 cards model 0x60 */
  1052. chandev_add_model(chandev_type_lcs,0x3088,0x60,-1,-1,1,default_msck_bits,FALSE,FALSE);
  1053. /* qeth gigabit ethernet */
  1054. chandev_add_model(chandev_type_qeth,0x1731,0x1,0x1732,0x1,0,default_msck_bits,FALSE,FALSE);
  1055. chandev_add_model(chandev_type_qeth,0x1731,0x5,0x1732,0x5,0,default_msck_bits,FALSE,FALSE);
  1056. /* Osa-D we currently aren't too emotionally involved with this */
  1057. chandev_add_model(chandev_type_osad,0x3088,0x62,-1,-1,0,default_msck_bits,FALSE,FALSE);
  1058. /* claw */
  1059. chandev_add_model(chandev_type_claw,0x3088,0x61,-1,-1,0,default_msck_bits,FALSE,FALSE);
  1061. /* ficon attached ctc */
  1062. chandev_add_model(chandev_type_escon,0x3088,0x1E,-1,-1,0,default_msck_bits,FALSE,FALSE);
  1063. }
  1066. void chandev_del_noauto(u16 devno)
  1067. {
  1068. chandev_noauto_range *curr_noauto,*next_noauto;
  1069. chandev_lock();
  1070. for_each_allow_delete(curr_noauto,next_noauto,chandev_noauto_head)
  1071. if(curr_noauto->lo_devno<=devno&&curr_noauto->hi_devno>=devno)
  1072. chandev_free_listmember((list **)&chandev_noauto_head,(list *)curr_noauto); 
  1073. chandev_unlock();
  1074. }
  1076. void chandev_del_msck(u16 devno)
  1077. {
  1078. chandev_msck_range *curr_msck_range,*next_msck_range;
  1079. chandev_lock();
  1080. for_each_allow_delete(curr_msck_range,next_msck_range,chandev_msck_range_head)
  1081. if(curr_msck_range->lo_devno<=devno&&curr_msck_range->hi_devno>=devno)
  1082. chandev_free_listmember((list **)&chandev_msck_range_head,(list *)curr_msck_range); 
  1083. chandev_unlock();
  1084. }
  1087. void chandev_add(s390_dev_info_t  *newdevinfo,chandev_model_info *newmodelinfo)
  1088. {
  1089. chandev *new_chandev=NULL;
  1091. if((new_chandev=chandev_alloc(sizeof(chandev))))
  1092. {
  1093. new_chandev->model_info=newmodelinfo;
  1094. new_chandev->sch.devno=newdevinfo->devno;
  1095. new_chandev->sch.irq=newdevinfo->irq;
  1096. new_chandev->sch.cu_type=newdevinfo->sid_data.cu_type; /* control unit type */
  1097. new_chandev->sch.cu_model=newdevinfo->sid_data.cu_model; /* control unit model */
  1098. new_chandev->sch.dev_type=newdevinfo->sid_data.dev_type; /* device type */
  1099. new_chandev->sch.dev_model=newdevinfo->sid_data.dev_model; /* device model */
  1100. chandev_add_schib_info(newdevinfo->irq,&new_chandev->sch);
  1101. new_chandev->owned=(newdevinfo->status&DEVSTAT_DEVICE_OWNED ? TRUE:FALSE);
  1102. chandev_queuemember(&chandev_head,new_chandev);
  1103. }
  1104. }
  1106. void chandev_unregister_probe(chandev_probefunc probefunc)
  1107. {
  1108. chandev_probelist *curr_probe,*next_probe;
  1110. chandev_lock();
  1111. for_each_allow_delete(curr_probe,next_probe,chandev_probelist_head)
  1112. if(curr_probe->probefunc==probefunc)
  1113. chandev_free_listmember((list **)&chandev_probelist_head,
  1114. (list *)curr_probe);
  1115. chandev_unlock();
  1116. }
  1118. void chandev_unregister_probe_by_chan_type(chandev_type chan_type)
  1119. {
  1120. chandev_probelist *curr_probe,*next_probe;
  1122. chandev_lock();
  1123. for_each_allow_delete(curr_probe,next_probe,chandev_probelist_head)
  1124. if(curr_probe->chan_type==chan_type)
  1125. chandev_free_listmember((list **)&chandev_probelist_head,
  1126. (list *)curr_probe);
  1127. chandev_unlock();
  1128. }
  1132. void chandev_reset(void)
  1133. {
  1134. chandev_lock();
  1135. chandev_remove_all_models();
  1136. chandev_free_all_list((list **)&chandev_noauto_head);
  1137. chandev_free_all_list((list **)&chandev_msck_range_head);
  1138. chandev_free_all_list((list **)&chandev_force_head);
  1139. chandev_remove_parms(-1,FALSE,-1);
  1140. #if LINUX_VERSION_CODE>=KERNEL_VERSION(2,3,0)
  1141. chandev_use_devno_names=FALSE;
  1142. #endif
  1143. chandev_persistent=0;
  1144. chandev_unlock();
  1145. }
  1148. int chandev_is_chandev(int irq,s390_dev_info_t *devinfo,chandev_force **forceinfo,chandev_model_info **ret_model)
  1149. {
  1150. chandev_force *curr_force;
  1151. chandev_model_info *curr_model=NULL;
  1152. int err;
  1153. int retval=FALSE;
  1155. if(forceinfo)
  1156. *forceinfo=NULL;
  1157. if(ret_model)
  1158. *ret_model=NULL;
  1159. if((err=get_dev_info_by_irq(irq,devinfo)))
  1160. {
  1161. printk("chandev_is_chandev get_dev_info_by_irq reported err=%X on irq %dn"
  1162.        "should not happenn",err,irq);
  1163. return FALSE;
  1164. }
  1165. chandev_lock();
  1167. for_each(curr_model,chandev_models_head)
  1168. {
  1169. if(((curr_model->cu_type==devinfo->sid_data.cu_type)||(curr_model->cu_type==-1))&&
  1170.    ((curr_model->cu_model==devinfo->sid_data.cu_model)||(curr_model->cu_model==-1))&&
  1171.    ((curr_model->dev_type==devinfo->sid_data.dev_type)||(curr_model->dev_type==-1))&&
  1172.    ((curr_model->dev_model==devinfo->sid_data.dev_model)||(curr_model->dev_model==-1)))
  1173. {
  1174. retval=TRUE;
  1175. if(ret_model)
  1176. *ret_model=curr_model;
  1177. break;
  1178. }
  1179. }
  1180. for_each(curr_force,chandev_force_head)
  1181. {
  1182. if(((curr_force->read_lo_devno==devinfo->devno)&&
  1183.    (curr_force->write_hi_devno==devinfo->devno)&&
  1184.     (curr_force->devif_num!=-2))||
  1185.    ((curr_force->read_lo_devno>=devinfo->devno)&&
  1186.     (curr_force->write_hi_devno<=devinfo->devno)&&
  1187.     (curr_force->devif_num==-2)))
  1188. {
  1189. if(forceinfo)
  1190. *forceinfo=curr_force;
  1191. break;
  1192. }
  1193. }
  1194. chandev_unlock();
  1195. return(retval);
  1196. }
  1198. void chandev_collect_devices(void)
  1199. {
  1200. int curr_irq,loopcnt=0;
  1201. s390_dev_info_t   curr_devinfo;
  1202. chandev_model_info *curr_model;
  1203.      
  1205. for(curr_irq=get_irq_first();curr_irq>=0; curr_irq=get_irq_next(curr_irq))
  1206. {
  1207. /* check read chandev
  1208.  * we had to do the cu_model check also because ctc devices
  1209.  * have the same cutype & after asking some people
  1210.  * the model numbers are given out pseudo randomly so
  1211.  * we can't just take a range of them also the dev_type & models are 0
  1212.  */
  1213. loopcnt++;
  1214. if(loopcnt>0x10000)
  1215. {
  1216. printk(KERN_ERR"chandev_collect_devices detected infinite loop bug in get_irq_nextn");
  1217. break;
  1218. }
  1219. chandev_lock();
  1220. if(chandev_is_chandev(curr_irq,&curr_devinfo,NULL,&curr_model))
  1221. chandev_add(&curr_devinfo,curr_model);
  1222. chandev_unlock();
  1223. }
  1224. }
  1226. int chandev_add_force(chandev_type chan_type,s32 devif_num,u16 read_lo_devno,
  1227. u16 write_hi_devno,u16 data_devno,s32 memory_usage_in_k,s16 port_protocol_no,u8 checksum_received_ip_pkts,
  1228. u8 use_hw_stats,char *host_name,char *adapter_name,char *api_type)
  1229. {
  1230. chandev_force *new_chandev_force;
  1232. if(devif_num==-2&&read_lo_devno>write_hi_devno)
  1233. {
  1234. printk("chandev_add_force detected bad device range lo_devno=0x%04x  hi_devno=0x%04xn,",
  1235.        (int)read_lo_devno,(int)write_hi_devno);
  1236. return(-1);
  1237. }
  1238. if(memory_usage_in_k<0)
  1239. {
  1240. printk("chandev_add_force memory_usage_in_k is badn");
  1241. return(-1);
  1242. }
  1243. if(chan_type==chandev_type_claw)
  1244. {
  1245. int host_name_len=strlen(host_name),
  1246. adapter_name_len=strlen(adapter_name),
  1247. api_type_len=strlen(api_type);
  1248. if(host_name_len>=CLAW_NAMELEN||host_name_len==0||
  1249.    adapter_name_len>=CLAW_NAMELEN||adapter_name_len==0||
  1250.    api_type_len>=CLAW_NAMELEN||api_type_len==0)
  1251. return(-1);
  1252. }
  1253. if((new_chandev_force=chandev_alloc(sizeof(chandev_force))))
  1254. {
  1255. new_chandev_force->chan_type=chan_type;
  1256. new_chandev_force->devif_num=devif_num;
  1257. new_chandev_force->read_lo_devno=read_lo_devno;
  1258. new_chandev_force->write_hi_devno=write_hi_devno;
  1259. new_chandev_force->data_devno=data_devno;
  1260. new_chandev_force->memory_usage_in_k=memory_usage_in_k;
  1261. new_chandev_force->port_protocol_no=port_protocol_no;
  1262. new_chandev_force->checksum_received_ip_pkts=checksum_received_ip_pkts;
  1263. new_chandev_force->use_hw_stats=use_hw_stats;
  1265. if(chan_type==chandev_type_claw)
  1266. {
  1267. strcpy(new_chandev_force->claw.host_name,host_name);
  1268. strcpy(new_chandev_force->claw.adapter_name,adapter_name);
  1269. strcpy(new_chandev_force->claw.api_type,api_type);
  1270. }
  1271. chandev_add_to_list((list **)&chandev_force_head,new_chandev_force);
  1272. }
  1273. return(0);
  1274. }
  1276. void chandev_del_force(int read_lo_devno)
  1277. {
  1278. chandev_force *curr_force,*next_force;
  1280. chandev_lock();
  1281. for_each_allow_delete(curr_force,next_force,chandev_force_head)
  1282. {
  1283. if(curr_force->read_lo_devno==read_lo_devno||read_lo_devno==-1)
  1284. chandev_free_listmember((list **)&chandev_force_head,
  1285. (list *)curr_force);
  1286. }
  1287. chandev_unlock();
  1288. }
  1291. void chandev_shutdown(chandev_activelist *curr_device)
  1292. {
  1293. int err=0;
  1294. chandev_lock();
  1297. /* unregister_netdev calls the dev->close so we shouldn't do this */
  1298. /* this otherwise we crash */
  1299. if(curr_device->unreg_dev)
  1300. {
  1301. curr_device->unreg_dev(curr_device->dev_ptr);
  1302. curr_device->unreg_dev=NULL;
  1303. }
  1304. if(curr_device->shutdownfunc)
  1305. {
  1306. err=curr_device->shutdownfunc(curr_device->dev_ptr);
  1307. }
  1308. if(err)
  1309. printk("chandev_shutdown unable to fully shutdown & unload %s err=%dn"
  1310.        "probably some upper layer still requires the device to existn",
  1311.        curr_device->devname,err);
  1312. else
  1313. {
  1315. chandev_free_irq_by_irqinfo(curr_device->read_irqinfo);
  1316. chandev_free_irq_by_irqinfo(curr_device->write_irqinfo);
  1317. if(curr_device->data_irqinfo)
  1318. chandev_free_irq_by_irqinfo(curr_device->data_irqinfo);
  1319. chandev_free_listmember((list **)&chandev_activelist_head,
  1320. (list *)curr_device);
  1321. }
  1322. chandev_unlock();
  1323. }
  1325. void chandev_shutdown_all(void)
  1326. {
  1327. while(chandev_activelist_head)
  1328. chandev_shutdown(chandev_activelist_head);
  1329. }
  1330. void chandev_shutdown_by_name(char *devname)
  1331. {
  1332. chandev_activelist *curr_device;
  1334. chandev_lock();
  1335. for_each(curr_device,chandev_activelist_head)
  1336. if(strcmp(devname,curr_device->devname)==0)
  1337. {
  1338. chandev_shutdown(curr_device);
  1339. break;
  1340. }
  1341. chandev_unlock();
  1342. }
  1344. static chandev_activelist *chandev_active(u16 devno)
  1345. {
  1346. chandev_activelist *curr_device;
  1348. for_each(curr_device,chandev_activelist_head)
  1349. if(curr_device->read_irqinfo->sch.devno==devno||
  1350.    curr_device->write_irqinfo->sch.devno==devno||
  1351.    (curr_device->data_irqinfo&&curr_device->data_irqinfo->sch.devno==devno))
  1352. {
  1353. return(curr_device);
  1354. }
  1355. return(NULL);
  1356. }
  1358. void chandev_shutdown_by_devno(u16 devno)
  1359. {
  1360. chandev_activelist *curr_device;
  1362. chandev_lock();
  1363. curr_device=chandev_active(devno);
  1364. if(curr_device)
  1365. chandev_shutdown(curr_device);
  1366. chandev_unlock();
  1367. }
  1370. int chandev_pack_args(char *str)
  1371. {
  1372. char *newstr=str,*next;
  1373. int strcnt=1;
  1375. while(*str)
  1376. {
  1377. next=str+1;
  1378. /*remove dead spaces */
  1379. if(isspace(*str)&&isspace(*next))
  1380. {
  1381. str++;
  1382. continue;
  1383. }
  1384. if(isspace(*str))
  1385. {
  1386. *str=',';
  1387. goto pack_dn;
  1388. }
  1389. if(((*str)==';')&&(*next))
  1390. {
  1391. strcnt++;
  1392. *str=0;
  1393. }
  1394. pack_dn:
  1395. *newstr++=*str++;
  1397. }
  1398. *newstr=0;
  1399. return(strcnt);
  1400. }
  1402. typedef enum
  1403. { 
  1404. isnull=0,
  1405. isstr=1,
  1406. isnum=2,
  1407. iscomma=4,
  1408. } chandev_strval;
  1410. chandev_strval chandev_strcmp(char *teststr,char **str,long *endlong)
  1411. {
  1412. char *cur;
  1413. chandev_strval  retval=isnull;
  1415. int len=strlen(teststr);
  1416. if(strncmp(teststr,*str,len)==0)
  1417. {
  1418. *str+=len;
  1419. retval=isstr;
  1420. cur=*str;
  1421. *endlong=simple_strtol(cur,str,0);
  1422. if(cur!=*str)
  1423. retval|=isnum;
  1424. if(**str==',')
  1425. {
  1426. retval|=iscomma;
  1427. *str+=1;
  1428. }
  1429. else if(**str!=0)
  1430. retval=isnull;
  1431. }
  1432. return(retval);
  1433. }
  1436. int chandev_initdevice(chandev_probeinfo *probeinfo,void *dev_ptr,u8 port_no,char *devname,chandev_category category,chandev_unregfunc unreg_dev)
  1437. {
  1438. chandev_activelist *newdevice,*curr_device;
  1440. chandev_interrupt_check();
  1441. if(probeinfo->newdevice!=NULL)
  1442. {
  1443. printk("probeinfo->newdevice!=NULL in chandev_initdevice for %s",devname);
  1444. return(-EPERM);
  1445. }
  1448. chandev_lock();
  1449. for_each(curr_device,chandev_activelist_head)
  1450. {
  1451. if(strcmp(curr_device->devname,devname)==0)
  1452. {
  1453. printk("chandev_initdevice detected duplicate devicename %sn",devname);
  1454. chandev_unlock();
  1455. return(-EPERM);
  1456. }
  1457. }
  1458. if((newdevice=chandev_allocstr(devname,offsetof(chandev_activelist,devname))))
  1459. {
  1460. newdevice->read_irqinfo=chandev_get_irqinfo_by_irq(probeinfo->read.irq);
  1461. newdevice->write_irqinfo=chandev_get_irqinfo_by_irq(probeinfo->write.irq);
  1462. if(probeinfo->data_exists)
  1463. newdevice->data_irqinfo=chandev_get_irqinfo_by_irq(probeinfo->data.irq);
  1464. chandev_unlock();
  1465. if(newdevice->read_irqinfo==NULL||newdevice->write_irqinfo==NULL||
  1466.    (probeinfo->data_exists&&newdevice->data_irqinfo==NULL))
  1467. {
  1468. printk("chandev_initdevice, it appears that chandev_request_irq was not "
  1469.        "called for devname=%s read_irq=%d write_irq=%d data_irq=%dn",
  1470.        devname,probeinfo->read.irq,probeinfo->write.irq,probeinfo->data.irq);
  1471. kfree(newdevice);
  1472. return(-EPERM);
  1473. }
  1474. newdevice->chan_type=probeinfo->chan_type;
  1475. newdevice->dev_ptr=dev_ptr;
  1476. newdevice->port_no=port_no;
  1477. newdevice->memory_usage_in_k=probeinfo->memory_usage_in_k;
  1478. newdevice->category=category;
  1479. newdevice->unreg_dev=unreg_dev;
  1480. probeinfo->newdevice=newdevice;
  1481. return(0);
  1482. }
  1483. chandev_unlock();
  1484. return(-ENOMEM);
  1485. }
  1488. char *chandev_build_device_name(chandev_probeinfo *probeinfo,char *destnamebuff,char *basename,int buildfullname)
  1489. {
  1490. if (chandev_use_devno_names&&(!probeinfo->device_forced||probeinfo->devif_num==-1)) 
  1491. sprintf(destnamebuff,"%s%04x",basename,(int)probeinfo->read.devno);
  1492. else
  1493. {
  1494. if(probeinfo->devif_num==-1)
  1495. {
  1496. if(buildfullname)
  1497. {
  1498. int idx,len=strlen(basename);
  1500. chandev_activelist *curr_device;
  1501. for(idx=0;idx<0xffff;idx++)
  1502. {
  1503. for_each(curr_device,chandev_activelist_head)
  1504. {
  1505. if(strncmp(curr_device->devname,basename,len)==0)
  1506. {
  1507. char numbuff[10];
  1508. sprintf(numbuff,"%d",idx);
  1509. if(strcmp(&curr_device->devname[len],numbuff)==0)
  1510. goto next_idx;
  1511. }
  1512. }
  1513. sprintf(destnamebuff,"%s%d",basename,idx);
  1514. return(destnamebuff);
  1515. next_idx:
  1516. }
  1517. printk("chandev_build_device_name was usable to build a unique name for %sn",basename);
  1518. return(NULL);
  1519. }
  1520. else
  1521. sprintf(destnamebuff,"%s%%d",basename);
  1522. }
  1523. else
  1524. {
  1525. sprintf(destnamebuff,"%s%d",basename,(int)probeinfo->devif_num);
  1526. }
  1527. }
  1528. return(destnamebuff);
  1529. }
  1531. #if LINUX_VERSION_CODE>=KERNEL_VERSION(2,3,0)
  1532. struct net_device *chandev_init_netdev(chandev_probeinfo *probeinfo,char *basename,
  1533. struct net_device *dev, int sizeof_priv,
  1534. struct net_device *(*init_netdevfunc)(struct net_device *dev, int sizeof_priv))
  1535. #else
  1536. struct device *chandev_init_netdev(chandev_probeinfo *probeinfo,char *basename,
  1537. struct device *dev, int sizeof_priv,
  1538. struct device *(*init_netdevfunc)(struct device *dev, int sizeof_priv))
  1539. #endif
  1540. {
  1541. #if LINUX_VERSION_CODE>=KERNEL_VERSION(2,3,0)
  1542. struct net_device *retdevice=NULL;
  1543. int new_device = FALSE;
  1544. #else
  1545. struct device *retdevice=NULL;
  1546. #endif
  1549. chandev_interrupt_check();
  1550. if (!init_netdevfunc) 
  1551. {
  1552. printk("init_netdevfunc=NULL in chandev_init_netdev, it should not be valid.n");
  1553. return NULL;
  1554. }
  1555. #if LINUX_VERSION_CODE>=KERNEL_VERSION(2,3,0)
  1556. /* Allocate a device if one is not provided. */
  1557.         if (dev == NULL) 
  1558. {
  1559. /* ensure 32-byte alignment of the private area */
  1560. int alloc_size = sizeof (*dev) + sizeof_priv + 31;
  1562. dev = (struct net_device *) kmalloc (alloc_size, GFP_KERNEL);
  1563. if (dev == NULL) 
  1564. {
  1565. printk(KERN_ERR "chandev_initnetdevice: Unable to allocate device memory.n");
  1566. return NULL;
  1567. }
  1569. memset(dev, 0, alloc_size);
  1571. if (sizeof_priv)
  1572. dev->priv = (void *) (((long)(dev + 1) + 31) & ~31);
  1573. new_device=TRUE;
  1574. }
  1575. chandev_build_device_name(probeinfo,dev->name,basename,FALSE);
  1576. #endif
  1577. retdevice=init_netdevfunc(dev,sizeof_priv);
  1578. #if LINUX_VERSION_CODE>=KERNEL_VERSION(2,3,0)
  1579. /* Register device if necessary */
  1580. /* we need to do this as init_netdev doesn't call register_netdevice */
  1581. /* for already allocated devices */
  1582. if (retdevice && new_device)
  1583. register_netdev(retdevice);
  1584. #endif
  1585. #if LINUX_VERSION_CODE>=KERNEL_VERSION(2,3,0)
  1586. /* We allocated it, so we should free it on error */
  1587. if (!retdevice && new_device) 
  1588. kfree(dev);
  1589. #endif
  1590. return retdevice;
  1591. }
  1596. #if LINUX_VERSION_CODE>=KERNEL_VERSION(2,3,0)
  1597. struct net_device *chandev_initnetdevice(chandev_probeinfo *probeinfo,u8 port_no,
  1598. struct net_device *dev, int sizeof_priv, char *basename, 
  1599. struct net_device *(*init_netdevfunc)(struct net_device *dev, int sizeof_priv),
  1600. void (*unreg_netdevfunc)(struct net_device *dev))
  1601. #else
  1602. struct device *chandev_initnetdevice(chandev_probeinfo *probeinfo,u8 port_no,
  1603. struct device *dev, int sizeof_priv, char *basename,
  1604. struct device *(*init_netdevfunc)(struct device *dev, int sizeof_priv),
  1605. void (*unreg_netdevfunc)(struct device *dev))
  1606. #endif
  1607. {
  1608. #if LINUX_VERSION_CODE>=KERNEL_VERSION(2,3,0)
  1609. struct net_device *retdevice=NULL;
  1610. int new_device=(dev==NULL);
  1611. #else
  1612. struct device *retdevice=NULL;
  1613. #endif
  1615. if (!unreg_netdevfunc) 
  1616. {
  1617. printk("unreg_netdevfunc=NULL in chandev_initnetdevice, it should not be valid.n");
  1618. return NULL;
  1619. }
  1620. chandev_interrupt_check();
  1621. retdevice=chandev_init_netdev(probeinfo,basename,dev,sizeof_priv,init_netdevfunc);
  1622. if (retdevice) 
  1623. {
  1624. if (chandev_initdevice(probeinfo,retdevice,port_no,retdevice->name,
  1625.       chandev_category_network_device,(chandev_unregfunc)unreg_netdevfunc)) 
  1626. {
  1627. unreg_netdevfunc(retdevice);
  1628. #if LINUX_VERSION_CODE>=KERNEL_VERSION(2,3,0)
  1629. /* We allocated it, so we should free it on error */
  1630. if(new_device)
  1631. kfree(dev);
  1632. #endif
  1634. retdevice = NULL;
  1635. }
  1636. }
  1637. return retdevice;
  1638. }
  1641. int chandev_compare_chpid_info(chandev_subchannel_info *chan1,chandev_subchannel_info *chan2)
  1642. {
  1643. return (chan1->pim!=chan2->pim || *chan1->chpid!=*chan2->chpid);
  1644. }
  1646. int chandev_compare_cu_dev_info(chandev_subchannel_info *chan1,chandev_subchannel_info *chan2)
  1647. {
  1648. return ((chan1->cu_type != chan2->cu_type)||
  1649. (chan1->cu_model != chan2->cu_model)||
  1650. (chan1->dev_type != chan2->dev_type)||
  1651. (chan1->dev_model != chan2->dev_model));
  1652. }
  1654. int chandev_compare_subchannel_info(chandev_subchannel_info *chan1,chandev_subchannel_info *chan2)
  1655. {
  1656. return((chan1->devno == chan2->devno) &&
  1657.        (chan1->cu_type == chan2->cu_type) &&
  1658.        (chan1->cu_model == chan2->cu_model) &&
  1659.        (chan1->dev_type == chan2->dev_type) &&
  1660.        (chan1->dev_model == chan2->dev_model) &&
  1661.        (chan1->pim == chan2->pim) &&
  1662.        (*chan1->chpid == *chan2->chpid));
  1663. }
  1666. int chandev_doprobe(chandev_force *force,chandev *read,
  1667. chandev *write,chandev *data)
  1668. {
  1669. chandev_probelist *probe;
  1670. chandev_model_info *model_info;
  1671. chandev_probeinfo probeinfo;
  1672. int               rc=-1,hint=-1;
  1673. chandev_activelist *newdevice;
  1674. chandev_probefunc  probefunc;
  1675. chandev_parms      *curr_parms;
  1676. chandev_model_info dummy_model_info;
  1678. memset(&probeinfo,0,sizeof(probeinfo));
  1679. memset(&dummy_model_info,0,sizeof(dummy_model_info));
  1680. probeinfo.device_forced=(force!=NULL);
  1681. probeinfo.chpid_info_inconsistent=chandev_compare_chpid_info(&read->sch,&write->sch)||
  1682.  (data&&chandev_compare_chpid_info(&read->sch,&data->sch));
  1683. probeinfo.cu_dev_info_inconsistent=chandev_compare_cu_dev_info(&read->sch,&write->sch)||
  1684.  (data&&chandev_compare_cu_dev_info(&read->sch,&data->sch));
  1685. if(read->model_info)
  1686. model_info=read->model_info;
  1687. else
  1688. {
  1689. dummy_model_info.chan_type=chandev_type_none;
  1690. dummy_model_info.max_port_no=16;
  1691. model_info=&dummy_model_info;
  1692. }
  1693. for_each(probe,chandev_probelist_head)
  1694. {
  1695. if(force)
  1696. probeinfo.chan_type = ( probe->chan_type & force->chan_type );
  1697. else
  1698. {
  1699. if(chandev_cautious_auto_detect)
  1700. probeinfo.chan_type = ( probe->chan_type == model_info->chan_type ? 
  1701.        probe->chan_type : chandev_type_none );
  1702. else
  1703. probeinfo.chan_type = ( probe->chan_type & model_info->chan_type );
  1704. }
  1705. if(probeinfo.chan_type && (force || ( !probeinfo.cu_dev_info_inconsistent &&
  1706.   ((probe->chan_type&(chandev_type_ctc|chandev_type_escon)) ||
  1707.    !probeinfo.chpid_info_inconsistent))))
  1708. {
  1709. #if LINUX_VERSION_CODE>=KERNEL_VERSION(2,3,0)
  1710. if(chandev_use_devno_names)
  1711. probeinfo.devif_num=read->sch.devno;
  1712. else
  1713. #endif
  1714. probeinfo.devif_num=-1;
  1715. probeinfo.read=read->sch;
  1716. probeinfo.write=write->sch;
  1717. if(data)
  1718. {
  1719. probeinfo.data=data->sch;
  1720. probeinfo.data_exists=TRUE;
  1721. }
  1722. probeinfo.max_port_no=(force&&(force->port_protocol_no!=-1) ? 
  1723.       force->port_protocol_no : model_info->max_port_no);
  1724. for_each(curr_parms,chandev_parms_head)
  1725. {
  1726. if(probe->chan_type==curr_parms->chan_type&&
  1727.    read->sch.devno>=curr_parms->lo_devno&&
  1728. read->sch.devno<=curr_parms->hi_devno)
  1729. {
  1730. probeinfo.parmstr=curr_parms->parmstr;
  1731. break;
  1732. }
  1733. }
  1734. if(force)
  1735. {
  1736. if(force->chan_type==chandev_type_claw)
  1737. memcpy(&probeinfo.claw,&force->claw,sizeof(chandev_claw_info));
  1738. probeinfo.port_protocol_no=force->port_protocol_no;
  1739. if(force->devif_num==-1&&force->devif_num==-2)
  1740. probeinfo.devif_num=-1;
  1741. else
  1742. probeinfo.devif_num=force->devif_num;
  1743. probeinfo.memory_usage_in_k=force->memory_usage_in_k;
  1744. probeinfo.checksum_received_ip_pkts=force->checksum_received_ip_pkts;
  1745. probeinfo.use_hw_stats=force->use_hw_stats;
  1746. }
  1747. else
  1748. {
  1749. probeinfo.port_protocol_no=0;
  1750. probeinfo.checksum_received_ip_pkts=model_info->default_checksum_received_ip_pkts;
  1751. probeinfo.use_hw_stats=model_info->default_use_hw_stats;
  1752. probeinfo.memory_usage_in_k=0;
  1753. if(probe->chan_type&chandev_type_lcs)
  1754. {
  1755. hint=(read->sch.devno&0xFF)>>1;
  1756. if(hint>model_info->max_port_no)
  1757. {
  1758. /* The card is possibly emulated e.g P/390 */
  1759. /* or possibly configured to use a shared */
  1760. /* port configured by osa-sf. */
  1761. hint=0;
  1762. }
  1763. }
  1764. }
  1765. probeinfo.hint_port_no=hint;
  1766. probefunc=probe->probefunc;
  1767. rc=probefunc(&probeinfo);
  1768. if(rc==0)
  1769. {
  1770. newdevice=probeinfo.newdevice;
  1771. if(newdevice)
  1772. {
  1773. newdevice->probefunc=probe->probefunc;
  1774. newdevice->shutdownfunc=probe->shutdownfunc;
  1775. newdevice->msck_notfunc=probe->msck_notfunc;
  1776. probe->devices_found++;
  1777. chandev_add_to_list((list **)&chandev_activelist_head,
  1778.     newdevice);
  1779. chandev_add_to_userland_notify_list(chandev_start,
  1780.       newdevice->devname,chandev_status_good,chandev_status_good);
  1781. }
  1782. else
  1783. {
  1784. printk("chandev_initdevice either failed or wasn't called for device read_irq=0x%04xn",probeinfo.read.irq);
  1785. }
  1786. break;
  1788. }
  1789. }
  1790. }
  1791. chandev_remove(read);
  1792. chandev_remove(write);
  1793. if(data)
  1794. chandev_remove(data);
  1795. return(rc);
  1796. }
  1799. int chandev_request_irq_from_irqinfo(chandev_irqinfo *irqinfo,chandev *this_chandev)
  1800. {
  1801. int retval=s390_request_irq_special(irqinfo->sch.irq,
  1802.    irqinfo->handler,
  1803.    chandev_not_oper_handler,
  1804.    irqinfo->irqflags,
  1805.    irqinfo->devname,
  1806.    irqinfo->dev_id);
  1807. if(retval==0)
  1808. {
  1809. irqinfo->msck_status=chandev_status_good;
  1810. this_chandev->owned=TRUE;
  1811. }
  1812. return(retval);
  1813. }
  1815. void chandev_irqallocerr(chandev_irqinfo *irqinfo,int err)
  1816. {
  1817. printk("chandev_probe failed to realloc irq=%d for %s err=%dn",irqinfo->sch.irq,irqinfo->devname,err);
  1818. }
  1821. void chandev_call_notification_func(chandev_activelist *curr_device,chandev_irqinfo *curr_irqinfo,
  1822. chandev_msck_status prevstatus)
  1823. {
  1824. if(curr_irqinfo->msck_status!=prevstatus)
  1825. {
  1826. chandev_msck_status new_msck_status=curr_irqinfo->msck_status;
  1827. if(curr_irqinfo->msck_status==chandev_status_good)
  1828. {
  1829. if(curr_device->read_irqinfo->msck_status==chandev_status_good&&
  1830.    curr_device->write_irqinfo->msck_status==chandev_status_good)
  1831. {
  1832. if(curr_device->data_irqinfo)
  1833. {
  1834. if(curr_device->data_irqinfo->msck_status==chandev_status_good)
  1835. new_msck_status=chandev_status_all_chans_good;
  1836. }
  1837. else
  1838. new_msck_status=chandev_status_all_chans_good;
  1839. }
  1840. }
  1841. if(curr_device->msck_notfunc)
  1842. {
  1843. curr_device->msck_notfunc(curr_device->dev_ptr,
  1844.       curr_irqinfo->sch.irq,
  1845.       prevstatus,new_msck_status);
  1846. }
  1847. if(new_msck_status!=chandev_status_good)
  1848. {
  1849. /* No point in sending a machine check if only one channel is good */
  1850. chandev_add_to_userland_notify_list(chandev_msck,curr_device->devname,
  1851.       prevstatus,curr_irqinfo->msck_status);
  1852. }
  1853. }
  1854. }
  1856. int chandev_find_eligible_channels(chandev *first_chandev_to_check,
  1857.        chandev **read,chandev **write,chandev **data,chandev **next,
  1858.    chandev_type chan_type)
  1859. {
  1860. chandev *curr_chandev;
  1861. int eligible_found=FALSE,changed;
  1863. *next=first_chandev_to_check->next;
  1864. *read=*write=*data=NULL;
  1865. for_each(curr_chandev,first_chandev_to_check)
  1866. if((curr_chandev->sch.devno&1)==0&&curr_chandev->model_info->chan_type!=chandev_type_claw)
  1867. {
  1868. *read=curr_chandev;
  1869. if(chan_type==chandev_type_none)
  1870. chan_type=(*read)->model_info->chan_type;
  1871. break;
  1872. }
  1873. if(*read)
  1874. {
  1875. for_each(curr_chandev,(chandev *)chandev_head.head)
  1876. if((((*read)->sch.devno|1)==curr_chandev->sch.devno)&&
  1877.    (chandev_compare_cu_dev_info(&(*read)->sch,&curr_chandev->sch)==0)&&
  1878.    ((chan_type&(chandev_type_ctc|chandev_type_escon))||
  1879.     chandev_compare_chpid_info(&(*read)->sch,&curr_chandev->sch)==0))
  1880. {
  1881. *write=curr_chandev;
  1882. break;
  1883. }
  1884. }
  1885. if((chan_type&chandev_type_qeth))
  1886. {
  1887. if(*write)
  1888. {
  1889. for_each(curr_chandev,(chandev *)chandev_head.head)
  1890. if((curr_chandev!=*read&&curr_chandev!=*write)&&
  1891.    (chandev_compare_cu_dev_info(&(*read)->sch,&curr_chandev->sch)==0)&&
  1892.    (chandev_compare_chpid_info(&(*read)->sch,&curr_chandev->sch)==0))
  1893. {
  1894. *data=curr_chandev;
  1895. break;
  1896. }
  1897. if(*data)
  1898. eligible_found=TRUE;
  1899. }
  1901. }
  1902. else
  1903. if(*write)
  1904. eligible_found=TRUE;
  1905. if(eligible_found)
  1906. {
  1907. do
  1908. {
  1909. changed=FALSE;
  1910. if(*next&&
  1911.    ((*read&&(*read==*next))||
  1912.    (*write&&(*write==*next))||
  1913.    (*data&&(*data==*next))))
  1914. {
  1915. *next=(*next)->next;
  1916. changed=TRUE;
  1917. }
  1918. }while(changed==TRUE);
  1919. }
  1920. return(eligible_found);
  1921. }
  1923. chandev *chandev_get_free_chandev_by_devno(int devno)
  1924. {
  1925. chandev *curr_chandev;
  1926. if(devno==-1)
  1927. return(NULL);
  1928. for_each(curr_chandev,(chandev *)chandev_head.head)
  1929. if(curr_chandev->sch.devno==devno)
  1930. {
  1931. if(chandev_active(devno))
  1932. return(NULL);
  1933. else
  1934. return(curr_chandev);
  1935. }
  1936. return(NULL);
  1938. }
  1940. void chandev_probe(void)
  1941. {
  1942. chandev *read_chandev,*write_chandev,*data_chandev,*curr_chandev,*next_chandev;
  1943. chandev_force *curr_force;
  1944. chandev_noauto_range *curr_noauto;
  1945. chandev_activelist *curr_device;
  1946. chandev_irqinfo *curr_irqinfo;
  1947. s390_dev_info_t curr_devinfo;
  1948. int  err;
  1949. int auto_msck_recovery;
  1950. chandev_msck_status prevstatus;
  1951. chandev_msck_range *curr_msck_range;
  1954. chandev_interrupt_check();
  1955. chandev_read_conf_if_necessary();
  1956. chandev_collect_devices();
  1957. chandev_lock();
  1958. for_each(curr_irqinfo,chandev_irqinfo_head)
  1959. {
  1960. if((curr_device=chandev_get_activelist_by_irq(curr_irqinfo->sch.irq)))
  1961. {
  1962. prevstatus=curr_irqinfo->msck_status;
  1963. if(curr_irqinfo->msck_status!=chandev_status_good)
  1964. {
  1965. curr_chandev=chandev_get_by_irq(curr_irqinfo->sch.irq);
  1966. if(curr_chandev)
  1967. {
  1968. auto_msck_recovery=curr_chandev->model_info->
  1969. auto_msck_recovery;
  1970. }
  1971. else
  1972. goto remove;
  1973. for_each(curr_msck_range,chandev_msck_range_head)
  1974. {
  1975. if(curr_msck_range->lo_devno<=
  1976.    curr_irqinfo->sch.devno&&
  1977.    curr_msck_range->hi_devno>=
  1978.    curr_irqinfo->sch.devno)
  1979. {
  1980. auto_msck_recovery=
  1981. curr_msck_range->
  1982. auto_msck_recovery;
  1983. break;
  1984. }
  1985. }
  1986. if((1<<(curr_irqinfo->msck_status-1))&auto_msck_recovery)
  1987. {
  1988. if(curr_irqinfo->msck_status==chandev_status_revalidate)
  1989. {
  1990. if((get_dev_info_by_irq(curr_irqinfo->sch.irq,&curr_devinfo)==0))
  1991. {
  1992. curr_irqinfo->sch.devno=curr_devinfo.devno;
  1993. curr_irqinfo->msck_status=chandev_status_good;
  1994. }
  1995. }
  1996. else
  1997. {
  1998. if(curr_chandev)
  1999. {
  2000. /* Has the device reappeared */
  2001. if(chandev_compare_subchannel_info(
  2002. &curr_chandev->sch,
  2003. &curr_device->read_irqinfo->sch)||
  2004.    chandev_compare_subchannel_info(
  2005. &curr_chandev->sch,
  2006. &curr_device->write_irqinfo->sch)||
  2007.    (curr_device->data_irqinfo&&
  2008.     chandev_compare_subchannel_info(
  2009.     &curr_chandev->sch,
  2010.     &curr_device->data_irqinfo->sch)))
  2011. {
  2012. if((err=chandev_request_irq_from_irqinfo(curr_irqinfo,curr_chandev))==0)
  2013. curr_irqinfo->msck_status=chandev_status_good;
  2014. else
  2015. chandev_irqallocerr(curr_irqinfo,err);
  2016. }
  2018. }
  2019. }
  2020. }
  2021. }
  2022. chandev_call_notification_func(curr_device,curr_irqinfo,prevstatus);
  2023. }
  2024. /* This is required because the device can go & come back */
  2025.                 /* even before we realize it is gone owing to the waits in our kernel threads */
  2026. /* & the device will be marked as not owned but its status will be good */
  2027.                 /* & an attempt to accidently reprobe it may be done. */ 
  2028. remove:
  2029. chandev_remove(chandev_get_by_irq(curr_irqinfo->sch.irq));
  2031. }
  2032. /* extra sanity */
  2033. for_each_allow_delete(curr_chandev,next_chandev,(chandev *)chandev_head.head)
  2034. if(curr_chandev->owned)
  2035. chandev_remove(curr_chandev);
  2036. for_each(curr_force,chandev_force_head)
  2037. {
  2038. if(curr_force->devif_num==-2)
  2039. {
  2040. for_each_allow_delete2(curr_chandev,next_chandev,(chandev *)chandev_head.head)
  2041. {
  2042. if(chandev_find_eligible_channels(curr_chandev,&read_chandev,
  2043.   &write_chandev,&data_chandev,
  2044.   &next_chandev,
  2045.   curr_force->chan_type));
  2046. {
  2047. if((curr_force->read_lo_devno>=read_chandev->sch.devno)&&
  2048.    (curr_force->write_hi_devno<=read_chandev->sch.devno)&&
  2049.    (curr_force->read_lo_devno>=write_chandev->sch.devno)&&
  2050.    (curr_force->write_hi_devno<=write_chandev->sch.devno)&&
  2051.    (!data_chandev||(data_chandev&&
  2052.    (curr_force->read_lo_devno>=data_chandev->sch.devno)&&
  2053.    (curr_force->write_hi_devno<=data_chandev->sch.devno))))
  2054. chandev_doprobe(curr_force,read_chandev,write_chandev,
  2055. data_chandev);
  2056. }
  2057. }
  2058. }
  2059. else
  2060. {
  2061. read_chandev=chandev_get_free_chandev_by_devno(curr_force->read_lo_devno);
  2062. if(read_chandev)
  2063. {
  2064. write_chandev=chandev_get_free_chandev_by_devno(curr_force->write_hi_devno);
  2065. if(write_chandev)
  2066. {
  2067. if(curr_force->chan_type==chandev_type_qeth)
  2068. {
  2070. data_chandev=chandev_get_free_chandev_by_devno(curr_force->data_devno);
  2071. if(data_chandev==NULL)
  2072. printk("chandev_probe unable to force gigabit_ethernet driver invalid device  no 0x%04x givenn",curr_force->data_devno);
  2073. }
  2074. else
  2075. data_chandev=NULL;
  2076. chandev_doprobe(curr_force,read_chandev,write_chandev,
  2077. data_chandev);
  2078. }
  2079. }
  2080. }
  2081. }
  2082. for_each_allow_delete(curr_chandev,next_chandev,(chandev *)chandev_head.head)
  2083. {
  2084. for_each(curr_noauto,chandev_noauto_head)
  2085. {
  2086. if(curr_chandev->sch.devno>=curr_noauto->lo_devno&&
  2087.    curr_chandev->sch.devno<=curr_noauto->hi_devno)
  2088. {
  2089. chandev_remove(curr_chandev);
  2090. break;
  2091. }
  2092. }
  2093. }
  2094. for_each_allow_delete2(curr_chandev,next_chandev,(chandev *)chandev_head.head)
  2095. {
  2096. if(chandev_find_eligible_channels(curr_chandev,&read_chandev,
  2097.   &write_chandev,&data_chandev,
  2098.   &next_chandev,
  2099.   chandev_type_none))
  2100. chandev_doprobe(NULL,read_chandev,write_chandev,
  2101. data_chandev);
  2102. }
  2103. chandev_remove_all();
  2104. chandev_unlock();
  2105. }
  2107. static void chandev_not_oper_func(int irq,int status)
  2108. {
  2109. chandev_irqinfo *curr_irqinfo;
  2110. chandev_activelist *curr_device;
  2112. chandev_lock();
  2113. for_each(curr_irqinfo,chandev_irqinfo_head)
  2114. if(curr_irqinfo->sch.irq==irq)
  2115. {
  2116. chandev_msck_status prevstatus=curr_irqinfo->msck_status;
  2117. switch(status)
  2118. {
  2119. /* Currently defined but not used in kernel */
  2120. /* Despite being in specs */
  2121. case DEVSTAT_NOT_OPER:
  2122. curr_irqinfo->msck_status=chandev_status_not_oper;
  2123. break;
  2124. #ifdef DEVSTAT_NO_PATH
  2125. /* Kernel hasn't this defined currently. */
  2126. /* Despite being in specs */
  2127. case DEVSTAT_NO_PATH:
  2128. curr_irqinfo->msck_status=chandev_status_no_path;
  2129. break;
  2130. #endif
  2131. case DEVSTAT_REVALIDATE:
  2132. curr_irqinfo->msck_status=chandev_status_revalidate;
  2133. break;
  2134. case DEVSTAT_DEVICE_GONE:
  2135. curr_irqinfo->msck_status=chandev_status_gone;
  2136. break;
  2137.                         }
  2138.                         if((curr_device=chandev_get_activelist_by_irq(irq)))
  2139. chandev_call_notification_func(curr_device,curr_irqinfo,prevstatus);
  2140.   else
  2141. printk("chandev_not_oper_func received channel check for unowned irq %d",irq);
  2142. }
  2143. chandev_unlock();
  2144. }
  2147. static int chandev_msck_thread(void *unused)
  2148. {
  2149. int loopcnt,not_oper_probe_required=FALSE;
  2150. wait_queue_head_t    wait;
  2151. chandev_not_oper_struct *new_not_oper;
  2153. /* This loop exists because machine checks tend to come in groups & we have
  2154.            to wait for the other devnos to appear also */
  2155. init_waitqueue_head(&wait);
  2156. for(loopcnt=0;loopcnt<10||(jiffies-chandev_last_machine_check)<HZ;loopcnt++)
  2157. {
  2158. sleep_on_timeout(&wait,HZ);
  2159. }
  2160. atomic_set(&chandev_msck_thread_lock,1);
  2161. while(!atomic_compare_and_swap(TRUE,FALSE,&chandev_new_msck));
  2162. {
  2163. chandev_probe();
  2164. }
  2165. while(TRUE)
  2166. {
  2168. unsigned long        flags; 
  2169. spin_lock_irqsave(&chandev_not_oper_spinlock,flags);
  2170. new_not_oper=(chandev_not_oper_struct *)dequeue_head(&chandev_not_oper_head);
  2171. spin_unlock_irqrestore(&chandev_not_oper_spinlock,flags);
  2172. if(new_not_oper)
  2173. {
  2174. chandev_not_oper_func(new_not_oper->irq,new_not_oper->status);
  2175. not_oper_probe_required=TRUE;
  2176. kfree(new_not_oper);
  2177. }
  2178. else
  2179. break;
  2180. }
  2181. if(not_oper_probe_required)
  2182. chandev_probe();
  2183. return(0);
  2184. }
  2186. static void chandev_msck_task(void *unused)
  2187. {
  2188. if(kernel_thread(chandev_msck_thread,NULL,SIGCHLD)<0)
  2189. {
  2190. atomic_set(&chandev_msck_thread_lock,1);
  2191. printk("error making chandev_msck_thread kernel threadn");
  2192. }
  2193. }
  2197. static char *argstrs[]=
  2198. {
  2199. "noauto",
  2200. "del_noauto",
  2201. "ctc",
  2202. "escon",
  2203. "lcs",
  2204. "osad",
  2205. "qeth",
  2206. "claw",
  2207. "add_parms",
  2208. "del_parms",
  2209. "del_force",
  2210. #if LINUX_VERSION_CODE>=KERNEL_VERSION(2,3,0)
  2211. "use_devno_names",
  2212. "dont_use_devno_names",
  2213. #endif
  2214. "cautious_auto_detect",
  2215. "non_cautious_auto_detect",
  2216. "add_model",
  2217. "del_model",
  2218. "auto_msck",
  2219. "del_auto_msck",
  2220. "del_all_models",
  2221. "reset_conf_clean",
  2222. "reset_conf",
  2223. "shutdown",
  2224. "reprobe",
  2225. "unregister_probe",
  2226. "unregister_probe_by_chan_type",
  2227. "read_conf",
  2228. "dont_read_conf",
  2229. "persist"
  2230. };
  2232. typedef enum
  2233. {
  2234. stridx_mult=256,
  2235. first_stridx=0,
  2236. noauto_stridx=first_stridx,
  2237. del_noauto_stridx,
  2238. ctc_stridx,
  2239. escon_stridx,
  2240. lcs_stridx,
  2241. osad_stridx,
  2242.         qeth_stridx,
  2243. claw_stridx,
  2244. add_parms_stridx,
  2245. del_parms_stridx,
  2246. del_force_stridx,
  2247. #if LINUX_VERSION_CODE>=KERNEL_VERSION(2,3,0)
  2248. use_devno_names_stridx,
  2249. dont_use_devno_names_stridx,
  2250. #endif
  2251. cautious_auto_detect_stridx,
  2252. non_cautious_auto_detect_stridx,
  2253. add_model_stridx,
  2254. del_model_stridx,
  2255. auto_msck_stridx,
  2256. del_auto_msck_stridx,
  2257. del_all_models_stridx,
  2258. reset_conf_clean_stridx,
  2259. reset_conf_stridx,
  2260. shutdown_stridx,
  2261. reprobe_stridx,
  2262. unregister_probe_stridx,
  2263. unregister_probe_by_chan_type_stridx,
  2264. read_conf_stridx,
  2265. dont_read_conf_stridx,
  2266. persist_stridx,
  2267. last_stridx,
  2268. } chandev_str_enum;
  2270. void chandev_add_noauto(u16 lo_devno,u16 hi_devno)
  2271. {
  2272. chandev_noauto_range *new_range;
  2274. if((new_range=chandev_alloc(sizeof(chandev_noauto_range))))
  2275. {
  2276. new_range->lo_devno=lo_devno;
  2277. new_range->hi_devno=hi_devno;
  2278. chandev_add_to_list((list **)&chandev_noauto_head,new_range);
  2279. }
  2280. }
  2283. void chandev_add_msck_range(u16 lo_devno,u16 hi_devno,int auto_msck_recovery)
  2284. {
  2285. chandev_msck_range *new_range;
  2287. if((new_range=chandev_alloc(sizeof(chandev_msck_range))))
  2288. {
  2289. new_range->lo_devno=lo_devno;
  2290. new_range->hi_devno=hi_devno;
  2291. new_range->auto_msck_recovery=auto_msck_recovery;
  2292. chandev_add_to_list((list **)&chandev_msck_range_head,new_range);
  2293. }
  2294. }
  2298. static char chandev_keydescript[]=
  2299. "nchan_type key bitfield ctc=0x1,escon=0x2,lcs=0x4,osad=0x8,qeth=0x10,claw=0x20n";
  2302. #if  CONFIG_ARCH_S390X
  2303. /* We need this as we sometimes use this to evaluate pointers */
  2304. typedef long chandev_int; 
  2305. #else
  2306. typedef int chandev_int;
  2307. #endif
  2310. #if (LINUX_VERSION_CODE<KERNEL_VERSION(2,3,0)) || (CONFIG_ARCH_S390X)
  2311. /*
  2312.  * Read an int from an option string; if available accept a subsequent
  2313.  * comma as well.
  2314.  *
  2315.  * Return values:
  2316.  * 0 : no int in string
  2317.  * 1 : int found, no subsequent comma
  2318.  * 2 : int found including a subsequent comma
  2319.  */
  2320. static chandev_int chandev_get_option(char **str,chandev_int *pint)
  2321. {
  2322.     char *cur = *str;
  2324.     if (!cur || !(*cur)) return 0;
  2325.     *pint = simple_strtol(cur,str,0);
  2326.     if (cur==*str) return 0;
  2327.     if (**str==',') {
  2328.         (*str)++;
  2329.         return 2;
  2330.     }
  2332.     return 1;
  2333. }
  2336. static char *chandev_get_options(char *str, int nints, chandev_int *ints)
  2337. {
  2338. int res,i=1;
  2340. while (i<nints) 
  2341. {
  2342. res = chandev_get_option(&str, ints+i);
  2343. if (res==0) break;
  2344. i++;
  2345. if (res==1) break;
  2346. }
  2347. ints[0] = i-1;
  2348. return(str);
  2349. }
  2350. #else
  2351. #define chandev_get_option get_option
  2352. #define chandev_get_options get_options
  2353. #endif
  2354. /*
  2355.  * Read an string from an option string; if available accept a subsequent
  2356.  * comma as well & set this comma to a null character when returning the string.
  2357.  *
  2358.  * Return values:
  2359.  * 0 : no string found
  2360.  * 1 : string found, no subsequent comma
  2361.  * 2 : string found including a subsequent comma
  2362.  */
  2363. static int chandev_get_string(char **instr,char **outstr)
  2364. {
  2365. char *cur = *instr;
  2367. if (!cur ||*cur==0)
  2368. {
  2369. *outstr=NULL;
  2370. return 0;
  2371. }
  2372. *outstr=*instr;
  2373. for(;;)
  2374. {
  2375. if(*(++cur)==',')
  2376. {
  2377. *cur=0;
  2378. *instr=cur+1;
  2379. return 2;
  2380. }
  2381. else if(*cur==0)
  2382. {
  2383. *instr=cur+1;
  2384. return 1;
  2385. }
  2386. }
  2387. }
  2392. static int chandev_setup(int in_read_conf,char *instr,char *errstr,int lineno)
  2393. {
  2394. chandev_strval   val=isnull;
  2395. chandev_str_enum stridx;
  2396. long             endlong;
  2397. chandev_type     chan_type;
  2398. char             *str,*currstr,*interpretstr=NULL;
  2399. int              cnt,strcnt;
  2400. int              retval=0;
  2401. #define CHANDEV_MAX_EXTRA_INTS 12
  2402. chandev_int ints[CHANDEV_MAX_EXTRA_INTS+1];
  2403. currstr=alloca(strlen(instr)+1);
  2404. strcpy(currstr,instr);
  2405. strcnt=chandev_pack_args(currstr);
  2406. for(cnt=1;cnt<=strcnt;cnt++)
  2407. {
  2408. interpretstr=currstr;
  2409. memset(ints,0,sizeof(ints));
  2410. for(stridx=first_stridx;stridx<last_stridx;stridx++)
  2411. {
  2412. str=currstr;
  2413. if((val=chandev_strcmp(argstrs[stridx],&str,&endlong)))
  2414. break;
  2415. }
  2416. currstr=str;
  2417. if(val)
  2418. {
  2419. val=(((chandev_strval)stridx)*stridx_mult)+(val&~isstr);
  2420. switch(val)
  2421. {
  2422. case (add_parms_stridx*stridx_mult)|iscomma:
  2423. currstr=chandev_get_options(currstr,4,ints);
  2424. if(*currstr&&ints[0]>=1)
  2425. {
  2426. if(ints[0]==1)
  2427. {
  2428. ints[2]=0;
  2429. ints[3]=0xffff;
  2430. }
  2431. else if(ints[0]==2)
  2432. ints[3]=ints[2];
  2433. chandev_add_parms(ints[1],ints[2],ints[3],currstr);
  2434. goto NextOption;
  2435. }
  2436. else
  2437. goto BadArgs;
  2438. break;
  2439. case (claw_stridx*stridx_mult)|isnum|iscomma:
  2440. case (claw_stridx*stridx_mult)|iscomma:
  2441. currstr=chandev_get_options(str,6,ints);
  2442. break;
  2443. default:
  2444. if(val&iscomma)
  2445. currstr=chandev_get_options(str,CHANDEV_MAX_EXTRA_INTS,ints);
  2446. break;
  2447. }
  2448. switch(val)
  2449. {
  2450. case noauto_stridx*stridx_mult:
  2451. case (noauto_stridx*stridx_mult)|iscomma:
  2452. switch(ints[0])
  2453. {
  2454. case 0: 
  2455. chandev_free_all_list((list **)&chandev_noauto_head);
  2456. chandev_add_noauto(0,0xffff);
  2457. break;
  2458. case 1:
  2459. ints[2]=ints[1];
  2460. case 2:
  2461. chandev_add_noauto(ints[1],ints[2]);
  2462. break;
  2463. default:
  2464. goto BadArgs;
  2465. }
  2466. break;
  2467. case (auto_msck_stridx*stridx_mult)|iscomma:
  2468. switch(ints[0])
  2469. {
  2470. case 1:
  2471. chandev_free_all_list((list **)&chandev_msck_range_head);
  2472. chandev_add_msck_range(0,0xffff,ints[1]);
  2473. break;
  2474. case 2:
  2475. chandev_add_msck_range(ints[1],ints[1],ints[2]);
  2476. break;
  2477. case 3:
  2478. chandev_add_msck_range(ints[1],ints[2],ints[3]);
  2479. break;
  2480. default:
  2481. goto BadArgs;
  2483. }
  2484. case del_auto_msck_stridx*stridx_mult:
  2485. case (del_auto_msck_stridx*stridx_mult)|iscomma:
  2486. switch(ints[0])
  2487. {
  2488. case 0:
  2489. chandev_free_all_list((list **)&chandev_msck_range_head);
  2490. break;
  2491. case 1:
  2492. chandev_del_msck(ints[1]);
  2493. default:
  2494. goto BadArgs;
  2495. }
  2496. case del_noauto_stridx*stridx_mult:
  2497. chandev_free_all_list((list **)&chandev_noauto_head);
  2498. break;
  2499. case (del_noauto_stridx*stridx_mult)|iscomma:
  2500. if(ints[0]==1)
  2501. chandev_del_noauto(ints[1]);
  2502. else
  2503. goto BadArgs;
  2504. break;
  2505. case (qeth_stridx*stridx_mult)|isnum|iscomma:
  2506. if(ints[0]<3||ints[0]>7)
  2507. goto BadArgs;
  2508. chandev_add_force(chandev_type_qeth,endlong,ints[1],ints[2],
  2509.   ints[3],ints[4],ints[5],ints[6],ints[7],
  2510.   NULL,NULL,NULL);
  2511. break;
  2512. case (ctc_stridx*stridx_mult)|isnum|iscomma:
  2513. case (escon_stridx*stridx_mult)|isnum|iscomma:
  2514. case (lcs_stridx*stridx_mult)|isnum|iscomma:
  2515. case (osad_stridx*stridx_mult)|isnum|iscomma:
  2516. case (ctc_stridx*stridx_mult)|iscomma:
  2517. case (escon_stridx*stridx_mult)|iscomma:
  2518. case (lcs_stridx*stridx_mult)|iscomma:
  2519. case (osad_stridx*stridx_mult)|iscomma:
  2520. switch(val&~(isnum|iscomma))
  2521. {
  2522. case (ctc_stridx*stridx_mult):
  2523. chan_type=chandev_type_ctc;
  2524. break;
  2525. case (escon_stridx*stridx_mult):
  2526. chan_type=chandev_type_escon;
  2527. break;
  2528. case (lcs_stridx*stridx_mult):
  2529. chan_type=chandev_type_lcs;
  2530. break;
  2531. case (osad_stridx*stridx_mult):
  2532. chan_type=chandev_type_osad;
  2533. break;
  2534. case (qeth_stridx*stridx_mult):
  2535. chan_type=chandev_type_qeth;
  2536. break;
  2537. default:
  2538. goto BadArgs;
  2539. }
  2540. if((val&isnum)==0)
  2541. endlong=-2;
  2542. if(ints[0]<2||ints[0]>6)
  2543. goto BadArgs;
  2544. chandev_add_force(chan_type,endlong,ints[1],ints[2],
  2545.   0,ints[3],ints[4],ints[5],ints[6],
  2546.   NULL,NULL,NULL);
  2547. break;
  2548. case (claw_stridx*stridx_mult)|isnum|iscomma:
  2549. case (claw_stridx*stridx_mult)|iscomma:
  2550. if(ints[0]>=2&&ints[0]<=5)
  2551. {
  2552. char    *host_name,*adapter_name,*api_type;
  2553. char    *clawstr=alloca(strlen(currstr)+1);
  2555. strcpy(clawstr,currstr);
  2556. if(!(chandev_get_string(&clawstr,&host_name)==2&&
  2557.      chandev_get_string(&clawstr,&adapter_name)==2&&
  2558.      chandev_get_string(&clawstr,&api_type)==1&&
  2559.      chandev_add_force(chandev_type_claw,
  2560.        endlong,ints[1],ints[2],0,
  2561.        ints[3],0,ints[4],ints[5],
  2562.        host_name,adapter_name,api_type)==0))
  2563. goto BadArgs;
  2565. }
  2566. else
  2567. goto BadArgs;
  2568. break;
  2569. case (del_parms_stridx*stridx_mult):
  2570. ints[1]=-1;
  2571. case (del_parms_stridx*stridx_mult)|iscomma:
  2572. if(ints[0]==0)
  2573. ints[1]=-1;
  2574. if(ints[0]<=1)
  2575. ints[2]=FALSE;
  2576. if(ints[0]<=2)
  2577. ints[3]=-1;
  2578. if(ints[0]>3)
  2579. goto BadArgs;
  2580. chandev_remove_parms(ints[1],ints[2],ints[3]);
  2581. break;
  2582. case (del_force_stridx*stridx_mult)|iscomma:
  2583. if(ints[0]!=1)
  2584. goto BadArgs;
  2585. chandev_del_force(ints[1]);
  2586. break;
  2587. case (del_force_stridx*stridx_mult):
  2588. chandev_del_force(-1);
  2589. break;
  2590. #if LINUX_VERSION_CODE>=KERNEL_VERSION(2,3,0)
  2591. case (use_devno_names_stridx*stridx_mult):
  2592. chandev_use_devno_names=TRUE;
  2593. break;
  2594. case (dont_use_devno_names_stridx*stridx_mult):
  2595. chandev_use_devno_names=FALSE;
  2596. break;
  2597. #endif
  2598. case (cautious_auto_detect_stridx*stridx_mult):
  2599. chandev_cautious_auto_detect=TRUE;
  2600. break;
  2601. case (non_cautious_auto_detect_stridx*stridx_mult):
  2602. chandev_cautious_auto_detect=FALSE;
  2603. break;
  2604. case (add_model_stridx*stridx_mult)|iscomma:
  2605. if(ints[0]<3)
  2606. goto BadArgs;
  2607. if(ints[0]==3)
  2608. ints[4]=-1;
  2609. if(ints[0]<=4)
  2610. ints[5]=-1;
  2611. if(ints[0]<=5)
  2612. ints[6]=-1;
  2613. if(ints[0]<=6)
  2614. ints[7]=default_msck_bits;
  2615. if(ints[0]<=7)
  2616. ints[8]=FALSE;
  2617. if(ints[0]<=8)
  2618. ints[9]=FALSE;
  2619. ints[0]=7;
  2620. chandev_add_model(ints[1],ints[2],ints[3],
  2621.   ints[4],ints[5],ints[6],ints[7],ints[8],ints[9]);
  2622. break;
  2623. case (del_model_stridx*stridx_mult)|iscomma:
  2624. if(ints[0]<2||ints[0]>4)
  2625. goto BadArgs;
  2626. if(ints[0]<3)
  2627. ints[3]=-2;
  2628. if(ints[0]<4)
  2629. ints[4]=-2;
  2630. ints[0]=4;
  2631. chandev_del_model(ints[1],ints[2],ints[3],ints[4]);
  2632. break;
  2633. case del_all_models_stridx*stridx_mult:
  2634. chandev_remove_all_models();
  2635. break;
  2636. case reset_conf_stridx*stridx_mult:
  2637. chandev_reset();
  2638. chandev_init_default_models();
  2639. break;
  2640. case reset_conf_clean_stridx*stridx_mult:
  2641. chandev_reset();
  2642. break;
  2643. case shutdown_stridx*stridx_mult:
  2644. chandev_shutdown_all();
  2645. break;
  2646. case (shutdown_stridx*stridx_mult)|iscomma:
  2647. switch(ints[0])
  2648. {
  2649. case 0:
  2650. if(strlen(str))
  2651. chandev_shutdown_by_name(str);
  2652. else
  2653. goto BadArgs;
  2654. break;
  2655. case 1:
  2656. chandev_shutdown_by_devno(ints[1]);
  2657. break;
  2658. default:
  2659. goto BadArgs;
  2660. }
  2661. break;
  2662. case reprobe_stridx*stridx_mult:
  2663. chandev_probe();
  2664. break;
  2665. case unregister_probe_stridx*stridx_mult:
  2666. chandev_free_all_list((list **)&chandev_probelist_head);
  2667. break;
  2668. case (unregister_probe_stridx*stridx_mult)|iscomma:
  2669. if(ints[0]!=1)
  2670. goto BadArgs;
  2671. chandev_unregister_probe((chandev_probefunc)ints[1]);
  2672. break;
  2673. case (unregister_probe_by_chan_type_stridx*stridx_mult)|iscomma:
  2674. if(ints[0]!=1)
  2675. goto BadArgs;
  2676. chandev_unregister_probe_by_chan_type((chandev_type)ints[1]);
  2677. break;
  2678. case read_conf_stridx*stridx_mult:
  2679. if(in_read_conf)
  2680. {
  2681. printk("attempt to recursively call read_confn");
  2682. goto BadArgs;
  2683. }
  2684. chandev_read_conf();
  2685. break;
  2686. case dont_read_conf_stridx*stridx_mult:
  2687. atomic_set(&chandev_conf_read,TRUE);
  2688. break;
  2689. case (persist_stridx*stridx_mult)|iscomma:
  2690. if(ints[0]==1)
  2691. chandev_persistent=ints[1];
  2692. else
  2693. goto BadArgs;
  2694. break;
  2695. default:
  2696. goto BadArgs;
  2697. }
  2698. }
  2699. else
  2700. goto BadArgs;
  2701. NextOption:
  2702. if(cnt<strcnt)
  2703. {
  2704. /* eat up stuff till next string */
  2705. while(*(currstr++));
  2706. }
  2707. }
  2708. retval=1;
  2709.  BadArgs:
  2710. if(!retval)
  2711. {
  2712. printk("chandev_setup %s %s",(val==0 ? "unknown verb":"bad argument"),instr);
  2713. if(errstr)
  2714. {
  2715. printk("%s %d interpreted as %s",errstr,lineno,interpretstr);
  2716. if(strcnt>1)
  2717. {
  2718. if(cnt==strcnt)
  2719. printk(" after the last semicolonn");
  2720. else
  2721. printk(" before semicolon no %d",cnt);
  2722. }
  2723. }
  2724. printk(".n Type man chandev for more info.nn");
  2725. }
  2726. return(retval);
  2727. }
  2728. #define CHANDEV_KEYWORD "chandev="
  2729. static int chandev_setup_bootargs(char *str,int paramno)
  2730. {
  2731. int len;
  2733. char *copystr;
  2734. for(len=0;str[len]!=0&&!isspace(str[len]);len++);
  2735. copystr=alloca(len+1);
  2736. strncpy(copystr,str,len);
  2737. copystr[len]=0;
  2738. if(chandev_setup(FALSE,copystr,"at "CHANDEV_KEYWORD" bootparam no",paramno)==0)
  2739. return(0);
  2740. return(len);
  2742. }
  2744. /*
  2745.   We can't parse using a __setup function as kmalloc isn't available
  2746.   at this time.
  2747.  */
  2748. static void __init chandev_parse_args(void)
  2749. {
  2750. #define CHANDEV_KEYWORD "chandev="
  2751. extern char saved_command_line[];
  2752. int cnt,len,paramno=1;
  2754. len=strlen(saved_command_line)-sizeof(CHANDEV_KEYWORD);
  2755. for(cnt=0;cnt<len;cnt++)
  2756. {
  2757. if(strncmp(&saved_command_line[cnt],CHANDEV_KEYWORD,
  2758.    sizeof(CHANDEV_KEYWORD)-1)==0)
  2759. {
  2760. cnt+=(sizeof(CHANDEV_KEYWORD)-1);
  2761. cnt+=chandev_setup_bootargs(&saved_command_line[cnt],paramno);
  2762. paramno++;
  2763. }
  2764. }
  2765. }
  2767. int chandev_do_setup(int in_read_conf,char *buff,int size)
  2768. {
  2769. int curr,comment=FALSE,newline=FALSE,oldnewline=TRUE;
  2770. char *startline=NULL,*endbuff=&buff[size];
  2772. int lineno=0;
  2774. *endbuff=0;
  2775. for(;buff<=endbuff;curr++,buff++)
  2776. {
  2777. if(*buff==0xa||*buff==0xc||*buff==0)
  2778. {
  2779. if(*buff==0xa||*buff==0)
  2780. lineno++;
  2781. *buff=0;
  2782. newline=TRUE;
  2783. }
  2784. else
  2785. { 
  2786. newline=FALSE;
  2787. if(*buff=='#')
  2788. comment=TRUE;
  2789. }
  2790. if(comment==TRUE)
  2791. *buff=0;
  2792. if(startline==NULL&&isalpha(*buff))
  2793. startline=buff;
  2794. if(startline&&(buff>startline)&&(oldnewline==FALSE)&&(newline==TRUE))
  2795. {
  2796. if((chandev_setup(in_read_conf,startline," on line no",lineno))==0)
  2797. return(-EINVAL);
  2798. startline=NULL;
  2799. }
  2800. if(newline)
  2801. comment=FALSE;
  2802.         oldnewline=newline;
  2803. }
  2804. return(0);
  2805. }
  2808. static void chandev_read_conf(void)
  2809. {
  2810. #define CHANDEV_FILE "/etc/chandev.conf"
  2811. struct stat statbuf;
  2812. char        *buff;
  2813. int         curr,left,len,fd;
  2815. /* if called from chandev_register_and_probe & 
  2816.    the driver is compiled into the kernel the
  2817.    parameters will need to be passed in from
  2818.    the kernel boot parameter line as the root
  2819.    fs is not mounted yet, we can't wait here.
  2820. */
  2821. if(in_interrupt()||current->fs->root==NULL)
  2822. return;
  2823. atomic_set(&chandev_conf_read,TRUE);
  2824. set_fs(KERNEL_DS);
  2825. if(stat(CHANDEV_FILE,&statbuf)==0)
  2826. {
  2827. set_fs(USER_DS);
  2828. buff=vmalloc(statbuf.st_size+1);
  2829. if(buff)
  2830. {
  2831. set_fs(KERNEL_DS);
  2832. if((fd=open(CHANDEV_FILE,O_RDONLY,0))!=-1)
  2833. {
  2834. curr=0;
  2835. left=statbuf.st_size;
  2836. while((len=read(fd,&buff[curr],left))>0)
  2837. {
  2838. curr+=len;
  2839. left-=len;
  2840. }
  2841. close(fd);
  2842. }
  2843. set_fs(USER_DS);
  2844. chandev_do_setup(TRUE,buff,statbuf.st_size);
  2845. vfree(buff);
  2846. }
  2847. }
  2848. set_fs(USER_DS);
  2849. }
  2851. static void chandev_read_conf_if_necessary(void)
  2852. {
  2853. if(in_interrupt()||current->fs->root==NULL)
  2854. return;
  2855. if(!atomic_compare_and_swap(FALSE,TRUE,&chandev_conf_read))
  2856. chandev_read_conf();
  2857. }
  2859. #ifdef CONFIG_PROC_FS
  2860. #define chandev_printf(exitchan,args...)     
  2861. splen=sprintf(spbuff,##args);                
  2862. spoffset+=splen;                             
  2863. if(spoffset>offset) {                        
  2864.        spbuff+=splen;                        
  2865.        currlen+=splen;                       
  2866. }                                            
  2867. if(currlen>=length)                          
  2868.        goto exitchan;
  2870. void sprintf_msck(char *buff,int auto_msck_recovery)
  2871. {
  2872. chandev_msck_status idx;
  2873. int first_time=TRUE;
  2874. buff[0]=0;
  2875. for(idx=chandev_status_first_msck;idx<chandev_status_last_msck;idx++)
  2876. {
  2877. if((1<<(idx-1))&auto_msck_recovery)
  2878. {
  2879. buff+=sprintf(buff,"%s%s",(first_time ? "":","),
  2880.       msck_status_strs[idx]);
  2881. first_time=FALSE;
  2882. }
  2883. }
  2884. }
  2886. static int chandev_read_proc(char *page, char **start, off_t offset,
  2887.   int length, int *eof, void *data)
  2888. {
  2889. char *spbuff=*start=page;
  2890. int    currlen=0,splen=0;
  2891. off_t  spoffset=0;
  2892. chandev_model_info *curr_model;
  2893. chandev_noauto_range *curr_noauto;
  2894. chandev_force *curr_force;
  2895. chandev_activelist *curr_device;
  2896. chandev_probelist  *curr_probe;
  2897. chandev_msck_range *curr_msck_range;
  2898. s390_dev_info_t   curr_devinfo;
  2899. int pass,chandevs_detected,curr_irq,loopcnt;
  2900. chandev_irqinfo *read_irqinfo,*write_irqinfo,*data_irqinfo;
  2901. char buff[3][80];    
  2903. chandev_lock();
  2904. chandev_printf(chan_exit,"n%sn"
  2905.        "*'s for cu/dev type/models indicate don't caresn",chandev_keydescript);
  2906. chandev_printf(chan_exit,"ncautious_auto_detect: %sn",chandev_cautious_auto_detect ? "on":"off");
  2907. chandev_printf(chan_exit,"npersist = 0x%02xn",chandev_persistent);
  2908. #if LINUX_VERSION_CODE>=KERNEL_VERSION(2,3,0)
  2909. chandev_printf(chan_exit,"nuse_devno_names: %snn",chandev_use_devno_names ? "on":"off");
  2910. #endif
  2912. if(chandev_models_head)
  2913. {
  2914. chandev_printf(chan_exit,"Channels enabled for detectionn");      
  2915. chandev_printf(chan_exit,"  chan     cu      cu     dev   dev    max     checksum  use hw  auto recoveryn");
  2916. chandev_printf(chan_exit,"  type    type    model  type  model  port_no. received   stats      typen");
  2917. chandev_printf(chan_exit,"==============================================================================n");
  2918. for_each(curr_model,chandev_models_head)
  2919. {
  2922. chandev_sprint_devinfo(buff[0],curr_model->cu_type,
  2923.        curr_model->cu_model,
  2924.        curr_model->dev_type,
  2925.        curr_model->dev_model);
  2926. sprintf_msck(buff[1],curr_model->auto_msck_recovery);
  2927. chandev_printf(chan_exit,"  0x%02x  %s%3d %s     %s     %sn",
  2928.        curr_model->chan_type,buff[0],
  2929.        (int)curr_model->max_port_no,
  2930.        curr_model->default_checksum_received_ip_pkts ? "yes":"no ",
  2931.        curr_model->default_use_hw_stats ? "yes":"no ",
  2932.        buff[1]);         
  2933. }
  2934. }
  2935.         
  2936. if(chandev_noauto_head)
  2937. {
  2938. chandev_printf(chan_exit,"nNo auto devno rangesn");
  2939. chandev_printf(chan_exit,"   From        To   n");
  2940. chandev_printf(chan_exit,"====================n");
  2941. for_each(curr_noauto,chandev_noauto_head)
  2942. {
  2943. chandev_printf(chan_exit,"  0x%04x     0x%04xn",
  2944.        curr_noauto->lo_devno,
  2945.        curr_noauto->hi_devno);
  2946. }
  2947. }
  2948. if(chandev_msck_range_head)
  2949. {
  2951. chandev_printf(chan_exit,"nAutomatic machine check recovery devno rangesn");
  2952. chandev_printf(chan_exit,"   From        To   automatic recovery typen");
  2953. chandev_printf(chan_exit,"===========================================n");
  2954. for_each(curr_msck_range,chandev_msck_range_head)
  2955. {
  2956. sprintf_msck(buff[0],curr_msck_range->auto_msck_recovery);
  2957. chandev_printf(chan_exit,"  0x%04x     0x%04x %sn",
  2958.        curr_msck_range->lo_devno,
  2959.        curr_msck_range->hi_devno,buff[0])
  2960. }
  2961. }
  2962. if(chandev_force_head)
  2963. {
  2964. chandev_printf(chan_exit,"nForced devicesn");
  2965. chandev_printf(chan_exit,"  chan defif read   write  data   memory      port         ip    hw   host       adapter   apin");
  2966. chandev_printf(chan_exit,"  type  num  devno  devno  devno  usage(k) protocol no.  chksum stats name        name     namen");
  2967. chandev_printf(chan_exit,"===============================================================================================n");
  2968. for_each(curr_force,chandev_force_head)
  2969. {
  2970. if(curr_force->memory_usage_in_k==0)
  2971. strcpy(buff[0],"default");
  2972. else
  2973. sprintf(buff[0],"%6d",curr_force->memory_usage_in_k);
  2974. chandev_printf(chan_exit,"  0x%02x  %3d  0x%04x 0x%04x 0x%04x %7s       %3d       %1d    %1d%s",
  2975.        (int)curr_force->chan_type,(int)curr_force->devif_num,
  2976.        (int)curr_force->read_lo_devno,(int)curr_force->write_hi_devno,
  2977.        (int)curr_force->data_devno,buff[0],
  2978.        (int)curr_force->port_protocol_no,(int)curr_force->checksum_received_ip_pkts,
  2979.        (int)curr_force->use_hw_stats,curr_force->chan_type==chandev_type_claw ? "":"n");
  2980. if(curr_force->chan_type==chandev_type_claw)
  2981. {
  2982. chandev_printf(chan_exit," %9s %9s %9sn",
  2983.        curr_force->claw.host_name,
  2984.        curr_force->claw.adapter_name,
  2985.        curr_force->claw.api_type);
  2986. }
  2988. }
  2989. }
  2990. if(chandev_probelist_head)
  2991. {
  2992. #if CONFIG_ARCH_S390X
  2993. chandev_printf(chan_exit,"nRegistered probe functionsn"
  2994.          "probefunc            shutdownfunc        msck_notfunc        chan  devices devicesn"
  2995.                                          "                                                             type   found  activen"
  2996.                  "==================================================================================n");
  2997. #else
  2998. chandev_printf(chan_exit,"nRegistered probe functionsn"
  2999.                  "probefunc   shutdownfunc   msck_notfunc   chan  devices devicesn"
  3000.                                          "                                          type   found  activen"
  3001.                  "===============================================================n");
  3002. #endif
  3003. for_each(curr_probe,chandev_probelist_head)
  3004. {
  3005. int devices_active=0;
  3006. for_each(curr_device,chandev_activelist_head)
  3007. {
  3008. if(curr_device->probefunc==curr_probe->probefunc)
  3009. devices_active++;
  3010. }
  3011. chandev_printf(chan_exit,"0x%p   0x%p   0x%p       0x%02x     %d      %dn",
  3012.        curr_probe->probefunc,
  3013.        curr_probe->shutdownfunc,
  3014.        curr_probe->msck_notfunc,
  3015.        curr_probe->chan_type,
  3016.        curr_probe->devices_found,
  3017.        devices_active);
  3018. }
  3019. }
  3020. if(chandev_activelist_head)
  3021. {
  3022. unsigned long long total_memory_usage_in_k=0;
  3023. chandev_printf(chan_exit,
  3024.        "nInitialised Devicesn"
  3025.        " read   write  data  read   write  data  chan port  dev     dev         memory   read msck    write msck    data msckn"
  3026.        " irq     irq    irq  devno  devno  devno type no.   ptr     name        usage(k)  status       status        statusn"
  3027.        "=====================================================================================================================n");
  3028. /* We print this list backwards for cosmetic reasons */
  3029. for(curr_device=chandev_activelist_head;
  3030.     curr_device->next!=NULL;curr_device=curr_device->next);
  3031. while(curr_device)
  3032. {
  3033. read_irqinfo=curr_device->read_irqinfo;
  3034. write_irqinfo=curr_device->write_irqinfo;
  3035. data_irqinfo=curr_device->data_irqinfo;
  3036. if(data_irqinfo)
  3037. {
  3038. sprintf(buff[0],"0x%04x",data_irqinfo->sch.irq);
  3039. sprintf(buff[1],"0x%04x",(int)data_irqinfo->sch.devno);
  3040. }
  3041. else
  3042. {
  3043. strcpy(buff[0],"  n/a ");
  3044. strcpy(buff[1],"  n/a ");
  3045. }
  3046. if(curr_device->memory_usage_in_k<0)
  3047. {
  3048. sprintf(buff[2],"%d",(int)-curr_device->memory_usage_in_k);
  3049. total_memory_usage_in_k-=curr_device->memory_usage_in_k;
  3050. }
  3051. else
  3052. strcpy(buff[2],"  n/a ");
  3053. chandev_printf(chan_exit,
  3054.        "0x%04x 0x%04x %s 0x%04x 0x%04x %s 0x%02x %2d 0x%p %-10s  %6s   %-12s %-12s %-12sn",
  3055.        read_irqinfo->sch.irq,
  3056.        write_irqinfo->sch.irq,
  3057.        buff[0],
  3058.        (int)read_irqinfo->sch.devno,
  3059.        (int)write_irqinfo->sch.devno,
  3060.        buff[1],
  3061.        curr_device->chan_type,(int)curr_device->port_no,
  3062.        curr_device->dev_ptr,curr_device->devname,
  3063.        buff[2],
  3064.        msck_status_strs[read_irqinfo->msck_status],
  3065.        msck_status_strs[write_irqinfo->msck_status],
  3066.        data_irqinfo ? msck_status_strs[data_irqinfo->msck_status] :
  3067.        "not applicable");
  3068. get_prev((list *)chandev_activelist_head,
  3069.  (list *)curr_device,
  3070.  (list **)&curr_device);
  3071. }
  3072. chandev_printf(chan_exit,"nTotal device memory usage %Luk.n",total_memory_usage_in_k);
  3073. }
  3074. chandevs_detected=FALSE;
  3075. for(pass=FALSE;pass<=TRUE;pass++)
  3076. {
  3077. if(pass&&chandevs_detected)
  3078. {
  3079. chandev_printf(chan_exit,"nchannels detectedn");
  3080. chandev_printf(chan_exit,"              chan    cu    cu   dev    dev                          in chandevn");
  3081. chandev_printf(chan_exit,"  irq  devno  type   type  model type  model pim      chpids         use  reg.n");
  3082. chandev_printf(chan_exit,"===============================================================================n");
  3083. }
  3084. for(curr_irq=get_irq_first(),loopcnt=0;curr_irq>=0; curr_irq=get_irq_next(curr_irq),loopcnt++)
  3085. {
  3086. if(loopcnt>0x10000)
  3087. {
  3088. printk(KERN_ERR"chandev_read_proc detected infinite loop bug in get_irq_nextn");
  3089. goto chan_error;
  3090. }
  3091. if(chandev_is_chandev(curr_irq,&curr_devinfo,&curr_force,&curr_model))
  3092. {
  3093. schib_t *curr_schib;
  3094. curr_schib=s390_get_schib(curr_irq);
  3095. chandevs_detected=TRUE;
  3096. if(pass)
  3097. {
  3098. chandev_printf(chan_exit,"0x%04x 0x%04x 0x%02x  0x%04x 0x%02x  0x%04x 0x%02x 0x%02x 0x%016Lx  %-5s%-5sn",
  3099.        curr_irq,curr_devinfo.devno,
  3100.        ( curr_force ? curr_force->chan_type : 
  3101.        ( curr_model ? curr_model->chan_type : 
  3102.  chandev_type_none )),
  3103.        (int)curr_devinfo.sid_data.cu_type,
  3104.        (int)curr_devinfo.sid_data.cu_model,
  3105.        (int)curr_devinfo.sid_data.dev_type,
  3106.        (int)curr_devinfo.sid_data.dev_model,
  3107.        (int)(curr_schib ? curr_schib->pmcw.pim : 0),
  3108.        *(long long *)(curr_schib ? &curr_schib->pmcw.chpid[0] : 0),
  3109.        (curr_devinfo.status&DEVSTAT_DEVICE_OWNED) ? "yes":"no ",
  3110.        (chandev_get_irqinfo_by_irq(curr_irq) ? "yes":"no "));
  3111.        
  3112.        
  3113. }
  3115. }
  3117. }
  3118. }
  3119. if(chandev_parms_head)
  3120. {
  3121. chandev_parms      *curr_parms;
  3123. chandev_printf(chan_exit,"n driver specific parametersn");
  3124. chandev_printf(chan_exit,"chan    lo    hi      drivern");
  3125. chandev_printf(chan_exit,"type  devno  devno  parametersn");
  3126. chandev_printf(chan_exit,"=============================================================================n");
  3127. for_each(curr_parms,chandev_parms_head)
  3128. {
  3129. chandev_printf(chan_exit,"0x%02x 0x%04x 0x%04x  %sn",
  3130.        curr_parms->chan_type,(int)curr_parms->lo_devno,
  3131.        (int)curr_parms->hi_devno,curr_parms->parmstr);
  3132. }
  3133. }
  3134.  chan_error:
  3135. *eof=TRUE;
  3136.  chan_exit:
  3137. if(currlen>length) {
  3138. /* rewind to previous printf so that we are correctly
  3139.  * aligned if we get called to print another page.
  3140.                  */
  3141. currlen-=splen;
  3142. }
  3143. chandev_unlock();
  3144. return(currlen);
  3145. }
  3148. static int chandev_write_proc(struct file *file, const char *buffer,
  3149.    unsigned long count, void *data)
  3150. {
  3151. int         rc;
  3152. char        *buff;
  3154. buff=vmalloc(count+1);
  3155. if(buff)
  3156. {
  3157. rc = copy_from_user(buff,buffer,count);
  3158. if (rc)
  3159. goto chandev_write_exit;
  3160. chandev_do_setup(FALSE,buff,count);
  3161. rc=count;
  3162. chandev_write_exit:
  3163. vfree(buff);
  3164. return rc;
  3165. }
  3166. else
  3167. return -ENOMEM;
  3168. return(0);
  3169. }
  3171. static void __init chandev_create_proc(void)
  3172. {
  3173. struct proc_dir_entry *dir_entry=
  3174. create_proc_entry("chandev",0644,
  3175.   &proc_root);
  3176. if(dir_entry)
  3177. {
  3178. dir_entry->read_proc=&chandev_read_proc;
  3179. dir_entry->write_proc=&chandev_write_proc;
  3180. }
  3181. }
  3184. #endif
  3185. #if LINUX_VERSION_CODE>=KERNEL_VERSION(2,3,0)
  3186. static  
  3187. #endif
  3188. int __init chandev_init(void)
  3189. {
  3190. atomic_set(&chandev_initialised,TRUE);
  3191. chandev_parse_args();
  3192. chandev_init_default_models();
  3193. #if CONFIG_PROC_FS
  3194. chandev_create_proc();
  3195. #endif
  3196. chandev_msck_task_tq.routine=
  3197. chandev_msck_task;
  3198. #if LINUX_VERSION_CODE>=KERNEL_VERSION(2,3,0)
  3199. INIT_LIST_HEAD(&chandev_msck_task_tq.list);
  3200. chandev_msck_task_tq.sync=0;
  3201. #endif
  3202. chandev_msck_task_tq.data=NULL;
  3203. chandev_last_startmsck_list_update=chandev_last_machine_check=jiffies-HZ;
  3204. atomic_set(&chandev_msck_thread_lock,1);
  3205. chandev_lock_owner=CHANDEV_INVALID_LOCK_OWNER;
  3206. chandev_lock_cnt=0;
  3207. spin_lock_init(&chandev_spinlock);
  3208. spin_lock_init(&chandev_not_oper_spinlock);
  3209. atomic_set(&chandev_new_msck,FALSE);
  3210. return(0);
  3211. }
  3212. #if LINUX_VERSION_CODE>=KERNEL_VERSION(2,3,0)
  3213. __initcall(chandev_init);
  3214. #endif
  3216. int chandev_register_and_probe(chandev_probefunc probefunc,
  3217.        chandev_shutdownfunc shutdownfunc,
  3218.        chandev_msck_notification_func msck_notfunc,
  3219.        chandev_type chan_type)
  3220. {
  3221. chandev_probelist *new_probe,*curr_probe;
  3222. /* Avoid chicked & egg situations where we may be called before we */
  3223. /* are initialised. */
  3225. chandev_interrupt_check();
  3226. if(!atomic_compare_and_swap(FALSE,TRUE,&chandev_initialised))
  3227. chandev_init();
  3228. chandev_lock();
  3229. for_each(curr_probe,chandev_probelist_head)
  3230. {
  3231. if(curr_probe->probefunc==probefunc)
  3232. {
  3233. chandev_unlock();
  3234. printk("chandev_register_and_probe detected duplicate probefunc %p"
  3235.        " for chan_type  0x%02x n",probefunc,chan_type);
  3236. return (-EPERM);
  3237. }
  3238. }
  3239. chandev_unlock();
  3240. if((new_probe=chandev_alloc(sizeof(chandev_probelist))))
  3241. {
  3242. new_probe->probefunc=probefunc;
  3243. new_probe->shutdownfunc=shutdownfunc;
  3244. new_probe->msck_notfunc=msck_notfunc;
  3245. new_probe->chan_type=chan_type;
  3246. new_probe->devices_found=0;
  3247. chandev_add_to_list((list **)&chandev_probelist_head,new_probe);
  3248. chandev_probe();
  3249. }
  3250. return(new_probe ? new_probe->devices_found:-ENOMEM);
  3251. }
  3253. void chandev_unregister(chandev_probefunc probefunc,int call_shutdown)
  3254. {
  3255. chandev_probelist *curr_probe;
  3256. chandev_activelist *curr_device,*next_device;
  3258. chandev_interrupt_check();
  3259. chandev_lock();
  3260. for_each(curr_probe,chandev_probelist_head)
  3261. {
  3262. if(curr_probe->probefunc==probefunc)
  3263. {
  3264. for_each_allow_delete(curr_device,next_device,chandev_activelist_head)
  3265. if(curr_device->probefunc==probefunc&&call_shutdown)
  3266. chandev_shutdown(curr_device);
  3267. chandev_free_listmember((list **)&chandev_probelist_head,
  3268. (list *)curr_probe);
  3269. break;
  3270. }
  3271. }
  3272. chandev_unlock();
  3273. }
  3276. int chandev_persist(chandev_type chan_type)
  3277. {
  3278. return((chandev_persistent&chan_type) ? TRUE:FALSE);
  3279. }
  3281. EXPORT_SYMBOL(chandev_register_and_probe);
  3282. EXPORT_SYMBOL(chandev_request_irq);
  3283. EXPORT_SYMBOL(chandev_unregister);
  3284. EXPORT_SYMBOL(chandev_initdevice);
  3285. EXPORT_SYMBOL(chandev_build_device_name);
  3286. EXPORT_SYMBOL(chandev_initnetdevice);
  3287. EXPORT_SYMBOL(chandev_init_netdev);
  3288. EXPORT_SYMBOL(chandev_use_devno_names);
  3289. EXPORT_SYMBOL(chandev_free_irq);
  3290. EXPORT_SYMBOL(chandev_add_model);
  3291. EXPORT_SYMBOL(chandev_del_model);
  3292. EXPORT_SYMBOL(chandev_persist);