Branch data 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 <linux/seq_file.h>
10 : : #include <scsi/scsi.h>
11 : :
12 : : struct request_queue;
13 : : struct block_device;
14 : : struct completion;
15 : : struct module;
16 : : struct scsi_cmnd;
17 : : struct scsi_device;
18 : : struct scsi_target;
19 : : struct Scsi_Host;
20 : : struct scsi_host_cmd_pool;
21 : : struct scsi_transport_template;
22 : : struct blk_queue_tags;
23 : :
24 : :
25 : : /*
26 : : * The various choices mean:
27 : : * NONE: Self evident. Host adapter is not capable of scatter-gather.
28 : : * ALL: Means that the host adapter module can do scatter-gather,
29 : : * and that there is no limit to the size of the table to which
30 : : * we scatter/gather data. The value we set here is the maximum
31 : : * single element sglist. To use chained sglists, the adapter
32 : : * has to set a value beyond ALL (and correctly use the chain
33 : : * handling API.
34 : : * Anything else: Indicates the maximum number of chains that can be
35 : : * used in one scatter-gather request.
36 : : */
37 : : #define SG_NONE 0
38 : : #define SG_ALL SCSI_MAX_SG_SEGMENTS
39 : :
40 : : #define MODE_UNKNOWN 0x00
41 : : #define MODE_INITIATOR 0x01
42 : : #define MODE_TARGET 0x02
43 : :
44 : : #define DISABLE_CLUSTERING 0
45 : : #define ENABLE_CLUSTERING 1
46 : :
47 : : enum {
48 : : SCSI_QDEPTH_DEFAULT, /* default requested change, e.g. from sysfs */
49 : : SCSI_QDEPTH_QFULL, /* scsi-ml requested due to queue full */
50 : : SCSI_QDEPTH_RAMP_UP, /* scsi-ml requested due to threshold event */
51 : : };
52 : :
53 : : struct scsi_host_template {
54 : : struct module *module;
55 : : const char *name;
56 : :
57 : : /*
58 : : * Used to initialize old-style drivers. For new-style drivers
59 : : * just perform all work in your module initialization function.
60 : : *
61 : : * Status: OBSOLETE
62 : : */
63 : : int (* detect)(struct scsi_host_template *);
64 : :
65 : : /*
66 : : * Used as unload callback for hosts with old-style drivers.
67 : : *
68 : : * Status: OBSOLETE
69 : : */
70 : : int (* release)(struct Scsi_Host *);
71 : :
72 : : /*
73 : : * The info function will return whatever useful information the
74 : : * developer sees fit. If not provided, then the name field will
75 : : * be used instead.
76 : : *
77 : : * Status: OPTIONAL
78 : : */
79 : : const char *(* info)(struct Scsi_Host *);
80 : :
81 : : /*
82 : : * Ioctl interface
83 : : *
84 : : * Status: OPTIONAL
85 : : */
86 : : int (* ioctl)(struct scsi_device *dev, int cmd, void __user *arg);
87 : :
88 : :
89 : : #ifdef CONFIG_COMPAT
90 : : /*
91 : : * Compat handler. Handle 32bit ABI.
92 : : * When unknown ioctl is passed return -ENOIOCTLCMD.
93 : : *
94 : : * Status: OPTIONAL
95 : : */
96 : : int (* compat_ioctl)(struct scsi_device *dev, int cmd, void __user *arg);
97 : : #endif
98 : :
99 : : /*
100 : : * The queuecommand function is used to queue up a scsi
101 : : * command block to the LLDD. When the driver finished
102 : : * processing the command the done callback is invoked.
103 : : *
104 : : * If queuecommand returns 0, then the HBA has accepted the
105 : : * command. The done() function must be called on the command
106 : : * when the driver has finished with it. (you may call done on the
107 : : * command before queuecommand returns, but in this case you
108 : : * *must* return 0 from queuecommand).
109 : : *
110 : : * Queuecommand may also reject the command, in which case it may
111 : : * not touch the command and must not call done() for it.
112 : : *
113 : : * There are two possible rejection returns:
114 : : *
115 : : * SCSI_MLQUEUE_DEVICE_BUSY: Block this device temporarily, but
116 : : * allow commands to other devices serviced by this host.
117 : : *
118 : : * SCSI_MLQUEUE_HOST_BUSY: Block all devices served by this
119 : : * host temporarily.
120 : : *
121 : : * For compatibility, any other non-zero return is treated the
122 : : * same as SCSI_MLQUEUE_HOST_BUSY.
123 : : *
124 : : * NOTE: "temporarily" means either until the next command for#
125 : : * this device/host completes, or a period of time determined by
126 : : * I/O pressure in the system if there are no other outstanding
127 : : * commands.
128 : : *
129 : : * STATUS: REQUIRED
130 : : */
131 : : int (* queuecommand)(struct Scsi_Host *, 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 : : * This function is called when one or more partitions on the
331 : : * device reach beyond the end of the device.
332 : : *
333 : : * Status: OPTIONAL
334 : : */
335 : : void (*unlock_native_capacity)(struct scsi_device *);
336 : :
337 : : /*
338 : : * Can be used to export driver statistics and other infos to the
339 : : * world outside the kernel ie. userspace and it also provides an
340 : : * interface to feed the driver with information.
341 : : *
342 : : * Status: OBSOLETE
343 : : */
344 : : int (*show_info)(struct seq_file *, struct Scsi_Host *);
345 : : int (*write_info)(struct Scsi_Host *, char *, int);
346 : :
347 : : /*
348 : : * This is an optional routine that allows the transport to become
349 : : * involved when a scsi io timer fires. The return value tells the
350 : : * timer routine how to finish the io timeout handling:
351 : : * EH_HANDLED: I fixed the error, please complete the command
352 : : * EH_RESET_TIMER: I need more time, reset the timer and
353 : : * begin counting again
354 : : * EH_NOT_HANDLED Begin normal error recovery
355 : : *
356 : : * Status: OPTIONAL
357 : : */
358 : : enum blk_eh_timer_return (*eh_timed_out)(struct scsi_cmnd *);
359 : :
360 : : /* This is an optional routine that allows transport to initiate
361 : : * LLD adapter or firmware reset using sysfs attribute.
362 : : *
363 : : * Return values: 0 on success, -ve value on failure.
364 : : *
365 : : * Status: OPTIONAL
366 : : */
367 : :
368 : : int (*host_reset)(struct Scsi_Host *shost, int reset_type);
369 : : #define SCSI_ADAPTER_RESET 1
370 : : #define SCSI_FIRMWARE_RESET 2
371 : :
372 : :
373 : : /*
374 : : * Name of proc directory
375 : : */
376 : : const char *proc_name;
377 : :
378 : : /*
379 : : * Used to store the procfs directory if a driver implements the
380 : : * show_info method.
381 : : */
382 : : struct proc_dir_entry *proc_dir;
383 : :
384 : : /*
385 : : * This determines if we will use a non-interrupt driven
386 : : * or an interrupt driven scheme. It is set to the maximum number
387 : : * of simultaneous commands a given host adapter will accept.
388 : : */
389 : : int can_queue;
390 : :
391 : : /*
392 : : * In many instances, especially where disconnect / reconnect are
393 : : * supported, our host also has an ID on the SCSI bus. If this is
394 : : * the case, then it must be reserved. Please set this_id to -1 if
395 : : * your setup is in single initiator mode, and the host lacks an
396 : : * ID.
397 : : */
398 : : int this_id;
399 : :
400 : : /*
401 : : * This determines the degree to which the host adapter is capable
402 : : * of scatter-gather.
403 : : */
404 : : unsigned short sg_tablesize;
405 : : unsigned short sg_prot_tablesize;
406 : :
407 : : /*
408 : : * Set this if the host adapter has limitations beside segment count.
409 : : */
410 : : unsigned short max_sectors;
411 : :
412 : : /*
413 : : * DMA scatter gather segment boundary limit. A segment crossing this
414 : : * boundary will be split in two.
415 : : */
416 : : unsigned long dma_boundary;
417 : :
418 : : /*
419 : : * This specifies "machine infinity" for host templates which don't
420 : : * limit the transfer size. Note this limit represents an absolute
421 : : * maximum, and may be over the transfer limits allowed for
422 : : * individual devices (e.g. 256 for SCSI-1).
423 : : */
424 : : #define SCSI_DEFAULT_MAX_SECTORS 1024
425 : :
426 : : /*
427 : : * True if this host adapter can make good use of linked commands.
428 : : * This will allow more than one command to be queued to a given
429 : : * unit on a given host. Set this to the maximum number of command
430 : : * blocks to be provided for each device. Set this to 1 for one
431 : : * command block per lun, 2 for two, etc. Do not set this to 0.
432 : : * You should make sure that the host adapter will do the right thing
433 : : * before you try setting this above 1.
434 : : */
435 : : short cmd_per_lun;
436 : :
437 : : /*
438 : : * present contains counter indicating how many boards of this
439 : : * type were found when we did the scan.
440 : : */
441 : : unsigned char present;
442 : :
443 : : /*
444 : : * This specifies the mode that a LLD supports.
445 : : */
446 : : unsigned supported_mode:2;
447 : :
448 : : /*
449 : : * True if this host adapter uses unchecked DMA onto an ISA bus.
450 : : */
451 : : unsigned unchecked_isa_dma:1;
452 : :
453 : : /*
454 : : * True if this host adapter can make good use of clustering.
455 : : * I originally thought that if the tablesize was large that it
456 : : * was a waste of CPU cycles to prepare a cluster list, but
457 : : * it works out that the Buslogic is faster if you use a smaller
458 : : * number of segments (i.e. use clustering). I guess it is
459 : : * inefficient.
460 : : */
461 : : unsigned use_clustering:1;
462 : :
463 : : /*
464 : : * True for emulated SCSI host adapters (e.g. ATAPI).
465 : : */
466 : : unsigned emulated:1;
467 : :
468 : : /*
469 : : * True if the low-level driver performs its own reset-settle delays.
470 : : */
471 : : unsigned skip_settle_delay:1;
472 : :
473 : : /*
474 : : * True if we are using ordered write support.
475 : : */
476 : : unsigned ordered_tag:1;
477 : :
478 : : /* True if the controller does not support WRITE SAME */
479 : : unsigned no_write_same:1;
480 : :
481 : : /*
482 : : * Countdown for host blocking with no commands outstanding.
483 : : */
484 : : unsigned int max_host_blocked;
485 : :
486 : : /*
487 : : * Default value for the blocking. If the queue is empty,
488 : : * host_blocked counts down in the request_fn until it restarts
489 : : * host operations as zero is reached.
490 : : *
491 : : * FIXME: This should probably be a value in the template
492 : : */
493 : : #define SCSI_DEFAULT_HOST_BLOCKED 7
494 : :
495 : : /*
496 : : * Pointer to the sysfs class properties for this host, NULL terminated.
497 : : */
498 : : struct device_attribute **shost_attrs;
499 : :
500 : : /*
501 : : * Pointer to the SCSI device properties for this host, NULL terminated.
502 : : */
503 : : struct device_attribute **sdev_attrs;
504 : :
505 : : /*
506 : : * List of hosts per template.
507 : : *
508 : : * This is only for use by scsi_module.c for legacy templates.
509 : : * For these access to it is synchronized implicitly by
510 : : * module_init/module_exit.
511 : : */
512 : : struct list_head legacy_hosts;
513 : :
514 : : /*
515 : : * Vendor Identifier associated with the host
516 : : *
517 : : * Note: When specifying vendor_id, be sure to read the
518 : : * Vendor Type and ID formatting requirements specified in
519 : : * scsi_netlink.h
520 : : */
521 : : u64 vendor_id;
522 : : };
523 : :
524 : : /*
525 : : * Temporary #define for host lock push down. Can be removed when all
526 : : * drivers have been updated to take advantage of unlocked
527 : : * queuecommand.
528 : : *
529 : : */
530 : : #define DEF_SCSI_QCMD(func_name) \
531 : : int func_name(struct Scsi_Host *shost, struct scsi_cmnd *cmd) \
532 : : { \
533 : : unsigned long irq_flags; \
534 : : int rc; \
535 : : spin_lock_irqsave(shost->host_lock, irq_flags); \
536 : : scsi_cmd_get_serial(shost, cmd); \
537 : : rc = func_name##_lck (cmd, cmd->scsi_done); \
538 : : spin_unlock_irqrestore(shost->host_lock, irq_flags); \
539 : : return rc; \
540 : : }
541 : :
542 : :
543 : : /*
544 : : * shost state: If you alter this, you also need to alter scsi_sysfs.c
545 : : * (for the ascii descriptions) and the state model enforcer:
546 : : * scsi_host_set_state()
547 : : */
548 : : enum scsi_host_state {
549 : : SHOST_CREATED = 1,
550 : : SHOST_RUNNING,
551 : : SHOST_CANCEL,
552 : : SHOST_DEL,
553 : : SHOST_RECOVERY,
554 : : SHOST_CANCEL_RECOVERY,
555 : : SHOST_DEL_RECOVERY,
556 : : };
557 : :
558 : : struct Scsi_Host {
559 : : /*
560 : : * __devices is protected by the host_lock, but you should
561 : : * usually use scsi_device_lookup / shost_for_each_device
562 : : * to access it and don't care about locking yourself.
563 : : * In the rare case of beeing in irq context you can use
564 : : * their __ prefixed variants with the lock held. NEVER
565 : : * access this list directly from a driver.
566 : : */
567 : : struct list_head __devices;
568 : : struct list_head __targets;
569 : :
570 : : struct scsi_host_cmd_pool *cmd_pool;
571 : : spinlock_t free_list_lock;
572 : : struct list_head free_list; /* backup store of cmd structs */
573 : : struct list_head starved_list;
574 : :
575 : : spinlock_t default_lock;
576 : : spinlock_t *host_lock;
577 : :
578 : : struct mutex scan_mutex;/* serialize scanning activity */
579 : :
580 : : struct list_head eh_cmd_q;
581 : : struct task_struct * ehandler; /* Error recovery thread. */
582 : : struct completion * eh_action; /* Wait for specific actions on the
583 : : host. */
584 : : wait_queue_head_t host_wait;
585 : : struct scsi_host_template *hostt;
586 : : struct scsi_transport_template *transportt;
587 : :
588 : : /*
589 : : * Area to keep a shared tag map (if needed, will be
590 : : * NULL if not).
591 : : */
592 : : struct blk_queue_tag *bqt;
593 : :
594 : : /*
595 : : * The following two fields are protected with host_lock;
596 : : * however, eh routines can safely access during eh processing
597 : : * without acquiring the lock.
598 : : */
599 : : unsigned int host_busy; /* commands actually active on low-level */
600 : : unsigned int host_failed; /* commands that failed. */
601 : : unsigned int host_eh_scheduled; /* EH scheduled without command */
602 : :
603 : : unsigned int host_no; /* Used for IOCTL_GET_IDLUN, /proc/scsi et al. */
604 : :
605 : : /* next two fields are used to bound the time spent in error handling */
606 : : int eh_deadline;
607 : : unsigned long last_reset;
608 : :
609 : :
610 : : /*
611 : : * These three parameters can be used to allow for wide scsi,
612 : : * and for host adapters that support multiple busses
613 : : * The first two should be set to 1 more than the actual max id
614 : : * or lun (i.e. 8 for normal systems).
615 : : */
616 : : unsigned int max_id;
617 : : unsigned int max_lun;
618 : : unsigned int max_channel;
619 : :
620 : : /*
621 : : * This is a unique identifier that must be assigned so that we
622 : : * have some way of identifying each detected host adapter properly
623 : : * and uniquely. For hosts that do not support more than one card
624 : : * in the system at one time, this does not need to be set. It is
625 : : * initialized to 0 in scsi_register.
626 : : */
627 : : unsigned int unique_id;
628 : :
629 : : /*
630 : : * The maximum length of SCSI commands that this host can accept.
631 : : * Probably 12 for most host adapters, but could be 16 for others.
632 : : * or 260 if the driver supports variable length cdbs.
633 : : * For drivers that don't set this field, a value of 12 is
634 : : * assumed.
635 : : */
636 : : unsigned short max_cmd_len;
637 : :
638 : : int this_id;
639 : : int can_queue;
640 : : short cmd_per_lun;
641 : : short unsigned int sg_tablesize;
642 : : short unsigned int sg_prot_tablesize;
643 : : short unsigned int max_sectors;
644 : : unsigned long dma_boundary;
645 : : /*
646 : : * Used to assign serial numbers to the cmds.
647 : : * Protected by the host lock.
648 : : */
649 : : unsigned long cmd_serial_number;
650 : :
651 : : unsigned active_mode:2;
652 : : unsigned unchecked_isa_dma:1;
653 : : unsigned use_clustering:1;
654 : : unsigned use_blk_tcq:1;
655 : :
656 : : /*
657 : : * Host has requested that no further requests come through for the
658 : : * time being.
659 : : */
660 : : unsigned host_self_blocked:1;
661 : :
662 : : /*
663 : : * Host uses correct SCSI ordering not PC ordering. The bit is
664 : : * set for the minority of drivers whose authors actually read
665 : : * the spec ;).
666 : : */
667 : : unsigned reverse_ordering:1;
668 : :
669 : : /*
670 : : * Ordered write support
671 : : */
672 : : unsigned ordered_tag:1;
673 : :
674 : : /* Task mgmt function in progress */
675 : : unsigned tmf_in_progress:1;
676 : :
677 : : /* Asynchronous scan in progress */
678 : : unsigned async_scan:1;
679 : :
680 : : /* Don't resume host in EH */
681 : : unsigned eh_noresume:1;
682 : :
683 : : /* The controller does not support WRITE SAME */
684 : : unsigned no_write_same:1;
685 : :
686 : : /*
687 : : * Optional work queue to be utilized by the transport
688 : : */
689 : : char work_q_name[20];
690 : : struct workqueue_struct *work_q;
691 : :
692 : : /*
693 : : * Host has rejected a command because it was busy.
694 : : */
695 : : unsigned int host_blocked;
696 : :
697 : : /*
698 : : * Value host_blocked counts down from
699 : : */
700 : : unsigned int max_host_blocked;
701 : :
702 : : /* Protection Information */
703 : : unsigned int prot_capabilities;
704 : : unsigned char prot_guard_type;
705 : :
706 : : /*
707 : : * q used for scsi_tgt msgs, async events or any other requests that
708 : : * need to be processed in userspace
709 : : */
710 : : struct request_queue *uspace_req_q;
711 : :
712 : : /* legacy crap */
713 : : unsigned long base;
714 : : unsigned long io_port;
715 : : unsigned char n_io_port;
716 : : unsigned char dma_channel;
717 : : unsigned int irq;
718 : :
719 : :
720 : : enum scsi_host_state shost_state;
721 : :
722 : : /* ldm bits */
723 : : struct device shost_gendev, shost_dev;
724 : :
725 : : /*
726 : : * List of hosts per template.
727 : : *
728 : : * This is only for use by scsi_module.c for legacy templates.
729 : : * For these access to it is synchronized implicitly by
730 : : * module_init/module_exit.
731 : : */
732 : : struct list_head sht_legacy_list;
733 : :
734 : : /*
735 : : * Points to the transport data (if any) which is allocated
736 : : * separately
737 : : */
738 : : void *shost_data;
739 : :
740 : : /*
741 : : * Points to the physical bus device we'd use to do DMA
742 : : * Needed just in case we have virtual hosts.
743 : : */
744 : : struct device *dma_dev;
745 : :
746 : : /*
747 : : * We should ensure that this is aligned, both for better performance
748 : : * and also because some compilers (m68k) don't automatically force
749 : : * alignment to a long boundary.
750 : : */
751 : : unsigned long hostdata[0] /* Used for storage of host specific stuff */
752 : : __attribute__ ((aligned (sizeof(unsigned long))));
753 : : };
754 : :
755 : : #define class_to_shost(d) \
756 : : container_of(d, struct Scsi_Host, shost_dev)
757 : :
758 : : #define shost_printk(prefix, shost, fmt, a...) \
759 : : dev_printk(prefix, &(shost)->shost_gendev, fmt, ##a)
760 : :
761 : : static inline void *shost_priv(struct Scsi_Host *shost)
762 : : {
763 : : return (void *)shost->hostdata;
764 : : }
765 : :
766 : : int scsi_is_host_device(const struct device *);
767 : :
768 : : static inline struct Scsi_Host *dev_to_shost(struct device *dev)
769 : : {
770 [ # # ][ # # ]: 0 : while (!scsi_is_host_device(dev)) {
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
771 [ # # ][ # # ]: 0 : if (!dev->parent)
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
772 : : return NULL;
773 : : dev = dev->parent;
774 : : }
775 : 0 : return container_of(dev, struct Scsi_Host, shost_gendev);
776 : : }
777 : :
778 : : static inline int scsi_host_in_recovery(struct Scsi_Host *shost)
779 : : {
780 : 906256 : return shost->shost_state == SHOST_RECOVERY ||
781 : 906256 : shost->shost_state == SHOST_CANCEL_RECOVERY ||
782 [ + - ][ + - ]: 906256 : shost->shost_state == SHOST_DEL_RECOVERY ||
[ # # ]
[ # # # # ]
[ # # ][ + - ]
[ + - ][ # # ]
[ # # ]
783 : 906256 : shost->tmf_in_progress;
784 : : }
785 : :
786 : : extern int scsi_queue_work(struct Scsi_Host *, struct work_struct *);
787 : : extern void scsi_flush_work(struct Scsi_Host *);
788 : :
789 : : extern struct Scsi_Host *scsi_host_alloc(struct scsi_host_template *, int);
790 : : extern int __must_check scsi_add_host_with_dma(struct Scsi_Host *,
791 : : struct device *,
792 : : struct device *);
793 : : extern void scsi_scan_host(struct Scsi_Host *);
794 : : extern void scsi_rescan_device(struct device *);
795 : : extern void scsi_remove_host(struct Scsi_Host *);
796 : : extern struct Scsi_Host *scsi_host_get(struct Scsi_Host *);
797 : : extern void scsi_host_put(struct Scsi_Host *t);
798 : : extern struct Scsi_Host *scsi_host_lookup(unsigned short);
799 : : extern const char *scsi_host_state_name(enum scsi_host_state);
800 : : extern void scsi_cmd_get_serial(struct Scsi_Host *, struct scsi_cmnd *);
801 : :
802 : : extern u64 scsi_calculate_bounce_limit(struct Scsi_Host *);
803 : :
804 : : static inline int __must_check scsi_add_host(struct Scsi_Host *host,
805 : : struct device *dev)
806 : : {
807 : 0 : return scsi_add_host_with_dma(host, dev, dev);
808 : : }
809 : :
810 : : static inline struct device *scsi_get_device(struct Scsi_Host *shost)
811 : : {
812 : : return shost->shost_gendev.parent;
813 : : }
814 : :
815 : : /**
816 : : * scsi_host_scan_allowed - Is scanning of this host allowed
817 : : * @shost: Pointer to Scsi_Host.
818 : : **/
819 : : static inline int scsi_host_scan_allowed(struct Scsi_Host *shost)
820 : : {
821 : 0 : return shost->shost_state == SHOST_RUNNING ||
822 : : shost->shost_state == SHOST_RECOVERY;
823 : : }
824 : :
825 : : extern void scsi_unblock_requests(struct Scsi_Host *);
826 : : extern void scsi_block_requests(struct Scsi_Host *);
827 : :
828 : : struct class_container;
829 : :
830 : : extern struct request_queue *__scsi_alloc_queue(struct Scsi_Host *shost,
831 : : void (*) (struct request_queue *));
832 : : /*
833 : : * These two functions are used to allocate and free a pseudo device
834 : : * which will connect to the host adapter itself rather than any
835 : : * physical device. You must deallocate when you are done with the
836 : : * thing. This physical pseudo-device isn't real and won't be available
837 : : * from any high-level drivers.
838 : : */
839 : : extern void scsi_free_host_dev(struct scsi_device *);
840 : : extern struct scsi_device *scsi_get_host_dev(struct Scsi_Host *);
841 : :
842 : : /*
843 : : * DIF defines the exchange of protection information between
844 : : * initiator and SBC block device.
845 : : *
846 : : * DIX defines the exchange of protection information between OS and
847 : : * initiator.
848 : : */
849 : : enum scsi_host_prot_capabilities {
850 : : SHOST_DIF_TYPE1_PROTECTION = 1 << 0, /* T10 DIF Type 1 */
851 : : SHOST_DIF_TYPE2_PROTECTION = 1 << 1, /* T10 DIF Type 2 */
852 : : SHOST_DIF_TYPE3_PROTECTION = 1 << 2, /* T10 DIF Type 3 */
853 : :
854 : : SHOST_DIX_TYPE0_PROTECTION = 1 << 3, /* DIX between OS and HBA only */
855 : : SHOST_DIX_TYPE1_PROTECTION = 1 << 4, /* DIX with DIF Type 1 */
856 : : SHOST_DIX_TYPE2_PROTECTION = 1 << 5, /* DIX with DIF Type 2 */
857 : : SHOST_DIX_TYPE3_PROTECTION = 1 << 6, /* DIX with DIF Type 3 */
858 : : };
859 : :
860 : : /*
861 : : * SCSI hosts which support the Data Integrity Extensions must
862 : : * indicate their capabilities by setting the prot_capabilities using
863 : : * this call.
864 : : */
865 : : static inline void scsi_host_set_prot(struct Scsi_Host *shost, unsigned int mask)
866 : : {
867 : : shost->prot_capabilities = mask;
868 : : }
869 : :
870 : : static inline unsigned int scsi_host_get_prot(struct Scsi_Host *shost)
871 : : {
872 : : return shost->prot_capabilities;
873 : : }
874 : :
875 : : static inline int scsi_host_prot_dma(struct Scsi_Host *shost)
876 : : {
877 : : return shost->prot_capabilities >= SHOST_DIX_TYPE0_PROTECTION;
878 : : }
879 : :
880 : : static inline unsigned int scsi_host_dif_capable(struct Scsi_Host *shost, unsigned int target_type)
881 : : {
882 : : static unsigned char cap[] = { 0,
883 : : SHOST_DIF_TYPE1_PROTECTION,
884 : : SHOST_DIF_TYPE2_PROTECTION,
885 : : SHOST_DIF_TYPE3_PROTECTION };
886 : :
887 [ # # ][ + - ]: 828620 : if (target_type >= ARRAY_SIZE(cap))
[ # # ]
888 : : return 0;
889 : :
890 [ # # ][ - + ]: 394901 : return shost->prot_capabilities & cap[target_type] ? target_type : 0;
[ # # ]
891 : : }
892 : :
893 : : static inline unsigned int scsi_host_dix_capable(struct Scsi_Host *shost, unsigned int target_type)
894 : : {
895 : : #if defined(CONFIG_BLK_DEV_INTEGRITY)
896 : : static unsigned char cap[] = { SHOST_DIX_TYPE0_PROTECTION,
897 : : SHOST_DIX_TYPE1_PROTECTION,
898 : : SHOST_DIX_TYPE2_PROTECTION,
899 : : SHOST_DIX_TYPE3_PROTECTION };
900 : :
901 : : if (target_type >= ARRAY_SIZE(cap))
902 : : return 0;
903 : :
904 : : return shost->prot_capabilities & cap[target_type];
905 : : #endif
906 : : return 0;
907 : : }
908 : :
909 : : /*
910 : : * All DIX-capable initiators must support the T10-mandated CRC
911 : : * checksum. Controllers can optionally implement the IP checksum
912 : : * scheme which has much lower impact on system performance. Note
913 : : * that the main rationale for the checksum is to match integrity
914 : : * metadata with data. Detecting bit errors are a job for ECC memory
915 : : * and buses.
916 : : */
917 : :
918 : : enum scsi_host_guard_type {
919 : : SHOST_DIX_GUARD_CRC = 1 << 0,
920 : : SHOST_DIX_GUARD_IP = 1 << 1,
921 : : };
922 : :
923 : : static inline void scsi_host_set_guard(struct Scsi_Host *shost, unsigned char type)
924 : : {
925 : : shost->prot_guard_type = type;
926 : : }
927 : :
928 : : static inline unsigned char scsi_host_get_guard(struct Scsi_Host *shost)
929 : : {
930 : : return shost->prot_guard_type;
931 : : }
932 : :
933 : : /* legacy interfaces */
934 : : extern struct Scsi_Host *scsi_register(struct scsi_host_template *, int);
935 : : extern void scsi_unregister(struct Scsi_Host *);
936 : : extern int scsi_host_set_state(struct Scsi_Host *, enum scsi_host_state);
937 : :
938 : : #endif /* _SCSI_SCSI_HOST_H */
|
