/drivers/block/pktcdvd.c

https://bitbucket.org/evzijst/gittest · C · 2681 lines · 1973 code · 390 blank · 318 comment · 369 complexity · 5cf97ce5b6e68125d0b8ceb8b0b8443a MD5 · raw file

Large files are truncated click here to view the full file

  1. /*
  2. * Copyright (C) 2000 Jens Axboe <axboe@suse.de>
  3. * Copyright (C) 2001-2004 Peter Osterlund <petero2@telia.com>
  4. *
  5. * May be copied or modified under the terms of the GNU General Public
  6. * License. See linux/COPYING for more information.
  7. *
  8. * Packet writing layer for ATAPI and SCSI CD-R, CD-RW, DVD-R, and
  9. * DVD-RW devices (aka an exercise in block layer masturbation)
  10. *
  11. *
  12. * TODO: (circa order of when I will fix it)
  13. * - Only able to write on CD-RW media right now.
  14. * - check host application code on media and set it in write page
  15. * - interface for UDF <-> packet to negotiate a new location when a write
  16. * fails.
  17. * - handle OPC, especially for -RW media
  18. *
  19. * Theory of operation:
  20. *
  21. * We use a custom make_request_fn function that forwards reads directly to
  22. * the underlying CD device. Write requests are either attached directly to
  23. * a live packet_data object, or simply stored sequentially in a list for
  24. * later processing by the kcdrwd kernel thread. This driver doesn't use
  25. * any elevator functionally as defined by the elevator_s struct, but the
  26. * underlying CD device uses a standard elevator.
  27. *
  28. * This strategy makes it possible to do very late merging of IO requests.
  29. * A new bio sent to pkt_make_request can be merged with a live packet_data
  30. * object even if the object is in the data gathering state.
  31. *
  32. *************************************************************************/
  33. #define VERSION_CODE "v0.2.0a 2004-07-14 Jens Axboe (axboe@suse.de) and petero2@telia.com"
  34. #include <linux/pktcdvd.h>
  35. #include <linux/config.h>
  36. #include <linux/module.h>
  37. #include <linux/types.h>
  38. #include <linux/kernel.h>
  39. #include <linux/kthread.h>
  40. #include <linux/errno.h>
  41. #include <linux/spinlock.h>
  42. #include <linux/file.h>
  43. #include <linux/proc_fs.h>
  44. #include <linux/seq_file.h>
  45. #include <linux/miscdevice.h>
  46. #include <linux/suspend.h>
  47. #include <scsi/scsi_cmnd.h>
  48. #include <scsi/scsi_ioctl.h>
  49. #include <asm/uaccess.h>
  50. #if PACKET_DEBUG
  51. #define DPRINTK(fmt, args...) printk(KERN_NOTICE fmt, ##args)
  52. #else
  53. #define DPRINTK(fmt, args...)
  54. #endif
  55. #if PACKET_DEBUG > 1
  56. #define VPRINTK(fmt, args...) printk(KERN_NOTICE fmt, ##args)
  57. #else
  58. #define VPRINTK(fmt, args...)
  59. #endif
  60. #define MAX_SPEED 0xffff
  61. #define ZONE(sector, pd) (((sector) + (pd)->offset) & ~((pd)->settings.size - 1))
  62. static struct pktcdvd_device *pkt_devs[MAX_WRITERS];
  63. static struct proc_dir_entry *pkt_proc;
  64. static int pkt_major;
  65. static struct semaphore ctl_mutex; /* Serialize open/close/setup/teardown */
  66. static mempool_t *psd_pool;
  67. static void pkt_bio_finished(struct pktcdvd_device *pd)
  68. {
  69. BUG_ON(atomic_read(&pd->cdrw.pending_bios) <= 0);
  70. if (atomic_dec_and_test(&pd->cdrw.pending_bios)) {
  71. VPRINTK("pktcdvd: queue empty\n");
  72. atomic_set(&pd->iosched.attention, 1);
  73. wake_up(&pd->wqueue);
  74. }
  75. }
  76. static void pkt_bio_destructor(struct bio *bio)
  77. {
  78. kfree(bio->bi_io_vec);
  79. kfree(bio);
  80. }
  81. static struct bio *pkt_bio_alloc(int nr_iovecs)
  82. {
  83. struct bio_vec *bvl = NULL;
  84. struct bio *bio;
  85. bio = kmalloc(sizeof(struct bio), GFP_KERNEL);
  86. if (!bio)
  87. goto no_bio;
  88. bio_init(bio);
  89. bvl = kmalloc(nr_iovecs * sizeof(struct bio_vec), GFP_KERNEL);
  90. if (!bvl)
  91. goto no_bvl;
  92. memset(bvl, 0, nr_iovecs * sizeof(struct bio_vec));
  93. bio->bi_max_vecs = nr_iovecs;
  94. bio->bi_io_vec = bvl;
  95. bio->bi_destructor = pkt_bio_destructor;
  96. return bio;
  97. no_bvl:
  98. kfree(bio);
  99. no_bio:
  100. return NULL;
  101. }
  102. /*
  103. * Allocate a packet_data struct
  104. */
  105. static struct packet_data *pkt_alloc_packet_data(void)
  106. {
  107. int i;
  108. struct packet_data *pkt;
  109. pkt = kmalloc(sizeof(struct packet_data), GFP_KERNEL);
  110. if (!pkt)
  111. goto no_pkt;
  112. memset(pkt, 0, sizeof(struct packet_data));
  113. pkt->w_bio = pkt_bio_alloc(PACKET_MAX_SIZE);
  114. if (!pkt->w_bio)
  115. goto no_bio;
  116. for (i = 0; i < PAGES_PER_PACKET; i++) {
  117. pkt->pages[i] = alloc_page(GFP_KERNEL|__GFP_ZERO);
  118. if (!pkt->pages[i])
  119. goto no_page;
  120. }
  121. spin_lock_init(&pkt->lock);
  122. for (i = 0; i < PACKET_MAX_SIZE; i++) {
  123. struct bio *bio = pkt_bio_alloc(1);
  124. if (!bio)
  125. goto no_rd_bio;
  126. pkt->r_bios[i] = bio;
  127. }
  128. return pkt;
  129. no_rd_bio:
  130. for (i = 0; i < PACKET_MAX_SIZE; i++) {
  131. struct bio *bio = pkt->r_bios[i];
  132. if (bio)
  133. bio_put(bio);
  134. }
  135. no_page:
  136. for (i = 0; i < PAGES_PER_PACKET; i++)
  137. if (pkt->pages[i])
  138. __free_page(pkt->pages[i]);
  139. bio_put(pkt->w_bio);
  140. no_bio:
  141. kfree(pkt);
  142. no_pkt:
  143. return NULL;
  144. }
  145. /*
  146. * Free a packet_data struct
  147. */
  148. static void pkt_free_packet_data(struct packet_data *pkt)
  149. {
  150. int i;
  151. for (i = 0; i < PACKET_MAX_SIZE; i++) {
  152. struct bio *bio = pkt->r_bios[i];
  153. if (bio)
  154. bio_put(bio);
  155. }
  156. for (i = 0; i < PAGES_PER_PACKET; i++)
  157. __free_page(pkt->pages[i]);
  158. bio_put(pkt->w_bio);
  159. kfree(pkt);
  160. }
  161. static void pkt_shrink_pktlist(struct pktcdvd_device *pd)
  162. {
  163. struct packet_data *pkt, *next;
  164. BUG_ON(!list_empty(&pd->cdrw.pkt_active_list));
  165. list_for_each_entry_safe(pkt, next, &pd->cdrw.pkt_free_list, list) {
  166. pkt_free_packet_data(pkt);
  167. }
  168. }
  169. static int pkt_grow_pktlist(struct pktcdvd_device *pd, int nr_packets)
  170. {
  171. struct packet_data *pkt;
  172. INIT_LIST_HEAD(&pd->cdrw.pkt_free_list);
  173. INIT_LIST_HEAD(&pd->cdrw.pkt_active_list);
  174. spin_lock_init(&pd->cdrw.active_list_lock);
  175. while (nr_packets > 0) {
  176. pkt = pkt_alloc_packet_data();
  177. if (!pkt) {
  178. pkt_shrink_pktlist(pd);
  179. return 0;
  180. }
  181. pkt->id = nr_packets;
  182. pkt->pd = pd;
  183. list_add(&pkt->list, &pd->cdrw.pkt_free_list);
  184. nr_packets--;
  185. }
  186. return 1;
  187. }
  188. static void *pkt_rb_alloc(unsigned int __nocast gfp_mask, void *data)
  189. {
  190. return kmalloc(sizeof(struct pkt_rb_node), gfp_mask);
  191. }
  192. static void pkt_rb_free(void *ptr, void *data)
  193. {
  194. kfree(ptr);
  195. }
  196. static inline struct pkt_rb_node *pkt_rbtree_next(struct pkt_rb_node *node)
  197. {
  198. struct rb_node *n = rb_next(&node->rb_node);
  199. if (!n)
  200. return NULL;
  201. return rb_entry(n, struct pkt_rb_node, rb_node);
  202. }
  203. static inline void pkt_rbtree_erase(struct pktcdvd_device *pd, struct pkt_rb_node *node)
  204. {
  205. rb_erase(&node->rb_node, &pd->bio_queue);
  206. mempool_free(node, pd->rb_pool);
  207. pd->bio_queue_size--;
  208. BUG_ON(pd->bio_queue_size < 0);
  209. }
  210. /*
  211. * Find the first node in the pd->bio_queue rb tree with a starting sector >= s.
  212. */
  213. static struct pkt_rb_node *pkt_rbtree_find(struct pktcdvd_device *pd, sector_t s)
  214. {
  215. struct rb_node *n = pd->bio_queue.rb_node;
  216. struct rb_node *next;
  217. struct pkt_rb_node *tmp;
  218. if (!n) {
  219. BUG_ON(pd->bio_queue_size > 0);
  220. return NULL;
  221. }
  222. for (;;) {
  223. tmp = rb_entry(n, struct pkt_rb_node, rb_node);
  224. if (s <= tmp->bio->bi_sector)
  225. next = n->rb_left;
  226. else
  227. next = n->rb_right;
  228. if (!next)
  229. break;
  230. n = next;
  231. }
  232. if (s > tmp->bio->bi_sector) {
  233. tmp = pkt_rbtree_next(tmp);
  234. if (!tmp)
  235. return NULL;
  236. }
  237. BUG_ON(s > tmp->bio->bi_sector);
  238. return tmp;
  239. }
  240. /*
  241. * Insert a node into the pd->bio_queue rb tree.
  242. */
  243. static void pkt_rbtree_insert(struct pktcdvd_device *pd, struct pkt_rb_node *node)
  244. {
  245. struct rb_node **p = &pd->bio_queue.rb_node;
  246. struct rb_node *parent = NULL;
  247. sector_t s = node->bio->bi_sector;
  248. struct pkt_rb_node *tmp;
  249. while (*p) {
  250. parent = *p;
  251. tmp = rb_entry(parent, struct pkt_rb_node, rb_node);
  252. if (s < tmp->bio->bi_sector)
  253. p = &(*p)->rb_left;
  254. else
  255. p = &(*p)->rb_right;
  256. }
  257. rb_link_node(&node->rb_node, parent, p);
  258. rb_insert_color(&node->rb_node, &pd->bio_queue);
  259. pd->bio_queue_size++;
  260. }
  261. /*
  262. * Add a bio to a single linked list defined by its head and tail pointers.
  263. */
  264. static inline void pkt_add_list_last(struct bio *bio, struct bio **list_head, struct bio **list_tail)
  265. {
  266. bio->bi_next = NULL;
  267. if (*list_tail) {
  268. BUG_ON((*list_head) == NULL);
  269. (*list_tail)->bi_next = bio;
  270. (*list_tail) = bio;
  271. } else {
  272. BUG_ON((*list_head) != NULL);
  273. (*list_head) = bio;
  274. (*list_tail) = bio;
  275. }
  276. }
  277. /*
  278. * Remove and return the first bio from a single linked list defined by its
  279. * head and tail pointers.
  280. */
  281. static inline struct bio *pkt_get_list_first(struct bio **list_head, struct bio **list_tail)
  282. {
  283. struct bio *bio;
  284. if (*list_head == NULL)
  285. return NULL;
  286. bio = *list_head;
  287. *list_head = bio->bi_next;
  288. if (*list_head == NULL)
  289. *list_tail = NULL;
  290. bio->bi_next = NULL;
  291. return bio;
  292. }
  293. /*
  294. * Send a packet_command to the underlying block device and
  295. * wait for completion.
  296. */
  297. static int pkt_generic_packet(struct pktcdvd_device *pd, struct packet_command *cgc)
  298. {
  299. char sense[SCSI_SENSE_BUFFERSIZE];
  300. request_queue_t *q;
  301. struct request *rq;
  302. DECLARE_COMPLETION(wait);
  303. int err = 0;
  304. q = bdev_get_queue(pd->bdev);
  305. rq = blk_get_request(q, (cgc->data_direction == CGC_DATA_WRITE) ? WRITE : READ,
  306. __GFP_WAIT);
  307. rq->errors = 0;
  308. rq->rq_disk = pd->bdev->bd_disk;
  309. rq->bio = NULL;
  310. rq->buffer = NULL;
  311. rq->timeout = 60*HZ;
  312. rq->data = cgc->buffer;
  313. rq->data_len = cgc->buflen;
  314. rq->sense = sense;
  315. memset(sense, 0, sizeof(sense));
  316. rq->sense_len = 0;
  317. rq->flags |= REQ_BLOCK_PC | REQ_HARDBARRIER;
  318. if (cgc->quiet)
  319. rq->flags |= REQ_QUIET;
  320. memcpy(rq->cmd, cgc->cmd, CDROM_PACKET_SIZE);
  321. if (sizeof(rq->cmd) > CDROM_PACKET_SIZE)
  322. memset(rq->cmd + CDROM_PACKET_SIZE, 0, sizeof(rq->cmd) - CDROM_PACKET_SIZE);
  323. rq->ref_count++;
  324. rq->flags |= REQ_NOMERGE;
  325. rq->waiting = &wait;
  326. rq->end_io = blk_end_sync_rq;
  327. elv_add_request(q, rq, ELEVATOR_INSERT_BACK, 1);
  328. generic_unplug_device(q);
  329. wait_for_completion(&wait);
  330. if (rq->errors)
  331. err = -EIO;
  332. blk_put_request(rq);
  333. return err;
  334. }
  335. /*
  336. * A generic sense dump / resolve mechanism should be implemented across
  337. * all ATAPI + SCSI devices.
  338. */
  339. static void pkt_dump_sense(struct packet_command *cgc)
  340. {
  341. static char *info[9] = { "No sense", "Recovered error", "Not ready",
  342. "Medium error", "Hardware error", "Illegal request",
  343. "Unit attention", "Data protect", "Blank check" };
  344. int i;
  345. struct request_sense *sense = cgc->sense;
  346. printk("pktcdvd:");
  347. for (i = 0; i < CDROM_PACKET_SIZE; i++)
  348. printk(" %02x", cgc->cmd[i]);
  349. printk(" - ");
  350. if (sense == NULL) {
  351. printk("no sense\n");
  352. return;
  353. }
  354. printk("sense %02x.%02x.%02x", sense->sense_key, sense->asc, sense->ascq);
  355. if (sense->sense_key > 8) {
  356. printk(" (INVALID)\n");
  357. return;
  358. }
  359. printk(" (%s)\n", info[sense->sense_key]);
  360. }
  361. /*
  362. * flush the drive cache to media
  363. */
  364. static int pkt_flush_cache(struct pktcdvd_device *pd)
  365. {
  366. struct packet_command cgc;
  367. init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
  368. cgc.cmd[0] = GPCMD_FLUSH_CACHE;
  369. cgc.quiet = 1;
  370. /*
  371. * the IMMED bit -- we default to not setting it, although that
  372. * would allow a much faster close, this is safer
  373. */
  374. #if 0
  375. cgc.cmd[1] = 1 << 1;
  376. #endif
  377. return pkt_generic_packet(pd, &cgc);
  378. }
  379. /*
  380. * speed is given as the normal factor, e.g. 4 for 4x
  381. */
  382. static int pkt_set_speed(struct pktcdvd_device *pd, unsigned write_speed, unsigned read_speed)
  383. {
  384. struct packet_command cgc;
  385. struct request_sense sense;
  386. int ret;
  387. init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
  388. cgc.sense = &sense;
  389. cgc.cmd[0] = GPCMD_SET_SPEED;
  390. cgc.cmd[2] = (read_speed >> 8) & 0xff;
  391. cgc.cmd[3] = read_speed & 0xff;
  392. cgc.cmd[4] = (write_speed >> 8) & 0xff;
  393. cgc.cmd[5] = write_speed & 0xff;
  394. if ((ret = pkt_generic_packet(pd, &cgc)))
  395. pkt_dump_sense(&cgc);
  396. return ret;
  397. }
  398. /*
  399. * Queue a bio for processing by the low-level CD device. Must be called
  400. * from process context.
  401. */
  402. static void pkt_queue_bio(struct pktcdvd_device *pd, struct bio *bio, int high_prio_read)
  403. {
  404. spin_lock(&pd->iosched.lock);
  405. if (bio_data_dir(bio) == READ) {
  406. pkt_add_list_last(bio, &pd->iosched.read_queue,
  407. &pd->iosched.read_queue_tail);
  408. if (high_prio_read)
  409. pd->iosched.high_prio_read = 1;
  410. } else {
  411. pkt_add_list_last(bio, &pd->iosched.write_queue,
  412. &pd->iosched.write_queue_tail);
  413. }
  414. spin_unlock(&pd->iosched.lock);
  415. atomic_set(&pd->iosched.attention, 1);
  416. wake_up(&pd->wqueue);
  417. }
  418. /*
  419. * Process the queued read/write requests. This function handles special
  420. * requirements for CDRW drives:
  421. * - A cache flush command must be inserted before a read request if the
  422. * previous request was a write.
  423. * - Switching between reading and writing is slow, so don't it more often
  424. * than necessary.
  425. * - Set the read speed according to current usage pattern. When only reading
  426. * from the device, it's best to use the highest possible read speed, but
  427. * when switching often between reading and writing, it's better to have the
  428. * same read and write speeds.
  429. * - Reads originating from user space should have higher priority than reads
  430. * originating from pkt_gather_data, because some process is usually waiting
  431. * on reads of the first kind.
  432. */
  433. static void pkt_iosched_process_queue(struct pktcdvd_device *pd)
  434. {
  435. request_queue_t *q;
  436. if (atomic_read(&pd->iosched.attention) == 0)
  437. return;
  438. atomic_set(&pd->iosched.attention, 0);
  439. q = bdev_get_queue(pd->bdev);
  440. for (;;) {
  441. struct bio *bio;
  442. int reads_queued, writes_queued, high_prio_read;
  443. spin_lock(&pd->iosched.lock);
  444. reads_queued = (pd->iosched.read_queue != NULL);
  445. writes_queued = (pd->iosched.write_queue != NULL);
  446. if (!reads_queued)
  447. pd->iosched.high_prio_read = 0;
  448. high_prio_read = pd->iosched.high_prio_read;
  449. spin_unlock(&pd->iosched.lock);
  450. if (!reads_queued && !writes_queued)
  451. break;
  452. if (pd->iosched.writing) {
  453. if (high_prio_read || (!writes_queued && reads_queued)) {
  454. if (atomic_read(&pd->cdrw.pending_bios) > 0) {
  455. VPRINTK("pktcdvd: write, waiting\n");
  456. break;
  457. }
  458. pkt_flush_cache(pd);
  459. pd->iosched.writing = 0;
  460. }
  461. } else {
  462. if (!reads_queued && writes_queued) {
  463. if (atomic_read(&pd->cdrw.pending_bios) > 0) {
  464. VPRINTK("pktcdvd: read, waiting\n");
  465. break;
  466. }
  467. pd->iosched.writing = 1;
  468. }
  469. }
  470. spin_lock(&pd->iosched.lock);
  471. if (pd->iosched.writing) {
  472. bio = pkt_get_list_first(&pd->iosched.write_queue,
  473. &pd->iosched.write_queue_tail);
  474. } else {
  475. bio = pkt_get_list_first(&pd->iosched.read_queue,
  476. &pd->iosched.read_queue_tail);
  477. }
  478. spin_unlock(&pd->iosched.lock);
  479. if (!bio)
  480. continue;
  481. if (bio_data_dir(bio) == READ)
  482. pd->iosched.successive_reads += bio->bi_size >> 10;
  483. else
  484. pd->iosched.successive_reads = 0;
  485. if (pd->iosched.successive_reads >= HI_SPEED_SWITCH) {
  486. if (pd->read_speed == pd->write_speed) {
  487. pd->read_speed = MAX_SPEED;
  488. pkt_set_speed(pd, pd->write_speed, pd->read_speed);
  489. }
  490. } else {
  491. if (pd->read_speed != pd->write_speed) {
  492. pd->read_speed = pd->write_speed;
  493. pkt_set_speed(pd, pd->write_speed, pd->read_speed);
  494. }
  495. }
  496. atomic_inc(&pd->cdrw.pending_bios);
  497. generic_make_request(bio);
  498. }
  499. }
  500. /*
  501. * Special care is needed if the underlying block device has a small
  502. * max_phys_segments value.
  503. */
  504. static int pkt_set_segment_merging(struct pktcdvd_device *pd, request_queue_t *q)
  505. {
  506. if ((pd->settings.size << 9) / CD_FRAMESIZE <= q->max_phys_segments) {
  507. /*
  508. * The cdrom device can handle one segment/frame
  509. */
  510. clear_bit(PACKET_MERGE_SEGS, &pd->flags);
  511. return 0;
  512. } else if ((pd->settings.size << 9) / PAGE_SIZE <= q->max_phys_segments) {
  513. /*
  514. * We can handle this case at the expense of some extra memory
  515. * copies during write operations
  516. */
  517. set_bit(PACKET_MERGE_SEGS, &pd->flags);
  518. return 0;
  519. } else {
  520. printk("pktcdvd: cdrom max_phys_segments too small\n");
  521. return -EIO;
  522. }
  523. }
  524. /*
  525. * Copy CD_FRAMESIZE bytes from src_bio into a destination page
  526. */
  527. static void pkt_copy_bio_data(struct bio *src_bio, int seg, int offs, struct page *dst_page, int dst_offs)
  528. {
  529. unsigned int copy_size = CD_FRAMESIZE;
  530. while (copy_size > 0) {
  531. struct bio_vec *src_bvl = bio_iovec_idx(src_bio, seg);
  532. void *vfrom = kmap_atomic(src_bvl->bv_page, KM_USER0) +
  533. src_bvl->bv_offset + offs;
  534. void *vto = page_address(dst_page) + dst_offs;
  535. int len = min_t(int, copy_size, src_bvl->bv_len - offs);
  536. BUG_ON(len < 0);
  537. memcpy(vto, vfrom, len);
  538. kunmap_atomic(vfrom, KM_USER0);
  539. seg++;
  540. offs = 0;
  541. dst_offs += len;
  542. copy_size -= len;
  543. }
  544. }
  545. /*
  546. * Copy all data for this packet to pkt->pages[], so that
  547. * a) The number of required segments for the write bio is minimized, which
  548. * is necessary for some scsi controllers.
  549. * b) The data can be used as cache to avoid read requests if we receive a
  550. * new write request for the same zone.
  551. */
  552. static void pkt_make_local_copy(struct packet_data *pkt, struct page **pages, int *offsets)
  553. {
  554. int f, p, offs;
  555. /* Copy all data to pkt->pages[] */
  556. p = 0;
  557. offs = 0;
  558. for (f = 0; f < pkt->frames; f++) {
  559. if (pages[f] != pkt->pages[p]) {
  560. void *vfrom = kmap_atomic(pages[f], KM_USER0) + offsets[f];
  561. void *vto = page_address(pkt->pages[p]) + offs;
  562. memcpy(vto, vfrom, CD_FRAMESIZE);
  563. kunmap_atomic(vfrom, KM_USER0);
  564. pages[f] = pkt->pages[p];
  565. offsets[f] = offs;
  566. } else {
  567. BUG_ON(offsets[f] != offs);
  568. }
  569. offs += CD_FRAMESIZE;
  570. if (offs >= PAGE_SIZE) {
  571. BUG_ON(offs > PAGE_SIZE);
  572. offs = 0;
  573. p++;
  574. }
  575. }
  576. }
  577. static int pkt_end_io_read(struct bio *bio, unsigned int bytes_done, int err)
  578. {
  579. struct packet_data *pkt = bio->bi_private;
  580. struct pktcdvd_device *pd = pkt->pd;
  581. BUG_ON(!pd);
  582. if (bio->bi_size)
  583. return 1;
  584. VPRINTK("pkt_end_io_read: bio=%p sec0=%llx sec=%llx err=%d\n", bio,
  585. (unsigned long long)pkt->sector, (unsigned long long)bio->bi_sector, err);
  586. if (err)
  587. atomic_inc(&pkt->io_errors);
  588. if (atomic_dec_and_test(&pkt->io_wait)) {
  589. atomic_inc(&pkt->run_sm);
  590. wake_up(&pd->wqueue);
  591. }
  592. pkt_bio_finished(pd);
  593. return 0;
  594. }
  595. static int pkt_end_io_packet_write(struct bio *bio, unsigned int bytes_done, int err)
  596. {
  597. struct packet_data *pkt = bio->bi_private;
  598. struct pktcdvd_device *pd = pkt->pd;
  599. BUG_ON(!pd);
  600. if (bio->bi_size)
  601. return 1;
  602. VPRINTK("pkt_end_io_packet_write: id=%d, err=%d\n", pkt->id, err);
  603. pd->stats.pkt_ended++;
  604. pkt_bio_finished(pd);
  605. atomic_dec(&pkt->io_wait);
  606. atomic_inc(&pkt->run_sm);
  607. wake_up(&pd->wqueue);
  608. return 0;
  609. }
  610. /*
  611. * Schedule reads for the holes in a packet
  612. */
  613. static void pkt_gather_data(struct pktcdvd_device *pd, struct packet_data *pkt)
  614. {
  615. int frames_read = 0;
  616. struct bio *bio;
  617. int f;
  618. char written[PACKET_MAX_SIZE];
  619. BUG_ON(!pkt->orig_bios);
  620. atomic_set(&pkt->io_wait, 0);
  621. atomic_set(&pkt->io_errors, 0);
  622. if (pkt->cache_valid) {
  623. VPRINTK("pkt_gather_data: zone %llx cached\n",
  624. (unsigned long long)pkt->sector);
  625. goto out_account;
  626. }
  627. /*
  628. * Figure out which frames we need to read before we can write.
  629. */
  630. memset(written, 0, sizeof(written));
  631. spin_lock(&pkt->lock);
  632. for (bio = pkt->orig_bios; bio; bio = bio->bi_next) {
  633. int first_frame = (bio->bi_sector - pkt->sector) / (CD_FRAMESIZE >> 9);
  634. int num_frames = bio->bi_size / CD_FRAMESIZE;
  635. BUG_ON(first_frame < 0);
  636. BUG_ON(first_frame + num_frames > pkt->frames);
  637. for (f = first_frame; f < first_frame + num_frames; f++)
  638. written[f] = 1;
  639. }
  640. spin_unlock(&pkt->lock);
  641. /*
  642. * Schedule reads for missing parts of the packet.
  643. */
  644. for (f = 0; f < pkt->frames; f++) {
  645. int p, offset;
  646. if (written[f])
  647. continue;
  648. bio = pkt->r_bios[f];
  649. bio_init(bio);
  650. bio->bi_max_vecs = 1;
  651. bio->bi_sector = pkt->sector + f * (CD_FRAMESIZE >> 9);
  652. bio->bi_bdev = pd->bdev;
  653. bio->bi_end_io = pkt_end_io_read;
  654. bio->bi_private = pkt;
  655. p = (f * CD_FRAMESIZE) / PAGE_SIZE;
  656. offset = (f * CD_FRAMESIZE) % PAGE_SIZE;
  657. VPRINTK("pkt_gather_data: Adding frame %d, page:%p offs:%d\n",
  658. f, pkt->pages[p], offset);
  659. if (!bio_add_page(bio, pkt->pages[p], CD_FRAMESIZE, offset))
  660. BUG();
  661. atomic_inc(&pkt->io_wait);
  662. bio->bi_rw = READ;
  663. pkt_queue_bio(pd, bio, 0);
  664. frames_read++;
  665. }
  666. out_account:
  667. VPRINTK("pkt_gather_data: need %d frames for zone %llx\n",
  668. frames_read, (unsigned long long)pkt->sector);
  669. pd->stats.pkt_started++;
  670. pd->stats.secs_rg += frames_read * (CD_FRAMESIZE >> 9);
  671. pd->stats.secs_w += pd->settings.size;
  672. }
  673. /*
  674. * Find a packet matching zone, or the least recently used packet if
  675. * there is no match.
  676. */
  677. static struct packet_data *pkt_get_packet_data(struct pktcdvd_device *pd, int zone)
  678. {
  679. struct packet_data *pkt;
  680. list_for_each_entry(pkt, &pd->cdrw.pkt_free_list, list) {
  681. if (pkt->sector == zone || pkt->list.next == &pd->cdrw.pkt_free_list) {
  682. list_del_init(&pkt->list);
  683. if (pkt->sector != zone)
  684. pkt->cache_valid = 0;
  685. break;
  686. }
  687. }
  688. return pkt;
  689. }
  690. static void pkt_put_packet_data(struct pktcdvd_device *pd, struct packet_data *pkt)
  691. {
  692. if (pkt->cache_valid) {
  693. list_add(&pkt->list, &pd->cdrw.pkt_free_list);
  694. } else {
  695. list_add_tail(&pkt->list, &pd->cdrw.pkt_free_list);
  696. }
  697. }
  698. /*
  699. * recover a failed write, query for relocation if possible
  700. *
  701. * returns 1 if recovery is possible, or 0 if not
  702. *
  703. */
  704. static int pkt_start_recovery(struct packet_data *pkt)
  705. {
  706. /*
  707. * FIXME. We need help from the file system to implement
  708. * recovery handling.
  709. */
  710. return 0;
  711. #if 0
  712. struct request *rq = pkt->rq;
  713. struct pktcdvd_device *pd = rq->rq_disk->private_data;
  714. struct block_device *pkt_bdev;
  715. struct super_block *sb = NULL;
  716. unsigned long old_block, new_block;
  717. sector_t new_sector;
  718. pkt_bdev = bdget(kdev_t_to_nr(pd->pkt_dev));
  719. if (pkt_bdev) {
  720. sb = get_super(pkt_bdev);
  721. bdput(pkt_bdev);
  722. }
  723. if (!sb)
  724. return 0;
  725. if (!sb->s_op || !sb->s_op->relocate_blocks)
  726. goto out;
  727. old_block = pkt->sector / (CD_FRAMESIZE >> 9);
  728. if (sb->s_op->relocate_blocks(sb, old_block, &new_block))
  729. goto out;
  730. new_sector = new_block * (CD_FRAMESIZE >> 9);
  731. pkt->sector = new_sector;
  732. pkt->bio->bi_sector = new_sector;
  733. pkt->bio->bi_next = NULL;
  734. pkt->bio->bi_flags = 1 << BIO_UPTODATE;
  735. pkt->bio->bi_idx = 0;
  736. BUG_ON(pkt->bio->bi_rw != (1 << BIO_RW));
  737. BUG_ON(pkt->bio->bi_vcnt != pkt->frames);
  738. BUG_ON(pkt->bio->bi_size != pkt->frames * CD_FRAMESIZE);
  739. BUG_ON(pkt->bio->bi_end_io != pkt_end_io_packet_write);
  740. BUG_ON(pkt->bio->bi_private != pkt);
  741. drop_super(sb);
  742. return 1;
  743. out:
  744. drop_super(sb);
  745. return 0;
  746. #endif
  747. }
  748. static inline void pkt_set_state(struct packet_data *pkt, enum packet_data_state state)
  749. {
  750. #if PACKET_DEBUG > 1
  751. static const char *state_name[] = {
  752. "IDLE", "WAITING", "READ_WAIT", "WRITE_WAIT", "RECOVERY", "FINISHED"
  753. };
  754. enum packet_data_state old_state = pkt->state;
  755. VPRINTK("pkt %2d : s=%6llx %s -> %s\n", pkt->id, (unsigned long long)pkt->sector,
  756. state_name[old_state], state_name[state]);
  757. #endif
  758. pkt->state = state;
  759. }
  760. /*
  761. * Scan the work queue to see if we can start a new packet.
  762. * returns non-zero if any work was done.
  763. */
  764. static int pkt_handle_queue(struct pktcdvd_device *pd)
  765. {
  766. struct packet_data *pkt, *p;
  767. struct bio *bio = NULL;
  768. sector_t zone = 0; /* Suppress gcc warning */
  769. struct pkt_rb_node *node, *first_node;
  770. struct rb_node *n;
  771. VPRINTK("handle_queue\n");
  772. atomic_set(&pd->scan_queue, 0);
  773. if (list_empty(&pd->cdrw.pkt_free_list)) {
  774. VPRINTK("handle_queue: no pkt\n");
  775. return 0;
  776. }
  777. /*
  778. * Try to find a zone we are not already working on.
  779. */
  780. spin_lock(&pd->lock);
  781. first_node = pkt_rbtree_find(pd, pd->current_sector);
  782. if (!first_node) {
  783. n = rb_first(&pd->bio_queue);
  784. if (n)
  785. first_node = rb_entry(n, struct pkt_rb_node, rb_node);
  786. }
  787. node = first_node;
  788. while (node) {
  789. bio = node->bio;
  790. zone = ZONE(bio->bi_sector, pd);
  791. list_for_each_entry(p, &pd->cdrw.pkt_active_list, list) {
  792. if (p->sector == zone)
  793. goto try_next_bio;
  794. }
  795. break;
  796. try_next_bio:
  797. node = pkt_rbtree_next(node);
  798. if (!node) {
  799. n = rb_first(&pd->bio_queue);
  800. if (n)
  801. node = rb_entry(n, struct pkt_rb_node, rb_node);
  802. }
  803. if (node == first_node)
  804. node = NULL;
  805. }
  806. spin_unlock(&pd->lock);
  807. if (!bio) {
  808. VPRINTK("handle_queue: no bio\n");
  809. return 0;
  810. }
  811. pkt = pkt_get_packet_data(pd, zone);
  812. BUG_ON(!pkt);
  813. pd->current_sector = zone + pd->settings.size;
  814. pkt->sector = zone;
  815. pkt->frames = pd->settings.size >> 2;
  816. BUG_ON(pkt->frames > PACKET_MAX_SIZE);
  817. pkt->write_size = 0;
  818. /*
  819. * Scan work queue for bios in the same zone and link them
  820. * to this packet.
  821. */
  822. spin_lock(&pd->lock);
  823. VPRINTK("pkt_handle_queue: looking for zone %llx\n", (unsigned long long)zone);
  824. while ((node = pkt_rbtree_find(pd, zone)) != NULL) {
  825. bio = node->bio;
  826. VPRINTK("pkt_handle_queue: found zone=%llx\n",
  827. (unsigned long long)ZONE(bio->bi_sector, pd));
  828. if (ZONE(bio->bi_sector, pd) != zone)
  829. break;
  830. pkt_rbtree_erase(pd, node);
  831. spin_lock(&pkt->lock);
  832. pkt_add_list_last(bio, &pkt->orig_bios, &pkt->orig_bios_tail);
  833. pkt->write_size += bio->bi_size / CD_FRAMESIZE;
  834. spin_unlock(&pkt->lock);
  835. }
  836. spin_unlock(&pd->lock);
  837. pkt->sleep_time = max(PACKET_WAIT_TIME, 1);
  838. pkt_set_state(pkt, PACKET_WAITING_STATE);
  839. atomic_set(&pkt->run_sm, 1);
  840. spin_lock(&pd->cdrw.active_list_lock);
  841. list_add(&pkt->list, &pd->cdrw.pkt_active_list);
  842. spin_unlock(&pd->cdrw.active_list_lock);
  843. return 1;
  844. }
  845. /*
  846. * Assemble a bio to write one packet and queue the bio for processing
  847. * by the underlying block device.
  848. */
  849. static void pkt_start_write(struct pktcdvd_device *pd, struct packet_data *pkt)
  850. {
  851. struct bio *bio;
  852. struct page *pages[PACKET_MAX_SIZE];
  853. int offsets[PACKET_MAX_SIZE];
  854. int f;
  855. int frames_write;
  856. for (f = 0; f < pkt->frames; f++) {
  857. pages[f] = pkt->pages[(f * CD_FRAMESIZE) / PAGE_SIZE];
  858. offsets[f] = (f * CD_FRAMESIZE) % PAGE_SIZE;
  859. }
  860. /*
  861. * Fill-in pages[] and offsets[] with data from orig_bios.
  862. */
  863. frames_write = 0;
  864. spin_lock(&pkt->lock);
  865. for (bio = pkt->orig_bios; bio; bio = bio->bi_next) {
  866. int segment = bio->bi_idx;
  867. int src_offs = 0;
  868. int first_frame = (bio->bi_sector - pkt->sector) / (CD_FRAMESIZE >> 9);
  869. int num_frames = bio->bi_size / CD_FRAMESIZE;
  870. BUG_ON(first_frame < 0);
  871. BUG_ON(first_frame + num_frames > pkt->frames);
  872. for (f = first_frame; f < first_frame + num_frames; f++) {
  873. struct bio_vec *src_bvl = bio_iovec_idx(bio, segment);
  874. while (src_offs >= src_bvl->bv_len) {
  875. src_offs -= src_bvl->bv_len;
  876. segment++;
  877. BUG_ON(segment >= bio->bi_vcnt);
  878. src_bvl = bio_iovec_idx(bio, segment);
  879. }
  880. if (src_bvl->bv_len - src_offs >= CD_FRAMESIZE) {
  881. pages[f] = src_bvl->bv_page;
  882. offsets[f] = src_bvl->bv_offset + src_offs;
  883. } else {
  884. pkt_copy_bio_data(bio, segment, src_offs,
  885. pages[f], offsets[f]);
  886. }
  887. src_offs += CD_FRAMESIZE;
  888. frames_write++;
  889. }
  890. }
  891. pkt_set_state(pkt, PACKET_WRITE_WAIT_STATE);
  892. spin_unlock(&pkt->lock);
  893. VPRINTK("pkt_start_write: Writing %d frames for zone %llx\n",
  894. frames_write, (unsigned long long)pkt->sector);
  895. BUG_ON(frames_write != pkt->write_size);
  896. if (test_bit(PACKET_MERGE_SEGS, &pd->flags) || (pkt->write_size < pkt->frames)) {
  897. pkt_make_local_copy(pkt, pages, offsets);
  898. pkt->cache_valid = 1;
  899. } else {
  900. pkt->cache_valid = 0;
  901. }
  902. /* Start the write request */
  903. bio_init(pkt->w_bio);
  904. pkt->w_bio->bi_max_vecs = PACKET_MAX_SIZE;
  905. pkt->w_bio->bi_sector = pkt->sector;
  906. pkt->w_bio->bi_bdev = pd->bdev;
  907. pkt->w_bio->bi_end_io = pkt_end_io_packet_write;
  908. pkt->w_bio->bi_private = pkt;
  909. for (f = 0; f < pkt->frames; f++) {
  910. if ((f + 1 < pkt->frames) && (pages[f + 1] == pages[f]) &&
  911. (offsets[f + 1] = offsets[f] + CD_FRAMESIZE)) {
  912. if (!bio_add_page(pkt->w_bio, pages[f], CD_FRAMESIZE * 2, offsets[f]))
  913. BUG();
  914. f++;
  915. } else {
  916. if (!bio_add_page(pkt->w_bio, pages[f], CD_FRAMESIZE, offsets[f]))
  917. BUG();
  918. }
  919. }
  920. VPRINTK("pktcdvd: vcnt=%d\n", pkt->w_bio->bi_vcnt);
  921. atomic_set(&pkt->io_wait, 1);
  922. pkt->w_bio->bi_rw = WRITE;
  923. pkt_queue_bio(pd, pkt->w_bio, 0);
  924. }
  925. static void pkt_finish_packet(struct packet_data *pkt, int uptodate)
  926. {
  927. struct bio *bio, *next;
  928. if (!uptodate)
  929. pkt->cache_valid = 0;
  930. /* Finish all bios corresponding to this packet */
  931. bio = pkt->orig_bios;
  932. while (bio) {
  933. next = bio->bi_next;
  934. bio->bi_next = NULL;
  935. bio_endio(bio, bio->bi_size, uptodate ? 0 : -EIO);
  936. bio = next;
  937. }
  938. pkt->orig_bios = pkt->orig_bios_tail = NULL;
  939. }
  940. static void pkt_run_state_machine(struct pktcdvd_device *pd, struct packet_data *pkt)
  941. {
  942. int uptodate;
  943. VPRINTK("run_state_machine: pkt %d\n", pkt->id);
  944. for (;;) {
  945. switch (pkt->state) {
  946. case PACKET_WAITING_STATE:
  947. if ((pkt->write_size < pkt->frames) && (pkt->sleep_time > 0))
  948. return;
  949. pkt->sleep_time = 0;
  950. pkt_gather_data(pd, pkt);
  951. pkt_set_state(pkt, PACKET_READ_WAIT_STATE);
  952. break;
  953. case PACKET_READ_WAIT_STATE:
  954. if (atomic_read(&pkt->io_wait) > 0)
  955. return;
  956. if (atomic_read(&pkt->io_errors) > 0) {
  957. pkt_set_state(pkt, PACKET_RECOVERY_STATE);
  958. } else {
  959. pkt_start_write(pd, pkt);
  960. }
  961. break;
  962. case PACKET_WRITE_WAIT_STATE:
  963. if (atomic_read(&pkt->io_wait) > 0)
  964. return;
  965. if (test_bit(BIO_UPTODATE, &pkt->w_bio->bi_flags)) {
  966. pkt_set_state(pkt, PACKET_FINISHED_STATE);
  967. } else {
  968. pkt_set_state(pkt, PACKET_RECOVERY_STATE);
  969. }
  970. break;
  971. case PACKET_RECOVERY_STATE:
  972. if (pkt_start_recovery(pkt)) {
  973. pkt_start_write(pd, pkt);
  974. } else {
  975. VPRINTK("No recovery possible\n");
  976. pkt_set_state(pkt, PACKET_FINISHED_STATE);
  977. }
  978. break;
  979. case PACKET_FINISHED_STATE:
  980. uptodate = test_bit(BIO_UPTODATE, &pkt->w_bio->bi_flags);
  981. pkt_finish_packet(pkt, uptodate);
  982. return;
  983. default:
  984. BUG();
  985. break;
  986. }
  987. }
  988. }
  989. static void pkt_handle_packets(struct pktcdvd_device *pd)
  990. {
  991. struct packet_data *pkt, *next;
  992. VPRINTK("pkt_handle_packets\n");
  993. /*
  994. * Run state machine for active packets
  995. */
  996. list_for_each_entry(pkt, &pd->cdrw.pkt_active_list, list) {
  997. if (atomic_read(&pkt->run_sm) > 0) {
  998. atomic_set(&pkt->run_sm, 0);
  999. pkt_run_state_machine(pd, pkt);
  1000. }
  1001. }
  1002. /*
  1003. * Move no longer active packets to the free list
  1004. */
  1005. spin_lock(&pd->cdrw.active_list_lock);
  1006. list_for_each_entry_safe(pkt, next, &pd->cdrw.pkt_active_list, list) {
  1007. if (pkt->state == PACKET_FINISHED_STATE) {
  1008. list_del(&pkt->list);
  1009. pkt_put_packet_data(pd, pkt);
  1010. pkt_set_state(pkt, PACKET_IDLE_STATE);
  1011. atomic_set(&pd->scan_queue, 1);
  1012. }
  1013. }
  1014. spin_unlock(&pd->cdrw.active_list_lock);
  1015. }
  1016. static void pkt_count_states(struct pktcdvd_device *pd, int *states)
  1017. {
  1018. struct packet_data *pkt;
  1019. int i;
  1020. for (i = 0; i <= PACKET_NUM_STATES; i++)
  1021. states[i] = 0;
  1022. spin_lock(&pd->cdrw.active_list_lock);
  1023. list_for_each_entry(pkt, &pd->cdrw.pkt_active_list, list) {
  1024. states[pkt->state]++;
  1025. }
  1026. spin_unlock(&pd->cdrw.active_list_lock);
  1027. }
  1028. /*
  1029. * kcdrwd is woken up when writes have been queued for one of our
  1030. * registered devices
  1031. */
  1032. static int kcdrwd(void *foobar)
  1033. {
  1034. struct pktcdvd_device *pd = foobar;
  1035. struct packet_data *pkt;
  1036. long min_sleep_time, residue;
  1037. set_user_nice(current, -20);
  1038. for (;;) {
  1039. DECLARE_WAITQUEUE(wait, current);
  1040. /*
  1041. * Wait until there is something to do
  1042. */
  1043. add_wait_queue(&pd->wqueue, &wait);
  1044. for (;;) {
  1045. set_current_state(TASK_INTERRUPTIBLE);
  1046. /* Check if we need to run pkt_handle_queue */
  1047. if (atomic_read(&pd->scan_queue) > 0)
  1048. goto work_to_do;
  1049. /* Check if we need to run the state machine for some packet */
  1050. list_for_each_entry(pkt, &pd->cdrw.pkt_active_list, list) {
  1051. if (atomic_read(&pkt->run_sm) > 0)
  1052. goto work_to_do;
  1053. }
  1054. /* Check if we need to process the iosched queues */
  1055. if (atomic_read(&pd->iosched.attention) != 0)
  1056. goto work_to_do;
  1057. /* Otherwise, go to sleep */
  1058. if (PACKET_DEBUG > 1) {
  1059. int states[PACKET_NUM_STATES];
  1060. pkt_count_states(pd, states);
  1061. VPRINTK("kcdrwd: i:%d ow:%d rw:%d ww:%d rec:%d fin:%d\n",
  1062. states[0], states[1], states[2], states[3],
  1063. states[4], states[5]);
  1064. }
  1065. min_sleep_time = MAX_SCHEDULE_TIMEOUT;
  1066. list_for_each_entry(pkt, &pd->cdrw.pkt_active_list, list) {
  1067. if (pkt->sleep_time && pkt->sleep_time < min_sleep_time)
  1068. min_sleep_time = pkt->sleep_time;
  1069. }
  1070. generic_unplug_device(bdev_get_queue(pd->bdev));
  1071. VPRINTK("kcdrwd: sleeping\n");
  1072. residue = schedule_timeout(min_sleep_time);
  1073. VPRINTK("kcdrwd: wake up\n");
  1074. /* make swsusp happy with our thread */
  1075. if (current->flags & PF_FREEZE)
  1076. refrigerator(PF_FREEZE);
  1077. list_for_each_entry(pkt, &pd->cdrw.pkt_active_list, list) {
  1078. if (!pkt->sleep_time)
  1079. continue;
  1080. pkt->sleep_time -= min_sleep_time - residue;
  1081. if (pkt->sleep_time <= 0) {
  1082. pkt->sleep_time = 0;
  1083. atomic_inc(&pkt->run_sm);
  1084. }
  1085. }
  1086. if (signal_pending(current)) {
  1087. flush_signals(current);
  1088. }
  1089. if (kthread_should_stop())
  1090. break;
  1091. }
  1092. work_to_do:
  1093. set_current_state(TASK_RUNNING);
  1094. remove_wait_queue(&pd->wqueue, &wait);
  1095. if (kthread_should_stop())
  1096. break;
  1097. /*
  1098. * if pkt_handle_queue returns true, we can queue
  1099. * another request.
  1100. */
  1101. while (pkt_handle_queue(pd))
  1102. ;
  1103. /*
  1104. * Handle packet state machine
  1105. */
  1106. pkt_handle_packets(pd);
  1107. /*
  1108. * Handle iosched queues
  1109. */
  1110. pkt_iosched_process_queue(pd);
  1111. }
  1112. return 0;
  1113. }
  1114. static void pkt_print_settings(struct pktcdvd_device *pd)
  1115. {
  1116. printk("pktcdvd: %s packets, ", pd->settings.fp ? "Fixed" : "Variable");
  1117. printk("%u blocks, ", pd->settings.size >> 2);
  1118. printk("Mode-%c disc\n", pd->settings.block_mode == 8 ? '1' : '2');
  1119. }
  1120. static int pkt_mode_sense(struct pktcdvd_device *pd, struct packet_command *cgc, int page_code, int page_control)
  1121. {
  1122. memset(cgc->cmd, 0, sizeof(cgc->cmd));
  1123. cgc->cmd[0] = GPCMD_MODE_SENSE_10;
  1124. cgc->cmd[2] = page_code | (page_control << 6);
  1125. cgc->cmd[7] = cgc->buflen >> 8;
  1126. cgc->cmd[8] = cgc->buflen & 0xff;
  1127. cgc->data_direction = CGC_DATA_READ;
  1128. return pkt_generic_packet(pd, cgc);
  1129. }
  1130. static int pkt_mode_select(struct pktcdvd_device *pd, struct packet_command *cgc)
  1131. {
  1132. memset(cgc->cmd, 0, sizeof(cgc->cmd));
  1133. memset(cgc->buffer, 0, 2);
  1134. cgc->cmd[0] = GPCMD_MODE_SELECT_10;
  1135. cgc->cmd[1] = 0x10; /* PF */
  1136. cgc->cmd[7] = cgc->buflen >> 8;
  1137. cgc->cmd[8] = cgc->buflen & 0xff;
  1138. cgc->data_direction = CGC_DATA_WRITE;
  1139. return pkt_generic_packet(pd, cgc);
  1140. }
  1141. static int pkt_get_disc_info(struct pktcdvd_device *pd, disc_information *di)
  1142. {
  1143. struct packet_command cgc;
  1144. int ret;
  1145. /* set up command and get the disc info */
  1146. init_cdrom_command(&cgc, di, sizeof(*di), CGC_DATA_READ);
  1147. cgc.cmd[0] = GPCMD_READ_DISC_INFO;
  1148. cgc.cmd[8] = cgc.buflen = 2;
  1149. cgc.quiet = 1;
  1150. if ((ret = pkt_generic_packet(pd, &cgc)))
  1151. return ret;
  1152. /* not all drives have the same disc_info length, so requeue
  1153. * packet with the length the drive tells us it can supply
  1154. */
  1155. cgc.buflen = be16_to_cpu(di->disc_information_length) +
  1156. sizeof(di->disc_information_length);
  1157. if (cgc.buflen > sizeof(disc_information))
  1158. cgc.buflen = sizeof(disc_information);
  1159. cgc.cmd[8] = cgc.buflen;
  1160. return pkt_generic_packet(pd, &cgc);
  1161. }
  1162. static int pkt_get_track_info(struct pktcdvd_device *pd, __u16 track, __u8 type, track_information *ti)
  1163. {
  1164. struct packet_command cgc;
  1165. int ret;
  1166. init_cdrom_command(&cgc, ti, 8, CGC_DATA_READ);
  1167. cgc.cmd[0] = GPCMD_READ_TRACK_RZONE_INFO;
  1168. cgc.cmd[1] = type & 3;
  1169. cgc.cmd[4] = (track & 0xff00) >> 8;
  1170. cgc.cmd[5] = track & 0xff;
  1171. cgc.cmd[8] = 8;
  1172. cgc.quiet = 1;
  1173. if ((ret = pkt_generic_packet(pd, &cgc)))
  1174. return ret;
  1175. cgc.buflen = be16_to_cpu(ti->track_information_length) +
  1176. sizeof(ti->track_information_length);
  1177. if (cgc.buflen > sizeof(track_information))
  1178. cgc.buflen = sizeof(track_information);
  1179. cgc.cmd[8] = cgc.buflen;
  1180. return pkt_generic_packet(pd, &cgc);
  1181. }
  1182. static int pkt_get_last_written(struct pktcdvd_device *pd, long *last_written)
  1183. {
  1184. disc_information di;
  1185. track_information ti;
  1186. __u32 last_track;
  1187. int ret = -1;
  1188. if ((ret = pkt_get_disc_info(pd, &di)))
  1189. return ret;
  1190. last_track = (di.last_track_msb << 8) | di.last_track_lsb;
  1191. if ((ret = pkt_get_track_info(pd, last_track, 1, &ti)))
  1192. return ret;
  1193. /* if this track is blank, try the previous. */
  1194. if (ti.blank) {
  1195. last_track--;
  1196. if ((ret = pkt_get_track_info(pd, last_track, 1, &ti)))
  1197. return ret;
  1198. }
  1199. /* if last recorded field is valid, return it. */
  1200. if (ti.lra_v) {
  1201. *last_written = be32_to_cpu(ti.last_rec_address);
  1202. } else {
  1203. /* make it up instead */
  1204. *last_written = be32_to_cpu(ti.track_start) +
  1205. be32_to_cpu(ti.track_size);
  1206. if (ti.free_blocks)
  1207. *last_written -= (be32_to_cpu(ti.free_blocks) + 7);
  1208. }
  1209. return 0;
  1210. }
  1211. /*
  1212. * write mode select package based on pd->settings
  1213. */
  1214. static int pkt_set_write_settings(struct pktcdvd_device *pd)
  1215. {
  1216. struct packet_command cgc;
  1217. struct request_sense sense;
  1218. write_param_page *wp;
  1219. char buffer[128];
  1220. int ret, size;
  1221. /* doesn't apply to DVD+RW or DVD-RAM */
  1222. if ((pd->mmc3_profile == 0x1a) || (pd->mmc3_profile == 0x12))
  1223. return 0;
  1224. memset(buffer, 0, sizeof(buffer));
  1225. init_cdrom_command(&cgc, buffer, sizeof(*wp), CGC_DATA_READ);
  1226. cgc.sense = &sense;
  1227. if ((ret = pkt_mode_sense(pd, &cgc, GPMODE_WRITE_PARMS_PAGE, 0))) {
  1228. pkt_dump_sense(&cgc);
  1229. return ret;
  1230. }
  1231. size = 2 + ((buffer[0] << 8) | (buffer[1] & 0xff));
  1232. pd->mode_offset = (buffer[6] << 8) | (buffer[7] & 0xff);
  1233. if (size > sizeof(buffer))
  1234. size = sizeof(buffer);
  1235. /*
  1236. * now get it all
  1237. */
  1238. init_cdrom_command(&cgc, buffer, size, CGC_DATA_READ);
  1239. cgc.sense = &sense;
  1240. if ((ret = pkt_mode_sense(pd, &cgc, GPMODE_WRITE_PARMS_PAGE, 0))) {
  1241. pkt_dump_sense(&cgc);
  1242. return ret;
  1243. }
  1244. /*
  1245. * write page is offset header + block descriptor length
  1246. */
  1247. wp = (write_param_page *) &buffer[sizeof(struct mode_page_header) + pd->mode_offset];
  1248. wp->fp = pd->settings.fp;
  1249. wp->track_mode = pd->settings.track_mode;
  1250. wp->write_type = pd->settings.write_type;
  1251. wp->data_block_type = pd->settings.block_mode;
  1252. wp->multi_session = 0;
  1253. #ifdef PACKET_USE_LS
  1254. wp->link_size = 7;
  1255. wp->ls_v = 1;
  1256. #endif
  1257. if (wp->data_block_type == PACKET_BLOCK_MODE1) {
  1258. wp->session_format = 0;
  1259. wp->subhdr2 = 0x20;
  1260. } else if (wp->data_block_type == PACKET_BLOCK_MODE2) {
  1261. wp->session_format = 0x20;
  1262. wp->subhdr2 = 8;
  1263. #if 0
  1264. wp->mcn[0] = 0x80;
  1265. memcpy(&wp->mcn[1], PACKET_MCN, sizeof(wp->mcn) - 1);
  1266. #endif
  1267. } else {
  1268. /*
  1269. * paranoia
  1270. */
  1271. printk("pktcdvd: write mode wrong %d\n", wp->data_block_type);
  1272. return 1;
  1273. }
  1274. wp->packet_size = cpu_to_be32(pd->settings.size >> 2);
  1275. cgc.buflen = cgc.cmd[8] = size;
  1276. if ((ret = pkt_mode_select(pd, &cgc))) {
  1277. pkt_dump_sense(&cgc);
  1278. return ret;
  1279. }
  1280. pkt_print_settings(pd);
  1281. return 0;
  1282. }
  1283. /*
  1284. * 0 -- we can write to this track, 1 -- we can't
  1285. */
  1286. static int pkt_good_track(track_information *ti)
  1287. {
  1288. /*
  1289. * only good for CD-RW at the moment, not DVD-RW
  1290. */
  1291. /*
  1292. * FIXME: only for FP
  1293. */
  1294. if (ti->fp == 0)
  1295. return 0;
  1296. /*
  1297. * "good" settings as per Mt Fuji.
  1298. */
  1299. if (ti->rt == 0 && ti->blank == 0 && ti->packet == 1)
  1300. return 0;
  1301. if (ti->rt == 0 && ti->blank == 1 && ti->packet == 1)
  1302. return 0;
  1303. if (ti->rt == 1 && ti->blank == 0 && ti->packet == 1)
  1304. return 0;
  1305. printk("pktcdvd: bad state %d-%d-%d\n", ti->rt, ti->blank, ti->packet);
  1306. return 1;
  1307. }
  1308. /*
  1309. * 0 -- we can write to this disc, 1 -- we can't
  1310. */
  1311. static int pkt_good_disc(struct pktcdvd_device *pd, disc_information *di)
  1312. {
  1313. switch (pd->mmc3_profile) {
  1314. case 0x0a: /* CD-RW */
  1315. case 0xffff: /* MMC3 not supported */
  1316. break;
  1317. case 0x1a: /* DVD+RW */
  1318. case 0x13: /* DVD-RW */
  1319. case 0x12: /* DVD-RAM */
  1320. return 0;
  1321. default:
  1322. printk("pktcdvd: Wrong disc profile (%x)\n", pd->mmc3_profile);
  1323. return 1;
  1324. }
  1325. /*
  1326. * for disc type 0xff we should probably reserve a new track.
  1327. * but i'm not sure, should we leave this to user apps? probably.
  1328. */
  1329. if (di->disc_type == 0xff) {
  1330. printk("pktcdvd: Unknown disc. No track?\n");
  1331. return 1;
  1332. }
  1333. if (di->disc_type != 0x20 && di->disc_type != 0) {
  1334. printk("pktcdvd: Wrong disc type (%x)\n", di->disc_type);
  1335. return 1;
  1336. }
  1337. if (di->erasable == 0) {
  1338. printk("pktcdvd: Disc not erasable\n");
  1339. return 1;
  1340. }
  1341. if (di->border_status == PACKET_SESSION_RESERVED) {
  1342. printk("pktcdvd: Can't write to last track (reserved)\n");
  1343. return 1;
  1344. }
  1345. return 0;
  1346. }
  1347. static int pkt_probe_settings(struct pktcdvd_device *pd)
  1348. {
  1349. struct packet_command cgc;
  1350. unsigned char buf[12];
  1351. disc_information di;
  1352. track_information ti;
  1353. int ret, track;
  1354. init_cdrom_command(&cgc, buf, sizeof(buf), CGC_DATA_READ);
  1355. cgc.cmd[0] = GPCMD_GET_CONFIGURATION;
  1356. cgc.cmd[8] = 8;
  1357. ret = pkt_generic_packet(pd, &cgc);
  1358. pd->mmc3_profile = ret ? 0xffff : buf[6] << 8 | buf[7];
  1359. memset(&di, 0, sizeof(disc_information));
  1360. memset(&ti, 0, sizeof(track_information));
  1361. if ((ret = pkt_get_disc_info(pd, &di))) {
  1362. printk("failed get_disc\n");
  1363. return ret;
  1364. }
  1365. if (pkt_good_disc(pd, &di))
  1366. return -ENXIO;
  1367. switch (pd->mmc3_profile) {
  1368. case 0x1a: /* DVD+RW */
  1369. printk("pktcdvd: inserted media is DVD+RW\n");
  1370. break;
  1371. case 0x13: /* DVD-RW */
  1372. printk("pktcdvd: inserted media is DVD-RW\n");
  1373. break;
  1374. case 0x12: /* DVD-RAM */
  1375. printk("pktcdvd: inserted media is DVD-RAM\n");
  1376. break;
  1377. default:
  1378. printk("pktcdvd: inserted media is CD-R%s\n", di.erasable ? "W" : "");
  1379. break;
  1380. }
  1381. pd->type = di.erasable ? PACKET_CDRW : PACKET_CDR;
  1382. track = 1; /* (di.last_track_msb << 8) | di.last_track_lsb; */
  1383. if ((ret = pkt_get_track_info(pd, track, 1, &ti))) {
  1384. printk("pktcdvd: failed get_track\n");
  1385. return ret;
  1386. }
  1387. if (pkt_good_track(&ti)) {
  1388. printk("pktcdvd: can't write to this track\n");
  1389. return -ENXIO;
  1390. }
  1391. /*
  1392. * we keep packet size in 512 byte units, makes it easier to
  1393. * deal with request calculations.
  1394. */
  1395. pd->settings.size = be32_to_cpu(ti.fixed_packet_size) << 2;
  1396. if (pd->settings.size == 0) {
  1397. printk("pktcdvd: detected zero packet size!\n");
  1398. pd->settings.size = 128;
  1399. }
  1400. pd->settings.fp = ti.fp;
  1401. pd->offset = (be32_to_cpu(ti.track_start) << 2) & (pd->settings.size - 1);
  1402. if (ti.nwa_v) {
  1403. pd->nwa = be32_to_cpu(ti.next_writable);
  1404. set_bit(PACKET_NWA_VALID, &pd->flags);
  1405. }
  1406. /*
  1407. * in theory we could use lra on -RW media as well and just zero
  1408. * blocks that haven't been written yet, but in practice that
  1409. * is just a no-go. we'll use that for -R, naturally.
  1410. */
  1411. if (ti.lra_v) {
  1412. pd->lra = be32_to_cpu(ti.last_rec_address);
  1413. set_bit(PACKET_LRA_VALID, &pd->flags);
  1414. } else {
  1415. pd->lra = 0xffffffff;
  1416. set_bit(PACKET_LRA_VALID, &pd->flags);
  1417. }
  1418. /*
  1419. * fine for now
  1420. */
  1421. pd->settings.link_loss = 7;
  1422. pd->settings.write_type = 0; /* packet */
  1423. pd->settings.track_mode = ti.track_mode;
  1424. /*
  1425. * mode1 or mode2 disc
  1426. */
  1427. switch (ti.data_mode) {
  1428. case PACKET_MODE1:
  1429. pd->settings.block_mode = PACKET_BLOCK_MODE1;
  1430. break;
  1431. case PACKET_MODE2:
  1432. pd->settings.block_mode = PACKET_BLOCK_MODE2;
  1433. break;
  1434. default:
  1435. printk("pktcdvd: unknown data mode\n");
  1436. return 1;
  1437. }
  1438. return 0;
  1439. }
  1440. /*
  1441. * enable/disable write caching on drive
  1442. */
  1443. static int pkt_write_caching(struct pktcdvd_device *pd, int set)
  1444. {
  1445. struct packet_command cgc;
  1446. struct request_sense sense;
  1447. unsigned char buf[64];
  1448. int ret;
  1449. memset(buf, 0, sizeof(buf));
  1450. init_cdrom_command(&cgc, buf, sizeof(buf), CGC_DATA_READ);
  1451. cgc.sense = &sense;
  1452. cgc.buflen = pd->mode_offset + 12;
  1453. /*
  1454. * caching mode page might not be there, so quiet this command
  1455. */
  1456. cgc.quiet = 1;
  1457. if ((ret = pkt_mode_sense(pd, &cgc, GPMODE_WCACHING_PAGE, 0)))
  1458. return ret;
  1459. buf[pd->mode_offset + 10] |= (!!set << 2);
  1460. cgc.buflen = cgc.cmd[8] = 2 + ((buf[0] << 8) | (buf[1] & 0xff));
  1461. ret = pkt_mode_select(pd, &cgc);
  1462. if (ret) {
  1463. printk("pktcdvd: write caching control failed\n");
  1464. pkt_dump_sense(&cgc);
  1465. } else if (!ret && set)
  1466. printk("pktcdvd: enabled write caching on %s\n", pd->name);
  1467. return ret;
  1468. }
  1469. static int pkt_lock_door(struct pktcdvd_device *pd, int lockflag)
  1470. {
  1471. struct packet_command cgc;
  1472. init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
  1473. cgc.cmd[0] = GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL;
  1474. cgc.cmd[4] = lockflag ? 1 : 0;
  1475. return pkt_generic_packet(pd, &cgc);
  1476. }
  1477. /*
  1478. * Returns drive maximum write speed
  1479. */
  1480. static int pkt_get_max_speed(struct pktcdvd_device *pd, unsigned *write_speed)
  1481. {
  1482. struct packet_command cgc;
  1483. struct request_sense sense;
  1484. unsigned char buf[256+18];
  1485. unsigned char *cap_buf;
  1486. int ret, offset;
  1487. memset(buf, 0, sizeof(buf));
  1488. cap_buf = &buf[sizeof(struct mode_page_header) + pd->mode_offset];
  1489. init_cdrom_command(&cgc, buf, sizeof(buf), CGC_DATA_UNKNOWN);
  1490. cgc.sense = &sense;
  1491. ret = pkt_mode_sense(pd, &cgc, GPMODE_CAPABILITIES_PAGE, 0);
  1492. if (ret) {
  1493. cgc.buflen = pd->mode_offset + cap_buf[1] + 2 +
  1494. sizeof(struct mode_page_header);
  1495. ret = pkt_mode_sense(pd, &cgc, GPMODE_CAPABILITIES_PAGE, 0);
  1496. if (ret) {
  1497. pkt_dump_sense(&cgc);
  1498. return ret;
  1499. }
  1500. }
  1501. offset = 20; /* Obsoleted field, used by older drives */
  1502. if (cap_buf[1] >= 28)
  1503. offset = 28; /* Current write speed selected */
  1504. if (cap_buf[1] >= 30) {
  1505. /* If the drive reports at least one "Logical Unit Write
  1506. * Speed Performance Descriptor Block", use the information
  1507. * in the first block. (contains the highest speed)
  1508. */
  1509. int num_spdb = (cap_buf[30] << 8) + cap_buf[31];
  1510. if (num_spdb > 0)
  1511. offset = 34;
  1512. }
  1513. *write_speed = (cap_buf[offset] << 8) | cap_buf[offset + 1];
  1514. return 0;
  1515. }
  1516. /* These tables from cdrecord - I don't have orange book */
  1517. /* standard speed CD-RW (1-4x) */
  1518. static char clv_to_speed[16] = {
  1519. /* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 */
  1520. 0, 2, 4, 6, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  1521. };
  1522. /* high speed CD-RW (-10x) */
  1523. static char hs_clv_to_speed[16] = {
  1524. /* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 */
  1525. 0, 2, 4, 6, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  1526. };
  1527. /* ultra high speed CD-RW */
  1528. static char us_clv_to_speed[16] = {
  1529. /* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 */
  1530. 0, 2, 4, 8, 0, 0,16, 0,24,32,40,48, 0, 0, 0, 0
  1531. };
  1532. /*
  1533. * reads the maximum media speed from ATIP
  1534. */
  1535. static int pkt_media_speed(struct pktcdvd_device *pd, unsigned *speed)
  1536. {
  1537. struct packet_command cgc;
  1538. struct request_sense sense;
  1539. unsigned char buf[64];
  1540. unsigned int size, st, sp;
  1541. int ret;
  1542. init_cdrom_command(&cgc, buf, 2, CGC_DATA_READ);
  1543. cgc.sense = &sense;
  1544. cgc.cmd[0] = GPCMD_READ_TOC_PMA_ATIP;
  1545. cgc.cmd[1] = 2;
  1546. cgc.cmd[2] = 4; /* READ ATIP */
  1547. cgc.cmd[8] = 2;
  1548. ret = pkt_generic_packet(pd, &cgc);
  1549. if (ret) {
  1550. pkt_dump_sense(&cgc);
  1551. return ret;
  1552. }
  1553. size = ((unsigned int) buf[0]<<8) + buf[1] + 2;
  1554. if (size > sizeof(buf))
  1555. size = sizeof(buf);
  1556. init_cdrom_command(&cgc, buf, size, CGC_DATA_READ);
  1557. cgc.sense = &sense;
  1558. cgc.cmd[0] = GPCMD_READ_TOC_PMA_ATIP;
  1559. cgc.cmd[1] = 2;
  1560. cgc.cmd[2] = 4;
  1561. cgc.cmd[8] = size;
  1562. ret = pkt_generic_packet(pd, &cgc);
  1563. if (ret) {
  1564. pkt_dump_sense(&cgc);
  1565. return ret;
  1566. }
  1567. if (!buf[6] & 0x40) {
  1568. printk("pktcdvd: Disc type is not CD-RW\n");
  1569. return 1;
  1570. }
  1571. if (!buf[6] & 0x4) {
  1572. printk("pktcdvd: A1 values on media are not valid, maybe not CDRW?\n");
  1573. return 1;
  1574. }
  1575. st = (buf[6] >> 3) & 0x7; /* disc sub-type */
  1576. sp = buf[16] & 0xf; /* max speed from ATIP A1 field */
  1577. /* Info from cdrecord */
  1578. switch (st) {
  1579. case 0: /* standard speed */
  1580. *speed = clv_to_speed[sp];
  1581. break;
  1582. case 1: /* high speed */
  1583. *speed = hs_clv_to_speed[sp];
  1584. break;
  1585. case 2: /* ultra high speed */
  1586. *speed = us_clv_to_speed[sp];
  1587. break;
  1588. default:
  1589. printk("pktcdvd: Unknown disc sub-type %d\n",st);
  1590. return 1;
  1591. }
  1592. if (*speed) {
  1593. printk("pktcdvd: Max. media speed: %d\n",*speed);
  1594. return 0;
  1595. } else {
  1596. printk("pktcdvd: Unknown speed %d for sub-type %d\n",sp,st);
  1597. return 1;
  1598. }
  1599. }
  1600. static int pkt_perform_opc(struct pktcdvd_device *pd)
  1601. {
  1602. struct packet_command cgc;
  1603. struct request_sense sense;
  1604. int ret;
  1605. VPRINTK("pktcdvd: Performing OPC\n");
  1606. init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
  1607. cgc.sense = &sense;
  1608. cgc.timeout = 60*HZ;
  1609. cgc.cmd[0] = GPCMD_SEND_OPC;
  1610. cgc.cmd[1] = 1;
  1611. if ((ret = pkt_generic_packet(pd, &cgc)))
  1612. pkt_dump_sense(&cgc);
  1613. return ret;
  1614. }
  1615. static int pkt_open_write(struct pktcdvd_device *pd)
  1616. {
  1617. int ret;
  1618. unsigned int write_speed, media_write_speed, read_speed;
  1619. if ((ret = pkt_probe_settings(pd))) {
  1620. DPRINTK("pktcdvd: %s failed probe\n", pd->name);
  1621. return -EIO;
  1622. }
  1623. if ((ret = pkt_set_write_settings(pd))) {
  1624. DPRINTK("pktcdvd: %s failed saving write settings\n", pd->name);
  1625. return -EIO;
  1626. }
  1627. pkt_write_caching(pd, USE_WCACHING);
  1628. if ((ret = pkt_get_max_speed(pd, &write_speed)))
  1629. write_speed = 16 * 177;
  1630. switch (pd->mmc3_profile) {
  1631. case 0x13: /* DVD-RW */
  1632. case 0x1a: /* DVD+RW */
  1633. case 0x12: /* DVD-RAM */
  1634. DPRINTK("pktcdvd: write speed %ukB/s\n", write_speed);
  1635. break;
  1636. default:
  1637. if ((ret = pkt_media_speed(pd, &media_write_speed)))
  1638. media_write_speed = 16;
  1639. write_speed = min(write_speed, media_write_speed * 177);
  1640. DPRINTK("pktcdvd: write speed %ux\n", write_speed / 176);
  1641. break;
  1642. }
  1643. read_speed = write_speed;
  1644. if ((ret = pkt_set_speed(pd, write_speed, read_speed))) {
  1645. DPRINTK("pktcdvd: %s couldn't set write speed\n", pd->name);
  1646. return -EIO;
  1647. }
  1648. pd->write_speed = write_speed;
  1649. pd->read_speed = read_speed;
  1650. if ((ret = pkt_perform_opc(pd))) {
  1651. DPRINTK("pktcdvd: %s Optimum Power Calibration failed\n", pd->name);
  1652. }
  1653. return 0;
  1654. }
  1655. /*
  1656. * called at open time.
  1657. */
  1658. static int pkt_open_dev(struct pktcdvd_device *pd, int write)
  1659. {
  1660. int ret;
  1661. long lba;
  1662. request_queue_t *q;
  1663. /*
  1664. * We need to re-open the cdrom device without O_NONBLOCK to be able
  1665. * to read/write from/to it. It is already opened in O_NONBLOCK mode
  1666. * so bdget() can't fail.
  1667. */
  1668. bdget(pd->bdev->bd_dev);
  1669. if ((ret = blkdev_get(pd->bdev, FMODE_READ, O_RDONLY)))
  1670. goto out;
  1671. if ((ret = pkt_get_last_written(pd, &lba))) {
  1672. printk("pktcdvd: pkt_get_last_written failed\n");
  1673. goto out_putdev;
  1674. }
  1675. set_capacity(pd->disk, lba << 2);
  1676. set_capacity(pd->bdev->bd_disk, lba << 2);
  1677. bd_set_size(pd->bdev, (loff_t)lba << 11);
  1678. q = bdev_get_queue(pd->bdev);
  1679. if (write) {
  1680. if ((ret = pkt_open_write(pd)))
  1681. goto out_putdev;
  1682. /*
  1683. * Some CDRW drives can not handle writes larger than one packet,
  1684. * even if the size is a multiple of the packet size.
  1685. */
  1686. spin_lock_irq(q->queue_lock);
  1687. blk_queue_max_sectors(q, pd->settings.size);
  1688. spin_unlock_irq(q->queue_lock);
  1689. set_bit(PACKET_WRITABLE, &pd->flags);
  1690. } else {
  1691. pkt_set_speed(pd, MAX_SPEED, MAX_SPEED);
  1692. clear_bit(PACKET_WRITABLE, &pd->flags);
  1693. }
  1694. if ((ret = pkt_set_segment_merging(pd, q)))
  1695. goto out_putdev;
  1696. if (write)
  1697. printk("pktcdvd: %lukB available on disc\n", lba << 1);
  1698. return 0;
  1699. out_putdev:
  1700. blkdev_put(pd->bdev);
  1701. out:
  1702. return ret;
  1703. }
  1704. /*
  1705. * called when the device is closed. makes sure that the device flushes
  1706. * the internal cache before we close.
  1707. */
  1708. static void pkt_release_dev(struct pktcdvd_device *pd, int flush)
  1709. {
  1710. if (flush && pkt_flush_cache(pd))
  1711. DPRINTK("pktcdvd: %s not flushing cache\n", pd->name);
  1712. pkt_lock_door(pd, 0);
  1713. pkt_set_speed(pd, MAX_SPEED, MAX_SPEED);
  1714. blkdev_put(pd->bdev);
  1715. }
  1716. static struct pktcdvd_device *pkt_find_dev_from_minor(int dev_minor)
  1717. {
  1718. if (dev_minor >= MAX_WRITERS)
  1719. return NULL;
  1720. return pkt_devs[dev_minor];
  1721. }
  1722. static int pkt_open(struct inode *inode, struct file *file)
  1723. {
  1724. struct pktcdvd_device *pd = NULL;
  1725. int ret;
  1726. VPRINTK("pktcdvd: entering open\n");
  1727. down(&ctl_mutex);
  1728. pd = pkt_find_dev_from_minor(iminor(inode));
  1729. if (!pd) {
  1730. ret = -ENODEV;
  1731. goto out;
  1732. }
  1733. BUG_ON(pd