blob: d36f155470a49dfcafef2ee19dbb9a3835475c9b [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Borislav Petkovd3f20842008-02-01 23:09:33 +01002 * IDE ATAPI floppy driver.
3 *
Bartlomiej Zolnierkiewicz59bca8c2008-02-01 23:09:33 +01004 * Copyright (C) 1996-1999 Gadi Oxman <gadio@netvision.net.il>
5 * Copyright (C) 2000-2002 Paul Bristow <paul@paulbristow.net>
6 * Copyright (C) 2005 Bartlomiej Zolnierkiewicz
Borislav Petkov0571c7a2008-02-02 19:56:38 +01007 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 * This driver supports the following IDE floppy drives:
9 *
10 * LS-120/240 SuperDisk
11 * Iomega Zip 100/250
12 * Iomega PC Card Clik!/PocketZip
13 *
Borislav Petkovd3f20842008-02-01 23:09:33 +010014 * For a historical changelog see
15 * Documentation/ide/ChangeLog.ide-floppy.1996-2002
Linus Torvalds1da177e2005-04-16 15:20:36 -070016 */
17
Bartlomiej Zolnierkiewicz51509ee2008-10-10 22:39:34 +020018#define DRV_NAME "ide-floppy"
19
Borislav Petkovfc6c5bc2008-02-02 19:56:38 +010020#define IDEFLOPPY_VERSION "1.00"
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>
30#include <linux/major.h>
31#include <linux/errno.h>
32#include <linux/genhd.h>
33#include <linux/slab.h>
34#include <linux/cdrom.h>
35#include <linux/ide.h>
Bartlomiej Zolnierkiewicz3ceca722008-10-10 22:39:27 +020036#include <linux/hdreg.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070037#include <linux/bitops.h>
Arjan van de Vencf8b8972006-03-23 03:00:45 -080038#include <linux/mutex.h>
Borislav Petkovb98b3402008-10-10 22:39:35 +020039#include <linux/scatterlist.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070040
Bartlomiej Zolnierkiewicz89636af2007-07-20 01:11:59 +020041#include <scsi/scsi_ioctl.h>
42
Linus Torvalds1da177e2005-04-16 15:20:36 -070043#include <asm/byteorder.h>
Borislav Petkov7e8b1632008-02-02 19:56:34 +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>
48
Bartlomiej Zolnierkiewicz01278542008-10-10 22:39:38 +020049#include "ide-floppy.h"
50
Borislav Petkovf373bd82008-02-02 19:56:36 +010051/* define to see debug info */
Linus Torvalds1da177e2005-04-16 15:20:36 -070052#define IDEFLOPPY_DEBUG_LOG 0
Linus Torvalds1da177e2005-04-16 15:20:36 -070053
54/* #define IDEFLOPPY_DEBUG(fmt, args...) printk(KERN_INFO fmt, ## args) */
Borislav Petkov0571c7a2008-02-02 19:56:38 +010055#define IDEFLOPPY_DEBUG(fmt, args...)
Linus Torvalds1da177e2005-04-16 15:20:36 -070056
57#if IDEFLOPPY_DEBUG_LOG
Borislav Petkovbcc77d92008-02-02 19:56:34 +010058#define debug_log(fmt, args...) \
59 printk(KERN_INFO "ide-floppy: " fmt, ## args)
Linus Torvalds1da177e2005-04-16 15:20:36 -070060#else
Borislav Petkov0571c7a2008-02-02 19:56:38 +010061#define debug_log(fmt, args...) do {} while (0)
Linus Torvalds1da177e2005-04-16 15:20:36 -070062#endif
63
Linus Torvalds1da177e2005-04-16 15:20:36 -070064/*
Borislav Petkov0571c7a2008-02-02 19:56:38 +010065 * After each failed packet command we issue a request sense command and retry
66 * the packet command IDEFLOPPY_MAX_PC_RETRIES times.
Linus Torvalds1da177e2005-04-16 15:20:36 -070067 */
68#define IDEFLOPPY_MAX_PC_RETRIES 3
69
Borislav Petkov194ec0c2008-02-02 19:56:35 +010070/* format capacities descriptor codes */
Linus Torvalds1da177e2005-04-16 15:20:36 -070071#define CAPACITY_INVALID 0x00
72#define CAPACITY_UNFORMATTED 0x01
73#define CAPACITY_CURRENT 0x02
74#define CAPACITY_NO_CARTRIDGE 0x03
75
Bartlomiej Zolnierkiewiczc40d3d32005-08-18 22:09:21 +020076#define IDEFLOPPY_TICKS_DELAY HZ/20 /* default delay for ZIP 100 (50ms) */
Linus Torvalds1da177e2005-04-16 15:20:36 -070077
Borislav Petkov0571c7a2008-02-02 19:56:38 +010078/* Error code returned in rq->errors to the higher part of the driver. */
Linus Torvalds1da177e2005-04-16 15:20:36 -070079#define IDEFLOPPY_ERROR_GENERAL 101
80
Arjan van de Vencf8b8972006-03-23 03:00:45 -080081static DEFINE_MUTEX(idefloppy_ref_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070082
83#define to_ide_floppy(obj) container_of(obj, struct ide_floppy_obj, kref)
84
85#define ide_floppy_g(disk) \
86 container_of((disk)->private_data, struct ide_floppy_obj, driver)
87
Bartlomiej Zolnierkiewicz08da5912008-07-24 22:53:15 +020088static void idefloppy_cleanup_obj(struct kref *);
89
Linus Torvalds1da177e2005-04-16 15:20:36 -070090static struct ide_floppy_obj *ide_floppy_get(struct gendisk *disk)
91{
92 struct ide_floppy_obj *floppy = NULL;
93
Arjan van de Vencf8b8972006-03-23 03:00:45 -080094 mutex_lock(&idefloppy_ref_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070095 floppy = ide_floppy_g(disk);
Bartlomiej Zolnierkiewicz08da5912008-07-24 22:53:15 +020096 if (floppy) {
Bartlomiej Zolnierkiewiczd3e33ff2008-08-05 18:16:59 +020097 if (ide_device_get(floppy->drive))
Bartlomiej Zolnierkiewicz08da5912008-07-24 22:53:15 +020098 floppy = NULL;
Bartlomiej Zolnierkiewiczd3e33ff2008-08-05 18:16:59 +020099 else
100 kref_get(&floppy->kref);
Bartlomiej Zolnierkiewicz08da5912008-07-24 22:53:15 +0200101 }
Arjan van de Vencf8b8972006-03-23 03:00:45 -0800102 mutex_unlock(&idefloppy_ref_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103 return floppy;
104}
105
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106static void ide_floppy_put(struct ide_floppy_obj *floppy)
107{
Bartlomiej Zolnierkiewiczd3e33ff2008-08-05 18:16:59 +0200108 ide_drive_t *drive = floppy->drive;
109
Arjan van de Vencf8b8972006-03-23 03:00:45 -0800110 mutex_lock(&idefloppy_ref_mutex);
Borislav Petkov9a24b632008-02-02 19:56:33 +0100111 kref_put(&floppy->kref, idefloppy_cleanup_obj);
Bartlomiej Zolnierkiewiczd3e33ff2008-08-05 18:16:59 +0200112 ide_device_put(drive);
Arjan van de Vencf8b8972006-03-23 03:00:45 -0800113 mutex_unlock(&idefloppy_ref_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114}
115
116/*
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100117 * Used to finish servicing a request. For read/write requests, we will call
118 * ide_end_request to pass to the next buffer.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119 */
Borislav Petkovc2b2b292008-04-18 00:46:27 +0200120static int idefloppy_end_request(ide_drive_t *drive, int uptodate, int nsecs)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121{
122 idefloppy_floppy_t *floppy = drive->driver_data;
123 struct request *rq = HWGROUP(drive)->rq;
124 int error;
125
Borislav Petkovbcc77d92008-02-02 19:56:34 +0100126 debug_log("Reached %s\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127
128 switch (uptodate) {
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100129 case 0: error = IDEFLOPPY_ERROR_GENERAL; break;
130 case 1: error = 0; break;
131 default: error = uptodate;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132 }
133 if (error)
134 floppy->failed_pc = NULL;
135 /* Why does this happen? */
136 if (!rq)
137 return 0;
Jens Axboe4aff5e22006-08-10 08:44:47 +0200138 if (!blk_special_request(rq)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139 /* our real local end request function */
140 ide_end_request(drive, uptodate, nsecs);
141 return 0;
142 }
143 rq->errors = error;
144 /* fixme: need to move this local also */
145 ide_end_drive_cmd(drive, 0, 0);
146 return 0;
147}
148
Borislav Petkov8e555122008-04-18 00:46:27 +0200149static void idefloppy_update_buffers(ide_drive_t *drive,
150 struct ide_atapi_pc *pc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151{
152 struct request *rq = pc->rq;
153 struct bio *bio = rq->bio;
154
155 while ((bio = rq->bio) != NULL)
Borislav Petkovc2b2b292008-04-18 00:46:27 +0200156 idefloppy_end_request(drive, 1, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157}
158
Borislav Petkov81f49382008-07-15 21:21:56 +0200159static void ide_floppy_callback(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160{
161 idefloppy_floppy_t *floppy = drive->driver_data;
Borislav Petkov81f49382008-07-15 21:21:56 +0200162 struct ide_atapi_pc *pc = floppy->pc;
163 int uptodate = pc->error ? 0 : 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164
Borislav Petkovbcc77d92008-02-02 19:56:34 +0100165 debug_log("Reached %s\n", __func__);
166
Bartlomiej Zolnierkiewiczdd2e9a02008-07-15 21:22:01 +0200167 if (floppy->failed_pc == pc)
168 floppy->failed_pc = NULL;
169
Borislav Petkov81f49382008-07-15 21:21:56 +0200170 if (pc->c[0] == GPCMD_READ_10 || pc->c[0] == GPCMD_WRITE_10 ||
171 (pc->rq && blk_pc_request(pc->rq)))
172 uptodate = 1; /* FIXME */
173 else if (pc->c[0] == GPCMD_REQUEST_SENSE) {
174 u8 *buf = floppy->pc->buf;
Borislav Petkova6ff2d32008-02-02 19:56:34 +0100175
Borislav Petkov81f49382008-07-15 21:21:56 +0200176 if (!pc->error) {
177 floppy->sense_key = buf[2] & 0x0F;
178 floppy->asc = buf[12];
179 floppy->ascq = buf[13];
180 floppy->progress_indication = buf[15] & 0x80 ?
181 (u16)get_unaligned((u16 *)&buf[16]) : 0x10000;
182
183 if (floppy->failed_pc)
184 debug_log("pc = %x, ", floppy->failed_pc->c[0]);
185
Borislav Petkova6ff2d32008-02-02 19:56:34 +0100186 debug_log("sense key = %x, asc = %x, ascq = %x\n",
Borislav Petkov81f49382008-07-15 21:21:56 +0200187 floppy->sense_key, floppy->asc, floppy->ascq);
188 } else
189 printk(KERN_ERR "Error in REQUEST SENSE itself - "
190 "Aborting request!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192
Borislav Petkov81f49382008-07-15 21:21:56 +0200193 idefloppy_end_request(drive, uptodate, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194}
195
Bartlomiej Zolnierkiewicz01278542008-10-10 22:39:38 +0200196void ide_floppy_create_request_sense_cmd(struct ide_atapi_pc *pc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197{
Bartlomiej Zolnierkiewicz7bf74202008-10-10 22:39:37 +0200198 ide_init_pc(pc);
Borislav Petkov30d67092008-02-02 19:56:33 +0100199 pc->c[0] = GPCMD_REQUEST_SENSE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200 pc->c[4] = 255;
Borislav Petkov8e555122008-04-18 00:46:27 +0200201 pc->req_xfer = 18;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202}
203
204/*
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100205 * Called when an error was detected during the last packet command. We queue a
206 * request sense packet command in the head of the request list.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 */
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100208static void idefloppy_retry_pc(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209{
Bartlomiej Zolnierkiewicz394a4c22008-10-10 22:39:35 +0200210 struct ide_floppy_obj *floppy = drive->driver_data;
211 struct request *rq = &floppy->request_sense_rq;
Bartlomiej Zolnierkiewicz2e8a6f82008-10-10 22:39:36 +0200212 struct ide_atapi_pc *pc = &floppy->request_sense_pc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213
Bartlomiej Zolnierkiewicz64a57fe2008-02-06 02:57:51 +0100214 (void)ide_read_error(drive);
Bartlomiej Zolnierkiewicz01278542008-10-10 22:39:38 +0200215 ide_floppy_create_request_sense_cmd(pc);
Bartlomiej Zolnierkiewicz7645c152008-10-10 22:39:37 +0200216 ide_queue_pc_head(drive, floppy->disk, pc, rq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217}
218
Borislav Petkov0eea6452008-02-02 19:56:36 +0100219/* The usual interrupt handler called during a packet command. */
Paolo Ciarrocchi52d3ccf2008-04-26 17:36:41 +0200220static ide_startstop_t idefloppy_pc_intr(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221{
222 idefloppy_floppy_t *floppy = drive->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223
Bartlomiej Zolnierkiewicz646c0cb2008-07-15 21:22:03 +0200224 return ide_pc_intr(drive, floppy->pc, idefloppy_pc_intr,
Bartlomiej Zolnierkiewiczd6e29552008-10-10 22:39:39 +0200225 WAIT_FLOPPY_CMD, NULL, idefloppy_update_buffers,
Bartlomiej Zolnierkiewiczacaa0f52008-10-10 22:39:36 +0200226 idefloppy_retry_pc, NULL, ide_io_buffers);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227}
228
229/*
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100230 * What we have here is a classic case of a top half / bottom half interrupt
231 * service routine. In interrupt mode, the device sends an interrupt to signal
232 * that it is ready to receive a packet. However, we need to delay about 2-3
233 * ticks before issuing the packet or we gets in trouble.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234 */
Borislav Petkovcbbc4e82008-07-15 21:22:03 +0200235static int idefloppy_transfer_pc(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236{
237 idefloppy_floppy_t *floppy = drive->driver_data;
238
239 /* Send the actual packet */
Bartlomiej Zolnierkiewicz374e0422008-07-23 19:55:56 +0200240 drive->hwif->tp_ops->output_data(drive, NULL, floppy->pc->c, 12);
Bartlomiej Zolnierkiewicz9567b342008-04-28 23:44:36 +0200241
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 /* Timeout for the packet command */
Bartlomiej Zolnierkiewiczd6e29552008-10-10 22:39:39 +0200243 return WAIT_FLOPPY_CMD;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244}
245
Borislav Petkovcbbc4e82008-07-15 21:22:03 +0200246/*
247 * Called as an interrupt (or directly). When the device says it's ready for a
248 * packet, we schedule the packet transfer to occur about 2-3 ticks later in
249 * transfer_pc.
250 */
251static ide_startstop_t idefloppy_start_pc_transfer(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252{
253 idefloppy_floppy_t *floppy = drive->driver_data;
Bartlomiej Zolnierkiewicz6ffb66412008-07-15 21:21:56 +0200254 struct ide_atapi_pc *pc = floppy->pc;
Bartlomiej Zolnierkiewicz0b2eea42008-07-15 21:21:54 +0200255 ide_expiry_t *expiry;
256 unsigned int timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100258 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259 * The following delay solves a problem with ATAPI Zip 100 drives
260 * where the Busy flag was apparently being deasserted before the
261 * unit was ready to receive data. This was happening on a
262 * 1200 MHz Athlon system. 10/26/01 25msec is too short,
263 * 40 and 50msec work well. idefloppy_pc_intr will not be actually
264 * used until after the packet is moved in about 50 msec.
265 */
Borislav Petkovea68d272008-07-23 19:56:01 +0200266 if (drive->atapi_flags & IDE_AFLAG_ZIP_DRIVE) {
Bartlomiej Zolnierkiewicz0b2eea42008-07-15 21:21:54 +0200267 timeout = floppy->ticks;
Borislav Petkovcbbc4e82008-07-15 21:22:03 +0200268 expiry = &idefloppy_transfer_pc;
Bartlomiej Zolnierkiewicz0b2eea42008-07-15 21:21:54 +0200269 } else {
Bartlomiej Zolnierkiewiczd6e29552008-10-10 22:39:39 +0200270 timeout = WAIT_FLOPPY_CMD;
Bartlomiej Zolnierkiewicz0b2eea42008-07-15 21:21:54 +0200271 expiry = NULL;
272 }
Borislav Petkov0078df22008-02-02 19:56:33 +0100273
Bartlomiej Zolnierkiewicz594c16d2008-07-15 21:21:58 +0200274 return ide_transfer_pc(drive, pc, idefloppy_pc_intr, timeout, expiry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275}
276
Borislav Petkovd652c132008-02-02 19:56:35 +0100277static void ide_floppy_report_error(idefloppy_floppy_t *floppy,
Borislav Petkov8e555122008-04-18 00:46:27 +0200278 struct ide_atapi_pc *pc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279{
Borislav Petkovd652c132008-02-02 19:56:35 +0100280 /* supress error messages resulting from Medium not present */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 if (floppy->sense_key == 0x02 &&
282 floppy->asc == 0x3a &&
283 floppy->ascq == 0x00)
Borislav Petkovd652c132008-02-02 19:56:35 +0100284 return;
285
286 printk(KERN_ERR "ide-floppy: %s: I/O error, pc = %2x, key = %2x, "
287 "asc = %2x, ascq = %2x\n",
288 floppy->drive->name, pc->c[0], floppy->sense_key,
289 floppy->asc, floppy->ascq);
290
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291}
292
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100293static ide_startstop_t idefloppy_issue_pc(ide_drive_t *drive,
Borislav Petkov8e555122008-04-18 00:46:27 +0200294 struct ide_atapi_pc *pc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295{
296 idefloppy_floppy_t *floppy = drive->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298 if (floppy->failed_pc == NULL &&
Borislav Petkov30d67092008-02-02 19:56:33 +0100299 pc->c[0] != GPCMD_REQUEST_SENSE)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300 floppy->failed_pc = pc;
301 /* Set the current packet command */
302 floppy->pc = pc;
303
Borislav Petkov757ced82008-02-02 19:56:37 +0100304 if (pc->retries > IDEFLOPPY_MAX_PC_RETRIES) {
Borislav Petkov6e5fa7b2008-02-02 19:56:37 +0100305 if (!(pc->flags & PC_FLAG_SUPPRESS_ERROR))
Borislav Petkov757ced82008-02-02 19:56:37 +0100306 ide_floppy_report_error(floppy, pc);
307 /* Giving up */
308 pc->error = IDEFLOPPY_ERROR_GENERAL;
309
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 floppy->failed_pc = NULL;
Borislav Petkov2207fa52008-07-23 19:55:59 +0200311 drive->pc_callback(drive);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312 return ide_stopped;
313 }
314
Borislav Petkovbcc77d92008-02-02 19:56:34 +0100315 debug_log("Retry number - %d\n", pc->retries);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316
317 pc->retries++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318
Borislav Petkovcbbc4e82008-07-15 21:22:03 +0200319 return ide_issue_pc(drive, pc, idefloppy_start_pc_transfer,
Bartlomiej Zolnierkiewiczd6e29552008-10-10 22:39:39 +0200320 WAIT_FLOPPY_CMD, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321}
322
Bartlomiej Zolnierkiewicz01278542008-10-10 22:39:38 +0200323void ide_floppy_create_read_capacity_cmd(struct ide_atapi_pc *pc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324{
Bartlomiej Zolnierkiewicz7bf74202008-10-10 22:39:37 +0200325 ide_init_pc(pc);
Borislav Petkov30d67092008-02-02 19:56:33 +0100326 pc->c[0] = GPCMD_READ_FORMAT_CAPACITIES;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327 pc->c[7] = 255;
328 pc->c[8] = 255;
Borislav Petkov8e555122008-04-18 00:46:27 +0200329 pc->req_xfer = 255;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330}
331
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100332/* A mode sense command is used to "sense" floppy parameters. */
Bartlomiej Zolnierkiewicz01278542008-10-10 22:39:38 +0200333void ide_floppy_create_mode_sense_cmd(struct ide_atapi_pc *pc, u8 page_code)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334{
Borislav Petkov24a5d702008-02-02 19:56:34 +0100335 u16 length = 8; /* sizeof(Mode Parameter Header) = 8 Bytes */
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100336
Bartlomiej Zolnierkiewicz7bf74202008-10-10 22:39:37 +0200337 ide_init_pc(pc);
Borislav Petkov30d67092008-02-02 19:56:33 +0100338 pc->c[0] = GPCMD_MODE_SENSE_10;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 pc->c[1] = 0;
Bartlomiej Zolnierkiewicz4de4b9e2008-10-10 22:39:36 +0200340 pc->c[2] = page_code;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341
342 switch (page_code) {
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100343 case IDEFLOPPY_CAPABILITIES_PAGE:
344 length += 12;
345 break;
346 case IDEFLOPPY_FLEXIBLE_DISK_PAGE:
347 length += 32;
348 break;
349 default:
350 printk(KERN_ERR "ide-floppy: unsupported page code "
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 "in create_mode_sense_cmd\n");
352 }
Borislav Petkov8f622432008-02-02 19:56:33 +0100353 put_unaligned(cpu_to_be16(length), (u16 *) &pc->c[7]);
Borislav Petkov8e555122008-04-18 00:46:27 +0200354 pc->req_xfer = length;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355}
356
Borislav Petkovae7e8dd2008-02-02 19:56:36 +0100357static void idefloppy_create_rw_cmd(idefloppy_floppy_t *floppy,
Borislav Petkov8e555122008-04-18 00:46:27 +0200358 struct ide_atapi_pc *pc, struct request *rq,
Borislav Petkovae7e8dd2008-02-02 19:56:36 +0100359 unsigned long sector)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360{
361 int block = sector / floppy->bs_factor;
362 int blocks = rq->nr_sectors / floppy->bs_factor;
363 int cmd = rq_data_dir(rq);
364
Borislav Petkovae7e8dd2008-02-02 19:56:36 +0100365 debug_log("create_rw10_cmd: block == %d, blocks == %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366 block, blocks);
367
Bartlomiej Zolnierkiewicz7bf74202008-10-10 22:39:37 +0200368 ide_init_pc(pc);
Borislav Petkovae7e8dd2008-02-02 19:56:36 +0100369 pc->c[0] = cmd == READ ? GPCMD_READ_10 : GPCMD_WRITE_10;
370 put_unaligned(cpu_to_be16(blocks), (unsigned short *)&pc->c[7]);
Borislav Petkov8f622432008-02-02 19:56:33 +0100371 put_unaligned(cpu_to_be32(block), (unsigned int *) &pc->c[2]);
Borislav Petkovae7e8dd2008-02-02 19:56:36 +0100372
Borislav Petkov20cd93be672008-07-23 19:56:00 +0200373 memcpy(rq->cmd, pc->c, 12);
374
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 pc->rq = rq;
Borislav Petkovb98b3402008-10-10 22:39:35 +0200376 pc->b_count = 0;
Jens Axboe4aff5e22006-08-10 08:44:47 +0200377 if (rq->cmd_flags & REQ_RW)
Borislav Petkov6e5fa7b2008-02-02 19:56:37 +0100378 pc->flags |= PC_FLAG_WRITING;
Borislav Petkov8e555122008-04-18 00:46:27 +0200379 pc->buf = NULL;
380 pc->req_xfer = pc->buf_size = blocks * floppy->block_size;
Bartlomiej Zolnierkiewicz5e331092008-07-15 21:21:56 +0200381 pc->flags |= PC_FLAG_DMA_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382}
383
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100384static void idefloppy_blockpc_cmd(idefloppy_floppy_t *floppy,
Borislav Petkov8e555122008-04-18 00:46:27 +0200385 struct ide_atapi_pc *pc, struct request *rq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386{
Bartlomiej Zolnierkiewicz7bf74202008-10-10 22:39:37 +0200387 ide_init_pc(pc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 memcpy(pc->c, rq->cmd, sizeof(pc->c));
Jens Axboe3d6392c2007-07-09 12:38:05 +0200389 pc->rq = rq;
Borislav Petkovb98b3402008-10-10 22:39:35 +0200390 pc->b_count = 0;
Jens Axboe3d6392c2007-07-09 12:38:05 +0200391 if (rq->data_len && rq_data_dir(rq) == WRITE)
Borislav Petkov6e5fa7b2008-02-02 19:56:37 +0100392 pc->flags |= PC_FLAG_WRITING;
Borislav Petkov8e555122008-04-18 00:46:27 +0200393 pc->buf = rq->data;
Jens Axboe3d6392c2007-07-09 12:38:05 +0200394 if (rq->bio)
Bartlomiej Zolnierkiewicz5e331092008-07-15 21:21:56 +0200395 pc->flags |= PC_FLAG_DMA_OK;
Jens Axboe3d6392c2007-07-09 12:38:05 +0200396 /*
397 * possibly problematic, doesn't look like ide-floppy correctly
398 * handled scattered requests if dma fails...
399 */
Borislav Petkov8e555122008-04-18 00:46:27 +0200400 pc->req_xfer = pc->buf_size = rq->data_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401}
402
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100403static ide_startstop_t idefloppy_do_request(ide_drive_t *drive,
404 struct request *rq, sector_t block_s)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405{
406 idefloppy_floppy_t *floppy = drive->driver_data;
Borislav Petkovb98b3402008-10-10 22:39:35 +0200407 ide_hwif_t *hwif = drive->hwif;
Borislav Petkov8e555122008-04-18 00:46:27 +0200408 struct ide_atapi_pc *pc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 unsigned long block = (unsigned long)block_s;
410
Borislav Petkovb98b3402008-10-10 22:39:35 +0200411 debug_log("%s: dev: %s, cmd: 0x%x, cmd_type: %x, errors: %d\n",
412 __func__, rq->rq_disk ? rq->rq_disk->disk_name : "?",
413 rq->cmd[0], rq->cmd_type, rq->errors);
414
415 debug_log("%s: sector: %ld, nr_sectors: %ld, current_nr_sectors: %d\n",
416 __func__, (long)rq->sector, rq->nr_sectors,
417 rq->current_nr_sectors);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418
419 if (rq->errors >= ERROR_MAX) {
Borislav Petkovd652c132008-02-02 19:56:35 +0100420 if (floppy->failed_pc)
421 ide_floppy_report_error(floppy, floppy->failed_pc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 else
423 printk(KERN_ERR "ide-floppy: %s: I/O error\n",
424 drive->name);
Borislav Petkovc2b2b292008-04-18 00:46:27 +0200425 idefloppy_end_request(drive, 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 return ide_stopped;
427 }
Jens Axboe4aff5e22006-08-10 08:44:47 +0200428 if (blk_fs_request(rq)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429 if (((long)rq->sector % floppy->bs_factor) ||
430 (rq->nr_sectors % floppy->bs_factor)) {
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100431 printk(KERN_ERR "%s: unsupported r/w request size\n",
432 drive->name);
Borislav Petkovc2b2b292008-04-18 00:46:27 +0200433 idefloppy_end_request(drive, 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434 return ide_stopped;
435 }
Bartlomiej Zolnierkiewicz2e8a6f82008-10-10 22:39:36 +0200436 pc = &floppy->queued_pc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 idefloppy_create_rw_cmd(floppy, pc, rq, block);
Jens Axboe4aff5e22006-08-10 08:44:47 +0200438 } else if (blk_special_request(rq)) {
Borislav Petkov8e555122008-04-18 00:46:27 +0200439 pc = (struct ide_atapi_pc *) rq->buffer;
Jens Axboe4aff5e22006-08-10 08:44:47 +0200440 } else if (blk_pc_request(rq)) {
Bartlomiej Zolnierkiewicz2e8a6f82008-10-10 22:39:36 +0200441 pc = &floppy->queued_pc;
Jens Axboe3d6392c2007-07-09 12:38:05 +0200442 idefloppy_blockpc_cmd(floppy, pc, rq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443 } else {
444 blk_dump_rq_flags(rq,
445 "ide-floppy: unsupported command in queue");
Borislav Petkovc2b2b292008-04-18 00:46:27 +0200446 idefloppy_end_request(drive, 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447 return ide_stopped;
448 }
449
Borislav Petkovb98b3402008-10-10 22:39:35 +0200450 ide_init_sg_cmd(drive, rq);
451 ide_map_sg(drive, rq);
452
453 pc->sg = hwif->sg_table;
454 pc->sg_cnt = hwif->sg_nents;
455
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456 pc->rq = rq;
Bartlomiej Zolnierkiewicz5d418932008-07-15 21:21:57 +0200457
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458 return idefloppy_issue_pc(drive, pc);
459}
460
461/*
Borislav Petkov8e81bbb2008-02-02 19:56:35 +0100462 * Look at the flexible disk page parameters. We ignore the CHS capacity
463 * parameters and use the LBA parameters instead.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464 */
Borislav Petkov8e81bbb2008-02-02 19:56:35 +0100465static int ide_floppy_get_flexible_disk_page(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466{
467 idefloppy_floppy_t *floppy = drive->driver_data;
Bartlomiej Zolnierkiewicz2ac07d92008-10-10 22:39:38 +0200468 struct gendisk *disk = floppy->disk;
Borislav Petkov8e555122008-04-18 00:46:27 +0200469 struct ide_atapi_pc pc;
Borislav Petkov8e81bbb2008-02-02 19:56:35 +0100470 u8 *page;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471 int capacity, lba_capacity;
Borislav Petkov8e81bbb2008-02-02 19:56:35 +0100472 u16 transfer_rate, sector_size, cyls, rpm;
473 u8 heads, sectors;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474
Bartlomiej Zolnierkiewicz01278542008-10-10 22:39:38 +0200475 ide_floppy_create_mode_sense_cmd(&pc, IDEFLOPPY_FLEXIBLE_DISK_PAGE);
Borislav Petkov8e81bbb2008-02-02 19:56:35 +0100476
Bartlomiej Zolnierkiewicz2ac07d92008-10-10 22:39:38 +0200477 if (ide_queue_pc_tail(drive, disk, &pc)) {
Borislav Petkov8e81bbb2008-02-02 19:56:35 +0100478 printk(KERN_ERR "ide-floppy: Can't get flexible disk page"
479 " parameters\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 return 1;
481 }
Bartlomiej Zolnierkiewicz49cac392008-10-10 22:39:38 +0200482
483 if (pc.buf[3] & 0x80)
484 drive->atapi_flags |= IDE_AFLAG_WP;
485 else
486 drive->atapi_flags &= ~IDE_AFLAG_WP;
487
488 set_disk_ro(disk, !!(drive->atapi_flags & IDE_AFLAG_WP));
489
Borislav Petkov8e555122008-04-18 00:46:27 +0200490 page = &pc.buf[8];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491
Harvey Harrison85ae98a32008-07-16 20:33:47 +0200492 transfer_rate = be16_to_cpup((__be16 *)&pc.buf[8 + 2]);
493 sector_size = be16_to_cpup((__be16 *)&pc.buf[8 + 6]);
494 cyls = be16_to_cpup((__be16 *)&pc.buf[8 + 8]);
495 rpm = be16_to_cpup((__be16 *)&pc.buf[8 + 28]);
Borislav Petkov8e555122008-04-18 00:46:27 +0200496 heads = pc.buf[8 + 4];
497 sectors = pc.buf[8 + 5];
Borislav Petkov8e81bbb2008-02-02 19:56:35 +0100498
499 capacity = cyls * heads * sectors * sector_size;
500
501 if (memcmp(page, &floppy->flexible_disk_page, 32))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502 printk(KERN_INFO "%s: %dkB, %d/%d/%d CHS, %d kBps, "
503 "%d sector size, %d rpm\n",
Borislav Petkov8e81bbb2008-02-02 19:56:35 +0100504 drive->name, capacity / 1024, cyls, heads,
505 sectors, transfer_rate / 8, sector_size, rpm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506
Borislav Petkov8e81bbb2008-02-02 19:56:35 +0100507 memcpy(&floppy->flexible_disk_page, page, 32);
508 drive->bios_cyl = cyls;
509 drive->bios_head = heads;
510 drive->bios_sect = sectors;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511 lba_capacity = floppy->blocks * floppy->block_size;
Borislav Petkov8e81bbb2008-02-02 19:56:35 +0100512
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 if (capacity < lba_capacity) {
514 printk(KERN_NOTICE "%s: The disk reports a capacity of %d "
515 "bytes, but the drive only handles %d\n",
516 drive->name, lba_capacity, capacity);
Borislav Petkov8e81bbb2008-02-02 19:56:35 +0100517 floppy->blocks = floppy->block_size ?
518 capacity / floppy->block_size : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519 }
520 return 0;
521}
522
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523/*
Borislav Petkov194ec0c2008-02-02 19:56:35 +0100524 * Determine if a media is present in the floppy drive, and if so, its LBA
525 * capacity.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 */
Borislav Petkov194ec0c2008-02-02 19:56:35 +0100527static int ide_floppy_get_capacity(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528{
529 idefloppy_floppy_t *floppy = drive->driver_data;
Bartlomiej Zolnierkiewicz2ac07d92008-10-10 22:39:38 +0200530 struct gendisk *disk = floppy->disk;
Borislav Petkov8e555122008-04-18 00:46:27 +0200531 struct ide_atapi_pc pc;
Borislav Petkov194ec0c2008-02-02 19:56:35 +0100532 u8 *cap_desc;
533 u8 header_len, desc_cnt;
534 int i, rc = 1, blocks, length;
535
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 drive->bios_cyl = 0;
537 drive->bios_head = drive->bios_sect = 0;
Alan Coxfdb77da2007-02-17 02:40:20 +0100538 floppy->blocks = 0;
539 floppy->bs_factor = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540 set_capacity(floppy->disk, 0);
541
Bartlomiej Zolnierkiewicz01278542008-10-10 22:39:38 +0200542 ide_floppy_create_read_capacity_cmd(&pc);
Bartlomiej Zolnierkiewicz2ac07d92008-10-10 22:39:38 +0200543 if (ide_queue_pc_tail(drive, disk, &pc)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 printk(KERN_ERR "ide-floppy: Can't get floppy parameters\n");
545 return 1;
546 }
Borislav Petkov8e555122008-04-18 00:46:27 +0200547 header_len = pc.buf[3];
548 cap_desc = &pc.buf[4];
Borislav Petkov194ec0c2008-02-02 19:56:35 +0100549 desc_cnt = header_len / 8; /* capacity descriptor of 8 bytes */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550
Borislav Petkov194ec0c2008-02-02 19:56:35 +0100551 for (i = 0; i < desc_cnt; i++) {
552 unsigned int desc_start = 4 + i*8;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553
Harvey Harrison85ae98a32008-07-16 20:33:47 +0200554 blocks = be32_to_cpup((__be32 *)&pc.buf[desc_start]);
555 length = be16_to_cpup((__be16 *)&pc.buf[desc_start + 6]);
Borislav Petkov194ec0c2008-02-02 19:56:35 +0100556
557 debug_log("Descriptor %d: %dkB, %d blocks, %d sector size\n",
558 i, blocks * length / 1024, blocks, length);
559
560 if (i)
561 continue;
562 /*
563 * the code below is valid only for the 1st descriptor, ie i=0
564 */
565
Borislav Petkov8e555122008-04-18 00:46:27 +0200566 switch (pc.buf[desc_start + 4] & 0x03) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567 /* Clik! drive returns this instead of CAPACITY_CURRENT */
568 case CAPACITY_UNFORMATTED:
Borislav Petkovea68d272008-07-23 19:56:01 +0200569 if (!(drive->atapi_flags & IDE_AFLAG_CLIK_DRIVE))
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100570 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571 * If it is not a clik drive, break out
572 * (maintains previous driver behaviour)
573 */
574 break;
575 case CAPACITY_CURRENT:
576 /* Normal Zip/LS-120 disks */
Borislav Petkov194ec0c2008-02-02 19:56:35 +0100577 if (memcmp(cap_desc, &floppy->cap_desc, 8))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578 printk(KERN_INFO "%s: %dkB, %d blocks, %d "
579 "sector size\n", drive->name,
580 blocks * length / 1024, blocks, length);
Borislav Petkov194ec0c2008-02-02 19:56:35 +0100581 memcpy(&floppy->cap_desc, cap_desc, 8);
582
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583 if (!length || length % 512) {
584 printk(KERN_NOTICE "%s: %d bytes block size "
585 "not supported\n", drive->name, length);
586 } else {
Borislav Petkov194ec0c2008-02-02 19:56:35 +0100587 floppy->blocks = blocks;
588 floppy->block_size = length;
589 floppy->bs_factor = length / 512;
590 if (floppy->bs_factor != 1)
591 printk(KERN_NOTICE "%s: warning: non "
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 "512 bytes block size not "
593 "fully supported\n",
594 drive->name);
Borislav Petkov194ec0c2008-02-02 19:56:35 +0100595 rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596 }
597 break;
598 case CAPACITY_NO_CARTRIDGE:
599 /*
600 * This is a KERN_ERR so it appears on screen
601 * for the user to see
602 */
603 printk(KERN_ERR "%s: No disk in drive\n", drive->name);
604 break;
605 case CAPACITY_INVALID:
606 printk(KERN_ERR "%s: Invalid capacity for disk "
607 "in drive\n", drive->name);
608 break;
609 }
Borislav Petkov194ec0c2008-02-02 19:56:35 +0100610 debug_log("Descriptor 0 Code: %d\n",
Borislav Petkov8e555122008-04-18 00:46:27 +0200611 pc.buf[desc_start + 4] & 0x03);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612 }
613
614 /* Clik! disk does not support get_flexible_disk_page */
Borislav Petkovea68d272008-07-23 19:56:01 +0200615 if (!(drive->atapi_flags & IDE_AFLAG_CLIK_DRIVE))
Borislav Petkov8e81bbb2008-02-02 19:56:35 +0100616 (void) ide_floppy_get_flexible_disk_page(drive);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617
Bartlomiej Zolnierkiewicz2ac07d92008-10-10 22:39:38 +0200618 set_capacity(disk, floppy->blocks * floppy->bs_factor);
619
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620 return rc;
621}
622
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100623static sector_t idefloppy_capacity(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624{
625 idefloppy_floppy_t *floppy = drive->driver_data;
626 unsigned long capacity = floppy->blocks * floppy->bs_factor;
627
628 return capacity;
629}
630
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200631#ifdef CONFIG_IDE_PROC_FS
Elias Oltmanns92f1f8f2008-10-10 22:39:40 +0200632ide_devset_rw_field(bios_cyl, bios_cyl);
633ide_devset_rw_field(bios_head, bios_head);
634ide_devset_rw_field(bios_sect, bios_sect);
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +0200635
636static int get_ticks(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637{
638 idefloppy_floppy_t *floppy = drive->driver_data;
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +0200639 return floppy->ticks;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640}
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +0200641
642static int set_ticks(ide_drive_t *drive, int arg)
643{
644 idefloppy_floppy_t *floppy = drive->driver_data;
645 floppy->ticks = arg;
646 return 0;
647}
648
Elias Oltmanns92f1f8f2008-10-10 22:39:40 +0200649IDE_DEVSET(ticks, DS_SYNC, get_ticks, set_ticks);
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +0200650
Elias Oltmanns92f1f8f2008-10-10 22:39:40 +0200651static const struct ide_proc_devset idefloppy_settings[] = {
652 IDE_PROC_DEVSET(bios_cyl, 0, 1023),
653 IDE_PROC_DEVSET(bios_head, 0, 255),
654 IDE_PROC_DEVSET(bios_sect, 0, 63),
655 IDE_PROC_DEVSET(ticks, 0, 255),
656 { 0 },
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +0200657};
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200658#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100660static void idefloppy_setup(ide_drive_t *drive, idefloppy_floppy_t *floppy)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661{
Bartlomiej Zolnierkiewicz4dde4492008-10-10 22:39:19 +0200662 u16 *id = drive->id;
Borislav Petkov3ad67762008-04-18 00:46:25 +0200663 u8 gcw[2];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664
Bartlomiej Zolnierkiewicz4dde4492008-10-10 22:39:19 +0200665 *((u16 *)&gcw) = id[ATA_ID_CONFIG];
Bartlomiej Zolnierkiewicz2e8a6f82008-10-10 22:39:36 +0200666
Borislav Petkov2207fa52008-07-23 19:55:59 +0200667 drive->pc_callback = ide_floppy_callback;
Borislav Petkov3ad67762008-04-18 00:46:25 +0200668
669 if (((gcw[0] & 0x60) >> 5) == 1)
Borislav Petkovea68d272008-07-23 19:56:01 +0200670 drive->atapi_flags |= IDE_AFLAG_DRQ_INTERRUPT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671 /*
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100672 * We used to check revisions here. At this point however I'm giving up.
673 * Just assume they are all broken, its easier.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674 *
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100675 * The actual reason for the workarounds was likely a driver bug after
676 * all rather than a firmware bug, and the workaround below used to hide
677 * it. It should be fixed as of version 1.9, but to be on the safe side
678 * we'll leave the limitation below for the 2.2.x tree.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679 */
Bartlomiej Zolnierkiewicz4dde4492008-10-10 22:39:19 +0200680 if (!strncmp((char *)&id[ATA_ID_PROD], "IOMEGA ZIP 100 ATAPI", 20)) {
Borislav Petkovea68d272008-07-23 19:56:01 +0200681 drive->atapi_flags |= IDE_AFLAG_ZIP_DRIVE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682 /* This value will be visible in the /proc/ide/hdx/settings */
683 floppy->ticks = IDEFLOPPY_TICKS_DELAY;
684 blk_queue_max_sectors(drive->queue, 64);
685 }
686
687 /*
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100688 * Guess what? The IOMEGA Clik! drive also needs the above fix. It makes
689 * nasty clicking noises without it, so please don't remove this.
690 */
Bartlomiej Zolnierkiewicz4dde4492008-10-10 22:39:19 +0200691 if (strncmp((char *)&id[ATA_ID_PROD], "IOMEGA Clik!", 11) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692 blk_queue_max_sectors(drive->queue, 64);
Borislav Petkovea68d272008-07-23 19:56:01 +0200693 drive->atapi_flags |= IDE_AFLAG_CLIK_DRIVE;
Bartlomiej Zolnierkiewicz05780422008-10-10 22:39:38 +0200694 /* IOMEGA Clik! drives do not support lock/unlock commands */
695 drive->atapi_flags |= IDE_AFLAG_NO_DOORLOCK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696 }
697
Borislav Petkov194ec0c2008-02-02 19:56:35 +0100698 (void) ide_floppy_get_capacity(drive);
Bartlomiej Zolnierkiewicz1e874f42008-10-10 22:39:27 +0200699
700 ide_proc_register_driver(drive, floppy->driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701}
702
Russell King4031bbe2006-01-06 11:41:00 +0000703static void ide_floppy_remove(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704{
705 idefloppy_floppy_t *floppy = drive->driver_data;
706 struct gendisk *g = floppy->disk;
707
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200708 ide_proc_unregister_driver(drive, floppy->driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709
710 del_gendisk(g);
711
712 ide_floppy_put(floppy);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713}
714
Borislav Petkov9a24b632008-02-02 19:56:33 +0100715static void idefloppy_cleanup_obj(struct kref *kref)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716{
717 struct ide_floppy_obj *floppy = to_ide_floppy(kref);
718 ide_drive_t *drive = floppy->drive;
719 struct gendisk *g = floppy->disk;
720
721 drive->driver_data = NULL;
722 g->private_data = NULL;
723 put_disk(g);
724 kfree(floppy);
725}
726
Bartlomiej Zolnierkiewiczecfd80e2007-05-10 00:01:09 +0200727#ifdef CONFIG_IDE_PROC_FS
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100728static int proc_idefloppy_read_capacity(char *page, char **start, off_t off,
729 int count, int *eof, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730{
731 ide_drive_t*drive = (ide_drive_t *)data;
732 int len;
733
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100734 len = sprintf(page, "%llu\n", (long long)idefloppy_capacity(drive));
735 PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736}
737
738static ide_proc_entry_t idefloppy_proc[] = {
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100739 { "capacity", S_IFREG|S_IRUGO, proc_idefloppy_read_capacity, NULL },
740 { "geometry", S_IFREG|S_IRUGO, proc_ide_read_geometry, NULL },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741 { NULL, 0, NULL, NULL }
742};
Bartlomiej Zolnierkiewiczecfd80e2007-05-10 00:01:09 +0200743#endif /* CONFIG_IDE_PROC_FS */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744
Russell King4031bbe2006-01-06 11:41:00 +0000745static int ide_floppy_probe(ide_drive_t *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747static ide_driver_t idefloppy_driver = {
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +0200748 .gen_driver = {
Laurent Riffard4ef3b8f2005-11-18 22:15:40 +0100749 .owner = THIS_MODULE,
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +0200750 .name = "ide-floppy",
751 .bus = &ide_bus_type,
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +0200752 },
Russell King4031bbe2006-01-06 11:41:00 +0000753 .probe = ide_floppy_probe,
754 .remove = ide_floppy_remove,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755 .version = IDEFLOPPY_VERSION,
756 .media = ide_floppy,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757 .do_request = idefloppy_do_request,
Borislav Petkovc2b2b292008-04-18 00:46:27 +0200758 .end_request = idefloppy_end_request,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 .error = __ide_error,
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200760#ifdef CONFIG_IDE_PROC_FS
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761 .proc = idefloppy_proc,
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +0200762 .settings = idefloppy_settings,
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200763#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764};
765
766static int idefloppy_open(struct inode *inode, struct file *filp)
767{
768 struct gendisk *disk = inode->i_bdev->bd_disk;
769 struct ide_floppy_obj *floppy;
770 ide_drive_t *drive;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771 int ret = 0;
772
Borislav Petkovbcc77d92008-02-02 19:56:34 +0100773 debug_log("Reached %s\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100775 floppy = ide_floppy_get(disk);
776 if (!floppy)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777 return -ENXIO;
778
779 drive = floppy->drive;
780
Bartlomiej Zolnierkiewiczc94964a2007-02-17 02:40:24 +0100781 floppy->openers++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782
Bartlomiej Zolnierkiewiczc94964a2007-02-17 02:40:24 +0100783 if (floppy->openers == 1) {
Borislav Petkovea68d272008-07-23 19:56:01 +0200784 drive->atapi_flags &= ~IDE_AFLAG_FORMAT_IN_PROGRESS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785 /* Just in case */
786
Bartlomiej Zolnierkiewiczde699ad2008-10-10 22:39:39 +0200787 if (ide_do_test_unit_ready(drive, disk))
Bartlomiej Zolnierkiewicz0c8a6c72008-10-10 22:39:39 +0200788 ide_do_start_stop(drive, disk, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789
Borislav Petkov194ec0c2008-02-02 19:56:35 +0100790 if (ide_floppy_get_capacity(drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791 && (filp->f_flags & O_NDELAY) == 0
792 /*
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100793 * Allow O_NDELAY to open a drive without a disk, or with an
794 * unreadable disk, so that we can get the format capacity
795 * of the drive or begin the format - Sam
796 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797 ) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798 ret = -EIO;
799 goto out_put_floppy;
800 }
801
Bartlomiej Zolnierkiewicz49cac392008-10-10 22:39:38 +0200802 if ((drive->atapi_flags & IDE_AFLAG_WP) && (filp->f_mode & 2)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 ret = -EROFS;
804 goto out_put_floppy;
805 }
Bartlomiej Zolnierkiewicze996fc82008-10-10 22:39:37 +0200806
Borislav Petkovea68d272008-07-23 19:56:01 +0200807 drive->atapi_flags |= IDE_AFLAG_MEDIA_CHANGED;
Bartlomiej Zolnierkiewicz05780422008-10-10 22:39:38 +0200808 ide_set_media_lock(drive, disk, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809 check_disk_change(inode->i_bdev);
Borislav Petkovea68d272008-07-23 19:56:01 +0200810 } else if (drive->atapi_flags & IDE_AFLAG_FORMAT_IN_PROGRESS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811 ret = -EBUSY;
812 goto out_put_floppy;
813 }
814 return 0;
815
816out_put_floppy:
Bartlomiej Zolnierkiewiczc94964a2007-02-17 02:40:24 +0100817 floppy->openers--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818 ide_floppy_put(floppy);
819 return ret;
820}
821
822static int idefloppy_release(struct inode *inode, struct file *filp)
823{
824 struct gendisk *disk = inode->i_bdev->bd_disk;
825 struct ide_floppy_obj *floppy = ide_floppy_g(disk);
826 ide_drive_t *drive = floppy->drive;
Borislav Petkovbcc77d92008-02-02 19:56:34 +0100827
828 debug_log("Reached %s\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829
Bartlomiej Zolnierkiewiczc94964a2007-02-17 02:40:24 +0100830 if (floppy->openers == 1) {
Bartlomiej Zolnierkiewicz05780422008-10-10 22:39:38 +0200831 ide_set_media_lock(drive, disk, 0);
Borislav Petkovea68d272008-07-23 19:56:01 +0200832 drive->atapi_flags &= ~IDE_AFLAG_FORMAT_IN_PROGRESS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833 }
Bartlomiej Zolnierkiewiczc94964a2007-02-17 02:40:24 +0100834
835 floppy->openers--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836
837 ide_floppy_put(floppy);
838
839 return 0;
840}
841
Christoph Hellwiga885c8c2006-01-08 01:02:50 -0800842static int idefloppy_getgeo(struct block_device *bdev, struct hd_geometry *geo)
843{
844 struct ide_floppy_obj *floppy = ide_floppy_g(bdev->bd_disk);
845 ide_drive_t *drive = floppy->drive;
846
847 geo->heads = drive->bios_head;
848 geo->sectors = drive->bios_sect;
849 geo->cylinders = (u16)drive->bios_cyl; /* truncate */
850 return 0;
851}
852
Borislav Petkovea68d272008-07-23 19:56:01 +0200853static int ide_floppy_lockdoor(ide_drive_t *drive, struct ide_atapi_pc *pc,
854 unsigned long arg, unsigned int cmd)
Borislav Petkov20bf7bd2008-02-02 19:56:35 +0100855{
Borislav Petkovea68d272008-07-23 19:56:01 +0200856 idefloppy_floppy_t *floppy = drive->driver_data;
Bartlomiej Zolnierkiewicz05780422008-10-10 22:39:38 +0200857 struct gendisk *disk = floppy->disk;
Bartlomiej Zolnierkiewicze996fc82008-10-10 22:39:37 +0200858 int prevent = (arg && cmd != CDROMEJECT) ? 1 : 0;
Borislav Petkovea68d272008-07-23 19:56:01 +0200859
Borislav Petkov20bf7bd2008-02-02 19:56:35 +0100860 if (floppy->openers > 1)
861 return -EBUSY;
862
Bartlomiej Zolnierkiewicz05780422008-10-10 22:39:38 +0200863 ide_set_media_lock(drive, disk, prevent);
Borislav Petkov20bf7bd2008-02-02 19:56:35 +0100864
Bartlomiej Zolnierkiewicz0c8a6c72008-10-10 22:39:39 +0200865 if (cmd == CDROMEJECT)
866 ide_do_start_stop(drive, disk, 2);
Borislav Petkov20bf7bd2008-02-02 19:56:35 +0100867
868 return 0;
869}
870
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871static int idefloppy_ioctl(struct inode *inode, struct file *file,
872 unsigned int cmd, unsigned long arg)
873{
874 struct block_device *bdev = inode->i_bdev;
875 struct ide_floppy_obj *floppy = ide_floppy_g(bdev->bd_disk);
876 ide_drive_t *drive = floppy->drive;
Borislav Petkov8e555122008-04-18 00:46:27 +0200877 struct ide_atapi_pc pc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878 void __user *argp = (void __user *)arg;
Ondrej Zary07203f62005-11-10 00:25:15 +0100879 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880
Bartlomiej Zolnierkiewiczd56c99e2008-10-10 22:39:34 +0200881 if (cmd == CDROMEJECT || cmd == CDROM_LOCKDOOR)
Borislav Petkovea68d272008-07-23 19:56:01 +0200882 return ide_floppy_lockdoor(drive, &pc, arg, cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883
Bartlomiej Zolnierkiewiczd56c99e2008-10-10 22:39:34 +0200884 err = ide_floppy_format_ioctl(drive, file, cmd, argp);
885 if (err != -ENOTTY)
886 return err;
Bartlomiej Zolnierkiewicz89636af2007-07-20 01:11:59 +0200887
888 /*
889 * skip SCSI_IOCTL_SEND_COMMAND (deprecated)
890 * and CDROM_SEND_PACKET (legacy) ioctls
891 */
892 if (cmd != CDROM_SEND_PACKET && cmd != SCSI_IOCTL_SEND_COMMAND)
893 err = scsi_cmd_ioctl(file, bdev->bd_disk->queue,
894 bdev->bd_disk, cmd, argp);
Bartlomiej Zolnierkiewicz89636af2007-07-20 01:11:59 +0200895
896 if (err == -ENOTTY)
897 err = generic_ide_ioctl(drive, file, bdev, cmd, arg);
898
899 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900}
901
902static int idefloppy_media_changed(struct gendisk *disk)
903{
904 struct ide_floppy_obj *floppy = ide_floppy_g(disk);
905 ide_drive_t *drive = floppy->drive;
Borislav Petkov6e5fa7b2008-02-02 19:56:37 +0100906 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907
908 /* do not scan partitions twice if this is a removable device */
909 if (drive->attach) {
910 drive->attach = 0;
911 return 0;
912 }
Borislav Petkovea68d272008-07-23 19:56:01 +0200913 ret = !!(drive->atapi_flags & IDE_AFLAG_MEDIA_CHANGED);
914 drive->atapi_flags &= ~IDE_AFLAG_MEDIA_CHANGED;
Borislav Petkov6e5fa7b2008-02-02 19:56:37 +0100915 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916}
917
918static int idefloppy_revalidate_disk(struct gendisk *disk)
919{
920 struct ide_floppy_obj *floppy = ide_floppy_g(disk);
921 set_capacity(disk, idefloppy_capacity(floppy->drive));
922 return 0;
923}
924
925static struct block_device_operations idefloppy_ops = {
Paolo Ciarrocchi52d3ccf2008-04-26 17:36:41 +0200926 .owner = THIS_MODULE,
927 .open = idefloppy_open,
928 .release = idefloppy_release,
929 .ioctl = idefloppy_ioctl,
930 .getgeo = idefloppy_getgeo,
931 .media_changed = idefloppy_media_changed,
932 .revalidate_disk = idefloppy_revalidate_disk
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933};
934
Russell King4031bbe2006-01-06 11:41:00 +0000935static int ide_floppy_probe(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936{
937 idefloppy_floppy_t *floppy;
938 struct gendisk *g;
939
940 if (!strstr("ide-floppy", drive->driver_req))
941 goto failed;
Bartlomiej Zolnierkiewicz2a924662008-10-10 22:39:24 +0200942
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943 if (drive->media != ide_floppy)
944 goto failed;
Bartlomiej Zolnierkiewicz2a924662008-10-10 22:39:24 +0200945
Bartlomiej Zolnierkiewicz51509ee2008-10-10 22:39:34 +0200946 if (!ide_check_atapi_device(drive, DRV_NAME)) {
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100947 printk(KERN_ERR "ide-floppy: %s: not supported by this version"
948 " of ide-floppy\n", drive->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949 goto failed;
950 }
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100951 floppy = kzalloc(sizeof(idefloppy_floppy_t), GFP_KERNEL);
952 if (!floppy) {
953 printk(KERN_ERR "ide-floppy: %s: Can't allocate a floppy"
954 " structure\n", drive->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955 goto failed;
956 }
957
958 g = alloc_disk(1 << PARTN_BITS);
959 if (!g)
960 goto out_free_floppy;
961
962 ide_init_disk(g, drive);
963
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964 kref_init(&floppy->kref);
965
966 floppy->drive = drive;
967 floppy->driver = &idefloppy_driver;
968 floppy->disk = g;
969
970 g->private_data = &floppy->driver;
971
972 drive->driver_data = floppy;
973
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100974 idefloppy_setup(drive, floppy);
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +0200975
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976 g->minors = 1 << PARTN_BITS;
977 g->driverfs_dev = &drive->gendev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978 g->flags = drive->removable ? GENHD_FL_REMOVABLE : 0;
979 g->fops = &idefloppy_ops;
980 drive->attach = 1;
981 add_disk(g);
982 return 0;
983
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984out_free_floppy:
985 kfree(floppy);
986failed:
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +0200987 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988}
989
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100990static void __exit idefloppy_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700991{
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +0200992 driver_unregister(&idefloppy_driver.gen_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993}
994
Bartlomiej Zolnierkiewicz17514e82005-11-19 22:24:35 +0100995static int __init idefloppy_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996{
997 printk("ide-floppy driver " IDEFLOPPY_VERSION "\n");
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +0200998 return driver_register(&idefloppy_driver.gen_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999}
1000
Kay Sievers263756e2005-12-12 18:03:44 +01001001MODULE_ALIAS("ide:*m-floppy*");
Bartlomiej Zolnierkiewicz01278542008-10-10 22:39:38 +02001002MODULE_ALIAS("ide-floppy");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003module_init(idefloppy_init);
1004module_exit(idefloppy_exit);
1005MODULE_LICENSE("GPL");
Borislav Petkov0571c7a2008-02-02 19:56:38 +01001006MODULE_DESCRIPTION("ATAPI FLOPPY Driver");
1007