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