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