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/kthread.h>
28 #include <linux/string.h>
30 #include <linux/init.h>
31 #include <linux/completion.h>
32 #include <linux/transport_class.h>
33 #include <linux/platform_device.h>
35 #include <scsi/scsi_device.h>
36 #include <scsi/scsi_host.h>
37 #include <scsi/scsi_transport.h>
39 #include "scsi_priv.h"
40 #include "scsi_logging.h"
43 static atomic_t scsi_host_next_hn
; /* host_no for next new host */
46 static void scsi_host_cls_release(struct class_device
*class_dev
)
48 put_device(&class_to_shost(class_dev
)->shost_gendev
);
51 static struct class shost_class
= {
53 .release
= scsi_host_cls_release
,
57 * scsi_host_set_state - Take the given host through the host
59 * @shost: scsi host to change the state of.
60 * @state: state to change to.
62 * Returns zero if unsuccessful or an error if the requested
63 * transition is illegal.
65 int scsi_host_set_state(struct Scsi_Host
*shost
, enum scsi_host_state state
)
67 enum scsi_host_state oldstate
= shost
->shost_state
;
69 if (state
== oldstate
)
74 /* There are no legal states that come back to
75 * created. This is the manually initialised start
102 case SHOST_CANCEL_RECOVERY
:
112 case SHOST_DEL_RECOVERY
:
119 case SHOST_CANCEL_RECOVERY
:
129 case SHOST_DEL_RECOVERY
:
131 case SHOST_CANCEL_RECOVERY
:
138 shost
->shost_state
= state
;
142 SCSI_LOG_ERROR_RECOVERY(1,
143 shost_printk(KERN_ERR
, shost
,
144 "Illegal host state transition"
146 scsi_host_state_name(oldstate
),
147 scsi_host_state_name(state
)));
150 EXPORT_SYMBOL(scsi_host_set_state
);
153 * scsi_remove_host - remove a scsi host
154 * @shost: a pointer to a scsi host to remove
156 void scsi_remove_host(struct Scsi_Host
*shost
)
159 mutex_lock(&shost
->scan_mutex
);
160 spin_lock_irqsave(shost
->host_lock
, flags
);
161 if (scsi_host_set_state(shost
, SHOST_CANCEL
))
162 if (scsi_host_set_state(shost
, SHOST_CANCEL_RECOVERY
)) {
163 spin_unlock_irqrestore(shost
->host_lock
, flags
);
164 mutex_unlock(&shost
->scan_mutex
);
167 spin_unlock_irqrestore(shost
->host_lock
, flags
);
168 scsi_forget_host(shost
);
169 mutex_unlock(&shost
->scan_mutex
);
170 scsi_proc_host_rm(shost
);
172 spin_lock_irqsave(shost
->host_lock
, flags
);
173 if (scsi_host_set_state(shost
, SHOST_DEL
))
174 BUG_ON(scsi_host_set_state(shost
, SHOST_DEL_RECOVERY
));
175 spin_unlock_irqrestore(shost
->host_lock
, flags
);
177 transport_unregister_device(&shost
->shost_gendev
);
178 class_device_unregister(&shost
->shost_classdev
);
179 device_del(&shost
->shost_gendev
);
181 EXPORT_SYMBOL(scsi_remove_host
);
184 * scsi_add_host - add a scsi host
185 * @shost: scsi host pointer to add
186 * @dev: a struct device of type scsi class
189 * 0 on success / != 0 for error
191 int scsi_add_host(struct Scsi_Host
*shost
, struct device
*dev
)
193 struct scsi_host_template
*sht
= shost
->hostt
;
196 printk(KERN_INFO
"scsi%d : %s\n", shost
->host_no
,
197 sht
->info
? sht
->info(shost
) : sht
->name
);
199 if (!shost
->can_queue
) {
200 printk(KERN_ERR
"%s: can_queue = 0 no longer supported\n",
205 error
= scsi_setup_command_freelist(shost
);
209 if (!shost
->shost_gendev
.parent
)
210 shost
->shost_gendev
.parent
= dev
? dev
: &platform_bus
;
212 error
= device_add(&shost
->shost_gendev
);
216 scsi_host_set_state(shost
, SHOST_RUNNING
);
217 get_device(shost
->shost_gendev
.parent
);
219 error
= class_device_add(&shost
->shost_classdev
);
223 get_device(&shost
->shost_gendev
);
225 if (shost
->transportt
->host_size
) {
226 shost
->shost_data
= kzalloc(shost
->transportt
->host_size
,
228 if (shost
->shost_data
== NULL
) {
230 goto out_del_classdev
;
234 if (shost
->transportt
->create_work_queue
) {
235 snprintf(shost
->work_q_name
, KOBJ_NAME_LEN
, "scsi_wq_%d",
237 shost
->work_q
= create_singlethread_workqueue(
239 if (!shost
->work_q
) {
241 goto out_free_shost_data
;
245 error
= scsi_sysfs_add_host(shost
);
247 goto out_destroy_host
;
249 scsi_proc_host_add(shost
);
254 destroy_workqueue(shost
->work_q
);
256 kfree(shost
->shost_data
);
258 class_device_del(&shost
->shost_classdev
);
260 device_del(&shost
->shost_gendev
);
262 scsi_destroy_command_freelist(shost
);
266 EXPORT_SYMBOL(scsi_add_host
);
268 static void scsi_host_dev_release(struct device
*dev
)
270 struct Scsi_Host
*shost
= dev_to_shost(dev
);
271 struct device
*parent
= dev
->parent
;
273 scsi_proc_hostdir_rm(shost
->hostt
);
276 kthread_stop(shost
->ehandler
);
278 destroy_workqueue(shost
->work_q
);
279 if (shost
->uspace_req_q
) {
280 kfree(shost
->uspace_req_q
->queuedata
);
281 scsi_free_queue(shost
->uspace_req_q
);
284 scsi_destroy_command_freelist(shost
);
286 blk_free_tags(shost
->bqt
);
288 kfree(shost
->shost_data
);
296 * scsi_host_alloc - register a scsi host adapter instance.
297 * @sht: pointer to scsi host template
298 * @privsize: extra bytes to allocate for driver
301 * Allocate a new Scsi_Host and perform basic initialization.
302 * The host is not published to the scsi midlayer until scsi_add_host
306 * Pointer to a new Scsi_Host
308 struct Scsi_Host
*scsi_host_alloc(struct scsi_host_template
*sht
, int privsize
)
310 struct Scsi_Host
*shost
;
311 gfp_t gfp_mask
= GFP_KERNEL
;
314 if (sht
->unchecked_isa_dma
&& privsize
)
315 gfp_mask
|= __GFP_DMA
;
317 shost
= kzalloc(sizeof(struct Scsi_Host
) + privsize
, gfp_mask
);
321 shost
->host_lock
= &shost
->default_lock
;
322 spin_lock_init(shost
->host_lock
);
323 shost
->shost_state
= SHOST_CREATED
;
324 INIT_LIST_HEAD(&shost
->__devices
);
325 INIT_LIST_HEAD(&shost
->__targets
);
326 INIT_LIST_HEAD(&shost
->eh_cmd_q
);
327 INIT_LIST_HEAD(&shost
->starved_list
);
328 init_waitqueue_head(&shost
->host_wait
);
330 mutex_init(&shost
->scan_mutex
);
333 * subtract one because we increment first then return, but we need to
334 * know what the next host number was before increment
336 shost
->host_no
= atomic_inc_return(&scsi_host_next_hn
) - 1;
337 shost
->dma_channel
= 0xff;
339 /* These three are default values which can be overridden */
340 shost
->max_channel
= 0;
344 /* Give each shost a default transportt */
345 shost
->transportt
= &blank_transport_template
;
348 * All drivers right now should be able to handle 12 byte
349 * commands. Every so often there are requests for 16 byte
350 * commands, but individual low-level drivers need to certify that
351 * they actually do something sensible with such commands.
353 shost
->max_cmd_len
= 12;
355 shost
->this_id
= sht
->this_id
;
356 shost
->can_queue
= sht
->can_queue
;
357 shost
->sg_tablesize
= sht
->sg_tablesize
;
358 shost
->cmd_per_lun
= sht
->cmd_per_lun
;
359 shost
->unchecked_isa_dma
= sht
->unchecked_isa_dma
;
360 shost
->use_clustering
= sht
->use_clustering
;
361 shost
->ordered_tag
= sht
->ordered_tag
;
363 if (sht
->max_host_blocked
)
364 shost
->max_host_blocked
= sht
->max_host_blocked
;
366 shost
->max_host_blocked
= SCSI_DEFAULT_HOST_BLOCKED
;
369 * If the driver imposes no hard sector transfer limit, start at
370 * machine infinity initially.
372 if (sht
->max_sectors
)
373 shost
->max_sectors
= sht
->max_sectors
;
375 shost
->max_sectors
= SCSI_DEFAULT_MAX_SECTORS
;
378 * assume a 4GB boundary, if not set
380 if (sht
->dma_boundary
)
381 shost
->dma_boundary
= sht
->dma_boundary
;
383 shost
->dma_boundary
= 0xffffffff;
385 device_initialize(&shost
->shost_gendev
);
386 snprintf(shost
->shost_gendev
.bus_id
, BUS_ID_SIZE
, "host%d",
388 shost
->shost_gendev
.release
= scsi_host_dev_release
;
390 class_device_initialize(&shost
->shost_classdev
);
391 shost
->shost_classdev
.dev
= &shost
->shost_gendev
;
392 shost
->shost_classdev
.class = &shost_class
;
393 snprintf(shost
->shost_classdev
.class_id
, BUS_ID_SIZE
, "host%d",
396 shost
->ehandler
= kthread_run(scsi_error_handler
, shost
,
397 "scsi_eh_%d", shost
->host_no
);
398 if (IS_ERR(shost
->ehandler
)) {
399 rval
= PTR_ERR(shost
->ehandler
);
403 scsi_proc_hostdir_add(shost
->hostt
);
410 EXPORT_SYMBOL(scsi_host_alloc
);
412 struct Scsi_Host
*scsi_register(struct scsi_host_template
*sht
, int privsize
)
414 struct Scsi_Host
*shost
= scsi_host_alloc(sht
, privsize
);
417 printk(KERN_WARNING
"scsi_register() called on new-style "
418 "template for driver %s\n", sht
->name
);
423 list_add_tail(&shost
->sht_legacy_list
, &sht
->legacy_hosts
);
426 EXPORT_SYMBOL(scsi_register
);
428 void scsi_unregister(struct Scsi_Host
*shost
)
430 list_del(&shost
->sht_legacy_list
);
431 scsi_host_put(shost
);
433 EXPORT_SYMBOL(scsi_unregister
);
436 * scsi_host_lookup - get a reference to a Scsi_Host by host no
438 * @hostnum: host number to locate
441 * A pointer to located Scsi_Host or NULL.
443 struct Scsi_Host
*scsi_host_lookup(unsigned short hostnum
)
445 struct class *class = &shost_class
;
446 struct class_device
*cdev
;
447 struct Scsi_Host
*shost
= NULL
, *p
;
450 list_for_each_entry(cdev
, &class->children
, node
) {
451 p
= class_to_shost(cdev
);
452 if (p
->host_no
== hostnum
) {
453 shost
= scsi_host_get(p
);
461 EXPORT_SYMBOL(scsi_host_lookup
);
464 * scsi_host_get - inc a Scsi_Host ref count
465 * @shost: Pointer to Scsi_Host to inc.
467 struct Scsi_Host
*scsi_host_get(struct Scsi_Host
*shost
)
469 if ((shost
->shost_state
== SHOST_DEL
) ||
470 !get_device(&shost
->shost_gendev
))
474 EXPORT_SYMBOL(scsi_host_get
);
477 * scsi_host_put - dec a Scsi_Host ref count
478 * @shost: Pointer to Scsi_Host to dec.
480 void scsi_host_put(struct Scsi_Host
*shost
)
482 put_device(&shost
->shost_gendev
);
484 EXPORT_SYMBOL(scsi_host_put
);
486 int scsi_init_hosts(void)
488 return class_register(&shost_class
);
491 void scsi_exit_hosts(void)
493 class_unregister(&shost_class
);
496 int scsi_is_host_device(const struct device
*dev
)
498 return dev
->release
== scsi_host_dev_release
;
500 EXPORT_SYMBOL(scsi_is_host_device
);
503 * scsi_queue_work - Queue work to the Scsi_Host workqueue.
504 * @shost: Pointer to Scsi_Host.
505 * @work: Work to queue for execution.
508 * 1 - work queued for execution
509 * 0 - work is already queued
510 * -EINVAL - work queue doesn't exist
512 int scsi_queue_work(struct Scsi_Host
*shost
, struct work_struct
*work
)
514 if (unlikely(!shost
->work_q
)) {
516 "ERROR: Scsi host '%s' attempted to queue scsi-work, "
517 "when no workqueue created.\n", shost
->hostt
->name
);
523 return queue_work(shost
->work_q
, work
);
525 EXPORT_SYMBOL_GPL(scsi_queue_work
);
528 * scsi_flush_work - Flush a Scsi_Host's workqueue.
529 * @shost: Pointer to Scsi_Host.
531 void scsi_flush_work(struct Scsi_Host
*shost
)
533 if (!shost
->work_q
) {
535 "ERROR: Scsi host '%s' attempted to flush scsi-work, "
536 "when no workqueue created.\n", shost
->hostt
->name
);
541 flush_workqueue(shost
->work_q
);
543 EXPORT_SYMBOL_GPL(scsi_flush_work
);