drivers/net/fc/iph5526.c

   1 /**********************************************************************
   2  * iph5526.c: IP/SCSI driver for the Interphase 5526 PCI Fibre Channel
   3  *                        Card.
   4  * Copyright (C) 1999 Vineet M Abraham <vmabraham@hotmail.com>
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License as
   8  * published by the Free Software Foundation; either version 2, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *********************************************************************/
  16 /**********************************************************************
  17 Log:
  18 Vineet M Abraham
  19 02.12.99 Support multiple cards.
  20 03.15.99 Added Fabric support.
  21 04.04.99 Added N_Port support.
  22 04.15.99 Added SCSI support.
  23 06.18.99 Added ABTS Protocol.
  24 06.24.99 Fixed data corruption when multiple XFER_RDYs are received.
  25 07.07.99 Can be loaded as part of the Kernel. Changed semaphores. Added
  26          more checks before invalidating SEST entries.
  27 07.08.99 Added Broadcast IP stuff and fixed an unicast timeout bug.
  28 ***********************************************************************/
  29 /* TODO:
  30         R_T_TOV set to 15msec in Loop topology. Need to be 100 msec.
  31     SMP testing.
  32         Fix ADISC Tx before completing FLOGI.
  33 */
  34
  35 static const char *version =
  36     "iph5526.c:v1.0 07.08.99 Vineet Abraham (vmabraham@hotmail.com)\n";
  37
  38 #include <linux/module.h>
  39 #include <linux/kernel.h>
  40 #include <linux/errno.h>
  41 #include <linux/pci.h>
  42 #include <linux/init.h>
  43 #include <linux/interrupt.h>
  44 #include <linux/mm.h>
  45 #include <linux/delay.h>
  46 #include <linux/skbuff.h>
  47 #include <linux/if_arp.h>
  48 #include <linux/timer.h>
  49 #include <linux/spinlock.h>
  50 #include <linux/netdevice.h>
  51 #include <linux/fcdevice.h> /* had the declarations for init_fcdev among
  52                                others + includes if_fcdevice.h */
  53
  54 #include "../../scsi/scsi.h"
  55 #include <scsi/scsi_host.h>
  56 #include "../../fc4/fcp.h"
  57
  58 #include <asm/system.h>
  59 #include <asm/io.h>
  60
  61 /* driver specific header files */
  62 #include "tach.h"
  63 #include "tach_structs.h"
  64 #include "iph5526_ip.h"
  65 #include "iph5526_scsi.h"
  66 #include "iph5526_novram.c"
  67
  68 #define RUN_AT(x) (jiffies + (x))
  69
  70 #define DEBUG_5526_0 0
  71 #define DEBUG_5526_1 0
  72 #define DEBUG_5526_2 0
  73
  74 #if DEBUG_5526_0
  75 #define DPRINTK(format, a...) {printk("%s: ", fi->name); \
  76                                                            printk(format, ##a); \
  77                                                            printk("\n");}
  78 #define ENTER(x)        {printk("%s: ", fi->name); \
  79                                          printk("iph5526.c : entering %s()\n", x);}
  80 #define LEAVE(x)        {printk("%s: ", fi->name); \
  81                                          printk("iph5526.c : leaving %s()\n",x);}
  82
  83 #else
  84 #define DPRINTK(format, a...) {}
  85 #define ENTER(x)        {}
  86 #define LEAVE(x)        {}
  87 #endif
  88
  89 #if DEBUG_5526_1
  90 #define DPRINTK1(format, a...) {printk("%s: ", fi->name); \
  91                                                            printk(format, ##a); \
  92                                                            printk("\n");}
  93 #else
  94 #define DPRINTK1(format, a...) {}
  95 #endif
  96
  97 #if DEBUG_5526_2
  98 #define DPRINTK2(format, a...) {printk("%s: ", fi->name); \
  99                                                            printk(format, ##a); \
 100                                                            printk("\n");}
 101 #else
 102 #define DPRINTK2(format, a...) {}
 103 #endif
 104
 105 #define T_MSG(format, a...) {printk("%s: ", fi->name); \
 106                                                          printk(format, ##a);\
 107                                                          printk("\n");}
 108
 109 #define ALIGNED_SFS_ADDR(addr) ((((unsigned long)(addr) + (SFS_BUFFER_SIZE - 1)) & ~(SFS_BUFFER_SIZE - 1)) - (unsigned long)(addr))
 110 #define ALIGNED_ADDR(addr, len) ((((unsigned long)(addr) + (len - 1)) & ~(len - 1)) - (unsigned long)(addr))
 111
 112
 113 static struct pci_device_id iph5526_pci_tbl[] = {
 114         { PCI_VENDOR_ID_INTERPHASE, PCI_DEVICE_ID_INTERPHASE_5526, PCI_ANY_ID, PCI_ANY_ID, },
 115         { PCI_VENDOR_ID_INTERPHASE, PCI_DEVICE_ID_INTERPHASE_55x6, PCI_ANY_ID, PCI_ANY_ID, },
 116         { }                     /* Terminating entry */
 117 };
 118 MODULE_DEVICE_TABLE(pci, iph5526_pci_tbl);
 119
 120 MODULE_LICENSE("GPL");
 121
 122 #define MAX_FC_CARDS 2
 123 static struct fc_info *fc[MAX_FC_CARDS+1];
 124 static unsigned int pci_irq_line;
 125 static struct {
 126         unsigned short vendor_id;
 127         unsigned short device_id;
 128         char *name;
 129 }
 130 clone_list[] __initdata  = {
 131         {PCI_VENDOR_ID_INTERPHASE, PCI_DEVICE_ID_INTERPHASE_5526, "Interphase Fibre Channel HBA"},
 132         {PCI_VENDOR_ID_INTERPHASE, PCI_DEVICE_ID_INTERPHASE_55x6, "Interphase Fibre Channel HBA"},
 133         {0,}
 134 };
 135
 136 static irqreturn_t tachyon_interrupt(int irq, void *dev_id, struct pt_regs *regs);
 137 static void tachyon_interrupt_handler(int irq, void* dev_id, struct pt_regs* regs);
 138
 139 static int initialize_register_pointers(struct fc_info *fi);
 140 void clean_up_memory(struct fc_info *fi);
 141
 142 static int tachyon_init(struct fc_info *fi);
 143 static int build_queues(struct fc_info *fi);
 144 static void build_tachyon_header(struct fc_info *fi, u_int my_id, u_int r_ctl, u_int d_id, u_int type, u_char seq_id, u_char df_ctl, u_short ox_id, u_short rx_id, char *data);
 145 static int get_free_header(struct fc_info *fi);
 146 static void build_EDB(struct fc_info *fi, char *data, u_short flags, u_short len);
 147 static int get_free_EDB(struct fc_info *fi);
 148 static void build_ODB(struct fc_info *fi, u_char seq_id, u_int d_id, u_int len, u_int cntl, u_short mtu, u_short ox_id, u_short rx_id, int NW_header, int int_required, u_int frame_class);
 149 static void write_to_tachyon_registers(struct fc_info *fi);
 150 static void reset_latch(struct fc_info *fi);
 151 static void reset_tachyon(struct fc_info *fi, u_int value);
 152 static void take_tachyon_offline(struct fc_info *fi);
 153 static void read_novram(struct fc_info *fi);
 154 static void reset_ichip(struct fc_info *fi);
 155 static void update_OCQ_indx(struct fc_info *fi);
 156 static void update_IMQ_indx(struct fc_info *fi, int count);
 157 static void update_SFSBQ_indx(struct fc_info *fi);
 158 static void update_MFSBQ_indx(struct fc_info *fi, int count);
 159 static void update_tachyon_header_indx(struct fc_info *fi);
 160 static void update_EDB_indx(struct fc_info *fi);
 161 static void handle_FM_interrupt(struct fc_info *fi);
 162 static void handle_MFS_interrupt(struct fc_info *fi);
 163 static void handle_OOO_interrupt(struct fc_info *fi);
 164 static void handle_SFS_interrupt(struct fc_info *fi);
 165 static void handle_OCI_interrupt(struct fc_info *fi);
 166 static void handle_SFS_BUF_WARN_interrupt(struct fc_info *fi);
 167 static void handle_MFS_BUF_WARN_interrupt(struct fc_info *fi);
 168 static void handle_IMQ_BUF_WARN_interrupt(struct fc_info *fi);
 169 static void handle_Unknown_Frame_interrupt(struct fc_info *fi);
 170 static void handle_Busied_Frame_interrupt(struct fc_info *fi);
 171 static void handle_Bad_SCSI_Frame_interrupt(struct fc_info *fi);
 172 static void handle_Inbound_SCSI_Status_interrupt(struct fc_info *fi);
 173 static void handle_Inbound_SCSI_Command_interrupt(struct fc_info *fi);
 174 static void completion_message_handler(struct fc_info *fi, u_int imq_int_type);
 175 static void fill_login_frame(struct fc_info *fi, u_int logi);
 176
 177 static int tx_exchange(struct fc_info *fi, char *data, u_int len, u_int r_ctl, u_int type, u_int d_id, u_int mtu, int int_required, u_short ox_id, u_int frame_class);
 178 static int tx_sequence(struct fc_info *fi, char *data, u_int len, u_int mtu, u_int d_id, u_short ox_id, u_short rx_id, u_char seq_id, int NW_flag, int int_required, u_int frame_class);
 179 static int validate_login(struct fc_info *fi, u_int *base_ptr);
 180 static void add_to_address_cache(struct fc_info *fi, u_int *base_ptr);
 181 static void remove_from_address_cache(struct fc_info *fi, u_int *data, u_int cmnd_code);
 182 static int node_logged_in_prev(struct fc_info *fi, u_int *buff_addr);
 183 static int sid_logged_in(struct fc_info *fi, u_int s_id);
 184 static struct fc_node_info *look_up_cache(struct fc_info *fi, char *data);
 185 static int display_cache(struct fc_info *fi);
 186
 187 static void tx_logi(struct fc_info *fi, u_int logi, u_int d_id);
 188 static void tx_logi_acc(struct fc_info *fi, u_int logi, u_int d_id, u_short received_ox_id);
 189 static void tx_prli(struct fc_info *fi, u_int command_code, u_int d_id, u_short received_ox_id);
 190 static void tx_logo(struct fc_info *fi, u_int d_id, u_short received_ox_id);
 191 static void tx_adisc(struct fc_info *fi, u_int cmnd_code, u_int d_id, u_short received_ox_id);
 192 static void tx_ls_rjt(struct fc_info *fi, u_int d_id, u_short received_ox_id, u_short reason_code, u_short expln_code);
 193 static u_int plogi_ok(struct fc_info *fi, u_int *buff_addr, int size);
 194 static void tx_acc(struct fc_info *fi, u_int d_id, u_short received_ox_id);
 195 static void tx_name_server_req(struct fc_info *fi, u_int req);
 196 static void rscn_handler(struct fc_info *fi, u_int node_id);
 197 static void tx_scr(struct fc_info *fi);
 198 static void scr_timer(unsigned long data);
 199 static void explore_fabric(struct fc_info *fi, u_int *buff_addr);
 200 static void perform_adisc(struct fc_info *fi);
 201 static void local_port_discovery(struct fc_info *fi);
 202 static void add_to_ox_id_list(struct fc_info *fi, u_int transaction_id, u_int cmnd_code);
 203 static u_int remove_from_ox_id_list(struct fc_info *fi, u_short received_ox_id);
 204 static void add_display_cache_timer(struct fc_info *fi);
 205
 206 /* Timers... */
 207 static void nos_ols_timer(unsigned long data);
 208 static void loop_timer(unsigned long data);
 209 static void fabric_explore_timer(unsigned long data);
 210 static void port_discovery_timer(unsigned long data);
 211 static void display_cache_timer(unsigned long data);
 212
 213 /* SCSI Stuff */
 214 static int add_to_sest(struct fc_info *fi, Scsi_Cmnd *Cmnd, struct fc_node_info *ni);
 215 static struct fc_node_info *resolve_target(struct fc_info *fi, u_char target);
 216 static void update_FCP_CMND_indx(struct fc_info *fi);
 217 static int get_free_SDB(struct fc_info *fi);
 218 static void update_SDB_indx(struct fc_info *fi);
 219 static void mark_scsi_sid(struct fc_info *fi, u_int *buff_addr, u_char action);
 220 static void invalidate_SEST_entry(struct fc_info *fi, u_short received_ox_id);
 221 static int abort_exchange(struct fc_info *fi, u_short ox_id);
 222 static void flush_tachyon_cache(struct fc_info *fi, u_short ox_id);
 223 static int get_scsi_oxid(struct fc_info *fi);
 224 static void update_scsi_oxid(struct fc_info *fi);
 225
 226 static Scsi_Host_Template driver_template = IPH5526_SCSI_FC;
 227
 228 static void iph5526_timeout(struct net_device *dev);
 229
 230 static int iph5526_probe_pci(struct net_device *dev);
 231
 232 int __init iph5526_probe(struct net_device *dev)
 233 {
 234         if (iph5526_probe_pci(dev) == 0)
 235                 return 0;
 236         return -ENODEV;
 237 }
 238
 239 static int __init iph5526_probe_pci(struct net_device *dev)
 240 {
 241         struct fc_info *fi = dev->priv;
 242         fi->dev = dev;
 243         dev->base_addr = fi->base_addr;
 244         dev->irq = fi->irq;
 245         if (dev->priv == NULL)
 246                 dev->priv = fi;
 247         fcdev_init(dev);
 248         /* Assign ur MAC address.
 249          */
 250         dev->dev_addr[0] = (fi->g.my_port_name_high & 0x0000FF00) >> 8;
 251         dev->dev_addr[1] = fi->g.my_port_name_high;
 252         dev->dev_addr[2] = (fi->g.my_port_name_low & 0xFF000000) >> 24;
 253         dev->dev_addr[3] = (fi->g.my_port_name_low & 0x00FF0000) >> 16;
 254         dev->dev_addr[4] = (fi->g.my_port_name_low & 0x0000FF00) >> 8;
 255         dev->dev_addr[5] = fi->g.my_port_name_low;
 256         display_cache(fi);
 257         return 0;
 258 }
 259
 260 static int __init fcdev_init(struct net_device *dev)
 261 {
 262         SET_MODULE_OWNER(dev);
 263         dev->open = iph5526_open;
 264         dev->stop = iph5526_close;
 265         dev->hard_start_xmit = iph5526_send_packet;
 266         dev->get_stats = iph5526_get_stats;
 267         dev->set_multicast_list = NULL;
 268         dev->change_mtu = iph5526_change_mtu;
 269         dev->tx_timeout = iph5526_timeout;
 270         dev->watchdog_timeo = 5*HZ;
 271         return 0;
 272 }
 273
 274 /* initialize tachyon and take it OnLine */
 275 static int tachyon_init(struct fc_info *fi)
 276 {
 277         ENTER("tachyon_init");
 278         if (build_queues(fi) == 0) {
 279                 T_MSG("build_queues() failed");
 280                 return 0;
 281         }
 282
 283         /* Retrieve your port/node name.
 284          */
 285         read_novram(fi);
 286
 287         reset_ichip(fi);
 288
 289         reset_tachyon(fi, SOFTWARE_RESET);
 290
 291         LEAVE("tachyon_init");
 292         return 1;
 293 }
 294
 295 /* Build the 4 Qs - IMQ, OCQ, MFSBQ, SFSBQ */
 296 /* Lots of dma_pages needed as Tachyon DMAs almost everything into
 297  * host memory.
 298  */
 299 static int build_queues(struct fc_info *fi)
 300 {
 301 int i,j;
 302 u_char *addr;
 303         ENTER("build_queues");
 304         /* Initializing Queue Variables.
 305          */
 306         fi->q.ptr_host_ocq_cons_indx = NULL;
 307         fi->q.ptr_host_hpcq_cons_indx = NULL;
 308         fi->q.ptr_host_imq_prod_indx = NULL;
 309
 310         fi->q.ptr_ocq_base = NULL;
 311         fi->q.ocq_len = 0;
 312         fi->q.ocq_end = 0;
 313         fi->q.ocq_prod_indx = 0;
 314
 315         fi->q.ptr_imq_base = NULL;
 316         fi->q.imq_len = 0;
 317         fi->q.imq_end = 0;
 318         fi->q.imq_cons_indx = 0;
 319         fi->q.imq_prod_indx = 0;
 320
 321         fi->q.ptr_mfsbq_base = NULL;
 322         fi->q.mfsbq_len = 0;
 323         fi->q.mfsbq_end = 0;
 324         fi->q.mfsbq_prod_indx = 0;
 325         fi->q.mfsbq_cons_indx = 0;
 326         fi->q.mfsbuff_len = 0;
 327         fi->q.mfsbuff_end = 0;
 328         fi->g.mfs_buffer_count = 0;
 329
 330         fi->q.ptr_sfsbq_base = NULL;
 331         fi->q.sfsbq_len = 0;
 332         fi->q.sfsbq_end = 0;
 333         fi->q.sfsbq_prod_indx = 0;
 334         fi->q.sfsbq_cons_indx = 0;
 335         fi->q.sfsbuff_len = 0;
 336         fi->q.sfsbuff_end = 0;
 337
 338         fi->q.sdb_indx = 0;
 339         fi->q.fcp_cmnd_indx = 0;
 340
 341         fi->q.ptr_edb_base = NULL;
 342         fi->q.edb_buffer_indx = 0;
 343         fi->q.ptr_tachyon_header_base = NULL;
 344         fi->q.tachyon_header_indx = 0;
 345         fi->node_info_list = NULL;
 346         fi->ox_id_list = NULL;
 347         fi->g.loop_up = FALSE;
 348         fi->g.ptp_up = FALSE;
 349         fi->g.link_up = FALSE;
 350         fi->g.fabric_present = FALSE;
 351         fi->g.n_port_try = FALSE;
 352         fi->g.dont_init = FALSE;
 353         fi->g.nport_timer_set = FALSE;
 354         fi->g.lport_timer_set = FALSE;
 355         fi->g.no_of_targets = 0;
 356         fi->g.sem = 0;
 357         fi->g.perform_adisc = FALSE;
 358         fi->g.e_i = 0;
 359
 360         /* build OCQ */
 361         if ( (fi->q.ptr_ocq_base = (u_int *)__get_free_pages(GFP_KERNEL, 0)) == 0) {
 362                 T_MSG("failed to get OCQ page");
 363                 return 0;
 364         }
 365         /* set up the OCQ structures */
 366         for (i = 0; i < OCQ_LENGTH; i++)
 367                 fi->q.ptr_odb[i] = fi->q.ptr_ocq_base + NO_OF_ENTRIES*i;
 368
 369         /* build IMQ */
 370         if ( (fi->q.ptr_imq_base = (u_int *)__get_free_pages(GFP_KERNEL, 0)) == 0) {
 371                 T_MSG("failed to get IMQ page");
 372                 return 0;
 373         }
 374         for (i = 0; i < IMQ_LENGTH; i++)
 375                 fi->q.ptr_imqe[i] = fi->q.ptr_imq_base + NO_OF_ENTRIES*i;
 376
 377         /* build MFSBQ */
 378         if ( (fi->q.ptr_mfsbq_base = (u_int *)__get_free_pages(GFP_KERNEL, 0)) == 0) {
 379                 T_MSG("failed to get MFSBQ page");
 380                 return 0;
 381         }
 382         memset((char *)fi->q.ptr_mfsbq_base, 0, MFSBQ_LENGTH * 32);
 383         /* Allocate one huge chunk of memory... helps while reassembling
 384          * frames.
 385          */
 386         if ( (addr = (u_char *)__get_free_pages(GFP_KERNEL, 5) ) == 0) {
 387                 T_MSG("failed to get MFSBQ page");
 388                 return 0;
 389         }
 390         /* fill in addresses of empty buffers */
 391         for (i = 0; i < MFSBQ_LENGTH; i++) {
 392                 for (j = 0; j < NO_OF_ENTRIES; j++) {
 393                                 *(fi->q.ptr_mfsbq_base + i*NO_OF_ENTRIES + j) = htonl(virt_to_bus(addr));
 394                                 addr += MFS_BUFFER_SIZE;
 395                 }
 396         }
 397
 398         /* The number of entries in each MFS buffer is 8. There are 8
 399          * MFS buffers. That leaves us with 4096-256 bytes. We use them
 400          * as temporary space for ELS frames. This is done to make sure that
 401          * the addresses are aligned.
 402          */
 403         fi->g.els_buffer[0] = fi->q.ptr_mfsbq_base + MFSBQ_LENGTH*NO_OF_ENTRIES;
 404         for (i = 1; i < MAX_PENDING_FRAMES; i++)
 405                 fi->g.els_buffer[i] = fi->g.els_buffer[i-1] + 64;
 406
 407         /* build SFSBQ */
 408         if ( (fi->q.ptr_sfsbq_base = (u_int *)__get_free_pages(GFP_KERNEL, 0)) == 0) {
 409                 T_MSG("failed to get SFSBQ page");
 410                 return 0;
 411         }
 412         memset((char *)fi->q.ptr_sfsbq_base, 0, SFSBQ_LENGTH * 32);
 413         /* fill in addresses of empty buffers */
 414         for (i = 0; i < SFSBQ_LENGTH; i++)
 415                 for (j = 0; j < NO_OF_ENTRIES; j++){
 416                         addr = kmalloc(SFS_BUFFER_SIZE*2, GFP_KERNEL);
 417                         if (addr == NULL){
 418                                 T_MSG("ptr_sfs_buffer : memory not allocated");
 419                                 return 0;
 420                         }
 421                         else {
 422                         int offset = ALIGNED_SFS_ADDR(addr);
 423                                 memset((char *)addr, 0, SFS_BUFFER_SIZE);
 424                                 fi->q.ptr_sfs_buffers[i*NO_OF_ENTRIES +j] = (u_int *)addr;
 425                                 addr += offset;
 426                                 *(fi->q.ptr_sfsbq_base + i*NO_OF_ENTRIES + j) = htonl(virt_to_bus(addr));
 427                         }
 428                 }
 429
 430         /* The number of entries in each SFS buffer is 8. There are 8
 431          * MFS buffers. That leaves us with 4096-256 bytes. We use them
 432          * as temporary space for ARP frames. This is done inorder to
 433          * support HW_Types of 0x1 and 0x6.
 434          */
 435         fi->g.arp_buffer = (char *)fi->q.ptr_sfsbq_base + SFSBQ_LENGTH*NO_OF_ENTRIES*4;
 436
 437         /* build EDB */
 438         if ((fi->q.ptr_edb_base = (u_int *)__get_free_pages(GFP_KERNEL, 5) ) == 0) {
 439                 T_MSG("failed to get EDB page");
 440                 return 0;
 441         }
 442         for (i = 0; i < EDB_LEN; i++)
 443                 fi->q.ptr_edb[i] = fi->q.ptr_edb_base + 2*i;
 444
 445         /* build SEST */
 446
 447         /* OX_IDs range from 0x0 - 0x4FFF.
 448          */
 449         if ((fi->q.ptr_sest_base = (u_int *)__get_free_pages(GFP_KERNEL, 5)) == 0) {
 450                 T_MSG("failed to get SEST page");
 451                 return 0;
 452         }
 453         for (i = 0; i < SEST_LENGTH; i++)
 454                 fi->q.ptr_sest[i] = fi->q.ptr_sest_base + NO_OF_ENTRIES*i;
 455
 456         if ((fi->q.ptr_sdb_base = (u_int *)__get_free_pages(GFP_KERNEL, 5)) == 0) {
 457                 T_MSG("failed to get SDB page");
 458                 return 0;
 459         }
 460         for (i = 0 ; i < NO_OF_SDB_ENTRIES; i++)
 461                 fi->q.ptr_sdb_slot[i] = fi->q.ptr_sdb_base + (SDB_SIZE/4)*i;
 462
 463         if ((fi->q.ptr_fcp_cmnd_base = (u_int *)__get_free_pages(GFP_KERNEL, 0)) == 0) {
 464                 T_MSG("failed to get FCP_CMND page");
 465                 return 0;
 466         }
 467         for (i = 0; i < NO_OF_FCP_CMNDS; i++)
 468                 fi->q.ptr_fcp_cmnd[i] = fi->q.ptr_fcp_cmnd_base + NO_OF_ENTRIES*i;
 469
 470         /* Allocate space for Tachyon Header as well...
 471          */
 472         if ((fi->q.ptr_tachyon_header_base = (u_int *)__get_free_pages(GFP_KERNEL, 0) ) == 0) {
 473                 T_MSG("failed to get tachyon_header page");
 474                 return 0;
 475         }
 476         for (i = 0; i < NO_OF_TACH_HEADERS; i++)
 477                 fi->q.ptr_tachyon_header[i] = fi->q.ptr_tachyon_header_base + 16*i;
 478
 479         /* Allocate memory for indices.
 480          * Indices should be aligned on 32 byte boundaries.
 481          */
 482         fi->q.host_ocq_cons_indx = kmalloc(2*32, GFP_KERNEL);
 483         if (fi->q.host_ocq_cons_indx == NULL){
 484                 T_MSG("fi->q.host_ocq_cons_indx : memory not allocated");
 485                 return 0;
 486         }
 487         fi->q.ptr_host_ocq_cons_indx = fi->q.host_ocq_cons_indx;
 488         if ((u_long)(fi->q.host_ocq_cons_indx) % 32)
 489                 fi->q.host_ocq_cons_indx++;
 490
 491         fi->q.host_hpcq_cons_indx = kmalloc(2*32, GFP_KERNEL);
 492         if (fi->q.host_hpcq_cons_indx == NULL){
 493                 T_MSG("fi->q.host_hpcq_cons_indx : memory not allocated");
 494                 return 0;
 495         }
 496         fi->q.ptr_host_hpcq_cons_indx= fi->q.host_hpcq_cons_indx;
 497         if ((u_long)(fi->q.host_hpcq_cons_indx) % 32)
 498                 fi->q.host_hpcq_cons_indx++;
 499
 500         fi->q.host_imq_prod_indx = kmalloc(2*32, GFP_KERNEL);
 501         if (fi->q.host_imq_prod_indx == NULL){
 502                 T_MSG("fi->q.host_imq_prod_indx : memory not allocated");
 503                 return 0;
 504         }
 505         fi->q.ptr_host_imq_prod_indx = fi->q.host_imq_prod_indx;
 506         if ((u_long)(fi->q.host_imq_prod_indx) % 32)
 507                 fi->q.host_imq_prod_indx++;
 508
 509         LEAVE("build_queues");
 510         return 1;
 511 }
 512
 513
 514 static void write_to_tachyon_registers(struct fc_info *fi)
 515 {
 516 u_int bus_addr, bus_indx_addr, i;
 517
 518         ENTER("write_to_tachyon_registers");
 519
 520         /* Clear Queues each time Tachyon is reset */
 521         memset((char *)fi->q.ptr_ocq_base, 0, OCQ_LENGTH * 32);
 522         memset((char *)fi->q.ptr_imq_base, 0, IMQ_LENGTH * 32);
 523         memset((char *)fi->q.ptr_edb_base, 0, EDB_LEN * 8);
 524         memset((char *)fi->q.ptr_sest_base, 0, SEST_LENGTH * 32);
 525         memset((char *)fi->q.ptr_sdb_base, 0, NO_OF_SDB_ENTRIES * SDB_SIZE);
 526         memset((char *)fi->q.ptr_tachyon_header_base, 0xFF, NO_OF_TACH_HEADERS * TACH_HEADER_SIZE);
 527         for (i = 0; i < SEST_LENGTH; i++)
 528                 fi->q.free_scsi_oxid[i] = OXID_AVAILABLE;
 529         for (i = 0; i < NO_OF_SDB_ENTRIES; i++)
 530                 fi->q.sdb_slot_status[i] = SDB_FREE;
 531
 532         take_tachyon_offline(fi);
 533         writel(readl(fi->t_r.ptr_tach_config_reg) | SCSI_ENABLE | WRITE_STREAM_SIZE | READ_STREAM_SIZE | PARITY_EVEN | OOO_REASSEMBLY_DISABLE, fi->t_r.ptr_tach_config_reg);
 534
 535         /* Write OCQ registers */
 536         fi->q.ocq_prod_indx = 0;
 537         *(fi->q.host_ocq_cons_indx) = 0;
 538
 539         /* The Tachyon needs to be passed the "real" address */
 540         bus_addr = virt_to_bus(fi->q.ptr_ocq_base);
 541         writel(bus_addr, fi->t_r.ptr_ocq_base_reg);
 542         writel(OCQ_LENGTH - 1, fi->t_r. ptr_ocq_len_reg);
 543         bus_indx_addr = virt_to_bus(fi->q.host_ocq_cons_indx);
 544         writel(bus_indx_addr, fi->t_r.ptr_ocq_cons_indx_reg);
 545
 546         /* Write IMQ registers */
 547         fi->q.imq_cons_indx = 0;
 548         *(fi->q.host_imq_prod_indx) = 0;
 549         bus_addr = virt_to_bus(fi->q.ptr_imq_base);
 550         writel(bus_addr, fi->t_r.ptr_imq_base_reg);
 551         writel(IMQ_LENGTH - 1, fi->t_r.ptr_imq_len_reg);
 552         bus_indx_addr = virt_to_bus(fi->q.host_imq_prod_indx);
 553         writel(bus_indx_addr, fi->t_r.ptr_imq_prod_indx_reg);
 554
 555         /* Write MFSBQ registers */
 556         fi->q.mfsbq_prod_indx = MFSBQ_LENGTH - 1;
 557         fi->q.mfsbuff_end = MFS_BUFFER_SIZE - 1;
 558         fi->q.mfsbq_cons_indx = 0;
 559         bus_addr = virt_to_bus(fi->q.ptr_mfsbq_base);
 560         writel(bus_addr, fi->t_r.ptr_mfsbq_base_reg);
 561         writel(MFSBQ_LENGTH - 1, fi->t_r.ptr_mfsbq_len_reg);
 562         writel(fi->q.mfsbuff_end, fi->t_r.ptr_mfsbuff_len_reg);
 563         /* Do this last as tachyon will prefetch the
 564          * first entry as soon as we write to it.
 565          */
 566         writel(fi->q.mfsbq_prod_indx, fi->t_r.ptr_mfsbq_prod_reg);
 567
 568         /* Write SFSBQ registers */
 569         fi->q.sfsbq_prod_indx = SFSBQ_LENGTH - 1;
 570         fi->q.sfsbuff_end = SFS_BUFFER_SIZE - 1;
 571         fi->q.sfsbq_cons_indx = 0;
 572         bus_addr = virt_to_bus(fi->q.ptr_sfsbq_base);
 573         writel(bus_addr, fi->t_r.ptr_sfsbq_base_reg);
 574         writel(SFSBQ_LENGTH - 1, fi->t_r.ptr_sfsbq_len_reg);
 575         writel(fi->q.sfsbuff_end, fi->t_r.ptr_sfsbuff_len_reg);
 576         /* Do this last as tachyon will prefetch the first
 577          * entry as soon as we write to it.
 578          */
 579         writel(fi->q.sfsbq_prod_indx, fi->t_r.ptr_sfsbq_prod_reg);
 580
 581         /* Write SEST registers */
 582         bus_addr = virt_to_bus(fi->q.ptr_sest_base);
 583         writel(bus_addr, fi->t_r.ptr_sest_base_reg);
 584         writel(SEST_LENGTH - 1, fi->t_r.ptr_sest_len_reg);
 585         /* the last 2 bits _should_ be 1 */
 586         writel(SEST_BUFFER_SIZE - 1, fi->t_r.ptr_scsibuff_len_reg);
 587
 588         /* write AL_TIME & E_D_TOV into the registers */
 589         writel(TOV_VALUES, fi->t_r.ptr_fm_tov_reg);
 590         /* Tell Tachyon to pick a Soft Assigned AL_PA */
 591         writel(LOOP_INIT_SOFT_ADDRESS, fi->t_r.ptr_fm_config_reg);
 592
 593         /* Read the WWN from EEPROM . But, for now we assign it here. */
 594         writel(WORLD_WIDE_NAME_LOW, fi->t_r.ptr_fm_wwn_low_reg);
 595         writel(WORLD_WIDE_NAME_HIGH, fi->t_r.ptr_fm_wwn_hi_reg);
 596
 597         DPRINTK1("TACHYON initializing as L_Port...\n");
 598         writel(INITIALIZE, fi->t_r.ptr_fm_control_reg);
 599
 600         LEAVE("write_to_tachyon_registers");
 601 }
 602
 603
 604 static irqreturn_t tachyon_interrupt(int irq, void* dev_id, struct pt_regs* regs)
 605 {
 606 struct Scsi_Host *host = dev_id;
 607 struct iph5526_hostdata *hostdata = (struct iph5526_hostdata *)host->hostdata;
 608 struct fc_info *fi = hostdata->fi;
 609 u_long flags;
 610         spin_lock_irqsave(&fi->fc_lock, flags);
 611         tachyon_interrupt_handler(irq, dev_id, regs);
 612         spin_unlock_irqrestore(&fi->fc_lock, flags);
 613         return IRQ_HANDLED;
 614 }
 615
 616 static void tachyon_interrupt_handler(int irq, void* dev_id, struct pt_regs* regs)
 617 {
 618 struct Scsi_Host *host = dev_id;
 619 struct iph5526_hostdata *hostdata = (struct iph5526_hostdata *)host->hostdata;
 620 struct fc_info *fi = hostdata->fi;
 621 u_int *ptr_imq_entry;
 622 u_int imq_int_type, current_IMQ_index = 0, prev_IMQ_index;
 623 int index, no_of_entries = 0;
 624
 625         DPRINTK("\n");
 626         ENTER("tachyon_interrupt");
 627         if (fi->q.host_imq_prod_indx != NULL) {
 628                 current_IMQ_index =  ntohl(*(fi->q.host_imq_prod_indx));
 629         }
 630         else {
 631                 /* _Should not_ happen */
 632                 T_MSG("IMQ_indx NULL. DISABLING INTERRUPTS!!!\n");
 633                 writel(0x0, fi->i_r.ptr_ichip_hw_control_reg);
 634         }
 635
 636         if (current_IMQ_index > fi->q.imq_cons_indx)
 637                 no_of_entries = current_IMQ_index - fi->q.imq_cons_indx;
 638         else
 639         if (current_IMQ_index < fi->q.imq_cons_indx)
 640                 no_of_entries = IMQ_LENGTH - (fi->q.imq_cons_indx - current_IMQ_index);
 641
 642         if (no_of_entries == 0) {
 643         u_int ichip_status;
 644                 ichip_status = readl(fi->i_r.ptr_ichip_hw_status_reg);
 645                 if (ichip_status & 0x20) {
 646                         /* Should _never_ happen. Might require a hard reset */
 647                         T_MSG("Too bad... PCI Bus Error. Resetting (i)chip");
 648                         reset_ichip(fi);
 649                         T_MSG("DISABLING INTERRUPTS!!!\n");
 650                         writel(0x0, fi->i_r.ptr_ichip_hw_control_reg);
 651                 }
 652         }
 653
 654         prev_IMQ_index = current_IMQ_index;
 655         for (index = 0; index < no_of_entries; index++) {
 656                 ptr_imq_entry = fi->q.ptr_imqe[fi->q.imq_cons_indx];
 657                 imq_int_type = ntohl(*ptr_imq_entry);
 658
 659                 completion_message_handler(fi, imq_int_type);
 660                 if ((fi->g.link_up == FALSE) && ((imq_int_type == MFS_BUF_WARN) || (imq_int_type == SFS_BUF_WARN) || (imq_int_type == IMQ_BUF_WARN)))
 661                         break;
 662                 update_IMQ_indx(fi, 1);
 663
 664                 /* Check for more entries */
 665                 current_IMQ_index =  ntohl(*(fi->q.host_imq_prod_indx));
 666                 if (current_IMQ_index != prev_IMQ_index) {
 667                         no_of_entries++;
 668                         prev_IMQ_index = current_IMQ_index;
 669                 }
 670         } /*end of for loop*/
 671         LEAVE("tachyon_interrupt");
 672        return;
 673 }
 674
 675
 676 static void handle_SFS_BUF_WARN_interrupt(struct fc_info *fi)
 677 {
 678 int i;
 679         ENTER("handle_SFS_BUF_WARN_interrupt");
 680         if (fi->g.link_up == FALSE) {
 681                 reset_tachyon(fi, SOFTWARE_RESET);
 682                 return;
 683         }
 684         /* Free up all but one entry in the Q.
 685          */
 686         for (i = 0; i < ((SFSBQ_LENGTH - 1) * NO_OF_ENTRIES); i++) {
 687                 handle_SFS_interrupt(fi);
 688                 update_IMQ_indx(fi, 1);
 689         }
 690         LEAVE("handle_SFS_BUF_WARN_interrupt");
 691 }
 692
 693 /* Untested_Code_Begin */
 694 static void handle_MFS_BUF_WARN_interrupt(struct fc_info *fi)
 695 {
 696 int i;
 697         ENTER("handle_MFS_BUF_WARN_interrupt");
 698         if (fi->g.link_up == FALSE) {
 699                 reset_tachyon(fi, SOFTWARE_RESET);
 700                 return;
 701         }
 702         /* FIXME: freeing up 8 entries.
 703          */
 704         for (i = 0; i < NO_OF_ENTRIES; i++) {
 705                 handle_MFS_interrupt(fi);
 706                 update_IMQ_indx(fi, 1);
 707         }
 708         LEAVE("handle_MFS_BUF_WARN_interrupt");
 709 }
 710 /*Untested_Code_End */
 711
 712 static void handle_IMQ_BUF_WARN_interrupt(struct fc_info *fi)
 713 {
 714 u_int *ptr_imq_entry;
 715 u_int imq_int_type, current_IMQ_index = 0, temp_imq_cons_indx;
 716 int index, no_of_entries = 0;
 717
 718         ENTER("handle_IMQ_BUF_WARN_interrupt");
 719         if (fi->g.link_up == FALSE) {
 720                 reset_tachyon(fi, SOFTWARE_RESET);
 721                 return;
 722         }
 723         current_IMQ_index =  ntohl(*(fi->q.host_imq_prod_indx));
 724
 725         if (current_IMQ_index > fi->q.imq_cons_indx)
 726                 no_of_entries = current_IMQ_index - fi->q.imq_cons_indx;
 727         else
 728                 if (current_IMQ_index < fi->q.imq_cons_indx)
 729                         no_of_entries = IMQ_LENGTH - (fi->q.imq_cons_indx - current_IMQ_index);
 730         /* We don't want to look at the same IMQ entry again.
 731          */
 732         temp_imq_cons_indx = fi->q.imq_cons_indx + 1;
 733         if (no_of_entries != 0)
 734                 no_of_entries -= 1;
 735         for (index = 0; index < no_of_entries; index++) {
 736                 ptr_imq_entry = fi->q.ptr_imqe[temp_imq_cons_indx];
 737                 imq_int_type = ntohl(*ptr_imq_entry);
 738                 if (imq_int_type != IMQ_BUF_WARN)
 739                         completion_message_handler(fi, imq_int_type);
 740                 temp_imq_cons_indx++;
 741                 if (temp_imq_cons_indx == IMQ_LENGTH)
 742                         temp_imq_cons_indx = 0;
 743         } /*end of for loop*/
 744         if (no_of_entries != 0)
 745                 update_IMQ_indx(fi, no_of_entries);
 746         LEAVE("handle_IMQ_BUF_WARN_interrupt");
 747 }
 748
 749 static void completion_message_handler(struct fc_info *fi, u_int imq_int_type)
 750 {
 751         switch(imq_int_type) {
 752                 case OUTBOUND_COMPLETION:
 753                         DPRINTK("OUTBOUND_COMPLETION message received");
 754                         break;
 755                 case OUTBOUND_COMPLETION_I:
 756                         DPRINTK("OUTBOUND_COMPLETION_I message received");
 757                         handle_OCI_interrupt(fi);
 758                         break;
 759                 case OUT_HI_PRI_COMPLETION:
 760                         DPRINTK("OUT_HI_PRI_COMPLETION message received");
 761                         break;
 762                 case OUT_HI_PRI_COMPLETION_I:
 763                         DPRINTK("OUT_HI_PRI_COMPLETION_I message received");
 764                         break;
 765                 case INBOUND_MFS_COMPLETION:
 766                         DPRINTK("INBOUND_MFS_COMPLETION message received");
 767                         handle_MFS_interrupt(fi);
 768                         break;
 769                 case INBOUND_OOO_COMPLETION:
 770                         DPRINTK("INBOUND_OOO_COMPLETION message received");
 771                         handle_OOO_interrupt(fi);
 772                         break;
 773                 case INBOUND_SFS_COMPLETION:
 774                         DPRINTK("INBOUND_SFS_COMPLETION message received");
 775                         handle_SFS_interrupt(fi);
 776                         break;
 777                 case INBOUND_UNKNOWN_FRAME_I:
 778                         DPRINTK("INBOUND_UNKNOWN_FRAME message received");
 779                         handle_Unknown_Frame_interrupt(fi);
 780                         break;
 781                 case INBOUND_BUSIED_FRAME:
 782                         DPRINTK("INBOUND_BUSIED_FRAME message received");
 783                         handle_Busied_Frame_interrupt(fi);
 784                         break;
 785                 case FRAME_MGR_INTERRUPT:
 786                         DPRINTK("FRAME_MGR_INTERRUPT message received");
 787                         handle_FM_interrupt(fi);
 788                         break;
 789                 case READ_STATUS:
 790                         DPRINTK("READ_STATUS message received");
 791                         break;
 792                 case SFS_BUF_WARN:
 793                         DPRINTK("SFS_BUF_WARN message received");
 794                         handle_SFS_BUF_WARN_interrupt(fi);
 795                         break;
 796                 case MFS_BUF_WARN:
 797                         DPRINTK("MFS_BUF_WARN message received");
 798                         handle_MFS_BUF_WARN_interrupt(fi);
 799                         break;
 800                 case IMQ_BUF_WARN:
 801                         DPRINTK("IMQ_BUF_WARN message received");
 802                         handle_IMQ_BUF_WARN_interrupt(fi);
 803                         break;
 804                 case INBOUND_C1_TIMEOUT:
 805                         DPRINTK("INBOUND_C1_TIMEOUT message received");
 806                         break;
 807                 case BAD_SCSI_FRAME:
 808                         DPRINTK("BAD_SCSI_FRAME message received");
 809                         handle_Bad_SCSI_Frame_interrupt(fi);
 810                         break;
 811                 case INB_SCSI_STATUS_COMPLETION:
 812                         DPRINTK("INB_SCSI_STATUS_COMPL message received");
 813                         handle_Inbound_SCSI_Status_interrupt(fi);
 814                         break;
 815                 case INBOUND_SCSI_COMMAND:
 816                         DPRINTK("INBOUND_SCSI_COMMAND message received");
 817                         handle_Inbound_SCSI_Command_interrupt(fi);
 818                         break;
 819                 case INBOUND_SCSI_DATA_COMPLETION:
 820                         DPRINTK("INBOUND_SCSI_DATA message received");
 821                         /* Only for targets */
 822                         break;
 823                 default:
 824                         T_MSG("DEFAULT message received, type = %x", imq_int_type);
 825                         return;
 826         }
 827         reset_latch(fi);
 828 }
 829
 830 static void handle_OCI_interrupt(struct fc_info *fi)
 831 {
 832 u_int *ptr_imq_entry;
 833 u_long transaction_id = 0;
 834 unsigned short status, seq_count, transmitted_ox_id;
 835 struct Scsi_Host *host = fi->host;
 836 struct iph5526_hostdata *hostdata = (struct iph5526_hostdata *)host->hostdata;
 837 Scsi_Cmnd *Cmnd;
 838 u_int tag;
 839
 840         ENTER("handle_OCI_interrupt");
 841         ptr_imq_entry = fi->q.ptr_imqe[fi->q.imq_cons_indx];
 842         transaction_id = ntohl(*(ptr_imq_entry + 1));
 843         status = ntohl(*(ptr_imq_entry + 2)) >> 16;
 844         seq_count = ntohl(*(ptr_imq_entry + 3));
 845         DPRINTK("transaction_id= %x", (u_int)transaction_id);
 846         tag = transaction_id & 0xFFFF0000;
 847         transmitted_ox_id = transaction_id;
 848
 849         /* The INT could be either due to TIME_OUT | BAD_ALPA.
 850          * But we check only for TimeOuts. Bad AL_PA will
 851          * caught by FM_interrupt handler.
 852          */
 853
 854         if ((status == OCM_TIMEOUT_OR_BAD_ALPA) && (!fi->g.port_discovery) && (!fi->g.perform_adisc)){
 855                 DPRINTK("Frame TimeOut on OX_ID = %x", (u_int)transaction_id);
 856
 857                 /* Is it a SCSI frame that is timing out ? Not a very good check...
 858                  */
 859                 if ((transmitted_ox_id <= MAX_SCSI_OXID) && ((tag == FC_SCSI_BAD_TARGET) || (tag < 0x00FF0000))) {
 860                         /* If it is a Bad AL_PA, we report it as BAD_TARGET.
 861                          * Else, we allow the command to time-out. A Link
 862                          * re-initialization could be taking place.
 863                          */
 864                         if (tag == FC_SCSI_BAD_TARGET) {
 865                                 Cmnd = hostdata->cmnd_handler[transmitted_ox_id & MAX_SCSI_XID];
 866                                 hostdata->cmnd_handler[transmitted_ox_id & MAX_SCSI_XID] = NULL;
 867                                 if (Cmnd != NULL) {
 868                                         Cmnd->result = DID_BAD_TARGET << 16;
 869                                         (*Cmnd->scsi_done) (Cmnd);
 870                                 }
 871                                 else
 872                                         T_MSG("NULL Command out of handler!");
 873                         } /* if Bad Target */
 874                         else {
 875                         u_char missing_target = tag >> 16;
 876                         struct fc_node_info *q = fi->node_info_list;
 877                                 /* A Node that we thought was logged in has gone
 878                                  * away. We are the optimistic kind and we keep
 879                                  * hoping that our dear little Target will come back
 880                                  * to us. For now we log him out.
 881                                  */
 882                                 DPRINTK2("Missing Target = %d", missing_target);
 883                                 while (q != NULL) {
 884                                         if (q->target_id == missing_target) {
 885                                                 T_MSG("Target %d Logged out", q->target_id);
 886                                                 q->login = LOGIN_ATTEMPTED;
 887                                                 if (fi->num_nodes > 0)
 888                                                         fi->num_nodes--;
 889                                                 tx_logi(fi, ELS_PLOGI, q->d_id);
 890                                                 break;
 891                                         }
 892                                         else
 893                                                 q = q->next;
 894                                 }
 895                         }
 896                 } /* End of SCSI frame timing out. */
 897                 else {
 898                         if (seq_count > 1) {
 899                                 /* An IP frame was transmitted to a Bad AL_PA. Free up
 900                                  * the skb used.
 901                                  */
 902                                 dev_kfree_skb_irq((struct sk_buff *)(bus_to_virt(transaction_id)));
 903                                 netif_wake_queue(fi->dev);
 904                         }
 905                 } /* End of IP frame timing out. */
 906         } /* End of frame timing out. */
 907         else {
 908                 /* Frame was transmitted successfully. Check if it was an ELS
 909                  * frame or an IP frame or a Bad_Target_Notification frame (in
 910                  * case of a ptp_link). Ugly!
 911                  */
 912                 if ((status == 0) && (seq_count == 0)) {
 913                 u_int tag = transaction_id & 0xFFFF0000;
 914                 /* Continue with port discovery after an ELS is successfully
 915                  * transmitted. (status == 0).
 916                  */
 917                         DPRINTK("tag = %x", tag);
 918                         switch(tag) {
 919                                 case ELS_FLOGI:
 920                                         /* Letz use the Name Server instead */
 921                                         fi->g.explore_fabric = TRUE;
 922                                         fi->g.port_discovery = FALSE;
 923                                         fi->g.alpa_list_index = MAX_NODES;
 924                                         add_to_ox_id_list(fi, transaction_id, tag);
 925                                         break;
 926                                 case ELS_PLOGI:
 927                                         if (fi->g.fabric_present && (fi->g.name_server == FALSE))
 928                                                 add_to_ox_id_list(fi,transaction_id,ELS_NS_PLOGI);
 929                                         else
 930                                                 add_to_ox_id_list(fi, transaction_id, tag);
 931                                         break;
 932                                 case FC_SCSI_BAD_TARGET:
 933                                         Cmnd = hostdata->cmnd_handler[transmitted_ox_id & MAX_SCSI_XID];
 934                                         hostdata->cmnd_handler[transmitted_ox_id & MAX_SCSI_XID] = NULL;
 935                                         if (Cmnd != NULL) {
 936                                                 Cmnd->result = DID_BAD_TARGET << 16;
 937                                                 (*Cmnd->scsi_done) (Cmnd);
 938                                         }
 939                                         else
 940                                                 T_MSG("NULL Command out of handler!");
 941                                         break;
 942                                 default:
 943                                         add_to_ox_id_list(fi, transaction_id, tag);
 944                         }
 945
 946                         if (fi->g.alpa_list_index >= MAX_NODES) {
 947                                 if (fi->g.port_discovery == TRUE) {
 948                                         fi->g.port_discovery = FALSE;
 949                                         add_display_cache_timer(fi);
 950                                 }
 951                                 fi->g.alpa_list_index = MAX_NODES;
 952                         }
 953                         if (fi->g.port_discovery == TRUE)
 954                                 local_port_discovery(fi);
 955                 }
 956                 else {
 957                         /* An IP frame has been successfully transmitted.
 958                          * Free the skb that was used for this IP frame.
 959                          */
 960                         if ((status == 0) && (seq_count > 1)) {
 961                                 dev_kfree_skb_irq((struct sk_buff *)(bus_to_virt(transaction_id)));
 962                                 netif_wake_queue(fi->dev);
 963                         }
 964                 }
 965         }
 966         LEAVE("handle_OCI_interrupt");
 967 }
 968
 969 /* Right now we discard OOO frames */
 970 static void handle_OOO_interrupt(struct fc_info *fi)
 971 {
 972 u_int *ptr_imq_entry;
 973 int queue_indx, offset, payload_size;
 974 int no_of_buffers = 1; /* header is in a separate buffer */
 975         ptr_imq_entry = fi->q.ptr_imqe[fi->q.imq_cons_indx];
 976         offset = ntohl(*(ptr_imq_entry + 1)) & 0x00000007;
 977         queue_indx = ntohl(*(ptr_imq_entry + 1)) & 0xFFFF0000;
 978         queue_indx = queue_indx >> 16;
 979         payload_size = ntohl(*(ptr_imq_entry + 2)) - TACHYON_HEADER_LEN;
 980         /* Calculate total number of buffers */
 981         no_of_buffers += payload_size / MFS_BUFFER_SIZE;
 982         if (payload_size % MFS_BUFFER_SIZE)
 983                 no_of_buffers++;
 984
 985         /* provide Tachyon will another set of buffers */
 986         fi->g.mfs_buffer_count += no_of_buffers;
 987         if (fi->g.mfs_buffer_count >= NO_OF_ENTRIES) {
 988         int count = fi->g.mfs_buffer_count / NO_OF_ENTRIES;
 989                 fi->g.mfs_buffer_count -= NO_OF_ENTRIES * count;
 990                 update_MFSBQ_indx(fi, count);
 991         }
 992 }
 993
 994 static void handle_MFS_interrupt(struct fc_info *fi)
 995 {
 996 u_int *ptr_imq_entry, *buff_addr;
 997 u_int type_of_frame, s_id;
 998 int queue_indx, offset, payload_size, starting_indx, starting_offset;
 999 u_short received_ox_id;
1000 int no_of_buffers = 1; /* header is in a separate buffer */
1001 struct sk_buff *skb;
1002 int wrap_around = FALSE, no_of_wrap_buffs = NO_OF_ENTRIES - 1;
1003         ENTER("handle_MFS_interrupt");
1004         ptr_imq_entry = fi->q.ptr_imqe[fi->q.imq_cons_indx];
1005         offset = ntohl(*(ptr_imq_entry + 1)) & 0x00000007;
1006         queue_indx = ntohl(*(ptr_imq_entry + 1)) & 0xFFFF0000;
1007         queue_indx = queue_indx >> 16;
1008         DPRINTK("queue_indx = %d, offset  = %d\n", queue_indx, offset);
1009         payload_size = ntohl(*(ptr_imq_entry + 2)) - TACHYON_HEADER_LEN;
1010         DPRINTK("payload_size = %d", payload_size);
1011         /* Calculate total number of buffers */
1012         no_of_buffers += payload_size / MFS_BUFFER_SIZE;
1013         if (payload_size % MFS_BUFFER_SIZE)
1014                 no_of_buffers++;
1015         DPRINTK("no_of_buffers = %d", no_of_buffers);
1016
1017         if ((no_of_buffers - 1) <= offset) {
1018                 starting_offset = offset - (no_of_buffers - 1);
1019                 starting_indx = queue_indx;
1020         }
1021         else {
1022         int temp = no_of_buffers - (offset + 1);
1023         int no_of_queues = temp / NO_OF_ENTRIES;
1024                 starting_offset = temp % NO_OF_ENTRIES;
1025                 if (starting_offset != 0) {
1026                         no_of_wrap_buffs = starting_offset - 1; //exclude header
1027                         starting_offset = NO_OF_ENTRIES - starting_offset;
1028                         no_of_queues++;
1029                 }
1030                 starting_indx = queue_indx - no_of_queues;
1031                 if (starting_indx < 0) {
1032                         no_of_wrap_buffs -= (starting_indx + 1) * NO_OF_ENTRIES;
1033                         starting_indx = MFSBQ_LENGTH + starting_indx;
1034                         wrap_around = TRUE;
1035                 }
1036         }
1037
1038         DPRINTK("starting_indx = %d, starting offset = %d no_of_wrap_buffs = %d\n", starting_indx, starting_offset, no_of_wrap_buffs);
1039         /* Get Tachyon Header from first buffer */
1040         buff_addr = bus_to_virt(ntohl(*(fi->q.ptr_mfsbq_base + starting_indx*NO_OF_ENTRIES + starting_offset)));
1041
1042
1043         /* extract Type of Frame */
1044         type_of_frame = (u_int)ntohl(*(buff_addr + 4)) & 0xFF000000;
1045         s_id = (u_int)ntohl(*(buff_addr + 3)) & 0x00FFFFFF;
1046         received_ox_id = ntohl(*(buff_addr + 6)) >> 16;
1047         buff_addr += MFS_BUFFER_SIZE/4;
1048         DPRINTK("type_of_frame = %x, s_id = %x, ox_id = %x", type_of_frame, s_id, received_ox_id);
1049
1050         switch(type_of_frame) {
1051           case TYPE_LLC_SNAP:
1052                 skb = dev_alloc_skb(payload_size);
1053                 if (skb == NULL) {
1054                         printk(KERN_NOTICE "%s: In handle_MFS_interrupt() Memory squeeze, dropping packet.\n", fi->name);
1055                         fi->fc_stats.rx_dropped++;
1056                         fi->g.mfs_buffer_count += no_of_buffers;
1057                         if (fi->g.mfs_buffer_count >= NO_OF_ENTRIES) {
1058                                 int count = fi->g.mfs_buffer_count / NO_OF_ENTRIES;
1059                                 fi->g.mfs_buffer_count -= NO_OF_ENTRIES * count;
1060                                 update_MFSBQ_indx(fi, count);
1061                         }
1062                         return;
1063                 }
1064                 if (wrap_around) {
1065                 int wrap_size = no_of_wrap_buffs * MFS_BUFFER_SIZE;
1066                 int tail_size = payload_size - wrap_size;
1067                         DPRINTK("wrap_size = %d, tail_size = %d\n", wrap_size, tail_size);
1068                         if (no_of_wrap_buffs)
1069                                 memcpy(skb_put(skb, wrap_size), buff_addr, wrap_size);
1070                         buff_addr = bus_to_virt(ntohl(*(fi->q.ptr_mfsbq_base)));
1071                         memcpy(skb_put(skb, tail_size), buff_addr, tail_size);
1072                 }
1073                 else
1074                         memcpy(skb_put(skb, payload_size), buff_addr, payload_size);
1075                 rx_net_mfs_packet(fi, skb);
1076                 break;
1077         default:
1078                 T_MSG("Unknown Frame Type received. Type = %x", type_of_frame);
1079         }
1080
1081         /* provide Tachyon will another set of buffers */
1082         fi->g.mfs_buffer_count += no_of_buffers;
1083         if (fi->g.mfs_buffer_count >= NO_OF_ENTRIES) {
1084         int count = fi->g.mfs_buffer_count / NO_OF_ENTRIES;
1085                 fi->g.mfs_buffer_count -= NO_OF_ENTRIES * count;
1086                 update_MFSBQ_indx(fi, count);
1087         }
1088         LEAVE("handle_MFS_interrupt");
1089 }
1090
1091 static void handle_Unknown_Frame_interrupt(struct fc_info *fi)
1092 {
1093 u_int *ptr_imq_entry;
1094 int queue_indx, offset;
1095         ENTER("handle_Unknown_Frame_interrupt");
1096         ptr_imq_entry = fi->q.ptr_imqe[fi->q.imq_cons_indx];
1097         offset = ntohl(*(ptr_imq_entry + 1)) & 0x00000007;
1098         queue_indx = ntohl(*(ptr_imq_entry + 1)) & 0xFFFF0000;
1099         queue_indx = queue_indx >> 16;
1100         /* We discard the "unknown" frame */
1101         /* provide Tachyon will another set of buffers */
1102         if (offset == (NO_OF_ENTRIES - 1))
1103                 update_SFSBQ_indx(fi);
1104         LEAVE("handle_Unknown_Frame_interrupt");
1105 }
1106
1107 static void handle_Busied_Frame_interrupt(struct fc_info *fi)
1108 {
1109 u_int *ptr_imq_entry;
1110 int queue_indx, offset;
1111         ENTER("handle_Busied_Frame_interrupt");
1112         ptr_imq_entry = fi->q.ptr_imqe[fi->q.imq_cons_indx];
1113         offset = ntohl(*(ptr_imq_entry + 1)) & 0x00000007;
1114         queue_indx = ntohl(*(ptr_imq_entry + 1)) & 0xFFFF0000;
1115         queue_indx = queue_indx >> 16;
1116         /* We discard the "busied" frame */
1117         /* provide Tachyon will another set of buffers */
1118         if (offset == (NO_OF_ENTRIES - 1))
1119                 update_SFSBQ_indx(fi);
1120         LEAVE("handle_Busied_Frame_interrupt");
1121 }
1122
1123 static void handle_Bad_SCSI_Frame_interrupt(struct fc_info *fi)
1124 {
1125 u_int *ptr_imq_entry, *buff_addr, *tach_header, *ptr_edb;
1126 u_int s_id, rctl, frame_class, burst_len, transfered_len, len = 0;
1127 int queue_indx, offset, payload_size, i;
1128 u_short ox_id, rx_id, x_id, mtu = 512;
1129 u_char target_id = 0xFF;
1130
1131         ENTER("handle_Bad_SCSI_Frame_interrupt");
1132         ptr_imq_entry = fi->q.ptr_imqe[fi->q.imq_cons_indx];
1133         offset = ntohl(*(ptr_imq_entry + 1)) & 0x00000007;
1134         queue_indx = ntohl(*(ptr_imq_entry + 1)) & 0xFFFF0000;
1135         queue_indx = queue_indx >> 16;
1136         payload_size = ntohl(*(ptr_imq_entry + 2));
1137
1138         buff_addr = bus_to_virt(ntohl(*(fi->q.ptr_sfsbq_base + queue_indx*NO_OF_ENTRIES + offset)));
1139
1140         rctl = ntohl(*(buff_addr + 2)) & 0xFF000000;
1141         s_id = ntohl(*(buff_addr + 3)) & 0x00FFFFFF;
1142         ox_id = ntohl(*(buff_addr + 6)) >> 16;
1143         rx_id = ntohl(*(buff_addr + 6));
1144         x_id = ox_id & MAX_SCSI_XID;
1145
1146         /* Any frame that comes in with OX_ID that matches an OX_ID
1147          * that has been allocated for SCSI, will be called a Bad
1148          * SCSI frame if the Exchange is not valid any more.
1149          *
1150          * We will also get a Bad SCSI frame interrupt if we receive
1151          * a XFER_RDY with offset != 0. Tachyon washes its hands off
1152          * this Exchange. We have to take care of ourselves. Grrr...
1153          */
1154         if (rctl == DATA_DESCRIPTOR) {
1155         struct fc_node_info *q = fi->node_info_list;
1156                 while (q != NULL) {
1157                         if (q->d_id == s_id) {
1158                                 target_id = q->target_id;
1159                                 mtu = q->mtu;
1160                                 break;
1161                         }
1162                         else
1163                                 q = q->next;
1164                 }
1165                 frame_class = target_id;
1166                 transfered_len = ntohl(*(buff_addr + 8));
1167                 burst_len = ntohl(*(buff_addr + 9));
1168
1169                 build_ODB(fi, fi->g.seq_id, s_id, burst_len, 0, mtu, ox_id, rx_id, 0, 0, frame_class << 16);
1170                 /* Update the SEQ_ID and Relative Offset in the
1171                  * Tachyon Header Structure.
1172                  */
1173                 tach_header = bus_to_virt(ntohl(*(fi->q.ptr_sest[x_id] + 5)));
1174                 *(tach_header + 5) = htonl(fi->g.seq_id << 24);
1175                 *(tach_header + 7) = htonl(transfered_len);
1176                 fi->g.odb.hdr_addr = *(fi->q.ptr_sest[x_id] + 5);
1177
1178                 /* Invalidate the EDBs used
1179                  */
1180                 ptr_edb = bus_to_virt(ntohl(*(fi->q.ptr_sest[x_id] + 7)));
1181
1182                 for (i = 0; i < EDB_LEN; i++)
1183                         if (fi->q.ptr_edb[i] == ptr_edb)
1184                                 break;
1185                 ptr_edb--;
1186
1187                 if (i < EDB_LEN) {
1188                 int j;
1189                         do {
1190                                 ptr_edb += 2;
1191                                 len += (htonl(*ptr_edb) & 0xFFFF);
1192                                 j = i;
1193                                 fi->q.free_edb_list[i++] = EDB_FREE;
1194                                 if (i == EDB_LEN) {
1195                                         i = 0;
1196                                         ptr_edb = fi->q.ptr_edb_base - 1;
1197                                 }
1198                         } while (len < transfered_len);
1199                         if (len > transfered_len) {
1200                                 ptr_edb--;
1201                                 fi->q.free_edb_list[j] = EDB_BUSY;
1202                         }
1203                         else
1204                                 ptr_edb++;
1205                 }
1206                 else {
1207                         T_MSG("EDB not found while freeing");
1208                         if (offset == (NO_OF_ENTRIES - 1))
1209                                 update_SFSBQ_indx(fi);
1210                         return;
1211                 }
1212
1213                 /* Update the EDB pointer in the ODB.
1214                  */
1215                 fi->g.odb.edb_addr = htonl(virt_to_bus(ptr_edb));
1216                 memcpy(fi->q.ptr_odb[fi->q.ocq_prod_indx], &(fi->g.odb), sizeof(ODB));
1217                 /* Update the EDB pointer in the SEST entry. We might need
1218                  * this if get another XFER_RDY for the same Exchange.
1219                  */
1220                 *(fi->q.ptr_sest[x_id] + 7) = htonl(virt_to_bus(ptr_edb));
1221
1222                 update_OCQ_indx(fi);
1223                 if (fi->g.seq_id == MAX_SEQ_ID)
1224                         fi->g.seq_id = 0;
1225                 else
1226                         fi->g.seq_id++;
1227         }
1228         else
1229         /* Could be a BA_ACC or a BA_RJT.
1230          */
1231         if (rctl == RCTL_BASIC_ACC) {
1232         u_int bls_type = remove_from_ox_id_list(fi, ox_id);
1233                 DPRINTK1("BA_ACC received from S_ID 0x%x with OX_ID = %x in response to %x", s_id, ox_id, bls_type);
1234                 if (bls_type == RCTL_BASIC_ABTS) {
1235                 u_int STE_bit;
1236                         /* Invalidate resources for that Exchange.
1237                          */
1238                         STE_bit = ntohl(*fi->q.ptr_sest[x_id]);
1239                         if (STE_bit & SEST_V) {
1240                                 *(fi->q.ptr_sest[x_id]) &= htonl(SEST_INV);
1241                                 invalidate_SEST_entry(fi, ox_id);
1242                         }
1243                 }
1244         }
1245         else
1246         if (rctl == RCTL_BASIC_RJT) {
1247         u_int bls_type = remove_from_ox_id_list(fi, ox_id);
1248                 DPRINTK1("BA_RJT received from S_ID 0x%x with OX_ID = %x in response to %x", s_id, ox_id, bls_type);
1249                 if (bls_type == RCTL_BASIC_ABTS) {
1250                 u_int STE_bit;
1251                         /* Invalidate resources for that Exchange.
1252                          */
1253                         STE_bit = ntohl(*fi->q.ptr_sest[x_id]);
1254                         if (STE_bit & SEST_V) {
1255                                 *(fi->q.ptr_sest[x_id]) &= htonl(SEST_INV);
1256                                 invalidate_SEST_entry(fi, ox_id);
1257                         }
1258                 }
1259         }
1260         else
1261                 DPRINTK1("Frame with R_CTL = %x received from S_ID 0x%x with OX_ID %x", rctl, s_id, ox_id);
1262
1263         /* Else, discard the "Bad" SCSI frame.
1264          */
1265
1266         /* provide Tachyon will another set of buffers
1267          */
1268         if (offset == (NO_OF_ENTRIES - 1))
1269                 update_SFSBQ_indx(fi);
1270         LEAVE("handle_Bad_SCSI_Frame_interrupt");
1271 }
1272
1273 static void handle_Inbound_SCSI_Status_interrupt(struct fc_info *fi)
1274 {
1275 struct Scsi_Host *host = fi->host;
1276 struct iph5526_hostdata *hostdata = (struct iph5526_hostdata *)host->hostdata;
1277 u_int *ptr_imq_entry, *buff_addr, *ptr_rsp_info, *ptr_sense_info = NULL;
1278 int queue_indx, offset, payload_size;
1279 u_short received_ox_id, x_id;
1280 Scsi_Cmnd *Cmnd;
1281 u_int fcp_status, fcp_rsp_info_len = 0, fcp_sense_info_len = 0, s_id;
1282         ENTER("handle_SCSI_status_interrupt");
1283
1284         ptr_imq_entry = fi->q.ptr_imqe[fi->q.imq_cons_indx];
1285         offset = ntohl(*(ptr_imq_entry + 1)) & 0x00000007;
1286         queue_indx = ntohl(*(ptr_imq_entry + 1)) & 0xFFFF0000;
1287         queue_indx = queue_indx >> 16;
1288         buff_addr = bus_to_virt(ntohl(*(fi->q.ptr_sfsbq_base + queue_indx*NO_OF_ENTRIES + offset)));
1289         payload_size = ntohl(*(ptr_imq_entry + 2));
1290         received_ox_id = ntohl(*(buff_addr + 6)) >> 16;
1291
1292         buff_addr = bus_to_virt(ntohl(*(fi->q.ptr_sfsbq_base + queue_indx*NO_OF_ENTRIES + offset)));
1293
1294         fcp_status = ntohl(*(buff_addr + 10));
1295         ptr_rsp_info = buff_addr + 14;
1296         if (fcp_status & FCP_STATUS_RSP_LEN)
1297                 fcp_rsp_info_len = ntohl(*(buff_addr + 13));
1298
1299         if (fcp_status & FCP_STATUS_SENSE_LEN) {
1300                 ptr_sense_info = ptr_rsp_info + fcp_rsp_info_len / 4;
1301                 fcp_sense_info_len = ntohl(*(buff_addr + 12));
1302                 DPRINTK("sense_info = %x", (u_int)ntohl(*ptr_sense_info));
1303         }
1304         DPRINTK("fcp_status = %x, fcp_rsp_len = %x", fcp_status, fcp_rsp_info_len);
1305         x_id = received_ox_id & MAX_SCSI_XID;
1306         Cmnd = hostdata->cmnd_handler[x_id];
1307         hostdata->cmnd_handler[x_id] = NULL;
1308         if (Cmnd != NULL) {
1309                 memset(Cmnd->sense_buffer, 0, sizeof(Cmnd->sense_buffer));
1310                 /* Check if there is a Sense field */
1311                 if (fcp_status & FCP_STATUS_SENSE_LEN) {
1312                 int size = sizeof(Cmnd->sense_buffer);
1313                         if (fcp_sense_info_len < size)
1314                                 size = fcp_sense_info_len;
1315                         memcpy(Cmnd->sense_buffer, (char *)ptr_sense_info, size);
1316                 }
1317                 Cmnd->result = fcp_status & FCP_STATUS_MASK;
1318                 (*Cmnd->scsi_done) (Cmnd);
1319         }
1320         else
1321                 T_MSG("NULL Command out of handler!");
1322
1323         invalidate_SEST_entry(fi, received_ox_id);
1324         s_id = ntohl(*(buff_addr + 3)) & 0x00FFFFFF;
1325         fi->q.free_scsi_oxid[x_id] = OXID_AVAILABLE;
1326
1327         /* provide Tachyon will another set of buffers */
1328         if (offset == (NO_OF_ENTRIES - 1))
1329                 update_SFSBQ_indx(fi);
1330         LEAVE("handle_SCSI_status_interrupt");
1331 }
1332
1333 static void invalidate_SEST_entry(struct fc_info *fi, u_short received_ox_id)
1334 {
1335 u_short x_id = received_ox_id & MAX_SCSI_XID;
1336         /* Invalidate SEST entry if it is an OutBound SEST Entry
1337          */
1338         if (!(received_ox_id & SCSI_READ_BIT)) {
1339         u_int *ptr_tach_header, *ptr_edb;
1340         u_short temp_ox_id = NOT_SCSI_XID;
1341         int i;
1342                 *(fi->q.ptr_sest[x_id]) &= htonl(SEST_INV);
1343
1344                 /* Invalidate the Tachyon Header structure
1345                  */
1346                 ptr_tach_header = bus_to_virt(ntohl(*(fi->q.ptr_sest[x_id] + 5)));
1347                 for (i = 0; i < NO_OF_TACH_HEADERS; i++)
1348                         if(fi->q.ptr_tachyon_header[i] == ptr_tach_header)
1349                                 break;
1350                 if (i < NO_OF_TACH_HEADERS)
1351                         memset(ptr_tach_header, 0xFF, 32);
1352                 else
1353                         T_MSG("Tachyon Header not found while freeing in invalidate_SEST_entry()");
1354
1355                 /* Invalidate the EDB used
1356                  */
1357                 ptr_edb = bus_to_virt(ntohl(*(fi->q.ptr_sest[x_id] + 7)));
1358                 for (i = 0; i < EDB_LEN; i++)
1359                         if (fi->q.ptr_edb[i] == ptr_edb)
1360                                 break;
1361                 ptr_edb--;
1362                 if (i < EDB_LEN) {
1363                         do {
1364                                 ptr_edb += 2;
1365                                 fi->q.free_edb_list[i++] = EDB_FREE;
1366                                 if (i == EDB_LEN) {
1367                                         i = 0;
1368                                         ptr_edb = fi->q.ptr_edb_base - 1;
1369                                 }
1370                         } while ((htonl(*ptr_edb) & 0x80000000) != 0x80000000);
1371                 }
1372                 else
1373                         T_MSG("EDB not found while freeing in invalidate_SEST_entry()");
1374
1375                 /* Search for its other header structure and destroy it!
1376                  */
1377                 if ((ptr_tach_header + 16) < (fi->q.ptr_tachyon_header_base + (MY_PAGE_SIZE/4)))
1378                         ptr_tach_header += 16;
1379                 else
1380                         ptr_tach_header = fi->q.ptr_tachyon_header_base;
1381                 while (temp_ox_id != x_id) {
1382                         temp_ox_id = ntohl(*(ptr_tach_header + 6)) >> 16;
1383                         if (temp_ox_id == x_id) {
1384                                 /* Paranoid checking...
1385                                  */
1386                                 for (i = 0; i < NO_OF_TACH_HEADERS; i++)
1387                                         if(fi->q.ptr_tachyon_header[i] == ptr_tach_header)
1388                                                 break;
1389                                 if (i < NO_OF_TACH_HEADERS)
1390                                         memset(ptr_tach_header, 0xFF, 32);
1391                                 else
1392                                         T_MSG("Tachyon Header not found while freeing in invalidate_SEST_entry()");
1393                                 break;
1394                         }
1395                         else {
1396                                 if ((ptr_tach_header + 16) < (fi->q.ptr_tachyon_header_base + (MY_PAGE_SIZE/4)))
1397                                         ptr_tach_header += 16;
1398                                 else
1399                                         ptr_tach_header = fi->q.ptr_tachyon_header_base;
1400                         }
1401                 }
1402         }
1403         else {
1404         u_short sdb_table_indx;
1405                 /* An Inbound Command has completed or needs to be Aborted.
1406                  * Clear up the SDB buffers.
1407                  */
1408                 sdb_table_indx = *(fi->q.ptr_sest[x_id] + 5);
1409                 fi->q.sdb_slot_status[sdb_table_indx] = SDB_FREE;
1410         }
1411 }
1412
1413 static void handle_Inbound_SCSI_Command_interrupt(struct fc_info *fi)
1414 {
1415 u_int *ptr_imq_entry;
1416 int queue_indx, offset;
1417         ENTER("handle_Inbound_SCSI_Command_interrupt");
1418         ptr_imq_entry = fi->q.ptr_imqe[fi->q.imq_cons_indx];
1419         offset = ntohl(*(ptr_imq_entry + 1)) & 0x00000007;
1420         queue_indx = ntohl(*(ptr_imq_entry + 1)) & 0xFFFF0000;
1421         queue_indx = queue_indx >> 16;
1422         /* We discard the SCSI frame as we shouldn't be receiving
1423          * a SCSI Command in the first place
1424          */
1425         /* provide Tachyon will another set of buffers */
1426         if (offset == (NO_OF_ENTRIES - 1))
1427                 update_SFSBQ_indx(fi);
1428         LEAVE("handle_Inbound_SCSI_Command_interrupt");
1429 }
1430
1431 static void handle_SFS_interrupt(struct fc_info *fi)
1432 {
1433 u_int *ptr_imq_entry, *buff_addr;
1434 u_int class_of_frame, type_of_frame, s_id, els_type = 0, rctl;
1435 int queue_indx, offset, payload_size, login_state;
1436 u_short received_ox_id, fs_cmnd_code;
1437         ENTER("handle_SFS_interrupt");
1438         ptr_imq_entry = fi->q.ptr_imqe[fi->q.imq_cons_indx];
1439         offset = ntohl(*(ptr_imq_entry + 1)) & 0x00000007;
1440         queue_indx = ntohl(*(ptr_imq_entry + 1)) & 0xFFFF0000;
1441         queue_indx = queue_indx >> 16;
1442         DPRINTK("queue_indx = %d, offset  = %d\n", queue_indx, offset);
1443         payload_size = ntohl(*(ptr_imq_entry + 2));
1444         DPRINTK("payload_size = %d", payload_size);
1445
1446         buff_addr = bus_to_virt(ntohl(*(fi->q.ptr_sfsbq_base + queue_indx*NO_OF_ENTRIES + offset)));
1447
1448         /* extract Type of Frame */
1449         type_of_frame = ntohl(*(buff_addr + 4)) & 0xFF000000;
1450         s_id = ntohl(*(buff_addr + 3)) & 0x00FFFFFF;
1451         received_ox_id = ntohl(*(buff_addr + 6)) >> 16;
1452         switch(type_of_frame) {
1453                 case TYPE_BLS:
1454                         rctl = ntohl(*(buff_addr + 2)) & 0xFF000000;
1455                         switch(rctl) {
1456                                 case RCTL_BASIC_ABTS:
1457                                         /* As an Initiator, we should never be receiving
1458                                          * this.
1459                                          */
1460                                         DPRINTK1("ABTS received from S_ID 0x%x with OX_ID = %x", s_id, received_ox_id);
1461                                         break;
1462                         }
1463                         break;
1464                 case TYPE_ELS:
1465                         class_of_frame = ntohl(*(buff_addr + 8));
1466                         login_state = sid_logged_in(fi, s_id);
1467                         switch(class_of_frame & 0xFF000000) {
1468                                 case ELS_PLOGI:
1469                                         if (s_id != fi->g.my_id) {
1470                                                 u_int ret_code;
1471                                                 DPRINTK1("PLOGI received from D_ID 0x%x with 0X_ID = %x", s_id, received_ox_id);
1472                                                 if ((ret_code = plogi_ok(fi, buff_addr, payload_size)) == 0){
1473                                                         tx_logi_acc(fi, ELS_ACC, s_id, received_ox_id);
1474                                                         add_to_address_cache(fi, buff_addr);
1475                                                 }
1476                                                 else {
1477                                                         u_short cmnd_code = ret_code >> 16;
1478                                                         u_short expln_code =  ret_code;
1479                                                         tx_ls_rjt(fi, s_id, received_ox_id, cmnd_code, expln_code);
1480                                                 }
1481                                         }
1482                                         break;
1483                                 case ELS_ACC:
1484                                         els_type = remove_from_ox_id_list(fi, received_ox_id);
1485                                         DPRINTK1("ELS_ACC received from D_ID 0x%x in response to ELS %x", s_id, els_type);
1486                                         switch(els_type) {
1487                                                 case ELS_PLOGI:
1488                                                         add_to_address_cache(fi, buff_addr);
1489                                                         tx_prli(fi, ELS_PRLI, s_id, OX_ID_FIRST_SEQUENCE);
1490                                                         break;
1491                                                 case ELS_FLOGI:
1492                                                         add_to_address_cache(fi, buff_addr);
1493                                                         fi->g.my_id = ntohl(*(buff_addr + 2)) & 0x00FFFFFF;
1494                                                         fi->g.fabric_present = TRUE;
1495                                                         fi->g.my_ddaa = fi->g.my_id & 0xFFFF00;
1496                                                         /* Login to the Name Server
1497                                                          */
1498                                                         tx_logi(fi, ELS_PLOGI, DIRECTORY_SERVER);
1499                                                         break;
1500                                                 case ELS_NS_PLOGI:
1501                                                         fi->g.name_server = TRUE;
1502                                                         add_to_address_cache(fi, buff_addr);
1503                                                         tx_name_server_req(fi, FCS_RFC_4);
1504                                                         tx_scr(fi);
1505                                                         /* Some devices have a delay before
1506                                                          * registering with the Name Server
1507                                                          */
1508                                                         udelay(500);
1509                                                         tx_name_server_req(fi, FCS_GP_ID4);
1510                                                         break;
1511                                                 case ELS_PRLI:
1512                                                         mark_scsi_sid(fi, buff_addr, ADD_ENTRY);
1513                                                         break;
1514                                                 case ELS_ADISC:
1515                                                         if (!(validate_login(fi, buff_addr)))
1516                                                                 tx_logo(fi, s_id, OX_ID_FIRST_SEQUENCE);
1517                                                         break;
1518                                         }
1519                                         break;
1520                                 case ELS_PDISC:
1521                                         DPRINTK1("ELS_PDISC received from D_ID 0x%x", s_id);
1522                                         tx_logo(fi, s_id, received_ox_id);
1523                                         break;
1524                                 case ELS_ADISC:
1525                                         DPRINTK1("ELS_ADISC received from D_ID 0x%x", s_id);
1526                                         if (node_logged_in_prev(fi, buff_addr))
1527                                                 tx_adisc(fi, ELS_ACC, s_id, received_ox_id);
1528                                         else
1529                                                 tx_logo(fi, s_id, received_ox_id);
1530                                         break;
1531                                 case ELS_PRLI:
1532                                         DPRINTK1("ELS_PRLI received from D_ID 0x%x", s_id);
1533                                         if ((login_state == NODE_LOGGED_IN) || (login_state == NODE_PROCESS_LOGGED_IN)) {
1534                                                 tx_prli(fi, ELS_ACC, s_id, received_ox_id);
1535                                                 mark_scsi_sid(fi, buff_addr, ADD_ENTRY);
1536                                         }
1537                                         else
1538                                                 tx_logo(fi, s_id, received_ox_id);
1539                                         break;
1540                                 case ELS_PRLO:
1541                                         DPRINTK1("ELS_PRLO received from D_ID 0x%x", s_id);
1542                                         if ((login_state == NODE_LOGGED_OUT) || (login_state == NODE_NOT_PRESENT))
1543                                                 tx_logo(fi, s_id, received_ox_id);
1544                                         else
1545                                         if (login_state == NODE_LOGGED_IN)
1546
1547                                                 tx_ls_rjt(fi, s_id, received_ox_id, CMND_NOT_SUPP, NO_EXPLN);
1548                                         else
1549                                         if (login_state == NODE_PROCESS_LOGGED_IN) {
1550                                                 tx_prli(fi, ELS_ACC, s_id, received_ox_id);
1551                                                 mark_scsi_sid(fi, buff_addr, DELETE_ENTRY);
1552                                         }
1553                                         break;
1554                                 case ELS_LS_RJT:
1555                                         els_type = remove_from_ox_id_list(fi, received_ox_id);
1556                                         DPRINTK1("ELS_LS_RJT received from D_ID 0x%x in response to %x", s_id, els_type);
1557                                         /* We should be chking the reason code.
1558                                          */
1559                                         switch (els_type) {
1560                                                 case ELS_ADISC:
1561                                                         tx_logi(fi, ELS_PLOGI, s_id);
1562                                                         break;
1563                                         }
1564                                         break;
1565                                 case ELS_LOGO:
1566                                         els_type = remove_from_ox_id_list(fi, received_ox_id);
1567                                         DPRINTK1("ELS_LOGO received from D_ID 0x%x in response to %x", s_id, els_type);
1568                                         remove_from_address_cache(fi, buff_addr, ELS_LOGO);
1569                                         tx_acc(fi, s_id, received_ox_id);
1570                                         if (els_type == ELS_ADISC)
1571                                                 tx_logi(fi, ELS_PLOGI, s_id);
1572                                         break;
1573                                 case ELS_RSCN:
1574                                         DPRINTK1("ELS_RSCN received from D_ID 0x%x", s_id);
1575                                         tx_acc(fi, s_id, received_ox_id);
1576                                         remove_from_address_cache(fi, buff_addr, ELS_RSCN);
1577                                         break;
1578                                 case ELS_FARP_REQ:
1579                                         /* We do not support FARP.
1580                                            So, silently discard it */
1581                                         DPRINTK1("ELS_FARP_REQ received from D_ID 0x%x", s_id);
1582                                         break;
1583                                 case ELS_ABTX:
1584                                         DPRINTK1("ELS_ABTX received from D_ID 0x%x", s_id);
1585                                         if ((login_state == NODE_LOGGED_IN) || (login_state == NODE_PROCESS_LOGGED_IN))
1586                                                 tx_ls_rjt(fi, s_id, received_ox_id, CMND_NOT_SUPP, NO_EXPLN);
1587                                         else
1588                                                 tx_logo(fi, s_id, received_ox_id);
1589                                         break;
1590                                 case ELS_FLOGI:
1591                                         DPRINTK1("ELS_FLOGI received from D_ID 0x%x", s_id);
1592                                         if (fi->g.ptp_up == TRUE) {
1593                                                 /* The node could have come up as an N_Port
1594                                                  * in a Loop! So,try initializing as an NL_port
1595                                                  */
1596                                                 take_tachyon_offline(fi);
1597                                                 /* write AL_TIME & E_D_TOV into the registers */
1598                                                 writel(TOV_VALUES, fi->t_r.ptr_fm_tov_reg);
1599                                                 writel(LOOP_INIT_SOFT_ADDRESS, fi->t_r.ptr_fm_config_reg);
1600                                                 DPRINTK1("FLOGI received, TACHYON initializing as L_Port...\n");
1601                                                 writel(INITIALIZE, fi->t_r.ptr_fm_control_reg);
1602                                         }
1603                                         else {
1604                                                 if ((login_state == NODE_LOGGED_IN) || (login_state == NODE_PROCESS_LOGGED_IN))
1605                                                         tx_ls_rjt(fi, s_id, received_ox_id, CMND_NOT_SUPP, NO_EXPLN);
1606                                                 else
1607                                                         tx_logo(fi, s_id, received_ox_id);
1608                                         }
1609                                         break;
1610                                 case ELS_ADVC:
1611                                         DPRINTK1("ELS_ADVC received from D_ID 0x%x", s_id);
1612                                         if ((login_state == NODE_LOGGED_IN) || (login_state == NODE_PROCESS_LOGGED_IN))
1613                                                 tx_ls_rjt(fi, s_id, received_ox_id, CMND_NOT_SUPP, NO_EXPLN);
1614                                         else
1615                                                 tx_logo(fi, s_id, received_ox_id);
1616                                         break;
1617                                 case ELS_ECHO:
1618                                         DPRINTK1("ELS_ECHO received from D_ID 0x%x", s_id);
1619                                         if ((login_state == NODE_LOGGED_IN) || (login_state == NODE_PROCESS_LOGGED_IN))
1620                                                 tx_ls_rjt(fi, s_id, received_ox_id, CMND_NOT_SUPP, NO_EXPLN);
1621                                         else
1622                                                 tx_logo(fi, s_id, received_ox_id);
1623                                         break;
1624                                 case ELS_ESTC:
1625                                         DPRINTK1("ELS_ESTC received from D_ID 0x%x", s_id);
1626                                         if ((login_state == NODE_LOGGED_IN) || (login_state == NODE_PROCESS_LOGGED_IN))
1627                                                 tx_ls_rjt(fi, s_id, received_ox_id, CMND_NOT_SUPP, NO_EXPLN);
1628                                         else
1629                                                 tx_logo(fi, s_id, received_ox_id);
1630                                         break;
1631                                 case ELS_ESTS:
1632                                         DPRINTK1("ELS_ESTS received from D_ID 0x%x", s_id);
1633                                         if ((login_state == NODE_LOGGED_IN) || (login_state == NODE_PROCESS_LOGGED_IN))
1634                                                 tx_ls_rjt(fi, s_id, received_ox_id, CMND_NOT_SUPP, NO_EXPLN);
1635                                         else
1636                                                 tx_logo(fi, s_id, received_ox_id);
1637                                         break;
1638                                 case ELS_RCS:
1639                                         DPRINTK1("ELS_RCS received from D_ID 0x%x", s_id);
1640                                         if ((login_state == NODE_LOGGED_IN) || (login_state == NODE_PROCESS_LOGGED_IN))
1641                                                 tx_ls_rjt(fi, s_id, received_ox_id, CMND_NOT_SUPP, NO_EXPLN);
1642                                         else
1643                                                 tx_logo(fi, s_id, received_ox_id);
1644                                         break;
1645                                 case ELS_RES:
1646                                         DPRINTK1("ELS_RES received from D_ID 0x%x", s_id);
1647                                         if ((login_state == NODE_LOGGED_IN) || (login_state == NODE_PROCESS_LOGGED_IN))
1648                                                 tx_ls_rjt(fi, s_id, received_ox_id, CMND_NOT_SUPP, NO_EXPLN);
1649                                         else
1650                                                 tx_logo(fi, s_id, received_ox_id);
1651                                         break;
1652                                 case ELS_RLS:
1653                                         DPRINTK1("ELS_RLS received from D_ID 0x%x", s_id);
1654                                         if ((login_state == NODE_LOGGED_IN) || (login_state == NODE_PROCESS_LOGGED_IN))
1655                                                 tx_ls_rjt(fi, s_id, received_ox_id, CMND_NOT_SUPP, NO_EXPLN);
1656                                         else
1657                                                 tx_logo(fi, s_id, received_ox_id);
1658                                         break;
1659                                 case ELS_RRQ:
1660                                         DPRINTK1("ELS_RRQ received from D_ID 0x%x", s_id);
1661                                         if ((login_state == NODE_LOGGED_IN) || (login_state == NODE_PROCESS_LOGGED_IN))
1662                                                 tx_ls_rjt(fi, s_id, received_ox_id, CMND_NOT_SUPP, NO_EXPLN);
1663                                         else
1664                                                 tx_logo(fi, s_id, received_ox_id);
1665                                         break;
1666                                 case ELS_RSS:
1667                                         DPRINTK1("ELS_RSS received from D_ID 0x%x", s_id);
1668                                         if ((login_state == NODE_LOGGED_IN) || (login_state == NODE_PROCESS_LOGGED_IN))
1669                                                 tx_ls_rjt(fi, s_id, received_ox_id, CMND_NOT_SUPP, NO_EXPLN);
1670                                         else
1671                                                 tx_logo(fi, s_id, received_ox_id);
1672                                         break;
1673                                 case ELS_RTV:
1674                                         DPRINTK1("ELS_RTV received from D_ID 0x%x", s_id);
1675                                         if ((login_state == NODE_LOGGED_IN) || (login_state == NODE_PROCESS_LOGGED_IN))
1676                                                 tx_ls_rjt(fi, s_id, received_ox_id, CMND_NOT_SUPP, NO_EXPLN);
1677                                         else
1678                                                 tx_logo(fi, s_id, received_ox_id);
1679                                         break;
1680                                 case ELS_RSI:
1681                                         DPRINTK1("ELS_RSI received from D_ID 0x%x", s_id);
1682                                         if ((login_state == NODE_LOGGED_IN) || (login_state == NODE_PROCESS_LOGGED_IN))
1683                                                 tx_ls_rjt(fi, s_id, received_ox_id, CMND_NOT_SUPP, NO_EXPLN);
1684                                         else
1685                                                 tx_logo(fi, s_id, received_ox_id);
1686                                         break;
1687                                 case ELS_TEST:
1688                                         /* No reply sequence */
1689                                         DPRINTK1("ELS_TEST received from D_ID 0x%x", s_id);
1690                                         break;
1691                                 case ELS_RNC:
1692                                         DPRINTK1("ELS_RNC received from D_ID 0x%x", s_id);
1693                                         if ((login_state == NODE_LOGGED_IN) || (login_state == NODE_PROCESS_LOGGED_IN))
1694                                                 tx_ls_rjt(fi, s_id, received_ox_id, CMND_NOT_SUPP, NO_EXPLN);
1695                                         else
1696                                                 tx_logo(fi, s_id, received_ox_id);
1697                                         break;
1698                                 case ELS_RVCS:
1699                                         DPRINTK1("ELS_RVCS received from D_ID 0x%x", s_id);
1700                                         if ((login_state == NODE_LOGGED_IN) || (login_state == NODE_PROCESS_LOGGED_IN))
1701                                                 tx_ls_rjt(fi, s_id, received_ox_id, CMND_NOT_SUPP, NO_EXPLN);
1702                                         else
1703                                                 tx_logo(fi, s_id, received_ox_id);
1704                                         break;
1705                                 case ELS_TPLS:
1706                                         DPRINTK1("ELS_TPLS received from D_ID 0x%x", s_id);
1707                                         if ((login_state == NODE_LOGGED_IN) || (login_state == NODE_PROCESS_LOGGED_IN))
1708                                                 tx_ls_rjt(fi, s_id, received_ox_id, CMND_NOT_SUPP, NO_EXPLN);
1709                                         else
1710                                                 tx_logo(fi, s_id, received_ox_id);
1711                                         break;
1712                                 case ELS_GAID:
1713                                         DPRINTK1("ELS_GAID received from D_ID 0x%x", s_id);
1714                                         if ((login_state == NODE_LOGGED_IN) || (login_state == NODE_PROCESS_LOGGED_IN))
1715                                                 tx_ls_rjt(fi, s_id, received_ox_id, CMND_NOT_SUPP, NO_EXPLN);
1716                                         else
1717                                                 tx_logo(fi, s_id, received_ox_id);
1718                                         break;
1719                                 case ELS_FACT:
1720                                         DPRINTK1("ELS_FACT received from D_ID 0x%x", s_id);
1721                                         if ((login_state == NODE_LOGGED_IN) || (login_state == NODE_PROCESS_LOGGED_IN))
1722                                                 tx_ls_rjt(fi, s_id, received_ox_id, CMND_NOT_SUPP, NO_EXPLN);
1723                                         else
1724                                                 tx_logo(fi, s_id, received_ox_id);
1725                                         break;
1726                                 case ELS_FAN:
1727                                         /* Hmmm... You don't support FAN ??? */
1728                                         DPRINTK1("ELS_FAN received from D_ID 0x%x", s_id);
1729                                         tx_ls_rjt(fi, s_id, received_ox_id, CMND_NOT_SUPP, NO_EXPLN);
1730                                         break;
1731                                 case ELS_FDACT:
1732                                         DPRINTK1("ELS_FDACT received from D_ID 0x%x", s_id);
1733                                         if ((login_state == NODE_LOGGED_IN) || (login_state == NODE_PROCESS_LOGGED_IN))
1734                                                 tx_ls_rjt(fi, s_id, received_ox_id, CMND_NOT_SUPP, NO_EXPLN);
1735                                         else
1736                                                 tx_logo(fi, s_id, received_ox_id);
1737                                         break;
1738                                 case ELS_NACT:
1739                                         DPRINTK1("ELS_NACT received from D_ID 0x%x", s_id);
1740                                         if ((login_state == NODE_LOGGED_IN) || (login_state == NODE_PROCESS_LOGGED_IN))
1741                                                 tx_ls_rjt(fi, s_id, received_ox_id, CMND_NOT_SUPP, NO_EXPLN);
1742                                         else
1743                                                 tx_logo(fi, s_id, received_ox_id);
1744                                         break;
1745                                 case ELS_NDACT:
1746                                         DPRINTK1("ELS_NDACT received from D_ID 0x%x", s_id);
1747                                         if ((login_state == NODE_LOGGED_IN) || (login_state == NODE_PROCESS_LOGGED_IN))
1748                                                 tx_ls_rjt(fi, s_id, received_ox_id, CMND_NOT_SUPP, NO_EXPLN);
1749                                         else
1750                                                 tx_logo(fi, s_id, received_ox_id);
1751                                         break;
1752                                 case ELS_QoSR:
1753                                         DPRINTK1("ELS_QoSR received from D_ID 0x%x", s_id);
1754                                         if ((login_state == NODE_LOGGED_IN) || (login_state == NODE_PROCESS_LOGGED_IN))
1755                                                 tx_ls_rjt(fi, s_id, received_ox_id, CMND_NOT_SUPP, NO_EXPLN);
1756                                         else
1757                                                 tx_logo(fi, s_id, received_ox_id);
1758                                         break;
1759                                 case ELS_FDISC:
1760                                         DPRINTK1("ELS_FDISC received from D_ID 0x%x", s_id);
1761                                         if ((login_state == NODE_LOGGED_IN) || (login_state == NODE_PROCESS_LOGGED_IN))
1762                                                 tx_ls_rjt(fi, s_id, received_ox_id, CMND_NOT_SUPP, NO_EXPLN);
1763                                         else
1764                                                 tx_logo(fi, s_id, received_ox_id);
1765                                         break;
1766                                 default:
1767                                         DPRINTK1("ELS Frame %x received from D_ID 0x%x", class_of_frame, s_id);
1768                                         if ((login_state == NODE_LOGGED_IN) || (login_state == NODE_PROCESS_LOGGED_IN))
1769                                                 tx_ls_rjt(fi, s_id, received_ox_id, CMND_NOT_SUPP, NO_EXPLN);
1770                                         else
1771                                                 tx_logo(fi, s_id, received_ox_id);
1772                                         break;
1773                         }
1774                         break;
1775                 case TYPE_FC_SERVICES:
1776                         fs_cmnd_code = (ntohl(*(buff_addr + 10)) & 0xFFFF0000) >>16;
1777                         switch(fs_cmnd_code) {
1778                                 case FCS_ACC:
1779                                         els_type = remove_from_ox_id_list(fi, received_ox_id);
1780                                         DPRINTK1("FCS_ACC received from D_ID 0x%x in response to %x", s_id, els_type);
1781                                         if (els_type == FCS_GP_ID4)
1782                                                 explore_fabric(fi, buff_addr);
1783                                         break;
1784                                 case FCS_REJECT:
1785                                         DPRINTK1("FCS_REJECT received from D_ID 0x%x in response to %x", s_id, els_type);
1786                                         break;
1787                         }
1788                         break;
1789                 case TYPE_LLC_SNAP:
1790                         rx_net_packet(fi, (u_char *)buff_addr, payload_size);
1791                         break;
1792                 default:
1793                         T_MSG("Frame Type %x received from %x", type_of_frame, s_id);
1794         }
1795
1796         /* provide Tachyon will another set of buffers */
1797         if (offset == (NO_OF_ENTRIES - 1))
1798                 update_SFSBQ_indx(fi);
1799         LEAVE("handle_SFS_interrupt");
1800 }
1801
1802 static void handle_FM_interrupt(struct fc_info *fi)
1803 {
1804 u_int fm_status;
1805 u_int tachyon_status;
1806
1807         ENTER("handle_FM_interrupt");
1808         fm_status = readl(fi->t_r.ptr_fm_status_reg);
1809         tachyon_status = readl(fi->t_r.ptr_tach_status_reg);
1810         DPRINTK("FM_status = %x, Tachyon_status = %x", fm_status, tachyon_status);
1811         if (fm_status & LINK_DOWN) {
1812                 T_MSG("Fibre Channel Link DOWN");
1813                 fm_status = readl(fi->t_r.ptr_fm_status_reg);
1814
1815                 del_timer(&fi->explore_timer);
1816                 del_timer(&fi->nport_timer);
1817                 del_timer(&fi->lport_timer);
1818                 del_timer(&fi->display_cache_timer);
1819                 fi->g.link_up = FALSE;
1820                 if (fi->g.ptp_up == TRUE)
1821                         fi->g.n_port_try = FALSE;
1822                 fi->g.ptp_up = FALSE;
1823                 fi->g.port_discovery = FALSE;
1824                 fi->g.explore_fabric = FALSE;
1825                 fi->g.perform_adisc = FALSE;
1826
1827                 /* Logout will all nodes */
1828                 if (fi->node_info_list) {
1829                         struct fc_node_info *temp_list = fi->node_info_list;
1830                                 while(temp_list) {
1831                                         temp_list->login = LOGIN_ATTEMPTED;
1832                                         temp_list = temp_list->next;
1833                                 }
1834                                 fi->num_nodes = 0;
1835                 }
1836
1837                 if ((fi->g.n_port_try == FALSE) && (fi->g.dont_init == FALSE)){
1838                         take_tachyon_offline(fi);
1839                         /* write AL_TIME & E_D_TOV into the registers */
1840                         writel(TOV_VALUES, fi->t_r.ptr_fm_tov_reg);
1841
1842                         if ((fi->g.fabric_present == TRUE) && (fi->g.loop_up == TRUE)) {
1843                         u_int al_pa = fi->g.my_id & 0xFF;
1844                                 writel((al_pa << 24) | LOOP_INIT_FABRIC_ADDRESS | LOOP_INIT_PREVIOUS_ADDRESS, fi->t_r.ptr_fm_config_reg);
1845                         }
1846                         else
1847                         if (fi->g.loop_up == TRUE) {
1848                         u_int al_pa = fi->g.my_id & 0xFF;
1849                                 writel((al_pa << 24) | LOOP_INIT_PREVIOUS_ADDRESS, fi->t_r.ptr_fm_config_reg);
1850                         }
1851                         else
1852                                 writel(LOOP_INIT_SOFT_ADDRESS, fi->t_r.ptr_fm_config_reg);
1853                         fi->g.loop_up = FALSE;
1854                         DPRINTK1("In LDWN TACHYON initializing as L_Port...\n");
1855                         writel(INITIALIZE, fi->t_r.ptr_fm_control_reg);
1856                 }
1857         }
1858
1859     if (fm_status & NON_PARTICIPATING) {
1860                 T_MSG("Did not acquire an AL_PA. I am not participating");
1861     }
1862         else
1863         if ((fm_status & LINK_UP) && ((fm_status & LINK_DOWN) == 0)) {
1864           T_MSG("Fibre Channel Link UP");
1865           if ((fm_status & NON_PARTICIPATING) != TRUE) {
1866                 fi->g.link_up = TRUE;
1867                 if (tachyon_status & OSM_FROZEN) {
1868                         reset_tachyon(fi, ERROR_RELEASE);
1869                         reset_tachyon(fi, OCQ_RESET);
1870                 }
1871                 init_timer(&fi->explore_timer);
1872                 init_timer(&fi->nport_timer);
1873                 init_timer(&fi->lport_timer);
1874                 init_timer(&fi->display_cache_timer);
1875                 if ((fm_status & OLD_PORT) == 0) {
1876                         fi->g.loop_up = TRUE;
1877                         fi->g.ptp_up = FALSE;
1878                         fi->g.my_id = readl(fi->t_r.ptr_fm_config_reg) >> 24;
1879                         DPRINTK1("My AL_PA = %x", fi->g.my_id);
1880                         fi->g.port_discovery = TRUE;
1881                         fi->g.explore_fabric = FALSE;
1882                 }
1883                 else
1884                 if (((fm_status & 0xF0) == OLD_PORT) && ((fm_status & 0x0F) == PORT_STATE_ACTIVE)) {
1885                         fi->g.loop_up = FALSE;
1886                         fi->g.my_id = 0x0;
1887                         /* In a point-to-point configuration, we expect to be
1888                          * connected to an F_Port. This driver does not yet support
1889                          * a configuration where it is connected to another N_Port
1890                          * directly.
1891                          */
1892                         fi->g.explore_fabric = TRUE;
1893                         fi->g.port_discovery = FALSE;
1894                         if (fi->g.n_port_try == FALSE) {
1895                                 take_tachyon_offline(fi);
1896                                 /* write R_T_TOV & E_D_TOV into the registers */
1897                                 writel(PTP_TOV_VALUES, fi->t_r.ptr_fm_tov_reg);
1898                                 writel(BB_CREDIT | NPORT, fi->t_r.ptr_fm_config_reg);
1899                                 fi->g.n_port_try = TRUE;
1900                                 DPRINTK1("In LUP TACHYON initializing as N_Port...\n");
1901                                 writel(INITIALIZE, fi->t_r.ptr_fm_control_reg);
1902                         }
1903                         else {
1904                                 fi->g.ptp_up = TRUE;
1905                                 tx_logi(fi, ELS_FLOGI, F_PORT);
1906                         }
1907                 }
1908                 fi->g.my_ddaa = 0x0;
1909                 fi->g.fabric_present = FALSE;
1910                 /* We havn't sent out any Name Server Reqs */
1911                 fi->g.name_server = FALSE;
1912                 fi->g.alpa_list_index = 0;
1913                 fi->g.ox_id = NOT_SCSI_XID;
1914                 fi->g.my_mtu = TACH_FRAME_SIZE;
1915
1916                 /* Implicitly LOGO with all logged-in nodes.
1917                  */
1918                 if (fi->node_info_list) {
1919                 struct fc_node_info *temp_list = fi->node_info_list;
1920                         while(temp_list) {
1921                                 temp_list->login = LOGIN_ATTEMPTED;
1922                                 temp_list = temp_list->next;
1923                         }
1924                         fi->num_nodes = 0;
1925                         fi->g.perform_adisc = TRUE;
1926                         //fi->g.perform_adisc = FALSE;
1927                         fi->g.port_discovery = FALSE;
1928                         tx_logi(fi, ELS_FLOGI, F_PORT);
1929                 }
1930                 else {
1931                         /* If Link coming up for the _first_ time or no nodes
1932                          * were logged in before...
1933                          */
1934                         fi->g.scsi_oxid = 0;
1935                         fi->g.seq_id = 0x00;
1936                         fi->g.perform_adisc = FALSE;
1937                 }
1938
1939                 /* reset OX_ID table */
1940                 while (fi->ox_id_list) {
1941                 struct ox_id_els_map *temp = fi->ox_id_list;
1942                         fi->ox_id_list = fi->ox_id_list->next;
1943                         kfree(temp);
1944                 }
1945                 fi->ox_id_list = NULL;
1946           } /* End of if partipating */
1947         }
1948
1949         if (fm_status & ELASTIC_STORE_ERROR) {
1950                 /* Too much junk on the Link
1951                  */
1952                 /* Trying to clear it up by Txing PLOGI to urself */
1953                 if (fi->g.link_up == TRUE)
1954                         tx_logi(fi, ELS_PLOGI, fi->g.my_id);
1955         }
1956
1957         if (fm_status & LOOP_UP) {
1958                 if (tachyon_status & OSM_FROZEN) {
1959                         reset_tachyon(fi, ERROR_RELEASE);
1960                         reset_tachyon(fi, OCQ_RESET);
1961                 }
1962         }
1963
1964         if (fm_status & NOS_OLS_RECEIVED){
1965                 if (fi->g.nport_timer_set == FALSE) {
1966                         DPRINTK("NOS/OLS Received");
1967                         DPRINTK("FM_status = %x", fm_status);
1968                         fi->nport_timer.function = nos_ols_timer;
1969                         fi->nport_timer.data = (unsigned long)fi;
1970                         fi->nport_timer.expires = RUN_AT((3*HZ)/100); /* 30 msec */
1971                         init_timer(&fi->nport_timer);
1972                         add_timer(&fi->nport_timer);
1973                         fi->g.nport_timer_set = TRUE;
1974                 }
1975         }
1976
1977         if (((fm_status & 0xF0) == OLD_PORT) && (((fm_status & 0x0F) == PORT_STATE_LF1) || ((fm_status & 0x0F) == PORT_STATE_LF2))) {
1978                 DPRINTK1("Link Fail-I in OLD-PORT.");
1979                 take_tachyon_offline(fi);
1980                 reset_tachyon(fi, SOFTWARE_RESET);
1981         }
1982
1983         if (fm_status & LOOP_STATE_TIMEOUT){
1984                 if ((fm_status & 0xF0) == ARBITRATING)
1985                         DPRINTK1("ED_TOV timesout.In ARBITRATING state...");
1986                 if ((fm_status & 0xF0) == ARB_WON)
1987                         DPRINTK1("ED_TOV timesout.In ARBITRATION WON state...");
1988                 if ((fm_status & 0xF0) == OPEN)
1989                         DPRINTK1("ED_TOV timesout.In OPEN state...");
1990                 if ((fm_status & 0xF0) == OPENED)
1991                         DPRINTK1("ED_TOV timesout.In OPENED state...");
1992                 if ((fm_status & 0xF0) == TX_CLS)
1993                         DPRINTK1("ED_TOV timesout.In XMITTED CLOSE state...");
1994                 if ((fm_status & 0xF0) == RX_CLS)
1995                         DPRINTK1("ED_TOV timesout.In RECEIVED CLOSE state...");
1996                 if ((fm_status & 0xF0) == INITIALIZING)
1997                         DPRINTK1("ED_TOV timesout.In INITIALIZING state...");
1998                 DPRINTK1("Initializing Loop...");
1999                 writel(INITIALIZE, fi->t_r.ptr_fm_control_reg);
2000         }
2001
2002         if ((fm_status & BAD_ALPA) && (fi->g.loop_up == TRUE)) {
2003         u_char bad_alpa = (readl(fi->t_r.ptr_fm_rx_al_pa_reg) & 0xFF00) >> 8;
2004                 if (tachyon_status & OSM_FROZEN) {
2005                         reset_tachyon(fi, ERROR_RELEASE);
2006                         reset_tachyon(fi, OCQ_RESET);
2007                 }
2008                 /* Fix for B34 */
2009                 tx_logi(fi, ELS_PLOGI, fi->g.my_id);
2010
2011                 if (!fi->g.port_discovery && !fi->g.perform_adisc) {
2012                         if (bad_alpa != 0xFE)
2013                                 DPRINTK("Bad AL_PA = %x", bad_alpa);
2014                 }
2015                 else {
2016                         if ((fi->g.perform_adisc == TRUE) && (bad_alpa == 0x00)) {
2017                                 DPRINTK1("Performing ADISC...");
2018                                 fi->g.fabric_present = FALSE;
2019                                 perform_adisc(fi);
2020                         }
2021                 }
2022         }
2023
2024         if (fm_status & LIPF_RECEIVED){
2025                 DPRINTK("LIP(F8) Received");
2026         }
2027
2028         if (fm_status & LINK_FAILURE) {
2029                 if (fm_status & LOSS_OF_SIGNAL)
2030                         DPRINTK1("Detected Loss of Signal.");
2031                 if (fm_status & OUT_OF_SYNC)
2032                         DPRINTK1("Detected Loss of Synchronization.");
2033         }
2034
2035         if (fm_status & TRANSMIT_PARITY_ERROR) {
2036                 /* Bad! Should not happen. Solution-> Hard Reset.
2037                  */
2038                 T_MSG("Parity Error. Perform Hard Reset!");
2039         }
2040
2041         if (fi->g.alpa_list_index >= MAX_NODES){
2042                 if (fi->g.port_discovery == TRUE) {
2043                         fi->g.port_discovery = FALSE;
2044                         add_display_cache_timer(fi);
2045                 }
2046                 fi->g.alpa_list_index = MAX_NODES;
2047         }
2048
2049         if (fi->g.port_discovery == TRUE)
2050                 local_port_discovery(fi);
2051
2052         LEAVE("handle_FM_interrupt");
2053         return;
2054 }
2055
2056 static void local_port_discovery(struct fc_info *fi)
2057 {
2058         if (fi->g.loop_up == TRUE) {
2059                 /* If this is not here, some of the Bad AL_PAs are missed.
2060                  */
2061                 udelay(20);
2062                 if ((fi->g.alpa_list_index == 0) && (fi->g.fabric_present == FALSE)){
2063                         tx_logi(fi, ELS_FLOGI, F_PORT);
2064                 }
2065                 else {
2066                 int login_state = sid_logged_in(fi, fi->g.my_ddaa | alpa_list[fi->g.alpa_list_index]);
2067                         while ((fi->g.alpa_list_index == 0) || ((fi->g.alpa_list_index < MAX_NODES) && ((login_state == NODE_LOGGED_IN) || (login_state == NODE_PROCESS_LOGGED_IN) || (alpa_list[fi->g.alpa_list_index] == (fi->g.my_id & 0xFF)))))
2068                                 fi->g.alpa_list_index++;
2069                         if (fi->g.alpa_list_index < MAX_NODES)
2070                                 tx_logi(fi, ELS_PLOGI, alpa_list[fi->g.alpa_list_index]);
2071                 }
2072                 fi->g.alpa_list_index++;
2073                 if (fi->g.alpa_list_index >= MAX_NODES){
2074                         if (fi->g.port_discovery == TRUE) {
2075                                 fi->g.port_discovery = FALSE;
2076                                 add_display_cache_timer(fi);
2077                         }
2078                         fi->g.alpa_list_index = MAX_NODES;
2079                 }
2080         }
2081 }
2082
2083 static void nos_ols_timer(unsigned long data)
2084 {
2085 struct fc_info *fi = (struct fc_info*)data;
2086 u_int fm_status;
2087         fm_status = readl(fi->t_r.ptr_fm_status_reg);
2088         DPRINTK1("FM_status in timer= %x", fm_status);
2089         fi->g.nport_timer_set = FALSE;
2090         del_timer(&fi->nport_timer);
2091         if ((fi->g.ptp_up == TRUE) || (fi->g.loop_up == TRUE))
2092                 return;
2093         if (((fm_status & 0xF0) == OLD_PORT) && (((fm_status & 0x0F) == PORT_STATE_ACTIVE) || ((fm_status & 0x0F) == PORT_STATE_OFFLINE))) {
2094                 DPRINTK1("In OLD-PORT after E_D_TOV.");
2095                 take_tachyon_offline(fi);
2096                 /* write R_T_TOV & E_D_TOV into the registers */
2097                 writel(PTP_TOV_VALUES, fi->t_r.ptr_fm_tov_reg);
2098                 writel(BB_CREDIT | NPORT, fi->t_r.ptr_fm_config_reg);
2099                 fi->g.n_port_try = TRUE;
2100                 DPRINTK1("In timer, TACHYON initializing as N_Port...\n");
2101                 writel(INITIALIZE, fi->t_r.ptr_fm_control_reg);
2102         }
2103         else
2104         if ((fi->g.lport_timer_set == FALSE) && ((fm_status & 0xF0) == LOOP_FAIL)) {
2105                 DPRINTK1("Loop Fail after E_D_TOV.");
2106                 fi->lport_timer.function = loop_timer;
2107                 fi->lport_timer.data = (unsigned long)fi;
2108                 fi->lport_timer.expires = RUN_AT((8*HZ)/100);
2109                 init_timer(&fi->lport_timer);
2110                 add_timer(&fi->lport_timer);
2111                 fi->g.lport_timer_set = TRUE;
2112                 take_tachyon_offline(fi);
2113                 reset_tachyon(fi, SOFTWARE_RESET);
2114         }
2115         else
2116         if (((fm_status & 0xF0) == OLD_PORT) && (((fm_status & 0x0F) == PORT_STATE_LF1) || ((fm_status & 0x0F) == PORT_STATE_LF2))) {
2117                 DPRINTK1("Link Fail-II in OLD-PORT.");
2118                 take_tachyon_offline(fi);
2119                 reset_tachyon(fi, SOFTWARE_RESET);
2120         }
2121 }
2122
2123 static void loop_timer(unsigned long data)
2124 {
2125 struct fc_info *fi = (struct fc_info*)data;
2126         fi->g.lport_timer_set = FALSE;
2127         del_timer(&fi->lport_timer);
2128         if ((fi->g.ptp_up == TRUE) || (fi->g.loop_up == TRUE))
2129                 return;
2130 }
2131
2132 static void add_display_cache_timer(struct fc_info *fi)
2133 {
2134         fi->display_cache_timer.function = display_cache_timer;
2135         fi->display_cache_timer.data = (unsigned long)fi;
2136         fi->display_cache_timer.expires = RUN_AT(fi->num_nodes * HZ);
2137         init_timer(&fi->display_cache_timer);
2138         add_timer(&fi->display_cache_timer);
2139 }
2140
2141 static void display_cache_timer(unsigned long data)
2142 {
2143 struct fc_info *fi = (struct fc_info*)data;
2144         del_timer(&fi->display_cache_timer);
2145         display_cache(fi);
2146         return;
2147 }
2148
2149 static void reset_tachyon(struct fc_info *fi, u_int value)
2150 {
2151 u_int tachyon_status, reset_done = OCQ_RESET_STATUS | SCSI_FREEZE_STATUS;
2152 int not_done = 1, i = 0;
2153         writel(value, fi->t_r.ptr_tach_control_reg);
2154         if (value == OCQ_RESET)
2155                 fi->q.ocq_prod_indx = 0;
2156         tachyon_status = readl(fi->t_r.ptr_tach_status_reg);
2157
2158         /* Software resets are immediately done, whereas other aren't. It
2159         about 30 clocks to do the reset */
2160         if (value != SOFTWARE_RESET) {
2161                 while(not_done) {
2162                         if (i++ > 100000) {
2163                                 T_MSG("Reset was unsuccessful! Tachyon Status = %x", tachyon_status);
2164                                 break;
2165                         }
2166                         tachyon_status = readl(fi->t_r.ptr_tach_status_reg);
2167                         if ((tachyon_status & reset_done) == 0)
2168                                 not_done = 0;
2169                 }
2170         }
2171         else {
2172                 write_to_tachyon_registers(fi);
2173         }
2174 }
2175
2176 static void take_tachyon_offline(struct fc_info *fi)
2177 {
2178 u_int fm_status = readl(fi->t_r.ptr_fm_status_reg);
2179
2180         /* The first two conditions will never be true. The Manual and
2181          * the errata say this. But the current implementation is
2182          * decently stable.
2183          */
2184         //if ((fm_status & 0xF0) == LOOP_FAIL) {
2185         if (fm_status == LOOP_FAIL) {
2186                 // workaround as in P. 89
2187                 writel(HOST_CONTROL, fi->t_r.ptr_fm_control_reg);
2188                 if (fi->g.loop_up == TRUE)
2189                         writel(SOFTWARE_RESET, fi->t_r.ptr_tach_control_reg);
2190                 else {
2191                         writel(OFFLINE, fi->t_r.ptr_fm_control_reg);
2192                         writel(EXIT_HOST_CONTROL, fi->t_r.ptr_fm_control_reg);
2193                 }
2194         }
2195         else
2196         //if ((fm_status & LOOP_UP) == LOOP_UP) {
2197         if (fm_status == LOOP_UP) {
2198                 writel(SOFTWARE_RESET, fi->t_r.ptr_tach_control_reg);
2199         }
2200         else
2201                 writel(OFFLINE, fi->t_r.ptr_fm_control_reg);
2202 }
2203
2204
2205 static void read_novram(struct fc_info *fi)
2206 {
2207 int off = 0;
2208         fi->n_r.ptr_novram_hw_control_reg = fi->i_r.ptr_ichip_hw_control_reg;
2209         fi->n_r.ptr_novram_hw_status_reg = fi->i_r.ptr_ichip_hw_status_reg;
2210         iph5526_nr_do_init(fi);
2211         if (fi->clone_id == PCI_VENDOR_ID_INTERPHASE)
2212                 off = 32;
2213
2214         fi->g.my_node_name_high = (fi->n_r.data[off] << 16) | fi->n_r.data[off+1];
2215         fi->g.my_node_name_low = (fi->n_r.data[off+2] << 16) | fi->n_r.data[off+3];
2216         fi->g.my_port_name_high = (fi->n_r.data[off+4] << 16) | fi->n_r.data[off+5];
2217         fi->g.my_port_name_low = (fi->n_r.data[off+6] << 16) | fi->n_r.data[off+7];
2218         DPRINTK("node_name = %x %x", fi->g.my_node_name_high, fi->g.my_node_name_low);
2219         DPRINTK("port_name = %x %x", fi->g.my_port_name_high, fi->g.my_port_name_low);
2220 }
2221
2222 static void reset_ichip(struct fc_info *fi)
2223 {
2224         /* (i)chip reset */
2225         writel(ICHIP_HCR_RESET, fi->i_r.ptr_ichip_hw_control_reg);
2226         /*wait for chip to get reset */
2227         mdelay(10);
2228         /*de-assert reset */
2229         writel(ICHIP_HCR_DERESET, fi->i_r.ptr_ichip_hw_control_reg);
2230
2231         /* enable INT lines on the (i)chip */
2232         writel(ICHIP_HCR_ENABLE_INTA , fi->i_r.ptr_ichip_hw_control_reg);
2233         /* enable byte swap */
2234         writel(ICHIP_HAMR_BYTE_SWAP_ADDR_TR, fi->i_r.ptr_ichip_hw_addr_mask_reg);
2235 }
2236
2237 static void tx_logi(struct fc_info *fi, u_int logi, u_int d_id)
2238 {
2239 int int_required = 1;
2240 u_short ox_id = OX_ID_FIRST_SEQUENCE;
2241 u_int r_ctl = RCTL_ELS_UCTL;
2242 u_int type  = TYPE_ELS | SEQUENCE_INITIATIVE | FIRST_SEQUENCE;
2243 u_int my_mtu = fi->g.my_mtu;
2244         ENTER("tx_logi");
2245         /* We don't want interrupted for our own logi.
2246          * It screws up the port discovery process.
2247          */
2248         if (d_id == fi->g.my_id)
2249                 int_required = 0;
2250         fill_login_frame(fi, logi);
2251         fi->g.type_of_frame = FC_ELS;
2252         memcpy(fi->g.els_buffer[fi->g.e_i], &fi->g.login, sizeof(LOGIN));
2253         tx_exchange(fi, (char *)(fi->g.els_buffer[fi->g.e_i]),sizeof(LOGIN), r_ctl, type, d_id, my_mtu, int_required, ox_id, logi);
2254         fi->g.e_i++;
2255         if (fi->g.e_i == MAX_PENDING_FRAMES)
2256                 fi->g.e_i = 0;
2257         LEAVE("tx_logi");
2258         return;
2259 }
2260
2261 static void tx_logi_acc(struct fc_info *fi, u_int logi, u_int d_id, u_short received_ox_id)
2262 {
2263 int int_required = 0;
2264 u_int r_ctl = RCTL_ELS_SCTL;
2265 u_int type  = TYPE_ELS | EXCHANGE_RESPONDER | LAST_SEQUENCE;
2266 u_int my_mtu = fi->g.my_mtu;
2267         ENTER("tx_logi_acc");
2268         fill_login_frame(fi, logi);
2269         fi->g.type_of_frame = FC_ELS;
2270         memcpy(fi->g.els_buffer[fi->g.e_i], &fi->g.login, sizeof(LOGIN));
2271         tx_exchange(fi, (char *)(fi->g.els_buffer[fi->g.e_i]),sizeof(LOGIN), r_ctl, type, d_id, my_mtu, int_required, received_ox_id, logi);
2272         fi->g.e_i++;
2273         if (fi->g.e_i == MAX_PENDING_FRAMES)
2274                 fi->g.e_i = 0;
2275         LEAVE("tx_logi_acc");
2276         return;
2277 }
2278
2279 static void tx_prli(struct fc_info *fi, u_int command_code, u_int d_id, u_short received_ox_id)
2280 {
2281 int int_required = 1;
2282 u_int r_ctl = RCTL_ELS_UCTL;
2283 u_int type  = TYPE_ELS | SEQUENCE_INITIATIVE | FIRST_SEQUENCE;
2284 u_int my_mtu = fi->g.my_mtu;
2285         ENTER("tx_prli");
2286         if (command_code == ELS_PRLI)
2287                 fi->g.prli.cmnd_code = htons((ELS_PRLI | PAGE_LEN) >> 16);
2288         else {
2289                 fi->g.prli.cmnd_code = htons((ELS_ACC | PAGE_LEN) >> 16);
2290                 int_required = 0;
2291                 type  = TYPE_ELS | EXCHANGE_RESPONDER | LAST_SEQUENCE;
2292                 r_ctl = RCTL_ELS_SCTL;
2293         }
2294         fi->g.prli.payload_length = htons(PRLI_LEN);
2295         fi->g.prli.type_code = htons(FCP_TYPE_CODE);
2296         fi->g.prli.est_image_pair = htons(IMAGE_PAIR);
2297         fi->g.prli.responder_pa = 0;
2298         fi->g.prli.originator_pa = 0;
2299         fi->g.prli.service_params = htonl(INITIATOR_FUNC | READ_XFER_RDY_DISABLED);
2300         fi->g.type_of_frame = FC_ELS;
2301         memcpy(fi->g.els_buffer[fi->g.e_i], &fi->g.prli, sizeof(PRLI));
2302         tx_exchange(fi, (char *)(fi->g.els_buffer[fi->g.e_i]), sizeof(PRLI), r_ctl, type, d_id, my_mtu, int_required, received_ox_id, command_code);
2303         fi->g.e_i++;
2304         if (fi->g.e_i == MAX_PENDING_FRAMES)
2305                 fi->g.e_i = 0;
2306         LEAVE("tx_prli");
2307         return;
2308 }
2309
2310 static void tx_logo(struct fc_info *fi, u_int d_id, u_short received_ox_id)
2311 {
2312 int int_required = 1;
2313 u_int r_ctl = RCTL_ELS_UCTL;
2314 u_int type  = TYPE_ELS | EXCHANGE_RESPONDER | SEQUENCE_RESPONDER | FIRST_SEQUENCE | END_SEQUENCE | SEQUENCE_INITIATIVE;
2315 int size = sizeof(LOGO);
2316 char fc_id[3];
2317 u_int my_mtu = fi->g.my_mtu;
2318         ENTER("tx_logo");
2319         fi->g.logo.logo_cmnd = htonl(ELS_LOGO);
2320         fi->g.logo.reserved = 0;
2321         memcpy(fc_id, &(fi->g.my_id), 3);
2322         fi->g.logo.n_port_id_0 = fc_id[0];
2323         fi->g.logo.n_port_id_1 = fc_id[1];
2324         fi->g.logo.n_port_id_2 = fc_id[2];
2325         fi->g.logo.port_name_up = htonl(N_PORT_NAME_HIGH);
2326         fi->g.logo.port_name_low = htonl(N_PORT_NAME_LOW);
2327         fi->g.type_of_frame = FC_ELS;
2328         memcpy(fi->g.els_buffer[fi->g.e_i], &fi->g.logo, sizeof(LOGO));
2329         tx_exchange(fi, (char *)(fi->g.els_buffer[fi->g.e_i]),size, r_ctl, type, d_id, my_mtu, int_required, received_ox_id, ELS_LOGO);
2330         fi->g.e_i++;
2331         if (fi->g.e_i == MAX_PENDING_FRAMES)
2332                 fi->g.e_i = 0;
2333         LEAVE("tx_logo");
2334 }
2335
2336 static void tx_adisc(struct fc_info *fi, u_int cmnd_code, u_int d_id, u_short received_ox_id)
2337 {
2338 int int_required = 0;
2339 u_int r_ctl = RCTL_ELS_SCTL;
2340 u_int type  = TYPE_ELS | EXCHANGE_RESPONDER | SEQUENCE_RESPONDER | FIRST_SEQUENCE | END_SEQUENCE;
2341 int size = sizeof(ADISC);
2342 u_int my_mtu = fi->g.my_mtu;
2343         fi->g.adisc.ls_cmnd_code = htonl(cmnd_code);
2344         fi->g.adisc.hard_address = htonl(0);
2345         fi->g.adisc.port_name_high = htonl(N_PORT_NAME_HIGH);
2346         fi->g.adisc.port_name_low = htonl(N_PORT_NAME_LOW);
2347         fi->g.adisc.node_name_high = htonl(NODE_NAME_HIGH);
2348         fi->g.adisc.node_name_low = htonl(NODE_NAME_LOW);
2349         fi->g.adisc.n_port_id = htonl(fi->g.my_id);
2350         if (cmnd_code == ELS_ADISC) {
2351                 int_required = 1;
2352                 r_ctl = RCTL_ELS_UCTL;
2353                 type  = TYPE_ELS | SEQUENCE_INITIATIVE | FIRST_SEQUENCE;
2354         }
2355         fi->g.type_of_frame = FC_ELS;
2356         memcpy(fi->g.els_buffer[fi->g.e_i], &fi->g.adisc, size);
2357         tx_exchange(fi, (char *)(fi->g.els_buffer[fi->g.e_i]),size, r_ctl, type, d_id, my_mtu, int_required, received_ox_id, cmnd_code);
2358         fi->g.e_i++;
2359         if (fi->g.e_i == MAX_PENDING_FRAMES)
2360                 fi->g.e_i = 0;
2361 }
2362
2363 static void tx_ls_rjt(struct fc_info *fi, u_int d_id, u_short received_ox_id, u_short reason_code, u_short expln_code)
2364 {
2365 int int_required = 0;
2366 u_int r_ctl = RCTL_ELS_SCTL;
2367 u_int type  = TYPE_ELS | EXCHANGE_RESPONDER | LAST_SEQUENCE;
2368 int size = sizeof(LS_RJT);
2369 u_int my_mtu = fi->g.my_mtu;
2370         ENTER("tx_ls_rjt");
2371         fi->g.ls_rjt.cmnd_code = htonl(ELS_LS_RJT);
2372         fi->g.ls_rjt.reason_code = htonl((reason_code << 16) | expln_code);
2373         fi->g.type_of_frame = FC_ELS;
2374         memcpy(fi->g.els_buffer[fi->g.e_i], &fi->g.ls_rjt, size);
2375         tx_exchange(fi, (char *)(fi->g.els_buffer[fi->g.e_i]),size, r_ctl, type, d_id, my_mtu, int_required, received_ox_id, ELS_LS_RJT);
2376         fi->g.e_i++;
2377         if (fi->g.e_i == MAX_PENDING_FRAMES)
2378                 fi->g.e_i = 0;
2379         LEAVE("tx_ls_rjt");
2380 }
2381
2382 static void tx_abts(struct fc_info *fi, u_int d_id, u_short ox_id)
2383 {
2384 int int_required = 1;
2385 u_int r_ctl = RCTL_BASIC_ABTS;
2386 u_int type  = TYPE_BLS | SEQUENCE_INITIATIVE | FIRST_SEQUENCE;
2387 int size = 0;
2388 u_int my_mtu = fi->g.my_mtu;
2389         ENTER("tx_abts");
2390         fi->g.type_of_frame = FC_BLS;
2391         tx_exchange(fi, NULL, size, r_ctl, type, d_id, my_mtu, int_required, ox_id, RCTL_BASIC_ABTS);
2392         LEAVE("tx_abts");
2393 }
2394
2395 static u_int plogi_ok(struct fc_info *fi, u_int *buff_addr, int size)
2396 {
2397 int ret_code = 0;
2398 u_short mtu = ntohl(*(buff_addr + 10)) & 0x00000FFF;
2399 u_short class3 = ntohl(*(buff_addr + 25)) >> 16;
2400 u_short class3_conc_seq = ntohl(*(buff_addr + 27)) >> 16;
2401 u_short open_seq = ntohl(*(buff_addr + 28)) >> 16;
2402         DPRINTK1("mtu = %x class3 = %x conc_seq = %x open_seq = %x", mtu, class3, class3_conc_seq, open_seq);
2403         size -= TACHYON_HEADER_LEN;
2404         if (!(class3 & 0x8000)) {
2405                 DPRINTK1("Received PLOGI with class3 = %x", class3);
2406                 ret_code = (LOGICAL_ERR << 16) | NO_EXPLN;
2407                 return ret_code;
2408         }
2409         if (mtu < 256) {
2410                 DPRINTK1("Received PLOGI with MTU set to %x", mtu);
2411                 ret_code = (LOGICAL_ERR << 16) | RECV_FIELD_SIZE;
2412                 return ret_code;
2413         }
2414         if (size != PLOGI_LEN) {
2415                 DPRINTK1("Received PLOGI of size %x", size);
2416                 ret_code = (LOGICAL_ERR << 16) | INV_PAYLOAD_LEN;
2417                 return ret_code;
2418         }
2419         if (class3_conc_seq == 0) {
2420                 DPRINTK1("Received PLOGI with conc_seq == 0");
2421                 ret_code = (LOGICAL_ERR << 16) | CONC_SEQ;
2422                 return ret_code;
2423         }
2424         if (open_seq == 0) {
2425                 DPRINTK1("Received PLOGI with open_seq == 0");
2426                 ret_code = (LOGICAL_ERR << 16) | NO_EXPLN;
2427                 return ret_code;
2428         }
2429
2430         /* Could potentially check for more fields, but might end up
2431            not talking to most of the devices. ;-) */
2432         /* Things that could get checked are:
2433            common_features = 0x8800
2434            total_concurrent_seq = at least 1
2435         */
2436         return ret_code;
2437 }
2438
2439 static void tx_acc(struct fc_info *fi, u_int d_id, u_short received_ox_id)
2440 {
2441 int int_required = 0;
2442 u_int r_ctl = RCTL_ELS_SCTL;
2443 u_int type  = TYPE_ELS | EXCHANGE_RESPONDER | LAST_SEQUENCE;
2444 int size = sizeof(ACC);
2445 u_int my_mtu = fi->g.my_mtu;
2446         ENTER("tx_acc");
2447         fi->g.acc.cmnd_code = htonl(ELS_ACC);
2448         fi->g.type_of_frame = FC_ELS;
2449         memcpy(fi->g.els_buffer[fi->g.e_i], &fi->g.acc, size);
2450         tx_exchange(fi, (char *)(fi->g.els_buffer[fi->g.e_i]),size, r_ctl, type, d_id, my_mtu, int_required, received_ox_id, ELS_ACC);
2451         fi->g.e_i++;
2452         if (fi->g.e_i == MAX_PENDING_FRAMES)
2453                 fi->g.e_i = 0;
2454         LEAVE("tx_acc");
2455 }
2456
2457
2458 static void tx_name_server_req(struct fc_info *fi, u_int req)
2459 {
2460 int int_required = 1, i, size = 0;
2461 u_short ox_id = OX_ID_FIRST_SEQUENCE;
2462 u_int type  = TYPE_FC_SERVICES | SEQUENCE_INITIATIVE | FIRST_SEQUENCE;
2463 u_int r_ctl = FC4_DEVICE_DATA | UNSOLICITED_CONTROL;
2464 u_int my_mtu = fi->g.my_mtu, d_id = DIRECTORY_SERVER;
2465 CT_HDR ct_hdr;
2466         ENTER("tx_name_server_req");
2467         /* Fill up CT_Header */
2468         ct_hdr.rev_in_id = htonl(FC_CT_REV);
2469         ct_hdr.fs_type = DIRECTORY_SERVER_APP;
2470         ct_hdr.fs_subtype = NAME_SERVICE;
2471         ct_hdr.options = 0;
2472         ct_hdr.resv1 = 0;
2473         ct_hdr.cmnd_resp_code = htons(req >> 16);
2474         ct_hdr.max_res_size = 0;
2475         ct_hdr.resv2 = 0;
2476         ct_hdr.reason_code = 0;
2477         ct_hdr.expln_code = 0;
2478         ct_hdr.vendor_unique = 0;
2479
2480         fi->g.type_of_frame = FC_ELS;
2481         switch(req) {
2482                 case FCS_RFC_4:
2483                         memcpy(&(fi->g.rfc_4.ct_hdr), &ct_hdr, sizeof(CT_HDR));
2484                         fi->g.rfc_4.s_id = htonl(fi->g.my_id);
2485                         for (i = 0; i < 32; i++)
2486                                 fi->g.rfc_4.bit_map[i] = 0;
2487                         /* We support IP & SCSI */
2488                         fi->g.rfc_4.bit_map[2] = 0x01;
2489                         fi->g.rfc_4.bit_map[3] = 0x20;
2490                         size = sizeof(RFC_4);
2491                         memcpy(fi->g.els_buffer[fi->g.e_i], &fi->g.rfc_4, size);
2492                         tx_exchange(fi, (char *)(fi->g.els_buffer[fi->g.e_i]),size, r_ctl, type, d_id, my_mtu, int_required, ox_id, req);
2493                         break;
2494                 case FCS_GP_ID4:
2495                         memcpy(&(fi->g.gp_id4.ct_hdr), &ct_hdr, sizeof(CT_HDR));
2496                         fi->g.gp_id4.port_type = htonl(PORT_TYPE_NX_PORTS);
2497                         size = sizeof(GP_ID4);
2498                         memcpy(fi->g.els_buffer[fi->g.e_i], &fi->g.gp_id4, size);
2499                         tx_exchange(fi, (char *)(fi->g.els_buffer[fi->g.e_i]),size, r_ctl, type, d_id, my_mtu, int_required, ox_id, req);
2500                         break;
2501         }
2502         fi->g.e_i++;
2503         if (fi->g.e_i == MAX_PENDING_FRAMES)
2504                 fi->g.e_i = 0;
2505         LEAVE("tx_name_server_req");
2506 }
2507
2508 static void tx_scr(struct fc_info *fi)
2509 {
2510 int int_required = 1, size = sizeof(SCR);
2511 u_short ox_id = OX_ID_FIRST_SEQUENCE;
2512 u_int type  = TYPE_ELS | SEQUENCE_INITIATIVE | FIRST_SEQUENCE;
2513 u_int r_ctl = RCTL_ELS_UCTL;
2514 u_int my_mtu = fi->g.my_mtu, d_id = FABRIC_CONTROLLER;
2515         ENTER("tx_scr");
2516         fi->g.scr.cmnd_code = htonl(ELS_SCR);
2517         fi->g.scr.reg_function = htonl(FULL_REGISTRATION);
2518         fi->g.type_of_frame = FC_ELS;
2519         memcpy(fi->g.els_buffer[fi->g.e_i], &fi->g.scr, size);
2520         tx_exchange(fi, (char *)(fi->g.els_buffer[fi->g.e_i]),size, r_ctl, type, d_id, my_mtu, int_required, ox_id, ELS_SCR);
2521         fi->g.e_i++;
2522         if (fi->g.e_i == MAX_PENDING_FRAMES)
2523                 fi->g.e_i = 0;
2524         LEAVE("tx_scr");
2525 }
2526
2527 static void perform_adisc(struct fc_info *fi)
2528 {
2529 int count = 0;
2530         /* Will be set to TRUE when timer expires in a PLDA environment.
2531          */
2532         fi->g.port_discovery = FALSE;
2533
2534         if (fi->node_info_list) {
2535                 struct fc_node_info *temp_list = fi->node_info_list;
2536                 while(temp_list) {
2537                         /* Tx ADISC to all non-fabric based
2538                          * entities.
2539                          */
2540                         if ((temp_list->d_id & 0xFF0000) != 0xFF0000)
2541                                 tx_adisc(fi, ELS_ADISC, temp_list->d_id, OX_ID_FIRST_SEQUENCE);
2542                         temp_list = temp_list->next;
2543                         udelay(20);
2544                         count++;
2545                 }
2546         }
2547         /* Perform Port Discovery after timer expires.
2548          * We are giving time for the ADISCed nodes to respond
2549          * so that we don't have to perform PLOGI to those whose
2550          * login are _still_ valid.
2551          */
2552         fi->explore_timer.function = port_discovery_timer;
2553         fi->explore_timer.data = (unsigned long)fi;
2554         fi->explore_timer.expires = RUN_AT((count*3*HZ)/100);
2555         init_timer(&fi->explore_timer);
2556         add_timer(&fi->explore_timer);
2557 }
2558
2559 static void explore_fabric(struct fc_info *fi, u_int *buff_addr)
2560 {
2561 u_int *addr = buff_addr + 12; /* index into payload */
2562 u_char control_code;
2563 u_int d_id;
2564 int count = 0;
2565         ENTER("explore_fabric");
2566         DPRINTK1("entering explore_fabric");
2567
2568         /*fi->g.perform_adisc = TRUE;
2569         fi->g.explore_fabric = TRUE;
2570         perform_adisc(fi);*/
2571
2572         do {
2573                 d_id = ntohl(*addr) & 0x00FFFFFF;
2574                 if (d_id != fi->g.my_id) {
2575                         if (sid_logged_in(fi, d_id) == NODE_NOT_PRESENT)
2576                                 tx_logi(fi, ELS_PLOGI, d_id);
2577                         else
2578                         if (sid_logged_in(fi, d_id) == NODE_LOGGED_OUT)
2579                                 tx_adisc(fi, ELS_ADISC, d_id, OX_ID_FIRST_SEQUENCE);
2580                         count++;
2581                 }
2582                 control_code = (ntohl(*addr) & 0xFF000000) >> 24;
2583                 addr++;
2584                 DPRINTK1("cc = %x, d_id = %x", control_code, d_id);
2585         } while (control_code != 0x80);
2586
2587         fi->explore_timer.function = fabric_explore_timer;
2588         fi->explore_timer.data = (unsigned long)fi;
2589         /* We give 30 msec for each device to respond and then send out
2590          * our SCSI enquiries.
2591          */
2592         fi->explore_timer.expires = RUN_AT((count*3*HZ)/100);
2593         init_timer(&fi->explore_timer);
2594         add_timer(&fi->explore_timer);
2595
2596         DPRINTK1("leaving explore_fabric");
2597         LEAVE("explore_fabric");
2598 }
2599
2600 static void fabric_explore_timer(unsigned long data)
2601 {
2602 struct fc_info *fi = (struct fc_info*)data;
2603         del_timer(&fi->explore_timer);
2604
2605         if ((fi->g.loop_up == TRUE) && (fi->g.ptp_up == FALSE)) {
2606                 /* Initiate Local Port Discovery on the Local Loop.
2607                  */
2608                 fi->g.port_discovery = TRUE;
2609                 fi->g.alpa_list_index = 1;
2610                 local_port_discovery(fi);
2611         }
2612         fi->g.explore_fabric = FALSE;
2613         return;
2614 }
2615
2616 static void port_discovery_timer(unsigned long data)
2617 {
2618 struct fc_info *fi = (struct fc_info*)data;
2619         del_timer(&fi->explore_timer);
2620
2621         if ((fi->g.loop_up == TRUE) && (fi->g.explore_fabric != TRUE)) {
2622                 fi->g.port_discovery = TRUE;
2623                 fi->g.alpa_list_index = 1;
2624                 local_port_discovery(fi);
2625         }
2626         fi->g.perform_adisc = FALSE;
2627         return;
2628 }
2629
2630 static void add_to_ox_id_list(struct fc_info *fi, u_int transaction_id, u_int cmnd_code)
2631 {
2632 struct ox_id_els_map *p, *q = fi->ox_id_list, *r = NULL;
2633 int size = sizeof(struct ox_id_els_map);
2634         while (q != NULL) {
2635                 r = q;
2636                 q = q->next;
2637         }
2638         p = (struct ox_id_els_map *)kmalloc(size, GFP_ATOMIC);
2639         if (p == NULL) {
2640                 T_MSG("kmalloc failed in add_to_ox_id_list()");
2641                 return;
2642         }
2643         p->ox_id = transaction_id;
2644         p->els = cmnd_code;
2645         p->next = NULL;
2646         if (fi->ox_id_list == NULL)
2647                 fi->ox_id_list = p;
2648         else
2649                 r->next = p;
2650         return;
2651 }
2652
2653 static u_int remove_from_ox_id_list(struct fc_info *fi, u_short received_ox_id)
2654 {
2655 struct ox_id_els_map *p = fi->ox_id_list, *q = fi->ox_id_list;
2656 u_int els_type;
2657         while (q != NULL) {
2658                 if (q->ox_id == received_ox_id) {
2659
2660                         if (q == fi->ox_id_list)
2661                                 fi->ox_id_list = fi->ox_id_list->next;
2662                         else
2663                                 if (q->next == NULL)
2664                                         p->next = NULL;
2665                         else
2666                                         p->next = q->next;
2667
2668                         els_type = q->els;
2669                         kfree(q);
2670                         return els_type;
2671                 }
2672                 p = q;
2673                 q = q->next;
2674         }
2675         if (q == NULL)
2676                 DPRINTK2("Could not find ox_id %x in ox_id_els_map", received_ox_id);
2677         return 0;
2678 }
2679
2680 static void build_tachyon_header(struct fc_info *fi, u_int my_id, u_int r_ctl, u_int d_id, u_int type, u_char seq_id, u_char df_ctl, u_short ox_id, u_short rx_id, char *data)
2681 {
2682 u_char alpa = d_id & 0x0000FF;
2683 u_int dest_ddaa = d_id &0xFFFF00;
2684
2685         ENTER("build_tachyon_header");
2686         DPRINTK("d_id = %x, my_ddaa = %x", d_id, fi->g.my_ddaa);
2687         /* Does it have to go to/thru a Fabric? */
2688         if ((dest_ddaa != 0) && ((d_id == F_PORT) || (fi->g.fabric_present && (dest_ddaa != fi->g.my_ddaa))))
2689                 alpa = 0x00;
2690         fi->g.tach_header.resv = 0x00000000;
2691         fi->g.tach_header.sof_and_eof = SOFI3 | EOFN;
2692         fi->g.tach_header.dest_alpa = alpa;
2693         /* Set LCr properly to have enuff credit */
2694         if (alpa == REPLICATE)
2695                 fi->g.tach_header.lcr_and_time_stamp = htons(0xC00);/* LCr=3 */
2696         else
2697                 fi->g.tach_header.lcr_and_time_stamp = 0;
2698         fi->g.tach_header.r_ctl_and_d_id = htonl(r_ctl | d_id);
2699         fi->g.tach_header.vc_id_and_s_id = htonl(my_id);
2700         fi->g.tach_header.type_and_f_cntl = htonl(type);
2701         fi->g.tach_header.seq_id = seq_id;
2702         fi->g.tach_header.df_cntl = df_ctl;
2703         fi->g.tach_header.seq_cnt = 0;
2704         fi->g.tach_header.ox_id = htons(ox_id);
2705         fi->g.tach_header.rx_id = htons(rx_id);
2706         fi->g.tach_header.ro = 0;
2707         if (data) {
2708                 /* We use the Seq_Count to keep track of IP frames in the
2709                  * OCI_interrupt handler. Initial Seq_Count of IP frames is 1.
2710                  */
2711                 if (fi->g.type_of_frame == FC_BROADCAST)
2712                         fi->g.tach_header.seq_cnt = htons(0x1);
2713                 else
2714                         fi->g.tach_header.seq_cnt = htons(0x2);
2715                 fi->g.tach_header.nw_header.d_naa = htons(0x1000);
2716                 fi->g.tach_header.nw_header.s_naa = htons(0x1000);
2717                 memcpy(&(fi->g.tach_header.nw_header.dest_high), data, 2);
2718                 memcpy(&(fi->g.tach_header.nw_header.dest_low), data + 2, 4);
2719                 memcpy(&(fi->g.tach_header.nw_header.source_high), data + 6, 2);
2720                 memcpy(&(fi->g.tach_header.nw_header.source_low), data + 8, 4);
2721         }
2722         LEAVE("build_tachyon_header");
2723 }
2724
2725 static void build_EDB(struct fc_info *fi, char *data, u_short flags, u_short len)
2726 {
2727         fi->g.edb.buf_addr = ntohl((u_int)virt_to_bus(data));
2728         fi->g.edb.ehf = ntohs(flags);
2729         if (len % 4)
2730                 len += (4 - (len % 4));
2731         fi->g.edb.buf_len = ntohs(len);
2732 }
2733
2734 static void build_ODB(struct fc_info *fi, u_char seq_id, u_int d_id, u_int len, u_int cntl, u_short mtu, u_short ox_id, u_short rx_id, int NW_header, int int_required, u_int frame_class)
2735 {
2736         fi->g.odb.seq_d_id = htonl(seq_id << 24 | d_id);
2737         fi->g.odb.tot_len = len;
2738         if (NW_header)
2739                 fi->g.odb.tot_len += NW_HEADER_LEN;
2740         if (fi->g.odb.tot_len % 4)
2741                 fi->g.odb.tot_len += (4 - (fi->g.odb.tot_len % 4));
2742         fi->g.odb.tot_len = htonl(fi->g.odb.tot_len);
2743         switch(int_required) {
2744                 case NO_COMP_AND_INT:
2745                         fi->g.odb.cntl = htons(ODB_CLASS_3 | ODB_EE_CREDIT | ODB_NO_INT | ODB_NO_COMP | cntl);
2746                         break;
2747                 case INT_AND_COMP_REQ:
2748                         fi->g.odb.cntl = htons(ODB_CLASS_3 | ODB_EE_CREDIT | cntl);
2749                         break;
2750                 case NO_INT_COMP_REQ:
2751                         fi->g.odb.cntl = htons(ODB_CLASS_3 | ODB_EE_CREDIT | ODB_NO_INT | cntl);
2752                         break;
2753         }
2754         fi->g.odb.rx_id = htons(rx_id);
2755         fi->g.odb.cs_enable = 0;
2756         fi->g.odb.cs_seed = htons(1);
2757
2758         fi->g.odb.hdr_addr = htonl(virt_to_bus(fi->q.ptr_tachyon_header[fi->q.tachyon_header_indx]));
2759         fi->g.odb.frame_len = htons(mtu);
2760
2761         if (NW_header) {
2762                 /* The pointer to the sk_buff is in here. Freed up when the
2763                  * OCI_interrupt is received.
2764                  */
2765                 fi->g.odb.trans_id = htonl(frame_class);
2766                 fi->g.odb.hdr_len = TACHYON_HEADER_LEN + NW_HEADER_LEN;
2767         }
2768         else {
2769                 /* helps in tracking transmitted OX_IDs */
2770                 fi->g.odb.trans_id = htonl((frame_class & 0xFFFF0000) | ox_id);
2771                 fi->g.odb.hdr_len = TACHYON_HEADER_LEN;
2772         }
2773         fi->g.odb.hdr_len = htons(fi->g.odb.hdr_len);
2774
2775         fi->g.odb.edb_addr = htonl(virt_to_bus(fi->q.ptr_edb[fi->q.edb_buffer_indx]));
2776 }
2777
2778 static void fill_login_frame(struct fc_info *fi, u_int logi)
2779 {
2780 int i;
2781         fi->g.login.ls_cmnd_code= htonl(logi);
2782         fi->g.login.fc_ph_version = htons(PH_VERSION);
2783         if (fi->g.loop_up)
2784                 fi->g.login.buff_to_buff_credit = htons(LOOP_BB_CREDIT);
2785         else
2786         if (fi->g.ptp_up)
2787                 fi->g.login.buff_to_buff_credit = htons(PT2PT_BB_CREDIT);
2788         if ((logi != ELS_FLOGI) || (logi == ELS_ACC))
2789                 fi->g.login.common_features = htons(PLOGI_C_F);
2790         else
2791         if (logi == ELS_FLOGI)
2792                 fi->g.login.common_features = htons(FLOGI_C_F);
2793         fi->g.login.recv_data_field_size = htons(TACH_FRAME_SIZE);
2794         fi->g.login.n_port_total_conc_seq = htons(CONCURRENT_SEQUENCES);
2795         fi->g.login.rel_off_by_info_cat = htons(RO_INFO_CATEGORY);
2796         fi->g.login.ED_TOV = htonl(E_D_TOV);
2797         fi->g.login.n_port_name_high = htonl(N_PORT_NAME_HIGH);
2798         fi->g.login.n_port_name_low = htonl(N_PORT_NAME_LOW);
2799         fi->g.login.node_name_high = htonl(NODE_NAME_HIGH);
2800         fi->g.login.node_name_low = htonl(NODE_NAME_LOW);
2801
2802         /* Fill Class 1 parameters */
2803         fi->g.login.c_of_s[0].service_options = htons(0);
2804         fi->g.login.c_of_s[0].initiator_ctl = htons(0);
2805         fi->g.login.c_of_s[0].recipient_ctl = htons(0);
2806         fi->g.login.c_of_s[0].recv_data_field_size = htons(0);
2807         fi->g.login.c_of_s[0].concurrent_sequences = htons(0);
2808         fi->g.login.c_of_s[0].n_port_end_to_end_credit = htons(0);
2809         fi->g.login.c_of_s[0].open_seq_per_exchange = htons(0);
2810         fi->g.login.c_of_s[0].resv = htons(0);
2811
2812         /* Fill Class 2 parameters */
2813         fi->g.login.c_of_s[1].service_options = htons(0);
2814         fi->g.login.c_of_s[1].initiator_ctl = htons(0);
2815         fi->g.login.c_of_s[1].recipient_ctl = htons(0);
2816         fi->g.login.c_of_s[1].recv_data_field_size = htons(0);
2817         fi->g.login.c_of_s[1].concurrent_sequences = htons(0);
2818         fi->g.login.c_of_s[1].n_port_end_to_end_credit = htons(0);
2819         fi->g.login.c_of_s[1].open_seq_per_exchange = htons(0);
2820         fi->g.login.c_of_s[1].resv = htons(0);
2821
2822         /* Fill Class 3 parameters */
2823         if (logi == ELS_FLOGI)
2824                 fi->g.login.c_of_s[2].service_options  = htons(SERVICE_VALID | SEQUENCE_DELIVERY);
2825         else
2826                 fi->g.login.c_of_s[2].service_options  = htons(SERVICE_VALID);
2827         fi->g.login.c_of_s[2].initiator_ctl = htons(0);
2828         fi->g.login.c_of_s[2].recipient_ctl = htons(0);
2829         fi->g.login.c_of_s[2].recv_data_field_size = htons(TACH_FRAME_SIZE);
2830         fi->g.login.c_of_s[2].concurrent_sequences = htons(CLASS3_CONCURRENT_SEQUENCE);
2831         fi->g.login.c_of_s[2].n_port_end_to_end_credit = htons(0);
2832         fi->g.login.c_of_s[2].open_seq_per_exchange = htons(CLASS3_OPEN_SEQUENCE);
2833         fi->g.login.c_of_s[2].resv = htons(0);
2834
2835         for(i = 0; i < 4; i++) {
2836                 fi->g.login.resv[i] = 0;
2837                 fi->g.login.vendor_version_level[i] = 0;
2838         }
2839 }
2840
2841
2842 /* clear the Interrupt Latch on the (i)chip, so that you can receive
2843  * Interrupts from Tachyon in future
2844  */
2845 static void reset_latch(struct fc_info *fi)
2846 {
2847         writel(readl(fi->i_r.ptr_ichip_hw_status_reg) | ICHIP_HSR_INT_LATCH, fi->i_r.ptr_ichip_hw_status_reg);
2848 }
2849
2850 static void update_OCQ_indx(struct fc_info *fi)
2851 {
2852         fi->q.ocq_prod_indx++;
2853         if (fi->q.ocq_prod_indx == OCQ_LENGTH)
2854                 fi->q.ocq_prod_indx = 0;
2855         writel(fi->q.ocq_prod_indx, fi->t_r.ptr_ocq_prod_indx_reg);
2856 }
2857
2858 static void update_IMQ_indx(struct fc_info *fi, int count)
2859 {
2860         fi->q.imq_cons_indx += count;
2861         if (fi->q.imq_cons_indx >= IMQ_LENGTH)
2862                 fi->q.imq_cons_indx -= IMQ_LENGTH;
2863         writel(fi->q.imq_cons_indx, fi->t_r.ptr_imq_cons_indx_reg);
2864 }
2865
2866 static void update_SFSBQ_indx(struct fc_info *fi)
2867 {
2868         fi->q.sfsbq_prod_indx++;
2869         if (fi->q.sfsbq_prod_indx == SFSBQ_LENGTH)
2870                 fi->q.sfsbq_prod_indx = 0;
2871         writel(fi->q.sfsbq_prod_indx, fi->t_r.ptr_sfsbq_prod_reg);
2872 }
2873
2874 static void update_MFSBQ_indx(struct fc_info *fi, int count)
2875 {
2876         fi->q.mfsbq_prod_indx += count;
2877         if (fi->q.mfsbq_prod_indx >= MFSBQ_LENGTH)
2878                 fi->q.mfsbq_prod_indx -= MFSBQ_LENGTH;
2879         writel(fi->q.mfsbq_prod_indx, fi->t_r.ptr_mfsbq_prod_reg);
2880 }
2881
2882
2883 static void update_tachyon_header_indx(struct fc_info *fi)
2884 {
2885         fi->q.tachyon_header_indx++;
2886         if (fi->q.tachyon_header_indx == NO_OF_TACH_HEADERS)
2887                 fi->q.tachyon_header_indx = 0;
2888 }
2889
2890 static void update_EDB_indx(struct fc_info *fi)
2891 {
2892         fi->q.edb_buffer_indx++;
2893         if (fi->q.edb_buffer_indx == EDB_LEN)
2894                 fi->q.edb_buffer_indx = 0;
2895 }
2896
2897 static int iph5526_open(struct net_device *dev)
2898 {
2899         netif_start_queue(dev);
2900         return 0;
2901 }
2902
2903 static int iph5526_close(struct net_device *dev)
2904 {
2905         netif_stop_queue(dev);
2906         return 0;
2907 }
2908
2909 static void iph5526_timeout(struct net_device *dev)
2910 {
2911         struct fc_info *fi = dev->priv;
2912         printk(KERN_WARNING "%s: timed out on send.\n", dev->name);
2913         fi->fc_stats.tx_dropped++;
2914         dev->trans_start = jiffies;
2915         netif_wake_queue(dev);
2916 }
2917
2918 static int iph5526_send_packet(struct sk_buff *skb, struct net_device *dev)
2919 {
2920         struct fc_info *fi = dev->priv;
2921         int status = 0;
2922         short type = 0;
2923         u_long flags;
2924         struct fcllc *fcllc;
2925
2926         ENTER("iph5526_send_packet");
2927
2928         netif_stop_queue(dev);
2929         /* Strip off the pseudo header.
2930          */
2931         skb->data = skb->data + 2*FC_ALEN;
2932         skb->len = skb->len - 2*FC_ALEN;
2933         fcllc = (struct fcllc *)skb->data;
2934         type = ntohs(fcllc->ethertype);
2935
2936         spin_lock_irqsave(&fi->fc_lock, flags);
2937         switch(type) {
2938                 case ETH_P_IP:
2939                         status = tx_ip_packet(skb, skb->len, fi);
2940                         break;
2941                 case ETH_P_ARP:
2942                         status = tx_arp_packet(skb->data, skb->len, fi);
2943                         break;
2944                 default:
2945                         T_MSG("WARNING!!! Received Unknown Packet Type... Discarding...");
2946                         fi->fc_stats.rx_dropped++;
2947                         break;
2948         }
2949         spin_unlock_irqrestore(&fi->fc_lock, flags);
2950
2951         if (status) {
2952                 fi->fc_stats.tx_bytes += skb->len;
2953                 fi->fc_stats.tx_packets++;
2954         }
2955         else
2956                 fi->fc_stats.tx_dropped++;
2957         dev->trans_start = jiffies;
2958         /* We free up the IP buffers in the OCI_interrupt handler.
2959          * status == 0 implies that the frame was not transmitted. So the
2960          * skb is freed here.
2961          */
2962         if ((type == ETH_P_ARP) || (status == 0))
2963                 dev_kfree_skb(skb);
2964         netif_wake_queue(dev);
2965         LEAVE("iph5526_send_packet");
2966         return 0;
2967 }
2968
2969 static int iph5526_change_mtu(struct net_device *dev, int mtu)
2970 {
2971         return 0;
2972 }
2973
2974 static int tx_ip_packet(struct sk_buff *skb, unsigned long len, struct fc_info *fi)
2975 {
2976 u_int d_id;
2977 int int_required = 1;
2978 u_int r_ctl = FC4_DEVICE_DATA | UNSOLICITED_DATA;
2979 u_int type = TYPE_LLC_SNAP;
2980 u_short ox_id = OX_ID_FIRST_SEQUENCE;
2981 u_int mtu;
2982 struct fc_node_info *q;
2983
2984         ENTER("tx_ip_packet");
2985         q = look_up_cache(fi, skb->data - 2*FC_ALEN);
2986         if (q != NULL) {
2987                 d_id = q->d_id;
2988                 DPRINTK("Look-Up Cache Succeeded for d_id = %x", d_id);
2989                 mtu = q->mtu;
2990                 if (q->login == LOGIN_COMPLETED){
2991                         fi->g.type_of_frame = FC_IP;
2992                         return tx_exchange(fi, skb->data, len, r_ctl, type, d_id, mtu, int_required, ox_id, virt_to_bus(skb));
2993                 }
2994
2995                 if (q->d_id == BROADCAST) {
2996                 struct fc_node_info *p = fi->node_info_list;
2997                 int return_value = FALSE;
2998                         fi->g.type_of_frame = FC_BROADCAST;
2999                         /* Do unicast to local nodes.
3000                          */
3001                         int_required = 0;
3002                         while(p != NULL) {
3003                                 d_id = p->d_id;
3004                                 if ((d_id & 0xFFFF00) == fi->g.my_ddaa)
3005                                         return_value |= tx_exchange(fi, skb->data, len, r_ctl, type, d_id, fi->g.my_mtu, int_required, ox_id, TYPE_LLC_SNAP);
3006                                 p = p->next;
3007                         }
3008                         kfree(q);
3009                         return return_value;
3010                 }
3011
3012                 if (q->login != LOGIN_COMPLETED) {
3013                         DPRINTK1("Node not logged in... Txing PLOGI to %x", d_id);
3014                         /* FIXME: we are dumping the frame here */
3015                         tx_logi(fi, ELS_PLOGI, d_id);
3016                 }
3017         }
3018         DPRINTK2("Look-Up Cache Failed");
3019         LEAVE("tx_ip_packet");
3020         return 0;
3021 }
3022
3023 static int tx_arp_packet(char *data, unsigned long len, struct fc_info *fi)
3024 {
3025 u_int opcode = data[ARP_OPCODE_0];
3026 u_int d_id;
3027 int int_required = 0, return_value = FALSE;
3028 u_int r_ctl = FC4_DEVICE_DATA | UNSOLICITED_DATA;
3029 u_int type = TYPE_LLC_SNAP;
3030 u_short ox_id = OX_ID_FIRST_SEQUENCE;
3031 u_int my_mtu = fi->g.my_mtu;
3032         ENTER("tx_arp_packet");
3033
3034         opcode = opcode << 8 | data[ARP_OPCODE_1];
3035         fi->g.type_of_frame = FC_IP;
3036
3037         if (opcode == ARPOP_REQUEST) {
3038         struct fc_node_info *q = fi->node_info_list;
3039                 d_id = BROADCAST;
3040                 return_value |= tx_exchange(fi, data, len, r_ctl, type, d_id, my_mtu, int_required, ox_id, TYPE_LLC_SNAP);
3041                 /* Some devices support HW_TYPE 0x01 */
3042                 memcpy(fi->g.arp_buffer, data - 2*FC_ALEN, len + 2*FC_ALEN);
3043                 fi->g.arp_buffer[9 + 2*FC_ALEN] = 0x01;
3044                 return_value |= tx_exchange(fi, (char *)(fi->g.arp_buffer + 2*FC_ALEN), len, r_ctl, type, d_id, my_mtu, int_required, ox_id, TYPE_LLC_SNAP);
3045
3046                 /* Do unicast to local nodes.
3047                  */
3048                 while(q != NULL) {
3049                         fi->g.type_of_frame = FC_BROADCAST;
3050                         d_id = q->d_id;
3051                         if ((d_id & 0xFFFF00) == fi->g.my_ddaa) {
3052                                 return_value |= tx_exchange(fi, data, len, r_ctl, type, d_id, my_mtu, int_required, ox_id, TYPE_LLC_SNAP);
3053                                 // Some devices support HW_TYPE 0x01
3054                                 memcpy(fi->g.arp_buffer, data - 2*FC_ALEN, len + 2*FC_ALEN);
3055                                 fi->g.arp_buffer[9 + 2*FC_ALEN] = 0x01;
3056                                 return_value |= tx_exchange(fi, (char *)(fi->g.arp_buffer + 2*FC_ALEN), len, r_ctl, type, d_id, my_mtu, int_required, ox_id, TYPE_LLC_SNAP);
3057                         }
3058                         q = q->next;
3059                 }
3060                 return return_value;
3061         }
3062         else
3063         if (opcode == ARPOP_REPLY) {
3064         struct fc_node_info *q; u_int mtu;
3065                 DPRINTK("We are sending out an ARP reply");
3066                 q = look_up_cache(fi, data - 2*FC_ALEN);
3067                 if (q != NULL) {
3068                         d_id = q->d_id;
3069                         DPRINTK("Look-Up Cache Succeeded for d_id = %x", d_id);
3070                         mtu = q->mtu;
3071                         if (q->login == LOGIN_COMPLETED){
3072                                 tx_exchange(fi, data, len, r_ctl, type, d_id, mtu, int_required, ox_id, TYPE_LLC_SNAP);
3073                                 /* Some devices support HW_TYPE 0x01 */
3074                                 memcpy(fi->g.arp_buffer, data - 2*FC_ALEN, len + 2*FC_ALEN);
3075                                 fi->g.arp_buffer[9 + 2*FC_ALEN] = 0x01;
3076                                 return tx_exchange(fi, (char *)(fi->g.arp_buffer + 2*FC_ALEN), len, r_ctl, type, d_id, my_mtu, int_required, ox_id, TYPE_LLC_SNAP);
3077                         }
3078                         else {
3079                                 DPRINTK1("Node not logged in... Txing PLOGI to %x", d_id);
3080                                 tx_logi(fi, ELS_PLOGI, d_id); /* FIXME: we are dumping the frame here */
3081                         }
3082                 }
3083                 DPRINTK2("Look-Up Cache Failed");
3084         }
3085         else {
3086                 T_MSG("Warning!!! Invalid Opcode in ARP Packet!");
3087         }
3088         LEAVE("tx_arp_packet");
3089         return 0;
3090 }
3091
3092
3093 static void rx_net_packet(struct fc_info *fi, u_char *buff_addr, int payload_size)
3094 {
3095 struct net_device *dev = fi->dev;
3096 struct sk_buff *skb;
3097 u_int skb_size = 0;
3098 struct fch_hdr fch;
3099         ENTER("rx_net_packet");
3100         skb_size = payload_size - TACHYON_HEADER_LEN;
3101         DPRINTK("skb_size = %d", skb_size);
3102         fi->fc_stats.rx_bytes += skb_size - 2;
3103         skb = dev_alloc_skb(skb_size);
3104         if (skb == NULL) {
3105                 printk(KERN_NOTICE "%s: In rx_net_packet() Memory squeeze, dropping packet.\n", dev->name);
3106                 fi->fc_stats.rx_dropped++;
3107                 return;
3108         }
3109         /* Skip over the Tachyon Frame Header.
3110          */
3111         buff_addr += TACHYON_HEADER_LEN;
3112
3113         memcpy(fch.daddr, buff_addr + 2, FC_ALEN);
3114         memcpy(fch.saddr, buff_addr + 10, FC_ALEN);
3115         buff_addr += 2;
3116         memcpy(buff_addr, fch.daddr, FC_ALEN);
3117         memcpy(buff_addr + 6, fch.saddr, FC_ALEN);
3118         skb_reserve(skb, 2);
3119         memcpy(skb_put(skb, skb_size - 2), buff_addr, skb_size - 2);
3120         skb->dev = dev;
3121         skb->protocol = fc_type_trans(skb, dev);
3122         DPRINTK("protocol = %x", skb->protocol);
3123
3124         /* Hmmm... to accept HW Type 0x01 as well...
3125          */
3126         if (skb->protocol == ntohs(ETH_P_ARP))
3127                 skb->data[1] = 0x06;
3128         netif_rx(skb);
3129         dev->last_rx = jiffies;
3130         fi->fc_stats.rx_packets++;
3131         LEAVE("rx_net_packet");
3132 }
3133
3134
3135 static void rx_net_mfs_packet(struct fc_info *fi, struct sk_buff *skb)
3136 {
3137 struct net_device *dev = fi->dev;
3138 struct fch_hdr fch;
3139         ENTER("rx_net_mfs_packet");
3140         /* Construct your Hard Header */
3141         memcpy(fch.daddr, skb->data + 2, FC_ALEN);
3142         memcpy(fch.saddr, skb->data + 10, FC_ALEN);
3143         skb_pull(skb, 2);
3144         memcpy(skb->data, fch.daddr, FC_ALEN);
3145         memcpy(skb->data + 6, fch.saddr, FC_ALEN);
3146         skb->dev = dev;
3147         skb->protocol = fc_type_trans(skb, dev);
3148         DPRINTK("protocol = %x", skb->protocol);
3149         netif_rx(skb);
3150         dev->last_rx = jiffies;
3151         LEAVE("rx_net_mfs_packet");
3152 }
3153
3154 static int tx_exchange(struct fc_info *fi, char *data, u_int len, u_int r_ctl, u_int type, u_int d_id, u_int mtu, int int_required, u_short tx_ox_id, u_int frame_class)
3155 {
3156 u_char df_ctl;
3157 int NW_flag = 0, h_size, return_value;
3158 u_short rx_id = RX_ID_FIRST_SEQUENCE;
3159 u_int tachyon_status;
3160 u_int my_id = fi->g.my_id;
3161         ENTER("tx_exchange");
3162
3163         tachyon_status = readl(fi->t_r.ptr_tach_status_reg);
3164         DPRINTK("Tachyon Status = %x len = %d MTU = %d", tachyon_status, len, mtu);
3165         if (tachyon_status & OSM_FROZEN) {
3166                 reset_tachyon(fi, ERROR_RELEASE);
3167                 reset_tachyon(fi, OCQ_RESET);
3168                 DPRINTK("Tachyon Status = %x len = %d MTU = %d", tachyon_status, len, mtu);
3169         }
3170         if (tx_ox_id == OX_ID_FIRST_SEQUENCE) {
3171                 switch(fi->g.type_of_frame) {
3172                         case FC_SCSI_READ:
3173                                 tx_ox_id = fi->g.scsi_oxid | SCSI_READ_BIT;
3174                                 break;
3175                         case FC_SCSI_WRITE:
3176                                 tx_ox_id = fi->g.scsi_oxid;
3177                                 break;
3178                         default:
3179                                 tx_ox_id = fi->g.ox_id;
3180                                 break;
3181                 }
3182         }
3183         else {
3184                 switch(fi->g.type_of_frame) {
3185                         case FC_SCSI_READ:
3186                                 rx_id = fi->g.scsi_oxid | SCSI_READ_BIT;
3187                                 break;
3188                         case FC_SCSI_WRITE:
3189                                 rx_id = fi->g.scsi_oxid;
3190                                 break;
3191                         case FC_BLS:
3192                                 rx_id = RX_ID_FIRST_SEQUENCE;
3193                                 break;
3194                         default:
3195                                 rx_id = fi->g.ox_id;
3196                                 break;
3197                 }
3198         }
3199
3200         if (type == TYPE_LLC_SNAP) {
3201                 df_ctl = 0x20;
3202                 NW_flag = 1;
3203                 /* Multi Frame Sequence ? If yes, set RO bit */
3204                 if (len > mtu)
3205                         type |= RELATIVE_OFF_PRESENT;
3206                 build_tachyon_header(fi, my_id, r_ctl, d_id, type, fi->g.seq_id, df_ctl, tx_ox_id, rx_id, data - 2*FC_ALEN);
3207         }
3208         else {
3209                 df_ctl = 0;
3210                 /* Multi Frame Sequence ? If yes, set RO bit */
3211                 if (len > mtu)
3212                         type |= RELATIVE_OFF_PRESENT;
3213                 build_tachyon_header(fi, my_id, r_ctl, d_id, type, fi->g.seq_id, df_ctl, tx_ox_id, rx_id, NULL);
3214         }
3215
3216         /* Get free Tachyon Headers and EDBs */
3217         if (get_free_header(fi) || get_free_EDB(fi))
3218                 return 0;
3219
3220         if ((type & 0xFF000000) == TYPE_LLC_SNAP) {
3221                 h_size =  TACHYON_HEADER_LEN + NW_HEADER_LEN;
3222                 memcpy(fi->q.ptr_tachyon_header[fi->q.tachyon_header_indx], &(fi->g.tach_header), h_size);
3223         }
3224         else
3225                 memcpy(fi->q.ptr_tachyon_header[fi->q.tachyon_header_indx], &(fi->g.tach_header), TACHYON_HEADER_LEN);
3226
3227         return_value = tx_sequence(fi, data, len, mtu, d_id, tx_ox_id, rx_id, fi->g.seq_id, NW_flag, int_required, frame_class);
3228
3229         switch(fi->g.type_of_frame) {
3230                 case FC_SCSI_READ:
3231                 case FC_SCSI_WRITE:
3232                         update_scsi_oxid(fi);
3233                         break;
3234                 case FC_BLS:
3235                         break;
3236                 default:
3237                         fi->g.ox_id++;
3238                         if (fi->g.ox_id == 0xFFFF)
3239                                 fi->g.ox_id = NOT_SCSI_XID;
3240                         break;
3241         }
3242
3243         if (fi->g.seq_id == MAX_SEQ_ID)
3244                 fi->g.seq_id = 0;
3245         else
3246                 fi->g.seq_id++;
3247         LEAVE("tx_exchange");
3248         return return_value;
3249 }
3250
3251 static int tx_sequence(struct fc_info *fi, char *data, u_int len, u_int mtu, u_int d_id, u_short ox_id, u_short rx_id, u_char seq_id, int NW_flag, int int_required, u_int frame_class)
3252 {
3253 u_int cntl = 0;
3254 int return_value;
3255         ENTER("tx_sequence");
3256         build_EDB(fi, data, EDB_END, len);
3257         memcpy(fi->q.ptr_edb[fi->q.edb_buffer_indx], &(fi->g.edb), sizeof(EDB));
3258         build_ODB(fi, seq_id, d_id, len, cntl, mtu, ox_id, rx_id, NW_flag, int_required, frame_class);
3259         memcpy(fi->q.ptr_odb[fi->q.ocq_prod_indx], &(fi->g.odb), sizeof(ODB));
3260         if (fi->g.link_up != TRUE) {
3261                 DPRINTK2("Fibre Channel Link not up. Dropping Exchange!");
3262                 return_value = FALSE;
3263         }
3264         else {
3265                 /* To be on the safe side, a check should be included
3266                  * at this point to check if we are overrunning
3267                  * Tachyon.
3268                  */
3269                 update_OCQ_indx(fi);
3270                 return_value = TRUE;
3271         }
3272         update_EDB_indx(fi);
3273         update_tachyon_header_indx(fi);
3274         LEAVE("tx_sequence");
3275         return return_value;
3276 }
3277
3278 static int get_free_header(struct fc_info *fi)
3279 {
3280 u_short temp_ox_id;
3281 u_int *tach_header, initial_indx = fi->q.tachyon_header_indx;
3282         /* Check if the header is in use.
3283          * We could have an outstanding command.
3284          * We should find a free slot as we can queue a
3285          * maximum of 32 SCSI commands only.
3286          */
3287         tach_header = fi->q.ptr_tachyon_header[fi->q.tachyon_header_indx];
3288         temp_ox_id = ntohl(*(tach_header + 6)) >> 16;
3289         /* We care about the SCSI writes only. Those are the wicked ones
3290          * that need an additional set of buffers.
3291          */
3292         while(temp_ox_id <= MAX_SCSI_XID) {
3293                 update_tachyon_header_indx(fi);
3294                 if (fi->q.tachyon_header_indx == initial_indx) {
3295                         /* Should never happen.
3296                          */
3297                         T_MSG("No free Tachyon headers available");
3298                         reset_tachyon(fi, SOFTWARE_RESET);
3299                         return 1;
3300                 }
3301                 tach_header = fi->q.ptr_tachyon_header[fi->q.tachyon_header_indx];
3302                 temp_ox_id = ntohl(*(tach_header + 6)) >> 16;
3303         }
3304         return 0;
3305 }
3306
3307 static int get_free_EDB(struct fc_info *fi)
3308 {
3309 unsigned int initial_indx = fi->q.edb_buffer_indx;
3310         /* Check if the EDB is in use.
3311          * We could have an outstanding SCSI Write command.
3312          * We should find a free slot as we can queue a
3313          * maximum of 32 SCSI commands only.
3314          */
3315         while (fi->q.free_edb_list[fi->q.edb_buffer_indx] != EDB_FREE) {
3316                 update_EDB_indx(fi);
3317                 if (fi->q.edb_buffer_indx == initial_indx) {
3318                         T_MSG("No free EDB buffers avaliable")
3319                         reset_tachyon(fi, SOFTWARE_RESET);
3320                         return 1;
3321                 }
3322         }
3323         return 0;
3324 }
3325
3326 static int validate_login(struct fc_info *fi, u_int *base_ptr)
3327 {
3328 struct fc_node_info *q = fi->node_info_list;
3329 char n_port_name[PORT_NAME_LEN];
3330 char node_name[NODE_NAME_LEN];
3331 u_int s_id;
3332         ENTER("validate_login");
3333         /*index to Port Name in the payload. We need the 8 byte Port Name */
3334         memcpy(n_port_name, base_ptr + 10, PORT_NAME_LEN);
3335         memcpy(node_name, base_ptr + 12, NODE_NAME_LEN);
3336         s_id = ntohl(*(base_ptr + 3)) & 0x00FFFFFF;
3337
3338         /* check if Fibre Channel IDs have changed */
3339         while(q != NULL) {
3340                 if (memcmp(n_port_name, q->hw_addr, PORT_NAME_LEN) == 0) {
3341                         if ((s_id != q->d_id) || (memcmp(node_name, q->node_name, NODE_NAME_LEN) != 0)) {
3342                                 DPRINTK1("Fibre Channel ID of Node has changed. Txing LOGO.");
3343                                 return 0;
3344                         }
3345                         q->login = LOGIN_COMPLETED;
3346 #if DEBUG_5526_2
3347                         display_cache(fi);
3348 #endif
3349                         return 1;
3350                 }
3351                 q = q->next;
3352         }
3353         DPRINTK1("Port Name does not match. Txing LOGO.");
3354         LEAVE("validate_login");
3355        return 0;
3356 }
3357
3358 static void add_to_address_cache(struct fc_info *fi, u_int *base_ptr)
3359 {
3360 int size = sizeof(struct fc_node_info);
3361 struct fc_node_info *p, *q = fi->node_info_list, *r = NULL;
3362 char n_port_name[PORT_NAME_LEN];
3363 u_int s_id;
3364         ENTER("add_to_address_cache");
3365         /*index to Port Name in the payload. We need the 8 byte Port Name */
3366         memcpy(n_port_name, base_ptr + 13, PORT_NAME_LEN);
3367         s_id = ntohl(*(base_ptr + 3)) & 0x00FFFFFF;
3368
3369         /* check if info already exists */
3370         while(q != NULL) {
3371                 if (memcmp(n_port_name, q->hw_addr, PORT_NAME_LEN) == 0) {
3372                         if (s_id != q->d_id) {
3373                                 memcpy(&(q->c_of_s[0]), base_ptr + 17, 3 * sizeof(CLASS_OF_SERVICE));
3374                                 q->mtu = ntohl(*(base_ptr + 10)) & 0x00000FFF;
3375                                 q->d_id = s_id;
3376                                 memcpy(q->node_name, base_ptr + 15, NODE_NAME_LEN);
3377                         }
3378                         q->login = LOGIN_COMPLETED;
3379                         q->scsi = FALSE;
3380                         fi->num_nodes++;
3381 #if DEBUG_5526_2
3382                         display_cache(fi);
3383 #endif
3384                         return;
3385                 }
3386                 r = q;
3387                 q = q->next;
3388         }
3389         p = (struct fc_node_info *)kmalloc(size, GFP_ATOMIC);
3390         if (p == NULL) {
3391                 T_MSG("kmalloc failed in add_to_address_cache()");
3392                 return;
3393         }
3394         memcpy(&(p->c_of_s[0]), base_ptr + 17, 3 * sizeof(CLASS_OF_SERVICE));
3395         p->mtu = ntohl(*(base_ptr + 10)) & 0x00000FFF;
3396         p->d_id = s_id;
3397         memcpy(p->hw_addr, base_ptr + 13, PORT_NAME_LEN);
3398         memcpy(p->node_name, base_ptr + 15, NODE_NAME_LEN);
3399         p->login = LOGIN_COMPLETED;
3400         p->scsi = FALSE;
3401         p->target_id = 0xFF;
3402         p->next = NULL;
3403         if (fi->node_info_list == NULL)
3404                 fi->node_info_list = p;
3405         else
3406                 r->next = p;
3407         fi->num_nodes++;
3408 #if DEBUG_5526_2
3409         display_cache(fi);
3410 #endif
3411         LEAVE("add_to_address_cache");
3412         return;
3413 }
3414
3415 static void remove_from_address_cache(struct fc_info *fi, u_int *base_ptr, u_int cmnd_code)
3416 {
3417 struct fc_node_info *q = fi->node_info_list;
3418 u_int s_id;
3419         ENTER("remove_from_address_cache");
3420         s_id = ntohl(*(base_ptr + 3)) & 0x00FFFFFF;
3421         switch(cmnd_code) {
3422                 case ELS_LOGO:
3423                         /* check if info exists */
3424                         while (q != NULL) {
3425                                 if (s_id == q->d_id) {
3426                                         if (q->login == LOGIN_COMPLETED)
3427                                                 q->login = LOGIN_ATTEMPTED;
3428                                         if (fi->num_nodes > 0)
3429                                                 fi->num_nodes--;
3430 #if DEBUG_5526_2
3431                                         display_cache(fi);
3432 #endif
3433                                         return;
3434                                 }
3435                                 q = q->next;
3436                         }
3437                         DPRINTK1("ELS_LOGO received from node 0x%x which is not logged-in", s_id);
3438                         break;
3439                 case ELS_RSCN:
3440                 {
3441                 int payload_len = ntohl(*(base_ptr + 8)) & 0xFF;
3442                 int no_of_pages, i;
3443                 u_char address_format;
3444                 u_short received_ox_id = ntohl(*(base_ptr + 6)) >> 16;
3445                 u_int node_id, mask, *page_ptr = base_ptr + 9;
3446                         if ((payload_len < 4) || (payload_len > 256)) {
3447                                 DPRINTK1("RSCN with invalid payload length received");
3448                                 tx_ls_rjt(fi, s_id, received_ox_id, LOGICAL_ERR, RECV_FIELD_SIZE);
3449                                 return;
3450                         }
3451                         /* Page_size includes the Command Code */
3452                         no_of_pages = (payload_len / 4) - 1;
3453                         for (i = 0; i < no_of_pages; i++) {
3454                                 address_format = ntohl(*page_ptr) >> 24;
3455                                 node_id = ntohl(*page_ptr) & 0x00FFFFFF;
3456                                 switch(address_format) {
3457                                         case PORT_ADDRESS_FORMAT:
3458                                                 rscn_handler(fi, node_id);
3459                                                 break;
3460                                         case AREA_ADDRESS_FORMAT:
3461                                         case DOMAIN_ADDRESS_FORMAT:
3462                                                 if (address_format == AREA_ADDRESS_FORMAT)
3463                                                         mask = 0xFFFF00;
3464                                                 else
3465                                                         mask = 0xFF0000;
3466                                                 while(q != NULL) {
3467                                                         if ((q->d_id & mask) == (node_id & mask))
3468                                                                 rscn_handler(fi, q->d_id);
3469                                                         q = q->next;
3470                                                 }
3471                                                 /* There might be some new nodes to be
3472                                                  * discovered. But, some of the earlier
3473                                                  * requests as a result of the RSCN might be
3474                                                  * in progress. We don't want to duplicate that
3475                                                  * effort. So letz call SCR after a lag.
3476                                                  */
3477                                                 fi->explore_timer.function = scr_timer;
3478                                                 fi->explore_timer.data = (unsigned long)fi;
3479                                                 fi->explore_timer.expires = RUN_AT((no_of_pages*3*HZ)/100);
3480                                                 init_timer(&fi->explore_timer);
3481                                                 add_timer(&fi->explore_timer);
3482                                                 break;
3483                                         default:
3484                                                 T_MSG("RSCN with invalid address format received");
3485                                                 tx_ls_rjt(fi, s_id, received_ox_id, LOGICAL_ERR, NO_EXPLN);
3486                                 }
3487                                 page_ptr += 1;
3488                         } /* end of for loop */
3489                 } /* end of case RSCN: */
3490                 break;
3491         }
3492 #if DEBUG_5526_2
3493         display_cache(fi);
3494 #endif
3495         LEAVE("remove_from_address_cache");
3496 }
3497
3498 static void rscn_handler(struct fc_info *fi, u_int node_id)
3499 {
3500 struct fc_node_info *q = fi->node_info_list;
3501 int login_state = sid_logged_in(fi, node_id);
3502         if ((login_state == NODE_LOGGED_IN) || (login_state == NODE_PROCESS_LOGGED_IN)) {
3503                 while(q != NULL) {
3504                         if (q->d_id == node_id) {
3505                                 q->login = LOGIN_ATTEMPTED;
3506                                 if (fi->num_nodes > 0)
3507                                         fi->num_nodes--;
3508                                 break;
3509                         }
3510                         else
3511                                 q = q->next;
3512                 }
3513         }
3514         else
3515         if (login_state == NODE_LOGGED_OUT)
3516                 tx_adisc(fi, ELS_ADISC, node_id, OX_ID_FIRST_SEQUENCE);
3517         else
3518         if (login_state == NODE_LOGGED_OUT)
3519                 tx_logi(fi, ELS_PLOGI, node_id);
3520 }
3521
3522 static void scr_timer(unsigned long data)
3523 {
3524 struct fc_info *fi = (struct fc_info *)data;
3525         del_timer(&fi->explore_timer);
3526         tx_name_server_req(fi, FCS_GP_ID4);
3527 }
3528
3529 static int sid_logged_in(struct fc_info *fi, u_int s_id)
3530 {
3531 struct fc_node_info *temp = fi->node_info_list;
3532         while(temp != NULL)
3533                 if ((temp->d_id == s_id) && (temp->login == LOGIN_COMPLETED)) {
3534                         if (temp->scsi != FALSE)
3535                                 return NODE_PROCESS_LOGGED_IN;
3536                         else
3537                                 return NODE_LOGGED_IN;
3538                 }
3539                 else
3540                 if ((temp->d_id == s_id) && (temp->login != LOGIN_COMPLETED))
3541                         return NODE_LOGGED_OUT;
3542                 else
3543                         temp = temp->next;
3544         return NODE_NOT_PRESENT;
3545 }
3546
3547 static void mark_scsi_sid(struct fc_info *fi, u_int *buff_addr, u_char action)
3548 {
3549 struct fc_node_info *temp = fi->node_info_list;
3550 u_int s_id;
3551 u_int service_params;
3552         s_id = ntohl(*(buff_addr + 3)) & 0x00FFFFFF;
3553         service_params = ntohl(*(buff_addr + 12)) & 0x000000F0;
3554         while(temp != NULL)
3555                 if ((temp->d_id == s_id) && (temp->login == LOGIN_COMPLETED)) {
3556                         if (action == DELETE_ENTRY) {
3557                                 temp->scsi = FALSE;
3558 #if DEBUG_5526_2
3559                                 display_cache(fi);
3560 #endif
3561                                 return;
3562                         }
3563                         /* Check if it is a SCSI Target */
3564                         if (!(service_params & TARGET_FUNC)) {
3565                                 temp->scsi = INITIATOR;
3566 #if DEBUG_5526_2
3567                                 display_cache(fi);
3568 #endif
3569                                 return;
3570                         }
3571                         temp->scsi = TARGET;
3572                         /* This helps to maintain the target_id no matter what your
3573                          *  Fibre Channel ID is.
3574                          */
3575                         if (temp->target_id == 0xFF) {
3576                                 if (fi->g.no_of_targets <= MAX_SCSI_TARGETS)
3577                                         temp->target_id = fi->g.no_of_targets++;
3578                                 else
3579                                         T_MSG("MAX TARGETS reached!");
3580                         }
3581                         else
3582                                 DPRINTK1("Target_id %d already present", temp->target_id);
3583 #if DEBUG_5526_2
3584                         display_cache(fi);
3585 #endif
3586                         return;
3587                 }
3588                 else
3589                         temp = temp->next;
3590         return;
3591 }
3592
3593 static int node_logged_in_prev(struct fc_info *fi, u_int *buff_addr)
3594 {
3595 struct fc_node_info *temp;
3596 u_char *data = (u_char *)buff_addr;
3597 u_int s_id;
3598 char node_name[NODE_NAME_LEN];
3599         s_id = ntohl(*(buff_addr + 3)) & 0x00FFFFFF;
3600         memcpy(node_name, buff_addr + 12, NODE_NAME_LEN);
3601         /* point to port_name in the ADISC payload */
3602         data += 10 * 4;
3603         /* point to last 6 bytes of port_name */
3604         data += 2;
3605         temp = look_up_cache(fi, data);
3606         if (temp != NULL) {
3607                 if ((temp->d_id == s_id) && (memcmp(node_name, temp->node_name, NODE_NAME_LEN) == 0)) {
3608                         temp->login = LOGIN_COMPLETED;
3609 #if DEBUG_5526_2
3610                         display_cache(fi);
3611 #endif
3612                         return TRUE;
3613                 }
3614         }
3615         return FALSE;
3616 }
3617
3618 static struct fc_node_info *look_up_cache(struct fc_info *fi, char *data)
3619 {
3620 struct fc_node_info *temp_list = fi->node_info_list, *q;
3621 u_char n_port_name[FC_ALEN], temp_addr[FC_ALEN];
3622         ENTER("look_up_cache");
3623         memcpy(n_port_name, data, FC_ALEN);
3624         while(temp_list) {
3625                 if (memcmp(n_port_name, &(temp_list->hw_addr[2]), FC_ALEN) == 0)
3626                         return temp_list;
3627                 else
3628                         temp_list = temp_list->next;
3629         }
3630
3631         /* Broadcast IP ?
3632          */
3633         temp_addr[0] = temp_addr[1] = temp_addr[2] = 0xFF;
3634         temp_addr[3] = temp_addr[4] = temp_addr[5] = 0xFF;
3635         if (memcmp(n_port_name, temp_addr, FC_ALEN) == 0) {
3636                 q = (struct fc_node_info *)kmalloc(sizeof(struct fc_node_info), GFP_ATOMIC);
3637                 if (q == NULL) {
3638                         T_MSG("kmalloc failed in look_up_cache()");
3639                         return NULL;
3640                 }
3641                 q->d_id = BROADCAST;
3642                 return q;
3643         }
3644         LEAVE("look_up_cache");
3645         return NULL;
3646 }
3647
3648 static int display_cache(struct fc_info *fi)
3649 {
3650 struct fc_node_info *q = fi->node_info_list;
3651 #if DEBUG_5526_2
3652 struct ox_id_els_map *temp_ox_id_list = fi->ox_id_list;
3653 #endif
3654 int count = 0, j;
3655         printk("\nFibre Channel Node Information for %s\n", fi->name);
3656         printk("My FC_ID = %x, My WWN = %x %x, ", fi->g.my_id, fi->g.my_node_name_high, fi->g.my_node_name_low);
3657         if (fi->g.ptp_up == TRUE)
3658                 printk("Port_Type = N_Port\n");
3659         if (fi->g.loop_up == TRUE)
3660                 printk("Port_Type = L_Port\n");
3661         while(q != NULL) {
3662                 printk("WWN = ");
3663                 for (j = 0; j < PORT_NAME_LEN; j++)
3664                         printk("%x ", q->hw_addr[j]);
3665                 printk("FC_ID = %x, ", q->d_id);
3666                 printk("Login = ");
3667                 if (q->login == LOGIN_COMPLETED)
3668                         printk("ON ");
3669                 else
3670                         printk("OFF ");
3671                 if (q->scsi == TARGET)
3672                         printk("Target_ID = %d ", q->target_id);
3673                 printk("\n");
3674                 q = q->next;
3675                 count++;
3676         }
3677
3678 #if DEBUG_5526_2
3679         printk("OX_ID -> ELS Map\n");
3680         while(temp_ox_id_list) {
3681                         printk("ox_id = %x, ELS = %x\n", temp_ox_id_list->ox_id, temp_ox_id_list->els);
3682                         temp_ox_id_list = temp_ox_id_list->next;
3683         }
3684 #endif
3685
3686         return 0;
3687 }
3688
3689 static struct net_device_stats * iph5526_get_stats(struct net_device *dev)
3690 {
3691 struct fc_info *fi = dev->priv;
3692         return (struct net_device_stats *) &fi->fc_stats;
3693 }
3694
3695
3696 /* SCSI stuff starts here */
3697
3698 int iph5526_detect(Scsi_Host_Template *tmpt)
3699 {
3700         struct Scsi_Host *host = NULL;
3701         struct iph5526_hostdata *hostdata;
3702         struct fc_info *fi = NULL;
3703         int no_of_hosts = 0, i, j, count = 0;
3704         u_int pci_maddr = 0;
3705         struct pci_dev *pdev = NULL;
3706         unsigned long timeout;
3707
3708         tmpt->proc_name = "iph5526";
3709
3710         for (i = 0; i <= MAX_FC_CARDS; i++)
3711                 fc[i] = NULL;
3712
3713         for (i = 0; clone_list[i].vendor_id != 0; i++)
3714         while ((pdev = pci_find_device(clone_list[i].vendor_id, clone_list[i].device_id, pdev))) {
3715                 unsigned short pci_command;
3716                 if (pci_enable_device(pdev))
3717                         continue;
3718                 if (count < MAX_FC_CARDS) {
3719                         fc[count] = kmalloc(sizeof(struct fc_info), GFP_ATOMIC);
3720                         if (fc[count] == NULL) {
3721                                 printk("iph5526.c: Unable to register card # %d\n", count + 1);
3722                                 return no_of_hosts;
3723                         }
3724                         memset(fc[count], 0, sizeof(struct fc_info));
3725                 }
3726                 else {
3727                         printk("iph5526.c: Maximum Number of cards reached.\n");
3728                         return no_of_hosts;
3729                 }
3730
3731                 fi = fc[count];
3732                 sprintf(fi->name, "fc%d", count);
3733
3734                 host = scsi_register(tmpt, sizeof(struct iph5526_hostdata));
3735                 if(host==NULL) {
3736                         kfree(fc[count]);
3737                         return no_of_hosts;
3738                 }
3739
3740                 hostdata = (struct iph5526_hostdata *)host->hostdata;
3741                 memset(hostdata, 0 , sizeof(struct iph5526_hostdata));
3742                 for (j = 0; j < MAX_SCSI_TARGETS; j++)
3743                         hostdata->tag_ages[j] = jiffies;
3744                 hostdata->fi = fi;
3745                 fi->host = host;
3746                 //host->max_id = MAX_SCSI_TARGETS;
3747                 host->max_id = 5;
3748                 host->this_id = tmpt->this_id;
3749
3750                 pci_maddr = pci_resource_start(pdev, 0);
3751                 if (pci_resource_flags(pdev, 0) & IORESOURCE_IO) {
3752                         printk("iph5526.c : Cannot find proper PCI device base address.\n");
3753                         scsi_unregister(host);
3754                         kfree(fc[count]);
3755                         fc[count] = NULL;
3756                         continue;
3757                 }
3758
3759                 DPRINTK("pci_maddr = %x", pci_maddr);
3760                 pci_read_config_word(pdev, PCI_COMMAND, &pci_command);
3761
3762                 pci_irq_line = pdev->irq;
3763                 printk("iph5526.c: PCI BIOS reports %s at i/o %#x, irq %d.\n", clone_list[i].name, pci_maddr, pci_irq_line);
3764                 fi->g.mem_base = ioremap(pci_maddr & PAGE_MASK, 1024);
3765
3766                 /* We use Memory Mapped IO. The initial space contains the
3767                  * PCI Configuration registers followed by the (i) chip
3768                  * registers followed by the Tachyon registers.
3769                  */
3770                 /* Thatz where (i)chip maps Tachyon Address Space.
3771                  */
3772                 fi->g.tachyon_base = (u_long)fi->g.mem_base + TACHYON_OFFSET + ( pci_maddr & ~PAGE_MASK );
3773                 DPRINTK("fi->g.tachyon_base = %x", (u_int)fi->g.tachyon_base);
3774                 if (fi->g.mem_base == NULL) {
3775                         printk("iph5526.c : ioremap failed!!!\n");
3776                         scsi_unregister(host);
3777                         kfree(fc[count]);
3778                         fc[count] = NULL;
3779                         continue;
3780                 }
3781                 DPRINTK("IRQ1 = %d\n", pci_irq_line);
3782                 printk(version);
3783                 fi->base_addr = (long) pdev;
3784
3785                 if (pci_irq_line) {
3786                 int irqval = 0;
3787                         /* Found it, get IRQ.
3788                          */
3789                         irqval = request_irq(pci_irq_line, &tachyon_interrupt, pci_irq_line ? SA_SHIRQ : 0, fi->name, host);
3790                         if (irqval) {
3791                                 printk("iph5526.c : Unable to get IRQ %d (irqval = %d).\n", pci_irq_line, irqval);
3792                                 scsi_unregister(host);
3793                                 kfree(fc[count]);
3794                                 fc[count] = NULL;
3795                                 continue;
3796                         }
3797                         host->irq = fi->irq = pci_irq_line;
3798                         pci_irq_line = 0;
3799                         fi->clone_id = clone_list[i].vendor_id;
3800                 }
3801
3802                 if (!initialize_register_pointers(fi) || !tachyon_init(fi)) {
3803                         printk("iph5526.c: TACHYON initialization failed for card # %d!!!\n", count + 1);
3804                         free_irq(host->irq, host);
3805                         scsi_unregister(host);
3806                         if (fi)
3807                                 clean_up_memory(fi);
3808                         kfree(fc[count]);
3809                         fc[count] = NULL;
3810                         break;
3811                 }
3812                 DPRINTK1("Fibre Channel card initialized");
3813                 /* Wait for the Link to come up and the login process
3814                  * to complete.
3815                  */
3816                 for(timeout = jiffies + 10*HZ; time_before(jiffies, timeout) && ((fi->g.link_up == FALSE) || (fi->g.port_discovery == TRUE) || (fi->g.explore_fabric == TRUE) || (fi->g.perform_adisc == TRUE));)
3817                 {
3818                         cpu_relax();
3819                         barrier();
3820                 }
3821
3822                 count++;
3823                 no_of_hosts++;
3824         }
3825         DPRINTK1("no_of_hosts = %d",no_of_hosts);
3826
3827         /* This is to make sure that the ACC to the PRLI comes in
3828          * for the last ALPA.
3829          */
3830         mdelay(1000); /* Ugly! Let the Gods forgive me */
3831
3832         DPRINTK1("leaving iph5526_detect\n");
3833         return no_of_hosts;
3834 }
3835
3836
3837 int iph5526_biosparam(struct scsi_device *sdev, struct block_device *n,
3838                 sector_t capacity, int ip[])
3839 {
3840 int size = capacity;
3841         ip[0] = 64;
3842         ip[1] = 32;
3843         ip[2] = size >> 11;
3844         if (ip[2] > 1024) {
3845                 ip[0] = 255;
3846                 ip[1] = 63;
3847                 ip[2] = size / (ip[0] * ip[1]);
3848         }
3849         return 0;
3850 }
3851
3852 int iph5526_queuecommand(Scsi_Cmnd *Cmnd, void (*done) (Scsi_Cmnd *))
3853 {
3854 int int_required = 0;
3855 u_int r_ctl = FC4_DEVICE_DATA | UNSOLICITED_COMMAND;
3856 u_int type = TYPE_FCP | SEQUENCE_INITIATIVE;
3857 u_int frame_class = Cmnd->device->id;
3858 u_short ox_id = OX_ID_FIRST_SEQUENCE;
3859 struct Scsi_Host *host = Cmnd->device->host;
3860 struct iph5526_hostdata *hostdata = (struct iph5526_hostdata*)host->hostdata;
3861 struct fc_info *fi = hostdata->fi;
3862 struct fc_node_info *q;
3863 u_long flags;
3864         ENTER("iph5526_queuecommand");
3865
3866         spin_lock_irqsave(&fi->fc_lock, flags);
3867         Cmnd->scsi_done = done;
3868
3869         if (Cmnd->device->tagged_supported) {
3870                 switch(Cmnd->tag) {
3871                         case SIMPLE_QUEUE_TAG:
3872                                 hostdata->cmnd.fcp_cntl = FCP_CNTL_QTYPE_SIMPLE;
3873                                 break;
3874                         case HEAD_OF_QUEUE_TAG:
3875                                 hostdata->cmnd.fcp_cntl = FCP_CNTL_QTYPE_HEAD_OF_Q;
3876                                 break;
3877                         case  ORDERED_QUEUE_TAG:
3878                                 hostdata->cmnd.fcp_cntl = FCP_CNTL_QTYPE_ORDERED;
3879                                 break;
3880                         default:
3881                                 if ((jiffies - hostdata->tag_ages[Cmnd->device->id]) > (5 * HZ)) {
3882                                         hostdata->cmnd.fcp_cntl = FCP_CNTL_QTYPE_ORDERED;
3883                                         hostdata->tag_ages[Cmnd->device->id] = jiffies;
3884                                 }
3885                                 else
3886                                         hostdata->cmnd.fcp_cntl = FCP_CNTL_QTYPE_SIMPLE;
3887                                 break;
3888                 }
3889         }
3890         /*else
3891                 hostdata->cmnd.fcp_cntl = FCP_CNTL_QTYPE_UNTAGGED;
3892         */
3893
3894         hostdata->cmnd.fcp_addr[3] = 0;
3895         hostdata->cmnd.fcp_addr[2] = 0;
3896         hostdata->cmnd.fcp_addr[1] = 0;
3897         hostdata->cmnd.fcp_addr[0] = htons(Cmnd->device->lun);
3898
3899         memcpy(&hostdata->cmnd.fcp_cdb, Cmnd->cmnd, Cmnd->cmd_len);
3900         hostdata->cmnd.fcp_data_len = htonl(Cmnd->request_bufflen);
3901
3902         /* Get an used OX_ID. We could have pending commands.
3903          */
3904         if (get_scsi_oxid(fi)) {
3905                 spin_unlock_irqrestore(&fi->fc_lock, flags);
3906                 return 1;
3907         }
3908         fi->q.free_scsi_oxid[fi->g.scsi_oxid] = OXID_INUSE;
3909
3910         /* Maintain a handler so that we can associate the done() function
3911          * on completion of the SCSI command.
3912          */
3913         hostdata->cmnd_handler[fi->g.scsi_oxid] = Cmnd;
3914
3915         switch(Cmnd->cmnd[0]) {
3916                 case WRITE_6:
3917                 case WRITE_10:
3918                 case WRITE_12:
3919                         fi->g.type_of_frame = FC_SCSI_WRITE;
3920                         hostdata->cmnd.fcp_cntl = htonl(FCP_CNTL_WRITE | hostdata->cmnd.fcp_cntl);
3921                         break;
3922                 default:
3923                         fi->g.type_of_frame = FC_SCSI_READ;
3924                         hostdata->cmnd.fcp_cntl = htonl(FCP_CNTL_READ | hostdata->cmnd.fcp_cntl);
3925         }
3926
3927         memcpy(fi->q.ptr_fcp_cmnd[fi->q.fcp_cmnd_indx], &(hostdata->cmnd), sizeof(fcp_cmd));
3928
3929         q = resolve_target(fi, Cmnd->device->id);
3930
3931         if (q == NULL) {
3932         u_int bad_id = fi->g.my_ddaa | 0xFE;
3933                 /* We transmit to an non-existant AL_PA so that the "done"
3934                  * function can be called while receiving the interrupt
3935                  * due to a Timeout for a bad AL_PA. In a PTP configuration,
3936                  * the int_required field is set, since there is no notion
3937                  * of AL_PAs. This approach sucks, but works alright!
3938                  */
3939                 if (fi->g.ptp_up == TRUE)
3940                         int_required = 1;
3941                 tx_exchange(fi, (char *)(&(hostdata->cmnd)), sizeof(fcp_cmd), r_ctl, type, bad_id, fi->g.my_mtu, int_required, ox_id, FC_SCSI_BAD_TARGET);
3942                 spin_unlock_irqrestore(&fi->fc_lock, flags);
3943                 DPRINTK1("Target ID %x not present", Cmnd->target);
3944                 return 0;
3945         }
3946         if (q->login == LOGIN_COMPLETED) {
3947                 if (add_to_sest(fi, Cmnd, q)) {
3948                         DPRINTK1("add_to_sest() failed.");
3949                         spin_unlock_irqrestore(&fi->fc_lock, flags);
3950                         return 0;
3951                 }
3952                 tx_exchange(fi, (char *)(fi->q.ptr_fcp_cmnd[fi->q.fcp_cmnd_indx]), sizeof(fcp_cmd), r_ctl, type, q->d_id, q->mtu, int_required, ox_id, frame_class << 16);
3953                 update_FCP_CMND_indx(fi);
3954         }
3955         spin_unlock_irqrestore(&fi->fc_lock, flags);
3956         /* If q != NULL, then we have a SCSI Target.
3957          * If q->login != LOGIN_COMPLETED, then that device could be
3958          * offline temporarily. So we let the command to time-out.
3959          */
3960         LEAVE("iph5526_queuecommand");
3961         return 0;
3962 }
3963
3964 int iph5526_abort(Scsi_Cmnd *Cmnd)
3965 {
3966 struct Scsi_Host *host = Cmnd->device->host;
3967 struct iph5526_hostdata *hostdata = (struct iph5526_hostdata *)host->hostdata;
3968 struct fc_info *fi = hostdata->fi;
3969 struct fc_node_info *q;
3970 u_int r_ctl = FC4_DEVICE_DATA | UNSOLICITED_COMMAND;
3971 u_int type = TYPE_FCP | SEQUENCE_INITIATIVE;
3972 u_short ox_id = OX_ID_FIRST_SEQUENCE;
3973 int int_required = 1, i, abort_status = FALSE;
3974 u_long flags;
3975
3976         ENTER("iph5526_abort");
3977
3978         spin_lock_irqsave(&fi->fc_lock, flags);
3979
3980         q = resolve_target(fi, Cmnd->device->id);
3981         if (q == NULL) {
3982         u_int bad_id = fi->g.my_ddaa | 0xFE;
3983                 /* This should not happen as we should always be able to
3984                  * resolve a target id. But, jus in case...
3985                  * We transmit to an non-existant AL_PA so that the done
3986                  * function can be called while receiving the interrupt
3987                  * for a bad AL_PA.
3988                  */
3989                 DPRINTK1("Unresolved Target ID!");
3990                 tx_exchange(fi, (char *)(&(hostdata->cmnd)), sizeof(fcp_cmd), r_ctl, type, bad_id, fi->g.my_mtu, int_required, ox_id, FC_SCSI_BAD_TARGET);
3991                 DPRINTK1("Target ID %x not present", Cmnd->target);
3992                 spin_unlock_irqrestore(&fi->fc_lock, flags);
3993                 return FAILED;
3994         }
3995
3996         /* If q != NULL, then we have a SCSI Target. If
3997          * q->login != LOGIN_COMPLETED, then that device could
3998          * be offline temporarily. So we let the command to time-out.
3999          */
4000
4001         /* Get the OX_ID for the Command to be aborted.
4002          */
4003         for (i = 0; i <= MAX_SCSI_XID; i++) {
4004                 if (hostdata->cmnd_handler[i] == Cmnd) {
4005                         hostdata->cmnd_handler[i] = NULL;
4006                         ox_id = i;
4007                         break;
4008                 }
4009         }
4010         if (i > MAX_SCSI_XID) {
4011                 T_MSG("Command could not be resolved to OX_ID");
4012                 spin_unlock_irqrestore(&fi->fc_lock, flags);
4013                 return FAILED;
4014         }
4015
4016         switch(Cmnd->cmnd[0]) {
4017                 case WRITE_6:
4018                 case WRITE_10:
4019                 case WRITE_12:
4020                         break;
4021                 default:
4022                         ox_id |= SCSI_READ_BIT;
4023         }
4024         abort_status = abort_exchange(fi, ox_id);
4025
4026         if ((q->login == LOGIN_COMPLETED) && (abort_status == TRUE)) {
4027                 /* Then, transmit an ABTS to the target. The rest
4028                  * is done when the BA_ACC is received for the ABTS.
4029                  */
4030                 tx_abts(fi, q->d_id, ox_id);
4031         }
4032         else {
4033         u_int STE_bit;
4034         u_short x_id;
4035                 /* Invalidate resources for that Exchange.
4036                  */
4037                 x_id = ox_id & MAX_SCSI_XID;
4038                 STE_bit = ntohl(*fi->q.ptr_sest[x_id]);
4039                 if (STE_bit & SEST_V) {
4040                         *(fi->q.ptr_sest[x_id]) &= htonl(SEST_INV);
4041                         invalidate_SEST_entry(fi, ox_id);
4042                 }
4043         }
4044
4045         LEAVE("iph5526_abort");
4046         spin_unlock_irqrestore(&fi->fc_lock, flags);
4047         return SUCCESS;
4048 }
4049
4050 static int abort_exchange(struct fc_info *fi, u_short ox_id)
4051 {
4052 u_short x_id;
4053 volatile u_int flush_SEST, STE_bit;
4054         x_id = ox_id & MAX_SCSI_XID;
4055         DPRINTK1("Aborting Exchange %x", ox_id);
4056
4057         STE_bit = ntohl(*fi->q.ptr_sest[x_id]);
4058         /* Is the Exchange still active?.
4059          */
4060         if (STE_bit & SEST_V) {
4061                 if (ox_id & SCSI_READ_BIT) {
4062                         /* If the Exchange to be aborted is Inbound,
4063                          * Flush the SEST Entry from Tachyon's Cache.
4064                          */
4065                         *(fi->q.ptr_sest[x_id]) &= htonl(SEST_INV);
4066                         flush_tachyon_cache(fi, ox_id);
4067                         flush_SEST = readl(fi->t_r.ptr_tach_flush_oxid_reg);
4068                         while ((flush_SEST & 0x80000000) != 0)
4069                                 flush_SEST = readl(fi->t_r.ptr_tach_flush_oxid_reg);
4070                         STE_bit = ntohl(*fi->q.ptr_sest[x_id]);
4071                         while ((STE_bit & 0x80000000) != 0)
4072                                 STE_bit = ntohl(*fi->q.ptr_sest[x_id]);
4073                         flush_SEST = readl(fi->t_r.ptr_tach_flush_oxid_reg);
4074                         invalidate_SEST_entry(fi, ox_id);
4075                 }
4076                 else {
4077                 int i;
4078                 u_int *ptr_edb;
4079                         /* For In-Order Reassembly, the following is done:
4080                          * First, write zero as the buffer length in the EDB.
4081                          */
4082                         ptr_edb = bus_to_virt(ntohl(*(fi->q.ptr_sest[x_id] + 7)));
4083                         for (i = 0; i < EDB_LEN; i++)
4084                                 if (fi->q.ptr_edb[i] == ptr_edb)
4085                                         break;
4086                         if (i < EDB_LEN)
4087                                 *ptr_edb = *ptr_edb & 0x0000FFFF;
4088                         else
4089                                 T_MSG("EDB not found while clearing in abort_exchange()");
4090                 }
4091                 DPRINTK1("Exchange %x invalidated", ox_id);
4092                 return TRUE;
4093         }
4094         else {
4095                 DPRINTK1("SEST Entry for exchange %x not valid", ox_id);
4096                 return FALSE;
4097         }
4098 }
4099
4100 static void flush_tachyon_cache(struct fc_info *fi, u_short ox_id)
4101 {
4102 volatile u_int tachyon_status;
4103         if (fi->g.loop_up == TRUE) {
4104                 writel(HOST_CONTROL, fi->t_r.ptr_fm_control_reg);
4105                 /* Make sure that the Inbound FIFO is empty.
4106                  */
4107                 do {
4108                         tachyon_status = readl(fi->t_r.ptr_tach_status_reg);
4109                         udelay(200);
4110                 }while ((tachyon_status & RECEIVE_FIFO_EMPTY) == 0);
4111                 /* Ok. Go ahead and flushhhhhhhhh!
4112                  */
4113                 writel(0x80000000 | ox_id, fi->t_r.ptr_tach_flush_oxid_reg);
4114                 writel(EXIT_HOST_CONTROL, fi->t_r.ptr_fm_control_reg);
4115                 return;
4116         }
4117         if (fi->g.ptp_up == TRUE) {
4118                 take_tachyon_offline(fi);
4119                 /* Make sure that the Inbound FIFO is empty.
4120                  */
4121                 do {
4122                         tachyon_status = readl(fi->t_r.ptr_tach_status_reg);
4123                         udelay(200);
4124                 }while ((tachyon_status & RECEIVE_FIFO_EMPTY) == 0);
4125                 writel(0x80000000 | ox_id, fi->t_r.ptr_tach_flush_oxid_reg);
4126                 /* Write the Initialize command to the FM Control reg.
4127                  */
4128                 fi->g.n_port_try = TRUE;
4129                 DPRINTK1("In abort_exchange, TACHYON initializing as N_Port...\n");
4130                 writel(INITIALIZE, fi->t_r.ptr_fm_control_reg);
4131         }
4132 }
4133
4134 static struct fc_node_info *resolve_target(struct fc_info *fi, u_char target)
4135 {
4136 struct fc_node_info *temp = fi->node_info_list;
4137         while(temp != NULL)
4138                 if (temp->target_id == target) {
4139                         if ((temp->scsi == TARGET) && (temp->login == LOGIN_COMPLETED))
4140                                 return temp;
4141                         else {
4142                                 if (temp->login != LOGIN_COMPLETED) {
4143                                         /* The Target is not currently logged in.
4144                                          * It could be a Target on the Local Loop or
4145                                          * on a Remote Loop connected through a switch.
4146                                          * In either case, we will know whenever the Target
4147                                          * comes On-Line again. We let the command to
4148                                          * time-out so that it gets retried.
4149                                          */
4150                                         T_MSG("Target %d not logged in.", temp->target_id);
4151                                         tx_logi(fi, ELS_PLOGI, temp->d_id);
4152                                         return temp;
4153                                 }
4154                                 else {
4155                                         if (temp->scsi != TARGET) {
4156                                                 /* For some reason, we did not get a response to
4157                                                  * PRLI. Letz try it again...
4158                                                  */
4159                                                 DPRINTK1("Node not PRLIied. Txing PRLI...");
4160                                                 tx_prli(fi, ELS_PRLI, temp->d_id, OX_ID_FIRST_SEQUENCE);
4161                                         }
4162                                 }
4163                                 return temp;
4164                         }
4165                 }
4166                 else
4167                         temp = temp->next;
4168         return NULL;
4169 }
4170
4171 static int add_to_sest(struct fc_info *fi, Scsi_Cmnd *Cmnd, struct fc_node_info *ni)
4172 {
4173 /* we have at least 1 buffer, the terminator */
4174 int no_of_sdb_buffers = 1, i;
4175 int no_of_edb_buffers = 0;
4176 u_int *req_buffer = (u_int *)Cmnd->request_buffer;
4177 u_int *ptr_sdb = NULL;
4178 struct scatterlist *sl1, *sl2 = NULL;
4179 int no_of_sg = 0;
4180
4181         switch(fi->g.type_of_frame) {
4182                 case FC_SCSI_READ:
4183                         fi->g.inb_sest_entry.flags_and_byte_offset = htonl(INB_SEST_VED);
4184                         fi->g.inb_sest_entry.byte_count = 0;
4185                         fi->g.inb_sest_entry.no_of_recvd_frames = 0;
4186                         fi->g.inb_sest_entry.no_of_expected_frames = 0;
4187                         fi->g.inb_sest_entry.last_fctl = 0;
4188
4189                         if (Cmnd->use_sg) {
4190                                 no_of_sg = Cmnd->use_sg;
4191                                 sl1 = sl2 = (struct scatterlist *)Cmnd->request_buffer;
4192                                 for (i = 0; i < no_of_sg; i++) {
4193                                         no_of_sdb_buffers += sl1->length / SEST_BUFFER_SIZE;
4194                                         if (sl1->length % SEST_BUFFER_SIZE)
4195                                                 no_of_sdb_buffers++;
4196                                         sl1++;
4197                                 }
4198                         }
4199                         else {
4200                                 no_of_sdb_buffers += Cmnd->request_bufflen / SEST_BUFFER_SIZE;
4201                                 if (Cmnd->request_bufflen % SEST_BUFFER_SIZE)
4202                                         no_of_sdb_buffers++;
4203                         } /* if !use_sg */
4204
4205                         /* We are working with the premise that at the max we would
4206                          * get a scatter-gather buffer containing 63 buffers
4207                          * of size 1024 bytes each. Is it a _bad_ assumption?
4208                          */
4209                         if (no_of_sdb_buffers > 512) {
4210                                 T_MSG("Number of SDB buffers needed = %d", no_of_sdb_buffers);
4211                                 T_MSG("Disable Scatter-Gather!!!");
4212                                 return 1;
4213                         }
4214
4215
4216                         /* Store it in the sdb_table so that we can retrieve that
4217                          * free up the memory when the Read Command completes.
4218                          */
4219                         if (get_free_SDB(fi))
4220                                 return 1;
4221                         ptr_sdb = fi->q.ptr_sdb_slot[fi->q.sdb_indx];
4222                         fi->q.sdb_slot_status[fi->q.sdb_indx] = SDB_BUSY;
4223                         fi->g.inb_sest_entry.sdb_address = htonl(virt_to_bus(ptr_sdb));
4224
4225                         if (Cmnd->use_sg) {
4226                         int count = 0, j;
4227                                 for(i = 0; i < no_of_sg; i++) {
4228                                 char *addr_ptr = sl2->address;
4229                                         count = sl2->length / SEST_BUFFER_SIZE;
4230                                         if (sl2->length % SEST_BUFFER_SIZE)
4231                                                 count++;
4232                                         for (j = 0; j < count; j++) {
4233                                                 *(ptr_sdb) = htonl(virt_to_bus(addr_ptr));
4234                                                 addr_ptr += SEST_BUFFER_SIZE;
4235                                                 ptr_sdb++;
4236                                         }
4237                                         count = 0;
4238                                         sl2++;
4239                                 }
4240                         }
4241                         else {
4242                                 for (i = 0; i < no_of_sdb_buffers - 1; i++) {
4243                                         *(ptr_sdb) = htonl(virt_to_bus(req_buffer));
4244                                         req_buffer += SEST_BUFFER_SIZE/4;
4245                                         ptr_sdb++;
4246                                 }
4247                         }
4248                         *(ptr_sdb) = htonl(0x1); /* Terminator */
4249
4250                         /* The scratch pad is used to hold the index into the SDB.
4251                          */
4252                         fi->g.inb_sest_entry.scratch_pad = fi->q.sdb_indx;
4253                         fi->g.inb_sest_entry.expected_ro = 0;
4254                         fi->g.inb_sest_entry.buffer_index = 0;
4255                         fi->g.inb_sest_entry.buffer_offset = 0;
4256                         memcpy(fi->q.ptr_sest[fi->g.scsi_oxid], &fi->g.inb_sest_entry, sizeof(INB_SEST_ENTRY));
4257                         break;
4258                 case FC_SCSI_WRITE:
4259                         fi->g.outb_sest_entry.flags_and_did = htonl(OUTB_SEST_VED | ni->d_id);
4260                         fi->g.outb_sest_entry.max_frame_len = htons(ni->mtu << 4);
4261                         fi->g.outb_sest_entry.cntl = htons(ODB_CLASS_3 | ODB_EE_CREDIT | ODB_NO_INT | ODB_NO_COMP);
4262                         fi->g.outb_sest_entry.total_seq_length = INV_SEQ_LEN;
4263                         fi->g.outb_sest_entry.link = htons(OUTB_SEST_LINK);
4264                         fi->g.outb_sest_entry.transaction_id = htonl(fi->g.scsi_oxid);
4265                         fi->g.outb_sest_entry.seq_id = fi->g.seq_id;
4266                         fi->g.outb_sest_entry.reserved = 0x0;
4267                         fi->g.outb_sest_entry.header_length = htons(TACHYON_HEADER_LEN);
4268
4269                         {
4270                         u_char df_ctl = 0;
4271                         u_short rx_id = RX_ID_FIRST_SEQUENCE;
4272                         u_int r_ctl = FC4_DEVICE_DATA | SOLICITED_DATA;
4273                         u_int type = TYPE_FCP | SEQUENCE_INITIATIVE;
4274                                 /* Multi Frame Sequence ? If yes, set RO bit.
4275                                  */
4276                                 if (Cmnd->request_bufflen > ni->mtu)
4277                                         type |= RELATIVE_OFF_PRESENT;
4278                                 build_tachyon_header(fi, fi->g.my_id, r_ctl, ni->d_id, type, fi->g.seq_id, df_ctl, fi->g.scsi_oxid, rx_id, NULL);
4279                                 if (get_free_header(fi) || get_free_EDB(fi))
4280                                         return 1;
4281                                 memcpy(fi->q.ptr_tachyon_header[fi->q.tachyon_header_indx], &(fi->g.tach_header), TACHYON_HEADER_LEN);
4282                                 fi->g.outb_sest_entry.header_address = htonl(virt_to_bus(fi->q.ptr_tachyon_header[fi->q.tachyon_header_indx]));
4283                                 update_tachyon_header_indx(fi);
4284                         }
4285
4286                         if (Cmnd->use_sg) {
4287                                 no_of_sg = Cmnd->use_sg;
4288                                 sl1 = sl2 = (struct scatterlist *)Cmnd->request_buffer;
4289                                 for (i = 0; i < no_of_sg; i++) {
4290                                         no_of_edb_buffers += sl1->length / SEST_BUFFER_SIZE;
4291                                         if (sl1->length % SEST_BUFFER_SIZE)
4292                                                 no_of_edb_buffers++;
4293                                         sl1++;
4294                                 }
4295                         }
4296                         else {
4297                                 no_of_edb_buffers += Cmnd->request_bufflen / SEST_BUFFER_SIZE;
4298                                 if (Cmnd->request_bufflen % SEST_BUFFER_SIZE)
4299                                         no_of_edb_buffers++;
4300                         } /* if !use_sg */
4301
4302
4303                         /* We need "no_of_edb_buffers" _contiguous_ EDBs
4304                          * that are FREE. Check for that first.
4305                          */
4306                         for (i = 0; i < no_of_edb_buffers; i++) {
4307                         int j;
4308                                 if ((fi->q.edb_buffer_indx + no_of_edb_buffers) >= EDB_LEN)
4309                                         fi->q.edb_buffer_indx = 0;
4310                                 if (fi->q.free_edb_list[fi->q.edb_buffer_indx + i] != EDB_FREE) {
4311                                         for (j = 0; j < i; j++)
4312                                                 update_EDB_indx(fi);
4313                                         if (get_free_EDB(fi))
4314                                                 return 1;
4315                                         i = 0;
4316                                 }
4317                         }
4318
4319                         /* We got enuff FREE EDBs.
4320                          */
4321                         if (Cmnd->use_sg) {
4322                                 fi->g.outb_sest_entry.edb_address = htonl(virt_to_bus(fi->q.ptr_edb[fi->q.edb_buffer_indx]));
4323                                 sl1 = (struct scatterlist *)Cmnd->request_buffer;
4324                                 for(i = 0; i < no_of_sg; i++) {
4325                                 int count = 0, j;
4326                                         count = sl1->length / SEST_BUFFER_SIZE;
4327                                         for (j = 0; j < count; j++) {
4328                                                 build_EDB(fi, (char *)sl1->address, 0, SEST_BUFFER_SIZE);
4329                                                 memcpy(fi->q.ptr_edb[fi->q.edb_buffer_indx], &(fi->g.edb), sizeof(EDB));
4330                                                 /* Mark this EDB as being in use */
4331                                                 fi->q.free_edb_list[fi->q.edb_buffer_indx] = EDB_BUSY;
4332                                                 /* We have already made sure that we have enuff
4333                                                  * free EDBs that are contiguous. So this is
4334                                                  * safe.
4335                                                  */
4336                                                 update_EDB_indx(fi);
4337                                                 sl1->address += SEST_BUFFER_SIZE;
4338                                         }
4339                                         /* Just in case itz not a multiple of
4340                                          * SEST_BUFFER_SIZE bytes.
4341                                          */
4342                                         if (sl1->length % SEST_BUFFER_SIZE) {
4343                                                 build_EDB(fi, (char *)sl1->address, 0, sl1->length % SEST_BUFFER_SIZE);
4344                                                 memcpy(fi->q.ptr_edb[fi->q.edb_buffer_indx], &(fi->g.edb), sizeof(EDB));
4345                                                 fi->q.free_edb_list[fi->q.edb_buffer_indx] = EDB_BUSY;
4346                                                 update_EDB_indx(fi);
4347                                         }
4348                                         sl1++;
4349                                 }
4350                                 /* The last EDB is special. It needs the "end bit" to
4351                                  * be set.
4352                                  */
4353                                 *(fi->q.ptr_edb[fi->q.edb_buffer_indx - 1] + 1) = *(fi->q.ptr_edb[fi->q.edb_buffer_indx - 1] + 1) | ntohs(EDB_END);
4354                         }
4355                         else {
4356                         int count = 0, j;
4357                                 fi->g.outb_sest_entry.edb_address = htonl(virt_to_bus(fi->q.ptr_edb[fi->q.edb_buffer_indx]));
4358                                 count = Cmnd->request_bufflen / SEST_BUFFER_SIZE;
4359                                 for (j = 0; j < count; j++) {
4360                                         build_EDB(fi, (char *)req_buffer, 0, SEST_BUFFER_SIZE);
4361                                         memcpy(fi->q.ptr_edb[fi->q.edb_buffer_indx], &(fi->g.edb), sizeof(EDB));
4362                                         /* Mark this EDB as being in use */
4363                                         fi->q.free_edb_list[fi->q.edb_buffer_indx] = EDB_BUSY;
4364                                         /* We have already made sure that we have enuff
4365                                          * free EDBs that are contiguous. So this is
4366                                          * safe.
4367                                          */
4368                                         update_EDB_indx(fi);
4369                                         req_buffer += SEST_BUFFER_SIZE;
4370                                 }
4371                                 /* Just in case itz not a multiple of
4372                                  * SEST_BUFFER_SIZE bytes.
4373                                  */
4374                                 if (Cmnd->request_bufflen % SEST_BUFFER_SIZE) {
4375                                         build_EDB(fi, (char *)req_buffer, EDB_END, Cmnd->request_bufflen % SEST_BUFFER_SIZE);
4376                                         memcpy(fi->q.ptr_edb[fi->q.edb_buffer_indx], &(fi->g.edb), sizeof(EDB));
4377                                         fi->q.free_edb_list[fi->q.edb_buffer_indx] = EDB_BUSY;
4378                                         update_EDB_indx(fi);
4379                                 }
4380                                 else {
4381                                         /* Mark the last EDB as the "end edb".
4382                                          */
4383                                         *(fi->q.ptr_edb[fi->q.edb_buffer_indx - 1] + 1) = *(fi->q.ptr_edb[fi->q.edb_buffer_indx - 1] + 1) | htons(EDB_END);
4384                                 }
4385                         }
4386
4387                         /* Finally we have something to send!.
4388                          */
4389                         memcpy(fi->q.ptr_sest[fi->g.scsi_oxid], &fi->g.outb_sest_entry, sizeof(OUTB_SEST_ENTRY));
4390                         break;
4391                 }
4392         return 0;
4393 }
4394
4395 static void update_FCP_CMND_indx(struct fc_info *fi)
4396 {
4397         fi->q.fcp_cmnd_indx++;
4398         if (fi->q.fcp_cmnd_indx == NO_OF_FCP_CMNDS)
4399                 fi->q.fcp_cmnd_indx = 0;
4400 }
4401
4402 static int get_scsi_oxid(struct fc_info *fi)
4403 {
4404 u_short initial_oxid = fi->g.scsi_oxid;
4405         /* Check if the OX_ID is in use.
4406          * We could have an outstanding SCSI command.
4407          */
4408         while (fi->q.free_scsi_oxid[fi->g.scsi_oxid] != OXID_AVAILABLE) {
4409                 update_scsi_oxid(fi);
4410                 if (fi->g.scsi_oxid == initial_oxid) {
4411                         T_MSG("No free OX_IDs avaliable")
4412                         reset_tachyon(fi, SOFTWARE_RESET);
4413                         return 1;
4414                 }
4415         }
4416         return 0;
4417 }
4418
4419 static void update_scsi_oxid(struct fc_info *fi)
4420 {
4421         fi->g.scsi_oxid++;
4422         if (fi->g.scsi_oxid == (MAX_SCSI_XID + 1))
4423                 fi->g.scsi_oxid = 0;
4424 }
4425
4426 static int get_free_SDB(struct fc_info *fi)
4427 {
4428 unsigned int initial_indx = fi->q.sdb_indx;
4429         /* Check if the SDB is in use.
4430          * We could have an outstanding SCSI Read command.
4431          * We should find a free slot as we can queue a
4432          * maximum of 32 SCSI commands only.
4433          */
4434         while (fi->q.sdb_slot_status[fi->q.sdb_indx] != SDB_FREE) {
4435                 update_SDB_indx(fi);
4436                 if (fi->q.sdb_indx == initial_indx) {
4437                         T_MSG("No free SDB buffers avaliable")
4438                         reset_tachyon(fi, SOFTWARE_RESET);
4439                         return 1;
4440                 }
4441         }
4442         return 0;
4443 }
4444
4445 static void update_SDB_indx(struct fc_info *fi)
4446 {
4447         fi->q.sdb_indx++;
4448         if (fi->q.sdb_indx == NO_OF_SDB_ENTRIES)
4449                 fi->q.sdb_indx = 0;
4450 }
4451
4452 int iph5526_release(struct Scsi_Host *host)
4453 {
4454 struct iph5526_hostdata *hostdata = (struct iph5526_hostdata*)host->hostdata;
4455 struct fc_info *fi = hostdata->fi;
4456         free_irq(host->irq, host);
4457         iounmap(fi->g.mem_base);
4458         return 0;
4459 }
4460
4461 const char *iph5526_info(struct Scsi_Host *host)
4462 {
4463 static char buf[80];
4464         sprintf(buf, "Interphase 5526 Fibre Channel PCI SCSI Adapter using IRQ %d\n", host->irq);
4465         return buf;
4466 }
4467
4468 #define NAMELEN         8       /* # of chars for storing dev->name */
4469
4470 static struct net_device *dev_fc[MAX_FC_CARDS];
4471
4472 static int io;
4473 static int irq;
4474 static int bad; /* 0xbad = bad sig or no reset ack */
4475 static int scsi_registered;
4476
4477
4478 static int __init iph5526_init(void)
4479 {
4480         int i = 0;
4481
4482         driver_template.module = THIS_MODULE;
4483         scsi_register_host(&driver_template);
4484         if (driver_template.present)
4485                 scsi_registered = TRUE;
4486         else {
4487                 printk("iph5526: SCSI registeration failed!!!\n");
4488                 scsi_registered = FALSE;
4489                 scsi_unregister_host(&driver_template);
4490         }
4491
4492         while(fc[i] != NULL) {
4493                 struct net_device *dev = alloc_fcdev(0);
4494                 int err;
4495
4496                 if (!dev) {
4497                         printk("iph5526.c: init_fcdev failed for card #%d\n", i+1);
4498                         break;
4499                 }
4500                 dev->priv = fc[i];
4501                 iph5526_probe_pci(dev);
4502                 err = register_netdev(dev);
4503                 if (err < 0) {
4504                         free_netdev(dev);
4505                         printk("iph5526.c: init_fcdev failed for card #%d\n", i+1);
4506                         break;
4507                 }
4508                 dev_fc[i] = dev;
4509                 i++;
4510         }
4511         if (i == 0)
4512                 return -ENODEV;
4513
4514         return 0;
4515 }
4516
4517 static void __exit iph5526_exit(void)
4518 {
4519         int i = 0;
4520         while(fc[i] != NULL) {
4521                 struct net_device *dev = fc[i]->dev;
4522                 void *priv = dev->priv;
4523                 fc[i]->g.dont_init = TRUE;
4524                 take_tachyon_offline(fc[i]);
4525                 unregister_netdev(dev);
4526                 clean_up_memory(fc[i]);
4527                 if (dev->priv)
4528                         kfree(priv);
4529                 free_netdev(dev);
4530                 dev = NULL;
4531                 i++;
4532         }
4533         if (scsi_registered == TRUE)
4534                 scsi_unregister_host(&driver_template);
4535 }
4536
4537 module_init(iph5526_init);
4538 module_exit(iph5526_exit);
4539
4540 void clean_up_memory(struct fc_info *fi)
4541 {
4542 int i,j;
4543         ENTER("clean_up_memory");
4544         if (fi->q.ptr_mfsbq_base)
4545                 free_pages((u_long)bus_to_virt(ntohl(*(fi->q.ptr_mfsbq_base))), 5);
4546         DPRINTK("after kfree2");
4547         for (i = 0; i < SFSBQ_LENGTH; i++)
4548                 for (j = 0; j < NO_OF_ENTRIES; j++)
4549                         if (fi->q.ptr_sfs_buffers[i*NO_OF_ENTRIES + j])
4550                                 kfree(fi->q.ptr_sfs_buffers[i*NO_OF_ENTRIES + j]);
4551         DPRINTK("after kfree1");
4552         if (fi->q.ptr_ocq_base)
4553                 free_page((u_long)fi->q.ptr_ocq_base);
4554         if (fi->q.ptr_imq_base)
4555                 free_page((u_long)fi->q.ptr_imq_base);
4556         if (fi->q.ptr_mfsbq_base)
4557                 free_page((u_long)fi->q.ptr_mfsbq_base);
4558         if (fi->q.ptr_sfsbq_base)
4559                 free_page((u_long)fi->q.ptr_sfsbq_base);
4560         if (fi->q.ptr_edb_base)
4561                 free_pages((u_long)fi->q.ptr_edb_base, 5);
4562         if (fi->q.ptr_sest_base)
4563                 free_pages((u_long)fi->q.ptr_sest_base, 5);
4564         if (fi->q.ptr_tachyon_header_base)
4565                 free_page((u_long)fi->q.ptr_tachyon_header_base);
4566         if (fi->q.ptr_sdb_base)
4567                 free_pages((u_long)fi->q.ptr_sdb_base, 5);
4568         if (fi->q.ptr_fcp_cmnd_base)
4569                 free_page((u_long)fi->q.ptr_fcp_cmnd_base);
4570         DPRINTK("after free_pages");
4571         if (fi->q.ptr_host_ocq_cons_indx)
4572                 kfree(fi->q.ptr_host_ocq_cons_indx);
4573         if (fi->q.ptr_host_hpcq_cons_indx)
4574                 kfree(fi->q.ptr_host_hpcq_cons_indx);
4575         if (fi->q.ptr_host_imq_prod_indx)
4576                 kfree(fi->q.ptr_host_imq_prod_indx);
4577         DPRINTK("after kfree3");
4578         while (fi->node_info_list) {
4579         struct fc_node_info *temp_list = fi->node_info_list;
4580                 fi->node_info_list = fi->node_info_list->next;
4581                 kfree(temp_list);
4582         }
4583         while (fi->ox_id_list) {
4584         struct ox_id_els_map *temp = fi->ox_id_list;
4585                 fi->ox_id_list = fi->ox_id_list->next;
4586                 kfree(temp);
4587         }
4588         LEAVE("clean_up_memory");
4589 }
4590
4591 static int initialize_register_pointers(struct fc_info *fi)
4592 {
4593 ENTER("initialize_register_pointers");
4594 if(fi->g.tachyon_base == 0)
4595         return -ENOMEM;
4596
4597 fi->i_r.ptr_ichip_hw_control_reg        = ICHIP_HW_CONTROL_REG_OFF + fi->g.tachyon_base;
4598 fi->i_r.ptr_ichip_hw_status_reg = ICHIP_HW_STATUS_REG_OFF + fi->g.tachyon_base;
4599 fi->i_r.ptr_ichip_hw_addr_mask_reg = ICHIP_HW_ADDR_MASK_REG_OFF + fi->g.tachyon_base;
4600 fi->t_r.ptr_ocq_base_reg = OCQ_BASE_REGISTER_OFFSET + fi->g.tachyon_base;
4601 fi->t_r.ptr_ocq_len_reg = OCQ_LENGTH_REGISTER_OFFSET + fi->g.tachyon_base;
4602 fi->t_r.ptr_ocq_prod_indx_reg = OCQ_PRODUCER_REGISTER_OFFSET + fi->g.tachyon_base;
4603 fi->t_r.ptr_ocq_cons_indx_reg = OCQ_CONSUMER_REGISTER_OFFSET + fi->g.tachyon_base;
4604 fi->t_r.ptr_imq_base_reg = IMQ_BASE_REGISTER_OFFSET + fi->g.tachyon_base;
4605 fi->t_r.ptr_imq_len_reg = IMQ_LENGTH_REGISTER_OFFSET + fi->g.tachyon_base;
4606 fi->t_r.ptr_imq_cons_indx_reg = IMQ_CONSUMER_REGISTER_OFFSET + fi->g.tachyon_base;
4607 fi->t_r.ptr_imq_prod_indx_reg = IMQ_PRODUCER_REGISTER_OFFSET + fi->g.tachyon_base;
4608 fi->t_r.ptr_mfsbq_base_reg = MFSBQ_BASE_REGISTER_OFFSET + fi->g.tachyon_base;
4609 fi->t_r.ptr_mfsbq_len_reg = MFSBQ_LENGTH_REGISTER_OFFSET + fi->g.tachyon_base;
4610 fi->t_r.ptr_mfsbq_prod_reg = MFSBQ_PRODUCER_REGISTER_OFFSET + fi->g.tachyon_base;
4611 fi->t_r.ptr_mfsbq_cons_reg = MFSBQ_CONSUMER_REGISTER_OFFSET + fi->g.tachyon_base;
4612 fi->t_r.ptr_mfsbuff_len_reg = MFS_LENGTH_REGISTER_OFFSET + fi->g.tachyon_base;
4613 fi->t_r.ptr_sfsbq_base_reg = SFSBQ_BASE_REGISTER_OFFSET + fi->g.tachyon_base;
4614 fi->t_r.ptr_sfsbq_len_reg = SFSBQ_LENGTH_REGISTER_OFFSET + fi->g.tachyon_base;
4615 fi->t_r.ptr_sfsbq_prod_reg = SFSBQ_PRODUCER_REGISTER_OFFSET + fi->g.tachyon_base;
4616 fi->t_r.ptr_sfsbq_cons_reg = SFSBQ_CONSUMER_REGISTER_OFFSET + fi->g.tachyon_base;
4617 fi->t_r.ptr_sfsbuff_len_reg = SFS_LENGTH_REGISTER_OFFSET + fi->g.tachyon_base;
4618 fi->t_r.ptr_sest_base_reg = SEST_BASE_REGISTER_OFFSET + fi->g.tachyon_base;
4619 fi->t_r.ptr_sest_len_reg = SEST_LENGTH_REGISTER_OFFSET + fi->g.tachyon_base;
4620 fi->t_r.ptr_scsibuff_len_reg = SCSI_LENGTH_REGISTER_OFFSET + fi->g.tachyon_base;
4621 fi->t_r.ptr_tach_config_reg = TACHYON_CONFIG_REGISTER_OFFSET + fi->g.tachyon_base;
4622 fi->t_r.ptr_tach_control_reg = TACHYON_CONTROL_REGISTER_OFFSET + fi->g.tachyon_base;
4623 fi->t_r.ptr_tach_status_reg = TACHYON_STATUS_REGISTER_OFFSET + fi->g.tachyon_base;
4624 fi->t_r.ptr_tach_flush_oxid_reg = TACHYON_FLUSH_SEST_REGISTER_OFFSET + fi->g.tachyon_base;
4625 fi->t_r.ptr_fm_config_reg = FMGR_CONFIG_REGISTER_OFFSET + fi->g.tachyon_base;
4626 fi->t_r.ptr_fm_control_reg = FMGR_CONTROL_REGISTER_OFFSET + fi->g.tachyon_base;
4627 fi->t_r.ptr_fm_status_reg = FMGR_STATUS_REGISTER_OFFSET + fi->g.tachyon_base;
4628 fi->t_r.ptr_fm_tov_reg = FMGR_TIMER_REGISTER_OFFSET + fi->g.tachyon_base;
4629 fi->t_r.ptr_fm_wwn_hi_reg = FMGR_WWN_HI_REGISTER_OFFSET + fi->g.tachyon_base;
4630 fi->t_r.ptr_fm_wwn_low_reg = FMGR_WWN_LO_REGISTER_OFFSET + fi->g.tachyon_base;
4631 fi->t_r.ptr_fm_rx_al_pa_reg = FMGR_RCVD_ALPA_REGISTER_OFFSET + fi->g.tachyon_base;
4632
4633 LEAVE("initialize_register_pointers");
4634 return 1;
4635 }
4636
4637
4638
4639 /*
4640  * Local variables:
4641  *  compile-command: "gcc -DKERNEL -Wall -O6 -fomit-frame-pointer -I/usr/src/linux/net/tcp -c iph5526.c"
4642  *  version-control: t
4643  *  kept-new-versions: 5
4644  * End:
4645  */