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 (!scsi_device_wide(sdev
)) {
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 (!scsi_device_sync(sdev
) && !scsi_device_dt(sdev
))
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 (scsi_device_qas(sdev
) && spi_max_qas(starget
)) {
885 if (scsi_device_ius(sdev
) && spi_max_iu(starget
) && min_period
< 9) {
886 /* This u320 (or u640). Set IU transfers */
888 /* Then set the optional parameters */
898 /* now that we've done all this, actually check the bus
899 * signal type (if known). Some devices are stupid on
900 * a SE bus and still claim they can try LVD only settings */
901 if (i
->f
->get_signalling
)
902 i
->f
->get_signalling(shost
);
903 if (spi_signalling(shost
) == SPI_SIGNAL_SE
||
904 spi_signalling(shost
) == SPI_SIGNAL_HVD
||
905 !scsi_device_dt(sdev
)) {
910 /* set width last because it will pull all the other
911 * parameters down to required values */
912 DV_SET(width
, max_width
);
914 /* Do the read only INQUIRY tests */
915 spi_dv_retrain(sdev
, buffer
, buffer
+ sdev
->inquiry_len
,
916 spi_dv_device_compare_inquiry
);
917 /* See if we actually managed to negotiate and sustain DT */
919 i
->f
->get_dt(starget
);
921 /* see if the device has an echo buffer. If it does we can do
922 * the SPI pattern write tests. Because of some broken
923 * devices, we *only* try this on a device that has actually
926 if (len
== -1 && spi_dt(starget
))
927 len
= spi_dv_device_get_echo_buffer(sdev
, buffer
);
930 starget_printk(KERN_INFO
, starget
, "Domain Validation skipping write tests\n");
934 if (len
> SPI_MAX_ECHO_BUFFER_SIZE
) {
935 starget_printk(KERN_WARNING
, starget
, "Echo buffer size %d is too big, trimming to %d\n", len
, SPI_MAX_ECHO_BUFFER_SIZE
);
936 len
= SPI_MAX_ECHO_BUFFER_SIZE
;
939 if (spi_dv_retrain(sdev
, buffer
, buffer
+ len
,
940 spi_dv_device_echo_buffer
)
941 == SPI_COMPARE_SKIP_TEST
) {
942 /* OK, the stupid drive can't do a write echo buffer
943 * test after all, fall back to the read tests */
950 /** spi_dv_device - Do Domain Validation on the device
951 * @sdev: scsi device to validate
953 * Performs the domain validation on the given device in the
954 * current execution thread. Since DV operations may sleep,
955 * the current thread must have user context. Also no SCSI
956 * related locks that would deadlock I/O issued by the DV may
960 spi_dv_device(struct scsi_device
*sdev
)
962 struct scsi_target
*starget
= sdev
->sdev_target
;
964 const int len
= SPI_MAX_ECHO_BUFFER_SIZE
*2;
966 if (unlikely(scsi_device_get(sdev
)))
969 if (unlikely(spi_dv_in_progress(starget
)))
971 spi_dv_in_progress(starget
) = 1;
973 buffer
= kzalloc(len
, GFP_KERNEL
);
975 if (unlikely(!buffer
))
978 /* We need to verify that the actual device will quiesce; the
979 * later target quiesce is just a nice to have */
980 if (unlikely(scsi_device_quiesce(sdev
)))
983 scsi_target_quiesce(starget
);
985 spi_dv_pending(starget
) = 1;
986 mutex_lock(&spi_dv_mutex(starget
));
988 starget_printk(KERN_INFO
, starget
, "Beginning Domain Validation\n");
990 spi_dv_device_internal(sdev
, buffer
);
992 starget_printk(KERN_INFO
, starget
, "Ending Domain Validation\n");
994 mutex_unlock(&spi_dv_mutex(starget
));
995 spi_dv_pending(starget
) = 0;
997 scsi_target_resume(starget
);
999 spi_initial_dv(starget
) = 1;
1004 spi_dv_in_progress(starget
) = 0;
1005 scsi_device_put(sdev
);
1007 EXPORT_SYMBOL(spi_dv_device
);
1009 struct work_queue_wrapper
{
1010 struct work_struct work
;
1011 struct scsi_device
*sdev
;
1015 spi_dv_device_work_wrapper(struct work_struct
*work
)
1017 struct work_queue_wrapper
*wqw
=
1018 container_of(work
, struct work_queue_wrapper
, work
);
1019 struct scsi_device
*sdev
= wqw
->sdev
;
1022 spi_dv_device(sdev
);
1023 spi_dv_pending(sdev
->sdev_target
) = 0;
1024 scsi_device_put(sdev
);
1029 * spi_schedule_dv_device - schedule domain validation to occur on the device
1030 * @sdev: The device to validate
1032 * Identical to spi_dv_device() above, except that the DV will be
1033 * scheduled to occur in a workqueue later. All memory allocations
1034 * are atomic, so may be called from any context including those holding
1038 spi_schedule_dv_device(struct scsi_device
*sdev
)
1040 struct work_queue_wrapper
*wqw
=
1041 kmalloc(sizeof(struct work_queue_wrapper
), GFP_ATOMIC
);
1046 if (unlikely(spi_dv_pending(sdev
->sdev_target
))) {
1050 /* Set pending early (dv_device doesn't check it, only sets it) */
1051 spi_dv_pending(sdev
->sdev_target
) = 1;
1052 if (unlikely(scsi_device_get(sdev
))) {
1054 spi_dv_pending(sdev
->sdev_target
) = 0;
1058 INIT_WORK(&wqw
->work
, spi_dv_device_work_wrapper
);
1061 schedule_work(&wqw
->work
);
1063 EXPORT_SYMBOL(spi_schedule_dv_device
);
1066 * spi_display_xfer_agreement - Print the current target transfer agreement
1067 * @starget: The target for which to display the agreement
1069 * Each SPI port is required to maintain a transfer agreement for each
1070 * other port on the bus. This function prints a one-line summary of
1071 * the current agreement; more detailed information is available in sysfs.
1073 void spi_display_xfer_agreement(struct scsi_target
*starget
)
1075 struct spi_transport_attrs
*tp
;
1076 tp
= (struct spi_transport_attrs
*)&starget
->starget_data
;
1078 if (tp
->offset
> 0 && tp
->period
> 0) {
1079 unsigned int picosec
, kb100
;
1080 char *scsi
= "FAST-?";
1083 if (tp
->period
<= SPI_STATIC_PPR
) {
1084 picosec
= ppr_to_ps
[tp
->period
];
1085 switch (tp
->period
) {
1086 case 7: scsi
= "FAST-320"; break;
1087 case 8: scsi
= "FAST-160"; break;
1088 case 9: scsi
= "FAST-80"; break;
1090 case 11: scsi
= "FAST-40"; break;
1091 case 12: scsi
= "FAST-20"; break;
1094 picosec
= tp
->period
* 4000;
1095 if (tp
->period
< 25)
1097 else if (tp
->period
< 50)
1103 kb100
= (10000000 + picosec
/ 2) / picosec
;
1106 sprint_frac(tmp
, picosec
, 1000);
1108 dev_info(&starget
->dev
,
1109 "%s %sSCSI %d.%d MB/s %s%s%s%s%s%s%s%s (%s ns, offset %d)\n",
1110 scsi
, tp
->width
? "WIDE " : "", kb100
/10, kb100
% 10,
1111 tp
->dt
? "DT" : "ST",
1112 tp
->iu
? " IU" : "",
1113 tp
->qas
? " QAS" : "",
1114 tp
->rd_strm
? " RDSTRM" : "",
1115 tp
->rti
? " RTI" : "",
1116 tp
->wr_flow
? " WRFLOW" : "",
1117 tp
->pcomp_en
? " PCOMP" : "",
1118 tp
->hold_mcs
? " HMCS" : "",
1121 dev_info(&starget
->dev
, "%sasynchronous\n",
1122 tp
->width
? "wide " : "");
1125 EXPORT_SYMBOL(spi_display_xfer_agreement
);
1127 int spi_populate_width_msg(unsigned char *msg
, int width
)
1129 msg
[0] = EXTENDED_MESSAGE
;
1131 msg
[2] = EXTENDED_WDTR
;
1135 EXPORT_SYMBOL_GPL(spi_populate_width_msg
);
1137 int spi_populate_sync_msg(unsigned char *msg
, int period
, int offset
)
1139 msg
[0] = EXTENDED_MESSAGE
;
1141 msg
[2] = EXTENDED_SDTR
;
1146 EXPORT_SYMBOL_GPL(spi_populate_sync_msg
);
1148 int spi_populate_ppr_msg(unsigned char *msg
, int period
, int offset
,
1149 int width
, int options
)
1151 msg
[0] = EXTENDED_MESSAGE
;
1153 msg
[2] = EXTENDED_PPR
;
1161 EXPORT_SYMBOL_GPL(spi_populate_ppr_msg
);
1163 #ifdef CONFIG_SCSI_CONSTANTS
1164 static const char * const one_byte_msgs
[] = {
1165 /* 0x00 */ "Task Complete", NULL
/* Extended Message */, "Save Pointers",
1166 /* 0x03 */ "Restore Pointers", "Disconnect", "Initiator Error",
1167 /* 0x06 */ "Abort Task Set", "Message Reject", "Nop", "Message Parity Error",
1168 /* 0x0a */ "Linked Command Complete", "Linked Command Complete w/flag",
1169 /* 0x0c */ "Target Reset", "Abort Task", "Clear Task Set",
1170 /* 0x0f */ "Initiate Recovery", "Release Recovery",
1171 /* 0x11 */ "Terminate Process", "Continue Task", "Target Transfer Disable",
1172 /* 0x14 */ NULL
, NULL
, "Clear ACA", "LUN Reset"
1175 static const char * const two_byte_msgs
[] = {
1176 /* 0x20 */ "Simple Queue Tag", "Head of Queue Tag", "Ordered Queue Tag",
1177 /* 0x23 */ "Ignore Wide Residue", "ACA"
1180 static const char * const extended_msgs
[] = {
1181 /* 0x00 */ "Modify Data Pointer", "Synchronous Data Transfer Request",
1182 /* 0x02 */ "SCSI-I Extended Identify", "Wide Data Transfer Request",
1183 /* 0x04 */ "Parallel Protocol Request", "Modify Bidirectional Data Pointer"
1186 static void print_nego(const unsigned char *msg
, int per
, int off
, int width
)
1190 period_to_str(buf
, msg
[per
]);
1191 printk("period = %s ns ", buf
);
1195 printk("offset = %d ", msg
[off
]);
1197 printk("width = %d ", 8 << msg
[width
]);
1200 static void print_ptr(const unsigned char *msg
, int msb
, const char *desc
)
1202 int ptr
= (msg
[msb
] << 24) | (msg
[msb
+1] << 16) | (msg
[msb
+2] << 8) |
1204 printk("%s = %d ", desc
, ptr
);
1207 int spi_print_msg(const unsigned char *msg
)
1210 if (msg
[0] == EXTENDED_MESSAGE
) {
1214 if (msg
[2] < ARRAY_SIZE(extended_msgs
))
1215 printk ("%s ", extended_msgs
[msg
[2]]);
1217 printk ("Extended Message, reserved code (0x%02x) ",
1220 case EXTENDED_MODIFY_DATA_POINTER
:
1221 print_ptr(msg
, 3, "pointer");
1224 print_nego(msg
, 3, 4, 0);
1227 print_nego(msg
, 0, 0, 3);
1230 print_nego(msg
, 3, 5, 6);
1232 case EXTENDED_MODIFY_BIDI_DATA_PTR
:
1233 print_ptr(msg
, 3, "out");
1234 print_ptr(msg
, 7, "in");
1237 for (i
= 2; i
< len
; ++i
)
1238 printk("%02x ", msg
[i
]);
1241 } else if (msg
[0] & 0x80) {
1242 printk("Identify disconnect %sallowed %s %d ",
1243 (msg
[0] & 0x40) ? "" : "not ",
1244 (msg
[0] & 0x20) ? "target routine" : "lun",
1246 /* Normal One byte */
1247 } else if (msg
[0] < 0x1f) {
1248 if (msg
[0] < ARRAY_SIZE(one_byte_msgs
) && one_byte_msgs
[msg
[0]])
1249 printk("%s ", one_byte_msgs
[msg
[0]]);
1251 printk("reserved (%02x) ", msg
[0]);
1252 } else if (msg
[0] == 0x55) {
1253 printk("QAS Request ");
1255 } else if (msg
[0] <= 0x2f) {
1256 if ((msg
[0] - 0x20) < ARRAY_SIZE(two_byte_msgs
))
1257 printk("%s %02x ", two_byte_msgs
[msg
[0] - 0x20],
1260 printk("reserved two byte (%02x %02x) ",
1264 printk("reserved ");
1267 EXPORT_SYMBOL(spi_print_msg
);
1269 #else /* ifndef CONFIG_SCSI_CONSTANTS */
1271 int spi_print_msg(const unsigned char *msg
)
1275 if (msg
[0] == EXTENDED_MESSAGE
) {
1279 for (i
= 0; i
< len
; ++i
)
1280 printk("%02x ", msg
[i
]);
1282 } else if (msg
[0] & 0x80) {
1283 printk("%02x ", msg
[0]);
1284 /* Normal One byte */
1285 } else if ((msg
[0] < 0x1f) || (msg
[0] == 0x55)) {
1286 printk("%02x ", msg
[0]);
1288 } else if (msg
[0] <= 0x2f) {
1289 printk("%02x %02x", msg
[0], msg
[1]);
1292 printk("%02x ", msg
[0]);
1295 EXPORT_SYMBOL(spi_print_msg
);
1296 #endif /* ! CONFIG_SCSI_CONSTANTS */
1298 static int spi_device_match(struct attribute_container
*cont
,
1301 struct scsi_device
*sdev
;
1302 struct Scsi_Host
*shost
;
1303 struct spi_internal
*i
;
1305 if (!scsi_is_sdev_device(dev
))
1308 sdev
= to_scsi_device(dev
);
1310 if (!shost
->transportt
|| shost
->transportt
->host_attrs
.ac
.class
1311 != &spi_host_class
.class)
1313 /* Note: this class has no device attributes, so it has
1314 * no per-HBA allocation and thus we don't need to distinguish
1315 * the attribute containers for the device */
1316 i
= to_spi_internal(shost
->transportt
);
1317 if (i
->f
->deny_binding
&& i
->f
->deny_binding(sdev
->sdev_target
))
1322 static int spi_target_match(struct attribute_container
*cont
,
1325 struct Scsi_Host
*shost
;
1326 struct scsi_target
*starget
;
1327 struct spi_internal
*i
;
1329 if (!scsi_is_target_device(dev
))
1332 shost
= dev_to_shost(dev
->parent
);
1333 if (!shost
->transportt
|| shost
->transportt
->host_attrs
.ac
.class
1334 != &spi_host_class
.class)
1337 i
= to_spi_internal(shost
->transportt
);
1338 starget
= to_scsi_target(dev
);
1340 if (i
->f
->deny_binding
&& i
->f
->deny_binding(starget
))
1343 return &i
->t
.target_attrs
.ac
== cont
;
1346 static DECLARE_TRANSPORT_CLASS(spi_transport_class
,
1348 spi_setup_transport_attrs
,
1350 spi_target_configure
);
1352 static DECLARE_ANON_TRANSPORT_CLASS(spi_device_class
,
1354 spi_device_configure
);
1356 static struct attribute
*host_attributes
[] = {
1357 &dev_attr_signalling
.attr
,
1361 static struct attribute_group host_attribute_group
= {
1362 .attrs
= host_attributes
,
1365 static int spi_host_configure(struct transport_container
*tc
,
1367 struct device
*cdev
)
1369 struct kobject
*kobj
= &cdev
->kobj
;
1370 struct Scsi_Host
*shost
= transport_class_to_shost(cdev
);
1371 struct spi_internal
*si
= to_spi_internal(shost
->transportt
);
1372 struct attribute
*attr
= &dev_attr_signalling
.attr
;
1375 if (si
->f
->set_signalling
)
1376 rc
= sysfs_chmod_file(kobj
, attr
, attr
->mode
| S_IWUSR
);
1381 /* returns true if we should be showing the variable. Also
1382 * overloads the return by setting 1<<1 if the attribute should
1384 #define TARGET_ATTRIBUTE_HELPER(name) \
1385 (si->f->show_##name ? S_IRUGO : 0) | \
1386 (si->f->set_##name ? S_IWUSR : 0)
1388 static mode_t
target_attribute_is_visible(struct kobject
*kobj
,
1389 struct attribute
*attr
, int i
)
1391 struct device
*cdev
= container_of(kobj
, struct device
, kobj
);
1392 struct scsi_target
*starget
= transport_class_to_starget(cdev
);
1393 struct Scsi_Host
*shost
= transport_class_to_shost(cdev
);
1394 struct spi_internal
*si
= to_spi_internal(shost
->transportt
);
1396 if (attr
== &dev_attr_period
.attr
&&
1397 spi_support_sync(starget
))
1398 return TARGET_ATTRIBUTE_HELPER(period
);
1399 else if (attr
== &dev_attr_min_period
.attr
&&
1400 spi_support_sync(starget
))
1401 return TARGET_ATTRIBUTE_HELPER(period
);
1402 else if (attr
== &dev_attr_offset
.attr
&&
1403 spi_support_sync(starget
))
1404 return TARGET_ATTRIBUTE_HELPER(offset
);
1405 else if (attr
== &dev_attr_max_offset
.attr
&&
1406 spi_support_sync(starget
))
1407 return TARGET_ATTRIBUTE_HELPER(offset
);
1408 else if (attr
== &dev_attr_width
.attr
&&
1409 spi_support_wide(starget
))
1410 return TARGET_ATTRIBUTE_HELPER(width
);
1411 else if (attr
== &dev_attr_max_width
.attr
&&
1412 spi_support_wide(starget
))
1413 return TARGET_ATTRIBUTE_HELPER(width
);
1414 else if (attr
== &dev_attr_iu
.attr
&&
1415 spi_support_ius(starget
))
1416 return TARGET_ATTRIBUTE_HELPER(iu
);
1417 else if (attr
== &dev_attr_max_iu
.attr
&&
1418 spi_support_ius(starget
))
1419 return TARGET_ATTRIBUTE_HELPER(iu
);
1420 else if (attr
== &dev_attr_dt
.attr
&&
1421 spi_support_dt(starget
))
1422 return TARGET_ATTRIBUTE_HELPER(dt
);
1423 else if (attr
== &dev_attr_qas
.attr
&&
1424 spi_support_qas(starget
))
1425 return TARGET_ATTRIBUTE_HELPER(qas
);
1426 else if (attr
== &dev_attr_max_qas
.attr
&&
1427 spi_support_qas(starget
))
1428 return TARGET_ATTRIBUTE_HELPER(qas
);
1429 else if (attr
== &dev_attr_wr_flow
.attr
&&
1430 spi_support_ius(starget
))
1431 return TARGET_ATTRIBUTE_HELPER(wr_flow
);
1432 else if (attr
== &dev_attr_rd_strm
.attr
&&
1433 spi_support_ius(starget
))
1434 return TARGET_ATTRIBUTE_HELPER(rd_strm
);
1435 else if (attr
== &dev_attr_rti
.attr
&&
1436 spi_support_ius(starget
))
1437 return TARGET_ATTRIBUTE_HELPER(rti
);
1438 else if (attr
== &dev_attr_pcomp_en
.attr
&&
1439 spi_support_ius(starget
))
1440 return TARGET_ATTRIBUTE_HELPER(pcomp_en
);
1441 else if (attr
== &dev_attr_hold_mcs
.attr
&&
1442 spi_support_ius(starget
))
1443 return TARGET_ATTRIBUTE_HELPER(hold_mcs
);
1444 else if (attr
== &dev_attr_revalidate
.attr
)
1450 static struct attribute
*target_attributes
[] = {
1451 &dev_attr_period
.attr
,
1452 &dev_attr_min_period
.attr
,
1453 &dev_attr_offset
.attr
,
1454 &dev_attr_max_offset
.attr
,
1455 &dev_attr_width
.attr
,
1456 &dev_attr_max_width
.attr
,
1458 &dev_attr_max_iu
.attr
,
1461 &dev_attr_max_qas
.attr
,
1462 &dev_attr_wr_flow
.attr
,
1463 &dev_attr_rd_strm
.attr
,
1465 &dev_attr_pcomp_en
.attr
,
1466 &dev_attr_hold_mcs
.attr
,
1467 &dev_attr_revalidate
.attr
,
1471 static struct attribute_group target_attribute_group
= {
1472 .attrs
= target_attributes
,
1473 .is_visible
= target_attribute_is_visible
,
1476 static int spi_target_configure(struct transport_container
*tc
,
1478 struct device
*cdev
)
1480 struct kobject
*kobj
= &cdev
->kobj
;
1482 /* force an update based on parameters read from the device */
1483 sysfs_update_group(kobj
, &target_attribute_group
);
1488 struct scsi_transport_template
*
1489 spi_attach_transport(struct spi_function_template
*ft
)
1491 struct spi_internal
*i
= kzalloc(sizeof(struct spi_internal
),
1497 i
->t
.target_attrs
.ac
.class = &spi_transport_class
.class;
1498 i
->t
.target_attrs
.ac
.grp
= &target_attribute_group
;
1499 i
->t
.target_attrs
.ac
.match
= spi_target_match
;
1500 transport_container_register(&i
->t
.target_attrs
);
1501 i
->t
.target_size
= sizeof(struct spi_transport_attrs
);
1502 i
->t
.host_attrs
.ac
.class = &spi_host_class
.class;
1503 i
->t
.host_attrs
.ac
.grp
= &host_attribute_group
;
1504 i
->t
.host_attrs
.ac
.match
= spi_host_match
;
1505 transport_container_register(&i
->t
.host_attrs
);
1506 i
->t
.host_size
= sizeof(struct spi_host_attrs
);
1511 EXPORT_SYMBOL(spi_attach_transport
);
1513 void spi_release_transport(struct scsi_transport_template
*t
)
1515 struct spi_internal
*i
= to_spi_internal(t
);
1517 transport_container_unregister(&i
->t
.target_attrs
);
1518 transport_container_unregister(&i
->t
.host_attrs
);
1522 EXPORT_SYMBOL(spi_release_transport
);
1524 static __init
int spi_transport_init(void)
1526 int error
= transport_class_register(&spi_transport_class
);
1529 error
= anon_transport_class_register(&spi_device_class
);
1530 return transport_class_register(&spi_host_class
);
1533 static void __exit
spi_transport_exit(void)
1535 transport_class_unregister(&spi_transport_class
);
1536 anon_transport_class_unregister(&spi_device_class
);
1537 transport_class_unregister(&spi_host_class
);
1540 MODULE_AUTHOR("Martin Hicks");
1541 MODULE_DESCRIPTION("SPI Transport Attributes");
1542 MODULE_LICENSE("GPL");
1544 module_init(spi_transport_init
);
1545 module_exit(spi_transport_exit
);