Revert "pktcdvd: remove driver."

This reverts commit f40eb99897af665f11858dd7b56edcb62c3f3c67. There are apparently still users out there of this driver. While we'd love to remove it to ease the maintenance burden, let's reinstate it for now until better (userspace) solutions can be developed.

Jens Axboe committed 3 years ago

Commit 4b83e991 parent 050a4f38 files · +3419 −0Browse files

Unified · Split

8 files

Documentation/ABI/testing/debugfs-pktcdvd +18 −0
Documentation/ABI/testing/sysfs-class-pktcdvd +97 −0
MAINTAINERS +7 −0
drivers/block/Kconfig +43 −0
drivers/block/Makefile +1 −0
drivers/block/pktcdvd.c +2944 −0
include/linux/pktcdvd.h +197 −0
include/uapi/linux/pktcdvd.h +112 −0

Documentation/ABI/testing/debugfs-pktcdvd+18−0

@@ -0,0 +1,18 @@
	1	What: /sys/kernel/debug/pktcdvd/pktcdvd[0-7]
	2	Date: Oct. 2006
	3	KernelVersion: 2.6.20
	4	Contact: Thomas Maier <balagi@justmail.de>
	5	Description:
	6
	7	The pktcdvd module (packet writing driver) creates
	8	these files in debugfs:
	9
	10	/sys/kernel/debug/pktcdvd/pktcdvd[0-7]/
	11
	12	==== ====== ====================================
	13	info 0444 Lots of driver statistics and infos.
	14	==== ====== ====================================
	15
	16	Example::
	17
	18	cat /sys/kernel/debug/pktcdvd/pktcdvd0/info

Documentation/ABI/testing/sysfs-class-pktcdvd+97−0

@@ -0,0 +1,97 @@
	1	sysfs interface
	2	---------------
	3	The pktcdvd module (packet writing driver) creates the following files in the
	4	sysfs: (<devid> is in the format major:minor)
	5
	6	What: /sys/class/pktcdvd/add
	7	What: /sys/class/pktcdvd/remove
	8	What: /sys/class/pktcdvd/device_map
	9	Date: Oct. 2006
	10	KernelVersion: 2.6.20
	11	Contact: Thomas Maier <balagi@justmail.de>
	12	Description:
	13
	14	========== ==============================================
	15	add (WO) Write a block device id (major:minor) to
	16	create a new pktcdvd device and map it to the
	17	block device.
	18
	19	remove (WO) Write the pktcdvd device id (major:minor)
	20	to remove the pktcdvd device.
	21
	22	device_map (RO) Shows the device mapping in format:
	23	pktcdvd[0-7] <pktdevid> <blkdevid>
	24	========== ==============================================
	25
	26
	27	What: /sys/class/pktcdvd/pktcdvd[0-7]/dev
	28	What: /sys/class/pktcdvd/pktcdvd[0-7]/uevent
	29	Date: Oct. 2006
	30	KernelVersion: 2.6.20
	31	Contact: Thomas Maier <balagi@justmail.de>
	32	Description:
	33	dev: (RO) Device id
	34
	35	uevent: (WO) To send a uevent
	36
	37
	38	What: /sys/class/pktcdvd/pktcdvd[0-7]/stat/packets_started
	39	What: /sys/class/pktcdvd/pktcdvd[0-7]/stat/packets_finished
	40	What: /sys/class/pktcdvd/pktcdvd[0-7]/stat/kb_written
	41	What: /sys/class/pktcdvd/pktcdvd[0-7]/stat/kb_read
	42	What: /sys/class/pktcdvd/pktcdvd[0-7]/stat/kb_read_gather
	43	What: /sys/class/pktcdvd/pktcdvd[0-7]/stat/reset
	44	Date: Oct. 2006
	45	KernelVersion: 2.6.20
	46	Contact: Thomas Maier <balagi@justmail.de>
	47	Description:
	48	packets_started: (RO) Number of started packets.
	49
	50	packets_finished: (RO) Number of finished packets.
	51
	52	kb_written: (RO) kBytes written.
	53
	54	kb_read: (RO) kBytes read.
	55
	56	kb_read_gather: (RO) kBytes read to fill write packets.
	57
	58	reset: (WO) Write any value to it to reset
	59	pktcdvd device statistic values, like
	60	bytes read/written.
	61
	62
	63	What: /sys/class/pktcdvd/pktcdvd[0-7]/write_queue/size
	64	What: /sys/class/pktcdvd/pktcdvd[0-7]/write_queue/congestion_off
	65	What: /sys/class/pktcdvd/pktcdvd[0-7]/write_queue/congestion_on
	66	Date: Oct. 2006
	67	KernelVersion: 2.6.20
	68	Contact: Thomas Maier <balagi@justmail.de>
	69	Description:
	70	============== ================================================
	71	size (RO) Contains the size of the bio write queue.
	72
	73	congestion_off (RW) If bio write queue size is below this mark,
	74	accept new bio requests from the block layer.
	75
	76	congestion_on (RW) If bio write queue size is higher as this
	77	mark, do no longer accept bio write requests
	78	from the block layer and wait till the pktcdvd
	79	device has processed enough bio's so that bio
	80	write queue size is below congestion off mark.
	81	A value of <= 0 disables congestion control.
	82	============== ================================================
	83
	84
	85	Example:
	86	--------
	87	To use the pktcdvd sysfs interface directly, you can do::
	88
	89	# create a new pktcdvd device mapped to /dev/hdc
	90	echo "22:0" >/sys/class/pktcdvd/add
	91	cat /sys/class/pktcdvd/device_map
	92	# assuming device pktcdvd0 was created, look at stat's
	93	cat /sys/class/pktcdvd/pktcdvd0/stat/kb_written
	94	# print the device id of the mapped block device
	95	fgrep pktcdvd0 /sys/class/pktcdvd/device_map
	96	# remove device, using pktcdvd0 device id 253:0
	97	echo "253:0" >/sys/class/pktcdvd/remove

