Commit 113d1dd9 authored May 14, 2024 by Linus Torvalds

Merge tag 'scsi-misc' of git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi

Pull SCSI updates from James Bottomley:
 "Updates to the usual drivers (ufs, lpfc, qla2xxx, mpi3mr, libsas).

  The major update (which causes a conflict with block, see below) is
  Christoph removing the queue limits and their associated block
  helpers.

  The remaining patches are assorted minor fixes and deprecated function
  updates plus a bit of constification"

* tag 'scsi-misc' of git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi: (141 commits)
  scsi: mpi3mr: Sanitise num_phys
  scsi: lpfc: Copyright updates for 14.4.0.2 patches
  scsi: lpfc: Update lpfc version to 14.4.0.2
  scsi: lpfc: Add support for 32 byte CDBs
  scsi: lpfc: Change lpfc_hba hba_flag member into a bitmask
  scsi: lpfc: Introduce rrq_list_lock to protect active_rrq_list
  scsi: lpfc: Clear deferred RSCN processing flag when driver is unloading
  scsi: lpfc: Update logging of protection type for T10 DIF I/O
  scsi: lpfc: Change default logging level for unsolicited CT MIB commands
  scsi: target: Remove unused list 'device_list'
  scsi: iscsi: Remove unused list 'connlist_err'
  scsi: ufs: exynos: Add support for Tensor gs101 SoC
  scsi: ufs: exynos: Add some pa_dbg_ register offsets into drvdata
  scsi: ufs: exynos: Allow max frequencies up to 267Mhz
  scsi: ufs: exynos: Add EXYNOS_UFS_OPT_TIMER_TICK_SELECT option
  scsi: ufs: exynos: Add EXYNOS_UFS_OPT_UFSPR_SECURE option
  scsi: ufs: dt-bindings: exynos: Add gs101 compatible
  scsi: qla2xxx: Fix debugfs output for fw_resource_count
  scsi: qedf: Ensure the copied buf is NUL terminated
  scsi: bfa: Ensure the copied buf is NUL terminated
  ...

parents b2665fe6 3668651d

Documentation/devicetree/bindings/ufs/samsung,exynos-ufs.yaml

+35 −3

Original line number	Diff line number	Diff line
		@@ -12,12 +12,10 @@ maintainers:
		description: \|
		Each Samsung UFS host controller instance should have its own node.

		allOf:
		- $ref: ufs-common.yaml

		properties:
		compatible:
		enum:
		- google,gs101-ufs
		- samsung,exynos7-ufs
		- samsung,exynosautov9-ufs
		- samsung,exynosautov9-ufs-vh
		@@ -38,14 +36,24 @@ properties:
		- const: ufsp

		clocks:
		minItems: 2
		items:
		- description: ufs link core clock
		- description: unipro main clock
		- description: fmp clock
		- description: ufs aclk clock
		- description: ufs pclk clock
		- description: sysreg clock

		clock-names:
		minItems: 2
		items:
		- const: core_clk
		- const: sclk_unipro_main
		- const: fmp
		- const: aclk
		- const: pclk
		- const: sysreg

		phys:
		maxItems: 1
		@@ -72,6 +80,30 @@ required:
		- clocks
		- clock-names

		allOf:
		- $ref: ufs-common.yaml
		- if:
		properties:
		compatible:
		contains:
		const: google,gs101-ufs

		then:
		properties:
		clocks:
		minItems: 6

		clock-names:
		minItems: 6

		else:
		properties:
		clocks:
		maxItems: 2

		clock-names:
		maxItems: 2

		unevaluatedProperties: false

		examples:

Documentation/driver-api/scsi.rst

+7 −8

