linux/drivers/firewire/sbp2.c
<<
>>
Prefs
   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/blkdev.h>
  32#include <linux/bug.h>
  33#include <linux/completion.h>
  34#include <linux/delay.h>
  35#include <linux/device.h>
  36#include <linux/dma-mapping.h>
  37#include <linux/firewire.h>
  38#include <linux/firewire-constants.h>
  39#include <linux/init.h>
  40#include <linux/jiffies.h>
  41#include <linux/kernel.h>
  42#include <linux/kref.h>
  43#include <linux/list.h>
  44#include <linux/mod_devicetable.h>
  45#include <linux/module.h>
  46#include <linux/moduleparam.h>
  47#include <linux/scatterlist.h>
  48#include <linux/slab.h>
  49#include <linux/spinlock.h>
  50#include <linux/string.h>
  51#include <linux/stringify.h>
  52#include <linux/workqueue.h>
  53
  54#include <asm/byteorder.h>
  55
  56#include <scsi/scsi.h>
  57#include <scsi/scsi_cmnd.h>
  58#include <scsi/scsi_device.h>
  59#include <scsi/scsi_host.h>
  60
  61/*
  62 * So far only bridges from Oxford Semiconductor are known to support
  63 * concurrent logins. Depending on firmware, four or two concurrent logins
  64 * are possible on OXFW911 and newer Oxsemi bridges.
  65 *
  66 * Concurrent logins are useful together with cluster filesystems.
  67 */
  68static bool sbp2_param_exclusive_login = 1;
  69module_param_named(exclusive_login, sbp2_param_exclusive_login, bool, 0644);
  70MODULE_PARM_DESC(exclusive_login, "Exclusive login to sbp2 device "
  71                 "(default = Y, use N for concurrent initiators)");
  72
  73/*
  74 * Flags for firmware oddities
  75 *
  76 * - 128kB max transfer
  77 *   Limit transfer size. Necessary for some old bridges.
  78 *
  79 * - 36 byte inquiry
  80 *   When scsi_mod probes the device, let the inquiry command look like that
  81 *   from MS Windows.
  82 *
  83 * - skip mode page 8
  84 *   Suppress sending of mode_sense for mode page 8 if the device pretends to
  85 *   support the SCSI Primary Block commands instead of Reduced Block Commands.
  86 *
  87 * - fix capacity
  88 *   Tell sd_mod to correct the last sector number reported by read_capacity.
  89 *   Avoids access beyond actual disk limits on devices with an off-by-one bug.
  90 *   Don't use this with devices which don't have this bug.
  91 *
  92 * - delay inquiry
  93 *   Wait extra SBP2_INQUIRY_DELAY seconds after login before SCSI inquiry.
  94 *
  95 * - power condition
  96 *   Set the power condition field in the START STOP UNIT commands sent by
  97 *   sd_mod on suspend, resume, and shutdown (if manage_start_stop is on).
  98 *   Some disks need this to spin down or to resume properly.
  99 *
 100 * - override internal blacklist
 101 *   Instead of adding to the built-in blacklist, use only the workarounds
 102 *   specified in the module load parameter.
 103 *   Useful if a blacklist entry interfered with a non-broken device.
 104 */
 105#define SBP2_WORKAROUND_128K_MAX_TRANS  0x1
 106#define SBP2_WORKAROUND_INQUIRY_36      0x2
 107#define SBP2_WORKAROUND_MODE_SENSE_8    0x4
 108#define SBP2_WORKAROUND_FIX_CAPACITY    0x8
 109#define SBP2_WORKAROUND_DELAY_INQUIRY   0x10
 110#define SBP2_INQUIRY_DELAY              12
 111#define SBP2_WORKAROUND_POWER_CONDITION 0x20
 112#define SBP2_WORKAROUND_OVERRIDE        0x100
 113
 114static int sbp2_param_workarounds;
 115module_param_named(workarounds, sbp2_param_workarounds, int, 0644);
 116MODULE_PARM_DESC(workarounds, "Work around device bugs (default = 0"
 117        ", 128kB max transfer = " __stringify(SBP2_WORKAROUND_128K_MAX_TRANS)
 118        ", 36 byte inquiry = "    __stringify(SBP2_WORKAROUND_INQUIRY_36)
 119        ", skip mode page 8 = "   __stringify(SBP2_WORKAROUND_MODE_SENSE_8)
 120        ", fix capacity = "       __stringify(SBP2_WORKAROUND_FIX_CAPACITY)
 121        ", delay inquiry = "      __stringify(SBP2_WORKAROUND_DELAY_INQUIRY)
 122        ", set power condition in start stop unit = "
 123                                  __stringify(SBP2_WORKAROUND_POWER_CONDITION)
 124        ", override internal blacklist = " __stringify(SBP2_WORKAROUND_OVERRIDE)
 125        ", or a combination)");
 126
 127/*
 128 * We create one struct sbp2_logical_unit per SBP-2 Logical Unit Number Entry
 129 * and one struct scsi_device per sbp2_logical_unit.
 130 */
 131struct sbp2_logical_unit {
 132        struct sbp2_target *tgt;
 133        struct list_head link;
 134        struct fw_address_handler address_handler;
 135        struct list_head orb_list;
 136
 137        u64 command_block_agent_address;
 138        u16 lun;
 139        int login_id;
 140
 141        /*
 142         * The generation is updated once we've logged in or reconnected
 143         * to the logical unit.  Thus, I/O to the device will automatically
 144         * fail and get retried if it happens in a window where the device
 145         * is not ready, e.g. after a bus reset but before we reconnect.
 146         */
 147        int generation;
 148        int retries;
 149        struct delayed_work work;
 150        bool has_sdev;
 151        bool blocked;
 152};
 153
 154static void sbp2_queue_work(struct sbp2_logical_unit *lu, unsigned long delay)
 155{
 156        queue_delayed_work(fw_workqueue, &lu->work, delay);
 157}
 158
 159/*
 160 * We create one struct sbp2_target per IEEE 1212 Unit Directory
 161 * and one struct Scsi_Host per sbp2_target.
 162 */
 163struct sbp2_target {
 164        struct fw_unit *unit;
 165        struct list_head lu_list;
 166
 167        u64 management_agent_address;
 168        u64 guid;
 169        int directory_id;
 170        int node_id;
 171        int address_high;
 172        unsigned int workarounds;
 173        unsigned int mgt_orb_timeout;
 174        unsigned int max_payload;
 175
 176        int dont_block; /* counter for each logical unit */
 177        int blocked;    /* ditto */
 178};
 179
 180static struct fw_device *target_parent_device(struct sbp2_target *tgt)
 181{
 182        return fw_parent_device(tgt->unit);
 183}
 184
 185static const struct device *tgt_dev(const struct sbp2_target *tgt)
 186{
 187        return &tgt->unit->device;
 188}
 189
 190static const struct device *lu_dev(const struct sbp2_logical_unit *lu)
 191{
 192        return &lu->tgt->unit->device;
 193}
 194
 195/* Impossible login_id, to detect logout attempt before successful login */
 196#define INVALID_LOGIN_ID 0x10000
 197
 198#define SBP2_ORB_TIMEOUT                2000U           /* Timeout in ms */
 199#define SBP2_ORB_NULL                   0x80000000
 200#define SBP2_RETRY_LIMIT                0xf             /* 15 retries */
 201#define SBP2_CYCLE_LIMIT                (0xc8 << 12)    /* 200 125us cycles */
 202
 203/*
 204 * There is no transport protocol limit to the CDB length,  but we implement
 205 * a fixed length only.  16 bytes is enough for disks larger than 2 TB.
 206 */
 207#define SBP2_MAX_CDB_SIZE               16
 208
 209/*
 210 * The maximum SBP-2 data buffer size is 0xffff.  We quadlet-align this
 211 * for compatibility with earlier versions of this driver.
 212 */
 213#define SBP2_MAX_SEG_SIZE               0xfffc
 214
 215/* Unit directory keys */
 216#define SBP2_CSR_UNIT_CHARACTERISTICS   0x3a
 217#define SBP2_CSR_FIRMWARE_REVISION      0x3c
 218#define SBP2_CSR_LOGICAL_UNIT_NUMBER    0x14
 219#define SBP2_CSR_UNIT_UNIQUE_ID         0x8d
 220#define SBP2_CSR_LOGICAL_UNIT_DIRECTORY 0xd4
 221
 222/* Management orb opcodes */
 223#define SBP2_LOGIN_REQUEST              0x0
 224#define SBP2_QUERY_LOGINS_REQUEST       0x1
 225#define SBP2_RECONNECT_REQUEST          0x3
 226#define SBP2_SET_PASSWORD_REQUEST       0x4
 227#define SBP2_LOGOUT_REQUEST             0x7
 228#define SBP2_ABORT_TASK_REQUEST         0xb
 229#define SBP2_ABORT_TASK_SET             0xc
 230#define SBP2_LOGICAL_UNIT_RESET         0xe
 231#define SBP2_TARGET_RESET_REQUEST       0xf
 232
 233/* Offsets for command block agent registers */
 234#define SBP2_AGENT_STATE                0x00
 235#define SBP2_AGENT_RESET                0x04
 236#define SBP2_ORB_POINTER                0x08
 237#define SBP2_DOORBELL                   0x10
 238#define SBP2_UNSOLICITED_STATUS_ENABLE  0x14
 239
 240/* Status write response codes */
 241#define SBP2_STATUS_REQUEST_COMPLETE    0x0
 242#define SBP2_STATUS_TRANSPORT_FAILURE   0x1
 243#define SBP2_STATUS_ILLEGAL_REQUEST     0x2
 244#define SBP2_STATUS_VENDOR_DEPENDENT    0x3
 245
 246#define STATUS_GET_ORB_HIGH(v)          ((v).status & 0xffff)
 247#define STATUS_GET_SBP_STATUS(v)        (((v).status >> 16) & 0xff)
 248#define STATUS_GET_LEN(v)               (((v).status >> 24) & 0x07)
 249#define STATUS_GET_DEAD(v)              (((v).status >> 27) & 0x01)
 250#define STATUS_GET_RESPONSE(v)          (((v).status >> 28) & 0x03)
 251#define STATUS_GET_SOURCE(v)            (((v).status >> 30) & 0x03)
 252#define STATUS_GET_ORB_LOW(v)           ((v).orb_low)
 253#define STATUS_GET_DATA(v)              ((v).data)
 254
 255struct sbp2_status {
 256        u32 status;
 257        u32 orb_low;
 258        u8 data[24];
 259};
 260
 261struct sbp2_pointer {
 262        __be32 high;
 263        __be32 low;
 264};
 265
 266struct sbp2_orb {
 267        struct fw_transaction t;
 268        struct kref kref;
 269        dma_addr_t request_bus;
 270        int rcode;
 271        void (*callback)(struct sbp2_orb * orb, struct sbp2_status * status);
 272        struct list_head link;
 273};
 274
 275#define MANAGEMENT_ORB_LUN(v)                   ((v))
 276#define MANAGEMENT_ORB_FUNCTION(v)              ((v) << 16)
 277#define MANAGEMENT_ORB_RECONNECT(v)             ((v) << 20)
 278#define MANAGEMENT_ORB_EXCLUSIVE(v)             ((v) ? 1 << 28 : 0)
 279#define MANAGEMENT_ORB_REQUEST_FORMAT(v)        ((v) << 29)
 280#define MANAGEMENT_ORB_NOTIFY                   ((1) << 31)
 281
 282#define MANAGEMENT_ORB_RESPONSE_LENGTH(v)       ((v))
 283#define MANAGEMENT_ORB_PASSWORD_LENGTH(v)       ((v) << 16)
 284
 285struct sbp2_management_orb {
 286        struct sbp2_orb base;
 287        struct {
 288                struct sbp2_pointer password;
 289                struct sbp2_pointer response;
 290                __be32 misc;
 291                __be32 length;
 292                struct sbp2_pointer status_fifo;
 293        } request;
 294        __be32 response[4];
 295        dma_addr_t response_bus;
 296        struct completion done;
 297        struct sbp2_status status;
 298};
 299
 300struct sbp2_login_response {
 301        __be32 misc;
 302        struct sbp2_pointer command_block_agent;
 303        __be32 reconnect_hold;
 304};
 305#define COMMAND_ORB_DATA_SIZE(v)        ((v))
 306#define COMMAND_ORB_PAGE_SIZE(v)        ((v) << 16)
 307#define COMMAND_ORB_PAGE_TABLE_PRESENT  ((1) << 19)
 308#define COMMAND_ORB_MAX_PAYLOAD(v)      ((v) << 20)
 309#define COMMAND_ORB_SPEED(v)            ((v) << 24)
 310#define COMMAND_ORB_DIRECTION           ((1) << 27)
 311#define COMMAND_ORB_REQUEST_FORMAT(v)   ((v) << 29)
 312#define COMMAND_ORB_NOTIFY              ((1) << 31)
 313
 314struct sbp2_command_orb {
 315        struct sbp2_orb base;
 316        struct {
 317                struct sbp2_pointer next;
 318                struct sbp2_pointer data_descriptor;
 319                __be32 misc;
 320                u8 command_block[SBP2_MAX_CDB_SIZE];
 321        } request;
 322        struct scsi_cmnd *cmd;
 323        struct sbp2_logical_unit *lu;
 324
 325        struct sbp2_pointer page_table[SG_ALL] __attribute__((aligned(8)));
 326        dma_addr_t page_table_bus;
 327};
 328
 329#define SBP2_ROM_VALUE_WILDCARD ~0         /* match all */
 330#define SBP2_ROM_VALUE_MISSING  0xff000000 /* not present in the unit dir. */
 331
 332/*
 333 * List of devices with known bugs.
 334 *
 335 * The firmware_revision field, masked with 0xffff00, is the best
 336 * indicator for the type of bridge chip of a device.  It yields a few
 337 * false positives but this did not break correctly behaving devices
 338 * so far.
 339 */
 340static const struct {
 341        u32 firmware_revision;
 342        u32 model;
 343        unsigned int workarounds;
 344} sbp2_workarounds_table[] = {
 345        /* DViCO Momobay CX-1 with TSB42AA9 bridge */ {
 346                .firmware_revision      = 0x002800,
 347                .model                  = 0x001010,
 348                .workarounds            = SBP2_WORKAROUND_INQUIRY_36 |
 349                                          SBP2_WORKAROUND_MODE_SENSE_8 |
 350                                          SBP2_WORKAROUND_POWER_CONDITION,
 351        },
 352        /* DViCO Momobay FX-3A with TSB42AA9A bridge */ {
 353                .firmware_revision      = 0x002800,
 354                .model                  = 0x000000,
 355                .workarounds            = SBP2_WORKAROUND_POWER_CONDITION,
 356        },
 357        /* Initio bridges, actually only needed for some older ones */ {
 358                .firmware_revision      = 0x000200,
 359                .model                  = SBP2_ROM_VALUE_WILDCARD,
 360                .workarounds            = SBP2_WORKAROUND_INQUIRY_36,
 361        },
 362        /* PL-3507 bridge with Prolific firmware */ {
 363                .firmware_revision      = 0x012800,
 364                .model                  = SBP2_ROM_VALUE_WILDCARD,
 365                .workarounds            = SBP2_WORKAROUND_POWER_CONDITION,
 366        },
 367        /* Symbios bridge */ {
 368                .firmware_revision      = 0xa0b800,
 369                .model                  = SBP2_ROM_VALUE_WILDCARD,
 370                .workarounds            = SBP2_WORKAROUND_128K_MAX_TRANS,
 371        },
 372        /* Datafab MD2-FW2 with Symbios/LSILogic SYM13FW500 bridge */ {
 373                .firmware_revision      = 0x002600,
 374                .model                  = SBP2_ROM_VALUE_WILDCARD,
 375                .workarounds            = SBP2_WORKAROUND_128K_MAX_TRANS,
 376        },
 377        /*
 378         * iPod 2nd generation: needs 128k max transfer size workaround
 379         * iPod 3rd generation: needs fix capacity workaround
 380         */
 381        {
 382                .firmware_revision      = 0x0a2700,
 383                .model                  = 0x000000,
 384                .workarounds            = SBP2_WORKAROUND_128K_MAX_TRANS |
 385                                          SBP2_WORKAROUND_FIX_CAPACITY,
 386        },
 387        /* iPod 4th generation */ {
 388                .firmware_revision      = 0x0a2700,
 389                .model                  = 0x000021,
 390                .workarounds            = SBP2_WORKAROUND_FIX_CAPACITY,
 391        },
 392        /* iPod mini */ {
 393                .firmware_revision      = 0x0a2700,
 394                .model                  = 0x000022,
 395                .workarounds            = SBP2_WORKAROUND_FIX_CAPACITY,
 396        },
 397        /* iPod mini */ {
 398                .firmware_revision      = 0x0a2700,
 399                .model                  = 0x000023,
 400                .workarounds            = SBP2_WORKAROUND_FIX_CAPACITY,
 401        },
 402        /* iPod Photo */ {
 403                .firmware_revision      = 0x0a2700,
 404                .model                  = 0x00007e,
 405                .workarounds            = SBP2_WORKAROUND_FIX_CAPACITY,
 406        }
 407};
 408
 409static void free_orb(struct kref *kref)
 410{
 411        struct sbp2_orb *orb = container_of(kref, struct sbp2_orb, kref);
 412
 413        kfree(orb);
 414}
 415
 416static void sbp2_status_write(struct fw_card *card, struct fw_request *request,
 417                              int tcode, int destination, int source,
 418                              int generation, unsigned long long offset,
 419                              void *payload, size_t length, void *callback_data)
 420{
 421        struct sbp2_logical_unit *lu = callback_data;
 422        struct sbp2_orb *orb;
 423        struct sbp2_status status;
 424        unsigned long flags;
 425
 426        if (tcode != TCODE_WRITE_BLOCK_REQUEST ||
 427            length < 8 || length > sizeof(status)) {
 428                fw_send_response(card, request, RCODE_TYPE_ERROR);
 429                return;
 430        }
 431
 432        status.status  = be32_to_cpup(payload);
 433        status.orb_low = be32_to_cpup(payload + 4);
 434        memset(status.data, 0, sizeof(status.data));
 435        if (length > 8)
 436                memcpy(status.data, payload + 8, length - 8);
 437
 438        if (STATUS_GET_SOURCE(status) == 2 || STATUS_GET_SOURCE(status) == 3) {
 439                dev_notice(lu_dev(lu),
 440                           "non-ORB related status write, not handled\n");
 441                fw_send_response(card, request, RCODE_COMPLETE);
 442                return;
 443        }
 444
 445        /* Lookup the orb corresponding to this status write. */
 446        spin_lock_irqsave(&card->lock, flags);
 447        list_for_each_entry(orb, &lu->orb_list, link) {
 448                if (STATUS_GET_ORB_HIGH(status) == 0 &&
 449                    STATUS_GET_ORB_LOW(status) == orb->request_bus) {
 450                        orb->rcode = RCODE_COMPLETE;
 451                        list_del(&orb->link);
 452                        break;
 453                }
 454        }
 455        spin_unlock_irqrestore(&card->lock, flags);
 456
 457        if (&orb->link != &lu->orb_list) {
 458                orb->callback(orb, &status);
 459                kref_put(&orb->kref, free_orb); /* orb callback reference */
 460        } else {
 461                dev_err(lu_dev(lu), "status write for unknown ORB\n");
 462        }
 463
 464        fw_send_response(card, request, RCODE_COMPLETE);
 465}
 466
 467static void complete_transaction(struct fw_card *card, int rcode,
 468                                 void *payload, size_t length, void *data)
 469{
 470        struct sbp2_orb *orb = data;
 471        unsigned long flags;
 472
 473        /*
 474         * This is a little tricky.  We can get the status write for
 475         * the orb before we get this callback.  The status write
 476         * handler above will assume the orb pointer transaction was
 477         * successful and set the rcode to RCODE_COMPLETE for the orb.
 478         * So this callback only sets the rcode if it hasn't already
 479         * been set and only does the cleanup if the transaction
 480         * failed and we didn't already get a status write.
 481         */
 482        spin_lock_irqsave(&card->lock, flags);
 483
 484        if (orb->rcode == -1)
 485                orb->rcode = rcode;
 486        if (orb->rcode != RCODE_COMPLETE) {
 487                list_del(&orb->link);
 488                spin_unlock_irqrestore(&card->lock, flags);
 489
 490                orb->callback(orb, NULL);
 491                kref_put(&orb->kref, free_orb); /* orb callback reference */
 492        } else {
 493                spin_unlock_irqrestore(&card->lock, flags);
 494        }
 495
 496        kref_put(&orb->kref, free_orb); /* transaction callback reference */
 497}
 498
 499static void sbp2_send_orb(struct sbp2_orb *orb, struct sbp2_logical_unit *lu,
 500                          int node_id, int generation, u64 offset)
 501{
 502        struct fw_device *device = target_parent_device(lu->tgt);
 503        struct sbp2_pointer orb_pointer;
 504        unsigned long flags;
 505
 506        orb_pointer.high = 0;
 507        orb_pointer.low = cpu_to_be32(orb->request_bus);
 508
 509        spin_lock_irqsave(&device->card->lock, flags);
 510        list_add_tail(&orb->link, &lu->orb_list);
 511        spin_unlock_irqrestore(&device->card->lock, flags);
 512
 513        kref_get(&orb->kref); /* transaction callback reference */
 514        kref_get(&orb->kref); /* orb callback reference */
 515
 516        fw_send_request(device->card, &orb->t, TCODE_WRITE_BLOCK_REQUEST,
 517                        node_id, generation, device->max_speed, offset,
 518                        &orb_pointer, 8, complete_transaction, orb);
 519}
 520
 521static int sbp2_cancel_orbs(struct sbp2_logical_unit *lu)
 522{
 523        struct fw_device *device = target_parent_device(lu->tgt);
 524        struct sbp2_orb *orb, *next;
 525        struct list_head list;
 526        unsigned long flags;
 527        int retval = -ENOENT;
 528
 529        INIT_LIST_HEAD(&list);
 530        spin_lock_irqsave(&device->card->lock, flags);
 531        list_splice_init(&lu->orb_list, &list);
 532        spin_unlock_irqrestore(&device->card->lock, flags);
 533
 534        list_for_each_entry_safe(orb, next, &list, link) {
 535                retval = 0;
 536                if (fw_cancel_transaction(device->card, &orb->t) == 0)
 537                        continue;
 538
 539                orb->rcode = RCODE_CANCELLED;
 540                orb->callback(orb, NULL);
 541                kref_put(&orb->kref, free_orb); /* orb callback reference */
 542        }
 543
 544        return retval;
 545}
 546
 547static void complete_management_orb(struct sbp2_orb *base_orb,
 548                                    struct sbp2_status *status)
 549{
 550        struct sbp2_management_orb *orb =
 551                container_of(base_orb, struct sbp2_management_orb, base);
 552
 553        if (status)
 554                memcpy(&orb->status, status, sizeof(*status));
 555        complete(&orb->done);
 556}
 557
 558static int sbp2_send_management_orb(struct sbp2_logical_unit *lu, int node_id,
 559                                    int generation, int function,
 560                                    int lun_or_login_id, void *response)
 561{
 562        struct fw_device *device = target_parent_device(lu->tgt);
 563        struct sbp2_management_orb *orb;
 564        unsigned int timeout;
 565        int retval = -ENOMEM;
 566
 567        if (function == SBP2_LOGOUT_REQUEST && fw_device_is_shutdown(device))
 568                return 0;
 569
 570        orb = kzalloc(sizeof(*orb), GFP_NOIO);
 571        if (orb == NULL)
 572                return -ENOMEM;
 573
 574        kref_init(&orb->base.kref);
 575        orb->response_bus =
 576                dma_map_single(device->card->device, &orb->response,
 577                               sizeof(orb->response), DMA_FROM_DEVICE);
 578        if (dma_mapping_error(device->card->device, orb->response_bus))
 579                goto fail_mapping_response;
 580
 581        orb->request.response.high = 0;
 582        orb->request.response.low  = cpu_to_be32(orb->response_bus);
 583
 584        orb->request.misc = cpu_to_be32(
 585                MANAGEMENT_ORB_NOTIFY |
 586                MANAGEMENT_ORB_FUNCTION(function) |
 587                MANAGEMENT_ORB_LUN(lun_or_login_id));
 588        orb->request.length = cpu_to_be32(
 589                MANAGEMENT_ORB_RESPONSE_LENGTH(sizeof(orb->response)));
 590
 591        orb->request.status_fifo.high =
 592                cpu_to_be32(lu->address_handler.offset >> 32);
 593        orb->request.status_fifo.low  =
 594                cpu_to_be32(lu->address_handler.offset);
 595
 596        if (function == SBP2_LOGIN_REQUEST) {
 597                /* Ask for 2^2 == 4 seconds reconnect grace period */
 598                orb->request.misc |= cpu_to_be32(
 599                        MANAGEMENT_ORB_RECONNECT(2) |
 600                        MANAGEMENT_ORB_EXCLUSIVE(sbp2_param_exclusive_login));
 601                timeout = lu->tgt->mgt_orb_timeout;
 602        } else {
 603                timeout = SBP2_ORB_TIMEOUT;
 604        }
 605
 606        init_completion(&orb->done);
 607        orb->base.callback = complete_management_orb;
 608
 609        orb->base.request_bus =
 610                dma_map_single(device->card->device, &orb->request,
 611                               sizeof(orb->request), DMA_TO_DEVICE);
 612        if (dma_mapping_error(device->card->device, orb->base.request_bus))
 613                goto fail_mapping_request;
 614
 615        sbp2_send_orb(&orb->base, lu, node_id, generation,
 616                      lu->tgt->management_agent_address);
 617
 618        wait_for_completion_timeout(&orb->done, msecs_to_jiffies(timeout));
 619
 620        retval = -EIO;
 621        if (sbp2_cancel_orbs(lu) == 0) {
 622                dev_err(lu_dev(lu), "ORB reply timed out, rcode 0x%02x\n",
 623                        orb->base.rcode);
 624                goto out;
 625        }
 626
 627        if (orb->base.rcode != RCODE_COMPLETE) {
 628                dev_err(lu_dev(lu), "management write failed, rcode 0x%02x\n",
 629                        orb->base.rcode);
 630                goto out;
 631        }
 632
 633        if (STATUS_GET_RESPONSE(orb->status) != 0 ||
 634            STATUS_GET_SBP_STATUS(orb->status) != 0) {
 635                dev_err(lu_dev(lu), "error status: %d:%d\n",
 636                         STATUS_GET_RESPONSE(orb->status),
 637                         STATUS_GET_SBP_STATUS(orb->status));
 638                goto out;
 639        }
 640
 641        retval = 0;
 642 out:
 643        dma_unmap_single(device->card->device, orb->base.request_bus,
 644                         sizeof(orb->request), DMA_TO_DEVICE);
 645 fail_mapping_request:
 646        dma_unmap_single(device->card->device, orb->response_bus,
 647                         sizeof(orb->response), DMA_FROM_DEVICE);
 648 fail_mapping_response:
 649        if (response)
 650                memcpy(response, orb->response, sizeof(orb->response));
 651        kref_put(&orb->base.kref, free_orb);
 652
 653        return retval;
 654}
 655
 656static void sbp2_agent_reset(struct sbp2_logical_unit *lu)
 657{
 658        struct fw_device *device = target_parent_device(lu->tgt);
 659        __be32 d = 0;
 660
 661        fw_run_transaction(device->card, TCODE_WRITE_QUADLET_REQUEST,
 662                           lu->tgt->node_id, lu->generation, device->max_speed,
 663                           lu->command_block_agent_address + SBP2_AGENT_RESET,
 664                           &d, 4);
 665}
 666
 667static void complete_agent_reset_write_no_wait(struct fw_card *card,
 668                int rcode, void *payload, size_t length, void *data)
 669{
 670        kfree(data);
 671}
 672
 673static void sbp2_agent_reset_no_wait(struct sbp2_logical_unit *lu)
 674{
 675        struct fw_device *device = target_parent_device(lu->tgt);
 676        struct fw_transaction *t;
 677        static __be32 d;
 678
 679        t = kmalloc(sizeof(*t), GFP_ATOMIC);
 680        if (t == NULL)
 681                return;
 682
 683        fw_send_request(device->card, t, TCODE_WRITE_QUADLET_REQUEST,
 684                        lu->tgt->node_id, lu->generation, device->max_speed,
 685                        lu->command_block_agent_address + SBP2_AGENT_RESET,
 686                        &d, 4, complete_agent_reset_write_no_wait, t);
 687}
 688
 689static inline void sbp2_allow_block(struct sbp2_logical_unit *lu)
 690{
 691        /*
 692         * We may access dont_block without taking card->lock here:
 693         * All callers of sbp2_allow_block() and all callers of sbp2_unblock()
 694         * are currently serialized against each other.
 695         * And a wrong result in sbp2_conditionally_block()'s access of
 696         * dont_block is rather harmless, it simply misses its first chance.
 697         */
 698        --lu->tgt->dont_block;
 699}
 700
 701/*
 702 * Blocks lu->tgt if all of the following conditions are met:
 703 *   - Login, INQUIRY, and high-level SCSI setup of all of the target's
 704 *     logical units have been finished (indicated by dont_block == 0).
 705 *   - lu->generation is stale.
 706 *
 707 * Note, scsi_block_requests() must be called while holding card->lock,
 708 * otherwise it might foil sbp2_[conditionally_]unblock()'s attempt to
 709 * unblock the target.
 710 */
 711static void sbp2_conditionally_block(struct sbp2_logical_unit *lu)
 712{
 713        struct sbp2_target *tgt = lu->tgt;
 714        struct fw_card *card = target_parent_device(tgt)->card;
 715        struct Scsi_Host *shost =
 716                container_of((void *)tgt, struct Scsi_Host, hostdata[0]);
 717        unsigned long flags;
 718
 719        spin_lock_irqsave(&card->lock, flags);
 720        if (!tgt->dont_block && !lu->blocked &&
 721            lu->generation != card->generation) {
 722                lu->blocked = true;
 723                if (++tgt->blocked == 1)
 724                        scsi_block_requests(shost);
 725        }
 726        spin_unlock_irqrestore(&card->lock, flags);
 727}
 728
 729/*
 730 * Unblocks lu->tgt as soon as all its logical units can be unblocked.
 731 * Note, it is harmless to run scsi_unblock_requests() outside the
 732 * card->lock protected section.  On the other hand, running it inside
 733 * the section might clash with shost->host_lock.
 734 */
 735static void sbp2_conditionally_unblock(struct sbp2_logical_unit *lu)
 736{
 737        struct sbp2_target *tgt = lu->tgt;
 738        struct fw_card *card = target_parent_device(tgt)->card;
 739        struct Scsi_Host *shost =
 740                container_of((void *)tgt, struct Scsi_Host, hostdata[0]);
 741        unsigned long flags;
 742        bool unblock = false;
 743
 744        spin_lock_irqsave(&card->lock, flags);
 745        if (lu->blocked && lu->generation == card->generation) {
 746                lu->blocked = false;
 747                unblock = --tgt->blocked == 0;
 748        }
 749        spin_unlock_irqrestore(&card->lock, flags);
 750
 751        if (unblock)
 752                scsi_unblock_requests(shost);
 753}
 754
 755/*
 756 * Prevents future blocking of tgt and unblocks it.
 757 * Note, it is harmless to run scsi_unblock_requests() outside the
 758 * card->lock protected section.  On the other hand, running it inside
 759 * the section might clash with shost->host_lock.
 760 */
 761static void sbp2_unblock(struct sbp2_target *tgt)
 762{
 763        struct fw_card *card = target_parent_device(tgt)->card;
 764        struct Scsi_Host *shost =
 765                container_of((void *)tgt, struct Scsi_Host, hostdata[0]);
 766        unsigned long flags;
 767
 768        spin_lock_irqsave(&card->lock, flags);
 769        ++tgt->dont_block;
 770        spin_unlock_irqrestore(&card->lock, flags);
 771
 772        scsi_unblock_requests(shost);
 773}
 774
 775static int sbp2_lun2int(u16 lun)
 776{
 777        struct scsi_lun eight_bytes_lun;
 778
 779        memset(&eight_bytes_lun, 0, sizeof(eight_bytes_lun));
 780        eight_bytes_lun.scsi_lun[0] = (lun >> 8) & 0xff;
 781        eight_bytes_lun.scsi_lun[1] = lun & 0xff;
 782
 783        return scsilun_to_int(&eight_bytes_lun);
 784}
 785
 786/*
 787 * Write retransmit retry values into the BUSY_TIMEOUT register.
 788 * - The single-phase retry protocol is supported by all SBP-2 devices, but the
 789 *   default retry_limit value is 0 (i.e. never retry transmission). We write a
 790 *   saner value after logging into the device.
 791 * - The dual-phase retry protocol is optional to implement, and if not
 792 *   supported, writes to the dual-phase portion of the register will be
 793 *   ignored. We try to write the original 1394-1995 default here.
 794 * - In the case of devices that are also SBP-3-compliant, all writes are
 795 *   ignored, as the register is read-only, but contains single-phase retry of
 796 *   15, which is what we're trying to set for all SBP-2 device anyway, so this
 797 *   write attempt is safe and yields more consistent behavior for all devices.
 798 *
 799 * See section 8.3.2.3.5 of the 1394-1995 spec, section 6.2 of the SBP-2 spec,
 800 * and section 6.4 of the SBP-3 spec for further details.
 801 */
 802static void sbp2_set_busy_timeout(struct sbp2_logical_unit *lu)
 803{
 804        struct fw_device *device = target_parent_device(lu->tgt);
 805        __be32 d = cpu_to_be32(SBP2_CYCLE_LIMIT | SBP2_RETRY_LIMIT);
 806
 807        fw_run_transaction(device->card, TCODE_WRITE_QUADLET_REQUEST,
 808                           lu->tgt->node_id, lu->generation, device->max_speed,
 809                           CSR_REGISTER_BASE + CSR_BUSY_TIMEOUT, &d, 4);
 810}
 811
 812static void sbp2_reconnect(struct work_struct *work);
 813
 814static void sbp2_login(struct work_struct *work)
 815{
 816        struct sbp2_logical_unit *lu =
 817                container_of(work, struct sbp2_logical_unit, work.work);
 818        struct sbp2_target *tgt = lu->tgt;
 819        struct fw_device *device = target_parent_device(tgt);
 820        struct Scsi_Host *shost;
 821        struct scsi_device *sdev;
 822        struct sbp2_login_response response;
 823        int generation, node_id, local_node_id;
 824
 825        if (fw_device_is_shutdown(device))
 826                return;
 827
 828        generation    = device->generation;
 829        smp_rmb();    /* node IDs must not be older than generation */
 830        node_id       = device->node_id;
 831        local_node_id = device->card->node_id;
 832
 833        /* If this is a re-login attempt, log out, or we might be rejected. */
 834        if (lu->has_sdev)
 835                sbp2_send_management_orb(lu, device->node_id, generation,
 836                                SBP2_LOGOUT_REQUEST, lu->login_id, NULL);
 837
 838        if (sbp2_send_management_orb(lu, node_id, generation,
 839                                SBP2_LOGIN_REQUEST, lu->lun, &response) < 0) {
 840                if (lu->retries++ < 5) {
 841                        sbp2_queue_work(lu, DIV_ROUND_UP(HZ, 5));
 842                } else {
 843                        dev_err(tgt_dev(tgt), "failed to login to LUN %04x\n",
 844                                lu->lun);
 845                        /* Let any waiting I/O fail from now on. */
 846                        sbp2_unblock(lu->tgt);
 847                }
 848                return;
 849        }
 850
 851        tgt->node_id      = node_id;
 852        tgt->address_high = local_node_id << 16;
 853        smp_wmb();        /* node IDs must not be older than generation */
 854        lu->generation    = generation;
 855
 856        lu->command_block_agent_address =
 857                ((u64)(be32_to_cpu(response.command_block_agent.high) & 0xffff)
 858                      << 32) | be32_to_cpu(response.command_block_agent.low);
 859        lu->login_id = be32_to_cpu(response.misc) & 0xffff;
 860
 861        dev_notice(tgt_dev(tgt), "logged in to LUN %04x (%d retries)\n",
 862                   lu->lun, lu->retries);
 863
 864        /* set appropriate retry limit(s) in BUSY_TIMEOUT register */
 865        sbp2_set_busy_timeout(lu);
 866
 867        PREPARE_DELAYED_WORK(&lu->work, sbp2_reconnect);
 868        sbp2_agent_reset(lu);
 869
 870        /* This was a re-login. */
 871        if (lu->has_sdev) {
 872                sbp2_cancel_orbs(lu);
 873                sbp2_conditionally_unblock(lu);
 874
 875                return;
 876        }
 877
 878        if (lu->tgt->workarounds & SBP2_WORKAROUND_DELAY_INQUIRY)
 879                ssleep(SBP2_INQUIRY_DELAY);
 880
 881        shost = container_of((void *)tgt, struct Scsi_Host, hostdata[0]);
 882        sdev = __scsi_add_device(shost, 0, 0, sbp2_lun2int(lu->lun), lu);
 883        /*
 884         * FIXME:  We are unable to perform reconnects while in sbp2_login().
 885         * Therefore __scsi_add_device() will get into trouble if a bus reset
 886         * happens in parallel.  It will either fail or leave us with an
 887         * unusable sdev.  As a workaround we check for this and retry the
 888         * whole login and SCSI probing.
 889         */
 890
 891        /* Reported error during __scsi_add_device() */
 892        if (IS_ERR(sdev))
 893                goto out_logout_login;
 894
 895        /* Unreported error during __scsi_add_device() */
 896        smp_rmb(); /* get current card generation */
 897        if (generation != device->card->generation) {
 898                scsi_remove_device(sdev);
 899                scsi_device_put(sdev);
 900                goto out_logout_login;
 901        }
 902
 903        /* No error during __scsi_add_device() */
 904        lu->has_sdev = true;
 905        scsi_device_put(sdev);
 906        sbp2_allow_block(lu);
 907
 908        return;
 909
 910 out_logout_login:
 911        smp_rmb(); /* generation may have changed */
 912        generation = device->generation;
 913        smp_rmb(); /* node_id must not be older than generation */
 914
 915        sbp2_send_management_orb(lu, device->node_id, generation,
 916                                 SBP2_LOGOUT_REQUEST, lu->login_id, NULL);
 917        /*
 918         * If a bus reset happened, sbp2_update will have requeued
 919         * lu->work already.  Reset the work from reconnect to login.
 920         */
 921        PREPARE_DELAYED_WORK(&lu->work, sbp2_login);
 922}
 923
 924static void sbp2_reconnect(struct work_struct *work)
 925{
 926        struct sbp2_logical_unit *lu =
 927                container_of(work, struct sbp2_logical_unit, work.work);
 928        struct sbp2_target *tgt = lu->tgt;
 929        struct fw_device *device = target_parent_device(tgt);
 930        int generation, node_id, local_node_id;
 931
 932        if (fw_device_is_shutdown(device))
 933                return;
 934
 935        generation    = device->generation;
 936        smp_rmb();    /* node IDs must not be older than generation */
 937        node_id       = device->node_id;
 938        local_node_id = device->card->node_id;
 939
 940        if (sbp2_send_management_orb(lu, node_id, generation,
 941                                     SBP2_RECONNECT_REQUEST,
 942                                     lu->login_id, NULL) < 0) {
 943                /*
 944                 * If reconnect was impossible even though we are in the
 945                 * current generation, fall back and try to log in again.
 946                 *
 947                 * We could check for "Function rejected" status, but
 948                 * looking at the bus generation as simpler and more general.
 949                 */
 950                smp_rmb(); /* get current card generation */
 951                if (generation == device->card->generation ||
 952                    lu->retries++ >= 5) {
 953                        dev_err(tgt_dev(tgt), "failed to reconnect\n");
 954                        lu->retries = 0;
 955                        PREPARE_DELAYED_WORK(&lu->work, sbp2_login);
 956                }
 957                sbp2_queue_work(lu, DIV_ROUND_UP(HZ, 5));
 958
 959                return;
 960        }
 961
 962        tgt->node_id      = node_id;
 963        tgt->address_high = local_node_id << 16;
 964        smp_wmb();        /* node IDs must not be older than generation */
 965        lu->generation    = generation;
 966
 967        dev_notice(tgt_dev(tgt), "reconnected to LUN %04x (%d retries)\n",
 968                   lu->lun, lu->retries);
 969
 970        sbp2_agent_reset(lu);
 971        sbp2_cancel_orbs(lu);
 972        sbp2_conditionally_unblock(lu);
 973}
 974
 975static int sbp2_add_logical_unit(struct sbp2_target *tgt, int lun_entry)
 976{
 977        struct sbp2_logical_unit *lu;
 978
 979        lu = kmalloc(sizeof(*lu), GFP_KERNEL);
 980        if (!lu)
 981                return -ENOMEM;
 982
 983        lu->address_handler.length           = 0x100;
 984        lu->address_handler.address_callback = sbp2_status_write;
 985        lu->address_handler.callback_data    = lu;
 986
 987        if (fw_core_add_address_handler(&lu->address_handler,
 988                                        &fw_high_memory_region) < 0) {
 989                kfree(lu);
 990                return -ENOMEM;
 991        }
 992
 993        lu->tgt      = tgt;
 994        lu->lun      = lun_entry & 0xffff;
 995        lu->login_id = INVALID_LOGIN_ID;
 996        lu->retries  = 0;
 997        lu->has_sdev = false;
 998        lu->blocked  = false;
 999        ++tgt->dont_block;
1000        INIT_LIST_HEAD(&lu->orb_list);
1001        INIT_DELAYED_WORK(&lu->work, sbp2_login);
1002
1003        list_add_tail(&lu->link, &tgt->lu_list);
1004        return 0;
1005}
1006
1007static void sbp2_get_unit_unique_id(struct sbp2_target *tgt,
1008                                    const u32 *leaf)
1009{
1010        if ((leaf[0] & 0xffff0000) == 0x00020000)
1011                tgt->guid = (u64)leaf[1] << 32 | leaf[2];
1012}
1013
1014static int sbp2_scan_logical_unit_dir(struct sbp2_target *tgt,
1015                                      const u32 *directory)
1016{
1017        struct fw_csr_iterator ci;
1018        int key, value;
1019
1020        fw_csr_iterator_init(&ci, directory);
1021        while (fw_csr_iterator_next(&ci, &key, &value))
1022                if (key == SBP2_CSR_LOGICAL_UNIT_NUMBER &&
1023                    sbp2_add_logical_unit(tgt, value) < 0)
1024                        return -ENOMEM;
1025        return 0;
1026}
1027
1028static int sbp2_scan_unit_dir(struct sbp2_target *tgt, const u32 *directory,
1029                              u32 *model, u32 *firmware_revision)
1030{
1031        struct fw_csr_iterator ci;
1032        int key, value;
1033
1034        fw_csr_iterator_init(&ci, directory);
1035        while (fw_csr_iterator_next(&ci, &key, &value)) {
1036                switch (key) {
1037
1038                case CSR_DEPENDENT_INFO | CSR_OFFSET:
1039                        tgt->management_agent_address =
1040                                        CSR_REGISTER_BASE + 4 * value;
1041                        break;
1042
1043                case CSR_DIRECTORY_ID:
1044                        tgt->directory_id = value;
1045                        break;
1046
1047                case CSR_MODEL:
1048                        *model = value;
1049                        break;
1050
1051                case SBP2_CSR_FIRMWARE_REVISION:
1052                        *firmware_revision = value;
1053                        break;
1054
1055                case SBP2_CSR_UNIT_CHARACTERISTICS:
1056                        /* the timeout value is stored in 500ms units */
1057                        tgt->mgt_orb_timeout = (value >> 8 & 0xff) * 500;
1058                        break;
1059
1060                case SBP2_CSR_LOGICAL_UNIT_NUMBER:
1061                        if (sbp2_add_logical_unit(tgt, value) < 0)
1062                                return -ENOMEM;
1063                        break;
1064
1065                case SBP2_CSR_UNIT_UNIQUE_ID:
1066                        sbp2_get_unit_unique_id(tgt, ci.p - 1 + value);
1067                        break;
1068
1069                case SBP2_CSR_LOGICAL_UNIT_DIRECTORY:
1070                        /* Adjust for the increment in the iterator */
1071                        if (sbp2_scan_logical_unit_dir(tgt, ci.p - 1 + value) < 0)
1072                                return -ENOMEM;
1073                        break;
1074                }
1075        }
1076        return 0;
1077}
1078
1079/*
1080 * Per section 7.4.8 of the SBP-2 spec, a mgt_ORB_timeout value can be
1081 * provided in the config rom. Most devices do provide a value, which
1082 * we'll use for login management orbs, but with some sane limits.
1083 */
1084static void sbp2_clamp_management_orb_timeout(struct sbp2_target *tgt)
1085{
1086        unsigned int timeout = tgt->mgt_orb_timeout;
1087
1088        if (timeout > 40000)
1089                dev_notice(tgt_dev(tgt), "%ds mgt_ORB_timeout limited to 40s\n",
1090                           timeout / 1000);
1091
1092        tgt->mgt_orb_timeout = clamp_val(timeout, 5000, 40000);
1093}
1094
1095static void sbp2_init_workarounds(struct sbp2_target *tgt, u32 model,
1096                                  u32 firmware_revision)
1097{
1098        int i;
1099        unsigned int w = sbp2_param_workarounds;
1100
1101        if (w)
1102                dev_notice(tgt_dev(tgt),
1103                           "Please notify linux1394-devel@lists.sf.net "
1104                           "if you need the workarounds parameter\n");
1105
1106        if (w & SBP2_WORKAROUND_OVERRIDE)
1107                goto out;
1108
1109        for (i = 0; i < ARRAY_SIZE(sbp2_workarounds_table); i++) {
1110
1111                if (sbp2_workarounds_table[i].firmware_revision !=
1112                    (firmware_revision & 0xffffff00))
1113                        continue;
1114
1115                if (sbp2_workarounds_table[i].model != model &&
1116                    sbp2_workarounds_table[i].model != SBP2_ROM_VALUE_WILDCARD)
1117                        continue;
1118
1119                w |= sbp2_workarounds_table[i].workarounds;
1120                break;
1121        }
1122 out:
1123        if (w)
1124                dev_notice(tgt_dev(tgt), "workarounds 0x%x "
1125                           "(firmware_revision 0x%06x, model_id 0x%06x)\n",
1126                           w, firmware_revision, model);
1127        tgt->workarounds = w;
1128}
1129
1130static struct scsi_host_template scsi_driver_template;
1131static int sbp2_remove(struct device *dev);
1132
1133static int sbp2_probe(struct device *dev)
1134{
1135        struct fw_unit *unit = fw_unit(dev);
1136        struct fw_device *device = fw_parent_device(unit);
1137        struct sbp2_target *tgt;
1138        struct sbp2_logical_unit *lu;
1139        struct Scsi_Host *shost;
1140        u32 model, firmware_revision;
1141
1142        /* cannot (or should not) handle targets on the local node */
1143        if (device->is_local)
1144                return -ENODEV;
1145
1146        if (dma_get_max_seg_size(device->card->device) > SBP2_MAX_SEG_SIZE)
1147                BUG_ON(dma_set_max_seg_size(device->card->device,
1148                                            SBP2_MAX_SEG_SIZE));
1149
1150        shost = scsi_host_alloc(&scsi_driver_template, sizeof(*tgt));
1151        if (shost == NULL)
1152                return -ENOMEM;
1153
1154        tgt = (struct sbp2_target *)shost->hostdata;
1155        dev_set_drvdata(&unit->device, tgt);
1156        tgt->unit = unit;
1157        INIT_LIST_HEAD(&tgt->lu_list);
1158        tgt->guid = (u64)device->config_rom[3] << 32 | device->config_rom[4];
1159
1160        if (fw_device_enable_phys_dma(device) < 0)
1161                goto fail_shost_put;
1162
1163        shost->max_cmd_len = SBP2_MAX_CDB_SIZE;
1164
1165        if (scsi_add_host_with_dma(shost, &unit->device,
1166                                   device->card->device) < 0)
1167                goto fail_shost_put;
1168
1169        /* implicit directory ID */
1170        tgt->directory_id = ((unit->directory - device->config_rom) * 4
1171                             + CSR_CONFIG_ROM) & 0xffffff;
1172
1173        firmware_revision = SBP2_ROM_VALUE_MISSING;
1174        model             = SBP2_ROM_VALUE_MISSING;
1175
1176        if (sbp2_scan_unit_dir(tgt, unit->directory, &model,
1177                               &firmware_revision) < 0)
1178                goto fail_remove;
1179
1180        sbp2_clamp_management_orb_timeout(tgt);
1181        sbp2_init_workarounds(tgt, model, firmware_revision);
1182
1183        /*
1184         * At S100 we can do 512 bytes per packet, at S200 1024 bytes,
1185         * and so on up to 4096 bytes.  The SBP-2 max_payload field
1186         * specifies the max payload size as 2 ^ (max_payload + 2), so
1187         * if we set this to max_speed + 7, we get the right value.
1188         */
1189        tgt->max_payload = min3(device->max_speed + 7, 10U,
1190                                device->card->max_receive - 1);
1191
1192        /* Do the login in a workqueue so we can easily reschedule retries. */
1193        list_for_each_entry(lu, &tgt->lu_list, link)
1194                sbp2_queue_work(lu, DIV_ROUND_UP(HZ, 5));
1195
1196        return 0;
1197
1198 fail_remove:
1199        sbp2_remove(dev);
1200        return -ENOMEM;
1201
1202 fail_shost_put:
1203        scsi_host_put(shost);
1204        return -ENOMEM;
1205}
1206
1207static void sbp2_update(struct fw_unit *unit)
1208{
1209        struct sbp2_target *tgt = dev_get_drvdata(&unit->device);
1210        struct sbp2_logical_unit *lu;
1211
1212        fw_device_enable_phys_dma(fw_parent_device(unit));
1213
1214        /*
1215         * Fw-core serializes sbp2_update() against sbp2_remove().
1216         * Iteration over tgt->lu_list is therefore safe here.
1217         */
1218        list_for_each_entry(lu, &tgt->lu_list, link) {
1219                sbp2_conditionally_block(lu);
1220                lu->retries = 0;
1221                sbp2_queue_work(lu, 0);
1222        }
1223}
1224
1225static int sbp2_remove(struct device *dev)
1226{
1227        struct fw_unit *unit = fw_unit(dev);
1228        struct fw_device *device = fw_parent_device(unit);
1229        struct sbp2_target *tgt = dev_get_drvdata(&unit->device);
1230        struct sbp2_logical_unit *lu, *next;
1231        struct Scsi_Host *shost =
1232                container_of((void *)tgt, struct Scsi_Host, hostdata[0]);
1233        struct scsi_device *sdev;
1234
1235        /* prevent deadlocks */
1236        sbp2_unblock(tgt);
1237
1238        list_for_each_entry_safe(lu, next, &tgt->lu_list, link) {
1239                cancel_delayed_work_sync(&lu->work);
1240                sdev = scsi_device_lookup(shost, 0, 0, sbp2_lun2int(lu->lun));
1241                if (sdev) {
1242                        scsi_remove_device(sdev);
1243                        scsi_device_put(sdev);
1244                }
1245                if (lu->login_id != INVALID_LOGIN_ID) {
1246                        int generation, node_id;
1247                        /*
1248                         * tgt->node_id may be obsolete here if we failed
1249                         * during initial login or after a bus reset where
1250                         * the topology changed.
1251                         */
1252                        generation = device->generation;
1253                        smp_rmb(); /* node_id vs. generation */
1254                        node_id    = device->node_id;
1255                        sbp2_send_management_orb(lu, node_id, generation,
1256                                                 SBP2_LOGOUT_REQUEST,
1257                                                 lu->login_id, NULL);
1258                }
1259                fw_core_remove_address_handler(&lu->address_handler);
1260                list_del(&lu->link);
1261                kfree(lu);
1262        }
1263        scsi_remove_host(shost);
1264        dev_notice(dev, "released target %d:0:0\n", shost->host_no);
1265
1266        scsi_host_put(shost);
1267        return 0;
1268}
1269
1270#define SBP2_UNIT_SPEC_ID_ENTRY 0x0000609e
1271#define SBP2_SW_VERSION_ENTRY   0x00010483
1272
1273static const struct ieee1394_device_id sbp2_id_table[] = {
1274        {
1275                .match_flags  = IEEE1394_MATCH_SPECIFIER_ID |
1276                                IEEE1394_MATCH_VERSION,
1277                .specifier_id = SBP2_UNIT_SPEC_ID_ENTRY,
1278                .version      = SBP2_SW_VERSION_ENTRY,
1279        },
1280        { }
1281};
1282
1283static struct fw_driver sbp2_driver = {
1284        .driver   = {
1285                .owner  = THIS_MODULE,
1286                .name   = KBUILD_MODNAME,
1287                .bus    = &fw_bus_type,
1288                .probe  = sbp2_probe,
1289                .remove = sbp2_remove,
1290        },
1291        .update   = sbp2_update,
1292        .id_table = sbp2_id_table,
1293};
1294
1295static void sbp2_unmap_scatterlist(struct device *card_device,
1296                                   struct sbp2_command_orb *orb)
1297{
1298        scsi_dma_unmap(orb->cmd);
1299
1300        if (orb->request.misc & cpu_to_be32(COMMAND_ORB_PAGE_TABLE_PRESENT))
1301                dma_unmap_single(card_device, orb->page_table_bus,
1302                                 sizeof(orb->page_table), DMA_TO_DEVICE);
1303}
1304
1305static unsigned int sbp2_status_to_sense_data(u8 *sbp2_status, u8 *sense_data)
1306{
1307        int sam_status;
1308        int sfmt = (sbp2_status[0] >> 6) & 0x03;
1309
1310        if (sfmt == 2 || sfmt == 3) {
1311                /*
1312                 * Reserved for future standardization (2) or
1313                 * Status block format vendor-dependent (3)
1314                 */
1315                return DID_ERROR << 16;
1316        }
1317
1318        sense_data[0] = 0x70 | sfmt | (sbp2_status[1] & 0x80);
1319        sense_data[1] = 0x0;
1320        sense_data[2] = ((sbp2_status[1] << 1) & 0xe0) | (sbp2_status[1] & 0x0f);
1321        sense_data[3] = sbp2_status[4];
1322        sense_data[4] = sbp2_status[5];
1323        sense_data[5] = sbp2_status[6];
1324        sense_data[6] = sbp2_status[7];
1325        sense_data[7] = 10;
1326        sense_data[8] = sbp2_status[8];
1327        sense_data[9] = sbp2_status[9];
1328        sense_data[10] = sbp2_status[10];
1329        sense_data[11] = sbp2_status[11];
1330        sense_data[12] = sbp2_status[2];
1331        sense_data[13] = sbp2_status[3];
1332        sense_data[14] = sbp2_status[12];
1333        sense_data[15] = sbp2_status[13];
1334
1335        sam_status = sbp2_status[0] & 0x3f;
1336
1337        switch (sam_status) {
1338        case SAM_STAT_GOOD:
1339        case SAM_STAT_CHECK_CONDITION:
1340        case SAM_STAT_CONDITION_MET:
1341        case SAM_STAT_BUSY:
1342        case SAM_STAT_RESERVATION_CONFLICT:
1343        case SAM_STAT_COMMAND_TERMINATED:
1344                return DID_OK << 16 | sam_status;
1345
1346        default:
1347                return DID_ERROR << 16;
1348        }
1349}
1350
1351static void complete_command_orb(struct sbp2_orb *base_orb,
1352                                 struct sbp2_status *status)
1353{
1354        struct sbp2_command_orb *orb =
1355                container_of(base_orb, struct sbp2_command_orb, base);
1356        struct fw_device *device = target_parent_device(orb->lu->tgt);
1357        int result;
1358
1359        if (status != NULL) {
1360                if (STATUS_GET_DEAD(*status))
1361                        sbp2_agent_reset_no_wait(orb->lu);
1362
1363                switch (STATUS_GET_RESPONSE(*status)) {
1364                case SBP2_STATUS_REQUEST_COMPLETE:
1365                        result = DID_OK << 16;
1366                        break;
1367                case SBP2_STATUS_TRANSPORT_FAILURE:
1368                        result = DID_BUS_BUSY << 16;
1369                        break;
1370                case SBP2_STATUS_ILLEGAL_REQUEST:
1371                case SBP2_STATUS_VENDOR_DEPENDENT:
1372                default:
1373                        result = DID_ERROR << 16;
1374                        break;
1375                }
1376
1377                if (result == DID_OK << 16 && STATUS_GET_LEN(*status) > 1)
1378                        result = sbp2_status_to_sense_data(STATUS_GET_DATA(*status),
1379                                                           orb->cmd->sense_buffer);
1380        } else {
1381                /*
1382                 * If the orb completes with status == NULL, something
1383                 * went wrong, typically a bus reset happened mid-orb
1384                 * or when sending the write (less likely).
1385                 */
1386                result = DID_BUS_BUSY << 16;
1387                sbp2_conditionally_block(orb->lu);
1388        }
1389
1390        dma_unmap_single(device->card->device, orb->base.request_bus,
1391                         sizeof(orb->request), DMA_TO_DEVICE);
1392        sbp2_unmap_scatterlist(device->card->device, orb);
1393
1394        orb->cmd->result = result;
1395        orb->cmd->scsi_done(orb->cmd);
1396}
1397
1398static int sbp2_map_scatterlist(struct sbp2_command_orb *orb,
1399                struct fw_device *device, struct sbp2_logical_unit *lu)
1400{
1401        struct scatterlist *sg = scsi_sglist(orb->cmd);
1402        int i, n;
1403
1404        n = scsi_dma_map(orb->cmd);
1405        if (n <= 0)
1406                goto fail;
1407
1408        /*
1409         * Handle the special case where there is only one element in
1410         * the scatter list by converting it to an immediate block
1411         * request. This is also a workaround for broken devices such
1412         * as the second generation iPod which doesn't support page
1413         * tables.
1414         */
1415        if (n == 1) {
1416                orb->request.data_descriptor.high =
1417                        cpu_to_be32(lu->tgt->address_high);
1418                orb->request.data_descriptor.low  =
1419                        cpu_to_be32(sg_dma_address(sg));
1420                orb->request.misc |=
1421                        cpu_to_be32(COMMAND_ORB_DATA_SIZE(sg_dma_len(sg)));
1422                return 0;
1423        }
1424
1425        for_each_sg(sg, sg, n, i) {
1426                orb->page_table[i].high = cpu_to_be32(sg_dma_len(sg) << 16);
1427                orb->page_table[i].low = cpu_to_be32(sg_dma_address(sg));
1428        }
1429
1430        orb->page_table_bus =
1431                dma_map_single(device->card->device, orb->page_table,
1432                               sizeof(orb->page_table), DMA_TO_DEVICE);
1433        if (dma_mapping_error(device->card->device, orb->page_table_bus))
1434                goto fail_page_table;
1435
1436        /*
1437         * The data_descriptor pointer is the one case where we need
1438         * to fill in the node ID part of the address.  All other
1439         * pointers assume that the data referenced reside on the
1440         * initiator (i.e. us), but data_descriptor can refer to data
1441         * on other nodes so we need to put our ID in descriptor.high.
1442         */
1443        orb->request.data_descriptor.high = cpu_to_be32(lu->tgt->address_high);
1444        orb->request.data_descriptor.low  = cpu_to_be32(orb->page_table_bus);
1445        orb->request.misc |= cpu_to_be32(COMMAND_ORB_PAGE_TABLE_PRESENT |
1446                                         COMMAND_ORB_DATA_SIZE(n));
1447
1448        return 0;
1449
1450 fail_page_table:
1451        scsi_dma_unmap(orb->cmd);
1452 fail:
1453        return -ENOMEM;
1454}
1455
1456/* SCSI stack integration */
1457
1458static int sbp2_scsi_queuecommand(struct Scsi_Host *shost,
1459                                  struct scsi_cmnd *cmd)
1460{
1461        struct sbp2_logical_unit *lu = cmd->device->hostdata;
1462        struct fw_device *device = target_parent_device(lu->tgt);
1463        struct sbp2_command_orb *orb;
1464        int generation, retval = SCSI_MLQUEUE_HOST_BUSY;
1465
1466        /*
1467         * Bidirectional commands are not yet implemented, and unknown
1468         * transfer direction not handled.
1469         */
1470        if (cmd->sc_data_direction == DMA_BIDIRECTIONAL) {
1471                dev_err(lu_dev(lu), "cannot handle bidirectional command\n");
1472                cmd->result = DID_ERROR << 16;
1473                cmd->scsi_done(cmd);
1474                return 0;
1475        }
1476
1477        orb = kzalloc(sizeof(*orb), GFP_ATOMIC);
1478        if (orb == NULL) {
1479                dev_notice(lu_dev(lu), "failed to alloc ORB\n");
1480                return SCSI_MLQUEUE_HOST_BUSY;
1481        }
1482
1483        /* Initialize rcode to something not RCODE_COMPLETE. */
1484        orb->base.rcode = -1;
1485        kref_init(&orb->base.kref);
1486        orb->lu = lu;
1487        orb->cmd = cmd;
1488        orb->request.next.high = cpu_to_be32(SBP2_ORB_NULL);
1489        orb->request.misc = cpu_to_be32(
1490                COMMAND_ORB_MAX_PAYLOAD(lu->tgt->max_payload) |
1491                COMMAND_ORB_SPEED(device->max_speed) |
1492                COMMAND_ORB_NOTIFY);
1493
1494        if (cmd->sc_data_direction == DMA_FROM_DEVICE)
1495                orb->request.misc |= cpu_to_be32(COMMAND_ORB_DIRECTION);
1496
1497        generation = device->generation;
1498        smp_rmb();    /* sbp2_map_scatterlist looks at tgt->address_high */
1499
1500        if (scsi_sg_count(cmd) && sbp2_map_scatterlist(orb, device, lu) < 0)
1501                goto out;
1502
1503        memcpy(orb->request.command_block, cmd->cmnd, cmd->cmd_len);
1504
1505        orb->base.callback = complete_command_orb;
1506        orb->base.request_bus =
1507                dma_map_single(device->card->device, &orb->request,
1508                               sizeof(orb->request), DMA_TO_DEVICE);
1509        if (dma_mapping_error(device->card->device, orb->base.request_bus)) {
1510                sbp2_unmap_scatterlist(device->card->device, orb);
1511                goto out;
1512        }
1513
1514        sbp2_send_orb(&orb->base, lu, lu->tgt->node_id, generation,
1515                      lu->command_block_agent_address + SBP2_ORB_POINTER);
1516        retval = 0;
1517 out:
1518        kref_put(&orb->base.kref, free_orb);
1519        return retval;
1520}
1521
1522static int sbp2_scsi_slave_alloc(struct scsi_device *sdev)
1523{
1524        struct sbp2_logical_unit *lu = sdev->hostdata;
1525
1526        /* (Re-)Adding logical units via the SCSI stack is not supported. */
1527        if (!lu)
1528                return -ENOSYS;
1529
1530        sdev->allow_restart = 1;
1531
1532        /*
1533         * SBP-2 does not require any alignment, but we set it anyway
1534         * for compatibility with earlier versions of this driver.
1535         */
1536        blk_queue_update_dma_alignment(sdev->request_queue, 4 - 1);
1537
1538        if (lu->tgt->workarounds & SBP2_WORKAROUND_INQUIRY_36)
1539                sdev->inquiry_len = 36;
1540
1541        return 0;
1542}
1543
1544static int sbp2_scsi_slave_configure(struct scsi_device *sdev)
1545{
1546        struct sbp2_logical_unit *lu = sdev->hostdata;
1547
1548        sdev->use_10_for_rw = 1;
1549
1550        if (sbp2_param_exclusive_login)
1551                sdev->manage_start_stop = 1;
1552
1553        if (sdev->type == TYPE_ROM)
1554                sdev->use_10_for_ms = 1;
1555
1556        if (sdev->type == TYPE_DISK &&
1557            lu->tgt->workarounds & SBP2_WORKAROUND_MODE_SENSE_8)
1558                sdev->skip_ms_page_8 = 1;
1559
1560        if (lu->tgt->workarounds & SBP2_WORKAROUND_FIX_CAPACITY)
1561                sdev->fix_capacity = 1;
1562
1563        if (lu->tgt->workarounds & SBP2_WORKAROUND_POWER_CONDITION)
1564                sdev->start_stop_pwr_cond = 1;
1565
1566        if (lu->tgt->workarounds & SBP2_WORKAROUND_128K_MAX_TRANS)
1567                blk_queue_max_hw_sectors(sdev->request_queue, 128 * 1024 / 512);
1568
1569        return 0;
1570}
1571
1572/*
1573 * Called by scsi stack when something has really gone wrong.  Usually
1574 * called when a command has timed-out for some reason.
1575 */
1576static int sbp2_scsi_abort(struct scsi_cmnd *cmd)
1577{
1578        struct sbp2_logical_unit *lu = cmd->device->hostdata;
1579
1580        dev_notice(lu_dev(lu), "sbp2_scsi_abort\n");
1581        sbp2_agent_reset(lu);
1582        sbp2_cancel_orbs(lu);
1583
1584        return SUCCESS;
1585}
1586
1587/*
1588 * Format of /sys/bus/scsi/devices/.../ieee1394_id:
1589 * u64 EUI-64 : u24 directory_ID : u16 LUN  (all printed in hexadecimal)
1590 *
1591 * This is the concatenation of target port identifier and logical unit
1592 * identifier as per SAM-2...SAM-4 annex A.
1593 */
1594static ssize_t sbp2_sysfs_ieee1394_id_show(struct device *dev,
1595                        struct device_attribute *attr, char *buf)
1596{
1597        struct scsi_device *sdev = to_scsi_device(dev);
1598        struct sbp2_logical_unit *lu;
1599
1600        if (!sdev)
1601                return 0;
1602
1603        lu = sdev->hostdata;
1604
1605        return sprintf(buf, "%016llx:%06x:%04x\n",
1606                        (unsigned long long)lu->tgt->guid,
1607                        lu->tgt->directory_id, lu->lun);
1608}
1609
1610static DEVICE_ATTR(ieee1394_id, S_IRUGO, sbp2_sysfs_ieee1394_id_show, NULL);
1611
1612static struct device_attribute *sbp2_scsi_sysfs_attrs[] = {
1613        &dev_attr_ieee1394_id,
1614        NULL
1615};
1616
1617static struct scsi_host_template scsi_driver_template = {
1618        .module                 = THIS_MODULE,
1619        .name                   = "SBP-2 IEEE-1394",
1620        .proc_name              = "sbp2",
1621        .queuecommand           = sbp2_scsi_queuecommand,
1622        .slave_alloc            = sbp2_scsi_slave_alloc,
1623        .slave_configure        = sbp2_scsi_slave_configure,
1624        .eh_abort_handler       = sbp2_scsi_abort,
1625        .this_id                = -1,
1626        .sg_tablesize           = SG_ALL,
1627        .use_clustering         = ENABLE_CLUSTERING,
1628        .cmd_per_lun            = 1,
1629        .can_queue              = 1,
1630        .sdev_attrs             = sbp2_scsi_sysfs_attrs,
1631};
1632
1633MODULE_AUTHOR("Kristian Hoegsberg <krh@bitplanet.net>");
1634MODULE_DESCRIPTION("SCSI over IEEE1394");
1635MODULE_LICENSE("GPL");
1636MODULE_DEVICE_TABLE(ieee1394, sbp2_id_table);
1637
1638/* Provide a module alias so root-on-sbp2 initrds don't break. */
1639#ifndef CONFIG_IEEE1394_SBP2_MODULE
1640MODULE_ALIAS("sbp2");
1641#endif
1642
1643static int __init sbp2_init(void)
1644{
1645        return driver_register(&sbp2_driver.driver);
1646}
1647
1648static void __exit sbp2_cleanup(void)
1649{
1650        driver_unregister(&sbp2_driver.driver);
1651}
1652
1653module_init(sbp2_init);
1654module_exit(sbp2_cleanup);
1655
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.