ide-scsi.c 34 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195
  1. /*
  2. * linux/drivers/scsi/ide-scsi.c Version 0.9 Jul 4, 1999
  3. *
  4. * Copyright (C) 1996 - 1999 Gadi Oxman <gadio@netvision.net.il>
  5. */
  6. /*
  7. * Emulation of a SCSI host adapter for IDE ATAPI devices.
  8. *
  9. * With this driver, one can use the Linux SCSI drivers instead of the
  10. * native IDE ATAPI drivers.
  11. *
  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
  31. */
  32. #define IDESCSI_VERSION "0.92"
  33. #include <linux/module.h>
  34. #include <linux/config.h>
  35. #include <linux/types.h>
  36. #include <linux/string.h>
  37. #include <linux/kernel.h>
  38. #include <linux/mm.h>
  39. #include <linux/ioport.h>
  40. #include <linux/blkdev.h>
  41. #include <linux/errno.h>
  42. #include <linux/hdreg.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 <asm/io.h>
  49. #include <asm/bitops.h>
  50. #include <asm/uaccess.h>
  51. #include <scsi/scsi.h>
  52. #include <scsi/scsi_cmnd.h>
  53. #include <scsi/scsi_device.h>
  54. #include <scsi/scsi_host.h>
  55. #include <scsi/scsi_tcq.h>
  56. #include <scsi/sg.h>
  57. #define IDESCSI_DEBUG_LOG 0
  58. typedef struct idescsi_pc_s {
  59. u8 c[12]; /* Actual packet bytes */
  60. int request_transfer; /* Bytes to transfer */
  61. int actually_transferred; /* Bytes actually transferred */
  62. int buffer_size; /* Size of our data buffer */
  63. struct request *rq; /* The corresponding request */
  64. u8 *buffer; /* Data buffer */
  65. u8 *current_position; /* Pointer into the above buffer */
  66. struct scatterlist *sg; /* Scatter gather table */
  67. int b_count; /* Bytes transferred from current entry */
  68. struct scsi_cmnd *scsi_cmd; /* SCSI command */
  69. void (*done)(struct scsi_cmnd *); /* Scsi completion routine */
  70. unsigned long flags; /* Status/Action flags */
  71. unsigned long timeout; /* Command timeout */
  72. } idescsi_pc_t;
  73. /*
  74. * Packet command status bits.
  75. */
  76. #define PC_DMA_IN_PROGRESS 0 /* 1 while DMA in progress */
  77. #define PC_WRITING 1 /* Data direction */
  78. #define PC_TRANSFORM 2 /* transform SCSI commands */
  79. #define PC_TIMEDOUT 3 /* command timed out */
  80. #define PC_DMA_OK 4 /* Use DMA */
  81. /*
  82. * SCSI command transformation layer
  83. */
  84. #define IDESCSI_TRANSFORM 0 /* Enable/Disable transformation */
  85. #define IDESCSI_SG_TRANSFORM 1 /* /dev/sg transformation */
  86. /*
  87. * Log flags
  88. */
  89. #define IDESCSI_LOG_CMD 0 /* Log SCSI commands */
  90. typedef struct ide_scsi_obj {
  91. ide_drive_t *drive;
  92. ide_driver_t *driver;
  93. struct gendisk *disk;
  94. struct Scsi_Host *host;
  95. idescsi_pc_t *pc; /* Current packet command */
  96. unsigned long flags; /* Status/Action flags */
  97. unsigned long transform; /* SCSI cmd translation layer */
  98. unsigned long log; /* log flags */
  99. } idescsi_scsi_t;
  100. static DEFINE_MUTEX(idescsi_ref_mutex);
  101. #define ide_scsi_g(disk) \
  102. container_of((disk)->private_data, struct ide_scsi_obj, driver)
  103. static struct ide_scsi_obj *ide_scsi_get(struct gendisk *disk)
  104. {
  105. struct ide_scsi_obj *scsi = NULL;
  106. mutex_lock(&idescsi_ref_mutex);
  107. scsi = ide_scsi_g(disk);
  108. if (scsi)
  109. scsi_host_get(scsi->host);
  110. mutex_unlock(&idescsi_ref_mutex);
  111. return scsi;
  112. }
  113. static void ide_scsi_put(struct ide_scsi_obj *scsi)
  114. {
  115. mutex_lock(&idescsi_ref_mutex);
  116. scsi_host_put(scsi->host);
  117. mutex_unlock(&idescsi_ref_mutex);
  118. }
  119. static inline idescsi_scsi_t *scsihost_to_idescsi(struct Scsi_Host *host)
  120. {
  121. return (idescsi_scsi_t*) (&host[1]);
  122. }
  123. static inline idescsi_scsi_t *drive_to_idescsi(ide_drive_t *ide_drive)
  124. {
  125. return scsihost_to_idescsi(ide_drive->driver_data);
  126. }
  127. /*
  128. * Per ATAPI device status bits.
  129. */
  130. #define IDESCSI_DRQ_INTERRUPT 0 /* DRQ interrupt device */
  131. /*
  132. * ide-scsi requests.
  133. */
  134. #define IDESCSI_PC_RQ 90
  135. static void idescsi_discard_data (ide_drive_t *drive, unsigned int bcount)
  136. {
  137. while (bcount--)
  138. (void) HWIF(drive)->INB(IDE_DATA_REG);
  139. }
  140. static void idescsi_output_zeros (ide_drive_t *drive, unsigned int bcount)
  141. {
  142. while (bcount--)
  143. HWIF(drive)->OUTB(0, IDE_DATA_REG);
  144. }
  145. /*
  146. * PIO data transfer routines using the scatter gather table.
  147. */
  148. static void idescsi_input_buffers (ide_drive_t *drive, idescsi_pc_t *pc, unsigned int bcount)
  149. {
  150. int count;
  151. char *buf;
  152. while (bcount) {
  153. if (pc->sg - (struct scatterlist *) pc->scsi_cmd->request_buffer > pc->scsi_cmd->use_sg) {
  154. printk (KERN_ERR "ide-scsi: scatter gather table too small, discarding data\n");
  155. idescsi_discard_data (drive, bcount);
  156. return;
  157. }
  158. count = min(pc->sg->length - pc->b_count, bcount);
  159. if (PageHighMem(pc->sg->page)) {
  160. unsigned long flags;
  161. local_irq_save(flags);
  162. buf = kmap_atomic(pc->sg->page, KM_IRQ0) +
  163. pc->sg->offset;
  164. drive->hwif->atapi_input_bytes(drive,
  165. buf + pc->b_count, count);
  166. kunmap_atomic(buf - pc->sg->offset, KM_IRQ0);
  167. local_irq_restore(flags);
  168. } else {
  169. buf = page_address(pc->sg->page) + pc->sg->offset;
  170. drive->hwif->atapi_input_bytes(drive,
  171. buf + pc->b_count, count);
  172. }
  173. bcount -= count; pc->b_count += count;
  174. if (pc->b_count == pc->sg->length) {
  175. pc->sg++;
  176. pc->b_count = 0;
  177. }
  178. }
  179. }
  180. static void idescsi_output_buffers (ide_drive_t *drive, idescsi_pc_t *pc, unsigned int bcount)
  181. {
  182. int count;
  183. char *buf;
  184. while (bcount) {
  185. if (pc->sg - (struct scatterlist *) pc->scsi_cmd->request_buffer > pc->scsi_cmd->use_sg) {
  186. printk (KERN_ERR "ide-scsi: scatter gather table too small, padding with zeros\n");
  187. idescsi_output_zeros (drive, bcount);
  188. return;
  189. }
  190. count = min(pc->sg->length - pc->b_count, bcount);
  191. if (PageHighMem(pc->sg->page)) {
  192. unsigned long flags;
  193. local_irq_save(flags);
  194. buf = kmap_atomic(pc->sg->page, KM_IRQ0) +
  195. pc->sg->offset;
  196. drive->hwif->atapi_output_bytes(drive,
  197. buf + pc->b_count, count);
  198. kunmap_atomic(buf - pc->sg->offset, KM_IRQ0);
  199. local_irq_restore(flags);
  200. } else {
  201. buf = page_address(pc->sg->page) + pc->sg->offset;
  202. drive->hwif->atapi_output_bytes(drive,
  203. buf + pc->b_count, count);
  204. }
  205. bcount -= count; pc->b_count += count;
  206. if (pc->b_count == pc->sg->length) {
  207. pc->sg++;
  208. pc->b_count = 0;
  209. }
  210. }
  211. }
  212. /*
  213. * Most of the SCSI commands are supported directly by ATAPI devices.
  214. * idescsi_transform_pc handles the few exceptions.
  215. */
  216. static inline void idescsi_transform_pc1 (ide_drive_t *drive, idescsi_pc_t *pc)
  217. {
  218. u8 *c = pc->c, *scsi_buf = pc->buffer, *sc = pc->scsi_cmd->cmnd;
  219. char *atapi_buf;
  220. if (!test_bit(PC_TRANSFORM, &pc->flags))
  221. return;
  222. if (drive->media == ide_cdrom || drive->media == ide_optical) {
  223. if (c[0] == READ_6 || c[0] == WRITE_6) {
  224. c[8] = c[4]; c[5] = c[3]; c[4] = c[2];
  225. c[3] = c[1] & 0x1f; c[2] = 0; c[1] &= 0xe0;
  226. c[0] += (READ_10 - READ_6);
  227. }
  228. if (c[0] == MODE_SENSE || c[0] == MODE_SELECT) {
  229. unsigned short new_len;
  230. if (!scsi_buf)
  231. return;
  232. if ((atapi_buf = kmalloc(pc->buffer_size + 4, GFP_ATOMIC)) == NULL)
  233. return;
  234. memset(atapi_buf, 0, pc->buffer_size + 4);
  235. memset (c, 0, 12);
  236. c[0] = sc[0] | 0x40;
  237. c[1] = sc[1];
  238. c[2] = sc[2];
  239. new_len = sc[4] + 4;
  240. c[8] = new_len;
  241. c[7] = new_len >> 8;
  242. c[9] = sc[5];
  243. if (c[0] == MODE_SELECT_10) {
  244. atapi_buf[1] = scsi_buf[0]; /* Mode data length */
  245. atapi_buf[2] = scsi_buf[1]; /* Medium type */
  246. atapi_buf[3] = scsi_buf[2]; /* Device specific parameter */
  247. atapi_buf[7] = scsi_buf[3]; /* Block descriptor length */
  248. memcpy(atapi_buf + 8, scsi_buf + 4, pc->buffer_size - 4);
  249. }
  250. pc->buffer = atapi_buf;
  251. pc->request_transfer += 4;
  252. pc->buffer_size += 4;
  253. }
  254. }
  255. }
  256. static inline void idescsi_transform_pc2 (ide_drive_t *drive, idescsi_pc_t *pc)
  257. {
  258. u8 *atapi_buf = pc->buffer;
  259. u8 *sc = pc->scsi_cmd->cmnd;
  260. u8 *scsi_buf = pc->scsi_cmd->request_buffer;
  261. if (!test_bit(PC_TRANSFORM, &pc->flags))
  262. return;
  263. if (drive->media == ide_cdrom || drive->media == ide_optical) {
  264. if (pc->c[0] == MODE_SENSE_10 && sc[0] == MODE_SENSE) {
  265. scsi_buf[0] = atapi_buf[1]; /* Mode data length */
  266. scsi_buf[1] = atapi_buf[2]; /* Medium type */
  267. scsi_buf[2] = atapi_buf[3]; /* Device specific parameter */
  268. scsi_buf[3] = atapi_buf[7]; /* Block descriptor length */
  269. memcpy(scsi_buf + 4, atapi_buf + 8, pc->request_transfer - 8);
  270. }
  271. if (pc->c[0] == INQUIRY) {
  272. scsi_buf[2] |= 2; /* ansi_revision */
  273. scsi_buf[3] = (scsi_buf[3] & 0xf0) | 2; /* response data format */
  274. }
  275. }
  276. if (atapi_buf && atapi_buf != scsi_buf)
  277. kfree(atapi_buf);
  278. }
  279. static void hexdump(u8 *x, int len)
  280. {
  281. int i;
  282. printk("[ ");
  283. for (i = 0; i < len; i++)
  284. printk("%x ", x[i]);
  285. printk("]\n");
  286. }
  287. static int idescsi_check_condition(ide_drive_t *drive, struct request *failed_command)
  288. {
  289. idescsi_scsi_t *scsi = drive_to_idescsi(drive);
  290. idescsi_pc_t *pc;
  291. struct request *rq;
  292. u8 *buf;
  293. /* stuff a sense request in front of our current request */
  294. pc = kmalloc (sizeof (idescsi_pc_t), GFP_ATOMIC);
  295. rq = kmalloc (sizeof (struct request), GFP_ATOMIC);
  296. buf = kmalloc(SCSI_SENSE_BUFFERSIZE, GFP_ATOMIC);
  297. if (pc == NULL || rq == NULL || buf == NULL) {
  298. kfree(buf);
  299. kfree(rq);
  300. kfree(pc);
  301. return -ENOMEM;
  302. }
  303. memset (pc, 0, sizeof (idescsi_pc_t));
  304. memset (buf, 0, SCSI_SENSE_BUFFERSIZE);
  305. ide_init_drive_cmd(rq);
  306. rq->special = (char *) pc;
  307. pc->rq = rq;
  308. pc->buffer = buf;
  309. pc->c[0] = REQUEST_SENSE;
  310. pc->c[4] = pc->request_transfer = pc->buffer_size = SCSI_SENSE_BUFFERSIZE;
  311. rq->flags = REQ_SENSE;
  312. pc->timeout = jiffies + WAIT_READY;
  313. /* NOTE! Save the failed packet command in "rq->buffer" */
  314. rq->buffer = (void *) failed_command->special;
  315. pc->scsi_cmd = ((idescsi_pc_t *) failed_command->special)->scsi_cmd;
  316. if (test_bit(IDESCSI_LOG_CMD, &scsi->log)) {
  317. printk ("ide-scsi: %s: queue cmd = ", drive->name);
  318. hexdump(pc->c, 6);
  319. }
  320. rq->rq_disk = scsi->disk;
  321. return ide_do_drive_cmd(drive, rq, ide_preempt);
  322. }
  323. static int idescsi_end_request(ide_drive_t *, int, int);
  324. static ide_startstop_t
  325. idescsi_atapi_error(ide_drive_t *drive, struct request *rq, u8 stat, u8 err)
  326. {
  327. if (HWIF(drive)->INB(IDE_STATUS_REG) & (BUSY_STAT|DRQ_STAT))
  328. /* force an abort */
  329. HWIF(drive)->OUTB(WIN_IDLEIMMEDIATE,IDE_COMMAND_REG);
  330. rq->errors++;
  331. idescsi_end_request(drive, 0, 0);
  332. return ide_stopped;
  333. }
  334. static ide_startstop_t
  335. idescsi_atapi_abort(ide_drive_t *drive, struct request *rq)
  336. {
  337. #if IDESCSI_DEBUG_LOG
  338. printk(KERN_WARNING "idescsi_atapi_abort called for %lu\n",
  339. ((idescsi_pc_t *) rq->special)->scsi_cmd->serial_number);
  340. #endif
  341. rq->errors |= ERROR_MAX;
  342. idescsi_end_request(drive, 0, 0);
  343. return ide_stopped;
  344. }
  345. static int idescsi_end_request (ide_drive_t *drive, int uptodate, int nrsecs)
  346. {
  347. idescsi_scsi_t *scsi = drive_to_idescsi(drive);
  348. struct request *rq = HWGROUP(drive)->rq;
  349. idescsi_pc_t *pc = (idescsi_pc_t *) rq->special;
  350. int log = test_bit(IDESCSI_LOG_CMD, &scsi->log);
  351. struct Scsi_Host *host;
  352. u8 *scsi_buf;
  353. int errors = rq->errors;
  354. unsigned long flags;
  355. if (!(rq->flags & (REQ_SPECIAL|REQ_SENSE))) {
  356. ide_end_request(drive, uptodate, nrsecs);
  357. return 0;
  358. }
  359. ide_end_drive_cmd (drive, 0, 0);
  360. if (rq->flags & REQ_SENSE) {
  361. idescsi_pc_t *opc = (idescsi_pc_t *) rq->buffer;
  362. if (log) {
  363. printk ("ide-scsi: %s: wrap up check %lu, rst = ", drive->name, opc->scsi_cmd->serial_number);
  364. hexdump(pc->buffer,16);
  365. }
  366. memcpy((void *) opc->scsi_cmd->sense_buffer, pc->buffer, SCSI_SENSE_BUFFERSIZE);
  367. kfree(pc->buffer);
  368. kfree(pc);
  369. kfree(rq);
  370. pc = opc;
  371. rq = pc->rq;
  372. pc->scsi_cmd->result = (CHECK_CONDITION << 1) |
  373. ((test_bit(PC_TIMEDOUT, &pc->flags)?DID_TIME_OUT:DID_OK) << 16);
  374. } else if (test_bit(PC_TIMEDOUT, &pc->flags)) {
  375. if (log)
  376. printk (KERN_WARNING "ide-scsi: %s: timed out for %lu\n",
  377. drive->name, pc->scsi_cmd->serial_number);
  378. pc->scsi_cmd->result = DID_TIME_OUT << 16;
  379. } else if (errors >= ERROR_MAX) {
  380. pc->scsi_cmd->result = DID_ERROR << 16;
  381. if (log)
  382. printk ("ide-scsi: %s: I/O error for %lu\n", drive->name, pc->scsi_cmd->serial_number);
  383. } else if (errors) {
  384. if (log)
  385. printk ("ide-scsi: %s: check condition for %lu\n", drive->name, pc->scsi_cmd->serial_number);
  386. if (!idescsi_check_condition(drive, rq))
  387. /* we started a request sense, so we'll be back, exit for now */
  388. return 0;
  389. pc->scsi_cmd->result = (CHECK_CONDITION << 1) | (DID_OK << 16);
  390. } else {
  391. pc->scsi_cmd->result = DID_OK << 16;
  392. idescsi_transform_pc2 (drive, pc);
  393. if (log) {
  394. printk ("ide-scsi: %s: suc %lu", drive->name, pc->scsi_cmd->serial_number);
  395. if (!test_bit(PC_WRITING, &pc->flags) && pc->actually_transferred && pc->actually_transferred <= 1024 && pc->buffer) {
  396. printk(", rst = ");
  397. scsi_buf = pc->scsi_cmd->request_buffer;
  398. hexdump(scsi_buf, min_t(unsigned, 16, pc->scsi_cmd->request_bufflen));
  399. } else printk("\n");
  400. }
  401. }
  402. host = pc->scsi_cmd->device->host;
  403. spin_lock_irqsave(host->host_lock, flags);
  404. pc->done(pc->scsi_cmd);
  405. spin_unlock_irqrestore(host->host_lock, flags);
  406. kfree(pc);
  407. kfree(rq);
  408. scsi->pc = NULL;
  409. return 0;
  410. }
  411. static inline unsigned long get_timeout(idescsi_pc_t *pc)
  412. {
  413. return max_t(unsigned long, WAIT_CMD, pc->timeout - jiffies);
  414. }
  415. static int idescsi_expiry(ide_drive_t *drive)
  416. {
  417. idescsi_scsi_t *scsi = drive->driver_data;
  418. idescsi_pc_t *pc = scsi->pc;
  419. #if IDESCSI_DEBUG_LOG
  420. printk(KERN_WARNING "idescsi_expiry called for %lu at %lu\n", pc->scsi_cmd->serial_number, jiffies);
  421. #endif
  422. set_bit(PC_TIMEDOUT, &pc->flags);
  423. return 0; /* we do not want the ide subsystem to retry */
  424. }
  425. /*
  426. * Our interrupt handler.
  427. */
  428. static ide_startstop_t idescsi_pc_intr (ide_drive_t *drive)
  429. {
  430. idescsi_scsi_t *scsi = drive_to_idescsi(drive);
  431. idescsi_pc_t *pc=scsi->pc;
  432. struct request *rq = pc->rq;
  433. atapi_bcount_t bcount;
  434. atapi_status_t status;
  435. atapi_ireason_t ireason;
  436. atapi_feature_t feature;
  437. unsigned int temp;
  438. #if IDESCSI_DEBUG_LOG
  439. printk (KERN_INFO "ide-scsi: Reached idescsi_pc_intr interrupt handler\n");
  440. #endif /* IDESCSI_DEBUG_LOG */
  441. if (test_bit(PC_TIMEDOUT, &pc->flags)){
  442. #if IDESCSI_DEBUG_LOG
  443. printk(KERN_WARNING "idescsi_pc_intr: got timed out packet %lu at %lu\n",
  444. pc->scsi_cmd->serial_number, jiffies);
  445. #endif
  446. /* end this request now - scsi should retry it*/
  447. idescsi_end_request (drive, 1, 0);
  448. return ide_stopped;
  449. }
  450. if (test_and_clear_bit (PC_DMA_IN_PROGRESS, &pc->flags)) {
  451. #if IDESCSI_DEBUG_LOG
  452. printk ("ide-scsi: %s: DMA complete\n", drive->name);
  453. #endif /* IDESCSI_DEBUG_LOG */
  454. pc->actually_transferred=pc->request_transfer;
  455. (void) HWIF(drive)->ide_dma_end(drive);
  456. }
  457. feature.all = 0;
  458. /* Clear the interrupt */
  459. status.all = HWIF(drive)->INB(IDE_STATUS_REG);
  460. if (!status.b.drq) {
  461. /* No more interrupts */
  462. if (test_bit(IDESCSI_LOG_CMD, &scsi->log))
  463. printk (KERN_INFO "Packet command completed, %d bytes transferred\n", pc->actually_transferred);
  464. local_irq_enable();
  465. if (status.b.check)
  466. rq->errors++;
  467. idescsi_end_request (drive, 1, 0);
  468. return ide_stopped;
  469. }
  470. bcount.b.low = HWIF(drive)->INB(IDE_BCOUNTL_REG);
  471. bcount.b.high = HWIF(drive)->INB(IDE_BCOUNTH_REG);
  472. ireason.all = HWIF(drive)->INB(IDE_IREASON_REG);
  473. if (ireason.b.cod) {
  474. printk(KERN_ERR "ide-scsi: CoD != 0 in idescsi_pc_intr\n");
  475. return ide_do_reset (drive);
  476. }
  477. if (ireason.b.io) {
  478. temp = pc->actually_transferred + bcount.all;
  479. if (temp > pc->request_transfer) {
  480. if (temp > pc->buffer_size) {
  481. printk(KERN_ERR "ide-scsi: The scsi wants to "
  482. "send us more data than expected "
  483. "- discarding data\n");
  484. temp = pc->buffer_size - pc->actually_transferred;
  485. if (temp) {
  486. clear_bit(PC_WRITING, &pc->flags);
  487. if (pc->sg)
  488. idescsi_input_buffers(drive, pc, temp);
  489. else
  490. drive->hwif->atapi_input_bytes(drive, pc->current_position, temp);
  491. printk(KERN_ERR "ide-scsi: transferred %d of %d bytes\n", temp, bcount.all);
  492. }
  493. pc->actually_transferred += temp;
  494. pc->current_position += temp;
  495. idescsi_discard_data(drive, bcount.all - temp);
  496. ide_set_handler(drive, &idescsi_pc_intr, get_timeout(pc), idescsi_expiry);
  497. return ide_started;
  498. }
  499. #if IDESCSI_DEBUG_LOG
  500. printk (KERN_NOTICE "ide-scsi: The scsi wants to send us more data than expected - allowing transfer\n");
  501. #endif /* IDESCSI_DEBUG_LOG */
  502. }
  503. }
  504. if (ireason.b.io) {
  505. clear_bit(PC_WRITING, &pc->flags);
  506. if (pc->sg)
  507. idescsi_input_buffers(drive, pc, bcount.all);
  508. else
  509. HWIF(drive)->atapi_input_bytes(drive, pc->current_position, bcount.all);
  510. } else {
  511. set_bit(PC_WRITING, &pc->flags);
  512. if (pc->sg)
  513. idescsi_output_buffers (drive, pc, bcount.all);
  514. else
  515. HWIF(drive)->atapi_output_bytes(drive, pc->current_position, bcount.all);
  516. }
  517. /* Update the current position */
  518. pc->actually_transferred += bcount.all;
  519. pc->current_position += bcount.all;
  520. /* And set the interrupt handler again */
  521. ide_set_handler(drive, &idescsi_pc_intr, get_timeout(pc), idescsi_expiry);
  522. return ide_started;
  523. }
  524. static ide_startstop_t idescsi_transfer_pc(ide_drive_t *drive)
  525. {
  526. ide_hwif_t *hwif = drive->hwif;
  527. idescsi_scsi_t *scsi = drive_to_idescsi(drive);
  528. idescsi_pc_t *pc = scsi->pc;
  529. atapi_ireason_t ireason;
  530. ide_startstop_t startstop;
  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. ireason.all = HWIF(drive)->INB(IDE_IREASON_REG);
  537. if (!ireason.b.cod || ireason.b.io) {
  538. printk(KERN_ERR "ide-scsi: (IO,CoD) != (0,1) while "
  539. "issuing a packet command\n");
  540. return ide_do_reset (drive);
  541. }
  542. if (HWGROUP(drive)->handler != NULL)
  543. BUG();
  544. /* Set the interrupt routine */
  545. ide_set_handler(drive, &idescsi_pc_intr, get_timeout(pc), idescsi_expiry);
  546. /* Send the actual packet */
  547. drive->hwif->atapi_output_bytes(drive, scsi->pc->c, 12);
  548. if (test_bit (PC_DMA_OK, &pc->flags)) {
  549. set_bit (PC_DMA_IN_PROGRESS, &pc->flags);
  550. hwif->dma_start(drive);
  551. }
  552. return ide_started;
  553. }
  554. static inline int idescsi_set_direction(idescsi_pc_t *pc)
  555. {
  556. switch (pc->c[0]) {
  557. case READ_6: case READ_10: case READ_12:
  558. clear_bit(PC_WRITING, &pc->flags);
  559. return 0;
  560. case WRITE_6: case WRITE_10: case WRITE_12:
  561. set_bit(PC_WRITING, &pc->flags);
  562. return 0;
  563. default:
  564. return 1;
  565. }
  566. }
  567. static int idescsi_map_sg(ide_drive_t *drive, idescsi_pc_t *pc)
  568. {
  569. ide_hwif_t *hwif = drive->hwif;
  570. struct scatterlist *sg, *scsi_sg;
  571. int segments;
  572. if (!pc->request_transfer || pc->request_transfer % 1024)
  573. return 1;
  574. if (idescsi_set_direction(pc))
  575. return 1;
  576. sg = hwif->sg_table;
  577. scsi_sg = pc->scsi_cmd->request_buffer;
  578. segments = pc->scsi_cmd->use_sg;
  579. if (segments > hwif->sg_max_nents)
  580. return 1;
  581. if (!segments) {
  582. hwif->sg_nents = 1;
  583. sg_init_one(sg, pc->scsi_cmd->request_buffer, pc->request_transfer);
  584. } else {
  585. hwif->sg_nents = segments;
  586. memcpy(sg, scsi_sg, sizeof(*sg) * segments);
  587. }
  588. return 0;
  589. }
  590. /*
  591. * Issue a packet command
  592. */
  593. static ide_startstop_t idescsi_issue_pc (ide_drive_t *drive, idescsi_pc_t *pc)
  594. {
  595. idescsi_scsi_t *scsi = drive_to_idescsi(drive);
  596. ide_hwif_t *hwif = drive->hwif;
  597. atapi_feature_t feature;
  598. atapi_bcount_t bcount;
  599. scsi->pc=pc; /* Set the current packet command */
  600. pc->actually_transferred=0; /* We haven't transferred any data yet */
  601. pc->current_position=pc->buffer;
  602. bcount.all = min(pc->request_transfer, 63 * 1024); /* Request to transfer the entire buffer at once */
  603. feature.all = 0;
  604. if (drive->using_dma && !idescsi_map_sg(drive, pc)) {
  605. hwif->sg_mapped = 1;
  606. feature.b.dma = !hwif->dma_setup(drive);
  607. hwif->sg_mapped = 0;
  608. }
  609. SELECT_DRIVE(drive);
  610. if (IDE_CONTROL_REG)
  611. HWIF(drive)->OUTB(drive->ctl, IDE_CONTROL_REG);
  612. HWIF(drive)->OUTB(feature.all, IDE_FEATURE_REG);
  613. HWIF(drive)->OUTB(bcount.b.high, IDE_BCOUNTH_REG);
  614. HWIF(drive)->OUTB(bcount.b.low, IDE_BCOUNTL_REG);
  615. if (feature.b.dma)
  616. set_bit(PC_DMA_OK, &pc->flags);
  617. if (test_bit(IDESCSI_DRQ_INTERRUPT, &scsi->flags)) {
  618. if (HWGROUP(drive)->handler != NULL)
  619. BUG();
  620. ide_set_handler(drive, &idescsi_transfer_pc,
  621. get_timeout(pc), idescsi_expiry);
  622. /* Issue the packet command */
  623. HWIF(drive)->OUTB(WIN_PACKETCMD, IDE_COMMAND_REG);
  624. return ide_started;
  625. } else {
  626. /* Issue the packet command */
  627. HWIF(drive)->OUTB(WIN_PACKETCMD, IDE_COMMAND_REG);
  628. return idescsi_transfer_pc(drive);
  629. }
  630. }
  631. /*
  632. * idescsi_do_request is our request handling function.
  633. */
  634. static ide_startstop_t idescsi_do_request (ide_drive_t *drive, struct request *rq, sector_t block)
  635. {
  636. #if IDESCSI_DEBUG_LOG
  637. printk (KERN_INFO "rq_status: %d, dev: %s, cmd: %x, errors: %d\n",rq->rq_status, rq->rq_disk->disk_name,rq->cmd[0],rq->errors);
  638. printk (KERN_INFO "sector: %ld, nr_sectors: %ld, current_nr_sectors: %d\n",rq->sector,rq->nr_sectors,rq->current_nr_sectors);
  639. #endif /* IDESCSI_DEBUG_LOG */
  640. if (rq->flags & (REQ_SPECIAL|REQ_SENSE)) {
  641. return idescsi_issue_pc (drive, (idescsi_pc_t *) rq->special);
  642. }
  643. blk_dump_rq_flags(rq, "ide-scsi: unsup command");
  644. idescsi_end_request (drive, 0, 0);
  645. return ide_stopped;
  646. }
  647. static void idescsi_add_settings(ide_drive_t *drive)
  648. {
  649. idescsi_scsi_t *scsi = drive_to_idescsi(drive);
  650. /*
  651. * drive setting name read/write ioctl ioctl data type min max mul_factor div_factor data pointer set function
  652. */
  653. ide_add_setting(drive, "bios_cyl", SETTING_RW, -1, -1, TYPE_INT, 0, 1023, 1, 1, &drive->bios_cyl, NULL);
  654. ide_add_setting(drive, "bios_head", SETTING_RW, -1, -1, TYPE_BYTE, 0, 255, 1, 1, &drive->bios_head, NULL);
  655. ide_add_setting(drive, "bios_sect", SETTING_RW, -1, -1, TYPE_BYTE, 0, 63, 1, 1, &drive->bios_sect, NULL);
  656. ide_add_setting(drive, "transform", SETTING_RW, -1, -1, TYPE_INT, 0, 3, 1, 1, &scsi->transform, NULL);
  657. ide_add_setting(drive, "log", SETTING_RW, -1, -1, TYPE_INT, 0, 1, 1, 1, &scsi->log, NULL);
  658. }
  659. /*
  660. * Driver initialization.
  661. */
  662. static void idescsi_setup (ide_drive_t *drive, idescsi_scsi_t *scsi)
  663. {
  664. if (drive->id && (drive->id->config & 0x0060) == 0x20)
  665. set_bit (IDESCSI_DRQ_INTERRUPT, &scsi->flags);
  666. set_bit(IDESCSI_TRANSFORM, &scsi->transform);
  667. clear_bit(IDESCSI_SG_TRANSFORM, &scsi->transform);
  668. #if IDESCSI_DEBUG_LOG
  669. set_bit(IDESCSI_LOG_CMD, &scsi->log);
  670. #endif /* IDESCSI_DEBUG_LOG */
  671. idescsi_add_settings(drive);
  672. }
  673. static void ide_scsi_remove(ide_drive_t *drive)
  674. {
  675. struct Scsi_Host *scsihost = drive->driver_data;
  676. struct ide_scsi_obj *scsi = scsihost_to_idescsi(scsihost);
  677. struct gendisk *g = scsi->disk;
  678. ide_unregister_subdriver(drive, scsi->driver);
  679. ide_unregister_region(g);
  680. drive->driver_data = NULL;
  681. g->private_data = NULL;
  682. put_disk(g);
  683. scsi_remove_host(scsihost);
  684. ide_scsi_put(scsi);
  685. }
  686. static int ide_scsi_probe(ide_drive_t *);
  687. #ifdef CONFIG_PROC_FS
  688. static ide_proc_entry_t idescsi_proc[] = {
  689. { "capacity", S_IFREG|S_IRUGO, proc_ide_read_capacity, NULL },
  690. { NULL, 0, NULL, NULL }
  691. };
  692. #else
  693. # define idescsi_proc NULL
  694. #endif
  695. static ide_driver_t idescsi_driver = {
  696. .gen_driver = {
  697. .owner = THIS_MODULE,
  698. .name = "ide-scsi",
  699. .bus = &ide_bus_type,
  700. },
  701. .probe = ide_scsi_probe,
  702. .remove = ide_scsi_remove,
  703. .version = IDESCSI_VERSION,
  704. .media = ide_scsi,
  705. .supports_dsc_overlap = 0,
  706. .proc = idescsi_proc,
  707. .do_request = idescsi_do_request,
  708. .end_request = idescsi_end_request,
  709. .error = idescsi_atapi_error,
  710. .abort = idescsi_atapi_abort,
  711. };
  712. static int idescsi_ide_open(struct inode *inode, struct file *filp)
  713. {
  714. struct gendisk *disk = inode->i_bdev->bd_disk;
  715. struct ide_scsi_obj *scsi;
  716. ide_drive_t *drive;
  717. if (!(scsi = ide_scsi_get(disk)))
  718. return -ENXIO;
  719. drive = scsi->drive;
  720. drive->usage++;
  721. return 0;
  722. }
  723. static int idescsi_ide_release(struct inode *inode, struct file *filp)
  724. {
  725. struct gendisk *disk = inode->i_bdev->bd_disk;
  726. struct ide_scsi_obj *scsi = ide_scsi_g(disk);
  727. ide_drive_t *drive = scsi->drive;
  728. drive->usage--;
  729. ide_scsi_put(scsi);
  730. return 0;
  731. }
  732. static int idescsi_ide_ioctl(struct inode *inode, struct file *file,
  733. unsigned int cmd, unsigned long arg)
  734. {
  735. struct block_device *bdev = inode->i_bdev;
  736. struct ide_scsi_obj *scsi = ide_scsi_g(bdev->bd_disk);
  737. return generic_ide_ioctl(scsi->drive, file, bdev, cmd, arg);
  738. }
  739. static struct block_device_operations idescsi_ops = {
  740. .owner = THIS_MODULE,
  741. .open = idescsi_ide_open,
  742. .release = idescsi_ide_release,
  743. .ioctl = idescsi_ide_ioctl,
  744. };
  745. static int idescsi_slave_configure(struct scsi_device * sdp)
  746. {
  747. /* Configure detected device */
  748. scsi_adjust_queue_depth(sdp, MSG_SIMPLE_TAG, sdp->host->cmd_per_lun);
  749. return 0;
  750. }
  751. static const char *idescsi_info (struct Scsi_Host *host)
  752. {
  753. return "SCSI host adapter emulation for IDE ATAPI devices";
  754. }
  755. static int idescsi_ioctl (struct scsi_device *dev, int cmd, void __user *arg)
  756. {
  757. idescsi_scsi_t *scsi = scsihost_to_idescsi(dev->host);
  758. if (cmd == SG_SET_TRANSFORM) {
  759. if (arg)
  760. set_bit(IDESCSI_SG_TRANSFORM, &scsi->transform);
  761. else
  762. clear_bit(IDESCSI_SG_TRANSFORM, &scsi->transform);
  763. return 0;
  764. } else if (cmd == SG_GET_TRANSFORM)
  765. return put_user(test_bit(IDESCSI_SG_TRANSFORM, &scsi->transform), (int __user *) arg);
  766. return -EINVAL;
  767. }
  768. static inline int should_transform(ide_drive_t *drive, struct scsi_cmnd *cmd)
  769. {
  770. idescsi_scsi_t *scsi = drive_to_idescsi(drive);
  771. /* this was a layering violation and we can't support it
  772. anymore, sorry. */
  773. #if 0
  774. struct gendisk *disk = cmd->request->rq_disk;
  775. if (disk) {
  776. struct struct scsi_device_Template **p = disk->private_data;
  777. if (strcmp((*p)->scsi_driverfs_driver.name, "sg") == 0)
  778. return test_bit(IDESCSI_SG_TRANSFORM, &scsi->transform);
  779. }
  780. #endif
  781. return test_bit(IDESCSI_TRANSFORM, &scsi->transform);
  782. }
  783. static int idescsi_queue (struct scsi_cmnd *cmd,
  784. void (*done)(struct scsi_cmnd *))
  785. {
  786. struct Scsi_Host *host = cmd->device->host;
  787. idescsi_scsi_t *scsi = scsihost_to_idescsi(host);
  788. ide_drive_t *drive = scsi->drive;
  789. struct request *rq = NULL;
  790. idescsi_pc_t *pc = NULL;
  791. if (!drive) {
  792. scmd_printk (KERN_ERR, cmd, "drive not present\n");
  793. goto abort;
  794. }
  795. scsi = drive_to_idescsi(drive);
  796. pc = kmalloc (sizeof (idescsi_pc_t), GFP_ATOMIC);
  797. rq = kmalloc (sizeof (struct request), GFP_ATOMIC);
  798. if (rq == NULL || pc == NULL) {
  799. printk (KERN_ERR "ide-scsi: %s: out of memory\n", drive->name);
  800. goto abort;
  801. }
  802. memset (pc->c, 0, 12);
  803. pc->flags = 0;
  804. pc->rq = rq;
  805. memcpy (pc->c, cmd->cmnd, cmd->cmd_len);
  806. if (cmd->use_sg) {
  807. pc->buffer = NULL;
  808. pc->sg = cmd->request_buffer;
  809. } else {
  810. pc->buffer = cmd->request_buffer;
  811. pc->sg = NULL;
  812. }
  813. pc->b_count = 0;
  814. pc->request_transfer = pc->buffer_size = cmd->request_bufflen;
  815. pc->scsi_cmd = cmd;
  816. pc->done = done;
  817. pc->timeout = jiffies + cmd->timeout_per_command;
  818. if (should_transform(drive, cmd))
  819. set_bit(PC_TRANSFORM, &pc->flags);
  820. idescsi_transform_pc1 (drive, pc);
  821. if (test_bit(IDESCSI_LOG_CMD, &scsi->log)) {
  822. printk ("ide-scsi: %s: que %lu, cmd = ", drive->name, cmd->serial_number);
  823. hexdump(cmd->cmnd, cmd->cmd_len);
  824. if (memcmp(pc->c, cmd->cmnd, cmd->cmd_len)) {
  825. printk ("ide-scsi: %s: que %lu, tsl = ", drive->name, cmd->serial_number);
  826. hexdump(pc->c, 12);
  827. }
  828. }
  829. ide_init_drive_cmd (rq);
  830. rq->special = (char *) pc;
  831. rq->flags = REQ_SPECIAL;
  832. spin_unlock_irq(host->host_lock);
  833. rq->rq_disk = scsi->disk;
  834. (void) ide_do_drive_cmd (drive, rq, ide_end);
  835. spin_lock_irq(host->host_lock);
  836. return 0;
  837. abort:
  838. kfree (pc);
  839. kfree (rq);
  840. cmd->result = DID_ERROR << 16;
  841. done(cmd);
  842. return 0;
  843. }
  844. static int idescsi_eh_abort (struct scsi_cmnd *cmd)
  845. {
  846. idescsi_scsi_t *scsi = scsihost_to_idescsi(cmd->device->host);
  847. ide_drive_t *drive = scsi->drive;
  848. int busy;
  849. int ret = FAILED;
  850. /* In idescsi_eh_abort we try to gently pry our command from the ide subsystem */
  851. if (test_bit(IDESCSI_LOG_CMD, &scsi->log))
  852. printk (KERN_WARNING "ide-scsi: abort called for %lu\n", cmd->serial_number);
  853. if (!drive) {
  854. printk (KERN_WARNING "ide-scsi: Drive not set in idescsi_eh_abort\n");
  855. WARN_ON(1);
  856. goto no_drive;
  857. }
  858. /* First give it some more time, how much is "right" is hard to say :-( */
  859. busy = ide_wait_not_busy(HWIF(drive), 100); /* FIXME - uses mdelay which causes latency? */
  860. if (test_bit(IDESCSI_LOG_CMD, &scsi->log))
  861. printk (KERN_WARNING "ide-scsi: drive did%s become ready\n", busy?" not":"");
  862. spin_lock_irq(&ide_lock);
  863. /* If there is no pc running we're done (our interrupt took care of it) */
  864. if (!scsi->pc) {
  865. ret = SUCCESS;
  866. goto ide_unlock;
  867. }
  868. /* It's somewhere in flight. Does ide subsystem agree? */
  869. if (scsi->pc->scsi_cmd->serial_number == cmd->serial_number && !busy &&
  870. elv_queue_empty(drive->queue) && HWGROUP(drive)->rq != scsi->pc->rq) {
  871. /*
  872. * FIXME - not sure this condition can ever occur
  873. */
  874. printk (KERN_ERR "ide-scsi: cmd aborted!\n");
  875. if (scsi->pc->rq->flags & REQ_SENSE)
  876. kfree(scsi->pc->buffer);
  877. kfree(scsi->pc->rq);
  878. kfree(scsi->pc);
  879. scsi->pc = NULL;
  880. ret = SUCCESS;
  881. }
  882. ide_unlock:
  883. spin_unlock_irq(&ide_lock);
  884. no_drive:
  885. if (test_bit(IDESCSI_LOG_CMD, &scsi->log))
  886. printk (KERN_WARNING "ide-scsi: abort returns %s\n", ret == SUCCESS?"success":"failed");
  887. return ret;
  888. }
  889. static int idescsi_eh_reset (struct scsi_cmnd *cmd)
  890. {
  891. struct request *req;
  892. idescsi_scsi_t *scsi = scsihost_to_idescsi(cmd->device->host);
  893. ide_drive_t *drive = scsi->drive;
  894. int ready = 0;
  895. int ret = SUCCESS;
  896. /* In idescsi_eh_reset we forcefully remove the command from the ide subsystem and reset the device. */
  897. if (test_bit(IDESCSI_LOG_CMD, &scsi->log))
  898. printk (KERN_WARNING "ide-scsi: reset called for %lu\n", cmd->serial_number);
  899. if (!drive) {
  900. printk (KERN_WARNING "ide-scsi: Drive not set in idescsi_eh_reset\n");
  901. WARN_ON(1);
  902. return FAILED;
  903. }
  904. spin_lock_irq(cmd->device->host->host_lock);
  905. spin_lock(&ide_lock);
  906. if (!scsi->pc || (req = scsi->pc->rq) != HWGROUP(drive)->rq || !HWGROUP(drive)->handler) {
  907. printk (KERN_WARNING "ide-scsi: No active request in idescsi_eh_reset\n");
  908. spin_unlock(&ide_lock);
  909. spin_unlock_irq(cmd->device->host->host_lock);
  910. return FAILED;
  911. }
  912. /* kill current request */
  913. blkdev_dequeue_request(req);
  914. end_that_request_last(req, 0);
  915. if (req->flags & REQ_SENSE)
  916. kfree(scsi->pc->buffer);
  917. kfree(scsi->pc);
  918. scsi->pc = NULL;
  919. kfree(req);
  920. /* now nuke the drive queue */
  921. while ((req = elv_next_request(drive->queue))) {
  922. blkdev_dequeue_request(req);
  923. end_that_request_last(req, 0);
  924. }
  925. HWGROUP(drive)->rq = NULL;
  926. HWGROUP(drive)->handler = NULL;
  927. HWGROUP(drive)->busy = 1; /* will set this to zero when ide reset finished */
  928. spin_unlock(&ide_lock);
  929. ide_do_reset(drive);
  930. /* ide_do_reset starts a polling handler which restarts itself every 50ms until the reset finishes */
  931. do {
  932. spin_unlock_irq(cmd->device->host->host_lock);
  933. msleep(50);
  934. spin_lock_irq(cmd->device->host->host_lock);
  935. } while ( HWGROUP(drive)->handler );
  936. ready = drive_is_ready(drive);
  937. HWGROUP(drive)->busy--;
  938. if (!ready) {
  939. printk (KERN_ERR "ide-scsi: reset failed!\n");
  940. ret = FAILED;
  941. }
  942. spin_unlock_irq(cmd->device->host->host_lock);
  943. return ret;
  944. }
  945. static int idescsi_bios(struct scsi_device *sdev, struct block_device *bdev,
  946. sector_t capacity, int *parm)
  947. {
  948. idescsi_scsi_t *idescsi = scsihost_to_idescsi(sdev->host);
  949. ide_drive_t *drive = idescsi->drive;
  950. if (drive->bios_cyl && drive->bios_head && drive->bios_sect) {
  951. parm[0] = drive->bios_head;
  952. parm[1] = drive->bios_sect;
  953. parm[2] = drive->bios_cyl;
  954. }
  955. return 0;
  956. }
  957. static struct scsi_host_template idescsi_template = {
  958. .module = THIS_MODULE,
  959. .name = "idescsi",
  960. .info = idescsi_info,
  961. .slave_configure = idescsi_slave_configure,
  962. .ioctl = idescsi_ioctl,
  963. .queuecommand = idescsi_queue,
  964. .eh_abort_handler = idescsi_eh_abort,
  965. .eh_host_reset_handler = idescsi_eh_reset,
  966. .bios_param = idescsi_bios,
  967. .can_queue = 40,
  968. .this_id = -1,
  969. .sg_tablesize = 256,
  970. .cmd_per_lun = 5,
  971. .max_sectors = 128,
  972. .use_clustering = DISABLE_CLUSTERING,
  973. .emulated = 1,
  974. .proc_name = "ide-scsi",
  975. };
  976. static int ide_scsi_probe(ide_drive_t *drive)
  977. {
  978. idescsi_scsi_t *idescsi;
  979. struct Scsi_Host *host;
  980. struct gendisk *g;
  981. static int warned;
  982. int err = -ENOMEM;
  983. if (!warned && drive->media == ide_cdrom) {
  984. printk(KERN_WARNING "ide-scsi is deprecated for cd burning! Use ide-cd and give dev=/dev/hdX as device\n");
  985. warned = 1;
  986. }
  987. if (!strstr("ide-scsi", drive->driver_req) ||
  988. !drive->present ||
  989. drive->media == ide_disk ||
  990. !(host = scsi_host_alloc(&idescsi_template,sizeof(idescsi_scsi_t))))
  991. return -ENODEV;
  992. g = alloc_disk(1 << PARTN_BITS);
  993. if (!g)
  994. goto out_host_put;
  995. ide_init_disk(g, drive);
  996. host->max_id = 1;
  997. #if IDESCSI_DEBUG_LOG
  998. if (drive->id->last_lun)
  999. printk(KERN_NOTICE "%s: id->last_lun=%u\n", drive->name, drive->id->last_lun);
  1000. #endif
  1001. if ((drive->id->last_lun & 0x7) != 7)
  1002. host->max_lun = (drive->id->last_lun & 0x7) + 1;
  1003. else
  1004. host->max_lun = 1;
  1005. drive->driver_data = host;
  1006. idescsi = scsihost_to_idescsi(host);
  1007. idescsi->drive = drive;
  1008. idescsi->driver = &idescsi_driver;
  1009. idescsi->host = host;
  1010. idescsi->disk = g;
  1011. g->private_data = &idescsi->driver;
  1012. ide_register_subdriver(drive, &idescsi_driver);
  1013. err = 0;
  1014. idescsi_setup(drive, idescsi);
  1015. g->fops = &idescsi_ops;
  1016. ide_register_region(g);
  1017. err = scsi_add_host(host, &drive->gendev);
  1018. if (!err) {
  1019. scsi_scan_host(host);
  1020. return 0;
  1021. }
  1022. /* fall through on error */
  1023. ide_unregister_region(g);
  1024. ide_unregister_subdriver(drive, &idescsi_driver);
  1025. put_disk(g);
  1026. out_host_put:
  1027. scsi_host_put(host);
  1028. return err;
  1029. }
  1030. static int __init init_idescsi_module(void)
  1031. {
  1032. return driver_register(&idescsi_driver.gen_driver);
  1033. }
  1034. static void __exit exit_idescsi_module(void)
  1035. {
  1036. driver_unregister(&idescsi_driver.gen_driver);
  1037. }
  1038. module_init(init_idescsi_module);
  1039. module_exit(exit_idescsi_module);
  1040. MODULE_LICENSE("GPL");