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