MAINTAINERS+7−0

@@ -16520,6 +16520,13 @@ S: Supported · 16519 unmodified lines
16520	F: Documentation/devicetree/bindings/input/pine64,pinephone-keyboard.yaml	16520	F: Documentation/devicetree/bindings/input/pine64,pinephone-keyboard.yaml
16521	F: drivers/input/keyboard/pinephone-keyboard.c	16521	F: drivers/input/keyboard/pinephone-keyboard.c
16522		16522
		16523	PKTCDVD DRIVER
		16524	M: linux-block@vger.kernel.org
		16525	S: Orphan
		16526	F: drivers/block/pktcdvd.c
		16527	F: include/linux/pktcdvd.h
		16528	F: include/uapi/linux/pktcdvd.h
		16529
16523	PLANTOWER PMS7003 AIR POLLUTION SENSOR DRIVER	16530	PLANTOWER PMS7003 AIR POLLUTION SENSOR DRIVER
16524	M: Tomasz Duszynski <tduszyns@gmail.com>	16531	M: Tomasz Duszynski <tduszyns@gmail.com>
16525	S: Maintained	16532	S: Maintained

drivers/block/Kconfig+43−0

@@ -285,6 +285,49 @@ config BLK_DEV_RAM_SIZE · 284 unmodified lines
285	The default value is 4096 kilobytes. Only change this if you know	285	The default value is 4096 kilobytes. Only change this if you know
286	what you are doing.	286	what you are doing.
287		287
		288	config CDROM_PKTCDVD
		289	tristate "Packet writing on CD/DVD media (DEPRECATED)"
		290	depends on !UML
		291	depends on SCSI
		292	select CDROM
		293	help
		294	Note: This driver is deprecated and will be removed from the
		295	kernel in the near future!
		296
		297	If you have a CDROM/DVD drive that supports packet writing, say
		298	Y to include support. It should work with any MMC/Mt Fuji
		299	compliant ATAPI or SCSI drive, which is just about any newer
		300	DVD/CD writer.
		301
		302	Currently only writing to CD-RW, DVD-RW, DVD+RW and DVDRAM discs
		303	is possible.
		304	DVD-RW disks must be in restricted overwrite mode.
		305
		306	See the file <file:Documentation/cdrom/packet-writing.rst>
		307	for further information on the use of this driver.
		308
		309	To compile this driver as a module, choose M here: the
		310	module will be called pktcdvd.
		311
		312	config CDROM_PKTCDVD_BUFFERS
		313	int "Free buffers for data gathering"
		314	depends on CDROM_PKTCDVD
		315	default "8"
		316	help
		317	This controls the maximum number of active concurrent packets. More
		318	concurrent packets can increase write performance, but also require
		319	more memory. Each concurrent packet will require approximately 64Kb
		320	of non-swappable kernel memory, memory which will be allocated when
		321	a disc is opened for writing.
		322
		323	config CDROM_PKTCDVD_WCACHE
		324	bool "Enable write caching"
		325	depends on CDROM_PKTCDVD
		326	help
		327	If enabled, write caching will be set for the CD-R/W device. For now
		328	this option is dangerous unless the CD-RW media is known good, as we
		329	don't do deferred write error handling yet.
		330
