drivers/scsi/qla4xxx/ql4_nvram.c

   1 /*
   2  * QLogic iSCSI HBA Driver
   3  * Copyright (c)  2003-2010 QLogic Corporation
   4  *
   5  * See LICENSE.qla4xxx for copyright and licensing details.
   6  */
   7
   8 #include "ql4_def.h"
   9 #include "ql4_glbl.h"
  10 #include "ql4_dbg.h"
  11 #include "ql4_inline.h"
  12
  13 static inline void eeprom_cmd(uint32_t cmd, struct scsi_qla_host *ha)
  14 {
  15         writel(cmd, isp_nvram(ha));
  16         readl(isp_nvram(ha));
  17         udelay(1);
  18 }
  19
  20 static inline int eeprom_size(struct scsi_qla_host *ha)
  21 {
  22         return is_qla4010(ha) ? FM93C66A_SIZE_16 : FM93C86A_SIZE_16;
  23 }
  24
  25 static inline int eeprom_no_addr_bits(struct scsi_qla_host *ha)
  26 {
  27         return is_qla4010(ha) ? FM93C56A_NO_ADDR_BITS_16 :
  28                 FM93C86A_NO_ADDR_BITS_16 ;
  29 }
  30
  31 static inline int eeprom_no_data_bits(struct scsi_qla_host *ha)
  32 {
  33         return FM93C56A_DATA_BITS_16;
  34 }
  35
  36 static int fm93c56a_select(struct scsi_qla_host * ha)
  37 {
  38         DEBUG5(printk(KERN_ERR "fm93c56a_select:\n"));
  39
  40         ha->eeprom_cmd_data = AUBURN_EEPROM_CS_1 | 0x000f0000;
  41         eeprom_cmd(ha->eeprom_cmd_data, ha);
  42         return 1;
  43 }
  44
  45 static int fm93c56a_cmd(struct scsi_qla_host * ha, int cmd, int addr)
  46 {
  47         int i;
  48         int mask;
  49         int dataBit;
  50         int previousBit;
  51
  52         /* Clock in a zero, then do the start bit. */
  53         eeprom_cmd(ha->eeprom_cmd_data | AUBURN_EEPROM_DO_1, ha);
  54
  55         eeprom_cmd(ha->eeprom_cmd_data | AUBURN_EEPROM_DO_1 |
  56                AUBURN_EEPROM_CLK_RISE, ha);
  57         eeprom_cmd(ha->eeprom_cmd_data | AUBURN_EEPROM_DO_1 |
  58                AUBURN_EEPROM_CLK_FALL, ha);
  59
  60         mask = 1 << (FM93C56A_CMD_BITS - 1);
  61
  62         /* Force the previous data bit to be different. */
  63         previousBit = 0xffff;
  64         for (i = 0; i < FM93C56A_CMD_BITS; i++) {
  65                 dataBit =
  66                         (cmd & mask) ? AUBURN_EEPROM_DO_1 : AUBURN_EEPROM_DO_0;
  67                 if (previousBit != dataBit) {
  68
  69                         /*
  70                          * If the bit changed, then change the DO state to
  71                          * match.
  72                          */
  73                         eeprom_cmd(ha->eeprom_cmd_data | dataBit, ha);
  74                         previousBit = dataBit;
  75                 }
  76                 eeprom_cmd(ha->eeprom_cmd_data | dataBit |
  77                        AUBURN_EEPROM_CLK_RISE, ha);
  78                 eeprom_cmd(ha->eeprom_cmd_data | dataBit |
  79                        AUBURN_EEPROM_CLK_FALL, ha);
  80
  81                 cmd = cmd << 1;
  82         }
  83         mask = 1 << (eeprom_no_addr_bits(ha) - 1);
  84
  85         /* Force the previous data bit to be different. */
  86         previousBit = 0xffff;
  87         for (i = 0; i < eeprom_no_addr_bits(ha); i++) {
  88                 dataBit = addr & mask ? AUBURN_EEPROM_DO_1 :
  89                         AUBURN_EEPROM_DO_0;
  90                 if (previousBit != dataBit) {
  91                         /*
  92                          * If the bit changed, then change the DO state to
  93                          * match.
  94                          */
  95                         eeprom_cmd(ha->eeprom_cmd_data | dataBit, ha);
  96
  97                         previousBit = dataBit;
  98                 }
  99                 eeprom_cmd(ha->eeprom_cmd_data | dataBit |
 100                        AUBURN_EEPROM_CLK_RISE, ha);
 101                 eeprom_cmd(ha->eeprom_cmd_data | dataBit |
 102                        AUBURN_EEPROM_CLK_FALL, ha);
 103
 104                 addr = addr << 1;
 105         }
 106         return 1;
 107 }
 108
 109 static int fm93c56a_deselect(struct scsi_qla_host * ha)
 110 {
 111         ha->eeprom_cmd_data = AUBURN_EEPROM_CS_0 | 0x000f0000;
 112         eeprom_cmd(ha->eeprom_cmd_data, ha);
 113         return 1;
 114 }
 115
 116 static int fm93c56a_datain(struct scsi_qla_host * ha, unsigned short *value)
 117 {
 118         int i;
 119         int data = 0;
 120         int dataBit;
 121
 122         /* Read the data bits
 123          * The first bit is a dummy.  Clock right over it. */
 124         for (i = 0; i < eeprom_no_data_bits(ha); i++) {
 125                 eeprom_cmd(ha->eeprom_cmd_data |
 126                        AUBURN_EEPROM_CLK_RISE, ha);
 127                 eeprom_cmd(ha->eeprom_cmd_data |
 128                        AUBURN_EEPROM_CLK_FALL, ha);
 129
 130                 dataBit = (readw(isp_nvram(ha)) & AUBURN_EEPROM_DI_1) ? 1 : 0;
 131
 132                 data = (data << 1) | dataBit;
 133         }
 134
 135         *value = data;
 136         return 1;
 137 }
 138
 139 static int eeprom_readword(int eepromAddr, u16 * value,
 140                            struct scsi_qla_host * ha)
 141 {
 142         fm93c56a_select(ha);
 143         fm93c56a_cmd(ha, FM93C56A_READ, eepromAddr);
 144         fm93c56a_datain(ha, value);
 145         fm93c56a_deselect(ha);
 146         return 1;
 147 }
 148
 149 /* Hardware_lock must be set before calling */
 150 u16 rd_nvram_word(struct scsi_qla_host * ha, int offset)
 151 {
 152         u16 val = 0;
 153
 154         /* NOTE: NVRAM uses half-word addresses */
 155         eeprom_readword(offset, &val, ha);
 156         return val;
 157 }
 158
 159 u8 rd_nvram_byte(struct scsi_qla_host *ha, int offset)
 160 {
 161         u16 val = 0;
 162         u8 rval = 0;
 163         int index = 0;
 164
 165         if (offset & 0x1)
 166                 index = (offset - 1) / 2;
 167         else
 168                 index = offset / 2;
 169
 170         val = le16_to_cpu(rd_nvram_word(ha, index));
 171
 172         if (offset & 0x1)
 173                 rval = (u8)((val & 0xff00) >> 8);
 174         else
 175                 rval = (u8)((val & 0x00ff));
 176
 177         return rval;
 178 }
 179
 180 int qla4xxx_is_nvram_configuration_valid(struct scsi_qla_host * ha)
 181 {
 182         int status = QLA_ERROR;
 183         uint16_t checksum = 0;
 184         uint32_t index;
 185         unsigned long flags;
 186
 187         spin_lock_irqsave(&ha->hardware_lock, flags);
 188         for (index = 0; index < eeprom_size(ha); index++)
 189                 checksum += rd_nvram_word(ha, index);
 190         spin_unlock_irqrestore(&ha->hardware_lock, flags);
 191
 192         if (checksum == 0)
 193                 status = QLA_SUCCESS;
 194
 195         return status;
 196 }
 197
 198 /*************************************************************************
 199  *
 200  *                      Hardware Semaphore routines
 201  *
 202  *************************************************************************/
 203 int ql4xxx_sem_spinlock(struct scsi_qla_host * ha, u32 sem_mask, u32 sem_bits)
 204 {
 205         uint32_t value;
 206         unsigned long flags;
 207         unsigned int seconds = 30;
 208
 209         DEBUG2(printk("scsi%ld : Trying to get SEM lock - mask= 0x%x, code = "
 210                       "0x%x\n", ha->host_no, sem_mask, sem_bits));
 211         do {
 212                 spin_lock_irqsave(&ha->hardware_lock, flags);
 213                 writel((sem_mask | sem_bits), isp_semaphore(ha));
 214                 value = readw(isp_semaphore(ha));
 215                 spin_unlock_irqrestore(&ha->hardware_lock, flags);
 216                 if ((value & (sem_mask >> 16)) == sem_bits) {
 217                         DEBUG2(printk("scsi%ld : Got SEM LOCK - mask= 0x%x, "
 218                                       "code = 0x%x\n", ha->host_no,
 219                                       sem_mask, sem_bits));
 220                         return QLA_SUCCESS;
 221                 }
 222                 ssleep(1);
 223         } while (--seconds);
 224         return QLA_ERROR;
 225 }
 226
 227 void ql4xxx_sem_unlock(struct scsi_qla_host * ha, u32 sem_mask)
 228 {
 229         unsigned long flags;
 230
 231         spin_lock_irqsave(&ha->hardware_lock, flags);
 232         writel(sem_mask, isp_semaphore(ha));
 233         readl(isp_semaphore(ha));
 234         spin_unlock_irqrestore(&ha->hardware_lock, flags);
 235
 236         DEBUG2(printk("scsi%ld : UNLOCK SEM - mask= 0x%x\n", ha->host_no,
 237                       sem_mask));
 238 }
 239
 240 int ql4xxx_sem_lock(struct scsi_qla_host * ha, u32 sem_mask, u32 sem_bits)
 241 {
 242         uint32_t value;
 243         unsigned long flags;
 244
 245         spin_lock_irqsave(&ha->hardware_lock, flags);
 246         writel((sem_mask | sem_bits), isp_semaphore(ha));
 247         value = readw(isp_semaphore(ha));
 248         spin_unlock_irqrestore(&ha->hardware_lock, flags);
 249         if ((value & (sem_mask >> 16)) == sem_bits) {
 250                 DEBUG2(printk("scsi%ld : Got SEM LOCK - mask= 0x%x, code = "
 251                               "0x%x, sema code=0x%x\n", ha->host_no,
 252                               sem_mask, sem_bits, value));
 253                 return 1;
 254         }
 255         return 0;
 256 }