1/* 2 * QLogic iSCSI HBA Driver 3 * Copyright (c) 2003-2006 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 13static 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 20static inline int eeprom_size(struct scsi_qla_host *ha) 21{ 22 return is_qla4010(ha) ? FM93C66A_SIZE_16 : FM93C86A_SIZE_16; 23} 24 25static 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 31static inline int eeprom_no_data_bits(struct scsi_qla_host *ha) 32{ 33 return FM93C56A_DATA_BITS_16; 34} 35 36static 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 45static 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 109static 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 116static 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 139static 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 */ 150u16 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 159int qla4xxx_is_nvram_configuration_valid(struct scsi_qla_host * ha) 160{ 161 int status = QLA_ERROR; 162 uint16_t checksum = 0; 163 uint32_t index; 164 unsigned long flags; 165 166 spin_lock_irqsave(&ha->hardware_lock, flags); 167 for (index = 0; index < eeprom_size(ha); index++) 168 checksum += rd_nvram_word(ha, index); 169 spin_unlock_irqrestore(&ha->hardware_lock, flags); 170 171 if (checksum == 0) 172 status = QLA_SUCCESS; 173 174 return status; 175} 176 177/************************************************************************* 178 * 179 * Hardware Semaphore routines 180 * 181 *************************************************************************/ 182int ql4xxx_sem_spinlock(struct scsi_qla_host * ha, u32 sem_mask, u32 sem_bits) 183{ 184 uint32_t value; 185 unsigned long flags; 186 unsigned int seconds = 30; 187 188 DEBUG2(printk("scsi%ld : Trying to get SEM lock - mask= 0x%x, code = " 189 "0x%x\n", ha->host_no, sem_mask, sem_bits)); 190 do { 191 spin_lock_irqsave(&ha->hardware_lock, flags); 192 writel((sem_mask | sem_bits), isp_semaphore(ha)); 193 value = readw(isp_semaphore(ha)); 194 spin_unlock_irqrestore(&ha->hardware_lock, flags); 195 if ((value & (sem_mask >> 16)) == sem_bits) { 196 DEBUG2(printk("scsi%ld : Got SEM LOCK - mask= 0x%x, " 197 "code = 0x%x\n", ha->host_no, 198 sem_mask, sem_bits)); 199 return QLA_SUCCESS; 200 } 201 ssleep(1); 202 } while (--seconds); 203 return QLA_ERROR; 204} 205 206void ql4xxx_sem_unlock(struct scsi_qla_host * ha, u32 sem_mask) 207{ 208 unsigned long flags; 209 210 spin_lock_irqsave(&ha->hardware_lock, flags); 211 writel(sem_mask, isp_semaphore(ha)); 212 readl(isp_semaphore(ha)); 213 spin_unlock_irqrestore(&ha->hardware_lock, flags); 214 215 DEBUG2(printk("scsi%ld : UNLOCK SEM - mask= 0x%x\n", ha->host_no, 216 sem_mask)); 217} 218 219int ql4xxx_sem_lock(struct scsi_qla_host * ha, u32 sem_mask, u32 sem_bits) 220{ 221 uint32_t value; 222 unsigned long flags; 223 224 spin_lock_irqsave(&ha->hardware_lock, flags); 225 writel((sem_mask | sem_bits), isp_semaphore(ha)); 226 value = readw(isp_semaphore(ha)); 227 spin_unlock_irqrestore(&ha->hardware_lock, flags); 228 if ((value & (sem_mask >> 16)) == sem_bits) { 229 DEBUG2(printk("scsi%ld : Got SEM LOCK - mask= 0x%x, code = " 230 "0x%x, sema code=0x%x\n", ha->host_no, 231 sem_mask, sem_bits, value)); 232 return 1; 233 } 234 return 0; 235} 236