drivers/firewire/fw-sbp2.c

   1 /*
   2  * SBP2 driver (SCSI over IEEE1394)
   3  *
   4  * Copyright (C) 2005-2007  Kristian Hoegsberg <krh@bitplanet.net>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software Foundation,
  18  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  19  */
  20
  21 /*
  22  * The basic structure of this driver is based on the old storage driver,
  23  * drivers/ieee1394/sbp2.c, originally written by
  24  *     James Goodwin <jamesg@filanet.com>
  25  * with later contributions and ongoing maintenance from
  26  *     Ben Collins <bcollins@debian.org>,
  27  *     Stefan Richter <stefanr@s5r6.in-berlin.de>
  28  * and many others.
  29  */
  30
  31 #include <linux/kernel.h>
  32 #include <linux/module.h>
  33 #include <linux/moduleparam.h>
  34 #include <linux/mod_devicetable.h>
  35 #include <linux/device.h>
  36 #include <linux/scatterlist.h>
  37 #include <linux/dma-mapping.h>
  38 #include <linux/blkdev.h>
  39 #include <linux/string.h>
  40 #include <linux/timer.h>
  41
  42 #include <scsi/scsi.h>
  43 #include <scsi/scsi_cmnd.h>
  44 #include <scsi/scsi_device.h>
  45 #include <scsi/scsi_host.h>
  46
  47 #include "fw-transaction.h"
  48 #include "fw-topology.h"
  49 #include "fw-device.h"
  50
  51 /*
  52  * So far only bridges from Oxford Semiconductor are known to support
  53  * concurrent logins. Depending on firmware, four or two concurrent logins
  54  * are possible on OXFW911 and newer Oxsemi bridges.
  55  *
  56  * Concurrent logins are useful together with cluster filesystems.
  57  */
  58 static int sbp2_param_exclusive_login = 1;
  59 module_param_named(exclusive_login, sbp2_param_exclusive_login, bool, 0644);
  60 MODULE_PARM_DESC(exclusive_login, "Exclusive login to sbp2 device "
  61                  "(default = Y, use N for concurrent initiators)");
  62
  63 /* I don't know why the SCSI stack doesn't define something like this... */
  64 typedef void (*scsi_done_fn_t)(struct scsi_cmnd *);
  65
  66 static const char sbp2_driver_name[] = "sbp2";
  67
  68 /*
  69  * We create one struct sbp2_logical_unit per SBP-2 Logical Unit Number Entry
  70  * and one struct scsi_device per sbp2_logical_unit.
  71  */
  72 struct sbp2_logical_unit {
  73         struct sbp2_target *tgt;
  74         struct list_head link;
  75         struct scsi_device *sdev;
  76         struct fw_address_handler address_handler;
  77         struct list_head orb_list;
  78
  79         u64 command_block_agent_address;
  80         u16 lun;
  81         int login_id;
  82
  83         /*
  84          * The generation is updated once we've logged in or reconnected
  85          * to the logical unit.  Thus, I/O to the device will automatically
  86          * fail and get retried if it happens in a window where the device
  87          * is not ready, e.g. after a bus reset but before we reconnect.
  88          */
  89         int generation;
  90         int retries;
  91         struct delayed_work work;
  92 };
  93
  94 /*
  95  * We create one struct sbp2_target per IEEE 1212 Unit Directory
  96  * and one struct Scsi_Host per sbp2_target.
  97  */
  98 struct sbp2_target {
  99         struct kref kref;
 100         struct fw_unit *unit;
 101
 102         u64 management_agent_address;
 103         int directory_id;
 104         int node_id;
 105         int address_high;
 106
 107         unsigned workarounds;
 108         struct list_head lu_list;
 109 };
 110
 111 #define SBP2_MAX_SG_ELEMENT_LENGTH      0xf000
 112 #define SBP2_MAX_SECTORS                255     /* Max sectors supported */
 113 #define SBP2_ORB_TIMEOUT                2000    /* Timeout in ms */
 114
 115 #define SBP2_ORB_NULL                   0x80000000
 116
 117 #define SBP2_DIRECTION_TO_MEDIA         0x0
 118 #define SBP2_DIRECTION_FROM_MEDIA       0x1
 119
 120 /* Unit directory keys */
 121 #define SBP2_CSR_FIRMWARE_REVISION      0x3c
 122 #define SBP2_CSR_LOGICAL_UNIT_NUMBER    0x14
 123 #define SBP2_CSR_LOGICAL_UNIT_DIRECTORY 0xd4
 124
 125 /* Flags for detected oddities and brokeness */
 126 #define SBP2_WORKAROUND_128K_MAX_TRANS  0x1
 127 #define SBP2_WORKAROUND_INQUIRY_36      0x2
 128 #define SBP2_WORKAROUND_MODE_SENSE_8    0x4
 129 #define SBP2_WORKAROUND_FIX_CAPACITY    0x8
 130 #define SBP2_WORKAROUND_OVERRIDE        0x100
 131
 132 /* Management orb opcodes */
 133 #define SBP2_LOGIN_REQUEST              0x0
 134 #define SBP2_QUERY_LOGINS_REQUEST       0x1
 135 #define SBP2_RECONNECT_REQUEST          0x3
 136 #define SBP2_SET_PASSWORD_REQUEST       0x4
 137 #define SBP2_LOGOUT_REQUEST             0x7
 138 #define SBP2_ABORT_TASK_REQUEST         0xb
 139 #define SBP2_ABORT_TASK_SET             0xc
 140 #define SBP2_LOGICAL_UNIT_RESET         0xe
 141 #define SBP2_TARGET_RESET_REQUEST       0xf
 142
 143 /* Offsets for command block agent registers */
 144 #define SBP2_AGENT_STATE                0x00
 145 #define SBP2_AGENT_RESET                0x04
 146 #define SBP2_ORB_POINTER                0x08
 147 #define SBP2_DOORBELL                   0x10
 148 #define SBP2_UNSOLICITED_STATUS_ENABLE  0x14
 149
 150 /* Status write response codes */
 151 #define SBP2_STATUS_REQUEST_COMPLETE    0x0
 152 #define SBP2_STATUS_TRANSPORT_FAILURE   0x1
 153 #define SBP2_STATUS_ILLEGAL_REQUEST     0x2
 154 #define SBP2_STATUS_VENDOR_DEPENDENT    0x3
 155
 156 #define STATUS_GET_ORB_HIGH(v)          ((v).status & 0xffff)
 157 #define STATUS_GET_SBP_STATUS(v)        (((v).status >> 16) & 0xff)
 158 #define STATUS_GET_LEN(v)               (((v).status >> 24) & 0x07)
 159 #define STATUS_GET_DEAD(v)              (((v).status >> 27) & 0x01)
 160 #define STATUS_GET_RESPONSE(v)          (((v).status >> 28) & 0x03)
 161 #define STATUS_GET_SOURCE(v)            (((v).status >> 30) & 0x03)
 162 #define STATUS_GET_ORB_LOW(v)           ((v).orb_low)
 163 #define STATUS_GET_DATA(v)              ((v).data)
 164
 165 struct sbp2_status {
 166         u32 status;
 167         u32 orb_low;
 168         u8 data[24];
 169 };
 170
 171 struct sbp2_pointer {
 172         u32 high;
 173         u32 low;
 174 };
 175
 176 struct sbp2_orb {
 177         struct fw_transaction t;
 178         struct kref kref;
 179         dma_addr_t request_bus;
 180         int rcode;
 181         struct sbp2_pointer pointer;
 182         void (*callback)(struct sbp2_orb * orb, struct sbp2_status * status);
 183         struct list_head link;
 184 };
 185
 186 #define MANAGEMENT_ORB_LUN(v)                   ((v))
 187 #define MANAGEMENT_ORB_FUNCTION(v)              ((v) << 16)
 188 #define MANAGEMENT_ORB_RECONNECT(v)             ((v) << 20)
 189 #define MANAGEMENT_ORB_EXCLUSIVE(v)             ((v) ? 1 << 28 : 0)
 190 #define MANAGEMENT_ORB_REQUEST_FORMAT(v)        ((v) << 29)
 191 #define MANAGEMENT_ORB_NOTIFY                   ((1) << 31)
 192
 193 #define MANAGEMENT_ORB_RESPONSE_LENGTH(v)       ((v))
 194 #define MANAGEMENT_ORB_PASSWORD_LENGTH(v)       ((v) << 16)
 195
 196 struct sbp2_management_orb {
 197         struct sbp2_orb base;
 198         struct {
 199                 struct sbp2_pointer password;
 200                 struct sbp2_pointer response;
 201                 u32 misc;
 202                 u32 length;
 203                 struct sbp2_pointer status_fifo;
 204         } request;
 205         __be32 response[4];
 206         dma_addr_t response_bus;
 207         struct completion done;
 208         struct sbp2_status status;
 209 };
 210
 211 #define LOGIN_RESPONSE_GET_LOGIN_ID(v)  ((v).misc & 0xffff)
 212 #define LOGIN_RESPONSE_GET_LENGTH(v)    (((v).misc >> 16) & 0xffff)
 213
 214 struct sbp2_login_response {
 215         u32 misc;
 216         struct sbp2_pointer command_block_agent;
 217         u32 reconnect_hold;
 218 };
 219 #define COMMAND_ORB_DATA_SIZE(v)        ((v))
 220 #define COMMAND_ORB_PAGE_SIZE(v)        ((v) << 16)
 221 #define COMMAND_ORB_PAGE_TABLE_PRESENT  ((1) << 19)
 222 #define COMMAND_ORB_MAX_PAYLOAD(v)      ((v) << 20)
 223 #define COMMAND_ORB_SPEED(v)            ((v) << 24)
 224 #define COMMAND_ORB_DIRECTION(v)        ((v) << 27)
 225 #define COMMAND_ORB_REQUEST_FORMAT(v)   ((v) << 29)
 226 #define COMMAND_ORB_NOTIFY              ((1) << 31)
 227
 228 struct sbp2_command_orb {
 229         struct sbp2_orb base;
 230         struct {
 231                 struct sbp2_pointer next;
 232                 struct sbp2_pointer data_descriptor;
 233                 u32 misc;
 234                 u8 command_block[12];
 235         } request;
 236         struct scsi_cmnd *cmd;
 237         scsi_done_fn_t done;
 238         struct sbp2_logical_unit *lu;
 239
 240         struct sbp2_pointer page_table[SG_ALL] __attribute__((aligned(8)));
 241         dma_addr_t page_table_bus;
 242 };
 243
 244 /*
 245  * List of devices with known bugs.
 246  *
 247  * The firmware_revision field, masked with 0xffff00, is the best
 248  * indicator for the type of bridge chip of a device.  It yields a few
 249  * false positives but this did not break correctly behaving devices
 250  * so far.  We use ~0 as a wildcard, since the 24 bit values we get
 251  * from the config rom can never match that.
 252  */
 253 static const struct {
 254         u32 firmware_revision;
 255         u32 model;
 256         unsigned workarounds;
 257 } sbp2_workarounds_table[] = {
 258         /* DViCO Momobay CX-1 with TSB42AA9 bridge */ {
 259                 .firmware_revision      = 0x002800,
 260                 .model                  = 0x001010,
 261                 .workarounds            = SBP2_WORKAROUND_INQUIRY_36 |
 262                                           SBP2_WORKAROUND_MODE_SENSE_8,
 263         },
 264         /* Initio bridges, actually only needed for some older ones */ {
 265                 .firmware_revision      = 0x000200,
 266                 .model                  = ~0,
 267                 .workarounds            = SBP2_WORKAROUND_INQUIRY_36,
 268         },
 269         /* Symbios bridge */ {
 270                 .firmware_revision      = 0xa0b800,
 271                 .model                  = ~0,
 272                 .workarounds            = SBP2_WORKAROUND_128K_MAX_TRANS,
 273         },
 274
 275         /*
 276          * There are iPods (2nd gen, 3rd gen) with model_id == 0, but
 277          * these iPods do not feature the read_capacity bug according
 278          * to one report.  Read_capacity behaviour as well as model_id
 279          * could change due to Apple-supplied firmware updates though.
 280          */
 281
 282         /* iPod 4th generation. */ {
 283                 .firmware_revision      = 0x0a2700,
 284                 .model                  = 0x000021,
 285                 .workarounds            = SBP2_WORKAROUND_FIX_CAPACITY,
 286         },
 287         /* iPod mini */ {
 288                 .firmware_revision      = 0x0a2700,
 289                 .model                  = 0x000023,
 290                 .workarounds            = SBP2_WORKAROUND_FIX_CAPACITY,
 291         },
 292         /* iPod Photo */ {
 293                 .firmware_revision      = 0x0a2700,
 294                 .model                  = 0x00007e,
 295                 .workarounds            = SBP2_WORKAROUND_FIX_CAPACITY,
 296         }
 297 };
 298
 299 static void
 300 free_orb(struct kref *kref)
 301 {
 302         struct sbp2_orb *orb = container_of(kref, struct sbp2_orb, kref);
 303
 304         kfree(orb);
 305 }
 306
 307 static void
 308 sbp2_status_write(struct fw_card *card, struct fw_request *request,
 309                   int tcode, int destination, int source,
 310                   int generation, int speed,
 311                   unsigned long long offset,
 312                   void *payload, size_t length, void *callback_data)
 313 {
 314         struct sbp2_logical_unit *lu = callback_data;
 315         struct sbp2_orb *orb;
 316         struct sbp2_status status;
 317         size_t header_size;
 318         unsigned long flags;
 319
 320         if (tcode != TCODE_WRITE_BLOCK_REQUEST ||
 321             length == 0 || length > sizeof(status)) {
 322                 fw_send_response(card, request, RCODE_TYPE_ERROR);
 323                 return;
 324         }
 325
 326         header_size = min(length, 2 * sizeof(u32));
 327         fw_memcpy_from_be32(&status, payload, header_size);
 328         if (length > header_size)
 329                 memcpy(status.data, payload + 8, length - header_size);
 330         if (STATUS_GET_SOURCE(status) == 2 || STATUS_GET_SOURCE(status) == 3) {
 331                 fw_notify("non-orb related status write, not handled\n");
 332                 fw_send_response(card, request, RCODE_COMPLETE);
 333                 return;
 334         }
 335
 336         /* Lookup the orb corresponding to this status write. */
 337         spin_lock_irqsave(&card->lock, flags);
 338         list_for_each_entry(orb, &lu->orb_list, link) {
 339                 if (STATUS_GET_ORB_HIGH(status) == 0 &&
 340                     STATUS_GET_ORB_LOW(status) == orb->request_bus) {
 341                         orb->rcode = RCODE_COMPLETE;
 342                         list_del(&orb->link);
 343                         break;
 344                 }
 345         }
 346         spin_unlock_irqrestore(&card->lock, flags);
 347
 348         if (&orb->link != &lu->orb_list)
 349                 orb->callback(orb, &status);
 350         else
 351                 fw_error("status write for unknown orb\n");
 352
 353         kref_put(&orb->kref, free_orb);
 354
 355         fw_send_response(card, request, RCODE_COMPLETE);
 356 }
 357
 358 static void
 359 complete_transaction(struct fw_card *card, int rcode,
 360                      void *payload, size_t length, void *data)
 361 {
 362         struct sbp2_orb *orb = data;
 363         unsigned long flags;
 364
 365         /*
 366          * This is a little tricky.  We can get the status write for
 367          * the orb before we get this callback.  The status write
 368          * handler above will assume the orb pointer transaction was
 369          * successful and set the rcode to RCODE_COMPLETE for the orb.
 370          * So this callback only sets the rcode if it hasn't already
 371          * been set and only does the cleanup if the transaction
 372          * failed and we didn't already get a status write.
 373          */
 374         spin_lock_irqsave(&card->lock, flags);
 375
 376         if (orb->rcode == -1)
 377                 orb->rcode = rcode;
 378         if (orb->rcode != RCODE_COMPLETE) {
 379                 list_del(&orb->link);
 380                 spin_unlock_irqrestore(&card->lock, flags);
 381                 orb->callback(orb, NULL);
 382         } else {
 383                 spin_unlock_irqrestore(&card->lock, flags);
 384         }
 385
 386         kref_put(&orb->kref, free_orb);
 387 }
 388
 389 static void
 390 sbp2_send_orb(struct sbp2_orb *orb, struct sbp2_logical_unit *lu,
 391               int node_id, int generation, u64 offset)
 392 {
 393         struct fw_device *device = fw_device(lu->tgt->unit->device.parent);
 394         unsigned long flags;
 395
 396         orb->pointer.high = 0;
 397         orb->pointer.low = orb->request_bus;
 398         fw_memcpy_to_be32(&orb->pointer, &orb->pointer, sizeof(orb->pointer));
 399
 400         spin_lock_irqsave(&device->card->lock, flags);
 401         list_add_tail(&orb->link, &lu->orb_list);
 402         spin_unlock_irqrestore(&device->card->lock, flags);
 403
 404         /* Take a ref for the orb list and for the transaction callback. */
 405         kref_get(&orb->kref);
 406         kref_get(&orb->kref);
 407
 408         fw_send_request(device->card, &orb->t, TCODE_WRITE_BLOCK_REQUEST,
 409                         node_id, generation, device->max_speed, offset,
 410                         &orb->pointer, sizeof(orb->pointer),
 411                         complete_transaction, orb);
 412 }
 413
 414 static int sbp2_cancel_orbs(struct sbp2_logical_unit *lu)
 415 {
 416         struct fw_device *device = fw_device(lu->tgt->unit->device.parent);
 417         struct sbp2_orb *orb, *next;
 418         struct list_head list;
 419         unsigned long flags;
 420         int retval = -ENOENT;
 421
 422         INIT_LIST_HEAD(&list);
 423         spin_lock_irqsave(&device->card->lock, flags);
 424         list_splice_init(&lu->orb_list, &list);
 425         spin_unlock_irqrestore(&device->card->lock, flags);
 426
 427         list_for_each_entry_safe(orb, next, &list, link) {
 428                 retval = 0;
 429                 if (fw_cancel_transaction(device->card, &orb->t) == 0)
 430                         continue;
 431
 432                 orb->rcode = RCODE_CANCELLED;
 433                 orb->callback(orb, NULL);
 434         }
 435
 436         return retval;
 437 }
 438
 439 static void
 440 complete_management_orb(struct sbp2_orb *base_orb, struct sbp2_status *status)
 441 {
 442         struct sbp2_management_orb *orb =
 443                 container_of(base_orb, struct sbp2_management_orb, base);
 444
 445         if (status)
 446                 memcpy(&orb->status, status, sizeof(*status));
 447         complete(&orb->done);
 448 }
 449
 450 static int
 451 sbp2_send_management_orb(struct sbp2_logical_unit *lu, int node_id,
 452                          int generation, int function, int lun_or_login_id,
 453                          void *response)
 454 {
 455         struct fw_device *device = fw_device(lu->tgt->unit->device.parent);
 456         struct sbp2_management_orb *orb;
 457         int retval = -ENOMEM;
 458
 459         orb = kzalloc(sizeof(*orb), GFP_ATOMIC);
 460         if (orb == NULL)
 461                 return -ENOMEM;
 462
 463         kref_init(&orb->base.kref);
 464         orb->response_bus =
 465                 dma_map_single(device->card->device, &orb->response,
 466                                sizeof(orb->response), DMA_FROM_DEVICE);
 467         if (dma_mapping_error(orb->response_bus))
 468                 goto fail_mapping_response;
 469
 470         orb->request.response.high    = 0;
 471         orb->request.response.low     = orb->response_bus;
 472
 473         orb->request.misc =
 474                 MANAGEMENT_ORB_NOTIFY |
 475                 MANAGEMENT_ORB_FUNCTION(function) |
 476                 MANAGEMENT_ORB_LUN(lun_or_login_id);
 477         orb->request.length =
 478                 MANAGEMENT_ORB_RESPONSE_LENGTH(sizeof(orb->response));
 479
 480         orb->request.status_fifo.high = lu->address_handler.offset >> 32;
 481         orb->request.status_fifo.low  = lu->address_handler.offset;
 482
 483         if (function == SBP2_LOGIN_REQUEST) {
 484                 orb->request.misc |=
 485                         MANAGEMENT_ORB_EXCLUSIVE(sbp2_param_exclusive_login) |
 486                         MANAGEMENT_ORB_RECONNECT(0);
 487         }
 488
 489         fw_memcpy_to_be32(&orb->request, &orb->request, sizeof(orb->request));
 490
 491         init_completion(&orb->done);
 492         orb->base.callback = complete_management_orb;
 493
 494         orb->base.request_bus =
 495                 dma_map_single(device->card->device, &orb->request,
 496                                sizeof(orb->request), DMA_TO_DEVICE);
 497         if (dma_mapping_error(orb->base.request_bus))
 498                 goto fail_mapping_request;
 499
 500         sbp2_send_orb(&orb->base, lu, node_id, generation,
 501                       lu->tgt->management_agent_address);
 502
 503         wait_for_completion_timeout(&orb->done,
 504                                     msecs_to_jiffies(SBP2_ORB_TIMEOUT));
 505
 506         retval = -EIO;
 507         if (sbp2_cancel_orbs(lu) == 0) {
 508                 fw_error("orb reply timed out, rcode=0x%02x\n",
 509                          orb->base.rcode);
 510                 goto out;
 511         }
 512
 513         if (orb->base.rcode != RCODE_COMPLETE) {
 514                 fw_error("management write failed, rcode 0x%02x\n",
 515                          orb->base.rcode);
 516                 goto out;
 517         }
 518
 519         if (STATUS_GET_RESPONSE(orb->status) != 0 ||
 520             STATUS_GET_SBP_STATUS(orb->status) != 0) {
 521                 fw_error("error status: %d:%d\n",
 522                          STATUS_GET_RESPONSE(orb->status),
 523                          STATUS_GET_SBP_STATUS(orb->status));
 524                 goto out;
 525         }
 526
 527         retval = 0;
 528  out:
 529         dma_unmap_single(device->card->device, orb->base.request_bus,
 530                          sizeof(orb->request), DMA_TO_DEVICE);
 531  fail_mapping_request:
 532         dma_unmap_single(device->card->device, orb->response_bus,
 533                          sizeof(orb->response), DMA_FROM_DEVICE);
 534  fail_mapping_response:
 535         if (response)
 536                 fw_memcpy_from_be32(response,
 537                                     orb->response, sizeof(orb->response));
 538         kref_put(&orb->base.kref, free_orb);
 539
 540         return retval;
 541 }
 542
 543 static void
 544 complete_agent_reset_write(struct fw_card *card, int rcode,
 545                            void *payload, size_t length, void *data)
 546 {
 547         struct fw_transaction *t = data;
 548
 549         kfree(t);
 550 }
 551
 552 static int sbp2_agent_reset(struct sbp2_logical_unit *lu)
 553 {
 554         struct fw_device *device = fw_device(lu->tgt->unit->device.parent);
 555         struct fw_transaction *t;
 556         static u32 zero;
 557
 558         t = kzalloc(sizeof(*t), GFP_ATOMIC);
 559         if (t == NULL)
 560                 return -ENOMEM;
 561
 562         fw_send_request(device->card, t, TCODE_WRITE_QUADLET_REQUEST,
 563                         lu->tgt->node_id, lu->generation, device->max_speed,
 564                         lu->command_block_agent_address + SBP2_AGENT_RESET,
 565                         &zero, sizeof(zero), complete_agent_reset_write, t);
 566
 567         return 0;
 568 }
 569
 570 static void sbp2_release_target(struct kref *kref)
 571 {
 572         struct sbp2_target *tgt = container_of(kref, struct sbp2_target, kref);
 573         struct sbp2_logical_unit *lu, *next;
 574         struct Scsi_Host *shost =
 575                 container_of((void *)tgt, struct Scsi_Host, hostdata[0]);
 576
 577         list_for_each_entry_safe(lu, next, &tgt->lu_list, link) {
 578                 if (lu->sdev)
 579                         scsi_remove_device(lu->sdev);
 580
 581                 sbp2_send_management_orb(lu, tgt->node_id, lu->generation,
 582                                 SBP2_LOGOUT_REQUEST, lu->login_id, NULL);
 583                 fw_core_remove_address_handler(&lu->address_handler);
 584                 list_del(&lu->link);
 585                 kfree(lu);
 586         }
 587         scsi_remove_host(shost);
 588         fw_notify("released %s\n", tgt->unit->device.bus_id);
 589
 590         put_device(&tgt->unit->device);
 591         scsi_host_put(shost);
 592 }
 593
 594 static void sbp2_reconnect(struct work_struct *work);
 595
 596 static void sbp2_login(struct work_struct *work)
 597 {
 598         struct sbp2_logical_unit *lu =
 599                 container_of(work, struct sbp2_logical_unit, work.work);
 600         struct Scsi_Host *shost =
 601                 container_of((void *)lu->tgt, struct Scsi_Host, hostdata[0]);
 602         struct scsi_device *sdev;
 603         struct scsi_lun eight_bytes_lun;
 604         struct fw_unit *unit = lu->tgt->unit;
 605         struct fw_device *device = fw_device(unit->device.parent);
 606         struct sbp2_login_response response;
 607         int generation, node_id, local_node_id;
 608
 609         generation    = device->card->generation;
 610         node_id       = device->node->node_id;
 611         local_node_id = device->card->local_node->node_id;
 612
 613         if (sbp2_send_management_orb(lu, node_id, generation,
 614                                 SBP2_LOGIN_REQUEST, lu->lun, &response) < 0) {
 615                 if (lu->retries++ < 5) {
 616                         schedule_delayed_work(&lu->work, DIV_ROUND_UP(HZ, 5));
 617                 } else {
 618                         fw_error("failed to login to %s LUN %04x\n",
 619                                  unit->device.bus_id, lu->lun);
 620                         kref_put(&lu->tgt->kref, sbp2_release_target);
 621                 }
 622                 return;
 623         }
 624
 625         lu->generation        = generation;
 626         lu->tgt->node_id      = node_id;
 627         lu->tgt->address_high = local_node_id << 16;
 628
 629         /* Get command block agent offset and login id. */
 630         lu->command_block_agent_address =
 631                 ((u64) (response.command_block_agent.high & 0xffff) << 32) |
 632                 response.command_block_agent.low;
 633         lu->login_id = LOGIN_RESPONSE_GET_LOGIN_ID(response);
 634
 635         fw_notify("logged in to %s LUN %04x (%d retries)\n",
 636                   unit->device.bus_id, lu->lun, lu->retries);
 637
 638 #if 0
 639         /* FIXME: The linux1394 sbp2 does this last step. */
 640         sbp2_set_busy_timeout(scsi_id);
 641 #endif
 642
 643         PREPARE_DELAYED_WORK(&lu->work, sbp2_reconnect);
 644         sbp2_agent_reset(lu);
 645
 646         memset(&eight_bytes_lun, 0, sizeof(eight_bytes_lun));
 647         eight_bytes_lun.scsi_lun[0] = (lu->lun >> 8) & 0xff;
 648         eight_bytes_lun.scsi_lun[1] = lu->lun & 0xff;
 649
 650         sdev = __scsi_add_device(shost, 0, 0,
 651                                  scsilun_to_int(&eight_bytes_lun), lu);
 652         if (IS_ERR(sdev)) {
 653                 sbp2_send_management_orb(lu, node_id, generation,
 654                                 SBP2_LOGOUT_REQUEST, lu->login_id, NULL);
 655                 /*
 656                  * Set this back to sbp2_login so we fall back and
 657                  * retry login on bus reset.
 658                  */
 659                 PREPARE_DELAYED_WORK(&lu->work, sbp2_login);
 660         } else {
 661                 lu->sdev = sdev;
 662                 scsi_device_put(sdev);
 663         }
 664         kref_put(&lu->tgt->kref, sbp2_release_target);
 665 }
 666
 667 static int sbp2_add_logical_unit(struct sbp2_target *tgt, int lun_entry)
 668 {
 669         struct sbp2_logical_unit *lu;
 670
 671         lu = kmalloc(sizeof(*lu), GFP_KERNEL);
 672         if (!lu)
 673                 return -ENOMEM;
 674
 675         lu->address_handler.length           = 0x100;
 676         lu->address_handler.address_callback = sbp2_status_write;
 677         lu->address_handler.callback_data    = lu;
 678
 679         if (fw_core_add_address_handler(&lu->address_handler,
 680                                         &fw_high_memory_region) < 0) {
 681                 kfree(lu);
 682                 return -ENOMEM;
 683         }
 684
 685         lu->tgt  = tgt;
 686         lu->sdev = NULL;
 687         lu->lun  = lun_entry & 0xffff;
 688         lu->retries = 0;
 689         INIT_LIST_HEAD(&lu->orb_list);
 690         INIT_DELAYED_WORK(&lu->work, sbp2_login);
 691
 692         list_add_tail(&lu->link, &tgt->lu_list);
 693         return 0;
 694 }
 695
 696 static int sbp2_scan_logical_unit_dir(struct sbp2_target *tgt, u32 *directory)
 697 {
 698         struct fw_csr_iterator ci;
 699         int key, value;
 700
 701         fw_csr_iterator_init(&ci, directory);
 702         while (fw_csr_iterator_next(&ci, &key, &value))
 703                 if (key == SBP2_CSR_LOGICAL_UNIT_NUMBER &&
 704                     sbp2_add_logical_unit(tgt, value) < 0)
 705                         return -ENOMEM;
 706         return 0;
 707 }
 708
 709 static int sbp2_scan_unit_dir(struct sbp2_target *tgt, u32 *directory,
 710                               u32 *model, u32 *firmware_revision)
 711 {
 712         struct fw_csr_iterator ci;
 713         int key, value;
 714
 715         fw_csr_iterator_init(&ci, directory);
 716         while (fw_csr_iterator_next(&ci, &key, &value)) {
 717                 switch (key) {
 718
 719                 case CSR_DEPENDENT_INFO | CSR_OFFSET:
 720                         tgt->management_agent_address =
 721                                         CSR_REGISTER_BASE + 4 * value;
 722                         break;
 723
 724                 case CSR_DIRECTORY_ID:
 725                         tgt->directory_id = value;
 726                         break;
 727
 728                 case CSR_MODEL:
 729                         *model = value;
 730                         break;
 731
 732                 case SBP2_CSR_FIRMWARE_REVISION:
 733                         *firmware_revision = value;
 734                         break;
 735
 736                 case SBP2_CSR_LOGICAL_UNIT_NUMBER:
 737                         if (sbp2_add_logical_unit(tgt, value) < 0)
 738                                 return -ENOMEM;
 739                         break;
 740
 741                 case SBP2_CSR_LOGICAL_UNIT_DIRECTORY:
 742                         if (sbp2_scan_logical_unit_dir(tgt, ci.p + value) < 0)
 743                                 return -ENOMEM;
 744                         break;
 745                 }
 746         }
 747         return 0;
 748 }
 749
 750 static void sbp2_init_workarounds(struct sbp2_target *tgt, u32 model,
 751                                   u32 firmware_revision)
 752 {
 753         int i;
 754
 755         tgt->workarounds = 0;
 756
 757         for (i = 0; i < ARRAY_SIZE(sbp2_workarounds_table); i++) {
 758
 759                 if (sbp2_workarounds_table[i].firmware_revision !=
 760                     (firmware_revision & 0xffffff00))
 761                         continue;
 762
 763                 if (sbp2_workarounds_table[i].model != model &&
 764                     sbp2_workarounds_table[i].model != ~0)
 765                         continue;
 766
 767                 tgt->workarounds |= sbp2_workarounds_table[i].workarounds;
 768                 break;
 769         }
 770
 771         if (tgt->workarounds)
 772                 fw_notify("Workarounds for %s: 0x%x "
 773                           "(firmware_revision 0x%06x, model_id 0x%06x)\n",
 774                           tgt->unit->device.bus_id,
 775                           tgt->workarounds, firmware_revision, model);
 776 }
 777
 778 static struct scsi_host_template scsi_driver_template;
 779
 780 static int sbp2_probe(struct device *dev)
 781 {
 782         struct fw_unit *unit = fw_unit(dev);
 783         struct fw_device *device = fw_device(unit->device.parent);
 784         struct sbp2_target *tgt;
 785         struct sbp2_logical_unit *lu;
 786         struct Scsi_Host *shost;
 787         u32 model, firmware_revision;
 788
 789         shost = scsi_host_alloc(&scsi_driver_template, sizeof(*tgt));
 790         if (shost == NULL)
 791                 return -ENOMEM;
 792
 793         tgt = (struct sbp2_target *)shost->hostdata;
 794         unit->device.driver_data = tgt;
 795         tgt->unit = unit;
 796         kref_init(&tgt->kref);
 797         INIT_LIST_HEAD(&tgt->lu_list);
 798
 799         if (fw_device_enable_phys_dma(device) < 0)
 800                 goto fail_shost_put;
 801
 802         if (scsi_add_host(shost, &unit->device) < 0)
 803                 goto fail_shost_put;
 804
 805         /* Initialize to values that won't match anything in our table. */
 806         firmware_revision = 0xff000000;
 807         model = 0xff000000;
 808
 809         /* implicit directory ID */
 810         tgt->directory_id = ((unit->directory - device->config_rom) * 4
 811                              + CSR_CONFIG_ROM) & 0xffffff;
 812
 813         if (sbp2_scan_unit_dir(tgt, unit->directory, &model,
 814                                &firmware_revision) < 0)
 815                 goto fail_tgt_put;
 816
 817         sbp2_init_workarounds(tgt, model, firmware_revision);
 818
 819         get_device(&unit->device);
 820
 821         /*
 822          * We schedule work to do the login so we can easily
 823          * reschedule retries. Always get the ref before scheduling
 824          * work.
 825          */
 826         list_for_each_entry(lu, &tgt->lu_list, link)
 827                 if (schedule_delayed_work(&lu->work, 0))
 828                         kref_get(&tgt->kref);
 829         return 0;
 830
 831  fail_tgt_put:
 832         kref_put(&tgt->kref, sbp2_release_target);
 833         return -ENOMEM;
 834
 835  fail_shost_put:
 836         scsi_host_put(shost);
 837         return -ENOMEM;
 838 }
 839
 840 static int sbp2_remove(struct device *dev)
 841 {
 842         struct fw_unit *unit = fw_unit(dev);
 843         struct sbp2_target *tgt = unit->device.driver_data;
 844
 845         kref_put(&tgt->kref, sbp2_release_target);
 846         return 0;
 847 }
 848
 849 static void sbp2_reconnect(struct work_struct *work)
 850 {
 851         struct sbp2_logical_unit *lu =
 852                 container_of(work, struct sbp2_logical_unit, work.work);
 853         struct fw_unit *unit = lu->tgt->unit;
 854         struct fw_device *device = fw_device(unit->device.parent);
 855         int generation, node_id, local_node_id;
 856
 857         generation    = device->card->generation;
 858         node_id       = device->node->node_id;
 859         local_node_id = device->card->local_node->node_id;
 860
 861         if (sbp2_send_management_orb(lu, node_id, generation,
 862                                      SBP2_RECONNECT_REQUEST,
 863                                      lu->login_id, NULL) < 0) {
 864                 if (lu->retries++ >= 5) {
 865                         fw_error("failed to reconnect to %s\n",
 866                                  unit->device.bus_id);
 867                         /* Fall back and try to log in again. */
 868                         lu->retries = 0;
 869                         PREPARE_DELAYED_WORK(&lu->work, sbp2_login);
 870                 }
 871                 schedule_delayed_work(&lu->work, DIV_ROUND_UP(HZ, 5));
 872                 return;
 873         }
 874
 875         lu->generation        = generation;
 876         lu->tgt->node_id      = node_id;
 877         lu->tgt->address_high = local_node_id << 16;
 878
 879         fw_notify("reconnected to %s LUN %04x (%d retries)\n",
 880                   unit->device.bus_id, lu->lun, lu->retries);
 881
 882         sbp2_agent_reset(lu);
 883         sbp2_cancel_orbs(lu);
 884
 885         kref_put(&lu->tgt->kref, sbp2_release_target);
 886 }
 887
 888 static void sbp2_update(struct fw_unit *unit)
 889 {
 890         struct sbp2_target *tgt = unit->device.driver_data;
 891         struct sbp2_logical_unit *lu;
 892
 893         fw_device_enable_phys_dma(fw_device(unit->device.parent));
 894
 895         /*
 896          * Fw-core serializes sbp2_update() against sbp2_remove().
 897          * Iteration over tgt->lu_list is therefore safe here.
 898          */
 899         list_for_each_entry(lu, &tgt->lu_list, link) {
 900                 lu->retries = 0;
 901                 if (schedule_delayed_work(&lu->work, 0))
 902                         kref_get(&tgt->kref);
 903         }
 904 }
 905
 906 #define SBP2_UNIT_SPEC_ID_ENTRY 0x0000609e
 907 #define SBP2_SW_VERSION_ENTRY   0x00010483
 908
 909 static const struct fw_device_id sbp2_id_table[] = {
 910         {
 911                 .match_flags  = FW_MATCH_SPECIFIER_ID | FW_MATCH_VERSION,
 912                 .specifier_id = SBP2_UNIT_SPEC_ID_ENTRY,
 913                 .version      = SBP2_SW_VERSION_ENTRY,
 914         },
 915         { }
 916 };
 917
 918 static struct fw_driver sbp2_driver = {
 919         .driver   = {
 920                 .owner  = THIS_MODULE,
 921                 .name   = sbp2_driver_name,
 922                 .bus    = &fw_bus_type,
 923                 .probe  = sbp2_probe,
 924                 .remove = sbp2_remove,
 925         },
 926         .update   = sbp2_update,
 927         .id_table = sbp2_id_table,
 928 };
 929
 930 static unsigned int
 931 sbp2_status_to_sense_data(u8 *sbp2_status, u8 *sense_data)
 932 {
 933         int sam_status;
 934
 935         sense_data[0] = 0x70;
 936         sense_data[1] = 0x0;
 937         sense_data[2] = sbp2_status[1];
 938         sense_data[3] = sbp2_status[4];
 939         sense_data[4] = sbp2_status[5];
 940         sense_data[5] = sbp2_status[6];
 941         sense_data[6] = sbp2_status[7];
 942         sense_data[7] = 10;
 943         sense_data[8] = sbp2_status[8];
 944         sense_data[9] = sbp2_status[9];
 945         sense_data[10] = sbp2_status[10];
 946         sense_data[11] = sbp2_status[11];
 947         sense_data[12] = sbp2_status[2];
 948         sense_data[13] = sbp2_status[3];
 949         sense_data[14] = sbp2_status[12];
 950         sense_data[15] = sbp2_status[13];
 951
 952         sam_status = sbp2_status[0] & 0x3f;
 953
 954         switch (sam_status) {
 955         case SAM_STAT_GOOD:
 956         case SAM_STAT_CHECK_CONDITION:
 957         case SAM_STAT_CONDITION_MET:
 958         case SAM_STAT_BUSY:
 959         case SAM_STAT_RESERVATION_CONFLICT:
 960         case SAM_STAT_COMMAND_TERMINATED:
 961                 return DID_OK << 16 | sam_status;
 962
 963         default:
 964                 return DID_ERROR << 16;
 965         }
 966 }
 967
 968 static void
 969 complete_command_orb(struct sbp2_orb *base_orb, struct sbp2_status *status)
 970 {
 971         struct sbp2_command_orb *orb =
 972                 container_of(base_orb, struct sbp2_command_orb, base);
 973         struct fw_device *device = fw_device(orb->lu->tgt->unit->device.parent);
 974         int result;
 975
 976         if (status != NULL) {
 977                 if (STATUS_GET_DEAD(*status))
 978                         sbp2_agent_reset(orb->lu);
 979
 980                 switch (STATUS_GET_RESPONSE(*status)) {
 981                 case SBP2_STATUS_REQUEST_COMPLETE:
 982                         result = DID_OK << 16;
 983                         break;
 984                 case SBP2_STATUS_TRANSPORT_FAILURE:
 985                         result = DID_BUS_BUSY << 16;
 986                         break;
 987                 case SBP2_STATUS_ILLEGAL_REQUEST:
 988                 case SBP2_STATUS_VENDOR_DEPENDENT:
 989                 default:
 990                         result = DID_ERROR << 16;
 991                         break;
 992                 }
 993
 994                 if (result == DID_OK << 16 && STATUS_GET_LEN(*status) > 1)
 995                         result = sbp2_status_to_sense_data(STATUS_GET_DATA(*status),
 996                                                            orb->cmd->sense_buffer);
 997         } else {
 998                 /*
 999                  * If the orb completes with status == NULL, something
1000                  * went wrong, typically a bus reset happened mid-orb
1001                  * or when sending the write (less likely).
1002                  */
1003                 result = DID_BUS_BUSY << 16;
1004         }
1005
1006         dma_unmap_single(device->card->device, orb->base.request_bus,
1007                          sizeof(orb->request), DMA_TO_DEVICE);
1008
1009         if (scsi_sg_count(orb->cmd) > 0)
1010                 dma_unmap_sg(device->card->device, scsi_sglist(orb->cmd),
1011                              scsi_sg_count(orb->cmd),
1012                              orb->cmd->sc_data_direction);
1013
1014         if (orb->page_table_bus != 0)
1015                 dma_unmap_single(device->card->device, orb->page_table_bus,
1016                                  sizeof(orb->page_table), DMA_TO_DEVICE);
1017
1018         orb->cmd->result = result;
1019         orb->done(orb->cmd);
1020 }
1021
1022 static int
1023 sbp2_map_scatterlist(struct sbp2_command_orb *orb, struct fw_device *device,
1024                      struct sbp2_logical_unit *lu)
1025 {
1026         struct scatterlist *sg;
1027         int sg_len, l, i, j, count;
1028         dma_addr_t sg_addr;
1029
1030         sg = scsi_sglist(orb->cmd);
1031         count = dma_map_sg(device->card->device, sg, scsi_sg_count(orb->cmd),
1032                            orb->cmd->sc_data_direction);
1033         if (count == 0)
1034                 goto fail;
1035
1036         /*
1037          * Handle the special case where there is only one element in
1038          * the scatter list by converting it to an immediate block
1039          * request. This is also a workaround for broken devices such
1040          * as the second generation iPod which doesn't support page
1041          * tables.
1042          */
1043         if (count == 1 && sg_dma_len(sg) < SBP2_MAX_SG_ELEMENT_LENGTH) {
1044                 orb->request.data_descriptor.high = lu->tgt->address_high;
1045                 orb->request.data_descriptor.low  = sg_dma_address(sg);
1046                 orb->request.misc |= COMMAND_ORB_DATA_SIZE(sg_dma_len(sg));
1047                 return 0;
1048         }
1049
1050         /*
1051          * Convert the scatterlist to an sbp2 page table.  If any
1052          * scatterlist entries are too big for sbp2, we split them as we
1053          * go.  Even if we ask the block I/O layer to not give us sg
1054          * elements larger than 65535 bytes, some IOMMUs may merge sg elements
1055          * during DMA mapping, and Linux currently doesn't prevent this.
1056          */
1057         for (i = 0, j = 0; i < count; i++) {
1058                 sg_len = sg_dma_len(sg + i);
1059                 sg_addr = sg_dma_address(sg + i);
1060                 while (sg_len) {
1061                         /* FIXME: This won't get us out of the pinch. */
1062                         if (unlikely(j >= ARRAY_SIZE(orb->page_table))) {
1063                                 fw_error("page table overflow\n");
1064                                 goto fail_page_table;
1065                         }
1066                         l = min(sg_len, SBP2_MAX_SG_ELEMENT_LENGTH);
1067                         orb->page_table[j].low = sg_addr;
1068                         orb->page_table[j].high = (l << 16);
1069                         sg_addr += l;
1070                         sg_len -= l;
1071                         j++;
1072                 }
1073         }
1074
1075         fw_memcpy_to_be32(orb->page_table, orb->page_table,
1076                           sizeof(orb->page_table[0]) * j);
1077         orb->page_table_bus =
1078                 dma_map_single(device->card->device, orb->page_table,
1079                                sizeof(orb->page_table), DMA_TO_DEVICE);
1080         if (dma_mapping_error(orb->page_table_bus))
1081                 goto fail_page_table;
1082
1083         /*
1084          * The data_descriptor pointer is the one case where we need
1085          * to fill in the node ID part of the address.  All other
1086          * pointers assume that the data referenced reside on the
1087          * initiator (i.e. us), but data_descriptor can refer to data
1088          * on other nodes so we need to put our ID in descriptor.high.
1089          */
1090         orb->request.data_descriptor.high = lu->tgt->address_high;
1091         orb->request.data_descriptor.low  = orb->page_table_bus;
1092         orb->request.misc |=
1093                 COMMAND_ORB_PAGE_TABLE_PRESENT |
1094                 COMMAND_ORB_DATA_SIZE(j);
1095
1096         return 0;
1097
1098  fail_page_table:
1099         dma_unmap_sg(device->card->device, sg, scsi_sg_count(orb->cmd),
1100                      orb->cmd->sc_data_direction);
1101  fail:
1102         return -ENOMEM;
1103 }
1104
1105 /* SCSI stack integration */
1106
1107 static int sbp2_scsi_queuecommand(struct scsi_cmnd *cmd, scsi_done_fn_t done)
1108 {
1109         struct sbp2_logical_unit *lu = cmd->device->hostdata;
1110         struct fw_device *device = fw_device(lu->tgt->unit->device.parent);
1111         struct sbp2_command_orb *orb;
1112         unsigned max_payload;
1113         int retval = SCSI_MLQUEUE_HOST_BUSY;
1114
1115         /*
1116          * Bidirectional commands are not yet implemented, and unknown
1117          * transfer direction not handled.
1118          */
1119         if (cmd->sc_data_direction == DMA_BIDIRECTIONAL) {
1120                 fw_error("Can't handle DMA_BIDIRECTIONAL, rejecting command\n");
1121                 cmd->result = DID_ERROR << 16;
1122                 done(cmd);
1123                 return 0;
1124         }
1125
1126         orb = kzalloc(sizeof(*orb), GFP_ATOMIC);
1127         if (orb == NULL) {
1128                 fw_notify("failed to alloc orb\n");
1129                 return SCSI_MLQUEUE_HOST_BUSY;
1130         }
1131
1132         /* Initialize rcode to something not RCODE_COMPLETE. */
1133         orb->base.rcode = -1;
1134         kref_init(&orb->base.kref);
1135
1136         orb->lu   = lu;
1137         orb->done = done;
1138         orb->cmd  = cmd;
1139
1140         orb->request.next.high   = SBP2_ORB_NULL;
1141         orb->request.next.low    = 0x0;
1142         /*
1143          * At speed 100 we can do 512 bytes per packet, at speed 200,
1144          * 1024 bytes per packet etc.  The SBP-2 max_payload field
1145          * specifies the max payload size as 2 ^ (max_payload + 2), so
1146          * if we set this to max_speed + 7, we get the right value.
1147          */
1148         max_payload = min(device->max_speed + 7,
1149                           device->card->max_receive - 1);
1150         orb->request.misc =
1151                 COMMAND_ORB_MAX_PAYLOAD(max_payload) |
1152                 COMMAND_ORB_SPEED(device->max_speed) |
1153                 COMMAND_ORB_NOTIFY;
1154
1155         if (cmd->sc_data_direction == DMA_FROM_DEVICE)
1156                 orb->request.misc |=
1157                         COMMAND_ORB_DIRECTION(SBP2_DIRECTION_FROM_MEDIA);
1158         else if (cmd->sc_data_direction == DMA_TO_DEVICE)
1159                 orb->request.misc |=
1160                         COMMAND_ORB_DIRECTION(SBP2_DIRECTION_TO_MEDIA);
1161
1162         if (scsi_sg_count(cmd) && sbp2_map_scatterlist(orb, device, lu) < 0)
1163                 goto out;
1164
1165         fw_memcpy_to_be32(&orb->request, &orb->request, sizeof(orb->request));
1166
1167         memset(orb->request.command_block,
1168                0, sizeof(orb->request.command_block));
1169         memcpy(orb->request.command_block, cmd->cmnd, COMMAND_SIZE(*cmd->cmnd));
1170
1171         orb->base.callback = complete_command_orb;
1172         orb->base.request_bus =
1173                 dma_map_single(device->card->device, &orb->request,
1174                                sizeof(orb->request), DMA_TO_DEVICE);
1175         if (dma_mapping_error(orb->base.request_bus))
1176                 goto out;
1177
1178         sbp2_send_orb(&orb->base, lu, lu->tgt->node_id, lu->generation,
1179                       lu->command_block_agent_address + SBP2_ORB_POINTER);
1180         retval = 0;
1181  out:
1182         kref_put(&orb->base.kref, free_orb);
1183         return retval;
1184 }
1185
1186 static int sbp2_scsi_slave_alloc(struct scsi_device *sdev)
1187 {
1188         struct sbp2_logical_unit *lu = sdev->hostdata;
1189
1190         sdev->allow_restart = 1;
1191
1192         if (lu->tgt->workarounds & SBP2_WORKAROUND_INQUIRY_36)
1193                 sdev->inquiry_len = 36;
1194
1195         return 0;
1196 }
1197
1198 static int sbp2_scsi_slave_configure(struct scsi_device *sdev)
1199 {
1200         struct sbp2_logical_unit *lu = sdev->hostdata;
1201
1202         sdev->use_10_for_rw = 1;
1203
1204         if (sdev->type == TYPE_ROM)
1205                 sdev->use_10_for_ms = 1;
1206
1207         if (sdev->type == TYPE_DISK &&
1208             lu->tgt->workarounds & SBP2_WORKAROUND_MODE_SENSE_8)
1209                 sdev->skip_ms_page_8 = 1;
1210
1211         if (lu->tgt->workarounds & SBP2_WORKAROUND_FIX_CAPACITY)
1212                 sdev->fix_capacity = 1;
1213
1214         if (lu->tgt->workarounds & SBP2_WORKAROUND_128K_MAX_TRANS)
1215                 blk_queue_max_sectors(sdev->request_queue, 128 * 1024 / 512);
1216
1217         return 0;
1218 }
1219
1220 /*
1221  * Called by scsi stack when something has really gone wrong.  Usually
1222  * called when a command has timed-out for some reason.
1223  */
1224 static int sbp2_scsi_abort(struct scsi_cmnd *cmd)
1225 {
1226         struct sbp2_logical_unit *lu = cmd->device->hostdata;
1227
1228         fw_notify("sbp2_scsi_abort\n");
1229         sbp2_agent_reset(lu);
1230         sbp2_cancel_orbs(lu);
1231
1232         return SUCCESS;
1233 }
1234
1235 /*
1236  * Format of /sys/bus/scsi/devices/.../ieee1394_id:
1237  * u64 EUI-64 : u24 directory_ID : u16 LUN  (all printed in hexadecimal)
1238  *
1239  * This is the concatenation of target port identifier and logical unit
1240  * identifier as per SAM-2...SAM-4 annex A.
1241  */
1242 static ssize_t
1243 sbp2_sysfs_ieee1394_id_show(struct device *dev, struct device_attribute *attr,
1244                             char *buf)
1245 {
1246         struct scsi_device *sdev = to_scsi_device(dev);
1247         struct sbp2_logical_unit *lu;
1248         struct fw_device *device;
1249
1250         if (!sdev)
1251                 return 0;
1252
1253         lu = sdev->hostdata;
1254         device = fw_device(lu->tgt->unit->device.parent);
1255
1256         return sprintf(buf, "%08x%08x:%06x:%04x\n",
1257                         device->config_rom[3], device->config_rom[4],
1258                         lu->tgt->directory_id, lu->lun);
1259 }
1260
1261 static DEVICE_ATTR(ieee1394_id, S_IRUGO, sbp2_sysfs_ieee1394_id_show, NULL);
1262
1263 static struct device_attribute *sbp2_scsi_sysfs_attrs[] = {
1264         &dev_attr_ieee1394_id,
1265         NULL
1266 };
1267
1268 static struct scsi_host_template scsi_driver_template = {
1269         .module                 = THIS_MODULE,
1270         .name                   = "SBP-2 IEEE-1394",
1271         .proc_name              = sbp2_driver_name,
1272         .queuecommand           = sbp2_scsi_queuecommand,
1273         .slave_alloc            = sbp2_scsi_slave_alloc,
1274         .slave_configure        = sbp2_scsi_slave_configure,
1275         .eh_abort_handler       = sbp2_scsi_abort,
1276         .this_id                = -1,
1277         .sg_tablesize           = SG_ALL,
1278         .use_clustering         = ENABLE_CLUSTERING,
1279         .cmd_per_lun            = 1,
1280         .can_queue              = 1,
1281         .sdev_attrs             = sbp2_scsi_sysfs_attrs,
1282 };
1283
1284 MODULE_AUTHOR("Kristian Hoegsberg <krh@bitplanet.net>");
1285 MODULE_DESCRIPTION("SCSI over IEEE1394");
1286 MODULE_LICENSE("GPL");
1287 MODULE_DEVICE_TABLE(ieee1394, sbp2_id_table);
1288
1289 /* Provide a module alias so root-on-sbp2 initrds don't break. */
1290 #ifndef CONFIG_IEEE1394_SBP2_MODULE
1291 MODULE_ALIAS("sbp2");
1292 #endif
1293
1294 static int __init sbp2_init(void)
1295 {
1296         return driver_register(&sbp2_driver.driver);
1297 }
1298
1299 static void __exit sbp2_cleanup(void)
1300 {
1301         driver_unregister(&sbp2_driver.driver);
1302 }
1303
1304 module_init(sbp2_init);
1305 module_exit(sbp2_cleanup);