1 // SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause)
2 // Copyright(c) 2015-17 Intel Corporation.
4 #include <linux/acpi.h>
5 #include <linux/mod_devicetable.h>
6 #include <linux/pm_runtime.h>
7 #include <linux/soundwire/sdw_registers.h>
8 #include <linux/soundwire/sdw.h>
12 * sdw_add_bus_master() - add a bus Master instance
15 * Initializes the bus instance, read properties and create child
18 int sdw_add_bus_master(struct sdw_bus
*bus
)
20 struct sdw_master_prop
*prop
= NULL
;
24 pr_err("SoundWire bus has no device\n");
29 dev_err(bus
->dev
, "SoundWire Bus ops are not set\n");
33 mutex_init(&bus
->msg_lock
);
34 mutex_init(&bus
->bus_lock
);
35 INIT_LIST_HEAD(&bus
->slaves
);
36 INIT_LIST_HEAD(&bus
->m_rt_list
);
39 * Initialize multi_link flag
40 * TODO: populate this flag by reading property from FW node
42 bus
->multi_link
= false;
43 if (bus
->ops
->read_prop
) {
44 ret
= bus
->ops
->read_prop(bus
);
47 "Bus read properties failed:%d\n", ret
);
53 * Device numbers in SoundWire are 0 through 15. Enumeration device
54 * number (0), Broadcast device number (15), Group numbers (12 and
55 * 13) and Master device number (14) are not used for assignment so
56 * mask these and other higher bits.
59 /* Set higher order bits */
60 *bus
->assigned
= ~GENMASK(SDW_BROADCAST_DEV_NUM
, SDW_ENUM_DEV_NUM
);
62 /* Set enumuration device number and broadcast device number */
63 set_bit(SDW_ENUM_DEV_NUM
, bus
->assigned
);
64 set_bit(SDW_BROADCAST_DEV_NUM
, bus
->assigned
);
66 /* Set group device numbers and master device number */
67 set_bit(SDW_GROUP12_DEV_NUM
, bus
->assigned
);
68 set_bit(SDW_GROUP13_DEV_NUM
, bus
->assigned
);
69 set_bit(SDW_MASTER_DEV_NUM
, bus
->assigned
);
72 * SDW is an enumerable bus, but devices can be powered off. So,
73 * they won't be able to report as present.
75 * Create Slave devices based on Slaves described in
76 * the respective firmware (ACPI/DT)
78 if (IS_ENABLED(CONFIG_ACPI
) && ACPI_HANDLE(bus
->dev
))
79 ret
= sdw_acpi_find_slaves(bus
);
81 ret
= -ENOTSUPP
; /* No ACPI/DT so error out */
84 dev_err(bus
->dev
, "Finding slaves failed:%d\n", ret
);
89 * Initialize clock values based on Master properties. The max
90 * frequency is read from max_freq property. Current assumption
91 * is that the bus will start at highest clock frequency when
94 * Default active bank will be 0 as out of reset the Slaves have
95 * to start with bank 0 (Table 40 of Spec)
98 bus
->params
.max_dr_freq
= prop
->max_freq
* SDW_DOUBLE_RATE_FACTOR
;
99 bus
->params
.curr_dr_freq
= bus
->params
.max_dr_freq
;
100 bus
->params
.curr_bank
= SDW_BANK0
;
101 bus
->params
.next_bank
= SDW_BANK1
;
105 EXPORT_SYMBOL(sdw_add_bus_master
);
107 static int sdw_delete_slave(struct device
*dev
, void *data
)
109 struct sdw_slave
*slave
= dev_to_sdw_dev(dev
);
110 struct sdw_bus
*bus
= slave
->bus
;
112 mutex_lock(&bus
->bus_lock
);
114 if (slave
->dev_num
) /* clear dev_num if assigned */
115 clear_bit(slave
->dev_num
, bus
->assigned
);
117 list_del_init(&slave
->node
);
118 mutex_unlock(&bus
->bus_lock
);
120 device_unregister(dev
);
125 * sdw_delete_bus_master() - delete the bus master instance
126 * @bus: bus to be deleted
128 * Remove the instance, delete the child devices.
130 void sdw_delete_bus_master(struct sdw_bus
*bus
)
132 device_for_each_child(bus
->dev
, NULL
, sdw_delete_slave
);
134 EXPORT_SYMBOL(sdw_delete_bus_master
);
140 static inline int find_response_code(enum sdw_command_response resp
)
146 case SDW_CMD_IGNORED
:
149 case SDW_CMD_TIMEOUT
:
157 static inline int do_transfer(struct sdw_bus
*bus
, struct sdw_msg
*msg
)
159 int retry
= bus
->prop
.err_threshold
;
160 enum sdw_command_response resp
;
163 for (i
= 0; i
<= retry
; i
++) {
164 resp
= bus
->ops
->xfer_msg(bus
, msg
);
165 ret
= find_response_code(resp
);
167 /* if cmd is ok or ignored return */
168 if (ret
== 0 || ret
== -ENODATA
)
175 static inline int do_transfer_defer(struct sdw_bus
*bus
,
177 struct sdw_defer
*defer
)
179 int retry
= bus
->prop
.err_threshold
;
180 enum sdw_command_response resp
;
184 defer
->length
= msg
->len
;
185 init_completion(&defer
->complete
);
187 for (i
= 0; i
<= retry
; i
++) {
188 resp
= bus
->ops
->xfer_msg_defer(bus
, msg
, defer
);
189 ret
= find_response_code(resp
);
190 /* if cmd is ok or ignored return */
191 if (ret
== 0 || ret
== -ENODATA
)
198 static int sdw_reset_page(struct sdw_bus
*bus
, u16 dev_num
)
200 int retry
= bus
->prop
.err_threshold
;
201 enum sdw_command_response resp
;
204 for (i
= 0; i
<= retry
; i
++) {
205 resp
= bus
->ops
->reset_page_addr(bus
, dev_num
);
206 ret
= find_response_code(resp
);
207 /* if cmd is ok or ignored return */
208 if (ret
== 0 || ret
== -ENODATA
)
216 * sdw_transfer() - Synchronous transfer message to a SDW Slave device
218 * @msg: SDW message to be xfered
220 int sdw_transfer(struct sdw_bus
*bus
, struct sdw_msg
*msg
)
224 mutex_lock(&bus
->msg_lock
);
226 ret
= do_transfer(bus
, msg
);
227 if (ret
!= 0 && ret
!= -ENODATA
)
228 dev_err(bus
->dev
, "trf on Slave %d failed:%d\n",
232 sdw_reset_page(bus
, msg
->dev_num
);
234 mutex_unlock(&bus
->msg_lock
);
240 * sdw_transfer_defer() - Asynchronously transfer message to a SDW Slave device
242 * @msg: SDW message to be xfered
243 * @defer: Defer block for signal completion
245 * Caller needs to hold the msg_lock lock while calling this
247 int sdw_transfer_defer(struct sdw_bus
*bus
, struct sdw_msg
*msg
,
248 struct sdw_defer
*defer
)
252 if (!bus
->ops
->xfer_msg_defer
)
255 ret
= do_transfer_defer(bus
, msg
, defer
);
256 if (ret
!= 0 && ret
!= -ENODATA
)
257 dev_err(bus
->dev
, "Defer trf on Slave %d failed:%d\n",
261 sdw_reset_page(bus
, msg
->dev_num
);
266 int sdw_fill_msg(struct sdw_msg
*msg
, struct sdw_slave
*slave
,
267 u32 addr
, size_t count
, u16 dev_num
, u8 flags
, u8
*buf
)
269 memset(msg
, 0, sizeof(*msg
));
270 msg
->addr
= addr
; /* addr is 16 bit and truncated here */
272 msg
->dev_num
= dev_num
;
276 if (addr
< SDW_REG_NO_PAGE
) { /* no paging area */
278 } else if (addr
>= SDW_REG_MAX
) { /* illegal addr */
279 pr_err("SDW: Invalid address %x passed\n", addr
);
283 if (addr
< SDW_REG_OPTIONAL_PAGE
) { /* 32k but no page */
284 if (slave
&& !slave
->prop
.paging_support
)
286 /* no need for else as that will fall-through to paging */
289 /* paging mandatory */
290 if (dev_num
== SDW_ENUM_DEV_NUM
|| dev_num
== SDW_BROADCAST_DEV_NUM
) {
291 pr_err("SDW: Invalid device for paging :%d\n", dev_num
);
296 pr_err("SDW: No slave for paging addr\n");
298 } else if (!slave
->prop
.paging_support
) {
300 "address %x needs paging but no support\n", addr
);
304 msg
->addr_page1
= (addr
>> SDW_REG_SHIFT(SDW_SCP_ADDRPAGE1_MASK
));
305 msg
->addr_page2
= (addr
>> SDW_REG_SHIFT(SDW_SCP_ADDRPAGE2_MASK
));
306 msg
->addr
|= BIT(15);
313 * sdw_nread() - Read "n" contiguous SDW Slave registers
315 * @addr: Register address
317 * @val: Buffer for values to be read
319 int sdw_nread(struct sdw_slave
*slave
, u32 addr
, size_t count
, u8
*val
)
324 ret
= sdw_fill_msg(&msg
, slave
, addr
, count
,
325 slave
->dev_num
, SDW_MSG_FLAG_READ
, val
);
329 ret
= pm_runtime_get_sync(slave
->bus
->dev
);
333 ret
= sdw_transfer(slave
->bus
, &msg
);
334 pm_runtime_put(slave
->bus
->dev
);
338 EXPORT_SYMBOL(sdw_nread
);
341 * sdw_nwrite() - Write "n" contiguous SDW Slave registers
343 * @addr: Register address
345 * @val: Buffer for values to be read
347 int sdw_nwrite(struct sdw_slave
*slave
, u32 addr
, size_t count
, u8
*val
)
352 ret
= sdw_fill_msg(&msg
, slave
, addr
, count
,
353 slave
->dev_num
, SDW_MSG_FLAG_WRITE
, val
);
357 ret
= pm_runtime_get_sync(slave
->bus
->dev
);
361 ret
= sdw_transfer(slave
->bus
, &msg
);
362 pm_runtime_put(slave
->bus
->dev
);
366 EXPORT_SYMBOL(sdw_nwrite
);
369 * sdw_read() - Read a SDW Slave register
371 * @addr: Register address
373 int sdw_read(struct sdw_slave
*slave
, u32 addr
)
378 ret
= sdw_nread(slave
, addr
, 1, &buf
);
384 EXPORT_SYMBOL(sdw_read
);
387 * sdw_write() - Write a SDW Slave register
389 * @addr: Register address
390 * @value: Register value
392 int sdw_write(struct sdw_slave
*slave
, u32 addr
, u8 value
)
394 return sdw_nwrite(slave
, addr
, 1, &value
);
396 EXPORT_SYMBOL(sdw_write
);
402 /* called with bus_lock held */
403 static struct sdw_slave
*sdw_get_slave(struct sdw_bus
*bus
, int i
)
405 struct sdw_slave
*slave
= NULL
;
407 list_for_each_entry(slave
, &bus
->slaves
, node
) {
408 if (slave
->dev_num
== i
)
415 static int sdw_compare_devid(struct sdw_slave
*slave
, struct sdw_slave_id id
)
417 if (slave
->id
.unique_id
!= id
.unique_id
||
418 slave
->id
.mfg_id
!= id
.mfg_id
||
419 slave
->id
.part_id
!= id
.part_id
||
420 slave
->id
.class_id
!= id
.class_id
)
426 /* called with bus_lock held */
427 static int sdw_get_device_num(struct sdw_slave
*slave
)
431 bit
= find_first_zero_bit(slave
->bus
->assigned
, SDW_MAX_DEVICES
);
432 if (bit
== SDW_MAX_DEVICES
) {
438 * Do not update dev_num in Slave data structure here,
439 * Update once program dev_num is successful
441 set_bit(bit
, slave
->bus
->assigned
);
447 static int sdw_assign_device_num(struct sdw_slave
*slave
)
451 /* check first if device number is assigned, if so reuse that */
452 if (!slave
->dev_num
) {
453 mutex_lock(&slave
->bus
->bus_lock
);
454 dev_num
= sdw_get_device_num(slave
);
455 mutex_unlock(&slave
->bus
->bus_lock
);
457 dev_err(slave
->bus
->dev
, "Get dev_num failed: %d\n",
462 dev_info(slave
->bus
->dev
,
463 "Slave already registered dev_num:%d\n",
466 /* Clear the slave->dev_num to transfer message on device 0 */
467 dev_num
= slave
->dev_num
;
471 ret
= sdw_write(slave
, SDW_SCP_DEVNUMBER
, dev_num
);
473 dev_err(&slave
->dev
, "Program device_num failed: %d\n", ret
);
477 /* After xfer of msg, restore dev_num */
478 slave
->dev_num
= dev_num
;
483 void sdw_extract_slave_id(struct sdw_bus
*bus
,
484 u64 addr
, struct sdw_slave_id
*id
)
486 dev_dbg(bus
->dev
, "SDW Slave Addr: %llx\n", addr
);
490 * Register Bit Contents
491 * DevId_0 [7:4] 47:44 sdw_version
492 * DevId_0 [3:0] 43:40 unique_id
493 * DevId_1 39:32 mfg_id [15:8]
494 * DevId_2 31:24 mfg_id [7:0]
495 * DevId_3 23:16 part_id [15:8]
496 * DevId_4 15:08 part_id [7:0]
497 * DevId_5 07:00 class_id
499 id
->sdw_version
= (addr
>> 44) & GENMASK(3, 0);
500 id
->unique_id
= (addr
>> 40) & GENMASK(3, 0);
501 id
->mfg_id
= (addr
>> 24) & GENMASK(15, 0);
502 id
->part_id
= (addr
>> 8) & GENMASK(15, 0);
503 id
->class_id
= addr
& GENMASK(7, 0);
506 "SDW Slave class_id %x, part_id %x, mfg_id %x, unique_id %x, version %x\n",
507 id
->class_id
, id
->part_id
, id
->mfg_id
,
508 id
->unique_id
, id
->sdw_version
);
511 static int sdw_program_device_num(struct sdw_bus
*bus
)
513 u8 buf
[SDW_NUM_DEV_ID_REGISTERS
] = {0};
514 struct sdw_slave
*slave
, *_s
;
515 struct sdw_slave_id id
;
521 /* No Slave, so use raw xfer api */
522 ret
= sdw_fill_msg(&msg
, NULL
, SDW_SCP_DEVID_0
,
523 SDW_NUM_DEV_ID_REGISTERS
, 0, SDW_MSG_FLAG_READ
, buf
);
528 ret
= sdw_transfer(bus
, &msg
);
529 if (ret
== -ENODATA
) { /* end of device id reads */
534 dev_err(bus
->dev
, "DEVID read fail:%d\n", ret
);
539 * Construct the addr and extract. Cast the higher shift
540 * bits to avoid truncation due to size limit.
542 addr
= buf
[5] | (buf
[4] << 8) | (buf
[3] << 16) |
543 ((u64
)buf
[2] << 24) | ((u64
)buf
[1] << 32) |
546 sdw_extract_slave_id(bus
, addr
, &id
);
548 /* Now compare with entries */
549 list_for_each_entry_safe(slave
, _s
, &bus
->slaves
, node
) {
550 if (sdw_compare_devid(slave
, id
) == 0) {
554 * Assign a new dev_num to this Slave and
555 * not mark it present. It will be marked
556 * present after it reports ATTACHED on new
559 ret
= sdw_assign_device_num(slave
);
561 dev_err(slave
->bus
->dev
,
562 "Assign dev_num failed:%d\n",
572 /* TODO: Park this device in Group 13 */
573 dev_err(bus
->dev
, "Slave Entry not found\n");
579 * Check till error out or retry (count) exhausts.
580 * Device can drop off and rejoin during enumeration
581 * so count till twice the bound.
584 } while (ret
== 0 && count
< (SDW_MAX_DEVICES
* 2));
589 static void sdw_modify_slave_status(struct sdw_slave
*slave
,
590 enum sdw_slave_status status
)
592 mutex_lock(&slave
->bus
->bus_lock
);
593 slave
->status
= status
;
594 mutex_unlock(&slave
->bus
->bus_lock
);
597 int sdw_configure_dpn_intr(struct sdw_slave
*slave
,
598 int port
, bool enable
, int mask
)
604 addr
= SDW_DPN_INTMASK(port
);
606 /* Set/Clear port ready interrupt mask */
609 val
|= SDW_DPN_INT_PORT_READY
;
612 val
&= ~SDW_DPN_INT_PORT_READY
;
615 ret
= sdw_update(slave
, addr
, (mask
| SDW_DPN_INT_PORT_READY
), val
);
617 dev_err(slave
->bus
->dev
,
618 "SDW_DPN_INTMASK write failed:%d\n", val
);
623 static int sdw_initialize_slave(struct sdw_slave
*slave
)
625 struct sdw_slave_prop
*prop
= &slave
->prop
;
630 * Set bus clash, parity and SCP implementation
631 * defined interrupt mask
632 * TODO: Read implementation defined interrupt mask
633 * from Slave property
635 val
= SDW_SCP_INT1_IMPL_DEF
| SDW_SCP_INT1_BUS_CLASH
|
638 /* Enable SCP interrupts */
639 ret
= sdw_update(slave
, SDW_SCP_INTMASK1
, val
, val
);
641 dev_err(slave
->bus
->dev
,
642 "SDW_SCP_INTMASK1 write failed:%d\n", ret
);
646 /* No need to continue if DP0 is not present */
647 if (!slave
->prop
.dp0_prop
)
650 /* Enable DP0 interrupts */
651 val
= prop
->dp0_prop
->device_interrupts
;
652 val
|= SDW_DP0_INT_PORT_READY
| SDW_DP0_INT_BRA_FAILURE
;
654 ret
= sdw_update(slave
, SDW_DP0_INTMASK
, val
, val
);
656 dev_err(slave
->bus
->dev
,
657 "SDW_DP0_INTMASK read failed:%d\n", ret
);
664 static int sdw_handle_dp0_interrupt(struct sdw_slave
*slave
, u8
*slave_status
)
666 u8 clear
= 0, impl_int_mask
;
667 int status
, status2
, ret
, count
= 0;
669 status
= sdw_read(slave
, SDW_DP0_INT
);
671 dev_err(slave
->bus
->dev
,
672 "SDW_DP0_INT read failed:%d\n", status
);
677 if (status
& SDW_DP0_INT_TEST_FAIL
) {
678 dev_err(&slave
->dev
, "Test fail for port 0\n");
679 clear
|= SDW_DP0_INT_TEST_FAIL
;
683 * Assumption: PORT_READY interrupt will be received only for
684 * ports implementing Channel Prepare state machine (CP_SM)
687 if (status
& SDW_DP0_INT_PORT_READY
) {
688 complete(&slave
->port_ready
[0]);
689 clear
|= SDW_DP0_INT_PORT_READY
;
692 if (status
& SDW_DP0_INT_BRA_FAILURE
) {
693 dev_err(&slave
->dev
, "BRA failed\n");
694 clear
|= SDW_DP0_INT_BRA_FAILURE
;
697 impl_int_mask
= SDW_DP0_INT_IMPDEF1
|
698 SDW_DP0_INT_IMPDEF2
| SDW_DP0_INT_IMPDEF3
;
700 if (status
& impl_int_mask
) {
701 clear
|= impl_int_mask
;
702 *slave_status
= clear
;
705 /* clear the interrupt */
706 ret
= sdw_write(slave
, SDW_DP0_INT
, clear
);
708 dev_err(slave
->bus
->dev
,
709 "SDW_DP0_INT write failed:%d\n", ret
);
713 /* Read DP0 interrupt again */
714 status2
= sdw_read(slave
, SDW_DP0_INT
);
716 dev_err(slave
->bus
->dev
,
717 "SDW_DP0_INT read failed:%d\n", status2
);
724 /* we can get alerts while processing so keep retrying */
725 } while (status
!= 0 && count
< SDW_READ_INTR_CLEAR_RETRY
);
727 if (count
== SDW_READ_INTR_CLEAR_RETRY
)
728 dev_warn(slave
->bus
->dev
, "Reached MAX_RETRY on DP0 read\n");
733 static int sdw_handle_port_interrupt(struct sdw_slave
*slave
,
734 int port
, u8
*slave_status
)
736 u8 clear
= 0, impl_int_mask
;
737 int status
, status2
, ret
, count
= 0;
741 return sdw_handle_dp0_interrupt(slave
, slave_status
);
743 addr
= SDW_DPN_INT(port
);
744 status
= sdw_read(slave
, addr
);
746 dev_err(slave
->bus
->dev
,
747 "SDW_DPN_INT read failed:%d\n", status
);
753 if (status
& SDW_DPN_INT_TEST_FAIL
) {
754 dev_err(&slave
->dev
, "Test fail for port:%d\n", port
);
755 clear
|= SDW_DPN_INT_TEST_FAIL
;
759 * Assumption: PORT_READY interrupt will be received only
760 * for ports implementing CP_SM.
762 if (status
& SDW_DPN_INT_PORT_READY
) {
763 complete(&slave
->port_ready
[port
]);
764 clear
|= SDW_DPN_INT_PORT_READY
;
767 impl_int_mask
= SDW_DPN_INT_IMPDEF1
|
768 SDW_DPN_INT_IMPDEF2
| SDW_DPN_INT_IMPDEF3
;
770 if (status
& impl_int_mask
) {
771 clear
|= impl_int_mask
;
772 *slave_status
= clear
;
775 /* clear the interrupt */
776 ret
= sdw_write(slave
, addr
, clear
);
778 dev_err(slave
->bus
->dev
,
779 "SDW_DPN_INT write failed:%d\n", ret
);
783 /* Read DPN interrupt again */
784 status2
= sdw_read(slave
, addr
);
786 dev_err(slave
->bus
->dev
,
787 "SDW_DPN_INT read failed:%d\n", status2
);
794 /* we can get alerts while processing so keep retrying */
795 } while (status
!= 0 && count
< SDW_READ_INTR_CLEAR_RETRY
);
797 if (count
== SDW_READ_INTR_CLEAR_RETRY
)
798 dev_warn(slave
->bus
->dev
, "Reached MAX_RETRY on port read");
803 static int sdw_handle_slave_alerts(struct sdw_slave
*slave
)
805 struct sdw_slave_intr_status slave_intr
;
806 u8 clear
= 0, bit
, port_status
[15];
807 int port_num
, stat
, ret
, count
= 0;
809 bool slave_notify
= false;
810 u8 buf
, buf2
[2], _buf
, _buf2
[2];
812 sdw_modify_slave_status(slave
, SDW_SLAVE_ALERT
);
814 /* Read Instat 1, Instat 2 and Instat 3 registers */
815 ret
= sdw_read(slave
, SDW_SCP_INT1
);
817 dev_err(slave
->bus
->dev
,
818 "SDW_SCP_INT1 read failed:%d\n", ret
);
823 ret
= sdw_nread(slave
, SDW_SCP_INTSTAT2
, 2, buf2
);
825 dev_err(slave
->bus
->dev
,
826 "SDW_SCP_INT2/3 read failed:%d\n", ret
);
832 * Check parity, bus clash and Slave (impl defined)
835 if (buf
& SDW_SCP_INT1_PARITY
) {
836 dev_err(&slave
->dev
, "Parity error detected\n");
837 clear
|= SDW_SCP_INT1_PARITY
;
840 if (buf
& SDW_SCP_INT1_BUS_CLASH
) {
841 dev_err(&slave
->dev
, "Bus clash error detected\n");
842 clear
|= SDW_SCP_INT1_BUS_CLASH
;
846 * When bus clash or parity errors are detected, such errors
847 * are unlikely to be recoverable errors.
848 * TODO: In such scenario, reset bus. Make this configurable
849 * via sysfs property with bus reset being the default.
852 if (buf
& SDW_SCP_INT1_IMPL_DEF
) {
853 dev_dbg(&slave
->dev
, "Slave impl defined interrupt\n");
854 clear
|= SDW_SCP_INT1_IMPL_DEF
;
858 /* Check port 0 - 3 interrupts */
859 port
= buf
& SDW_SCP_INT1_PORT0_3
;
861 /* To get port number corresponding to bits, shift it */
862 port
= port
>> SDW_REG_SHIFT(SDW_SCP_INT1_PORT0_3
);
863 for_each_set_bit(bit
, &port
, 8) {
864 sdw_handle_port_interrupt(slave
, bit
,
868 /* Check if cascade 2 interrupt is present */
869 if (buf
& SDW_SCP_INT1_SCP2_CASCADE
) {
870 port
= buf2
[0] & SDW_SCP_INTSTAT2_PORT4_10
;
871 for_each_set_bit(bit
, &port
, 8) {
872 /* scp2 ports start from 4 */
874 sdw_handle_port_interrupt(slave
,
876 &port_status
[port_num
]);
880 /* now check last cascade */
881 if (buf2
[0] & SDW_SCP_INTSTAT2_SCP3_CASCADE
) {
882 port
= buf2
[1] & SDW_SCP_INTSTAT3_PORT11_14
;
883 for_each_set_bit(bit
, &port
, 8) {
884 /* scp3 ports start from 11 */
886 sdw_handle_port_interrupt(slave
,
888 &port_status
[port_num
]);
892 /* Update the Slave driver */
893 if (slave_notify
&& slave
->ops
&&
894 slave
->ops
->interrupt_callback
) {
895 slave_intr
.control_port
= clear
;
896 memcpy(slave_intr
.port
, &port_status
,
897 sizeof(slave_intr
.port
));
899 slave
->ops
->interrupt_callback(slave
, &slave_intr
);
903 ret
= sdw_write(slave
, SDW_SCP_INT1
, clear
);
905 dev_err(slave
->bus
->dev
,
906 "SDW_SCP_INT1 write failed:%d\n", ret
);
911 * Read status again to ensure no new interrupts arrived
912 * while servicing interrupts.
914 ret
= sdw_read(slave
, SDW_SCP_INT1
);
916 dev_err(slave
->bus
->dev
,
917 "SDW_SCP_INT1 read failed:%d\n", ret
);
922 ret
= sdw_nread(slave
, SDW_SCP_INTSTAT2
, 2, _buf2
);
924 dev_err(slave
->bus
->dev
,
925 "SDW_SCP_INT2/3 read failed:%d\n", ret
);
929 /* Make sure no interrupts are pending */
933 stat
= buf
|| buf2
[0] || buf2
[1];
936 * Exit loop if Slave is continuously in ALERT state even
937 * after servicing the interrupt multiple times.
941 /* we can get alerts while processing so keep retrying */
942 } while (stat
!= 0 && count
< SDW_READ_INTR_CLEAR_RETRY
);
944 if (count
== SDW_READ_INTR_CLEAR_RETRY
)
945 dev_warn(slave
->bus
->dev
, "Reached MAX_RETRY on alert read\n");
950 static int sdw_update_slave_status(struct sdw_slave
*slave
,
951 enum sdw_slave_status status
)
953 if (slave
->ops
&& slave
->ops
->update_status
)
954 return slave
->ops
->update_status(slave
, status
);
960 * sdw_handle_slave_status() - Handle Slave status
961 * @bus: SDW bus instance
962 * @status: Status for all Slave(s)
964 int sdw_handle_slave_status(struct sdw_bus
*bus
,
965 enum sdw_slave_status status
[])
967 enum sdw_slave_status prev_status
;
968 struct sdw_slave
*slave
;
971 if (status
[0] == SDW_SLAVE_ATTACHED
) {
972 ret
= sdw_program_device_num(bus
);
974 dev_err(bus
->dev
, "Slave attach failed: %d\n", ret
);
977 /* Continue to check other slave statuses */
978 for (i
= 1; i
<= SDW_MAX_DEVICES
; i
++) {
979 mutex_lock(&bus
->bus_lock
);
980 if (test_bit(i
, bus
->assigned
) == false) {
981 mutex_unlock(&bus
->bus_lock
);
984 mutex_unlock(&bus
->bus_lock
);
986 slave
= sdw_get_slave(bus
, i
);
991 case SDW_SLAVE_UNATTACHED
:
992 if (slave
->status
== SDW_SLAVE_UNATTACHED
)
995 sdw_modify_slave_status(slave
, SDW_SLAVE_UNATTACHED
);
998 case SDW_SLAVE_ALERT
:
999 ret
= sdw_handle_slave_alerts(slave
);
1002 "Slave %d alert handling failed: %d\n",
1006 case SDW_SLAVE_ATTACHED
:
1007 if (slave
->status
== SDW_SLAVE_ATTACHED
)
1010 prev_status
= slave
->status
;
1011 sdw_modify_slave_status(slave
, SDW_SLAVE_ATTACHED
);
1013 if (prev_status
== SDW_SLAVE_ALERT
)
1016 ret
= sdw_initialize_slave(slave
);
1019 "Slave %d initialization failed: %d\n",
1025 dev_err(bus
->dev
, "Invalid slave %d status:%d\n",
1030 ret
= sdw_update_slave_status(slave
, status
[i
]);
1032 dev_err(slave
->bus
->dev
,
1033 "Update Slave status failed:%d\n", ret
);
1038 EXPORT_SYMBOL(sdw_handle_slave_status
);