288	config ATA_OVER_ETH	331	config ATA_OVER_ETH
289	tristate "ATA over Ethernet support"	332	tristate "ATA over Ethernet support"
290	depends on NET	333	depends on NET

drivers/block/Makefile+1−0

@@ -20,6 +20,7 @@ obj-$(CONFIG_AMIGA_Z2RAM) += z2ram.o · 19 unmodified lines
20	obj-$(CONFIG_N64CART) += n64cart.o	20	obj-$(CONFIG_N64CART) += n64cart.o
21	obj-$(CONFIG_BLK_DEV_RAM) += brd.o	21	obj-$(CONFIG_BLK_DEV_RAM) += brd.o
22	obj-$(CONFIG_BLK_DEV_LOOP) += loop.o	22	obj-$(CONFIG_BLK_DEV_LOOP) += loop.o
		23	obj-$(CONFIG_CDROM_PKTCDVD) += pktcdvd.o
23	obj-$(CONFIG_SUNVDC) += sunvdc.o	24	obj-$(CONFIG_SUNVDC) += sunvdc.o
24		25
25	obj-$(CONFIG_BLK_DEV_NBD) += nbd.o	26	obj-$(CONFIG_BLK_DEV_NBD) += nbd.o

drivers/block/pktcdvd.c+2944−0

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

include/linux/pktcdvd.h+197−0

