ide-atapi.c 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680
  1. /*
  2. * ATAPI support.
  3. */
  4. #include <linux/kernel.h>
  5. #include <linux/cdrom.h>
  6. #include <linux/delay.h>
  7. #include <linux/ide.h>
  8. #include <linux/scatterlist.h>
  9. #include <scsi/scsi.h>
  10. #ifdef DEBUG
  11. #define debug_log(fmt, args...) \
  12. printk(KERN_INFO "ide: " fmt, ## args)
  13. #else
  14. #define debug_log(fmt, args...) do {} while (0)
  15. #endif
  16. #define ATAPI_MIN_CDB_BYTES 12
  17. static inline int dev_is_idecd(ide_drive_t *drive)
  18. {
  19. return drive->media == ide_cdrom || drive->media == ide_optical;
  20. }
  21. /*
  22. * Check whether we can support a device,
  23. * based on the ATAPI IDENTIFY command results.
  24. */
  25. int ide_check_atapi_device(ide_drive_t *drive, const char *s)
  26. {
  27. u16 *id = drive->id;
  28. u8 gcw[2], protocol, device_type, removable, drq_type, packet_size;
  29. *((u16 *)&gcw) = id[ATA_ID_CONFIG];
  30. protocol = (gcw[1] & 0xC0) >> 6;
  31. device_type = gcw[1] & 0x1F;
  32. removable = (gcw[0] & 0x80) >> 7;
  33. drq_type = (gcw[0] & 0x60) >> 5;
  34. packet_size = gcw[0] & 0x03;
  35. #ifdef CONFIG_PPC
  36. /* kludge for Apple PowerBook internal zip */
  37. if (drive->media == ide_floppy && device_type == 5 &&
  38. !strstr((char *)&id[ATA_ID_PROD], "CD-ROM") &&
  39. strstr((char *)&id[ATA_ID_PROD], "ZIP"))
  40. device_type = 0;
  41. #endif
  42. if (protocol != 2)
  43. printk(KERN_ERR "%s: %s: protocol (0x%02x) is not ATAPI\n",
  44. s, drive->name, protocol);
  45. else if ((drive->media == ide_floppy && device_type != 0) ||
  46. (drive->media == ide_tape && device_type != 1))
  47. printk(KERN_ERR "%s: %s: invalid device type (0x%02x)\n",
  48. s, drive->name, device_type);
  49. else if (removable == 0)
  50. printk(KERN_ERR "%s: %s: the removable flag is not set\n",
  51. s, drive->name);
  52. else if (drive->media == ide_floppy && drq_type == 3)
  53. printk(KERN_ERR "%s: %s: sorry, DRQ type (0x%02x) not "
  54. "supported\n", s, drive->name, drq_type);
  55. else if (packet_size != 0)
  56. printk(KERN_ERR "%s: %s: packet size (0x%02x) is not 12 "
  57. "bytes\n", s, drive->name, packet_size);
  58. else
  59. return 1;
  60. return 0;
  61. }
  62. EXPORT_SYMBOL_GPL(ide_check_atapi_device);
  63. void ide_init_pc(struct ide_atapi_pc *pc)
  64. {
  65. memset(pc, 0, sizeof(*pc));
  66. pc->buf = pc->pc_buf;
  67. pc->buf_size = IDE_PC_BUFFER_SIZE;
  68. }
  69. EXPORT_SYMBOL_GPL(ide_init_pc);
  70. /*
  71. * Add a special packet command request to the tail of the request queue,
  72. * and wait for it to be serviced.
  73. */
  74. int ide_queue_pc_tail(ide_drive_t *drive, struct gendisk *disk,
  75. struct ide_atapi_pc *pc)
  76. {
  77. struct request *rq;
  78. int error;
  79. rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
  80. rq->cmd_type = REQ_TYPE_SPECIAL;
  81. rq->special = (char *)pc;
  82. if (pc->req_xfer) {
  83. error = blk_rq_map_kern(drive->queue, rq, pc->buf, pc->req_xfer,
  84. GFP_NOIO);
  85. if (error)
  86. goto put_req;
  87. }
  88. memcpy(rq->cmd, pc->c, 12);
  89. if (drive->media == ide_tape)
  90. rq->cmd[13] = REQ_IDETAPE_PC1;
  91. error = blk_execute_rq(drive->queue, disk, rq, 0);
  92. put_req:
  93. blk_put_request(rq);
  94. return error;
  95. }
  96. EXPORT_SYMBOL_GPL(ide_queue_pc_tail);
  97. int ide_do_test_unit_ready(ide_drive_t *drive, struct gendisk *disk)
  98. {
  99. struct ide_atapi_pc pc;
  100. ide_init_pc(&pc);
  101. pc.c[0] = TEST_UNIT_READY;
  102. return ide_queue_pc_tail(drive, disk, &pc);
  103. }
  104. EXPORT_SYMBOL_GPL(ide_do_test_unit_ready);
  105. int ide_do_start_stop(ide_drive_t *drive, struct gendisk *disk, int start)
  106. {
  107. struct ide_atapi_pc pc;
  108. ide_init_pc(&pc);
  109. pc.c[0] = START_STOP;
  110. pc.c[4] = start;
  111. if (drive->media == ide_tape)
  112. pc.flags |= PC_FLAG_WAIT_FOR_DSC;
  113. return ide_queue_pc_tail(drive, disk, &pc);
  114. }
  115. EXPORT_SYMBOL_GPL(ide_do_start_stop);
  116. int ide_set_media_lock(ide_drive_t *drive, struct gendisk *disk, int on)
  117. {
  118. struct ide_atapi_pc pc;
  119. if ((drive->dev_flags & IDE_DFLAG_DOORLOCKING) == 0)
  120. return 0;
  121. ide_init_pc(&pc);
  122. pc.c[0] = ALLOW_MEDIUM_REMOVAL;
  123. pc.c[4] = on;
  124. return ide_queue_pc_tail(drive, disk, &pc);
  125. }
  126. EXPORT_SYMBOL_GPL(ide_set_media_lock);
  127. void ide_create_request_sense_cmd(ide_drive_t *drive, struct ide_atapi_pc *pc)
  128. {
  129. ide_init_pc(pc);
  130. pc->c[0] = REQUEST_SENSE;
  131. if (drive->media == ide_floppy) {
  132. pc->c[4] = 255;
  133. pc->req_xfer = 18;
  134. } else {
  135. pc->c[4] = 20;
  136. pc->req_xfer = 20;
  137. }
  138. }
  139. EXPORT_SYMBOL_GPL(ide_create_request_sense_cmd);
  140. void ide_prep_sense(ide_drive_t *drive, struct request *rq)
  141. {
  142. struct request_sense *sense = &drive->sense_data;
  143. struct request *sense_rq = &drive->sense_rq;
  144. unsigned int cmd_len, sense_len;
  145. int err;
  146. debug_log("%s: enter\n", __func__);
  147. switch (drive->media) {
  148. case ide_floppy:
  149. cmd_len = 255;
  150. sense_len = 18;
  151. break;
  152. case ide_tape:
  153. cmd_len = 20;
  154. sense_len = 20;
  155. break;
  156. default:
  157. cmd_len = 18;
  158. sense_len = 18;
  159. }
  160. BUG_ON(sense_len > sizeof(*sense));
  161. if (blk_sense_request(rq) || drive->sense_rq_armed)
  162. return;
  163. memset(sense, 0, sizeof(*sense));
  164. blk_rq_init(rq->q, sense_rq);
  165. err = blk_rq_map_kern(drive->queue, sense_rq, sense, sense_len,
  166. GFP_NOIO);
  167. if (unlikely(err)) {
  168. if (printk_ratelimit())
  169. printk(KERN_WARNING "%s: failed to map sense buffer\n",
  170. drive->name);
  171. return;
  172. }
  173. sense_rq->rq_disk = rq->rq_disk;
  174. sense_rq->cmd[0] = GPCMD_REQUEST_SENSE;
  175. sense_rq->cmd[4] = cmd_len;
  176. sense_rq->cmd_type = REQ_TYPE_SENSE;
  177. sense_rq->cmd_flags |= REQ_PREEMPT;
  178. if (drive->media == ide_tape)
  179. sense_rq->cmd[13] = REQ_IDETAPE_PC1;
  180. drive->sense_rq_armed = true;
  181. }
  182. EXPORT_SYMBOL_GPL(ide_prep_sense);
  183. int ide_queue_sense_rq(ide_drive_t *drive, void *special)
  184. {
  185. /* deferred failure from ide_prep_sense() */
  186. if (!drive->sense_rq_armed) {
  187. printk(KERN_WARNING "%s: failed queue sense request\n",
  188. drive->name);
  189. return -ENOMEM;
  190. }
  191. drive->sense_rq.special = special;
  192. drive->sense_rq_armed = false;
  193. drive->hwif->rq = NULL;
  194. elv_add_request(drive->queue, &drive->sense_rq,
  195. ELEVATOR_INSERT_FRONT, 0);
  196. return 0;
  197. }
  198. EXPORT_SYMBOL_GPL(ide_queue_sense_rq);
  199. /*
  200. * Called when an error was detected during the last packet command.
  201. * We queue a request sense packet command at the head of the request
  202. * queue.
  203. */
  204. void ide_retry_pc(ide_drive_t *drive)
  205. {
  206. struct request *sense_rq = &drive->sense_rq;
  207. struct ide_atapi_pc *pc = &drive->request_sense_pc;
  208. (void)ide_read_error(drive);
  209. /* init pc from sense_rq */
  210. ide_init_pc(pc);
  211. memcpy(pc->c, sense_rq->cmd, 12);
  212. pc->buf = bio_data(sense_rq->bio); /* pointer to mapped address */
  213. pc->req_xfer = sense_rq->data_len;
  214. if (drive->media == ide_tape)
  215. set_bit(IDE_AFLAG_IGNORE_DSC, &drive->atapi_flags);
  216. if (ide_queue_sense_rq(drive, pc))
  217. ide_complete_rq(drive, -EIO, blk_rq_bytes(drive->hwif->rq));
  218. }
  219. EXPORT_SYMBOL_GPL(ide_retry_pc);
  220. int ide_cd_expiry(ide_drive_t *drive)
  221. {
  222. struct request *rq = drive->hwif->rq;
  223. unsigned long wait = 0;
  224. debug_log("%s: rq->cmd[0]: 0x%x\n", __func__, rq->cmd[0]);
  225. /*
  226. * Some commands are *slow* and normally take a long time to complete.
  227. * Usually we can use the ATAPI "disconnect" to bypass this, but not all
  228. * commands/drives support that. Let ide_timer_expiry keep polling us
  229. * for these.
  230. */
  231. switch (rq->cmd[0]) {
  232. case GPCMD_BLANK:
  233. case GPCMD_FORMAT_UNIT:
  234. case GPCMD_RESERVE_RZONE_TRACK:
  235. case GPCMD_CLOSE_TRACK:
  236. case GPCMD_FLUSH_CACHE:
  237. wait = ATAPI_WAIT_PC;
  238. break;
  239. default:
  240. if (!(rq->cmd_flags & REQ_QUIET))
  241. printk(KERN_INFO "cmd 0x%x timed out\n",
  242. rq->cmd[0]);
  243. wait = 0;
  244. break;
  245. }
  246. return wait;
  247. }
  248. EXPORT_SYMBOL_GPL(ide_cd_expiry);
  249. int ide_cd_get_xferlen(struct request *rq)
  250. {
  251. if (blk_fs_request(rq))
  252. return 32768;
  253. else if (blk_sense_request(rq) || blk_pc_request(rq) ||
  254. rq->cmd_type == REQ_TYPE_ATA_PC)
  255. return rq->data_len;
  256. else
  257. return 0;
  258. }
  259. EXPORT_SYMBOL_GPL(ide_cd_get_xferlen);
  260. void ide_read_bcount_and_ireason(ide_drive_t *drive, u16 *bcount, u8 *ireason)
  261. {
  262. struct ide_taskfile tf;
  263. drive->hwif->tp_ops->tf_read(drive, &tf, IDE_VALID_NSECT |
  264. IDE_VALID_LBAM | IDE_VALID_LBAH);
  265. *bcount = (tf.lbah << 8) | tf.lbam;
  266. *ireason = tf.nsect & 3;
  267. }
  268. EXPORT_SYMBOL_GPL(ide_read_bcount_and_ireason);
  269. /*
  270. * This is the usual interrupt handler which will be called during a packet
  271. * command. We will transfer some of the data (as requested by the drive)
  272. * and will re-point interrupt handler to us.
  273. */
  274. static ide_startstop_t ide_pc_intr(ide_drive_t *drive)
  275. {
  276. struct ide_atapi_pc *pc = drive->pc;
  277. ide_hwif_t *hwif = drive->hwif;
  278. struct ide_cmd *cmd = &hwif->cmd;
  279. struct request *rq = hwif->rq;
  280. const struct ide_tp_ops *tp_ops = hwif->tp_ops;
  281. unsigned int timeout, done;
  282. u16 bcount;
  283. u8 stat, ireason, dsc = 0;
  284. u8 write = !!(pc->flags & PC_FLAG_WRITING);
  285. debug_log("Enter %s - interrupt handler\n", __func__);
  286. timeout = (drive->media == ide_floppy) ? WAIT_FLOPPY_CMD
  287. : WAIT_TAPE_CMD;
  288. /* Clear the interrupt */
  289. stat = tp_ops->read_status(hwif);
  290. if (pc->flags & PC_FLAG_DMA_IN_PROGRESS) {
  291. int rc;
  292. drive->waiting_for_dma = 0;
  293. rc = hwif->dma_ops->dma_end(drive);
  294. ide_dma_unmap_sg(drive, cmd);
  295. if (rc || (drive->media == ide_tape && (stat & ATA_ERR))) {
  296. if (drive->media == ide_floppy)
  297. printk(KERN_ERR "%s: DMA %s error\n",
  298. drive->name, rq_data_dir(pc->rq)
  299. ? "write" : "read");
  300. pc->flags |= PC_FLAG_DMA_ERROR;
  301. } else
  302. pc->xferred = pc->req_xfer;
  303. debug_log("%s: DMA finished\n", drive->name);
  304. }
  305. /* No more interrupts */
  306. if ((stat & ATA_DRQ) == 0) {
  307. int uptodate, error;
  308. unsigned int done;
  309. debug_log("Packet command completed, %d bytes transferred\n",
  310. pc->xferred);
  311. pc->flags &= ~PC_FLAG_DMA_IN_PROGRESS;
  312. local_irq_enable_in_hardirq();
  313. if (drive->media == ide_tape &&
  314. (stat & ATA_ERR) && rq->cmd[0] == REQUEST_SENSE)
  315. stat &= ~ATA_ERR;
  316. if ((stat & ATA_ERR) || (pc->flags & PC_FLAG_DMA_ERROR)) {
  317. /* Error detected */
  318. debug_log("%s: I/O error\n", drive->name);
  319. if (drive->media != ide_tape)
  320. pc->rq->errors++;
  321. if (rq->cmd[0] == REQUEST_SENSE) {
  322. printk(KERN_ERR "%s: I/O error in request sense"
  323. " command\n", drive->name);
  324. return ide_do_reset(drive);
  325. }
  326. debug_log("[cmd %x]: check condition\n", rq->cmd[0]);
  327. /* Retry operation */
  328. ide_retry_pc(drive);
  329. /* queued, but not started */
  330. return ide_stopped;
  331. }
  332. pc->error = 0;
  333. if ((pc->flags & PC_FLAG_WAIT_FOR_DSC) && (stat & ATA_DSC) == 0)
  334. dsc = 1;
  335. /*
  336. * ->pc_callback() might change rq->data_len for
  337. * residual count, cache total length.
  338. */
  339. done = blk_rq_bytes(rq);
  340. /* Command finished - Call the callback function */
  341. uptodate = drive->pc_callback(drive, dsc);
  342. if (uptodate == 0)
  343. drive->failed_pc = NULL;
  344. if (blk_special_request(rq)) {
  345. rq->errors = 0;
  346. error = 0;
  347. } else {
  348. if (blk_fs_request(rq) == 0 && uptodate <= 0) {
  349. if (rq->errors == 0)
  350. rq->errors = -EIO;
  351. }
  352. error = uptodate ? 0 : -EIO;
  353. }
  354. ide_complete_rq(drive, error, done);
  355. return ide_stopped;
  356. }
  357. if (pc->flags & PC_FLAG_DMA_IN_PROGRESS) {
  358. pc->flags &= ~PC_FLAG_DMA_IN_PROGRESS;
  359. printk(KERN_ERR "%s: The device wants to issue more interrupts "
  360. "in DMA mode\n", drive->name);
  361. ide_dma_off(drive);
  362. return ide_do_reset(drive);
  363. }
  364. /* Get the number of bytes to transfer on this interrupt. */
  365. ide_read_bcount_and_ireason(drive, &bcount, &ireason);
  366. if (ireason & ATAPI_COD) {
  367. printk(KERN_ERR "%s: CoD != 0 in %s\n", drive->name, __func__);
  368. return ide_do_reset(drive);
  369. }
  370. if (((ireason & ATAPI_IO) == ATAPI_IO) == write) {
  371. /* Hopefully, we will never get here */
  372. printk(KERN_ERR "%s: We wanted to %s, but the device wants us "
  373. "to %s!\n", drive->name,
  374. (ireason & ATAPI_IO) ? "Write" : "Read",
  375. (ireason & ATAPI_IO) ? "Read" : "Write");
  376. return ide_do_reset(drive);
  377. }
  378. done = min_t(unsigned int, bcount, cmd->nleft);
  379. ide_pio_bytes(drive, cmd, write, done);
  380. /* Update transferred byte count */
  381. pc->xferred += done;
  382. bcount -= done;
  383. if (bcount)
  384. ide_pad_transfer(drive, write, bcount);
  385. debug_log("[cmd %x] transferred %d bytes, padded %d bytes\n",
  386. rq->cmd[0], done, bcount);
  387. /* And set the interrupt handler again */
  388. ide_set_handler(drive, ide_pc_intr, timeout);
  389. return ide_started;
  390. }
  391. static void ide_init_packet_cmd(struct ide_cmd *cmd, u8 valid_tf,
  392. u16 bcount, u8 dma)
  393. {
  394. cmd->protocol = dma ? ATAPI_PROT_DMA : ATAPI_PROT_PIO;
  395. cmd->valid.out.tf = IDE_VALID_LBAH | IDE_VALID_LBAM |
  396. IDE_VALID_FEATURE | valid_tf;
  397. cmd->tf.command = ATA_CMD_PACKET;
  398. cmd->tf.feature = dma; /* Use PIO/DMA */
  399. cmd->tf.lbam = bcount & 0xff;
  400. cmd->tf.lbah = (bcount >> 8) & 0xff;
  401. }
  402. static u8 ide_read_ireason(ide_drive_t *drive)
  403. {
  404. struct ide_taskfile tf;
  405. drive->hwif->tp_ops->tf_read(drive, &tf, IDE_VALID_NSECT);
  406. return tf.nsect & 3;
  407. }
  408. static u8 ide_wait_ireason(ide_drive_t *drive, u8 ireason)
  409. {
  410. int retries = 100;
  411. while (retries-- && ((ireason & ATAPI_COD) == 0 ||
  412. (ireason & ATAPI_IO))) {
  413. printk(KERN_ERR "%s: (IO,CoD != (0,1) while issuing "
  414. "a packet command, retrying\n", drive->name);
  415. udelay(100);
  416. ireason = ide_read_ireason(drive);
  417. if (retries == 0) {
  418. printk(KERN_ERR "%s: (IO,CoD != (0,1) while issuing "
  419. "a packet command, ignoring\n",
  420. drive->name);
  421. ireason |= ATAPI_COD;
  422. ireason &= ~ATAPI_IO;
  423. }
  424. }
  425. return ireason;
  426. }
  427. static int ide_delayed_transfer_pc(ide_drive_t *drive)
  428. {
  429. /* Send the actual packet */
  430. drive->hwif->tp_ops->output_data(drive, NULL, drive->pc->c, 12);
  431. /* Timeout for the packet command */
  432. return WAIT_FLOPPY_CMD;
  433. }
  434. static ide_startstop_t ide_transfer_pc(ide_drive_t *drive)
  435. {
  436. struct ide_atapi_pc *uninitialized_var(pc);
  437. ide_hwif_t *hwif = drive->hwif;
  438. struct request *rq = hwif->rq;
  439. ide_expiry_t *expiry;
  440. unsigned int timeout;
  441. int cmd_len;
  442. ide_startstop_t startstop;
  443. u8 ireason;
  444. if (ide_wait_stat(&startstop, drive, ATA_DRQ, ATA_BUSY, WAIT_READY)) {
  445. printk(KERN_ERR "%s: Strange, packet command initiated yet "
  446. "DRQ isn't asserted\n", drive->name);
  447. return startstop;
  448. }
  449. if (drive->atapi_flags & IDE_AFLAG_DRQ_INTERRUPT) {
  450. if (drive->dma)
  451. drive->waiting_for_dma = 1;
  452. }
  453. if (dev_is_idecd(drive)) {
  454. /* ATAPI commands get padded out to 12 bytes minimum */
  455. cmd_len = COMMAND_SIZE(rq->cmd[0]);
  456. if (cmd_len < ATAPI_MIN_CDB_BYTES)
  457. cmd_len = ATAPI_MIN_CDB_BYTES;
  458. timeout = rq->timeout;
  459. expiry = ide_cd_expiry;
  460. } else {
  461. pc = drive->pc;
  462. cmd_len = ATAPI_MIN_CDB_BYTES;
  463. /*
  464. * If necessary schedule the packet transfer to occur 'timeout'
  465. * miliseconds later in ide_delayed_transfer_pc() after the
  466. * device says it's ready for a packet.
  467. */
  468. if (drive->atapi_flags & IDE_AFLAG_ZIP_DRIVE) {
  469. timeout = drive->pc_delay;
  470. expiry = &ide_delayed_transfer_pc;
  471. } else {
  472. timeout = (drive->media == ide_floppy) ? WAIT_FLOPPY_CMD
  473. : WAIT_TAPE_CMD;
  474. expiry = NULL;
  475. }
  476. ireason = ide_read_ireason(drive);
  477. if (drive->media == ide_tape)
  478. ireason = ide_wait_ireason(drive, ireason);
  479. if ((ireason & ATAPI_COD) == 0 || (ireason & ATAPI_IO)) {
  480. printk(KERN_ERR "%s: (IO,CoD) != (0,1) while issuing "
  481. "a packet command\n", drive->name);
  482. return ide_do_reset(drive);
  483. }
  484. }
  485. hwif->expiry = expiry;
  486. /* Set the interrupt routine */
  487. ide_set_handler(drive,
  488. (dev_is_idecd(drive) ? drive->irq_handler
  489. : ide_pc_intr),
  490. timeout);
  491. /* Send the actual packet */
  492. if ((drive->atapi_flags & IDE_AFLAG_ZIP_DRIVE) == 0)
  493. hwif->tp_ops->output_data(drive, NULL, rq->cmd, cmd_len);
  494. /* Begin DMA, if necessary */
  495. if (dev_is_idecd(drive)) {
  496. if (drive->dma)
  497. hwif->dma_ops->dma_start(drive);
  498. } else {
  499. if (pc->flags & PC_FLAG_DMA_OK) {
  500. pc->flags |= PC_FLAG_DMA_IN_PROGRESS;
  501. hwif->dma_ops->dma_start(drive);
  502. }
  503. }
  504. return ide_started;
  505. }
  506. ide_startstop_t ide_issue_pc(ide_drive_t *drive, struct ide_cmd *cmd)
  507. {
  508. struct ide_atapi_pc *pc;
  509. ide_hwif_t *hwif = drive->hwif;
  510. ide_expiry_t *expiry = NULL;
  511. struct request *rq = hwif->rq;
  512. unsigned int timeout;
  513. u16 bcount;
  514. u8 valid_tf;
  515. u8 drq_int = !!(drive->atapi_flags & IDE_AFLAG_DRQ_INTERRUPT);
  516. if (dev_is_idecd(drive)) {
  517. valid_tf = IDE_VALID_NSECT | IDE_VALID_LBAL;
  518. bcount = ide_cd_get_xferlen(rq);
  519. expiry = ide_cd_expiry;
  520. timeout = ATAPI_WAIT_PC;
  521. if (drive->dma)
  522. drive->dma = !ide_dma_prepare(drive, cmd);
  523. } else {
  524. pc = drive->pc;
  525. /* We haven't transferred any data yet */
  526. pc->xferred = 0;
  527. valid_tf = IDE_VALID_DEVICE;
  528. bcount = ((drive->media == ide_tape) ?
  529. pc->req_xfer :
  530. min(pc->req_xfer, 63 * 1024));
  531. if (pc->flags & PC_FLAG_DMA_ERROR) {
  532. pc->flags &= ~PC_FLAG_DMA_ERROR;
  533. ide_dma_off(drive);
  534. }
  535. if (pc->flags & PC_FLAG_DMA_OK)
  536. drive->dma = !ide_dma_prepare(drive, cmd);
  537. if (!drive->dma)
  538. pc->flags &= ~PC_FLAG_DMA_OK;
  539. timeout = (drive->media == ide_floppy) ? WAIT_FLOPPY_CMD
  540. : WAIT_TAPE_CMD;
  541. }
  542. ide_init_packet_cmd(cmd, valid_tf, bcount, drive->dma);
  543. (void)do_rw_taskfile(drive, cmd);
  544. if (drq_int) {
  545. if (drive->dma)
  546. drive->waiting_for_dma = 0;
  547. hwif->expiry = expiry;
  548. }
  549. ide_execute_command(drive, cmd, ide_transfer_pc, timeout);
  550. return drq_int ? ide_started : ide_transfer_pc(drive);
  551. }
  552. EXPORT_SYMBOL_GPL(ide_issue_pc);