2 * Parallel SCSI (SPI) transport specific attributes exported to sysfs.
4 * Copyright (c) 2003 Silicon Graphics, Inc. All rights reserved.
5 * Copyright (c) 2004, 2005 James Bottomley <James.Bottomley@SteelEye.com>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 #include <linux/ctype.h>
22 #include <linux/init.h>
23 #include <linux/module.h>
24 #include <linux/workqueue.h>
25 #include <linux/blkdev.h>
26 #include <asm/semaphore.h>
27 #include <scsi/scsi.h>
28 #include "scsi_priv.h"
29 #include <scsi/scsi_device.h>
30 #include <scsi/scsi_host.h>
31 #include <scsi/scsi_request.h>
32 #include <scsi/scsi_eh.h>
33 #include <scsi/scsi_transport.h>
34 #include <scsi/scsi_transport_spi.h>
36 #define SPI_PRINTK(x, l, f, a...) dev_printk(l, &(x)->dev, f , ##a)
38 #define SPI_NUM_ATTRS 13 /* increase this if you add attributes */
39 #define SPI_OTHER_ATTRS 1 /* Increase this if you add "always
41 #define SPI_HOST_ATTRS 1
43 #define SPI_MAX_ECHO_BUFFER_SIZE 4096
46 #define DV_TIMEOUT (10*HZ)
47 #define DV_RETRIES 3 /* should only need at most
50 /* Private data accessors (keep these out of the header file) */
51 #define spi_dv_pending(x) (((struct spi_transport_attrs *)&(x)->starget_data)->dv_pending)
52 #define spi_dv_sem(x) (((struct spi_transport_attrs *)&(x)->starget_data)->dv_sem)
55 struct scsi_transport_template t
;
56 struct spi_function_template
*f
;
57 /* The actual attributes */
58 struct class_device_attribute private_attrs
[SPI_NUM_ATTRS
];
59 /* The array of null terminated pointers to attributes
60 * needed by scsi_sysfs.c */
61 struct class_device_attribute
*attrs
[SPI_NUM_ATTRS
+ SPI_OTHER_ATTRS
+ 1];
62 struct class_device_attribute private_host_attrs
[SPI_HOST_ATTRS
];
63 struct class_device_attribute
*host_attrs
[SPI_HOST_ATTRS
+ 1];
66 #define to_spi_internal(tmpl) container_of(tmpl, struct spi_internal, t)
68 static const int ppr_to_ps
[] = {
69 /* The PPR values 0-6 are reserved, fill them in when
70 * the committee defines them */
85 /* The PPR values at which you calculate the period in ns by multiplying
87 #define SPI_STATIC_PPR 0x0c
89 static int sprint_frac(char *dest
, int value
, int denom
)
91 int frac
= value
% denom
;
92 int result
= sprintf(dest
, "%d", value
/ denom
);
100 sprintf(dest
+ result
, "%d", frac
/ denom
);
105 dest
[result
++] = '\0';
109 /* Modification of scsi_wait_req that will clear UNIT ATTENTION conditions
110 * resulting from (likely) bus and device resets */
111 static void spi_wait_req(struct scsi_request
*sreq
, const void *cmd
,
112 void *buffer
, unsigned bufflen
)
116 for(i
= 0; i
< DV_RETRIES
; i
++) {
117 sreq
->sr_request
->flags
|= REQ_FAILFAST
;
119 scsi_wait_req(sreq
, cmd
, buffer
, bufflen
,
120 DV_TIMEOUT
, /* retries */ 1);
121 if (sreq
->sr_result
& DRIVER_SENSE
) {
122 struct scsi_sense_hdr sshdr
;
124 if (scsi_request_normalize_sense(sreq
, &sshdr
)
125 && sshdr
.sense_key
== UNIT_ATTENTION
)
133 enum spi_signal_type value
;
136 { SPI_SIGNAL_UNKNOWN
, "unknown" },
137 { SPI_SIGNAL_SE
, "SE" },
138 { SPI_SIGNAL_LVD
, "LVD" },
139 { SPI_SIGNAL_HVD
, "HVD" },
142 static inline const char *spi_signal_to_string(enum spi_signal_type type
)
146 for (i
= 0; i
< sizeof(signal_types
)/sizeof(signal_types
[0]); i
++) {
147 if (type
== signal_types
[i
].value
)
148 return signal_types
[i
].name
;
152 static inline enum spi_signal_type
spi_signal_to_value(const char *name
)
156 for (i
= 0; i
< sizeof(signal_types
)/sizeof(signal_types
[0]); i
++) {
157 len
= strlen(signal_types
[i
].name
);
158 if (strncmp(name
, signal_types
[i
].name
, len
) == 0 &&
159 (name
[len
] == '\n' || name
[len
] == '\0'))
160 return signal_types
[i
].value
;
162 return SPI_SIGNAL_UNKNOWN
;
165 static int spi_host_setup(struct device
*dev
)
167 struct Scsi_Host
*shost
= dev_to_shost(dev
);
169 spi_signalling(shost
) = SPI_SIGNAL_UNKNOWN
;
174 static DECLARE_TRANSPORT_CLASS(spi_host_class
,
180 static int spi_host_match(struct attribute_container
*cont
,
183 struct Scsi_Host
*shost
;
184 struct spi_internal
*i
;
186 if (!scsi_is_host_device(dev
))
189 shost
= dev_to_shost(dev
);
190 if (!shost
->transportt
|| shost
->transportt
->host_attrs
.ac
.class
191 != &spi_host_class
.class)
194 i
= to_spi_internal(shost
->transportt
);
196 return &i
->t
.host_attrs
.ac
== cont
;
199 static int spi_device_configure(struct device
*dev
)
201 struct scsi_device
*sdev
= to_scsi_device(dev
);
202 struct scsi_target
*starget
= sdev
->sdev_target
;
204 /* Populate the target capability fields with the values
205 * gleaned from the device inquiry */
207 spi_support_sync(starget
) = scsi_device_sync(sdev
);
208 spi_support_wide(starget
) = scsi_device_wide(sdev
);
209 spi_support_dt(starget
) = scsi_device_dt(sdev
);
210 spi_support_dt_only(starget
) = scsi_device_dt_only(sdev
);
211 spi_support_ius(starget
) = scsi_device_ius(sdev
);
212 spi_support_qas(starget
) = scsi_device_qas(sdev
);
217 static int spi_setup_transport_attrs(struct device
*dev
)
219 struct scsi_target
*starget
= to_scsi_target(dev
);
221 spi_period(starget
) = -1; /* illegal value */
222 spi_min_period(starget
) = 0;
223 spi_offset(starget
) = 0; /* async */
224 spi_max_offset(starget
) = 255;
225 spi_width(starget
) = 0; /* narrow */
226 spi_max_width(starget
) = 1;
227 spi_iu(starget
) = 0; /* no IU */
228 spi_dt(starget
) = 0; /* ST */
229 spi_qas(starget
) = 0;
230 spi_wr_flow(starget
) = 0;
231 spi_rd_strm(starget
) = 0;
232 spi_rti(starget
) = 0;
233 spi_pcomp_en(starget
) = 0;
234 spi_dv_pending(starget
) = 0;
235 spi_initial_dv(starget
) = 0;
236 init_MUTEX(&spi_dv_sem(starget
));
241 #define spi_transport_show_simple(field, format_string) \
244 show_spi_transport_##field(struct class_device *cdev, char *buf) \
246 struct scsi_target *starget = transport_class_to_starget(cdev); \
247 struct spi_transport_attrs *tp; \
249 tp = (struct spi_transport_attrs *)&starget->starget_data; \
250 return snprintf(buf, 20, format_string, tp->field); \
253 #define spi_transport_store_simple(field, format_string) \
256 store_spi_transport_##field(struct class_device *cdev, const char *buf, \
260 struct scsi_target *starget = transport_class_to_starget(cdev); \
261 struct spi_transport_attrs *tp; \
263 tp = (struct spi_transport_attrs *)&starget->starget_data; \
264 val = simple_strtoul(buf, NULL, 0); \
269 #define spi_transport_show_function(field, format_string) \
272 show_spi_transport_##field(struct class_device *cdev, char *buf) \
274 struct scsi_target *starget = transport_class_to_starget(cdev); \
275 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); \
276 struct spi_transport_attrs *tp; \
277 struct spi_internal *i = to_spi_internal(shost->transportt); \
278 tp = (struct spi_transport_attrs *)&starget->starget_data; \
279 if (i->f->get_##field) \
280 i->f->get_##field(starget); \
281 return snprintf(buf, 20, format_string, tp->field); \
284 #define spi_transport_store_function(field, format_string) \
286 store_spi_transport_##field(struct class_device *cdev, const char *buf, \
290 struct scsi_target *starget = transport_class_to_starget(cdev); \
291 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); \
292 struct spi_internal *i = to_spi_internal(shost->transportt); \
294 val = simple_strtoul(buf, NULL, 0); \
295 i->f->set_##field(starget, val); \
299 #define spi_transport_store_max(field, format_string) \
301 store_spi_transport_##field(struct class_device *cdev, const char *buf, \
305 struct scsi_target *starget = transport_class_to_starget(cdev); \
306 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); \
307 struct spi_internal *i = to_spi_internal(shost->transportt); \
308 struct spi_transport_attrs *tp \
309 = (struct spi_transport_attrs *)&starget->starget_data; \
311 val = simple_strtoul(buf, NULL, 0); \
312 if (val > tp->max_##field) \
313 val = tp->max_##field; \
314 i->f->set_##field(starget, val); \
318 #define spi_transport_rd_attr(field, format_string) \
319 spi_transport_show_function(field, format_string) \
320 spi_transport_store_function(field, format_string) \
321 static CLASS_DEVICE_ATTR(field, S_IRUGO | S_IWUSR, \
322 show_spi_transport_##field, \
323 store_spi_transport_##field);
325 #define spi_transport_simple_attr(field, format_string) \
326 spi_transport_show_simple(field, format_string) \
327 spi_transport_store_simple(field, format_string) \
328 static CLASS_DEVICE_ATTR(field, S_IRUGO | S_IWUSR, \
329 show_spi_transport_##field, \
330 store_spi_transport_##field);
332 #define spi_transport_max_attr(field, format_string) \
333 spi_transport_show_function(field, format_string) \
334 spi_transport_store_max(field, format_string) \
335 spi_transport_simple_attr(max_##field, format_string) \
336 static CLASS_DEVICE_ATTR(field, S_IRUGO | S_IWUSR, \
337 show_spi_transport_##field, \
338 store_spi_transport_##field);
340 /* The Parallel SCSI Tranport Attributes: */
341 spi_transport_max_attr(offset
, "%d\n");
342 spi_transport_max_attr(width
, "%d\n");
343 spi_transport_rd_attr(iu
, "%d\n");
344 spi_transport_rd_attr(dt
, "%d\n");
345 spi_transport_rd_attr(qas
, "%d\n");
346 spi_transport_rd_attr(wr_flow
, "%d\n");
347 spi_transport_rd_attr(rd_strm
, "%d\n");
348 spi_transport_rd_attr(rti
, "%d\n");
349 spi_transport_rd_attr(pcomp_en
, "%d\n");
352 store_spi_revalidate(struct class_device
*cdev
, const char *buf
, size_t count
)
354 struct scsi_target
*starget
= transport_class_to_starget(cdev
);
356 /* FIXME: we're relying on an awful lot of device internals
357 * here. We really need a function to get the first available
359 struct device
*dev
= container_of(starget
->dev
.children
.next
, struct device
, node
);
360 struct scsi_device
*sdev
= to_scsi_device(dev
);
364 static CLASS_DEVICE_ATTR(revalidate
, S_IWUSR
, NULL
, store_spi_revalidate
);
366 /* Translate the period into ns according to the current spec
367 * for SDTR/PPR messages */
369 show_spi_transport_period_helper(struct class_device
*cdev
, char *buf
,
374 if (period
< 0 || period
> 0xff) {
376 } else if (period
<= SPI_STATIC_PPR
) {
377 picosec
= ppr_to_ps
[period
];
379 picosec
= period
* 4000;
383 len
= sprintf(buf
, "reserved");
385 len
= sprint_frac(buf
, picosec
, 1000);
394 store_spi_transport_period_helper(struct class_device
*cdev
, const char *buf
,
395 size_t count
, int *periodp
)
397 int j
, picosec
, period
= -1;
400 picosec
= simple_strtoul(buf
, &endp
, 10) * 1000;
407 picosec
+= (*endp
- '0') * mult
;
412 for (j
= 0; j
<= SPI_STATIC_PPR
; j
++) {
413 if (ppr_to_ps
[j
] < picosec
)
420 period
= picosec
/ 4000;
431 show_spi_transport_period(struct class_device
*cdev
, char *buf
)
433 struct scsi_target
*starget
= transport_class_to_starget(cdev
);
434 struct Scsi_Host
*shost
= dev_to_shost(starget
->dev
.parent
);
435 struct spi_internal
*i
= to_spi_internal(shost
->transportt
);
436 struct spi_transport_attrs
*tp
=
437 (struct spi_transport_attrs
*)&starget
->starget_data
;
439 if (i
->f
->get_period
)
440 i
->f
->get_period(starget
);
442 return show_spi_transport_period_helper(cdev
, buf
, tp
->period
);
446 store_spi_transport_period(struct class_device
*cdev
, const char *buf
,
449 struct scsi_target
*starget
= transport_class_to_starget(cdev
);
450 struct Scsi_Host
*shost
= dev_to_shost(starget
->dev
.parent
);
451 struct spi_internal
*i
= to_spi_internal(shost
->transportt
);
452 struct spi_transport_attrs
*tp
=
453 (struct spi_transport_attrs
*)&starget
->starget_data
;
456 retval
= store_spi_transport_period_helper(cdev
, buf
, count
, &period
);
458 if (period
< tp
->min_period
)
459 period
= tp
->min_period
;
461 i
->f
->set_period(starget
, period
);
466 static CLASS_DEVICE_ATTR(period
, S_IRUGO
| S_IWUSR
,
467 show_spi_transport_period
,
468 store_spi_transport_period
);
471 show_spi_transport_min_period(struct class_device
*cdev
, char *buf
)
473 struct scsi_target
*starget
= transport_class_to_starget(cdev
);
474 struct spi_transport_attrs
*tp
=
475 (struct spi_transport_attrs
*)&starget
->starget_data
;
477 return show_spi_transport_period_helper(cdev
, buf
, tp
->min_period
);
481 store_spi_transport_min_period(struct class_device
*cdev
, const char *buf
,
484 struct scsi_target
*starget
= transport_class_to_starget(cdev
);
485 struct spi_transport_attrs
*tp
=
486 (struct spi_transport_attrs
*)&starget
->starget_data
;
488 return store_spi_transport_period_helper(cdev
, buf
, count
,
493 static CLASS_DEVICE_ATTR(min_period
, S_IRUGO
| S_IWUSR
,
494 show_spi_transport_min_period
,
495 store_spi_transport_min_period
);
498 static ssize_t
show_spi_host_signalling(struct class_device
*cdev
, char *buf
)
500 struct Scsi_Host
*shost
= transport_class_to_shost(cdev
);
501 struct spi_internal
*i
= to_spi_internal(shost
->transportt
);
503 if (i
->f
->get_signalling
)
504 i
->f
->get_signalling(shost
);
506 return sprintf(buf
, "%s\n", spi_signal_to_string(spi_signalling(shost
)));
508 static ssize_t
store_spi_host_signalling(struct class_device
*cdev
,
509 const char *buf
, size_t count
)
511 struct Scsi_Host
*shost
= transport_class_to_shost(cdev
);
512 struct spi_internal
*i
= to_spi_internal(shost
->transportt
);
513 enum spi_signal_type type
= spi_signal_to_value(buf
);
515 if (type
!= SPI_SIGNAL_UNKNOWN
)
516 i
->f
->set_signalling(shost
, type
);
520 static CLASS_DEVICE_ATTR(signalling
, S_IRUGO
| S_IWUSR
,
521 show_spi_host_signalling
,
522 store_spi_host_signalling
);
524 #define DV_SET(x, y) \
526 i->f->set_##x(sdev->sdev_target, y)
528 enum spi_compare_returns
{
531 SPI_COMPARE_SKIP_TEST
,
535 /* This is for read/write Domain Validation: If the device supports
536 * an echo buffer, we do read/write tests to it */
537 static enum spi_compare_returns
538 spi_dv_device_echo_buffer(struct scsi_request
*sreq
, u8
*buffer
,
539 u8
*ptr
, const int retries
)
541 struct scsi_device
*sdev
= sreq
->sr_device
;
542 int len
= ptr
- buffer
;
544 unsigned int pattern
= 0x0000ffff;
546 const char spi_write_buffer
[] = {
547 WRITE_BUFFER
, 0x0a, 0, 0, 0, 0, 0, len
>> 8, len
& 0xff, 0
549 const char spi_read_buffer
[] = {
550 READ_BUFFER
, 0x0a, 0, 0, 0, 0, 0, len
>> 8, len
& 0xff, 0
553 /* set up the pattern buffer. Doesn't matter if we spill
554 * slightly beyond since that's where the read buffer is */
555 for (j
= 0; j
< len
; ) {
557 /* fill the buffer with counting (test a) */
558 for ( ; j
< min(len
, 32); j
++)
561 /* fill the buffer with alternating words of 0x0 and
563 for ( ; j
< min(len
, k
+ 32); j
+= 2) {
564 u16
*word
= (u16
*)&buffer
[j
];
566 *word
= (j
& 0x02) ? 0x0000 : 0xffff;
569 /* fill with crosstalk (alternating 0x5555 0xaaa)
571 for ( ; j
< min(len
, k
+ 32); j
+= 2) {
572 u16
*word
= (u16
*)&buffer
[j
];
574 *word
= (j
& 0x02) ? 0x5555 : 0xaaaa;
577 /* fill with shifting bits (test d) */
578 for ( ; j
< min(len
, k
+ 32); j
+= 4) {
579 u32
*word
= (unsigned int *)&buffer
[j
];
580 u32 roll
= (pattern
& 0x80000000) ? 1 : 0;
583 pattern
= (pattern
<< 1) | roll
;
585 /* don't bother with random data (test e) */
588 for (r
= 0; r
< retries
; r
++) {
589 sreq
->sr_cmd_len
= 0; /* wait_req to fill in */
590 sreq
->sr_data_direction
= DMA_TO_DEVICE
;
591 spi_wait_req(sreq
, spi_write_buffer
, buffer
, len
);
592 if(sreq
->sr_result
|| !scsi_device_online(sdev
)) {
593 struct scsi_sense_hdr sshdr
;
595 scsi_device_set_state(sdev
, SDEV_QUIESCE
);
596 if (scsi_request_normalize_sense(sreq
, &sshdr
)
597 && sshdr
.sense_key
== ILLEGAL_REQUEST
598 /* INVALID FIELD IN CDB */
599 && sshdr
.asc
== 0x24 && sshdr
.ascq
== 0x00)
600 /* This would mean that the drive lied
601 * to us about supporting an echo
602 * buffer (unfortunately some Western
603 * Digital drives do precisely this)
605 return SPI_COMPARE_SKIP_TEST
;
608 SPI_PRINTK(sdev
->sdev_target
, KERN_ERR
, "Write Buffer failure %x\n", sreq
->sr_result
);
609 return SPI_COMPARE_FAILURE
;
613 sreq
->sr_cmd_len
= 0; /* wait_req to fill in */
614 sreq
->sr_data_direction
= DMA_FROM_DEVICE
;
615 spi_wait_req(sreq
, spi_read_buffer
, ptr
, len
);
616 scsi_device_set_state(sdev
, SDEV_QUIESCE
);
618 if (memcmp(buffer
, ptr
, len
) != 0)
619 return SPI_COMPARE_FAILURE
;
621 return SPI_COMPARE_SUCCESS
;
624 /* This is for the simplest form of Domain Validation: a read test
625 * on the inquiry data from the device */
626 static enum spi_compare_returns
627 spi_dv_device_compare_inquiry(struct scsi_request
*sreq
, u8
*buffer
,
628 u8
*ptr
, const int retries
)
631 const int len
= sreq
->sr_device
->inquiry_len
;
632 struct scsi_device
*sdev
= sreq
->sr_device
;
633 const char spi_inquiry
[] = {
634 INQUIRY
, 0, 0, 0, len
, 0
637 for (r
= 0; r
< retries
; r
++) {
638 sreq
->sr_cmd_len
= 0; /* wait_req to fill in */
639 sreq
->sr_data_direction
= DMA_FROM_DEVICE
;
643 spi_wait_req(sreq
, spi_inquiry
, ptr
, len
);
645 if(sreq
->sr_result
|| !scsi_device_online(sdev
)) {
646 scsi_device_set_state(sdev
, SDEV_QUIESCE
);
647 return SPI_COMPARE_FAILURE
;
650 /* If we don't have the inquiry data already, the
651 * first read gets it */
658 if (memcmp(buffer
, ptr
, len
) != 0)
660 return SPI_COMPARE_FAILURE
;
662 return SPI_COMPARE_SUCCESS
;
665 static enum spi_compare_returns
666 spi_dv_retrain(struct scsi_request
*sreq
, u8
*buffer
, u8
*ptr
,
667 enum spi_compare_returns
668 (*compare_fn
)(struct scsi_request
*, u8
*, u8
*, int))
670 struct spi_internal
*i
= to_spi_internal(sreq
->sr_host
->transportt
);
671 struct scsi_device
*sdev
= sreq
->sr_device
;
672 int period
= 0, prevperiod
= 0;
673 enum spi_compare_returns retval
;
678 retval
= compare_fn(sreq
, buffer
, ptr
, DV_LOOPS
);
680 if (retval
== SPI_COMPARE_SUCCESS
681 || retval
== SPI_COMPARE_SKIP_TEST
)
684 /* OK, retrain, fallback */
685 if (i
->f
->get_period
)
686 i
->f
->get_period(sdev
->sdev_target
);
687 newperiod
= spi_period(sdev
->sdev_target
);
688 period
= newperiod
> period
? newperiod
: period
;
692 period
+= period
>> 1;
694 if (unlikely(period
> 0xff || period
== prevperiod
)) {
695 /* Total failure; set to async and return */
696 SPI_PRINTK(sdev
->sdev_target
, KERN_ERR
, "Domain Validation Failure, dropping back to Asynchronous\n");
698 return SPI_COMPARE_FAILURE
;
700 SPI_PRINTK(sdev
->sdev_target
, KERN_ERR
, "Domain Validation detected failure, dropping back\n");
701 DV_SET(period
, period
);
708 spi_dv_device_get_echo_buffer(struct scsi_request
*sreq
, u8
*buffer
)
712 /* first off do a test unit ready. This can error out
713 * because of reservations or some other reason. If it
714 * fails, the device won't let us write to the echo buffer
715 * so just return failure */
717 const char spi_test_unit_ready
[] = {
718 TEST_UNIT_READY
, 0, 0, 0, 0, 0
721 const char spi_read_buffer_descriptor
[] = {
722 READ_BUFFER
, 0x0b, 0, 0, 0, 0, 0, 0, 4, 0
726 sreq
->sr_cmd_len
= 0;
727 sreq
->sr_data_direction
= DMA_NONE
;
729 /* We send a set of three TURs to clear any outstanding
730 * unit attention conditions if they exist (Otherwise the
731 * buffer tests won't be happy). If the TUR still fails
732 * (reservation conflict, device not ready, etc) just
733 * skip the write tests */
735 spi_wait_req(sreq
, spi_test_unit_ready
, NULL
, 0);
737 if(sreq
->sr_result
) {
746 sreq
->sr_cmd_len
= 0;
747 sreq
->sr_data_direction
= DMA_FROM_DEVICE
;
749 spi_wait_req(sreq
, spi_read_buffer_descriptor
, buffer
, 4);
752 /* Device has no echo buffer */
755 return buffer
[3] + ((buffer
[2] & 0x1f) << 8);
759 spi_dv_device_internal(struct scsi_request
*sreq
, u8
*buffer
)
761 struct spi_internal
*i
= to_spi_internal(sreq
->sr_host
->transportt
);
762 struct scsi_device
*sdev
= sreq
->sr_device
;
763 struct scsi_target
*starget
= sdev
->sdev_target
;
764 int len
= sdev
->inquiry_len
;
765 /* first set us up for narrow async */
769 if (spi_dv_device_compare_inquiry(sreq
, buffer
, buffer
, DV_LOOPS
)
770 != SPI_COMPARE_SUCCESS
) {
771 SPI_PRINTK(sdev
->sdev_target
, KERN_ERR
, "Domain Validation Initial Inquiry Failed\n");
772 /* FIXME: should probably offline the device here? */
777 if (i
->f
->set_width
&& spi_max_width(starget
) && sdev
->wdtr
) {
778 i
->f
->set_width(sdev
->sdev_target
, 1);
780 printk("WIDTH IS %d\n", spi_max_width(starget
));
782 if (spi_dv_device_compare_inquiry(sreq
, buffer
,
785 != SPI_COMPARE_SUCCESS
) {
786 SPI_PRINTK(sdev
->sdev_target
, KERN_ERR
, "Wide Transfers Fail\n");
787 i
->f
->set_width(sdev
->sdev_target
, 0);
791 if (!i
->f
->set_period
)
794 /* device can't handle synchronous */
795 if(!sdev
->ppr
&& !sdev
->sdtr
)
798 /* see if the device has an echo buffer. If it does we can
799 * do the SPI pattern write tests */
803 len
= spi_dv_device_get_echo_buffer(sreq
, buffer
);
807 /* now set up to the maximum */
808 DV_SET(offset
, spi_max_offset(starget
));
809 DV_SET(period
, spi_min_period(starget
));
812 SPI_PRINTK(sdev
->sdev_target
, KERN_INFO
, "Domain Validation skipping write tests\n");
813 spi_dv_retrain(sreq
, buffer
, buffer
+ len
,
814 spi_dv_device_compare_inquiry
);
818 if (len
> SPI_MAX_ECHO_BUFFER_SIZE
) {
819 SPI_PRINTK(sdev
->sdev_target
, KERN_WARNING
, "Echo buffer size %d is too big, trimming to %d\n", len
, SPI_MAX_ECHO_BUFFER_SIZE
);
820 len
= SPI_MAX_ECHO_BUFFER_SIZE
;
823 if (spi_dv_retrain(sreq
, buffer
, buffer
+ len
,
824 spi_dv_device_echo_buffer
)
825 == SPI_COMPARE_SKIP_TEST
) {
826 /* OK, the stupid drive can't do a write echo buffer
827 * test after all, fall back to the read tests */
834 /** spi_dv_device - Do Domain Validation on the device
835 * @sdev: scsi device to validate
837 * Performs the domain validation on the given device in the
838 * current execution thread. Since DV operations may sleep,
839 * the current thread must have user context. Also no SCSI
840 * related locks that would deadlock I/O issued by the DV may
844 spi_dv_device(struct scsi_device
*sdev
)
846 struct scsi_request
*sreq
= scsi_allocate_request(sdev
, GFP_KERNEL
);
847 struct scsi_target
*starget
= sdev
->sdev_target
;
849 const int len
= SPI_MAX_ECHO_BUFFER_SIZE
*2;
854 if (unlikely(scsi_device_get(sdev
)))
857 buffer
= kmalloc(len
, GFP_KERNEL
);
859 if (unlikely(!buffer
))
862 memset(buffer
, 0, len
);
864 /* We need to verify that the actual device will quiesce; the
865 * later target quiesce is just a nice to have */
866 if (unlikely(scsi_device_quiesce(sdev
)))
869 scsi_target_quiesce(starget
);
871 spi_dv_pending(starget
) = 1;
872 down(&spi_dv_sem(starget
));
874 SPI_PRINTK(starget
, KERN_INFO
, "Beginning Domain Validation\n");
876 spi_dv_device_internal(sreq
, buffer
);
878 SPI_PRINTK(starget
, KERN_INFO
, "Ending Domain Validation\n");
880 up(&spi_dv_sem(starget
));
881 spi_dv_pending(starget
) = 0;
883 scsi_target_resume(starget
);
885 spi_initial_dv(starget
) = 1;
890 scsi_device_put(sdev
);
892 scsi_release_request(sreq
);
894 EXPORT_SYMBOL(spi_dv_device
);
896 struct work_queue_wrapper
{
897 struct work_struct work
;
898 struct scsi_device
*sdev
;
902 spi_dv_device_work_wrapper(void *data
)
904 struct work_queue_wrapper
*wqw
= (struct work_queue_wrapper
*)data
;
905 struct scsi_device
*sdev
= wqw
->sdev
;
909 spi_dv_pending(sdev
->sdev_target
) = 0;
910 scsi_device_put(sdev
);
915 * spi_schedule_dv_device - schedule domain validation to occur on the device
916 * @sdev: The device to validate
918 * Identical to spi_dv_device() above, except that the DV will be
919 * scheduled to occur in a workqueue later. All memory allocations
920 * are atomic, so may be called from any context including those holding
924 spi_schedule_dv_device(struct scsi_device
*sdev
)
926 struct work_queue_wrapper
*wqw
=
927 kmalloc(sizeof(struct work_queue_wrapper
), GFP_ATOMIC
);
932 if (unlikely(spi_dv_pending(sdev
->sdev_target
))) {
936 /* Set pending early (dv_device doesn't check it, only sets it) */
937 spi_dv_pending(sdev
->sdev_target
) = 1;
938 if (unlikely(scsi_device_get(sdev
))) {
940 spi_dv_pending(sdev
->sdev_target
) = 0;
944 INIT_WORK(&wqw
->work
, spi_dv_device_work_wrapper
, wqw
);
947 schedule_work(&wqw
->work
);
949 EXPORT_SYMBOL(spi_schedule_dv_device
);
952 * spi_display_xfer_agreement - Print the current target transfer agreement
953 * @starget: The target for which to display the agreement
955 * Each SPI port is required to maintain a transfer agreement for each
956 * other port on the bus. This function prints a one-line summary of
957 * the current agreement; more detailed information is available in sysfs.
959 void spi_display_xfer_agreement(struct scsi_target
*starget
)
961 struct spi_transport_attrs
*tp
;
962 tp
= (struct spi_transport_attrs
*)&starget
->starget_data
;
964 if (tp
->offset
> 0 && tp
->period
> 0) {
965 unsigned int picosec
, kb100
;
966 char *scsi
= "FAST-?";
969 if (tp
->period
<= SPI_STATIC_PPR
) {
970 picosec
= ppr_to_ps
[tp
->period
];
971 switch (tp
->period
) {
972 case 7: scsi
= "FAST-320"; break;
973 case 8: scsi
= "FAST-160"; break;
974 case 9: scsi
= "FAST-80"; break;
976 case 11: scsi
= "FAST-40"; break;
977 case 12: scsi
= "FAST-20"; break;
980 picosec
= tp
->period
* 4000;
983 else if (tp
->period
< 50)
989 kb100
= (10000000 + picosec
/ 2) / picosec
;
992 sprint_frac(tmp
, picosec
, 1000);
994 dev_info(&starget
->dev
,
995 "%s %sSCSI %d.%d MB/s %s%s%s (%s ns, offset %d)\n",
996 scsi
, tp
->width
? "WIDE " : "", kb100
/10, kb100
% 10,
997 tp
->dt
? "DT" : "ST", tp
->iu
? " IU" : "",
998 tp
->qas
? " QAS" : "", tmp
, tp
->offset
);
1000 dev_info(&starget
->dev
, "%sasynchronous.\n",
1001 tp
->width
? "wide " : "");
1004 EXPORT_SYMBOL(spi_display_xfer_agreement
);
1006 #define SETUP_ATTRIBUTE(field) \
1007 i->private_attrs[count] = class_device_attr_##field; \
1008 if (!i->f->set_##field) { \
1009 i->private_attrs[count].attr.mode = S_IRUGO; \
1010 i->private_attrs[count].store = NULL; \
1012 i->attrs[count] = &i->private_attrs[count]; \
1013 if (i->f->show_##field) \
1016 #define SETUP_RELATED_ATTRIBUTE(field, rel_field) \
1017 i->private_attrs[count] = class_device_attr_##field; \
1018 if (!i->f->set_##rel_field) { \
1019 i->private_attrs[count].attr.mode = S_IRUGO; \
1020 i->private_attrs[count].store = NULL; \
1022 i->attrs[count] = &i->private_attrs[count]; \
1023 if (i->f->show_##rel_field) \
1026 #define SETUP_HOST_ATTRIBUTE(field) \
1027 i->private_host_attrs[count] = class_device_attr_##field; \
1028 if (!i->f->set_##field) { \
1029 i->private_host_attrs[count].attr.mode = S_IRUGO; \
1030 i->private_host_attrs[count].store = NULL; \
1032 i->host_attrs[count] = &i->private_host_attrs[count]; \
1035 static int spi_device_match(struct attribute_container
*cont
,
1038 struct scsi_device
*sdev
;
1039 struct Scsi_Host
*shost
;
1041 if (!scsi_is_sdev_device(dev
))
1044 sdev
= to_scsi_device(dev
);
1046 if (!shost
->transportt
|| shost
->transportt
->host_attrs
.ac
.class
1047 != &spi_host_class
.class)
1049 /* Note: this class has no device attributes, so it has
1050 * no per-HBA allocation and thus we don't need to distinguish
1051 * the attribute containers for the device */
1055 static int spi_target_match(struct attribute_container
*cont
,
1058 struct Scsi_Host
*shost
;
1059 struct spi_internal
*i
;
1061 if (!scsi_is_target_device(dev
))
1064 shost
= dev_to_shost(dev
->parent
);
1065 if (!shost
->transportt
|| shost
->transportt
->host_attrs
.ac
.class
1066 != &spi_host_class
.class)
1069 i
= to_spi_internal(shost
->transportt
);
1071 return &i
->t
.target_attrs
.ac
== cont
;
1074 static DECLARE_TRANSPORT_CLASS(spi_transport_class
,
1076 spi_setup_transport_attrs
,
1080 static DECLARE_ANON_TRANSPORT_CLASS(spi_device_class
,
1082 spi_device_configure
);
1084 struct scsi_transport_template
*
1085 spi_attach_transport(struct spi_function_template
*ft
)
1087 struct spi_internal
*i
= kmalloc(sizeof(struct spi_internal
),
1093 memset(i
, 0, sizeof(struct spi_internal
));
1096 i
->t
.target_attrs
.ac
.class = &spi_transport_class
.class;
1097 i
->t
.target_attrs
.ac
.attrs
= &i
->attrs
[0];
1098 i
->t
.target_attrs
.ac
.match
= spi_target_match
;
1099 transport_container_register(&i
->t
.target_attrs
);
1100 i
->t
.target_size
= sizeof(struct spi_transport_attrs
);
1101 i
->t
.host_attrs
.ac
.class = &spi_host_class
.class;
1102 i
->t
.host_attrs
.ac
.attrs
= &i
->host_attrs
[0];
1103 i
->t
.host_attrs
.ac
.match
= spi_host_match
;
1104 transport_container_register(&i
->t
.host_attrs
);
1105 i
->t
.host_size
= sizeof(struct spi_host_attrs
);
1108 SETUP_ATTRIBUTE(period
);
1109 SETUP_RELATED_ATTRIBUTE(min_period
, period
);
1110 SETUP_ATTRIBUTE(offset
);
1111 SETUP_RELATED_ATTRIBUTE(max_offset
, offset
);
1112 SETUP_ATTRIBUTE(width
);
1113 SETUP_RELATED_ATTRIBUTE(max_width
, width
);
1114 SETUP_ATTRIBUTE(iu
);
1115 SETUP_ATTRIBUTE(dt
);
1116 SETUP_ATTRIBUTE(qas
);
1117 SETUP_ATTRIBUTE(wr_flow
);
1118 SETUP_ATTRIBUTE(rd_strm
);
1119 SETUP_ATTRIBUTE(rti
);
1120 SETUP_ATTRIBUTE(pcomp_en
);
1122 /* if you add an attribute but forget to increase SPI_NUM_ATTRS
1123 * this bug will trigger */
1124 BUG_ON(count
> SPI_NUM_ATTRS
);
1126 i
->attrs
[count
++] = &class_device_attr_revalidate
;
1128 i
->attrs
[count
] = NULL
;
1131 SETUP_HOST_ATTRIBUTE(signalling
);
1133 BUG_ON(count
> SPI_HOST_ATTRS
);
1135 i
->host_attrs
[count
] = NULL
;
1139 EXPORT_SYMBOL(spi_attach_transport
);
1141 void spi_release_transport(struct scsi_transport_template
*t
)
1143 struct spi_internal
*i
= to_spi_internal(t
);
1145 transport_container_unregister(&i
->t
.target_attrs
);
1146 transport_container_unregister(&i
->t
.host_attrs
);
1150 EXPORT_SYMBOL(spi_release_transport
);
1152 static __init
int spi_transport_init(void)
1154 int error
= transport_class_register(&spi_transport_class
);
1157 error
= anon_transport_class_register(&spi_device_class
);
1158 return transport_class_register(&spi_host_class
);
1161 static void __exit
spi_transport_exit(void)
1163 transport_class_unregister(&spi_transport_class
);
1164 anon_transport_class_unregister(&spi_device_class
);
1165 transport_class_unregister(&spi_host_class
);
1168 MODULE_AUTHOR("Martin Hicks");
1169 MODULE_DESCRIPTION("SPI Transport Attributes");
1170 MODULE_LICENSE("GPL");
1172 module_init(spi_transport_init
);
1173 module_exit(spi_transport_exit
);