@@ -0,0 +1,197 @@
	1	/*
	2	* Copyright (C) 2000 Jens Axboe <axboe@suse.de>
	3	* Copyright (C) 2001-2004 Peter Osterlund <petero2@telia.com>
	4	*
	5	* May be copied or modified under the terms of the GNU General Public
	6	* License. See linux/COPYING for more information.
	7	*
	8	* Packet writing layer for ATAPI and SCSI CD-R, CD-RW, DVD-R, and
	9	* DVD-RW devices.
	10	*
	11	*/
	12	#ifndef __PKTCDVD_H
	13	#define __PKTCDVD_H
	14
	15	#include <linux/blkdev.h>
	16	#include <linux/completion.h>
	17	#include <linux/cdrom.h>
	18	#include <linux/kobject.h>
	19	#include <linux/sysfs.h>
	20	#include <linux/mempool.h>
	21	#include <uapi/linux/pktcdvd.h>
	22
	23	/* default bio write queue congestion marks */
	24	#define PKT_WRITE_CONGESTION_ON 10000
	25	#define PKT_WRITE_CONGESTION_OFF 9000
	26
	27
	28	struct packet_settings
	29	{
	30	__u32 size; /* packet size in (512 byte) sectors */
	31	__u8 fp; /* fixed packets */
	32	__u8 link_loss; /* the rest is specified
	33	* as per Mt Fuji */
	34	__u8 write_type;
	35	__u8 track_mode;
	36	__u8 block_mode;
	37	};
	38
	39	/*
	40	* Very crude stats for now
	41	*/
	42	struct packet_stats
	43	{
	44	unsigned long pkt_started;
	45	unsigned long pkt_ended;
	46	unsigned long secs_w;
	47	unsigned long secs_rg;
	48	unsigned long secs_r;
	49	};
	50
	51	struct packet_cdrw
	52	{
	53	struct list_head pkt_free_list;
	54	struct list_head pkt_active_list;
	55	spinlock_t active_list_lock; /* Serialize access to pkt_active_list */
	56	struct task_struct *thread;
	57	atomic_t pending_bios;
	58	};
	59
	60	/*
	61	* Switch to high speed reading after reading this many kilobytes
	62	* with no interspersed writes.
	63	*/
	64	#define HI_SPEED_SWITCH 512
	65
	66	struct packet_iosched
	67	{
	68	atomic_t attention; /* Set to non-zero when queue processing is needed */
	69	int writing; /* Non-zero when writing, zero when reading */
	70	spinlock_t lock; /* Protecting read/write queue manipulations */
	71	struct bio_list read_queue;
	72	struct bio_list write_queue;
	73	sector_t last_write; /* The sector where the last write ended */
	74	int successive_reads;
	75	};
	76
	77	/*
	78	* 32 buffers of 2048 bytes
	79	*/
	80	#if (PAGE_SIZE % CD_FRAMESIZE) != 0
	81	#error "PAGE_SIZE must be a multiple of CD_FRAMESIZE"
	82	#endif
	83	#define PACKET_MAX_SIZE 128
	84	#define FRAMES_PER_PAGE (PAGE_SIZE / CD_FRAMESIZE)
	85	#define PACKET_MAX_SECTORS (PACKET_MAX_SIZE * CD_FRAMESIZE >> 9)
	86
	87	enum packet_data_state {
	88	PACKET_IDLE_STATE, /* Not used at the moment */
	89	PACKET_WAITING_STATE, /* Waiting for more bios to arrive, so */
	90	/* we don't have to do as much */
	91	/* data gathering */
	92	PACKET_READ_WAIT_STATE, /* Waiting for reads to fill in holes */
	93	PACKET_WRITE_WAIT_STATE, /* Waiting for the write to complete */
	94	PACKET_RECOVERY_STATE, /* Recover after read/write errors */
	95	PACKET_FINISHED_STATE, /* After write has finished */
	96
	97	PACKET_NUM_STATES /* Number of possible states */
	98	};
	99
	100	/*
	101	* Information needed for writing a single packet
	102	*/
	103	struct pktcdvd_device;
	104
	105	struct packet_data
	106	{
	107	struct list_head list;
	108
	109	spinlock_t lock; /* Lock protecting state transitions and */
	110	/* orig_bios list */
	111
	112	struct bio_list orig_bios; /* Original bios passed to pkt_make_request */
	113	/* that will be handled by this packet */
	114	int write_size; /* Total size of all bios in the orig_bios */
	115	/* list, measured in number of frames */
	116
	117	struct bio w_bio; / The bio we will send to the real CD */
	118	/* device once we have all data for the */
	119	/* packet we are going to write */
	120	sector_t sector; /* First sector in this packet */
	121	int frames; /* Number of frames in this packet */
	122
	123	enum packet_data_state state; /* Current state */
	124	atomic_t run_sm; /* Incremented whenever the state */
	125	/* machine needs to be run */
	126	long sleep_time; /* Set this to non-zero to make the state */
	127	/* machine run after this many jiffies. */
	128
	129	atomic_t io_wait; /* Number of pending IO operations */
	130	atomic_t io_errors; /* Number of read/write errors during IO */
	131
	132	struct bio r_bios[PACKET_MAX_SIZE]; / bios to use during data gathering */
	133	struct page *pages[PACKET_MAX_SIZE / FRAMES_PER_PAGE];
	134
	135	int cache_valid; /* If non-zero, the data for the zone defined */
	136	/* by the sector variable is completely cached */
	137	/* in the pages[] vector. */
	138
	139	int id; /* ID number for debugging */
	140	struct pktcdvd_device *pd;
	141	};
	142
	143	struct pkt_rb_node {
	144	struct rb_node rb_node;
	145	struct bio *bio;
	146	};
	147
	148	struct packet_stacked_data
	149	{
	150	struct bio bio; / Original read request bio */
	151	struct pktcdvd_device *pd;
	152	};
	153	#define PSD_POOL_SIZE 64
	154
	155	struct pktcdvd_device
	156	{
	157	struct block_device bdev; / dev attached */
	158	dev_t pkt_dev; /* our dev */
	159	char name[20];
	160	struct packet_settings settings;
	161	struct packet_stats stats;
	162	int refcnt; /* Open count */
	163	int write_speed; /* current write speed, kB/s */
	164	int read_speed; /* current read speed, kB/s */
	165	unsigned long offset; /* start offset */
	166	__u8 mode_offset; /* 0 / 8 */
	167	__u8 type;
	168	unsigned long flags;
	169	__u16 mmc3_profile;
	170	__u32 nwa; /* next writable address */
	171	__u32 lra; /* last recorded address */
	172	struct packet_cdrw cdrw;
	173	wait_queue_head_t wqueue;
	174
	175	spinlock_t lock; /* Serialize access to bio_queue */
	176	struct rb_root bio_queue; /* Work queue of bios we need to handle */
	177	int bio_queue_size; /* Number of nodes in bio_queue */
	178	bool congested; /* Someone is waiting for bio_queue_size
	179	* to drop. */
	180	sector_t current_sector; /* Keep track of where the elevator is */
	181	atomic_t scan_queue; /* Set to non-zero when pkt_handle_queue */
	182	/* needs to be run. */
	183	mempool_t rb_pool; /* mempool for pkt_rb_node allocations */
	184
	185	struct packet_iosched iosched;
	186	struct gendisk *disk;
	187
	188	int write_congestion_off;
	189	int write_congestion_on;
	190
	191	struct device dev; / sysfs pktcdvd[0-7] dev */
	192
	193	struct dentry dfs_d_root; / debugfs: devname directory */
	194	struct dentry dfs_f_info; / debugfs: info file */
	195	};
	196
	197	#endif /* __PKTCDVD_H */

