blob: 3babdc76b3fb37f3e361243f8d5b7167a0d85f8b [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 SCSI Tape Driver for Linux version 1.1 and newer. See the accompanying
3 file Documentation/scsi/st.txt for more information.
4
5 History:
6 Rewritten from Dwayne Forsyth's SCSI tape driver by Kai Makisara.
7 Contribution and ideas from several people including (in alphabetical
8 order) Klaus Ehrenfried, Eugene Exarevsky, Eric Lee Green, Wolfgang Denk,
9 Steve Hirsch, Andreas Koppenh"ofer, Michael Leodolter, Eyal Lebedinsky,
10 Michael Schaefer, J"org Weule, and Eric Youngdale.
11
12 Copyright 1992 - 2005 Kai Makisara
13 email Kai.Makisara@kolumbus.fi
14
15 Some small formal changes - aeb, 950809
16
17 Last modified: 18-JAN-1998 Richard Gooch <rgooch@atnf.csiro.au> Devfs support
18 */
19
Arjan van de Ven0ad78202005-11-28 16:22:25 +010020static const char *verstr = "20050830";
Linus Torvalds1da177e2005-04-16 15:20:36 -070021
22#include <linux/module.h>
23
24#include <linux/fs.h>
25#include <linux/kernel.h>
26#include <linux/sched.h>
27#include <linux/mm.h>
28#include <linux/init.h>
29#include <linux/string.h>
30#include <linux/errno.h>
31#include <linux/mtio.h>
Kai Makisara 16c4b3e2005-05-01 18:11:55 +030032#include <linux/cdrom.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#include <linux/ioctl.h>
34#include <linux/fcntl.h>
35#include <linux/spinlock.h>
36#include <linux/blkdev.h>
37#include <linux/moduleparam.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070038#include <linux/cdev.h>
39#include <linux/delay.h>
Arjan van de Ven0b950672006-01-11 13:16:10 +010040#include <linux/mutex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070041
42#include <asm/uaccess.h>
43#include <asm/dma.h>
44#include <asm/system.h>
45
46#include <scsi/scsi.h>
47#include <scsi/scsi_dbg.h>
48#include <scsi/scsi_device.h>
49#include <scsi/scsi_driver.h>
50#include <scsi/scsi_eh.h>
51#include <scsi/scsi_host.h>
52#include <scsi/scsi_ioctl.h>
Kai Makisara 16c4b3e2005-05-01 18:11:55 +030053#include <scsi/sg.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070054
55
56/* The driver prints some debugging information on the console if DEBUG
57 is defined and non-zero. */
58#define DEBUG 0
59
60#if DEBUG
61/* The message level for the debug messages is currently set to KERN_NOTICE
62 so that people can easily see the messages. Later when the debugging messages
63 in the drivers are more widely classified, this may be changed to KERN_DEBUG. */
64#define ST_DEB_MSG KERN_NOTICE
65#define DEB(a) a
66#define DEBC(a) if (debugging) { a ; }
67#else
68#define DEB(a)
69#define DEBC(a)
70#endif
71
72#define ST_KILOBYTE 1024
73
74#include "st_options.h"
75#include "st.h"
76
77static int buffer_kbs;
78static int max_sg_segs;
79static int try_direct_io = TRY_DIRECT_IO;
80static int try_rdio = 1;
81static int try_wdio = 1;
82
83static int st_dev_max;
84static int st_nr_dev;
85
gregkh@suse.ded2538782005-03-23 09:55:22 -080086static struct class *st_sysfs_class;
Linus Torvalds1da177e2005-04-16 15:20:36 -070087
88MODULE_AUTHOR("Kai Makisara");
Rene Hermanf018fa52006-03-08 00:14:20 -080089MODULE_DESCRIPTION("SCSI tape (st) driver");
Linus Torvalds1da177e2005-04-16 15:20:36 -070090MODULE_LICENSE("GPL");
Rene Hermanf018fa52006-03-08 00:14:20 -080091MODULE_ALIAS_CHARDEV_MAJOR(SCSI_TAPE_MAJOR);
Linus Torvalds1da177e2005-04-16 15:20:36 -070092
93/* Set 'perm' (4th argument) to 0 to disable module_param's definition
94 * of sysfs parameters (which module_param doesn't yet support).
95 * Sysfs parameters defined explicitly later.
96 */
97module_param_named(buffer_kbs, buffer_kbs, int, 0);
98MODULE_PARM_DESC(buffer_kbs, "Default driver buffer size for fixed block mode (KB; 32)");
99module_param_named(max_sg_segs, max_sg_segs, int, 0);
100MODULE_PARM_DESC(max_sg_segs, "Maximum number of scatter/gather segments to use (256)");
101module_param_named(try_direct_io, try_direct_io, int, 0);
102MODULE_PARM_DESC(try_direct_io, "Try direct I/O between user buffer and tape drive (1)");
103
104/* Extra parameters for testing */
105module_param_named(try_rdio, try_rdio, int, 0);
106MODULE_PARM_DESC(try_rdio, "Try direct read i/o when possible");
107module_param_named(try_wdio, try_wdio, int, 0);
108MODULE_PARM_DESC(try_wdio, "Try direct write i/o when possible");
109
110#ifndef MODULE
111static int write_threshold_kbs; /* retained for compatibility */
112static struct st_dev_parm {
113 char *name;
114 int *val;
115} parms[] __initdata = {
116 {
117 "buffer_kbs", &buffer_kbs
118 },
119 { /* Retained for compatibility with 2.4 */
120 "write_threshold_kbs", &write_threshold_kbs
121 },
122 {
123 "max_sg_segs", NULL
124 },
125 {
126 "try_direct_io", &try_direct_io
127 }
128};
129#endif
130
131/* Restrict the number of modes so that names for all are assigned */
132#if ST_NBR_MODES > 16
133#error "Maximum number of modes is 16"
134#endif
135/* Bit reversed order to get same names for same minors with all
136 mode counts */
Arjan van de Ven0ad78202005-11-28 16:22:25 +0100137static const char *st_formats[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138 "", "r", "k", "s", "l", "t", "o", "u",
139 "m", "v", "p", "x", "a", "y", "q", "z"};
140
141/* The default definitions have been moved to st_options.h */
142
143#define ST_FIXED_BUFFER_SIZE (ST_FIXED_BUFFER_BLOCKS * ST_KILOBYTE)
144
145/* The buffer size should fit into the 24 bits for length in the
146 6-byte SCSI read and write commands. */
147#if ST_FIXED_BUFFER_SIZE >= (2 << 24 - 1)
148#error "Buffer size should not exceed (2 << 24 - 1) bytes!"
149#endif
150
151static int debugging = DEBUG;
152
153#define MAX_RETRIES 0
154#define MAX_WRITE_RETRIES 0
155#define MAX_READY_RETRIES 0
156#define NO_TAPE NOT_READY
157
158#define ST_TIMEOUT (900 * HZ)
159#define ST_LONG_TIMEOUT (14000 * HZ)
160
161/* Remove mode bits and auto-rewind bit (7) */
162#define TAPE_NR(x) ( ((iminor(x) & ~255) >> (ST_NBR_MODE_BITS + 1)) | \
163 (iminor(x) & ~(-1 << ST_MODE_SHIFT)) )
164#define TAPE_MODE(x) ((iminor(x) & ST_MODE_MASK) >> ST_MODE_SHIFT)
165
166/* Construct the minor number from the device (d), mode (m), and non-rewind (n) data */
167#define TAPE_MINOR(d, m, n) (((d & ~(255 >> (ST_NBR_MODE_BITS + 1))) << (ST_NBR_MODE_BITS + 1)) | \
168 (d & (255 >> (ST_NBR_MODE_BITS + 1))) | (m << ST_MODE_SHIFT) | ((n != 0) << 7) )
169
170/* Internal ioctl to set both density (uppermost 8 bits) and blocksize (lower
171 24 bits) */
172#define SET_DENS_AND_BLK 0x10001
173
174static DEFINE_RWLOCK(st_dev_arr_lock);
175
176static int st_fixed_buffer_size = ST_FIXED_BUFFER_SIZE;
177static int st_max_sg_segs = ST_MAX_SG;
178
179static struct scsi_tape **scsi_tapes = NULL;
180
181static int modes_defined;
182
183static struct st_buffer *new_tape_buffer(int, int, int);
184static int enlarge_buffer(struct st_buffer *, int, int);
185static void normalize_buffer(struct st_buffer *);
186static int append_to_buffer(const char __user *, struct st_buffer *, int);
187static int from_buffer(struct st_buffer *, char __user *, int);
188static void move_buffer_data(struct st_buffer *, int);
189static void buf_to_sg(struct st_buffer *, unsigned int);
190
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191static int sgl_map_user_pages(struct scatterlist *, const unsigned int,
192 unsigned long, size_t, int);
193static int sgl_unmap_user_pages(struct scatterlist *, const unsigned int, int);
194
195static int st_probe(struct device *);
196static int st_remove(struct device *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197
Jeff Garzik13026a62006-10-04 06:00:38 -0400198static int do_create_driverfs_files(void);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199static void do_remove_driverfs_files(void);
Jeff Garzik13026a62006-10-04 06:00:38 -0400200static int do_create_class_files(struct scsi_tape *, int, int);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201
202static struct scsi_driver st_template = {
203 .owner = THIS_MODULE,
204 .gendrv = {
205 .name = "st",
206 .probe = st_probe,
207 .remove = st_remove,
208 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209};
210
211static int st_compression(struct scsi_tape *, int);
212
213static int find_partition(struct scsi_tape *);
214static int switch_partition(struct scsi_tape *);
215
216static int st_int_ioctl(struct scsi_tape *, unsigned int, unsigned long);
217
Kai Makisaraf03a5672005-08-02 13:40:47 +0300218static void scsi_tape_release(struct kref *);
219
220#define to_scsi_tape(obj) container_of(obj, struct scsi_tape, kref)
221
Arjan van de Ven0b950672006-01-11 13:16:10 +0100222static DEFINE_MUTEX(st_ref_mutex);
Kai Makisaraf03a5672005-08-02 13:40:47 +0300223
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224
225#include "osst_detect.h"
226#ifndef SIGS_FROM_OSST
227#define SIGS_FROM_OSST \
228 {"OnStream", "SC-", "", "osst"}, \
229 {"OnStream", "DI-", "", "osst"}, \
230 {"OnStream", "DP-", "", "osst"}, \
231 {"OnStream", "USB", "", "osst"}, \
232 {"OnStream", "FW-", "", "osst"}
233#endif
234
Kai Makisaraf03a5672005-08-02 13:40:47 +0300235static struct scsi_tape *scsi_tape_get(int dev)
236{
237 struct scsi_tape *STp = NULL;
238
Arjan van de Ven0b950672006-01-11 13:16:10 +0100239 mutex_lock(&st_ref_mutex);
Kai Makisaraf03a5672005-08-02 13:40:47 +0300240 write_lock(&st_dev_arr_lock);
241
242 if (dev < st_dev_max && scsi_tapes != NULL)
243 STp = scsi_tapes[dev];
244 if (!STp) goto out;
245
246 kref_get(&STp->kref);
247
248 if (!STp->device)
249 goto out_put;
250
251 if (scsi_device_get(STp->device))
252 goto out_put;
253
254 goto out;
255
256out_put:
257 kref_put(&STp->kref, scsi_tape_release);
258 STp = NULL;
259out:
260 write_unlock(&st_dev_arr_lock);
Arjan van de Ven0b950672006-01-11 13:16:10 +0100261 mutex_unlock(&st_ref_mutex);
Kai Makisaraf03a5672005-08-02 13:40:47 +0300262 return STp;
263}
264
265static void scsi_tape_put(struct scsi_tape *STp)
266{
267 struct scsi_device *sdev = STp->device;
268
Arjan van de Ven0b950672006-01-11 13:16:10 +0100269 mutex_lock(&st_ref_mutex);
Kai Makisaraf03a5672005-08-02 13:40:47 +0300270 kref_put(&STp->kref, scsi_tape_release);
271 scsi_device_put(sdev);
Arjan van de Ven0b950672006-01-11 13:16:10 +0100272 mutex_unlock(&st_ref_mutex);
Kai Makisaraf03a5672005-08-02 13:40:47 +0300273}
274
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275struct st_reject_data {
276 char *vendor;
277 char *model;
278 char *rev;
279 char *driver_hint; /* Name of the correct driver, NULL if unknown */
280};
281
282static struct st_reject_data reject_list[] = {
283 /* {"XXX", "Yy-", "", NULL}, example */
284 SIGS_FROM_OSST,
285 {NULL, }};
286
287/* If the device signature is on the list of incompatible drives, the
288 function returns a pointer to the name of the correct driver (if known) */
289static char * st_incompatible(struct scsi_device* SDp)
290{
291 struct st_reject_data *rp;
292
293 for (rp=&(reject_list[0]); rp->vendor != NULL; rp++)
294 if (!strncmp(rp->vendor, SDp->vendor, strlen(rp->vendor)) &&
295 !strncmp(rp->model, SDp->model, strlen(rp->model)) &&
296 !strncmp(rp->rev, SDp->rev, strlen(rp->rev))) {
297 if (rp->driver_hint)
298 return rp->driver_hint;
299 else
300 return "unknown";
301 }
302 return NULL;
303}
304
305
306static inline char *tape_name(struct scsi_tape *tape)
307{
308 return tape->disk->disk_name;
309}
310
311
Mike Christie8b05b772005-11-08 04:06:44 -0600312static void st_analyze_sense(struct st_request *SRpnt, struct st_cmdstatus *s)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313{
314 const u8 *ucp;
Mike Christie8b05b772005-11-08 04:06:44 -0600315 const u8 *sense = SRpnt->sense;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316
Mike Christie8b05b772005-11-08 04:06:44 -0600317 s->have_sense = scsi_normalize_sense(SRpnt->sense,
318 SCSI_SENSE_BUFFERSIZE, &s->sense_hdr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319 s->flags = 0;
320
321 if (s->have_sense) {
322 s->deferred = 0;
323 s->remainder_valid =
324 scsi_get_sense_info_fld(sense, SCSI_SENSE_BUFFERSIZE, &s->uremainder64);
325 switch (sense[0] & 0x7f) {
326 case 0x71:
327 s->deferred = 1;
328 case 0x70:
329 s->fixed_format = 1;
330 s->flags = sense[2] & 0xe0;
331 break;
332 case 0x73:
333 s->deferred = 1;
334 case 0x72:
335 s->fixed_format = 0;
336 ucp = scsi_sense_desc_find(sense, SCSI_SENSE_BUFFERSIZE, 4);
337 s->flags = ucp ? (ucp[3] & 0xe0) : 0;
338 break;
339 }
340 }
341}
342
343
344/* Convert the result to success code */
Mike Christie8b05b772005-11-08 04:06:44 -0600345static int st_chk_result(struct scsi_tape *STp, struct st_request * SRpnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346{
Mike Christie8b05b772005-11-08 04:06:44 -0600347 int result = SRpnt->result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348 u8 scode;
349 DEB(const char *stp;)
350 char *name = tape_name(STp);
351 struct st_cmdstatus *cmdstatp;
352
353 if (!result)
354 return 0;
355
356 cmdstatp = &STp->buffer->cmdstat;
Kai Makisaraf03a5672005-08-02 13:40:47 +0300357 st_analyze_sense(SRpnt, cmdstatp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358
359 if (cmdstatp->have_sense)
360 scode = STp->buffer->cmdstat.sense_hdr.sense_key;
361 else
362 scode = 0;
363
364 DEB(
365 if (debugging) {
Mike Christie8b05b772005-11-08 04:06:44 -0600366 printk(ST_DEB_MSG "%s: Error: %x, cmd: %x %x %x %x %x %x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367 name, result,
Mike Christie8b05b772005-11-08 04:06:44 -0600368 SRpnt->cmd[0], SRpnt->cmd[1], SRpnt->cmd[2],
369 SRpnt->cmd[3], SRpnt->cmd[4], SRpnt->cmd[5]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 if (cmdstatp->have_sense)
Luben Tuikov4e73ea72006-07-07 00:02:18 -0700371 __scsi_print_sense(name, SRpnt->sense, SCSI_SENSE_BUFFERSIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 } ) /* end DEB */
373 if (!debugging) { /* Abnormal conditions for tape */
374 if (!cmdstatp->have_sense)
375 printk(KERN_WARNING
376 "%s: Error %x (sugg. bt 0x%x, driver bt 0x%x, host bt 0x%x).\n",
377 name, result, suggestion(result),
378 driver_byte(result) & DRIVER_MASK, host_byte(result));
379 else if (cmdstatp->have_sense &&
380 scode != NO_SENSE &&
381 scode != RECOVERED_ERROR &&
382 /* scode != UNIT_ATTENTION && */
383 scode != BLANK_CHECK &&
384 scode != VOLUME_OVERFLOW &&
Mike Christie8b05b772005-11-08 04:06:44 -0600385 SRpnt->cmd[0] != MODE_SENSE &&
386 SRpnt->cmd[0] != TEST_UNIT_READY) {
Luben Tuikov4e73ea72006-07-07 00:02:18 -0700387
388 __scsi_print_sense(name, SRpnt->sense, SCSI_SENSE_BUFFERSIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389 }
390 }
391
392 if (cmdstatp->fixed_format &&
393 STp->cln_mode >= EXTENDED_SENSE_START) { /* Only fixed format sense */
394 if (STp->cln_sense_value)
Mike Christie8b05b772005-11-08 04:06:44 -0600395 STp->cleaning_req |= ((SRpnt->sense[STp->cln_mode] &
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 STp->cln_sense_mask) == STp->cln_sense_value);
397 else
Mike Christie8b05b772005-11-08 04:06:44 -0600398 STp->cleaning_req |= ((SRpnt->sense[STp->cln_mode] &
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 STp->cln_sense_mask) != 0);
400 }
401 if (cmdstatp->have_sense &&
402 cmdstatp->sense_hdr.asc == 0 && cmdstatp->sense_hdr.ascq == 0x17)
403 STp->cleaning_req = 1; /* ASC and ASCQ => cleaning requested */
404
405 STp->pos_unknown |= STp->device->was_reset;
406
407 if (cmdstatp->have_sense &&
408 scode == RECOVERED_ERROR
409#if ST_RECOVERED_WRITE_FATAL
Mike Christie8b05b772005-11-08 04:06:44 -0600410 && SRpnt->cmd[0] != WRITE_6
411 && SRpnt->cmd[0] != WRITE_FILEMARKS
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412#endif
413 ) {
414 STp->recover_count++;
415 STp->recover_reg++;
416
417 DEB(
418 if (debugging) {
Mike Christie8b05b772005-11-08 04:06:44 -0600419 if (SRpnt->cmd[0] == READ_6)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 stp = "read";
Mike Christie8b05b772005-11-08 04:06:44 -0600421 else if (SRpnt->cmd[0] == WRITE_6)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 stp = "write";
423 else
424 stp = "ioctl";
425 printk(ST_DEB_MSG "%s: Recovered %s error (%d).\n", name, stp,
426 STp->recover_count);
427 } ) /* end DEB */
428
429 if (cmdstatp->flags == 0)
430 return 0;
431 }
432 return (-EIO);
433}
434
435
436/* Wakeup from interrupt */
Mike Christie8b05b772005-11-08 04:06:44 -0600437static void st_sleep_done(void *data, char *sense, int result, int resid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438{
Mike Christie8b05b772005-11-08 04:06:44 -0600439 struct st_request *SRpnt = data;
440 struct scsi_tape *STp = SRpnt->stp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441
Mike Christie8b05b772005-11-08 04:06:44 -0600442 memcpy(SRpnt->sense, sense, SCSI_SENSE_BUFFERSIZE);
443 (STp->buffer)->cmdstat.midlevel_result = SRpnt->result = result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 DEB( STp->write_pending = 0; )
445
Mike Christie8b05b772005-11-08 04:06:44 -0600446 if (SRpnt->waiting)
447 complete(SRpnt->waiting);
448}
449
450static struct st_request *st_allocate_request(void)
451{
452 return kzalloc(sizeof(struct st_request), GFP_KERNEL);
453}
454
455static void st_release_request(struct st_request *streq)
456{
457 kfree(streq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458}
459
460/* Do the scsi command. Waits until command performed if do_wait is true.
461 Otherwise write_behind_check() is used to check that the command
462 has finished. */
Mike Christie8b05b772005-11-08 04:06:44 -0600463static struct st_request *
464st_do_scsi(struct st_request * SRpnt, struct scsi_tape * STp, unsigned char *cmd,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 int bytes, int direction, int timeout, int retries, int do_wait)
466{
Kai Makisaraf03a5672005-08-02 13:40:47 +0300467 struct completion *waiting;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468
Kai Makisaraf03a5672005-08-02 13:40:47 +0300469 /* if async, make sure there's no command outstanding */
470 if (!do_wait && ((STp->buffer)->last_SRpnt)) {
471 printk(KERN_ERR "%s: Async command already active.\n",
472 tape_name(STp));
473 if (signal_pending(current))
474 (STp->buffer)->syscall_result = (-EINTR);
475 else
476 (STp->buffer)->syscall_result = (-EBUSY);
477 return NULL;
478 }
479
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 if (SRpnt == NULL) {
Mike Christie8b05b772005-11-08 04:06:44 -0600481 SRpnt = st_allocate_request();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482 if (SRpnt == NULL) {
483 DEBC( printk(KERN_ERR "%s: Can't get SCSI request.\n",
484 tape_name(STp)); );
485 if (signal_pending(current))
486 (STp->buffer)->syscall_result = (-EINTR);
487 else
488 (STp->buffer)->syscall_result = (-EBUSY);
489 return NULL;
490 }
Mike Christie8b05b772005-11-08 04:06:44 -0600491 SRpnt->stp = STp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 }
493
Kai Makisaraf03a5672005-08-02 13:40:47 +0300494 /* If async IO, set last_SRpnt. This ptr tells write_behind_check
495 which IO is outstanding. It's nulled out when the IO completes. */
496 if (!do_wait)
497 (STp->buffer)->last_SRpnt = SRpnt;
498
499 waiting = &STp->wait;
500 init_completion(waiting);
Mike Christie8b05b772005-11-08 04:06:44 -0600501 SRpnt->waiting = waiting;
502
503 if (!STp->buffer->do_dio)
504 buf_to_sg(STp->buffer, bytes);
505
506 memcpy(SRpnt->cmd, cmd, sizeof(SRpnt->cmd));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 STp->buffer->cmdstat.have_sense = 0;
Mike Christie8b05b772005-11-08 04:06:44 -0600508 STp->buffer->syscall_result = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509
brking@us.ibm.combb1d1072006-01-23 15:03:22 -0600510 if (scsi_execute_async(STp->device, cmd, COMMAND_SIZE(cmd[0]), direction,
Mike Christie8b05b772005-11-08 04:06:44 -0600511 &((STp->buffer)->sg[0]), bytes, (STp->buffer)->sg_segs,
Kai Makisara787926b2005-11-13 10:04:44 +0200512 timeout, retries, SRpnt, st_sleep_done, GFP_KERNEL)) {
Mike Christie8b05b772005-11-08 04:06:44 -0600513 /* could not allocate the buffer or request was too large */
514 (STp->buffer)->syscall_result = (-EBUSY);
Kai Makisara787926b2005-11-13 10:04:44 +0200515 (STp->buffer)->last_SRpnt = NULL;
516 }
Mike Christie8b05b772005-11-08 04:06:44 -0600517 else if (do_wait) {
Kai Makisaraf03a5672005-08-02 13:40:47 +0300518 wait_for_completion(waiting);
Mike Christie8b05b772005-11-08 04:06:44 -0600519 SRpnt->waiting = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520 (STp->buffer)->syscall_result = st_chk_result(STp, SRpnt);
521 }
Mike Christie8b05b772005-11-08 04:06:44 -0600522
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 return SRpnt;
524}
525
526
527/* Handle the write-behind checking (waits for completion). Returns -ENOSPC if
528 write has been correct but EOM early warning reached, -EIO if write ended in
529 error or zero if write successful. Asynchronous writes are used only in
530 variable block mode. */
531static int write_behind_check(struct scsi_tape * STp)
532{
533 int retval = 0;
534 struct st_buffer *STbuffer;
535 struct st_partstat *STps;
536 struct st_cmdstatus *cmdstatp;
Mike Christie8b05b772005-11-08 04:06:44 -0600537 struct st_request *SRpnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538
539 STbuffer = STp->buffer;
540 if (!STbuffer->writing)
541 return 0;
542
543 DEB(
544 if (STp->write_pending)
545 STp->nbr_waits++;
546 else
547 STp->nbr_finished++;
548 ) /* end DEB */
549
550 wait_for_completion(&(STp->wait));
Kai Makisaraf03a5672005-08-02 13:40:47 +0300551 SRpnt = STbuffer->last_SRpnt;
552 STbuffer->last_SRpnt = NULL;
Mike Christie8b05b772005-11-08 04:06:44 -0600553 SRpnt->waiting = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554
Kai Makisaraf03a5672005-08-02 13:40:47 +0300555 (STp->buffer)->syscall_result = st_chk_result(STp, SRpnt);
Mike Christie8b05b772005-11-08 04:06:44 -0600556 st_release_request(SRpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557
558 STbuffer->buffer_bytes -= STbuffer->writing;
559 STps = &(STp->ps[STp->partition]);
560 if (STps->drv_block >= 0) {
561 if (STp->block_size == 0)
562 STps->drv_block++;
563 else
564 STps->drv_block += STbuffer->writing / STp->block_size;
565 }
566
567 cmdstatp = &STbuffer->cmdstat;
568 if (STbuffer->syscall_result) {
569 retval = -EIO;
570 if (cmdstatp->have_sense && !cmdstatp->deferred &&
571 (cmdstatp->flags & SENSE_EOM) &&
572 (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
573 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR)) {
574 /* EOM at write-behind, has all data been written? */
575 if (!cmdstatp->remainder_valid ||
576 cmdstatp->uremainder64 == 0)
577 retval = -ENOSPC;
578 }
579 if (retval == -EIO)
580 STps->drv_block = -1;
581 }
582 STbuffer->writing = 0;
583
584 DEB(if (debugging && retval)
585 printk(ST_DEB_MSG "%s: Async write error %x, return value %d.\n",
586 tape_name(STp), STbuffer->cmdstat.midlevel_result, retval);) /* end DEB */
587
588 return retval;
589}
590
591
592/* Step over EOF if it has been inadvertently crossed (ioctl not used because
593 it messes up the block number). */
594static int cross_eof(struct scsi_tape * STp, int forward)
595{
Mike Christie8b05b772005-11-08 04:06:44 -0600596 struct st_request *SRpnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 unsigned char cmd[MAX_COMMAND_SIZE];
598
599 cmd[0] = SPACE;
600 cmd[1] = 0x01; /* Space FileMarks */
601 if (forward) {
602 cmd[2] = cmd[3] = 0;
603 cmd[4] = 1;
604 } else
605 cmd[2] = cmd[3] = cmd[4] = 0xff; /* -1 filemarks */
606 cmd[5] = 0;
607
608 DEBC(printk(ST_DEB_MSG "%s: Stepping over filemark %s.\n",
609 tape_name(STp), forward ? "forward" : "backward"));
610
611 SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
612 STp->device->timeout, MAX_RETRIES, 1);
613 if (!SRpnt)
614 return (STp->buffer)->syscall_result;
615
Mike Christie8b05b772005-11-08 04:06:44 -0600616 st_release_request(SRpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617 SRpnt = NULL;
618
619 if ((STp->buffer)->cmdstat.midlevel_result != 0)
620 printk(KERN_ERR "%s: Stepping over filemark %s failed.\n",
621 tape_name(STp), forward ? "forward" : "backward");
622
623 return (STp->buffer)->syscall_result;
624}
625
626
627/* Flush the write buffer (never need to write if variable blocksize). */
628static int flush_write_buffer(struct scsi_tape * STp)
629{
630 int offset, transfer, blks;
631 int result;
632 unsigned char cmd[MAX_COMMAND_SIZE];
Mike Christie8b05b772005-11-08 04:06:44 -0600633 struct st_request *SRpnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634 struct st_partstat *STps;
635
636 result = write_behind_check(STp);
637 if (result)
638 return result;
639
640 result = 0;
641 if (STp->dirty == 1) {
642
643 offset = (STp->buffer)->buffer_bytes;
644 transfer = ((offset + STp->block_size - 1) /
645 STp->block_size) * STp->block_size;
646 DEBC(printk(ST_DEB_MSG "%s: Flushing %d bytes.\n",
647 tape_name(STp), transfer));
648
649 memset((STp->buffer)->b_data + offset, 0, transfer - offset);
650
651 memset(cmd, 0, MAX_COMMAND_SIZE);
652 cmd[0] = WRITE_6;
653 cmd[1] = 1;
654 blks = transfer / STp->block_size;
655 cmd[2] = blks >> 16;
656 cmd[3] = blks >> 8;
657 cmd[4] = blks;
658
659 SRpnt = st_do_scsi(NULL, STp, cmd, transfer, DMA_TO_DEVICE,
660 STp->device->timeout, MAX_WRITE_RETRIES, 1);
661 if (!SRpnt)
662 return (STp->buffer)->syscall_result;
663
664 STps = &(STp->ps[STp->partition]);
665 if ((STp->buffer)->syscall_result != 0) {
666 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
667
668 if (cmdstatp->have_sense && !cmdstatp->deferred &&
669 (cmdstatp->flags & SENSE_EOM) &&
670 (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
671 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) &&
672 (!cmdstatp->remainder_valid ||
673 cmdstatp->uremainder64 == 0)) { /* All written at EOM early warning */
674 STp->dirty = 0;
675 (STp->buffer)->buffer_bytes = 0;
676 if (STps->drv_block >= 0)
677 STps->drv_block += blks;
678 result = (-ENOSPC);
679 } else {
680 printk(KERN_ERR "%s: Error on flush.\n",
681 tape_name(STp));
682 STps->drv_block = (-1);
683 result = (-EIO);
684 }
685 } else {
686 if (STps->drv_block >= 0)
687 STps->drv_block += blks;
688 STp->dirty = 0;
689 (STp->buffer)->buffer_bytes = 0;
690 }
Mike Christie8b05b772005-11-08 04:06:44 -0600691 st_release_request(SRpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692 SRpnt = NULL;
693 }
694 return result;
695}
696
697
698/* Flush the tape buffer. The tape will be positioned correctly unless
699 seek_next is true. */
700static int flush_buffer(struct scsi_tape *STp, int seek_next)
701{
702 int backspace, result;
703 struct st_buffer *STbuffer;
704 struct st_partstat *STps;
705
706 STbuffer = STp->buffer;
707
708 /*
709 * If there was a bus reset, block further access
710 * to this device.
711 */
712 if (STp->pos_unknown)
713 return (-EIO);
714
715 if (STp->ready != ST_READY)
716 return 0;
717 STps = &(STp->ps[STp->partition]);
718 if (STps->rw == ST_WRITING) /* Writing */
719 return flush_write_buffer(STp);
720
721 if (STp->block_size == 0)
722 return 0;
723
724 backspace = ((STp->buffer)->buffer_bytes +
725 (STp->buffer)->read_pointer) / STp->block_size -
726 ((STp->buffer)->read_pointer + STp->block_size - 1) /
727 STp->block_size;
728 (STp->buffer)->buffer_bytes = 0;
729 (STp->buffer)->read_pointer = 0;
730 result = 0;
731 if (!seek_next) {
732 if (STps->eof == ST_FM_HIT) {
733 result = cross_eof(STp, 0); /* Back over the EOF hit */
734 if (!result)
735 STps->eof = ST_NOEOF;
736 else {
737 if (STps->drv_file >= 0)
738 STps->drv_file++;
739 STps->drv_block = 0;
740 }
741 }
742 if (!result && backspace > 0)
743 result = st_int_ioctl(STp, MTBSR, backspace);
744 } else if (STps->eof == ST_FM_HIT) {
745 if (STps->drv_file >= 0)
746 STps->drv_file++;
747 STps->drv_block = 0;
748 STps->eof = ST_NOEOF;
749 }
750 return result;
751
752}
753
754/* Set the mode parameters */
755static int set_mode_densblk(struct scsi_tape * STp, struct st_modedef * STm)
756{
757 int set_it = 0;
758 unsigned long arg;
759 char *name = tape_name(STp);
760
761 if (!STp->density_changed &&
762 STm->default_density >= 0 &&
763 STm->default_density != STp->density) {
764 arg = STm->default_density;
765 set_it = 1;
766 } else
767 arg = STp->density;
768 arg <<= MT_ST_DENSITY_SHIFT;
769 if (!STp->blksize_changed &&
770 STm->default_blksize >= 0 &&
771 STm->default_blksize != STp->block_size) {
772 arg |= STm->default_blksize;
773 set_it = 1;
774 } else
775 arg |= STp->block_size;
776 if (set_it &&
777 st_int_ioctl(STp, SET_DENS_AND_BLK, arg)) {
778 printk(KERN_WARNING
779 "%s: Can't set default block size to %d bytes and density %x.\n",
780 name, STm->default_blksize, STm->default_density);
781 if (modes_defined)
782 return (-EINVAL);
783 }
784 return 0;
785}
786
787
Mike Christie8b05b772005-11-08 04:06:44 -0600788/* Lock or unlock the drive door. Don't use when st_request allocated. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789static int do_door_lock(struct scsi_tape * STp, int do_lock)
790{
791 int retval, cmd;
792 DEB(char *name = tape_name(STp);)
793
794
795 cmd = do_lock ? SCSI_IOCTL_DOORLOCK : SCSI_IOCTL_DOORUNLOCK;
796 DEBC(printk(ST_DEB_MSG "%s: %socking drive door.\n", name,
797 do_lock ? "L" : "Unl"));
798 retval = scsi_ioctl(STp->device, cmd, NULL);
799 if (!retval) {
800 STp->door_locked = do_lock ? ST_LOCKED_EXPLICIT : ST_UNLOCKED;
801 }
802 else {
803 STp->door_locked = ST_LOCK_FAILS;
804 }
805 return retval;
806}
807
808
809/* Set the internal state after reset */
810static void reset_state(struct scsi_tape *STp)
811{
812 int i;
813 struct st_partstat *STps;
814
815 STp->pos_unknown = 0;
816 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
817 STps = &(STp->ps[i]);
818 STps->rw = ST_IDLE;
819 STps->eof = ST_NOEOF;
820 STps->at_sm = 0;
821 STps->last_block_valid = 0;
822 STps->drv_block = -1;
823 STps->drv_file = -1;
824 }
825 if (STp->can_partitions) {
826 STp->partition = find_partition(STp);
827 if (STp->partition < 0)
828 STp->partition = 0;
829 STp->new_partition = STp->partition;
830 }
831}
832
833/* Test if the drive is ready. Returns either one of the codes below or a negative system
834 error code. */
835#define CHKRES_READY 0
836#define CHKRES_NEW_SESSION 1
837#define CHKRES_NOT_READY 2
838#define CHKRES_NO_TAPE 3
839
840#define MAX_ATTENTIONS 10
841
842static int test_ready(struct scsi_tape *STp, int do_wait)
843{
844 int attentions, waits, max_wait, scode;
845 int retval = CHKRES_READY, new_session = 0;
846 unsigned char cmd[MAX_COMMAND_SIZE];
Mike Christie8b05b772005-11-08 04:06:44 -0600847 struct st_request *SRpnt = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
849
850 max_wait = do_wait ? ST_BLOCK_SECONDS : 0;
851
852 for (attentions=waits=0; ; ) {
853 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
854 cmd[0] = TEST_UNIT_READY;
855 SRpnt = st_do_scsi(SRpnt, STp, cmd, 0, DMA_NONE,
856 STp->long_timeout, MAX_READY_RETRIES, 1);
857
858 if (!SRpnt) {
859 retval = (STp->buffer)->syscall_result;
860 break;
861 }
862
863 if (cmdstatp->have_sense) {
864
865 scode = cmdstatp->sense_hdr.sense_key;
866
867 if (scode == UNIT_ATTENTION) { /* New media? */
868 new_session = 1;
869 if (attentions < MAX_ATTENTIONS) {
870 attentions++;
871 continue;
872 }
873 else {
874 retval = (-EIO);
875 break;
876 }
877 }
878
879 if (scode == NOT_READY) {
880 if (waits < max_wait) {
881 if (msleep_interruptible(1000)) {
882 retval = (-EINTR);
883 break;
884 }
885 waits++;
886 continue;
887 }
888 else {
889 if ((STp->device)->scsi_level >= SCSI_2 &&
890 cmdstatp->sense_hdr.asc == 0x3a) /* Check ASC */
891 retval = CHKRES_NO_TAPE;
892 else
893 retval = CHKRES_NOT_READY;
894 break;
895 }
896 }
897 }
898
899 retval = (STp->buffer)->syscall_result;
900 if (!retval)
901 retval = new_session ? CHKRES_NEW_SESSION : CHKRES_READY;
902 break;
903 }
904
905 if (SRpnt != NULL)
Mike Christie8b05b772005-11-08 04:06:44 -0600906 st_release_request(SRpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907 return retval;
908}
909
910
911/* See if the drive is ready and gather information about the tape. Return values:
912 < 0 negative error code from errno.h
913 0 drive ready
914 1 drive not ready (possibly no tape)
915*/
916static int check_tape(struct scsi_tape *STp, struct file *filp)
917{
918 int i, retval, new_session = 0, do_wait;
919 unsigned char cmd[MAX_COMMAND_SIZE], saved_cleaning;
920 unsigned short st_flags = filp->f_flags;
Mike Christie8b05b772005-11-08 04:06:44 -0600921 struct st_request *SRpnt = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922 struct st_modedef *STm;
923 struct st_partstat *STps;
924 char *name = tape_name(STp);
925 struct inode *inode = filp->f_dentry->d_inode;
926 int mode = TAPE_MODE(inode);
927
928 STp->ready = ST_READY;
929
930 if (mode != STp->current_mode) {
931 DEBC(printk(ST_DEB_MSG "%s: Mode change from %d to %d.\n",
932 name, STp->current_mode, mode));
933 new_session = 1;
934 STp->current_mode = mode;
935 }
936 STm = &(STp->modes[STp->current_mode]);
937
938 saved_cleaning = STp->cleaning_req;
939 STp->cleaning_req = 0;
940
941 do_wait = ((filp->f_flags & O_NONBLOCK) == 0);
942 retval = test_ready(STp, do_wait);
943
944 if (retval < 0)
945 goto err_out;
946
947 if (retval == CHKRES_NEW_SESSION) {
948 STp->pos_unknown = 0;
949 STp->partition = STp->new_partition = 0;
950 if (STp->can_partitions)
951 STp->nbr_partitions = 1; /* This guess will be updated later
952 if necessary */
953 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
954 STps = &(STp->ps[i]);
955 STps->rw = ST_IDLE;
956 STps->eof = ST_NOEOF;
957 STps->at_sm = 0;
958 STps->last_block_valid = 0;
959 STps->drv_block = 0;
960 STps->drv_file = 0;
961 }
962 new_session = 1;
963 }
964 else {
965 STp->cleaning_req |= saved_cleaning;
966
967 if (retval == CHKRES_NOT_READY || retval == CHKRES_NO_TAPE) {
968 if (retval == CHKRES_NO_TAPE)
969 STp->ready = ST_NO_TAPE;
970 else
971 STp->ready = ST_NOT_READY;
972
973 STp->density = 0; /* Clear the erroneous "residue" */
974 STp->write_prot = 0;
975 STp->block_size = 0;
976 STp->ps[0].drv_file = STp->ps[0].drv_block = (-1);
977 STp->partition = STp->new_partition = 0;
978 STp->door_locked = ST_UNLOCKED;
979 return CHKRES_NOT_READY;
980 }
981 }
982
983 if (STp->omit_blklims)
984 STp->min_block = STp->max_block = (-1);
985 else {
986 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
987 cmd[0] = READ_BLOCK_LIMITS;
988
989 SRpnt = st_do_scsi(SRpnt, STp, cmd, 6, DMA_FROM_DEVICE,
990 STp->device->timeout, MAX_READY_RETRIES, 1);
991 if (!SRpnt) {
992 retval = (STp->buffer)->syscall_result;
993 goto err_out;
994 }
995
Mike Christie8b05b772005-11-08 04:06:44 -0600996 if (!SRpnt->result && !STp->buffer->cmdstat.have_sense) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997 STp->max_block = ((STp->buffer)->b_data[1] << 16) |
998 ((STp->buffer)->b_data[2] << 8) | (STp->buffer)->b_data[3];
999 STp->min_block = ((STp->buffer)->b_data[4] << 8) |
1000 (STp->buffer)->b_data[5];
1001 if ( DEB( debugging || ) !STp->inited)
1002 printk(KERN_WARNING
1003 "%s: Block limits %d - %d bytes.\n", name,
1004 STp->min_block, STp->max_block);
1005 } else {
1006 STp->min_block = STp->max_block = (-1);
1007 DEBC(printk(ST_DEB_MSG "%s: Can't read block limits.\n",
1008 name));
1009 }
1010 }
1011
1012 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
1013 cmd[0] = MODE_SENSE;
1014 cmd[4] = 12;
1015
1016 SRpnt = st_do_scsi(SRpnt, STp, cmd, 12, DMA_FROM_DEVICE,
1017 STp->device->timeout, MAX_READY_RETRIES, 1);
1018 if (!SRpnt) {
1019 retval = (STp->buffer)->syscall_result;
1020 goto err_out;
1021 }
1022
1023 if ((STp->buffer)->syscall_result != 0) {
1024 DEBC(printk(ST_DEB_MSG "%s: No Mode Sense.\n", name));
1025 STp->block_size = ST_DEFAULT_BLOCK; /* Educated guess (?) */
1026 (STp->buffer)->syscall_result = 0; /* Prevent error propagation */
1027 STp->drv_write_prot = 0;
1028 } else {
1029 DEBC(printk(ST_DEB_MSG
1030 "%s: Mode sense. Length %d, medium %x, WBS %x, BLL %d\n",
1031 name,
1032 (STp->buffer)->b_data[0], (STp->buffer)->b_data[1],
1033 (STp->buffer)->b_data[2], (STp->buffer)->b_data[3]));
1034
1035 if ((STp->buffer)->b_data[3] >= 8) {
1036 STp->drv_buffer = ((STp->buffer)->b_data[2] >> 4) & 7;
1037 STp->density = (STp->buffer)->b_data[4];
1038 STp->block_size = (STp->buffer)->b_data[9] * 65536 +
1039 (STp->buffer)->b_data[10] * 256 + (STp->buffer)->b_data[11];
1040 DEBC(printk(ST_DEB_MSG
1041 "%s: Density %x, tape length: %x, drv buffer: %d\n",
1042 name, STp->density, (STp->buffer)->b_data[5] * 65536 +
1043 (STp->buffer)->b_data[6] * 256 + (STp->buffer)->b_data[7],
1044 STp->drv_buffer));
1045 }
1046 STp->drv_write_prot = ((STp->buffer)->b_data[2] & 0x80) != 0;
1047 }
Mike Christie8b05b772005-11-08 04:06:44 -06001048 st_release_request(SRpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049 SRpnt = NULL;
1050 STp->inited = 1;
1051
1052 if (STp->block_size > 0)
1053 (STp->buffer)->buffer_blocks =
1054 (STp->buffer)->buffer_size / STp->block_size;
1055 else
1056 (STp->buffer)->buffer_blocks = 1;
1057 (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0;
1058
1059 DEBC(printk(ST_DEB_MSG
1060 "%s: Block size: %d, buffer size: %d (%d blocks).\n", name,
1061 STp->block_size, (STp->buffer)->buffer_size,
1062 (STp->buffer)->buffer_blocks));
1063
1064 if (STp->drv_write_prot) {
1065 STp->write_prot = 1;
1066
1067 DEBC(printk(ST_DEB_MSG "%s: Write protected\n", name));
1068
1069 if (do_wait &&
1070 ((st_flags & O_ACCMODE) == O_WRONLY ||
1071 (st_flags & O_ACCMODE) == O_RDWR)) {
1072 retval = (-EROFS);
1073 goto err_out;
1074 }
1075 }
1076
1077 if (STp->can_partitions && STp->nbr_partitions < 1) {
1078 /* This code is reached when the device is opened for the first time
1079 after the driver has been initialized with tape in the drive and the
1080 partition support has been enabled. */
1081 DEBC(printk(ST_DEB_MSG
1082 "%s: Updating partition number in status.\n", name));
1083 if ((STp->partition = find_partition(STp)) < 0) {
1084 retval = STp->partition;
1085 goto err_out;
1086 }
1087 STp->new_partition = STp->partition;
1088 STp->nbr_partitions = 1; /* This guess will be updated when necessary */
1089 }
1090
1091 if (new_session) { /* Change the drive parameters for the new mode */
1092 STp->density_changed = STp->blksize_changed = 0;
1093 STp->compression_changed = 0;
1094 if (!(STm->defaults_for_writes) &&
1095 (retval = set_mode_densblk(STp, STm)) < 0)
1096 goto err_out;
1097
1098 if (STp->default_drvbuffer != 0xff) {
1099 if (st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer))
1100 printk(KERN_WARNING
1101 "%s: Can't set default drive buffering to %d.\n",
1102 name, STp->default_drvbuffer);
1103 }
1104 }
1105
1106 return CHKRES_READY;
1107
1108 err_out:
1109 return retval;
1110}
1111
1112
1113 /* Open the device. Needs to be called with BKL only because of incrementing the SCSI host
1114 module count. */
1115static int st_open(struct inode *inode, struct file *filp)
1116{
1117 int i, retval = (-EIO);
1118 struct scsi_tape *STp;
1119 struct st_partstat *STps;
1120 int dev = TAPE_NR(inode);
1121 char *name;
1122
1123 /*
1124 * We really want to do nonseekable_open(inode, filp); here, but some
1125 * versions of tar incorrectly call lseek on tapes and bail out if that
1126 * fails. So we disallow pread() and pwrite(), but permit lseeks.
1127 */
1128 filp->f_mode &= ~(FMODE_PREAD | FMODE_PWRITE);
1129
Kai Makisaraf03a5672005-08-02 13:40:47 +03001130 if (!(STp = scsi_tape_get(dev)))
1131 return -ENXIO;
1132
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133 write_lock(&st_dev_arr_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001134 filp->private_data = STp;
1135 name = tape_name(STp);
1136
1137 if (STp->in_use) {
1138 write_unlock(&st_dev_arr_lock);
Kai Makisaraf03a5672005-08-02 13:40:47 +03001139 scsi_tape_put(STp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140 DEB( printk(ST_DEB_MSG "%s: Device already in use.\n", name); )
1141 return (-EBUSY);
1142 }
1143
Linus Torvalds1da177e2005-04-16 15:20:36 -07001144 STp->in_use = 1;
1145 write_unlock(&st_dev_arr_lock);
1146 STp->rew_at_close = STp->autorew_dev = (iminor(inode) & 0x80) == 0;
1147
1148 if (!scsi_block_when_processing_errors(STp->device)) {
1149 retval = (-ENXIO);
1150 goto err_out;
1151 }
1152
1153 /* See that we have at least a one page buffer available */
1154 if (!enlarge_buffer(STp->buffer, PAGE_SIZE, STp->restr_dma)) {
1155 printk(KERN_WARNING "%s: Can't allocate one page tape buffer.\n",
1156 name);
1157 retval = (-EOVERFLOW);
1158 goto err_out;
1159 }
1160
1161 (STp->buffer)->writing = 0;
1162 (STp->buffer)->syscall_result = 0;
1163
1164 STp->write_prot = ((filp->f_flags & O_ACCMODE) == O_RDONLY);
1165
1166 STp->dirty = 0;
1167 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
1168 STps = &(STp->ps[i]);
1169 STps->rw = ST_IDLE;
1170 }
1171 STp->recover_count = 0;
1172 DEB( STp->nbr_waits = STp->nbr_finished = 0;
1173 STp->nbr_requests = STp->nbr_dio = STp->nbr_pages = STp->nbr_combinable = 0; )
1174
1175 retval = check_tape(STp, filp);
1176 if (retval < 0)
1177 goto err_out;
1178 if ((filp->f_flags & O_NONBLOCK) == 0 &&
1179 retval != CHKRES_READY) {
1180 retval = (-EIO);
1181 goto err_out;
1182 }
1183 return 0;
1184
1185 err_out:
1186 normalize_buffer(STp->buffer);
1187 STp->in_use = 0;
Kai Makisaraf03a5672005-08-02 13:40:47 +03001188 scsi_tape_put(STp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189 return retval;
1190
1191}
1192
1193
1194/* Flush the tape buffer before close */
Miklos Szeredi75e1fcc2006-06-23 02:05:12 -07001195static int st_flush(struct file *filp, fl_owner_t id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196{
1197 int result = 0, result2;
1198 unsigned char cmd[MAX_COMMAND_SIZE];
Mike Christie8b05b772005-11-08 04:06:44 -06001199 struct st_request *SRpnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200 struct scsi_tape *STp = filp->private_data;
1201 struct st_modedef *STm = &(STp->modes[STp->current_mode]);
1202 struct st_partstat *STps = &(STp->ps[STp->partition]);
1203 char *name = tape_name(STp);
1204
1205 if (file_count(filp) > 1)
1206 return 0;
1207
1208 if (STps->rw == ST_WRITING && !STp->pos_unknown) {
1209 result = flush_write_buffer(STp);
1210 if (result != 0 && result != (-ENOSPC))
1211 goto out;
1212 }
1213
1214 if (STp->can_partitions &&
1215 (result2 = switch_partition(STp)) < 0) {
1216 DEBC(printk(ST_DEB_MSG
1217 "%s: switch_partition at close failed.\n", name));
1218 if (result == 0)
1219 result = result2;
1220 goto out;
1221 }
1222
1223 DEBC( if (STp->nbr_requests)
1224 printk(KERN_WARNING "%s: Number of r/w requests %d, dio used in %d, pages %d (%d).\n",
1225 name, STp->nbr_requests, STp->nbr_dio, STp->nbr_pages, STp->nbr_combinable));
1226
1227 if (STps->rw == ST_WRITING && !STp->pos_unknown) {
1228 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1229
1230 DEBC(printk(ST_DEB_MSG "%s: Async write waits %d, finished %d.\n",
1231 name, STp->nbr_waits, STp->nbr_finished);
1232 )
1233
1234 memset(cmd, 0, MAX_COMMAND_SIZE);
1235 cmd[0] = WRITE_FILEMARKS;
1236 cmd[4] = 1 + STp->two_fm;
1237
1238 SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
1239 STp->device->timeout, MAX_WRITE_RETRIES, 1);
1240 if (!SRpnt) {
1241 result = (STp->buffer)->syscall_result;
1242 goto out;
1243 }
1244
1245 if (STp->buffer->syscall_result == 0 ||
1246 (cmdstatp->have_sense && !cmdstatp->deferred &&
1247 (cmdstatp->flags & SENSE_EOM) &&
1248 (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
1249 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) &&
1250 (!cmdstatp->remainder_valid || cmdstatp->uremainder64 == 0))) {
1251 /* Write successful at EOM */
Mike Christie8b05b772005-11-08 04:06:44 -06001252 st_release_request(SRpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001253 SRpnt = NULL;
1254 if (STps->drv_file >= 0)
1255 STps->drv_file++;
1256 STps->drv_block = 0;
1257 if (STp->two_fm)
1258 cross_eof(STp, 0);
1259 STps->eof = ST_FM;
1260 }
1261 else { /* Write error */
Mike Christie8b05b772005-11-08 04:06:44 -06001262 st_release_request(SRpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263 SRpnt = NULL;
1264 printk(KERN_ERR "%s: Error on write filemark.\n", name);
1265 if (result == 0)
1266 result = (-EIO);
1267 }
1268
1269 DEBC(printk(ST_DEB_MSG "%s: Buffer flushed, %d EOF(s) written\n",
1270 name, cmd[4]));
1271 } else if (!STp->rew_at_close) {
1272 STps = &(STp->ps[STp->partition]);
1273 if (!STm->sysv || STps->rw != ST_READING) {
1274 if (STp->can_bsr)
1275 result = flush_buffer(STp, 0);
1276 else if (STps->eof == ST_FM_HIT) {
1277 result = cross_eof(STp, 0);
1278 if (result) {
1279 if (STps->drv_file >= 0)
1280 STps->drv_file++;
1281 STps->drv_block = 0;
1282 STps->eof = ST_FM;
1283 } else
1284 STps->eof = ST_NOEOF;
1285 }
1286 } else if ((STps->eof == ST_NOEOF &&
1287 !(result = cross_eof(STp, 1))) ||
1288 STps->eof == ST_FM_HIT) {
1289 if (STps->drv_file >= 0)
1290 STps->drv_file++;
1291 STps->drv_block = 0;
1292 STps->eof = ST_FM;
1293 }
1294 }
1295
1296 out:
1297 if (STp->rew_at_close) {
1298 result2 = st_int_ioctl(STp, MTREW, 1);
1299 if (result == 0)
1300 result = result2;
1301 }
1302 return result;
1303}
1304
1305
1306/* Close the device and release it. BKL is not needed: this is the only thread
1307 accessing this tape. */
1308static int st_release(struct inode *inode, struct file *filp)
1309{
1310 int result = 0;
1311 struct scsi_tape *STp = filp->private_data;
1312
1313 if (STp->door_locked == ST_LOCKED_AUTO)
1314 do_door_lock(STp, 0);
1315
1316 normalize_buffer(STp->buffer);
1317 write_lock(&st_dev_arr_lock);
1318 STp->in_use = 0;
1319 write_unlock(&st_dev_arr_lock);
Kai Makisaraf03a5672005-08-02 13:40:47 +03001320 scsi_tape_put(STp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321
1322 return result;
1323}
1324
1325/* The checks common to both reading and writing */
1326static ssize_t rw_checks(struct scsi_tape *STp, struct file *filp, size_t count)
1327{
1328 ssize_t retval = 0;
1329
1330 /*
1331 * If we are in the middle of error recovery, don't let anyone
1332 * else try and use this device. Also, if error recovery fails, it
1333 * may try and take the device offline, in which case all further
1334 * access to the device is prohibited.
1335 */
1336 if (!scsi_block_when_processing_errors(STp->device)) {
1337 retval = (-ENXIO);
1338 goto out;
1339 }
1340
1341 if (STp->ready != ST_READY) {
1342 if (STp->ready == ST_NO_TAPE)
1343 retval = (-ENOMEDIUM);
1344 else
1345 retval = (-EIO);
1346 goto out;
1347 }
1348
1349 if (! STp->modes[STp->current_mode].defined) {
1350 retval = (-ENXIO);
1351 goto out;
1352 }
1353
1354
1355 /*
1356 * If there was a bus reset, block further access
1357 * to this device.
1358 */
1359 if (STp->pos_unknown) {
1360 retval = (-EIO);
1361 goto out;
1362 }
1363
1364 if (count == 0)
1365 goto out;
1366
1367 DEB(
1368 if (!STp->in_use) {
1369 printk(ST_DEB_MSG "%s: Incorrect device.\n", tape_name(STp));
1370 retval = (-EIO);
1371 goto out;
1372 } ) /* end DEB */
1373
1374 if (STp->can_partitions &&
1375 (retval = switch_partition(STp)) < 0)
1376 goto out;
1377
1378 if (STp->block_size == 0 && STp->max_block > 0 &&
1379 (count < STp->min_block || count > STp->max_block)) {
1380 retval = (-EINVAL);
1381 goto out;
1382 }
1383
1384 if (STp->do_auto_lock && STp->door_locked == ST_UNLOCKED &&
1385 !do_door_lock(STp, 1))
1386 STp->door_locked = ST_LOCKED_AUTO;
1387
1388 out:
1389 return retval;
1390}
1391
1392
1393static int setup_buffering(struct scsi_tape *STp, const char __user *buf,
1394 size_t count, int is_read)
1395{
1396 int i, bufsize, retval = 0;
1397 struct st_buffer *STbp = STp->buffer;
1398
1399 if (is_read)
1400 i = STp->try_dio && try_rdio;
1401 else
1402 i = STp->try_dio && try_wdio;
Mike Christie8b05b772005-11-08 04:06:44 -06001403
Linus Torvalds1da177e2005-04-16 15:20:36 -07001404 if (i && ((unsigned long)buf & queue_dma_alignment(
1405 STp->device->request_queue)) == 0) {
Mike Christie8b05b772005-11-08 04:06:44 -06001406 i = sgl_map_user_pages(&(STbp->sg[0]), STbp->use_sg,
1407 (unsigned long)buf, count, (is_read ? READ : WRITE));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001408 if (i > 0) {
1409 STbp->do_dio = i;
1410 STbp->buffer_bytes = 0; /* can be used as transfer counter */
1411 }
1412 else
1413 STbp->do_dio = 0; /* fall back to buffering with any error */
1414 STbp->sg_segs = STbp->do_dio;
1415 STbp->frp_sg_current = 0;
1416 DEB(
1417 if (STbp->do_dio) {
1418 STp->nbr_dio++;
1419 STp->nbr_pages += STbp->do_dio;
1420 for (i=1; i < STbp->do_dio; i++)
1421 if (page_to_pfn(STbp->sg[i].page) == page_to_pfn(STbp->sg[i-1].page) + 1)
1422 STp->nbr_combinable++;
1423 }
1424 )
1425 } else
1426 STbp->do_dio = 0;
1427 DEB( STp->nbr_requests++; )
1428
1429 if (!STbp->do_dio) {
1430 if (STp->block_size)
1431 bufsize = STp->block_size > st_fixed_buffer_size ?
1432 STp->block_size : st_fixed_buffer_size;
1433 else
1434 bufsize = count;
1435 if (bufsize > STbp->buffer_size &&
1436 !enlarge_buffer(STbp, bufsize, STp->restr_dma)) {
1437 printk(KERN_WARNING "%s: Can't allocate %d byte tape buffer.\n",
1438 tape_name(STp), bufsize);
1439 retval = (-EOVERFLOW);
1440 goto out;
1441 }
1442 if (STp->block_size)
1443 STbp->buffer_blocks = bufsize / STp->block_size;
1444 }
1445
1446 out:
1447 return retval;
1448}
1449
1450
1451/* Can be called more than once after each setup_buffer() */
Kai Makisara787926b2005-11-13 10:04:44 +02001452static void release_buffering(struct scsi_tape *STp, int is_read)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001453{
1454 struct st_buffer *STbp;
1455
1456 STbp = STp->buffer;
1457 if (STbp->do_dio) {
Kai Makisara787926b2005-11-13 10:04:44 +02001458 sgl_unmap_user_pages(&(STbp->sg[0]), STbp->do_dio, is_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001459 STbp->do_dio = 0;
Kai Makisara787926b2005-11-13 10:04:44 +02001460 STbp->sg_segs = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001461 }
1462}
1463
1464
1465/* Write command */
1466static ssize_t
1467st_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
1468{
1469 ssize_t total;
1470 ssize_t i, do_count, blks, transfer;
1471 ssize_t retval;
1472 int undone, retry_eot = 0, scode;
1473 int async_write;
1474 unsigned char cmd[MAX_COMMAND_SIZE];
1475 const char __user *b_point;
Mike Christie8b05b772005-11-08 04:06:44 -06001476 struct st_request *SRpnt = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001477 struct scsi_tape *STp = filp->private_data;
1478 struct st_modedef *STm;
1479 struct st_partstat *STps;
1480 struct st_buffer *STbp;
1481 char *name = tape_name(STp);
1482
1483 if (down_interruptible(&STp->lock))
1484 return -ERESTARTSYS;
1485
1486 retval = rw_checks(STp, filp, count);
1487 if (retval || count == 0)
1488 goto out;
1489
1490 /* Write must be integral number of blocks */
1491 if (STp->block_size != 0 && (count % STp->block_size) != 0) {
1492 printk(KERN_WARNING "%s: Write not multiple of tape block size.\n",
1493 name);
1494 retval = (-EINVAL);
1495 goto out;
1496 }
1497
1498 STm = &(STp->modes[STp->current_mode]);
1499 STps = &(STp->ps[STp->partition]);
1500
1501 if (STp->write_prot) {
1502 retval = (-EACCES);
1503 goto out;
1504 }
1505
1506
1507 if (STps->rw == ST_READING) {
1508 retval = flush_buffer(STp, 0);
1509 if (retval)
1510 goto out;
1511 STps->rw = ST_WRITING;
1512 } else if (STps->rw != ST_WRITING &&
1513 STps->drv_file == 0 && STps->drv_block == 0) {
1514 if ((retval = set_mode_densblk(STp, STm)) < 0)
1515 goto out;
1516 if (STm->default_compression != ST_DONT_TOUCH &&
1517 !(STp->compression_changed)) {
1518 if (st_compression(STp, (STm->default_compression == ST_YES))) {
1519 printk(KERN_WARNING "%s: Can't set default compression.\n",
1520 name);
1521 if (modes_defined) {
1522 retval = (-EINVAL);
1523 goto out;
1524 }
1525 }
1526 }
1527 }
1528
1529 STbp = STp->buffer;
1530 i = write_behind_check(STp);
1531 if (i) {
1532 if (i == -ENOSPC)
1533 STps->eof = ST_EOM_OK;
1534 else
1535 STps->eof = ST_EOM_ERROR;
1536 }
1537
1538 if (STps->eof == ST_EOM_OK) {
1539 STps->eof = ST_EOD_1; /* allow next write */
1540 retval = (-ENOSPC);
1541 goto out;
1542 }
1543 else if (STps->eof == ST_EOM_ERROR) {
1544 retval = (-EIO);
1545 goto out;
1546 }
1547
1548 /* Check the buffer readability in cases where copy_user might catch
1549 the problems after some tape movement. */
1550 if (STp->block_size != 0 &&
1551 !STbp->do_dio &&
1552 (copy_from_user(&i, buf, 1) != 0 ||
1553 copy_from_user(&i, buf + count - 1, 1) != 0)) {
1554 retval = (-EFAULT);
1555 goto out;
1556 }
1557
1558 retval = setup_buffering(STp, buf, count, 0);
1559 if (retval)
1560 goto out;
1561
1562 total = count;
1563
1564 memset(cmd, 0, MAX_COMMAND_SIZE);
1565 cmd[0] = WRITE_6;
1566 cmd[1] = (STp->block_size != 0);
1567
1568 STps->rw = ST_WRITING;
1569
1570 b_point = buf;
1571 while (count > 0 && !retry_eot) {
1572
1573 if (STbp->do_dio) {
1574 do_count = count;
1575 }
1576 else {
1577 if (STp->block_size == 0)
1578 do_count = count;
1579 else {
1580 do_count = STbp->buffer_blocks * STp->block_size -
1581 STbp->buffer_bytes;
1582 if (do_count > count)
1583 do_count = count;
1584 }
1585
1586 i = append_to_buffer(b_point, STbp, do_count);
1587 if (i) {
1588 retval = i;
1589 goto out;
1590 }
1591 }
1592 count -= do_count;
1593 b_point += do_count;
1594
1595 async_write = STp->block_size == 0 && !STbp->do_dio &&
1596 STm->do_async_writes && STps->eof < ST_EOM_OK;
1597
1598 if (STp->block_size != 0 && STm->do_buffer_writes &&
1599 !(STp->try_dio && try_wdio) && STps->eof < ST_EOM_OK &&
1600 STbp->buffer_bytes < STbp->buffer_size) {
1601 STp->dirty = 1;
1602 /* Don't write a buffer that is not full enough. */
1603 if (!async_write && count == 0)
1604 break;
1605 }
1606
1607 retry_write:
1608 if (STp->block_size == 0)
1609 blks = transfer = do_count;
1610 else {
1611 if (!STbp->do_dio)
1612 blks = STbp->buffer_bytes;
1613 else
1614 blks = do_count;
1615 blks /= STp->block_size;
1616 transfer = blks * STp->block_size;
1617 }
1618 cmd[2] = blks >> 16;
1619 cmd[3] = blks >> 8;
1620 cmd[4] = blks;
1621
1622 SRpnt = st_do_scsi(SRpnt, STp, cmd, transfer, DMA_TO_DEVICE,
1623 STp->device->timeout, MAX_WRITE_RETRIES, !async_write);
1624 if (!SRpnt) {
1625 retval = STbp->syscall_result;
1626 goto out;
1627 }
Mike Christie8b05b772005-11-08 04:06:44 -06001628 if (async_write && !STbp->syscall_result) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001629 STbp->writing = transfer;
1630 STp->dirty = !(STbp->writing ==
1631 STbp->buffer_bytes);
1632 SRpnt = NULL; /* Prevent releasing this request! */
1633 DEB( STp->write_pending = 1; )
1634 break;
1635 }
1636
1637 if (STbp->syscall_result != 0) {
1638 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1639
1640 DEBC(printk(ST_DEB_MSG "%s: Error on write:\n", name));
1641 if (cmdstatp->have_sense && (cmdstatp->flags & SENSE_EOM)) {
1642 scode = cmdstatp->sense_hdr.sense_key;
1643 if (cmdstatp->remainder_valid)
1644 undone = (int)cmdstatp->uremainder64;
1645 else if (STp->block_size == 0 &&
1646 scode == VOLUME_OVERFLOW)
1647 undone = transfer;
1648 else
1649 undone = 0;
1650 if (STp->block_size != 0)
1651 undone *= STp->block_size;
1652 if (undone <= do_count) {
1653 /* Only data from this write is not written */
1654 count += undone;
1655 do_count -= undone;
1656 if (STp->block_size)
1657 blks = (transfer - undone) / STp->block_size;
1658 STps->eof = ST_EOM_OK;
1659 /* Continue in fixed block mode if all written
1660 in this request but still something left to write
1661 (retval left to zero)
1662 */
1663 if (STp->block_size == 0 ||
1664 undone > 0 || count == 0)
1665 retval = (-ENOSPC); /* EOM within current request */
1666 DEBC(printk(ST_DEB_MSG
1667 "%s: EOM with %d bytes unwritten.\n",
1668 name, (int)count));
1669 } else {
1670 /* EOT within data buffered earlier (possible only
1671 in fixed block mode without direct i/o) */
1672 if (!retry_eot && !cmdstatp->deferred &&
1673 (scode == NO_SENSE || scode == RECOVERED_ERROR)) {
1674 move_buffer_data(STp->buffer, transfer - undone);
1675 retry_eot = 1;
1676 if (STps->drv_block >= 0) {
1677 STps->drv_block += (transfer - undone) /
1678 STp->block_size;
1679 }
1680 STps->eof = ST_EOM_OK;
1681 DEBC(printk(ST_DEB_MSG
1682 "%s: Retry write of %d bytes at EOM.\n",
1683 name, STp->buffer->buffer_bytes));
1684 goto retry_write;
1685 }
1686 else {
1687 /* Either error within data buffered by driver or
1688 failed retry */
1689 count -= do_count;
1690 blks = do_count = 0;
1691 STps->eof = ST_EOM_ERROR;
1692 STps->drv_block = (-1); /* Too cautious? */
1693 retval = (-EIO); /* EOM for old data */
1694 DEBC(printk(ST_DEB_MSG
1695 "%s: EOM with lost data.\n",
1696 name));
1697 }
1698 }
1699 } else {
1700 count += do_count;
1701 STps->drv_block = (-1); /* Too cautious? */
Mike Christie8b05b772005-11-08 04:06:44 -06001702 retval = STbp->syscall_result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001703 }
1704
1705 }
1706
1707 if (STps->drv_block >= 0) {
1708 if (STp->block_size == 0)
1709 STps->drv_block += (do_count > 0);
1710 else
1711 STps->drv_block += blks;
1712 }
1713
1714 STbp->buffer_bytes = 0;
1715 STp->dirty = 0;
1716
1717 if (retval || retry_eot) {
1718 if (count < total)
1719 retval = total - count;
1720 goto out;
1721 }
1722 }
1723
1724 if (STps->eof == ST_EOD_1)
1725 STps->eof = ST_EOM_OK;
1726 else if (STps->eof != ST_EOM_OK)
1727 STps->eof = ST_NOEOF;
1728 retval = total - count;
1729
1730 out:
1731 if (SRpnt != NULL)
Mike Christie8b05b772005-11-08 04:06:44 -06001732 st_release_request(SRpnt);
Kai Makisara787926b2005-11-13 10:04:44 +02001733 release_buffering(STp, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001734 up(&STp->lock);
1735
1736 return retval;
1737}
1738
1739/* Read data from the tape. Returns zero in the normal case, one if the
1740 eof status has changed, and the negative error code in case of a
1741 fatal error. Otherwise updates the buffer and the eof state.
1742
1743 Does release user buffer mapping if it is set.
1744*/
1745static long read_tape(struct scsi_tape *STp, long count,
Mike Christie8b05b772005-11-08 04:06:44 -06001746 struct st_request ** aSRpnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001747{
1748 int transfer, blks, bytes;
1749 unsigned char cmd[MAX_COMMAND_SIZE];
Mike Christie8b05b772005-11-08 04:06:44 -06001750 struct st_request *SRpnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001751 struct st_modedef *STm;
1752 struct st_partstat *STps;
1753 struct st_buffer *STbp;
1754 int retval = 0;
1755 char *name = tape_name(STp);
1756
1757 if (count == 0)
1758 return 0;
1759
1760 STm = &(STp->modes[STp->current_mode]);
1761 STps = &(STp->ps[STp->partition]);
1762 if (STps->eof == ST_FM_HIT)
1763 return 1;
1764 STbp = STp->buffer;
1765
1766 if (STp->block_size == 0)
1767 blks = bytes = count;
1768 else {
1769 if (!(STp->try_dio && try_rdio) && STm->do_read_ahead) {
1770 blks = (STp->buffer)->buffer_blocks;
1771 bytes = blks * STp->block_size;
1772 } else {
1773 bytes = count;
1774 if (!STbp->do_dio && bytes > (STp->buffer)->buffer_size)
1775 bytes = (STp->buffer)->buffer_size;
1776 blks = bytes / STp->block_size;
1777 bytes = blks * STp->block_size;
1778 }
1779 }
1780
1781 memset(cmd, 0, MAX_COMMAND_SIZE);
1782 cmd[0] = READ_6;
1783 cmd[1] = (STp->block_size != 0);
1784 cmd[2] = blks >> 16;
1785 cmd[3] = blks >> 8;
1786 cmd[4] = blks;
1787
1788 SRpnt = *aSRpnt;
1789 SRpnt = st_do_scsi(SRpnt, STp, cmd, bytes, DMA_FROM_DEVICE,
1790 STp->device->timeout, MAX_RETRIES, 1);
Kai Makisara787926b2005-11-13 10:04:44 +02001791 release_buffering(STp, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001792 *aSRpnt = SRpnt;
1793 if (!SRpnt)
1794 return STbp->syscall_result;
1795
1796 STbp->read_pointer = 0;
1797 STps->at_sm = 0;
1798
1799 /* Something to check */
1800 if (STbp->syscall_result) {
1801 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1802
1803 retval = 1;
1804 DEBC(printk(ST_DEB_MSG "%s: Sense: %2x %2x %2x %2x %2x %2x %2x %2x\n",
1805 name,
Mike Christie8b05b772005-11-08 04:06:44 -06001806 SRpnt->sense[0], SRpnt->sense[1],
1807 SRpnt->sense[2], SRpnt->sense[3],
1808 SRpnt->sense[4], SRpnt->sense[5],
1809 SRpnt->sense[6], SRpnt->sense[7]));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001810 if (cmdstatp->have_sense) {
1811
1812 if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK)
1813 cmdstatp->flags &= 0xcf; /* No need for EOM in this case */
1814
1815 if (cmdstatp->flags != 0) { /* EOF, EOM, or ILI */
1816 /* Compute the residual count */
1817 if (cmdstatp->remainder_valid)
1818 transfer = (int)cmdstatp->uremainder64;
1819 else
1820 transfer = 0;
1821 if (STp->block_size == 0 &&
1822 cmdstatp->sense_hdr.sense_key == MEDIUM_ERROR)
1823 transfer = bytes;
1824
1825 if (cmdstatp->flags & SENSE_ILI) { /* ILI */
1826 if (STp->block_size == 0) {
1827 if (transfer <= 0) {
1828 if (transfer < 0)
1829 printk(KERN_NOTICE
1830 "%s: Failed to read %d byte block with %d byte transfer.\n",
1831 name, bytes - transfer, bytes);
1832 if (STps->drv_block >= 0)
1833 STps->drv_block += 1;
1834 STbp->buffer_bytes = 0;
1835 return (-ENOMEM);
1836 }
1837 STbp->buffer_bytes = bytes - transfer;
1838 } else {
Mike Christie8b05b772005-11-08 04:06:44 -06001839 st_release_request(SRpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001840 SRpnt = *aSRpnt = NULL;
1841 if (transfer == blks) { /* We did not get anything, error */
1842 printk(KERN_NOTICE "%s: Incorrect block size.\n", name);
1843 if (STps->drv_block >= 0)
1844 STps->drv_block += blks - transfer + 1;
1845 st_int_ioctl(STp, MTBSR, 1);
1846 return (-EIO);
1847 }
1848 /* We have some data, deliver it */
1849 STbp->buffer_bytes = (blks - transfer) *
1850 STp->block_size;
1851 DEBC(printk(ST_DEB_MSG
1852 "%s: ILI but enough data received %ld %d.\n",
1853 name, count, STbp->buffer_bytes));
1854 if (STps->drv_block >= 0)
1855 STps->drv_block += 1;
1856 if (st_int_ioctl(STp, MTBSR, 1))
1857 return (-EIO);
1858 }
1859 } else if (cmdstatp->flags & SENSE_FMK) { /* FM overrides EOM */
1860 if (STps->eof != ST_FM_HIT)
1861 STps->eof = ST_FM_HIT;
1862 else
1863 STps->eof = ST_EOD_2;
1864 if (STp->block_size == 0)
1865 STbp->buffer_bytes = 0;
1866 else
1867 STbp->buffer_bytes =
1868 bytes - transfer * STp->block_size;
1869 DEBC(printk(ST_DEB_MSG
1870 "%s: EOF detected (%d bytes read).\n",
1871 name, STbp->buffer_bytes));
1872 } else if (cmdstatp->flags & SENSE_EOM) {
1873 if (STps->eof == ST_FM)
1874 STps->eof = ST_EOD_1;
1875 else
1876 STps->eof = ST_EOM_OK;
1877 if (STp->block_size == 0)
1878 STbp->buffer_bytes = bytes - transfer;
1879 else
1880 STbp->buffer_bytes =
1881 bytes - transfer * STp->block_size;
1882
1883 DEBC(printk(ST_DEB_MSG "%s: EOM detected (%d bytes read).\n",
1884 name, STbp->buffer_bytes));
1885 }
1886 }
1887 /* end of EOF, EOM, ILI test */
1888 else { /* nonzero sense key */
1889 DEBC(printk(ST_DEB_MSG
1890 "%s: Tape error while reading.\n", name));
1891 STps->drv_block = (-1);
1892 if (STps->eof == ST_FM &&
1893 cmdstatp->sense_hdr.sense_key == BLANK_CHECK) {
1894 DEBC(printk(ST_DEB_MSG
1895 "%s: Zero returned for first BLANK CHECK after EOF.\n",
1896 name));
1897 STps->eof = ST_EOD_2; /* First BLANK_CHECK after FM */
1898 } else /* Some other extended sense code */
1899 retval = (-EIO);
1900 }
1901
1902 if (STbp->buffer_bytes < 0) /* Caused by bogus sense data */
1903 STbp->buffer_bytes = 0;
1904 }
1905 /* End of extended sense test */
1906 else { /* Non-extended sense */
1907 retval = STbp->syscall_result;
1908 }
1909
1910 }
1911 /* End of error handling */
1912 else /* Read successful */
1913 STbp->buffer_bytes = bytes;
1914
1915 if (STps->drv_block >= 0) {
1916 if (STp->block_size == 0)
1917 STps->drv_block++;
1918 else
1919 STps->drv_block += STbp->buffer_bytes / STp->block_size;
1920 }
1921 return retval;
1922}
1923
1924
1925/* Read command */
1926static ssize_t
1927st_read(struct file *filp, char __user *buf, size_t count, loff_t * ppos)
1928{
1929 ssize_t total;
1930 ssize_t retval = 0;
1931 ssize_t i, transfer;
1932 int special, do_dio = 0;
Mike Christie8b05b772005-11-08 04:06:44 -06001933 struct st_request *SRpnt = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001934 struct scsi_tape *STp = filp->private_data;
1935 struct st_modedef *STm;
1936 struct st_partstat *STps;
1937 struct st_buffer *STbp = STp->buffer;
1938 DEB( char *name = tape_name(STp); )
1939
1940 if (down_interruptible(&STp->lock))
1941 return -ERESTARTSYS;
1942
1943 retval = rw_checks(STp, filp, count);
1944 if (retval || count == 0)
1945 goto out;
1946
1947 STm = &(STp->modes[STp->current_mode]);
1948 if (!(STm->do_read_ahead) && STp->block_size != 0 &&
1949 (count % STp->block_size) != 0) {
1950 retval = (-EINVAL); /* Read must be integral number of blocks */
1951 goto out;
1952 }
1953
1954 STps = &(STp->ps[STp->partition]);
1955 if (STps->rw == ST_WRITING) {
1956 retval = flush_buffer(STp, 0);
1957 if (retval)
1958 goto out;
1959 STps->rw = ST_READING;
1960 }
1961 DEB(
1962 if (debugging && STps->eof != ST_NOEOF)
1963 printk(ST_DEB_MSG "%s: EOF/EOM flag up (%d). Bytes %d\n", name,
1964 STps->eof, STbp->buffer_bytes);
1965 ) /* end DEB */
1966
1967 retval = setup_buffering(STp, buf, count, 1);
1968 if (retval)
1969 goto out;
1970 do_dio = STbp->do_dio;
1971
1972 if (STbp->buffer_bytes == 0 &&
1973 STps->eof >= ST_EOD_1) {
1974 if (STps->eof < ST_EOD) {
1975 STps->eof += 1;
1976 retval = 0;
1977 goto out;
1978 }
1979 retval = (-EIO); /* EOM or Blank Check */
1980 goto out;
1981 }
1982
1983 if (do_dio) {
1984 /* Check the buffer writability before any tape movement. Don't alter
1985 buffer data. */
1986 if (copy_from_user(&i, buf, 1) != 0 ||
1987 copy_to_user(buf, &i, 1) != 0 ||
1988 copy_from_user(&i, buf + count - 1, 1) != 0 ||
1989 copy_to_user(buf + count - 1, &i, 1) != 0) {
1990 retval = (-EFAULT);
1991 goto out;
1992 }
1993 }
1994
1995 STps->rw = ST_READING;
1996
1997
1998 /* Loop until enough data in buffer or a special condition found */
1999 for (total = 0, special = 0; total < count && !special;) {
2000
2001 /* Get new data if the buffer is empty */
2002 if (STbp->buffer_bytes == 0) {
2003 special = read_tape(STp, count - total, &SRpnt);
2004 if (special < 0) { /* No need to continue read */
2005 retval = special;
2006 goto out;
2007 }
2008 }
2009
2010 /* Move the data from driver buffer to user buffer */
2011 if (STbp->buffer_bytes > 0) {
2012 DEB(
2013 if (debugging && STps->eof != ST_NOEOF)
2014 printk(ST_DEB_MSG
2015 "%s: EOF up (%d). Left %d, needed %d.\n", name,
2016 STps->eof, STbp->buffer_bytes,
2017 (int)(count - total));
2018 ) /* end DEB */
2019 transfer = STbp->buffer_bytes < count - total ?
2020 STbp->buffer_bytes : count - total;
2021 if (!do_dio) {
2022 i = from_buffer(STbp, buf, transfer);
2023 if (i) {
2024 retval = i;
2025 goto out;
2026 }
2027 }
2028 buf += transfer;
2029 total += transfer;
2030 }
2031
2032 if (STp->block_size == 0)
2033 break; /* Read only one variable length block */
2034
2035 } /* for (total = 0, special = 0;
2036 total < count && !special; ) */
2037
2038 /* Change the eof state if no data from tape or buffer */
2039 if (total == 0) {
2040 if (STps->eof == ST_FM_HIT) {
2041 STps->eof = ST_FM;
2042 STps->drv_block = 0;
2043 if (STps->drv_file >= 0)
2044 STps->drv_file++;
2045 } else if (STps->eof == ST_EOD_1) {
2046 STps->eof = ST_EOD_2;
2047 STps->drv_block = 0;
2048 if (STps->drv_file >= 0)
2049 STps->drv_file++;
2050 } else if (STps->eof == ST_EOD_2)
2051 STps->eof = ST_EOD;
2052 } else if (STps->eof == ST_FM)
2053 STps->eof = ST_NOEOF;
2054 retval = total;
2055
2056 out:
2057 if (SRpnt != NULL) {
Mike Christie8b05b772005-11-08 04:06:44 -06002058 st_release_request(SRpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002059 SRpnt = NULL;
2060 }
2061 if (do_dio) {
Kai Makisara787926b2005-11-13 10:04:44 +02002062 release_buffering(STp, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002063 STbp->buffer_bytes = 0;
2064 }
2065 up(&STp->lock);
2066
2067 return retval;
2068}
2069
2070
2071
2072DEB(
2073/* Set the driver options */
2074static void st_log_options(struct scsi_tape * STp, struct st_modedef * STm, char *name)
2075{
2076 if (debugging) {
2077 printk(KERN_INFO
2078 "%s: Mode %d options: buffer writes: %d, async writes: %d, read ahead: %d\n",
2079 name, STp->current_mode, STm->do_buffer_writes, STm->do_async_writes,
2080 STm->do_read_ahead);
2081 printk(KERN_INFO
2082 "%s: can bsr: %d, two FMs: %d, fast mteom: %d, auto lock: %d,\n",
2083 name, STp->can_bsr, STp->two_fm, STp->fast_mteom, STp->do_auto_lock);
2084 printk(KERN_INFO
2085 "%s: defs for wr: %d, no block limits: %d, partitions: %d, s2 log: %d\n",
2086 name, STm->defaults_for_writes, STp->omit_blklims, STp->can_partitions,
2087 STp->scsi2_logical);
2088 printk(KERN_INFO
2089 "%s: sysv: %d nowait: %d\n", name, STm->sysv, STp->immediate);
2090 printk(KERN_INFO "%s: debugging: %d\n",
2091 name, debugging);
2092 }
2093}
2094 )
2095
2096
2097static int st_set_options(struct scsi_tape *STp, long options)
2098{
2099 int value;
2100 long code;
2101 struct st_modedef *STm;
2102 char *name = tape_name(STp);
2103 struct cdev *cd0, *cd1;
2104
2105 STm = &(STp->modes[STp->current_mode]);
2106 if (!STm->defined) {
2107 cd0 = STm->cdevs[0]; cd1 = STm->cdevs[1];
2108 memcpy(STm, &(STp->modes[0]), sizeof(struct st_modedef));
2109 STm->cdevs[0] = cd0; STm->cdevs[1] = cd1;
2110 modes_defined = 1;
2111 DEBC(printk(ST_DEB_MSG
2112 "%s: Initialized mode %d definition from mode 0\n",
2113 name, STp->current_mode));
2114 }
2115
2116 code = options & MT_ST_OPTIONS;
2117 if (code == MT_ST_BOOLEANS) {
2118 STm->do_buffer_writes = (options & MT_ST_BUFFER_WRITES) != 0;
2119 STm->do_async_writes = (options & MT_ST_ASYNC_WRITES) != 0;
2120 STm->defaults_for_writes = (options & MT_ST_DEF_WRITES) != 0;
2121 STm->do_read_ahead = (options & MT_ST_READ_AHEAD) != 0;
2122 STp->two_fm = (options & MT_ST_TWO_FM) != 0;
2123 STp->fast_mteom = (options & MT_ST_FAST_MTEOM) != 0;
2124 STp->do_auto_lock = (options & MT_ST_AUTO_LOCK) != 0;
2125 STp->can_bsr = (options & MT_ST_CAN_BSR) != 0;
2126 STp->omit_blklims = (options & MT_ST_NO_BLKLIMS) != 0;
2127 if ((STp->device)->scsi_level >= SCSI_2)
2128 STp->can_partitions = (options & MT_ST_CAN_PARTITIONS) != 0;
2129 STp->scsi2_logical = (options & MT_ST_SCSI2LOGICAL) != 0;
2130 STp->immediate = (options & MT_ST_NOWAIT) != 0;
2131 STm->sysv = (options & MT_ST_SYSV) != 0;
2132 DEB( debugging = (options & MT_ST_DEBUGGING) != 0;
2133 st_log_options(STp, STm, name); )
2134 } else if (code == MT_ST_SETBOOLEANS || code == MT_ST_CLEARBOOLEANS) {
2135 value = (code == MT_ST_SETBOOLEANS);
2136 if ((options & MT_ST_BUFFER_WRITES) != 0)
2137 STm->do_buffer_writes = value;
2138 if ((options & MT_ST_ASYNC_WRITES) != 0)
2139 STm->do_async_writes = value;
2140 if ((options & MT_ST_DEF_WRITES) != 0)
2141 STm->defaults_for_writes = value;
2142 if ((options & MT_ST_READ_AHEAD) != 0)
2143 STm->do_read_ahead = value;
2144 if ((options & MT_ST_TWO_FM) != 0)
2145 STp->two_fm = value;
2146 if ((options & MT_ST_FAST_MTEOM) != 0)
2147 STp->fast_mteom = value;
2148 if ((options & MT_ST_AUTO_LOCK) != 0)
2149 STp->do_auto_lock = value;
2150 if ((options & MT_ST_CAN_BSR) != 0)
2151 STp->can_bsr = value;
2152 if ((options & MT_ST_NO_BLKLIMS) != 0)
2153 STp->omit_blklims = value;
2154 if ((STp->device)->scsi_level >= SCSI_2 &&
2155 (options & MT_ST_CAN_PARTITIONS) != 0)
2156 STp->can_partitions = value;
2157 if ((options & MT_ST_SCSI2LOGICAL) != 0)
2158 STp->scsi2_logical = value;
2159 if ((options & MT_ST_NOWAIT) != 0)
2160 STp->immediate = value;
2161 if ((options & MT_ST_SYSV) != 0)
2162 STm->sysv = value;
2163 DEB(
2164 if ((options & MT_ST_DEBUGGING) != 0)
2165 debugging = value;
2166 st_log_options(STp, STm, name); )
2167 } else if (code == MT_ST_WRITE_THRESHOLD) {
2168 /* Retained for compatibility */
2169 } else if (code == MT_ST_DEF_BLKSIZE) {
2170 value = (options & ~MT_ST_OPTIONS);
2171 if (value == ~MT_ST_OPTIONS) {
2172 STm->default_blksize = (-1);
2173 DEBC( printk(KERN_INFO "%s: Default block size disabled.\n", name));
2174 } else {
2175 STm->default_blksize = value;
2176 DEBC( printk(KERN_INFO "%s: Default block size set to %d bytes.\n",
2177 name, STm->default_blksize));
2178 if (STp->ready == ST_READY) {
2179 STp->blksize_changed = 0;
2180 set_mode_densblk(STp, STm);
2181 }
2182 }
2183 } else if (code == MT_ST_TIMEOUTS) {
2184 value = (options & ~MT_ST_OPTIONS);
2185 if ((value & MT_ST_SET_LONG_TIMEOUT) != 0) {
2186 STp->long_timeout = (value & ~MT_ST_SET_LONG_TIMEOUT) * HZ;
2187 DEBC( printk(KERN_INFO "%s: Long timeout set to %d seconds.\n", name,
2188 (value & ~MT_ST_SET_LONG_TIMEOUT)));
2189 } else {
2190 STp->device->timeout = value * HZ;
2191 DEBC( printk(KERN_INFO "%s: Normal timeout set to %d seconds.\n",
2192 name, value) );
2193 }
2194 } else if (code == MT_ST_SET_CLN) {
2195 value = (options & ~MT_ST_OPTIONS) & 0xff;
2196 if (value != 0 &&
2197 value < EXTENDED_SENSE_START && value >= SCSI_SENSE_BUFFERSIZE)
2198 return (-EINVAL);
2199 STp->cln_mode = value;
2200 STp->cln_sense_mask = (options >> 8) & 0xff;
2201 STp->cln_sense_value = (options >> 16) & 0xff;
2202 printk(KERN_INFO
2203 "%s: Cleaning request mode %d, mask %02x, value %02x\n",
2204 name, value, STp->cln_sense_mask, STp->cln_sense_value);
2205 } else if (code == MT_ST_DEF_OPTIONS) {
2206 code = (options & ~MT_ST_CLEAR_DEFAULT);
2207 value = (options & MT_ST_CLEAR_DEFAULT);
2208 if (code == MT_ST_DEF_DENSITY) {
2209 if (value == MT_ST_CLEAR_DEFAULT) {
2210 STm->default_density = (-1);
2211 DEBC( printk(KERN_INFO "%s: Density default disabled.\n",
2212 name));
2213 } else {
2214 STm->default_density = value & 0xff;
2215 DEBC( printk(KERN_INFO "%s: Density default set to %x\n",
2216 name, STm->default_density));
2217 if (STp->ready == ST_READY) {
2218 STp->density_changed = 0;
2219 set_mode_densblk(STp, STm);
2220 }
2221 }
2222 } else if (code == MT_ST_DEF_DRVBUFFER) {
2223 if (value == MT_ST_CLEAR_DEFAULT) {
2224 STp->default_drvbuffer = 0xff;
2225 DEBC( printk(KERN_INFO
2226 "%s: Drive buffer default disabled.\n", name));
2227 } else {
2228 STp->default_drvbuffer = value & 7;
2229 DEBC( printk(KERN_INFO
2230 "%s: Drive buffer default set to %x\n",
2231 name, STp->default_drvbuffer));
2232 if (STp->ready == ST_READY)
2233 st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer);
2234 }
2235 } else if (code == MT_ST_DEF_COMPRESSION) {
2236 if (value == MT_ST_CLEAR_DEFAULT) {
2237 STm->default_compression = ST_DONT_TOUCH;
2238 DEBC( printk(KERN_INFO
2239 "%s: Compression default disabled.\n", name));
2240 } else {
2241 if ((value & 0xff00) != 0) {
2242 STp->c_algo = (value & 0xff00) >> 8;
2243 DEBC( printk(KERN_INFO "%s: Compression algorithm set to 0x%x.\n",
2244 name, STp->c_algo));
2245 }
2246 if ((value & 0xff) != 0xff) {
2247 STm->default_compression = (value & 1 ? ST_YES : ST_NO);
2248 DEBC( printk(KERN_INFO "%s: Compression default set to %x\n",
2249 name, (value & 1)));
2250 if (STp->ready == ST_READY) {
2251 STp->compression_changed = 0;
2252 st_compression(STp, (STm->default_compression == ST_YES));
2253 }
2254 }
2255 }
2256 }
2257 } else
2258 return (-EIO);
2259
2260 return 0;
2261}
2262
2263#define MODE_HEADER_LENGTH 4
2264
2265/* Mode header and page byte offsets */
2266#define MH_OFF_DATA_LENGTH 0
2267#define MH_OFF_MEDIUM_TYPE 1
2268#define MH_OFF_DEV_SPECIFIC 2
2269#define MH_OFF_BDESCS_LENGTH 3
2270#define MP_OFF_PAGE_NBR 0
2271#define MP_OFF_PAGE_LENGTH 1
2272
2273/* Mode header and page bit masks */
2274#define MH_BIT_WP 0x80
2275#define MP_MSK_PAGE_NBR 0x3f
2276
2277/* Don't return block descriptors */
2278#define MODE_SENSE_OMIT_BDESCS 0x08
2279
2280#define MODE_SELECT_PAGE_FORMAT 0x10
2281
2282/* Read a mode page into the tape buffer. The block descriptors are included
2283 if incl_block_descs is true. The page control is ored to the page number
2284 parameter, if necessary. */
2285static int read_mode_page(struct scsi_tape *STp, int page, int omit_block_descs)
2286{
2287 unsigned char cmd[MAX_COMMAND_SIZE];
Mike Christie8b05b772005-11-08 04:06:44 -06002288 struct st_request *SRpnt = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002289
2290 memset(cmd, 0, MAX_COMMAND_SIZE);
2291 cmd[0] = MODE_SENSE;
2292 if (omit_block_descs)
2293 cmd[1] = MODE_SENSE_OMIT_BDESCS;
2294 cmd[2] = page;
2295 cmd[4] = 255;
2296
2297 SRpnt = st_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_FROM_DEVICE,
2298 STp->device->timeout, 0, 1);
2299 if (SRpnt == NULL)
2300 return (STp->buffer)->syscall_result;
2301
Mike Christie8b05b772005-11-08 04:06:44 -06002302 st_release_request(SRpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002303
2304 return (STp->buffer)->syscall_result;
2305}
2306
2307
2308/* Send the mode page in the tape buffer to the drive. Assumes that the mode data
2309 in the buffer is correctly formatted. The long timeout is used if slow is non-zero. */
2310static int write_mode_page(struct scsi_tape *STp, int page, int slow)
2311{
2312 int pgo;
2313 unsigned char cmd[MAX_COMMAND_SIZE];
Mike Christie8b05b772005-11-08 04:06:44 -06002314 struct st_request *SRpnt = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002315
2316 memset(cmd, 0, MAX_COMMAND_SIZE);
2317 cmd[0] = MODE_SELECT;
2318 cmd[1] = MODE_SELECT_PAGE_FORMAT;
2319 pgo = MODE_HEADER_LENGTH + (STp->buffer)->b_data[MH_OFF_BDESCS_LENGTH];
2320 cmd[4] = pgo + (STp->buffer)->b_data[pgo + MP_OFF_PAGE_LENGTH] + 2;
2321
2322 /* Clear reserved fields */
2323 (STp->buffer)->b_data[MH_OFF_DATA_LENGTH] = 0;
2324 (STp->buffer)->b_data[MH_OFF_MEDIUM_TYPE] = 0;
2325 (STp->buffer)->b_data[MH_OFF_DEV_SPECIFIC] &= ~MH_BIT_WP;
2326 (STp->buffer)->b_data[pgo + MP_OFF_PAGE_NBR] &= MP_MSK_PAGE_NBR;
2327
2328 SRpnt = st_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_TO_DEVICE,
2329 (slow ? STp->long_timeout : STp->device->timeout), 0, 1);
2330 if (SRpnt == NULL)
2331 return (STp->buffer)->syscall_result;
2332
Mike Christie8b05b772005-11-08 04:06:44 -06002333 st_release_request(SRpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002334
2335 return (STp->buffer)->syscall_result;
2336}
2337
2338
2339#define COMPRESSION_PAGE 0x0f
2340#define COMPRESSION_PAGE_LENGTH 16
2341
2342#define CP_OFF_DCE_DCC 2
2343#define CP_OFF_C_ALGO 7
2344
2345#define DCE_MASK 0x80
2346#define DCC_MASK 0x40
2347#define RED_MASK 0x60
2348
2349
2350/* Control the compression with mode page 15. Algorithm not changed if zero.
2351
2352 The block descriptors are read and written because Sony SDT-7000 does not
2353 work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>).
2354 Including block descriptors should not cause any harm to other drives. */
2355
2356static int st_compression(struct scsi_tape * STp, int state)
2357{
2358 int retval;
2359 int mpoffs; /* Offset to mode page start */
2360 unsigned char *b_data = (STp->buffer)->b_data;
2361 DEB( char *name = tape_name(STp); )
2362
2363 if (STp->ready != ST_READY)
2364 return (-EIO);
2365
2366 /* Read the current page contents */
2367 retval = read_mode_page(STp, COMPRESSION_PAGE, 0);
2368 if (retval) {
2369 DEBC(printk(ST_DEB_MSG "%s: Compression mode page not supported.\n",
2370 name));
2371 return (-EIO);
2372 }
2373
2374 mpoffs = MODE_HEADER_LENGTH + b_data[MH_OFF_BDESCS_LENGTH];
2375 DEBC(printk(ST_DEB_MSG "%s: Compression state is %d.\n", name,
2376 (b_data[mpoffs + CP_OFF_DCE_DCC] & DCE_MASK ? 1 : 0)));
2377
2378 /* Check if compression can be changed */
2379 if ((b_data[mpoffs + CP_OFF_DCE_DCC] & DCC_MASK) == 0) {
2380 DEBC(printk(ST_DEB_MSG "%s: Compression not supported.\n", name));
2381 return (-EIO);
2382 }
2383
2384 /* Do the change */
2385 if (state) {
2386 b_data[mpoffs + CP_OFF_DCE_DCC] |= DCE_MASK;
2387 if (STp->c_algo != 0)
2388 b_data[mpoffs + CP_OFF_C_ALGO] = STp->c_algo;
2389 }
2390 else {
2391 b_data[mpoffs + CP_OFF_DCE_DCC] &= ~DCE_MASK;
2392 if (STp->c_algo != 0)
2393 b_data[mpoffs + CP_OFF_C_ALGO] = 0; /* no compression */
2394 }
2395
2396 retval = write_mode_page(STp, COMPRESSION_PAGE, 0);
2397 if (retval) {
2398 DEBC(printk(ST_DEB_MSG "%s: Compression change failed.\n", name));
2399 return (-EIO);
2400 }
2401 DEBC(printk(ST_DEB_MSG "%s: Compression state changed to %d.\n",
2402 name, state));
2403
2404 STp->compression_changed = 1;
2405 return 0;
2406}
2407
2408
2409/* Process the load and unload commands (does unload if the load code is zero) */
2410static int do_load_unload(struct scsi_tape *STp, struct file *filp, int load_code)
2411{
2412 int retval = (-EIO), timeout;
2413 DEB( char *name = tape_name(STp); )
2414 unsigned char cmd[MAX_COMMAND_SIZE];
2415 struct st_partstat *STps;
Mike Christie8b05b772005-11-08 04:06:44 -06002416 struct st_request *SRpnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002417
2418 if (STp->ready != ST_READY && !load_code) {
2419 if (STp->ready == ST_NO_TAPE)
2420 return (-ENOMEDIUM);
2421 else
2422 return (-EIO);
2423 }
2424
2425 memset(cmd, 0, MAX_COMMAND_SIZE);
2426 cmd[0] = START_STOP;
2427 if (load_code)
2428 cmd[4] |= 1;
2429 /*
2430 * If arg >= 1 && arg <= 6 Enhanced load/unload in HP C1553A
2431 */
2432 if (load_code >= 1 + MT_ST_HPLOADER_OFFSET
2433 && load_code <= 6 + MT_ST_HPLOADER_OFFSET) {
2434 DEBC(printk(ST_DEB_MSG "%s: Enhanced %sload slot %2d.\n",
2435 name, (cmd[4]) ? "" : "un",
2436 load_code - MT_ST_HPLOADER_OFFSET));
2437 cmd[3] = load_code - MT_ST_HPLOADER_OFFSET; /* MediaID field of C1553A */
2438 }
2439 if (STp->immediate) {
2440 cmd[1] = 1; /* Don't wait for completion */
2441 timeout = STp->device->timeout;
2442 }
2443 else
2444 timeout = STp->long_timeout;
2445
2446 DEBC(
2447 if (!load_code)
2448 printk(ST_DEB_MSG "%s: Unloading tape.\n", name);
2449 else
2450 printk(ST_DEB_MSG "%s: Loading tape.\n", name);
2451 );
2452
2453 SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
2454 timeout, MAX_RETRIES, 1);
2455 if (!SRpnt)
2456 return (STp->buffer)->syscall_result;
2457
2458 retval = (STp->buffer)->syscall_result;
Mike Christie8b05b772005-11-08 04:06:44 -06002459 st_release_request(SRpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002460
2461 if (!retval) { /* SCSI command successful */
2462
2463 if (!load_code) {
2464 STp->rew_at_close = 0;
2465 STp->ready = ST_NO_TAPE;
2466 }
2467 else {
2468 STp->rew_at_close = STp->autorew_dev;
2469 retval = check_tape(STp, filp);
2470 if (retval > 0)
2471 retval = 0;
2472 }
2473 }
2474 else {
2475 STps = &(STp->ps[STp->partition]);
2476 STps->drv_file = STps->drv_block = (-1);
2477 }
2478
2479 return retval;
2480}
2481
2482#if DEBUG
2483#define ST_DEB_FORWARD 0
2484#define ST_DEB_BACKWARD 1
2485static void deb_space_print(char *name, int direction, char *units, unsigned char *cmd)
2486{
2487 s32 sc;
2488
2489 sc = cmd[2] & 0x80 ? 0xff000000 : 0;
2490 sc |= (cmd[2] << 16) | (cmd[3] << 8) | cmd[4];
2491 if (direction)
2492 sc = -sc;
2493 printk(ST_DEB_MSG "%s: Spacing tape %s over %d %s.\n", name,
2494 direction ? "backward" : "forward", sc, units);
2495}
2496#endif
2497
2498
2499/* Internal ioctl function */
2500static int st_int_ioctl(struct scsi_tape *STp, unsigned int cmd_in, unsigned long arg)
2501{
2502 int timeout;
2503 long ltmp;
2504 int ioctl_result;
2505 int chg_eof = 1;
2506 unsigned char cmd[MAX_COMMAND_SIZE];
Mike Christie8b05b772005-11-08 04:06:44 -06002507 struct st_request *SRpnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002508 struct st_partstat *STps;
2509 int fileno, blkno, at_sm, undone;
2510 int datalen = 0, direction = DMA_NONE;
2511 char *name = tape_name(STp);
2512
2513 WARN_ON(STp->buffer->do_dio != 0);
2514 if (STp->ready != ST_READY) {
2515 if (STp->ready == ST_NO_TAPE)
2516 return (-ENOMEDIUM);
2517 else
2518 return (-EIO);
2519 }
2520 timeout = STp->long_timeout;
2521 STps = &(STp->ps[STp->partition]);
2522 fileno = STps->drv_file;
2523 blkno = STps->drv_block;
2524 at_sm = STps->at_sm;
2525
2526 memset(cmd, 0, MAX_COMMAND_SIZE);
2527 switch (cmd_in) {
2528 case MTFSFM:
2529 chg_eof = 0; /* Changed from the FSF after this */
2530 case MTFSF:
2531 cmd[0] = SPACE;
2532 cmd[1] = 0x01; /* Space FileMarks */
2533 cmd[2] = (arg >> 16);
2534 cmd[3] = (arg >> 8);
2535 cmd[4] = arg;
2536 DEBC(deb_space_print(name, ST_DEB_FORWARD, "filemarks", cmd);)
2537 if (fileno >= 0)
2538 fileno += arg;
2539 blkno = 0;
2540 at_sm &= (arg == 0);
2541 break;
2542 case MTBSFM:
2543 chg_eof = 0; /* Changed from the FSF after this */
2544 case MTBSF:
2545 cmd[0] = SPACE;
2546 cmd[1] = 0x01; /* Space FileMarks */
2547 ltmp = (-arg);
2548 cmd[2] = (ltmp >> 16);
2549 cmd[3] = (ltmp >> 8);
2550 cmd[4] = ltmp;
2551 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "filemarks", cmd);)
2552 if (fileno >= 0)
2553 fileno -= arg;
2554 blkno = (-1); /* We can't know the block number */
2555 at_sm &= (arg == 0);
2556 break;
2557 case MTFSR:
2558 cmd[0] = SPACE;
2559 cmd[1] = 0x00; /* Space Blocks */
2560 cmd[2] = (arg >> 16);
2561 cmd[3] = (arg >> 8);
2562 cmd[4] = arg;
2563 DEBC(deb_space_print(name, ST_DEB_FORWARD, "blocks", cmd);)
2564 if (blkno >= 0)
2565 blkno += arg;
2566 at_sm &= (arg == 0);
2567 break;
2568 case MTBSR:
2569 cmd[0] = SPACE;
2570 cmd[1] = 0x00; /* Space Blocks */
2571 ltmp = (-arg);
2572 cmd[2] = (ltmp >> 16);
2573 cmd[3] = (ltmp >> 8);
2574 cmd[4] = ltmp;
2575 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "blocks", cmd);)
2576 if (blkno >= 0)
2577 blkno -= arg;
2578 at_sm &= (arg == 0);
2579 break;
2580 case MTFSS:
2581 cmd[0] = SPACE;
2582 cmd[1] = 0x04; /* Space Setmarks */
2583 cmd[2] = (arg >> 16);
2584 cmd[3] = (arg >> 8);
2585 cmd[4] = arg;
2586 DEBC(deb_space_print(name, ST_DEB_FORWARD, "setmarks", cmd);)
2587 if (arg != 0) {
2588 blkno = fileno = (-1);
2589 at_sm = 1;
2590 }
2591 break;
2592 case MTBSS:
2593 cmd[0] = SPACE;
2594 cmd[1] = 0x04; /* Space Setmarks */
2595 ltmp = (-arg);
2596 cmd[2] = (ltmp >> 16);
2597 cmd[3] = (ltmp >> 8);
2598 cmd[4] = ltmp;
2599 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "setmarks", cmd);)
2600 if (arg != 0) {
2601 blkno = fileno = (-1);
2602 at_sm = 1;
2603 }
2604 break;
2605 case MTWEOF:
2606 case MTWSM:
2607 if (STp->write_prot)
2608 return (-EACCES);
2609 cmd[0] = WRITE_FILEMARKS;
2610 if (cmd_in == MTWSM)
2611 cmd[1] = 2;
2612 cmd[2] = (arg >> 16);
2613 cmd[3] = (arg >> 8);
2614 cmd[4] = arg;
2615 timeout = STp->device->timeout;
2616 DEBC(
2617 if (cmd_in == MTWEOF)
2618 printk(ST_DEB_MSG "%s: Writing %d filemarks.\n", name,
2619 cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
2620 else
2621 printk(ST_DEB_MSG "%s: Writing %d setmarks.\n", name,
2622 cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
2623 )
2624 if (fileno >= 0)
2625 fileno += arg;
2626 blkno = 0;
2627 at_sm = (cmd_in == MTWSM);
2628 break;
2629 case MTREW:
2630 cmd[0] = REZERO_UNIT;
2631 if (STp->immediate) {
2632 cmd[1] = 1; /* Don't wait for completion */
2633 timeout = STp->device->timeout;
2634 }
2635 DEBC(printk(ST_DEB_MSG "%s: Rewinding tape.\n", name));
2636 fileno = blkno = at_sm = 0;
2637 break;
2638 case MTNOP:
2639 DEBC(printk(ST_DEB_MSG "%s: No op on tape.\n", name));
2640 return 0; /* Should do something ? */
2641 break;
2642 case MTRETEN:
2643 cmd[0] = START_STOP;
2644 if (STp->immediate) {
2645 cmd[1] = 1; /* Don't wait for completion */
2646 timeout = STp->device->timeout;
2647 }
2648 cmd[4] = 3;
2649 DEBC(printk(ST_DEB_MSG "%s: Retensioning tape.\n", name));
2650 fileno = blkno = at_sm = 0;
2651 break;
2652 case MTEOM:
2653 if (!STp->fast_mteom) {
2654 /* space to the end of tape */
2655 ioctl_result = st_int_ioctl(STp, MTFSF, 0x7fffff);
2656 fileno = STps->drv_file;
2657 if (STps->eof >= ST_EOD_1)
2658 return 0;
2659 /* The next lines would hide the number of spaced FileMarks
2660 That's why I inserted the previous lines. I had no luck
2661 with detecting EOM with FSF, so we go now to EOM.
2662 Joerg Weule */
2663 } else
2664 fileno = (-1);
2665 cmd[0] = SPACE;
2666 cmd[1] = 3;
2667 DEBC(printk(ST_DEB_MSG "%s: Spacing to end of recorded medium.\n",
2668 name));
2669 blkno = -1;
2670 at_sm = 0;
2671 break;
2672 case MTERASE:
2673 if (STp->write_prot)
2674 return (-EACCES);
2675 cmd[0] = ERASE;
2676 cmd[1] = (arg ? 1 : 0); /* Long erase with non-zero argument */
2677 if (STp->immediate) {
2678 cmd[1] |= 2; /* Don't wait for completion */
2679 timeout = STp->device->timeout;
2680 }
2681 else
2682 timeout = STp->long_timeout * 8;
2683
2684 DEBC(printk(ST_DEB_MSG "%s: Erasing tape.\n", name));
2685 fileno = blkno = at_sm = 0;
2686 break;
2687 case MTSETBLK: /* Set block length */
2688 case MTSETDENSITY: /* Set tape density */
2689 case MTSETDRVBUFFER: /* Set drive buffering */
2690 case SET_DENS_AND_BLK: /* Set density and block size */
2691 chg_eof = 0;
2692 if (STp->dirty || (STp->buffer)->buffer_bytes != 0)
2693 return (-EIO); /* Not allowed if data in buffer */
2694 if ((cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) &&
2695 (arg & MT_ST_BLKSIZE_MASK) != 0 &&
2696 STp->max_block > 0 &&
2697 ((arg & MT_ST_BLKSIZE_MASK) < STp->min_block ||
2698 (arg & MT_ST_BLKSIZE_MASK) > STp->max_block)) {
2699 printk(KERN_WARNING "%s: Illegal block size.\n", name);
2700 return (-EINVAL);
2701 }
2702 cmd[0] = MODE_SELECT;
2703 if ((STp->use_pf & USE_PF))
2704 cmd[1] = MODE_SELECT_PAGE_FORMAT;
2705 cmd[4] = datalen = 12;
2706 direction = DMA_TO_DEVICE;
2707
2708 memset((STp->buffer)->b_data, 0, 12);
2709 if (cmd_in == MTSETDRVBUFFER)
2710 (STp->buffer)->b_data[2] = (arg & 7) << 4;
2711 else
2712 (STp->buffer)->b_data[2] =
2713 STp->drv_buffer << 4;
2714 (STp->buffer)->b_data[3] = 8; /* block descriptor length */
2715 if (cmd_in == MTSETDENSITY) {
2716 (STp->buffer)->b_data[4] = arg;
2717 STp->density_changed = 1; /* At least we tried ;-) */
2718 } else if (cmd_in == SET_DENS_AND_BLK)
2719 (STp->buffer)->b_data[4] = arg >> 24;
2720 else
2721 (STp->buffer)->b_data[4] = STp->density;
2722 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) {
2723 ltmp = arg & MT_ST_BLKSIZE_MASK;
2724 if (cmd_in == MTSETBLK)
2725 STp->blksize_changed = 1; /* At least we tried ;-) */
2726 } else
2727 ltmp = STp->block_size;
2728 (STp->buffer)->b_data[9] = (ltmp >> 16);
2729 (STp->buffer)->b_data[10] = (ltmp >> 8);
2730 (STp->buffer)->b_data[11] = ltmp;
2731 timeout = STp->device->timeout;
2732 DEBC(
2733 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK)
2734 printk(ST_DEB_MSG
2735 "%s: Setting block size to %d bytes.\n", name,
2736 (STp->buffer)->b_data[9] * 65536 +
2737 (STp->buffer)->b_data[10] * 256 +
2738 (STp->buffer)->b_data[11]);
2739 if (cmd_in == MTSETDENSITY || cmd_in == SET_DENS_AND_BLK)
2740 printk(ST_DEB_MSG
2741 "%s: Setting density code to %x.\n", name,
2742 (STp->buffer)->b_data[4]);
2743 if (cmd_in == MTSETDRVBUFFER)
2744 printk(ST_DEB_MSG
2745 "%s: Setting drive buffer code to %d.\n", name,
2746 ((STp->buffer)->b_data[2] >> 4) & 7);
2747 )
2748 break;
2749 default:
2750 return (-ENOSYS);
2751 }
2752
2753 SRpnt = st_do_scsi(NULL, STp, cmd, datalen, direction,
2754 timeout, MAX_RETRIES, 1);
2755 if (!SRpnt)
2756 return (STp->buffer)->syscall_result;
2757
2758 ioctl_result = (STp->buffer)->syscall_result;
2759
2760 if (!ioctl_result) { /* SCSI command successful */
Mike Christie8b05b772005-11-08 04:06:44 -06002761 st_release_request(SRpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002762 SRpnt = NULL;
2763 STps->drv_block = blkno;
2764 STps->drv_file = fileno;
2765 STps->at_sm = at_sm;
2766
2767 if (cmd_in == MTBSFM)
2768 ioctl_result = st_int_ioctl(STp, MTFSF, 1);
2769 else if (cmd_in == MTFSFM)
2770 ioctl_result = st_int_ioctl(STp, MTBSF, 1);
2771
2772 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) {
2773 int old_block_size = STp->block_size;
2774 STp->block_size = arg & MT_ST_BLKSIZE_MASK;
2775 if (STp->block_size != 0) {
2776 if (old_block_size == 0)
2777 normalize_buffer(STp->buffer);
2778 (STp->buffer)->buffer_blocks =
2779 (STp->buffer)->buffer_size / STp->block_size;
2780 }
2781 (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0;
2782 if (cmd_in == SET_DENS_AND_BLK)
2783 STp->density = arg >> MT_ST_DENSITY_SHIFT;
2784 } else if (cmd_in == MTSETDRVBUFFER)
2785 STp->drv_buffer = (arg & 7);
2786 else if (cmd_in == MTSETDENSITY)
2787 STp->density = arg;
2788
2789 if (cmd_in == MTEOM)
2790 STps->eof = ST_EOD;
2791 else if (cmd_in == MTFSF)
2792 STps->eof = ST_FM;
2793 else if (chg_eof)
2794 STps->eof = ST_NOEOF;
2795
2796 if (cmd_in == MTWEOF)
2797 STps->rw = ST_IDLE;
2798 } else { /* SCSI command was not completely successful. Don't return
2799 from this block without releasing the SCSI command block! */
2800 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
2801
2802 if (cmdstatp->flags & SENSE_EOM) {
2803 if (cmd_in != MTBSF && cmd_in != MTBSFM &&
2804 cmd_in != MTBSR && cmd_in != MTBSS)
2805 STps->eof = ST_EOM_OK;
2806 STps->drv_block = 0;
2807 }
2808
2809 if (cmdstatp->remainder_valid)
2810 undone = (int)cmdstatp->uremainder64;
2811 else
2812 undone = 0;
2813
2814 if (cmd_in == MTWEOF &&
2815 cmdstatp->have_sense &&
2816 (cmdstatp->flags & SENSE_EOM) &&
2817 (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
2818 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) &&
2819 undone == 0) {
Andreas Mohrd6e05ed2006-06-26 18:35:02 +02002820 ioctl_result = 0; /* EOF written successfully at EOM */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002821 if (fileno >= 0)
2822 fileno++;
2823 STps->drv_file = fileno;
2824 STps->eof = ST_NOEOF;
2825 } else if ((cmd_in == MTFSF) || (cmd_in == MTFSFM)) {
2826 if (fileno >= 0)
2827 STps->drv_file = fileno - undone;
2828 else
2829 STps->drv_file = fileno;
2830 STps->drv_block = -1;
2831 STps->eof = ST_NOEOF;
2832 } else if ((cmd_in == MTBSF) || (cmd_in == MTBSFM)) {
2833 if (arg > 0 && undone < 0) /* Some drives get this wrong */
2834 undone = (-undone);
2835 if (STps->drv_file >= 0)
2836 STps->drv_file = fileno + undone;
2837 STps->drv_block = 0;
2838 STps->eof = ST_NOEOF;
2839 } else if (cmd_in == MTFSR) {
2840 if (cmdstatp->flags & SENSE_FMK) { /* Hit filemark */
2841 if (STps->drv_file >= 0)
2842 STps->drv_file++;
2843 STps->drv_block = 0;
2844 STps->eof = ST_FM;
2845 } else {
2846 if (blkno >= undone)
2847 STps->drv_block = blkno - undone;
2848 else
2849 STps->drv_block = (-1);
2850 STps->eof = ST_NOEOF;
2851 }
2852 } else if (cmd_in == MTBSR) {
2853 if (cmdstatp->flags & SENSE_FMK) { /* Hit filemark */
2854 STps->drv_file--;
2855 STps->drv_block = (-1);
2856 } else {
2857 if (arg > 0 && undone < 0) /* Some drives get this wrong */
2858 undone = (-undone);
2859 if (STps->drv_block >= 0)
2860 STps->drv_block = blkno + undone;
2861 }
2862 STps->eof = ST_NOEOF;
2863 } else if (cmd_in == MTEOM) {
2864 STps->drv_file = (-1);
2865 STps->drv_block = (-1);
2866 STps->eof = ST_EOD;
2867 } else if (cmd_in == MTSETBLK ||
2868 cmd_in == MTSETDENSITY ||
2869 cmd_in == MTSETDRVBUFFER ||
2870 cmd_in == SET_DENS_AND_BLK) {
2871 if (cmdstatp->sense_hdr.sense_key == ILLEGAL_REQUEST &&
2872 !(STp->use_pf & PF_TESTED)) {
2873 /* Try the other possible state of Page Format if not
2874 already tried */
2875 STp->use_pf = !STp->use_pf | PF_TESTED;
Mike Christie8b05b772005-11-08 04:06:44 -06002876 st_release_request(SRpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002877 SRpnt = NULL;
2878 return st_int_ioctl(STp, cmd_in, arg);
2879 }
2880 } else if (chg_eof)
2881 STps->eof = ST_NOEOF;
2882
2883 if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK)
2884 STps->eof = ST_EOD;
2885
Mike Christie8b05b772005-11-08 04:06:44 -06002886 st_release_request(SRpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002887 SRpnt = NULL;
2888 }
2889
2890 return ioctl_result;
2891}
2892
2893
2894/* Get the tape position. If bt == 2, arg points into a kernel space mt_loc
2895 structure. */
2896
2897static int get_location(struct scsi_tape *STp, unsigned int *block, int *partition,
2898 int logical)
2899{
2900 int result;
2901 unsigned char scmd[MAX_COMMAND_SIZE];
Mike Christie8b05b772005-11-08 04:06:44 -06002902 struct st_request *SRpnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002903 DEB( char *name = tape_name(STp); )
2904
2905 if (STp->ready != ST_READY)
2906 return (-EIO);
2907
2908 memset(scmd, 0, MAX_COMMAND_SIZE);
2909 if ((STp->device)->scsi_level < SCSI_2) {
2910 scmd[0] = QFA_REQUEST_BLOCK;
2911 scmd[4] = 3;
2912 } else {
2913 scmd[0] = READ_POSITION;
2914 if (!logical && !STp->scsi2_logical)
2915 scmd[1] = 1;
2916 }
2917 SRpnt = st_do_scsi(NULL, STp, scmd, 20, DMA_FROM_DEVICE,
2918 STp->device->timeout, MAX_READY_RETRIES, 1);
2919 if (!SRpnt)
2920 return (STp->buffer)->syscall_result;
2921
2922 if ((STp->buffer)->syscall_result != 0 ||
2923 (STp->device->scsi_level >= SCSI_2 &&
2924 ((STp->buffer)->b_data[0] & 4) != 0)) {
2925 *block = *partition = 0;
2926 DEBC(printk(ST_DEB_MSG "%s: Can't read tape position.\n", name));
2927 result = (-EIO);
2928 } else {
2929 result = 0;
2930 if ((STp->device)->scsi_level < SCSI_2) {
2931 *block = ((STp->buffer)->b_data[0] << 16)
2932 + ((STp->buffer)->b_data[1] << 8)
2933 + (STp->buffer)->b_data[2];
2934 *partition = 0;
2935 } else {
2936 *block = ((STp->buffer)->b_data[4] << 24)
2937 + ((STp->buffer)->b_data[5] << 16)
2938 + ((STp->buffer)->b_data[6] << 8)
2939 + (STp->buffer)->b_data[7];
2940 *partition = (STp->buffer)->b_data[1];
2941 if (((STp->buffer)->b_data[0] & 0x80) &&
2942 (STp->buffer)->b_data[1] == 0) /* BOP of partition 0 */
2943 STp->ps[0].drv_block = STp->ps[0].drv_file = 0;
2944 }
2945 DEBC(printk(ST_DEB_MSG "%s: Got tape pos. blk %d part %d.\n", name,
2946 *block, *partition));
2947 }
Mike Christie8b05b772005-11-08 04:06:44 -06002948 st_release_request(SRpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002949 SRpnt = NULL;
2950
2951 return result;
2952}
2953
2954
2955/* Set the tape block and partition. Negative partition means that only the
2956 block should be set in vendor specific way. */
2957static int set_location(struct scsi_tape *STp, unsigned int block, int partition,
2958 int logical)
2959{
2960 struct st_partstat *STps;
2961 int result, p;
2962 unsigned int blk;
2963 int timeout;
2964 unsigned char scmd[MAX_COMMAND_SIZE];
Mike Christie8b05b772005-11-08 04:06:44 -06002965 struct st_request *SRpnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002966 DEB( char *name = tape_name(STp); )
2967
2968 if (STp->ready != ST_READY)
2969 return (-EIO);
2970 timeout = STp->long_timeout;
2971 STps = &(STp->ps[STp->partition]);
2972
2973 DEBC(printk(ST_DEB_MSG "%s: Setting block to %d and partition to %d.\n",
2974 name, block, partition));
2975 DEB(if (partition < 0)
2976 return (-EIO); )
2977
2978 /* Update the location at the partition we are leaving */
2979 if ((!STp->can_partitions && partition != 0) ||
2980 partition >= ST_NBR_PARTITIONS)
2981 return (-EINVAL);
2982 if (partition != STp->partition) {
2983 if (get_location(STp, &blk, &p, 1))
2984 STps->last_block_valid = 0;
2985 else {
2986 STps->last_block_valid = 1;
2987 STps->last_block_visited = blk;
2988 DEBC(printk(ST_DEB_MSG
2989 "%s: Visited block %d for partition %d saved.\n",
2990 name, blk, STp->partition));
2991 }
2992 }
2993
2994 memset(scmd, 0, MAX_COMMAND_SIZE);
2995 if ((STp->device)->scsi_level < SCSI_2) {
2996 scmd[0] = QFA_SEEK_BLOCK;
2997 scmd[2] = (block >> 16);
2998 scmd[3] = (block >> 8);
2999 scmd[4] = block;
3000 scmd[5] = 0;
3001 } else {
3002 scmd[0] = SEEK_10;
3003 scmd[3] = (block >> 24);
3004 scmd[4] = (block >> 16);
3005 scmd[5] = (block >> 8);
3006 scmd[6] = block;
3007 if (!logical && !STp->scsi2_logical)
3008 scmd[1] = 4;
3009 if (STp->partition != partition) {
3010 scmd[1] |= 2;
3011 scmd[8] = partition;
3012 DEBC(printk(ST_DEB_MSG
3013 "%s: Trying to change partition from %d to %d\n",
3014 name, STp->partition, partition));
3015 }
3016 }
3017 if (STp->immediate) {
3018 scmd[1] |= 1; /* Don't wait for completion */
3019 timeout = STp->device->timeout;
3020 }
3021
3022 SRpnt = st_do_scsi(NULL, STp, scmd, 0, DMA_NONE,
3023 timeout, MAX_READY_RETRIES, 1);
3024 if (!SRpnt)
3025 return (STp->buffer)->syscall_result;
3026
3027 STps->drv_block = STps->drv_file = (-1);
3028 STps->eof = ST_NOEOF;
3029 if ((STp->buffer)->syscall_result != 0) {
3030 result = (-EIO);
3031 if (STp->can_partitions &&
3032 (STp->device)->scsi_level >= SCSI_2 &&
3033 (p = find_partition(STp)) >= 0)
3034 STp->partition = p;
3035 } else {
3036 if (STp->can_partitions) {
3037 STp->partition = partition;
3038 STps = &(STp->ps[partition]);
3039 if (!STps->last_block_valid ||
3040 STps->last_block_visited != block) {
3041 STps->at_sm = 0;
3042 STps->rw = ST_IDLE;
3043 }
3044 } else
3045 STps->at_sm = 0;
3046 if (block == 0)
3047 STps->drv_block = STps->drv_file = 0;
3048 result = 0;
3049 }
3050
Mike Christie8b05b772005-11-08 04:06:44 -06003051 st_release_request(SRpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003052 SRpnt = NULL;
3053
3054 return result;
3055}
3056
3057
3058/* Find the current partition number for the drive status. Called from open and
3059 returns either partition number of negative error code. */
3060static int find_partition(struct scsi_tape *STp)
3061{
3062 int i, partition;
3063 unsigned int block;
3064
3065 if ((i = get_location(STp, &block, &partition, 1)) < 0)
3066 return i;
3067 if (partition >= ST_NBR_PARTITIONS)
3068 return (-EIO);
3069 return partition;
3070}
3071
3072
3073/* Change the partition if necessary */
3074static int switch_partition(struct scsi_tape *STp)
3075{
3076 struct st_partstat *STps;
3077
3078 if (STp->partition == STp->new_partition)
3079 return 0;
3080 STps = &(STp->ps[STp->new_partition]);
3081 if (!STps->last_block_valid)
3082 STps->last_block_visited = 0;
3083 return set_location(STp, STps->last_block_visited, STp->new_partition, 1);
3084}
3085
3086/* Functions for reading and writing the medium partition mode page. */
3087
3088#define PART_PAGE 0x11
3089#define PART_PAGE_FIXED_LENGTH 8
3090
3091#define PP_OFF_MAX_ADD_PARTS 2
3092#define PP_OFF_NBR_ADD_PARTS 3
3093#define PP_OFF_FLAGS 4
3094#define PP_OFF_PART_UNITS 6
3095#define PP_OFF_RESERVED 7
3096
3097#define PP_BIT_IDP 0x20
3098#define PP_MSK_PSUM_MB 0x10
3099
3100/* Get the number of partitions on the tape. As a side effect reads the
3101 mode page into the tape buffer. */
3102static int nbr_partitions(struct scsi_tape *STp)
3103{
3104 int result;
3105 DEB( char *name = tape_name(STp); )
3106
3107 if (STp->ready != ST_READY)
3108 return (-EIO);
3109
3110 result = read_mode_page(STp, PART_PAGE, 1);
3111
3112 if (result) {
3113 DEBC(printk(ST_DEB_MSG "%s: Can't read medium partition page.\n",
3114 name));
3115 result = (-EIO);
3116 } else {
3117 result = (STp->buffer)->b_data[MODE_HEADER_LENGTH +
3118 PP_OFF_NBR_ADD_PARTS] + 1;
3119 DEBC(printk(ST_DEB_MSG "%s: Number of partitions %d.\n", name, result));
3120 }
3121
3122 return result;
3123}
3124
3125
3126/* Partition the tape into two partitions if size > 0 or one partition if
3127 size == 0.
3128
3129 The block descriptors are read and written because Sony SDT-7000 does not
3130 work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>).
3131
3132 My HP C1533A drive returns only one partition size field. This is used to
3133 set the size of partition 1. There is no size field for the default partition.
3134 Michael Schaefer's Sony SDT-7000 returns two descriptors and the second is
3135 used to set the size of partition 1 (this is what the SCSI-3 standard specifies).
3136 The following algorithm is used to accommodate both drives: if the number of
3137 partition size fields is greater than the maximum number of additional partitions
3138 in the mode page, the second field is used. Otherwise the first field is used.
3139
3140 For Seagate DDS drives the page length must be 8 when no partitions is defined
3141 and 10 when 1 partition is defined (information from Eric Lee Green). This is
3142 is acceptable also to some other old drives and enforced if the first partition
3143 size field is used for the first additional partition size.
3144 */
3145static int partition_tape(struct scsi_tape *STp, int size)
3146{
3147 char *name = tape_name(STp);
3148 int result;
3149 int pgo, psd_cnt, psdo;
3150 unsigned char *bp;
3151
3152 result = read_mode_page(STp, PART_PAGE, 0);
3153 if (result) {
3154 DEBC(printk(ST_DEB_MSG "%s: Can't read partition mode page.\n", name));
3155 return result;
3156 }
3157 /* The mode page is in the buffer. Let's modify it and write it. */
3158 bp = (STp->buffer)->b_data;
3159 pgo = MODE_HEADER_LENGTH + bp[MH_OFF_BDESCS_LENGTH];
3160 DEBC(printk(ST_DEB_MSG "%s: Partition page length is %d bytes.\n",
3161 name, bp[pgo + MP_OFF_PAGE_LENGTH] + 2));
3162
3163 psd_cnt = (bp[pgo + MP_OFF_PAGE_LENGTH] + 2 - PART_PAGE_FIXED_LENGTH) / 2;
3164 psdo = pgo + PART_PAGE_FIXED_LENGTH;
3165 if (psd_cnt > bp[pgo + PP_OFF_MAX_ADD_PARTS]) {
3166 bp[psdo] = bp[psdo + 1] = 0xff; /* Rest of the tape */
3167 psdo += 2;
3168 }
3169 memset(bp + psdo, 0, bp[pgo + PP_OFF_NBR_ADD_PARTS] * 2);
3170
3171 DEBC(printk("%s: psd_cnt %d, max.parts %d, nbr_parts %d\n", name,
3172 psd_cnt, bp[pgo + PP_OFF_MAX_ADD_PARTS],
3173 bp[pgo + PP_OFF_NBR_ADD_PARTS]));
3174
3175 if (size <= 0) {
3176 bp[pgo + PP_OFF_NBR_ADD_PARTS] = 0;
3177 if (psd_cnt <= bp[pgo + PP_OFF_MAX_ADD_PARTS])
3178 bp[pgo + MP_OFF_PAGE_LENGTH] = 6;
3179 DEBC(printk(ST_DEB_MSG "%s: Formatting tape with one partition.\n",
3180 name));
3181 } else {
3182 bp[psdo] = (size >> 8) & 0xff;
3183 bp[psdo + 1] = size & 0xff;
3184 bp[pgo + 3] = 1;
3185 if (bp[pgo + MP_OFF_PAGE_LENGTH] < 8)
3186 bp[pgo + MP_OFF_PAGE_LENGTH] = 8;
3187 DEBC(printk(ST_DEB_MSG
3188 "%s: Formatting tape with two partitions (1 = %d MB).\n",
3189 name, size));
3190 }
3191 bp[pgo + PP_OFF_PART_UNITS] = 0;
3192 bp[pgo + PP_OFF_RESERVED] = 0;
3193 bp[pgo + PP_OFF_FLAGS] = PP_BIT_IDP | PP_MSK_PSUM_MB;
3194
3195 result = write_mode_page(STp, PART_PAGE, 1);
3196 if (result) {
3197 printk(KERN_INFO "%s: Partitioning of tape failed.\n", name);
3198 result = (-EIO);
3199 }
3200
3201 return result;
3202}
3203
3204
3205
3206/* The ioctl command */
3207static int st_ioctl(struct inode *inode, struct file *file,
3208 unsigned int cmd_in, unsigned long arg)
3209{
3210 int i, cmd_nr, cmd_type, bt;
3211 int retval = 0;
3212 unsigned int blk;
3213 struct scsi_tape *STp = file->private_data;
3214 struct st_modedef *STm;
3215 struct st_partstat *STps;
3216 char *name = tape_name(STp);
3217 void __user *p = (void __user *)arg;
3218
3219 if (down_interruptible(&STp->lock))
3220 return -ERESTARTSYS;
3221
3222 DEB(
3223 if (debugging && !STp->in_use) {
3224 printk(ST_DEB_MSG "%s: Incorrect device.\n", name);
3225 retval = (-EIO);
3226 goto out;
3227 } ) /* end DEB */
3228
3229 STm = &(STp->modes[STp->current_mode]);
3230 STps = &(STp->ps[STp->partition]);
3231
3232 /*
3233 * If we are in the middle of error recovery, don't let anyone
3234 * else try and use this device. Also, if error recovery fails, it
3235 * may try and take the device offline, in which case all further
3236 * access to the device is prohibited.
3237 */
3238 retval = scsi_nonblockable_ioctl(STp->device, cmd_in, p, file);
3239 if (!scsi_block_when_processing_errors(STp->device) || retval != -ENODEV)
3240 goto out;
3241 retval = 0;
3242
3243 cmd_type = _IOC_TYPE(cmd_in);
3244 cmd_nr = _IOC_NR(cmd_in);
3245
3246 if (cmd_type == _IOC_TYPE(MTIOCTOP) && cmd_nr == _IOC_NR(MTIOCTOP)) {
3247 struct mtop mtc;
3248
3249 if (_IOC_SIZE(cmd_in) != sizeof(mtc)) {
3250 retval = (-EINVAL);
3251 goto out;
3252 }
3253
3254 i = copy_from_user(&mtc, p, sizeof(struct mtop));
3255 if (i) {
3256 retval = (-EFAULT);
3257 goto out;
3258 }
3259
3260 if (mtc.mt_op == MTSETDRVBUFFER && !capable(CAP_SYS_ADMIN)) {
3261 printk(KERN_WARNING
3262 "%s: MTSETDRVBUFFER only allowed for root.\n", name);
3263 retval = (-EPERM);
3264 goto out;
3265 }
3266 if (!STm->defined &&
3267 (mtc.mt_op != MTSETDRVBUFFER &&
3268 (mtc.mt_count & MT_ST_OPTIONS) == 0)) {
3269 retval = (-ENXIO);
3270 goto out;
3271 }
3272
3273 if (!STp->pos_unknown) {
3274
3275 if (STps->eof == ST_FM_HIT) {
3276 if (mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM ||
3277 mtc.mt_op == MTEOM) {
3278 mtc.mt_count -= 1;
3279 if (STps->drv_file >= 0)
3280 STps->drv_file += 1;
3281 } else if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM) {
3282 mtc.mt_count += 1;
3283 if (STps->drv_file >= 0)
3284 STps->drv_file += 1;
3285 }
3286 }
3287
3288 if (mtc.mt_op == MTSEEK) {
3289 /* Old position must be restored if partition will be
3290 changed */
3291 i = !STp->can_partitions ||
3292 (STp->new_partition != STp->partition);
3293 } else {
3294 i = mtc.mt_op == MTREW || mtc.mt_op == MTOFFL ||
3295 mtc.mt_op == MTRETEN || mtc.mt_op == MTEOM ||
3296 mtc.mt_op == MTLOCK || mtc.mt_op == MTLOAD ||
3297 mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM ||
3298 mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM ||
3299 mtc.mt_op == MTCOMPRESSION;
3300 }
3301 i = flush_buffer(STp, i);
3302 if (i < 0) {
3303 retval = i;
3304 goto out;
3305 }
3306 if (STps->rw == ST_WRITING &&
3307 (mtc.mt_op == MTREW || mtc.mt_op == MTOFFL ||
3308 mtc.mt_op == MTSEEK ||
3309 mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM)) {
3310 i = st_int_ioctl(STp, MTWEOF, 1);
3311 if (i < 0) {
3312 retval = i;
3313 goto out;
3314 }
3315 if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM)
3316 mtc.mt_count++;
3317 STps->rw = ST_IDLE;
3318 }
3319
3320 } else {
3321 /*
3322 * If there was a bus reset, block further access
3323 * to this device. If the user wants to rewind the tape,
3324 * then reset the flag and allow access again.
3325 */
3326 if (mtc.mt_op != MTREW &&
3327 mtc.mt_op != MTOFFL &&
3328 mtc.mt_op != MTRETEN &&
3329 mtc.mt_op != MTERASE &&
3330 mtc.mt_op != MTSEEK &&
3331 mtc.mt_op != MTEOM) {
3332 retval = (-EIO);
3333 goto out;
3334 }
3335 reset_state(STp);
3336 /* remove this when the midlevel properly clears was_reset */
3337 STp->device->was_reset = 0;
3338 }
3339
3340 if (mtc.mt_op != MTNOP && mtc.mt_op != MTSETBLK &&
3341 mtc.mt_op != MTSETDENSITY && mtc.mt_op != MTWSM &&
3342 mtc.mt_op != MTSETDRVBUFFER && mtc.mt_op != MTSETPART)
3343 STps->rw = ST_IDLE; /* Prevent automatic WEOF and fsf */
3344
3345 if (mtc.mt_op == MTOFFL && STp->door_locked != ST_UNLOCKED)
3346 do_door_lock(STp, 0); /* Ignore result! */
3347
3348 if (mtc.mt_op == MTSETDRVBUFFER &&
3349 (mtc.mt_count & MT_ST_OPTIONS) != 0) {
3350 retval = st_set_options(STp, mtc.mt_count);
3351 goto out;
3352 }
3353
3354 if (mtc.mt_op == MTSETPART) {
3355 if (!STp->can_partitions ||
3356 mtc.mt_count < 0 || mtc.mt_count >= ST_NBR_PARTITIONS) {
3357 retval = (-EINVAL);
3358 goto out;
3359 }
3360 if (mtc.mt_count >= STp->nbr_partitions &&
3361 (STp->nbr_partitions = nbr_partitions(STp)) < 0) {
3362 retval = (-EIO);
3363 goto out;
3364 }
3365 if (mtc.mt_count >= STp->nbr_partitions) {
3366 retval = (-EINVAL);
3367 goto out;
3368 }
3369 STp->new_partition = mtc.mt_count;
3370 retval = 0;
3371 goto out;
3372 }
3373
3374 if (mtc.mt_op == MTMKPART) {
3375 if (!STp->can_partitions) {
3376 retval = (-EINVAL);
3377 goto out;
3378 }
3379 if ((i = st_int_ioctl(STp, MTREW, 0)) < 0 ||
3380 (i = partition_tape(STp, mtc.mt_count)) < 0) {
3381 retval = i;
3382 goto out;
3383 }
3384 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
3385 STp->ps[i].rw = ST_IDLE;
3386 STp->ps[i].at_sm = 0;
3387 STp->ps[i].last_block_valid = 0;
3388 }
3389 STp->partition = STp->new_partition = 0;
3390 STp->nbr_partitions = 1; /* Bad guess ?-) */
3391 STps->drv_block = STps->drv_file = 0;
3392 retval = 0;
3393 goto out;
3394 }
3395
3396 if (mtc.mt_op == MTSEEK) {
3397 i = set_location(STp, mtc.mt_count, STp->new_partition, 0);
3398 if (!STp->can_partitions)
3399 STp->ps[0].rw = ST_IDLE;
3400 retval = i;
3401 goto out;
3402 }
3403
3404 if (mtc.mt_op == MTUNLOAD || mtc.mt_op == MTOFFL) {
3405 retval = do_load_unload(STp, file, 0);
3406 goto out;
3407 }
3408
3409 if (mtc.mt_op == MTLOAD) {
3410 retval = do_load_unload(STp, file, max(1, mtc.mt_count));
3411 goto out;
3412 }
3413
3414 if (mtc.mt_op == MTLOCK || mtc.mt_op == MTUNLOCK) {
3415 retval = do_door_lock(STp, (mtc.mt_op == MTLOCK));
3416 goto out;
3417 }
3418
3419 if (STp->can_partitions && STp->ready == ST_READY &&
3420 (i = switch_partition(STp)) < 0) {
3421 retval = i;
3422 goto out;
3423 }
3424
3425 if (mtc.mt_op == MTCOMPRESSION)
3426 retval = st_compression(STp, (mtc.mt_count & 1));
3427 else
3428 retval = st_int_ioctl(STp, mtc.mt_op, mtc.mt_count);
3429 goto out;
3430 }
3431 if (!STm->defined) {
3432 retval = (-ENXIO);
3433 goto out;
3434 }
3435
3436 if ((i = flush_buffer(STp, 0)) < 0) {
3437 retval = i;
3438 goto out;
3439 }
3440 if (STp->can_partitions &&
3441 (i = switch_partition(STp)) < 0) {
3442 retval = i;
3443 goto out;
3444 }
3445
3446 if (cmd_type == _IOC_TYPE(MTIOCGET) && cmd_nr == _IOC_NR(MTIOCGET)) {
3447 struct mtget mt_status;
3448
3449 if (_IOC_SIZE(cmd_in) != sizeof(struct mtget)) {
3450 retval = (-EINVAL);
3451 goto out;
3452 }
3453
3454 mt_status.mt_type = STp->tape_type;
3455 mt_status.mt_dsreg =
3456 ((STp->block_size << MT_ST_BLKSIZE_SHIFT) & MT_ST_BLKSIZE_MASK) |
3457 ((STp->density << MT_ST_DENSITY_SHIFT) & MT_ST_DENSITY_MASK);
3458 mt_status.mt_blkno = STps->drv_block;
3459 mt_status.mt_fileno = STps->drv_file;
3460 if (STp->block_size != 0) {
3461 if (STps->rw == ST_WRITING)
3462 mt_status.mt_blkno +=
3463 (STp->buffer)->buffer_bytes / STp->block_size;
3464 else if (STps->rw == ST_READING)
3465 mt_status.mt_blkno -=
3466 ((STp->buffer)->buffer_bytes +
3467 STp->block_size - 1) / STp->block_size;
3468 }
3469
3470 mt_status.mt_gstat = 0;
3471 if (STp->drv_write_prot)
3472 mt_status.mt_gstat |= GMT_WR_PROT(0xffffffff);
3473 if (mt_status.mt_blkno == 0) {
3474 if (mt_status.mt_fileno == 0)
3475 mt_status.mt_gstat |= GMT_BOT(0xffffffff);
3476 else
3477 mt_status.mt_gstat |= GMT_EOF(0xffffffff);
3478 }
3479 mt_status.mt_erreg = (STp->recover_reg << MT_ST_SOFTERR_SHIFT);
3480 mt_status.mt_resid = STp->partition;
3481 if (STps->eof == ST_EOM_OK || STps->eof == ST_EOM_ERROR)
3482 mt_status.mt_gstat |= GMT_EOT(0xffffffff);
3483 else if (STps->eof >= ST_EOM_OK)
3484 mt_status.mt_gstat |= GMT_EOD(0xffffffff);
3485 if (STp->density == 1)
3486 mt_status.mt_gstat |= GMT_D_800(0xffffffff);
3487 else if (STp->density == 2)
3488 mt_status.mt_gstat |= GMT_D_1600(0xffffffff);
3489 else if (STp->density == 3)
3490 mt_status.mt_gstat |= GMT_D_6250(0xffffffff);
3491 if (STp->ready == ST_READY)
3492 mt_status.mt_gstat |= GMT_ONLINE(0xffffffff);
3493 if (STp->ready == ST_NO_TAPE)
3494 mt_status.mt_gstat |= GMT_DR_OPEN(0xffffffff);
3495 if (STps->at_sm)
3496 mt_status.mt_gstat |= GMT_SM(0xffffffff);
3497 if (STm->do_async_writes ||
3498 (STm->do_buffer_writes && STp->block_size != 0) ||
3499 STp->drv_buffer != 0)
3500 mt_status.mt_gstat |= GMT_IM_REP_EN(0xffffffff);
3501 if (STp->cleaning_req)
3502 mt_status.mt_gstat |= GMT_CLN(0xffffffff);
3503
3504 i = copy_to_user(p, &mt_status, sizeof(struct mtget));
3505 if (i) {
3506 retval = (-EFAULT);
3507 goto out;
3508 }
3509
3510 STp->recover_reg = 0; /* Clear after read */
3511 retval = 0;
3512 goto out;
3513 } /* End of MTIOCGET */
3514 if (cmd_type == _IOC_TYPE(MTIOCPOS) && cmd_nr == _IOC_NR(MTIOCPOS)) {
3515 struct mtpos mt_pos;
3516 if (_IOC_SIZE(cmd_in) != sizeof(struct mtpos)) {
3517 retval = (-EINVAL);
3518 goto out;
3519 }
3520 if ((i = get_location(STp, &blk, &bt, 0)) < 0) {
3521 retval = i;
3522 goto out;
3523 }
3524 mt_pos.mt_blkno = blk;
3525 i = copy_to_user(p, &mt_pos, sizeof(struct mtpos));
3526 if (i)
3527 retval = (-EFAULT);
3528 goto out;
3529 }
3530 up(&STp->lock);
3531 switch (cmd_in) {
3532 case SCSI_IOCTL_GET_IDLUN:
3533 case SCSI_IOCTL_GET_BUS_NUMBER:
3534 break;
3535 default:
Kai Makisara 16c4b3e2005-05-01 18:11:55 +03003536 if ((cmd_in == SG_IO ||
3537 cmd_in == SCSI_IOCTL_SEND_COMMAND ||
3538 cmd_in == CDROM_SEND_PACKET) &&
3539 !capable(CAP_SYS_RAWIO))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003540 i = -EPERM;
3541 else
3542 i = scsi_cmd_ioctl(file, STp->disk, cmd_in, p);
3543 if (i != -ENOTTY)
3544 return i;
3545 break;
3546 }
Kai Makisara 16c4b3e2005-05-01 18:11:55 +03003547 retval = scsi_ioctl(STp->device, cmd_in, p);
3548 if (!retval && cmd_in == SCSI_IOCTL_STOP_UNIT) { /* unload */
3549 STp->rew_at_close = 0;
3550 STp->ready = ST_NO_TAPE;
3551 }
3552 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003553
3554 out:
3555 up(&STp->lock);
3556 return retval;
3557}
3558
3559#ifdef CONFIG_COMPAT
3560static long st_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
3561{
3562 struct scsi_tape *STp = file->private_data;
3563 struct scsi_device *sdev = STp->device;
3564 int ret = -ENOIOCTLCMD;
3565 if (sdev->host->hostt->compat_ioctl) {
3566
3567 ret = sdev->host->hostt->compat_ioctl(sdev, cmd, (void __user *)arg);
3568
3569 }
3570 return ret;
3571}
3572#endif
3573
3574
3575
3576/* Try to allocate a new tape buffer. Calling function must not hold
3577 dev_arr_lock. */
3578static struct st_buffer *
3579 new_tape_buffer(int from_initialization, int need_dma, int max_sg)
3580{
Mike Christie8b05b772005-11-08 04:06:44 -06003581 int i, got = 0;
Al Viroc53033f2005-10-21 03:22:08 -04003582 gfp_t priority;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003583 struct st_buffer *tb;
3584
3585 if (from_initialization)
3586 priority = GFP_ATOMIC;
3587 else
3588 priority = GFP_KERNEL;
3589
3590 i = sizeof(struct st_buffer) + (max_sg - 1) * sizeof(struct scatterlist) +
3591 max_sg * sizeof(struct st_buf_fragment);
Jes Sorensen24669f752006-01-16 10:31:18 -05003592 tb = kzalloc(i, priority);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003593 if (!tb) {
3594 printk(KERN_NOTICE "st: Can't allocate new tape buffer.\n");
3595 return NULL;
3596 }
Mike Christie8b05b772005-11-08 04:06:44 -06003597 tb->frp_segs = tb->orig_frp_segs = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003598 tb->use_sg = max_sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003599 tb->frp = (struct st_buf_fragment *)(&(tb->sg[0]) + max_sg);
3600
Linus Torvalds1da177e2005-04-16 15:20:36 -07003601 tb->dma = need_dma;
3602 tb->buffer_size = got;
3603
3604 return tb;
3605}
3606
3607
3608/* Try to allocate enough space in the tape buffer */
3609static int enlarge_buffer(struct st_buffer * STbuffer, int new_size, int need_dma)
3610{
Al Viroc53033f2005-10-21 03:22:08 -04003611 int segs, nbr, max_segs, b_size, order, got;
3612 gfp_t priority;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003613
3614 if (new_size <= STbuffer->buffer_size)
3615 return 1;
3616
3617 if (STbuffer->buffer_size <= PAGE_SIZE)
3618 normalize_buffer(STbuffer); /* Avoid extra segment */
3619
3620 max_segs = STbuffer->use_sg;
3621 nbr = max_segs - STbuffer->frp_segs;
3622 if (nbr <= 0)
3623 return 0;
3624
3625 priority = GFP_KERNEL | __GFP_NOWARN;
3626 if (need_dma)
3627 priority |= GFP_DMA;
Mike Christie8b05b772005-11-08 04:06:44 -06003628 for (b_size = PAGE_SIZE, order=0; order <= 6 &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07003629 b_size < new_size - STbuffer->buffer_size;
3630 order++, b_size *= 2)
3631 ; /* empty */
3632
3633 for (segs = STbuffer->frp_segs, got = STbuffer->buffer_size;
3634 segs < max_segs && got < new_size;) {
3635 STbuffer->frp[segs].page = alloc_pages(priority, order);
3636 if (STbuffer->frp[segs].page == NULL) {
3637 if (new_size - got <= (max_segs - segs) * b_size / 2) {
3638 b_size /= 2; /* Large enough for the rest of the buffers */
3639 order--;
3640 continue;
3641 }
3642 DEB(STbuffer->buffer_size = got);
3643 normalize_buffer(STbuffer);
3644 return 0;
3645 }
3646 STbuffer->frp[segs].length = b_size;
3647 STbuffer->frp_segs += 1;
3648 got += b_size;
3649 STbuffer->buffer_size = got;
3650 segs++;
3651 }
3652 STbuffer->b_data = page_address(STbuffer->frp[0].page);
3653
3654 return 1;
3655}
3656
3657
3658/* Release the extra buffer */
3659static void normalize_buffer(struct st_buffer * STbuffer)
3660{
3661 int i, order;
3662
3663 for (i = STbuffer->orig_frp_segs; i < STbuffer->frp_segs; i++) {
3664 order = get_order(STbuffer->frp[i].length);
3665 __free_pages(STbuffer->frp[i].page, order);
3666 STbuffer->buffer_size -= STbuffer->frp[i].length;
3667 }
3668 STbuffer->frp_segs = STbuffer->orig_frp_segs;
3669 STbuffer->frp_sg_current = 0;
Mike Christie8b05b772005-11-08 04:06:44 -06003670 STbuffer->sg_segs = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003671}
3672
3673
3674/* Move data from the user buffer to the tape buffer. Returns zero (success) or
3675 negative error code. */
3676static int append_to_buffer(const char __user *ubp, struct st_buffer * st_bp, int do_count)
3677{
3678 int i, cnt, res, offset;
3679
3680 for (i = 0, offset = st_bp->buffer_bytes;
3681 i < st_bp->frp_segs && offset >= st_bp->frp[i].length; i++)
3682 offset -= st_bp->frp[i].length;
3683 if (i == st_bp->frp_segs) { /* Should never happen */
3684 printk(KERN_WARNING "st: append_to_buffer offset overflow.\n");
3685 return (-EIO);
3686 }
3687 for (; i < st_bp->frp_segs && do_count > 0; i++) {
3688 cnt = st_bp->frp[i].length - offset < do_count ?
3689 st_bp->frp[i].length - offset : do_count;
3690 res = copy_from_user(page_address(st_bp->frp[i].page) + offset, ubp, cnt);
3691 if (res)
3692 return (-EFAULT);
3693 do_count -= cnt;
3694 st_bp->buffer_bytes += cnt;
3695 ubp += cnt;
3696 offset = 0;
3697 }
3698 if (do_count) /* Should never happen */
3699 return (-EIO);
3700
3701 return 0;
3702}
3703
3704
3705/* Move data from the tape buffer to the user buffer. Returns zero (success) or
3706 negative error code. */
3707static int from_buffer(struct st_buffer * st_bp, char __user *ubp, int do_count)
3708{
3709 int i, cnt, res, offset;
3710
3711 for (i = 0, offset = st_bp->read_pointer;
3712 i < st_bp->frp_segs && offset >= st_bp->frp[i].length; i++)
3713 offset -= st_bp->frp[i].length;
3714 if (i == st_bp->frp_segs) { /* Should never happen */
3715 printk(KERN_WARNING "st: from_buffer offset overflow.\n");
3716 return (-EIO);
3717 }
3718 for (; i < st_bp->frp_segs && do_count > 0; i++) {
3719 cnt = st_bp->frp[i].length - offset < do_count ?
3720 st_bp->frp[i].length - offset : do_count;
3721 res = copy_to_user(ubp, page_address(st_bp->frp[i].page) + offset, cnt);
3722 if (res)
3723 return (-EFAULT);
3724 do_count -= cnt;
3725 st_bp->buffer_bytes -= cnt;
3726 st_bp->read_pointer += cnt;
3727 ubp += cnt;
3728 offset = 0;
3729 }
3730 if (do_count) /* Should never happen */
3731 return (-EIO);
3732
3733 return 0;
3734}
3735
3736
3737/* Move data towards start of buffer */
3738static void move_buffer_data(struct st_buffer * st_bp, int offset)
3739{
3740 int src_seg, dst_seg, src_offset = 0, dst_offset;
3741 int count, total;
3742
3743 if (offset == 0)
3744 return;
3745
3746 total=st_bp->buffer_bytes - offset;
3747 for (src_seg=0; src_seg < st_bp->frp_segs; src_seg++) {
3748 src_offset = offset;
3749 if (src_offset < st_bp->frp[src_seg].length)
3750 break;
3751 offset -= st_bp->frp[src_seg].length;
3752 }
3753
3754 st_bp->buffer_bytes = st_bp->read_pointer = total;
3755 for (dst_seg=dst_offset=0; total > 0; ) {
3756 count = min(st_bp->frp[dst_seg].length - dst_offset,
3757 st_bp->frp[src_seg].length - src_offset);
3758 memmove(page_address(st_bp->frp[dst_seg].page) + dst_offset,
3759 page_address(st_bp->frp[src_seg].page) + src_offset, count);
3760 src_offset += count;
3761 if (src_offset >= st_bp->frp[src_seg].length) {
3762 src_seg++;
3763 src_offset = 0;
3764 }
3765 dst_offset += count;
3766 if (dst_offset >= st_bp->frp[dst_seg].length) {
3767 dst_seg++;
3768 dst_offset = 0;
3769 }
3770 total -= count;
3771 }
3772}
3773
3774
3775/* Fill the s/g list up to the length required for this transfer */
3776static void buf_to_sg(struct st_buffer *STbp, unsigned int length)
3777{
3778 int i;
3779 unsigned int count;
3780 struct scatterlist *sg;
3781 struct st_buf_fragment *frp;
3782
3783 if (length == STbp->frp_sg_current)
3784 return; /* work already done */
3785
3786 sg = &(STbp->sg[0]);
3787 frp = STbp->frp;
3788 for (i=count=0; count < length; i++) {
3789 sg[i].page = frp[i].page;
3790 if (length - count > frp[i].length)
3791 sg[i].length = frp[i].length;
3792 else
3793 sg[i].length = length - count;
3794 count += sg[i].length;
3795 sg[i].offset = 0;
3796 }
3797 STbp->sg_segs = i;
3798 STbp->frp_sg_current = length;
3799}
3800
3801
3802/* Validate the options from command line or module parameters */
3803static void validate_options(void)
3804{
3805 if (buffer_kbs > 0)
3806 st_fixed_buffer_size = buffer_kbs * ST_KILOBYTE;
3807 if (max_sg_segs >= ST_FIRST_SG)
3808 st_max_sg_segs = max_sg_segs;
3809}
3810
3811#ifndef MODULE
3812/* Set the boot options. Syntax is defined in Documenation/scsi/st.txt.
3813 */
3814static int __init st_setup(char *str)
3815{
3816 int i, len, ints[5];
3817 char *stp;
3818
3819 stp = get_options(str, ARRAY_SIZE(ints), ints);
3820
3821 if (ints[0] > 0) {
3822 for (i = 0; i < ints[0] && i < ARRAY_SIZE(parms); i++)
3823 if (parms[i].val)
3824 *parms[i].val = ints[i + 1];
3825 } else {
3826 while (stp != NULL) {
3827 for (i = 0; i < ARRAY_SIZE(parms); i++) {
3828 len = strlen(parms[i].name);
3829 if (!strncmp(stp, parms[i].name, len) &&
3830 (*(stp + len) == ':' || *(stp + len) == '=')) {
3831 if (parms[i].val)
3832 *parms[i].val =
3833 simple_strtoul(stp + len + 1, NULL, 0);
3834 else
3835 printk(KERN_WARNING "st: Obsolete parameter %s\n",
3836 parms[i].name);
3837 break;
3838 }
3839 }
Tobias Klauser6391a112006-06-08 22:23:48 -07003840 if (i >= ARRAY_SIZE(parms))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003841 printk(KERN_WARNING "st: invalid parameter in '%s'\n",
3842 stp);
3843 stp = strchr(stp, ',');
3844 if (stp)
3845 stp++;
3846 }
3847 }
3848
3849 validate_options();
3850
3851 return 1;
3852}
3853
3854__setup("st=", st_setup);
3855
3856#endif
3857
3858static struct file_operations st_fops =
3859{
3860 .owner = THIS_MODULE,
3861 .read = st_read,
3862 .write = st_write,
3863 .ioctl = st_ioctl,
3864#ifdef CONFIG_COMPAT
3865 .compat_ioctl = st_compat_ioctl,
3866#endif
3867 .open = st_open,
3868 .flush = st_flush,
3869 .release = st_release,
3870};
3871
3872static int st_probe(struct device *dev)
3873{
3874 struct scsi_device *SDp = to_scsi_device(dev);
3875 struct gendisk *disk = NULL;
3876 struct cdev *cdev = NULL;
3877 struct scsi_tape *tpnt = NULL;
3878 struct st_modedef *STm;
3879 struct st_partstat *STps;
3880 struct st_buffer *buffer;
3881 int i, j, mode, dev_num, error;
3882 char *stp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003883
3884 if (SDp->type != TYPE_TAPE)
3885 return -ENODEV;
3886 if ((stp = st_incompatible(SDp))) {
Jeff Garzik3bf743e2005-10-24 18:04:06 -04003887 sdev_printk(KERN_INFO, SDp, "Found incompatible tape\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003888 printk(KERN_INFO "st: The suggested driver is %s.\n", stp);
3889 return -ENODEV;
3890 }
3891
Mike Christie8b05b772005-11-08 04:06:44 -06003892 i = min(SDp->request_queue->max_hw_segments,
3893 SDp->request_queue->max_phys_segments);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003894 if (st_max_sg_segs < i)
3895 i = st_max_sg_segs;
3896 buffer = new_tape_buffer(1, (SDp->host)->unchecked_isa_dma, i);
3897 if (buffer == NULL) {
3898 printk(KERN_ERR
3899 "st: Can't allocate new tape buffer. Device not attached.\n");
3900 goto out;
3901 }
3902
3903 disk = alloc_disk(1);
3904 if (!disk) {
3905 printk(KERN_ERR "st: out of memory. Device not attached.\n");
3906 goto out_buffer_free;
3907 }
3908
3909 write_lock(&st_dev_arr_lock);
3910 if (st_nr_dev >= st_dev_max) {
3911 struct scsi_tape **tmp_da;
3912 int tmp_dev_max;
3913
3914 tmp_dev_max = max(st_nr_dev * 2, 8);
3915 if (tmp_dev_max > ST_MAX_TAPES)
3916 tmp_dev_max = ST_MAX_TAPES;
3917 if (tmp_dev_max <= st_nr_dev) {
3918 write_unlock(&st_dev_arr_lock);
3919 printk(KERN_ERR "st: Too many tape devices (max. %d).\n",
3920 ST_MAX_TAPES);
3921 goto out_put_disk;
3922 }
3923
Jes Sorensen24669f752006-01-16 10:31:18 -05003924 tmp_da = kzalloc(tmp_dev_max * sizeof(struct scsi_tape *), GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003925 if (tmp_da == NULL) {
3926 write_unlock(&st_dev_arr_lock);
3927 printk(KERN_ERR "st: Can't extend device array.\n");
3928 goto out_put_disk;
3929 }
3930
Linus Torvalds1da177e2005-04-16 15:20:36 -07003931 if (scsi_tapes != NULL) {
3932 memcpy(tmp_da, scsi_tapes,
3933 st_dev_max * sizeof(struct scsi_tape *));
3934 kfree(scsi_tapes);
3935 }
3936 scsi_tapes = tmp_da;
3937
3938 st_dev_max = tmp_dev_max;
3939 }
3940
3941 for (i = 0; i < st_dev_max; i++)
3942 if (scsi_tapes[i] == NULL)
3943 break;
3944 if (i >= st_dev_max)
3945 panic("scsi_devices corrupt (st)");
3946
Jes Sorensen24669f752006-01-16 10:31:18 -05003947 tpnt = kzalloc(sizeof(struct scsi_tape), GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003948 if (tpnt == NULL) {
3949 write_unlock(&st_dev_arr_lock);
3950 printk(KERN_ERR "st: Can't allocate device descriptor.\n");
3951 goto out_put_disk;
3952 }
Kai Makisaraf03a5672005-08-02 13:40:47 +03003953 kref_init(&tpnt->kref);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003954 tpnt->disk = disk;
3955 sprintf(disk->disk_name, "st%d", i);
3956 disk->private_data = &tpnt->driver;
3957 disk->queue = SDp->request_queue;
3958 tpnt->driver = &st_template;
3959 scsi_tapes[i] = tpnt;
3960 dev_num = i;
3961
3962 tpnt->device = SDp;
3963 if (SDp->scsi_level <= 2)
3964 tpnt->tape_type = MT_ISSCSI1;
3965 else
3966 tpnt->tape_type = MT_ISSCSI2;
3967
3968 tpnt->buffer = buffer;
Kai Makisaraf03a5672005-08-02 13:40:47 +03003969 tpnt->buffer->last_SRpnt = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003970
3971 tpnt->inited = 0;
3972 tpnt->dirty = 0;
3973 tpnt->in_use = 0;
3974 tpnt->drv_buffer = 1; /* Try buffering if no mode sense */
3975 tpnt->restr_dma = (SDp->host)->unchecked_isa_dma;
3976 tpnt->use_pf = (SDp->scsi_level >= SCSI_2);
3977 tpnt->density = 0;
3978 tpnt->do_auto_lock = ST_AUTO_LOCK;
3979 tpnt->can_bsr = (SDp->scsi_level > 2 ? 1 : ST_IN_FILE_POS); /* BSR mandatory in SCSI3 */
3980 tpnt->can_partitions = 0;
3981 tpnt->two_fm = ST_TWO_FM;
3982 tpnt->fast_mteom = ST_FAST_MTEOM;
3983 tpnt->scsi2_logical = ST_SCSI2LOGICAL;
3984 tpnt->immediate = ST_NOWAIT;
3985 tpnt->default_drvbuffer = 0xff; /* No forced buffering */
3986 tpnt->partition = 0;
3987 tpnt->new_partition = 0;
3988 tpnt->nbr_partitions = 0;
3989 tpnt->device->timeout = ST_TIMEOUT;
3990 tpnt->long_timeout = ST_LONG_TIMEOUT;
3991 tpnt->try_dio = try_direct_io && !SDp->host->unchecked_isa_dma;
3992
Linus Torvalds1da177e2005-04-16 15:20:36 -07003993 for (i = 0; i < ST_NBR_MODES; i++) {
3994 STm = &(tpnt->modes[i]);
3995 STm->defined = 0;
3996 STm->sysv = ST_SYSV;
3997 STm->defaults_for_writes = 0;
3998 STm->do_async_writes = ST_ASYNC_WRITES;
3999 STm->do_buffer_writes = ST_BUFFER_WRITES;
4000 STm->do_read_ahead = ST_READ_AHEAD;
4001 STm->default_compression = ST_DONT_TOUCH;
4002 STm->default_blksize = (-1); /* No forced size */
4003 STm->default_density = (-1); /* No forced density */
4004 }
4005
4006 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
4007 STps = &(tpnt->ps[i]);
4008 STps->rw = ST_IDLE;
4009 STps->eof = ST_NOEOF;
4010 STps->at_sm = 0;
4011 STps->last_block_valid = 0;
4012 STps->drv_block = (-1);
4013 STps->drv_file = (-1);
4014 }
4015
4016 tpnt->current_mode = 0;
4017 tpnt->modes[0].defined = 1;
4018
4019 tpnt->density_changed = tpnt->compression_changed =
4020 tpnt->blksize_changed = 0;
4021 init_MUTEX(&tpnt->lock);
4022
4023 st_nr_dev++;
4024 write_unlock(&st_dev_arr_lock);
4025
4026 for (mode = 0; mode < ST_NBR_MODES; ++mode) {
4027 STm = &(tpnt->modes[mode]);
4028 for (j=0; j < 2; j++) {
4029 cdev = cdev_alloc();
4030 if (!cdev) {
4031 printk(KERN_ERR
4032 "st%d: out of memory. Device not attached.\n",
4033 dev_num);
4034 goto out_free_tape;
4035 }
4036 cdev->owner = THIS_MODULE;
4037 cdev->ops = &st_fops;
4038
4039 error = cdev_add(cdev,
4040 MKDEV(SCSI_TAPE_MAJOR, TAPE_MINOR(dev_num, mode, j)),
4041 1);
4042 if (error) {
4043 printk(KERN_ERR "st%d: Can't add %s-rewind mode %d\n",
4044 dev_num, j ? "non" : "auto", mode);
4045 printk(KERN_ERR "st%d: Device not attached.\n", dev_num);
4046 goto out_free_tape;
4047 }
4048 STm->cdevs[j] = cdev;
4049
4050 }
Jeff Garzik13026a62006-10-04 06:00:38 -04004051 error = do_create_class_files(tpnt, dev_num, mode);
4052 if (error)
4053 goto out_free_tape;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004054 }
4055
James Bottomley9ccfc752005-10-02 11:45:08 -05004056 sdev_printk(KERN_WARNING, SDp,
Rene Herman8b1ea242006-05-20 15:00:22 -07004057 "Attached scsi tape %s\n", tape_name(tpnt));
Mike Christie8b05b772005-11-08 04:06:44 -06004058 printk(KERN_WARNING "%s: try direct i/o: %s (alignment %d B)\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07004059 tape_name(tpnt), tpnt->try_dio ? "yes" : "no",
Mike Christie8b05b772005-11-08 04:06:44 -06004060 queue_dma_alignment(SDp->request_queue) + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004061
4062 return 0;
4063
4064out_free_tape:
4065 for (mode=0; mode < ST_NBR_MODES; mode++) {
4066 STm = &(tpnt->modes[mode]);
4067 sysfs_remove_link(&tpnt->device->sdev_gendev.kobj,
4068 "tape");
4069 for (j=0; j < 2; j++) {
4070 if (STm->cdevs[j]) {
4071 if (cdev == STm->cdevs[j])
4072 cdev = NULL;
gregkh@suse.ded2538782005-03-23 09:55:22 -08004073 class_device_destroy(st_sysfs_class,
4074 MKDEV(SCSI_TAPE_MAJOR,
4075 TAPE_MINOR(i, mode, j)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07004076 cdev_del(STm->cdevs[j]);
4077 }
4078 }
4079 }
4080 if (cdev)
4081 cdev_del(cdev);
4082 write_lock(&st_dev_arr_lock);
4083 scsi_tapes[dev_num] = NULL;
4084 st_nr_dev--;
4085 write_unlock(&st_dev_arr_lock);
4086out_put_disk:
4087 put_disk(disk);
Jesper Juhlc9475cb2005-11-07 01:01:26 -08004088 kfree(tpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004089out_buffer_free:
4090 kfree(buffer);
4091out:
4092 return -ENODEV;
4093};
4094
4095
4096static int st_remove(struct device *dev)
4097{
4098 struct scsi_device *SDp = to_scsi_device(dev);
4099 struct scsi_tape *tpnt;
4100 int i, j, mode;
4101
4102 write_lock(&st_dev_arr_lock);
4103 for (i = 0; i < st_dev_max; i++) {
4104 tpnt = scsi_tapes[i];
4105 if (tpnt != NULL && tpnt->device == SDp) {
4106 scsi_tapes[i] = NULL;
4107 st_nr_dev--;
4108 write_unlock(&st_dev_arr_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004109 sysfs_remove_link(&tpnt->device->sdev_gendev.kobj,
4110 "tape");
4111 for (mode = 0; mode < ST_NBR_MODES; ++mode) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004112 for (j=0; j < 2; j++) {
gregkh@suse.ded2538782005-03-23 09:55:22 -08004113 class_device_destroy(st_sysfs_class,
4114 MKDEV(SCSI_TAPE_MAJOR,
4115 TAPE_MINOR(i, mode, j)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07004116 cdev_del(tpnt->modes[mode].cdevs[j]);
4117 tpnt->modes[mode].cdevs[j] = NULL;
4118 }
4119 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004120
Arjan van de Ven0b950672006-01-11 13:16:10 +01004121 mutex_lock(&st_ref_mutex);
Kai Makisaraf03a5672005-08-02 13:40:47 +03004122 kref_put(&tpnt->kref, scsi_tape_release);
Arjan van de Ven0b950672006-01-11 13:16:10 +01004123 mutex_unlock(&st_ref_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004124 return 0;
4125 }
4126 }
4127
4128 write_unlock(&st_dev_arr_lock);
4129 return 0;
4130}
4131
Kai Makisaraf03a5672005-08-02 13:40:47 +03004132/**
4133 * scsi_tape_release - Called to free the Scsi_Tape structure
4134 * @kref: pointer to embedded kref
4135 *
Arjan van de Ven0b950672006-01-11 13:16:10 +01004136 * st_ref_mutex must be held entering this routine. Because it is
Kai Makisaraf03a5672005-08-02 13:40:47 +03004137 * called on last put, you should always use the scsi_tape_get()
4138 * scsi_tape_put() helpers which manipulate the semaphore directly
4139 * and never do a direct kref_put().
4140 **/
4141static void scsi_tape_release(struct kref *kref)
4142{
4143 struct scsi_tape *tpnt = to_scsi_tape(kref);
4144 struct gendisk *disk = tpnt->disk;
4145
4146 tpnt->device = NULL;
4147
4148 if (tpnt->buffer) {
4149 tpnt->buffer->orig_frp_segs = 0;
4150 normalize_buffer(tpnt->buffer);
4151 kfree(tpnt->buffer);
4152 }
4153
4154 disk->private_data = NULL;
4155 put_disk(disk);
4156 kfree(tpnt);
4157 return;
4158}
4159
Linus Torvalds1da177e2005-04-16 15:20:36 -07004160static int __init init_st(void)
4161{
Jeff Garzik13026a62006-10-04 06:00:38 -04004162 int err;
4163
Linus Torvalds1da177e2005-04-16 15:20:36 -07004164 validate_options();
4165
Jeff Garzik13026a62006-10-04 06:00:38 -04004166 printk(KERN_INFO "st: Version %s, fixed bufsize %d, s/g segs %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07004167 verstr, st_fixed_buffer_size, st_max_sg_segs);
4168
gregkh@suse.ded2538782005-03-23 09:55:22 -08004169 st_sysfs_class = class_create(THIS_MODULE, "scsi_tape");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004170 if (IS_ERR(st_sysfs_class)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004171 printk(KERN_ERR "Unable create sysfs class for SCSI tapes\n");
Jeff Garzik13026a62006-10-04 06:00:38 -04004172 return PTR_ERR(st_sysfs_class);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004173 }
4174
Jeff Garzik13026a62006-10-04 06:00:38 -04004175 err = register_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4176 ST_MAX_TAPE_ENTRIES, "st");
4177 if (err) {
4178 printk(KERN_ERR "Unable to get major %d for SCSI tapes\n",
4179 SCSI_TAPE_MAJOR);
4180 goto err_class;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004181 }
Jeff Garzik13026a62006-10-04 06:00:38 -04004182
4183 err = scsi_register_driver(&st_template.gendrv);
4184 if (err)
4185 goto err_chrdev;
4186
4187 err = do_create_driverfs_files();
4188 if (err)
4189 goto err_scsidrv;
4190
4191 return 0;
4192
4193err_scsidrv:
4194 scsi_unregister_driver(&st_template.gendrv);
4195err_chrdev:
4196 unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4197 ST_MAX_TAPE_ENTRIES);
4198err_class:
Kai Makisarac2c96f42005-08-02 12:21:51 +03004199 class_destroy(st_sysfs_class);
Jeff Garzik13026a62006-10-04 06:00:38 -04004200 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004201}
4202
4203static void __exit exit_st(void)
4204{
Linus Torvalds1da177e2005-04-16 15:20:36 -07004205 do_remove_driverfs_files();
4206 scsi_unregister_driver(&st_template.gendrv);
4207 unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4208 ST_MAX_TAPE_ENTRIES);
Kai Makisarac2c96f42005-08-02 12:21:51 +03004209 class_destroy(st_sysfs_class);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004210 kfree(scsi_tapes);
4211 printk(KERN_INFO "st: Unloaded.\n");
4212}
4213
4214module_init(init_st);
4215module_exit(exit_st);
4216
4217
4218/* The sysfs driver interface. Read-only at the moment */
4219static ssize_t st_try_direct_io_show(struct device_driver *ddp, char *buf)
4220{
4221 return snprintf(buf, PAGE_SIZE, "%d\n", try_direct_io);
4222}
4223static DRIVER_ATTR(try_direct_io, S_IRUGO, st_try_direct_io_show, NULL);
4224
4225static ssize_t st_fixed_buffer_size_show(struct device_driver *ddp, char *buf)
4226{
4227 return snprintf(buf, PAGE_SIZE, "%d\n", st_fixed_buffer_size);
4228}
4229static DRIVER_ATTR(fixed_buffer_size, S_IRUGO, st_fixed_buffer_size_show, NULL);
4230
4231static ssize_t st_max_sg_segs_show(struct device_driver *ddp, char *buf)
4232{
4233 return snprintf(buf, PAGE_SIZE, "%d\n", st_max_sg_segs);
4234}
4235static DRIVER_ATTR(max_sg_segs, S_IRUGO, st_max_sg_segs_show, NULL);
4236
4237static ssize_t st_version_show(struct device_driver *ddd, char *buf)
4238{
4239 return snprintf(buf, PAGE_SIZE, "[%s]\n", verstr);
4240}
4241static DRIVER_ATTR(version, S_IRUGO, st_version_show, NULL);
4242
Jeff Garzik13026a62006-10-04 06:00:38 -04004243static int do_create_driverfs_files(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004244{
4245 struct device_driver *driverfs = &st_template.gendrv;
Jeff Garzik13026a62006-10-04 06:00:38 -04004246 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004247
Jeff Garzik13026a62006-10-04 06:00:38 -04004248 err = driver_create_file(driverfs, &driver_attr_try_direct_io);
4249 if (err)
4250 return err;
4251 err = driver_create_file(driverfs, &driver_attr_fixed_buffer_size);
4252 if (err)
4253 goto err_try_direct_io;
4254 err = driver_create_file(driverfs, &driver_attr_max_sg_segs);
4255 if (err)
4256 goto err_attr_fixed_buf;
4257 err = driver_create_file(driverfs, &driver_attr_version);
4258 if (err)
4259 goto err_attr_max_sg;
4260
4261 return 0;
4262
4263err_attr_max_sg:
4264 driver_remove_file(driverfs, &driver_attr_max_sg_segs);
4265err_attr_fixed_buf:
4266 driver_remove_file(driverfs, &driver_attr_fixed_buffer_size);
4267err_try_direct_io:
4268 driver_remove_file(driverfs, &driver_attr_try_direct_io);
4269 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004270}
4271
4272static void do_remove_driverfs_files(void)
4273{
4274 struct device_driver *driverfs = &st_template.gendrv;
4275
4276 driver_remove_file(driverfs, &driver_attr_version);
4277 driver_remove_file(driverfs, &driver_attr_max_sg_segs);
4278 driver_remove_file(driverfs, &driver_attr_fixed_buffer_size);
4279 driver_remove_file(driverfs, &driver_attr_try_direct_io);
4280}
4281
4282
4283/* The sysfs simple class interface */
4284static ssize_t st_defined_show(struct class_device *class_dev, char *buf)
4285{
4286 struct st_modedef *STm = (struct st_modedef *)class_get_devdata(class_dev);
4287 ssize_t l = 0;
4288
4289 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->defined);
4290 return l;
4291}
4292
4293CLASS_DEVICE_ATTR(defined, S_IRUGO, st_defined_show, NULL);
4294
4295static ssize_t st_defblk_show(struct class_device *class_dev, char *buf)
4296{
4297 struct st_modedef *STm = (struct st_modedef *)class_get_devdata(class_dev);
4298 ssize_t l = 0;
4299
4300 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_blksize);
4301 return l;
4302}
4303
4304CLASS_DEVICE_ATTR(default_blksize, S_IRUGO, st_defblk_show, NULL);
4305
4306static ssize_t st_defdensity_show(struct class_device *class_dev, char *buf)
4307{
4308 struct st_modedef *STm = (struct st_modedef *)class_get_devdata(class_dev);
4309 ssize_t l = 0;
4310 char *fmt;
4311
4312 fmt = STm->default_density >= 0 ? "0x%02x\n" : "%d\n";
4313 l = snprintf(buf, PAGE_SIZE, fmt, STm->default_density);
4314 return l;
4315}
4316
4317CLASS_DEVICE_ATTR(default_density, S_IRUGO, st_defdensity_show, NULL);
4318
4319static ssize_t st_defcompression_show(struct class_device *class_dev, char *buf)
4320{
4321 struct st_modedef *STm = (struct st_modedef *)class_get_devdata(class_dev);
4322 ssize_t l = 0;
4323
4324 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_compression - 1);
4325 return l;
4326}
4327
4328CLASS_DEVICE_ATTR(default_compression, S_IRUGO, st_defcompression_show, NULL);
4329
Jeff Garzik13026a62006-10-04 06:00:38 -04004330static int do_create_class_files(struct scsi_tape *STp, int dev_num, int mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004331{
4332 int i, rew, error;
4333 char name[10];
4334 struct class_device *st_class_member;
4335
Linus Torvalds1da177e2005-04-16 15:20:36 -07004336 for (rew=0; rew < 2; rew++) {
4337 /* Make sure that the minor numbers corresponding to the four
4338 first modes always get the same names */
4339 i = mode << (4 - ST_NBR_MODE_BITS);
4340 snprintf(name, 10, "%s%s%s", rew ? "n" : "",
4341 STp->disk->disk_name, st_formats[i]);
4342 st_class_member =
Greg Kroah-Hartman53f46542005-10-27 22:25:43 -07004343 class_device_create(st_sysfs_class, NULL,
gregkh@suse.ded2538782005-03-23 09:55:22 -08004344 MKDEV(SCSI_TAPE_MAJOR,
4345 TAPE_MINOR(dev_num, mode, rew)),
4346 &STp->device->sdev_gendev, "%s", name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004347 if (IS_ERR(st_class_member)) {
gregkh@suse.ded2538782005-03-23 09:55:22 -08004348 printk(KERN_WARNING "st%d: class_device_create failed\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07004349 dev_num);
Jeff Garzik13026a62006-10-04 06:00:38 -04004350 error = PTR_ERR(st_class_member);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004351 goto out;
4352 }
4353 class_set_devdata(st_class_member, &STp->modes[mode]);
4354
Jeff Garzik13026a62006-10-04 06:00:38 -04004355 error = class_device_create_file(st_class_member,
4356 &class_device_attr_defined);
4357 if (error) goto out;
4358 error = class_device_create_file(st_class_member,
4359 &class_device_attr_default_blksize);
4360 if (error) goto out;
4361 error = class_device_create_file(st_class_member,
4362 &class_device_attr_default_density);
4363 if (error) goto out;
4364 error = class_device_create_file(st_class_member,
4365 &class_device_attr_default_compression);
4366 if (error) goto out;
4367
Linus Torvalds1da177e2005-04-16 15:20:36 -07004368 if (mode == 0 && rew == 0) {
4369 error = sysfs_create_link(&STp->device->sdev_gendev.kobj,
4370 &st_class_member->kobj,
4371 "tape");
4372 if (error) {
4373 printk(KERN_ERR
4374 "st%d: Can't create sysfs link from SCSI device.\n",
4375 dev_num);
Jeff Garzik13026a62006-10-04 06:00:38 -04004376 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004377 }
4378 }
4379 }
Jeff Garzik13026a62006-10-04 06:00:38 -04004380
4381 return 0;
4382
4383out:
4384 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004385}
4386
Linus Torvalds1da177e2005-04-16 15:20:36 -07004387/* The following functions may be useful for a larger audience. */
4388static int sgl_map_user_pages(struct scatterlist *sgl, const unsigned int max_pages,
4389 unsigned long uaddr, size_t count, int rw)
4390{
James Bottomley07542b82005-08-31 20:27:22 -04004391 unsigned long end = (uaddr + count + PAGE_SIZE - 1) >> PAGE_SHIFT;
4392 unsigned long start = uaddr >> PAGE_SHIFT;
4393 const int nr_pages = end - start;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004394 int res, i, j;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004395 struct page **pages;
4396
Linus Torvalds1da177e2005-04-16 15:20:36 -07004397 /* User attempted Overflow! */
4398 if ((uaddr + count) < uaddr)
4399 return -EINVAL;
4400
4401 /* Too big */
4402 if (nr_pages > max_pages)
4403 return -ENOMEM;
4404
4405 /* Hmm? */
4406 if (count == 0)
4407 return 0;
4408
4409 if ((pages = kmalloc(max_pages * sizeof(*pages), GFP_KERNEL)) == NULL)
4410 return -ENOMEM;
4411
4412 /* Try to fault in all of the necessary pages */
4413 down_read(&current->mm->mmap_sem);
4414 /* rw==READ means read from drive, write into memory area */
4415 res = get_user_pages(
4416 current,
4417 current->mm,
4418 uaddr,
4419 nr_pages,
4420 rw == READ,
4421 0, /* don't force */
4422 pages,
4423 NULL);
4424 up_read(&current->mm->mmap_sem);
4425
4426 /* Errors and no page mapped should return here */
4427 if (res < nr_pages)
4428 goto out_unmap;
4429
4430 for (i=0; i < nr_pages; i++) {
4431 /* FIXME: flush superflous for rw==READ,
4432 * probably wrong function for rw==WRITE
4433 */
4434 flush_dcache_page(pages[i]);
4435 }
4436
4437 /* Populate the scatter/gather list */
4438 sgl[0].page = pages[0];
4439 sgl[0].offset = uaddr & ~PAGE_MASK;
4440 if (nr_pages > 1) {
4441 sgl[0].length = PAGE_SIZE - sgl[0].offset;
4442 count -= sgl[0].length;
4443 for (i=1; i < nr_pages ; i++) {
4444 sgl[i].offset = 0;
4445 sgl[i].page = pages[i];
4446 sgl[i].length = count < PAGE_SIZE ? count : PAGE_SIZE;
4447 count -= PAGE_SIZE;
4448 }
4449 }
4450 else {
4451 sgl[0].length = count;
4452 }
4453
4454 kfree(pages);
4455 return nr_pages;
4456
4457 out_unmap:
4458 if (res > 0) {
4459 for (j=0; j < res; j++)
4460 page_cache_release(pages[j]);
Hugh Dickins6bc733e2005-12-01 20:21:57 +00004461 res = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004462 }
4463 kfree(pages);
4464 return res;
4465}
4466
4467
4468/* And unmap them... */
4469static int sgl_unmap_user_pages(struct scatterlist *sgl, const unsigned int nr_pages,
4470 int dirtied)
4471{
4472 int i;
4473
4474 for (i=0; i < nr_pages; i++) {
Nick Pigginb5810032005-10-29 18:16:12 -07004475 struct page *page = sgl[i].page;
4476
Nick Pigginb5810032005-10-29 18:16:12 -07004477 if (dirtied)
4478 SetPageDirty(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004479 /* FIXME: cache flush missing for rw==READ
4480 * FIXME: call the correct reference counting function
4481 */
Nick Pigginb5810032005-10-29 18:16:12 -07004482 page_cache_release(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004483 }
4484
4485 return 0;
4486}