1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Copyright (C) 2004 - 2006 rt2x00 SourceForge Project 4 * <http://rt2x00.serialmonkey.com> 5 * 6 * Module: eeprom_93cx6 7 * Abstract: EEPROM reader routines for 93cx6 chipsets. 8 * Supported chipsets: 93c46 & 93c66. 9 */ 10 11 #include <linux/kernel.h> 12 #include <linux/module.h> 13 #include <linux/delay.h> 14 #include <linux/eeprom_93cx6.h> 15 16 MODULE_AUTHOR("http://rt2x00.serialmonkey.com"); 17 MODULE_VERSION("1.0"); 18 MODULE_DESCRIPTION("EEPROM 93cx6 chip driver"); 19 MODULE_LICENSE("GPL"); 20 21 static inline void eeprom_93cx6_pulse_high(struct eeprom_93cx6 *eeprom) 22 { 23 eeprom->reg_data_clock = 1; 24 eeprom->register_write(eeprom); 25 26 /* 27 * Add a short delay for the pulse to work. 28 * According to the specifications the "maximum minimum" 29 * time should be 450ns. 30 */ 31 ndelay(450); 32 } 33 34 static inline void eeprom_93cx6_pulse_low(struct eeprom_93cx6 *eeprom) 35 { 36 eeprom->reg_data_clock = 0; 37 eeprom->register_write(eeprom); 38 39 /* 40 * Add a short delay for the pulse to work. 41 * According to the specifications the "maximum minimum" 42 * time should be 450ns. 43 */ 44 ndelay(450); 45 } 46 47 static void eeprom_93cx6_startup(struct eeprom_93cx6 *eeprom) 48 { 49 /* 50 * Clear all flags, and enable chip select. 51 */ 52 eeprom->register_read(eeprom); 53 eeprom->reg_data_in = 0; 54 eeprom->reg_data_out = 0; 55 eeprom->reg_data_clock = 0; 56 eeprom->reg_chip_select = 1; 57 eeprom->drive_data = 1; 58 eeprom->register_write(eeprom); 59 60 /* 61 * kick a pulse. 62 */ 63 eeprom_93cx6_pulse_high(eeprom); 64 eeprom_93cx6_pulse_low(eeprom); 65 } 66 67 static void eeprom_93cx6_cleanup(struct eeprom_93cx6 *eeprom) 68 { 69 /* 70 * Clear chip_select and data_in flags. 71 */ 72 eeprom->register_read(eeprom); 73 eeprom->reg_data_in = 0; 74 eeprom->reg_chip_select = 0; 75 eeprom->register_write(eeprom); 76 77 /* 78 * kick a pulse. 79 */ 80 eeprom_93cx6_pulse_high(eeprom); 81 eeprom_93cx6_pulse_low(eeprom); 82 } 83 84 static void eeprom_93cx6_write_bits(struct eeprom_93cx6 *eeprom, 85 const u16 data, const u16 count) 86 { 87 unsigned int i; 88 89 eeprom->register_read(eeprom); 90 91 /* 92 * Clear data flags. 93 */ 94 eeprom->reg_data_in = 0; 95 eeprom->reg_data_out = 0; 96 eeprom->drive_data = 1; 97 98 /* 99 * Start writing all bits. 100 */ 101 for (i = count; i > 0; i--) { 102 /* 103 * Check if this bit needs to be set. 104 */ 105 eeprom->reg_data_in = !!(data & (1 << (i - 1))); 106 107 /* 108 * Write the bit to the eeprom register. 109 */ 110 eeprom->register_write(eeprom); 111 112 /* 113 * Kick a pulse. 114 */ 115 eeprom_93cx6_pulse_high(eeprom); 116 eeprom_93cx6_pulse_low(eeprom); 117 } 118 119 eeprom->reg_data_in = 0; 120 eeprom->register_write(eeprom); 121 } 122 123 static void eeprom_93cx6_read_bits(struct eeprom_93cx6 *eeprom, 124 u16 *data, const u16 count) 125 { 126 unsigned int i; 127 u16 buf = 0; 128 129 eeprom->register_read(eeprom); 130 131 /* 132 * Clear data flags. 133 */ 134 eeprom->reg_data_in = 0; 135 eeprom->reg_data_out = 0; 136 eeprom->drive_data = 0; 137 138 /* 139 * Start reading all bits. 140 */ 141 for (i = count; i > 0; i--) { 142 eeprom_93cx6_pulse_high(eeprom); 143 144 eeprom->register_read(eeprom); 145 146 /* 147 * Clear data_in flag. 148 */ 149 eeprom->reg_data_in = 0; 150 151 /* 152 * Read if the bit has been set. 153 */ 154 if (eeprom->reg_data_out) 155 buf |= (1 << (i - 1)); 156 157 eeprom_93cx6_pulse_low(eeprom); 158 } 159 160 *data = buf; 161 } 162 163 /** 164 * eeprom_93cx6_read - Read a word from eeprom 165 * @eeprom: Pointer to eeprom structure 166 * @word: Word index from where we should start reading 167 * @data: target pointer where the information will have to be stored 168 * 169 * This function will read the eeprom data as host-endian word 170 * into the given data pointer. 171 */ 172 void eeprom_93cx6_read(struct eeprom_93cx6 *eeprom, const u8 word, 173 u16 *data) 174 { 175 u16 command; 176 177 /* 178 * Initialize the eeprom register 179 */ 180 eeprom_93cx6_startup(eeprom); 181 182 /* 183 * Select the read opcode and the word to be read. 184 */ 185 command = (PCI_EEPROM_READ_OPCODE << eeprom->width) | word; 186 eeprom_93cx6_write_bits(eeprom, command, 187 PCI_EEPROM_WIDTH_OPCODE + eeprom->width); 188 189 /* 190 * Read the requested 16 bits. 191 */ 192 eeprom_93cx6_read_bits(eeprom, data, 16); 193 194 /* 195 * Cleanup eeprom register. 196 */ 197 eeprom_93cx6_cleanup(eeprom); 198 } 199 EXPORT_SYMBOL_GPL(eeprom_93cx6_read); 200 201 /** 202 * eeprom_93cx6_multiread - Read multiple words from eeprom 203 * @eeprom: Pointer to eeprom structure 204 * @word: Word index from where we should start reading 205 * @data: target pointer where the information will have to be stored 206 * @words: Number of words that should be read. 207 * 208 * This function will read all requested words from the eeprom, 209 * this is done by calling eeprom_93cx6_read() multiple times. 210 * But with the additional change that while the eeprom_93cx6_read 211 * will return host ordered bytes, this method will return little 212 * endian words. 213 */ 214 void eeprom_93cx6_multiread(struct eeprom_93cx6 *eeprom, const u8 word, 215 __le16 *data, const u16 words) 216 { 217 unsigned int i; 218 u16 tmp; 219 220 for (i = 0; i < words; i++) { 221 tmp = 0; 222 eeprom_93cx6_read(eeprom, word + i, &tmp); 223 data[i] = cpu_to_le16(tmp); 224 } 225 } 226 EXPORT_SYMBOL_GPL(eeprom_93cx6_multiread); 227 228 /** 229 * eeprom_93cx6_readb - Read a byte from eeprom 230 * @eeprom: Pointer to eeprom structure 231 * @byte: Byte index from where we should start reading 232 * @data: target pointer where the information will have to be stored 233 * 234 * This function will read a byte of the eeprom data 235 * into the given data pointer. 236 */ 237 void eeprom_93cx6_readb(struct eeprom_93cx6 *eeprom, const u8 byte, 238 u8 *data) 239 { 240 u16 command; 241 u16 tmp; 242 243 /* 244 * Initialize the eeprom register 245 */ 246 eeprom_93cx6_startup(eeprom); 247 248 /* 249 * Select the read opcode and the byte to be read. 250 */ 251 command = (PCI_EEPROM_READ_OPCODE << (eeprom->width + 1)) | byte; 252 eeprom_93cx6_write_bits(eeprom, command, 253 PCI_EEPROM_WIDTH_OPCODE + eeprom->width + 1); 254 255 /* 256 * Read the requested 8 bits. 257 */ 258 eeprom_93cx6_read_bits(eeprom, &tmp, 8); 259 *data = tmp & 0xff; 260 261 /* 262 * Cleanup eeprom register. 263 */ 264 eeprom_93cx6_cleanup(eeprom); 265 } 266 EXPORT_SYMBOL_GPL(eeprom_93cx6_readb); 267 268 /** 269 * eeprom_93cx6_multireadb - Read multiple bytes from eeprom 270 * @eeprom: Pointer to eeprom structure 271 * @byte: Index from where we should start reading 272 * @data: target pointer where the information will have to be stored 273 * @bytes: Number of bytes that should be read. 274 * 275 * This function will read all requested bytes from the eeprom, 276 * this is done by calling eeprom_93cx6_readb() multiple times. 277 */ 278 void eeprom_93cx6_multireadb(struct eeprom_93cx6 *eeprom, const u8 byte, 279 u8 *data, const u16 bytes) 280 { 281 unsigned int i; 282 283 for (i = 0; i < bytes; i++) 284 eeprom_93cx6_readb(eeprom, byte + i, &data[i]); 285 } 286 EXPORT_SYMBOL_GPL(eeprom_93cx6_multireadb); 287 288 /** 289 * eeprom_93cx6_wren - set the write enable state 290 * @eeprom: Pointer to eeprom structure 291 * @enable: true to enable writes, otherwise disable writes 292 * 293 * Set the EEPROM write enable state to either allow or deny 294 * writes depending on the @enable value. 295 */ 296 void eeprom_93cx6_wren(struct eeprom_93cx6 *eeprom, bool enable) 297 { 298 u16 command; 299 300 /* start the command */ 301 eeprom_93cx6_startup(eeprom); 302 303 /* create command to enable/disable */ 304 305 command = enable ? PCI_EEPROM_EWEN_OPCODE : PCI_EEPROM_EWDS_OPCODE; 306 command <<= (eeprom->width - 2); 307 308 eeprom_93cx6_write_bits(eeprom, command, 309 PCI_EEPROM_WIDTH_OPCODE + eeprom->width); 310 311 eeprom_93cx6_cleanup(eeprom); 312 } 313 EXPORT_SYMBOL_GPL(eeprom_93cx6_wren); 314 315 /** 316 * eeprom_93cx6_write - write data to the EEPROM 317 * @eeprom: Pointer to eeprom structure 318 * @addr: Address to write data to. 319 * @data: The data to write to address @addr. 320 * 321 * Write the @data to the specified @addr in the EEPROM and 322 * waiting for the device to finish writing. 323 * 324 * Note, since we do not expect large number of write operations 325 * we delay in between parts of the operation to avoid using excessive 326 * amounts of CPU time busy waiting. 327 */ 328 void eeprom_93cx6_write(struct eeprom_93cx6 *eeprom, u8 addr, u16 data) 329 { 330 int timeout = 100; 331 u16 command; 332 333 /* start the command */ 334 eeprom_93cx6_startup(eeprom); 335 336 command = PCI_EEPROM_WRITE_OPCODE << eeprom->width; 337 command |= addr; 338 339 /* send write command */ 340 eeprom_93cx6_write_bits(eeprom, command, 341 PCI_EEPROM_WIDTH_OPCODE + eeprom->width); 342 343 /* send data */ 344 eeprom_93cx6_write_bits(eeprom, data, 16); 345 346 /* get ready to check for busy */ 347 eeprom->drive_data = 0; 348 eeprom->reg_chip_select = 1; 349 eeprom->register_write(eeprom); 350 351 /* wait at-least 250ns to get DO to be the busy signal */ 352 usleep_range(1000, 2000); 353 354 /* wait for DO to go high to signify finish */ 355 356 while (true) { 357 eeprom->register_read(eeprom); 358 359 if (eeprom->reg_data_out) 360 break; 361 362 usleep_range(1000, 2000); 363 364 if (--timeout <= 0) { 365 printk(KERN_ERR "%s: timeout\n", __func__); 366 break; 367 } 368 } 369 370 eeprom_93cx6_cleanup(eeprom); 371 } 372 EXPORT_SYMBOL_GPL(eeprom_93cx6_write); 373