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 <linux/mutex.h> 27 #include <linux/sysfs.h> 28 #include <scsi/scsi.h> 29 #include "scsi_priv.h" 30 #include <scsi/scsi_device.h> 31 #include <scsi/scsi_host.h> 32 #include <scsi/scsi_cmnd.h> 33 #include <scsi/scsi_eh.h> 34 #include <scsi/scsi_transport.h> 35 #include <scsi/scsi_transport_spi.h> 36 37 #define SPI_NUM_ATTRS 14 /* increase this if you add attributes */ 38 #define SPI_OTHER_ATTRS 1 /* Increase this if you add "always 39 * on" attributes */ 40 #define SPI_HOST_ATTRS 1 41 42 #define SPI_MAX_ECHO_BUFFER_SIZE 4096 43 44 #define DV_LOOPS 3 45 #define DV_TIMEOUT (10*HZ) 46 #define DV_RETRIES 3 /* should only need at most 47 * two cc/ua clears */ 48 49 /* Private data accessors (keep these out of the header file) */ 50 #define spi_dv_in_progress(x) (((struct spi_transport_attrs *)&(x)->starget_data)->dv_in_progress) 51 #define spi_dv_mutex(x) (((struct spi_transport_attrs *)&(x)->starget_data)->dv_mutex) 52 53 struct spi_internal { 54 struct scsi_transport_template t; 55 struct spi_function_template *f; 56 }; 57 58 #define to_spi_internal(tmpl) container_of(tmpl, struct spi_internal, t) 59 60 static const int ppr_to_ps[] = { 61 /* The PPR values 0-6 are reserved, fill them in when 62 * the committee defines them */ 63 -1, /* 0x00 */ 64 -1, /* 0x01 */ 65 -1, /* 0x02 */ 66 -1, /* 0x03 */ 67 -1, /* 0x04 */ 68 -1, /* 0x05 */ 69 -1, /* 0x06 */ 70 3125, /* 0x07 */ 71 6250, /* 0x08 */ 72 12500, /* 0x09 */ 73 25000, /* 0x0a */ 74 30300, /* 0x0b */ 75 50000, /* 0x0c */ 76 }; 77 /* The PPR values at which you calculate the period in ns by multiplying 78 * by 4 */ 79 #define SPI_STATIC_PPR 0x0c 80 81 static int sprint_frac(char *dest, int value, int denom) 82 { 83 int frac = value % denom; 84 int result = sprintf(dest, "%d", value / denom); 85 86 if (frac == 0) 87 return result; 88 dest[result++] = '.'; 89 90 do { 91 denom /= 10; 92 sprintf(dest + result, "%d", frac / denom); 93 result++; 94 frac %= denom; 95 } while (frac); 96 97 dest[result++] = '\0'; 98 return result; 99 } 100 101 static int spi_execute(struct scsi_device *sdev, const void *cmd, 102 enum dma_data_direction dir, 103 void *buffer, unsigned bufflen, 104 struct scsi_sense_hdr *sshdr) 105 { 106 int i, result; 107 unsigned char sense[SCSI_SENSE_BUFFERSIZE]; 108 109 for(i = 0; i < DV_RETRIES; i++) { 110 result = scsi_execute(sdev, cmd, dir, buffer, bufflen, 111 sense, DV_TIMEOUT, /* retries */ 1, 112 REQ_FAILFAST_DEV | 113 REQ_FAILFAST_TRANSPORT | 114 REQ_FAILFAST_DRIVER); 115 if (result & DRIVER_SENSE) { 116 struct scsi_sense_hdr sshdr_tmp; 117 if (!sshdr) 118 sshdr = &sshdr_tmp; 119 120 if (scsi_normalize_sense(sense, SCSI_SENSE_BUFFERSIZE, 121 sshdr) 122 && sshdr->sense_key == UNIT_ATTENTION) 123 continue; 124 } 125 break; 126 } 127 return result; 128 } 129 130 static struct { 131 enum spi_signal_type value; 132 char *name; 133 } signal_types[] = { 134 { SPI_SIGNAL_UNKNOWN, "unknown" }, 135 { SPI_SIGNAL_SE, "SE" }, 136 { SPI_SIGNAL_LVD, "LVD" }, 137 { SPI_SIGNAL_HVD, "HVD" }, 138 }; 139 140 static inline const char *spi_signal_to_string(enum spi_signal_type type) 141 { 142 int i; 143 144 for (i = 0; i < ARRAY_SIZE(signal_types); i++) { 145 if (type == signal_types[i].value) 146 return signal_types[i].name; 147 } 148 return NULL; 149 } 150 static inline enum spi_signal_type spi_signal_to_value(const char *name) 151 { 152 int i, len; 153 154 for (i = 0; i < ARRAY_SIZE(signal_types); i++) { 155 len = strlen(signal_types[i].name); 156 if (strncmp(name, signal_types[i].name, len) == 0 && 157 (name[len] == '\n' || name[len] == '\0')) 158 return signal_types[i].value; 159 } 160 return SPI_SIGNAL_UNKNOWN; 161 } 162 163 static int spi_host_setup(struct transport_container *tc, struct device *dev, 164 struct device *cdev) 165 { 166 struct Scsi_Host *shost = dev_to_shost(dev); 167 168 spi_signalling(shost) = SPI_SIGNAL_UNKNOWN; 169 170 return 0; 171 } 172 173 static int spi_host_configure(struct transport_container *tc, 174 struct device *dev, 175 struct device *cdev); 176 177 static DECLARE_TRANSPORT_CLASS(spi_host_class, 178 "spi_host", 179 spi_host_setup, 180 NULL, 181 spi_host_configure); 182 183 static int spi_host_match(struct attribute_container *cont, 184 struct device *dev) 185 { 186 struct Scsi_Host *shost; 187 188 if (!scsi_is_host_device(dev)) 189 return 0; 190 191 shost = dev_to_shost(dev); 192 if (!shost->transportt || shost->transportt->host_attrs.ac.class 193 != &spi_host_class.class) 194 return 0; 195 196 return &shost->transportt->host_attrs.ac == cont; 197 } 198 199 static int spi_target_configure(struct transport_container *tc, 200 struct device *dev, 201 struct device *cdev); 202 203 static int spi_device_configure(struct transport_container *tc, 204 struct device *dev, 205 struct device *cdev) 206 { 207 struct scsi_device *sdev = to_scsi_device(dev); 208 struct scsi_target *starget = sdev->sdev_target; 209 210 /* Populate the target capability fields with the values 211 * gleaned from the device inquiry */ 212 213 spi_support_sync(starget) = scsi_device_sync(sdev); 214 spi_support_wide(starget) = scsi_device_wide(sdev); 215 spi_support_dt(starget) = scsi_device_dt(sdev); 216 spi_support_dt_only(starget) = scsi_device_dt_only(sdev); 217 spi_support_ius(starget) = scsi_device_ius(sdev); 218 spi_support_qas(starget) = scsi_device_qas(sdev); 219 220 return 0; 221 } 222 223 static int spi_setup_transport_attrs(struct transport_container *tc, 224 struct device *dev, 225 struct device *cdev) 226 { 227 struct scsi_target *starget = to_scsi_target(dev); 228 229 spi_period(starget) = -1; /* illegal value */ 230 spi_min_period(starget) = 0; 231 spi_offset(starget) = 0; /* async */ 232 spi_max_offset(starget) = 255; 233 spi_width(starget) = 0; /* narrow */ 234 spi_max_width(starget) = 1; 235 spi_iu(starget) = 0; /* no IU */ 236 spi_dt(starget) = 0; /* ST */ 237 spi_qas(starget) = 0; 238 spi_wr_flow(starget) = 0; 239 spi_rd_strm(starget) = 0; 240 spi_rti(starget) = 0; 241 spi_pcomp_en(starget) = 0; 242 spi_hold_mcs(starget) = 0; 243 spi_dv_pending(starget) = 0; 244 spi_dv_in_progress(starget) = 0; 245 spi_initial_dv(starget) = 0; 246 mutex_init(&spi_dv_mutex(starget)); 247 248 return 0; 249 } 250 251 #define spi_transport_show_simple(field, format_string) \ 252 \ 253 static ssize_t \ 254 show_spi_transport_##field(struct device *dev, \ 255 struct device_attribute *attr, char *buf) \ 256 { \ 257 struct scsi_target *starget = transport_class_to_starget(dev); \ 258 struct spi_transport_attrs *tp; \ 259 \ 260 tp = (struct spi_transport_attrs *)&starget->starget_data; \ 261 return snprintf(buf, 20, format_string, tp->field); \ 262 } 263 264 #define spi_transport_store_simple(field, format_string) \ 265 \ 266 static ssize_t \ 267 store_spi_transport_##field(struct device *dev, \ 268 struct device_attribute *attr, \ 269 const char *buf, size_t count) \ 270 { \ 271 int val; \ 272 struct scsi_target *starget = transport_class_to_starget(dev); \ 273 struct spi_transport_attrs *tp; \ 274 \ 275 tp = (struct spi_transport_attrs *)&starget->starget_data; \ 276 val = simple_strtoul(buf, NULL, 0); \ 277 tp->field = val; \ 278 return count; \ 279 } 280 281 #define spi_transport_show_function(field, format_string) \ 282 \ 283 static ssize_t \ 284 show_spi_transport_##field(struct device *dev, \ 285 struct device_attribute *attr, char *buf) \ 286 { \ 287 struct scsi_target *starget = transport_class_to_starget(dev); \ 288 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); \ 289 struct spi_transport_attrs *tp; \ 290 struct spi_internal *i = to_spi_internal(shost->transportt); \ 291 tp = (struct spi_transport_attrs *)&starget->starget_data; \ 292 if (i->f->get_##field) \ 293 i->f->get_##field(starget); \ 294 return snprintf(buf, 20, format_string, tp->field); \ 295 } 296 297 #define spi_transport_store_function(field, format_string) \ 298 static ssize_t \ 299 store_spi_transport_##field(struct device *dev, \ 300 struct device_attribute *attr, \ 301 const char *buf, size_t count) \ 302 { \ 303 int val; \ 304 struct scsi_target *starget = transport_class_to_starget(dev); \ 305 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); \ 306 struct spi_internal *i = to_spi_internal(shost->transportt); \ 307 \ 308 if (!i->f->set_##field) \ 309 return -EINVAL; \ 310 val = simple_strtoul(buf, NULL, 0); \ 311 i->f->set_##field(starget, val); \ 312 return count; \ 313 } 314 315 #define spi_transport_store_max(field, format_string) \ 316 static ssize_t \ 317 store_spi_transport_##field(struct device *dev, \ 318 struct device_attribute *attr, \ 319 const char *buf, size_t count) \ 320 { \ 321 int val; \ 322 struct scsi_target *starget = transport_class_to_starget(dev); \ 323 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); \ 324 struct spi_internal *i = to_spi_internal(shost->transportt); \ 325 struct spi_transport_attrs *tp \ 326 = (struct spi_transport_attrs *)&starget->starget_data; \ 327 \ 328 if (i->f->set_##field) \ 329 return -EINVAL; \ 330 val = simple_strtoul(buf, NULL, 0); \ 331 if (val > tp->max_##field) \ 332 val = tp->max_##field; \ 333 i->f->set_##field(starget, val); \ 334 return count; \ 335 } 336 337 #define spi_transport_rd_attr(field, format_string) \ 338 spi_transport_show_function(field, format_string) \ 339 spi_transport_store_function(field, format_string) \ 340 static DEVICE_ATTR(field, S_IRUGO, \ 341 show_spi_transport_##field, \ 342 store_spi_transport_##field); 343 344 #define spi_transport_simple_attr(field, format_string) \ 345 spi_transport_show_simple(field, format_string) \ 346 spi_transport_store_simple(field, format_string) \ 347 static DEVICE_ATTR(field, S_IRUGO, \ 348 show_spi_transport_##field, \ 349 store_spi_transport_##field); 350 351 #define spi_transport_max_attr(field, format_string) \ 352 spi_transport_show_function(field, format_string) \ 353 spi_transport_store_max(field, format_string) \ 354 spi_transport_simple_attr(max_##field, format_string) \ 355 static DEVICE_ATTR(field, S_IRUGO, \ 356 show_spi_transport_##field, \ 357 store_spi_transport_##field); 358 359 /* The Parallel SCSI Tranport Attributes: */ 360 spi_transport_max_attr(offset, "%d\n"); 361 spi_transport_max_attr(width, "%d\n"); 362 spi_transport_rd_attr(iu, "%d\n"); 363 spi_transport_rd_attr(dt, "%d\n"); 364 spi_transport_rd_attr(qas, "%d\n"); 365 spi_transport_rd_attr(wr_flow, "%d\n"); 366 spi_transport_rd_attr(rd_strm, "%d\n"); 367 spi_transport_rd_attr(rti, "%d\n"); 368 spi_transport_rd_attr(pcomp_en, "%d\n"); 369 spi_transport_rd_attr(hold_mcs, "%d\n"); 370 371 /* we only care about the first child device that's a real SCSI device 372 * so we return 1 to terminate the iteration when we find it */ 373 static int child_iter(struct device *dev, void *data) 374 { 375 if (!scsi_is_sdev_device(dev)) 376 return 0; 377 378 spi_dv_device(to_scsi_device(dev)); 379 return 1; 380 } 381 382 static ssize_t 383 store_spi_revalidate(struct device *dev, struct device_attribute *attr, 384 const char *buf, size_t count) 385 { 386 struct scsi_target *starget = transport_class_to_starget(dev); 387 388 device_for_each_child(&starget->dev, NULL, child_iter); 389 return count; 390 } 391 static DEVICE_ATTR(revalidate, S_IWUSR, NULL, store_spi_revalidate); 392 393 /* Translate the period into ns according to the current spec 394 * for SDTR/PPR messages */ 395 static int period_to_str(char *buf, int period) 396 { 397 int len, picosec; 398 399 if (period < 0 || period > 0xff) { 400 picosec = -1; 401 } else if (period <= SPI_STATIC_PPR) { 402 picosec = ppr_to_ps[period]; 403 } else { 404 picosec = period * 4000; 405 } 406 407 if (picosec == -1) { 408 len = sprintf(buf, "reserved"); 409 } else { 410 len = sprint_frac(buf, picosec, 1000); 411 } 412 413 return len; 414 } 415 416 static ssize_t 417 show_spi_transport_period_helper(char *buf, int period) 418 { 419 int len = period_to_str(buf, period); 420 buf[len++] = '\n'; 421 buf[len] = '\0'; 422 return len; 423 } 424 425 static ssize_t 426 store_spi_transport_period_helper(struct device *dev, const char *buf, 427 size_t count, int *periodp) 428 { 429 int j, picosec, period = -1; 430 char *endp; 431 432 picosec = simple_strtoul(buf, &endp, 10) * 1000; 433 if (*endp == '.') { 434 int mult = 100; 435 do { 436 endp++; 437 if (!isdigit(*endp)) 438 break; 439 picosec += (*endp - '0') * mult; 440 mult /= 10; 441 } while (mult > 0); 442 } 443 444 for (j = 0; j <= SPI_STATIC_PPR; j++) { 445 if (ppr_to_ps[j] < picosec) 446 continue; 447 period = j; 448 break; 449 } 450 451 if (period == -1) 452 period = picosec / 4000; 453 454 if (period > 0xff) 455 period = 0xff; 456 457 *periodp = period; 458 459 return count; 460 } 461 462 static ssize_t 463 show_spi_transport_period(struct device *dev, 464 struct device_attribute *attr, char *buf) 465 { 466 struct scsi_target *starget = transport_class_to_starget(dev); 467 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); 468 struct spi_internal *i = to_spi_internal(shost->transportt); 469 struct spi_transport_attrs *tp = 470 (struct spi_transport_attrs *)&starget->starget_data; 471 472 if (i->f->get_period) 473 i->f->get_period(starget); 474 475 return show_spi_transport_period_helper(buf, tp->period); 476 } 477 478 static ssize_t 479 store_spi_transport_period(struct device *cdev, struct device_attribute *attr, 480 const char *buf, size_t count) 481 { 482 struct scsi_target *starget = transport_class_to_starget(cdev); 483 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); 484 struct spi_internal *i = to_spi_internal(shost->transportt); 485 struct spi_transport_attrs *tp = 486 (struct spi_transport_attrs *)&starget->starget_data; 487 int period, retval; 488 489 if (!i->f->set_period) 490 return -EINVAL; 491 492 retval = store_spi_transport_period_helper(cdev, buf, count, &period); 493 494 if (period < tp->min_period) 495 period = tp->min_period; 496 497 i->f->set_period(starget, period); 498 499 return retval; 500 } 501 502 static DEVICE_ATTR(period, S_IRUGO, 503 show_spi_transport_period, 504 store_spi_transport_period); 505 506 static ssize_t 507 show_spi_transport_min_period(struct device *cdev, 508 struct device_attribute *attr, char *buf) 509 { 510 struct scsi_target *starget = transport_class_to_starget(cdev); 511 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); 512 struct spi_internal *i = to_spi_internal(shost->transportt); 513 struct spi_transport_attrs *tp = 514 (struct spi_transport_attrs *)&starget->starget_data; 515 516 if (!i->f->set_period) 517 return -EINVAL; 518 519 return show_spi_transport_period_helper(buf, tp->min_period); 520 } 521 522 static ssize_t 523 store_spi_transport_min_period(struct device *cdev, 524 struct device_attribute *attr, 525 const char *buf, size_t count) 526 { 527 struct scsi_target *starget = transport_class_to_starget(cdev); 528 struct spi_transport_attrs *tp = 529 (struct spi_transport_attrs *)&starget->starget_data; 530 531 return store_spi_transport_period_helper(cdev, buf, count, 532 &tp->min_period); 533 } 534 535 536 static DEVICE_ATTR(min_period, S_IRUGO, 537 show_spi_transport_min_period, 538 store_spi_transport_min_period); 539 540 541 static ssize_t show_spi_host_signalling(struct device *cdev, 542 struct device_attribute *attr, 543 char *buf) 544 { 545 struct Scsi_Host *shost = transport_class_to_shost(cdev); 546 struct spi_internal *i = to_spi_internal(shost->transportt); 547 548 if (i->f->get_signalling) 549 i->f->get_signalling(shost); 550 551 return sprintf(buf, "%s\n", spi_signal_to_string(spi_signalling(shost))); 552 } 553 static ssize_t store_spi_host_signalling(struct device *dev, 554 struct device_attribute *attr, 555 const char *buf, size_t count) 556 { 557 struct Scsi_Host *shost = transport_class_to_shost(dev); 558 struct spi_internal *i = to_spi_internal(shost->transportt); 559 enum spi_signal_type type = spi_signal_to_value(buf); 560 561 if (!i->f->set_signalling) 562 return -EINVAL; 563 564 if (type != SPI_SIGNAL_UNKNOWN) 565 i->f->set_signalling(shost, type); 566 567 return count; 568 } 569 static DEVICE_ATTR(signalling, S_IRUGO, 570 show_spi_host_signalling, 571 store_spi_host_signalling); 572 573 #define DV_SET(x, y) \ 574 if(i->f->set_##x) \ 575 i->f->set_##x(sdev->sdev_target, y) 576 577 enum spi_compare_returns { 578 SPI_COMPARE_SUCCESS, 579 SPI_COMPARE_FAILURE, 580 SPI_COMPARE_SKIP_TEST, 581 }; 582 583 584 /* This is for read/write Domain Validation: If the device supports 585 * an echo buffer, we do read/write tests to it */ 586 static enum spi_compare_returns 587 spi_dv_device_echo_buffer(struct scsi_device *sdev, u8 *buffer, 588 u8 *ptr, const int retries) 589 { 590 int len = ptr - buffer; 591 int j, k, r, result; 592 unsigned int pattern = 0x0000ffff; 593 struct scsi_sense_hdr sshdr; 594 595 const char spi_write_buffer[] = { 596 WRITE_BUFFER, 0x0a, 0, 0, 0, 0, 0, len >> 8, len & 0xff, 0 597 }; 598 const char spi_read_buffer[] = { 599 READ_BUFFER, 0x0a, 0, 0, 0, 0, 0, len >> 8, len & 0xff, 0 600 }; 601 602 /* set up the pattern buffer. Doesn't matter if we spill 603 * slightly beyond since that's where the read buffer is */ 604 for (j = 0; j < len; ) { 605 606 /* fill the buffer with counting (test a) */ 607 for ( ; j < min(len, 32); j++) 608 buffer[j] = j; 609 k = j; 610 /* fill the buffer with alternating words of 0x0 and 611 * 0xffff (test b) */ 612 for ( ; j < min(len, k + 32); j += 2) { 613 u16 *word = (u16 *)&buffer[j]; 614 615 *word = (j & 0x02) ? 0x0000 : 0xffff; 616 } 617 k = j; 618 /* fill with crosstalk (alternating 0x5555 0xaaa) 619 * (test c) */ 620 for ( ; j < min(len, k + 32); j += 2) { 621 u16 *word = (u16 *)&buffer[j]; 622 623 *word = (j & 0x02) ? 0x5555 : 0xaaaa; 624 } 625 k = j; 626 /* fill with shifting bits (test d) */ 627 for ( ; j < min(len, k + 32); j += 4) { 628 u32 *word = (unsigned int *)&buffer[j]; 629 u32 roll = (pattern & 0x80000000) ? 1 : 0; 630 631 *word = pattern; 632 pattern = (pattern << 1) | roll; 633 } 634 /* don't bother with random data (test e) */ 635 } 636 637 for (r = 0; r < retries; r++) { 638 result = spi_execute(sdev, spi_write_buffer, DMA_TO_DEVICE, 639 buffer, len, &sshdr); 640 if(result || !scsi_device_online(sdev)) { 641 642 scsi_device_set_state(sdev, SDEV_QUIESCE); 643 if (scsi_sense_valid(&sshdr) 644 && sshdr.sense_key == ILLEGAL_REQUEST 645 /* INVALID FIELD IN CDB */ 646 && sshdr.asc == 0x24 && sshdr.ascq == 0x00) 647 /* This would mean that the drive lied 648 * to us about supporting an echo 649 * buffer (unfortunately some Western 650 * Digital drives do precisely this) 651 */ 652 return SPI_COMPARE_SKIP_TEST; 653 654 655 sdev_printk(KERN_ERR, sdev, "Write Buffer failure %x\n", result); 656 return SPI_COMPARE_FAILURE; 657 } 658 659 memset(ptr, 0, len); 660 spi_execute(sdev, spi_read_buffer, DMA_FROM_DEVICE, 661 ptr, len, NULL); 662 scsi_device_set_state(sdev, SDEV_QUIESCE); 663 664 if (memcmp(buffer, ptr, len) != 0) 665 return SPI_COMPARE_FAILURE; 666 } 667 return SPI_COMPARE_SUCCESS; 668 } 669 670 /* This is for the simplest form of Domain Validation: a read test 671 * on the inquiry data from the device */ 672 static enum spi_compare_returns 673 spi_dv_device_compare_inquiry(struct scsi_device *sdev, u8 *buffer, 674 u8 *ptr, const int retries) 675 { 676 int r, result; 677 const int len = sdev->inquiry_len; 678 const char spi_inquiry[] = { 679 INQUIRY, 0, 0, 0, len, 0 680 }; 681 682 for (r = 0; r < retries; r++) { 683 memset(ptr, 0, len); 684 685 result = spi_execute(sdev, spi_inquiry, DMA_FROM_DEVICE, 686 ptr, len, NULL); 687 688 if(result || !scsi_device_online(sdev)) { 689 scsi_device_set_state(sdev, SDEV_QUIESCE); 690 return SPI_COMPARE_FAILURE; 691 } 692 693 /* If we don't have the inquiry data already, the 694 * first read gets it */ 695 if (ptr == buffer) { 696 ptr += len; 697 --r; 698 continue; 699 } 700 701 if (memcmp(buffer, ptr, len) != 0) 702 /* failure */ 703 return SPI_COMPARE_FAILURE; 704 } 705 return SPI_COMPARE_SUCCESS; 706 } 707 708 static enum spi_compare_returns 709 spi_dv_retrain(struct scsi_device *sdev, u8 *buffer, u8 *ptr, 710 enum spi_compare_returns 711 (*compare_fn)(struct scsi_device *, u8 *, u8 *, int)) 712 { 713 struct spi_internal *i = to_spi_internal(sdev->host->transportt); 714 struct scsi_target *starget = sdev->sdev_target; 715 int period = 0, prevperiod = 0; 716 enum spi_compare_returns retval; 717 718 719 for (;;) { 720 int newperiod; 721 retval = compare_fn(sdev, buffer, ptr, DV_LOOPS); 722 723 if (retval == SPI_COMPARE_SUCCESS 724 || retval == SPI_COMPARE_SKIP_TEST) 725 break; 726 727 /* OK, retrain, fallback */ 728 if (i->f->get_iu) 729 i->f->get_iu(starget); 730 if (i->f->get_qas) 731 i->f->get_qas(starget); 732 if (i->f->get_period) 733 i->f->get_period(sdev->sdev_target); 734 735 /* Here's the fallback sequence; first try turning off 736 * IU, then QAS (if we can control them), then finally 737 * fall down the periods */ 738 if (i->f->set_iu && spi_iu(starget)) { 739 starget_printk(KERN_ERR, starget, "Domain Validation Disabing Information Units\n"); 740 DV_SET(iu, 0); 741 } else if (i->f->set_qas && spi_qas(starget)) { 742 starget_printk(KERN_ERR, starget, "Domain Validation Disabing Quick Arbitration and Selection\n"); 743 DV_SET(qas, 0); 744 } else { 745 newperiod = spi_period(starget); 746 period = newperiod > period ? newperiod : period; 747 if (period < 0x0d) 748 period++; 749 else 750 period += period >> 1; 751 752 if (unlikely(period > 0xff || period == prevperiod)) { 753 /* Total failure; set to async and return */ 754 starget_printk(KERN_ERR, starget, "Domain Validation Failure, dropping back to Asynchronous\n"); 755 DV_SET(offset, 0); 756 return SPI_COMPARE_FAILURE; 757 } 758 starget_printk(KERN_ERR, starget, "Domain Validation detected failure, dropping back\n"); 759 DV_SET(period, period); 760 prevperiod = period; 761 } 762 } 763 return retval; 764 } 765 766 static int 767 spi_dv_device_get_echo_buffer(struct scsi_device *sdev, u8 *buffer) 768 { 769 int l, result; 770 771 /* first off do a test unit ready. This can error out 772 * because of reservations or some other reason. If it 773 * fails, the device won't let us write to the echo buffer 774 * so just return failure */ 775 776 const char spi_test_unit_ready[] = { 777 TEST_UNIT_READY, 0, 0, 0, 0, 0 778 }; 779 780 const char spi_read_buffer_descriptor[] = { 781 READ_BUFFER, 0x0b, 0, 0, 0, 0, 0, 0, 4, 0 782 }; 783 784 785 /* We send a set of three TURs to clear any outstanding 786 * unit attention conditions if they exist (Otherwise the 787 * buffer tests won't be happy). If the TUR still fails 788 * (reservation conflict, device not ready, etc) just 789 * skip the write tests */ 790 for (l = 0; ; l++) { 791 result = spi_execute(sdev, spi_test_unit_ready, DMA_NONE, 792 NULL, 0, NULL); 793 794 if(result) { 795 if(l >= 3) 796 return 0; 797 } else { 798 /* TUR succeeded */ 799 break; 800 } 801 } 802 803 result = spi_execute(sdev, spi_read_buffer_descriptor, 804 DMA_FROM_DEVICE, buffer, 4, NULL); 805 806 if (result) 807 /* Device has no echo buffer */ 808 return 0; 809 810 return buffer[3] + ((buffer[2] & 0x1f) << 8); 811 } 812 813 static void 814 spi_dv_device_internal(struct scsi_device *sdev, u8 *buffer) 815 { 816 struct spi_internal *i = to_spi_internal(sdev->host->transportt); 817 struct scsi_target *starget = sdev->sdev_target; 818 struct Scsi_Host *shost = sdev->host; 819 int len = sdev->inquiry_len; 820 int min_period = spi_min_period(starget); 821 int max_width = spi_max_width(starget); 822 /* first set us up for narrow async */ 823 DV_SET(offset, 0); 824 DV_SET(width, 0); 825 826 if (spi_dv_device_compare_inquiry(sdev, buffer, buffer, DV_LOOPS) 827 != SPI_COMPARE_SUCCESS) { 828 starget_printk(KERN_ERR, starget, "Domain Validation Initial Inquiry Failed\n"); 829 /* FIXME: should probably offline the device here? */ 830 return; 831 } 832 833 if (!scsi_device_wide(sdev)) { 834 spi_max_width(starget) = 0; 835 max_width = 0; 836 } 837 838 /* test width */ 839 if (i->f->set_width && max_width) { 840 i->f->set_width(starget, 1); 841 842 if (spi_dv_device_compare_inquiry(sdev, buffer, 843 buffer + len, 844 DV_LOOPS) 845 != SPI_COMPARE_SUCCESS) { 846 starget_printk(KERN_ERR, starget, "Wide Transfers Fail\n"); 847 i->f->set_width(starget, 0); 848 /* Make sure we don't force wide back on by asking 849 * for a transfer period that requires it */ 850 max_width = 0; 851 if (min_period < 10) 852 min_period = 10; 853 } 854 } 855 856 if (!i->f->set_period) 857 return; 858 859 /* device can't handle synchronous */ 860 if (!scsi_device_sync(sdev) && !scsi_device_dt(sdev)) 861 return; 862 863 /* len == -1 is the signal that we need to ascertain the 864 * presence of an echo buffer before trying to use it. len == 865 * 0 means we don't have an echo buffer */ 866 len = -1; 867 868 retry: 869 870 /* now set up to the maximum */ 871 DV_SET(offset, spi_max_offset(starget)); 872 DV_SET(period, min_period); 873 874 /* try QAS requests; this should be harmless to set if the 875 * target supports it */ 876 if (scsi_device_qas(sdev)) { 877 DV_SET(qas, 1); 878 } else { 879 DV_SET(qas, 0); 880 } 881 882 if (scsi_device_ius(sdev) && min_period < 9) { 883 /* This u320 (or u640). Set IU transfers */ 884 DV_SET(iu, 1); 885 /* Then set the optional parameters */ 886 DV_SET(rd_strm, 1); 887 DV_SET(wr_flow, 1); 888 DV_SET(rti, 1); 889 if (min_period == 8) 890 DV_SET(pcomp_en, 1); 891 } else { 892 DV_SET(iu, 0); 893 } 894 895 /* now that we've done all this, actually check the bus 896 * signal type (if known). Some devices are stupid on 897 * a SE bus and still claim they can try LVD only settings */ 898 if (i->f->get_signalling) 899 i->f->get_signalling(shost); 900 if (spi_signalling(shost) == SPI_SIGNAL_SE || 901 spi_signalling(shost) == SPI_SIGNAL_HVD || 902 !scsi_device_dt(sdev)) { 903 DV_SET(dt, 0); 904 } else { 905 DV_SET(dt, 1); 906 } 907 /* set width last because it will pull all the other 908 * parameters down to required values */ 909 DV_SET(width, max_width); 910 911 /* Do the read only INQUIRY tests */ 912 spi_dv_retrain(sdev, buffer, buffer + sdev->inquiry_len, 913 spi_dv_device_compare_inquiry); 914 /* See if we actually managed to negotiate and sustain DT */ 915 if (i->f->get_dt) 916 i->f->get_dt(starget); 917 918 /* see if the device has an echo buffer. If it does we can do 919 * the SPI pattern write tests. Because of some broken 920 * devices, we *only* try this on a device that has actually 921 * negotiated DT */ 922 923 if (len == -1 && spi_dt(starget)) 924 len = spi_dv_device_get_echo_buffer(sdev, buffer); 925 926 if (len <= 0) { 927 starget_printk(KERN_INFO, starget, "Domain Validation skipping write tests\n"); 928 return; 929 } 930 931 if (len > SPI_MAX_ECHO_BUFFER_SIZE) { 932 starget_printk(KERN_WARNING, starget, "Echo buffer size %d is too big, trimming to %d\n", len, SPI_MAX_ECHO_BUFFER_SIZE); 933 len = SPI_MAX_ECHO_BUFFER_SIZE; 934 } 935 936 if (spi_dv_retrain(sdev, buffer, buffer + len, 937 spi_dv_device_echo_buffer) 938 == SPI_COMPARE_SKIP_TEST) { 939 /* OK, the stupid drive can't do a write echo buffer 940 * test after all, fall back to the read tests */ 941 len = 0; 942 goto retry; 943 } 944 } 945 946 947 /** spi_dv_device - Do Domain Validation on the device 948 * @sdev: scsi device to validate 949 * 950 * Performs the domain validation on the given device in the 951 * current execution thread. Since DV operations may sleep, 952 * the current thread must have user context. Also no SCSI 953 * related locks that would deadlock I/O issued by the DV may 954 * be held. 955 */ 956 void 957 spi_dv_device(struct scsi_device *sdev) 958 { 959 struct scsi_target *starget = sdev->sdev_target; 960 u8 *buffer; 961 const int len = SPI_MAX_ECHO_BUFFER_SIZE*2; 962 963 if (unlikely(scsi_device_get(sdev))) 964 return; 965 966 if (unlikely(spi_dv_in_progress(starget))) 967 return; 968 spi_dv_in_progress(starget) = 1; 969 970 buffer = kzalloc(len, GFP_KERNEL); 971 972 if (unlikely(!buffer)) 973 goto out_put; 974 975 /* We need to verify that the actual device will quiesce; the 976 * later target quiesce is just a nice to have */ 977 if (unlikely(scsi_device_quiesce(sdev))) 978 goto out_free; 979 980 scsi_target_quiesce(starget); 981 982 spi_dv_pending(starget) = 1; 983 mutex_lock(&spi_dv_mutex(starget)); 984 985 starget_printk(KERN_INFO, starget, "Beginning Domain Validation\n"); 986 987 spi_dv_device_internal(sdev, buffer); 988 989 starget_printk(KERN_INFO, starget, "Ending Domain Validation\n"); 990 991 mutex_unlock(&spi_dv_mutex(starget)); 992 spi_dv_pending(starget) = 0; 993 994 scsi_target_resume(starget); 995 996 spi_initial_dv(starget) = 1; 997 998 out_free: 999 kfree(buffer); 1000 out_put: 1001 spi_dv_in_progress(starget) = 0; 1002 scsi_device_put(sdev); 1003 } 1004 EXPORT_SYMBOL(spi_dv_device); 1005 1006 struct work_queue_wrapper { 1007 struct work_struct work; 1008 struct scsi_device *sdev; 1009 }; 1010 1011 static void 1012 spi_dv_device_work_wrapper(struct work_struct *work) 1013 { 1014 struct work_queue_wrapper *wqw = 1015 container_of(work, struct work_queue_wrapper, work); 1016 struct scsi_device *sdev = wqw->sdev; 1017 1018 kfree(wqw); 1019 spi_dv_device(sdev); 1020 spi_dv_pending(sdev->sdev_target) = 0; 1021 scsi_device_put(sdev); 1022 } 1023 1024 1025 /** 1026 * spi_schedule_dv_device - schedule domain validation to occur on the device 1027 * @sdev: The device to validate 1028 * 1029 * Identical to spi_dv_device() above, except that the DV will be 1030 * scheduled to occur in a workqueue later. All memory allocations 1031 * are atomic, so may be called from any context including those holding 1032 * SCSI locks. 1033 */ 1034 void 1035 spi_schedule_dv_device(struct scsi_device *sdev) 1036 { 1037 struct work_queue_wrapper *wqw = 1038 kmalloc(sizeof(struct work_queue_wrapper), GFP_ATOMIC); 1039 1040 if (unlikely(!wqw)) 1041 return; 1042 1043 if (unlikely(spi_dv_pending(sdev->sdev_target))) { 1044 kfree(wqw); 1045 return; 1046 } 1047 /* Set pending early (dv_device doesn't check it, only sets it) */ 1048 spi_dv_pending(sdev->sdev_target) = 1; 1049 if (unlikely(scsi_device_get(sdev))) { 1050 kfree(wqw); 1051 spi_dv_pending(sdev->sdev_target) = 0; 1052 return; 1053 } 1054 1055 INIT_WORK(&wqw->work, spi_dv_device_work_wrapper); 1056 wqw->sdev = sdev; 1057 1058 schedule_work(&wqw->work); 1059 } 1060 EXPORT_SYMBOL(spi_schedule_dv_device); 1061 1062 /** 1063 * spi_display_xfer_agreement - Print the current target transfer agreement 1064 * @starget: The target for which to display the agreement 1065 * 1066 * Each SPI port is required to maintain a transfer agreement for each 1067 * other port on the bus. This function prints a one-line summary of 1068 * the current agreement; more detailed information is available in sysfs. 1069 */ 1070 void spi_display_xfer_agreement(struct scsi_target *starget) 1071 { 1072 struct spi_transport_attrs *tp; 1073 tp = (struct spi_transport_attrs *)&starget->starget_data; 1074 1075 if (tp->offset > 0 && tp->period > 0) { 1076 unsigned int picosec, kb100; 1077 char *scsi = "FAST-?"; 1078 char tmp[8]; 1079 1080 if (tp->period <= SPI_STATIC_PPR) { 1081 picosec = ppr_to_ps[tp->period]; 1082 switch (tp->period) { 1083 case 7: scsi = "FAST-320"; break; 1084 case 8: scsi = "FAST-160"; break; 1085 case 9: scsi = "FAST-80"; break; 1086 case 10: 1087 case 11: scsi = "FAST-40"; break; 1088 case 12: scsi = "FAST-20"; break; 1089 } 1090 } else { 1091 picosec = tp->period * 4000; 1092 if (tp->period < 25) 1093 scsi = "FAST-20"; 1094 else if (tp->period < 50) 1095 scsi = "FAST-10"; 1096 else 1097 scsi = "FAST-5"; 1098 } 1099 1100 kb100 = (10000000 + picosec / 2) / picosec; 1101 if (tp->width) 1102 kb100 *= 2; 1103 sprint_frac(tmp, picosec, 1000); 1104 1105 dev_info(&starget->dev, 1106 "%s %sSCSI %d.%d MB/s %s%s%s%s%s%s%s%s (%s ns, offset %d)\n", 1107 scsi, tp->width ? "WIDE " : "", kb100/10, kb100 % 10, 1108 tp->dt ? "DT" : "ST", 1109 tp->iu ? " IU" : "", 1110 tp->qas ? " QAS" : "", 1111 tp->rd_strm ? " RDSTRM" : "", 1112 tp->rti ? " RTI" : "", 1113 tp->wr_flow ? " WRFLOW" : "", 1114 tp->pcomp_en ? " PCOMP" : "", 1115 tp->hold_mcs ? " HMCS" : "", 1116 tmp, tp->offset); 1117 } else { 1118 dev_info(&starget->dev, "%sasynchronous\n", 1119 tp->width ? "wide " : ""); 1120 } 1121 } 1122 EXPORT_SYMBOL(spi_display_xfer_agreement); 1123 1124 int spi_populate_width_msg(unsigned char *msg, int width) 1125 { 1126 msg[0] = EXTENDED_MESSAGE; 1127 msg[1] = 2; 1128 msg[2] = EXTENDED_WDTR; 1129 msg[3] = width; 1130 return 4; 1131 } 1132 EXPORT_SYMBOL_GPL(spi_populate_width_msg); 1133 1134 int spi_populate_sync_msg(unsigned char *msg, int period, int offset) 1135 { 1136 msg[0] = EXTENDED_MESSAGE; 1137 msg[1] = 3; 1138 msg[2] = EXTENDED_SDTR; 1139 msg[3] = period; 1140 msg[4] = offset; 1141 return 5; 1142 } 1143 EXPORT_SYMBOL_GPL(spi_populate_sync_msg); 1144 1145 int spi_populate_ppr_msg(unsigned char *msg, int period, int offset, 1146 int width, int options) 1147 { 1148 msg[0] = EXTENDED_MESSAGE; 1149 msg[1] = 6; 1150 msg[2] = EXTENDED_PPR; 1151 msg[3] = period; 1152 msg[4] = 0; 1153 msg[5] = offset; 1154 msg[6] = width; 1155 msg[7] = options; 1156 return 8; 1157 } 1158 EXPORT_SYMBOL_GPL(spi_populate_ppr_msg); 1159 1160 #ifdef CONFIG_SCSI_CONSTANTS 1161 static const char * const one_byte_msgs[] = { 1162 /* 0x00 */ "Task Complete", NULL /* Extended Message */, "Save Pointers", 1163 /* 0x03 */ "Restore Pointers", "Disconnect", "Initiator Error", 1164 /* 0x06 */ "Abort Task Set", "Message Reject", "Nop", "Message Parity Error", 1165 /* 0x0a */ "Linked Command Complete", "Linked Command Complete w/flag", 1166 /* 0x0c */ "Target Reset", "Abort Task", "Clear Task Set", 1167 /* 0x0f */ "Initiate Recovery", "Release Recovery", 1168 /* 0x11 */ "Terminate Process", "Continue Task", "Target Transfer Disable", 1169 /* 0x14 */ NULL, NULL, "Clear ACA", "LUN Reset" 1170 }; 1171 1172 static const char * const two_byte_msgs[] = { 1173 /* 0x20 */ "Simple Queue Tag", "Head of Queue Tag", "Ordered Queue Tag", 1174 /* 0x23 */ "Ignore Wide Residue", "ACA" 1175 }; 1176 1177 static const char * const extended_msgs[] = { 1178 /* 0x00 */ "Modify Data Pointer", "Synchronous Data Transfer Request", 1179 /* 0x02 */ "SCSI-I Extended Identify", "Wide Data Transfer Request", 1180 /* 0x04 */ "Parallel Protocol Request", "Modify Bidirectional Data Pointer" 1181 }; 1182 1183 static void print_nego(const unsigned char *msg, int per, int off, int width) 1184 { 1185 if (per) { 1186 char buf[20]; 1187 period_to_str(buf, msg[per]); 1188 printk("period = %s ns ", buf); 1189 } 1190 1191 if (off) 1192 printk("offset = %d ", msg[off]); 1193 if (width) 1194 printk("width = %d ", 8 << msg[width]); 1195 } 1196 1197 static void print_ptr(const unsigned char *msg, int msb, const char *desc) 1198 { 1199 int ptr = (msg[msb] << 24) | (msg[msb+1] << 16) | (msg[msb+2] << 8) | 1200 msg[msb+3]; 1201 printk("%s = %d ", desc, ptr); 1202 } 1203 1204 int spi_print_msg(const unsigned char *msg) 1205 { 1206 int len = 1, i; 1207 if (msg[0] == EXTENDED_MESSAGE) { 1208 len = 2 + msg[1]; 1209 if (len == 2) 1210 len += 256; 1211 if (msg[2] < ARRAY_SIZE(extended_msgs)) 1212 printk ("%s ", extended_msgs[msg[2]]); 1213 else 1214 printk ("Extended Message, reserved code (0x%02x) ", 1215 (int) msg[2]); 1216 switch (msg[2]) { 1217 case EXTENDED_MODIFY_DATA_POINTER: 1218 print_ptr(msg, 3, "pointer"); 1219 break; 1220 case EXTENDED_SDTR: 1221 print_nego(msg, 3, 4, 0); 1222 break; 1223 case EXTENDED_WDTR: 1224 print_nego(msg, 0, 0, 3); 1225 break; 1226 case EXTENDED_PPR: 1227 print_nego(msg, 3, 5, 6); 1228 break; 1229 case EXTENDED_MODIFY_BIDI_DATA_PTR: 1230 print_ptr(msg, 3, "out"); 1231 print_ptr(msg, 7, "in"); 1232 break; 1233 default: 1234 for (i = 2; i < len; ++i) 1235 printk("%02x ", msg[i]); 1236 } 1237 /* Identify */ 1238 } else if (msg[0] & 0x80) { 1239 printk("Identify disconnect %sallowed %s %d ", 1240 (msg[0] & 0x40) ? "" : "not ", 1241 (msg[0] & 0x20) ? "target routine" : "lun", 1242 msg[0] & 0x7); 1243 /* Normal One byte */ 1244 } else if (msg[0] < 0x1f) { 1245 if (msg[0] < ARRAY_SIZE(one_byte_msgs) && one_byte_msgs[msg[0]]) 1246 printk("%s ", one_byte_msgs[msg[0]]); 1247 else 1248 printk("reserved (%02x) ", msg[0]); 1249 } else if (msg[0] == 0x55) { 1250 printk("QAS Request "); 1251 /* Two byte */ 1252 } else if (msg[0] <= 0x2f) { 1253 if ((msg[0] - 0x20) < ARRAY_SIZE(two_byte_msgs)) 1254 printk("%s %02x ", two_byte_msgs[msg[0] - 0x20], 1255 msg[1]); 1256 else 1257 printk("reserved two byte (%02x %02x) ", 1258 msg[0], msg[1]); 1259 len = 2; 1260 } else 1261 printk("reserved "); 1262 return len; 1263 } 1264 EXPORT_SYMBOL(spi_print_msg); 1265 1266 #else /* ifndef CONFIG_SCSI_CONSTANTS */ 1267 1268 int spi_print_msg(const unsigned char *msg) 1269 { 1270 int len = 1, i; 1271 1272 if (msg[0] == EXTENDED_MESSAGE) { 1273 len = 2 + msg[1]; 1274 if (len == 2) 1275 len += 256; 1276 for (i = 0; i < len; ++i) 1277 printk("%02x ", msg[i]); 1278 /* Identify */ 1279 } else if (msg[0] & 0x80) { 1280 printk("%02x ", msg[0]); 1281 /* Normal One byte */ 1282 } else if ((msg[0] < 0x1f) || (msg[0] == 0x55)) { 1283 printk("%02x ", msg[0]); 1284 /* Two byte */ 1285 } else if (msg[0] <= 0x2f) { 1286 printk("%02x %02x", msg[0], msg[1]); 1287 len = 2; 1288 } else 1289 printk("%02x ", msg[0]); 1290 return len; 1291 } 1292 EXPORT_SYMBOL(spi_print_msg); 1293 #endif /* ! CONFIG_SCSI_CONSTANTS */ 1294 1295 static int spi_device_match(struct attribute_container *cont, 1296 struct device *dev) 1297 { 1298 struct scsi_device *sdev; 1299 struct Scsi_Host *shost; 1300 struct spi_internal *i; 1301 1302 if (!scsi_is_sdev_device(dev)) 1303 return 0; 1304 1305 sdev = to_scsi_device(dev); 1306 shost = sdev->host; 1307 if (!shost->transportt || shost->transportt->host_attrs.ac.class 1308 != &spi_host_class.class) 1309 return 0; 1310 /* Note: this class has no device attributes, so it has 1311 * no per-HBA allocation and thus we don't need to distinguish 1312 * the attribute containers for the device */ 1313 i = to_spi_internal(shost->transportt); 1314 if (i->f->deny_binding && i->f->deny_binding(sdev->sdev_target)) 1315 return 0; 1316 return 1; 1317 } 1318 1319 static int spi_target_match(struct attribute_container *cont, 1320 struct device *dev) 1321 { 1322 struct Scsi_Host *shost; 1323 struct scsi_target *starget; 1324 struct spi_internal *i; 1325 1326 if (!scsi_is_target_device(dev)) 1327 return 0; 1328 1329 shost = dev_to_shost(dev->parent); 1330 if (!shost->transportt || shost->transportt->host_attrs.ac.class 1331 != &spi_host_class.class) 1332 return 0; 1333 1334 i = to_spi_internal(shost->transportt); 1335 starget = to_scsi_target(dev); 1336 1337 if (i->f->deny_binding && i->f->deny_binding(starget)) 1338 return 0; 1339 1340 return &i->t.target_attrs.ac == cont; 1341 } 1342 1343 static DECLARE_TRANSPORT_CLASS(spi_transport_class, 1344 "spi_transport", 1345 spi_setup_transport_attrs, 1346 NULL, 1347 spi_target_configure); 1348 1349 static DECLARE_ANON_TRANSPORT_CLASS(spi_device_class, 1350 spi_device_match, 1351 spi_device_configure); 1352 1353 static struct attribute *host_attributes[] = { 1354 &dev_attr_signalling.attr, 1355 NULL 1356 }; 1357 1358 static struct attribute_group host_attribute_group = { 1359 .attrs = host_attributes, 1360 }; 1361 1362 static int spi_host_configure(struct transport_container *tc, 1363 struct device *dev, 1364 struct device *cdev) 1365 { 1366 struct kobject *kobj = &cdev->kobj; 1367 struct Scsi_Host *shost = transport_class_to_shost(cdev); 1368 struct spi_internal *si = to_spi_internal(shost->transportt); 1369 struct attribute *attr = &dev_attr_signalling.attr; 1370 int rc = 0; 1371 1372 if (si->f->set_signalling) 1373 rc = sysfs_chmod_file(kobj, attr, attr->mode | S_IWUSR); 1374 1375 return rc; 1376 } 1377 1378 /* returns true if we should be showing the variable. Also 1379 * overloads the return by setting 1<<1 if the attribute should 1380 * be writeable */ 1381 #define TARGET_ATTRIBUTE_HELPER(name) \ 1382 (si->f->show_##name ? S_IRUGO : 0) | \ 1383 (si->f->set_##name ? S_IWUSR : 0) 1384 1385 static mode_t target_attribute_is_visible(struct kobject *kobj, 1386 struct attribute *attr, int i) 1387 { 1388 struct device *cdev = container_of(kobj, struct device, kobj); 1389 struct scsi_target *starget = transport_class_to_starget(cdev); 1390 struct Scsi_Host *shost = transport_class_to_shost(cdev); 1391 struct spi_internal *si = to_spi_internal(shost->transportt); 1392 1393 if (attr == &dev_attr_period.attr && 1394 spi_support_sync(starget)) 1395 return TARGET_ATTRIBUTE_HELPER(period); 1396 else if (attr == &dev_attr_min_period.attr && 1397 spi_support_sync(starget)) 1398 return TARGET_ATTRIBUTE_HELPER(period); 1399 else if (attr == &dev_attr_offset.attr && 1400 spi_support_sync(starget)) 1401 return TARGET_ATTRIBUTE_HELPER(offset); 1402 else if (attr == &dev_attr_max_offset.attr && 1403 spi_support_sync(starget)) 1404 return TARGET_ATTRIBUTE_HELPER(offset); 1405 else if (attr == &dev_attr_width.attr && 1406 spi_support_wide(starget)) 1407 return TARGET_ATTRIBUTE_HELPER(width); 1408 else if (attr == &dev_attr_max_width.attr && 1409 spi_support_wide(starget)) 1410 return TARGET_ATTRIBUTE_HELPER(width); 1411 else if (attr == &dev_attr_iu.attr && 1412 spi_support_ius(starget)) 1413 return TARGET_ATTRIBUTE_HELPER(iu); 1414 else if (attr == &dev_attr_dt.attr && 1415 spi_support_dt(starget)) 1416 return TARGET_ATTRIBUTE_HELPER(dt); 1417 else if (attr == &dev_attr_qas.attr && 1418 spi_support_qas(starget)) 1419 return TARGET_ATTRIBUTE_HELPER(qas); 1420 else if (attr == &dev_attr_wr_flow.attr && 1421 spi_support_ius(starget)) 1422 return TARGET_ATTRIBUTE_HELPER(wr_flow); 1423 else if (attr == &dev_attr_rd_strm.attr && 1424 spi_support_ius(starget)) 1425 return TARGET_ATTRIBUTE_HELPER(rd_strm); 1426 else if (attr == &dev_attr_rti.attr && 1427 spi_support_ius(starget)) 1428 return TARGET_ATTRIBUTE_HELPER(rti); 1429 else if (attr == &dev_attr_pcomp_en.attr && 1430 spi_support_ius(starget)) 1431 return TARGET_ATTRIBUTE_HELPER(pcomp_en); 1432 else if (attr == &dev_attr_hold_mcs.attr && 1433 spi_support_ius(starget)) 1434 return TARGET_ATTRIBUTE_HELPER(hold_mcs); 1435 else if (attr == &dev_attr_revalidate.attr) 1436 return S_IWUSR; 1437 1438 return 0; 1439 } 1440 1441 static struct attribute *target_attributes[] = { 1442 &dev_attr_period.attr, 1443 &dev_attr_min_period.attr, 1444 &dev_attr_offset.attr, 1445 &dev_attr_max_offset.attr, 1446 &dev_attr_width.attr, 1447 &dev_attr_max_width.attr, 1448 &dev_attr_iu.attr, 1449 &dev_attr_dt.attr, 1450 &dev_attr_qas.attr, 1451 &dev_attr_wr_flow.attr, 1452 &dev_attr_rd_strm.attr, 1453 &dev_attr_rti.attr, 1454 &dev_attr_pcomp_en.attr, 1455 &dev_attr_hold_mcs.attr, 1456 &dev_attr_revalidate.attr, 1457 NULL 1458 }; 1459 1460 static struct attribute_group target_attribute_group = { 1461 .attrs = target_attributes, 1462 .is_visible = target_attribute_is_visible, 1463 }; 1464 1465 static int spi_target_configure(struct transport_container *tc, 1466 struct device *dev, 1467 struct device *cdev) 1468 { 1469 struct kobject *kobj = &cdev->kobj; 1470 1471 /* force an update based on parameters read from the device */ 1472 sysfs_update_group(kobj, &target_attribute_group); 1473 1474 return 0; 1475 } 1476 1477 struct scsi_transport_template * 1478 spi_attach_transport(struct spi_function_template *ft) 1479 { 1480 struct spi_internal *i = kzalloc(sizeof(struct spi_internal), 1481 GFP_KERNEL); 1482 1483 if (unlikely(!i)) 1484 return NULL; 1485 1486 i->t.target_attrs.ac.class = &spi_transport_class.class; 1487 i->t.target_attrs.ac.grp = &target_attribute_group; 1488 i->t.target_attrs.ac.match = spi_target_match; 1489 transport_container_register(&i->t.target_attrs); 1490 i->t.target_size = sizeof(struct spi_transport_attrs); 1491 i->t.host_attrs.ac.class = &spi_host_class.class; 1492 i->t.host_attrs.ac.grp = &host_attribute_group; 1493 i->t.host_attrs.ac.match = spi_host_match; 1494 transport_container_register(&i->t.host_attrs); 1495 i->t.host_size = sizeof(struct spi_host_attrs); 1496 i->f = ft; 1497 1498 return &i->t; 1499 } 1500 EXPORT_SYMBOL(spi_attach_transport); 1501 1502 void spi_release_transport(struct scsi_transport_template *t) 1503 { 1504 struct spi_internal *i = to_spi_internal(t); 1505 1506 transport_container_unregister(&i->t.target_attrs); 1507 transport_container_unregister(&i->t.host_attrs); 1508 1509 kfree(i); 1510 } 1511 EXPORT_SYMBOL(spi_release_transport); 1512 1513 static __init int spi_transport_init(void) 1514 { 1515 int error = transport_class_register(&spi_transport_class); 1516 if (error) 1517 return error; 1518 error = anon_transport_class_register(&spi_device_class); 1519 return transport_class_register(&spi_host_class); 1520 } 1521 1522 static void __exit spi_transport_exit(void) 1523 { 1524 transport_class_unregister(&spi_transport_class); 1525 anon_transport_class_unregister(&spi_device_class); 1526 transport_class_unregister(&spi_host_class); 1527 } 1528 1529 MODULE_AUTHOR("Martin Hicks"); 1530 MODULE_DESCRIPTION("SPI Transport Attributes"); 1531 MODULE_LICENSE("GPL"); 1532 1533 module_init(spi_transport_init); 1534 module_exit(spi_transport_exit); 1535