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 <scsi/scsi.h>
28 #include "scsi_priv.h"
29 #include <scsi/scsi_device.h>
30 #include <scsi/scsi_host.h>
31 #include <scsi/scsi_cmnd.h>
32 #include <scsi/scsi_eh.h>
33 #include <scsi/scsi_transport.h>
34 #include <scsi/scsi_transport_spi.h>
36 #define SPI_NUM_ATTRS 14 /* increase this if you add attributes */
37 #define SPI_OTHER_ATTRS 1 /* Increase this if you add "always
39 #define SPI_HOST_ATTRS 1
41 #define SPI_MAX_ECHO_BUFFER_SIZE 4096
44 #define DV_TIMEOUT (10*HZ)
45 #define DV_RETRIES 3 /* should only need at most
48 /* Private data accessors (keep these out of the header file) */
49 #define spi_dv_pending(x) (((struct spi_transport_attrs *)&(x)->starget_data)->dv_pending)
50 #define spi_dv_mutex(x) (((struct spi_transport_attrs *)&(x)->starget_data)->dv_mutex)
53 struct scsi_transport_template t
;
54 struct spi_function_template
*f
;
55 /* The actual attributes */
56 struct class_device_attribute private_attrs
[SPI_NUM_ATTRS
];
57 /* The array of null terminated pointers to attributes
58 * needed by scsi_sysfs.c */
59 struct class_device_attribute
*attrs
[SPI_NUM_ATTRS
+ SPI_OTHER_ATTRS
+ 1];
60 struct class_device_attribute private_host_attrs
[SPI_HOST_ATTRS
];
61 struct class_device_attribute
*host_attrs
[SPI_HOST_ATTRS
+ 1];
64 #define to_spi_internal(tmpl) container_of(tmpl, struct spi_internal, t)
66 static const int ppr_to_ps
[] = {
67 /* The PPR values 0-6 are reserved, fill them in when
68 * the committee defines them */
83 /* The PPR values at which you calculate the period in ns by multiplying
85 #define SPI_STATIC_PPR 0x0c
87 static int sprint_frac(char *dest
, int value
, int denom
)
89 int frac
= value
% denom
;
90 int result
= sprintf(dest
, "%d", value
/ denom
);
98 sprintf(dest
+ result
, "%d", frac
/ denom
);
103 dest
[result
++] = '\0';
107 static int spi_execute(struct scsi_device
*sdev
, const void *cmd
,
108 enum dma_data_direction dir
,
109 void *buffer
, unsigned bufflen
,
110 struct scsi_sense_hdr
*sshdr
)
113 unsigned char sense
[SCSI_SENSE_BUFFERSIZE
];
115 for(i
= 0; i
< DV_RETRIES
; i
++) {
116 result
= scsi_execute(sdev
, cmd
, dir
, buffer
, bufflen
,
117 sense
, DV_TIMEOUT
, /* retries */ 1,
119 if (result
& DRIVER_SENSE
) {
120 struct scsi_sense_hdr sshdr_tmp
;
124 if (scsi_normalize_sense(sense
, sizeof(*sense
),
126 && sshdr
->sense_key
== UNIT_ATTENTION
)
135 enum spi_signal_type value
;
138 { SPI_SIGNAL_UNKNOWN
, "unknown" },
139 { SPI_SIGNAL_SE
, "SE" },
140 { SPI_SIGNAL_LVD
, "LVD" },
141 { SPI_SIGNAL_HVD
, "HVD" },
144 static inline const char *spi_signal_to_string(enum spi_signal_type type
)
148 for (i
= 0; i
< ARRAY_SIZE(signal_types
); i
++) {
149 if (type
== signal_types
[i
].value
)
150 return signal_types
[i
].name
;
154 static inline enum spi_signal_type
spi_signal_to_value(const char *name
)
158 for (i
= 0; i
< ARRAY_SIZE(signal_types
); i
++) {
159 len
= strlen(signal_types
[i
].name
);
160 if (strncmp(name
, signal_types
[i
].name
, len
) == 0 &&
161 (name
[len
] == '\n' || name
[len
] == '\0'))
162 return signal_types
[i
].value
;
164 return SPI_SIGNAL_UNKNOWN
;
167 static int spi_host_setup(struct transport_container
*tc
, struct device
*dev
,
168 struct class_device
*cdev
)
170 struct Scsi_Host
*shost
= dev_to_shost(dev
);
172 spi_signalling(shost
) = SPI_SIGNAL_UNKNOWN
;
177 static DECLARE_TRANSPORT_CLASS(spi_host_class
,
183 static int spi_host_match(struct attribute_container
*cont
,
186 struct Scsi_Host
*shost
;
187 struct spi_internal
*i
;
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 i
= to_spi_internal(shost
->transportt
);
199 return &i
->t
.host_attrs
.ac
== cont
;
202 static int spi_device_configure(struct transport_container
*tc
,
204 struct class_device
*cdev
)
206 struct scsi_device
*sdev
= to_scsi_device(dev
);
207 struct scsi_target
*starget
= sdev
->sdev_target
;
209 /* Populate the target capability fields with the values
210 * gleaned from the device inquiry */
212 spi_support_sync(starget
) = scsi_device_sync(sdev
);
213 spi_support_wide(starget
) = scsi_device_wide(sdev
);
214 spi_support_dt(starget
) = scsi_device_dt(sdev
);
215 spi_support_dt_only(starget
) = scsi_device_dt_only(sdev
);
216 spi_support_ius(starget
) = scsi_device_ius(sdev
);
217 spi_support_qas(starget
) = scsi_device_qas(sdev
);
222 static int spi_setup_transport_attrs(struct transport_container
*tc
,
224 struct class_device
*cdev
)
226 struct scsi_target
*starget
= to_scsi_target(dev
);
228 spi_period(starget
) = -1; /* illegal value */
229 spi_min_period(starget
) = 0;
230 spi_offset(starget
) = 0; /* async */
231 spi_max_offset(starget
) = 255;
232 spi_width(starget
) = 0; /* narrow */
233 spi_max_width(starget
) = 1;
234 spi_iu(starget
) = 0; /* no IU */
235 spi_dt(starget
) = 0; /* ST */
236 spi_qas(starget
) = 0;
237 spi_wr_flow(starget
) = 0;
238 spi_rd_strm(starget
) = 0;
239 spi_rti(starget
) = 0;
240 spi_pcomp_en(starget
) = 0;
241 spi_hold_mcs(starget
) = 0;
242 spi_dv_pending(starget
) = 0;
243 spi_initial_dv(starget
) = 0;
244 mutex_init(&spi_dv_mutex(starget
));
249 #define spi_transport_show_simple(field, format_string) \
252 show_spi_transport_##field(struct class_device *cdev, char *buf) \
254 struct scsi_target *starget = transport_class_to_starget(cdev); \
255 struct spi_transport_attrs *tp; \
257 tp = (struct spi_transport_attrs *)&starget->starget_data; \
258 return snprintf(buf, 20, format_string, tp->field); \
261 #define spi_transport_store_simple(field, format_string) \
264 store_spi_transport_##field(struct class_device *cdev, const char *buf, \
268 struct scsi_target *starget = transport_class_to_starget(cdev); \
269 struct spi_transport_attrs *tp; \
271 tp = (struct spi_transport_attrs *)&starget->starget_data; \
272 val = simple_strtoul(buf, NULL, 0); \
277 #define spi_transport_show_function(field, format_string) \
280 show_spi_transport_##field(struct class_device *cdev, char *buf) \
282 struct scsi_target *starget = transport_class_to_starget(cdev); \
283 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); \
284 struct spi_transport_attrs *tp; \
285 struct spi_internal *i = to_spi_internal(shost->transportt); \
286 tp = (struct spi_transport_attrs *)&starget->starget_data; \
287 if (i->f->get_##field) \
288 i->f->get_##field(starget); \
289 return snprintf(buf, 20, format_string, tp->field); \
292 #define spi_transport_store_function(field, format_string) \
294 store_spi_transport_##field(struct class_device *cdev, const char *buf, \
298 struct scsi_target *starget = transport_class_to_starget(cdev); \
299 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); \
300 struct spi_internal *i = to_spi_internal(shost->transportt); \
302 val = simple_strtoul(buf, NULL, 0); \
303 i->f->set_##field(starget, val); \
307 #define spi_transport_store_max(field, format_string) \
309 store_spi_transport_##field(struct class_device *cdev, const char *buf, \
313 struct scsi_target *starget = transport_class_to_starget(cdev); \
314 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); \
315 struct spi_internal *i = to_spi_internal(shost->transportt); \
316 struct spi_transport_attrs *tp \
317 = (struct spi_transport_attrs *)&starget->starget_data; \
319 val = simple_strtoul(buf, NULL, 0); \
320 if (val > tp->max_##field) \
321 val = tp->max_##field; \
322 i->f->set_##field(starget, val); \
326 #define spi_transport_rd_attr(field, format_string) \
327 spi_transport_show_function(field, format_string) \
328 spi_transport_store_function(field, format_string) \
329 static CLASS_DEVICE_ATTR(field, S_IRUGO | S_IWUSR, \
330 show_spi_transport_##field, \
331 store_spi_transport_##field);
333 #define spi_transport_simple_attr(field, format_string) \
334 spi_transport_show_simple(field, format_string) \
335 spi_transport_store_simple(field, format_string) \
336 static CLASS_DEVICE_ATTR(field, S_IRUGO | S_IWUSR, \
337 show_spi_transport_##field, \
338 store_spi_transport_##field);
340 #define spi_transport_max_attr(field, format_string) \
341 spi_transport_show_function(field, format_string) \
342 spi_transport_store_max(field, format_string) \
343 spi_transport_simple_attr(max_##field, format_string) \
344 static CLASS_DEVICE_ATTR(field, S_IRUGO | S_IWUSR, \
345 show_spi_transport_##field, \
346 store_spi_transport_##field);
348 /* The Parallel SCSI Tranport Attributes: */
349 spi_transport_max_attr(offset
, "%d\n");
350 spi_transport_max_attr(width
, "%d\n");
351 spi_transport_rd_attr(iu
, "%d\n");
352 spi_transport_rd_attr(dt
, "%d\n");
353 spi_transport_rd_attr(qas
, "%d\n");
354 spi_transport_rd_attr(wr_flow
, "%d\n");
355 spi_transport_rd_attr(rd_strm
, "%d\n");
356 spi_transport_rd_attr(rti
, "%d\n");
357 spi_transport_rd_attr(pcomp_en
, "%d\n");
358 spi_transport_rd_attr(hold_mcs
, "%d\n");
360 /* we only care about the first child device so we return 1 */
361 static int child_iter(struct device
*dev
, void *data
)
363 struct scsi_device
*sdev
= to_scsi_device(dev
);
370 store_spi_revalidate(struct class_device
*cdev
, const char *buf
, size_t count
)
372 struct scsi_target
*starget
= transport_class_to_starget(cdev
);
374 device_for_each_child(&starget
->dev
, NULL
, child_iter
);
377 static CLASS_DEVICE_ATTR(revalidate
, S_IWUSR
, NULL
, store_spi_revalidate
);
379 /* Translate the period into ns according to the current spec
380 * for SDTR/PPR messages */
381 static int period_to_str(char *buf
, int period
)
385 if (period
< 0 || period
> 0xff) {
387 } else if (period
<= SPI_STATIC_PPR
) {
388 picosec
= ppr_to_ps
[period
];
390 picosec
= period
* 4000;
394 len
= sprintf(buf
, "reserved");
396 len
= sprint_frac(buf
, picosec
, 1000);
403 show_spi_transport_period_helper(char *buf
, int period
)
405 int len
= period_to_str(buf
, period
);
412 store_spi_transport_period_helper(struct class_device
*cdev
, const char *buf
,
413 size_t count
, int *periodp
)
415 int j
, picosec
, period
= -1;
418 picosec
= simple_strtoul(buf
, &endp
, 10) * 1000;
425 picosec
+= (*endp
- '0') * mult
;
430 for (j
= 0; j
<= SPI_STATIC_PPR
; j
++) {
431 if (ppr_to_ps
[j
] < picosec
)
438 period
= picosec
/ 4000;
449 show_spi_transport_period(struct class_device
*cdev
, char *buf
)
451 struct scsi_target
*starget
= transport_class_to_starget(cdev
);
452 struct Scsi_Host
*shost
= dev_to_shost(starget
->dev
.parent
);
453 struct spi_internal
*i
= to_spi_internal(shost
->transportt
);
454 struct spi_transport_attrs
*tp
=
455 (struct spi_transport_attrs
*)&starget
->starget_data
;
457 if (i
->f
->get_period
)
458 i
->f
->get_period(starget
);
460 return show_spi_transport_period_helper(buf
, tp
->period
);
464 store_spi_transport_period(struct class_device
*cdev
, const char *buf
,
467 struct scsi_target
*starget
= transport_class_to_starget(cdev
);
468 struct Scsi_Host
*shost
= dev_to_shost(starget
->dev
.parent
);
469 struct spi_internal
*i
= to_spi_internal(shost
->transportt
);
470 struct spi_transport_attrs
*tp
=
471 (struct spi_transport_attrs
*)&starget
->starget_data
;
474 retval
= store_spi_transport_period_helper(cdev
, buf
, count
, &period
);
476 if (period
< tp
->min_period
)
477 period
= tp
->min_period
;
479 i
->f
->set_period(starget
, period
);
484 static CLASS_DEVICE_ATTR(period
, S_IRUGO
| S_IWUSR
,
485 show_spi_transport_period
,
486 store_spi_transport_period
);
489 show_spi_transport_min_period(struct class_device
*cdev
, char *buf
)
491 struct scsi_target
*starget
= transport_class_to_starget(cdev
);
492 struct spi_transport_attrs
*tp
=
493 (struct spi_transport_attrs
*)&starget
->starget_data
;
495 return show_spi_transport_period_helper(buf
, tp
->min_period
);
499 store_spi_transport_min_period(struct class_device
*cdev
, const char *buf
,
502 struct scsi_target
*starget
= transport_class_to_starget(cdev
);
503 struct spi_transport_attrs
*tp
=
504 (struct spi_transport_attrs
*)&starget
->starget_data
;
506 return store_spi_transport_period_helper(cdev
, buf
, count
,
511 static CLASS_DEVICE_ATTR(min_period
, S_IRUGO
| S_IWUSR
,
512 show_spi_transport_min_period
,
513 store_spi_transport_min_period
);
516 static ssize_t
show_spi_host_signalling(struct class_device
*cdev
, char *buf
)
518 struct Scsi_Host
*shost
= transport_class_to_shost(cdev
);
519 struct spi_internal
*i
= to_spi_internal(shost
->transportt
);
521 if (i
->f
->get_signalling
)
522 i
->f
->get_signalling(shost
);
524 return sprintf(buf
, "%s\n", spi_signal_to_string(spi_signalling(shost
)));
526 static ssize_t
store_spi_host_signalling(struct class_device
*cdev
,
527 const char *buf
, size_t count
)
529 struct Scsi_Host
*shost
= transport_class_to_shost(cdev
);
530 struct spi_internal
*i
= to_spi_internal(shost
->transportt
);
531 enum spi_signal_type type
= spi_signal_to_value(buf
);
533 if (type
!= SPI_SIGNAL_UNKNOWN
)
534 i
->f
->set_signalling(shost
, type
);
538 static CLASS_DEVICE_ATTR(signalling
, S_IRUGO
| S_IWUSR
,
539 show_spi_host_signalling
,
540 store_spi_host_signalling
);
542 #define DV_SET(x, y) \
544 i->f->set_##x(sdev->sdev_target, y)
546 enum spi_compare_returns
{
549 SPI_COMPARE_SKIP_TEST
,
553 /* This is for read/write Domain Validation: If the device supports
554 * an echo buffer, we do read/write tests to it */
555 static enum spi_compare_returns
556 spi_dv_device_echo_buffer(struct scsi_device
*sdev
, u8
*buffer
,
557 u8
*ptr
, const int retries
)
559 int len
= ptr
- buffer
;
561 unsigned int pattern
= 0x0000ffff;
562 struct scsi_sense_hdr sshdr
;
564 const char spi_write_buffer
[] = {
565 WRITE_BUFFER
, 0x0a, 0, 0, 0, 0, 0, len
>> 8, len
& 0xff, 0
567 const char spi_read_buffer
[] = {
568 READ_BUFFER
, 0x0a, 0, 0, 0, 0, 0, len
>> 8, len
& 0xff, 0
571 /* set up the pattern buffer. Doesn't matter if we spill
572 * slightly beyond since that's where the read buffer is */
573 for (j
= 0; j
< len
; ) {
575 /* fill the buffer with counting (test a) */
576 for ( ; j
< min(len
, 32); j
++)
579 /* fill the buffer with alternating words of 0x0 and
581 for ( ; j
< min(len
, k
+ 32); j
+= 2) {
582 u16
*word
= (u16
*)&buffer
[j
];
584 *word
= (j
& 0x02) ? 0x0000 : 0xffff;
587 /* fill with crosstalk (alternating 0x5555 0xaaa)
589 for ( ; j
< min(len
, k
+ 32); j
+= 2) {
590 u16
*word
= (u16
*)&buffer
[j
];
592 *word
= (j
& 0x02) ? 0x5555 : 0xaaaa;
595 /* fill with shifting bits (test d) */
596 for ( ; j
< min(len
, k
+ 32); j
+= 4) {
597 u32
*word
= (unsigned int *)&buffer
[j
];
598 u32 roll
= (pattern
& 0x80000000) ? 1 : 0;
601 pattern
= (pattern
<< 1) | roll
;
603 /* don't bother with random data (test e) */
606 for (r
= 0; r
< retries
; r
++) {
607 result
= spi_execute(sdev
, spi_write_buffer
, DMA_TO_DEVICE
,
608 buffer
, len
, &sshdr
);
609 if(result
|| !scsi_device_online(sdev
)) {
611 scsi_device_set_state(sdev
, SDEV_QUIESCE
);
612 if (scsi_sense_valid(&sshdr
)
613 && sshdr
.sense_key
== ILLEGAL_REQUEST
614 /* INVALID FIELD IN CDB */
615 && sshdr
.asc
== 0x24 && sshdr
.ascq
== 0x00)
616 /* This would mean that the drive lied
617 * to us about supporting an echo
618 * buffer (unfortunately some Western
619 * Digital drives do precisely this)
621 return SPI_COMPARE_SKIP_TEST
;
624 sdev_printk(KERN_ERR
, sdev
, "Write Buffer failure %x\n", result
);
625 return SPI_COMPARE_FAILURE
;
629 spi_execute(sdev
, spi_read_buffer
, DMA_FROM_DEVICE
,
631 scsi_device_set_state(sdev
, SDEV_QUIESCE
);
633 if (memcmp(buffer
, ptr
, len
) != 0)
634 return SPI_COMPARE_FAILURE
;
636 return SPI_COMPARE_SUCCESS
;
639 /* This is for the simplest form of Domain Validation: a read test
640 * on the inquiry data from the device */
641 static enum spi_compare_returns
642 spi_dv_device_compare_inquiry(struct scsi_device
*sdev
, u8
*buffer
,
643 u8
*ptr
, const int retries
)
646 const int len
= sdev
->inquiry_len
;
647 const char spi_inquiry
[] = {
648 INQUIRY
, 0, 0, 0, len
, 0
651 for (r
= 0; r
< retries
; r
++) {
654 result
= spi_execute(sdev
, spi_inquiry
, DMA_FROM_DEVICE
,
657 if(result
|| !scsi_device_online(sdev
)) {
658 scsi_device_set_state(sdev
, SDEV_QUIESCE
);
659 return SPI_COMPARE_FAILURE
;
662 /* If we don't have the inquiry data already, the
663 * first read gets it */
670 if (memcmp(buffer
, ptr
, len
) != 0)
672 return SPI_COMPARE_FAILURE
;
674 return SPI_COMPARE_SUCCESS
;
677 static enum spi_compare_returns
678 spi_dv_retrain(struct scsi_device
*sdev
, u8
*buffer
, u8
*ptr
,
679 enum spi_compare_returns
680 (*compare_fn
)(struct scsi_device
*, u8
*, u8
*, int))
682 struct spi_internal
*i
= to_spi_internal(sdev
->host
->transportt
);
683 struct scsi_target
*starget
= sdev
->sdev_target
;
684 int period
= 0, prevperiod
= 0;
685 enum spi_compare_returns retval
;
690 retval
= compare_fn(sdev
, buffer
, ptr
, DV_LOOPS
);
692 if (retval
== SPI_COMPARE_SUCCESS
693 || retval
== SPI_COMPARE_SKIP_TEST
)
696 /* OK, retrain, fallback */
698 i
->f
->get_iu(starget
);
700 i
->f
->get_qas(starget
);
701 if (i
->f
->get_period
)
702 i
->f
->get_period(sdev
->sdev_target
);
704 /* Here's the fallback sequence; first try turning off
705 * IU, then QAS (if we can control them), then finally
706 * fall down the periods */
707 if (i
->f
->set_iu
&& spi_iu(starget
)) {
708 starget_printk(KERN_ERR
, starget
, "Domain Validation Disabing Information Units\n");
710 } else if (i
->f
->set_qas
&& spi_qas(starget
)) {
711 starget_printk(KERN_ERR
, starget
, "Domain Validation Disabing Quick Arbitration and Selection\n");
714 newperiod
= spi_period(starget
);
715 period
= newperiod
> period
? newperiod
: period
;
719 period
+= period
>> 1;
721 if (unlikely(period
> 0xff || period
== prevperiod
)) {
722 /* Total failure; set to async and return */
723 starget_printk(KERN_ERR
, starget
, "Domain Validation Failure, dropping back to Asynchronous\n");
725 return SPI_COMPARE_FAILURE
;
727 starget_printk(KERN_ERR
, starget
, "Domain Validation detected failure, dropping back\n");
728 DV_SET(period
, period
);
736 spi_dv_device_get_echo_buffer(struct scsi_device
*sdev
, u8
*buffer
)
740 /* first off do a test unit ready. This can error out
741 * because of reservations or some other reason. If it
742 * fails, the device won't let us write to the echo buffer
743 * so just return failure */
745 const char spi_test_unit_ready
[] = {
746 TEST_UNIT_READY
, 0, 0, 0, 0, 0
749 const char spi_read_buffer_descriptor
[] = {
750 READ_BUFFER
, 0x0b, 0, 0, 0, 0, 0, 0, 4, 0
754 /* We send a set of three TURs to clear any outstanding
755 * unit attention conditions if they exist (Otherwise the
756 * buffer tests won't be happy). If the TUR still fails
757 * (reservation conflict, device not ready, etc) just
758 * skip the write tests */
760 result
= spi_execute(sdev
, spi_test_unit_ready
, DMA_NONE
,
772 result
= spi_execute(sdev
, spi_read_buffer_descriptor
,
773 DMA_FROM_DEVICE
, buffer
, 4, NULL
);
776 /* Device has no echo buffer */
779 return buffer
[3] + ((buffer
[2] & 0x1f) << 8);
783 spi_dv_device_internal(struct scsi_device
*sdev
, u8
*buffer
)
785 struct spi_internal
*i
= to_spi_internal(sdev
->host
->transportt
);
786 struct scsi_target
*starget
= sdev
->sdev_target
;
787 struct Scsi_Host
*shost
= sdev
->host
;
788 int len
= sdev
->inquiry_len
;
789 /* first set us up for narrow async */
793 if (spi_dv_device_compare_inquiry(sdev
, buffer
, buffer
, DV_LOOPS
)
794 != SPI_COMPARE_SUCCESS
) {
795 starget_printk(KERN_ERR
, starget
, "Domain Validation Initial Inquiry Failed\n");
796 /* FIXME: should probably offline the device here? */
801 if (i
->f
->set_width
&& spi_max_width(starget
) &&
802 scsi_device_wide(sdev
)) {
803 i
->f
->set_width(starget
, 1);
805 if (spi_dv_device_compare_inquiry(sdev
, buffer
,
808 != SPI_COMPARE_SUCCESS
) {
809 starget_printk(KERN_ERR
, starget
, "Wide Transfers Fail\n");
810 i
->f
->set_width(starget
, 0);
814 if (!i
->f
->set_period
)
817 /* device can't handle synchronous */
818 if (!scsi_device_sync(sdev
) && !scsi_device_dt(sdev
))
821 /* len == -1 is the signal that we need to ascertain the
822 * presence of an echo buffer before trying to use it. len ==
823 * 0 means we don't have an echo buffer */
828 /* now set up to the maximum */
829 DV_SET(offset
, spi_max_offset(starget
));
830 DV_SET(period
, spi_min_period(starget
));
831 /* try QAS requests; this should be harmless to set if the
832 * target supports it */
833 if (scsi_device_qas(sdev
))
835 /* Also try IU transfers */
836 if (scsi_device_ius(sdev
))
838 if (spi_min_period(starget
) < 9) {
839 /* This u320 (or u640). Ignore the coupled parameters
840 * like DT and IU, but set the optional ones */
844 if (spi_min_period(starget
) == 8)
847 /* now that we've done all this, actually check the bus
848 * signal type (if known). Some devices are stupid on
849 * a SE bus and still claim they can try LVD only settings */
850 if (i
->f
->get_signalling
)
851 i
->f
->get_signalling(shost
);
852 if (spi_signalling(shost
) == SPI_SIGNAL_SE
||
853 spi_signalling(shost
) == SPI_SIGNAL_HVD
)
855 /* Do the read only INQUIRY tests */
856 spi_dv_retrain(sdev
, buffer
, buffer
+ sdev
->inquiry_len
,
857 spi_dv_device_compare_inquiry
);
858 /* See if we actually managed to negotiate and sustain DT */
860 i
->f
->get_dt(starget
);
862 /* see if the device has an echo buffer. If it does we can do
863 * the SPI pattern write tests. Because of some broken
864 * devices, we *only* try this on a device that has actually
867 if (len
== -1 && spi_dt(starget
))
868 len
= spi_dv_device_get_echo_buffer(sdev
, buffer
);
871 starget_printk(KERN_INFO
, starget
, "Domain Validation skipping write tests\n");
875 if (len
> SPI_MAX_ECHO_BUFFER_SIZE
) {
876 starget_printk(KERN_WARNING
, starget
, "Echo buffer size %d is too big, trimming to %d\n", len
, SPI_MAX_ECHO_BUFFER_SIZE
);
877 len
= SPI_MAX_ECHO_BUFFER_SIZE
;
880 if (spi_dv_retrain(sdev
, buffer
, buffer
+ len
,
881 spi_dv_device_echo_buffer
)
882 == SPI_COMPARE_SKIP_TEST
) {
883 /* OK, the stupid drive can't do a write echo buffer
884 * test after all, fall back to the read tests */
891 /** spi_dv_device - Do Domain Validation on the device
892 * @sdev: scsi device to validate
894 * Performs the domain validation on the given device in the
895 * current execution thread. Since DV operations may sleep,
896 * the current thread must have user context. Also no SCSI
897 * related locks that would deadlock I/O issued by the DV may
901 spi_dv_device(struct scsi_device
*sdev
)
903 struct scsi_target
*starget
= sdev
->sdev_target
;
905 const int len
= SPI_MAX_ECHO_BUFFER_SIZE
*2;
907 if (unlikely(scsi_device_get(sdev
)))
910 buffer
= kzalloc(len
, GFP_KERNEL
);
912 if (unlikely(!buffer
))
915 /* We need to verify that the actual device will quiesce; the
916 * later target quiesce is just a nice to have */
917 if (unlikely(scsi_device_quiesce(sdev
)))
920 scsi_target_quiesce(starget
);
922 spi_dv_pending(starget
) = 1;
923 mutex_lock(&spi_dv_mutex(starget
));
925 starget_printk(KERN_INFO
, starget
, "Beginning Domain Validation\n");
927 spi_dv_device_internal(sdev
, buffer
);
929 starget_printk(KERN_INFO
, starget
, "Ending Domain Validation\n");
931 mutex_unlock(&spi_dv_mutex(starget
));
932 spi_dv_pending(starget
) = 0;
934 scsi_target_resume(starget
);
936 spi_initial_dv(starget
) = 1;
941 scsi_device_put(sdev
);
943 EXPORT_SYMBOL(spi_dv_device
);
945 struct work_queue_wrapper
{
946 struct work_struct work
;
947 struct scsi_device
*sdev
;
951 spi_dv_device_work_wrapper(void *data
)
953 struct work_queue_wrapper
*wqw
= (struct work_queue_wrapper
*)data
;
954 struct scsi_device
*sdev
= wqw
->sdev
;
958 spi_dv_pending(sdev
->sdev_target
) = 0;
959 scsi_device_put(sdev
);
964 * spi_schedule_dv_device - schedule domain validation to occur on the device
965 * @sdev: The device to validate
967 * Identical to spi_dv_device() above, except that the DV will be
968 * scheduled to occur in a workqueue later. All memory allocations
969 * are atomic, so may be called from any context including those holding
973 spi_schedule_dv_device(struct scsi_device
*sdev
)
975 struct work_queue_wrapper
*wqw
=
976 kmalloc(sizeof(struct work_queue_wrapper
), GFP_ATOMIC
);
981 if (unlikely(spi_dv_pending(sdev
->sdev_target
))) {
985 /* Set pending early (dv_device doesn't check it, only sets it) */
986 spi_dv_pending(sdev
->sdev_target
) = 1;
987 if (unlikely(scsi_device_get(sdev
))) {
989 spi_dv_pending(sdev
->sdev_target
) = 0;
993 INIT_WORK(&wqw
->work
, spi_dv_device_work_wrapper
, wqw
);
996 schedule_work(&wqw
->work
);
998 EXPORT_SYMBOL(spi_schedule_dv_device
);
1001 * spi_display_xfer_agreement - Print the current target transfer agreement
1002 * @starget: The target for which to display the agreement
1004 * Each SPI port is required to maintain a transfer agreement for each
1005 * other port on the bus. This function prints a one-line summary of
1006 * the current agreement; more detailed information is available in sysfs.
1008 void spi_display_xfer_agreement(struct scsi_target
*starget
)
1010 struct spi_transport_attrs
*tp
;
1011 tp
= (struct spi_transport_attrs
*)&starget
->starget_data
;
1013 if (tp
->offset
> 0 && tp
->period
> 0) {
1014 unsigned int picosec
, kb100
;
1015 char *scsi
= "FAST-?";
1018 if (tp
->period
<= SPI_STATIC_PPR
) {
1019 picosec
= ppr_to_ps
[tp
->period
];
1020 switch (tp
->period
) {
1021 case 7: scsi
= "FAST-320"; break;
1022 case 8: scsi
= "FAST-160"; break;
1023 case 9: scsi
= "FAST-80"; break;
1025 case 11: scsi
= "FAST-40"; break;
1026 case 12: scsi
= "FAST-20"; break;
1029 picosec
= tp
->period
* 4000;
1030 if (tp
->period
< 25)
1032 else if (tp
->period
< 50)
1038 kb100
= (10000000 + picosec
/ 2) / picosec
;
1041 sprint_frac(tmp
, picosec
, 1000);
1043 dev_info(&starget
->dev
,
1044 "%s %sSCSI %d.%d MB/s %s%s%s%s%s%s%s%s (%s ns, offset %d)\n",
1045 scsi
, tp
->width
? "WIDE " : "", kb100
/10, kb100
% 10,
1046 tp
->dt
? "DT" : "ST",
1047 tp
->iu
? " IU" : "",
1048 tp
->qas
? " QAS" : "",
1049 tp
->rd_strm
? " RDSTRM" : "",
1050 tp
->rti
? " RTI" : "",
1051 tp
->wr_flow
? " WRFLOW" : "",
1052 tp
->pcomp_en
? " PCOMP" : "",
1053 tp
->hold_mcs
? " HMCS" : "",
1056 dev_info(&starget
->dev
, "%sasynchronous\n",
1057 tp
->width
? "wide " : "");
1060 EXPORT_SYMBOL(spi_display_xfer_agreement
);
1062 int spi_populate_width_msg(unsigned char *msg
, int width
)
1064 msg
[0] = EXTENDED_MESSAGE
;
1066 msg
[2] = EXTENDED_WDTR
;
1070 EXPORT_SYMBOL_GPL(spi_populate_width_msg
);
1072 int spi_populate_sync_msg(unsigned char *msg
, int period
, int offset
)
1074 msg
[0] = EXTENDED_MESSAGE
;
1076 msg
[2] = EXTENDED_SDTR
;
1081 EXPORT_SYMBOL_GPL(spi_populate_sync_msg
);
1083 int spi_populate_ppr_msg(unsigned char *msg
, int period
, int offset
,
1084 int width
, int options
)
1086 msg
[0] = EXTENDED_MESSAGE
;
1088 msg
[2] = EXTENDED_PPR
;
1096 EXPORT_SYMBOL_GPL(spi_populate_ppr_msg
);
1098 #ifdef CONFIG_SCSI_CONSTANTS
1099 static const char * const one_byte_msgs
[] = {
1100 /* 0x00 */ "Task Complete", NULL
/* Extended Message */, "Save Pointers",
1101 /* 0x03 */ "Restore Pointers", "Disconnect", "Initiator Error",
1102 /* 0x06 */ "Abort Task Set", "Message Reject", "Nop", "Message Parity Error",
1103 /* 0x0a */ "Linked Command Complete", "Linked Command Complete w/flag",
1104 /* 0x0c */ "Target Reset", "Abort Task", "Clear Task Set",
1105 /* 0x0f */ "Initiate Recovery", "Release Recovery",
1106 /* 0x11 */ "Terminate Process", "Continue Task", "Target Transfer Disable",
1107 /* 0x14 */ NULL
, NULL
, "Clear ACA", "LUN Reset"
1110 static const char * const two_byte_msgs
[] = {
1111 /* 0x20 */ "Simple Queue Tag", "Head of Queue Tag", "Ordered Queue Tag",
1112 /* 0x23 */ "Ignore Wide Residue", "ACA"
1115 static const char * const extended_msgs
[] = {
1116 /* 0x00 */ "Modify Data Pointer", "Synchronous Data Transfer Request",
1117 /* 0x02 */ "SCSI-I Extended Identify", "Wide Data Transfer Request",
1118 /* 0x04 */ "Parallel Protocol Request", "Modify Bidirectional Data Pointer"
1121 static void print_nego(const unsigned char *msg
, int per
, int off
, int width
)
1125 period_to_str(buf
, msg
[per
]);
1126 printk("period = %s ns ", buf
);
1130 printk("offset = %d ", msg
[off
]);
1132 printk("width = %d ", 8 << msg
[width
]);
1135 static void print_ptr(const unsigned char *msg
, int msb
, const char *desc
)
1137 int ptr
= (msg
[msb
] << 24) | (msg
[msb
+1] << 16) | (msg
[msb
+2] << 8) |
1139 printk("%s = %d ", desc
, ptr
);
1142 int spi_print_msg(const unsigned char *msg
)
1145 if (msg
[0] == EXTENDED_MESSAGE
) {
1149 if (msg
[2] < ARRAY_SIZE(extended_msgs
))
1150 printk ("%s ", extended_msgs
[msg
[2]]);
1152 printk ("Extended Message, reserved code (0x%02x) ",
1155 case EXTENDED_MODIFY_DATA_POINTER
:
1156 print_ptr(msg
, 3, "pointer");
1159 print_nego(msg
, 3, 4, 0);
1162 print_nego(msg
, 0, 0, 3);
1165 print_nego(msg
, 3, 5, 6);
1167 case EXTENDED_MODIFY_BIDI_DATA_PTR
:
1168 print_ptr(msg
, 3, "out");
1169 print_ptr(msg
, 7, "in");
1172 for (i
= 2; i
< len
; ++i
)
1173 printk("%02x ", msg
[i
]);
1176 } else if (msg
[0] & 0x80) {
1177 printk("Identify disconnect %sallowed %s %d ",
1178 (msg
[0] & 0x40) ? "" : "not ",
1179 (msg
[0] & 0x20) ? "target routine" : "lun",
1181 /* Normal One byte */
1182 } else if (msg
[0] < 0x1f) {
1183 if (msg
[0] < ARRAY_SIZE(one_byte_msgs
) && one_byte_msgs
[msg
[0]])
1184 printk("%s ", one_byte_msgs
[msg
[0]]);
1186 printk("reserved (%02x) ", msg
[0]);
1187 } else if (msg
[0] == 0x55) {
1188 printk("QAS Request ");
1190 } else if (msg
[0] <= 0x2f) {
1191 if ((msg
[0] - 0x20) < ARRAY_SIZE(two_byte_msgs
))
1192 printk("%s %02x ", two_byte_msgs
[msg
[0] - 0x20],
1195 printk("reserved two byte (%02x %02x) ",
1199 printk("reserved ");
1202 EXPORT_SYMBOL(spi_print_msg
);
1204 #else /* ifndef CONFIG_SCSI_CONSTANTS */
1206 int spi_print_msg(const unsigned char *msg
)
1210 if (msg
[0] == EXTENDED_MESSAGE
) {
1214 for (i
= 0; i
< len
; ++i
)
1215 printk("%02x ", msg
[i
]);
1217 } else if (msg
[0] & 0x80) {
1218 printk("%02x ", msg
[0]);
1219 /* Normal One byte */
1220 } else if ((msg
[0] < 0x1f) || (msg
[0] == 0x55)) {
1221 printk("%02x ", msg
[0]);
1223 } else if (msg
[0] <= 0x2f) {
1224 printk("%02x %02x", msg
[0], msg
[1]);
1227 printk("%02x ", msg
[0]);
1230 EXPORT_SYMBOL(spi_print_msg
);
1231 #endif /* ! CONFIG_SCSI_CONSTANTS */
1233 #define SETUP_ATTRIBUTE(field) \
1234 i->private_attrs[count] = class_device_attr_##field; \
1235 if (!i->f->set_##field) { \
1236 i->private_attrs[count].attr.mode = S_IRUGO; \
1237 i->private_attrs[count].store = NULL; \
1239 i->attrs[count] = &i->private_attrs[count]; \
1240 if (i->f->show_##field) \
1243 #define SETUP_RELATED_ATTRIBUTE(field, rel_field) \
1244 i->private_attrs[count] = class_device_attr_##field; \
1245 if (!i->f->set_##rel_field) { \
1246 i->private_attrs[count].attr.mode = S_IRUGO; \
1247 i->private_attrs[count].store = NULL; \
1249 i->attrs[count] = &i->private_attrs[count]; \
1250 if (i->f->show_##rel_field) \
1253 #define SETUP_HOST_ATTRIBUTE(field) \
1254 i->private_host_attrs[count] = class_device_attr_##field; \
1255 if (!i->f->set_##field) { \
1256 i->private_host_attrs[count].attr.mode = S_IRUGO; \
1257 i->private_host_attrs[count].store = NULL; \
1259 i->host_attrs[count] = &i->private_host_attrs[count]; \
1262 static int spi_device_match(struct attribute_container
*cont
,
1265 struct scsi_device
*sdev
;
1266 struct Scsi_Host
*shost
;
1267 struct spi_internal
*i
;
1269 if (!scsi_is_sdev_device(dev
))
1272 sdev
= to_scsi_device(dev
);
1274 if (!shost
->transportt
|| shost
->transportt
->host_attrs
.ac
.class
1275 != &spi_host_class
.class)
1277 /* Note: this class has no device attributes, so it has
1278 * no per-HBA allocation and thus we don't need to distinguish
1279 * the attribute containers for the device */
1280 i
= to_spi_internal(shost
->transportt
);
1281 if (i
->f
->deny_binding
&& i
->f
->deny_binding(sdev
->sdev_target
))
1286 static int spi_target_match(struct attribute_container
*cont
,
1289 struct Scsi_Host
*shost
;
1290 struct scsi_target
*starget
;
1291 struct spi_internal
*i
;
1293 if (!scsi_is_target_device(dev
))
1296 shost
= dev_to_shost(dev
->parent
);
1297 if (!shost
->transportt
|| shost
->transportt
->host_attrs
.ac
.class
1298 != &spi_host_class
.class)
1301 i
= to_spi_internal(shost
->transportt
);
1302 starget
= to_scsi_target(dev
);
1304 if (i
->f
->deny_binding
&& i
->f
->deny_binding(starget
))
1307 return &i
->t
.target_attrs
.ac
== cont
;
1310 static DECLARE_TRANSPORT_CLASS(spi_transport_class
,
1312 spi_setup_transport_attrs
,
1316 static DECLARE_ANON_TRANSPORT_CLASS(spi_device_class
,
1318 spi_device_configure
);
1320 struct scsi_transport_template
*
1321 spi_attach_transport(struct spi_function_template
*ft
)
1324 struct spi_internal
*i
= kzalloc(sizeof(struct spi_internal
),
1330 i
->t
.target_attrs
.ac
.class = &spi_transport_class
.class;
1331 i
->t
.target_attrs
.ac
.attrs
= &i
->attrs
[0];
1332 i
->t
.target_attrs
.ac
.match
= spi_target_match
;
1333 transport_container_register(&i
->t
.target_attrs
);
1334 i
->t
.target_size
= sizeof(struct spi_transport_attrs
);
1335 i
->t
.host_attrs
.ac
.class = &spi_host_class
.class;
1336 i
->t
.host_attrs
.ac
.attrs
= &i
->host_attrs
[0];
1337 i
->t
.host_attrs
.ac
.match
= spi_host_match
;
1338 transport_container_register(&i
->t
.host_attrs
);
1339 i
->t
.host_size
= sizeof(struct spi_host_attrs
);
1342 SETUP_ATTRIBUTE(period
);
1343 SETUP_RELATED_ATTRIBUTE(min_period
, period
);
1344 SETUP_ATTRIBUTE(offset
);
1345 SETUP_RELATED_ATTRIBUTE(max_offset
, offset
);
1346 SETUP_ATTRIBUTE(width
);
1347 SETUP_RELATED_ATTRIBUTE(max_width
, width
);
1348 SETUP_ATTRIBUTE(iu
);
1349 SETUP_ATTRIBUTE(dt
);
1350 SETUP_ATTRIBUTE(qas
);
1351 SETUP_ATTRIBUTE(wr_flow
);
1352 SETUP_ATTRIBUTE(rd_strm
);
1353 SETUP_ATTRIBUTE(rti
);
1354 SETUP_ATTRIBUTE(pcomp_en
);
1355 SETUP_ATTRIBUTE(hold_mcs
);
1357 /* if you add an attribute but forget to increase SPI_NUM_ATTRS
1358 * this bug will trigger */
1359 BUG_ON(count
> SPI_NUM_ATTRS
);
1361 i
->attrs
[count
++] = &class_device_attr_revalidate
;
1363 i
->attrs
[count
] = NULL
;
1366 SETUP_HOST_ATTRIBUTE(signalling
);
1368 BUG_ON(count
> SPI_HOST_ATTRS
);
1370 i
->host_attrs
[count
] = NULL
;
1374 EXPORT_SYMBOL(spi_attach_transport
);
1376 void spi_release_transport(struct scsi_transport_template
*t
)
1378 struct spi_internal
*i
= to_spi_internal(t
);
1380 transport_container_unregister(&i
->t
.target_attrs
);
1381 transport_container_unregister(&i
->t
.host_attrs
);
1385 EXPORT_SYMBOL(spi_release_transport
);
1387 static __init
int spi_transport_init(void)
1389 int error
= transport_class_register(&spi_transport_class
);
1392 error
= anon_transport_class_register(&spi_device_class
);
1393 return transport_class_register(&spi_host_class
);
1396 static void __exit
spi_transport_exit(void)
1398 transport_class_unregister(&spi_transport_class
);
1399 anon_transport_class_unregister(&spi_device_class
);
1400 transport_class_unregister(&spi_host_class
);
1403 MODULE_AUTHOR("Martin Hicks");
1404 MODULE_DESCRIPTION("SPI Transport Attributes");
1405 MODULE_LICENSE("GPL");
1407 module_init(spi_transport_init
);
1408 module_exit(spi_transport_exit
);