drivers/misc/eeprom/idt_89hpesx.c

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