drivers/misc/eeprom/idt_89hpesx.c

   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 <[email protected]>, <[email protected]>
   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);