Original line number	Diff line number	Diff line
		@@ -20,7 +20,7 @@ Although the old parallel (fast/wide/ultra) SCSI bus has largely fallen
		out of use, the SCSI command set is more widely used than ever to
		communicate with devices over a number of different busses.

		The `SCSI protocol <http://www.t10.org/scsi-3.htm>`__ is a big-endian
		The `SCSI protocol <https://www.t10.org/scsi-3.htm>`__ is a big-endian
		peer-to-peer packet based protocol. SCSI commands are 6, 10, 12, or 16
		bytes long, often followed by an associated data payload.

		@@ -28,8 +28,7 @@ SCSI commands can be transported over just about any kind of bus, and
		are the default protocol for storage devices attached to USB, SATA, SAS,
		Fibre Channel, FireWire, and ATAPI devices. SCSI packets are also
		commonly exchanged over Infiniband,
		`I2O <http://i2o.shadowconnect.com/faq.php>`__, TCP/IP
		(`iSCSI <https://en.wikipedia.org/wiki/ISCSI>`__), even `Parallel
		TCP/IP (`iSCSI <https://en.wikipedia.org/wiki/ISCSI>`__), even `Parallel
		ports <http://cyberelk.net/tim/parport/parscsi.html>`__.

		Design of the Linux SCSI subsystem
		@@ -170,9 +169,9 @@ drivers/scsi/scsi_netlink.c

		Infrastructure to provide async events from transports to userspace via
		netlink, using a single NETLINK_SCSITRANSPORT protocol for all
		transports. See `the original patch
		submission <http://marc.info/?l=linux-scsi&m=115507374832500&w=2>`__ for
		more details.
		transports. See `the original patch submission
		<https://lore.kernel.org/linux-scsi/1155070439.6275.5.camel@localhost.localdomain/>`__
		for more details.

		.. kernel-doc:: drivers/scsi/scsi_netlink.c
		:internal:
		@@ -328,11 +327,11 @@ the ordinary is seen.
		To be more realistic, the simulated devices have the transport
		attributes of SAS disks.

		For documentation see http://sg.danny.cz/sg/sdebug26.html
		For documentation see http://sg.danny.cz/sg/scsi_debug.html

		todo
		~~~~

		Parallel (fast/wide/ultra) SCSI, USB, SATA, SAS, Fibre Channel,
		FireWire, ATAPI devices, Infiniband, I2O, Parallel ports,
		FireWire, ATAPI devices, Infiniband, Parallel ports,
		netlink...

Documentation/scsi/scsi_mid_low_api.rst

+11 −11

Original line number	Diff line number	Diff line
		@@ -42,18 +42,18 @@ This version of the document roughly matches linux kernel version 2.6.8 .
		Documentation
		=============
		There is a SCSI documentation directory within the kernel source tree,
		typically Documentation/scsi . Most documents are in plain
		(i.e. ASCII) text. This file is named scsi_mid_low_api.txt and can be
		typically Documentation/scsi . Most documents are in reStructuredText
		format. This file is named scsi_mid_low_api.rst and can be
		found in that directory. A more recent copy of this document may be found
		at http://web.archive.org/web/20070107183357rn_1/sg.torque.net/scsi/.
		Many LLDs are documented there (e.g. aic7xxx.txt). The SCSI mid-level is
		briefly described in scsi.txt which contains a url to a document
		describing the SCSI subsystem in the lk 2.4 series. Two upper level
		drivers have documents in that directory: st.txt (SCSI tape driver) and
		scsi-generic.txt (for the sg driver).

		Some documentation (or urls) for LLDs may be found in the C source code
		or in the same directory as the C source code. For example to find a url
		at https://docs.kernel.org/scsi/scsi_mid_low_api.html. Many LLDs are
		documented in Documentation/scsi (e.g. aic7xxx.rst). The SCSI mid-level is
		briefly described in scsi.rst which contains a URL to a document describing
		the SCSI subsystem in the Linux Kernel 2.4 series. Two upper level
		drivers have documents in that directory: st.rst (SCSI tape driver) and
		scsi-generic.rst (for the sg driver).

		Some documentation (or URLs) for LLDs may be found in the C source code
		or in the same directory as the C source code. For example to find a URL
		about the USB mass storage driver see the
		/usr/src/linux/drivers/usb/storage directory.

MAINTAINERS

+1 −2

Original line number	Diff line number	Diff line
		@@ -5828,10 +5828,9 @@ F: include/uapi/misc/cxl.h

		CXLFLASH (IBM Coherent Accelerator Processor Interface CAPI Flash) SCSI DRIVER
		M: Manoj N. Kumar <manoj@linux.ibm.com>
		M: Matthew R. Ochs <mrochs@linux.ibm.com>
		M: Uma Krishnan <ukrishn@linux.ibm.com>
		L: linux-scsi@vger.kernel.org
		S: Supported
		S: Obsolete
		F: Documentation/arch/powerpc/cxlflash.rst
		F: drivers/scsi/cxlflash/
		F: include/uapi/scsi/cxlflash_ioctl.h

block/blk-settings.c

+0 −245

