scsi_host.h 23 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748
  1. #ifndef _SCSI_SCSI_HOST_H
  2. #define _SCSI_SCSI_HOST_H
  3. #include <linux/device.h>
  4. #include <linux/list.h>
  5. #include <linux/types.h>
  6. #include <linux/workqueue.h>
  7. #include <linux/mutex.h>
  8. struct request_queue;
  9. struct block_device;
  10. struct completion;
  11. struct module;
  12. struct scsi_cmnd;
  13. struct scsi_device;
  14. struct scsi_target;
  15. struct Scsi_Host;
  16. struct scsi_host_cmd_pool;
  17. struct scsi_transport_template;
  18. struct blk_queue_tags;
  19. /*
  20. * The various choices mean:
  21. * NONE: Self evident. Host adapter is not capable of scatter-gather.
  22. * ALL: Means that the host adapter module can do scatter-gather,
  23. * and that there is no limit to the size of the table to which
  24. * we scatter/gather data.
  25. * Anything else: Indicates the maximum number of chains that can be
  26. * used in one scatter-gather request.
  27. */
  28. #define SG_NONE 0
  29. #define SG_ALL 0xff
  30. #define DISABLE_CLUSTERING 0
  31. #define ENABLE_CLUSTERING 1
  32. enum scsi_eh_timer_return {
  33. EH_NOT_HANDLED,
  34. EH_HANDLED,
  35. EH_RESET_TIMER,
  36. };
  37. struct scsi_host_template {
  38. struct module *module;
  39. const char *name;
  40. /*
  41. * Used to initialize old-style drivers. For new-style drivers
  42. * just perform all work in your module initialization function.
  43. *
  44. * Status: OBSOLETE
  45. */
  46. int (* detect)(struct scsi_host_template *);
  47. /*
  48. * Used as unload callback for hosts with old-style drivers.
  49. *
  50. * Status: OBSOLETE
  51. */
  52. int (* release)(struct Scsi_Host *);
  53. /*
  54. * The info function will return whatever useful information the
  55. * developer sees fit. If not provided, then the name field will
  56. * be used instead.
  57. *
  58. * Status: OPTIONAL
  59. */
  60. const char *(* info)(struct Scsi_Host *);
  61. /*
  62. * Ioctl interface
  63. *
  64. * Status: OPTIONAL
  65. */
  66. int (* ioctl)(struct scsi_device *dev, int cmd, void __user *arg);
  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, int cmd, void __user *arg);
  75. #endif
  76. /*
  77. * The queuecommand function is used to queue up a scsi
  78. * command block to the LLDD. When the driver finished
  79. * processing the command the done callback is invoked.
  80. *
  81. * If queuecommand returns 0, then the HBA has accepted the
  82. * command. The done() function must be called on the command
  83. * when the driver has finished with it. (you may call done on the
  84. * command before queuecommand returns, but in this case you
  85. * *must* return 0 from queuecommand).
  86. *
  87. * Queuecommand may also reject the command, in which case it may
  88. * not touch the command and must not call done() for it.
  89. *
  90. * There are two possible rejection returns:
  91. *
  92. * SCSI_MLQUEUE_DEVICE_BUSY: Block this device temporarily, but
  93. * allow commands to other devices serviced by this host.
  94. *
  95. * SCSI_MLQUEUE_HOST_BUSY: Block all devices served by this
  96. * host temporarily.
  97. *
  98. * For compatibility, any other non-zero return is treated the
  99. * same as SCSI_MLQUEUE_HOST_BUSY.
  100. *
  101. * NOTE: "temporarily" means either until the next command for#
  102. * this device/host completes, or a period of time determined by
  103. * I/O pressure in the system if there are no other outstanding
  104. * commands.
  105. *
  106. * STATUS: REQUIRED
  107. */
  108. int (* queuecommand)(struct scsi_cmnd *,
  109. void (*done)(struct scsi_cmnd *));
  110. /*
  111. * The transfer functions are used to queue a scsi command to
  112. * the LLD. When the driver is finished processing the command
  113. * the done callback is invoked.
  114. *
  115. * return values: see queuecommand
  116. *
  117. * If the LLD accepts the cmd, it should set the result to an
  118. * appropriate value when completed before calling the done function.
  119. *
  120. * STATUS: REQUIRED FOR TARGET DRIVERS
  121. */
  122. /* TODO: rename */
  123. int (* transfer_response)(struct scsi_cmnd *,
  124. void (*done)(struct scsi_cmnd *));
  125. /*
  126. * This is called to inform the LLD to transfer cmd->request_bufflen
  127. * bytes of the cmd at cmd->offset in the cmd. The cmd->use_sg
  128. * speciefies the number of scatterlist entried in the command
  129. * and cmd->request_buffer contains the scatterlist.
  130. *
  131. * If the command cannot be processed in one transfer_data call
  132. * becuase a scatterlist within the LLD's limits cannot be
  133. * created then transfer_data will be called multiple times.
  134. * It is initially called from process context, and later
  135. * calls are from the interrup context.
  136. */
  137. int (* transfer_data)(struct scsi_cmnd *,
  138. void (*done)(struct scsi_cmnd *));
  139. /* Used as callback for the completion of task management request. */
  140. int (* tsk_mgmt_response)(u64 mid, int result);
  141. /*
  142. * This is an error handling strategy routine. You don't need to
  143. * define one of these if you don't want to - there is a default
  144. * routine that is present that should work in most cases. For those
  145. * driver authors that have the inclination and ability to write their
  146. * own strategy routine, this is where it is specified. Note - the
  147. * strategy routine is *ALWAYS* run in the context of the kernel eh
  148. * thread. Thus you are guaranteed to *NOT* be in an interrupt
  149. * handler when you execute this, and you are also guaranteed to
  150. * *NOT* have any other commands being queued while you are in the
  151. * strategy routine. When you return from this function, operations
  152. * return to normal.
  153. *
  154. * See scsi_error.c scsi_unjam_host for additional comments about
  155. * what this function should and should not be attempting to do.
  156. *
  157. * Status: REQUIRED (at least one of them)
  158. */
  159. int (* eh_abort_handler)(struct scsi_cmnd *);
  160. int (* eh_device_reset_handler)(struct scsi_cmnd *);
  161. int (* eh_bus_reset_handler)(struct scsi_cmnd *);
  162. int (* eh_host_reset_handler)(struct scsi_cmnd *);
  163. /*
  164. * Before the mid layer attempts to scan for a new device where none
  165. * currently exists, it will call this entry in your driver. Should
  166. * your driver need to allocate any structs or perform any other init
  167. * items in order to send commands to a currently unused target/lun
  168. * combo, then this is where you can perform those allocations. This
  169. * is specifically so that drivers won't have to perform any kind of
  170. * "is this a new device" checks in their queuecommand routine,
  171. * thereby making the hot path a bit quicker.
  172. *
  173. * Return values: 0 on success, non-0 on failure
  174. *
  175. * Deallocation: If we didn't find any devices at this ID, you will
  176. * get an immediate call to slave_destroy(). If we find something
  177. * here then you will get a call to slave_configure(), then the
  178. * device will be used for however long it is kept around, then when
  179. * the device is removed from the system (or * possibly at reboot
  180. * time), you will then get a call to slave_destroy(). This is
  181. * assuming you implement slave_configure and slave_destroy.
  182. * However, if you allocate memory and hang it off the device struct,
  183. * then you must implement the slave_destroy() routine at a minimum
  184. * in order to avoid leaking memory
  185. * each time a device is tore down.
  186. *
  187. * Status: OPTIONAL
  188. */
  189. int (* slave_alloc)(struct scsi_device *);
  190. /*
  191. * Once the device has responded to an INQUIRY and we know the
  192. * device is online, we call into the low level driver with the
  193. * struct scsi_device *. If the low level device driver implements
  194. * this function, it *must* perform the task of setting the queue
  195. * depth on the device. All other tasks are optional and depend
  196. * on what the driver supports and various implementation details.
  197. *
  198. * Things currently recommended to be handled at this time include:
  199. *
  200. * 1. Setting the device queue depth. Proper setting of this is
  201. * described in the comments for scsi_adjust_queue_depth.
  202. * 2. Determining if the device supports the various synchronous
  203. * negotiation protocols. The device struct will already have
  204. * responded to INQUIRY and the results of the standard items
  205. * will have been shoved into the various device flag bits, eg.
  206. * device->sdtr will be true if the device supports SDTR messages.
  207. * 3. Allocating command structs that the device will need.
  208. * 4. Setting the default timeout on this device (if needed).
  209. * 5. Anything else the low level driver might want to do on a device
  210. * specific setup basis...
  211. * 6. Return 0 on success, non-0 on error. The device will be marked
  212. * as offline on error so that no access will occur. If you return
  213. * non-0, your slave_destroy routine will never get called for this
  214. * device, so don't leave any loose memory hanging around, clean
  215. * up after yourself before returning non-0
  216. *
  217. * Status: OPTIONAL
  218. */
  219. int (* slave_configure)(struct scsi_device *);
  220. /*
  221. * Immediately prior to deallocating the device and after all activity
  222. * has ceased the mid layer calls this point so that the low level
  223. * driver may completely detach itself from the scsi device and vice
  224. * versa. The low level driver is responsible for freeing any memory
  225. * it allocated in the slave_alloc or slave_configure calls.
  226. *
  227. * Status: OPTIONAL
  228. */
  229. void (* slave_destroy)(struct scsi_device *);
  230. /*
  231. * Before the mid layer attempts to scan for a new device attached
  232. * to a target where no target currently exists, it will call this
  233. * entry in your driver. Should your driver need to allocate any
  234. * structs or perform any other init items in order to send commands
  235. * to a currently unused target, then this is where you can perform
  236. * those allocations.
  237. *
  238. * Return values: 0 on success, non-0 on failure
  239. *
  240. * Status: OPTIONAL
  241. */
  242. int (* target_alloc)(struct scsi_target *);
  243. /*
  244. * Immediately prior to deallocating the target structure, and
  245. * after all activity to attached scsi devices has ceased, the
  246. * midlayer calls this point so that the driver may deallocate
  247. * and terminate any references to the target.
  248. *
  249. * Status: OPTIONAL
  250. */
  251. void (* target_destroy)(struct scsi_target *);
  252. /*
  253. * If a host has the ability to discover targets on its own instead
  254. * of scanning the entire bus, it can fill in this function and
  255. * call scsi_scan_host(). This function will be called periodically
  256. * until it returns 1 with the scsi_host and the elapsed time of
  257. * the scan in jiffies.
  258. *
  259. * Status: OPTIONAL
  260. */
  261. int (* scan_finished)(struct Scsi_Host *, unsigned long);
  262. /*
  263. * If the host wants to be called before the scan starts, but
  264. * after the midlayer has set up ready for the scan, it can fill
  265. * in this function.
  266. */
  267. void (* scan_start)(struct Scsi_Host *);
  268. /*
  269. * fill in this function to allow the queue depth of this host
  270. * to be changeable (on a per device basis). returns either
  271. * the current queue depth setting (may be different from what
  272. * was passed in) or an error. An error should only be
  273. * returned if the requested depth is legal but the driver was
  274. * unable to set it. If the requested depth is illegal, the
  275. * driver should set and return the closest legal queue depth.
  276. *
  277. */
  278. int (* change_queue_depth)(struct scsi_device *, int);
  279. /*
  280. * fill in this function to allow the changing of tag types
  281. * (this also allows the enabling/disabling of tag command
  282. * queueing). An error should only be returned if something
  283. * went wrong in the driver while trying to set the tag type.
  284. * If the driver doesn't support the requested tag type, then
  285. * it should set the closest type it does support without
  286. * returning an error. Returns the actual tag type set.
  287. */
  288. int (* change_queue_type)(struct scsi_device *, int);
  289. /*
  290. * This function determines the bios parameters for a given
  291. * harddisk. These tend to be numbers that are made up by
  292. * the host adapter. Parameters:
  293. * size, device, list (heads, sectors, cylinders)
  294. *
  295. * Status: OPTIONAL */
  296. int (* bios_param)(struct scsi_device *, struct block_device *,
  297. sector_t, int []);
  298. /*
  299. * Can be used to export driver statistics and other infos to the
  300. * world outside the kernel ie. userspace and it also provides an
  301. * interface to feed the driver with information.
  302. *
  303. * Status: OBSOLETE
  304. */
  305. int (*proc_info)(struct Scsi_Host *, char *, char **, off_t, int, int);
  306. /*
  307. * suspend support
  308. */
  309. int (*resume)(struct scsi_device *);
  310. int (*suspend)(struct scsi_device *, pm_message_t state);
  311. /*
  312. * Name of proc directory
  313. */
  314. char *proc_name;
  315. /*
  316. * Used to store the procfs directory if a driver implements the
  317. * proc_info method.
  318. */
  319. struct proc_dir_entry *proc_dir;
  320. /*
  321. * This determines if we will use a non-interrupt driven
  322. * or an interrupt driven scheme, It is set to the maximum number
  323. * of simultaneous commands a given host adapter will accept.
  324. */
  325. int can_queue;
  326. /*
  327. * In many instances, especially where disconnect / reconnect are
  328. * supported, our host also has an ID on the SCSI bus. If this is
  329. * the case, then it must be reserved. Please set this_id to -1 if
  330. * your setup is in single initiator mode, and the host lacks an
  331. * ID.
  332. */
  333. int this_id;
  334. /*
  335. * This determines the degree to which the host adapter is capable
  336. * of scatter-gather.
  337. */
  338. unsigned short sg_tablesize;
  339. /*
  340. * If the host adapter has limitations beside segment count
  341. */
  342. unsigned short max_sectors;
  343. /*
  344. * dma scatter gather segment boundary limit. a segment crossing this
  345. * boundary will be split in two.
  346. */
  347. unsigned long dma_boundary;
  348. /*
  349. * This specifies "machine infinity" for host templates which don't
  350. * limit the transfer size. Note this limit represents an absolute
  351. * maximum, and may be over the transfer limits allowed for
  352. * individual devices (e.g. 256 for SCSI-1)
  353. */
  354. #define SCSI_DEFAULT_MAX_SECTORS 1024
  355. /*
  356. * True if this host adapter can make good use of linked commands.
  357. * This will allow more than one command to be queued to a given
  358. * unit on a given host. Set this to the maximum number of command
  359. * blocks to be provided for each device. Set this to 1 for one
  360. * command block per lun, 2 for two, etc. Do not set this to 0.
  361. * You should make sure that the host adapter will do the right thing
  362. * before you try setting this above 1.
  363. */
  364. short cmd_per_lun;
  365. /*
  366. * present contains counter indicating how many boards of this
  367. * type were found when we did the scan.
  368. */
  369. unsigned char present;
  370. /*
  371. * true if this host adapter uses unchecked DMA onto an ISA bus.
  372. */
  373. unsigned unchecked_isa_dma:1;
  374. /*
  375. * true if this host adapter can make good use of clustering.
  376. * I originally thought that if the tablesize was large that it
  377. * was a waste of CPU cycles to prepare a cluster list, but
  378. * it works out that the Buslogic is faster if you use a smaller
  379. * number of segments (i.e. use clustering). I guess it is
  380. * inefficient.
  381. */
  382. unsigned use_clustering:1;
  383. /*
  384. * True for emulated SCSI host adapters (e.g. ATAPI)
  385. */
  386. unsigned emulated:1;
  387. /*
  388. * True if the low-level driver performs its own reset-settle delays.
  389. */
  390. unsigned skip_settle_delay:1;
  391. /*
  392. * ordered write support
  393. */
  394. unsigned ordered_tag:1;
  395. /*
  396. * Countdown for host blocking with no commands outstanding
  397. */
  398. unsigned int max_host_blocked;
  399. /*
  400. * Default value for the blocking. If the queue is empty,
  401. * host_blocked counts down in the request_fn until it restarts
  402. * host operations as zero is reached.
  403. *
  404. * FIXME: This should probably be a value in the template
  405. */
  406. #define SCSI_DEFAULT_HOST_BLOCKED 7
  407. /*
  408. * Pointer to the sysfs class properties for this host, NULL terminated.
  409. */
  410. struct class_device_attribute **shost_attrs;
  411. /*
  412. * Pointer to the SCSI device properties for this host, NULL terminated.
  413. */
  414. struct device_attribute **sdev_attrs;
  415. /*
  416. * List of hosts per template.
  417. *
  418. * This is only for use by scsi_module.c for legacy templates.
  419. * For these access to it is synchronized implicitly by
  420. * module_init/module_exit.
  421. */
  422. struct list_head legacy_hosts;
  423. };
  424. /*
  425. * shost state: If you alter this, you also need to alter scsi_sysfs.c
  426. * (for the ascii descriptions) and the state model enforcer:
  427. * scsi_host_set_state()
  428. */
  429. enum scsi_host_state {
  430. SHOST_CREATED = 1,
  431. SHOST_RUNNING,
  432. SHOST_CANCEL,
  433. SHOST_DEL,
  434. SHOST_RECOVERY,
  435. SHOST_CANCEL_RECOVERY,
  436. SHOST_DEL_RECOVERY,
  437. };
  438. struct Scsi_Host {
  439. /*
  440. * __devices is protected by the host_lock, but you should
  441. * usually use scsi_device_lookup / shost_for_each_device
  442. * to access it and don't care about locking yourself.
  443. * In the rare case of beeing in irq context you can use
  444. * their __ prefixed variants with the lock held. NEVER
  445. * access this list directly from a driver.
  446. */
  447. struct list_head __devices;
  448. struct list_head __targets;
  449. struct scsi_host_cmd_pool *cmd_pool;
  450. spinlock_t free_list_lock;
  451. struct list_head free_list; /* backup store of cmd structs */
  452. struct list_head starved_list;
  453. spinlock_t default_lock;
  454. spinlock_t *host_lock;
  455. struct mutex scan_mutex;/* serialize scanning activity */
  456. struct list_head eh_cmd_q;
  457. struct task_struct * ehandler; /* Error recovery thread. */
  458. struct completion * eh_action; /* Wait for specific actions on the
  459. host. */
  460. wait_queue_head_t host_wait;
  461. struct scsi_host_template *hostt;
  462. struct scsi_transport_template *transportt;
  463. /*
  464. * area to keep a shared tag map (if needed, will be
  465. * NULL if not)
  466. */
  467. struct blk_queue_tag *bqt;
  468. /*
  469. * The following two fields are protected with host_lock;
  470. * however, eh routines can safely access during eh processing
  471. * without acquiring the lock.
  472. */
  473. unsigned int host_busy; /* commands actually active on low-level */
  474. unsigned int host_failed; /* commands that failed. */
  475. unsigned int host_eh_scheduled; /* EH scheduled without command */
  476. unsigned short host_no; /* Used for IOCTL_GET_IDLUN, /proc/scsi et al. */
  477. int resetting; /* if set, it means that last_reset is a valid value */
  478. unsigned long last_reset;
  479. /*
  480. * These three parameters can be used to allow for wide scsi,
  481. * and for host adapters that support multiple busses
  482. * The first two should be set to 1 more than the actual max id
  483. * or lun (i.e. 8 for normal systems).
  484. */
  485. unsigned int max_id;
  486. unsigned int max_lun;
  487. unsigned int max_channel;
  488. /*
  489. * This is a unique identifier that must be assigned so that we
  490. * have some way of identifying each detected host adapter properly
  491. * and uniquely. For hosts that do not support more than one card
  492. * in the system at one time, this does not need to be set. It is
  493. * initialized to 0 in scsi_register.
  494. */
  495. unsigned int unique_id;
  496. /*
  497. * The maximum length of SCSI commands that this host can accept.
  498. * Probably 12 for most host adapters, but could be 16 for others.
  499. * For drivers that don't set this field, a value of 12 is
  500. * assumed. I am leaving this as a number rather than a bit
  501. * because you never know what subsequent SCSI standards might do
  502. * (i.e. could there be a 20 byte or a 24-byte command a few years
  503. * down the road?).
  504. */
  505. unsigned char max_cmd_len;
  506. int this_id;
  507. int can_queue;
  508. short cmd_per_lun;
  509. short unsigned int sg_tablesize;
  510. short unsigned int max_sectors;
  511. unsigned long dma_boundary;
  512. /*
  513. * Used to assign serial numbers to the cmds.
  514. * Protected by the host lock.
  515. */
  516. unsigned long cmd_serial_number, cmd_pid;
  517. unsigned unchecked_isa_dma:1;
  518. unsigned use_clustering:1;
  519. unsigned use_blk_tcq:1;
  520. /*
  521. * Host has requested that no further requests come through for the
  522. * time being.
  523. */
  524. unsigned host_self_blocked:1;
  525. /*
  526. * Host uses correct SCSI ordering not PC ordering. The bit is
  527. * set for the minority of drivers whose authors actually read
  528. * the spec ;)
  529. */
  530. unsigned reverse_ordering:1;
  531. /*
  532. * ordered write support
  533. */
  534. unsigned ordered_tag:1;
  535. /* task mgmt function in progress */
  536. unsigned tmf_in_progress:1;
  537. /* Asynchronous scan in progress */
  538. unsigned async_scan:1;
  539. /*
  540. * Optional work queue to be utilized by the transport
  541. */
  542. char work_q_name[KOBJ_NAME_LEN];
  543. struct workqueue_struct *work_q;
  544. /*
  545. * Host has rejected a command because it was busy.
  546. */
  547. unsigned int host_blocked;
  548. /*
  549. * Value host_blocked counts down from
  550. */
  551. unsigned int max_host_blocked;
  552. /*
  553. * q used for scsi_tgt msgs, async events or any other requests that
  554. * need to be processed in userspace
  555. */
  556. struct request_queue *uspace_req_q;
  557. /* legacy crap */
  558. unsigned long base;
  559. unsigned long io_port;
  560. unsigned char n_io_port;
  561. unsigned char dma_channel;
  562. unsigned int irq;
  563. enum scsi_host_state shost_state;
  564. /* ldm bits */
  565. struct device shost_gendev;
  566. struct class_device shost_classdev;
  567. /*
  568. * List of hosts per template.
  569. *
  570. * This is only for use by scsi_module.c for legacy templates.
  571. * For these access to it is synchronized implicitly by
  572. * module_init/module_exit.
  573. */
  574. struct list_head sht_legacy_list;
  575. /*
  576. * Points to the transport data (if any) which is allocated
  577. * separately
  578. */
  579. void *shost_data;
  580. /*
  581. * We should ensure that this is aligned, both for better performance
  582. * and also because some compilers (m68k) don't automatically force
  583. * alignment to a long boundary.
  584. */
  585. unsigned long hostdata[0] /* Used for storage of host specific stuff */
  586. __attribute__ ((aligned (sizeof(unsigned long))));
  587. };
  588. #define class_to_shost(d) \
  589. container_of(d, struct Scsi_Host, shost_classdev)
  590. #define shost_printk(prefix, shost, fmt, a...) \
  591. dev_printk(prefix, &(shost)->shost_gendev, fmt, ##a)
  592. int scsi_is_host_device(const struct device *);
  593. static inline struct Scsi_Host *dev_to_shost(struct device *dev)
  594. {
  595. while (!scsi_is_host_device(dev)) {
  596. if (!dev->parent)
  597. return NULL;
  598. dev = dev->parent;
  599. }
  600. return container_of(dev, struct Scsi_Host, shost_gendev);
  601. }
  602. static inline int scsi_host_in_recovery(struct Scsi_Host *shost)
  603. {
  604. return shost->shost_state == SHOST_RECOVERY ||
  605. shost->shost_state == SHOST_CANCEL_RECOVERY ||
  606. shost->shost_state == SHOST_DEL_RECOVERY ||
  607. shost->tmf_in_progress;
  608. }
  609. extern int scsi_queue_work(struct Scsi_Host *, struct work_struct *);
  610. extern void scsi_flush_work(struct Scsi_Host *);
  611. extern struct Scsi_Host *scsi_host_alloc(struct scsi_host_template *, int);
  612. extern int __must_check scsi_add_host(struct Scsi_Host *, struct device *);
  613. extern void scsi_scan_host(struct Scsi_Host *);
  614. extern void scsi_rescan_device(struct device *);
  615. extern void scsi_remove_host(struct Scsi_Host *);
  616. extern struct Scsi_Host *scsi_host_get(struct Scsi_Host *);
  617. extern void scsi_host_put(struct Scsi_Host *t);
  618. extern struct Scsi_Host *scsi_host_lookup(unsigned short);
  619. extern const char *scsi_host_state_name(enum scsi_host_state);
  620. extern u64 scsi_calculate_bounce_limit(struct Scsi_Host *);
  621. static inline struct device *scsi_get_device(struct Scsi_Host *shost)
  622. {
  623. return shost->shost_gendev.parent;
  624. }
  625. /**
  626. * scsi_host_scan_allowed - Is scanning of this host allowed
  627. * @shost: Pointer to Scsi_Host.
  628. **/
  629. static inline int scsi_host_scan_allowed(struct Scsi_Host *shost)
  630. {
  631. return shost->shost_state == SHOST_RUNNING;
  632. }
  633. extern void scsi_unblock_requests(struct Scsi_Host *);
  634. extern void scsi_block_requests(struct Scsi_Host *);
  635. struct class_container;
  636. extern struct request_queue *__scsi_alloc_queue(struct Scsi_Host *shost,
  637. void (*) (struct request_queue *));
  638. /*
  639. * These two functions are used to allocate and free a pseudo device
  640. * which will connect to the host adapter itself rather than any
  641. * physical device. You must deallocate when you are done with the
  642. * thing. This physical pseudo-device isn't real and won't be available
  643. * from any high-level drivers.
  644. */
  645. extern void scsi_free_host_dev(struct scsi_device *);
  646. extern struct scsi_device *scsi_get_host_dev(struct Scsi_Host *);
  647. /* legacy interfaces */
  648. extern struct Scsi_Host *scsi_register(struct scsi_host_template *, int);
  649. extern void scsi_unregister(struct Scsi_Host *);
  650. extern int scsi_host_set_state(struct Scsi_Host *, enum scsi_host_state);
  651. #endif /* _SCSI_SCSI_HOST_H */