drivers/s390/char/tape_std.c

   1 /*
   2  *    standard tape device functions for ibm tapes.
   3  *
   4  *  S390 and zSeries version
   5  *    Copyright IBM Corp. 2001, 2002
   6  *    Author(s): Carsten Otte <cotte@de.ibm.com>
   7  *               Michael Holzheu <holzheu@de.ibm.com>
   8  *               Tuan Ngo-Anh <ngoanh@de.ibm.com>
   9  *               Martin Schwidefsky <schwidefsky@de.ibm.com>
  10  *               Stefan Bader <shbader@de.ibm.com>
  11  */
  12
  13 #define KMSG_COMPONENT "tape"
  14 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
  15
  16 #include <linux/stddef.h>
  17 #include <linux/kernel.h>
  18 #include <linux/bio.h>
  19 #include <linux/timer.h>
  20
  21 #include <asm/types.h>
  22 #include <asm/idals.h>
  23 #include <asm/ebcdic.h>
  24 #include <asm/tape390.h>
  25
  26 #define TAPE_DBF_AREA   tape_core_dbf
  27
  28 #include "tape.h"
  29 #include "tape_std.h"
  30
  31 /*
  32  * tape_std_assign
  33  */
  34 static void
  35 tape_std_assign_timeout(unsigned long data)
  36 {
  37         struct tape_request *   request;
  38         struct tape_device *    device;
  39         int rc;
  40
  41         request = (struct tape_request *) data;
  42         device = request->device;
  43         BUG_ON(!device);
  44
  45         DBF_EVENT(3, "%08x: Assignment timeout. Device busy.\n",
  46                         device->cdev_id);
  47         rc = tape_cancel_io(device, request);
  48         if(rc)
  49                 DBF_EVENT(3, "(%08x): Assign timeout: Cancel failed with rc = "
  50                           "%i\n", device->cdev_id, rc);
  51 }
  52
  53 int
  54 tape_std_assign(struct tape_device *device)
  55 {
  56         int                  rc;
  57         struct timer_list    timeout;
  58         struct tape_request *request;
  59
  60         request = tape_alloc_request(2, 11);
  61         if (IS_ERR(request))
  62                 return PTR_ERR(request);
  63
  64         request->op = TO_ASSIGN;
  65         tape_ccw_cc(request->cpaddr, ASSIGN, 11, request->cpdata);
  66         tape_ccw_end(request->cpaddr + 1, NOP, 0, NULL);
  67
  68         /*
  69          * The assign command sometimes blocks if the device is assigned
  70          * to another host (actually this shouldn't happen but it does).
  71          * So we set up a timeout for this call.
  72          */
  73         init_timer_on_stack(&timeout);
  74         timeout.function = tape_std_assign_timeout;
  75         timeout.data     = (unsigned long) request;
  76         timeout.expires  = jiffies + 2 * HZ;
  77         add_timer(&timeout);
  78
  79         rc = tape_do_io_interruptible(device, request);
  80
  81         del_timer_sync(&timeout);
  82         destroy_timer_on_stack(&timeout);
  83
  84         if (rc != 0) {
  85                 DBF_EVENT(3, "%08x: assign failed - device might be busy\n",
  86                         device->cdev_id);
  87         } else {
  88                 DBF_EVENT(3, "%08x: Tape assigned\n", device->cdev_id);
  89         }
  90         tape_free_request(request);
  91         return rc;
  92 }
  93
  94 /*
  95  * tape_std_unassign
  96  */
  97 int
  98 tape_std_unassign (struct tape_device *device)
  99 {
 100         int                  rc;
 101         struct tape_request *request;
 102
 103         if (device->tape_state == TS_NOT_OPER) {
 104                 DBF_EVENT(3, "(%08x): Can't unassign device\n",
 105                         device->cdev_id);
 106                 return -EIO;
 107         }
 108
 109         request = tape_alloc_request(2, 11);
 110         if (IS_ERR(request))
 111                 return PTR_ERR(request);
 112
 113         request->op = TO_UNASSIGN;
 114         tape_ccw_cc(request->cpaddr, UNASSIGN, 11, request->cpdata);
 115         tape_ccw_end(request->cpaddr + 1, NOP, 0, NULL);
 116
 117         if ((rc = tape_do_io(device, request)) != 0) {
 118                 DBF_EVENT(3, "%08x: Unassign failed\n", device->cdev_id);
 119         } else {
 120                 DBF_EVENT(3, "%08x: Tape unassigned\n", device->cdev_id);
 121         }
 122         tape_free_request(request);
 123         return rc;
 124 }
 125
 126 /*
 127  * TAPE390_DISPLAY: Show a string on the tape display.
 128  */
 129 int
 130 tape_std_display(struct tape_device *device, struct display_struct *disp)
 131 {
 132         struct tape_request *request;
 133         int rc;
 134
 135         request = tape_alloc_request(2, 17);
 136         if (IS_ERR(request)) {
 137                 DBF_EVENT(3, "TAPE: load display failed\n");
 138                 return PTR_ERR(request);
 139         }
 140         request->op = TO_DIS;
 141
 142         *(unsigned char *) request->cpdata = disp->cntrl;
 143         DBF_EVENT(5, "TAPE: display cntrl=%04x\n", disp->cntrl);
 144         memcpy(((unsigned char *) request->cpdata) + 1, disp->message1, 8);
 145         memcpy(((unsigned char *) request->cpdata) + 9, disp->message2, 8);
 146         ASCEBC(((unsigned char*) request->cpdata) + 1, 16);
 147
 148         tape_ccw_cc(request->cpaddr, LOAD_DISPLAY, 17, request->cpdata);
 149         tape_ccw_end(request->cpaddr + 1, NOP, 0, NULL);
 150
 151         rc = tape_do_io_interruptible(device, request);
 152         tape_free_request(request);
 153         return rc;
 154 }
 155
 156 /*
 157  * Read block id.
 158  */
 159 int
 160 tape_std_read_block_id(struct tape_device *device, __u64 *id)
 161 {
 162         struct tape_request *request;
 163         int rc;
 164
 165         request = tape_alloc_request(3, 8);
 166         if (IS_ERR(request))
 167                 return PTR_ERR(request);
 168         request->op = TO_RBI;
 169         /* setup ccws */
 170         tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1, device->modeset_byte);
 171         tape_ccw_cc(request->cpaddr + 1, READ_BLOCK_ID, 8, request->cpdata);
 172         tape_ccw_end(request->cpaddr + 2, NOP, 0, NULL);
 173         /* execute it */
 174         rc = tape_do_io(device, request);
 175         if (rc == 0)
 176                 /* Get result from read buffer. */
 177                 *id = *(__u64 *) request->cpdata;
 178         tape_free_request(request);
 179         return rc;
 180 }
 181
 182 int
 183 tape_std_terminate_write(struct tape_device *device)
 184 {
 185         int rc;
 186
 187         if(device->required_tapemarks == 0)
 188                 return 0;
 189
 190         DBF_LH(5, "tape%d: terminate write %dxEOF\n", device->first_minor,
 191                 device->required_tapemarks);
 192
 193         rc = tape_mtop(device, MTWEOF, device->required_tapemarks);
 194         if (rc)
 195                 return rc;
 196
 197         device->required_tapemarks = 0;
 198         return tape_mtop(device, MTBSR, 1);
 199 }
 200
 201 /*
 202  * MTLOAD: Loads the tape.
 203  * The default implementation just wait until the tape medium state changes
 204  * to MS_LOADED.
 205  */
 206 int
 207 tape_std_mtload(struct tape_device *device, int count)
 208 {
 209         return wait_event_interruptible(device->state_change_wq,
 210                 (device->medium_state == MS_LOADED));
 211 }
 212
 213 /*
 214  * MTSETBLK: Set block size.
 215  */
 216 int
 217 tape_std_mtsetblk(struct tape_device *device, int count)
 218 {
 219         struct idal_buffer *new;
 220
 221         DBF_LH(6, "tape_std_mtsetblk(%d)\n", count);
 222         if (count <= 0) {
 223                 /*
 224                  * Just set block_size to 0. tapechar_read/tapechar_write
 225                  * will realloc the idal buffer if a bigger one than the
 226                  * current is needed.
 227                  */
 228                 device->char_data.block_size = 0;
 229                 return 0;
 230         }
 231         if (device->char_data.idal_buf != NULL &&
 232             device->char_data.idal_buf->size == count)
 233                 /* We already have a idal buffer of that size. */
 234                 return 0;
 235
 236         if (count > MAX_BLOCKSIZE) {
 237                 DBF_EVENT(3, "Invalid block size (%d > %d) given.\n",
 238                         count, MAX_BLOCKSIZE);
 239                 return -EINVAL;
 240         }
 241
 242         /* Allocate a new idal buffer. */
 243         new = idal_buffer_alloc(count, 0);
 244         if (IS_ERR(new))
 245                 return -ENOMEM;
 246         if (device->char_data.idal_buf != NULL)
 247                 idal_buffer_free(device->char_data.idal_buf);
 248         device->char_data.idal_buf = new;
 249         device->char_data.block_size = count;
 250
 251         DBF_LH(6, "new blocksize is %d\n", device->char_data.block_size);
 252
 253         return 0;
 254 }
 255
 256 /*
 257  * MTRESET: Set block size to 0.
 258  */
 259 int
 260 tape_std_mtreset(struct tape_device *device, int count)
 261 {
 262         DBF_EVENT(6, "TCHAR:devreset:\n");
 263         device->char_data.block_size = 0;
 264         return 0;
 265 }
 266
 267 /*
 268  * MTFSF: Forward space over 'count' file marks. The tape is positioned
 269  * at the EOT (End of Tape) side of the file mark.
 270  */
 271 int
 272 tape_std_mtfsf(struct tape_device *device, int mt_count)
 273 {
 274         struct tape_request *request;
 275         struct ccw1 *ccw;
 276
 277         request = tape_alloc_request(mt_count + 2, 0);
 278         if (IS_ERR(request))
 279                 return PTR_ERR(request);
 280         request->op = TO_FSF;
 281         /* setup ccws */
 282         ccw = tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1,
 283                           device->modeset_byte);
 284         ccw = tape_ccw_repeat(ccw, FORSPACEFILE, mt_count);
 285         ccw = tape_ccw_end(ccw, NOP, 0, NULL);
 286
 287         /* execute it */
 288         return tape_do_io_free(device, request);
 289 }
 290
 291 /*
 292  * MTFSR: Forward space over 'count' tape blocks (blocksize is set
 293  * via MTSETBLK.
 294  */
 295 int
 296 tape_std_mtfsr(struct tape_device *device, int mt_count)
 297 {
 298         struct tape_request *request;
 299         struct ccw1 *ccw;
 300         int rc;
 301
 302         request = tape_alloc_request(mt_count + 2, 0);
 303         if (IS_ERR(request))
 304                 return PTR_ERR(request);
 305         request->op = TO_FSB;
 306         /* setup ccws */
 307         ccw = tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1,
 308                           device->modeset_byte);
 309         ccw = tape_ccw_repeat(ccw, FORSPACEBLOCK, mt_count);
 310         ccw = tape_ccw_end(ccw, NOP, 0, NULL);
 311
 312         /* execute it */
 313         rc = tape_do_io(device, request);
 314         if (rc == 0 && request->rescnt > 0) {
 315                 DBF_LH(3, "FSR over tapemark\n");
 316                 rc = 1;
 317         }
 318         tape_free_request(request);
 319
 320         return rc;
 321 }
 322
 323 /*
 324  * MTBSR: Backward space over 'count' tape blocks.
 325  * (blocksize is set via MTSETBLK.
 326  */
 327 int
 328 tape_std_mtbsr(struct tape_device *device, int mt_count)
 329 {
 330         struct tape_request *request;
 331         struct ccw1 *ccw;
 332         int rc;
 333
 334         request = tape_alloc_request(mt_count + 2, 0);
 335         if (IS_ERR(request))
 336                 return PTR_ERR(request);
 337         request->op = TO_BSB;
 338         /* setup ccws */
 339         ccw = tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1,
 340                           device->modeset_byte);
 341         ccw = tape_ccw_repeat(ccw, BACKSPACEBLOCK, mt_count);
 342         ccw = tape_ccw_end(ccw, NOP, 0, NULL);
 343
 344         /* execute it */
 345         rc = tape_do_io(device, request);
 346         if (rc == 0 && request->rescnt > 0) {
 347                 DBF_LH(3, "BSR over tapemark\n");
 348                 rc = 1;
 349         }
 350         tape_free_request(request);
 351
 352         return rc;
 353 }
 354
 355 /*
 356  * MTWEOF: Write 'count' file marks at the current position.
 357  */
 358 int
 359 tape_std_mtweof(struct tape_device *device, int mt_count)
 360 {
 361         struct tape_request *request;
 362         struct ccw1 *ccw;
 363
 364         request = tape_alloc_request(mt_count + 2, 0);
 365         if (IS_ERR(request))
 366                 return PTR_ERR(request);
 367         request->op = TO_WTM;
 368         /* setup ccws */
 369         ccw = tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1,
 370                           device->modeset_byte);
 371         ccw = tape_ccw_repeat(ccw, WRITETAPEMARK, mt_count);
 372         ccw = tape_ccw_end(ccw, NOP, 0, NULL);
 373
 374         /* execute it */
 375         return tape_do_io_free(device, request);
 376 }
 377
 378 /*
 379  * MTBSFM: Backward space over 'count' file marks.
 380  * The tape is positioned at the BOT (Begin Of Tape) side of the
 381  * last skipped file mark.
 382  */
 383 int
 384 tape_std_mtbsfm(struct tape_device *device, int mt_count)
 385 {
 386         struct tape_request *request;
 387         struct ccw1 *ccw;
 388
 389         request = tape_alloc_request(mt_count + 2, 0);
 390         if (IS_ERR(request))
 391                 return PTR_ERR(request);
 392         request->op = TO_BSF;
 393         /* setup ccws */
 394         ccw = tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1,
 395                           device->modeset_byte);
 396         ccw = tape_ccw_repeat(ccw, BACKSPACEFILE, mt_count);
 397         ccw = tape_ccw_end(ccw, NOP, 0, NULL);
 398
 399         /* execute it */
 400         return tape_do_io_free(device, request);
 401 }
 402
 403 /*
 404  * MTBSF: Backward space over 'count' file marks. The tape is positioned at
 405  * the EOT (End of Tape) side of the last skipped file mark.
 406  */
 407 int
 408 tape_std_mtbsf(struct tape_device *device, int mt_count)
 409 {
 410         struct tape_request *request;
 411         struct ccw1 *ccw;
 412         int rc;
 413
 414         request = tape_alloc_request(mt_count + 2, 0);
 415         if (IS_ERR(request))
 416                 return PTR_ERR(request);
 417         request->op = TO_BSF;
 418         /* setup ccws */
 419         ccw = tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1,
 420                           device->modeset_byte);
 421         ccw = tape_ccw_repeat(ccw, BACKSPACEFILE, mt_count);
 422         ccw = tape_ccw_end(ccw, NOP, 0, NULL);
 423         /* execute it */
 424         rc = tape_do_io_free(device, request);
 425         if (rc == 0) {
 426                 rc = tape_mtop(device, MTFSR, 1);
 427                 if (rc > 0)
 428                         rc = 0;
 429         }
 430         return rc;
 431 }
 432
 433 /*
 434  * MTFSFM: Forward space over 'count' file marks.
 435  * The tape is positioned at the BOT (Begin Of Tape) side
 436  * of the last skipped file mark.
 437  */
 438 int
 439 tape_std_mtfsfm(struct tape_device *device, int mt_count)
 440 {
 441         struct tape_request *request;
 442         struct ccw1 *ccw;
 443         int rc;
 444
 445         request = tape_alloc_request(mt_count + 2, 0);
 446         if (IS_ERR(request))
 447                 return PTR_ERR(request);
 448         request->op = TO_FSF;
 449         /* setup ccws */
 450         ccw = tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1,
 451                           device->modeset_byte);
 452         ccw = tape_ccw_repeat(ccw, FORSPACEFILE, mt_count);
 453         ccw = tape_ccw_end(ccw, NOP, 0, NULL);
 454         /* execute it */
 455         rc = tape_do_io_free(device, request);
 456         if (rc == 0) {
 457                 rc = tape_mtop(device, MTBSR, 1);
 458                 if (rc > 0)
 459                         rc = 0;
 460         }
 461
 462         return rc;
 463 }
 464
 465 /*
 466  * MTREW: Rewind the tape.
 467  */
 468 int
 469 tape_std_mtrew(struct tape_device *device, int mt_count)
 470 {
 471         struct tape_request *request;
 472
 473         request = tape_alloc_request(3, 0);
 474         if (IS_ERR(request))
 475                 return PTR_ERR(request);
 476         request->op = TO_REW;
 477         /* setup ccws */
 478         tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1,
 479                     device->modeset_byte);
 480         tape_ccw_cc(request->cpaddr + 1, REWIND, 0, NULL);
 481         tape_ccw_end(request->cpaddr + 2, NOP, 0, NULL);
 482
 483         /* execute it */
 484         return tape_do_io_free(device, request);
 485 }
 486
 487 /*
 488  * MTOFFL: Rewind the tape and put the drive off-line.
 489  * Implement 'rewind unload'
 490  */
 491 int
 492 tape_std_mtoffl(struct tape_device *device, int mt_count)
 493 {
 494         struct tape_request *request;
 495
 496         request = tape_alloc_request(3, 0);
 497         if (IS_ERR(request))
 498                 return PTR_ERR(request);
 499         request->op = TO_RUN;
 500         /* setup ccws */
 501         tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1, device->modeset_byte);
 502         tape_ccw_cc(request->cpaddr + 1, REWIND_UNLOAD, 0, NULL);
 503         tape_ccw_end(request->cpaddr + 2, NOP, 0, NULL);
 504
 505         /* execute it */
 506         return tape_do_io_free(device, request);
 507 }
 508
 509 /*
 510  * MTNOP: 'No operation'.
 511  */
 512 int
 513 tape_std_mtnop(struct tape_device *device, int mt_count)
 514 {
 515         struct tape_request *request;
 516
 517         request = tape_alloc_request(2, 0);
 518         if (IS_ERR(request))
 519                 return PTR_ERR(request);
 520         request->op = TO_NOP;
 521         /* setup ccws */
 522         tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1, device->modeset_byte);
 523         tape_ccw_end(request->cpaddr + 1, NOP, 0, NULL);
 524         /* execute it */
 525         return tape_do_io_free(device, request);
 526 }
 527
 528 /*
 529  * MTEOM: positions at the end of the portion of the tape already used
 530  * for recordind data. MTEOM positions after the last file mark, ready for
 531  * appending another file.
 532  */
 533 int
 534 tape_std_mteom(struct tape_device *device, int mt_count)
 535 {
 536         int rc;
 537
 538         /*
 539          * Seek from the beginning of tape (rewind).
 540          */
 541         if ((rc = tape_mtop(device, MTREW, 1)) < 0)
 542                 return rc;
 543
 544         /*
 545          * The logical end of volume is given by two sewuential tapemarks.
 546          * Look for this by skipping to the next file (over one tapemark)
 547          * and then test for another one (fsr returns 1 if a tapemark was
 548          * encountered).
 549          */
 550         do {
 551                 if ((rc = tape_mtop(device, MTFSF, 1)) < 0)
 552                         return rc;
 553                 if ((rc = tape_mtop(device, MTFSR, 1)) < 0)
 554                         return rc;
 555         } while (rc == 0);
 556
 557         return tape_mtop(device, MTBSR, 1);
 558 }
 559
 560 /*
 561  * MTRETEN: Retension the tape, i.e. forward space to end of tape and rewind.
 562  */
 563 int
 564 tape_std_mtreten(struct tape_device *device, int mt_count)
 565 {
 566         struct tape_request *request;
 567
 568         request = tape_alloc_request(4, 0);
 569         if (IS_ERR(request))
 570                 return PTR_ERR(request);
 571         request->op = TO_FSF;
 572         /* setup ccws */
 573         tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1, device->modeset_byte);
 574         tape_ccw_cc(request->cpaddr + 1,FORSPACEFILE, 0, NULL);
 575         tape_ccw_cc(request->cpaddr + 2, NOP, 0, NULL);
 576         tape_ccw_end(request->cpaddr + 3, CCW_CMD_TIC, 0, request->cpaddr);
 577         /* execute it, MTRETEN rc gets ignored */
 578         tape_do_io_interruptible(device, request);
 579         tape_free_request(request);
 580         return tape_mtop(device, MTREW, 1);
 581 }
 582
 583 /*
 584  * MTERASE: erases the tape.
 585  */
 586 int
 587 tape_std_mterase(struct tape_device *device, int mt_count)
 588 {
 589         struct tape_request *request;
 590
 591         request = tape_alloc_request(6, 0);
 592         if (IS_ERR(request))
 593                 return PTR_ERR(request);
 594         request->op = TO_DSE;
 595         /* setup ccws */
 596         tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1, device->modeset_byte);
 597         tape_ccw_cc(request->cpaddr + 1, REWIND, 0, NULL);
 598         tape_ccw_cc(request->cpaddr + 2, ERASE_GAP, 0, NULL);
 599         tape_ccw_cc(request->cpaddr + 3, DATA_SEC_ERASE, 0, NULL);
 600         tape_ccw_cc(request->cpaddr + 4, REWIND, 0, NULL);
 601         tape_ccw_end(request->cpaddr + 5, NOP, 0, NULL);
 602
 603         /* execute it */
 604         return tape_do_io_free(device, request);
 605 }
 606
 607 /*
 608  * MTUNLOAD: Rewind the tape and unload it.
 609  */
 610 int
 611 tape_std_mtunload(struct tape_device *device, int mt_count)
 612 {
 613         return tape_mtop(device, MTOFFL, mt_count);
 614 }
 615
 616 /*
 617  * MTCOMPRESSION: used to enable compression.
 618  * Sets the IDRC on/off.
 619  */
 620 int
 621 tape_std_mtcompression(struct tape_device *device, int mt_count)
 622 {
 623         struct tape_request *request;
 624
 625         if (mt_count < 0 || mt_count > 1) {
 626                 DBF_EXCEPTION(6, "xcom parm\n");
 627                 return -EINVAL;
 628         }
 629         request = tape_alloc_request(2, 0);
 630         if (IS_ERR(request))
 631                 return PTR_ERR(request);
 632         request->op = TO_NOP;
 633         /* setup ccws */
 634         if (mt_count == 0)
 635                 *device->modeset_byte &= ~0x08;
 636         else
 637                 *device->modeset_byte |= 0x08;
 638         tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1, device->modeset_byte);
 639         tape_ccw_end(request->cpaddr + 1, NOP, 0, NULL);
 640         /* execute it */
 641         return tape_do_io_free(device, request);
 642 }
 643
 644 /*
 645  * Read Block
 646  */
 647 struct tape_request *
 648 tape_std_read_block(struct tape_device *device, size_t count)
 649 {
 650         struct tape_request *request;
 651
 652         /*
 653          * We have to alloc 4 ccws in order to be able to transform request
 654          * into a read backward request in error case.
 655          */
 656         request = tape_alloc_request(4, 0);
 657         if (IS_ERR(request)) {
 658                 DBF_EXCEPTION(6, "xrbl fail");
 659                 return request;
 660         }
 661         request->op = TO_RFO;
 662         tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1, device->modeset_byte);
 663         tape_ccw_end_idal(request->cpaddr + 1, READ_FORWARD,
 664                           device->char_data.idal_buf);
 665         DBF_EVENT(6, "xrbl ccwg\n");
 666         return request;
 667 }
 668
 669 /*
 670  * Read Block backward transformation function.
 671  */
 672 void
 673 tape_std_read_backward(struct tape_device *device, struct tape_request *request)
 674 {
 675         /*
 676          * We have allocated 4 ccws in tape_std_read, so we can now
 677          * transform the request to a read backward, followed by a
 678          * forward space block.
 679          */
 680         request->op = TO_RBA;
 681         tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1, device->modeset_byte);
 682         tape_ccw_cc_idal(request->cpaddr + 1, READ_BACKWARD,
 683                          device->char_data.idal_buf);
 684         tape_ccw_cc(request->cpaddr + 2, FORSPACEBLOCK, 0, NULL);
 685         tape_ccw_end(request->cpaddr + 3, NOP, 0, NULL);
 686         DBF_EVENT(6, "xrop ccwg");}
 687
 688 /*
 689  * Write Block
 690  */
 691 struct tape_request *
 692 tape_std_write_block(struct tape_device *device, size_t count)
 693 {
 694         struct tape_request *request;
 695
 696         request = tape_alloc_request(2, 0);
 697         if (IS_ERR(request)) {
 698                 DBF_EXCEPTION(6, "xwbl fail\n");
 699                 return request;
 700         }
 701         request->op = TO_WRI;
 702         tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1, device->modeset_byte);
 703         tape_ccw_end_idal(request->cpaddr + 1, WRITE_CMD,
 704                           device->char_data.idal_buf);
 705         DBF_EVENT(6, "xwbl ccwg\n");
 706         return request;
 707 }
 708
 709 /*
 710  * This routine is called by frontend after an ENOSP on write
 711  */
 712 void
 713 tape_std_process_eov(struct tape_device *device)
 714 {
 715         /*
 716          * End of volume: We have to backspace the last written record, then
 717          * we TRY to write a tapemark and then backspace over the written TM
 718          */
 719         if (tape_mtop(device, MTBSR, 1) == 0 &&
 720             tape_mtop(device, MTWEOF, 1) == 0) {
 721                 tape_mtop(device, MTBSR, 1);
 722         }
 723 }
 724
 725 EXPORT_SYMBOL(tape_std_assign);
 726 EXPORT_SYMBOL(tape_std_unassign);
 727 EXPORT_SYMBOL(tape_std_display);
 728 EXPORT_SYMBOL(tape_std_read_block_id);
 729 EXPORT_SYMBOL(tape_std_mtload);
 730 EXPORT_SYMBOL(tape_std_mtsetblk);
 731 EXPORT_SYMBOL(tape_std_mtreset);
 732 EXPORT_SYMBOL(tape_std_mtfsf);
 733 EXPORT_SYMBOL(tape_std_mtfsr);
 734 EXPORT_SYMBOL(tape_std_mtbsr);
 735 EXPORT_SYMBOL(tape_std_mtweof);
 736 EXPORT_SYMBOL(tape_std_mtbsfm);
 737 EXPORT_SYMBOL(tape_std_mtbsf);
 738 EXPORT_SYMBOL(tape_std_mtfsfm);
 739 EXPORT_SYMBOL(tape_std_mtrew);
 740 EXPORT_SYMBOL(tape_std_mtoffl);
 741 EXPORT_SYMBOL(tape_std_mtnop);
 742 EXPORT_SYMBOL(tape_std_mteom);
 743 EXPORT_SYMBOL(tape_std_mtreten);
 744 EXPORT_SYMBOL(tape_std_mterase);
 745 EXPORT_SYMBOL(tape_std_mtunload);
 746 EXPORT_SYMBOL(tape_std_mtcompression);
 747 EXPORT_SYMBOL(tape_std_read_block);
 748 EXPORT_SYMBOL(tape_std_read_backward);
 749 EXPORT_SYMBOL(tape_std_write_block);
 750 EXPORT_SYMBOL(tape_std_process_eov);