Original line number	Diff line number	Diff line
		@@ -282,72 +282,6 @@ int queue_limits_set(struct request_queue q, struct queue_limits lim)
		}
		EXPORT_SYMBOL_GPL(queue_limits_set);

		/**
		* blk_queue_bounce_limit - set bounce buffer limit for queue
		* @q: the request queue for the device
		* @bounce: bounce limit to enforce
		*
		* Description:
		* Force bouncing for ISA DMA ranges or highmem.
		*
		* DEPRECATED, don't use in new code.
		**/
		void blk_queue_bounce_limit(struct request_queue *q, enum blk_bounce bounce)
		{
		q->limits.bounce = bounce;
		}
		EXPORT_SYMBOL(blk_queue_bounce_limit);

		/**
		* blk_queue_max_hw_sectors - set max sectors for a request for this queue
		* @q: the request queue for the device
		* @max_hw_sectors: max hardware sectors in the usual 512b unit
		*
		* Description:
		* Enables a low level driver to set a hard upper limit,
		* max_hw_sectors, on the size of requests. max_hw_sectors is set by
		* the device driver based upon the capabilities of the I/O
		* controller.
		*
		* max_dev_sectors is a hard limit imposed by the storage device for
		* READ/WRITE requests. It is set by the disk driver.
		*
		* max_sectors is a soft limit imposed by the block layer for
		* filesystem type requests. This value can be overridden on a
		* per-device basis in /sys/block/<device>/queue/max_sectors_kb.
		* The soft limit can not exceed max_hw_sectors.
		**/
		void blk_queue_max_hw_sectors(struct request_queue *q, unsigned int max_hw_sectors)
		{
		struct queue_limits *limits = &q->limits;
		unsigned int max_sectors;

		if ((max_hw_sectors << 9) < PAGE_SIZE) {
		max_hw_sectors = 1 << (PAGE_SHIFT - 9);
		pr_info("%s: set to minimum %u\n", __func__, max_hw_sectors);
		}

		max_hw_sectors = round_down(max_hw_sectors,
		limits->logical_block_size >> SECTOR_SHIFT);
		limits->max_hw_sectors = max_hw_sectors;

		max_sectors = min_not_zero(max_hw_sectors, limits->max_dev_sectors);

		if (limits->max_user_sectors)
		max_sectors = min(max_sectors, limits->max_user_sectors);
		else
		max_sectors = min(max_sectors, BLK_DEF_MAX_SECTORS_CAP);

		max_sectors = round_down(max_sectors,
		limits->logical_block_size >> SECTOR_SHIFT);
		limits->max_sectors = max_sectors;

		if (!q->disk)
		return;
		q->disk->bdi->io_pages = max_sectors >> (PAGE_SHIFT - 9);
		}
		EXPORT_SYMBOL(blk_queue_max_hw_sectors);

		/**
		* blk_queue_chunk_sectors - set size of the chunk for this queue
		* @q: the request queue for the device
		@@ -442,65 +376,6 @@ void blk_queue_max_zone_append_sectors(struct request_queue *q,
		}
		EXPORT_SYMBOL_GPL(blk_queue_max_zone_append_sectors);

		/**
		* blk_queue_max_segments - set max hw segments for a request for this queue
		* @q: the request queue for the device
		* @max_segments: max number of segments
		*
		* Description:
		* Enables a low level driver to set an upper limit on the number of
		* hw data segments in a request.
		**/
		void blk_queue_max_segments(struct request_queue *q, unsigned short max_segments)
		{
		if (!max_segments) {
		max_segments = 1;
		pr_info("%s: set to minimum %u\n", __func__, max_segments);
		}

		q->limits.max_segments = max_segments;
		}
		EXPORT_SYMBOL(blk_queue_max_segments);

		/**
		* blk_queue_max_discard_segments - set max segments for discard requests
		* @q: the request queue for the device
		* @max_segments: max number of segments
		*
		* Description:
		* Enables a low level driver to set an upper limit on the number of
		* segments in a discard request.
		**/
		void blk_queue_max_discard_segments(struct request_queue *q,
		unsigned short max_segments)
		{
		q->limits.max_discard_segments = max_segments;
		}
		EXPORT_SYMBOL_GPL(blk_queue_max_discard_segments);

		/**
		* blk_queue_max_segment_size - set max segment size for blk_rq_map_sg
		* @q: the request queue for the device
		* @max_size: max size of segment in bytes
		*
		* Description:
		* Enables a low level driver to set an upper limit on the size of a
		* coalesced segment
		**/
		void blk_queue_max_segment_size(struct request_queue *q, unsigned int max_size)
		{
		if (max_size < PAGE_SIZE) {
		max_size = PAGE_SIZE;
		pr_info("%s: set to minimum %u\n", __func__, max_size);
		}

		/* see blk_queue_virt_boundary() for the explanation */
		WARN_ON_ONCE(q->limits.virt_boundary_mask);

		q->limits.max_segment_size = max_size;
		}
		EXPORT_SYMBOL(blk_queue_max_segment_size);

		/**
		* blk_queue_logical_block_size - set logical block size for the queue
		* @q: the request queue for the device
		@@ -667,29 +542,6 @@ void blk_limits_io_opt(struct queue_limits *limits, unsigned int opt)
		}
		EXPORT_SYMBOL(blk_limits_io_opt);

		/**
		* blk_queue_io_opt - set optimal request size for the queue
		* @q: the request queue for the device
		* @opt: optimal request size in bytes
		*
		* Description:
		* Storage devices may report an optimal I/O size, which is the
		* device's preferred unit for sustained I/O. This is rarely reported
		* for disk drives. For RAID arrays it is usually the stripe width or
		* the internal track size. A properly aligned multiple of
		* optimal_io_size is the preferred request size for workloads where
		* sustained throughput is desired.
		*/
		void blk_queue_io_opt(struct request_queue *q, unsigned int opt)
		{
		blk_limits_io_opt(&q->limits, opt);
		if (!q->disk)
		return;
		q->disk->bdi->ra_pages =
		max(queue_io_opt(q) * 2 / PAGE_SIZE, VM_READAHEAD_PAGES);
		}
		EXPORT_SYMBOL(blk_queue_io_opt);

		static int queue_limit_alignment_offset(const struct queue_limits *lim,
		sector_t sector)
		{
		@@ -939,81 +791,6 @@ void blk_queue_update_dma_pad(struct request_queue *q, unsigned int mask)
		}
		EXPORT_SYMBOL(blk_queue_update_dma_pad);

		/**
		* blk_queue_segment_boundary - set boundary rules for segment merging
		* @q: the request queue for the device
		* @mask: the memory boundary mask
		**/
		void blk_queue_segment_boundary(struct request_queue *q, unsigned long mask)
		{
		if (mask < PAGE_SIZE - 1) {
		mask = PAGE_SIZE - 1;
		pr_info("%s: set to minimum %lx\n", __func__, mask);
		}

		q->limits.seg_boundary_mask = mask;
		}
		EXPORT_SYMBOL(blk_queue_segment_boundary);

		/**
		* blk_queue_virt_boundary - set boundary rules for bio merging
		* @q: the request queue for the device
		* @mask: the memory boundary mask
		**/
		void blk_queue_virt_boundary(struct request_queue *q, unsigned long mask)
		{
		q->limits.virt_boundary_mask = mask;

		/*
		* Devices that require a virtual boundary do not support scatter/gather
		* I/O natively, but instead require a descriptor list entry for each
		* page (which might not be idential to the Linux PAGE_SIZE). Because
		* of that they are not limited by our notion of "segment size".
		*/
		if (mask)
		q->limits.max_segment_size = UINT_MAX;
		}
		EXPORT_SYMBOL(blk_queue_virt_boundary);

		/**
		* blk_queue_dma_alignment - set dma length and memory alignment
		* @q: the request queue for the device
		* @mask: alignment mask
		*
		* description:
		* set required memory and length alignment for direct dma transactions.
		* this is used when building direct io requests for the queue.
		*
		**/
		void blk_queue_dma_alignment(struct request_queue *q, int mask)
		{
		q->limits.dma_alignment = mask;
		}
		EXPORT_SYMBOL(blk_queue_dma_alignment);

		/**
		* blk_queue_update_dma_alignment - update dma length and memory alignment
		* @q: the request queue for the device
		* @mask: alignment mask
		*
		* description:
		* update required memory and length alignment for direct dma transactions.
		* If the requested alignment is larger than the current alignment, then
		* the current queue alignment is updated to the new value, otherwise it
		* is left alone. The design of this is to allow multiple objects
		* (driver, device, transport etc) to set their respective
		* alignments without having them interfere.
		*
		**/
		void blk_queue_update_dma_alignment(struct request_queue *q, int mask)
		{
		BUG_ON(mask > PAGE_SIZE);

		if (mask > q->limits.dma_alignment)
		q->limits.dma_alignment = mask;
		}
		EXPORT_SYMBOL(blk_queue_update_dma_alignment);

		/**
		* blk_set_queue_depth - tell the block layer about the device queue depth
		* @q: the request queue for the device
		@@ -1051,28 +828,6 @@ void blk_queue_write_cache(struct request_queue *q, bool wc, bool fua)
		}
		EXPORT_SYMBOL_GPL(blk_queue_write_cache);

		/**
		* blk_queue_can_use_dma_map_merging - configure queue for merging segments.
		* @q: the request queue for the device
		* @dev: the device pointer for dma
		*
		* Tell the block layer about merging the segments by dma map of @q.
		*/
		bool blk_queue_can_use_dma_map_merging(struct request_queue *q,
		struct device *dev)
		{
		unsigned long boundary = dma_get_merge_boundary(dev);

		if (!boundary)
		return false;

		/* No need to update max_segment_size. see blk_queue_virt_boundary() */
		blk_queue_virt_boundary(q, boundary);

		return true;
		}
		EXPORT_SYMBOL_GPL(blk_queue_can_use_dma_map_merging);

		/**
		* disk_set_zoned - inidicate a zoned device
		* @disk: gendisk to configure