qla_isp/linux/isp_scst.c

   1 /*
   2  *  Copyright (c) 1997-2007 by Matthew Jacob
   3  *  All rights reserved.
   4  *
   5  *  Redistribution and use in source and binary forms, with or without
   6  *  modification, are permitted provided that the following conditions
   7  *  are met:
   8  *
   9  *  1. Redistributions of source code must retain the above copyright
  10  *     notice, this list of conditions and the following disclaimer.
  11  *  2. Redistributions in binary form must reproduce the above copyright
  12  *     notice, this list of conditions and the following disclaimer in the
  13  *     documentation and/or other materials provided with the distribution.
  14  *
  15  *  THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  *  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  *  ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
  19  *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  *  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  *  OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  *  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  *  OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  *  SUCH DAMAGE.
  26  *
  27  *
  28  *  Alternatively, this software may be distributed under the terms of the
  29  *  the GNU Public License ("GPL") with platforms where the prevalant license
  30  *  is the GNU Public License:
  31  *
  32  *   This program is free software; you can redistribute it and/or modify
  33  *   it under the terms of The Version 2 GNU General Public License as published
  34  *    by the Free Software Foundation.
  35  *
  36  *   This program is distributed in the hope that it will be useful,
  37  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  38  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  39  *   GNU General Public License for more details.
  40  *
  41  *   You should have received a copy of the GNU General Public License
  42  *   along with this program; if not, write to the Free Software
  43  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  44  *
  45  *
  46  *  Matthew Jacob
  47  *  Feral Software
  48  *  421 Laurel Avenue
  49  *  Menlo Park, CA 94025
  50  *  USA
  51  *
  52  *  gplbsd at feral com
  53  *
  54  */
  55
  56 /*
  57  * Qlogic ISP target driver for SCST.
  58  * Copyright (c) 2007 Stanislaw Gruszka
  59  * Copyright (c) 2007, 2008 Open-E Inc
  60  */
  61
  62 /*
  63  * This file connects tpublic API from the low level ISP driver (see common/isp_tpublic.h)
  64  * with the SCST target driver API. Such a design does have certain disadvantages as
  65  * opposed to using SCST target API directly in the low level driver:
  66  * - we need to maintain duplicate data structures which are already maintained in the low
  67  *   level driver (commands queue, initiator data),
  68  * - processing takes additional cpu time for calling procedures and processing data.
  69  * However, the performance/memory cost is not so big, and such a design is flexible, as we
  70  * don't need to worry about low level details (e.g. if there is support for a new chipset
  71  * added to the low level ISP driver this code will not need to be changed).
  72  */
  73
  74 #ifndef  MODULE
  75 #error  "this can only be built as a module"
  76 #endif
  77
  78 #include <linux/version.h>
  79 #include <linux/module.h>
  80 #include <linux/kernel.h>
  81 #include <linux/ctype.h>
  82 #include <linux/proc_fs.h>
  83 #include <linux/seq_file.h>
  84 #include <linux/kthread.h>
  85
  86 #define LOG_PREFIX "qla_isp"
  87
  88 #include <scsi/scsi_host.h>
  89 #include <scsi/scsi.h>
  90 #include <scst.h>
  91 #include <scst_debug.h>
  92
  93 #include "isp_tpublic.h"
  94 #include "isp_linux.h"
  95 #include "linux/smp_lock.h"
  96
  97 #define MAX_BUS             8
  98 #define MAX_LUN             64
  99
 100 /* usefull pointers when data is processed */
 101 #define cd_scst_cmd      cd_hreserved[0].ptrs[0]
 102 #define cd_bus           cd_hreserved[1].ptrs[0]
 103 #define cd_hnext         cd_hreserved[2].ptrs[0]
 104 #define cd_ini           cd_hreserved[3].ptrs[0]
 105 #define nt_ini           nt_hreserved
 106
 107 /* command private flags */
 108 #define CDF_PRIVATE_ABORTED     0x1000
 109
 110 #ifndef SCSI_GOOD
 111 #define SCSI_GOOD   0x0
 112 #endif
 113 #ifndef SCSI_BUSY
 114 #define SCSI_BUSY   0x8
 115 #endif
 116 #ifndef SCSI_CHECK
 117 #define SCSI_CHECK  0x2
 118 #endif
 119 #ifndef SCSI_QFULL
 120 #define SCSI_QFULL  0x28
 121 #endif
 122
 123 typedef struct bus bus_t;
 124 typedef struct bus_chan bus_chan_t;
 125 typedef struct initiator ini_t;
 126
 127 struct initiator {
 128     ini_t *                 ini_next;
 129     uint64_t                ini_iid;        /* initiator identifier */
 130     struct scst_session *   ini_scst_sess;  /* sesson established by this remote initiator */
 131     int                     ini_refcnt;     /* reference counter, protected by bus_chan_t::tmds_lock */
 132 };
 133
 134 #define    HASH_WIDTH    16
 135 #define    INI_HASH_LISTP(bc, ini_id)    bc->list[ini_id & (HASH_WIDTH - 1)]
 136
 137 struct bus_chan {
 138     ini_t *                  list[HASH_WIDTH];   /* hash list of known initiators */
 139     spinlock_t               tmds_lock;
 140     tmd_cmd_t *              tmds_front;
 141     tmd_cmd_t *              tmds_tail;
 142     struct tasklet_struct    tasklet;
 143     struct scst_tgt *        scst_tgt;
 144     uint64_t                 enable;             /* is target mode enabled in low level driver, one bit per lun */
 145     struct rw_semaphore      disable_sem;        /* help to synchronize when disabling target mode */
 146     bus_t *                  bus;                /* back pointer */
 147     wait_queue_head_t        unreg_waitq;
 148     atomic_t                 sess_count;
 149 };
 150
 151 struct bus {
 152     hba_register_t           h;                  /* must be first */
 153     int                      need_reg;           /* helpers for registration / unregistration */
 154     hba_register_t *         unreg_hp;
 155     bus_chan_t *             bchan;              /* channels */
 156     struct scst_proc_data    proc_data;
 157 };
 158
 159 #define DEBUG 1
 160
 161 #ifdef DEBUG
 162 #define    BUS_DBG(bp, fmt, args...)    if (debug > 0) printk("%s%d: %s " fmt, bp->h.r_name, bp->h.r_inst, __func__, ##args)
 163 #define    BUS_DBG2(bp, fmt, args...)   if (debug > 1) printk("%s%d: %s " fmt, bp->h.r_name, bp->h.r_inst, __func__, ##args)
 164 static int debug = 0;
 165 module_param(debug, int, 0);
 166 #else
 167 #define    BUS_DBG(bp, fmt, args...)
 168 #define    BUS_DBG2(bp, fmt, args...)
 169 #endif
 170
 171 #define    Eprintk(fmt, args...) printk(KERN_ERR "isp_scst(%s): " fmt, __func__, ##args)
 172 #define    Iprintk(fmt, args...) printk(KERN_INFO "isp_scst(%s): " fmt, __func__, ##args)
 173
 174 static void scsi_target_handler(qact_e, void *);
 175
 176 static __inline bus_t *bus_from_tmd(tmd_cmd_t *);
 177 static __inline bus_t *bus_from_name(const char *);
 178
 179 static void scsi_target_start_cmd(tmd_cmd_t *);
 180 static void scsi_target_done_cmd(tmd_cmd_t *);
 181 static int scsi_target_enadis(bus_t *, uint64_t, int, int);
 182 static void bus_chan_unregister_sessions(bus_chan_t *bc, int wait);
 183
 184 static bus_t busses[MAX_BUS];
 185
 186 static DEFINE_SPINLOCK(scsi_target_lock);
 187
 188 DECLARE_WAIT_QUEUE_HEAD(qlaispd_waitq);
 189 struct task_struct *qlaispd_task;
 190
 191 static unsigned long qlaispd_flags = 0;
 192 #define SF_ADD_INITIATORS  0
 193 #define SF_REGISTER_SCST   1
 194 #define SF_UNREGISTER_SCST 2
 195
 196 static __inline void
 197 schedule_qlaispd(int flag)
 198 {
 199     set_bit(flag, &qlaispd_flags);
 200     wake_up_interruptible(&qlaispd_waitq);
 201 }
 202
 203 static __inline int
 204 validate_bus_pointer(bus_t *bp, void *identity)
 205 {
 206     if (bp >= busses && bp < &busses[MAX_BUS]) {
 207         if (bp->h.r_action) {
 208             if (bp->h.r_identity == identity) {
 209                 return (1);
 210             }
 211         }
 212     }
 213     return (0);
 214 }
 215
 216 static __inline bus_t *
 217 bus_from_tmd(tmd_cmd_t *tmd)
 218 {
 219     bus_t *bp;
 220     for (bp = busses; bp < &busses[MAX_BUS]; bp++) {
 221         if (validate_bus_pointer(bp, tmd->cd_hba)) {
 222             return (bp);
 223         }
 224     }
 225     return (NULL);
 226 }
 227
 228 static __inline bus_t *
 229 bus_from_name(const char *name)
 230 {
 231     bus_t *bp;
 232     for (bp = busses; bp < &busses[MAX_BUS]; bp++) {
 233         char localbuf[32];
 234         if (bp->h.r_action == NULL) {
 235             continue;
 236         }
 237         snprintf(localbuf, sizeof (localbuf), "%s%d", bp->h.r_name, bp->h.r_inst);
 238         if (strncmp(name, localbuf, sizeof (localbuf) - 1) == 0) {
 239             return (bp);
 240         }
 241     }
 242     return (NULL);
 243 }
 244
 245 static __inline bus_t *
 246 bus_from_notify(isp_notify_t *np)
 247 {
 248     bus_t *bp;
 249     for (bp = busses; bp < &busses[MAX_BUS]; bp++) {
 250         if (bp->h.r_action == NULL) {
 251             continue;
 252         }
 253         if (bp->h.r_identity == np->nt_hba) {
 254             return (bp);
 255         }
 256     }
 257     return (NULL);
 258 }
 259
 260 static __inline ini_t *
 261 ini_from_iid(bus_chan_t *bc, uint64_t iid)
 262 {
 263    ini_t *ptr = INI_HASH_LISTP(bc, iid);
 264    if (ptr) {
 265         do {
 266             if (ptr->ini_iid == iid) {
 267                 return (ptr);
 268             }
 269         } while ((ptr = ptr->ini_next) != NULL);
 270    }
 271    return (ptr);
 272 }
 273
 274 static ini_t *
 275 alloc_ini(bus_chan_t *bc, uint64_t iid)
 276 {
 277     ini_t *nptr;
 278     char ini_name[24];
 279
 280     nptr = kmalloc(sizeof(ini_t), GFP_KERNEL);
 281     if (!nptr) {
 282         Eprintk("cannot allocate initiator data\n");
 283         return (NULL);
 284     }
 285     memset(nptr, 0, sizeof(ini_t));
 286
 287     #define GET(byte) (uint8_t) ((iid >> 8*byte) & 0xff)
 288     snprintf(ini_name, sizeof(ini_name), "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
 289              GET(7), GET(6), GET(5) , GET(4), GET(3), GET(2), GET(1), GET(0));
 290     #undef GET
 291
 292     nptr->ini_scst_sess = scst_register_session(bc->scst_tgt, 0, ini_name, NULL, NULL);
 293     if (!nptr->ini_scst_sess) {
 294         Eprintk("cannot register SCST session\n");
 295         kfree(nptr);
 296         return (NULL);
 297     }
 298     atomic_inc(&bc->sess_count);
 299     BUS_DBG(bc->bus, "0x%016llx, ++sess_count %d\n", iid, atomic_read(&bc->sess_count));
 300     return (nptr);
 301 }
 302
 303 static void
 304 free_ini(bus_chan_t *bc, ini_t *ini, int wait)
 305 {
 306     BUS_DBG(bc->bus, "0x%016llx, sess_count-- %d, wait %d\n", ini->ini_iid, atomic_read(&bc->sess_count), wait);
 307     scst_unregister_session(ini->ini_scst_sess, wait, NULL);
 308     /* no wait call is only when there are no pending commands, so we can free stuff here */
 309     kfree(ini);
 310     atomic_dec(&bc->sess_count);
 311     wake_up(&bc->unreg_waitq);
 312 }
 313
 314 static void
 315 add_ini(bus_chan_t *bc, uint64_t iid, ini_t *nptr)
 316 {
 317     ini_t **ptrlptr = &INI_HASH_LISTP(bc, iid);
 318
 319     nptr->ini_iid = iid;
 320     nptr->ini_next = *ptrlptr;
 321     nptr->ini_refcnt = 0;
 322     *ptrlptr = nptr;
 323 }
 324
 325 static int
 326 del_ini(bus_chan_t *bc, uint64_t iid)
 327 {
 328     ini_t *ptr, *prev;
 329     ini_t **ptrlptr = &INI_HASH_LISTP(bc, iid);
 330
 331     ptr = *ptrlptr;
 332     if (ptr == NULL) {
 333         return (0);
 334     }
 335     if (ptr->ini_iid == iid) {
 336         *ptrlptr = ptr->ini_next;
 337         ptr->ini_next = NULL;
 338     } else {
 339         while (1) {
 340             prev = ptr;
 341             ptr = ptr->ini_next;
 342             if (ptr == NULL) {
 343                 return (0);
 344             }
 345             if (ptr->ini_iid == iid) {
 346                 prev->ini_next = ptr->ini_next;
 347                 ptr->ini_next = NULL;
 348                 break;
 349             }
 350         }
 351     }
 352     return (1);
 353 }
 354
 355 static __inline void
 356 __ini_get(bus_chan_t *bc, ini_t *ini)
 357 {
 358     if (ini != NULL) {
 359         ini->ini_refcnt++;
 360         BUS_DBG2(bc->bus, "0x%016llx ++refcnt (%d)\n", ini->ini_iid, ini->ini_refcnt);
 361     }
 362 }
 363
 364 static __inline void
 365 ini_get(bus_chan_t *bc, ini_t *ini)
 366 {
 367     unsigned long flags;
 368     spin_lock_irqsave(&bc->tmds_lock, flags);
 369     __ini_get(bc, ini);
 370     spin_unlock_irqrestore(&bc->tmds_lock, flags);
 371 }
 372
 373 static __inline void
 374 __ini_put(bus_chan_t *bc, ini_t *ini)
 375 {
 376     if (ini != NULL) {
 377         ini->ini_refcnt--;
 378         BUS_DBG2(bc->bus, "0x%016llx --refcnt (%d)\n", ini->ini_iid, ini->ini_refcnt);
 379         if (ini->ini_refcnt < 0) {
 380             free_ini(bc, ini, 0);
 381         }
 382     }
 383 }
 384
 385 static __inline void
 386 ini_put(bus_chan_t *bc, ini_t *ini)
 387 {
 388     unsigned long flags;
 389     spin_lock_irqsave(&bc->tmds_lock, flags);
 390     __ini_put(bc, ini);
 391     spin_unlock_irqrestore(&bc->tmds_lock, flags);
 392 }
 393
 394 static void
 395 tasklet_rx_cmds(unsigned long data)
 396 {
 397     bus_chan_t *bc = (bus_chan_t *) data;
 398     bus_t *bp = bc->bus;
 399     ini_t *ini;
 400     tmd_cmd_t *tmd;
 401     tmd_xact_t *xact;
 402     struct scst_cmd *scst_cmd;
 403
 404 rx_loop:
 405     spin_lock_irq(&bc->tmds_lock);
 406     tmd = bc->tmds_front;
 407     if (tmd == NULL || tmd->cd_ini == NULL) {
 408         spin_unlock_irq(&bc->tmds_lock);
 409         return;
 410     }
 411
 412     /* remove from queue */
 413     bc->tmds_front = tmd->cd_hnext;
 414     if (bc->tmds_front == NULL) {
 415         bc->tmds_tail = NULL;
 416     }
 417
 418     /* free command if aborted */
 419     if (tmd->cd_flags & CDF_PRIVATE_ABORTED) {
 420         __ini_put(bc, tmd->cd_ini);
 421         spin_unlock_irq(&bc->tmds_lock);
 422         BUS_DBG(bp, "ABORTED TMD_FIN[%llx]\n", tmd->cd_tagval);
 423         (*bp->h.r_action)(QIN_TMD_FIN, tmd);
 424         goto rx_loop;
 425     }
 426
 427     ini = tmd->cd_ini;
 428     scst_cmd = scst_rx_cmd(ini->ini_scst_sess, tmd->cd_lun, sizeof(tmd->cd_lun), tmd->cd_cdb, sizeof(tmd->cd_cdb), 1);
 429     if (scst_cmd == NULL) {
 430         spin_unlock_irq(&bc->tmds_lock);
 431         tmd->cd_scsi_status = SCSI_BUSY;
 432         xact = &tmd->cd_xact;
 433         xact->td_hflags = TDFH_STSVALID;
 434         xact->td_lflags = 0;
 435         xact->td_xfrlen = 0;
 436         (*bp->h.r_action)(QIN_TMD_CONT, xact);
 437         goto rx_loop;
 438     }
 439
 440     scst_cmd_set_tgt_priv(scst_cmd, tmd);
 441     scst_cmd_set_tag(scst_cmd, tmd->cd_tagval);
 442     tmd->cd_scst_cmd = scst_cmd;
 443
 444     switch (tmd->cd_tagtype) {
 445         case CD_UNTAGGED:
 446             scst_cmd->queue_type = SCST_CMD_QUEUE_UNTAGGED;
 447             break;
 448         case CD_SIMPLE_TAG:
 449             scst_cmd->queue_type = SCST_CMD_QUEUE_SIMPLE;
 450             break;
 451         case CD_ORDERED_TAG:
 452             scst_cmd->queue_type = SCST_CMD_QUEUE_ORDERED;
 453             break;
 454         case CD_HEAD_TAG:
 455             scst_cmd->queue_type = SCST_CMD_QUEUE_HEAD_OF_QUEUE;
 456             break;
 457         case CD_ACA_TAG:
 458             scst_cmd->queue_type = SCST_CMD_QUEUE_ACA;
 459             break;
 460         default:
 461             scst_cmd->queue_type = SCST_CMD_QUEUE_ORDERED;
 462             break;
 463     }
 464
 465     if (bp->h.r_type == R_FC) {
 466         scst_data_direction dir;
 467         int len;
 468
 469         dir = SCST_DATA_NONE;
 470         if ((tmd->cd_flags & CDF_BIDIR) == CDF_BIDIR) {
 471             dir = SCST_DATA_UNKNOWN;
 472         } else if (tmd->cd_flags & CDF_DATA_OUT) {
 473             dir = SCST_DATA_WRITE;
 474         } else if (tmd->cd_flags & CDF_DATA_IN) {
 475             dir = SCST_DATA_READ;
 476         }
 477         len = tmd->cd_totlen;
 478         if (tmd->cd_cdb[0] == INQUIRY) {
 479             len = min(len, tmd->cd_cdb[4]);
 480         }
 481         scst_cmd_set_expected(scst_cmd, dir, len);
 482     }
 483     spin_unlock_irq(&bc->tmds_lock);
 484
 485     scst_cmd_init_done(scst_cmd, SCST_CONTEXT_DIRECT_ATOMIC);
 486
 487     goto rx_loop;
 488 }
 489
 490 static void
 491 scsi_target_start_cmd(tmd_cmd_t *tmd)
 492 {
 493     unsigned long flags;
 494     bus_t *bp;
 495     bus_chan_t *bc;
 496
 497     /* first, find the bus */
 498     spin_lock_irqsave(&scsi_target_lock, flags);
 499     bp = bus_from_tmd(tmd);
 500     if (unlikely(bp == NULL || bp->bchan == NULL)) {
 501         spin_unlock_irqrestore(&scsi_target_lock, flags);
 502         Eprintk("cannot find %s for incoming command\n", (bp == NULL) ? "bus" : "channel");
 503         return;
 504     }
 505     spin_unlock_irqrestore(&scsi_target_lock, flags);
 506
 507     BUS_DBG2(bp, "TMD_START[%llx] %p cdb0=%x\n", tmd->cd_tagval, tmd, tmd->cd_cdb[0] & 0xff);
 508
 509     tmd->cd_bus = bp;
 510     tmd->cd_hnext = NULL;
 511     bc = &bp->bchan[tmd->cd_channel];
 512
 513     /* then, add commands to queue */
 514     spin_lock_irqsave(&bc->tmds_lock, flags);
 515     tmd->cd_ini = ini_from_iid(bc, tmd->cd_iid);
 516     __ini_get(bc, tmd->cd_ini);
 517     if (bc->tmds_front == NULL) {
 518         bc->tmds_front = tmd;
 519     } else {
 520         bc->tmds_tail->cd_hnext = tmd;
 521     }
 522     bc->tmds_tail = tmd;
 523     spin_unlock_irqrestore(&bc->tmds_lock, flags);
 524
 525     /* finally, schedule proper action */
 526     if (unlikely(tmd->cd_ini == NULL)) {
 527         schedule_qlaispd(SF_ADD_INITIATORS);
 528     } else {
 529         tasklet_schedule(&bc->tasklet);
 530     }
 531 }
 532
 533 static void
 534 bus_chan_add_initiators(bus_t *bp, int chan)
 535 {
 536     bus_chan_t *bc = &bp->bchan[chan];
 537     ini_t *ini;
 538     tmd_cmd_t *tmd;
 539     tmd_cmd_t *prev_tmd = NULL;
 540     tmd_xact_t *xact;
 541
 542     BUS_DBG(bp, "Chan %d searching new initiators\n", chan);
 543
 544     /* iterate over queue and find any commands not assigned to initiator */
 545     spin_lock_irq(&bc->tmds_lock);
 546     tmd = bc->tmds_front;
 547     while (tmd) {
 548         BUG_ON(tmd->cd_channel != chan);
 549         if (tmd->cd_ini != NULL) {
 550             /* ini assigned, go to the next command */
 551             prev_tmd = tmd;
 552             tmd = tmd->cd_hnext;
 553         } else {
 554             /* check if proper initiator exist already */
 555             ini = ini_from_iid(bc, tmd->cd_iid);
 556             if (ini != NULL) {
 557                 tmd->cd_ini = ini;
 558                 __ini_get(bc, ini);
 559             } else {
 560                 spin_unlock_irq(&bc->tmds_lock);
 561
 562                 ini = alloc_ini(bc, tmd->cd_iid);
 563
 564                 spin_lock_irq(&bc->tmds_lock);
 565                 if (ini != NULL) {
 566                     tmd->cd_ini = ini;
 567                     add_ini(bc, tmd->cd_iid, ini);
 568                     __ini_get(bc, ini);
 569                 } else {
 570                     /* fail to alloc initiator, remove from queue and send busy */
 571                     if (prev_tmd == NULL) {
 572                         bc->tmds_front = tmd->cd_hnext;
 573                     } else {
 574                         prev_tmd->cd_hnext = tmd->cd_hnext;
 575                     }
 576                     if (bc->tmds_tail == tmd) {
 577                         bc->tmds_tail = prev_tmd;
 578                     }
 579                     spin_unlock_irq(&bc->tmds_lock);
 580
 581                     tmd->cd_scsi_status = SCSI_BUSY;
 582                     xact = &tmd->cd_xact;
 583                     xact->td_hflags = TDFH_STSVALID;
 584                     xact->td_lflags = 0;
 585                     xact->td_xfrlen = 0;
 586                     (*bp->h.r_action)(QIN_TMD_CONT, xact);
 587
 588                     spin_lock_irq(&bc->tmds_lock);
 589                     /* iterate to the next command, previous is not changed */
 590                     tmd = tmd->cd_hnext;
 591                 }
 592             }
 593         }
 594     }
 595     spin_unlock_irq(&bc->tmds_lock);
 596     /* now we can run queue and pass commands to scst */
 597     tasklet_schedule(&bc->tasklet);
 598 }
 599
 600 static void
 601 bus_add_initiators(void)
 602 {
 603     bus_t *bp;
 604     int chan;
 605
 606     for (bp = busses; bp < &busses[MAX_BUS]; bp++) {
 607         spin_lock_irq(&scsi_target_lock);
 608         if (bp->h.r_action == NULL) {
 609             spin_unlock_irq(&scsi_target_lock);
 610             continue;
 611         }
 612         spin_unlock_irq(&scsi_target_lock);
 613
 614         for (chan = 0; chan < bp->h.r_nchannels; chan++) {
 615             bus_chan_add_initiators(bp, chan);
 616         }
 617     }
 618 }
 619
 620 static void
 621 scsi_target_done_cmd(tmd_cmd_t *tmd)
 622 {
 623     bus_t *bp;
 624     struct scst_cmd *scst_cmd;
 625     tmd_xact_t *xact = &tmd->cd_xact;
 626     enum scst_exec_context context = scst_estimate_context();
 627
 628     bp = tmd->cd_bus;
 629
 630     BUS_DBG2(bp,"TMD_DONE[%llx] %p hf %x lf %x xfrlen %d totlen %d moved %d\n",
 631              tmd->cd_tagval, tmd, xact->td_hflags, xact->td_lflags, xact->td_xfrlen, tmd->cd_totlen, tmd->cd_moved);
 632
 633     scst_cmd = tmd->cd_scst_cmd;
 634     if (!scst_cmd) {
 635         /* command returned by us with status BUSY */
 636         BUS_DBG(bp, "BUSY TMD_FIN[%llx]\n", tmd->cd_tagval);
 637         ini_put(&bp->bchan[tmd->cd_channel], tmd->cd_ini);
 638         (*bp->h.r_action)(QIN_TMD_FIN, tmd);
 639         return;
 640     }
 641
 642     if (xact->td_hflags & TDFH_STSVALID) {
 643         if (xact->td_hflags & TDFH_DATA_IN) {
 644             xact->td_hflags &= ~TDFH_DATA_MASK;
 645             xact->td_xfrlen = 0;
 646         }
 647         if (unlikely(xact->td_error)) {
 648             scst_set_delivery_status(scst_cmd, SCST_CMD_DELIVERY_FAILED);
 649         }
 650         scst_tgt_cmd_done(scst_cmd, context);
 651         return;
 652     }
 653
 654     if (xact->td_hflags & TDFH_DATA_OUT) {
 655         if (likely(tmd->cd_totlen == tmd->cd_moved) || unlikely(xact->td_error)) {
 656             if (xact->td_xfrlen) {
 657                 int rx_status = SCST_RX_STATUS_SUCCESS;
 658                 if (unlikely(xact->td_error)) {
 659                     rx_status = SCST_RX_STATUS_ERROR;
 660                 }
 661                 scst_rx_data(scst_cmd, rx_status, context);
 662             } else {
 663                 if (unlikely(xact->td_error)) {
 664                     scst_set_delivery_status(scst_cmd, SCST_CMD_DELIVERY_FAILED);
 665                 }
 666                 scst_tgt_cmd_done(scst_cmd, context);
 667             }
 668         } else {
 669             ; /* we don't have all data, do nothing */
 670         }
 671     } else if (xact->td_hflags & TDFH_DATA_IN) {
 672         xact->td_hflags &= ~TDFH_DATA_MASK;
 673         xact->td_xfrlen = 0;
 674         if (unlikely(xact->td_error)) {
 675             scst_set_delivery_status(scst_cmd, SCST_CMD_DELIVERY_FAILED);
 676         }
 677         scst_tgt_cmd_done(scst_cmd, context);
 678     } else {
 679         Eprintk("don't know what to do with TMD_DONE[%llx] cdb0 %x hf %x lf %x xfrlen %d totlen %d moved %d\n",
 680                 tmd->cd_tagval, tmd->cd_cdb[0], xact->td_hflags, xact->td_lflags, xact->td_xfrlen, tmd->cd_totlen, tmd->cd_moved);
 681     }
 682 }
 683
 684 static int
 685 abort_task(bus_chan_t *bc, uint64_t iid, uint64_t tagval)
 686 {
 687     unsigned long flags;
 688     tmd_cmd_t *tmd;
 689
 690     spin_lock_irqsave(&bc->tmds_lock, flags);
 691     for (tmd = bc->tmds_front; tmd; tmd = tmd->cd_hnext) {
 692         if (tmd->cd_tagval == tagval && tmd->cd_iid == iid) {
 693             tmd->cd_flags |= CDF_PRIVATE_ABORTED;
 694             spin_unlock_irqrestore(&bc->tmds_lock, flags);
 695             tasklet_schedule(&bc->tasklet);
 696             return (1);
 697         }
 698     }
 699     spin_unlock_irqrestore(&bc->tmds_lock, flags);
 700     return (0);
 701 }
 702
 703 static void
 704 abort_all_tasks(bus_chan_t *bc, uint64_t iid)
 705 {
 706     unsigned long flags;
 707     tmd_cmd_t *tmd;
 708
 709     spin_lock_irqsave(&bc->tmds_lock, flags);
 710     for (tmd = bc->tmds_front; tmd; tmd = tmd->cd_hnext) {
 711         if (tmd->cd_iid == iid) {
 712             tmd->cd_flags |= CDF_PRIVATE_ABORTED;
 713         }
 714     }
 715     spin_unlock_irqrestore(&bc->tmds_lock, flags);
 716     tasklet_schedule(&bc->tasklet);
 717 }
 718
 719 static void
 720 scsi_target_notify(isp_notify_t *np)
 721 {
 722     bus_t *bp;
 723     bus_chan_t *bc;
 724     ini_t *ini;
 725     int fn;
 726     char *tmf = NULL;
 727     uint16_t lun;
 728     uint8_t lunbuf[8];
 729     unsigned long flags;
 730
 731     spin_lock_irqsave(&scsi_target_lock, flags);
 732     bp = bus_from_notify(np);
 733     if (unlikely(bp == NULL || bp->bchan == NULL)) {
 734         spin_unlock_irqrestore(&scsi_target_lock, flags);
 735         Eprintk("cannot find %s for incoming notify\n", bp == NULL ? "bus" : "channel");
 736         return;
 737     }
 738     spin_unlock_irqrestore(&scsi_target_lock, flags);
 739
 740     BUS_DBG(bp, "TMD_NOTIFY %p code %x iid 0x%016llx tag %llx\n", np, np->nt_ncode, np->nt_wwn, np->nt_tagval);
 741
 742     bc = &bp->bchan[np->nt_channel];
 743
 744     spin_lock_irqsave(&bc->tmds_lock, flags);
 745     ini = ini_from_iid(bc, np->nt_wwn);
 746     np->nt_ini = ini;
 747     __ini_get(bc, np->nt_ini);
 748     spin_unlock_irqrestore(&bc->tmds_lock, flags);
 749
 750     switch (np->nt_ncode) {
 751         case NT_ABORT_TASK:
 752             tmf = "ABORT TASK";
 753             if (ini == NULL) {
 754                goto err_no_ini;
 755             }
 756             if (abort_task(bc, np->nt_wwn, np->nt_tagval)) {
 757                 BUS_DBG(bp, "TMD_NOTIFY abort task [%llx]\n", np->nt_tagval);
 758                 goto notify_ack;
 759             }
 760             if (scst_rx_mgmt_fn_tag(ini->ini_scst_sess, SCST_ABORT_TASK, np->nt_tagval, 1, np) < 0) {
 761                 np->nt_failed = 1;
 762                 goto notify_ack;
 763             }
 764             /* wait for SCST now */
 765             return;
 766         case NT_ABORT_TASK_SET:
 767             tmf = "ABORT TASK SET";
 768             if (ini == NULL) {
 769                 goto err_no_ini;
 770             }
 771             abort_all_tasks(bc, np->nt_wwn);
 772             fn = SCST_ABORT_TASK_SET;
 773             break;
 774         case NT_CLEAR_TASK_SET:
 775             tmf = "CLEAR TASK SET";
 776             if (ini == NULL) {
 777                 goto err_no_ini;
 778             }
 779             abort_all_tasks(bc, np->nt_wwn);
 780             fn = SCST_CLEAR_TASK_SET;
 781             break;
 782         case NT_CLEAR_ACA:
 783             tmf = "CLEAR ACA";
 784             fn = SCST_CLEAR_ACA;
 785             break;
 786         case NT_LUN_RESET:
 787             tmf = "LUN RESET";
 788             if (np->nt_lun == LUN_ANY) {
 789                 np->nt_failed = 1;
 790                 goto notify_ack;
 791             }
 792             fn = SCST_LUN_RESET;
 793             break;
 794         case NT_TARGET_RESET:
 795             tmf = "TARGET RESET";
 796             fn = SCST_TARGET_RESET;
 797             break;
 798         case NT_BUS_RESET:
 799         case NT_HBA_RESET:
 800             ini_put(bc, ini);
 801             //schedule_reset();
 802             return;
 803         case NT_LIP_RESET:
 804         case NT_LINK_UP:
 805         case NT_LINK_DOWN:
 806             /* we don't care about lip resets and link up/down */
 807             goto notify_ack;
 808         case NT_LOGOUT:
 809             spin_lock_irqsave(&bc->tmds_lock, flags);
 810             /*
 811              * If someone disables the target during this notify, reference to initiator
 812              * is currently dropped, so we need to check if IID is still in initiators
 813              * table to avoid double free
 814              */
 815             if (del_ini(bc, np->nt_wwn)) {
 816                 BUS_DBG(bp, "droping reference to initiator 0x%016llx\n", np->nt_wwn);
 817                 __ini_put(bc, ini);
 818             } else {
 819                 Eprintk("cannot logout initiator 0x%016llx\n", np->nt_wwn);
 820             }
 821             spin_unlock_irqrestore(&bc->tmds_lock, flags);
 822             goto notify_ack;
 823         default:
 824             Eprintk("unknown notify 0x%x\n", np->nt_ncode);
 825             ini_put(bc, ini);
 826             return;
 827     }
 828
 829     if (tmf) {
 830         if (ini == NULL) {
 831             goto err_no_ini;
 832         }
 833         if (np->nt_lun == LUN_ANY) {
 834             lun = 0;
 835         } else {
 836             lun = np->nt_lun;
 837         }
 838         FLATLUN_TO_L0LUN(lunbuf, lun);
 839         if (scst_rx_mgmt_fn_lun(ini->ini_scst_sess, fn, lunbuf, sizeof(lunbuf), 1, np) < 0) {
 840             np->nt_failed = 1;
 841             goto notify_ack;
 842         }
 843     }
 844     return;
 845
 846 err_no_ini:
 847     Eprintk("cannot find initiator 0x%016llx for %s\n", np->nt_wwn, tmf);
 848     np->nt_failed = 1;
 849 notify_ack:
 850     ini_put(bc, ini);
 851     (*bp->h.r_action) (QIN_NOTIFY_ACK, np);
 852 }
 853
 854 static void
 855 scsi_target_handler(qact_e action, void *arg)
 856 {
 857     unsigned long flags;
 858     bus_t *bp;
 859
 860     switch (action) {
 861     case QOUT_HBA_REG:
 862     {
 863         hba_register_t *hp;
 864
 865         spin_lock_irqsave(&scsi_target_lock, flags);
 866         for (bp = busses; bp < &busses[MAX_BUS]; bp++) {
 867             if (bp->h.r_action == NULL) {
 868                 break;
 869            }
 870         }
 871         if (bp == &busses[MAX_BUS]) {
 872             spin_unlock_irqrestore(&scsi_target_lock, flags);
 873             Eprintk("cannot register any more SCSI busses\n");
 874             break;
 875         }
 876         hp = arg;
 877         if (hp->r_version != QR_VERSION) {
 878             spin_unlock_irqrestore(&scsi_target_lock, flags);
 879             Eprintk("version mismatch - compiled with %d, got %d\n", QR_VERSION, hp->r_version);
 880             break;
 881         }
 882         bp->h = *hp;
 883         bp->need_reg = 1;
 884         spin_unlock_irqrestore(&scsi_target_lock, flags);
 885         schedule_qlaispd(SF_REGISTER_SCST);
 886         break;
 887     }
 888     case QOUT_ENABLE:
 889     {
 890         enadis_t *ep = arg;
 891         if (ep->en_private) {
 892             up(ep->en_private);
 893         }
 894         break;
 895     }
 896     case QOUT_DISABLE:
 897     {
 898         enadis_t *ep = arg;
 899         if (ep->en_private) {
 900             up(ep->en_private);
 901         }
 902         break;
 903     }
 904     case QOUT_TMD_START:
 905     {
 906         tmd_cmd_t *tmd = arg;
 907         tmd->cd_xact.td_cmd = tmd;
 908         scsi_target_start_cmd(arg);
 909         break;
 910     }
 911     case QOUT_TMD_DONE:
 912     {
 913         tmd_xact_t *xact = arg;
 914         tmd_cmd_t *tmd = xact->td_cmd;
 915         scsi_target_done_cmd(tmd);
 916         break;
 917     }
 918     case QOUT_NOTIFY:
 919     {
 920         isp_notify_t *np = arg;
 921         scsi_target_notify(np);
 922         break;
 923     }
 924     case QOUT_HBA_UNREG:
 925     {
 926         hba_register_t *hp = arg;
 927
 928         spin_lock_irqsave(&scsi_target_lock, flags);
 929         for (bp = busses; bp < &busses[MAX_BUS]; bp++) {
 930             if (bp->h.r_action == NULL) {
 931                continue;
 932             }
 933             if (bp->h.r_identity == hp->r_identity) {
 934                 break;
 935            }
 936         }
 937         if (bp == &busses[MAX_BUS]) {
 938             spin_unlock_irqrestore(&scsi_target_lock, flags);
 939             Eprintk("HBA_UNREG cannot find bus\n");
 940             break;
 941         }
 942         bp->unreg_hp = hp;
 943         spin_unlock_irqrestore(&scsi_target_lock, flags);
 944         schedule_qlaispd(SF_UNREGISTER_SCST);
 945         break;
 946     }
 947     default:
 948         Eprintk("action code %d (0x%x)?\n", action, action);
 949         break;
 950     }
 951 }
 952
 953 static void register_scst(void);
 954 static void unregister_scst(void);
 955
 956 static int
 957 qlaispd_function(void *arg)
 958 {
 959     printk(KERN_DEBUG "qlaispd starting\n");
 960     while (!kthread_should_stop()) {
 961         printk(KERN_DEBUG "qlaispd sleeping\n");
 962         wait_event_interruptible(qlaispd_waitq, qlaispd_flags || kthread_should_stop());
 963         printk(KERN_DEBUG "qlaispd running\n");
 964
 965         if (test_and_clear_bit(SF_REGISTER_SCST, &qlaispd_flags)) {
 966             register_scst();
 967         }
 968         if (test_and_clear_bit(SF_ADD_INITIATORS, &qlaispd_flags)) {
 969             bus_add_initiators();
 970         }
 971         if (test_and_clear_bit(SF_UNREGISTER_SCST, &qlaispd_flags)) {
 972             unregister_scst();
 973         }
 974     }
 975     printk(KERN_DEBUG "qlaispd exiting\n");
 976     return (0);
 977 }
 978
 979 static int
 980 scsi_target_enadis(bus_t *bp, uint64_t en, int chan, int lun)
 981 {
 982     struct semaphore rsem;
 983     enadis_t ec;
 984     info_t info;
 985     bus_chan_t *bc;
 986     uint64_t mask;
 987
 988     BUG_ON(chan < 0 || chan >= bp->h.r_nchannels);
 989     BUG_ON(lun != LUN_ANY && (lun < 0 || lun >= MAX_LUN));
 990     bc = &bp->bchan[chan];
 991     sema_init(&rsem, 0);
 992
 993     if (bp->h.r_type == R_FC) {
 994         if (en == bc->enable) {
 995             return (0);
 996         }
 997     } else {
 998         if (lun == LUN_ANY) {
 999             return (-EINVAL);
1000         } else {
1001             mask = ~(1 << lun);
1002             if ((en << lun) == (bc->enable & mask)) {
1003                 return (0);
1004             }
1005         }
1006     }
1007
1008     memset(&info, 0, sizeof (info));
1009     info.i_identity = bp->h.r_identity;
1010     info.i_channel = chan;
1011     (*bp->h.r_action)(QIN_GETINFO, &info);
1012     if (info.i_error) {
1013         return (info.i_error);
1014     }
1015
1016     memset(&ec, 0, sizeof (ec));
1017     ec.en_hba = bp->h.r_identity;
1018     ec.en_chan = chan;
1019     if (bp->h.r_type == R_FC) {
1020         ec.en_lun = LUN_ANY;
1021     } else {
1022         ec.en_lun = lun;
1023     }
1024
1025     /* Locking disable_sem prevent moving pending commands to low level driver
1026      * during disabling luns, as we can't get them back, what leads to SCST
1027      * commands leakage */
1028     BUS_DBG(bp, "Chan %d before down_write disable_sem\n", chan);
1029     down_write(&bc->disable_sem);
1030     BUS_DBG(bp, "Chan %d after down_write disable_sem\n", chan);
1031
1032     ec.en_private = &rsem;
1033     (*bp->h.r_action)(en ? QIN_ENABLE : QIN_DISABLE, &ec);
1034     down(&rsem);
1035     if (ec.en_error) {
1036         up_write(&bc->disable_sem);
1037         return (ec.en_error);
1038     }
1039
1040     if (bp->h.r_type == R_FC) {
1041         bc->enable = en;
1042     } else {
1043         mask = ~(1 << lun);
1044         bc->enable &= mask;
1045         bc->enable |= (en << lun);
1046     }
1047
1048     if (bc->enable == 0) {
1049         BUS_DBG(bp, "Chan %d drop all initiators references\n", chan);
1050         /* If no lun is active on channel we want to logoff from SCST. At this point no new
1051          * commands and notifies come from low level driver, but we need to care on pendgin
1052          * ones. We just drop reference to initiators. When last command/notify finish
1053          * for initiator, we will unregister session from SCST */
1054         bus_chan_unregister_sessions(bc, 0);
1055     }
1056     up_write(&bc->disable_sem);
1057     return (0);
1058 }
1059
1060 static int
1061 isp_detect(struct scst_tgt_template *tgt_template)
1062 {
1063     schedule_qlaispd(SF_REGISTER_SCST);
1064     return (0);
1065 }
1066
1067 static int
1068 isp_release(struct scst_tgt *tgt)
1069 {
1070     return (0);
1071 }
1072
1073 static int
1074 isp_rdy_to_xfer(struct scst_cmd *scst_cmd)
1075 {
1076     /* don't need to check against aborted, low level driver handle
1077      * this and call us back with error */
1078
1079     if (scst_cmd_get_data_direction(scst_cmd) == SCST_DATA_WRITE) {
1080         tmd_cmd_t *tmd = (tmd_cmd_t *) scst_cmd_get_tgt_priv(scst_cmd);
1081         tmd_xact_t *xact = &tmd->cd_xact;
1082         bus_t *bp = tmd->cd_bus;
1083         bus_chan_t *bc = &bp->bchan[tmd->cd_channel];
1084         int len = scst_cmd_get_bufflen(scst_cmd);
1085
1086         xact->td_hflags = TDFH_DATA_OUT;
1087         xact->td_lflags = 0;
1088         xact->td_data = scst_cmd_get_sg(scst_cmd);
1089         xact->td_xfrlen = len;
1090         if (bp->h.r_type == R_SPI) {
1091             tmd->cd_totlen = len;
1092         }
1093
1094         if (unlikely(down_read_trylock(&bc->disable_sem) != 1)) {
1095             BUS_DBG(bp, "TMD[%llx] Chan %d disable_sem trylock failed, atomic %d\n",
1096                     tmd->cd_tagval, tmd->cd_channel, scst_cmd_atomic(scst_cmd));
1097             if (scst_cmd_atomic(scst_cmd)) {
1098                 return (SCST_TGT_RES_NEED_THREAD_CTX);
1099             }
1100             down_read(&bc->disable_sem);
1101         }
1102
1103         if (unlikely(bc->enable == 0)) {
1104             BUS_DBG(bp, "TMD[%llx] Chan %d not enabled\n", tmd->cd_tagval, tmd->cd_channel);
1105             up_read(&bc->disable_sem);
1106             scst_rx_data(scst_cmd, SCST_RX_STATUS_ERROR, SCST_CONTEXT_SAME);
1107             return (SCST_TGT_RES_SUCCESS);
1108         }
1109
1110         BUS_DBG2(bp, "TMD[%llx] write nbytes %u\n", tmd->cd_tagval, scst_cmd_get_bufflen(scst_cmd));
1111         (*bp->h.r_action)(QIN_TMD_CONT, xact);
1112         up_read(&bc->disable_sem);
1113         /*
1114          * Did we have an error starting this particular transaction?
1115          */
1116         if (unlikely((xact->td_lflags & (TDFL_ERROR|TDFL_SYNCERROR)) == (TDFL_ERROR|TDFL_SYNCERROR))) {
1117             if (xact->td_error == -ENOMEM) {
1118                 return (SCST_TGT_RES_QUEUE_FULL);
1119             } else {
1120                 return (SCST_TGT_RES_FATAL_ERROR);
1121             }
1122         }
1123     }
1124     return (SCST_TGT_RES_SUCCESS);
1125 }
1126
1127 static int
1128 isp_xmit_response(struct scst_cmd *scst_cmd)
1129 {
1130     tmd_cmd_t *tmd = (tmd_cmd_t *) scst_cmd_get_tgt_priv(scst_cmd);
1131     bus_t *bp = tmd->cd_bus;
1132     bus_chan_t *bc = &bp->bchan[tmd->cd_channel];
1133     tmd_xact_t *xact = &tmd->cd_xact;
1134
1135     if (unlikely(scst_cmd_aborted(scst_cmd))) {
1136         scst_set_delivery_status(scst_cmd, SCST_CMD_DELIVERY_ABORTED);
1137         scst_tgt_cmd_done(scst_cmd, SCST_CONTEXT_SAME);
1138         return (SCST_TGT_RES_SUCCESS);
1139     }
1140
1141     if (scst_cmd_get_data_direction(scst_cmd) == SCST_DATA_READ) {
1142         unsigned int len = scst_cmd_get_resp_data_len(scst_cmd);
1143         if (bp->h.r_type == R_SPI) {
1144             tmd->cd_totlen = len;
1145         }
1146         if (unlikely(len > tmd->cd_totlen)) {
1147             /* some broken FC initiators may send SCSI commands with data load
1148              * larger than underlaying transport specified */
1149             const uint8_t ifailure[TMD_SENSELEN] = { 0xf0, 0, 0x4, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0x44 };
1150
1151             Eprintk("data size too big (totlen %u len %u)\n", tmd->cd_totlen, len);
1152
1153             memcpy(tmd->cd_sense, ifailure, TMD_SENSELEN);
1154             xact->td_hflags = TDFH_STSVALID;
1155             tmd->cd_scsi_status = SCSI_CHECK;
1156             goto out;
1157         } else {
1158             xact->td_hflags = TDFH_DATA_IN;
1159             xact->td_xfrlen = len;
1160             xact->td_data = scst_cmd_get_sg(scst_cmd);
1161         }
1162     } else {
1163         /* finished write to target or command with no data */
1164         xact->td_xfrlen = 0;
1165         xact->td_hflags &= ~TDFH_DATA_MASK;
1166     }
1167
1168     xact->td_lflags = 0;
1169
1170     if (scst_cmd_get_is_send_status(scst_cmd)) {
1171         xact->td_hflags |= TDFH_STSVALID;
1172         tmd->cd_scsi_status = scst_cmd_get_status(scst_cmd);
1173
1174         if (tmd->cd_scsi_status == SCSI_CHECK) {
1175             uint8_t *sbuf = scst_cmd_get_sense_buffer(scst_cmd);
1176             unsigned int slen = scst_cmd_get_sense_buffer_len(scst_cmd);
1177             if (likely(slen > TMD_SENSELEN)) {
1178                 /* 18 bytes sense code not cover vendor specific sense data,
1179                  * we can't send more than 18 bytes through low level driver,
1180                  * however SCST give us 96 bytes, so truncate */
1181                 slen = TMD_SENSELEN;
1182             }
1183             memcpy(tmd->cd_sense, sbuf, slen);
1184 #ifdef DEBUG
1185             if (unlikely(debug > 0)) {
1186                 uint8_t key, asc, ascq;
1187                 key = (slen >= 2) ? sbuf[2] : 0;
1188                 asc = (slen >= 12) ? sbuf[12] : 0;
1189                 ascq = (slen >= 13) ? sbuf[13] : 0;
1190                 BUS_DBG(bp, "sense code: key 0x%02x asc 0x%02x ascq 0x%02x\n", key, asc, ascq);
1191             }
1192 #endif
1193         }
1194         BUS_DBG2(bp, "TMD[%llx] status %d\n", tmd->cd_tagval, scst_cmd_get_status(scst_cmd));
1195     }
1196
1197 out:
1198     if ((xact->td_hflags & TDFH_STSVALID) && (tmd->cd_scsi_status == SCSI_CHECK)) {
1199         xact->td_xfrlen = 0;
1200         xact->td_hflags &= ~TDFH_DATA_MASK;
1201         xact->td_hflags |= TDFH_SNSVALID;
1202     }
1203
1204     if (unlikely(down_read_trylock(&bc->disable_sem) != 1)) {
1205         BUS_DBG(bp, "TMD[%llx] Chan %d disable_sem trylock failed, atomic %d\n",
1206                 tmd->cd_tagval, tmd->cd_channel, scst_cmd_atomic(scst_cmd));
1207         if (scst_cmd_atomic(scst_cmd)) {
1208             return (SCST_TGT_RES_NEED_THREAD_CTX);
1209         }
1210         down_read(&bc->disable_sem);
1211     }
1212
1213     if (unlikely(bc->enable == 0)) {
1214         BUS_DBG(bp, "TMD[%llx] Chan %d not enabled\n", tmd->cd_tagval, tmd->cd_channel);
1215         up_read(&bc->disable_sem);
1216         scst_tgt_cmd_done(scst_cmd, SCST_CONTEXT_SAME);
1217         return (SCST_TGT_RES_SUCCESS);
1218     }
1219
1220     BUS_DBG2(bp, "TMD[%llx] %p hf %x lf %x xfrlen %d totlen %d moved %d\n",
1221              tmd->cd_tagval, tmd, xact->td_hflags, xact->td_lflags, xact->td_xfrlen, tmd->cd_totlen, tmd->cd_moved);
1222     up_read(&bc->disable_sem);
1223     (*bp->h.r_action)(QIN_TMD_CONT, xact);
1224     /*
1225      * Did we have an error starting this particular transaction?
1226      */
1227     if (unlikely((xact->td_lflags & (TDFL_ERROR|TDFL_SYNCERROR)) == (TDFL_ERROR|TDFL_SYNCERROR))) {
1228         if (xact->td_error == -ENOMEM) {
1229             return (SCST_TGT_RES_QUEUE_FULL);
1230         } else {
1231             return (SCST_TGT_RES_FATAL_ERROR);
1232         }
1233     }
1234     return (SCST_TGT_RES_SUCCESS);
1235 }
1236
1237 static void
1238 isp_on_free_cmd(struct scst_cmd *scst_cmd)
1239 {
1240     tmd_cmd_t *tmd = (tmd_cmd_t *) scst_cmd_get_tgt_priv(scst_cmd);
1241     bus_t *bp = tmd->cd_bus;
1242     tmd_xact_t *xact = &tmd->cd_xact;
1243
1244     xact->td_data = NULL;
1245     ini_put(&bp->bchan[tmd->cd_channel], tmd->cd_ini);
1246     BUS_DBG2(bp, "TMD_FIN[%llx]\n", tmd->cd_tagval);
1247     (*bp->h.r_action)(QIN_TMD_FIN, tmd);
1248 }
1249
1250 static void
1251 isp_task_mgmt_fn_done(struct scst_mgmt_cmd *mgmt_cmd)
1252 {
1253     isp_notify_t *np = mgmt_cmd->tgt_priv;
1254     bus_t *bp = bus_from_notify(np);
1255
1256     ini_put(&bp->bchan[np->nt_channel], np->nt_ini);
1257     BUS_DBG(bp, "NOTIFY_ACK[%llx]\n", np->nt_tagval);
1258     (*bp->h.r_action) (QIN_NOTIFY_ACK, np);
1259 }
1260
1261 static DEFINE_MUTEX(proc_mutex);
1262
1263 /*
1264  * Many procfs things is taken from scst/src/scst_proc.c
1265  */
1266
1267 #if !defined(CONFIG_PPC) && (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 22))
1268
1269 static int strncasecmp(const char *s1, const char *s2, size_t n)
1270 {
1271         int c1, c2;
1272         do {
1273                 c1 = tolower(*s1++);
1274                 c2 = tolower(*s2++);
1275         } while ((--n > 0) && c1 == c2 && c1 != 0);
1276         return c1 - c2;
1277 }
1278
1279 #endif
1280
1281 static int
1282 isp_read_proc(struct seq_file *seq, void *v)
1283 {
1284     bus_t *bp = seq->private;
1285     bus_chan_t *bc;
1286     int chan;
1287
1288     if (bp == NULL || bp->bchan == NULL) {
1289         return (-ENODEV);
1290     }
1291
1292     if (mutex_lock_interruptible(&proc_mutex)) {
1293         return (-ERESTARTSYS);
1294     }
1295
1296     seq_printf(seq, "%s HBA %s%d DEVID %x\n", bp->h.r_type == R_FC ? "FC" : "SPI", bp->h.r_name, bp->h.r_inst, bp->h.r_locator);
1297     for (chan = 0; chan < bp->h.r_nchannels; chan++) {
1298         bc = &bp->bchan[chan];
1299         if (bp->h.r_type == R_FC) {
1300             seq_printf(seq, "%-2d: %d\n", chan, bc->enable ? 1 : 0);
1301         } else {
1302             seq_printf(seq, "%-2d: 0x%llx\n", chan, bc->enable);
1303         }
1304     }
1305
1306     mutex_unlock(&proc_mutex);
1307     return (0);
1308 }
1309
1310 static ssize_t
1311 isp_write_proc(struct file *file, const char __user *buf, size_t len, loff_t *off)
1312 {
1313     char *ptr, *p, *old;
1314     enum { DISABLE = 0, ENABLE = 1, TEST } action;
1315     int en = -1, res = -EINVAL;
1316     int all_channels = 0, all_luns = 0;
1317     int lun = 0, chan = 0;
1318     bus_t *bp = PDE(file->f_dentry->d_inode)->data;
1319
1320     if (bp == NULL || bp->bchan == NULL) {
1321         return (-ENODEV);
1322     }
1323     if (!buf) {
1324         goto out;
1325     }
1326     ptr = (char *)__get_free_page(GFP_KERNEL);
1327     if (ptr == NULL) {
1328         res = -ENOMEM;
1329         goto out;
1330     }
1331     if (copy_from_user(ptr, buf, len)) {
1332         res = -EFAULT;
1333         goto out_free;
1334     }
1335     if (len < PAGE_SIZE) {
1336         ptr[len] = '\0';
1337     } else if (ptr[PAGE_SIZE-1]) {
1338         goto out_free;
1339     }
1340
1341     /*
1342      * Usage: echo "enable|disable chan lun" > /proc/scsi_tgt/qla_isp/N
1343      *   or   echo "test" > /proc/scsi_tgt/qla_isp/N
1344      */
1345     p = ptr;
1346     if (p[strlen(p) - 1] == '\n') {
1347         p[strlen(p) - 1] = '\0';
1348     }
1349     if (!strncasecmp("enable", p, 6)) {
1350         p += 6;
1351         action = ENABLE;
1352     } else if (!strncasecmp("disable", p, 7)) {
1353         p += 7;
1354         action = DISABLE;
1355     } else if (!strncasecmp("test", p, 4)) {
1356         action = TEST;
1357     } else {
1358         PRINT_ERROR("unknown action \"%s\"", p);
1359         goto out_free;
1360     }
1361
1362     switch (action) {
1363     case ENABLE:
1364     case DISABLE:
1365         if (!isspace(*p)) {
1366             PRINT_ERROR("cannot parse arguments for action \"%s\"", action == DISABLE ? "disable" : "enable");
1367             goto out_free;
1368         }
1369
1370         /* get channel */
1371         while (isspace(*p) && *p != '\0') {
1372             p++;
1373         }
1374         old = p;
1375         chan = simple_strtoul(p, &p, 0);
1376         if (old == p) {
1377             if (!strncasecmp("all", p, 3)) {
1378                 all_channels = 1;
1379             } else {
1380                 PRINT_ERROR("cannot parse channel for action \"%s\"", action == DISABLE ? "disable" : "enable");
1381                 goto out_free;
1382             }
1383         } else if (chan < 0 || chan >= bp->h.r_nchannels) {
1384             PRINT_ERROR("bad channel number %d", chan);
1385             goto out_free;
1386         }
1387
1388         /* get lun */
1389         if (bp->h.r_type == R_SPI) {
1390             while (isspace(*p) && *p != '\0') {
1391                 p++;
1392             }
1393             old = p;
1394             lun = simple_strtoul(p, &p, 0);
1395             if (old == p) {
1396                 if (!strncasecmp("all", p, 3)) {
1397                     all_luns = 1;
1398                 } else {
1399                     PRINT_ERROR("cannot parse lun for action \"%s\"", action == DISABLE ? "disable" : "enable");
1400                     goto out_free;
1401                 }
1402             } else if (lun < 0 && lun >= MAX_LUN) {
1403                 PRINT_ERROR("bad lun %d", lun);
1404                 goto out_free;
1405             }
1406         } else {
1407             lun = LUN_ANY;
1408         }
1409
1410         en = action;
1411         break;
1412     case TEST:
1413         printk("%s test\n", __FUNCTION__);
1414         res = len;
1415         break;
1416     }
1417
1418     if (en == 0 || en == 1) {
1419         /*
1420          * channel 0 must be enabled first and disabled last, so when enabling all
1421          * channels do it in ascending order and when disabling all in descending order
1422          */
1423         int chan_srt, chan_end, chan_inc;
1424         int lun_srt, lun_end;
1425
1426         if (all_channels) {
1427             if (en) {
1428                 chan_srt = 0;
1429                 chan_end = bp->h.r_nchannels;
1430                 chan_inc = 1;
1431             } else {
1432                 chan_srt = bp->h.r_nchannels - 1;
1433                 chan_end = -1;
1434                 chan_inc = -1;
1435             }
1436         } else {
1437             chan_srt = chan;
1438             chan_end = chan + 1;
1439             chan_inc = 1;
1440         }
1441
1442         if (bp->h.r_type == R_FC) {
1443             lun_srt = LUN_ANY;
1444             lun_end = LUN_ANY + 1;
1445         } else {
1446             if (all_luns) {
1447                  lun_srt = 0;
1448                  lun_end = MAX_LUN;
1449             } else {
1450                 lun_srt = lun;
1451                 lun_end = lun + 1;
1452             }
1453         }
1454
1455         if (mutex_lock_interruptible(&proc_mutex)) {
1456             res = -ERESTARTSYS;
1457             goto out_free;
1458         }
1459         for (chan = chan_srt; chan != chan_end; chan += chan_inc) {
1460             for (lun = lun_srt; lun != lun_end; lun++) {
1461                res = scsi_target_enadis(bp, en, chan, lun);
1462                 if (res < 0) {
1463                     PRINT_ERROR("%s channel %d failed with error %d", en ? "enable" : "disable", chan, res);
1464                      /* processed anyway */
1465                 }
1466             }
1467         }
1468         res = len;
1469         mutex_unlock(&proc_mutex);
1470     }
1471
1472 out_free:
1473     free_page((unsigned long)ptr);
1474 out:
1475     return (res);
1476 }
1477
1478 static struct scst_tgt_template isp_tgt_template =
1479 {
1480     .sg_tablesize = SG_ALL, /* we set this value lately based on hardware */
1481     .name = "qla_isp",
1482     .unchecked_isa_dma = 0,
1483     .use_clustering = 1,
1484     .xmit_response_atomic = 1,
1485     .rdy_to_xfer_atomic = 1,
1486     //.report_aen_atomic = 0,
1487
1488     .detect = isp_detect,
1489     .release = isp_release,
1490
1491     .xmit_response = isp_xmit_response,
1492     .rdy_to_xfer = isp_rdy_to_xfer,
1493     .on_free_cmd = isp_on_free_cmd,
1494     .task_mgmt_fn_done = isp_task_mgmt_fn_done,
1495
1496     //.report_aen = isp_report_aen,
1497 };
1498
1499 #ifdef ISP_DAC_SUPPORTED
1500 #define ISP_A64 1
1501 #else
1502 #define ISP_A64 0
1503 #endif
1504
1505 static int
1506 get_sg_tablesize(ispsoftc_t *isp)
1507 {
1508     // FIXME: check if this is correct? What about multichannel ?
1509     // FIXME: move to the low level driver and export via tpublic API
1510     int rq_seglim, ct_seglim;
1511     int nctios = (isp->isp_maxcmds < 4) ? 0 : isp->isp_maxcmds - 4;
1512
1513     if (IS_24XX(isp)) {
1514         rq_seglim = 1;
1515         ct_seglim = ISP_CDSEG64;
1516     } else if (IS_2322(isp) || ISP_A64) {
1517         rq_seglim = ISP_RQDSEG_T3;
1518         ct_seglim = ISP_CDSEG64;
1519     } else if (IS_FC(isp)) {
1520         rq_seglim = ISP_RQDSEG_T2;
1521         ct_seglim = ISP_CDSEG;
1522     } else { // SPI
1523         rq_seglim = ISP_RQDSEG;
1524         ct_seglim = ISP_RQDSEG;
1525     }
1526
1527     return rq_seglim + nctios * ct_seglim;
1528 }
1529
1530 static void
1531 bus_set_proc_data(bus_t *bp)
1532 {
1533     const struct scst_proc_data proc_data = {
1534         SCST_DEF_RW_SEQ_OP(isp_write_proc)
1535         .show = isp_read_proc,
1536     };
1537     memcpy(&bp->proc_data, &proc_data, sizeof(bp->proc_data));
1538     bp->proc_data.data = bp;
1539 }
1540
1541 static void
1542 register_hba(bus_t *bp)
1543 {
1544     char name[32];
1545     info_t info;
1546     int chan;
1547     bus_chan_t *bchan, *bc;
1548     struct scst_tgt *scst_tgt;
1549     struct proc_dir_entry *pde;
1550
1551     bchan = kzalloc(bp->h.r_nchannels * sizeof(bus_chan_t), GFP_KERNEL);
1552     if (bchan == NULL) {
1553         Eprintk("cannot allocate %d channels for %s%d\n", bp->h.r_nchannels, bp->h.r_name, bp->h.r_inst);
1554         goto err_free_bus;
1555     }
1556
1557     for (chan = 0; chan < bp->h.r_nchannels; chan++) {
1558         memset(&info, 0, sizeof(info_t));
1559         info.i_identity = bp->h.r_identity;
1560         if (bp->h.r_type == R_FC) {
1561             info.i_type = I_FC;
1562         } else {
1563             info.i_type = I_SPI;
1564         }
1565         info.i_channel = chan;
1566         (*bp->h.r_action)(QIN_GETINFO, &info);
1567         if (info.i_error) {
1568             Eprintk("cannot get device name from %s%d!\n", bp->h.r_name, bp->h.r_inst);
1569             goto err_free_chan;
1570         }
1571
1572         if (info.i_type == I_FC) {
1573             #define GET(byte) (uint8_t) ((info.i_id.fc.wwpn >> 8*byte) & 0xff)
1574             snprintf(name, sizeof(name), "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
1575                      GET(7), GET(6), GET(5) , GET(4), GET(3), GET(2), GET(1), GET(0));
1576             #undef GET
1577         } else { // SPI
1578             #define GET(byte) (uint8_t) ((info.i_id.spi.iid >> 8*byte) & 0xff)
1579             snprintf(name, sizeof(name), "%02x:%02x:%02x:%02x", GET(3), GET(2), GET(1), GET(0));
1580             #undef GET
1581         }
1582
1583         isp_tgt_template.sg_tablesize = get_sg_tablesize(bp->h.r_identity);
1584         scst_tgt = scst_register(&isp_tgt_template, name);
1585         if (scst_tgt == NULL) {
1586             Eprintk("cannot register scst device %s for %s%d\n", name, bp->h.r_name, bp->h.r_inst);
1587             goto err_free_chan;
1588         }
1589
1590         bc = &bchan[chan];
1591         spin_lock_init(&bc->tmds_lock);
1592         tasklet_init(&bc->tasklet, tasklet_rx_cmds, (unsigned long) bc);
1593         init_rwsem(&bc->disable_sem);
1594         init_waitqueue_head(&bc->unreg_waitq);
1595         atomic_set(&bc->sess_count, 0);
1596         bc->bus = bp;
1597         bc->scst_tgt = scst_tgt;
1598         scst_tgt->tgt_priv = bc;
1599     }
1600
1601     snprintf(name, sizeof(name), "%d", ((ispsoftc_t *)bp->h.r_identity)->isp_osinfo.host->host_no);
1602     bus_set_proc_data(bp);
1603     pde = scst_create_proc_entry(scst_proc_get_tgt_root(&isp_tgt_template), name, &bp->proc_data);
1604     if (pde == NULL) {
1605         Eprintk("cannot create entry %s in /proc\n", name);
1606         goto err_free_chan;
1607     }
1608
1609     spin_lock_irq(&scsi_target_lock);
1610     bp->bchan = bchan;
1611     spin_unlock_irq(&scsi_target_lock);
1612
1613     Iprintk("registering %s%d\n", bp->h.r_name, bp->h.r_inst);
1614     (bp->h.r_action)(QIN_HBA_REG, &bp->h);
1615     return;
1616
1617 err_free_chan:
1618     for (chan = bp->h.r_nchannels -1; chan >= 0; chan--) {
1619         if (bchan[chan].scst_tgt) {
1620             scst_unregister(bchan[chan].scst_tgt);
1621         }
1622     }
1623     kfree(bchan);
1624
1625 err_free_bus:
1626     spin_lock_irq(&scsi_target_lock);
1627     memset(&bp->h, 0, sizeof (hba_register_t));
1628     spin_unlock_irq(&scsi_target_lock);
1629 }
1630
1631 static void
1632 bus_chan_unregister_sessions(bus_chan_t *bc, int wait)
1633 {
1634     int i;
1635     ini_t *ini_next, *ptr;
1636
1637     for (i = 0; i < HASH_WIDTH; i++) {
1638         spin_lock_irq(&bc->tmds_lock);
1639         ptr = bc->list[i];
1640         bc->list[i] = NULL;
1641         spin_unlock_irq(&bc->tmds_lock);
1642
1643         if (ptr) {
1644             do {
1645                 ini_next = ptr->ini_next;
1646                 if (wait) {
1647                     free_ini(bc, ptr, 1);
1648                 } else {
1649                     ini_put(bc, ptr);
1650                 }
1651             } while ((ptr = ini_next) != NULL);
1652         }
1653     }
1654 }
1655
1656 static void
1657 unregister_hba(bus_t *bp, hba_register_t *unreg_hp)
1658 {
1659     int chan;
1660     char name[32];
1661     bus_chan_t *bc;
1662
1663     snprintf(name, sizeof(name), "%d", ((ispsoftc_t *)bp->h.r_identity)->isp_osinfo.host->host_no);
1664     remove_proc_entry(name, scst_proc_get_tgt_root(&isp_tgt_template));
1665
1666     /* it's safe now to unregister and reinit bp */
1667     for (chan = 0; chan < bp->h.r_nchannels; chan++) {
1668         bc = &bp->bchan[chan];
1669         bus_chan_unregister_sessions(bc, 1);
1670         if (bc->scst_tgt) {
1671             BUS_DBG(bp, "Chan %d waiting for finishing %d sessions\n", chan, atomic_read(&bc->sess_count));
1672             wait_event(bc->unreg_waitq, atomic_read(&bc->sess_count) == 0);
1673             BUS_DBG(bp, "Chan %d all sessions finished\n", chan);
1674             scst_unregister(bc->scst_tgt);
1675         }
1676     }
1677     kfree(bp->bchan);
1678     spin_lock_irq(&scsi_target_lock);
1679     memset(bp, 0, sizeof(bus_t));
1680     spin_unlock_irq(&scsi_target_lock);
1681
1682     Iprintk("unregistering %s%d\n", unreg_hp->r_name, unreg_hp->r_inst);
1683     (unreg_hp->r_action)(QIN_HBA_UNREG, unreg_hp);
1684 }
1685
1686 /* Register SCST target, must be called in process context */
1687 static void
1688 register_scst(void)
1689 {
1690     bus_t *bp;
1691
1692     for (bp = busses; bp < &busses[MAX_BUS]; bp++) {
1693         spin_lock_irq(&scsi_target_lock);
1694         if (bp->need_reg == 0) {
1695             spin_unlock_irq(&scsi_target_lock);
1696             continue;
1697         }
1698         bp->need_reg = 0;
1699         spin_unlock_irq(&scsi_target_lock);
1700
1701         register_hba(bp);
1702    }
1703 }
1704
1705 /* Unregister SCST target, must be called in process context */
1706 static void
1707 unregister_scst(void)
1708 {
1709     bus_t *bp;
1710     hba_register_t *unreg_hp;
1711
1712     for (bp = busses; bp < &busses[MAX_BUS]; bp++) {
1713         spin_lock_irq(&scsi_target_lock);
1714         if (bp->unreg_hp == NULL) {
1715             spin_unlock_irq(&scsi_target_lock);
1716             continue;
1717         }
1718         unreg_hp = bp->unreg_hp;
1719         bp->unreg_hp = NULL;
1720         spin_unlock_irq(&scsi_target_lock);
1721
1722         unregister_hba(bp, unreg_hp);
1723     }
1724 }
1725
1726 EXPORT_SYMBOL(scsi_target_handler);
1727
1728 #ifdef    MODULE_LICENSE
1729 MODULE_LICENSE("Dual BSD/GPL");
1730 #endif
1731
1732 int init_module(void)
1733 {
1734     int ret;
1735
1736     qlaispd_task = kthread_run(qlaispd_function, NULL, "qlaispd");
1737     if (IS_ERR(qlaispd_task)) {
1738         Eprintk("running qlaispd failed\n");
1739         return PTR_ERR(qlaispd_task);
1740     }
1741
1742     ret = scst_register_target_template(&isp_tgt_template);
1743     if (ret < 0) {
1744         Eprintk("cannot register scst target template\n");
1745         kthread_stop(qlaispd_task);
1746     }
1747     return (ret);
1748 }
1749
1750 /*
1751  * We can't get here until all hbas have deregistered
1752  */
1753 void cleanup_module(void)
1754 {
1755     kthread_stop(qlaispd_task);
1756     scst_unregister_target_template(&isp_tgt_template);
1757 }
1758 /*
1759  * vim:ts=4:sw=4:expandtab
1760  */