1 /*
2 * linux/drivers/scsi/ide-scsi.c Version 0.94 Sept 09, 2003
3 *
4 * Copyright (C) 1996 - 1999 Gadi Oxman <gadio@netvision.net.il>
5 * Copyright (C) 2001 - 2002 Andre Hedrick <andre@linux-ide.org>
6 */
7
8 /*
9 * Emulation of a SCSI host adapter for IDE ATAPI devices.
10 *
11 * With this driver, one can use the Linux SCSI drivers instead of the
12 * native IDE ATAPI drivers.
13 *
14 * Ver 0.1 Dec 3 96 Initial version.
15 * Ver 0.2 Jan 26 97 Fixed bug in cleanup_module() and added emulation
16 * of MODE_SENSE_6/MODE_SELECT_6 for cdroms. Thanks
17 * to Janos Farkas for pointing this out.
18 * Avoid using bitfields in structures for m68k.
19 * Added Scatter/Gather and DMA support.
20 * Ver 0.4 Dec 7 97 Add support for ATAPI PD/CD drives.
21 * Use variable timeout for each command.
22 * Ver 0.5 Jan 2 98 Fix previous PD/CD support.
23 * Allow disabling of SCSI-6 to SCSI-10 transformation.
24 * Ver 0.6 Jan 27 98 Allow disabling of SCSI command translation layer
25 * for access through /dev/sg.
26 * Fix MODE_SENSE_6/MODE_SELECT_6/INQUIRY translation.
27 * Ver 0.7 Dec 04 98 Ignore commands where lun != 0 to avoid multiple
28 * detection of devices with CONFIG_SCSI_MULTI_LUN
29 * Ver 0.8 Feb 05 99 Optical media need translation too. Reverse 0.7.
30 * Ver 0.9 Jul 04 99 Fix a bug in SG_SET_TRANSFORM.
31 * Ver 0.91 Jan 06 02 Added 'ignore' parameter when ide-scsi is a module
32 * so that use of scsi emulation can be made independent
33 * of load order when other IDE drivers are modules.
34 * Chris Ebenezer <chriseb@pobox.com>
35 * Ver 0.92 Mar 21 02 Include DevFs support
36 * Borsenkow Andrej <Andrej.Borsenkow@mow.siemens.ru>
37 * Ver 0.93 Jun 10 02 Fix "off by one" error in transforms
38 * Ver 0.94 Sep 09 03 Added transform for reading ATAPI tape drive block
39 * limits (ATAPI tapes report block limits in mode
40 * page 0x2A, not by "read block limits" command)
41 */
42
43 #define IDESCSI_VERSION "0.94"
44
45 #include <linux/module.h>
46 #include <linux/config.h>
47 #include <linux/types.h>
48 #include <linux/string.h>
49 #include <linux/kernel.h>
50 #include <linux/mm.h>
51 #include <linux/ioport.h>
52 #include <linux/blkdev.h>
53 #include <linux/errno.h>
54 #include <linux/hdreg.h>
55 #include <linux/slab.h>
56 #include <linux/ide.h>
57
58 #include <asm/io.h>
59 #include <asm/bitops.h>
60 #include <asm/uaccess.h>
61
62 #include "scsi.h"
63 #include "hosts.h"
64 #include "sd.h"
65 #include "ide-scsi.h"
66 #include <scsi/sg.h>
67
68 #define IDESCSI_DEBUG_LOG 0
69
70 typedef struct idescsi_pc_s {
71 u8 c[12]; /* Actual packet bytes */
72 int request_transfer; /* Bytes to transfer */
73 int actually_transferred; /* Bytes actually transferred */
74 int buffer_size; /* Size of our data buffer */
75 struct request *rq; /* The corresponding request */
76 u8 *buffer; /* Data buffer */
77 u8 *current_position; /* Pointer into the above buffer */
78 struct scatterlist *sg; /* Scatter gather table */
79 int b_count; /* Bytes transferred from current entry */
80 Scsi_Cmnd *scsi_cmd; /* SCSI command */
81 void (*done)(Scsi_Cmnd *); /* Scsi completion routine */
82 unsigned long flags; /* Status/Action flags */
83 unsigned long timeout; /* Command timeout */
84 } idescsi_pc_t;
85
86 /*
87 * Packet command status bits.
88 */
89 #define PC_DMA_IN_PROGRESS 0 /* 1 while DMA in progress */
90 #define PC_WRITING 1 /* Data direction */
91 #define PC_TRANSFORM 2 /* transform SCSI commands */
92 #define PC_DMA_OK 4 /* Use DMA */
93
94 /*
95 * SCSI command transformation layer
96 */
97 #define IDESCSI_TRANSFORM 0 /* Enable/Disable transformation */
98 #define IDESCSI_SG_TRANSFORM 1 /* /dev/sg transformation */
99
100 /*
101 * Log flags
102 */
103 #define IDESCSI_LOG_CMD 0 /* Log SCSI commands */
104
105 #define IDESCSI_DEVFS
106
107 typedef struct {
108 ide_drive_t *drive;
109 idescsi_pc_t *pc; /* Current packet command */
110 unsigned long flags; /* Status/Action flags */
111 unsigned long transform; /* SCSI cmd translation layer */
112 unsigned long log; /* log flags */
113 int id; /* id */
114 #ifdef IDESCSI_DEVFS
115 devfs_handle_t de; /* pointer to IDE device */
116 #endif /* IDESCSI_DEVFS */
117 } idescsi_scsi_t;
118
119 /*
120 * Per ATAPI device status bits.
121 */
122 #define IDESCSI_DRQ_INTERRUPT 0 /* DRQ interrupt device */
123
124 /*
125 * ide-scsi requests.
126 */
127 #define IDESCSI_PC_RQ 90
128
idescsi_discard_data(ide_drive_t * drive,unsigned int bcount)129 static void idescsi_discard_data (ide_drive_t *drive, unsigned int bcount)
130 {
131 while (bcount--)
132 (void) HWIF(drive)->INB(IDE_DATA_REG);
133 }
134
idescsi_output_zeros(ide_drive_t * drive,unsigned int bcount)135 static void idescsi_output_zeros (ide_drive_t *drive, unsigned int bcount)
136 {
137 while (bcount--)
138 HWIF(drive)->OUTB(0, IDE_DATA_REG);
139 }
140
141 /*
142 * PIO data transfer routines using the scatter gather table.
143 */
idescsi_input_buffers(ide_drive_t * drive,idescsi_pc_t * pc,unsigned int bcount)144 static void idescsi_input_buffers (ide_drive_t *drive, idescsi_pc_t *pc, unsigned int bcount)
145 {
146 int count;
147
148 while (bcount) {
149 if (pc->sg - (struct scatterlist *) pc->scsi_cmd->request_buffer > pc->scsi_cmd->use_sg) {
150 printk(KERN_ERR "ide-scsi: scatter gather "
151 "table too small, discarding data\n");
152 idescsi_discard_data(drive, bcount);
153 return;
154 }
155 count = IDE_MIN(pc->sg->length - pc->b_count, bcount);
156 HWIF(drive)->atapi_input_bytes(drive, pc->sg->address + pc->b_count, count);
157 bcount -= count;
158 pc->b_count += count;
159 if (pc->b_count == pc->sg->length) {
160 pc->sg++;
161 pc->b_count = 0;
162 }
163 }
164 }
165
idescsi_output_buffers(ide_drive_t * drive,idescsi_pc_t * pc,unsigned int bcount)166 static void idescsi_output_buffers (ide_drive_t *drive, idescsi_pc_t *pc, unsigned int bcount)
167 {
168 int count;
169
170 while (bcount) {
171 if (pc->sg - (struct scatterlist *) pc->scsi_cmd->request_buffer > pc->scsi_cmd->use_sg) {
172 printk(KERN_ERR "ide-scsi: scatter gather table "
173 "too small, padding with zeros\n");
174 idescsi_output_zeros(drive, bcount);
175 return;
176 }
177 count = IDE_MIN(pc->sg->length - pc->b_count, bcount);
178 HWIF(drive)->atapi_output_bytes(drive, pc->sg->address + pc->b_count, count);
179 bcount -= count;
180 pc->b_count += count;
181 if (pc->b_count == pc->sg->length) {
182 pc->sg++;
183 pc->b_count = 0;
184 }
185 }
186 }
187
188 /*
189 * Most of the SCSI commands are supported directly by ATAPI devices.
190 * idescsi_transform_pc handles the few exceptions.
191 */
idescsi_transform_pc1(ide_drive_t * drive,idescsi_pc_t * pc)192 static inline void idescsi_transform_pc1 (ide_drive_t *drive, idescsi_pc_t *pc)
193 {
194 u8 *c = pc->c, *scsi_buf = pc->buffer, *sc = pc->scsi_cmd->cmnd;
195 char *atapi_buf;
196
197 if (!test_bit(PC_TRANSFORM, &pc->flags))
198 return;
199 if (drive->media == ide_cdrom || drive->media == ide_optical) {
200 if (c[0] == READ_6 || c[0] == WRITE_6) {
201 c[8] = c[4];
202 c[5] = c[3];
203 c[4] = c[2];
204 c[3] = c[1] & 0x1f;
205 c[2] = 0;
206 c[1] &= 0xe0;
207 c[0] += (READ_10 - READ_6);
208 }
209 if (c[0] == MODE_SENSE || c[0] == MODE_SELECT) {
210 unsigned short new_len;
211 if (!scsi_buf)
212 return;
213 if ((atapi_buf = kmalloc(pc->buffer_size + 4, GFP_ATOMIC)) == NULL)
214 return;
215 memset(atapi_buf, 0, pc->buffer_size + 4);
216 memset (c, 0, 12);
217 c[0] = sc[0] | 0x40;
218 c[1] = sc[1];
219 c[2] = sc[2];
220 new_len = sc[4] + 4;
221 c[8] = new_len;
222 c[7] = new_len >> 8;
223 c[9] = sc[5];
224 if (c[0] == MODE_SELECT_10) {
225 /* Mode data length */
226 atapi_buf[1] = scsi_buf[0];
227 /* Medium type */
228 atapi_buf[2] = scsi_buf[1];
229 /* Device specific parameter */
230 atapi_buf[3] = scsi_buf[2];
231 /* Block descriptor length */
232 atapi_buf[7] = scsi_buf[3];
233 memcpy(atapi_buf + 8, scsi_buf + 4, pc->buffer_size - 4);
234 }
235 pc->buffer = atapi_buf;
236 pc->request_transfer += 4;
237 pc->buffer_size += 4;
238 }
239 }
240 if (drive->media == ide_tape) {
241 if (sc[0] == READ_BLOCK_LIMITS) { /* IDE tapes have blk lmts in mode page 0x2a */
242 if (!scsi_buf)
243 return;
244 /* buffer size should be 6 for READ_BLOCK_LIMITS */
245 /* we need 12 bytes (4 for header + 8 for mode page */
246 if ((atapi_buf = kmalloc(12, GFP_ATOMIC)) == NULL)
247 return;
248 memset(atapi_buf, 0, 12);
249 memset (c, 0, 12);
250 c[0] = MODE_SENSE;
251 c[1] = 8; /* no block descriptors */
252 c[2] = 0x2A; /* mode page 0x2A */
253 c[4] = 12; /* buffer length 12 decimal */
254 pc->buffer = atapi_buf;
255 pc->request_transfer = 12;
256 pc->buffer_size = 12;
257 }
258 }
259 }
260
idescsi_transform_pc2(ide_drive_t * drive,idescsi_pc_t * pc)261 static inline void idescsi_transform_pc2 (ide_drive_t *drive, idescsi_pc_t *pc)
262 {
263 u8 *atapi_buf = pc->buffer;
264 u8 *sc = pc->scsi_cmd->cmnd;
265 u8 *scsi_buf = pc->scsi_cmd->request_buffer;
266
267 if (!test_bit(PC_TRANSFORM, &pc->flags))
268 return;
269 if (drive->media == ide_cdrom || drive->media == ide_optical) {
270 if (pc->c[0] == MODE_SENSE_10 && sc[0] == MODE_SENSE) {
271 /* Mode data length */
272 scsi_buf[0] = atapi_buf[1];
273 /* Medium type */
274 scsi_buf[1] = atapi_buf[2];
275 /* Device specific parameter */
276 scsi_buf[2] = atapi_buf[3];
277 /* Block descriptor length */
278 scsi_buf[3] = atapi_buf[7];
279 memcpy(scsi_buf + 4, atapi_buf + 8, pc->request_transfer - 8);
280 }
281 if (pc->c[0] == INQUIRY) {
282 /* ansi_revision */
283 scsi_buf[2] |= 2;
284 /* response data format */
285 scsi_buf[3] = (scsi_buf[3] & 0xf0) | 2;
286 }
287 }
288 if (drive->media == ide_tape) {
289 if (sc[0] == READ_BLOCK_LIMITS) {
290 memset(scsi_buf, 0, pc->scsi_cmd->request_bufflen);
291 /* granularity of 9 (always 9 for ide tapes) */
292 scsi_buf[0] = 9;
293 /* block length of 1024 bytes supported? */
294 scsi_buf[2] = (atapi_buf[11] & 0x04) ? 4 : 2;
295 /* block length of 512 bytes supported? */
296 scsi_buf[4] = (atapi_buf[11] & 0x02) ? 2 : 4;
297 }
298 }
299
300 if (atapi_buf && atapi_buf != scsi_buf)
301 kfree(atapi_buf);
302 }
303
idescsi_free_bh(struct buffer_head * bh)304 static inline void idescsi_free_bh (struct buffer_head *bh)
305 {
306 struct buffer_head *bhp;
307
308 while (bh) {
309 bhp = bh;
310 bh = bh->b_reqnext;
311 kfree (bhp);
312 }
313 }
314
hexdump(u8 * x,int len)315 static void hexdump(u8 *x, int len)
316 {
317 int i;
318
319 printk("[ ");
320 for (i = 0; i < len; i++)
321 printk("%x ", x[i]);
322 printk("]\n");
323 }
324
idescsi_do_end_request(ide_drive_t * drive,int uptodate)325 static int idescsi_do_end_request (ide_drive_t *drive, int uptodate)
326 {
327 struct request *rq;
328 unsigned long flags;
329 int ret = 1;
330
331 spin_lock_irqsave(&io_request_lock, flags);
332 rq = HWGROUP(drive)->rq;
333
334 /*
335 * decide whether to reenable DMA -- 3 is a random magic for now,
336 * if we DMA timeout more than 3 times, just stay in PIO
337 */
338 if (drive->state == DMA_PIO_RETRY && drive->retry_pio <= 3) {
339 drive->state = 0;
340 HWGROUP(drive)->hwif->ide_dma_on(drive);
341 }
342
343 if (!end_that_request_first(rq, uptodate, drive->name)) {
344 add_blkdev_randomness(MAJOR(rq->rq_dev));
345 blkdev_dequeue_request(rq);
346 HWGROUP(drive)->rq = NULL;
347 end_that_request_last(rq);
348 ret = 0;
349 }
350 spin_unlock_irqrestore(&io_request_lock, flags);
351 return ret;
352 }
353
idescsi_end_request(ide_drive_t * drive,int uptodate)354 static int idescsi_end_request (ide_drive_t *drive, int uptodate)
355 {
356 idescsi_scsi_t *scsi = drive->driver_data;
357 struct request *rq = HWGROUP(drive)->rq;
358 idescsi_pc_t *pc = (idescsi_pc_t *) rq->special;
359 int log = test_bit(IDESCSI_LOG_CMD, &scsi->log);
360 u8 *scsi_buf;
361 unsigned long flags;
362
363 if (rq->cmd != IDESCSI_PC_RQ) {
364 idescsi_do_end_request(drive, uptodate);
365 return 0;
366 }
367 ide_end_drive_cmd(drive, 0, 0);
368 if (rq->errors >= ERROR_MAX) {
369 pc->scsi_cmd->result = DID_ERROR << 16;
370 if (log)
371 printk("ide-scsi: %s: I/O error for %lu\n",
372 drive->name, pc->scsi_cmd->serial_number);
373 } else if (rq->errors) {
374 pc->scsi_cmd->result = (CHECK_CONDITION << 1) | (DID_OK << 16);
375 if (log)
376 printk("ide-scsi: %s: check condition for %lu\n",
377 drive->name, pc->scsi_cmd->serial_number);
378 } else {
379 pc->scsi_cmd->result = DID_OK << 16;
380 idescsi_transform_pc2(drive, pc);
381 if (log) {
382 printk("ide-scsi: %s: suc %lu", drive->name,
383 pc->scsi_cmd->serial_number);
384 if (!test_bit(PC_WRITING, &pc->flags) &&
385 pc->actually_transferred &&
386 pc->actually_transferred <= 1024 &&
387 pc->buffer) {
388 printk(", rst = ");
389 scsi_buf = pc->scsi_cmd->request_buffer;
390 hexdump(scsi_buf, IDE_MIN(16, pc->scsi_cmd->request_bufflen));
391 } else printk("\n");
392 }
393 }
394 spin_lock_irqsave(&io_request_lock, flags);
395 pc->done(pc->scsi_cmd);
396 spin_unlock_irqrestore(&io_request_lock, flags);
397 idescsi_free_bh(rq->bh);
398 kfree(pc);
399 kfree(rq);
400 scsi->pc = NULL;
401 return 0;
402 }
403
get_timeout(idescsi_pc_t * pc)404 static inline unsigned long get_timeout(idescsi_pc_t *pc)
405 {
406 return IDE_MAX(WAIT_CMD, pc->timeout - jiffies);
407 }
408
409 /*
410 * Our interrupt handler.
411 */
idescsi_pc_intr(ide_drive_t * drive)412 static ide_startstop_t idescsi_pc_intr (ide_drive_t *drive)
413 {
414 idescsi_scsi_t *scsi = drive->driver_data;
415 idescsi_pc_t *pc = scsi->pc;
416 struct request *rq = pc->rq;
417 atapi_bcount_t bcount;
418 atapi_status_t status;
419 atapi_ireason_t ireason;
420 atapi_feature_t feature;
421 unsigned int temp;
422
423 #if IDESCSI_DEBUG_LOG
424 printk(KERN_INFO "ide-scsi: Reached idescsi_pc_intr "
425 "interrupt handler\n");
426 #endif /* IDESCSI_DEBUG_LOG */
427
428 if (test_and_clear_bit(PC_DMA_IN_PROGRESS, &pc->flags)) {
429 #if IDESCSI_DEBUG_LOG
430 printk("ide-scsi: %s: DMA complete\n", drive->name);
431 #endif /* IDESCSI_DEBUG_LOG */
432 pc->actually_transferred = pc->request_transfer;
433 (void) (HWIF(drive)->ide_dma_end(drive));
434 }
435
436 feature.all = 0;
437 /* Clear the interrupt */
438 status.all = HWIF(drive)->INB(IDE_STATUS_REG);
439
440 if (!status.b.drq) {
441 /* No more interrupts */
442 if (test_bit(IDESCSI_LOG_CMD, &scsi->log))
443 printk(KERN_INFO "Packet command completed, %d "
444 "bytes transferred\n",
445 pc->actually_transferred);
446 local_irq_enable();
447 if (status.b.check)
448 rq->errors++;
449 idescsi_end_request(drive, 1);
450 return ide_stopped;
451 }
452
453 bcount.b.low = HWIF(drive)->INB(IDE_BCOUNTL_REG);
454 bcount.b.high = HWIF(drive)->INB(IDE_BCOUNTH_REG);
455 ireason.all = HWIF(drive)->INB(IDE_IREASON_REG);
456
457 if (ireason.b.cod) {
458 printk(KERN_ERR "ide-scsi: CoD != 0 in idescsi_pc_intr\n");
459 return ide_do_reset(drive);
460 }
461 if (ireason.b.io) {
462 temp = pc->actually_transferred + bcount.all;
463 if (temp > pc->request_transfer) {
464 if (temp > pc->buffer_size) {
465 printk(KERN_ERR "ide-scsi: The scsi wants to "
466 "send us more data than expected "
467 "- discarding data\n");
468 printk(KERN_ERR "ide-scsi: [");
469 hexdump(pc->c, 12);
470 printk("]\n");
471 printk(KERN_ERR "ide-scsi: expected %d got %d limit %d\n",
472 pc->request_transfer, temp, pc->buffer_size);
473 temp = pc->buffer_size - pc->actually_transferred;
474 if (temp) {
475 clear_bit(PC_WRITING, &pc->flags);
476 if (pc->sg)
477 idescsi_input_buffers(drive, pc, temp);
478 else
479 HWIF(drive)->atapi_input_bytes(drive, pc->current_position, temp);
480 printk(KERN_ERR "ide-scsi: transferred %d of %d bytes\n", temp, bcount.all);
481 }
482 pc->actually_transferred += temp;
483 pc->current_position += temp;
484 idescsi_discard_data(drive, bcount.all - temp);
485 if (HWGROUP(drive)->handler != NULL)
486 BUG();
487 ide_set_handler(drive,
488 &idescsi_pc_intr,
489 get_timeout(pc),
490 NULL);
491 return ide_started;
492 }
493 #if IDESCSI_DEBUG_LOG
494 printk(KERN_NOTICE "ide-scsi: The scsi wants to send "
495 "us more data than expected - "
496 "allowing transfer\n");
497 #endif /* IDESCSI_DEBUG_LOG */
498 }
499 }
500 if (ireason.b.io) {
501 clear_bit(PC_WRITING, &pc->flags);
502 if (pc->sg)
503 idescsi_input_buffers(drive, pc, bcount.all);
504 else
505 HWIF(drive)->atapi_input_bytes(drive, pc->current_position, bcount.all);
506 } else {
507 set_bit(PC_WRITING, &pc->flags);
508 if (pc->sg)
509 idescsi_output_buffers(drive, pc, bcount.all);
510 else
511 HWIF(drive)->atapi_output_bytes(drive, pc->current_position, bcount.all);
512 }
513 /* Update the current position */
514 pc->actually_transferred += bcount.all;
515 pc->current_position += bcount.all;
516
517 if (HWGROUP(drive)->handler != NULL)
518 BUG();
519 /* And set the interrupt handler again */
520 ide_set_handler(drive, &idescsi_pc_intr, get_timeout(pc), NULL);
521 return ide_started;
522 }
523
idescsi_transfer_pc(ide_drive_t * drive)524 static ide_startstop_t idescsi_transfer_pc (ide_drive_t *drive)
525 {
526 idescsi_scsi_t *scsi = drive->driver_data;
527 idescsi_pc_t *pc = scsi->pc;
528 atapi_ireason_t ireason;
529 ide_startstop_t startstop;
530
531 if (ide_wait_stat(&startstop,drive,DRQ_STAT,BUSY_STAT,WAIT_READY)) {
532 printk(KERN_ERR "ide-scsi: Strange, packet command "
533 "initiated yet DRQ isn't asserted\n");
534 return startstop;
535 }
536
537 ireason.all = HWIF(drive)->INB(IDE_IREASON_REG);
538
539 if (!ireason.b.cod || ireason.b.io) {
540 printk(KERN_ERR "ide-scsi: (IO,CoD) != (0,1) while "
541 "issuing a packet command\n");
542 return ide_do_reset(drive);
543 }
544
545 if (HWGROUP(drive)->handler != NULL)
546 BUG();
547 /* Set the interrupt routine */
548 ide_set_handler(drive, &idescsi_pc_intr, get_timeout(pc), NULL);
549 /* Send the actual packet */
550 HWIF(drive)->atapi_output_bytes(drive, scsi->pc->c, 12);
551 if (test_bit (PC_DMA_OK, &pc->flags)) {
552 set_bit(PC_DMA_IN_PROGRESS, &pc->flags);
553 (void) (HWIF(drive)->ide_dma_begin(drive));
554 }
555 return ide_started;
556 }
557
558 /*
559 * Issue a packet command
560 */
idescsi_issue_pc(ide_drive_t * drive,idescsi_pc_t * pc)561 static ide_startstop_t idescsi_issue_pc (ide_drive_t *drive, idescsi_pc_t *pc)
562 {
563 idescsi_scsi_t *scsi = drive->driver_data;
564 atapi_feature_t feature;
565 atapi_bcount_t bcount;
566 struct request *rq = pc->rq;
567
568 feature.all = 0;
569
570 /* Set the current packet command */
571 scsi->pc = pc;
572 /* We haven't transferred any data yet */
573 pc->actually_transferred = 0;
574 pc->current_position = pc->buffer;
575 /* Request to transfer the entire buffer at once */
576 bcount.all = IDE_MIN(pc->request_transfer, 63 * 1024);
577
578
579 if (drive->using_dma && rq->bh) {
580 if (test_bit(PC_WRITING, &pc->flags))
581 feature.b.dma = !HWIF(drive)->ide_dma_write(drive);
582 else
583 feature.b.dma = !HWIF(drive)->ide_dma_read(drive);
584 }
585
586 SELECT_DRIVE(drive);
587 if (IDE_CONTROL_REG)
588 HWIF(drive)->OUTB(drive->ctl, IDE_CONTROL_REG);
589 HWIF(drive)->OUTB(feature.all, IDE_FEATURE_REG);
590 HWIF(drive)->OUTB(bcount.b.high, IDE_BCOUNTH_REG);
591 HWIF(drive)->OUTB(bcount.b.low, IDE_BCOUNTL_REG);
592
593 if (feature.b.dma) {
594 set_bit(PC_DMA_OK, &pc->flags);
595 }
596 if (test_bit(IDESCSI_DRQ_INTERRUPT, &scsi->flags)) {
597 if (HWGROUP(drive)->handler != NULL)
598 BUG();
599 ide_set_handler(drive,
600 &idescsi_transfer_pc,
601 get_timeout(pc),
602 NULL);
603 /* Issue the packet command */
604 HWIF(drive)->OUTB(WIN_PACKETCMD, IDE_COMMAND_REG);
605 return ide_started;
606 } else {
607 /* Issue the packet command */
608 HWIF(drive)->OUTB(WIN_PACKETCMD, IDE_COMMAND_REG);
609 return idescsi_transfer_pc(drive);
610 }
611 }
612
613 /*
614 * idescsi_do_request is our request handling function.
615 */
idescsi_do_request(ide_drive_t * drive,struct request * rq,unsigned long block)616 static ide_startstop_t idescsi_do_request (ide_drive_t *drive, struct request *rq, unsigned long block)
617 {
618 #if IDESCSI_DEBUG_LOG
619 printk(KERN_INFO "rq_status: %d, rq_dev: %u, cmd: %d, errors: %d\n",
620 rq->rq_status, (unsigned int) rq->rq_dev, rq->cmd, rq->errors);
621 printk(KERN_INFO "sector: %ld, nr_sectors: %ld, "
622 "current_nr_sectors: %ld\n", rq->sector,
623 rq->nr_sectors, rq->current_nr_sectors);
624 #endif /* IDESCSI_DEBUG_LOG */
625
626 if (rq->cmd == IDESCSI_PC_RQ) {
627 return idescsi_issue_pc(drive, rq->special);
628 }
629 printk(KERN_ERR "ide-scsi: %s: unsupported command in request "
630 "queue (%x)\n", drive->name, rq->cmd);
631 idescsi_end_request(drive, 0);
632 return ide_stopped;
633 }
634
idescsi_do_ioctl(ide_drive_t * drive,struct inode * inode,struct file * file,unsigned int cmd,unsigned long arg)635 static int idescsi_do_ioctl (ide_drive_t *drive, struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
636 {
637 /* need to figure out how to parse scsi-atapi media type */
638
639 return -EINVAL;
640 }
641
idescsi_ide_open(struct inode * inode,struct file * filp,ide_drive_t * drive)642 static int idescsi_ide_open (struct inode *inode, struct file *filp, ide_drive_t *drive)
643 {
644 MOD_INC_USE_COUNT;
645 return 0;
646 }
647
idescsi_ide_release(struct inode * inode,struct file * filp,ide_drive_t * drive)648 static void idescsi_ide_release (struct inode *inode, struct file *filp, ide_drive_t *drive)
649 {
650 MOD_DEC_USE_COUNT;
651 }
652
653 static ide_drive_t *idescsi_drives[MAX_HWIFS * MAX_DRIVES];
654 static int idescsi_initialized = 0;
655 static int drive_count = 0;
656
idescsi_add_settings(ide_drive_t * drive)657 static void idescsi_add_settings(ide_drive_t *drive)
658 {
659 idescsi_scsi_t *scsi = drive->driver_data;
660
661 /*
662 * drive setting name read/write ioctl ioctl data type min max mul_factor div_factor data pointer set function
663 */
664 ide_add_setting(drive, "bios_cyl", SETTING_RW, -1, -1, TYPE_INT, 0, 1023, 1, 1, &drive->bios_cyl, NULL);
665 ide_add_setting(drive, "bios_head", SETTING_RW, -1, -1, TYPE_BYTE, 0, 255, 1, 1, &drive->bios_head, NULL);
666 ide_add_setting(drive, "bios_sect", SETTING_RW, -1, -1, TYPE_BYTE, 0, 63, 1, 1, &drive->bios_sect, NULL);
667 ide_add_setting(drive, "transform", SETTING_RW, -1, -1, TYPE_INT, 0, 3, 1, 1, &scsi->transform, NULL);
668 ide_add_setting(drive, "log", SETTING_RW, -1, -1, TYPE_INT, 0, 1, 1, 1, &scsi->log, NULL);
669 }
670
671 /*
672 * Driver initialization.
673 */
idescsi_setup(ide_drive_t * drive,idescsi_scsi_t * scsi,int id)674 static void idescsi_setup (ide_drive_t *drive, idescsi_scsi_t *scsi, int id)
675 {
676 int minor = (drive->select.b.unit) << PARTN_BITS;
677
678 DRIVER(drive)->busy++;
679 idescsi_drives[id] = drive;
680 drive->driver_data = scsi;
681 drive->ready_stat = 0;
682 memset(scsi, 0, sizeof(idescsi_scsi_t));
683 scsi->drive = drive;
684 scsi->id = id;
685 if (drive->id && (drive->id->config & 0x0060) == 0x20)
686 set_bit(IDESCSI_DRQ_INTERRUPT, &scsi->flags);
687 set_bit(IDESCSI_TRANSFORM, &scsi->transform);
688 clear_bit(IDESCSI_SG_TRANSFORM, &scsi->transform);
689 #if IDESCSI_DEBUG_LOG
690 set_bit(IDESCSI_LOG_CMD, &scsi->log);
691 #endif /* IDESCSI_DEBUG_LOG */
692 idescsi_add_settings(drive);
693 #ifdef IDESCSI_DEVFS
694 scsi->de = devfs_register(drive->de, "generic", DEVFS_FL_DEFAULT,
695 HWIF(drive)->major, minor,
696 S_IFBLK | S_IRUSR | S_IWUSR,
697 ide_fops, NULL);
698 #endif /* IDESCSI_DEVFS */
699 drive_count++;
700 DRIVER(drive)->busy--;
701 }
702
idescsi_cleanup(ide_drive_t * drive)703 static int idescsi_cleanup (ide_drive_t *drive)
704 {
705 idescsi_scsi_t *scsi = drive->driver_data;
706
707 if (ide_unregister_subdriver(drive)) {
708 printk("%s: %s: failed to unregister! \n",
709 __FUNCTION__, drive->name);
710 printk("%s: usage %d, busy %d, driver %p, Dbusy %d\n",
711 drive->name, drive->usage, drive->busy,
712 drive->driver, DRIVER(drive)->busy);
713 return 1;
714 }
715 idescsi_drives[scsi->id] = NULL;
716 #ifdef IDESCSI_DEVFS
717 if (scsi->de)
718 devfs_unregister(scsi->de);
719 #endif /* IDESCSI_DEVFS */
720 drive->driver_data = NULL;
721 kfree(scsi);
722 drive_count--;
723 return 0;
724 }
725
726 int idescsi_init(void);
727 int idescsi_attach(ide_drive_t *drive);
728
729 /*
730 * IDE subdriver functions, registered with ide.c
731 */
732 static ide_driver_t idescsi_driver = {
733 name: "ide-scsi",
734 version: IDESCSI_VERSION,
735 media: ide_scsi,
736 busy: 0,
737 #ifdef CONFIG_IDEDMA_ONLYDISK
738 supports_dma: 0,
739 #else
740 supports_dma: 1,
741 #endif
742 supports_dsc_overlap: 0,
743 cleanup: idescsi_cleanup,
744 standby: NULL,
745 suspend: NULL,
746 resume: NULL,
747 flushcache: NULL,
748 do_request: idescsi_do_request,
749 end_request: idescsi_end_request,
750 sense: NULL,
751 error: NULL,
752 ioctl: idescsi_do_ioctl,
753 open: idescsi_ide_open,
754 release: idescsi_ide_release,
755 media_change: NULL,
756 revalidate: NULL,
757 pre_reset: NULL,
758 capacity: NULL,
759 special: NULL,
760 proc: NULL,
761 init: idescsi_init,
762 attach: idescsi_attach,
763 ata_prebuilder: NULL,
764 atapi_prebuilder: NULL,
765 };
766
767 static ide_module_t idescsi_module = {
768 IDE_DRIVER_MODULE,
769 idescsi_init,
770 &idescsi_driver,
771 NULL
772 };
773
idescsi_attach(ide_drive_t * drive)774 int idescsi_attach (ide_drive_t *drive)
775 {
776 idescsi_scsi_t *scsi;
777 u8 media[] = { TYPE_DISK, /* 0x00 */
778 TYPE_TAPE, /* 0x01 */
779 TYPE_PRINTER, /* 0x02 */
780 TYPE_PROCESSOR, /* 0x03 */
781 TYPE_WORM, /* 0x04 */
782 TYPE_ROM, /* 0x05 */
783 TYPE_SCANNER, /* 0x06 */
784 TYPE_MOD, /* 0x07 */
785 255};
786 int i = 0, ret = 0, id = 0;
787 // int id = 2 * HWIF(drive)->index + drive->select.b.unit;
788 // int id = drive_count + 1;
789
790 for (id = 0; id < MAX_HWIFS*MAX_DRIVES; id++)
791 if (idescsi_drives[id] == NULL)
792 break;
793
794 printk("%s: id = %d\n", drive->name, id);
795
796 if ((!idescsi_initialized) || (drive->media == ide_disk)) {
797 printk(KERN_ERR "ide-scsi: (%sinitialized) %s: "
798 "media-type (%ssupported)\n",
799 (idescsi_initialized) ? "" : "! ",
800 drive->name,
801 (drive->media == ide_disk) ? "! " : "");
802 return (drive->media == ide_disk) ? 2 : 0;
803 }
804
805 MOD_INC_USE_COUNT;
806
807 for (i = 0; media[i] != 255; i++) {
808 if (drive->media != media[i])
809 continue;
810 else
811 break;
812 }
813
814 if ((scsi = (idescsi_scsi_t *) kmalloc(sizeof(idescsi_scsi_t), GFP_KERNEL)) == NULL) {
815 printk(KERN_ERR "ide-scsi: %s: Can't allocate a scsi "
816 "structure\n", drive->name);
817 ret = 1;
818 goto bye_game_over;
819 }
820 if (ide_register_subdriver(drive, &idescsi_driver,
821 IDE_SUBDRIVER_VERSION)) {
822 printk(KERN_ERR "ide-scsi: %s: Failed to register the "
823 "driver with ide.c\n", drive->name);
824 kfree(scsi);
825 ret = 1;
826 goto bye_game_over;
827 }
828
829 idescsi_setup(drive, scsi, id);
830
831 // scan_scsis(HBA, 1, channel, id, lun);
832 bye_game_over:
833 MOD_DEC_USE_COUNT;
834 return ret;
835 }
836
837 #ifdef MODULE
838 /* options */
839 char *ignore = NULL;
840
841 MODULE_PARM(ignore, "s");
842 #endif
843
idescsi_init(void)844 int idescsi_init (void)
845 {
846 #ifdef CLASSIC_BUILTINS_METHOD
847 ide_drive_t *drive;
848 idescsi_scsi_t *scsi;
849 u8 media[] = { TYPE_DISK, /* 0x00 */
850 TYPE_TAPE, /* 0x01 */
851 TYPE_PRINTER, /* 0x02 */
852 TYPE_PROCESSOR, /* 0x03 */
853 TYPE_WORM, /* 0x04 */
854 TYPE_ROM, /* 0x05 */
855 TYPE_SCANNER, /* 0x06 */
856 TYPE_MOD, /* 0x07 */
857 255};
858
859 int i, failed, id;
860
861 if (idescsi_initialized)
862 return 0;
863 idescsi_initialized = 1;
864 for (i = 0; i < MAX_HWIFS * MAX_DRIVES; i++)
865 idescsi_drives[i] = NULL;
866 MOD_INC_USE_COUNT;
867 for (i = 0; media[i] != 255; i++) {
868 failed = 0;
869 while ((drive = ide_scan_devices(media[i],
870 idescsi_driver.name, NULL, failed++)) != NULL) {
871 #ifdef MODULE
872 /* skip drives we were told to ignore */
873 if (ignore != NULL && strstr(ignore, drive->name)) {
874 printk("ide-scsi: ignoring drive %s\n",
875 drive->name);
876 continue;
877 }
878 #endif
879
880 if ((scsi = (idescsi_scsi_t *) kmalloc(sizeof(idescsi_scsi_t), GFP_KERNEL)) == NULL) {
881 printk(KERN_ERR "ide-scsi: %s: Can't allocate "
882 "a scsi structure\n", drive->name);
883 continue;
884 }
885 if (ide_register_subdriver(drive, &idescsi_driver,
886 IDE_SUBDRIVER_VERSION)) {
887 printk(KERN_ERR "ide-scsi: %s: Failed to "
888 "register the driver with ide.c\n",
889 drive->name);
890 kfree(scsi);
891 continue;
892 }
893 for (id = 0;
894 id < MAX_HWIFS*MAX_DRIVES && idescsi_drives[id];
895 id++);
896 idescsi_setup(drive, scsi, id);
897 failed--;
898 }
899 }
900 #else /* ! CLASSIC_BUILTINS_METHOD */
901 int i;
902
903 if (idescsi_initialized)
904 return 0;
905 idescsi_initialized = 1;
906 for (i = 0; i < MAX_HWIFS * MAX_DRIVES; i++)
907 idescsi_drives[i] = NULL;
908 MOD_INC_USE_COUNT;
909 #endif /* CLASSIC_BUILTINS_METHOD */
910 ide_register_module(&idescsi_module);
911 MOD_DEC_USE_COUNT;
912 return 0;
913 }
914
idescsi_detect(Scsi_Host_Template * host_template)915 int idescsi_detect (Scsi_Host_Template *host_template)
916 {
917 struct Scsi_Host *host;
918 int id;
919 int last_lun = 0;
920
921 host_template->proc_name = "ide-scsi";
922 host = scsi_register(host_template, 0);
923 if (host == NULL) {
924 printk(KERN_WARNING "%s: host failure!\n", __FUNCTION__);
925 return 0;
926 }
927
928 for (id = 0; id < MAX_HWIFS * MAX_DRIVES && idescsi_drives[id]; id++)
929 last_lun = IDE_MAX(last_lun, idescsi_drives[id]->last_lun);
930 host->max_id = id;
931 host->max_lun = last_lun + 1;
932 host->can_queue = host->cmd_per_lun * id;
933 return 1;
934 }
935
idescsi_release(struct Scsi_Host * host)936 int idescsi_release (struct Scsi_Host *host)
937 {
938 ide_drive_t *drive;
939 int id;
940
941 for (id = 0; id < MAX_HWIFS * MAX_DRIVES; id++) {
942 drive = idescsi_drives[id];
943 if (drive)
944 DRIVER(drive)->busy = 0;
945 }
946 return 0;
947 }
948
idescsi_info(struct Scsi_Host * host)949 const char *idescsi_info (struct Scsi_Host *host)
950 {
951 return "SCSI host adapter emulation for IDE ATAPI devices";
952 }
953
idescsi_ioctl(Scsi_Device * dev,int cmd,void * arg)954 int idescsi_ioctl (Scsi_Device *dev, int cmd, void *arg)
955 {
956 ide_drive_t *drive = idescsi_drives[dev->id];
957 idescsi_scsi_t *scsi = drive->driver_data;
958
959 if (cmd == SG_SET_TRANSFORM) {
960 if (arg)
961 set_bit(IDESCSI_SG_TRANSFORM, &scsi->transform);
962 else
963 clear_bit(IDESCSI_SG_TRANSFORM, &scsi->transform);
964 return 0;
965 } else if (cmd == SG_GET_TRANSFORM)
966 return put_user(test_bit(IDESCSI_SG_TRANSFORM, &scsi->transform), (int *) arg);
967 return -EINVAL;
968 }
969
idescsi_kmalloc_bh(int count)970 static inline struct buffer_head *idescsi_kmalloc_bh (int count)
971 {
972 struct buffer_head *bh, *bhp, *first_bh;
973
974 if ((first_bh = bhp = bh = kmalloc(sizeof(struct buffer_head), GFP_ATOMIC)) == NULL)
975 goto abort;
976 memset(bh, 0, sizeof(struct buffer_head));
977 bh->b_reqnext = NULL;
978 while (--count) {
979 if ((bh = kmalloc(sizeof(struct buffer_head), GFP_ATOMIC)) == NULL)
980 goto abort;
981 memset(bh, 0, sizeof(struct buffer_head));
982 bhp->b_reqnext = bh;
983 bhp = bh;
984 bh->b_reqnext = NULL;
985 }
986 return first_bh;
987 abort:
988 idescsi_free_bh(first_bh);
989 return NULL;
990 }
991
idescsi_set_direction(idescsi_pc_t * pc)992 static inline int idescsi_set_direction (idescsi_pc_t *pc)
993 {
994 switch (pc->c[0]) {
995 case READ_6:
996 case READ_10:
997 case READ_12:
998 clear_bit(PC_WRITING, &pc->flags);
999 return 0;
1000 case WRITE_6:
1001 case WRITE_10:
1002 case WRITE_12:
1003 set_bit(PC_WRITING, &pc->flags);
1004 return 0;
1005 default:
1006 return 1;
1007 }
1008 }
1009
idescsi_dma_bh(ide_drive_t * drive,idescsi_pc_t * pc)1010 static inline struct buffer_head *idescsi_dma_bh (ide_drive_t *drive, idescsi_pc_t *pc)
1011 {
1012 struct buffer_head *bh = NULL, *first_bh = NULL;
1013 int segments = pc->scsi_cmd->use_sg;
1014 struct scatterlist *sg = pc->scsi_cmd->request_buffer;
1015
1016 if (!drive->using_dma || !pc->request_transfer || pc->request_transfer & 1023)
1017 return NULL;
1018 if (idescsi_set_direction(pc))
1019 return NULL;
1020 if (segments) {
1021 if ((first_bh = bh = idescsi_kmalloc_bh(segments)) == NULL)
1022 return NULL;
1023 #if IDESCSI_DEBUG_LOG
1024 printk("ide-scsi: %s: building DMA table, %d segments, "
1025 "%dkB total\n", drive->name, segments,
1026 pc->request_transfer >> 10);
1027 #endif /* IDESCSI_DEBUG_LOG */
1028 while (segments--) {
1029 #if 1
1030 bh->b_data = sg->address;
1031 #else
1032 if (sg->address) {
1033 bh->b_page = virt_to_page(sg->address);
1034 bh->b_data = (char *) ((unsigned long) sg->address & ~PAGE_MASK);
1035 } else if (sg->page) {
1036 bh->b_page = sg->page;
1037 bh->b_data = (char *) sg->offset;
1038 }
1039 #endif
1040 bh->b_size = sg->length;
1041 bh = bh->b_reqnext;
1042 sg++;
1043 }
1044 } else {
1045 /*
1046 * non-sg requests are guarenteed not to reside in highmem /jens
1047 */
1048 if ((first_bh = bh = idescsi_kmalloc_bh(1)) == NULL)
1049 return NULL;
1050 #if IDESCSI_DEBUG_LOG
1051 printk("ide-scsi: %s: building DMA table for a single "
1052 "buffer (%dkB)\n", drive->name,
1053 pc->request_transfer >> 10);
1054 #endif /* IDESCSI_DEBUG_LOG */
1055 bh->b_data = pc->scsi_cmd->request_buffer;
1056 bh->b_size = pc->request_transfer;
1057 }
1058 return first_bh;
1059 }
1060
should_transform(ide_drive_t * drive,Scsi_Cmnd * cmd)1061 static inline int should_transform(ide_drive_t *drive, Scsi_Cmnd *cmd)
1062 {
1063 idescsi_scsi_t *scsi = drive->driver_data;
1064
1065 if (MAJOR(cmd->request.rq_dev) == SCSI_GENERIC_MAJOR)
1066 return test_bit(IDESCSI_SG_TRANSFORM, &scsi->transform);
1067 return test_bit(IDESCSI_TRANSFORM, &scsi->transform);
1068 }
1069
idescsi_queue(Scsi_Cmnd * cmd,void (* done)(Scsi_Cmnd *))1070 int idescsi_queue (Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *))
1071 {
1072 ide_drive_t *drive = idescsi_drives[cmd->target];
1073 idescsi_scsi_t *scsi;
1074 struct request *rq = NULL;
1075 idescsi_pc_t *pc = NULL;
1076
1077 if (!drive) {
1078 printk(KERN_ERR "ide-scsi: drive id %d not present\n",
1079 cmd->target);
1080 goto abort;
1081 }
1082 scsi = drive->driver_data;
1083 pc = kmalloc(sizeof(idescsi_pc_t), GFP_ATOMIC);
1084 rq = kmalloc(sizeof(struct request), GFP_ATOMIC);
1085 if (rq == NULL || pc == NULL) {
1086 printk(KERN_ERR "ide-scsi: %s: out of memory\n", drive->name);
1087 goto abort;
1088 }
1089
1090 memset(pc->c, 0, 12);
1091 pc->flags = 0;
1092 pc->rq = rq;
1093 memcpy(pc->c, cmd->cmnd, cmd->cmd_len);
1094 if (cmd->use_sg) {
1095 pc->buffer = NULL;
1096 pc->sg = cmd->request_buffer;
1097 } else {
1098 pc->buffer = cmd->request_buffer;
1099 pc->sg = NULL;
1100 }
1101 pc->b_count = 0;
1102 pc->request_transfer = pc->buffer_size = cmd->request_bufflen;
1103 pc->scsi_cmd = cmd;
1104 pc->done = done;
1105 pc->timeout = jiffies + cmd->timeout_per_command;
1106
1107 if (should_transform(drive, cmd))
1108 set_bit(PC_TRANSFORM, &pc->flags);
1109 idescsi_transform_pc1(drive, pc);
1110
1111 if (test_bit(IDESCSI_LOG_CMD, &scsi->log)) {
1112 printk("ide-scsi: %s: que %lu, cmd = ",
1113 drive->name, cmd->serial_number);
1114 hexdump(cmd->cmnd, cmd->cmd_len);
1115 if (memcmp(pc->c, cmd->cmnd, cmd->cmd_len)) {
1116 printk("ide-scsi: %s: que %lu, tsl = ",
1117 drive->name, cmd->serial_number);
1118 hexdump(pc->c, 12);
1119 }
1120 }
1121
1122 ide_init_drive_cmd(rq);
1123 rq->special = pc;
1124 rq->bh = idescsi_dma_bh(drive, pc);
1125 rq->cmd = IDESCSI_PC_RQ;
1126 spin_unlock_irq(&io_request_lock);
1127 (void) ide_do_drive_cmd(drive, rq, ide_end);
1128 spin_lock_irq(&io_request_lock);
1129 return 0;
1130 abort:
1131 if (pc) kfree(pc);
1132 if (rq) kfree(rq);
1133 cmd->result = DID_ERROR << 16;
1134 done(cmd);
1135 return 0;
1136 }
1137
idescsi_abort(Scsi_Cmnd * cmd)1138 int idescsi_abort (Scsi_Cmnd *cmd)
1139 {
1140 return SCSI_ABORT_SNOOZE;
1141 }
1142
idescsi_reset(Scsi_Cmnd * cmd,unsigned int resetflags)1143 int idescsi_reset (Scsi_Cmnd *cmd, unsigned int resetflags)
1144 {
1145 return SCSI_RESET_SNOOZE;
1146
1147 #ifdef WORK_IN_PROGRESS
1148 ide_drive_t *drive = idescsi_drives[cmd->target];
1149
1150 /* At this point the state machine is running, that
1151 requires we are especially careful. Ideally we want
1152 to abort commands on timeout only if they hit the
1153 cable but thats harder */
1154
1155 DRIVER(drive)->abort(drive, "scsi reset");
1156 if(HWGROUP(drive)->handler)
1157 BUG();
1158
1159 /* Ok the state machine is halted but make sure it
1160 doesn't restart too early */
1161
1162 HWGROUP(drive)->busy = 1;
1163 spin_unlock_irq(&io_request_lock);
1164
1165 /* Apply the mallet of re-education firmly to the drive */
1166 ide_do_reset(drive);
1167
1168 /* At this point the reset state machine is running and
1169 its termination will kick off the next command */
1170 spin_lock_irq(&io_request_lock);
1171 return SCSI_RESET_SUCCESS;
1172 #endif
1173 }
1174
idescsi_bios(Disk * disk,kdev_t dev,int * parm)1175 int idescsi_bios (Disk *disk, kdev_t dev, int *parm)
1176 {
1177 ide_drive_t *drive = idescsi_drives[disk->device->id];
1178
1179 if (drive->bios_cyl && drive->bios_head && drive->bios_sect) {
1180 parm[0] = drive->bios_head;
1181 parm[1] = drive->bios_sect;
1182 parm[2] = drive->bios_cyl;
1183 }
1184 return 0;
1185 }
1186
1187 static Scsi_Host_Template idescsi_template = IDESCSI;
1188
init_idescsi_module(void)1189 static int __init init_idescsi_module(void)
1190 {
1191 drive_count = 0;
1192 idescsi_init();
1193 idescsi_template.module = THIS_MODULE;
1194 scsi_register_module(MODULE_SCSI_HA, &idescsi_template);
1195 return 0;
1196 }
1197
exit_idescsi_module(void)1198 static void __exit exit_idescsi_module(void)
1199 {
1200 ide_drive_t *drive;
1201 u8 media[] = {TYPE_DISK, TYPE_TAPE, TYPE_PROCESSOR, TYPE_WORM, TYPE_ROM, TYPE_SCANNER, TYPE_MOD, 255};
1202 int i, failed;
1203
1204 scsi_unregister_module(MODULE_SCSI_HA, &idescsi_template);
1205 for (i = 0; media[i] != 255; i++) {
1206 failed = 0;
1207 while ((drive = ide_scan_devices(media[i], idescsi_driver.name, &idescsi_driver, failed)) != NULL)
1208 if (idescsi_cleanup(drive)) {
1209 printk("%s: exit_idescsi_module() called while still busy\n", drive->name);
1210 failed++;
1211 }
1212 }
1213 ide_unregister_module(&idescsi_module);
1214 }
1215
1216 module_init(init_idescsi_module);
1217 module_exit(exit_idescsi_module);
1218 MODULE_LICENSE("GPL");
1219