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 <linux/soundwire/sdw_type.h>
  11 #include "bus.h"
  12 #include "sysfs_local.h"
  13
  14 static DEFINE_IDA(sdw_bus_ida);
  15 static DEFINE_IDA(sdw_peripheral_ida);
  16
  17 static int sdw_get_id(struct sdw_bus *bus)
  18 {
  19         int rc = ida_alloc(&sdw_bus_ida, GFP_KERNEL);
  20
  21         if (rc < 0)
  22                 return rc;
  23
  24         bus->id = rc;
  25         return 0;
  26 }
  27
  28 /**
  29  * sdw_bus_master_add() - add a bus Master instance
  30  * @bus: bus instance
  31  * @parent: parent device
  32  * @fwnode: firmware node handle
  33  *
  34  * Initializes the bus instance, read properties and create child
  35  * devices.
  36  */
  37 int sdw_bus_master_add(struct sdw_bus *bus, struct device *parent,
  38                        struct fwnode_handle *fwnode)
  39 {
  40         struct sdw_master_prop *prop = NULL;
  41         int ret;
  42
  43         if (!parent) {
  44                 pr_err("SoundWire parent device is not set\n");
  45                 return -ENODEV;
  46         }
  47
  48         ret = sdw_get_id(bus);
  49         if (ret < 0) {
  50                 dev_err(parent, "Failed to get bus id\n");
  51                 return ret;
  52         }
  53
  54         ret = sdw_master_device_add(bus, parent, fwnode);
  55         if (ret < 0) {
  56                 dev_err(parent, "Failed to add master device at link %d\n",
  57                         bus->link_id);
  58                 return ret;
  59         }
  60
  61         if (!bus->ops) {
  62                 dev_err(bus->dev, "SoundWire Bus ops are not set\n");
  63                 return -EINVAL;
  64         }
  65
  66         if (!bus->compute_params) {
  67                 dev_err(bus->dev,
  68                         "Bandwidth allocation not configured, compute_params no set\n");
  69                 return -EINVAL;
  70         }
  71
  72         mutex_init(&bus->msg_lock);
  73         mutex_init(&bus->bus_lock);
  74         INIT_LIST_HEAD(&bus->slaves);
  75         INIT_LIST_HEAD(&bus->m_rt_list);
  76
  77         /*
  78          * Initialize multi_link flag
  79          */
  80         bus->multi_link = false;
  81         if (bus->ops->read_prop) {
  82                 ret = bus->ops->read_prop(bus);
  83                 if (ret < 0) {
  84                         dev_err(bus->dev,
  85                                 "Bus read properties failed:%d\n", ret);
  86                         return ret;
  87                 }
  88         }
  89
  90         sdw_bus_debugfs_init(bus);
  91
  92         /*
  93          * Device numbers in SoundWire are 0 through 15. Enumeration device
  94          * number (0), Broadcast device number (15), Group numbers (12 and
  95          * 13) and Master device number (14) are not used for assignment so
  96          * mask these and other higher bits.
  97          */
  98
  99         /* Set higher order bits */
 100         *bus->assigned = ~GENMASK(SDW_BROADCAST_DEV_NUM, SDW_ENUM_DEV_NUM);
 101
 102         /* Set enumuration device number and broadcast device number */
 103         set_bit(SDW_ENUM_DEV_NUM, bus->assigned);
 104         set_bit(SDW_BROADCAST_DEV_NUM, bus->assigned);
 105
 106         /* Set group device numbers and master device number */
 107         set_bit(SDW_GROUP12_DEV_NUM, bus->assigned);
 108         set_bit(SDW_GROUP13_DEV_NUM, bus->assigned);
 109         set_bit(SDW_MASTER_DEV_NUM, bus->assigned);
 110
 111         /*
 112          * SDW is an enumerable bus, but devices can be powered off. So,
 113          * they won't be able to report as present.
 114          *
 115          * Create Slave devices based on Slaves described in
 116          * the respective firmware (ACPI/DT)
 117          */
 118         if (IS_ENABLED(CONFIG_ACPI) && ACPI_HANDLE(bus->dev))
 119                 ret = sdw_acpi_find_slaves(bus);
 120         else if (IS_ENABLED(CONFIG_OF) && bus->dev->of_node)
 121                 ret = sdw_of_find_slaves(bus);
 122         else
 123                 ret = -ENOTSUPP; /* No ACPI/DT so error out */
 124
 125         if (ret < 0) {
 126                 dev_err(bus->dev, "Finding slaves failed:%d\n", ret);
 127                 return ret;
 128         }
 129
 130         /*
 131          * Initialize clock values based on Master properties. The max
 132          * frequency is read from max_clk_freq property. Current assumption
 133          * is that the bus will start at highest clock frequency when
 134          * powered on.
 135          *
 136          * Default active bank will be 0 as out of reset the Slaves have
 137          * to start with bank 0 (Table 40 of Spec)
 138          */
 139         prop = &bus->prop;
 140         bus->params.max_dr_freq = prop->max_clk_freq * SDW_DOUBLE_RATE_FACTOR;
 141         bus->params.curr_dr_freq = bus->params.max_dr_freq;
 142         bus->params.curr_bank = SDW_BANK0;
 143         bus->params.next_bank = SDW_BANK1;
 144
 145         return 0;
 146 }
 147 EXPORT_SYMBOL(sdw_bus_master_add);
 148
 149 static int sdw_delete_slave(struct device *dev, void *data)
 150 {
 151         struct sdw_slave *slave = dev_to_sdw_dev(dev);
 152         struct sdw_bus *bus = slave->bus;
 153
 154         pm_runtime_disable(dev);
 155
 156         sdw_slave_debugfs_exit(slave);
 157
 158         mutex_lock(&bus->bus_lock);
 159
 160         if (slave->dev_num) { /* clear dev_num if assigned */
 161                 clear_bit(slave->dev_num, bus->assigned);
 162                 if (bus->dev_num_ida_min)
 163                         ida_free(&sdw_peripheral_ida, slave->dev_num);
 164         }
 165         list_del_init(&slave->node);
 166         mutex_unlock(&bus->bus_lock);
 167
 168         device_unregister(dev);
 169         return 0;
 170 }
 171
 172 /**
 173  * sdw_bus_master_delete() - delete the bus master instance
 174  * @bus: bus to be deleted
 175  *
 176  * Remove the instance, delete the child devices.
 177  */
 178 void sdw_bus_master_delete(struct sdw_bus *bus)
 179 {
 180         device_for_each_child(bus->dev, NULL, sdw_delete_slave);
 181         sdw_master_device_del(bus);
 182
 183         sdw_bus_debugfs_exit(bus);
 184         ida_free(&sdw_bus_ida, bus->id);
 185 }
 186 EXPORT_SYMBOL(sdw_bus_master_delete);
 187
 188 /*
 189  * SDW IO Calls
 190  */
 191
 192 static inline int find_response_code(enum sdw_command_response resp)
 193 {
 194         switch (resp) {
 195         case SDW_CMD_OK:
 196                 return 0;
 197
 198         case SDW_CMD_IGNORED:
 199                 return -ENODATA;
 200
 201         case SDW_CMD_TIMEOUT:
 202                 return -ETIMEDOUT;
 203
 204         default:
 205                 return -EIO;
 206         }
 207 }
 208
 209 static inline int do_transfer(struct sdw_bus *bus, struct sdw_msg *msg)
 210 {
 211         int retry = bus->prop.err_threshold;
 212         enum sdw_command_response resp;
 213         int ret = 0, i;
 214
 215         for (i = 0; i <= retry; i++) {
 216                 resp = bus->ops->xfer_msg(bus, msg);
 217                 ret = find_response_code(resp);
 218
 219                 /* if cmd is ok or ignored return */
 220                 if (ret == 0 || ret == -ENODATA)
 221                         return ret;
 222         }
 223
 224         return ret;
 225 }
 226
 227 static inline int do_transfer_defer(struct sdw_bus *bus,
 228                                     struct sdw_msg *msg)
 229 {
 230         struct sdw_defer *defer = &bus->defer_msg;
 231         int retry = bus->prop.err_threshold;
 232         enum sdw_command_response resp;
 233         int ret = 0, i;
 234
 235         defer->msg = msg;
 236         defer->length = msg->len;
 237         init_completion(&defer->complete);
 238
 239         for (i = 0; i <= retry; i++) {
 240                 resp = bus->ops->xfer_msg_defer(bus);
 241                 ret = find_response_code(resp);
 242                 /* if cmd is ok or ignored return */
 243                 if (ret == 0 || ret == -ENODATA)
 244                         return ret;
 245         }
 246
 247         return ret;
 248 }
 249
 250 static int sdw_transfer_unlocked(struct sdw_bus *bus, struct sdw_msg *msg)
 251 {
 252         int ret;
 253
 254         ret = do_transfer(bus, msg);
 255         if (ret != 0 && ret != -ENODATA)
 256                 dev_err(bus->dev, "trf on Slave %d failed:%d %s addr %x count %d\n",
 257                         msg->dev_num, ret,
 258                         (msg->flags & SDW_MSG_FLAG_WRITE) ? "write" : "read",
 259                         msg->addr, msg->len);
 260
 261         return ret;
 262 }
 263
 264 /**
 265  * sdw_transfer() - Synchronous transfer message to a SDW Slave device
 266  * @bus: SDW bus
 267  * @msg: SDW message to be xfered
 268  */
 269 int sdw_transfer(struct sdw_bus *bus, struct sdw_msg *msg)
 270 {
 271         int ret;
 272
 273         mutex_lock(&bus->msg_lock);
 274
 275         ret = sdw_transfer_unlocked(bus, msg);
 276
 277         mutex_unlock(&bus->msg_lock);
 278
 279         return ret;
 280 }
 281
 282 /**
 283  * sdw_show_ping_status() - Direct report of PING status, to be used by Peripheral drivers
 284  * @bus: SDW bus
 285  * @sync_delay: Delay before reading status
 286  */
 287 void sdw_show_ping_status(struct sdw_bus *bus, bool sync_delay)
 288 {
 289         u32 status;
 290
 291         if (!bus->ops->read_ping_status)
 292                 return;
 293
 294         /*
 295          * wait for peripheral to sync if desired. 10-15ms should be more than
 296          * enough in most cases.
 297          */
 298         if (sync_delay)
 299                 usleep_range(10000, 15000);
 300
 301         mutex_lock(&bus->msg_lock);
 302
 303         status = bus->ops->read_ping_status(bus);
 304
 305         mutex_unlock(&bus->msg_lock);
 306
 307         if (!status)
 308                 dev_warn(bus->dev, "%s: no peripherals attached\n", __func__);
 309         else
 310                 dev_dbg(bus->dev, "PING status: %#x\n", status);
 311 }
 312 EXPORT_SYMBOL(sdw_show_ping_status);
 313
 314 /**
 315  * sdw_transfer_defer() - Asynchronously transfer message to a SDW Slave device
 316  * @bus: SDW bus
 317  * @msg: SDW message to be xfered
 318  *
 319  * Caller needs to hold the msg_lock lock while calling this
 320  */
 321 int sdw_transfer_defer(struct sdw_bus *bus, struct sdw_msg *msg)
 322 {
 323         int ret;
 324
 325         if (!bus->ops->xfer_msg_defer)
 326                 return -ENOTSUPP;
 327
 328         ret = do_transfer_defer(bus, msg);
 329         if (ret != 0 && ret != -ENODATA)
 330                 dev_err(bus->dev, "Defer trf on Slave %d failed:%d\n",
 331                         msg->dev_num, ret);
 332
 333         return ret;
 334 }
 335
 336 int sdw_fill_msg(struct sdw_msg *msg, struct sdw_slave *slave,
 337                  u32 addr, size_t count, u16 dev_num, u8 flags, u8 *buf)
 338 {
 339         memset(msg, 0, sizeof(*msg));
 340         msg->addr = addr; /* addr is 16 bit and truncated here */
 341         msg->len = count;
 342         msg->dev_num = dev_num;
 343         msg->flags = flags;
 344         msg->buf = buf;
 345
 346         if (addr < SDW_REG_NO_PAGE) /* no paging area */
 347                 return 0;
 348
 349         if (addr >= SDW_REG_MAX) { /* illegal addr */
 350                 pr_err("SDW: Invalid address %x passed\n", addr);
 351                 return -EINVAL;
 352         }
 353
 354         if (addr < SDW_REG_OPTIONAL_PAGE) { /* 32k but no page */
 355                 if (slave && !slave->prop.paging_support)
 356                         return 0;
 357                 /* no need for else as that will fall-through to paging */
 358         }
 359
 360         /* paging mandatory */
 361         if (dev_num == SDW_ENUM_DEV_NUM || dev_num == SDW_BROADCAST_DEV_NUM) {
 362                 pr_err("SDW: Invalid device for paging :%d\n", dev_num);
 363                 return -EINVAL;
 364         }
 365
 366         if (!slave) {
 367                 pr_err("SDW: No slave for paging addr\n");
 368                 return -EINVAL;
 369         }
 370
 371         if (!slave->prop.paging_support) {
 372                 dev_err(&slave->dev,
 373                         "address %x needs paging but no support\n", addr);
 374                 return -EINVAL;
 375         }
 376
 377         msg->addr_page1 = FIELD_GET(SDW_SCP_ADDRPAGE1_MASK, addr);
 378         msg->addr_page2 = FIELD_GET(SDW_SCP_ADDRPAGE2_MASK, addr);
 379         msg->addr |= BIT(15);
 380         msg->page = true;
 381
 382         return 0;
 383 }
 384
 385 /*
 386  * Read/Write IO functions.
 387  */
 388
 389 int sdw_nread_no_pm(struct sdw_slave *slave, u32 addr, size_t count, u8 *val)
 390 {
 391         struct sdw_msg msg;
 392         int ret;
 393
 394         ret = sdw_fill_msg(&msg, slave, addr, count,
 395                            slave->dev_num, SDW_MSG_FLAG_READ, val);
 396         if (ret < 0)
 397                 return ret;
 398
 399         ret = sdw_transfer(slave->bus, &msg);
 400         if (slave->is_mockup_device)
 401                 ret = 0;
 402         return ret;
 403 }
 404 EXPORT_SYMBOL(sdw_nread_no_pm);
 405
 406 int sdw_nwrite_no_pm(struct sdw_slave *slave, u32 addr, size_t count, const u8 *val)
 407 {
 408         struct sdw_msg msg;
 409         int ret;
 410
 411         ret = sdw_fill_msg(&msg, slave, addr, count,
 412                            slave->dev_num, SDW_MSG_FLAG_WRITE, (u8 *)val);
 413         if (ret < 0)
 414                 return ret;
 415
 416         ret = sdw_transfer(slave->bus, &msg);
 417         if (slave->is_mockup_device)
 418                 ret = 0;
 419         return ret;
 420 }
 421 EXPORT_SYMBOL(sdw_nwrite_no_pm);
 422
 423 int sdw_write_no_pm(struct sdw_slave *slave, u32 addr, u8 value)
 424 {
 425         return sdw_nwrite_no_pm(slave, addr, 1, &value);
 426 }
 427 EXPORT_SYMBOL(sdw_write_no_pm);
 428
 429 static int
 430 sdw_bread_no_pm(struct sdw_bus *bus, u16 dev_num, u32 addr)
 431 {
 432         struct sdw_msg msg;
 433         u8 buf;
 434         int ret;
 435
 436         ret = sdw_fill_msg(&msg, NULL, addr, 1, dev_num,
 437                            SDW_MSG_FLAG_READ, &buf);
 438         if (ret < 0)
 439                 return ret;
 440
 441         ret = sdw_transfer(bus, &msg);
 442         if (ret < 0)
 443                 return ret;
 444
 445         return buf;
 446 }
 447
 448 static int
 449 sdw_bwrite_no_pm(struct sdw_bus *bus, u16 dev_num, u32 addr, u8 value)
 450 {
 451         struct sdw_msg msg;
 452         int ret;
 453
 454         ret = sdw_fill_msg(&msg, NULL, addr, 1, dev_num,
 455                            SDW_MSG_FLAG_WRITE, &value);
 456         if (ret < 0)
 457                 return ret;
 458
 459         return sdw_transfer(bus, &msg);
 460 }
 461
 462 int sdw_bread_no_pm_unlocked(struct sdw_bus *bus, u16 dev_num, u32 addr)
 463 {
 464         struct sdw_msg msg;
 465         u8 buf;
 466         int ret;
 467
 468         ret = sdw_fill_msg(&msg, NULL, addr, 1, dev_num,
 469                            SDW_MSG_FLAG_READ, &buf);
 470         if (ret < 0)
 471                 return ret;
 472
 473         ret = sdw_transfer_unlocked(bus, &msg);
 474         if (ret < 0)
 475                 return ret;
 476
 477         return buf;
 478 }
 479 EXPORT_SYMBOL(sdw_bread_no_pm_unlocked);
 480
 481 int sdw_bwrite_no_pm_unlocked(struct sdw_bus *bus, u16 dev_num, u32 addr, u8 value)
 482 {
 483         struct sdw_msg msg;
 484         int ret;
 485
 486         ret = sdw_fill_msg(&msg, NULL, addr, 1, dev_num,
 487                            SDW_MSG_FLAG_WRITE, &value);
 488         if (ret < 0)
 489                 return ret;
 490
 491         return sdw_transfer_unlocked(bus, &msg);
 492 }
 493 EXPORT_SYMBOL(sdw_bwrite_no_pm_unlocked);
 494
 495 int sdw_read_no_pm(struct sdw_slave *slave, u32 addr)
 496 {
 497         u8 buf;
 498         int ret;
 499
 500         ret = sdw_nread_no_pm(slave, addr, 1, &buf);
 501         if (ret < 0)
 502                 return ret;
 503         else
 504                 return buf;
 505 }
 506 EXPORT_SYMBOL(sdw_read_no_pm);
 507
 508 int sdw_update_no_pm(struct sdw_slave *slave, u32 addr, u8 mask, u8 val)
 509 {
 510         int tmp;
 511
 512         tmp = sdw_read_no_pm(slave, addr);
 513         if (tmp < 0)
 514                 return tmp;
 515
 516         tmp = (tmp & ~mask) | val;
 517         return sdw_write_no_pm(slave, addr, tmp);
 518 }
 519 EXPORT_SYMBOL(sdw_update_no_pm);
 520
 521 /* Read-Modify-Write Slave register */
 522 int sdw_update(struct sdw_slave *slave, u32 addr, u8 mask, u8 val)
 523 {
 524         int tmp;
 525
 526         tmp = sdw_read(slave, addr);
 527         if (tmp < 0)
 528                 return tmp;
 529
 530         tmp = (tmp & ~mask) | val;
 531         return sdw_write(slave, addr, tmp);
 532 }
 533 EXPORT_SYMBOL(sdw_update);
 534
 535 /**
 536  * sdw_nread() - Read "n" contiguous SDW Slave registers
 537  * @slave: SDW Slave
 538  * @addr: Register address
 539  * @count: length
 540  * @val: Buffer for values to be read
 541  */
 542 int sdw_nread(struct sdw_slave *slave, u32 addr, size_t count, u8 *val)
 543 {
 544         int ret;
 545
 546         ret = pm_runtime_resume_and_get(&slave->dev);
 547         if (ret < 0 && ret != -EACCES)
 548                 return ret;
 549
 550         ret = sdw_nread_no_pm(slave, addr, count, val);
 551
 552         pm_runtime_mark_last_busy(&slave->dev);
 553         pm_runtime_put(&slave->dev);
 554
 555         return ret;
 556 }
 557 EXPORT_SYMBOL(sdw_nread);
 558
 559 /**
 560  * sdw_nwrite() - Write "n" contiguous SDW Slave registers
 561  * @slave: SDW Slave
 562  * @addr: Register address
 563  * @count: length
 564  * @val: Buffer for values to be written
 565  */
 566 int sdw_nwrite(struct sdw_slave *slave, u32 addr, size_t count, const u8 *val)
 567 {
 568         int ret;
 569
 570         ret = pm_runtime_resume_and_get(&slave->dev);
 571         if (ret < 0 && ret != -EACCES)
 572                 return ret;
 573
 574         ret = sdw_nwrite_no_pm(slave, addr, count, val);
 575
 576         pm_runtime_mark_last_busy(&slave->dev);
 577         pm_runtime_put(&slave->dev);
 578
 579         return ret;
 580 }
 581 EXPORT_SYMBOL(sdw_nwrite);
 582
 583 /**
 584  * sdw_read() - Read a SDW Slave register
 585  * @slave: SDW Slave
 586  * @addr: Register address
 587  */
 588 int sdw_read(struct sdw_slave *slave, u32 addr)
 589 {
 590         u8 buf;
 591         int ret;
 592
 593         ret = sdw_nread(slave, addr, 1, &buf);
 594         if (ret < 0)
 595                 return ret;
 596
 597         return buf;
 598 }
 599 EXPORT_SYMBOL(sdw_read);
 600
 601 /**
 602  * sdw_write() - Write a SDW Slave register
 603  * @slave: SDW Slave
 604  * @addr: Register address
 605  * @value: Register value
 606  */
 607 int sdw_write(struct sdw_slave *slave, u32 addr, u8 value)
 608 {
 609         return sdw_nwrite(slave, addr, 1, &value);
 610 }
 611 EXPORT_SYMBOL(sdw_write);
 612
 613 /*
 614  * SDW alert handling
 615  */
 616
 617 /* called with bus_lock held */
 618 static struct sdw_slave *sdw_get_slave(struct sdw_bus *bus, int i)
 619 {
 620         struct sdw_slave *slave;
 621
 622         list_for_each_entry(slave, &bus->slaves, node) {
 623                 if (slave->dev_num == i)
 624                         return slave;
 625         }
 626
 627         return NULL;
 628 }
 629
 630 int sdw_compare_devid(struct sdw_slave *slave, struct sdw_slave_id id)
 631 {
 632         if (slave->id.mfg_id != id.mfg_id ||
 633             slave->id.part_id != id.part_id ||
 634             slave->id.class_id != id.class_id ||
 635             (slave->id.unique_id != SDW_IGNORED_UNIQUE_ID &&
 636              slave->id.unique_id != id.unique_id))
 637                 return -ENODEV;
 638
 639         return 0;
 640 }
 641 EXPORT_SYMBOL(sdw_compare_devid);
 642
 643 /* called with bus_lock held */
 644 static int sdw_get_device_num(struct sdw_slave *slave)
 645 {
 646         int bit;
 647
 648         if (slave->bus->dev_num_ida_min) {
 649                 bit = ida_alloc_range(&sdw_peripheral_ida,
 650                                       slave->bus->dev_num_ida_min, SDW_MAX_DEVICES,
 651                                       GFP_KERNEL);
 652                 if (bit < 0)
 653                         goto err;
 654         } else {
 655                 bit = find_first_zero_bit(slave->bus->assigned, SDW_MAX_DEVICES);
 656                 if (bit == SDW_MAX_DEVICES) {
 657                         bit = -ENODEV;
 658                         goto err;
 659                 }
 660         }
 661
 662         /*
 663          * Do not update dev_num in Slave data structure here,
 664          * Update once program dev_num is successful
 665          */
 666         set_bit(bit, slave->bus->assigned);
 667
 668 err:
 669         return bit;
 670 }
 671
 672 static int sdw_assign_device_num(struct sdw_slave *slave)
 673 {
 674         struct sdw_bus *bus = slave->bus;
 675         int ret, dev_num;
 676         bool new_device = false;
 677
 678         /* check first if device number is assigned, if so reuse that */
 679         if (!slave->dev_num) {
 680                 if (!slave->dev_num_sticky) {
 681                         mutex_lock(&slave->bus->bus_lock);
 682                         dev_num = sdw_get_device_num(slave);
 683                         mutex_unlock(&slave->bus->bus_lock);
 684                         if (dev_num < 0) {
 685                                 dev_err(bus->dev, "Get dev_num failed: %d\n",
 686                                         dev_num);
 687                                 return dev_num;
 688                         }
 689                         slave->dev_num = dev_num;
 690                         slave->dev_num_sticky = dev_num;
 691                         new_device = true;
 692                 } else {
 693                         slave->dev_num = slave->dev_num_sticky;
 694                 }
 695         }
 696
 697         if (!new_device)
 698                 dev_dbg(bus->dev,
 699                         "Slave already registered, reusing dev_num:%d\n",
 700                         slave->dev_num);
 701
 702         /* Clear the slave->dev_num to transfer message on device 0 */
 703         dev_num = slave->dev_num;
 704         slave->dev_num = 0;
 705
 706         ret = sdw_write_no_pm(slave, SDW_SCP_DEVNUMBER, dev_num);
 707         if (ret < 0) {
 708                 dev_err(bus->dev, "Program device_num %d failed: %d\n",
 709                         dev_num, ret);
 710                 return ret;
 711         }
 712
 713         /* After xfer of msg, restore dev_num */
 714         slave->dev_num = slave->dev_num_sticky;
 715
 716         return 0;
 717 }
 718
 719 void sdw_extract_slave_id(struct sdw_bus *bus,
 720                           u64 addr, struct sdw_slave_id *id)
 721 {
 722         dev_dbg(bus->dev, "SDW Slave Addr: %llx\n", addr);
 723
 724         id->sdw_version = SDW_VERSION(addr);
 725         id->unique_id = SDW_UNIQUE_ID(addr);
 726         id->mfg_id = SDW_MFG_ID(addr);
 727         id->part_id = SDW_PART_ID(addr);
 728         id->class_id = SDW_CLASS_ID(addr);
 729
 730         dev_dbg(bus->dev,
 731                 "SDW Slave class_id 0x%02x, mfg_id 0x%04x, part_id 0x%04x, unique_id 0x%x, version 0x%x\n",
 732                 id->class_id, id->mfg_id, id->part_id, id->unique_id, id->sdw_version);
 733 }
 734 EXPORT_SYMBOL(sdw_extract_slave_id);
 735
 736 static int sdw_program_device_num(struct sdw_bus *bus, bool *programmed)
 737 {
 738         u8 buf[SDW_NUM_DEV_ID_REGISTERS] = {0};
 739         struct sdw_slave *slave, *_s;
 740         struct sdw_slave_id id;
 741         struct sdw_msg msg;
 742         bool found;
 743         int count = 0, ret;
 744         u64 addr;
 745
 746         *programmed = false;
 747
 748         /* No Slave, so use raw xfer api */
 749         ret = sdw_fill_msg(&msg, NULL, SDW_SCP_DEVID_0,
 750                            SDW_NUM_DEV_ID_REGISTERS, 0, SDW_MSG_FLAG_READ, buf);
 751         if (ret < 0)
 752                 return ret;
 753
 754         do {
 755                 ret = sdw_transfer(bus, &msg);
 756                 if (ret == -ENODATA) { /* end of device id reads */
 757                         dev_dbg(bus->dev, "No more devices to enumerate\n");
 758                         ret = 0;
 759                         break;
 760                 }
 761                 if (ret < 0) {
 762                         dev_err(bus->dev, "DEVID read fail:%d\n", ret);
 763                         break;
 764                 }
 765
 766                 /*
 767                  * Construct the addr and extract. Cast the higher shift
 768                  * bits to avoid truncation due to size limit.
 769                  */
 770                 addr = buf[5] | (buf[4] << 8) | (buf[3] << 16) |
 771                         ((u64)buf[2] << 24) | ((u64)buf[1] << 32) |
 772                         ((u64)buf[0] << 40);
 773
 774                 sdw_extract_slave_id(bus, addr, &id);
 775
 776                 found = false;
 777                 /* Now compare with entries */
 778                 list_for_each_entry_safe(slave, _s, &bus->slaves, node) {
 779                         if (sdw_compare_devid(slave, id) == 0) {
 780                                 found = true;
 781
 782                                 /*
 783                                  * To prevent skipping state-machine stages don't
 784                                  * program a device until we've seen it UNATTACH.
 785                                  * Must return here because no other device on #0
 786                                  * can be detected until this one has been
 787                                  * assigned a device ID.
 788                                  */
 789                                 if (slave->status != SDW_SLAVE_UNATTACHED)
 790                                         return 0;
 791
 792                                 /*
 793                                  * Assign a new dev_num to this Slave and
 794                                  * not mark it present. It will be marked
 795                                  * present after it reports ATTACHED on new
 796                                  * dev_num
 797                                  */
 798                                 ret = sdw_assign_device_num(slave);
 799                                 if (ret < 0) {
 800                                         dev_err(bus->dev,
 801                                                 "Assign dev_num failed:%d\n",
 802                                                 ret);
 803                                         return ret;
 804                                 }
 805
 806                                 *programmed = true;
 807
 808                                 break;
 809                         }
 810                 }
 811
 812                 if (!found) {
 813                         /* TODO: Park this device in Group 13 */
 814
 815                         /*
 816                          * add Slave device even if there is no platform
 817                          * firmware description. There will be no driver probe
 818                          * but the user/integration will be able to see the
 819                          * device, enumeration status and device number in sysfs
 820                          */
 821                         sdw_slave_add(bus, &id, NULL);
 822
 823                         dev_err(bus->dev, "Slave Entry not found\n");
 824                 }
 825
 826                 count++;
 827
 828                 /*
 829                  * Check till error out or retry (count) exhausts.
 830                  * Device can drop off and rejoin during enumeration
 831                  * so count till twice the bound.
 832                  */
 833
 834         } while (ret == 0 && count < (SDW_MAX_DEVICES * 2));
 835
 836         return ret;
 837 }
 838
 839 static void sdw_modify_slave_status(struct sdw_slave *slave,
 840                                     enum sdw_slave_status status)
 841 {
 842         struct sdw_bus *bus = slave->bus;
 843
 844         mutex_lock(&bus->bus_lock);
 845
 846         dev_vdbg(bus->dev,
 847                  "changing status slave %d status %d new status %d\n",
 848                  slave->dev_num, slave->status, status);
 849
 850         if (status == SDW_SLAVE_UNATTACHED) {
 851                 dev_dbg(&slave->dev,
 852                         "initializing enumeration and init completion for Slave %d\n",
 853                         slave->dev_num);
 854
 855                 init_completion(&slave->enumeration_complete);
 856                 init_completion(&slave->initialization_complete);
 857
 858         } else if ((status == SDW_SLAVE_ATTACHED) &&
 859                    (slave->status == SDW_SLAVE_UNATTACHED)) {
 860                 dev_dbg(&slave->dev,
 861                         "signaling enumeration completion for Slave %d\n",
 862                         slave->dev_num);
 863
 864                 complete(&slave->enumeration_complete);
 865         }
 866         slave->status = status;
 867         mutex_unlock(&bus->bus_lock);
 868 }
 869
 870 static int sdw_slave_clk_stop_callback(struct sdw_slave *slave,
 871                                        enum sdw_clk_stop_mode mode,
 872                                        enum sdw_clk_stop_type type)
 873 {
 874         int ret = 0;
 875
 876         mutex_lock(&slave->sdw_dev_lock);
 877
 878         if (slave->probed)  {
 879                 struct device *dev = &slave->dev;
 880                 struct sdw_driver *drv = drv_to_sdw_driver(dev->driver);
 881
 882                 if (drv->ops && drv->ops->clk_stop)
 883                         ret = drv->ops->clk_stop(slave, mode, type);
 884         }
 885
 886         mutex_unlock(&slave->sdw_dev_lock);
 887
 888         return ret;
 889 }
 890
 891 static int sdw_slave_clk_stop_prepare(struct sdw_slave *slave,
 892                                       enum sdw_clk_stop_mode mode,
 893                                       bool prepare)
 894 {
 895         bool wake_en;
 896         u32 val = 0;
 897         int ret;
 898
 899         wake_en = slave->prop.wake_capable;
 900
 901         if (prepare) {
 902                 val = SDW_SCP_SYSTEMCTRL_CLK_STP_PREP;
 903
 904                 if (mode == SDW_CLK_STOP_MODE1)
 905                         val |= SDW_SCP_SYSTEMCTRL_CLK_STP_MODE1;
 906
 907                 if (wake_en)
 908                         val |= SDW_SCP_SYSTEMCTRL_WAKE_UP_EN;
 909         } else {
 910                 ret = sdw_read_no_pm(slave, SDW_SCP_SYSTEMCTRL);
 911                 if (ret < 0) {
 912                         if (ret != -ENODATA)
 913                                 dev_err(&slave->dev, "SDW_SCP_SYSTEMCTRL read failed:%d\n", ret);
 914                         return ret;
 915                 }
 916                 val = ret;
 917                 val &= ~(SDW_SCP_SYSTEMCTRL_CLK_STP_PREP);
 918         }
 919
 920         ret = sdw_write_no_pm(slave, SDW_SCP_SYSTEMCTRL, val);
 921
 922         if (ret < 0 && ret != -ENODATA)
 923                 dev_err(&slave->dev, "SDW_SCP_SYSTEMCTRL write failed:%d\n", ret);
 924
 925         return ret;
 926 }
 927
 928 static int sdw_bus_wait_for_clk_prep_deprep(struct sdw_bus *bus, u16 dev_num)
 929 {
 930         int retry = bus->clk_stop_timeout;
 931         int val;
 932
 933         do {
 934                 val = sdw_bread_no_pm(bus, dev_num, SDW_SCP_STAT);
 935                 if (val < 0) {
 936                         if (val != -ENODATA)
 937                                 dev_err(bus->dev, "SDW_SCP_STAT bread failed:%d\n", val);
 938                         return val;
 939                 }
 940                 val &= SDW_SCP_STAT_CLK_STP_NF;
 941                 if (!val) {
 942                         dev_dbg(bus->dev, "clock stop prep/de-prep done slave:%d\n",
 943                                 dev_num);
 944                         return 0;
 945                 }
 946
 947                 usleep_range(1000, 1500);
 948                 retry--;
 949         } while (retry);
 950
 951         dev_err(bus->dev, "clock stop prep/de-prep failed slave:%d\n",
 952                 dev_num);
 953
 954         return -ETIMEDOUT;
 955 }
 956
 957 /**
 958  * sdw_bus_prep_clk_stop: prepare Slave(s) for clock stop
 959  *
 960  * @bus: SDW bus instance
 961  *
 962  * Query Slave for clock stop mode and prepare for that mode.
 963  */
 964 int sdw_bus_prep_clk_stop(struct sdw_bus *bus)
 965 {
 966         bool simple_clk_stop = true;
 967         struct sdw_slave *slave;
 968         bool is_slave = false;
 969         int ret = 0;
 970
 971         /*
 972          * In order to save on transition time, prepare
 973          * each Slave and then wait for all Slave(s) to be
 974          * prepared for clock stop.
 975          * If one of the Slave devices has lost sync and
 976          * replies with Command Ignored/-ENODATA, we continue
 977          * the loop
 978          */
 979         list_for_each_entry(slave, &bus->slaves, node) {
 980                 if (!slave->dev_num)
 981                         continue;
 982
 983                 if (slave->status != SDW_SLAVE_ATTACHED &&
 984                     slave->status != SDW_SLAVE_ALERT)
 985                         continue;
 986
 987                 /* Identify if Slave(s) are available on Bus */
 988                 is_slave = true;
 989
 990                 ret = sdw_slave_clk_stop_callback(slave,
 991                                                   SDW_CLK_STOP_MODE0,
 992                                                   SDW_CLK_PRE_PREPARE);
 993                 if (ret < 0 && ret != -ENODATA) {
 994                         dev_err(&slave->dev, "clock stop pre-prepare cb failed:%d\n", ret);
 995                         return ret;
 996                 }
 997
 998                 /* Only prepare a Slave device if needed */
 999                 if (!slave->prop.simple_clk_stop_capable) {
1000                         simple_clk_stop = false;
1001
1002                         ret = sdw_slave_clk_stop_prepare(slave,
1003                                                          SDW_CLK_STOP_MODE0,
1004                                                          true);
1005                         if (ret < 0 && ret != -ENODATA) {
1006                                 dev_err(&slave->dev, "clock stop prepare failed:%d\n", ret);
1007                                 return ret;
1008                         }
1009                 }
1010         }
1011
1012         /* Skip remaining clock stop preparation if no Slave is attached */
1013         if (!is_slave)
1014                 return 0;
1015
1016         /*
1017          * Don't wait for all Slaves to be ready if they follow the simple
1018          * state machine
1019          */
1020         if (!simple_clk_stop) {
1021                 ret = sdw_bus_wait_for_clk_prep_deprep(bus,
1022                                                        SDW_BROADCAST_DEV_NUM);
1023                 /*
1024                  * if there are no Slave devices present and the reply is
1025                  * Command_Ignored/-ENODATA, we don't need to continue with the
1026                  * flow and can just return here. The error code is not modified
1027                  * and its handling left as an exercise for the caller.
1028                  */
1029                 if (ret < 0)
1030                         return ret;
1031         }
1032
1033         /* Inform slaves that prep is done */
1034         list_for_each_entry(slave, &bus->slaves, node) {
1035                 if (!slave->dev_num)
1036                         continue;
1037
1038                 if (slave->status != SDW_SLAVE_ATTACHED &&
1039                     slave->status != SDW_SLAVE_ALERT)
1040                         continue;
1041
1042                 ret = sdw_slave_clk_stop_callback(slave,
1043                                                   SDW_CLK_STOP_MODE0,
1044                                                   SDW_CLK_POST_PREPARE);
1045
1046                 if (ret < 0 && ret != -ENODATA) {
1047                         dev_err(&slave->dev, "clock stop post-prepare cb failed:%d\n", ret);
1048                         return ret;
1049                 }
1050         }
1051
1052         return 0;
1053 }
1054 EXPORT_SYMBOL(sdw_bus_prep_clk_stop);
1055
1056 /**
1057  * sdw_bus_clk_stop: stop bus clock
1058  *
1059  * @bus: SDW bus instance
1060  *
1061  * After preparing the Slaves for clock stop, stop the clock by broadcasting
1062  * write to SCP_CTRL register.
1063  */
1064 int sdw_bus_clk_stop(struct sdw_bus *bus)
1065 {
1066         int ret;
1067
1068         /*
1069          * broadcast clock stop now, attached Slaves will ACK this,
1070          * unattached will ignore
1071          */
1072         ret = sdw_bwrite_no_pm(bus, SDW_BROADCAST_DEV_NUM,
1073                                SDW_SCP_CTRL, SDW_SCP_CTRL_CLK_STP_NOW);
1074         if (ret < 0) {
1075                 if (ret != -ENODATA)
1076                         dev_err(bus->dev, "ClockStopNow Broadcast msg failed %d\n", ret);
1077                 return ret;
1078         }
1079
1080         return 0;
1081 }
1082 EXPORT_SYMBOL(sdw_bus_clk_stop);
1083
1084 /**
1085  * sdw_bus_exit_clk_stop: Exit clock stop mode
1086  *
1087  * @bus: SDW bus instance
1088  *
1089  * This De-prepares the Slaves by exiting Clock Stop Mode 0. For the Slaves
1090  * exiting Clock Stop Mode 1, they will be de-prepared after they enumerate
1091  * back.
1092  */
1093 int sdw_bus_exit_clk_stop(struct sdw_bus *bus)
1094 {
1095         bool simple_clk_stop = true;
1096         struct sdw_slave *slave;
1097         bool is_slave = false;
1098         int ret;
1099
1100         /*
1101          * In order to save on transition time, de-prepare
1102          * each Slave and then wait for all Slave(s) to be
1103          * de-prepared after clock resume.
1104          */
1105         list_for_each_entry(slave, &bus->slaves, node) {
1106                 if (!slave->dev_num)
1107                         continue;
1108
1109                 if (slave->status != SDW_SLAVE_ATTACHED &&
1110                     slave->status != SDW_SLAVE_ALERT)
1111                         continue;
1112
1113                 /* Identify if Slave(s) are available on Bus */
1114                 is_slave = true;
1115
1116                 ret = sdw_slave_clk_stop_callback(slave, SDW_CLK_STOP_MODE0,
1117                                                   SDW_CLK_PRE_DEPREPARE);
1118                 if (ret < 0)
1119                         dev_warn(&slave->dev, "clock stop pre-deprepare cb failed:%d\n", ret);
1120
1121                 /* Only de-prepare a Slave device if needed */
1122                 if (!slave->prop.simple_clk_stop_capable) {
1123                         simple_clk_stop = false;
1124
1125                         ret = sdw_slave_clk_stop_prepare(slave, SDW_CLK_STOP_MODE0,
1126                                                          false);
1127
1128                         if (ret < 0)
1129                                 dev_warn(&slave->dev, "clock stop deprepare failed:%d\n", ret);
1130                 }
1131         }
1132
1133         /* Skip remaining clock stop de-preparation if no Slave is attached */
1134         if (!is_slave)
1135                 return 0;
1136
1137         /*
1138          * Don't wait for all Slaves to be ready if they follow the simple
1139          * state machine
1140          */
1141         if (!simple_clk_stop) {
1142                 ret = sdw_bus_wait_for_clk_prep_deprep(bus, SDW_BROADCAST_DEV_NUM);
1143                 if (ret < 0)
1144                         dev_warn(bus->dev, "clock stop deprepare wait failed:%d\n", ret);
1145         }
1146
1147         list_for_each_entry(slave, &bus->slaves, node) {
1148                 if (!slave->dev_num)
1149                         continue;
1150
1151                 if (slave->status != SDW_SLAVE_ATTACHED &&
1152                     slave->status != SDW_SLAVE_ALERT)
1153                         continue;
1154
1155                 ret = sdw_slave_clk_stop_callback(slave, SDW_CLK_STOP_MODE0,
1156                                                   SDW_CLK_POST_DEPREPARE);
1157                 if (ret < 0)
1158                         dev_warn(&slave->dev, "clock stop post-deprepare cb failed:%d\n", ret);
1159         }
1160
1161         return 0;
1162 }
1163 EXPORT_SYMBOL(sdw_bus_exit_clk_stop);
1164
1165 int sdw_configure_dpn_intr(struct sdw_slave *slave,
1166                            int port, bool enable, int mask)
1167 {
1168         u32 addr;
1169         int ret;
1170         u8 val = 0;
1171
1172         if (slave->bus->params.s_data_mode != SDW_PORT_DATA_MODE_NORMAL) {
1173                 dev_dbg(&slave->dev, "TEST FAIL interrupt %s\n",
1174                         enable ? "on" : "off");
1175                 mask |= SDW_DPN_INT_TEST_FAIL;
1176         }
1177
1178         addr = SDW_DPN_INTMASK(port);
1179
1180         /* Set/Clear port ready interrupt mask */
1181         if (enable) {
1182                 val |= mask;
1183                 val |= SDW_DPN_INT_PORT_READY;
1184         } else {
1185                 val &= ~(mask);
1186                 val &= ~SDW_DPN_INT_PORT_READY;
1187         }
1188
1189         ret = sdw_update_no_pm(slave, addr, (mask | SDW_DPN_INT_PORT_READY), val);
1190         if (ret < 0)
1191                 dev_err(&slave->dev,
1192                         "SDW_DPN_INTMASK write failed:%d\n", val);
1193
1194         return ret;
1195 }
1196
1197 static int sdw_slave_set_frequency(struct sdw_slave *slave)
1198 {
1199         u32 mclk_freq = slave->bus->prop.mclk_freq;
1200         u32 curr_freq = slave->bus->params.curr_dr_freq >> 1;
1201         unsigned int scale;
1202         u8 scale_index;
1203         u8 base;
1204         int ret;
1205
1206         /*
1207          * frequency base and scale registers are required for SDCA
1208          * devices. They may also be used for 1.2+/non-SDCA devices.
1209          * Driver can set the property, we will need a DisCo property
1210          * to discover this case from platform firmware.
1211          */
1212         if (!slave->id.class_id && !slave->prop.clock_reg_supported)
1213                 return 0;
1214
1215         if (!mclk_freq) {
1216                 dev_err(&slave->dev,
1217                         "no bus MCLK, cannot set SDW_SCP_BUS_CLOCK_BASE\n");
1218                 return -EINVAL;
1219         }
1220
1221         /*
1222          * map base frequency using Table 89 of SoundWire 1.2 spec.
1223          * The order of the tests just follows the specification, this
1224          * is not a selection between possible values or a search for
1225          * the best value but just a mapping.  Only one case per platform
1226          * is relevant.
1227          * Some BIOS have inconsistent values for mclk_freq but a
1228          * correct root so we force the mclk_freq to avoid variations.
1229          */
1230         if (!(19200000 % mclk_freq)) {
1231                 mclk_freq = 19200000;
1232                 base = SDW_SCP_BASE_CLOCK_19200000_HZ;
1233         } else if (!(24000000 % mclk_freq)) {
1234                 mclk_freq = 24000000;
1235                 base = SDW_SCP_BASE_CLOCK_24000000_HZ;
1236         } else if (!(24576000 % mclk_freq)) {
1237                 mclk_freq = 24576000;
1238                 base = SDW_SCP_BASE_CLOCK_24576000_HZ;
1239         } else if (!(22579200 % mclk_freq)) {
1240                 mclk_freq = 22579200;
1241                 base = SDW_SCP_BASE_CLOCK_22579200_HZ;
1242         } else if (!(32000000 % mclk_freq)) {
1243                 mclk_freq = 32000000;
1244                 base = SDW_SCP_BASE_CLOCK_32000000_HZ;
1245         } else {
1246                 dev_err(&slave->dev,
1247                         "Unsupported clock base, mclk %d\n",
1248                         mclk_freq);
1249                 return -EINVAL;
1250         }
1251
1252         if (mclk_freq % curr_freq) {
1253                 dev_err(&slave->dev,
1254                         "mclk %d is not multiple of bus curr_freq %d\n",
1255                         mclk_freq, curr_freq);
1256                 return -EINVAL;
1257         }
1258
1259         scale = mclk_freq / curr_freq;
1260
1261         /*
1262          * map scale to Table 90 of SoundWire 1.2 spec - and check
1263          * that the scale is a power of two and maximum 64
1264          */
1265         scale_index = ilog2(scale);
1266
1267         if (BIT(scale_index) != scale || scale_index > 6) {
1268                 dev_err(&slave->dev,
1269                         "No match found for scale %d, bus mclk %d curr_freq %d\n",
1270                         scale, mclk_freq, curr_freq);
1271                 return -EINVAL;
1272         }
1273         scale_index++;
1274
1275         ret = sdw_write_no_pm(slave, SDW_SCP_BUS_CLOCK_BASE, base);
1276         if (ret < 0) {
1277                 dev_err(&slave->dev,
1278                         "SDW_SCP_BUS_CLOCK_BASE write failed:%d\n", ret);
1279                 return ret;
1280         }
1281
1282         /* initialize scale for both banks */
1283         ret = sdw_write_no_pm(slave, SDW_SCP_BUSCLOCK_SCALE_B0, scale_index);
1284         if (ret < 0) {
1285                 dev_err(&slave->dev,
1286                         "SDW_SCP_BUSCLOCK_SCALE_B0 write failed:%d\n", ret);
1287                 return ret;
1288         }
1289         ret = sdw_write_no_pm(slave, SDW_SCP_BUSCLOCK_SCALE_B1, scale_index);
1290         if (ret < 0)
1291                 dev_err(&slave->dev,
1292                         "SDW_SCP_BUSCLOCK_SCALE_B1 write failed:%d\n", ret);
1293
1294         dev_dbg(&slave->dev,
1295                 "Configured bus base %d, scale %d, mclk %d, curr_freq %d\n",
1296                 base, scale_index, mclk_freq, curr_freq);
1297
1298         return ret;
1299 }
1300
1301 static int sdw_initialize_slave(struct sdw_slave *slave)
1302 {
1303         struct sdw_slave_prop *prop = &slave->prop;
1304         int status;
1305         int ret;
1306         u8 val;
1307
1308         ret = sdw_slave_set_frequency(slave);
1309         if (ret < 0)
1310                 return ret;
1311
1312         if (slave->bus->prop.quirks & SDW_MASTER_QUIRKS_CLEAR_INITIAL_CLASH) {
1313                 /* Clear bus clash interrupt before enabling interrupt mask */
1314                 status = sdw_read_no_pm(slave, SDW_SCP_INT1);
1315                 if (status < 0) {
1316                         dev_err(&slave->dev,
1317                                 "SDW_SCP_INT1 (BUS_CLASH) read failed:%d\n", status);
1318                         return status;
1319                 }
1320                 if (status & SDW_SCP_INT1_BUS_CLASH) {
1321                         dev_warn(&slave->dev, "Bus clash detected before INT mask is enabled\n");
1322                         ret = sdw_write_no_pm(slave, SDW_SCP_INT1, SDW_SCP_INT1_BUS_CLASH);
1323                         if (ret < 0) {
1324                                 dev_err(&slave->dev,
1325                                         "SDW_SCP_INT1 (BUS_CLASH) write failed:%d\n", ret);
1326                                 return ret;
1327                         }
1328                 }
1329         }
1330         if ((slave->bus->prop.quirks & SDW_MASTER_QUIRKS_CLEAR_INITIAL_PARITY) &&
1331             !(slave->prop.quirks & SDW_SLAVE_QUIRKS_INVALID_INITIAL_PARITY)) {
1332                 /* Clear parity interrupt before enabling interrupt mask */
1333                 status = sdw_read_no_pm(slave, SDW_SCP_INT1);
1334                 if (status < 0) {
1335                         dev_err(&slave->dev,
1336                                 "SDW_SCP_INT1 (PARITY) read failed:%d\n", status);
1337                         return status;
1338                 }
1339                 if (status & SDW_SCP_INT1_PARITY) {
1340                         dev_warn(&slave->dev, "PARITY error detected before INT mask is enabled\n");
1341                         ret = sdw_write_no_pm(slave, SDW_SCP_INT1, SDW_SCP_INT1_PARITY);
1342                         if (ret < 0) {
1343                                 dev_err(&slave->dev,
1344                                         "SDW_SCP_INT1 (PARITY) write failed:%d\n", ret);
1345                                 return ret;
1346                         }
1347                 }
1348         }
1349
1350         /*
1351          * Set SCP_INT1_MASK register, typically bus clash and
1352          * implementation-defined interrupt mask. The Parity detection
1353          * may not always be correct on startup so its use is
1354          * device-dependent, it might e.g. only be enabled in
1355          * steady-state after a couple of frames.
1356          */
1357         val = slave->prop.scp_int1_mask;
1358
1359         /* Enable SCP interrupts */
1360         ret = sdw_update_no_pm(slave, SDW_SCP_INTMASK1, val, val);
1361         if (ret < 0) {
1362                 dev_err(&slave->dev,
1363                         "SDW_SCP_INTMASK1 write failed:%d\n", ret);
1364                 return ret;
1365         }
1366
1367         /* No need to continue if DP0 is not present */
1368         if (!slave->prop.dp0_prop)
1369                 return 0;
1370
1371         /* Enable DP0 interrupts */
1372         val = prop->dp0_prop->imp_def_interrupts;
1373         val |= SDW_DP0_INT_PORT_READY | SDW_DP0_INT_BRA_FAILURE;
1374
1375         ret = sdw_update_no_pm(slave, SDW_DP0_INTMASK, val, val);
1376         if (ret < 0)
1377                 dev_err(&slave->dev,
1378                         "SDW_DP0_INTMASK read failed:%d\n", ret);
1379         return ret;
1380 }
1381
1382 static int sdw_handle_dp0_interrupt(struct sdw_slave *slave, u8 *slave_status)
1383 {
1384         u8 clear, impl_int_mask;
1385         int status, status2, ret, count = 0;
1386
1387         status = sdw_read_no_pm(slave, SDW_DP0_INT);
1388         if (status < 0) {
1389                 dev_err(&slave->dev,
1390                         "SDW_DP0_INT read failed:%d\n", status);
1391                 return status;
1392         }
1393
1394         do {
1395                 clear = status & ~SDW_DP0_INTERRUPTS;
1396
1397                 if (status & SDW_DP0_INT_TEST_FAIL) {
1398                         dev_err(&slave->dev, "Test fail for port 0\n");
1399                         clear |= SDW_DP0_INT_TEST_FAIL;
1400                 }
1401
1402                 /*
1403                  * Assumption: PORT_READY interrupt will be received only for
1404                  * ports implementing Channel Prepare state machine (CP_SM)
1405                  */
1406
1407                 if (status & SDW_DP0_INT_PORT_READY) {
1408                         complete(&slave->port_ready[0]);
1409                         clear |= SDW_DP0_INT_PORT_READY;
1410                 }
1411
1412                 if (status & SDW_DP0_INT_BRA_FAILURE) {
1413                         dev_err(&slave->dev, "BRA failed\n");
1414                         clear |= SDW_DP0_INT_BRA_FAILURE;
1415                 }
1416
1417                 impl_int_mask = SDW_DP0_INT_IMPDEF1 |
1418                         SDW_DP0_INT_IMPDEF2 | SDW_DP0_INT_IMPDEF3;
1419
1420                 if (status & impl_int_mask) {
1421                         clear |= impl_int_mask;
1422                         *slave_status = clear;
1423                 }
1424
1425                 /* clear the interrupts but don't touch reserved and SDCA_CASCADE fields */
1426                 ret = sdw_write_no_pm(slave, SDW_DP0_INT, clear);
1427                 if (ret < 0) {
1428                         dev_err(&slave->dev,
1429                                 "SDW_DP0_INT write failed:%d\n", ret);
1430                         return ret;
1431                 }
1432
1433                 /* Read DP0 interrupt again */
1434                 status2 = sdw_read_no_pm(slave, SDW_DP0_INT);
1435                 if (status2 < 0) {
1436                         dev_err(&slave->dev,
1437                                 "SDW_DP0_INT read failed:%d\n", status2);
1438                         return status2;
1439                 }
1440                 /* filter to limit loop to interrupts identified in the first status read */
1441                 status &= status2;
1442
1443                 count++;
1444
1445                 /* we can get alerts while processing so keep retrying */
1446         } while ((status & SDW_DP0_INTERRUPTS) && (count < SDW_READ_INTR_CLEAR_RETRY));
1447
1448         if (count == SDW_READ_INTR_CLEAR_RETRY)
1449                 dev_warn(&slave->dev, "Reached MAX_RETRY on DP0 read\n");
1450
1451         return ret;
1452 }
1453
1454 static int sdw_handle_port_interrupt(struct sdw_slave *slave,
1455                                      int port, u8 *slave_status)
1456 {
1457         u8 clear, impl_int_mask;
1458         int status, status2, ret, count = 0;
1459         u32 addr;
1460
1461         if (port == 0)
1462                 return sdw_handle_dp0_interrupt(slave, slave_status);
1463
1464         addr = SDW_DPN_INT(port);
1465         status = sdw_read_no_pm(slave, addr);
1466         if (status < 0) {
1467                 dev_err(&slave->dev,
1468                         "SDW_DPN_INT read failed:%d\n", status);
1469
1470                 return status;
1471         }
1472
1473         do {
1474                 clear = status & ~SDW_DPN_INTERRUPTS;
1475
1476                 if (status & SDW_DPN_INT_TEST_FAIL) {
1477                         dev_err(&slave->dev, "Test fail for port:%d\n", port);
1478                         clear |= SDW_DPN_INT_TEST_FAIL;
1479                 }
1480
1481                 /*
1482                  * Assumption: PORT_READY interrupt will be received only
1483                  * for ports implementing CP_SM.
1484                  */
1485                 if (status & SDW_DPN_INT_PORT_READY) {
1486                         complete(&slave->port_ready[port]);
1487                         clear |= SDW_DPN_INT_PORT_READY;
1488                 }
1489
1490                 impl_int_mask = SDW_DPN_INT_IMPDEF1 |
1491                         SDW_DPN_INT_IMPDEF2 | SDW_DPN_INT_IMPDEF3;
1492
1493                 if (status & impl_int_mask) {
1494                         clear |= impl_int_mask;
1495                         *slave_status = clear;
1496                 }
1497
1498                 /* clear the interrupt but don't touch reserved fields */
1499                 ret = sdw_write_no_pm(slave, addr, clear);
1500                 if (ret < 0) {
1501                         dev_err(&slave->dev,
1502                                 "SDW_DPN_INT write failed:%d\n", ret);
1503                         return ret;
1504                 }
1505
1506                 /* Read DPN interrupt again */
1507                 status2 = sdw_read_no_pm(slave, addr);
1508                 if (status2 < 0) {
1509                         dev_err(&slave->dev,
1510                                 "SDW_DPN_INT read failed:%d\n", status2);
1511                         return status2;
1512                 }
1513                 /* filter to limit loop to interrupts identified in the first status read */
1514                 status &= status2;
1515
1516                 count++;
1517
1518                 /* we can get alerts while processing so keep retrying */
1519         } while ((status & SDW_DPN_INTERRUPTS) && (count < SDW_READ_INTR_CLEAR_RETRY));
1520
1521         if (count == SDW_READ_INTR_CLEAR_RETRY)
1522                 dev_warn(&slave->dev, "Reached MAX_RETRY on port read");
1523
1524         return ret;
1525 }
1526
1527 static int sdw_handle_slave_alerts(struct sdw_slave *slave)
1528 {
1529         struct sdw_slave_intr_status slave_intr;
1530         u8 clear = 0, bit, port_status[15] = {0};
1531         int port_num, stat, ret, count = 0;
1532         unsigned long port;
1533         bool slave_notify;
1534         u8 sdca_cascade = 0;
1535         u8 buf, buf2[2], _buf, _buf2[2];
1536         bool parity_check;
1537         bool parity_quirk;
1538
1539         sdw_modify_slave_status(slave, SDW_SLAVE_ALERT);
1540
1541         ret = pm_runtime_resume_and_get(&slave->dev);
1542         if (ret < 0 && ret != -EACCES) {
1543                 dev_err(&slave->dev, "Failed to resume device: %d\n", ret);
1544                 return ret;
1545         }
1546
1547         /* Read Intstat 1, Intstat 2 and Intstat 3 registers */
1548         ret = sdw_read_no_pm(slave, SDW_SCP_INT1);
1549         if (ret < 0) {
1550                 dev_err(&slave->dev,
1551                         "SDW_SCP_INT1 read failed:%d\n", ret);
1552                 goto io_err;
1553         }
1554         buf = ret;
1555
1556         ret = sdw_nread_no_pm(slave, SDW_SCP_INTSTAT2, 2, buf2);
1557         if (ret < 0) {
1558                 dev_err(&slave->dev,
1559                         "SDW_SCP_INT2/3 read failed:%d\n", ret);
1560                 goto io_err;
1561         }
1562
1563         if (slave->id.class_id) {
1564                 ret = sdw_read_no_pm(slave, SDW_DP0_INT);
1565                 if (ret < 0) {
1566                         dev_err(&slave->dev,
1567                                 "SDW_DP0_INT read failed:%d\n", ret);
1568                         goto io_err;
1569                 }
1570                 sdca_cascade = ret & SDW_DP0_SDCA_CASCADE;
1571         }
1572
1573         do {
1574                 slave_notify = false;
1575
1576                 /*
1577                  * Check parity, bus clash and Slave (impl defined)
1578                  * interrupt
1579                  */
1580                 if (buf & SDW_SCP_INT1_PARITY) {
1581                         parity_check = slave->prop.scp_int1_mask & SDW_SCP_INT1_PARITY;
1582                         parity_quirk = !slave->first_interrupt_done &&
1583                                 (slave->prop.quirks & SDW_SLAVE_QUIRKS_INVALID_INITIAL_PARITY);
1584
1585                         if (parity_check && !parity_quirk)
1586                                 dev_err(&slave->dev, "Parity error detected\n");
1587                         clear |= SDW_SCP_INT1_PARITY;
1588                 }
1589
1590                 if (buf & SDW_SCP_INT1_BUS_CLASH) {
1591                         if (slave->prop.scp_int1_mask & SDW_SCP_INT1_BUS_CLASH)
1592                                 dev_err(&slave->dev, "Bus clash detected\n");
1593                         clear |= SDW_SCP_INT1_BUS_CLASH;
1594                 }
1595
1596                 /*
1597                  * When bus clash or parity errors are detected, such errors
1598                  * are unlikely to be recoverable errors.
1599                  * TODO: In such scenario, reset bus. Make this configurable
1600                  * via sysfs property with bus reset being the default.
1601                  */
1602
1603                 if (buf & SDW_SCP_INT1_IMPL_DEF) {
1604                         if (slave->prop.scp_int1_mask & SDW_SCP_INT1_IMPL_DEF) {
1605                                 dev_dbg(&slave->dev, "Slave impl defined interrupt\n");
1606                                 slave_notify = true;
1607                         }
1608                         clear |= SDW_SCP_INT1_IMPL_DEF;
1609                 }
1610
1611                 /* the SDCA interrupts are cleared in the codec driver .interrupt_callback() */
1612                 if (sdca_cascade)
1613                         slave_notify = true;
1614
1615                 /* Check port 0 - 3 interrupts */
1616                 port = buf & SDW_SCP_INT1_PORT0_3;
1617
1618                 /* To get port number corresponding to bits, shift it */
1619                 port = FIELD_GET(SDW_SCP_INT1_PORT0_3, port);
1620                 for_each_set_bit(bit, &port, 8) {
1621                         sdw_handle_port_interrupt(slave, bit,
1622                                                   &port_status[bit]);
1623                 }
1624
1625                 /* Check if cascade 2 interrupt is present */
1626                 if (buf & SDW_SCP_INT1_SCP2_CASCADE) {
1627                         port = buf2[0] & SDW_SCP_INTSTAT2_PORT4_10;
1628                         for_each_set_bit(bit, &port, 8) {
1629                                 /* scp2 ports start from 4 */
1630                                 port_num = bit + 4;
1631                                 sdw_handle_port_interrupt(slave,
1632                                                 port_num,
1633                                                 &port_status[port_num]);
1634                         }
1635                 }
1636
1637                 /* now check last cascade */
1638                 if (buf2[0] & SDW_SCP_INTSTAT2_SCP3_CASCADE) {
1639                         port = buf2[1] & SDW_SCP_INTSTAT3_PORT11_14;
1640                         for_each_set_bit(bit, &port, 8) {
1641                                 /* scp3 ports start from 11 */
1642                                 port_num = bit + 11;
1643                                 sdw_handle_port_interrupt(slave,
1644                                                 port_num,
1645                                                 &port_status[port_num]);
1646                         }
1647                 }
1648
1649                 /* Update the Slave driver */
1650                 if (slave_notify) {
1651                         mutex_lock(&slave->sdw_dev_lock);
1652
1653                         if (slave->probed) {
1654                                 struct device *dev = &slave->dev;
1655                                 struct sdw_driver *drv = drv_to_sdw_driver(dev->driver);
1656
1657                                 if (drv->ops && drv->ops->interrupt_callback) {
1658                                         slave_intr.sdca_cascade = sdca_cascade;
1659                                         slave_intr.control_port = clear;
1660                                         memcpy(slave_intr.port, &port_status,
1661                                                sizeof(slave_intr.port));
1662
1663                                         drv->ops->interrupt_callback(slave, &slave_intr);
1664                                 }
1665                         }
1666
1667                         mutex_unlock(&slave->sdw_dev_lock);
1668                 }
1669
1670                 /* Ack interrupt */
1671                 ret = sdw_write_no_pm(slave, SDW_SCP_INT1, clear);
1672                 if (ret < 0) {
1673                         dev_err(&slave->dev,
1674                                 "SDW_SCP_INT1 write failed:%d\n", ret);
1675                         goto io_err;
1676                 }
1677
1678                 /* at this point all initial interrupt sources were handled */
1679                 slave->first_interrupt_done = true;
1680
1681                 /*
1682                  * Read status again to ensure no new interrupts arrived
1683                  * while servicing interrupts.
1684                  */
1685                 ret = sdw_read_no_pm(slave, SDW_SCP_INT1);
1686                 if (ret < 0) {
1687                         dev_err(&slave->dev,
1688                                 "SDW_SCP_INT1 recheck read failed:%d\n", ret);
1689                         goto io_err;
1690                 }
1691                 _buf = ret;
1692
1693                 ret = sdw_nread_no_pm(slave, SDW_SCP_INTSTAT2, 2, _buf2);
1694                 if (ret < 0) {
1695                         dev_err(&slave->dev,
1696                                 "SDW_SCP_INT2/3 recheck read failed:%d\n", ret);
1697                         goto io_err;
1698                 }
1699
1700                 if (slave->id.class_id) {
1701                         ret = sdw_read_no_pm(slave, SDW_DP0_INT);
1702                         if (ret < 0) {
1703                                 dev_err(&slave->dev,
1704                                         "SDW_DP0_INT recheck read failed:%d\n", ret);
1705                                 goto io_err;
1706                         }
1707                         sdca_cascade = ret & SDW_DP0_SDCA_CASCADE;
1708                 }
1709
1710                 /*
1711                  * Make sure no interrupts are pending, but filter to limit loop
1712                  * to interrupts identified in the first status read
1713                  */
1714                 buf &= _buf;
1715                 buf2[0] &= _buf2[0];
1716                 buf2[1] &= _buf2[1];
1717                 stat = buf || buf2[0] || buf2[1] || sdca_cascade;
1718
1719                 /*
1720                  * Exit loop if Slave is continuously in ALERT state even
1721                  * after servicing the interrupt multiple times.
1722                  */
1723                 count++;
1724
1725                 /* we can get alerts while processing so keep retrying */
1726         } while (stat != 0 && count < SDW_READ_INTR_CLEAR_RETRY);
1727
1728         if (count == SDW_READ_INTR_CLEAR_RETRY)
1729                 dev_warn(&slave->dev, "Reached MAX_RETRY on alert read\n");
1730
1731 io_err:
1732         pm_runtime_mark_last_busy(&slave->dev);
1733         pm_runtime_put_autosuspend(&slave->dev);
1734
1735         return ret;
1736 }
1737
1738 static int sdw_update_slave_status(struct sdw_slave *slave,
1739                                    enum sdw_slave_status status)
1740 {
1741         int ret = 0;
1742
1743         mutex_lock(&slave->sdw_dev_lock);
1744
1745         if (slave->probed) {
1746                 struct device *dev = &slave->dev;
1747                 struct sdw_driver *drv = drv_to_sdw_driver(dev->driver);
1748
1749                 if (drv->ops && drv->ops->update_status)
1750                         ret = drv->ops->update_status(slave, status);
1751         }
1752
1753         mutex_unlock(&slave->sdw_dev_lock);
1754
1755         return ret;
1756 }
1757
1758 /**
1759  * sdw_handle_slave_status() - Handle Slave status
1760  * @bus: SDW bus instance
1761  * @status: Status for all Slave(s)
1762  */
1763 int sdw_handle_slave_status(struct sdw_bus *bus,
1764                             enum sdw_slave_status status[])
1765 {
1766         enum sdw_slave_status prev_status;
1767         struct sdw_slave *slave;
1768         bool attached_initializing, id_programmed;
1769         int i, ret = 0;
1770
1771         /* first check if any Slaves fell off the bus */
1772         for (i = 1; i <= SDW_MAX_DEVICES; i++) {
1773                 mutex_lock(&bus->bus_lock);
1774                 if (test_bit(i, bus->assigned) == false) {
1775                         mutex_unlock(&bus->bus_lock);
1776                         continue;
1777                 }
1778                 mutex_unlock(&bus->bus_lock);
1779
1780                 slave = sdw_get_slave(bus, i);
1781                 if (!slave)
1782                         continue;
1783
1784                 if (status[i] == SDW_SLAVE_UNATTACHED &&
1785                     slave->status != SDW_SLAVE_UNATTACHED) {
1786                         dev_warn(&slave->dev, "Slave %d state check1: UNATTACHED, status was %d\n",
1787                                  i, slave->status);
1788                         sdw_modify_slave_status(slave, SDW_SLAVE_UNATTACHED);
1789
1790                         /* Ensure driver knows that peripheral unattached */
1791                         ret = sdw_update_slave_status(slave, status[i]);
1792                         if (ret < 0)
1793                                 dev_warn(&slave->dev, "Update Slave status failed:%d\n", ret);
1794                 }
1795         }
1796
1797         if (status[0] == SDW_SLAVE_ATTACHED) {
1798                 dev_dbg(bus->dev, "Slave attached, programming device number\n");
1799
1800                 /*
1801                  * Programming a device number will have side effects,
1802                  * so we deal with other devices at a later time.
1803                  * This relies on those devices reporting ATTACHED, which will
1804                  * trigger another call to this function. This will only
1805                  * happen if at least one device ID was programmed.
1806                  * Error returns from sdw_program_device_num() are currently
1807                  * ignored because there's no useful recovery that can be done.
1808                  * Returning the error here could result in the current status
1809                  * of other devices not being handled, because if no device IDs
1810                  * were programmed there's nothing to guarantee a status change
1811                  * to trigger another call to this function.
1812                  */
1813                 sdw_program_device_num(bus, &id_programmed);
1814                 if (id_programmed)
1815                         return 0;
1816         }
1817
1818         /* Continue to check other slave statuses */
1819         for (i = 1; i <= SDW_MAX_DEVICES; i++) {
1820                 mutex_lock(&bus->bus_lock);
1821                 if (test_bit(i, bus->assigned) == false) {
1822                         mutex_unlock(&bus->bus_lock);
1823                         continue;
1824                 }
1825                 mutex_unlock(&bus->bus_lock);
1826
1827                 slave = sdw_get_slave(bus, i);
1828                 if (!slave)
1829                         continue;
1830
1831                 attached_initializing = false;
1832
1833                 switch (status[i]) {
1834                 case SDW_SLAVE_UNATTACHED:
1835                         if (slave->status == SDW_SLAVE_UNATTACHED)
1836                                 break;
1837
1838                         dev_warn(&slave->dev, "Slave %d state check2: UNATTACHED, status was %d\n",
1839                                  i, slave->status);
1840
1841                         sdw_modify_slave_status(slave, SDW_SLAVE_UNATTACHED);
1842                         break;
1843
1844                 case SDW_SLAVE_ALERT:
1845                         ret = sdw_handle_slave_alerts(slave);
1846                         if (ret < 0)
1847                                 dev_err(&slave->dev,
1848                                         "Slave %d alert handling failed: %d\n",
1849                                         i, ret);
1850                         break;
1851
1852                 case SDW_SLAVE_ATTACHED:
1853                         if (slave->status == SDW_SLAVE_ATTACHED)
1854                                 break;
1855
1856                         prev_status = slave->status;
1857                         sdw_modify_slave_status(slave, SDW_SLAVE_ATTACHED);
1858
1859                         if (prev_status == SDW_SLAVE_ALERT)
1860                                 break;
1861
1862                         attached_initializing = true;
1863
1864                         ret = sdw_initialize_slave(slave);
1865                         if (ret < 0)
1866                                 dev_err(&slave->dev,
1867                                         "Slave %d initialization failed: %d\n",
1868                                         i, ret);
1869
1870                         break;
1871
1872                 default:
1873                         dev_err(&slave->dev, "Invalid slave %d status:%d\n",
1874                                 i, status[i]);
1875                         break;
1876                 }
1877
1878                 ret = sdw_update_slave_status(slave, status[i]);
1879                 if (ret < 0)
1880                         dev_err(&slave->dev,
1881                                 "Update Slave status failed:%d\n", ret);
1882                 if (attached_initializing) {
1883                         dev_dbg(&slave->dev,
1884                                 "signaling initialization completion for Slave %d\n",
1885                                 slave->dev_num);
1886
1887                         complete(&slave->initialization_complete);
1888
1889                         /*
1890                          * If the manager became pm_runtime active, the peripherals will be
1891                          * restarted and attach, but their pm_runtime status may remain
1892                          * suspended. If the 'update_slave_status' callback initiates
1893                          * any sort of deferred processing, this processing would not be
1894                          * cancelled on pm_runtime suspend.
1895                          * To avoid such zombie states, we queue a request to resume.
1896                          * This would be a no-op in case the peripheral was being resumed
1897                          * by e.g. the ALSA/ASoC framework.
1898                          */
1899                         pm_request_resume(&slave->dev);
1900                 }
1901         }
1902
1903         return ret;
1904 }
1905 EXPORT_SYMBOL(sdw_handle_slave_status);
1906
1907 void sdw_clear_slave_status(struct sdw_bus *bus, u32 request)
1908 {
1909         struct sdw_slave *slave;
1910         int i;
1911
1912         /* Check all non-zero devices */
1913         for (i = 1; i <= SDW_MAX_DEVICES; i++) {
1914                 mutex_lock(&bus->bus_lock);
1915                 if (test_bit(i, bus->assigned) == false) {
1916                         mutex_unlock(&bus->bus_lock);
1917                         continue;
1918                 }
1919                 mutex_unlock(&bus->bus_lock);
1920
1921                 slave = sdw_get_slave(bus, i);
1922                 if (!slave)
1923                         continue;
1924
1925                 if (slave->status != SDW_SLAVE_UNATTACHED) {
1926                         sdw_modify_slave_status(slave, SDW_SLAVE_UNATTACHED);
1927                         slave->first_interrupt_done = false;
1928                         sdw_update_slave_status(slave, SDW_SLAVE_UNATTACHED);
1929                 }
1930
1931                 /* keep track of request, used in pm_runtime resume */
1932                 slave->unattach_request = request;
1933         }
1934 }
1935 EXPORT_SYMBOL(sdw_clear_slave_status);