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

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

Linux/Unix编程

开发平台：

Unix_Linux

tape34xx.c：源码内容
  1. /***************************************************************************
  2.  *
  3.  *  drivers/s390/char/tape34xx.c
  4.  *    common tape device discipline for 34xx 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"
  15. #include <linux/config.h>
  16. #include <linux/version.h>
  17. #include <linux/stddef.h>
  18. #include <linux/kernel.h>
  19. #include <asm/types.h>
  20. #include <asm/uaccess.h>
  21. #include <linux/stat.h>
  22. #include <linux/proc_fs.h>
  23. #include <asm/ccwcache.h> 
  24. #include <asm/idals.h>  
  25. #ifdef CONFIG_S390_TAPE_DYNAMIC
  26. #include <asm/s390dyn.h>
  27. #endif
  28. #include <asm/debug.h>
  29. #include <linux/compatmac.h>
  30. #include "tape.h"
  31. #include "tape34xx.h"
  33. #define PRINTK_HEADER "T34xx:"
  35. tape_event_handler_t tape34xx_event_handler_table[TS_SIZE][TE_SIZE] =
  36. {
  37.     /* {START , DONE, FAILED, ERROR, OTHER } */
  38. {NULL, tape34xx_unused_done, NULL, NULL, NULL}, /* TS_UNUSED */
  39. {NULL, tape34xx_idle_done, NULL, NULL, NULL}, /* TS_IDLE */
  40. {NULL, NULL, NULL, NULL, NULL}, /* TS_DONE */
  41. {NULL, NULL, NULL, NULL, NULL}, /* TS_FAILED */
  42. {NULL, tape34xx_block_done, NULL, NULL, NULL}, /* TS_BLOCK_INIT */
  43. {NULL, tape34xx_bsb_init_done, NULL, NULL, NULL}, /* TS_BSB_INIT */
  44. {NULL, tape34xx_bsf_init_done, NULL, NULL, NULL}, /* TS_BSF_INIT */
  45. {NULL, tape34xx_dse_init_done, NULL, NULL, NULL}, /* TS_DSE_INIT */
  46. {NULL, NULL, NULL, NULL, NULL}, /* TS_EGA_INIT */
  47. {NULL, tape34xx_fsb_init_done, NULL, NULL, NULL}, /* TS_FSB_INIT */
  48. {NULL, tape34xx_fsf_init_done, NULL, NULL, NULL}, /* TS_FSF_INIT */
  49. {NULL, NULL, NULL, NULL, NULL}, /* TS_LDI_INIT */
  50. {NULL, tape34xx_lbl_init_done, NULL, NULL, NULL}, /* TS_LBL_INIT */
  51. {NULL, NULL, NULL, NULL, NULL}, /* TS_MSE_INIT */
  52. {NULL, tape34xx_nop_init_done, NULL, NULL, NULL}, /* TS_NOP_INIT */
  53. {NULL, NULL, NULL, NULL, NULL}, /* TS_RBA_INIT */
  54. {NULL, tape34xx_rbi_init_done, NULL, NULL, NULL}, /* TS_RBI_INIT */
  55. {NULL, NULL, NULL, NULL, NULL}, /* TS_RBU_INIT */
  56. {NULL, NULL, NULL, NULL, NULL}, /* TS_RBL_INIT */
  57. {NULL, NULL, NULL, NULL, NULL}, /* TS_RDC_INIT */
  58. {NULL, tape34xx_rfo_init_done, NULL, NULL, NULL}, /* TS_RFO_INIT */
  59. {NULL, NULL, NULL, NULL, NULL}, /* TS_RSD_INIT */
  60. {NULL, tape34xx_rew_init_done, NULL, NULL, NULL}, /* TS_REW_INIT */
  61. {NULL, tape34xx_rew_release_init_done, NULL, NULL, NULL}, /* TS_REW_RELEASE_IMIT */
  62. {NULL, tape34xx_run_init_done, NULL, NULL, NULL}, /* TS_RUN_INIT */
  63. {NULL, NULL, NULL, NULL, NULL}, /* TS_SEN_INIT */
  64. {NULL, NULL, NULL, NULL, NULL}, /* TS_SID_INIT */
  65. {NULL, NULL, NULL, NULL, NULL}, /* TS_SNP_INIT */
  66. {NULL, NULL, NULL, NULL, NULL}, /* TS_SPG_INIT */
  67. {NULL, NULL, NULL, NULL, NULL}, /* TS_SWI_INIT */
  68. {NULL, NULL, NULL, NULL, NULL}, /* TS_SMR_INIT */
  69. {NULL, NULL, NULL, NULL, NULL}, /* TS_SYN_INIT */
  70. {NULL, NULL, NULL, NULL, NULL}, /* TS_TIO_INIT */
  71. {NULL, NULL, NULL, NULL, NULL}, /* TS_UNA_INIT */
  72. {NULL, tape34xx_wri_init_done, NULL, NULL, NULL}, /* TS_WRI_INIT */
  73. {NULL, tape34xx_wtm_init_done, NULL, NULL, NULL}, /* TS_WTM_INIT */
  74. {NULL, NULL, NULL, NULL, NULL}};        /* TS_NOT_OPER */
  77. int
  78. tape34xx_ioctl_overload (struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg)
  79. {
  80. return -EINVAL; // no additional ioctls
  82. }
  84. ccw_req_t *
  85. tape34xx_write_block (const char *data, size_t count, tape_info_t * ti)
  86. {
  87. long lockflags;
  88. ccw_req_t *cqr;
  89. ccw1_t *ccw;
  90. void *mem;
  91. cqr = tape_alloc_ccw_req (ti, 2, 0);
  92. if (!cqr) {
  93. #ifdef TAPE_DEBUG
  94.         debug_text_exception (tape_debug_area,6,"xwbl nomem");
  95. #endif /* TAPE_DEBUG */
  96. return NULL;
  97. }
  98. mem = kmalloc (count, GFP_KERNEL);
  99. if (!mem) {
  100. tape_free_request (cqr);
  101. #ifdef TAPE_DEBUG
  102.         debug_text_exception (tape_debug_area,6,"xwbl nomem");
  103. #endif /* TAPE_DEBUG */
  104. return NULL;
  105. }
  106. if (copy_from_user (mem, data, count)) {
  107. kfree (mem);
  108. tape_free_request (cqr);
  109. #ifdef TAPE_DEBUG
  110.         debug_text_exception (tape_debug_area,6,"xwbl segf.");
  111. #endif /* TAPE_DEBUG */
  112. return NULL;
  113. }
  114. ccw = cqr->cpaddr;
  115. ccw->cmd_code = MODE_SET_DB;
  116. ccw->flags = CCW_FLAG_CC;
  117. ccw->count = 1;
  118. set_normalized_cda (ccw, (unsigned long) (&(((tape34xx_disc_data_t *) ti->discdata)->modeset_byte)));
  119. ccw++;
  121. ccw->cmd_code = WRITE_CMD;
  122. ccw->flags = 0;
  123. ccw->count = count;
  124. set_normalized_cda (ccw, (unsigned long) mem);
  125. if ((ccw->cda) == 0) {
  126. kfree (mem);
  127. tape_free_request (cqr);
  128. return NULL;
  129. }
  130. s390irq_spin_lock_irqsave (ti->devinfo.irq, lockflags);
  131. ti->kernbuf = mem;
  132. ti->userbuf = (void *) data;
  133. tapestate_set (ti, TS_WRI_INIT);
  134. s390irq_spin_unlock_irqrestore (ti->devinfo.irq, lockflags);
  135. #ifdef TAPE_DEBUG
  136. debug_text_event (tape_debug_area,6,"xwbl ccwg");
  137. #endif /* TAPE_DEBUG */
  138. return cqr;
  139. }
  141. void 
  142. tape34xx_free_write_block (ccw_req_t * cqr, tape_info_t * ti)
  143. {
  144. unsigned long lockflags;
  145. ccw1_t *ccw;
  146. s390irq_spin_lock_irqsave (ti->devinfo.irq, lockflags);
  147. ccw = cqr->cpaddr;
  148. ccw++;
  149. clear_normalized_cda (ccw);
  150. kfree (ti->kernbuf);
  151. tape_free_request (cqr);
  152. ti->kernbuf = ti->userbuf = NULL;
  153. s390irq_spin_unlock_irqrestore (ti->devinfo.irq, lockflags);
  154. #ifdef TAPE_DEBUG
  155. debug_text_event (tape_debug_area,6,"xfwb free");
  156. #endif /* TAPE_DEBUG */
  157. }
  159. ccw_req_t *
  160. tape34xx_read_block (const char *data, size_t count, tape_info_t * ti)
  161. {
  162. long lockflags;
  163. ccw_req_t *cqr;
  164. ccw1_t *ccw;
  165. void *mem;
  166. cqr = tape_alloc_ccw_req (ti, 2, 0);
  167. if (!cqr) {
  168. #ifdef TAPE_DEBUG
  169.         debug_text_exception (tape_debug_area,6,"xrbl nomem");
  170. #endif /* TAPE_DEBUG */
  171. return NULL;
  172. }
  173. mem = kmalloc (count, GFP_KERNEL);
  174. if (!mem) {
  175. tape_free_request (cqr);
  176. #ifdef TAPE_DEBUG
  177.         debug_text_exception (tape_debug_area,6,"xrbl nomem");
  178. #endif /* TAPE_DEBUG */
  179. return NULL;
  180. }
  181. ccw = cqr->cpaddr;
  182. ccw->cmd_code = MODE_SET_DB;
  183. ccw->flags = CCW_FLAG_CC;
  184. ccw->count = 1;
  185. set_normalized_cda (ccw, (unsigned long) (&(((tape34xx_disc_data_t *) ti->discdata)->modeset_byte)));
  186. ccw++;
  188. ccw->cmd_code = READ_FORWARD;
  189. ccw->flags = 0;
  190. ccw->count = count;
  191. set_normalized_cda (ccw, (unsigned long) mem);
  192. if ((ccw->cda) == 0) {
  193. kfree (mem);
  194. tape_free_request (cqr);
  195. return NULL;
  196. }
  197. s390irq_spin_lock_irqsave (ti->devinfo.irq, lockflags);
  198. ti->kernbuf = mem;
  199. ti->userbuf = (void *) data;
  200. tapestate_set (ti, TS_RFO_INIT);
  201. s390irq_spin_unlock_irqrestore (ti->devinfo.irq, lockflags);
  202. #ifdef TAPE_DEBUG
  203. debug_text_event (tape_debug_area,6,"xrbl ccwg");
  204. #endif /* TAPE_DEBUG */
  205. return cqr;
  206. }
  208. ccw_req_t *
  209. tape34xx_read_opposite (tape_info_t * ti,int novalue)
  210. {
  211. ccw_req_t *cqr;
  212. ccw1_t *ccw;
  213. size_t count;
  214. // first, retrieve the count from the old cqr.
  215. cqr = ti->cqr;
  216. ccw = cqr->cpaddr;
  217. ccw++;
  218. count=ccw->count;
  219. // free old cqr.
  220. clear_normalized_cda (ccw);
  221. tape_free_request (cqr);
  222. // build new cqr
  223. cqr = tape_alloc_ccw_req (ti, 3, 0);
  224. if (!cqr) {
  225. #ifdef TAPE_DEBUG
  226.         debug_text_exception (tape_debug_area,6,"xrop nomem");
  227. #endif /* TAPE_DEBUG */
  228. return NULL;
  229. }
  230. ccw = cqr->cpaddr;
  231. ccw->cmd_code = MODE_SET_DB;
  232. ccw->flags = CCW_FLAG_CC;
  233. ccw->count = 1;
  234. set_normalized_cda (ccw, (unsigned long) (&(((tape34xx_disc_data_t *) ti->discdata)->modeset_byte)));
  235. ccw++;
  237. ccw->cmd_code = READ_BACKWARD;
  238. ccw->flags = CCW_FLAG_CC;
  239. ccw->count = count;
  240. set_normalized_cda (ccw, (unsigned long) ti->kernbuf);
  241. if ((ccw->cda) == 0) {
  242. tape_free_request (cqr);
  243. return NULL;
  244. }
  245. ccw++;
  246. ccw->cmd_code = FORSPACEBLOCK;
  247. ccw->flags = CCW_FLAG_CC;
  248. ccw->count = 1;
  249. ccw->cda = (unsigned long)ccw;
  250. ccw++;
  251. ccw->cmd_code = NOP;
  252. ccw->flags = 0;
  253. ccw->count = 1;
  254. ccw->cda = (unsigned long)ccw;
  255. tapestate_set (ti, TS_RBA_INIT);
  256. #ifdef TAPE_DEBUG
  257. debug_text_event (tape_debug_area,6,"xrop ccwg");
  258. #endif /* TAPE_DEBUG */
  259. return cqr;
  260. }
  262. void 
  263. tape34xx_free_read_block (ccw_req_t * cqr, tape_info_t * ti)
  264. {
  265. unsigned long lockflags;
  266. size_t cpysize;
  267. ccw1_t *ccw;
  268. s390irq_spin_lock_irqsave (ti->devinfo.irq, lockflags);
  269. ccw = cqr->cpaddr;
  270. ccw++;
  271. cpysize = ccw->count - ti->devstat.rescnt;
  272. s390irq_spin_unlock_irqrestore (ti->devinfo.irq, lockflags);
  273. if (copy_to_user (ti->userbuf, ti->kernbuf, cpysize)) {
  274. #ifdef TAPE_DEBUG
  275.     debug_text_exception (tape_debug_area,6,"xfrb segf.");
  276. #endif /* TAPE_DEBUG */
  277. }
  278. s390irq_spin_lock_irqsave (ti->devinfo.irq, lockflags);
  279. clear_normalized_cda (ccw);
  280. kfree (ti->kernbuf);
  281. tape_free_request (cqr);
  282. ti->kernbuf = ti->userbuf = NULL;
  283. s390irq_spin_unlock_irqrestore (ti->devinfo.irq, lockflags);
  284. #ifdef TAPE_DEBUG
  285. debug_text_event (tape_debug_area,6,"xfrb free");
  286. #endif /* TAPE_DEBUG */
  287. }
  289. /*
  290.  * The IOCTL interface is implemented in the following section,
  291.  * excepted the MTRESET, MTSETBLK which are handled by tapechar.c
  292.  */
  293. /*
  294.  * MTFSF: Forward space over 'count' file marks. The tape is positioned
  295.  * at the EOT (End of Tape) side of the file mark.
  296.  */
  297. ccw_req_t *
  298. tape34xx_mtfsf (tape_info_t * ti, int count)
  299. {
  300. long lockflags;
  301. int i;
  302. ccw_req_t *cqr;
  303. ccw1_t *ccw;
  304. if ((count == 0) || (count > 510)) {
  305. #ifdef TAPE_DEBUG
  306.         debug_text_exception (tape_debug_area,6,"xfsf parm");
  307. #endif /* TAPE_DEBUG */
  308. return NULL;
  309. }
  310. cqr = tape_alloc_ccw_req (ti, 2 + count, 0);
  311. if (!cqr) {
  312. #ifdef TAPE_DEBUG
  313.         debug_text_exception (tape_debug_area,6,"xfsf nomem");
  314. #endif /* TAPE_DEBUG */
  315. return NULL;
  316. }
  317. ccw = cqr->cpaddr;
  318. ccw->cmd_code = MODE_SET_DB;
  319. ccw->flags = CCW_FLAG_CC;
  320. ccw->count = 1;
  321. set_normalized_cda (ccw, (unsigned long) (&(((tape34xx_disc_data_t *) ti->discdata)->modeset_byte)));
  322. ccw++;
  323. for (i = 0; i < count; i++) {
  324. ccw->cmd_code = FORSPACEFILE;
  325. ccw->flags = CCW_FLAG_CC;
  326. ccw->count = 0;
  327. ccw->cda = (unsigned long) (&(ccw->cmd_code));
  328. ccw++;
  329. }
  330. ccw->cmd_code = NOP;
  331. ccw->flags = 0;
  332. ccw->count = 0;
  333. ccw->cda = (unsigned long) (&(ccw->cmd_code));
  334. s390irq_spin_lock_irqsave (ti->devinfo.irq, lockflags);
  335. ti->kernbuf = NULL;
  336. ti->userbuf = NULL;
  337. tapestate_set (ti, TS_FSF_INIT);
  338. s390irq_spin_unlock_irqrestore (ti->devinfo.irq, lockflags);
  339. #ifdef TAPE_DEBUG
  340. debug_text_event (tape_debug_area,6,"xfsf ccwg");
  341. #endif /* TAPE_DEBUG */
  342. return cqr;
  343. }
  345. /*
  346.  * MTBSF: Backward space over 'count' file marks. The tape is positioned at
  347.  * the EOT (End of Tape) side of the last skipped file mark.
  348.  */
  349. ccw_req_t *
  350. tape34xx_mtbsf (tape_info_t * ti, int count)
  351. {
  352. long lockflags;
  353. int i;
  354. ccw_req_t *cqr;
  355. ccw1_t *ccw;
  356. if ((count == 0) || (count > 510)) {
  357. #ifdef TAPE_DEBUG
  358.         debug_text_exception (tape_debug_area,6,"xbsf parm");
  359. #endif /* TAPE_DEBUG */
  360.         return NULL;
  361. }
  362. cqr = tape_alloc_ccw_req (ti, 2 + count, 0);
  363. if (!cqr) {
  364. #ifdef TAPE_DEBUG
  365.         debug_text_exception (tape_debug_area,6,"xbsf nomem");
  366. #endif /* TAPE_DEBUG */
  367. return NULL;
  368. }
  369. ccw = cqr->cpaddr;
  370. ccw->cmd_code = MODE_SET_DB;
  371. ccw->flags = CCW_FLAG_CC;
  372. ccw->count = 1;
  373. set_normalized_cda (ccw, (unsigned long) (&(((tape34xx_disc_data_t *) ti->discdata)->modeset_byte)));
  374. ccw++;
  375. for (i = 0; i < count; i++) {
  376. ccw->cmd_code = BACKSPACEFILE;
  377. ccw->flags = CCW_FLAG_CC;
  378. ccw->count = 0;
  379. ccw->cda = (unsigned long) (&(ccw->cmd_code));
  380. ccw++;
  381. }
  382. ccw->cmd_code = NOP;
  383. ccw->flags = 0;
  384. ccw->count = 0;
  385. ccw->cda = (unsigned long) (&(ccw->cmd_code));
  386. s390irq_spin_lock_irqsave (ti->devinfo.irq, lockflags);
  387. ti->kernbuf = NULL;
  388. ti->userbuf = NULL;
  389. tapestate_set (ti, TS_BSF_INIT);
  390. s390irq_spin_unlock_irqrestore (ti->devinfo.irq, lockflags);
  391. #ifdef TAPE_DEBUG
  392. debug_text_event (tape_debug_area,6,"xbsf ccwg");
  393. #endif /* TAPE_DEBUG */
  394. return cqr;
  395. }
  397. /*
  398.  * MTFSR: Forward space over 'count' tape blocks (blocksize is set
  399.  * via MTSETBLK.
  400.  */
  401. ccw_req_t *
  402. tape34xx_mtfsr (tape_info_t * ti, int count)
  403. {
  404. long lockflags;
  405. int i;
  406. ccw_req_t *cqr;
  407. ccw1_t *ccw;
  408. if ((count == 0) || (count > 510)) {
  409. #ifdef TAPE_DEBUG
  410.         debug_text_exception (tape_debug_area,6,"xfsr parm");
  411. #endif /* TAPE_DEBUG */
  412. return NULL;
  413. }
  414. cqr = tape_alloc_ccw_req (ti, 2 + count, 0);
  415. if (!cqr) {
  416. #ifdef TAPE_DEBUG
  417.         debug_text_exception (tape_debug_area,6,"xfsr nomem");
  418. #endif /* TAPE_DEBUG */
  419. return NULL;
  420. }
  421. ccw = cqr->cpaddr;
  422. ccw->cmd_code = MODE_SET_DB;
  423. ccw->flags = CCW_FLAG_CC;
  424. ccw->count = 1;
  425. set_normalized_cda (ccw, (unsigned long) (&(((tape34xx_disc_data_t *) ti->discdata)->modeset_byte)));
  426. ccw++;
  427. for (i = 0; i < count; i++) {
  428. ccw->cmd_code = FORSPACEBLOCK;
  429. ccw->flags = CCW_FLAG_CC;
  430. ccw->count = 0;
  431. ccw->cda = (unsigned long) (&(ccw->cmd_code));
  432. ccw++;
  433. }
  434. ccw->cmd_code = NOP;
  435. ccw->flags = 0;
  436. ccw->count = 0;
  437. ccw->cda = (unsigned long) (&(ccw->cmd_code));
  438. s390irq_spin_lock_irqsave (ti->devinfo.irq, lockflags);
  439. ti->kernbuf = NULL;
  440. ti->userbuf = NULL;
  441. tapestate_set (ti, TS_FSB_INIT);
  442. s390irq_spin_unlock_irqrestore (ti->devinfo.irq, lockflags);
  443. #ifdef TAPE_DEBUG
  444. debug_text_event (tape_debug_area,6,"xfsr ccwgen");
  445. #endif /* TAPE_DEBUG */
  446. return cqr;
  447. }
  449. /*
  450.  * MTBSR: Backward space over 'count' tape blocks.
  451.  * (blocksize is set via MTSETBLK.
  452.  */
  453. ccw_req_t *
  454. tape34xx_mtbsr (tape_info_t * ti, int count)
  455. {
  456. long lockflags;
  457. int i;
  458. ccw_req_t *cqr;
  459. ccw1_t *ccw;
  460. if ((count == 0) || (count > 510)) {
  461. #ifdef TAPE_DEBUG
  462.         debug_text_exception (tape_debug_area,6,"xbsr parm");
  463. #endif /* TAPE_DEBUG */   
  464.         return NULL;
  465. }
  466. cqr = tape_alloc_ccw_req (ti, 2 + count, 0);
  467. if (!cqr) {
  468. #ifdef TAPE_DEBUG
  469.         debug_text_exception (tape_debug_area,6,"xbsr nomem");
  470. #endif /* TAPE_DEBUG */
  471. return NULL;
  472. }
  473. ccw = cqr->cpaddr;
  474. ccw->cmd_code = MODE_SET_DB;
  475. ccw->flags = CCW_FLAG_CC;
  476. ccw->count = 1;
  477. set_normalized_cda (ccw, (unsigned long) (&(((tape34xx_disc_data_t *) ti->discdata)->modeset_byte)));
  478. ccw++;
  479. for (i = 0; i < count; i++) {
  480. ccw->cmd_code = BACKSPACEBLOCK;
  481. ccw->flags = CCW_FLAG_CC;
  482. ccw->count = 0;
  483. ccw->cda = (unsigned long) (&(ccw->cmd_code));
  484. ccw++;
  485. }
  486. ccw->cmd_code = NOP;
  487. ccw->flags = 0;
  488. ccw->count = 0;
  489. ccw->cda = (unsigned long) (&(ccw->cmd_code));
  490. s390irq_spin_lock_irqsave (ti->devinfo.irq, lockflags);
  491. ti->kernbuf = NULL;
  492. ti->userbuf = NULL;
  493. tapestate_set (ti, TS_BSB_INIT);
  494. s390irq_spin_unlock_irqrestore (ti->devinfo.irq, lockflags);
  495. #ifdef TAPE_DEBUG
  496. debug_text_event (tape_debug_area,6,"xbsr ccwg");
  497. #endif /* TAPE_DEBUG */
  498. return cqr;
  499. }
  501. /*
  502.  * MTWEOF: Write 'count' file marks at the current position.
  503.  */
  504. ccw_req_t *
  505. tape34xx_mtweof (tape_info_t * ti, int count)
  506. {
  507. long lockflags;
  508. int i;
  509. ccw_req_t *cqr;
  510. ccw1_t *ccw;
  511. if ((count == 0) || (count > 510)) {
  512. #ifdef TAPE_DEBUG
  513.         debug_text_exception (tape_debug_area,6,"xweo parm");
  514. #endif /* TAPE_DEBUG */
  515. return NULL;
  516. }
  517. cqr = tape_alloc_ccw_req (ti, 2 + count, 0);
  518. if (!cqr) {
  519. #ifdef TAPE_DEBUG
  520.         debug_text_exception (tape_debug_area,6,"xweo nomem");
  521. #endif /* TAPE_DEBUG */
  522. return NULL;
  523. }
  524. ccw = cqr->cpaddr;
  525. ccw->cmd_code = MODE_SET_DB;
  526. ccw->flags = CCW_FLAG_CC;
  527. ccw->count = 1;
  528. set_normalized_cda (ccw, (unsigned long) (&(((tape34xx_disc_data_t *) ti->discdata)->modeset_byte)));
  529. ccw++;
  530. for (i = 0; i < count; i++) {
  531. ccw->cmd_code = WRITETAPEMARK;
  532. ccw->flags = CCW_FLAG_CC;
  533. ccw->count = 1;
  534. ccw->cda = (unsigned long) (&(ccw->cmd_code));
  535. ccw++;
  536. }
  537. ccw->cmd_code = NOP;
  538. ccw->flags = 0;
  539. ccw->count = 0;
  540. ccw->cda = (unsigned long) (&(ccw->cmd_code));
  541. ccw++;
  542. s390irq_spin_lock_irqsave (ti->devinfo.irq, lockflags);
  543. ti->kernbuf = NULL;
  544. ti->userbuf = NULL;
  545. tapestate_set (ti, TS_WTM_INIT);
  546. s390irq_spin_unlock_irqrestore (ti->devinfo.irq, lockflags);
  547. #ifdef TAPE_DEBUG
  548. debug_text_event (tape_debug_area,6,"xweo ccwg");
  549. #endif /* TAPE_DEBUG */
  550. return cqr;
  551. }
  553. /*
  554.  * MTREW: Rewind the tape.
  555.  */
  556. ccw_req_t *
  557. tape34xx_mtrew (tape_info_t * ti, int count)
  558. {
  559. long lockflags;
  560. ccw_req_t *cqr;
  561. ccw1_t *ccw;
  562. cqr = tape_alloc_ccw_req (ti, 3, 0);
  563. if (!cqr) {
  564. #ifdef TAPE_DEBUG
  565.         debug_text_exception (tape_debug_area,6,"xrew nomem");
  566. #endif /* TAPE_DEBUG */
  567. return NULL;
  568. }
  569. ccw = cqr->cpaddr;
  570. ccw->cmd_code = MODE_SET_DB;
  571. ccw->flags = CCW_FLAG_CC;
  572. ccw->count = 1;
  573. set_normalized_cda (ccw, (unsigned long) (&(((tape34xx_disc_data_t *) ti->discdata)->modeset_byte)));
  574. ccw++;
  575. ccw->cmd_code = REWIND;
  576. ccw->flags = CCW_FLAG_CC;
  577. ccw->count = 0;
  578. ccw->cda = (unsigned long) (&(ccw->cmd_code));
  579. ccw++;
  580. ccw->cmd_code = NOP;
  581. ccw->flags = 0;
  582. ccw->count = 0;
  583. ccw->cda = (unsigned long) (&(ccw->cmd_code));
  584. s390irq_spin_lock_irqsave (ti->devinfo.irq, lockflags);
  585. ti->kernbuf = NULL;
  586. ti->userbuf = NULL;
  587. tapestate_set (ti, TS_REW_INIT);
  588. s390irq_spin_unlock_irqrestore (ti->devinfo.irq, lockflags);
  589. #ifdef TAPE_DEBUG
  590. debug_text_event (tape_debug_area,6,"xrew ccwg");
  591. #endif /* TAPE_DEBUG */
  592. return cqr;
  593. }
  595. /*
  596.  * MTOFFL: Rewind the tape and put the drive off-line.
  597.  * Implement 'rewind unload'
  598.  */
  599. ccw_req_t *
  600. tape34xx_mtoffl (tape_info_t * ti, int count)
  601. {
  602. long lockflags;
  603. ccw_req_t *cqr;
  604. ccw1_t *ccw;
  605. cqr = tape_alloc_ccw_req (ti, 3, 32);
  606. if (!cqr) {
  607. #ifdef TAPE_DEBUG
  608.         debug_text_exception (tape_debug_area,6,"xoff nomem");
  609. #endif /* TAPE_DEBUG */
  610. return NULL;
  611. }
  612. ccw = cqr->cpaddr;
  613. ccw->cmd_code = MODE_SET_DB;
  614. ccw->flags = CCW_FLAG_CC;
  615. ccw->count = 1;
  616. set_normalized_cda (ccw, (unsigned long) (&(((tape34xx_disc_data_t *) ti->discdata)->modeset_byte)));
  617. ccw++;
  618. ccw->cmd_code = REWIND_UNLOAD;
  619. ccw->flags = CCW_FLAG_CC;
  620. ccw->count = 1;
  621. ccw->cda = (unsigned long) (&(ccw->cmd_code));
  622. ccw++;
  623. ccw->cmd_code = SENSE;
  624. ccw->flags = 0;
  625. ccw->count = 32;
  626. ccw->cda = (unsigned long) cqr->cpaddr;
  627. s390irq_spin_lock_irqsave (ti->devinfo.irq, lockflags);
  628. ti->kernbuf = NULL;
  629. ti->userbuf = NULL;
  630. tapestate_set (ti, TS_RUN_INIT);
  631. s390irq_spin_unlock_irqrestore (ti->devinfo.irq, lockflags);
  632. #ifdef TAPE_DEBUG
  633. debug_text_event (tape_debug_area,6,"xoff ccwg");
  634. #endif /* TAPE_DEBUG */
  635. return cqr;
  636. }
  638. /*
  639.  * MTNOP: 'No operation'.
  640.  */
  641. ccw_req_t *
  642. tape34xx_mtnop (tape_info_t * ti, int count)
  643. {
  644. long lockflags;
  645. ccw_req_t *cqr;
  646. ccw1_t *ccw;
  647. cqr = tape_alloc_ccw_req (ti, 1, 0);
  648. if (!cqr) {
  649. #ifdef TAPE_DEBUG
  650.         debug_text_exception (tape_debug_area,6,"xnop nomem");
  651. #endif /* TAPE_DEBUG */
  652. return NULL;
  653. }
  654. ccw = cqr->cpaddr;
  655. ccw->cmd_code = NOP;
  656. ccw->flags = 0;
  657. ccw->count = 0;
  658. ccw->cda = (unsigned long) ccw->cmd_code;
  659. s390irq_spin_lock_irqsave (ti->devinfo.irq, lockflags);
  660. ti->kernbuf = NULL;
  661. ti->userbuf = NULL;
  662. tapestate_set (ti, TS_NOP_INIT);
  663. s390irq_spin_unlock_irqrestore (ti->devinfo.irq, lockflags);
  664. #ifdef TAPE_DEBUG
  665. debug_text_event (tape_debug_area,6,"xnop ccwg");
  666. #endif /* TAPE_DEBUG */
  667. return cqr;
  668. }
  670. /*
  671.  * MTBSFM: Backward space over 'count' file marks.
  672.  * The tape is positioned at the BOT (Begin Of Tape) side of the
  673.  * last skipped file mark.
  674.  */
  675. ccw_req_t *
  676. tape34xx_mtbsfm (tape_info_t * ti, int count)
  677. {
  678. long lockflags;
  679. int i;
  680. ccw_req_t *cqr;
  681. ccw1_t *ccw;
  682. if ((count == 0) || (count > 510)) {
  683. #ifdef TAPE_DEBUG
  684.         debug_text_exception (tape_debug_area,6,"xbsm parm");
  685. #endif /* TAPE_DEBUG */
  686. return NULL;
  687. }
  688. cqr = tape_alloc_ccw_req (ti, 2 + count, 0);
  689. if (!cqr) {
  690. #ifdef TAPE_DEBUG
  691.         debug_text_exception (tape_debug_area,6,"xbsm nomem");
  692. #endif /* TAPE_DEBUG */
  693. return NULL;
  694. }
  695. ccw = cqr->cpaddr;
  696. ccw->cmd_code = MODE_SET_DB;
  697. ccw->flags = CCW_FLAG_CC;
  698. ccw->count = 1;
  699. set_normalized_cda (ccw, (unsigned long) (&(((tape34xx_disc_data_t *) ti->discdata)->modeset_byte)));
  700. ccw++;
  701. for (i = 0; i < count; i++) {
  702. ccw->cmd_code = BACKSPACEFILE;
  703. ccw->flags = CCW_FLAG_CC;
  704. ccw->count = 0;
  705. ccw->cda = (unsigned long) (&(ccw->cmd_code));
  706. ccw++;
  707. }
  708. ccw->cmd_code = NOP;
  709. ccw->flags = 0;
  710. ccw->count = 0;
  711. ccw->cda = (unsigned long) (&(ccw->cmd_code));
  712. s390irq_spin_lock_irqsave (ti->devinfo.irq, lockflags);
  713. ti->kernbuf = NULL;
  714. ti->userbuf = NULL;
  715. tapestate_set (ti, TS_BSF_INIT);
  716. s390irq_spin_unlock_irqrestore (ti->devinfo.irq, lockflags);
  717. #ifdef TAPE_DEBUG
  718. debug_text_event (tape_debug_area,6,"xbsm ccwg");
  719. #endif /* TAPE_DEBUG */
  720. return cqr;
  721. }
  723. /*
  724.  * MTFSFM: Forward space over 'count' file marks.
  725.  * The tape is positioned at the BOT (Begin Of Tape) side
  726.  * of the last skipped file mark.
  727.  */
  728. ccw_req_t *
  729. tape34xx_mtfsfm (tape_info_t * ti, int count)
  730. {
  731. long lockflags;
  732. int i;
  733. ccw_req_t *cqr;
  734. ccw1_t *ccw;
  735. if ((count == 0) || (count > 510)) {
  736. #ifdef TAPE_DEBUG
  737.         debug_text_exception (tape_debug_area,6,"xfsm parm");
  738. #endif /* TAPE_DEBUG */
  739. return NULL;
  740. }
  741. cqr = tape_alloc_ccw_req (ti, 2 + count, 0);
  742. if (!cqr) {
  743. #ifdef TAPE_DEBUG
  744.         debug_text_exception (tape_debug_area,6,"xfsm nomem");
  745. #endif /* TAPE_DEBUG */     
  746. return NULL;
  747. }
  748. ccw = cqr->cpaddr;
  749. ccw->cmd_code = MODE_SET_DB;
  750. ccw->flags = CCW_FLAG_CC;
  751. ccw->count = 1;
  752. set_normalized_cda (ccw, (unsigned long) (&(((tape34xx_disc_data_t *) ti->discdata)->modeset_byte)));
  753. ccw++;
  754. for (i = 0; i < count; i++) {
  755. ccw->cmd_code = FORSPACEFILE;
  756. ccw->flags = CCW_FLAG_CC;
  757. ccw->count = 0;
  758. ccw->cda = (unsigned long) (&(ccw->cmd_code));
  759. ccw++;
  760. }
  761. ccw->cmd_code = NOP;
  762. ccw->flags = 0;
  763. ccw->count = 0;
  764. ccw->cda = (unsigned long) (&(ccw->cmd_code));
  765. s390irq_spin_lock_irqsave (ti->devinfo.irq, lockflags);
  766. ti->kernbuf = NULL;
  767. ti->userbuf = NULL;
  768. tapestate_set (ti, TS_FSF_INIT);
  769. s390irq_spin_unlock_irqrestore (ti->devinfo.irq, lockflags);
  770. #ifdef TAPE_DEBUG
  771. debug_text_event (tape_debug_area,6,"xfsm ccwg");
  772. #endif /* TAPE_DEBUG */
  773. return cqr;
  774. }
  776. /*
  777.  * MTEOM: positions at the end of the portion of the tape already used
  778.  * for recordind data. MTEOM positions after the last file mark, ready for
  779.  * appending another file.
  780.  * MTRETEN: Retension the tape, i.e. forward space to end of tape and rewind.
  781.  */
  782. ccw_req_t *
  783. tape34xx_mteom (tape_info_t * ti, int count)
  784. {
  785. long lockflags;
  786. ccw_req_t *cqr;
  787. ccw1_t *ccw;
  788. cqr = tape_alloc_ccw_req (ti, 4, 0);
  789. if (!cqr) {
  790. #ifdef TAPE_DEBUG
  791.         debug_text_exception (tape_debug_area,6,"xeom nomem");
  792. #endif /* TAPE_DEBUG */
  793. return NULL;
  794. }
  795. ccw = cqr->cpaddr;
  796. ccw->cmd_code = MODE_SET_DB;
  797. ccw->flags = CCW_FLAG_CC;
  798. ccw->count = 1;
  799. set_normalized_cda (ccw, (unsigned long) (&(((tape34xx_disc_data_t *) ti->discdata)->modeset_byte)));
  800. ccw++;
  801. ccw->cmd_code = FORSPACEFILE;
  802. ccw->flags = CCW_FLAG_CC;
  803. ccw->count = 0;
  804. ccw->cda = (unsigned long) (&(ccw->cmd_code));
  805. ccw++;
  806. ccw->cmd_code = NOP;
  807. ccw->flags = CCW_FLAG_CC;
  808. ccw->count = 0;
  809. ccw->cda = (unsigned long) (&(ccw->cmd_code));
  810. ccw++;
  811. ccw->cmd_code = CCW_CMD_TIC;
  812. ccw->flags = 0;
  813. ccw->count = 0;
  814. ccw->cda = (unsigned long) (cqr->cpaddr);
  815. s390irq_spin_lock_irqsave (ti->devinfo.irq, lockflags);
  816. ti->kernbuf = NULL;
  817. ti->userbuf = NULL;
  818. tapestate_set (ti, TS_FSF_INIT);
  819. s390irq_spin_unlock_irqrestore (ti->devinfo.irq, lockflags);
  820. #ifdef TAPE_DEBUG
  821. debug_text_event (tape_debug_area,6,"xeom ccwg");
  822. #endif /* TAPE_DEBUG */
  823. return cqr;
  824. }
  826. /*
  827.  * MTERASE: erases the tape.
  828.  */
  829. ccw_req_t *
  830. tape34xx_mterase (tape_info_t * ti, int count)
  831. {
  832. long lockflags;
  833. ccw_req_t *cqr;
  834. ccw1_t *ccw;
  835. cqr = tape_alloc_ccw_req (ti, 5, 0);
  836. if (!cqr) {
  837. #ifdef TAPE_DEBUG
  838.         debug_text_exception (tape_debug_area,6,"xera nomem");
  839. #endif /* TAPE_DEBUG */
  840. return NULL;
  841. }
  842. ccw = cqr->cpaddr;
  843. ccw->cmd_code = MODE_SET_DB;
  844. ccw->flags = CCW_FLAG_CC;
  845. ccw->count = 1;
  846. set_normalized_cda (ccw, (unsigned long) (&(((tape34xx_disc_data_t *) ti->discdata)->modeset_byte)));
  847. ccw++;
  848. ccw->cmd_code = REWIND;
  849. ccw->flags = CCW_FLAG_CC;
  850. ccw->count = 0;
  851. ccw->cda = (unsigned long) (&(ccw->cmd_code));
  852. ccw++;
  853. ccw->cmd_code = ERASE_GAP;
  854. ccw->flags = CCW_FLAG_CC;
  855. ccw->count = 0;
  856. ccw->cda = (unsigned long) (&(ccw->cmd_code));
  857. ccw++;
  858. ccw->cmd_code = DATA_SEC_ERASE;
  859. ccw->flags = CCW_FLAG_CC;
  860. ccw->count = 0;
  861. ccw->cda = (unsigned long) (&(ccw->cmd_code));
  862. ccw++;
  863. ccw->cmd_code = NOP;
  864. ccw->flags = 0;
  865. ccw->count = 0;
  866. ccw->cda = (unsigned long) (&(ccw->cmd_code));
  867. s390irq_spin_lock_irqsave (ti->devinfo.irq, lockflags);
  868. ti->kernbuf = NULL;
  869. ti->userbuf = NULL;
  870. tapestate_set (ti, TS_DSE_INIT);
  871. s390irq_spin_unlock_irqrestore (ti->devinfo.irq, lockflags);
  872. #ifdef TAPE_DEBUG
  873. debug_text_event (tape_debug_area,6,"xera ccwg");
  874. #endif /* TAPE_DEBUG */
  875. return cqr;
  876. }
  878. /*
  879.  * MTSETDENSITY: set tape density.
  880.  */
  881. ccw_req_t *
  882. tape34xx_mtsetdensity (tape_info_t * ti, int count)
  883. {
  884. long lockflags;
  885. ccw_req_t *cqr;
  886. ccw1_t *ccw;
  887. cqr = tape_alloc_ccw_req (ti, 2, 0);
  888. if (!cqr) {
  889. #ifdef TAPE_DEBUG
  890.         debug_text_exception (tape_debug_area,6,"xden nomem");
  891. #endif /* TAPE_DEBUG */
  892. return NULL;
  893. }
  894. ccw = cqr->cpaddr;
  895. ccw->cmd_code = MODE_SET_DB;
  896. ccw->flags = CCW_FLAG_CC;
  897. ccw->count = 1;
  898. set_normalized_cda (ccw, (unsigned long) (&(((tape34xx_disc_data_t *) ti->discdata)->modeset_byte)));
  899. ccw++;
  900. ccw->cmd_code = NOP;
  901. ccw->flags = 0;
  902. ccw->count = 0;
  903. ccw->cda = (unsigned long) (&(ccw->cmd_code));
  904. s390irq_spin_lock_irqsave (ti->devinfo.irq, lockflags);
  905. ti->kernbuf = NULL;
  906. ti->userbuf = NULL;
  907. tapestate_set (ti, TS_NOP_INIT);
  908. s390irq_spin_unlock_irqrestore (ti->devinfo.irq, lockflags);
  909. #ifdef TAPE_DEBUG
  910. debug_text_event (tape_debug_area,6,"xden ccwg");
  911. #endif /* TAPE_DEBUG */
  912. return cqr;
  913. }
  915. /*
  916.  * MTSEEK: seek to the specified block.
  917.  */
  918. ccw_req_t *
  919. tape34xx_mtseek (tape_info_t * ti, int count)
  920. {
  921. long lockflags;
  922. __u8 *data;
  923. ccw_req_t *cqr;
  924. ccw1_t *ccw;
  925. if ((data = kmalloc (4 * sizeof (__u8), GFP_KERNEL)) == NULL) {
  926. #ifdef TAPE_DEBUG
  927.         debug_text_exception (tape_debug_area,6,"xsee nomem");
  928. #endif /* TAPE_DEBUG */
  929. return NULL;
  930. }
  931. data[0] = 0x01;
  932. data[1] = data[2] = data[3] = 0x00;
  933. if (count >= 4194304) {
  934. #ifdef TAPE_DEBUG
  935.         debug_text_exception (tape_debug_area,6,"xsee parm");
  936. #endif /* TAPE_DEBUG */
  937. kfree(data);
  938. return NULL;
  939. }
  940. if (((tape34xx_disc_data_t *) ti->discdata)->modeset_byte & 0x08) // IDRC on
  942. data[1] = data[1] | 0x80;
  943. data[3] += count % 256;
  944. data[2] += (count / 256) % 256;
  945. data[1] += (count / 65536);
  946. #ifdef TAPE_DEBUG
  947. debug_text_event (tape_debug_area,6,"xsee id:");
  948. debug_int_event (tape_debug_area,6,count);
  949. #endif /* TAPE_DEBUG */
  950. cqr = tape_alloc_ccw_req (ti, 3, 0);
  951. if (!cqr) {
  952. #ifdef TAPE_DEBUG
  953.         debug_text_exception (tape_debug_area,6,"xsee nomem");
  954. #endif /* TAPE_DEBUG */
  955. kfree (data);
  956. return NULL;
  957. }
  958. ccw = cqr->cpaddr;
  959. ccw->cmd_code = MODE_SET_DB;
  960. ccw->flags = CCW_FLAG_CC;
  961. ccw->count = 1;
  962. set_normalized_cda (ccw, (unsigned long) (&(((tape34xx_disc_data_t *) ti->discdata)->modeset_byte)));
  963. ccw++;
  964. ccw->cmd_code = LOCATE;
  965. ccw->flags = CCW_FLAG_CC;
  966. ccw->count = 4;
  967. set_normalized_cda (ccw, (unsigned long) data);
  968. ccw++;
  969. ccw->cmd_code = NOP;
  970. ccw->flags = 0;
  971. ccw->count = 0;
  972. ccw->cda = (unsigned long) (&(ccw->cmd_code));
  973. s390irq_spin_lock_irqsave (ti->devinfo.irq, lockflags);
  974. ti->kernbuf = data;
  975. ti->userbuf = NULL;
  976. tapestate_set (ti, TS_LBL_INIT);
  977. s390irq_spin_unlock_irqrestore (ti->devinfo.irq, lockflags);
  978. #ifdef TAPE_DEBUG
  979. debug_text_event (tape_debug_area,6,"xsee ccwg");
  980. #endif /* TAPE_DEBUG */
  981. return cqr;
  982. }
  984. /*
  985.  * MTTELL: Tell block. Return the number of block relative to current file.
  986.  */
  987. ccw_req_t *
  988. tape34xx_mttell (tape_info_t * ti, int count)
  989. {
  990. long lockflags;
  991. ccw_req_t *cqr;
  992. ccw1_t *ccw;
  993. void *mem;
  994. cqr = tape_alloc_ccw_req (ti, 2, 0);
  995. if (!cqr) {
  996. #ifdef TAPE_DEBUG
  997.         debug_text_exception (tape_debug_area,6,"xtel nomem");
  998. #endif /* TAPE_DEBUG */
  999. return NULL;
  1000. }
  1001. mem = kmalloc (8, GFP_KERNEL);
  1002. if (!mem) {
  1003. tape_free_request (cqr);
  1004. #ifdef TAPE_DEBUG
  1005.         debug_text_exception (tape_debug_area,6,"xtel nomem");
  1006. #endif /* TAPE_DEBUG */
  1007. return NULL;
  1008. }
  1009. ccw = cqr->cpaddr;
  1010. ccw->cmd_code = MODE_SET_DB;
  1011. ccw->flags = CCW_FLAG_CC;
  1012. ccw->count = 1;
  1013. set_normalized_cda (ccw, (unsigned long) (&(((tape34xx_disc_data_t *) ti->discdata)->modeset_byte)));
  1014. ccw++;
  1016. ccw->cmd_code = READ_BLOCK_ID;
  1017. ccw->flags = 0;
  1018. ccw->count = 8;
  1019. set_normalized_cda (ccw, (unsigned long) mem);
  1020. s390irq_spin_lock_irqsave (ti->devinfo.irq, lockflags);
  1021. ti->kernbuf = mem;
  1022. ti->userbuf = NULL;
  1023. tapestate_set (ti, TS_RBI_INIT);
  1024. s390irq_spin_unlock_irqrestore (ti->devinfo.irq, lockflags);
  1025. #ifdef TAPE_DEBUG
  1026. debug_text_event (tape_debug_area,6,"xtel ccwg");
  1027. #endif /* TAPE_DEBUG */
  1028. return cqr;
  1029. }
  1031. /*
  1032.  * MTSETDRVBUFFER: Set the tape drive buffer code to number.
  1033.  * Implement NOP.
  1034.  */
  1035. ccw_req_t *
  1036. tape34xx_mtsetdrvbuffer (tape_info_t * ti, int count)
  1037. {
  1038. long lockflags;
  1039. ccw_req_t *cqr;
  1040. ccw1_t *ccw;
  1041. cqr = tape_alloc_ccw_req (ti, 2, 0);
  1042. if (!cqr) {
  1043. #ifdef TAPE_DEBUG
  1044.         debug_text_exception (tape_debug_area,6,"xbuf nomem");
  1045. #endif /* TAPE_DEBUG */
  1046. return NULL;
  1047. }
  1048. ccw = cqr->cpaddr;
  1049. ccw->cmd_code = MODE_SET_DB;
  1050. ccw->flags = CCW_FLAG_CC;
  1051. ccw->count = 1;
  1052. set_normalized_cda (ccw, (unsigned long) (&(((tape34xx_disc_data_t *) ti->discdata)->modeset_byte)));
  1053. ccw++;
  1054. ccw->cmd_code = NOP;
  1055. ccw->flags = 0;
  1056. ccw->count = 0;
  1057. ccw->cda = (unsigned long) (&(ccw->cmd_code));
  1058. s390irq_spin_lock_irqsave (ti->devinfo.irq, lockflags);
  1059. ti->kernbuf = NULL;
  1060. ti->userbuf = NULL;
  1061. tapestate_set (ti, TS_NOP_INIT);
  1062. s390irq_spin_unlock_irqrestore (ti->devinfo.irq, lockflags);
  1063. #ifdef TAPE_DEBUG
  1064. debug_text_event (tape_debug_area,6,"xbuf ccwg");
  1065. #endif /* TAPE_DEBUG */
  1066. return cqr;
  1067. }
  1069. /*
  1070.  * MTLOCK: Locks the tape drive door.
  1071.  * Implement NOP CCW command.
  1072.  */
  1073. ccw_req_t *
  1074. tape34xx_mtlock (tape_info_t * ti, int count)
  1075. {
  1076. long lockflags;
  1077. ccw_req_t *cqr;
  1078. ccw1_t *ccw;
  1079. cqr = tape_alloc_ccw_req (ti, 2, 0);
  1080. if (!cqr) {
  1081. #ifdef TAPE_DEBUG
  1082.         debug_text_exception (tape_debug_area,6,"xloc nomem");
  1083. #endif /* TAPE_DEBUG */
  1084. return NULL;
  1085. }
  1086. ccw = cqr->cpaddr;
  1087. ccw->cmd_code = MODE_SET_DB;
  1088. ccw->flags = CCW_FLAG_CC;
  1089. ccw->count = 1;
  1090. set_normalized_cda (ccw, (unsigned long) (&(((tape34xx_disc_data_t *) ti->discdata)->modeset_byte)));
  1091. ccw++;
  1092. ccw->cmd_code = NOP;
  1093. ccw->flags = 0;
  1094. ccw->count = 0;
  1095. ccw->cda = (unsigned long) (&(ccw->cmd_code));
  1096. s390irq_spin_lock_irqsave (ti->devinfo.irq, lockflags);
  1097. ti->kernbuf = NULL;
  1098. ti->userbuf = NULL;
  1099. tapestate_set (ti, TS_NOP_INIT);
  1100. s390irq_spin_unlock_irqrestore (ti->devinfo.irq, lockflags);
  1101. #ifdef TAPE_DEBUG
  1102. debug_text_event (tape_debug_area,6,"xloc ccwg");
  1103. #endif /* TAPE_DEBUG */
  1104. return cqr;
  1105. }
  1107. /*
  1108.  * MTUNLOCK: Unlocks the tape drive door.
  1109.  * Implement the NOP CCW command.
  1110.  */
  1111. ccw_req_t *
  1112. tape34xx_mtunlock (tape_info_t * ti, int count)
  1113. {
  1114. long lockflags;
  1115. ccw_req_t *cqr;
  1116. ccw1_t *ccw;
  1117. cqr = tape_alloc_ccw_req (ti, 2, 0);
  1118. if (!cqr) {
  1119. #ifdef TAPE_DEBUG
  1120.         debug_text_exception (tape_debug_area,6,"xulk nomem");
  1121. #endif /* TAPE_DEBUG */
  1122. return NULL;
  1123. }
  1124. ccw = cqr->cpaddr;
  1125. ccw->cmd_code = MODE_SET_DB;
  1126. ccw->flags = CCW_FLAG_CC;
  1127. ccw->count = 1;
  1128. set_normalized_cda (ccw, (unsigned long) (&(((tape34xx_disc_data_t *) ti->discdata)->modeset_byte)));
  1129. ccw++;
  1130. ccw->cmd_code = NOP;
  1131. ccw->flags = 0;
  1132. ccw->count = 0;
  1133. ccw->cda = (unsigned long) (&(ccw->cmd_code));
  1134. s390irq_spin_lock_irqsave (ti->devinfo.irq, lockflags);
  1135. ti->kernbuf = NULL;
  1136. ti->userbuf = NULL;
  1137. tapestate_set (ti, TS_NOP_INIT);
  1138. s390irq_spin_unlock_irqrestore (ti->devinfo.irq, lockflags);
  1139. #ifdef TAPE_DEBUG
  1140. debug_text_event (tape_debug_area,6,"xulk ccwg");
  1141. #endif /* TAPE_DEBUG */
  1142. return cqr;
  1143. }
  1145. /*
  1146.  * MTLOAD: Loads the tape.
  1147.  * This function is not implemented and returns NULL, which causes the Frontend to wait for a medium being loaded.
  1148.  *  The 3480/3490 type Tapes do not support a load command
  1149.  */
  1150. ccw_req_t *
  1151. tape34xx_mtload (tape_info_t * ti, int count)
  1152. {
  1153.          return NULL;
  1154. }
  1156. /*
  1157.  * MTUNLOAD: Rewind the tape and unload it.
  1158.  */
  1159. ccw_req_t *
  1160. tape34xx_mtunload (tape_info_t * ti, int count)
  1161. {
  1162. long lockflags;
  1163. ccw_req_t *cqr;
  1164. ccw1_t *ccw;
  1165. cqr = tape_alloc_ccw_req (ti, 3, 32);
  1166. if (!cqr) {
  1167. #ifdef TAPE_DEBUG
  1168.         debug_text_exception (tape_debug_area,6,"xunl nomem");
  1169. #endif /* TAPE_DEBUG */
  1170. return NULL;
  1171. }
  1172. ccw = cqr->cpaddr;
  1173. ccw->cmd_code = MODE_SET_DB;
  1174. ccw->flags = CCW_FLAG_CC;
  1175. ccw->count = 1;
  1176. set_normalized_cda (ccw, (unsigned long) (&(((tape34xx_disc_data_t *) ti->discdata)->modeset_byte)));
  1177. ccw++;
  1178. ccw->cmd_code = REWIND_UNLOAD;
  1179. ccw->flags = CCW_FLAG_CC;
  1180. ccw->count = 1;
  1181. ccw->cda = (unsigned long) (&(ccw->cmd_code));
  1182. ccw++;
  1183. ccw->cmd_code = SENSE;
  1184. ccw->flags = 0;
  1185. ccw->count = 32;
  1186. ccw->cda = (unsigned long) cqr->cpaddr;
  1187. s390irq_spin_lock_irqsave (ti->devinfo.irq, lockflags);
  1188. ti->kernbuf = NULL;
  1189. ti->userbuf = NULL;
  1190. tapestate_set (ti, TS_RUN_INIT);
  1191. s390irq_spin_unlock_irqrestore (ti->devinfo.irq, lockflags);
  1192. #ifdef TAPE_DEBUG
  1193. debug_text_event (tape_debug_area,6,"xunl ccwg");
  1194. #endif /* TAPE_DEBUG */
  1195. return cqr;
  1196. }
  1198. /*
  1199.  * MTCOMPRESSION: used to enable compression.
  1200.  * Sets the IDRC on/off.
  1201.  */
  1202. ccw_req_t *
  1203. tape34xx_mtcompression (tape_info_t * ti, int count)
  1204. {
  1205. long lockflags;
  1206. ccw_req_t *cqr;
  1207. ccw1_t *ccw;
  1208. if ((count < 0) || (count > 1)) {
  1209. #ifdef TAPE_DEBUG
  1210.         debug_text_exception (tape_debug_area,6,"xcom parm");
  1211. #endif /* TAPE_DEBUG */
  1212. return NULL;
  1213. }
  1214. if (count == 0)
  1215. ((tape34xx_disc_data_t *) ti->discdata)->modeset_byte = 0x00; // IDRC off
  1217. else
  1218. ((tape34xx_disc_data_t *) ti->discdata)->modeset_byte = 0x08; // IDRC on
  1220. cqr = tape_alloc_ccw_req (ti, 2, 0);
  1221. if (!cqr) {
  1222. #ifdef TAPE_DEBUG
  1223.         debug_text_exception (tape_debug_area,6,"xcom nomem");
  1224. #endif /* TAPE_DEBUG */
  1225. return NULL;
  1226. }
  1227. ccw = cqr->cpaddr;
  1228. ccw->cmd_code = MODE_SET_DB;
  1229. ccw->flags = CCW_FLAG_CC;
  1230. ccw->count = 1;
  1231. set_normalized_cda (ccw, (unsigned long) (&(((tape34xx_disc_data_t *) ti->discdata)->modeset_byte)));
  1232. ccw++;
  1233. ccw->cmd_code = NOP;
  1234. ccw->flags = 0;
  1235. ccw->count = 0;
  1236. ccw->cda = (unsigned long) (&(ccw->cmd_code));
  1237. s390irq_spin_lock_irqsave (ti->devinfo.irq, lockflags);
  1238. ti->kernbuf = NULL;
  1239. ti->userbuf = NULL;
  1240. tapestate_set (ti, TS_NOP_INIT);
  1241. s390irq_spin_unlock_irqrestore (ti->devinfo.irq, lockflags);
  1242. #ifdef TAPE_DEBUG
  1243. debug_text_event (tape_debug_area,6,"xcom ccwg");
  1244. #endif /* TAPE_DEBUG */
  1245. return cqr;
  1246. }
  1248. /*
  1249.  * MTSTPART: Move the tape head at the partition with the number 'count'.
  1250.  * Implement the NOP CCW command.
  1251.  */
  1252. ccw_req_t *
  1253. tape34xx_mtsetpart (tape_info_t * ti, int count)
  1254. {
  1255. long lockflags;
  1256. ccw_req_t *cqr;
  1257. ccw1_t *ccw;
  1258. cqr = tape_alloc_ccw_req (ti, 2, 0);
  1259. if (!cqr) {
  1260. #ifdef TAPE_DEBUG
  1261.         debug_text_exception (tape_debug_area,6,"xspa nomem");
  1262. #endif /* TAPE_DEBUG */     
  1263. return NULL;
  1264. }
  1265. ccw = cqr->cpaddr;
  1266. ccw->cmd_code = MODE_SET_DB;
  1267. ccw->flags = CCW_FLAG_CC;
  1268. ccw->count = 1;
  1269. set_normalized_cda (ccw, (unsigned long) (&(((tape34xx_disc_data_t *) ti->discdata)->modeset_byte)));
  1270. ccw++;
  1271. ccw->cmd_code = NOP;
  1272. ccw->flags = 0;
  1273. ccw->count = 0;
  1274. ccw->cda = (unsigned long) (&(ccw->cmd_code));
  1275. s390irq_spin_lock_irqsave (ti->devinfo.irq, lockflags);
  1276. ti->kernbuf = NULL;
  1277. ti->userbuf = NULL;
  1278. tapestate_set (ti, TS_NOP_INIT);
  1279. s390irq_spin_unlock_irqrestore (ti->devinfo.irq, lockflags);
  1280. #ifdef TAPE_DEBUG
  1281. debug_text_event (tape_debug_area,6,"xspa ccwg");
  1282. #endif /* TAPE_DEBUG */
  1283. return cqr;
  1284. }
  1286. /*
  1287.  * MTMKPART: .... dummy .
  1288.  * Implement the NOP CCW command.
  1289.  */
  1290. ccw_req_t *
  1291. tape34xx_mtmkpart (tape_info_t * ti, int count)
  1292. {
  1293. long lockflags;
  1294. ccw_req_t *cqr;
  1295. ccw1_t *ccw;
  1296. cqr = tape_alloc_ccw_req (ti, 2, 0);
  1297. if (!cqr) {
  1298. #ifdef TAPE_DEBUG
  1299.         debug_text_exception (tape_debug_area,6,"xnpa nomem");
  1300. #endif /* TAPE_DEBUG */
  1301. return NULL;
  1302. }
  1303. ccw = cqr->cpaddr;
  1304. ccw->cmd_code = MODE_SET_DB;
  1305. ccw->flags = CCW_FLAG_CC;
  1306. ccw->count = 1;
  1307. set_normalized_cda (ccw, (unsigned long) (&(((tape34xx_disc_data_t *) ti->discdata)->modeset_byte)));
  1308. ccw++;
  1309. ccw->cmd_code = NOP;
  1310. ccw->flags = 0;
  1311. ccw->count = 0;
  1312. ccw->cda = (unsigned long) (&(ccw->cmd_code));
  1313. s390irq_spin_lock_irqsave (ti->devinfo.irq, lockflags);
  1314. ti->kernbuf = NULL;
  1315. ti->userbuf = NULL;
  1316. tapestate_set (ti, TS_NOP_INIT);
  1317. s390irq_spin_unlock_irqrestore (ti->devinfo.irq, lockflags);
  1318. #ifdef TAPE_DEBUG
  1319. debug_text_event (tape_debug_area,6,"xnpa ccwg");
  1320. #endif /* TAPE_DEBUG */
  1321. return cqr;
  1322. }
  1324. /*
  1325.  * MTIOCGET: query the tape drive status.
  1326.  */
  1327. ccw_req_t *
  1328. tape34xx_mtiocget (tape_info_t * ti, int count)
  1329. {
  1330. return NULL;
  1331. }
  1333. /*
  1334.  * MTIOCPOS: query the tape position.
  1335.  */
  1336. ccw_req_t *
  1337. tape34xx_mtiocpos (tape_info_t * ti, int count)
  1338. {
  1339. return NULL;
  1340. }
  1342. ccw_req_t * tape34xx_bread (struct request *req,tape_info_t* ti,int tapeblock_major) {
  1343. ccw_req_t *cqr;
  1344. ccw1_t *ccw;
  1345. __u8 *data;
  1346. int s2b = blksize_size[tapeblock_major][ti->blk_minor]/hardsect_size[tapeblock_major][ti->blk_minor];
  1347. int realcount;
  1348. int size,bhct = 0;
  1349. struct buffer_head* bh;
  1350. for (bh = req->bh; bh; bh = bh->b_reqnext) {
  1351. if (bh->b_size > blksize_size[tapeblock_major][ti->blk_minor])
  1352. for (size = 0; size < bh->b_size; size += blksize_size[tapeblock_major][ti->blk_minor])
  1353. bhct++;
  1354. else
  1355. bhct++;
  1356. }
  1357. if ((data = kmalloc (4 * sizeof (__u8), GFP_ATOMIC)) == NULL) {
  1358. #ifdef TAPE_DEBUG
  1359.         debug_text_exception (tape_debug_area,3,"xBREDnomem");
  1360. #endif /* TAPE_DEBUG */
  1361. return NULL;
  1362. }
  1363. data[0] = 0x01;
  1364. data[1] = data[2] = data[3] = 0x00;
  1365. realcount=req->sector/s2b;
  1366. if (((tape34xx_disc_data_t *) ti->discdata)->modeset_byte & 0x08) // IDRC on
  1368. data[1] = data[1] | 0x80;
  1369. data[3] += realcount % 256;
  1370. data[2] += (realcount / 256) % 256;
  1371. data[1] += (realcount / 65536);
  1372. #ifdef TAPE_DEBUG
  1373. debug_text_event (tape_debug_area,6,"xBREDid:");
  1374. debug_int_event (tape_debug_area,6,realcount);
  1375. #endif /* TAPE_DEBUG */
  1376. cqr = tape_alloc_ccw_req (ti, 2+bhct+1, 0);
  1377. if (!cqr) {
  1378. #ifdef TAPE_DEBUG
  1379.         debug_text_exception (tape_debug_area,6,"xBREDnomem");
  1380. #endif /* TAPE_DEBUG */
  1381. kfree(data);
  1382. return NULL;
  1383. }
  1384. ccw = cqr->cpaddr;
  1385. ccw->cmd_code = MODE_SET_DB;
  1386. ccw->flags = CCW_FLAG_CC;
  1387. ccw->count = 1;
  1388. set_normalized_cda (ccw, (unsigned long) (&(((tape34xx_disc_data_t *) ti->discdata)->modeset_byte)));
  1389. if (realcount!=ti->position) {
  1390.     ccw++;
  1391.     ccw->cmd_code = LOCATE;
  1392.     ccw->flags = CCW_FLAG_CC;
  1393.     ccw->count = 4;
  1394.     set_normalized_cda (ccw, (unsigned long) data);
  1395. }
  1396. ti->position=realcount+req->nr_sectors/s2b;
  1397. for (bh=req->bh;bh!=NULL;) {
  1398.         ccw->flags = CCW_FLAG_CC;
  1399. if (bh->b_size >= blksize_size[tapeblock_major][ti->blk_minor]) {
  1400. for (size = 0; size < bh->b_size; size += blksize_size[tapeblock_major][ti->blk_minor]) {
  1401.         ccw++;
  1402. ccw->flags = CCW_FLAG_CC;
  1403. ccw->cmd_code = READ_FORWARD;
  1404. ccw->count = blksize_size[tapeblock_major][ti->blk_minor];
  1405. set_normalized_cda (ccw, __pa (bh->b_data + size));
  1406. }
  1407. bh = bh->b_reqnext;
  1408. } else { /* group N bhs to fit into byt_per_blk */
  1409. for (size = 0; bh != NULL && size < blksize_size[tapeblock_major][ti->blk_minor];) {
  1410. ccw++;
  1411. ccw->flags = CCW_FLAG_DC;
  1412. ccw->cmd_code = READ_FORWARD;
  1413. ccw->count = bh->b_size;
  1414. set_normalized_cda (ccw, __pa (bh->b_data));
  1415. size += bh->b_size;
  1416. bh = bh->b_reqnext;
  1417. }
  1418. if (size != blksize_size[tapeblock_major][ti->blk_minor]) {
  1419. PRINT_WARN ("Cannot fulfill small request %d vs. %d (%ld sects)n",
  1420.     size,
  1421.     blksize_size[tapeblock_major][ti->blk_minor],
  1422.     req->nr_sectors);
  1423. kfree(data);
  1424. tape_free_request (cqr);
  1425. return NULL;
  1426. }
  1427. }
  1428. }
  1429. ccw -> flags &= ~(CCW_FLAG_DC);
  1430. ccw -> flags |= (CCW_FLAG_CC);
  1431. ccw++;
  1432. ccw->cmd_code = NOP;
  1433. ccw->flags = 0;
  1434. ccw->count = 0;
  1435. ccw->cda = (unsigned long) (&(ccw->cmd_code));
  1436. ti->kernbuf = data;
  1437. ti->userbuf = NULL;
  1438. tapestate_set (ti, TS_BLOCK_INIT);
  1439. #ifdef TAPE_DEBUG
  1440. debug_text_event (tape_debug_area,6,"xBREDccwg");
  1441. #endif /* TAPE_DEBUG */
  1442. return cqr;
  1443. }
  1444. void tape34xx_free_bread (ccw_req_t* cqr,struct _tape_info_t* ti) {
  1445.     ccw1_t* ccw;
  1446.     for (ccw=(ccw1_t*)cqr->cpaddr;(ccw->flags & CCW_FLAG_CC)||(ccw->flags & CCW_FLAG_DC);ccw++) 
  1447. if ((ccw->cmd_code == MODE_SET_DB) ||
  1448.     (ccw->cmd_code == LOCATE) ||
  1449.     (ccw->cmd_code == READ_FORWARD))
  1450.     clear_normalized_cda(ccw);
  1451.     tape_free_request(cqr);
  1452.     kfree(ti->kernbuf);
  1453.     ti->kernbuf=NULL;
  1454. }
  1456. /* event handlers */
  1457. void
  1458. tape34xx_default_handler (tape_info_t * ti)
  1459. {
  1460. #ifdef TAPE_DEBUG
  1461.     debug_text_event (tape_debug_area,6,"xdefhandle");
  1462. #endif /* TAPE_DEBUG */
  1463. PRINT_ERR ("TAPE34XX: An unexpected Unit Check occurred.n");
  1464. PRINT_ERR ("TAPE34XX: Please read Documentation/s390/TAPE and report it!n");
  1465. PRINT_ERR ("TAPE34XX: Current state is: %s",
  1466.    (((tapestate_get (ti) < TS_SIZE) && (tapestate_get (ti) >= 0)) ?
  1467.     state_verbose[tapestate_get (ti)] : "->UNKNOWN STATE<-"));
  1468. tape_dump_sense (&ti->devstat);
  1469. ti->rc = -EIO;
  1470. ti->wanna_wakeup=1;
  1471.         switch (tapestate_get(ti)) {
  1472.         case TS_REW_RELEASE_INIT:
  1473.             tapestate_set(ti,TS_FAILED);
  1474.             wake_up (&ti->wq);
  1475.             break;
  1476.         case TS_BLOCK_INIT:
  1477.             tapestate_set(ti,TS_FAILED);
  1478.             schedule_tapeblock_exec_IO(ti);
  1479.             break;
  1480.         default:
  1481.             tapestate_set(ti,TS_FAILED);
  1482.             wake_up_interruptible (&ti->wq);
  1483.         }      
  1484. }
  1486. void
  1487. tape34xx_unexpect_uchk_handler (tape_info_t * ti)
  1488. {
  1489. if ((ti->devstat.ii.sense.data[0] == 0x40) &&
  1490.     (ti->devstat.ii.sense.data[1] == 0x40) &&
  1491.     (ti->devstat.ii.sense.data[3] == 0x43)) {
  1492. // no tape in the drive
  1493.         PRINT_INFO ("Drive %d not ready. No volume loaded.n", ti->rew_minor / 2);
  1494. #ifdef TAPE_DEBUG
  1495.         debug_text_event (tape_debug_area,3,"xuuh nomed");
  1496. #endif /* TAPE_DEBUG */
  1497. tapestate_set (ti, TS_FAILED);
  1498. ti->rc = -ENOMEDIUM;
  1499. ti->wanna_wakeup=1;
  1500. wake_up_interruptible (&ti->wq);
  1501. } else if ((ti->devstat.ii.sense.data[0] == 0x42) &&
  1502.    (ti->devstat.ii.sense.data[1] == 0x44) &&
  1503.    (ti->devstat.ii.sense.data[3] == 0x3b)) {
  1504.                 PRINT_INFO ("Media in drive %d was changed!n",
  1505.     ti->rew_minor / 2);
  1506. #ifdef TAPE_DEBUG
  1507. debug_text_event (tape_debug_area,3,"xuuh medchg");
  1508. #endif
  1509. /* nothing to do. chan end & dev end will be reported when io is finished */
  1510. } else {
  1511. #ifdef TAPE_DEBUG
  1512.         debug_text_event (tape_debug_area,3,"xuuh unexp");
  1513.         debug_text_event (tape_debug_area,3,"state:");
  1514.         debug_text_event (tape_debug_area,3,((tapestate_get (ti) < TS_SIZE) && 
  1515.      (tapestate_get (ti) >= 0)) ?
  1516.   state_verbose[tapestate_get (ti)] : 
  1517.   "TS UNKNOWN");
  1518. #endif /* TAPE_DEBUG */
  1519. tape34xx_default_handler (ti);
  1520. }
  1521. }
  1523. void
  1524. tape34xx_unused_done (tape_info_t * ti)
  1525. {
  1526.     if (ti->medium_is_unloaded) {
  1527. // A medium was inserted in the drive!
  1528. #ifdef TAPE_DEBUG
  1529. debug_text_event (tape_debug_area,6,"xuui med");
  1530. #endif /* TAPE_DEBUG */
  1531. PRINT_WARN ("A medium was inserted into the tape.n");
  1532. ti->medium_is_unloaded=0;
  1533.     } else {
  1534. #ifdef TAPE_DEBUG
  1535.         debug_text_event (tape_debug_area,3,"unsol.irq!");
  1536.         debug_text_event (tape_debug_area,3,"dev end");
  1537.         debug_int_exception (tape_debug_area,3,ti->devinfo.irq);
  1538. #endif /* TAPE_DEBUG */
  1539. PRINT_WARN ("Unsolicited IRQ (Device End) caught in unused state.n");
  1540. tape_dump_sense (&ti->devstat);
  1541.     }
  1542. }
  1545. void
  1546. tape34xx_idle_done (tape_info_t * ti)
  1547. {
  1548.     if (ti->medium_is_unloaded) {
  1549. // A medium was inserted in the drive!
  1550. #ifdef TAPE_DEBUG
  1551. debug_text_event (tape_debug_area,6,"xuud med");
  1552. #endif /* TAPE_DEBUG */
  1553. PRINT_WARN ("A medium was inserted into the tape.n");
  1554. ti->medium_is_unloaded=0;
  1555. wake_up_interruptible (&ti->wq);
  1556.     } else {
  1557. #ifdef TAPE_DEBUG
  1558.         debug_text_event (tape_debug_area,3,"unsol.irq!");
  1559.         debug_text_event (tape_debug_area,3,"dev end");
  1560.         debug_int_exception (tape_debug_area,3,ti->devinfo.irq);
  1561. #endif /* TAPE_DEBUG */
  1562. PRINT_WARN ("Unsolicited IRQ (Device End) caught in idle state.n");
  1563. tape_dump_sense (&ti->devstat);
  1564.     }
  1565. }
  1567. void
  1568. tape34xx_block_done (tape_info_t * ti)
  1569. {
  1570. #ifdef TAPE_DEBUG
  1571.         debug_text_event (tape_debug_area,6,"x:bREQdone");
  1572. #endif /* TAPE_DEBUG */
  1573. tapestate_set(ti,TS_DONE);
  1574. schedule_tapeblock_exec_IO(ti);
  1575. }
  1577. void
  1578. tape34xx_bsf_init_done (tape_info_t * ti)
  1579. {
  1580. #ifdef TAPE_DEBUG
  1581.         debug_text_event (tape_debug_area,6,"bsf done");
  1582. #endif
  1583. tapestate_set (ti, TS_DONE);
  1584. ti->rc = 0;
  1585. ti->wanna_wakeup=1;
  1586. wake_up_interruptible (&ti->wq);
  1587. }
  1589. void
  1590. tape34xx_dse_init_done (tape_info_t * ti)
  1591. {
  1592. #ifdef TAPE_DEBUG
  1593.         debug_text_event (tape_debug_area,6,"dse done");
  1594. #endif
  1595. tapestate_set (ti, TS_DONE);
  1596. ti->rc = 0;
  1597. ti->wanna_wakeup=1;
  1598. wake_up_interruptible (&ti->wq);
  1599. }
  1601. void
  1602. tape34xx_fsf_init_done (tape_info_t * ti)
  1603. {
  1604. #ifdef TAPE_DEBUG
  1605.         debug_text_event (tape_debug_area,6,"fsf done");
  1606. #endif
  1607. tapestate_set (ti, TS_DONE);
  1608. ti->rc = 0;
  1609. ti->wanna_wakeup=1;
  1610. wake_up_interruptible (&ti->wq);
  1611. }
  1613. void
  1614. tape34xx_fsb_init_done (tape_info_t * ti)
  1615. {
  1616. #ifdef TAPE_DEBUG
  1617.         debug_text_event (tape_debug_area,6,"fsb done");
  1618. #endif
  1619. tapestate_set (ti, TS_DONE);
  1620. ti->rc = 0;
  1621. ti->wanna_wakeup=1;
  1622. wake_up_interruptible (&ti->wq);
  1623. }
  1625. void
  1626. tape34xx_bsb_init_done (tape_info_t * ti)
  1627. {
  1628. #ifdef TAPE_DEBUG
  1629.         debug_text_event (tape_debug_area,6,"bsb done");
  1630. #endif
  1631. tapestate_set (ti, TS_DONE);
  1632. ti->rc = 0;
  1633. ti->wanna_wakeup=1;
  1634. wake_up (&ti->wq);
  1635. }
  1637. void
  1638. tape34xx_lbl_init_done (tape_info_t * ti)
  1639. {
  1640. #ifdef TAPE_DEBUG
  1641.         debug_text_event (tape_debug_area,6,"lbl done");
  1642. #endif
  1643. tapestate_set (ti, TS_DONE);
  1644. ti->rc = 0;
  1645. //s390irq_spin_unlock(tape->devinfo.irq);
  1646. ti->wanna_wakeup=1;
  1647. wake_up (&ti->wq);
  1648. }
  1650. void
  1651. tape34xx_nop_init_done (tape_info_t * ti)
  1652. {
  1653. #ifdef TAPE_DEBUG
  1654.         debug_text_event (tape_debug_area,6,"nop done..");
  1655.         debug_text_exception (tape_debug_area,6,"or rew/rel");
  1656. #endif
  1657. tapestate_set (ti, TS_DONE);
  1658. ti->rc = 0;
  1659. //s390irq_spin_unlock(tape->devinfo.irq);
  1660. ti->wanna_wakeup=1;
  1661. wake_up (&ti->wq);
  1662. }
  1664. void
  1665. tape34xx_rfo_init_done (tape_info_t * ti)
  1666. {
  1667. #ifdef TAPE_DEBUG
  1668.         debug_text_event (tape_debug_area,6,"rfo done");
  1669. #endif
  1670. tapestate_set (ti, TS_DONE);
  1671. ti->rc = 0;
  1672. ti->wanna_wakeup=1;
  1673. wake_up (&ti->wq);
  1674. }
  1676. void
  1677. tape34xx_rbi_init_done (tape_info_t * ti)
  1678. {
  1679. __u8 *data;
  1680. #ifdef TAPE_DEBUG
  1681. int i;
  1682. #endif
  1683. tapestate_set (ti, TS_FAILED);
  1684. data = ti->kernbuf;
  1685. ti->rc = data[3];
  1686. ti->rc += 256 * data[2];
  1687. ti->rc += 65536 * (data[1] & 0x3F);
  1688. #ifdef TAPE_DEBUG
  1689.         debug_text_event (tape_debug_area,6,"rbi done");
  1690.         debug_text_event (tape_debug_area,6,"data:");
  1691. for (i=0;i<8;i++)
  1692.     debug_int_event (tape_debug_area,6,data[i]);
  1693. #endif
  1694. ti->wanna_wakeup=1;
  1695. wake_up_interruptible (&ti->wq);
  1696. }
  1698. void
  1699. tape34xx_rew_init_done (tape_info_t * ti)
  1700. {
  1701. #ifdef TAPE_DEBUG
  1702.         debug_text_event (tape_debug_area,6,"rew done");
  1703. #endif
  1704. //BH: use irqsave
  1705. //s390irq_spin_lock(tape->devinfo.irq);
  1706. tapestate_set (ti, TS_DONE);
  1707. ti->rc = 0;
  1708. //s390irq_spin_unlock(tape->devinfo.irq);
  1709. ti->wanna_wakeup=1;
  1710. wake_up_interruptible (&ti->wq);
  1711. }
  1713. void
  1714. tape34xx_rew_release_init_done (tape_info_t * ti)
  1715. {
  1716. #ifdef TAPE_DEBUG
  1717.         debug_text_event (tape_debug_area,6,"rewR done");
  1718. #endif
  1719. tapestate_set (ti, TS_DONE);
  1720. ti->rc = 0;
  1721. //s390irq_spin_unlock(tape->devinfo.irq);
  1722. ti->wanna_wakeup=1;
  1723. wake_up (&ti->wq);
  1724. }
  1726. void
  1727. tape34xx_run_init_done (tape_info_t * ti)
  1728. {
  1729. #ifdef TAPE_DEBUG
  1730.         debug_text_event (tape_debug_area,6,"rew done");
  1731. #endif
  1732. tapestate_set (ti, TS_DONE);
  1733. ti->rc = 0;
  1734. ti->wanna_wakeup=1;
  1735. wake_up_interruptible (&ti->wq);
  1736. }
  1738. void
  1739. tape34xx_wri_init_done (tape_info_t * ti)
  1740. {
  1741. #ifdef TAPE_DEBUG
  1742.         debug_text_event (tape_debug_area,6,"wri done");
  1743. #endif
  1744. //BH: use irqsave
  1745. //s390irq_spin_lock(ti->devinfo.irq);
  1746. tapestate_set (ti, TS_DONE);
  1747. ti->rc = 0;
  1748. //s390irq_spin_unlock(ti->devinfo.irq);
  1749. ti->wanna_wakeup=1;
  1750. wake_up_interruptible (&ti->wq);
  1751. }
  1753. void
  1754. tape34xx_wtm_init_done (tape_info_t * ti)
  1755. {
  1756. #ifdef TAPE_DEBUG
  1757.         debug_text_event (tape_debug_area,3,"wtm done");
  1758. #endif
  1759. tapestate_set (ti, TS_DONE);
  1760. ti->rc = 0;
  1761. ti->wanna_wakeup=1;
  1762. wake_up_interruptible (&ti->wq);
  1763. }
  1765. /* This function analyses the tape's sense-data in case of a unit-check. If possible,
  1766.    it tries to recover from the error. Else the user is informed about the problem. */
  1767. void
  1768. tape34xx_error_recovery (tape_info_t* ti)
  1769. {
  1770.     __u8* sense=ti->devstat.ii.sense.data;
  1771.     int inhibit_cu_recovery=0;
  1772.     int cu_type=ti->discipline->cu_type;
  1773.     if ((((tape34xx_disc_data_t *) ti->discdata)->modeset_byte)&0x80) inhibit_cu_recovery=1;
  1774.     if (tapestate_get(ti)==TS_BLOCK_INIT) {
  1775. // no recovery for block device, bottom half will retry...
  1776. tape34xx_error_recovery_has_failed(ti,EIO);
  1777. return;
  1778.     }
  1779.     if (sense[0]&SENSE_COMMAND_REJECT)
  1780. switch (tapestate_get(ti)) {
  1781. case TS_BLOCK_INIT:
  1782. case TS_DSE_INIT:
  1783. case TS_EGA_INIT:
  1784. case TS_WRI_INIT:
  1785. case TS_WTM_INIT:
  1786.     if (sense[1]&SENSE_WRITE_PROTECT) {
  1787. // trying to write, but medium is write protected
  1788. tape34xx_error_recovery_has_failed(ti,EACCES);
  1789. return;
  1790.     }
  1791. default:
  1792.     tape34xx_error_recovery_HWBUG(ti,1);
  1793.     return;
  1794. }
  1795.     // special cases for various tape-states when reaching end of recorded area
  1796.     if (((sense[0]==0x08) || (sense[0]==0x10) || (sense[0]==0x12)) &&
  1797. ((sense[1]==0x40) || (sense[1]==0x0c)))
  1798. switch (tapestate_get(ti)) {
  1799. case TS_FSF_INIT:
  1800.     // Trying to seek beyond end of recorded area
  1801.     tape34xx_error_recovery_has_failed(ti,EIO);
  1802.     return;
  1803. case TS_LBL_INIT:
  1804.     // Block could not be located.
  1805.     tape34xx_error_recovery_has_failed(ti,EIO);
  1806.     return;
  1807. case TS_RFO_INIT:
  1808.     // Try to read beyond end of recorded area -> 0 bytes read
  1809.     tape34xx_error_recovery_has_failed(ti,0);
  1810.     return;
  1811. }
  1812.     // Sensing special bits
  1813.     if (sense[0]&SENSE_BUS_OUT_CHECK) {
  1814. tape34xx_error_recovery_do_retry(ti);
  1815. return;
  1816.     }
  1817.     if (sense[0]&SENSE_DATA_CHECK) {
  1818. // hardware failure, damaged tape or improper operating conditions
  1819. switch (sense[3]) {
  1820. case 0x23:
  1821.     // a read data check occurred
  1822.     if ((sense[2]&SENSE_TAPE_SYNC_MODE) ||
  1823. (inhibit_cu_recovery)) {
  1824. // data check is not permanent, may be recovered. 
  1825. // We always use async-mode with cu-recovery, so this should *never* happen.
  1826. tape34xx_error_recovery_HWBUG(ti,2);
  1827. return;
  1828.     } else {
  1829. // data check is permanent, CU recovery has failed
  1830. PRINT_WARN("Permanent read error, recovery failed!n");
  1831. tape34xx_error_recovery_has_failed(ti,EIO);
  1832. return;
  1833.     }
  1834. case 0x25:
  1835.     // a write data check occurred
  1836.     if ((sense[2]&SENSE_TAPE_SYNC_MODE) ||
  1837. (inhibit_cu_recovery)) {
  1838. // data check is not permanent, may be recovered.
  1839. // We always use async-mode with cu-recovery, so this should *never* happen.
  1840. tape34xx_error_recovery_HWBUG(ti,3);
  1841. return;
  1842.     } else {
  1843. // data check is permanent, cu-recovery has failed
  1844. PRINT_WARN("Permanent write error, recovery failed!n");
  1845. tape34xx_error_recovery_has_failed(ti,EIO);
  1846. return;
  1847.     }
  1848. case 0x26:
  1849.     // Data Check (read opposite) occurred. We'll recover this.
  1850.     tape34xx_error_recovery_read_opposite(ti);
  1851.     return;
  1852. case 0x28:
  1853.     // The ID-Mark at the beginning of the tape could not be written. This is fatal, we'll report and exit.
  1854.     PRINT_WARN("ID-Mark could not be written. Check your hardware!n");
  1855.     tape34xx_error_recovery_has_failed(ti,EIO);
  1856.     return;
  1857. case 0x31:
  1858.     // Tape void. Tried to read beyond end of device. We'll report and exit.
  1859.     PRINT_WARN("Try to read beyond end of recorded area!n");
  1860.     tape34xx_error_recovery_has_failed(ti,ENOSPC);
  1861.     return;
  1862. case 0x41:
  1863.     // Record sequence error. cu detected incorrect block-id sequence on tape. We'll report and exit.
  1864.     PRINT_WARN("Illegal block-id sequence found!n");
  1865.     tape34xx_error_recovery_has_failed(ti,EIO);
  1866.     return;
  1867.     default:
  1868.     // well, all data checks for 3480 should result in one of the above erpa-codes. if not -> bug
  1869.     // On 3490, other data-check conditions do exist.
  1870. if (cu_type==0x3480) {
  1871.     tape34xx_error_recovery_HWBUG(ti,4);
  1872.     return;
  1873. }
  1874. }
  1875.     }
  1876.     if (sense[0]&SENSE_OVERRUN) {
  1877. // A data overrun between cu and drive occurred. The channel speed is to slow! We'll report this and exit!
  1878. switch (sense[3]) {
  1879. case 0x40: // overrun error
  1880.     PRINT_WARN ("Data overrun error between control-unit and drive. Use a faster channel connection, if possible! n");
  1881.     tape34xx_error_recovery_has_failed(ti,EIO);
  1882.     return;
  1883. default:
  1884.     // Overrun bit is set, but erpa does not show overrun error. This is a bug.
  1885.     tape34xx_error_recovery_HWBUG(ti,5);
  1886.     return;
  1887. }
  1888.     }
  1889.     if (sense[1]&SENSE_RECORD_SEQUENCE_ERR) {
  1890. switch (sense[3]) {
  1891. case 0x41:
  1892.     // Record sequence error. cu detected incorrect block-id sequence on tape. We'll report and exit.
  1893.     PRINT_WARN("Illegal block-id sequence found!n");
  1894.     tape34xx_error_recovery_has_failed(ti,EIO);
  1895.     return;
  1896. default:
  1897.     // Record sequence error bit is set, but erpa does not show record sequence error. This is a bug.
  1898.     tape34xx_error_recovery_HWBUG(ti,6);
  1899.     return;
  1900. }
  1901.     }
  1902.     // Sensing erpa codes
  1903.     switch (sense[3]) {
  1904.     case 0x00:
  1905. // Everything is fine, but we got a unit check. Report and ignore!
  1906. PRINT_WARN ("Non-error sense was found. Unit-check will be ignored, expect errors...n");
  1907. return;
  1908.     case 0x21:
  1909. // Data streaming not operational. Cu switches to interlock mode, we reissue the command.
  1910. PRINT_WARN ("Data streaming not operational. Switching to interlock-mode! n");
  1911. tape34xx_error_recovery_do_retry(ti);
  1912. return;
  1913.     case 0x22:
  1914. // Path equipment check. Might be drive adapter error, buffer error on the lower interface, internal path not useable, or error during cartridge load.
  1915. // All of the above are not recoverable
  1916. PRINT_WARN ("A path equipment check occurred. One of the following conditions occurred:n");
  1917. PRINT_WARN ("drive adapter error,buffer error on the lower interface, internal path not useable, error during cartridge load.n");
  1918. tape34xx_error_recovery_has_failed(ti,EIO);
  1919. return;
  1920.     case 0x23:
  1921. // Read data check. Should have been be covered earlier -> Bug!
  1922. tape34xx_error_recovery_HWBUG(ti,7);
  1923. return;
  1924.     case 0x24:
  1925. // Load display check. Load display was command was issued, but the drive is displaying a drive check message. Can be threated as "device end".
  1926. tape34xx_error_recovery_succeded(ti);
  1927. return;
  1928.     case 0x25:
  1929. // Write data check. Should have been covered earlier -> Bug!
  1930. tape34xx_error_recovery_HWBUG(ti,8);
  1931. return;
  1932.     case 0x26:
  1933. // Data check (read opposite). Should have been covered earlier -> Bug!
  1934. tape34xx_error_recovery_HWBUG(ti,9);
  1935. return;
  1936.     case 0x27:
  1937. // Command reject. May indicate illegal channel program or buffer over/underrun. 
  1938. // Since all channel programms are issued by this driver and ought be correct,
  1939. // we assume a over/underrun situaltion and retry the channel program.
  1940. tape34xx_error_recovery_do_retry(ti);
  1941. return;
  1942.     case 0x28:
  1943. // Write id mark check. Should have beed covered earlier -> bug!
  1944. tape34xx_error_recovery_HWBUG(ti,10);
  1945. return;
  1946.     case 0x29:
  1947. // Function incompatible. Either idrc is on but hardware not capable doing idrc 
  1948. // or a perform subsystem func is issued and the cu is not online. Anyway, this 
  1949. // cannot be recovered and is an I/O error.
  1950. PRINT_WARN ("Function incompatible. Try to switch off idrc! n");
  1951. tape34xx_error_recovery_has_failed(ti,EIO);
  1952. return;
  1953.     case 0x2a:
  1954. // Unsolicited environmental data. An internal counter overflows, we can ignore
  1955. // this and reissue the cmd.
  1956. tape34xx_error_recovery_do_retry(ti);
  1957. return;
  1958.     case 0x2b:
  1959. // Environmental data present. Indicates either unload completed ok or read buffered 
  1960. // log command completed ok. 
  1961. if (tapestate_get(ti)==TS_RUN_INIT) {
  1962.     // Rewind unload completed ok.
  1963.     tape34xx_error_recovery_succeded(ti);
  1964.     return;
  1965. }
  1966. // Since we do not issue read buffered log commands, this should never occur -> bug.
  1967. tape34xx_error_recovery_HWBUG(ti,11);
  1968. return;
  1969.     case 0x2c:
  1970. // Permanent equipment check. cu has tried recovery, but did not succeed. This is an
  1971. // I/O error.
  1972. tape34xx_error_recovery_has_failed(ti,EIO);
  1973. return;
  1974.     case 0x2d:
  1975. // Data security erase failure.
  1976. if (tapestate_get(ti)==TS_DSE_INIT) {
  1977.     // report an I/O error
  1978.     tape34xx_error_recovery_has_failed(ti,EIO);
  1979.     return;
  1980. }
  1981. // Data security erase failure, but no such command issued. This is a bug.
  1982. tape34xx_error_recovery_HWBUG(ti,12);
  1983. return;
  1984.     case 0x2e:
  1985. // Not capable. This indicates either that the drive fails reading the format id mark
  1986. // or that that format specified is not supported by the drive. We write a message and
  1987. // return an I/O error.
  1988. PRINT_WARN("Drive not capable processing the tape format!");
  1989. tape34xx_error_recovery_has_failed(ti,EMEDIUMTYPE);
  1990. return;
  1991.     case 0x2f:
  1992. // This erpa is reserved. This is a bug.
  1993. tape34xx_error_recovery_HWBUG(ti,13);
  1994. return;
  1995.     case 0x30:
  1996. // The medium is write protected, while trying to write on it. We'll report this.
  1997. PRINT_WARN("Medium is write protected!n");
  1998. tape34xx_error_recovery_has_failed(ti,EACCES);
  1999. return;
  2000.     case 0x31:
  2001. // Tape void. Should have beed covered ealier -> bug
  2002. tape34xx_error_recovery_HWBUG(ti,14);
  2003. return;
  2004.     case 0x32:
  2005. // Tension loss. We cannot recover this, it's an I/O error.
  2006. PRINT_WARN("The drive lost tape tension.n");
  2007. tape34xx_error_recovery_has_failed(ti,EIO);
  2008. return;
  2009.     case 0x33:
  2010. // Load Failure. The catridge was not inserted correctly or the tape is not threaded
  2011. // correctly. We cannot recover this, the user has to reload the catridge.
  2012. PRINT_WARN("Cartridge load failure. Reload the cartridge and try again.n");
  2013. tape34xx_error_recovery_has_failed(ti,EIO);
  2014. return;
  2015.     case 0x34:
  2016. // Unload failure. The drive cannot maintain tape tension and control tape movement 
  2017. // during an unload operation. 
  2018. PRINT_WARN("Failure during cartridge unload. Please try manually.n");
  2019. if (tapestate_get(ti)!=TS_RUN_INIT) {
  2020.     tape34xx_error_recovery_HWBUG(ti,15);
  2021.     return;
  2022. }
  2023. tape34xx_error_recovery_has_failed(ti,EIO);
  2024. return;
  2025.     case 0x35:
  2026. // Drive equipment check. One of the following:
  2027. // - cu cannot recover from a drive detected error
  2028. // - a check code message is displayed on drive message/load displays
  2029. // - the cartridge loader does not respond correctly
  2030. // - a failure occurs during an index, load, or unload cycle
  2031. PRINT_WARN("Equipment check! Please check the drive and the cartridge loader.n");
  2032. tape34xx_error_recovery_has_failed(ti,EIO);
  2033. return;
  2034.     case 0x36:
  2035. switch (cu_type) {
  2036. case 0x3480:
  2037.     // This erpa is reserved for 3480 -> BUG
  2038.     tape34xx_error_recovery_HWBUG(ti,16);
  2039.     return;
  2040. case 0x3490:
  2041.     // End of data. This is a permanent I/O error, which cannot be recovered.
  2042.     // A read-type command has reached the end-of-data mark.
  2043.     tape34xx_error_recovery_has_failed(ti,EIO);
  2044.     return;
  2045. }
  2046.     case 0x37:
  2047. // Tape length error. The tape is shorter than reported in the beginning-of-tape data.
  2048. PRINT_WARN("Tape length error.n");
  2049. tape34xx_error_recovery_has_failed(ti,EIO);
  2050. return;
  2051.     case 0x38:
  2052. // Physical end of tape. A read/write operation reached the physical end of tape.
  2053. if (tapestate_get(ti)==TS_WRI_INIT ||
  2054.     tapestate_get(ti)==TS_DSE_INIT ||
  2055.     tapestate_get(ti)==TS_EGA_INIT ||
  2056.     tapestate_get(ti)==TS_WTM_INIT){
  2057.       tape34xx_error_recovery_has_failed(ti,ENOSPC);
  2058. } else {
  2059.     tape34xx_error_recovery_has_failed(ti,EIO);
  2060. }
  2061. return;
  2062.     case 0x39:
  2063. // Backward at BOT. The drive is at BOT and is requestet to move backward.
  2064. tape34xx_error_recovery_has_failed(ti,EIO);
  2065. return;
  2066.     case 0x3a:
  2067. // Drive switched not ready, but the command needs the drive to be ready.
  2068. PRINT_WARN("Drive not ready. Turn the ready/not ready switch to ready position and try again.n");
  2069. tape34xx_error_recovery_has_failed(ti,EIO);
  2070. return;
  2071.     case 0x3b:
  2072. // Manual rewind or unload. This causes an I/O error.
  2073. PRINT_WARN("Medium was rewound or unloaded manually. Expect errors! Please do only use the mtoffl and mtrew ioctl to unload tapes or rewind tapes.n");
  2074. tape34xx_error_recovery_has_failed(ti,EIO);
  2075. return;
  2076.     case 0x3c:
  2077.     case 0x3d:
  2078.     case 0x3e:
  2079.     case 0x3f:
  2080. // These erpas are reserved -> BUG
  2081. tape34xx_error_recovery_HWBUG(ti,17);
  2082. return;
  2083.     case 0x40:
  2084. // Overrun error. This should have been covered earlier -> bug.
  2085. tape34xx_error_recovery_HWBUG(ti,18);
  2086. return;
  2087.     case 0x41:
  2088. // Record sequence error. This should have been covered earlier -> bug.
  2089. tape34xx_error_recovery_HWBUG(ti,19);
  2090. return;
  2091.     case 0x42:
  2092. // Degraded mode. A condition that can cause degraded performace is detected.
  2093. PRINT_WARN("Subsystem is running in degraded mode. This may compromise your performace.n");
  2094. tape34xx_error_recovery_do_retry(ti);
  2095. return;
  2096.     case 0x43:
  2097. // Drive not ready. Probably swith the ready/not ready switch to ready?
  2098. PRINT_WARN("The drive is not ready. Maybe no medium in?n");
  2099. tape34xx_error_recovery_has_failed(ti,ENOMEDIUM);
  2100. return;
  2101.     case 0x44:
  2102. // Locate Block unsuccessfull. We'll report this.
  2103. if ((tapestate_get(ti)!=TS_BLOCK_INIT) &&
  2104.     (tapestate_get(ti)!=TS_LBL_INIT)) {
  2105.     tape34xx_error_recovery_HWBUG(ti,20); // No locate block was issued...
  2106.     return;
  2107. }
  2108. tape34xx_error_recovery_has_failed(ti,EIO);
  2109. return;
  2110.     case 0x45:
  2111. // The drive is assigned elsewhere [to a different channel path/computer].
  2112. PRINT_WARN("The drive is assigned elsewhere.n");
  2113. tape34xx_error_recovery_has_failed(ti,EIO);
  2114. return;
  2115.     case 0x46:
  2116. // Drive not online. Drive may be switched offline, the power supply may be switched off 
  2117. // or the drive address may not be set correctly.
  2118. PRINT_WARN("The drive is not online.");
  2119. tape34xx_error_recovery_has_failed(ti,EIO);
  2120. return;
  2121.     case 0x47:
  2122. // Volume fenced. cu reports volume integrity is lost! 
  2123. PRINT_WARN("Volume fenced. The volume integrity is lost! n");
  2124. tape34xx_error_recovery_has_failed(ti,EIO);
  2125. return;
  2126.     case 0x48:
  2127. // Log sense data and retry request. We'll do so...
  2128. tape34xx_error_recovery_do_retry(ti);
  2129. return;
  2130.     case 0x49:
  2131. // Bus out check. A parity check error on the bus was found. PRINT_WARN("Bus out check. A data transfer over the bus was corrupted.n");
  2132. tape34xx_error_recovery_has_failed(ti,EIO);
  2133. return;
  2134.     case 0x4a:
  2135. // Control unit erp failed. We'll report this.
  2136. PRINT_WARN("The control unit failed recovering an I/O error.n");
  2137. tape34xx_error_recovery_has_failed(ti,EIO);
  2138. return;
  2139.     case 0x4b:
  2140. // Cu and drive incompatible. The drive requests micro-program patches, which are not available on the cu.
  2141. PRINT_WARN("The drive needs microprogram patches from the control unit, which are not available.n");
  2142. tape34xx_error_recovery_has_failed(ti,EIO);
  2143. return;
  2144.     case 0x4c:
  2145. // Recovered Check-One failure. Cu develops a hardware error, but is able to recover. We'll reissue the command.
  2146. tape34xx_error_recovery_do_retry(ti);
  2147. return;
  2148.     case 0x4d:
  2149. switch (cu_type) {
  2150. case 0x3480:
  2151.     // This erpa is reserved for 3480 -> bug
  2152.            tape34xx_error_recovery_HWBUG(ti,21);
  2153.     return;
  2154. case 0x3490:
  2155.     // Resetting event received. Since the driver does not support resetting event recovery
  2156.     // (which has to be handled by the I/O Layer), we'll report and retry our command.
  2157.     tape34xx_error_recovery_do_retry(ti);
  2158.     return;
  2159. }
  2160.     case 0x4e:
  2161. switch (cu_type) {
  2162. case 0x3480:
  2163.     // This erpa is reserved for 3480 -> bug.
  2164.     tape34xx_error_recovery_HWBUG(ti,22);
  2165.     return;
  2166. case 0x3490:
  2167.     // Maximum block size exeeded. This indicates, that the block to be written is larger
  2168.     // than allowed for buffered mode. We'll report this...
  2169.     PRINT_WARN("Maximum block size for buffered mode exceeded.n");
  2170.     tape34xx_error_recovery_has_failed(ti,ENOBUFS);
  2171.     return;
  2172. }
  2173.     case 0x4f:
  2174. // These erpas are reserved -> bug
  2175. tape34xx_error_recovery_HWBUG(ti,23);
  2176. return;
  2177.     case 0x50:
  2178. // Read buffered log (Overflow). Cu is running in extended beffered log mode, and a counter overflows.
  2179. // This should never happen, since we're never running in extended buffered log mode -> bug.
  2180. tape34xx_error_recovery_do_retry(ti);
  2181. return;
  2182.     case 0x51:
  2183. // Read buffered log (EOV). EOF processing occurs while the cu is in extended buffered log mode.
  2184. // This should never happen, since we're never running in extended buffered log mode -> bug.
  2185. tape34xx_error_recovery_do_retry(ti);
  2186. return;
  2187.     case 0x52:
  2188. // End of Volume complete. Rewind unload completed ok. We'll report to the user...
  2189. if (tapestate_get(ti)!=TS_RUN_INIT) {
  2190.     tape34xx_error_recovery_HWBUG(ti,24);
  2191.     return;
  2192. }
  2193. tape34xx_error_recovery_succeded(ti);
  2194. return;
  2195.     case 0x53:
  2196. // Global command intercept. We'll have to reissue our command.
  2197. tape34xx_error_recovery_do_retry(ti);
  2198. return;
  2199.     case 0x54:
  2200. // Channel interface recovery (temporary). This can be recovered by reissuing the command.
  2201. tape34xx_error_recovery_do_retry(ti);
  2202. return;
  2203.     case 0x55:
  2204. // Channel interface recovery (permanent). This cannot be recovered, we'll inform the user.
  2205. PRINT_WARN("A permanent channel interface error occurred.n");
  2206. tape34xx_error_recovery_has_failed(ti,EIO);
  2207. return;
  2208.     case 0x56:
  2209. // Channel protocol error. This cannot be recovered.
  2210. PRINT_WARN("A channel protocol error occurred.n");
  2211. tape34xx_error_recovery_has_failed(ti,EIO);
  2212. return;
  2213.     case 0x57:
  2214. switch (cu_type) {
  2215. case 0x3480:
  2216.     // Attention intercept. We have to reissue the command.
  2217.     PRINT_WARN("An attention intercept occurred, which will be recovered.n");
  2218.     tape34xx_error_recovery_do_retry(ti);
  2219.     return;
  2220. case 0x3490:
  2221.     // Global status intercept. We have to reissue the command.
  2222.     PRINT_WARN("An global status intercept was received, which will be recovered.n");
  2223.     tape34xx_error_recovery_do_retry(ti);
  2224.     return;
  2225. }
  2226.     case 0x58:
  2227.     case 0x59:
  2228. // These erpas are reserved -> bug.
  2229. tape34xx_error_recovery_HWBUG(ti,25);
  2230. return;
  2231.     case 0x5a:
  2232. // Tape length incompatible. The tape inserted is too long, 
  2233. // which could cause damage to the tape or the drive.
  2234. PRINT_WARN("Tape length incompatible [should be IBM Cartridge System Tape]. May cause damage to drive or tape.n");
  2235. tape34xx_error_recovery_has_failed(ti,EIO);
  2236. return;
  2237.     case 0x5b:
  2238. // Format 3480 XF incompatible
  2239. if (sense[1]&SENSE_BEGINNING_OF_TAPE) {
  2240.     // Everything is fine. The tape will be overwritten in a different format.
  2241.     tape34xx_error_recovery_do_retry(ti);
  2242.     return;
  2243. }
  2244. PRINT_WARN("Tape format is incompatible to the drive, which writes 3480-2 XF.n");
  2245. tape34xx_error_recovery_has_failed(ti,EIO);
  2246. return;
  2247.     case 0x5c:
  2248. // Format 3480-2 XF incompatible
  2249. PRINT_WARN("Tape format is incompatible to the drive. The drive cannot access 3480-2 XF volumes.n");
  2250. tape34xx_error_recovery_has_failed(ti,EIO);
  2251. return;
  2252.     case 0x5d:
  2253. // Tape length violation. 
  2254. PRINT_WARN("Tape length violation [should be IBM Enhanced Capacity Cartridge System Tape]. May cause damage to drive or tape.n");
  2255. tape34xx_error_recovery_has_failed(ti,EMEDIUMTYPE);
  2256. return;
  2257.     case 0x5e:
  2258. // Compaction algorithm incompatible.
  2259. PRINT_WARN("The volume is recorded using an incompatible compaction algorith, which is not supported by the control unit.n");
  2260. tape34xx_error_recovery_has_failed(ti,EMEDIUMTYPE);
  2261. return;
  2262.     default:
  2263. // Reserved erpas -> bug
  2264. tape34xx_error_recovery_HWBUG(ti,26);
  2265. return;
  2266.     }
  2267. }
  2269. void tape34xx_error_recovery_has_failed (tape_info_t* ti,int error_id) {
  2270. #ifdef TAPE_DEBUG
  2271.     debug_text_event (tape_debug_area,3,"xerp fail");
  2272.     debug_text_event (tape_debug_area,3,(((tapestate_get (ti) < TS_SIZE) && 
  2273.       (tapestate_get (ti) >= 0)) ?
  2274. state_verbose[tapestate_get (ti)] : "UNKNOWN"));
  2275. #endif
  2276.     if ((tapestate_get(ti)!=TS_UNUSED) && (tapestate_get(ti)!=TS_IDLE)) {
  2277. tape_dump_sense(&ti->devstat);
  2278. ti->rc = -error_id;
  2279. ti->wanna_wakeup=1;
  2280. switch (tapestate_get(ti)) {
  2281. case TS_REW_RELEASE_INIT:
  2282. case TS_RFO_INIT:
  2283. case TS_RBA_INIT:
  2284.     tapestate_set(ti,TS_FAILED);
  2285.     wake_up (&ti->wq);
  2286.     break;
  2287. case TS_BLOCK_INIT:
  2288.     tapestate_set(ti,TS_FAILED);
  2289.     schedule_tapeblock_exec_IO(ti);
  2290.     break;
  2291. default:
  2292.     tapestate_set(ti,TS_FAILED);
  2293.     wake_up_interruptible (&ti->wq);
  2294. }
  2295.     } else {
  2296. PRINT_WARN("Recieved an unsolicited IRQ.n");
  2297. tape_dump_sense(&ti->devstat);
  2298.     }
  2299. }    
  2301. void tape34xx_error_recovery_succeded(tape_info_t* ti) {
  2302. #ifdef TAPE_DEBUG
  2303.     debug_text_event (tape_debug_area,3,"xerp done");
  2304.     debug_text_event (tape_debug_area,3,(((tapestate_get (ti) < TS_SIZE) && 
  2305.       (tapestate_get (ti) >= 0)) ?
  2306. state_verbose[tapestate_get (ti)] : "UNKNOWN"));
  2307. #endif
  2308.     if ((tapestate_get(ti)!=TS_UNUSED) && (tapestate_get(ti)!=TS_DONE)) {
  2309. tapestate_event (ti, TE_DONE);
  2310.     } else {
  2311. PRINT_WARN("Recieved an unsolicited IRQ.n");
  2312. tape_dump_sense(&ti->devstat);
  2313.     }
  2314. }
  2316. void tape34xx_error_recovery_do_retry(tape_info_t* ti) {
  2317. #ifdef TAPE_DEBUG
  2318.     debug_text_event (tape_debug_area,3,"xerp retr");
  2319.     debug_text_event (tape_debug_area,3,(((tapestate_get (ti) < TS_SIZE) && 
  2320.   (tapestate_get (ti) >= 0)) ?
  2321.  state_verbose[tapestate_get (ti)] : "UNKNOWN"));
  2322. #endif
  2323.     if ((tapestate_get(ti)!=TS_UNUSED) && (tapestate_get(ti)!=TS_IDLE)) {
  2324. tape_dump_sense(&ti->devstat);
  2325. while (do_IO (ti->devinfo.irq, ti->cqr->cpaddr, (unsigned long) ti->cqr, 0x00, ti->cqr->options));
  2326.     } else {
  2327. PRINT_WARN("Recieved an unsolicited IRQ.n");
  2328. tape_dump_sense(&ti->devstat);
  2329.     }
  2330. }
  2331.     
  2332. void 
  2333. tape34xx_error_recovery_read_opposite (tape_info_t* ti) {
  2334.     switch (tapestate_get(ti)) {
  2335.     case TS_RFO_INIT:
  2336. // We did read forward, but the data could not be read *correctly*.
  2337. // We will read backward and then skip forward again.
  2338. ti->cqr=tape34xx_read_opposite(ti,0);
  2339. if (ti->cqr==NULL)
  2340.     tape34xx_error_recovery_has_failed(ti,EIO);
  2341. else
  2342.     tape34xx_error_recovery_do_retry(ti);
  2343. break;
  2344.     case TS_RBA_INIT:
  2345. // We tried to read forward and backward, but hat no success -> failed.
  2346. tape34xx_error_recovery_has_failed(ti,EIO);
  2347. break;
  2348.     case TS_BLOCK_INIT:
  2349. tape34xx_error_recovery_do_retry(ti);
  2350. break;
  2351.     default:
  2352. PRINT_WARN("read_opposite_recovery_called_with_state:%sn",
  2353.    (((tapestate_get (ti) < TS_SIZE) && 
  2354.      (tapestate_get (ti) >= 0)) ?
  2355.     state_verbose[tapestate_get (ti)] : "UNKNOWN"));
  2356.     }
  2357. }
  2359. void 
  2360. tape34xx_error_recovery_HWBUG (tape_info_t* ti,int condno) {
  2361.     devstat_t* stat=&ti->devstat;
  2362.     PRINT_WARN("An unexpected condition #%d was caught in tape error recovery.n",condno);
  2363.     PRINT_WARN("Please report this incident.n");
  2364.     PRINT_WARN("State of the tape:%sn",
  2365.        (((tapestate_get (ti) < TS_SIZE) && 
  2366.  (tapestate_get (ti) >= 0)) ?
  2367. state_verbose[tapestate_get (ti)] : "UNKNOWN"));
  2368.     PRINT_INFO ("Sense data: %02X%02X%02X%02X %02X%02X%02X%02X "
  2369. " %02X%02X%02X%02X %02X%02X%02X%02X n",
  2370. stat->ii.sense.data[0], stat->ii.sense.data[1],
  2371. stat->ii.sense.data[2], stat->ii.sense.data[3],
  2372. stat->ii.sense.data[4], stat->ii.sense.data[5],
  2373. stat->ii.sense.data[6], stat->ii.sense.data[7],
  2374. stat->ii.sense.data[8], stat->ii.sense.data[9],
  2375. stat->ii.sense.data[10], stat->ii.sense.data[11],
  2376. stat->ii.sense.data[12], stat->ii.sense.data[13],
  2377. stat->ii.sense.data[14], stat->ii.sense.data[15]);
  2378.     PRINT_INFO ("Sense data: %02X%02X%02X%02X %02X%02X%02X%02X "
  2379. " %02X%02X%02X%02X %02X%02X%02X%02X n",
  2380. stat->ii.sense.data[16], stat->ii.sense.data[17],
  2381. stat->ii.sense.data[18], stat->ii.sense.data[19],
  2382. stat->ii.sense.data[20], stat->ii.sense.data[21],
  2383. stat->ii.sense.data[22], stat->ii.sense.data[23],
  2384. stat->ii.sense.data[24], stat->ii.sense.data[25],
  2385. stat->ii.sense.data[26], stat->ii.sense.data[27],
  2386. stat->ii.sense.data[28], stat->ii.sense.data[29],
  2387. stat->ii.sense.data[30], stat->ii.sense.data[31]);
  2388.     tape34xx_error_recovery_has_failed(ti,EIO);
  2389. }