]>
Commit | Line | Data |
---|---|---|
7c3cd189 VK |
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> | |
9d715fa0 VK |
6 | #include <linux/pm_runtime.h> |
7 | #include <linux/soundwire/sdw_registers.h> | |
7c3cd189 VK |
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 | ||
9d715fa0 VK |
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); | |
7c3cd189 VK |
33 | mutex_init(&bus->bus_lock); |
34 | INIT_LIST_HEAD(&bus->slaves); | |
35 | ||
56d4fe31 VK |
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 | ||
7c3cd189 VK |
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 | ||
9d715fa0 VK |
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); | |
c22c0ae5 | 308 | if (ret < 0) |
9d715fa0 VK |
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); | |
c22c0ae5 | 336 | if (ret < 0) |
9d715fa0 VK |
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 | ||
d52d7a1b SK |
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 | ||
7c3cd189 VK |
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 | } | |
d52d7a1b SK |
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) | | |
0132af05 CIK |
525 | ((u64)buf[2] << 24) | ((u64)buf[1] << 32) | |
526 | ((u64)buf[0] << 40); | |
d52d7a1b SK |
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 | } | |
b0a9c37b VK |
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, | |
80cd8f01 WY |
674 | "SDW_DP0_INT read failed:%d", status2); |
675 | return status2; | |
b0a9c37b VK |
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); | |
80cd8f01 | 744 | if (status2 < 0) { |
b0a9c37b | 745 | dev_err(slave->bus->dev, |
80cd8f01 WY |
746 | "SDW_DPN_INT read failed:%d", status2); |
747 | return status2; | |
b0a9c37b VK |
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 */ | |
51c26656 | 774 | buf = ret = sdw_read(slave, SDW_SCP_INT1); |
b0a9c37b VK |
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 | */ | |
51c26656 | 873 | _buf = ret = sdw_read(slave, SDW_SCP_INT1); |
b0a9c37b VK |
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); |