projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge tag 'drm-next-2019-01-05' of git://anongit.freedesktop.org/drm/drm
[linux-2.6-block.git] / drivers / fsi / fsi-core.c
CommitLineData
0508ad1f
JK		 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.
d1dcd678
BH		 14 *
15 * TODO:
16 * - Rework topology
17 * - s/chip_id/chip_loc
18 * - s/cfam/chip (cfam_id -> chip_id etc...)
0508ad1f
JK		 19 */
20
2b545cd8 21#include <linux/crc4.h>
0508ad1f
JK		 22#include <linux/device.h>
23#include <linux/fsi.h>
09aecfab 24#include <linux/idr.h>
0508ad1f 25#include <linux/module.h>
f6a2f8eb 26#include <linux/of.h>
2b545cd8 27#include <linux/slab.h>
f7ade2a6 28#include <linux/bitops.h>
d1dcd678
BH		 29#include <linux/cdev.h>
30#include <linux/fs.h>
31#include <linux/uaccess.h>
0508ad1f 32
09aecfab
JK		 33#include "fsi-master.h"
34
66433b05
JK		 35#define CREATE_TRACE_POINTS
36#include <trace/events/fsi.h>
37
f7ade2a6
JK		 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
4efe37f4
JK		 49#define FSI_PEEK_BASE 0x410
50
f7ade2a6
JK		 51static const int engine_page_size = 0x400;
52
2b37c3e2
CB		 53#define FSI_SLAVE_BASE 0x800
54
55/*
56 * FSI slave engine control register offsets
57 */
1fa847d7
JK		 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 */
4af889b0 61#define FSI_LLMODE 0x100 /* R/W: Link layer mode register */
2b37c3e2
CB		 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
4af889b0
JK		 77/*
78 * LLMODE fields
79 */
80#define FSI_LLMODE_ASYNC 0x1
81
2b545cd8
JK		 82#define FSI_SLAVE_SIZE_23b 0x800000
83
09aecfab
JK		 84static DEFINE_IDA(master_ida);
85
faf0b116
JK		 86struct fsi_slave {
87 struct device dev;
88 struct fsi_master *master;
d1dcd678
BH		 89 struct cdev cdev;
90 int cdev_idx;
91 int id; /* FSI address */
92 int link; /* FSI link# */
93 u32 cfam_id;
0a213777 94 int chip_id;
faf0b116 95 uint32_t size; /* size of slave address space */
a2e7da86
BH		 96 u8 t_send_delay;
97 u8 t_echo_delay;
faf0b116
JK		 98};
99
cd0fdb5c 100#define to_fsi_master(d) container_of(d, struct fsi_master, dev)
faf0b116
JK		 101#define to_fsi_slave(d) container_of(d, struct fsi_slave, dev)
102
1fa847d7
JK		 103static const int slave_retries = 2;
104static int discard_errors;
105
0ab5fe53
BH		 106static dev_t fsi_base_dev;
107static 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
014c2abc
JK		 113static int fsi_master_read(struct fsi_master *master, int link,
114 uint8_t slave_id, uint32_t addr, void *val, size_t size);
115static int fsi_master_write(struct fsi_master *master, int link,
116 uint8_t slave_id, uint32_t addr, const void *val, size_t size);
1fa847d7 117static int fsi_master_break(struct fsi_master *master, int link);
4efe37f4
JK		 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 */
136int 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}
144EXPORT_SYMBOL_GPL(fsi_device_read);
145
146int 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}
154EXPORT_SYMBOL_GPL(fsi_device_write);
155
156int fsi_device_peek(struct fsi_device *dev, void *val)
157{
158 uint32_t addr = FSI_PEEK_BASE + ((dev->unit - 2) * sizeof(uint32_t));
014c2abc 159
4efe37f4
JK		 160 return fsi_slave_read(dev->slave, addr, val, sizeof(uint32_t));
161}
f7ade2a6
JK		 162
163static void fsi_device_release(struct device *_device)
164{
165 struct fsi_device *device = to_fsi_dev(_device);
166
f6a2f8eb 167 of_node_put(device->dev.of_node);
f7ade2a6
JK		 168 kfree(device);
169}
170
171static 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
414c1026 186/* FSI slave support */
014c2abc
JK		 187static 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
ed50a089 211static int fsi_slave_report_and_clear_errors(struct fsi_slave *slave)
1fa847d7
JK		 212{
213 struct fsi_master *master = slave->master;
11454d6d 214 __be32 irq, stat;
1fa847d7
JK		 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
638bd9ac 231 dev_dbg(&slave->dev, "status: 0x%08x, sisc: 0x%08x\n",
1fa847d7
JK		 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
935f9636
BH		 239/* Encode slave local bus echo delay */
240static 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 */
246static 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 */
252static 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 */
258static inline uint32_t fsi_smode_sid(int x)
259{
260 return (x & FSI_SMODE_SID_MASK) << FSI_SMODE_SID_SHIFT;
261}
262
a2e7da86 263static uint32_t fsi_slave_smode(int id, u8 t_senddly, u8 t_echodly)
935f9636
BH		 264{
265 return FSI_SMODE_WSC | FSI_SMODE_ECRC
266 | fsi_smode_sid(id)
a2e7da86 267 | fsi_smode_echodly(t_echodly - 1) | fsi_smode_senddly(t_senddly - 1)
935f9636
BH		 268 | fsi_smode_lbcrr(0x8);
269}
270
a2e7da86 271static int fsi_slave_set_smode(struct fsi_slave *slave)
935f9636
BH		 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 */
a2e7da86 279 smode = fsi_slave_smode(slave->id, slave->t_send_delay, slave->t_echo_delay);
935f9636
BH		 280 data = cpu_to_be32(smode);
281
a2e7da86
BH		 282 return fsi_master_write(slave->master, slave->link, slave->id,
283 FSI_SLAVE_BASE + FSI_SMODE,
284 &data, sizeof(data));
935f9636 285}
1fa847d7 286
ed50a089
CIK		 287static int fsi_slave_handle_error(struct fsi_slave *slave, bool write,
288 uint32_t addr, size_t size)
1fa847d7
JK		 289{
290 struct fsi_master *master = slave->master;
291 int rc, link;
292 uint32_t reg;
a2e7da86 293 uint8_t id, send_delay, echo_delay;
1fa847d7
JK		 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
a2e7da86
BH		 324 send_delay = slave->t_send_delay;
325 echo_delay = slave->t_echo_delay;
326
1fa847d7
JK		 327 /* getting serious, reset the slave via BREAK */
328 rc = fsi_master_break(master, link);
329 if (rc)
330 return rc;
331
a2e7da86
BH		 332 slave->t_send_delay = send_delay;
333 slave->t_echo_delay = echo_delay;
334
335 rc = fsi_slave_set_smode(slave);
1fa847d7
JK		 336 if (rc)
337 return rc;
338
a2e7da86
BH		 339 if (master->link_config)
340 master->link_config(master, link,
341 slave->t_send_delay,
342 slave->t_echo_delay);
343
1fa847d7
JK		 344 return fsi_slave_report_and_clear_errors(slave);
345}
346
da36cadf 347int fsi_slave_read(struct fsi_slave *slave, uint32_t addr,
014c2abc
JK		 348 void *val, size_t size)
349{
350 uint8_t id = slave->id;
1fa847d7 351 int rc, err_rc, i;
014c2abc
JK		 352
353 rc = fsi_slave_calc_addr(slave, &addr, &id);
354 if (rc)
355 return rc;
356
1fa847d7
JK		 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;
014c2abc 369}
da36cadf 370EXPORT_SYMBOL_GPL(fsi_slave_read);
014c2abc 371
da36cadf 372int fsi_slave_write(struct fsi_slave *slave, uint32_t addr,
014c2abc
JK		 373 const void *val, size_t size)
374{
375 uint8_t id = slave->id;
1fa847d7 376 int rc, err_rc, i;
014c2abc
JK		 377
378 rc = fsi_slave_calc_addr(slave, &addr, &id);
379 if (rc)
380 return rc;
381
1fa847d7
JK		 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;
014c2abc 394}
da36cadf
JK		 395EXPORT_SYMBOL_GPL(fsi_slave_write);
396
397extern 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}
409EXPORT_SYMBOL_GPL(fsi_slave_claim_range);
410
411extern void fsi_slave_release_range(struct fsi_slave *slave,
412 uint32_t addr, uint32_t size)
413{
414}
415EXPORT_SYMBOL_GPL(fsi_slave_release_range);
014c2abc 416
f6a2f8eb
JK		 417static 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 */
451static 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
f7ade2a6
JK		 468static int fsi_slave_scan(struct fsi_slave *slave)
469{
470 uint32_t engine_addr;
f7ade2a6
JK		 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;
11454d6d
JS		 484 uint32_t conf;
485 __be32 data;
f7ade2a6 486
11454d6d
JS		 487 rc = fsi_slave_read(slave, (i + 1) * sizeof(data),
488 &data, sizeof(data));
f7ade2a6
JK		 489 if (rc) {
490 dev_warn(&slave->dev,
491 "error reading slave registers\n");
492 return -1;
493 }
11454d6d 494 conf = be32_to_cpu(data);
f7ade2a6
JK		 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);
f6a2f8eb 537 dev->dev.of_node = fsi_device_find_of_node(dev);
f7ade2a6
JK		 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
125739cb
JK		 555static 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
583static 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
061c0958 611static const struct bin_attribute fsi_slave_raw_attr = {
125739cb
JK		 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
2b545cd8
JK		 621static void fsi_slave_release(struct device *dev)
622{
623 struct fsi_slave *slave = to_fsi_slave(dev);
624
0ab5fe53 625 fsi_free_minor(slave->dev.devt);
f6a2f8eb 626 of_node_put(dev->of_node);
2b545cd8
JK		 627 kfree(slave);
628}
629
f6a2f8eb
JK		 630static 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 */
656static 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
d1dcd678
BH		 673static 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
709static 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
746static 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
761static 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
770static 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
778static 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
792static DEVICE_ATTR_WO(send_term);
793
a2e7da86
BH		 794static 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
803static 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
835static DEVICE_ATTR(send_echo_delays, 0600,
836 slave_send_echo_show, slave_send_echo_store);
837
0a213777
BH		 838static 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
847static DEVICE_ATTR_RO(chip_id);
848
d1dcd678
BH		 849static 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
858static DEVICE_ATTR_RO(cfam_id);
859
860static 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
868static const struct attribute_group cfam_attr_group = {
869 .attrs = cfam_attr,
870};
871
872static const struct attribute_group *cfam_attr_groups[] = {
873 &cfam_attr_group,
874 NULL,
875};
876
877static 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
889static const struct device_type cfam_type = {
890 .name = "cfam",
891 .devnode = cfam_devnode,
892 .groups = cfam_attr_groups
893};
894
0ab5fe53
BH		 895static 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
905const struct device_type fsi_cdev_type = {
906 .name = "fsi-cdev",
907 .devnode = fsi_cdev_devnode,
908};
909EXPORT_SYMBOL_GPL(fsi_cdev_type);
910
911/* Backward compatible /dev/ numbering in "old style" mode */
912static 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
921static 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
951int 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}
956EXPORT_SYMBOL_GPL(fsi_get_new_minor);
957
958void fsi_free_minor(dev_t dev)
959{
960 ida_simple_remove(&fsi_minor_ida, MINOR(dev));
961}
962EXPORT_SYMBOL_GPL(fsi_free_minor);
963
414c1026
JK		 964static int fsi_slave_init(struct fsi_master *master, int link, uint8_t id)
965{
d1dcd678 966 uint32_t cfam_id;
2b545cd8 967 struct fsi_slave *slave;
2b545cd8 968 uint8_t crc;
11454d6d 969 __be32 data, llmode;
2b545cd8
JK		 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
11454d6d 978 rc = fsi_master_read(master, link, id, 0, &data, sizeof(data));
2b545cd8
JK		 979 if (rc) {
980 dev_dbg(&master->dev, "can't read slave %02x:%02x %d\n",
981 link, id, rc);
982 return -ENODEV;
983 }
d1dcd678 984 cfam_id = be32_to_cpu(data);
2b545cd8 985
d1dcd678 986 crc = crc4(0, cfam_id, 32);
2b545cd8 987 if (crc) {
d1dcd678 988 dev_warn(&master->dev, "slave %02x:%02x invalid cfam id CRC!\n",
2b545cd8
JK		 989 link, id);
990 return -EIO;
991 }
992
638bd9ac 993 dev_dbg(&master->dev, "fsi: found chip %08x at %02x:%02x:%02x\n",
d1dcd678 994 cfam_id, master->idx, link, id);
2b545cd8 995
4af889b0
JK		 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
2b545cd8
JK		 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
d1dcd678
BH		 1017 dev_set_name(&slave->dev, "slave@%02x:%02x", link, id);
1018 slave->dev.type = &cfam_type;
2b545cd8 1019 slave->dev.parent = &master->dev;
f6a2f8eb 1020 slave->dev.of_node = fsi_slave_find_of_node(master, link, id);
2b545cd8 1021 slave->dev.release = fsi_slave_release;
d1dcd678
BH		 1022 device_initialize(&slave->dev);
1023 slave->cfam_id = cfam_id;
1024 slave->master = master;
2b545cd8
JK		 1025 slave->link = link;
1026 slave->id = id;
1027 slave->size = FSI_SLAVE_SIZE_23b;
a2e7da86
BH		 1028 slave->t_send_delay = 16;
1029 slave->t_echo_delay = 16;
1030
0a213777
BH		 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 }
d1dcd678
BH		 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
a2e7da86
BH		 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);
2b545cd8 1066
d1dcd678 1067 /* Legacy raw file -> to be removed */
125739cb
JK		 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
0a213777 1072
f7ade2a6
JK		 1073 rc = fsi_slave_scan(slave);
1074 if (rc)
1075 dev_dbg(&master->dev, "failed during slave scan with: %d\n",
1076 rc);
414c1026 1077
2b545cd8 1078 return rc;
d1dcd678
BH		 1079
1080 err_free:
1081 put_device(&slave->dev);
1082 return rc;
414c1026
JK		 1083}
1084
09aecfab 1085/* FSI master support */
014c2abc
JK		 1086static int fsi_check_access(uint32_t addr, size_t size)
1087{
99f039e9
EJ		 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)
014c2abc
JK		 1095 return -EINVAL;
1096
1097 return 0;
1098}
1099
1100static 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
66433b05
JK		 1105 trace_fsi_master_read(master, link, slave_id, addr, size);
1106
014c2abc 1107 rc = fsi_check_access(addr, size);
66433b05
JK		 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);
014c2abc 1113
66433b05 1114 return rc;
014c2abc
JK		 1115}
1116
1117static 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
66433b05
JK		 1122 trace_fsi_master_write(master, link, slave_id, addr, size, val);
1123
014c2abc 1124 rc = fsi_check_access(addr, size);
66433b05
JK		 1125 if (!rc)
1126 rc = master->write(master, link, slave_id, addr, val, size);
014c2abc 1127
66433b05
JK		 1128 trace_fsi_master_rw_result(master, link, slave_id, addr, size,
1129 true, val, rc);
1130
1131 return rc;
014c2abc
JK		 1132}
1133
26095282
CB		 1134static 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 */
1145static int fsi_master_break(struct fsi_master *master, int link)
1146{
a2e7da86
BH		 1147 int rc = 0;
1148
66433b05
JK		 1149 trace_fsi_master_break(master, link);
1150
26095282 1151 if (master->send_break)
a2e7da86
BH		 1152 rc = master->send_break(master, link);
1153 if (master->link_config)
1154 master->link_config(master, link, 16, 16);
26095282 1155
a2e7da86 1156 return rc;
26095282
CB		 1157}
1158
414c1026
JK		 1159static int fsi_master_scan(struct fsi_master *master)
1160{
26095282
CB		 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 }
414c1026 1176
414c1026 1177 fsi_slave_init(master, link, 0);
26095282 1178 }
414c1026
JK		 1179
1180 return 0;
1181}
1182
cd0fdb5c
CB		 1183static int fsi_slave_remove_device(struct device *dev, void *arg)
1184{
1185 device_unregister(dev);
1186 return 0;
1187}
1188
1189static int fsi_master_remove_slave(struct device *dev, void *arg)
1190{
d1dcd678
BH		 1191 struct fsi_slave *slave = to_fsi_slave(dev);
1192
cd0fdb5c 1193 device_for_each_child(dev, NULL, fsi_slave_remove_device);
d1dcd678 1194 cdev_device_del(&slave->cdev, &slave->dev);
0ab5fe53 1195 put_device(dev);
cd0fdb5c
CB		 1196 return 0;
1197}
1198
1199static void fsi_master_unscan(struct fsi_master *master)
1200{
1201 device_for_each_child(&master->dev, NULL, fsi_master_remove_slave);
1202}
1203
15362d69
JK		 1204int fsi_master_rescan(struct fsi_master *master)
1205{
9840fcd8
BH		 1206 int rc;
1207
1208 mutex_lock(&master->scan_lock);
15362d69 1209 fsi_master_unscan(master);
9840fcd8
BH		 1210 rc = fsi_master_scan(master);
1211 mutex_unlock(&master->scan_lock);
1212
1213 return rc;
15362d69
JK		 1214}
1215EXPORT_SYMBOL_GPL(fsi_master_rescan);
1216
cd0fdb5c
CB		 1217static 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
15362d69 1223 rc = fsi_master_rescan(master);
cd0fdb5c
CB		 1224 if (rc < 0)
1225 return rc;
1226
1227 return count;
1228}
1229
1230static DEVICE_ATTR(rescan, 0200, NULL, master_rescan_store);
1231
125739cb
JK		 1232static 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
1242static DEVICE_ATTR(break, 0200, NULL, master_break_store);
1243
09aecfab
JK		 1244int fsi_master_register(struct fsi_master *master)
1245{
1246 int rc;
f3aa2c6f 1247 struct device_node *np;
09aecfab 1248
9840fcd8 1249 mutex_init(&master->scan_lock);
09aecfab
JK		 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);
414c1026 1254 if (rc) {
09aecfab 1255 ida_simple_remove(&master_ida, master->idx);
414c1026
JK		 1256 return rc;
1257 }
09aecfab 1258
cd0fdb5c
CB		 1259 rc = device_create_file(&master->dev, &dev_attr_rescan);
1260 if (rc) {
265aac26 1261 device_del(&master->dev);
cd0fdb5c
CB		 1262 ida_simple_remove(&master_ida, master->idx);
1263 return rc;
1264 }
1265
125739cb
JK		 1266 rc = device_create_file(&master->dev, &dev_attr_break);
1267 if (rc) {
265aac26 1268 device_del(&master->dev);
125739cb
JK		 1269 ida_simple_remove(&master_ida, master->idx);
1270 return rc;
1271 }
1272
f3aa2c6f 1273 np = dev_of_node(&master->dev);
9840fcd8
BH		 1274 if (!of_property_read_bool(np, "no-scan-on-init")) {
1275 mutex_lock(&master->scan_lock);
f3aa2c6f 1276 fsi_master_scan(master);
9840fcd8
BH		 1277 mutex_unlock(&master->scan_lock);
1278 }
cd0fdb5c 1279
414c1026 1280 return 0;
09aecfab
JK		 1281}
1282EXPORT_SYMBOL_GPL(fsi_master_register);
1283
1284void 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
9840fcd8 1291 mutex_lock(&master->scan_lock);
cd0fdb5c 1292 fsi_master_unscan(master);
9840fcd8 1293 mutex_unlock(&master->scan_lock);
09aecfab
JK		 1294 device_unregister(&master->dev);
1295}
1296EXPORT_SYMBOL_GPL(fsi_master_unregister);
1297
0508ad1f
JK		 1298/* FSI core & Linux bus type definitions */
1299
dd37eed7
JK		 1300static 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
356d8009
CB		 1320int 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}
1329EXPORT_SYMBOL_GPL(fsi_driver_register);
1330
1331void fsi_driver_unregister(struct fsi_driver *fsi_drv)
1332{
1333 driver_unregister(&fsi_drv->drv);
1334}
1335EXPORT_SYMBOL_GPL(fsi_driver_unregister);
1336
0508ad1f
JK		 1337struct bus_type fsi_bus_type = {
1338 .name = "fsi",
dd37eed7 1339 .match = fsi_bus_match,
0508ad1f
JK		 1340};
1341EXPORT_SYMBOL_GPL(fsi_bus_type);
1342
496f8931 1343static int __init fsi_init(void)
0508ad1f 1344{
0ab5fe53
BH		 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;
0508ad1f 1358}
496f8931 1359postcore_initcall(fsi_init);
0508ad1f
JK		 1360
1361static void fsi_exit(void)
1362{
1363 bus_unregister(&fsi_bus_type);
0ab5fe53
BH		 1364 unregister_chrdev_region(fsi_base_dev, FSI_CHAR_MAX_DEVICES);
1365 ida_destroy(&fsi_minor_ida);
0508ad1f 1366}
0508ad1f 1367module_exit(fsi_exit);
1fa847d7 1368module_param(discard_errors, int, 0664);
acb7e8f7 1369MODULE_LICENSE("GPL");
1fa847d7 1370MODULE_PARM_DESC(discard_errors, "Don't invoke error handling on bus accesses");
Linux 6.x block layer and io_uring tree(s)