1/* SPDX-License-Identifier: GPL-2.0 */
  2#ifndef _SCSI_SCSI_HOST_H
  3#define _SCSI_SCSI_HOST_H
  4
  5#include <linux/device.h>
  6#include <linux/list.h>
  7#include <linux/types.h>
  8#include <linux/workqueue.h>
  9#include <linux/mutex.h>
 10#include <linux/seq_file.h>
 11#include <linux/blk-mq.h>
 12#include <scsi/scsi.h>
 13
 14struct block_device;
 15struct completion;
 16struct module;
 17struct scsi_cmnd;
 18struct scsi_device;
 19struct scsi_host_cmd_pool;
 20struct scsi_target;
 21struct Scsi_Host;
 22struct scsi_host_cmd_pool;
 23struct scsi_transport_template;
 24
 25
 26#define SG_ALL	SG_CHUNK_SIZE
 27
 28#define MODE_UNKNOWN 0x00
 29#define MODE_INITIATOR 0x01
 30#define MODE_TARGET 0x02
 31
 32struct scsi_host_template {
 33	struct module *module;
 34	const char *name;
 
 
 
 
 
 
 
 
 35
 
 36	/*
 37	 * The info function will return whatever useful information the
 38	 * developer sees fit.  If not provided, then the name field will
 39	 * be used instead.
 40	 *
 41	 * Status: OPTIONAL
 42	 */
 43	const char *(* info)(struct Scsi_Host *);
 44
 45	/*
 46	 * Ioctl interface
 47	 *
 48	 * Status: OPTIONAL
 49	 */
 50	int (*ioctl)(struct scsi_device *dev, unsigned int cmd,
 51		     void __user *arg);
 52
 53
 54#ifdef CONFIG_COMPAT
 55	/* 
 56	 * Compat handler. Handle 32bit ABI.
 57	 * When unknown ioctl is passed return -ENOIOCTLCMD.
 58	 *
 59	 * Status: OPTIONAL
 60	 */
 61	int (*compat_ioctl)(struct scsi_device *dev, unsigned int cmd,
 62			    void __user *arg);
 63#endif
 64
 65	int (*init_cmd_priv)(struct Scsi_Host *shost, struct scsi_cmnd *cmd);
 66	int (*exit_cmd_priv)(struct Scsi_Host *shost, struct scsi_cmnd *cmd);
 67
 68	/*
 69	 * The queuecommand function is used to queue up a scsi
 70	 * command block to the LLDD.  When the driver finished
 71	 * processing the command the done callback is invoked.
 72	 *
 73	 * If queuecommand returns 0, then the driver has accepted the
 74	 * command.  It must also push it to the HBA if the scsi_cmnd
 75	 * flag SCMD_LAST is set, or if the driver does not implement
 76	 * commit_rqs.  The done() function must be called on the command
 77	 * when the driver has finished with it. (you may call done on the
 78	 * command before queuecommand returns, but in this case you
 79	 * *must* return 0 from queuecommand).
 80	 *
 81	 * Queuecommand may also reject the command, in which case it may
 82	 * not touch the command and must not call done() for it.
 83	 *
 84	 * There are two possible rejection returns:
 85	 *
 86	 *   SCSI_MLQUEUE_DEVICE_BUSY: Block this device temporarily, but
 87	 *   allow commands to other devices serviced by this host.
 88	 *
 89	 *   SCSI_MLQUEUE_HOST_BUSY: Block all devices served by this
 90	 *   host temporarily.
 91	 *
 92         * For compatibility, any other non-zero return is treated the
 93         * same as SCSI_MLQUEUE_HOST_BUSY.
 94	 *
 95	 * NOTE: "temporarily" means either until the next command for#
 96	 * this device/host completes, or a period of time determined by
 97	 * I/O pressure in the system if there are no other outstanding
 98	 * commands.
 99	 *
100	 * STATUS: REQUIRED
101	 */
102	int (* queuecommand)(struct Scsi_Host *, struct scsi_cmnd *);
103
104	/*
105	 * The commit_rqs function is used to trigger a hardware
106	 * doorbell after some requests have been queued with
107	 * queuecommand, when an error is encountered before sending
108	 * the request with SCMD_LAST set.
109	 *
110	 * STATUS: OPTIONAL
111	 */
112	void (*commit_rqs)(struct Scsi_Host *, u16);
113
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
114	/*
115	 * This is an error handling strategy routine.  You don't need to
116	 * define one of these if you don't want to - there is a default
117	 * routine that is present that should work in most cases.  For those
118	 * driver authors that have the inclination and ability to write their
119	 * own strategy routine, this is where it is specified.  Note - the
120	 * strategy routine is *ALWAYS* run in the context of the kernel eh
121	 * thread.  Thus you are guaranteed to *NOT* be in an interrupt
122	 * handler when you execute this, and you are also guaranteed to
123	 * *NOT* have any other commands being queued while you are in the
124	 * strategy routine. When you return from this function, operations
125	 * return to normal.
126	 *
127	 * See scsi_error.c scsi_unjam_host for additional comments about
128	 * what this function should and should not be attempting to do.
129	 *
130	 * Status: REQUIRED	(at least one of them)
131	 */
132	int (* eh_abort_handler)(struct scsi_cmnd *);
133	int (* eh_device_reset_handler)(struct scsi_cmnd *);
134	int (* eh_target_reset_handler)(struct scsi_cmnd *);
135	int (* eh_bus_reset_handler)(struct scsi_cmnd *);
136	int (* eh_host_reset_handler)(struct scsi_cmnd *);
137
138	/*
139	 * Before the mid layer attempts to scan for a new device where none
140	 * currently exists, it will call this entry in your driver.  Should
141	 * your driver need to allocate any structs or perform any other init
142	 * items in order to send commands to a currently unused target/lun
143	 * combo, then this is where you can perform those allocations.  This
144	 * is specifically so that drivers won't have to perform any kind of
145	 * "is this a new device" checks in their queuecommand routine,
146	 * thereby making the hot path a bit quicker.
147	 *
148	 * Return values: 0 on success, non-0 on failure
149	 *
150	 * Deallocation:  If we didn't find any devices at this ID, you will
151	 * get an immediate call to slave_destroy().  If we find something
152	 * here then you will get a call to slave_configure(), then the
153	 * device will be used for however long it is kept around, then when
154	 * the device is removed from the system (or * possibly at reboot
155	 * time), you will then get a call to slave_destroy().  This is
156	 * assuming you implement slave_configure and slave_destroy.
157	 * However, if you allocate memory and hang it off the device struct,
158	 * then you must implement the slave_destroy() routine at a minimum
159	 * in order to avoid leaking memory
160	 * each time a device is tore down.
161	 *
162	 * Status: OPTIONAL
163	 */
164	int (* slave_alloc)(struct scsi_device *);
165
166	/*
167	 * Once the device has responded to an INQUIRY and we know the
168	 * device is online, we call into the low level driver with the
169	 * struct scsi_device *.  If the low level device driver implements
170	 * this function, it *must* perform the task of setting the queue
171	 * depth on the device.  All other tasks are optional and depend
172	 * on what the driver supports and various implementation details.
173	 * 
174	 * Things currently recommended to be handled at this time include:
175	 *
176	 * 1.  Setting the device queue depth.  Proper setting of this is
177	 *     described in the comments for scsi_change_queue_depth.
178	 * 2.  Determining if the device supports the various synchronous
179	 *     negotiation protocols.  The device struct will already have
180	 *     responded to INQUIRY and the results of the standard items
181	 *     will have been shoved into the various device flag bits, eg.
182	 *     device->sdtr will be true if the device supports SDTR messages.
183	 * 3.  Allocating command structs that the device will need.
184	 * 4.  Setting the default timeout on this device (if needed).
185	 * 5.  Anything else the low level driver might want to do on a device
186	 *     specific setup basis...
187	 * 6.  Return 0 on success, non-0 on error.  The device will be marked
188	 *     as offline on error so that no access will occur.  If you return
189	 *     non-0, your slave_destroy routine will never get called for this
190	 *     device, so don't leave any loose memory hanging around, clean
191	 *     up after yourself before returning non-0
192	 *
193	 * Status: OPTIONAL
194	 */
195	int (* slave_configure)(struct scsi_device *);
196
197	/*
198	 * Immediately prior to deallocating the device and after all activity
199	 * has ceased the mid layer calls this point so that the low level
200	 * driver may completely detach itself from the scsi device and vice
201	 * versa.  The low level driver is responsible for freeing any memory
202	 * it allocated in the slave_alloc or slave_configure calls. 
203	 *
204	 * Status: OPTIONAL
205	 */
206	void (* slave_destroy)(struct scsi_device *);
207
208	/*
209	 * Before the mid layer attempts to scan for a new device attached
210	 * to a target where no target currently exists, it will call this
211	 * entry in your driver.  Should your driver need to allocate any
212	 * structs or perform any other init items in order to send commands
213	 * to a currently unused target, then this is where you can perform
214	 * those allocations.
215	 *
216	 * Return values: 0 on success, non-0 on failure
217	 *
218	 * Status: OPTIONAL
219	 */
220	int (* target_alloc)(struct scsi_target *);
221
222	/*
223	 * Immediately prior to deallocating the target structure, and
224	 * after all activity to attached scsi devices has ceased, the
225	 * midlayer calls this point so that the driver may deallocate
226	 * and terminate any references to the target.
227	 *
 
 
 
228	 * Status: OPTIONAL
229	 */
230	void (* target_destroy)(struct scsi_target *);
231
232	/*
233	 * If a host has the ability to discover targets on its own instead
234	 * of scanning the entire bus, it can fill in this function and
235	 * call scsi_scan_host().  This function will be called periodically
236	 * until it returns 1 with the scsi_host and the elapsed time of
237	 * the scan in jiffies.
238	 *
239	 * Status: OPTIONAL
240	 */
241	int (* scan_finished)(struct Scsi_Host *, unsigned long);
242
243	/*
244	 * If the host wants to be called before the scan starts, but
245	 * after the midlayer has set up ready for the scan, it can fill
246	 * in this function.
247	 *
248	 * Status: OPTIONAL
249	 */
250	void (* scan_start)(struct Scsi_Host *);
251
252	/*
253	 * Fill in this function to allow the queue depth of this host
254	 * to be changeable (on a per device basis).  Returns either
255	 * the current queue depth setting (may be different from what
256	 * was passed in) or an error.  An error should only be
257	 * returned if the requested depth is legal but the driver was
258	 * unable to set it.  If the requested depth is illegal, the
259	 * driver should set and return the closest legal queue depth.
260	 *
261	 * Status: OPTIONAL
262	 */
263	int (* change_queue_depth)(struct scsi_device *, int);
264
265	/*
266	 * This functions lets the driver expose the queue mapping
267	 * to the block layer.
268	 *
269	 * Status: OPTIONAL
270	 */
271	int (* map_queues)(struct Scsi_Host *shost);
 
 
 
 
 
 
 
 
 
 
272
273	/*
274	 * Check if scatterlists need to be padded for DMA draining.
275	 *
276	 * Status: OPTIONAL
277	 */
278	bool (* dma_need_drain)(struct request *rq);
279
280	/*
281	 * This function determines the BIOS parameters for a given
282	 * harddisk.  These tend to be numbers that are made up by
283	 * the host adapter.  Parameters:
284	 * size, device, list (heads, sectors, cylinders)
285	 *
286	 * Status: OPTIONAL
287	 */
288	int (* bios_param)(struct scsi_device *, struct block_device *,
289			sector_t, int []);
290
291	/*
292	 * This function is called when one or more partitions on the
293	 * device reach beyond the end of the device.
294	 *
295	 * Status: OPTIONAL
296	 */
297	void (*unlock_native_capacity)(struct scsi_device *);
298
299	/*
300	 * Can be used to export driver statistics and other infos to the
301	 * world outside the kernel ie. userspace and it also provides an
302	 * interface to feed the driver with information.
303	 *
304	 * Status: OBSOLETE
305	 */
306	int (*show_info)(struct seq_file *, struct Scsi_Host *);
307	int (*write_info)(struct Scsi_Host *, char *, int);
308
309	/*
310	 * This is an optional routine that allows the transport to become
311	 * involved when a scsi io timer fires. The return value tells the
312	 * timer routine how to finish the io timeout handling.
313	 *
314	 * Status: OPTIONAL
315	 */
316	enum blk_eh_timer_return (*eh_timed_out)(struct scsi_cmnd *);
 
 
 
 
 
 
317
318	/* This is an optional routine that allows transport to initiate
319	 * LLD adapter or firmware reset using sysfs attribute.
320	 *
321	 * Return values: 0 on success, -ve value on failure.
322	 *
323	 * Status: OPTIONAL
324	 */
325
326	int (*host_reset)(struct Scsi_Host *shost, int reset_type);
327#define SCSI_ADAPTER_RESET	1
328#define SCSI_FIRMWARE_RESET	2
329
330
331	/*
332	 * Name of proc directory
333	 */
334	const char *proc_name;
335
336	/*
337	 * Used to store the procfs directory if a driver implements the
338	 * show_info method.
339	 */
340	struct proc_dir_entry *proc_dir;
341
342	/*
343	 * This determines if we will use a non-interrupt driven
344	 * or an interrupt driven scheme.  It is set to the maximum number
345	 * of simultaneous commands a single hw queue in HBA will accept.
346	 */
347	int can_queue;
348
349	/*
350	 * In many instances, especially where disconnect / reconnect are
351	 * supported, our host also has an ID on the SCSI bus.  If this is
352	 * the case, then it must be reserved.  Please set this_id to -1 if
353	 * your setup is in single initiator mode, and the host lacks an
354	 * ID.
355	 */
356	int this_id;
357
358	/*
359	 * This determines the degree to which the host adapter is capable
360	 * of scatter-gather.
361	 */
362	unsigned short sg_tablesize;
363	unsigned short sg_prot_tablesize;
364
365	/*
366	 * Set this if the host adapter has limitations beside segment count.
367	 */
368	unsigned int max_sectors;
369
370	/*
371	 * Maximum size in bytes of a single segment.
372	 */
373	unsigned int max_segment_size;
374
375	/*
376	 * DMA scatter gather segment boundary limit. A segment crossing this
377	 * boundary will be split in two.
378	 */
379	unsigned long dma_boundary;
380
381	unsigned long virt_boundary_mask;
382
383	/*
384	 * This specifies "machine infinity" for host templates which don't
385	 * limit the transfer size.  Note this limit represents an absolute
386	 * maximum, and may be over the transfer limits allowed for
387	 * individual devices (e.g. 256 for SCSI-1).
388	 */
389#define SCSI_DEFAULT_MAX_SECTORS	1024
390
391	/*
392	 * True if this host adapter can make good use of linked commands.
393	 * This will allow more than one command to be queued to a given
394	 * unit on a given host.  Set this to the maximum number of command
395	 * blocks to be provided for each device.  Set this to 1 for one
396	 * command block per lun, 2 for two, etc.  Do not set this to 0.
397	 * You should make sure that the host adapter will do the right thing
398	 * before you try setting this above 1.
399	 */
400	short cmd_per_lun;
401
402	/*
403	 * present contains counter indicating how many boards of this
404	 * type were found when we did the scan.
405	 */
406	unsigned char present;
407
408	/* If use block layer to manage tags, this is tag allocation policy */
409	int tag_alloc_policy;
410
411	/*
412	 * Track QUEUE_FULL events and reduce queue depth on demand.
413	 */
414	unsigned track_queue_depth:1;
415
416	/*
417	 * This specifies the mode that a LLD supports.
418	 */
419	unsigned supported_mode:2;
420
421	/*
422	 * True if this host adapter uses unchecked DMA onto an ISA bus.
423	 */
424	unsigned unchecked_isa_dma:1;
425
426	/*
427	 * True for emulated SCSI host adapters (e.g. ATAPI).
428	 */
429	unsigned emulated:1;
430
431	/*
432	 * True if the low-level driver performs its own reset-settle delays.
433	 */
434	unsigned skip_settle_delay:1;
435
436	/* True if the controller does not support WRITE SAME */
437	unsigned no_write_same:1;
438
 
 
 
 
 
 
439	/*
440	 * Countdown for host blocking with no commands outstanding.
441	 */
442	unsigned int max_host_blocked;
443
444	/*
445	 * Default value for the blocking.  If the queue is empty,
446	 * host_blocked counts down in the request_fn until it restarts
447	 * host operations as zero is reached.  
448	 *
449	 * FIXME: This should probably be a value in the template
450	 */
451#define SCSI_DEFAULT_HOST_BLOCKED	7
452
453	/*
454	 * Pointer to the sysfs class properties for this host, NULL terminated.
455	 */
456	struct device_attribute **shost_attrs;
457
458	/*
459	 * Pointer to the SCSI device properties for this host, NULL terminated.
460	 */
461	struct device_attribute **sdev_attrs;
462
463	/*
464	 * Pointer to the SCSI device attribute groups for this host,
465	 * NULL terminated.
466	 */
467	const struct attribute_group **sdev_groups;
468
469	/*
470	 * Vendor Identifier associated with the host
471	 *
472	 * Note: When specifying vendor_id, be sure to read the
473	 *   Vendor Type and ID formatting requirements specified in
474	 *   scsi_netlink.h
475	 */
476	u64 vendor_id;
477
478	/*
479	 * Additional per-command data allocated for the driver.
480	 */
481	unsigned int cmd_size;
482	struct scsi_host_cmd_pool *cmd_pool;
483
484	/* Delay for runtime autosuspend */
485	int rpm_autosuspend_delay;
486};
487
488/*
489 * Temporary #define for host lock push down. Can be removed when all
490 * drivers have been updated to take advantage of unlocked
491 * queuecommand.
492 *
493 */
494#define DEF_SCSI_QCMD(func_name) \
495	int func_name(struct Scsi_Host *shost, struct scsi_cmnd *cmd)	\
496	{								\
497		unsigned long irq_flags;				\
498		int rc;							\
499		spin_lock_irqsave(shost->host_lock, irq_flags);		\
500		rc = func_name##_lck (cmd, cmd->scsi_done);			\
501		spin_unlock_irqrestore(shost->host_lock, irq_flags);	\
502		return rc;						\
503	}
504
505
506/*
507 * shost state: If you alter this, you also need to alter scsi_sysfs.c
508 * (for the ascii descriptions) and the state model enforcer:
509 * scsi_host_set_state()
510 */
511enum scsi_host_state {
512	SHOST_CREATED = 1,
513	SHOST_RUNNING,
514	SHOST_CANCEL,
515	SHOST_DEL,
516	SHOST_RECOVERY,
517	SHOST_CANCEL_RECOVERY,
518	SHOST_DEL_RECOVERY,
519};
520
521struct Scsi_Host {
522	/*
523	 * __devices is protected by the host_lock, but you should
524	 * usually use scsi_device_lookup / shost_for_each_device
525	 * to access it and don't care about locking yourself.
526	 * In the rare case of being in irq context you can use
527	 * their __ prefixed variants with the lock held. NEVER
528	 * access this list directly from a driver.
529	 */
530	struct list_head	__devices;
531	struct list_head	__targets;
532	
533	struct list_head	starved_list;
534
535	spinlock_t		default_lock;
536	spinlock_t		*host_lock;
537
538	struct mutex		scan_mutex;/* serialize scanning activity */
539
 
540	struct list_head	eh_cmd_q;
541	struct task_struct    * ehandler;  /* Error recovery thread. */
542	struct completion     * eh_action; /* Wait for specific actions on the
543					      host. */
544	wait_queue_head_t       host_wait;
545	struct scsi_host_template *hostt;
546	struct scsi_transport_template *transportt;
547
 
 
548	/* Area to keep a shared tag map */
549	struct blk_mq_tag_set	tag_set;
550
551	atomic_t host_blocked;
552
553	unsigned int host_failed;	   /* commands that failed.
554					      protected by host_lock */
555	unsigned int host_eh_scheduled;    /* EH scheduled without command */
556    
557	unsigned int host_no;  /* Used for IOCTL_GET_IDLUN, /proc/scsi et al. */
558
559	/* next two fields are used to bound the time spent in error handling */
560	int eh_deadline;
561	unsigned long last_reset;
562
563
564	/*
565	 * These three parameters can be used to allow for wide scsi,
566	 * and for host adapters that support multiple busses
567	 * The last two should be set to 1 more than the actual max id
568	 * or lun (e.g. 8 for SCSI parallel systems).
569	 */
570	unsigned int max_channel;
571	unsigned int max_id;
572	u64 max_lun;
573
574	/*
575	 * This is a unique identifier that must be assigned so that we
576	 * have some way of identifying each detected host adapter properly
577	 * and uniquely.  For hosts that do not support more than one card
578	 * in the system at one time, this does not need to be set.  It is
579	 * initialized to 0 in scsi_register.
580	 */
581	unsigned int unique_id;
582
583	/*
584	 * The maximum length of SCSI commands that this host can accept.
585	 * Probably 12 for most host adapters, but could be 16 for others.
586	 * or 260 if the driver supports variable length cdbs.
587	 * For drivers that don't set this field, a value of 12 is
588	 * assumed.
589	 */
590	unsigned short max_cmd_len;
591
592	int this_id;
593	int can_queue;
594	short cmd_per_lun;
595	short unsigned int sg_tablesize;
596	short unsigned int sg_prot_tablesize;
597	unsigned int max_sectors;
 
598	unsigned int max_segment_size;
599	unsigned long dma_boundary;
600	unsigned long virt_boundary_mask;
601	/*
602	 * In scsi-mq mode, the number of hardware queues supported by the LLD.
603	 *
604	 * Note: it is assumed that each hardware queue has a queue depth of
605	 * can_queue. In other words, the total queue depth per host
606	 * is nr_hw_queues * can_queue.
 
607	 */
608	unsigned nr_hw_queues;
 
609	unsigned active_mode:2;
610	unsigned unchecked_isa_dma:1;
611
612	/*
613	 * Host has requested that no further requests come through for the
614	 * time being.
615	 */
616	unsigned host_self_blocked:1;
617    
618	/*
619	 * Host uses correct SCSI ordering not PC ordering. The bit is
620	 * set for the minority of drivers whose authors actually read
621	 * the spec ;).
622	 */
623	unsigned reverse_ordering:1;
624
625	/* Task mgmt function in progress */
626	unsigned tmf_in_progress:1;
627
628	/* Asynchronous scan in progress */
629	unsigned async_scan:1;
630
631	/* Don't resume host in EH */
632	unsigned eh_noresume:1;
633
634	/* The controller does not support WRITE SAME */
635	unsigned no_write_same:1;
636
 
 
 
 
 
 
637	/* Host responded with short (<36 bytes) INQUIRY result */
638	unsigned short_inquiry:1;
639
640	/* The transport requires the LUN bits NOT to be stored in CDB[1] */
641	unsigned no_scsi2_lun_in_cdb:1;
642
643	/*
644	 * Optional work queue to be utilized by the transport
645	 */
646	char work_q_name[20];
647	struct workqueue_struct *work_q;
648
649	/*
650	 * Task management function work queue
651	 */
652	struct workqueue_struct *tmf_work_q;
653
654	/*
655	 * Value host_blocked counts down from
656	 */
657	unsigned int max_host_blocked;
658
659	/* Protection Information */
660	unsigned int prot_capabilities;
661	unsigned char prot_guard_type;
662
663	/* legacy crap */
664	unsigned long base;
665	unsigned long io_port;
666	unsigned char n_io_port;
667	unsigned char dma_channel;
668	unsigned int  irq;
669	
670
671	enum scsi_host_state shost_state;
672
673	/* ldm bits */
674	struct device		shost_gendev, shost_dev;
675
676	/*
677	 * Points to the transport data (if any) which is allocated
678	 * separately
679	 */
680	void *shost_data;
681
682	/*
683	 * Points to the physical bus device we'd use to do DMA
684	 * Needed just in case we have virtual hosts.
685	 */
686	struct device *dma_dev;
687
688	/*
689	 * We should ensure that this is aligned, both for better performance
690	 * and also because some compilers (m68k) don't automatically force
691	 * alignment to a long boundary.
692	 */
693	unsigned long hostdata[]  /* Used for storage of host specific stuff */
694		__attribute__ ((aligned (sizeof(unsigned long))));
695};
696
697#define		class_to_shost(d)	\
698	container_of(d, struct Scsi_Host, shost_dev)
699
700#define shost_printk(prefix, shost, fmt, a...)	\
701	dev_printk(prefix, &(shost)->shost_gendev, fmt, ##a)
702
703static inline void *shost_priv(struct Scsi_Host *shost)
704{
705	return (void *)shost->hostdata;
706}
707
708int scsi_is_host_device(const struct device *);
709
710static inline struct Scsi_Host *dev_to_shost(struct device *dev)
711{
712	while (!scsi_is_host_device(dev)) {
713		if (!dev->parent)
714			return NULL;
715		dev = dev->parent;
716	}
717	return container_of(dev, struct Scsi_Host, shost_gendev);
718}
719
720static inline int scsi_host_in_recovery(struct Scsi_Host *shost)
721{
722	return shost->shost_state == SHOST_RECOVERY ||
723		shost->shost_state == SHOST_CANCEL_RECOVERY ||
724		shost->shost_state == SHOST_DEL_RECOVERY ||
725		shost->tmf_in_progress;
726}
727
728extern int scsi_queue_work(struct Scsi_Host *, struct work_struct *);
729extern void scsi_flush_work(struct Scsi_Host *);
730
731extern struct Scsi_Host *scsi_host_alloc(struct scsi_host_template *, int);
732extern int __must_check scsi_add_host_with_dma(struct Scsi_Host *,
733					       struct device *,
734					       struct device *);
 
 
 
 
 
 
735extern void scsi_scan_host(struct Scsi_Host *);
736extern void scsi_rescan_device(struct device *);
737extern void scsi_remove_host(struct Scsi_Host *);
738extern struct Scsi_Host *scsi_host_get(struct Scsi_Host *);
739extern int scsi_host_busy(struct Scsi_Host *shost);
740extern void scsi_host_put(struct Scsi_Host *t);
741extern struct Scsi_Host *scsi_host_lookup(unsigned short);
742extern const char *scsi_host_state_name(enum scsi_host_state);
743extern void scsi_host_complete_all_commands(struct Scsi_Host *shost,
744					    int status);
745
746static inline int __must_check scsi_add_host(struct Scsi_Host *host,
747					     struct device *dev)
748{
749	return scsi_add_host_with_dma(host, dev, dev);
750}
751
752static inline struct device *scsi_get_device(struct Scsi_Host *shost)
753{
754        return shost->shost_gendev.parent;
755}
756
757/**
758 * scsi_host_scan_allowed - Is scanning of this host allowed
759 * @shost:	Pointer to Scsi_Host.
760 **/
761static inline int scsi_host_scan_allowed(struct Scsi_Host *shost)
762{
763	return shost->shost_state == SHOST_RUNNING ||
764	       shost->shost_state == SHOST_RECOVERY;
765}
766
767extern void scsi_unblock_requests(struct Scsi_Host *);
768extern void scsi_block_requests(struct Scsi_Host *);
769extern int scsi_host_block(struct Scsi_Host *shost);
770extern int scsi_host_unblock(struct Scsi_Host *shost, int new_state);
771
772void scsi_host_busy_iter(struct Scsi_Host *,
773			 bool (*fn)(struct scsi_cmnd *, void *, bool), void *priv);
774
775struct class_container;
776
777/*
778 * These two functions are used to allocate and free a pseudo device
779 * which will connect to the host adapter itself rather than any
780 * physical device.  You must deallocate when you are done with the
781 * thing.  This physical pseudo-device isn't real and won't be available
782 * from any high-level drivers.
783 */
784extern void scsi_free_host_dev(struct scsi_device *);
785extern struct scsi_device *scsi_get_host_dev(struct Scsi_Host *);
786
787/*
788 * DIF defines the exchange of protection information between
789 * initiator and SBC block device.
790 *
791 * DIX defines the exchange of protection information between OS and
792 * initiator.
793 */
794enum scsi_host_prot_capabilities {
795	SHOST_DIF_TYPE1_PROTECTION = 1 << 0, /* T10 DIF Type 1 */
796	SHOST_DIF_TYPE2_PROTECTION = 1 << 1, /* T10 DIF Type 2 */
797	SHOST_DIF_TYPE3_PROTECTION = 1 << 2, /* T10 DIF Type 3 */
798
799	SHOST_DIX_TYPE0_PROTECTION = 1 << 3, /* DIX between OS and HBA only */
800	SHOST_DIX_TYPE1_PROTECTION = 1 << 4, /* DIX with DIF Type 1 */
801	SHOST_DIX_TYPE2_PROTECTION = 1 << 5, /* DIX with DIF Type 2 */
802	SHOST_DIX_TYPE3_PROTECTION = 1 << 6, /* DIX with DIF Type 3 */
803};
804
805/*
806 * SCSI hosts which support the Data Integrity Extensions must
807 * indicate their capabilities by setting the prot_capabilities using
808 * this call.
809 */
810static inline void scsi_host_set_prot(struct Scsi_Host *shost, unsigned int mask)
811{
812	shost->prot_capabilities = mask;
813}
814
815static inline unsigned int scsi_host_get_prot(struct Scsi_Host *shost)
816{
817	return shost->prot_capabilities;
818}
819
820static inline int scsi_host_prot_dma(struct Scsi_Host *shost)
821{
822	return shost->prot_capabilities >= SHOST_DIX_TYPE0_PROTECTION;
823}
824
825static inline unsigned int scsi_host_dif_capable(struct Scsi_Host *shost, unsigned int target_type)
826{
827	static unsigned char cap[] = { 0,
828				       SHOST_DIF_TYPE1_PROTECTION,
829				       SHOST_DIF_TYPE2_PROTECTION,
830				       SHOST_DIF_TYPE3_PROTECTION };
831
832	if (target_type >= ARRAY_SIZE(cap))
833		return 0;
834
835	return shost->prot_capabilities & cap[target_type] ? target_type : 0;
836}
837
838static inline unsigned int scsi_host_dix_capable(struct Scsi_Host *shost, unsigned int target_type)
839{
840#if defined(CONFIG_BLK_DEV_INTEGRITY)
841	static unsigned char cap[] = { SHOST_DIX_TYPE0_PROTECTION,
842				       SHOST_DIX_TYPE1_PROTECTION,
843				       SHOST_DIX_TYPE2_PROTECTION,
844				       SHOST_DIX_TYPE3_PROTECTION };
845
846	if (target_type >= ARRAY_SIZE(cap))
847		return 0;
848
849	return shost->prot_capabilities & cap[target_type];
850#endif
851	return 0;
852}
853
854/*
855 * All DIX-capable initiators must support the T10-mandated CRC
856 * checksum.  Controllers can optionally implement the IP checksum
857 * scheme which has much lower impact on system performance.  Note
858 * that the main rationale for the checksum is to match integrity
859 * metadata with data.  Detecting bit errors are a job for ECC memory
860 * and buses.
861 */
862
863enum scsi_host_guard_type {
864	SHOST_DIX_GUARD_CRC = 1 << 0,
865	SHOST_DIX_GUARD_IP  = 1 << 1,
866};
867
868static inline void scsi_host_set_guard(struct Scsi_Host *shost, unsigned char type)
869{
870	shost->prot_guard_type = type;
871}
872
873static inline unsigned char scsi_host_get_guard(struct Scsi_Host *shost)
874{
875	return shost->prot_guard_type;
876}
877
878extern int scsi_host_set_state(struct Scsi_Host *, enum scsi_host_state);
879
880#endif /* _SCSI_SCSI_HOST_H */

  1/* SPDX-License-Identifier: GPL-2.0 */
  2#ifndef _SCSI_SCSI_HOST_H
  3#define _SCSI_SCSI_HOST_H
  4
  5#include <linux/device.h>
  6#include <linux/list.h>
  7#include <linux/types.h>
  8#include <linux/workqueue.h>
  9#include <linux/mutex.h>
 10#include <linux/seq_file.h>
 11#include <linux/blk-mq.h>
 12#include <scsi/scsi.h>
 13
 14struct block_device;
 15struct completion;
 16struct module;
 17struct scsi_cmnd;
 18struct scsi_device;
 
 19struct scsi_target;
 20struct Scsi_Host;
 
 21struct scsi_transport_template;
 22
 23
 24#define SG_ALL	SG_CHUNK_SIZE
 25
 26#define MODE_UNKNOWN 0x00
 27#define MODE_INITIATOR 0x01
 28#define MODE_TARGET 0x02
 29
 30/**
 31 * enum scsi_timeout_action - How to handle a command that timed out.
 32 * @SCSI_EH_DONE: The command has already been completed.
 33 * @SCSI_EH_RESET_TIMER: Reset the timer and continue waiting for completion.
 34 * @SCSI_EH_NOT_HANDLED: The command has not yet finished. Abort the command.
 35 */
 36enum scsi_timeout_action {
 37	SCSI_EH_DONE,
 38	SCSI_EH_RESET_TIMER,
 39	SCSI_EH_NOT_HANDLED,
 40};
 41
 42struct scsi_host_template {
 43	/*
 44	 * Put fields referenced in IO submission path together in
 45	 * same cacheline
 
 
 
 46	 */
 
 47
 48	/*
 49	 * Additional per-command data allocated for the driver.
 
 
 
 
 
 
 
 
 
 
 
 
 
 50	 */
 51	unsigned int cmd_size;
 
 
 
 
 
 52
 53	/*
 54	 * The queuecommand function is used to queue up a scsi
 55	 * command block to the LLDD.  When the driver finished
 56	 * processing the command the done callback is invoked.
 57	 *
 58	 * If queuecommand returns 0, then the driver has accepted the
 59	 * command.  It must also push it to the HBA if the scsi_cmnd
 60	 * flag SCMD_LAST is set, or if the driver does not implement
 61	 * commit_rqs.  The done() function must be called on the command
 62	 * when the driver has finished with it. (you may call done on the
 63	 * command before queuecommand returns, but in this case you
 64	 * *must* return 0 from queuecommand).
 65	 *
 66	 * Queuecommand may also reject the command, in which case it may
 67	 * not touch the command and must not call done() for it.
 68	 *
 69	 * There are two possible rejection returns:
 70	 *
 71	 *   SCSI_MLQUEUE_DEVICE_BUSY: Block this device temporarily, but
 72	 *   allow commands to other devices serviced by this host.
 73	 *
 74	 *   SCSI_MLQUEUE_HOST_BUSY: Block all devices served by this
 75	 *   host temporarily.
 76	 *
 77         * For compatibility, any other non-zero return is treated the
 78         * same as SCSI_MLQUEUE_HOST_BUSY.
 79	 *
 80	 * NOTE: "temporarily" means either until the next command for#
 81	 * this device/host completes, or a period of time determined by
 82	 * I/O pressure in the system if there are no other outstanding
 83	 * commands.
 84	 *
 85	 * STATUS: REQUIRED
 86	 */
 87	int (* queuecommand)(struct Scsi_Host *, struct scsi_cmnd *);
 88
 89	/*
 90	 * The commit_rqs function is used to trigger a hardware
 91	 * doorbell after some requests have been queued with
 92	 * queuecommand, when an error is encountered before sending
 93	 * the request with SCMD_LAST set.
 94	 *
 95	 * STATUS: OPTIONAL
 96	 */
 97	void (*commit_rqs)(struct Scsi_Host *, u16);
 98
 99	struct module *module;
100	const char *name;
101
102	/*
103	 * The info function will return whatever useful information the
104	 * developer sees fit.  If not provided, then the name field will
105	 * be used instead.
106	 *
107	 * Status: OPTIONAL
108	 */
109	const char *(*info)(struct Scsi_Host *);
110
111	/*
112	 * Ioctl interface
113	 *
114	 * Status: OPTIONAL
115	 */
116	int (*ioctl)(struct scsi_device *dev, unsigned int cmd,
117		     void __user *arg);
118
119
120#ifdef CONFIG_COMPAT
121	/*
122	 * Compat handler. Handle 32bit ABI.
123	 * When unknown ioctl is passed return -ENOIOCTLCMD.
124	 *
125	 * Status: OPTIONAL
126	 */
127	int (*compat_ioctl)(struct scsi_device *dev, unsigned int cmd,
128			    void __user *arg);
129#endif
130
131	int (*init_cmd_priv)(struct Scsi_Host *shost, struct scsi_cmnd *cmd);
132	int (*exit_cmd_priv)(struct Scsi_Host *shost, struct scsi_cmnd *cmd);
133
134	/*
135	 * This is an error handling strategy routine.  You don't need to
136	 * define one of these if you don't want to - there is a default
137	 * routine that is present that should work in most cases.  For those
138	 * driver authors that have the inclination and ability to write their
139	 * own strategy routine, this is where it is specified.  Note - the
140	 * strategy routine is *ALWAYS* run in the context of the kernel eh
141	 * thread.  Thus you are guaranteed to *NOT* be in an interrupt
142	 * handler when you execute this, and you are also guaranteed to
143	 * *NOT* have any other commands being queued while you are in the
144	 * strategy routine. When you return from this function, operations
145	 * return to normal.
146	 *
147	 * See scsi_error.c scsi_unjam_host for additional comments about
148	 * what this function should and should not be attempting to do.
149	 *
150	 * Status: REQUIRED	(at least one of them)
151	 */
152	int (* eh_abort_handler)(struct scsi_cmnd *);
153	int (* eh_device_reset_handler)(struct scsi_cmnd *);
154	int (* eh_target_reset_handler)(struct scsi_cmnd *);
155	int (* eh_bus_reset_handler)(struct scsi_cmnd *);
156	int (* eh_host_reset_handler)(struct scsi_cmnd *);
157
158	/*
159	 * Before the mid layer attempts to scan for a new device where none
160	 * currently exists, it will call this entry in your driver.  Should
161	 * your driver need to allocate any structs or perform any other init
162	 * items in order to send commands to a currently unused target/lun
163	 * combo, then this is where you can perform those allocations.  This
164	 * is specifically so that drivers won't have to perform any kind of
165	 * "is this a new device" checks in their queuecommand routine,
166	 * thereby making the hot path a bit quicker.
167	 *
168	 * Return values: 0 on success, non-0 on failure
169	 *
170	 * Deallocation:  If we didn't find any devices at this ID, you will
171	 * get an immediate call to slave_destroy().  If we find something
172	 * here then you will get a call to slave_configure(), then the
173	 * device will be used for however long it is kept around, then when
174	 * the device is removed from the system (or * possibly at reboot
175	 * time), you will then get a call to slave_destroy().  This is
176	 * assuming you implement slave_configure and slave_destroy.
177	 * However, if you allocate memory and hang it off the device struct,
178	 * then you must implement the slave_destroy() routine at a minimum
179	 * in order to avoid leaking memory
180	 * each time a device is tore down.
181	 *
182	 * Status: OPTIONAL
183	 */
184	int (* slave_alloc)(struct scsi_device *);
185
186	/*
187	 * Once the device has responded to an INQUIRY and we know the
188	 * device is online, we call into the low level driver with the
189	 * struct scsi_device *.  If the low level device driver implements
190	 * this function, it *must* perform the task of setting the queue
191	 * depth on the device.  All other tasks are optional and depend
192	 * on what the driver supports and various implementation details.
193	 * 
194	 * Things currently recommended to be handled at this time include:
195	 *
196	 * 1.  Setting the device queue depth.  Proper setting of this is
197	 *     described in the comments for scsi_change_queue_depth.
198	 * 2.  Determining if the device supports the various synchronous
199	 *     negotiation protocols.  The device struct will already have
200	 *     responded to INQUIRY and the results of the standard items
201	 *     will have been shoved into the various device flag bits, eg.
202	 *     device->sdtr will be true if the device supports SDTR messages.
203	 * 3.  Allocating command structs that the device will need.
204	 * 4.  Setting the default timeout on this device (if needed).
205	 * 5.  Anything else the low level driver might want to do on a device
206	 *     specific setup basis...
207	 * 6.  Return 0 on success, non-0 on error.  The device will be marked
208	 *     as offline on error so that no access will occur.  If you return
209	 *     non-0, your slave_destroy routine will never get called for this
210	 *     device, so don't leave any loose memory hanging around, clean
211	 *     up after yourself before returning non-0
212	 *
213	 * Status: OPTIONAL
214	 */
215	int (* slave_configure)(struct scsi_device *);
216
217	/*
218	 * Immediately prior to deallocating the device and after all activity
219	 * has ceased the mid layer calls this point so that the low level
220	 * driver may completely detach itself from the scsi device and vice
221	 * versa.  The low level driver is responsible for freeing any memory
222	 * it allocated in the slave_alloc or slave_configure calls. 
223	 *
224	 * Status: OPTIONAL
225	 */
226	void (* slave_destroy)(struct scsi_device *);
227
228	/*
229	 * Before the mid layer attempts to scan for a new device attached
230	 * to a target where no target currently exists, it will call this
231	 * entry in your driver.  Should your driver need to allocate any
232	 * structs or perform any other init items in order to send commands
233	 * to a currently unused target, then this is where you can perform
234	 * those allocations.
235	 *
236	 * Return values: 0 on success, non-0 on failure
237	 *
238	 * Status: OPTIONAL
239	 */
240	int (* target_alloc)(struct scsi_target *);
241
242	/*
243	 * Immediately prior to deallocating the target structure, and
244	 * after all activity to attached scsi devices has ceased, the
245	 * midlayer calls this point so that the driver may deallocate
246	 * and terminate any references to the target.
247	 *
248	 * Note: This callback is called with the host lock held and hence
249	 * must not sleep.
250	 *
251	 * Status: OPTIONAL
252	 */
253	void (* target_destroy)(struct scsi_target *);
254
255	/*
256	 * If a host has the ability to discover targets on its own instead
257	 * of scanning the entire bus, it can fill in this function and
258	 * call scsi_scan_host().  This function will be called periodically
259	 * until it returns 1 with the scsi_host and the elapsed time of
260	 * the scan in jiffies.
261	 *
262	 * Status: OPTIONAL
263	 */
264	int (* scan_finished)(struct Scsi_Host *, unsigned long);
265
266	/*
267	 * If the host wants to be called before the scan starts, but
268	 * after the midlayer has set up ready for the scan, it can fill
269	 * in this function.
270	 *
271	 * Status: OPTIONAL
272	 */
273	void (* scan_start)(struct Scsi_Host *);
274
275	/*
276	 * Fill in this function to allow the queue depth of this host
277	 * to be changeable (on a per device basis).  Returns either
278	 * the current queue depth setting (may be different from what
279	 * was passed in) or an error.  An error should only be
280	 * returned if the requested depth is legal but the driver was
281	 * unable to set it.  If the requested depth is illegal, the
282	 * driver should set and return the closest legal queue depth.
283	 *
284	 * Status: OPTIONAL
285	 */
286	int (* change_queue_depth)(struct scsi_device *, int);
287
288	/*
289	 * This functions lets the driver expose the queue mapping
290	 * to the block layer.
291	 *
292	 * Status: OPTIONAL
293	 */
294	void (* map_queues)(struct Scsi_Host *shost);
295
296	/*
297	 * SCSI interface of blk_poll - poll for IO completions.
298	 * Only applicable if SCSI LLD exposes multiple h/w queues.
299	 *
300	 * Return value: Number of completed entries found.
301	 *
302	 * Status: OPTIONAL
303	 */
304	int (* mq_poll)(struct Scsi_Host *shost, unsigned int queue_num);
305
306	/*
307	 * Check if scatterlists need to be padded for DMA draining.
308	 *
309	 * Status: OPTIONAL
310	 */
311	bool (* dma_need_drain)(struct request *rq);
312
313	/*
314	 * This function determines the BIOS parameters for a given
315	 * harddisk.  These tend to be numbers that are made up by
316	 * the host adapter.  Parameters:
317	 * size, device, list (heads, sectors, cylinders)
318	 *
319	 * Status: OPTIONAL
320	 */
321	int (* bios_param)(struct scsi_device *, struct block_device *,
322			sector_t, int []);
323
324	/*
325	 * This function is called when one or more partitions on the
326	 * device reach beyond the end of the device.
327	 *
328	 * Status: OPTIONAL
329	 */
330	void (*unlock_native_capacity)(struct scsi_device *);
331
332	/*
333	 * Can be used to export driver statistics and other infos to the
334	 * world outside the kernel ie. userspace and it also provides an
335	 * interface to feed the driver with information.
336	 *
337	 * Status: OBSOLETE
338	 */
339	int (*show_info)(struct seq_file *, struct Scsi_Host *);
340	int (*write_info)(struct Scsi_Host *, char *, int);
341
342	/*
343	 * This is an optional routine that allows the transport to become
344	 * involved when a scsi io timer fires. The return value tells the
345	 * timer routine how to finish the io timeout handling.
346	 *
347	 * Status: OPTIONAL
348	 */
349	enum scsi_timeout_action (*eh_timed_out)(struct scsi_cmnd *);
350	/*
351	 * Optional routine that allows the transport to decide if a cmd
352	 * is retryable. Return true if the transport is in a state the
353	 * cmd should be retried on.
354	 */
355	bool (*eh_should_retry_cmd)(struct scsi_cmnd *scmd);
356
357	/* This is an optional routine that allows transport to initiate
358	 * LLD adapter or firmware reset using sysfs attribute.
359	 *
360	 * Return values: 0 on success, -ve value on failure.
361	 *
362	 * Status: OPTIONAL
363	 */
364
365	int (*host_reset)(struct Scsi_Host *shost, int reset_type);
366#define SCSI_ADAPTER_RESET	1
367#define SCSI_FIRMWARE_RESET	2
368
369
370	/*
371	 * Name of proc directory
372	 */
373	const char *proc_name;
374
375	/*
 
 
 
 
 
 
376	 * This determines if we will use a non-interrupt driven
377	 * or an interrupt driven scheme.  It is set to the maximum number
378	 * of simultaneous commands a single hw queue in HBA will accept.
379	 */
380	int can_queue;
381
382	/*
383	 * In many instances, especially where disconnect / reconnect are
384	 * supported, our host also has an ID on the SCSI bus.  If this is
385	 * the case, then it must be reserved.  Please set this_id to -1 if
386	 * your setup is in single initiator mode, and the host lacks an
387	 * ID.
388	 */
389	int this_id;
390
391	/*
392	 * This determines the degree to which the host adapter is capable
393	 * of scatter-gather.
394	 */
395	unsigned short sg_tablesize;
396	unsigned short sg_prot_tablesize;
397
398	/*
399	 * Set this if the host adapter has limitations beside segment count.
400	 */
401	unsigned int max_sectors;
402
403	/*
404	 * Maximum size in bytes of a single segment.
405	 */
406	unsigned int max_segment_size;
407
408	/*
409	 * DMA scatter gather segment boundary limit. A segment crossing this
410	 * boundary will be split in two.
411	 */
412	unsigned long dma_boundary;
413
414	unsigned long virt_boundary_mask;
415
416	/*
417	 * This specifies "machine infinity" for host templates which don't
418	 * limit the transfer size.  Note this limit represents an absolute
419	 * maximum, and may be over the transfer limits allowed for
420	 * individual devices (e.g. 256 for SCSI-1).
421	 */
422#define SCSI_DEFAULT_MAX_SECTORS	1024
423
424	/*
425	 * True if this host adapter can make good use of linked commands.
426	 * This will allow more than one command to be queued to a given
427	 * unit on a given host.  Set this to the maximum number of command
428	 * blocks to be provided for each device.  Set this to 1 for one
429	 * command block per lun, 2 for two, etc.  Do not set this to 0.
430	 * You should make sure that the host adapter will do the right thing
431	 * before you try setting this above 1.
432	 */
433	short cmd_per_lun;
434
 
 
 
 
 
 
435	/* If use block layer to manage tags, this is tag allocation policy */
436	int tag_alloc_policy;
437
438	/*
439	 * Track QUEUE_FULL events and reduce queue depth on demand.
440	 */
441	unsigned track_queue_depth:1;
442
443	/*
444	 * This specifies the mode that a LLD supports.
445	 */
446	unsigned supported_mode:2;
447
448	/*
 
 
 
 
 
449	 * True for emulated SCSI host adapters (e.g. ATAPI).
450	 */
451	unsigned emulated:1;
452
453	/*
454	 * True if the low-level driver performs its own reset-settle delays.
455	 */
456	unsigned skip_settle_delay:1;
457
458	/* True if the controller does not support WRITE SAME */
459	unsigned no_write_same:1;
460
461	/* True if the host uses host-wide tagspace */
462	unsigned host_tagset:1;
463
464	/* The queuecommand callback may block. See also BLK_MQ_F_BLOCKING. */
465	unsigned queuecommand_may_block:1;
466
467	/*
468	 * Countdown for host blocking with no commands outstanding.
469	 */
470	unsigned int max_host_blocked;
471
472	/*
473	 * Default value for the blocking.  If the queue is empty,
474	 * host_blocked counts down in the request_fn until it restarts
475	 * host operations as zero is reached.  
476	 *
477	 * FIXME: This should probably be a value in the template
478	 */
479#define SCSI_DEFAULT_HOST_BLOCKED	7
480
481	/*
482	 * Pointer to the SCSI host sysfs attribute groups, NULL terminated.
483	 */
484	const struct attribute_group **shost_groups;
 
 
 
 
 
485
486	/*
487	 * Pointer to the SCSI device attribute groups for this host,
488	 * NULL terminated.
489	 */
490	const struct attribute_group **sdev_groups;
491
492	/*
493	 * Vendor Identifier associated with the host
494	 *
495	 * Note: When specifying vendor_id, be sure to read the
496	 *   Vendor Type and ID formatting requirements specified in
497	 *   scsi_netlink.h
498	 */
499	u64 vendor_id;
500
 
 
 
 
 
 
501	/* Delay for runtime autosuspend */
502	int rpm_autosuspend_delay;
503};
504
505/*
506 * Temporary #define for host lock push down. Can be removed when all
507 * drivers have been updated to take advantage of unlocked
508 * queuecommand.
509 *
510 */
511#define DEF_SCSI_QCMD(func_name) \
512	int func_name(struct Scsi_Host *shost, struct scsi_cmnd *cmd)	\
513	{								\
514		unsigned long irq_flags;				\
515		int rc;							\
516		spin_lock_irqsave(shost->host_lock, irq_flags);		\
517		rc = func_name##_lck(cmd);				\
518		spin_unlock_irqrestore(shost->host_lock, irq_flags);	\
519		return rc;						\
520	}
521
522
523/*
524 * shost state: If you alter this, you also need to alter scsi_sysfs.c
525 * (for the ascii descriptions) and the state model enforcer:
526 * scsi_host_set_state()
527 */
528enum scsi_host_state {
529	SHOST_CREATED = 1,
530	SHOST_RUNNING,
531	SHOST_CANCEL,
532	SHOST_DEL,
533	SHOST_RECOVERY,
534	SHOST_CANCEL_RECOVERY,
535	SHOST_DEL_RECOVERY,
536};
537
538struct Scsi_Host {
539	/*
540	 * __devices is protected by the host_lock, but you should
541	 * usually use scsi_device_lookup / shost_for_each_device
542	 * to access it and don't care about locking yourself.
543	 * In the rare case of being in irq context you can use
544	 * their __ prefixed variants with the lock held. NEVER
545	 * access this list directly from a driver.
546	 */
547	struct list_head	__devices;
548	struct list_head	__targets;
549	
550	struct list_head	starved_list;
551
552	spinlock_t		default_lock;
553	spinlock_t		*host_lock;
554
555	struct mutex		scan_mutex;/* serialize scanning activity */
556
557	struct list_head	eh_abort_list;
558	struct list_head	eh_cmd_q;
559	struct task_struct    * ehandler;  /* Error recovery thread. */
560	struct completion     * eh_action; /* Wait for specific actions on the
561					      host. */
562	wait_queue_head_t       host_wait;
563	const struct scsi_host_template *hostt;
564	struct scsi_transport_template *transportt;
565
566	struct kref		tagset_refcnt;
567	struct completion	tagset_freed;
568	/* Area to keep a shared tag map */
569	struct blk_mq_tag_set	tag_set;
570
571	atomic_t host_blocked;
572
573	unsigned int host_failed;	   /* commands that failed.
574					      protected by host_lock */
575	unsigned int host_eh_scheduled;    /* EH scheduled without command */
576    
577	unsigned int host_no;  /* Used for IOCTL_GET_IDLUN, /proc/scsi et al. */
578
579	/* next two fields are used to bound the time spent in error handling */
580	int eh_deadline;
581	unsigned long last_reset;
582
583
584	/*
585	 * These three parameters can be used to allow for wide scsi,
586	 * and for host adapters that support multiple busses
587	 * The last two should be set to 1 more than the actual max id
588	 * or lun (e.g. 8 for SCSI parallel systems).
589	 */
590	unsigned int max_channel;
591	unsigned int max_id;
592	u64 max_lun;
593
594	/*
595	 * This is a unique identifier that must be assigned so that we
596	 * have some way of identifying each detected host adapter properly
597	 * and uniquely.  For hosts that do not support more than one card
598	 * in the system at one time, this does not need to be set.  It is
599	 * initialized to 0 in scsi_register.
600	 */
601	unsigned int unique_id;
602
603	/*
604	 * The maximum length of SCSI commands that this host can accept.
605	 * Probably 12 for most host adapters, but could be 16 for others.
606	 * or 260 if the driver supports variable length cdbs.
607	 * For drivers that don't set this field, a value of 12 is
608	 * assumed.
609	 */
610	unsigned short max_cmd_len;
611
612	int this_id;
613	int can_queue;
614	short cmd_per_lun;
615	short unsigned int sg_tablesize;
616	short unsigned int sg_prot_tablesize;
617	unsigned int max_sectors;
618	unsigned int opt_sectors;
619	unsigned int max_segment_size;
620	unsigned long dma_boundary;
621	unsigned long virt_boundary_mask;
622	/*
623	 * In scsi-mq mode, the number of hardware queues supported by the LLD.
624	 *
625	 * Note: it is assumed that each hardware queue has a queue depth of
626	 * can_queue. In other words, the total queue depth per host
627	 * is nr_hw_queues * can_queue. However, for when host_tagset is set,
628	 * the total queue depth is can_queue.
629	 */
630	unsigned nr_hw_queues;
631	unsigned nr_maps;
632	unsigned active_mode:2;
 
633
634	/*
635	 * Host has requested that no further requests come through for the
636	 * time being.
637	 */
638	unsigned host_self_blocked:1;
639    
640	/*
641	 * Host uses correct SCSI ordering not PC ordering. The bit is
642	 * set for the minority of drivers whose authors actually read
643	 * the spec ;).
644	 */
645	unsigned reverse_ordering:1;
646
647	/* Task mgmt function in progress */
648	unsigned tmf_in_progress:1;
649
650	/* Asynchronous scan in progress */
651	unsigned async_scan:1;
652
653	/* Don't resume host in EH */
654	unsigned eh_noresume:1;
655
656	/* The controller does not support WRITE SAME */
657	unsigned no_write_same:1;
658
659	/* True if the host uses host-wide tagspace */
660	unsigned host_tagset:1;
661
662	/* The queuecommand callback may block. See also BLK_MQ_F_BLOCKING. */
663	unsigned queuecommand_may_block:1;
664
665	/* Host responded with short (<36 bytes) INQUIRY result */
666	unsigned short_inquiry:1;
667
668	/* The transport requires the LUN bits NOT to be stored in CDB[1] */
669	unsigned no_scsi2_lun_in_cdb:1;
670
671	/*
672	 * Optional work queue to be utilized by the transport
673	 */
674	char work_q_name[20];
675	struct workqueue_struct *work_q;
676
677	/*
678	 * Task management function work queue
679	 */
680	struct workqueue_struct *tmf_work_q;
681
682	/*
683	 * Value host_blocked counts down from
684	 */
685	unsigned int max_host_blocked;
686
687	/* Protection Information */
688	unsigned int prot_capabilities;
689	unsigned char prot_guard_type;
690
691	/* legacy crap */
692	unsigned long base;
693	unsigned long io_port;
694	unsigned char n_io_port;
695	unsigned char dma_channel;
696	unsigned int  irq;
697	
698
699	enum scsi_host_state shost_state;
700
701	/* ldm bits */
702	struct device		shost_gendev, shost_dev;
703
704	/*
705	 * Points to the transport data (if any) which is allocated
706	 * separately
707	 */
708	void *shost_data;
709
710	/*
711	 * Points to the physical bus device we'd use to do DMA
712	 * Needed just in case we have virtual hosts.
713	 */
714	struct device *dma_dev;
715
716	/*
717	 * We should ensure that this is aligned, both for better performance
718	 * and also because some compilers (m68k) don't automatically force
719	 * alignment to a long boundary.
720	 */
721	unsigned long hostdata[]  /* Used for storage of host specific stuff */
722		__attribute__ ((aligned (sizeof(unsigned long))));
723};
724
725#define		class_to_shost(d)	\
726	container_of(d, struct Scsi_Host, shost_dev)
727
728#define shost_printk(prefix, shost, fmt, a...)	\
729	dev_printk(prefix, &(shost)->shost_gendev, fmt, ##a)
730
731static inline void *shost_priv(struct Scsi_Host *shost)
732{
733	return (void *)shost->hostdata;
734}
735
736int scsi_is_host_device(const struct device *);
737
738static inline struct Scsi_Host *dev_to_shost(struct device *dev)
739{
740	while (!scsi_is_host_device(dev)) {
741		if (!dev->parent)
742			return NULL;
743		dev = dev->parent;
744	}
745	return container_of(dev, struct Scsi_Host, shost_gendev);
746}
747
748static inline int scsi_host_in_recovery(struct Scsi_Host *shost)
749{
750	return shost->shost_state == SHOST_RECOVERY ||
751		shost->shost_state == SHOST_CANCEL_RECOVERY ||
752		shost->shost_state == SHOST_DEL_RECOVERY ||
753		shost->tmf_in_progress;
754}
755
756extern int scsi_queue_work(struct Scsi_Host *, struct work_struct *);
757extern void scsi_flush_work(struct Scsi_Host *);
758
759extern struct Scsi_Host *scsi_host_alloc(const struct scsi_host_template *, int);
760extern int __must_check scsi_add_host_with_dma(struct Scsi_Host *,
761					       struct device *,
762					       struct device *);
763#if defined(CONFIG_SCSI_PROC_FS)
764struct proc_dir_entry *
765scsi_template_proc_dir(const struct scsi_host_template *sht);
766#else
767#define scsi_template_proc_dir(sht) NULL
768#endif
769extern void scsi_scan_host(struct Scsi_Host *);
770extern int scsi_rescan_device(struct scsi_device *sdev);
771extern void scsi_remove_host(struct Scsi_Host *);
772extern struct Scsi_Host *scsi_host_get(struct Scsi_Host *);
773extern int scsi_host_busy(struct Scsi_Host *shost);
774extern void scsi_host_put(struct Scsi_Host *t);
775extern struct Scsi_Host *scsi_host_lookup(unsigned int hostnum);
776extern const char *scsi_host_state_name(enum scsi_host_state);
777extern void scsi_host_complete_all_commands(struct Scsi_Host *shost,
778					    enum scsi_host_status status);
779
780static inline int __must_check scsi_add_host(struct Scsi_Host *host,
781					     struct device *dev)
782{
783	return scsi_add_host_with_dma(host, dev, dev);
784}
785
786static inline struct device *scsi_get_device(struct Scsi_Host *shost)
787{
788        return shost->shost_gendev.parent;
789}
790
791/**
792 * scsi_host_scan_allowed - Is scanning of this host allowed
793 * @shost:	Pointer to Scsi_Host.
794 **/
795static inline int scsi_host_scan_allowed(struct Scsi_Host *shost)
796{
797	return shost->shost_state == SHOST_RUNNING ||
798	       shost->shost_state == SHOST_RECOVERY;
799}
800
801extern void scsi_unblock_requests(struct Scsi_Host *);
802extern void scsi_block_requests(struct Scsi_Host *);
803extern int scsi_host_block(struct Scsi_Host *shost);
804extern int scsi_host_unblock(struct Scsi_Host *shost, int new_state);
805
806void scsi_host_busy_iter(struct Scsi_Host *,
807			 bool (*fn)(struct scsi_cmnd *, void *), void *priv);
808
809struct class_container;
 
 
 
 
 
 
 
 
 
 
810
811/*
812 * DIF defines the exchange of protection information between
813 * initiator and SBC block device.
814 *
815 * DIX defines the exchange of protection information between OS and
816 * initiator.
817 */
818enum scsi_host_prot_capabilities {
819	SHOST_DIF_TYPE1_PROTECTION = 1 << 0, /* T10 DIF Type 1 */
820	SHOST_DIF_TYPE2_PROTECTION = 1 << 1, /* T10 DIF Type 2 */
821	SHOST_DIF_TYPE3_PROTECTION = 1 << 2, /* T10 DIF Type 3 */
822
823	SHOST_DIX_TYPE0_PROTECTION = 1 << 3, /* DIX between OS and HBA only */
824	SHOST_DIX_TYPE1_PROTECTION = 1 << 4, /* DIX with DIF Type 1 */
825	SHOST_DIX_TYPE2_PROTECTION = 1 << 5, /* DIX with DIF Type 2 */
826	SHOST_DIX_TYPE3_PROTECTION = 1 << 6, /* DIX with DIF Type 3 */
827};
828
829/*
830 * SCSI hosts which support the Data Integrity Extensions must
831 * indicate their capabilities by setting the prot_capabilities using
832 * this call.
833 */
834static inline void scsi_host_set_prot(struct Scsi_Host *shost, unsigned int mask)
835{
836	shost->prot_capabilities = mask;
837}
838
839static inline unsigned int scsi_host_get_prot(struct Scsi_Host *shost)
840{
841	return shost->prot_capabilities;
842}
843
844static inline int scsi_host_prot_dma(struct Scsi_Host *shost)
845{
846	return shost->prot_capabilities >= SHOST_DIX_TYPE0_PROTECTION;
847}
848
849static inline unsigned int scsi_host_dif_capable(struct Scsi_Host *shost, unsigned int target_type)
850{
851	static unsigned char cap[] = { 0,
852				       SHOST_DIF_TYPE1_PROTECTION,
853				       SHOST_DIF_TYPE2_PROTECTION,
854				       SHOST_DIF_TYPE3_PROTECTION };
855
856	if (target_type >= ARRAY_SIZE(cap))
857		return 0;
858
859	return shost->prot_capabilities & cap[target_type] ? target_type : 0;
860}
861
862static inline unsigned int scsi_host_dix_capable(struct Scsi_Host *shost, unsigned int target_type)
863{
864#if defined(CONFIG_BLK_DEV_INTEGRITY)
865	static unsigned char cap[] = { SHOST_DIX_TYPE0_PROTECTION,
866				       SHOST_DIX_TYPE1_PROTECTION,
867				       SHOST_DIX_TYPE2_PROTECTION,
868				       SHOST_DIX_TYPE3_PROTECTION };
869
870	if (target_type >= ARRAY_SIZE(cap))
871		return 0;
872
873	return shost->prot_capabilities & cap[target_type];
874#endif
875	return 0;
876}
877
878/*
879 * All DIX-capable initiators must support the T10-mandated CRC
880 * checksum.  Controllers can optionally implement the IP checksum
881 * scheme which has much lower impact on system performance.  Note
882 * that the main rationale for the checksum is to match integrity
883 * metadata with data.  Detecting bit errors are a job for ECC memory
884 * and buses.
885 */
886
887enum scsi_host_guard_type {
888	SHOST_DIX_GUARD_CRC = 1 << 0,
889	SHOST_DIX_GUARD_IP  = 1 << 1,
890};
891
892static inline void scsi_host_set_guard(struct Scsi_Host *shost, unsigned char type)
893{
894	shost->prot_guard_type = type;
895}
896
897static inline unsigned char scsi_host_get_guard(struct Scsi_Host *shost)
898{
899	return shost->prot_guard_type;
900}
901
902extern int scsi_host_set_state(struct Scsi_Host *, enum scsi_host_state);
903
904#endif /* _SCSI_SCSI_HOST_H */