blob: 013dc595fab63754b391b33a7efd6b3e287167c3 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Borislav Petkov5ce78af2008-02-02 19:56:48 +01002 * IDE ATAPI streaming tape driver.
3 *
Bartlomiej Zolnierkiewicz59bca8c2008-02-01 23:09:33 +01004 * Copyright (C) 1995-1999 Gadi Oxman <gadio@netvision.net.il>
5 * Copyright (C) 2003-2005 Bartlomiej Zolnierkiewicz
Linus Torvalds1da177e2005-04-16 15:20:36 -07006 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 * This driver was constructed as a student project in the software laboratory
8 * of the faculty of electrical engineering in the Technion - Israel's
9 * Institute Of Technology, with the guide of Avner Lottem and Dr. Ilana David.
10 *
11 * It is hereby placed under the terms of the GNU general public license.
12 * (See linux/COPYING).
Linus Torvalds1da177e2005-04-16 15:20:36 -070013 *
Borislav Petkov5ce78af2008-02-02 19:56:48 +010014 * For a historical changelog see
15 * Documentation/ide/ChangeLog.ide-tape.1995-2002
Linus Torvalds1da177e2005-04-16 15:20:36 -070016 */
17
Bartlomiej Zolnierkiewicz51509ee2008-10-10 22:39:34 +020018#define DRV_NAME "ide-tape"
19
Borislav Petkovdfe79932008-02-06 02:57:55 +010020#define IDETAPE_VERSION "1.20"
Linus Torvalds1da177e2005-04-16 15:20:36 -070021
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include <linux/module.h>
23#include <linux/types.h>
24#include <linux/string.h>
25#include <linux/kernel.h>
26#include <linux/delay.h>
27#include <linux/timer.h>
28#include <linux/mm.h>
29#include <linux/interrupt.h>
Marcelo Feitoza Parisi9bae1ff2006-03-28 01:56:46 -080030#include <linux/jiffies.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070031#include <linux/major.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#include <linux/errno.h>
33#include <linux/genhd.h>
34#include <linux/slab.h>
35#include <linux/pci.h>
36#include <linux/ide.h>
37#include <linux/smp_lock.h>
38#include <linux/completion.h>
39#include <linux/bitops.h>
Arjan van de Vencf8b8972006-03-23 03:00:45 -080040#include <linux/mutex.h>
Borislav Petkov90699ce2008-02-02 19:56:50 +010041#include <scsi/scsi.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070042
43#include <asm/byteorder.h>
Borislav Petkovc837cfa2008-02-06 02:57:54 +010044#include <linux/irq.h>
45#include <linux/uaccess.h>
46#include <linux/io.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070047#include <asm/unaligned.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070048#include <linux/mtio.h>
49
Borislav Petkov8004a8c2008-02-06 02:57:51 +010050enum {
51 /* output errors only */
52 DBG_ERR = (1 << 0),
53 /* output all sense key/asc */
54 DBG_SENSE = (1 << 1),
55 /* info regarding all chrdev-related procedures */
56 DBG_CHRDEV = (1 << 2),
57 /* all remaining procedures */
58 DBG_PROCS = (1 << 3),
Borislav Petkov8004a8c2008-02-06 02:57:51 +010059};
60
61/* define to see debug info */
62#define IDETAPE_DEBUG_LOG 0
63
64#if IDETAPE_DEBUG_LOG
65#define debug_log(lvl, fmt, args...) \
66{ \
67 if (tape->debug_mask & lvl) \
68 printk(KERN_INFO "ide-tape: " fmt, ## args); \
69}
70#else
71#define debug_log(lvl, fmt, args...) do {} while (0)
72#endif
73
Linus Torvalds1da177e2005-04-16 15:20:36 -070074/**************************** Tunable parameters *****************************/
Linus Torvalds1da177e2005-04-16 15:20:36 -070075/*
Borislav Petkov3c98bf32008-02-06 02:57:53 +010076 * After each failed packet command we issue a request sense command and retry
77 * the packet command IDETAPE_MAX_PC_RETRIES times.
Linus Torvalds1da177e2005-04-16 15:20:36 -070078 *
Borislav Petkov3c98bf32008-02-06 02:57:53 +010079 * Setting IDETAPE_MAX_PC_RETRIES to 0 will disable retries.
Linus Torvalds1da177e2005-04-16 15:20:36 -070080 */
81#define IDETAPE_MAX_PC_RETRIES 3
82
83/*
Borislav Petkov3c98bf32008-02-06 02:57:53 +010084 * The following parameter is used to select the point in the internal tape fifo
85 * in which we will start to refill the buffer. Decreasing the following
86 * parameter will improve the system's latency and interactive response, while
87 * using a high value might improve system throughput.
Linus Torvalds1da177e2005-04-16 15:20:36 -070088 */
Borislav Petkov3c98bf32008-02-06 02:57:53 +010089#define IDETAPE_FIFO_THRESHOLD 2
Linus Torvalds1da177e2005-04-16 15:20:36 -070090
91/*
Borislav Petkov3c98bf32008-02-06 02:57:53 +010092 * DSC polling parameters.
Linus Torvalds1da177e2005-04-16 15:20:36 -070093 *
Borislav Petkov3c98bf32008-02-06 02:57:53 +010094 * Polling for DSC (a single bit in the status register) is a very important
95 * function in ide-tape. There are two cases in which we poll for DSC:
Linus Torvalds1da177e2005-04-16 15:20:36 -070096 *
Borislav Petkov3c98bf32008-02-06 02:57:53 +010097 * 1. Before a read/write packet command, to ensure that we can transfer data
98 * from/to the tape's data buffers, without causing an actual media access.
99 * In case the tape is not ready yet, we take out our request from the device
100 * request queue, so that ide.c could service requests from the other device
101 * on the same interface in the meantime.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102 *
Borislav Petkov3c98bf32008-02-06 02:57:53 +0100103 * 2. After the successful initialization of a "media access packet command",
104 * which is a command that can take a long time to complete (the interval can
105 * range from several seconds to even an hour). Again, we postpone our request
106 * in the middle to free the bus for the other device. The polling frequency
107 * here should be lower than the read/write frequency since those media access
108 * commands are slow. We start from a "fast" frequency - IDETAPE_DSC_MA_FAST
109 * (1 second), and if we don't receive DSC after IDETAPE_DSC_MA_THRESHOLD
110 * (5 min), we switch it to a lower frequency - IDETAPE_DSC_MA_SLOW (1 min).
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111 *
Borislav Petkov3c98bf32008-02-06 02:57:53 +0100112 * We also set a timeout for the timer, in case something goes wrong. The
113 * timeout should be longer then the maximum execution time of a tape operation.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114 */
Borislav Petkov3c98bf32008-02-06 02:57:53 +0100115
116/* DSC timings. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117#define IDETAPE_DSC_RW_MIN 5*HZ/100 /* 50 msec */
118#define IDETAPE_DSC_RW_MAX 40*HZ/100 /* 400 msec */
119#define IDETAPE_DSC_RW_TIMEOUT 2*60*HZ /* 2 minutes */
120#define IDETAPE_DSC_MA_FAST 2*HZ /* 2 seconds */
121#define IDETAPE_DSC_MA_THRESHOLD 5*60*HZ /* 5 minutes */
122#define IDETAPE_DSC_MA_SLOW 30*HZ /* 30 seconds */
123#define IDETAPE_DSC_MA_TIMEOUT 2*60*60*HZ /* 2 hours */
124
125/*************************** End of tunable parameters ***********************/
126
Borislav Petkov54abf372008-02-06 02:57:52 +0100127/* tape directions */
128enum {
129 IDETAPE_DIR_NONE = (1 << 0),
130 IDETAPE_DIR_READ = (1 << 1),
131 IDETAPE_DIR_WRITE = (1 << 2),
132};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133
Borislav Petkov03056b92008-04-18 00:46:26 +0200134/* Tape door status */
135#define DOOR_UNLOCKED 0
136#define DOOR_LOCKED 1
137#define DOOR_EXPLICITLY_LOCKED 2
138
139/* Some defines for the SPACE command */
140#define IDETAPE_SPACE_OVER_FILEMARK 1
141#define IDETAPE_SPACE_TO_EOD 3
142
143/* Some defines for the LOAD UNLOAD command */
144#define IDETAPE_LU_LOAD_MASK 1
145#define IDETAPE_LU_RETENSION_MASK 2
146#define IDETAPE_LU_EOT_MASK 4
147
Borislav Petkov03056b92008-04-18 00:46:26 +0200148/* Structures related to the SELECT SENSE / MODE SENSE packet commands. */
149#define IDETAPE_BLOCK_DESCRIPTOR 0
150#define IDETAPE_CAPABILITIES_PAGE 0x2a
151
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152/*
Borislav Petkov3c98bf32008-02-06 02:57:53 +0100153 * Most of our global data which we need to save even as we leave the driver due
154 * to an interrupt or a timer event is stored in the struct defined below.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155 */
156typedef struct ide_tape_obj {
Bartlomiej Zolnierkiewicz7f3c8682009-01-06 17:20:53 +0100157 ide_drive_t *drive;
158 struct ide_driver *driver;
159 struct gendisk *disk;
Bartlomiej Zolnierkiewicz8fed4362009-02-25 20:28:24 +0100160 struct device dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161
Bartlomiej Zolnierkiewicz2e8a6f82008-10-10 22:39:36 +0200162 /* used by REQ_IDETAPE_{READ,WRITE} requests */
163 struct ide_atapi_pc queued_pc;
Bartlomiej Zolnierkiewicz394a4c22008-10-10 22:39:35 +0200164
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165 /*
Borislav Petkov3c98bf32008-02-06 02:57:53 +0100166 * DSC polling variables.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167 *
Borislav Petkov3c98bf32008-02-06 02:57:53 +0100168 * While polling for DSC we use postponed_rq to postpone the current
169 * request so that ide.c will be able to service pending requests on the
170 * other device. Note that at most we will have only one DSC (usually
Borislav Petkov5bd50dc2008-04-27 15:38:28 +0200171 * data transfer) request in the device request queue.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172 */
173 struct request *postponed_rq;
174 /* The time in which we started polling for DSC */
175 unsigned long dsc_polling_start;
176 /* Timer used to poll for dsc */
177 struct timer_list dsc_timer;
178 /* Read/Write dsc polling frequency */
Borislav Petkov54bb2072008-02-06 02:57:52 +0100179 unsigned long best_dsc_rw_freq;
180 unsigned long dsc_poll_freq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181 unsigned long dsc_timeout;
182
Borislav Petkov3c98bf32008-02-06 02:57:53 +0100183 /* Read position information */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184 u8 partition;
185 /* Current block */
Borislav Petkov54bb2072008-02-06 02:57:52 +0100186 unsigned int first_frame;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187
Borislav Petkov3c98bf32008-02-06 02:57:53 +0100188 /* Last error information */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 u8 sense_key, asc, ascq;
190
Borislav Petkov3c98bf32008-02-06 02:57:53 +0100191 /* Character device operation */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 unsigned int minor;
193 /* device name */
194 char name[4];
195 /* Current character device data transfer direction */
Borislav Petkov54abf372008-02-06 02:57:52 +0100196 u8 chrdev_dir;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197
Borislav Petkov54bb2072008-02-06 02:57:52 +0100198 /* tape block size, usually 512 or 1024 bytes */
199 unsigned short blk_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200 int user_bs_factor;
Borislav Petkovb6422012008-02-02 19:56:49 +0100201
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202 /* Copy of the tape's Capabilities and Mechanical Page */
Borislav Petkovb6422012008-02-02 19:56:49 +0100203 u8 caps[20];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204
205 /*
Borislav Petkov3c98bf32008-02-06 02:57:53 +0100206 * Active data transfer request parameters.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 *
Borislav Petkov3c98bf32008-02-06 02:57:53 +0100208 * At most, there is only one ide-tape originated data transfer request
209 * in the device request queue. This allows ide.c to easily service
210 * requests from the other device when we postpone our active request.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 */
Borislav Petkov83042b22008-04-27 15:38:27 +0200212
Borislav Petkov3c98bf32008-02-06 02:57:53 +0100213 /* Data buffer size chosen based on the tape's recommendation */
Borislav Petkovf73850a2008-04-27 15:38:33 +0200214 int buffer_size;
Tejun Heo963da552009-04-19 08:46:02 +0900215 /* Staging buffer of buffer_size bytes */
216 void *buf;
217 /* The read/write cursor */
218 void *cur;
219 /* The number of valid bytes in buf */
220 size_t valid;
Borislav Petkov3c98bf32008-02-06 02:57:53 +0100221
Borislav Petkov3c98bf32008-02-06 02:57:53 +0100222 /* Measures average tape speed */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223 unsigned long avg_time;
224 int avg_size;
225 int avg_speed;
226
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227 /* the door is currently locked */
228 int door_locked;
229 /* the tape hardware is write protected */
230 char drv_write_prot;
231 /* the tape is write protected (hardware or opened as read-only) */
232 char write_prot;
233
Borislav Petkov8004a8c2008-02-06 02:57:51 +0100234 u32 debug_mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235} idetape_tape_t;
236
Arjan van de Vencf8b8972006-03-23 03:00:45 -0800237static DEFINE_MUTEX(idetape_ref_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238
Will Dysond5dee802005-09-16 02:55:07 -0700239static struct class *idetape_sysfs_class;
240
Bartlomiej Zolnierkiewicz8fed4362009-02-25 20:28:24 +0100241static void ide_tape_release(struct device *);
Bartlomiej Zolnierkiewicz08da5912008-07-24 22:53:15 +0200242
Borislav Petkov9d01e4c2009-06-08 22:03:03 +0200243static struct ide_tape_obj *idetape_devs[MAX_HWIFS * MAX_DRIVES];
244
245static struct ide_tape_obj *ide_tape_get(struct gendisk *disk, bool cdev,
246 unsigned int i)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247{
248 struct ide_tape_obj *tape = NULL;
249
Arjan van de Vencf8b8972006-03-23 03:00:45 -0800250 mutex_lock(&idetape_ref_mutex);
Borislav Petkov9d01e4c2009-06-08 22:03:03 +0200251
252 if (cdev)
253 tape = idetape_devs[i];
254 else
255 tape = ide_drv_g(disk, ide_tape_obj);
256
Bartlomiej Zolnierkiewicz08da5912008-07-24 22:53:15 +0200257 if (tape) {
Bartlomiej Zolnierkiewiczd3e33ff2008-08-05 18:16:59 +0200258 if (ide_device_get(tape->drive))
Bartlomiej Zolnierkiewicz08da5912008-07-24 22:53:15 +0200259 tape = NULL;
Bartlomiej Zolnierkiewiczd3e33ff2008-08-05 18:16:59 +0200260 else
Bartlomiej Zolnierkiewicz8fed4362009-02-25 20:28:24 +0100261 get_device(&tape->dev);
Bartlomiej Zolnierkiewicz08da5912008-07-24 22:53:15 +0200262 }
Borislav Petkov9d01e4c2009-06-08 22:03:03 +0200263
Arjan van de Vencf8b8972006-03-23 03:00:45 -0800264 mutex_unlock(&idetape_ref_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265 return tape;
266}
267
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268static void ide_tape_put(struct ide_tape_obj *tape)
269{
Bartlomiej Zolnierkiewiczd3e33ff2008-08-05 18:16:59 +0200270 ide_drive_t *drive = tape->drive;
271
Arjan van de Vencf8b8972006-03-23 03:00:45 -0800272 mutex_lock(&idetape_ref_mutex);
Bartlomiej Zolnierkiewicz8fed4362009-02-25 20:28:24 +0100273 put_device(&tape->dev);
Bartlomiej Zolnierkiewiczd3e33ff2008-08-05 18:16:59 +0200274 ide_device_put(drive);
Arjan van de Vencf8b8972006-03-23 03:00:45 -0800275 mutex_unlock(&idetape_ref_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276}
277
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278/*
Borislav Petkov1b5db432008-02-02 19:56:48 +0100279 * called on each failed packet command retry to analyze the request sense. We
280 * currently do not utilize this information.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 */
Borislav Petkovae3a8382009-05-02 10:58:17 +0200282static void idetape_analyze_error(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283{
284 idetape_tape_t *tape = drive->driver_data;
Bartlomiej Zolnierkiewicz5e2040fd2009-03-27 12:46:34 +0100285 struct ide_atapi_pc *pc = drive->failed_pc;
Borislav Petkovdfb7e622009-05-01 20:35:21 +0200286 struct request *rq = drive->hwif->rq;
Borislav Petkovae3a8382009-05-02 10:58:17 +0200287 u8 *sense = bio_data(rq->bio);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288
Borislav Petkov1b5db432008-02-02 19:56:48 +0100289 tape->sense_key = sense[2] & 0xF;
290 tape->asc = sense[12];
291 tape->ascq = sense[13];
Borislav Petkov8004a8c2008-02-06 02:57:51 +0100292
293 debug_log(DBG_ERR, "pc = %x, sense key = %x, asc = %x, ascq = %x\n",
294 pc->c[0], tape->sense_key, tape->asc, tape->ascq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295
Borislav Petkov077e6db2009-05-01 21:21:02 +0200296 /* correct remaining bytes to transfer */
Tejun Heo21d9c5d2009-04-19 08:46:02 +0900297 if (pc->flags & PC_FLAG_DMA_ERROR)
Borislav Petkov077e6db2009-05-01 21:21:02 +0200298 rq->resid_len = tape->blk_size * get_unaligned_be32(&sense[3]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299
300 /*
301 * If error was the result of a zero-length read or write command,
302 * with sense key=5, asc=0x22, ascq=0, let it slide. Some drives
303 * (i.e. Seagate STT3401A Travan) don't support 0-length read/writes.
304 */
Borislav Petkov90699ce2008-02-02 19:56:50 +0100305 if ((pc->c[0] == READ_6 || pc->c[0] == WRITE_6)
Borislav Petkov1b5db432008-02-02 19:56:48 +0100306 /* length == 0 */
307 && pc->c[4] == 0 && pc->c[3] == 0 && pc->c[2] == 0) {
308 if (tape->sense_key == 5) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309 /* don't report an error, everything's ok */
310 pc->error = 0;
311 /* don't retry read/write */
Borislav Petkov346331f2008-04-18 00:46:26 +0200312 pc->flags |= PC_FLAG_ABORT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 }
314 }
Borislav Petkov90699ce2008-02-02 19:56:50 +0100315 if (pc->c[0] == READ_6 && (sense[2] & 0x80)) {
Bartlomiej Zolnierkiewiczc152cc12009-03-27 12:46:34 +0100316 pc->error = IDE_DRV_ERROR_FILEMARK;
Borislav Petkov346331f2008-04-18 00:46:26 +0200317 pc->flags |= PC_FLAG_ABORT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 }
Borislav Petkov90699ce2008-02-02 19:56:50 +0100319 if (pc->c[0] == WRITE_6) {
Borislav Petkov1b5db432008-02-02 19:56:48 +0100320 if ((sense[2] & 0x40) || (tape->sense_key == 0xd
321 && tape->asc == 0x0 && tape->ascq == 0x2)) {
Bartlomiej Zolnierkiewiczc152cc12009-03-27 12:46:34 +0100322 pc->error = IDE_DRV_ERROR_EOD;
Borislav Petkov346331f2008-04-18 00:46:26 +0200323 pc->flags |= PC_FLAG_ABORT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324 }
325 }
Borislav Petkov90699ce2008-02-02 19:56:50 +0100326 if (pc->c[0] == READ_6 || pc->c[0] == WRITE_6) {
Borislav Petkov1b5db432008-02-02 19:56:48 +0100327 if (tape->sense_key == 8) {
Bartlomiej Zolnierkiewiczc152cc12009-03-27 12:46:34 +0100328 pc->error = IDE_DRV_ERROR_EOD;
Borislav Petkov346331f2008-04-18 00:46:26 +0200329 pc->flags |= PC_FLAG_ABORT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330 }
Borislav Petkov346331f2008-04-18 00:46:26 +0200331 if (!(pc->flags & PC_FLAG_ABORT) &&
Borislav Petkov077e6db2009-05-01 21:21:02 +0200332 (blk_rq_bytes(rq) - rq->resid_len))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333 pc->retries = IDETAPE_MAX_PC_RETRIES + 1;
334 }
335}
336
Bartlomiej Zolnierkiewiczb14c7212008-10-13 21:39:30 +0200337static void ide_tape_handle_dsc(ide_drive_t *);
338
Bartlomiej Zolnierkiewicz03a2faa2009-03-27 12:46:36 +0100339static int ide_tape_callback(ide_drive_t *drive, int dsc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340{
341 idetape_tape_t *tape = drive->driver_data;
Bartlomiej Zolnierkiewicz2b9efba2008-10-13 21:39:31 +0200342 struct ide_atapi_pc *pc = drive->pc;
Bartlomiej Zolnierkiewicz313afea2009-03-27 12:46:34 +0100343 struct request *rq = drive->hwif->rq;
Bartlomiej Zolnierkiewicz5985e6a2008-07-15 21:21:55 +0200344 int uptodate = pc->error ? 0 : 1;
Bartlomiej Zolnierkiewicz313afea2009-03-27 12:46:34 +0100345 int err = uptodate ? 0 : IDE_DRV_ERROR_GENERAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346
Borislav Petkov8004a8c2008-02-06 02:57:51 +0100347 debug_log(DBG_PROCS, "Enter %s\n", __func__);
348
Bartlomiej Zolnierkiewiczb14c7212008-10-13 21:39:30 +0200349 if (dsc)
350 ide_tape_handle_dsc(drive);
351
Bartlomiej Zolnierkiewicz5e2040fd2009-03-27 12:46:34 +0100352 if (drive->failed_pc == pc)
353 drive->failed_pc = NULL;
Bartlomiej Zolnierkiewiczdd2e9a02008-07-15 21:22:01 +0200354
Bartlomiej Zolnierkiewicz5985e6a2008-07-15 21:21:55 +0200355 if (pc->c[0] == REQUEST_SENSE) {
356 if (uptodate)
Borislav Petkovae3a8382009-05-02 10:58:17 +0200357 idetape_analyze_error(drive);
Bartlomiej Zolnierkiewicz5985e6a2008-07-15 21:21:55 +0200358 else
359 printk(KERN_ERR "ide-tape: Error in REQUEST SENSE "
360 "itself - Aborting request!\n");
361 } else if (pc->c[0] == READ_6 || pc->c[0] == WRITE_6) {
Borislav Petkov077e6db2009-05-01 21:21:02 +0200362 unsigned int blocks =
363 (blk_rq_bytes(rq) - rq->resid_len) / tape->blk_size;
Bartlomiej Zolnierkiewicz5985e6a2008-07-15 21:21:55 +0200364
365 tape->avg_size += blocks * tape->blk_size;
366
367 if (time_after_eq(jiffies, tape->avg_time + HZ)) {
368 tape->avg_speed = tape->avg_size * HZ /
369 (jiffies - tape->avg_time) / 1024;
370 tape->avg_size = 0;
371 tape->avg_time = jiffies;
372 }
373
374 tape->first_frame += blocks;
Bartlomiej Zolnierkiewicz5985e6a2008-07-15 21:21:55 +0200375
Bartlomiej Zolnierkiewicz313afea2009-03-27 12:46:34 +0100376 if (pc->error) {
377 uptodate = 0;
378 err = pc->error;
379 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 }
Bartlomiej Zolnierkiewicz313afea2009-03-27 12:46:34 +0100381 rq->errors = err;
382
Bartlomiej Zolnierkiewicz03a2faa2009-03-27 12:46:36 +0100383 return uptodate;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384}
385
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386/*
Borislav Petkov3c98bf32008-02-06 02:57:53 +0100387 * Postpone the current request so that ide.c will be able to service requests
Bartlomiej Zolnierkiewiczb65fac32009-01-06 17:20:50 +0100388 * from another device on the same port while we are polling for DSC.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389 */
Borislav Petkov5a04cfa2008-02-06 02:57:54 +0100390static void idetape_postpone_request(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391{
392 idetape_tape_t *tape = drive->driver_data;
393
Borislav Petkov8004a8c2008-02-06 02:57:51 +0100394 debug_log(DBG_PROCS, "Enter %s\n", __func__);
395
Bartlomiej Zolnierkiewiczb65fac32009-01-06 17:20:50 +0100396 tape->postponed_rq = drive->hwif->rq;
397
Borislav Petkov54bb2072008-02-06 02:57:52 +0100398 ide_stall_queue(drive, tape->dsc_poll_freq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399}
400
Bartlomiej Zolnierkiewicz74e63e742008-07-15 21:22:01 +0200401static void ide_tape_handle_dsc(ide_drive_t *drive)
402{
403 idetape_tape_t *tape = drive->driver_data;
404
405 /* Media access command */
406 tape->dsc_polling_start = jiffies;
407 tape->dsc_poll_freq = IDETAPE_DSC_MA_FAST;
408 tape->dsc_timeout = jiffies + IDETAPE_DSC_MA_TIMEOUT;
409 /* Allow ide.c to handle other requests */
410 idetape_postpone_request(drive);
411}
412
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413/*
Borislav Petkov3c98bf32008-02-06 02:57:53 +0100414 * Packet Command Interface
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 *
Bartlomiej Zolnierkiewicz2b9efba2008-10-13 21:39:31 +0200416 * The current Packet Command is available in drive->pc, and will not change
Borislav Petkov3c98bf32008-02-06 02:57:53 +0100417 * until we finish handling it. Each packet command is associated with a
418 * callback function that will be called when the command is finished.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 *
Borislav Petkov3c98bf32008-02-06 02:57:53 +0100420 * The handling will be done in three stages:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 *
Bartlomiej Zolnierkiewiczb788ee92009-03-27 12:46:46 +0100422 * 1. ide_tape_issue_pc will send the packet command to the drive, and will set
Bartlomiej Zolnierkiewiczaa5d2de72008-10-13 21:39:32 +0200423 * the interrupt handler to ide_pc_intr.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 *
Bartlomiej Zolnierkiewiczaa5d2de72008-10-13 21:39:32 +0200425 * 2. On each interrupt, ide_pc_intr will be called. This step will be
Borislav Petkov3c98bf32008-02-06 02:57:53 +0100426 * repeated until the device signals us that no more interrupts will be issued.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 *
Borislav Petkov3c98bf32008-02-06 02:57:53 +0100428 * 3. ATAPI Tape media access commands have immediate status with a delayed
429 * process. In case of a successful initiation of a media access packet command,
430 * the DSC bit will be set when the actual execution of the command is finished.
431 * Since the tape drive will not issue an interrupt, we have to poll for this
432 * event. In this case, we define the request as "low priority request" by
433 * setting rq_status to IDETAPE_RQ_POSTPONED, set a timer to poll for DSC and
434 * exit the driver.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 *
Borislav Petkov3c98bf32008-02-06 02:57:53 +0100436 * ide.c will then give higher priority to requests which originate from the
437 * other device, until will change rq_status to RQ_ACTIVE.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 *
Borislav Petkov3c98bf32008-02-06 02:57:53 +0100439 * 4. When the packet command is finished, it will be checked for errors.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 *
Borislav Petkov3c98bf32008-02-06 02:57:53 +0100441 * 5. In case an error was found, we queue a request sense packet command in
442 * front of the request queue and retry the operation up to
443 * IDETAPE_MAX_PC_RETRIES times.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 *
Borislav Petkov3c98bf32008-02-06 02:57:53 +0100445 * 6. In case no error was found, or we decided to give up and not to retry
446 * again, the callback function will be called and then we will handle the next
447 * request.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449
Bartlomiej Zolnierkiewiczb788ee92009-03-27 12:46:46 +0100450static ide_startstop_t ide_tape_issue_pc(ide_drive_t *drive,
451 struct ide_cmd *cmd,
452 struct ide_atapi_pc *pc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 idetape_tape_t *tape = drive->driver_data;
Borislav Petkovdfb7e622009-05-01 20:35:21 +0200455 struct request *rq = drive->hwif->rq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456
Bartlomiej Zolnierkiewicz5e2040fd2009-03-27 12:46:34 +0100457 if (drive->failed_pc == NULL && pc->c[0] != REQUEST_SENSE)
458 drive->failed_pc = pc;
Bartlomiej Zolnierkiewicz2b9efba2008-10-13 21:39:31 +0200459
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 /* Set the current packet command */
Bartlomiej Zolnierkiewicz2b9efba2008-10-13 21:39:31 +0200461 drive->pc = pc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462
463 if (pc->retries > IDETAPE_MAX_PC_RETRIES ||
Borislav Petkov346331f2008-04-18 00:46:26 +0200464 (pc->flags & PC_FLAG_ABORT)) {
Tejun Heob3071d12009-04-19 08:46:02 +0900465
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466 /*
Borislav Petkov3c98bf32008-02-06 02:57:53 +0100467 * We will "abort" retrying a packet command in case legitimate
468 * error code was received (crossing a filemark, or end of the
469 * media, for example).
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470 */
Borislav Petkov346331f2008-04-18 00:46:26 +0200471 if (!(pc->flags & PC_FLAG_ABORT)) {
Borislav Petkov90699ce2008-02-02 19:56:50 +0100472 if (!(pc->c[0] == TEST_UNIT_READY &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473 tape->sense_key == 2 && tape->asc == 4 &&
474 (tape->ascq == 1 || tape->ascq == 8))) {
475 printk(KERN_ERR "ide-tape: %s: I/O error, "
476 "pc = %2x, key = %2x, "
477 "asc = %2x, ascq = %2x\n",
478 tape->name, pc->c[0],
479 tape->sense_key, tape->asc,
480 tape->ascq);
481 }
482 /* Giving up */
Bartlomiej Zolnierkiewiczc152cc12009-03-27 12:46:34 +0100483 pc->error = IDE_DRV_ERROR_GENERAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 }
Tejun Heob3071d12009-04-19 08:46:02 +0900485
Bartlomiej Zolnierkiewicz5e2040fd2009-03-27 12:46:34 +0100486 drive->failed_pc = NULL;
Bartlomiej Zolnierkiewiczb14c7212008-10-13 21:39:30 +0200487 drive->pc_callback(drive, 0);
Borislav Petkovdfb7e622009-05-01 20:35:21 +0200488 ide_complete_rq(drive, -EIO, blk_rq_bytes(rq));
Bartlomiej Zolnierkiewicz92f5daf2008-07-15 21:21:55 +0200489 return ide_stopped;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490 }
Borislav Petkov8004a8c2008-02-06 02:57:51 +0100491 debug_log(DBG_SENSE, "Retry #%d, cmd = %02X\n", pc->retries, pc->c[0]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492
493 pc->retries++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494
Bartlomiej Zolnierkiewiczb788ee92009-03-27 12:46:46 +0100495 return ide_issue_pc(drive, cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496}
497
Borislav Petkov3c98bf32008-02-06 02:57:53 +0100498/* A mode sense command is used to "sense" tape parameters. */
Borislav Petkovd236d742008-04-18 00:46:27 +0200499static void idetape_create_mode_sense_cmd(struct ide_atapi_pc *pc, u8 page_code)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500{
Bartlomiej Zolnierkiewicz7bf74202008-10-10 22:39:37 +0200501 ide_init_pc(pc);
Borislav Petkov90699ce2008-02-02 19:56:50 +0100502 pc->c[0] = MODE_SENSE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503 if (page_code != IDETAPE_BLOCK_DESCRIPTOR)
Borislav Petkov3c98bf32008-02-06 02:57:53 +0100504 /* DBD = 1 - Don't return block descriptors */
505 pc->c[1] = 8;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 pc->c[2] = page_code;
507 /*
508 * Changed pc->c[3] to 0 (255 will at best return unused info).
509 *
510 * For SCSI this byte is defined as subpage instead of high byte
511 * of length and some IDE drives seem to interpret it this way
512 * and return an error when 255 is used.
513 */
514 pc->c[3] = 0;
Borislav Petkov3c98bf32008-02-06 02:57:53 +0100515 /* We will just discard data in that case */
516 pc->c[4] = 255;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517 if (page_code == IDETAPE_BLOCK_DESCRIPTOR)
Borislav Petkovd236d742008-04-18 00:46:27 +0200518 pc->req_xfer = 12;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519 else if (page_code == IDETAPE_CAPABILITIES_PAGE)
Borislav Petkovd236d742008-04-18 00:46:27 +0200520 pc->req_xfer = 24;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 else
Borislav Petkovd236d742008-04-18 00:46:27 +0200522 pc->req_xfer = 50;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523}
524
Borislav Petkov5a04cfa2008-02-06 02:57:54 +0100525static ide_startstop_t idetape_media_access_finished(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526{
Bartlomiej Zolnierkiewiczb73c7ee2008-07-23 19:55:52 +0200527 ide_hwif_t *hwif = drive->hwif;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528 idetape_tape_t *tape = drive->driver_data;
Bartlomiej Zolnierkiewicz2b9efba2008-10-13 21:39:31 +0200529 struct ide_atapi_pc *pc = drive->pc;
Bartlomiej Zolnierkiewicz22c525b2008-01-25 22:17:11 +0100530 u8 stat;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531
Bartlomiej Zolnierkiewicz374e0422008-07-23 19:55:56 +0200532 stat = hwif->tp_ops->read_status(hwif);
Bartlomiej Zolnierkiewiczc47137a2008-02-06 02:57:51 +0100533
Bartlomiej Zolnierkiewicz3a7d2482008-10-10 22:39:21 +0200534 if (stat & ATA_DSC) {
535 if (stat & ATA_ERR) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 /* Error detected */
Borislav Petkov90699ce2008-02-02 19:56:50 +0100537 if (pc->c[0] != TEST_UNIT_READY)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 printk(KERN_ERR "ide-tape: %s: I/O error, ",
539 tape->name);
540 /* Retry operation */
Borislav Petkov6b544fc2009-04-19 07:00:42 +0900541 ide_retry_pc(drive);
Bartlomiej Zolnierkiewicz258ec412008-07-15 21:21:55 +0200542 return ide_stopped;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 }
544 pc->error = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545 } else {
Bartlomiej Zolnierkiewiczc152cc12009-03-27 12:46:34 +0100546 pc->error = IDE_DRV_ERROR_GENERAL;
Bartlomiej Zolnierkiewicz5e2040fd2009-03-27 12:46:34 +0100547 drive->failed_pc = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548 }
Bartlomiej Zolnierkiewiczb14c7212008-10-13 21:39:30 +0200549 drive->pc_callback(drive, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550 return ide_stopped;
551}
552
Borislav Petkovcd2abbf2008-07-15 21:22:03 +0200553static void ide_tape_create_rw_cmd(idetape_tape_t *tape,
Borislav Petkov0014c752008-07-23 19:56:00 +0200554 struct ide_atapi_pc *pc, struct request *rq,
555 u8 opcode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556{
Borislav Petkov10c0b342009-05-01 20:29:53 +0200557 unsigned int length = blk_rq_sectors(rq) / (tape->blk_size >> 9);
Borislav Petkov0014c752008-07-23 19:56:00 +0200558
Bartlomiej Zolnierkiewicz7bf74202008-10-10 22:39:37 +0200559 ide_init_pc(pc);
Borislav Petkov860ff5e2008-02-02 19:56:50 +0100560 put_unaligned(cpu_to_be32(length), (unsigned int *) &pc->c[1]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561 pc->c[1] = 1;
Borislav Petkov19f52a72009-05-04 09:53:03 +0200562
563 if (blk_rq_bytes(rq) == tape->buffer_size)
Bartlomiej Zolnierkiewicz5e331092008-07-15 21:21:56 +0200564 pc->flags |= PC_FLAG_DMA_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565
Tejun Heo963da552009-04-19 08:46:02 +0900566 if (opcode == READ_6)
Borislav Petkovcd2abbf2008-07-15 21:22:03 +0200567 pc->c[0] = READ_6;
Tejun Heo963da552009-04-19 08:46:02 +0900568 else if (opcode == WRITE_6) {
Borislav Petkovcd2abbf2008-07-15 21:22:03 +0200569 pc->c[0] = WRITE_6;
570 pc->flags |= PC_FLAG_WRITING;
Borislav Petkovcd2abbf2008-07-15 21:22:03 +0200571 }
Borislav Petkov0014c752008-07-23 19:56:00 +0200572
573 memcpy(rq->cmd, pc->c, 12);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574}
575
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576static ide_startstop_t idetape_do_request(ide_drive_t *drive,
577 struct request *rq, sector_t block)
578{
Bartlomiej Zolnierkiewiczb73c7ee2008-07-23 19:55:52 +0200579 ide_hwif_t *hwif = drive->hwif;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580 idetape_tape_t *tape = drive->driver_data;
Borislav Petkovd236d742008-04-18 00:46:27 +0200581 struct ide_atapi_pc *pc = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 struct request *postponed_rq = tape->postponed_rq;
Bartlomiej Zolnierkiewiczb788ee92009-03-27 12:46:46 +0100583 struct ide_cmd cmd;
Bartlomiej Zolnierkiewicz22c525b2008-01-25 22:17:11 +0100584 u8 stat;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585
Tejun Heo9780e2d2009-05-07 22:24:40 +0900586 debug_log(DBG_SENSE, "sector: %llu, nr_sectors: %u\n"
587 (unsigned long long)blk_rq_pos(rq), blk_rq_sectors(rq));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588
Bartlomiej Zolnierkiewicz2c7eaa42009-06-15 22:16:10 +0200589 BUG_ON(!(blk_special_request(rq) || blk_sense_request(rq)));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590
Borislav Petkov3c98bf32008-02-06 02:57:53 +0100591 /* Retry a failed packet command */
Bartlomiej Zolnierkiewicz5e2040fd2009-03-27 12:46:34 +0100592 if (drive->failed_pc && drive->pc->c[0] == REQUEST_SENSE) {
593 pc = drive->failed_pc;
Bartlomiej Zolnierkiewicz28c72142008-07-15 21:21:59 +0200594 goto out;
595 }
Borislav Petkov5a04cfa2008-02-06 02:57:54 +0100596
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 if (postponed_rq != NULL)
598 if (rq != postponed_rq) {
599 printk(KERN_ERR "ide-tape: ide-tape.c bug - "
600 "Two DSC requests were queued\n");
Bartlomiej Zolnierkiewicz313afea2009-03-27 12:46:34 +0100601 drive->failed_pc = NULL;
Bartlomiej Zolnierkiewicz6902a532009-03-27 12:46:43 +0100602 rq->errors = 0;
Bartlomiej Zolnierkiewiczf974b192009-03-27 12:46:44 +0100603 ide_complete_rq(drive, 0, blk_rq_bytes(rq));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604 return ide_stopped;
605 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606
607 tape->postponed_rq = NULL;
608
609 /*
610 * If the tape is still busy, postpone our request and service
611 * the other device meanwhile.
612 */
Bartlomiej Zolnierkiewicz374e0422008-07-23 19:55:56 +0200613 stat = hwif->tp_ops->read_status(hwif);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200615 if ((drive->dev_flags & IDE_DFLAG_DSC_OVERLAP) == 0 &&
616 (rq->cmd[13] & REQ_IDETAPE_PC2) == 0)
Borislav Petkov626542c2009-06-07 15:37:05 +0200617 drive->atapi_flags |= IDE_AFLAG_IGNORE_DSC;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200619 if (drive->dev_flags & IDE_DFLAG_POST_RESET) {
Borislav Petkov626542c2009-06-07 15:37:05 +0200620 drive->atapi_flags |= IDE_AFLAG_IGNORE_DSC;
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200621 drive->dev_flags &= ~IDE_DFLAG_POST_RESET;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622 }
623
Borislav Petkov626542c2009-06-07 15:37:05 +0200624 if (!(drive->atapi_flags & IDE_AFLAG_IGNORE_DSC) &&
625 !(stat & ATA_DSC)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626 if (postponed_rq == NULL) {
627 tape->dsc_polling_start = jiffies;
Borislav Petkov54bb2072008-02-06 02:57:52 +0100628 tape->dsc_poll_freq = tape->best_dsc_rw_freq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629 tape->dsc_timeout = jiffies + IDETAPE_DSC_RW_TIMEOUT;
630 } else if (time_after(jiffies, tape->dsc_timeout)) {
631 printk(KERN_ERR "ide-tape: %s: DSC timeout\n",
632 tape->name);
Borislav Petkov83dd5732008-07-23 19:56:00 +0200633 if (rq->cmd[13] & REQ_IDETAPE_PC2) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634 idetape_media_access_finished(drive);
635 return ide_stopped;
636 } else {
637 return ide_do_reset(drive);
638 }
Borislav Petkov5a04cfa2008-02-06 02:57:54 +0100639 } else if (time_after(jiffies,
640 tape->dsc_polling_start +
641 IDETAPE_DSC_MA_THRESHOLD))
Borislav Petkov54bb2072008-02-06 02:57:52 +0100642 tape->dsc_poll_freq = IDETAPE_DSC_MA_SLOW;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643 idetape_postpone_request(drive);
644 return ide_stopped;
Borislav Petkov626542c2009-06-07 15:37:05 +0200645 } else
646 drive->atapi_flags &= ~IDE_AFLAG_IGNORE_DSC;
647
Borislav Petkov83dd5732008-07-23 19:56:00 +0200648 if (rq->cmd[13] & REQ_IDETAPE_READ) {
Bartlomiej Zolnierkiewicz2e8a6f82008-10-10 22:39:36 +0200649 pc = &tape->queued_pc;
Borislav Petkov0014c752008-07-23 19:56:00 +0200650 ide_tape_create_rw_cmd(tape, pc, rq, READ_6);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 goto out;
652 }
Borislav Petkov83dd5732008-07-23 19:56:00 +0200653 if (rq->cmd[13] & REQ_IDETAPE_WRITE) {
Bartlomiej Zolnierkiewicz2e8a6f82008-10-10 22:39:36 +0200654 pc = &tape->queued_pc;
Borislav Petkov0014c752008-07-23 19:56:00 +0200655 ide_tape_create_rw_cmd(tape, pc, rq, WRITE_6);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 goto out;
657 }
Borislav Petkov83dd5732008-07-23 19:56:00 +0200658 if (rq->cmd[13] & REQ_IDETAPE_PC1) {
Tejun Heoc267cc12009-04-19 07:00:42 +0900659 pc = (struct ide_atapi_pc *)rq->special;
Borislav Petkov83dd5732008-07-23 19:56:00 +0200660 rq->cmd[13] &= ~(REQ_IDETAPE_PC1);
661 rq->cmd[13] |= REQ_IDETAPE_PC2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662 goto out;
663 }
Borislav Petkov83dd5732008-07-23 19:56:00 +0200664 if (rq->cmd[13] & REQ_IDETAPE_PC2) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 idetape_media_access_finished(drive);
666 return ide_stopped;
667 }
668 BUG();
Bartlomiej Zolnierkiewicz28c72142008-07-15 21:21:59 +0200669
Borislav Petkovf2e3ab52008-07-23 19:56:01 +0200670out:
Borislav Petkov6b544fc2009-04-19 07:00:42 +0900671 /* prepare sense request for this command */
672 ide_prep_sense(drive, rq);
673
Bartlomiej Zolnierkiewiczb788ee92009-03-27 12:46:46 +0100674 memset(&cmd, 0, sizeof(cmd));
675
676 if (rq_data_dir(rq))
677 cmd.tf_flags |= IDE_TFLAG_WRITE;
678
679 cmd.rq = rq;
680
Borislav Petkovdfb7e622009-05-01 20:35:21 +0200681 ide_init_sg_cmd(&cmd, blk_rq_bytes(rq));
Tejun Heo5c4be572009-04-19 07:00:42 +0900682 ide_map_sg(drive, &cmd);
683
Bartlomiej Zolnierkiewiczb788ee92009-03-27 12:46:46 +0100684 return ide_tape_issue_pc(drive, &cmd, pc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685}
686
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687/*
Borislav Petkov3c98bf32008-02-06 02:57:53 +0100688 * Write a filemark if write_filemark=1. Flush the device buffers without
689 * writing a filemark otherwise.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690 */
Borislav Petkov5a04cfa2008-02-06 02:57:54 +0100691static void idetape_create_write_filemark_cmd(ide_drive_t *drive,
Borislav Petkovd236d742008-04-18 00:46:27 +0200692 struct ide_atapi_pc *pc, int write_filemark)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693{
Bartlomiej Zolnierkiewicz7bf74202008-10-10 22:39:37 +0200694 ide_init_pc(pc);
Borislav Petkov90699ce2008-02-02 19:56:50 +0100695 pc->c[0] = WRITE_FILEMARKS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696 pc->c[4] = write_filemark;
Borislav Petkov346331f2008-04-18 00:46:26 +0200697 pc->flags |= PC_FLAG_WAIT_FOR_DSC;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698}
699
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700static int idetape_wait_ready(ide_drive_t *drive, unsigned long timeout)
701{
702 idetape_tape_t *tape = drive->driver_data;
Bartlomiej Zolnierkiewicz2ac07d92008-10-10 22:39:38 +0200703 struct gendisk *disk = tape->disk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704 int load_attempted = 0;
705
Borislav Petkov3c98bf32008-02-06 02:57:53 +0100706 /* Wait for the tape to become ready */
Borislav Petkov49d80782009-06-07 15:37:06 +0200707 set_bit(ilog2(IDE_AFLAG_MEDIUM_PRESENT), &drive->atapi_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708 timeout += jiffies;
709 while (time_before(jiffies, timeout)) {
Bartlomiej Zolnierkiewiczde699ad2008-10-10 22:39:39 +0200710 if (ide_do_test_unit_ready(drive, disk) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711 return 0;
712 if ((tape->sense_key == 2 && tape->asc == 4 && tape->ascq == 2)
Borislav Petkov3c98bf32008-02-06 02:57:53 +0100713 || (tape->asc == 0x3A)) {
714 /* no media */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715 if (load_attempted)
716 return -ENOMEDIUM;
Bartlomiej Zolnierkiewicz0c8a6c72008-10-10 22:39:39 +0200717 ide_do_start_stop(drive, disk, IDETAPE_LU_LOAD_MASK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718 load_attempted = 1;
719 /* not about to be ready */
720 } else if (!(tape->sense_key == 2 && tape->asc == 4 &&
721 (tape->ascq == 1 || tape->ascq == 8)))
722 return -EIO;
Nishanth Aravamudan80ce45f2005-09-10 00:27:08 -0700723 msleep(100);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724 }
725 return -EIO;
726}
727
Borislav Petkov5a04cfa2008-02-06 02:57:54 +0100728static int idetape_flush_tape_buffers(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729{
Bartlomiej Zolnierkiewicz2ac07d92008-10-10 22:39:38 +0200730 struct ide_tape_obj *tape = drive->driver_data;
Borislav Petkovd236d742008-04-18 00:46:27 +0200731 struct ide_atapi_pc pc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 int rc;
733
734 idetape_create_write_filemark_cmd(drive, &pc, 0);
Borislav Petkovb13345f2009-05-02 10:26:12 +0200735 rc = ide_queue_pc_tail(drive, tape->disk, &pc, NULL, 0);
Borislav Petkov5a04cfa2008-02-06 02:57:54 +0100736 if (rc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737 return rc;
738 idetape_wait_ready(drive, 60 * 5 * HZ);
739 return 0;
740}
741
Borislav Petkov55ce3a12009-05-04 09:38:15 +0200742static int ide_tape_read_position(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743{
744 idetape_tape_t *tape = drive->driver_data;
Borislav Petkovd236d742008-04-18 00:46:27 +0200745 struct ide_atapi_pc pc;
Borislav Petkov55ce3a12009-05-04 09:38:15 +0200746 u8 buf[20];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747
Borislav Petkov8004a8c2008-02-06 02:57:51 +0100748 debug_log(DBG_PROCS, "Enter %s\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749
Borislav Petkov55ce3a12009-05-04 09:38:15 +0200750 /* prep cmd */
751 ide_init_pc(&pc);
752 pc.c[0] = READ_POSITION;
753 pc.req_xfer = 20;
754
755 if (ide_queue_pc_tail(drive, tape->disk, &pc, buf, pc.req_xfer))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756 return -1;
Borislav Petkov55ce3a12009-05-04 09:38:15 +0200757
758 if (!pc.error) {
759 debug_log(DBG_SENSE, "BOP - %s\n",
760 (buf[0] & 0x80) ? "Yes" : "No");
761 debug_log(DBG_SENSE, "EOP - %s\n",
762 (buf[0] & 0x40) ? "Yes" : "No");
763
764 if (buf[0] & 0x4) {
765 printk(KERN_INFO "ide-tape: Block location is unknown"
766 "to the tape\n");
Bartlomiej Zolnierkiewicz8dcce402009-06-13 12:00:54 +0200767 clear_bit(ilog2(IDE_AFLAG_ADDRESS_VALID),
768 &drive->atapi_flags);
Borislav Petkov55ce3a12009-05-04 09:38:15 +0200769 return -1;
770 } else {
771 debug_log(DBG_SENSE, "Block Location - %u\n",
772 be32_to_cpup((__be32 *)&buf[4]));
773
774 tape->partition = buf[1];
775 tape->first_frame = be32_to_cpup((__be32 *)&buf[4]);
Bartlomiej Zolnierkiewicz8dcce402009-06-13 12:00:54 +0200776 set_bit(ilog2(IDE_AFLAG_ADDRESS_VALID),
777 &drive->atapi_flags);
Borislav Petkov55ce3a12009-05-04 09:38:15 +0200778 }
779 }
780
781 return tape->first_frame;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782}
783
Borislav Petkovd236d742008-04-18 00:46:27 +0200784static void idetape_create_locate_cmd(ide_drive_t *drive,
785 struct ide_atapi_pc *pc,
Borislav Petkov5a04cfa2008-02-06 02:57:54 +0100786 unsigned int block, u8 partition, int skip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787{
Bartlomiej Zolnierkiewicz7bf74202008-10-10 22:39:37 +0200788 ide_init_pc(pc);
Borislav Petkov90699ce2008-02-02 19:56:50 +0100789 pc->c[0] = POSITION_TO_ELEMENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790 pc->c[1] = 2;
Borislav Petkov860ff5e2008-02-02 19:56:50 +0100791 put_unaligned(cpu_to_be32(block), (unsigned int *) &pc->c[3]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792 pc->c[8] = partition;
Borislav Petkov346331f2008-04-18 00:46:26 +0200793 pc->flags |= PC_FLAG_WAIT_FOR_DSC;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794}
795
Borislav Petkovec0fdb02008-04-27 15:38:34 +0200796static void __ide_tape_discard_merge_buffer(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797{
798 idetape_tape_t *tape = drive->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799
Borislav Petkov54abf372008-02-06 02:57:52 +0100800 if (tape->chrdev_dir != IDETAPE_DIR_READ)
Borislav Petkov97986302008-04-27 15:38:34 +0200801 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802
Borislav Petkov49d80782009-06-07 15:37:06 +0200803 clear_bit(ilog2(IDE_AFLAG_FILEMARK), &drive->atapi_flags);
Tejun Heo963da552009-04-19 08:46:02 +0900804 tape->valid = 0;
805 if (tape->buf != NULL) {
806 kfree(tape->buf);
807 tape->buf = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808 }
809
Borislav Petkov54abf372008-02-06 02:57:52 +0100810 tape->chrdev_dir = IDETAPE_DIR_NONE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811}
812
813/*
Borislav Petkov3c98bf32008-02-06 02:57:53 +0100814 * Position the tape to the requested block using the LOCATE packet command.
815 * A READ POSITION command is then issued to check where we are positioned. Like
816 * all higher level operations, we queue the commands at the tail of the request
817 * queue and wait for their completion.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818 */
Borislav Petkov5a04cfa2008-02-06 02:57:54 +0100819static int idetape_position_tape(ide_drive_t *drive, unsigned int block,
820 u8 partition, int skip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821{
822 idetape_tape_t *tape = drive->driver_data;
Bartlomiej Zolnierkiewicz2ac07d92008-10-10 22:39:38 +0200823 struct gendisk *disk = tape->disk;
Borislav Petkov55ce3a12009-05-04 09:38:15 +0200824 int ret;
Borislav Petkovd236d742008-04-18 00:46:27 +0200825 struct ide_atapi_pc pc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826
Borislav Petkov54abf372008-02-06 02:57:52 +0100827 if (tape->chrdev_dir == IDETAPE_DIR_READ)
Borislav Petkovec0fdb02008-04-27 15:38:34 +0200828 __ide_tape_discard_merge_buffer(drive);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829 idetape_wait_ready(drive, 60 * 5 * HZ);
830 idetape_create_locate_cmd(drive, &pc, block, partition, skip);
Borislav Petkov55ce3a12009-05-04 09:38:15 +0200831 ret = ide_queue_pc_tail(drive, disk, &pc, NULL, 0);
832 if (ret)
833 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834
Borislav Petkov55ce3a12009-05-04 09:38:15 +0200835 ret = ide_tape_read_position(drive);
836 if (ret < 0)
837 return ret;
838 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839}
840
Borislav Petkovec0fdb02008-04-27 15:38:34 +0200841static void ide_tape_discard_merge_buffer(ide_drive_t *drive,
Borislav Petkov5a04cfa2008-02-06 02:57:54 +0100842 int restore_position)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843{
844 idetape_tape_t *tape = drive->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845 int seek, position;
846
Borislav Petkovec0fdb02008-04-27 15:38:34 +0200847 __ide_tape_discard_merge_buffer(drive);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848 if (restore_position) {
Borislav Petkov55ce3a12009-05-04 09:38:15 +0200849 position = ide_tape_read_position(drive);
Borislav Petkov97986302008-04-27 15:38:34 +0200850 seek = position > 0 ? position : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851 if (idetape_position_tape(drive, seek, 0, 0)) {
Borislav Petkov5a04cfa2008-02-06 02:57:54 +0100852 printk(KERN_INFO "ide-tape: %s: position_tape failed in"
Borislav Petkovec0fdb02008-04-27 15:38:34 +0200853 " %s\n", tape->name, __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700854 return;
855 }
856 }
857}
858
859/*
Borislav Petkov3c98bf32008-02-06 02:57:53 +0100860 * Generate a read/write request for the block device interface and wait for it
861 * to be serviced.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862 */
Tejun Heo6bb11dd2009-04-19 08:46:03 +0900863static int idetape_queue_rw_tail(ide_drive_t *drive, int cmd, int size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864{
865 idetape_tape_t *tape = drive->driver_data;
FUJITA Tomonori64ea1b42008-07-15 21:21:43 +0200866 struct request *rq;
Tejun Heo21d9c5d2009-04-19 08:46:02 +0900867 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868
Borislav Petkov8004a8c2008-02-06 02:57:51 +0100869 debug_log(DBG_SENSE, "%s: cmd=%d\n", __func__, cmd);
Tejun Heo21d9c5d2009-04-19 08:46:02 +0900870 BUG_ON(cmd != REQ_IDETAPE_READ && cmd != REQ_IDETAPE_WRITE);
Tejun Heo6bb11dd2009-04-19 08:46:03 +0900871 BUG_ON(size < 0 || size % tape->blk_size);
Borislav Petkov8004a8c2008-02-06 02:57:51 +0100872
FUJITA Tomonori64ea1b42008-07-15 21:21:43 +0200873 rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
874 rq->cmd_type = REQ_TYPE_SPECIAL;
Borislav Petkov83dd5732008-07-23 19:56:00 +0200875 rq->cmd[13] = cmd;
FUJITA Tomonori64ea1b42008-07-15 21:21:43 +0200876 rq->rq_disk = tape->disk;
Linus Torvaldsc9059592009-06-11 10:52:27 -0700877 rq->__sector = tape->first_frame;
Tejun Heo21d9c5d2009-04-19 08:46:02 +0900878
879 if (size) {
Tejun Heo963da552009-04-19 08:46:02 +0900880 ret = blk_rq_map_kern(drive->queue, rq, tape->buf, size,
Tejun Heo21d9c5d2009-04-19 08:46:02 +0900881 __GFP_WAIT);
882 if (ret)
883 goto out_put;
884 }
885
FUJITA Tomonori64ea1b42008-07-15 21:21:43 +0200886 blk_execute_rq(drive->queue, tape->disk, rq, 0);
887
Tejun Heo963da552009-04-19 08:46:02 +0900888 /* calculate the number of transferred bytes and update buffer state */
Tejun Heoc3a4d782009-05-07 22:24:37 +0900889 size -= rq->resid_len;
Tejun Heo963da552009-04-19 08:46:02 +0900890 tape->cur = tape->buf;
Tejun Heo21d9c5d2009-04-19 08:46:02 +0900891 if (cmd == REQ_IDETAPE_READ)
Tejun Heo963da552009-04-19 08:46:02 +0900892 tape->valid = size;
893 else
894 tape->valid = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895
Tejun Heo21d9c5d2009-04-19 08:46:02 +0900896 ret = size;
897 if (rq->errors == IDE_DRV_ERROR_GENERAL)
898 ret = -EIO;
Tejun Heo21d9c5d2009-04-19 08:46:02 +0900899out_put:
900 blk_put_request(rq);
FUJITA Tomonori64ea1b42008-07-15 21:21:43 +0200901 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902}
903
Borislav Petkovd236d742008-04-18 00:46:27 +0200904static void idetape_create_inquiry_cmd(struct ide_atapi_pc *pc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905{
Bartlomiej Zolnierkiewicz7bf74202008-10-10 22:39:37 +0200906 ide_init_pc(pc);
Borislav Petkov90699ce2008-02-02 19:56:50 +0100907 pc->c[0] = INQUIRY;
Borislav Petkov5a04cfa2008-02-06 02:57:54 +0100908 pc->c[4] = 254;
Borislav Petkovd236d742008-04-18 00:46:27 +0200909 pc->req_xfer = 254;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910}
911
Borislav Petkovd236d742008-04-18 00:46:27 +0200912static void idetape_create_rewind_cmd(ide_drive_t *drive,
913 struct ide_atapi_pc *pc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700914{
Bartlomiej Zolnierkiewicz7bf74202008-10-10 22:39:37 +0200915 ide_init_pc(pc);
Borislav Petkov90699ce2008-02-02 19:56:50 +0100916 pc->c[0] = REZERO_UNIT;
Borislav Petkov346331f2008-04-18 00:46:26 +0200917 pc->flags |= PC_FLAG_WAIT_FOR_DSC;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918}
919
Borislav Petkovd236d742008-04-18 00:46:27 +0200920static void idetape_create_erase_cmd(struct ide_atapi_pc *pc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921{
Bartlomiej Zolnierkiewicz7bf74202008-10-10 22:39:37 +0200922 ide_init_pc(pc);
Borislav Petkov90699ce2008-02-02 19:56:50 +0100923 pc->c[0] = ERASE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924 pc->c[1] = 1;
Borislav Petkov346331f2008-04-18 00:46:26 +0200925 pc->flags |= PC_FLAG_WAIT_FOR_DSC;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926}
927
Borislav Petkovd236d742008-04-18 00:46:27 +0200928static void idetape_create_space_cmd(struct ide_atapi_pc *pc, int count, u8 cmd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929{
Bartlomiej Zolnierkiewicz7bf74202008-10-10 22:39:37 +0200930 ide_init_pc(pc);
Borislav Petkov90699ce2008-02-02 19:56:50 +0100931 pc->c[0] = SPACE;
Borislav Petkov860ff5e2008-02-02 19:56:50 +0100932 put_unaligned(cpu_to_be32(count), (unsigned int *) &pc->c[1]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933 pc->c[1] = cmd;
Borislav Petkov346331f2008-04-18 00:46:26 +0200934 pc->flags |= PC_FLAG_WAIT_FOR_DSC;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935}
936
Borislav Petkovd9df9372008-04-27 15:38:34 +0200937static void ide_tape_flush_merge_buffer(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938{
939 idetape_tape_t *tape = drive->driver_data;
Borislav Petkov55a5d292008-02-02 19:56:49 +0100940
Borislav Petkov54abf372008-02-06 02:57:52 +0100941 if (tape->chrdev_dir != IDETAPE_DIR_WRITE) {
Borislav Petkov077e3bd2008-04-27 15:38:34 +0200942 printk(KERN_ERR "ide-tape: bug: Trying to empty merge buffer"
Borislav Petkov5a04cfa2008-02-06 02:57:54 +0100943 " but we are not writing.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944 return;
945 }
Tejun Heo963da552009-04-19 08:46:02 +0900946 if (tape->buf) {
Tejun Heo6bb11dd2009-04-19 08:46:03 +0900947 size_t aligned = roundup(tape->valid, tape->blk_size);
948
949 memset(tape->cur, 0, aligned - tape->valid);
Tejun Heo07bd9682009-04-19 08:46:03 +0900950 idetape_queue_rw_tail(drive, REQ_IDETAPE_WRITE, aligned);
Tejun Heo963da552009-04-19 08:46:02 +0900951 kfree(tape->buf);
952 tape->buf = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700953 }
Borislav Petkov54abf372008-02-06 02:57:52 +0100954 tape->chrdev_dir = IDETAPE_DIR_NONE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955}
956
Tejun Heo88f1b942009-04-19 08:46:02 +0900957static int idetape_init_rw(ide_drive_t *drive, int dir)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958{
959 idetape_tape_t *tape = drive->driver_data;
Tejun Heo88f1b942009-04-19 08:46:02 +0900960 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700961
Tejun Heo88f1b942009-04-19 08:46:02 +0900962 BUG_ON(dir != IDETAPE_DIR_READ && dir != IDETAPE_DIR_WRITE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963
Tejun Heo88f1b942009-04-19 08:46:02 +0900964 if (tape->chrdev_dir == dir)
965 return 0;
966
967 if (tape->chrdev_dir == IDETAPE_DIR_READ)
968 ide_tape_discard_merge_buffer(drive, 1);
969 else if (tape->chrdev_dir == IDETAPE_DIR_WRITE) {
970 ide_tape_flush_merge_buffer(drive);
971 idetape_flush_tape_buffers(drive);
972 }
973
974 if (tape->buf || tape->valid) {
975 printk(KERN_ERR "ide-tape: valid should be 0 now\n");
976 tape->valid = 0;
977 }
978
979 tape->buf = kmalloc(tape->buffer_size, GFP_KERNEL);
980 if (!tape->buf)
981 return -ENOMEM;
982 tape->chrdev_dir = dir;
983 tape->cur = tape->buf;
984
985 /*
986 * Issue a 0 rw command to ensure that DSC handshake is
987 * switched from completion mode to buffer available mode. No
988 * point in issuing this if DSC overlap isn't supported, some
989 * drives (Seagate STT3401A) will return an error.
990 */
991 if (drive->dev_flags & IDE_DFLAG_DSC_OVERLAP) {
992 int cmd = dir == IDETAPE_DIR_READ ? REQ_IDETAPE_READ
993 : REQ_IDETAPE_WRITE;
994
995 rc = idetape_queue_rw_tail(drive, cmd, 0);
996 if (rc < 0) {
997 kfree(tape->buf);
998 tape->buf = NULL;
999 tape->chrdev_dir = IDETAPE_DIR_NONE;
1000 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001 }
1002 }
Borislav Petkov5e69bd92008-04-27 15:38:25 +02001003
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004 return 0;
1005}
1006
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001007static void idetape_pad_zeros(ide_drive_t *drive, int bcount)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008{
1009 idetape_tape_t *tape = drive->driver_data;
Tejun Heo963da552009-04-19 08:46:02 +09001010
1011 memset(tape->buf, 0, tape->buffer_size);
Borislav Petkov3c98bf32008-02-06 02:57:53 +01001012
Linus Torvalds1da177e2005-04-16 15:20:36 -07001013 while (bcount) {
Tejun Heo963da552009-04-19 08:46:02 +09001014 unsigned int count = min(tape->buffer_size, bcount);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015
Tejun Heo6bb11dd2009-04-19 08:46:03 +09001016 idetape_queue_rw_tail(drive, REQ_IDETAPE_WRITE, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017 bcount -= count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018 }
1019}
1020
Linus Torvalds1da177e2005-04-16 15:20:36 -07001021/*
Borislav Petkov3c98bf32008-02-06 02:57:53 +01001022 * Rewinds the tape to the Beginning Of the current Partition (BOP). We
1023 * currently support only one partition.
1024 */
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001025static int idetape_rewind_tape(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026{
Bartlomiej Zolnierkiewicz2ac07d92008-10-10 22:39:38 +02001027 struct ide_tape_obj *tape = drive->driver_data;
1028 struct gendisk *disk = tape->disk;
Borislav Petkovd236d742008-04-18 00:46:27 +02001029 struct ide_atapi_pc pc;
Borislav Petkov55ce3a12009-05-04 09:38:15 +02001030 int ret;
Borislav Petkov8004a8c2008-02-06 02:57:51 +01001031
1032 debug_log(DBG_SENSE, "Enter %s\n", __func__);
1033
Linus Torvalds1da177e2005-04-16 15:20:36 -07001034 idetape_create_rewind_cmd(drive, &pc);
Borislav Petkov55ce3a12009-05-04 09:38:15 +02001035 ret = ide_queue_pc_tail(drive, disk, &pc, NULL, 0);
1036 if (ret)
1037 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038
Borislav Petkov55ce3a12009-05-04 09:38:15 +02001039 ret = ide_tape_read_position(drive);
1040 if (ret < 0)
1041 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001042 return 0;
1043}
1044
Borislav Petkov3c98bf32008-02-06 02:57:53 +01001045/* mtio.h compatible commands should be issued to the chrdev interface. */
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001046static int idetape_blkdev_ioctl(ide_drive_t *drive, unsigned int cmd,
1047 unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048{
1049 idetape_tape_t *tape = drive->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050 void __user *argp = (void __user *)arg;
1051
Borislav Petkovd59823f2008-02-02 19:56:51 +01001052 struct idetape_config {
1053 int dsc_rw_frequency;
1054 int dsc_media_access_frequency;
1055 int nr_stages;
1056 } config;
1057
Borislav Petkov8004a8c2008-02-06 02:57:51 +01001058 debug_log(DBG_PROCS, "Enter %s\n", __func__);
1059
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060 switch (cmd) {
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001061 case 0x0340:
1062 if (copy_from_user(&config, argp, sizeof(config)))
1063 return -EFAULT;
1064 tape->best_dsc_rw_freq = config.dsc_rw_frequency;
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001065 break;
1066 case 0x0350:
1067 config.dsc_rw_frequency = (int) tape->best_dsc_rw_freq;
Borislav Petkov83042b22008-04-27 15:38:27 +02001068 config.nr_stages = 1;
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001069 if (copy_to_user(argp, &config, sizeof(config)))
1070 return -EFAULT;
1071 break;
1072 default:
1073 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074 }
1075 return 0;
1076}
1077
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001078static int idetape_space_over_filemarks(ide_drive_t *drive, short mt_op,
1079 int mt_count)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080{
1081 idetape_tape_t *tape = drive->driver_data;
Bartlomiej Zolnierkiewicz2ac07d92008-10-10 22:39:38 +02001082 struct gendisk *disk = tape->disk;
Borislav Petkovd236d742008-04-18 00:46:27 +02001083 struct ide_atapi_pc pc;
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001084 int retval, count = 0;
Borislav Petkovb6422012008-02-02 19:56:49 +01001085 int sprev = !!(tape->caps[4] & 0x20);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001086
1087 if (mt_count == 0)
1088 return 0;
1089 if (MTBSF == mt_op || MTBSFM == mt_op) {
Borislav Petkovb6422012008-02-02 19:56:49 +01001090 if (!sprev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091 return -EIO;
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001092 mt_count = -mt_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001093 }
1094
Borislav Petkov54abf372008-02-06 02:57:52 +01001095 if (tape->chrdev_dir == IDETAPE_DIR_READ) {
Tejun Heo963da552009-04-19 08:46:02 +09001096 tape->valid = 0;
Borislav Petkov49d80782009-06-07 15:37:06 +02001097 if (test_and_clear_bit(ilog2(IDE_AFLAG_FILEMARK),
1098 &drive->atapi_flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001099 ++count;
Borislav Petkovec0fdb02008-04-27 15:38:34 +02001100 ide_tape_discard_merge_buffer(drive, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001101 }
1102
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103 switch (mt_op) {
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001104 case MTFSF:
1105 case MTBSF:
1106 idetape_create_space_cmd(&pc, mt_count - count,
1107 IDETAPE_SPACE_OVER_FILEMARK);
Borislav Petkovb13345f2009-05-02 10:26:12 +02001108 return ide_queue_pc_tail(drive, disk, &pc, NULL, 0);
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001109 case MTFSFM:
1110 case MTBSFM:
1111 if (!sprev)
1112 return -EIO;
1113 retval = idetape_space_over_filemarks(drive, MTFSF,
1114 mt_count - count);
1115 if (retval)
1116 return retval;
1117 count = (MTBSFM == mt_op ? 1 : -1);
1118 return idetape_space_over_filemarks(drive, MTFSF, count);
1119 default:
1120 printk(KERN_ERR "ide-tape: MTIO operation %d not supported\n",
1121 mt_op);
1122 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123 }
1124}
1125
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126/*
Borislav Petkov3c98bf32008-02-06 02:57:53 +01001127 * Our character device read / write functions.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001128 *
Borislav Petkov3c98bf32008-02-06 02:57:53 +01001129 * The tape is optimized to maximize throughput when it is transferring an
1130 * integral number of the "continuous transfer limit", which is a parameter of
1131 * the specific tape (26kB on my particular tape, 32kB for Onstream).
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132 *
Borislav Petkov3c98bf32008-02-06 02:57:53 +01001133 * As of version 1.3 of the driver, the character device provides an abstract
1134 * continuous view of the media - any mix of block sizes (even 1 byte) on the
1135 * same backup/restore procedure is supported. The driver will internally
1136 * convert the requests to the recommended transfer unit, so that an unmatch
1137 * between the user's block size to the recommended size will only result in a
1138 * (slightly) increased driver overhead, but will no longer hit performance.
1139 * This is not applicable to Onstream.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140 */
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001141static ssize_t idetape_chrdev_read(struct file *file, char __user *buf,
1142 size_t count, loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143{
Borislav Petkov5aeddf92008-10-13 21:39:34 +02001144 struct ide_tape_obj *tape = file->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001145 ide_drive_t *drive = tape->drive;
Tejun Heo07bd9682009-04-19 08:46:03 +09001146 size_t done = 0;
Daniel Walkerdcd96372006-06-25 05:47:37 -07001147 ssize_t ret = 0;
Tejun Heo07bd9682009-04-19 08:46:03 +09001148 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001149
Borislav Petkov8004a8c2008-02-06 02:57:51 +01001150 debug_log(DBG_CHRDEV, "Enter %s, count %Zd\n", __func__, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151
Borislav Petkov54abf372008-02-06 02:57:52 +01001152 if (tape->chrdev_dir != IDETAPE_DIR_READ) {
Borislav Petkov49d80782009-06-07 15:37:06 +02001153 if (test_bit(ilog2(IDE_AFLAG_DETECT_BS), &drive->atapi_flags))
Borislav Petkov54bb2072008-02-06 02:57:52 +01001154 if (count > tape->blk_size &&
1155 (count % tape->blk_size) == 0)
1156 tape->user_bs_factor = count / tape->blk_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157 }
Tejun Heo07bd9682009-04-19 08:46:03 +09001158
Tejun Heo88f1b942009-04-19 08:46:02 +09001159 rc = idetape_init_rw(drive, IDETAPE_DIR_READ);
Borislav Petkov8d06bfa2008-02-06 02:57:53 +01001160 if (rc < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161 return rc;
Tejun Heo07bd9682009-04-19 08:46:03 +09001162
1163 while (done < count) {
1164 size_t todo;
1165
1166 /* refill if staging buffer is empty */
1167 if (!tape->valid) {
1168 /* If we are at a filemark, nothing more to read */
Borislav Petkov49d80782009-06-07 15:37:06 +02001169 if (test_bit(ilog2(IDE_AFLAG_FILEMARK),
1170 &drive->atapi_flags))
Tejun Heo07bd9682009-04-19 08:46:03 +09001171 break;
1172 /* read */
1173 if (idetape_queue_rw_tail(drive, REQ_IDETAPE_READ,
1174 tape->buffer_size) <= 0)
1175 break;
1176 }
1177
1178 /* copy out */
1179 todo = min_t(size_t, count - done, tape->valid);
1180 if (copy_to_user(buf + done, tape->cur, todo))
Daniel Walkerdcd96372006-06-25 05:47:37 -07001181 ret = -EFAULT;
Tejun Heo07bd9682009-04-19 08:46:03 +09001182
1183 tape->cur += todo;
1184 tape->valid -= todo;
1185 done += todo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186 }
Tejun Heo07bd9682009-04-19 08:46:03 +09001187
Borislav Petkov49d80782009-06-07 15:37:06 +02001188 if (!done && test_bit(ilog2(IDE_AFLAG_FILEMARK), &drive->atapi_flags)) {
Borislav Petkov8004a8c2008-02-06 02:57:51 +01001189 debug_log(DBG_SENSE, "%s: spacing over filemark\n", tape->name);
1190
Linus Torvalds1da177e2005-04-16 15:20:36 -07001191 idetape_space_over_filemarks(drive, MTFSF, 1);
1192 return 0;
1193 }
Daniel Walkerdcd96372006-06-25 05:47:37 -07001194
Tejun Heo07bd9682009-04-19 08:46:03 +09001195 return ret ? ret : done;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196}
1197
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001198static ssize_t idetape_chrdev_write(struct file *file, const char __user *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199 size_t count, loff_t *ppos)
1200{
Borislav Petkov5aeddf92008-10-13 21:39:34 +02001201 struct ide_tape_obj *tape = file->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202 ide_drive_t *drive = tape->drive;
Tejun Heo07bd9682009-04-19 08:46:03 +09001203 size_t done = 0;
Daniel Walkerdcd96372006-06-25 05:47:37 -07001204 ssize_t ret = 0;
Tejun Heo88f1b942009-04-19 08:46:02 +09001205 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001206
1207 /* The drive is write protected. */
1208 if (tape->write_prot)
1209 return -EACCES;
1210
Borislav Petkov8004a8c2008-02-06 02:57:51 +01001211 debug_log(DBG_CHRDEV, "Enter %s, count %Zd\n", __func__, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001212
1213 /* Initialize write operation */
Tejun Heo88f1b942009-04-19 08:46:02 +09001214 rc = idetape_init_rw(drive, IDETAPE_DIR_WRITE);
1215 if (rc < 0)
1216 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001217
Tejun Heo07bd9682009-04-19 08:46:03 +09001218 while (done < count) {
1219 size_t todo;
1220
1221 /* flush if staging buffer is full */
1222 if (tape->valid == tape->buffer_size &&
1223 idetape_queue_rw_tail(drive, REQ_IDETAPE_WRITE,
1224 tape->buffer_size) <= 0)
1225 return rc;
1226
1227 /* copy in */
1228 todo = min_t(size_t, count - done,
1229 tape->buffer_size - tape->valid);
1230 if (copy_from_user(tape->cur, buf + done, todo))
Daniel Walkerdcd96372006-06-25 05:47:37 -07001231 ret = -EFAULT;
Tejun Heo07bd9682009-04-19 08:46:03 +09001232
1233 tape->cur += todo;
1234 tape->valid += todo;
1235 done += todo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001236 }
Tejun Heo07bd9682009-04-19 08:46:03 +09001237
1238 return ret ? ret : done;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001239}
1240
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001241static int idetape_write_filemark(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001242{
Bartlomiej Zolnierkiewicz2ac07d92008-10-10 22:39:38 +02001243 struct ide_tape_obj *tape = drive->driver_data;
Borislav Petkovd236d742008-04-18 00:46:27 +02001244 struct ide_atapi_pc pc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245
1246 /* Write a filemark */
1247 idetape_create_write_filemark_cmd(drive, &pc, 1);
Borislav Petkovb13345f2009-05-02 10:26:12 +02001248 if (ide_queue_pc_tail(drive, tape->disk, &pc, NULL, 0)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001249 printk(KERN_ERR "ide-tape: Couldn't write a filemark\n");
1250 return -EIO;
1251 }
1252 return 0;
1253}
1254
1255/*
Borislav Petkovd99c9da2008-02-02 19:56:51 +01001256 * Called from idetape_chrdev_ioctl when the general mtio MTIOCTOP ioctl is
1257 * requested.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001258 *
Borislav Petkovd99c9da2008-02-02 19:56:51 +01001259 * Note: MTBSF and MTBSFM are not supported when the tape doesn't support
1260 * spacing over filemarks in the reverse direction. In this case, MTFSFM is also
Borislav Petkov5bd50dc2008-04-27 15:38:28 +02001261 * usually not supported.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262 *
Borislav Petkovd99c9da2008-02-02 19:56:51 +01001263 * The following commands are currently not supported:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001264 *
Borislav Petkovd99c9da2008-02-02 19:56:51 +01001265 * MTFSS, MTBSS, MTWSM, MTSETDENSITY, MTSETDRVBUFFER, MT_ST_BOOLEANS,
1266 * MT_ST_WRITE_THRESHOLD.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267 */
Borislav Petkovd99c9da2008-02-02 19:56:51 +01001268static int idetape_mtioctop(ide_drive_t *drive, short mt_op, int mt_count)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001269{
1270 idetape_tape_t *tape = drive->driver_data;
Bartlomiej Zolnierkiewicz2ac07d92008-10-10 22:39:38 +02001271 struct gendisk *disk = tape->disk;
Borislav Petkovd236d742008-04-18 00:46:27 +02001272 struct ide_atapi_pc pc;
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001273 int i, retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001274
Borislav Petkov8004a8c2008-02-06 02:57:51 +01001275 debug_log(DBG_ERR, "Handling MTIOCTOP ioctl: mt_op=%d, mt_count=%d\n",
1276 mt_op, mt_count);
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001277
Linus Torvalds1da177e2005-04-16 15:20:36 -07001278 switch (mt_op) {
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001279 case MTFSF:
1280 case MTFSFM:
1281 case MTBSF:
1282 case MTBSFM:
1283 if (!mt_count)
1284 return 0;
1285 return idetape_space_over_filemarks(drive, mt_op, mt_count);
1286 default:
1287 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288 }
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001289
Linus Torvalds1da177e2005-04-16 15:20:36 -07001290 switch (mt_op) {
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001291 case MTWEOF:
1292 if (tape->write_prot)
1293 return -EACCES;
Borislav Petkovec0fdb02008-04-27 15:38:34 +02001294 ide_tape_discard_merge_buffer(drive, 1);
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001295 for (i = 0; i < mt_count; i++) {
1296 retval = idetape_write_filemark(drive);
1297 if (retval)
1298 return retval;
1299 }
1300 return 0;
1301 case MTREW:
Borislav Petkovec0fdb02008-04-27 15:38:34 +02001302 ide_tape_discard_merge_buffer(drive, 0);
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001303 if (idetape_rewind_tape(drive))
1304 return -EIO;
1305 return 0;
1306 case MTLOAD:
Borislav Petkovec0fdb02008-04-27 15:38:34 +02001307 ide_tape_discard_merge_buffer(drive, 0);
Bartlomiej Zolnierkiewicz0c8a6c72008-10-10 22:39:39 +02001308 return ide_do_start_stop(drive, disk, IDETAPE_LU_LOAD_MASK);
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001309 case MTUNLOAD:
1310 case MTOFFL:
1311 /*
1312 * If door is locked, attempt to unlock before
1313 * attempting to eject.
1314 */
1315 if (tape->door_locked) {
Bartlomiej Zolnierkiewicz05780422008-10-10 22:39:38 +02001316 if (!ide_set_media_lock(drive, disk, 0))
Bartlomiej Zolnierkiewicz385a4b82008-10-10 22:39:37 +02001317 tape->door_locked = DOOR_UNLOCKED;
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001318 }
Borislav Petkovec0fdb02008-04-27 15:38:34 +02001319 ide_tape_discard_merge_buffer(drive, 0);
Bartlomiej Zolnierkiewicz0c8a6c72008-10-10 22:39:39 +02001320 retval = ide_do_start_stop(drive, disk, !IDETAPE_LU_LOAD_MASK);
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001321 if (!retval)
Borislav Petkov49d80782009-06-07 15:37:06 +02001322 clear_bit(ilog2(IDE_AFLAG_MEDIUM_PRESENT),
1323 &drive->atapi_flags);
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001324 return retval;
1325 case MTNOP:
Borislav Petkovec0fdb02008-04-27 15:38:34 +02001326 ide_tape_discard_merge_buffer(drive, 0);
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001327 return idetape_flush_tape_buffers(drive);
1328 case MTRETEN:
Borislav Petkovec0fdb02008-04-27 15:38:34 +02001329 ide_tape_discard_merge_buffer(drive, 0);
Bartlomiej Zolnierkiewicz0c8a6c72008-10-10 22:39:39 +02001330 return ide_do_start_stop(drive, disk,
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001331 IDETAPE_LU_RETENSION_MASK | IDETAPE_LU_LOAD_MASK);
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001332 case MTEOM:
1333 idetape_create_space_cmd(&pc, 0, IDETAPE_SPACE_TO_EOD);
Borislav Petkovb13345f2009-05-02 10:26:12 +02001334 return ide_queue_pc_tail(drive, disk, &pc, NULL, 0);
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001335 case MTERASE:
1336 (void)idetape_rewind_tape(drive);
1337 idetape_create_erase_cmd(&pc);
Borislav Petkovb13345f2009-05-02 10:26:12 +02001338 return ide_queue_pc_tail(drive, disk, &pc, NULL, 0);
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001339 case MTSETBLK:
1340 if (mt_count) {
1341 if (mt_count < tape->blk_size ||
1342 mt_count % tape->blk_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001343 return -EIO;
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001344 tape->user_bs_factor = mt_count / tape->blk_size;
Borislav Petkov49d80782009-06-07 15:37:06 +02001345 clear_bit(ilog2(IDE_AFLAG_DETECT_BS),
1346 &drive->atapi_flags);
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001347 } else
Borislav Petkov49d80782009-06-07 15:37:06 +02001348 set_bit(ilog2(IDE_AFLAG_DETECT_BS),
1349 &drive->atapi_flags);
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001350 return 0;
1351 case MTSEEK:
Borislav Petkovec0fdb02008-04-27 15:38:34 +02001352 ide_tape_discard_merge_buffer(drive, 0);
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001353 return idetape_position_tape(drive,
1354 mt_count * tape->user_bs_factor, tape->partition, 0);
1355 case MTSETPART:
Borislav Petkovec0fdb02008-04-27 15:38:34 +02001356 ide_tape_discard_merge_buffer(drive, 0);
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001357 return idetape_position_tape(drive, 0, mt_count, 0);
1358 case MTFSR:
1359 case MTBSR:
1360 case MTLOCK:
Bartlomiej Zolnierkiewicz05780422008-10-10 22:39:38 +02001361 retval = ide_set_media_lock(drive, disk, 1);
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001362 if (retval)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363 return retval;
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001364 tape->door_locked = DOOR_EXPLICITLY_LOCKED;
1365 return 0;
1366 case MTUNLOCK:
Bartlomiej Zolnierkiewicz05780422008-10-10 22:39:38 +02001367 retval = ide_set_media_lock(drive, disk, 0);
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001368 if (retval)
1369 return retval;
1370 tape->door_locked = DOOR_UNLOCKED;
1371 return 0;
1372 default:
1373 printk(KERN_ERR "ide-tape: MTIO operation %d not supported\n",
1374 mt_op);
1375 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001376 }
1377}
1378
1379/*
Borislav Petkovd99c9da2008-02-02 19:56:51 +01001380 * Our character device ioctls. General mtio.h magnetic io commands are
1381 * supported here, and not in the corresponding block interface. Our own
1382 * ide-tape ioctls are supported on both interfaces.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001383 */
Borislav Petkovd99c9da2008-02-02 19:56:51 +01001384static int idetape_chrdev_ioctl(struct inode *inode, struct file *file,
1385 unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001386{
Borislav Petkov5aeddf92008-10-13 21:39:34 +02001387 struct ide_tape_obj *tape = file->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388 ide_drive_t *drive = tape->drive;
1389 struct mtop mtop;
1390 struct mtget mtget;
1391 struct mtpos mtpos;
Borislav Petkov54bb2072008-02-06 02:57:52 +01001392 int block_offset = 0, position = tape->first_frame;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001393 void __user *argp = (void __user *)arg;
1394
Borislav Petkov8004a8c2008-02-06 02:57:51 +01001395 debug_log(DBG_CHRDEV, "Enter %s, cmd=%u\n", __func__, cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001396
Borislav Petkov54abf372008-02-06 02:57:52 +01001397 if (tape->chrdev_dir == IDETAPE_DIR_WRITE) {
Borislav Petkovd9df9372008-04-27 15:38:34 +02001398 ide_tape_flush_merge_buffer(drive);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001399 idetape_flush_tape_buffers(drive);
1400 }
1401 if (cmd == MTIOCGET || cmd == MTIOCPOS) {
Tejun Heo963da552009-04-19 08:46:02 +09001402 block_offset = tape->valid /
Borislav Petkov54bb2072008-02-06 02:57:52 +01001403 (tape->blk_size * tape->user_bs_factor);
Borislav Petkov55ce3a12009-05-04 09:38:15 +02001404 position = ide_tape_read_position(drive);
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001405 if (position < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001406 return -EIO;
1407 }
1408 switch (cmd) {
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001409 case MTIOCTOP:
1410 if (copy_from_user(&mtop, argp, sizeof(struct mtop)))
1411 return -EFAULT;
1412 return idetape_mtioctop(drive, mtop.mt_op, mtop.mt_count);
1413 case MTIOCGET:
1414 memset(&mtget, 0, sizeof(struct mtget));
1415 mtget.mt_type = MT_ISSCSI2;
1416 mtget.mt_blkno = position / tape->user_bs_factor - block_offset;
1417 mtget.mt_dsreg =
1418 ((tape->blk_size * tape->user_bs_factor)
1419 << MT_ST_BLKSIZE_SHIFT) & MT_ST_BLKSIZE_MASK;
Borislav Petkov54bb2072008-02-06 02:57:52 +01001420
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001421 if (tape->drv_write_prot)
1422 mtget.mt_gstat |= GMT_WR_PROT(0xffffffff);
1423
1424 if (copy_to_user(argp, &mtget, sizeof(struct mtget)))
1425 return -EFAULT;
1426 return 0;
1427 case MTIOCPOS:
1428 mtpos.mt_blkno = position / tape->user_bs_factor - block_offset;
1429 if (copy_to_user(argp, &mtpos, sizeof(struct mtpos)))
1430 return -EFAULT;
1431 return 0;
1432 default:
1433 if (tape->chrdev_dir == IDETAPE_DIR_READ)
Borislav Petkovec0fdb02008-04-27 15:38:34 +02001434 ide_tape_discard_merge_buffer(drive, 1);
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001435 return idetape_blkdev_ioctl(drive, cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001436 }
1437}
1438
Borislav Petkov3cffb9c2008-02-02 19:56:50 +01001439/*
1440 * Do a mode sense page 0 with block descriptor and if it succeeds set the tape
1441 * block size with the reported value.
1442 */
1443static void ide_tape_get_bsize_from_bdesc(ide_drive_t *drive)
1444{
1445 idetape_tape_t *tape = drive->driver_data;
Borislav Petkovd236d742008-04-18 00:46:27 +02001446 struct ide_atapi_pc pc;
Borislav Petkov837272b2009-05-04 09:48:57 +02001447 u8 buf[12];
Borislav Petkov3cffb9c2008-02-02 19:56:50 +01001448
1449 idetape_create_mode_sense_cmd(&pc, IDETAPE_BLOCK_DESCRIPTOR);
Borislav Petkov837272b2009-05-04 09:48:57 +02001450 if (ide_queue_pc_tail(drive, tape->disk, &pc, buf, pc.req_xfer)) {
Borislav Petkov3cffb9c2008-02-02 19:56:50 +01001451 printk(KERN_ERR "ide-tape: Can't get block descriptor\n");
Borislav Petkov54bb2072008-02-06 02:57:52 +01001452 if (tape->blk_size == 0) {
Borislav Petkov3cffb9c2008-02-02 19:56:50 +01001453 printk(KERN_WARNING "ide-tape: Cannot deal with zero "
1454 "block size, assuming 32k\n");
Borislav Petkov54bb2072008-02-06 02:57:52 +01001455 tape->blk_size = 32768;
Borislav Petkov3cffb9c2008-02-02 19:56:50 +01001456 }
1457 return;
1458 }
Borislav Petkov837272b2009-05-04 09:48:57 +02001459 tape->blk_size = (buf[4 + 5] << 16) +
1460 (buf[4 + 6] << 8) +
1461 buf[4 + 7];
1462 tape->drv_write_prot = (buf[2] & 0x80) >> 7;
Borislav Petkov3cffb9c2008-02-02 19:56:50 +01001463}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001464
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001465static int idetape_chrdev_open(struct inode *inode, struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001466{
1467 unsigned int minor = iminor(inode), i = minor & ~0xc0;
1468 ide_drive_t *drive;
1469 idetape_tape_t *tape;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001470 int retval;
1471
Borislav Petkov8004a8c2008-02-06 02:57:51 +01001472 if (i >= MAX_HWIFS * MAX_DRIVES)
1473 return -ENXIO;
1474
Jonathan Corbet04f4ac92008-05-15 12:01:56 -06001475 lock_kernel();
Borislav Petkov9d01e4c2009-06-08 22:03:03 +02001476 tape = ide_tape_get(NULL, true, i);
Jonathan Corbet04f4ac92008-05-15 12:01:56 -06001477 if (!tape) {
1478 unlock_kernel();
Borislav Petkov8004a8c2008-02-06 02:57:51 +01001479 return -ENXIO;
Jonathan Corbet04f4ac92008-05-15 12:01:56 -06001480 }
Borislav Petkov8004a8c2008-02-06 02:57:51 +01001481
1482 debug_log(DBG_CHRDEV, "Enter %s\n", __func__);
1483
Linus Torvalds1da177e2005-04-16 15:20:36 -07001484 /*
1485 * We really want to do nonseekable_open(inode, filp); here, but some
1486 * versions of tar incorrectly call lseek on tapes and bail out if that
1487 * fails. So we disallow pread() and pwrite(), but permit lseeks.
1488 */
1489 filp->f_mode &= ~(FMODE_PREAD | FMODE_PWRITE);
1490
Linus Torvalds1da177e2005-04-16 15:20:36 -07001491 drive = tape->drive;
1492
1493 filp->private_data = tape;
1494
Borislav Petkov49d80782009-06-07 15:37:06 +02001495 if (test_and_set_bit(ilog2(IDE_AFLAG_BUSY), &drive->atapi_flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001496 retval = -EBUSY;
1497 goto out_put_tape;
1498 }
1499
1500 retval = idetape_wait_ready(drive, 60 * HZ);
1501 if (retval) {
Borislav Petkov49d80782009-06-07 15:37:06 +02001502 clear_bit(ilog2(IDE_AFLAG_BUSY), &drive->atapi_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001503 printk(KERN_ERR "ide-tape: %s: drive not ready\n", tape->name);
1504 goto out_put_tape;
1505 }
1506
Borislav Petkov79ca7432009-06-15 07:32:04 +02001507 ide_tape_read_position(drive);
Borislav Petkov49d80782009-06-07 15:37:06 +02001508 if (!test_bit(ilog2(IDE_AFLAG_ADDRESS_VALID), &drive->atapi_flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001509 (void)idetape_rewind_tape(drive);
1510
Linus Torvalds1da177e2005-04-16 15:20:36 -07001511 /* Read block size and write protect status from drive. */
Borislav Petkov3cffb9c2008-02-02 19:56:50 +01001512 ide_tape_get_bsize_from_bdesc(drive);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001513
1514 /* Set write protect flag if device is opened as read-only. */
1515 if ((filp->f_flags & O_ACCMODE) == O_RDONLY)
1516 tape->write_prot = 1;
1517 else
1518 tape->write_prot = tape->drv_write_prot;
1519
1520 /* Make sure drive isn't write protected if user wants to write. */
1521 if (tape->write_prot) {
1522 if ((filp->f_flags & O_ACCMODE) == O_WRONLY ||
1523 (filp->f_flags & O_ACCMODE) == O_RDWR) {
Borislav Petkov49d80782009-06-07 15:37:06 +02001524 clear_bit(ilog2(IDE_AFLAG_BUSY), &drive->atapi_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001525 retval = -EROFS;
1526 goto out_put_tape;
1527 }
1528 }
1529
Borislav Petkov3c98bf32008-02-06 02:57:53 +01001530 /* Lock the tape drive door so user can't eject. */
Borislav Petkov54abf372008-02-06 02:57:52 +01001531 if (tape->chrdev_dir == IDETAPE_DIR_NONE) {
Bartlomiej Zolnierkiewicz05780422008-10-10 22:39:38 +02001532 if (!ide_set_media_lock(drive, tape->disk, 1)) {
Bartlomiej Zolnierkiewicz385a4b82008-10-10 22:39:37 +02001533 if (tape->door_locked != DOOR_EXPLICITLY_LOCKED)
1534 tape->door_locked = DOOR_LOCKED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001535 }
1536 }
Jonathan Corbet04f4ac92008-05-15 12:01:56 -06001537 unlock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001538 return 0;
1539
1540out_put_tape:
1541 ide_tape_put(tape);
Jonathan Corbet04f4ac92008-05-15 12:01:56 -06001542 unlock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001543 return retval;
1544}
1545
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001546static void idetape_write_release(ide_drive_t *drive, unsigned int minor)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001547{
1548 idetape_tape_t *tape = drive->driver_data;
1549
Borislav Petkovd9df9372008-04-27 15:38:34 +02001550 ide_tape_flush_merge_buffer(drive);
Tejun Heo963da552009-04-19 08:46:02 +09001551 tape->buf = kmalloc(tape->buffer_size, GFP_KERNEL);
1552 if (tape->buf != NULL) {
Borislav Petkov54bb2072008-02-06 02:57:52 +01001553 idetape_pad_zeros(drive, tape->blk_size *
1554 (tape->user_bs_factor - 1));
Tejun Heo963da552009-04-19 08:46:02 +09001555 kfree(tape->buf);
1556 tape->buf = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001557 }
1558 idetape_write_filemark(drive);
1559 idetape_flush_tape_buffers(drive);
1560 idetape_flush_tape_buffers(drive);
1561}
1562
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001563static int idetape_chrdev_release(struct inode *inode, struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001564{
Borislav Petkov5aeddf92008-10-13 21:39:34 +02001565 struct ide_tape_obj *tape = filp->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001566 ide_drive_t *drive = tape->drive;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001567 unsigned int minor = iminor(inode);
1568
1569 lock_kernel();
1570 tape = drive->driver_data;
Borislav Petkov8004a8c2008-02-06 02:57:51 +01001571
1572 debug_log(DBG_CHRDEV, "Enter %s\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001573
Borislav Petkov54abf372008-02-06 02:57:52 +01001574 if (tape->chrdev_dir == IDETAPE_DIR_WRITE)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001575 idetape_write_release(drive, minor);
Borislav Petkov54abf372008-02-06 02:57:52 +01001576 if (tape->chrdev_dir == IDETAPE_DIR_READ) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001577 if (minor < 128)
Borislav Petkovec0fdb02008-04-27 15:38:34 +02001578 ide_tape_discard_merge_buffer(drive, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001579 }
Borislav Petkovf64eee72008-04-27 15:38:25 +02001580
Borislav Petkov49d80782009-06-07 15:37:06 +02001581 if (minor < 128 && test_bit(ilog2(IDE_AFLAG_MEDIUM_PRESENT),
1582 &drive->atapi_flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001583 (void) idetape_rewind_tape(drive);
Borislav Petkov49d80782009-06-07 15:37:06 +02001584
Borislav Petkov54abf372008-02-06 02:57:52 +01001585 if (tape->chrdev_dir == IDETAPE_DIR_NONE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001586 if (tape->door_locked == DOOR_LOCKED) {
Bartlomiej Zolnierkiewicz05780422008-10-10 22:39:38 +02001587 if (!ide_set_media_lock(drive, tape->disk, 0))
Bartlomiej Zolnierkiewicz385a4b82008-10-10 22:39:37 +02001588 tape->door_locked = DOOR_UNLOCKED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001589 }
1590 }
Borislav Petkov49d80782009-06-07 15:37:06 +02001591 clear_bit(ilog2(IDE_AFLAG_BUSY), &drive->atapi_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001592 ide_tape_put(tape);
1593 unlock_kernel();
1594 return 0;
1595}
1596
Borislav Petkov6d29c8f2008-02-02 19:56:49 +01001597static void idetape_get_inquiry_results(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001598{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001599 idetape_tape_t *tape = drive->driver_data;
Borislav Petkovd236d742008-04-18 00:46:27 +02001600 struct ide_atapi_pc pc;
Bartlomiej Zolnierkiewicz41fa9f82009-03-31 20:15:25 +02001601 u8 pc_buf[256];
Borislav Petkov801bd322008-09-27 19:32:17 +02001602 char fw_rev[4], vendor_id[8], product_id[16];
Borislav Petkov6d29c8f2008-02-02 19:56:49 +01001603
Linus Torvalds1da177e2005-04-16 15:20:36 -07001604 idetape_create_inquiry_cmd(&pc);
Borislav Petkovb13345f2009-05-02 10:26:12 +02001605 if (ide_queue_pc_tail(drive, tape->disk, &pc, pc_buf, pc.req_xfer)) {
Borislav Petkov6d29c8f2008-02-02 19:56:49 +01001606 printk(KERN_ERR "ide-tape: %s: can't get INQUIRY results\n",
1607 tape->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001608 return;
1609 }
Borislav Petkovb13345f2009-05-02 10:26:12 +02001610 memcpy(vendor_id, &pc_buf[8], 8);
1611 memcpy(product_id, &pc_buf[16], 16);
1612 memcpy(fw_rev, &pc_buf[32], 4);
Borislav Petkov6d29c8f2008-02-02 19:56:49 +01001613
Borislav Petkov801bd322008-09-27 19:32:17 +02001614 ide_fixstring(vendor_id, 8, 0);
1615 ide_fixstring(product_id, 16, 0);
1616 ide_fixstring(fw_rev, 4, 0);
Borislav Petkov41f81d542008-02-06 02:57:52 +01001617
Borislav Petkov801bd322008-09-27 19:32:17 +02001618 printk(KERN_INFO "ide-tape: %s <-> %s: %.8s %.16s rev %.4s\n",
Borislav Petkov41f81d542008-02-06 02:57:52 +01001619 drive->name, tape->name, vendor_id, product_id, fw_rev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001620}
1621
1622/*
Borislav Petkovb6422012008-02-02 19:56:49 +01001623 * Ask the tape about its various parameters. In particular, we will adjust our
1624 * data transfer buffer size to the recommended value as returned by the tape.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001625 */
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001626static void idetape_get_mode_sense_results(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627{
1628 idetape_tape_t *tape = drive->driver_data;
Borislav Petkovd236d742008-04-18 00:46:27 +02001629 struct ide_atapi_pc pc;
Borislav Petkovb13345f2009-05-02 10:26:12 +02001630 u8 buf[24], *caps;
Borislav Petkovb6422012008-02-02 19:56:49 +01001631 u8 speed, max_speed;
Borislav Petkov47314fa2008-02-02 19:56:48 +01001632
Linus Torvalds1da177e2005-04-16 15:20:36 -07001633 idetape_create_mode_sense_cmd(&pc, IDETAPE_CAPABILITIES_PAGE);
Borislav Petkovb13345f2009-05-02 10:26:12 +02001634 if (ide_queue_pc_tail(drive, tape->disk, &pc, buf, pc.req_xfer)) {
Borislav Petkovb6422012008-02-02 19:56:49 +01001635 printk(KERN_ERR "ide-tape: Can't get tape parameters - assuming"
1636 " some default values\n");
Borislav Petkov54bb2072008-02-06 02:57:52 +01001637 tape->blk_size = 512;
Borislav Petkovb6422012008-02-02 19:56:49 +01001638 put_unaligned(52, (u16 *)&tape->caps[12]);
1639 put_unaligned(540, (u16 *)&tape->caps[14]);
1640 put_unaligned(6*52, (u16 *)&tape->caps[16]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001641 return;
1642 }
Borislav Petkovb13345f2009-05-02 10:26:12 +02001643 caps = buf + 4 + buf[3];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001644
Borislav Petkovb6422012008-02-02 19:56:49 +01001645 /* convert to host order and save for later use */
Harvey Harrisoncd740ab2008-07-24 22:53:33 +02001646 speed = be16_to_cpup((__be16 *)&caps[14]);
1647 max_speed = be16_to_cpup((__be16 *)&caps[8]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001648
Harvey Harrisoncd740ab2008-07-24 22:53:33 +02001649 *(u16 *)&caps[8] = max_speed;
1650 *(u16 *)&caps[12] = be16_to_cpup((__be16 *)&caps[12]);
1651 *(u16 *)&caps[14] = speed;
1652 *(u16 *)&caps[16] = be16_to_cpup((__be16 *)&caps[16]);
Borislav Petkovb6422012008-02-02 19:56:49 +01001653
1654 if (!speed) {
1655 printk(KERN_INFO "ide-tape: %s: invalid tape speed "
1656 "(assuming 650KB/sec)\n", drive->name);
Harvey Harrisoncd740ab2008-07-24 22:53:33 +02001657 *(u16 *)&caps[14] = 650;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001658 }
Borislav Petkovb6422012008-02-02 19:56:49 +01001659 if (!max_speed) {
1660 printk(KERN_INFO "ide-tape: %s: invalid max_speed "
1661 "(assuming 650KB/sec)\n", drive->name);
Harvey Harrisoncd740ab2008-07-24 22:53:33 +02001662 *(u16 *)&caps[8] = 650;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001663 }
1664
Borislav Petkovb6422012008-02-02 19:56:49 +01001665 memcpy(&tape->caps, caps, 20);
Bartlomiej Zolnierkiewicz05780422008-10-10 22:39:38 +02001666
1667 /* device lacks locking support according to capabilities page */
1668 if ((caps[6] & 1) == 0)
Bartlomiej Zolnierkiewicz42619d32008-10-17 18:09:11 +02001669 drive->dev_flags &= ~IDE_DFLAG_DOORLOCKING;
Bartlomiej Zolnierkiewicz05780422008-10-10 22:39:38 +02001670
Borislav Petkovb6422012008-02-02 19:56:49 +01001671 if (caps[7] & 0x02)
Borislav Petkov54bb2072008-02-06 02:57:52 +01001672 tape->blk_size = 512;
Borislav Petkovb6422012008-02-02 19:56:49 +01001673 else if (caps[7] & 0x04)
Borislav Petkov54bb2072008-02-06 02:57:52 +01001674 tape->blk_size = 1024;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001675}
1676
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +02001677#ifdef CONFIG_IDE_PROC_FS
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +02001678#define ide_tape_devset_get(name, field) \
1679static int get_##name(ide_drive_t *drive) \
1680{ \
1681 idetape_tape_t *tape = drive->driver_data; \
1682 return tape->field; \
Linus Torvalds1da177e2005-04-16 15:20:36 -07001683}
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +02001684
1685#define ide_tape_devset_set(name, field) \
1686static int set_##name(ide_drive_t *drive, int arg) \
1687{ \
1688 idetape_tape_t *tape = drive->driver_data; \
1689 tape->field = arg; \
1690 return 0; \
1691}
1692
Elias Oltmanns92f1f8f2008-10-10 22:39:40 +02001693#define ide_tape_devset_rw_field(_name, _field) \
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +02001694ide_tape_devset_get(_name, _field) \
1695ide_tape_devset_set(_name, _field) \
Elias Oltmanns92f1f8f2008-10-10 22:39:40 +02001696IDE_DEVSET(_name, DS_SYNC, get_##_name, set_##_name)
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +02001697
Elias Oltmanns92f1f8f2008-10-10 22:39:40 +02001698#define ide_tape_devset_r_field(_name, _field) \
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +02001699ide_tape_devset_get(_name, _field) \
Elias Oltmanns92f1f8f2008-10-10 22:39:40 +02001700IDE_DEVSET(_name, 0, get_##_name, NULL)
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +02001701
1702static int mulf_tdsc(ide_drive_t *drive) { return 1000; }
1703static int divf_tdsc(ide_drive_t *drive) { return HZ; }
1704static int divf_buffer(ide_drive_t *drive) { return 2; }
1705static int divf_buffer_size(ide_drive_t *drive) { return 1024; }
1706
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +02001707ide_devset_rw_flag(dsc_overlap, IDE_DFLAG_DSC_OVERLAP);
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +02001708
Elias Oltmanns92f1f8f2008-10-10 22:39:40 +02001709ide_tape_devset_rw_field(debug_mask, debug_mask);
1710ide_tape_devset_rw_field(tdsc, best_dsc_rw_freq);
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +02001711
Elias Oltmanns92f1f8f2008-10-10 22:39:40 +02001712ide_tape_devset_r_field(avg_speed, avg_speed);
1713ide_tape_devset_r_field(speed, caps[14]);
1714ide_tape_devset_r_field(buffer, caps[16]);
1715ide_tape_devset_r_field(buffer_size, buffer_size);
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +02001716
Elias Oltmanns92f1f8f2008-10-10 22:39:40 +02001717static const struct ide_proc_devset idetape_settings[] = {
1718 __IDE_PROC_DEVSET(avg_speed, 0, 0xffff, NULL, NULL),
1719 __IDE_PROC_DEVSET(buffer, 0, 0xffff, NULL, divf_buffer),
1720 __IDE_PROC_DEVSET(buffer_size, 0, 0xffff, NULL, divf_buffer_size),
1721 __IDE_PROC_DEVSET(debug_mask, 0, 0xffff, NULL, NULL),
1722 __IDE_PROC_DEVSET(dsc_overlap, 0, 1, NULL, NULL),
1723 __IDE_PROC_DEVSET(speed, 0, 0xffff, NULL, NULL),
1724 __IDE_PROC_DEVSET(tdsc, IDETAPE_DSC_RW_MIN, IDETAPE_DSC_RW_MAX,
1725 mulf_tdsc, divf_tdsc),
Hannes Eder71bfc7a2009-03-05 16:10:56 +01001726 { NULL },
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +02001727};
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +02001728#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001729
1730/*
Borislav Petkov3c98bf32008-02-06 02:57:53 +01001731 * The function below is called to:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001732 *
Borislav Petkov3c98bf32008-02-06 02:57:53 +01001733 * 1. Initialize our various state variables.
1734 * 2. Ask the tape for its capabilities.
1735 * 3. Allocate a buffer which will be used for data transfer. The buffer size
1736 * is chosen based on the recommendation which we received in step 2.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001737 *
Borislav Petkov3c98bf32008-02-06 02:57:53 +01001738 * Note that at this point ide.c already assigned us an irq, so that we can
1739 * queue requests here and wait for their completion.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001740 */
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001741static void idetape_setup(ide_drive_t *drive, idetape_tape_t *tape, int minor)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001742{
Borislav Petkov83042b22008-04-27 15:38:27 +02001743 unsigned long t;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001744 int speed;
Borislav Petkovf73850a2008-04-27 15:38:33 +02001745 int buffer_size;
Borislav Petkovb6422012008-02-02 19:56:49 +01001746 u16 *ctl = (u16 *)&tape->caps[12];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001747
Bartlomiej Zolnierkiewicz85e39032008-10-13 21:39:32 +02001748 drive->pc_callback = ide_tape_callback;
Borislav Petkov776bb022008-07-23 19:55:59 +02001749
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +02001750 drive->dev_flags |= IDE_DFLAG_DSC_OVERLAP;
1751
Bartlomiej Zolnierkiewicz4166c192008-02-01 23:09:30 +01001752 if (drive->hwif->host_flags & IDE_HFLAG_NO_DSC) {
1753 printk(KERN_INFO "ide-tape: %s: disabling DSC overlap\n",
1754 tape->name);
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +02001755 drive->dev_flags &= ~IDE_DFLAG_DSC_OVERLAP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001756 }
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +02001757
Linus Torvalds1da177e2005-04-16 15:20:36 -07001758 /* Seagate Travan drives do not support DSC overlap. */
Bartlomiej Zolnierkiewicz4dde4492008-10-10 22:39:19 +02001759 if (strstr((char *)&drive->id[ATA_ID_PROD], "Seagate STT3401"))
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +02001760 drive->dev_flags &= ~IDE_DFLAG_DSC_OVERLAP;
1761
Linus Torvalds1da177e2005-04-16 15:20:36 -07001762 tape->minor = minor;
1763 tape->name[0] = 'h';
1764 tape->name[1] = 't';
1765 tape->name[2] = '0' + minor;
Borislav Petkov54abf372008-02-06 02:57:52 +01001766 tape->chrdev_dir = IDETAPE_DIR_NONE;
Bartlomiej Zolnierkiewicz4dde4492008-10-10 22:39:19 +02001767
Linus Torvalds1da177e2005-04-16 15:20:36 -07001768 idetape_get_inquiry_results(drive);
1769 idetape_get_mode_sense_results(drive);
Borislav Petkov3cffb9c2008-02-02 19:56:50 +01001770 ide_tape_get_bsize_from_bdesc(drive);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001771 tape->user_bs_factor = 1;
Borislav Petkovf73850a2008-04-27 15:38:33 +02001772 tape->buffer_size = *ctl * tape->blk_size;
1773 while (tape->buffer_size > 0xffff) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001774 printk(KERN_NOTICE "ide-tape: decreasing stage size\n");
Borislav Petkovb6422012008-02-02 19:56:49 +01001775 *ctl /= 2;
Borislav Petkovf73850a2008-04-27 15:38:33 +02001776 tape->buffer_size = *ctl * tape->blk_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001777 }
Borislav Petkovf73850a2008-04-27 15:38:33 +02001778 buffer_size = tape->buffer_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001779
Borislav Petkov83042b22008-04-27 15:38:27 +02001780 /* select the "best" DSC read/write polling freq */
Borislav Petkovb6422012008-02-02 19:56:49 +01001781 speed = max(*(u16 *)&tape->caps[14], *(u16 *)&tape->caps[8]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001782
Borislav Petkovf73850a2008-04-27 15:38:33 +02001783 t = (IDETAPE_FIFO_THRESHOLD * tape->buffer_size * HZ) / (speed * 1000);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001784
1785 /*
Borislav Petkov3c98bf32008-02-06 02:57:53 +01001786 * Ensure that the number we got makes sense; limit it within
1787 * IDETAPE_DSC_RW_MIN and IDETAPE_DSC_RW_MAX.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001788 */
Harvey Harrisona792bd52008-07-15 21:21:41 +02001789 tape->best_dsc_rw_freq = clamp_t(unsigned long, t, IDETAPE_DSC_RW_MIN,
1790 IDETAPE_DSC_RW_MAX);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001791 printk(KERN_INFO "ide-tape: %s <-> %s: %dKBps, %d*%dkB buffer, "
Borislav Petkov83042b22008-04-27 15:38:27 +02001792 "%lums tDSC%s\n",
Borislav Petkovb6422012008-02-02 19:56:49 +01001793 drive->name, tape->name, *(u16 *)&tape->caps[14],
Borislav Petkovf73850a2008-04-27 15:38:33 +02001794 (*(u16 *)&tape->caps[16] * 512) / tape->buffer_size,
1795 tape->buffer_size / 1024,
Borislav Petkov54bb2072008-02-06 02:57:52 +01001796 tape->best_dsc_rw_freq * 1000 / HZ,
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +02001797 (drive->dev_flags & IDE_DFLAG_USING_DMA) ? ", DMA" : "");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001798
Bartlomiej Zolnierkiewicz1e874f42008-10-10 22:39:27 +02001799 ide_proc_register_driver(drive, tape->driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001800}
1801
Russell King4031bbe2006-01-06 11:41:00 +00001802static void ide_tape_remove(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001803{
1804 idetape_tape_t *tape = drive->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001805
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +02001806 ide_proc_unregister_driver(drive, tape->driver);
Bartlomiej Zolnierkiewicz8fed4362009-02-25 20:28:24 +01001807 device_del(&tape->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001808 ide_unregister_region(tape->disk);
1809
Bartlomiej Zolnierkiewicz8fed4362009-02-25 20:28:24 +01001810 mutex_lock(&idetape_ref_mutex);
1811 put_device(&tape->dev);
1812 mutex_unlock(&idetape_ref_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001813}
1814
Bartlomiej Zolnierkiewicz8fed4362009-02-25 20:28:24 +01001815static void ide_tape_release(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001816{
Bartlomiej Zolnierkiewicz8fed4362009-02-25 20:28:24 +01001817 struct ide_tape_obj *tape = to_ide_drv(dev, ide_tape_obj);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001818 ide_drive_t *drive = tape->drive;
1819 struct gendisk *g = tape->disk;
1820
Tejun Heo963da552009-04-19 08:46:02 +09001821 BUG_ON(tape->valid);
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +02001822
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +02001823 drive->dev_flags &= ~IDE_DFLAG_DSC_OVERLAP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001824 drive->driver_data = NULL;
Tony Jonesdbc12722007-09-25 02:03:03 +02001825 device_destroy(idetape_sysfs_class, MKDEV(IDETAPE_MAJOR, tape->minor));
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001826 device_destroy(idetape_sysfs_class,
1827 MKDEV(IDETAPE_MAJOR, tape->minor + 128));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001828 idetape_devs[tape->minor] = NULL;
1829 g->private_data = NULL;
1830 put_disk(g);
1831 kfree(tape);
1832}
1833
Bartlomiej Zolnierkiewiczecfd80e2007-05-10 00:01:09 +02001834#ifdef CONFIG_IDE_PROC_FS
Linus Torvalds1da177e2005-04-16 15:20:36 -07001835static int proc_idetape_read_name
1836 (char *page, char **start, off_t off, int count, int *eof, void *data)
1837{
1838 ide_drive_t *drive = (ide_drive_t *) data;
1839 idetape_tape_t *tape = drive->driver_data;
1840 char *out = page;
1841 int len;
1842
1843 len = sprintf(out, "%s\n", tape->name);
1844 PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
1845}
1846
1847static ide_proc_entry_t idetape_proc[] = {
1848 { "capacity", S_IFREG|S_IRUGO, proc_ide_read_capacity, NULL },
1849 { "name", S_IFREG|S_IRUGO, proc_idetape_read_name, NULL },
1850 { NULL, 0, NULL, NULL }
1851};
Bartlomiej Zolnierkiewicz79cb3802008-10-17 18:09:13 +02001852
1853static ide_proc_entry_t *ide_tape_proc_entries(ide_drive_t *drive)
1854{
1855 return idetape_proc;
1856}
1857
1858static const struct ide_proc_devset *ide_tape_proc_devsets(ide_drive_t *drive)
1859{
1860 return idetape_settings;
1861}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001862#endif
1863
Russell King4031bbe2006-01-06 11:41:00 +00001864static int ide_tape_probe(ide_drive_t *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001865
Bartlomiej Zolnierkiewicz7f3c8682009-01-06 17:20:53 +01001866static struct ide_driver idetape_driver = {
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +02001867 .gen_driver = {
Laurent Riffard4ef3b8f2005-11-18 22:15:40 +01001868 .owner = THIS_MODULE,
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +02001869 .name = "ide-tape",
1870 .bus = &ide_bus_type,
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +02001871 },
Russell King4031bbe2006-01-06 11:41:00 +00001872 .probe = ide_tape_probe,
1873 .remove = ide_tape_remove,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001874 .version = IDETAPE_VERSION,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001875 .do_request = idetape_do_request,
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +02001876#ifdef CONFIG_IDE_PROC_FS
Bartlomiej Zolnierkiewicz79cb3802008-10-17 18:09:13 +02001877 .proc_entries = ide_tape_proc_entries,
1878 .proc_devsets = ide_tape_proc_devsets,
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +02001879#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001880};
1881
Borislav Petkov3c98bf32008-02-06 02:57:53 +01001882/* Our character device supporting functions, passed to register_chrdev. */
Arjan van de Ven2b8693c2007-02-12 00:55:32 -08001883static const struct file_operations idetape_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001884 .owner = THIS_MODULE,
1885 .read = idetape_chrdev_read,
1886 .write = idetape_chrdev_write,
1887 .ioctl = idetape_chrdev_ioctl,
1888 .open = idetape_chrdev_open,
1889 .release = idetape_chrdev_release,
1890};
1891
Al Viroa4600f82008-03-02 10:27:58 -05001892static int idetape_open(struct block_device *bdev, fmode_t mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001893{
Borislav Petkov9d01e4c2009-06-08 22:03:03 +02001894 struct ide_tape_obj *tape = ide_tape_get(bdev->bd_disk, false, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001895
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001896 if (!tape)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001897 return -ENXIO;
1898
Linus Torvalds1da177e2005-04-16 15:20:36 -07001899 return 0;
1900}
1901
Al Viroa4600f82008-03-02 10:27:58 -05001902static int idetape_release(struct gendisk *disk, fmode_t mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001903{
Borislav Petkov5aeddf92008-10-13 21:39:34 +02001904 struct ide_tape_obj *tape = ide_drv_g(disk, ide_tape_obj);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001905
1906 ide_tape_put(tape);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001907 return 0;
1908}
1909
Al Viroa4600f82008-03-02 10:27:58 -05001910static int idetape_ioctl(struct block_device *bdev, fmode_t mode,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001911 unsigned int cmd, unsigned long arg)
1912{
Borislav Petkov5aeddf92008-10-13 21:39:34 +02001913 struct ide_tape_obj *tape = ide_drv_g(bdev->bd_disk, ide_tape_obj);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001914 ide_drive_t *drive = tape->drive;
Al Viro1bddd9e2008-09-02 17:19:43 -04001915 int err = generic_ide_ioctl(drive, bdev, cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001916 if (err == -EINVAL)
1917 err = idetape_blkdev_ioctl(drive, cmd, arg);
1918 return err;
1919}
1920
1921static struct block_device_operations idetape_block_ops = {
1922 .owner = THIS_MODULE,
Al Viroa4600f82008-03-02 10:27:58 -05001923 .open = idetape_open,
1924 .release = idetape_release,
1925 .locked_ioctl = idetape_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001926};
1927
Russell King4031bbe2006-01-06 11:41:00 +00001928static int ide_tape_probe(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001929{
1930 idetape_tape_t *tape;
1931 struct gendisk *g;
1932 int minor;
1933
1934 if (!strstr("ide-tape", drive->driver_req))
1935 goto failed;
Bartlomiej Zolnierkiewicz2a924662008-10-10 22:39:24 +02001936
Linus Torvalds1da177e2005-04-16 15:20:36 -07001937 if (drive->media != ide_tape)
1938 goto failed;
Bartlomiej Zolnierkiewicz2a924662008-10-10 22:39:24 +02001939
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +02001940 if ((drive->dev_flags & IDE_DFLAG_ID_READ) &&
1941 ide_check_atapi_device(drive, DRV_NAME) == 0) {
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001942 printk(KERN_ERR "ide-tape: %s: not supported by this version of"
1943 " the driver\n", drive->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001944 goto failed;
1945 }
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001946 tape = kzalloc(sizeof(idetape_tape_t), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001947 if (tape == NULL) {
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01001948 printk(KERN_ERR "ide-tape: %s: Can't allocate a tape struct\n",
1949 drive->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001950 goto failed;
1951 }
1952
1953 g = alloc_disk(1 << PARTN_BITS);
1954 if (!g)
1955 goto out_free_tape;
1956
1957 ide_init_disk(g, drive);
1958
Bartlomiej Zolnierkiewicz8fed4362009-02-25 20:28:24 +01001959 tape->dev.parent = &drive->gendev;
1960 tape->dev.release = ide_tape_release;
1961 dev_set_name(&tape->dev, dev_name(&drive->gendev));
1962
1963 if (device_register(&tape->dev))
1964 goto out_free_disk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001965
1966 tape->drive = drive;
1967 tape->driver = &idetape_driver;
1968 tape->disk = g;
1969
1970 g->private_data = &tape->driver;
1971
1972 drive->driver_data = tape;
1973
Arjan van de Vencf8b8972006-03-23 03:00:45 -08001974 mutex_lock(&idetape_ref_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001975 for (minor = 0; idetape_devs[minor]; minor++)
1976 ;
1977 idetape_devs[minor] = tape;
Arjan van de Vencf8b8972006-03-23 03:00:45 -08001978 mutex_unlock(&idetape_ref_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001979
1980 idetape_setup(drive, tape, minor);
1981
Greg Kroah-Hartman3ee074b2008-07-21 20:03:34 -07001982 device_create(idetape_sysfs_class, &drive->gendev,
1983 MKDEV(IDETAPE_MAJOR, minor), NULL, "%s", tape->name);
1984 device_create(idetape_sysfs_class, &drive->gendev,
1985 MKDEV(IDETAPE_MAJOR, minor + 128), NULL,
1986 "n%s", tape->name);
Will Dysond5dee802005-09-16 02:55:07 -07001987
Linus Torvalds1da177e2005-04-16 15:20:36 -07001988 g->fops = &idetape_block_ops;
1989 ide_register_region(g);
1990
1991 return 0;
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +02001992
Bartlomiej Zolnierkiewicz8fed4362009-02-25 20:28:24 +01001993out_free_disk:
1994 put_disk(g);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001995out_free_tape:
1996 kfree(tape);
1997failed:
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +02001998 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001999}
2000
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01002001static void __exit idetape_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002002{
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +02002003 driver_unregister(&idetape_driver.gen_driver);
Will Dysond5dee802005-09-16 02:55:07 -07002004 class_destroy(idetape_sysfs_class);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002005 unregister_chrdev(IDETAPE_MAJOR, "ht");
2006}
2007
Bartlomiej Zolnierkiewicz17514e82005-11-19 22:24:35 +01002008static int __init idetape_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002009{
Will Dysond5dee802005-09-16 02:55:07 -07002010 int error = 1;
2011 idetape_sysfs_class = class_create(THIS_MODULE, "ide_tape");
2012 if (IS_ERR(idetape_sysfs_class)) {
2013 idetape_sysfs_class = NULL;
2014 printk(KERN_ERR "Unable to create sysfs class for ide tapes\n");
2015 error = -EBUSY;
2016 goto out;
2017 }
2018
Linus Torvalds1da177e2005-04-16 15:20:36 -07002019 if (register_chrdev(IDETAPE_MAJOR, "ht", &idetape_fops)) {
Borislav Petkov5a04cfa2008-02-06 02:57:54 +01002020 printk(KERN_ERR "ide-tape: Failed to register chrdev"
2021 " interface\n");
Will Dysond5dee802005-09-16 02:55:07 -07002022 error = -EBUSY;
2023 goto out_free_class;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002024 }
Will Dysond5dee802005-09-16 02:55:07 -07002025
2026 error = driver_register(&idetape_driver.gen_driver);
2027 if (error)
2028 goto out_free_driver;
2029
2030 return 0;
2031
2032out_free_driver:
2033 driver_unregister(&idetape_driver.gen_driver);
2034out_free_class:
2035 class_destroy(idetape_sysfs_class);
2036out:
2037 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002038}
2039
Kay Sievers263756e2005-12-12 18:03:44 +01002040MODULE_ALIAS("ide:*m-tape*");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002041module_init(idetape_init);
2042module_exit(idetape_exit);
2043MODULE_ALIAS_CHARDEV_MAJOR(IDETAPE_MAJOR);
Borislav Petkov9c145762008-02-06 02:57:54 +01002044MODULE_DESCRIPTION("ATAPI Streaming TAPE Driver");
2045MODULE_LICENSE("GPL");