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/init.h>
11 #include <linux/blkdev.h>
12 #include <linux/device.h>
14 #include <scsi/scsi.h>
15 #include <scsi/scsi_device.h>
16 #include <scsi/scsi_host.h>
17 #include <scsi/scsi_tcq.h>
18 #include <scsi/scsi_transport.h>
20 #include "scsi_priv.h"
21 #include "scsi_logging.h"
24 enum scsi_device_state value
;
27 { SDEV_CREATED
, "created" },
28 { SDEV_RUNNING
, "running" },
29 { SDEV_CANCEL
, "cancel" },
30 { SDEV_DEL
, "deleted" },
31 { SDEV_QUIESCE
, "quiesce" },
32 { SDEV_OFFLINE
, "offline" },
33 { SDEV_BLOCK
, "blocked" },
36 const char *scsi_device_state_name(enum scsi_device_state state
)
41 for (i
= 0; i
< ARRAY_SIZE(sdev_states
); i
++) {
42 if (sdev_states
[i
].value
== state
) {
43 name
= sdev_states
[i
].name
;
51 enum scsi_host_state value
;
54 { SHOST_CREATED
, "created" },
55 { SHOST_RUNNING
, "running" },
56 { SHOST_CANCEL
, "cancel" },
57 { SHOST_DEL
, "deleted" },
58 { SHOST_RECOVERY
, "recovery" },
59 { SHOST_CANCEL_RECOVERY
, "cancel/recovery" },
60 { SHOST_DEL_RECOVERY
, "deleted/recovery", },
62 const char *scsi_host_state_name(enum scsi_host_state state
)
67 for (i
= 0; i
< ARRAY_SIZE(shost_states
); i
++) {
68 if (shost_states
[i
].value
== state
) {
69 name
= shost_states
[i
].name
;
76 static int check_set(unsigned int *val
, char *src
)
80 if (strncmp(src
, "-", 20) == 0) {
81 *val
= SCAN_WILD_CARD
;
84 * Doesn't check for int overflow
86 *val
= simple_strtoul(src
, &last
, 0);
93 static int scsi_scan(struct Scsi_Host
*shost
, const char *str
)
95 char s1
[15], s2
[15], s3
[15], junk
;
96 unsigned int channel
, id
, lun
;
99 res
= sscanf(str
, "%10s %10s %10s %c", s1
, s2
, s3
, &junk
);
102 if (check_set(&channel
, s1
))
104 if (check_set(&id
, s2
))
106 if (check_set(&lun
, s3
))
108 if (shost
->transportt
->user_scan
)
109 res
= shost
->transportt
->user_scan(shost
, channel
, id
, lun
);
111 res
= scsi_scan_host_selected(shost
, channel
, id
, lun
, 1);
116 * shost_show_function: macro to create an attr function that can be used to
117 * show a non-bit field.
119 #define shost_show_function(name, field, format_string) \
121 show_##name (struct class_device *class_dev, char *buf) \
123 struct Scsi_Host *shost = class_to_shost(class_dev); \
124 return snprintf (buf, 20, format_string, shost->field); \
128 * shost_rd_attr: macro to create a function and attribute variable for a
131 #define shost_rd_attr2(name, field, format_string) \
132 shost_show_function(name, field, format_string) \
133 static CLASS_DEVICE_ATTR(name, S_IRUGO, show_##name, NULL);
135 #define shost_rd_attr(field, format_string) \
136 shost_rd_attr2(field, field, format_string)
139 * Create the actual show/store functions and data structures.
142 static ssize_t
store_scan(struct class_device
*class_dev
, const char *buf
,
145 struct Scsi_Host
*shost
= class_to_shost(class_dev
);
148 res
= scsi_scan(shost
, buf
);
153 static CLASS_DEVICE_ATTR(scan
, S_IWUSR
, NULL
, store_scan
);
156 store_shost_state(struct class_device
*class_dev
, const char *buf
, size_t count
)
159 struct Scsi_Host
*shost
= class_to_shost(class_dev
);
160 enum scsi_host_state state
= 0;
162 for (i
= 0; i
< ARRAY_SIZE(shost_states
); i
++) {
163 const int len
= strlen(shost_states
[i
].name
);
164 if (strncmp(shost_states
[i
].name
, buf
, len
) == 0 &&
166 state
= shost_states
[i
].value
;
173 if (scsi_host_set_state(shost
, state
))
179 show_shost_state(struct class_device
*class_dev
, char *buf
)
181 struct Scsi_Host
*shost
= class_to_shost(class_dev
);
182 const char *name
= scsi_host_state_name(shost
->shost_state
);
187 return snprintf(buf
, 20, "%s\n", name
);
190 static CLASS_DEVICE_ATTR(state
, S_IRUGO
| S_IWUSR
, show_shost_state
, store_shost_state
);
192 shost_rd_attr(unique_id
, "%u\n");
193 shost_rd_attr(host_busy
, "%hu\n");
194 shost_rd_attr(cmd_per_lun
, "%hd\n");
195 shost_rd_attr(can_queue
, "%hd\n");
196 shost_rd_attr(sg_tablesize
, "%hu\n");
197 shost_rd_attr(unchecked_isa_dma
, "%d\n");
198 shost_rd_attr2(proc_name
, hostt
->proc_name
, "%s\n");
200 static struct class_device_attribute
*scsi_sysfs_shost_attrs
[] = {
201 &class_device_attr_unique_id
,
202 &class_device_attr_host_busy
,
203 &class_device_attr_cmd_per_lun
,
204 &class_device_attr_can_queue
,
205 &class_device_attr_sg_tablesize
,
206 &class_device_attr_unchecked_isa_dma
,
207 &class_device_attr_proc_name
,
208 &class_device_attr_scan
,
209 &class_device_attr_state
,
213 static void scsi_device_cls_release(struct class_device
*class_dev
)
215 struct scsi_device
*sdev
;
217 sdev
= class_to_sdev(class_dev
);
218 put_device(&sdev
->sdev_gendev
);
221 static void scsi_device_dev_release_usercontext(struct work_struct
*work
)
223 struct scsi_device
*sdev
;
224 struct device
*parent
;
225 struct scsi_target
*starget
;
228 sdev
= container_of(work
, struct scsi_device
, ew
.work
);
230 parent
= sdev
->sdev_gendev
.parent
;
231 starget
= to_scsi_target(parent
);
233 spin_lock_irqsave(sdev
->host
->host_lock
, flags
);
235 list_del(&sdev
->siblings
);
236 list_del(&sdev
->same_target_siblings
);
237 list_del(&sdev
->starved_entry
);
238 spin_unlock_irqrestore(sdev
->host
->host_lock
, flags
);
240 if (sdev
->request_queue
) {
241 sdev
->request_queue
->queuedata
= NULL
;
242 /* user context needed to free queue */
243 scsi_free_queue(sdev
->request_queue
);
244 /* temporary expedient, try to catch use of queue lock
245 * after free of sdev */
246 sdev
->request_queue
= NULL
;
249 scsi_target_reap(scsi_target(sdev
));
251 kfree(sdev
->inquiry
);
258 static void scsi_device_dev_release(struct device
*dev
)
260 struct scsi_device
*sdp
= to_scsi_device(dev
);
261 execute_in_process_context(scsi_device_dev_release_usercontext
,
265 static struct class sdev_class
= {
266 .name
= "scsi_device",
267 .release
= scsi_device_cls_release
,
270 /* all probing is done in the individual ->probe routines */
271 static int scsi_bus_match(struct device
*dev
, struct device_driver
*gendrv
)
273 struct scsi_device
*sdp
= to_scsi_device(dev
);
274 if (sdp
->no_uld_attach
)
276 return (sdp
->inq_periph_qual
== SCSI_INQ_PQ_CON
)? 1: 0;
279 static int scsi_bus_uevent(struct device
*dev
, char **envp
, int num_envp
,
280 char *buffer
, int buffer_size
)
282 struct scsi_device
*sdev
= to_scsi_device(dev
);
286 add_uevent_var(envp
, num_envp
, &i
, buffer
, buffer_size
, &length
,
287 "MODALIAS=" SCSI_DEVICE_MODALIAS_FMT
, sdev
->type
);
292 static int scsi_bus_suspend(struct device
* dev
, pm_message_t state
)
294 struct device_driver
*drv
= dev
->driver
;
295 struct scsi_device
*sdev
= to_scsi_device(dev
);
298 err
= scsi_device_quiesce(sdev
);
302 if (drv
&& drv
->suspend
) {
303 err
= drv
->suspend(dev
, state
);
311 static int scsi_bus_resume(struct device
* dev
)
313 struct device_driver
*drv
= dev
->driver
;
314 struct scsi_device
*sdev
= to_scsi_device(dev
);
317 if (drv
&& drv
->resume
)
318 err
= drv
->resume(dev
);
320 scsi_device_resume(sdev
);
325 struct bus_type scsi_bus_type
= {
327 .match
= scsi_bus_match
,
328 .uevent
= scsi_bus_uevent
,
329 .suspend
= scsi_bus_suspend
,
330 .resume
= scsi_bus_resume
,
333 int scsi_sysfs_register(void)
337 error
= bus_register(&scsi_bus_type
);
339 error
= class_register(&sdev_class
);
341 bus_unregister(&scsi_bus_type
);
347 void scsi_sysfs_unregister(void)
349 class_unregister(&sdev_class
);
350 bus_unregister(&scsi_bus_type
);
354 * sdev_show_function: macro to create an attr function that can be used to
355 * show a non-bit field.
357 #define sdev_show_function(field, format_string) \
359 sdev_show_##field (struct device *dev, struct device_attribute *attr, char *buf) \
361 struct scsi_device *sdev; \
362 sdev = to_scsi_device(dev); \
363 return snprintf (buf, 20, format_string, sdev->field); \
367 * sdev_rd_attr: macro to create a function and attribute variable for a
370 #define sdev_rd_attr(field, format_string) \
371 sdev_show_function(field, format_string) \
372 static DEVICE_ATTR(field, S_IRUGO, sdev_show_##field, NULL);
376 * sdev_rd_attr: create a function and attribute variable for a
379 #define sdev_rw_attr(field, format_string) \
380 sdev_show_function(field, format_string) \
383 sdev_store_##field (struct device *dev, struct device_attribute *attr, const char *buf, size_t count) \
385 struct scsi_device *sdev; \
386 sdev = to_scsi_device(dev); \
387 snscanf (buf, 20, format_string, &sdev->field); \
390 static DEVICE_ATTR(field, S_IRUGO | S_IWUSR, sdev_show_##field, sdev_store_##field);
392 /* Currently we don't export bit fields, but we might in future,
393 * so leave this code in */
396 * sdev_rd_attr: create a function and attribute variable for a
397 * read/write bit field.
399 #define sdev_rw_attr_bit(field) \
400 sdev_show_function(field, "%d\n") \
403 sdev_store_##field (struct device *dev, struct device_attribute *attr, const char *buf, size_t count) \
406 struct scsi_device *sdev; \
407 ret = scsi_sdev_check_buf_bit(buf); \
409 sdev = to_scsi_device(dev); \
415 static DEVICE_ATTR(field, S_IRUGO | S_IWUSR, sdev_show_##field, sdev_store_##field);
418 * scsi_sdev_check_buf_bit: return 0 if buf is "0", return 1 if buf is "1",
419 * else return -EINVAL.
421 static int scsi_sdev_check_buf_bit(const char *buf
)
423 if ((buf
[1] == '\0') || ((buf
[1] == '\n') && (buf
[2] == '\0'))) {
426 else if (buf
[0] == '0')
435 * Create the actual show/store functions and data structures.
437 sdev_rd_attr (device_blocked
, "%d\n");
438 sdev_rd_attr (queue_depth
, "%d\n");
439 sdev_rd_attr (type
, "%d\n");
440 sdev_rd_attr (scsi_level
, "%d\n");
441 sdev_rd_attr (vendor
, "%.8s\n");
442 sdev_rd_attr (model
, "%.16s\n");
443 sdev_rd_attr (rev
, "%.4s\n");
446 sdev_show_timeout (struct device
*dev
, struct device_attribute
*attr
, char *buf
)
448 struct scsi_device
*sdev
;
449 sdev
= to_scsi_device(dev
);
450 return snprintf (buf
, 20, "%d\n", sdev
->timeout
/ HZ
);
454 sdev_store_timeout (struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
456 struct scsi_device
*sdev
;
458 sdev
= to_scsi_device(dev
);
459 sscanf (buf
, "%d\n", &timeout
);
460 sdev
->timeout
= timeout
* HZ
;
463 static DEVICE_ATTR(timeout
, S_IRUGO
| S_IWUSR
, sdev_show_timeout
, sdev_store_timeout
);
466 store_rescan_field (struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
468 scsi_rescan_device(dev
);
471 static DEVICE_ATTR(rescan
, S_IWUSR
, NULL
, store_rescan_field
);
473 static void sdev_store_delete_callback(struct device
*dev
)
475 scsi_remove_device(to_scsi_device(dev
));
478 static ssize_t
sdev_store_delete(struct device
*dev
, struct device_attribute
*attr
, const char *buf
,
483 /* An attribute cannot be unregistered by one of its own methods,
484 * so we have to use this roundabout approach.
486 rc
= device_schedule_callback(dev
, sdev_store_delete_callback
);
491 static DEVICE_ATTR(delete, S_IWUSR
, NULL
, sdev_store_delete
);
494 store_state_field(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
497 struct scsi_device
*sdev
= to_scsi_device(dev
);
498 enum scsi_device_state state
= 0;
500 for (i
= 0; i
< ARRAY_SIZE(sdev_states
); i
++) {
501 const int len
= strlen(sdev_states
[i
].name
);
502 if (strncmp(sdev_states
[i
].name
, buf
, len
) == 0 &&
504 state
= sdev_states
[i
].value
;
511 if (scsi_device_set_state(sdev
, state
))
517 show_state_field(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
519 struct scsi_device
*sdev
= to_scsi_device(dev
);
520 const char *name
= scsi_device_state_name(sdev
->sdev_state
);
525 return snprintf(buf
, 20, "%s\n", name
);
528 static DEVICE_ATTR(state
, S_IRUGO
| S_IWUSR
, show_state_field
, store_state_field
);
531 show_queue_type_field(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
533 struct scsi_device
*sdev
= to_scsi_device(dev
);
534 const char *name
= "none";
536 if (sdev
->ordered_tags
)
538 else if (sdev
->simple_tags
)
541 return snprintf(buf
, 20, "%s\n", name
);
544 static DEVICE_ATTR(queue_type
, S_IRUGO
, show_queue_type_field
, NULL
);
547 show_iostat_counterbits(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
549 return snprintf(buf
, 20, "%d\n", (int)sizeof(atomic_t
) * 8);
552 static DEVICE_ATTR(iocounterbits
, S_IRUGO
, show_iostat_counterbits
, NULL
);
554 #define show_sdev_iostat(field) \
556 show_iostat_##field(struct device *dev, struct device_attribute *attr, char *buf) \
558 struct scsi_device *sdev = to_scsi_device(dev); \
559 unsigned long long count = atomic_read(&sdev->field); \
560 return snprintf(buf, 20, "0x%llx\n", count); \
562 static DEVICE_ATTR(field, S_IRUGO, show_iostat_##field, NULL)
564 show_sdev_iostat(iorequest_cnt
);
565 show_sdev_iostat(iodone_cnt
);
566 show_sdev_iostat(ioerr_cnt
);
569 sdev_show_modalias(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
571 struct scsi_device
*sdev
;
572 sdev
= to_scsi_device(dev
);
573 return snprintf (buf
, 20, SCSI_DEVICE_MODALIAS_FMT
"\n", sdev
->type
);
575 static DEVICE_ATTR(modalias
, S_IRUGO
, sdev_show_modalias
, NULL
);
577 /* Default template for device attributes. May NOT be modified */
578 static struct device_attribute
*scsi_sysfs_sdev_attrs
[] = {
579 &dev_attr_device_blocked
,
580 &dev_attr_queue_depth
,
581 &dev_attr_queue_type
,
583 &dev_attr_scsi_level
,
591 &dev_attr_iocounterbits
,
592 &dev_attr_iorequest_cnt
,
593 &dev_attr_iodone_cnt
,
599 static ssize_t
sdev_store_queue_depth_rw(struct device
*dev
, struct device_attribute
*attr
, const char *buf
,
603 struct scsi_device
*sdev
= to_scsi_device(dev
);
604 struct scsi_host_template
*sht
= sdev
->host
->hostt
;
606 if (!sht
->change_queue_depth
)
609 depth
= simple_strtoul(buf
, NULL
, 0);
614 retval
= sht
->change_queue_depth(sdev
, depth
);
621 static struct device_attribute sdev_attr_queue_depth_rw
=
622 __ATTR(queue_depth
, S_IRUGO
| S_IWUSR
, sdev_show_queue_depth
,
623 sdev_store_queue_depth_rw
);
625 static ssize_t
sdev_store_queue_type_rw(struct device
*dev
, struct device_attribute
*attr
, const char *buf
,
628 struct scsi_device
*sdev
= to_scsi_device(dev
);
629 struct scsi_host_template
*sht
= sdev
->host
->hostt
;
630 int tag_type
= 0, retval
;
631 int prev_tag_type
= scsi_get_tag_type(sdev
);
633 if (!sdev
->tagged_supported
|| !sht
->change_queue_type
)
636 if (strncmp(buf
, "ordered", 7) == 0)
637 tag_type
= MSG_ORDERED_TAG
;
638 else if (strncmp(buf
, "simple", 6) == 0)
639 tag_type
= MSG_SIMPLE_TAG
;
640 else if (strncmp(buf
, "none", 4) != 0)
643 if (tag_type
== prev_tag_type
)
646 retval
= sht
->change_queue_type(sdev
, tag_type
);
653 static struct device_attribute sdev_attr_queue_type_rw
=
654 __ATTR(queue_type
, S_IRUGO
| S_IWUSR
, show_queue_type_field
,
655 sdev_store_queue_type_rw
);
657 static struct device_attribute
*attr_changed_internally(
658 struct Scsi_Host
*shost
,
659 struct device_attribute
* attr
)
661 if (!strcmp("queue_depth", attr
->attr
.name
)
662 && shost
->hostt
->change_queue_depth
)
663 return &sdev_attr_queue_depth_rw
;
664 else if (!strcmp("queue_type", attr
->attr
.name
)
665 && shost
->hostt
->change_queue_type
)
666 return &sdev_attr_queue_type_rw
;
671 static struct device_attribute
*attr_overridden(
672 struct device_attribute
**attrs
,
673 struct device_attribute
*attr
)
679 for (i
= 0; attrs
[i
]; i
++)
680 if (!strcmp(attrs
[i
]->attr
.name
, attr
->attr
.name
))
685 static int attr_add(struct device
*dev
, struct device_attribute
*attr
)
687 struct device_attribute
*base_attr
;
690 * Spare the caller from having to copy things it's not interested in.
692 base_attr
= attr_overridden(scsi_sysfs_sdev_attrs
, attr
);
694 /* extend permissions */
695 attr
->attr
.mode
|= base_attr
->attr
.mode
;
697 /* override null show/store with default */
699 attr
->show
= base_attr
->show
;
701 attr
->store
= base_attr
->store
;
704 return device_create_file(dev
, attr
);
708 * scsi_sysfs_add_sdev - add scsi device to sysfs
709 * @sdev: scsi_device to add
712 * 0 on Success / non-zero on Failure
714 int scsi_sysfs_add_sdev(struct scsi_device
*sdev
)
718 if ((error
= scsi_device_set_state(sdev
, SDEV_RUNNING
)) != 0)
721 error
= device_add(&sdev
->sdev_gendev
);
723 put_device(sdev
->sdev_gendev
.parent
);
724 printk(KERN_INFO
"error 1\n");
727 error
= class_device_add(&sdev
->sdev_classdev
);
729 printk(KERN_INFO
"error 2\n");
733 /* take a reference for the sdev_classdev; this is
734 * released by the sdev_class .release */
735 get_device(&sdev
->sdev_gendev
);
736 if (sdev
->host
->hostt
->sdev_attrs
) {
737 for (i
= 0; sdev
->host
->hostt
->sdev_attrs
[i
]; i
++) {
738 error
= attr_add(&sdev
->sdev_gendev
,
739 sdev
->host
->hostt
->sdev_attrs
[i
]);
741 __scsi_remove_device(sdev
);
747 for (i
= 0; scsi_sysfs_sdev_attrs
[i
]; i
++) {
748 if (!attr_overridden(sdev
->host
->hostt
->sdev_attrs
,
749 scsi_sysfs_sdev_attrs
[i
])) {
750 struct device_attribute
* attr
=
751 attr_changed_internally(sdev
->host
,
752 scsi_sysfs_sdev_attrs
[i
]);
753 error
= device_create_file(&sdev
->sdev_gendev
, attr
);
755 __scsi_remove_device(sdev
);
761 transport_add_device(&sdev
->sdev_gendev
);
766 scsi_device_set_state(sdev
, SDEV_CANCEL
);
768 device_del(&sdev
->sdev_gendev
);
769 transport_destroy_device(&sdev
->sdev_gendev
);
770 put_device(&sdev
->sdev_gendev
);
775 void __scsi_remove_device(struct scsi_device
*sdev
)
777 struct device
*dev
= &sdev
->sdev_gendev
;
779 if (scsi_device_set_state(sdev
, SDEV_CANCEL
) != 0)
782 class_device_unregister(&sdev
->sdev_classdev
);
783 transport_remove_device(dev
);
785 scsi_device_set_state(sdev
, SDEV_DEL
);
786 if (sdev
->host
->hostt
->slave_destroy
)
787 sdev
->host
->hostt
->slave_destroy(sdev
);
788 transport_destroy_device(dev
);
793 * scsi_remove_device - unregister a device from the scsi bus
794 * @sdev: scsi_device to unregister
796 void scsi_remove_device(struct scsi_device
*sdev
)
798 struct Scsi_Host
*shost
= sdev
->host
;
800 mutex_lock(&shost
->scan_mutex
);
801 __scsi_remove_device(sdev
);
802 mutex_unlock(&shost
->scan_mutex
);
804 EXPORT_SYMBOL(scsi_remove_device
);
806 void __scsi_remove_target(struct scsi_target
*starget
)
808 struct Scsi_Host
*shost
= dev_to_shost(starget
->dev
.parent
);
810 struct scsi_device
*sdev
;
812 spin_lock_irqsave(shost
->host_lock
, flags
);
815 list_for_each_entry(sdev
, &shost
->__devices
, siblings
) {
816 if (sdev
->channel
!= starget
->channel
||
817 sdev
->id
!= starget
->id
||
818 sdev
->sdev_state
== SDEV_DEL
)
820 spin_unlock_irqrestore(shost
->host_lock
, flags
);
821 scsi_remove_device(sdev
);
822 spin_lock_irqsave(shost
->host_lock
, flags
);
825 spin_unlock_irqrestore(shost
->host_lock
, flags
);
826 scsi_target_reap(starget
);
829 static int __remove_child (struct device
* dev
, void * data
)
831 if (scsi_is_target_device(dev
))
832 __scsi_remove_target(to_scsi_target(dev
));
837 * scsi_remove_target - try to remove a target and all its devices
838 * @dev: generic starget or parent of generic stargets to be removed
840 * Note: This is slightly racy. It is possible that if the user
841 * requests the addition of another device then the target won't be
844 void scsi_remove_target(struct device
*dev
)
848 if (scsi_is_target_device(dev
)) {
849 __scsi_remove_target(to_scsi_target(dev
));
853 rdev
= get_device(dev
);
854 device_for_each_child(dev
, NULL
, __remove_child
);
857 EXPORT_SYMBOL(scsi_remove_target
);
859 int scsi_register_driver(struct device_driver
*drv
)
861 drv
->bus
= &scsi_bus_type
;
863 return driver_register(drv
);
865 EXPORT_SYMBOL(scsi_register_driver
);
867 int scsi_register_interface(struct class_interface
*intf
)
869 intf
->class = &sdev_class
;
871 return class_interface_register(intf
);
873 EXPORT_SYMBOL(scsi_register_interface
);
876 static struct class_device_attribute
*class_attr_overridden(
877 struct class_device_attribute
**attrs
,
878 struct class_device_attribute
*attr
)
884 for (i
= 0; attrs
[i
]; i
++)
885 if (!strcmp(attrs
[i
]->attr
.name
, attr
->attr
.name
))
890 static int class_attr_add(struct class_device
*classdev
,
891 struct class_device_attribute
*attr
)
893 struct class_device_attribute
*base_attr
;
896 * Spare the caller from having to copy things it's not interested in.
898 base_attr
= class_attr_overridden(scsi_sysfs_shost_attrs
, attr
);
900 /* extend permissions */
901 attr
->attr
.mode
|= base_attr
->attr
.mode
;
903 /* override null show/store with default */
905 attr
->show
= base_attr
->show
;
907 attr
->store
= base_attr
->store
;
910 return class_device_create_file(classdev
, attr
);
914 * scsi_sysfs_add_host - add scsi host to subsystem
915 * @shost: scsi host struct to add to subsystem
916 * @dev: parent struct device pointer
918 int scsi_sysfs_add_host(struct Scsi_Host
*shost
)
922 if (shost
->hostt
->shost_attrs
) {
923 for (i
= 0; shost
->hostt
->shost_attrs
[i
]; i
++) {
924 error
= class_attr_add(&shost
->shost_classdev
,
925 shost
->hostt
->shost_attrs
[i
]);
931 for (i
= 0; scsi_sysfs_shost_attrs
[i
]; i
++) {
932 if (!class_attr_overridden(shost
->hostt
->shost_attrs
,
933 scsi_sysfs_shost_attrs
[i
])) {
934 error
= class_device_create_file(&shost
->shost_classdev
,
935 scsi_sysfs_shost_attrs
[i
]);
941 transport_register_device(&shost
->shost_gendev
);
945 void scsi_sysfs_device_initialize(struct scsi_device
*sdev
)
948 struct Scsi_Host
*shost
= sdev
->host
;
949 struct scsi_target
*starget
= sdev
->sdev_target
;
951 device_initialize(&sdev
->sdev_gendev
);
952 sdev
->sdev_gendev
.bus
= &scsi_bus_type
;
953 sdev
->sdev_gendev
.release
= scsi_device_dev_release
;
954 sprintf(sdev
->sdev_gendev
.bus_id
,"%d:%d:%d:%d",
955 sdev
->host
->host_no
, sdev
->channel
, sdev
->id
,
958 class_device_initialize(&sdev
->sdev_classdev
);
959 sdev
->sdev_classdev
.dev
= &sdev
->sdev_gendev
;
960 sdev
->sdev_classdev
.class = &sdev_class
;
961 snprintf(sdev
->sdev_classdev
.class_id
, BUS_ID_SIZE
,
962 "%d:%d:%d:%d", sdev
->host
->host_no
,
963 sdev
->channel
, sdev
->id
, sdev
->lun
);
964 sdev
->scsi_level
= starget
->scsi_level
;
965 transport_setup_device(&sdev
->sdev_gendev
);
966 spin_lock_irqsave(shost
->host_lock
, flags
);
967 list_add_tail(&sdev
->same_target_siblings
, &starget
->devices
);
968 list_add_tail(&sdev
->siblings
, &shost
->__devices
);
969 spin_unlock_irqrestore(shost
->host_lock
, flags
);
972 int scsi_is_sdev_device(const struct device
*dev
)
974 return dev
->release
== scsi_device_dev_release
;
976 EXPORT_SYMBOL(scsi_is_sdev_device
);
978 /* A blank transport template that is used in drivers that don't
979 * yet implement Transport Attributes */
980 struct scsi_transport_template blank_transport_template
= { { { {NULL
, }, }, }, };