blob: 84e2a8ad83c9509a779b8f83727ce2413335537c [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>
10#include <linux/init.h>
11#include <linux/blkdev.h>
12#include <linux/device.h>
13
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>
Adrian Bunk44818ef2007-07-09 11:59:59 -070019#include <scsi/scsi_driver.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020
21#include "scsi_priv.h"
22#include "scsi_logging.h"
23
Hannes Reineckeb0ed4332008-03-18 14:32:28 +010024static struct device_type scsi_dev_type;
25
Arjan van de Ven0ad78202005-11-28 16:22:25 +010026static const struct {
Linus Torvalds1da177e2005-04-16 15:20:36 -070027 enum scsi_device_state value;
28 char *name;
29} sdev_states[] = {
30 { SDEV_CREATED, "created" },
31 { SDEV_RUNNING, "running" },
32 { SDEV_CANCEL, "cancel" },
33 { SDEV_DEL, "deleted" },
34 { SDEV_QUIESCE, "quiesce" },
35 { SDEV_OFFLINE, "offline" },
36 { SDEV_BLOCK, "blocked" },
37};
38
39const char *scsi_device_state_name(enum scsi_device_state state)
40{
41 int i;
42 char *name = NULL;
43
Tobias Klauser6391a112006-06-08 22:23:48 -070044 for (i = 0; i < ARRAY_SIZE(sdev_states); i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070045 if (sdev_states[i].value == state) {
46 name = sdev_states[i].name;
47 break;
48 }
49 }
50 return name;
51}
52
Arjan van de Ven0ad78202005-11-28 16:22:25 +010053static const struct {
Mike Andersond3301872005-06-16 11:12:38 -070054 enum scsi_host_state value;
55 char *name;
56} shost_states[] = {
57 { SHOST_CREATED, "created" },
58 { SHOST_RUNNING, "running" },
59 { SHOST_CANCEL, "cancel" },
60 { SHOST_DEL, "deleted" },
61 { SHOST_RECOVERY, "recovery" },
James Bottomley939647e2005-09-18 15:05:20 -050062 { SHOST_CANCEL_RECOVERY, "cancel/recovery" },
63 { SHOST_DEL_RECOVERY, "deleted/recovery", },
Mike Andersond3301872005-06-16 11:12:38 -070064};
65const char *scsi_host_state_name(enum scsi_host_state state)
66{
67 int i;
68 char *name = NULL;
69
Tobias Klauser6391a112006-06-08 22:23:48 -070070 for (i = 0; i < ARRAY_SIZE(shost_states); i++) {
Mike Andersond3301872005-06-16 11:12:38 -070071 if (shost_states[i].value == state) {
72 name = shost_states[i].name;
73 break;
74 }
75 }
76 return name;
77}
78
Linus Torvalds1da177e2005-04-16 15:20:36 -070079static int check_set(unsigned int *val, char *src)
80{
81 char *last;
82
83 if (strncmp(src, "-", 20) == 0) {
84 *val = SCAN_WILD_CARD;
85 } else {
86 /*
87 * Doesn't check for int overflow
88 */
89 *val = simple_strtoul(src, &last, 0);
90 if (*last != '\0')
91 return 1;
92 }
93 return 0;
94}
95
96static int scsi_scan(struct Scsi_Host *shost, const char *str)
97{
98 char s1[15], s2[15], s3[15], junk;
99 unsigned int channel, id, lun;
100 int res;
101
102 res = sscanf(str, "%10s %10s %10s %c", s1, s2, s3, &junk);
103 if (res != 3)
104 return -EINVAL;
105 if (check_set(&channel, s1))
106 return -EINVAL;
107 if (check_set(&id, s2))
108 return -EINVAL;
109 if (check_set(&lun, s3))
110 return -EINVAL;
Christoph Hellwige02f3f52006-01-13 19:04:00 +0100111 if (shost->transportt->user_scan)
112 res = shost->transportt->user_scan(shost, channel, id, lun);
113 else
114 res = scsi_scan_host_selected(shost, channel, id, lun, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115 return res;
116}
117
118/*
119 * shost_show_function: macro to create an attr function that can be used to
120 * show a non-bit field.
121 */
122#define shost_show_function(name, field, format_string) \
123static ssize_t \
Tony Jonesee959b02008-02-22 00:13:36 +0100124show_##name (struct device *dev, struct device_attribute *attr, \
125 char *buf) \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126{ \
Tony Jonesee959b02008-02-22 00:13:36 +0100127 struct Scsi_Host *shost = class_to_shost(dev); \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128 return snprintf (buf, 20, format_string, shost->field); \
129}
130
131/*
132 * shost_rd_attr: macro to create a function and attribute variable for a
133 * read only field.
134 */
135#define shost_rd_attr2(name, field, format_string) \
136 shost_show_function(name, field, format_string) \
Tony Jonesee959b02008-02-22 00:13:36 +0100137static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138
139#define shost_rd_attr(field, format_string) \
140shost_rd_attr2(field, field, format_string)
141
142/*
143 * Create the actual show/store functions and data structures.
144 */
145
Tony Jonesee959b02008-02-22 00:13:36 +0100146static ssize_t
147store_scan(struct device *dev, struct device_attribute *attr,
148 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149{
Tony Jonesee959b02008-02-22 00:13:36 +0100150 struct Scsi_Host *shost = class_to_shost(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151 int res;
152
153 res = scsi_scan(shost, buf);
154 if (res == 0)
155 res = count;
156 return res;
157};
Tony Jonesee959b02008-02-22 00:13:36 +0100158static DEVICE_ATTR(scan, S_IWUSR, NULL, store_scan);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159
Mike Andersond3301872005-06-16 11:12:38 -0700160static ssize_t
Tony Jonesee959b02008-02-22 00:13:36 +0100161store_shost_state(struct device *dev, struct device_attribute *attr,
162 const char *buf, size_t count)
Mike Andersond3301872005-06-16 11:12:38 -0700163{
164 int i;
Tony Jonesee959b02008-02-22 00:13:36 +0100165 struct Scsi_Host *shost = class_to_shost(dev);
Mike Andersond3301872005-06-16 11:12:38 -0700166 enum scsi_host_state state = 0;
167
Tobias Klauser6391a112006-06-08 22:23:48 -0700168 for (i = 0; i < ARRAY_SIZE(shost_states); i++) {
Mike Andersond3301872005-06-16 11:12:38 -0700169 const int len = strlen(shost_states[i].name);
170 if (strncmp(shost_states[i].name, buf, len) == 0 &&
171 buf[len] == '\n') {
172 state = shost_states[i].value;
173 break;
174 }
175 }
176 if (!state)
177 return -EINVAL;
178
179 if (scsi_host_set_state(shost, state))
180 return -EINVAL;
181 return count;
182}
183
184static ssize_t
Tony Jonesee959b02008-02-22 00:13:36 +0100185show_shost_state(struct device *dev, struct device_attribute *attr, char *buf)
Mike Andersond3301872005-06-16 11:12:38 -0700186{
Tony Jonesee959b02008-02-22 00:13:36 +0100187 struct Scsi_Host *shost = class_to_shost(dev);
Mike Andersond3301872005-06-16 11:12:38 -0700188 const char *name = scsi_host_state_name(shost->shost_state);
189
190 if (!name)
191 return -EINVAL;
192
193 return snprintf(buf, 20, "%s\n", name);
194}
195
Tony Jonesee959b02008-02-22 00:13:36 +0100196/* DEVICE_ATTR(state) clashes with dev_attr_state for sdev */
197struct device_attribute dev_attr_hstate =
198 __ATTR(state, S_IRUGO | S_IWUSR, show_shost_state, store_shost_state);
Mike Andersond3301872005-06-16 11:12:38 -0700199
FUJITA Tomonori5dc2b892007-09-01 02:02:20 +0900200static ssize_t
201show_shost_mode(unsigned int mode, char *buf)
202{
203 ssize_t len = 0;
204
205 if (mode & MODE_INITIATOR)
206 len = sprintf(buf, "%s", "Initiator");
207
208 if (mode & MODE_TARGET)
209 len += sprintf(buf + len, "%s%s", len ? ", " : "", "Target");
210
211 len += sprintf(buf + len, "\n");
212
213 return len;
214}
215
Tony Jonesee959b02008-02-22 00:13:36 +0100216static ssize_t
217show_shost_supported_mode(struct device *dev, struct device_attribute *attr,
218 char *buf)
FUJITA Tomonori5dc2b892007-09-01 02:02:20 +0900219{
Tony Jonesee959b02008-02-22 00:13:36 +0100220 struct Scsi_Host *shost = class_to_shost(dev);
James Bottomley7a39ac32007-09-25 22:45:53 -0500221 unsigned int supported_mode = shost->hostt->supported_mode;
FUJITA Tomonori5dc2b892007-09-01 02:02:20 +0900222
James Bottomley7a39ac32007-09-25 22:45:53 -0500223 if (supported_mode == MODE_UNKNOWN)
224 /* by default this should be initiator */
225 supported_mode = MODE_INITIATOR;
226
227 return show_shost_mode(supported_mode, buf);
FUJITA Tomonori5dc2b892007-09-01 02:02:20 +0900228}
229
Tony Jonesee959b02008-02-22 00:13:36 +0100230static DEVICE_ATTR(supported_mode, S_IRUGO | S_IWUSR, show_shost_supported_mode, NULL);
FUJITA Tomonori5dc2b892007-09-01 02:02:20 +0900231
Tony Jonesee959b02008-02-22 00:13:36 +0100232static ssize_t
233show_shost_active_mode(struct device *dev,
234 struct device_attribute *attr, char *buf)
FUJITA Tomonori5dc2b892007-09-01 02:02:20 +0900235{
Tony Jonesee959b02008-02-22 00:13:36 +0100236 struct Scsi_Host *shost = class_to_shost(dev);
FUJITA Tomonori5dc2b892007-09-01 02:02:20 +0900237
238 if (shost->active_mode == MODE_UNKNOWN)
239 return snprintf(buf, 20, "unknown\n");
240 else
241 return show_shost_mode(shost->active_mode, buf);
242}
243
Tony Jonesee959b02008-02-22 00:13:36 +0100244static DEVICE_ATTR(active_mode, S_IRUGO | S_IWUSR, show_shost_active_mode, NULL);
FUJITA Tomonori5dc2b892007-09-01 02:02:20 +0900245
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246shost_rd_attr(unique_id, "%u\n");
247shost_rd_attr(host_busy, "%hu\n");
248shost_rd_attr(cmd_per_lun, "%hd\n");
James Bottomleyed632da2006-10-16 10:06:27 -0500249shost_rd_attr(can_queue, "%hd\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250shost_rd_attr(sg_tablesize, "%hu\n");
251shost_rd_attr(unchecked_isa_dma, "%d\n");
252shost_rd_attr2(proc_name, hostt->proc_name, "%s\n");
253
Hannes Reineckef7120a42008-03-18 14:32:28 +0100254static struct attribute *scsi_sysfs_shost_attrs[] = {
255 &dev_attr_unique_id.attr,
256 &dev_attr_host_busy.attr,
257 &dev_attr_cmd_per_lun.attr,
258 &dev_attr_can_queue.attr,
259 &dev_attr_sg_tablesize.attr,
260 &dev_attr_unchecked_isa_dma.attr,
261 &dev_attr_proc_name.attr,
262 &dev_attr_scan.attr,
263 &dev_attr_hstate.attr,
264 &dev_attr_supported_mode.attr,
265 &dev_attr_active_mode.attr,
266 NULL
267};
268
269struct attribute_group scsi_shost_attr_group = {
270 .attrs = scsi_sysfs_shost_attrs,
271};
272
273struct attribute_group *scsi_sysfs_shost_attr_groups[] = {
274 &scsi_shost_attr_group,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275 NULL
276};
277
Tony Jonesee959b02008-02-22 00:13:36 +0100278static void scsi_device_cls_release(struct device *class_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279{
280 struct scsi_device *sdev;
281
282 sdev = class_to_sdev(class_dev);
283 put_device(&sdev->sdev_gendev);
284}
285
David Howells65f27f32006-11-22 14:55:48 +0000286static void scsi_device_dev_release_usercontext(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287{
288 struct scsi_device *sdev;
289 struct device *parent;
290 struct scsi_target *starget;
Jeff Garzika341cd02007-10-29 17:15:22 -0400291 struct list_head *this, *tmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 unsigned long flags;
293
David Howells65f27f32006-11-22 14:55:48 +0000294 sdev = container_of(work, struct scsi_device, ew.work);
295
296 parent = sdev->sdev_gendev.parent;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 starget = to_scsi_target(parent);
298
299 spin_lock_irqsave(sdev->host->host_lock, flags);
300 starget->reap_ref++;
301 list_del(&sdev->siblings);
302 list_del(&sdev->same_target_siblings);
303 list_del(&sdev->starved_entry);
304 spin_unlock_irqrestore(sdev->host->host_lock, flags);
305
Jeff Garzika341cd02007-10-29 17:15:22 -0400306 cancel_work_sync(&sdev->event_work);
307
308 list_for_each_safe(this, tmp, &sdev->event_list) {
309 struct scsi_event *evt;
310
311 evt = list_entry(this, struct scsi_event, node);
312 list_del(&evt->node);
313 kfree(evt);
314 }
315
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316 if (sdev->request_queue) {
317 sdev->request_queue->queuedata = NULL;
James Bottomley65110b22006-02-14 10:48:46 -0600318 /* user context needed to free queue */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319 scsi_free_queue(sdev->request_queue);
c2a93312005-04-12 16:38:09 -0500320 /* temporary expedient, try to catch use of queue lock
321 * after free of sdev */
322 sdev->request_queue = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323 }
324
325 scsi_target_reap(scsi_target(sdev));
326
327 kfree(sdev->inquiry);
328 kfree(sdev);
329
330 if (parent)
331 put_device(parent);
332}
333
James Bottomley65110b22006-02-14 10:48:46 -0600334static void scsi_device_dev_release(struct device *dev)
335{
James Bottomleyffedb452006-02-23 14:27:18 -0600336 struct scsi_device *sdp = to_scsi_device(dev);
David Howells65f27f32006-11-22 14:55:48 +0000337 execute_in_process_context(scsi_device_dev_release_usercontext,
James Bottomleyffedb452006-02-23 14:27:18 -0600338 &sdp->ew);
James Bottomley65110b22006-02-14 10:48:46 -0600339}
340
Adrian Bunk52c1da32005-06-23 22:05:33 -0700341static struct class sdev_class = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 .name = "scsi_device",
Tony Jonesee959b02008-02-22 00:13:36 +0100343 .dev_release = scsi_device_cls_release,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344};
345
346/* all probing is done in the individual ->probe routines */
347static int scsi_bus_match(struct device *dev, struct device_driver *gendrv)
348{
Hannes Reineckeb0ed4332008-03-18 14:32:28 +0100349 struct scsi_device *sdp;
350
351 if (dev->type != &scsi_dev_type)
352 return 0;
353
354 sdp = to_scsi_device(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 if (sdp->no_uld_attach)
356 return 0;
357 return (sdp->inq_periph_qual == SCSI_INQ_PQ_CON)? 1: 0;
358}
359
Kay Sievers7eff2e72007-08-14 15:15:12 +0200360static int scsi_bus_uevent(struct device *dev, struct kobj_uevent_env *env)
Michael Tokarevd7b8bcb2006-10-27 16:02:37 +0400361{
362 struct scsi_device *sdev = to_scsi_device(dev);
Michael Tokarevd7b8bcb2006-10-27 16:02:37 +0400363
Kay Sievers7eff2e72007-08-14 15:15:12 +0200364 add_uevent_var(env, "MODALIAS=" SCSI_DEVICE_MODALIAS_FMT, sdev->type);
Michael Tokarevd7b8bcb2006-10-27 16:02:37 +0400365 return 0;
366}
367
Jens Axboe9b847542006-01-06 09:28:07 +0100368static int scsi_bus_suspend(struct device * dev, pm_message_t state)
369{
Hannes Reineckeb0ed4332008-03-18 14:32:28 +0100370 struct device_driver *drv;
371 struct scsi_device *sdev;
Jens Axboe9b847542006-01-06 09:28:07 +0100372 int err;
373
Hannes Reineckeb0ed4332008-03-18 14:32:28 +0100374 if (dev->type != &scsi_dev_type)
375 return 0;
376
377 drv = dev->driver;
378 sdev = to_scsi_device(dev);
379
Jens Axboe9b847542006-01-06 09:28:07 +0100380 err = scsi_device_quiesce(sdev);
381 if (err)
382 return err;
383
Tejun Heoc3c94c52007-03-21 00:13:59 +0900384 if (drv && drv->suspend) {
385 err = drv->suspend(dev, state);
386 if (err)
387 return err;
388 }
Jens Axboe9b847542006-01-06 09:28:07 +0100389
Tejun Heoc3c94c52007-03-21 00:13:59 +0900390 return 0;
Jens Axboe9b847542006-01-06 09:28:07 +0100391}
392
393static int scsi_bus_resume(struct device * dev)
394{
Hannes Reineckeb0ed4332008-03-18 14:32:28 +0100395 struct device_driver *drv;
396 struct scsi_device *sdev;
Tejun Heo1dfcda02007-03-21 16:05:16 +0900397 int err = 0;
Jens Axboe9b847542006-01-06 09:28:07 +0100398
Hannes Reineckeb0ed4332008-03-18 14:32:28 +0100399 if (dev->type != &scsi_dev_type)
400 return 0;
401
402 drv = dev->driver;
403 sdev = to_scsi_device(dev);
404
Tejun Heoc3c94c52007-03-21 00:13:59 +0900405 if (drv && drv->resume)
Tejun Heo1dfcda02007-03-21 16:05:16 +0900406 err = drv->resume(dev);
Tejun Heoc3c94c52007-03-21 00:13:59 +0900407
Jens Axboe9b847542006-01-06 09:28:07 +0100408 scsi_device_resume(sdev);
Tejun Heoc3c94c52007-03-21 00:13:59 +0900409
Tejun Heo1dfcda02007-03-21 16:05:16 +0900410 return err;
Jens Axboe9b847542006-01-06 09:28:07 +0100411}
412
James Bottomley751bf4d2008-01-02 11:14:30 -0600413static int scsi_bus_remove(struct device *dev)
414{
415 struct device_driver *drv = dev->driver;
416 struct scsi_device *sdev = to_scsi_device(dev);
417 int err = 0;
418
419 /* reset the prep_fn back to the default since the
420 * driver may have altered it and it's being removed */
421 blk_queue_prep_rq(sdev->request_queue, scsi_prep_fn);
422
423 if (drv && drv->remove)
424 err = drv->remove(dev);
425
426 return 0;
427}
428
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429struct bus_type scsi_bus_type = {
430 .name = "scsi",
431 .match = scsi_bus_match,
Michael Tokarevd7b8bcb2006-10-27 16:02:37 +0400432 .uevent = scsi_bus_uevent,
Jens Axboe9b847542006-01-06 09:28:07 +0100433 .suspend = scsi_bus_suspend,
434 .resume = scsi_bus_resume,
James Bottomley751bf4d2008-01-02 11:14:30 -0600435 .remove = scsi_bus_remove,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436};
437
438int scsi_sysfs_register(void)
439{
440 int error;
441
442 error = bus_register(&scsi_bus_type);
443 if (!error) {
444 error = class_register(&sdev_class);
445 if (error)
446 bus_unregister(&scsi_bus_type);
447 }
448
449 return error;
450}
451
452void scsi_sysfs_unregister(void)
453{
454 class_unregister(&sdev_class);
455 bus_unregister(&scsi_bus_type);
456}
457
458/*
459 * sdev_show_function: macro to create an attr function that can be used to
460 * show a non-bit field.
461 */
462#define sdev_show_function(field, format_string) \
463static ssize_t \
Tony Jonesee959b02008-02-22 00:13:36 +0100464sdev_show_##field (struct device *dev, struct device_attribute *attr, \
465 char *buf) \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466{ \
467 struct scsi_device *sdev; \
468 sdev = to_scsi_device(dev); \
469 return snprintf (buf, 20, format_string, sdev->field); \
470} \
471
472/*
473 * sdev_rd_attr: macro to create a function and attribute variable for a
474 * read only field.
475 */
476#define sdev_rd_attr(field, format_string) \
477 sdev_show_function(field, format_string) \
478static DEVICE_ATTR(field, S_IRUGO, sdev_show_##field, NULL);
479
480
481/*
482 * sdev_rd_attr: create a function and attribute variable for a
483 * read/write field.
484 */
485#define sdev_rw_attr(field, format_string) \
486 sdev_show_function(field, format_string) \
487 \
488static ssize_t \
Tony Jonesee959b02008-02-22 00:13:36 +0100489sdev_store_##field (struct device *dev, struct device_attribute *attr, \
490 const char *buf, size_t count) \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491{ \
492 struct scsi_device *sdev; \
493 sdev = to_scsi_device(dev); \
494 snscanf (buf, 20, format_string, &sdev->field); \
495 return count; \
496} \
497static DEVICE_ATTR(field, S_IRUGO | S_IWUSR, sdev_show_##field, sdev_store_##field);
498
499/* Currently we don't export bit fields, but we might in future,
500 * so leave this code in */
501#if 0
502/*
503 * sdev_rd_attr: create a function and attribute variable for a
504 * read/write bit field.
505 */
506#define sdev_rw_attr_bit(field) \
507 sdev_show_function(field, "%d\n") \
508 \
509static ssize_t \
Tony Jonesee959b02008-02-22 00:13:36 +0100510sdev_store_##field (struct device *dev, struct device_attribute *attr, \
511 const char *buf, size_t count) \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512{ \
513 int ret; \
514 struct scsi_device *sdev; \
515 ret = scsi_sdev_check_buf_bit(buf); \
516 if (ret >= 0) { \
517 sdev = to_scsi_device(dev); \
518 sdev->field = ret; \
519 ret = count; \
520 } \
521 return ret; \
522} \
523static DEVICE_ATTR(field, S_IRUGO | S_IWUSR, sdev_show_##field, sdev_store_##field);
524
525/*
526 * scsi_sdev_check_buf_bit: return 0 if buf is "0", return 1 if buf is "1",
527 * else return -EINVAL.
528 */
529static int scsi_sdev_check_buf_bit(const char *buf)
530{
531 if ((buf[1] == '\0') || ((buf[1] == '\n') && (buf[2] == '\0'))) {
532 if (buf[0] == '1')
533 return 1;
534 else if (buf[0] == '0')
535 return 0;
536 else
537 return -EINVAL;
538 } else
539 return -EINVAL;
540}
541#endif
542/*
543 * Create the actual show/store functions and data structures.
544 */
545sdev_rd_attr (device_blocked, "%d\n");
546sdev_rd_attr (queue_depth, "%d\n");
547sdev_rd_attr (type, "%d\n");
548sdev_rd_attr (scsi_level, "%d\n");
549sdev_rd_attr (vendor, "%.8s\n");
550sdev_rd_attr (model, "%.16s\n");
551sdev_rd_attr (rev, "%.4s\n");
552
553static ssize_t
Yani Ioannou10523b32005-05-17 06:43:37 -0400554sdev_show_timeout (struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555{
556 struct scsi_device *sdev;
557 sdev = to_scsi_device(dev);
558 return snprintf (buf, 20, "%d\n", sdev->timeout / HZ);
559}
560
561static ssize_t
Tony Jonesee959b02008-02-22 00:13:36 +0100562sdev_store_timeout (struct device *dev, struct device_attribute *attr,
563 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564{
565 struct scsi_device *sdev;
566 int timeout;
567 sdev = to_scsi_device(dev);
568 sscanf (buf, "%d\n", &timeout);
569 sdev->timeout = timeout * HZ;
570 return count;
571}
572static DEVICE_ATTR(timeout, S_IRUGO | S_IWUSR, sdev_show_timeout, sdev_store_timeout);
573
574static ssize_t
Tony Jonesee959b02008-02-22 00:13:36 +0100575store_rescan_field (struct device *dev, struct device_attribute *attr,
576 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577{
578 scsi_rescan_device(dev);
579 return count;
580}
581static DEVICE_ATTR(rescan, S_IWUSR, NULL, store_rescan_field);
582
Alan Sternd9a9cdf2007-03-15 15:50:34 -0400583static void sdev_store_delete_callback(struct device *dev)
584{
585 scsi_remove_device(to_scsi_device(dev));
586}
587
Tony Jonesee959b02008-02-22 00:13:36 +0100588static ssize_t
589sdev_store_delete(struct device *dev, struct device_attribute *attr,
590 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591{
Alan Sternd9a9cdf2007-03-15 15:50:34 -0400592 int rc;
593
594 /* An attribute cannot be unregistered by one of its own methods,
595 * so we have to use this roundabout approach.
596 */
597 rc = device_schedule_callback(dev, sdev_store_delete_callback);
598 if (rc)
599 count = rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600 return count;
601};
602static DEVICE_ATTR(delete, S_IWUSR, NULL, sdev_store_delete);
603
604static ssize_t
Tony Jonesee959b02008-02-22 00:13:36 +0100605store_state_field(struct device *dev, struct device_attribute *attr,
606 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607{
608 int i;
609 struct scsi_device *sdev = to_scsi_device(dev);
610 enum scsi_device_state state = 0;
611
Tobias Klauser6391a112006-06-08 22:23:48 -0700612 for (i = 0; i < ARRAY_SIZE(sdev_states); i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613 const int len = strlen(sdev_states[i].name);
614 if (strncmp(sdev_states[i].name, buf, len) == 0 &&
615 buf[len] == '\n') {
616 state = sdev_states[i].value;
617 break;
618 }
619 }
620 if (!state)
621 return -EINVAL;
622
623 if (scsi_device_set_state(sdev, state))
624 return -EINVAL;
625 return count;
626}
627
628static ssize_t
Yani Ioannou10523b32005-05-17 06:43:37 -0400629show_state_field(struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630{
631 struct scsi_device *sdev = to_scsi_device(dev);
632 const char *name = scsi_device_state_name(sdev->sdev_state);
633
634 if (!name)
635 return -EINVAL;
636
637 return snprintf(buf, 20, "%s\n", name);
638}
639
640static DEVICE_ATTR(state, S_IRUGO | S_IWUSR, show_state_field, store_state_field);
641
642static ssize_t
Tony Jonesee959b02008-02-22 00:13:36 +0100643show_queue_type_field(struct device *dev, struct device_attribute *attr,
644 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645{
646 struct scsi_device *sdev = to_scsi_device(dev);
647 const char *name = "none";
648
649 if (sdev->ordered_tags)
650 name = "ordered";
651 else if (sdev->simple_tags)
652 name = "simple";
653
654 return snprintf(buf, 20, "%s\n", name);
655}
656
657static DEVICE_ATTR(queue_type, S_IRUGO, show_queue_type_field, NULL);
658
659static ssize_t
Tony Jonesee959b02008-02-22 00:13:36 +0100660show_iostat_counterbits(struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661{
662 return snprintf(buf, 20, "%d\n", (int)sizeof(atomic_t) * 8);
663}
664
665static DEVICE_ATTR(iocounterbits, S_IRUGO, show_iostat_counterbits, NULL);
666
667#define show_sdev_iostat(field) \
668static ssize_t \
Tony Jonesee959b02008-02-22 00:13:36 +0100669show_iostat_##field(struct device *dev, struct device_attribute *attr, \
670 char *buf) \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671{ \
672 struct scsi_device *sdev = to_scsi_device(dev); \
673 unsigned long long count = atomic_read(&sdev->field); \
674 return snprintf(buf, 20, "0x%llx\n", count); \
675} \
676static DEVICE_ATTR(field, S_IRUGO, show_iostat_##field, NULL)
677
678show_sdev_iostat(iorequest_cnt);
679show_sdev_iostat(iodone_cnt);
680show_sdev_iostat(ioerr_cnt);
681
Michael Tokarevd7b8bcb2006-10-27 16:02:37 +0400682static ssize_t
683sdev_show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
684{
685 struct scsi_device *sdev;
686 sdev = to_scsi_device(dev);
687 return snprintf (buf, 20, SCSI_DEVICE_MODALIAS_FMT "\n", sdev->type);
688}
689static DEVICE_ATTR(modalias, S_IRUGO, sdev_show_modalias, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690
Jeff Garzika341cd02007-10-29 17:15:22 -0400691#define DECLARE_EVT_SHOW(name, Cap_name) \
692static ssize_t \
693sdev_show_evt_##name(struct device *dev, struct device_attribute *attr, \
Tony Jonesee959b02008-02-22 00:13:36 +0100694 char *buf) \
Jeff Garzika341cd02007-10-29 17:15:22 -0400695{ \
696 struct scsi_device *sdev = to_scsi_device(dev); \
697 int val = test_bit(SDEV_EVT_##Cap_name, sdev->supported_events);\
698 return snprintf(buf, 20, "%d\n", val); \
699}
700
701#define DECLARE_EVT_STORE(name, Cap_name) \
702static ssize_t \
Tony Jonesee959b02008-02-22 00:13:36 +0100703sdev_store_evt_##name(struct device *dev, struct device_attribute *attr,\
Jeff Garzika341cd02007-10-29 17:15:22 -0400704 const char *buf, size_t count) \
705{ \
706 struct scsi_device *sdev = to_scsi_device(dev); \
707 int val = simple_strtoul(buf, NULL, 0); \
708 if (val == 0) \
709 clear_bit(SDEV_EVT_##Cap_name, sdev->supported_events); \
710 else if (val == 1) \
711 set_bit(SDEV_EVT_##Cap_name, sdev->supported_events); \
712 else \
713 return -EINVAL; \
714 return count; \
715}
716
717#define DECLARE_EVT(name, Cap_name) \
718 DECLARE_EVT_SHOW(name, Cap_name) \
719 DECLARE_EVT_STORE(name, Cap_name) \
720 static DEVICE_ATTR(evt_##name, S_IRUGO, sdev_show_evt_##name, \
721 sdev_store_evt_##name);
722#define REF_EVT(name) &dev_attr_evt_##name.attr
723
724DECLARE_EVT(media_change, MEDIA_CHANGE)
725
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726/* Default template for device attributes. May NOT be modified */
Kay Sieversbfd12942007-09-11 17:00:14 +0200727static struct attribute *scsi_sdev_attrs[] = {
728 &dev_attr_device_blocked.attr,
729 &dev_attr_type.attr,
730 &dev_attr_scsi_level.attr,
731 &dev_attr_vendor.attr,
732 &dev_attr_model.attr,
733 &dev_attr_rev.attr,
734 &dev_attr_rescan.attr,
735 &dev_attr_delete.attr,
736 &dev_attr_state.attr,
737 &dev_attr_timeout.attr,
738 &dev_attr_iocounterbits.attr,
739 &dev_attr_iorequest_cnt.attr,
740 &dev_attr_iodone_cnt.attr,
741 &dev_attr_ioerr_cnt.attr,
742 &dev_attr_modalias.attr,
Jeff Garzika341cd02007-10-29 17:15:22 -0400743 REF_EVT(media_change),
Kay Sieversbfd12942007-09-11 17:00:14 +0200744 NULL
745};
746
747static struct attribute_group scsi_sdev_attr_group = {
748 .attrs = scsi_sdev_attrs,
749};
750
751static struct attribute_group *scsi_sdev_attr_groups[] = {
752 &scsi_sdev_attr_group,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753 NULL
754};
755
Tony Jonesee959b02008-02-22 00:13:36 +0100756static ssize_t
757sdev_store_queue_depth_rw(struct device *dev, struct device_attribute *attr,
758 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759{
760 int depth, retval;
761 struct scsi_device *sdev = to_scsi_device(dev);
762 struct scsi_host_template *sht = sdev->host->hostt;
763
764 if (!sht->change_queue_depth)
765 return -EINVAL;
766
767 depth = simple_strtoul(buf, NULL, 0);
768
769 if (depth < 1)
770 return -EINVAL;
771
772 retval = sht->change_queue_depth(sdev, depth);
773 if (retval < 0)
774 return retval;
775
776 return count;
777}
778
779static struct device_attribute sdev_attr_queue_depth_rw =
780 __ATTR(queue_depth, S_IRUGO | S_IWUSR, sdev_show_queue_depth,
781 sdev_store_queue_depth_rw);
782
Tony Jonesee959b02008-02-22 00:13:36 +0100783static ssize_t
784sdev_store_queue_type_rw(struct device *dev, struct device_attribute *attr,
785 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786{
787 struct scsi_device *sdev = to_scsi_device(dev);
788 struct scsi_host_template *sht = sdev->host->hostt;
789 int tag_type = 0, retval;
790 int prev_tag_type = scsi_get_tag_type(sdev);
791
792 if (!sdev->tagged_supported || !sht->change_queue_type)
793 return -EINVAL;
794
795 if (strncmp(buf, "ordered", 7) == 0)
796 tag_type = MSG_ORDERED_TAG;
797 else if (strncmp(buf, "simple", 6) == 0)
798 tag_type = MSG_SIMPLE_TAG;
799 else if (strncmp(buf, "none", 4) != 0)
800 return -EINVAL;
801
802 if (tag_type == prev_tag_type)
803 return count;
804
805 retval = sht->change_queue_type(sdev, tag_type);
806 if (retval < 0)
807 return retval;
808
809 return count;
810}
811
812static struct device_attribute sdev_attr_queue_type_rw =
813 __ATTR(queue_type, S_IRUGO | S_IWUSR, show_queue_type_field,
814 sdev_store_queue_type_rw);
815
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816/**
817 * scsi_sysfs_add_sdev - add scsi device to sysfs
818 * @sdev: scsi_device to add
819 *
820 * Return value:
821 * 0 on Success / non-zero on Failure
822 **/
823int scsi_sysfs_add_sdev(struct scsi_device *sdev)
824{
825 int error, i;
James Bottomley80ed71c2007-07-19 10:15:10 -0500826 struct request_queue *rq = sdev->request_queue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827
828 if ((error = scsi_device_set_state(sdev, SDEV_RUNNING)) != 0)
829 return error;
830
831 error = device_add(&sdev->sdev_gendev);
832 if (error) {
833 put_device(sdev->sdev_gendev.parent);
834 printk(KERN_INFO "error 1\n");
835 return error;
836 }
Tony Jonesee959b02008-02-22 00:13:36 +0100837 error = device_add(&sdev->sdev_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838 if (error) {
839 printk(KERN_INFO "error 2\n");
840 goto clean_device;
841 }
842
Tony Jonesee959b02008-02-22 00:13:36 +0100843 /* take a reference for the sdev_dev; this is
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844 * released by the sdev_class .release */
845 get_device(&sdev->sdev_gendev);
James Bottomley80ed71c2007-07-19 10:15:10 -0500846
Kay Sieversbfd12942007-09-11 17:00:14 +0200847 /* create queue files, which may be writable, depending on the host */
848 if (sdev->host->hostt->change_queue_depth)
849 error = device_create_file(&sdev->sdev_gendev, &sdev_attr_queue_depth_rw);
850 else
851 error = device_create_file(&sdev->sdev_gendev, &dev_attr_queue_depth);
852 if (error) {
853 __scsi_remove_device(sdev);
854 goto out;
855 }
856 if (sdev->host->hostt->change_queue_type)
857 error = device_create_file(&sdev->sdev_gendev, &sdev_attr_queue_type_rw);
858 else
859 error = device_create_file(&sdev->sdev_gendev, &dev_attr_queue_type);
860 if (error) {
861 __scsi_remove_device(sdev);
862 goto out;
863 }
864
James Bottomley39dca552007-07-20 18:22:17 -0500865 error = bsg_register_queue(rq, &sdev->sdev_gendev, NULL);
James Bottomley80ed71c2007-07-19 10:15:10 -0500866
867 if (error)
868 sdev_printk(KERN_INFO, sdev,
869 "Failed to register bsg queue, errno=%d\n", error);
870
871 /* we're treating error on bsg register as non-fatal, so pretend
872 * nothing went wrong */
873 error = 0;
874
Kay Sieversbfd12942007-09-11 17:00:14 +0200875 /* add additional host specific attributes */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876 if (sdev->host->hostt->sdev_attrs) {
877 for (i = 0; sdev->host->hostt->sdev_attrs[i]; i++) {
Kay Sieversbfd12942007-09-11 17:00:14 +0200878 error = device_create_file(&sdev->sdev_gendev,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879 sdev->host->hostt->sdev_attrs[i]);
880 if (error) {
Alan Stern903f4fe2005-07-26 10:20:53 -0400881 __scsi_remove_device(sdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882 goto out;
883 }
884 }
885 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886
887 transport_add_device(&sdev->sdev_gendev);
888 out:
889 return error;
890
891 clean_device:
892 scsi_device_set_state(sdev, SDEV_CANCEL);
893
894 device_del(&sdev->sdev_gendev);
895 transport_destroy_device(&sdev->sdev_gendev);
896 put_device(&sdev->sdev_gendev);
897
898 return error;
899}
900
Alan Stern903f4fe2005-07-26 10:20:53 -0400901void __scsi_remove_device(struct scsi_device *sdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902{
James Bottomleydf133c22005-11-06 11:47:08 -0600903 struct device *dev = &sdev->sdev_gendev;
904
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905 if (scsi_device_set_state(sdev, SDEV_CANCEL) != 0)
Alan Stern903f4fe2005-07-26 10:20:53 -0400906 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907
James Bottomley0feed272008-03-26 09:09:19 -0700908 bsg_unregister_queue(sdev->request_queue);
Tony Jonesee959b02008-02-22 00:13:36 +0100909 device_unregister(&sdev->sdev_dev);
James Bottomleydf133c22005-11-06 11:47:08 -0600910 transport_remove_device(dev);
911 device_del(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912 scsi_device_set_state(sdev, SDEV_DEL);
913 if (sdev->host->hostt->slave_destroy)
914 sdev->host->hostt->slave_destroy(sdev);
James Bottomleydf133c22005-11-06 11:47:08 -0600915 transport_destroy_device(dev);
916 put_device(dev);
Alan Stern903f4fe2005-07-26 10:20:53 -0400917}
918
919/**
920 * scsi_remove_device - unregister a device from the scsi bus
921 * @sdev: scsi_device to unregister
922 **/
923void scsi_remove_device(struct scsi_device *sdev)
924{
Alan Stern54195002005-09-15 21:52:51 -0400925 struct Scsi_Host *shost = sdev->host;
926
Arjan van de Ven0b950672006-01-11 13:16:10 +0100927 mutex_lock(&shost->scan_mutex);
Alan Stern903f4fe2005-07-26 10:20:53 -0400928 __scsi_remove_device(sdev);
Arjan van de Ven0b950672006-01-11 13:16:10 +0100929 mutex_unlock(&shost->scan_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930}
931EXPORT_SYMBOL(scsi_remove_device);
932
Adrian Bunk44818ef2007-07-09 11:59:59 -0700933static void __scsi_remove_target(struct scsi_target *starget)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934{
935 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
936 unsigned long flags;
Alan Sterna64358d2005-07-26 10:27:10 -0400937 struct scsi_device *sdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938
939 spin_lock_irqsave(shost->host_lock, flags);
940 starget->reap_ref++;
Alan Sterna64358d2005-07-26 10:27:10 -0400941 restart:
942 list_for_each_entry(sdev, &shost->__devices, siblings) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943 if (sdev->channel != starget->channel ||
Alan Sterna64358d2005-07-26 10:27:10 -0400944 sdev->id != starget->id ||
945 sdev->sdev_state == SDEV_DEL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946 continue;
947 spin_unlock_irqrestore(shost->host_lock, flags);
948 scsi_remove_device(sdev);
949 spin_lock_irqsave(shost->host_lock, flags);
Alan Sterna64358d2005-07-26 10:27:10 -0400950 goto restart;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951 }
952 spin_unlock_irqrestore(shost->host_lock, flags);
953 scsi_target_reap(starget);
954}
955
mochel@digitalimplant.org20b1e672005-03-24 19:03:59 -0800956static int __remove_child (struct device * dev, void * data)
957{
958 if (scsi_is_target_device(dev))
959 __scsi_remove_target(to_scsi_target(dev));
960 return 0;
961}
962
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963/**
964 * scsi_remove_target - try to remove a target and all its devices
965 * @dev: generic starget or parent of generic stargets to be removed
966 *
967 * Note: This is slightly racy. It is possible that if the user
968 * requests the addition of another device then the target won't be
969 * removed.
970 */
971void scsi_remove_target(struct device *dev)
972{
mochel@digitalimplant.org20b1e672005-03-24 19:03:59 -0800973 struct device *rdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700974
975 if (scsi_is_target_device(dev)) {
976 __scsi_remove_target(to_scsi_target(dev));
977 return;
978 }
979
980 rdev = get_device(dev);
mochel@digitalimplant.org20b1e672005-03-24 19:03:59 -0800981 device_for_each_child(dev, NULL, __remove_child);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700982 put_device(rdev);
983}
984EXPORT_SYMBOL(scsi_remove_target);
985
986int scsi_register_driver(struct device_driver *drv)
987{
988 drv->bus = &scsi_bus_type;
989
990 return driver_register(drv);
991}
992EXPORT_SYMBOL(scsi_register_driver);
993
994int scsi_register_interface(struct class_interface *intf)
995{
996 intf->class = &sdev_class;
997
998 return class_interface_register(intf);
999}
1000EXPORT_SYMBOL(scsi_register_interface);
1001
Linus Torvalds1da177e2005-04-16 15:20:36 -07001002/**
1003 * scsi_sysfs_add_host - add scsi host to subsystem
1004 * @shost: scsi host struct to add to subsystem
1005 * @dev: parent struct device pointer
1006 **/
1007int scsi_sysfs_add_host(struct Scsi_Host *shost)
1008{
1009 int error, i;
1010
Hannes Reineckef7120a42008-03-18 14:32:28 +01001011 /* add host specific attributes */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012 if (shost->hostt->shost_attrs) {
1013 for (i = 0; shost->hostt->shost_attrs[i]; i++) {
Tony Jonesee959b02008-02-22 00:13:36 +01001014 error = device_create_file(&shost->shost_dev,
Hannes Reineckef7120a42008-03-18 14:32:28 +01001015 shost->hostt->shost_attrs[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016 if (error)
1017 return error;
1018 }
1019 }
1020
1021 transport_register_device(&shost->shost_gendev);
James Bottomleyd52b3812008-01-05 09:38:30 -06001022 transport_configure_device(&shost->shost_gendev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001023 return 0;
1024}
1025
Kay Sieversbfd12942007-09-11 17:00:14 +02001026static struct device_type scsi_dev_type = {
1027 .name = "scsi_device",
1028 .release = scsi_device_dev_release,
1029 .groups = scsi_sdev_attr_groups,
1030};
1031
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032void scsi_sysfs_device_initialize(struct scsi_device *sdev)
1033{
1034 unsigned long flags;
1035 struct Scsi_Host *shost = sdev->host;
1036 struct scsi_target *starget = sdev->sdev_target;
1037
1038 device_initialize(&sdev->sdev_gendev);
1039 sdev->sdev_gendev.bus = &scsi_bus_type;
Kay Sieversbfd12942007-09-11 17:00:14 +02001040 sdev->sdev_gendev.type = &scsi_dev_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041 sprintf(sdev->sdev_gendev.bus_id,"%d:%d:%d:%d",
1042 sdev->host->host_no, sdev->channel, sdev->id,
1043 sdev->lun);
1044
Tony Jonesee959b02008-02-22 00:13:36 +01001045 device_initialize(&sdev->sdev_dev);
1046 sdev->sdev_dev.parent = &sdev->sdev_gendev;
1047 sdev->sdev_dev.class = &sdev_class;
1048 snprintf(sdev->sdev_dev.bus_id, BUS_ID_SIZE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049 "%d:%d:%d:%d", sdev->host->host_no,
1050 sdev->channel, sdev->id, sdev->lun);
Alan Stern7c9d6f12007-01-08 11:12:32 -05001051 sdev->scsi_level = starget->scsi_level;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052 transport_setup_device(&sdev->sdev_gendev);
1053 spin_lock_irqsave(shost->host_lock, flags);
1054 list_add_tail(&sdev->same_target_siblings, &starget->devices);
1055 list_add_tail(&sdev->siblings, &shost->__devices);
1056 spin_unlock_irqrestore(shost->host_lock, flags);
1057}
1058
1059int scsi_is_sdev_device(const struct device *dev)
1060{
Kay Sievers13ba9bc2007-09-26 19:54:49 +02001061 return dev->type == &scsi_dev_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062}
1063EXPORT_SYMBOL(scsi_is_sdev_device);
1064
1065/* A blank transport template that is used in drivers that don't
1066 * yet implement Transport Attributes */
1067struct scsi_transport_template blank_transport_template = { { { {NULL, }, }, }, };