drivers/scsi/qla2xxx/qla_inline.h

   1 /*
   2  * QLogic Fibre Channel HBA Driver
   3  * Copyright (c)  2003-2011 QLogic Corporation
   4  *
   5  * See LICENSE.qla2xxx for copyright and licensing details.
   6  */
   7
   8 /*
   9  * qla2x00_debounce_register
  10  *      Debounce register.
  11  *
  12  * Input:
  13  *      port = register address.
  14  *
  15  * Returns:
  16  *      register value.
  17  */
  18 static __inline__ uint16_t
  19 qla2x00_debounce_register(volatile uint16_t __iomem *addr)
  20 {
  21         volatile uint16_t first;
  22         volatile uint16_t second;
  23
  24         do {
  25                 first = RD_REG_WORD(addr);
  26                 barrier();
  27                 cpu_relax();
  28                 second = RD_REG_WORD(addr);
  29         } while (first != second);
  30
  31         return (first);
  32 }
  33
  34 static inline void
  35 qla2x00_poll(struct rsp_que *rsp)
  36 {
  37         unsigned long flags;
  38         struct qla_hw_data *ha = rsp->hw;
  39         local_irq_save(flags);
  40         if (IS_QLA82XX(ha))
  41                 qla82xx_poll(0, rsp);
  42         else
  43                 ha->isp_ops->intr_handler(0, rsp);
  44         local_irq_restore(flags);
  45 }
  46
  47 static inline uint8_t *
  48 host_to_fcp_swap(uint8_t *fcp, uint32_t bsize)
  49 {
  50        uint32_t *ifcp = (uint32_t *) fcp;
  51        uint32_t *ofcp = (uint32_t *) fcp;
  52        uint32_t iter = bsize >> 2;
  53
  54        for (; iter ; iter--)
  55                *ofcp++ = swab32(*ifcp++);
  56
  57        return fcp;
  58 }
  59
  60 static inline int
  61 qla2x00_is_reserved_id(scsi_qla_host_t *vha, uint16_t loop_id)
  62 {
  63         struct qla_hw_data *ha = vha->hw;
  64         if (IS_FWI2_CAPABLE(ha))
  65                 return (loop_id > NPH_LAST_HANDLE);
  66
  67         return ((loop_id > ha->max_loop_id && loop_id < SNS_FIRST_LOOP_ID) ||
  68             loop_id == MANAGEMENT_SERVER || loop_id == BROADCAST);
  69 }
  70
  71 static inline void
  72 qla2x00_clean_dsd_pool(struct qla_hw_data *ha, srb_t *sp)
  73 {
  74         struct dsd_dma *dsd_ptr, *tdsd_ptr;
  75         struct crc_context *ctx;
  76
  77         ctx = (struct crc_context *)GET_CMD_CTX_SP(sp);
  78
  79         /* clean up allocated prev pool */
  80         list_for_each_entry_safe(dsd_ptr, tdsd_ptr,
  81             &ctx->dsd_list, list) {
  82                 dma_pool_free(ha->dl_dma_pool, dsd_ptr->dsd_addr,
  83                     dsd_ptr->dsd_list_dma);
  84                 list_del(&dsd_ptr->list);
  85                 kfree(dsd_ptr);
  86         }
  87         INIT_LIST_HEAD(&ctx->dsd_list);
  88 }
  89
  90 static inline void
  91 qla2x00_set_fcport_state(fc_port_t *fcport, int state)
  92 {
  93         int old_state;
  94
  95         old_state = atomic_read(&fcport->state);
  96         atomic_set(&fcport->state, state);
  97
  98         /* Don't print state transitions during initial allocation of fcport */
  99         if (old_state && old_state != state) {
 100                 ql_dbg(ql_dbg_disc, fcport->vha, 0x207d,
 101                     "FCPort state transitioned from %s to %s - "
 102                     "portid=%02x%02x%02x.\n",
 103                     port_state_str[old_state], port_state_str[state],
 104                     fcport->d_id.b.domain, fcport->d_id.b.area,
 105                     fcport->d_id.b.al_pa);
 106         }
 107 }
 108
 109 static inline int
 110 qla2x00_hba_err_chk_enabled(srb_t *sp)
 111 {
 112         /*
 113          * Uncomment when corresponding SCSI changes are done.
 114          *
 115         if (!sp->cmd->prot_chk)
 116                 return 0;
 117          *
 118          */
 119         switch (scsi_get_prot_op(GET_CMD_SP(sp))) {
 120         case SCSI_PROT_READ_STRIP:
 121         case SCSI_PROT_WRITE_INSERT:
 122                 if (ql2xenablehba_err_chk >= 1)
 123                         return 1;
 124                 break;
 125         case SCSI_PROT_READ_PASS:
 126         case SCSI_PROT_WRITE_PASS:
 127                 if (ql2xenablehba_err_chk >= 2)
 128                         return 1;
 129                 break;
 130         case SCSI_PROT_READ_INSERT:
 131         case SCSI_PROT_WRITE_STRIP:
 132                 return 1;
 133         }
 134         return 0;
 135 }
 136
 137 static inline int
 138 qla2x00_reset_active(scsi_qla_host_t *vha)
 139 {
 140         scsi_qla_host_t *base_vha = pci_get_drvdata(vha->hw->pdev);
 141
 142         /* Test appropriate base-vha and vha flags. */
 143         return test_bit(ISP_ABORT_NEEDED, &base_vha->dpc_flags) ||
 144             test_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags) ||
 145             test_bit(ISP_ABORT_RETRY, &base_vha->dpc_flags) ||
 146             test_bit(ISP_ABORT_NEEDED, &vha->dpc_flags) ||
 147             test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags);
 148 }
 149
 150 static inline srb_t *
 151 qla2x00_get_sp(scsi_qla_host_t *vha, fc_port_t *fcport, gfp_t flag)
 152 {
 153         srb_t *sp = NULL;
 154         struct qla_hw_data *ha = vha->hw;
 155         uint8_t bail;
 156
 157         QLA_VHA_MARK_BUSY(vha, bail);
 158         if (unlikely(bail))
 159                 return NULL;
 160
 161         sp = mempool_alloc(ha->srb_mempool, flag);
 162         if (!sp)
 163                 goto done;
 164
 165         memset(sp, 0, sizeof(*sp));
 166         sp->fcport = fcport;
 167         sp->iocbs = 1;
 168 done:
 169         if (!sp)
 170                 QLA_VHA_MARK_NOT_BUSY(vha);
 171         return sp;
 172 }
 173
 174 static inline void
 175 qla2x00_init_timer(srb_t *sp, unsigned long tmo)
 176 {
 177         init_timer(&sp->u.iocb_cmd.timer);
 178         sp->u.iocb_cmd.timer.expires = jiffies + tmo * HZ;
 179         sp->u.iocb_cmd.timer.data = (unsigned long)sp;
 180         sp->u.iocb_cmd.timer.function = qla2x00_sp_timeout;
 181         add_timer(&sp->u.iocb_cmd.timer);
 182         sp->free = qla2x00_sp_free;
 183 }
 184
 185 static inline int
 186 qla2x00_gid_list_size(struct qla_hw_data *ha)
 187 {
 188         return sizeof(struct gid_list_info) * ha->max_fibre_devices;
 189 }