kernel/drivers/target/sbp/sbp_target.c

   1 /*
   2  * SBP2 target driver (SCSI over IEEE1394 in target mode)
   3  *
   4  * Copyright (C) 2011  Chris Boot <bootc@bootc.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 #define KMSG_COMPONENT "sbp_target"
  22 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
  23
  24 #include <linux/kernel.h>
  25 #include <linux/module.h>
  26 #include <linux/init.h>
  27 #include <linux/types.h>
  28 #include <linux/string.h>
  29 #include <linux/configfs.h>
  30 #include <linux/ctype.h>
  31 #include <linux/firewire.h>
  32 #include <linux/firewire-constants.h>
  33 #include <scsi/scsi.h>
  34 #include <scsi/scsi_tcq.h>
  35 #include <target/target_core_base.h>
  36 #include <target/target_core_backend.h>
  37 #include <target/target_core_fabric.h>
  38 #include <target/target_core_fabric_configfs.h>
  39 #include <target/target_core_configfs.h>
  40 #include <target/configfs_macros.h>
  41 #include <asm/unaligned.h>
  42
  43 #include "sbp_target.h"
  44
  45 static const struct target_core_fabric_ops sbp_ops;
  46
  47 /* FireWire address region for management and command block address handlers */
  48 static const struct fw_address_region sbp_register_region = {
  49         .start  = CSR_REGISTER_BASE + 0x10000,
  50         .end    = 0x1000000000000ULL,
  51 };
  52
  53 static const u32 sbp_unit_directory_template[] = {
  54         0x1200609e, /* unit_specifier_id: NCITS/T10 */
  55         0x13010483, /* unit_sw_version: 1155D Rev 4 */
  56         0x3800609e, /* command_set_specifier_id: NCITS/T10 */
  57         0x390104d8, /* command_set: SPC-2 */
  58         0x3b000000, /* command_set_revision: 0 */
  59         0x3c000001, /* firmware_revision: 1 */
  60 };
  61
  62 #define SESSION_MAINTENANCE_INTERVAL HZ
  63
  64 static atomic_t login_id = ATOMIC_INIT(0);
  65
  66 static void session_maintenance_work(struct work_struct *);
  67 static int sbp_run_transaction(struct fw_card *, int, int, int, int,
  68                 unsigned long long, void *, size_t);
  69
  70 static int read_peer_guid(u64 *guid, const struct sbp_management_request *req)
  71 {
  72         int ret;
  73         __be32 high, low;
  74
  75         ret = sbp_run_transaction(req->card, TCODE_READ_QUADLET_REQUEST,
  76                         req->node_addr, req->generation, req->speed,
  77                         (CSR_REGISTER_BASE | CSR_CONFIG_ROM) + 3 * 4,
  78                         &high, sizeof(high));
  79         if (ret != RCODE_COMPLETE)
  80                 return ret;
  81
  82         ret = sbp_run_transaction(req->card, TCODE_READ_QUADLET_REQUEST,
  83                         req->node_addr, req->generation, req->speed,
  84                         (CSR_REGISTER_BASE | CSR_CONFIG_ROM) + 4 * 4,
  85                         &low, sizeof(low));
  86         if (ret != RCODE_COMPLETE)
  87                 return ret;
  88
  89         *guid = (u64)be32_to_cpu(high) << 32 | be32_to_cpu(low);
  90
  91         return RCODE_COMPLETE;
  92 }
  93
  94 static struct sbp_session *sbp_session_find_by_guid(
  95         struct sbp_tpg *tpg, u64 guid)
  96 {
  97         struct se_session *se_sess;
  98         struct sbp_session *sess, *found = NULL;
  99
 100         spin_lock_bh(&tpg->se_tpg.session_lock);
 101         list_for_each_entry(se_sess, &tpg->se_tpg.tpg_sess_list, sess_list) {
 102                 sess = se_sess->fabric_sess_ptr;
 103                 if (sess->guid == guid)
 104                         found = sess;
 105         }
 106         spin_unlock_bh(&tpg->se_tpg.session_lock);
 107
 108         return found;
 109 }
 110
 111 static struct sbp_login_descriptor *sbp_login_find_by_lun(
 112                 struct sbp_session *session, struct se_lun *lun)
 113 {
 114         struct sbp_login_descriptor *login, *found = NULL;
 115
 116         spin_lock_bh(&session->lock);
 117         list_for_each_entry(login, &session->login_list, link) {
 118                 if (login->lun == lun)
 119                         found = login;
 120         }
 121         spin_unlock_bh(&session->lock);
 122
 123         return found;
 124 }
 125
 126 static int sbp_login_count_all_by_lun(
 127                 struct sbp_tpg *tpg,
 128                 struct se_lun *lun,
 129                 int exclusive)
 130 {
 131         struct se_session *se_sess;
 132         struct sbp_session *sess;
 133         struct sbp_login_descriptor *login;
 134         int count = 0;
 135
 136         spin_lock_bh(&tpg->se_tpg.session_lock);
 137         list_for_each_entry(se_sess, &tpg->se_tpg.tpg_sess_list, sess_list) {
 138                 sess = se_sess->fabric_sess_ptr;
 139
 140                 spin_lock_bh(&sess->lock);
 141                 list_for_each_entry(login, &sess->login_list, link) {
 142                         if (login->lun != lun)
 143                                 continue;
 144
 145                         if (!exclusive || login->exclusive)
 146                                 count++;
 147                 }
 148                 spin_unlock_bh(&sess->lock);
 149         }
 150         spin_unlock_bh(&tpg->se_tpg.session_lock);
 151
 152         return count;
 153 }
 154
 155 static struct sbp_login_descriptor *sbp_login_find_by_id(
 156         struct sbp_tpg *tpg, int login_id)
 157 {
 158         struct se_session *se_sess;
 159         struct sbp_session *sess;
 160         struct sbp_login_descriptor *login, *found = NULL;
 161
 162         spin_lock_bh(&tpg->se_tpg.session_lock);
 163         list_for_each_entry(se_sess, &tpg->se_tpg.tpg_sess_list, sess_list) {
 164                 sess = se_sess->fabric_sess_ptr;
 165
 166                 spin_lock_bh(&sess->lock);
 167                 list_for_each_entry(login, &sess->login_list, link) {
 168                         if (login->login_id == login_id)
 169                                 found = login;
 170                 }
 171                 spin_unlock_bh(&sess->lock);
 172         }
 173         spin_unlock_bh(&tpg->se_tpg.session_lock);
 174
 175         return found;
 176 }
 177
 178 static struct se_lun *sbp_get_lun_from_tpg(struct sbp_tpg *tpg, int lun)
 179 {
 180         struct se_portal_group *se_tpg = &tpg->se_tpg;
 181         struct se_lun *se_lun;
 182
 183         if (lun >= TRANSPORT_MAX_LUNS_PER_TPG)
 184                 return ERR_PTR(-EINVAL);
 185
 186         spin_lock(&se_tpg->tpg_lun_lock);
 187         se_lun = se_tpg->tpg_lun_list[lun];
 188
 189         if (se_lun->lun_status != TRANSPORT_LUN_STATUS_ACTIVE)
 190                 se_lun = ERR_PTR(-ENODEV);
 191
 192         spin_unlock(&se_tpg->tpg_lun_lock);
 193
 194         return se_lun;
 195 }
 196
 197 static struct sbp_session *sbp_session_create(
 198                 struct sbp_tpg *tpg,
 199                 u64 guid)
 200 {
 201         struct sbp_session *sess;
 202         int ret;
 203         char guid_str[17];
 204         struct se_node_acl *se_nacl;
 205
 206         sess = kmalloc(sizeof(*sess), GFP_KERNEL);
 207         if (!sess) {
 208                 pr_err("failed to allocate session descriptor\n");
 209                 return ERR_PTR(-ENOMEM);
 210         }
 211
 212         sess->se_sess = transport_init_session(TARGET_PROT_NORMAL);
 213         if (IS_ERR(sess->se_sess)) {
 214                 pr_err("failed to init se_session\n");
 215
 216                 ret = PTR_ERR(sess->se_sess);
 217                 kfree(sess);
 218                 return ERR_PTR(ret);
 219         }
 220
 221         snprintf(guid_str, sizeof(guid_str), "%016llx", guid);
 222
 223         se_nacl = core_tpg_check_initiator_node_acl(&tpg->se_tpg, guid_str);
 224         if (!se_nacl) {
 225                 pr_warn("Node ACL not found for %s\n", guid_str);
 226
 227                 transport_free_session(sess->se_sess);
 228                 kfree(sess);
 229
 230                 return ERR_PTR(-EPERM);
 231         }
 232
 233         sess->se_sess->se_node_acl = se_nacl;
 234
 235         spin_lock_init(&sess->lock);
 236         INIT_LIST_HEAD(&sess->login_list);
 237         INIT_DELAYED_WORK(&sess->maint_work, session_maintenance_work);
 238
 239         sess->guid = guid;
 240
 241         transport_register_session(&tpg->se_tpg, se_nacl, sess->se_sess, sess);
 242
 243         return sess;
 244 }
 245
 246 static void sbp_session_release(struct sbp_session *sess, bool cancel_work)
 247 {
 248         spin_lock_bh(&sess->lock);
 249         if (!list_empty(&sess->login_list)) {
 250                 spin_unlock_bh(&sess->lock);
 251                 return;
 252         }
 253         spin_unlock_bh(&sess->lock);
 254
 255         if (cancel_work)
 256                 cancel_delayed_work_sync(&sess->maint_work);
 257
 258         transport_deregister_session_configfs(sess->se_sess);
 259         transport_deregister_session(sess->se_sess);
 260
 261         if (sess->card)
 262                 fw_card_put(sess->card);
 263
 264         kfree(sess);
 265 }
 266
 267 static void sbp_target_agent_unregister(struct sbp_target_agent *);
 268
 269 static void sbp_login_release(struct sbp_login_descriptor *login,
 270         bool cancel_work)
 271 {
 272         struct sbp_session *sess = login->sess;
 273
 274         /* FIXME: abort/wait on tasks */
 275
 276         sbp_target_agent_unregister(login->tgt_agt);
 277
 278         if (sess) {
 279                 spin_lock_bh(&sess->lock);
 280                 list_del(&login->link);
 281                 spin_unlock_bh(&sess->lock);
 282
 283                 sbp_session_release(sess, cancel_work);
 284         }
 285
 286         kfree(login);
 287 }
 288
 289 static struct sbp_target_agent *sbp_target_agent_register(
 290         struct sbp_login_descriptor *);
 291
 292 static void sbp_management_request_login(
 293         struct sbp_management_agent *agent, struct sbp_management_request *req,
 294         int *status_data_size)
 295 {
 296         struct sbp_tport *tport = agent->tport;
 297         struct sbp_tpg *tpg = tport->tpg;
 298         struct se_lun *se_lun;
 299         int ret;
 300         u64 guid;
 301         struct sbp_session *sess;
 302         struct sbp_login_descriptor *login;
 303         struct sbp_login_response_block *response;
 304         int login_response_len;
 305
 306         se_lun = sbp_get_lun_from_tpg(tpg,
 307                         LOGIN_ORB_LUN(be32_to_cpu(req->orb.misc)));
 308         if (IS_ERR(se_lun)) {
 309                 pr_notice("login to unknown LUN: %d\n",
 310                         LOGIN_ORB_LUN(be32_to_cpu(req->orb.misc)));
 311
 312                 req->status.status = cpu_to_be32(
 313                         STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
 314                         STATUS_BLOCK_SBP_STATUS(SBP_STATUS_LUN_NOTSUPP));
 315                 return;
 316         }
 317
 318         ret = read_peer_guid(&guid, req);
 319         if (ret != RCODE_COMPLETE) {
 320                 pr_warn("failed to read peer GUID: %d\n", ret);
 321
 322                 req->status.status = cpu_to_be32(
 323                         STATUS_BLOCK_RESP(STATUS_RESP_TRANSPORT_FAILURE) |
 324                         STATUS_BLOCK_SBP_STATUS(SBP_STATUS_UNSPECIFIED_ERROR));
 325                 return;
 326         }
 327
 328         pr_notice("mgt_agent LOGIN to LUN %d from %016llx\n",
 329                 se_lun->unpacked_lun, guid);
 330
 331         sess = sbp_session_find_by_guid(tpg, guid);
 332         if (sess) {
 333                 login = sbp_login_find_by_lun(sess, se_lun);
 334                 if (login) {
 335                         pr_notice("initiator already logged-in\n");
 336
 337                         /*
 338                          * SBP-2 R4 says we should return access denied, but
 339                          * that can confuse initiators. Instead we need to
 340                          * treat this like a reconnect, but send the login
 341                          * response block like a fresh login.
 342                          *
 343                          * This is required particularly in the case of Apple
 344                          * devices booting off the FireWire target, where
 345                          * the firmware has an active login to the target. When
 346                          * the OS takes control of the session it issues its own
 347                          * LOGIN rather than a RECONNECT. To avoid the machine
 348                          * waiting until the reconnect_hold expires, we can skip
 349                          * the ACCESS_DENIED errors to speed things up.
 350                          */
 351
 352                         goto already_logged_in;
 353                 }
 354         }
 355
 356         /*
 357          * check exclusive bit in login request
 358          * reject with access_denied if any logins present
 359          */
 360         if (LOGIN_ORB_EXCLUSIVE(be32_to_cpu(req->orb.misc)) &&
 361                         sbp_login_count_all_by_lun(tpg, se_lun, 0)) {
 362                 pr_warn("refusing exclusive login with other active logins\n");
 363
 364                 req->status.status = cpu_to_be32(
 365                         STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
 366                         STATUS_BLOCK_SBP_STATUS(SBP_STATUS_ACCESS_DENIED));
 367                 return;
 368         }
 369
 370         /*
 371          * check exclusive bit in any existing login descriptor
 372          * reject with access_denied if any exclusive logins present
 373          */
 374         if (sbp_login_count_all_by_lun(tpg, se_lun, 1)) {
 375                 pr_warn("refusing login while another exclusive login present\n");
 376
 377                 req->status.status = cpu_to_be32(
 378                         STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
 379                         STATUS_BLOCK_SBP_STATUS(SBP_STATUS_ACCESS_DENIED));
 380                 return;
 381         }
 382
 383         /*
 384          * check we haven't exceeded the number of allowed logins
 385          * reject with resources_unavailable if we have
 386          */
 387         if (sbp_login_count_all_by_lun(tpg, se_lun, 0) >=
 388                         tport->max_logins_per_lun) {
 389                 pr_warn("max number of logins reached\n");
 390
 391                 req->status.status = cpu_to_be32(
 392                         STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
 393                         STATUS_BLOCK_SBP_STATUS(SBP_STATUS_RESOURCES_UNAVAIL));
 394                 return;
 395         }
 396
 397         if (!sess) {
 398                 sess = sbp_session_create(tpg, guid);
 399                 if (IS_ERR(sess)) {
 400                         switch (PTR_ERR(sess)) {
 401                         case -EPERM:
 402                                 ret = SBP_STATUS_ACCESS_DENIED;
 403                                 break;
 404                         default:
 405                                 ret = SBP_STATUS_RESOURCES_UNAVAIL;
 406                                 break;
 407                         }
 408
 409                         req->status.status = cpu_to_be32(
 410                                 STATUS_BLOCK_RESP(
 411                                         STATUS_RESP_REQUEST_COMPLETE) |
 412                                 STATUS_BLOCK_SBP_STATUS(ret));
 413                         return;
 414                 }
 415
 416                 sess->node_id = req->node_addr;
 417                 sess->card = fw_card_get(req->card);
 418                 sess->generation = req->generation;
 419                 sess->speed = req->speed;
 420
 421                 schedule_delayed_work(&sess->maint_work,
 422                                 SESSION_MAINTENANCE_INTERVAL);
 423         }
 424
 425         /* only take the latest reconnect_hold into account */
 426         sess->reconnect_hold = min(
 427                 1 << LOGIN_ORB_RECONNECT(be32_to_cpu(req->orb.misc)),
 428                 tport->max_reconnect_timeout) - 1;
 429
 430         login = kmalloc(sizeof(*login), GFP_KERNEL);
 431         if (!login) {
 432                 pr_err("failed to allocate login descriptor\n");
 433
 434                 sbp_session_release(sess, true);
 435
 436                 req->status.status = cpu_to_be32(
 437                         STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
 438                         STATUS_BLOCK_SBP_STATUS(SBP_STATUS_RESOURCES_UNAVAIL));
 439                 return;
 440         }
 441
 442         login->sess = sess;
 443         login->lun = se_lun;
 444         login->status_fifo_addr = sbp2_pointer_to_addr(&req->orb.status_fifo);
 445         login->exclusive = LOGIN_ORB_EXCLUSIVE(be32_to_cpu(req->orb.misc));
 446         login->login_id = atomic_inc_return(&login_id);
 447
 448         login->tgt_agt = sbp_target_agent_register(login);
 449         if (IS_ERR(login->tgt_agt)) {
 450                 ret = PTR_ERR(login->tgt_agt);
 451                 pr_err("failed to map command block handler: %d\n", ret);
 452
 453                 sbp_session_release(sess, true);
 454                 kfree(login);
 455
 456                 req->status.status = cpu_to_be32(
 457                         STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
 458                         STATUS_BLOCK_SBP_STATUS(SBP_STATUS_RESOURCES_UNAVAIL));
 459                 return;
 460         }
 461
 462         spin_lock_bh(&sess->lock);
 463         list_add_tail(&login->link, &sess->login_list);
 464         spin_unlock_bh(&sess->lock);
 465
 466 already_logged_in:
 467         response = kzalloc(sizeof(*response), GFP_KERNEL);
 468         if (!response) {
 469                 pr_err("failed to allocate login response block\n");
 470
 471                 sbp_login_release(login, true);
 472
 473                 req->status.status = cpu_to_be32(
 474                         STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
 475                         STATUS_BLOCK_SBP_STATUS(SBP_STATUS_RESOURCES_UNAVAIL));
 476                 return;
 477         }
 478
 479         login_response_len = clamp_val(
 480                         LOGIN_ORB_RESPONSE_LENGTH(be32_to_cpu(req->orb.length)),
 481                         12, sizeof(*response));
 482         response->misc = cpu_to_be32(
 483                 ((login_response_len & 0xffff) << 16) |
 484                 (login->login_id & 0xffff));
 485         response->reconnect_hold = cpu_to_be32(sess->reconnect_hold & 0xffff);
 486         addr_to_sbp2_pointer(login->tgt_agt->handler.offset,
 487                 &response->command_block_agent);
 488
 489         ret = sbp_run_transaction(sess->card, TCODE_WRITE_BLOCK_REQUEST,
 490                 sess->node_id, sess->generation, sess->speed,
 491                 sbp2_pointer_to_addr(&req->orb.ptr2), response,
 492                 login_response_len);
 493         if (ret != RCODE_COMPLETE) {
 494                 pr_debug("failed to write login response block: %x\n", ret);
 495
 496                 kfree(response);
 497                 sbp_login_release(login, true);
 498
 499                 req->status.status = cpu_to_be32(
 500                         STATUS_BLOCK_RESP(STATUS_RESP_TRANSPORT_FAILURE) |
 501                         STATUS_BLOCK_SBP_STATUS(SBP_STATUS_UNSPECIFIED_ERROR));
 502                 return;
 503         }
 504
 505         kfree(response);
 506
 507         req->status.status = cpu_to_be32(
 508                 STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
 509                 STATUS_BLOCK_SBP_STATUS(SBP_STATUS_OK));
 510 }
 511
 512 static void sbp_management_request_query_logins(
 513         struct sbp_management_agent *agent, struct sbp_management_request *req,
 514         int *status_data_size)
 515 {
 516         pr_notice("QUERY LOGINS not implemented\n");
 517         /* FIXME: implement */
 518
 519         req->status.status = cpu_to_be32(
 520                 STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
 521                 STATUS_BLOCK_SBP_STATUS(SBP_STATUS_REQ_TYPE_NOTSUPP));
 522 }
 523
 524 static void sbp_management_request_reconnect(
 525         struct sbp_management_agent *agent, struct sbp_management_request *req,
 526         int *status_data_size)
 527 {
 528         struct sbp_tport *tport = agent->tport;
 529         struct sbp_tpg *tpg = tport->tpg;
 530         int ret;
 531         u64 guid;
 532         struct sbp_login_descriptor *login;
 533
 534         ret = read_peer_guid(&guid, req);
 535         if (ret != RCODE_COMPLETE) {
 536                 pr_warn("failed to read peer GUID: %d\n", ret);
 537
 538                 req->status.status = cpu_to_be32(
 539                         STATUS_BLOCK_RESP(STATUS_RESP_TRANSPORT_FAILURE) |
 540                         STATUS_BLOCK_SBP_STATUS(SBP_STATUS_UNSPECIFIED_ERROR));
 541                 return;
 542         }
 543
 544         pr_notice("mgt_agent RECONNECT from %016llx\n", guid);
 545
 546         login = sbp_login_find_by_id(tpg,
 547                 RECONNECT_ORB_LOGIN_ID(be32_to_cpu(req->orb.misc)));
 548
 549         if (!login) {
 550                 pr_err("mgt_agent RECONNECT unknown login ID\n");
 551
 552                 req->status.status = cpu_to_be32(
 553                         STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
 554                         STATUS_BLOCK_SBP_STATUS(SBP_STATUS_ACCESS_DENIED));
 555                 return;
 556         }
 557
 558         if (login->sess->guid != guid) {
 559                 pr_err("mgt_agent RECONNECT login GUID doesn't match\n");
 560
 561                 req->status.status = cpu_to_be32(
 562                         STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
 563                         STATUS_BLOCK_SBP_STATUS(SBP_STATUS_ACCESS_DENIED));
 564                 return;
 565         }
 566
 567         spin_lock_bh(&login->sess->lock);
 568         if (login->sess->card)
 569                 fw_card_put(login->sess->card);
 570
 571         /* update the node details */
 572         login->sess->generation = req->generation;
 573         login->sess->node_id = req->node_addr;
 574         login->sess->card = fw_card_get(req->card);
 575         login->sess->speed = req->speed;
 576         spin_unlock_bh(&login->sess->lock);
 577
 578         req->status.status = cpu_to_be32(
 579                 STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
 580                 STATUS_BLOCK_SBP_STATUS(SBP_STATUS_OK));
 581 }
 582
 583 static void sbp_management_request_logout(
 584         struct sbp_management_agent *agent, struct sbp_management_request *req,
 585         int *status_data_size)
 586 {
 587         struct sbp_tport *tport = agent->tport;
 588         struct sbp_tpg *tpg = tport->tpg;
 589         int id;
 590         struct sbp_login_descriptor *login;
 591
 592         id = LOGOUT_ORB_LOGIN_ID(be32_to_cpu(req->orb.misc));
 593
 594         login = sbp_login_find_by_id(tpg, id);
 595         if (!login) {
 596                 pr_warn("cannot find login: %d\n", id);
 597
 598                 req->status.status = cpu_to_be32(
 599                         STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
 600                         STATUS_BLOCK_SBP_STATUS(SBP_STATUS_LOGIN_ID_UNKNOWN));
 601                 return;
 602         }
 603
 604         pr_info("mgt_agent LOGOUT from LUN %d session %d\n",
 605                 login->lun->unpacked_lun, login->login_id);
 606
 607         if (req->node_addr != login->sess->node_id) {
 608                 pr_warn("logout from different node ID\n");
 609
 610                 req->status.status = cpu_to_be32(
 611                         STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
 612                         STATUS_BLOCK_SBP_STATUS(SBP_STATUS_ACCESS_DENIED));
 613                 return;
 614         }
 615
 616         sbp_login_release(login, true);
 617
 618         req->status.status = cpu_to_be32(
 619                 STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
 620                 STATUS_BLOCK_SBP_STATUS(SBP_STATUS_OK));
 621 }
 622
 623 static void session_check_for_reset(struct sbp_session *sess)
 624 {
 625         bool card_valid = false;
 626
 627         spin_lock_bh(&sess->lock);
 628
 629         if (sess->card) {
 630                 spin_lock_irq(&sess->card->lock);
 631                 card_valid = (sess->card->local_node != NULL);
 632                 spin_unlock_irq(&sess->card->lock);
 633
 634                 if (!card_valid) {
 635                         fw_card_put(sess->card);
 636                         sess->card = NULL;
 637                 }
 638         }
 639
 640         if (!card_valid || (sess->generation != sess->card->generation)) {
 641                 pr_info("Waiting for reconnect from node: %016llx\n",
 642                                 sess->guid);
 643
 644                 sess->node_id = -1;
 645                 sess->reconnect_expires = get_jiffies_64() +
 646                         ((sess->reconnect_hold + 1) * HZ);
 647         }
 648
 649         spin_unlock_bh(&sess->lock);
 650 }
 651
 652 static void session_reconnect_expired(struct sbp_session *sess)
 653 {
 654         struct sbp_login_descriptor *login, *temp;
 655         LIST_HEAD(login_list);
 656
 657         pr_info("Reconnect timer expired for node: %016llx\n", sess->guid);
 658
 659         spin_lock_bh(&sess->lock);
 660         list_for_each_entry_safe(login, temp, &sess->login_list, link) {
 661                 login->sess = NULL;
 662                 list_move_tail(&login->link, &login_list);
 663         }
 664         spin_unlock_bh(&sess->lock);
 665
 666         list_for_each_entry_safe(login, temp, &login_list, link) {
 667                 list_del(&login->link);
 668                 sbp_login_release(login, false);
 669         }
 670
 671         sbp_session_release(sess, false);
 672 }
 673
 674 static void session_maintenance_work(struct work_struct *work)
 675 {
 676         struct sbp_session *sess = container_of(work, struct sbp_session,
 677                         maint_work.work);
 678
 679         /* could be called while tearing down the session */
 680         spin_lock_bh(&sess->lock);
 681         if (list_empty(&sess->login_list)) {
 682                 spin_unlock_bh(&sess->lock);
 683                 return;
 684         }
 685         spin_unlock_bh(&sess->lock);
 686
 687         if (sess->node_id != -1) {
 688                 /* check for bus reset and make node_id invalid */
 689                 session_check_for_reset(sess);
 690
 691                 schedule_delayed_work(&sess->maint_work,
 692                                 SESSION_MAINTENANCE_INTERVAL);
 693         } else if (!time_after64(get_jiffies_64(), sess->reconnect_expires)) {
 694                 /* still waiting for reconnect */
 695                 schedule_delayed_work(&sess->maint_work,
 696                                 SESSION_MAINTENANCE_INTERVAL);
 697         } else {
 698                 /* reconnect timeout has expired */
 699                 session_reconnect_expired(sess);
 700         }
 701 }
 702
 703 static int tgt_agent_rw_agent_state(struct fw_card *card, int tcode, void *data,
 704                 struct sbp_target_agent *agent)
 705 {
 706         int state;
 707
 708         switch (tcode) {
 709         case TCODE_READ_QUADLET_REQUEST:
 710                 pr_debug("tgt_agent AGENT_STATE READ\n");
 711
 712                 spin_lock_bh(&agent->lock);
 713                 state = agent->state;
 714                 spin_unlock_bh(&agent->lock);
 715
 716                 *(__be32 *)data = cpu_to_be32(state);
 717
 718                 return RCODE_COMPLETE;
 719
 720         case TCODE_WRITE_QUADLET_REQUEST:
 721                 /* ignored */
 722                 return RCODE_COMPLETE;
 723
 724         default:
 725                 return RCODE_TYPE_ERROR;
 726         }
 727 }
 728
 729 static int tgt_agent_rw_agent_reset(struct fw_card *card, int tcode, void *data,
 730                 struct sbp_target_agent *agent)
 731 {
 732         switch (tcode) {
 733         case TCODE_WRITE_QUADLET_REQUEST:
 734                 pr_debug("tgt_agent AGENT_RESET\n");
 735                 spin_lock_bh(&agent->lock);
 736                 agent->state = AGENT_STATE_RESET;
 737                 spin_unlock_bh(&agent->lock);
 738                 return RCODE_COMPLETE;
 739
 740         default:
 741                 return RCODE_TYPE_ERROR;
 742         }
 743 }
 744
 745 static int tgt_agent_rw_orb_pointer(struct fw_card *card, int tcode, void *data,
 746                 struct sbp_target_agent *agent)
 747 {
 748         struct sbp2_pointer *ptr = data;
 749
 750         switch (tcode) {
 751         case TCODE_WRITE_BLOCK_REQUEST:
 752                 spin_lock_bh(&agent->lock);
 753                 if (agent->state != AGENT_STATE_SUSPENDED &&
 754                                 agent->state != AGENT_STATE_RESET) {
 755                         spin_unlock_bh(&agent->lock);
 756                         pr_notice("Ignoring ORB_POINTER write while active.\n");
 757                         return RCODE_CONFLICT_ERROR;
 758                 }
 759                 agent->state = AGENT_STATE_ACTIVE;
 760                 spin_unlock_bh(&agent->lock);
 761
 762                 agent->orb_pointer = sbp2_pointer_to_addr(ptr);
 763                 agent->doorbell = false;
 764
 765                 pr_debug("tgt_agent ORB_POINTER write: 0x%llx\n",
 766                                 agent->orb_pointer);
 767
 768                 queue_work(system_unbound_wq, &agent->work);
 769
 770                 return RCODE_COMPLETE;
 771
 772         case TCODE_READ_BLOCK_REQUEST:
 773                 pr_debug("tgt_agent ORB_POINTER READ\n");
 774                 spin_lock_bh(&agent->lock);
 775                 addr_to_sbp2_pointer(agent->orb_pointer, ptr);
 776                 spin_unlock_bh(&agent->lock);
 777                 return RCODE_COMPLETE;
 778
 779         default:
 780                 return RCODE_TYPE_ERROR;
 781         }
 782 }
 783
 784 static int tgt_agent_rw_doorbell(struct fw_card *card, int tcode, void *data,
 785                 struct sbp_target_agent *agent)
 786 {
 787         switch (tcode) {
 788         case TCODE_WRITE_QUADLET_REQUEST:
 789                 spin_lock_bh(&agent->lock);
 790                 if (agent->state != AGENT_STATE_SUSPENDED) {
 791                         spin_unlock_bh(&agent->lock);
 792                         pr_debug("Ignoring DOORBELL while active.\n");
 793                         return RCODE_CONFLICT_ERROR;
 794                 }
 795                 agent->state = AGENT_STATE_ACTIVE;
 796                 spin_unlock_bh(&agent->lock);
 797
 798                 agent->doorbell = true;
 799
 800                 pr_debug("tgt_agent DOORBELL\n");
 801
 802                 queue_work(system_unbound_wq, &agent->work);
 803
 804                 return RCODE_COMPLETE;
 805
 806         case TCODE_READ_QUADLET_REQUEST:
 807                 return RCODE_COMPLETE;
 808
 809         default:
 810                 return RCODE_TYPE_ERROR;
 811         }
 812 }
 813
 814 static int tgt_agent_rw_unsolicited_status_enable(struct fw_card *card,
 815                 int tcode, void *data, struct sbp_target_agent *agent)
 816 {
 817         switch (tcode) {
 818         case TCODE_WRITE_QUADLET_REQUEST:
 819                 pr_debug("tgt_agent UNSOLICITED_STATUS_ENABLE\n");
 820                 /* ignored as we don't send unsolicited status */
 821                 return RCODE_COMPLETE;
 822
 823         case TCODE_READ_QUADLET_REQUEST:
 824                 return RCODE_COMPLETE;
 825
 826         default:
 827                 return RCODE_TYPE_ERROR;
 828         }
 829 }
 830
 831 static void tgt_agent_rw(struct fw_card *card, struct fw_request *request,
 832                 int tcode, int destination, int source, int generation,
 833                 unsigned long long offset, void *data, size_t length,
 834                 void *callback_data)
 835 {
 836         struct sbp_target_agent *agent = callback_data;
 837         struct sbp_session *sess = agent->login->sess;
 838         int sess_gen, sess_node, rcode;
 839
 840         spin_lock_bh(&sess->lock);
 841         sess_gen = sess->generation;
 842         sess_node = sess->node_id;
 843         spin_unlock_bh(&sess->lock);
 844
 845         if (generation != sess_gen) {
 846                 pr_notice("ignoring request with wrong generation\n");
 847                 rcode = RCODE_TYPE_ERROR;
 848                 goto out;
 849         }
 850
 851         if (source != sess_node) {
 852                 pr_notice("ignoring request from foreign node (%x != %x)\n",
 853                                 source, sess_node);
 854                 rcode = RCODE_TYPE_ERROR;
 855                 goto out;
 856         }
 857
 858         /* turn offset into the offset from the start of the block */
 859         offset -= agent->handler.offset;
 860
 861         if (offset == 0x00 && length == 4) {
 862                 /* AGENT_STATE */
 863                 rcode = tgt_agent_rw_agent_state(card, tcode, data, agent);
 864         } else if (offset == 0x04 && length == 4) {
 865                 /* AGENT_RESET */
 866                 rcode = tgt_agent_rw_agent_reset(card, tcode, data, agent);
 867         } else if (offset == 0x08 && length == 8) {
 868                 /* ORB_POINTER */
 869                 rcode = tgt_agent_rw_orb_pointer(card, tcode, data, agent);
 870         } else if (offset == 0x10 && length == 4) {
 871                 /* DOORBELL */
 872                 rcode = tgt_agent_rw_doorbell(card, tcode, data, agent);
 873         } else if (offset == 0x14 && length == 4) {
 874                 /* UNSOLICITED_STATUS_ENABLE */
 875                 rcode = tgt_agent_rw_unsolicited_status_enable(card, tcode,
 876                                 data, agent);
 877         } else {
 878                 rcode = RCODE_ADDRESS_ERROR;
 879         }
 880
 881 out:
 882         fw_send_response(card, request, rcode);
 883 }
 884
 885 static void sbp_handle_command(struct sbp_target_request *);
 886 static int sbp_send_status(struct sbp_target_request *);
 887 static void sbp_free_request(struct sbp_target_request *);
 888
 889 static void tgt_agent_process_work(struct work_struct *work)
 890 {
 891         struct sbp_target_request *req =
 892                 container_of(work, struct sbp_target_request, work);
 893
 894         pr_debug("tgt_orb ptr:0x%llx next_ORB:0x%llx data_descriptor:0x%llx misc:0x%x\n",
 895                         req->orb_pointer,
 896                         sbp2_pointer_to_addr(&req->orb.next_orb),
 897                         sbp2_pointer_to_addr(&req->orb.data_descriptor),
 898                         be32_to_cpu(req->orb.misc));
 899
 900         if (req->orb_pointer >> 32)
 901                 pr_debug("ORB with high bits set\n");
 902
 903         switch (ORB_REQUEST_FORMAT(be32_to_cpu(req->orb.misc))) {
 904                 case 0:/* Format specified by this standard */
 905                         sbp_handle_command(req);
 906                         return;
 907                 case 1: /* Reserved for future standardization */
 908                 case 2: /* Vendor-dependent */
 909                         req->status.status |= cpu_to_be32(
 910                                         STATUS_BLOCK_RESP(
 911                                                 STATUS_RESP_REQUEST_COMPLETE) |
 912                                         STATUS_BLOCK_DEAD(0) |
 913                                         STATUS_BLOCK_LEN(1) |
 914                                         STATUS_BLOCK_SBP_STATUS(
 915                                                 SBP_STATUS_REQ_TYPE_NOTSUPP));
 916                         sbp_send_status(req);
 917                         sbp_free_request(req);
 918                         return;
 919                 case 3: /* Dummy ORB */
 920                         req->status.status |= cpu_to_be32(
 921                                         STATUS_BLOCK_RESP(
 922                                                 STATUS_RESP_REQUEST_COMPLETE) |
 923                                         STATUS_BLOCK_DEAD(0) |
 924                                         STATUS_BLOCK_LEN(1) |
 925                                         STATUS_BLOCK_SBP_STATUS(
 926                                                 SBP_STATUS_DUMMY_ORB_COMPLETE));
 927                         sbp_send_status(req);
 928                         sbp_free_request(req);
 929                         return;
 930                 default:
 931                         BUG();
 932         }
 933 }
 934
 935 /* used to double-check we haven't been issued an AGENT_RESET */
 936 static inline bool tgt_agent_check_active(struct sbp_target_agent *agent)
 937 {
 938         bool active;
 939
 940         spin_lock_bh(&agent->lock);
 941         active = (agent->state == AGENT_STATE_ACTIVE);
 942         spin_unlock_bh(&agent->lock);
 943
 944         return active;
 945 }
 946
 947 static void tgt_agent_fetch_work(struct work_struct *work)
 948 {
 949         struct sbp_target_agent *agent =
 950                 container_of(work, struct sbp_target_agent, work);
 951         struct sbp_session *sess = agent->login->sess;
 952         struct sbp_target_request *req;
 953         int ret;
 954         bool doorbell = agent->doorbell;
 955         u64 next_orb = agent->orb_pointer;
 956
 957         while (next_orb && tgt_agent_check_active(agent)) {
 958                 req = kzalloc(sizeof(*req), GFP_KERNEL);
 959                 if (!req) {
 960                         spin_lock_bh(&agent->lock);
 961                         agent->state = AGENT_STATE_DEAD;
 962                         spin_unlock_bh(&agent->lock);
 963                         return;
 964                 }
 965
 966                 req->login = agent->login;
 967                 req->orb_pointer = next_orb;
 968
 969                 req->status.status = cpu_to_be32(STATUS_BLOCK_ORB_OFFSET_HIGH(
 970                                         req->orb_pointer >> 32));
 971                 req->status.orb_low = cpu_to_be32(
 972                                 req->orb_pointer & 0xfffffffc);
 973
 974                 /* read in the ORB */
 975                 ret = sbp_run_transaction(sess->card, TCODE_READ_BLOCK_REQUEST,
 976                                 sess->node_id, sess->generation, sess->speed,
 977                                 req->orb_pointer, &req->orb, sizeof(req->orb));
 978                 if (ret != RCODE_COMPLETE) {
 979                         pr_debug("tgt_orb fetch failed: %x\n", ret);
 980                         req->status.status |= cpu_to_be32(
 981                                         STATUS_BLOCK_SRC(
 982                                                 STATUS_SRC_ORB_FINISHED) |
 983                                         STATUS_BLOCK_RESP(
 984                                                 STATUS_RESP_TRANSPORT_FAILURE) |
 985                                         STATUS_BLOCK_DEAD(1) |
 986                                         STATUS_BLOCK_LEN(1) |
 987                                         STATUS_BLOCK_SBP_STATUS(
 988                                                 SBP_STATUS_UNSPECIFIED_ERROR));
 989                         spin_lock_bh(&agent->lock);
 990                         agent->state = AGENT_STATE_DEAD;
 991                         spin_unlock_bh(&agent->lock);
 992
 993                         sbp_send_status(req);
 994                         sbp_free_request(req);
 995                         return;
 996                 }
 997
 998                 /* check the next_ORB field */
 999                 if (be32_to_cpu(req->orb.next_orb.high) & 0x80000000) {
1000                         next_orb = 0;
1001                         req->status.status |= cpu_to_be32(STATUS_BLOCK_SRC(
1002                                                 STATUS_SRC_ORB_FINISHED));
1003                 } else {
1004                         next_orb = sbp2_pointer_to_addr(&req->orb.next_orb);
1005                         req->status.status |= cpu_to_be32(STATUS_BLOCK_SRC(
1006                                                 STATUS_SRC_ORB_CONTINUING));
1007                 }
1008
1009                 if (tgt_agent_check_active(agent) && !doorbell) {
1010                         INIT_WORK(&req->work, tgt_agent_process_work);
1011                         queue_work(system_unbound_wq, &req->work);
1012                 } else {
1013                         /* don't process this request, just check next_ORB */
1014                         sbp_free_request(req);
1015                 }
1016
1017                 spin_lock_bh(&agent->lock);
1018                 doorbell = agent->doorbell = false;
1019
1020                 /* check if we should carry on processing */
1021                 if (next_orb)
1022                         agent->orb_pointer = next_orb;
1023                 else
1024                         agent->state = AGENT_STATE_SUSPENDED;
1025
1026                 spin_unlock_bh(&agent->lock);
1027         };
1028 }
1029
1030 static struct sbp_target_agent *sbp_target_agent_register(
1031                 struct sbp_login_descriptor *login)
1032 {
1033         struct sbp_target_agent *agent;
1034         int ret;
1035
1036         agent = kmalloc(sizeof(*agent), GFP_KERNEL);
1037         if (!agent)
1038                 return ERR_PTR(-ENOMEM);
1039
1040         spin_lock_init(&agent->lock);
1041
1042         agent->handler.length = 0x20;
1043         agent->handler.address_callback = tgt_agent_rw;
1044         agent->handler.callback_data = agent;
1045
1046         agent->login = login;
1047         agent->state = AGENT_STATE_RESET;
1048         INIT_WORK(&agent->work, tgt_agent_fetch_work);
1049         agent->orb_pointer = 0;
1050         agent->doorbell = false;
1051
1052         ret = fw_core_add_address_handler(&agent->handler,
1053                         &sbp_register_region);
1054         if (ret < 0) {
1055                 kfree(agent);
1056                 return ERR_PTR(ret);
1057         }
1058
1059         return agent;
1060 }
1061
1062 static void sbp_target_agent_unregister(struct sbp_target_agent *agent)
1063 {
1064         fw_core_remove_address_handler(&agent->handler);
1065         cancel_work_sync(&agent->work);
1066         kfree(agent);
1067 }
1068
1069 /*
1070  * Simple wrapper around fw_run_transaction that retries the transaction several
1071  * times in case of failure, with an exponential backoff.
1072  */
1073 static int sbp_run_transaction(struct fw_card *card, int tcode, int destination_id,
1074                 int generation, int speed, unsigned long long offset,
1075                 void *payload, size_t length)
1076 {
1077         int attempt, ret, delay;
1078
1079         for (attempt = 1; attempt <= 5; attempt++) {
1080                 ret = fw_run_transaction(card, tcode, destination_id,
1081                                 generation, speed, offset, payload, length);
1082
1083                 switch (ret) {
1084                 case RCODE_COMPLETE:
1085                 case RCODE_TYPE_ERROR:
1086                 case RCODE_ADDRESS_ERROR:
1087                 case RCODE_GENERATION:
1088                         return ret;
1089
1090                 default:
1091                         delay = 5 * attempt * attempt;
1092                         usleep_range(delay, delay * 2);
1093                 }
1094         }
1095
1096         return ret;
1097 }
1098
1099 /*
1100  * Wrapper around sbp_run_transaction that gets the card, destination,
1101  * generation and speed out of the request's session.
1102  */
1103 static int sbp_run_request_transaction(struct sbp_target_request *req,
1104                 int tcode, unsigned long long offset, void *payload,
1105                 size_t length)
1106 {
1107         struct sbp_login_descriptor *login = req->login;
1108         struct sbp_session *sess = login->sess;
1109         struct fw_card *card;
1110         int node_id, generation, speed, ret;
1111
1112         spin_lock_bh(&sess->lock);
1113         card = fw_card_get(sess->card);
1114         node_id = sess->node_id;
1115         generation = sess->generation;
1116         speed = sess->speed;
1117         spin_unlock_bh(&sess->lock);
1118
1119         ret = sbp_run_transaction(card, tcode, node_id, generation, speed,
1120                         offset, payload, length);
1121
1122         fw_card_put(card);
1123
1124         return ret;
1125 }
1126
1127 static int sbp_fetch_command(struct sbp_target_request *req)
1128 {
1129         int ret, cmd_len, copy_len;
1130
1131         cmd_len = scsi_command_size(req->orb.command_block);
1132
1133         req->cmd_buf = kmalloc(cmd_len, GFP_KERNEL);
1134         if (!req->cmd_buf)
1135                 return -ENOMEM;
1136
1137         memcpy(req->cmd_buf, req->orb.command_block,
1138                 min_t(int, cmd_len, sizeof(req->orb.command_block)));
1139
1140         if (cmd_len > sizeof(req->orb.command_block)) {
1141                 pr_debug("sbp_fetch_command: filling in long command\n");
1142                 copy_len = cmd_len - sizeof(req->orb.command_block);
1143
1144                 ret = sbp_run_request_transaction(req,
1145                                 TCODE_READ_BLOCK_REQUEST,
1146                                 req->orb_pointer + sizeof(req->orb),
1147                                 req->cmd_buf + sizeof(req->orb.command_block),
1148                                 copy_len);
1149                 if (ret != RCODE_COMPLETE)
1150                         return -EIO;
1151         }
1152
1153         return 0;
1154 }
1155
1156 static int sbp_fetch_page_table(struct sbp_target_request *req)
1157 {
1158         int pg_tbl_sz, ret;
1159         struct sbp_page_table_entry *pg_tbl;
1160
1161         if (!CMDBLK_ORB_PG_TBL_PRESENT(be32_to_cpu(req->orb.misc)))
1162                 return 0;
1163
1164         pg_tbl_sz = CMDBLK_ORB_DATA_SIZE(be32_to_cpu(req->orb.misc)) *
1165                 sizeof(struct sbp_page_table_entry);
1166
1167         pg_tbl = kmalloc(pg_tbl_sz, GFP_KERNEL);
1168         if (!pg_tbl)
1169                 return -ENOMEM;
1170
1171         ret = sbp_run_request_transaction(req, TCODE_READ_BLOCK_REQUEST,
1172                         sbp2_pointer_to_addr(&req->orb.data_descriptor),
1173                         pg_tbl, pg_tbl_sz);
1174         if (ret != RCODE_COMPLETE) {
1175                 kfree(pg_tbl);
1176                 return -EIO;
1177         }
1178
1179         req->pg_tbl = pg_tbl;
1180         return 0;
1181 }
1182
1183 static void sbp_calc_data_length_direction(struct sbp_target_request *req,
1184         u32 *data_len, enum dma_data_direction *data_dir)
1185 {
1186         int data_size, direction, idx;
1187
1188         data_size = CMDBLK_ORB_DATA_SIZE(be32_to_cpu(req->orb.misc));
1189         direction = CMDBLK_ORB_DIRECTION(be32_to_cpu(req->orb.misc));
1190
1191         if (!data_size) {
1192                 *data_len = 0;
1193                 *data_dir = DMA_NONE;
1194                 return;
1195         }
1196
1197         *data_dir = direction ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
1198
1199         if (req->pg_tbl) {
1200                 *data_len = 0;
1201                 for (idx = 0; idx < data_size; idx++) {
1202                         *data_len += be16_to_cpu(
1203                                         req->pg_tbl[idx].segment_length);
1204                 }
1205         } else {
1206                 *data_len = data_size;
1207         }
1208 }
1209
1210 static void sbp_handle_command(struct sbp_target_request *req)
1211 {
1212         struct sbp_login_descriptor *login = req->login;
1213         struct sbp_session *sess = login->sess;
1214         int ret, unpacked_lun;
1215         u32 data_length;
1216         enum dma_data_direction data_dir;
1217
1218         ret = sbp_fetch_command(req);
1219         if (ret) {
1220                 pr_debug("sbp_handle_command: fetch command failed: %d\n", ret);
1221                 goto err;
1222         }
1223
1224         ret = sbp_fetch_page_table(req);
1225         if (ret) {
1226                 pr_debug("sbp_handle_command: fetch page table failed: %d\n",
1227                         ret);
1228                 goto err;
1229         }
1230
1231         unpacked_lun = req->login->lun->unpacked_lun;
1232         sbp_calc_data_length_direction(req, &data_length, &data_dir);
1233
1234         pr_debug("sbp_handle_command ORB:0x%llx unpacked_lun:%d data_len:%d data_dir:%d\n",
1235                         req->orb_pointer, unpacked_lun, data_length, data_dir);
1236
1237         if (target_submit_cmd(&req->se_cmd, sess->se_sess, req->cmd_buf,
1238                               req->sense_buf, unpacked_lun, data_length,
1239                               TCM_SIMPLE_TAG, data_dir, 0))
1240                 goto err;
1241
1242         return;
1243
1244 err:
1245         req->status.status |= cpu_to_be32(
1246                 STATUS_BLOCK_RESP(STATUS_RESP_TRANSPORT_FAILURE) |
1247                 STATUS_BLOCK_DEAD(0) |
1248                 STATUS_BLOCK_LEN(1) |
1249                 STATUS_BLOCK_SBP_STATUS(SBP_STATUS_UNSPECIFIED_ERROR));
1250         sbp_send_status(req);
1251         sbp_free_request(req);
1252 }
1253
1254 /*
1255  * DMA_TO_DEVICE = read from initiator (SCSI WRITE)
1256  * DMA_FROM_DEVICE = write to initiator (SCSI READ)
1257  */
1258 static int sbp_rw_data(struct sbp_target_request *req)
1259 {
1260         struct sbp_session *sess = req->login->sess;
1261         int tcode, sg_miter_flags, max_payload, pg_size, speed, node_id,
1262                 generation, num_pte, length, tfr_length,
1263                 rcode = RCODE_COMPLETE;
1264         struct sbp_page_table_entry *pte;
1265         unsigned long long offset;
1266         struct fw_card *card;
1267         struct sg_mapping_iter iter;
1268
1269         if (req->se_cmd.data_direction == DMA_FROM_DEVICE) {
1270                 tcode = TCODE_WRITE_BLOCK_REQUEST;
1271                 sg_miter_flags = SG_MITER_FROM_SG;
1272         } else {
1273                 tcode = TCODE_READ_BLOCK_REQUEST;
1274                 sg_miter_flags = SG_MITER_TO_SG;
1275         }
1276
1277         max_payload = 4 << CMDBLK_ORB_MAX_PAYLOAD(be32_to_cpu(req->orb.misc));
1278         speed = CMDBLK_ORB_SPEED(be32_to_cpu(req->orb.misc));
1279
1280         pg_size = CMDBLK_ORB_PG_SIZE(be32_to_cpu(req->orb.misc));
1281         if (pg_size) {
1282                 pr_err("sbp_run_transaction: page size ignored\n");
1283                 pg_size = 0x100 << pg_size;
1284         }
1285
1286         spin_lock_bh(&sess->lock);
1287         card = fw_card_get(sess->card);
1288         node_id = sess->node_id;
1289         generation = sess->generation;
1290         spin_unlock_bh(&sess->lock);
1291
1292         if (req->pg_tbl) {
1293                 pte = req->pg_tbl;
1294                 num_pte = CMDBLK_ORB_DATA_SIZE(be32_to_cpu(req->orb.misc));
1295
1296                 offset = 0;
1297                 length = 0;
1298         } else {
1299                 pte = NULL;
1300                 num_pte = 0;
1301
1302                 offset = sbp2_pointer_to_addr(&req->orb.data_descriptor);
1303                 length = req->se_cmd.data_length;
1304         }
1305
1306         sg_miter_start(&iter, req->se_cmd.t_data_sg, req->se_cmd.t_data_nents,
1307                 sg_miter_flags);
1308
1309         while (length || num_pte) {
1310                 if (!length) {
1311                         offset = (u64)be16_to_cpu(pte->segment_base_hi) << 32 |
1312                                 be32_to_cpu(pte->segment_base_lo);
1313                         length = be16_to_cpu(pte->segment_length);
1314
1315                         pte++;
1316                         num_pte--;
1317                 }
1318
1319                 sg_miter_next(&iter);
1320
1321                 tfr_length = min3(length, max_payload, (int)iter.length);
1322
1323                 /* FIXME: take page_size into account */
1324
1325                 rcode = sbp_run_transaction(card, tcode, node_id,
1326                                 generation, speed,
1327                                 offset, iter.addr, tfr_length);
1328
1329                 if (rcode != RCODE_COMPLETE)
1330                         break;
1331
1332                 length -= tfr_length;
1333                 offset += tfr_length;
1334                 iter.consumed = tfr_length;
1335         }
1336
1337         sg_miter_stop(&iter);
1338         fw_card_put(card);
1339
1340         if (rcode == RCODE_COMPLETE) {
1341                 WARN_ON(length != 0);
1342                 return 0;
1343         } else {
1344                 return -EIO;
1345         }
1346 }
1347
1348 static int sbp_send_status(struct sbp_target_request *req)
1349 {
1350         int ret, length;
1351         struct sbp_login_descriptor *login = req->login;
1352
1353         length = (((be32_to_cpu(req->status.status) >> 24) & 0x07) + 1) * 4;
1354
1355         ret = sbp_run_request_transaction(req, TCODE_WRITE_BLOCK_REQUEST,
1356                         login->status_fifo_addr, &req->status, length);
1357         if (ret != RCODE_COMPLETE) {
1358                 pr_debug("sbp_send_status: write failed: 0x%x\n", ret);
1359                 return -EIO;
1360         }
1361
1362         pr_debug("sbp_send_status: status write complete for ORB: 0x%llx\n",
1363                         req->orb_pointer);
1364
1365         return 0;
1366 }
1367
1368 static void sbp_sense_mangle(struct sbp_target_request *req)
1369 {
1370         struct se_cmd *se_cmd = &req->se_cmd;
1371         u8 *sense = req->sense_buf;
1372         u8 *status = req->status.data;
1373
1374         WARN_ON(se_cmd->scsi_sense_length < 18);
1375
1376         switch (sense[0] & 0x7f) {              /* sfmt */
1377         case 0x70: /* current, fixed */
1378                 status[0] = 0 << 6;
1379                 break;
1380         case 0x71: /* deferred, fixed */
1381                 status[0] = 1 << 6;
1382                 break;
1383         case 0x72: /* current, descriptor */
1384         case 0x73: /* deferred, descriptor */
1385         default:
1386                 /*
1387                  * TODO: SBP-3 specifies what we should do with descriptor
1388                  * format sense data
1389                  */
1390                 pr_err("sbp_send_sense: unknown sense format: 0x%x\n",
1391                         sense[0]);
1392                 req->status.status |= cpu_to_be32(
1393                         STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
1394                         STATUS_BLOCK_DEAD(0) |
1395                         STATUS_BLOCK_LEN(1) |
1396                         STATUS_BLOCK_SBP_STATUS(SBP_STATUS_REQUEST_ABORTED));
1397                 return;
1398         }
1399
1400         status[0] |= se_cmd->scsi_status & 0x3f;/* status */
1401         status[1] =
1402                 (sense[0] & 0x80) |             /* valid */
1403                 ((sense[2] & 0xe0) >> 1) |      /* mark, eom, ili */
1404                 (sense[2] & 0x0f);              /* sense_key */
1405         status[2] = se_cmd->scsi_asc;           /* sense_code */
1406         status[3] = se_cmd->scsi_ascq;          /* sense_qualifier */
1407
1408         /* information */
1409         status[4] = sense[3];
1410         status[5] = sense[4];
1411         status[6] = sense[5];
1412         status[7] = sense[6];
1413
1414         /* CDB-dependent */
1415         status[8] = sense[8];
1416         status[9] = sense[9];
1417         status[10] = sense[10];
1418         status[11] = sense[11];
1419
1420         /* fru */
1421         status[12] = sense[14];
1422
1423         /* sense_key-dependent */
1424         status[13] = sense[15];
1425         status[14] = sense[16];
1426         status[15] = sense[17];
1427
1428         req->status.status |= cpu_to_be32(
1429                 STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
1430                 STATUS_BLOCK_DEAD(0) |
1431                 STATUS_BLOCK_LEN(5) |
1432                 STATUS_BLOCK_SBP_STATUS(SBP_STATUS_OK));
1433 }
1434
1435 static int sbp_send_sense(struct sbp_target_request *req)
1436 {
1437         struct se_cmd *se_cmd = &req->se_cmd;
1438
1439         if (se_cmd->scsi_sense_length) {
1440                 sbp_sense_mangle(req);
1441         } else {
1442                 req->status.status |= cpu_to_be32(
1443                         STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
1444                         STATUS_BLOCK_DEAD(0) |
1445                         STATUS_BLOCK_LEN(1) |
1446                         STATUS_BLOCK_SBP_STATUS(SBP_STATUS_OK));
1447         }
1448
1449         return sbp_send_status(req);
1450 }
1451
1452 static void sbp_free_request(struct sbp_target_request *req)
1453 {
1454         kfree(req->pg_tbl);
1455         kfree(req->cmd_buf);
1456         kfree(req);
1457 }
1458
1459 static void sbp_mgt_agent_process(struct work_struct *work)
1460 {
1461         struct sbp_management_agent *agent =
1462                 container_of(work, struct sbp_management_agent, work);
1463         struct sbp_management_request *req = agent->request;
1464         int ret;
1465         int status_data_len = 0;
1466
1467         /* fetch the ORB from the initiator */
1468         ret = sbp_run_transaction(req->card, TCODE_READ_BLOCK_REQUEST,
1469                 req->node_addr, req->generation, req->speed,
1470                 agent->orb_offset, &req->orb, sizeof(req->orb));
1471         if (ret != RCODE_COMPLETE) {
1472                 pr_debug("mgt_orb fetch failed: %x\n", ret);
1473                 goto out;
1474         }
1475
1476         pr_debug("mgt_orb ptr1:0x%llx ptr2:0x%llx misc:0x%x len:0x%x status_fifo:0x%llx\n",
1477                 sbp2_pointer_to_addr(&req->orb.ptr1),
1478                 sbp2_pointer_to_addr(&req->orb.ptr2),
1479                 be32_to_cpu(req->orb.misc), be32_to_cpu(req->orb.length),
1480                 sbp2_pointer_to_addr(&req->orb.status_fifo));
1481
1482         if (!ORB_NOTIFY(be32_to_cpu(req->orb.misc)) ||
1483                 ORB_REQUEST_FORMAT(be32_to_cpu(req->orb.misc)) != 0) {
1484                 pr_err("mgt_orb bad request\n");
1485                 goto out;
1486         }
1487
1488         switch (MANAGEMENT_ORB_FUNCTION(be32_to_cpu(req->orb.misc))) {
1489         case MANAGEMENT_ORB_FUNCTION_LOGIN:
1490                 sbp_management_request_login(agent, req, &status_data_len);
1491                 break;
1492
1493         case MANAGEMENT_ORB_FUNCTION_QUERY_LOGINS:
1494                 sbp_management_request_query_logins(agent, req,
1495                                 &status_data_len);
1496                 break;
1497
1498         case MANAGEMENT_ORB_FUNCTION_RECONNECT:
1499                 sbp_management_request_reconnect(agent, req, &status_data_len);
1500                 break;
1501
1502         case MANAGEMENT_ORB_FUNCTION_SET_PASSWORD:
1503                 pr_notice("SET PASSWORD not implemented\n");
1504
1505                 req->status.status = cpu_to_be32(
1506                         STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
1507                         STATUS_BLOCK_SBP_STATUS(SBP_STATUS_REQ_TYPE_NOTSUPP));
1508
1509                 break;
1510
1511         case MANAGEMENT_ORB_FUNCTION_LOGOUT:
1512                 sbp_management_request_logout(agent, req, &status_data_len);
1513                 break;
1514
1515         case MANAGEMENT_ORB_FUNCTION_ABORT_TASK:
1516                 pr_notice("ABORT TASK not implemented\n");
1517
1518                 req->status.status = cpu_to_be32(
1519                         STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
1520                         STATUS_BLOCK_SBP_STATUS(SBP_STATUS_REQ_TYPE_NOTSUPP));
1521
1522                 break;
1523
1524         case MANAGEMENT_ORB_FUNCTION_ABORT_TASK_SET:
1525                 pr_notice("ABORT TASK SET not implemented\n");
1526
1527                 req->status.status = cpu_to_be32(
1528                         STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
1529                         STATUS_BLOCK_SBP_STATUS(SBP_STATUS_REQ_TYPE_NOTSUPP));
1530
1531                 break;
1532
1533         case MANAGEMENT_ORB_FUNCTION_LOGICAL_UNIT_RESET:
1534                 pr_notice("LOGICAL UNIT RESET not implemented\n");
1535
1536                 req->status.status = cpu_to_be32(
1537                         STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
1538                         STATUS_BLOCK_SBP_STATUS(SBP_STATUS_REQ_TYPE_NOTSUPP));
1539
1540                 break;
1541
1542         case MANAGEMENT_ORB_FUNCTION_TARGET_RESET:
1543                 pr_notice("TARGET RESET not implemented\n");
1544
1545                 req->status.status = cpu_to_be32(
1546                         STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
1547                         STATUS_BLOCK_SBP_STATUS(SBP_STATUS_REQ_TYPE_NOTSUPP));
1548
1549                 break;
1550
1551         default:
1552                 pr_notice("unknown management function 0x%x\n",
1553                         MANAGEMENT_ORB_FUNCTION(be32_to_cpu(req->orb.misc)));
1554
1555                 req->status.status = cpu_to_be32(
1556                         STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
1557                         STATUS_BLOCK_SBP_STATUS(SBP_STATUS_REQ_TYPE_NOTSUPP));
1558
1559                 break;
1560         }
1561
1562         req->status.status |= cpu_to_be32(
1563                 STATUS_BLOCK_SRC(1) | /* Response to ORB, next_ORB absent */
1564                 STATUS_BLOCK_LEN(DIV_ROUND_UP(status_data_len, 4) + 1) |
1565                 STATUS_BLOCK_ORB_OFFSET_HIGH(agent->orb_offset >> 32));
1566         req->status.orb_low = cpu_to_be32(agent->orb_offset);
1567
1568         /* write the status block back to the initiator */
1569         ret = sbp_run_transaction(req->card, TCODE_WRITE_BLOCK_REQUEST,
1570                 req->node_addr, req->generation, req->speed,
1571                 sbp2_pointer_to_addr(&req->orb.status_fifo),
1572                 &req->status, 8 + status_data_len);
1573         if (ret != RCODE_COMPLETE) {
1574                 pr_debug("mgt_orb status write failed: %x\n", ret);
1575                 goto out;
1576         }
1577
1578 out:
1579         fw_card_put(req->card);
1580         kfree(req);
1581
1582         spin_lock_bh(&agent->lock);
1583         agent->state = MANAGEMENT_AGENT_STATE_IDLE;
1584         spin_unlock_bh(&agent->lock);
1585 }
1586
1587 static void sbp_mgt_agent_rw(struct fw_card *card,
1588         struct fw_request *request, int tcode, int destination, int source,
1589         int generation, unsigned long long offset, void *data, size_t length,
1590         void *callback_data)
1591 {
1592         struct sbp_management_agent *agent = callback_data;
1593         struct sbp2_pointer *ptr = data;
1594         int rcode = RCODE_ADDRESS_ERROR;
1595
1596         if (!agent->tport->enable)
1597                 goto out;
1598
1599         if ((offset != agent->handler.offset) || (length != 8))
1600                 goto out;
1601
1602         if (tcode == TCODE_WRITE_BLOCK_REQUEST) {
1603                 struct sbp_management_request *req;
1604                 int prev_state;
1605
1606                 spin_lock_bh(&agent->lock);
1607                 prev_state = agent->state;
1608                 agent->state = MANAGEMENT_AGENT_STATE_BUSY;
1609                 spin_unlock_bh(&agent->lock);
1610
1611                 if (prev_state == MANAGEMENT_AGENT_STATE_BUSY) {
1612                         pr_notice("ignoring management request while busy\n");
1613                         rcode = RCODE_CONFLICT_ERROR;
1614                         goto out;
1615                 }
1616
1617                 req = kzalloc(sizeof(*req), GFP_ATOMIC);
1618                 if (!req) {
1619                         rcode = RCODE_CONFLICT_ERROR;
1620                         goto out;
1621                 }
1622
1623                 req->card = fw_card_get(card);
1624                 req->generation = generation;
1625                 req->node_addr = source;
1626                 req->speed = fw_get_request_speed(request);
1627
1628                 agent->orb_offset = sbp2_pointer_to_addr(ptr);
1629                 agent->request = req;
1630
1631                 queue_work(system_unbound_wq, &agent->work);
1632                 rcode = RCODE_COMPLETE;
1633         } else if (tcode == TCODE_READ_BLOCK_REQUEST) {
1634                 addr_to_sbp2_pointer(agent->orb_offset, ptr);
1635                 rcode = RCODE_COMPLETE;
1636         } else {
1637                 rcode = RCODE_TYPE_ERROR;
1638         }
1639
1640 out:
1641         fw_send_response(card, request, rcode);
1642 }
1643
1644 static struct sbp_management_agent *sbp_management_agent_register(
1645                 struct sbp_tport *tport)
1646 {
1647         int ret;
1648         struct sbp_management_agent *agent;
1649
1650         agent = kmalloc(sizeof(*agent), GFP_KERNEL);
1651         if (!agent)
1652                 return ERR_PTR(-ENOMEM);
1653
1654         spin_lock_init(&agent->lock);
1655         agent->tport = tport;
1656         agent->handler.length = 0x08;
1657         agent->handler.address_callback = sbp_mgt_agent_rw;
1658         agent->handler.callback_data = agent;
1659         agent->state = MANAGEMENT_AGENT_STATE_IDLE;
1660         INIT_WORK(&agent->work, sbp_mgt_agent_process);
1661         agent->orb_offset = 0;
1662         agent->request = NULL;
1663
1664         ret = fw_core_add_address_handler(&agent->handler,
1665                         &sbp_register_region);
1666         if (ret < 0) {
1667                 kfree(agent);
1668                 return ERR_PTR(ret);
1669         }
1670
1671         return agent;
1672 }
1673
1674 static void sbp_management_agent_unregister(struct sbp_management_agent *agent)
1675 {
1676         fw_core_remove_address_handler(&agent->handler);
1677         cancel_work_sync(&agent->work);
1678         kfree(agent);
1679 }
1680
1681 static int sbp_check_true(struct se_portal_group *se_tpg)
1682 {
1683         return 1;
1684 }
1685
1686 static int sbp_check_false(struct se_portal_group *se_tpg)
1687 {
1688         return 0;
1689 }
1690
1691 static char *sbp_get_fabric_name(void)
1692 {
1693         return "sbp";
1694 }
1695
1696 static char *sbp_get_fabric_wwn(struct se_portal_group *se_tpg)
1697 {
1698         struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
1699         struct sbp_tport *tport = tpg->tport;
1700
1701         return &tport->tport_name[0];
1702 }
1703
1704 static u16 sbp_get_tag(struct se_portal_group *se_tpg)
1705 {
1706         struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
1707         return tpg->tport_tpgt;
1708 }
1709
1710 static u32 sbp_get_default_depth(struct se_portal_group *se_tpg)
1711 {
1712         return 1;
1713 }
1714
1715 static struct se_node_acl *sbp_alloc_fabric_acl(struct se_portal_group *se_tpg)
1716 {
1717         struct sbp_nacl *nacl;
1718
1719         nacl = kzalloc(sizeof(struct sbp_nacl), GFP_KERNEL);
1720         if (!nacl) {
1721                 pr_err("Unable to allocate struct sbp_nacl\n");
1722                 return NULL;
1723         }
1724
1725         return &nacl->se_node_acl;
1726 }
1727
1728 static void sbp_release_fabric_acl(
1729         struct se_portal_group *se_tpg,
1730         struct se_node_acl *se_nacl)
1731 {
1732         struct sbp_nacl *nacl =
1733                 container_of(se_nacl, struct sbp_nacl, se_node_acl);
1734         kfree(nacl);
1735 }
1736
1737 static u32 sbp_tpg_get_inst_index(struct se_portal_group *se_tpg)
1738 {
1739         return 1;
1740 }
1741
1742 static void sbp_release_cmd(struct se_cmd *se_cmd)
1743 {
1744         struct sbp_target_request *req = container_of(se_cmd,
1745                         struct sbp_target_request, se_cmd);
1746
1747         sbp_free_request(req);
1748 }
1749
1750 static int sbp_shutdown_session(struct se_session *se_sess)
1751 {
1752         return 0;
1753 }
1754
1755 static void sbp_close_session(struct se_session *se_sess)
1756 {
1757         return;
1758 }
1759
1760 static u32 sbp_sess_get_index(struct se_session *se_sess)
1761 {
1762         return 0;
1763 }
1764
1765 static int sbp_write_pending(struct se_cmd *se_cmd)
1766 {
1767         struct sbp_target_request *req = container_of(se_cmd,
1768                         struct sbp_target_request, se_cmd);
1769         int ret;
1770
1771         ret = sbp_rw_data(req);
1772         if (ret) {
1773                 req->status.status |= cpu_to_be32(
1774                         STATUS_BLOCK_RESP(
1775                                 STATUS_RESP_TRANSPORT_FAILURE) |
1776                         STATUS_BLOCK_DEAD(0) |
1777                         STATUS_BLOCK_LEN(1) |
1778                         STATUS_BLOCK_SBP_STATUS(
1779                                 SBP_STATUS_UNSPECIFIED_ERROR));
1780                 sbp_send_status(req);
1781                 return ret;
1782         }
1783
1784         target_execute_cmd(se_cmd);
1785         return 0;
1786 }
1787
1788 static int sbp_write_pending_status(struct se_cmd *se_cmd)
1789 {
1790         return 0;
1791 }
1792
1793 static void sbp_set_default_node_attrs(struct se_node_acl *nacl)
1794 {
1795         return;
1796 }
1797
1798 static u32 sbp_get_task_tag(struct se_cmd *se_cmd)
1799 {
1800         struct sbp_target_request *req = container_of(se_cmd,
1801                         struct sbp_target_request, se_cmd);
1802
1803         /* only used for printk until we do TMRs */
1804         return (u32)req->orb_pointer;
1805 }
1806
1807 static int sbp_get_cmd_state(struct se_cmd *se_cmd)
1808 {
1809         return 0;
1810 }
1811
1812 static int sbp_queue_data_in(struct se_cmd *se_cmd)
1813 {
1814         struct sbp_target_request *req = container_of(se_cmd,
1815                         struct sbp_target_request, se_cmd);
1816         int ret;
1817
1818         ret = sbp_rw_data(req);
1819         if (ret) {
1820                 req->status.status |= cpu_to_be32(
1821                         STATUS_BLOCK_RESP(STATUS_RESP_TRANSPORT_FAILURE) |
1822                         STATUS_BLOCK_DEAD(0) |
1823                         STATUS_BLOCK_LEN(1) |
1824                         STATUS_BLOCK_SBP_STATUS(SBP_STATUS_UNSPECIFIED_ERROR));
1825                 sbp_send_status(req);
1826                 return ret;
1827         }
1828
1829         return sbp_send_sense(req);
1830 }
1831
1832 /*
1833  * Called after command (no data transfer) or after the write (to device)
1834  * operation is completed
1835  */
1836 static int sbp_queue_status(struct se_cmd *se_cmd)
1837 {
1838         struct sbp_target_request *req = container_of(se_cmd,
1839                         struct sbp_target_request, se_cmd);
1840
1841         return sbp_send_sense(req);
1842 }
1843
1844 static void sbp_queue_tm_rsp(struct se_cmd *se_cmd)
1845 {
1846 }
1847
1848 static void sbp_aborted_task(struct se_cmd *se_cmd)
1849 {
1850         return;
1851 }
1852
1853 static int sbp_check_stop_free(struct se_cmd *se_cmd)
1854 {
1855         struct sbp_target_request *req = container_of(se_cmd,
1856                         struct sbp_target_request, se_cmd);
1857
1858         transport_generic_free_cmd(&req->se_cmd, 0);
1859         return 1;
1860 }
1861
1862 /*
1863  * Handlers for Serial Bus Protocol 2/3 (SBP-2 / SBP-3)
1864  */
1865 static u8 sbp_get_fabric_proto_ident(struct se_portal_group *se_tpg)
1866 {
1867         /*
1868          * Return a IEEE 1394 SCSI Protocol identifier for loopback operations
1869          * This is defined in section 7.5.1 Table 362 in spc4r17
1870          */
1871         return SCSI_PROTOCOL_SBP;
1872 }
1873
1874 static u32 sbp_get_pr_transport_id(
1875         struct se_portal_group *se_tpg,
1876         struct se_node_acl *se_nacl,
1877         struct t10_pr_registration *pr_reg,
1878         int *format_code,
1879         unsigned char *buf)
1880 {
1881         int ret;
1882
1883         /*
1884          * Set PROTOCOL IDENTIFIER to 3h for SBP
1885          */
1886         buf[0] = SCSI_PROTOCOL_SBP;
1887         /*
1888          * From spc4r17, 7.5.4.4 TransportID for initiator ports using SCSI
1889          * over IEEE 1394
1890          */
1891         ret = hex2bin(&buf[8], se_nacl->initiatorname, 8);
1892         if (ret < 0)
1893                 pr_debug("sbp transport_id: invalid hex string\n");
1894
1895         /*
1896          * The IEEE 1394 Transport ID is a hardcoded 24-byte length
1897          */
1898         return 24;
1899 }
1900
1901 static u32 sbp_get_pr_transport_id_len(
1902         struct se_portal_group *se_tpg,
1903         struct se_node_acl *se_nacl,
1904         struct t10_pr_registration *pr_reg,
1905         int *format_code)
1906 {
1907         *format_code = 0;
1908         /*
1909          * From spc4r17, 7.5.4.4 TransportID for initiator ports using SCSI
1910          * over IEEE 1394
1911          *
1912          * The SBP Transport ID is a hardcoded 24-byte length
1913          */
1914         return 24;
1915 }
1916
1917 /*
1918  * Used for handling SCSI fabric dependent TransportIDs in SPC-3 and above
1919  * Persistent Reservation SPEC_I_PT=1 and PROUT REGISTER_AND_MOVE operations.
1920  */
1921 static char *sbp_parse_pr_out_transport_id(
1922         struct se_portal_group *se_tpg,
1923         const char *buf,
1924         u32 *out_tid_len,
1925         char **port_nexus_ptr)
1926 {
1927         /*
1928          * Assume the FORMAT CODE 00b from spc4r17, 7.5.4.4 TransportID
1929          * for initiator ports using SCSI over SBP Serial SCSI Protocol
1930          *
1931          * The TransportID for a IEEE 1394 Initiator Port is of fixed size of
1932          * 24 bytes, and IEEE 1394 does not contain a I_T nexus identifier,
1933          * so we return the **port_nexus_ptr set to NULL.
1934          */
1935         *port_nexus_ptr = NULL;
1936         *out_tid_len = 24;
1937
1938         return (char *)&buf[8];
1939 }
1940
1941 static int sbp_count_se_tpg_luns(struct se_portal_group *tpg)
1942 {
1943         int i, count = 0;
1944
1945         spin_lock(&tpg->tpg_lun_lock);
1946         for (i = 0; i < TRANSPORT_MAX_LUNS_PER_TPG; i++) {
1947                 struct se_lun *se_lun = tpg->tpg_lun_list[i];
1948
1949                 if (se_lun->lun_status == TRANSPORT_LUN_STATUS_FREE)
1950                         continue;
1951
1952                 count++;
1953         }
1954         spin_unlock(&tpg->tpg_lun_lock);
1955
1956         return count;
1957 }
1958
1959 static int sbp_update_unit_directory(struct sbp_tport *tport)
1960 {
1961         int num_luns, num_entries, idx = 0, mgt_agt_addr, ret, i;
1962         u32 *data;
1963
1964         if (tport->unit_directory.data) {
1965                 fw_core_remove_descriptor(&tport->unit_directory);
1966                 kfree(tport->unit_directory.data);
1967                 tport->unit_directory.data = NULL;
1968         }
1969
1970         if (!tport->enable || !tport->tpg)
1971                 return 0;
1972
1973         num_luns = sbp_count_se_tpg_luns(&tport->tpg->se_tpg);
1974
1975         /*
1976          * Number of entries in the final unit directory:
1977          *  - all of those in the template
1978          *  - management_agent
1979          *  - unit_characteristics
1980          *  - reconnect_timeout
1981          *  - unit unique ID
1982          *  - one for each LUN
1983          *
1984          *  MUST NOT include leaf or sub-directory entries
1985          */
1986         num_entries = ARRAY_SIZE(sbp_unit_directory_template) + 4 + num_luns;
1987
1988         if (tport->directory_id != -1)
1989                 num_entries++;
1990
1991         /* allocate num_entries + 4 for the header and unique ID leaf */
1992         data = kcalloc((num_entries + 4), sizeof(u32), GFP_KERNEL);
1993         if (!data)
1994                 return -ENOMEM;
1995
1996         /* directory_length */
1997         data[idx++] = num_entries << 16;
1998
1999         /* directory_id */
2000         if (tport->directory_id != -1)
2001                 data[idx++] = (CSR_DIRECTORY_ID << 24) | tport->directory_id;
2002
2003         /* unit directory template */
2004         memcpy(&data[idx], sbp_unit_directory_template,
2005                         sizeof(sbp_unit_directory_template));
2006         idx += ARRAY_SIZE(sbp_unit_directory_template);
2007
2008         /* management_agent */
2009         mgt_agt_addr = (tport->mgt_agt->handler.offset - CSR_REGISTER_BASE) / 4;
2010         data[idx++] = 0x54000000 | (mgt_agt_addr & 0x00ffffff);
2011
2012         /* unit_characteristics */
2013         data[idx++] = 0x3a000000 |
2014                 (((tport->mgt_orb_timeout * 2) << 8) & 0xff00) |
2015                 SBP_ORB_FETCH_SIZE;
2016
2017         /* reconnect_timeout */
2018         data[idx++] = 0x3d000000 | (tport->max_reconnect_timeout & 0xffff);
2019
2020         /* unit unique ID (leaf is just after LUNs) */
2021         data[idx++] = 0x8d000000 | (num_luns + 1);
2022
2023         spin_lock(&tport->tpg->se_tpg.tpg_lun_lock);
2024         for (i = 0; i < TRANSPORT_MAX_LUNS_PER_TPG; i++) {
2025                 struct se_lun *se_lun = tport->tpg->se_tpg.tpg_lun_list[i];
2026                 struct se_device *dev;
2027                 int type;
2028
2029                 if (se_lun->lun_status == TRANSPORT_LUN_STATUS_FREE)
2030                         continue;
2031
2032                 spin_unlock(&tport->tpg->se_tpg.tpg_lun_lock);
2033
2034                 dev = se_lun->lun_se_dev;
2035                 type = dev->transport->get_device_type(dev);
2036
2037                 /* logical_unit_number */
2038                 data[idx++] = 0x14000000 |
2039                         ((type << 16) & 0x1f0000) |
2040                         (se_lun->unpacked_lun & 0xffff);
2041
2042                 spin_lock(&tport->tpg->se_tpg.tpg_lun_lock);
2043         }
2044         spin_unlock(&tport->tpg->se_tpg.tpg_lun_lock);
2045
2046         /* unit unique ID leaf */
2047         data[idx++] = 2 << 16;
2048         data[idx++] = tport->guid >> 32;
2049         data[idx++] = tport->guid;
2050
2051         tport->unit_directory.length = idx;
2052         tport->unit_directory.key = (CSR_DIRECTORY | CSR_UNIT) << 24;
2053         tport->unit_directory.data = data;
2054
2055         ret = fw_core_add_descriptor(&tport->unit_directory);
2056         if (ret < 0) {
2057                 kfree(tport->unit_directory.data);
2058                 tport->unit_directory.data = NULL;
2059         }
2060
2061         return ret;
2062 }
2063
2064 static ssize_t sbp_parse_wwn(const char *name, u64 *wwn)
2065 {
2066         const char *cp;
2067         char c, nibble;
2068         int pos = 0, err;
2069
2070         *wwn = 0;
2071         for (cp = name; cp < &name[SBP_NAMELEN - 1]; cp++) {
2072                 c = *cp;
2073                 if (c == '\n' && cp[1] == '\0')
2074                         continue;
2075                 if (c == '\0') {
2076                         err = 2;
2077                         if (pos != 16)
2078                                 goto fail;
2079                         return cp - name;
2080                 }
2081                 err = 3;
2082                 if (isdigit(c))
2083                         nibble = c - '0';
2084                 else if (isxdigit(c))
2085                         nibble = tolower(c) - 'a' + 10;
2086                 else
2087                         goto fail;
2088                 *wwn = (*wwn << 4) | nibble;
2089                 pos++;
2090         }
2091         err = 4;
2092 fail:
2093         printk(KERN_INFO "err %u len %zu pos %u\n",
2094                         err, cp - name, pos);
2095         return -1;
2096 }
2097
2098 static ssize_t sbp_format_wwn(char *buf, size_t len, u64 wwn)
2099 {
2100         return snprintf(buf, len, "%016llx", wwn);
2101 }
2102
2103 static struct se_node_acl *sbp_make_nodeacl(
2104                 struct se_portal_group *se_tpg,
2105                 struct config_group *group,
2106                 const char *name)
2107 {
2108         struct se_node_acl *se_nacl, *se_nacl_new;
2109         struct sbp_nacl *nacl;
2110         u64 guid = 0;
2111         u32 nexus_depth = 1;
2112
2113         if (sbp_parse_wwn(name, &guid) < 0)
2114                 return ERR_PTR(-EINVAL);
2115
2116         se_nacl_new = sbp_alloc_fabric_acl(se_tpg);
2117         if (!se_nacl_new)
2118                 return ERR_PTR(-ENOMEM);
2119
2120         /*
2121          * se_nacl_new may be released by core_tpg_add_initiator_node_acl()
2122          * when converting a NodeACL from demo mode -> explict
2123          */
2124         se_nacl = core_tpg_add_initiator_node_acl(se_tpg, se_nacl_new,
2125                         name, nexus_depth);
2126         if (IS_ERR(se_nacl)) {
2127                 sbp_release_fabric_acl(se_tpg, se_nacl_new);
2128                 return se_nacl;
2129         }
2130
2131         nacl = container_of(se_nacl, struct sbp_nacl, se_node_acl);
2132         nacl->guid = guid;
2133         sbp_format_wwn(nacl->iport_name, SBP_NAMELEN, guid);
2134
2135         return se_nacl;
2136 }
2137
2138 static void sbp_drop_nodeacl(struct se_node_acl *se_acl)
2139 {
2140         struct sbp_nacl *nacl =
2141                 container_of(se_acl, struct sbp_nacl, se_node_acl);
2142
2143         core_tpg_del_initiator_node_acl(se_acl->se_tpg, se_acl, 1);
2144         kfree(nacl);
2145 }
2146
2147 static int sbp_post_link_lun(
2148                 struct se_portal_group *se_tpg,
2149                 struct se_lun *se_lun)
2150 {
2151         struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
2152
2153         return sbp_update_unit_directory(tpg->tport);
2154 }
2155
2156 static void sbp_pre_unlink_lun(
2157                 struct se_portal_group *se_tpg,
2158                 struct se_lun *se_lun)
2159 {
2160         struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
2161         struct sbp_tport *tport = tpg->tport;
2162         int ret;
2163
2164         if (sbp_count_se_tpg_luns(&tpg->se_tpg) == 0)
2165                 tport->enable = 0;
2166
2167         ret = sbp_update_unit_directory(tport);
2168         if (ret < 0)
2169                 pr_err("unlink LUN: failed to update unit directory\n");
2170 }
2171
2172 static struct se_portal_group *sbp_make_tpg(
2173                 struct se_wwn *wwn,
2174                 struct config_group *group,
2175                 const char *name)
2176 {
2177         struct sbp_tport *tport =
2178                 container_of(wwn, struct sbp_tport, tport_wwn);
2179
2180         struct sbp_tpg *tpg;
2181         unsigned long tpgt;
2182         int ret;
2183
2184         if (strstr(name, "tpgt_") != name)
2185                 return ERR_PTR(-EINVAL);
2186         if (kstrtoul(name + 5, 10, &tpgt) || tpgt > UINT_MAX)
2187                 return ERR_PTR(-EINVAL);
2188
2189         if (tport->tpg) {
2190                 pr_err("Only one TPG per Unit is possible.\n");
2191                 return ERR_PTR(-EBUSY);
2192         }
2193
2194         tpg = kzalloc(sizeof(*tpg), GFP_KERNEL);
2195         if (!tpg) {
2196                 pr_err("Unable to allocate struct sbp_tpg\n");
2197                 return ERR_PTR(-ENOMEM);
2198         }
2199
2200         tpg->tport = tport;
2201         tpg->tport_tpgt = tpgt;
2202         tport->tpg = tpg;
2203
2204         /* default attribute values */
2205         tport->enable = 0;
2206         tport->directory_id = -1;
2207         tport->mgt_orb_timeout = 15;
2208         tport->max_reconnect_timeout = 5;
2209         tport->max_logins_per_lun = 1;
2210
2211         tport->mgt_agt = sbp_management_agent_register(tport);
2212         if (IS_ERR(tport->mgt_agt)) {
2213                 ret = PTR_ERR(tport->mgt_agt);
2214                 goto out_free_tpg;
2215         }
2216
2217         ret = core_tpg_register(&sbp_ops, wwn, &tpg->se_tpg, tpg,
2218                         TRANSPORT_TPG_TYPE_NORMAL);
2219         if (ret < 0)
2220                 goto out_unreg_mgt_agt;
2221
2222         return &tpg->se_tpg;
2223
2224 out_unreg_mgt_agt:
2225         sbp_management_agent_unregister(tport->mgt_agt);
2226 out_free_tpg:
2227         tport->tpg = NULL;
2228         kfree(tpg);
2229         return ERR_PTR(ret);
2230 }
2231
2232 static void sbp_drop_tpg(struct se_portal_group *se_tpg)
2233 {
2234         struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
2235         struct sbp_tport *tport = tpg->tport;
2236
2237         core_tpg_deregister(se_tpg);
2238         sbp_management_agent_unregister(tport->mgt_agt);
2239         tport->tpg = NULL;
2240         kfree(tpg);
2241 }
2242
2243 static struct se_wwn *sbp_make_tport(
2244                 struct target_fabric_configfs *tf,
2245                 struct config_group *group,
2246                 const char *name)
2247 {
2248         struct sbp_tport *tport;
2249         u64 guid = 0;
2250
2251         if (sbp_parse_wwn(name, &guid) < 0)
2252                 return ERR_PTR(-EINVAL);
2253
2254         tport = kzalloc(sizeof(*tport), GFP_KERNEL);
2255         if (!tport) {
2256                 pr_err("Unable to allocate struct sbp_tport\n");
2257                 return ERR_PTR(-ENOMEM);
2258         }
2259
2260         tport->guid = guid;
2261         sbp_format_wwn(tport->tport_name, SBP_NAMELEN, guid);
2262
2263         return &tport->tport_wwn;
2264 }
2265
2266 static void sbp_drop_tport(struct se_wwn *wwn)
2267 {
2268         struct sbp_tport *tport =
2269                 container_of(wwn, struct sbp_tport, tport_wwn);
2270
2271         kfree(tport);
2272 }
2273
2274 static ssize_t sbp_wwn_show_attr_version(
2275                 struct target_fabric_configfs *tf,
2276                 char *page)
2277 {
2278         return sprintf(page, "FireWire SBP fabric module %s\n", SBP_VERSION);
2279 }
2280
2281 TF_WWN_ATTR_RO(sbp, version);
2282
2283 static struct configfs_attribute *sbp_wwn_attrs[] = {
2284         &sbp_wwn_version.attr,
2285         NULL,
2286 };
2287
2288 static ssize_t sbp_tpg_show_directory_id(
2289                 struct se_portal_group *se_tpg,
2290                 char *page)
2291 {
2292         struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
2293         struct sbp_tport *tport = tpg->tport;
2294
2295         if (tport->directory_id == -1)
2296                 return sprintf(page, "implicit\n");
2297         else
2298                 return sprintf(page, "%06x\n", tport->directory_id);
2299 }
2300
2301 static ssize_t sbp_tpg_store_directory_id(
2302                 struct se_portal_group *se_tpg,
2303                 const char *page,
2304                 size_t count)
2305 {
2306         struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
2307         struct sbp_tport *tport = tpg->tport;
2308         unsigned long val;
2309
2310         if (tport->enable) {
2311                 pr_err("Cannot change the directory_id on an active target.\n");
2312                 return -EBUSY;
2313         }
2314
2315         if (strstr(page, "implicit") == page) {
2316                 tport->directory_id = -1;
2317         } else {
2318                 if (kstrtoul(page, 16, &val) < 0)
2319                         return -EINVAL;
2320                 if (val > 0xffffff)
2321                         return -EINVAL;
2322
2323                 tport->directory_id = val;
2324         }
2325
2326         return count;
2327 }
2328
2329 static ssize_t sbp_tpg_show_enable(
2330                 struct se_portal_group *se_tpg,
2331                 char *page)
2332 {
2333         struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
2334         struct sbp_tport *tport = tpg->tport;
2335         return sprintf(page, "%d\n", tport->enable);
2336 }
2337
2338 static ssize_t sbp_tpg_store_enable(
2339                 struct se_portal_group *se_tpg,
2340                 const char *page,
2341                 size_t count)
2342 {
2343         struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
2344         struct sbp_tport *tport = tpg->tport;
2345         unsigned long val;
2346         int ret;
2347
2348         if (kstrtoul(page, 0, &val) < 0)
2349                 return -EINVAL;
2350         if ((val != 0) && (val != 1))
2351                 return -EINVAL;
2352
2353         if (tport->enable == val)
2354                 return count;
2355
2356         if (val) {
2357                 if (sbp_count_se_tpg_luns(&tpg->se_tpg) == 0) {
2358                         pr_err("Cannot enable a target with no LUNs!\n");
2359                         return -EINVAL;
2360                 }
2361         } else {
2362                 /* XXX: force-shutdown sessions instead? */
2363                 spin_lock_bh(&se_tpg->session_lock);
2364                 if (!list_empty(&se_tpg->tpg_sess_list)) {
2365                         spin_unlock_bh(&se_tpg->session_lock);
2366                         return -EBUSY;
2367                 }
2368                 spin_unlock_bh(&se_tpg->session_lock);
2369         }
2370
2371         tport->enable = val;
2372
2373         ret = sbp_update_unit_directory(tport);
2374         if (ret < 0) {
2375                 pr_err("Could not update Config ROM\n");
2376                 return ret;
2377         }
2378
2379         return count;
2380 }
2381
2382 TF_TPG_BASE_ATTR(sbp, directory_id, S_IRUGO | S_IWUSR);
2383 TF_TPG_BASE_ATTR(sbp, enable, S_IRUGO | S_IWUSR);
2384
2385 static struct configfs_attribute *sbp_tpg_base_attrs[] = {
2386         &sbp_tpg_directory_id.attr,
2387         &sbp_tpg_enable.attr,
2388         NULL,
2389 };
2390
2391 static ssize_t sbp_tpg_attrib_show_mgt_orb_timeout(
2392                 struct se_portal_group *se_tpg,
2393                 char *page)
2394 {
2395         struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
2396         struct sbp_tport *tport = tpg->tport;
2397         return sprintf(page, "%d\n", tport->mgt_orb_timeout);
2398 }
2399
2400 static ssize_t sbp_tpg_attrib_store_mgt_orb_timeout(
2401                 struct se_portal_group *se_tpg,
2402                 const char *page,
2403                 size_t count)
2404 {
2405         struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
2406         struct sbp_tport *tport = tpg->tport;
2407         unsigned long val;
2408         int ret;
2409
2410         if (kstrtoul(page, 0, &val) < 0)
2411                 return -EINVAL;
2412         if ((val < 1) || (val > 127))
2413                 return -EINVAL;
2414
2415         if (tport->mgt_orb_timeout == val)
2416                 return count;
2417
2418         tport->mgt_orb_timeout = val;
2419
2420         ret = sbp_update_unit_directory(tport);
2421         if (ret < 0)
2422                 return ret;
2423
2424         return count;
2425 }
2426
2427 static ssize_t sbp_tpg_attrib_show_max_reconnect_timeout(
2428                 struct se_portal_group *se_tpg,
2429                 char *page)
2430 {
2431         struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
2432         struct sbp_tport *tport = tpg->tport;
2433         return sprintf(page, "%d\n", tport->max_reconnect_timeout);
2434 }
2435
2436 static ssize_t sbp_tpg_attrib_store_max_reconnect_timeout(
2437                 struct se_portal_group *se_tpg,
2438                 const char *page,
2439                 size_t count)
2440 {
2441         struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
2442         struct sbp_tport *tport = tpg->tport;
2443         unsigned long val;
2444         int ret;
2445
2446         if (kstrtoul(page, 0, &val) < 0)
2447                 return -EINVAL;
2448         if ((val < 1) || (val > 32767))
2449                 return -EINVAL;
2450
2451         if (tport->max_reconnect_timeout == val)
2452                 return count;
2453
2454         tport->max_reconnect_timeout = val;
2455
2456         ret = sbp_update_unit_directory(tport);
2457         if (ret < 0)
2458                 return ret;
2459
2460         return count;
2461 }
2462
2463 static ssize_t sbp_tpg_attrib_show_max_logins_per_lun(
2464                 struct se_portal_group *se_tpg,
2465                 char *page)
2466 {
2467         struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
2468         struct sbp_tport *tport = tpg->tport;
2469         return sprintf(page, "%d\n", tport->max_logins_per_lun);
2470 }
2471
2472 static ssize_t sbp_tpg_attrib_store_max_logins_per_lun(
2473                 struct se_portal_group *se_tpg,
2474                 const char *page,
2475                 size_t count)
2476 {
2477         struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
2478         struct sbp_tport *tport = tpg->tport;
2479         unsigned long val;
2480
2481         if (kstrtoul(page, 0, &val) < 0)
2482                 return -EINVAL;
2483         if ((val < 1) || (val > 127))
2484                 return -EINVAL;
2485
2486         /* XXX: also check against current count? */
2487
2488         tport->max_logins_per_lun = val;
2489
2490         return count;
2491 }
2492
2493 TF_TPG_ATTRIB_ATTR(sbp, mgt_orb_timeout, S_IRUGO | S_IWUSR);
2494 TF_TPG_ATTRIB_ATTR(sbp, max_reconnect_timeout, S_IRUGO | S_IWUSR);
2495 TF_TPG_ATTRIB_ATTR(sbp, max_logins_per_lun, S_IRUGO | S_IWUSR);
2496
2497 static struct configfs_attribute *sbp_tpg_attrib_attrs[] = {
2498         &sbp_tpg_attrib_mgt_orb_timeout.attr,
2499         &sbp_tpg_attrib_max_reconnect_timeout.attr,
2500         &sbp_tpg_attrib_max_logins_per_lun.attr,
2501         NULL,
2502 };
2503
2504 static const struct target_core_fabric_ops sbp_ops = {
2505         .module                         = THIS_MODULE,
2506         .name                           = "sbp",
2507         .get_fabric_name                = sbp_get_fabric_name,
2508         .get_fabric_proto_ident         = sbp_get_fabric_proto_ident,
2509         .tpg_get_wwn                    = sbp_get_fabric_wwn,
2510         .tpg_get_tag                    = sbp_get_tag,
2511         .tpg_get_default_depth          = sbp_get_default_depth,
2512         .tpg_get_pr_transport_id        = sbp_get_pr_transport_id,
2513         .tpg_get_pr_transport_id_len    = sbp_get_pr_transport_id_len,
2514         .tpg_parse_pr_out_transport_id  = sbp_parse_pr_out_transport_id,
2515         .tpg_check_demo_mode            = sbp_check_true,
2516         .tpg_check_demo_mode_cache      = sbp_check_true,
2517         .tpg_check_demo_mode_write_protect = sbp_check_false,
2518         .tpg_check_prod_mode_write_protect = sbp_check_false,
2519         .tpg_alloc_fabric_acl           = sbp_alloc_fabric_acl,
2520         .tpg_release_fabric_acl         = sbp_release_fabric_acl,
2521         .tpg_get_inst_index             = sbp_tpg_get_inst_index,
2522         .release_cmd                    = sbp_release_cmd,
2523         .shutdown_session               = sbp_shutdown_session,
2524         .close_session                  = sbp_close_session,
2525         .sess_get_index                 = sbp_sess_get_index,
2526         .write_pending                  = sbp_write_pending,
2527         .write_pending_status           = sbp_write_pending_status,
2528         .set_default_node_attributes    = sbp_set_default_node_attrs,
2529         .get_task_tag                   = sbp_get_task_tag,
2530         .get_cmd_state                  = sbp_get_cmd_state,
2531         .queue_data_in                  = sbp_queue_data_in,
2532         .queue_status                   = sbp_queue_status,
2533         .queue_tm_rsp                   = sbp_queue_tm_rsp,
2534         .aborted_task                   = sbp_aborted_task,
2535         .check_stop_free                = sbp_check_stop_free,
2536
2537         .fabric_make_wwn                = sbp_make_tport,
2538         .fabric_drop_wwn                = sbp_drop_tport,
2539         .fabric_make_tpg                = sbp_make_tpg,
2540         .fabric_drop_tpg                = sbp_drop_tpg,
2541         .fabric_post_link               = sbp_post_link_lun,
2542         .fabric_pre_unlink              = sbp_pre_unlink_lun,
2543         .fabric_make_np                 = NULL,
2544         .fabric_drop_np                 = NULL,
2545         .fabric_make_nodeacl            = sbp_make_nodeacl,
2546         .fabric_drop_nodeacl            = sbp_drop_nodeacl,
2547
2548         .tfc_wwn_attrs                  = sbp_wwn_attrs,
2549         .tfc_tpg_base_attrs             = sbp_tpg_base_attrs,
2550         .tfc_tpg_attrib_attrs           = sbp_tpg_attrib_attrs,
2551 };
2552
2553 static int __init sbp_init(void)
2554 {
2555         return target_register_template(&sbp_ops);
2556 };
2557
2558 static void __exit sbp_exit(void)
2559 {
2560         target_unregister_template(&sbp_ops);
2561 };
2562
2563 MODULE_DESCRIPTION("FireWire SBP fabric driver");
2564 MODULE_LICENSE("GPL");
2565 module_init(sbp_init);
2566 module_exit(sbp_exit);