2 * Parallel SCSI (SPI) transport specific attributes exported to sysfs.
4 * Copyright (c) 2003 Silicon Graphics, Inc. All rights reserved.
5 * Copyright (c) 2004, 2005 James Bottomley <James.Bottomley@SteelEye.com>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 #include <linux/ctype.h>
22 #include <linux/init.h>
23 #include <linux/module.h>
24 #include <linux/workqueue.h>
25 #include <linux/blkdev.h>
26 #include <asm/semaphore.h>
27 #include <scsi/scsi.h>
28 #include "scsi_priv.h"
29 #include <scsi/scsi_device.h>
30 #include <scsi/scsi_host.h>
31 #include <scsi/scsi_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_sem(x) (((struct spi_transport_attrs *)&(x)->starget_data)->dv_sem)
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
< sizeof(signal_types
)/sizeof(signal_types
[0]); 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
< sizeof(signal_types
)/sizeof(signal_types
[0]); 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 init_MUTEX(&spi_dv_sem(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 */
382 show_spi_transport_period_helper(struct class_device
*cdev
, char *buf
,
387 if (period
< 0 || period
> 0xff) {
389 } else if (period
<= SPI_STATIC_PPR
) {
390 picosec
= ppr_to_ps
[period
];
392 picosec
= period
* 4000;
396 len
= sprintf(buf
, "reserved");
398 len
= sprint_frac(buf
, picosec
, 1000);
407 store_spi_transport_period_helper(struct class_device
*cdev
, const char *buf
,
408 size_t count
, int *periodp
)
410 int j
, picosec
, period
= -1;
413 picosec
= simple_strtoul(buf
, &endp
, 10) * 1000;
420 picosec
+= (*endp
- '0') * mult
;
425 for (j
= 0; j
<= SPI_STATIC_PPR
; j
++) {
426 if (ppr_to_ps
[j
] < picosec
)
433 period
= picosec
/ 4000;
444 show_spi_transport_period(struct class_device
*cdev
, char *buf
)
446 struct scsi_target
*starget
= transport_class_to_starget(cdev
);
447 struct Scsi_Host
*shost
= dev_to_shost(starget
->dev
.parent
);
448 struct spi_internal
*i
= to_spi_internal(shost
->transportt
);
449 struct spi_transport_attrs
*tp
=
450 (struct spi_transport_attrs
*)&starget
->starget_data
;
452 if (i
->f
->get_period
)
453 i
->f
->get_period(starget
);
455 return show_spi_transport_period_helper(cdev
, buf
, tp
->period
);
459 store_spi_transport_period(struct class_device
*cdev
, const char *buf
,
462 struct scsi_target
*starget
= transport_class_to_starget(cdev
);
463 struct Scsi_Host
*shost
= dev_to_shost(starget
->dev
.parent
);
464 struct spi_internal
*i
= to_spi_internal(shost
->transportt
);
465 struct spi_transport_attrs
*tp
=
466 (struct spi_transport_attrs
*)&starget
->starget_data
;
469 retval
= store_spi_transport_period_helper(cdev
, buf
, count
, &period
);
471 if (period
< tp
->min_period
)
472 period
= tp
->min_period
;
474 i
->f
->set_period(starget
, period
);
479 static CLASS_DEVICE_ATTR(period
, S_IRUGO
| S_IWUSR
,
480 show_spi_transport_period
,
481 store_spi_transport_period
);
484 show_spi_transport_min_period(struct class_device
*cdev
, char *buf
)
486 struct scsi_target
*starget
= transport_class_to_starget(cdev
);
487 struct spi_transport_attrs
*tp
=
488 (struct spi_transport_attrs
*)&starget
->starget_data
;
490 return show_spi_transport_period_helper(cdev
, buf
, tp
->min_period
);
494 store_spi_transport_min_period(struct class_device
*cdev
, const char *buf
,
497 struct scsi_target
*starget
= transport_class_to_starget(cdev
);
498 struct spi_transport_attrs
*tp
=
499 (struct spi_transport_attrs
*)&starget
->starget_data
;
501 return store_spi_transport_period_helper(cdev
, buf
, count
,
506 static CLASS_DEVICE_ATTR(min_period
, S_IRUGO
| S_IWUSR
,
507 show_spi_transport_min_period
,
508 store_spi_transport_min_period
);
511 static ssize_t
show_spi_host_signalling(struct class_device
*cdev
, char *buf
)
513 struct Scsi_Host
*shost
= transport_class_to_shost(cdev
);
514 struct spi_internal
*i
= to_spi_internal(shost
->transportt
);
516 if (i
->f
->get_signalling
)
517 i
->f
->get_signalling(shost
);
519 return sprintf(buf
, "%s\n", spi_signal_to_string(spi_signalling(shost
)));
521 static ssize_t
store_spi_host_signalling(struct class_device
*cdev
,
522 const char *buf
, size_t count
)
524 struct Scsi_Host
*shost
= transport_class_to_shost(cdev
);
525 struct spi_internal
*i
= to_spi_internal(shost
->transportt
);
526 enum spi_signal_type type
= spi_signal_to_value(buf
);
528 if (type
!= SPI_SIGNAL_UNKNOWN
)
529 i
->f
->set_signalling(shost
, type
);
533 static CLASS_DEVICE_ATTR(signalling
, S_IRUGO
| S_IWUSR
,
534 show_spi_host_signalling
,
535 store_spi_host_signalling
);
537 #define DV_SET(x, y) \
539 i->f->set_##x(sdev->sdev_target, y)
541 enum spi_compare_returns
{
544 SPI_COMPARE_SKIP_TEST
,
548 /* This is for read/write Domain Validation: If the device supports
549 * an echo buffer, we do read/write tests to it */
550 static enum spi_compare_returns
551 spi_dv_device_echo_buffer(struct scsi_device
*sdev
, u8
*buffer
,
552 u8
*ptr
, const int retries
)
554 int len
= ptr
- buffer
;
556 unsigned int pattern
= 0x0000ffff;
557 struct scsi_sense_hdr sshdr
;
559 const char spi_write_buffer
[] = {
560 WRITE_BUFFER
, 0x0a, 0, 0, 0, 0, 0, len
>> 8, len
& 0xff, 0
562 const char spi_read_buffer
[] = {
563 READ_BUFFER
, 0x0a, 0, 0, 0, 0, 0, len
>> 8, len
& 0xff, 0
566 /* set up the pattern buffer. Doesn't matter if we spill
567 * slightly beyond since that's where the read buffer is */
568 for (j
= 0; j
< len
; ) {
570 /* fill the buffer with counting (test a) */
571 for ( ; j
< min(len
, 32); j
++)
574 /* fill the buffer with alternating words of 0x0 and
576 for ( ; j
< min(len
, k
+ 32); j
+= 2) {
577 u16
*word
= (u16
*)&buffer
[j
];
579 *word
= (j
& 0x02) ? 0x0000 : 0xffff;
582 /* fill with crosstalk (alternating 0x5555 0xaaa)
584 for ( ; j
< min(len
, k
+ 32); j
+= 2) {
585 u16
*word
= (u16
*)&buffer
[j
];
587 *word
= (j
& 0x02) ? 0x5555 : 0xaaaa;
590 /* fill with shifting bits (test d) */
591 for ( ; j
< min(len
, k
+ 32); j
+= 4) {
592 u32
*word
= (unsigned int *)&buffer
[j
];
593 u32 roll
= (pattern
& 0x80000000) ? 1 : 0;
596 pattern
= (pattern
<< 1) | roll
;
598 /* don't bother with random data (test e) */
601 for (r
= 0; r
< retries
; r
++) {
602 result
= spi_execute(sdev
, spi_write_buffer
, DMA_TO_DEVICE
,
603 buffer
, len
, &sshdr
);
604 if(result
|| !scsi_device_online(sdev
)) {
606 scsi_device_set_state(sdev
, SDEV_QUIESCE
);
607 if (scsi_sense_valid(&sshdr
)
608 && sshdr
.sense_key
== ILLEGAL_REQUEST
609 /* INVALID FIELD IN CDB */
610 && sshdr
.asc
== 0x24 && sshdr
.ascq
== 0x00)
611 /* This would mean that the drive lied
612 * to us about supporting an echo
613 * buffer (unfortunately some Western
614 * Digital drives do precisely this)
616 return SPI_COMPARE_SKIP_TEST
;
619 sdev_printk(KERN_ERR
, sdev
, "Write Buffer failure %x\n", result
);
620 return SPI_COMPARE_FAILURE
;
624 spi_execute(sdev
, spi_read_buffer
, DMA_FROM_DEVICE
,
626 scsi_device_set_state(sdev
, SDEV_QUIESCE
);
628 if (memcmp(buffer
, ptr
, len
) != 0)
629 return SPI_COMPARE_FAILURE
;
631 return SPI_COMPARE_SUCCESS
;
634 /* This is for the simplest form of Domain Validation: a read test
635 * on the inquiry data from the device */
636 static enum spi_compare_returns
637 spi_dv_device_compare_inquiry(struct scsi_device
*sdev
, u8
*buffer
,
638 u8
*ptr
, const int retries
)
641 const int len
= sdev
->inquiry_len
;
642 const char spi_inquiry
[] = {
643 INQUIRY
, 0, 0, 0, len
, 0
646 for (r
= 0; r
< retries
; r
++) {
649 result
= spi_execute(sdev
, spi_inquiry
, DMA_FROM_DEVICE
,
652 if(result
|| !scsi_device_online(sdev
)) {
653 scsi_device_set_state(sdev
, SDEV_QUIESCE
);
654 return SPI_COMPARE_FAILURE
;
657 /* If we don't have the inquiry data already, the
658 * first read gets it */
665 if (memcmp(buffer
, ptr
, len
) != 0)
667 return SPI_COMPARE_FAILURE
;
669 return SPI_COMPARE_SUCCESS
;
672 static enum spi_compare_returns
673 spi_dv_retrain(struct scsi_device
*sdev
, u8
*buffer
, u8
*ptr
,
674 enum spi_compare_returns
675 (*compare_fn
)(struct scsi_device
*, u8
*, u8
*, int))
677 struct spi_internal
*i
= to_spi_internal(sdev
->host
->transportt
);
678 struct scsi_target
*starget
= sdev
->sdev_target
;
679 int period
= 0, prevperiod
= 0;
680 enum spi_compare_returns retval
;
685 retval
= compare_fn(sdev
, buffer
, ptr
, DV_LOOPS
);
687 if (retval
== SPI_COMPARE_SUCCESS
688 || retval
== SPI_COMPARE_SKIP_TEST
)
691 /* OK, retrain, fallback */
693 i
->f
->get_iu(starget
);
695 i
->f
->get_qas(starget
);
696 if (i
->f
->get_period
)
697 i
->f
->get_period(sdev
->sdev_target
);
699 /* Here's the fallback sequence; first try turning off
700 * IU, then QAS (if we can control them), then finally
701 * fall down the periods */
702 if (i
->f
->set_iu
&& spi_iu(starget
)) {
703 starget_printk(KERN_ERR
, starget
, "Domain Validation Disabing Information Units\n");
705 } else if (i
->f
->set_qas
&& spi_qas(starget
)) {
706 starget_printk(KERN_ERR
, starget
, "Domain Validation Disabing Quick Arbitration and Selection\n");
709 newperiod
= spi_period(starget
);
710 period
= newperiod
> period
? newperiod
: period
;
714 period
+= period
>> 1;
716 if (unlikely(period
> 0xff || period
== prevperiod
)) {
717 /* Total failure; set to async and return */
718 starget_printk(KERN_ERR
, starget
, "Domain Validation Failure, dropping back to Asynchronous\n");
720 return SPI_COMPARE_FAILURE
;
722 starget_printk(KERN_ERR
, starget
, "Domain Validation detected failure, dropping back\n");
723 DV_SET(period
, period
);
731 spi_dv_device_get_echo_buffer(struct scsi_device
*sdev
, u8
*buffer
)
735 /* first off do a test unit ready. This can error out
736 * because of reservations or some other reason. If it
737 * fails, the device won't let us write to the echo buffer
738 * so just return failure */
740 const char spi_test_unit_ready
[] = {
741 TEST_UNIT_READY
, 0, 0, 0, 0, 0
744 const char spi_read_buffer_descriptor
[] = {
745 READ_BUFFER
, 0x0b, 0, 0, 0, 0, 0, 0, 4, 0
749 /* We send a set of three TURs to clear any outstanding
750 * unit attention conditions if they exist (Otherwise the
751 * buffer tests won't be happy). If the TUR still fails
752 * (reservation conflict, device not ready, etc) just
753 * skip the write tests */
755 result
= spi_execute(sdev
, spi_test_unit_ready
, DMA_NONE
,
767 result
= spi_execute(sdev
, spi_read_buffer_descriptor
,
768 DMA_FROM_DEVICE
, buffer
, 4, NULL
);
771 /* Device has no echo buffer */
774 return buffer
[3] + ((buffer
[2] & 0x1f) << 8);
778 spi_dv_device_internal(struct scsi_device
*sdev
, u8
*buffer
)
780 struct spi_internal
*i
= to_spi_internal(sdev
->host
->transportt
);
781 struct scsi_target
*starget
= sdev
->sdev_target
;
782 int len
= sdev
->inquiry_len
;
783 /* first set us up for narrow async */
787 if (spi_dv_device_compare_inquiry(sdev
, buffer
, buffer
, DV_LOOPS
)
788 != SPI_COMPARE_SUCCESS
) {
789 starget_printk(KERN_ERR
, starget
, "Domain Validation Initial Inquiry Failed\n");
790 /* FIXME: should probably offline the device here? */
795 if (i
->f
->set_width
&& spi_max_width(starget
) &&
796 scsi_device_wide(sdev
)) {
797 i
->f
->set_width(starget
, 1);
799 if (spi_dv_device_compare_inquiry(sdev
, buffer
,
802 != SPI_COMPARE_SUCCESS
) {
803 starget_printk(KERN_ERR
, starget
, "Wide Transfers Fail\n");
804 i
->f
->set_width(starget
, 0);
808 if (!i
->f
->set_period
)
811 /* device can't handle synchronous */
812 if (!scsi_device_sync(sdev
) && !scsi_device_dt(sdev
))
815 /* see if the device has an echo buffer. If it does we can
816 * do the SPI pattern write tests */
819 if (scsi_device_dt(sdev
))
820 len
= spi_dv_device_get_echo_buffer(sdev
, buffer
);
824 /* now set up to the maximum */
825 DV_SET(offset
, spi_max_offset(starget
));
826 DV_SET(period
, spi_min_period(starget
));
827 /* try QAS requests; this should be harmless to set if the
828 * target supports it */
829 if (scsi_device_qas(sdev
))
831 /* Also try IU transfers */
832 if (scsi_device_ius(sdev
))
834 if (spi_min_period(starget
) < 9) {
835 /* This u320 (or u640). Ignore the coupled parameters
836 * like DT and IU, but set the optional ones */
840 if (spi_min_period(starget
) == 8)
845 starget_printk(KERN_INFO
, starget
, "Domain Validation skipping write tests\n");
846 spi_dv_retrain(sdev
, buffer
, buffer
+ len
,
847 spi_dv_device_compare_inquiry
);
851 if (len
> SPI_MAX_ECHO_BUFFER_SIZE
) {
852 starget_printk(KERN_WARNING
, starget
, "Echo buffer size %d is too big, trimming to %d\n", len
, SPI_MAX_ECHO_BUFFER_SIZE
);
853 len
= SPI_MAX_ECHO_BUFFER_SIZE
;
856 if (spi_dv_retrain(sdev
, buffer
, buffer
+ len
,
857 spi_dv_device_echo_buffer
)
858 == SPI_COMPARE_SKIP_TEST
) {
859 /* OK, the stupid drive can't do a write echo buffer
860 * test after all, fall back to the read tests */
867 /** spi_dv_device - Do Domain Validation on the device
868 * @sdev: scsi device to validate
870 * Performs the domain validation on the given device in the
871 * current execution thread. Since DV operations may sleep,
872 * the current thread must have user context. Also no SCSI
873 * related locks that would deadlock I/O issued by the DV may
877 spi_dv_device(struct scsi_device
*sdev
)
879 struct scsi_target
*starget
= sdev
->sdev_target
;
881 const int len
= SPI_MAX_ECHO_BUFFER_SIZE
*2;
883 if (unlikely(scsi_device_get(sdev
)))
886 buffer
= kmalloc(len
, GFP_KERNEL
);
888 if (unlikely(!buffer
))
891 memset(buffer
, 0, len
);
893 /* We need to verify that the actual device will quiesce; the
894 * later target quiesce is just a nice to have */
895 if (unlikely(scsi_device_quiesce(sdev
)))
898 scsi_target_quiesce(starget
);
900 spi_dv_pending(starget
) = 1;
901 down(&spi_dv_sem(starget
));
903 starget_printk(KERN_INFO
, starget
, "Beginning Domain Validation\n");
905 spi_dv_device_internal(sdev
, buffer
);
907 starget_printk(KERN_INFO
, starget
, "Ending Domain Validation\n");
909 up(&spi_dv_sem(starget
));
910 spi_dv_pending(starget
) = 0;
912 scsi_target_resume(starget
);
914 spi_initial_dv(starget
) = 1;
919 scsi_device_put(sdev
);
921 EXPORT_SYMBOL(spi_dv_device
);
923 struct work_queue_wrapper
{
924 struct work_struct work
;
925 struct scsi_device
*sdev
;
929 spi_dv_device_work_wrapper(void *data
)
931 struct work_queue_wrapper
*wqw
= (struct work_queue_wrapper
*)data
;
932 struct scsi_device
*sdev
= wqw
->sdev
;
936 spi_dv_pending(sdev
->sdev_target
) = 0;
937 scsi_device_put(sdev
);
942 * spi_schedule_dv_device - schedule domain validation to occur on the device
943 * @sdev: The device to validate
945 * Identical to spi_dv_device() above, except that the DV will be
946 * scheduled to occur in a workqueue later. All memory allocations
947 * are atomic, so may be called from any context including those holding
951 spi_schedule_dv_device(struct scsi_device
*sdev
)
953 struct work_queue_wrapper
*wqw
=
954 kmalloc(sizeof(struct work_queue_wrapper
), GFP_ATOMIC
);
959 if (unlikely(spi_dv_pending(sdev
->sdev_target
))) {
963 /* Set pending early (dv_device doesn't check it, only sets it) */
964 spi_dv_pending(sdev
->sdev_target
) = 1;
965 if (unlikely(scsi_device_get(sdev
))) {
967 spi_dv_pending(sdev
->sdev_target
) = 0;
971 INIT_WORK(&wqw
->work
, spi_dv_device_work_wrapper
, wqw
);
974 schedule_work(&wqw
->work
);
976 EXPORT_SYMBOL(spi_schedule_dv_device
);
979 * spi_display_xfer_agreement - Print the current target transfer agreement
980 * @starget: The target for which to display the agreement
982 * Each SPI port is required to maintain a transfer agreement for each
983 * other port on the bus. This function prints a one-line summary of
984 * the current agreement; more detailed information is available in sysfs.
986 void spi_display_xfer_agreement(struct scsi_target
*starget
)
988 struct spi_transport_attrs
*tp
;
989 tp
= (struct spi_transport_attrs
*)&starget
->starget_data
;
991 if (tp
->offset
> 0 && tp
->period
> 0) {
992 unsigned int picosec
, kb100
;
993 char *scsi
= "FAST-?";
996 if (tp
->period
<= SPI_STATIC_PPR
) {
997 picosec
= ppr_to_ps
[tp
->period
];
998 switch (tp
->period
) {
999 case 7: scsi
= "FAST-320"; break;
1000 case 8: scsi
= "FAST-160"; break;
1001 case 9: scsi
= "FAST-80"; break;
1003 case 11: scsi
= "FAST-40"; break;
1004 case 12: scsi
= "FAST-20"; break;
1007 picosec
= tp
->period
* 4000;
1008 if (tp
->period
< 25)
1010 else if (tp
->period
< 50)
1016 kb100
= (10000000 + picosec
/ 2) / picosec
;
1019 sprint_frac(tmp
, picosec
, 1000);
1021 dev_info(&starget
->dev
,
1022 "%s %sSCSI %d.%d MB/s %s%s%s%s%s%s%s%s (%s ns, offset %d)\n",
1023 scsi
, tp
->width
? "WIDE " : "", kb100
/10, kb100
% 10,
1024 tp
->dt
? "DT" : "ST",
1025 tp
->iu
? " IU" : "",
1026 tp
->qas
? " QAS" : "",
1027 tp
->rd_strm
? " RDSTRM" : "",
1028 tp
->rti
? " RTI" : "",
1029 tp
->wr_flow
? " WRFLOW" : "",
1030 tp
->pcomp_en
? " PCOMP" : "",
1031 tp
->hold_mcs
? " HMCS" : "",
1034 dev_info(&starget
->dev
, "%sasynchronous.\n",
1035 tp
->width
? "wide " : "");
1038 EXPORT_SYMBOL(spi_display_xfer_agreement
);
1040 #define SETUP_ATTRIBUTE(field) \
1041 i->private_attrs[count] = class_device_attr_##field; \
1042 if (!i->f->set_##field) { \
1043 i->private_attrs[count].attr.mode = S_IRUGO; \
1044 i->private_attrs[count].store = NULL; \
1046 i->attrs[count] = &i->private_attrs[count]; \
1047 if (i->f->show_##field) \
1050 #define SETUP_RELATED_ATTRIBUTE(field, rel_field) \
1051 i->private_attrs[count] = class_device_attr_##field; \
1052 if (!i->f->set_##rel_field) { \
1053 i->private_attrs[count].attr.mode = S_IRUGO; \
1054 i->private_attrs[count].store = NULL; \
1056 i->attrs[count] = &i->private_attrs[count]; \
1057 if (i->f->show_##rel_field) \
1060 #define SETUP_HOST_ATTRIBUTE(field) \
1061 i->private_host_attrs[count] = class_device_attr_##field; \
1062 if (!i->f->set_##field) { \
1063 i->private_host_attrs[count].attr.mode = S_IRUGO; \
1064 i->private_host_attrs[count].store = NULL; \
1066 i->host_attrs[count] = &i->private_host_attrs[count]; \
1069 static int spi_device_match(struct attribute_container
*cont
,
1072 struct scsi_device
*sdev
;
1073 struct Scsi_Host
*shost
;
1074 struct spi_internal
*i
;
1076 if (!scsi_is_sdev_device(dev
))
1079 sdev
= to_scsi_device(dev
);
1081 if (!shost
->transportt
|| shost
->transportt
->host_attrs
.ac
.class
1082 != &spi_host_class
.class)
1084 /* Note: this class has no device attributes, so it has
1085 * no per-HBA allocation and thus we don't need to distinguish
1086 * the attribute containers for the device */
1087 i
= to_spi_internal(shost
->transportt
);
1088 if (i
->f
->deny_binding
&& i
->f
->deny_binding(sdev
->sdev_target
))
1093 static int spi_target_match(struct attribute_container
*cont
,
1096 struct Scsi_Host
*shost
;
1097 struct scsi_target
*starget
;
1098 struct spi_internal
*i
;
1100 if (!scsi_is_target_device(dev
))
1103 shost
= dev_to_shost(dev
->parent
);
1104 if (!shost
->transportt
|| shost
->transportt
->host_attrs
.ac
.class
1105 != &spi_host_class
.class)
1108 i
= to_spi_internal(shost
->transportt
);
1109 starget
= to_scsi_target(dev
);
1111 if (i
->f
->deny_binding
&& i
->f
->deny_binding(starget
))
1114 return &i
->t
.target_attrs
.ac
== cont
;
1117 static DECLARE_TRANSPORT_CLASS(spi_transport_class
,
1119 spi_setup_transport_attrs
,
1123 static DECLARE_ANON_TRANSPORT_CLASS(spi_device_class
,
1125 spi_device_configure
);
1127 struct scsi_transport_template
*
1128 spi_attach_transport(struct spi_function_template
*ft
)
1130 struct spi_internal
*i
= kmalloc(sizeof(struct spi_internal
),
1136 memset(i
, 0, sizeof(struct spi_internal
));
1139 i
->t
.target_attrs
.ac
.class = &spi_transport_class
.class;
1140 i
->t
.target_attrs
.ac
.attrs
= &i
->attrs
[0];
1141 i
->t
.target_attrs
.ac
.match
= spi_target_match
;
1142 transport_container_register(&i
->t
.target_attrs
);
1143 i
->t
.target_size
= sizeof(struct spi_transport_attrs
);
1144 i
->t
.host_attrs
.ac
.class = &spi_host_class
.class;
1145 i
->t
.host_attrs
.ac
.attrs
= &i
->host_attrs
[0];
1146 i
->t
.host_attrs
.ac
.match
= spi_host_match
;
1147 transport_container_register(&i
->t
.host_attrs
);
1148 i
->t
.host_size
= sizeof(struct spi_host_attrs
);
1151 SETUP_ATTRIBUTE(period
);
1152 SETUP_RELATED_ATTRIBUTE(min_period
, period
);
1153 SETUP_ATTRIBUTE(offset
);
1154 SETUP_RELATED_ATTRIBUTE(max_offset
, offset
);
1155 SETUP_ATTRIBUTE(width
);
1156 SETUP_RELATED_ATTRIBUTE(max_width
, width
);
1157 SETUP_ATTRIBUTE(iu
);
1158 SETUP_ATTRIBUTE(dt
);
1159 SETUP_ATTRIBUTE(qas
);
1160 SETUP_ATTRIBUTE(wr_flow
);
1161 SETUP_ATTRIBUTE(rd_strm
);
1162 SETUP_ATTRIBUTE(rti
);
1163 SETUP_ATTRIBUTE(pcomp_en
);
1164 SETUP_ATTRIBUTE(hold_mcs
);
1166 /* if you add an attribute but forget to increase SPI_NUM_ATTRS
1167 * this bug will trigger */
1168 BUG_ON(count
> SPI_NUM_ATTRS
);
1170 i
->attrs
[count
++] = &class_device_attr_revalidate
;
1172 i
->attrs
[count
] = NULL
;
1175 SETUP_HOST_ATTRIBUTE(signalling
);
1177 BUG_ON(count
> SPI_HOST_ATTRS
);
1179 i
->host_attrs
[count
] = NULL
;
1183 EXPORT_SYMBOL(spi_attach_transport
);
1185 void spi_release_transport(struct scsi_transport_template
*t
)
1187 struct spi_internal
*i
= to_spi_internal(t
);
1189 transport_container_unregister(&i
->t
.target_attrs
);
1190 transport_container_unregister(&i
->t
.host_attrs
);
1194 EXPORT_SYMBOL(spi_release_transport
);
1196 static __init
int spi_transport_init(void)
1198 int error
= transport_class_register(&spi_transport_class
);
1201 error
= anon_transport_class_register(&spi_device_class
);
1202 return transport_class_register(&spi_host_class
);
1205 static void __exit
spi_transport_exit(void)
1207 transport_class_unregister(&spi_transport_class
);
1208 anon_transport_class_unregister(&spi_device_class
);
1209 transport_class_unregister(&spi_host_class
);
1212 MODULE_AUTHOR("Martin Hicks");
1213 MODULE_DESCRIPTION("SPI Transport Attributes");
1214 MODULE_LICENSE("GPL");
1216 module_init(spi_transport_init
);
1217 module_exit(spi_transport_exit
);