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

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

嵌入式Linux

开发平台：

Unix_Linux

tapeblock.c：源码内容
  2. /***************************************************************************
  3.  *
  4.  *  drivers/s390/char/tapeblock.c
  5.  *    block device frontend for tape device driver
  6.  *
  7.  *  S390 and zSeries version
  8.  *    Copyright (C) 2001 IBM Corporation
  9.  *    Author(s): Carsten Otte <cotte@de.ibm.com>
  10.  *               Tuan Ngo-Anh <ngoanh@de.ibm.com>
  11.  *
  12.  *
  13.  ****************************************************************************
  14.  */
  16. #include "tapedefs.h"
  17. #include <linux/config.h>
  18. #include <linux/blkdev.h>
  19. #include <linux/blk.h>
  20. #include <linux/version.h>
  21. #include <linux/interrupt.h>
  22. #include <asm/ccwcache.h> /* CCW allocations      */
  23. #include <asm/debug.h>
  24. #include <asm/s390dyn.h>
  25. #include <linux/compatmac.h>
  26. #ifdef MODULE
  27. #define __NO_VERSION__
  28. #include <linux/module.h>
  29. #endif
  30. #include "tape.h"
  31. #include "tapeblock.h"
  33. #define PRINTK_HEADER "TBLOCK:"
  35. /*
  36.  * file operation structure for tape devices
  37.  */
  38. #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,3,98))
  39. static struct block_device_operations tapeblock_fops = {
  40. #else
  41. static struct file_operations tapeblock_fops = {
  42. #endif
  43.     owner   : THIS_MODULE,
  44.     open    : tapeblock_open,      /* open */
  45.     release : tapeblock_release,   /* release */
  46.         };
  48. int    tapeblock_major = 0;
  50. #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,3,98))
  51. static void tape_request_fn (request_queue_t * queue);
  52. #else
  53. static void tape_request_fn (void);
  54. #endif
  56. static request_queue_t* tapeblock_getqueue (kdev_t kdev);
  58. #ifdef CONFIG_DEVFS_FS
  59. void
  60. tapeblock_mkdevfstree (tape_info_t* ti) {
  61.     ti->devfs_block_dir=devfs_mk_dir (ti->devfs_dir, "block", ti);
  62.     ti->devfs_disc=devfs_register(ti->devfs_block_dir, "disc",DEVFS_FL_DEFAULT,
  63.     tapeblock_major, ti->blk_minor,
  64.     TAPEBLOCK_DEFAULTMODE, &tapeblock_fops, ti);
  65. }
  67. void
  68. tapeblock_rmdevfstree (tape_info_t* ti) {
  69.     devfs_unregister(ti->devfs_disc);
  70.     devfs_unregister(ti->devfs_block_dir);
  71. }
  72. #endif
  74. void 
  75. tapeblock_setup(tape_info_t* ti) {
  76.     blk_size[tapeblock_major][ti->blk_minor]=0; // this will be detected
  77.     blksize_size[tapeblock_major][ti->blk_minor]=2048; // blocks are 2k by default.
  78.     hardsect_size[tapeblock_major][ti->blk_minor]=512;
  79.     blk_init_queue (&ti->request_queue, tape_request_fn); 
  80.     blk_queue_headactive (&ti->request_queue, 0); 
  81. #ifdef CONFIG_DEVFS_FS
  82.     tapeblock_mkdevfstree(ti);
  83. #endif
  84. }
  86. int
  87. tapeblock_init(void) {
  88.     int result;
  89.     tape_frontend_t* blkfront,*temp;
  90.     tape_info_t* ti;
  92.     tape_init();
  93.     /* Register the tape major number to the kernel */
  94. #ifdef CONFIG_DEVFS_FS
  95.     result = devfs_register_blkdev(tapeblock_major, "tBLK", &tapeblock_fops);
  96. #else
  97.     result = register_blkdev(tapeblock_major, "tBLK", &tapeblock_fops);
  98. #endif
  99.     if (result < 0) {
  100.         PRINT_WARN(KERN_ERR "tape: can't get major %d for block devicen", tapeblock_major);
  101.         panic ("cannot get major number for tape block device");
  102.     }
  103.     if (tapeblock_major == 0) tapeblock_major = result;   /* accept dynamic major number*/
  104.     INIT_BLK_DEV(tapeblock_major,tape_request_fn,tapeblock_getqueue,NULL);
  105.     read_ahead[tapeblock_major]=TAPEBLOCK_READAHEAD;
  106.     PRINT_WARN(KERN_ERR " tape gets major %d for block devicen", result);
  107.     blk_size[tapeblock_major] = (int*) kmalloc (256*sizeof(int),GFP_ATOMIC);
  108.     memset(blk_size[tapeblock_major],0,256*sizeof(int));
  109.     blksize_size[tapeblock_major] = (int*) kmalloc (256*sizeof(int),GFP_ATOMIC);
  110.     memset(blksize_size[tapeblock_major],0,256*sizeof(int));
  111.     hardsect_size[tapeblock_major] = (int*) kmalloc (256*sizeof(int),GFP_ATOMIC);
  112.     memset(hardsect_size[tapeblock_major],0,256*sizeof(int));
  113.     max_sectors[tapeblock_major] = (int*) kmalloc (256*sizeof(int),GFP_ATOMIC);
  114.     memset(max_sectors[tapeblock_major],0,256*sizeof(int));
  115.     blkfront = kmalloc(sizeof(tape_frontend_t),GFP_KERNEL);
  116.     if (blkfront==NULL) panic ("no mem for tape block device structure");
  117.     blkfront->device_setup=tapeblock_setup;
  118. #ifdef CONFIG_DEVFS_FS
  119.     blkfront->mkdevfstree = tapeblock_mkdevfstree;
  120.     blkfront->rmdevfstree = tapeblock_rmdevfstree;
  121. #endif
  122.     blkfront->next=NULL;
  123.     if (first_frontend==NULL) {
  124. first_frontend=blkfront;
  125.     } else {
  126. temp=first_frontend;
  127. while (temp->next!=NULL)
  128. temp=temp->next;
  129. temp->next=blkfront;
  130.     }
  131.     ti=first_tape_info;
  132.     while (ti!=NULL) {
  133. tapeblock_setup(ti);
  134. ti=ti->next;
  135.     }
  136.     return 0;
  137. }
  140. void 
  141. tapeblock_uninit(void) {
  142.     unregister_blkdev(tapeblock_major, "tBLK");
  143. }
  145. int
  146. tapeblock_open(struct inode *inode, struct file *filp) {
  147.     tape_info_t *ti;
  148.     kdev_t dev;
  149.     int rc;
  150.     long lockflags;
  152.     inode = filp->f_dentry->d_inode;
  153.     ti = first_tape_info;
  154.     while ((ti != NULL) && (ti->blk_minor != MINOR (inode->i_rdev)))
  155. ti = (tape_info_t *) ti->next;
  156. if (ti == NULL)
  157. return -ENODEV;
  158. #ifdef TAPE_DEBUG
  159. debug_text_event (tape_debug_area,6,"b:open:");
  160. debug_int_event (tape_debug_area,6,ti->blk_minor);
  161. #endif
  162. s390irq_spin_lock_irqsave (ti->devinfo.irq, lockflags);
  163. if (tapestate_get (ti) != TS_UNUSED) {
  164. s390irq_spin_unlock_irqrestore (ti->devinfo.irq, lockflags);
  165. #ifdef TAPE_DEBUG
  166. debug_text_event (tape_debug_area,6,"b:dbusy");
  167. #endif
  168. return -EBUSY;
  169. }
  170. tapestate_set (ti, TS_IDLE);
  171.         ti->position=-1;
  172.         
  173. s390irq_spin_unlock_irqrestore (ti->devinfo.irq, lockflags);
  174.         rc=tapeblock_mediumdetect(ti);
  175.         if (rc) {
  176.     s390irq_spin_lock_irqsave (ti->devinfo.irq, lockflags);
  177.     tapestate_set (ti, TS_UNUSED);
  178.     s390irq_spin_unlock_irqrestore (ti->devinfo.irq, lockflags);
  179.     return rc; // in case of errors, we don't have a size of the medium
  180. }
  181. dev = MKDEV (tapeblock_major, MINOR (inode->i_rdev)); /* Get the device */
  182. s390irq_spin_lock_irqsave (ti->devinfo.irq, lockflags);
  183. ti->blk_filp = filp;
  184. filp->private_data = ti; /* save the dev.info for later reference */
  185.         ti->cqr=NULL;
  186. s390irq_spin_unlock_irqrestore (ti->devinfo.irq, lockflags);
  187.     
  188. return 0;
  189. }
  191. int
  192. tapeblock_release(struct inode *inode, struct file *filp) {
  193. long lockflags;
  194. tape_info_t *ti,*lastti;
  195. ti = first_tape_info;
  196. while ((ti != NULL) && (ti->blk_minor != MINOR (inode->i_rdev)))
  197. ti = (tape_info_t *) ti->next;
  198. if ((ti != NULL) && (tapestate_get (ti) == TS_NOT_OPER)) {
  199.     if (ti==first_tape_info) {
  200. first_tape_info=ti->next;
  201.     } else {
  202. lastti=first_tape_info;
  203. while (lastti->next!=ti) lastti=lastti->next;
  204. lastti->next=ti->next;
  205.     }
  206.     kfree(ti);    
  207.     return 0;
  208. }
  209. if ((ti == NULL) || (tapestate_get (ti) != TS_IDLE)) {
  210. #ifdef TAPE_DEBUG
  211. debug_text_event (tape_debug_area,3,"b:notidle!");
  212. #endif
  213. return -ENXIO; /* error in tape_release */
  214. }
  215. #ifdef TAPE_DEBUG
  216. debug_text_event (tape_debug_area,6,"b:release:");
  217. debug_int_event (tape_debug_area,6,ti->blk_minor);
  218. #endif
  219. s390irq_spin_lock_irqsave (ti->devinfo.irq, lockflags);
  220. tapestate_set (ti, TS_UNUSED);
  221. s390irq_spin_unlock_irqrestore (ti->devinfo.irq, lockflags);
  222. invalidate_buffers(inode->i_rdev);
  223. return 0;
  224. }
  226. static void
  227. tapeblock_end_request(tape_info_t* ti) {
  228.     struct buffer_head *bh;
  229.     int uptodate;
  230.     if ((tapestate_get(ti)!=TS_FAILED) &&
  231. (tapestate_get(ti)!=TS_DONE))
  232.        BUG(); // A request has to be completed to end it
  233.     uptodate=(tapestate_get(ti)==TS_DONE); // is the buffer up to date?
  234. #ifdef TAPE_DEBUG
  235.     if (uptodate) {
  236. debug_text_event (tape_debug_area,6,"b:done:");
  237. debug_int_event (tape_debug_area,6,(long)ti->cqr);
  238.     } else {
  239. debug_text_event (tape_debug_area,3,"b:failed:");
  240. debug_int_event (tape_debug_area,3,(long)ti->cqr);
  241.     }
  242. #endif
  243.     // now inform ll_rw_block about a request status
  244.     while ((bh = ti->current_request->bh) != NULL) {
  245. ti->current_request->bh = bh->b_reqnext;
  246. bh->b_reqnext = NULL;
  247. bh->b_end_io (bh, uptodate);
  248.     }
  249.     if (!end_that_request_first (ti->current_request, uptodate, "tBLK")) {
  250. #ifndef DEVICE_NO_RANDOM
  251. add_blkdev_randomness (MAJOR (ti->current_request->rq_dev));
  252. #endif
  253. end_that_request_last (ti->current_request);
  254.     }
  255.     ti->discipline->free_bread(ti->cqr,ti);
  256.     ti->cqr=NULL;
  257.     ti->current_request=NULL;
  258.     if (tapestate_get(ti)!=TS_NOT_OPER) tapestate_set(ti,TS_IDLE);
  259.     return;
  260. }
  262. static void
  263. tapeblock_exec_IO (tape_info_t* ti) {
  264.     int rc;
  265.     struct request* req;
  266.     if (ti->cqr) { // process done/failed request
  267. while ((tapestate_get(ti)==TS_FAILED) &&
  268.     ti->blk_retries>0) {
  269.     ti->blk_retries--;
  270.     ti->position=-1;
  271.     tapestate_set(ti,TS_BLOCK_INIT);
  272. #ifdef TAPE_DEBUG
  273.     debug_text_event (tape_debug_area,3,"b:retryreq:");
  274.     debug_int_event (tape_debug_area,3,(long)ti->cqr);
  275. #endif
  276.     rc = do_IO (ti->devinfo.irq, ti->cqr->cpaddr, (unsigned long) ti->cqr, 
  277. 0x00, ti->cqr->options);
  278.     if (rc) {
  279. #ifdef TAPE_DEBUG
  280. debug_text_event (tape_debug_area,3,"b:doIOfail:");
  281. debug_int_event (tape_debug_area,3,(long)ti->cqr);
  282. #endif 
  283. continue; // one retry lost 'cause doIO failed
  284.     }
  285.     return;
  286. }
  287. tapeblock_end_request (ti); // check state, inform user, free mem, dev=idl
  288.     }
  289.     if (ti->cqr!=NULL) BUG(); // tape should be idle now, request should be freed!
  290.     if (tapestate_get (ti) == TS_NOT_OPER) {
  291. ti->blk_minor=ti->rew_minor=ti->nor_minor=-1;
  292. ti->devinfo.irq=-1;
  293. return;
  294.     }
  295. #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,3,98))
  296. if (list_empty (&ti->request_queue.queue_head)) {
  297. #else
  298. if (ti->request_queue==NULL) {
  299. #endif
  300. // nothing more to do or device has dissapeared;)
  301. #ifdef TAPE_DEBUG
  302. debug_text_event (tape_debug_area,6,"b:Qempty");
  303. #endif
  304. tapestate_set(ti,TS_IDLE);
  305. return;
  306.     }
  307.     // queue is not empty, fetch a request and start IO!
  308.     req=ti->current_request=tape_next_request(&ti->request_queue);
  309.     if (req==NULL) {
  310. BUG(); // Yo. The queue was not reported empy, but no request found. This is _bad_.
  311.     }
  312.     if (req->cmd!=READ) { // we only support reading
  313. tapestate_set(ti,TS_FAILED);
  314. tapeblock_end_request (ti); // check state, inform user, free mem, dev=idl
  315. tapestate_set(ti,TS_BLOCK_INIT);
  316. schedule_tapeblock_exec_IO(ti);
  317. return;
  318.     }
  319.     ti->cqr=ti->discipline->bread(req,ti,tapeblock_major); //build channel program from request
  320.     if (!ti->cqr) {
  321. // ccw generation failed. we try again later.
  322. #ifdef TAPE_DEBUG
  323. debug_text_event (tape_debug_area,3,"b:cqrNULL");
  324. #endif
  325. schedule_tapeblock_exec_IO(ti);
  326. ti->current_request=NULL;
  327. return;
  328.     }
  329.     ti->blk_retries = TAPEBLOCK_RETRIES;
  330.     rc= do_IO (ti->devinfo.irq, ti->cqr->cpaddr, 
  331.        (unsigned long) ti->cqr, 0x00, ti->cqr->options);
  332.     if (rc) {
  333. // okay. ssch failed. we try later.
  334. #ifdef TAPE_DEBUG
  335. debug_text_event (tape_debug_area,3,"b:doIOfail");
  336. #endif
  337. ti->discipline->free_bread(ti->cqr,ti);
  338. ti->cqr=NULL;
  339. ti->current_request=NULL;
  340. schedule_tapeblock_exec_IO(ti);
  341. return;
  342.     }
  343.     // our request is in IO. we remove it from the queue and exit
  344.     tape_dequeue_request (&ti->request_queue,req);
  345. }
  347. static void 
  348. do_tape_request (request_queue_t * queue) {
  349.     tape_info_t* ti;
  350.     long lockflags;
  351.     for (ti=first_tape_info;
  352.  ((ti!=NULL) && ((&ti->request_queue)!=queue));
  353.  ti=ti->next);
  354.     if (ti==NULL) BUG();
  355.     s390irq_spin_lock_irqsave (ti->devinfo.irq, lockflags);
  356.     if (tapestate_get(ti)!=TS_IDLE) {
  357. s390irq_spin_unlock_irqrestore(ti->devinfo.irq,lockflags);
  358. return;
  359.     }
  360.     if (tapestate_get(ti)!=TS_IDLE) BUG();
  361.     tapestate_set(ti,TS_BLOCK_INIT);
  362.     tapeblock_exec_IO(ti);
  363.     s390irq_spin_unlock_irqrestore(ti->devinfo.irq,lockflags);
  364. }
  366. static void
  367. run_tapeblock_exec_IO (tape_info_t* ti) {
  368.     long flags_390irq,flags_ior;
  369.     spin_lock_irqsave (&io_request_lock, flags_ior);
  370.     s390irq_spin_lock_irqsave(ti->devinfo.irq,flags_390irq);
  371.     atomic_set(&ti->bh_scheduled,0);
  372.     tapeblock_exec_IO(ti);
  373.     s390irq_spin_unlock_irqrestore(ti->devinfo.irq,flags_390irq);
  374.     spin_unlock_irqrestore (&io_request_lock, flags_ior);
  375. }
  377. void
  378. schedule_tapeblock_exec_IO (tape_info_t *ti)
  379. {
  380. /* Protect against rescheduling, when already running */
  381.         if (atomic_compare_and_swap(0,1,&ti->bh_scheduled)) {
  382.                 return;
  383.         }
  384. #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,3,98))
  385. INIT_LIST_HEAD(&ti->bh_tq.list);
  386. #endif
  387. ti->bh_tq.sync = 0;
  388. ti->bh_tq.routine = (void *) (void *) run_tapeblock_exec_IO;
  389. ti->bh_tq.data = ti;
  391. queue_task (&ti->bh_tq, &tq_immediate);
  392. mark_bh (IMMEDIATE_BH);
  393. return;
  394. }
  396. /* wrappers around do_tape_request for different kernel versions */
  397. #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,3,98))
  398. static void tape_request_fn (void) {
  399.     tape_info_t* ti=first_tape_info;
  400.     while (ti!=NULL) {
  401. do_tape_request(&ti->request_queue);
  402. ti=ti->next;
  403.     }
  404. }
  405. #else
  406. static void  tape_request_fn (request_queue_t* queue) {
  407.     do_tape_request(queue);
  408. }
  409. #endif
  411. static request_queue_t* tapeblock_getqueue (kdev_t kdev) {
  412.     tape_info_t* ti=first_tape_info;
  413.     while ((ti!=NULL) && (MINOR(kdev)!=ti->blk_minor)) 
  414.         ti=ti->next;
  415.     if (ti!=NULL) return &ti->request_queue;
  416.     return NULL;
  417. }
  419. int tapeblock_mediumdetect(tape_info_t* ti) {
  420.         ccw_req_t* cqr;
  421.     int losize=1,hisize=1,rc;
  422.     long lockflags;
  423. #ifdef TAPE_DEBUG
  424.     debug_text_event (tape_debug_area,3,"b:medDet");
  425. #endif
  426.     PRINT_WARN("Detecting media size. This will take _long_, so get yourself a coffee...n");
  427.     while (1) { //is interruped by break
  428. hisize=hisize << 1; // try twice the size tested before 
  429. cqr=ti->discipline->mtseek (ti, hisize);
  430. if (cqr == NULL) {
  431. #ifdef TAPE_DEBUG
  432.     debug_text_event (tape_debug_area,6,"b:ccwg fail");
  433. #endif
  434.     return -ENOSPC;
  435. }
  436. s390irq_spin_lock_irqsave (ti->devinfo.irq, lockflags);
  437. ti->cqr = cqr;
  438. ti->wanna_wakeup=0;
  439. rc = do_IO (ti->devinfo.irq, cqr->cpaddr, (unsigned long) cqr, 0x00, cqr->options);
  440. s390irq_spin_unlock_irqrestore (ti->devinfo.irq, lockflags);
  441. if (rc) return -EIO;
  442. wait_event_interruptible (ti->wq,ti->wanna_wakeup);
  443. ti->cqr = NULL;
  444. tape_free_request (cqr);
  445. if (ti->kernbuf) {
  446.     kfree (ti->kernbuf);
  447.     ti->kernbuf=NULL;
  448. }
  449. if (signal_pending (current)) {
  450. tapestate_set (ti, TS_IDLE);
  451. return -ERESTARTSYS;
  452. }
  453. s390irq_spin_lock_irqsave (ti->devinfo.irq, lockflags);
  454. if (tapestate_get (ti) == TS_FAILED) {
  455. tapestate_set (ti, TS_IDLE);
  456. s390irq_spin_unlock_irqrestore (ti->devinfo.irq, lockflags);
  457. break;
  458. }
  459. if (tapestate_get (ti) == TS_NOT_OPER) {
  460.     ti->blk_minor=ti->rew_minor=ti->nor_minor=-1;
  461.     ti->devinfo.irq=-1;
  462.     s390irq_spin_unlock_irqrestore (ti->devinfo.irq,lockflags);
  463.     return -ENODEV;
  464. }
  465. if (tapestate_get (ti) != TS_DONE) {
  466. tapestate_set (ti, TS_IDLE);
  467. s390irq_spin_unlock_irqrestore (ti->devinfo.irq, lockflags);
  468. return -EIO;
  469. }
  470. tapestate_set (ti, TS_IDLE);
  471. s390irq_spin_unlock_irqrestore (ti->devinfo.irq, lockflags);
  472. losize=hisize;
  473.     }
  474.     cqr = ti->discipline->mtrew (ti, 1);
  475.     if (cqr == NULL) {
  476. #ifdef TAPE_DEBUG
  477. debug_text_event (tape_debug_area,6,"b:ccwg fail");
  478. #endif
  479. return -ENOSPC;
  480.     }
  481.     s390irq_spin_lock_irqsave (ti->devinfo.irq, lockflags);
  482.     ti->cqr = cqr;
  483.     ti->wanna_wakeup=0;
  484.     rc = do_IO (ti->devinfo.irq, cqr->cpaddr, (unsigned long) cqr, 0x00, cqr->options);
  485.     s390irq_spin_unlock_irqrestore (ti->devinfo.irq, lockflags);
  486.     wait_event_interruptible (ti->wq,ti->wanna_wakeup);
  487.     ti->cqr = NULL;
  488.     tape_free_request (cqr);
  489.     if (signal_pending (current)) {
  490. tapestate_set (ti, TS_IDLE);
  491. return -ERESTARTSYS;
  492.     }
  493.     s390irq_spin_lock_irqsave (ti->devinfo.irq, lockflags);
  494.     if (tapestate_get (ti) == TS_FAILED) {
  495. tapestate_set (ti, TS_IDLE);
  496. s390irq_spin_unlock_irqrestore (ti->devinfo.irq, lockflags);
  497. return -EIO;
  498.     }
  499.     if (tapestate_get (ti) == TS_NOT_OPER) {
  500. ti->blk_minor=ti->rew_minor=ti->nor_minor=-1;
  501. ti->devinfo.irq=-1;
  502. s390irq_spin_unlock_irqrestore (ti->devinfo.irq,lockflags);
  503. return -ENODEV;
  504.     }
  505.     if (tapestate_get (ti) != TS_DONE) {
  506. tapestate_set (ti, TS_IDLE);
  507. s390irq_spin_unlock_irqrestore (ti->devinfo.irq, lockflags);
  508. return -EIO;
  509.     }
  510.     tapestate_set (ti, TS_IDLE);
  511.     s390irq_spin_unlock_irqrestore (ti->devinfo.irq, lockflags);
  512.     while (losize!=hisize) {
  513. cqr=ti->discipline->mtseek (ti, (hisize+losize)/2+1);
  514. if (cqr == NULL) {
  515. #ifdef TAPE_DEBUG
  516.     debug_text_event (tape_debug_area,6,"b:ccwg fail");
  517. #endif
  518.     return -ENOSPC;
  519. }
  520. s390irq_spin_lock_irqsave (ti->devinfo.irq, lockflags);
  521. ti->cqr = cqr;
  522. ti->wanna_wakeup=0;
  523. rc = do_IO (ti->devinfo.irq, cqr->cpaddr, (unsigned long) cqr, 0x00, cqr->options);
  524. s390irq_spin_unlock_irqrestore (ti->devinfo.irq, lockflags);
  525. if (rc) return -EIO;
  526. wait_event_interruptible (ti->wq,ti->wanna_wakeup);
  527. ti->cqr = NULL;
  528. tape_free_request (cqr);
  529. if (ti->kernbuf) {
  530.     kfree (ti->kernbuf);
  531.     ti->kernbuf=NULL;
  532. }
  533. if (signal_pending (current)) {
  534. tapestate_set (ti, TS_IDLE);
  535. return -ERESTARTSYS;
  536. }
  537. s390irq_spin_lock_irqsave (ti->devinfo.irq, lockflags);
  538. if (tapestate_get (ti) == TS_NOT_OPER) {
  539.     ti->blk_minor=ti->rew_minor=ti->nor_minor=-1;
  540.     ti->devinfo.irq=-1;
  541.     s390irq_spin_unlock_irqrestore (ti->devinfo.irq,lockflags);
  542.     return -ENODEV;
  543. }
  544. if (tapestate_get (ti) == TS_FAILED) {
  545. tapestate_set (ti, TS_IDLE);
  546. s390irq_spin_unlock_irqrestore (ti->devinfo.irq, lockflags);
  547. hisize=(hisize+losize)/2;
  548. cqr = ti->discipline->mtrew (ti, 1);
  549. if (cqr == NULL) {
  550. #ifdef TAPE_DEBUG
  551.     debug_text_event (tape_debug_area,6,"b:ccwg fail");
  552. #endif
  553.     return -ENOSPC;
  554. }
  555. s390irq_spin_lock_irqsave (ti->devinfo.irq, lockflags);
  556. ti->cqr = cqr;
  557. ti->wanna_wakeup=0;
  558. rc = do_IO (ti->devinfo.irq, cqr->cpaddr, (unsigned long) cqr, 0x00, cqr->options);
  559. s390irq_spin_unlock_irqrestore (ti->devinfo.irq, lockflags);
  560. wait_event_interruptible (ti->wq,ti->wanna_wakeup);
  561. ti->cqr = NULL;
  562. tape_free_request (cqr);
  563. if (signal_pending (current)) {
  564.     tapestate_set (ti, TS_IDLE);
  565.     return -ERESTARTSYS;
  566. }
  567. s390irq_spin_lock_irqsave (ti->devinfo.irq, lockflags);
  568. if (tapestate_get (ti) == TS_FAILED) {
  569.     tapestate_set (ti, TS_IDLE);
  570.     s390irq_spin_unlock_irqrestore (ti->devinfo.irq, lockflags);
  571.     return -EIO;
  572. }
  573. if (tapestate_get (ti) != TS_DONE) {
  574.     tapestate_set (ti, TS_IDLE);
  575.     s390irq_spin_unlock_irqrestore (ti->devinfo.irq, lockflags);
  576.     return -EIO;
  577. }
  578. tapestate_set (ti, TS_IDLE);
  579. s390irq_spin_unlock_irqrestore (ti->devinfo.irq, lockflags);
  580. continue;
  581. }
  582. if (tapestate_get (ti) != TS_DONE) {
  583. tapestate_set (ti, TS_IDLE);
  584. s390irq_spin_unlock_irqrestore (ti->devinfo.irq, lockflags);
  585. return -EIO;
  586. }
  587. tapestate_set (ti, TS_IDLE);
  588. s390irq_spin_unlock_irqrestore (ti->devinfo.irq, lockflags);
  589. losize=(hisize+losize)/2+1;
  590.     }
  591.     blk_size[tapeblock_major][ti->blk_minor]=(losize)*(blksize_size[tapeblock_major][ti->blk_minor]/1024);
  592.     return 0;
  593. }