blob: 490ce213204e9dc2bfb5d1699abdb99066cd8c05 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * scsi_sysfs.c
3 *
4 * SCSI sysfs interface routines.
5 *
6 * Created to pull SCSI mid layer sysfs routines into one file.
7 */
8
Linus Torvalds1da177e2005-04-16 15:20:36 -07009#include <linux/module.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090010#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070011#include <linux/init.h>
12#include <linux/blkdev.h>
13#include <linux/device.h>
Alan Sternbc4f2402010-06-17 10:41:42 -040014#include <linux/pm_runtime.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015
16#include <scsi/scsi.h>
17#include <scsi/scsi_device.h>
18#include <scsi/scsi_host.h>
19#include <scsi/scsi_tcq.h>
20#include <scsi/scsi_transport.h>
Adrian Bunk44818ef2007-07-09 11:59:59 -070021#include <scsi/scsi_driver.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070022
23#include "scsi_priv.h"
24#include "scsi_logging.h"
25
Hannes Reineckeb0ed4332008-03-18 14:32:28 +010026static struct device_type scsi_dev_type;
27
Arjan van de Ven0ad78202005-11-28 16:22:25 +010028static const struct {
Linus Torvalds1da177e2005-04-16 15:20:36 -070029 enum scsi_device_state value;
30 char *name;
31} sdev_states[] = {
32 { SDEV_CREATED, "created" },
33 { SDEV_RUNNING, "running" },
34 { SDEV_CANCEL, "cancel" },
35 { SDEV_DEL, "deleted" },
36 { SDEV_QUIESCE, "quiesce" },
37 { SDEV_OFFLINE, "offline" },
38 { SDEV_BLOCK, "blocked" },
James Bottomley6f4267e2008-08-22 16:53:31 -050039 { SDEV_CREATED_BLOCK, "created-blocked" },
Linus Torvalds1da177e2005-04-16 15:20:36 -070040};
41
42const char *scsi_device_state_name(enum scsi_device_state state)
43{
44 int i;
45 char *name = NULL;
46
Tobias Klauser6391a112006-06-08 22:23:48 -070047 for (i = 0; i < ARRAY_SIZE(sdev_states); i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070048 if (sdev_states[i].value == state) {
49 name = sdev_states[i].name;
50 break;
51 }
52 }
53 return name;
54}
55
Arjan van de Ven0ad78202005-11-28 16:22:25 +010056static const struct {
Mike Andersond3301872005-06-16 11:12:38 -070057 enum scsi_host_state value;
58 char *name;
59} shost_states[] = {
60 { SHOST_CREATED, "created" },
61 { SHOST_RUNNING, "running" },
62 { SHOST_CANCEL, "cancel" },
63 { SHOST_DEL, "deleted" },
64 { SHOST_RECOVERY, "recovery" },
James Bottomley939647e2005-09-18 15:05:20 -050065 { SHOST_CANCEL_RECOVERY, "cancel/recovery" },
66 { SHOST_DEL_RECOVERY, "deleted/recovery", },
Mike Andersond3301872005-06-16 11:12:38 -070067};
68const char *scsi_host_state_name(enum scsi_host_state state)
69{
70 int i;
71 char *name = NULL;
72
Tobias Klauser6391a112006-06-08 22:23:48 -070073 for (i = 0; i < ARRAY_SIZE(shost_states); i++) {
Mike Andersond3301872005-06-16 11:12:38 -070074 if (shost_states[i].value == state) {
75 name = shost_states[i].name;
76 break;
77 }
78 }
79 return name;
80}
81
Linus Torvalds1da177e2005-04-16 15:20:36 -070082static int check_set(unsigned int *val, char *src)
83{
84 char *last;
85
86 if (strncmp(src, "-", 20) == 0) {
87 *val = SCAN_WILD_CARD;
88 } else {
89 /*
90 * Doesn't check for int overflow
91 */
92 *val = simple_strtoul(src, &last, 0);
93 if (*last != '\0')
94 return 1;
95 }
96 return 0;
97}
98
99static int scsi_scan(struct Scsi_Host *shost, const char *str)
100{
101 char s1[15], s2[15], s3[15], junk;
102 unsigned int channel, id, lun;
103 int res;
104
105 res = sscanf(str, "%10s %10s %10s %c", s1, s2, s3, &junk);
106 if (res != 3)
107 return -EINVAL;
108 if (check_set(&channel, s1))
109 return -EINVAL;
110 if (check_set(&id, s2))
111 return -EINVAL;
112 if (check_set(&lun, s3))
113 return -EINVAL;
Christoph Hellwige02f3f52006-01-13 19:04:00 +0100114 if (shost->transportt->user_scan)
115 res = shost->transportt->user_scan(shost, channel, id, lun);
116 else
117 res = scsi_scan_host_selected(shost, channel, id, lun, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118 return res;
119}
120
121/*
122 * shost_show_function: macro to create an attr function that can be used to
123 * show a non-bit field.
124 */
125#define shost_show_function(name, field, format_string) \
126static ssize_t \
Tony Jonesee959b02008-02-22 00:13:36 +0100127show_##name (struct device *dev, struct device_attribute *attr, \
128 char *buf) \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129{ \
Tony Jonesee959b02008-02-22 00:13:36 +0100130 struct Scsi_Host *shost = class_to_shost(dev); \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131 return snprintf (buf, 20, format_string, shost->field); \
132}
133
134/*
135 * shost_rd_attr: macro to create a function and attribute variable for a
136 * read only field.
137 */
138#define shost_rd_attr2(name, field, format_string) \
139 shost_show_function(name, field, format_string) \
Tony Jonesee959b02008-02-22 00:13:36 +0100140static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141
142#define shost_rd_attr(field, format_string) \
143shost_rd_attr2(field, field, format_string)
144
145/*
146 * Create the actual show/store functions and data structures.
147 */
148
Tony Jonesee959b02008-02-22 00:13:36 +0100149static ssize_t
150store_scan(struct device *dev, struct device_attribute *attr,
151 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152{
Tony Jonesee959b02008-02-22 00:13:36 +0100153 struct Scsi_Host *shost = class_to_shost(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154 int res;
155
156 res = scsi_scan(shost, buf);
157 if (res == 0)
158 res = count;
159 return res;
160};
Tony Jonesee959b02008-02-22 00:13:36 +0100161static DEVICE_ATTR(scan, S_IWUSR, NULL, store_scan);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162
Mike Andersond3301872005-06-16 11:12:38 -0700163static ssize_t
Tony Jonesee959b02008-02-22 00:13:36 +0100164store_shost_state(struct device *dev, struct device_attribute *attr,
165 const char *buf, size_t count)
Mike Andersond3301872005-06-16 11:12:38 -0700166{
167 int i;
Tony Jonesee959b02008-02-22 00:13:36 +0100168 struct Scsi_Host *shost = class_to_shost(dev);
Mike Andersond3301872005-06-16 11:12:38 -0700169 enum scsi_host_state state = 0;
170
Tobias Klauser6391a112006-06-08 22:23:48 -0700171 for (i = 0; i < ARRAY_SIZE(shost_states); i++) {
Mike Andersond3301872005-06-16 11:12:38 -0700172 const int len = strlen(shost_states[i].name);
173 if (strncmp(shost_states[i].name, buf, len) == 0 &&
174 buf[len] == '\n') {
175 state = shost_states[i].value;
176 break;
177 }
178 }
179 if (!state)
180 return -EINVAL;
181
182 if (scsi_host_set_state(shost, state))
183 return -EINVAL;
184 return count;
185}
186
187static ssize_t
Tony Jonesee959b02008-02-22 00:13:36 +0100188show_shost_state(struct device *dev, struct device_attribute *attr, char *buf)
Mike Andersond3301872005-06-16 11:12:38 -0700189{
Tony Jonesee959b02008-02-22 00:13:36 +0100190 struct Scsi_Host *shost = class_to_shost(dev);
Mike Andersond3301872005-06-16 11:12:38 -0700191 const char *name = scsi_host_state_name(shost->shost_state);
192
193 if (!name)
194 return -EINVAL;
195
196 return snprintf(buf, 20, "%s\n", name);
197}
198
Tony Jonesee959b02008-02-22 00:13:36 +0100199/* DEVICE_ATTR(state) clashes with dev_attr_state for sdev */
200struct device_attribute dev_attr_hstate =
201 __ATTR(state, S_IRUGO | S_IWUSR, show_shost_state, store_shost_state);
Mike Andersond3301872005-06-16 11:12:38 -0700202
FUJITA Tomonori5dc2b892007-09-01 02:02:20 +0900203static ssize_t
204show_shost_mode(unsigned int mode, char *buf)
205{
206 ssize_t len = 0;
207
208 if (mode & MODE_INITIATOR)
209 len = sprintf(buf, "%s", "Initiator");
210
211 if (mode & MODE_TARGET)
212 len += sprintf(buf + len, "%s%s", len ? ", " : "", "Target");
213
214 len += sprintf(buf + len, "\n");
215
216 return len;
217}
218
Tony Jonesee959b02008-02-22 00:13:36 +0100219static ssize_t
220show_shost_supported_mode(struct device *dev, struct device_attribute *attr,
221 char *buf)
FUJITA Tomonori5dc2b892007-09-01 02:02:20 +0900222{
Tony Jonesee959b02008-02-22 00:13:36 +0100223 struct Scsi_Host *shost = class_to_shost(dev);
James Bottomley7a39ac32007-09-25 22:45:53 -0500224 unsigned int supported_mode = shost->hostt->supported_mode;
FUJITA Tomonori5dc2b892007-09-01 02:02:20 +0900225
James Bottomley7a39ac32007-09-25 22:45:53 -0500226 if (supported_mode == MODE_UNKNOWN)
227 /* by default this should be initiator */
228 supported_mode = MODE_INITIATOR;
229
230 return show_shost_mode(supported_mode, buf);
FUJITA Tomonori5dc2b892007-09-01 02:02:20 +0900231}
232
Tony Jonesee959b02008-02-22 00:13:36 +0100233static DEVICE_ATTR(supported_mode, S_IRUGO | S_IWUSR, show_shost_supported_mode, NULL);
FUJITA Tomonori5dc2b892007-09-01 02:02:20 +0900234
Tony Jonesee959b02008-02-22 00:13:36 +0100235static ssize_t
236show_shost_active_mode(struct device *dev,
237 struct device_attribute *attr, char *buf)
FUJITA Tomonori5dc2b892007-09-01 02:02:20 +0900238{
Tony Jonesee959b02008-02-22 00:13:36 +0100239 struct Scsi_Host *shost = class_to_shost(dev);
FUJITA Tomonori5dc2b892007-09-01 02:02:20 +0900240
241 if (shost->active_mode == MODE_UNKNOWN)
242 return snprintf(buf, 20, "unknown\n");
243 else
244 return show_shost_mode(shost->active_mode, buf);
245}
246
Tony Jonesee959b02008-02-22 00:13:36 +0100247static DEVICE_ATTR(active_mode, S_IRUGO | S_IWUSR, show_shost_active_mode, NULL);
FUJITA Tomonori5dc2b892007-09-01 02:02:20 +0900248
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249shost_rd_attr(unique_id, "%u\n");
250shost_rd_attr(host_busy, "%hu\n");
251shost_rd_attr(cmd_per_lun, "%hd\n");
James Bottomleyed632da2006-10-16 10:06:27 -0500252shost_rd_attr(can_queue, "%hd\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253shost_rd_attr(sg_tablesize, "%hu\n");
Martin K. Petersen13f05c82010-09-10 20:50:10 +0200254shost_rd_attr(sg_prot_tablesize, "%hu\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255shost_rd_attr(unchecked_isa_dma, "%d\n");
Martin K. Petersen4469f982008-07-17 04:28:30 -0400256shost_rd_attr(prot_capabilities, "%u\n");
257shost_rd_attr(prot_guard_type, "%hd\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258shost_rd_attr2(proc_name, hostt->proc_name, "%s\n");
259
Hannes Reineckef7120a42008-03-18 14:32:28 +0100260static struct attribute *scsi_sysfs_shost_attrs[] = {
261 &dev_attr_unique_id.attr,
262 &dev_attr_host_busy.attr,
263 &dev_attr_cmd_per_lun.attr,
264 &dev_attr_can_queue.attr,
265 &dev_attr_sg_tablesize.attr,
Martin K. Petersen13f05c82010-09-10 20:50:10 +0200266 &dev_attr_sg_prot_tablesize.attr,
Hannes Reineckef7120a42008-03-18 14:32:28 +0100267 &dev_attr_unchecked_isa_dma.attr,
268 &dev_attr_proc_name.attr,
269 &dev_attr_scan.attr,
270 &dev_attr_hstate.attr,
271 &dev_attr_supported_mode.attr,
272 &dev_attr_active_mode.attr,
Martin K. Petersen4469f982008-07-17 04:28:30 -0400273 &dev_attr_prot_capabilities.attr,
274 &dev_attr_prot_guard_type.attr,
Hannes Reineckef7120a42008-03-18 14:32:28 +0100275 NULL
276};
277
278struct attribute_group scsi_shost_attr_group = {
279 .attrs = scsi_sysfs_shost_attrs,
280};
281
David Brownella4dbd672009-06-24 10:06:31 -0700282const struct attribute_group *scsi_sysfs_shost_attr_groups[] = {
Hannes Reineckef7120a42008-03-18 14:32:28 +0100283 &scsi_shost_attr_group,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 NULL
285};
286
Tony Jonesee959b02008-02-22 00:13:36 +0100287static void scsi_device_cls_release(struct device *class_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288{
289 struct scsi_device *sdev;
290
291 sdev = class_to_sdev(class_dev);
292 put_device(&sdev->sdev_gendev);
293}
294
David Howells65f27f32006-11-22 14:55:48 +0000295static void scsi_device_dev_release_usercontext(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296{
297 struct scsi_device *sdev;
298 struct device *parent;
299 struct scsi_target *starget;
Jeff Garzika341cd02007-10-29 17:15:22 -0400300 struct list_head *this, *tmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301 unsigned long flags;
302
David Howells65f27f32006-11-22 14:55:48 +0000303 sdev = container_of(work, struct scsi_device, ew.work);
304
305 parent = sdev->sdev_gendev.parent;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 starget = to_scsi_target(parent);
307
308 spin_lock_irqsave(sdev->host->host_lock, flags);
309 starget->reap_ref++;
310 list_del(&sdev->siblings);
311 list_del(&sdev->same_target_siblings);
312 list_del(&sdev->starved_entry);
313 spin_unlock_irqrestore(sdev->host->host_lock, flags);
314
Jeff Garzika341cd02007-10-29 17:15:22 -0400315 cancel_work_sync(&sdev->event_work);
316
317 list_for_each_safe(this, tmp, &sdev->event_list) {
318 struct scsi_event *evt;
319
320 evt = list_entry(this, struct scsi_event, node);
321 list_del(&evt->node);
322 kfree(evt);
323 }
324
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325 if (sdev->request_queue) {
326 sdev->request_queue->queuedata = NULL;
James Bottomley65110b22006-02-14 10:48:46 -0600327 /* user context needed to free queue */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328 scsi_free_queue(sdev->request_queue);
c2a93312005-04-12 16:38:09 -0500329 /* temporary expedient, try to catch use of queue lock
330 * after free of sdev */
331 sdev->request_queue = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 }
333
334 scsi_target_reap(scsi_target(sdev));
335
336 kfree(sdev->inquiry);
337 kfree(sdev);
338
339 if (parent)
340 put_device(parent);
341}
342
James Bottomley65110b22006-02-14 10:48:46 -0600343static void scsi_device_dev_release(struct device *dev)
344{
James Bottomleyffedb452006-02-23 14:27:18 -0600345 struct scsi_device *sdp = to_scsi_device(dev);
David Howells65f27f32006-11-22 14:55:48 +0000346 execute_in_process_context(scsi_device_dev_release_usercontext,
James Bottomleyffedb452006-02-23 14:27:18 -0600347 &sdp->ew);
James Bottomley65110b22006-02-14 10:48:46 -0600348}
349
Adrian Bunk52c1da32005-06-23 22:05:33 -0700350static struct class sdev_class = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 .name = "scsi_device",
Tony Jonesee959b02008-02-22 00:13:36 +0100352 .dev_release = scsi_device_cls_release,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353};
354
355/* all probing is done in the individual ->probe routines */
356static int scsi_bus_match(struct device *dev, struct device_driver *gendrv)
357{
Hannes Reineckeb0ed4332008-03-18 14:32:28 +0100358 struct scsi_device *sdp;
359
360 if (dev->type != &scsi_dev_type)
361 return 0;
362
363 sdp = to_scsi_device(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 if (sdp->no_uld_attach)
365 return 0;
366 return (sdp->inq_periph_qual == SCSI_INQ_PQ_CON)? 1: 0;
367}
368
Kay Sievers7eff2e72007-08-14 15:15:12 +0200369static int scsi_bus_uevent(struct device *dev, struct kobj_uevent_env *env)
Michael Tokarevd7b8bcb2006-10-27 16:02:37 +0400370{
James Bottomley1f42ea72008-05-22 12:34:41 +0100371 struct scsi_device *sdev;
372
373 if (dev->type != &scsi_dev_type)
374 return 0;
375
376 sdev = to_scsi_device(dev);
Michael Tokarevd7b8bcb2006-10-27 16:02:37 +0400377
Kay Sievers7eff2e72007-08-14 15:15:12 +0200378 add_uevent_var(env, "MODALIAS=" SCSI_DEVICE_MODALIAS_FMT, sdev->type);
Michael Tokarevd7b8bcb2006-10-27 16:02:37 +0400379 return 0;
380}
381
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382struct bus_type scsi_bus_type = {
383 .name = "scsi",
384 .match = scsi_bus_match,
Michael Tokarevd7b8bcb2006-10-27 16:02:37 +0400385 .uevent = scsi_bus_uevent,
Alan Sterne6da54d2010-08-05 13:17:10 -0400386#ifdef CONFIG_PM_OPS
Alan Sterndb5bd1e2010-06-17 10:36:49 -0400387 .pm = &scsi_bus_pm_ops,
Alan Sterne6da54d2010-08-05 13:17:10 -0400388#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389};
Chandra Seetharamana6a8d9f2008-05-01 14:49:46 -0700390EXPORT_SYMBOL_GPL(scsi_bus_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391
392int scsi_sysfs_register(void)
393{
394 int error;
395
396 error = bus_register(&scsi_bus_type);
397 if (!error) {
398 error = class_register(&sdev_class);
399 if (error)
400 bus_unregister(&scsi_bus_type);
401 }
402
403 return error;
404}
405
406void scsi_sysfs_unregister(void)
407{
408 class_unregister(&sdev_class);
409 bus_unregister(&scsi_bus_type);
410}
411
412/*
413 * sdev_show_function: macro to create an attr function that can be used to
414 * show a non-bit field.
415 */
416#define sdev_show_function(field, format_string) \
417static ssize_t \
Tony Jonesee959b02008-02-22 00:13:36 +0100418sdev_show_##field (struct device *dev, struct device_attribute *attr, \
419 char *buf) \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420{ \
421 struct scsi_device *sdev; \
422 sdev = to_scsi_device(dev); \
423 return snprintf (buf, 20, format_string, sdev->field); \
424} \
425
426/*
427 * sdev_rd_attr: macro to create a function and attribute variable for a
428 * read only field.
429 */
430#define sdev_rd_attr(field, format_string) \
431 sdev_show_function(field, format_string) \
432static DEVICE_ATTR(field, S_IRUGO, sdev_show_##field, NULL);
433
434
435/*
Tomohiro Kusumi160e7f62010-04-14 15:15:14 +0900436 * sdev_rw_attr: create a function and attribute variable for a
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 * read/write field.
438 */
439#define sdev_rw_attr(field, format_string) \
440 sdev_show_function(field, format_string) \
441 \
442static ssize_t \
Tony Jonesee959b02008-02-22 00:13:36 +0100443sdev_store_##field (struct device *dev, struct device_attribute *attr, \
444 const char *buf, size_t count) \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445{ \
446 struct scsi_device *sdev; \
447 sdev = to_scsi_device(dev); \
Tomohiro Kusumi160e7f62010-04-14 15:15:14 +0900448 sscanf (buf, format_string, &sdev->field); \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 return count; \
450} \
451static DEVICE_ATTR(field, S_IRUGO | S_IWUSR, sdev_show_##field, sdev_store_##field);
452
453/* Currently we don't export bit fields, but we might in future,
454 * so leave this code in */
455#if 0
456/*
457 * sdev_rd_attr: create a function and attribute variable for a
458 * read/write bit field.
459 */
460#define sdev_rw_attr_bit(field) \
461 sdev_show_function(field, "%d\n") \
462 \
463static ssize_t \
Tony Jonesee959b02008-02-22 00:13:36 +0100464sdev_store_##field (struct device *dev, struct device_attribute *attr, \
465 const char *buf, size_t count) \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466{ \
467 int ret; \
468 struct scsi_device *sdev; \
469 ret = scsi_sdev_check_buf_bit(buf); \
470 if (ret >= 0) { \
471 sdev = to_scsi_device(dev); \
472 sdev->field = ret; \
473 ret = count; \
474 } \
475 return ret; \
476} \
477static DEVICE_ATTR(field, S_IRUGO | S_IWUSR, sdev_show_##field, sdev_store_##field);
478
479/*
480 * scsi_sdev_check_buf_bit: return 0 if buf is "0", return 1 if buf is "1",
481 * else return -EINVAL.
482 */
483static int scsi_sdev_check_buf_bit(const char *buf)
484{
485 if ((buf[1] == '\0') || ((buf[1] == '\n') && (buf[2] == '\0'))) {
486 if (buf[0] == '1')
487 return 1;
488 else if (buf[0] == '0')
489 return 0;
490 else
491 return -EINVAL;
492 } else
493 return -EINVAL;
494}
495#endif
496/*
497 * Create the actual show/store functions and data structures.
498 */
499sdev_rd_attr (device_blocked, "%d\n");
500sdev_rd_attr (queue_depth, "%d\n");
501sdev_rd_attr (type, "%d\n");
502sdev_rd_attr (scsi_level, "%d\n");
503sdev_rd_attr (vendor, "%.8s\n");
504sdev_rd_attr (model, "%.16s\n");
505sdev_rd_attr (rev, "%.4s\n");
506
Jens Axboe242f9dc2008-09-14 05:55:09 -0700507/*
508 * TODO: can we make these symlinks to the block layer ones?
509 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510static ssize_t
Yani Ioannou10523b32005-05-17 06:43:37 -0400511sdev_show_timeout (struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512{
513 struct scsi_device *sdev;
514 sdev = to_scsi_device(dev);
Jens Axboe242f9dc2008-09-14 05:55:09 -0700515 return snprintf(buf, 20, "%d\n", sdev->request_queue->rq_timeout / HZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516}
517
518static ssize_t
Tony Jonesee959b02008-02-22 00:13:36 +0100519sdev_store_timeout (struct device *dev, struct device_attribute *attr,
520 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521{
522 struct scsi_device *sdev;
523 int timeout;
524 sdev = to_scsi_device(dev);
525 sscanf (buf, "%d\n", &timeout);
Jens Axboe242f9dc2008-09-14 05:55:09 -0700526 blk_queue_rq_timeout(sdev->request_queue, timeout * HZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 return count;
528}
529static DEVICE_ATTR(timeout, S_IRUGO | S_IWUSR, sdev_show_timeout, sdev_store_timeout);
530
531static ssize_t
Tony Jonesee959b02008-02-22 00:13:36 +0100532store_rescan_field (struct device *dev, struct device_attribute *attr,
533 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534{
535 scsi_rescan_device(dev);
536 return count;
537}
538static DEVICE_ATTR(rescan, S_IWUSR, NULL, store_rescan_field);
539
Alan Sternd9a9cdf2007-03-15 15:50:34 -0400540static void sdev_store_delete_callback(struct device *dev)
541{
542 scsi_remove_device(to_scsi_device(dev));
543}
544
Tony Jonesee959b02008-02-22 00:13:36 +0100545static ssize_t
546sdev_store_delete(struct device *dev, struct device_attribute *attr,
547 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548{
Alan Sternd9a9cdf2007-03-15 15:50:34 -0400549 int rc;
550
551 /* An attribute cannot be unregistered by one of its own methods,
552 * so we have to use this roundabout approach.
553 */
554 rc = device_schedule_callback(dev, sdev_store_delete_callback);
555 if (rc)
556 count = rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 return count;
558};
559static DEVICE_ATTR(delete, S_IWUSR, NULL, sdev_store_delete);
560
561static ssize_t
Tony Jonesee959b02008-02-22 00:13:36 +0100562store_state_field(struct device *dev, struct device_attribute *attr,
563 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564{
565 int i;
566 struct scsi_device *sdev = to_scsi_device(dev);
567 enum scsi_device_state state = 0;
568
Tobias Klauser6391a112006-06-08 22:23:48 -0700569 for (i = 0; i < ARRAY_SIZE(sdev_states); i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570 const int len = strlen(sdev_states[i].name);
571 if (strncmp(sdev_states[i].name, buf, len) == 0 &&
572 buf[len] == '\n') {
573 state = sdev_states[i].value;
574 break;
575 }
576 }
577 if (!state)
578 return -EINVAL;
579
580 if (scsi_device_set_state(sdev, state))
581 return -EINVAL;
582 return count;
583}
584
585static ssize_t
Yani Ioannou10523b32005-05-17 06:43:37 -0400586show_state_field(struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587{
588 struct scsi_device *sdev = to_scsi_device(dev);
589 const char *name = scsi_device_state_name(sdev->sdev_state);
590
591 if (!name)
592 return -EINVAL;
593
594 return snprintf(buf, 20, "%s\n", name);
595}
596
597static DEVICE_ATTR(state, S_IRUGO | S_IWUSR, show_state_field, store_state_field);
598
599static ssize_t
Tony Jonesee959b02008-02-22 00:13:36 +0100600show_queue_type_field(struct device *dev, struct device_attribute *attr,
601 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602{
603 struct scsi_device *sdev = to_scsi_device(dev);
604 const char *name = "none";
605
606 if (sdev->ordered_tags)
607 name = "ordered";
608 else if (sdev->simple_tags)
609 name = "simple";
610
611 return snprintf(buf, 20, "%s\n", name);
612}
613
614static DEVICE_ATTR(queue_type, S_IRUGO, show_queue_type_field, NULL);
615
616static ssize_t
Tony Jonesee959b02008-02-22 00:13:36 +0100617show_iostat_counterbits(struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618{
619 return snprintf(buf, 20, "%d\n", (int)sizeof(atomic_t) * 8);
620}
621
622static DEVICE_ATTR(iocounterbits, S_IRUGO, show_iostat_counterbits, NULL);
623
624#define show_sdev_iostat(field) \
625static ssize_t \
Tony Jonesee959b02008-02-22 00:13:36 +0100626show_iostat_##field(struct device *dev, struct device_attribute *attr, \
627 char *buf) \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628{ \
629 struct scsi_device *sdev = to_scsi_device(dev); \
630 unsigned long long count = atomic_read(&sdev->field); \
631 return snprintf(buf, 20, "0x%llx\n", count); \
632} \
633static DEVICE_ATTR(field, S_IRUGO, show_iostat_##field, NULL)
634
635show_sdev_iostat(iorequest_cnt);
636show_sdev_iostat(iodone_cnt);
637show_sdev_iostat(ioerr_cnt);
638
Michael Tokarevd7b8bcb2006-10-27 16:02:37 +0400639static ssize_t
640sdev_show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
641{
642 struct scsi_device *sdev;
643 sdev = to_scsi_device(dev);
644 return snprintf (buf, 20, SCSI_DEVICE_MODALIAS_FMT "\n", sdev->type);
645}
646static DEVICE_ATTR(modalias, S_IRUGO, sdev_show_modalias, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647
Jeff Garzika341cd02007-10-29 17:15:22 -0400648#define DECLARE_EVT_SHOW(name, Cap_name) \
649static ssize_t \
650sdev_show_evt_##name(struct device *dev, struct device_attribute *attr, \
Tony Jonesee959b02008-02-22 00:13:36 +0100651 char *buf) \
Jeff Garzika341cd02007-10-29 17:15:22 -0400652{ \
653 struct scsi_device *sdev = to_scsi_device(dev); \
654 int val = test_bit(SDEV_EVT_##Cap_name, sdev->supported_events);\
655 return snprintf(buf, 20, "%d\n", val); \
656}
657
658#define DECLARE_EVT_STORE(name, Cap_name) \
659static ssize_t \
Tony Jonesee959b02008-02-22 00:13:36 +0100660sdev_store_evt_##name(struct device *dev, struct device_attribute *attr,\
Jeff Garzika341cd02007-10-29 17:15:22 -0400661 const char *buf, size_t count) \
662{ \
663 struct scsi_device *sdev = to_scsi_device(dev); \
664 int val = simple_strtoul(buf, NULL, 0); \
665 if (val == 0) \
666 clear_bit(SDEV_EVT_##Cap_name, sdev->supported_events); \
667 else if (val == 1) \
668 set_bit(SDEV_EVT_##Cap_name, sdev->supported_events); \
669 else \
670 return -EINVAL; \
671 return count; \
672}
673
674#define DECLARE_EVT(name, Cap_name) \
675 DECLARE_EVT_SHOW(name, Cap_name) \
676 DECLARE_EVT_STORE(name, Cap_name) \
677 static DEVICE_ATTR(evt_##name, S_IRUGO, sdev_show_evt_##name, \
678 sdev_store_evt_##name);
679#define REF_EVT(name) &dev_attr_evt_##name.attr
680
681DECLARE_EVT(media_change, MEDIA_CHANGE)
682
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683/* Default template for device attributes. May NOT be modified */
Kay Sieversbfd12942007-09-11 17:00:14 +0200684static struct attribute *scsi_sdev_attrs[] = {
685 &dev_attr_device_blocked.attr,
686 &dev_attr_type.attr,
687 &dev_attr_scsi_level.attr,
688 &dev_attr_vendor.attr,
689 &dev_attr_model.attr,
690 &dev_attr_rev.attr,
691 &dev_attr_rescan.attr,
692 &dev_attr_delete.attr,
693 &dev_attr_state.attr,
694 &dev_attr_timeout.attr,
695 &dev_attr_iocounterbits.attr,
696 &dev_attr_iorequest_cnt.attr,
697 &dev_attr_iodone_cnt.attr,
698 &dev_attr_ioerr_cnt.attr,
699 &dev_attr_modalias.attr,
Jeff Garzika341cd02007-10-29 17:15:22 -0400700 REF_EVT(media_change),
Kay Sieversbfd12942007-09-11 17:00:14 +0200701 NULL
702};
703
704static struct attribute_group scsi_sdev_attr_group = {
705 .attrs = scsi_sdev_attrs,
706};
707
David Brownella4dbd672009-06-24 10:06:31 -0700708static const struct attribute_group *scsi_sdev_attr_groups[] = {
Kay Sieversbfd12942007-09-11 17:00:14 +0200709 &scsi_sdev_attr_group,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710 NULL
711};
712
Tony Jonesee959b02008-02-22 00:13:36 +0100713static ssize_t
714sdev_store_queue_depth_rw(struct device *dev, struct device_attribute *attr,
715 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716{
717 int depth, retval;
718 struct scsi_device *sdev = to_scsi_device(dev);
719 struct scsi_host_template *sht = sdev->host->hostt;
720
721 if (!sht->change_queue_depth)
722 return -EINVAL;
723
724 depth = simple_strtoul(buf, NULL, 0);
725
726 if (depth < 1)
727 return -EINVAL;
728
Mike Christiee881a172009-10-15 17:46:39 -0700729 retval = sht->change_queue_depth(sdev, depth,
730 SCSI_QDEPTH_DEFAULT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731 if (retval < 0)
732 return retval;
733
Vasu Dev4a840672009-10-22 15:46:33 -0700734 sdev->max_queue_depth = sdev->queue_depth;
735
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736 return count;
737}
738
739static struct device_attribute sdev_attr_queue_depth_rw =
740 __ATTR(queue_depth, S_IRUGO | S_IWUSR, sdev_show_queue_depth,
741 sdev_store_queue_depth_rw);
742
Tony Jonesee959b02008-02-22 00:13:36 +0100743static ssize_t
Vasu Dev4a840672009-10-22 15:46:33 -0700744sdev_show_queue_ramp_up_period(struct device *dev,
745 struct device_attribute *attr,
746 char *buf)
747{
748 struct scsi_device *sdev;
749 sdev = to_scsi_device(dev);
750 return snprintf(buf, 20, "%u\n",
751 jiffies_to_msecs(sdev->queue_ramp_up_period));
752}
753
754static ssize_t
755sdev_store_queue_ramp_up_period(struct device *dev,
756 struct device_attribute *attr,
757 const char *buf, size_t count)
758{
759 struct scsi_device *sdev = to_scsi_device(dev);
760 unsigned long period;
761
762 if (strict_strtoul(buf, 10, &period))
763 return -EINVAL;
764
765 sdev->queue_ramp_up_period = msecs_to_jiffies(period);
766 return period;
767}
768
769static struct device_attribute sdev_attr_queue_ramp_up_period =
770 __ATTR(queue_ramp_up_period, S_IRUGO | S_IWUSR,
771 sdev_show_queue_ramp_up_period,
772 sdev_store_queue_ramp_up_period);
773
774static ssize_t
Tony Jonesee959b02008-02-22 00:13:36 +0100775sdev_store_queue_type_rw(struct device *dev, struct device_attribute *attr,
776 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777{
778 struct scsi_device *sdev = to_scsi_device(dev);
779 struct scsi_host_template *sht = sdev->host->hostt;
780 int tag_type = 0, retval;
781 int prev_tag_type = scsi_get_tag_type(sdev);
782
783 if (!sdev->tagged_supported || !sht->change_queue_type)
784 return -EINVAL;
785
786 if (strncmp(buf, "ordered", 7) == 0)
787 tag_type = MSG_ORDERED_TAG;
788 else if (strncmp(buf, "simple", 6) == 0)
789 tag_type = MSG_SIMPLE_TAG;
790 else if (strncmp(buf, "none", 4) != 0)
791 return -EINVAL;
792
793 if (tag_type == prev_tag_type)
794 return count;
795
796 retval = sht->change_queue_type(sdev, tag_type);
797 if (retval < 0)
798 return retval;
799
800 return count;
801}
802
James Bottomley643eb2d2008-03-22 22:42:27 -0500803static int scsi_target_add(struct scsi_target *starget)
804{
805 int error;
806
807 if (starget->state != STARGET_CREATED)
808 return 0;
809
810 error = device_add(&starget->dev);
811 if (error) {
812 dev_err(&starget->dev, "target device_add failed, error %d\n", error);
James Bottomley643eb2d2008-03-22 22:42:27 -0500813 return error;
814 }
815 transport_add_device(&starget->dev);
816 starget->state = STARGET_RUNNING;
817
Alan Sternbc4f2402010-06-17 10:41:42 -0400818 pm_runtime_set_active(&starget->dev);
819 pm_runtime_enable(&starget->dev);
820 device_enable_async_suspend(&starget->dev);
821
James Bottomley643eb2d2008-03-22 22:42:27 -0500822 return 0;
823}
824
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825static struct device_attribute sdev_attr_queue_type_rw =
826 __ATTR(queue_type, S_IRUGO | S_IWUSR, show_queue_type_field,
827 sdev_store_queue_type_rw);
828
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829/**
830 * scsi_sysfs_add_sdev - add scsi device to sysfs
831 * @sdev: scsi_device to add
832 *
833 * Return value:
834 * 0 on Success / non-zero on Failure
835 **/
836int scsi_sysfs_add_sdev(struct scsi_device *sdev)
837{
838 int error, i;
James Bottomley80ed71c2007-07-19 10:15:10 -0500839 struct request_queue *rq = sdev->request_queue;
James Bottomley643eb2d2008-03-22 22:42:27 -0500840 struct scsi_target *starget = sdev->sdev_target;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841
Alan Sternee37e092010-02-12 12:13:55 -0500842 error = scsi_device_set_state(sdev, SDEV_RUNNING);
843 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844 return error;
845
James Bottomley643eb2d2008-03-22 22:42:27 -0500846 error = scsi_target_add(starget);
847 if (error)
848 return error;
849
850 transport_configure_device(&starget->dev);
Alan Sternbc4f2402010-06-17 10:41:42 -0400851
Rafael J. Wysocki4cb077d2010-02-08 19:18:26 +0100852 device_enable_async_suspend(&sdev->sdev_gendev);
Alan Sternbc4f2402010-06-17 10:41:42 -0400853 scsi_autopm_get_target(starget);
854 pm_runtime_set_active(&sdev->sdev_gendev);
855 pm_runtime_forbid(&sdev->sdev_gendev);
856 pm_runtime_enable(&sdev->sdev_gendev);
857 scsi_autopm_put_target(starget);
858
859 /* The following call will keep sdev active indefinitely, until
860 * its driver does a corresponding scsi_autopm_pm_device(). Only
861 * drivers supporting autosuspend will do this.
862 */
863 scsi_autopm_get_device(sdev);
864
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 error = device_add(&sdev->sdev_gendev);
866 if (error) {
Alan Stern73d8c342010-11-15 16:03:04 -0500867 sdev_printk(KERN_INFO, sdev,
868 "failed to add device: %d\n", error);
Alan Sternee37e092010-02-12 12:13:55 -0500869 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870 }
Rafael J. Wysocki4cb077d2010-02-08 19:18:26 +0100871 device_enable_async_suspend(&sdev->sdev_dev);
Tony Jonesee959b02008-02-22 00:13:36 +0100872 error = device_add(&sdev->sdev_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873 if (error) {
Alan Stern73d8c342010-11-15 16:03:04 -0500874 sdev_printk(KERN_INFO, sdev,
875 "failed to add class device: %d\n", error);
James Bottomley860dc732009-11-19 17:48:29 -0500876 device_del(&sdev->sdev_gendev);
Alan Sternee37e092010-02-12 12:13:55 -0500877 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878 }
James Bottomley860dc732009-11-19 17:48:29 -0500879 transport_add_device(&sdev->sdev_gendev);
880 sdev->is_visible = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881
Kay Sieversbfd12942007-09-11 17:00:14 +0200882 /* create queue files, which may be writable, depending on the host */
Vasu Dev4a840672009-10-22 15:46:33 -0700883 if (sdev->host->hostt->change_queue_depth) {
884 error = device_create_file(&sdev->sdev_gendev,
885 &sdev_attr_queue_depth_rw);
886 error = device_create_file(&sdev->sdev_gendev,
887 &sdev_attr_queue_ramp_up_period);
888 }
Kay Sieversbfd12942007-09-11 17:00:14 +0200889 else
890 error = device_create_file(&sdev->sdev_gendev, &dev_attr_queue_depth);
James Bottomley860dc732009-11-19 17:48:29 -0500891 if (error)
Alan Sternee37e092010-02-12 12:13:55 -0500892 return error;
James Bottomley860dc732009-11-19 17:48:29 -0500893
Kay Sieversbfd12942007-09-11 17:00:14 +0200894 if (sdev->host->hostt->change_queue_type)
895 error = device_create_file(&sdev->sdev_gendev, &sdev_attr_queue_type_rw);
896 else
897 error = device_create_file(&sdev->sdev_gendev, &dev_attr_queue_type);
James Bottomley860dc732009-11-19 17:48:29 -0500898 if (error)
Alan Sternee37e092010-02-12 12:13:55 -0500899 return error;
Kay Sieversbfd12942007-09-11 17:00:14 +0200900
FUJITA Tomonori97f46ae2008-04-19 00:43:14 +0900901 error = bsg_register_queue(rq, &sdev->sdev_gendev, NULL, NULL);
James Bottomley80ed71c2007-07-19 10:15:10 -0500902
903 if (error)
James Bottomley860dc732009-11-19 17:48:29 -0500904 /* we're treating error on bsg register as non-fatal,
905 * so pretend nothing went wrong */
James Bottomley80ed71c2007-07-19 10:15:10 -0500906 sdev_printk(KERN_INFO, sdev,
907 "Failed to register bsg queue, errno=%d\n", error);
908
Kay Sieversbfd12942007-09-11 17:00:14 +0200909 /* add additional host specific attributes */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910 if (sdev->host->hostt->sdev_attrs) {
911 for (i = 0; sdev->host->hostt->sdev_attrs[i]; i++) {
Kay Sieversbfd12942007-09-11 17:00:14 +0200912 error = device_create_file(&sdev->sdev_gendev,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913 sdev->host->hostt->sdev_attrs[i]);
James Bottomley860dc732009-11-19 17:48:29 -0500914 if (error)
Alan Sternee37e092010-02-12 12:13:55 -0500915 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916 }
917 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920}
921
Alan Stern903f4fe2005-07-26 10:20:53 -0400922void __scsi_remove_device(struct scsi_device *sdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923{
James Bottomleydf133c22005-11-06 11:47:08 -0600924 struct device *dev = &sdev->sdev_gendev;
925
James Bottomley860dc732009-11-19 17:48:29 -0500926 if (sdev->is_visible) {
927 if (scsi_device_set_state(sdev, SDEV_CANCEL) != 0)
928 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929
James Bottomley860dc732009-11-19 17:48:29 -0500930 bsg_unregister_queue(sdev->request_queue);
931 device_unregister(&sdev->sdev_dev);
932 transport_remove_device(dev);
933 device_del(dev);
934 } else
935 put_device(&sdev->sdev_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936 scsi_device_set_state(sdev, SDEV_DEL);
937 if (sdev->host->hostt->slave_destroy)
938 sdev->host->hostt->slave_destroy(sdev);
James Bottomleydf133c22005-11-06 11:47:08 -0600939 transport_destroy_device(dev);
940 put_device(dev);
Alan Stern903f4fe2005-07-26 10:20:53 -0400941}
942
943/**
944 * scsi_remove_device - unregister a device from the scsi bus
945 * @sdev: scsi_device to unregister
946 **/
947void scsi_remove_device(struct scsi_device *sdev)
948{
Alan Stern54195002005-09-15 21:52:51 -0400949 struct Scsi_Host *shost = sdev->host;
950
Arjan van de Ven0b950672006-01-11 13:16:10 +0100951 mutex_lock(&shost->scan_mutex);
Alan Stern903f4fe2005-07-26 10:20:53 -0400952 __scsi_remove_device(sdev);
Arjan van de Ven0b950672006-01-11 13:16:10 +0100953 mutex_unlock(&shost->scan_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954}
955EXPORT_SYMBOL(scsi_remove_device);
956
Adrian Bunk44818ef2007-07-09 11:59:59 -0700957static void __scsi_remove_target(struct scsi_target *starget)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958{
959 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
960 unsigned long flags;
Alan Sterna64358d2005-07-26 10:27:10 -0400961 struct scsi_device *sdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962
963 spin_lock_irqsave(shost->host_lock, flags);
964 starget->reap_ref++;
Alan Sterna64358d2005-07-26 10:27:10 -0400965 restart:
966 list_for_each_entry(sdev, &shost->__devices, siblings) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967 if (sdev->channel != starget->channel ||
Alan Sterna64358d2005-07-26 10:27:10 -0400968 sdev->id != starget->id ||
Christof Schmitt546ae792010-10-06 13:19:44 +0200969 scsi_device_get(sdev))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970 continue;
971 spin_unlock_irqrestore(shost->host_lock, flags);
972 scsi_remove_device(sdev);
Christof Schmitt546ae792010-10-06 13:19:44 +0200973 scsi_device_put(sdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700974 spin_lock_irqsave(shost->host_lock, flags);
Alan Sterna64358d2005-07-26 10:27:10 -0400975 goto restart;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976 }
977 spin_unlock_irqrestore(shost->host_lock, flags);
978 scsi_target_reap(starget);
979}
980
mochel@digitalimplant.org20b1e672005-03-24 19:03:59 -0800981static int __remove_child (struct device * dev, void * data)
982{
983 if (scsi_is_target_device(dev))
984 __scsi_remove_target(to_scsi_target(dev));
985 return 0;
986}
987
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988/**
989 * scsi_remove_target - try to remove a target and all its devices
990 * @dev: generic starget or parent of generic stargets to be removed
991 *
992 * Note: This is slightly racy. It is possible that if the user
993 * requests the addition of another device then the target won't be
994 * removed.
995 */
996void scsi_remove_target(struct device *dev)
997{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998 if (scsi_is_target_device(dev)) {
999 __scsi_remove_target(to_scsi_target(dev));
1000 return;
1001 }
1002
Alan Stern41511702010-11-15 16:04:56 -05001003 get_device(dev);
mochel@digitalimplant.org20b1e672005-03-24 19:03:59 -08001004 device_for_each_child(dev, NULL, __remove_child);
Alan Stern41511702010-11-15 16:04:56 -05001005 put_device(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006}
1007EXPORT_SYMBOL(scsi_remove_target);
1008
1009int scsi_register_driver(struct device_driver *drv)
1010{
1011 drv->bus = &scsi_bus_type;
1012
1013 return driver_register(drv);
1014}
1015EXPORT_SYMBOL(scsi_register_driver);
1016
1017int scsi_register_interface(struct class_interface *intf)
1018{
1019 intf->class = &sdev_class;
1020
1021 return class_interface_register(intf);
1022}
1023EXPORT_SYMBOL(scsi_register_interface);
1024
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025/**
1026 * scsi_sysfs_add_host - add scsi host to subsystem
1027 * @shost: scsi host struct to add to subsystem
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028 **/
1029int scsi_sysfs_add_host(struct Scsi_Host *shost)
1030{
1031 int error, i;
1032
Hannes Reineckef7120a42008-03-18 14:32:28 +01001033 /* add host specific attributes */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001034 if (shost->hostt->shost_attrs) {
1035 for (i = 0; shost->hostt->shost_attrs[i]; i++) {
Tony Jonesee959b02008-02-22 00:13:36 +01001036 error = device_create_file(&shost->shost_dev,
Hannes Reineckef7120a42008-03-18 14:32:28 +01001037 shost->hostt->shost_attrs[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038 if (error)
1039 return error;
1040 }
1041 }
1042
1043 transport_register_device(&shost->shost_gendev);
James Bottomleyd52b3812008-01-05 09:38:30 -06001044 transport_configure_device(&shost->shost_gendev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001045 return 0;
1046}
1047
Kay Sieversbfd12942007-09-11 17:00:14 +02001048static struct device_type scsi_dev_type = {
1049 .name = "scsi_device",
1050 .release = scsi_device_dev_release,
1051 .groups = scsi_sdev_attr_groups,
1052};
1053
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054void scsi_sysfs_device_initialize(struct scsi_device *sdev)
1055{
1056 unsigned long flags;
1057 struct Scsi_Host *shost = sdev->host;
1058 struct scsi_target *starget = sdev->sdev_target;
1059
1060 device_initialize(&sdev->sdev_gendev);
1061 sdev->sdev_gendev.bus = &scsi_bus_type;
Kay Sieversbfd12942007-09-11 17:00:14 +02001062 sdev->sdev_gendev.type = &scsi_dev_type;
Kay Sievers71610f52008-12-03 22:41:36 +01001063 dev_set_name(&sdev->sdev_gendev, "%d:%d:%d:%d",
1064 sdev->host->host_no, sdev->channel, sdev->id, sdev->lun);
1065
Tony Jonesee959b02008-02-22 00:13:36 +01001066 device_initialize(&sdev->sdev_dev);
James Bottomley37e6ba02009-10-02 13:30:08 -05001067 sdev->sdev_dev.parent = get_device(&sdev->sdev_gendev);
Tony Jonesee959b02008-02-22 00:13:36 +01001068 sdev->sdev_dev.class = &sdev_class;
Kay Sievers71610f52008-12-03 22:41:36 +01001069 dev_set_name(&sdev->sdev_dev, "%d:%d:%d:%d",
1070 sdev->host->host_no, sdev->channel, sdev->id, sdev->lun);
Alan Stern7c9d6f12007-01-08 11:12:32 -05001071 sdev->scsi_level = starget->scsi_level;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072 transport_setup_device(&sdev->sdev_gendev);
1073 spin_lock_irqsave(shost->host_lock, flags);
1074 list_add_tail(&sdev->same_target_siblings, &starget->devices);
1075 list_add_tail(&sdev->siblings, &shost->__devices);
1076 spin_unlock_irqrestore(shost->host_lock, flags);
1077}
1078
1079int scsi_is_sdev_device(const struct device *dev)
1080{
Kay Sievers13ba9bc2007-09-26 19:54:49 +02001081 return dev->type == &scsi_dev_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082}
1083EXPORT_SYMBOL(scsi_is_sdev_device);
1084
1085/* A blank transport template that is used in drivers that don't
1086 * yet implement Transport Attributes */
1087struct scsi_transport_template blank_transport_template = { { { {NULL, }, }, }, };