1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  *   Copyright (C) 2016 T-Platforms. All Rights Reserved.
4  *
5  * IDT PCIe-switch NTB Linux driver
6  *
7  * Contact Information:
8  * Serge Semin <fancer.lancer@gmail.com>, <Sergey.Semin@t-platforms.ru>
9  */
10 /*
11  *           NOTE of the IDT 89HPESx SMBus-slave interface driver
12  *    This driver primarily is developed to have an access to EEPROM device of
13  * IDT PCIe-switches. IDT provides a simple SMBus interface to perform IO-
14  * operations from/to EEPROM, which is located at private (so called Master)
15  * SMBus of switches. Using that interface this the driver creates a simple
16  * binary sysfs-file in the device directory:
17  * /sys/bus/i2c/devices/<bus>-<devaddr>/eeprom
18  * In case if read-only flag is specified in the dts-node of device desription,
19  * User-space applications won't be able to write to the EEPROM sysfs-node.
20  *    Additionally IDT 89HPESx SMBus interface has an ability to write/read
21  * data of device CSRs. This driver exposes debugf-file to perform simple IO
22  * operations using that ability for just basic debug purpose. Particularly
23  * next file is created in the specific debugfs-directory:
24  * /sys/kernel/debug/idt_csr/
25  * Format of the debugfs-node is:
26  * $ cat /sys/kernel/debug/idt_csr/<bus>-<devaddr>/<devname>;
27  * <CSR address>:<CSR value>
28  * So reading the content of the file gives current CSR address and it value.
29  * If User-space application wishes to change current CSR address,
30  * it can just write a proper value to the sysfs-file:
31  * $ echo "<CSR address>" > /sys/kernel/debug/idt_csr/<bus>-<devaddr>/<devname>
32  * If it wants to change the CSR value as well, the format of the write
33  * operation is:
34  * $ echo "<CSR address>:<CSR value>" > \
35  *        /sys/kernel/debug/idt_csr/<bus>-<devaddr>/<devname>;
36  * CSR address and value can be any of hexadecimal, decimal or octal format.
37  */
38 
39 #include <linux/kernel.h>
40 #include <linux/init.h>
41 #include <linux/module.h>
42 #include <linux/types.h>
43 #include <linux/sizes.h>
44 #include <linux/slab.h>
45 #include <linux/mutex.h>
46 #include <linux/sysfs.h>
47 #include <linux/debugfs.h>
48 #include <linux/mod_devicetable.h>
49 #include <linux/property.h>
50 #include <linux/i2c.h>
51 #include <linux/pci_ids.h>
52 #include <linux/delay.h>
53 
54 #define IDT_NAME		"89hpesx"
55 #define IDT_89HPESX_DESC	"IDT 89HPESx SMBus-slave interface driver"
56 #define IDT_89HPESX_VER		"1.0"
57 
58 MODULE_DESCRIPTION(IDT_89HPESX_DESC);
59 MODULE_VERSION(IDT_89HPESX_VER);
60 MODULE_LICENSE("GPL v2");
61 MODULE_AUTHOR("T-platforms");
62 
63 /*
64  * csr_dbgdir - CSR read/write operations Debugfs directory
65  */
66 static struct dentry *csr_dbgdir;
67 
68 /*
69  * struct idt_89hpesx_dev - IDT 89HPESx device data structure
70  * @eesize:	Size of EEPROM in bytes (calculated from "idt,eecompatible")
71  * @eero:	EEPROM Read-only flag
72  * @eeaddr:	EEPROM custom address
73  *
74  * @inieecmd:	Initial cmd value for EEPROM read/write operations
75  * @inicsrcmd:	Initial cmd value for CSR read/write operations
76  * @iniccode:	Initialial command code value for IO-operations
77  *
78  * @csr:	CSR address to perform read operation
79  *
80  * @smb_write:	SMBus write method
81  * @smb_read:	SMBus read method
82  * @smb_mtx:	SMBus mutex
83  *
84  * @client:	i2c client used to perform IO operations
85  *
86  * @ee_file:	EEPROM read/write sysfs-file
87  */
88 struct idt_smb_seq;
89 struct idt_89hpesx_dev {
90 	u32 eesize;
91 	bool eero;
92 	u8 eeaddr;
93 
94 	u8 inieecmd;
95 	u8 inicsrcmd;
96 	u8 iniccode;
97 
98 	u16 csr;
99 
100 	int (*smb_write)(struct idt_89hpesx_dev *, const struct idt_smb_seq *);
101 	int (*smb_read)(struct idt_89hpesx_dev *, struct idt_smb_seq *);
102 	struct mutex smb_mtx;
103 
104 	struct i2c_client *client;
105 
106 	struct bin_attribute *ee_file;
107 	struct dentry *csr_dir;
108 };
109 
110 /*
111  * struct idt_smb_seq - sequence of data to be read/written from/to IDT 89HPESx
112  * @ccode:	SMBus command code
113  * @bytecnt:	Byte count of operation
114  * @data:	Data to by written
115  */
116 struct idt_smb_seq {
117 	u8 ccode;
118 	u8 bytecnt;
119 	u8 *data;
120 };
121 
122 /*
123  * struct idt_eeprom_seq - sequence of data to be read/written from/to EEPROM
124  * @cmd:	Transaction CMD
125  * @eeaddr:	EEPROM custom address
126  * @memaddr:	Internal memory address of EEPROM
127  * @data:	Data to be written at the memory address
128  */
129 struct idt_eeprom_seq {
130 	u8 cmd;
131 	u8 eeaddr;
132 	u16 memaddr;
133 	u8 data;
134 } __packed;
135 
136 /*
137  * struct idt_csr_seq - sequence of data to be read/written from/to CSR
138  * @cmd:	Transaction CMD
139  * @csraddr:	Internal IDT device CSR address
140  * @data:	Data to be read/written from/to the CSR address
141  */
142 struct idt_csr_seq {
143 	u8 cmd;
144 	u16 csraddr;
145 	u32 data;
146 } __packed;
147 
148 /*
149  * SMBus command code macros
150  * @CCODE_END:		Indicates the end of transaction
151  * @CCODE_START:	Indicates the start of transaction
152  * @CCODE_CSR:		CSR read/write transaction
153  * @CCODE_EEPROM:	EEPROM read/write transaction
154  * @CCODE_BYTE:		Supplied data has BYTE length
155  * @CCODE_WORD:		Supplied data has WORD length
156  * @CCODE_BLOCK:	Supplied data has variable length passed in bytecnt
157  *			byte right following CCODE byte
158  */
159 #define CCODE_END	((u8)0x01)
160 #define CCODE_START	((u8)0x02)
161 #define CCODE_CSR	((u8)0x00)
162 #define CCODE_EEPROM	((u8)0x04)
163 #define CCODE_BYTE	((u8)0x00)
164 #define CCODE_WORD	((u8)0x20)
165 #define CCODE_BLOCK	((u8)0x40)
166 #define CCODE_PEC	((u8)0x80)
167 
168 /*
169  * EEPROM command macros
170  * @EEPROM_OP_WRITE:	EEPROM write operation
171  * @EEPROM_OP_READ:	EEPROM read operation
172  * @EEPROM_USA:		Use specified address of EEPROM
173  * @EEPROM_NAERR:	EEPROM device is not ready to respond
174  * @EEPROM_LAERR:	EEPROM arbitration loss error
175  * @EEPROM_MSS:		EEPROM misplace start & stop bits error
176  * @EEPROM_WR_CNT:	Bytes count to perform write operation
177  * @EEPROM_WRRD_CNT:	Bytes count to write before reading
178  * @EEPROM_RD_CNT:	Bytes count to perform read operation
179  * @EEPROM_DEF_SIZE:	Fall back size of EEPROM
180  * @EEPROM_DEF_ADDR:	Defatul EEPROM address
181  * @EEPROM_TOUT:	Timeout before retry read operation if eeprom is busy
182  */
183 #define EEPROM_OP_WRITE	((u8)0x00)
184 #define EEPROM_OP_READ	((u8)0x01)
185 #define EEPROM_USA	((u8)0x02)
186 #define EEPROM_NAERR	((u8)0x08)
187 #define EEPROM_LAERR    ((u8)0x10)
188 #define EEPROM_MSS	((u8)0x20)
189 #define EEPROM_WR_CNT	((u8)5)
190 #define EEPROM_WRRD_CNT	((u8)4)
191 #define EEPROM_RD_CNT	((u8)5)
192 #define EEPROM_DEF_SIZE	((u16)4096)
193 #define EEPROM_DEF_ADDR	((u8)0x50)
194 #define EEPROM_TOUT	(100)
195 
196 /*
197  * CSR command macros
198  * @CSR_DWE:		Enable all four bytes of the operation
199  * @CSR_OP_WRITE:	CSR write operation
200  * @CSR_OP_READ:	CSR read operation
201  * @CSR_RERR:		Read operation error
202  * @CSR_WERR:		Write operation error
203  * @CSR_WR_CNT:		Bytes count to perform write operation
204  * @CSR_WRRD_CNT:	Bytes count to write before reading
205  * @CSR_RD_CNT:		Bytes count to perform read operation
206  * @CSR_MAX:		Maximum CSR address
207  * @CSR_DEF:		Default CSR address
208  * @CSR_REAL_ADDR:	CSR real unshifted address
209  */
210 #define CSR_DWE			((u8)0x0F)
211 #define CSR_OP_WRITE		((u8)0x00)
212 #define CSR_OP_READ		((u8)0x10)
213 #define CSR_RERR		((u8)0x40)
214 #define CSR_WERR		((u8)0x80)
215 #define CSR_WR_CNT		((u8)7)
216 #define CSR_WRRD_CNT		((u8)3)
217 #define CSR_RD_CNT		((u8)7)
218 #define CSR_MAX			((u32)0x3FFFF)
219 #define CSR_DEF			((u16)0x0000)
220 #define CSR_REAL_ADDR(val)	((unsigned int)val << 2)
221 
222 /*
223  * IDT 89HPESx basic register
224  * @IDT_VIDDID_CSR:	PCIe VID and DID of IDT 89HPESx
225  * @IDT_VID_MASK:	Mask of VID
226  */
227 #define IDT_VIDDID_CSR	((u32)0x0000)
228 #define IDT_VID_MASK	((u32)0xFFFF)
229 
230 /*
231  * IDT 89HPESx can send NACK when new command is sent before previous one
232  * fininshed execution. In this case driver retries operation
233  * certain times.
234  * @RETRY_CNT:		Number of retries before giving up and fail
235  * @idt_smb_safe:	Generate a retry loop on corresponding SMBus method
236  */
237 #define RETRY_CNT (128)
238 #define idt_smb_safe(ops, args...) ({ \
239 	int __retry = RETRY_CNT; \
240 	s32 __sts; \
241 	do { \
242 		__sts = i2c_smbus_ ## ops ## _data(args); \
243 	} while (__retry-- && __sts < 0); \
244 	__sts; \
245 })
246 
247 /*===========================================================================
248  *                         i2c bus level IO-operations
249  *===========================================================================
250  */
251 
252 /*
253  * idt_smb_write_byte() - SMBus write method when I2C_SMBUS_BYTE_DATA operation
254  *                        is only available
255  * @pdev:	Pointer to the driver data
256  * @seq:	Sequence of data to be written
257  */
258 static int idt_smb_write_byte(struct idt_89hpesx_dev *pdev,
259 			      const struct idt_smb_seq *seq)
260 {
261 	s32 sts;
262 	u8 ccode;
263 	int idx;
264 
265 	/* Loop over the supplied data sending byte one-by-one */
266 	for (idx = 0; idx < seq->bytecnt; idx++) {
267 		/* Collect the command code byte */
268 		ccode = seq->ccode | CCODE_BYTE;
269 		if (idx == 0)
270 			ccode |= CCODE_START;
271 		if (idx == seq->bytecnt - 1)
272 			ccode |= CCODE_END;
273 
274 		/* Send data to the device */
275 		sts = idt_smb_safe(write_byte, pdev->client, ccode,
276 			seq->data[idx]);
277 		if (sts != 0)
278 			return (int)sts;
279 	}
280 
281 	return 0;
282 }
283 
284 /*
285  * idt_smb_read_byte() - SMBus read method when I2C_SMBUS_BYTE_DATA operation
286  *                        is only available
287  * @pdev:	Pointer to the driver data
288  * @seq:	Buffer to read data to
289  */
290 static int idt_smb_read_byte(struct idt_89hpesx_dev *pdev,
291 			     struct idt_smb_seq *seq)
292 {
293 	s32 sts;
294 	u8 ccode;
295 	int idx;
296 
297 	/* Loop over the supplied buffer receiving byte one-by-one */
298 	for (idx = 0; idx < seq->bytecnt; idx++) {
299 		/* Collect the command code byte */
300 		ccode = seq->ccode | CCODE_BYTE;
301 		if (idx == 0)
302 			ccode |= CCODE_START;
303 		if (idx == seq->bytecnt - 1)
304 			ccode |= CCODE_END;
305 
306 		/* Read data from the device */
307 		sts = idt_smb_safe(read_byte, pdev->client, ccode);
308 		if (sts < 0)
309 			return (int)sts;
310 
311 		seq->data[idx] = (u8)sts;
312 	}
313 
314 	return 0;
315 }
316 
317 /*
318  * idt_smb_write_word() - SMBus write method when I2C_SMBUS_BYTE_DATA and
319  *                        I2C_FUNC_SMBUS_WORD_DATA operations are available
320  * @pdev:	Pointer to the driver data
321  * @seq:	Sequence of data to be written
322  */
323 static int idt_smb_write_word(struct idt_89hpesx_dev *pdev,
324 			      const struct idt_smb_seq *seq)
325 {
326 	s32 sts;
327 	u8 ccode;
328 	int idx, evencnt;
329 
330 	/* Calculate the even count of data to send */
331 	evencnt = seq->bytecnt - (seq->bytecnt % 2);
332 
333 	/* Loop over the supplied data sending two bytes at a time */
334 	for (idx = 0; idx < evencnt; idx += 2) {
335 		/* Collect the command code byte */
336 		ccode = seq->ccode | CCODE_WORD;
337 		if (idx == 0)
338 			ccode |= CCODE_START;
339 		if (idx == evencnt - 2)
340 			ccode |= CCODE_END;
341 
342 		/* Send word data to the device */
343 		sts = idt_smb_safe(write_word, pdev->client, ccode,
344 			*(u16 *)&seq->data[idx]);
345 		if (sts != 0)
346 			return (int)sts;
347 	}
348 
349 	/* If there is odd number of bytes then send just one last byte */
350 	if (seq->bytecnt != evencnt) {
351 		/* Collect the command code byte */
352 		ccode = seq->ccode | CCODE_BYTE | CCODE_END;
353 		if (idx == 0)
354 			ccode |= CCODE_START;
355 
356 		/* Send byte data to the device */
357 		sts = idt_smb_safe(write_byte, pdev->client, ccode,
358 			seq->data[idx]);
359 		if (sts != 0)
360 			return (int)sts;
361 	}
362 
363 	return 0;
364 }
365 
366 /*
367  * idt_smb_read_word() - SMBus read method when I2C_SMBUS_BYTE_DATA and
368  *                       I2C_FUNC_SMBUS_WORD_DATA operations are available
369  * @pdev:	Pointer to the driver data
370  * @seq:	Buffer to read data to
371  */
372 static int idt_smb_read_word(struct idt_89hpesx_dev *pdev,
373 			     struct idt_smb_seq *seq)
374 {
375 	s32 sts;
376 	u8 ccode;
377 	int idx, evencnt;
378 
379 	/* Calculate the even count of data to send */
380 	evencnt = seq->bytecnt - (seq->bytecnt % 2);
381 
382 	/* Loop over the supplied data reading two bytes at a time */
383 	for (idx = 0; idx < evencnt; idx += 2) {
384 		/* Collect the command code byte */
385 		ccode = seq->ccode | CCODE_WORD;
386 		if (idx == 0)
387 			ccode |= CCODE_START;
388 		if (idx == evencnt - 2)
389 			ccode |= CCODE_END;
390 
391 		/* Read word data from the device */
392 		sts = idt_smb_safe(read_word, pdev->client, ccode);
393 		if (sts < 0)
394 			return (int)sts;
395 
396 		*(u16 *)&seq->data[idx] = (u16)sts;
397 	}
398 
399 	/* If there is odd number of bytes then receive just one last byte */
400 	if (seq->bytecnt != evencnt) {
401 		/* Collect the command code byte */
402 		ccode = seq->ccode | CCODE_BYTE | CCODE_END;
403 		if (idx == 0)
404 			ccode |= CCODE_START;
405 
406 		/* Read last data byte from the device */
407 		sts = idt_smb_safe(read_byte, pdev->client, ccode);
408 		if (sts < 0)
409 			return (int)sts;
410 
411 		seq->data[idx] = (u8)sts;
412 	}
413 
414 	return 0;
415 }
416 
417 /*
418  * idt_smb_write_block() - SMBus write method when I2C_SMBUS_BLOCK_DATA
419  *                         operation is available
420  * @pdev:	Pointer to the driver data
421  * @seq:	Sequence of data to be written
422  */
423 static int idt_smb_write_block(struct idt_89hpesx_dev *pdev,
424 			       const struct idt_smb_seq *seq)
425 {
426 	u8 ccode;
427 
428 	/* Return error if too much data passed to send */
429 	if (seq->bytecnt > I2C_SMBUS_BLOCK_MAX)
430 		return -EINVAL;
431 
432 	/* Collect the command code byte */
433 	ccode = seq->ccode | CCODE_BLOCK | CCODE_START | CCODE_END;
434 
435 	/* Send block of data to the device */
436 	return idt_smb_safe(write_block, pdev->client, ccode, seq->bytecnt,
437 		seq->data);
438 }
439 
440 /*
441  * idt_smb_read_block() - SMBus read method when I2C_SMBUS_BLOCK_DATA
442  *                        operation is available
443  * @pdev:	Pointer to the driver data
444  * @seq:	Buffer to read data to
445  */
446 static int idt_smb_read_block(struct idt_89hpesx_dev *pdev,
447 			      struct idt_smb_seq *seq)
448 {
449 	s32 sts;
450 	u8 ccode;
451 
452 	/* Return error if too much data passed to send */
453 	if (seq->bytecnt > I2C_SMBUS_BLOCK_MAX)
454 		return -EINVAL;
455 
456 	/* Collect the command code byte */
457 	ccode = seq->ccode | CCODE_BLOCK | CCODE_START | CCODE_END;
458 
459 	/* Read block of data from the device */
460 	sts = idt_smb_safe(read_block, pdev->client, ccode, seq->data);
461 	if (sts != seq->bytecnt)
462 		return (sts < 0 ? sts : -ENODATA);
463 
464 	return 0;
465 }
466 
467 /*
468  * idt_smb_write_i2c_block() - SMBus write method when I2C_SMBUS_I2C_BLOCK_DATA
469  *                             operation is available
470  * @pdev:	Pointer to the driver data
471  * @seq:	Sequence of data to be written
472  *
473  * NOTE It's usual SMBus write block operation, except the actual data length is
474  * sent as first byte of data
475  */
476 static int idt_smb_write_i2c_block(struct idt_89hpesx_dev *pdev,
477 				   const struct idt_smb_seq *seq)
478 {
479 	u8 ccode, buf[I2C_SMBUS_BLOCK_MAX + 1];
480 
481 	/* Return error if too much data passed to send */
482 	if (seq->bytecnt > I2C_SMBUS_BLOCK_MAX)
483 		return -EINVAL;
484 
485 	/* Collect the data to send. Length byte must be added prior the data */
486 	buf[0] = seq->bytecnt;
487 	memcpy(&buf[1], seq->data, seq->bytecnt);
488 
489 	/* Collect the command code byte */
490 	ccode = seq->ccode | CCODE_BLOCK | CCODE_START | CCODE_END;
491 
492 	/* Send length and block of data to the device */
493 	return idt_smb_safe(write_i2c_block, pdev->client, ccode,
494 		seq->bytecnt + 1, buf);
495 }
496 
497 /*
498  * idt_smb_read_i2c_block() - SMBus read method when I2C_SMBUS_I2C_BLOCK_DATA
499  *                            operation is available
500  * @pdev:	Pointer to the driver data
501  * @seq:	Buffer to read data to
502  *
503  * NOTE It's usual SMBus read block operation, except the actual data length is
504  * retrieved as first byte of data
505  */
506 static int idt_smb_read_i2c_block(struct idt_89hpesx_dev *pdev,
507 				  struct idt_smb_seq *seq)
508 {
509 	u8 ccode, buf[I2C_SMBUS_BLOCK_MAX + 1];
510 	s32 sts;
511 
512 	/* Return error if too much data passed to send */
513 	if (seq->bytecnt > I2C_SMBUS_BLOCK_MAX)
514 		return -EINVAL;
515 
516 	/* Collect the command code byte */
517 	ccode = seq->ccode | CCODE_BLOCK | CCODE_START | CCODE_END;
518 
519 	/* Read length and block of data from the device */
520 	sts = idt_smb_safe(read_i2c_block, pdev->client, ccode,
521 		seq->bytecnt + 1, buf);
522 	if (sts != seq->bytecnt + 1)
523 		return (sts < 0 ? sts : -ENODATA);
524 	if (buf[0] != seq->bytecnt)
525 		return -ENODATA;
526 
527 	/* Copy retrieved data to the output data buffer */
528 	memcpy(seq->data, &buf[1], seq->bytecnt);
529 
530 	return 0;
531 }
532 
533 /*===========================================================================
534  *                          EEPROM IO-operations
535  *===========================================================================
536  */
537 
538 /*
539  * idt_eeprom_read_byte() - read just one byte from EEPROM
540  * @pdev:	Pointer to the driver data
541  * @memaddr:	Start EEPROM memory address
542  * @data:	Data to be written to EEPROM
543  */
544 static int idt_eeprom_read_byte(struct idt_89hpesx_dev *pdev, u16 memaddr,
545 				u8 *data)
546 {
547 	struct device *dev = &pdev->client->dev;
548 	struct idt_eeprom_seq eeseq;
549 	struct idt_smb_seq smbseq;
550 	int ret, retry;
551 
552 	/* Initialize SMBus sequence fields */
553 	smbseq.ccode = pdev->iniccode | CCODE_EEPROM;
554 	smbseq.data = (u8 *)&eeseq;
555 
556 	/*
557 	 * Sometimes EEPROM may respond with NACK if it's busy with previous
558 	 * operation, so we need to perform a few attempts of read cycle
559 	 */
560 	retry = RETRY_CNT;
561 	do {
562 		/* Send EEPROM memory address to read data from */
563 		smbseq.bytecnt = EEPROM_WRRD_CNT;
564 		eeseq.cmd = pdev->inieecmd | EEPROM_OP_READ;
565 		eeseq.eeaddr = pdev->eeaddr;
566 		eeseq.memaddr = cpu_to_le16(memaddr);
567 		ret = pdev->smb_write(pdev, &smbseq);
568 		if (ret != 0) {
569 			dev_err(dev, "Failed to init eeprom addr 0x%02x",
570 				memaddr);
571 			break;
572 		}
573 
574 		/* Perform read operation */
575 		smbseq.bytecnt = EEPROM_RD_CNT;
576 		ret = pdev->smb_read(pdev, &smbseq);
577 		if (ret != 0) {
578 			dev_err(dev, "Failed to read eeprom data 0x%02x",
579 				memaddr);
580 			break;
581 		}
582 
583 		/* Restart read operation if the device is busy */
584 		if (retry && (eeseq.cmd & EEPROM_NAERR)) {
585 			dev_dbg(dev, "EEPROM busy, retry reading after %d ms",
586 				EEPROM_TOUT);
587 			msleep(EEPROM_TOUT);
588 			continue;
589 		}
590 
591 		/* Check whether IDT successfully read data from EEPROM */
592 		if (eeseq.cmd & (EEPROM_NAERR | EEPROM_LAERR | EEPROM_MSS)) {
593 			dev_err(dev,
594 				"Communication with eeprom failed, cmd 0x%hhx",
595 				eeseq.cmd);
596 			ret = -EREMOTEIO;
597 			break;
598 		}
599 
600 		/* Save retrieved data and exit the loop */
601 		*data = eeseq.data;
602 		break;
603 	} while (retry--);
604 
605 	/* Return the status of operation */
606 	return ret;
607 }
608 
609 /*
610  * idt_eeprom_write() - EEPROM write operation
611  * @pdev:	Pointer to the driver data
612  * @memaddr:	Start EEPROM memory address
613  * @len:	Length of data to be written
614  * @data:	Data to be written to EEPROM
615  */
616 static int idt_eeprom_write(struct idt_89hpesx_dev *pdev, u16 memaddr, u16 len,
617 			    const u8 *data)
618 {
619 	struct device *dev = &pdev->client->dev;
620 	struct idt_eeprom_seq eeseq;
621 	struct idt_smb_seq smbseq;
622 	int ret;
623 	u16 idx;
624 
625 	/* Initialize SMBus sequence fields */
626 	smbseq.ccode = pdev->iniccode | CCODE_EEPROM;
627 	smbseq.data = (u8 *)&eeseq;
628 
629 	/* Send data byte-by-byte, checking if it is successfully written */
630 	for (idx = 0; idx < len; idx++, memaddr++) {
631 		/* Lock IDT SMBus device */
632 		mutex_lock(&pdev->smb_mtx);
633 
634 		/* Perform write operation */
635 		smbseq.bytecnt = EEPROM_WR_CNT;
636 		eeseq.cmd = pdev->inieecmd | EEPROM_OP_WRITE;
637 		eeseq.eeaddr = pdev->eeaddr;
638 		eeseq.memaddr = cpu_to_le16(memaddr);
639 		eeseq.data = data[idx];
640 		ret = pdev->smb_write(pdev, &smbseq);
641 		if (ret != 0) {
642 			dev_err(dev,
643 				"Failed to write 0x%04hx:0x%02hhx to eeprom",
644 				memaddr, data[idx]);
645 			goto err_mutex_unlock;
646 		}
647 
648 		/*
649 		 * Check whether the data is successfully written by reading
650 		 * from the same EEPROM memory address.
651 		 */
652 		eeseq.data = ~data[idx];
653 		ret = idt_eeprom_read_byte(pdev, memaddr, &eeseq.data);
654 		if (ret != 0)
655 			goto err_mutex_unlock;
656 
657 		/* Check whether the read byte is the same as written one */
658 		if (eeseq.data != data[idx]) {
659 			dev_err(dev, "Values don't match 0x%02hhx != 0x%02hhx",
660 				eeseq.data, data[idx]);
661 			ret = -EREMOTEIO;
662 			goto err_mutex_unlock;
663 		}
664 
665 		/* Unlock IDT SMBus device */
666 err_mutex_unlock:
667 		mutex_unlock(&pdev->smb_mtx);
668 		if (ret != 0)
669 			return ret;
670 	}
671 
672 	return 0;
673 }
674 
675 /*
676  * idt_eeprom_read() - EEPROM read operation
677  * @pdev:	Pointer to the driver data
678  * @memaddr:	Start EEPROM memory address
679  * @len:	Length of data to read
680  * @buf:	Buffer to read data to
681  */
682 static int idt_eeprom_read(struct idt_89hpesx_dev *pdev, u16 memaddr, u16 len,
683 			   u8 *buf)
684 {
685 	int ret;
686 	u16 idx;
687 
688 	/* Read data byte-by-byte, retrying if it wasn't successful */
689 	for (idx = 0; idx < len; idx++, memaddr++) {
690 		/* Lock IDT SMBus device */
691 		mutex_lock(&pdev->smb_mtx);
692 
693 		/* Just read the byte to the buffer */
694 		ret = idt_eeprom_read_byte(pdev, memaddr, &buf[idx]);
695 
696 		/* Unlock IDT SMBus device */
697 		mutex_unlock(&pdev->smb_mtx);
698 
699 		/* Return error if read operation failed */
700 		if (ret != 0)
701 			return ret;
702 	}
703 
704 	return 0;
705 }
706 
707 /*===========================================================================
708  *                          CSR IO-operations
709  *===========================================================================
710  */
711 
712 /*
713  * idt_csr_write() - CSR write operation
714  * @pdev:	Pointer to the driver data
715  * @csraddr:	CSR address (with no two LS bits)
716  * @data:	Data to be written to CSR
717  */
718 static int idt_csr_write(struct idt_89hpesx_dev *pdev, u16 csraddr,
719 			 const u32 data)
720 {
721 	struct device *dev = &pdev->client->dev;
722 	struct idt_csr_seq csrseq;
723 	struct idt_smb_seq smbseq;
724 	int ret;
725 
726 	/* Initialize SMBus sequence fields */
727 	smbseq.ccode = pdev->iniccode | CCODE_CSR;
728 	smbseq.data = (u8 *)&csrseq;
729 
730 	/* Lock IDT SMBus device */
731 	mutex_lock(&pdev->smb_mtx);
732 
733 	/* Perform write operation */
734 	smbseq.bytecnt = CSR_WR_CNT;
735 	csrseq.cmd = pdev->inicsrcmd | CSR_OP_WRITE;
736 	csrseq.csraddr = cpu_to_le16(csraddr);
737 	csrseq.data = cpu_to_le32(data);
738 	ret = pdev->smb_write(pdev, &smbseq);
739 	if (ret != 0) {
740 		dev_err(dev, "Failed to write 0x%04x: 0x%04x to csr",
741 			CSR_REAL_ADDR(csraddr), data);
742 		goto err_mutex_unlock;
743 	}
744 
745 	/* Send CSR address to read data from */
746 	smbseq.bytecnt = CSR_WRRD_CNT;
747 	csrseq.cmd = pdev->inicsrcmd | CSR_OP_READ;
748 	ret = pdev->smb_write(pdev, &smbseq);
749 	if (ret != 0) {
750 		dev_err(dev, "Failed to init csr address 0x%04x",
751 			CSR_REAL_ADDR(csraddr));
752 		goto err_mutex_unlock;
753 	}
754 
755 	/* Perform read operation */
756 	smbseq.bytecnt = CSR_RD_CNT;
757 	ret = pdev->smb_read(pdev, &smbseq);
758 	if (ret != 0) {
759 		dev_err(dev, "Failed to read csr 0x%04x",
760 			CSR_REAL_ADDR(csraddr));
761 		goto err_mutex_unlock;
762 	}
763 
764 	/* Check whether IDT successfully retrieved CSR data */
765 	if (csrseq.cmd & (CSR_RERR | CSR_WERR)) {
766 		dev_err(dev, "IDT failed to perform CSR r/w");
767 		ret = -EREMOTEIO;
768 		goto err_mutex_unlock;
769 	}
770 
771 	/* Unlock IDT SMBus device */
772 err_mutex_unlock:
773 	mutex_unlock(&pdev->smb_mtx);
774 
775 	return ret;
776 }
777 
778 /*
779  * idt_csr_read() - CSR read operation
780  * @pdev:	Pointer to the driver data
781  * @csraddr:	CSR address (with no two LS bits)
782  * @data:	Data to be written to CSR
783  */
784 static int idt_csr_read(struct idt_89hpesx_dev *pdev, u16 csraddr, u32 *data)
785 {
786 	struct device *dev = &pdev->client->dev;
787 	struct idt_csr_seq csrseq;
788 	struct idt_smb_seq smbseq;
789 	int ret;
790 
791 	/* Initialize SMBus sequence fields */
792 	smbseq.ccode = pdev->iniccode | CCODE_CSR;
793 	smbseq.data = (u8 *)&csrseq;
794 
795 	/* Lock IDT SMBus device */
796 	mutex_lock(&pdev->smb_mtx);
797 
798 	/* Send CSR register address before reading it */
799 	smbseq.bytecnt = CSR_WRRD_CNT;
800 	csrseq.cmd = pdev->inicsrcmd | CSR_OP_READ;
801 	csrseq.csraddr = cpu_to_le16(csraddr);
802 	ret = pdev->smb_write(pdev, &smbseq);
803 	if (ret != 0) {
804 		dev_err(dev, "Failed to init csr address 0x%04x",
805 			CSR_REAL_ADDR(csraddr));
806 		goto err_mutex_unlock;
807 	}
808 
809 	/* Perform read operation */
810 	smbseq.bytecnt = CSR_RD_CNT;
811 	ret = pdev->smb_read(pdev, &smbseq);
812 	if (ret != 0) {
813 		dev_err(dev, "Failed to read csr 0x%04x",
814 			CSR_REAL_ADDR(csraddr));
815 		goto err_mutex_unlock;
816 	}
817 
818 	/* Check whether IDT successfully retrieved CSR data */
819 	if (csrseq.cmd & (CSR_RERR | CSR_WERR)) {
820 		dev_err(dev, "IDT failed to perform CSR r/w");
821 		ret = -EREMOTEIO;
822 		goto err_mutex_unlock;
823 	}
824 
825 	/* Save data retrieved from IDT */
826 	*data = le32_to_cpu(csrseq.data);
827 
828 	/* Unlock IDT SMBus device */
829 err_mutex_unlock:
830 	mutex_unlock(&pdev->smb_mtx);
831 
832 	return ret;
833 }
834 
835 /*===========================================================================
836  *                          Sysfs/debugfs-nodes IO-operations
837  *===========================================================================
838  */
839 
840 /*
841  * eeprom_write() - EEPROM sysfs-node write callback
842  * @filep:	Pointer to the file system node
843  * @kobj:	Pointer to the kernel object related to the sysfs-node
844  * @attr:	Attributes of the file
845  * @buf:	Buffer to write data to
846  * @off:	Offset at which data should be written to
847  * @count:	Number of bytes to write
848  */
849 static ssize_t eeprom_write(struct file *filp, struct kobject *kobj,
850 			    struct bin_attribute *attr,
851 			    char *buf, loff_t off, size_t count)
852 {
853 	struct idt_89hpesx_dev *pdev;
854 	int ret;
855 
856 	/* Retrieve driver data */
857 	pdev = dev_get_drvdata(kobj_to_dev(kobj));
858 
859 	/* Perform EEPROM write operation */
860 	ret = idt_eeprom_write(pdev, (u16)off, (u16)count, (u8 *)buf);
861 	return (ret != 0 ? ret : count);
862 }
863 
864 /*
865  * eeprom_read() - EEPROM sysfs-node read callback
866  * @filep:	Pointer to the file system node
867  * @kobj:	Pointer to the kernel object related to the sysfs-node
868  * @attr:	Attributes of the file
869  * @buf:	Buffer to write data to
870  * @off:	Offset at which data should be written to
871  * @count:	Number of bytes to write
872  */
873 static ssize_t eeprom_read(struct file *filp, struct kobject *kobj,
874 			   struct bin_attribute *attr,
875 			   char *buf, loff_t off, size_t count)
876 {
877 	struct idt_89hpesx_dev *pdev;
878 	int ret;
879 
880 	/* Retrieve driver data */
881 	pdev = dev_get_drvdata(kobj_to_dev(kobj));
882 
883 	/* Perform EEPROM read operation */
884 	ret = idt_eeprom_read(pdev, (u16)off, (u16)count, (u8 *)buf);
885 	return (ret != 0 ? ret : count);
886 }
887 
888 /*
889  * idt_dbgfs_csr_write() - CSR debugfs-node write callback
890  * @filep:	Pointer to the file system file descriptor
891  * @buf:	Buffer to read data from
892  * @count:	Size of the buffer
893  * @offp:	Offset within the file
894  *
895  * It accepts either "0x<reg addr>:0x<value>" for saving register address
896  * and writing value to specified DWORD register or "0x<reg addr>" for
897  * just saving register address in order to perform next read operation.
898  *
899  * WARNING No spaces are allowed. Incoming string must be strictly formated as:
900  * "<reg addr>:<value>". Register address must be aligned within 4 bytes
901  * (one DWORD).
902  */
903 static ssize_t idt_dbgfs_csr_write(struct file *filep, const char __user *ubuf,
904 				   size_t count, loff_t *offp)
905 {
906 	struct idt_89hpesx_dev *pdev = filep->private_data;
907 	char *colon_ch, *csraddr_str, *csrval_str;
908 	int ret, csraddr_len;
909 	u32 csraddr, csrval;
910 	char *buf;
911 
912 	if (*offp)
913 		return 0;
914 
915 	/* Copy data from User-space */
916 	buf = kmalloc(count + 1, GFP_KERNEL);
917 	if (!buf)
918 		return -ENOMEM;
919 
920 	if (copy_from_user(buf, ubuf, count)) {
921 		ret = -EFAULT;
922 		goto free_buf;
923 	}
924 	buf[count] = 0;
925 
926 	/* Find position of colon in the buffer */
927 	colon_ch = strnchr(buf, count, ':');
928 
929 	/*
930 	 * If there is colon passed then new CSR value should be parsed as
931 	 * well, so allocate buffer for CSR address substring.
932 	 * If no colon is found, then string must have just one number with
933 	 * no new CSR value
934 	 */
935 	if (colon_ch != NULL) {
936 		csraddr_len = colon_ch - buf;
937 		csraddr_str =
938 			kmalloc(csraddr_len + 1, GFP_KERNEL);
939 		if (csraddr_str == NULL) {
940 			ret = -ENOMEM;
941 			goto free_buf;
942 		}
943 		/* Copy the register address to the substring buffer */
944 		strncpy(csraddr_str, buf, csraddr_len);
945 		csraddr_str[csraddr_len] = '\0';
946 		/* Register value must follow the colon */
947 		csrval_str = colon_ch + 1;
948 	} else /* if (str_colon == NULL) */ {
949 		csraddr_str = (char *)buf; /* Just to shut warning up */
950 		csraddr_len = strnlen(csraddr_str, count);
951 		csrval_str = NULL;
952 	}
953 
954 	/* Convert CSR address to u32 value */
955 	ret = kstrtou32(csraddr_str, 0, &csraddr);
956 	if (ret != 0)
957 		goto free_csraddr_str;
958 
959 	/* Check whether passed register address is valid */
960 	if (csraddr > CSR_MAX || !IS_ALIGNED(csraddr, SZ_4)) {
961 		ret = -EINVAL;
962 		goto free_csraddr_str;
963 	}
964 
965 	/* Shift register address to the right so to have u16 address */
966 	pdev->csr = (csraddr >> 2);
967 
968 	/* Parse new CSR value and send it to IDT, if colon has been found */
969 	if (colon_ch != NULL) {
970 		ret = kstrtou32(csrval_str, 0, &csrval);
971 		if (ret != 0)
972 			goto free_csraddr_str;
973 
974 		ret = idt_csr_write(pdev, pdev->csr, csrval);
975 		if (ret != 0)
976 			goto free_csraddr_str;
977 	}
978 
979 	/* Free memory only if colon has been found */
980 free_csraddr_str:
981 	if (colon_ch != NULL)
982 		kfree(csraddr_str);
983 
984 	/* Free buffer allocated for data retrieved from User-space */
985 free_buf:
986 	kfree(buf);
987 
988 	return (ret != 0 ? ret : count);
989 }
990 
991 /*
992  * idt_dbgfs_csr_read() - CSR debugfs-node read callback
993  * @filep:	Pointer to the file system file descriptor
994  * @buf:	Buffer to write data to
995  * @count:	Size of the buffer
996  * @offp:	Offset within the file
997  *
998  * It just prints the pair "0x<reg addr>:0x<value>" to passed buffer.
999  */
1000 #define CSRBUF_SIZE	((size_t)32)
1001 static ssize_t idt_dbgfs_csr_read(struct file *filep, char __user *ubuf,
1002 				  size_t count, loff_t *offp)
1003 {
1004 	struct idt_89hpesx_dev *pdev = filep->private_data;
1005 	u32 csraddr, csrval;
1006 	char buf[CSRBUF_SIZE];
1007 	int ret, size;
1008 
1009 	/* Perform CSR read operation */
1010 	ret = idt_csr_read(pdev, pdev->csr, &csrval);
1011 	if (ret != 0)
1012 		return ret;
1013 
1014 	/* Shift register address to the left so to have real address */
1015 	csraddr = ((u32)pdev->csr << 2);
1016 
1017 	/* Print the "0x<reg addr>:0x<value>" to buffer */
1018 	size = snprintf(buf, CSRBUF_SIZE, "0x%05x:0x%08x\n",
1019 		(unsigned int)csraddr, (unsigned int)csrval);
1020 
1021 	/* Copy data to User-space */
1022 	return simple_read_from_buffer(ubuf, count, offp, buf, size);
1023 }
1024 
1025 /*
1026  * eeprom_attribute - EEPROM sysfs-node attributes
1027  *
1028  * NOTE Size will be changed in compliance with OF node. EEPROM attribute will
1029  * be read-only as well if the corresponding flag is specified in OF node.
1030  */
1031 static BIN_ATTR_RW(eeprom, EEPROM_DEF_SIZE);
1032 
1033 /*
1034  * csr_dbgfs_ops - CSR debugfs-node read/write operations
1035  */
1036 static const struct file_operations csr_dbgfs_ops = {
1037 	.owner = THIS_MODULE,
1038 	.open = simple_open,
1039 	.write = idt_dbgfs_csr_write,
1040 	.read = idt_dbgfs_csr_read
1041 };
1042 
1043 /*===========================================================================
1044  *                       Driver init/deinit methods
1045  *===========================================================================
1046  */
1047 
1048 /*
1049  * idt_set_defval() - disable EEPROM access by default
1050  * @pdev:	Pointer to the driver data
1051  */
1052 static void idt_set_defval(struct idt_89hpesx_dev *pdev)
1053 {
1054 	/* If OF info is missing then use next values */
1055 	pdev->eesize = 0;
1056 	pdev->eero = true;
1057 	pdev->inieecmd = 0;
1058 	pdev->eeaddr = 0;
1059 }
1060 
1061 static const struct i2c_device_id ee_ids[];
1062 
1063 /*
1064  * idt_ee_match_id() - check whether the node belongs to compatible EEPROMs
1065  */
1066 static const struct i2c_device_id *idt_ee_match_id(struct fwnode_handle *fwnode)
1067 {
1068 	const struct i2c_device_id *id = ee_ids;
1069 	const char *compatible, *p;
1070 	char devname[I2C_NAME_SIZE];
1071 	int ret;
1072 
1073 	ret = fwnode_property_read_string(fwnode, "compatible", &compatible);
1074 	if (ret)
1075 		return NULL;
1076 
1077 	p = strchr(compatible, ',');
1078 	strlcpy(devname, p ? p + 1 : compatible, sizeof(devname));
1079 	/* Search through the device name */
1080 	while (id->name[0]) {
1081 		if (strcmp(devname, id->name) == 0)
1082 			return id;
1083 		id++;
1084 	}
1085 	return NULL;
1086 }
1087 
1088 /*
1089  * idt_get_fw_data() - get IDT i2c-device parameters from device tree
1090  * @pdev:	Pointer to the driver data
1091  */
1092 static void idt_get_fw_data(struct idt_89hpesx_dev *pdev)
1093 {
1094 	struct device *dev = &pdev->client->dev;
1095 	struct fwnode_handle *fwnode;
1096 	const struct i2c_device_id *ee_id = NULL;
1097 	u32 eeprom_addr;
1098 	int ret;
1099 
1100 	device_for_each_child_node(dev, fwnode) {
1101 		ee_id = idt_ee_match_id(fwnode);
1102 		if (ee_id)
1103 			break;
1104 
1105 		dev_warn(dev, "Skip unsupported EEPROM device %pfw\n", fwnode);
1106 	}
1107 
1108 	/* If there is no fwnode EEPROM device, then set zero size */
1109 	if (!ee_id) {
1110 		dev_warn(dev, "No fwnode, EEPROM access disabled");
1111 		idt_set_defval(pdev);
1112 		return;
1113 	}
1114 
1115 	/* Retrieve EEPROM size */
1116 	pdev->eesize = (u32)ee_id->driver_data;
1117 
1118 	/* Get custom EEPROM address from 'reg' attribute */
1119 	ret = fwnode_property_read_u32(fwnode, "reg", &eeprom_addr);
1120 	if (ret || (eeprom_addr == 0)) {
1121 		dev_warn(dev, "No EEPROM reg found, use default address 0x%x",
1122 			 EEPROM_DEF_ADDR);
1123 		pdev->inieecmd = 0;
1124 		pdev->eeaddr = EEPROM_DEF_ADDR << 1;
1125 	} else {
1126 		pdev->inieecmd = EEPROM_USA;
1127 		pdev->eeaddr = eeprom_addr << 1;
1128 	}
1129 
1130 	/* Check EEPROM 'read-only' flag */
1131 	if (fwnode_property_read_bool(fwnode, "read-only"))
1132 		pdev->eero = true;
1133 	else /* if (!fwnode_property_read_bool(node, "read-only")) */
1134 		pdev->eero = false;
1135 
1136 	fwnode_handle_put(fwnode);
1137 	dev_info(dev, "EEPROM of %d bytes found by 0x%x",
1138 		pdev->eesize, pdev->eeaddr);
1139 }
1140 
1141 /*
1142  * idt_create_pdev() - create and init data structure of the driver
1143  * @client:	i2c client of IDT PCIe-switch device
1144  */
1145 static struct idt_89hpesx_dev *idt_create_pdev(struct i2c_client *client)
1146 {
1147 	struct idt_89hpesx_dev *pdev;
1148 
1149 	/* Allocate memory for driver data */
1150 	pdev = devm_kmalloc(&client->dev, sizeof(struct idt_89hpesx_dev),
1151 		GFP_KERNEL);
1152 	if (pdev == NULL)
1153 		return ERR_PTR(-ENOMEM);
1154 
1155 	/* Initialize basic fields of the data */
1156 	pdev->client = client;
1157 	i2c_set_clientdata(client, pdev);
1158 
1159 	/* Read firmware nodes information */
1160 	idt_get_fw_data(pdev);
1161 
1162 	/* Initialize basic CSR CMD field - use full DWORD-sized r/w ops */
1163 	pdev->inicsrcmd = CSR_DWE;
1164 	pdev->csr = CSR_DEF;
1165 
1166 	/* Enable Packet Error Checking if it's supported by adapter */
1167 	if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_PEC)) {
1168 		pdev->iniccode = CCODE_PEC;
1169 		client->flags |= I2C_CLIENT_PEC;
1170 	} else /* PEC is unsupported */ {
1171 		pdev->iniccode = 0;
1172 	}
1173 
1174 	return pdev;
1175 }
1176 
1177 /*
1178  * idt_free_pdev() - free data structure of the driver
1179  * @pdev:	Pointer to the driver data
1180  */
1181 static void idt_free_pdev(struct idt_89hpesx_dev *pdev)
1182 {
1183 	/* Clear driver data from device private field */
1184 	i2c_set_clientdata(pdev->client, NULL);
1185 }
1186 
1187 /*
1188  * idt_set_smbus_ops() - set supported SMBus operations
1189  * @pdev:	Pointer to the driver data
1190  * Return status of smbus check operations
1191  */
1192 static int idt_set_smbus_ops(struct idt_89hpesx_dev *pdev)
1193 {
1194 	struct i2c_adapter *adapter = pdev->client->adapter;
1195 	struct device *dev = &pdev->client->dev;
1196 
1197 	/* Check i2c adapter read functionality */
1198 	if (i2c_check_functionality(adapter,
1199 				    I2C_FUNC_SMBUS_READ_BLOCK_DATA)) {
1200 		pdev->smb_read = idt_smb_read_block;
1201 		dev_dbg(dev, "SMBus block-read op chosen");
1202 	} else if (i2c_check_functionality(adapter,
1203 					   I2C_FUNC_SMBUS_READ_I2C_BLOCK)) {
1204 		pdev->smb_read = idt_smb_read_i2c_block;
1205 		dev_dbg(dev, "SMBus i2c-block-read op chosen");
1206 	} else if (i2c_check_functionality(adapter,
1207 					   I2C_FUNC_SMBUS_READ_WORD_DATA) &&
1208 		   i2c_check_functionality(adapter,
1209 					   I2C_FUNC_SMBUS_READ_BYTE_DATA)) {
1210 		pdev->smb_read = idt_smb_read_word;
1211 		dev_warn(dev, "Use slow word/byte SMBus read ops");
1212 	} else if (i2c_check_functionality(adapter,
1213 					   I2C_FUNC_SMBUS_READ_BYTE_DATA)) {
1214 		pdev->smb_read = idt_smb_read_byte;
1215 		dev_warn(dev, "Use slow byte SMBus read op");
1216 	} else /* no supported smbus read operations */ {
1217 		dev_err(dev, "No supported SMBus read op");
1218 		return -EPFNOSUPPORT;
1219 	}
1220 
1221 	/* Check i2c adapter write functionality */
1222 	if (i2c_check_functionality(adapter,
1223 				    I2C_FUNC_SMBUS_WRITE_BLOCK_DATA)) {
1224 		pdev->smb_write = idt_smb_write_block;
1225 		dev_dbg(dev, "SMBus block-write op chosen");
1226 	} else if (i2c_check_functionality(adapter,
1227 					   I2C_FUNC_SMBUS_WRITE_I2C_BLOCK)) {
1228 		pdev->smb_write = idt_smb_write_i2c_block;
1229 		dev_dbg(dev, "SMBus i2c-block-write op chosen");
1230 	} else if (i2c_check_functionality(adapter,
1231 					   I2C_FUNC_SMBUS_WRITE_WORD_DATA) &&
1232 		   i2c_check_functionality(adapter,
1233 					   I2C_FUNC_SMBUS_WRITE_BYTE_DATA)) {
1234 		pdev->smb_write = idt_smb_write_word;
1235 		dev_warn(dev, "Use slow word/byte SMBus write op");
1236 	} else if (i2c_check_functionality(adapter,
1237 					   I2C_FUNC_SMBUS_WRITE_BYTE_DATA)) {
1238 		pdev->smb_write = idt_smb_write_byte;
1239 		dev_warn(dev, "Use slow byte SMBus write op");
1240 	} else /* no supported smbus write operations */ {
1241 		dev_err(dev, "No supported SMBus write op");
1242 		return -EPFNOSUPPORT;
1243 	}
1244 
1245 	/* Initialize IDT SMBus slave interface mutex */
1246 	mutex_init(&pdev->smb_mtx);
1247 
1248 	return 0;
1249 }
1250 
1251 /*
1252  * idt_check_dev() - check whether it's really IDT 89HPESx device
1253  * @pdev:	Pointer to the driver data
1254  * Return status of i2c adapter check operation
1255  */
1256 static int idt_check_dev(struct idt_89hpesx_dev *pdev)
1257 {
1258 	struct device *dev = &pdev->client->dev;
1259 	u32 viddid;
1260 	int ret;
1261 
1262 	/* Read VID and DID directly from IDT memory space */
1263 	ret = idt_csr_read(pdev, IDT_VIDDID_CSR, &viddid);
1264 	if (ret != 0) {
1265 		dev_err(dev, "Failed to read VID/DID");
1266 		return ret;
1267 	}
1268 
1269 	/* Check whether it's IDT device */
1270 	if ((viddid & IDT_VID_MASK) != PCI_VENDOR_ID_IDT) {
1271 		dev_err(dev, "Got unsupported VID/DID: 0x%08x", viddid);
1272 		return -ENODEV;
1273 	}
1274 
1275 	dev_info(dev, "Found IDT 89HPES device VID:0x%04x, DID:0x%04x",
1276 		(viddid & IDT_VID_MASK), (viddid >> 16));
1277 
1278 	return 0;
1279 }
1280 
1281 /*
1282  * idt_create_sysfs_files() - create sysfs attribute files
1283  * @pdev:	Pointer to the driver data
1284  * Return status of operation
1285  */
1286 static int idt_create_sysfs_files(struct idt_89hpesx_dev *pdev)
1287 {
1288 	struct device *dev = &pdev->client->dev;
1289 	int ret;
1290 
1291 	/* Don't do anything if EEPROM isn't accessible */
1292 	if (pdev->eesize == 0) {
1293 		dev_dbg(dev, "Skip creating sysfs-files");
1294 		return 0;
1295 	}
1296 
1297 	/* Allocate memory for attribute file */
1298 	pdev->ee_file = devm_kmalloc(dev, sizeof(*pdev->ee_file), GFP_KERNEL);
1299 	if (!pdev->ee_file)
1300 		return -ENOMEM;
1301 
1302 	/* Copy the declared EEPROM attr structure to change some of fields */
1303 	memcpy(pdev->ee_file, &bin_attr_eeprom, sizeof(*pdev->ee_file));
1304 
1305 	/* In case of read-only EEPROM get rid of write ability */
1306 	if (pdev->eero) {
1307 		pdev->ee_file->attr.mode &= ~0200;
1308 		pdev->ee_file->write = NULL;
1309 	}
1310 	/* Create EEPROM sysfs file */
1311 	pdev->ee_file->size = pdev->eesize;
1312 	ret = sysfs_create_bin_file(&dev->kobj, pdev->ee_file);
1313 	if (ret != 0) {
1314 		dev_err(dev, "Failed to create EEPROM sysfs-node");
1315 		return ret;
1316 	}
1317 
1318 	return 0;
1319 }
1320 
1321 /*
1322  * idt_remove_sysfs_files() - remove sysfs attribute files
1323  * @pdev:	Pointer to the driver data
1324  */
1325 static void idt_remove_sysfs_files(struct idt_89hpesx_dev *pdev)
1326 {
1327 	struct device *dev = &pdev->client->dev;
1328 
1329 	/* Don't do anything if EEPROM wasn't accessible */
1330 	if (pdev->eesize == 0)
1331 		return;
1332 
1333 	/* Remove EEPROM sysfs file */
1334 	sysfs_remove_bin_file(&dev->kobj, pdev->ee_file);
1335 }
1336 
1337 /*
1338  * idt_create_dbgfs_files() - create debugfs files
1339  * @pdev:	Pointer to the driver data
1340  */
1341 #define CSRNAME_LEN	((size_t)32)
1342 static void idt_create_dbgfs_files(struct idt_89hpesx_dev *pdev)
1343 {
1344 	struct i2c_client *cli = pdev->client;
1345 	char fname[CSRNAME_LEN];
1346 
1347 	/* Create Debugfs directory for CSR file */
1348 	snprintf(fname, CSRNAME_LEN, "%d-%04hx", cli->adapter->nr, cli->addr);
1349 	pdev->csr_dir = debugfs_create_dir(fname, csr_dbgdir);
1350 
1351 	/* Create Debugfs file for CSR read/write operations */
1352 	debugfs_create_file(cli->name, 0600, pdev->csr_dir, pdev,
1353 			    &csr_dbgfs_ops);
1354 }
1355 
1356 /*
1357  * idt_remove_dbgfs_files() - remove debugfs files
1358  * @pdev:	Pointer to the driver data
1359  */
1360 static void idt_remove_dbgfs_files(struct idt_89hpesx_dev *pdev)
1361 {
1362 	/* Remove CSR directory and it sysfs-node */
1363 	debugfs_remove_recursive(pdev->csr_dir);
1364 }
1365 
1366 /*
1367  * idt_probe() - IDT 89HPESx driver probe() callback method
1368  */
1369 static int idt_probe(struct i2c_client *client, const struct i2c_device_id *id)
1370 {
1371 	struct idt_89hpesx_dev *pdev;
1372 	int ret;
1373 
1374 	/* Create driver data */
1375 	pdev = idt_create_pdev(client);
1376 	if (IS_ERR(pdev))
1377 		return PTR_ERR(pdev);
1378 
1379 	/* Set SMBus operations */
1380 	ret = idt_set_smbus_ops(pdev);
1381 	if (ret != 0)
1382 		goto err_free_pdev;
1383 
1384 	/* Check whether it is truly IDT 89HPESx device */
1385 	ret = idt_check_dev(pdev);
1386 	if (ret != 0)
1387 		goto err_free_pdev;
1388 
1389 	/* Create sysfs files */
1390 	ret = idt_create_sysfs_files(pdev);
1391 	if (ret != 0)
1392 		goto err_free_pdev;
1393 
1394 	/* Create debugfs files */
1395 	idt_create_dbgfs_files(pdev);
1396 
1397 	return 0;
1398 
1399 err_free_pdev:
1400 	idt_free_pdev(pdev);
1401 
1402 	return ret;
1403 }
1404 
1405 /*
1406  * idt_remove() - IDT 89HPESx driver remove() callback method
1407  */
1408 static int idt_remove(struct i2c_client *client)
1409 {
1410 	struct idt_89hpesx_dev *pdev = i2c_get_clientdata(client);
1411 
1412 	/* Remove debugfs files first */
1413 	idt_remove_dbgfs_files(pdev);
1414 
1415 	/* Remove sysfs files */
1416 	idt_remove_sysfs_files(pdev);
1417 
1418 	/* Discard driver data structure */
1419 	idt_free_pdev(pdev);
1420 
1421 	return 0;
1422 }
1423 
1424 /*
1425  * ee_ids - array of supported EEPROMs
1426  */
1427 static const struct i2c_device_id ee_ids[] = {
1428 	{ "24c32",  4096},
1429 	{ "24c64",  8192},
1430 	{ "24c128", 16384},
1431 	{ "24c256", 32768},
1432 	{ "24c512", 65536},
1433 	{}
1434 };
1435 MODULE_DEVICE_TABLE(i2c, ee_ids);
1436 
1437 /*
1438  * idt_ids - supported IDT 89HPESx devices
1439  */
1440 static const struct i2c_device_id idt_ids[] = {
1441 	{ "89hpes8nt2", 0 },
1442 	{ "89hpes12nt3", 0 },
1443 
1444 	{ "89hpes24nt6ag2", 0 },
1445 	{ "89hpes32nt8ag2", 0 },
1446 	{ "89hpes32nt8bg2", 0 },
1447 	{ "89hpes12nt12g2", 0 },
1448 	{ "89hpes16nt16g2", 0 },
1449 	{ "89hpes24nt24g2", 0 },
1450 	{ "89hpes32nt24ag2", 0 },
1451 	{ "89hpes32nt24bg2", 0 },
1452 
1453 	{ "89hpes12n3", 0 },
1454 	{ "89hpes12n3a", 0 },
1455 	{ "89hpes24n3", 0 },
1456 	{ "89hpes24n3a", 0 },
1457 
1458 	{ "89hpes32h8", 0 },
1459 	{ "89hpes32h8g2", 0 },
1460 	{ "89hpes48h12", 0 },
1461 	{ "89hpes48h12g2", 0 },
1462 	{ "89hpes48h12ag2", 0 },
1463 	{ "89hpes16h16", 0 },
1464 	{ "89hpes22h16", 0 },
1465 	{ "89hpes22h16g2", 0 },
1466 	{ "89hpes34h16", 0 },
1467 	{ "89hpes34h16g2", 0 },
1468 	{ "89hpes64h16", 0 },
1469 	{ "89hpes64h16g2", 0 },
1470 	{ "89hpes64h16ag2", 0 },
1471 
1472 	/* { "89hpes3t3", 0 }, // No SMBus-slave iface */
1473 	{ "89hpes12t3g2", 0 },
1474 	{ "89hpes24t3g2", 0 },
1475 	/* { "89hpes4t4", 0 }, // No SMBus-slave iface */
1476 	{ "89hpes16t4", 0 },
1477 	{ "89hpes4t4g2", 0 },
1478 	{ "89hpes10t4g2", 0 },
1479 	{ "89hpes16t4g2", 0 },
1480 	{ "89hpes16t4ag2", 0 },
1481 	{ "89hpes5t5", 0 },
1482 	{ "89hpes6t5", 0 },
1483 	{ "89hpes8t5", 0 },
1484 	{ "89hpes8t5a", 0 },
1485 	{ "89hpes24t6", 0 },
1486 	{ "89hpes6t6g2", 0 },
1487 	{ "89hpes24t6g2", 0 },
1488 	{ "89hpes16t7", 0 },
1489 	{ "89hpes32t8", 0 },
1490 	{ "89hpes32t8g2", 0 },
1491 	{ "89hpes48t12", 0 },
1492 	{ "89hpes48t12g2", 0 },
1493 	{ /* END OF LIST */ }
1494 };
1495 MODULE_DEVICE_TABLE(i2c, idt_ids);
1496 
1497 static const struct of_device_id idt_of_match[] = {
1498 	{ .compatible = "idt,89hpes8nt2", },
1499 	{ .compatible = "idt,89hpes12nt3", },
1500 
1501 	{ .compatible = "idt,89hpes24nt6ag2", },
1502 	{ .compatible = "idt,89hpes32nt8ag2", },
1503 	{ .compatible = "idt,89hpes32nt8bg2", },
1504 	{ .compatible = "idt,89hpes12nt12g2", },
1505 	{ .compatible = "idt,89hpes16nt16g2", },
1506 	{ .compatible = "idt,89hpes24nt24g2", },
1507 	{ .compatible = "idt,89hpes32nt24ag2", },
1508 	{ .compatible = "idt,89hpes32nt24bg2", },
1509 
1510 	{ .compatible = "idt,89hpes12n3", },
1511 	{ .compatible = "idt,89hpes12n3a", },
1512 	{ .compatible = "idt,89hpes24n3", },
1513 	{ .compatible = "idt,89hpes24n3a", },
1514 
1515 	{ .compatible = "idt,89hpes32h8", },
1516 	{ .compatible = "idt,89hpes32h8g2", },
1517 	{ .compatible = "idt,89hpes48h12", },
1518 	{ .compatible = "idt,89hpes48h12g2", },
1519 	{ .compatible = "idt,89hpes48h12ag2", },
1520 	{ .compatible = "idt,89hpes16h16", },
1521 	{ .compatible = "idt,89hpes22h16", },
1522 	{ .compatible = "idt,89hpes22h16g2", },
1523 	{ .compatible = "idt,89hpes34h16", },
1524 	{ .compatible = "idt,89hpes34h16g2", },
1525 	{ .compatible = "idt,89hpes64h16", },
1526 	{ .compatible = "idt,89hpes64h16g2", },
1527 	{ .compatible = "idt,89hpes64h16ag2", },
1528 
1529 	{ .compatible = "idt,89hpes12t3g2", },
1530 	{ .compatible = "idt,89hpes24t3g2", },
1531 
1532 	{ .compatible = "idt,89hpes16t4", },
1533 	{ .compatible = "idt,89hpes4t4g2", },
1534 	{ .compatible = "idt,89hpes10t4g2", },
1535 	{ .compatible = "idt,89hpes16t4g2", },
1536 	{ .compatible = "idt,89hpes16t4ag2", },
1537 	{ .compatible = "idt,89hpes5t5", },
1538 	{ .compatible = "idt,89hpes6t5", },
1539 	{ .compatible = "idt,89hpes8t5", },
1540 	{ .compatible = "idt,89hpes8t5a", },
1541 	{ .compatible = "idt,89hpes24t6", },
1542 	{ .compatible = "idt,89hpes6t6g2", },
1543 	{ .compatible = "idt,89hpes24t6g2", },
1544 	{ .compatible = "idt,89hpes16t7", },
1545 	{ .compatible = "idt,89hpes32t8", },
1546 	{ .compatible = "idt,89hpes32t8g2", },
1547 	{ .compatible = "idt,89hpes48t12", },
1548 	{ .compatible = "idt,89hpes48t12g2", },
1549 	{ },
1550 };
1551 MODULE_DEVICE_TABLE(of, idt_of_match);
1552 
1553 /*
1554  * idt_driver - IDT 89HPESx driver structure
1555  */
1556 static struct i2c_driver idt_driver = {
1557 	.driver = {
1558 		.name = IDT_NAME,
1559 		.of_match_table = idt_of_match,
1560 	},
1561 	.probe = idt_probe,
1562 	.remove = idt_remove,
1563 	.id_table = idt_ids,
1564 };
1565 
1566 /*
1567  * idt_init() - IDT 89HPESx driver init() callback method
1568  */
1569 static int __init idt_init(void)
1570 {
1571 	/* Create Debugfs directory first */
1572 	if (debugfs_initialized())
1573 		csr_dbgdir = debugfs_create_dir("idt_csr", NULL);
1574 
1575 	/* Add new i2c-device driver */
1576 	return i2c_add_driver(&idt_driver);
1577 }
1578 module_init(idt_init);
1579 
1580 /*
1581  * idt_exit() - IDT 89HPESx driver exit() callback method
1582  */
1583 static void __exit idt_exit(void)
1584 {
1585 	/* Discard debugfs directory and all files if any */
1586 	debugfs_remove_recursive(csr_dbgdir);
1587 
1588 	/* Unregister i2c-device driver */
1589 	i2c_del_driver(&idt_driver);
1590 }
1591 module_exit(idt_exit);
1592