drivers/ptp/ptp_ocp.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /* Copyright (c) 2020 Facebook */
   3
   4 #include <linux/bits.h>
   5 #include <linux/err.h>
   6 #include <linux/kernel.h>
   7 #include <linux/module.h>
   8 #include <linux/debugfs.h>
   9 #include <linux/init.h>
  10 #include <linux/pci.h>
  11 #include <linux/serial_8250.h>
  12 #include <linux/clkdev.h>
  13 #include <linux/clk-provider.h>
  14 #include <linux/platform_device.h>
  15 #include <linux/platform_data/i2c-xiic.h>
  16 #include <linux/ptp_clock_kernel.h>
  17 #include <linux/spi/spi.h>
  18 #include <linux/spi/xilinx_spi.h>
  19 #include <net/devlink.h>
  20 #include <linux/i2c.h>
  21 #include <linux/mtd/mtd.h>
  22 #include <linux/nvmem-consumer.h>
  23 #include <linux/crc16.h>
  24
  25 #define PCI_VENDOR_ID_FACEBOOK                  0x1d9b
  26 #define PCI_DEVICE_ID_FACEBOOK_TIMECARD         0x0400
  27
  28 #define PCI_VENDOR_ID_CELESTICA                 0x18d4
  29 #define PCI_DEVICE_ID_CELESTICA_TIMECARD        0x1008
  30
  31 static struct class timecard_class = {
  32         .owner          = THIS_MODULE,
  33         .name           = "timecard",
  34 };
  35
  36 struct ocp_reg {
  37         u32     ctrl;
  38         u32     status;
  39         u32     select;
  40         u32     version;
  41         u32     time_ns;
  42         u32     time_sec;
  43         u32     __pad0[2];
  44         u32     adjust_ns;
  45         u32     adjust_sec;
  46         u32     __pad1[2];
  47         u32     offset_ns;
  48         u32     offset_window_ns;
  49         u32     __pad2[2];
  50         u32     drift_ns;
  51         u32     drift_window_ns;
  52         u32     __pad3[6];
  53         u32     servo_offset_p;
  54         u32     servo_offset_i;
  55         u32     servo_drift_p;
  56         u32     servo_drift_i;
  57         u32     status_offset;
  58         u32     status_drift;
  59 };
  60
  61 #define OCP_CTRL_ENABLE         BIT(0)
  62 #define OCP_CTRL_ADJUST_TIME    BIT(1)
  63 #define OCP_CTRL_ADJUST_OFFSET  BIT(2)
  64 #define OCP_CTRL_ADJUST_DRIFT   BIT(3)
  65 #define OCP_CTRL_ADJUST_SERVO   BIT(8)
  66 #define OCP_CTRL_READ_TIME_REQ  BIT(30)
  67 #define OCP_CTRL_READ_TIME_DONE BIT(31)
  68
  69 #define OCP_STATUS_IN_SYNC      BIT(0)
  70 #define OCP_STATUS_IN_HOLDOVER  BIT(1)
  71
  72 #define OCP_SELECT_CLK_NONE     0
  73 #define OCP_SELECT_CLK_REG      0xfe
  74
  75 struct tod_reg {
  76         u32     ctrl;
  77         u32     status;
  78         u32     uart_polarity;
  79         u32     version;
  80         u32     adj_sec;
  81         u32     __pad0[3];
  82         u32     uart_baud;
  83         u32     __pad1[3];
  84         u32     utc_status;
  85         u32     leap;
  86 };
  87
  88 #define TOD_CTRL_PROTOCOL       BIT(28)
  89 #define TOD_CTRL_DISABLE_FMT_A  BIT(17)
  90 #define TOD_CTRL_DISABLE_FMT_B  BIT(16)
  91 #define TOD_CTRL_ENABLE         BIT(0)
  92 #define TOD_CTRL_GNSS_MASK      GENMASK(3, 0)
  93 #define TOD_CTRL_GNSS_SHIFT     24
  94
  95 #define TOD_STATUS_UTC_MASK             GENMASK(7, 0)
  96 #define TOD_STATUS_UTC_VALID            BIT(8)
  97 #define TOD_STATUS_LEAP_ANNOUNCE        BIT(12)
  98 #define TOD_STATUS_LEAP_VALID           BIT(16)
  99
 100 struct ts_reg {
 101         u32     enable;
 102         u32     error;
 103         u32     polarity;
 104         u32     version;
 105         u32     __pad0[4];
 106         u32     cable_delay;
 107         u32     __pad1[3];
 108         u32     intr;
 109         u32     intr_mask;
 110         u32     event_count;
 111         u32     __pad2[1];
 112         u32     ts_count;
 113         u32     time_ns;
 114         u32     time_sec;
 115         u32     data_width;
 116         u32     data;
 117 };
 118
 119 struct pps_reg {
 120         u32     ctrl;
 121         u32     status;
 122         u32     __pad0[6];
 123         u32     cable_delay;
 124 };
 125
 126 #define PPS_STATUS_FILTER_ERR   BIT(0)
 127 #define PPS_STATUS_SUPERV_ERR   BIT(1)
 128
 129 struct img_reg {
 130         u32     version;
 131 };
 132
 133 struct gpio_reg {
 134         u32     gpio1;
 135         u32     __pad0;
 136         u32     gpio2;
 137         u32     __pad1;
 138 };
 139
 140 struct irig_master_reg {
 141         u32     ctrl;
 142         u32     status;
 143         u32     __pad0;
 144         u32     version;
 145         u32     adj_sec;
 146         u32     mode_ctrl;
 147 };
 148
 149 #define IRIG_M_CTRL_ENABLE      BIT(0)
 150
 151 struct irig_slave_reg {
 152         u32     ctrl;
 153         u32     status;
 154         u32     __pad0;
 155         u32     version;
 156         u32     adj_sec;
 157         u32     mode_ctrl;
 158 };
 159
 160 #define IRIG_S_CTRL_ENABLE      BIT(0)
 161
 162 struct dcf_master_reg {
 163         u32     ctrl;
 164         u32     status;
 165         u32     __pad0;
 166         u32     version;
 167         u32     adj_sec;
 168 };
 169
 170 #define DCF_M_CTRL_ENABLE       BIT(0)
 171
 172 struct dcf_slave_reg {
 173         u32     ctrl;
 174         u32     status;
 175         u32     __pad0;
 176         u32     version;
 177         u32     adj_sec;
 178 };
 179
 180 #define DCF_S_CTRL_ENABLE       BIT(0)
 181
 182 struct signal_reg {
 183         u32     enable;
 184         u32     status;
 185         u32     polarity;
 186         u32     version;
 187         u32     __pad0[4];
 188         u32     cable_delay;
 189         u32     __pad1[3];
 190         u32     intr;
 191         u32     intr_mask;
 192         u32     __pad2[2];
 193         u32     start_ns;
 194         u32     start_sec;
 195         u32     pulse_ns;
 196         u32     pulse_sec;
 197         u32     period_ns;
 198         u32     period_sec;
 199         u32     repeat_count;
 200 };
 201
 202 struct frequency_reg {
 203         u32     ctrl;
 204         u32     status;
 205 };
 206 #define FREQ_STATUS_VALID       BIT(31)
 207 #define FREQ_STATUS_ERROR       BIT(30)
 208 #define FREQ_STATUS_OVERRUN     BIT(29)
 209 #define FREQ_STATUS_MASK        GENMASK(23, 0)
 210
 211 struct ptp_ocp_flash_info {
 212         const char *name;
 213         int pci_offset;
 214         int data_size;
 215         void *data;
 216 };
 217
 218 struct ptp_ocp_firmware_header {
 219         char magic[4];
 220         __be16 pci_vendor_id;
 221         __be16 pci_device_id;
 222         __be32 image_size;
 223         __be16 hw_revision;
 224         __be16 crc;
 225 };
 226
 227 #define OCP_FIRMWARE_MAGIC_HEADER "OCPC"
 228
 229 struct ptp_ocp_i2c_info {
 230         const char *name;
 231         unsigned long fixed_rate;
 232         size_t data_size;
 233         void *data;
 234 };
 235
 236 struct ptp_ocp_ext_info {
 237         int index;
 238         irqreturn_t (*irq_fcn)(int irq, void *priv);
 239         int (*enable)(void *priv, u32 req, bool enable);
 240 };
 241
 242 struct ptp_ocp_ext_src {
 243         void __iomem            *mem;
 244         struct ptp_ocp          *bp;
 245         struct ptp_ocp_ext_info *info;
 246         int                     irq_vec;
 247 };
 248
 249 enum ptp_ocp_sma_mode {
 250         SMA_MODE_IN,
 251         SMA_MODE_OUT,
 252 };
 253
 254 struct ptp_ocp_sma_connector {
 255         enum    ptp_ocp_sma_mode mode;
 256         bool    fixed_fcn;
 257         bool    fixed_dir;
 258         bool    disabled;
 259         u8      default_fcn;
 260 };
 261
 262 struct ocp_attr_group {
 263         u64 cap;
 264         const struct attribute_group *group;
 265 };
 266
 267 #define OCP_CAP_BASIC   BIT(0)
 268 #define OCP_CAP_SIGNAL  BIT(1)
 269 #define OCP_CAP_FREQ    BIT(2)
 270
 271 struct ptp_ocp_signal {
 272         ktime_t         period;
 273         ktime_t         pulse;
 274         ktime_t         phase;
 275         ktime_t         start;
 276         int             duty;
 277         bool            polarity;
 278         bool            running;
 279 };
 280
 281 struct ptp_ocp_serial_port {
 282         int line;
 283         int baud;
 284 };
 285
 286 #define OCP_BOARD_ID_LEN                13
 287 #define OCP_SERIAL_LEN                  6
 288
 289 struct ptp_ocp {
 290         struct pci_dev          *pdev;
 291         struct device           dev;
 292         spinlock_t              lock;
 293         struct ocp_reg __iomem  *reg;
 294         struct tod_reg __iomem  *tod;
 295         struct pps_reg __iomem  *pps_to_ext;
 296         struct pps_reg __iomem  *pps_to_clk;
 297         struct gpio_reg __iomem *pps_select;
 298         struct gpio_reg __iomem *sma_map1;
 299         struct gpio_reg __iomem *sma_map2;
 300         struct irig_master_reg  __iomem *irig_out;
 301         struct irig_slave_reg   __iomem *irig_in;
 302         struct dcf_master_reg   __iomem *dcf_out;
 303         struct dcf_slave_reg    __iomem *dcf_in;
 304         struct tod_reg          __iomem *nmea_out;
 305         struct frequency_reg    __iomem *freq_in[4];
 306         struct ptp_ocp_ext_src  *signal_out[4];
 307         struct ptp_ocp_ext_src  *pps;
 308         struct ptp_ocp_ext_src  *ts0;
 309         struct ptp_ocp_ext_src  *ts1;
 310         struct ptp_ocp_ext_src  *ts2;
 311         struct ptp_ocp_ext_src  *ts3;
 312         struct ptp_ocp_ext_src  *ts4;
 313         struct img_reg __iomem  *image;
 314         struct ptp_clock        *ptp;
 315         struct ptp_clock_info   ptp_info;
 316         struct platform_device  *i2c_ctrl;
 317         struct platform_device  *spi_flash;
 318         struct clk_hw           *i2c_clk;
 319         struct timer_list       watchdog;
 320         const struct attribute_group **attr_group;
 321         const struct ptp_ocp_eeprom_map *eeprom_map;
 322         struct dentry           *debug_root;
 323         time64_t                gnss_lost;
 324         int                     id;
 325         int                     n_irqs;
 326         struct ptp_ocp_serial_port      gnss_port;
 327         struct ptp_ocp_serial_port      gnss2_port;
 328         struct ptp_ocp_serial_port      mac_port;   /* miniature atomic clock */
 329         struct ptp_ocp_serial_port      nmea_port;
 330         bool                    fw_loader;
 331         u8                      fw_tag;
 332         u16                     fw_version;
 333         u8                      board_id[OCP_BOARD_ID_LEN];
 334         u8                      serial[OCP_SERIAL_LEN];
 335         bool                    has_eeprom_data;
 336         u32                     pps_req_map;
 337         int                     flash_start;
 338         u32                     utc_tai_offset;
 339         u32                     ts_window_adjust;
 340         u64                     fw_cap;
 341         struct ptp_ocp_signal   signal[4];
 342         struct ptp_ocp_sma_connector sma[4];
 343         const struct ocp_sma_op *sma_op;
 344 };
 345
 346 #define OCP_REQ_TIMESTAMP       BIT(0)
 347 #define OCP_REQ_PPS             BIT(1)
 348
 349 struct ocp_resource {
 350         unsigned long offset;
 351         int size;
 352         int irq_vec;
 353         int (*setup)(struct ptp_ocp *bp, struct ocp_resource *r);
 354         void *extra;
 355         unsigned long bp_offset;
 356         const char * const name;
 357 };
 358
 359 static int ptp_ocp_register_mem(struct ptp_ocp *bp, struct ocp_resource *r);
 360 static int ptp_ocp_register_i2c(struct ptp_ocp *bp, struct ocp_resource *r);
 361 static int ptp_ocp_register_spi(struct ptp_ocp *bp, struct ocp_resource *r);
 362 static int ptp_ocp_register_serial(struct ptp_ocp *bp, struct ocp_resource *r);
 363 static int ptp_ocp_register_ext(struct ptp_ocp *bp, struct ocp_resource *r);
 364 static int ptp_ocp_fb_board_init(struct ptp_ocp *bp, struct ocp_resource *r);
 365 static irqreturn_t ptp_ocp_ts_irq(int irq, void *priv);
 366 static irqreturn_t ptp_ocp_signal_irq(int irq, void *priv);
 367 static int ptp_ocp_ts_enable(void *priv, u32 req, bool enable);
 368 static int ptp_ocp_signal_from_perout(struct ptp_ocp *bp, int gen,
 369                                       struct ptp_perout_request *req);
 370 static int ptp_ocp_signal_enable(void *priv, u32 req, bool enable);
 371 static int ptp_ocp_sma_store(struct ptp_ocp *bp, const char *buf, int sma_nr);
 372
 373 static const struct ocp_attr_group fb_timecard_groups[];
 374
 375 struct ptp_ocp_eeprom_map {
 376         u16     off;
 377         u16     len;
 378         u32     bp_offset;
 379         const void * const tag;
 380 };
 381
 382 #define EEPROM_ENTRY(addr, member)                              \
 383         .off = addr,                                            \
 384         .len = sizeof_field(struct ptp_ocp, member),            \
 385         .bp_offset = offsetof(struct ptp_ocp, member)
 386
 387 #define BP_MAP_ENTRY_ADDR(bp, map) ({                           \
 388         (void *)((uintptr_t)(bp) + (map)->bp_offset);           \
 389 })
 390
 391 static struct ptp_ocp_eeprom_map fb_eeprom_map[] = {
 392         { EEPROM_ENTRY(0x43, board_id) },
 393         { EEPROM_ENTRY(0x00, serial), .tag = "mac" },
 394         { }
 395 };
 396
 397 #define bp_assign_entry(bp, res, val) ({                                \
 398         uintptr_t addr = (uintptr_t)(bp) + (res)->bp_offset;            \
 399         *(typeof(val) *)addr = val;                                     \
 400 })
 401
 402 #define OCP_RES_LOCATION(member) \
 403         .name = #member, .bp_offset = offsetof(struct ptp_ocp, member)
 404
 405 #define OCP_MEM_RESOURCE(member) \
 406         OCP_RES_LOCATION(member), .setup = ptp_ocp_register_mem
 407
 408 #define OCP_SERIAL_RESOURCE(member) \
 409         OCP_RES_LOCATION(member), .setup = ptp_ocp_register_serial
 410
 411 #define OCP_I2C_RESOURCE(member) \
 412         OCP_RES_LOCATION(member), .setup = ptp_ocp_register_i2c
 413
 414 #define OCP_SPI_RESOURCE(member) \
 415         OCP_RES_LOCATION(member), .setup = ptp_ocp_register_spi
 416
 417 #define OCP_EXT_RESOURCE(member) \
 418         OCP_RES_LOCATION(member), .setup = ptp_ocp_register_ext
 419
 420 /* This is the MSI vector mapping used.
 421  * 0: PPS (TS5)
 422  * 1: TS0
 423  * 2: TS1
 424  * 3: GNSS1
 425  * 4: GNSS2
 426  * 5: MAC
 427  * 6: TS2
 428  * 7: I2C controller
 429  * 8: HWICAP (notused)
 430  * 9: SPI Flash
 431  * 10: NMEA
 432  * 11: Signal Generator 1
 433  * 12: Signal Generator 2
 434  * 13: Signal Generator 3
 435  * 14: Signal Generator 4
 436  * 15: TS3
 437  * 16: TS4
 438  */
 439
 440 static struct ocp_resource ocp_fb_resource[] = {
 441         {
 442                 OCP_MEM_RESOURCE(reg),
 443                 .offset = 0x01000000, .size = 0x10000,
 444         },
 445         {
 446                 OCP_EXT_RESOURCE(ts0),
 447                 .offset = 0x01010000, .size = 0x10000, .irq_vec = 1,
 448                 .extra = &(struct ptp_ocp_ext_info) {
 449                         .index = 0,
 450                         .irq_fcn = ptp_ocp_ts_irq,
 451                         .enable = ptp_ocp_ts_enable,
 452                 },
 453         },
 454         {
 455                 OCP_EXT_RESOURCE(ts1),
 456                 .offset = 0x01020000, .size = 0x10000, .irq_vec = 2,
 457                 .extra = &(struct ptp_ocp_ext_info) {
 458                         .index = 1,
 459                         .irq_fcn = ptp_ocp_ts_irq,
 460                         .enable = ptp_ocp_ts_enable,
 461                 },
 462         },
 463         {
 464                 OCP_EXT_RESOURCE(ts2),
 465                 .offset = 0x01060000, .size = 0x10000, .irq_vec = 6,
 466                 .extra = &(struct ptp_ocp_ext_info) {
 467                         .index = 2,
 468                         .irq_fcn = ptp_ocp_ts_irq,
 469                         .enable = ptp_ocp_ts_enable,
 470                 },
 471         },
 472         {
 473                 OCP_EXT_RESOURCE(ts3),
 474                 .offset = 0x01110000, .size = 0x10000, .irq_vec = 15,
 475                 .extra = &(struct ptp_ocp_ext_info) {
 476                         .index = 3,
 477                         .irq_fcn = ptp_ocp_ts_irq,
 478                         .enable = ptp_ocp_ts_enable,
 479                 },
 480         },
 481         {
 482                 OCP_EXT_RESOURCE(ts4),
 483                 .offset = 0x01120000, .size = 0x10000, .irq_vec = 16,
 484                 .extra = &(struct ptp_ocp_ext_info) {
 485                         .index = 4,
 486                         .irq_fcn = ptp_ocp_ts_irq,
 487                         .enable = ptp_ocp_ts_enable,
 488                 },
 489         },
 490         /* Timestamp for PHC and/or PPS generator */
 491         {
 492                 OCP_EXT_RESOURCE(pps),
 493                 .offset = 0x010C0000, .size = 0x10000, .irq_vec = 0,
 494                 .extra = &(struct ptp_ocp_ext_info) {
 495                         .index = 5,
 496                         .irq_fcn = ptp_ocp_ts_irq,
 497                         .enable = ptp_ocp_ts_enable,
 498                 },
 499         },
 500         {
 501                 OCP_EXT_RESOURCE(signal_out[0]),
 502                 .offset = 0x010D0000, .size = 0x10000, .irq_vec = 11,
 503                 .extra = &(struct ptp_ocp_ext_info) {
 504                         .index = 1,
 505                         .irq_fcn = ptp_ocp_signal_irq,
 506                         .enable = ptp_ocp_signal_enable,
 507                 },
 508         },
 509         {
 510                 OCP_EXT_RESOURCE(signal_out[1]),
 511                 .offset = 0x010E0000, .size = 0x10000, .irq_vec = 12,
 512                 .extra = &(struct ptp_ocp_ext_info) {
 513                         .index = 2,
 514                         .irq_fcn = ptp_ocp_signal_irq,
 515                         .enable = ptp_ocp_signal_enable,
 516                 },
 517         },
 518         {
 519                 OCP_EXT_RESOURCE(signal_out[2]),
 520                 .offset = 0x010F0000, .size = 0x10000, .irq_vec = 13,
 521                 .extra = &(struct ptp_ocp_ext_info) {
 522                         .index = 3,
 523                         .irq_fcn = ptp_ocp_signal_irq,
 524                         .enable = ptp_ocp_signal_enable,
 525                 },
 526         },
 527         {
 528                 OCP_EXT_RESOURCE(signal_out[3]),
 529                 .offset = 0x01100000, .size = 0x10000, .irq_vec = 14,
 530                 .extra = &(struct ptp_ocp_ext_info) {
 531                         .index = 4,
 532                         .irq_fcn = ptp_ocp_signal_irq,
 533                         .enable = ptp_ocp_signal_enable,
 534                 },
 535         },
 536         {
 537                 OCP_MEM_RESOURCE(pps_to_ext),
 538                 .offset = 0x01030000, .size = 0x10000,
 539         },
 540         {
 541                 OCP_MEM_RESOURCE(pps_to_clk),
 542                 .offset = 0x01040000, .size = 0x10000,
 543         },
 544         {
 545                 OCP_MEM_RESOURCE(tod),
 546                 .offset = 0x01050000, .size = 0x10000,
 547         },
 548         {
 549                 OCP_MEM_RESOURCE(irig_in),
 550                 .offset = 0x01070000, .size = 0x10000,
 551         },
 552         {
 553                 OCP_MEM_RESOURCE(irig_out),
 554                 .offset = 0x01080000, .size = 0x10000,
 555         },
 556         {
 557                 OCP_MEM_RESOURCE(dcf_in),
 558                 .offset = 0x01090000, .size = 0x10000,
 559         },
 560         {
 561                 OCP_MEM_RESOURCE(dcf_out),
 562                 .offset = 0x010A0000, .size = 0x10000,
 563         },
 564         {
 565                 OCP_MEM_RESOURCE(nmea_out),
 566                 .offset = 0x010B0000, .size = 0x10000,
 567         },
 568         {
 569                 OCP_MEM_RESOURCE(image),
 570                 .offset = 0x00020000, .size = 0x1000,
 571         },
 572         {
 573                 OCP_MEM_RESOURCE(pps_select),
 574                 .offset = 0x00130000, .size = 0x1000,
 575         },
 576         {
 577                 OCP_MEM_RESOURCE(sma_map1),
 578                 .offset = 0x00140000, .size = 0x1000,
 579         },
 580         {
 581                 OCP_MEM_RESOURCE(sma_map2),
 582                 .offset = 0x00220000, .size = 0x1000,
 583         },
 584         {
 585                 OCP_I2C_RESOURCE(i2c_ctrl),
 586                 .offset = 0x00150000, .size = 0x10000, .irq_vec = 7,
 587                 .extra = &(struct ptp_ocp_i2c_info) {
 588                         .name = "xiic-i2c",
 589                         .fixed_rate = 50000000,
 590                         .data_size = sizeof(struct xiic_i2c_platform_data),
 591                         .data = &(struct xiic_i2c_platform_data) {
 592                                 .num_devices = 2,
 593                                 .devices = (struct i2c_board_info[]) {
 594                                         { I2C_BOARD_INFO("24c02", 0x50) },
 595                                         { I2C_BOARD_INFO("24mac402", 0x58),
 596                                           .platform_data = "mac" },
 597                                 },
 598                         },
 599                 },
 600         },
 601         {
 602                 OCP_SERIAL_RESOURCE(gnss_port),
 603                 .offset = 0x00160000 + 0x1000, .irq_vec = 3,
 604                 .extra = &(struct ptp_ocp_serial_port) {
 605                         .baud = 115200,
 606                 },
 607         },
 608         {
 609                 OCP_SERIAL_RESOURCE(gnss2_port),
 610                 .offset = 0x00170000 + 0x1000, .irq_vec = 4,
 611                 .extra = &(struct ptp_ocp_serial_port) {
 612                         .baud = 115200,
 613                 },
 614         },
 615         {
 616                 OCP_SERIAL_RESOURCE(mac_port),
 617                 .offset = 0x00180000 + 0x1000, .irq_vec = 5,
 618                 .extra = &(struct ptp_ocp_serial_port) {
 619                         .baud = 57600,
 620                 },
 621         },
 622         {
 623                 OCP_SERIAL_RESOURCE(nmea_port),
 624                 .offset = 0x00190000 + 0x1000, .irq_vec = 10,
 625         },
 626         {
 627                 OCP_SPI_RESOURCE(spi_flash),
 628                 .offset = 0x00310000, .size = 0x10000, .irq_vec = 9,
 629                 .extra = &(struct ptp_ocp_flash_info) {
 630                         .name = "xilinx_spi", .pci_offset = 0,
 631                         .data_size = sizeof(struct xspi_platform_data),
 632                         .data = &(struct xspi_platform_data) {
 633                                 .num_chipselect = 1,
 634                                 .bits_per_word = 8,
 635                                 .num_devices = 1,
 636                                 .devices = &(struct spi_board_info) {
 637                                         .modalias = "spi-nor",
 638                                 },
 639                         },
 640                 },
 641         },
 642         {
 643                 OCP_MEM_RESOURCE(freq_in[0]),
 644                 .offset = 0x01200000, .size = 0x10000,
 645         },
 646         {
 647                 OCP_MEM_RESOURCE(freq_in[1]),
 648                 .offset = 0x01210000, .size = 0x10000,
 649         },
 650         {
 651                 OCP_MEM_RESOURCE(freq_in[2]),
 652                 .offset = 0x01220000, .size = 0x10000,
 653         },
 654         {
 655                 OCP_MEM_RESOURCE(freq_in[3]),
 656                 .offset = 0x01230000, .size = 0x10000,
 657         },
 658         {
 659                 .setup = ptp_ocp_fb_board_init,
 660         },
 661         { }
 662 };
 663
 664 static const struct pci_device_id ptp_ocp_pcidev_id[] = {
 665         { PCI_DEVICE_DATA(FACEBOOK, TIMECARD, &ocp_fb_resource) },
 666         { PCI_DEVICE_DATA(CELESTICA, TIMECARD, &ocp_fb_resource) },
 667         { }
 668 };
 669 MODULE_DEVICE_TABLE(pci, ptp_ocp_pcidev_id);
 670
 671 static DEFINE_MUTEX(ptp_ocp_lock);
 672 static DEFINE_IDR(ptp_ocp_idr);
 673
 674 struct ocp_selector {
 675         const char *name;
 676         int value;
 677 };
 678
 679 static const struct ocp_selector ptp_ocp_clock[] = {
 680         { .name = "NONE",       .value = 0 },
 681         { .name = "TOD",        .value = 1 },
 682         { .name = "IRIG",       .value = 2 },
 683         { .name = "PPS",        .value = 3 },
 684         { .name = "PTP",        .value = 4 },
 685         { .name = "RTC",        .value = 5 },
 686         { .name = "DCF",        .value = 6 },
 687         { .name = "REGS",       .value = 0xfe },
 688         { .name = "EXT",        .value = 0xff },
 689         { }
 690 };
 691
 692 #define SMA_DISABLE             BIT(16)
 693 #define SMA_ENABLE              BIT(15)
 694 #define SMA_SELECT_MASK         GENMASK(14, 0)
 695
 696 static const struct ocp_selector ptp_ocp_sma_in[] = {
 697         { .name = "10Mhz",      .value = 0x0000 },
 698         { .name = "PPS1",       .value = 0x0001 },
 699         { .name = "PPS2",       .value = 0x0002 },
 700         { .name = "TS1",        .value = 0x0004 },
 701         { .name = "TS2",        .value = 0x0008 },
 702         { .name = "IRIG",       .value = 0x0010 },
 703         { .name = "DCF",        .value = 0x0020 },
 704         { .name = "TS3",        .value = 0x0040 },
 705         { .name = "TS4",        .value = 0x0080 },
 706         { .name = "FREQ1",      .value = 0x0100 },
 707         { .name = "FREQ2",      .value = 0x0200 },
 708         { .name = "FREQ3",      .value = 0x0400 },
 709         { .name = "FREQ4",      .value = 0x0800 },
 710         { .name = "None",       .value = SMA_DISABLE },
 711         { }
 712 };
 713
 714 static const struct ocp_selector ptp_ocp_sma_out[] = {
 715         { .name = "10Mhz",      .value = 0x0000 },
 716         { .name = "PHC",        .value = 0x0001 },
 717         { .name = "MAC",        .value = 0x0002 },
 718         { .name = "GNSS1",      .value = 0x0004 },
 719         { .name = "GNSS2",      .value = 0x0008 },
 720         { .name = "IRIG",       .value = 0x0010 },
 721         { .name = "DCF",        .value = 0x0020 },
 722         { .name = "GEN1",       .value = 0x0040 },
 723         { .name = "GEN2",       .value = 0x0080 },
 724         { .name = "GEN3",       .value = 0x0100 },
 725         { .name = "GEN4",       .value = 0x0200 },
 726         { .name = "GND",        .value = 0x2000 },
 727         { .name = "VCC",        .value = 0x4000 },
 728         { }
 729 };
 730
 731 struct ocp_sma_op {
 732         const struct ocp_selector *tbl[2];
 733         void (*init)(struct ptp_ocp *bp);
 734         u32 (*get)(struct ptp_ocp *bp, int sma_nr);
 735         int (*set_inputs)(struct ptp_ocp *bp, int sma_nr, u32 val);
 736         int (*set_output)(struct ptp_ocp *bp, int sma_nr, u32 val);
 737 };
 738
 739 static void
 740 ptp_ocp_sma_init(struct ptp_ocp *bp)
 741 {
 742         return bp->sma_op->init(bp);
 743 }
 744
 745 static u32
 746 ptp_ocp_sma_get(struct ptp_ocp *bp, int sma_nr)
 747 {
 748         return bp->sma_op->get(bp, sma_nr);
 749 }
 750
 751 static int
 752 ptp_ocp_sma_set_inputs(struct ptp_ocp *bp, int sma_nr, u32 val)
 753 {
 754         return bp->sma_op->set_inputs(bp, sma_nr, val);
 755 }
 756
 757 static int
 758 ptp_ocp_sma_set_output(struct ptp_ocp *bp, int sma_nr, u32 val)
 759 {
 760         return bp->sma_op->set_output(bp, sma_nr, val);
 761 }
 762
 763 static const char *
 764 ptp_ocp_select_name_from_val(const struct ocp_selector *tbl, int val)
 765 {
 766         int i;
 767
 768         for (i = 0; tbl[i].name; i++)
 769                 if (tbl[i].value == val)
 770                         return tbl[i].name;
 771         return NULL;
 772 }
 773
 774 static int
 775 ptp_ocp_select_val_from_name(const struct ocp_selector *tbl, const char *name)
 776 {
 777         const char *select;
 778         int i;
 779
 780         for (i = 0; tbl[i].name; i++) {
 781                 select = tbl[i].name;
 782                 if (!strncasecmp(name, select, strlen(select)))
 783                         return tbl[i].value;
 784         }
 785         return -EINVAL;
 786 }
 787
 788 static ssize_t
 789 ptp_ocp_select_table_show(const struct ocp_selector *tbl, char *buf)
 790 {
 791         ssize_t count;
 792         int i;
 793
 794         count = 0;
 795         for (i = 0; tbl[i].name; i++)
 796                 count += sysfs_emit_at(buf, count, "%s ", tbl[i].name);
 797         if (count)
 798                 count--;
 799         count += sysfs_emit_at(buf, count, "\n");
 800         return count;
 801 }
 802
 803 static int
 804 __ptp_ocp_gettime_locked(struct ptp_ocp *bp, struct timespec64 *ts,
 805                          struct ptp_system_timestamp *sts)
 806 {
 807         u32 ctrl, time_sec, time_ns;
 808         int i;
 809
 810         ptp_read_system_prets(sts);
 811
 812         ctrl = OCP_CTRL_READ_TIME_REQ | OCP_CTRL_ENABLE;
 813         iowrite32(ctrl, &bp->reg->ctrl);
 814
 815         for (i = 0; i < 100; i++) {
 816                 ctrl = ioread32(&bp->reg->ctrl);
 817                 if (ctrl & OCP_CTRL_READ_TIME_DONE)
 818                         break;
 819         }
 820         ptp_read_system_postts(sts);
 821
 822         if (sts && bp->ts_window_adjust) {
 823                 s64 ns = timespec64_to_ns(&sts->post_ts);
 824
 825                 sts->post_ts = ns_to_timespec64(ns - bp->ts_window_adjust);
 826         }
 827
 828         time_ns = ioread32(&bp->reg->time_ns);
 829         time_sec = ioread32(&bp->reg->time_sec);
 830
 831         ts->tv_sec = time_sec;
 832         ts->tv_nsec = time_ns;
 833
 834         return ctrl & OCP_CTRL_READ_TIME_DONE ? 0 : -ETIMEDOUT;
 835 }
 836
 837 static int
 838 ptp_ocp_gettimex(struct ptp_clock_info *ptp_info, struct timespec64 *ts,
 839                  struct ptp_system_timestamp *sts)
 840 {
 841         struct ptp_ocp *bp = container_of(ptp_info, struct ptp_ocp, ptp_info);
 842         unsigned long flags;
 843         int err;
 844
 845         spin_lock_irqsave(&bp->lock, flags);
 846         err = __ptp_ocp_gettime_locked(bp, ts, sts);
 847         spin_unlock_irqrestore(&bp->lock, flags);
 848
 849         return err;
 850 }
 851
 852 static void
 853 __ptp_ocp_settime_locked(struct ptp_ocp *bp, const struct timespec64 *ts)
 854 {
 855         u32 ctrl, time_sec, time_ns;
 856         u32 select;
 857
 858         time_ns = ts->tv_nsec;
 859         time_sec = ts->tv_sec;
 860
 861         select = ioread32(&bp->reg->select);
 862         iowrite32(OCP_SELECT_CLK_REG, &bp->reg->select);
 863
 864         iowrite32(time_ns, &bp->reg->adjust_ns);
 865         iowrite32(time_sec, &bp->reg->adjust_sec);
 866
 867         ctrl = OCP_CTRL_ADJUST_TIME | OCP_CTRL_ENABLE;
 868         iowrite32(ctrl, &bp->reg->ctrl);
 869
 870         /* restore clock selection */
 871         iowrite32(select >> 16, &bp->reg->select);
 872 }
 873
 874 static int
 875 ptp_ocp_settime(struct ptp_clock_info *ptp_info, const struct timespec64 *ts)
 876 {
 877         struct ptp_ocp *bp = container_of(ptp_info, struct ptp_ocp, ptp_info);
 878         unsigned long flags;
 879
 880         spin_lock_irqsave(&bp->lock, flags);
 881         __ptp_ocp_settime_locked(bp, ts);
 882         spin_unlock_irqrestore(&bp->lock, flags);
 883
 884         return 0;
 885 }
 886
 887 static void
 888 __ptp_ocp_adjtime_locked(struct ptp_ocp *bp, u32 adj_val)
 889 {
 890         u32 select, ctrl;
 891
 892         select = ioread32(&bp->reg->select);
 893         iowrite32(OCP_SELECT_CLK_REG, &bp->reg->select);
 894
 895         iowrite32(adj_val, &bp->reg->offset_ns);
 896         iowrite32(NSEC_PER_SEC, &bp->reg->offset_window_ns);
 897
 898         ctrl = OCP_CTRL_ADJUST_OFFSET | OCP_CTRL_ENABLE;
 899         iowrite32(ctrl, &bp->reg->ctrl);
 900
 901         /* restore clock selection */
 902         iowrite32(select >> 16, &bp->reg->select);
 903 }
 904
 905 static void
 906 ptp_ocp_adjtime_coarse(struct ptp_ocp *bp, s64 delta_ns)
 907 {
 908         struct timespec64 ts;
 909         unsigned long flags;
 910         int err;
 911
 912         spin_lock_irqsave(&bp->lock, flags);
 913         err = __ptp_ocp_gettime_locked(bp, &ts, NULL);
 914         if (likely(!err)) {
 915                 set_normalized_timespec64(&ts, ts.tv_sec,
 916                                           ts.tv_nsec + delta_ns);
 917                 __ptp_ocp_settime_locked(bp, &ts);
 918         }
 919         spin_unlock_irqrestore(&bp->lock, flags);
 920 }
 921
 922 static int
 923 ptp_ocp_adjtime(struct ptp_clock_info *ptp_info, s64 delta_ns)
 924 {
 925         struct ptp_ocp *bp = container_of(ptp_info, struct ptp_ocp, ptp_info);
 926         unsigned long flags;
 927         u32 adj_ns, sign;
 928
 929         if (delta_ns > NSEC_PER_SEC || -delta_ns > NSEC_PER_SEC) {
 930                 ptp_ocp_adjtime_coarse(bp, delta_ns);
 931                 return 0;
 932         }
 933
 934         sign = delta_ns < 0 ? BIT(31) : 0;
 935         adj_ns = sign ? -delta_ns : delta_ns;
 936
 937         spin_lock_irqsave(&bp->lock, flags);
 938         __ptp_ocp_adjtime_locked(bp, sign | adj_ns);
 939         spin_unlock_irqrestore(&bp->lock, flags);
 940
 941         return 0;
 942 }
 943
 944 static int
 945 ptp_ocp_null_adjfine(struct ptp_clock_info *ptp_info, long scaled_ppm)
 946 {
 947         if (scaled_ppm == 0)
 948                 return 0;
 949
 950         return -EOPNOTSUPP;
 951 }
 952
 953 static int
 954 ptp_ocp_null_adjphase(struct ptp_clock_info *ptp_info, s32 phase_ns)
 955 {
 956         return -EOPNOTSUPP;
 957 }
 958
 959 static int
 960 ptp_ocp_enable(struct ptp_clock_info *ptp_info, struct ptp_clock_request *rq,
 961                int on)
 962 {
 963         struct ptp_ocp *bp = container_of(ptp_info, struct ptp_ocp, ptp_info);
 964         struct ptp_ocp_ext_src *ext = NULL;
 965         u32 req;
 966         int err;
 967
 968         switch (rq->type) {
 969         case PTP_CLK_REQ_EXTTS:
 970                 req = OCP_REQ_TIMESTAMP;
 971                 switch (rq->extts.index) {
 972                 case 0:
 973                         ext = bp->ts0;
 974                         break;
 975                 case 1:
 976                         ext = bp->ts1;
 977                         break;
 978                 case 2:
 979                         ext = bp->ts2;
 980                         break;
 981                 case 3:
 982                         ext = bp->ts3;
 983                         break;
 984                 case 4:
 985                         ext = bp->ts4;
 986                         break;
 987                 case 5:
 988                         ext = bp->pps;
 989                         break;
 990                 }
 991                 break;
 992         case PTP_CLK_REQ_PPS:
 993                 req = OCP_REQ_PPS;
 994                 ext = bp->pps;
 995                 break;
 996         case PTP_CLK_REQ_PEROUT:
 997                 switch (rq->perout.index) {
 998                 case 0:
 999                         /* This is a request for 1PPS on an output SMA.
1000                          * Allow, but assume manual configuration.
1001                          */
1002                         if (on && (rq->perout.period.sec != 1 ||
1003                                    rq->perout.period.nsec != 0))
1004                                 return -EINVAL;
1005                         return 0;
1006                 case 1:
1007                 case 2:
1008                 case 3:
1009                 case 4:
1010                         req = rq->perout.index - 1;
1011                         ext = bp->signal_out[req];
1012                         err = ptp_ocp_signal_from_perout(bp, req, &rq->perout);
1013                         if (err)
1014                                 return err;
1015                         break;
1016                 }
1017                 break;
1018         default:
1019                 return -EOPNOTSUPP;
1020         }
1021
1022         err = -ENXIO;
1023         if (ext)
1024                 err = ext->info->enable(ext, req, on);
1025
1026         return err;
1027 }
1028
1029 static int
1030 ptp_ocp_verify(struct ptp_clock_info *ptp_info, unsigned pin,
1031                enum ptp_pin_function func, unsigned chan)
1032 {
1033         struct ptp_ocp *bp = container_of(ptp_info, struct ptp_ocp, ptp_info);
1034         char buf[16];
1035
1036         switch (func) {
1037         case PTP_PF_NONE:
1038                 snprintf(buf, sizeof(buf), "IN: None");
1039                 break;
1040         case PTP_PF_EXTTS:
1041                 /* Allow timestamps, but require sysfs configuration. */
1042                 return 0;
1043         case PTP_PF_PEROUT:
1044                 /* channel 0 is 1PPS from PHC.
1045                  * channels 1..4 are the frequency generators.
1046                  */
1047                 if (chan)
1048                         snprintf(buf, sizeof(buf), "OUT: GEN%d", chan);
1049                 else
1050                         snprintf(buf, sizeof(buf), "OUT: PHC");
1051                 break;
1052         default:
1053                 return -EOPNOTSUPP;
1054         }
1055
1056         return ptp_ocp_sma_store(bp, buf, pin + 1);
1057 }
1058
1059 static const struct ptp_clock_info ptp_ocp_clock_info = {
1060         .owner          = THIS_MODULE,
1061         .name           = KBUILD_MODNAME,
1062         .max_adj        = 100000000,
1063         .gettimex64     = ptp_ocp_gettimex,
1064         .settime64      = ptp_ocp_settime,
1065         .adjtime        = ptp_ocp_adjtime,
1066         .adjfine        = ptp_ocp_null_adjfine,
1067         .adjphase       = ptp_ocp_null_adjphase,
1068         .enable         = ptp_ocp_enable,
1069         .verify         = ptp_ocp_verify,
1070         .pps            = true,
1071         .n_ext_ts       = 6,
1072         .n_per_out      = 5,
1073 };
1074
1075 static void
1076 __ptp_ocp_clear_drift_locked(struct ptp_ocp *bp)
1077 {
1078         u32 ctrl, select;
1079
1080         select = ioread32(&bp->reg->select);
1081         iowrite32(OCP_SELECT_CLK_REG, &bp->reg->select);
1082
1083         iowrite32(0, &bp->reg->drift_ns);
1084
1085         ctrl = OCP_CTRL_ADJUST_DRIFT | OCP_CTRL_ENABLE;
1086         iowrite32(ctrl, &bp->reg->ctrl);
1087
1088         /* restore clock selection */
1089         iowrite32(select >> 16, &bp->reg->select);
1090 }
1091
1092 static void
1093 ptp_ocp_utc_distribute(struct ptp_ocp *bp, u32 val)
1094 {
1095         unsigned long flags;
1096
1097         spin_lock_irqsave(&bp->lock, flags);
1098
1099         bp->utc_tai_offset = val;
1100
1101         if (bp->irig_out)
1102                 iowrite32(val, &bp->irig_out->adj_sec);
1103         if (bp->dcf_out)
1104                 iowrite32(val, &bp->dcf_out->adj_sec);
1105         if (bp->nmea_out)
1106                 iowrite32(val, &bp->nmea_out->adj_sec);
1107
1108         spin_unlock_irqrestore(&bp->lock, flags);
1109 }
1110
1111 static void
1112 ptp_ocp_watchdog(struct timer_list *t)
1113 {
1114         struct ptp_ocp *bp = from_timer(bp, t, watchdog);
1115         unsigned long flags;
1116         u32 status, utc_offset;
1117
1118         status = ioread32(&bp->pps_to_clk->status);
1119
1120         if (status & PPS_STATUS_SUPERV_ERR) {
1121                 iowrite32(status, &bp->pps_to_clk->status);
1122                 if (!bp->gnss_lost) {
1123                         spin_lock_irqsave(&bp->lock, flags);
1124                         __ptp_ocp_clear_drift_locked(bp);
1125                         spin_unlock_irqrestore(&bp->lock, flags);
1126                         bp->gnss_lost = ktime_get_real_seconds();
1127                 }
1128
1129         } else if (bp->gnss_lost) {
1130                 bp->gnss_lost = 0;
1131         }
1132
1133         /* if GNSS provides correct data we can rely on
1134          * it to get leap second information
1135          */
1136         if (bp->tod) {
1137                 status = ioread32(&bp->tod->utc_status);
1138                 utc_offset = status & TOD_STATUS_UTC_MASK;
1139                 if (status & TOD_STATUS_UTC_VALID &&
1140                     utc_offset != bp->utc_tai_offset)
1141                         ptp_ocp_utc_distribute(bp, utc_offset);
1142         }
1143
1144         mod_timer(&bp->watchdog, jiffies + HZ);
1145 }
1146
1147 static void
1148 ptp_ocp_estimate_pci_timing(struct ptp_ocp *bp)
1149 {
1150         ktime_t start, end;
1151         ktime_t delay;
1152         u32 ctrl;
1153
1154         ctrl = ioread32(&bp->reg->ctrl);
1155         ctrl = OCP_CTRL_READ_TIME_REQ | OCP_CTRL_ENABLE;
1156
1157         iowrite32(ctrl, &bp->reg->ctrl);
1158
1159         start = ktime_get_ns();
1160
1161         ctrl = ioread32(&bp->reg->ctrl);
1162
1163         end = ktime_get_ns();
1164
1165         delay = end - start;
1166         bp->ts_window_adjust = (delay >> 5) * 3;
1167 }
1168
1169 static int
1170 ptp_ocp_init_clock(struct ptp_ocp *bp)
1171 {
1172         struct timespec64 ts;
1173         bool sync;
1174         u32 ctrl;
1175
1176         ctrl = OCP_CTRL_ENABLE;
1177         iowrite32(ctrl, &bp->reg->ctrl);
1178
1179         /* NO DRIFT Correction */
1180         /* offset_p:i 1/8, offset_i: 1/16, drift_p: 0, drift_i: 0 */
1181         iowrite32(0x2000, &bp->reg->servo_offset_p);
1182         iowrite32(0x1000, &bp->reg->servo_offset_i);
1183         iowrite32(0,      &bp->reg->servo_drift_p);
1184         iowrite32(0,      &bp->reg->servo_drift_i);
1185
1186         /* latch servo values */
1187         ctrl |= OCP_CTRL_ADJUST_SERVO;
1188         iowrite32(ctrl, &bp->reg->ctrl);
1189
1190         if ((ioread32(&bp->reg->ctrl) & OCP_CTRL_ENABLE) == 0) {
1191                 dev_err(&bp->pdev->dev, "clock not enabled\n");
1192                 return -ENODEV;
1193         }
1194
1195         ptp_ocp_estimate_pci_timing(bp);
1196
1197         sync = ioread32(&bp->reg->status) & OCP_STATUS_IN_SYNC;
1198         if (!sync) {
1199                 ktime_get_clocktai_ts64(&ts);
1200                 ptp_ocp_settime(&bp->ptp_info, &ts);
1201         }
1202
1203         /* If there is a clock supervisor, then enable the watchdog */
1204         if (bp->pps_to_clk) {
1205                 timer_setup(&bp->watchdog, ptp_ocp_watchdog, 0);
1206                 mod_timer(&bp->watchdog, jiffies + HZ);
1207         }
1208
1209         return 0;
1210 }
1211
1212 static void
1213 ptp_ocp_tod_init(struct ptp_ocp *bp)
1214 {
1215         u32 ctrl, reg;
1216
1217         ctrl = ioread32(&bp->tod->ctrl);
1218         ctrl |= TOD_CTRL_PROTOCOL | TOD_CTRL_ENABLE;
1219         ctrl &= ~(TOD_CTRL_DISABLE_FMT_A | TOD_CTRL_DISABLE_FMT_B);
1220         iowrite32(ctrl, &bp->tod->ctrl);
1221
1222         reg = ioread32(&bp->tod->utc_status);
1223         if (reg & TOD_STATUS_UTC_VALID)
1224                 ptp_ocp_utc_distribute(bp, reg & TOD_STATUS_UTC_MASK);
1225 }
1226
1227 static const char *
1228 ptp_ocp_tod_proto_name(const int idx)
1229 {
1230         static const char * const proto_name[] = {
1231                 "NMEA", "NMEA_ZDA", "NMEA_RMC", "NMEA_none",
1232                 "UBX", "UBX_UTC", "UBX_LS", "UBX_none"
1233         };
1234         return proto_name[idx];
1235 }
1236
1237 static const char *
1238 ptp_ocp_tod_gnss_name(int idx)
1239 {
1240         static const char * const gnss_name[] = {
1241                 "ALL", "COMBINED", "GPS", "GLONASS", "GALILEO", "BEIDOU",
1242                 "Unknown"
1243         };
1244         if (idx >= ARRAY_SIZE(gnss_name))
1245                 idx = ARRAY_SIZE(gnss_name) - 1;
1246         return gnss_name[idx];
1247 }
1248
1249 struct ptp_ocp_nvmem_match_info {
1250         struct ptp_ocp *bp;
1251         const void * const tag;
1252 };
1253
1254 static int
1255 ptp_ocp_nvmem_match(struct device *dev, const void *data)
1256 {
1257         const struct ptp_ocp_nvmem_match_info *info = data;
1258
1259         dev = dev->parent;
1260         if (!i2c_verify_client(dev) || info->tag != dev->platform_data)
1261                 return 0;
1262
1263         while ((dev = dev->parent))
1264                 if (dev->driver && !strcmp(dev->driver->name, KBUILD_MODNAME))
1265                         return info->bp == dev_get_drvdata(dev);
1266         return 0;
1267 }
1268
1269 static inline struct nvmem_device *
1270 ptp_ocp_nvmem_device_get(struct ptp_ocp *bp, const void * const tag)
1271 {
1272         struct ptp_ocp_nvmem_match_info info = { .bp = bp, .tag = tag };
1273
1274         return nvmem_device_find(&info, ptp_ocp_nvmem_match);
1275 }
1276
1277 static inline void
1278 ptp_ocp_nvmem_device_put(struct nvmem_device **nvmemp)
1279 {
1280         if (!IS_ERR_OR_NULL(*nvmemp))
1281                 nvmem_device_put(*nvmemp);
1282         *nvmemp = NULL;
1283 }
1284
1285 static void
1286 ptp_ocp_read_eeprom(struct ptp_ocp *bp)
1287 {
1288         const struct ptp_ocp_eeprom_map *map;
1289         struct nvmem_device *nvmem;
1290         const void *tag;
1291         int ret;
1292
1293         if (!bp->i2c_ctrl)
1294                 return;
1295
1296         tag = NULL;
1297         nvmem = NULL;
1298
1299         for (map = bp->eeprom_map; map->len; map++) {
1300                 if (map->tag != tag) {
1301                         tag = map->tag;
1302                         ptp_ocp_nvmem_device_put(&nvmem);
1303                 }
1304                 if (!nvmem) {
1305                         nvmem = ptp_ocp_nvmem_device_get(bp, tag);
1306                         if (IS_ERR(nvmem)) {
1307                                 ret = PTR_ERR(nvmem);
1308                                 goto fail;
1309                         }
1310                 }
1311                 ret = nvmem_device_read(nvmem, map->off, map->len,
1312                                         BP_MAP_ENTRY_ADDR(bp, map));
1313                 if (ret != map->len)
1314                         goto fail;
1315         }
1316
1317         bp->has_eeprom_data = true;
1318
1319 out:
1320         ptp_ocp_nvmem_device_put(&nvmem);
1321         return;
1322
1323 fail:
1324         dev_err(&bp->pdev->dev, "could not read eeprom: %d\n", ret);
1325         goto out;
1326 }
1327
1328 static struct device *
1329 ptp_ocp_find_flash(struct ptp_ocp *bp)
1330 {
1331         struct device *dev, *last;
1332
1333         last = NULL;
1334         dev = &bp->spi_flash->dev;
1335
1336         while ((dev = device_find_any_child(dev))) {
1337                 if (!strcmp("mtd", dev_bus_name(dev)))
1338                         break;
1339                 put_device(last);
1340                 last = dev;
1341         }
1342         put_device(last);
1343
1344         return dev;
1345 }
1346
1347 static int
1348 ptp_ocp_devlink_fw_image(struct devlink *devlink, const struct firmware *fw,
1349                          const u8 **data, size_t *size)
1350 {
1351         struct ptp_ocp *bp = devlink_priv(devlink);
1352         const struct ptp_ocp_firmware_header *hdr;
1353         size_t offset, length;
1354         u16 crc;
1355
1356         hdr = (const struct ptp_ocp_firmware_header *)fw->data;
1357         if (memcmp(hdr->magic, OCP_FIRMWARE_MAGIC_HEADER, 4)) {
1358                 devlink_flash_update_status_notify(devlink,
1359                         "No firmware header found, flashing raw image",
1360                         NULL, 0, 0);
1361                 offset = 0;
1362                 length = fw->size;
1363                 goto out;
1364         }
1365
1366         if (be16_to_cpu(hdr->pci_vendor_id) != bp->pdev->vendor ||
1367             be16_to_cpu(hdr->pci_device_id) != bp->pdev->device) {
1368                 devlink_flash_update_status_notify(devlink,
1369                         "Firmware image compatibility check failed",
1370                         NULL, 0, 0);
1371                 return -EINVAL;
1372         }
1373
1374         offset = sizeof(*hdr);
1375         length = be32_to_cpu(hdr->image_size);
1376         if (length != (fw->size - offset)) {
1377                 devlink_flash_update_status_notify(devlink,
1378                         "Firmware image size check failed",
1379                         NULL, 0, 0);
1380                 return -EINVAL;
1381         }
1382
1383         crc = crc16(0xffff, &fw->data[offset], length);
1384         if (be16_to_cpu(hdr->crc) != crc) {
1385                 devlink_flash_update_status_notify(devlink,
1386                         "Firmware image CRC check failed",
1387                         NULL, 0, 0);
1388                 return -EINVAL;
1389         }
1390
1391 out:
1392         *data = &fw->data[offset];
1393         *size = length;
1394
1395         return 0;
1396 }
1397
1398 static int
1399 ptp_ocp_devlink_flash(struct devlink *devlink, struct device *dev,
1400                       const struct firmware *fw)
1401 {
1402         struct mtd_info *mtd = dev_get_drvdata(dev);
1403         struct ptp_ocp *bp = devlink_priv(devlink);
1404         size_t off, len, size, resid, wrote;
1405         struct erase_info erase;
1406         size_t base, blksz;
1407         const u8 *data;
1408         int err;
1409
1410         err = ptp_ocp_devlink_fw_image(devlink, fw, &data, &size);
1411         if (err)
1412                 goto out;
1413
1414         off = 0;
1415         base = bp->flash_start;
1416         blksz = 4096;
1417         resid = size;
1418
1419         while (resid) {
1420                 devlink_flash_update_status_notify(devlink, "Flashing",
1421                                                    NULL, off, size);
1422
1423                 len = min_t(size_t, resid, blksz);
1424                 erase.addr = base + off;
1425                 erase.len = blksz;
1426
1427                 err = mtd_erase(mtd, &erase);
1428                 if (err)
1429                         goto out;
1430
1431                 err = mtd_write(mtd, base + off, len, &wrote, data + off);
1432                 if (err)
1433                         goto out;
1434
1435                 off += blksz;
1436                 resid -= len;
1437         }
1438 out:
1439         return err;
1440 }
1441
1442 static int
1443 ptp_ocp_devlink_flash_update(struct devlink *devlink,
1444                              struct devlink_flash_update_params *params,
1445                              struct netlink_ext_ack *extack)
1446 {
1447         struct ptp_ocp *bp = devlink_priv(devlink);
1448         struct device *dev;
1449         const char *msg;
1450         int err;
1451
1452         dev = ptp_ocp_find_flash(bp);
1453         if (!dev) {
1454                 dev_err(&bp->pdev->dev, "Can't find Flash SPI adapter\n");
1455                 return -ENODEV;
1456         }
1457
1458         devlink_flash_update_status_notify(devlink, "Preparing to flash",
1459                                            NULL, 0, 0);
1460
1461         err = ptp_ocp_devlink_flash(devlink, dev, params->fw);
1462
1463         msg = err ? "Flash error" : "Flash complete";
1464         devlink_flash_update_status_notify(devlink, msg, NULL, 0, 0);
1465
1466         put_device(dev);
1467         return err;
1468 }
1469
1470 static int
1471 ptp_ocp_devlink_info_get(struct devlink *devlink, struct devlink_info_req *req,
1472                          struct netlink_ext_ack *extack)
1473 {
1474         struct ptp_ocp *bp = devlink_priv(devlink);
1475         const char *fw_image;
1476         char buf[32];
1477         int err;
1478
1479         err = devlink_info_driver_name_put(req, KBUILD_MODNAME);
1480         if (err)
1481                 return err;
1482
1483         fw_image = bp->fw_loader ? "loader" : "fw";
1484         sprintf(buf, "%d.%d", bp->fw_tag, bp->fw_version);
1485         err = devlink_info_version_running_put(req, fw_image, buf);
1486         if (err)
1487                 return err;
1488
1489         if (!bp->has_eeprom_data) {
1490                 ptp_ocp_read_eeprom(bp);
1491                 if (!bp->has_eeprom_data)
1492                         return 0;
1493         }
1494
1495         sprintf(buf, "%pM", bp->serial);
1496         err = devlink_info_serial_number_put(req, buf);
1497         if (err)
1498                 return err;
1499
1500         err = devlink_info_version_fixed_put(req,
1501                         DEVLINK_INFO_VERSION_GENERIC_BOARD_ID,
1502                         bp->board_id);
1503         if (err)
1504                 return err;
1505
1506         return 0;
1507 }
1508
1509 static const struct devlink_ops ptp_ocp_devlink_ops = {
1510         .flash_update = ptp_ocp_devlink_flash_update,
1511         .info_get = ptp_ocp_devlink_info_get,
1512 };
1513
1514 static void __iomem *
1515 __ptp_ocp_get_mem(struct ptp_ocp *bp, resource_size_t start, int size)
1516 {
1517         struct resource res = DEFINE_RES_MEM_NAMED(start, size, "ptp_ocp");
1518
1519         return devm_ioremap_resource(&bp->pdev->dev, &res);
1520 }
1521
1522 static void __iomem *
1523 ptp_ocp_get_mem(struct ptp_ocp *bp, struct ocp_resource *r)
1524 {
1525         resource_size_t start;
1526
1527         start = pci_resource_start(bp->pdev, 0) + r->offset;
1528         return __ptp_ocp_get_mem(bp, start, r->size);
1529 }
1530
1531 static void
1532 ptp_ocp_set_irq_resource(struct resource *res, int irq)
1533 {
1534         struct resource r = DEFINE_RES_IRQ(irq);
1535         *res = r;
1536 }
1537
1538 static void
1539 ptp_ocp_set_mem_resource(struct resource *res, resource_size_t start, int size)
1540 {
1541         struct resource r = DEFINE_RES_MEM(start, size);
1542         *res = r;
1543 }
1544
1545 static int
1546 ptp_ocp_register_spi(struct ptp_ocp *bp, struct ocp_resource *r)
1547 {
1548         struct ptp_ocp_flash_info *info;
1549         struct pci_dev *pdev = bp->pdev;
1550         struct platform_device *p;
1551         struct resource res[2];
1552         resource_size_t start;
1553         int id;
1554
1555         start = pci_resource_start(pdev, 0) + r->offset;
1556         ptp_ocp_set_mem_resource(&res[0], start, r->size);
1557         ptp_ocp_set_irq_resource(&res[1], pci_irq_vector(pdev, r->irq_vec));
1558
1559         info = r->extra;
1560         id = pci_dev_id(pdev) << 1;
1561         id += info->pci_offset;
1562
1563         p = platform_device_register_resndata(&pdev->dev, info->name, id,
1564                                               res, 2, info->data,
1565                                               info->data_size);
1566         if (IS_ERR(p))
1567                 return PTR_ERR(p);
1568
1569         bp_assign_entry(bp, r, p);
1570
1571         return 0;
1572 }
1573
1574 static struct platform_device *
1575 ptp_ocp_i2c_bus(struct pci_dev *pdev, struct ocp_resource *r, int id)
1576 {
1577         struct ptp_ocp_i2c_info *info;
1578         struct resource res[2];
1579         resource_size_t start;
1580
1581         info = r->extra;
1582         start = pci_resource_start(pdev, 0) + r->offset;
1583         ptp_ocp_set_mem_resource(&res[0], start, r->size);
1584         ptp_ocp_set_irq_resource(&res[1], pci_irq_vector(pdev, r->irq_vec));
1585
1586         return platform_device_register_resndata(&pdev->dev, info->name,
1587                                                  id, res, 2,
1588                                                  info->data, info->data_size);
1589 }
1590
1591 static int
1592 ptp_ocp_register_i2c(struct ptp_ocp *bp, struct ocp_resource *r)
1593 {
1594         struct pci_dev *pdev = bp->pdev;
1595         struct ptp_ocp_i2c_info *info;
1596         struct platform_device *p;
1597         struct clk_hw *clk;
1598         char buf[32];
1599         int id;
1600
1601         info = r->extra;
1602         id = pci_dev_id(bp->pdev);
1603
1604         sprintf(buf, "AXI.%d", id);
1605         clk = clk_hw_register_fixed_rate(&pdev->dev, buf, NULL, 0,
1606                                          info->fixed_rate);
1607         if (IS_ERR(clk))
1608                 return PTR_ERR(clk);
1609         bp->i2c_clk = clk;
1610
1611         sprintf(buf, "%s.%d", info->name, id);
1612         devm_clk_hw_register_clkdev(&pdev->dev, clk, NULL, buf);
1613         p = ptp_ocp_i2c_bus(bp->pdev, r, id);
1614         if (IS_ERR(p))
1615                 return PTR_ERR(p);
1616
1617         bp_assign_entry(bp, r, p);
1618
1619         return 0;
1620 }
1621
1622 /* The expectation is that this is triggered only on error. */
1623 static irqreturn_t
1624 ptp_ocp_signal_irq(int irq, void *priv)
1625 {
1626         struct ptp_ocp_ext_src *ext = priv;
1627         struct signal_reg __iomem *reg = ext->mem;
1628         struct ptp_ocp *bp = ext->bp;
1629         u32 enable, status;
1630         int gen;
1631
1632         gen = ext->info->index - 1;
1633
1634         enable = ioread32(&reg->enable);
1635         status = ioread32(&reg->status);
1636
1637         /* disable generator on error */
1638         if (status || !enable) {
1639                 iowrite32(0, &reg->intr_mask);
1640                 iowrite32(0, &reg->enable);
1641                 bp->signal[gen].running = false;
1642         }
1643
1644         iowrite32(0, &reg->intr);       /* ack interrupt */
1645
1646         return IRQ_HANDLED;
1647 }
1648
1649 static int
1650 ptp_ocp_signal_set(struct ptp_ocp *bp, int gen, struct ptp_ocp_signal *s)
1651 {
1652         struct ptp_system_timestamp sts;
1653         struct timespec64 ts;
1654         ktime_t start_ns;
1655         int err;
1656
1657         if (!s->period)
1658                 return 0;
1659
1660         if (!s->pulse)
1661                 s->pulse = ktime_divns(s->period * s->duty, 100);
1662
1663         err = ptp_ocp_gettimex(&bp->ptp_info, &ts, &sts);
1664         if (err)
1665                 return err;
1666
1667         start_ns = ktime_set(ts.tv_sec, ts.tv_nsec) + NSEC_PER_MSEC;
1668         if (!s->start) {
1669                 /* roundup() does not work on 32-bit systems */
1670                 s->start = DIV64_U64_ROUND_UP(start_ns, s->period);
1671                 s->start = ktime_add(s->start, s->phase);
1672         }
1673
1674         if (s->duty < 1 || s->duty > 99)
1675                 return -EINVAL;
1676
1677         if (s->pulse < 1 || s->pulse > s->period)
1678                 return -EINVAL;
1679
1680         if (s->start < start_ns)
1681                 return -EINVAL;
1682
1683         bp->signal[gen] = *s;
1684
1685         return 0;
1686 }
1687
1688 static int
1689 ptp_ocp_signal_from_perout(struct ptp_ocp *bp, int gen,
1690                            struct ptp_perout_request *req)
1691 {
1692         struct ptp_ocp_signal s = { };
1693
1694         s.polarity = bp->signal[gen].polarity;
1695         s.period = ktime_set(req->period.sec, req->period.nsec);
1696         if (!s.period)
1697                 return 0;
1698
1699         if (req->flags & PTP_PEROUT_DUTY_CYCLE) {
1700                 s.pulse = ktime_set(req->on.sec, req->on.nsec);
1701                 s.duty = ktime_divns(s.pulse * 100, s.period);
1702         }
1703
1704         if (req->flags & PTP_PEROUT_PHASE)
1705                 s.phase = ktime_set(req->phase.sec, req->phase.nsec);
1706         else
1707                 s.start = ktime_set(req->start.sec, req->start.nsec);
1708
1709         return ptp_ocp_signal_set(bp, gen, &s);
1710 }
1711
1712 static int
1713 ptp_ocp_signal_enable(void *priv, u32 req, bool enable)
1714 {
1715         struct ptp_ocp_ext_src *ext = priv;
1716         struct signal_reg __iomem *reg = ext->mem;
1717         struct ptp_ocp *bp = ext->bp;
1718         struct timespec64 ts;
1719         int gen;
1720
1721         gen = ext->info->index - 1;
1722
1723         iowrite32(0, &reg->intr_mask);
1724         iowrite32(0, &reg->enable);
1725         bp->signal[gen].running = false;
1726         if (!enable)
1727                 return 0;
1728
1729         ts = ktime_to_timespec64(bp->signal[gen].start);
1730         iowrite32(ts.tv_sec, &reg->start_sec);
1731         iowrite32(ts.tv_nsec, &reg->start_ns);
1732
1733         ts = ktime_to_timespec64(bp->signal[gen].period);
1734         iowrite32(ts.tv_sec, &reg->period_sec);
1735         iowrite32(ts.tv_nsec, &reg->period_ns);
1736
1737         ts = ktime_to_timespec64(bp->signal[gen].pulse);
1738         iowrite32(ts.tv_sec, &reg->pulse_sec);
1739         iowrite32(ts.tv_nsec, &reg->pulse_ns);
1740
1741         iowrite32(bp->signal[gen].polarity, &reg->polarity);
1742         iowrite32(0, &reg->repeat_count);
1743
1744         iowrite32(0, &reg->intr);               /* clear interrupt state */
1745         iowrite32(1, &reg->intr_mask);          /* enable interrupt */
1746         iowrite32(3, &reg->enable);             /* valid & enable */
1747
1748         bp->signal[gen].running = true;
1749
1750         return 0;
1751 }
1752
1753 static irqreturn_t
1754 ptp_ocp_ts_irq(int irq, void *priv)
1755 {
1756         struct ptp_ocp_ext_src *ext = priv;
1757         struct ts_reg __iomem *reg = ext->mem;
1758         struct ptp_clock_event ev;
1759         u32 sec, nsec;
1760
1761         if (ext == ext->bp->pps) {
1762                 if (ext->bp->pps_req_map & OCP_REQ_PPS) {
1763                         ev.type = PTP_CLOCK_PPS;
1764                         ptp_clock_event(ext->bp->ptp, &ev);
1765                 }
1766
1767                 if ((ext->bp->pps_req_map & ~OCP_REQ_PPS) == 0)
1768                         goto out;
1769         }
1770
1771         /* XXX should fix API - this converts s/ns -> ts -> s/ns */
1772         sec = ioread32(&reg->time_sec);
1773         nsec = ioread32(&reg->time_ns);
1774
1775         ev.type = PTP_CLOCK_EXTTS;
1776         ev.index = ext->info->index;
1777         ev.timestamp = sec * NSEC_PER_SEC + nsec;
1778
1779         ptp_clock_event(ext->bp->ptp, &ev);
1780
1781 out:
1782         iowrite32(1, &reg->intr);       /* write 1 to ack */
1783
1784         return IRQ_HANDLED;
1785 }
1786
1787 static int
1788 ptp_ocp_ts_enable(void *priv, u32 req, bool enable)
1789 {
1790         struct ptp_ocp_ext_src *ext = priv;
1791         struct ts_reg __iomem *reg = ext->mem;
1792         struct ptp_ocp *bp = ext->bp;
1793
1794         if (ext == bp->pps) {
1795                 u32 old_map = bp->pps_req_map;
1796
1797                 if (enable)
1798                         bp->pps_req_map |= req;
1799                 else
1800                         bp->pps_req_map &= ~req;
1801
1802                 /* if no state change, just return */
1803                 if ((!!old_map ^ !!bp->pps_req_map) == 0)
1804                         return 0;
1805         }
1806
1807         if (enable) {
1808                 iowrite32(1, &reg->enable);
1809                 iowrite32(1, &reg->intr_mask);
1810                 iowrite32(1, &reg->intr);
1811         } else {
1812                 iowrite32(0, &reg->intr_mask);
1813                 iowrite32(0, &reg->enable);
1814         }
1815
1816         return 0;
1817 }
1818
1819 static void
1820 ptp_ocp_unregister_ext(struct ptp_ocp_ext_src *ext)
1821 {
1822         ext->info->enable(ext, ~0, false);
1823         pci_free_irq(ext->bp->pdev, ext->irq_vec, ext);
1824         kfree(ext);
1825 }
1826
1827 static int
1828 ptp_ocp_register_ext(struct ptp_ocp *bp, struct ocp_resource *r)
1829 {
1830         struct pci_dev *pdev = bp->pdev;
1831         struct ptp_ocp_ext_src *ext;
1832         int err;
1833
1834         ext = kzalloc(sizeof(*ext), GFP_KERNEL);
1835         if (!ext)
1836                 return -ENOMEM;
1837
1838         ext->mem = ptp_ocp_get_mem(bp, r);
1839         if (IS_ERR(ext->mem)) {
1840                 err = PTR_ERR(ext->mem);
1841                 goto out;
1842         }
1843
1844         ext->bp = bp;
1845         ext->info = r->extra;
1846         ext->irq_vec = r->irq_vec;
1847
1848         err = pci_request_irq(pdev, r->irq_vec, ext->info->irq_fcn, NULL,
1849                               ext, "ocp%d.%s", bp->id, r->name);
1850         if (err) {
1851                 dev_err(&pdev->dev, "Could not get irq %d\n", r->irq_vec);
1852                 goto out;
1853         }
1854
1855         bp_assign_entry(bp, r, ext);
1856
1857         return 0;
1858
1859 out:
1860         kfree(ext);
1861         return err;
1862 }
1863
1864 static int
1865 ptp_ocp_serial_line(struct ptp_ocp *bp, struct ocp_resource *r)
1866 {
1867         struct pci_dev *pdev = bp->pdev;
1868         struct uart_8250_port uart;
1869
1870         /* Setting UPF_IOREMAP and leaving port.membase unspecified lets
1871          * the serial port device claim and release the pci resource.
1872          */
1873         memset(&uart, 0, sizeof(uart));
1874         uart.port.dev = &pdev->dev;
1875         uart.port.iotype = UPIO_MEM;
1876         uart.port.regshift = 2;
1877         uart.port.mapbase = pci_resource_start(pdev, 0) + r->offset;
1878         uart.port.irq = pci_irq_vector(pdev, r->irq_vec);
1879         uart.port.uartclk = 50000000;
1880         uart.port.flags = UPF_FIXED_TYPE | UPF_IOREMAP | UPF_NO_THRE_TEST;
1881         uart.port.type = PORT_16550A;
1882
1883         return serial8250_register_8250_port(&uart);
1884 }
1885
1886 static int
1887 ptp_ocp_register_serial(struct ptp_ocp *bp, struct ocp_resource *r)
1888 {
1889         struct ptp_ocp_serial_port *p = (struct ptp_ocp_serial_port *)r->extra;
1890         struct ptp_ocp_serial_port port = {};
1891
1892         port.line = ptp_ocp_serial_line(bp, r);
1893         if (port.line < 0)
1894                 return port.line;
1895
1896         if (p)
1897                 port.baud = p->baud;
1898
1899         bp_assign_entry(bp, r, port);
1900
1901         return 0;
1902 }
1903
1904 static int
1905 ptp_ocp_register_mem(struct ptp_ocp *bp, struct ocp_resource *r)
1906 {
1907         void __iomem *mem;
1908
1909         mem = ptp_ocp_get_mem(bp, r);
1910         if (IS_ERR(mem))
1911                 return PTR_ERR(mem);
1912
1913         bp_assign_entry(bp, r, mem);
1914
1915         return 0;
1916 }
1917
1918 static void
1919 ptp_ocp_nmea_out_init(struct ptp_ocp *bp)
1920 {
1921         if (!bp->nmea_out)
1922                 return;
1923
1924         iowrite32(0, &bp->nmea_out->ctrl);              /* disable */
1925         iowrite32(7, &bp->nmea_out->uart_baud);         /* 115200 */
1926         iowrite32(1, &bp->nmea_out->ctrl);              /* enable */
1927 }
1928
1929 static void
1930 _ptp_ocp_signal_init(struct ptp_ocp_signal *s, struct signal_reg __iomem *reg)
1931 {
1932         u32 val;
1933
1934         iowrite32(0, &reg->enable);             /* disable */
1935
1936         val = ioread32(&reg->polarity);
1937         s->polarity = val ? true : false;
1938         s->duty = 50;
1939 }
1940
1941 static void
1942 ptp_ocp_signal_init(struct ptp_ocp *bp)
1943 {
1944         int i;
1945
1946         for (i = 0; i < 4; i++)
1947                 if (bp->signal_out[i])
1948                         _ptp_ocp_signal_init(&bp->signal[i],
1949                                              bp->signal_out[i]->mem);
1950 }
1951
1952 static void
1953 ptp_ocp_attr_group_del(struct ptp_ocp *bp)
1954 {
1955         sysfs_remove_groups(&bp->dev.kobj, bp->attr_group);
1956         kfree(bp->attr_group);
1957 }
1958
1959 static int
1960 ptp_ocp_attr_group_add(struct ptp_ocp *bp,
1961                        const struct ocp_attr_group *attr_tbl)
1962 {
1963         int count, i;
1964         int err;
1965
1966         count = 0;
1967         for (i = 0; attr_tbl[i].cap; i++)
1968                 if (attr_tbl[i].cap & bp->fw_cap)
1969                         count++;
1970
1971         bp->attr_group = kcalloc(count + 1, sizeof(struct attribute_group *),
1972                                  GFP_KERNEL);
1973         if (!bp->attr_group)
1974                 return -ENOMEM;
1975
1976         count = 0;
1977         for (i = 0; attr_tbl[i].cap; i++)
1978                 if (attr_tbl[i].cap & bp->fw_cap)
1979                         bp->attr_group[count++] = attr_tbl[i].group;
1980
1981         err = sysfs_create_groups(&bp->dev.kobj, bp->attr_group);
1982         if (err)
1983                 bp->attr_group[0] = NULL;
1984
1985         return err;
1986 }
1987
1988 static void
1989 ptp_ocp_enable_fpga(u32 __iomem *reg, u32 bit, bool enable)
1990 {
1991         u32 ctrl;
1992         bool on;
1993
1994         ctrl = ioread32(reg);
1995         on = ctrl & bit;
1996         if (on ^ enable) {
1997                 ctrl &= ~bit;
1998                 ctrl |= enable ? bit : 0;
1999                 iowrite32(ctrl, reg);
2000         }
2001 }
2002
2003 static void
2004 ptp_ocp_irig_out(struct ptp_ocp *bp, bool enable)
2005 {
2006         return ptp_ocp_enable_fpga(&bp->irig_out->ctrl,
2007                                    IRIG_M_CTRL_ENABLE, enable);
2008 }
2009
2010 static void
2011 ptp_ocp_irig_in(struct ptp_ocp *bp, bool enable)
2012 {
2013         return ptp_ocp_enable_fpga(&bp->irig_in->ctrl,
2014                                    IRIG_S_CTRL_ENABLE, enable);
2015 }
2016
2017 static void
2018 ptp_ocp_dcf_out(struct ptp_ocp *bp, bool enable)
2019 {
2020         return ptp_ocp_enable_fpga(&bp->dcf_out->ctrl,
2021                                    DCF_M_CTRL_ENABLE, enable);
2022 }
2023
2024 static void
2025 ptp_ocp_dcf_in(struct ptp_ocp *bp, bool enable)
2026 {
2027         return ptp_ocp_enable_fpga(&bp->dcf_in->ctrl,
2028                                    DCF_S_CTRL_ENABLE, enable);
2029 }
2030
2031 static void
2032 __handle_signal_outputs(struct ptp_ocp *bp, u32 val)
2033 {
2034         ptp_ocp_irig_out(bp, val & 0x00100010);
2035         ptp_ocp_dcf_out(bp, val & 0x00200020);
2036 }
2037
2038 static void
2039 __handle_signal_inputs(struct ptp_ocp *bp, u32 val)
2040 {
2041         ptp_ocp_irig_in(bp, val & 0x00100010);
2042         ptp_ocp_dcf_in(bp, val & 0x00200020);
2043 }
2044
2045 static u32
2046 ptp_ocp_sma_fb_get(struct ptp_ocp *bp, int sma_nr)
2047 {
2048         u32 __iomem *gpio;
2049         u32 shift;
2050
2051         if (bp->sma[sma_nr - 1].fixed_fcn)
2052                 return (sma_nr - 1) & 1;
2053
2054         if (bp->sma[sma_nr - 1].mode == SMA_MODE_IN)
2055                 gpio = sma_nr > 2 ? &bp->sma_map2->gpio1 : &bp->sma_map1->gpio1;
2056         else
2057                 gpio = sma_nr > 2 ? &bp->sma_map1->gpio2 : &bp->sma_map2->gpio2;
2058         shift = sma_nr & 1 ? 0 : 16;
2059
2060         return (ioread32(gpio) >> shift) & 0xffff;
2061 }
2062
2063 static int
2064 ptp_ocp_sma_fb_set_output(struct ptp_ocp *bp, int sma_nr, u32 val)
2065 {
2066         u32 reg, mask, shift;
2067         unsigned long flags;
2068         u32 __iomem *gpio;
2069
2070         gpio = sma_nr > 2 ? &bp->sma_map1->gpio2 : &bp->sma_map2->gpio2;
2071         shift = sma_nr & 1 ? 0 : 16;
2072
2073         mask = 0xffff << (16 - shift);
2074
2075         spin_lock_irqsave(&bp->lock, flags);
2076
2077         reg = ioread32(gpio);
2078         reg = (reg & mask) | (val << shift);
2079
2080         __handle_signal_outputs(bp, reg);
2081
2082         iowrite32(reg, gpio);
2083
2084         spin_unlock_irqrestore(&bp->lock, flags);
2085
2086         return 0;
2087 }
2088
2089 static int
2090 ptp_ocp_sma_fb_set_inputs(struct ptp_ocp *bp, int sma_nr, u32 val)
2091 {
2092         u32 reg, mask, shift;
2093         unsigned long flags;
2094         u32 __iomem *gpio;
2095
2096         gpio = sma_nr > 2 ? &bp->sma_map2->gpio1 : &bp->sma_map1->gpio1;
2097         shift = sma_nr & 1 ? 0 : 16;
2098
2099         mask = 0xffff << (16 - shift);
2100
2101         spin_lock_irqsave(&bp->lock, flags);
2102
2103         reg = ioread32(gpio);
2104         reg = (reg & mask) | (val << shift);
2105
2106         __handle_signal_inputs(bp, reg);
2107
2108         iowrite32(reg, gpio);
2109
2110         spin_unlock_irqrestore(&bp->lock, flags);
2111
2112         return 0;
2113 }
2114
2115 static void
2116 ptp_ocp_sma_fb_init(struct ptp_ocp *bp)
2117 {
2118         u32 reg;
2119         int i;
2120
2121         /* defaults */
2122         bp->sma[0].mode = SMA_MODE_IN;
2123         bp->sma[1].mode = SMA_MODE_IN;
2124         bp->sma[2].mode = SMA_MODE_OUT;
2125         bp->sma[3].mode = SMA_MODE_OUT;
2126         for (i = 0; i < 4; i++)
2127                 bp->sma[i].default_fcn = i & 1;
2128
2129         /* If no SMA1 map, the pin functions and directions are fixed. */
2130         if (!bp->sma_map1) {
2131                 for (i = 0; i < 4; i++) {
2132                         bp->sma[i].fixed_fcn = true;
2133                         bp->sma[i].fixed_dir = true;
2134                 }
2135                 return;
2136         }
2137
2138         /* If SMA2 GPIO output map is all 1, it is not present.
2139          * This indicates the firmware has fixed direction SMA pins.
2140          */
2141         reg = ioread32(&bp->sma_map2->gpio2);
2142         if (reg == 0xffffffff) {
2143                 for (i = 0; i < 4; i++)
2144                         bp->sma[i].fixed_dir = true;
2145         } else {
2146                 reg = ioread32(&bp->sma_map1->gpio1);
2147                 bp->sma[0].mode = reg & BIT(15) ? SMA_MODE_IN : SMA_MODE_OUT;
2148                 bp->sma[1].mode = reg & BIT(31) ? SMA_MODE_IN : SMA_MODE_OUT;
2149
2150                 reg = ioread32(&bp->sma_map1->gpio2);
2151                 bp->sma[2].mode = reg & BIT(15) ? SMA_MODE_OUT : SMA_MODE_IN;
2152                 bp->sma[3].mode = reg & BIT(31) ? SMA_MODE_OUT : SMA_MODE_IN;
2153         }
2154 }
2155
2156 static const struct ocp_sma_op ocp_fb_sma_op = {
2157         .tbl            = { ptp_ocp_sma_in, ptp_ocp_sma_out },
2158         .init           = ptp_ocp_sma_fb_init,
2159         .get            = ptp_ocp_sma_fb_get,
2160         .set_inputs     = ptp_ocp_sma_fb_set_inputs,
2161         .set_output     = ptp_ocp_sma_fb_set_output,
2162 };
2163
2164 static int
2165 ptp_ocp_fb_set_pins(struct ptp_ocp *bp)
2166 {
2167         struct ptp_pin_desc *config;
2168         int i;
2169
2170         config = kcalloc(4, sizeof(*config), GFP_KERNEL);
2171         if (!config)
2172                 return -ENOMEM;
2173
2174         for (i = 0; i < 4; i++) {
2175                 sprintf(config[i].name, "sma%d", i + 1);
2176                 config[i].index = i;
2177         }
2178
2179         bp->ptp_info.n_pins = 4;
2180         bp->ptp_info.pin_config = config;
2181
2182         return 0;
2183 }
2184
2185 static void
2186 ptp_ocp_fb_set_version(struct ptp_ocp *bp)
2187 {
2188         u64 cap = OCP_CAP_BASIC;
2189         u32 version;
2190
2191         version = ioread32(&bp->image->version);
2192
2193         /* if lower 16 bits are empty, this is the fw loader. */
2194         if ((version & 0xffff) == 0) {
2195                 version = version >> 16;
2196                 bp->fw_loader = true;
2197         }
2198
2199         bp->fw_tag = version >> 15;
2200         bp->fw_version = version & 0x7fff;
2201
2202         if (bp->fw_tag) {
2203                 /* FPGA firmware */
2204                 if (version >= 5)
2205                         cap |= OCP_CAP_SIGNAL | OCP_CAP_FREQ;
2206         } else {
2207                 /* SOM firmware */
2208                 if (version >= 19)
2209                         cap |= OCP_CAP_SIGNAL;
2210                 if (version >= 20)
2211                         cap |= OCP_CAP_FREQ;
2212         }
2213
2214         bp->fw_cap = cap;
2215 }
2216
2217 /* FB specific board initializers; last "resource" registered. */
2218 static int
2219 ptp_ocp_fb_board_init(struct ptp_ocp *bp, struct ocp_resource *r)
2220 {
2221         int err;
2222
2223         bp->flash_start = 1024 * 4096;
2224         bp->eeprom_map = fb_eeprom_map;
2225         bp->fw_version = ioread32(&bp->image->version);
2226         bp->sma_op = &ocp_fb_sma_op;
2227
2228         ptp_ocp_fb_set_version(bp);
2229
2230         ptp_ocp_tod_init(bp);
2231         ptp_ocp_nmea_out_init(bp);
2232         ptp_ocp_sma_init(bp);
2233         ptp_ocp_signal_init(bp);
2234
2235         err = ptp_ocp_attr_group_add(bp, fb_timecard_groups);
2236         if (err)
2237                 return err;
2238
2239         err = ptp_ocp_fb_set_pins(bp);
2240         if (err)
2241                 return err;
2242
2243         return ptp_ocp_init_clock(bp);
2244 }
2245
2246 static bool
2247 ptp_ocp_allow_irq(struct ptp_ocp *bp, struct ocp_resource *r)
2248 {
2249         bool allow = !r->irq_vec || r->irq_vec < bp->n_irqs;
2250
2251         if (!allow)
2252                 dev_err(&bp->pdev->dev, "irq %d out of range, skipping %s\n",
2253                         r->irq_vec, r->name);
2254         return allow;
2255 }
2256
2257 static int
2258 ptp_ocp_register_resources(struct ptp_ocp *bp, kernel_ulong_t driver_data)
2259 {
2260         struct ocp_resource *r, *table;
2261         int err = 0;
2262
2263         table = (struct ocp_resource *)driver_data;
2264         for (r = table; r->setup; r++) {
2265                 if (!ptp_ocp_allow_irq(bp, r))
2266                         continue;
2267                 err = r->setup(bp, r);
2268                 if (err) {
2269                         dev_err(&bp->pdev->dev,
2270                                 "Could not register %s: err %d\n",
2271                                 r->name, err);
2272                         break;
2273                 }
2274         }
2275         return err;
2276 }
2277
2278 static ssize_t
2279 ptp_ocp_show_output(const struct ocp_selector *tbl, u32 val, char *buf,
2280                     int def_val)
2281 {
2282         const char *name;
2283         ssize_t count;
2284
2285         count = sysfs_emit(buf, "OUT: ");
2286         name = ptp_ocp_select_name_from_val(tbl, val);
2287         if (!name)
2288                 name = ptp_ocp_select_name_from_val(tbl, def_val);
2289         count += sysfs_emit_at(buf, count, "%s\n", name);
2290         return count;
2291 }
2292
2293 static ssize_t
2294 ptp_ocp_show_inputs(const struct ocp_selector *tbl, u32 val, char *buf,
2295                     int def_val)
2296 {
2297         const char *name;
2298         ssize_t count;
2299         int i;
2300
2301         count = sysfs_emit(buf, "IN: ");
2302         for (i = 0; tbl[i].name; i++) {
2303                 if (val & tbl[i].value) {
2304                         name = tbl[i].name;
2305                         count += sysfs_emit_at(buf, count, "%s ", name);
2306                 }
2307         }
2308         if (!val && def_val >= 0) {
2309                 name = ptp_ocp_select_name_from_val(tbl, def_val);
2310                 count += sysfs_emit_at(buf, count, "%s ", name);
2311         }
2312         if (count)
2313                 count--;
2314         count += sysfs_emit_at(buf, count, "\n");
2315         return count;
2316 }
2317
2318 static int
2319 sma_parse_inputs(const struct ocp_selector * const tbl[], const char *buf,
2320                  enum ptp_ocp_sma_mode *mode)
2321 {
2322         int idx, count, dir;
2323         char **argv;
2324         int ret;
2325
2326         argv = argv_split(GFP_KERNEL, buf, &count);
2327         if (!argv)
2328                 return -ENOMEM;
2329
2330         ret = -EINVAL;
2331         if (!count)
2332                 goto out;
2333
2334         idx = 0;
2335         dir = *mode == SMA_MODE_IN ? 0 : 1;
2336         if (!strcasecmp("IN:", argv[0])) {
2337                 dir = 0;
2338                 idx++;
2339         }
2340         if (!strcasecmp("OUT:", argv[0])) {
2341                 dir = 1;
2342                 idx++;
2343         }
2344         *mode = dir == 0 ? SMA_MODE_IN : SMA_MODE_OUT;
2345
2346         ret = 0;
2347         for (; idx < count; idx++)
2348                 ret |= ptp_ocp_select_val_from_name(tbl[dir], argv[idx]);
2349         if (ret < 0)
2350                 ret = -EINVAL;
2351
2352 out:
2353         argv_free(argv);
2354         return ret;
2355 }
2356
2357 static ssize_t
2358 ptp_ocp_sma_show(struct ptp_ocp *bp, int sma_nr, char *buf,
2359                  int default_in_val, int default_out_val)
2360 {
2361         struct ptp_ocp_sma_connector *sma = &bp->sma[sma_nr - 1];
2362         const struct ocp_selector * const *tbl;
2363         u32 val;
2364
2365         tbl = bp->sma_op->tbl;
2366         val = ptp_ocp_sma_get(bp, sma_nr) & SMA_SELECT_MASK;
2367
2368         if (sma->mode == SMA_MODE_IN) {
2369                 if (sma->disabled)
2370                         val = SMA_DISABLE;
2371                 return ptp_ocp_show_inputs(tbl[0], val, buf, default_in_val);
2372         }
2373
2374         return ptp_ocp_show_output(tbl[1], val, buf, default_out_val);
2375 }
2376
2377 static ssize_t
2378 sma1_show(struct device *dev, struct device_attribute *attr, char *buf)
2379 {
2380         struct ptp_ocp *bp = dev_get_drvdata(dev);
2381
2382         return ptp_ocp_sma_show(bp, 1, buf, 0, 1);
2383 }
2384
2385 static ssize_t
2386 sma2_show(struct device *dev, struct device_attribute *attr, char *buf)
2387 {
2388         struct ptp_ocp *bp = dev_get_drvdata(dev);
2389
2390         return ptp_ocp_sma_show(bp, 2, buf, -1, 1);
2391 }
2392
2393 static ssize_t
2394 sma3_show(struct device *dev, struct device_attribute *attr, char *buf)
2395 {
2396         struct ptp_ocp *bp = dev_get_drvdata(dev);
2397
2398         return ptp_ocp_sma_show(bp, 3, buf, -1, 0);
2399 }
2400
2401 static ssize_t
2402 sma4_show(struct device *dev, struct device_attribute *attr, char *buf)
2403 {
2404         struct ptp_ocp *bp = dev_get_drvdata(dev);
2405
2406         return ptp_ocp_sma_show(bp, 4, buf, -1, 1);
2407 }
2408
2409 static int
2410 ptp_ocp_sma_store(struct ptp_ocp *bp, const char *buf, int sma_nr)
2411 {
2412         struct ptp_ocp_sma_connector *sma = &bp->sma[sma_nr - 1];
2413         enum ptp_ocp_sma_mode mode;
2414         int val;
2415
2416         mode = sma->mode;
2417         val = sma_parse_inputs(bp->sma_op->tbl, buf, &mode);
2418         if (val < 0)
2419                 return val;
2420
2421         if (sma->fixed_dir && (mode != sma->mode || val & SMA_DISABLE))
2422                 return -EOPNOTSUPP;
2423
2424         if (sma->fixed_fcn) {
2425                 if (val != sma->default_fcn)
2426                         return -EOPNOTSUPP;
2427                 return 0;
2428         }
2429
2430         sma->disabled = !!(val & SMA_DISABLE);
2431
2432         if (mode != sma->mode) {
2433                 if (mode == SMA_MODE_IN)
2434                         ptp_ocp_sma_set_output(bp, sma_nr, 0);
2435                 else
2436                         ptp_ocp_sma_set_inputs(bp, sma_nr, 0);
2437                 sma->mode = mode;
2438         }
2439
2440         if (!sma->fixed_dir)
2441                 val |= SMA_ENABLE;              /* add enable bit */
2442
2443         if (sma->disabled)
2444                 val = 0;
2445
2446         if (mode == SMA_MODE_IN)
2447                 val = ptp_ocp_sma_set_inputs(bp, sma_nr, val);
2448         else
2449                 val = ptp_ocp_sma_set_output(bp, sma_nr, val);
2450
2451         return val;
2452 }
2453
2454 static ssize_t
2455 sma1_store(struct device *dev, struct device_attribute *attr,
2456            const char *buf, size_t count)
2457 {
2458         struct ptp_ocp *bp = dev_get_drvdata(dev);
2459         int err;
2460
2461         err = ptp_ocp_sma_store(bp, buf, 1);
2462         return err ? err : count;
2463 }
2464
2465 static ssize_t
2466 sma2_store(struct device *dev, struct device_attribute *attr,
2467            const char *buf, size_t count)
2468 {
2469         struct ptp_ocp *bp = dev_get_drvdata(dev);
2470         int err;
2471
2472         err = ptp_ocp_sma_store(bp, buf, 2);
2473         return err ? err : count;
2474 }
2475
2476 static ssize_t
2477 sma3_store(struct device *dev, struct device_attribute *attr,
2478            const char *buf, size_t count)
2479 {
2480         struct ptp_ocp *bp = dev_get_drvdata(dev);
2481         int err;
2482
2483         err = ptp_ocp_sma_store(bp, buf, 3);
2484         return err ? err : count;
2485 }
2486
2487 static ssize_t
2488 sma4_store(struct device *dev, struct device_attribute *attr,
2489            const char *buf, size_t count)
2490 {
2491         struct ptp_ocp *bp = dev_get_drvdata(dev);
2492         int err;
2493
2494         err = ptp_ocp_sma_store(bp, buf, 4);
2495         return err ? err : count;
2496 }
2497 static DEVICE_ATTR_RW(sma1);
2498 static DEVICE_ATTR_RW(sma2);
2499 static DEVICE_ATTR_RW(sma3);
2500 static DEVICE_ATTR_RW(sma4);
2501
2502 static ssize_t
2503 available_sma_inputs_show(struct device *dev,
2504                           struct device_attribute *attr, char *buf)
2505 {
2506         struct ptp_ocp *bp = dev_get_drvdata(dev);
2507
2508         return ptp_ocp_select_table_show(bp->sma_op->tbl[0], buf);
2509 }
2510 static DEVICE_ATTR_RO(available_sma_inputs);
2511
2512 static ssize_t
2513 available_sma_outputs_show(struct device *dev,
2514                            struct device_attribute *attr, char *buf)
2515 {
2516         struct ptp_ocp *bp = dev_get_drvdata(dev);
2517
2518         return ptp_ocp_select_table_show(bp->sma_op->tbl[1], buf);
2519 }
2520 static DEVICE_ATTR_RO(available_sma_outputs);
2521
2522 #define EXT_ATTR_RO(_group, _name, _val)                                \
2523         struct dev_ext_attribute dev_attr_##_group##_val##_##_name =    \
2524                 { __ATTR_RO(_name), (void *)_val }
2525 #define EXT_ATTR_RW(_group, _name, _val)                                \
2526         struct dev_ext_attribute dev_attr_##_group##_val##_##_name =    \
2527                 { __ATTR_RW(_name), (void *)_val }
2528 #define to_ext_attr(x) container_of(x, struct dev_ext_attribute, attr)
2529
2530 /* period [duty [phase [polarity]]] */
2531 static ssize_t
2532 signal_store(struct device *dev, struct device_attribute *attr,
2533              const char *buf, size_t count)
2534 {
2535         struct dev_ext_attribute *ea = to_ext_attr(attr);
2536         struct ptp_ocp *bp = dev_get_drvdata(dev);
2537         struct ptp_ocp_signal s = { };
2538         int gen = (uintptr_t)ea->var;
2539         int argc, err;
2540         char **argv;
2541
2542         argv = argv_split(GFP_KERNEL, buf, &argc);
2543         if (!argv)
2544                 return -ENOMEM;
2545
2546         err = -EINVAL;
2547         s.duty = bp->signal[gen].duty;
2548         s.phase = bp->signal[gen].phase;
2549         s.period = bp->signal[gen].period;
2550         s.polarity = bp->signal[gen].polarity;
2551
2552         switch (argc) {
2553         case 4:
2554                 argc--;
2555                 err = kstrtobool(argv[argc], &s.polarity);
2556                 if (err)
2557                         goto out;
2558                 fallthrough;
2559         case 3:
2560                 argc--;
2561                 err = kstrtou64(argv[argc], 0, &s.phase);
2562                 if (err)
2563                         goto out;
2564                 fallthrough;
2565         case 2:
2566                 argc--;
2567                 err = kstrtoint(argv[argc], 0, &s.duty);
2568                 if (err)
2569                         goto out;
2570                 fallthrough;
2571         case 1:
2572                 argc--;
2573                 err = kstrtou64(argv[argc], 0, &s.period);
2574                 if (err)
2575                         goto out;
2576                 break;
2577         default:
2578                 goto out;
2579         }
2580
2581         err = ptp_ocp_signal_set(bp, gen, &s);
2582         if (err)
2583                 goto out;
2584
2585         err = ptp_ocp_signal_enable(bp->signal_out[gen], gen, s.period != 0);
2586
2587 out:
2588         argv_free(argv);
2589         return err ? err : count;
2590 }
2591
2592 static ssize_t
2593 signal_show(struct device *dev, struct device_attribute *attr, char *buf)
2594 {
2595         struct dev_ext_attribute *ea = to_ext_attr(attr);
2596         struct ptp_ocp *bp = dev_get_drvdata(dev);
2597         struct ptp_ocp_signal *signal;
2598         struct timespec64 ts;
2599         ssize_t count;
2600         int i;
2601
2602         i = (uintptr_t)ea->var;
2603         signal = &bp->signal[i];
2604
2605         count = sysfs_emit(buf, "%llu %d %llu %d", signal->period,
2606                            signal->duty, signal->phase, signal->polarity);
2607
2608         ts = ktime_to_timespec64(signal->start);
2609         count += sysfs_emit_at(buf, count, " %ptT TAI\n", &ts);
2610
2611         return count;
2612 }
2613 static EXT_ATTR_RW(signal, signal, 0);
2614 static EXT_ATTR_RW(signal, signal, 1);
2615 static EXT_ATTR_RW(signal, signal, 2);
2616 static EXT_ATTR_RW(signal, signal, 3);
2617
2618 static ssize_t
2619 duty_show(struct device *dev, struct device_attribute *attr, char *buf)
2620 {
2621         struct dev_ext_attribute *ea = to_ext_attr(attr);
2622         struct ptp_ocp *bp = dev_get_drvdata(dev);
2623         int i = (uintptr_t)ea->var;
2624
2625         return sysfs_emit(buf, "%d\n", bp->signal[i].duty);
2626 }
2627 static EXT_ATTR_RO(signal, duty, 0);
2628 static EXT_ATTR_RO(signal, duty, 1);
2629 static EXT_ATTR_RO(signal, duty, 2);
2630 static EXT_ATTR_RO(signal, duty, 3);
2631
2632 static ssize_t
2633 period_show(struct device *dev, struct device_attribute *attr, char *buf)
2634 {
2635         struct dev_ext_attribute *ea = to_ext_attr(attr);
2636         struct ptp_ocp *bp = dev_get_drvdata(dev);
2637         int i = (uintptr_t)ea->var;
2638
2639         return sysfs_emit(buf, "%llu\n", bp->signal[i].period);
2640 }
2641 static EXT_ATTR_RO(signal, period, 0);
2642 static EXT_ATTR_RO(signal, period, 1);
2643 static EXT_ATTR_RO(signal, period, 2);
2644 static EXT_ATTR_RO(signal, period, 3);
2645
2646 static ssize_t
2647 phase_show(struct device *dev, struct device_attribute *attr, char *buf)
2648 {
2649         struct dev_ext_attribute *ea = to_ext_attr(attr);
2650         struct ptp_ocp *bp = dev_get_drvdata(dev);
2651         int i = (uintptr_t)ea->var;
2652
2653         return sysfs_emit(buf, "%llu\n", bp->signal[i].phase);
2654 }
2655 static EXT_ATTR_RO(signal, phase, 0);
2656 static EXT_ATTR_RO(signal, phase, 1);
2657 static EXT_ATTR_RO(signal, phase, 2);
2658 static EXT_ATTR_RO(signal, phase, 3);
2659
2660 static ssize_t
2661 polarity_show(struct device *dev, struct device_attribute *attr,
2662               char *buf)
2663 {
2664         struct dev_ext_attribute *ea = to_ext_attr(attr);
2665         struct ptp_ocp *bp = dev_get_drvdata(dev);
2666         int i = (uintptr_t)ea->var;
2667
2668         return sysfs_emit(buf, "%d\n", bp->signal[i].polarity);
2669 }
2670 static EXT_ATTR_RO(signal, polarity, 0);
2671 static EXT_ATTR_RO(signal, polarity, 1);
2672 static EXT_ATTR_RO(signal, polarity, 2);
2673 static EXT_ATTR_RO(signal, polarity, 3);
2674
2675 static ssize_t
2676 running_show(struct device *dev, struct device_attribute *attr, char *buf)
2677 {
2678         struct dev_ext_attribute *ea = to_ext_attr(attr);
2679         struct ptp_ocp *bp = dev_get_drvdata(dev);
2680         int i = (uintptr_t)ea->var;
2681
2682         return sysfs_emit(buf, "%d\n", bp->signal[i].running);
2683 }
2684 static EXT_ATTR_RO(signal, running, 0);
2685 static EXT_ATTR_RO(signal, running, 1);
2686 static EXT_ATTR_RO(signal, running, 2);
2687 static EXT_ATTR_RO(signal, running, 3);
2688
2689 static ssize_t
2690 start_show(struct device *dev, struct device_attribute *attr, char *buf)
2691 {
2692         struct dev_ext_attribute *ea = to_ext_attr(attr);
2693         struct ptp_ocp *bp = dev_get_drvdata(dev);
2694         int i = (uintptr_t)ea->var;
2695         struct timespec64 ts;
2696
2697         ts = ktime_to_timespec64(bp->signal[i].start);
2698         return sysfs_emit(buf, "%llu.%lu\n", ts.tv_sec, ts.tv_nsec);
2699 }
2700 static EXT_ATTR_RO(signal, start, 0);
2701 static EXT_ATTR_RO(signal, start, 1);
2702 static EXT_ATTR_RO(signal, start, 2);
2703 static EXT_ATTR_RO(signal, start, 3);
2704
2705 static ssize_t
2706 seconds_store(struct device *dev, struct device_attribute *attr,
2707               const char *buf, size_t count)
2708 {
2709         struct dev_ext_attribute *ea = to_ext_attr(attr);
2710         struct ptp_ocp *bp = dev_get_drvdata(dev);
2711         int idx = (uintptr_t)ea->var;
2712         u32 val;
2713         int err;
2714
2715         err = kstrtou32(buf, 0, &val);
2716         if (err)
2717                 return err;
2718         if (val > 0xff)
2719                 return -EINVAL;
2720
2721         if (val)
2722                 val = (val << 8) | 0x1;
2723
2724         iowrite32(val, &bp->freq_in[idx]->ctrl);
2725
2726         return count;
2727 }
2728
2729 static ssize_t
2730 seconds_show(struct device *dev, struct device_attribute *attr, char *buf)
2731 {
2732         struct dev_ext_attribute *ea = to_ext_attr(attr);
2733         struct ptp_ocp *bp = dev_get_drvdata(dev);
2734         int idx = (uintptr_t)ea->var;
2735         u32 val;
2736
2737         val = ioread32(&bp->freq_in[idx]->ctrl);
2738         if (val & 1)
2739                 val = (val >> 8) & 0xff;
2740         else
2741                 val = 0;
2742
2743         return sysfs_emit(buf, "%u\n", val);
2744 }
2745 static EXT_ATTR_RW(freq, seconds, 0);
2746 static EXT_ATTR_RW(freq, seconds, 1);
2747 static EXT_ATTR_RW(freq, seconds, 2);
2748 static EXT_ATTR_RW(freq, seconds, 3);
2749
2750 static ssize_t
2751 frequency_show(struct device *dev, struct device_attribute *attr, char *buf)
2752 {
2753         struct dev_ext_attribute *ea = to_ext_attr(attr);
2754         struct ptp_ocp *bp = dev_get_drvdata(dev);
2755         int idx = (uintptr_t)ea->var;
2756         u32 val;
2757
2758         val = ioread32(&bp->freq_in[idx]->status);
2759         if (val & FREQ_STATUS_ERROR)
2760                 return sysfs_emit(buf, "error\n");
2761         if (val & FREQ_STATUS_OVERRUN)
2762                 return sysfs_emit(buf, "overrun\n");
2763         if (val & FREQ_STATUS_VALID)
2764                 return sysfs_emit(buf, "%lu\n", val & FREQ_STATUS_MASK);
2765         return 0;
2766 }
2767 static EXT_ATTR_RO(freq, frequency, 0);
2768 static EXT_ATTR_RO(freq, frequency, 1);
2769 static EXT_ATTR_RO(freq, frequency, 2);
2770 static EXT_ATTR_RO(freq, frequency, 3);
2771
2772 static ssize_t
2773 serialnum_show(struct device *dev, struct device_attribute *attr, char *buf)
2774 {
2775         struct ptp_ocp *bp = dev_get_drvdata(dev);
2776
2777         if (!bp->has_eeprom_data)
2778                 ptp_ocp_read_eeprom(bp);
2779
2780         return sysfs_emit(buf, "%pM\n", bp->serial);
2781 }
2782 static DEVICE_ATTR_RO(serialnum);
2783
2784 static ssize_t
2785 gnss_sync_show(struct device *dev, struct device_attribute *attr, char *buf)
2786 {
2787         struct ptp_ocp *bp = dev_get_drvdata(dev);
2788         ssize_t ret;
2789
2790         if (bp->gnss_lost)
2791                 ret = sysfs_emit(buf, "LOST @ %ptT\n", &bp->gnss_lost);
2792         else
2793                 ret = sysfs_emit(buf, "SYNC\n");
2794
2795         return ret;
2796 }
2797 static DEVICE_ATTR_RO(gnss_sync);
2798
2799 static ssize_t
2800 utc_tai_offset_show(struct device *dev,
2801                     struct device_attribute *attr, char *buf)
2802 {
2803         struct ptp_ocp *bp = dev_get_drvdata(dev);
2804
2805         return sysfs_emit(buf, "%d\n", bp->utc_tai_offset);
2806 }
2807
2808 static ssize_t
2809 utc_tai_offset_store(struct device *dev,
2810                      struct device_attribute *attr,
2811                      const char *buf, size_t count)
2812 {
2813         struct ptp_ocp *bp = dev_get_drvdata(dev);
2814         int err;
2815         u32 val;
2816
2817         err = kstrtou32(buf, 0, &val);
2818         if (err)
2819                 return err;
2820
2821         ptp_ocp_utc_distribute(bp, val);
2822
2823         return count;
2824 }
2825 static DEVICE_ATTR_RW(utc_tai_offset);
2826
2827 static ssize_t
2828 ts_window_adjust_show(struct device *dev,
2829                       struct device_attribute *attr, char *buf)
2830 {
2831         struct ptp_ocp *bp = dev_get_drvdata(dev);
2832
2833         return sysfs_emit(buf, "%d\n", bp->ts_window_adjust);
2834 }
2835
2836 static ssize_t
2837 ts_window_adjust_store(struct device *dev,
2838                        struct device_attribute *attr,
2839                        const char *buf, size_t count)
2840 {
2841         struct ptp_ocp *bp = dev_get_drvdata(dev);
2842         int err;
2843         u32 val;
2844
2845         err = kstrtou32(buf, 0, &val);
2846         if (err)
2847                 return err;
2848
2849         bp->ts_window_adjust = val;
2850
2851         return count;
2852 }
2853 static DEVICE_ATTR_RW(ts_window_adjust);
2854
2855 static ssize_t
2856 irig_b_mode_show(struct device *dev, struct device_attribute *attr, char *buf)
2857 {
2858         struct ptp_ocp *bp = dev_get_drvdata(dev);
2859         u32 val;
2860
2861         val = ioread32(&bp->irig_out->ctrl);
2862         val = (val >> 16) & 0x07;
2863         return sysfs_emit(buf, "%d\n", val);
2864 }
2865
2866 static ssize_t
2867 irig_b_mode_store(struct device *dev,
2868                   struct device_attribute *attr,
2869                   const char *buf, size_t count)
2870 {
2871         struct ptp_ocp *bp = dev_get_drvdata(dev);
2872         unsigned long flags;
2873         int err;
2874         u32 reg;
2875         u8 val;
2876
2877         err = kstrtou8(buf, 0, &val);
2878         if (err)
2879                 return err;
2880         if (val > 7)
2881                 return -EINVAL;
2882
2883         reg = ((val & 0x7) << 16);
2884
2885         spin_lock_irqsave(&bp->lock, flags);
2886         iowrite32(0, &bp->irig_out->ctrl);              /* disable */
2887         iowrite32(reg, &bp->irig_out->ctrl);            /* change mode */
2888         iowrite32(reg | IRIG_M_CTRL_ENABLE, &bp->irig_out->ctrl);
2889         spin_unlock_irqrestore(&bp->lock, flags);
2890
2891         return count;
2892 }
2893 static DEVICE_ATTR_RW(irig_b_mode);
2894
2895 static ssize_t
2896 clock_source_show(struct device *dev, struct device_attribute *attr, char *buf)
2897 {
2898         struct ptp_ocp *bp = dev_get_drvdata(dev);
2899         const char *p;
2900         u32 select;
2901
2902         select = ioread32(&bp->reg->select);
2903         p = ptp_ocp_select_name_from_val(ptp_ocp_clock, select >> 16);
2904
2905         return sysfs_emit(buf, "%s\n", p);
2906 }
2907
2908 static ssize_t
2909 clock_source_store(struct device *dev, struct device_attribute *attr,
2910                    const char *buf, size_t count)
2911 {
2912         struct ptp_ocp *bp = dev_get_drvdata(dev);
2913         unsigned long flags;
2914         int val;
2915
2916         val = ptp_ocp_select_val_from_name(ptp_ocp_clock, buf);
2917         if (val < 0)
2918                 return val;
2919
2920         spin_lock_irqsave(&bp->lock, flags);
2921         iowrite32(val, &bp->reg->select);
2922         spin_unlock_irqrestore(&bp->lock, flags);
2923
2924         return count;
2925 }
2926 static DEVICE_ATTR_RW(clock_source);
2927
2928 static ssize_t
2929 available_clock_sources_show(struct device *dev,
2930                              struct device_attribute *attr, char *buf)
2931 {
2932         return ptp_ocp_select_table_show(ptp_ocp_clock, buf);
2933 }
2934 static DEVICE_ATTR_RO(available_clock_sources);
2935
2936 static ssize_t
2937 clock_status_drift_show(struct device *dev,
2938                         struct device_attribute *attr, char *buf)
2939 {
2940         struct ptp_ocp *bp = dev_get_drvdata(dev);
2941         u32 val;
2942         int res;
2943
2944         val = ioread32(&bp->reg->status_drift);
2945         res = (val & ~INT_MAX) ? -1 : 1;
2946         res *= (val & INT_MAX);
2947         return sysfs_emit(buf, "%d\n", res);
2948 }
2949 static DEVICE_ATTR_RO(clock_status_drift);
2950
2951 static ssize_t
2952 clock_status_offset_show(struct device *dev,
2953                          struct device_attribute *attr, char *buf)
2954 {
2955         struct ptp_ocp *bp = dev_get_drvdata(dev);
2956         u32 val;
2957         int res;
2958
2959         val = ioread32(&bp->reg->status_offset);
2960         res = (val & ~INT_MAX) ? -1 : 1;
2961         res *= (val & INT_MAX);
2962         return sysfs_emit(buf, "%d\n", res);
2963 }
2964 static DEVICE_ATTR_RO(clock_status_offset);
2965
2966 static ssize_t
2967 tod_correction_show(struct device *dev,
2968                     struct device_attribute *attr, char *buf)
2969 {
2970         struct ptp_ocp *bp = dev_get_drvdata(dev);
2971         u32 val;
2972         int res;
2973
2974         val = ioread32(&bp->tod->adj_sec);
2975         res = (val & ~INT_MAX) ? -1 : 1;
2976         res *= (val & INT_MAX);
2977         return sysfs_emit(buf, "%d\n", res);
2978 }
2979
2980 static ssize_t
2981 tod_correction_store(struct device *dev, struct device_attribute *attr,
2982                      const char *buf, size_t count)
2983 {
2984         struct ptp_ocp *bp = dev_get_drvdata(dev);
2985         unsigned long flags;
2986         int err, res;
2987         u32 val = 0;
2988
2989         err = kstrtos32(buf, 0, &res);
2990         if (err)
2991                 return err;
2992         if (res < 0) {
2993                 res *= -1;
2994                 val |= BIT(31);
2995         }
2996         val |= res;
2997
2998         spin_lock_irqsave(&bp->lock, flags);
2999         iowrite32(val, &bp->tod->adj_sec);
3000         spin_unlock_irqrestore(&bp->lock, flags);
3001
3002         return count;
3003 }
3004 static DEVICE_ATTR_RW(tod_correction);
3005
3006 #define _DEVICE_SIGNAL_GROUP_ATTRS(_nr)                                 \
3007         static struct attribute *fb_timecard_signal##_nr##_attrs[] = {  \
3008                 &dev_attr_signal##_nr##_signal.attr.attr,               \
3009                 &dev_attr_signal##_nr##_duty.attr.attr,                 \
3010                 &dev_attr_signal##_nr##_phase.attr.attr,                \
3011                 &dev_attr_signal##_nr##_period.attr.attr,               \
3012                 &dev_attr_signal##_nr##_polarity.attr.attr,             \
3013                 &dev_attr_signal##_nr##_running.attr.attr,              \
3014                 &dev_attr_signal##_nr##_start.attr.attr,                \
3015                 NULL,                                                   \
3016         }
3017
3018 #define DEVICE_SIGNAL_GROUP(_name, _nr)                                 \
3019         _DEVICE_SIGNAL_GROUP_ATTRS(_nr);                                \
3020         static const struct attribute_group                             \
3021                         fb_timecard_signal##_nr##_group = {             \
3022                 .name = #_name,                                         \
3023                 .attrs = fb_timecard_signal##_nr##_attrs,               \
3024 }
3025
3026 DEVICE_SIGNAL_GROUP(gen1, 0);
3027 DEVICE_SIGNAL_GROUP(gen2, 1);
3028 DEVICE_SIGNAL_GROUP(gen3, 2);
3029 DEVICE_SIGNAL_GROUP(gen4, 3);
3030
3031 #define _DEVICE_FREQ_GROUP_ATTRS(_nr)                                   \
3032         static struct attribute *fb_timecard_freq##_nr##_attrs[] = {    \
3033                 &dev_attr_freq##_nr##_seconds.attr.attr,                \
3034                 &dev_attr_freq##_nr##_frequency.attr.attr,              \
3035                 NULL,                                                   \
3036         }
3037
3038 #define DEVICE_FREQ_GROUP(_name, _nr)                                   \
3039         _DEVICE_FREQ_GROUP_ATTRS(_nr);                                  \
3040         static const struct attribute_group                             \
3041                         fb_timecard_freq##_nr##_group = {               \
3042                 .name = #_name,                                         \
3043                 .attrs = fb_timecard_freq##_nr##_attrs,                 \
3044 }
3045
3046 DEVICE_FREQ_GROUP(freq1, 0);
3047 DEVICE_FREQ_GROUP(freq2, 1);
3048 DEVICE_FREQ_GROUP(freq3, 2);
3049 DEVICE_FREQ_GROUP(freq4, 3);
3050
3051 static struct attribute *fb_timecard_attrs[] = {
3052         &dev_attr_serialnum.attr,
3053         &dev_attr_gnss_sync.attr,
3054         &dev_attr_clock_source.attr,
3055         &dev_attr_available_clock_sources.attr,
3056         &dev_attr_sma1.attr,
3057         &dev_attr_sma2.attr,
3058         &dev_attr_sma3.attr,
3059         &dev_attr_sma4.attr,
3060         &dev_attr_available_sma_inputs.attr,
3061         &dev_attr_available_sma_outputs.attr,
3062         &dev_attr_clock_status_drift.attr,
3063         &dev_attr_clock_status_offset.attr,
3064         &dev_attr_irig_b_mode.attr,
3065         &dev_attr_utc_tai_offset.attr,
3066         &dev_attr_ts_window_adjust.attr,
3067         &dev_attr_tod_correction.attr,
3068         NULL,
3069 };
3070 static const struct attribute_group fb_timecard_group = {
3071         .attrs = fb_timecard_attrs,
3072 };
3073 static const struct ocp_attr_group fb_timecard_groups[] = {
3074         { .cap = OCP_CAP_BASIC,     .group = &fb_timecard_group },
3075         { .cap = OCP_CAP_SIGNAL,    .group = &fb_timecard_signal0_group },
3076         { .cap = OCP_CAP_SIGNAL,    .group = &fb_timecard_signal1_group },
3077         { .cap = OCP_CAP_SIGNAL,    .group = &fb_timecard_signal2_group },
3078         { .cap = OCP_CAP_SIGNAL,    .group = &fb_timecard_signal3_group },
3079         { .cap = OCP_CAP_FREQ,      .group = &fb_timecard_freq0_group },
3080         { .cap = OCP_CAP_FREQ,      .group = &fb_timecard_freq1_group },
3081         { .cap = OCP_CAP_FREQ,      .group = &fb_timecard_freq2_group },
3082         { .cap = OCP_CAP_FREQ,      .group = &fb_timecard_freq3_group },
3083         { },
3084 };
3085
3086 static void
3087 gpio_input_map(char *buf, struct ptp_ocp *bp, u16 map[][2], u16 bit,
3088                const char *def)
3089 {
3090         int i;
3091
3092         for (i = 0; i < 4; i++) {
3093                 if (bp->sma[i].mode != SMA_MODE_IN)
3094                         continue;
3095                 if (map[i][0] & (1 << bit)) {
3096                         sprintf(buf, "sma%d", i + 1);
3097                         return;
3098                 }
3099         }
3100         if (!def)
3101                 def = "----";
3102         strcpy(buf, def);
3103 }
3104
3105 static void
3106 gpio_output_map(char *buf, struct ptp_ocp *bp, u16 map[][2], u16 bit)
3107 {
3108         char *ans = buf;
3109         int i;
3110
3111         strcpy(ans, "----");
3112         for (i = 0; i < 4; i++) {
3113                 if (bp->sma[i].mode != SMA_MODE_OUT)
3114                         continue;
3115                 if (map[i][1] & (1 << bit))
3116                         ans += sprintf(ans, "sma%d ", i + 1);
3117         }
3118 }
3119
3120 static void
3121 _signal_summary_show(struct seq_file *s, struct ptp_ocp *bp, int nr)
3122 {
3123         struct signal_reg __iomem *reg = bp->signal_out[nr]->mem;
3124         struct ptp_ocp_signal *signal = &bp->signal[nr];
3125         char label[8];
3126         bool on;
3127         u32 val;
3128
3129         if (!signal)
3130                 return;
3131
3132         on = signal->running;
3133         sprintf(label, "GEN%d", nr + 1);
3134         seq_printf(s, "%7s: %s, period:%llu duty:%d%% phase:%llu pol:%d",
3135                    label, on ? " ON" : "OFF",
3136                    signal->period, signal->duty, signal->phase,
3137                    signal->polarity);
3138
3139         val = ioread32(&reg->enable);
3140         seq_printf(s, " [%x", val);
3141         val = ioread32(&reg->status);
3142         seq_printf(s, " %x]", val);
3143
3144         seq_printf(s, " start:%llu\n", signal->start);
3145 }
3146
3147 static void
3148 _frequency_summary_show(struct seq_file *s, int nr,
3149                         struct frequency_reg __iomem *reg)
3150 {
3151         char label[8];
3152         bool on;
3153         u32 val;
3154
3155         if (!reg)
3156                 return;
3157
3158         sprintf(label, "FREQ%d", nr + 1);
3159         val = ioread32(&reg->ctrl);
3160         on = val & 1;
3161         val = (val >> 8) & 0xff;
3162         seq_printf(s, "%7s: %s, sec:%u",
3163                    label,
3164                    on ? " ON" : "OFF",
3165                    val);
3166
3167         val = ioread32(&reg->status);
3168         if (val & FREQ_STATUS_ERROR)
3169                 seq_printf(s, ", error");
3170         if (val & FREQ_STATUS_OVERRUN)
3171                 seq_printf(s, ", overrun");
3172         if (val & FREQ_STATUS_VALID)
3173                 seq_printf(s, ", freq %lu Hz", val & FREQ_STATUS_MASK);
3174         seq_printf(s, "  reg:%x\n", val);
3175 }
3176
3177 static int
3178 ptp_ocp_summary_show(struct seq_file *s, void *data)
3179 {
3180         struct device *dev = s->private;
3181         struct ptp_system_timestamp sts;
3182         struct ts_reg __iomem *ts_reg;
3183         char *buf, *src, *mac_src;
3184         struct timespec64 ts;
3185         struct ptp_ocp *bp;
3186         u16 sma_val[4][2];
3187         u32 ctrl, val;
3188         bool on, map;
3189         int i;
3190
3191         buf = (char *)__get_free_page(GFP_KERNEL);
3192         if (!buf)
3193                 return -ENOMEM;
3194
3195         bp = dev_get_drvdata(dev);
3196
3197         seq_printf(s, "%7s: /dev/ptp%d\n", "PTP", ptp_clock_index(bp->ptp));
3198         if (bp->gnss_port.line != -1)
3199                 seq_printf(s, "%7s: /dev/ttyS%d\n", "GNSS1",
3200                            bp->gnss_port.line);
3201         if (bp->gnss2_port.line != -1)
3202                 seq_printf(s, "%7s: /dev/ttyS%d\n", "GNSS2",
3203                            bp->gnss2_port.line);
3204         if (bp->mac_port.line != -1)
3205                 seq_printf(s, "%7s: /dev/ttyS%d\n", "MAC", bp->mac_port.line);
3206         if (bp->nmea_port.line != -1)
3207                 seq_printf(s, "%7s: /dev/ttyS%d\n", "NMEA", bp->nmea_port.line);
3208
3209         memset(sma_val, 0xff, sizeof(sma_val));
3210         if (bp->sma_map1) {
3211                 u32 reg;
3212
3213                 reg = ioread32(&bp->sma_map1->gpio1);
3214                 sma_val[0][0] = reg & 0xffff;
3215                 sma_val[1][0] = reg >> 16;
3216
3217                 reg = ioread32(&bp->sma_map1->gpio2);
3218                 sma_val[2][1] = reg & 0xffff;
3219                 sma_val[3][1] = reg >> 16;
3220
3221                 reg = ioread32(&bp->sma_map2->gpio1);
3222                 sma_val[2][0] = reg & 0xffff;
3223                 sma_val[3][0] = reg >> 16;
3224
3225                 reg = ioread32(&bp->sma_map2->gpio2);
3226                 sma_val[0][1] = reg & 0xffff;
3227                 sma_val[1][1] = reg >> 16;
3228         }
3229
3230         sma1_show(dev, NULL, buf);
3231         seq_printf(s, "   sma1: %04x,%04x %s",
3232                    sma_val[0][0], sma_val[0][1], buf);
3233
3234         sma2_show(dev, NULL, buf);
3235         seq_printf(s, "   sma2: %04x,%04x %s",
3236                    sma_val[1][0], sma_val[1][1], buf);
3237
3238         sma3_show(dev, NULL, buf);
3239         seq_printf(s, "   sma3: %04x,%04x %s",
3240                    sma_val[2][0], sma_val[2][1], buf);
3241
3242         sma4_show(dev, NULL, buf);
3243         seq_printf(s, "   sma4: %04x,%04x %s",
3244                    sma_val[3][0], sma_val[3][1], buf);
3245
3246         if (bp->ts0) {
3247                 ts_reg = bp->ts0->mem;
3248                 on = ioread32(&ts_reg->enable);
3249                 src = "GNSS1";
3250                 seq_printf(s, "%7s: %s, src: %s\n", "TS0",
3251                            on ? " ON" : "OFF", src);
3252         }
3253
3254         if (bp->ts1) {
3255                 ts_reg = bp->ts1->mem;
3256                 on = ioread32(&ts_reg->enable);
3257                 gpio_input_map(buf, bp, sma_val, 2, NULL);
3258                 seq_printf(s, "%7s: %s, src: %s\n", "TS1",
3259                            on ? " ON" : "OFF", buf);
3260         }
3261
3262         if (bp->ts2) {
3263                 ts_reg = bp->ts2->mem;
3264                 on = ioread32(&ts_reg->enable);
3265                 gpio_input_map(buf, bp, sma_val, 3, NULL);
3266                 seq_printf(s, "%7s: %s, src: %s\n", "TS2",
3267                            on ? " ON" : "OFF", buf);
3268         }
3269
3270         if (bp->ts3) {
3271                 ts_reg = bp->ts3->mem;
3272                 on = ioread32(&ts_reg->enable);
3273                 gpio_input_map(buf, bp, sma_val, 6, NULL);
3274                 seq_printf(s, "%7s: %s, src: %s\n", "TS3",
3275                            on ? " ON" : "OFF", buf);
3276         }
3277
3278         if (bp->ts4) {
3279                 ts_reg = bp->ts4->mem;
3280                 on = ioread32(&ts_reg->enable);
3281                 gpio_input_map(buf, bp, sma_val, 7, NULL);
3282                 seq_printf(s, "%7s: %s, src: %s\n", "TS4",
3283                            on ? " ON" : "OFF", buf);
3284         }
3285
3286         if (bp->pps) {
3287                 ts_reg = bp->pps->mem;
3288                 src = "PHC";
3289                 on = ioread32(&ts_reg->enable);
3290                 map = !!(bp->pps_req_map & OCP_REQ_TIMESTAMP);
3291                 seq_printf(s, "%7s: %s, src: %s\n", "TS5",
3292                            on && map ? " ON" : "OFF", src);
3293
3294                 map = !!(bp->pps_req_map & OCP_REQ_PPS);
3295                 seq_printf(s, "%7s: %s, src: %s\n", "PPS",
3296                            on && map ? " ON" : "OFF", src);
3297         }
3298
3299         if (bp->fw_cap & OCP_CAP_SIGNAL)
3300                 for (i = 0; i < 4; i++)
3301                         _signal_summary_show(s, bp, i);
3302
3303         if (bp->fw_cap & OCP_CAP_FREQ)
3304                 for (i = 0; i < 4; i++)
3305                         _frequency_summary_show(s, i, bp->freq_in[i]);
3306
3307         if (bp->irig_out) {
3308                 ctrl = ioread32(&bp->irig_out->ctrl);
3309                 on = ctrl & IRIG_M_CTRL_ENABLE;
3310                 val = ioread32(&bp->irig_out->status);
3311                 gpio_output_map(buf, bp, sma_val, 4);
3312                 seq_printf(s, "%7s: %s, error: %d, mode %d, out: %s\n", "IRIG",
3313                            on ? " ON" : "OFF", val, (ctrl >> 16), buf);
3314         }
3315
3316         if (bp->irig_in) {
3317                 on = ioread32(&bp->irig_in->ctrl) & IRIG_S_CTRL_ENABLE;
3318                 val = ioread32(&bp->irig_in->status);
3319                 gpio_input_map(buf, bp, sma_val, 4, NULL);
3320                 seq_printf(s, "%7s: %s, error: %d, src: %s\n", "IRIG in",
3321                            on ? " ON" : "OFF", val, buf);
3322         }
3323
3324         if (bp->dcf_out) {
3325                 on = ioread32(&bp->dcf_out->ctrl) & DCF_M_CTRL_ENABLE;
3326                 val = ioread32(&bp->dcf_out->status);
3327                 gpio_output_map(buf, bp, sma_val, 5);
3328                 seq_printf(s, "%7s: %s, error: %d, out: %s\n", "DCF",
3329                            on ? " ON" : "OFF", val, buf);
3330         }
3331
3332         if (bp->dcf_in) {
3333                 on = ioread32(&bp->dcf_in->ctrl) & DCF_S_CTRL_ENABLE;
3334                 val = ioread32(&bp->dcf_in->status);
3335                 gpio_input_map(buf, bp, sma_val, 5, NULL);
3336                 seq_printf(s, "%7s: %s, error: %d, src: %s\n", "DCF in",
3337                            on ? " ON" : "OFF", val, buf);
3338         }
3339
3340         if (bp->nmea_out) {
3341                 on = ioread32(&bp->nmea_out->ctrl) & 1;
3342                 val = ioread32(&bp->nmea_out->status);
3343                 seq_printf(s, "%7s: %s, error: %d\n", "NMEA",
3344                            on ? " ON" : "OFF", val);
3345         }
3346
3347         /* compute src for PPS1, used below. */
3348         if (bp->pps_select) {
3349                 val = ioread32(&bp->pps_select->gpio1);
3350                 src = &buf[80];
3351                 mac_src = "GNSS1";
3352                 if (val & 0x01) {
3353                         gpio_input_map(src, bp, sma_val, 0, NULL);
3354                         mac_src = src;
3355                 } else if (val & 0x02) {
3356                         src = "MAC";
3357                 } else if (val & 0x04) {
3358                         src = "GNSS1";
3359                 } else {
3360                         src = "----";
3361                         mac_src = src;
3362                 }
3363         } else {
3364                 src = "?";
3365                 mac_src = src;
3366         }
3367         seq_printf(s, "MAC PPS1 src: %s\n", mac_src);
3368
3369         gpio_input_map(buf, bp, sma_val, 1, "GNSS2");
3370         seq_printf(s, "MAC PPS2 src: %s\n", buf);
3371
3372         /* assumes automatic switchover/selection */
3373         val = ioread32(&bp->reg->select);
3374         switch (val >> 16) {
3375         case 0:
3376                 sprintf(buf, "----");
3377                 break;
3378         case 2:
3379                 sprintf(buf, "IRIG");
3380                 break;
3381         case 3:
3382                 sprintf(buf, "%s via PPS1", src);
3383                 break;
3384         case 6:
3385                 sprintf(buf, "DCF");
3386                 break;
3387         default:
3388                 strcpy(buf, "unknown");
3389                 break;
3390         }
3391         val = ioread32(&bp->reg->status);
3392         seq_printf(s, "%7s: %s, state: %s\n", "PHC src", buf,
3393                    val & OCP_STATUS_IN_SYNC ? "sync" : "unsynced");
3394
3395         if (!ptp_ocp_gettimex(&bp->ptp_info, &ts, &sts)) {
3396                 struct timespec64 sys_ts;
3397                 s64 pre_ns, post_ns, ns;
3398
3399                 pre_ns = timespec64_to_ns(&sts.pre_ts);
3400                 post_ns = timespec64_to_ns(&sts.post_ts);
3401                 ns = (pre_ns + post_ns) / 2;
3402                 ns += (s64)bp->utc_tai_offset * NSEC_PER_SEC;
3403                 sys_ts = ns_to_timespec64(ns);
3404
3405                 seq_printf(s, "%7s: %lld.%ld == %ptT TAI\n", "PHC",
3406                            ts.tv_sec, ts.tv_nsec, &ts);
3407                 seq_printf(s, "%7s: %lld.%ld == %ptT UTC offset %d\n", "SYS",
3408                            sys_ts.tv_sec, sys_ts.tv_nsec, &sys_ts,
3409                            bp->utc_tai_offset);
3410                 seq_printf(s, "%7s: PHC:SYS offset: %lld  window: %lld\n", "",
3411                            timespec64_to_ns(&ts) - ns,
3412                            post_ns - pre_ns);
3413         }
3414
3415         free_page((unsigned long)buf);
3416         return 0;
3417 }
3418 DEFINE_SHOW_ATTRIBUTE(ptp_ocp_summary);
3419
3420 static int
3421 ptp_ocp_tod_status_show(struct seq_file *s, void *data)
3422 {
3423         struct device *dev = s->private;
3424         struct ptp_ocp *bp;
3425         u32 val;
3426         int idx;
3427
3428         bp = dev_get_drvdata(dev);
3429
3430         val = ioread32(&bp->tod->ctrl);
3431         if (!(val & TOD_CTRL_ENABLE)) {
3432                 seq_printf(s, "TOD Slave disabled\n");
3433                 return 0;
3434         }
3435         seq_printf(s, "TOD Slave enabled, Control Register 0x%08X\n", val);
3436
3437         idx = val & TOD_CTRL_PROTOCOL ? 4 : 0;
3438         idx += (val >> 16) & 3;
3439         seq_printf(s, "Protocol %s\n", ptp_ocp_tod_proto_name(idx));
3440
3441         idx = (val >> TOD_CTRL_GNSS_SHIFT) & TOD_CTRL_GNSS_MASK;
3442         seq_printf(s, "GNSS %s\n", ptp_ocp_tod_gnss_name(idx));
3443
3444         val = ioread32(&bp->tod->version);
3445         seq_printf(s, "TOD Version %d.%d.%d\n",
3446                 val >> 24, (val >> 16) & 0xff, val & 0xffff);
3447
3448         val = ioread32(&bp->tod->status);
3449         seq_printf(s, "Status register: 0x%08X\n", val);
3450
3451         val = ioread32(&bp->tod->adj_sec);
3452         idx = (val & ~INT_MAX) ? -1 : 1;
3453         idx *= (val & INT_MAX);
3454         seq_printf(s, "Correction seconds: %d\n", idx);
3455
3456         val = ioread32(&bp->tod->utc_status);
3457         seq_printf(s, "UTC status register: 0x%08X\n", val);
3458         seq_printf(s, "UTC offset: %ld  valid:%d\n",
3459                 val & TOD_STATUS_UTC_MASK, val & TOD_STATUS_UTC_VALID ? 1 : 0);
3460         seq_printf(s, "Leap second info valid:%d, Leap second announce %d\n",
3461                 val & TOD_STATUS_LEAP_VALID ? 1 : 0,
3462                 val & TOD_STATUS_LEAP_ANNOUNCE ? 1 : 0);
3463
3464         val = ioread32(&bp->tod->leap);
3465         seq_printf(s, "Time to next leap second (in sec): %d\n", (s32) val);
3466
3467         return 0;
3468 }
3469 DEFINE_SHOW_ATTRIBUTE(ptp_ocp_tod_status);
3470
3471 static struct dentry *ptp_ocp_debugfs_root;
3472
3473 static void
3474 ptp_ocp_debugfs_add_device(struct ptp_ocp *bp)
3475 {
3476         struct dentry *d;
3477
3478         d = debugfs_create_dir(dev_name(&bp->dev), ptp_ocp_debugfs_root);
3479         bp->debug_root = d;
3480         debugfs_create_file("summary", 0444, bp->debug_root,
3481                             &bp->dev, &ptp_ocp_summary_fops);
3482         if (bp->tod)
3483                 debugfs_create_file("tod_status", 0444, bp->debug_root,
3484                                     &bp->dev, &ptp_ocp_tod_status_fops);
3485 }
3486
3487 static void
3488 ptp_ocp_debugfs_remove_device(struct ptp_ocp *bp)
3489 {
3490         debugfs_remove_recursive(bp->debug_root);
3491 }
3492
3493 static void
3494 ptp_ocp_debugfs_init(void)
3495 {
3496         ptp_ocp_debugfs_root = debugfs_create_dir("timecard", NULL);
3497 }
3498
3499 static void
3500 ptp_ocp_debugfs_fini(void)
3501 {
3502         debugfs_remove_recursive(ptp_ocp_debugfs_root);
3503 }
3504
3505 static void
3506 ptp_ocp_dev_release(struct device *dev)
3507 {
3508         struct ptp_ocp *bp = dev_get_drvdata(dev);
3509
3510         mutex_lock(&ptp_ocp_lock);
3511         idr_remove(&ptp_ocp_idr, bp->id);
3512         mutex_unlock(&ptp_ocp_lock);
3513 }
3514
3515 static int
3516 ptp_ocp_device_init(struct ptp_ocp *bp, struct pci_dev *pdev)
3517 {
3518         int err;
3519
3520         mutex_lock(&ptp_ocp_lock);
3521         err = idr_alloc(&ptp_ocp_idr, bp, 0, 0, GFP_KERNEL);
3522         mutex_unlock(&ptp_ocp_lock);
3523         if (err < 0) {
3524                 dev_err(&pdev->dev, "idr_alloc failed: %d\n", err);
3525                 return err;
3526         }
3527         bp->id = err;
3528
3529         bp->ptp_info = ptp_ocp_clock_info;
3530         spin_lock_init(&bp->lock);
3531         bp->gnss_port.line = -1;
3532         bp->gnss2_port.line = -1;
3533         bp->mac_port.line = -1;
3534         bp->nmea_port.line = -1;
3535         bp->pdev = pdev;
3536
3537         device_initialize(&bp->dev);
3538         dev_set_name(&bp->dev, "ocp%d", bp->id);
3539         bp->dev.class = &timecard_class;
3540         bp->dev.parent = &pdev->dev;
3541         bp->dev.release = ptp_ocp_dev_release;
3542         dev_set_drvdata(&bp->dev, bp);
3543
3544         err = device_add(&bp->dev);
3545         if (err) {
3546                 dev_err(&bp->dev, "device add failed: %d\n", err);
3547                 goto out;
3548         }
3549
3550         pci_set_drvdata(pdev, bp);
3551
3552         return 0;
3553
3554 out:
3555         ptp_ocp_dev_release(&bp->dev);
3556         put_device(&bp->dev);
3557         return err;
3558 }
3559
3560 static void
3561 ptp_ocp_symlink(struct ptp_ocp *bp, struct device *child, const char *link)
3562 {
3563         struct device *dev = &bp->dev;
3564
3565         if (sysfs_create_link(&dev->kobj, &child->kobj, link))
3566                 dev_err(dev, "%s symlink failed\n", link);
3567 }
3568
3569 static void
3570 ptp_ocp_link_child(struct ptp_ocp *bp, const char *name, const char *link)
3571 {
3572         struct device *dev, *child;
3573
3574         dev = &bp->pdev->dev;
3575
3576         child = device_find_child_by_name(dev, name);
3577         if (!child) {
3578                 dev_err(dev, "Could not find device %s\n", name);
3579                 return;
3580         }
3581
3582         ptp_ocp_symlink(bp, child, link);
3583         put_device(child);
3584 }
3585
3586 static int
3587 ptp_ocp_complete(struct ptp_ocp *bp)
3588 {
3589         struct pps_device *pps;
3590         char buf[32];
3591
3592         if (bp->gnss_port.line != -1) {
3593                 sprintf(buf, "ttyS%d", bp->gnss_port.line);
3594                 ptp_ocp_link_child(bp, buf, "ttyGNSS");
3595         }
3596         if (bp->gnss2_port.line != -1) {
3597                 sprintf(buf, "ttyS%d", bp->gnss2_port.line);
3598                 ptp_ocp_link_child(bp, buf, "ttyGNSS2");
3599         }
3600         if (bp->mac_port.line != -1) {
3601                 sprintf(buf, "ttyS%d", bp->mac_port.line);
3602                 ptp_ocp_link_child(bp, buf, "ttyMAC");
3603         }
3604         if (bp->nmea_port.line != -1) {
3605                 sprintf(buf, "ttyS%d", bp->nmea_port.line);
3606                 ptp_ocp_link_child(bp, buf, "ttyNMEA");
3607         }
3608         sprintf(buf, "ptp%d", ptp_clock_index(bp->ptp));
3609         ptp_ocp_link_child(bp, buf, "ptp");
3610
3611         pps = pps_lookup_dev(bp->ptp);
3612         if (pps)
3613                 ptp_ocp_symlink(bp, pps->dev, "pps");
3614
3615         ptp_ocp_debugfs_add_device(bp);
3616
3617         return 0;
3618 }
3619
3620 static void
3621 ptp_ocp_phc_info(struct ptp_ocp *bp)
3622 {
3623         struct timespec64 ts;
3624         u32 version, select;
3625         bool sync;
3626
3627         version = ioread32(&bp->reg->version);
3628         select = ioread32(&bp->reg->select);
3629         dev_info(&bp->pdev->dev, "Version %d.%d.%d, clock %s, device ptp%d\n",
3630                  version >> 24, (version >> 16) & 0xff, version & 0xffff,
3631                  ptp_ocp_select_name_from_val(ptp_ocp_clock, select >> 16),
3632                  ptp_clock_index(bp->ptp));
3633
3634         sync = ioread32(&bp->reg->status) & OCP_STATUS_IN_SYNC;
3635         if (!ptp_ocp_gettimex(&bp->ptp_info, &ts, NULL))
3636                 dev_info(&bp->pdev->dev, "Time: %lld.%ld, %s\n",
3637                          ts.tv_sec, ts.tv_nsec,
3638                          sync ? "in-sync" : "UNSYNCED");
3639 }
3640
3641 static void
3642 ptp_ocp_serial_info(struct device *dev, const char *name, int port, int baud)
3643 {
3644         if (port != -1)
3645                 dev_info(dev, "%5s: /dev/ttyS%-2d @ %6d\n", name, port, baud);
3646 }
3647
3648 static void
3649 ptp_ocp_info(struct ptp_ocp *bp)
3650 {
3651         static int nmea_baud[] = {
3652                 1200, 2400, 4800, 9600, 19200, 38400,
3653                 57600, 115200, 230400, 460800, 921600,
3654                 1000000, 2000000
3655         };
3656         struct device *dev = &bp->pdev->dev;
3657         u32 reg;
3658
3659         ptp_ocp_phc_info(bp);
3660
3661         ptp_ocp_serial_info(dev, "GNSS", bp->gnss_port.line,
3662                             bp->gnss_port.baud);
3663         ptp_ocp_serial_info(dev, "GNSS2", bp->gnss2_port.line,
3664                             bp->gnss2_port.baud);
3665         ptp_ocp_serial_info(dev, "MAC", bp->mac_port.line, bp->mac_port.baud);
3666         if (bp->nmea_out && bp->nmea_port.line != -1) {
3667                 bp->nmea_port.baud = -1;
3668
3669                 reg = ioread32(&bp->nmea_out->uart_baud);
3670                 if (reg < ARRAY_SIZE(nmea_baud))
3671                         bp->nmea_port.baud = nmea_baud[reg];
3672
3673                 ptp_ocp_serial_info(dev, "NMEA", bp->nmea_port.line,
3674                                     bp->nmea_port.baud);
3675         }
3676 }
3677
3678 static void
3679 ptp_ocp_detach_sysfs(struct ptp_ocp *bp)
3680 {
3681         struct device *dev = &bp->dev;
3682
3683         sysfs_remove_link(&dev->kobj, "ttyGNSS");
3684         sysfs_remove_link(&dev->kobj, "ttyGNSS2");
3685         sysfs_remove_link(&dev->kobj, "ttyMAC");
3686         sysfs_remove_link(&dev->kobj, "ptp");
3687         sysfs_remove_link(&dev->kobj, "pps");
3688 }
3689
3690 static void
3691 ptp_ocp_detach(struct ptp_ocp *bp)
3692 {
3693         int i;
3694
3695         ptp_ocp_debugfs_remove_device(bp);
3696         ptp_ocp_detach_sysfs(bp);
3697         ptp_ocp_attr_group_del(bp);
3698         if (timer_pending(&bp->watchdog))
3699                 del_timer_sync(&bp->watchdog);
3700         if (bp->ts0)
3701                 ptp_ocp_unregister_ext(bp->ts0);
3702         if (bp->ts1)
3703                 ptp_ocp_unregister_ext(bp->ts1);
3704         if (bp->ts2)
3705                 ptp_ocp_unregister_ext(bp->ts2);
3706         if (bp->ts3)
3707                 ptp_ocp_unregister_ext(bp->ts3);
3708         if (bp->ts4)
3709                 ptp_ocp_unregister_ext(bp->ts4);
3710         if (bp->pps)
3711                 ptp_ocp_unregister_ext(bp->pps);
3712         for (i = 0; i < 4; i++)
3713                 if (bp->signal_out[i])
3714                         ptp_ocp_unregister_ext(bp->signal_out[i]);
3715         if (bp->gnss_port.line != -1)
3716                 serial8250_unregister_port(bp->gnss_port.line);
3717         if (bp->gnss2_port.line != -1)
3718                 serial8250_unregister_port(bp->gnss2_port.line);
3719         if (bp->mac_port.line != -1)
3720                 serial8250_unregister_port(bp->mac_port.line);
3721         if (bp->nmea_port.line != -1)
3722                 serial8250_unregister_port(bp->nmea_port.line);
3723         platform_device_unregister(bp->spi_flash);
3724         platform_device_unregister(bp->i2c_ctrl);
3725         if (bp->i2c_clk)
3726                 clk_hw_unregister_fixed_rate(bp->i2c_clk);
3727         if (bp->n_irqs)
3728                 pci_free_irq_vectors(bp->pdev);
3729         if (bp->ptp)
3730                 ptp_clock_unregister(bp->ptp);
3731         kfree(bp->ptp_info.pin_config);
3732         device_unregister(&bp->dev);
3733 }
3734
3735 static int
3736 ptp_ocp_probe(struct pci_dev *pdev, const struct pci_device_id *id)
3737 {
3738         struct devlink *devlink;
3739         struct ptp_ocp *bp;
3740         int err;
3741
3742         devlink = devlink_alloc(&ptp_ocp_devlink_ops, sizeof(*bp), &pdev->dev);
3743         if (!devlink) {
3744                 dev_err(&pdev->dev, "devlink_alloc failed\n");
3745                 return -ENOMEM;
3746         }
3747
3748         err = pci_enable_device(pdev);
3749         if (err) {
3750                 dev_err(&pdev->dev, "pci_enable_device\n");
3751                 goto out_free;
3752         }
3753
3754         bp = devlink_priv(devlink);
3755         err = ptp_ocp_device_init(bp, pdev);
3756         if (err)
3757                 goto out_disable;
3758
3759         /* compat mode.
3760          * Older FPGA firmware only returns 2 irq's.
3761          * allow this - if not all of the IRQ's are returned, skip the
3762          * extra devices and just register the clock.
3763          */
3764         err = pci_alloc_irq_vectors(pdev, 1, 17, PCI_IRQ_MSI | PCI_IRQ_MSIX);
3765         if (err < 0) {
3766                 dev_err(&pdev->dev, "alloc_irq_vectors err: %d\n", err);
3767                 goto out;
3768         }
3769         bp->n_irqs = err;
3770         pci_set_master(pdev);
3771
3772         err = ptp_ocp_register_resources(bp, id->driver_data);
3773         if (err)
3774                 goto out;
3775
3776         bp->ptp = ptp_clock_register(&bp->ptp_info, &pdev->dev);
3777         if (IS_ERR(bp->ptp)) {
3778                 err = PTR_ERR(bp->ptp);
3779                 dev_err(&pdev->dev, "ptp_clock_register: %d\n", err);
3780                 bp->ptp = NULL;
3781                 goto out;
3782         }
3783
3784         err = ptp_ocp_complete(bp);
3785         if (err)
3786                 goto out;
3787
3788         ptp_ocp_info(bp);
3789         devlink_register(devlink);
3790         return 0;
3791
3792 out:
3793         ptp_ocp_detach(bp);
3794 out_disable:
3795         pci_disable_device(pdev);
3796 out_free:
3797         devlink_free(devlink);
3798         return err;
3799 }
3800
3801 static void
3802 ptp_ocp_remove(struct pci_dev *pdev)
3803 {
3804         struct ptp_ocp *bp = pci_get_drvdata(pdev);
3805         struct devlink *devlink = priv_to_devlink(bp);
3806
3807         devlink_unregister(devlink);
3808         ptp_ocp_detach(bp);
3809         pci_disable_device(pdev);
3810
3811         devlink_free(devlink);
3812 }
3813
3814 static struct pci_driver ptp_ocp_driver = {
3815         .name           = KBUILD_MODNAME,
3816         .id_table       = ptp_ocp_pcidev_id,
3817         .probe          = ptp_ocp_probe,
3818         .remove         = ptp_ocp_remove,
3819 };
3820
3821 static int
3822 ptp_ocp_i2c_notifier_call(struct notifier_block *nb,
3823                           unsigned long action, void *data)
3824 {
3825         struct device *dev, *child = data;
3826         struct ptp_ocp *bp;
3827         bool add;
3828
3829         switch (action) {
3830         case BUS_NOTIFY_ADD_DEVICE:
3831         case BUS_NOTIFY_DEL_DEVICE:
3832                 add = action == BUS_NOTIFY_ADD_DEVICE;
3833                 break;
3834         default:
3835                 return 0;
3836         }
3837
3838         if (!i2c_verify_adapter(child))
3839                 return 0;
3840
3841         dev = child;
3842         while ((dev = dev->parent))
3843                 if (dev->driver && !strcmp(dev->driver->name, KBUILD_MODNAME))
3844                         goto found;
3845         return 0;
3846
3847 found:
3848         bp = dev_get_drvdata(dev);
3849         if (add)
3850                 ptp_ocp_symlink(bp, child, "i2c");
3851         else
3852                 sysfs_remove_link(&bp->dev.kobj, "i2c");
3853
3854         return 0;
3855 }
3856
3857 static struct notifier_block ptp_ocp_i2c_notifier = {
3858         .notifier_call = ptp_ocp_i2c_notifier_call,
3859 };
3860
3861 static int __init
3862 ptp_ocp_init(void)
3863 {
3864         const char *what;
3865         int err;
3866
3867         ptp_ocp_debugfs_init();
3868
3869         what = "timecard class";
3870         err = class_register(&timecard_class);
3871         if (err)
3872                 goto out;
3873
3874         what = "i2c notifier";
3875         err = bus_register_notifier(&i2c_bus_type, &ptp_ocp_i2c_notifier);
3876         if (err)
3877                 goto out_notifier;
3878
3879         what = "ptp_ocp driver";
3880         err = pci_register_driver(&ptp_ocp_driver);
3881         if (err)
3882                 goto out_register;
3883
3884         return 0;
3885
3886 out_register:
3887         bus_unregister_notifier(&i2c_bus_type, &ptp_ocp_i2c_notifier);
3888 out_notifier:
3889         class_unregister(&timecard_class);
3890 out:
3891         ptp_ocp_debugfs_fini();
3892         pr_err(KBUILD_MODNAME ": failed to register %s: %d\n", what, err);
3893         return err;
3894 }
3895
3896 static void __exit
3897 ptp_ocp_fini(void)
3898 {
3899         bus_unregister_notifier(&i2c_bus_type, &ptp_ocp_i2c_notifier);
3900         pci_unregister_driver(&ptp_ocp_driver);
3901         class_unregister(&timecard_class);
3902         ptp_ocp_debugfs_fini();
3903 }
3904
3905 module_init(ptp_ocp_init);
3906 module_exit(ptp_ocp_fini);
3907
3908 MODULE_DESCRIPTION("OpenCompute TimeCard driver");
3909 MODULE_LICENSE("GPL v2");