drivers/fsi/fsi-master-gpio.c

   1 /*
   2  * A FSI master controller, using a simple GPIO bit-banging interface
   3  */
   4
   5 #include <linux/crc4.h>
   6 #include <linux/delay.h>
   7 #include <linux/device.h>
   8 #include <linux/fsi.h>
   9 #include <linux/gpio/consumer.h>
  10 #include <linux/io.h>
  11 #include <linux/module.h>
  12 #include <linux/of.h>
  13 #include <linux/platform_device.h>
  14 #include <linux/slab.h>
  15 #include <linux/spinlock.h>
  16
  17 #include "fsi-master.h"
  18
  19 #define FSI_GPIO_STD_DLY        1       /* Standard pin delay in nS */
  20 #define FSI_ECHO_DELAY_CLOCKS   16      /* Number clocks for echo delay */
  21 #define FSI_PRE_BREAK_CLOCKS    50      /* Number clocks to prep for break */
  22 #define FSI_BREAK_CLOCKS        256     /* Number of clocks to issue break */
  23 #define FSI_POST_BREAK_CLOCKS   16000   /* Number clocks to set up cfam */
  24 #define FSI_INIT_CLOCKS         5000    /* Clock out any old data */
  25 #define FSI_GPIO_STD_DELAY      10      /* Standard GPIO delay in nS */
  26                                         /* todo: adjust down as low as */
  27                                         /* possible or eliminate */
  28 #define FSI_GPIO_CMD_DPOLL      0x2
  29 #define FSI_GPIO_CMD_TERM       0x3f
  30 #define FSI_GPIO_CMD_ABS_AR     0x4
  31
  32 #define FSI_GPIO_DPOLL_CLOCKS   100      /* < 21 will cause slave to hang */
  33
  34 /* Bus errors */
  35 #define FSI_GPIO_ERR_BUSY       1       /* Slave stuck in busy state */
  36 #define FSI_GPIO_RESP_ERRA      2       /* Any (misc) Error */
  37 #define FSI_GPIO_RESP_ERRC      3       /* Slave reports master CRC error */
  38 #define FSI_GPIO_MTOE           4       /* Master time out error */
  39 #define FSI_GPIO_CRC_INVAL      5       /* Master reports slave CRC error */
  40
  41 /* Normal slave responses */
  42 #define FSI_GPIO_RESP_BUSY      1
  43 #define FSI_GPIO_RESP_ACK       0
  44 #define FSI_GPIO_RESP_ACKD      4
  45
  46 #define FSI_GPIO_MAX_BUSY       100
  47 #define FSI_GPIO_MTOE_COUNT     1000
  48 #define FSI_GPIO_DRAIN_BITS     20
  49 #define FSI_GPIO_CRC_SIZE       4
  50 #define FSI_GPIO_MSG_ID_SIZE            2
  51 #define FSI_GPIO_MSG_RESPID_SIZE        2
  52 #define FSI_GPIO_PRIME_SLAVE_CLOCKS     100
  53
  54 struct fsi_master_gpio {
  55         struct fsi_master       master;
  56         struct device           *dev;
  57         spinlock_t              cmd_lock;       /* Lock for commands */
  58         struct gpio_desc        *gpio_clk;
  59         struct gpio_desc        *gpio_data;
  60         struct gpio_desc        *gpio_trans;    /* Voltage translator */
  61         struct gpio_desc        *gpio_enable;   /* FSI enable */
  62         struct gpio_desc        *gpio_mux;      /* Mux control */
  63         bool                    external_mode;
  64 };
  65
  66 #define CREATE_TRACE_POINTS
  67 #include <trace/events/fsi_master_gpio.h>
  68
  69 #define to_fsi_master_gpio(m) container_of(m, struct fsi_master_gpio, master)
  70
  71 struct fsi_gpio_msg {
  72         uint64_t        msg;
  73         uint8_t         bits;
  74 };
  75
  76 static void clock_toggle(struct fsi_master_gpio *master, int count)
  77 {
  78         int i;
  79
  80         for (i = 0; i < count; i++) {
  81                 ndelay(FSI_GPIO_STD_DLY);
  82                 gpiod_set_value(master->gpio_clk, 0);
  83                 ndelay(FSI_GPIO_STD_DLY);
  84                 gpiod_set_value(master->gpio_clk, 1);
  85         }
  86 }
  87
  88 static int sda_in(struct fsi_master_gpio *master)
  89 {
  90         int in;
  91
  92         ndelay(FSI_GPIO_STD_DLY);
  93         in = gpiod_get_value(master->gpio_data);
  94         return in ? 1 : 0;
  95 }
  96
  97 static void sda_out(struct fsi_master_gpio *master, int value)
  98 {
  99         gpiod_set_value(master->gpio_data, value);
 100 }
 101
 102 static void set_sda_input(struct fsi_master_gpio *master)
 103 {
 104         gpiod_direction_input(master->gpio_data);
 105         gpiod_set_value(master->gpio_trans, 0);
 106 }
 107
 108 static void set_sda_output(struct fsi_master_gpio *master, int value)
 109 {
 110         gpiod_set_value(master->gpio_trans, 1);
 111         gpiod_direction_output(master->gpio_data, value);
 112 }
 113
 114 static void clock_zeros(struct fsi_master_gpio *master, int count)
 115 {
 116         set_sda_output(master, 1);
 117         clock_toggle(master, count);
 118 }
 119
 120 static void serial_in(struct fsi_master_gpio *master, struct fsi_gpio_msg *msg,
 121                         uint8_t num_bits)
 122 {
 123         uint8_t bit, in_bit;
 124
 125         set_sda_input(master);
 126
 127         for (bit = 0; bit < num_bits; bit++) {
 128                 clock_toggle(master, 1);
 129                 in_bit = sda_in(master);
 130                 msg->msg <<= 1;
 131                 msg->msg |= ~in_bit & 0x1;      /* Data is active low */
 132         }
 133         msg->bits += num_bits;
 134
 135         trace_fsi_master_gpio_in(master, num_bits, msg->msg);
 136 }
 137
 138 static void serial_out(struct fsi_master_gpio *master,
 139                         const struct fsi_gpio_msg *cmd)
 140 {
 141         uint8_t bit;
 142         uint64_t msg = ~cmd->msg;       /* Data is active low */
 143         uint64_t sda_mask = 0x1ULL << (cmd->bits - 1);
 144         uint64_t last_bit = ~0;
 145         int next_bit;
 146
 147         trace_fsi_master_gpio_out(master, cmd->bits, cmd->msg);
 148
 149         if (!cmd->bits) {
 150                 dev_warn(master->dev, "trying to output 0 bits\n");
 151                 return;
 152         }
 153         set_sda_output(master, 0);
 154
 155         /* Send the start bit */
 156         sda_out(master, 0);
 157         clock_toggle(master, 1);
 158
 159         /* Send the message */
 160         for (bit = 0; bit < cmd->bits; bit++) {
 161                 next_bit = (msg & sda_mask) >> (cmd->bits - 1);
 162                 if (last_bit ^ next_bit) {
 163                         sda_out(master, next_bit);
 164                         last_bit = next_bit;
 165                 }
 166                 clock_toggle(master, 1);
 167                 msg <<= 1;
 168         }
 169 }
 170
 171 static void msg_push_bits(struct fsi_gpio_msg *msg, uint64_t data, int bits)
 172 {
 173         msg->msg <<= bits;
 174         msg->msg |= data & ((1ull << bits) - 1);
 175         msg->bits += bits;
 176 }
 177
 178 static void msg_push_crc(struct fsi_gpio_msg *msg)
 179 {
 180         uint8_t crc;
 181         int top;
 182
 183         top = msg->bits & 0x3;
 184
 185         /* start bit, and any non-aligned top bits */
 186         crc = crc4(0, 1 << top | msg->msg >> (msg->bits - top), top + 1);
 187
 188         /* aligned bits */
 189         crc = crc4(crc, msg->msg, msg->bits - top);
 190
 191         msg_push_bits(msg, crc, 4);
 192 }
 193
 194 /*
 195  * Encode an Absolute Address command
 196  */
 197 static void build_abs_ar_command(struct fsi_gpio_msg *cmd,
 198                 uint8_t id, uint32_t addr, size_t size, const void *data)
 199 {
 200         bool write = !!data;
 201         uint8_t ds;
 202         int i;
 203
 204         cmd->bits = 0;
 205         cmd->msg = 0;
 206
 207         msg_push_bits(cmd, id, 2);
 208         msg_push_bits(cmd, FSI_GPIO_CMD_ABS_AR, 3);
 209         msg_push_bits(cmd, write ? 0 : 1, 1);
 210
 211         /*
 212          * The read/write size is encoded in the lower bits of the address
 213          * (as it must be naturally-aligned), and the following ds bit.
 214          *
 215          *      size    addr:1  addr:0  ds
 216          *      1       x       x       0
 217          *      2       x       0       1
 218          *      4       0       1       1
 219          *
 220          */
 221         ds = size > 1 ? 1 : 0;
 222         addr &= ~(size - 1);
 223         if (size == 4)
 224                 addr |= 1;
 225
 226         msg_push_bits(cmd, addr & ((1 << 21) - 1), 21);
 227         msg_push_bits(cmd, ds, 1);
 228         for (i = 0; write && i < size; i++)
 229                 msg_push_bits(cmd, ((uint8_t *)data)[i], 8);
 230
 231         msg_push_crc(cmd);
 232 }
 233
 234 static void build_dpoll_command(struct fsi_gpio_msg *cmd, uint8_t slave_id)
 235 {
 236         cmd->bits = 0;
 237         cmd->msg = 0;
 238
 239         msg_push_bits(cmd, slave_id, 2);
 240         msg_push_bits(cmd, FSI_GPIO_CMD_DPOLL, 3);
 241         msg_push_crc(cmd);
 242 }
 243
 244 static void echo_delay(struct fsi_master_gpio *master)
 245 {
 246         set_sda_output(master, 1);
 247         clock_toggle(master, FSI_ECHO_DELAY_CLOCKS);
 248 }
 249
 250 static void build_term_command(struct fsi_gpio_msg *cmd, uint8_t slave_id)
 251 {
 252         cmd->bits = 0;
 253         cmd->msg = 0;
 254
 255         msg_push_bits(cmd, slave_id, 2);
 256         msg_push_bits(cmd, FSI_GPIO_CMD_TERM, 6);
 257         msg_push_crc(cmd);
 258 }
 259
 260 /*
 261  * Store information on master errors so handler can detect and clean
 262  * up the bus
 263  */
 264 static void fsi_master_gpio_error(struct fsi_master_gpio *master, int error)
 265 {
 266
 267 }
 268
 269 static int read_one_response(struct fsi_master_gpio *master,
 270                 uint8_t data_size, struct fsi_gpio_msg *msgp, uint8_t *tagp)
 271 {
 272         struct fsi_gpio_msg msg;
 273         uint8_t id, tag;
 274         uint32_t crc;
 275         int i;
 276
 277         /* wait for the start bit */
 278         for (i = 0; i < FSI_GPIO_MTOE_COUNT; i++) {
 279                 msg.bits = 0;
 280                 msg.msg = 0;
 281                 serial_in(master, &msg, 1);
 282                 if (msg.msg)
 283                         break;
 284         }
 285         if (i == FSI_GPIO_MTOE_COUNT) {
 286                 dev_dbg(master->dev,
 287                         "Master time out waiting for response\n");
 288                 fsi_master_gpio_error(master, FSI_GPIO_MTOE);
 289                 return -EIO;
 290         }
 291
 292         msg.bits = 0;
 293         msg.msg = 0;
 294
 295         /* Read slave ID & response tag */
 296         serial_in(master, &msg, 4);
 297
 298         id = (msg.msg >> FSI_GPIO_MSG_RESPID_SIZE) & 0x3;
 299         tag = msg.msg & 0x3;
 300
 301         /* If we have an ACK and we're expecting data, clock the data in too */
 302         if (tag == FSI_GPIO_RESP_ACK && data_size)
 303                 serial_in(master, &msg, data_size * 8);
 304
 305         /* read CRC */
 306         serial_in(master, &msg, FSI_GPIO_CRC_SIZE);
 307
 308         /* we have a whole message now; check CRC */
 309         crc = crc4(0, 1, 1);
 310         crc = crc4(crc, msg.msg, msg.bits);
 311         if (crc) {
 312                 dev_dbg(master->dev, "ERR response CRC\n");
 313                 fsi_master_gpio_error(master, FSI_GPIO_CRC_INVAL);
 314                 return -EIO;
 315         }
 316
 317         if (msgp)
 318                 *msgp = msg;
 319         if (tagp)
 320                 *tagp = tag;
 321
 322         return 0;
 323 }
 324
 325 static int issue_term(struct fsi_master_gpio *master, uint8_t slave)
 326 {
 327         struct fsi_gpio_msg cmd;
 328         uint8_t tag;
 329         int rc;
 330
 331         build_term_command(&cmd, slave);
 332         serial_out(master, &cmd);
 333         echo_delay(master);
 334
 335         rc = read_one_response(master, 0, NULL, &tag);
 336         if (rc < 0) {
 337                 dev_err(master->dev,
 338                                 "TERM failed; lost communication with slave\n");
 339                 return -EIO;
 340         } else if (tag != FSI_GPIO_RESP_ACK) {
 341                 dev_err(master->dev, "TERM failed; response %d\n", tag);
 342                 return -EIO;
 343         }
 344
 345         return 0;
 346 }
 347
 348 static int poll_for_response(struct fsi_master_gpio *master,
 349                 uint8_t slave, uint8_t size, void *data)
 350 {
 351         struct fsi_gpio_msg response, cmd;
 352         int busy_count = 0, rc, i;
 353         uint8_t tag;
 354         uint8_t *data_byte = data;
 355
 356 retry:
 357         rc = read_one_response(master, size, &response, &tag);
 358         if (rc)
 359                 return rc;
 360
 361         switch (tag) {
 362         case FSI_GPIO_RESP_ACK:
 363                 if (size && data) {
 364                         uint64_t val = response.msg;
 365                         /* clear crc & mask */
 366                         val >>= 4;
 367                         val &= (1ull << (size * 8)) - 1;
 368
 369                         for (i = 0; i < size; i++) {
 370                                 data_byte[size-i-1] = val;
 371                                 val >>= 8;
 372                         }
 373                 }
 374                 break;
 375         case FSI_GPIO_RESP_BUSY:
 376                 /*
 377                  * Its necessary to clock slave before issuing
 378                  * d-poll, not indicated in the hardware protocol
 379                  * spec. < 20 clocks causes slave to hang, 21 ok.
 380                  */
 381                 clock_zeros(master, FSI_GPIO_DPOLL_CLOCKS);
 382                 if (busy_count++ < FSI_GPIO_MAX_BUSY) {
 383                         build_dpoll_command(&cmd, slave);
 384                         serial_out(master, &cmd);
 385                         echo_delay(master);
 386                         goto retry;
 387                 }
 388                 dev_warn(master->dev,
 389                         "ERR slave is stuck in busy state, issuing TERM\n");
 390                 issue_term(master, slave);
 391                 rc = -EIO;
 392                 break;
 393
 394         case FSI_GPIO_RESP_ERRA:
 395         case FSI_GPIO_RESP_ERRC:
 396                 dev_dbg(master->dev, "ERR%c received: 0x%x\n",
 397                         tag == FSI_GPIO_RESP_ERRA ? 'A' : 'C',
 398                         (int)response.msg);
 399                 fsi_master_gpio_error(master, response.msg);
 400                 rc = -EIO;
 401                 break;
 402         }
 403
 404         if (busy_count > 0)
 405                 trace_fsi_master_gpio_poll_response_busy(master, busy_count);
 406
 407         /* Clock the slave enough to be ready for next operation */
 408         clock_zeros(master, FSI_GPIO_PRIME_SLAVE_CLOCKS);
 409         return rc;
 410 }
 411
 412 static int fsi_master_gpio_xfer(struct fsi_master_gpio *master, uint8_t slave,
 413                 struct fsi_gpio_msg *cmd, size_t resp_len, void *resp)
 414 {
 415         unsigned long flags;
 416         int rc;
 417
 418         spin_lock_irqsave(&master->cmd_lock, flags);
 419
 420         if (master->external_mode) {
 421                 spin_unlock_irqrestore(&master->cmd_lock, flags);
 422                 return -EBUSY;
 423         }
 424
 425         serial_out(master, cmd);
 426         echo_delay(master);
 427         rc = poll_for_response(master, slave, resp_len, resp);
 428         spin_unlock_irqrestore(&master->cmd_lock, flags);
 429
 430         return rc;
 431 }
 432
 433 static int fsi_master_gpio_read(struct fsi_master *_master, int link,
 434                 uint8_t id, uint32_t addr, void *val, size_t size)
 435 {
 436         struct fsi_master_gpio *master = to_fsi_master_gpio(_master);
 437         struct fsi_gpio_msg cmd;
 438
 439         if (link != 0)
 440                 return -ENODEV;
 441
 442         build_abs_ar_command(&cmd, id, addr, size, NULL);
 443         return fsi_master_gpio_xfer(master, id, &cmd, size, val);
 444 }
 445
 446 static int fsi_master_gpio_write(struct fsi_master *_master, int link,
 447                 uint8_t id, uint32_t addr, const void *val, size_t size)
 448 {
 449         struct fsi_master_gpio *master = to_fsi_master_gpio(_master);
 450         struct fsi_gpio_msg cmd;
 451
 452         if (link != 0)
 453                 return -ENODEV;
 454
 455         build_abs_ar_command(&cmd, id, addr, size, val);
 456         return fsi_master_gpio_xfer(master, id, &cmd, 0, NULL);
 457 }
 458
 459 static int fsi_master_gpio_term(struct fsi_master *_master,
 460                 int link, uint8_t id)
 461 {
 462         struct fsi_master_gpio *master = to_fsi_master_gpio(_master);
 463         struct fsi_gpio_msg cmd;
 464
 465         if (link != 0)
 466                 return -ENODEV;
 467
 468         build_term_command(&cmd, id);
 469         return fsi_master_gpio_xfer(master, id, &cmd, 0, NULL);
 470 }
 471
 472 static int fsi_master_gpio_break(struct fsi_master *_master, int link)
 473 {
 474         struct fsi_master_gpio *master = to_fsi_master_gpio(_master);
 475         unsigned long flags;
 476
 477         if (link != 0)
 478                 return -ENODEV;
 479
 480         trace_fsi_master_gpio_break(master);
 481
 482         spin_lock_irqsave(&master->cmd_lock, flags);
 483         if (master->external_mode) {
 484                 spin_unlock_irqrestore(&master->cmd_lock, flags);
 485                 return -EBUSY;
 486         }
 487         set_sda_output(master, 1);
 488         sda_out(master, 1);
 489         clock_toggle(master, FSI_PRE_BREAK_CLOCKS);
 490         sda_out(master, 0);
 491         clock_toggle(master, FSI_BREAK_CLOCKS);
 492         echo_delay(master);
 493         sda_out(master, 1);
 494         clock_toggle(master, FSI_POST_BREAK_CLOCKS);
 495         spin_unlock_irqrestore(&master->cmd_lock, flags);
 496
 497         /* Wait for logic reset to take effect */
 498         udelay(200);
 499
 500         return 0;
 501 }
 502
 503 static void fsi_master_gpio_init(struct fsi_master_gpio *master)
 504 {
 505         gpiod_direction_output(master->gpio_mux, 1);
 506         gpiod_direction_output(master->gpio_trans, 1);
 507         gpiod_direction_output(master->gpio_enable, 1);
 508         gpiod_direction_output(master->gpio_clk, 1);
 509         gpiod_direction_output(master->gpio_data, 1);
 510
 511         /* todo: evaluate if clocks can be reduced */
 512         clock_zeros(master, FSI_INIT_CLOCKS);
 513 }
 514
 515 static void fsi_master_gpio_init_external(struct fsi_master_gpio *master)
 516 {
 517         gpiod_direction_output(master->gpio_mux, 0);
 518         gpiod_direction_output(master->gpio_trans, 0);
 519         gpiod_direction_output(master->gpio_enable, 1);
 520         gpiod_direction_input(master->gpio_clk);
 521         gpiod_direction_input(master->gpio_data);
 522 }
 523
 524 static int fsi_master_gpio_link_enable(struct fsi_master *_master, int link)
 525 {
 526         struct fsi_master_gpio *master = to_fsi_master_gpio(_master);
 527         unsigned long flags;
 528         int rc = -EBUSY;
 529
 530         if (link != 0)
 531                 return -ENODEV;
 532
 533         spin_lock_irqsave(&master->cmd_lock, flags);
 534         if (!master->external_mode) {
 535                 gpiod_set_value(master->gpio_enable, 1);
 536                 rc = 0;
 537         }
 538         spin_unlock_irqrestore(&master->cmd_lock, flags);
 539
 540         return rc;
 541 }
 542
 543 static ssize_t external_mode_show(struct device *dev,
 544                 struct device_attribute *attr, char *buf)
 545 {
 546         struct fsi_master_gpio *master = dev_get_drvdata(dev);
 547
 548         return snprintf(buf, PAGE_SIZE - 1, "%u\n",
 549                         master->external_mode ? 1 : 0);
 550 }
 551
 552 static ssize_t external_mode_store(struct device *dev,
 553                 struct device_attribute *attr, const char *buf, size_t count)
 554 {
 555         struct fsi_master_gpio *master = dev_get_drvdata(dev);
 556         unsigned long flags, val;
 557         bool external_mode;
 558         int err;
 559
 560         err = kstrtoul(buf, 0, &val);
 561         if (err)
 562                 return err;
 563
 564         external_mode = !!val;
 565
 566         spin_lock_irqsave(&master->cmd_lock, flags);
 567
 568         if (external_mode == master->external_mode) {
 569                 spin_unlock_irqrestore(&master->cmd_lock, flags);
 570                 return count;
 571         }
 572
 573         master->external_mode = external_mode;
 574         if (master->external_mode)
 575                 fsi_master_gpio_init_external(master);
 576         else
 577                 fsi_master_gpio_init(master);
 578         spin_unlock_irqrestore(&master->cmd_lock, flags);
 579
 580         fsi_master_rescan(&master->master);
 581
 582         return count;
 583 }
 584
 585 static DEVICE_ATTR(external_mode, 0664,
 586                 external_mode_show, external_mode_store);
 587
 588 static int fsi_master_gpio_probe(struct platform_device *pdev)
 589 {
 590         struct fsi_master_gpio *master;
 591         struct gpio_desc *gpio;
 592         int rc;
 593
 594         master = devm_kzalloc(&pdev->dev, sizeof(*master), GFP_KERNEL);
 595         if (!master)
 596                 return -ENOMEM;
 597
 598         master->dev = &pdev->dev;
 599         master->master.dev.parent = master->dev;
 600         master->master.dev.of_node = of_node_get(dev_of_node(master->dev));
 601
 602         gpio = devm_gpiod_get(&pdev->dev, "clock", 0);
 603         if (IS_ERR(gpio)) {
 604                 dev_err(&pdev->dev, "failed to get clock gpio\n");
 605                 return PTR_ERR(gpio);
 606         }
 607         master->gpio_clk = gpio;
 608
 609         gpio = devm_gpiod_get(&pdev->dev, "data", 0);
 610         if (IS_ERR(gpio)) {
 611                 dev_err(&pdev->dev, "failed to get data gpio\n");
 612                 return PTR_ERR(gpio);
 613         }
 614         master->gpio_data = gpio;
 615
 616         /* Optional GPIOs */
 617         gpio = devm_gpiod_get_optional(&pdev->dev, "trans", 0);
 618         if (IS_ERR(gpio)) {
 619                 dev_err(&pdev->dev, "failed to get trans gpio\n");
 620                 return PTR_ERR(gpio);
 621         }
 622         master->gpio_trans = gpio;
 623
 624         gpio = devm_gpiod_get_optional(&pdev->dev, "enable", 0);
 625         if (IS_ERR(gpio)) {
 626                 dev_err(&pdev->dev, "failed to get enable gpio\n");
 627                 return PTR_ERR(gpio);
 628         }
 629         master->gpio_enable = gpio;
 630
 631         gpio = devm_gpiod_get_optional(&pdev->dev, "mux", 0);
 632         if (IS_ERR(gpio)) {
 633                 dev_err(&pdev->dev, "failed to get mux gpio\n");
 634                 return PTR_ERR(gpio);
 635         }
 636         master->gpio_mux = gpio;
 637
 638         master->master.n_links = 1;
 639         master->master.flags = FSI_MASTER_FLAG_SWCLOCK;
 640         master->master.read = fsi_master_gpio_read;
 641         master->master.write = fsi_master_gpio_write;
 642         master->master.term = fsi_master_gpio_term;
 643         master->master.send_break = fsi_master_gpio_break;
 644         master->master.link_enable = fsi_master_gpio_link_enable;
 645         platform_set_drvdata(pdev, master);
 646         spin_lock_init(&master->cmd_lock);
 647
 648         fsi_master_gpio_init(master);
 649
 650         rc = device_create_file(&pdev->dev, &dev_attr_external_mode);
 651         if (rc)
 652                 return rc;
 653
 654         return fsi_master_register(&master->master);
 655 }
 656
 657
 658 static int fsi_master_gpio_remove(struct platform_device *pdev)
 659 {
 660         struct fsi_master_gpio *master = platform_get_drvdata(pdev);
 661
 662         devm_gpiod_put(&pdev->dev, master->gpio_clk);
 663         devm_gpiod_put(&pdev->dev, master->gpio_data);
 664         if (master->gpio_trans)
 665                 devm_gpiod_put(&pdev->dev, master->gpio_trans);
 666         if (master->gpio_enable)
 667                 devm_gpiod_put(&pdev->dev, master->gpio_enable);
 668         if (master->gpio_mux)
 669                 devm_gpiod_put(&pdev->dev, master->gpio_mux);
 670         fsi_master_unregister(&master->master);
 671
 672         of_node_put(master->master.dev.of_node);
 673
 674         return 0;
 675 }
 676
 677 static const struct of_device_id fsi_master_gpio_match[] = {
 678         { .compatible = "fsi-master-gpio" },
 679         { },
 680 };
 681
 682 static struct platform_driver fsi_master_gpio_driver = {
 683         .driver = {
 684                 .name           = "fsi-master-gpio",
 685                 .of_match_table = fsi_master_gpio_match,
 686         },
 687         .probe  = fsi_master_gpio_probe,
 688         .remove = fsi_master_gpio_remove,
 689 };
 690
 691 module_platform_driver(fsi_master_gpio_driver);
 692 MODULE_LICENSE("GPL");