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 struct ide_atapi_pc
*pc
; /* Current packet command */
86 unsigned long transform
; /* SCSI cmd translation layer */
87 unsigned long log
; /* log flags */
90 static DEFINE_MUTEX(idescsi_ref_mutex
);
91 /* Set by module param to skip cd */
92 static int idescsi_nocd
;
94 #define ide_scsi_g(disk) \
95 container_of((disk)->private_data, struct ide_scsi_obj, driver)
97 static struct ide_scsi_obj
*ide_scsi_get(struct gendisk
*disk
)
99 struct ide_scsi_obj
*scsi
= NULL
;
101 mutex_lock(&idescsi_ref_mutex
);
102 scsi
= ide_scsi_g(disk
);
104 if (ide_device_get(scsi
->drive
))
107 scsi_host_get(scsi
->host
);
109 mutex_unlock(&idescsi_ref_mutex
);
113 static void ide_scsi_put(struct ide_scsi_obj
*scsi
)
115 ide_drive_t
*drive
= scsi
->drive
;
117 mutex_lock(&idescsi_ref_mutex
);
118 scsi_host_put(scsi
->host
);
119 ide_device_put(drive
);
120 mutex_unlock(&idescsi_ref_mutex
);
123 static inline idescsi_scsi_t
*scsihost_to_idescsi(struct Scsi_Host
*host
)
125 return (idescsi_scsi_t
*) (&host
[1]);
128 static inline idescsi_scsi_t
*drive_to_idescsi(ide_drive_t
*ide_drive
)
130 return scsihost_to_idescsi(ide_drive
->driver_data
);
133 static void ide_scsi_hex_dump(u8
*data
, int len
)
135 print_hex_dump(KERN_CONT
, "", DUMP_PREFIX_NONE
, 16, 1, data
, len
, 0);
138 static int idescsi_end_request(ide_drive_t
*, int, int);
140 static void ide_scsi_callback(ide_drive_t
*drive
)
142 idescsi_scsi_t
*scsi
= drive_to_idescsi(drive
);
143 struct ide_atapi_pc
*pc
= scsi
->pc
;
145 if (pc
->flags
& PC_FLAG_TIMEDOUT
)
146 debug_log("%s: got timed out packet %lu at %lu\n", __func__
,
147 pc
->scsi_cmd
->serial_number
, jiffies
);
148 /* end this request now - scsi should retry it*/
149 else if (test_bit(IDESCSI_LOG_CMD
, &scsi
->log
))
150 printk(KERN_INFO
"Packet command completed, %d bytes"
151 " transferred\n", pc
->xferred
);
153 idescsi_end_request(drive
, 1, 0);
156 static int idescsi_check_condition(ide_drive_t
*drive
,
157 struct request
*failed_cmd
)
159 idescsi_scsi_t
*scsi
= drive_to_idescsi(drive
);
160 struct ide_atapi_pc
*pc
;
164 /* stuff a sense request in front of our current request */
165 pc
= kzalloc(sizeof(struct ide_atapi_pc
), GFP_ATOMIC
);
166 rq
= blk_get_request(drive
->queue
, READ
, GFP_ATOMIC
);
167 buf
= kzalloc(SCSI_SENSE_BUFFERSIZE
, GFP_ATOMIC
);
168 if (!pc
|| !rq
|| !buf
) {
175 rq
->special
= (char *) pc
;
178 pc
->c
[0] = REQUEST_SENSE
;
179 pc
->c
[4] = pc
->req_xfer
= pc
->buf_size
= SCSI_SENSE_BUFFERSIZE
;
180 rq
->cmd_type
= REQ_TYPE_SENSE
;
181 rq
->cmd_flags
|= REQ_PREEMPT
;
182 pc
->timeout
= jiffies
+ WAIT_READY
;
183 /* NOTE! Save the failed packet command in "rq->buffer" */
184 rq
->buffer
= (void *) failed_cmd
->special
;
185 pc
->scsi_cmd
= ((struct ide_atapi_pc
*) failed_cmd
->special
)->scsi_cmd
;
186 if (test_bit(IDESCSI_LOG_CMD
, &scsi
->log
)) {
187 printk ("ide-scsi: %s: queue cmd = ", drive
->name
);
188 ide_scsi_hex_dump(pc
->c
, 6);
190 rq
->rq_disk
= scsi
->disk
;
192 memcpy(rq
->cmd
, pc
->c
, 12);
193 ide_do_drive_cmd(drive
, rq
);
197 static ide_startstop_t
198 idescsi_atapi_error(ide_drive_t
*drive
, struct request
*rq
, u8 stat
, u8 err
)
200 ide_hwif_t
*hwif
= drive
->hwif
;
202 if (hwif
->tp_ops
->read_status(hwif
) & (ATA_BUSY
| ATA_DRQ
))
204 hwif
->tp_ops
->exec_command(hwif
, ATA_CMD_IDLEIMMEDIATE
);
208 idescsi_end_request(drive
, 0, 0);
213 static int idescsi_end_request (ide_drive_t
*drive
, int uptodate
, int nrsecs
)
215 idescsi_scsi_t
*scsi
= drive_to_idescsi(drive
);
216 struct request
*rq
= HWGROUP(drive
)->rq
;
217 struct ide_atapi_pc
*pc
= (struct ide_atapi_pc
*) rq
->special
;
218 int log
= test_bit(IDESCSI_LOG_CMD
, &scsi
->log
);
219 struct Scsi_Host
*host
;
220 int errors
= rq
->errors
;
223 if (!blk_special_request(rq
) && !blk_sense_request(rq
)) {
224 ide_end_request(drive
, uptodate
, nrsecs
);
227 ide_end_drive_cmd (drive
, 0, 0);
228 if (blk_sense_request(rq
)) {
229 struct ide_atapi_pc
*opc
= (struct ide_atapi_pc
*) rq
->buffer
;
231 printk ("ide-scsi: %s: wrap up check %lu, rst = ", drive
->name
, opc
->scsi_cmd
->serial_number
);
232 ide_scsi_hex_dump(pc
->buf
, 16);
234 memcpy((void *) opc
->scsi_cmd
->sense_buffer
, pc
->buf
,
235 SCSI_SENSE_BUFFERSIZE
);
241 pc
->scsi_cmd
->result
= (CHECK_CONDITION
<< 1) |
242 (((pc
->flags
& PC_FLAG_TIMEDOUT
) ?
245 } else if (pc
->flags
& PC_FLAG_TIMEDOUT
) {
247 printk (KERN_WARNING
"ide-scsi: %s: timed out for %lu\n",
248 drive
->name
, pc
->scsi_cmd
->serial_number
);
249 pc
->scsi_cmd
->result
= DID_TIME_OUT
<< 16;
250 } else if (errors
>= ERROR_MAX
) {
251 pc
->scsi_cmd
->result
= DID_ERROR
<< 16;
253 printk ("ide-scsi: %s: I/O error for %lu\n", drive
->name
, pc
->scsi_cmd
->serial_number
);
256 printk ("ide-scsi: %s: check condition for %lu\n", drive
->name
, pc
->scsi_cmd
->serial_number
);
257 if (!idescsi_check_condition(drive
, rq
))
258 /* we started a request sense, so we'll be back, exit for now */
260 pc
->scsi_cmd
->result
= (CHECK_CONDITION
<< 1) | (DID_OK
<< 16);
262 pc
->scsi_cmd
->result
= DID_OK
<< 16;
264 host
= pc
->scsi_cmd
->device
->host
;
265 spin_lock_irqsave(host
->host_lock
, flags
);
266 pc
->done(pc
->scsi_cmd
);
267 spin_unlock_irqrestore(host
->host_lock
, flags
);
274 static inline unsigned long get_timeout(struct ide_atapi_pc
*pc
)
276 return max_t(unsigned long, WAIT_CMD
, pc
->timeout
- jiffies
);
279 static int idescsi_expiry(ide_drive_t
*drive
)
281 idescsi_scsi_t
*scsi
= drive_to_idescsi(drive
);
282 struct ide_atapi_pc
*pc
= scsi
->pc
;
284 debug_log("%s called for %lu at %lu\n", __func__
,
285 pc
->scsi_cmd
->serial_number
, jiffies
);
287 pc
->flags
|= PC_FLAG_TIMEDOUT
;
289 return 0; /* we do not want the ide subsystem to retry */
293 * Our interrupt handler.
295 static ide_startstop_t
idescsi_pc_intr (ide_drive_t
*drive
)
297 idescsi_scsi_t
*scsi
= drive_to_idescsi(drive
);
298 struct ide_atapi_pc
*pc
= scsi
->pc
;
300 return ide_pc_intr(drive
, pc
, idescsi_pc_intr
, get_timeout(pc
),
301 idescsi_expiry
, NULL
, NULL
, NULL
,
305 static ide_startstop_t
idescsi_transfer_pc(ide_drive_t
*drive
)
307 idescsi_scsi_t
*scsi
= drive_to_idescsi(drive
);
309 return ide_transfer_pc(drive
, scsi
->pc
, idescsi_pc_intr
,
310 get_timeout(scsi
->pc
), idescsi_expiry
);
313 static inline int idescsi_set_direction(struct ide_atapi_pc
*pc
)
316 case READ_6
: case READ_10
: case READ_12
:
317 pc
->flags
&= ~PC_FLAG_WRITING
;
319 case WRITE_6
: case WRITE_10
: case WRITE_12
:
320 pc
->flags
|= PC_FLAG_WRITING
;
327 static int idescsi_map_sg(ide_drive_t
*drive
, struct ide_atapi_pc
*pc
)
329 ide_hwif_t
*hwif
= drive
->hwif
;
330 struct scatterlist
*sg
, *scsi_sg
;
333 if (!pc
->req_xfer
|| pc
->req_xfer
% 1024)
336 if (idescsi_set_direction(pc
))
340 scsi_sg
= scsi_sglist(pc
->scsi_cmd
);
341 segments
= scsi_sg_count(pc
->scsi_cmd
);
343 if (segments
> hwif
->sg_max_nents
)
346 hwif
->sg_nents
= segments
;
347 memcpy(sg
, scsi_sg
, sizeof(*sg
) * segments
);
352 static ide_startstop_t
idescsi_issue_pc(ide_drive_t
*drive
,
353 struct ide_atapi_pc
*pc
)
355 idescsi_scsi_t
*scsi
= drive_to_idescsi(drive
);
357 /* Set the current packet command */
360 return ide_issue_pc(drive
, pc
, idescsi_transfer_pc
,
361 get_timeout(pc
), idescsi_expiry
);
365 * idescsi_do_request is our request handling function.
367 static ide_startstop_t
idescsi_do_request (ide_drive_t
*drive
, struct request
*rq
, sector_t block
)
369 debug_log("dev: %s, cmd: %x, errors: %d\n", rq
->rq_disk
->disk_name
,
370 rq
->cmd
[0], rq
->errors
);
371 debug_log("sector: %ld, nr_sectors: %ld, current_nr_sectors: %d\n",
372 rq
->sector
, rq
->nr_sectors
, rq
->current_nr_sectors
);
374 if (blk_sense_request(rq
) || blk_special_request(rq
)) {
375 struct ide_atapi_pc
*pc
= (struct ide_atapi_pc
*)rq
->special
;
377 if (drive
->using_dma
&& !idescsi_map_sg(drive
, pc
))
378 pc
->flags
|= PC_FLAG_DMA_OK
;
380 return idescsi_issue_pc(drive
, pc
);
382 blk_dump_rq_flags(rq
, "ide-scsi: unsup command");
383 idescsi_end_request (drive
, 0, 0);
387 #ifdef CONFIG_IDE_PROC_FS
388 #define ide_scsi_devset_get(name, field) \
389 static int get_##name(ide_drive_t *drive) \
391 idescsi_scsi_t *scsi = drive_to_idescsi(drive); \
392 return scsi->field; \
395 #define ide_scsi_devset_set(name, field) \
396 static int set_##name(ide_drive_t *drive, int arg) \
398 idescsi_scsi_t *scsi = drive_to_idescsi(drive); \
403 #define ide_scsi_devset_rw_field(_name, _field) \
404 ide_scsi_devset_get(_name, _field); \
405 ide_scsi_devset_set(_name, _field); \
406 IDE_DEVSET(_name, DS_SYNC, get_##_name, set_##_name);
408 ide_devset_rw_field(bios_cyl
, bios_cyl
);
409 ide_devset_rw_field(bios_head
, bios_head
);
410 ide_devset_rw_field(bios_sect
, bios_sect
);
412 ide_scsi_devset_rw_field(transform
, transform
);
413 ide_scsi_devset_rw_field(log
, log
);
415 static const struct ide_proc_devset idescsi_settings
[] = {
416 IDE_PROC_DEVSET(bios_cyl
, 0, 1023),
417 IDE_PROC_DEVSET(bios_head
, 0, 255),
418 IDE_PROC_DEVSET(bios_sect
, 0, 63),
419 IDE_PROC_DEVSET(log
, 0, 1),
420 IDE_PROC_DEVSET(transform
, 0, 3),
426 * Driver initialization.
428 static void idescsi_setup (ide_drive_t
*drive
, idescsi_scsi_t
*scsi
)
430 if ((drive
->id
[ATA_ID_CONFIG
] & 0x0060) == 0x20)
431 set_bit(IDE_AFLAG_DRQ_INTERRUPT
, &drive
->atapi_flags
);
432 clear_bit(IDESCSI_SG_TRANSFORM
, &scsi
->transform
);
433 #if IDESCSI_DEBUG_LOG
434 set_bit(IDESCSI_LOG_CMD
, &scsi
->log
);
435 #endif /* IDESCSI_DEBUG_LOG */
437 drive
->pc_callback
= ide_scsi_callback
;
439 ide_proc_register_driver(drive
, scsi
->driver
);
442 static void ide_scsi_remove(ide_drive_t
*drive
)
444 struct Scsi_Host
*scsihost
= drive
->driver_data
;
445 struct ide_scsi_obj
*scsi
= scsihost_to_idescsi(scsihost
);
446 struct gendisk
*g
= scsi
->disk
;
448 scsi_remove_host(scsihost
);
449 ide_proc_unregister_driver(drive
, scsi
->driver
);
451 ide_unregister_region(g
);
453 drive
->driver_data
= NULL
;
454 g
->private_data
= NULL
;
462 static int ide_scsi_probe(ide_drive_t
*);
464 #ifdef CONFIG_IDE_PROC_FS
465 static ide_proc_entry_t idescsi_proc
[] = {
466 { "capacity", S_IFREG
|S_IRUGO
, proc_ide_read_capacity
, NULL
},
467 { NULL
, 0, NULL
, NULL
}
471 static ide_driver_t idescsi_driver
= {
473 .owner
= THIS_MODULE
,
475 .bus
= &ide_bus_type
,
477 .probe
= ide_scsi_probe
,
478 .remove
= ide_scsi_remove
,
479 .version
= IDESCSI_VERSION
,
481 .do_request
= idescsi_do_request
,
482 .end_request
= idescsi_end_request
,
483 .error
= idescsi_atapi_error
,
484 #ifdef CONFIG_IDE_PROC_FS
485 .proc
= idescsi_proc
,
486 .settings
= idescsi_settings
,
490 static int idescsi_ide_open(struct inode
*inode
, struct file
*filp
)
492 struct gendisk
*disk
= inode
->i_bdev
->bd_disk
;
493 struct ide_scsi_obj
*scsi
;
495 if (!(scsi
= ide_scsi_get(disk
)))
501 static int idescsi_ide_release(struct inode
*inode
, struct file
*filp
)
503 struct gendisk
*disk
= inode
->i_bdev
->bd_disk
;
504 struct ide_scsi_obj
*scsi
= ide_scsi_g(disk
);
511 static int idescsi_ide_ioctl(struct inode
*inode
, struct file
*file
,
512 unsigned int cmd
, unsigned long arg
)
514 struct block_device
*bdev
= inode
->i_bdev
;
515 struct ide_scsi_obj
*scsi
= ide_scsi_g(bdev
->bd_disk
);
516 return generic_ide_ioctl(scsi
->drive
, file
, bdev
, cmd
, arg
);
519 static struct block_device_operations idescsi_ops
= {
520 .owner
= THIS_MODULE
,
521 .open
= idescsi_ide_open
,
522 .release
= idescsi_ide_release
,
523 .ioctl
= idescsi_ide_ioctl
,
526 static int idescsi_slave_configure(struct scsi_device
* sdp
)
528 /* Configure detected device */
529 sdp
->use_10_for_rw
= 1;
530 sdp
->use_10_for_ms
= 1;
531 scsi_adjust_queue_depth(sdp
, MSG_SIMPLE_TAG
, sdp
->host
->cmd_per_lun
);
535 static const char *idescsi_info (struct Scsi_Host
*host
)
537 return "SCSI host adapter emulation for IDE ATAPI devices";
540 static int idescsi_ioctl (struct scsi_device
*dev
, int cmd
, void __user
*arg
)
542 idescsi_scsi_t
*scsi
= scsihost_to_idescsi(dev
->host
);
544 if (cmd
== SG_SET_TRANSFORM
) {
546 set_bit(IDESCSI_SG_TRANSFORM
, &scsi
->transform
);
548 clear_bit(IDESCSI_SG_TRANSFORM
, &scsi
->transform
);
550 } else if (cmd
== SG_GET_TRANSFORM
)
551 return put_user(test_bit(IDESCSI_SG_TRANSFORM
, &scsi
->transform
), (int __user
*) arg
);
555 static int idescsi_queue (struct scsi_cmnd
*cmd
,
556 void (*done
)(struct scsi_cmnd
*))
558 struct Scsi_Host
*host
= cmd
->device
->host
;
559 idescsi_scsi_t
*scsi
= scsihost_to_idescsi(host
);
560 ide_drive_t
*drive
= scsi
->drive
;
561 struct request
*rq
= NULL
;
562 struct ide_atapi_pc
*pc
= NULL
;
563 int write
= cmd
->sc_data_direction
== DMA_TO_DEVICE
;
566 scmd_printk (KERN_ERR
, cmd
, "drive not present\n");
569 scsi
= drive_to_idescsi(drive
);
570 pc
= kmalloc(sizeof(struct ide_atapi_pc
), GFP_ATOMIC
);
571 rq
= blk_get_request(drive
->queue
, write
, GFP_ATOMIC
);
572 if (rq
== NULL
|| pc
== NULL
) {
573 printk (KERN_ERR
"ide-scsi: %s: out of memory\n", drive
->name
);
577 memset (pc
->c
, 0, 12);
579 if (cmd
->sc_data_direction
== DMA_TO_DEVICE
)
580 pc
->flags
|= PC_FLAG_WRITING
;
582 memcpy (pc
->c
, cmd
->cmnd
, cmd
->cmd_len
);
584 pc
->sg
= scsi_sglist(cmd
);
585 pc
->sg_cnt
= scsi_sg_count(cmd
);
587 pc
->req_xfer
= pc
->buf_size
= scsi_bufflen(cmd
);
590 pc
->timeout
= jiffies
+ cmd
->request
->timeout
;
592 if (test_bit(IDESCSI_LOG_CMD
, &scsi
->log
)) {
593 printk ("ide-scsi: %s: que %lu, cmd = ", drive
->name
, cmd
->serial_number
);
594 ide_scsi_hex_dump(cmd
->cmnd
, cmd
->cmd_len
);
595 if (memcmp(pc
->c
, cmd
->cmnd
, cmd
->cmd_len
)) {
596 printk ("ide-scsi: %s: que %lu, tsl = ", drive
->name
, cmd
->serial_number
);
597 ide_scsi_hex_dump(pc
->c
, 12);
601 rq
->special
= (char *) pc
;
602 rq
->cmd_type
= REQ_TYPE_SPECIAL
;
603 spin_unlock_irq(host
->host_lock
);
605 memcpy(rq
->cmd
, pc
->c
, 12);
606 blk_execute_rq_nowait(drive
->queue
, scsi
->disk
, rq
, 0, NULL
);
607 spin_lock_irq(host
->host_lock
);
613 cmd
->result
= DID_ERROR
<< 16;
618 static int idescsi_eh_abort (struct scsi_cmnd
*cmd
)
620 idescsi_scsi_t
*scsi
= scsihost_to_idescsi(cmd
->device
->host
);
621 ide_drive_t
*drive
= scsi
->drive
;
625 /* In idescsi_eh_abort we try to gently pry our command from the ide subsystem */
627 if (test_bit(IDESCSI_LOG_CMD
, &scsi
->log
))
628 printk (KERN_WARNING
"ide-scsi: abort called for %lu\n", cmd
->serial_number
);
631 printk (KERN_WARNING
"ide-scsi: Drive not set in idescsi_eh_abort\n");
636 /* First give it some more time, how much is "right" is hard to say :-( */
638 busy
= ide_wait_not_busy(HWIF(drive
), 100); /* FIXME - uses mdelay which causes latency? */
639 if (test_bit(IDESCSI_LOG_CMD
, &scsi
->log
))
640 printk (KERN_WARNING
"ide-scsi: drive did%s become ready\n", busy
?" not":"");
642 spin_lock_irq(&ide_lock
);
644 /* If there is no pc running we're done (our interrupt took care of it) */
650 /* It's somewhere in flight. Does ide subsystem agree? */
651 if (scsi
->pc
->scsi_cmd
->serial_number
== cmd
->serial_number
&& !busy
&&
652 elv_queue_empty(drive
->queue
) && HWGROUP(drive
)->rq
!= scsi
->pc
->rq
) {
654 * FIXME - not sure this condition can ever occur
656 printk (KERN_ERR
"ide-scsi: cmd aborted!\n");
658 if (blk_sense_request(scsi
->pc
->rq
))
659 kfree(scsi
->pc
->buf
);
660 /* we need to call blk_put_request twice. */
661 blk_put_request(scsi
->pc
->rq
);
662 blk_put_request(scsi
->pc
->rq
);
670 spin_unlock_irq(&ide_lock
);
672 if (test_bit(IDESCSI_LOG_CMD
, &scsi
->log
))
673 printk (KERN_WARNING
"ide-scsi: abort returns %s\n", ret
== SUCCESS
?"success":"failed");
678 static int idescsi_eh_reset (struct scsi_cmnd
*cmd
)
681 idescsi_scsi_t
*scsi
= scsihost_to_idescsi(cmd
->device
->host
);
682 ide_drive_t
*drive
= scsi
->drive
;
686 /* In idescsi_eh_reset we forcefully remove the command from the ide subsystem and reset the device. */
688 if (test_bit(IDESCSI_LOG_CMD
, &scsi
->log
))
689 printk (KERN_WARNING
"ide-scsi: reset called for %lu\n", cmd
->serial_number
);
692 printk (KERN_WARNING
"ide-scsi: Drive not set in idescsi_eh_reset\n");
697 spin_lock_irq(cmd
->device
->host
->host_lock
);
698 spin_lock(&ide_lock
);
700 if (!scsi
->pc
|| (req
= scsi
->pc
->rq
) != HWGROUP(drive
)->rq
|| !HWGROUP(drive
)->handler
) {
701 printk (KERN_WARNING
"ide-scsi: No active request in idescsi_eh_reset\n");
702 spin_unlock(&ide_lock
);
703 spin_unlock_irq(cmd
->device
->host
->host_lock
);
707 /* kill current request */
708 if (__blk_end_request(req
, -EIO
, 0))
710 if (blk_sense_request(req
))
711 kfree(scsi
->pc
->buf
);
714 blk_put_request(req
);
716 /* now nuke the drive queue */
717 while ((req
= elv_next_request(drive
->queue
))) {
718 if (__blk_end_request(req
, -EIO
, 0))
722 HWGROUP(drive
)->rq
= NULL
;
723 HWGROUP(drive
)->handler
= NULL
;
724 HWGROUP(drive
)->busy
= 1; /* will set this to zero when ide reset finished */
725 spin_unlock(&ide_lock
);
729 /* ide_do_reset starts a polling handler which restarts itself every 50ms until the reset finishes */
732 spin_unlock_irq(cmd
->device
->host
->host_lock
);
734 spin_lock_irq(cmd
->device
->host
->host_lock
);
735 } while ( HWGROUP(drive
)->handler
);
737 ready
= drive_is_ready(drive
);
738 HWGROUP(drive
)->busy
--;
740 printk (KERN_ERR
"ide-scsi: reset failed!\n");
744 spin_unlock_irq(cmd
->device
->host
->host_lock
);
748 static int idescsi_bios(struct scsi_device
*sdev
, struct block_device
*bdev
,
749 sector_t capacity
, int *parm
)
751 idescsi_scsi_t
*idescsi
= scsihost_to_idescsi(sdev
->host
);
752 ide_drive_t
*drive
= idescsi
->drive
;
754 if (drive
->bios_cyl
&& drive
->bios_head
&& drive
->bios_sect
) {
755 parm
[0] = drive
->bios_head
;
756 parm
[1] = drive
->bios_sect
;
757 parm
[2] = drive
->bios_cyl
;
762 static struct scsi_host_template idescsi_template
= {
763 .module
= THIS_MODULE
,
765 .info
= idescsi_info
,
766 .slave_configure
= idescsi_slave_configure
,
767 .ioctl
= idescsi_ioctl
,
768 .queuecommand
= idescsi_queue
,
769 .eh_abort_handler
= idescsi_eh_abort
,
770 .eh_host_reset_handler
= idescsi_eh_reset
,
771 .bios_param
= idescsi_bios
,
777 .use_clustering
= DISABLE_CLUSTERING
,
779 .proc_name
= "ide-scsi",
782 static int ide_scsi_probe(ide_drive_t
*drive
)
784 idescsi_scsi_t
*idescsi
;
785 struct Scsi_Host
*host
;
791 if (!warned
&& drive
->media
== ide_cdrom
) {
792 printk(KERN_WARNING
"ide-scsi is deprecated for cd burning! Use ide-cd and give dev=/dev/hdX as device\n");
796 if (idescsi_nocd
&& drive
->media
== ide_cdrom
)
799 if (!strstr("ide-scsi", drive
->driver_req
) ||
800 drive
->media
== ide_disk
||
801 !(host
= scsi_host_alloc(&idescsi_template
,sizeof(idescsi_scsi_t
))))
806 g
= alloc_disk(1 << PARTN_BITS
);
810 ide_init_disk(g
, drive
);
814 last_lun
= drive
->id
[ATA_ID_LAST_LUN
];
816 debug_log("%s: last_lun=%u\n", drive
->name
, last_lun
);
818 if ((last_lun
& 7) != 7)
819 host
->max_lun
= (last_lun
& 7) + 1;
823 drive
->driver_data
= host
;
824 idescsi
= scsihost_to_idescsi(host
);
825 idescsi
->drive
= drive
;
826 idescsi
->driver
= &idescsi_driver
;
827 idescsi
->host
= host
;
829 g
->private_data
= &idescsi
->driver
;
831 idescsi_setup(drive
, idescsi
);
832 g
->fops
= &idescsi_ops
;
833 ide_register_region(g
);
834 err
= scsi_add_host(host
, &drive
->gendev
);
836 scsi_scan_host(host
);
839 /* fall through on error */
840 ide_unregister_region(g
);
841 ide_proc_unregister_driver(drive
, &idescsi_driver
);
850 static int __init
init_idescsi_module(void)
852 return driver_register(&idescsi_driver
.gen_driver
);
855 static void __exit
exit_idescsi_module(void)
857 driver_unregister(&idescsi_driver
.gen_driver
);
860 module_param(idescsi_nocd
, int, 0600);
861 MODULE_PARM_DESC(idescsi_nocd
, "Disable handling of CD-ROMs so they may be driven by ide-cd");
862 module_init(init_idescsi_module
);
863 module_exit(exit_idescsi_module
);
864 MODULE_LICENSE("GPL");