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