?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[TG3]: Add tagged status support.
[linux-2.6/verdex.git] / drivers / scsi / scsi_transport_spi.c
blob28966d05435cf6506c214ab56b8b92050ab85c81
1 /*
2 * Parallel SCSI (SPI) transport specific attributes exported to sysfs.
3 *
4 * Copyright (c) 2003 Silicon Graphics, Inc. All rights reserved.
5 * Copyright (c) 2004, 2005 James Bottomley <James.Bottomley@SteelEye.com>
6 *
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.
11 *
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.
16 *
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
20 */
21 #include <linux/ctype.h>
22 #include <linux/init.h>
23 #include <linux/module.h>
24 #include <linux/workqueue.h>
25 #include <linux/blkdev.h>
26 #include <asm/semaphore.h>
27 #include <scsi/scsi.h>
28 #include "scsi_priv.h"
29 #include <scsi/scsi_device.h>
30 #include <scsi/scsi_host.h>
31 #include <scsi/scsi_request.h>
32 #include <scsi/scsi_eh.h>
33 #include <scsi/scsi_transport.h>
34 #include <scsi/scsi_transport_spi.h>
35
36 #define SPI_PRINTK(x, l, f, a...) dev_printk(l, &(x)->dev, f , ##a)
37
38 #define SPI_NUM_ATTRS 10 /* increase this if you add attributes */
39 #define SPI_OTHER_ATTRS 1 /* Increase this if you add "always
40 * on" attributes */
41 #define SPI_HOST_ATTRS 1
42
43 #define SPI_MAX_ECHO_BUFFER_SIZE 4096
44
45 #define DV_LOOPS 3
46 #define DV_TIMEOUT (10*HZ)
47 #define DV_RETRIES 3 /* should only need at most
48 * two cc/ua clears */
49
50 /* Private data accessors (keep these out of the header file) */
51 #define spi_dv_pending(x) (((struct spi_transport_attrs *)&(x)->starget_data)->dv_pending)
52 #define spi_dv_sem(x) (((struct spi_transport_attrs *)&(x)->starget_data)->dv_sem)
53
54 struct spi_internal {
55 struct scsi_transport_template t;
56 struct spi_function_template *f;
57 /* The actual attributes */
58 struct class_device_attribute private_attrs[SPI_NUM_ATTRS];
59 /* The array of null terminated pointers to attributes
60 * needed by scsi_sysfs.c */
61 struct class_device_attribute *attrs[SPI_NUM_ATTRS + SPI_OTHER_ATTRS + 1];
62 struct class_device_attribute private_host_attrs[SPI_HOST_ATTRS];
63 struct class_device_attribute *host_attrs[SPI_HOST_ATTRS + 1];
64 };
65
66 #define to_spi_internal(tmpl) container_of(tmpl, struct spi_internal, t)
67
68 static const int ppr_to_ps[] = {
69 /* The PPR values 0-6 are reserved, fill them in when
70 * the committee defines them */
71 -1, /* 0x00 */
72 -1, /* 0x01 */
73 -1, /* 0x02 */
74 -1, /* 0x03 */
75 -1, /* 0x04 */
76 -1, /* 0x05 */
77 -1, /* 0x06 */
78 3125, /* 0x07 */
79 6250, /* 0x08 */
80 12500, /* 0x09 */
81 25000, /* 0x0a */
82 30300, /* 0x0b */
83 50000, /* 0x0c */
84 };
85 /* The PPR values at which you calculate the period in ns by multiplying
86 * by 4 */
87 #define SPI_STATIC_PPR 0x0c
88
89 static int sprint_frac(char *dest, int value, int denom)
90 {
91 int frac = value % denom;
92 int result = sprintf(dest, "%d", value / denom);
93
94 if (frac == 0)
95 return result;
96 dest[result++] = '.';
97
98 do {
99 denom /= 10;
100 sprintf(dest + result, "%d", frac / denom);
101 result++;
102 frac %= denom;
103 } while (frac);
104
105 dest[result++] = '\0';
106 return result;
107 }
108
109 /* Modification of scsi_wait_req that will clear UNIT ATTENTION conditions
110 * resulting from (likely) bus and device resets */
111 static void spi_wait_req(struct scsi_request *sreq, const void *cmd,
112 void *buffer, unsigned bufflen)
113 {
114 int i;
115
116 for(i = 0; i < DV_RETRIES; i++) {
117 sreq->sr_request->flags |= REQ_FAILFAST;
118
119 scsi_wait_req(sreq, cmd, buffer, bufflen,
120 DV_TIMEOUT, /* retries */ 1);
121 if (sreq->sr_result & DRIVER_SENSE) {
122 struct scsi_sense_hdr sshdr;
123
124 if (scsi_request_normalize_sense(sreq, &sshdr)
125 && sshdr.sense_key == UNIT_ATTENTION)
126 continue;
127 }
128 break;
129 }
130 }
131
132 static struct {
133 enum spi_signal_type value;
134 char *name;
135 } signal_types[] = {
136 { SPI_SIGNAL_UNKNOWN, "unknown" },
137 { SPI_SIGNAL_SE, "SE" },
138 { SPI_SIGNAL_LVD, "LVD" },
139 { SPI_SIGNAL_HVD, "HVD" },
140 };
141
142 static inline const char *spi_signal_to_string(enum spi_signal_type type)
143 {
144 int i;
145
146 for (i = 0; i < sizeof(signal_types)/sizeof(signal_types[0]); i++) {
147 if (type == signal_types[i].value)
148 return signal_types[i].name;
149 }
150 return NULL;
151 }
152 static inline enum spi_signal_type spi_signal_to_value(const char *name)
153 {
154 int i, len;
155
156 for (i = 0; i < sizeof(signal_types)/sizeof(signal_types[0]); i++) {
157 len = strlen(signal_types[i].name);
158 if (strncmp(name, signal_types[i].name, len) == 0 &&
159 (name[len] == '\n' || name[len] == '\0'))
160 return signal_types[i].value;
161 }
162 return SPI_SIGNAL_UNKNOWN;
163 }
164
165 static int spi_host_setup(struct device *dev)
166 {
167 struct Scsi_Host *shost = dev_to_shost(dev);
168
169 spi_signalling(shost) = SPI_SIGNAL_UNKNOWN;
170
171 return 0;
172 }
173
174 static DECLARE_TRANSPORT_CLASS(spi_host_class,
175 "spi_host",
176 spi_host_setup,
177 NULL,
178 NULL);
179
180 static int spi_host_match(struct attribute_container *cont,
181 struct device *dev)
182 {
183 struct Scsi_Host *shost;
184 struct spi_internal *i;
185
186 if (!scsi_is_host_device(dev))
187 return 0;
188
189 shost = dev_to_shost(dev);
190 if (!shost->transportt || shost->transportt->host_attrs.ac.class
191 != &spi_host_class.class)
192 return 0;
193
194 i = to_spi_internal(shost->transportt);
195
196 return &i->t.host_attrs.ac == cont;
197 }
198
199 static int spi_device_configure(struct device *dev)
200 {
201 struct scsi_device *sdev = to_scsi_device(dev);
202 struct scsi_target *starget = sdev->sdev_target;
203
204 /* Populate the target capability fields with the values
205 * gleaned from the device inquiry */
206
207 spi_support_sync(starget) = scsi_device_sync(sdev);
208 spi_support_wide(starget) = scsi_device_wide(sdev);
209 spi_support_dt(starget) = scsi_device_dt(sdev);
210 spi_support_dt_only(starget) = scsi_device_dt_only(sdev);
211 spi_support_ius(starget) = scsi_device_ius(sdev);
212 spi_support_qas(starget) = scsi_device_qas(sdev);
213
214 return 0;
215 }
216
217 static int spi_setup_transport_attrs(struct device *dev)
218 {
219 struct scsi_target *starget = to_scsi_target(dev);
220
221 spi_period(starget) = -1; /* illegal value */
222 spi_offset(starget) = 0; /* async */
223 spi_width(starget) = 0; /* narrow */
224 spi_iu(starget) = 0; /* no IU */
225 spi_dt(starget) = 0; /* ST */
226 spi_qas(starget) = 0;
227 spi_wr_flow(starget) = 0;
228 spi_rd_strm(starget) = 0;
229 spi_rti(starget) = 0;
230 spi_pcomp_en(starget) = 0;
231 spi_dv_pending(starget) = 0;
232 spi_initial_dv(starget) = 0;
233 init_MUTEX(&spi_dv_sem(starget));
234
235 return 0;
236 }
237
238 #define spi_transport_show_function(field, format_string) \
239 \
240 static ssize_t \
241 show_spi_transport_##field(struct class_device *cdev, char *buf) \
242 { \
243 struct scsi_target *starget = transport_class_to_starget(cdev); \
244 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); \
245 struct spi_transport_attrs *tp; \
246 struct spi_internal *i = to_spi_internal(shost->transportt); \
247 tp = (struct spi_transport_attrs *)&starget->starget_data; \
248 if (i->f->get_##field) \
249 i->f->get_##field(starget); \
250 return snprintf(buf, 20, format_string, tp->field); \
251 }
252
253 #define spi_transport_store_function(field, format_string) \
254 static ssize_t \
255 store_spi_transport_##field(struct class_device *cdev, const char *buf, \
256 size_t count) \
257 { \
258 int val; \
259 struct scsi_target *starget = transport_class_to_starget(cdev); \
260 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); \
261 struct spi_internal *i = to_spi_internal(shost->transportt); \
262 \
263 val = simple_strtoul(buf, NULL, 0); \
264 i->f->set_##field(starget, val); \
265 return count; \
266 }
267
268 #define spi_transport_rd_attr(field, format_string) \
269 spi_transport_show_function(field, format_string) \
270 spi_transport_store_function(field, format_string) \
271 static CLASS_DEVICE_ATTR(field, S_IRUGO | S_IWUSR, \
272 show_spi_transport_##field, \
273 store_spi_transport_##field);
274
275 /* The Parallel SCSI Tranport Attributes: */
276 spi_transport_rd_attr(offset, "%d\n");
277 spi_transport_rd_attr(width, "%d\n");
278 spi_transport_rd_attr(iu, "%d\n");
279 spi_transport_rd_attr(dt, "%d\n");
280 spi_transport_rd_attr(qas, "%d\n");
281 spi_transport_rd_attr(wr_flow, "%d\n");
282 spi_transport_rd_attr(rd_strm, "%d\n");
283 spi_transport_rd_attr(rti, "%d\n");
284 spi_transport_rd_attr(pcomp_en, "%d\n");
285
286 static ssize_t
287 store_spi_revalidate(struct class_device *cdev, const char *buf, size_t count)
288 {
289 struct scsi_target *starget = transport_class_to_starget(cdev);
290
291 /* FIXME: we're relying on an awful lot of device internals
292 * here. We really need a function to get the first available
293 * child */
294 struct device *dev = container_of(starget->dev.children.next, struct device, node);
295 struct scsi_device *sdev = to_scsi_device(dev);
296 spi_dv_device(sdev);
297 return count;
298 }
299 static CLASS_DEVICE_ATTR(revalidate, S_IWUSR, NULL, store_spi_revalidate);
300
301 /* Translate the period into ns according to the current spec
302 * for SDTR/PPR messages */
303 static ssize_t show_spi_transport_period(struct class_device *cdev, char *buf)
304
305 {
306 struct scsi_target *starget = transport_class_to_starget(cdev);
307 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
308 struct spi_transport_attrs *tp;
309 int len, picosec;
310 struct spi_internal *i = to_spi_internal(shost->transportt);
311
312 tp = (struct spi_transport_attrs *)&starget->starget_data;
313
314 if (i->f->get_period)
315 i->f->get_period(starget);
316
317 if (tp->period < 0 || tp->period > 0xff) {
318 picosec = -1;
319 } else if (tp->period <= SPI_STATIC_PPR) {
320 picosec = ppr_to_ps[tp->period];
321 } else {
322 picosec = tp->period * 4000;
323 }
324
325 if (picosec == -1) {
326 len = sprintf(buf, "reserved");
327 } else {
328 len = sprint_frac(buf, picosec, 1000);
329 }
330
331 buf[len++] = '\n';
332 buf[len] = '\0';
333 return len;
334 }
335
336 static ssize_t
337 store_spi_transport_period(struct class_device *cdev, const char *buf,
338 size_t count)
339 {
340 struct scsi_target *starget = transport_class_to_starget(cdev);
341 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
342 struct spi_internal *i = to_spi_internal(shost->transportt);
343 int j, picosec, period = -1;
344 char *endp;
345
346 picosec = simple_strtoul(buf, &endp, 10) * 1000;
347 if (*endp == '.') {
348 int mult = 100;
349 do {
350 endp++;
351 if (!isdigit(*endp))
352 break;
353 picosec += (*endp - '0') * mult;
354 mult /= 10;
355 } while (mult > 0);
356 }
357
358 for (j = 0; j <= SPI_STATIC_PPR; j++) {
359 if (ppr_to_ps[j] < picosec)
360 continue;
361 period = j;
362 break;
363 }
364
365 if (period == -1)
366 period = picosec / 4000;
367
368 if (period > 0xff)
369 period = 0xff;
370
371 i->f->set_period(starget, period);
372
373 return count;
374 }
375
376 static CLASS_DEVICE_ATTR(period, S_IRUGO | S_IWUSR,
377 show_spi_transport_period,
378 store_spi_transport_period);
379
380 static ssize_t show_spi_host_signalling(struct class_device *cdev, char *buf)
381 {
382 struct Scsi_Host *shost = transport_class_to_shost(cdev);
383 struct spi_internal *i = to_spi_internal(shost->transportt);
384
385 if (i->f->get_signalling)
386 i->f->get_signalling(shost);
387
388 return sprintf(buf, "%s\n", spi_signal_to_string(spi_signalling(shost)));
389 }
390 static ssize_t store_spi_host_signalling(struct class_device *cdev,
391 const char *buf, size_t count)
392 {
393 struct Scsi_Host *shost = transport_class_to_shost(cdev);
394 struct spi_internal *i = to_spi_internal(shost->transportt);
395 enum spi_signal_type type = spi_signal_to_value(buf);
396
397 if (type != SPI_SIGNAL_UNKNOWN)
398 i->f->set_signalling(shost, type);
399
400 return count;
401 }
402 static CLASS_DEVICE_ATTR(signalling, S_IRUGO | S_IWUSR,
403 show_spi_host_signalling,
404 store_spi_host_signalling);
405
406 #define DV_SET(x, y) \
407 if(i->f->set_##x) \
408 i->f->set_##x(sdev->sdev_target, y)
409
410 enum spi_compare_returns {
411 SPI_COMPARE_SUCCESS,
412 SPI_COMPARE_FAILURE,
413 SPI_COMPARE_SKIP_TEST,
414 };
415
416
417 /* This is for read/write Domain Validation: If the device supports
418 * an echo buffer, we do read/write tests to it */
419 static enum spi_compare_returns
420 spi_dv_device_echo_buffer(struct scsi_request *sreq, u8 *buffer,
421 u8 *ptr, const int retries)
422 {
423 struct scsi_device *sdev = sreq->sr_device;
424 int len = ptr - buffer;
425 int j, k, r;
426 unsigned int pattern = 0x0000ffff;
427
428 const char spi_write_buffer[] = {
429 WRITE_BUFFER, 0x0a, 0, 0, 0, 0, 0, len >> 8, len & 0xff, 0
430 };
431 const char spi_read_buffer[] = {
432 READ_BUFFER, 0x0a, 0, 0, 0, 0, 0, len >> 8, len & 0xff, 0
433 };
434
435 /* set up the pattern buffer. Doesn't matter if we spill
436 * slightly beyond since that's where the read buffer is */
437 for (j = 0; j < len; ) {
438
439 /* fill the buffer with counting (test a) */
440 for ( ; j < min(len, 32); j++)
441 buffer[j] = j;
442 k = j;
443 /* fill the buffer with alternating words of 0x0 and
444 * 0xffff (test b) */
445 for ( ; j < min(len, k + 32); j += 2) {
446 u16 *word = (u16 *)&buffer[j];
447
448 *word = (j & 0x02) ? 0x0000 : 0xffff;
449 }
450 k = j;
451 /* fill with crosstalk (alternating 0x5555 0xaaa)
452 * (test c) */
453 for ( ; j < min(len, k + 32); j += 2) {
454 u16 *word = (u16 *)&buffer[j];
455
456 *word = (j & 0x02) ? 0x5555 : 0xaaaa;
457 }
458 k = j;
459 /* fill with shifting bits (test d) */
460 for ( ; j < min(len, k + 32); j += 4) {
461 u32 *word = (unsigned int *)&buffer[j];
462 u32 roll = (pattern & 0x80000000) ? 1 : 0;
463
464 *word = pattern;
465 pattern = (pattern << 1) | roll;
466 }
467 /* don't bother with random data (test e) */
468 }
469
470 for (r = 0; r < retries; r++) {
471 sreq->sr_cmd_len = 0; /* wait_req to fill in */
472 sreq->sr_data_direction = DMA_TO_DEVICE;
473 spi_wait_req(sreq, spi_write_buffer, buffer, len);
474 if(sreq->sr_result || !scsi_device_online(sdev)) {
475 struct scsi_sense_hdr sshdr;
476
477 scsi_device_set_state(sdev, SDEV_QUIESCE);
478 if (scsi_request_normalize_sense(sreq, &sshdr)
479 && sshdr.sense_key == ILLEGAL_REQUEST
480 /* INVALID FIELD IN CDB */
481 && sshdr.asc == 0x24 && sshdr.ascq == 0x00)
482 /* This would mean that the drive lied
483 * to us about supporting an echo
484 * buffer (unfortunately some Western
485 * Digital drives do precisely this)
486 */
487 return SPI_COMPARE_SKIP_TEST;
488
489
490 SPI_PRINTK(sdev->sdev_target, KERN_ERR, "Write Buffer failure %x\n", sreq->sr_result);
491 return SPI_COMPARE_FAILURE;
492 }
493
494 memset(ptr, 0, len);
495 sreq->sr_cmd_len = 0; /* wait_req to fill in */
496 sreq->sr_data_direction = DMA_FROM_DEVICE;
497 spi_wait_req(sreq, spi_read_buffer, ptr, len);
498 scsi_device_set_state(sdev, SDEV_QUIESCE);
499
500 if (memcmp(buffer, ptr, len) != 0)
501 return SPI_COMPARE_FAILURE;
502 }
503 return SPI_COMPARE_SUCCESS;
504 }
505
506 /* This is for the simplest form of Domain Validation: a read test
507 * on the inquiry data from the device */
508 static enum spi_compare_returns
509 spi_dv_device_compare_inquiry(struct scsi_request *sreq, u8 *buffer,
510 u8 *ptr, const int retries)
511 {
512 int r;
513 const int len = sreq->sr_device->inquiry_len;
514 struct scsi_device *sdev = sreq->sr_device;
515 const char spi_inquiry[] = {
516 INQUIRY, 0, 0, 0, len, 0
517 };
518
519 for (r = 0; r < retries; r++) {
520 sreq->sr_cmd_len = 0; /* wait_req to fill in */
521 sreq->sr_data_direction = DMA_FROM_DEVICE;
522
523 memset(ptr, 0, len);
524
525 spi_wait_req(sreq, spi_inquiry, ptr, len);
526
527 if(sreq->sr_result || !scsi_device_online(sdev)) {
528 scsi_device_set_state(sdev, SDEV_QUIESCE);
529 return SPI_COMPARE_FAILURE;
530 }
531
532 /* If we don't have the inquiry data already, the
533 * first read gets it */
534 if (ptr == buffer) {
535 ptr += len;
536 --r;
537 continue;
538 }
539
540 if (memcmp(buffer, ptr, len) != 0)
541 /* failure */
542 return SPI_COMPARE_FAILURE;
543 }
544 return SPI_COMPARE_SUCCESS;
545 }
546
547 static enum spi_compare_returns
548 spi_dv_retrain(struct scsi_request *sreq, u8 *buffer, u8 *ptr,
549 enum spi_compare_returns
550 (*compare_fn)(struct scsi_request *, u8 *, u8 *, int))
551 {
552 struct spi_internal *i = to_spi_internal(sreq->sr_host->transportt);
553 struct scsi_device *sdev = sreq->sr_device;
554 int period = 0, prevperiod = 0;
555 enum spi_compare_returns retval;
556
557
558 for (;;) {
559 int newperiod;
560 retval = compare_fn(sreq, buffer, ptr, DV_LOOPS);
561
562 if (retval == SPI_COMPARE_SUCCESS
563 || retval == SPI_COMPARE_SKIP_TEST)
564 break;
565
566 /* OK, retrain, fallback */
567 if (i->f->get_period)
568 i->f->get_period(sdev->sdev_target);
569 newperiod = spi_period(sdev->sdev_target);
570 period = newperiod > period ? newperiod : period;
571 if (period < 0x0d)
572 period++;
573 else
574 period += period >> 1;
575
576 if (unlikely(period > 0xff || period == prevperiod)) {
577 /* Total failure; set to async and return */
578 SPI_PRINTK(sdev->sdev_target, KERN_ERR, "Domain Validation Failure, dropping back to Asynchronous\n");
579 DV_SET(offset, 0);
580 return SPI_COMPARE_FAILURE;
581 }
582 SPI_PRINTK(sdev->sdev_target, KERN_ERR, "Domain Validation detected failure, dropping back\n");
583 DV_SET(period, period);
584 prevperiod = period;
585 }
586 return retval;
587 }
588
589 static int
590 spi_dv_device_get_echo_buffer(struct scsi_request *sreq, u8 *buffer)
591 {
592 int l;
593
594 /* first off do a test unit ready. This can error out
595 * because of reservations or some other reason. If it
596 * fails, the device won't let us write to the echo buffer
597 * so just return failure */
598
599 const char spi_test_unit_ready[] = {
600 TEST_UNIT_READY, 0, 0, 0, 0, 0
601 };
602
603 const char spi_read_buffer_descriptor[] = {
604 READ_BUFFER, 0x0b, 0, 0, 0, 0, 0, 0, 4, 0
605 };
606
607
608 sreq->sr_cmd_len = 0;
609 sreq->sr_data_direction = DMA_NONE;
610
611 /* We send a set of three TURs to clear any outstanding
612 * unit attention conditions if they exist (Otherwise the
613 * buffer tests won't be happy). If the TUR still fails
614 * (reservation conflict, device not ready, etc) just
615 * skip the write tests */
616 for (l = 0; ; l++) {
617 spi_wait_req(sreq, spi_test_unit_ready, NULL, 0);
618
619 if(sreq->sr_result) {
620 if(l >= 3)
621 return 0;
622 } else {
623 /* TUR succeeded */
624 break;
625 }
626 }
627
628 sreq->sr_cmd_len = 0;
629 sreq->sr_data_direction = DMA_FROM_DEVICE;
630
631 spi_wait_req(sreq, spi_read_buffer_descriptor, buffer, 4);
632
633 if (sreq->sr_result)
634 /* Device has no echo buffer */
635 return 0;
636
637 return buffer[3] + ((buffer[2] & 0x1f) << 8);
638 }
639
640 static void
641 spi_dv_device_internal(struct scsi_request *sreq, u8 *buffer)
642 {
643 struct spi_internal *i = to_spi_internal(sreq->sr_host->transportt);
644 struct scsi_device *sdev = sreq->sr_device;
645 int len = sdev->inquiry_len;
646 /* first set us up for narrow async */
647 DV_SET(offset, 0);
648 DV_SET(width, 0);
649
650 if (spi_dv_device_compare_inquiry(sreq, buffer, buffer, DV_LOOPS)
651 != SPI_COMPARE_SUCCESS) {
652 SPI_PRINTK(sdev->sdev_target, KERN_ERR, "Domain Validation Initial Inquiry Failed\n");
653 /* FIXME: should probably offline the device here? */
654 return;
655 }
656
657 /* test width */
658 if (i->f->set_width && sdev->wdtr) {
659 i->f->set_width(sdev->sdev_target, 1);
660
661 if (spi_dv_device_compare_inquiry(sreq, buffer,
662 buffer + len,
663 DV_LOOPS)
664 != SPI_COMPARE_SUCCESS) {
665 SPI_PRINTK(sdev->sdev_target, KERN_ERR, "Wide Transfers Fail\n");
666 i->f->set_width(sdev->sdev_target, 0);
667 }
668 }
669
670 if (!i->f->set_period)
671 return;
672
673 /* device can't handle synchronous */
674 if(!sdev->ppr && !sdev->sdtr)
675 return;
676
677 /* see if the device has an echo buffer. If it does we can
678 * do the SPI pattern write tests */
679
680 len = 0;
681 if (sdev->ppr)
682 len = spi_dv_device_get_echo_buffer(sreq, buffer);
683
684 retry:
685
686 /* now set up to the maximum */
687 DV_SET(offset, 255);
688 DV_SET(period, 1);
689
690 if (len == 0) {
691 SPI_PRINTK(sdev->sdev_target, KERN_INFO, "Domain Validation skipping write tests\n");
692 spi_dv_retrain(sreq, buffer, buffer + len,
693 spi_dv_device_compare_inquiry);
694 return;
695 }
696
697 if (len > SPI_MAX_ECHO_BUFFER_SIZE) {
698 SPI_PRINTK(sdev->sdev_target, KERN_WARNING, "Echo buffer size %d is too big, trimming to %d\n", len, SPI_MAX_ECHO_BUFFER_SIZE);
699 len = SPI_MAX_ECHO_BUFFER_SIZE;
700 }
701
702 if (spi_dv_retrain(sreq, buffer, buffer + len,
703 spi_dv_device_echo_buffer)
704 == SPI_COMPARE_SKIP_TEST) {
705 /* OK, the stupid drive can't do a write echo buffer
706 * test after all, fall back to the read tests */
707 len = 0;
708 goto retry;
709 }
710 }
711
712
713 /** spi_dv_device - Do Domain Validation on the device
714 * @sdev: scsi device to validate
715 *
716 * Performs the domain validation on the given device in the
717 * current execution thread. Since DV operations may sleep,
718 * the current thread must have user context. Also no SCSI
719 * related locks that would deadlock I/O issued by the DV may
720 * be held.
721 */
722 void
723 spi_dv_device(struct scsi_device *sdev)
724 {
725 struct scsi_request *sreq = scsi_allocate_request(sdev, GFP_KERNEL);
726 struct scsi_target *starget = sdev->sdev_target;
727 u8 *buffer;
728 const int len = SPI_MAX_ECHO_BUFFER_SIZE*2;
729
730 if (unlikely(!sreq))
731 return;
732
733 if (unlikely(scsi_device_get(sdev)))
734 goto out_free_req;
735
736 buffer = kmalloc(len, GFP_KERNEL);
737
738 if (unlikely(!buffer))
739 goto out_put;
740
741 memset(buffer, 0, len);
742
743 /* We need to verify that the actual device will quiesce; the
744 * later target quiesce is just a nice to have */
745 if (unlikely(scsi_device_quiesce(sdev)))
746 goto out_free;
747
748 scsi_target_quiesce(starget);
749
750 spi_dv_pending(starget) = 1;
751 down(&spi_dv_sem(starget));
752
753 SPI_PRINTK(starget, KERN_INFO, "Beginning Domain Validation\n");
754
755 spi_dv_device_internal(sreq, buffer);
756
757 SPI_PRINTK(starget, KERN_INFO, "Ending Domain Validation\n");
758
759 up(&spi_dv_sem(starget));
760 spi_dv_pending(starget) = 0;
761
762 scsi_target_resume(starget);
763
764 spi_initial_dv(starget) = 1;
765
766 out_free:
767 kfree(buffer);
768 out_put:
769 scsi_device_put(sdev);
770 out_free_req:
771 scsi_release_request(sreq);
772 }
773 EXPORT_SYMBOL(spi_dv_device);
774
775 struct work_queue_wrapper {
776 struct work_struct work;
777 struct scsi_device *sdev;
778 };
779
780 static void
781 spi_dv_device_work_wrapper(void *data)
782 {
783 struct work_queue_wrapper *wqw = (struct work_queue_wrapper *)data;
784 struct scsi_device *sdev = wqw->sdev;
785
786 kfree(wqw);
787 spi_dv_device(sdev);
788 spi_dv_pending(sdev->sdev_target) = 0;
789 scsi_device_put(sdev);
790 }
791
792
793 /**
794 * spi_schedule_dv_device - schedule domain validation to occur on the device
795 * @sdev: The device to validate
796 *
797 * Identical to spi_dv_device() above, except that the DV will be
798 * scheduled to occur in a workqueue later. All memory allocations
799 * are atomic, so may be called from any context including those holding
800 * SCSI locks.
801 */
802 void
803 spi_schedule_dv_device(struct scsi_device *sdev)
804 {
805 struct work_queue_wrapper *wqw =
806 kmalloc(sizeof(struct work_queue_wrapper), GFP_ATOMIC);
807
808 if (unlikely(!wqw))
809 return;
810
811 if (unlikely(spi_dv_pending(sdev->sdev_target))) {
812 kfree(wqw);
813 return;
814 }
815 /* Set pending early (dv_device doesn't check it, only sets it) */
816 spi_dv_pending(sdev->sdev_target) = 1;
817 if (unlikely(scsi_device_get(sdev))) {
818 kfree(wqw);
819 spi_dv_pending(sdev->sdev_target) = 0;
820 return;
821 }
822
823 INIT_WORK(&wqw->work, spi_dv_device_work_wrapper, wqw);
824 wqw->sdev = sdev;
825
826 schedule_work(&wqw->work);
827 }
828 EXPORT_SYMBOL(spi_schedule_dv_device);
829
830 /**
831 * spi_display_xfer_agreement - Print the current target transfer agreement
832 * @starget: The target for which to display the agreement
833 *
834 * Each SPI port is required to maintain a transfer agreement for each
835 * other port on the bus. This function prints a one-line summary of
836 * the current agreement; more detailed information is available in sysfs.
837 */
838 void spi_display_xfer_agreement(struct scsi_target *starget)
839 {
840 struct spi_transport_attrs *tp;
841 tp = (struct spi_transport_attrs *)&starget->starget_data;
842
843 if (tp->offset > 0 && tp->period > 0) {
844 unsigned int picosec, kb100;
845 char *scsi = "FAST-?";
846 char tmp[8];
847
848 if (tp->period <= SPI_STATIC_PPR) {
849 picosec = ppr_to_ps[tp->period];
850 switch (tp->period) {
851 case 7: scsi = "FAST-320"; break;
852 case 8: scsi = "FAST-160"; break;
853 case 9: scsi = "FAST-80"; break;
854 case 10:
855 case 11: scsi = "FAST-40"; break;
856 case 12: scsi = "FAST-20"; break;
857 }
858 } else {
859 picosec = tp->period * 4000;
860 if (tp->period < 25)
861 scsi = "FAST-20";
862 else if (tp->period < 50)
863 scsi = "FAST-10";
864 else
865 scsi = "FAST-5";
866 }
867
868 kb100 = (10000000 + picosec / 2) / picosec;
869 if (tp->width)
870 kb100 *= 2;
871 sprint_frac(tmp, picosec, 1000);
872
873 dev_info(&starget->dev,
874 "%s %sSCSI %d.%d MB/s %s%s%s (%s ns, offset %d)\n",
875 scsi, tp->width ? "WIDE " : "", kb100/10, kb100 % 10,
876 tp->dt ? "DT" : "ST", tp->iu ? " IU" : "",
877 tp->qas ? " QAS" : "", tmp, tp->offset);
878 } else {
879 dev_info(&starget->dev, "%sasynchronous.\n",
880 tp->width ? "wide " : "");
881 }
882 }
883 EXPORT_SYMBOL(spi_display_xfer_agreement);
884
885 #define SETUP_ATTRIBUTE(field) \
886 i->private_attrs[count] = class_device_attr_##field; \
887 if (!i->f->set_##field) { \
888 i->private_attrs[count].attr.mode = S_IRUGO; \
889 i->private_attrs[count].store = NULL; \
890 } \
891 i->attrs[count] = &i->private_attrs[count]; \
892 if (i->f->show_##field) \
893 count++
894
895 #define SETUP_HOST_ATTRIBUTE(field) \
896 i->private_host_attrs[count] = class_device_attr_##field; \
897 if (!i->f->set_##field) { \
898 i->private_host_attrs[count].attr.mode = S_IRUGO; \
899 i->private_host_attrs[count].store = NULL; \
900 } \
901 i->host_attrs[count] = &i->private_host_attrs[count]; \
902 count++
903
904 static int spi_device_match(struct attribute_container *cont,
905 struct device *dev)
906 {
907 struct scsi_device *sdev;
908 struct Scsi_Host *shost;
909
910 if (!scsi_is_sdev_device(dev))
911 return 0;
912
913 sdev = to_scsi_device(dev);
914 shost = sdev->host;
915 if (!shost->transportt || shost->transportt->host_attrs.ac.class
916 != &spi_host_class.class)
917 return 0;
918 /* Note: this class has no device attributes, so it has
919 * no per-HBA allocation and thus we don't need to distinguish
920 * the attribute containers for the device */
921 return 1;
922 }
923
924 static int spi_target_match(struct attribute_container *cont,
925 struct device *dev)
926 {
927 struct Scsi_Host *shost;
928 struct spi_internal *i;
929
930 if (!scsi_is_target_device(dev))
931 return 0;
932
933 shost = dev_to_shost(dev->parent);
934 if (!shost->transportt || shost->transportt->host_attrs.ac.class
935 != &spi_host_class.class)
936 return 0;
937
938 i = to_spi_internal(shost->transportt);
939
940 return &i->t.target_attrs.ac == cont;
941 }
942
943 static DECLARE_TRANSPORT_CLASS(spi_transport_class,
944 "spi_transport",
945 spi_setup_transport_attrs,
946 NULL,
947 NULL);
948
949 static DECLARE_ANON_TRANSPORT_CLASS(spi_device_class,
950 spi_device_match,
951 spi_device_configure);
952
953 struct scsi_transport_template *
954 spi_attach_transport(struct spi_function_template *ft)
955 {
956 struct spi_internal *i = kmalloc(sizeof(struct spi_internal),
957 GFP_KERNEL);
958 int count = 0;
959 if (unlikely(!i))
960 return NULL;
961
962 memset(i, 0, sizeof(struct spi_internal));
963
964
965 i->t.target_attrs.ac.class = &spi_transport_class.class;
966 i->t.target_attrs.ac.attrs = &i->attrs[0];
967 i->t.target_attrs.ac.match = spi_target_match;
968 transport_container_register(&i->t.target_attrs);
969 i->t.target_size = sizeof(struct spi_transport_attrs);
970 i->t.host_attrs.ac.class = &spi_host_class.class;
971 i->t.host_attrs.ac.attrs = &i->host_attrs[0];
972 i->t.host_attrs.ac.match = spi_host_match;
973 transport_container_register(&i->t.host_attrs);
974 i->t.host_size = sizeof(struct spi_host_attrs);
975 i->f = ft;
976
977 SETUP_ATTRIBUTE(period);
978 SETUP_ATTRIBUTE(offset);
979 SETUP_ATTRIBUTE(width);
980 SETUP_ATTRIBUTE(iu);
981 SETUP_ATTRIBUTE(dt);
982 SETUP_ATTRIBUTE(qas);
983 SETUP_ATTRIBUTE(wr_flow);
984 SETUP_ATTRIBUTE(rd_strm);
985 SETUP_ATTRIBUTE(rti);
986 SETUP_ATTRIBUTE(pcomp_en);
987
988 /* if you add an attribute but forget to increase SPI_NUM_ATTRS
989 * this bug will trigger */
990 BUG_ON(count > SPI_NUM_ATTRS);
991
992 i->attrs[count++] = &class_device_attr_revalidate;
993
994 i->attrs[count] = NULL;
995
996 count = 0;
997 SETUP_HOST_ATTRIBUTE(signalling);
998
999 BUG_ON(count > SPI_HOST_ATTRS);
1000
1001 i->host_attrs[count] = NULL;
1002
1003 return &i->t;
1004 }
1005 EXPORT_SYMBOL(spi_attach_transport);
1006
1007 void spi_release_transport(struct scsi_transport_template *t)
1008 {
1009 struct spi_internal *i = to_spi_internal(t);
1010
1011 transport_container_unregister(&i->t.target_attrs);
1012 transport_container_unregister(&i->t.host_attrs);
1013
1014 kfree(i);
1015 }
1016 EXPORT_SYMBOL(spi_release_transport);
1017
1018 static __init int spi_transport_init(void)
1019 {
1020 int error = transport_class_register(&spi_transport_class);
1021 if (error)
1022 return error;
1023 error = anon_transport_class_register(&spi_device_class);
1024 return transport_class_register(&spi_host_class);
1025 }
1026
1027 static void __exit spi_transport_exit(void)
1028 {
1029 transport_class_unregister(&spi_transport_class);
1030 anon_transport_class_unregister(&spi_device_class);
1031 transport_class_unregister(&spi_host_class);
1032 }
1033
1034 MODULE_AUTHOR("Martin Hicks");
1035 MODULE_DESCRIPTION("SPI Transport Attributes");
1036 MODULE_LICENSE("GPL");
1037
1038 module_init(spi_transport_init);
1039 module_exit(spi_transport_exit);
Verdex Pro support