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