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/delay.h>
   6 #include <linux/mod_devicetable.h>
   7 #include <linux/pm_runtime.h>
   8 #include <linux/soundwire/sdw_registers.h>
   9 #include <linux/soundwire/sdw.h>
  10 #include "bus.h"
  11
  12 static DEFINE_IDA(sdw_ida);
  13
  14 static int sdw_get_id(struct sdw_bus *bus)
  15 {
  16         int rc = ida_alloc(&sdw_ida, GFP_KERNEL);
  17
  18         if (rc < 0)
  19                 return rc;
  20
  21         bus->id = rc;
  22         return 0;
  23 }
  24
  25 /**
  26  * sdw_bus_master_add() - add a bus Master instance
  27  * @bus: bus instance
  28  * @parent: parent device
  29  * @fwnode: firmware node handle
  30  *
  31  * Initializes the bus instance, read properties and create child
  32  * devices.
  33  */
  34 int sdw_bus_master_add(struct sdw_bus *bus, struct device *parent,
  35                        struct fwnode_handle *fwnode)
  36 {
  37         struct sdw_master_prop *prop = NULL;
  38         int ret;
  39
  40         if (!parent) {
  41                 pr_err("SoundWire parent device is not set\n");
  42                 return -ENODEV;
  43         }
  44
  45         ret = sdw_get_id(bus);
  46         if (ret) {
  47                 dev_err(parent, "Failed to get bus id\n");
  48                 return ret;
  49         }
  50
  51         ret = sdw_master_device_add(bus, parent, fwnode);
  52         if (ret) {
  53                 dev_err(parent, "Failed to add master device at link %d\n",
  54                         bus->link_id);
  55                 return ret;
  56         }
  57
  58         if (!bus->ops) {
  59                 dev_err(bus->dev, "SoundWire Bus ops are not set\n");
  60                 return -EINVAL;
  61         }
  62
  63         mutex_init(&bus->msg_lock);
  64         mutex_init(&bus->bus_lock);
  65         INIT_LIST_HEAD(&bus->slaves);
  66         INIT_LIST_HEAD(&bus->m_rt_list);
  67
  68         /*
  69          * Initialize multi_link flag
  70          * TODO: populate this flag by reading property from FW node
  71          */
  72         bus->multi_link = false;
  73         if (bus->ops->read_prop) {
  74                 ret = bus->ops->read_prop(bus);
  75                 if (ret < 0) {
  76                         dev_err(bus->dev,
  77                                 "Bus read properties failed:%d\n", ret);
  78                         return ret;
  79                 }
  80         }
  81
  82         sdw_bus_debugfs_init(bus);
  83
  84         /*
  85          * Device numbers in SoundWire are 0 through 15. Enumeration device
  86          * number (0), Broadcast device number (15), Group numbers (12 and
  87          * 13) and Master device number (14) are not used for assignment so
  88          * mask these and other higher bits.
  89          */
  90
  91         /* Set higher order bits */
  92         *bus->assigned = ~GENMASK(SDW_BROADCAST_DEV_NUM, SDW_ENUM_DEV_NUM);
  93
  94         /* Set enumuration device number and broadcast device number */
  95         set_bit(SDW_ENUM_DEV_NUM, bus->assigned);
  96         set_bit(SDW_BROADCAST_DEV_NUM, bus->assigned);
  97
  98         /* Set group device numbers and master device number */
  99         set_bit(SDW_GROUP12_DEV_NUM, bus->assigned);
 100         set_bit(SDW_GROUP13_DEV_NUM, bus->assigned);
 101         set_bit(SDW_MASTER_DEV_NUM, bus->assigned);
 102
 103         /*
 104          * SDW is an enumerable bus, but devices can be powered off. So,
 105          * they won't be able to report as present.
 106          *
 107          * Create Slave devices based on Slaves described in
 108          * the respective firmware (ACPI/DT)
 109          */
 110         if (IS_ENABLED(CONFIG_ACPI) && ACPI_HANDLE(bus->dev))
 111                 ret = sdw_acpi_find_slaves(bus);
 112         else if (IS_ENABLED(CONFIG_OF) && bus->dev->of_node)
 113                 ret = sdw_of_find_slaves(bus);
 114         else
 115                 ret = -ENOTSUPP; /* No ACPI/DT so error out */
 116
 117         if (ret) {
 118                 dev_err(bus->dev, "Finding slaves failed:%d\n", ret);
 119                 return ret;
 120         }
 121
 122         /*
 123          * Initialize clock values based on Master properties. The max
 124          * frequency is read from max_clk_freq property. Current assumption
 125          * is that the bus will start at highest clock frequency when
 126          * powered on.
 127          *
 128          * Default active bank will be 0 as out of reset the Slaves have
 129          * to start with bank 0 (Table 40 of Spec)
 130          */
 131         prop = &bus->prop;
 132         bus->params.max_dr_freq = prop->max_clk_freq * SDW_DOUBLE_RATE_FACTOR;
 133         bus->params.curr_dr_freq = bus->params.max_dr_freq;
 134         bus->params.curr_bank = SDW_BANK0;
 135         bus->params.next_bank = SDW_BANK1;
 136
 137         return 0;
 138 }
 139 EXPORT_SYMBOL(sdw_bus_master_add);
 140
 141 static int sdw_delete_slave(struct device *dev, void *data)
 142 {
 143         struct sdw_slave *slave = dev_to_sdw_dev(dev);
 144         struct sdw_bus *bus = slave->bus;
 145
 146         pm_runtime_disable(dev);
 147
 148         sdw_slave_debugfs_exit(slave);
 149
 150         mutex_lock(&bus->bus_lock);
 151
 152         if (slave->dev_num) /* clear dev_num if assigned */
 153                 clear_bit(slave->dev_num, bus->assigned);
 154
 155         list_del_init(&slave->node);
 156         mutex_unlock(&bus->bus_lock);
 157
 158         device_unregister(dev);
 159         return 0;
 160 }
 161
 162 /**
 163  * sdw_bus_master_delete() - delete the bus master instance
 164  * @bus: bus to be deleted
 165  *
 166  * Remove the instance, delete the child devices.
 167  */
 168 void sdw_bus_master_delete(struct sdw_bus *bus)
 169 {
 170         device_for_each_child(bus->dev, NULL, sdw_delete_slave);
 171         sdw_master_device_del(bus);
 172
 173         sdw_bus_debugfs_exit(bus);
 174         ida_free(&sdw_ida, bus->id);
 175 }
 176 EXPORT_SYMBOL(sdw_bus_master_delete);
 177
 178 /*
 179  * SDW IO Calls
 180  */
 181
 182 static inline int find_response_code(enum sdw_command_response resp)
 183 {
 184         switch (resp) {
 185         case SDW_CMD_OK:
 186                 return 0;
 187
 188         case SDW_CMD_IGNORED:
 189                 return -ENODATA;
 190
 191         case SDW_CMD_TIMEOUT:
 192                 return -ETIMEDOUT;
 193
 194         default:
 195                 return -EIO;
 196         }
 197 }
 198
 199 static inline int do_transfer(struct sdw_bus *bus, struct sdw_msg *msg)
 200 {
 201         int retry = bus->prop.err_threshold;
 202         enum sdw_command_response resp;
 203         int ret = 0, i;
 204
 205         for (i = 0; i <= retry; i++) {
 206                 resp = bus->ops->xfer_msg(bus, msg);
 207                 ret = find_response_code(resp);
 208
 209                 /* if cmd is ok or ignored return */
 210                 if (ret == 0 || ret == -ENODATA)
 211                         return ret;
 212         }
 213
 214         return ret;
 215 }
 216
 217 static inline int do_transfer_defer(struct sdw_bus *bus,
 218                                     struct sdw_msg *msg,
 219                                     struct sdw_defer *defer)
 220 {
 221         int retry = bus->prop.err_threshold;
 222         enum sdw_command_response resp;
 223         int ret = 0, i;
 224
 225         defer->msg = msg;
 226         defer->length = msg->len;
 227         init_completion(&defer->complete);
 228
 229         for (i = 0; i <= retry; i++) {
 230                 resp = bus->ops->xfer_msg_defer(bus, msg, defer);
 231                 ret = find_response_code(resp);
 232                 /* if cmd is ok or ignored return */
 233                 if (ret == 0 || ret == -ENODATA)
 234                         return ret;
 235         }
 236
 237         return ret;
 238 }
 239
 240 static int sdw_reset_page(struct sdw_bus *bus, u16 dev_num)
 241 {
 242         int retry = bus->prop.err_threshold;
 243         enum sdw_command_response resp;
 244         int ret = 0, i;
 245
 246         for (i = 0; i <= retry; i++) {
 247                 resp = bus->ops->reset_page_addr(bus, dev_num);
 248                 ret = find_response_code(resp);
 249                 /* if cmd is ok or ignored return */
 250                 if (ret == 0 || ret == -ENODATA)
 251                         return ret;
 252         }
 253
 254         return ret;
 255 }
 256
 257 /**
 258  * sdw_transfer() - Synchronous transfer message to a SDW Slave device
 259  * @bus: SDW bus
 260  * @msg: SDW message to be xfered
 261  */
 262 int sdw_transfer(struct sdw_bus *bus, struct sdw_msg *msg)
 263 {
 264         int ret;
 265
 266         mutex_lock(&bus->msg_lock);
 267
 268         ret = do_transfer(bus, msg);
 269         if (ret != 0 && ret != -ENODATA)
 270                 dev_err(bus->dev, "trf on Slave %d failed:%d\n",
 271                         msg->dev_num, ret);
 272
 273         if (msg->page)
 274                 sdw_reset_page(bus, msg->dev_num);
 275
 276         mutex_unlock(&bus->msg_lock);
 277
 278         return ret;
 279 }
 280
 281 /**
 282  * sdw_transfer_defer() - Asynchronously transfer message to a SDW Slave device
 283  * @bus: SDW bus
 284  * @msg: SDW message to be xfered
 285  * @defer: Defer block for signal completion
 286  *
 287  * Caller needs to hold the msg_lock lock while calling this
 288  */
 289 int sdw_transfer_defer(struct sdw_bus *bus, struct sdw_msg *msg,
 290                        struct sdw_defer *defer)
 291 {
 292         int ret;
 293
 294         if (!bus->ops->xfer_msg_defer)
 295                 return -ENOTSUPP;
 296
 297         ret = do_transfer_defer(bus, msg, defer);
 298         if (ret != 0 && ret != -ENODATA)
 299                 dev_err(bus->dev, "Defer trf on Slave %d failed:%d\n",
 300                         msg->dev_num, ret);
 301
 302         if (msg->page)
 303                 sdw_reset_page(bus, msg->dev_num);
 304
 305         return ret;
 306 }
 307
 308 int sdw_fill_msg(struct sdw_msg *msg, struct sdw_slave *slave,
 309                  u32 addr, size_t count, u16 dev_num, u8 flags, u8 *buf)
 310 {
 311         memset(msg, 0, sizeof(*msg));
 312         msg->addr = addr; /* addr is 16 bit and truncated here */
 313         msg->len = count;
 314         msg->dev_num = dev_num;
 315         msg->flags = flags;
 316         msg->buf = buf;
 317
 318         if (addr < SDW_REG_NO_PAGE) /* no paging area */
 319                 return 0;
 320
 321         if (addr >= SDW_REG_MAX) { /* illegal addr */
 322                 pr_err("SDW: Invalid address %x passed\n", addr);
 323                 return -EINVAL;
 324         }
 325
 326         if (addr < SDW_REG_OPTIONAL_PAGE) { /* 32k but no page */
 327                 if (slave && !slave->prop.paging_support)
 328                         return 0;
 329                 /* no need for else as that will fall-through to paging */
 330         }
 331
 332         /* paging mandatory */
 333         if (dev_num == SDW_ENUM_DEV_NUM || dev_num == SDW_BROADCAST_DEV_NUM) {
 334                 pr_err("SDW: Invalid device for paging :%d\n", dev_num);
 335                 return -EINVAL;
 336         }
 337
 338         if (!slave) {
 339                 pr_err("SDW: No slave for paging addr\n");
 340                 return -EINVAL;
 341         }
 342
 343         if (!slave->prop.paging_support) {
 344                 dev_err(&slave->dev,
 345                         "address %x needs paging but no support\n", addr);
 346                 return -EINVAL;
 347         }
 348
 349         msg->addr_page1 = (addr >> SDW_REG_SHIFT(SDW_SCP_ADDRPAGE1_MASK));
 350         msg->addr_page2 = (addr >> SDW_REG_SHIFT(SDW_SCP_ADDRPAGE2_MASK));
 351         msg->addr |= BIT(15);
 352         msg->page = true;
 353
 354         return 0;
 355 }
 356
 357 /*
 358  * Read/Write IO functions.
 359  * no_pm versions can only be called by the bus, e.g. while enumerating or
 360  * handling suspend-resume sequences.
 361  * all clients need to use the pm versions
 362  */
 363
 364 static int
 365 sdw_nread_no_pm(struct sdw_slave *slave, u32 addr, size_t count, u8 *val)
 366 {
 367         struct sdw_msg msg;
 368         int ret;
 369
 370         ret = sdw_fill_msg(&msg, slave, addr, count,
 371                            slave->dev_num, SDW_MSG_FLAG_READ, val);
 372         if (ret < 0)
 373                 return ret;
 374
 375         return sdw_transfer(slave->bus, &msg);
 376 }
 377
 378 static int
 379 sdw_nwrite_no_pm(struct sdw_slave *slave, u32 addr, size_t count, u8 *val)
 380 {
 381         struct sdw_msg msg;
 382         int ret;
 383
 384         ret = sdw_fill_msg(&msg, slave, addr, count,
 385                            slave->dev_num, SDW_MSG_FLAG_WRITE, val);
 386         if (ret < 0)
 387                 return ret;
 388
 389         return sdw_transfer(slave->bus, &msg);
 390 }
 391
 392 static int sdw_write_no_pm(struct sdw_slave *slave, u32 addr, u8 value)
 393 {
 394         return sdw_nwrite_no_pm(slave, addr, 1, &value);
 395 }
 396
 397 static int
 398 sdw_bread_no_pm(struct sdw_bus *bus, u16 dev_num, u32 addr)
 399 {
 400         struct sdw_msg msg;
 401         u8 buf;
 402         int ret;
 403
 404         ret = sdw_fill_msg(&msg, NULL, addr, 1, dev_num,
 405                            SDW_MSG_FLAG_READ, &buf);
 406         if (ret)
 407                 return ret;
 408
 409         ret = sdw_transfer(bus, &msg);
 410         if (ret < 0)
 411                 return ret;
 412
 413         return buf;
 414 }
 415
 416 static int
 417 sdw_bwrite_no_pm(struct sdw_bus *bus, u16 dev_num, u32 addr, u8 value)
 418 {
 419         struct sdw_msg msg;
 420         int ret;
 421
 422         ret = sdw_fill_msg(&msg, NULL, addr, 1, dev_num,
 423                            SDW_MSG_FLAG_WRITE, &value);
 424         if (ret)
 425                 return ret;
 426
 427         return sdw_transfer(bus, &msg);
 428 }
 429
 430 static int
 431 sdw_read_no_pm(struct sdw_slave *slave, u32 addr)
 432 {
 433         u8 buf;
 434         int ret;
 435
 436         ret = sdw_nread_no_pm(slave, addr, 1, &buf);
 437         if (ret < 0)
 438                 return ret;
 439         else
 440                 return buf;
 441 }
 442
 443 /**
 444  * sdw_nread() - Read "n" contiguous SDW Slave registers
 445  * @slave: SDW Slave
 446  * @addr: Register address
 447  * @count: length
 448  * @val: Buffer for values to be read
 449  */
 450 int sdw_nread(struct sdw_slave *slave, u32 addr, size_t count, u8 *val)
 451 {
 452         int ret;
 453
 454         ret = pm_runtime_get_sync(slave->bus->dev);
 455         if (ret < 0 && ret != -EACCES) {
 456                 pm_runtime_put_noidle(slave->bus->dev);
 457                 return ret;
 458         }
 459
 460         ret = sdw_nread_no_pm(slave, addr, count, val);
 461
 462         pm_runtime_mark_last_busy(slave->bus->dev);
 463         pm_runtime_put(slave->bus->dev);
 464
 465         return ret;
 466 }
 467 EXPORT_SYMBOL(sdw_nread);
 468
 469 /**
 470  * sdw_nwrite() - Write "n" contiguous SDW Slave registers
 471  * @slave: SDW Slave
 472  * @addr: Register address
 473  * @count: length
 474  * @val: Buffer for values to be read
 475  */
 476 int sdw_nwrite(struct sdw_slave *slave, u32 addr, size_t count, u8 *val)
 477 {
 478         int ret;
 479
 480         ret = pm_runtime_get_sync(slave->bus->dev);
 481         if (ret < 0 && ret != -EACCES) {
 482                 pm_runtime_put_noidle(slave->bus->dev);
 483                 return ret;
 484         }
 485
 486         ret = sdw_nwrite_no_pm(slave, addr, count, val);
 487
 488         pm_runtime_mark_last_busy(slave->bus->dev);
 489         pm_runtime_put(slave->bus->dev);
 490
 491         return ret;
 492 }
 493 EXPORT_SYMBOL(sdw_nwrite);
 494
 495 /**
 496  * sdw_read() - Read a SDW Slave register
 497  * @slave: SDW Slave
 498  * @addr: Register address
 499  */
 500 int sdw_read(struct sdw_slave *slave, u32 addr)
 501 {
 502         u8 buf;
 503         int ret;
 504
 505         ret = sdw_nread(slave, addr, 1, &buf);
 506         if (ret < 0)
 507                 return ret;
 508
 509         return buf;
 510 }
 511 EXPORT_SYMBOL(sdw_read);
 512
 513 /**
 514  * sdw_write() - Write a SDW Slave register
 515  * @slave: SDW Slave
 516  * @addr: Register address
 517  * @value: Register value
 518  */
 519 int sdw_write(struct sdw_slave *slave, u32 addr, u8 value)
 520 {
 521         return sdw_nwrite(slave, addr, 1, &value);
 522 }
 523 EXPORT_SYMBOL(sdw_write);
 524
 525 /*
 526  * SDW alert handling
 527  */
 528
 529 /* called with bus_lock held */
 530 static struct sdw_slave *sdw_get_slave(struct sdw_bus *bus, int i)
 531 {
 532         struct sdw_slave *slave = NULL;
 533
 534         list_for_each_entry(slave, &bus->slaves, node) {
 535                 if (slave->dev_num == i)
 536                         return slave;
 537         }
 538
 539         return NULL;
 540 }
 541
 542 static int sdw_compare_devid(struct sdw_slave *slave, struct sdw_slave_id id)
 543 {
 544         if (slave->id.mfg_id != id.mfg_id ||
 545             slave->id.part_id != id.part_id ||
 546             slave->id.class_id != id.class_id ||
 547             (slave->id.unique_id != SDW_IGNORED_UNIQUE_ID &&
 548              slave->id.unique_id != id.unique_id))
 549                 return -ENODEV;
 550
 551         return 0;
 552 }
 553
 554 /* called with bus_lock held */
 555 static int sdw_get_device_num(struct sdw_slave *slave)
 556 {
 557         int bit;
 558
 559         bit = find_first_zero_bit(slave->bus->assigned, SDW_MAX_DEVICES);
 560         if (bit == SDW_MAX_DEVICES) {
 561                 bit = -ENODEV;
 562                 goto err;
 563         }
 564
 565         /*
 566          * Do not update dev_num in Slave data structure here,
 567          * Update once program dev_num is successful
 568          */
 569         set_bit(bit, slave->bus->assigned);
 570
 571 err:
 572         return bit;
 573 }
 574
 575 static int sdw_assign_device_num(struct sdw_slave *slave)
 576 {
 577         int ret, dev_num;
 578         bool new_device = false;
 579
 580         /* check first if device number is assigned, if so reuse that */
 581         if (!slave->dev_num) {
 582                 if (!slave->dev_num_sticky) {
 583                         mutex_lock(&slave->bus->bus_lock);
 584                         dev_num = sdw_get_device_num(slave);
 585                         mutex_unlock(&slave->bus->bus_lock);
 586                         if (dev_num < 0) {
 587                                 dev_err(slave->bus->dev, "Get dev_num failed: %d\n",
 588                                         dev_num);
 589                                 return dev_num;
 590                         }
 591                         slave->dev_num = dev_num;
 592                         slave->dev_num_sticky = dev_num;
 593                         new_device = true;
 594                 } else {
 595                         slave->dev_num = slave->dev_num_sticky;
 596                 }
 597         }
 598
 599         if (!new_device)
 600                 dev_dbg(slave->bus->dev,
 601                         "Slave already registered, reusing dev_num:%d\n",
 602                         slave->dev_num);
 603
 604         /* Clear the slave->dev_num to transfer message on device 0 */
 605         dev_num = slave->dev_num;
 606         slave->dev_num = 0;
 607
 608         ret = sdw_write_no_pm(slave, SDW_SCP_DEVNUMBER, dev_num);
 609         if (ret < 0) {
 610                 dev_err(&slave->dev, "Program device_num %d failed: %d\n",
 611                         dev_num, ret);
 612                 return ret;
 613         }
 614
 615         /* After xfer of msg, restore dev_num */
 616         slave->dev_num = slave->dev_num_sticky;
 617
 618         return 0;
 619 }
 620
 621 void sdw_extract_slave_id(struct sdw_bus *bus,
 622                           u64 addr, struct sdw_slave_id *id)
 623 {
 624         dev_dbg(bus->dev, "SDW Slave Addr: %llx\n", addr);
 625
 626         id->sdw_version = SDW_VERSION(addr);
 627         id->unique_id = SDW_UNIQUE_ID(addr);
 628         id->mfg_id = SDW_MFG_ID(addr);
 629         id->part_id = SDW_PART_ID(addr);
 630         id->class_id = SDW_CLASS_ID(addr);
 631
 632         dev_dbg(bus->dev,
 633                 "SDW Slave class_id %x, part_id %x, mfg_id %x, unique_id %x, version %x\n",
 634                                 id->class_id, id->part_id, id->mfg_id,
 635                                 id->unique_id, id->sdw_version);
 636 }
 637
 638 static int sdw_program_device_num(struct sdw_bus *bus)
 639 {
 640         u8 buf[SDW_NUM_DEV_ID_REGISTERS] = {0};
 641         struct sdw_slave *slave, *_s;
 642         struct sdw_slave_id id;
 643         struct sdw_msg msg;
 644         bool found = false;
 645         int count = 0, ret;
 646         u64 addr;
 647
 648         /* No Slave, so use raw xfer api */
 649         ret = sdw_fill_msg(&msg, NULL, SDW_SCP_DEVID_0,
 650                            SDW_NUM_DEV_ID_REGISTERS, 0, SDW_MSG_FLAG_READ, buf);
 651         if (ret < 0)
 652                 return ret;
 653
 654         do {
 655                 ret = sdw_transfer(bus, &msg);
 656                 if (ret == -ENODATA) { /* end of device id reads */
 657                         dev_dbg(bus->dev, "No more devices to enumerate\n");
 658                         ret = 0;
 659                         break;
 660                 }
 661                 if (ret < 0) {
 662                         dev_err(bus->dev, "DEVID read fail:%d\n", ret);
 663                         break;
 664                 }
 665
 666                 /*
 667                  * Construct the addr and extract. Cast the higher shift
 668                  * bits to avoid truncation due to size limit.
 669                  */
 670                 addr = buf[5] | (buf[4] << 8) | (buf[3] << 16) |
 671                         ((u64)buf[2] << 24) | ((u64)buf[1] << 32) |
 672                         ((u64)buf[0] << 40);
 673
 674                 sdw_extract_slave_id(bus, addr, &id);
 675
 676                 /* Now compare with entries */
 677                 list_for_each_entry_safe(slave, _s, &bus->slaves, node) {
 678                         if (sdw_compare_devid(slave, id) == 0) {
 679                                 found = true;
 680
 681                                 /*
 682                                  * Assign a new dev_num to this Slave and
 683                                  * not mark it present. It will be marked
 684                                  * present after it reports ATTACHED on new
 685                                  * dev_num
 686                                  */
 687                                 ret = sdw_assign_device_num(slave);
 688                                 if (ret) {
 689                                         dev_err(slave->bus->dev,
 690                                                 "Assign dev_num failed:%d\n",
 691                                                 ret);
 692                                         return ret;
 693                                 }
 694
 695                                 break;
 696                         }
 697                 }
 698
 699                 if (!found) {
 700                         /* TODO: Park this device in Group 13 */
 701                         dev_err(bus->dev, "Slave Entry not found\n");
 702                 }
 703
 704                 count++;
 705
 706                 /*
 707                  * Check till error out or retry (count) exhausts.
 708                  * Device can drop off and rejoin during enumeration
 709                  * so count till twice the bound.
 710                  */
 711
 712         } while (ret == 0 && count < (SDW_MAX_DEVICES * 2));
 713
 714         return ret;
 715 }
 716
 717 static void sdw_modify_slave_status(struct sdw_slave *slave,
 718                                     enum sdw_slave_status status)
 719 {
 720         mutex_lock(&slave->bus->bus_lock);
 721
 722         dev_vdbg(&slave->dev,
 723                  "%s: changing status slave %d status %d new status %d\n",
 724                  __func__, slave->dev_num, slave->status, status);
 725
 726         if (status == SDW_SLAVE_UNATTACHED) {
 727                 dev_dbg(&slave->dev,
 728                         "%s: initializing completion for Slave %d\n",
 729                         __func__, slave->dev_num);
 730
 731                 init_completion(&slave->enumeration_complete);
 732                 init_completion(&slave->initialization_complete);
 733
 734         } else if ((status == SDW_SLAVE_ATTACHED) &&
 735                    (slave->status == SDW_SLAVE_UNATTACHED)) {
 736                 dev_dbg(&slave->dev,
 737                         "%s: signaling completion for Slave %d\n",
 738                         __func__, slave->dev_num);
 739
 740                 complete(&slave->enumeration_complete);
 741         }
 742         slave->status = status;
 743         mutex_unlock(&slave->bus->bus_lock);
 744 }
 745
 746 static enum sdw_clk_stop_mode sdw_get_clk_stop_mode(struct sdw_slave *slave)
 747 {
 748         enum sdw_clk_stop_mode mode;
 749
 750         /*
 751          * Query for clock stop mode if Slave implements
 752          * ops->get_clk_stop_mode, else read from property.
 753          */
 754         if (slave->ops && slave->ops->get_clk_stop_mode) {
 755                 mode = slave->ops->get_clk_stop_mode(slave);
 756         } else {
 757                 if (slave->prop.clk_stop_mode1)
 758                         mode = SDW_CLK_STOP_MODE1;
 759                 else
 760                         mode = SDW_CLK_STOP_MODE0;
 761         }
 762
 763         return mode;
 764 }
 765
 766 static int sdw_slave_clk_stop_callback(struct sdw_slave *slave,
 767                                        enum sdw_clk_stop_mode mode,
 768                                        enum sdw_clk_stop_type type)
 769 {
 770         int ret;
 771
 772         if (slave->ops && slave->ops->clk_stop) {
 773                 ret = slave->ops->clk_stop(slave, mode, type);
 774                 if (ret < 0) {
 775                         dev_err(&slave->dev,
 776                                 "Clk Stop type =%d failed: %d\n", type, ret);
 777                         return ret;
 778                 }
 779         }
 780
 781         return 0;
 782 }
 783
 784 static int sdw_slave_clk_stop_prepare(struct sdw_slave *slave,
 785                                       enum sdw_clk_stop_mode mode,
 786                                       bool prepare)
 787 {
 788         bool wake_en;
 789         u32 val = 0;
 790         int ret;
 791
 792         wake_en = slave->prop.wake_capable;
 793
 794         if (prepare) {
 795                 val = SDW_SCP_SYSTEMCTRL_CLK_STP_PREP;
 796
 797                 if (mode == SDW_CLK_STOP_MODE1)
 798                         val |= SDW_SCP_SYSTEMCTRL_CLK_STP_MODE1;
 799
 800                 if (wake_en)
 801                         val |= SDW_SCP_SYSTEMCTRL_WAKE_UP_EN;
 802         } else {
 803                 val = sdw_read_no_pm(slave, SDW_SCP_SYSTEMCTRL);
 804
 805                 val &= ~(SDW_SCP_SYSTEMCTRL_CLK_STP_PREP);
 806         }
 807
 808         ret = sdw_write_no_pm(slave, SDW_SCP_SYSTEMCTRL, val);
 809
 810         if (ret != 0)
 811                 dev_err(&slave->dev,
 812                         "Clock Stop prepare failed for slave: %d", ret);
 813
 814         return ret;
 815 }
 816
 817 static int sdw_bus_wait_for_clk_prep_deprep(struct sdw_bus *bus, u16 dev_num)
 818 {
 819         int retry = bus->clk_stop_timeout;
 820         int val;
 821
 822         do {
 823                 val = sdw_bread_no_pm(bus, dev_num, SDW_SCP_STAT) &
 824                         SDW_SCP_STAT_CLK_STP_NF;
 825                 if (!val) {
 826                         dev_info(bus->dev, "clock stop prep/de-prep done slave:%d",
 827                                  dev_num);
 828                         return 0;
 829                 }
 830
 831                 usleep_range(1000, 1500);
 832                 retry--;
 833         } while (retry);
 834
 835         dev_err(bus->dev, "clock stop prep/de-prep failed slave:%d",
 836                 dev_num);
 837
 838         return -ETIMEDOUT;
 839 }
 840
 841 /**
 842  * sdw_bus_prep_clk_stop: prepare Slave(s) for clock stop
 843  *
 844  * @bus: SDW bus instance
 845  *
 846  * Query Slave for clock stop mode and prepare for that mode.
 847  */
 848 int sdw_bus_prep_clk_stop(struct sdw_bus *bus)
 849 {
 850         enum sdw_clk_stop_mode slave_mode;
 851         bool simple_clk_stop = true;
 852         struct sdw_slave *slave;
 853         bool is_slave = false;
 854         int ret = 0;
 855
 856         /*
 857          * In order to save on transition time, prepare
 858          * each Slave and then wait for all Slave(s) to be
 859          * prepared for clock stop.
 860          */
 861         list_for_each_entry(slave, &bus->slaves, node) {
 862                 if (!slave->dev_num)
 863                         continue;
 864
 865                 /* Identify if Slave(s) are available on Bus */
 866                 is_slave = true;
 867
 868                 if (slave->status != SDW_SLAVE_ATTACHED &&
 869                     slave->status != SDW_SLAVE_ALERT)
 870                         continue;
 871
 872                 slave_mode = sdw_get_clk_stop_mode(slave);
 873                 slave->curr_clk_stop_mode = slave_mode;
 874
 875                 ret = sdw_slave_clk_stop_callback(slave, slave_mode,
 876                                                   SDW_CLK_PRE_PREPARE);
 877                 if (ret < 0) {
 878                         dev_err(&slave->dev,
 879                                 "pre-prepare failed:%d", ret);
 880                         return ret;
 881                 }
 882
 883                 ret = sdw_slave_clk_stop_prepare(slave,
 884                                                  slave_mode, true);
 885                 if (ret < 0) {
 886                         dev_err(&slave->dev,
 887                                 "pre-prepare failed:%d", ret);
 888                         return ret;
 889                 }
 890
 891                 if (slave_mode == SDW_CLK_STOP_MODE1)
 892                         simple_clk_stop = false;
 893         }
 894
 895         if (is_slave && !simple_clk_stop) {
 896                 ret = sdw_bus_wait_for_clk_prep_deprep(bus,
 897                                                        SDW_BROADCAST_DEV_NUM);
 898                 if (ret < 0)
 899                         return ret;
 900         }
 901
 902         /* Inform slaves that prep is done */
 903         list_for_each_entry(slave, &bus->slaves, node) {
 904                 if (!slave->dev_num)
 905                         continue;
 906
 907                 if (slave->status != SDW_SLAVE_ATTACHED &&
 908                     slave->status != SDW_SLAVE_ALERT)
 909                         continue;
 910
 911                 slave_mode = slave->curr_clk_stop_mode;
 912
 913                 if (slave_mode == SDW_CLK_STOP_MODE1) {
 914                         ret = sdw_slave_clk_stop_callback(slave,
 915                                                           slave_mode,
 916                                                           SDW_CLK_POST_PREPARE);
 917
 918                         if (ret < 0) {
 919                                 dev_err(&slave->dev,
 920                                         "post-prepare failed:%d", ret);
 921                         }
 922                 }
 923         }
 924
 925         return ret;
 926 }
 927 EXPORT_SYMBOL(sdw_bus_prep_clk_stop);
 928
 929 /**
 930  * sdw_bus_clk_stop: stop bus clock
 931  *
 932  * @bus: SDW bus instance
 933  *
 934  * After preparing the Slaves for clock stop, stop the clock by broadcasting
 935  * write to SCP_CTRL register.
 936  */
 937 int sdw_bus_clk_stop(struct sdw_bus *bus)
 938 {
 939         int ret;
 940
 941         /*
 942          * broadcast clock stop now, attached Slaves will ACK this,
 943          * unattached will ignore
 944          */
 945         ret = sdw_bwrite_no_pm(bus, SDW_BROADCAST_DEV_NUM,
 946                                SDW_SCP_CTRL, SDW_SCP_CTRL_CLK_STP_NOW);
 947         if (ret < 0) {
 948                 if (ret == -ENODATA)
 949                         dev_dbg(bus->dev,
 950                                 "ClockStopNow Broadcast msg ignored %d", ret);
 951                 else
 952                         dev_err(bus->dev,
 953                                 "ClockStopNow Broadcast msg failed %d", ret);
 954                 return ret;
 955         }
 956
 957         return 0;
 958 }
 959 EXPORT_SYMBOL(sdw_bus_clk_stop);
 960
 961 /**
 962  * sdw_bus_exit_clk_stop: Exit clock stop mode
 963  *
 964  * @bus: SDW bus instance
 965  *
 966  * This De-prepares the Slaves by exiting Clock Stop Mode 0. For the Slaves
 967  * exiting Clock Stop Mode 1, they will be de-prepared after they enumerate
 968  * back.
 969  */
 970 int sdw_bus_exit_clk_stop(struct sdw_bus *bus)
 971 {
 972         enum sdw_clk_stop_mode mode;
 973         bool simple_clk_stop = true;
 974         struct sdw_slave *slave;
 975         bool is_slave = false;
 976         int ret;
 977
 978         /*
 979          * In order to save on transition time, de-prepare
 980          * each Slave and then wait for all Slave(s) to be
 981          * de-prepared after clock resume.
 982          */
 983         list_for_each_entry(slave, &bus->slaves, node) {
 984                 if (!slave->dev_num)
 985                         continue;
 986
 987                 /* Identify if Slave(s) are available on Bus */
 988                 is_slave = true;
 989
 990                 if (slave->status != SDW_SLAVE_ATTACHED &&
 991                     slave->status != SDW_SLAVE_ALERT)
 992                         continue;
 993
 994                 mode = slave->curr_clk_stop_mode;
 995
 996                 if (mode == SDW_CLK_STOP_MODE1) {
 997                         simple_clk_stop = false;
 998                         continue;
 999                 }
1000
1001                 ret = sdw_slave_clk_stop_callback(slave, mode,
1002                                                   SDW_CLK_PRE_DEPREPARE);
1003                 if (ret < 0)
1004                         dev_warn(&slave->dev,
1005                                  "clk stop deprep failed:%d", ret);
1006
1007                 ret = sdw_slave_clk_stop_prepare(slave, mode,
1008                                                  false);
1009
1010                 if (ret < 0)
1011                         dev_warn(&slave->dev,
1012                                  "clk stop deprep failed:%d", ret);
1013         }
1014
1015         if (is_slave && !simple_clk_stop)
1016                 sdw_bus_wait_for_clk_prep_deprep(bus, SDW_BROADCAST_DEV_NUM);
1017
1018         list_for_each_entry(slave, &bus->slaves, node) {
1019                 if (!slave->dev_num)
1020                         continue;
1021
1022                 if (slave->status != SDW_SLAVE_ATTACHED &&
1023                     slave->status != SDW_SLAVE_ALERT)
1024                         continue;
1025
1026                 mode = slave->curr_clk_stop_mode;
1027                 sdw_slave_clk_stop_callback(slave, mode,
1028                                             SDW_CLK_POST_DEPREPARE);
1029         }
1030
1031         return 0;
1032 }
1033 EXPORT_SYMBOL(sdw_bus_exit_clk_stop);
1034
1035 int sdw_configure_dpn_intr(struct sdw_slave *slave,
1036                            int port, bool enable, int mask)
1037 {
1038         u32 addr;
1039         int ret;
1040         u8 val = 0;
1041
1042         addr = SDW_DPN_INTMASK(port);
1043
1044         /* Set/Clear port ready interrupt mask */
1045         if (enable) {
1046                 val |= mask;
1047                 val |= SDW_DPN_INT_PORT_READY;
1048         } else {
1049                 val &= ~(mask);
1050                 val &= ~SDW_DPN_INT_PORT_READY;
1051         }
1052
1053         ret = sdw_update(slave, addr, (mask | SDW_DPN_INT_PORT_READY), val);
1054         if (ret < 0)
1055                 dev_err(slave->bus->dev,
1056                         "SDW_DPN_INTMASK write failed:%d\n", val);
1057
1058         return ret;
1059 }
1060
1061 static int sdw_initialize_slave(struct sdw_slave *slave)
1062 {
1063         struct sdw_slave_prop *prop = &slave->prop;
1064         int ret;
1065         u8 val;
1066
1067         /*
1068          * Set bus clash, parity and SCP implementation
1069          * defined interrupt mask
1070          * TODO: Read implementation defined interrupt mask
1071          * from Slave property
1072          */
1073         val = SDW_SCP_INT1_IMPL_DEF | SDW_SCP_INT1_BUS_CLASH |
1074                                         SDW_SCP_INT1_PARITY;
1075
1076         /* Enable SCP interrupts */
1077         ret = sdw_update(slave, SDW_SCP_INTMASK1, val, val);
1078         if (ret < 0) {
1079                 dev_err(slave->bus->dev,
1080                         "SDW_SCP_INTMASK1 write failed:%d\n", ret);
1081                 return ret;
1082         }
1083
1084         /* No need to continue if DP0 is not present */
1085         if (!slave->prop.dp0_prop)
1086                 return 0;
1087
1088         /* Enable DP0 interrupts */
1089         val = prop->dp0_prop->imp_def_interrupts;
1090         val |= SDW_DP0_INT_PORT_READY | SDW_DP0_INT_BRA_FAILURE;
1091
1092         ret = sdw_update(slave, SDW_DP0_INTMASK, val, val);
1093         if (ret < 0)
1094                 dev_err(slave->bus->dev,
1095                         "SDW_DP0_INTMASK read failed:%d\n", ret);
1096         return ret;
1097 }
1098
1099 static int sdw_handle_dp0_interrupt(struct sdw_slave *slave, u8 *slave_status)
1100 {
1101         u8 clear = 0, impl_int_mask;
1102         int status, status2, ret, count = 0;
1103
1104         status = sdw_read(slave, SDW_DP0_INT);
1105         if (status < 0) {
1106                 dev_err(slave->bus->dev,
1107                         "SDW_DP0_INT read failed:%d\n", status);
1108                 return status;
1109         }
1110
1111         do {
1112                 if (status & SDW_DP0_INT_TEST_FAIL) {
1113                         dev_err(&slave->dev, "Test fail for port 0\n");
1114                         clear |= SDW_DP0_INT_TEST_FAIL;
1115                 }
1116
1117                 /*
1118                  * Assumption: PORT_READY interrupt will be received only for
1119                  * ports implementing Channel Prepare state machine (CP_SM)
1120                  */
1121
1122                 if (status & SDW_DP0_INT_PORT_READY) {
1123                         complete(&slave->port_ready[0]);
1124                         clear |= SDW_DP0_INT_PORT_READY;
1125                 }
1126
1127                 if (status & SDW_DP0_INT_BRA_FAILURE) {
1128                         dev_err(&slave->dev, "BRA failed\n");
1129                         clear |= SDW_DP0_INT_BRA_FAILURE;
1130                 }
1131
1132                 impl_int_mask = SDW_DP0_INT_IMPDEF1 |
1133                         SDW_DP0_INT_IMPDEF2 | SDW_DP0_INT_IMPDEF3;
1134
1135                 if (status & impl_int_mask) {
1136                         clear |= impl_int_mask;
1137                         *slave_status = clear;
1138                 }
1139
1140                 /* clear the interrupt */
1141                 ret = sdw_write(slave, SDW_DP0_INT, clear);
1142                 if (ret < 0) {
1143                         dev_err(slave->bus->dev,
1144                                 "SDW_DP0_INT write failed:%d\n", ret);
1145                         return ret;
1146                 }
1147
1148                 /* Read DP0 interrupt again */
1149                 status2 = sdw_read(slave, SDW_DP0_INT);
1150                 if (status2 < 0) {
1151                         dev_err(slave->bus->dev,
1152                                 "SDW_DP0_INT read failed:%d\n", status2);
1153                         return status2;
1154                 }
1155                 status &= status2;
1156
1157                 count++;
1158
1159                 /* we can get alerts while processing so keep retrying */
1160         } while (status != 0 && count < SDW_READ_INTR_CLEAR_RETRY);
1161
1162         if (count == SDW_READ_INTR_CLEAR_RETRY)
1163                 dev_warn(slave->bus->dev, "Reached MAX_RETRY on DP0 read\n");
1164
1165         return ret;
1166 }
1167
1168 static int sdw_handle_port_interrupt(struct sdw_slave *slave,
1169                                      int port, u8 *slave_status)
1170 {
1171         u8 clear = 0, impl_int_mask;
1172         int status, status2, ret, count = 0;
1173         u32 addr;
1174
1175         if (port == 0)
1176                 return sdw_handle_dp0_interrupt(slave, slave_status);
1177
1178         addr = SDW_DPN_INT(port);
1179         status = sdw_read(slave, addr);
1180         if (status < 0) {
1181                 dev_err(slave->bus->dev,
1182                         "SDW_DPN_INT read failed:%d\n", status);
1183
1184                 return status;
1185         }
1186
1187         do {
1188                 if (status & SDW_DPN_INT_TEST_FAIL) {
1189                         dev_err(&slave->dev, "Test fail for port:%d\n", port);
1190                         clear |= SDW_DPN_INT_TEST_FAIL;
1191                 }
1192
1193                 /*
1194                  * Assumption: PORT_READY interrupt will be received only
1195                  * for ports implementing CP_SM.
1196                  */
1197                 if (status & SDW_DPN_INT_PORT_READY) {
1198                         complete(&slave->port_ready[port]);
1199                         clear |= SDW_DPN_INT_PORT_READY;
1200                 }
1201
1202                 impl_int_mask = SDW_DPN_INT_IMPDEF1 |
1203                         SDW_DPN_INT_IMPDEF2 | SDW_DPN_INT_IMPDEF3;
1204
1205                 if (status & impl_int_mask) {
1206                         clear |= impl_int_mask;
1207                         *slave_status = clear;
1208                 }
1209
1210                 /* clear the interrupt */
1211                 ret = sdw_write(slave, addr, clear);
1212                 if (ret < 0) {
1213                         dev_err(slave->bus->dev,
1214                                 "SDW_DPN_INT write failed:%d\n", ret);
1215                         return ret;
1216                 }
1217
1218                 /* Read DPN interrupt again */
1219                 status2 = sdw_read(slave, addr);
1220                 if (status2 < 0) {
1221                         dev_err(slave->bus->dev,
1222                                 "SDW_DPN_INT read failed:%d\n", status2);
1223                         return status2;
1224                 }
1225                 status &= status2;
1226
1227                 count++;
1228
1229                 /* we can get alerts while processing so keep retrying */
1230         } while (status != 0 && count < SDW_READ_INTR_CLEAR_RETRY);
1231
1232         if (count == SDW_READ_INTR_CLEAR_RETRY)
1233                 dev_warn(slave->bus->dev, "Reached MAX_RETRY on port read");
1234
1235         return ret;
1236 }
1237
1238 static int sdw_handle_slave_alerts(struct sdw_slave *slave)
1239 {
1240         struct sdw_slave_intr_status slave_intr;
1241         u8 clear = 0, bit, port_status[15] = {0};
1242         int port_num, stat, ret, count = 0;
1243         unsigned long port;
1244         bool slave_notify = false;
1245         u8 buf, buf2[2], _buf, _buf2[2];
1246
1247         sdw_modify_slave_status(slave, SDW_SLAVE_ALERT);
1248
1249         ret = pm_runtime_get_sync(&slave->dev);
1250         if (ret < 0 && ret != -EACCES) {
1251                 dev_err(&slave->dev, "Failed to resume device: %d\n", ret);
1252                 pm_runtime_put_noidle(slave->bus->dev);
1253                 return ret;
1254         }
1255
1256         /* Read Instat 1, Instat 2 and Instat 3 registers */
1257         ret = sdw_read(slave, SDW_SCP_INT1);
1258         if (ret < 0) {
1259                 dev_err(slave->bus->dev,
1260                         "SDW_SCP_INT1 read failed:%d\n", ret);
1261                 goto io_err;
1262         }
1263         buf = ret;
1264
1265         ret = sdw_nread(slave, SDW_SCP_INTSTAT2, 2, buf2);
1266         if (ret < 0) {
1267                 dev_err(slave->bus->dev,
1268                         "SDW_SCP_INT2/3 read failed:%d\n", ret);
1269                 goto io_err;
1270         }
1271
1272         do {
1273                 /*
1274                  * Check parity, bus clash and Slave (impl defined)
1275                  * interrupt
1276                  */
1277                 if (buf & SDW_SCP_INT1_PARITY) {
1278                         dev_err(&slave->dev, "Parity error detected\n");
1279                         clear |= SDW_SCP_INT1_PARITY;
1280                 }
1281
1282                 if (buf & SDW_SCP_INT1_BUS_CLASH) {
1283                         dev_err(&slave->dev, "Bus clash error detected\n");
1284                         clear |= SDW_SCP_INT1_BUS_CLASH;
1285                 }
1286
1287                 /*
1288                  * When bus clash or parity errors are detected, such errors
1289                  * are unlikely to be recoverable errors.
1290                  * TODO: In such scenario, reset bus. Make this configurable
1291                  * via sysfs property with bus reset being the default.
1292                  */
1293
1294                 if (buf & SDW_SCP_INT1_IMPL_DEF) {
1295                         dev_dbg(&slave->dev, "Slave impl defined interrupt\n");
1296                         clear |= SDW_SCP_INT1_IMPL_DEF;
1297                         slave_notify = true;
1298                 }
1299
1300                 /* Check port 0 - 3 interrupts */
1301                 port = buf & SDW_SCP_INT1_PORT0_3;
1302
1303                 /* To get port number corresponding to bits, shift it */
1304                 port = port >> SDW_REG_SHIFT(SDW_SCP_INT1_PORT0_3);
1305                 for_each_set_bit(bit, &port, 8) {
1306                         sdw_handle_port_interrupt(slave, bit,
1307                                                   &port_status[bit]);
1308                 }
1309
1310                 /* Check if cascade 2 interrupt is present */
1311                 if (buf & SDW_SCP_INT1_SCP2_CASCADE) {
1312                         port = buf2[0] & SDW_SCP_INTSTAT2_PORT4_10;
1313                         for_each_set_bit(bit, &port, 8) {
1314                                 /* scp2 ports start from 4 */
1315                                 port_num = bit + 3;
1316                                 sdw_handle_port_interrupt(slave,
1317                                                 port_num,
1318                                                 &port_status[port_num]);
1319                         }
1320                 }
1321
1322                 /* now check last cascade */
1323                 if (buf2[0] & SDW_SCP_INTSTAT2_SCP3_CASCADE) {
1324                         port = buf2[1] & SDW_SCP_INTSTAT3_PORT11_14;
1325                         for_each_set_bit(bit, &port, 8) {
1326                                 /* scp3 ports start from 11 */
1327                                 port_num = bit + 10;
1328                                 sdw_handle_port_interrupt(slave,
1329                                                 port_num,
1330                                                 &port_status[port_num]);
1331                         }
1332                 }
1333
1334                 /* Update the Slave driver */
1335                 if (slave_notify && slave->ops &&
1336                     slave->ops->interrupt_callback) {
1337                         slave_intr.control_port = clear;
1338                         memcpy(slave_intr.port, &port_status,
1339                                sizeof(slave_intr.port));
1340
1341                         slave->ops->interrupt_callback(slave, &slave_intr);
1342                 }
1343
1344                 /* Ack interrupt */
1345                 ret = sdw_write(slave, SDW_SCP_INT1, clear);
1346                 if (ret < 0) {
1347                         dev_err(slave->bus->dev,
1348                                 "SDW_SCP_INT1 write failed:%d\n", ret);
1349                         goto io_err;
1350                 }
1351
1352                 /*
1353                  * Read status again to ensure no new interrupts arrived
1354                  * while servicing interrupts.
1355                  */
1356                 ret = sdw_read(slave, SDW_SCP_INT1);
1357                 if (ret < 0) {
1358                         dev_err(slave->bus->dev,
1359                                 "SDW_SCP_INT1 read failed:%d\n", ret);
1360                         goto io_err;
1361                 }
1362                 _buf = ret;
1363
1364                 ret = sdw_nread(slave, SDW_SCP_INTSTAT2, 2, _buf2);
1365                 if (ret < 0) {
1366                         dev_err(slave->bus->dev,
1367                                 "SDW_SCP_INT2/3 read failed:%d\n", ret);
1368                         goto io_err;
1369                 }
1370
1371                 /* Make sure no interrupts are pending */
1372                 buf &= _buf;
1373                 buf2[0] &= _buf2[0];
1374                 buf2[1] &= _buf2[1];
1375                 stat = buf || buf2[0] || buf2[1];
1376
1377                 /*
1378                  * Exit loop if Slave is continuously in ALERT state even
1379                  * after servicing the interrupt multiple times.
1380                  */
1381                 count++;
1382
1383                 /* we can get alerts while processing so keep retrying */
1384         } while (stat != 0 && count < SDW_READ_INTR_CLEAR_RETRY);
1385
1386         if (count == SDW_READ_INTR_CLEAR_RETRY)
1387                 dev_warn(slave->bus->dev, "Reached MAX_RETRY on alert read\n");
1388
1389 io_err:
1390         pm_runtime_mark_last_busy(&slave->dev);
1391         pm_runtime_put_autosuspend(&slave->dev);
1392
1393         return ret;
1394 }
1395
1396 static int sdw_update_slave_status(struct sdw_slave *slave,
1397                                    enum sdw_slave_status status)
1398 {
1399         unsigned long time;
1400
1401         if (!slave->probed) {
1402                 /*
1403                  * the slave status update is typically handled in an
1404                  * interrupt thread, which can race with the driver
1405                  * probe, e.g. when a module needs to be loaded.
1406                  *
1407                  * make sure the probe is complete before updating
1408                  * status.
1409                  */
1410                 time = wait_for_completion_timeout(&slave->probe_complete,
1411                                 msecs_to_jiffies(DEFAULT_PROBE_TIMEOUT));
1412                 if (!time) {
1413                         dev_err(&slave->dev, "Probe not complete, timed out\n");
1414                         return -ETIMEDOUT;
1415                 }
1416         }
1417
1418         if (!slave->ops || !slave->ops->update_status)
1419                 return 0;
1420
1421         return slave->ops->update_status(slave, status);
1422 }
1423
1424 /**
1425  * sdw_handle_slave_status() - Handle Slave status
1426  * @bus: SDW bus instance
1427  * @status: Status for all Slave(s)
1428  */
1429 int sdw_handle_slave_status(struct sdw_bus *bus,
1430                             enum sdw_slave_status status[])
1431 {
1432         enum sdw_slave_status prev_status;
1433         struct sdw_slave *slave;
1434         bool attached_initializing;
1435         int i, ret = 0;
1436
1437         /* first check if any Slaves fell off the bus */
1438         for (i = 1; i <= SDW_MAX_DEVICES; i++) {
1439                 mutex_lock(&bus->bus_lock);
1440                 if (test_bit(i, bus->assigned) == false) {
1441                         mutex_unlock(&bus->bus_lock);
1442                         continue;
1443                 }
1444                 mutex_unlock(&bus->bus_lock);
1445
1446                 slave = sdw_get_slave(bus, i);
1447                 if (!slave)
1448                         continue;
1449
1450                 if (status[i] == SDW_SLAVE_UNATTACHED &&
1451                     slave->status != SDW_SLAVE_UNATTACHED)
1452                         sdw_modify_slave_status(slave, SDW_SLAVE_UNATTACHED);
1453         }
1454
1455         if (status[0] == SDW_SLAVE_ATTACHED) {
1456                 dev_dbg(bus->dev, "Slave attached, programming device number\n");
1457                 ret = sdw_program_device_num(bus);
1458                 if (ret)
1459                         dev_err(bus->dev, "Slave attach failed: %d\n", ret);
1460                 /*
1461                  * programming a device number will have side effects,
1462                  * so we deal with other devices at a later time
1463                  */
1464                 return ret;
1465         }
1466
1467         /* Continue to check other slave statuses */
1468         for (i = 1; i <= SDW_MAX_DEVICES; i++) {
1469                 mutex_lock(&bus->bus_lock);
1470                 if (test_bit(i, bus->assigned) == false) {
1471                         mutex_unlock(&bus->bus_lock);
1472                         continue;
1473                 }
1474                 mutex_unlock(&bus->bus_lock);
1475
1476                 slave = sdw_get_slave(bus, i);
1477                 if (!slave)
1478                         continue;
1479
1480                 attached_initializing = false;
1481
1482                 switch (status[i]) {
1483                 case SDW_SLAVE_UNATTACHED:
1484                         if (slave->status == SDW_SLAVE_UNATTACHED)
1485                                 break;
1486
1487                         sdw_modify_slave_status(slave, SDW_SLAVE_UNATTACHED);
1488                         break;
1489
1490                 case SDW_SLAVE_ALERT:
1491                         ret = sdw_handle_slave_alerts(slave);
1492                         if (ret)
1493                                 dev_err(bus->dev,
1494                                         "Slave %d alert handling failed: %d\n",
1495                                         i, ret);
1496                         break;
1497
1498                 case SDW_SLAVE_ATTACHED:
1499                         if (slave->status == SDW_SLAVE_ATTACHED)
1500                                 break;
1501
1502                         prev_status = slave->status;
1503                         sdw_modify_slave_status(slave, SDW_SLAVE_ATTACHED);
1504
1505                         if (prev_status == SDW_SLAVE_ALERT)
1506                                 break;
1507
1508                         attached_initializing = true;
1509
1510                         ret = sdw_initialize_slave(slave);
1511                         if (ret)
1512                                 dev_err(bus->dev,
1513                                         "Slave %d initialization failed: %d\n",
1514                                         i, ret);
1515
1516                         break;
1517
1518                 default:
1519                         dev_err(bus->dev, "Invalid slave %d status:%d\n",
1520                                 i, status[i]);
1521                         break;
1522                 }
1523
1524                 ret = sdw_update_slave_status(slave, status[i]);
1525                 if (ret)
1526                         dev_err(slave->bus->dev,
1527                                 "Update Slave status failed:%d\n", ret);
1528                 if (attached_initializing)
1529                         complete(&slave->initialization_complete);
1530         }
1531
1532         return ret;
1533 }
1534 EXPORT_SYMBOL(sdw_handle_slave_status);
1535
1536 void sdw_clear_slave_status(struct sdw_bus *bus, u32 request)
1537 {
1538         struct sdw_slave *slave;
1539         int i;
1540
1541         /* Check all non-zero devices */
1542         for (i = 1; i <= SDW_MAX_DEVICES; i++) {
1543                 mutex_lock(&bus->bus_lock);
1544                 if (test_bit(i, bus->assigned) == false) {
1545                         mutex_unlock(&bus->bus_lock);
1546                         continue;
1547                 }
1548                 mutex_unlock(&bus->bus_lock);
1549
1550                 slave = sdw_get_slave(bus, i);
1551                 if (!slave)
1552                         continue;
1553
1554                 if (slave->status != SDW_SLAVE_UNATTACHED)
1555                         sdw_modify_slave_status(slave, SDW_SLAVE_UNATTACHED);
1556
1557                 /* keep track of request, used in pm_runtime resume */
1558                 slave->unattach_request = request;
1559         }
1560 }
1561 EXPORT_SYMBOL(sdw_clear_slave_status);