include/uapi/linux/pktcdvd.h+112−0

@@ -0,0 +1,112 @@
	1	/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
	2	/*
	3	* Copyright (C) 2000 Jens Axboe <axboe@suse.de>
	4	* Copyright (C) 2001-2004 Peter Osterlund <petero2@telia.com>
	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-R, CD-RW, DVD-R, and
	10	* DVD-RW devices.
	11	*
	12	*/
	13	#ifndef _UAPI__PKTCDVD_H
	14	#define _UAPI__PKTCDVD_H
	15
	16	#include <linux/types.h>
	17
	18	/*
	19	* 1 for normal debug messages, 2 is very verbose. 0 to turn it off.
	20	*/
	21	#define PACKET_DEBUG 1
	22
	23	#define MAX_WRITERS 8
	24
	25	#define PKT_RB_POOL_SIZE 512
	26
	27	/*
	28	* How long we should hold a non-full packet before starting data gathering.
	29	*/
	30	#define PACKET_WAIT_TIME (HZ * 5 / 1000)
	31
	32	/*
	33	* use drive write caching -- we need deferred error handling to be
	34	* able to successfully recover with this option (drive will return good
	35	* status as soon as the cdb is validated).
	36	*/
	37	#if defined(CONFIG_CDROM_PKTCDVD_WCACHE)
	38	#define USE_WCACHING 1
	39	#else
	40	#define USE_WCACHING 0
	41	#endif
	42
	43	/*
	44	* No user-servicable parts beyond this point ->
	45	*/
	46
	47	/*
	48	* device types
	49	*/
	50	#define PACKET_CDR 1
	51	#define PACKET_CDRW 2
	52	#define PACKET_DVDR 3
	53	#define PACKET_DVDRW 4
	54
	55	/*
	56	* flags
	57	*/
	58	#define PACKET_WRITABLE 1 /* pd is writable */
	59	#define PACKET_NWA_VALID 2 /* next writable address valid */
	60	#define PACKET_LRA_VALID 3 /* last recorded address valid */
	61	#define PACKET_MERGE_SEGS 4 /* perform segment merging to keep */
	62	/* underlying cdrom device happy */
	63
	64	/*
	65	* Disc status -- from READ_DISC_INFO
	66	*/
	67	#define PACKET_DISC_EMPTY 0
	68	#define PACKET_DISC_INCOMPLETE 1
	69	#define PACKET_DISC_COMPLETE 2
	70	#define PACKET_DISC_OTHER 3
	71
	72	/*
	73	* write type, and corresponding data block type
	74	*/
	75	#define PACKET_MODE1 1
	76	#define PACKET_MODE2 2
	77	#define PACKET_BLOCK_MODE1 8
	78	#define PACKET_BLOCK_MODE2 10
	79
	80	/*
	81	* Last session/border status
	82	*/
	83	#define PACKET_SESSION_EMPTY 0
	84	#define PACKET_SESSION_INCOMPLETE 1
	85	#define PACKET_SESSION_RESERVED 2
	86	#define PACKET_SESSION_COMPLETE 3
	87
	88	#define PACKET_MCN "4a656e734178626f65323030300000"
	89
	90	#undef PACKET_USE_LS
	91
	92	#define PKT_CTRL_CMD_SETUP 0
	93	#define PKT_CTRL_CMD_TEARDOWN 1
	94	#define PKT_CTRL_CMD_STATUS 2
	95
	96	struct pkt_ctrl_command {
	97	__u32 command; /* in: Setup, teardown, status */
	98	__u32 dev_index; /* in/out: Device index */
	99	__u32 dev; /* in/out: Device nr for cdrw device */
	100	__u32 pkt_dev; /* in/out: Device nr for packet device */
	101	__u32 num_devices; /* out: Largest device index + 1 */
	102	__u32 padding; /* Not used */
	103	};
	104
	105	/*
	106	* packet ioctls
	107	*/
	108	#define PACKET_IOCTL_MAGIC ('X')
	109	#define PACKET_CTRL_CMD _IOWR(PACKET_IOCTL_MAGIC, 1, struct pkt_ctrl_command)
	110
	111
	112	#endif /* _UAPI__PKTCDVD_H */