2 * hosts.c Copyright (C) 1992 Drew Eckhardt
3 * Copyright (C) 1993, 1994, 1995 Eric Youngdale
4 * Copyright (C) 2002-2003 Christoph Hellwig
6 * mid to lowlevel SCSI driver interface
7 * Initial versions: Drew Eckhardt
8 * Subsequent revisions: Eric Youngdale
12 * Jiffies wrap fixes (host->resetting), 3 Dec 1998 Andrea Arcangeli
13 * Added QLOGIC QLA1280 SCSI controller kernel host support.
14 * August 4, 1999 Fred Lewis, Intel DuPont
16 * Updated to reflect the new initialization scheme for the higher
17 * level of scsi drivers (sd/sr/st)
18 * September 17, 2000 Torben Mathiasen <tmm@image.dk>
20 * Restructured scsi_host lists and associated functions.
21 * September 04, 2002 Mike Anderson (andmike@us.ibm.com)
24 #include <linux/module.h>
25 #include <linux/blkdev.h>
26 #include <linux/kernel.h>
27 #include <linux/slab.h>
28 #include <linux/kthread.h>
29 #include <linux/string.h>
31 #include <linux/init.h>
32 #include <linux/completion.h>
33 #include <linux/transport_class.h>
34 #include <linux/platform_device.h>
35 #include <linux/pm_runtime.h>
36 #include <linux/idr.h>
37 #include <scsi/scsi_device.h>
38 #include <scsi/scsi_host.h>
39 #include <scsi/scsi_transport.h>
41 #include "scsi_priv.h"
42 #include "scsi_logging.h"
45 static DEFINE_IDA(host_index_ida
);
48 static void scsi_host_cls_release(struct device
*dev
)
50 put_device(&class_to_shost(dev
)->shost_gendev
);
53 static struct class shost_class
= {
55 .dev_release
= scsi_host_cls_release
,
59 * scsi_host_set_state - Take the given host through the host state model.
60 * @shost: scsi host to change the state of.
61 * @state: state to change to.
63 * Returns zero if unsuccessful or an error if the requested
64 * transition is illegal.
66 int scsi_host_set_state(struct Scsi_Host
*shost
, enum scsi_host_state state
)
68 enum scsi_host_state oldstate
= shost
->shost_state
;
70 if (state
== oldstate
)
75 /* There are no legal states that come back to
76 * created. This is the manually initialised start
103 case SHOST_CANCEL_RECOVERY
:
113 case SHOST_DEL_RECOVERY
:
120 case SHOST_CANCEL_RECOVERY
:
130 case SHOST_DEL_RECOVERY
:
132 case SHOST_CANCEL_RECOVERY
:
139 shost
->shost_state
= state
;
143 SCSI_LOG_ERROR_RECOVERY(1,
144 shost_printk(KERN_ERR
, shost
,
145 "Illegal host state transition"
147 scsi_host_state_name(oldstate
),
148 scsi_host_state_name(state
)));
151 EXPORT_SYMBOL(scsi_host_set_state
);
154 * scsi_remove_host - remove a scsi host
155 * @shost: a pointer to a scsi host to remove
157 void scsi_remove_host(struct Scsi_Host
*shost
)
161 mutex_lock(&shost
->scan_mutex
);
162 spin_lock_irqsave(shost
->host_lock
, flags
);
163 if (scsi_host_set_state(shost
, SHOST_CANCEL
))
164 if (scsi_host_set_state(shost
, SHOST_CANCEL_RECOVERY
)) {
165 spin_unlock_irqrestore(shost
->host_lock
, flags
);
166 mutex_unlock(&shost
->scan_mutex
);
169 spin_unlock_irqrestore(shost
->host_lock
, flags
);
171 scsi_autopm_get_host(shost
);
172 flush_workqueue(shost
->tmf_work_q
);
173 scsi_forget_host(shost
);
174 mutex_unlock(&shost
->scan_mutex
);
175 scsi_proc_host_rm(shost
);
177 spin_lock_irqsave(shost
->host_lock
, flags
);
178 if (scsi_host_set_state(shost
, SHOST_DEL
))
179 BUG_ON(scsi_host_set_state(shost
, SHOST_DEL_RECOVERY
));
180 spin_unlock_irqrestore(shost
->host_lock
, flags
);
182 transport_unregister_device(&shost
->shost_gendev
);
183 device_unregister(&shost
->shost_dev
);
184 device_del(&shost
->shost_gendev
);
186 EXPORT_SYMBOL(scsi_remove_host
);
189 * scsi_add_host_with_dma - add a scsi host with dma device
190 * @shost: scsi host pointer to add
191 * @dev: a struct device of type scsi class
192 * @dma_dev: dma device for the host
194 * Note: You rarely need to worry about this unless you're in a
195 * virtualised host environments, so use the simpler scsi_add_host()
199 * 0 on success / != 0 for error
201 int scsi_add_host_with_dma(struct Scsi_Host
*shost
, struct device
*dev
,
202 struct device
*dma_dev
)
204 struct scsi_host_template
*sht
= shost
->hostt
;
207 shost_printk(KERN_INFO
, shost
, "%s\n",
208 sht
->info
? sht
->info(shost
) : sht
->name
);
210 if (!shost
->can_queue
) {
211 shost_printk(KERN_ERR
, shost
,
212 "can_queue = 0 no longer supported\n");
216 error
= scsi_init_sense_cache(shost
);
220 if (shost_use_blk_mq(shost
)) {
221 error
= scsi_mq_setup_tags(shost
);
225 shost
->bqt
= blk_init_tags(shost
->can_queue
,
226 shost
->hostt
->tag_alloc_policy
);
233 if (!shost
->shost_gendev
.parent
)
234 shost
->shost_gendev
.parent
= dev
? dev
: &platform_bus
;
236 dma_dev
= shost
->shost_gendev
.parent
;
238 shost
->dma_dev
= dma_dev
;
241 * Increase usage count temporarily here so that calling
242 * scsi_autopm_put_host() will trigger runtime idle if there is
243 * nothing else preventing suspending the device.
245 pm_runtime_get_noresume(&shost
->shost_gendev
);
246 pm_runtime_set_active(&shost
->shost_gendev
);
247 pm_runtime_enable(&shost
->shost_gendev
);
248 device_enable_async_suspend(&shost
->shost_gendev
);
250 error
= device_add(&shost
->shost_gendev
);
252 goto out_disable_runtime_pm
;
254 scsi_host_set_state(shost
, SHOST_RUNNING
);
255 get_device(shost
->shost_gendev
.parent
);
257 device_enable_async_suspend(&shost
->shost_dev
);
259 error
= device_add(&shost
->shost_dev
);
263 get_device(&shost
->shost_gendev
);
265 if (shost
->transportt
->host_size
) {
266 shost
->shost_data
= kzalloc(shost
->transportt
->host_size
,
268 if (shost
->shost_data
== NULL
) {
274 if (shost
->transportt
->create_work_queue
) {
275 snprintf(shost
->work_q_name
, sizeof(shost
->work_q_name
),
276 "scsi_wq_%d", shost
->host_no
);
277 shost
->work_q
= create_singlethread_workqueue(
279 if (!shost
->work_q
) {
281 goto out_free_shost_data
;
285 error
= scsi_sysfs_add_host(shost
);
287 goto out_destroy_host
;
289 scsi_proc_host_add(shost
);
290 scsi_autopm_put_host(shost
);
295 destroy_workqueue(shost
->work_q
);
297 kfree(shost
->shost_data
);
299 device_del(&shost
->shost_dev
);
301 device_del(&shost
->shost_gendev
);
302 out_disable_runtime_pm
:
303 device_disable_async_suspend(&shost
->shost_gendev
);
304 pm_runtime_disable(&shost
->shost_gendev
);
305 pm_runtime_set_suspended(&shost
->shost_gendev
);
306 pm_runtime_put_noidle(&shost
->shost_gendev
);
307 if (shost_use_blk_mq(shost
))
308 scsi_mq_destroy_tags(shost
);
312 EXPORT_SYMBOL(scsi_add_host_with_dma
);
314 static void scsi_host_dev_release(struct device
*dev
)
316 struct Scsi_Host
*shost
= dev_to_shost(dev
);
317 struct device
*parent
= dev
->parent
;
318 struct request_queue
*q
;
321 scsi_proc_hostdir_rm(shost
->hostt
);
323 if (shost
->tmf_work_q
)
324 destroy_workqueue(shost
->tmf_work_q
);
326 kthread_stop(shost
->ehandler
);
328 destroy_workqueue(shost
->work_q
);
329 q
= shost
->uspace_req_q
;
331 queuedata
= q
->queuedata
;
332 blk_cleanup_queue(q
);
336 if (shost
->shost_state
== SHOST_CREATED
) {
338 * Free the shost_dev device name here if scsi_host_alloc()
339 * and scsi_host_put() have been called but neither
340 * scsi_host_add() nor scsi_host_remove() has been called.
341 * This avoids that the memory allocated for the shost_dev
344 kfree(dev_name(&shost
->shost_dev
));
347 if (shost_use_blk_mq(shost
)) {
348 if (shost
->tag_set
.tags
)
349 scsi_mq_destroy_tags(shost
);
352 blk_free_tags(shost
->bqt
);
355 kfree(shost
->shost_data
);
357 ida_simple_remove(&host_index_ida
, shost
->host_no
);
364 static int shost_eh_deadline
= -1;
366 module_param_named(eh_deadline
, shost_eh_deadline
, int, S_IRUGO
|S_IWUSR
);
367 MODULE_PARM_DESC(eh_deadline
,
368 "SCSI EH timeout in seconds (should be between 0 and 2^31-1)");
370 static struct device_type scsi_host_type
= {
372 .release
= scsi_host_dev_release
,
376 * scsi_host_alloc - register a scsi host adapter instance.
377 * @sht: pointer to scsi host template
378 * @privsize: extra bytes to allocate for driver
381 * Allocate a new Scsi_Host and perform basic initialization.
382 * The host is not published to the scsi midlayer until scsi_add_host
386 * Pointer to a new Scsi_Host
388 struct Scsi_Host
*scsi_host_alloc(struct scsi_host_template
*sht
, int privsize
)
390 struct Scsi_Host
*shost
;
391 gfp_t gfp_mask
= GFP_KERNEL
;
394 if (sht
->unchecked_isa_dma
&& privsize
)
395 gfp_mask
|= __GFP_DMA
;
397 shost
= kzalloc(sizeof(struct Scsi_Host
) + privsize
, gfp_mask
);
401 shost
->host_lock
= &shost
->default_lock
;
402 spin_lock_init(shost
->host_lock
);
403 shost
->shost_state
= SHOST_CREATED
;
404 INIT_LIST_HEAD(&shost
->__devices
);
405 INIT_LIST_HEAD(&shost
->__targets
);
406 INIT_LIST_HEAD(&shost
->eh_cmd_q
);
407 INIT_LIST_HEAD(&shost
->starved_list
);
408 init_waitqueue_head(&shost
->host_wait
);
409 mutex_init(&shost
->scan_mutex
);
411 index
= ida_simple_get(&host_index_ida
, 0, 0, GFP_KERNEL
);
414 shost
->host_no
= index
;
416 shost
->dma_channel
= 0xff;
418 /* These three are default values which can be overridden */
419 shost
->max_channel
= 0;
423 /* Give each shost a default transportt */
424 shost
->transportt
= &blank_transport_template
;
427 * All drivers right now should be able to handle 12 byte
428 * commands. Every so often there are requests for 16 byte
429 * commands, but individual low-level drivers need to certify that
430 * they actually do something sensible with such commands.
432 shost
->max_cmd_len
= 12;
434 shost
->this_id
= sht
->this_id
;
435 shost
->can_queue
= sht
->can_queue
;
436 shost
->sg_tablesize
= sht
->sg_tablesize
;
437 shost
->sg_prot_tablesize
= sht
->sg_prot_tablesize
;
438 shost
->cmd_per_lun
= sht
->cmd_per_lun
;
439 shost
->unchecked_isa_dma
= sht
->unchecked_isa_dma
;
440 shost
->use_clustering
= sht
->use_clustering
;
441 shost
->no_write_same
= sht
->no_write_same
;
443 if (shost_eh_deadline
== -1 || !sht
->eh_host_reset_handler
)
444 shost
->eh_deadline
= -1;
445 else if ((ulong
) shost_eh_deadline
* HZ
> INT_MAX
) {
446 shost_printk(KERN_WARNING
, shost
,
447 "eh_deadline %u too large, setting to %u\n",
448 shost_eh_deadline
, INT_MAX
/ HZ
);
449 shost
->eh_deadline
= INT_MAX
;
451 shost
->eh_deadline
= shost_eh_deadline
* HZ
;
453 if (sht
->supported_mode
== MODE_UNKNOWN
)
454 /* means we didn't set it ... default to INITIATOR */
455 shost
->active_mode
= MODE_INITIATOR
;
457 shost
->active_mode
= sht
->supported_mode
;
459 if (sht
->max_host_blocked
)
460 shost
->max_host_blocked
= sht
->max_host_blocked
;
462 shost
->max_host_blocked
= SCSI_DEFAULT_HOST_BLOCKED
;
465 * If the driver imposes no hard sector transfer limit, start at
466 * machine infinity initially.
468 if (sht
->max_sectors
)
469 shost
->max_sectors
= sht
->max_sectors
;
471 shost
->max_sectors
= SCSI_DEFAULT_MAX_SECTORS
;
474 * assume a 4GB boundary, if not set
476 if (sht
->dma_boundary
)
477 shost
->dma_boundary
= sht
->dma_boundary
;
479 shost
->dma_boundary
= 0xffffffff;
481 shost
->use_blk_mq
= scsi_use_blk_mq
;
483 device_initialize(&shost
->shost_gendev
);
484 dev_set_name(&shost
->shost_gendev
, "host%d", shost
->host_no
);
485 shost
->shost_gendev
.bus
= &scsi_bus_type
;
486 shost
->shost_gendev
.type
= &scsi_host_type
;
488 device_initialize(&shost
->shost_dev
);
489 shost
->shost_dev
.parent
= &shost
->shost_gendev
;
490 shost
->shost_dev
.class = &shost_class
;
491 dev_set_name(&shost
->shost_dev
, "host%d", shost
->host_no
);
492 shost
->shost_dev
.groups
= scsi_sysfs_shost_attr_groups
;
494 shost
->ehandler
= kthread_run(scsi_error_handler
, shost
,
495 "scsi_eh_%d", shost
->host_no
);
496 if (IS_ERR(shost
->ehandler
)) {
497 shost_printk(KERN_WARNING
, shost
,
498 "error handler thread failed to spawn, error = %ld\n",
499 PTR_ERR(shost
->ehandler
));
500 goto fail_index_remove
;
503 shost
->tmf_work_q
= alloc_workqueue("scsi_tmf_%d",
504 WQ_UNBOUND
| WQ_MEM_RECLAIM
,
506 if (!shost
->tmf_work_q
) {
507 shost_printk(KERN_WARNING
, shost
,
508 "failed to create tmf workq\n");
511 scsi_proc_hostdir_add(shost
->hostt
);
515 kthread_stop(shost
->ehandler
);
517 ida_simple_remove(&host_index_ida
, shost
->host_no
);
522 EXPORT_SYMBOL(scsi_host_alloc
);
524 struct Scsi_Host
*scsi_register(struct scsi_host_template
*sht
, int privsize
)
526 struct Scsi_Host
*shost
= scsi_host_alloc(sht
, privsize
);
529 printk(KERN_WARNING
"scsi_register() called on new-style "
530 "template for driver %s\n", sht
->name
);
535 list_add_tail(&shost
->sht_legacy_list
, &sht
->legacy_hosts
);
538 EXPORT_SYMBOL(scsi_register
);
540 void scsi_unregister(struct Scsi_Host
*shost
)
542 list_del(&shost
->sht_legacy_list
);
543 scsi_host_put(shost
);
545 EXPORT_SYMBOL(scsi_unregister
);
547 static int __scsi_host_match(struct device
*dev
, const void *data
)
550 const unsigned short *hostnum
= data
;
552 p
= class_to_shost(dev
);
553 return p
->host_no
== *hostnum
;
557 * scsi_host_lookup - get a reference to a Scsi_Host by host no
558 * @hostnum: host number to locate
561 * A pointer to located Scsi_Host or NULL.
563 * The caller must do a scsi_host_put() to drop the reference
564 * that scsi_host_get() took. The put_device() below dropped
565 * the reference from class_find_device().
567 struct Scsi_Host
*scsi_host_lookup(unsigned short hostnum
)
570 struct Scsi_Host
*shost
= NULL
;
572 cdev
= class_find_device(&shost_class
, NULL
, &hostnum
,
575 shost
= scsi_host_get(class_to_shost(cdev
));
580 EXPORT_SYMBOL(scsi_host_lookup
);
583 * scsi_host_get - inc a Scsi_Host ref count
584 * @shost: Pointer to Scsi_Host to inc.
586 struct Scsi_Host
*scsi_host_get(struct Scsi_Host
*shost
)
588 if ((shost
->shost_state
== SHOST_DEL
) ||
589 !get_device(&shost
->shost_gendev
))
593 EXPORT_SYMBOL(scsi_host_get
);
596 * scsi_host_put - dec a Scsi_Host ref count
597 * @shost: Pointer to Scsi_Host to dec.
599 void scsi_host_put(struct Scsi_Host
*shost
)
601 put_device(&shost
->shost_gendev
);
603 EXPORT_SYMBOL(scsi_host_put
);
605 int scsi_init_hosts(void)
607 return class_register(&shost_class
);
610 void scsi_exit_hosts(void)
612 class_unregister(&shost_class
);
613 ida_destroy(&host_index_ida
);
616 int scsi_is_host_device(const struct device
*dev
)
618 return dev
->type
== &scsi_host_type
;
620 EXPORT_SYMBOL(scsi_is_host_device
);
623 * scsi_queue_work - Queue work to the Scsi_Host workqueue.
624 * @shost: Pointer to Scsi_Host.
625 * @work: Work to queue for execution.
628 * 1 - work queued for execution
629 * 0 - work is already queued
630 * -EINVAL - work queue doesn't exist
632 int scsi_queue_work(struct Scsi_Host
*shost
, struct work_struct
*work
)
634 if (unlikely(!shost
->work_q
)) {
635 shost_printk(KERN_ERR
, shost
,
636 "ERROR: Scsi host '%s' attempted to queue scsi-work, "
637 "when no workqueue created.\n", shost
->hostt
->name
);
643 return queue_work(shost
->work_q
, work
);
645 EXPORT_SYMBOL_GPL(scsi_queue_work
);
648 * scsi_flush_work - Flush a Scsi_Host's workqueue.
649 * @shost: Pointer to Scsi_Host.
651 void scsi_flush_work(struct Scsi_Host
*shost
)
653 if (!shost
->work_q
) {
654 shost_printk(KERN_ERR
, shost
,
655 "ERROR: Scsi host '%s' attempted to flush scsi-work, "
656 "when no workqueue created.\n", shost
->hostt
->name
);
661 flush_workqueue(shost
->work_q
);
663 EXPORT_SYMBOL_GPL(scsi_flush_work
);