4 * SCSI sysfs interface routines.
6 * Created to pull SCSI mid layer sysfs routines into one file.
9 #include <linux/module.h>
10 #include <linux/slab.h>
11 #include <linux/init.h>
12 #include <linux/blkdev.h>
13 #include <linux/device.h>
15 #include <scsi/scsi.h>
16 #include <scsi/scsi_device.h>
17 #include <scsi/scsi_host.h>
18 #include <scsi/scsi_tcq.h>
19 #include <scsi/scsi_transport.h>
20 #include <scsi/scsi_driver.h>
22 #include "scsi_priv.h"
23 #include "scsi_logging.h"
25 static struct device_type scsi_dev_type
;
28 enum scsi_device_state value
;
31 { SDEV_CREATED
, "created" },
32 { SDEV_RUNNING
, "running" },
33 { SDEV_CANCEL
, "cancel" },
34 { SDEV_DEL
, "deleted" },
35 { SDEV_QUIESCE
, "quiesce" },
36 { SDEV_OFFLINE
, "offline" },
37 { SDEV_BLOCK
, "blocked" },
38 { SDEV_CREATED_BLOCK
, "created-blocked" },
41 const char *scsi_device_state_name(enum scsi_device_state state
)
46 for (i
= 0; i
< ARRAY_SIZE(sdev_states
); i
++) {
47 if (sdev_states
[i
].value
== state
) {
48 name
= sdev_states
[i
].name
;
56 enum scsi_host_state value
;
59 { SHOST_CREATED
, "created" },
60 { SHOST_RUNNING
, "running" },
61 { SHOST_CANCEL
, "cancel" },
62 { SHOST_DEL
, "deleted" },
63 { SHOST_RECOVERY
, "recovery" },
64 { SHOST_CANCEL_RECOVERY
, "cancel/recovery" },
65 { SHOST_DEL_RECOVERY
, "deleted/recovery", },
67 const char *scsi_host_state_name(enum scsi_host_state state
)
72 for (i
= 0; i
< ARRAY_SIZE(shost_states
); i
++) {
73 if (shost_states
[i
].value
== state
) {
74 name
= shost_states
[i
].name
;
81 static int check_set(unsigned int *val
, char *src
)
85 if (strncmp(src
, "-", 20) == 0) {
86 *val
= SCAN_WILD_CARD
;
89 * Doesn't check for int overflow
91 *val
= simple_strtoul(src
, &last
, 0);
98 static int scsi_scan(struct Scsi_Host
*shost
, const char *str
)
100 char s1
[15], s2
[15], s3
[15], junk
;
101 unsigned int channel
, id
, lun
;
104 res
= sscanf(str
, "%10s %10s %10s %c", s1
, s2
, s3
, &junk
);
107 if (check_set(&channel
, s1
))
109 if (check_set(&id
, s2
))
111 if (check_set(&lun
, s3
))
113 if (shost
->transportt
->user_scan
)
114 res
= shost
->transportt
->user_scan(shost
, channel
, id
, lun
);
116 res
= scsi_scan_host_selected(shost
, channel
, id
, lun
, 1);
121 * shost_show_function: macro to create an attr function that can be used to
122 * show a non-bit field.
124 #define shost_show_function(name, field, format_string) \
126 show_##name (struct device *dev, struct device_attribute *attr, \
129 struct Scsi_Host *shost = class_to_shost(dev); \
130 return snprintf (buf, 20, format_string, shost->field); \
134 * shost_rd_attr: macro to create a function and attribute variable for a
137 #define shost_rd_attr2(name, field, format_string) \
138 shost_show_function(name, field, format_string) \
139 static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL);
141 #define shost_rd_attr(field, format_string) \
142 shost_rd_attr2(field, field, format_string)
145 * Create the actual show/store functions and data structures.
149 store_scan(struct device
*dev
, struct device_attribute
*attr
,
150 const char *buf
, size_t count
)
152 struct Scsi_Host
*shost
= class_to_shost(dev
);
155 res
= scsi_scan(shost
, buf
);
160 static DEVICE_ATTR(scan
, S_IWUSR
, NULL
, store_scan
);
163 store_shost_state(struct device
*dev
, struct device_attribute
*attr
,
164 const char *buf
, size_t count
)
167 struct Scsi_Host
*shost
= class_to_shost(dev
);
168 enum scsi_host_state state
= 0;
170 for (i
= 0; i
< ARRAY_SIZE(shost_states
); i
++) {
171 const int len
= strlen(shost_states
[i
].name
);
172 if (strncmp(shost_states
[i
].name
, buf
, len
) == 0 &&
174 state
= shost_states
[i
].value
;
181 if (scsi_host_set_state(shost
, state
))
187 show_shost_state(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
189 struct Scsi_Host
*shost
= class_to_shost(dev
);
190 const char *name
= scsi_host_state_name(shost
->shost_state
);
195 return snprintf(buf
, 20, "%s\n", name
);
198 /* DEVICE_ATTR(state) clashes with dev_attr_state for sdev */
199 struct device_attribute dev_attr_hstate
=
200 __ATTR(state
, S_IRUGO
| S_IWUSR
, show_shost_state
, store_shost_state
);
203 show_shost_mode(unsigned int mode
, char *buf
)
207 if (mode
& MODE_INITIATOR
)
208 len
= sprintf(buf
, "%s", "Initiator");
210 if (mode
& MODE_TARGET
)
211 len
+= sprintf(buf
+ len
, "%s%s", len
? ", " : "", "Target");
213 len
+= sprintf(buf
+ len
, "\n");
219 show_shost_supported_mode(struct device
*dev
, struct device_attribute
*attr
,
222 struct Scsi_Host
*shost
= class_to_shost(dev
);
223 unsigned int supported_mode
= shost
->hostt
->supported_mode
;
225 if (supported_mode
== MODE_UNKNOWN
)
226 /* by default this should be initiator */
227 supported_mode
= MODE_INITIATOR
;
229 return show_shost_mode(supported_mode
, buf
);
232 static DEVICE_ATTR(supported_mode
, S_IRUGO
| S_IWUSR
, show_shost_supported_mode
, NULL
);
235 show_shost_active_mode(struct device
*dev
,
236 struct device_attribute
*attr
, char *buf
)
238 struct Scsi_Host
*shost
= class_to_shost(dev
);
240 if (shost
->active_mode
== MODE_UNKNOWN
)
241 return snprintf(buf
, 20, "unknown\n");
243 return show_shost_mode(shost
->active_mode
, buf
);
246 static DEVICE_ATTR(active_mode
, S_IRUGO
| S_IWUSR
, show_shost_active_mode
, NULL
);
248 shost_rd_attr(unique_id
, "%u\n");
249 shost_rd_attr(host_busy
, "%hu\n");
250 shost_rd_attr(cmd_per_lun
, "%hd\n");
251 shost_rd_attr(can_queue
, "%hd\n");
252 shost_rd_attr(sg_tablesize
, "%hu\n");
253 shost_rd_attr(unchecked_isa_dma
, "%d\n");
254 shost_rd_attr(prot_capabilities
, "%u\n");
255 shost_rd_attr(prot_guard_type
, "%hd\n");
256 shost_rd_attr2(proc_name
, hostt
->proc_name
, "%s\n");
258 static struct attribute
*scsi_sysfs_shost_attrs
[] = {
259 &dev_attr_unique_id
.attr
,
260 &dev_attr_host_busy
.attr
,
261 &dev_attr_cmd_per_lun
.attr
,
262 &dev_attr_can_queue
.attr
,
263 &dev_attr_sg_tablesize
.attr
,
264 &dev_attr_unchecked_isa_dma
.attr
,
265 &dev_attr_proc_name
.attr
,
267 &dev_attr_hstate
.attr
,
268 &dev_attr_supported_mode
.attr
,
269 &dev_attr_active_mode
.attr
,
270 &dev_attr_prot_capabilities
.attr
,
271 &dev_attr_prot_guard_type
.attr
,
275 struct attribute_group scsi_shost_attr_group
= {
276 .attrs
= scsi_sysfs_shost_attrs
,
279 const struct attribute_group
*scsi_sysfs_shost_attr_groups
[] = {
280 &scsi_shost_attr_group
,
284 static void scsi_device_cls_release(struct device
*class_dev
)
286 struct scsi_device
*sdev
;
288 sdev
= class_to_sdev(class_dev
);
289 put_device(&sdev
->sdev_gendev
);
292 static void scsi_device_dev_release_usercontext(struct work_struct
*work
)
294 struct scsi_device
*sdev
;
295 struct device
*parent
;
296 struct scsi_target
*starget
;
297 struct list_head
*this, *tmp
;
300 sdev
= container_of(work
, struct scsi_device
, ew
.work
);
302 parent
= sdev
->sdev_gendev
.parent
;
303 starget
= to_scsi_target(parent
);
305 spin_lock_irqsave(sdev
->host
->host_lock
, flags
);
307 list_del(&sdev
->siblings
);
308 list_del(&sdev
->same_target_siblings
);
309 list_del(&sdev
->starved_entry
);
310 spin_unlock_irqrestore(sdev
->host
->host_lock
, flags
);
312 cancel_work_sync(&sdev
->event_work
);
314 list_for_each_safe(this, tmp
, &sdev
->event_list
) {
315 struct scsi_event
*evt
;
317 evt
= list_entry(this, struct scsi_event
, node
);
318 list_del(&evt
->node
);
322 if (sdev
->request_queue
) {
323 sdev
->request_queue
->queuedata
= NULL
;
324 /* user context needed to free queue */
325 scsi_free_queue(sdev
->request_queue
);
326 /* temporary expedient, try to catch use of queue lock
327 * after free of sdev */
328 sdev
->request_queue
= NULL
;
331 scsi_target_reap(scsi_target(sdev
));
333 kfree(sdev
->inquiry
);
340 static void scsi_device_dev_release(struct device
*dev
)
342 struct scsi_device
*sdp
= to_scsi_device(dev
);
343 execute_in_process_context(scsi_device_dev_release_usercontext
,
347 static struct class sdev_class
= {
348 .name
= "scsi_device",
349 .dev_release
= scsi_device_cls_release
,
352 /* all probing is done in the individual ->probe routines */
353 static int scsi_bus_match(struct device
*dev
, struct device_driver
*gendrv
)
355 struct scsi_device
*sdp
;
357 if (dev
->type
!= &scsi_dev_type
)
360 sdp
= to_scsi_device(dev
);
361 if (sdp
->no_uld_attach
)
363 return (sdp
->inq_periph_qual
== SCSI_INQ_PQ_CON
)? 1: 0;
366 static int scsi_bus_uevent(struct device
*dev
, struct kobj_uevent_env
*env
)
368 struct scsi_device
*sdev
;
370 if (dev
->type
!= &scsi_dev_type
)
373 sdev
= to_scsi_device(dev
);
375 add_uevent_var(env
, "MODALIAS=" SCSI_DEVICE_MODALIAS_FMT
, sdev
->type
);
379 static int scsi_bus_suspend(struct device
* dev
, pm_message_t state
)
381 struct device_driver
*drv
;
382 struct scsi_device
*sdev
;
385 if (dev
->type
!= &scsi_dev_type
)
389 sdev
= to_scsi_device(dev
);
391 err
= scsi_device_quiesce(sdev
);
395 if (drv
&& drv
->suspend
) {
396 err
= drv
->suspend(dev
, state
);
404 static int scsi_bus_resume(struct device
* dev
)
406 struct device_driver
*drv
;
407 struct scsi_device
*sdev
;
410 if (dev
->type
!= &scsi_dev_type
)
414 sdev
= to_scsi_device(dev
);
416 if (drv
&& drv
->resume
)
417 err
= drv
->resume(dev
);
419 scsi_device_resume(sdev
);
424 struct bus_type scsi_bus_type
= {
426 .match
= scsi_bus_match
,
427 .uevent
= scsi_bus_uevent
,
428 .suspend
= scsi_bus_suspend
,
429 .resume
= scsi_bus_resume
,
431 EXPORT_SYMBOL_GPL(scsi_bus_type
);
433 int scsi_sysfs_register(void)
437 error
= bus_register(&scsi_bus_type
);
439 error
= class_register(&sdev_class
);
441 bus_unregister(&scsi_bus_type
);
447 void scsi_sysfs_unregister(void)
449 class_unregister(&sdev_class
);
450 bus_unregister(&scsi_bus_type
);
454 * sdev_show_function: macro to create an attr function that can be used to
455 * show a non-bit field.
457 #define sdev_show_function(field, format_string) \
459 sdev_show_##field (struct device *dev, struct device_attribute *attr, \
462 struct scsi_device *sdev; \
463 sdev = to_scsi_device(dev); \
464 return snprintf (buf, 20, format_string, sdev->field); \
468 * sdev_rd_attr: macro to create a function and attribute variable for a
471 #define sdev_rd_attr(field, format_string) \
472 sdev_show_function(field, format_string) \
473 static DEVICE_ATTR(field, S_IRUGO, sdev_show_##field, NULL);
477 * sdev_rd_attr: create a function and attribute variable for a
480 #define sdev_rw_attr(field, format_string) \
481 sdev_show_function(field, format_string) \
484 sdev_store_##field (struct device *dev, struct device_attribute *attr, \
485 const char *buf, size_t count) \
487 struct scsi_device *sdev; \
488 sdev = to_scsi_device(dev); \
489 snscanf (buf, 20, format_string, &sdev->field); \
492 static DEVICE_ATTR(field, S_IRUGO | S_IWUSR, sdev_show_##field, sdev_store_##field);
494 /* Currently we don't export bit fields, but we might in future,
495 * so leave this code in */
498 * sdev_rd_attr: create a function and attribute variable for a
499 * read/write bit field.
501 #define sdev_rw_attr_bit(field) \
502 sdev_show_function(field, "%d\n") \
505 sdev_store_##field (struct device *dev, struct device_attribute *attr, \
506 const char *buf, size_t count) \
509 struct scsi_device *sdev; \
510 ret = scsi_sdev_check_buf_bit(buf); \
512 sdev = to_scsi_device(dev); \
518 static DEVICE_ATTR(field, S_IRUGO | S_IWUSR, sdev_show_##field, sdev_store_##field);
521 * scsi_sdev_check_buf_bit: return 0 if buf is "0", return 1 if buf is "1",
522 * else return -EINVAL.
524 static int scsi_sdev_check_buf_bit(const char *buf
)
526 if ((buf
[1] == '\0') || ((buf
[1] == '\n') && (buf
[2] == '\0'))) {
529 else if (buf
[0] == '0')
538 * Create the actual show/store functions and data structures.
540 sdev_rd_attr (device_blocked
, "%d\n");
541 sdev_rd_attr (queue_depth
, "%d\n");
542 sdev_rd_attr (type
, "%d\n");
543 sdev_rd_attr (scsi_level
, "%d\n");
544 sdev_rd_attr (vendor
, "%.8s\n");
545 sdev_rd_attr (model
, "%.16s\n");
546 sdev_rd_attr (rev
, "%.4s\n");
549 * TODO: can we make these symlinks to the block layer ones?
552 sdev_show_timeout (struct device
*dev
, struct device_attribute
*attr
, char *buf
)
554 struct scsi_device
*sdev
;
555 sdev
= to_scsi_device(dev
);
556 return snprintf(buf
, 20, "%d\n", sdev
->request_queue
->rq_timeout
/ HZ
);
560 sdev_store_timeout (struct device
*dev
, struct device_attribute
*attr
,
561 const char *buf
, size_t count
)
563 struct scsi_device
*sdev
;
565 sdev
= to_scsi_device(dev
);
566 sscanf (buf
, "%d\n", &timeout
);
567 blk_queue_rq_timeout(sdev
->request_queue
, timeout
* HZ
);
570 static DEVICE_ATTR(timeout
, S_IRUGO
| S_IWUSR
, sdev_show_timeout
, sdev_store_timeout
);
573 store_rescan_field (struct device
*dev
, struct device_attribute
*attr
,
574 const char *buf
, size_t count
)
576 scsi_rescan_device(dev
);
579 static DEVICE_ATTR(rescan
, S_IWUSR
, NULL
, store_rescan_field
);
581 static void sdev_store_delete_callback(struct device
*dev
)
583 scsi_remove_device(to_scsi_device(dev
));
587 sdev_store_delete(struct device
*dev
, struct device_attribute
*attr
,
588 const char *buf
, size_t count
)
592 /* An attribute cannot be unregistered by one of its own methods,
593 * so we have to use this roundabout approach.
595 rc
= device_schedule_callback(dev
, sdev_store_delete_callback
);
600 static DEVICE_ATTR(delete, S_IWUSR
, NULL
, sdev_store_delete
);
603 store_state_field(struct device
*dev
, struct device_attribute
*attr
,
604 const char *buf
, size_t count
)
607 struct scsi_device
*sdev
= to_scsi_device(dev
);
608 enum scsi_device_state state
= 0;
610 for (i
= 0; i
< ARRAY_SIZE(sdev_states
); i
++) {
611 const int len
= strlen(sdev_states
[i
].name
);
612 if (strncmp(sdev_states
[i
].name
, buf
, len
) == 0 &&
614 state
= sdev_states
[i
].value
;
621 if (scsi_device_set_state(sdev
, state
))
627 show_state_field(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
629 struct scsi_device
*sdev
= to_scsi_device(dev
);
630 const char *name
= scsi_device_state_name(sdev
->sdev_state
);
635 return snprintf(buf
, 20, "%s\n", name
);
638 static DEVICE_ATTR(state
, S_IRUGO
| S_IWUSR
, show_state_field
, store_state_field
);
641 show_queue_type_field(struct device
*dev
, struct device_attribute
*attr
,
644 struct scsi_device
*sdev
= to_scsi_device(dev
);
645 const char *name
= "none";
647 if (sdev
->ordered_tags
)
649 else if (sdev
->simple_tags
)
652 return snprintf(buf
, 20, "%s\n", name
);
655 static DEVICE_ATTR(queue_type
, S_IRUGO
, show_queue_type_field
, NULL
);
658 show_iostat_counterbits(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
660 return snprintf(buf
, 20, "%d\n", (int)sizeof(atomic_t
) * 8);
663 static DEVICE_ATTR(iocounterbits
, S_IRUGO
, show_iostat_counterbits
, NULL
);
665 #define show_sdev_iostat(field) \
667 show_iostat_##field(struct device *dev, struct device_attribute *attr, \
670 struct scsi_device *sdev = to_scsi_device(dev); \
671 unsigned long long count = atomic_read(&sdev->field); \
672 return snprintf(buf, 20, "0x%llx\n", count); \
674 static DEVICE_ATTR(field, S_IRUGO, show_iostat_##field, NULL)
676 show_sdev_iostat(iorequest_cnt
);
677 show_sdev_iostat(iodone_cnt
);
678 show_sdev_iostat(ioerr_cnt
);
681 sdev_show_modalias(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
683 struct scsi_device
*sdev
;
684 sdev
= to_scsi_device(dev
);
685 return snprintf (buf
, 20, SCSI_DEVICE_MODALIAS_FMT
"\n", sdev
->type
);
687 static DEVICE_ATTR(modalias
, S_IRUGO
, sdev_show_modalias
, NULL
);
689 #define DECLARE_EVT_SHOW(name, Cap_name) \
691 sdev_show_evt_##name(struct device *dev, struct device_attribute *attr, \
694 struct scsi_device *sdev = to_scsi_device(dev); \
695 int val = test_bit(SDEV_EVT_##Cap_name, sdev->supported_events);\
696 return snprintf(buf, 20, "%d\n", val); \
699 #define DECLARE_EVT_STORE(name, Cap_name) \
701 sdev_store_evt_##name(struct device *dev, struct device_attribute *attr,\
702 const char *buf, size_t count) \
704 struct scsi_device *sdev = to_scsi_device(dev); \
705 int val = simple_strtoul(buf, NULL, 0); \
707 clear_bit(SDEV_EVT_##Cap_name, sdev->supported_events); \
709 set_bit(SDEV_EVT_##Cap_name, sdev->supported_events); \
715 #define DECLARE_EVT(name, Cap_name) \
716 DECLARE_EVT_SHOW(name, Cap_name) \
717 DECLARE_EVT_STORE(name, Cap_name) \
718 static DEVICE_ATTR(evt_##name, S_IRUGO, sdev_show_evt_##name, \
719 sdev_store_evt_##name);
720 #define REF_EVT(name) &dev_attr_evt_##name.attr
722 DECLARE_EVT(media_change
, MEDIA_CHANGE
)
724 /* Default template for device attributes. May NOT be modified */
725 static struct attribute
*scsi_sdev_attrs
[] = {
726 &dev_attr_device_blocked
.attr
,
728 &dev_attr_scsi_level
.attr
,
729 &dev_attr_vendor
.attr
,
730 &dev_attr_model
.attr
,
732 &dev_attr_rescan
.attr
,
733 &dev_attr_delete
.attr
,
734 &dev_attr_state
.attr
,
735 &dev_attr_timeout
.attr
,
736 &dev_attr_iocounterbits
.attr
,
737 &dev_attr_iorequest_cnt
.attr
,
738 &dev_attr_iodone_cnt
.attr
,
739 &dev_attr_ioerr_cnt
.attr
,
740 &dev_attr_modalias
.attr
,
741 REF_EVT(media_change
),
745 static struct attribute_group scsi_sdev_attr_group
= {
746 .attrs
= scsi_sdev_attrs
,
749 static const struct attribute_group
*scsi_sdev_attr_groups
[] = {
750 &scsi_sdev_attr_group
,
755 sdev_store_queue_depth_rw(struct device
*dev
, struct device_attribute
*attr
,
756 const char *buf
, size_t count
)
759 struct scsi_device
*sdev
= to_scsi_device(dev
);
760 struct scsi_host_template
*sht
= sdev
->host
->hostt
;
762 if (!sht
->change_queue_depth
)
765 depth
= simple_strtoul(buf
, NULL
, 0);
770 retval
= sht
->change_queue_depth(sdev
, depth
,
771 SCSI_QDEPTH_DEFAULT
);
775 sdev
->max_queue_depth
= sdev
->queue_depth
;
780 static struct device_attribute sdev_attr_queue_depth_rw
=
781 __ATTR(queue_depth
, S_IRUGO
| S_IWUSR
, sdev_show_queue_depth
,
782 sdev_store_queue_depth_rw
);
785 sdev_show_queue_ramp_up_period(struct device
*dev
,
786 struct device_attribute
*attr
,
789 struct scsi_device
*sdev
;
790 sdev
= to_scsi_device(dev
);
791 return snprintf(buf
, 20, "%u\n",
792 jiffies_to_msecs(sdev
->queue_ramp_up_period
));
796 sdev_store_queue_ramp_up_period(struct device
*dev
,
797 struct device_attribute
*attr
,
798 const char *buf
, size_t count
)
800 struct scsi_device
*sdev
= to_scsi_device(dev
);
801 unsigned long period
;
803 if (strict_strtoul(buf
, 10, &period
))
806 sdev
->queue_ramp_up_period
= msecs_to_jiffies(period
);
810 static struct device_attribute sdev_attr_queue_ramp_up_period
=
811 __ATTR(queue_ramp_up_period
, S_IRUGO
| S_IWUSR
,
812 sdev_show_queue_ramp_up_period
,
813 sdev_store_queue_ramp_up_period
);
816 sdev_store_queue_type_rw(struct device
*dev
, struct device_attribute
*attr
,
817 const char *buf
, size_t count
)
819 struct scsi_device
*sdev
= to_scsi_device(dev
);
820 struct scsi_host_template
*sht
= sdev
->host
->hostt
;
821 int tag_type
= 0, retval
;
822 int prev_tag_type
= scsi_get_tag_type(sdev
);
824 if (!sdev
->tagged_supported
|| !sht
->change_queue_type
)
827 if (strncmp(buf
, "ordered", 7) == 0)
828 tag_type
= MSG_ORDERED_TAG
;
829 else if (strncmp(buf
, "simple", 6) == 0)
830 tag_type
= MSG_SIMPLE_TAG
;
831 else if (strncmp(buf
, "none", 4) != 0)
834 if (tag_type
== prev_tag_type
)
837 retval
= sht
->change_queue_type(sdev
, tag_type
);
844 static int scsi_target_add(struct scsi_target
*starget
)
848 if (starget
->state
!= STARGET_CREATED
)
851 device_enable_async_suspend(&starget
->dev
);
853 error
= device_add(&starget
->dev
);
855 dev_err(&starget
->dev
, "target device_add failed, error %d\n", error
);
856 get_device(&starget
->dev
);
857 scsi_target_reap(starget
);
858 put_device(&starget
->dev
);
861 transport_add_device(&starget
->dev
);
862 starget
->state
= STARGET_RUNNING
;
867 static struct device_attribute sdev_attr_queue_type_rw
=
868 __ATTR(queue_type
, S_IRUGO
| S_IWUSR
, show_queue_type_field
,
869 sdev_store_queue_type_rw
);
872 * scsi_sysfs_add_sdev - add scsi device to sysfs
873 * @sdev: scsi_device to add
876 * 0 on Success / non-zero on Failure
878 int scsi_sysfs_add_sdev(struct scsi_device
*sdev
)
881 struct request_queue
*rq
= sdev
->request_queue
;
882 struct scsi_target
*starget
= sdev
->sdev_target
;
884 error
= scsi_device_set_state(sdev
, SDEV_RUNNING
);
888 error
= scsi_target_add(starget
);
892 transport_configure_device(&starget
->dev
);
893 device_enable_async_suspend(&sdev
->sdev_gendev
);
894 error
= device_add(&sdev
->sdev_gendev
);
896 printk(KERN_INFO
"error 1\n");
899 device_enable_async_suspend(&sdev
->sdev_dev
);
900 error
= device_add(&sdev
->sdev_dev
);
902 printk(KERN_INFO
"error 2\n");
903 device_del(&sdev
->sdev_gendev
);
906 transport_add_device(&sdev
->sdev_gendev
);
907 sdev
->is_visible
= 1;
909 /* create queue files, which may be writable, depending on the host */
910 if (sdev
->host
->hostt
->change_queue_depth
) {
911 error
= device_create_file(&sdev
->sdev_gendev
,
912 &sdev_attr_queue_depth_rw
);
913 error
= device_create_file(&sdev
->sdev_gendev
,
914 &sdev_attr_queue_ramp_up_period
);
917 error
= device_create_file(&sdev
->sdev_gendev
, &dev_attr_queue_depth
);
921 if (sdev
->host
->hostt
->change_queue_type
)
922 error
= device_create_file(&sdev
->sdev_gendev
, &sdev_attr_queue_type_rw
);
924 error
= device_create_file(&sdev
->sdev_gendev
, &dev_attr_queue_type
);
928 error
= bsg_register_queue(rq
, &sdev
->sdev_gendev
, NULL
, NULL
);
931 /* we're treating error on bsg register as non-fatal,
932 * so pretend nothing went wrong */
933 sdev_printk(KERN_INFO
, sdev
,
934 "Failed to register bsg queue, errno=%d\n", error
);
936 /* add additional host specific attributes */
937 if (sdev
->host
->hostt
->sdev_attrs
) {
938 for (i
= 0; sdev
->host
->hostt
->sdev_attrs
[i
]; i
++) {
939 error
= device_create_file(&sdev
->sdev_gendev
,
940 sdev
->host
->hostt
->sdev_attrs
[i
]);
949 void __scsi_remove_device(struct scsi_device
*sdev
)
951 struct device
*dev
= &sdev
->sdev_gendev
;
953 if (sdev
->is_visible
) {
954 if (scsi_device_set_state(sdev
, SDEV_CANCEL
) != 0)
957 bsg_unregister_queue(sdev
->request_queue
);
958 device_unregister(&sdev
->sdev_dev
);
959 transport_remove_device(dev
);
962 put_device(&sdev
->sdev_dev
);
963 scsi_device_set_state(sdev
, SDEV_DEL
);
964 if (sdev
->host
->hostt
->slave_destroy
)
965 sdev
->host
->hostt
->slave_destroy(sdev
);
966 transport_destroy_device(dev
);
971 * scsi_remove_device - unregister a device from the scsi bus
972 * @sdev: scsi_device to unregister
974 void scsi_remove_device(struct scsi_device
*sdev
)
976 struct Scsi_Host
*shost
= sdev
->host
;
978 mutex_lock(&shost
->scan_mutex
);
979 __scsi_remove_device(sdev
);
980 mutex_unlock(&shost
->scan_mutex
);
982 EXPORT_SYMBOL(scsi_remove_device
);
984 static void __scsi_remove_target(struct scsi_target
*starget
)
986 struct Scsi_Host
*shost
= dev_to_shost(starget
->dev
.parent
);
988 struct scsi_device
*sdev
;
990 spin_lock_irqsave(shost
->host_lock
, flags
);
993 list_for_each_entry(sdev
, &shost
->__devices
, siblings
) {
994 if (sdev
->channel
!= starget
->channel
||
995 sdev
->id
!= starget
->id
||
996 sdev
->sdev_state
== SDEV_DEL
)
998 spin_unlock_irqrestore(shost
->host_lock
, flags
);
999 scsi_remove_device(sdev
);
1000 spin_lock_irqsave(shost
->host_lock
, flags
);
1003 spin_unlock_irqrestore(shost
->host_lock
, flags
);
1004 scsi_target_reap(starget
);
1007 static int __remove_child (struct device
* dev
, void * data
)
1009 if (scsi_is_target_device(dev
))
1010 __scsi_remove_target(to_scsi_target(dev
));
1015 * scsi_remove_target - try to remove a target and all its devices
1016 * @dev: generic starget or parent of generic stargets to be removed
1018 * Note: This is slightly racy. It is possible that if the user
1019 * requests the addition of another device then the target won't be
1022 void scsi_remove_target(struct device
*dev
)
1024 struct device
*rdev
;
1026 if (scsi_is_target_device(dev
)) {
1027 __scsi_remove_target(to_scsi_target(dev
));
1031 rdev
= get_device(dev
);
1032 device_for_each_child(dev
, NULL
, __remove_child
);
1035 EXPORT_SYMBOL(scsi_remove_target
);
1037 int scsi_register_driver(struct device_driver
*drv
)
1039 drv
->bus
= &scsi_bus_type
;
1041 return driver_register(drv
);
1043 EXPORT_SYMBOL(scsi_register_driver
);
1045 int scsi_register_interface(struct class_interface
*intf
)
1047 intf
->class = &sdev_class
;
1049 return class_interface_register(intf
);
1051 EXPORT_SYMBOL(scsi_register_interface
);
1054 * scsi_sysfs_add_host - add scsi host to subsystem
1055 * @shost: scsi host struct to add to subsystem
1057 int scsi_sysfs_add_host(struct Scsi_Host
*shost
)
1061 /* add host specific attributes */
1062 if (shost
->hostt
->shost_attrs
) {
1063 for (i
= 0; shost
->hostt
->shost_attrs
[i
]; i
++) {
1064 error
= device_create_file(&shost
->shost_dev
,
1065 shost
->hostt
->shost_attrs
[i
]);
1071 transport_register_device(&shost
->shost_gendev
);
1072 transport_configure_device(&shost
->shost_gendev
);
1076 static struct device_type scsi_dev_type
= {
1077 .name
= "scsi_device",
1078 .release
= scsi_device_dev_release
,
1079 .groups
= scsi_sdev_attr_groups
,
1082 void scsi_sysfs_device_initialize(struct scsi_device
*sdev
)
1084 unsigned long flags
;
1085 struct Scsi_Host
*shost
= sdev
->host
;
1086 struct scsi_target
*starget
= sdev
->sdev_target
;
1088 device_initialize(&sdev
->sdev_gendev
);
1089 sdev
->sdev_gendev
.bus
= &scsi_bus_type
;
1090 sdev
->sdev_gendev
.type
= &scsi_dev_type
;
1091 dev_set_name(&sdev
->sdev_gendev
, "%d:%d:%d:%d",
1092 sdev
->host
->host_no
, sdev
->channel
, sdev
->id
, sdev
->lun
);
1094 device_initialize(&sdev
->sdev_dev
);
1095 sdev
->sdev_dev
.parent
= get_device(&sdev
->sdev_gendev
);
1096 sdev
->sdev_dev
.class = &sdev_class
;
1097 dev_set_name(&sdev
->sdev_dev
, "%d:%d:%d:%d",
1098 sdev
->host
->host_no
, sdev
->channel
, sdev
->id
, sdev
->lun
);
1099 sdev
->scsi_level
= starget
->scsi_level
;
1100 transport_setup_device(&sdev
->sdev_gendev
);
1101 spin_lock_irqsave(shost
->host_lock
, flags
);
1102 list_add_tail(&sdev
->same_target_siblings
, &starget
->devices
);
1103 list_add_tail(&sdev
->siblings
, &shost
->__devices
);
1104 spin_unlock_irqrestore(shost
->host_lock
, flags
);
1107 int scsi_is_sdev_device(const struct device
*dev
)
1109 return dev
->type
== &scsi_dev_type
;
1111 EXPORT_SYMBOL(scsi_is_sdev_device
);
1113 /* A blank transport template that is used in drivers that don't
1114 * yet implement Transport Attributes */
1115 struct scsi_transport_template blank_transport_template
= { { { {NULL
, }, }, }, };