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 <linux/mutex.h>
27 #include <linux/sysfs.h>
28 #include <scsi/scsi.h>
29 #include "scsi_priv.h"
30 #include <scsi/scsi_device.h>
31 #include <scsi/scsi_host.h>
32 #include <scsi/scsi_cmnd.h>
33 #include <scsi/scsi_eh.h>
34 #include <scsi/scsi_transport.h>
35 #include <scsi/scsi_transport_spi.h>
37 #define SPI_NUM_ATTRS 14 /* increase this if you add attributes */
38 #define SPI_OTHER_ATTRS 1 /* Increase this if you add "always
40 #define SPI_HOST_ATTRS 1
42 #define SPI_MAX_ECHO_BUFFER_SIZE 4096
45 #define DV_TIMEOUT (10*HZ)
46 #define DV_RETRIES 3 /* should only need at most
49 /* Private data accessors (keep these out of the header file) */
50 #define spi_dv_in_progress(x) (((struct spi_transport_attrs *)&(x)->starget_data)->dv_in_progress)
51 #define spi_dv_mutex(x) (((struct spi_transport_attrs *)&(x)->starget_data)->dv_mutex)
54 struct scsi_transport_template t
;
55 struct spi_function_template
*f
;
58 #define to_spi_internal(tmpl) container_of(tmpl, struct spi_internal, t)
60 static const int ppr_to_ps
[] = {
61 /* The PPR values 0-6 are reserved, fill them in when
62 * the committee defines them */
77 /* The PPR values at which you calculate the period in ns by multiplying
79 #define SPI_STATIC_PPR 0x0c
81 static int sprint_frac(char *dest
, int value
, int denom
)
83 int frac
= value
% denom
;
84 int result
= sprintf(dest
, "%d", value
/ denom
);
92 sprintf(dest
+ result
, "%d", frac
/ denom
);
97 dest
[result
++] = '\0';
101 static int spi_execute(struct scsi_device
*sdev
, const void *cmd
,
102 enum dma_data_direction dir
,
103 void *buffer
, unsigned bufflen
,
104 struct scsi_sense_hdr
*sshdr
)
107 unsigned char sense
[SCSI_SENSE_BUFFERSIZE
];
109 for(i
= 0; i
< DV_RETRIES
; i
++) {
110 result
= scsi_execute(sdev
, cmd
, dir
, buffer
, bufflen
,
111 sense
, DV_TIMEOUT
, /* retries */ 1,
113 REQ_FAILFAST_TRANSPORT
|
116 if (driver_byte(result
) & DRIVER_SENSE
) {
117 struct scsi_sense_hdr sshdr_tmp
;
121 if (scsi_normalize_sense(sense
, SCSI_SENSE_BUFFERSIZE
,
123 && sshdr
->sense_key
== UNIT_ATTENTION
)
132 enum spi_signal_type value
;
135 { SPI_SIGNAL_UNKNOWN
, "unknown" },
136 { SPI_SIGNAL_SE
, "SE" },
137 { SPI_SIGNAL_LVD
, "LVD" },
138 { SPI_SIGNAL_HVD
, "HVD" },
141 static inline const char *spi_signal_to_string(enum spi_signal_type type
)
145 for (i
= 0; i
< ARRAY_SIZE(signal_types
); i
++) {
146 if (type
== signal_types
[i
].value
)
147 return signal_types
[i
].name
;
151 static inline enum spi_signal_type
spi_signal_to_value(const char *name
)
155 for (i
= 0; i
< ARRAY_SIZE(signal_types
); i
++) {
156 len
= strlen(signal_types
[i
].name
);
157 if (strncmp(name
, signal_types
[i
].name
, len
) == 0 &&
158 (name
[len
] == '\n' || name
[len
] == '\0'))
159 return signal_types
[i
].value
;
161 return SPI_SIGNAL_UNKNOWN
;
164 static int spi_host_setup(struct transport_container
*tc
, struct device
*dev
,
167 struct Scsi_Host
*shost
= dev_to_shost(dev
);
169 spi_signalling(shost
) = SPI_SIGNAL_UNKNOWN
;
174 static int spi_host_configure(struct transport_container
*tc
,
176 struct device
*cdev
);
178 static DECLARE_TRANSPORT_CLASS(spi_host_class
,
184 static int spi_host_match(struct attribute_container
*cont
,
187 struct Scsi_Host
*shost
;
189 if (!scsi_is_host_device(dev
))
192 shost
= dev_to_shost(dev
);
193 if (!shost
->transportt
|| shost
->transportt
->host_attrs
.ac
.class
194 != &spi_host_class
.class)
197 return &shost
->transportt
->host_attrs
.ac
== cont
;
200 static int spi_target_configure(struct transport_container
*tc
,
202 struct device
*cdev
);
204 static int spi_device_configure(struct transport_container
*tc
,
208 struct scsi_device
*sdev
= to_scsi_device(dev
);
209 struct scsi_target
*starget
= sdev
->sdev_target
;
211 /* Populate the target capability fields with the values
212 * gleaned from the device inquiry */
214 spi_support_sync(starget
) = scsi_device_sync(sdev
);
215 spi_support_wide(starget
) = scsi_device_wide(sdev
);
216 spi_support_dt(starget
) = scsi_device_dt(sdev
);
217 spi_support_dt_only(starget
) = scsi_device_dt_only(sdev
);
218 spi_support_ius(starget
) = scsi_device_ius(sdev
);
219 spi_support_qas(starget
) = scsi_device_qas(sdev
);
224 static int spi_setup_transport_attrs(struct transport_container
*tc
,
228 struct scsi_target
*starget
= to_scsi_target(dev
);
230 spi_period(starget
) = -1; /* illegal value */
231 spi_min_period(starget
) = 0;
232 spi_offset(starget
) = 0; /* async */
233 spi_max_offset(starget
) = 255;
234 spi_width(starget
) = 0; /* narrow */
235 spi_max_width(starget
) = 1;
236 spi_iu(starget
) = 0; /* no IU */
237 spi_max_iu(starget
) = 1;
238 spi_dt(starget
) = 0; /* ST */
239 spi_qas(starget
) = 0;
240 spi_max_qas(starget
) = 1;
241 spi_wr_flow(starget
) = 0;
242 spi_rd_strm(starget
) = 0;
243 spi_rti(starget
) = 0;
244 spi_pcomp_en(starget
) = 0;
245 spi_hold_mcs(starget
) = 0;
246 spi_dv_pending(starget
) = 0;
247 spi_dv_in_progress(starget
) = 0;
248 spi_initial_dv(starget
) = 0;
249 mutex_init(&spi_dv_mutex(starget
));
254 #define spi_transport_show_simple(field, format_string) \
257 show_spi_transport_##field(struct device *dev, \
258 struct device_attribute *attr, char *buf) \
260 struct scsi_target *starget = transport_class_to_starget(dev); \
261 struct spi_transport_attrs *tp; \
263 tp = (struct spi_transport_attrs *)&starget->starget_data; \
264 return snprintf(buf, 20, format_string, tp->field); \
267 #define spi_transport_store_simple(field, format_string) \
270 store_spi_transport_##field(struct device *dev, \
271 struct device_attribute *attr, \
272 const char *buf, size_t count) \
275 struct scsi_target *starget = transport_class_to_starget(dev); \
276 struct spi_transport_attrs *tp; \
278 tp = (struct spi_transport_attrs *)&starget->starget_data; \
279 val = simple_strtoul(buf, NULL, 0); \
284 #define spi_transport_show_function(field, format_string) \
287 show_spi_transport_##field(struct device *dev, \
288 struct device_attribute *attr, char *buf) \
290 struct scsi_target *starget = transport_class_to_starget(dev); \
291 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); \
292 struct spi_transport_attrs *tp; \
293 struct spi_internal *i = to_spi_internal(shost->transportt); \
294 tp = (struct spi_transport_attrs *)&starget->starget_data; \
295 if (i->f->get_##field) \
296 i->f->get_##field(starget); \
297 return snprintf(buf, 20, format_string, tp->field); \
300 #define spi_transport_store_function(field, format_string) \
302 store_spi_transport_##field(struct device *dev, \
303 struct device_attribute *attr, \
304 const char *buf, size_t count) \
307 struct scsi_target *starget = transport_class_to_starget(dev); \
308 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); \
309 struct spi_internal *i = to_spi_internal(shost->transportt); \
311 if (!i->f->set_##field) \
313 val = simple_strtoul(buf, NULL, 0); \
314 i->f->set_##field(starget, val); \
318 #define spi_transport_store_max(field, format_string) \
320 store_spi_transport_##field(struct device *dev, \
321 struct device_attribute *attr, \
322 const char *buf, size_t count) \
325 struct scsi_target *starget = transport_class_to_starget(dev); \
326 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); \
327 struct spi_internal *i = to_spi_internal(shost->transportt); \
328 struct spi_transport_attrs *tp \
329 = (struct spi_transport_attrs *)&starget->starget_data; \
331 if (i->f->set_##field) \
333 val = simple_strtoul(buf, NULL, 0); \
334 if (val > tp->max_##field) \
335 val = tp->max_##field; \
336 i->f->set_##field(starget, val); \
340 #define spi_transport_rd_attr(field, format_string) \
341 spi_transport_show_function(field, format_string) \
342 spi_transport_store_function(field, format_string) \
343 static DEVICE_ATTR(field, S_IRUGO, \
344 show_spi_transport_##field, \
345 store_spi_transport_##field);
347 #define spi_transport_simple_attr(field, format_string) \
348 spi_transport_show_simple(field, format_string) \
349 spi_transport_store_simple(field, format_string) \
350 static DEVICE_ATTR(field, S_IRUGO, \
351 show_spi_transport_##field, \
352 store_spi_transport_##field);
354 #define spi_transport_max_attr(field, format_string) \
355 spi_transport_show_function(field, format_string) \
356 spi_transport_store_max(field, format_string) \
357 spi_transport_simple_attr(max_##field, format_string) \
358 static DEVICE_ATTR(field, S_IRUGO, \
359 show_spi_transport_##field, \
360 store_spi_transport_##field);
362 /* The Parallel SCSI Tranport Attributes: */
363 spi_transport_max_attr(offset
, "%d\n");
364 spi_transport_max_attr(width
, "%d\n");
365 spi_transport_max_attr(iu
, "%d\n");
366 spi_transport_rd_attr(dt
, "%d\n");
367 spi_transport_max_attr(qas
, "%d\n");
368 spi_transport_rd_attr(wr_flow
, "%d\n");
369 spi_transport_rd_attr(rd_strm
, "%d\n");
370 spi_transport_rd_attr(rti
, "%d\n");
371 spi_transport_rd_attr(pcomp_en
, "%d\n");
372 spi_transport_rd_attr(hold_mcs
, "%d\n");
374 /* we only care about the first child device that's a real SCSI device
375 * so we return 1 to terminate the iteration when we find it */
376 static int child_iter(struct device
*dev
, void *data
)
378 if (!scsi_is_sdev_device(dev
))
381 spi_dv_device(to_scsi_device(dev
));
386 store_spi_revalidate(struct device
*dev
, struct device_attribute
*attr
,
387 const char *buf
, size_t count
)
389 struct scsi_target
*starget
= transport_class_to_starget(dev
);
391 device_for_each_child(&starget
->dev
, NULL
, child_iter
);
394 static DEVICE_ATTR(revalidate
, S_IWUSR
, NULL
, store_spi_revalidate
);
396 /* Translate the period into ns according to the current spec
397 * for SDTR/PPR messages */
398 static int period_to_str(char *buf
, int period
)
402 if (period
< 0 || period
> 0xff) {
404 } else if (period
<= SPI_STATIC_PPR
) {
405 picosec
= ppr_to_ps
[period
];
407 picosec
= period
* 4000;
411 len
= sprintf(buf
, "reserved");
413 len
= sprint_frac(buf
, picosec
, 1000);
420 show_spi_transport_period_helper(char *buf
, int period
)
422 int len
= period_to_str(buf
, period
);
429 store_spi_transport_period_helper(struct device
*dev
, const char *buf
,
430 size_t count
, int *periodp
)
432 int j
, picosec
, period
= -1;
435 picosec
= simple_strtoul(buf
, &endp
, 10) * 1000;
442 picosec
+= (*endp
- '0') * mult
;
447 for (j
= 0; j
<= SPI_STATIC_PPR
; j
++) {
448 if (ppr_to_ps
[j
] < picosec
)
455 period
= picosec
/ 4000;
466 show_spi_transport_period(struct device
*dev
,
467 struct device_attribute
*attr
, char *buf
)
469 struct scsi_target
*starget
= transport_class_to_starget(dev
);
470 struct Scsi_Host
*shost
= dev_to_shost(starget
->dev
.parent
);
471 struct spi_internal
*i
= to_spi_internal(shost
->transportt
);
472 struct spi_transport_attrs
*tp
=
473 (struct spi_transport_attrs
*)&starget
->starget_data
;
475 if (i
->f
->get_period
)
476 i
->f
->get_period(starget
);
478 return show_spi_transport_period_helper(buf
, tp
->period
);
482 store_spi_transport_period(struct device
*cdev
, struct device_attribute
*attr
,
483 const char *buf
, size_t count
)
485 struct scsi_target
*starget
= transport_class_to_starget(cdev
);
486 struct Scsi_Host
*shost
= dev_to_shost(starget
->dev
.parent
);
487 struct spi_internal
*i
= to_spi_internal(shost
->transportt
);
488 struct spi_transport_attrs
*tp
=
489 (struct spi_transport_attrs
*)&starget
->starget_data
;
492 if (!i
->f
->set_period
)
495 retval
= store_spi_transport_period_helper(cdev
, buf
, count
, &period
);
497 if (period
< tp
->min_period
)
498 period
= tp
->min_period
;
500 i
->f
->set_period(starget
, period
);
505 static DEVICE_ATTR(period
, S_IRUGO
,
506 show_spi_transport_period
,
507 store_spi_transport_period
);
510 show_spi_transport_min_period(struct device
*cdev
,
511 struct device_attribute
*attr
, char *buf
)
513 struct scsi_target
*starget
= transport_class_to_starget(cdev
);
514 struct Scsi_Host
*shost
= dev_to_shost(starget
->dev
.parent
);
515 struct spi_internal
*i
= to_spi_internal(shost
->transportt
);
516 struct spi_transport_attrs
*tp
=
517 (struct spi_transport_attrs
*)&starget
->starget_data
;
519 if (!i
->f
->set_period
)
522 return show_spi_transport_period_helper(buf
, tp
->min_period
);
526 store_spi_transport_min_period(struct device
*cdev
,
527 struct device_attribute
*attr
,
528 const char *buf
, size_t count
)
530 struct scsi_target
*starget
= transport_class_to_starget(cdev
);
531 struct spi_transport_attrs
*tp
=
532 (struct spi_transport_attrs
*)&starget
->starget_data
;
534 return store_spi_transport_period_helper(cdev
, buf
, count
,
539 static DEVICE_ATTR(min_period
, S_IRUGO
,
540 show_spi_transport_min_period
,
541 store_spi_transport_min_period
);
544 static ssize_t
show_spi_host_signalling(struct device
*cdev
,
545 struct device_attribute
*attr
,
548 struct Scsi_Host
*shost
= transport_class_to_shost(cdev
);
549 struct spi_internal
*i
= to_spi_internal(shost
->transportt
);
551 if (i
->f
->get_signalling
)
552 i
->f
->get_signalling(shost
);
554 return sprintf(buf
, "%s\n", spi_signal_to_string(spi_signalling(shost
)));
556 static ssize_t
store_spi_host_signalling(struct device
*dev
,
557 struct device_attribute
*attr
,
558 const char *buf
, size_t count
)
560 struct Scsi_Host
*shost
= transport_class_to_shost(dev
);
561 struct spi_internal
*i
= to_spi_internal(shost
->transportt
);
562 enum spi_signal_type type
= spi_signal_to_value(buf
);
564 if (!i
->f
->set_signalling
)
567 if (type
!= SPI_SIGNAL_UNKNOWN
)
568 i
->f
->set_signalling(shost
, type
);
572 static DEVICE_ATTR(signalling
, S_IRUGO
,
573 show_spi_host_signalling
,
574 store_spi_host_signalling
);
576 #define DV_SET(x, y) \
578 i->f->set_##x(sdev->sdev_target, y)
580 enum spi_compare_returns
{
583 SPI_COMPARE_SKIP_TEST
,
587 /* This is for read/write Domain Validation: If the device supports
588 * an echo buffer, we do read/write tests to it */
589 static enum spi_compare_returns
590 spi_dv_device_echo_buffer(struct scsi_device
*sdev
, u8
*buffer
,
591 u8
*ptr
, const int retries
)
593 int len
= ptr
- buffer
;
595 unsigned int pattern
= 0x0000ffff;
596 struct scsi_sense_hdr sshdr
;
598 const char spi_write_buffer
[] = {
599 WRITE_BUFFER
, 0x0a, 0, 0, 0, 0, 0, len
>> 8, len
& 0xff, 0
601 const char spi_read_buffer
[] = {
602 READ_BUFFER
, 0x0a, 0, 0, 0, 0, 0, len
>> 8, len
& 0xff, 0
605 /* set up the pattern buffer. Doesn't matter if we spill
606 * slightly beyond since that's where the read buffer is */
607 for (j
= 0; j
< len
; ) {
609 /* fill the buffer with counting (test a) */
610 for ( ; j
< min(len
, 32); j
++)
613 /* fill the buffer with alternating words of 0x0 and
615 for ( ; j
< min(len
, k
+ 32); j
+= 2) {
616 u16
*word
= (u16
*)&buffer
[j
];
618 *word
= (j
& 0x02) ? 0x0000 : 0xffff;
621 /* fill with crosstalk (alternating 0x5555 0xaaa)
623 for ( ; j
< min(len
, k
+ 32); j
+= 2) {
624 u16
*word
= (u16
*)&buffer
[j
];
626 *word
= (j
& 0x02) ? 0x5555 : 0xaaaa;
629 /* fill with shifting bits (test d) */
630 for ( ; j
< min(len
, k
+ 32); j
+= 4) {
631 u32
*word
= (unsigned int *)&buffer
[j
];
632 u32 roll
= (pattern
& 0x80000000) ? 1 : 0;
635 pattern
= (pattern
<< 1) | roll
;
637 /* don't bother with random data (test e) */
640 for (r
= 0; r
< retries
; r
++) {
641 result
= spi_execute(sdev
, spi_write_buffer
, DMA_TO_DEVICE
,
642 buffer
, len
, &sshdr
);
643 if(result
|| !scsi_device_online(sdev
)) {
645 scsi_device_set_state(sdev
, SDEV_QUIESCE
);
646 if (scsi_sense_valid(&sshdr
)
647 && sshdr
.sense_key
== ILLEGAL_REQUEST
648 /* INVALID FIELD IN CDB */
649 && sshdr
.asc
== 0x24 && sshdr
.ascq
== 0x00)
650 /* This would mean that the drive lied
651 * to us about supporting an echo
652 * buffer (unfortunately some Western
653 * Digital drives do precisely this)
655 return SPI_COMPARE_SKIP_TEST
;
658 sdev_printk(KERN_ERR
, sdev
, "Write Buffer failure %x\n", result
);
659 return SPI_COMPARE_FAILURE
;
663 spi_execute(sdev
, spi_read_buffer
, DMA_FROM_DEVICE
,
665 scsi_device_set_state(sdev
, SDEV_QUIESCE
);
667 if (memcmp(buffer
, ptr
, len
) != 0)
668 return SPI_COMPARE_FAILURE
;
670 return SPI_COMPARE_SUCCESS
;
673 /* This is for the simplest form of Domain Validation: a read test
674 * on the inquiry data from the device */
675 static enum spi_compare_returns
676 spi_dv_device_compare_inquiry(struct scsi_device
*sdev
, u8
*buffer
,
677 u8
*ptr
, const int retries
)
680 const int len
= sdev
->inquiry_len
;
681 const char spi_inquiry
[] = {
682 INQUIRY
, 0, 0, 0, len
, 0
685 for (r
= 0; r
< retries
; r
++) {
688 result
= spi_execute(sdev
, spi_inquiry
, DMA_FROM_DEVICE
,
691 if(result
|| !scsi_device_online(sdev
)) {
692 scsi_device_set_state(sdev
, SDEV_QUIESCE
);
693 return SPI_COMPARE_FAILURE
;
696 /* If we don't have the inquiry data already, the
697 * first read gets it */
704 if (memcmp(buffer
, ptr
, len
) != 0)
706 return SPI_COMPARE_FAILURE
;
708 return SPI_COMPARE_SUCCESS
;
711 static enum spi_compare_returns
712 spi_dv_retrain(struct scsi_device
*sdev
, u8
*buffer
, u8
*ptr
,
713 enum spi_compare_returns
714 (*compare_fn
)(struct scsi_device
*, u8
*, u8
*, int))
716 struct spi_internal
*i
= to_spi_internal(sdev
->host
->transportt
);
717 struct scsi_target
*starget
= sdev
->sdev_target
;
718 int period
= 0, prevperiod
= 0;
719 enum spi_compare_returns retval
;
724 retval
= compare_fn(sdev
, buffer
, ptr
, DV_LOOPS
);
726 if (retval
== SPI_COMPARE_SUCCESS
727 || retval
== SPI_COMPARE_SKIP_TEST
)
730 /* OK, retrain, fallback */
732 i
->f
->get_iu(starget
);
734 i
->f
->get_qas(starget
);
735 if (i
->f
->get_period
)
736 i
->f
->get_period(sdev
->sdev_target
);
738 /* Here's the fallback sequence; first try turning off
739 * IU, then QAS (if we can control them), then finally
740 * fall down the periods */
741 if (i
->f
->set_iu
&& spi_iu(starget
)) {
742 starget_printk(KERN_ERR
, starget
, "Domain Validation Disabing Information Units\n");
744 } else if (i
->f
->set_qas
&& spi_qas(starget
)) {
745 starget_printk(KERN_ERR
, starget
, "Domain Validation Disabing Quick Arbitration and Selection\n");
748 newperiod
= spi_period(starget
);
749 period
= newperiod
> period
? newperiod
: period
;
753 period
+= period
>> 1;
755 if (unlikely(period
> 0xff || period
== prevperiod
)) {
756 /* Total failure; set to async and return */
757 starget_printk(KERN_ERR
, starget
, "Domain Validation Failure, dropping back to Asynchronous\n");
759 return SPI_COMPARE_FAILURE
;
761 starget_printk(KERN_ERR
, starget
, "Domain Validation detected failure, dropping back\n");
762 DV_SET(period
, period
);
770 spi_dv_device_get_echo_buffer(struct scsi_device
*sdev
, u8
*buffer
)
774 /* first off do a test unit ready. This can error out
775 * because of reservations or some other reason. If it
776 * fails, the device won't let us write to the echo buffer
777 * so just return failure */
779 const char spi_test_unit_ready
[] = {
780 TEST_UNIT_READY
, 0, 0, 0, 0, 0
783 const char spi_read_buffer_descriptor
[] = {
784 READ_BUFFER
, 0x0b, 0, 0, 0, 0, 0, 0, 4, 0
788 /* We send a set of three TURs to clear any outstanding
789 * unit attention conditions if they exist (Otherwise the
790 * buffer tests won't be happy). If the TUR still fails
791 * (reservation conflict, device not ready, etc) just
792 * skip the write tests */
794 result
= spi_execute(sdev
, spi_test_unit_ready
, DMA_NONE
,
806 result
= spi_execute(sdev
, spi_read_buffer_descriptor
,
807 DMA_FROM_DEVICE
, buffer
, 4, NULL
);
810 /* Device has no echo buffer */
813 return buffer
[3] + ((buffer
[2] & 0x1f) << 8);
817 spi_dv_device_internal(struct scsi_device
*sdev
, u8
*buffer
)
819 struct spi_internal
*i
= to_spi_internal(sdev
->host
->transportt
);
820 struct scsi_target
*starget
= sdev
->sdev_target
;
821 struct Scsi_Host
*shost
= sdev
->host
;
822 int len
= sdev
->inquiry_len
;
823 int min_period
= spi_min_period(starget
);
824 int max_width
= spi_max_width(starget
);
825 /* first set us up for narrow async */
829 if (spi_dv_device_compare_inquiry(sdev
, buffer
, buffer
, DV_LOOPS
)
830 != SPI_COMPARE_SUCCESS
) {
831 starget_printk(KERN_ERR
, starget
, "Domain Validation Initial Inquiry Failed\n");
832 /* FIXME: should probably offline the device here? */
836 if (!spi_support_wide(starget
)) {
837 spi_max_width(starget
) = 0;
842 if (i
->f
->set_width
&& max_width
) {
843 i
->f
->set_width(starget
, 1);
845 if (spi_dv_device_compare_inquiry(sdev
, buffer
,
848 != SPI_COMPARE_SUCCESS
) {
849 starget_printk(KERN_ERR
, starget
, "Wide Transfers Fail\n");
850 i
->f
->set_width(starget
, 0);
851 /* Make sure we don't force wide back on by asking
852 * for a transfer period that requires it */
859 if (!i
->f
->set_period
)
862 /* device can't handle synchronous */
863 if (!spi_support_sync(starget
) && !spi_support_dt(starget
))
866 /* len == -1 is the signal that we need to ascertain the
867 * presence of an echo buffer before trying to use it. len ==
868 * 0 means we don't have an echo buffer */
873 /* now set up to the maximum */
874 DV_SET(offset
, spi_max_offset(starget
));
875 DV_SET(period
, min_period
);
877 /* try QAS requests; this should be harmless to set if the
878 * target supports it */
879 if (spi_support_qas(starget
) && spi_max_qas(starget
)) {
885 if (spi_support_ius(starget
) && spi_max_iu(starget
) &&
887 /* This u320 (or u640). Set IU transfers */
889 /* Then set the optional parameters */
899 /* now that we've done all this, actually check the bus
900 * signal type (if known). Some devices are stupid on
901 * a SE bus and still claim they can try LVD only settings */
902 if (i
->f
->get_signalling
)
903 i
->f
->get_signalling(shost
);
904 if (spi_signalling(shost
) == SPI_SIGNAL_SE
||
905 spi_signalling(shost
) == SPI_SIGNAL_HVD
||
906 !spi_support_dt(starget
)) {
911 /* set width last because it will pull all the other
912 * parameters down to required values */
913 DV_SET(width
, max_width
);
915 /* Do the read only INQUIRY tests */
916 spi_dv_retrain(sdev
, buffer
, buffer
+ sdev
->inquiry_len
,
917 spi_dv_device_compare_inquiry
);
918 /* See if we actually managed to negotiate and sustain DT */
920 i
->f
->get_dt(starget
);
922 /* see if the device has an echo buffer. If it does we can do
923 * the SPI pattern write tests. Because of some broken
924 * devices, we *only* try this on a device that has actually
927 if (len
== -1 && spi_dt(starget
))
928 len
= spi_dv_device_get_echo_buffer(sdev
, buffer
);
931 starget_printk(KERN_INFO
, starget
, "Domain Validation skipping write tests\n");
935 if (len
> SPI_MAX_ECHO_BUFFER_SIZE
) {
936 starget_printk(KERN_WARNING
, starget
, "Echo buffer size %d is too big, trimming to %d\n", len
, SPI_MAX_ECHO_BUFFER_SIZE
);
937 len
= SPI_MAX_ECHO_BUFFER_SIZE
;
940 if (spi_dv_retrain(sdev
, buffer
, buffer
+ len
,
941 spi_dv_device_echo_buffer
)
942 == SPI_COMPARE_SKIP_TEST
) {
943 /* OK, the stupid drive can't do a write echo buffer
944 * test after all, fall back to the read tests */
951 /** spi_dv_device - Do Domain Validation on the device
952 * @sdev: scsi device to validate
954 * Performs the domain validation on the given device in the
955 * current execution thread. Since DV operations may sleep,
956 * the current thread must have user context. Also no SCSI
957 * related locks that would deadlock I/O issued by the DV may
961 spi_dv_device(struct scsi_device
*sdev
)
963 struct scsi_target
*starget
= sdev
->sdev_target
;
965 const int len
= SPI_MAX_ECHO_BUFFER_SIZE
*2;
967 if (unlikely(scsi_device_get(sdev
)))
970 if (unlikely(spi_dv_in_progress(starget
)))
972 spi_dv_in_progress(starget
) = 1;
974 buffer
= kzalloc(len
, GFP_KERNEL
);
976 if (unlikely(!buffer
))
979 /* We need to verify that the actual device will quiesce; the
980 * later target quiesce is just a nice to have */
981 if (unlikely(scsi_device_quiesce(sdev
)))
984 scsi_target_quiesce(starget
);
986 spi_dv_pending(starget
) = 1;
987 mutex_lock(&spi_dv_mutex(starget
));
989 starget_printk(KERN_INFO
, starget
, "Beginning Domain Validation\n");
991 spi_dv_device_internal(sdev
, buffer
);
993 starget_printk(KERN_INFO
, starget
, "Ending Domain Validation\n");
995 mutex_unlock(&spi_dv_mutex(starget
));
996 spi_dv_pending(starget
) = 0;
998 scsi_target_resume(starget
);
1000 spi_initial_dv(starget
) = 1;
1005 spi_dv_in_progress(starget
) = 0;
1006 scsi_device_put(sdev
);
1008 EXPORT_SYMBOL(spi_dv_device
);
1010 struct work_queue_wrapper
{
1011 struct work_struct work
;
1012 struct scsi_device
*sdev
;
1016 spi_dv_device_work_wrapper(struct work_struct
*work
)
1018 struct work_queue_wrapper
*wqw
=
1019 container_of(work
, struct work_queue_wrapper
, work
);
1020 struct scsi_device
*sdev
= wqw
->sdev
;
1023 spi_dv_device(sdev
);
1024 spi_dv_pending(sdev
->sdev_target
) = 0;
1025 scsi_device_put(sdev
);
1030 * spi_schedule_dv_device - schedule domain validation to occur on the device
1031 * @sdev: The device to validate
1033 * Identical to spi_dv_device() above, except that the DV will be
1034 * scheduled to occur in a workqueue later. All memory allocations
1035 * are atomic, so may be called from any context including those holding
1039 spi_schedule_dv_device(struct scsi_device
*sdev
)
1041 struct work_queue_wrapper
*wqw
=
1042 kmalloc(sizeof(struct work_queue_wrapper
), GFP_ATOMIC
);
1047 if (unlikely(spi_dv_pending(sdev
->sdev_target
))) {
1051 /* Set pending early (dv_device doesn't check it, only sets it) */
1052 spi_dv_pending(sdev
->sdev_target
) = 1;
1053 if (unlikely(scsi_device_get(sdev
))) {
1055 spi_dv_pending(sdev
->sdev_target
) = 0;
1059 INIT_WORK(&wqw
->work
, spi_dv_device_work_wrapper
);
1062 schedule_work(&wqw
->work
);
1064 EXPORT_SYMBOL(spi_schedule_dv_device
);
1067 * spi_display_xfer_agreement - Print the current target transfer agreement
1068 * @starget: The target for which to display the agreement
1070 * Each SPI port is required to maintain a transfer agreement for each
1071 * other port on the bus. This function prints a one-line summary of
1072 * the current agreement; more detailed information is available in sysfs.
1074 void spi_display_xfer_agreement(struct scsi_target
*starget
)
1076 struct spi_transport_attrs
*tp
;
1077 tp
= (struct spi_transport_attrs
*)&starget
->starget_data
;
1079 if (tp
->offset
> 0 && tp
->period
> 0) {
1080 unsigned int picosec
, kb100
;
1081 char *scsi
= "FAST-?";
1084 if (tp
->period
<= SPI_STATIC_PPR
) {
1085 picosec
= ppr_to_ps
[tp
->period
];
1086 switch (tp
->period
) {
1087 case 7: scsi
= "FAST-320"; break;
1088 case 8: scsi
= "FAST-160"; break;
1089 case 9: scsi
= "FAST-80"; break;
1091 case 11: scsi
= "FAST-40"; break;
1092 case 12: scsi
= "FAST-20"; break;
1095 picosec
= tp
->period
* 4000;
1096 if (tp
->period
< 25)
1098 else if (tp
->period
< 50)
1104 kb100
= (10000000 + picosec
/ 2) / picosec
;
1107 sprint_frac(tmp
, picosec
, 1000);
1109 dev_info(&starget
->dev
,
1110 "%s %sSCSI %d.%d MB/s %s%s%s%s%s%s%s%s (%s ns, offset %d)\n",
1111 scsi
, tp
->width
? "WIDE " : "", kb100
/10, kb100
% 10,
1112 tp
->dt
? "DT" : "ST",
1113 tp
->iu
? " IU" : "",
1114 tp
->qas
? " QAS" : "",
1115 tp
->rd_strm
? " RDSTRM" : "",
1116 tp
->rti
? " RTI" : "",
1117 tp
->wr_flow
? " WRFLOW" : "",
1118 tp
->pcomp_en
? " PCOMP" : "",
1119 tp
->hold_mcs
? " HMCS" : "",
1122 dev_info(&starget
->dev
, "%sasynchronous\n",
1123 tp
->width
? "wide " : "");
1126 EXPORT_SYMBOL(spi_display_xfer_agreement
);
1128 int spi_populate_width_msg(unsigned char *msg
, int width
)
1130 msg
[0] = EXTENDED_MESSAGE
;
1132 msg
[2] = EXTENDED_WDTR
;
1136 EXPORT_SYMBOL_GPL(spi_populate_width_msg
);
1138 int spi_populate_sync_msg(unsigned char *msg
, int period
, int offset
)
1140 msg
[0] = EXTENDED_MESSAGE
;
1142 msg
[2] = EXTENDED_SDTR
;
1147 EXPORT_SYMBOL_GPL(spi_populate_sync_msg
);
1149 int spi_populate_ppr_msg(unsigned char *msg
, int period
, int offset
,
1150 int width
, int options
)
1152 msg
[0] = EXTENDED_MESSAGE
;
1154 msg
[2] = EXTENDED_PPR
;
1162 EXPORT_SYMBOL_GPL(spi_populate_ppr_msg
);
1164 #ifdef CONFIG_SCSI_CONSTANTS
1165 static const char * const one_byte_msgs
[] = {
1166 /* 0x00 */ "Task Complete", NULL
/* Extended Message */, "Save Pointers",
1167 /* 0x03 */ "Restore Pointers", "Disconnect", "Initiator Error",
1168 /* 0x06 */ "Abort Task Set", "Message Reject", "Nop", "Message Parity Error",
1169 /* 0x0a */ "Linked Command Complete", "Linked Command Complete w/flag",
1170 /* 0x0c */ "Target Reset", "Abort Task", "Clear Task Set",
1171 /* 0x0f */ "Initiate Recovery", "Release Recovery",
1172 /* 0x11 */ "Terminate Process", "Continue Task", "Target Transfer Disable",
1173 /* 0x14 */ NULL
, NULL
, "Clear ACA", "LUN Reset"
1176 static const char * const two_byte_msgs
[] = {
1177 /* 0x20 */ "Simple Queue Tag", "Head of Queue Tag", "Ordered Queue Tag",
1178 /* 0x23 */ "Ignore Wide Residue", "ACA"
1181 static const char * const extended_msgs
[] = {
1182 /* 0x00 */ "Modify Data Pointer", "Synchronous Data Transfer Request",
1183 /* 0x02 */ "SCSI-I Extended Identify", "Wide Data Transfer Request",
1184 /* 0x04 */ "Parallel Protocol Request", "Modify Bidirectional Data Pointer"
1187 static void print_nego(const unsigned char *msg
, int per
, int off
, int width
)
1191 period_to_str(buf
, msg
[per
]);
1192 printk("period = %s ns ", buf
);
1196 printk("offset = %d ", msg
[off
]);
1198 printk("width = %d ", 8 << msg
[width
]);
1201 static void print_ptr(const unsigned char *msg
, int msb
, const char *desc
)
1203 int ptr
= (msg
[msb
] << 24) | (msg
[msb
+1] << 16) | (msg
[msb
+2] << 8) |
1205 printk("%s = %d ", desc
, ptr
);
1208 int spi_print_msg(const unsigned char *msg
)
1211 if (msg
[0] == EXTENDED_MESSAGE
) {
1215 if (msg
[2] < ARRAY_SIZE(extended_msgs
))
1216 printk ("%s ", extended_msgs
[msg
[2]]);
1218 printk ("Extended Message, reserved code (0x%02x) ",
1221 case EXTENDED_MODIFY_DATA_POINTER
:
1222 print_ptr(msg
, 3, "pointer");
1225 print_nego(msg
, 3, 4, 0);
1228 print_nego(msg
, 0, 0, 3);
1231 print_nego(msg
, 3, 5, 6);
1233 case EXTENDED_MODIFY_BIDI_DATA_PTR
:
1234 print_ptr(msg
, 3, "out");
1235 print_ptr(msg
, 7, "in");
1238 for (i
= 2; i
< len
; ++i
)
1239 printk("%02x ", msg
[i
]);
1242 } else if (msg
[0] & 0x80) {
1243 printk("Identify disconnect %sallowed %s %d ",
1244 (msg
[0] & 0x40) ? "" : "not ",
1245 (msg
[0] & 0x20) ? "target routine" : "lun",
1247 /* Normal One byte */
1248 } else if (msg
[0] < 0x1f) {
1249 if (msg
[0] < ARRAY_SIZE(one_byte_msgs
) && one_byte_msgs
[msg
[0]])
1250 printk("%s ", one_byte_msgs
[msg
[0]]);
1252 printk("reserved (%02x) ", msg
[0]);
1253 } else if (msg
[0] == 0x55) {
1254 printk("QAS Request ");
1256 } else if (msg
[0] <= 0x2f) {
1257 if ((msg
[0] - 0x20) < ARRAY_SIZE(two_byte_msgs
))
1258 printk("%s %02x ", two_byte_msgs
[msg
[0] - 0x20],
1261 printk("reserved two byte (%02x %02x) ",
1265 printk("reserved ");
1268 EXPORT_SYMBOL(spi_print_msg
);
1270 #else /* ifndef CONFIG_SCSI_CONSTANTS */
1272 int spi_print_msg(const unsigned char *msg
)
1276 if (msg
[0] == EXTENDED_MESSAGE
) {
1280 for (i
= 0; i
< len
; ++i
)
1281 printk("%02x ", msg
[i
]);
1283 } else if (msg
[0] & 0x80) {
1284 printk("%02x ", msg
[0]);
1285 /* Normal One byte */
1286 } else if ((msg
[0] < 0x1f) || (msg
[0] == 0x55)) {
1287 printk("%02x ", msg
[0]);
1289 } else if (msg
[0] <= 0x2f) {
1290 printk("%02x %02x", msg
[0], msg
[1]);
1293 printk("%02x ", msg
[0]);
1296 EXPORT_SYMBOL(spi_print_msg
);
1297 #endif /* ! CONFIG_SCSI_CONSTANTS */
1299 static int spi_device_match(struct attribute_container
*cont
,
1302 struct scsi_device
*sdev
;
1303 struct Scsi_Host
*shost
;
1304 struct spi_internal
*i
;
1306 if (!scsi_is_sdev_device(dev
))
1309 sdev
= to_scsi_device(dev
);
1311 if (!shost
->transportt
|| shost
->transportt
->host_attrs
.ac
.class
1312 != &spi_host_class
.class)
1314 /* Note: this class has no device attributes, so it has
1315 * no per-HBA allocation and thus we don't need to distinguish
1316 * the attribute containers for the device */
1317 i
= to_spi_internal(shost
->transportt
);
1318 if (i
->f
->deny_binding
&& i
->f
->deny_binding(sdev
->sdev_target
))
1323 static int spi_target_match(struct attribute_container
*cont
,
1326 struct Scsi_Host
*shost
;
1327 struct scsi_target
*starget
;
1328 struct spi_internal
*i
;
1330 if (!scsi_is_target_device(dev
))
1333 shost
= dev_to_shost(dev
->parent
);
1334 if (!shost
->transportt
|| shost
->transportt
->host_attrs
.ac
.class
1335 != &spi_host_class
.class)
1338 i
= to_spi_internal(shost
->transportt
);
1339 starget
= to_scsi_target(dev
);
1341 if (i
->f
->deny_binding
&& i
->f
->deny_binding(starget
))
1344 return &i
->t
.target_attrs
.ac
== cont
;
1347 static DECLARE_TRANSPORT_CLASS(spi_transport_class
,
1349 spi_setup_transport_attrs
,
1351 spi_target_configure
);
1353 static DECLARE_ANON_TRANSPORT_CLASS(spi_device_class
,
1355 spi_device_configure
);
1357 static struct attribute
*host_attributes
[] = {
1358 &dev_attr_signalling
.attr
,
1362 static struct attribute_group host_attribute_group
= {
1363 .attrs
= host_attributes
,
1366 static int spi_host_configure(struct transport_container
*tc
,
1368 struct device
*cdev
)
1370 struct kobject
*kobj
= &cdev
->kobj
;
1371 struct Scsi_Host
*shost
= transport_class_to_shost(cdev
);
1372 struct spi_internal
*si
= to_spi_internal(shost
->transportt
);
1373 struct attribute
*attr
= &dev_attr_signalling
.attr
;
1376 if (si
->f
->set_signalling
)
1377 rc
= sysfs_chmod_file(kobj
, attr
, attr
->mode
| S_IWUSR
);
1382 /* returns true if we should be showing the variable. Also
1383 * overloads the return by setting 1<<1 if the attribute should
1385 #define TARGET_ATTRIBUTE_HELPER(name) \
1386 (si->f->show_##name ? S_IRUGO : 0) | \
1387 (si->f->set_##name ? S_IWUSR : 0)
1389 static mode_t
target_attribute_is_visible(struct kobject
*kobj
,
1390 struct attribute
*attr
, int i
)
1392 struct device
*cdev
= container_of(kobj
, struct device
, kobj
);
1393 struct scsi_target
*starget
= transport_class_to_starget(cdev
);
1394 struct Scsi_Host
*shost
= transport_class_to_shost(cdev
);
1395 struct spi_internal
*si
= to_spi_internal(shost
->transportt
);
1397 if (attr
== &dev_attr_period
.attr
&&
1398 spi_support_sync(starget
))
1399 return TARGET_ATTRIBUTE_HELPER(period
);
1400 else if (attr
== &dev_attr_min_period
.attr
&&
1401 spi_support_sync(starget
))
1402 return TARGET_ATTRIBUTE_HELPER(period
);
1403 else if (attr
== &dev_attr_offset
.attr
&&
1404 spi_support_sync(starget
))
1405 return TARGET_ATTRIBUTE_HELPER(offset
);
1406 else if (attr
== &dev_attr_max_offset
.attr
&&
1407 spi_support_sync(starget
))
1408 return TARGET_ATTRIBUTE_HELPER(offset
);
1409 else if (attr
== &dev_attr_width
.attr
&&
1410 spi_support_wide(starget
))
1411 return TARGET_ATTRIBUTE_HELPER(width
);
1412 else if (attr
== &dev_attr_max_width
.attr
&&
1413 spi_support_wide(starget
))
1414 return TARGET_ATTRIBUTE_HELPER(width
);
1415 else if (attr
== &dev_attr_iu
.attr
&&
1416 spi_support_ius(starget
))
1417 return TARGET_ATTRIBUTE_HELPER(iu
);
1418 else if (attr
== &dev_attr_max_iu
.attr
&&
1419 spi_support_ius(starget
))
1420 return TARGET_ATTRIBUTE_HELPER(iu
);
1421 else if (attr
== &dev_attr_dt
.attr
&&
1422 spi_support_dt(starget
))
1423 return TARGET_ATTRIBUTE_HELPER(dt
);
1424 else if (attr
== &dev_attr_qas
.attr
&&
1425 spi_support_qas(starget
))
1426 return TARGET_ATTRIBUTE_HELPER(qas
);
1427 else if (attr
== &dev_attr_max_qas
.attr
&&
1428 spi_support_qas(starget
))
1429 return TARGET_ATTRIBUTE_HELPER(qas
);
1430 else if (attr
== &dev_attr_wr_flow
.attr
&&
1431 spi_support_ius(starget
))
1432 return TARGET_ATTRIBUTE_HELPER(wr_flow
);
1433 else if (attr
== &dev_attr_rd_strm
.attr
&&
1434 spi_support_ius(starget
))
1435 return TARGET_ATTRIBUTE_HELPER(rd_strm
);
1436 else if (attr
== &dev_attr_rti
.attr
&&
1437 spi_support_ius(starget
))
1438 return TARGET_ATTRIBUTE_HELPER(rti
);
1439 else if (attr
== &dev_attr_pcomp_en
.attr
&&
1440 spi_support_ius(starget
))
1441 return TARGET_ATTRIBUTE_HELPER(pcomp_en
);
1442 else if (attr
== &dev_attr_hold_mcs
.attr
&&
1443 spi_support_ius(starget
))
1444 return TARGET_ATTRIBUTE_HELPER(hold_mcs
);
1445 else if (attr
== &dev_attr_revalidate
.attr
)
1451 static struct attribute
*target_attributes
[] = {
1452 &dev_attr_period
.attr
,
1453 &dev_attr_min_period
.attr
,
1454 &dev_attr_offset
.attr
,
1455 &dev_attr_max_offset
.attr
,
1456 &dev_attr_width
.attr
,
1457 &dev_attr_max_width
.attr
,
1459 &dev_attr_max_iu
.attr
,
1462 &dev_attr_max_qas
.attr
,
1463 &dev_attr_wr_flow
.attr
,
1464 &dev_attr_rd_strm
.attr
,
1466 &dev_attr_pcomp_en
.attr
,
1467 &dev_attr_hold_mcs
.attr
,
1468 &dev_attr_revalidate
.attr
,
1472 static struct attribute_group target_attribute_group
= {
1473 .attrs
= target_attributes
,
1474 .is_visible
= target_attribute_is_visible
,
1477 static int spi_target_configure(struct transport_container
*tc
,
1479 struct device
*cdev
)
1481 struct kobject
*kobj
= &cdev
->kobj
;
1483 /* force an update based on parameters read from the device */
1484 sysfs_update_group(kobj
, &target_attribute_group
);
1489 struct scsi_transport_template
*
1490 spi_attach_transport(struct spi_function_template
*ft
)
1492 struct spi_internal
*i
= kzalloc(sizeof(struct spi_internal
),
1498 i
->t
.target_attrs
.ac
.class = &spi_transport_class
.class;
1499 i
->t
.target_attrs
.ac
.grp
= &target_attribute_group
;
1500 i
->t
.target_attrs
.ac
.match
= spi_target_match
;
1501 transport_container_register(&i
->t
.target_attrs
);
1502 i
->t
.target_size
= sizeof(struct spi_transport_attrs
);
1503 i
->t
.host_attrs
.ac
.class = &spi_host_class
.class;
1504 i
->t
.host_attrs
.ac
.grp
= &host_attribute_group
;
1505 i
->t
.host_attrs
.ac
.match
= spi_host_match
;
1506 transport_container_register(&i
->t
.host_attrs
);
1507 i
->t
.host_size
= sizeof(struct spi_host_attrs
);
1512 EXPORT_SYMBOL(spi_attach_transport
);
1514 void spi_release_transport(struct scsi_transport_template
*t
)
1516 struct spi_internal
*i
= to_spi_internal(t
);
1518 transport_container_unregister(&i
->t
.target_attrs
);
1519 transport_container_unregister(&i
->t
.host_attrs
);
1523 EXPORT_SYMBOL(spi_release_transport
);
1525 static __init
int spi_transport_init(void)
1527 int error
= transport_class_register(&spi_transport_class
);
1530 error
= anon_transport_class_register(&spi_device_class
);
1531 return transport_class_register(&spi_host_class
);
1534 static void __exit
spi_transport_exit(void)
1536 transport_class_unregister(&spi_transport_class
);
1537 anon_transport_class_unregister(&spi_device_class
);
1538 transport_class_unregister(&spi_host_class
);
1541 MODULE_AUTHOR("Martin Hicks");
1542 MODULE_DESCRIPTION("SPI Transport Attributes");
1543 MODULE_LICENSE("GPL");
1545 module_init(spi_transport_init
);
1546 module_exit(spi_transport_exit
);