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