2 * Copyright (C) 1996-1999 Gadi Oxman <gadio@netvision.net.il>
3 * Copyright (C) 2004-2005 Bartlomiej Zolnierkiewicz
7 * Emulation of a SCSI host adapter for IDE ATAPI devices.
9 * With this driver, one can use the Linux SCSI drivers instead of the
10 * native IDE ATAPI drivers.
12 * Ver 0.1 Dec 3 96 Initial version.
13 * Ver 0.2 Jan 26 97 Fixed bug in cleanup_module() and added emulation
14 * of MODE_SENSE_6/MODE_SELECT_6 for cdroms. Thanks
15 * to Janos Farkas for pointing this out.
16 * Avoid using bitfields in structures for m68k.
17 * Added Scatter/Gather and DMA support.
18 * Ver 0.4 Dec 7 97 Add support for ATAPI PD/CD drives.
19 * Use variable timeout for each command.
20 * Ver 0.5 Jan 2 98 Fix previous PD/CD support.
21 * Allow disabling of SCSI-6 to SCSI-10 transformation.
22 * Ver 0.6 Jan 27 98 Allow disabling of SCSI command translation layer
23 * for access through /dev/sg.
24 * Fix MODE_SENSE_6/MODE_SELECT_6/INQUIRY translation.
25 * Ver 0.7 Dec 04 98 Ignore commands where lun != 0 to avoid multiple
26 * detection of devices with CONFIG_SCSI_MULTI_LUN
27 * Ver 0.8 Feb 05 99 Optical media need translation too. Reverse 0.7.
28 * Ver 0.9 Jul 04 99 Fix a bug in SG_SET_TRANSFORM.
29 * Ver 0.91 Jun 10 02 Fix "off by one" error in transforms
30 * Ver 0.92 Dec 31 02 Implement new SCSI mid level API
33 #define IDESCSI_VERSION "0.92"
35 #include <linux/module.h>
36 #include <linux/types.h>
37 #include <linux/string.h>
38 #include <linux/kernel.h>
40 #include <linux/ioport.h>
41 #include <linux/blkdev.h>
42 #include <linux/errno.h>
43 #include <linux/slab.h>
44 #include <linux/ide.h>
45 #include <linux/scatterlist.h>
46 #include <linux/delay.h>
47 #include <linux/mutex.h>
48 #include <linux/bitops.h>
51 #include <asm/uaccess.h>
53 #include <scsi/scsi.h>
54 #include <scsi/scsi_cmnd.h>
55 #include <scsi/scsi_device.h>
56 #include <scsi/scsi_host.h>
57 #include <scsi/scsi_tcq.h>
60 #define IDESCSI_DEBUG_LOG 0
63 #define debug_log(fmt, args...) \
64 printk(KERN_INFO "ide-scsi: " fmt, ## args)
66 #define debug_log(fmt, args...) do {} while (0)
70 * SCSI command transformation layer
72 #define IDESCSI_SG_TRANSFORM 1 /* /dev/sg transformation */
77 #define IDESCSI_LOG_CMD 0 /* Log SCSI commands */
79 typedef struct ide_scsi_obj
{
83 struct Scsi_Host
*host
;
85 unsigned long transform
; /* SCSI cmd translation layer */
86 unsigned long log
; /* log flags */
89 static DEFINE_MUTEX(idescsi_ref_mutex
);
90 /* Set by module param to skip cd */
91 static int idescsi_nocd
;
93 #define ide_scsi_g(disk) \
94 container_of((disk)->private_data, struct ide_scsi_obj, driver)
96 static struct ide_scsi_obj
*ide_scsi_get(struct gendisk
*disk
)
98 struct ide_scsi_obj
*scsi
= NULL
;
100 mutex_lock(&idescsi_ref_mutex
);
101 scsi
= ide_scsi_g(disk
);
103 if (ide_device_get(scsi
->drive
))
106 scsi_host_get(scsi
->host
);
108 mutex_unlock(&idescsi_ref_mutex
);
112 static void ide_scsi_put(struct ide_scsi_obj
*scsi
)
114 ide_drive_t
*drive
= scsi
->drive
;
116 mutex_lock(&idescsi_ref_mutex
);
117 scsi_host_put(scsi
->host
);
118 ide_device_put(drive
);
119 mutex_unlock(&idescsi_ref_mutex
);
122 static inline idescsi_scsi_t
*scsihost_to_idescsi(struct Scsi_Host
*host
)
124 return (idescsi_scsi_t
*) (&host
[1]);
127 static inline idescsi_scsi_t
*drive_to_idescsi(ide_drive_t
*ide_drive
)
129 return scsihost_to_idescsi(ide_drive
->driver_data
);
132 static void ide_scsi_hex_dump(u8
*data
, int len
)
134 print_hex_dump(KERN_CONT
, "", DUMP_PREFIX_NONE
, 16, 1, data
, len
, 0);
137 static int idescsi_end_request(ide_drive_t
*, int, int);
139 static void ide_scsi_callback(ide_drive_t
*drive
, int dsc
)
141 idescsi_scsi_t
*scsi
= drive_to_idescsi(drive
);
142 struct ide_atapi_pc
*pc
= drive
->pc
;
144 if (pc
->flags
& PC_FLAG_TIMEDOUT
)
145 debug_log("%s: got timed out packet %lu at %lu\n", __func__
,
146 pc
->scsi_cmd
->serial_number
, jiffies
);
147 /* end this request now - scsi should retry it*/
148 else if (test_bit(IDESCSI_LOG_CMD
, &scsi
->log
))
149 printk(KERN_INFO
"Packet command completed, %d bytes"
150 " transferred\n", pc
->xferred
);
152 idescsi_end_request(drive
, 1, 0);
155 static int idescsi_check_condition(ide_drive_t
*drive
,
156 struct request
*failed_cmd
)
158 idescsi_scsi_t
*scsi
= drive_to_idescsi(drive
);
159 struct ide_atapi_pc
*pc
;
163 /* stuff a sense request in front of our current request */
164 pc
= kzalloc(sizeof(struct ide_atapi_pc
), GFP_ATOMIC
);
165 rq
= blk_get_request(drive
->queue
, READ
, GFP_ATOMIC
);
166 buf
= kzalloc(SCSI_SENSE_BUFFERSIZE
, GFP_ATOMIC
);
167 if (!pc
|| !rq
|| !buf
) {
174 rq
->special
= (char *) pc
;
177 pc
->c
[0] = REQUEST_SENSE
;
178 pc
->c
[4] = pc
->req_xfer
= pc
->buf_size
= SCSI_SENSE_BUFFERSIZE
;
179 rq
->cmd_type
= REQ_TYPE_SENSE
;
180 rq
->cmd_flags
|= REQ_PREEMPT
;
181 pc
->timeout
= jiffies
+ WAIT_READY
;
182 /* NOTE! Save the failed packet command in "rq->buffer" */
183 rq
->buffer
= (void *) failed_cmd
->special
;
184 pc
->scsi_cmd
= ((struct ide_atapi_pc
*) failed_cmd
->special
)->scsi_cmd
;
185 if (test_bit(IDESCSI_LOG_CMD
, &scsi
->log
)) {
186 printk ("ide-scsi: %s: queue cmd = ", drive
->name
);
187 ide_scsi_hex_dump(pc
->c
, 6);
189 rq
->rq_disk
= scsi
->disk
;
191 memcpy(rq
->cmd
, pc
->c
, 12);
192 ide_do_drive_cmd(drive
, rq
);
196 static ide_startstop_t
197 idescsi_atapi_error(ide_drive_t
*drive
, struct request
*rq
, u8 stat
, u8 err
)
199 ide_hwif_t
*hwif
= drive
->hwif
;
201 if (hwif
->tp_ops
->read_status(hwif
) & (ATA_BUSY
| ATA_DRQ
))
203 hwif
->tp_ops
->exec_command(hwif
, ATA_CMD_IDLEIMMEDIATE
);
207 idescsi_end_request(drive
, 0, 0);
212 static int idescsi_end_request (ide_drive_t
*drive
, int uptodate
, int nrsecs
)
214 idescsi_scsi_t
*scsi
= drive_to_idescsi(drive
);
215 struct request
*rq
= HWGROUP(drive
)->rq
;
216 struct ide_atapi_pc
*pc
= (struct ide_atapi_pc
*) rq
->special
;
217 int log
= test_bit(IDESCSI_LOG_CMD
, &scsi
->log
);
218 struct Scsi_Host
*host
;
219 int errors
= rq
->errors
;
222 if (!blk_special_request(rq
) && !blk_sense_request(rq
)) {
223 ide_end_request(drive
, uptodate
, nrsecs
);
226 ide_end_drive_cmd (drive
, 0, 0);
227 if (blk_sense_request(rq
)) {
228 struct ide_atapi_pc
*opc
= (struct ide_atapi_pc
*) rq
->buffer
;
230 printk ("ide-scsi: %s: wrap up check %lu, rst = ", drive
->name
, opc
->scsi_cmd
->serial_number
);
231 ide_scsi_hex_dump(pc
->buf
, 16);
233 memcpy((void *) opc
->scsi_cmd
->sense_buffer
, pc
->buf
,
234 SCSI_SENSE_BUFFERSIZE
);
240 pc
->scsi_cmd
->result
= (CHECK_CONDITION
<< 1) |
241 (((pc
->flags
& PC_FLAG_TIMEDOUT
) ?
244 } else if (pc
->flags
& PC_FLAG_TIMEDOUT
) {
246 printk (KERN_WARNING
"ide-scsi: %s: timed out for %lu\n",
247 drive
->name
, pc
->scsi_cmd
->serial_number
);
248 pc
->scsi_cmd
->result
= DID_TIME_OUT
<< 16;
249 } else if (errors
>= ERROR_MAX
) {
250 pc
->scsi_cmd
->result
= DID_ERROR
<< 16;
252 printk ("ide-scsi: %s: I/O error for %lu\n", drive
->name
, pc
->scsi_cmd
->serial_number
);
255 printk ("ide-scsi: %s: check condition for %lu\n", drive
->name
, pc
->scsi_cmd
->serial_number
);
256 if (!idescsi_check_condition(drive
, rq
))
257 /* we started a request sense, so we'll be back, exit for now */
259 pc
->scsi_cmd
->result
= (CHECK_CONDITION
<< 1) | (DID_OK
<< 16);
261 pc
->scsi_cmd
->result
= DID_OK
<< 16;
263 host
= pc
->scsi_cmd
->device
->host
;
264 spin_lock_irqsave(host
->host_lock
, flags
);
265 pc
->done(pc
->scsi_cmd
);
266 spin_unlock_irqrestore(host
->host_lock
, flags
);
273 static inline int idescsi_set_direction(struct ide_atapi_pc
*pc
)
276 case READ_6
: case READ_10
: case READ_12
:
277 pc
->flags
&= ~PC_FLAG_WRITING
;
279 case WRITE_6
: case WRITE_10
: case WRITE_12
:
280 pc
->flags
|= PC_FLAG_WRITING
;
287 static int idescsi_map_sg(ide_drive_t
*drive
, struct ide_atapi_pc
*pc
)
289 ide_hwif_t
*hwif
= drive
->hwif
;
290 struct scatterlist
*sg
, *scsi_sg
;
293 if (!pc
->req_xfer
|| pc
->req_xfer
% 1024)
296 if (idescsi_set_direction(pc
))
300 scsi_sg
= scsi_sglist(pc
->scsi_cmd
);
301 segments
= scsi_sg_count(pc
->scsi_cmd
);
303 if (segments
> hwif
->sg_max_nents
)
306 hwif
->sg_nents
= segments
;
307 memcpy(sg
, scsi_sg
, sizeof(*sg
) * segments
);
312 static ide_startstop_t
idescsi_issue_pc(ide_drive_t
*drive
,
313 struct ide_atapi_pc
*pc
)
315 /* Set the current packet command */
318 return ide_issue_pc(drive
, ide_scsi_get_timeout(pc
), ide_scsi_expiry
);
322 * idescsi_do_request is our request handling function.
324 static ide_startstop_t
idescsi_do_request (ide_drive_t
*drive
, struct request
*rq
, sector_t block
)
326 debug_log("dev: %s, cmd: %x, errors: %d\n", rq
->rq_disk
->disk_name
,
327 rq
->cmd
[0], rq
->errors
);
328 debug_log("sector: %ld, nr_sectors: %ld, current_nr_sectors: %d\n",
329 rq
->sector
, rq
->nr_sectors
, rq
->current_nr_sectors
);
331 if (blk_sense_request(rq
) || blk_special_request(rq
)) {
332 struct ide_atapi_pc
*pc
= (struct ide_atapi_pc
*)rq
->special
;
334 if ((drive
->dev_flags
& IDE_DFLAG_USING_DMA
) &&
335 idescsi_map_sg(drive
, pc
) == 0)
336 pc
->flags
|= PC_FLAG_DMA_OK
;
338 return idescsi_issue_pc(drive
, pc
);
340 blk_dump_rq_flags(rq
, "ide-scsi: unsup command");
341 idescsi_end_request (drive
, 0, 0);
345 #ifdef CONFIG_IDE_PROC_FS
346 static ide_proc_entry_t idescsi_proc
[] = {
347 { "capacity", S_IFREG
|S_IRUGO
, proc_ide_read_capacity
, NULL
},
348 { NULL
, 0, NULL
, NULL
}
351 #define ide_scsi_devset_get(name, field) \
352 static int get_##name(ide_drive_t *drive) \
354 idescsi_scsi_t *scsi = drive_to_idescsi(drive); \
355 return scsi->field; \
358 #define ide_scsi_devset_set(name, field) \
359 static int set_##name(ide_drive_t *drive, int arg) \
361 idescsi_scsi_t *scsi = drive_to_idescsi(drive); \
366 #define ide_scsi_devset_rw_field(_name, _field) \
367 ide_scsi_devset_get(_name, _field); \
368 ide_scsi_devset_set(_name, _field); \
369 IDE_DEVSET(_name, DS_SYNC, get_##_name, set_##_name);
371 ide_devset_rw_field(bios_cyl
, bios_cyl
);
372 ide_devset_rw_field(bios_head
, bios_head
);
373 ide_devset_rw_field(bios_sect
, bios_sect
);
375 ide_scsi_devset_rw_field(transform
, transform
);
376 ide_scsi_devset_rw_field(log
, log
);
378 static const struct ide_proc_devset idescsi_settings
[] = {
379 IDE_PROC_DEVSET(bios_cyl
, 0, 1023),
380 IDE_PROC_DEVSET(bios_head
, 0, 255),
381 IDE_PROC_DEVSET(bios_sect
, 0, 63),
382 IDE_PROC_DEVSET(log
, 0, 1),
383 IDE_PROC_DEVSET(transform
, 0, 3),
387 static ide_proc_entry_t
*ide_scsi_proc_entries(ide_drive_t
*drive
)
392 static const struct ide_proc_devset
*ide_scsi_proc_devsets(ide_drive_t
*drive
)
394 return idescsi_settings
;
399 * Driver initialization.
401 static void idescsi_setup (ide_drive_t
*drive
, idescsi_scsi_t
*scsi
)
403 clear_bit(IDESCSI_SG_TRANSFORM
, &scsi
->transform
);
404 #if IDESCSI_DEBUG_LOG
405 set_bit(IDESCSI_LOG_CMD
, &scsi
->log
);
406 #endif /* IDESCSI_DEBUG_LOG */
408 drive
->pc_callback
= ide_scsi_callback
;
409 drive
->pc_update_buffers
= NULL
;
410 drive
->pc_io_buffers
= ide_io_buffers
;
412 ide_proc_register_driver(drive
, scsi
->driver
);
415 static void ide_scsi_remove(ide_drive_t
*drive
)
417 struct Scsi_Host
*scsihost
= drive
->driver_data
;
418 struct ide_scsi_obj
*scsi
= scsihost_to_idescsi(scsihost
);
419 struct gendisk
*g
= scsi
->disk
;
421 scsi_remove_host(scsihost
);
422 ide_proc_unregister_driver(drive
, scsi
->driver
);
424 ide_unregister_region(g
);
426 drive
->driver_data
= NULL
;
427 g
->private_data
= NULL
;
432 drive
->dev_flags
&= ~IDE_DFLAG_SCSI
;
435 static int ide_scsi_probe(ide_drive_t
*);
437 static ide_driver_t idescsi_driver
= {
439 .owner
= THIS_MODULE
,
441 .bus
= &ide_bus_type
,
443 .probe
= ide_scsi_probe
,
444 .remove
= ide_scsi_remove
,
445 .version
= IDESCSI_VERSION
,
446 .do_request
= idescsi_do_request
,
447 .end_request
= idescsi_end_request
,
448 .error
= idescsi_atapi_error
,
449 #ifdef CONFIG_IDE_PROC_FS
450 .proc_entries
= ide_scsi_proc_entries
,
451 .proc_devsets
= ide_scsi_proc_devsets
,
455 static int idescsi_ide_open(struct block_device
*bdev
, fmode_t mode
)
457 struct ide_scsi_obj
*scsi
= ide_scsi_get(bdev
->bd_disk
);
465 static int idescsi_ide_release(struct gendisk
*disk
, fmode_t mode
)
467 ide_scsi_put(ide_scsi_g(disk
));
471 static int idescsi_ide_ioctl(struct block_device
*bdev
, fmode_t mode
,
472 unsigned int cmd
, unsigned long arg
)
474 struct ide_scsi_obj
*scsi
= ide_scsi_g(bdev
->bd_disk
);
475 return generic_ide_ioctl(scsi
->drive
, bdev
, cmd
, arg
);
478 static struct block_device_operations idescsi_ops
= {
479 .owner
= THIS_MODULE
,
480 .open
= idescsi_ide_open
,
481 .release
= idescsi_ide_release
,
482 .locked_ioctl
= idescsi_ide_ioctl
,
485 static int idescsi_slave_configure(struct scsi_device
* sdp
)
487 /* Configure detected device */
488 sdp
->use_10_for_rw
= 1;
489 sdp
->use_10_for_ms
= 1;
490 scsi_adjust_queue_depth(sdp
, MSG_SIMPLE_TAG
, sdp
->host
->cmd_per_lun
);
494 static const char *idescsi_info (struct Scsi_Host
*host
)
496 return "SCSI host adapter emulation for IDE ATAPI devices";
499 static int idescsi_ioctl (struct scsi_device
*dev
, int cmd
, void __user
*arg
)
501 idescsi_scsi_t
*scsi
= scsihost_to_idescsi(dev
->host
);
503 if (cmd
== SG_SET_TRANSFORM
) {
505 set_bit(IDESCSI_SG_TRANSFORM
, &scsi
->transform
);
507 clear_bit(IDESCSI_SG_TRANSFORM
, &scsi
->transform
);
509 } else if (cmd
== SG_GET_TRANSFORM
)
510 return put_user(test_bit(IDESCSI_SG_TRANSFORM
, &scsi
->transform
), (int __user
*) arg
);
514 static int idescsi_queue (struct scsi_cmnd
*cmd
,
515 void (*done
)(struct scsi_cmnd
*))
517 struct Scsi_Host
*host
= cmd
->device
->host
;
518 idescsi_scsi_t
*scsi
= scsihost_to_idescsi(host
);
519 ide_drive_t
*drive
= scsi
->drive
;
520 struct request
*rq
= NULL
;
521 struct ide_atapi_pc
*pc
= NULL
;
522 int write
= cmd
->sc_data_direction
== DMA_TO_DEVICE
;
525 scmd_printk (KERN_ERR
, cmd
, "drive not present\n");
528 scsi
= drive_to_idescsi(drive
);
529 pc
= kmalloc(sizeof(struct ide_atapi_pc
), GFP_ATOMIC
);
530 rq
= blk_get_request(drive
->queue
, write
, GFP_ATOMIC
);
531 if (rq
== NULL
|| pc
== NULL
) {
532 printk (KERN_ERR
"ide-scsi: %s: out of memory\n", drive
->name
);
536 memset (pc
->c
, 0, 12);
538 if (cmd
->sc_data_direction
== DMA_TO_DEVICE
)
539 pc
->flags
|= PC_FLAG_WRITING
;
541 memcpy (pc
->c
, cmd
->cmnd
, cmd
->cmd_len
);
543 pc
->sg
= scsi_sglist(cmd
);
544 pc
->sg_cnt
= scsi_sg_count(cmd
);
546 pc
->req_xfer
= pc
->buf_size
= scsi_bufflen(cmd
);
549 pc
->timeout
= jiffies
+ cmd
->request
->timeout
;
551 if (test_bit(IDESCSI_LOG_CMD
, &scsi
->log
)) {
552 printk ("ide-scsi: %s: que %lu, cmd = ", drive
->name
, cmd
->serial_number
);
553 ide_scsi_hex_dump(cmd
->cmnd
, cmd
->cmd_len
);
554 if (memcmp(pc
->c
, cmd
->cmnd
, cmd
->cmd_len
)) {
555 printk ("ide-scsi: %s: que %lu, tsl = ", drive
->name
, cmd
->serial_number
);
556 ide_scsi_hex_dump(pc
->c
, 12);
560 rq
->special
= (char *) pc
;
561 rq
->cmd_type
= REQ_TYPE_SPECIAL
;
562 spin_unlock_irq(host
->host_lock
);
564 memcpy(rq
->cmd
, pc
->c
, 12);
565 blk_execute_rq_nowait(drive
->queue
, scsi
->disk
, rq
, 0, NULL
);
566 spin_lock_irq(host
->host_lock
);
572 cmd
->result
= DID_ERROR
<< 16;
577 static int idescsi_eh_abort (struct scsi_cmnd
*cmd
)
579 idescsi_scsi_t
*scsi
= scsihost_to_idescsi(cmd
->device
->host
);
580 ide_drive_t
*drive
= scsi
->drive
;
584 struct ide_atapi_pc
*pc
;
586 /* In idescsi_eh_abort we try to gently pry our command from the ide subsystem */
588 if (test_bit(IDESCSI_LOG_CMD
, &scsi
->log
))
589 printk (KERN_WARNING
"ide-scsi: abort called for %lu\n", cmd
->serial_number
);
592 printk (KERN_WARNING
"ide-scsi: Drive not set in idescsi_eh_abort\n");
597 /* First give it some more time, how much is "right" is hard to say :-( */
599 busy
= ide_wait_not_busy(HWIF(drive
), 100); /* FIXME - uses mdelay which causes latency? */
600 if (test_bit(IDESCSI_LOG_CMD
, &scsi
->log
))
601 printk (KERN_WARNING
"ide-scsi: drive did%s become ready\n", busy
?" not":"");
603 spin_lock_irq(&ide_lock
);
605 /* If there is no pc running we're done (our interrupt took care of it) */
612 /* It's somewhere in flight. Does ide subsystem agree? */
613 if (pc
->scsi_cmd
->serial_number
== cmd
->serial_number
&& !busy
&&
614 elv_queue_empty(drive
->queue
) && HWGROUP(drive
)->rq
!= pc
->rq
) {
616 * FIXME - not sure this condition can ever occur
618 printk (KERN_ERR
"ide-scsi: cmd aborted!\n");
620 if (blk_sense_request(pc
->rq
))
622 /* we need to call blk_put_request twice. */
623 blk_put_request(pc
->rq
);
624 blk_put_request(pc
->rq
);
632 spin_unlock_irq(&ide_lock
);
634 if (test_bit(IDESCSI_LOG_CMD
, &scsi
->log
))
635 printk (KERN_WARNING
"ide-scsi: abort returns %s\n", ret
== SUCCESS
?"success":"failed");
640 static int idescsi_eh_reset (struct scsi_cmnd
*cmd
)
643 idescsi_scsi_t
*scsi
= scsihost_to_idescsi(cmd
->device
->host
);
644 ide_drive_t
*drive
= scsi
->drive
;
648 struct ide_atapi_pc
*pc
;
650 /* In idescsi_eh_reset we forcefully remove the command from the ide subsystem and reset the device. */
652 if (test_bit(IDESCSI_LOG_CMD
, &scsi
->log
))
653 printk (KERN_WARNING
"ide-scsi: reset called for %lu\n", cmd
->serial_number
);
656 printk (KERN_WARNING
"ide-scsi: Drive not set in idescsi_eh_reset\n");
661 spin_lock_irq(cmd
->device
->host
->host_lock
);
662 spin_lock(&ide_lock
);
666 if (pc
== NULL
|| (req
= pc
->rq
) != HWGROUP(drive
)->rq
|| !HWGROUP(drive
)->handler
) {
667 printk (KERN_WARNING
"ide-scsi: No active request in idescsi_eh_reset\n");
668 spin_unlock(&ide_lock
);
669 spin_unlock_irq(cmd
->device
->host
->host_lock
);
673 /* kill current request */
674 if (__blk_end_request(req
, -EIO
, 0))
676 if (blk_sense_request(req
))
680 blk_put_request(req
);
682 /* now nuke the drive queue */
683 while ((req
= elv_next_request(drive
->queue
))) {
684 if (__blk_end_request(req
, -EIO
, 0))
688 HWGROUP(drive
)->rq
= NULL
;
689 HWGROUP(drive
)->handler
= NULL
;
690 HWGROUP(drive
)->busy
= 1; /* will set this to zero when ide reset finished */
691 spin_unlock(&ide_lock
);
695 /* ide_do_reset starts a polling handler which restarts itself every 50ms until the reset finishes */
698 spin_unlock_irq(cmd
->device
->host
->host_lock
);
700 spin_lock_irq(cmd
->device
->host
->host_lock
);
701 } while ( HWGROUP(drive
)->handler
);
703 ready
= drive_is_ready(drive
);
704 HWGROUP(drive
)->busy
--;
706 printk (KERN_ERR
"ide-scsi: reset failed!\n");
710 spin_unlock_irq(cmd
->device
->host
->host_lock
);
714 static int idescsi_bios(struct scsi_device
*sdev
, struct block_device
*bdev
,
715 sector_t capacity
, int *parm
)
717 idescsi_scsi_t
*idescsi
= scsihost_to_idescsi(sdev
->host
);
718 ide_drive_t
*drive
= idescsi
->drive
;
720 if (drive
->bios_cyl
&& drive
->bios_head
&& drive
->bios_sect
) {
721 parm
[0] = drive
->bios_head
;
722 parm
[1] = drive
->bios_sect
;
723 parm
[2] = drive
->bios_cyl
;
728 static struct scsi_host_template idescsi_template
= {
729 .module
= THIS_MODULE
,
731 .info
= idescsi_info
,
732 .slave_configure
= idescsi_slave_configure
,
733 .ioctl
= idescsi_ioctl
,
734 .queuecommand
= idescsi_queue
,
735 .eh_abort_handler
= idescsi_eh_abort
,
736 .eh_host_reset_handler
= idescsi_eh_reset
,
737 .bios_param
= idescsi_bios
,
743 .use_clustering
= DISABLE_CLUSTERING
,
745 .proc_name
= "ide-scsi",
748 static int ide_scsi_probe(ide_drive_t
*drive
)
750 idescsi_scsi_t
*idescsi
;
751 struct Scsi_Host
*host
;
757 if (!warned
&& drive
->media
== ide_cdrom
) {
758 printk(KERN_WARNING
"ide-scsi is deprecated for cd burning! Use ide-cd and give dev=/dev/hdX as device\n");
762 if (idescsi_nocd
&& drive
->media
== ide_cdrom
)
765 if (!strstr("ide-scsi", drive
->driver_req
) ||
766 drive
->media
== ide_disk
||
767 !(host
= scsi_host_alloc(&idescsi_template
,sizeof(idescsi_scsi_t
))))
770 drive
->dev_flags
|= IDE_DFLAG_SCSI
;
772 g
= alloc_disk(1 << PARTN_BITS
);
776 ide_init_disk(g
, drive
);
780 last_lun
= drive
->id
[ATA_ID_LAST_LUN
];
782 debug_log("%s: last_lun=%u\n", drive
->name
, last_lun
);
784 if ((last_lun
& 7) != 7)
785 host
->max_lun
= (last_lun
& 7) + 1;
789 drive
->driver_data
= host
;
790 idescsi
= scsihost_to_idescsi(host
);
791 idescsi
->drive
= drive
;
792 idescsi
->driver
= &idescsi_driver
;
793 idescsi
->host
= host
;
795 g
->private_data
= &idescsi
->driver
;
797 idescsi_setup(drive
, idescsi
);
798 g
->fops
= &idescsi_ops
;
799 ide_register_region(g
);
800 err
= scsi_add_host(host
, &drive
->gendev
);
802 scsi_scan_host(host
);
805 /* fall through on error */
806 ide_unregister_region(g
);
807 ide_proc_unregister_driver(drive
, &idescsi_driver
);
811 drive
->dev_flags
&= ~IDE_DFLAG_SCSI
;
816 static int __init
init_idescsi_module(void)
818 return driver_register(&idescsi_driver
.gen_driver
);
821 static void __exit
exit_idescsi_module(void)
823 driver_unregister(&idescsi_driver
.gen_driver
);
826 module_param(idescsi_nocd
, int, 0600);
827 MODULE_PARM_DESC(idescsi_nocd
, "Disable handling of CD-ROMs so they may be driven by ide-cd");
828 module_init(init_idescsi_module
);
829 module_exit(exit_idescsi_module
);
830 MODULE_LICENSE("GPL");