drivers/block/pktcdvd.c

   1 /*
   2  * Copyright (C) 2000 Jens Axboe <axboe@suse.de>
   3  * Copyright (C) 2001-2004 Peter Osterlund <petero2@telia.com>
   4  * Copyright (C) 2006 Thomas Maier <balagi@justmail.de>
   5  *
   6  * May be copied or modified under the terms of the GNU General Public
   7  * License.  See linux/COPYING for more information.
   8  *
   9  * Packet writing layer for ATAPI and SCSI CD-RW, DVD+RW, DVD-RW and
  10  * DVD-RAM devices.
  11  *
  12  * Theory of operation:
  13  *
  14  * At the lowest level, there is the standard driver for the CD/DVD device,
  15  * typically ide-cd.c or sr.c. This driver can handle read and write requests,
  16  * but it doesn't know anything about the special restrictions that apply to
  17  * packet writing. One restriction is that write requests must be aligned to
  18  * packet boundaries on the physical media, and the size of a write request
  19  * must be equal to the packet size. Another restriction is that a
  20  * GPCMD_FLUSH_CACHE command has to be issued to the drive before a read
  21  * command, if the previous command was a write.
  22  *
  23  * The purpose of the packet writing driver is to hide these restrictions from
  24  * higher layers, such as file systems, and present a block device that can be
  25  * randomly read and written using 2kB-sized blocks.
  26  *
  27  * The lowest layer in the packet writing driver is the packet I/O scheduler.
  28  * Its data is defined by the struct packet_iosched and includes two bio
  29  * queues with pending read and write requests. These queues are processed
  30  * by the pkt_iosched_process_queue() function. The write requests in this
  31  * queue are already properly aligned and sized. This layer is responsible for
  32  * issuing the flush cache commands and scheduling the I/O in a good order.
  33  *
  34  * The next layer transforms unaligned write requests to aligned writes. This
  35  * transformation requires reading missing pieces of data from the underlying
  36  * block device, assembling the pieces to full packets and queuing them to the
  37  * packet I/O scheduler.
  38  *
  39  * At the top layer there is a custom ->submit_bio function that forwards
  40  * read requests directly to the iosched queue and puts write requests in the
  41  * unaligned write queue. A kernel thread performs the necessary read
  42  * gathering to convert the unaligned writes to aligned writes and then feeds
  43  * them to the packet I/O scheduler.
  44  *
  45  *************************************************************************/
  46
  47 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  48
  49 #include <linux/pktcdvd.h>
  50 #include <linux/module.h>
  51 #include <linux/types.h>
  52 #include <linux/kernel.h>
  53 #include <linux/compat.h>
  54 #include <linux/kthread.h>
  55 #include <linux/errno.h>
  56 #include <linux/spinlock.h>
  57 #include <linux/file.h>
  58 #include <linux/proc_fs.h>
  59 #include <linux/seq_file.h>
  60 #include <linux/miscdevice.h>
  61 #include <linux/freezer.h>
  62 #include <linux/mutex.h>
  63 #include <linux/slab.h>
  64 #include <linux/backing-dev.h>
  65 #include <scsi/scsi_cmnd.h>
  66 #include <scsi/scsi_ioctl.h>
  67 #include <scsi/scsi.h>
  68 #include <linux/debugfs.h>
  69 #include <linux/device.h>
  70 #include <linux/nospec.h>
  71 #include <linux/uaccess.h>
  72
  73 #define DRIVER_NAME     "pktcdvd"
  74
  75 #define pkt_err(pd, fmt, ...)                                           \
  76         pr_err("%s: " fmt, pd->name, ##__VA_ARGS__)
  77 #define pkt_notice(pd, fmt, ...)                                        \
  78         pr_notice("%s: " fmt, pd->name, ##__VA_ARGS__)
  79 #define pkt_info(pd, fmt, ...)                                          \
  80         pr_info("%s: " fmt, pd->name, ##__VA_ARGS__)
  81
  82 #define pkt_dbg(level, pd, fmt, ...)                                    \
  83 do {                                                                    \
  84         if (level == 2 && PACKET_DEBUG >= 2)                            \
  85                 pr_notice("%s: %s():" fmt,                              \
  86                           pd->name, __func__, ##__VA_ARGS__);           \
  87         else if (level == 1 && PACKET_DEBUG >= 1)                       \
  88                 pr_notice("%s: " fmt, pd->name, ##__VA_ARGS__);         \
  89 } while (0)
  90
  91 #define MAX_SPEED 0xffff
  92
  93 static DEFINE_MUTEX(pktcdvd_mutex);
  94 static struct pktcdvd_device *pkt_devs[MAX_WRITERS];
  95 static struct proc_dir_entry *pkt_proc;
  96 static int pktdev_major;
  97 static int write_congestion_on  = PKT_WRITE_CONGESTION_ON;
  98 static int write_congestion_off = PKT_WRITE_CONGESTION_OFF;
  99 static struct mutex ctl_mutex;  /* Serialize open/close/setup/teardown */
 100 static mempool_t psd_pool;
 101 static struct bio_set pkt_bio_set;
 102
 103 static struct class     *class_pktcdvd = NULL;    /* /sys/class/pktcdvd */
 104 static struct dentry    *pkt_debugfs_root = NULL; /* /sys/kernel/debug/pktcdvd */
 105
 106 /* forward declaration */
 107 static int pkt_setup_dev(dev_t dev, dev_t* pkt_dev);
 108 static int pkt_remove_dev(dev_t pkt_dev);
 109 static int pkt_seq_show(struct seq_file *m, void *p);
 110
 111 static sector_t get_zone(sector_t sector, struct pktcdvd_device *pd)
 112 {
 113         return (sector + pd->offset) & ~(sector_t)(pd->settings.size - 1);
 114 }
 115
 116 /**********************************************************
 117  * sysfs interface for pktcdvd
 118  * by (C) 2006  Thomas Maier <balagi@justmail.de>
 119
 120   /sys/class/pktcdvd/pktcdvd[0-7]/
 121                      stat/reset
 122                      stat/packets_started
 123                      stat/packets_finished
 124                      stat/kb_written
 125                      stat/kb_read
 126                      stat/kb_read_gather
 127                      write_queue/size
 128                      write_queue/congestion_off
 129                      write_queue/congestion_on
 130  **********************************************************/
 131
 132 static ssize_t packets_started_show(struct device *dev,
 133                                     struct device_attribute *attr, char *buf)
 134 {
 135         struct pktcdvd_device *pd = dev_get_drvdata(dev);
 136
 137         return sysfs_emit(buf, "%lu\n", pd->stats.pkt_started);
 138 }
 139 static DEVICE_ATTR_RO(packets_started);
 140
 141 static ssize_t packets_finished_show(struct device *dev,
 142                                      struct device_attribute *attr, char *buf)
 143 {
 144         struct pktcdvd_device *pd = dev_get_drvdata(dev);
 145
 146         return sysfs_emit(buf, "%lu\n", pd->stats.pkt_ended);
 147 }
 148 static DEVICE_ATTR_RO(packets_finished);
 149
 150 static ssize_t kb_written_show(struct device *dev,
 151                                struct device_attribute *attr, char *buf)
 152 {
 153         struct pktcdvd_device *pd = dev_get_drvdata(dev);
 154
 155         return sysfs_emit(buf, "%lu\n", pd->stats.secs_w >> 1);
 156 }
 157 static DEVICE_ATTR_RO(kb_written);
 158
 159 static ssize_t kb_read_show(struct device *dev,
 160                             struct device_attribute *attr, char *buf)
 161 {
 162         struct pktcdvd_device *pd = dev_get_drvdata(dev);
 163
 164         return sysfs_emit(buf, "%lu\n", pd->stats.secs_r >> 1);
 165 }
 166 static DEVICE_ATTR_RO(kb_read);
 167
 168 static ssize_t kb_read_gather_show(struct device *dev,
 169                                    struct device_attribute *attr, char *buf)
 170 {
 171         struct pktcdvd_device *pd = dev_get_drvdata(dev);
 172
 173         return sysfs_emit(buf, "%lu\n", pd->stats.secs_rg >> 1);
 174 }
 175 static DEVICE_ATTR_RO(kb_read_gather);
 176
 177 static ssize_t reset_store(struct device *dev, struct device_attribute *attr,
 178                            const char *buf, size_t len)
 179 {
 180         struct pktcdvd_device *pd = dev_get_drvdata(dev);
 181
 182         if (len > 0) {
 183                 pd->stats.pkt_started = 0;
 184                 pd->stats.pkt_ended = 0;
 185                 pd->stats.secs_w = 0;
 186                 pd->stats.secs_rg = 0;
 187                 pd->stats.secs_r = 0;
 188         }
 189         return len;
 190 }
 191 static DEVICE_ATTR_WO(reset);
 192
 193 static struct attribute *pkt_stat_attrs[] = {
 194         &dev_attr_packets_finished.attr,
 195         &dev_attr_packets_started.attr,
 196         &dev_attr_kb_read.attr,
 197         &dev_attr_kb_written.attr,
 198         &dev_attr_kb_read_gather.attr,
 199         &dev_attr_reset.attr,
 200         NULL,
 201 };
 202
 203 static const struct attribute_group pkt_stat_group = {
 204         .name = "stat",
 205         .attrs = pkt_stat_attrs,
 206 };
 207
 208 static ssize_t size_show(struct device *dev,
 209                          struct device_attribute *attr, char *buf)
 210 {
 211         struct pktcdvd_device *pd = dev_get_drvdata(dev);
 212         int n;
 213
 214         spin_lock(&pd->lock);
 215         n = sysfs_emit(buf, "%d\n", pd->bio_queue_size);
 216         spin_unlock(&pd->lock);
 217         return n;
 218 }
 219 static DEVICE_ATTR_RO(size);
 220
 221 static void init_write_congestion_marks(int* lo, int* hi)
 222 {
 223         if (*hi > 0) {
 224                 *hi = max(*hi, 500);
 225                 *hi = min(*hi, 1000000);
 226                 if (*lo <= 0)
 227                         *lo = *hi - 100;
 228                 else {
 229                         *lo = min(*lo, *hi - 100);
 230                         *lo = max(*lo, 100);
 231                 }
 232         } else {
 233                 *hi = -1;
 234                 *lo = -1;
 235         }
 236 }
 237
 238 static ssize_t congestion_off_show(struct device *dev,
 239                                    struct device_attribute *attr, char *buf)
 240 {
 241         struct pktcdvd_device *pd = dev_get_drvdata(dev);
 242         int n;
 243
 244         spin_lock(&pd->lock);
 245         n = sysfs_emit(buf, "%d\n", pd->write_congestion_off);
 246         spin_unlock(&pd->lock);
 247         return n;
 248 }
 249
 250 static ssize_t congestion_off_store(struct device *dev,
 251                                     struct device_attribute *attr,
 252                                     const char *buf, size_t len)
 253 {
 254         struct pktcdvd_device *pd = dev_get_drvdata(dev);
 255         int val;
 256
 257         if (sscanf(buf, "%d", &val) == 1) {
 258                 spin_lock(&pd->lock);
 259                 pd->write_congestion_off = val;
 260                 init_write_congestion_marks(&pd->write_congestion_off,
 261                                         &pd->write_congestion_on);
 262                 spin_unlock(&pd->lock);
 263         }
 264         return len;
 265 }
 266 static DEVICE_ATTR_RW(congestion_off);
 267
 268 static ssize_t congestion_on_show(struct device *dev,
 269                                   struct device_attribute *attr, char *buf)
 270 {
 271         struct pktcdvd_device *pd = dev_get_drvdata(dev);
 272         int n;
 273
 274         spin_lock(&pd->lock);
 275         n = sysfs_emit(buf, "%d\n", pd->write_congestion_on);
 276         spin_unlock(&pd->lock);
 277         return n;
 278 }
 279
 280 static ssize_t congestion_on_store(struct device *dev,
 281                                    struct device_attribute *attr,
 282                                    const char *buf, size_t len)
 283 {
 284         struct pktcdvd_device *pd = dev_get_drvdata(dev);
 285         int val;
 286
 287         if (sscanf(buf, "%d", &val) == 1) {
 288                 spin_lock(&pd->lock);
 289                 pd->write_congestion_on = val;
 290                 init_write_congestion_marks(&pd->write_congestion_off,
 291                                         &pd->write_congestion_on);
 292                 spin_unlock(&pd->lock);
 293         }
 294         return len;
 295 }
 296 static DEVICE_ATTR_RW(congestion_on);
 297
 298 static struct attribute *pkt_wq_attrs[] = {
 299         &dev_attr_congestion_on.attr,
 300         &dev_attr_congestion_off.attr,
 301         &dev_attr_size.attr,
 302         NULL,
 303 };
 304
 305 static const struct attribute_group pkt_wq_group = {
 306         .name = "write_queue",
 307         .attrs = pkt_wq_attrs,
 308 };
 309
 310 static const struct attribute_group *pkt_groups[] = {
 311         &pkt_stat_group,
 312         &pkt_wq_group,
 313         NULL,
 314 };
 315
 316 static void pkt_sysfs_dev_new(struct pktcdvd_device *pd)
 317 {
 318         if (class_pktcdvd) {
 319                 pd->dev = device_create_with_groups(class_pktcdvd, NULL,
 320                                                     MKDEV(0, 0), pd, pkt_groups,
 321                                                     "%s", pd->name);
 322                 if (IS_ERR(pd->dev))
 323                         pd->dev = NULL;
 324         }
 325 }
 326
 327 static void pkt_sysfs_dev_remove(struct pktcdvd_device *pd)
 328 {
 329         if (class_pktcdvd)
 330                 device_unregister(pd->dev);
 331 }
 332
 333
 334 /********************************************************************
 335   /sys/class/pktcdvd/
 336                      add            map block device
 337                      remove         unmap packet dev
 338                      device_map     show mappings
 339  *******************************************************************/
 340
 341 static void class_pktcdvd_release(struct class *cls)
 342 {
 343         kfree(cls);
 344 }
 345
 346 static ssize_t device_map_show(struct class *c, struct class_attribute *attr,
 347                                char *data)
 348 {
 349         int n = 0;
 350         int idx;
 351         mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
 352         for (idx = 0; idx < MAX_WRITERS; idx++) {
 353                 struct pktcdvd_device *pd = pkt_devs[idx];
 354                 if (!pd)
 355                         continue;
 356                 n += sprintf(data+n, "%s %u:%u %u:%u\n",
 357                         pd->name,
 358                         MAJOR(pd->pkt_dev), MINOR(pd->pkt_dev),
 359                         MAJOR(pd->bdev->bd_dev),
 360                         MINOR(pd->bdev->bd_dev));
 361         }
 362         mutex_unlock(&ctl_mutex);
 363         return n;
 364 }
 365 static CLASS_ATTR_RO(device_map);
 366
 367 static ssize_t add_store(struct class *c, struct class_attribute *attr,
 368                          const char *buf, size_t count)
 369 {
 370         unsigned int major, minor;
 371
 372         if (sscanf(buf, "%u:%u", &major, &minor) == 2) {
 373                 /* pkt_setup_dev() expects caller to hold reference to self */
 374                 if (!try_module_get(THIS_MODULE))
 375                         return -ENODEV;
 376
 377                 pkt_setup_dev(MKDEV(major, minor), NULL);
 378
 379                 module_put(THIS_MODULE);
 380
 381                 return count;
 382         }
 383
 384         return -EINVAL;
 385 }
 386 static CLASS_ATTR_WO(add);
 387
 388 static ssize_t remove_store(struct class *c, struct class_attribute *attr,
 389                             const char *buf, size_t count)
 390 {
 391         unsigned int major, minor;
 392         if (sscanf(buf, "%u:%u", &major, &minor) == 2) {
 393                 pkt_remove_dev(MKDEV(major, minor));
 394                 return count;
 395         }
 396         return -EINVAL;
 397 }
 398 static CLASS_ATTR_WO(remove);
 399
 400 static struct attribute *class_pktcdvd_attrs[] = {
 401         &class_attr_add.attr,
 402         &class_attr_remove.attr,
 403         &class_attr_device_map.attr,
 404         NULL,
 405 };
 406 ATTRIBUTE_GROUPS(class_pktcdvd);
 407
 408 static int pkt_sysfs_init(void)
 409 {
 410         int ret = 0;
 411
 412         /*
 413          * create control files in sysfs
 414          * /sys/class/pktcdvd/...
 415          */
 416         class_pktcdvd = kzalloc(sizeof(*class_pktcdvd), GFP_KERNEL);
 417         if (!class_pktcdvd)
 418                 return -ENOMEM;
 419         class_pktcdvd->name = DRIVER_NAME;
 420         class_pktcdvd->owner = THIS_MODULE;
 421         class_pktcdvd->class_release = class_pktcdvd_release;
 422         class_pktcdvd->class_groups = class_pktcdvd_groups;
 423         ret = class_register(class_pktcdvd);
 424         if (ret) {
 425                 kfree(class_pktcdvd);
 426                 class_pktcdvd = NULL;
 427                 pr_err("failed to create class pktcdvd\n");
 428                 return ret;
 429         }
 430         return 0;
 431 }
 432
 433 static void pkt_sysfs_cleanup(void)
 434 {
 435         if (class_pktcdvd)
 436                 class_destroy(class_pktcdvd);
 437         class_pktcdvd = NULL;
 438 }
 439
 440 /********************************************************************
 441   entries in debugfs
 442
 443   /sys/kernel/debug/pktcdvd[0-7]/
 444                         info
 445
 446  *******************************************************************/
 447
 448 static int pkt_debugfs_seq_show(struct seq_file *m, void *p)
 449 {
 450         return pkt_seq_show(m, p);
 451 }
 452
 453 static int pkt_debugfs_fops_open(struct inode *inode, struct file *file)
 454 {
 455         return single_open(file, pkt_debugfs_seq_show, inode->i_private);
 456 }
 457
 458 static const struct file_operations debug_fops = {
 459         .open           = pkt_debugfs_fops_open,
 460         .read           = seq_read,
 461         .llseek         = seq_lseek,
 462         .release        = single_release,
 463         .owner          = THIS_MODULE,
 464 };
 465
 466 static void pkt_debugfs_dev_new(struct pktcdvd_device *pd)
 467 {
 468         if (!pkt_debugfs_root)
 469                 return;
 470         pd->dfs_d_root = debugfs_create_dir(pd->name, pkt_debugfs_root);
 471         if (!pd->dfs_d_root)
 472                 return;
 473
 474         pd->dfs_f_info = debugfs_create_file("info", 0444,
 475                                              pd->dfs_d_root, pd, &debug_fops);
 476 }
 477
 478 static void pkt_debugfs_dev_remove(struct pktcdvd_device *pd)
 479 {
 480         if (!pkt_debugfs_root)
 481                 return;
 482         debugfs_remove(pd->dfs_f_info);
 483         debugfs_remove(pd->dfs_d_root);
 484         pd->dfs_f_info = NULL;
 485         pd->dfs_d_root = NULL;
 486 }
 487
 488 static void pkt_debugfs_init(void)
 489 {
 490         pkt_debugfs_root = debugfs_create_dir(DRIVER_NAME, NULL);
 491 }
 492
 493 static void pkt_debugfs_cleanup(void)
 494 {
 495         debugfs_remove(pkt_debugfs_root);
 496         pkt_debugfs_root = NULL;
 497 }
 498
 499 /* ----------------------------------------------------------*/
 500
 501
 502 static void pkt_bio_finished(struct pktcdvd_device *pd)
 503 {
 504         BUG_ON(atomic_read(&pd->cdrw.pending_bios) <= 0);
 505         if (atomic_dec_and_test(&pd->cdrw.pending_bios)) {
 506                 pkt_dbg(2, pd, "queue empty\n");
 507                 atomic_set(&pd->iosched.attention, 1);
 508                 wake_up(&pd->wqueue);
 509         }
 510 }
 511
 512 /*
 513  * Allocate a packet_data struct
 514  */
 515 static struct packet_data *pkt_alloc_packet_data(int frames)
 516 {
 517         int i;
 518         struct packet_data *pkt;
 519
 520         pkt = kzalloc(sizeof(struct packet_data), GFP_KERNEL);
 521         if (!pkt)
 522                 goto no_pkt;
 523
 524         pkt->frames = frames;
 525         pkt->w_bio = bio_kmalloc(GFP_KERNEL, frames);
 526         if (!pkt->w_bio)
 527                 goto no_bio;
 528
 529         for (i = 0; i < frames / FRAMES_PER_PAGE; i++) {
 530                 pkt->pages[i] = alloc_page(GFP_KERNEL|__GFP_ZERO);
 531                 if (!pkt->pages[i])
 532                         goto no_page;
 533         }
 534
 535         spin_lock_init(&pkt->lock);
 536         bio_list_init(&pkt->orig_bios);
 537
 538         for (i = 0; i < frames; i++) {
 539                 struct bio *bio = bio_kmalloc(GFP_KERNEL, 1);
 540                 if (!bio)
 541                         goto no_rd_bio;
 542
 543                 pkt->r_bios[i] = bio;
 544         }
 545
 546         return pkt;
 547
 548 no_rd_bio:
 549         for (i = 0; i < frames; i++) {
 550                 struct bio *bio = pkt->r_bios[i];
 551                 if (bio)
 552                         bio_put(bio);
 553         }
 554
 555 no_page:
 556         for (i = 0; i < frames / FRAMES_PER_PAGE; i++)
 557                 if (pkt->pages[i])
 558                         __free_page(pkt->pages[i]);
 559         bio_put(pkt->w_bio);
 560 no_bio:
 561         kfree(pkt);
 562 no_pkt:
 563         return NULL;
 564 }
 565
 566 /*
 567  * Free a packet_data struct
 568  */
 569 static void pkt_free_packet_data(struct packet_data *pkt)
 570 {
 571         int i;
 572
 573         for (i = 0; i < pkt->frames; i++) {
 574                 struct bio *bio = pkt->r_bios[i];
 575                 if (bio)
 576                         bio_put(bio);
 577         }
 578         for (i = 0; i < pkt->frames / FRAMES_PER_PAGE; i++)
 579                 __free_page(pkt->pages[i]);
 580         bio_put(pkt->w_bio);
 581         kfree(pkt);
 582 }
 583
 584 static void pkt_shrink_pktlist(struct pktcdvd_device *pd)
 585 {
 586         struct packet_data *pkt, *next;
 587
 588         BUG_ON(!list_empty(&pd->cdrw.pkt_active_list));
 589
 590         list_for_each_entry_safe(pkt, next, &pd->cdrw.pkt_free_list, list) {
 591                 pkt_free_packet_data(pkt);
 592         }
 593         INIT_LIST_HEAD(&pd->cdrw.pkt_free_list);
 594 }
 595
 596 static int pkt_grow_pktlist(struct pktcdvd_device *pd, int nr_packets)
 597 {
 598         struct packet_data *pkt;
 599
 600         BUG_ON(!list_empty(&pd->cdrw.pkt_free_list));
 601
 602         while (nr_packets > 0) {
 603                 pkt = pkt_alloc_packet_data(pd->settings.size >> 2);
 604                 if (!pkt) {
 605                         pkt_shrink_pktlist(pd);
 606                         return 0;
 607                 }
 608                 pkt->id = nr_packets;
 609                 pkt->pd = pd;
 610                 list_add(&pkt->list, &pd->cdrw.pkt_free_list);
 611                 nr_packets--;
 612         }
 613         return 1;
 614 }
 615
 616 static inline struct pkt_rb_node *pkt_rbtree_next(struct pkt_rb_node *node)
 617 {
 618         struct rb_node *n = rb_next(&node->rb_node);
 619         if (!n)
 620                 return NULL;
 621         return rb_entry(n, struct pkt_rb_node, rb_node);
 622 }
 623
 624 static void pkt_rbtree_erase(struct pktcdvd_device *pd, struct pkt_rb_node *node)
 625 {
 626         rb_erase(&node->rb_node, &pd->bio_queue);
 627         mempool_free(node, &pd->rb_pool);
 628         pd->bio_queue_size--;
 629         BUG_ON(pd->bio_queue_size < 0);
 630 }
 631
 632 /*
 633  * Find the first node in the pd->bio_queue rb tree with a starting sector >= s.
 634  */
 635 static struct pkt_rb_node *pkt_rbtree_find(struct pktcdvd_device *pd, sector_t s)
 636 {
 637         struct rb_node *n = pd->bio_queue.rb_node;
 638         struct rb_node *next;
 639         struct pkt_rb_node *tmp;
 640
 641         if (!n) {
 642                 BUG_ON(pd->bio_queue_size > 0);
 643                 return NULL;
 644         }
 645
 646         for (;;) {
 647                 tmp = rb_entry(n, struct pkt_rb_node, rb_node);
 648                 if (s <= tmp->bio->bi_iter.bi_sector)
 649                         next = n->rb_left;
 650                 else
 651                         next = n->rb_right;
 652                 if (!next)
 653                         break;
 654                 n = next;
 655         }
 656
 657         if (s > tmp->bio->bi_iter.bi_sector) {
 658                 tmp = pkt_rbtree_next(tmp);
 659                 if (!tmp)
 660                         return NULL;
 661         }
 662         BUG_ON(s > tmp->bio->bi_iter.bi_sector);
 663         return tmp;
 664 }
 665
 666 /*
 667  * Insert a node into the pd->bio_queue rb tree.
 668  */
 669 static void pkt_rbtree_insert(struct pktcdvd_device *pd, struct pkt_rb_node *node)
 670 {
 671         struct rb_node **p = &pd->bio_queue.rb_node;
 672         struct rb_node *parent = NULL;
 673         sector_t s = node->bio->bi_iter.bi_sector;
 674         struct pkt_rb_node *tmp;
 675
 676         while (*p) {
 677                 parent = *p;
 678                 tmp = rb_entry(parent, struct pkt_rb_node, rb_node);
 679                 if (s < tmp->bio->bi_iter.bi_sector)
 680                         p = &(*p)->rb_left;
 681                 else
 682                         p = &(*p)->rb_right;
 683         }
 684         rb_link_node(&node->rb_node, parent, p);
 685         rb_insert_color(&node->rb_node, &pd->bio_queue);
 686         pd->bio_queue_size++;
 687 }
 688
 689 /*
 690  * Send a packet_command to the underlying block device and
 691  * wait for completion.
 692  */
 693 static int pkt_generic_packet(struct pktcdvd_device *pd, struct packet_command *cgc)
 694 {
 695         struct request_queue *q = bdev_get_queue(pd->bdev);
 696         struct request *rq;
 697         int ret = 0;
 698
 699         rq = scsi_alloc_request(q, (cgc->data_direction == CGC_DATA_WRITE) ?
 700                              REQ_OP_DRV_OUT : REQ_OP_DRV_IN, 0);
 701         if (IS_ERR(rq))
 702                 return PTR_ERR(rq);
 703
 704         if (cgc->buflen) {
 705                 ret = blk_rq_map_kern(q, rq, cgc->buffer, cgc->buflen,
 706                                       GFP_NOIO);
 707                 if (ret)
 708                         goto out;
 709         }
 710
 711         scsi_req(rq)->cmd_len = COMMAND_SIZE(cgc->cmd[0]);
 712         memcpy(scsi_req(rq)->cmd, cgc->cmd, CDROM_PACKET_SIZE);
 713
 714         rq->timeout = 60*HZ;
 715         if (cgc->quiet)
 716                 rq->rq_flags |= RQF_QUIET;
 717
 718         blk_execute_rq(rq, false);
 719         if (scsi_req(rq)->result)
 720                 ret = -EIO;
 721 out:
 722         blk_mq_free_request(rq);
 723         return ret;
 724 }
 725
 726 static const char *sense_key_string(__u8 index)
 727 {
 728         static const char * const info[] = {
 729                 "No sense", "Recovered error", "Not ready",
 730                 "Medium error", "Hardware error", "Illegal request",
 731                 "Unit attention", "Data protect", "Blank check",
 732         };
 733
 734         return index < ARRAY_SIZE(info) ? info[index] : "INVALID";
 735 }
 736
 737 /*
 738  * A generic sense dump / resolve mechanism should be implemented across
 739  * all ATAPI + SCSI devices.
 740  */
 741 static void pkt_dump_sense(struct pktcdvd_device *pd,
 742                            struct packet_command *cgc)
 743 {
 744         struct scsi_sense_hdr *sshdr = cgc->sshdr;
 745
 746         if (sshdr)
 747                 pkt_err(pd, "%*ph - sense %02x.%02x.%02x (%s)\n",
 748                         CDROM_PACKET_SIZE, cgc->cmd,
 749                         sshdr->sense_key, sshdr->asc, sshdr->ascq,
 750                         sense_key_string(sshdr->sense_key));
 751         else
 752                 pkt_err(pd, "%*ph - no sense\n", CDROM_PACKET_SIZE, cgc->cmd);
 753 }
 754
 755 /*
 756  * flush the drive cache to media
 757  */
 758 static int pkt_flush_cache(struct pktcdvd_device *pd)
 759 {
 760         struct packet_command cgc;
 761
 762         init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
 763         cgc.cmd[0] = GPCMD_FLUSH_CACHE;
 764         cgc.quiet = 1;
 765
 766         /*
 767          * the IMMED bit -- we default to not setting it, although that
 768          * would allow a much faster close, this is safer
 769          */
 770 #if 0
 771         cgc.cmd[1] = 1 << 1;
 772 #endif
 773         return pkt_generic_packet(pd, &cgc);
 774 }
 775
 776 /*
 777  * speed is given as the normal factor, e.g. 4 for 4x
 778  */
 779 static noinline_for_stack int pkt_set_speed(struct pktcdvd_device *pd,
 780                                 unsigned write_speed, unsigned read_speed)
 781 {
 782         struct packet_command cgc;
 783         struct scsi_sense_hdr sshdr;
 784         int ret;
 785
 786         init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
 787         cgc.sshdr = &sshdr;
 788         cgc.cmd[0] = GPCMD_SET_SPEED;
 789         cgc.cmd[2] = (read_speed >> 8) & 0xff;
 790         cgc.cmd[3] = read_speed & 0xff;
 791         cgc.cmd[4] = (write_speed >> 8) & 0xff;
 792         cgc.cmd[5] = write_speed & 0xff;
 793
 794         ret = pkt_generic_packet(pd, &cgc);
 795         if (ret)
 796                 pkt_dump_sense(pd, &cgc);
 797
 798         return ret;
 799 }
 800
 801 /*
 802  * Queue a bio for processing by the low-level CD device. Must be called
 803  * from process context.
 804  */
 805 static void pkt_queue_bio(struct pktcdvd_device *pd, struct bio *bio)
 806 {
 807         spin_lock(&pd->iosched.lock);
 808         if (bio_data_dir(bio) == READ)
 809                 bio_list_add(&pd->iosched.read_queue, bio);
 810         else
 811                 bio_list_add(&pd->iosched.write_queue, bio);
 812         spin_unlock(&pd->iosched.lock);
 813
 814         atomic_set(&pd->iosched.attention, 1);
 815         wake_up(&pd->wqueue);
 816 }
 817
 818 /*
 819  * Process the queued read/write requests. This function handles special
 820  * requirements for CDRW drives:
 821  * - A cache flush command must be inserted before a read request if the
 822  *   previous request was a write.
 823  * - Switching between reading and writing is slow, so don't do it more often
 824  *   than necessary.
 825  * - Optimize for throughput at the expense of latency. This means that streaming
 826  *   writes will never be interrupted by a read, but if the drive has to seek
 827  *   before the next write, switch to reading instead if there are any pending
 828  *   read requests.
 829  * - Set the read speed according to current usage pattern. When only reading
 830  *   from the device, it's best to use the highest possible read speed, but
 831  *   when switching often between reading and writing, it's better to have the
 832  *   same read and write speeds.
 833  */
 834 static void pkt_iosched_process_queue(struct pktcdvd_device *pd)
 835 {
 836
 837         if (atomic_read(&pd->iosched.attention) == 0)
 838                 return;
 839         atomic_set(&pd->iosched.attention, 0);
 840
 841         for (;;) {
 842                 struct bio *bio;
 843                 int reads_queued, writes_queued;
 844
 845                 spin_lock(&pd->iosched.lock);
 846                 reads_queued = !bio_list_empty(&pd->iosched.read_queue);
 847                 writes_queued = !bio_list_empty(&pd->iosched.write_queue);
 848                 spin_unlock(&pd->iosched.lock);
 849
 850                 if (!reads_queued && !writes_queued)
 851                         break;
 852
 853                 if (pd->iosched.writing) {
 854                         int need_write_seek = 1;
 855                         spin_lock(&pd->iosched.lock);
 856                         bio = bio_list_peek(&pd->iosched.write_queue);
 857                         spin_unlock(&pd->iosched.lock);
 858                         if (bio && (bio->bi_iter.bi_sector ==
 859                                     pd->iosched.last_write))
 860                                 need_write_seek = 0;
 861                         if (need_write_seek && reads_queued) {
 862                                 if (atomic_read(&pd->cdrw.pending_bios) > 0) {
 863                                         pkt_dbg(2, pd, "write, waiting\n");
 864                                         break;
 865                                 }
 866                                 pkt_flush_cache(pd);
 867                                 pd->iosched.writing = 0;
 868                         }
 869                 } else {
 870                         if (!reads_queued && writes_queued) {
 871                                 if (atomic_read(&pd->cdrw.pending_bios) > 0) {
 872                                         pkt_dbg(2, pd, "read, waiting\n");
 873                                         break;
 874                                 }
 875                                 pd->iosched.writing = 1;
 876                         }
 877                 }
 878
 879                 spin_lock(&pd->iosched.lock);
 880                 if (pd->iosched.writing)
 881                         bio = bio_list_pop(&pd->iosched.write_queue);
 882                 else
 883                         bio = bio_list_pop(&pd->iosched.read_queue);
 884                 spin_unlock(&pd->iosched.lock);
 885
 886                 if (!bio)
 887                         continue;
 888
 889                 if (bio_data_dir(bio) == READ)
 890                         pd->iosched.successive_reads +=
 891                                 bio->bi_iter.bi_size >> 10;
 892                 else {
 893                         pd->iosched.successive_reads = 0;
 894                         pd->iosched.last_write = bio_end_sector(bio);
 895                 }
 896                 if (pd->iosched.successive_reads >= HI_SPEED_SWITCH) {
 897                         if (pd->read_speed == pd->write_speed) {
 898                                 pd->read_speed = MAX_SPEED;
 899                                 pkt_set_speed(pd, pd->write_speed, pd->read_speed);
 900                         }
 901                 } else {
 902                         if (pd->read_speed != pd->write_speed) {
 903                                 pd->read_speed = pd->write_speed;
 904                                 pkt_set_speed(pd, pd->write_speed, pd->read_speed);
 905                         }
 906                 }
 907
 908                 atomic_inc(&pd->cdrw.pending_bios);
 909                 submit_bio_noacct(bio);
 910         }
 911 }
 912
 913 /*
 914  * Special care is needed if the underlying block device has a small
 915  * max_phys_segments value.
 916  */
 917 static int pkt_set_segment_merging(struct pktcdvd_device *pd, struct request_queue *q)
 918 {
 919         if ((pd->settings.size << 9) / CD_FRAMESIZE
 920             <= queue_max_segments(q)) {
 921                 /*
 922                  * The cdrom device can handle one segment/frame
 923                  */
 924                 clear_bit(PACKET_MERGE_SEGS, &pd->flags);
 925                 return 0;
 926         } else if ((pd->settings.size << 9) / PAGE_SIZE
 927                    <= queue_max_segments(q)) {
 928                 /*
 929                  * We can handle this case at the expense of some extra memory
 930                  * copies during write operations
 931                  */
 932                 set_bit(PACKET_MERGE_SEGS, &pd->flags);
 933                 return 0;
 934         } else {
 935                 pkt_err(pd, "cdrom max_phys_segments too small\n");
 936                 return -EIO;
 937         }
 938 }
 939
 940 static void pkt_end_io_read(struct bio *bio)
 941 {
 942         struct packet_data *pkt = bio->bi_private;
 943         struct pktcdvd_device *pd = pkt->pd;
 944         BUG_ON(!pd);
 945
 946         pkt_dbg(2, pd, "bio=%p sec0=%llx sec=%llx err=%d\n",
 947                 bio, (unsigned long long)pkt->sector,
 948                 (unsigned long long)bio->bi_iter.bi_sector, bio->bi_status);
 949
 950         if (bio->bi_status)
 951                 atomic_inc(&pkt->io_errors);
 952         if (atomic_dec_and_test(&pkt->io_wait)) {
 953                 atomic_inc(&pkt->run_sm);
 954                 wake_up(&pd->wqueue);
 955         }
 956         pkt_bio_finished(pd);
 957 }
 958
 959 static void pkt_end_io_packet_write(struct bio *bio)
 960 {
 961         struct packet_data *pkt = bio->bi_private;
 962         struct pktcdvd_device *pd = pkt->pd;
 963         BUG_ON(!pd);
 964
 965         pkt_dbg(2, pd, "id=%d, err=%d\n", pkt->id, bio->bi_status);
 966
 967         pd->stats.pkt_ended++;
 968
 969         pkt_bio_finished(pd);
 970         atomic_dec(&pkt->io_wait);
 971         atomic_inc(&pkt->run_sm);
 972         wake_up(&pd->wqueue);
 973 }
 974
 975 /*
 976  * Schedule reads for the holes in a packet
 977  */
 978 static void pkt_gather_data(struct pktcdvd_device *pd, struct packet_data *pkt)
 979 {
 980         int frames_read = 0;
 981         struct bio *bio;
 982         int f;
 983         char written[PACKET_MAX_SIZE];
 984
 985         BUG_ON(bio_list_empty(&pkt->orig_bios));
 986
 987         atomic_set(&pkt->io_wait, 0);
 988         atomic_set(&pkt->io_errors, 0);
 989
 990         /*
 991          * Figure out which frames we need to read before we can write.
 992          */
 993         memset(written, 0, sizeof(written));
 994         spin_lock(&pkt->lock);
 995         bio_list_for_each(bio, &pkt->orig_bios) {
 996                 int first_frame = (bio->bi_iter.bi_sector - pkt->sector) /
 997                         (CD_FRAMESIZE >> 9);
 998                 int num_frames = bio->bi_iter.bi_size / CD_FRAMESIZE;
 999                 pd->stats.secs_w += num_frames * (CD_FRAMESIZE >> 9);
1000                 BUG_ON(first_frame < 0);
1001                 BUG_ON(first_frame + num_frames > pkt->frames);
1002                 for (f = first_frame; f < first_frame + num_frames; f++)
1003                         written[f] = 1;
1004         }
1005         spin_unlock(&pkt->lock);
1006
1007         if (pkt->cache_valid) {
1008                 pkt_dbg(2, pd, "zone %llx cached\n",
1009                         (unsigned long long)pkt->sector);
1010                 goto out_account;
1011         }
1012
1013         /*
1014          * Schedule reads for missing parts of the packet.
1015          */
1016         for (f = 0; f < pkt->frames; f++) {
1017                 int p, offset;
1018
1019                 if (written[f])
1020                         continue;
1021
1022                 bio = pkt->r_bios[f];
1023                 bio_reset(bio);
1024                 bio->bi_iter.bi_sector = pkt->sector + f * (CD_FRAMESIZE >> 9);
1025                 bio_set_dev(bio, pd->bdev);
1026                 bio->bi_end_io = pkt_end_io_read;
1027                 bio->bi_private = pkt;
1028
1029                 p = (f * CD_FRAMESIZE) / PAGE_SIZE;
1030                 offset = (f * CD_FRAMESIZE) % PAGE_SIZE;
1031                 pkt_dbg(2, pd, "Adding frame %d, page:%p offs:%d\n",
1032                         f, pkt->pages[p], offset);
1033                 if (!bio_add_page(bio, pkt->pages[p], CD_FRAMESIZE, offset))
1034                         BUG();
1035
1036                 atomic_inc(&pkt->io_wait);
1037                 bio_set_op_attrs(bio, REQ_OP_READ, 0);
1038                 pkt_queue_bio(pd, bio);
1039                 frames_read++;
1040         }
1041
1042 out_account:
1043         pkt_dbg(2, pd, "need %d frames for zone %llx\n",
1044                 frames_read, (unsigned long long)pkt->sector);
1045         pd->stats.pkt_started++;
1046         pd->stats.secs_rg += frames_read * (CD_FRAMESIZE >> 9);
1047 }
1048
1049 /*
1050  * Find a packet matching zone, or the least recently used packet if
1051  * there is no match.
1052  */
1053 static struct packet_data *pkt_get_packet_data(struct pktcdvd_device *pd, int zone)
1054 {
1055         struct packet_data *pkt;
1056
1057         list_for_each_entry(pkt, &pd->cdrw.pkt_free_list, list) {
1058                 if (pkt->sector == zone || pkt->list.next == &pd->cdrw.pkt_free_list) {
1059                         list_del_init(&pkt->list);
1060                         if (pkt->sector != zone)
1061                                 pkt->cache_valid = 0;
1062                         return pkt;
1063                 }
1064         }
1065         BUG();
1066         return NULL;
1067 }
1068
1069 static void pkt_put_packet_data(struct pktcdvd_device *pd, struct packet_data *pkt)
1070 {
1071         if (pkt->cache_valid) {
1072                 list_add(&pkt->list, &pd->cdrw.pkt_free_list);
1073         } else {
1074                 list_add_tail(&pkt->list, &pd->cdrw.pkt_free_list);
1075         }
1076 }
1077
1078 static inline void pkt_set_state(struct packet_data *pkt, enum packet_data_state state)
1079 {
1080 #if PACKET_DEBUG > 1
1081         static const char *state_name[] = {
1082                 "IDLE", "WAITING", "READ_WAIT", "WRITE_WAIT", "RECOVERY", "FINISHED"
1083         };
1084         enum packet_data_state old_state = pkt->state;
1085         pkt_dbg(2, pd, "pkt %2d : s=%6llx %s -> %s\n",
1086                 pkt->id, (unsigned long long)pkt->sector,
1087                 state_name[old_state], state_name[state]);
1088 #endif
1089         pkt->state = state;
1090 }
1091
1092 /*
1093  * Scan the work queue to see if we can start a new packet.
1094  * returns non-zero if any work was done.
1095  */
1096 static int pkt_handle_queue(struct pktcdvd_device *pd)
1097 {
1098         struct packet_data *pkt, *p;
1099         struct bio *bio = NULL;
1100         sector_t zone = 0; /* Suppress gcc warning */
1101         struct pkt_rb_node *node, *first_node;
1102         struct rb_node *n;
1103
1104         atomic_set(&pd->scan_queue, 0);
1105
1106         if (list_empty(&pd->cdrw.pkt_free_list)) {
1107                 pkt_dbg(2, pd, "no pkt\n");
1108                 return 0;
1109         }
1110
1111         /*
1112          * Try to find a zone we are not already working on.
1113          */
1114         spin_lock(&pd->lock);
1115         first_node = pkt_rbtree_find(pd, pd->current_sector);
1116         if (!first_node) {
1117                 n = rb_first(&pd->bio_queue);
1118                 if (n)
1119                         first_node = rb_entry(n, struct pkt_rb_node, rb_node);
1120         }
1121         node = first_node;
1122         while (node) {
1123                 bio = node->bio;
1124                 zone = get_zone(bio->bi_iter.bi_sector, pd);
1125                 list_for_each_entry(p, &pd->cdrw.pkt_active_list, list) {
1126                         if (p->sector == zone) {
1127                                 bio = NULL;
1128                                 goto try_next_bio;
1129                         }
1130                 }
1131                 break;
1132 try_next_bio:
1133                 node = pkt_rbtree_next(node);
1134                 if (!node) {
1135                         n = rb_first(&pd->bio_queue);
1136                         if (n)
1137                                 node = rb_entry(n, struct pkt_rb_node, rb_node);
1138                 }
1139                 if (node == first_node)
1140                         node = NULL;
1141         }
1142         spin_unlock(&pd->lock);
1143         if (!bio) {
1144                 pkt_dbg(2, pd, "no bio\n");
1145                 return 0;
1146         }
1147
1148         pkt = pkt_get_packet_data(pd, zone);
1149
1150         pd->current_sector = zone + pd->settings.size;
1151         pkt->sector = zone;
1152         BUG_ON(pkt->frames != pd->settings.size >> 2);
1153         pkt->write_size = 0;
1154
1155         /*
1156          * Scan work queue for bios in the same zone and link them
1157          * to this packet.
1158          */
1159         spin_lock(&pd->lock);
1160         pkt_dbg(2, pd, "looking for zone %llx\n", (unsigned long long)zone);
1161         while ((node = pkt_rbtree_find(pd, zone)) != NULL) {
1162                 bio = node->bio;
1163                 pkt_dbg(2, pd, "found zone=%llx\n", (unsigned long long)
1164                         get_zone(bio->bi_iter.bi_sector, pd));
1165                 if (get_zone(bio->bi_iter.bi_sector, pd) != zone)
1166                         break;
1167                 pkt_rbtree_erase(pd, node);
1168                 spin_lock(&pkt->lock);
1169                 bio_list_add(&pkt->orig_bios, bio);
1170                 pkt->write_size += bio->bi_iter.bi_size / CD_FRAMESIZE;
1171                 spin_unlock(&pkt->lock);
1172         }
1173         /* check write congestion marks, and if bio_queue_size is
1174          * below, wake up any waiters
1175          */
1176         if (pd->congested &&
1177             pd->bio_queue_size <= pd->write_congestion_off) {
1178                 pd->congested = false;
1179                 wake_up_var(&pd->congested);
1180         }
1181         spin_unlock(&pd->lock);
1182
1183         pkt->sleep_time = max(PACKET_WAIT_TIME, 1);
1184         pkt_set_state(pkt, PACKET_WAITING_STATE);
1185         atomic_set(&pkt->run_sm, 1);
1186
1187         spin_lock(&pd->cdrw.active_list_lock);
1188         list_add(&pkt->list, &pd->cdrw.pkt_active_list);
1189         spin_unlock(&pd->cdrw.active_list_lock);
1190
1191         return 1;
1192 }
1193
1194 /**
1195  * bio_list_copy_data - copy contents of data buffers from one chain of bios to
1196  * another
1197  * @src: source bio list
1198  * @dst: destination bio list
1199  *
1200  * Stops when it reaches the end of either the @src list or @dst list - that is,
1201  * copies min(src->bi_size, dst->bi_size) bytes (or the equivalent for lists of
1202  * bios).
1203  */
1204 static void bio_list_copy_data(struct bio *dst, struct bio *src)
1205 {
1206         struct bvec_iter src_iter = src->bi_iter;
1207         struct bvec_iter dst_iter = dst->bi_iter;
1208
1209         while (1) {
1210                 if (!src_iter.bi_size) {
1211                         src = src->bi_next;
1212                         if (!src)
1213                                 break;
1214
1215                         src_iter = src->bi_iter;
1216                 }
1217
1218                 if (!dst_iter.bi_size) {
1219                         dst = dst->bi_next;
1220                         if (!dst)
1221                                 break;
1222
1223                         dst_iter = dst->bi_iter;
1224                 }
1225
1226                 bio_copy_data_iter(dst, &dst_iter, src, &src_iter);
1227         }
1228 }
1229
1230 /*
1231  * Assemble a bio to write one packet and queue the bio for processing
1232  * by the underlying block device.
1233  */
1234 static void pkt_start_write(struct pktcdvd_device *pd, struct packet_data *pkt)
1235 {
1236         int f;
1237
1238         bio_reset(pkt->w_bio);
1239         pkt->w_bio->bi_iter.bi_sector = pkt->sector;
1240         bio_set_dev(pkt->w_bio, pd->bdev);
1241         pkt->w_bio->bi_end_io = pkt_end_io_packet_write;
1242         pkt->w_bio->bi_private = pkt;
1243
1244         /* XXX: locking? */
1245         for (f = 0; f < pkt->frames; f++) {
1246                 struct page *page = pkt->pages[(f * CD_FRAMESIZE) / PAGE_SIZE];
1247                 unsigned offset = (f * CD_FRAMESIZE) % PAGE_SIZE;
1248
1249                 if (!bio_add_page(pkt->w_bio, page, CD_FRAMESIZE, offset))
1250                         BUG();
1251         }
1252         pkt_dbg(2, pd, "vcnt=%d\n", pkt->w_bio->bi_vcnt);
1253
1254         /*
1255          * Fill-in bvec with data from orig_bios.
1256          */
1257         spin_lock(&pkt->lock);
1258         bio_list_copy_data(pkt->w_bio, pkt->orig_bios.head);
1259
1260         pkt_set_state(pkt, PACKET_WRITE_WAIT_STATE);
1261         spin_unlock(&pkt->lock);
1262
1263         pkt_dbg(2, pd, "Writing %d frames for zone %llx\n",
1264                 pkt->write_size, (unsigned long long)pkt->sector);
1265
1266         if (test_bit(PACKET_MERGE_SEGS, &pd->flags) || (pkt->write_size < pkt->frames))
1267                 pkt->cache_valid = 1;
1268         else
1269                 pkt->cache_valid = 0;
1270
1271         /* Start the write request */
1272         atomic_set(&pkt->io_wait, 1);
1273         bio_set_op_attrs(pkt->w_bio, REQ_OP_WRITE, 0);
1274         pkt_queue_bio(pd, pkt->w_bio);
1275 }
1276
1277 static void pkt_finish_packet(struct packet_data *pkt, blk_status_t status)
1278 {
1279         struct bio *bio;
1280
1281         if (status)
1282                 pkt->cache_valid = 0;
1283
1284         /* Finish all bios corresponding to this packet */
1285         while ((bio = bio_list_pop(&pkt->orig_bios))) {
1286                 bio->bi_status = status;
1287                 bio_endio(bio);
1288         }
1289 }
1290
1291 static void pkt_run_state_machine(struct pktcdvd_device *pd, struct packet_data *pkt)
1292 {
1293         pkt_dbg(2, pd, "pkt %d\n", pkt->id);
1294
1295         for (;;) {
1296                 switch (pkt->state) {
1297                 case PACKET_WAITING_STATE:
1298                         if ((pkt->write_size < pkt->frames) && (pkt->sleep_time > 0))
1299                                 return;
1300
1301                         pkt->sleep_time = 0;
1302                         pkt_gather_data(pd, pkt);
1303                         pkt_set_state(pkt, PACKET_READ_WAIT_STATE);
1304                         break;
1305
1306                 case PACKET_READ_WAIT_STATE:
1307                         if (atomic_read(&pkt->io_wait) > 0)
1308                                 return;
1309
1310                         if (atomic_read(&pkt->io_errors) > 0) {
1311                                 pkt_set_state(pkt, PACKET_RECOVERY_STATE);
1312                         } else {
1313                                 pkt_start_write(pd, pkt);
1314                         }
1315                         break;
1316
1317                 case PACKET_WRITE_WAIT_STATE:
1318                         if (atomic_read(&pkt->io_wait) > 0)
1319                                 return;
1320
1321                         if (!pkt->w_bio->bi_status) {
1322                                 pkt_set_state(pkt, PACKET_FINISHED_STATE);
1323                         } else {
1324                                 pkt_set_state(pkt, PACKET_RECOVERY_STATE);
1325                         }
1326                         break;
1327
1328                 case PACKET_RECOVERY_STATE:
1329                         pkt_dbg(2, pd, "No recovery possible\n");
1330                         pkt_set_state(pkt, PACKET_FINISHED_STATE);
1331                         break;
1332
1333                 case PACKET_FINISHED_STATE:
1334                         pkt_finish_packet(pkt, pkt->w_bio->bi_status);
1335                         return;
1336
1337                 default:
1338                         BUG();
1339                         break;
1340                 }
1341         }
1342 }
1343
1344 static void pkt_handle_packets(struct pktcdvd_device *pd)
1345 {
1346         struct packet_data *pkt, *next;
1347
1348         /*
1349          * Run state machine for active packets
1350          */
1351         list_for_each_entry(pkt, &pd->cdrw.pkt_active_list, list) {
1352                 if (atomic_read(&pkt->run_sm) > 0) {
1353                         atomic_set(&pkt->run_sm, 0);
1354                         pkt_run_state_machine(pd, pkt);
1355                 }
1356         }
1357
1358         /*
1359          * Move no longer active packets to the free list
1360          */
1361         spin_lock(&pd->cdrw.active_list_lock);
1362         list_for_each_entry_safe(pkt, next, &pd->cdrw.pkt_active_list, list) {
1363                 if (pkt->state == PACKET_FINISHED_STATE) {
1364                         list_del(&pkt->list);
1365                         pkt_put_packet_data(pd, pkt);
1366                         pkt_set_state(pkt, PACKET_IDLE_STATE);
1367                         atomic_set(&pd->scan_queue, 1);
1368                 }
1369         }
1370         spin_unlock(&pd->cdrw.active_list_lock);
1371 }
1372
1373 static void pkt_count_states(struct pktcdvd_device *pd, int *states)
1374 {
1375         struct packet_data *pkt;
1376         int i;
1377
1378         for (i = 0; i < PACKET_NUM_STATES; i++)
1379                 states[i] = 0;
1380
1381         spin_lock(&pd->cdrw.active_list_lock);
1382         list_for_each_entry(pkt, &pd->cdrw.pkt_active_list, list) {
1383                 states[pkt->state]++;
1384         }
1385         spin_unlock(&pd->cdrw.active_list_lock);
1386 }
1387
1388 /*
1389  * kcdrwd is woken up when writes have been queued for one of our
1390  * registered devices
1391  */
1392 static int kcdrwd(void *foobar)
1393 {
1394         struct pktcdvd_device *pd = foobar;
1395         struct packet_data *pkt;
1396         long min_sleep_time, residue;
1397
1398         set_user_nice(current, MIN_NICE);
1399         set_freezable();
1400
1401         for (;;) {
1402                 DECLARE_WAITQUEUE(wait, current);
1403
1404                 /*
1405                  * Wait until there is something to do
1406                  */
1407                 add_wait_queue(&pd->wqueue, &wait);
1408                 for (;;) {
1409                         set_current_state(TASK_INTERRUPTIBLE);
1410
1411                         /* Check if we need to run pkt_handle_queue */
1412                         if (atomic_read(&pd->scan_queue) > 0)
1413                                 goto work_to_do;
1414
1415                         /* Check if we need to run the state machine for some packet */
1416                         list_for_each_entry(pkt, &pd->cdrw.pkt_active_list, list) {
1417                                 if (atomic_read(&pkt->run_sm) > 0)
1418                                         goto work_to_do;
1419                         }
1420
1421                         /* Check if we need to process the iosched queues */
1422                         if (atomic_read(&pd->iosched.attention) != 0)
1423                                 goto work_to_do;
1424
1425                         /* Otherwise, go to sleep */
1426                         if (PACKET_DEBUG > 1) {
1427                                 int states[PACKET_NUM_STATES];
1428                                 pkt_count_states(pd, states);
1429                                 pkt_dbg(2, pd, "i:%d ow:%d rw:%d ww:%d rec:%d fin:%d\n",
1430                                         states[0], states[1], states[2],
1431                                         states[3], states[4], states[5]);
1432                         }
1433
1434                         min_sleep_time = MAX_SCHEDULE_TIMEOUT;
1435                         list_for_each_entry(pkt, &pd->cdrw.pkt_active_list, list) {
1436                                 if (pkt->sleep_time && pkt->sleep_time < min_sleep_time)
1437                                         min_sleep_time = pkt->sleep_time;
1438                         }
1439
1440                         pkt_dbg(2, pd, "sleeping\n");
1441                         residue = schedule_timeout(min_sleep_time);
1442                         pkt_dbg(2, pd, "wake up\n");
1443
1444                         /* make swsusp happy with our thread */
1445                         try_to_freeze();
1446
1447                         list_for_each_entry(pkt, &pd->cdrw.pkt_active_list, list) {
1448                                 if (!pkt->sleep_time)
1449                                         continue;
1450                                 pkt->sleep_time -= min_sleep_time - residue;
1451                                 if (pkt->sleep_time <= 0) {
1452                                         pkt->sleep_time = 0;
1453                                         atomic_inc(&pkt->run_sm);
1454                                 }
1455                         }
1456
1457                         if (kthread_should_stop())
1458                                 break;
1459                 }
1460 work_to_do:
1461                 set_current_state(TASK_RUNNING);
1462                 remove_wait_queue(&pd->wqueue, &wait);
1463
1464                 if (kthread_should_stop())
1465                         break;
1466
1467                 /*
1468                  * if pkt_handle_queue returns true, we can queue
1469                  * another request.
1470                  */
1471                 while (pkt_handle_queue(pd))
1472                         ;
1473
1474                 /*
1475                  * Handle packet state machine
1476                  */
1477                 pkt_handle_packets(pd);
1478
1479                 /*
1480                  * Handle iosched queues
1481                  */
1482                 pkt_iosched_process_queue(pd);
1483         }
1484
1485         return 0;
1486 }
1487
1488 static void pkt_print_settings(struct pktcdvd_device *pd)
1489 {
1490         pkt_info(pd, "%s packets, %u blocks, Mode-%c disc\n",
1491                  pd->settings.fp ? "Fixed" : "Variable",
1492                  pd->settings.size >> 2,
1493                  pd->settings.block_mode == 8 ? '1' : '2');
1494 }
1495
1496 static int pkt_mode_sense(struct pktcdvd_device *pd, struct packet_command *cgc, int page_code, int page_control)
1497 {
1498         memset(cgc->cmd, 0, sizeof(cgc->cmd));
1499
1500         cgc->cmd[0] = GPCMD_MODE_SENSE_10;
1501         cgc->cmd[2] = page_code | (page_control << 6);
1502         cgc->cmd[7] = cgc->buflen >> 8;
1503         cgc->cmd[8] = cgc->buflen & 0xff;
1504         cgc->data_direction = CGC_DATA_READ;
1505         return pkt_generic_packet(pd, cgc);
1506 }
1507
1508 static int pkt_mode_select(struct pktcdvd_device *pd, struct packet_command *cgc)
1509 {
1510         memset(cgc->cmd, 0, sizeof(cgc->cmd));
1511         memset(cgc->buffer, 0, 2);
1512         cgc->cmd[0] = GPCMD_MODE_SELECT_10;
1513         cgc->cmd[1] = 0x10;             /* PF */
1514         cgc->cmd[7] = cgc->buflen >> 8;
1515         cgc->cmd[8] = cgc->buflen & 0xff;
1516         cgc->data_direction = CGC_DATA_WRITE;
1517         return pkt_generic_packet(pd, cgc);
1518 }
1519
1520 static int pkt_get_disc_info(struct pktcdvd_device *pd, disc_information *di)
1521 {
1522         struct packet_command cgc;
1523         int ret;
1524
1525         /* set up command and get the disc info */
1526         init_cdrom_command(&cgc, di, sizeof(*di), CGC_DATA_READ);
1527         cgc.cmd[0] = GPCMD_READ_DISC_INFO;
1528         cgc.cmd[8] = cgc.buflen = 2;
1529         cgc.quiet = 1;
1530
1531         ret = pkt_generic_packet(pd, &cgc);
1532         if (ret)
1533                 return ret;
1534
1535         /* not all drives have the same disc_info length, so requeue
1536          * packet with the length the drive tells us it can supply
1537          */
1538         cgc.buflen = be16_to_cpu(di->disc_information_length) +
1539                      sizeof(di->disc_information_length);
1540
1541         if (cgc.buflen > sizeof(disc_information))
1542                 cgc.buflen = sizeof(disc_information);
1543
1544         cgc.cmd[8] = cgc.buflen;
1545         return pkt_generic_packet(pd, &cgc);
1546 }
1547
1548 static int pkt_get_track_info(struct pktcdvd_device *pd, __u16 track, __u8 type, track_information *ti)
1549 {
1550         struct packet_command cgc;
1551         int ret;
1552
1553         init_cdrom_command(&cgc, ti, 8, CGC_DATA_READ);
1554         cgc.cmd[0] = GPCMD_READ_TRACK_RZONE_INFO;
1555         cgc.cmd[1] = type & 3;
1556         cgc.cmd[4] = (track & 0xff00) >> 8;
1557         cgc.cmd[5] = track & 0xff;
1558         cgc.cmd[8] = 8;
1559         cgc.quiet = 1;
1560
1561         ret = pkt_generic_packet(pd, &cgc);
1562         if (ret)
1563                 return ret;
1564
1565         cgc.buflen = be16_to_cpu(ti->track_information_length) +
1566                      sizeof(ti->track_information_length);
1567
1568         if (cgc.buflen > sizeof(track_information))
1569                 cgc.buflen = sizeof(track_information);
1570
1571         cgc.cmd[8] = cgc.buflen;
1572         return pkt_generic_packet(pd, &cgc);
1573 }
1574
1575 static noinline_for_stack int pkt_get_last_written(struct pktcdvd_device *pd,
1576                                                 long *last_written)
1577 {
1578         disc_information di;
1579         track_information ti;
1580         __u32 last_track;
1581         int ret;
1582
1583         ret = pkt_get_disc_info(pd, &di);
1584         if (ret)
1585                 return ret;
1586
1587         last_track = (di.last_track_msb << 8) | di.last_track_lsb;
1588         ret = pkt_get_track_info(pd, last_track, 1, &ti);
1589         if (ret)
1590                 return ret;
1591
1592         /* if this track is blank, try the previous. */
1593         if (ti.blank) {
1594                 last_track--;
1595                 ret = pkt_get_track_info(pd, last_track, 1, &ti);
1596                 if (ret)
1597                         return ret;
1598         }
1599
1600         /* if last recorded field is valid, return it. */
1601         if (ti.lra_v) {
1602                 *last_written = be32_to_cpu(ti.last_rec_address);
1603         } else {
1604                 /* make it up instead */
1605                 *last_written = be32_to_cpu(ti.track_start) +
1606                                 be32_to_cpu(ti.track_size);
1607                 if (ti.free_blocks)
1608                         *last_written -= (be32_to_cpu(ti.free_blocks) + 7);
1609         }
1610         return 0;
1611 }
1612
1613 /*
1614  * write mode select package based on pd->settings
1615  */
1616 static noinline_for_stack int pkt_set_write_settings(struct pktcdvd_device *pd)
1617 {
1618         struct packet_command cgc;
1619         struct scsi_sense_hdr sshdr;
1620         write_param_page *wp;
1621         char buffer[128];
1622         int ret, size;
1623
1624         /* doesn't apply to DVD+RW or DVD-RAM */
1625         if ((pd->mmc3_profile == 0x1a) || (pd->mmc3_profile == 0x12))
1626                 return 0;
1627
1628         memset(buffer, 0, sizeof(buffer));
1629         init_cdrom_command(&cgc, buffer, sizeof(*wp), CGC_DATA_READ);
1630         cgc.sshdr = &sshdr;
1631         ret = pkt_mode_sense(pd, &cgc, GPMODE_WRITE_PARMS_PAGE, 0);
1632         if (ret) {
1633                 pkt_dump_sense(pd, &cgc);
1634                 return ret;
1635         }
1636
1637         size = 2 + ((buffer[0] << 8) | (buffer[1] & 0xff));
1638         pd->mode_offset = (buffer[6] << 8) | (buffer[7] & 0xff);
1639         if (size > sizeof(buffer))
1640                 size = sizeof(buffer);
1641
1642         /*
1643          * now get it all
1644          */
1645         init_cdrom_command(&cgc, buffer, size, CGC_DATA_READ);
1646         cgc.sshdr = &sshdr;
1647         ret = pkt_mode_sense(pd, &cgc, GPMODE_WRITE_PARMS_PAGE, 0);
1648         if (ret) {
1649                 pkt_dump_sense(pd, &cgc);
1650                 return ret;
1651         }
1652
1653         /*
1654          * write page is offset header + block descriptor length
1655          */
1656         wp = (write_param_page *) &buffer[sizeof(struct mode_page_header) + pd->mode_offset];
1657
1658         wp->fp = pd->settings.fp;
1659         wp->track_mode = pd->settings.track_mode;
1660         wp->write_type = pd->settings.write_type;
1661         wp->data_block_type = pd->settings.block_mode;
1662
1663         wp->multi_session = 0;
1664
1665 #ifdef PACKET_USE_LS
1666         wp->link_size = 7;
1667         wp->ls_v = 1;
1668 #endif
1669
1670         if (wp->data_block_type == PACKET_BLOCK_MODE1) {
1671                 wp->session_format = 0;
1672                 wp->subhdr2 = 0x20;
1673         } else if (wp->data_block_type == PACKET_BLOCK_MODE2) {
1674                 wp->session_format = 0x20;
1675                 wp->subhdr2 = 8;
1676 #if 0
1677                 wp->mcn[0] = 0x80;
1678                 memcpy(&wp->mcn[1], PACKET_MCN, sizeof(wp->mcn) - 1);
1679 #endif
1680         } else {
1681                 /*
1682                  * paranoia
1683                  */
1684                 pkt_err(pd, "write mode wrong %d\n", wp->data_block_type);
1685                 return 1;
1686         }
1687         wp->packet_size = cpu_to_be32(pd->settings.size >> 2);
1688
1689         cgc.buflen = cgc.cmd[8] = size;
1690         ret = pkt_mode_select(pd, &cgc);
1691         if (ret) {
1692                 pkt_dump_sense(pd, &cgc);
1693                 return ret;
1694         }
1695
1696         pkt_print_settings(pd);
1697         return 0;
1698 }
1699
1700 /*
1701  * 1 -- we can write to this track, 0 -- we can't
1702  */
1703 static int pkt_writable_track(struct pktcdvd_device *pd, track_information *ti)
1704 {
1705         switch (pd->mmc3_profile) {
1706                 case 0x1a: /* DVD+RW */
1707                 case 0x12: /* DVD-RAM */
1708                         /* The track is always writable on DVD+RW/DVD-RAM */
1709                         return 1;
1710                 default:
1711                         break;
1712         }
1713
1714         if (!ti->packet || !ti->fp)
1715                 return 0;
1716
1717         /*
1718          * "good" settings as per Mt Fuji.
1719          */
1720         if (ti->rt == 0 && ti->blank == 0)
1721                 return 1;
1722
1723         if (ti->rt == 0 && ti->blank == 1)
1724                 return 1;
1725
1726         if (ti->rt == 1 && ti->blank == 0)
1727                 return 1;
1728
1729         pkt_err(pd, "bad state %d-%d-%d\n", ti->rt, ti->blank, ti->packet);
1730         return 0;
1731 }
1732
1733 /*
1734  * 1 -- we can write to this disc, 0 -- we can't
1735  */
1736 static int pkt_writable_disc(struct pktcdvd_device *pd, disc_information *di)
1737 {
1738         switch (pd->mmc3_profile) {
1739                 case 0x0a: /* CD-RW */
1740                 case 0xffff: /* MMC3 not supported */
1741                         break;
1742                 case 0x1a: /* DVD+RW */
1743                 case 0x13: /* DVD-RW */
1744                 case 0x12: /* DVD-RAM */
1745                         return 1;
1746                 default:
1747                         pkt_dbg(2, pd, "Wrong disc profile (%x)\n",
1748                                 pd->mmc3_profile);
1749                         return 0;
1750         }
1751
1752         /*
1753          * for disc type 0xff we should probably reserve a new track.
1754          * but i'm not sure, should we leave this to user apps? probably.
1755          */
1756         if (di->disc_type == 0xff) {
1757                 pkt_notice(pd, "unknown disc - no track?\n");
1758                 return 0;
1759         }
1760
1761         if (di->disc_type != 0x20 && di->disc_type != 0) {
1762                 pkt_err(pd, "wrong disc type (%x)\n", di->disc_type);
1763                 return 0;
1764         }
1765
1766         if (di->erasable == 0) {
1767                 pkt_notice(pd, "disc not erasable\n");
1768                 return 0;
1769         }
1770
1771         if (di->border_status == PACKET_SESSION_RESERVED) {
1772                 pkt_err(pd, "can't write to last track (reserved)\n");
1773                 return 0;
1774         }
1775
1776         return 1;
1777 }
1778
1779 static noinline_for_stack int pkt_probe_settings(struct pktcdvd_device *pd)
1780 {
1781         struct packet_command cgc;
1782         unsigned char buf[12];
1783         disc_information di;
1784         track_information ti;
1785         int ret, track;
1786
1787         init_cdrom_command(&cgc, buf, sizeof(buf), CGC_DATA_READ);
1788         cgc.cmd[0] = GPCMD_GET_CONFIGURATION;
1789         cgc.cmd[8] = 8;
1790         ret = pkt_generic_packet(pd, &cgc);
1791         pd->mmc3_profile = ret ? 0xffff : buf[6] << 8 | buf[7];
1792
1793         memset(&di, 0, sizeof(disc_information));
1794         memset(&ti, 0, sizeof(track_information));
1795
1796         ret = pkt_get_disc_info(pd, &di);
1797         if (ret) {
1798                 pkt_err(pd, "failed get_disc\n");
1799                 return ret;
1800         }
1801
1802         if (!pkt_writable_disc(pd, &di))
1803                 return -EROFS;
1804
1805         pd->type = di.erasable ? PACKET_CDRW : PACKET_CDR;
1806
1807         track = 1; /* (di.last_track_msb << 8) | di.last_track_lsb; */
1808         ret = pkt_get_track_info(pd, track, 1, &ti);
1809         if (ret) {
1810                 pkt_err(pd, "failed get_track\n");
1811                 return ret;
1812         }
1813
1814         if (!pkt_writable_track(pd, &ti)) {
1815                 pkt_err(pd, "can't write to this track\n");
1816                 return -EROFS;
1817         }
1818
1819         /*
1820          * we keep packet size in 512 byte units, makes it easier to
1821          * deal with request calculations.
1822          */
1823         pd->settings.size = be32_to_cpu(ti.fixed_packet_size) << 2;
1824         if (pd->settings.size == 0) {
1825                 pkt_notice(pd, "detected zero packet size!\n");
1826                 return -ENXIO;
1827         }
1828         if (pd->settings.size > PACKET_MAX_SECTORS) {
1829                 pkt_err(pd, "packet size is too big\n");
1830                 return -EROFS;
1831         }
1832         pd->settings.fp = ti.fp;
1833         pd->offset = (be32_to_cpu(ti.track_start) << 2) & (pd->settings.size - 1);
1834
1835         if (ti.nwa_v) {
1836                 pd->nwa = be32_to_cpu(ti.next_writable);
1837                 set_bit(PACKET_NWA_VALID, &pd->flags);
1838         }
1839
1840         /*
1841          * in theory we could use lra on -RW media as well and just zero
1842          * blocks that haven't been written yet, but in practice that
1843          * is just a no-go. we'll use that for -R, naturally.
1844          */
1845         if (ti.lra_v) {
1846                 pd->lra = be32_to_cpu(ti.last_rec_address);
1847                 set_bit(PACKET_LRA_VALID, &pd->flags);
1848         } else {
1849                 pd->lra = 0xffffffff;
1850                 set_bit(PACKET_LRA_VALID, &pd->flags);
1851         }
1852
1853         /*
1854          * fine for now
1855          */
1856         pd->settings.link_loss = 7;
1857         pd->settings.write_type = 0;    /* packet */
1858         pd->settings.track_mode = ti.track_mode;
1859
1860         /*
1861          * mode1 or mode2 disc
1862          */
1863         switch (ti.data_mode) {
1864                 case PACKET_MODE1:
1865                         pd->settings.block_mode = PACKET_BLOCK_MODE1;
1866                         break;
1867                 case PACKET_MODE2:
1868                         pd->settings.block_mode = PACKET_BLOCK_MODE2;
1869                         break;
1870                 default:
1871                         pkt_err(pd, "unknown data mode\n");
1872                         return -EROFS;
1873         }
1874         return 0;
1875 }
1876
1877 /*
1878  * enable/disable write caching on drive
1879  */
1880 static noinline_for_stack int pkt_write_caching(struct pktcdvd_device *pd,
1881                                                 int set)
1882 {
1883         struct packet_command cgc;
1884         struct scsi_sense_hdr sshdr;
1885         unsigned char buf[64];
1886         int ret;
1887
1888         init_cdrom_command(&cgc, buf, sizeof(buf), CGC_DATA_READ);
1889         cgc.sshdr = &sshdr;
1890         cgc.buflen = pd->mode_offset + 12;
1891
1892         /*
1893          * caching mode page might not be there, so quiet this command
1894          */
1895         cgc.quiet = 1;
1896
1897         ret = pkt_mode_sense(pd, &cgc, GPMODE_WCACHING_PAGE, 0);
1898         if (ret)
1899                 return ret;
1900
1901         buf[pd->mode_offset + 10] |= (!!set << 2);
1902
1903         cgc.buflen = cgc.cmd[8] = 2 + ((buf[0] << 8) | (buf[1] & 0xff));
1904         ret = pkt_mode_select(pd, &cgc);
1905         if (ret) {
1906                 pkt_err(pd, "write caching control failed\n");
1907                 pkt_dump_sense(pd, &cgc);
1908         } else if (!ret && set)
1909                 pkt_notice(pd, "enabled write caching\n");
1910         return ret;
1911 }
1912
1913 static int pkt_lock_door(struct pktcdvd_device *pd, int lockflag)
1914 {
1915         struct packet_command cgc;
1916
1917         init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
1918         cgc.cmd[0] = GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL;
1919         cgc.cmd[4] = lockflag ? 1 : 0;
1920         return pkt_generic_packet(pd, &cgc);
1921 }
1922
1923 /*
1924  * Returns drive maximum write speed
1925  */
1926 static noinline_for_stack int pkt_get_max_speed(struct pktcdvd_device *pd,
1927                                                 unsigned *write_speed)
1928 {
1929         struct packet_command cgc;
1930         struct scsi_sense_hdr sshdr;
1931         unsigned char buf[256+18];
1932         unsigned char *cap_buf;
1933         int ret, offset;
1934
1935         cap_buf = &buf[sizeof(struct mode_page_header) + pd->mode_offset];
1936         init_cdrom_command(&cgc, buf, sizeof(buf), CGC_DATA_UNKNOWN);
1937         cgc.sshdr = &sshdr;
1938
1939         ret = pkt_mode_sense(pd, &cgc, GPMODE_CAPABILITIES_PAGE, 0);
1940         if (ret) {
1941                 cgc.buflen = pd->mode_offset + cap_buf[1] + 2 +
1942                              sizeof(struct mode_page_header);
1943                 ret = pkt_mode_sense(pd, &cgc, GPMODE_CAPABILITIES_PAGE, 0);
1944                 if (ret) {
1945                         pkt_dump_sense(pd, &cgc);
1946                         return ret;
1947                 }
1948         }
1949
1950         offset = 20;                        /* Obsoleted field, used by older drives */
1951         if (cap_buf[1] >= 28)
1952                 offset = 28;                /* Current write speed selected */
1953         if (cap_buf[1] >= 30) {
1954                 /* If the drive reports at least one "Logical Unit Write
1955                  * Speed Performance Descriptor Block", use the information
1956                  * in the first block. (contains the highest speed)
1957                  */
1958                 int num_spdb = (cap_buf[30] << 8) + cap_buf[31];
1959                 if (num_spdb > 0)
1960                         offset = 34;
1961         }
1962
1963         *write_speed = (cap_buf[offset] << 8) | cap_buf[offset + 1];
1964         return 0;
1965 }
1966
1967 /* These tables from cdrecord - I don't have orange book */
1968 /* standard speed CD-RW (1-4x) */
1969 static char clv_to_speed[16] = {
1970         /* 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 */
1971            0, 2, 4, 6, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
1972 };
1973 /* high speed CD-RW (-10x) */
1974 static char hs_clv_to_speed[16] = {
1975         /* 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 */
1976            0, 2, 4, 6, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
1977 };
1978 /* ultra high speed CD-RW */
1979 static char us_clv_to_speed[16] = {
1980         /* 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 */
1981            0, 2, 4, 8, 0, 0,16, 0,24,32,40,48, 0, 0, 0, 0
1982 };
1983
1984 /*
1985  * reads the maximum media speed from ATIP
1986  */
1987 static noinline_for_stack int pkt_media_speed(struct pktcdvd_device *pd,
1988                                                 unsigned *speed)
1989 {
1990         struct packet_command cgc;
1991         struct scsi_sense_hdr sshdr;
1992         unsigned char buf[64];
1993         unsigned int size, st, sp;
1994         int ret;
1995
1996         init_cdrom_command(&cgc, buf, 2, CGC_DATA_READ);
1997         cgc.sshdr = &sshdr;
1998         cgc.cmd[0] = GPCMD_READ_TOC_PMA_ATIP;
1999         cgc.cmd[1] = 2;
2000         cgc.cmd[2] = 4; /* READ ATIP */
2001         cgc.cmd[8] = 2;
2002         ret = pkt_generic_packet(pd, &cgc);
2003         if (ret) {
2004                 pkt_dump_sense(pd, &cgc);
2005                 return ret;
2006         }
2007         size = ((unsigned int) buf[0]<<8) + buf[1] + 2;
2008         if (size > sizeof(buf))
2009                 size = sizeof(buf);
2010
2011         init_cdrom_command(&cgc, buf, size, CGC_DATA_READ);
2012         cgc.sshdr = &sshdr;
2013         cgc.cmd[0] = GPCMD_READ_TOC_PMA_ATIP;
2014         cgc.cmd[1] = 2;
2015         cgc.cmd[2] = 4;
2016         cgc.cmd[8] = size;
2017         ret = pkt_generic_packet(pd, &cgc);
2018         if (ret) {
2019                 pkt_dump_sense(pd, &cgc);
2020                 return ret;
2021         }
2022
2023         if (!(buf[6] & 0x40)) {
2024                 pkt_notice(pd, "disc type is not CD-RW\n");
2025                 return 1;
2026         }
2027         if (!(buf[6] & 0x4)) {
2028                 pkt_notice(pd, "A1 values on media are not valid, maybe not CDRW?\n");
2029                 return 1;
2030         }
2031
2032         st = (buf[6] >> 3) & 0x7; /* disc sub-type */
2033
2034         sp = buf[16] & 0xf; /* max speed from ATIP A1 field */
2035
2036         /* Info from cdrecord */
2037         switch (st) {
2038                 case 0: /* standard speed */
2039                         *speed = clv_to_speed[sp];
2040                         break;
2041                 case 1: /* high speed */
2042                         *speed = hs_clv_to_speed[sp];
2043                         break;
2044                 case 2: /* ultra high speed */
2045                         *speed = us_clv_to_speed[sp];
2046                         break;
2047                 default:
2048                         pkt_notice(pd, "unknown disc sub-type %d\n", st);
2049                         return 1;
2050         }
2051         if (*speed) {
2052                 pkt_info(pd, "maximum media speed: %d\n", *speed);
2053                 return 0;
2054         } else {
2055                 pkt_notice(pd, "unknown speed %d for sub-type %d\n", sp, st);
2056                 return 1;
2057         }
2058 }
2059
2060 static noinline_for_stack int pkt_perform_opc(struct pktcdvd_device *pd)
2061 {
2062         struct packet_command cgc;
2063         struct scsi_sense_hdr sshdr;
2064         int ret;
2065
2066         pkt_dbg(2, pd, "Performing OPC\n");
2067
2068         init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
2069         cgc.sshdr = &sshdr;
2070         cgc.timeout = 60*HZ;
2071         cgc.cmd[0] = GPCMD_SEND_OPC;
2072         cgc.cmd[1] = 1;
2073         ret = pkt_generic_packet(pd, &cgc);
2074         if (ret)
2075                 pkt_dump_sense(pd, &cgc);
2076         return ret;
2077 }
2078
2079 static int pkt_open_write(struct pktcdvd_device *pd)
2080 {
2081         int ret;
2082         unsigned int write_speed, media_write_speed, read_speed;
2083
2084         ret = pkt_probe_settings(pd);
2085         if (ret) {
2086                 pkt_dbg(2, pd, "failed probe\n");
2087                 return ret;
2088         }
2089
2090         ret = pkt_set_write_settings(pd);
2091         if (ret) {
2092                 pkt_dbg(1, pd, "failed saving write settings\n");
2093                 return -EIO;
2094         }
2095
2096         pkt_write_caching(pd, USE_WCACHING);
2097
2098         ret = pkt_get_max_speed(pd, &write_speed);
2099         if (ret)
2100                 write_speed = 16 * 177;
2101         switch (pd->mmc3_profile) {
2102                 case 0x13: /* DVD-RW */
2103                 case 0x1a: /* DVD+RW */
2104                 case 0x12: /* DVD-RAM */
2105                         pkt_dbg(1, pd, "write speed %ukB/s\n", write_speed);
2106                         break;
2107                 default:
2108                         ret = pkt_media_speed(pd, &media_write_speed);
2109                         if (ret)
2110                                 media_write_speed = 16;
2111                         write_speed = min(write_speed, media_write_speed * 177);
2112                         pkt_dbg(1, pd, "write speed %ux\n", write_speed / 176);
2113                         break;
2114         }
2115         read_speed = write_speed;
2116
2117         ret = pkt_set_speed(pd, write_speed, read_speed);
2118         if (ret) {
2119                 pkt_dbg(1, pd, "couldn't set write speed\n");
2120                 return -EIO;
2121         }
2122         pd->write_speed = write_speed;
2123         pd->read_speed = read_speed;
2124
2125         ret = pkt_perform_opc(pd);
2126         if (ret) {
2127                 pkt_dbg(1, pd, "Optimum Power Calibration failed\n");
2128         }
2129
2130         return 0;
2131 }
2132
2133 /*
2134  * called at open time.
2135  */
2136 static int pkt_open_dev(struct pktcdvd_device *pd, fmode_t write)
2137 {
2138         int ret;
2139         long lba;
2140         struct request_queue *q;
2141         struct block_device *bdev;
2142
2143         /*
2144          * We need to re-open the cdrom device without O_NONBLOCK to be able
2145          * to read/write from/to it. It is already opened in O_NONBLOCK mode
2146          * so open should not fail.
2147          */
2148         bdev = blkdev_get_by_dev(pd->bdev->bd_dev, FMODE_READ | FMODE_EXCL, pd);
2149         if (IS_ERR(bdev)) {
2150                 ret = PTR_ERR(bdev);
2151                 goto out;
2152         }
2153
2154         ret = pkt_get_last_written(pd, &lba);
2155         if (ret) {
2156                 pkt_err(pd, "pkt_get_last_written failed\n");
2157                 goto out_putdev;
2158         }
2159
2160         set_capacity(pd->disk, lba << 2);
2161         set_capacity_and_notify(pd->bdev->bd_disk, lba << 2);
2162
2163         q = bdev_get_queue(pd->bdev);
2164         if (write) {
2165                 ret = pkt_open_write(pd);
2166                 if (ret)
2167                         goto out_putdev;
2168                 /*
2169                  * Some CDRW drives can not handle writes larger than one packet,
2170                  * even if the size is a multiple of the packet size.
2171                  */
2172                 blk_queue_max_hw_sectors(q, pd->settings.size);
2173                 set_bit(PACKET_WRITABLE, &pd->flags);
2174         } else {
2175                 pkt_set_speed(pd, MAX_SPEED, MAX_SPEED);
2176                 clear_bit(PACKET_WRITABLE, &pd->flags);
2177         }
2178
2179         ret = pkt_set_segment_merging(pd, q);
2180         if (ret)
2181                 goto out_putdev;
2182
2183         if (write) {
2184                 if (!pkt_grow_pktlist(pd, CONFIG_CDROM_PKTCDVD_BUFFERS)) {
2185                         pkt_err(pd, "not enough memory for buffers\n");
2186                         ret = -ENOMEM;
2187                         goto out_putdev;
2188                 }
2189                 pkt_info(pd, "%lukB available on disc\n", lba << 1);
2190         }
2191
2192         return 0;
2193
2194 out_putdev:
2195         blkdev_put(bdev, FMODE_READ | FMODE_EXCL);
2196 out:
2197         return ret;
2198 }
2199
2200 /*
2201  * called when the device is closed. makes sure that the device flushes
2202  * the internal cache before we close.
2203  */
2204 static void pkt_release_dev(struct pktcdvd_device *pd, int flush)
2205 {
2206         if (flush && pkt_flush_cache(pd))
2207                 pkt_dbg(1, pd, "not flushing cache\n");
2208
2209         pkt_lock_door(pd, 0);
2210
2211         pkt_set_speed(pd, MAX_SPEED, MAX_SPEED);
2212         blkdev_put(pd->bdev, FMODE_READ | FMODE_EXCL);
2213
2214         pkt_shrink_pktlist(pd);
2215 }
2216
2217 static struct pktcdvd_device *pkt_find_dev_from_minor(unsigned int dev_minor)
2218 {
2219         if (dev_minor >= MAX_WRITERS)
2220                 return NULL;
2221
2222         dev_minor = array_index_nospec(dev_minor, MAX_WRITERS);
2223         return pkt_devs[dev_minor];
2224 }
2225
2226 static int pkt_open(struct block_device *bdev, fmode_t mode)
2227 {
2228         struct pktcdvd_device *pd = NULL;
2229         int ret;
2230
2231         mutex_lock(&pktcdvd_mutex);
2232         mutex_lock(&ctl_mutex);
2233         pd = pkt_find_dev_from_minor(MINOR(bdev->bd_dev));
2234         if (!pd) {
2235                 ret = -ENODEV;
2236                 goto out;
2237         }
2238         BUG_ON(pd->refcnt < 0);
2239
2240         pd->refcnt++;
2241         if (pd->refcnt > 1) {
2242                 if ((mode & FMODE_WRITE) &&
2243                     !test_bit(PACKET_WRITABLE, &pd->flags)) {
2244                         ret = -EBUSY;
2245                         goto out_dec;
2246                 }
2247         } else {
2248                 ret = pkt_open_dev(pd, mode & FMODE_WRITE);
2249                 if (ret)
2250                         goto out_dec;
2251                 /*
2252                  * needed here as well, since ext2 (among others) may change
2253                  * the blocksize at mount time
2254                  */
2255                 set_blocksize(bdev, CD_FRAMESIZE);
2256         }
2257
2258         mutex_unlock(&ctl_mutex);
2259         mutex_unlock(&pktcdvd_mutex);
2260         return 0;
2261
2262 out_dec:
2263         pd->refcnt--;
2264 out:
2265         mutex_unlock(&ctl_mutex);
2266         mutex_unlock(&pktcdvd_mutex);
2267         return ret;
2268 }
2269
2270 static void pkt_close(struct gendisk *disk, fmode_t mode)
2271 {
2272         struct pktcdvd_device *pd = disk->private_data;
2273
2274         mutex_lock(&pktcdvd_mutex);
2275         mutex_lock(&ctl_mutex);
2276         pd->refcnt--;
2277         BUG_ON(pd->refcnt < 0);
2278         if (pd->refcnt == 0) {
2279                 int flush = test_bit(PACKET_WRITABLE, &pd->flags);
2280                 pkt_release_dev(pd, flush);
2281         }
2282         mutex_unlock(&ctl_mutex);
2283         mutex_unlock(&pktcdvd_mutex);
2284 }
2285
2286
2287 static void pkt_end_io_read_cloned(struct bio *bio)
2288 {
2289         struct packet_stacked_data *psd = bio->bi_private;
2290         struct pktcdvd_device *pd = psd->pd;
2291
2292         psd->bio->bi_status = bio->bi_status;
2293         bio_put(bio);
2294         bio_endio(psd->bio);
2295         mempool_free(psd, &psd_pool);
2296         pkt_bio_finished(pd);
2297 }
2298
2299 static void pkt_make_request_read(struct pktcdvd_device *pd, struct bio *bio)
2300 {
2301         struct bio *cloned_bio = bio_clone_fast(bio, GFP_NOIO, &pkt_bio_set);
2302         struct packet_stacked_data *psd = mempool_alloc(&psd_pool, GFP_NOIO);
2303
2304         psd->pd = pd;
2305         psd->bio = bio;
2306         bio_set_dev(cloned_bio, pd->bdev);
2307         cloned_bio->bi_private = psd;
2308         cloned_bio->bi_end_io = pkt_end_io_read_cloned;
2309         pd->stats.secs_r += bio_sectors(bio);
2310         pkt_queue_bio(pd, cloned_bio);
2311 }
2312
2313 static void pkt_make_request_write(struct request_queue *q, struct bio *bio)
2314 {
2315         struct pktcdvd_device *pd = q->queuedata;
2316         sector_t zone;
2317         struct packet_data *pkt;
2318         int was_empty, blocked_bio;
2319         struct pkt_rb_node *node;
2320
2321         zone = get_zone(bio->bi_iter.bi_sector, pd);
2322
2323         /*
2324          * If we find a matching packet in state WAITING or READ_WAIT, we can
2325          * just append this bio to that packet.
2326          */
2327         spin_lock(&pd->cdrw.active_list_lock);
2328         blocked_bio = 0;
2329         list_for_each_entry(pkt, &pd->cdrw.pkt_active_list, list) {
2330                 if (pkt->sector == zone) {
2331                         spin_lock(&pkt->lock);
2332                         if ((pkt->state == PACKET_WAITING_STATE) ||
2333                             (pkt->state == PACKET_READ_WAIT_STATE)) {
2334                                 bio_list_add(&pkt->orig_bios, bio);
2335                                 pkt->write_size +=
2336                                         bio->bi_iter.bi_size / CD_FRAMESIZE;
2337                                 if ((pkt->write_size >= pkt->frames) &&
2338                                     (pkt->state == PACKET_WAITING_STATE)) {
2339                                         atomic_inc(&pkt->run_sm);
2340                                         wake_up(&pd->wqueue);
2341                                 }
2342                                 spin_unlock(&pkt->lock);
2343                                 spin_unlock(&pd->cdrw.active_list_lock);
2344                                 return;
2345                         } else {
2346                                 blocked_bio = 1;
2347                         }
2348                         spin_unlock(&pkt->lock);
2349                 }
2350         }
2351         spin_unlock(&pd->cdrw.active_list_lock);
2352
2353         /*
2354          * Test if there is enough room left in the bio work queue
2355          * (queue size >= congestion on mark).
2356          * If not, wait till the work queue size is below the congestion off mark.
2357          */
2358         spin_lock(&pd->lock);
2359         if (pd->write_congestion_on > 0
2360             && pd->bio_queue_size >= pd->write_congestion_on) {
2361                 struct wait_bit_queue_entry wqe;
2362
2363                 init_wait_var_entry(&wqe, &pd->congested, 0);
2364                 for (;;) {
2365                         prepare_to_wait_event(__var_waitqueue(&pd->congested),
2366                                               &wqe.wq_entry,
2367                                               TASK_UNINTERRUPTIBLE);
2368                         if (pd->bio_queue_size <= pd->write_congestion_off)
2369                                 break;
2370                         pd->congested = true;
2371                         spin_unlock(&pd->lock);
2372                         schedule();
2373                         spin_lock(&pd->lock);
2374                 }
2375         }
2376         spin_unlock(&pd->lock);
2377
2378         /*
2379          * No matching packet found. Store the bio in the work queue.
2380          */
2381         node = mempool_alloc(&pd->rb_pool, GFP_NOIO);
2382         node->bio = bio;
2383         spin_lock(&pd->lock);
2384         BUG_ON(pd->bio_queue_size < 0);
2385         was_empty = (pd->bio_queue_size == 0);
2386         pkt_rbtree_insert(pd, node);
2387         spin_unlock(&pd->lock);
2388
2389         /*
2390          * Wake up the worker thread.
2391          */
2392         atomic_set(&pd->scan_queue, 1);
2393         if (was_empty) {
2394                 /* This wake_up is required for correct operation */
2395                 wake_up(&pd->wqueue);
2396         } else if (!list_empty(&pd->cdrw.pkt_free_list) && !blocked_bio) {
2397                 /*
2398                  * This wake up is not required for correct operation,
2399                  * but improves performance in some cases.
2400                  */
2401                 wake_up(&pd->wqueue);
2402         }
2403 }
2404
2405 static void pkt_submit_bio(struct bio *bio)
2406 {
2407         struct pktcdvd_device *pd;
2408         char b[BDEVNAME_SIZE];
2409         struct bio *split;
2410
2411         blk_queue_split(&bio);
2412
2413         pd = bio->bi_bdev->bd_disk->queue->queuedata;
2414         if (!pd) {
2415                 pr_err("%s incorrect request queue\n", bio_devname(bio, b));
2416                 goto end_io;
2417         }
2418
2419         pkt_dbg(2, pd, "start = %6llx stop = %6llx\n",
2420                 (unsigned long long)bio->bi_iter.bi_sector,
2421                 (unsigned long long)bio_end_sector(bio));
2422
2423         /*
2424          * Clone READ bios so we can have our own bi_end_io callback.
2425          */
2426         if (bio_data_dir(bio) == READ) {
2427                 pkt_make_request_read(pd, bio);
2428                 return;
2429         }
2430
2431         if (!test_bit(PACKET_WRITABLE, &pd->flags)) {
2432                 pkt_notice(pd, "WRITE for ro device (%llu)\n",
2433                            (unsigned long long)bio->bi_iter.bi_sector);
2434                 goto end_io;
2435         }
2436
2437         if (!bio->bi_iter.bi_size || (bio->bi_iter.bi_size % CD_FRAMESIZE)) {
2438                 pkt_err(pd, "wrong bio size\n");
2439                 goto end_io;
2440         }
2441
2442         do {
2443                 sector_t zone = get_zone(bio->bi_iter.bi_sector, pd);
2444                 sector_t last_zone = get_zone(bio_end_sector(bio) - 1, pd);
2445
2446                 if (last_zone != zone) {
2447                         BUG_ON(last_zone != zone + pd->settings.size);
2448
2449                         split = bio_split(bio, last_zone -
2450                                           bio->bi_iter.bi_sector,
2451                                           GFP_NOIO, &pkt_bio_set);
2452                         bio_chain(split, bio);
2453                 } else {
2454                         split = bio;
2455                 }
2456
2457                 pkt_make_request_write(bio->bi_bdev->bd_disk->queue, split);
2458         } while (split != bio);
2459
2460         return;
2461 end_io:
2462         bio_io_error(bio);
2463 }
2464
2465 static void pkt_init_queue(struct pktcdvd_device *pd)
2466 {
2467         struct request_queue *q = pd->disk->queue;
2468
2469         blk_queue_logical_block_size(q, CD_FRAMESIZE);
2470         blk_queue_max_hw_sectors(q, PACKET_MAX_SECTORS);
2471         q->queuedata = pd;
2472 }
2473
2474 static int pkt_seq_show(struct seq_file *m, void *p)
2475 {
2476         struct pktcdvd_device *pd = m->private;
2477         char *msg;
2478         char bdev_buf[BDEVNAME_SIZE];
2479         int states[PACKET_NUM_STATES];
2480
2481         seq_printf(m, "Writer %s mapped to %s:\n", pd->name,
2482                    bdevname(pd->bdev, bdev_buf));
2483
2484         seq_printf(m, "\nSettings:\n");
2485         seq_printf(m, "\tpacket size:\t\t%dkB\n", pd->settings.size / 2);
2486
2487         if (pd->settings.write_type == 0)
2488                 msg = "Packet";
2489         else
2490                 msg = "Unknown";
2491         seq_printf(m, "\twrite type:\t\t%s\n", msg);
2492
2493         seq_printf(m, "\tpacket type:\t\t%s\n", pd->settings.fp ? "Fixed" : "Variable");
2494         seq_printf(m, "\tlink loss:\t\t%d\n", pd->settings.link_loss);
2495
2496         seq_printf(m, "\ttrack mode:\t\t%d\n", pd->settings.track_mode);
2497
2498         if (pd->settings.block_mode == PACKET_BLOCK_MODE1)
2499                 msg = "Mode 1";
2500         else if (pd->settings.block_mode == PACKET_BLOCK_MODE2)
2501                 msg = "Mode 2";
2502         else
2503                 msg = "Unknown";
2504         seq_printf(m, "\tblock mode:\t\t%s\n", msg);
2505
2506         seq_printf(m, "\nStatistics:\n");
2507         seq_printf(m, "\tpackets started:\t%lu\n", pd->stats.pkt_started);
2508         seq_printf(m, "\tpackets ended:\t\t%lu\n", pd->stats.pkt_ended);
2509         seq_printf(m, "\twritten:\t\t%lukB\n", pd->stats.secs_w >> 1);
2510         seq_printf(m, "\tread gather:\t\t%lukB\n", pd->stats.secs_rg >> 1);
2511         seq_printf(m, "\tread:\t\t\t%lukB\n", pd->stats.secs_r >> 1);
2512
2513         seq_printf(m, "\nMisc:\n");
2514         seq_printf(m, "\treference count:\t%d\n", pd->refcnt);
2515         seq_printf(m, "\tflags:\t\t\t0x%lx\n", pd->flags);
2516         seq_printf(m, "\tread speed:\t\t%ukB/s\n", pd->read_speed);
2517         seq_printf(m, "\twrite speed:\t\t%ukB/s\n", pd->write_speed);
2518         seq_printf(m, "\tstart offset:\t\t%lu\n", pd->offset);
2519         seq_printf(m, "\tmode page offset:\t%u\n", pd->mode_offset);
2520
2521         seq_printf(m, "\nQueue state:\n");
2522         seq_printf(m, "\tbios queued:\t\t%d\n", pd->bio_queue_size);
2523         seq_printf(m, "\tbios pending:\t\t%d\n", atomic_read(&pd->cdrw.pending_bios));
2524         seq_printf(m, "\tcurrent sector:\t\t0x%llx\n", (unsigned long long)pd->current_sector);
2525
2526         pkt_count_states(pd, states);
2527         seq_printf(m, "\tstate:\t\t\ti:%d ow:%d rw:%d ww:%d rec:%d fin:%d\n",
2528                    states[0], states[1], states[2], states[3], states[4], states[5]);
2529
2530         seq_printf(m, "\twrite congestion marks:\toff=%d on=%d\n",
2531                         pd->write_congestion_off,
2532                         pd->write_congestion_on);
2533         return 0;
2534 }
2535
2536 static int pkt_new_dev(struct pktcdvd_device *pd, dev_t dev)
2537 {
2538         int i;
2539         char b[BDEVNAME_SIZE];
2540         struct block_device *bdev;
2541         struct scsi_device *sdev;
2542
2543         if (pd->pkt_dev == dev) {
2544                 pkt_err(pd, "recursive setup not allowed\n");
2545                 return -EBUSY;
2546         }
2547         for (i = 0; i < MAX_WRITERS; i++) {
2548                 struct pktcdvd_device *pd2 = pkt_devs[i];
2549                 if (!pd2)
2550                         continue;
2551                 if (pd2->bdev->bd_dev == dev) {
2552                         pkt_err(pd, "%s already setup\n",
2553                                 bdevname(pd2->bdev, b));
2554                         return -EBUSY;
2555                 }
2556                 if (pd2->pkt_dev == dev) {
2557                         pkt_err(pd, "can't chain pktcdvd devices\n");
2558                         return -EBUSY;
2559                 }
2560         }
2561
2562         bdev = blkdev_get_by_dev(dev, FMODE_READ | FMODE_NDELAY, NULL);
2563         if (IS_ERR(bdev))
2564                 return PTR_ERR(bdev);
2565         sdev = scsi_device_from_queue(bdev->bd_disk->queue);
2566         if (!sdev) {
2567                 blkdev_put(bdev, FMODE_READ | FMODE_NDELAY);
2568                 return -EINVAL;
2569         }
2570         put_device(&sdev->sdev_gendev);
2571
2572         /* This is safe, since we have a reference from open(). */
2573         __module_get(THIS_MODULE);
2574
2575         pd->bdev = bdev;
2576         set_blocksize(bdev, CD_FRAMESIZE);
2577
2578         pkt_init_queue(pd);
2579
2580         atomic_set(&pd->cdrw.pending_bios, 0);
2581         pd->cdrw.thread = kthread_run(kcdrwd, pd, "%s", pd->name);
2582         if (IS_ERR(pd->cdrw.thread)) {
2583                 pkt_err(pd, "can't start kernel thread\n");
2584                 goto out_mem;
2585         }
2586
2587         proc_create_single_data(pd->name, 0, pkt_proc, pkt_seq_show, pd);
2588         pkt_dbg(1, pd, "writer mapped to %s\n", bdevname(bdev, b));
2589         return 0;
2590
2591 out_mem:
2592         blkdev_put(bdev, FMODE_READ | FMODE_NDELAY);
2593         /* This is safe: open() is still holding a reference. */
2594         module_put(THIS_MODULE);
2595         return -ENOMEM;
2596 }
2597
2598 static int pkt_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd, unsigned long arg)
2599 {
2600         struct pktcdvd_device *pd = bdev->bd_disk->private_data;
2601         int ret;
2602
2603         pkt_dbg(2, pd, "cmd %x, dev %d:%d\n",
2604                 cmd, MAJOR(bdev->bd_dev), MINOR(bdev->bd_dev));
2605
2606         mutex_lock(&pktcdvd_mutex);
2607         switch (cmd) {
2608         case CDROMEJECT:
2609                 /*
2610                  * The door gets locked when the device is opened, so we
2611                  * have to unlock it or else the eject command fails.
2612                  */
2613                 if (pd->refcnt == 1)
2614                         pkt_lock_door(pd, 0);
2615                 fallthrough;
2616         /*
2617          * forward selected CDROM ioctls to CD-ROM, for UDF
2618          */
2619         case CDROMMULTISESSION:
2620         case CDROMREADTOCENTRY:
2621         case CDROM_LAST_WRITTEN:
2622         case CDROM_SEND_PACKET:
2623         case SCSI_IOCTL_SEND_COMMAND:
2624                 if (!bdev->bd_disk->fops->ioctl)
2625                         ret = -ENOTTY;
2626                 else
2627                         ret = bdev->bd_disk->fops->ioctl(bdev, mode, cmd, arg);
2628                 break;
2629         default:
2630                 pkt_dbg(2, pd, "Unknown ioctl (%x)\n", cmd);
2631                 ret = -ENOTTY;
2632         }
2633         mutex_unlock(&pktcdvd_mutex);
2634
2635         return ret;
2636 }
2637
2638 static unsigned int pkt_check_events(struct gendisk *disk,
2639                                      unsigned int clearing)
2640 {
2641         struct pktcdvd_device *pd = disk->private_data;
2642         struct gendisk *attached_disk;
2643
2644         if (!pd)
2645                 return 0;
2646         if (!pd->bdev)
2647                 return 0;
2648         attached_disk = pd->bdev->bd_disk;
2649         if (!attached_disk || !attached_disk->fops->check_events)
2650                 return 0;
2651         return attached_disk->fops->check_events(attached_disk, clearing);
2652 }
2653
2654 static char *pkt_devnode(struct gendisk *disk, umode_t *mode)
2655 {
2656         return kasprintf(GFP_KERNEL, "pktcdvd/%s", disk->disk_name);
2657 }
2658
2659 static const struct block_device_operations pktcdvd_ops = {
2660         .owner =                THIS_MODULE,
2661         .submit_bio =           pkt_submit_bio,
2662         .open =                 pkt_open,
2663         .release =              pkt_close,
2664         .ioctl =                pkt_ioctl,
2665         .compat_ioctl =         blkdev_compat_ptr_ioctl,
2666         .check_events =         pkt_check_events,
2667         .devnode =              pkt_devnode,
2668 };
2669
2670 /*
2671  * Set up mapping from pktcdvd device to CD-ROM device.
2672  */
2673 static int pkt_setup_dev(dev_t dev, dev_t* pkt_dev)
2674 {
2675         int idx;
2676         int ret = -ENOMEM;
2677         struct pktcdvd_device *pd;
2678         struct gendisk *disk;
2679
2680         mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
2681
2682         for (idx = 0; idx < MAX_WRITERS; idx++)
2683                 if (!pkt_devs[idx])
2684                         break;
2685         if (idx == MAX_WRITERS) {
2686                 pr_err("max %d writers supported\n", MAX_WRITERS);
2687                 ret = -EBUSY;
2688                 goto out_mutex;
2689         }
2690
2691         pd = kzalloc(sizeof(struct pktcdvd_device), GFP_KERNEL);
2692         if (!pd)
2693                 goto out_mutex;
2694
2695         ret = mempool_init_kmalloc_pool(&pd->rb_pool, PKT_RB_POOL_SIZE,
2696                                         sizeof(struct pkt_rb_node));
2697         if (ret)
2698                 goto out_mem;
2699
2700         INIT_LIST_HEAD(&pd->cdrw.pkt_free_list);
2701         INIT_LIST_HEAD(&pd->cdrw.pkt_active_list);
2702         spin_lock_init(&pd->cdrw.active_list_lock);
2703
2704         spin_lock_init(&pd->lock);
2705         spin_lock_init(&pd->iosched.lock);
2706         bio_list_init(&pd->iosched.read_queue);
2707         bio_list_init(&pd->iosched.write_queue);
2708         sprintf(pd->name, DRIVER_NAME"%d", idx);
2709         init_waitqueue_head(&pd->wqueue);
2710         pd->bio_queue = RB_ROOT;
2711
2712         pd->write_congestion_on  = write_congestion_on;
2713         pd->write_congestion_off = write_congestion_off;
2714
2715         ret = -ENOMEM;
2716         disk = blk_alloc_disk(NUMA_NO_NODE);
2717         if (!disk)
2718                 goto out_mem;
2719         pd->disk = disk;
2720         disk->major = pktdev_major;
2721         disk->first_minor = idx;
2722         disk->minors = 1;
2723         disk->fops = &pktcdvd_ops;
2724         disk->flags = GENHD_FL_REMOVABLE | GENHD_FL_NO_PART;
2725         strcpy(disk->disk_name, pd->name);
2726         disk->private_data = pd;
2727
2728         pd->pkt_dev = MKDEV(pktdev_major, idx);
2729         ret = pkt_new_dev(pd, dev);
2730         if (ret)
2731                 goto out_mem2;
2732
2733         /* inherit events of the host device */
2734         disk->events = pd->bdev->bd_disk->events;
2735
2736         ret = add_disk(disk);
2737         if (ret)
2738                 goto out_mem2;
2739
2740         pkt_sysfs_dev_new(pd);
2741         pkt_debugfs_dev_new(pd);
2742
2743         pkt_devs[idx] = pd;
2744         if (pkt_dev)
2745                 *pkt_dev = pd->pkt_dev;
2746
2747         mutex_unlock(&ctl_mutex);
2748         return 0;
2749
2750 out_mem2:
2751         blk_cleanup_disk(disk);
2752 out_mem:
2753         mempool_exit(&pd->rb_pool);
2754         kfree(pd);
2755 out_mutex:
2756         mutex_unlock(&ctl_mutex);
2757         pr_err("setup of pktcdvd device failed\n");
2758         return ret;
2759 }
2760
2761 /*
2762  * Tear down mapping from pktcdvd device to CD-ROM device.
2763  */
2764 static int pkt_remove_dev(dev_t pkt_dev)
2765 {
2766         struct pktcdvd_device *pd;
2767         int idx;
2768         int ret = 0;
2769
2770         mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
2771
2772         for (idx = 0; idx < MAX_WRITERS; idx++) {
2773                 pd = pkt_devs[idx];
2774                 if (pd && (pd->pkt_dev == pkt_dev))
2775                         break;
2776         }
2777         if (idx == MAX_WRITERS) {
2778                 pr_debug("dev not setup\n");
2779                 ret = -ENXIO;
2780                 goto out;
2781         }
2782
2783         if (pd->refcnt > 0) {
2784                 ret = -EBUSY;
2785                 goto out;
2786         }
2787         if (!IS_ERR(pd->cdrw.thread))
2788                 kthread_stop(pd->cdrw.thread);
2789
2790         pkt_devs[idx] = NULL;
2791
2792         pkt_debugfs_dev_remove(pd);
2793         pkt_sysfs_dev_remove(pd);
2794
2795         blkdev_put(pd->bdev, FMODE_READ | FMODE_NDELAY);
2796
2797         remove_proc_entry(pd->name, pkt_proc);
2798         pkt_dbg(1, pd, "writer unmapped\n");
2799
2800         del_gendisk(pd->disk);
2801         blk_cleanup_disk(pd->disk);
2802
2803         mempool_exit(&pd->rb_pool);
2804         kfree(pd);
2805
2806         /* This is safe: open() is still holding a reference. */
2807         module_put(THIS_MODULE);
2808
2809 out:
2810         mutex_unlock(&ctl_mutex);
2811         return ret;
2812 }
2813
2814 static void pkt_get_status(struct pkt_ctrl_command *ctrl_cmd)
2815 {
2816         struct pktcdvd_device *pd;
2817
2818         mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
2819
2820         pd = pkt_find_dev_from_minor(ctrl_cmd->dev_index);
2821         if (pd) {
2822                 ctrl_cmd->dev = new_encode_dev(pd->bdev->bd_dev);
2823                 ctrl_cmd->pkt_dev = new_encode_dev(pd->pkt_dev);
2824         } else {
2825                 ctrl_cmd->dev = 0;
2826                 ctrl_cmd->pkt_dev = 0;
2827         }
2828         ctrl_cmd->num_devices = MAX_WRITERS;
2829
2830         mutex_unlock(&ctl_mutex);
2831 }
2832
2833 static long pkt_ctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
2834 {
2835         void __user *argp = (void __user *)arg;
2836         struct pkt_ctrl_command ctrl_cmd;
2837         int ret = 0;
2838         dev_t pkt_dev = 0;
2839
2840         if (cmd != PACKET_CTRL_CMD)
2841                 return -ENOTTY;
2842
2843         if (copy_from_user(&ctrl_cmd, argp, sizeof(struct pkt_ctrl_command)))
2844                 return -EFAULT;
2845
2846         switch (ctrl_cmd.command) {
2847         case PKT_CTRL_CMD_SETUP:
2848                 if (!capable(CAP_SYS_ADMIN))
2849                         return -EPERM;
2850                 ret = pkt_setup_dev(new_decode_dev(ctrl_cmd.dev), &pkt_dev);
2851                 ctrl_cmd.pkt_dev = new_encode_dev(pkt_dev);
2852                 break;
2853         case PKT_CTRL_CMD_TEARDOWN:
2854                 if (!capable(CAP_SYS_ADMIN))
2855                         return -EPERM;
2856                 ret = pkt_remove_dev(new_decode_dev(ctrl_cmd.pkt_dev));
2857                 break;
2858         case PKT_CTRL_CMD_STATUS:
2859                 pkt_get_status(&ctrl_cmd);
2860                 break;
2861         default:
2862                 return -ENOTTY;
2863         }
2864
2865         if (copy_to_user(argp, &ctrl_cmd, sizeof(struct pkt_ctrl_command)))
2866                 return -EFAULT;
2867         return ret;
2868 }
2869
2870 #ifdef CONFIG_COMPAT
2871 static long pkt_ctl_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
2872 {
2873         return pkt_ctl_ioctl(file, cmd, (unsigned long)compat_ptr(arg));
2874 }
2875 #endif
2876
2877 static const struct file_operations pkt_ctl_fops = {
2878         .open           = nonseekable_open,
2879         .unlocked_ioctl = pkt_ctl_ioctl,
2880 #ifdef CONFIG_COMPAT
2881         .compat_ioctl   = pkt_ctl_compat_ioctl,
2882 #endif
2883         .owner          = THIS_MODULE,
2884         .llseek         = no_llseek,
2885 };
2886
2887 static struct miscdevice pkt_misc = {
2888         .minor          = MISC_DYNAMIC_MINOR,
2889         .name           = DRIVER_NAME,
2890         .nodename       = "pktcdvd/control",
2891         .fops           = &pkt_ctl_fops
2892 };
2893
2894 static int __init pkt_init(void)
2895 {
2896         int ret;
2897
2898         mutex_init(&ctl_mutex);
2899
2900         ret = mempool_init_kmalloc_pool(&psd_pool, PSD_POOL_SIZE,
2901                                     sizeof(struct packet_stacked_data));
2902         if (ret)
2903                 return ret;
2904         ret = bioset_init(&pkt_bio_set, BIO_POOL_SIZE, 0, 0);
2905         if (ret) {
2906                 mempool_exit(&psd_pool);
2907                 return ret;
2908         }
2909
2910         ret = register_blkdev(pktdev_major, DRIVER_NAME);
2911         if (ret < 0) {
2912                 pr_err("unable to register block device\n");
2913                 goto out2;
2914         }
2915         if (!pktdev_major)
2916                 pktdev_major = ret;
2917
2918         ret = pkt_sysfs_init();
2919         if (ret)
2920                 goto out;
2921
2922         pkt_debugfs_init();
2923
2924         ret = misc_register(&pkt_misc);
2925         if (ret) {
2926                 pr_err("unable to register misc device\n");
2927                 goto out_misc;
2928         }
2929
2930         pkt_proc = proc_mkdir("driver/"DRIVER_NAME, NULL);
2931
2932         return 0;
2933
2934 out_misc:
2935         pkt_debugfs_cleanup();
2936         pkt_sysfs_cleanup();
2937 out:
2938         unregister_blkdev(pktdev_major, DRIVER_NAME);
2939 out2:
2940         mempool_exit(&psd_pool);
2941         bioset_exit(&pkt_bio_set);
2942         return ret;
2943 }
2944
2945 static void __exit pkt_exit(void)
2946 {
2947         remove_proc_entry("driver/"DRIVER_NAME, NULL);
2948         misc_deregister(&pkt_misc);
2949
2950         pkt_debugfs_cleanup();
2951         pkt_sysfs_cleanup();
2952
2953         unregister_blkdev(pktdev_major, DRIVER_NAME);
2954         mempool_exit(&psd_pool);
2955         bioset_exit(&pkt_bio_set);
2956 }
2957
2958 MODULE_DESCRIPTION("Packet writing layer for CD/DVD drives");
2959 MODULE_AUTHOR("Jens Axboe <axboe@suse.de>");
2960 MODULE_LICENSE("GPL");
2961
2962 module_init(pkt_init);
2963 module_exit(pkt_exit);