1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * FSI core driver |
4 | * |
5 | * Copyright (C) IBM Corporation 2016 |
6 | * |
7 | * TODO: |
8 | * - Rework topology |
9 | * - s/chip_id/chip_loc |
10 | * - s/cfam/chip (cfam_id -> chip_id etc...) |
11 | */ |
12 | |
13 | #include <linux/crc4.h> |
14 | #include <linux/device.h> |
15 | #include <linux/fsi.h> |
16 | #include <linux/idr.h> |
17 | #include <linux/module.h> |
18 | #include <linux/of.h> |
19 | #include <linux/of_address.h> |
20 | #include <linux/of_device.h> |
21 | #include <linux/slab.h> |
22 | #include <linux/bitops.h> |
23 | #include <linux/cdev.h> |
24 | #include <linux/fs.h> |
25 | #include <linux/uaccess.h> |
26 | |
27 | #include "fsi-master.h" |
28 | #include "fsi-slave.h" |
29 | |
30 | #define CREATE_TRACE_POINTS |
31 | #include <trace/events/fsi.h> |
32 | |
33 | #define FSI_SLAVE_CONF_NEXT_MASK GENMASK(31, 31) |
34 | #define FSI_SLAVE_CONF_SLOTS_MASK GENMASK(23, 16) |
35 | #define FSI_SLAVE_CONF_SLOTS_SHIFT 16 |
36 | #define FSI_SLAVE_CONF_VERSION_MASK GENMASK(15, 12) |
37 | #define FSI_SLAVE_CONF_VERSION_SHIFT 12 |
38 | #define FSI_SLAVE_CONF_TYPE_MASK GENMASK(11, 4) |
39 | #define FSI_SLAVE_CONF_TYPE_SHIFT 4 |
40 | #define FSI_SLAVE_CONF_CRC_SHIFT 4 |
41 | #define FSI_SLAVE_CONF_CRC_MASK GENMASK(3, 0) |
42 | #define FSI_SLAVE_CONF_DATA_BITS 28 |
43 | |
44 | #define FSI_PEEK_BASE 0x410 |
45 | |
46 | static const int engine_page_size = 0x400; |
47 | |
48 | #define FSI_SLAVE_BASE 0x800 |
49 | |
50 | /* |
51 | * FSI slave engine control register offsets |
52 | */ |
53 | #define FSI_SMODE 0x0 /* R/W: Mode register */ |
54 | #define FSI_SISC 0x8 /* R/W: Interrupt condition */ |
55 | #define FSI_SSTAT 0x14 /* R : Slave status */ |
56 | #define FSI_SLBUS 0x30 /* W : LBUS Ownership */ |
57 | #define FSI_LLMODE 0x100 /* R/W: Link layer mode register */ |
58 | |
59 | /* |
60 | * SMODE fields |
61 | */ |
62 | #define FSI_SMODE_WSC 0x80000000 /* Warm start done */ |
63 | #define FSI_SMODE_ECRC 0x20000000 /* Hw CRC check */ |
64 | #define FSI_SMODE_SID_SHIFT 24 /* ID shift */ |
65 | #define FSI_SMODE_SID_MASK 3 /* ID Mask */ |
66 | #define FSI_SMODE_ED_SHIFT 20 /* Echo delay shift */ |
67 | #define FSI_SMODE_ED_MASK 0xf /* Echo delay mask */ |
68 | #define FSI_SMODE_SD_SHIFT 16 /* Send delay shift */ |
69 | #define FSI_SMODE_SD_MASK 0xf /* Send delay mask */ |
70 | #define FSI_SMODE_LBCRR_SHIFT 8 /* Clk ratio shift */ |
71 | #define FSI_SMODE_LBCRR_MASK 0xf /* Clk ratio mask */ |
72 | |
73 | /* |
74 | * SLBUS fields |
75 | */ |
76 | #define FSI_SLBUS_FORCE 0x80000000 /* Force LBUS ownership */ |
77 | |
78 | /* |
79 | * LLMODE fields |
80 | */ |
81 | #define FSI_LLMODE_ASYNC 0x1 |
82 | |
83 | #define FSI_SLAVE_SIZE_23b 0x800000 |
84 | |
85 | static DEFINE_IDA(master_ida); |
86 | |
87 | static const int slave_retries = 2; |
88 | static int discard_errors; |
89 | |
90 | static dev_t fsi_base_dev; |
91 | static DEFINE_IDA(fsi_minor_ida); |
92 | #define FSI_CHAR_MAX_DEVICES 0x1000 |
93 | |
94 | /* Legacy /dev numbering: 4 devices per chip, 16 chips */ |
95 | #define FSI_CHAR_LEGACY_TOP 64 |
96 | |
97 | static int fsi_master_read(struct fsi_master *master, int link, |
98 | uint8_t slave_id, uint32_t addr, void *val, size_t size); |
99 | static int fsi_master_write(struct fsi_master *master, int link, |
100 | uint8_t slave_id, uint32_t addr, const void *val, size_t size); |
101 | static int fsi_master_break(struct fsi_master *master, int link); |
102 | |
103 | /* |
104 | * fsi_device_read() / fsi_device_write() / fsi_device_peek() |
105 | * |
106 | * FSI endpoint-device support |
107 | * |
108 | * Read / write / peek accessors for a client |
109 | * |
110 | * Parameters: |
111 | * dev: Structure passed to FSI client device drivers on probe(). |
112 | * addr: FSI address of given device. Client should pass in its base address |
113 | * plus desired offset to access its register space. |
114 | * val: For read/peek this is the value read at the specified address. For |
115 | * write this is value to write to the specified address. |
116 | * The data in val must be FSI bus endian (big endian). |
117 | * size: Size in bytes of the operation. Sizes supported are 1, 2 and 4 bytes. |
118 | * Addresses must be aligned on size boundaries or an error will result. |
119 | */ |
120 | int fsi_device_read(struct fsi_device *dev, uint32_t addr, void *val, |
121 | size_t size) |
122 | { |
123 | if (addr > dev->size || size > dev->size || addr > dev->size - size) |
124 | return -EINVAL; |
125 | |
126 | return fsi_slave_read(slave: dev->slave, addr: dev->addr + addr, val, size); |
127 | } |
128 | EXPORT_SYMBOL_GPL(fsi_device_read); |
129 | |
130 | int fsi_device_write(struct fsi_device *dev, uint32_t addr, const void *val, |
131 | size_t size) |
132 | { |
133 | if (addr > dev->size || size > dev->size || addr > dev->size - size) |
134 | return -EINVAL; |
135 | |
136 | return fsi_slave_write(slave: dev->slave, addr: dev->addr + addr, val, size); |
137 | } |
138 | EXPORT_SYMBOL_GPL(fsi_device_write); |
139 | |
140 | int fsi_device_peek(struct fsi_device *dev, void *val) |
141 | { |
142 | uint32_t addr = FSI_PEEK_BASE + ((dev->unit - 2) * sizeof(uint32_t)); |
143 | |
144 | return fsi_slave_read(slave: dev->slave, addr, val, size: sizeof(uint32_t)); |
145 | } |
146 | |
147 | static void fsi_device_release(struct device *_device) |
148 | { |
149 | struct fsi_device *device = to_fsi_dev(_device); |
150 | |
151 | of_node_put(node: device->dev.of_node); |
152 | kfree(objp: device); |
153 | } |
154 | |
155 | static struct fsi_device *fsi_create_device(struct fsi_slave *slave) |
156 | { |
157 | struct fsi_device *dev; |
158 | |
159 | dev = kzalloc(size: sizeof(*dev), GFP_KERNEL); |
160 | if (!dev) |
161 | return NULL; |
162 | |
163 | dev->dev.parent = &slave->dev; |
164 | dev->dev.bus = &fsi_bus_type; |
165 | dev->dev.release = fsi_device_release; |
166 | |
167 | return dev; |
168 | } |
169 | |
170 | /* FSI slave support */ |
171 | static int fsi_slave_calc_addr(struct fsi_slave *slave, uint32_t *addrp, |
172 | uint8_t *idp) |
173 | { |
174 | uint32_t addr = *addrp; |
175 | uint8_t id = *idp; |
176 | |
177 | if (addr > slave->size) |
178 | return -EINVAL; |
179 | |
180 | /* For 23 bit addressing, we encode the extra two bits in the slave |
181 | * id (and the slave's actual ID needs to be 0). |
182 | */ |
183 | if (addr > 0x1fffff) { |
184 | if (slave->id != 0) |
185 | return -EINVAL; |
186 | id = (addr >> 21) & 0x3; |
187 | addr &= 0x1fffff; |
188 | } |
189 | |
190 | *addrp = addr; |
191 | *idp = id; |
192 | return 0; |
193 | } |
194 | |
195 | static int fsi_slave_report_and_clear_errors(struct fsi_slave *slave) |
196 | { |
197 | struct fsi_master *master = slave->master; |
198 | __be32 irq, stat; |
199 | int rc, link; |
200 | uint8_t id; |
201 | |
202 | link = slave->link; |
203 | id = slave->id; |
204 | |
205 | rc = fsi_master_read(master, link, slave_id: id, FSI_SLAVE_BASE + FSI_SISC, |
206 | val: &irq, size: sizeof(irq)); |
207 | if (rc) |
208 | return rc; |
209 | |
210 | rc = fsi_master_read(master, link, slave_id: id, FSI_SLAVE_BASE + FSI_SSTAT, |
211 | val: &stat, size: sizeof(stat)); |
212 | if (rc) |
213 | return rc; |
214 | |
215 | dev_dbg(&slave->dev, "status: 0x%08x, sisc: 0x%08x\n" , |
216 | be32_to_cpu(stat), be32_to_cpu(irq)); |
217 | |
218 | /* clear interrupts */ |
219 | return fsi_master_write(master, link, slave_id: id, FSI_SLAVE_BASE + FSI_SISC, |
220 | val: &irq, size: sizeof(irq)); |
221 | } |
222 | |
223 | /* Encode slave local bus echo delay */ |
224 | static inline uint32_t fsi_smode_echodly(int x) |
225 | { |
226 | return (x & FSI_SMODE_ED_MASK) << FSI_SMODE_ED_SHIFT; |
227 | } |
228 | |
229 | /* Encode slave local bus send delay */ |
230 | static inline uint32_t fsi_smode_senddly(int x) |
231 | { |
232 | return (x & FSI_SMODE_SD_MASK) << FSI_SMODE_SD_SHIFT; |
233 | } |
234 | |
235 | /* Encode slave local bus clock rate ratio */ |
236 | static inline uint32_t fsi_smode_lbcrr(int x) |
237 | { |
238 | return (x & FSI_SMODE_LBCRR_MASK) << FSI_SMODE_LBCRR_SHIFT; |
239 | } |
240 | |
241 | /* Encode slave ID */ |
242 | static inline uint32_t fsi_smode_sid(int x) |
243 | { |
244 | return (x & FSI_SMODE_SID_MASK) << FSI_SMODE_SID_SHIFT; |
245 | } |
246 | |
247 | static uint32_t fsi_slave_smode(int id, u8 t_senddly, u8 t_echodly) |
248 | { |
249 | return FSI_SMODE_WSC | FSI_SMODE_ECRC |
250 | | fsi_smode_sid(x: id) |
251 | | fsi_smode_echodly(x: t_echodly - 1) | fsi_smode_senddly(x: t_senddly - 1) |
252 | | fsi_smode_lbcrr(x: 0x8); |
253 | } |
254 | |
255 | static int fsi_slave_set_smode(struct fsi_slave *slave) |
256 | { |
257 | uint32_t smode; |
258 | __be32 data; |
259 | |
260 | /* set our smode register with the slave ID field to 0; this enables |
261 | * extended slave addressing |
262 | */ |
263 | smode = fsi_slave_smode(id: slave->id, t_senddly: slave->t_send_delay, t_echodly: slave->t_echo_delay); |
264 | data = cpu_to_be32(smode); |
265 | |
266 | return fsi_master_write(master: slave->master, link: slave->link, slave_id: slave->id, |
267 | FSI_SLAVE_BASE + FSI_SMODE, |
268 | val: &data, size: sizeof(data)); |
269 | } |
270 | |
271 | static int fsi_slave_handle_error(struct fsi_slave *slave, bool write, |
272 | uint32_t addr, size_t size) |
273 | { |
274 | struct fsi_master *master = slave->master; |
275 | int rc, link; |
276 | uint32_t reg; |
277 | uint8_t id, send_delay, echo_delay; |
278 | |
279 | if (discard_errors) |
280 | return -1; |
281 | |
282 | link = slave->link; |
283 | id = slave->id; |
284 | |
285 | dev_dbg(&slave->dev, "handling error on %s to 0x%08x[%zd]" , |
286 | write ? "write" : "read" , addr, size); |
287 | |
288 | /* try a simple clear of error conditions, which may fail if we've lost |
289 | * communication with the slave |
290 | */ |
291 | rc = fsi_slave_report_and_clear_errors(slave); |
292 | if (!rc) |
293 | return 0; |
294 | |
295 | /* send a TERM and retry */ |
296 | if (master->term) { |
297 | rc = master->term(master, link, id); |
298 | if (!rc) { |
299 | rc = fsi_master_read(master, link, slave_id: id, addr: 0, |
300 | val: ®, size: sizeof(reg)); |
301 | if (!rc) |
302 | rc = fsi_slave_report_and_clear_errors(slave); |
303 | if (!rc) |
304 | return 0; |
305 | } |
306 | } |
307 | |
308 | send_delay = slave->t_send_delay; |
309 | echo_delay = slave->t_echo_delay; |
310 | |
311 | /* getting serious, reset the slave via BREAK */ |
312 | rc = fsi_master_break(master, link); |
313 | if (rc) |
314 | return rc; |
315 | |
316 | slave->t_send_delay = send_delay; |
317 | slave->t_echo_delay = echo_delay; |
318 | |
319 | rc = fsi_slave_set_smode(slave); |
320 | if (rc) |
321 | return rc; |
322 | |
323 | if (master->link_config) |
324 | master->link_config(master, link, |
325 | slave->t_send_delay, |
326 | slave->t_echo_delay); |
327 | |
328 | return fsi_slave_report_and_clear_errors(slave); |
329 | } |
330 | |
331 | int fsi_slave_read(struct fsi_slave *slave, uint32_t addr, |
332 | void *val, size_t size) |
333 | { |
334 | uint8_t id = slave->id; |
335 | int rc, err_rc, i; |
336 | |
337 | rc = fsi_slave_calc_addr(slave, addrp: &addr, idp: &id); |
338 | if (rc) |
339 | return rc; |
340 | |
341 | for (i = 0; i < slave_retries; i++) { |
342 | rc = fsi_master_read(master: slave->master, link: slave->link, |
343 | slave_id: id, addr, val, size); |
344 | if (!rc) |
345 | break; |
346 | |
347 | err_rc = fsi_slave_handle_error(slave, write: false, addr, size); |
348 | if (err_rc) |
349 | break; |
350 | } |
351 | |
352 | return rc; |
353 | } |
354 | EXPORT_SYMBOL_GPL(fsi_slave_read); |
355 | |
356 | int fsi_slave_write(struct fsi_slave *slave, uint32_t addr, |
357 | const void *val, size_t size) |
358 | { |
359 | uint8_t id = slave->id; |
360 | int rc, err_rc, i; |
361 | |
362 | rc = fsi_slave_calc_addr(slave, addrp: &addr, idp: &id); |
363 | if (rc) |
364 | return rc; |
365 | |
366 | for (i = 0; i < slave_retries; i++) { |
367 | rc = fsi_master_write(master: slave->master, link: slave->link, |
368 | slave_id: id, addr, val, size); |
369 | if (!rc) |
370 | break; |
371 | |
372 | err_rc = fsi_slave_handle_error(slave, write: true, addr, size); |
373 | if (err_rc) |
374 | break; |
375 | } |
376 | |
377 | return rc; |
378 | } |
379 | EXPORT_SYMBOL_GPL(fsi_slave_write); |
380 | |
381 | int fsi_slave_claim_range(struct fsi_slave *slave, |
382 | uint32_t addr, uint32_t size) |
383 | { |
384 | if (addr + size < addr) |
385 | return -EINVAL; |
386 | |
387 | if (addr + size > slave->size) |
388 | return -EINVAL; |
389 | |
390 | /* todo: check for overlapping claims */ |
391 | return 0; |
392 | } |
393 | EXPORT_SYMBOL_GPL(fsi_slave_claim_range); |
394 | |
395 | void fsi_slave_release_range(struct fsi_slave *slave, |
396 | uint32_t addr, uint32_t size) |
397 | { |
398 | } |
399 | EXPORT_SYMBOL_GPL(fsi_slave_release_range); |
400 | |
401 | static bool fsi_device_node_matches(struct device *dev, struct device_node *np, |
402 | uint32_t addr, uint32_t size) |
403 | { |
404 | u64 paddr, psize; |
405 | |
406 | if (of_property_read_reg(np, idx: 0, addr: &paddr, size: &psize)) |
407 | return false; |
408 | |
409 | if (paddr != addr) |
410 | return false; |
411 | |
412 | if (psize != size) { |
413 | dev_warn(dev, |
414 | "node %pOF matches probed address, but not size (got 0x%llx, expected 0x%x)" , |
415 | np, psize, size); |
416 | } |
417 | |
418 | return true; |
419 | } |
420 | |
421 | /* Find a matching node for the slave engine at @address, using @size bytes |
422 | * of space. Returns NULL if not found, or a matching node with refcount |
423 | * already incremented. |
424 | */ |
425 | static struct device_node *fsi_device_find_of_node(struct fsi_device *dev) |
426 | { |
427 | struct device_node *parent, *np; |
428 | |
429 | parent = dev_of_node(dev: &dev->slave->dev); |
430 | if (!parent) |
431 | return NULL; |
432 | |
433 | for_each_child_of_node(parent, np) { |
434 | if (fsi_device_node_matches(dev: &dev->dev, np, |
435 | addr: dev->addr, size: dev->size)) |
436 | return np; |
437 | } |
438 | |
439 | return NULL; |
440 | } |
441 | |
442 | static int fsi_slave_scan(struct fsi_slave *slave) |
443 | { |
444 | uint32_t engine_addr; |
445 | int rc, i; |
446 | |
447 | /* |
448 | * scan engines |
449 | * |
450 | * We keep the peek mode and slave engines for the core; so start |
451 | * at the third slot in the configuration table. We also need to |
452 | * skip the chip ID entry at the start of the address space. |
453 | */ |
454 | engine_addr = engine_page_size * 3; |
455 | for (i = 2; i < engine_page_size / sizeof(uint32_t); i++) { |
456 | uint8_t slots, version, type, crc; |
457 | struct fsi_device *dev; |
458 | uint32_t conf; |
459 | __be32 data; |
460 | |
461 | rc = fsi_slave_read(slave, (i + 1) * sizeof(data), |
462 | &data, sizeof(data)); |
463 | if (rc) { |
464 | dev_warn(&slave->dev, |
465 | "error reading slave registers\n" ); |
466 | return -1; |
467 | } |
468 | conf = be32_to_cpu(data); |
469 | |
470 | crc = crc4(c: 0, x: conf, bits: 32); |
471 | if (crc) { |
472 | dev_warn(&slave->dev, |
473 | "crc error in slave register at 0x%04x\n" , |
474 | i); |
475 | return -1; |
476 | } |
477 | |
478 | slots = (conf & FSI_SLAVE_CONF_SLOTS_MASK) |
479 | >> FSI_SLAVE_CONF_SLOTS_SHIFT; |
480 | version = (conf & FSI_SLAVE_CONF_VERSION_MASK) |
481 | >> FSI_SLAVE_CONF_VERSION_SHIFT; |
482 | type = (conf & FSI_SLAVE_CONF_TYPE_MASK) |
483 | >> FSI_SLAVE_CONF_TYPE_SHIFT; |
484 | |
485 | /* |
486 | * Unused address areas are marked by a zero type value; this |
487 | * skips the defined address areas |
488 | */ |
489 | if (type != 0 && slots != 0) { |
490 | |
491 | /* create device */ |
492 | dev = fsi_create_device(slave); |
493 | if (!dev) |
494 | return -ENOMEM; |
495 | |
496 | dev->slave = slave; |
497 | dev->engine_type = type; |
498 | dev->version = version; |
499 | dev->unit = i; |
500 | dev->addr = engine_addr; |
501 | dev->size = slots * engine_page_size; |
502 | |
503 | trace_fsi_dev_init(dev); |
504 | |
505 | dev_dbg(&slave->dev, |
506 | "engine[%i]: type %x, version %x, addr %x size %x\n" , |
507 | dev->unit, dev->engine_type, version, |
508 | dev->addr, dev->size); |
509 | |
510 | dev_set_name(dev: &dev->dev, name: "%02x:%02x:%02x:%02x" , |
511 | slave->master->idx, slave->link, |
512 | slave->id, i - 2); |
513 | dev->dev.of_node = fsi_device_find_of_node(dev); |
514 | |
515 | rc = device_register(dev: &dev->dev); |
516 | if (rc) { |
517 | dev_warn(&slave->dev, "add failed: %d\n" , rc); |
518 | put_device(dev: &dev->dev); |
519 | } |
520 | } |
521 | |
522 | engine_addr += slots * engine_page_size; |
523 | |
524 | if (!(conf & FSI_SLAVE_CONF_NEXT_MASK)) |
525 | break; |
526 | } |
527 | |
528 | return 0; |
529 | } |
530 | |
531 | static unsigned long aligned_access_size(size_t offset, size_t count) |
532 | { |
533 | unsigned long offset_unit, count_unit; |
534 | |
535 | /* Criteria: |
536 | * |
537 | * 1. Access size must be less than or equal to the maximum access |
538 | * width or the highest power-of-two factor of offset |
539 | * 2. Access size must be less than or equal to the amount specified by |
540 | * count |
541 | * |
542 | * The access width is optimal if we can calculate 1 to be strictly |
543 | * equal while still satisfying 2. |
544 | */ |
545 | |
546 | /* Find 1 by the bottom bit of offset (with a 4 byte access cap) */ |
547 | offset_unit = BIT(__builtin_ctzl(offset | 4)); |
548 | |
549 | /* Find 2 by the top bit of count */ |
550 | count_unit = BIT(8 * sizeof(unsigned long) - 1 - __builtin_clzl(count)); |
551 | |
552 | /* Constrain the maximum access width to the minimum of both criteria */ |
553 | return BIT(__builtin_ctzl(offset_unit | count_unit)); |
554 | } |
555 | |
556 | static ssize_t fsi_slave_sysfs_raw_read(struct file *file, |
557 | struct kobject *kobj, struct bin_attribute *attr, char *buf, |
558 | loff_t off, size_t count) |
559 | { |
560 | struct fsi_slave *slave = to_fsi_slave(kobj_to_dev(kobj)); |
561 | size_t total_len, read_len; |
562 | int rc; |
563 | |
564 | if (off < 0) |
565 | return -EINVAL; |
566 | |
567 | if (off > 0xffffffff || count > 0xffffffff || off + count > 0xffffffff) |
568 | return -EINVAL; |
569 | |
570 | for (total_len = 0; total_len < count; total_len += read_len) { |
571 | read_len = aligned_access_size(offset: off, count: count - total_len); |
572 | |
573 | rc = fsi_slave_read(slave, off, buf + total_len, read_len); |
574 | if (rc) |
575 | return rc; |
576 | |
577 | off += read_len; |
578 | } |
579 | |
580 | return count; |
581 | } |
582 | |
583 | static ssize_t fsi_slave_sysfs_raw_write(struct file *file, |
584 | struct kobject *kobj, struct bin_attribute *attr, |
585 | char *buf, loff_t off, size_t count) |
586 | { |
587 | struct fsi_slave *slave = to_fsi_slave(kobj_to_dev(kobj)); |
588 | size_t total_len, write_len; |
589 | int rc; |
590 | |
591 | if (off < 0) |
592 | return -EINVAL; |
593 | |
594 | if (off > 0xffffffff || count > 0xffffffff || off + count > 0xffffffff) |
595 | return -EINVAL; |
596 | |
597 | for (total_len = 0; total_len < count; total_len += write_len) { |
598 | write_len = aligned_access_size(offset: off, count: count - total_len); |
599 | |
600 | rc = fsi_slave_write(slave, off, buf + total_len, write_len); |
601 | if (rc) |
602 | return rc; |
603 | |
604 | off += write_len; |
605 | } |
606 | |
607 | return count; |
608 | } |
609 | |
610 | static const struct bin_attribute fsi_slave_raw_attr = { |
611 | .attr = { |
612 | .name = "raw" , |
613 | .mode = 0600, |
614 | }, |
615 | .size = 0, |
616 | .read = fsi_slave_sysfs_raw_read, |
617 | .write = fsi_slave_sysfs_raw_write, |
618 | }; |
619 | |
620 | static void fsi_slave_release(struct device *dev) |
621 | { |
622 | struct fsi_slave *slave = to_fsi_slave(dev); |
623 | |
624 | fsi_free_minor(dev: slave->dev.devt); |
625 | of_node_put(node: dev->of_node); |
626 | kfree(objp: slave); |
627 | } |
628 | |
629 | static bool fsi_slave_node_matches(struct device_node *np, |
630 | int link, uint8_t id) |
631 | { |
632 | u64 addr; |
633 | |
634 | if (of_property_read_reg(np, idx: 0, addr: &addr, NULL)) |
635 | return false; |
636 | |
637 | return addr == (((u64)link << 32) | id); |
638 | } |
639 | |
640 | /* Find a matching node for the slave at (link, id). Returns NULL if none |
641 | * found, or a matching node with refcount already incremented. |
642 | */ |
643 | static struct device_node *fsi_slave_find_of_node(struct fsi_master *master, |
644 | int link, uint8_t id) |
645 | { |
646 | struct device_node *parent, *np; |
647 | |
648 | parent = dev_of_node(dev: &master->dev); |
649 | if (!parent) |
650 | return NULL; |
651 | |
652 | for_each_child_of_node(parent, np) { |
653 | if (fsi_slave_node_matches(np, link, id)) |
654 | return np; |
655 | } |
656 | |
657 | return NULL; |
658 | } |
659 | |
660 | static ssize_t cfam_read(struct file *filep, char __user *buf, size_t count, |
661 | loff_t *offset) |
662 | { |
663 | struct fsi_slave *slave = filep->private_data; |
664 | size_t total_len, read_len; |
665 | loff_t off = *offset; |
666 | ssize_t rc; |
667 | |
668 | if (off < 0) |
669 | return -EINVAL; |
670 | |
671 | if (off > 0xffffffff || count > 0xffffffff || off + count > 0xffffffff) |
672 | return -EINVAL; |
673 | |
674 | for (total_len = 0; total_len < count; total_len += read_len) { |
675 | __be32 data; |
676 | |
677 | read_len = min_t(size_t, count, 4); |
678 | read_len -= off & 0x3; |
679 | |
680 | rc = fsi_slave_read(slave, off, &data, read_len); |
681 | if (rc) |
682 | goto fail; |
683 | rc = copy_to_user(to: buf + total_len, from: &data, n: read_len); |
684 | if (rc) { |
685 | rc = -EFAULT; |
686 | goto fail; |
687 | } |
688 | off += read_len; |
689 | } |
690 | rc = count; |
691 | fail: |
692 | *offset = off; |
693 | return rc; |
694 | } |
695 | |
696 | static ssize_t cfam_write(struct file *filep, const char __user *buf, |
697 | size_t count, loff_t *offset) |
698 | { |
699 | struct fsi_slave *slave = filep->private_data; |
700 | size_t total_len, write_len; |
701 | loff_t off = *offset; |
702 | ssize_t rc; |
703 | |
704 | |
705 | if (off < 0) |
706 | return -EINVAL; |
707 | |
708 | if (off > 0xffffffff || count > 0xffffffff || off + count > 0xffffffff) |
709 | return -EINVAL; |
710 | |
711 | for (total_len = 0; total_len < count; total_len += write_len) { |
712 | __be32 data; |
713 | |
714 | write_len = min_t(size_t, count, 4); |
715 | write_len -= off & 0x3; |
716 | |
717 | rc = copy_from_user(to: &data, from: buf + total_len, n: write_len); |
718 | if (rc) { |
719 | rc = -EFAULT; |
720 | goto fail; |
721 | } |
722 | rc = fsi_slave_write(slave, off, &data, write_len); |
723 | if (rc) |
724 | goto fail; |
725 | off += write_len; |
726 | } |
727 | rc = count; |
728 | fail: |
729 | *offset = off; |
730 | return rc; |
731 | } |
732 | |
733 | static loff_t cfam_llseek(struct file *file, loff_t offset, int whence) |
734 | { |
735 | switch (whence) { |
736 | case SEEK_CUR: |
737 | break; |
738 | case SEEK_SET: |
739 | file->f_pos = offset; |
740 | break; |
741 | default: |
742 | return -EINVAL; |
743 | } |
744 | |
745 | return offset; |
746 | } |
747 | |
748 | static int cfam_open(struct inode *inode, struct file *file) |
749 | { |
750 | struct fsi_slave *slave = container_of(inode->i_cdev, struct fsi_slave, cdev); |
751 | |
752 | file->private_data = slave; |
753 | |
754 | return 0; |
755 | } |
756 | |
757 | static const struct file_operations cfam_fops = { |
758 | .owner = THIS_MODULE, |
759 | .open = cfam_open, |
760 | .llseek = cfam_llseek, |
761 | .read = cfam_read, |
762 | .write = cfam_write, |
763 | }; |
764 | |
765 | static ssize_t send_term_store(struct device *dev, |
766 | struct device_attribute *attr, |
767 | const char *buf, size_t count) |
768 | { |
769 | struct fsi_slave *slave = to_fsi_slave(dev); |
770 | struct fsi_master *master = slave->master; |
771 | |
772 | if (!master->term) |
773 | return -ENODEV; |
774 | |
775 | master->term(master, slave->link, slave->id); |
776 | return count; |
777 | } |
778 | |
779 | static DEVICE_ATTR_WO(send_term); |
780 | |
781 | static ssize_t slave_send_echo_show(struct device *dev, |
782 | struct device_attribute *attr, |
783 | char *buf) |
784 | { |
785 | struct fsi_slave *slave = to_fsi_slave(dev); |
786 | |
787 | return sprintf(buf, fmt: "%u\n" , slave->t_send_delay); |
788 | } |
789 | |
790 | static ssize_t slave_send_echo_store(struct device *dev, |
791 | struct device_attribute *attr, const char *buf, size_t count) |
792 | { |
793 | struct fsi_slave *slave = to_fsi_slave(dev); |
794 | struct fsi_master *master = slave->master; |
795 | unsigned long val; |
796 | int rc; |
797 | |
798 | if (kstrtoul(s: buf, base: 0, res: &val) < 0) |
799 | return -EINVAL; |
800 | |
801 | if (val < 1 || val > 16) |
802 | return -EINVAL; |
803 | |
804 | if (!master->link_config) |
805 | return -ENXIO; |
806 | |
807 | /* Current HW mandates that send and echo delay are identical */ |
808 | slave->t_send_delay = val; |
809 | slave->t_echo_delay = val; |
810 | |
811 | rc = fsi_slave_set_smode(slave); |
812 | if (rc < 0) |
813 | return rc; |
814 | if (master->link_config) |
815 | master->link_config(master, slave->link, |
816 | slave->t_send_delay, |
817 | slave->t_echo_delay); |
818 | |
819 | return count; |
820 | } |
821 | |
822 | static DEVICE_ATTR(send_echo_delays, 0600, |
823 | slave_send_echo_show, slave_send_echo_store); |
824 | |
825 | static ssize_t chip_id_show(struct device *dev, |
826 | struct device_attribute *attr, |
827 | char *buf) |
828 | { |
829 | struct fsi_slave *slave = to_fsi_slave(dev); |
830 | |
831 | return sprintf(buf, fmt: "%d\n" , slave->chip_id); |
832 | } |
833 | |
834 | static DEVICE_ATTR_RO(chip_id); |
835 | |
836 | static ssize_t cfam_id_show(struct device *dev, |
837 | struct device_attribute *attr, |
838 | char *buf) |
839 | { |
840 | struct fsi_slave *slave = to_fsi_slave(dev); |
841 | |
842 | return sprintf(buf, fmt: "0x%x\n" , slave->cfam_id); |
843 | } |
844 | |
845 | static DEVICE_ATTR_RO(cfam_id); |
846 | |
847 | static struct attribute *cfam_attr[] = { |
848 | &dev_attr_send_echo_delays.attr, |
849 | &dev_attr_chip_id.attr, |
850 | &dev_attr_cfam_id.attr, |
851 | &dev_attr_send_term.attr, |
852 | NULL, |
853 | }; |
854 | |
855 | static const struct attribute_group cfam_attr_group = { |
856 | .attrs = cfam_attr, |
857 | }; |
858 | |
859 | static const struct attribute_group *cfam_attr_groups[] = { |
860 | &cfam_attr_group, |
861 | NULL, |
862 | }; |
863 | |
864 | static char *cfam_devnode(const struct device *dev, umode_t *mode, |
865 | kuid_t *uid, kgid_t *gid) |
866 | { |
867 | const struct fsi_slave *slave = to_fsi_slave(dev); |
868 | |
869 | #ifdef CONFIG_FSI_NEW_DEV_NODE |
870 | return kasprintf(GFP_KERNEL, fmt: "fsi/cfam%d" , slave->cdev_idx); |
871 | #else |
872 | return kasprintf(GFP_KERNEL, "cfam%d" , slave->cdev_idx); |
873 | #endif |
874 | } |
875 | |
876 | static const struct device_type cfam_type = { |
877 | .name = "cfam" , |
878 | .devnode = cfam_devnode, |
879 | .groups = cfam_attr_groups |
880 | }; |
881 | |
882 | static char *fsi_cdev_devnode(const struct device *dev, umode_t *mode, |
883 | kuid_t *uid, kgid_t *gid) |
884 | { |
885 | #ifdef CONFIG_FSI_NEW_DEV_NODE |
886 | return kasprintf(GFP_KERNEL, fmt: "fsi/%s" , dev_name(dev)); |
887 | #else |
888 | return kasprintf(GFP_KERNEL, "%s" , dev_name(dev)); |
889 | #endif |
890 | } |
891 | |
892 | const struct device_type fsi_cdev_type = { |
893 | .name = "fsi-cdev" , |
894 | .devnode = fsi_cdev_devnode, |
895 | }; |
896 | EXPORT_SYMBOL_GPL(fsi_cdev_type); |
897 | |
898 | /* Backward compatible /dev/ numbering in "old style" mode */ |
899 | static int fsi_adjust_index(int index) |
900 | { |
901 | #ifdef CONFIG_FSI_NEW_DEV_NODE |
902 | return index; |
903 | #else |
904 | return index + 1; |
905 | #endif |
906 | } |
907 | |
908 | static int __fsi_get_new_minor(struct fsi_slave *slave, enum fsi_dev_type type, |
909 | dev_t *out_dev, int *out_index) |
910 | { |
911 | int cid = slave->chip_id; |
912 | int id; |
913 | |
914 | /* Check if we qualify for legacy numbering */ |
915 | if (cid >= 0 && cid < 16 && type < 4) { |
916 | /* |
917 | * Try reserving the legacy number, which has 0 - 0x3f reserved |
918 | * in the ida range. cid goes up to 0xf and type contains two |
919 | * bits, so construct the id with the below two bit shift. |
920 | */ |
921 | id = (cid << 2) | type; |
922 | id = ida_alloc_range(&fsi_minor_ida, min: id, max: id, GFP_KERNEL); |
923 | if (id >= 0) { |
924 | *out_index = fsi_adjust_index(index: cid); |
925 | *out_dev = fsi_base_dev + id; |
926 | return 0; |
927 | } |
928 | /* Other failure */ |
929 | if (id != -ENOSPC) |
930 | return id; |
931 | /* Fallback to non-legacy allocation */ |
932 | } |
933 | id = ida_alloc_range(&fsi_minor_ida, FSI_CHAR_LEGACY_TOP, |
934 | FSI_CHAR_MAX_DEVICES - 1, GFP_KERNEL); |
935 | if (id < 0) |
936 | return id; |
937 | *out_index = fsi_adjust_index(index: id); |
938 | *out_dev = fsi_base_dev + id; |
939 | return 0; |
940 | } |
941 | |
942 | static const char *const fsi_dev_type_names[] = { |
943 | "cfam" , |
944 | "sbefifo" , |
945 | "scom" , |
946 | "occ" , |
947 | }; |
948 | |
949 | int fsi_get_new_minor(struct fsi_device *fdev, enum fsi_dev_type type, |
950 | dev_t *out_dev, int *out_index) |
951 | { |
952 | if (fdev->dev.of_node) { |
953 | int aid = of_alias_get_id(np: fdev->dev.of_node, stem: fsi_dev_type_names[type]); |
954 | |
955 | if (aid >= 0) { |
956 | /* Use the same scheme as the legacy numbers. */ |
957 | int id = (aid << 2) | type; |
958 | |
959 | id = ida_alloc_range(&fsi_minor_ida, min: id, max: id, GFP_KERNEL); |
960 | if (id >= 0) { |
961 | *out_index = aid; |
962 | *out_dev = fsi_base_dev + id; |
963 | return 0; |
964 | } |
965 | |
966 | if (id != -ENOSPC) |
967 | return id; |
968 | } |
969 | } |
970 | |
971 | return __fsi_get_new_minor(slave: fdev->slave, type, out_dev, out_index); |
972 | } |
973 | EXPORT_SYMBOL_GPL(fsi_get_new_minor); |
974 | |
975 | void fsi_free_minor(dev_t dev) |
976 | { |
977 | ida_free(&fsi_minor_ida, MINOR(dev)); |
978 | } |
979 | EXPORT_SYMBOL_GPL(fsi_free_minor); |
980 | |
981 | static int fsi_slave_init(struct fsi_master *master, int link, uint8_t id) |
982 | { |
983 | uint32_t cfam_id; |
984 | struct fsi_slave *slave; |
985 | uint8_t crc; |
986 | __be32 data, llmode, slbus; |
987 | int rc; |
988 | |
989 | /* Currently, we only support single slaves on a link, and use the |
990 | * full 23-bit address range |
991 | */ |
992 | if (id != 0) |
993 | return -EINVAL; |
994 | |
995 | rc = fsi_master_read(master, link, slave_id: id, addr: 0, val: &data, size: sizeof(data)); |
996 | if (rc) { |
997 | dev_dbg(&master->dev, "can't read slave %02x:%02x %d\n" , |
998 | link, id, rc); |
999 | return -ENODEV; |
1000 | } |
1001 | cfam_id = be32_to_cpu(data); |
1002 | |
1003 | crc = crc4(c: 0, x: cfam_id, bits: 32); |
1004 | if (crc) { |
1005 | trace_fsi_slave_invalid_cfam(master, link, cfam_id); |
1006 | dev_warn(&master->dev, "slave %02x:%02x invalid cfam id CRC!\n" , |
1007 | link, id); |
1008 | return -EIO; |
1009 | } |
1010 | |
1011 | dev_dbg(&master->dev, "fsi: found chip %08x at %02x:%02x:%02x\n" , |
1012 | cfam_id, master->idx, link, id); |
1013 | |
1014 | /* If we're behind a master that doesn't provide a self-running bus |
1015 | * clock, put the slave into async mode |
1016 | */ |
1017 | if (master->flags & FSI_MASTER_FLAG_SWCLOCK) { |
1018 | llmode = cpu_to_be32(FSI_LLMODE_ASYNC); |
1019 | rc = fsi_master_write(master, link, slave_id: id, |
1020 | FSI_SLAVE_BASE + FSI_LLMODE, |
1021 | val: &llmode, size: sizeof(llmode)); |
1022 | if (rc) |
1023 | dev_warn(&master->dev, |
1024 | "can't set llmode on slave:%02x:%02x %d\n" , |
1025 | link, id, rc); |
1026 | } |
1027 | |
1028 | /* We can communicate with a slave; create the slave device and |
1029 | * register. |
1030 | */ |
1031 | slave = kzalloc(size: sizeof(*slave), GFP_KERNEL); |
1032 | if (!slave) |
1033 | return -ENOMEM; |
1034 | |
1035 | dev_set_name(dev: &slave->dev, name: "slave@%02x:%02x" , link, id); |
1036 | slave->dev.type = &cfam_type; |
1037 | slave->dev.parent = &master->dev; |
1038 | slave->dev.of_node = fsi_slave_find_of_node(master, link, id); |
1039 | slave->dev.release = fsi_slave_release; |
1040 | device_initialize(dev: &slave->dev); |
1041 | slave->cfam_id = cfam_id; |
1042 | slave->master = master; |
1043 | slave->link = link; |
1044 | slave->id = id; |
1045 | slave->size = FSI_SLAVE_SIZE_23b; |
1046 | slave->t_send_delay = 16; |
1047 | slave->t_echo_delay = 16; |
1048 | |
1049 | /* Get chip ID if any */ |
1050 | slave->chip_id = -1; |
1051 | if (slave->dev.of_node) { |
1052 | uint32_t prop; |
1053 | if (!of_property_read_u32(np: slave->dev.of_node, propname: "chip-id" , out_value: &prop)) |
1054 | slave->chip_id = prop; |
1055 | |
1056 | } |
1057 | |
1058 | slbus = cpu_to_be32(FSI_SLBUS_FORCE); |
1059 | rc = fsi_master_write(master, link, slave_id: id, FSI_SLAVE_BASE + FSI_SLBUS, |
1060 | val: &slbus, size: sizeof(slbus)); |
1061 | if (rc) |
1062 | dev_warn(&master->dev, |
1063 | "can't set slbus on slave:%02x:%02x %d\n" , link, id, |
1064 | rc); |
1065 | |
1066 | rc = fsi_slave_set_smode(slave); |
1067 | if (rc) { |
1068 | dev_warn(&master->dev, |
1069 | "can't set smode on slave:%02x:%02x %d\n" , |
1070 | link, id, rc); |
1071 | goto err_free; |
1072 | } |
1073 | |
1074 | /* Allocate a minor in the FSI space */ |
1075 | rc = __fsi_get_new_minor(slave, type: fsi_dev_cfam, out_dev: &slave->dev.devt, |
1076 | out_index: &slave->cdev_idx); |
1077 | if (rc) |
1078 | goto err_free; |
1079 | |
1080 | trace_fsi_slave_init(slave); |
1081 | |
1082 | /* Create chardev for userspace access */ |
1083 | cdev_init(&slave->cdev, &cfam_fops); |
1084 | rc = cdev_device_add(cdev: &slave->cdev, dev: &slave->dev); |
1085 | if (rc) { |
1086 | dev_err(&slave->dev, "Error %d creating slave device\n" , rc); |
1087 | goto err_free_ida; |
1088 | } |
1089 | |
1090 | /* Now that we have the cdev registered with the core, any fatal |
1091 | * failures beyond this point will need to clean up through |
1092 | * cdev_device_del(). Fortunately though, nothing past here is fatal. |
1093 | */ |
1094 | |
1095 | if (master->link_config) |
1096 | master->link_config(master, link, |
1097 | slave->t_send_delay, |
1098 | slave->t_echo_delay); |
1099 | |
1100 | /* Legacy raw file -> to be removed */ |
1101 | rc = device_create_bin_file(dev: &slave->dev, attr: &fsi_slave_raw_attr); |
1102 | if (rc) |
1103 | dev_warn(&slave->dev, "failed to create raw attr: %d\n" , rc); |
1104 | |
1105 | |
1106 | rc = fsi_slave_scan(slave); |
1107 | if (rc) |
1108 | dev_dbg(&master->dev, "failed during slave scan with: %d\n" , |
1109 | rc); |
1110 | |
1111 | return 0; |
1112 | |
1113 | err_free_ida: |
1114 | fsi_free_minor(slave->dev.devt); |
1115 | err_free: |
1116 | of_node_put(node: slave->dev.of_node); |
1117 | kfree(objp: slave); |
1118 | return rc; |
1119 | } |
1120 | |
1121 | /* FSI master support */ |
1122 | static int fsi_check_access(uint32_t addr, size_t size) |
1123 | { |
1124 | if (size == 4) { |
1125 | if (addr & 0x3) |
1126 | return -EINVAL; |
1127 | } else if (size == 2) { |
1128 | if (addr & 0x1) |
1129 | return -EINVAL; |
1130 | } else if (size != 1) |
1131 | return -EINVAL; |
1132 | |
1133 | return 0; |
1134 | } |
1135 | |
1136 | static int fsi_master_read(struct fsi_master *master, int link, |
1137 | uint8_t slave_id, uint32_t addr, void *val, size_t size) |
1138 | { |
1139 | int rc; |
1140 | |
1141 | trace_fsi_master_read(master, link, id: slave_id, addr, size); |
1142 | |
1143 | rc = fsi_check_access(addr, size); |
1144 | if (!rc) |
1145 | rc = master->read(master, link, slave_id, addr, val, size); |
1146 | |
1147 | trace_fsi_master_rw_result(master, link, id: slave_id, addr, size, |
1148 | write: false, data: val, ret: rc); |
1149 | |
1150 | return rc; |
1151 | } |
1152 | |
1153 | static int fsi_master_write(struct fsi_master *master, int link, |
1154 | uint8_t slave_id, uint32_t addr, const void *val, size_t size) |
1155 | { |
1156 | int rc; |
1157 | |
1158 | trace_fsi_master_write(master, link, id: slave_id, addr, size, data: val); |
1159 | |
1160 | rc = fsi_check_access(addr, size); |
1161 | if (!rc) |
1162 | rc = master->write(master, link, slave_id, addr, val, size); |
1163 | |
1164 | trace_fsi_master_rw_result(master, link, id: slave_id, addr, size, |
1165 | write: true, data: val, ret: rc); |
1166 | |
1167 | return rc; |
1168 | } |
1169 | |
1170 | static int fsi_master_link_disable(struct fsi_master *master, int link) |
1171 | { |
1172 | if (master->link_enable) |
1173 | return master->link_enable(master, link, false); |
1174 | |
1175 | return 0; |
1176 | } |
1177 | |
1178 | static int fsi_master_link_enable(struct fsi_master *master, int link) |
1179 | { |
1180 | if (master->link_enable) |
1181 | return master->link_enable(master, link, true); |
1182 | |
1183 | return 0; |
1184 | } |
1185 | |
1186 | /* |
1187 | * Issue a break command on this link |
1188 | */ |
1189 | static int fsi_master_break(struct fsi_master *master, int link) |
1190 | { |
1191 | int rc = 0; |
1192 | |
1193 | trace_fsi_master_break(master, link); |
1194 | |
1195 | if (master->send_break) |
1196 | rc = master->send_break(master, link); |
1197 | if (master->link_config) |
1198 | master->link_config(master, link, 16, 16); |
1199 | |
1200 | return rc; |
1201 | } |
1202 | |
1203 | static int fsi_master_scan(struct fsi_master *master) |
1204 | { |
1205 | int link, rc; |
1206 | |
1207 | trace_fsi_master_scan(master, scan: true); |
1208 | for (link = 0; link < master->n_links; link++) { |
1209 | rc = fsi_master_link_enable(master, link); |
1210 | if (rc) { |
1211 | dev_dbg(&master->dev, |
1212 | "enable link %d failed: %d\n" , link, rc); |
1213 | continue; |
1214 | } |
1215 | rc = fsi_master_break(master, link); |
1216 | if (rc) { |
1217 | fsi_master_link_disable(master, link); |
1218 | dev_dbg(&master->dev, |
1219 | "break to link %d failed: %d\n" , link, rc); |
1220 | continue; |
1221 | } |
1222 | |
1223 | rc = fsi_slave_init(master, link, id: 0); |
1224 | if (rc) |
1225 | fsi_master_link_disable(master, link); |
1226 | } |
1227 | |
1228 | return 0; |
1229 | } |
1230 | |
1231 | static int fsi_slave_remove_device(struct device *dev, void *arg) |
1232 | { |
1233 | device_unregister(dev); |
1234 | return 0; |
1235 | } |
1236 | |
1237 | static int fsi_master_remove_slave(struct device *dev, void *arg) |
1238 | { |
1239 | struct fsi_slave *slave = to_fsi_slave(dev); |
1240 | |
1241 | device_for_each_child(dev, NULL, fn: fsi_slave_remove_device); |
1242 | cdev_device_del(cdev: &slave->cdev, dev: &slave->dev); |
1243 | put_device(dev); |
1244 | return 0; |
1245 | } |
1246 | |
1247 | static void fsi_master_unscan(struct fsi_master *master) |
1248 | { |
1249 | trace_fsi_master_scan(master, scan: false); |
1250 | device_for_each_child(dev: &master->dev, NULL, fn: fsi_master_remove_slave); |
1251 | } |
1252 | |
1253 | int fsi_master_rescan(struct fsi_master *master) |
1254 | { |
1255 | int rc; |
1256 | |
1257 | mutex_lock(&master->scan_lock); |
1258 | fsi_master_unscan(master); |
1259 | rc = fsi_master_scan(master); |
1260 | mutex_unlock(lock: &master->scan_lock); |
1261 | |
1262 | return rc; |
1263 | } |
1264 | EXPORT_SYMBOL_GPL(fsi_master_rescan); |
1265 | |
1266 | static ssize_t master_rescan_store(struct device *dev, |
1267 | struct device_attribute *attr, const char *buf, size_t count) |
1268 | { |
1269 | struct fsi_master *master = to_fsi_master(dev); |
1270 | int rc; |
1271 | |
1272 | rc = fsi_master_rescan(master); |
1273 | if (rc < 0) |
1274 | return rc; |
1275 | |
1276 | return count; |
1277 | } |
1278 | |
1279 | static DEVICE_ATTR(rescan, 0200, NULL, master_rescan_store); |
1280 | |
1281 | static ssize_t master_break_store(struct device *dev, |
1282 | struct device_attribute *attr, const char *buf, size_t count) |
1283 | { |
1284 | struct fsi_master *master = to_fsi_master(dev); |
1285 | |
1286 | fsi_master_break(master, link: 0); |
1287 | |
1288 | return count; |
1289 | } |
1290 | |
1291 | static DEVICE_ATTR(break, 0200, NULL, master_break_store); |
1292 | |
1293 | static struct attribute *master_attrs[] = { |
1294 | &dev_attr_break.attr, |
1295 | &dev_attr_rescan.attr, |
1296 | NULL |
1297 | }; |
1298 | |
1299 | ATTRIBUTE_GROUPS(master); |
1300 | |
1301 | static struct class fsi_master_class = { |
1302 | .name = "fsi-master" , |
1303 | .dev_groups = master_groups, |
1304 | }; |
1305 | |
1306 | int fsi_master_register(struct fsi_master *master) |
1307 | { |
1308 | int rc; |
1309 | struct device_node *np; |
1310 | |
1311 | mutex_init(&master->scan_lock); |
1312 | |
1313 | /* Alloc the requested index if it's non-zero */ |
1314 | if (master->idx) { |
1315 | master->idx = ida_alloc_range(&master_ida, min: master->idx, |
1316 | max: master->idx, GFP_KERNEL); |
1317 | } else { |
1318 | master->idx = ida_alloc(ida: &master_ida, GFP_KERNEL); |
1319 | } |
1320 | |
1321 | if (master->idx < 0) |
1322 | return master->idx; |
1323 | |
1324 | if (!dev_name(dev: &master->dev)) |
1325 | dev_set_name(dev: &master->dev, name: "fsi%d" , master->idx); |
1326 | |
1327 | master->dev.class = &fsi_master_class; |
1328 | |
1329 | mutex_lock(&master->scan_lock); |
1330 | rc = device_register(dev: &master->dev); |
1331 | if (rc) { |
1332 | ida_free(&master_ida, id: master->idx); |
1333 | goto out; |
1334 | } |
1335 | |
1336 | np = dev_of_node(dev: &master->dev); |
1337 | if (!of_property_read_bool(np, propname: "no-scan-on-init" )) { |
1338 | fsi_master_scan(master); |
1339 | } |
1340 | out: |
1341 | mutex_unlock(lock: &master->scan_lock); |
1342 | return rc; |
1343 | } |
1344 | EXPORT_SYMBOL_GPL(fsi_master_register); |
1345 | |
1346 | void fsi_master_unregister(struct fsi_master *master) |
1347 | { |
1348 | int idx = master->idx; |
1349 | |
1350 | trace_fsi_master_unregister(master); |
1351 | |
1352 | mutex_lock(&master->scan_lock); |
1353 | fsi_master_unscan(master); |
1354 | master->n_links = 0; |
1355 | mutex_unlock(lock: &master->scan_lock); |
1356 | |
1357 | device_unregister(dev: &master->dev); |
1358 | ida_free(&master_ida, id: idx); |
1359 | } |
1360 | EXPORT_SYMBOL_GPL(fsi_master_unregister); |
1361 | |
1362 | /* FSI core & Linux bus type definitions */ |
1363 | |
1364 | static int fsi_bus_match(struct device *dev, struct device_driver *drv) |
1365 | { |
1366 | struct fsi_device *fsi_dev = to_fsi_dev(dev); |
1367 | struct fsi_driver *fsi_drv = to_fsi_drv(drv); |
1368 | const struct fsi_device_id *id; |
1369 | |
1370 | if (!fsi_drv->id_table) |
1371 | return 0; |
1372 | |
1373 | for (id = fsi_drv->id_table; id->engine_type; id++) { |
1374 | if (id->engine_type != fsi_dev->engine_type) |
1375 | continue; |
1376 | if (id->version == FSI_VERSION_ANY || |
1377 | id->version == fsi_dev->version) { |
1378 | if (drv->of_match_table) { |
1379 | if (of_driver_match_device(dev, drv)) |
1380 | return 1; |
1381 | } else { |
1382 | return 1; |
1383 | } |
1384 | } |
1385 | } |
1386 | |
1387 | return 0; |
1388 | } |
1389 | |
1390 | int fsi_driver_register(struct fsi_driver *fsi_drv) |
1391 | { |
1392 | if (!fsi_drv) |
1393 | return -EINVAL; |
1394 | if (!fsi_drv->id_table) |
1395 | return -EINVAL; |
1396 | |
1397 | return driver_register(drv: &fsi_drv->drv); |
1398 | } |
1399 | EXPORT_SYMBOL_GPL(fsi_driver_register); |
1400 | |
1401 | void fsi_driver_unregister(struct fsi_driver *fsi_drv) |
1402 | { |
1403 | driver_unregister(drv: &fsi_drv->drv); |
1404 | } |
1405 | EXPORT_SYMBOL_GPL(fsi_driver_unregister); |
1406 | |
1407 | struct bus_type fsi_bus_type = { |
1408 | .name = "fsi" , |
1409 | .match = fsi_bus_match, |
1410 | }; |
1411 | EXPORT_SYMBOL_GPL(fsi_bus_type); |
1412 | |
1413 | static int __init fsi_init(void) |
1414 | { |
1415 | int rc; |
1416 | |
1417 | rc = alloc_chrdev_region(&fsi_base_dev, 0, FSI_CHAR_MAX_DEVICES, "fsi" ); |
1418 | if (rc) |
1419 | return rc; |
1420 | rc = bus_register(bus: &fsi_bus_type); |
1421 | if (rc) |
1422 | goto fail_bus; |
1423 | |
1424 | rc = class_register(class: &fsi_master_class); |
1425 | if (rc) |
1426 | goto fail_class; |
1427 | |
1428 | return 0; |
1429 | |
1430 | fail_class: |
1431 | bus_unregister(bus: &fsi_bus_type); |
1432 | fail_bus: |
1433 | unregister_chrdev_region(fsi_base_dev, FSI_CHAR_MAX_DEVICES); |
1434 | return rc; |
1435 | } |
1436 | postcore_initcall(fsi_init); |
1437 | |
1438 | static void fsi_exit(void) |
1439 | { |
1440 | class_unregister(class: &fsi_master_class); |
1441 | bus_unregister(bus: &fsi_bus_type); |
1442 | unregister_chrdev_region(fsi_base_dev, FSI_CHAR_MAX_DEVICES); |
1443 | ida_destroy(ida: &fsi_minor_ida); |
1444 | } |
1445 | module_exit(fsi_exit); |
1446 | module_param(discard_errors, int, 0664); |
1447 | MODULE_LICENSE("GPL" ); |
1448 | MODULE_PARM_DESC(discard_errors, "Don't invoke error handling on bus accesses" ); |
1449 | |