drivers/scsi/qla4xxx/ql4_83xx.c

   1 /*
   2  * QLogic iSCSI HBA Driver
   3  * Copyright (c)   2003-2013 QLogic Corporation
   4  *
   5  * See LICENSE.qla4xxx for copyright and licensing details.
   6  */
   7
   8 #include <linux/ratelimit.h>
   9
  10 #include "ql4_def.h"
  11 #include "ql4_version.h"
  12 #include "ql4_glbl.h"
  13 #include "ql4_dbg.h"
  14 #include "ql4_inline.h"
  15
  16 uint32_t qla4_83xx_rd_reg(struct scsi_qla_host *ha, ulong addr)
  17 {
  18         return readl((void __iomem *)(ha->nx_pcibase + addr));
  19 }
  20
  21 void qla4_83xx_wr_reg(struct scsi_qla_host *ha, ulong addr, uint32_t val)
  22 {
  23         writel(val, (void __iomem *)(ha->nx_pcibase + addr));
  24 }
  25
  26 static int qla4_83xx_set_win_base(struct scsi_qla_host *ha, uint32_t addr)
  27 {
  28         uint32_t val;
  29         int ret_val = QLA_SUCCESS;
  30
  31         qla4_83xx_wr_reg(ha, QLA83XX_CRB_WIN_FUNC(ha->func_num), addr);
  32         val = qla4_83xx_rd_reg(ha, QLA83XX_CRB_WIN_FUNC(ha->func_num));
  33         if (val != addr) {
  34                 ql4_printk(KERN_ERR, ha, "%s: Failed to set register window : addr written 0x%x, read 0x%x!\n",
  35                            __func__, addr, val);
  36                 ret_val = QLA_ERROR;
  37         }
  38
  39         return ret_val;
  40 }
  41
  42 int qla4_83xx_rd_reg_indirect(struct scsi_qla_host *ha, uint32_t addr,
  43                               uint32_t *data)
  44 {
  45         int ret_val;
  46
  47         ret_val = qla4_83xx_set_win_base(ha, addr);
  48
  49         if (ret_val == QLA_SUCCESS)
  50                 *data = qla4_83xx_rd_reg(ha, QLA83XX_WILDCARD);
  51         else
  52                 ql4_printk(KERN_ERR, ha, "%s: failed read of addr 0x%x!\n",
  53                            __func__, addr);
  54
  55         return ret_val;
  56 }
  57
  58 int qla4_83xx_wr_reg_indirect(struct scsi_qla_host *ha, uint32_t addr,
  59                               uint32_t data)
  60 {
  61         int ret_val;
  62
  63         ret_val = qla4_83xx_set_win_base(ha, addr);
  64
  65         if (ret_val == QLA_SUCCESS)
  66                 qla4_83xx_wr_reg(ha, QLA83XX_WILDCARD, data);
  67         else
  68                 ql4_printk(KERN_ERR, ha, "%s: failed wrt to addr 0x%x, data 0x%x\n",
  69                            __func__, addr, data);
  70
  71         return ret_val;
  72 }
  73
  74 static int qla4_83xx_flash_lock(struct scsi_qla_host *ha)
  75 {
  76         int lock_owner;
  77         int timeout = 0;
  78         uint32_t lock_status = 0;
  79         int ret_val = QLA_SUCCESS;
  80
  81         while (lock_status == 0) {
  82                 lock_status = qla4_83xx_rd_reg(ha, QLA83XX_FLASH_LOCK);
  83                 if (lock_status)
  84                         break;
  85
  86                 if (++timeout >= QLA83XX_FLASH_LOCK_TIMEOUT / 20) {
  87                         lock_owner = qla4_83xx_rd_reg(ha,
  88                                                       QLA83XX_FLASH_LOCK_ID);
  89                         ql4_printk(KERN_ERR, ha, "%s: flash lock by func %d failed, held by func %d\n",
  90                                    __func__, ha->func_num, lock_owner);
  91                         ret_val = QLA_ERROR;
  92                         break;
  93                 }
  94                 msleep(20);
  95         }
  96
  97         qla4_83xx_wr_reg(ha, QLA83XX_FLASH_LOCK_ID, ha->func_num);
  98         return ret_val;
  99 }
 100
 101 static void qla4_83xx_flash_unlock(struct scsi_qla_host *ha)
 102 {
 103         /* Reading FLASH_UNLOCK register unlocks the Flash */
 104         qla4_83xx_wr_reg(ha, QLA83XX_FLASH_LOCK_ID, 0xFF);
 105         qla4_83xx_rd_reg(ha, QLA83XX_FLASH_UNLOCK);
 106 }
 107
 108 int qla4_83xx_flash_read_u32(struct scsi_qla_host *ha, uint32_t flash_addr,
 109                              uint8_t *p_data, int u32_word_count)
 110 {
 111         int i;
 112         uint32_t u32_word;
 113         uint32_t addr = flash_addr;
 114         int ret_val = QLA_SUCCESS;
 115
 116         ret_val = qla4_83xx_flash_lock(ha);
 117         if (ret_val == QLA_ERROR)
 118                 goto exit_lock_error;
 119
 120         if (addr & 0x03) {
 121                 ql4_printk(KERN_ERR, ha, "%s: Illegal addr = 0x%x\n",
 122                            __func__, addr);
 123                 ret_val = QLA_ERROR;
 124                 goto exit_flash_read;
 125         }
 126
 127         for (i = 0; i < u32_word_count; i++) {
 128                 ret_val = qla4_83xx_wr_reg_indirect(ha,
 129                                                     QLA83XX_FLASH_DIRECT_WINDOW,
 130                                                     (addr & 0xFFFF0000));
 131                 if (ret_val == QLA_ERROR) {
 132                         ql4_printk(KERN_ERR, ha, "%s: failed to write addr 0x%x to FLASH_DIRECT_WINDOW\n!",
 133                                    __func__, addr);
 134                         goto exit_flash_read;
 135                 }
 136
 137                 ret_val = qla4_83xx_rd_reg_indirect(ha,
 138                                                 QLA83XX_FLASH_DIRECT_DATA(addr),
 139                                                 &u32_word);
 140                 if (ret_val == QLA_ERROR) {
 141                         ql4_printk(KERN_ERR, ha, "%s: failed to read addr 0x%x!\n",
 142                                    __func__, addr);
 143                         goto exit_flash_read;
 144                 }
 145
 146                 *(__le32 *)p_data = le32_to_cpu(u32_word);
 147                 p_data = p_data + 4;
 148                 addr = addr + 4;
 149         }
 150
 151 exit_flash_read:
 152         qla4_83xx_flash_unlock(ha);
 153
 154 exit_lock_error:
 155         return ret_val;
 156 }
 157
 158 int qla4_83xx_lockless_flash_read_u32(struct scsi_qla_host *ha,
 159                                       uint32_t flash_addr, uint8_t *p_data,
 160                                       int u32_word_count)
 161 {
 162         uint32_t i;
 163         uint32_t u32_word;
 164         uint32_t flash_offset;
 165         uint32_t addr = flash_addr;
 166         int ret_val = QLA_SUCCESS;
 167
 168         flash_offset = addr & (QLA83XX_FLASH_SECTOR_SIZE - 1);
 169
 170         if (addr & 0x3) {
 171                 ql4_printk(KERN_ERR, ha, "%s: Illegal addr = 0x%x\n",
 172                            __func__, addr);
 173                 ret_val = QLA_ERROR;
 174                 goto exit_lockless_read;
 175         }
 176
 177         ret_val = qla4_83xx_wr_reg_indirect(ha, QLA83XX_FLASH_DIRECT_WINDOW,
 178                                             addr);
 179         if (ret_val == QLA_ERROR) {
 180                 ql4_printk(KERN_ERR, ha, "%s: failed to write addr 0x%x to FLASH_DIRECT_WINDOW!\n",
 181                            __func__, addr);
 182                 goto exit_lockless_read;
 183         }
 184
 185         /* Check if data is spread across multiple sectors  */
 186         if ((flash_offset + (u32_word_count * sizeof(uint32_t))) >
 187             (QLA83XX_FLASH_SECTOR_SIZE - 1)) {
 188
 189                 /* Multi sector read */
 190                 for (i = 0; i < u32_word_count; i++) {
 191                         ret_val = qla4_83xx_rd_reg_indirect(ha,
 192                                                 QLA83XX_FLASH_DIRECT_DATA(addr),
 193                                                 &u32_word);
 194                         if (ret_val == QLA_ERROR) {
 195                                 ql4_printk(KERN_ERR, ha, "%s: failed to read addr 0x%x!\n",
 196                                            __func__, addr);
 197                                 goto exit_lockless_read;
 198                         }
 199
 200                         *(__le32 *)p_data  = le32_to_cpu(u32_word);
 201                         p_data = p_data + 4;
 202                         addr = addr + 4;
 203                         flash_offset = flash_offset + 4;
 204
 205                         if (flash_offset > (QLA83XX_FLASH_SECTOR_SIZE - 1)) {
 206                                 /* This write is needed once for each sector */
 207                                 ret_val = qla4_83xx_wr_reg_indirect(ha,
 208                                                    QLA83XX_FLASH_DIRECT_WINDOW,
 209                                                    addr);
 210                                 if (ret_val == QLA_ERROR) {
 211                                         ql4_printk(KERN_ERR, ha, "%s: failed to write addr 0x%x to FLASH_DIRECT_WINDOW!\n",
 212                                                    __func__, addr);
 213                                         goto exit_lockless_read;
 214                                 }
 215                                 flash_offset = 0;
 216                         }
 217                 }
 218         } else {
 219                 /* Single sector read */
 220                 for (i = 0; i < u32_word_count; i++) {
 221                         ret_val = qla4_83xx_rd_reg_indirect(ha,
 222                                                 QLA83XX_FLASH_DIRECT_DATA(addr),
 223                                                 &u32_word);
 224                         if (ret_val == QLA_ERROR) {
 225                                 ql4_printk(KERN_ERR, ha, "%s: failed to read addr 0x%x!\n",
 226                                            __func__, addr);
 227                                 goto exit_lockless_read;
 228                         }
 229
 230                         *(__le32 *)p_data = le32_to_cpu(u32_word);
 231                         p_data = p_data + 4;
 232                         addr = addr + 4;
 233                 }
 234         }
 235
 236 exit_lockless_read:
 237         return ret_val;
 238 }
 239
 240 void qla4_83xx_rom_lock_recovery(struct scsi_qla_host *ha)
 241 {
 242         if (qla4_83xx_flash_lock(ha))
 243                 ql4_printk(KERN_INFO, ha, "%s: Resetting rom lock\n", __func__);
 244
 245         /*
 246          * We got the lock, or someone else is holding the lock
 247          * since we are restting, forcefully unlock
 248          */
 249         qla4_83xx_flash_unlock(ha);
 250 }
 251
 252 #define INTENT_TO_RECOVER       0x01
 253 #define PROCEED_TO_RECOVER      0x02
 254
 255 static int qla4_83xx_lock_recovery(struct scsi_qla_host *ha)
 256 {
 257
 258         uint32_t lock = 0, lockid;
 259         int ret_val = QLA_ERROR;
 260
 261         lockid = ha->isp_ops->rd_reg_direct(ha, QLA83XX_DRV_LOCKRECOVERY);
 262
 263         /* Check for other Recovery in progress, go wait */
 264         if ((lockid & 0x3) != 0)
 265                 goto exit_lock_recovery;
 266
 267         /* Intent to Recover */
 268         ha->isp_ops->wr_reg_direct(ha, QLA83XX_DRV_LOCKRECOVERY,
 269                                    (ha->func_num << 2) | INTENT_TO_RECOVER);
 270
 271         msleep(200);
 272
 273         /* Check Intent to Recover is advertised */
 274         lockid = ha->isp_ops->rd_reg_direct(ha, QLA83XX_DRV_LOCKRECOVERY);
 275         if ((lockid & 0x3C) != (ha->func_num << 2))
 276                 goto exit_lock_recovery;
 277
 278         ql4_printk(KERN_INFO, ha, "%s: IDC Lock recovery initiated for func %d\n",
 279                    __func__, ha->func_num);
 280
 281         /* Proceed to Recover */
 282         ha->isp_ops->wr_reg_direct(ha, QLA83XX_DRV_LOCKRECOVERY,
 283                                    (ha->func_num << 2) | PROCEED_TO_RECOVER);
 284
 285         /* Force Unlock */
 286         ha->isp_ops->wr_reg_direct(ha, QLA83XX_DRV_LOCK_ID, 0xFF);
 287         ha->isp_ops->rd_reg_direct(ha, QLA83XX_DRV_UNLOCK);
 288
 289         /* Clear bits 0-5 in IDC_RECOVERY register*/
 290         ha->isp_ops->wr_reg_direct(ha, QLA83XX_DRV_LOCKRECOVERY, 0);
 291
 292         /* Get lock */
 293         lock = ha->isp_ops->rd_reg_direct(ha, QLA83XX_DRV_LOCK);
 294         if (lock) {
 295                 lockid = ha->isp_ops->rd_reg_direct(ha, QLA83XX_DRV_LOCK_ID);
 296                 lockid = ((lockid + (1 << 8)) & ~0xFF) | ha->func_num;
 297                 ha->isp_ops->wr_reg_direct(ha, QLA83XX_DRV_LOCK_ID, lockid);
 298                 ret_val = QLA_SUCCESS;
 299         }
 300
 301 exit_lock_recovery:
 302         return ret_val;
 303 }
 304
 305 #define QLA83XX_DRV_LOCK_MSLEEP         200
 306
 307 int qla4_83xx_drv_lock(struct scsi_qla_host *ha)
 308 {
 309         int timeout = 0;
 310         uint32_t status = 0;
 311         int ret_val = QLA_SUCCESS;
 312         uint32_t first_owner = 0;
 313         uint32_t tmo_owner = 0;
 314         uint32_t lock_id;
 315         uint32_t func_num;
 316         uint32_t lock_cnt;
 317
 318         while (status == 0) {
 319                 status = qla4_83xx_rd_reg(ha, QLA83XX_DRV_LOCK);
 320                 if (status) {
 321                         /* Increment Counter (8-31) and update func_num (0-7) on
 322                          * getting a successful lock  */
 323                         lock_id = qla4_83xx_rd_reg(ha, QLA83XX_DRV_LOCK_ID);
 324                         lock_id = ((lock_id + (1 << 8)) & ~0xFF) | ha->func_num;
 325                         qla4_83xx_wr_reg(ha, QLA83XX_DRV_LOCK_ID, lock_id);
 326                         break;
 327                 }
 328
 329                 if (timeout == 0)
 330                         /* Save counter + ID of function holding the lock for
 331                          * first failure */
 332                         first_owner = ha->isp_ops->rd_reg_direct(ha,
 333                                                           QLA83XX_DRV_LOCK_ID);
 334
 335                 if (++timeout >=
 336                     (QLA83XX_DRV_LOCK_TIMEOUT / QLA83XX_DRV_LOCK_MSLEEP)) {
 337                         tmo_owner = qla4_83xx_rd_reg(ha, QLA83XX_DRV_LOCK_ID);
 338                         func_num = tmo_owner & 0xFF;
 339                         lock_cnt = tmo_owner >> 8;
 340                         ql4_printk(KERN_INFO, ha, "%s: Lock by func %d failed after 2s, lock held by func %d, lock count %d, first_owner %d\n",
 341                                    __func__, ha->func_num, func_num, lock_cnt,
 342                                    (first_owner & 0xFF));
 343
 344                         if (first_owner != tmo_owner) {
 345                                 /* Some other driver got lock, OR same driver
 346                                  * got lock again (counter value changed), when
 347                                  * we were waiting for lock.
 348                                  * Retry for another 2 sec */
 349                                 ql4_printk(KERN_INFO, ha, "%s: IDC lock failed for func %d\n",
 350                                            __func__, ha->func_num);
 351                                 timeout = 0;
 352                         } else {
 353                                 /* Same driver holding lock > 2sec.
 354                                  * Force Recovery */
 355                                 ret_val = qla4_83xx_lock_recovery(ha);
 356                                 if (ret_val == QLA_SUCCESS) {
 357                                         /* Recovered and got lock */
 358                                         ql4_printk(KERN_INFO, ha, "%s: IDC lock Recovery by %d successful\n",
 359                                                    __func__, ha->func_num);
 360                                         break;
 361                                 }
 362                                 /* Recovery Failed, some other function
 363                                  * has the lock, wait for 2secs and retry */
 364                                 ql4_printk(KERN_INFO, ha, "%s: IDC lock Recovery by %d failed, Retrying timeout\n",
 365                                            __func__, ha->func_num);
 366                                 timeout = 0;
 367                         }
 368                 }
 369                 msleep(QLA83XX_DRV_LOCK_MSLEEP);
 370         }
 371
 372         return ret_val;
 373 }
 374
 375 void qla4_83xx_drv_unlock(struct scsi_qla_host *ha)
 376 {
 377         int id;
 378
 379         id = qla4_83xx_rd_reg(ha, QLA83XX_DRV_LOCK_ID);
 380
 381         if ((id & 0xFF) != ha->func_num) {
 382                 ql4_printk(KERN_ERR, ha, "%s: IDC Unlock by %d failed, lock owner is %d\n",
 383                            __func__, ha->func_num, (id & 0xFF));
 384                 return;
 385         }
 386
 387         /* Keep lock counter value, update the ha->func_num to 0xFF */
 388         qla4_83xx_wr_reg(ha, QLA83XX_DRV_LOCK_ID, (id | 0xFF));
 389         qla4_83xx_rd_reg(ha, QLA83XX_DRV_UNLOCK);
 390 }
 391
 392 void qla4_83xx_set_idc_dontreset(struct scsi_qla_host *ha)
 393 {
 394         uint32_t idc_ctrl;
 395
 396         idc_ctrl = qla4_83xx_rd_reg(ha, QLA83XX_IDC_DRV_CTRL);
 397         idc_ctrl |= DONTRESET_BIT0;
 398         qla4_83xx_wr_reg(ha, QLA83XX_IDC_DRV_CTRL, idc_ctrl);
 399         DEBUG2(ql4_printk(KERN_INFO, ha, "%s: idc_ctrl = %d\n", __func__,
 400                           idc_ctrl));
 401 }
 402
 403 void qla4_83xx_clear_idc_dontreset(struct scsi_qla_host *ha)
 404 {
 405         uint32_t idc_ctrl;
 406
 407         idc_ctrl = qla4_83xx_rd_reg(ha, QLA83XX_IDC_DRV_CTRL);
 408         idc_ctrl &= ~DONTRESET_BIT0;
 409         qla4_83xx_wr_reg(ha, QLA83XX_IDC_DRV_CTRL, idc_ctrl);
 410         DEBUG2(ql4_printk(KERN_INFO, ha, "%s: idc_ctrl = %d\n", __func__,
 411                           idc_ctrl));
 412 }
 413
 414 int qla4_83xx_idc_dontreset(struct scsi_qla_host *ha)
 415 {
 416         uint32_t idc_ctrl;
 417
 418         idc_ctrl = qla4_83xx_rd_reg(ha, QLA83XX_IDC_DRV_CTRL);
 419         return idc_ctrl & DONTRESET_BIT0;
 420 }
 421
 422 /*-------------------------IDC State Machine ---------------------*/
 423
 424 enum {
 425         UNKNOWN_CLASS = 0,
 426         NIC_CLASS,
 427         FCOE_CLASS,
 428         ISCSI_CLASS
 429 };
 430
 431 struct device_info {
 432         int func_num;
 433         int device_type;
 434         int port_num;
 435 };
 436
 437 int qla4_83xx_can_perform_reset(struct scsi_qla_host *ha)
 438 {
 439         uint32_t drv_active;
 440         uint32_t dev_part, dev_part1, dev_part2;
 441         int i;
 442         struct device_info device_map[16];
 443         int func_nibble;
 444         int nibble;
 445         int nic_present = 0;
 446         int iscsi_present = 0;
 447         int iscsi_func_low = 0;
 448
 449         /* Use the dev_partition register to determine the PCI function number
 450          * and then check drv_active register to see which driver is loaded */
 451         dev_part1 = qla4_83xx_rd_reg(ha,
 452                                      ha->reg_tbl[QLA8XXX_CRB_DEV_PART_INFO]);
 453         dev_part2 = qla4_83xx_rd_reg(ha, QLA83XX_CRB_DEV_PART_INFO2);
 454         drv_active = qla4_83xx_rd_reg(ha, ha->reg_tbl[QLA8XXX_CRB_DRV_ACTIVE]);
 455
 456         /* Each function has 4 bits in dev_partition Info register,
 457          * Lower 2 bits - device type, Upper 2 bits - physical port number */
 458         dev_part = dev_part1;
 459         for (i = nibble = 0; i <= 15; i++, nibble++) {
 460                 func_nibble = dev_part & (0xF << (nibble * 4));
 461                 func_nibble >>= (nibble * 4);
 462                 device_map[i].func_num = i;
 463                 device_map[i].device_type = func_nibble & 0x3;
 464                 device_map[i].port_num = func_nibble & 0xC;
 465
 466                 if (device_map[i].device_type == NIC_CLASS) {
 467                         if (drv_active & (1 << device_map[i].func_num)) {
 468                                 nic_present++;
 469                                 break;
 470                         }
 471                 } else if (device_map[i].device_type == ISCSI_CLASS) {
 472                         if (drv_active & (1 << device_map[i].func_num)) {
 473                                 if (!iscsi_present ||
 474                                     (iscsi_present &&
 475                                      (iscsi_func_low > device_map[i].func_num)))
 476                                         iscsi_func_low = device_map[i].func_num;
 477
 478                                 iscsi_present++;
 479                         }
 480                 }
 481
 482                 /* For function_num[8..15] get info from dev_part2 register */
 483                 if (nibble == 7) {
 484                         nibble = 0;
 485                         dev_part = dev_part2;
 486                 }
 487         }
 488
 489         /* NIC, iSCSI and FCOE are the Reset owners based on order, NIC gets
 490          * precedence over iSCSI and FCOE and iSCSI over FCOE, based on drivers
 491          * present. */
 492         if (!nic_present && (ha->func_num == iscsi_func_low)) {
 493                 DEBUG2(ql4_printk(KERN_INFO, ha,
 494                                   "%s: can reset - NIC not present and lower iSCSI function is %d\n",
 495                                   __func__, ha->func_num));
 496                 return 1;
 497         }
 498
 499         return 0;
 500 }
 501
 502 /**
 503  * qla4_83xx_need_reset_handler - Code to start reset sequence
 504  * @ha: pointer to adapter structure
 505  *
 506  * Note: IDC lock must be held upon entry
 507  **/
 508 void qla4_83xx_need_reset_handler(struct scsi_qla_host *ha)
 509 {
 510         uint32_t dev_state, drv_state, drv_active;
 511         unsigned long reset_timeout, dev_init_timeout;
 512
 513         ql4_printk(KERN_INFO, ha, "%s: Performing ISP error recovery\n",
 514                    __func__);
 515
 516         if (!test_bit(AF_8XXX_RST_OWNER, &ha->flags)) {
 517                 DEBUG2(ql4_printk(KERN_INFO, ha, "%s: reset acknowledged\n",
 518                                   __func__));
 519                 qla4_8xxx_set_rst_ready(ha);
 520
 521                 /* Non-reset owners ACK Reset and wait for device INIT state
 522                  * as part of Reset Recovery by Reset Owner */
 523                 dev_init_timeout = jiffies + (ha->nx_dev_init_timeout * HZ);
 524
 525                 do {
 526                         if (time_after_eq(jiffies, dev_init_timeout)) {
 527                                 ql4_printk(KERN_INFO, ha, "%s: Non Reset owner dev init timeout\n",
 528                                            __func__);
 529                                 break;
 530                         }
 531
 532                         ha->isp_ops->idc_unlock(ha);
 533                         msleep(1000);
 534                         ha->isp_ops->idc_lock(ha);
 535
 536                         dev_state = qla4_8xxx_rd_direct(ha,
 537                                                         QLA8XXX_CRB_DEV_STATE);
 538                 } while (dev_state == QLA8XXX_DEV_NEED_RESET);
 539         } else {
 540                 qla4_8xxx_set_rst_ready(ha);
 541                 reset_timeout = jiffies + (ha->nx_reset_timeout * HZ);
 542                 drv_state = qla4_8xxx_rd_direct(ha, QLA8XXX_CRB_DRV_STATE);
 543                 drv_active = qla4_8xxx_rd_direct(ha, QLA8XXX_CRB_DRV_ACTIVE);
 544
 545                 ql4_printk(KERN_INFO, ha, "%s: drv_state = 0x%x, drv_active = 0x%x\n",
 546                            __func__, drv_state, drv_active);
 547
 548                 while (drv_state != drv_active) {
 549                         if (time_after_eq(jiffies, reset_timeout)) {
 550                                 ql4_printk(KERN_INFO, ha, "%s: %s: RESET TIMEOUT! drv_state: 0x%08x, drv_active: 0x%08x\n",
 551                                            __func__, DRIVER_NAME, drv_state,
 552                                            drv_active);
 553                                 break;
 554                         }
 555
 556                         ha->isp_ops->idc_unlock(ha);
 557                         msleep(1000);
 558                         ha->isp_ops->idc_lock(ha);
 559
 560                         drv_state = qla4_8xxx_rd_direct(ha,
 561                                                         QLA8XXX_CRB_DRV_STATE);
 562                         drv_active = qla4_8xxx_rd_direct(ha,
 563                                                         QLA8XXX_CRB_DRV_ACTIVE);
 564                 }
 565
 566                 if (drv_state != drv_active) {
 567                         ql4_printk(KERN_INFO, ha, "%s: Reset_owner turning off drv_active of non-acking function 0x%x\n",
 568                                    __func__, (drv_active ^ drv_state));
 569                         drv_active = drv_active & drv_state;
 570                         qla4_8xxx_wr_direct(ha, QLA8XXX_CRB_DRV_ACTIVE,
 571                                             drv_active);
 572                 }
 573
 574                 clear_bit(AF_8XXX_RST_OWNER, &ha->flags);
 575                 /* Start Reset Recovery */
 576                 qla4_8xxx_device_bootstrap(ha);
 577         }
 578 }
 579
 580 void qla4_83xx_get_idc_param(struct scsi_qla_host *ha)
 581 {
 582         uint32_t idc_params, ret_val;
 583
 584         ret_val = qla4_83xx_flash_read_u32(ha, QLA83XX_IDC_PARAM_ADDR,
 585                                            (uint8_t *)&idc_params, 1);
 586         if (ret_val == QLA_SUCCESS) {
 587                 ha->nx_dev_init_timeout = idc_params & 0xFFFF;
 588                 ha->nx_reset_timeout = (idc_params >> 16) & 0xFFFF;
 589         } else {
 590                 ha->nx_dev_init_timeout = ROM_DEV_INIT_TIMEOUT;
 591                 ha->nx_reset_timeout = ROM_DRV_RESET_ACK_TIMEOUT;
 592         }
 593
 594         DEBUG2(ql4_printk(KERN_DEBUG, ha,
 595                           "%s: ha->nx_dev_init_timeout = %d, ha->nx_reset_timeout = %d\n",
 596                           __func__, ha->nx_dev_init_timeout,
 597                           ha->nx_reset_timeout));
 598 }
 599
 600 /*-------------------------Reset Sequence Functions-----------------------*/
 601
 602 static void qla4_83xx_dump_reset_seq_hdr(struct scsi_qla_host *ha)
 603 {
 604         uint8_t *phdr;
 605
 606         if (!ha->reset_tmplt.buff) {
 607                 ql4_printk(KERN_ERR, ha, "%s: Error: Invalid reset_seq_template\n",
 608                            __func__);
 609                 return;
 610         }
 611
 612         phdr = ha->reset_tmplt.buff;
 613
 614         DEBUG2(ql4_printk(KERN_INFO, ha,
 615                           "Reset Template: 0x%X 0x%X 0x%X 0x%X 0x%X 0x%X 0x%X 0x%X 0x%X 0x%X 0x%X 0x%X 0x%X 0x%X 0x%X 0x%X\n",
 616                           *phdr, *(phdr+1), *(phdr+2), *(phdr+3), *(phdr+4),
 617                           *(phdr+5), *(phdr+6), *(phdr+7), *(phdr + 8),
 618                           *(phdr+9), *(phdr+10), *(phdr+11), *(phdr+12),
 619                           *(phdr+13), *(phdr+14), *(phdr+15)));
 620 }
 621
 622 static int qla4_83xx_copy_bootloader(struct scsi_qla_host *ha)
 623 {
 624         uint8_t *p_cache;
 625         uint32_t src, count, size;
 626         uint64_t dest;
 627         int ret_val = QLA_SUCCESS;
 628
 629         src = QLA83XX_BOOTLOADER_FLASH_ADDR;
 630         dest = qla4_83xx_rd_reg(ha, QLA83XX_BOOTLOADER_ADDR);
 631         size = qla4_83xx_rd_reg(ha, QLA83XX_BOOTLOADER_SIZE);
 632
 633         /* 128 bit alignment check */
 634         if (size & 0xF)
 635                 size = (size + 16) & ~0xF;
 636
 637         /* 16 byte count */
 638         count = size/16;
 639
 640         p_cache = vmalloc(size);
 641         if (p_cache == NULL) {
 642                 ql4_printk(KERN_ERR, ha, "%s: Failed to allocate memory for boot loader cache\n",
 643                            __func__);
 644                 ret_val = QLA_ERROR;
 645                 goto exit_copy_bootloader;
 646         }
 647
 648         ret_val = qla4_83xx_lockless_flash_read_u32(ha, src, p_cache,
 649                                                     size / sizeof(uint32_t));
 650         if (ret_val == QLA_ERROR) {
 651                 ql4_printk(KERN_ERR, ha, "%s: Error reading firmware from flash\n",
 652                            __func__);
 653                 goto exit_copy_error;
 654         }
 655         DEBUG2(ql4_printk(KERN_INFO, ha, "%s: Read firmware from flash\n",
 656                           __func__));
 657
 658         /* 128 bit/16 byte write to MS memory */
 659         ret_val = qla4_8xxx_ms_mem_write_128b(ha, dest, (uint32_t *)p_cache,
 660                                               count);
 661         if (ret_val == QLA_ERROR) {
 662                 ql4_printk(KERN_ERR, ha, "%s: Error writing firmware to MS\n",
 663                            __func__);
 664                 goto exit_copy_error;
 665         }
 666
 667         DEBUG2(ql4_printk(KERN_INFO, ha, "%s: Wrote firmware size %d to MS\n",
 668                           __func__, size));
 669
 670 exit_copy_error:
 671         vfree(p_cache);
 672
 673 exit_copy_bootloader:
 674         return ret_val;
 675 }
 676
 677 static int qla4_83xx_check_cmd_peg_status(struct scsi_qla_host *ha)
 678 {
 679         uint32_t val, ret_val = QLA_ERROR;
 680         int retries = CRB_CMDPEG_CHECK_RETRY_COUNT;
 681
 682         do {
 683                 val = qla4_83xx_rd_reg(ha, QLA83XX_CMDPEG_STATE);
 684                 if (val == PHAN_INITIALIZE_COMPLETE) {
 685                         DEBUG2(ql4_printk(KERN_INFO, ha,
 686                                           "%s: Command Peg initialization complete. State=0x%x\n",
 687                                           __func__, val));
 688                         ret_val = QLA_SUCCESS;
 689                         break;
 690                 }
 691                 msleep(CRB_CMDPEG_CHECK_DELAY);
 692         } while (--retries);
 693
 694         return ret_val;
 695 }
 696
 697 /**
 698  * qla4_83xx_poll_reg - Poll the given CRB addr for duration msecs till
 699  * value read ANDed with test_mask is equal to test_result.
 700  *
 701  * @ha : Pointer to adapter structure
 702  * @addr : CRB register address
 703  * @duration : Poll for total of "duration" msecs
 704  * @test_mask : Mask value read with "test_mask"
 705  * @test_result : Compare (value&test_mask) with test_result.
 706  **/
 707 static int qla4_83xx_poll_reg(struct scsi_qla_host *ha, uint32_t addr,
 708                               int duration, uint32_t test_mask,
 709                               uint32_t test_result)
 710 {
 711         uint32_t value;
 712         uint8_t retries;
 713         int ret_val = QLA_SUCCESS;
 714
 715         ret_val = qla4_83xx_rd_reg_indirect(ha, addr, &value);
 716         if (ret_val == QLA_ERROR)
 717                 goto exit_poll_reg;
 718
 719         retries = duration / 10;
 720         do {
 721                 if ((value & test_mask) != test_result) {
 722                         msleep(duration / 10);
 723                         ret_val = qla4_83xx_rd_reg_indirect(ha, addr, &value);
 724                         if (ret_val == QLA_ERROR)
 725                                 goto exit_poll_reg;
 726
 727                         ret_val = QLA_ERROR;
 728                 } else {
 729                         ret_val = QLA_SUCCESS;
 730                         break;
 731                 }
 732         } while (retries--);
 733
 734 exit_poll_reg:
 735         if (ret_val == QLA_ERROR) {
 736                 ha->reset_tmplt.seq_error++;
 737                 ql4_printk(KERN_ERR, ha, "%s: Poll Failed:  0x%08x 0x%08x 0x%08x\n",
 738                            __func__, value, test_mask, test_result);
 739         }
 740
 741         return ret_val;
 742 }
 743
 744 static int qla4_83xx_reset_seq_checksum_test(struct scsi_qla_host *ha)
 745 {
 746         uint32_t sum =  0;
 747         uint16_t *buff = (uint16_t *)ha->reset_tmplt.buff;
 748         int u16_count =  ha->reset_tmplt.hdr->size / sizeof(uint16_t);
 749         int ret_val;
 750
 751         while (u16_count-- > 0)
 752                 sum += *buff++;
 753
 754         while (sum >> 16)
 755                 sum = (sum & 0xFFFF) +  (sum >> 16);
 756
 757         /* checksum of 0 indicates a valid template */
 758         if (~sum) {
 759                 ret_val = QLA_SUCCESS;
 760         } else {
 761                 ql4_printk(KERN_ERR, ha, "%s: Reset seq checksum failed\n",
 762                            __func__);
 763                 ret_val = QLA_ERROR;
 764         }
 765
 766         return ret_val;
 767 }
 768
 769 /**
 770  * qla4_83xx_read_reset_template - Read Reset Template from Flash
 771  * @ha: Pointer to adapter structure
 772  **/
 773 void qla4_83xx_read_reset_template(struct scsi_qla_host *ha)
 774 {
 775         uint8_t *p_buff;
 776         uint32_t addr, tmplt_hdr_def_size, tmplt_hdr_size;
 777         uint32_t ret_val;
 778
 779         ha->reset_tmplt.seq_error = 0;
 780         ha->reset_tmplt.buff = vmalloc(QLA83XX_RESTART_TEMPLATE_SIZE);
 781         if (ha->reset_tmplt.buff == NULL) {
 782                 ql4_printk(KERN_ERR, ha, "%s: Failed to allocate reset template resources\n",
 783                            __func__);
 784                 goto exit_read_reset_template;
 785         }
 786
 787         p_buff = ha->reset_tmplt.buff;
 788         addr = QLA83XX_RESET_TEMPLATE_ADDR;
 789
 790         tmplt_hdr_def_size = sizeof(struct qla4_83xx_reset_template_hdr) /
 791                                     sizeof(uint32_t);
 792
 793         DEBUG2(ql4_printk(KERN_INFO, ha,
 794                           "%s: Read template hdr size %d from Flash\n",
 795                           __func__, tmplt_hdr_def_size));
 796
 797         /* Copy template header from flash */
 798         ret_val = qla4_83xx_flash_read_u32(ha, addr, p_buff,
 799                                            tmplt_hdr_def_size);
 800         if (ret_val != QLA_SUCCESS) {
 801                 ql4_printk(KERN_ERR, ha, "%s: Failed to read reset template\n",
 802                            __func__);
 803                 goto exit_read_template_error;
 804         }
 805
 806         ha->reset_tmplt.hdr =
 807                 (struct qla4_83xx_reset_template_hdr *)ha->reset_tmplt.buff;
 808
 809         /* Validate the template header size and signature */
 810         tmplt_hdr_size = ha->reset_tmplt.hdr->hdr_size/sizeof(uint32_t);
 811         if ((tmplt_hdr_size != tmplt_hdr_def_size) ||
 812             (ha->reset_tmplt.hdr->signature != RESET_TMPLT_HDR_SIGNATURE)) {
 813                 ql4_printk(KERN_ERR, ha, "%s: Template Header size %d is invalid, tmplt_hdr_def_size %d\n",
 814                            __func__, tmplt_hdr_size, tmplt_hdr_def_size);
 815                 goto exit_read_template_error;
 816         }
 817
 818         addr = QLA83XX_RESET_TEMPLATE_ADDR + ha->reset_tmplt.hdr->hdr_size;
 819         p_buff = ha->reset_tmplt.buff + ha->reset_tmplt.hdr->hdr_size;
 820         tmplt_hdr_def_size = (ha->reset_tmplt.hdr->size -
 821                               ha->reset_tmplt.hdr->hdr_size) / sizeof(uint32_t);
 822
 823         DEBUG2(ql4_printk(KERN_INFO, ha,
 824                           "%s: Read rest of the template size %d\n",
 825                           __func__, ha->reset_tmplt.hdr->size));
 826
 827         /* Copy rest of the template */
 828         ret_val = qla4_83xx_flash_read_u32(ha, addr, p_buff,
 829                                            tmplt_hdr_def_size);
 830         if (ret_val != QLA_SUCCESS) {
 831                 ql4_printk(KERN_ERR, ha, "%s: Failed to read reset template\n",
 832                            __func__);
 833                 goto exit_read_template_error;
 834         }
 835
 836         /* Integrity check */
 837         if (qla4_83xx_reset_seq_checksum_test(ha)) {
 838                 ql4_printk(KERN_ERR, ha, "%s: Reset Seq checksum failed!\n",
 839                            __func__);
 840                 goto exit_read_template_error;
 841         }
 842         DEBUG2(ql4_printk(KERN_INFO, ha,
 843                           "%s: Reset Seq checksum passed, Get stop, start and init seq offsets\n",
 844                           __func__));
 845
 846         /* Get STOP, START, INIT sequence offsets */
 847         ha->reset_tmplt.init_offset = ha->reset_tmplt.buff +
 848                                       ha->reset_tmplt.hdr->init_seq_offset;
 849         ha->reset_tmplt.start_offset = ha->reset_tmplt.buff +
 850                                        ha->reset_tmplt.hdr->start_seq_offset;
 851         ha->reset_tmplt.stop_offset = ha->reset_tmplt.buff +
 852                                       ha->reset_tmplt.hdr->hdr_size;
 853         qla4_83xx_dump_reset_seq_hdr(ha);
 854
 855         goto exit_read_reset_template;
 856
 857 exit_read_template_error:
 858         vfree(ha->reset_tmplt.buff);
 859
 860 exit_read_reset_template:
 861         return;
 862 }
 863
 864 /**
 865  * qla4_83xx_read_write_crb_reg - Read from raddr and write value to waddr.
 866  *
 867  * @ha : Pointer to adapter structure
 868  * @raddr : CRB address to read from
 869  * @waddr : CRB address to write to
 870  **/
 871 static void qla4_83xx_read_write_crb_reg(struct scsi_qla_host *ha,
 872                                          uint32_t raddr, uint32_t waddr)
 873 {
 874         uint32_t value;
 875
 876         qla4_83xx_rd_reg_indirect(ha, raddr, &value);
 877         qla4_83xx_wr_reg_indirect(ha, waddr, value);
 878 }
 879
 880 /**
 881  * qla4_83xx_rmw_crb_reg - Read Modify Write crb register
 882  *
 883  * This function read value from raddr, AND with test_mask,
 884  * Shift Left,Right/OR/XOR with values RMW header and write value to waddr.
 885  *
 886  * @ha : Pointer to adapter structure
 887  * @raddr : CRB address to read from
 888  * @waddr : CRB address to write to
 889  * @p_rmw_hdr : header with shift/or/xor values.
 890  **/
 891 static void qla4_83xx_rmw_crb_reg(struct scsi_qla_host *ha, uint32_t raddr,
 892                                   uint32_t waddr,
 893                                   struct qla4_83xx_rmw *p_rmw_hdr)
 894 {
 895         uint32_t value;
 896
 897         if (p_rmw_hdr->index_a)
 898                 value = ha->reset_tmplt.array[p_rmw_hdr->index_a];
 899         else
 900                 qla4_83xx_rd_reg_indirect(ha, raddr, &value);
 901
 902         value &= p_rmw_hdr->test_mask;
 903         value <<= p_rmw_hdr->shl;
 904         value >>= p_rmw_hdr->shr;
 905         value |= p_rmw_hdr->or_value;
 906         value ^= p_rmw_hdr->xor_value;
 907
 908         qla4_83xx_wr_reg_indirect(ha, waddr, value);
 909
 910         return;
 911 }
 912
 913 static void qla4_83xx_write_list(struct scsi_qla_host *ha,
 914                                  struct qla4_83xx_reset_entry_hdr *p_hdr)
 915 {
 916         struct qla4_83xx_entry *p_entry;
 917         uint32_t i;
 918
 919         p_entry = (struct qla4_83xx_entry *)
 920                   ((char *)p_hdr + sizeof(struct qla4_83xx_reset_entry_hdr));
 921
 922         for (i = 0; i < p_hdr->count; i++, p_entry++) {
 923                 qla4_83xx_wr_reg_indirect(ha, p_entry->arg1, p_entry->arg2);
 924                 if (p_hdr->delay)
 925                         udelay((uint32_t)(p_hdr->delay));
 926         }
 927 }
 928
 929 static void qla4_83xx_read_write_list(struct scsi_qla_host *ha,
 930                                       struct qla4_83xx_reset_entry_hdr *p_hdr)
 931 {
 932         struct qla4_83xx_entry *p_entry;
 933         uint32_t i;
 934
 935         p_entry = (struct qla4_83xx_entry *)
 936                   ((char *)p_hdr + sizeof(struct qla4_83xx_reset_entry_hdr));
 937
 938         for (i = 0; i < p_hdr->count; i++, p_entry++) {
 939                 qla4_83xx_read_write_crb_reg(ha, p_entry->arg1, p_entry->arg2);
 940                 if (p_hdr->delay)
 941                         udelay((uint32_t)(p_hdr->delay));
 942         }
 943 }
 944
 945 static void qla4_83xx_poll_list(struct scsi_qla_host *ha,
 946                                 struct qla4_83xx_reset_entry_hdr *p_hdr)
 947 {
 948         long delay;
 949         struct qla4_83xx_entry *p_entry;
 950         struct qla4_83xx_poll *p_poll;
 951         uint32_t i;
 952         uint32_t value;
 953
 954         p_poll = (struct qla4_83xx_poll *)
 955                  ((char *)p_hdr + sizeof(struct qla4_83xx_reset_entry_hdr));
 956
 957         /* Entries start after 8 byte qla4_83xx_poll, poll header contains
 958          * the test_mask, test_value. */
 959         p_entry = (struct qla4_83xx_entry *)((char *)p_poll +
 960                                              sizeof(struct qla4_83xx_poll));
 961
 962         delay = (long)p_hdr->delay;
 963         if (!delay) {
 964                 for (i = 0; i < p_hdr->count; i++, p_entry++) {
 965                         qla4_83xx_poll_reg(ha, p_entry->arg1, delay,
 966                                            p_poll->test_mask,
 967                                            p_poll->test_value);
 968                 }
 969         } else {
 970                 for (i = 0; i < p_hdr->count; i++, p_entry++) {
 971                         if (qla4_83xx_poll_reg(ha, p_entry->arg1, delay,
 972                                                p_poll->test_mask,
 973                                                p_poll->test_value)) {
 974                                 qla4_83xx_rd_reg_indirect(ha, p_entry->arg1,
 975                                                           &value);
 976                                 qla4_83xx_rd_reg_indirect(ha, p_entry->arg2,
 977                                                           &value);
 978                         }
 979                 }
 980         }
 981 }
 982
 983 static void qla4_83xx_poll_write_list(struct scsi_qla_host *ha,
 984                                       struct qla4_83xx_reset_entry_hdr *p_hdr)
 985 {
 986         long delay;
 987         struct qla4_83xx_quad_entry *p_entry;
 988         struct qla4_83xx_poll *p_poll;
 989         uint32_t i;
 990
 991         p_poll = (struct qla4_83xx_poll *)
 992                  ((char *)p_hdr + sizeof(struct qla4_83xx_reset_entry_hdr));
 993         p_entry = (struct qla4_83xx_quad_entry *)
 994                   ((char *)p_poll + sizeof(struct qla4_83xx_poll));
 995         delay = (long)p_hdr->delay;
 996
 997         for (i = 0; i < p_hdr->count; i++, p_entry++) {
 998                 qla4_83xx_wr_reg_indirect(ha, p_entry->dr_addr,
 999                                           p_entry->dr_value);
1000                 qla4_83xx_wr_reg_indirect(ha, p_entry->ar_addr,
1001                                           p_entry->ar_value);
1002                 if (delay) {
1003                         if (qla4_83xx_poll_reg(ha, p_entry->ar_addr, delay,
1004                                                p_poll->test_mask,
1005                                                p_poll->test_value)) {
1006                                 DEBUG2(ql4_printk(KERN_INFO, ha,
1007                                                   "%s: Timeout Error: poll list, item_num %d, entry_num %d\n",
1008                                                   __func__, i,
1009                                                   ha->reset_tmplt.seq_index));
1010                         }
1011                 }
1012         }
1013 }
1014
1015 static void qla4_83xx_read_modify_write(struct scsi_qla_host *ha,
1016                                         struct qla4_83xx_reset_entry_hdr *p_hdr)
1017 {
1018         struct qla4_83xx_entry *p_entry;
1019         struct qla4_83xx_rmw *p_rmw_hdr;
1020         uint32_t i;
1021
1022         p_rmw_hdr = (struct qla4_83xx_rmw *)
1023                     ((char *)p_hdr + sizeof(struct qla4_83xx_reset_entry_hdr));
1024         p_entry = (struct qla4_83xx_entry *)
1025                   ((char *)p_rmw_hdr + sizeof(struct qla4_83xx_rmw));
1026
1027         for (i = 0; i < p_hdr->count; i++, p_entry++) {
1028                 qla4_83xx_rmw_crb_reg(ha, p_entry->arg1, p_entry->arg2,
1029                                       p_rmw_hdr);
1030                 if (p_hdr->delay)
1031                         udelay((uint32_t)(p_hdr->delay));
1032         }
1033 }
1034
1035 static void qla4_83xx_pause(struct scsi_qla_host *ha,
1036                             struct qla4_83xx_reset_entry_hdr *p_hdr)
1037 {
1038         if (p_hdr->delay)
1039                 mdelay((uint32_t)((long)p_hdr->delay));
1040 }
1041
1042 static void qla4_83xx_poll_read_list(struct scsi_qla_host *ha,
1043                                      struct qla4_83xx_reset_entry_hdr *p_hdr)
1044 {
1045         long delay;
1046         int index;
1047         struct qla4_83xx_quad_entry *p_entry;
1048         struct qla4_83xx_poll *p_poll;
1049         uint32_t i;
1050         uint32_t value;
1051
1052         p_poll = (struct qla4_83xx_poll *)
1053                  ((char *)p_hdr + sizeof(struct qla4_83xx_reset_entry_hdr));
1054         p_entry = (struct qla4_83xx_quad_entry *)
1055                   ((char *)p_poll + sizeof(struct qla4_83xx_poll));
1056         delay = (long)p_hdr->delay;
1057
1058         for (i = 0; i < p_hdr->count; i++, p_entry++) {
1059                 qla4_83xx_wr_reg_indirect(ha, p_entry->ar_addr,
1060                                           p_entry->ar_value);
1061                 if (delay) {
1062                         if (qla4_83xx_poll_reg(ha, p_entry->ar_addr, delay,
1063                                                p_poll->test_mask,
1064                                                p_poll->test_value)) {
1065                                 DEBUG2(ql4_printk(KERN_INFO, ha,
1066                                                   "%s: Timeout Error: poll list, Item_num %d, entry_num %d\n",
1067                                                   __func__, i,
1068                                                   ha->reset_tmplt.seq_index));
1069                         } else {
1070                                 index = ha->reset_tmplt.array_index;
1071                                 qla4_83xx_rd_reg_indirect(ha, p_entry->dr_addr,
1072                                                           &value);
1073                                 ha->reset_tmplt.array[index++] = value;
1074
1075                                 if (index == QLA83XX_MAX_RESET_SEQ_ENTRIES)
1076                                         ha->reset_tmplt.array_index = 1;
1077                         }
1078                 }
1079         }
1080 }
1081
1082 static void qla4_83xx_seq_end(struct scsi_qla_host *ha,
1083                               struct qla4_83xx_reset_entry_hdr *p_hdr)
1084 {
1085         ha->reset_tmplt.seq_end = 1;
1086 }
1087
1088 static void qla4_83xx_template_end(struct scsi_qla_host *ha,
1089                                    struct qla4_83xx_reset_entry_hdr *p_hdr)
1090 {
1091         ha->reset_tmplt.template_end = 1;
1092
1093         if (ha->reset_tmplt.seq_error == 0) {
1094                 DEBUG2(ql4_printk(KERN_INFO, ha,
1095                                   "%s: Reset sequence completed SUCCESSFULLY.\n",
1096                                   __func__));
1097         } else {
1098                 ql4_printk(KERN_ERR, ha, "%s: Reset sequence completed with some timeout errors.\n",
1099                            __func__);
1100         }
1101 }
1102
1103 /**
1104  * qla4_83xx_process_reset_template - Process reset template.
1105  *
1106  * Process all entries in reset template till entry with SEQ_END opcode,
1107  * which indicates end of the reset template processing. Each entry has a
1108  * Reset Entry header, entry opcode/command, with size of the entry, number
1109  * of entries in sub-sequence and delay in microsecs or timeout in millisecs.
1110  *
1111  * @ha : Pointer to adapter structure
1112  * @p_buff : Common reset entry header.
1113  **/
1114 static void qla4_83xx_process_reset_template(struct scsi_qla_host *ha,
1115                                              char *p_buff)
1116 {
1117         int index, entries;
1118         struct qla4_83xx_reset_entry_hdr *p_hdr;
1119         char *p_entry = p_buff;
1120
1121         ha->reset_tmplt.seq_end = 0;
1122         ha->reset_tmplt.template_end = 0;
1123         entries = ha->reset_tmplt.hdr->entries;
1124         index = ha->reset_tmplt.seq_index;
1125
1126         for (; (!ha->reset_tmplt.seq_end) && (index  < entries); index++) {
1127
1128                 p_hdr = (struct qla4_83xx_reset_entry_hdr *)p_entry;
1129                 switch (p_hdr->cmd) {
1130                 case OPCODE_NOP:
1131                         break;
1132                 case OPCODE_WRITE_LIST:
1133                         qla4_83xx_write_list(ha, p_hdr);
1134                         break;
1135                 case OPCODE_READ_WRITE_LIST:
1136                         qla4_83xx_read_write_list(ha, p_hdr);
1137                         break;
1138                 case OPCODE_POLL_LIST:
1139                         qla4_83xx_poll_list(ha, p_hdr);
1140                         break;
1141                 case OPCODE_POLL_WRITE_LIST:
1142                         qla4_83xx_poll_write_list(ha, p_hdr);
1143                         break;
1144                 case OPCODE_READ_MODIFY_WRITE:
1145                         qla4_83xx_read_modify_write(ha, p_hdr);
1146                         break;
1147                 case OPCODE_SEQ_PAUSE:
1148                         qla4_83xx_pause(ha, p_hdr);
1149                         break;
1150                 case OPCODE_SEQ_END:
1151                         qla4_83xx_seq_end(ha, p_hdr);
1152                         break;
1153                 case OPCODE_TMPL_END:
1154                         qla4_83xx_template_end(ha, p_hdr);
1155                         break;
1156                 case OPCODE_POLL_READ_LIST:
1157                         qla4_83xx_poll_read_list(ha, p_hdr);
1158                         break;
1159                 default:
1160                         ql4_printk(KERN_ERR, ha, "%s: Unknown command ==> 0x%04x on entry = %d\n",
1161                                    __func__, p_hdr->cmd, index);
1162                         break;
1163                 }
1164
1165                 /* Set pointer to next entry in the sequence. */
1166                 p_entry += p_hdr->size;
1167         }
1168
1169         ha->reset_tmplt.seq_index = index;
1170 }
1171
1172 static void qla4_83xx_process_stop_seq(struct scsi_qla_host *ha)
1173 {
1174         ha->reset_tmplt.seq_index = 0;
1175         qla4_83xx_process_reset_template(ha, ha->reset_tmplt.stop_offset);
1176
1177         if (ha->reset_tmplt.seq_end != 1)
1178                 ql4_printk(KERN_ERR, ha, "%s: Abrupt STOP Sub-Sequence end.\n",
1179                            __func__);
1180 }
1181
1182 static void qla4_83xx_process_start_seq(struct scsi_qla_host *ha)
1183 {
1184         qla4_83xx_process_reset_template(ha, ha->reset_tmplt.start_offset);
1185
1186         if (ha->reset_tmplt.template_end != 1)
1187                 ql4_printk(KERN_ERR, ha, "%s: Abrupt START Sub-Sequence end.\n",
1188                            __func__);
1189 }
1190
1191 static void qla4_83xx_process_init_seq(struct scsi_qla_host *ha)
1192 {
1193         qla4_83xx_process_reset_template(ha, ha->reset_tmplt.init_offset);
1194
1195         if (ha->reset_tmplt.seq_end != 1)
1196                 ql4_printk(KERN_ERR, ha, "%s: Abrupt INIT Sub-Sequence end.\n",
1197                            __func__);
1198 }
1199
1200 static int qla4_83xx_restart(struct scsi_qla_host *ha)
1201 {
1202         int ret_val = QLA_SUCCESS;
1203         uint32_t idc_ctrl;
1204
1205         qla4_83xx_process_stop_seq(ha);
1206
1207         /*
1208          * Collect minidump.
1209          * If IDC_CTRL BIT1 is set, clear it on going to INIT state and
1210          * don't collect minidump
1211          */
1212         idc_ctrl = qla4_83xx_rd_reg(ha, QLA83XX_IDC_DRV_CTRL);
1213         if (idc_ctrl & GRACEFUL_RESET_BIT1) {
1214                 qla4_83xx_wr_reg(ha, QLA83XX_IDC_DRV_CTRL,
1215                                  (idc_ctrl & ~GRACEFUL_RESET_BIT1));
1216                 ql4_printk(KERN_INFO, ha, "%s: Graceful RESET: Not collecting minidump\n",
1217                            __func__);
1218         } else {
1219                 qla4_8xxx_get_minidump(ha);
1220         }
1221
1222         qla4_83xx_process_init_seq(ha);
1223
1224         if (qla4_83xx_copy_bootloader(ha)) {
1225                 ql4_printk(KERN_ERR, ha, "%s: Copy bootloader, firmware restart failed!\n",
1226                            __func__);
1227                 ret_val = QLA_ERROR;
1228                 goto exit_restart;
1229         }
1230
1231         qla4_83xx_wr_reg(ha, QLA83XX_FW_IMAGE_VALID, QLA83XX_BOOT_FROM_FLASH);
1232         qla4_83xx_process_start_seq(ha);
1233
1234 exit_restart:
1235         return ret_val;
1236 }
1237
1238 int qla4_83xx_start_firmware(struct scsi_qla_host *ha)
1239 {
1240         int ret_val = QLA_SUCCESS;
1241
1242         ret_val = qla4_83xx_restart(ha);
1243         if (ret_val == QLA_ERROR) {
1244                 ql4_printk(KERN_ERR, ha, "%s: Restart error\n", __func__);
1245                 goto exit_start_fw;
1246         } else {
1247                 DEBUG2(ql4_printk(KERN_INFO, ha, "%s: Restart done\n",
1248                                   __func__));
1249         }
1250
1251         ret_val = qla4_83xx_check_cmd_peg_status(ha);
1252         if (ret_val == QLA_ERROR)
1253                 ql4_printk(KERN_ERR, ha, "%s: Peg not initialized\n",
1254                            __func__);
1255
1256 exit_start_fw:
1257         return ret_val;
1258 }
1259
1260 /*----------------------Interrupt Related functions ---------------------*/
1261
1262 static void qla4_83xx_disable_iocb_intrs(struct scsi_qla_host *ha)
1263 {
1264         if (test_and_clear_bit(AF_83XX_IOCB_INTR_ON, &ha->flags))
1265                 qla4_8xxx_intr_disable(ha);
1266 }
1267
1268 static void qla4_83xx_disable_mbox_intrs(struct scsi_qla_host *ha)
1269 {
1270         uint32_t mb_int, ret;
1271
1272         if (test_and_clear_bit(AF_83XX_MBOX_INTR_ON, &ha->flags)) {
1273                 ret = readl(&ha->qla4_83xx_reg->mbox_int);
1274                 mb_int = ret & ~INT_ENABLE_FW_MB;
1275                 writel(mb_int, &ha->qla4_83xx_reg->mbox_int);
1276                 writel(1, &ha->qla4_83xx_reg->leg_int_mask);
1277         }
1278 }
1279
1280 void qla4_83xx_disable_intrs(struct scsi_qla_host *ha)
1281 {
1282         qla4_83xx_disable_mbox_intrs(ha);
1283         qla4_83xx_disable_iocb_intrs(ha);
1284 }
1285
1286 static void qla4_83xx_enable_iocb_intrs(struct scsi_qla_host *ha)
1287 {
1288         if (!test_bit(AF_83XX_IOCB_INTR_ON, &ha->flags)) {
1289                 qla4_8xxx_intr_enable(ha);
1290                 set_bit(AF_83XX_IOCB_INTR_ON, &ha->flags);
1291         }
1292 }
1293
1294 void qla4_83xx_enable_mbox_intrs(struct scsi_qla_host *ha)
1295 {
1296         uint32_t mb_int;
1297
1298         if (!test_bit(AF_83XX_MBOX_INTR_ON, &ha->flags)) {
1299                 mb_int = INT_ENABLE_FW_MB;
1300                 writel(mb_int, &ha->qla4_83xx_reg->mbox_int);
1301                 writel(0, &ha->qla4_83xx_reg->leg_int_mask);
1302                 set_bit(AF_83XX_MBOX_INTR_ON, &ha->flags);
1303         }
1304 }
1305
1306
1307 void qla4_83xx_enable_intrs(struct scsi_qla_host *ha)
1308 {
1309         qla4_83xx_enable_mbox_intrs(ha);
1310         qla4_83xx_enable_iocb_intrs(ha);
1311 }
1312
1313
1314 void qla4_83xx_queue_mbox_cmd(struct scsi_qla_host *ha, uint32_t *mbx_cmd,
1315                               int incount)
1316 {
1317         int i;
1318
1319         /* Load all mailbox registers, except mailbox 0. */
1320         for (i = 1; i < incount; i++)
1321                 writel(mbx_cmd[i], &ha->qla4_83xx_reg->mailbox_in[i]);
1322
1323         writel(mbx_cmd[0], &ha->qla4_83xx_reg->mailbox_in[0]);
1324
1325         /* Set Host Interrupt register to 1, to tell the firmware that
1326          * a mailbox command is pending. Firmware after reading the
1327          * mailbox command, clears the host interrupt register */
1328         writel(HINT_MBX_INT_PENDING, &ha->qla4_83xx_reg->host_intr);
1329 }
1330
1331 void qla4_83xx_process_mbox_intr(struct scsi_qla_host *ha, int outcount)
1332 {
1333         int intr_status;
1334
1335         intr_status = readl(&ha->qla4_83xx_reg->risc_intr);
1336         if (intr_status) {
1337                 ha->mbox_status_count = outcount;
1338                 ha->isp_ops->interrupt_service_routine(ha, intr_status);
1339         }
1340 }
1341
1342 /**
1343  * qla4_83xx_isp_reset - Resets ISP and aborts all outstanding commands.
1344  * @ha: pointer to host adapter structure.
1345  **/
1346 int qla4_83xx_isp_reset(struct scsi_qla_host *ha)
1347 {
1348         int rval;
1349         uint32_t dev_state;
1350
1351         ha->isp_ops->idc_lock(ha);
1352         dev_state = qla4_8xxx_rd_direct(ha, QLA8XXX_CRB_DEV_STATE);
1353
1354         if (ql4xdontresethba)
1355                 qla4_83xx_set_idc_dontreset(ha);
1356
1357         if (dev_state == QLA8XXX_DEV_READY) {
1358                 /* If IDC_CTRL DONTRESETHBA_BIT0 is set dont do reset
1359                  * recovery */
1360                 if (qla4_83xx_idc_dontreset(ha) == DONTRESET_BIT0) {
1361                         ql4_printk(KERN_ERR, ha, "%s: Reset recovery disabled\n",
1362                                    __func__);
1363                         rval = QLA_ERROR;
1364                         goto exit_isp_reset;
1365                 }
1366
1367                 DEBUG2(ql4_printk(KERN_INFO, ha, "%s: HW State: NEED RESET\n",
1368                                   __func__));
1369                 qla4_8xxx_wr_direct(ha, QLA8XXX_CRB_DEV_STATE,
1370                                     QLA8XXX_DEV_NEED_RESET);
1371
1372         } else {
1373                 /* If device_state is NEED_RESET, go ahead with
1374                  * Reset,irrespective of ql4xdontresethba. This is to allow a
1375                  * non-reset-owner to force a reset. Non-reset-owner sets
1376                  * the IDC_CTRL BIT0 to prevent Reset-owner from doing a Reset
1377                  * and then forces a Reset by setting device_state to
1378                  * NEED_RESET. */
1379                 DEBUG2(ql4_printk(KERN_INFO, ha,
1380                                   "%s: HW state already set to NEED_RESET\n",
1381                                   __func__));
1382         }
1383
1384         /* For ISP8324 and ISP8042, Reset owner is NIC, iSCSI or FCOE based on
1385          * priority and which drivers are present. Unlike ISP8022, the function
1386          * setting NEED_RESET, may not be the Reset owner. */
1387         if (qla4_83xx_can_perform_reset(ha))
1388                 set_bit(AF_8XXX_RST_OWNER, &ha->flags);
1389
1390         ha->isp_ops->idc_unlock(ha);
1391         rval = qla4_8xxx_device_state_handler(ha);
1392
1393         ha->isp_ops->idc_lock(ha);
1394         qla4_8xxx_clear_rst_ready(ha);
1395 exit_isp_reset:
1396         ha->isp_ops->idc_unlock(ha);
1397
1398         if (rval == QLA_SUCCESS)
1399                 clear_bit(AF_FW_RECOVERY, &ha->flags);
1400
1401         return rval;
1402 }
1403
1404 static void qla4_83xx_dump_pause_control_regs(struct scsi_qla_host *ha)
1405 {
1406         u32 val = 0, val1 = 0;
1407         int i, status = QLA_SUCCESS;
1408
1409         status = qla4_83xx_rd_reg_indirect(ha, QLA83XX_SRE_SHIM_CONTROL, &val);
1410         DEBUG2(ql4_printk(KERN_INFO, ha, "SRE-Shim Ctrl:0x%x\n", val));
1411
1412         /* Port 0 Rx Buffer Pause Threshold Registers. */
1413         DEBUG2(ql4_printk(KERN_INFO, ha,
1414                 "Port 0 Rx Buffer Pause Threshold Registers[TC7..TC0]:"));
1415         for (i = 0; i < 8; i++) {
1416                 status = qla4_83xx_rd_reg_indirect(ha,
1417                                 QLA83XX_PORT0_RXB_PAUSE_THRS + (i * 0x4), &val);
1418                 DEBUG2(pr_info("0x%x ", val));
1419         }
1420
1421         DEBUG2(pr_info("\n"));
1422
1423         /* Port 1 Rx Buffer Pause Threshold Registers. */
1424         DEBUG2(ql4_printk(KERN_INFO, ha,
1425                 "Port 1 Rx Buffer Pause Threshold Registers[TC7..TC0]:"));
1426         for (i = 0; i < 8; i++) {
1427                 status = qla4_83xx_rd_reg_indirect(ha,
1428                                 QLA83XX_PORT1_RXB_PAUSE_THRS + (i * 0x4), &val);
1429                 DEBUG2(pr_info("0x%x  ", val));
1430         }
1431
1432         DEBUG2(pr_info("\n"));
1433
1434         /* Port 0 RxB Traffic Class Max Cell Registers. */
1435         DEBUG2(ql4_printk(KERN_INFO, ha,
1436                 "Port 0 RxB Traffic Class Max Cell Registers[3..0]:"));
1437         for (i = 0; i < 4; i++) {
1438                 status = qla4_83xx_rd_reg_indirect(ha,
1439                                QLA83XX_PORT0_RXB_TC_MAX_CELL + (i * 0x4), &val);
1440                 DEBUG2(pr_info("0x%x  ", val));
1441         }
1442
1443         DEBUG2(pr_info("\n"));
1444
1445         /* Port 1 RxB Traffic Class Max Cell Registers. */
1446         DEBUG2(ql4_printk(KERN_INFO, ha,
1447                 "Port 1 RxB Traffic Class Max Cell Registers[3..0]:"));
1448         for (i = 0; i < 4; i++) {
1449                 status = qla4_83xx_rd_reg_indirect(ha,
1450                                QLA83XX_PORT1_RXB_TC_MAX_CELL + (i * 0x4), &val);
1451                 DEBUG2(pr_info("0x%x  ", val));
1452         }
1453
1454         DEBUG2(pr_info("\n"));
1455
1456         /* Port 0 RxB Rx Traffic Class Stats. */
1457         DEBUG2(ql4_printk(KERN_INFO, ha,
1458                           "Port 0 RxB Rx Traffic Class Stats [TC7..TC0]"));
1459         for (i = 7; i >= 0; i--) {
1460                 status = qla4_83xx_rd_reg_indirect(ha,
1461                                                    QLA83XX_PORT0_RXB_TC_STATS,
1462                                                    &val);
1463                 val &= ~(0x7 << 29);    /* Reset bits 29 to 31 */
1464                 qla4_83xx_wr_reg_indirect(ha, QLA83XX_PORT0_RXB_TC_STATS,
1465                                           (val | (i << 29)));
1466                 status = qla4_83xx_rd_reg_indirect(ha,
1467                                                    QLA83XX_PORT0_RXB_TC_STATS,
1468                                                    &val);
1469                 DEBUG2(pr_info("0x%x  ", val));
1470         }
1471
1472         DEBUG2(pr_info("\n"));
1473
1474         /* Port 1 RxB Rx Traffic Class Stats. */
1475         DEBUG2(ql4_printk(KERN_INFO, ha,
1476                           "Port 1 RxB Rx Traffic Class Stats [TC7..TC0]"));
1477         for (i = 7; i >= 0; i--) {
1478                 status = qla4_83xx_rd_reg_indirect(ha,
1479                                                    QLA83XX_PORT1_RXB_TC_STATS,
1480                                                    &val);
1481                 val &= ~(0x7 << 29);    /* Reset bits 29 to 31 */
1482                 qla4_83xx_wr_reg_indirect(ha, QLA83XX_PORT1_RXB_TC_STATS,
1483                                           (val | (i << 29)));
1484                 status = qla4_83xx_rd_reg_indirect(ha,
1485                                                    QLA83XX_PORT1_RXB_TC_STATS,
1486                                                    &val);
1487                 DEBUG2(pr_info("0x%x  ", val));
1488         }
1489
1490         DEBUG2(pr_info("\n"));
1491
1492         status = qla4_83xx_rd_reg_indirect(ha, QLA83XX_PORT2_IFB_PAUSE_THRS,
1493                                            &val);
1494         status = qla4_83xx_rd_reg_indirect(ha, QLA83XX_PORT3_IFB_PAUSE_THRS,
1495                                            &val1);
1496
1497         DEBUG2(ql4_printk(KERN_INFO, ha,
1498                           "IFB-Pause Thresholds: Port 2:0x%x, Port 3:0x%x\n",
1499                           val, val1));
1500 }
1501
1502 static void __qla4_83xx_disable_pause(struct scsi_qla_host *ha)
1503 {
1504         int i;
1505
1506         /* set SRE-Shim Control Register */
1507         qla4_83xx_wr_reg_indirect(ha, QLA83XX_SRE_SHIM_CONTROL,
1508                                   QLA83XX_SET_PAUSE_VAL);
1509
1510         for (i = 0; i < 8; i++) {
1511                 /* Port 0 Rx Buffer Pause Threshold Registers. */
1512                 qla4_83xx_wr_reg_indirect(ha,
1513                                       QLA83XX_PORT0_RXB_PAUSE_THRS + (i * 0x4),
1514                                       QLA83XX_SET_PAUSE_VAL);
1515                 /* Port 1 Rx Buffer Pause Threshold Registers. */
1516                 qla4_83xx_wr_reg_indirect(ha,
1517                                       QLA83XX_PORT1_RXB_PAUSE_THRS + (i * 0x4),
1518                                       QLA83XX_SET_PAUSE_VAL);
1519         }
1520
1521         for (i = 0; i < 4; i++) {
1522                 /* Port 0 RxB Traffic Class Max Cell Registers. */
1523                 qla4_83xx_wr_reg_indirect(ha,
1524                                      QLA83XX_PORT0_RXB_TC_MAX_CELL + (i * 0x4),
1525                                      QLA83XX_SET_TC_MAX_CELL_VAL);
1526                 /* Port 1 RxB Traffic Class Max Cell Registers. */
1527                 qla4_83xx_wr_reg_indirect(ha,
1528                                      QLA83XX_PORT1_RXB_TC_MAX_CELL + (i * 0x4),
1529                                      QLA83XX_SET_TC_MAX_CELL_VAL);
1530         }
1531
1532         qla4_83xx_wr_reg_indirect(ha, QLA83XX_PORT2_IFB_PAUSE_THRS,
1533                                   QLA83XX_SET_PAUSE_VAL);
1534         qla4_83xx_wr_reg_indirect(ha, QLA83XX_PORT3_IFB_PAUSE_THRS,
1535                                   QLA83XX_SET_PAUSE_VAL);
1536
1537         ql4_printk(KERN_INFO, ha, "Disabled pause frames successfully.\n");
1538 }
1539
1540 /**
1541  * qla4_83xx_eport_init - Initialize EPort.
1542  * @ha: Pointer to host adapter structure.
1543  *
1544  * If EPort hardware is in reset state before disabling pause, there would be
1545  * serious hardware wedging issues. To prevent this perform eport init everytime
1546  * before disabling pause frames.
1547  **/
1548 static void qla4_83xx_eport_init(struct scsi_qla_host *ha)
1549 {
1550         /* Clear the 8 registers */
1551         qla4_83xx_wr_reg_indirect(ha, QLA83XX_RESET_REG, 0x0);
1552         qla4_83xx_wr_reg_indirect(ha, QLA83XX_RESET_PORT0, 0x0);
1553         qla4_83xx_wr_reg_indirect(ha, QLA83XX_RESET_PORT1, 0x0);
1554         qla4_83xx_wr_reg_indirect(ha, QLA83XX_RESET_PORT2, 0x0);
1555         qla4_83xx_wr_reg_indirect(ha, QLA83XX_RESET_PORT3, 0x0);
1556         qla4_83xx_wr_reg_indirect(ha, QLA83XX_RESET_SRE_SHIM, 0x0);
1557         qla4_83xx_wr_reg_indirect(ha, QLA83XX_RESET_EPG_SHIM, 0x0);
1558         qla4_83xx_wr_reg_indirect(ha, QLA83XX_RESET_ETHER_PCS, 0x0);
1559
1560         /* Write any value to Reset Control register */
1561         qla4_83xx_wr_reg_indirect(ha, QLA83XX_RESET_CONTROL, 0xFF);
1562
1563         ql4_printk(KERN_INFO, ha, "EPORT is out of reset.\n");
1564 }
1565
1566 void qla4_83xx_disable_pause(struct scsi_qla_host *ha)
1567 {
1568         ha->isp_ops->idc_lock(ha);
1569         /* Before disabling pause frames, ensure that eport is not in reset */
1570         qla4_83xx_eport_init(ha);
1571         qla4_83xx_dump_pause_control_regs(ha);
1572         __qla4_83xx_disable_pause(ha);
1573         ha->isp_ops->idc_unlock(ha);
1574 }
1575
1576 /**
1577  * qla4_83xx_is_detached - Check if we are marked invisible.
1578  * @ha: Pointer to host adapter structure.
1579  **/
1580 int qla4_83xx_is_detached(struct scsi_qla_host *ha)
1581 {
1582         uint32_t drv_active;
1583
1584         drv_active = qla4_8xxx_rd_direct(ha, QLA8XXX_CRB_DRV_ACTIVE);
1585
1586         if (test_bit(AF_INIT_DONE, &ha->flags) &&
1587             !(drv_active & (1 << ha->func_num))) {
1588                 DEBUG2(ql4_printk(KERN_INFO, ha, "%s: drv_active = 0x%X\n",
1589                                   __func__, drv_active));
1590                 return QLA_SUCCESS;
1591         }
1592
1593         return QLA_ERROR;
1594 }