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