blob: 4d7e9ef8242549ba23fc33867ce1f28c4d9638b2 [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
64
Borislav Petkov0571c7a2008-02-02 19:56:38 +010065/* Some drives require a longer irq timeout. */
Linus Torvalds1da177e2005-04-16 15:20:36 -070066#define IDEFLOPPY_WAIT_CMD (5 * WAIT_CMD)
67
68/*
Borislav Petkov0571c7a2008-02-02 19:56:38 +010069 * After each failed packet command we issue a request sense command and retry
70 * the packet command IDEFLOPPY_MAX_PC_RETRIES times.
Linus Torvalds1da177e2005-04-16 15:20:36 -070071 */
72#define IDEFLOPPY_MAX_PC_RETRIES 3
73
Borislav Petkov194ec0c2008-02-02 19:56:35 +010074/* format capacities descriptor codes */
Linus Torvalds1da177e2005-04-16 15:20:36 -070075#define CAPACITY_INVALID 0x00
76#define CAPACITY_UNFORMATTED 0x01
77#define CAPACITY_CURRENT 0x02
78#define CAPACITY_NO_CARTRIDGE 0x03
79
Bartlomiej Zolnierkiewiczc40d3d32005-08-18 22:09:21 +020080#define IDEFLOPPY_TICKS_DELAY HZ/20 /* default delay for ZIP 100 (50ms) */
Linus Torvalds1da177e2005-04-16 15:20:36 -070081
Borislav Petkov0571c7a2008-02-02 19:56:38 +010082/* Error code returned in rq->errors to the higher part of the driver. */
Linus Torvalds1da177e2005-04-16 15:20:36 -070083#define IDEFLOPPY_ERROR_GENERAL 101
84
Arjan van de Vencf8b8972006-03-23 03:00:45 -080085static DEFINE_MUTEX(idefloppy_ref_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070086
87#define to_ide_floppy(obj) container_of(obj, struct ide_floppy_obj, kref)
88
89#define ide_floppy_g(disk) \
90 container_of((disk)->private_data, struct ide_floppy_obj, driver)
91
Bartlomiej Zolnierkiewicz08da5912008-07-24 22:53:15 +020092static void idefloppy_cleanup_obj(struct kref *);
93
Linus Torvalds1da177e2005-04-16 15:20:36 -070094static struct ide_floppy_obj *ide_floppy_get(struct gendisk *disk)
95{
96 struct ide_floppy_obj *floppy = NULL;
97
Arjan van de Vencf8b8972006-03-23 03:00:45 -080098 mutex_lock(&idefloppy_ref_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070099 floppy = ide_floppy_g(disk);
Bartlomiej Zolnierkiewicz08da5912008-07-24 22:53:15 +0200100 if (floppy) {
Bartlomiej Zolnierkiewiczd3e33ff2008-08-05 18:16:59 +0200101 if (ide_device_get(floppy->drive))
Bartlomiej Zolnierkiewicz08da5912008-07-24 22:53:15 +0200102 floppy = NULL;
Bartlomiej Zolnierkiewiczd3e33ff2008-08-05 18:16:59 +0200103 else
104 kref_get(&floppy->kref);
Bartlomiej Zolnierkiewicz08da5912008-07-24 22:53:15 +0200105 }
Arjan van de Vencf8b8972006-03-23 03:00:45 -0800106 mutex_unlock(&idefloppy_ref_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107 return floppy;
108}
109
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110static void ide_floppy_put(struct ide_floppy_obj *floppy)
111{
Bartlomiej Zolnierkiewiczd3e33ff2008-08-05 18:16:59 +0200112 ide_drive_t *drive = floppy->drive;
113
Arjan van de Vencf8b8972006-03-23 03:00:45 -0800114 mutex_lock(&idefloppy_ref_mutex);
Borislav Petkov9a24b632008-02-02 19:56:33 +0100115 kref_put(&floppy->kref, idefloppy_cleanup_obj);
Bartlomiej Zolnierkiewiczd3e33ff2008-08-05 18:16:59 +0200116 ide_device_put(drive);
Arjan van de Vencf8b8972006-03-23 03:00:45 -0800117 mutex_unlock(&idefloppy_ref_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118}
119
120/*
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100121 * Used to finish servicing a request. For read/write requests, we will call
122 * ide_end_request to pass to the next buffer.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123 */
Borislav Petkovc2b2b292008-04-18 00:46:27 +0200124static int idefloppy_end_request(ide_drive_t *drive, int uptodate, int nsecs)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125{
126 idefloppy_floppy_t *floppy = drive->driver_data;
127 struct request *rq = HWGROUP(drive)->rq;
128 int error;
129
Borislav Petkovbcc77d92008-02-02 19:56:34 +0100130 debug_log("Reached %s\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131
132 switch (uptodate) {
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100133 case 0: error = IDEFLOPPY_ERROR_GENERAL; break;
134 case 1: error = 0; break;
135 default: error = uptodate;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136 }
137 if (error)
138 floppy->failed_pc = NULL;
139 /* Why does this happen? */
140 if (!rq)
141 return 0;
Jens Axboe4aff5e22006-08-10 08:44:47 +0200142 if (!blk_special_request(rq)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143 /* our real local end request function */
144 ide_end_request(drive, uptodate, nsecs);
145 return 0;
146 }
147 rq->errors = error;
148 /* fixme: need to move this local also */
149 ide_end_drive_cmd(drive, 0, 0);
150 return 0;
151}
152
Borislav Petkov8e555122008-04-18 00:46:27 +0200153static void idefloppy_update_buffers(ide_drive_t *drive,
154 struct ide_atapi_pc *pc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155{
156 struct request *rq = pc->rq;
157 struct bio *bio = rq->bio;
158
159 while ((bio = rq->bio) != NULL)
Borislav Petkovc2b2b292008-04-18 00:46:27 +0200160 idefloppy_end_request(drive, 1, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161}
162
Borislav Petkov81f49382008-07-15 21:21:56 +0200163static void ide_floppy_callback(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164{
165 idefloppy_floppy_t *floppy = drive->driver_data;
Borislav Petkov81f49382008-07-15 21:21:56 +0200166 struct ide_atapi_pc *pc = floppy->pc;
167 int uptodate = pc->error ? 0 : 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168
Borislav Petkovbcc77d92008-02-02 19:56:34 +0100169 debug_log("Reached %s\n", __func__);
170
Bartlomiej Zolnierkiewiczdd2e9a02008-07-15 21:22:01 +0200171 if (floppy->failed_pc == pc)
172 floppy->failed_pc = NULL;
173
Borislav Petkov81f49382008-07-15 21:21:56 +0200174 if (pc->c[0] == GPCMD_READ_10 || pc->c[0] == GPCMD_WRITE_10 ||
175 (pc->rq && blk_pc_request(pc->rq)))
176 uptodate = 1; /* FIXME */
177 else if (pc->c[0] == GPCMD_REQUEST_SENSE) {
178 u8 *buf = floppy->pc->buf;
Borislav Petkova6ff2d32008-02-02 19:56:34 +0100179
Borislav Petkov81f49382008-07-15 21:21:56 +0200180 if (!pc->error) {
181 floppy->sense_key = buf[2] & 0x0F;
182 floppy->asc = buf[12];
183 floppy->ascq = buf[13];
184 floppy->progress_indication = buf[15] & 0x80 ?
185 (u16)get_unaligned((u16 *)&buf[16]) : 0x10000;
186
187 if (floppy->failed_pc)
188 debug_log("pc = %x, ", floppy->failed_pc->c[0]);
189
Borislav Petkova6ff2d32008-02-02 19:56:34 +0100190 debug_log("sense key = %x, asc = %x, ascq = %x\n",
Borislav Petkov81f49382008-07-15 21:21:56 +0200191 floppy->sense_key, floppy->asc, floppy->ascq);
192 } else
193 printk(KERN_ERR "Error in REQUEST SENSE itself - "
194 "Aborting request!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196
Borislav Petkov81f49382008-07-15 21:21:56 +0200197 idefloppy_end_request(drive, uptodate, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198}
199
Bartlomiej Zolnierkiewicz01278542008-10-10 22:39:38 +0200200void ide_floppy_create_request_sense_cmd(struct ide_atapi_pc *pc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201{
Bartlomiej Zolnierkiewicz7bf74202008-10-10 22:39:37 +0200202 ide_init_pc(pc);
Borislav Petkov30d67092008-02-02 19:56:33 +0100203 pc->c[0] = GPCMD_REQUEST_SENSE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204 pc->c[4] = 255;
Borislav Petkov8e555122008-04-18 00:46:27 +0200205 pc->req_xfer = 18;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206}
207
208/*
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100209 * Called when an error was detected during the last packet command. We queue a
210 * request sense packet command in the head of the request list.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 */
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100212static void idefloppy_retry_pc(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213{
Bartlomiej Zolnierkiewicz394a4c22008-10-10 22:39:35 +0200214 struct ide_floppy_obj *floppy = drive->driver_data;
215 struct request *rq = &floppy->request_sense_rq;
Bartlomiej Zolnierkiewicz2e8a6f82008-10-10 22:39:36 +0200216 struct ide_atapi_pc *pc = &floppy->request_sense_pc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217
Bartlomiej Zolnierkiewicz64a57fe2008-02-06 02:57:51 +0100218 (void)ide_read_error(drive);
Bartlomiej Zolnierkiewicz01278542008-10-10 22:39:38 +0200219 ide_floppy_create_request_sense_cmd(pc);
Bartlomiej Zolnierkiewicz7645c152008-10-10 22:39:37 +0200220 ide_queue_pc_head(drive, floppy->disk, pc, rq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221}
222
Borislav Petkov0eea6452008-02-02 19:56:36 +0100223/* The usual interrupt handler called during a packet command. */
Paolo Ciarrocchi52d3ccf2008-04-26 17:36:41 +0200224static ide_startstop_t idefloppy_pc_intr(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225{
226 idefloppy_floppy_t *floppy = drive->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227
Bartlomiej Zolnierkiewicz646c0cb2008-07-15 21:22:03 +0200228 return ide_pc_intr(drive, floppy->pc, idefloppy_pc_intr,
229 IDEFLOPPY_WAIT_CMD, NULL, idefloppy_update_buffers,
Bartlomiej Zolnierkiewiczacaa0f52008-10-10 22:39:36 +0200230 idefloppy_retry_pc, NULL, ide_io_buffers);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231}
232
233/*
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100234 * What we have here is a classic case of a top half / bottom half interrupt
235 * service routine. In interrupt mode, the device sends an interrupt to signal
236 * that it is ready to receive a packet. However, we need to delay about 2-3
237 * ticks before issuing the packet or we gets in trouble.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 */
Borislav Petkovcbbc4e82008-07-15 21:22:03 +0200239static int idefloppy_transfer_pc(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240{
241 idefloppy_floppy_t *floppy = drive->driver_data;
242
243 /* Send the actual packet */
Bartlomiej Zolnierkiewicz374e0422008-07-23 19:55:56 +0200244 drive->hwif->tp_ops->output_data(drive, NULL, floppy->pc->c, 12);
Bartlomiej Zolnierkiewicz9567b342008-04-28 23:44:36 +0200245
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 /* Timeout for the packet command */
247 return IDEFLOPPY_WAIT_CMD;
248}
249
Borislav Petkovcbbc4e82008-07-15 21:22:03 +0200250
251/*
252 * Called as an interrupt (or directly). When the device says it's ready for a
253 * packet, we schedule the packet transfer to occur about 2-3 ticks later in
254 * transfer_pc.
255 */
256static ide_startstop_t idefloppy_start_pc_transfer(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257{
258 idefloppy_floppy_t *floppy = drive->driver_data;
Bartlomiej Zolnierkiewicz6ffb66412008-07-15 21:21:56 +0200259 struct ide_atapi_pc *pc = floppy->pc;
Bartlomiej Zolnierkiewicz0b2eea42008-07-15 21:21:54 +0200260 ide_expiry_t *expiry;
261 unsigned int timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100263 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 * The following delay solves a problem with ATAPI Zip 100 drives
265 * where the Busy flag was apparently being deasserted before the
266 * unit was ready to receive data. This was happening on a
267 * 1200 MHz Athlon system. 10/26/01 25msec is too short,
268 * 40 and 50msec work well. idefloppy_pc_intr will not be actually
269 * used until after the packet is moved in about 50 msec.
270 */
Borislav Petkovea68d272008-07-23 19:56:01 +0200271 if (drive->atapi_flags & IDE_AFLAG_ZIP_DRIVE) {
Bartlomiej Zolnierkiewicz0b2eea42008-07-15 21:21:54 +0200272 timeout = floppy->ticks;
Borislav Petkovcbbc4e82008-07-15 21:22:03 +0200273 expiry = &idefloppy_transfer_pc;
Bartlomiej Zolnierkiewicz0b2eea42008-07-15 21:21:54 +0200274 } else {
275 timeout = IDEFLOPPY_WAIT_CMD;
276 expiry = NULL;
277 }
Borislav Petkov0078df22008-02-02 19:56:33 +0100278
Bartlomiej Zolnierkiewicz594c16d2008-07-15 21:21:58 +0200279 return ide_transfer_pc(drive, pc, idefloppy_pc_intr, timeout, expiry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280}
281
Borislav Petkovd652c132008-02-02 19:56:35 +0100282static void ide_floppy_report_error(idefloppy_floppy_t *floppy,
Borislav Petkov8e555122008-04-18 00:46:27 +0200283 struct ide_atapi_pc *pc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284{
Borislav Petkovd652c132008-02-02 19:56:35 +0100285 /* supress error messages resulting from Medium not present */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 if (floppy->sense_key == 0x02 &&
287 floppy->asc == 0x3a &&
288 floppy->ascq == 0x00)
Borislav Petkovd652c132008-02-02 19:56:35 +0100289 return;
290
291 printk(KERN_ERR "ide-floppy: %s: I/O error, pc = %2x, key = %2x, "
292 "asc = %2x, ascq = %2x\n",
293 floppy->drive->name, pc->c[0], floppy->sense_key,
294 floppy->asc, floppy->ascq);
295
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296}
297
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100298static ide_startstop_t idefloppy_issue_pc(ide_drive_t *drive,
Borislav Petkov8e555122008-04-18 00:46:27 +0200299 struct ide_atapi_pc *pc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300{
301 idefloppy_floppy_t *floppy = drive->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303 if (floppy->failed_pc == NULL &&
Borislav Petkov30d67092008-02-02 19:56:33 +0100304 pc->c[0] != GPCMD_REQUEST_SENSE)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305 floppy->failed_pc = pc;
306 /* Set the current packet command */
307 floppy->pc = pc;
308
Borislav Petkov757ced82008-02-02 19:56:37 +0100309 if (pc->retries > IDEFLOPPY_MAX_PC_RETRIES) {
Borislav Petkov6e5fa7b2008-02-02 19:56:37 +0100310 if (!(pc->flags & PC_FLAG_SUPPRESS_ERROR))
Borislav Petkov757ced82008-02-02 19:56:37 +0100311 ide_floppy_report_error(floppy, pc);
312 /* Giving up */
313 pc->error = IDEFLOPPY_ERROR_GENERAL;
314
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315 floppy->failed_pc = NULL;
Borislav Petkov2207fa52008-07-23 19:55:59 +0200316 drive->pc_callback(drive);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 return ide_stopped;
318 }
319
Borislav Petkovbcc77d92008-02-02 19:56:34 +0100320 debug_log("Retry number - %d\n", pc->retries);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321
322 pc->retries++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323
Borislav Petkovcbbc4e82008-07-15 21:22:03 +0200324 return ide_issue_pc(drive, pc, idefloppy_start_pc_transfer,
Bartlomiej Zolnierkiewicz6bf16412008-07-15 21:22:00 +0200325 IDEFLOPPY_WAIT_CMD, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326}
327
Bartlomiej Zolnierkiewicz01278542008-10-10 22:39:38 +0200328void ide_floppy_create_read_capacity_cmd(struct ide_atapi_pc *pc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329{
Bartlomiej Zolnierkiewicz7bf74202008-10-10 22:39:37 +0200330 ide_init_pc(pc);
Borislav Petkov30d67092008-02-02 19:56:33 +0100331 pc->c[0] = GPCMD_READ_FORMAT_CAPACITIES;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 pc->c[7] = 255;
333 pc->c[8] = 255;
Borislav Petkov8e555122008-04-18 00:46:27 +0200334 pc->req_xfer = 255;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335}
336
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100337/* A mode sense command is used to "sense" floppy parameters. */
Bartlomiej Zolnierkiewicz01278542008-10-10 22:39:38 +0200338void ide_floppy_create_mode_sense_cmd(struct ide_atapi_pc *pc, u8 page_code)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339{
Borislav Petkov24a5d702008-02-02 19:56:34 +0100340 u16 length = 8; /* sizeof(Mode Parameter Header) = 8 Bytes */
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100341
Bartlomiej Zolnierkiewicz7bf74202008-10-10 22:39:37 +0200342 ide_init_pc(pc);
Borislav Petkov30d67092008-02-02 19:56:33 +0100343 pc->c[0] = GPCMD_MODE_SENSE_10;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344 pc->c[1] = 0;
Bartlomiej Zolnierkiewicz4de4b9e2008-10-10 22:39:36 +0200345 pc->c[2] = page_code;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346
347 switch (page_code) {
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100348 case IDEFLOPPY_CAPABILITIES_PAGE:
349 length += 12;
350 break;
351 case IDEFLOPPY_FLEXIBLE_DISK_PAGE:
352 length += 32;
353 break;
354 default:
355 printk(KERN_ERR "ide-floppy: unsupported page code "
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 "in create_mode_sense_cmd\n");
357 }
Borislav Petkov8f622432008-02-02 19:56:33 +0100358 put_unaligned(cpu_to_be16(length), (u16 *) &pc->c[7]);
Borislav Petkov8e555122008-04-18 00:46:27 +0200359 pc->req_xfer = length;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360}
361
Borislav Petkovae7e8dd2008-02-02 19:56:36 +0100362static void idefloppy_create_rw_cmd(idefloppy_floppy_t *floppy,
Borislav Petkov8e555122008-04-18 00:46:27 +0200363 struct ide_atapi_pc *pc, struct request *rq,
Borislav Petkovae7e8dd2008-02-02 19:56:36 +0100364 unsigned long sector)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365{
366 int block = sector / floppy->bs_factor;
367 int blocks = rq->nr_sectors / floppy->bs_factor;
368 int cmd = rq_data_dir(rq);
369
Borislav Petkovae7e8dd2008-02-02 19:56:36 +0100370 debug_log("create_rw10_cmd: block == %d, blocks == %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 block, blocks);
372
Bartlomiej Zolnierkiewicz7bf74202008-10-10 22:39:37 +0200373 ide_init_pc(pc);
Borislav Petkovae7e8dd2008-02-02 19:56:36 +0100374 pc->c[0] = cmd == READ ? GPCMD_READ_10 : GPCMD_WRITE_10;
375 put_unaligned(cpu_to_be16(blocks), (unsigned short *)&pc->c[7]);
Borislav Petkov8f622432008-02-02 19:56:33 +0100376 put_unaligned(cpu_to_be32(block), (unsigned int *) &pc->c[2]);
Borislav Petkovae7e8dd2008-02-02 19:56:36 +0100377
Borislav Petkov20cd93be672008-07-23 19:56:00 +0200378 memcpy(rq->cmd, pc->c, 12);
379
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 pc->rq = rq;
Borislav Petkovb98b3402008-10-10 22:39:35 +0200381 pc->b_count = 0;
Jens Axboe4aff5e22006-08-10 08:44:47 +0200382 if (rq->cmd_flags & REQ_RW)
Borislav Petkov6e5fa7b2008-02-02 19:56:37 +0100383 pc->flags |= PC_FLAG_WRITING;
Borislav Petkov8e555122008-04-18 00:46:27 +0200384 pc->buf = NULL;
385 pc->req_xfer = pc->buf_size = blocks * floppy->block_size;
Bartlomiej Zolnierkiewicz5e331092008-07-15 21:21:56 +0200386 pc->flags |= PC_FLAG_DMA_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387}
388
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100389static void idefloppy_blockpc_cmd(idefloppy_floppy_t *floppy,
Borislav Petkov8e555122008-04-18 00:46:27 +0200390 struct ide_atapi_pc *pc, struct request *rq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391{
Bartlomiej Zolnierkiewicz7bf74202008-10-10 22:39:37 +0200392 ide_init_pc(pc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 memcpy(pc->c, rq->cmd, sizeof(pc->c));
Jens Axboe3d6392c2007-07-09 12:38:05 +0200394 pc->rq = rq;
Borislav Petkovb98b3402008-10-10 22:39:35 +0200395 pc->b_count = 0;
Jens Axboe3d6392c2007-07-09 12:38:05 +0200396 if (rq->data_len && rq_data_dir(rq) == WRITE)
Borislav Petkov6e5fa7b2008-02-02 19:56:37 +0100397 pc->flags |= PC_FLAG_WRITING;
Borislav Petkov8e555122008-04-18 00:46:27 +0200398 pc->buf = rq->data;
Jens Axboe3d6392c2007-07-09 12:38:05 +0200399 if (rq->bio)
Bartlomiej Zolnierkiewicz5e331092008-07-15 21:21:56 +0200400 pc->flags |= PC_FLAG_DMA_OK;
Jens Axboe3d6392c2007-07-09 12:38:05 +0200401 /*
402 * possibly problematic, doesn't look like ide-floppy correctly
403 * handled scattered requests if dma fails...
404 */
Borislav Petkov8e555122008-04-18 00:46:27 +0200405 pc->req_xfer = pc->buf_size = rq->data_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406}
407
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100408static ide_startstop_t idefloppy_do_request(ide_drive_t *drive,
409 struct request *rq, sector_t block_s)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410{
411 idefloppy_floppy_t *floppy = drive->driver_data;
Borislav Petkovb98b3402008-10-10 22:39:35 +0200412 ide_hwif_t *hwif = drive->hwif;
Borislav Petkov8e555122008-04-18 00:46:27 +0200413 struct ide_atapi_pc *pc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 unsigned long block = (unsigned long)block_s;
415
Borislav Petkovb98b3402008-10-10 22:39:35 +0200416 debug_log("%s: dev: %s, cmd: 0x%x, cmd_type: %x, errors: %d\n",
417 __func__, rq->rq_disk ? rq->rq_disk->disk_name : "?",
418 rq->cmd[0], rq->cmd_type, rq->errors);
419
420 debug_log("%s: sector: %ld, nr_sectors: %ld, current_nr_sectors: %d\n",
421 __func__, (long)rq->sector, rq->nr_sectors,
422 rq->current_nr_sectors);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423
424 if (rq->errors >= ERROR_MAX) {
Borislav Petkovd652c132008-02-02 19:56:35 +0100425 if (floppy->failed_pc)
426 ide_floppy_report_error(floppy, floppy->failed_pc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 else
428 printk(KERN_ERR "ide-floppy: %s: I/O error\n",
429 drive->name);
Borislav Petkovc2b2b292008-04-18 00:46:27 +0200430 idefloppy_end_request(drive, 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 return ide_stopped;
432 }
Jens Axboe4aff5e22006-08-10 08:44:47 +0200433 if (blk_fs_request(rq)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434 if (((long)rq->sector % floppy->bs_factor) ||
435 (rq->nr_sectors % floppy->bs_factor)) {
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100436 printk(KERN_ERR "%s: unsupported r/w request size\n",
437 drive->name);
Borislav Petkovc2b2b292008-04-18 00:46:27 +0200438 idefloppy_end_request(drive, 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 return ide_stopped;
440 }
Bartlomiej Zolnierkiewicz2e8a6f82008-10-10 22:39:36 +0200441 pc = &floppy->queued_pc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442 idefloppy_create_rw_cmd(floppy, pc, rq, block);
Jens Axboe4aff5e22006-08-10 08:44:47 +0200443 } else if (blk_special_request(rq)) {
Borislav Petkov8e555122008-04-18 00:46:27 +0200444 pc = (struct ide_atapi_pc *) rq->buffer;
Jens Axboe4aff5e22006-08-10 08:44:47 +0200445 } else if (blk_pc_request(rq)) {
Bartlomiej Zolnierkiewicz2e8a6f82008-10-10 22:39:36 +0200446 pc = &floppy->queued_pc;
Jens Axboe3d6392c2007-07-09 12:38:05 +0200447 idefloppy_blockpc_cmd(floppy, pc, rq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 } else {
449 blk_dump_rq_flags(rq,
450 "ide-floppy: unsupported command in queue");
Borislav Petkovc2b2b292008-04-18 00:46:27 +0200451 idefloppy_end_request(drive, 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 return ide_stopped;
453 }
454
Borislav Petkovb98b3402008-10-10 22:39:35 +0200455 ide_init_sg_cmd(drive, rq);
456 ide_map_sg(drive, rq);
457
458 pc->sg = hwif->sg_table;
459 pc->sg_cnt = hwif->sg_nents;
460
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 pc->rq = rq;
Bartlomiej Zolnierkiewicz5d418932008-07-15 21:21:57 +0200462
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 return idefloppy_issue_pc(drive, pc);
464}
465
466/*
Borislav Petkov8e81bbb2008-02-02 19:56:35 +0100467 * Look at the flexible disk page parameters. We ignore the CHS capacity
468 * parameters and use the LBA parameters instead.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 */
Borislav Petkov8e81bbb2008-02-02 19:56:35 +0100470static int ide_floppy_get_flexible_disk_page(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471{
472 idefloppy_floppy_t *floppy = drive->driver_data;
Bartlomiej Zolnierkiewicz2ac07d92008-10-10 22:39:38 +0200473 struct gendisk *disk = floppy->disk;
Borislav Petkov8e555122008-04-18 00:46:27 +0200474 struct ide_atapi_pc pc;
Borislav Petkov8e81bbb2008-02-02 19:56:35 +0100475 u8 *page;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 int capacity, lba_capacity;
Borislav Petkov8e81bbb2008-02-02 19:56:35 +0100477 u16 transfer_rate, sector_size, cyls, rpm;
478 u8 heads, sectors;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479
Bartlomiej Zolnierkiewicz01278542008-10-10 22:39:38 +0200480 ide_floppy_create_mode_sense_cmd(&pc, IDEFLOPPY_FLEXIBLE_DISK_PAGE);
Borislav Petkov8e81bbb2008-02-02 19:56:35 +0100481
Bartlomiej Zolnierkiewicz2ac07d92008-10-10 22:39:38 +0200482 if (ide_queue_pc_tail(drive, disk, &pc)) {
Borislav Petkov8e81bbb2008-02-02 19:56:35 +0100483 printk(KERN_ERR "ide-floppy: Can't get flexible disk page"
484 " parameters\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485 return 1;
486 }
Bartlomiej Zolnierkiewicz49cac392008-10-10 22:39:38 +0200487
488 if (pc.buf[3] & 0x80)
489 drive->atapi_flags |= IDE_AFLAG_WP;
490 else
491 drive->atapi_flags &= ~IDE_AFLAG_WP;
492
493 set_disk_ro(disk, !!(drive->atapi_flags & IDE_AFLAG_WP));
494
Borislav Petkov8e555122008-04-18 00:46:27 +0200495 page = &pc.buf[8];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496
Harvey Harrison85ae98a32008-07-16 20:33:47 +0200497 transfer_rate = be16_to_cpup((__be16 *)&pc.buf[8 + 2]);
498 sector_size = be16_to_cpup((__be16 *)&pc.buf[8 + 6]);
499 cyls = be16_to_cpup((__be16 *)&pc.buf[8 + 8]);
500 rpm = be16_to_cpup((__be16 *)&pc.buf[8 + 28]);
Borislav Petkov8e555122008-04-18 00:46:27 +0200501 heads = pc.buf[8 + 4];
502 sectors = pc.buf[8 + 5];
Borislav Petkov8e81bbb2008-02-02 19:56:35 +0100503
504 capacity = cyls * heads * sectors * sector_size;
505
506 if (memcmp(page, &floppy->flexible_disk_page, 32))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 printk(KERN_INFO "%s: %dkB, %d/%d/%d CHS, %d kBps, "
508 "%d sector size, %d rpm\n",
Borislav Petkov8e81bbb2008-02-02 19:56:35 +0100509 drive->name, capacity / 1024, cyls, heads,
510 sectors, transfer_rate / 8, sector_size, rpm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511
Borislav Petkov8e81bbb2008-02-02 19:56:35 +0100512 memcpy(&floppy->flexible_disk_page, page, 32);
513 drive->bios_cyl = cyls;
514 drive->bios_head = heads;
515 drive->bios_sect = sectors;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 lba_capacity = floppy->blocks * floppy->block_size;
Borislav Petkov8e81bbb2008-02-02 19:56:35 +0100517
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518 if (capacity < lba_capacity) {
519 printk(KERN_NOTICE "%s: The disk reports a capacity of %d "
520 "bytes, but the drive only handles %d\n",
521 drive->name, lba_capacity, capacity);
Borislav Petkov8e81bbb2008-02-02 19:56:35 +0100522 floppy->blocks = floppy->block_size ?
523 capacity / floppy->block_size : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524 }
525 return 0;
526}
527
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528/*
Borislav Petkov194ec0c2008-02-02 19:56:35 +0100529 * Determine if a media is present in the floppy drive, and if so, its LBA
530 * capacity.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 */
Borislav Petkov194ec0c2008-02-02 19:56:35 +0100532static int ide_floppy_get_capacity(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533{
534 idefloppy_floppy_t *floppy = drive->driver_data;
Bartlomiej Zolnierkiewicz2ac07d92008-10-10 22:39:38 +0200535 struct gendisk *disk = floppy->disk;
Borislav Petkov8e555122008-04-18 00:46:27 +0200536 struct ide_atapi_pc pc;
Borislav Petkov194ec0c2008-02-02 19:56:35 +0100537 u8 *cap_desc;
538 u8 header_len, desc_cnt;
539 int i, rc = 1, blocks, length;
540
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541 drive->bios_cyl = 0;
542 drive->bios_head = drive->bios_sect = 0;
Alan Coxfdb77da2007-02-17 02:40:20 +0100543 floppy->blocks = 0;
544 floppy->bs_factor = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545 set_capacity(floppy->disk, 0);
546
Bartlomiej Zolnierkiewicz01278542008-10-10 22:39:38 +0200547 ide_floppy_create_read_capacity_cmd(&pc);
Bartlomiej Zolnierkiewicz2ac07d92008-10-10 22:39:38 +0200548 if (ide_queue_pc_tail(drive, disk, &pc)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 printk(KERN_ERR "ide-floppy: Can't get floppy parameters\n");
550 return 1;
551 }
Borislav Petkov8e555122008-04-18 00:46:27 +0200552 header_len = pc.buf[3];
553 cap_desc = &pc.buf[4];
Borislav Petkov194ec0c2008-02-02 19:56:35 +0100554 desc_cnt = header_len / 8; /* capacity descriptor of 8 bytes */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555
Borislav Petkov194ec0c2008-02-02 19:56:35 +0100556 for (i = 0; i < desc_cnt; i++) {
557 unsigned int desc_start = 4 + i*8;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558
Harvey Harrison85ae98a32008-07-16 20:33:47 +0200559 blocks = be32_to_cpup((__be32 *)&pc.buf[desc_start]);
560 length = be16_to_cpup((__be16 *)&pc.buf[desc_start + 6]);
Borislav Petkov194ec0c2008-02-02 19:56:35 +0100561
562 debug_log("Descriptor %d: %dkB, %d blocks, %d sector size\n",
563 i, blocks * length / 1024, blocks, length);
564
565 if (i)
566 continue;
567 /*
568 * the code below is valid only for the 1st descriptor, ie i=0
569 */
570
Borislav Petkov8e555122008-04-18 00:46:27 +0200571 switch (pc.buf[desc_start + 4] & 0x03) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572 /* Clik! drive returns this instead of CAPACITY_CURRENT */
573 case CAPACITY_UNFORMATTED:
Borislav Petkovea68d272008-07-23 19:56:01 +0200574 if (!(drive->atapi_flags & IDE_AFLAG_CLIK_DRIVE))
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100575 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576 * If it is not a clik drive, break out
577 * (maintains previous driver behaviour)
578 */
579 break;
580 case CAPACITY_CURRENT:
581 /* Normal Zip/LS-120 disks */
Borislav Petkov194ec0c2008-02-02 19:56:35 +0100582 if (memcmp(cap_desc, &floppy->cap_desc, 8))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583 printk(KERN_INFO "%s: %dkB, %d blocks, %d "
584 "sector size\n", drive->name,
585 blocks * length / 1024, blocks, length);
Borislav Petkov194ec0c2008-02-02 19:56:35 +0100586 memcpy(&floppy->cap_desc, cap_desc, 8);
587
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 if (!length || length % 512) {
589 printk(KERN_NOTICE "%s: %d bytes block size "
590 "not supported\n", drive->name, length);
591 } else {
Borislav Petkov194ec0c2008-02-02 19:56:35 +0100592 floppy->blocks = blocks;
593 floppy->block_size = length;
594 floppy->bs_factor = length / 512;
595 if (floppy->bs_factor != 1)
596 printk(KERN_NOTICE "%s: warning: non "
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 "512 bytes block size not "
598 "fully supported\n",
599 drive->name);
Borislav Petkov194ec0c2008-02-02 19:56:35 +0100600 rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601 }
602 break;
603 case CAPACITY_NO_CARTRIDGE:
604 /*
605 * This is a KERN_ERR so it appears on screen
606 * for the user to see
607 */
608 printk(KERN_ERR "%s: No disk in drive\n", drive->name);
609 break;
610 case CAPACITY_INVALID:
611 printk(KERN_ERR "%s: Invalid capacity for disk "
612 "in drive\n", drive->name);
613 break;
614 }
Borislav Petkov194ec0c2008-02-02 19:56:35 +0100615 debug_log("Descriptor 0 Code: %d\n",
Borislav Petkov8e555122008-04-18 00:46:27 +0200616 pc.buf[desc_start + 4] & 0x03);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617 }
618
619 /* Clik! disk does not support get_flexible_disk_page */
Borislav Petkovea68d272008-07-23 19:56:01 +0200620 if (!(drive->atapi_flags & IDE_AFLAG_CLIK_DRIVE))
Borislav Petkov8e81bbb2008-02-02 19:56:35 +0100621 (void) ide_floppy_get_flexible_disk_page(drive);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622
Bartlomiej Zolnierkiewicz2ac07d92008-10-10 22:39:38 +0200623 set_capacity(disk, floppy->blocks * floppy->bs_factor);
624
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 return rc;
626}
627
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100628static sector_t idefloppy_capacity(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629{
630 idefloppy_floppy_t *floppy = drive->driver_data;
631 unsigned long capacity = floppy->blocks * floppy->bs_factor;
632
633 return capacity;
634}
635
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200636#ifdef CONFIG_IDE_PROC_FS
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +0200637ide_devset_rw(bios_cyl, 0, 1023, bios_cyl);
638ide_devset_rw(bios_head, 0, 255, bios_head);
639ide_devset_rw(bios_sect, 0, 63, bios_sect);
640
641static int get_ticks(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642{
643 idefloppy_floppy_t *floppy = drive->driver_data;
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +0200644 return floppy->ticks;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645}
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +0200646
647static int set_ticks(ide_drive_t *drive, int arg)
648{
649 idefloppy_floppy_t *floppy = drive->driver_data;
650 floppy->ticks = arg;
651 return 0;
652}
653
654IDE_DEVSET(ticks, S_RW, 0, 255, get_ticks, set_ticks);
655
656static const struct ide_devset *idefloppy_settings[] = {
657 &ide_devset_bios_cyl,
658 &ide_devset_bios_head,
659 &ide_devset_bios_sect,
660 &ide_devset_ticks,
661 NULL
662};
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200663#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100665static void idefloppy_setup(ide_drive_t *drive, idefloppy_floppy_t *floppy)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666{
Bartlomiej Zolnierkiewicz4dde4492008-10-10 22:39:19 +0200667 u16 *id = drive->id;
Borislav Petkov3ad67762008-04-18 00:46:25 +0200668 u8 gcw[2];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669
Bartlomiej Zolnierkiewicz4dde4492008-10-10 22:39:19 +0200670 *((u16 *)&gcw) = id[ATA_ID_CONFIG];
Bartlomiej Zolnierkiewicz2e8a6f82008-10-10 22:39:36 +0200671
Borislav Petkov2207fa52008-07-23 19:55:59 +0200672 drive->pc_callback = ide_floppy_callback;
Borislav Petkov3ad67762008-04-18 00:46:25 +0200673
674 if (((gcw[0] & 0x60) >> 5) == 1)
Borislav Petkovea68d272008-07-23 19:56:01 +0200675 drive->atapi_flags |= IDE_AFLAG_DRQ_INTERRUPT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676 /*
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100677 * We used to check revisions here. At this point however I'm giving up.
678 * Just assume they are all broken, its easier.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679 *
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100680 * The actual reason for the workarounds was likely a driver bug after
681 * all rather than a firmware bug, and the workaround below used to hide
682 * it. It should be fixed as of version 1.9, but to be on the safe side
683 * we'll leave the limitation below for the 2.2.x tree.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684 */
Bartlomiej Zolnierkiewicz4dde4492008-10-10 22:39:19 +0200685 if (!strncmp((char *)&id[ATA_ID_PROD], "IOMEGA ZIP 100 ATAPI", 20)) {
Borislav Petkovea68d272008-07-23 19:56:01 +0200686 drive->atapi_flags |= IDE_AFLAG_ZIP_DRIVE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687 /* This value will be visible in the /proc/ide/hdx/settings */
688 floppy->ticks = IDEFLOPPY_TICKS_DELAY;
689 blk_queue_max_sectors(drive->queue, 64);
690 }
691
692 /*
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100693 * Guess what? The IOMEGA Clik! drive also needs the above fix. It makes
694 * nasty clicking noises without it, so please don't remove this.
695 */
Bartlomiej Zolnierkiewicz4dde4492008-10-10 22:39:19 +0200696 if (strncmp((char *)&id[ATA_ID_PROD], "IOMEGA Clik!", 11) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697 blk_queue_max_sectors(drive->queue, 64);
Borislav Petkovea68d272008-07-23 19:56:01 +0200698 drive->atapi_flags |= IDE_AFLAG_CLIK_DRIVE;
Bartlomiej Zolnierkiewicz05780422008-10-10 22:39:38 +0200699 /* IOMEGA Clik! drives do not support lock/unlock commands */
700 drive->atapi_flags |= IDE_AFLAG_NO_DOORLOCK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701 }
702
Borislav Petkov194ec0c2008-02-02 19:56:35 +0100703 (void) ide_floppy_get_capacity(drive);
Bartlomiej Zolnierkiewicz1e874f42008-10-10 22:39:27 +0200704
705 ide_proc_register_driver(drive, floppy->driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706}
707
Russell King4031bbe2006-01-06 11:41:00 +0000708static void ide_floppy_remove(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709{
710 idefloppy_floppy_t *floppy = drive->driver_data;
711 struct gendisk *g = floppy->disk;
712
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200713 ide_proc_unregister_driver(drive, floppy->driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714
715 del_gendisk(g);
716
717 ide_floppy_put(floppy);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718}
719
Borislav Petkov9a24b632008-02-02 19:56:33 +0100720static void idefloppy_cleanup_obj(struct kref *kref)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721{
722 struct ide_floppy_obj *floppy = to_ide_floppy(kref);
723 ide_drive_t *drive = floppy->drive;
724 struct gendisk *g = floppy->disk;
725
726 drive->driver_data = NULL;
727 g->private_data = NULL;
728 put_disk(g);
729 kfree(floppy);
730}
731
Bartlomiej Zolnierkiewiczecfd80e2007-05-10 00:01:09 +0200732#ifdef CONFIG_IDE_PROC_FS
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100733static int proc_idefloppy_read_capacity(char *page, char **start, off_t off,
734 int count, int *eof, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735{
736 ide_drive_t*drive = (ide_drive_t *)data;
737 int len;
738
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100739 len = sprintf(page, "%llu\n", (long long)idefloppy_capacity(drive));
740 PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741}
742
743static ide_proc_entry_t idefloppy_proc[] = {
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100744 { "capacity", S_IFREG|S_IRUGO, proc_idefloppy_read_capacity, NULL },
745 { "geometry", S_IFREG|S_IRUGO, proc_ide_read_geometry, NULL },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746 { NULL, 0, NULL, NULL }
747};
Bartlomiej Zolnierkiewiczecfd80e2007-05-10 00:01:09 +0200748#endif /* CONFIG_IDE_PROC_FS */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749
Russell King4031bbe2006-01-06 11:41:00 +0000750static int ide_floppy_probe(ide_drive_t *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752static ide_driver_t idefloppy_driver = {
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +0200753 .gen_driver = {
Laurent Riffard4ef3b8f2005-11-18 22:15:40 +0100754 .owner = THIS_MODULE,
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +0200755 .name = "ide-floppy",
756 .bus = &ide_bus_type,
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +0200757 },
Russell King4031bbe2006-01-06 11:41:00 +0000758 .probe = ide_floppy_probe,
759 .remove = ide_floppy_remove,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760 .version = IDEFLOPPY_VERSION,
761 .media = ide_floppy,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762 .do_request = idefloppy_do_request,
Borislav Petkovc2b2b292008-04-18 00:46:27 +0200763 .end_request = idefloppy_end_request,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764 .error = __ide_error,
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200765#ifdef CONFIG_IDE_PROC_FS
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766 .proc = idefloppy_proc,
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +0200767 .settings = idefloppy_settings,
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200768#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769};
770
771static int idefloppy_open(struct inode *inode, struct file *filp)
772{
773 struct gendisk *disk = inode->i_bdev->bd_disk;
774 struct ide_floppy_obj *floppy;
775 ide_drive_t *drive;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776 int ret = 0;
777
Borislav Petkovbcc77d92008-02-02 19:56:34 +0100778 debug_log("Reached %s\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100780 floppy = ide_floppy_get(disk);
781 if (!floppy)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782 return -ENXIO;
783
784 drive = floppy->drive;
785
Bartlomiej Zolnierkiewiczc94964a2007-02-17 02:40:24 +0100786 floppy->openers++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787
Bartlomiej Zolnierkiewiczc94964a2007-02-17 02:40:24 +0100788 if (floppy->openers == 1) {
Borislav Petkovea68d272008-07-23 19:56:01 +0200789 drive->atapi_flags &= ~IDE_AFLAG_FORMAT_IN_PROGRESS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790 /* Just in case */
791
Bartlomiej Zolnierkiewiczde699ad2008-10-10 22:39:39 +0200792 if (ide_do_test_unit_ready(drive, disk))
Bartlomiej Zolnierkiewicz0c8a6c72008-10-10 22:39:39 +0200793 ide_do_start_stop(drive, disk, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794
Borislav Petkov194ec0c2008-02-02 19:56:35 +0100795 if (ide_floppy_get_capacity(drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796 && (filp->f_flags & O_NDELAY) == 0
797 /*
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100798 * Allow O_NDELAY to open a drive without a disk, or with an
799 * unreadable disk, so that we can get the format capacity
800 * of the drive or begin the format - Sam
801 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802 ) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 ret = -EIO;
804 goto out_put_floppy;
805 }
806
Bartlomiej Zolnierkiewicz49cac392008-10-10 22:39:38 +0200807 if ((drive->atapi_flags & IDE_AFLAG_WP) && (filp->f_mode & 2)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808 ret = -EROFS;
809 goto out_put_floppy;
810 }
Bartlomiej Zolnierkiewicze996fc82008-10-10 22:39:37 +0200811
Borislav Petkovea68d272008-07-23 19:56:01 +0200812 drive->atapi_flags |= IDE_AFLAG_MEDIA_CHANGED;
Bartlomiej Zolnierkiewicz05780422008-10-10 22:39:38 +0200813 ide_set_media_lock(drive, disk, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814 check_disk_change(inode->i_bdev);
Borislav Petkovea68d272008-07-23 19:56:01 +0200815 } else if (drive->atapi_flags & IDE_AFLAG_FORMAT_IN_PROGRESS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816 ret = -EBUSY;
817 goto out_put_floppy;
818 }
819 return 0;
820
821out_put_floppy:
Bartlomiej Zolnierkiewiczc94964a2007-02-17 02:40:24 +0100822 floppy->openers--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823 ide_floppy_put(floppy);
824 return ret;
825}
826
827static int idefloppy_release(struct inode *inode, struct file *filp)
828{
829 struct gendisk *disk = inode->i_bdev->bd_disk;
830 struct ide_floppy_obj *floppy = ide_floppy_g(disk);
831 ide_drive_t *drive = floppy->drive;
Borislav Petkovbcc77d92008-02-02 19:56:34 +0100832
833 debug_log("Reached %s\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834
Bartlomiej Zolnierkiewiczc94964a2007-02-17 02:40:24 +0100835 if (floppy->openers == 1) {
Bartlomiej Zolnierkiewicz05780422008-10-10 22:39:38 +0200836 ide_set_media_lock(drive, disk, 0);
Borislav Petkovea68d272008-07-23 19:56:01 +0200837 drive->atapi_flags &= ~IDE_AFLAG_FORMAT_IN_PROGRESS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838 }
Bartlomiej Zolnierkiewiczc94964a2007-02-17 02:40:24 +0100839
840 floppy->openers--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841
842 ide_floppy_put(floppy);
843
844 return 0;
845}
846
Christoph Hellwiga885c8c2006-01-08 01:02:50 -0800847static int idefloppy_getgeo(struct block_device *bdev, struct hd_geometry *geo)
848{
849 struct ide_floppy_obj *floppy = ide_floppy_g(bdev->bd_disk);
850 ide_drive_t *drive = floppy->drive;
851
852 geo->heads = drive->bios_head;
853 geo->sectors = drive->bios_sect;
854 geo->cylinders = (u16)drive->bios_cyl; /* truncate */
855 return 0;
856}
857
Borislav Petkovea68d272008-07-23 19:56:01 +0200858static int ide_floppy_lockdoor(ide_drive_t *drive, struct ide_atapi_pc *pc,
859 unsigned long arg, unsigned int cmd)
Borislav Petkov20bf7bd2008-02-02 19:56:35 +0100860{
Borislav Petkovea68d272008-07-23 19:56:01 +0200861 idefloppy_floppy_t *floppy = drive->driver_data;
Bartlomiej Zolnierkiewicz05780422008-10-10 22:39:38 +0200862 struct gendisk *disk = floppy->disk;
Bartlomiej Zolnierkiewicze996fc82008-10-10 22:39:37 +0200863 int prevent = (arg && cmd != CDROMEJECT) ? 1 : 0;
Borislav Petkovea68d272008-07-23 19:56:01 +0200864
Borislav Petkov20bf7bd2008-02-02 19:56:35 +0100865 if (floppy->openers > 1)
866 return -EBUSY;
867
Bartlomiej Zolnierkiewicz05780422008-10-10 22:39:38 +0200868 ide_set_media_lock(drive, disk, prevent);
Borislav Petkov20bf7bd2008-02-02 19:56:35 +0100869
Bartlomiej Zolnierkiewicz0c8a6c72008-10-10 22:39:39 +0200870 if (cmd == CDROMEJECT)
871 ide_do_start_stop(drive, disk, 2);
Borislav Petkov20bf7bd2008-02-02 19:56:35 +0100872
873 return 0;
874}
875
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876static int idefloppy_ioctl(struct inode *inode, struct file *file,
877 unsigned int cmd, unsigned long arg)
878{
879 struct block_device *bdev = inode->i_bdev;
880 struct ide_floppy_obj *floppy = ide_floppy_g(bdev->bd_disk);
881 ide_drive_t *drive = floppy->drive;
Borislav Petkov8e555122008-04-18 00:46:27 +0200882 struct ide_atapi_pc pc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883 void __user *argp = (void __user *)arg;
Ondrej Zary07203f62005-11-10 00:25:15 +0100884 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885
Bartlomiej Zolnierkiewiczd56c99e2008-10-10 22:39:34 +0200886 if (cmd == CDROMEJECT || cmd == CDROM_LOCKDOOR)
Borislav Petkovea68d272008-07-23 19:56:01 +0200887 return ide_floppy_lockdoor(drive, &pc, arg, cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888
Bartlomiej Zolnierkiewiczd56c99e2008-10-10 22:39:34 +0200889 err = ide_floppy_format_ioctl(drive, file, cmd, argp);
890 if (err != -ENOTTY)
891 return err;
Bartlomiej Zolnierkiewicz89636af2007-07-20 01:11:59 +0200892
893 /*
894 * skip SCSI_IOCTL_SEND_COMMAND (deprecated)
895 * and CDROM_SEND_PACKET (legacy) ioctls
896 */
897 if (cmd != CDROM_SEND_PACKET && cmd != SCSI_IOCTL_SEND_COMMAND)
898 err = scsi_cmd_ioctl(file, bdev->bd_disk->queue,
899 bdev->bd_disk, cmd, argp);
Bartlomiej Zolnierkiewicz89636af2007-07-20 01:11:59 +0200900
901 if (err == -ENOTTY)
902 err = generic_ide_ioctl(drive, file, bdev, cmd, arg);
903
904 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905}
906
907static int idefloppy_media_changed(struct gendisk *disk)
908{
909 struct ide_floppy_obj *floppy = ide_floppy_g(disk);
910 ide_drive_t *drive = floppy->drive;
Borislav Petkov6e5fa7b2008-02-02 19:56:37 +0100911 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912
913 /* do not scan partitions twice if this is a removable device */
914 if (drive->attach) {
915 drive->attach = 0;
916 return 0;
917 }
Borislav Petkovea68d272008-07-23 19:56:01 +0200918 ret = !!(drive->atapi_flags & IDE_AFLAG_MEDIA_CHANGED);
919 drive->atapi_flags &= ~IDE_AFLAG_MEDIA_CHANGED;
Borislav Petkov6e5fa7b2008-02-02 19:56:37 +0100920 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921}
922
923static int idefloppy_revalidate_disk(struct gendisk *disk)
924{
925 struct ide_floppy_obj *floppy = ide_floppy_g(disk);
926 set_capacity(disk, idefloppy_capacity(floppy->drive));
927 return 0;
928}
929
930static struct block_device_operations idefloppy_ops = {
Paolo Ciarrocchi52d3ccf2008-04-26 17:36:41 +0200931 .owner = THIS_MODULE,
932 .open = idefloppy_open,
933 .release = idefloppy_release,
934 .ioctl = idefloppy_ioctl,
935 .getgeo = idefloppy_getgeo,
936 .media_changed = idefloppy_media_changed,
937 .revalidate_disk = idefloppy_revalidate_disk
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938};
939
Russell King4031bbe2006-01-06 11:41:00 +0000940static int ide_floppy_probe(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700941{
942 idefloppy_floppy_t *floppy;
943 struct gendisk *g;
944
945 if (!strstr("ide-floppy", drive->driver_req))
946 goto failed;
Bartlomiej Zolnierkiewicz2a924662008-10-10 22:39:24 +0200947
Linus Torvalds1da177e2005-04-16 15:20:36 -0700948 if (drive->media != ide_floppy)
949 goto failed;
Bartlomiej Zolnierkiewicz2a924662008-10-10 22:39:24 +0200950
Bartlomiej Zolnierkiewicz51509ee2008-10-10 22:39:34 +0200951 if (!ide_check_atapi_device(drive, DRV_NAME)) {
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100952 printk(KERN_ERR "ide-floppy: %s: not supported by this version"
953 " of ide-floppy\n", drive->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954 goto failed;
955 }
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100956 floppy = kzalloc(sizeof(idefloppy_floppy_t), GFP_KERNEL);
957 if (!floppy) {
958 printk(KERN_ERR "ide-floppy: %s: Can't allocate a floppy"
959 " structure\n", drive->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960 goto failed;
961 }
962
963 g = alloc_disk(1 << PARTN_BITS);
964 if (!g)
965 goto out_free_floppy;
966
967 ide_init_disk(g, drive);
968
Linus Torvalds1da177e2005-04-16 15:20:36 -0700969 kref_init(&floppy->kref);
970
971 floppy->drive = drive;
972 floppy->driver = &idefloppy_driver;
973 floppy->disk = g;
974
975 g->private_data = &floppy->driver;
976
977 drive->driver_data = floppy;
978
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100979 idefloppy_setup(drive, floppy);
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +0200980
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981 g->minors = 1 << PARTN_BITS;
982 g->driverfs_dev = &drive->gendev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983 g->flags = drive->removable ? GENHD_FL_REMOVABLE : 0;
984 g->fops = &idefloppy_ops;
985 drive->attach = 1;
986 add_disk(g);
987 return 0;
988
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989out_free_floppy:
990 kfree(floppy);
991failed:
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +0200992 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993}
994
Borislav Petkov0571c7a2008-02-02 19:56:38 +0100995static void __exit idefloppy_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996{
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +0200997 driver_unregister(&idefloppy_driver.gen_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998}
999
Bartlomiej Zolnierkiewicz17514e82005-11-19 22:24:35 +01001000static int __init idefloppy_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001{
1002 printk("ide-floppy driver " IDEFLOPPY_VERSION "\n");
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +02001003 return driver_register(&idefloppy_driver.gen_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004}
1005
Kay Sievers263756e2005-12-12 18:03:44 +01001006MODULE_ALIAS("ide:*m-floppy*");
Bartlomiej Zolnierkiewicz01278542008-10-10 22:39:38 +02001007MODULE_ALIAS("ide-floppy");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008module_init(idefloppy_init);
1009module_exit(idefloppy_exit);
1010MODULE_LICENSE("GPL");
Borislav Petkov0571c7a2008-02-02 19:56:38 +01001011MODULE_DESCRIPTION("ATAPI FLOPPY Driver");
1012