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