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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
tape.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：34k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

tape.c：源码内容
  2. /***********************************************************************
  3.  *  drivers/s390/char/tape.c
  4.  *    tape device driver for S/390 and zSeries tapes.
  5.  *
  6.  *  S390 and zSeries version
  7.  *    Copyright (C) 2001 IBM Corporation
  8.  *    Author(s): Carsten Otte <cotte@de.ibm.com>
  9.  *               Tuan Ngo-Anh <ngoanh@de.ibm.com>
  10.  *
  11.  ***********************************************************************
  12.  */
  14. #include "tapedefs.h"
  16. #include <linux/config.h>
  17. #include <linux/stddef.h>
  18. #include <linux/kernel.h>
  19. #include <linux/version.h>
  20. #include <linux/proc_fs.h>
  21. #include <linux/init.h>
  22. #include <asm/types.h>
  23. #include <asm/ccwcache.h>
  24. #include <asm/idals.h>
  25. #include <asm/ebcdic.h>
  26. #include <linux/compatmac.h>
  27. #ifdef MODULE
  28. #include <linux/module.h>
  29. #endif   
  30. #include <asm/debug.h>
  31. #ifdef CONFIG_S390_TAPE_DYNAMIC
  32. #include <asm/s390dyn.h>
  33. #endif
  34. #include "tape.h"
  35. #ifdef CONFIG_S390_TAPE_3490
  36. #include "tape3490.h"
  37. #endif
  38. #ifdef CONFIG_S390_TAPE_3480
  39. #include "tape3480.h"
  40. #endif
  41. #ifdef CONFIG_S390_TAPE_BLOCK
  42. #include "tapeblock.h"
  43. #endif
  44. #ifdef CONFIG_S390_TAPE_CHAR
  45. #include "tapechar.h"
  46. #endif
  47. #ifdef CONFIG_PROC_FS
  48. #include <linux/vmalloc.h>
  49. #endif
  50. #define PRINTK_HEADER "T390:"
  53. /* state handling routines */
  54. inline void tapestate_set (tape_info_t * ti, int newstate);
  55. inline int tapestate_get (tape_info_t * ti);
  56. void tapestate_event (tape_info_t * ti, int event);
  58. /* our globals */
  59. tape_info_t *first_tape_info = NULL;
  60. tape_discipline_t *first_discipline = NULL;
  61. tape_frontend_t *first_frontend = NULL;
  62. devreg_t* tape_devreg[128];
  63. int devregct=0;
  65. #ifdef TAPE_DEBUG
  66. debug_info_t *tape_debug_area = NULL;
  67. #endif
  69. char* state_verbose[TS_SIZE]={
  70.     "TS_UNUSED",  "TS_IDLE", "TS_DONE", "TS_FAILED",
  71.     "TS_BLOCK_INIT",
  72.     "TS_BSB_INIT",
  73.     "TS_BSF_INIT",
  74.     "TS_DSE_INIT",
  75.     "TS_EGA_INIT",
  76.     "TS_FSB_INIT",
  77.     "TS_FSF_INIT",
  78.     "TS_LDI_INIT",
  79.     "TS_LBL_INIT",
  80.     "TS_MSE_INIT",
  81.     "TS_NOP_INIT",
  82.     "TS_RBA_INIT",
  83.     "TS_RBI_INIT",
  84.     "TS_RBU_INIT",
  85.     "TS_RBL_INIT",
  86.     "TS_RDC_INIT",
  87.     "TS_RFO_INIT",
  88.     "TS_RSD_INIT",
  89.     "TS_REW_INIT",
  90.     "TS_REW_RELEASE_INIT",
  91.     "TS_RUN_INIT",
  92.     "TS_SEN_INIT",
  93.     "TS_SID_INIT",
  94.     "TS_SNP_INIT",
  95.     "TS_SPG_INIT",
  96.     "TS_SWI_INIT",
  97.     "TS_SMR_INIT",
  98.     "TS_SYN_INIT",
  99.     "TS_TIO_INIT",
  100.     "TS_UNA_INIT",
  101.     "TS_WRI_INIT",
  102.     "TS_WTM_INIT",
  103.     "TS_NOT_OPER"};
  105. char* event_verbose[TE_SIZE]= {
  106.     "TE_START", "TE_DONE", "TE_FAILED", "TE_ERROR", "TE_OTHER"};
  108. /* our root devfs handle */
  109. #ifdef CONFIG_DEVFS_FS
  110. devfs_handle_t tape_devfs_root_entry;
  112. inline void
  113. tape_mkdevfsroots (tape_info_t* ti) 
  114. {
  115.     char devno [5];
  116.     sprintf (devno,"%04x",ti->devinfo.devno);
  117.     ti->devfs_dir=devfs_mk_dir (tape_devfs_root_entry, devno, ti);
  118. }
  120. inline void
  121. tape_rmdevfsroots (tape_info_t* ti)
  122. {
  123.     devfs_unregister (ti->devfs_dir);
  124. }
  125. #endif
  127. #ifdef CONFIG_PROC_FS
  128. /* our proc tapedevices entry */
  129. static struct proc_dir_entry *tape_devices_entry;
  131. typedef struct {
  132. char *data;
  133. int len;
  134. } tempinfo_t;
  137. static int
  138. tape_devices_open (struct inode *inode, struct file *file)
  139. {
  140.     int size=80;
  141.     tape_info_t* ti;
  142.     tempinfo_t* tempinfo;
  143.     char* data;
  144.     int pos=0;
  145.     tempinfo = kmalloc (sizeof(tempinfo_t),GFP_KERNEL);
  146.     if (!tempinfo)
  147.         return -ENOMEM;
  148.     for (ti=first_tape_info;ti!=NULL;ti=ti->next)
  149.         size+=80; // FIXME: Guess better!
  150.     data=vmalloc(size);
  151.     if (!data) {
  152.         kfree (tempinfo);
  153.         return -ENOMEM;
  154.     }
  155.     pos+=sprintf(data+pos,"TapeNotDevNotCuTypetCuModeltDevTypetDevModeltStaten");
  156.     for (ti=first_tape_info;ti!=NULL;ti=ti->next) {
  157.         pos+=sprintf(data+pos,"%dt%04Xt%04Xt%02Xt%04Xt%02Xtt%sn",ti->rew_minor/2,
  158.                      ti->devinfo.devno,ti->devinfo.sid_data.cu_type,
  159.                      ti->devinfo.sid_data.cu_model,ti->devinfo.sid_data.dev_type,
  160.                      ti->devinfo.sid_data.dev_model,((tapestate_get(ti) >= 0) &&
  161.                                                        (tapestate_get(ti) < TS_SIZE)) ?
  162.                      state_verbose[tapestate_get (ti)] : "TS UNKNOWN");
  163.     }
  164.     tempinfo->len=pos;
  165.     tempinfo->data=data;
  166.     file->private_data= (void*) tempinfo;
  167. #ifdef MODULE
  168.     MOD_INC_USE_COUNT;
  169. #endif
  170.     return 0;
  171. }
  173. static ssize_t
  174. tape_devices_read (struct file *file, char *user_buf, size_t user_len, loff_t * offset)
  175. {
  176. loff_t len;
  177. tempinfo_t *p_info = (tempinfo_t *) file->private_data;
  179. if (*offset >= p_info->len) {
  180. return 0; /* EOF */
  181. } else {
  182. len =  user_len<(p_info->len - *offset)?user_len:(p_info->len - *offset);
  183. if (copy_to_user (user_buf, &(p_info->data[*offset]), len))
  184. return -EFAULT;
  185. (*offset) += len;
  186. return len; /* number of bytes "read" */
  187. }
  188. }
  190. static int
  191. tape_devices_release (struct inode *inode, struct file *file)
  192. {
  193. int rc = 0;
  194. tempinfo_t *p_info = (tempinfo_t *) file->private_data;
  195. if (p_info) {
  196. if (p_info->data)
  197. vfree (p_info->data);
  198. kfree (p_info);
  199. }
  200. #ifdef MODULE
  201.         MOD_DEC_USE_COUNT;
  202. #endif
  203. return rc;
  204. }
  206. static struct file_operations tape_devices_file_ops =
  207. {
  208. read:tape_devices_read, /* read */
  209. open:tape_devices_open, /* open */
  210. release:tape_devices_release, /* close */
  211. };
  213. static struct inode_operations tape_devices_inode_ops =
  214. {
  215. #if !(LINUX_VERSION_CODE > KERNEL_VERSION(2,3,98))
  216. default_file_ops:&tape_devices_file_ops /* file ops */
  217. #endif /* LINUX_IS_24 */
  218. };
  219. #endif /* CONFIG_PROC_FS */
  221. /* SECTION: Parameters for tape */
  222. char *tape[256] = { NULL, };
  224. #ifndef MODULE
  225. static char tape_parm_string[1024] __initdata = { 0, };
  226. static void
  227. tape_split_parm_string (char *str)
  228. {
  229. char *tmp = str;
  230. int count = 0;
  231. while (tmp != NULL && *tmp != '') {
  232. char *end;
  233. int len;
  234. end = strchr (tmp, ',');
  235. if (end == NULL) {
  236. len = strlen (tmp) + 1;
  237. } else {
  238. len = (long) end - (long) tmp + 1;
  239. *end = '';
  240. end++;
  241. }
  242. tape[count] = kmalloc (len * sizeof (char), GFP_ATOMIC);
  243. if (tape[count] == NULL) {
  244. printk (KERN_WARNING PRINTK_HEADER
  245. "can't store tape= parameter no %dn",
  246. count + 1);
  247. break;
  248. }
  249. memset (tape[count], 0, len * sizeof (char));
  250. memcpy (tape[count], tmp, len * sizeof (char));
  251. count++;
  252. tmp = end;
  253. };
  254. }
  256. void __init
  257. tape_parm_setup (char *str, int *ints)
  258. {
  259. int len = strlen (tape_parm_string);
  260. if (len != 0) {
  261. strcat (tape_parm_string, ",");
  262. }
  263. strcat (tape_parm_string, str);
  264. }
  266. int __init
  267. tape_parm_call_setup (char *str)
  268. {
  269. int dummy;
  270. tape_parm_setup (str, &dummy);
  271. return 1;
  272. }
  274. #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,2,16))
  275. __setup("tape=", tape_parm_call_setup);
  276. #endif   /* kernel <2.2.19 */
  277. #endif   /* not defined MODULE */
  279. static inline int
  280. tape_parm_strtoul (char *str, char **stra)
  281. {
  282. char *temp = str;
  283. int val;
  284. if (*temp == '0') {
  285. temp++; /* strip leading zero */
  286. if (*temp == 'x')
  287. temp++; /* strip leading x */
  288. }
  289. val = simple_strtoul (temp, &temp, 16); /* interpret anything as hex */
  290. *stra = temp;
  291. return val;
  292. }
  294. static inline devreg_t *
  295. tape_create_devreg (int devno)
  296. {
  297. devreg_t *devreg = kmalloc (sizeof (devreg_t), GFP_KERNEL);
  298. if (devreg != NULL) {
  299. memset (devreg, 0, sizeof (devreg_t));
  300. devreg->ci.devno = devno;
  301. devreg->flag = DEVREG_TYPE_DEVNO;
  302. devreg->oper_func = tape_oper_handler;
  303. }
  304. return devreg;
  305. }
  307. static inline void
  308. tape_parm_parse (char **str)
  309. {
  310. char *temp;
  311. int from, to,i,irq=0,rc,retries=0,tape_num=0;
  312.         s390_dev_info_t dinfo;
  313.         tape_info_t* ti,*tempti;
  314.         tape_discipline_t* disc;
  315.         long lockflags;
  316. if (*str==NULL) {
  317.             /* no params present -> leave */
  318.             return;
  319. }
  320. while (*str) {
  321. temp = *str;
  322. from = 0;
  323. to = 0;
  325.                 /* turn off autodetect mode, if any range is present */
  326.                 from = tape_parm_strtoul (temp, &temp);
  327.                 to = from;
  328.                 if (*temp == '-') {
  329.                     temp++;
  330.                     to = tape_parm_strtoul (temp, &temp);
  331.                 }
  332.                 for (i=from;i<=to;i++) {
  333.                     retries=0;
  334.                     // register for attch/detach of a devno
  335.                     tape_devreg[devregct]=tape_create_devreg(i);
  336.                     if (tape_devreg[devregct]==NULL) {
  337.                         PRINT_WARN ("Could not create devreg for devno %04x, dyn. attach for this devno deactivated.n",i);
  338.                     } else {
  339.                         s390_device_register (tape_devreg[devregct++]);
  340.                     }
  341.                     // we are activating a device if it is present
  342.                     for (irq = get_irq_first(); irq!=-ENODEV; irq=get_irq_next(irq)) {
  343.                         rc = get_dev_info_by_irq (irq, &dinfo);
  344.                      
  345.                         disc = first_discipline;
  346.                         while ((dinfo.devno == i) && (disc != NULL) && (disc->cu_type != dinfo.sid_data.cu_type))
  347.                             disc = (tape_discipline_t *) (disc->next);
  348.                         if ((disc == NULL) || (rc == -ENODEV) || (i!=dinfo.devno)) {
  349.                             continue;
  350.                         }
  351. #ifdef TAPE_DEBUG
  352.                         debug_text_event (tape_debug_area,3,"det irq:  ");
  353.                         debug_int_event (tape_debug_area,3,irq);
  354.                         debug_text_event (tape_debug_area,3,"cu:       ");
  355.                         debug_int_event (tape_debug_area,3,disc->cu_type);
  356. #endif /* TAPE_DEBUG */
  357.                         PRINT_INFO ("using devno %04x with discipline %04x on irq %d as tape device %dn",dinfo.devno,dinfo.sid_data.cu_type,irq,tape_num/2);
  358.                         /* Allocate tape structure  */
  359.                         ti = kmalloc (sizeof (tape_info_t), GFP_ATOMIC);
  360.                         if (ti == NULL) {
  361. #ifdef TAPE_DEBUG
  362.                             debug_text_exception (tape_debug_area,3,"ti:no mem ");
  363. #endif /* TAPE_DEBUG */
  364.                             PRINT_INFO ("tape: can't allocate memory for "
  365.                                         "tape info structuren");
  366.                             continue;
  367.                         }
  368.                         memset(ti,0,sizeof(tape_info_t));
  369.                         ti->discipline = disc;
  370.                         disc->tape = ti;
  371.                         rc = tape_setup (ti, irq, tape_num);
  372.                         if (rc) {
  373. #ifdef TAPE_DEBUG
  374.                             debug_text_event (tape_debug_area,3,"tsetup err");
  375.                             debug_int_exception (tape_debug_area,3,rc);
  376. #endif /* TAPE_DEBUG */
  377.                             kfree (ti);
  378.                         } else {
  379.                             s390irq_spin_lock_irqsave (irq, lockflags);
  380.                             if (first_tape_info == NULL) {
  381.                                 first_tape_info = ti;
  382.                             } else {
  383.                                 tempti = first_tape_info;
  384.                                 while (tempti->next != NULL)
  385.                                     tempti = tempti->next;
  386.                                 tempti->next = ti;
  387.                             }
  388.                             s390irq_spin_unlock_irqrestore (irq, lockflags);
  389.                         }
  390.                     }
  391.                     tape_num+=2;
  392.                 }
  393.                 str++;
  394.         }
  395. }
  398. /* SECTION: Managing wrappers for ccwcache */
  400. #define TAPE_EMERGENCY_REQUESTS 16
  402. static ccw_req_t *tape_emergency_req[TAPE_EMERGENCY_REQUESTS] =
  403. {NULL,};
  404. static spinlock_t tape_emergency_req_lock = SPIN_LOCK_UNLOCKED;
  406. static void
  407. tape_init_emergency_req (void)
  408. {
  409. int i;
  410. for (i = 0; i < TAPE_EMERGENCY_REQUESTS; i++) {
  411. tape_emergency_req[i] = (ccw_req_t *) get_free_page (GFP_KERNEL);
  412. }
  413. }
  415. #ifdef MODULE // We only cleanup the emergency requests on module unload.
  416. static void
  417. tape_cleanup_emergency_req (void)
  418. {
  419. int i;
  420. for (i = 0; i < TAPE_EMERGENCY_REQUESTS; i++) {
  421. if (tape_emergency_req[i])
  422. free_page ((long) (tape_emergency_req[i]));
  423. else
  424. printk (KERN_WARNING PRINTK_HEADER "losing one page for 'in-use' emergency requestn");
  425. }
  426. }
  427. #endif
  429. ccw_req_t *
  430. tape_alloc_request (char *magic, int cplength, int datasize)
  431. {
  432. ccw_req_t *rv = NULL;
  433. int i;
  434. if ((rv = ccw_alloc_request (magic, cplength, datasize)) != NULL) {
  435. return rv;
  436. }
  437. if (cplength * sizeof (ccw1_t) + datasize + sizeof (ccw_req_t) > PAGE_SIZE) {
  438. return NULL;
  439. }
  440. spin_lock (&tape_emergency_req_lock);
  441. for (i = 0; i < TAPE_EMERGENCY_REQUESTS; i++) {
  442. if (tape_emergency_req[i] != NULL) {
  443. rv = tape_emergency_req[i];
  444. tape_emergency_req[i] = NULL;
  445. }
  446. }
  447. spin_unlock (&tape_emergency_req_lock);
  448. if (rv) {
  449. memset (rv, 0, PAGE_SIZE);
  450. rv->cache = (kmem_cache_t *) (tape_emergency_req + i);
  451. strncpy ((char *) (&rv->magic), magic, 4);
  452. ASCEBC ((char *) (&rv->magic), 4);
  453. rv->cplength = cplength;
  454. rv->datasize = datasize;
  455. rv->data = (void *) ((long) rv + PAGE_SIZE - datasize);
  456. rv->cpaddr = (ccw1_t *) ((long) rv + sizeof (ccw_req_t));
  457. }
  458. return rv;
  459. }
  461. void
  462. tape_free_request (ccw_req_t * request)
  463. {
  464. if (request->cache >= (kmem_cache_t *) tape_emergency_req &&
  465.     request->cache <= (kmem_cache_t *) (tape_emergency_req + TAPE_EMERGENCY_REQUESTS)) {
  466. *((ccw_req_t **) (request->cache)) = request;
  467. } else {
  468. clear_normalized_cda ((ccw1_t *) (request->cpaddr)); // avoid memory leak caused by modeset_byte
  469. ccw_free_request (request);
  470. }
  471. }
  473. /*
  474.  * Allocate a ccw request and reserve it for tape driver
  475.  */
  476. inline
  477.  ccw_req_t *
  478. tape_alloc_ccw_req (tape_info_t * ti, int cplength, int datasize)
  479. {
  480. char tape_magic_id[] = "tape";
  481. ccw_req_t *cqr = NULL;
  483. if (!ti)
  484. return NULL;
  485. cqr = tape_alloc_request (tape_magic_id, cplength, datasize);
  487. if (!cqr) {
  488. #ifdef TAPE_DEBUG
  489. PRINT_WARN ("empty CQR generatedn");
  490. #endif
  491. }
  492. cqr->magic = TAPE_MAGIC; /* sets an identifier for tape driver   */
  493. cqr->device = ti; /* save pointer to tape info    */
  494. return cqr;
  495. }
  497. /*
  498.  * Find the tape_info_t structure associated with irq
  499.  */
  500. static inline tape_info_t *
  501. tapedev_find_info (int irq)
  502. {
  503. tape_info_t *ti;
  505. ti = first_tape_info;
  506. if (ti != NULL)
  507. do {
  508. if (ti->devinfo.irq == irq)
  509. break;
  510. } while ((ti = (tape_info_t *) ti->next) != NULL);
  511. return ti;
  512. }
  514. #define QUEUE_THRESHOLD 5
  516. /*
  517.  * Tape interrupt routine, called from Ingo's I/O layer
  518.  */
  519. void
  520. tape_irq (int irq, void *int_parm, struct pt_regs *regs)
  521. {
  522. tape_info_t *ti = tapedev_find_info (irq);
  524. /* analyse devstat and fire event */
  525. if (ti->devstat.dstat & DEV_STAT_UNIT_CHECK) {
  526. tapestate_event (ti, TE_ERROR);
  527. } else if (ti->devstat.dstat & (DEV_STAT_DEV_END)) {
  528. tapestate_event (ti, TE_DONE);
  529. } else
  530. tapestate_event (ti, TE_OTHER);
  531. }
  533. int 
  534. tape_oper_handler ( int irq, struct _devreg *dreg) {
  535.     tape_info_t* ti=first_tape_info;
  536.     tape_info_t* newtape;
  537.     int rc,tape_num,retries=0,i;
  538.     s390_dev_info_t dinfo;
  539.     tape_discipline_t* disc;
  540. #ifdef CONFIG_DEVFS_FS
  541.     tape_frontend_t* frontend;
  542. #endif
  543.     long lockflags;
  544.     while ((ti!=NULL) && (ti->devinfo.irq!=irq)) 
  545.         ti=ti->next;
  546.     if (ti!=NULL) {
  547.         // irq is (still) used by tape. tell ingo to try again later
  548.         PRINT_WARN ("Oper handler for irq %d called while irq still (internaly?) used.n",irq);
  549.         return -EAGAIN;
  550.     }
  551.     // irq is not used by tape
  552.     rc = get_dev_info_by_irq (irq, &dinfo);
  553.     if (rc == -ENODEV) {
  554.         retries++;
  555.         rc = get_dev_info_by_irq (irq, &dinfo);
  556.         if (retries > 5) {
  557.             PRINT_WARN ("No device information for new dev. could be retrieved.n");
  558.             return -ENODEV;
  559.         }
  560.     }
  561.     disc = first_discipline;
  562.     while ((disc != NULL) && (disc->cu_type != dinfo.sid_data.cu_type))
  563.         disc = (tape_discipline_t *) (disc->next);
  564.     if (disc == NULL)
  565.         PRINT_WARN ("No matching discipline for cu_type %x found, ignoring device %04x.n",dinfo.sid_data.cu_type,dinfo.devno);
  566.     if (rc == -ENODEV) 
  567.         PRINT_WARN ("No device information for new dev. could be retrieved.n");
  568.     if ((disc == NULL) || (rc == -ENODEV))
  569.         return -ENODEV;
  570.     
  571.     /* Allocate tape structure  */
  572.     ti = kmalloc (sizeof (tape_info_t), GFP_ATOMIC);
  573.     if (ti == NULL) {
  574.         PRINT_INFO ( "tape: can't allocate memory for "
  575.                     "tape info structuren");
  576.         return -ENOBUFS;
  577.     }
  578.     memset(ti,0,sizeof(tape_info_t));
  579.     ti->discipline = disc;
  580.     disc->tape = ti;
  581.     tape_num=0;
  582.     if (*tape) {
  583.         // we have static device ranges, so fingure out the tape_num of the attached tape
  584.         for (i=0;i<devregct;i++)
  585.             if (tape_devreg[i]->ci.devno==dinfo.devno) {
  586.                 tape_num=2*i;
  587.                 break;
  588.             }
  589.     } else {
  590.         // we are running in autoprobe mode, find a free tape_num
  591.         newtape=first_tape_info;
  592.         while (newtape!=NULL) {
  593.             if (newtape->rew_minor==tape_num) {
  594.                 // tape num in use. try next one
  595.                 tape_num+=2;
  596.                 newtape=first_tape_info;
  597.             } else {
  598.                 // tape num not used by newtape. look at next tape info
  599.                 newtape=newtape->next;
  600.             }
  601.         }
  602.     }
  603.     rc = tape_setup (ti, irq, tape_num);
  604.     if (rc) {
  605.         kfree (ti);
  606.         return -ENOBUFS;
  607.     }
  608. #ifdef CONFIG_DEVFS_FS
  609.     for (frontend=first_frontend;frontend!=NULL;frontend=frontend->next) 
  610.         frontend->mkdevfstree(ti);
  611. #endif
  612.     s390irq_spin_lock_irqsave (irq,lockflags);
  613.     if (first_tape_info == NULL) {
  614.         first_tape_info = ti;
  615.     } else {
  616.         newtape = first_tape_info;
  617.         while (newtape->next != NULL)
  618.             newtape = newtape->next;
  619.         newtape->next = ti;
  620.     }
  621.     s390irq_spin_unlock_irqrestore (irq, lockflags);
  622.     return 0;
  623. }
  626. static void
  627. tape_noper_handler ( int irq, int status ) {
  628.     tape_info_t *ti=first_tape_info;
  629.     tape_info_t *lastti;
  630. #ifdef CONFIG_DEVFS_FS
  631.     tape_frontend_t *frontend;
  632. #endif
  633.     long lockflags;
  634.     s390irq_spin_lock_irqsave(irq,lockflags);
  635.     while (ti!=NULL && ti->devinfo.irq!=irq) ti=ti->next;
  636.     if (ti==NULL) return;
  637.     if (tapestate_get(ti)!=TS_UNUSED) {
  638.         // device is in use!
  639.         PRINT_WARN ("Tape #%d was detached while it was busy. Expect errors!",ti->blk_minor/2);
  640.         tapestate_set(ti,TS_NOT_OPER);
  641.         ti->rc=-ENODEV; 
  642. ti->wanna_wakeup=1;
  643. switch (tapestate_get(ti)) {
  644. case TS_REW_RELEASE_INIT:
  645.     tapestate_set(ti,TS_NOT_OPER);
  646.     wake_up (&ti->wq);
  647.     break;
  648. #ifdef CONFIG_S390_TAPE_BLOCK
  649. case TS_BLOCK_INIT:
  650.     tapestate_set(ti,TS_NOT_OPER);
  651.     schedule_tapeblock_exec_IO(ti);
  652.     break;
  653. #endif
  654. default:
  655.     tapestate_set(ti,TS_NOT_OPER);
  656.     wake_up_interruptible (&ti->wq);
  657. }
  658.     } else {
  659.         // device is unused!
  660.         PRINT_WARN ("Tape #%d was detached.n",ti->blk_minor/2);
  661.         if (ti==first_tape_info) {
  662.             first_tape_info=ti->next;
  663.         } else {
  664.             lastti=first_tape_info;
  665.             while (lastti->next!=ti) lastti=lastti->next;
  666.             lastti->next=ti->next;
  667.         }
  668. #ifdef CONFIG_DEVFS_FS
  669.         for (frontend=first_frontend;frontend!=NULL;frontend=frontend->next)
  670.             frontend->rmdevfstree(ti);
  671.         tape_rmdevfsroots(ti);
  672. #endif
  673.         kfree(ti);
  674.     }
  675.     s390irq_spin_unlock_irqrestore(irq,lockflags);
  676.     return;
  677. }
  680. void
  681. tape_dump_sense (devstat_t * stat)
  682. {
  683. #ifdef TAPE_DEBUG
  684.         int sl;
  685. #endif
  686. #if 0
  688. PRINT_WARN ("------------I/O resulted in unit check:-----------n");
  689. for (sl = 0; sl < 4; sl++) {
  690. PRINT_WARN ("Sense:");
  691. for (sct = 0; sct < 8; sct++) {
  692. PRINT_WARN (" %2d:0x%02X", 8 * sl + sct,
  693.     stat->ii.sense.data[8 * sl + sct]);
  694. }
  695. PRINT_WARN ("n");
  696. }
  697. PRINT_INFO ("Sense data: %02X%02X%02X%02X %02X%02X%02X%02X "
  698.     " %02X%02X%02X%02X %02X%02X%02X%02X n",
  699.     stat->ii.sense.data[0], stat->ii.sense.data[1],
  700.     stat->ii.sense.data[2], stat->ii.sense.data[3],
  701.     stat->ii.sense.data[4], stat->ii.sense.data[5],
  702.     stat->ii.sense.data[6], stat->ii.sense.data[7],
  703.     stat->ii.sense.data[8], stat->ii.sense.data[9],
  704.     stat->ii.sense.data[10], stat->ii.sense.data[11],
  705.     stat->ii.sense.data[12], stat->ii.sense.data[13],
  706.     stat->ii.sense.data[14], stat->ii.sense.data[15]);
  707. PRINT_INFO ("Sense data: %02X%02X%02X%02X %02X%02X%02X%02X "
  708.     " %02X%02X%02X%02X %02X%02X%02X%02X n",
  709.     stat->ii.sense.data[16], stat->ii.sense.data[17],
  710.     stat->ii.sense.data[18], stat->ii.sense.data[19],
  711.     stat->ii.sense.data[20], stat->ii.sense.data[21],
  712.     stat->ii.sense.data[22], stat->ii.sense.data[23],
  713.     stat->ii.sense.data[24], stat->ii.sense.data[25],
  714.     stat->ii.sense.data[26], stat->ii.sense.data[27],
  715.     stat->ii.sense.data[28], stat->ii.sense.data[29],
  716.     stat->ii.sense.data[30], stat->ii.sense.data[31]);
  717. #endif
  718. #ifdef TAPE_DEBUG
  719.         debug_text_event (tape_debug_area,3,"SENSE:");
  720.         for (sl=0;sl<31;sl++) {
  721.             debug_int_event (tape_debug_area,3,stat->ii.sense.data[sl]);
  722.         }
  723.         debug_int_exception (tape_debug_area,3,stat->ii.sense.data[31]);
  724. #endif
  725. }
  727. /*
  728.  * Setup tape_info_t structure of a tape device
  729.  */
  730. int
  731. tape_setup (tape_info_t * ti, int irq, int minor)
  732. {
  733. long lockflags;
  734. int rc = 0;
  736.         if (minor>254) {
  737.             PRINT_WARN ("Device id %d on irq %d will not be accessible since this driver is restricted to 128 devices.n",minor/2,irq);
  738.             return -EINVAL;
  739.         }
  740. rc = get_dev_info_by_irq (irq, &(ti->devinfo));
  741. if (rc == -ENODEV) { /* end of device list */
  742. return rc;
  743. }
  744. ti->rew_minor = minor;
  745. ti->nor_minor = minor + 1;
  746. ti->blk_minor = minor;
  747. #ifdef CONFIG_DEVFS_FS
  748.         tape_mkdevfsroots(ti);
  749. #endif
  750. /* Register IRQ */
  751. #ifdef CONFIG_S390_TAPE_DYNAMIC
  752.         rc = s390_request_irq_special (irq, tape_irq, tape_noper_handler,0, "tape", &(ti->devstat));
  753. #else
  754. rc = s390_request_irq (irq, tape_irq, 0, "tape", &(ti->devstat));
  755. #endif
  756. s390irq_spin_lock_irqsave (irq, lockflags);
  757. ti->next = NULL;
  758. if (rc)
  759.             PRINT_WARN ("Cannot register irq %d, rc=%dn", irq, rc);
  760. init_waitqueue_head (&ti->wq);
  761. ti->kernbuf = ti->userbuf = ti->discdata = NULL;
  762. tapestate_set (ti, TS_UNUSED);
  763.         ti->discdata=NULL;
  764. ti->discipline->setup_assist (ti);
  765.         ti->wanna_wakeup=0;
  766. s390irq_spin_unlock_irqrestore (irq, lockflags);
  767. return rc;
  768. }
  770. /*
  771.  *      tape_init will register the driver for each tape.
  772.  */
  773. int
  774. tape_init (void)
  775. {
  776. long lockflags;
  777. s390_dev_info_t dinfo;
  778. tape_discipline_t *disc;
  779. tape_info_t *ti = NULL, *tempti = NULL;
  780.         char *opt_char,*opt_block,*opt_3490,*opt_3480;
  781. int irq = 0, rc, retries = 0, tape_num = 0;
  782.         static int initialized=0;
  784.         if (initialized) // Only init the devices once
  785.             return 0;
  786.         initialized=1;
  788. #ifdef TAPE_DEBUG
  789.         tape_debug_area = debug_register ( "tape", 3, 2, 10);
  790.         debug_register_view(tape_debug_area,&debug_hex_ascii_view);
  791.         debug_text_event (tape_debug_area,3,"begin init");
  792. #endif /* TAPE_DEBUG */
  794.         /* print banner */        
  795.         PRINT_WARN ("IBM S/390 Tape Device Driver (v1.01).n");
  796.         PRINT_WARN ("(C) IBM Deutschland Entwicklung GmbH, 2000n");
  797.         opt_char=opt_block=opt_3480=opt_3490="not present";
  798. #ifdef CONFIG_S390_TAPE_CHAR
  799.         opt_char="built in";
  800. #endif
  801. #ifdef CONFIG_S390_TAPE_BLOCK
  802.         opt_block="built in";
  803. #endif
  804. #ifdef CONFIG_S390_TAPE_3480
  805.         opt_3480="built in";
  806. #endif
  807. #ifdef CONFIG_S390_TAPE_3490
  808.         opt_3490="built in";
  809. #endif
  810.         /* print feature info */
  811.         PRINT_WARN ("character device frontend   : %sn",opt_char);
  812.         PRINT_WARN ("block device frontend       : %sn",opt_block);
  813.         PRINT_WARN ("support for 3480 compatible : %sn",opt_3480);
  814.         PRINT_WARN ("support for 3490 compatible : %sn",opt_3490);
  815.         
  816. #ifndef MODULE
  817.         tape_split_parm_string(tape_parm_string);
  818. #endif
  819.         if (*tape) 
  820.             PRINT_INFO ("Using ranges supplied in parameters, disabling autoprobe mode.n");
  821.         else
  822.             PRINT_INFO ("No parameters supplied, enabling autoprobe mode for all supported devices.n");
  823. #ifdef CONFIG_S390_TAPE_3490
  824.         if (*tape)
  825.             first_discipline = tape3490_init (0); // no autoprobe for devices
  826.         else
  827.             first_discipline = tape3490_init (1); // do autoprobe since no parm specified
  828. first_discipline->next = NULL;
  829. #endif
  831. #ifdef CONFIG_S390_TAPE_3480
  832.         if (first_discipline == NULL) {
  833.             if (*tape)
  834.                 first_discipline = tape3480_init (0); // no autoprobe for devices
  835.             else 
  836.                 first_discipline = tape3480_init (1); // do autoprobe since no parm specified
  837.             first_discipline->next = NULL;
  838.         } else {
  839.             if (*tape)
  840.                 first_discipline->next = tape3480_init (0); // no autoprobe for devices
  841.             else
  842.                 first_discipline->next = tape3480_init (1); // do autoprobe since no parm specified
  843.             ((tape_discipline_t*) (first_discipline->next))->next=NULL;
  844.         }
  845. #endif
  846. #ifdef CONFIG_DEVFS_FS
  847.         tape_devfs_root_entry=devfs_mk_dir (NULL, "tape", NULL);
  848. #endif CONFIG_DEVFS_FS
  850. #ifdef TAPE_DEBUG
  851.         debug_text_event (tape_debug_area,3,"dev detect");
  852. #endif /* TAPE_DEBUG */
  853. /* Allocate the tape structures */
  854.         if (*tape!=NULL) {
  855.             // we have parameters, continue with parsing the parameters and set the devices online
  856.             tape_parm_parse (tape);
  857.         } else {
  858.             // we are running in autodetect mode, search all devices for compatibles
  859.             for (irq = get_irq_first(); irq!=-ENODEV; irq=get_irq_next(irq)) {
  860. rc = get_dev_info_by_irq (irq, &dinfo);
  861. disc = first_discipline;
  862. while ((disc != NULL) && (disc->cu_type != dinfo.sid_data.cu_type))
  863.                     disc = (tape_discipline_t *) (disc->next);
  864. if ((disc == NULL) || (rc == -ENODEV))
  865.                     continue;
  866. #ifdef TAPE_DEBUG
  867.                 debug_text_event (tape_debug_area,3,"det irq:  ");
  868.                 debug_int_event (tape_debug_area,3,irq);
  869.                 debug_text_event (tape_debug_area,3,"cu:       ");
  870.                 debug_int_event (tape_debug_area,3,disc->cu_type);
  871. #endif /* TAPE_DEBUG */
  872.                 PRINT_INFO ("using devno %04x with discipline %04x on irq %d as tape device %dn",dinfo.devno,dinfo.sid_data.cu_type,irq,tape_num/2);
  873. /* Allocate tape structure  */
  874. ti = kmalloc (sizeof (tape_info_t), GFP_ATOMIC);
  875. if (ti == NULL) {
  876. #ifdef TAPE_DEBUG
  877.                     debug_text_exception (tape_debug_area,3,"ti:no mem ");
  878. #endif /* TAPE_DEBUG */
  879.                     PRINT_INFO ("tape: can't allocate memory for "
  880.     "tape info structuren");
  881.                     continue;
  882. }
  883. memset(ti,0,sizeof(tape_info_t));
  884. ti->discipline = disc;
  885. disc->tape = ti;
  886. rc = tape_setup (ti, irq, tape_num);
  887. if (rc) {
  888. #ifdef TAPE_DEBUG
  889.                     debug_text_event (tape_debug_area,3,"tsetup err");
  890.                     debug_int_exception (tape_debug_area,3,rc);
  891. #endif /* TAPE_DEBUG */
  892.                     kfree (ti);
  893. } else {
  894.                     s390irq_spin_lock_irqsave (irq, lockflags);
  895.                     if (first_tape_info == NULL) {
  896.                         first_tape_info = ti;
  897.                     } else {
  898.                         tempti = first_tape_info;
  899.                         while (tempti->next != NULL)
  900.                             tempti = tempti->next;
  901.                         tempti->next = ti;
  902.                     }
  903.                     tape_num += 2;
  904.                     s390irq_spin_unlock_irqrestore (irq, lockflags);
  905. }
  906.             }
  907.         }
  908.             
  909. /* Allocate local buffer for the ccwcache       */
  910. tape_init_emergency_req ();
  911. #ifdef CONFIG_PROC_FS
  912. #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,3,98))
  913. tape_devices_entry = create_proc_entry ("tapedevices",
  914. S_IFREG | S_IRUGO | S_IWUSR,
  915. &proc_root);
  916. tape_devices_entry->proc_fops = &tape_devices_file_ops;
  917. tape_devices_entry->proc_iops = &tape_devices_inode_ops;
  918. #else
  919. tape_devices_entry = (struct proc_dir_entry *) kmalloc 
  920.             (sizeof (struct proc_dir_entry), GFP_ATOMIC);
  921.         if (tape_devices_entry) {
  922.             memset (tape_devices_entry, 0, sizeof (struct proc_dir_entry));
  923.             tape_devices_entry->name = "tapedevices";
  924.             tape_devices_entry->namelen = strlen ("tapedevices");
  925.             tape_devices_entry->low_ino = 0;
  926.             tape_devices_entry->mode = (S_IFREG | S_IRUGO | S_IWUSR);
  927.             tape_devices_entry->nlink = 1;
  928.             tape_devices_entry->uid = 0;
  929.             tape_devices_entry->gid = 0;
  930.             tape_devices_entry->size = 0;
  931.             tape_devices_entry->get_info = NULL;
  932.             tape_devices_entry->ops = &tape_devices_inode_ops;
  933.             proc_register (&proc_root, tape_devices_entry);
  934. }
  935. #endif
  936. #endif /* CONFIG_PROC_FS */
  938. return 0;
  939. }
  941. #ifdef MODULE
  942. MODULE_AUTHOR("(C) 2001 IBM Deutschland Entwicklung GmbH by Carsten Otte (cotte@de.ibm.com)");
  943. MODULE_DESCRIPTION("Linux for S/390 channel attached tape device driver");
  944. MODULE_PARM (tape, "1-" __MODULE_STRING (256) "s");
  946. int
  947. init_module (void)
  948. {
  949. #ifdef CONFIG_S390_TAPE_CHAR
  950. tapechar_init ();
  951. #endif
  952. #ifdef CONFIG_S390_TAPE_BLOCK
  953. tapeblock_init ();
  954. #endif
  955.         return 0;
  956. }
  958. void
  959. cleanup_module (void)
  960. {
  961.         tape_info_t *ti ,*temp;
  962.         tape_frontend_t* frontend, *tempfe;
  963.         tape_discipline_t* disc ,*tempdi;
  964.         int i;
  965. #ifdef TAPE_DEBUG
  966.         debug_text_event (tape_debug_area,6,"cleaup mod");
  967. #endif /* TAPE_DEBUG */
  969.         if (*tape) {
  970.             // we are running with parameters. we'll now deregister from our devno's
  971.             for (i=0;i<devregct;i++) {
  972.                 s390_device_unregister(tape_devreg[devregct]);
  973.             }
  974.         }
  975. ti = first_tape_info;
  976. while (ti != NULL) {
  977. temp = ti;
  978. ti = ti->next;
  979.                 //cleanup a device 
  980. #ifdef TAPE_DEBUG
  981.                 debug_text_event (tape_debug_area,6,"free irq:");
  982.                 debug_int_event (tape_debug_area,6,temp->devinfo.irq);
  983. #endif /* TAPE_DEBUG */
  984. free_irq (temp->devinfo.irq, &(temp->devstat));
  985.                 if (temp->discdata) kfree (temp->discdata);
  986.                 if (temp->kernbuf) kfree (temp->kernbuf);
  987.                 if (temp->cqr) tape_free_request(temp->cqr);
  988. #ifdef CONFIG_DEVFS_FS
  989.                 for (frontend=first_frontend;frontend!=NULL;frontend=frontend->next)
  990.                     frontend->rmdevfstree(temp);
  991.                 tape_rmdevfsroots(temp);
  992. #endif
  993. kfree (temp);
  994. }
  995. #ifdef CONFIG_DEVFS_FS
  996.         devfs_unregister (tape_devfs_root_entry);
  997. #endif CONFIG_DEVFS_FS
  998. #ifdef CONFIG_PROC_FS
  999. #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,3,98))
  1000. remove_proc_entry ("tapedevices", &proc_root);
  1001. #else
  1002. proc_unregister (&proc_root, tape_devices_entry->low_ino);
  1003. kfree (tape_devices_entry);
  1004. #endif /* LINUX_IS_24 */
  1005. #endif 
  1006. #ifdef CONFIG_S390_TAPE_CHAR
  1007. tapechar_uninit();
  1008. #endif
  1009. #ifdef CONFIG_S390_TAPE_BLOCK
  1010.         tapeblock_uninit();
  1011. #endif
  1012.         frontend=first_frontend;
  1013. while (frontend != NULL) {
  1014. tempfe = frontend;
  1015. frontend = frontend->next;
  1016. kfree (tempfe);
  1017. }
  1018.         disc=first_discipline;
  1019. while (disc != NULL) {
  1020.                 if (*tape)
  1021.                     disc->shutdown(0);
  1022.                 else
  1023.                     disc->shutdown(1);
  1024. tempdi = disc;
  1025. disc = disc->next;
  1026. kfree (tempdi);
  1027. }
  1028. /* Deallocate the local buffer for the ccwcache         */
  1029. tape_cleanup_emergency_req ();
  1030. #ifdef TAPE_DEBUG
  1031.         debug_unregister (tape_debug_area);
  1032. #endif /* TAPE_DEBUG */
  1033. }
  1034. #endif /* MODULE */
  1036. inline void
  1037. tapestate_set (tape_info_t * ti, int newstate)
  1038. {
  1039.     if (ti->tape_state == TS_NOT_OPER) {
  1040. #ifdef TAPE_DEBUG
  1041.         debug_text_event (tape_debug_area,3,"ts_set err");
  1042.         debug_text_exception (tape_debug_area,3,"dev n.oper");
  1043. #endif /* TAPE_DEBUG */
  1044.     } else {
  1045. #ifdef TAPE_DEBUG
  1046.         debug_text_event (tape_debug_area,4,"ts. dev:  ");
  1047.         debug_int_event (tape_debug_area,4,ti->blk_minor);
  1048.         debug_text_event (tape_debug_area,4,"old ts:   ");
  1049.         debug_text_event (tape_debug_area,4,(((tapestate_get (ti) < TS_SIZE) &&
  1050.                                              (tapestate_get (ti) >=0 )) ?
  1051.                                             state_verbose[tapestate_get (ti)] :
  1052.                                             "UNKNOWN TS"));
  1053.         debug_text_event (tape_debug_area,4,"new ts:   ");
  1054.         debug_text_event (tape_debug_area,4,(((newstate < TS_SIZE) &&
  1055.                                               (newstate >= 0)) ?
  1056.                                              state_verbose[newstate] :
  1057.                                              "UNKNOWN TS"));
  1058. #endif /* TAPE_DEBUG */
  1059. ti->tape_state = newstate;
  1060.     }
  1061. }
  1063. inline int
  1064. tapestate_get (tape_info_t * ti)
  1065. {
  1066. return (ti->tape_state);
  1067. }
  1069. void
  1070. tapestate_event (tape_info_t * ti, int event)
  1071. {
  1072. #ifdef TAPE_DEBUG
  1073.         debug_text_event (tape_debug_area,6,"te! dev:  ");
  1074.         debug_int_event (tape_debug_area,6,ti->blk_minor);
  1075.         debug_text_event (tape_debug_area,6,"event:");
  1076.         debug_text_event (tape_debug_area,6,((event >=0) &&
  1077.                                             (event < TE_SIZE)) ?
  1078.                          event_verbose[event] : "TE UNKNOWN");
  1079.         debug_text_event (tape_debug_area,6,"state:");
  1080.         debug_text_event (tape_debug_area,6,((tapestate_get(ti) >= 0) &&
  1081.                                             (tapestate_get(ti) < TS_SIZE)) ?
  1082.                          state_verbose[tapestate_get (ti)] :
  1083.                          "TS UNKNOWN");
  1084. #endif /* TAPE_DEBUG */    
  1085.         if (event == TE_ERROR) { 
  1086.             ti->discipline->error_recovery(ti);
  1087.         } else {
  1088.             if ((event >= 0) &&
  1089.                 (event < TE_SIZE) &&
  1090.                 (tapestate_get (ti) >= 0) &&
  1091.                 (tapestate_get (ti) < TS_SIZE) &&
  1092.                 ((*(ti->discipline->event_table))[tapestate_get (ti)][event] != NULL))
  1093. ((*(ti->discipline->event_table))[tapestate_get (ti)][event]) (ti);
  1094.             else {
  1095. #ifdef TAPE_DEBUG
  1096.                 debug_text_exception (tape_debug_area,3,"TE UNEXPEC");
  1097. #endif /* TAPE_DEBUG */
  1098. ti->discipline->default_handler (ti);
  1099.             }
  1100.         }
  1101. }
  1103. /*
  1104.  * Overrides for Emacs so that we follow Linus's tabbing style.
  1105.  * Emacs will notice this stuff at the end of the file and automatically
  1106.  * adjust the settings for this buffer only.  This must remain at the end
  1107.  * of the file.
  1108.  * ---------------------------------------------------------------------------
  1109.  * Local variables:
  1110.  * c-indent-level: 4
  1111.  * c-brace-imaginary-offset: 0
  1112.  * c-brace-offset: -4
  1113.  * c-argdecl-indent: 4
  1114.  * c-label-offset: -4
  1115.  * c-continued-statement-offset: 4
  1116.  * c-continued-brace-offset: 0
  1117.  * indent-tabs-mode: nil
  1118.  * tab-width: 8
  1119.  * End:
  1120.  */