drivers/soundwire/bus.c

   1 // SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause)
   2 // Copyright(c) 2015-17 Intel Corporation.
   3
   4 #include <linux/acpi.h>
   5 #include <linux/mod_devicetable.h>
   6 #include <linux/pm_runtime.h>
   7 #include <linux/soundwire/sdw_registers.h>
   8 #include <linux/soundwire/sdw.h>
   9 #include "bus.h"
  10
  11 /**
  12  * sdw_add_bus_master() - add a bus Master instance
  13  * @bus: bus instance
  14  *
  15  * Initializes the bus instance, read properties and create child
  16  * devices.
  17  */
  18 int sdw_add_bus_master(struct sdw_bus *bus)
  19 {
  20         struct sdw_master_prop *prop = NULL;
  21         int ret;
  22
  23         if (!bus->dev) {
  24                 pr_err("SoundWire bus has no device\n");
  25                 return -ENODEV;
  26         }
  27
  28         if (!bus->ops) {
  29                 dev_err(bus->dev, "SoundWire Bus ops are not set\n");
  30                 return -EINVAL;
  31         }
  32
  33         mutex_init(&bus->msg_lock);
  34         mutex_init(&bus->bus_lock);
  35         INIT_LIST_HEAD(&bus->slaves);
  36         INIT_LIST_HEAD(&bus->m_rt_list);
  37
  38         /*
  39          * Initialize multi_link flag
  40          * TODO: populate this flag by reading property from FW node
  41          */
  42         bus->multi_link = false;
  43         if (bus->ops->read_prop) {
  44                 ret = bus->ops->read_prop(bus);
  45                 if (ret < 0) {
  46                         dev_err(bus->dev,
  47                                 "Bus read properties failed:%d\n", ret);
  48                         return ret;
  49                 }
  50         }
  51
  52         sdw_bus_debugfs_init(bus);
  53
  54         /*
  55          * Device numbers in SoundWire are 0 through 15. Enumeration device
  56          * number (0), Broadcast device number (15), Group numbers (12 and
  57          * 13) and Master device number (14) are not used for assignment so
  58          * mask these and other higher bits.
  59          */
  60
  61         /* Set higher order bits */
  62         *bus->assigned = ~GENMASK(SDW_BROADCAST_DEV_NUM, SDW_ENUM_DEV_NUM);
  63
  64         /* Set enumuration device number and broadcast device number */
  65         set_bit(SDW_ENUM_DEV_NUM, bus->assigned);
  66         set_bit(SDW_BROADCAST_DEV_NUM, bus->assigned);
  67
  68         /* Set group device numbers and master device number */
  69         set_bit(SDW_GROUP12_DEV_NUM, bus->assigned);
  70         set_bit(SDW_GROUP13_DEV_NUM, bus->assigned);
  71         set_bit(SDW_MASTER_DEV_NUM, bus->assigned);
  72
  73         /*
  74          * SDW is an enumerable bus, but devices can be powered off. So,
  75          * they won't be able to report as present.
  76          *
  77          * Create Slave devices based on Slaves described in
  78          * the respective firmware (ACPI/DT)
  79          */
  80         if (IS_ENABLED(CONFIG_ACPI) && ACPI_HANDLE(bus->dev))
  81                 ret = sdw_acpi_find_slaves(bus);
  82         else if (IS_ENABLED(CONFIG_OF) && bus->dev->of_node)
  83                 ret = sdw_of_find_slaves(bus);
  84         else
  85                 ret = -ENOTSUPP; /* No ACPI/DT so error out */
  86
  87         if (ret) {
  88                 dev_err(bus->dev, "Finding slaves failed:%d\n", ret);
  89                 return ret;
  90         }
  91
  92         /*
  93          * Initialize clock values based on Master properties. The max
  94          * frequency is read from max_clk_freq property. Current assumption
  95          * is that the bus will start at highest clock frequency when
  96          * powered on.
  97          *
  98          * Default active bank will be 0 as out of reset the Slaves have
  99          * to start with bank 0 (Table 40 of Spec)
 100          */
 101         prop = &bus->prop;
 102         bus->params.max_dr_freq = prop->max_clk_freq * SDW_DOUBLE_RATE_FACTOR;
 103         bus->params.curr_dr_freq = bus->params.max_dr_freq;
 104         bus->params.curr_bank = SDW_BANK0;
 105         bus->params.next_bank = SDW_BANK1;
 106
 107         return 0;
 108 }
 109 EXPORT_SYMBOL(sdw_add_bus_master);
 110
 111 static int sdw_delete_slave(struct device *dev, void *data)
 112 {
 113         struct sdw_slave *slave = dev_to_sdw_dev(dev);
 114         struct sdw_bus *bus = slave->bus;
 115
 116         pm_runtime_disable(dev);
 117
 118         sdw_slave_debugfs_exit(slave);
 119
 120         mutex_lock(&bus->bus_lock);
 121
 122         if (slave->dev_num) /* clear dev_num if assigned */
 123                 clear_bit(slave->dev_num, bus->assigned);
 124
 125         list_del_init(&slave->node);
 126         mutex_unlock(&bus->bus_lock);
 127
 128         device_unregister(dev);
 129         return 0;
 130 }
 131
 132 /**
 133  * sdw_delete_bus_master() - delete the bus master instance
 134  * @bus: bus to be deleted
 135  *
 136  * Remove the instance, delete the child devices.
 137  */
 138 void sdw_delete_bus_master(struct sdw_bus *bus)
 139 {
 140         device_for_each_child(bus->dev, NULL, sdw_delete_slave);
 141
 142         sdw_bus_debugfs_exit(bus);
 143 }
 144 EXPORT_SYMBOL(sdw_delete_bus_master);
 145
 146 /*
 147  * SDW IO Calls
 148  */
 149
 150 static inline int find_response_code(enum sdw_command_response resp)
 151 {
 152         switch (resp) {
 153         case SDW_CMD_OK:
 154                 return 0;
 155
 156         case SDW_CMD_IGNORED:
 157                 return -ENODATA;
 158
 159         case SDW_CMD_TIMEOUT:
 160                 return -ETIMEDOUT;
 161
 162         default:
 163                 return -EIO;
 164         }
 165 }
 166
 167 static inline int do_transfer(struct sdw_bus *bus, struct sdw_msg *msg)
 168 {
 169         int retry = bus->prop.err_threshold;
 170         enum sdw_command_response resp;
 171         int ret = 0, i;
 172
 173         for (i = 0; i <= retry; i++) {
 174                 resp = bus->ops->xfer_msg(bus, msg);
 175                 ret = find_response_code(resp);
 176
 177                 /* if cmd is ok or ignored return */
 178                 if (ret == 0 || ret == -ENODATA)
 179                         return ret;
 180         }
 181
 182         return ret;
 183 }
 184
 185 static inline int do_transfer_defer(struct sdw_bus *bus,
 186                                     struct sdw_msg *msg,
 187                                     struct sdw_defer *defer)
 188 {
 189         int retry = bus->prop.err_threshold;
 190         enum sdw_command_response resp;
 191         int ret = 0, i;
 192
 193         defer->msg = msg;
 194         defer->length = msg->len;
 195         init_completion(&defer->complete);
 196
 197         for (i = 0; i <= retry; i++) {
 198                 resp = bus->ops->xfer_msg_defer(bus, msg, defer);
 199                 ret = find_response_code(resp);
 200                 /* if cmd is ok or ignored return */
 201                 if (ret == 0 || ret == -ENODATA)
 202                         return ret;
 203         }
 204
 205         return ret;
 206 }
 207
 208 static int sdw_reset_page(struct sdw_bus *bus, u16 dev_num)
 209 {
 210         int retry = bus->prop.err_threshold;
 211         enum sdw_command_response resp;
 212         int ret = 0, i;
 213
 214         for (i = 0; i <= retry; i++) {
 215                 resp = bus->ops->reset_page_addr(bus, dev_num);
 216                 ret = find_response_code(resp);
 217                 /* if cmd is ok or ignored return */
 218                 if (ret == 0 || ret == -ENODATA)
 219                         return ret;
 220         }
 221
 222         return ret;
 223 }
 224
 225 /**
 226  * sdw_transfer() - Synchronous transfer message to a SDW Slave device
 227  * @bus: SDW bus
 228  * @msg: SDW message to be xfered
 229  */
 230 int sdw_transfer(struct sdw_bus *bus, struct sdw_msg *msg)
 231 {
 232         int ret;
 233
 234         mutex_lock(&bus->msg_lock);
 235
 236         ret = do_transfer(bus, msg);
 237         if (ret != 0 && ret != -ENODATA)
 238                 dev_err(bus->dev, "trf on Slave %d failed:%d\n",
 239                         msg->dev_num, ret);
 240
 241         if (msg->page)
 242                 sdw_reset_page(bus, msg->dev_num);
 243
 244         mutex_unlock(&bus->msg_lock);
 245
 246         return ret;
 247 }
 248
 249 /**
 250  * sdw_transfer_defer() - Asynchronously transfer message to a SDW Slave device
 251  * @bus: SDW bus
 252  * @msg: SDW message to be xfered
 253  * @defer: Defer block for signal completion
 254  *
 255  * Caller needs to hold the msg_lock lock while calling this
 256  */
 257 int sdw_transfer_defer(struct sdw_bus *bus, struct sdw_msg *msg,
 258                        struct sdw_defer *defer)
 259 {
 260         int ret;
 261
 262         if (!bus->ops->xfer_msg_defer)
 263                 return -ENOTSUPP;
 264
 265         ret = do_transfer_defer(bus, msg, defer);
 266         if (ret != 0 && ret != -ENODATA)
 267                 dev_err(bus->dev, "Defer trf on Slave %d failed:%d\n",
 268                         msg->dev_num, ret);
 269
 270         if (msg->page)
 271                 sdw_reset_page(bus, msg->dev_num);
 272
 273         return ret;
 274 }
 275
 276 int sdw_fill_msg(struct sdw_msg *msg, struct sdw_slave *slave,
 277                  u32 addr, size_t count, u16 dev_num, u8 flags, u8 *buf)
 278 {
 279         memset(msg, 0, sizeof(*msg));
 280         msg->addr = addr; /* addr is 16 bit and truncated here */
 281         msg->len = count;
 282         msg->dev_num = dev_num;
 283         msg->flags = flags;
 284         msg->buf = buf;
 285
 286         if (addr < SDW_REG_NO_PAGE) { /* no paging area */
 287                 return 0;
 288         } else if (addr >= SDW_REG_MAX) { /* illegal addr */
 289                 pr_err("SDW: Invalid address %x passed\n", addr);
 290                 return -EINVAL;
 291         }
 292
 293         if (addr < SDW_REG_OPTIONAL_PAGE) { /* 32k but no page */
 294                 if (slave && !slave->prop.paging_support)
 295                         return 0;
 296                 /* no need for else as that will fall-through to paging */
 297         }
 298
 299         /* paging mandatory */
 300         if (dev_num == SDW_ENUM_DEV_NUM || dev_num == SDW_BROADCAST_DEV_NUM) {
 301                 pr_err("SDW: Invalid device for paging :%d\n", dev_num);
 302                 return -EINVAL;
 303         }
 304
 305         if (!slave) {
 306                 pr_err("SDW: No slave for paging addr\n");
 307                 return -EINVAL;
 308         } else if (!slave->prop.paging_support) {
 309                 dev_err(&slave->dev,
 310                         "address %x needs paging but no support\n", addr);
 311                 return -EINVAL;
 312         }
 313
 314         msg->addr_page1 = (addr >> SDW_REG_SHIFT(SDW_SCP_ADDRPAGE1_MASK));
 315         msg->addr_page2 = (addr >> SDW_REG_SHIFT(SDW_SCP_ADDRPAGE2_MASK));
 316         msg->addr |= BIT(15);
 317         msg->page = true;
 318
 319         return 0;
 320 }
 321
 322 /**
 323  * sdw_nread() - Read "n" contiguous SDW Slave registers
 324  * @slave: SDW Slave
 325  * @addr: Register address
 326  * @count: length
 327  * @val: Buffer for values to be read
 328  */
 329 int sdw_nread(struct sdw_slave *slave, u32 addr, size_t count, u8 *val)
 330 {
 331         struct sdw_msg msg;
 332         int ret;
 333
 334         ret = sdw_fill_msg(&msg, slave, addr, count,
 335                            slave->dev_num, SDW_MSG_FLAG_READ, val);
 336         if (ret < 0)
 337                 return ret;
 338
 339         ret = pm_runtime_get_sync(slave->bus->dev);
 340         if (ret < 0)
 341                 return ret;
 342
 343         ret = sdw_transfer(slave->bus, &msg);
 344         pm_runtime_put(slave->bus->dev);
 345
 346         return ret;
 347 }
 348 EXPORT_SYMBOL(sdw_nread);
 349
 350 /**
 351  * sdw_nwrite() - Write "n" contiguous SDW Slave registers
 352  * @slave: SDW Slave
 353  * @addr: Register address
 354  * @count: length
 355  * @val: Buffer for values to be read
 356  */
 357 int sdw_nwrite(struct sdw_slave *slave, u32 addr, size_t count, u8 *val)
 358 {
 359         struct sdw_msg msg;
 360         int ret;
 361
 362         ret = sdw_fill_msg(&msg, slave, addr, count,
 363                            slave->dev_num, SDW_MSG_FLAG_WRITE, val);
 364         if (ret < 0)
 365                 return ret;
 366
 367         ret = pm_runtime_get_sync(slave->bus->dev);
 368         if (ret < 0)
 369                 return ret;
 370
 371         ret = sdw_transfer(slave->bus, &msg);
 372         pm_runtime_put(slave->bus->dev);
 373
 374         return ret;
 375 }
 376 EXPORT_SYMBOL(sdw_nwrite);
 377
 378 /**
 379  * sdw_read() - Read a SDW Slave register
 380  * @slave: SDW Slave
 381  * @addr: Register address
 382  */
 383 int sdw_read(struct sdw_slave *slave, u32 addr)
 384 {
 385         u8 buf;
 386         int ret;
 387
 388         ret = sdw_nread(slave, addr, 1, &buf);
 389         if (ret < 0)
 390                 return ret;
 391         else
 392                 return buf;
 393 }
 394 EXPORT_SYMBOL(sdw_read);
 395
 396 /**
 397  * sdw_write() - Write a SDW Slave register
 398  * @slave: SDW Slave
 399  * @addr: Register address
 400  * @value: Register value
 401  */
 402 int sdw_write(struct sdw_slave *slave, u32 addr, u8 value)
 403 {
 404         return sdw_nwrite(slave, addr, 1, &value);
 405 }
 406 EXPORT_SYMBOL(sdw_write);
 407
 408 /*
 409  * SDW alert handling
 410  */
 411
 412 /* called with bus_lock held */
 413 static struct sdw_slave *sdw_get_slave(struct sdw_bus *bus, int i)
 414 {
 415         struct sdw_slave *slave = NULL;
 416
 417         list_for_each_entry(slave, &bus->slaves, node) {
 418                 if (slave->dev_num == i)
 419                         return slave;
 420         }
 421
 422         return NULL;
 423 }
 424
 425 static int sdw_compare_devid(struct sdw_slave *slave, struct sdw_slave_id id)
 426 {
 427         if (slave->id.unique_id != id.unique_id ||
 428             slave->id.mfg_id != id.mfg_id ||
 429             slave->id.part_id != id.part_id ||
 430             slave->id.class_id != id.class_id)
 431                 return -ENODEV;
 432
 433         return 0;
 434 }
 435
 436 /* called with bus_lock held */
 437 static int sdw_get_device_num(struct sdw_slave *slave)
 438 {
 439         int bit;
 440
 441         bit = find_first_zero_bit(slave->bus->assigned, SDW_MAX_DEVICES);
 442         if (bit == SDW_MAX_DEVICES) {
 443                 bit = -ENODEV;
 444                 goto err;
 445         }
 446
 447         /*
 448          * Do not update dev_num in Slave data structure here,
 449          * Update once program dev_num is successful
 450          */
 451         set_bit(bit, slave->bus->assigned);
 452
 453 err:
 454         return bit;
 455 }
 456
 457 static int sdw_assign_device_num(struct sdw_slave *slave)
 458 {
 459         int ret, dev_num;
 460
 461         /* check first if device number is assigned, if so reuse that */
 462         if (!slave->dev_num) {
 463                 mutex_lock(&slave->bus->bus_lock);
 464                 dev_num = sdw_get_device_num(slave);
 465                 mutex_unlock(&slave->bus->bus_lock);
 466                 if (dev_num < 0) {
 467                         dev_err(slave->bus->dev, "Get dev_num failed: %d\n",
 468                                 dev_num);
 469                         return dev_num;
 470                 }
 471         } else {
 472                 dev_info(slave->bus->dev,
 473                          "Slave already registered dev_num:%d\n",
 474                          slave->dev_num);
 475
 476                 /* Clear the slave->dev_num to transfer message on device 0 */
 477                 dev_num = slave->dev_num;
 478                 slave->dev_num = 0;
 479         }
 480
 481         ret = sdw_write(slave, SDW_SCP_DEVNUMBER, dev_num);
 482         if (ret < 0) {
 483                 dev_err(&slave->dev, "Program device_num %d failed: %d\n",
 484                         dev_num, ret);
 485                 return ret;
 486         }
 487
 488         /* After xfer of msg, restore dev_num */
 489         slave->dev_num = dev_num;
 490
 491         return 0;
 492 }
 493
 494 void sdw_extract_slave_id(struct sdw_bus *bus,
 495                           u64 addr, struct sdw_slave_id *id)
 496 {
 497         dev_dbg(bus->dev, "SDW Slave Addr: %llx\n", addr);
 498
 499         /*
 500          * Spec definition
 501          *   Register           Bit     Contents
 502          *   DevId_0 [7:4]      47:44   sdw_version
 503          *   DevId_0 [3:0]      43:40   unique_id
 504          *   DevId_1            39:32   mfg_id [15:8]
 505          *   DevId_2            31:24   mfg_id [7:0]
 506          *   DevId_3            23:16   part_id [15:8]
 507          *   DevId_4            15:08   part_id [7:0]
 508          *   DevId_5            07:00   class_id
 509          */
 510         id->sdw_version = (addr >> 44) & GENMASK(3, 0);
 511         id->unique_id = (addr >> 40) & GENMASK(3, 0);
 512         id->mfg_id = (addr >> 24) & GENMASK(15, 0);
 513         id->part_id = (addr >> 8) & GENMASK(15, 0);
 514         id->class_id = addr & GENMASK(7, 0);
 515
 516         dev_dbg(bus->dev,
 517                 "SDW Slave class_id %x, part_id %x, mfg_id %x, unique_id %x, version %x\n",
 518                                 id->class_id, id->part_id, id->mfg_id,
 519                                 id->unique_id, id->sdw_version);
 520 }
 521
 522 static int sdw_program_device_num(struct sdw_bus *bus)
 523 {
 524         u8 buf[SDW_NUM_DEV_ID_REGISTERS] = {0};
 525         struct sdw_slave *slave, *_s;
 526         struct sdw_slave_id id;
 527         struct sdw_msg msg;
 528         bool found;
 529         int count = 0, ret;
 530         u64 addr;
 531
 532         /* No Slave, so use raw xfer api */
 533         ret = sdw_fill_msg(&msg, NULL, SDW_SCP_DEVID_0,
 534                            SDW_NUM_DEV_ID_REGISTERS, 0, SDW_MSG_FLAG_READ, buf);
 535         if (ret < 0)
 536                 return ret;
 537
 538         do {
 539                 ret = sdw_transfer(bus, &msg);
 540                 if (ret == -ENODATA) { /* end of device id reads */
 541                         dev_dbg(bus->dev, "No more devices to enumerate\n");
 542                         ret = 0;
 543                         break;
 544                 }
 545                 if (ret < 0) {
 546                         dev_err(bus->dev, "DEVID read fail:%d\n", ret);
 547                         break;
 548                 }
 549
 550                 /*
 551                  * Construct the addr and extract. Cast the higher shift
 552                  * bits to avoid truncation due to size limit.
 553                  */
 554                 addr = buf[5] | (buf[4] << 8) | (buf[3] << 16) |
 555                         ((u64)buf[2] << 24) | ((u64)buf[1] << 32) |
 556                         ((u64)buf[0] << 40);
 557
 558                 sdw_extract_slave_id(bus, addr, &id);
 559
 560                 found = false;
 561                 /* Now compare with entries */
 562                 list_for_each_entry_safe(slave, _s, &bus->slaves, node) {
 563                         if (sdw_compare_devid(slave, id) == 0) {
 564                                 found = true;
 565
 566                                 /*
 567                                  * Assign a new dev_num to this Slave and
 568                                  * not mark it present. It will be marked
 569                                  * present after it reports ATTACHED on new
 570                                  * dev_num
 571                                  */
 572                                 ret = sdw_assign_device_num(slave);
 573                                 if (ret) {
 574                                         dev_err(slave->bus->dev,
 575                                                 "Assign dev_num failed:%d\n",
 576                                                 ret);
 577                                         return ret;
 578                                 }
 579
 580                                 break;
 581                         }
 582                 }
 583
 584                 if (!found) {
 585                         /* TODO: Park this device in Group 13 */
 586                         dev_err(bus->dev, "Slave Entry not found\n");
 587                 }
 588
 589                 count++;
 590
 591                 /*
 592                  * Check till error out or retry (count) exhausts.
 593                  * Device can drop off and rejoin during enumeration
 594                  * so count till twice the bound.
 595                  */
 596
 597         } while (ret == 0 && count < (SDW_MAX_DEVICES * 2));
 598
 599         return ret;
 600 }
 601
 602 static void sdw_modify_slave_status(struct sdw_slave *slave,
 603                                     enum sdw_slave_status status)
 604 {
 605         mutex_lock(&slave->bus->bus_lock);
 606         slave->status = status;
 607         mutex_unlock(&slave->bus->bus_lock);
 608 }
 609
 610 int sdw_configure_dpn_intr(struct sdw_slave *slave,
 611                            int port, bool enable, int mask)
 612 {
 613         u32 addr;
 614         int ret;
 615         u8 val = 0;
 616
 617         addr = SDW_DPN_INTMASK(port);
 618
 619         /* Set/Clear port ready interrupt mask */
 620         if (enable) {
 621                 val |= mask;
 622                 val |= SDW_DPN_INT_PORT_READY;
 623         } else {
 624                 val &= ~(mask);
 625                 val &= ~SDW_DPN_INT_PORT_READY;
 626         }
 627
 628         ret = sdw_update(slave, addr, (mask | SDW_DPN_INT_PORT_READY), val);
 629         if (ret < 0)
 630                 dev_err(slave->bus->dev,
 631                         "SDW_DPN_INTMASK write failed:%d\n", val);
 632
 633         return ret;
 634 }
 635
 636 static int sdw_initialize_slave(struct sdw_slave *slave)
 637 {
 638         struct sdw_slave_prop *prop = &slave->prop;
 639         int ret;
 640         u8 val;
 641
 642         /*
 643          * Set bus clash, parity and SCP implementation
 644          * defined interrupt mask
 645          * TODO: Read implementation defined interrupt mask
 646          * from Slave property
 647          */
 648         val = SDW_SCP_INT1_IMPL_DEF | SDW_SCP_INT1_BUS_CLASH |
 649                                         SDW_SCP_INT1_PARITY;
 650
 651         /* Enable SCP interrupts */
 652         ret = sdw_update(slave, SDW_SCP_INTMASK1, val, val);
 653         if (ret < 0) {
 654                 dev_err(slave->bus->dev,
 655                         "SDW_SCP_INTMASK1 write failed:%d\n", ret);
 656                 return ret;
 657         }
 658
 659         /* No need to continue if DP0 is not present */
 660         if (!slave->prop.dp0_prop)
 661                 return 0;
 662
 663         /* Enable DP0 interrupts */
 664         val = prop->dp0_prop->imp_def_interrupts;
 665         val |= SDW_DP0_INT_PORT_READY | SDW_DP0_INT_BRA_FAILURE;
 666
 667         ret = sdw_update(slave, SDW_DP0_INTMASK, val, val);
 668         if (ret < 0) {
 669                 dev_err(slave->bus->dev,
 670                         "SDW_DP0_INTMASK read failed:%d\n", ret);
 671                 return val;
 672         }
 673
 674         return 0;
 675 }
 676
 677 static int sdw_handle_dp0_interrupt(struct sdw_slave *slave, u8 *slave_status)
 678 {
 679         u8 clear = 0, impl_int_mask;
 680         int status, status2, ret, count = 0;
 681
 682         status = sdw_read(slave, SDW_DP0_INT);
 683         if (status < 0) {
 684                 dev_err(slave->bus->dev,
 685                         "SDW_DP0_INT read failed:%d\n", status);
 686                 return status;
 687         }
 688
 689         do {
 690                 if (status & SDW_DP0_INT_TEST_FAIL) {
 691                         dev_err(&slave->dev, "Test fail for port 0\n");
 692                         clear |= SDW_DP0_INT_TEST_FAIL;
 693                 }
 694
 695                 /*
 696                  * Assumption: PORT_READY interrupt will be received only for
 697                  * ports implementing Channel Prepare state machine (CP_SM)
 698                  */
 699
 700                 if (status & SDW_DP0_INT_PORT_READY) {
 701                         complete(&slave->port_ready[0]);
 702                         clear |= SDW_DP0_INT_PORT_READY;
 703                 }
 704
 705                 if (status & SDW_DP0_INT_BRA_FAILURE) {
 706                         dev_err(&slave->dev, "BRA failed\n");
 707                         clear |= SDW_DP0_INT_BRA_FAILURE;
 708                 }
 709
 710                 impl_int_mask = SDW_DP0_INT_IMPDEF1 |
 711                         SDW_DP0_INT_IMPDEF2 | SDW_DP0_INT_IMPDEF3;
 712
 713                 if (status & impl_int_mask) {
 714                         clear |= impl_int_mask;
 715                         *slave_status = clear;
 716                 }
 717
 718                 /* clear the interrupt */
 719                 ret = sdw_write(slave, SDW_DP0_INT, clear);
 720                 if (ret < 0) {
 721                         dev_err(slave->bus->dev,
 722                                 "SDW_DP0_INT write failed:%d\n", ret);
 723                         return ret;
 724                 }
 725
 726                 /* Read DP0 interrupt again */
 727                 status2 = sdw_read(slave, SDW_DP0_INT);
 728                 if (status2 < 0) {
 729                         dev_err(slave->bus->dev,
 730                                 "SDW_DP0_INT read failed:%d\n", status2);
 731                         return status2;
 732                 }
 733                 status &= status2;
 734
 735                 count++;
 736
 737                 /* we can get alerts while processing so keep retrying */
 738         } while (status != 0 && count < SDW_READ_INTR_CLEAR_RETRY);
 739
 740         if (count == SDW_READ_INTR_CLEAR_RETRY)
 741                 dev_warn(slave->bus->dev, "Reached MAX_RETRY on DP0 read\n");
 742
 743         return ret;
 744 }
 745
 746 static int sdw_handle_port_interrupt(struct sdw_slave *slave,
 747                                      int port, u8 *slave_status)
 748 {
 749         u8 clear = 0, impl_int_mask;
 750         int status, status2, ret, count = 0;
 751         u32 addr;
 752
 753         if (port == 0)
 754                 return sdw_handle_dp0_interrupt(slave, slave_status);
 755
 756         addr = SDW_DPN_INT(port);
 757         status = sdw_read(slave, addr);
 758         if (status < 0) {
 759                 dev_err(slave->bus->dev,
 760                         "SDW_DPN_INT read failed:%d\n", status);
 761
 762                 return status;
 763         }
 764
 765         do {
 766                 if (status & SDW_DPN_INT_TEST_FAIL) {
 767                         dev_err(&slave->dev, "Test fail for port:%d\n", port);
 768                         clear |= SDW_DPN_INT_TEST_FAIL;
 769                 }
 770
 771                 /*
 772                  * Assumption: PORT_READY interrupt will be received only
 773                  * for ports implementing CP_SM.
 774                  */
 775                 if (status & SDW_DPN_INT_PORT_READY) {
 776                         complete(&slave->port_ready[port]);
 777                         clear |= SDW_DPN_INT_PORT_READY;
 778                 }
 779
 780                 impl_int_mask = SDW_DPN_INT_IMPDEF1 |
 781                         SDW_DPN_INT_IMPDEF2 | SDW_DPN_INT_IMPDEF3;
 782
 783                 if (status & impl_int_mask) {
 784                         clear |= impl_int_mask;
 785                         *slave_status = clear;
 786                 }
 787
 788                 /* clear the interrupt */
 789                 ret = sdw_write(slave, addr, clear);
 790                 if (ret < 0) {
 791                         dev_err(slave->bus->dev,
 792                                 "SDW_DPN_INT write failed:%d\n", ret);
 793                         return ret;
 794                 }
 795
 796                 /* Read DPN interrupt again */
 797                 status2 = sdw_read(slave, addr);
 798                 if (status2 < 0) {
 799                         dev_err(slave->bus->dev,
 800                                 "SDW_DPN_INT read failed:%d\n", status2);
 801                         return status2;
 802                 }
 803                 status &= status2;
 804
 805                 count++;
 806
 807                 /* we can get alerts while processing so keep retrying */
 808         } while (status != 0 && count < SDW_READ_INTR_CLEAR_RETRY);
 809
 810         if (count == SDW_READ_INTR_CLEAR_RETRY)
 811                 dev_warn(slave->bus->dev, "Reached MAX_RETRY on port read");
 812
 813         return ret;
 814 }
 815
 816 static int sdw_handle_slave_alerts(struct sdw_slave *slave)
 817 {
 818         struct sdw_slave_intr_status slave_intr;
 819         u8 clear = 0, bit, port_status[15] = {0};
 820         int port_num, stat, ret, count = 0;
 821         unsigned long port;
 822         bool slave_notify = false;
 823         u8 buf, buf2[2], _buf, _buf2[2];
 824
 825         sdw_modify_slave_status(slave, SDW_SLAVE_ALERT);
 826
 827         /* Read Instat 1, Instat 2 and Instat 3 registers */
 828         ret = sdw_read(slave, SDW_SCP_INT1);
 829         if (ret < 0) {
 830                 dev_err(slave->bus->dev,
 831                         "SDW_SCP_INT1 read failed:%d\n", ret);
 832                 return ret;
 833         }
 834         buf = ret;
 835
 836         ret = sdw_nread(slave, SDW_SCP_INTSTAT2, 2, buf2);
 837         if (ret < 0) {
 838                 dev_err(slave->bus->dev,
 839                         "SDW_SCP_INT2/3 read failed:%d\n", ret);
 840                 return ret;
 841         }
 842
 843         do {
 844                 /*
 845                  * Check parity, bus clash and Slave (impl defined)
 846                  * interrupt
 847                  */
 848                 if (buf & SDW_SCP_INT1_PARITY) {
 849                         dev_err(&slave->dev, "Parity error detected\n");
 850                         clear |= SDW_SCP_INT1_PARITY;
 851                 }
 852
 853                 if (buf & SDW_SCP_INT1_BUS_CLASH) {
 854                         dev_err(&slave->dev, "Bus clash error detected\n");
 855                         clear |= SDW_SCP_INT1_BUS_CLASH;
 856                 }
 857
 858                 /*
 859                  * When bus clash or parity errors are detected, such errors
 860                  * are unlikely to be recoverable errors.
 861                  * TODO: In such scenario, reset bus. Make this configurable
 862                  * via sysfs property with bus reset being the default.
 863                  */
 864
 865                 if (buf & SDW_SCP_INT1_IMPL_DEF) {
 866                         dev_dbg(&slave->dev, "Slave impl defined interrupt\n");
 867                         clear |= SDW_SCP_INT1_IMPL_DEF;
 868                         slave_notify = true;
 869                 }
 870
 871                 /* Check port 0 - 3 interrupts */
 872                 port = buf & SDW_SCP_INT1_PORT0_3;
 873
 874                 /* To get port number corresponding to bits, shift it */
 875                 port = port >> SDW_REG_SHIFT(SDW_SCP_INT1_PORT0_3);
 876                 for_each_set_bit(bit, &port, 8) {
 877                         sdw_handle_port_interrupt(slave, bit,
 878                                                   &port_status[bit]);
 879                 }
 880
 881                 /* Check if cascade 2 interrupt is present */
 882                 if (buf & SDW_SCP_INT1_SCP2_CASCADE) {
 883                         port = buf2[0] & SDW_SCP_INTSTAT2_PORT4_10;
 884                         for_each_set_bit(bit, &port, 8) {
 885                                 /* scp2 ports start from 4 */
 886                                 port_num = bit + 3;
 887                                 sdw_handle_port_interrupt(slave,
 888                                                 port_num,
 889                                                 &port_status[port_num]);
 890                         }
 891                 }
 892
 893                 /* now check last cascade */
 894                 if (buf2[0] & SDW_SCP_INTSTAT2_SCP3_CASCADE) {
 895                         port = buf2[1] & SDW_SCP_INTSTAT3_PORT11_14;
 896                         for_each_set_bit(bit, &port, 8) {
 897                                 /* scp3 ports start from 11 */
 898                                 port_num = bit + 10;
 899                                 sdw_handle_port_interrupt(slave,
 900                                                 port_num,
 901                                                 &port_status[port_num]);
 902                         }
 903                 }
 904
 905                 /* Update the Slave driver */
 906                 if (slave_notify && slave->ops &&
 907                     slave->ops->interrupt_callback) {
 908                         slave_intr.control_port = clear;
 909                         memcpy(slave_intr.port, &port_status,
 910                                sizeof(slave_intr.port));
 911
 912                         slave->ops->interrupt_callback(slave, &slave_intr);
 913                 }
 914
 915                 /* Ack interrupt */
 916                 ret = sdw_write(slave, SDW_SCP_INT1, clear);
 917                 if (ret < 0) {
 918                         dev_err(slave->bus->dev,
 919                                 "SDW_SCP_INT1 write failed:%d\n", ret);
 920                         return ret;
 921                 }
 922
 923                 /*
 924                  * Read status again to ensure no new interrupts arrived
 925                  * while servicing interrupts.
 926                  */
 927                 ret = sdw_read(slave, SDW_SCP_INT1);
 928                 if (ret < 0) {
 929                         dev_err(slave->bus->dev,
 930                                 "SDW_SCP_INT1 read failed:%d\n", ret);
 931                         return ret;
 932                 }
 933                 _buf = ret;
 934
 935                 ret = sdw_nread(slave, SDW_SCP_INTSTAT2, 2, _buf2);
 936                 if (ret < 0) {
 937                         dev_err(slave->bus->dev,
 938                                 "SDW_SCP_INT2/3 read failed:%d\n", ret);
 939                         return ret;
 940                 }
 941
 942                 /* Make sure no interrupts are pending */
 943                 buf &= _buf;
 944                 buf2[0] &= _buf2[0];
 945                 buf2[1] &= _buf2[1];
 946                 stat = buf || buf2[0] || buf2[1];
 947
 948                 /*
 949                  * Exit loop if Slave is continuously in ALERT state even
 950                  * after servicing the interrupt multiple times.
 951                  */
 952                 count++;
 953
 954                 /* we can get alerts while processing so keep retrying */
 955         } while (stat != 0 && count < SDW_READ_INTR_CLEAR_RETRY);
 956
 957         if (count == SDW_READ_INTR_CLEAR_RETRY)
 958                 dev_warn(slave->bus->dev, "Reached MAX_RETRY on alert read\n");
 959
 960         return ret;
 961 }
 962
 963 static int sdw_update_slave_status(struct sdw_slave *slave,
 964                                    enum sdw_slave_status status)
 965 {
 966         if (slave->ops && slave->ops->update_status)
 967                 return slave->ops->update_status(slave, status);
 968
 969         return 0;
 970 }
 971
 972 /**
 973  * sdw_handle_slave_status() - Handle Slave status
 974  * @bus: SDW bus instance
 975  * @status: Status for all Slave(s)
 976  */
 977 int sdw_handle_slave_status(struct sdw_bus *bus,
 978                             enum sdw_slave_status status[])
 979 {
 980         enum sdw_slave_status prev_status;
 981         struct sdw_slave *slave;
 982         int i, ret = 0;
 983
 984         if (status[0] == SDW_SLAVE_ATTACHED) {
 985                 dev_dbg(bus->dev, "Slave attached, programming device number\n");
 986                 ret = sdw_program_device_num(bus);
 987                 if (ret)
 988                         dev_err(bus->dev, "Slave attach failed: %d\n", ret);
 989                 /*
 990                  * programming a device number will have side effects,
 991                  * so we deal with other devices at a later time
 992                  */
 993                 return ret;
 994         }
 995
 996         /* Continue to check other slave statuses */
 997         for (i = 1; i <= SDW_MAX_DEVICES; i++) {
 998                 mutex_lock(&bus->bus_lock);
 999                 if (test_bit(i, bus->assigned) == false) {
1000                         mutex_unlock(&bus->bus_lock);
1001                         continue;
1002                 }
1003                 mutex_unlock(&bus->bus_lock);
1004
1005                 slave = sdw_get_slave(bus, i);
1006                 if (!slave)
1007                         continue;
1008
1009                 switch (status[i]) {
1010                 case SDW_SLAVE_UNATTACHED:
1011                         if (slave->status == SDW_SLAVE_UNATTACHED)
1012                                 break;
1013
1014                         sdw_modify_slave_status(slave, SDW_SLAVE_UNATTACHED);
1015                         break;
1016
1017                 case SDW_SLAVE_ALERT:
1018                         ret = sdw_handle_slave_alerts(slave);
1019                         if (ret)
1020                                 dev_err(bus->dev,
1021                                         "Slave %d alert handling failed: %d\n",
1022                                         i, ret);
1023                         break;
1024
1025                 case SDW_SLAVE_ATTACHED:
1026                         if (slave->status == SDW_SLAVE_ATTACHED)
1027                                 break;
1028
1029                         prev_status = slave->status;
1030                         sdw_modify_slave_status(slave, SDW_SLAVE_ATTACHED);
1031
1032                         if (prev_status == SDW_SLAVE_ALERT)
1033                                 break;
1034
1035                         ret = sdw_initialize_slave(slave);
1036                         if (ret)
1037                                 dev_err(bus->dev,
1038                                         "Slave %d initialization failed: %d\n",
1039                                         i, ret);
1040
1041                         break;
1042
1043                 default:
1044                         dev_err(bus->dev, "Invalid slave %d status:%d\n",
1045                                 i, status[i]);
1046                         break;
1047                 }
1048
1049                 ret = sdw_update_slave_status(slave, status[i]);
1050                 if (ret)
1051                         dev_err(slave->bus->dev,
1052                                 "Update Slave status failed:%d\n", ret);
1053         }
1054
1055         return ret;
1056 }
1057 EXPORT_SYMBOL(sdw_handle_slave_status);