Merge tag 'i3c/fixes-for-5.0-rc5' of git://git.kernel.org/pub/scm/linux/kernel/git...
[sfrench/cifs-2.6.git] / drivers / i3c / master.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (C) 2018 Cadence Design Systems Inc.
4  *
5  * Author: Boris Brezillon <boris.brezillon@bootlin.com>
6  */
7
8 #include <linux/atomic.h>
9 #include <linux/bug.h>
10 #include <linux/device.h>
11 #include <linux/err.h>
12 #include <linux/export.h>
13 #include <linux/kernel.h>
14 #include <linux/list.h>
15 #include <linux/of.h>
16 #include <linux/slab.h>
17 #include <linux/spinlock.h>
18 #include <linux/workqueue.h>
19
20 #include "internals.h"
21
22 static DEFINE_IDR(i3c_bus_idr);
23 static DEFINE_MUTEX(i3c_core_lock);
24
25 /**
26  * i3c_bus_maintenance_lock - Lock the bus for a maintenance operation
27  * @bus: I3C bus to take the lock on
28  *
29  * This function takes the bus lock so that no other operations can occur on
30  * the bus. This is needed for all kind of bus maintenance operation, like
31  * - enabling/disabling slave events
32  * - re-triggering DAA
33  * - changing the dynamic address of a device
34  * - relinquishing mastership
35  * - ...
36  *
37  * The reason for this kind of locking is that we don't want drivers and core
38  * logic to rely on I3C device information that could be changed behind their
39  * back.
40  */
41 static void i3c_bus_maintenance_lock(struct i3c_bus *bus)
42 {
43         down_write(&bus->lock);
44 }
45
46 /**
47  * i3c_bus_maintenance_unlock - Release the bus lock after a maintenance
48  *                            operation
49  * @bus: I3C bus to release the lock on
50  *
51  * Should be called when the bus maintenance operation is done. See
52  * i3c_bus_maintenance_lock() for more details on what these maintenance
53  * operations are.
54  */
55 static void i3c_bus_maintenance_unlock(struct i3c_bus *bus)
56 {
57         up_write(&bus->lock);
58 }
59
60 /**
61  * i3c_bus_normaluse_lock - Lock the bus for a normal operation
62  * @bus: I3C bus to take the lock on
63  *
64  * This function takes the bus lock for any operation that is not a maintenance
65  * operation (see i3c_bus_maintenance_lock() for a non-exhaustive list of
66  * maintenance operations). Basically all communications with I3C devices are
67  * normal operations (HDR, SDR transfers or CCC commands that do not change bus
68  * state or I3C dynamic address).
69  *
70  * Note that this lock is not guaranteeing serialization of normal operations.
71  * In other words, transfer requests passed to the I3C master can be submitted
72  * in parallel and I3C master drivers have to use their own locking to make
73  * sure two different communications are not inter-mixed, or access to the
74  * output/input queue is not done while the engine is busy.
75  */
76 void i3c_bus_normaluse_lock(struct i3c_bus *bus)
77 {
78         down_read(&bus->lock);
79 }
80
81 /**
82  * i3c_bus_normaluse_unlock - Release the bus lock after a normal operation
83  * @bus: I3C bus to release the lock on
84  *
85  * Should be called when a normal operation is done. See
86  * i3c_bus_normaluse_lock() for more details on what these normal operations
87  * are.
88  */
89 void i3c_bus_normaluse_unlock(struct i3c_bus *bus)
90 {
91         up_read(&bus->lock);
92 }
93
94 static struct i3c_master_controller *dev_to_i3cmaster(struct device *dev)
95 {
96         return container_of(dev, struct i3c_master_controller, dev);
97 }
98
99 static const struct device_type i3c_device_type;
100
101 static struct i3c_bus *dev_to_i3cbus(struct device *dev)
102 {
103         struct i3c_master_controller *master;
104
105         if (dev->type == &i3c_device_type)
106                 return dev_to_i3cdev(dev)->bus;
107
108         master = dev_to_i3cmaster(dev);
109
110         return &master->bus;
111 }
112
113 static struct i3c_dev_desc *dev_to_i3cdesc(struct device *dev)
114 {
115         struct i3c_master_controller *master;
116
117         if (dev->type == &i3c_device_type)
118                 return dev_to_i3cdev(dev)->desc;
119
120         master = container_of(dev, struct i3c_master_controller, dev);
121
122         return master->this;
123 }
124
125 static ssize_t bcr_show(struct device *dev,
126                         struct device_attribute *da,
127                         char *buf)
128 {
129         struct i3c_bus *bus = dev_to_i3cbus(dev);
130         struct i3c_dev_desc *desc;
131         ssize_t ret;
132
133         i3c_bus_normaluse_lock(bus);
134         desc = dev_to_i3cdesc(dev);
135         ret = sprintf(buf, "%x\n", desc->info.bcr);
136         i3c_bus_normaluse_unlock(bus);
137
138         return ret;
139 }
140 static DEVICE_ATTR_RO(bcr);
141
142 static ssize_t dcr_show(struct device *dev,
143                         struct device_attribute *da,
144                         char *buf)
145 {
146         struct i3c_bus *bus = dev_to_i3cbus(dev);
147         struct i3c_dev_desc *desc;
148         ssize_t ret;
149
150         i3c_bus_normaluse_lock(bus);
151         desc = dev_to_i3cdesc(dev);
152         ret = sprintf(buf, "%x\n", desc->info.dcr);
153         i3c_bus_normaluse_unlock(bus);
154
155         return ret;
156 }
157 static DEVICE_ATTR_RO(dcr);
158
159 static ssize_t pid_show(struct device *dev,
160                         struct device_attribute *da,
161                         char *buf)
162 {
163         struct i3c_bus *bus = dev_to_i3cbus(dev);
164         struct i3c_dev_desc *desc;
165         ssize_t ret;
166
167         i3c_bus_normaluse_lock(bus);
168         desc = dev_to_i3cdesc(dev);
169         ret = sprintf(buf, "%llx\n", desc->info.pid);
170         i3c_bus_normaluse_unlock(bus);
171
172         return ret;
173 }
174 static DEVICE_ATTR_RO(pid);
175
176 static ssize_t dynamic_address_show(struct device *dev,
177                                     struct device_attribute *da,
178                                     char *buf)
179 {
180         struct i3c_bus *bus = dev_to_i3cbus(dev);
181         struct i3c_dev_desc *desc;
182         ssize_t ret;
183
184         i3c_bus_normaluse_lock(bus);
185         desc = dev_to_i3cdesc(dev);
186         ret = sprintf(buf, "%02x\n", desc->info.dyn_addr);
187         i3c_bus_normaluse_unlock(bus);
188
189         return ret;
190 }
191 static DEVICE_ATTR_RO(dynamic_address);
192
193 static const char * const hdrcap_strings[] = {
194         "hdr-ddr", "hdr-tsp", "hdr-tsl",
195 };
196
197 static ssize_t hdrcap_show(struct device *dev,
198                            struct device_attribute *da,
199                            char *buf)
200 {
201         struct i3c_bus *bus = dev_to_i3cbus(dev);
202         struct i3c_dev_desc *desc;
203         ssize_t offset = 0, ret;
204         unsigned long caps;
205         int mode;
206
207         i3c_bus_normaluse_lock(bus);
208         desc = dev_to_i3cdesc(dev);
209         caps = desc->info.hdr_cap;
210         for_each_set_bit(mode, &caps, 8) {
211                 if (mode >= ARRAY_SIZE(hdrcap_strings))
212                         break;
213
214                 if (!hdrcap_strings[mode])
215                         continue;
216
217                 ret = sprintf(buf + offset, offset ? " %s" : "%s",
218                               hdrcap_strings[mode]);
219                 if (ret < 0)
220                         goto out;
221
222                 offset += ret;
223         }
224
225         ret = sprintf(buf + offset, "\n");
226         if (ret < 0)
227                 goto out;
228
229         ret = offset + ret;
230
231 out:
232         i3c_bus_normaluse_unlock(bus);
233
234         return ret;
235 }
236 static DEVICE_ATTR_RO(hdrcap);
237
238 static struct attribute *i3c_device_attrs[] = {
239         &dev_attr_bcr.attr,
240         &dev_attr_dcr.attr,
241         &dev_attr_pid.attr,
242         &dev_attr_dynamic_address.attr,
243         &dev_attr_hdrcap.attr,
244         NULL,
245 };
246 ATTRIBUTE_GROUPS(i3c_device);
247
248 static int i3c_device_uevent(struct device *dev, struct kobj_uevent_env *env)
249 {
250         struct i3c_device *i3cdev = dev_to_i3cdev(dev);
251         struct i3c_device_info devinfo;
252         u16 manuf, part, ext;
253
254         i3c_device_get_info(i3cdev, &devinfo);
255         manuf = I3C_PID_MANUF_ID(devinfo.pid);
256         part = I3C_PID_PART_ID(devinfo.pid);
257         ext = I3C_PID_EXTRA_INFO(devinfo.pid);
258
259         if (I3C_PID_RND_LOWER_32BITS(devinfo.pid))
260                 return add_uevent_var(env, "MODALIAS=i3c:dcr%02Xmanuf%04X",
261                                       devinfo.dcr, manuf);
262
263         return add_uevent_var(env,
264                               "MODALIAS=i3c:dcr%02Xmanuf%04Xpart%04xext%04x",
265                               devinfo.dcr, manuf, part, ext);
266 }
267
268 static const struct device_type i3c_device_type = {
269         .groups = i3c_device_groups,
270         .uevent = i3c_device_uevent,
271 };
272
273 static const struct i3c_device_id *
274 i3c_device_match_id(struct i3c_device *i3cdev,
275                     const struct i3c_device_id *id_table)
276 {
277         struct i3c_device_info devinfo;
278         const struct i3c_device_id *id;
279
280         i3c_device_get_info(i3cdev, &devinfo);
281
282         /*
283          * The lower 32bits of the provisional ID is just filled with a random
284          * value, try to match using DCR info.
285          */
286         if (!I3C_PID_RND_LOWER_32BITS(devinfo.pid)) {
287                 u16 manuf = I3C_PID_MANUF_ID(devinfo.pid);
288                 u16 part = I3C_PID_PART_ID(devinfo.pid);
289                 u16 ext_info = I3C_PID_EXTRA_INFO(devinfo.pid);
290
291                 /* First try to match by manufacturer/part ID. */
292                 for (id = id_table; id->match_flags != 0; id++) {
293                         if ((id->match_flags & I3C_MATCH_MANUF_AND_PART) !=
294                             I3C_MATCH_MANUF_AND_PART)
295                                 continue;
296
297                         if (manuf != id->manuf_id || part != id->part_id)
298                                 continue;
299
300                         if ((id->match_flags & I3C_MATCH_EXTRA_INFO) &&
301                             ext_info != id->extra_info)
302                                 continue;
303
304                         return id;
305                 }
306         }
307
308         /* Fallback to DCR match. */
309         for (id = id_table; id->match_flags != 0; id++) {
310                 if ((id->match_flags & I3C_MATCH_DCR) &&
311                     id->dcr == devinfo.dcr)
312                         return id;
313         }
314
315         return NULL;
316 }
317
318 static int i3c_device_match(struct device *dev, struct device_driver *drv)
319 {
320         struct i3c_device *i3cdev;
321         struct i3c_driver *i3cdrv;
322
323         if (dev->type != &i3c_device_type)
324                 return 0;
325
326         i3cdev = dev_to_i3cdev(dev);
327         i3cdrv = drv_to_i3cdrv(drv);
328         if (i3c_device_match_id(i3cdev, i3cdrv->id_table))
329                 return 1;
330
331         return 0;
332 }
333
334 static int i3c_device_probe(struct device *dev)
335 {
336         struct i3c_device *i3cdev = dev_to_i3cdev(dev);
337         struct i3c_driver *driver = drv_to_i3cdrv(dev->driver);
338
339         return driver->probe(i3cdev);
340 }
341
342 static int i3c_device_remove(struct device *dev)
343 {
344         struct i3c_device *i3cdev = dev_to_i3cdev(dev);
345         struct i3c_driver *driver = drv_to_i3cdrv(dev->driver);
346         int ret;
347
348         ret = driver->remove(i3cdev);
349         if (ret)
350                 return ret;
351
352         i3c_device_free_ibi(i3cdev);
353
354         return ret;
355 }
356
357 struct bus_type i3c_bus_type = {
358         .name = "i3c",
359         .match = i3c_device_match,
360         .probe = i3c_device_probe,
361         .remove = i3c_device_remove,
362 };
363
364 static enum i3c_addr_slot_status
365 i3c_bus_get_addr_slot_status(struct i3c_bus *bus, u16 addr)
366 {
367         int status, bitpos = addr * 2;
368
369         if (addr > I2C_MAX_ADDR)
370                 return I3C_ADDR_SLOT_RSVD;
371
372         status = bus->addrslots[bitpos / BITS_PER_LONG];
373         status >>= bitpos % BITS_PER_LONG;
374
375         return status & I3C_ADDR_SLOT_STATUS_MASK;
376 }
377
378 static void i3c_bus_set_addr_slot_status(struct i3c_bus *bus, u16 addr,
379                                          enum i3c_addr_slot_status status)
380 {
381         int bitpos = addr * 2;
382         unsigned long *ptr;
383
384         if (addr > I2C_MAX_ADDR)
385                 return;
386
387         ptr = bus->addrslots + (bitpos / BITS_PER_LONG);
388         *ptr &= ~(I3C_ADDR_SLOT_STATUS_MASK << (bitpos % BITS_PER_LONG));
389         *ptr |= status << (bitpos % BITS_PER_LONG);
390 }
391
392 static bool i3c_bus_dev_addr_is_avail(struct i3c_bus *bus, u8 addr)
393 {
394         enum i3c_addr_slot_status status;
395
396         status = i3c_bus_get_addr_slot_status(bus, addr);
397
398         return status == I3C_ADDR_SLOT_FREE;
399 }
400
401 static int i3c_bus_get_free_addr(struct i3c_bus *bus, u8 start_addr)
402 {
403         enum i3c_addr_slot_status status;
404         u8 addr;
405
406         for (addr = start_addr; addr < I3C_MAX_ADDR; addr++) {
407                 status = i3c_bus_get_addr_slot_status(bus, addr);
408                 if (status == I3C_ADDR_SLOT_FREE)
409                         return addr;
410         }
411
412         return -ENOMEM;
413 }
414
415 static void i3c_bus_init_addrslots(struct i3c_bus *bus)
416 {
417         int i;
418
419         /* Addresses 0 to 7 are reserved. */
420         for (i = 0; i < 8; i++)
421                 i3c_bus_set_addr_slot_status(bus, i, I3C_ADDR_SLOT_RSVD);
422
423         /*
424          * Reserve broadcast address and all addresses that might collide
425          * with the broadcast address when facing a single bit error.
426          */
427         i3c_bus_set_addr_slot_status(bus, I3C_BROADCAST_ADDR,
428                                      I3C_ADDR_SLOT_RSVD);
429         for (i = 0; i < 7; i++)
430                 i3c_bus_set_addr_slot_status(bus, I3C_BROADCAST_ADDR ^ BIT(i),
431                                              I3C_ADDR_SLOT_RSVD);
432 }
433
434 static void i3c_bus_cleanup(struct i3c_bus *i3cbus)
435 {
436         mutex_lock(&i3c_core_lock);
437         idr_remove(&i3c_bus_idr, i3cbus->id);
438         mutex_unlock(&i3c_core_lock);
439 }
440
441 static int i3c_bus_init(struct i3c_bus *i3cbus)
442 {
443         int ret;
444
445         init_rwsem(&i3cbus->lock);
446         INIT_LIST_HEAD(&i3cbus->devs.i2c);
447         INIT_LIST_HEAD(&i3cbus->devs.i3c);
448         i3c_bus_init_addrslots(i3cbus);
449         i3cbus->mode = I3C_BUS_MODE_PURE;
450
451         mutex_lock(&i3c_core_lock);
452         ret = idr_alloc(&i3c_bus_idr, i3cbus, 0, 0, GFP_KERNEL);
453         mutex_unlock(&i3c_core_lock);
454
455         if (ret < 0)
456                 return ret;
457
458         i3cbus->id = ret;
459
460         return 0;
461 }
462
463 static const char * const i3c_bus_mode_strings[] = {
464         [I3C_BUS_MODE_PURE] = "pure",
465         [I3C_BUS_MODE_MIXED_FAST] = "mixed-fast",
466         [I3C_BUS_MODE_MIXED_SLOW] = "mixed-slow",
467 };
468
469 static ssize_t mode_show(struct device *dev,
470                          struct device_attribute *da,
471                          char *buf)
472 {
473         struct i3c_bus *i3cbus = dev_to_i3cbus(dev);
474         ssize_t ret;
475
476         i3c_bus_normaluse_lock(i3cbus);
477         if (i3cbus->mode < 0 ||
478             i3cbus->mode >= ARRAY_SIZE(i3c_bus_mode_strings) ||
479             !i3c_bus_mode_strings[i3cbus->mode])
480                 ret = sprintf(buf, "unknown\n");
481         else
482                 ret = sprintf(buf, "%s\n", i3c_bus_mode_strings[i3cbus->mode]);
483         i3c_bus_normaluse_unlock(i3cbus);
484
485         return ret;
486 }
487 static DEVICE_ATTR_RO(mode);
488
489 static ssize_t current_master_show(struct device *dev,
490                                    struct device_attribute *da,
491                                    char *buf)
492 {
493         struct i3c_bus *i3cbus = dev_to_i3cbus(dev);
494         ssize_t ret;
495
496         i3c_bus_normaluse_lock(i3cbus);
497         ret = sprintf(buf, "%d-%llx\n", i3cbus->id,
498                       i3cbus->cur_master->info.pid);
499         i3c_bus_normaluse_unlock(i3cbus);
500
501         return ret;
502 }
503 static DEVICE_ATTR_RO(current_master);
504
505 static ssize_t i3c_scl_frequency_show(struct device *dev,
506                                       struct device_attribute *da,
507                                       char *buf)
508 {
509         struct i3c_bus *i3cbus = dev_to_i3cbus(dev);
510         ssize_t ret;
511
512         i3c_bus_normaluse_lock(i3cbus);
513         ret = sprintf(buf, "%ld\n", i3cbus->scl_rate.i3c);
514         i3c_bus_normaluse_unlock(i3cbus);
515
516         return ret;
517 }
518 static DEVICE_ATTR_RO(i3c_scl_frequency);
519
520 static ssize_t i2c_scl_frequency_show(struct device *dev,
521                                       struct device_attribute *da,
522                                       char *buf)
523 {
524         struct i3c_bus *i3cbus = dev_to_i3cbus(dev);
525         ssize_t ret;
526
527         i3c_bus_normaluse_lock(i3cbus);
528         ret = sprintf(buf, "%ld\n", i3cbus->scl_rate.i2c);
529         i3c_bus_normaluse_unlock(i3cbus);
530
531         return ret;
532 }
533 static DEVICE_ATTR_RO(i2c_scl_frequency);
534
535 static struct attribute *i3c_masterdev_attrs[] = {
536         &dev_attr_mode.attr,
537         &dev_attr_current_master.attr,
538         &dev_attr_i3c_scl_frequency.attr,
539         &dev_attr_i2c_scl_frequency.attr,
540         &dev_attr_bcr.attr,
541         &dev_attr_dcr.attr,
542         &dev_attr_pid.attr,
543         &dev_attr_dynamic_address.attr,
544         &dev_attr_hdrcap.attr,
545         NULL,
546 };
547 ATTRIBUTE_GROUPS(i3c_masterdev);
548
549 static void i3c_masterdev_release(struct device *dev)
550 {
551         struct i3c_master_controller *master = dev_to_i3cmaster(dev);
552         struct i3c_bus *bus = dev_to_i3cbus(dev);
553
554         if (master->wq)
555                 destroy_workqueue(master->wq);
556
557         WARN_ON(!list_empty(&bus->devs.i2c) || !list_empty(&bus->devs.i3c));
558         i3c_bus_cleanup(bus);
559
560         of_node_put(dev->of_node);
561 }
562
563 static const struct device_type i3c_masterdev_type = {
564         .groups = i3c_masterdev_groups,
565 };
566
567 int i3c_bus_set_mode(struct i3c_bus *i3cbus, enum i3c_bus_mode mode)
568 {
569         i3cbus->mode = mode;
570
571         if (!i3cbus->scl_rate.i3c)
572                 i3cbus->scl_rate.i3c = I3C_BUS_TYP_I3C_SCL_RATE;
573
574         if (!i3cbus->scl_rate.i2c) {
575                 if (i3cbus->mode == I3C_BUS_MODE_MIXED_SLOW)
576                         i3cbus->scl_rate.i2c = I3C_BUS_I2C_FM_SCL_RATE;
577                 else
578                         i3cbus->scl_rate.i2c = I3C_BUS_I2C_FM_PLUS_SCL_RATE;
579         }
580
581         /*
582          * I3C/I2C frequency may have been overridden, check that user-provided
583          * values are not exceeding max possible frequency.
584          */
585         if (i3cbus->scl_rate.i3c > I3C_BUS_MAX_I3C_SCL_RATE ||
586             i3cbus->scl_rate.i2c > I3C_BUS_I2C_FM_PLUS_SCL_RATE)
587                 return -EINVAL;
588
589         return 0;
590 }
591
592 static struct i3c_master_controller *
593 i2c_adapter_to_i3c_master(struct i2c_adapter *adap)
594 {
595         return container_of(adap, struct i3c_master_controller, i2c);
596 }
597
598 static struct i2c_adapter *
599 i3c_master_to_i2c_adapter(struct i3c_master_controller *master)
600 {
601         return &master->i2c;
602 }
603
604 static void i3c_master_free_i2c_dev(struct i2c_dev_desc *dev)
605 {
606         kfree(dev);
607 }
608
609 static struct i2c_dev_desc *
610 i3c_master_alloc_i2c_dev(struct i3c_master_controller *master,
611                          const struct i2c_dev_boardinfo *boardinfo)
612 {
613         struct i2c_dev_desc *dev;
614
615         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
616         if (!dev)
617                 return ERR_PTR(-ENOMEM);
618
619         dev->common.master = master;
620         dev->boardinfo = boardinfo;
621
622         return dev;
623 }
624
625 static void *i3c_ccc_cmd_dest_init(struct i3c_ccc_cmd_dest *dest, u8 addr,
626                                    u16 payloadlen)
627 {
628         dest->addr = addr;
629         dest->payload.len = payloadlen;
630         if (payloadlen)
631                 dest->payload.data = kzalloc(payloadlen, GFP_KERNEL);
632         else
633                 dest->payload.data = NULL;
634
635         return dest->payload.data;
636 }
637
638 static void i3c_ccc_cmd_dest_cleanup(struct i3c_ccc_cmd_dest *dest)
639 {
640         kfree(dest->payload.data);
641 }
642
643 static void i3c_ccc_cmd_init(struct i3c_ccc_cmd *cmd, bool rnw, u8 id,
644                              struct i3c_ccc_cmd_dest *dests,
645                              unsigned int ndests)
646 {
647         cmd->rnw = rnw ? 1 : 0;
648         cmd->id = id;
649         cmd->dests = dests;
650         cmd->ndests = ndests;
651         cmd->err = I3C_ERROR_UNKNOWN;
652 }
653
654 static int i3c_master_send_ccc_cmd_locked(struct i3c_master_controller *master,
655                                           struct i3c_ccc_cmd *cmd)
656 {
657         int ret;
658
659         if (!cmd || !master)
660                 return -EINVAL;
661
662         if (WARN_ON(master->init_done &&
663                     !rwsem_is_locked(&master->bus.lock)))
664                 return -EINVAL;
665
666         if (!master->ops->send_ccc_cmd)
667                 return -ENOTSUPP;
668
669         if ((cmd->id & I3C_CCC_DIRECT) && (!cmd->dests || !cmd->ndests))
670                 return -EINVAL;
671
672         if (master->ops->supports_ccc_cmd &&
673             !master->ops->supports_ccc_cmd(master, cmd))
674                 return -ENOTSUPP;
675
676         ret = master->ops->send_ccc_cmd(master, cmd);
677         if (ret) {
678                 if (cmd->err != I3C_ERROR_UNKNOWN)
679                         return cmd->err;
680
681                 return ret;
682         }
683
684         return 0;
685 }
686
687 static struct i2c_dev_desc *
688 i3c_master_find_i2c_dev_by_addr(const struct i3c_master_controller *master,
689                                 u16 addr)
690 {
691         struct i2c_dev_desc *dev;
692
693         i3c_bus_for_each_i2cdev(&master->bus, dev) {
694                 if (dev->boardinfo->base.addr == addr)
695                         return dev;
696         }
697
698         return NULL;
699 }
700
701 /**
702  * i3c_master_get_free_addr() - get a free address on the bus
703  * @master: I3C master object
704  * @start_addr: where to start searching
705  *
706  * This function must be called with the bus lock held in write mode.
707  *
708  * Return: the first free address starting at @start_addr (included) or -ENOMEM
709  * if there's no more address available.
710  */
711 int i3c_master_get_free_addr(struct i3c_master_controller *master,
712                              u8 start_addr)
713 {
714         return i3c_bus_get_free_addr(&master->bus, start_addr);
715 }
716 EXPORT_SYMBOL_GPL(i3c_master_get_free_addr);
717
718 static void i3c_device_release(struct device *dev)
719 {
720         struct i3c_device *i3cdev = dev_to_i3cdev(dev);
721
722         WARN_ON(i3cdev->desc);
723
724         of_node_put(i3cdev->dev.of_node);
725         kfree(i3cdev);
726 }
727
728 static void i3c_master_free_i3c_dev(struct i3c_dev_desc *dev)
729 {
730         kfree(dev);
731 }
732
733 static struct i3c_dev_desc *
734 i3c_master_alloc_i3c_dev(struct i3c_master_controller *master,
735                          const struct i3c_device_info *info)
736 {
737         struct i3c_dev_desc *dev;
738
739         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
740         if (!dev)
741                 return ERR_PTR(-ENOMEM);
742
743         dev->common.master = master;
744         dev->info = *info;
745         mutex_init(&dev->ibi_lock);
746
747         return dev;
748 }
749
750 static int i3c_master_rstdaa_locked(struct i3c_master_controller *master,
751                                     u8 addr)
752 {
753         enum i3c_addr_slot_status addrstat;
754         struct i3c_ccc_cmd_dest dest;
755         struct i3c_ccc_cmd cmd;
756         int ret;
757
758         if (!master)
759                 return -EINVAL;
760
761         addrstat = i3c_bus_get_addr_slot_status(&master->bus, addr);
762         if (addr != I3C_BROADCAST_ADDR && addrstat != I3C_ADDR_SLOT_I3C_DEV)
763                 return -EINVAL;
764
765         i3c_ccc_cmd_dest_init(&dest, addr, 0);
766         i3c_ccc_cmd_init(&cmd, false,
767                          I3C_CCC_RSTDAA(addr == I3C_BROADCAST_ADDR),
768                          &dest, 1);
769         ret = i3c_master_send_ccc_cmd_locked(master, &cmd);
770         i3c_ccc_cmd_dest_cleanup(&dest);
771
772         return ret;
773 }
774
775 /**
776  * i3c_master_entdaa_locked() - start a DAA (Dynamic Address Assignment)
777  *                              procedure
778  * @master: master used to send frames on the bus
779  *
780  * Send a ENTDAA CCC command to start a DAA procedure.
781  *
782  * Note that this function only sends the ENTDAA CCC command, all the logic
783  * behind dynamic address assignment has to be handled in the I3C master
784  * driver.
785  *
786  * This function must be called with the bus lock held in write mode.
787  *
788  * Return: 0 in case of success, a positive I3C error code if the error is
789  * one of the official Mx error codes, and a negative error code otherwise.
790  */
791 int i3c_master_entdaa_locked(struct i3c_master_controller *master)
792 {
793         struct i3c_ccc_cmd_dest dest;
794         struct i3c_ccc_cmd cmd;
795         int ret;
796
797         i3c_ccc_cmd_dest_init(&dest, I3C_BROADCAST_ADDR, 0);
798         i3c_ccc_cmd_init(&cmd, false, I3C_CCC_ENTDAA, &dest, 1);
799         ret = i3c_master_send_ccc_cmd_locked(master, &cmd);
800         i3c_ccc_cmd_dest_cleanup(&dest);
801
802         return ret;
803 }
804 EXPORT_SYMBOL_GPL(i3c_master_entdaa_locked);
805
806 static int i3c_master_enec_disec_locked(struct i3c_master_controller *master,
807                                         u8 addr, bool enable, u8 evts)
808 {
809         struct i3c_ccc_events *events;
810         struct i3c_ccc_cmd_dest dest;
811         struct i3c_ccc_cmd cmd;
812         int ret;
813
814         events = i3c_ccc_cmd_dest_init(&dest, addr, sizeof(*events));
815         if (!events)
816                 return -ENOMEM;
817
818         events->events = evts;
819         i3c_ccc_cmd_init(&cmd, false,
820                          enable ?
821                          I3C_CCC_ENEC(addr == I3C_BROADCAST_ADDR) :
822                          I3C_CCC_DISEC(addr == I3C_BROADCAST_ADDR),
823                          &dest, 1);
824         ret = i3c_master_send_ccc_cmd_locked(master, &cmd);
825         i3c_ccc_cmd_dest_cleanup(&dest);
826
827         return ret;
828 }
829
830 /**
831  * i3c_master_disec_locked() - send a DISEC CCC command
832  * @master: master used to send frames on the bus
833  * @addr: a valid I3C slave address or %I3C_BROADCAST_ADDR
834  * @evts: events to disable
835  *
836  * Send a DISEC CCC command to disable some or all events coming from a
837  * specific slave, or all devices if @addr is %I3C_BROADCAST_ADDR.
838  *
839  * This function must be called with the bus lock held in write mode.
840  *
841  * Return: 0 in case of success, a positive I3C error code if the error is
842  * one of the official Mx error codes, and a negative error code otherwise.
843  */
844 int i3c_master_disec_locked(struct i3c_master_controller *master, u8 addr,
845                             u8 evts)
846 {
847         return i3c_master_enec_disec_locked(master, addr, false, evts);
848 }
849 EXPORT_SYMBOL_GPL(i3c_master_disec_locked);
850
851 /**
852  * i3c_master_enec_locked() - send an ENEC CCC command
853  * @master: master used to send frames on the bus
854  * @addr: a valid I3C slave address or %I3C_BROADCAST_ADDR
855  * @evts: events to disable
856  *
857  * Sends an ENEC CCC command to enable some or all events coming from a
858  * specific slave, or all devices if @addr is %I3C_BROADCAST_ADDR.
859  *
860  * This function must be called with the bus lock held in write mode.
861  *
862  * Return: 0 in case of success, a positive I3C error code if the error is
863  * one of the official Mx error codes, and a negative error code otherwise.
864  */
865 int i3c_master_enec_locked(struct i3c_master_controller *master, u8 addr,
866                            u8 evts)
867 {
868         return i3c_master_enec_disec_locked(master, addr, true, evts);
869 }
870 EXPORT_SYMBOL_GPL(i3c_master_enec_locked);
871
872 /**
873  * i3c_master_defslvs_locked() - send a DEFSLVS CCC command
874  * @master: master used to send frames on the bus
875  *
876  * Send a DEFSLVS CCC command containing all the devices known to the @master.
877  * This is useful when you have secondary masters on the bus to propagate
878  * device information.
879  *
880  * This should be called after all I3C devices have been discovered (in other
881  * words, after the DAA procedure has finished) and instantiated in
882  * &i3c_master_controller_ops->bus_init().
883  * It should also be called if a master ACKed an Hot-Join request and assigned
884  * a dynamic address to the device joining the bus.
885  *
886  * This function must be called with the bus lock held in write mode.
887  *
888  * Return: 0 in case of success, a positive I3C error code if the error is
889  * one of the official Mx error codes, and a negative error code otherwise.
890  */
891 int i3c_master_defslvs_locked(struct i3c_master_controller *master)
892 {
893         struct i3c_ccc_defslvs *defslvs;
894         struct i3c_ccc_dev_desc *desc;
895         struct i3c_ccc_cmd_dest dest;
896         struct i3c_dev_desc *i3cdev;
897         struct i2c_dev_desc *i2cdev;
898         struct i3c_ccc_cmd cmd;
899         struct i3c_bus *bus;
900         bool send = false;
901         int ndevs = 0, ret;
902
903         if (!master)
904                 return -EINVAL;
905
906         bus = i3c_master_get_bus(master);
907         i3c_bus_for_each_i3cdev(bus, i3cdev) {
908                 ndevs++;
909
910                 if (i3cdev == master->this)
911                         continue;
912
913                 if (I3C_BCR_DEVICE_ROLE(i3cdev->info.bcr) ==
914                     I3C_BCR_I3C_MASTER)
915                         send = true;
916         }
917
918         /* No other master on the bus, skip DEFSLVS. */
919         if (!send)
920                 return 0;
921
922         i3c_bus_for_each_i2cdev(bus, i2cdev)
923                 ndevs++;
924
925         defslvs = i3c_ccc_cmd_dest_init(&dest, I3C_BROADCAST_ADDR,
926                                         sizeof(*defslvs) +
927                                         ((ndevs - 1) *
928                                          sizeof(struct i3c_ccc_dev_desc)));
929         if (!defslvs)
930                 return -ENOMEM;
931
932         defslvs->count = ndevs;
933         defslvs->master.bcr = master->this->info.bcr;
934         defslvs->master.dcr = master->this->info.dcr;
935         defslvs->master.dyn_addr = master->this->info.dyn_addr << 1;
936         defslvs->master.static_addr = I3C_BROADCAST_ADDR << 1;
937
938         desc = defslvs->slaves;
939         i3c_bus_for_each_i2cdev(bus, i2cdev) {
940                 desc->lvr = i2cdev->boardinfo->lvr;
941                 desc->static_addr = i2cdev->boardinfo->base.addr << 1;
942                 desc++;
943         }
944
945         i3c_bus_for_each_i3cdev(bus, i3cdev) {
946                 /* Skip the I3C dev representing this master. */
947                 if (i3cdev == master->this)
948                         continue;
949
950                 desc->bcr = i3cdev->info.bcr;
951                 desc->dcr = i3cdev->info.dcr;
952                 desc->dyn_addr = i3cdev->info.dyn_addr << 1;
953                 desc->static_addr = i3cdev->info.static_addr << 1;
954                 desc++;
955         }
956
957         i3c_ccc_cmd_init(&cmd, false, I3C_CCC_DEFSLVS, &dest, 1);
958         ret = i3c_master_send_ccc_cmd_locked(master, &cmd);
959         i3c_ccc_cmd_dest_cleanup(&dest);
960
961         return ret;
962 }
963 EXPORT_SYMBOL_GPL(i3c_master_defslvs_locked);
964
965 static int i3c_master_setda_locked(struct i3c_master_controller *master,
966                                    u8 oldaddr, u8 newaddr, bool setdasa)
967 {
968         struct i3c_ccc_cmd_dest dest;
969         struct i3c_ccc_setda *setda;
970         struct i3c_ccc_cmd cmd;
971         int ret;
972
973         if (!oldaddr || !newaddr)
974                 return -EINVAL;
975
976         setda = i3c_ccc_cmd_dest_init(&dest, oldaddr, sizeof(*setda));
977         if (!setda)
978                 return -ENOMEM;
979
980         setda->addr = newaddr << 1;
981         i3c_ccc_cmd_init(&cmd, false,
982                          setdasa ? I3C_CCC_SETDASA : I3C_CCC_SETNEWDA,
983                          &dest, 1);
984         ret = i3c_master_send_ccc_cmd_locked(master, &cmd);
985         i3c_ccc_cmd_dest_cleanup(&dest);
986
987         return ret;
988 }
989
990 static int i3c_master_setdasa_locked(struct i3c_master_controller *master,
991                                      u8 static_addr, u8 dyn_addr)
992 {
993         return i3c_master_setda_locked(master, static_addr, dyn_addr, true);
994 }
995
996 static int i3c_master_setnewda_locked(struct i3c_master_controller *master,
997                                       u8 oldaddr, u8 newaddr)
998 {
999         return i3c_master_setda_locked(master, oldaddr, newaddr, false);
1000 }
1001
1002 static int i3c_master_getmrl_locked(struct i3c_master_controller *master,
1003                                     struct i3c_device_info *info)
1004 {
1005         struct i3c_ccc_cmd_dest dest;
1006         unsigned int expected_len;
1007         struct i3c_ccc_mrl *mrl;
1008         struct i3c_ccc_cmd cmd;
1009         int ret;
1010
1011         mrl = i3c_ccc_cmd_dest_init(&dest, info->dyn_addr, sizeof(*mrl));
1012         if (!mrl)
1013                 return -ENOMEM;
1014
1015         /*
1016          * When the device does not have IBI payload GETMRL only returns 2
1017          * bytes of data.
1018          */
1019         if (!(info->bcr & I3C_BCR_IBI_PAYLOAD))
1020                 dest.payload.len -= 1;
1021
1022         expected_len = dest.payload.len;
1023         i3c_ccc_cmd_init(&cmd, true, I3C_CCC_GETMRL, &dest, 1);
1024         ret = i3c_master_send_ccc_cmd_locked(master, &cmd);
1025         if (ret)
1026                 goto out;
1027
1028         if (dest.payload.len != expected_len) {
1029                 ret = -EIO;
1030                 goto out;
1031         }
1032
1033         info->max_read_len = be16_to_cpu(mrl->read_len);
1034
1035         if (info->bcr & I3C_BCR_IBI_PAYLOAD)
1036                 info->max_ibi_len = mrl->ibi_len;
1037
1038 out:
1039         i3c_ccc_cmd_dest_cleanup(&dest);
1040
1041         return ret;
1042 }
1043
1044 static int i3c_master_getmwl_locked(struct i3c_master_controller *master,
1045                                     struct i3c_device_info *info)
1046 {
1047         struct i3c_ccc_cmd_dest dest;
1048         struct i3c_ccc_mwl *mwl;
1049         struct i3c_ccc_cmd cmd;
1050         int ret;
1051
1052         mwl = i3c_ccc_cmd_dest_init(&dest, info->dyn_addr, sizeof(*mwl));
1053         if (!mwl)
1054                 return -ENOMEM;
1055
1056         i3c_ccc_cmd_init(&cmd, true, I3C_CCC_GETMWL, &dest, 1);
1057         ret = i3c_master_send_ccc_cmd_locked(master, &cmd);
1058         if (ret)
1059                 goto out;
1060
1061         if (dest.payload.len != sizeof(*mwl))
1062                 return -EIO;
1063
1064         info->max_write_len = be16_to_cpu(mwl->len);
1065
1066 out:
1067         i3c_ccc_cmd_dest_cleanup(&dest);
1068
1069         return ret;
1070 }
1071
1072 static int i3c_master_getmxds_locked(struct i3c_master_controller *master,
1073                                      struct i3c_device_info *info)
1074 {
1075         struct i3c_ccc_getmxds *getmaxds;
1076         struct i3c_ccc_cmd_dest dest;
1077         struct i3c_ccc_cmd cmd;
1078         int ret;
1079
1080         getmaxds = i3c_ccc_cmd_dest_init(&dest, info->dyn_addr,
1081                                          sizeof(*getmaxds));
1082         if (!getmaxds)
1083                 return -ENOMEM;
1084
1085         i3c_ccc_cmd_init(&cmd, true, I3C_CCC_GETMXDS, &dest, 1);
1086         ret = i3c_master_send_ccc_cmd_locked(master, &cmd);
1087         if (ret)
1088                 goto out;
1089
1090         if (dest.payload.len != 2 && dest.payload.len != 5) {
1091                 ret = -EIO;
1092                 goto out;
1093         }
1094
1095         info->max_read_ds = getmaxds->maxrd;
1096         info->max_write_ds = getmaxds->maxwr;
1097         if (dest.payload.len == 5)
1098                 info->max_read_turnaround = getmaxds->maxrdturn[0] |
1099                                             ((u32)getmaxds->maxrdturn[1] << 8) |
1100                                             ((u32)getmaxds->maxrdturn[2] << 16);
1101
1102 out:
1103         i3c_ccc_cmd_dest_cleanup(&dest);
1104
1105         return ret;
1106 }
1107
1108 static int i3c_master_gethdrcap_locked(struct i3c_master_controller *master,
1109                                        struct i3c_device_info *info)
1110 {
1111         struct i3c_ccc_gethdrcap *gethdrcap;
1112         struct i3c_ccc_cmd_dest dest;
1113         struct i3c_ccc_cmd cmd;
1114         int ret;
1115
1116         gethdrcap = i3c_ccc_cmd_dest_init(&dest, info->dyn_addr,
1117                                           sizeof(*gethdrcap));
1118         if (!gethdrcap)
1119                 return -ENOMEM;
1120
1121         i3c_ccc_cmd_init(&cmd, true, I3C_CCC_GETHDRCAP, &dest, 1);
1122         ret = i3c_master_send_ccc_cmd_locked(master, &cmd);
1123         if (ret)
1124                 goto out;
1125
1126         if (dest.payload.len != 1) {
1127                 ret = -EIO;
1128                 goto out;
1129         }
1130
1131         info->hdr_cap = gethdrcap->modes;
1132
1133 out:
1134         i3c_ccc_cmd_dest_cleanup(&dest);
1135
1136         return ret;
1137 }
1138
1139 static int i3c_master_getpid_locked(struct i3c_master_controller *master,
1140                                     struct i3c_device_info *info)
1141 {
1142         struct i3c_ccc_getpid *getpid;
1143         struct i3c_ccc_cmd_dest dest;
1144         struct i3c_ccc_cmd cmd;
1145         int ret, i;
1146
1147         getpid = i3c_ccc_cmd_dest_init(&dest, info->dyn_addr, sizeof(*getpid));
1148         if (!getpid)
1149                 return -ENOMEM;
1150
1151         i3c_ccc_cmd_init(&cmd, true, I3C_CCC_GETPID, &dest, 1);
1152         ret = i3c_master_send_ccc_cmd_locked(master, &cmd);
1153         if (ret)
1154                 goto out;
1155
1156         info->pid = 0;
1157         for (i = 0; i < sizeof(getpid->pid); i++) {
1158                 int sft = (sizeof(getpid->pid) - i - 1) * 8;
1159
1160                 info->pid |= (u64)getpid->pid[i] << sft;
1161         }
1162
1163 out:
1164         i3c_ccc_cmd_dest_cleanup(&dest);
1165
1166         return ret;
1167 }
1168
1169 static int i3c_master_getbcr_locked(struct i3c_master_controller *master,
1170                                     struct i3c_device_info *info)
1171 {
1172         struct i3c_ccc_getbcr *getbcr;
1173         struct i3c_ccc_cmd_dest dest;
1174         struct i3c_ccc_cmd cmd;
1175         int ret;
1176
1177         getbcr = i3c_ccc_cmd_dest_init(&dest, info->dyn_addr, sizeof(*getbcr));
1178         if (!getbcr)
1179                 return -ENOMEM;
1180
1181         i3c_ccc_cmd_init(&cmd, true, I3C_CCC_GETBCR, &dest, 1);
1182         ret = i3c_master_send_ccc_cmd_locked(master, &cmd);
1183         if (ret)
1184                 goto out;
1185
1186         info->bcr = getbcr->bcr;
1187
1188 out:
1189         i3c_ccc_cmd_dest_cleanup(&dest);
1190
1191         return ret;
1192 }
1193
1194 static int i3c_master_getdcr_locked(struct i3c_master_controller *master,
1195                                     struct i3c_device_info *info)
1196 {
1197         struct i3c_ccc_getdcr *getdcr;
1198         struct i3c_ccc_cmd_dest dest;
1199         struct i3c_ccc_cmd cmd;
1200         int ret;
1201
1202         getdcr = i3c_ccc_cmd_dest_init(&dest, info->dyn_addr, sizeof(*getdcr));
1203         if (!getdcr)
1204                 return -ENOMEM;
1205
1206         i3c_ccc_cmd_init(&cmd, true, I3C_CCC_GETDCR, &dest, 1);
1207         ret = i3c_master_send_ccc_cmd_locked(master, &cmd);
1208         if (ret)
1209                 goto out;
1210
1211         info->dcr = getdcr->dcr;
1212
1213 out:
1214         i3c_ccc_cmd_dest_cleanup(&dest);
1215
1216         return ret;
1217 }
1218
1219 static int i3c_master_retrieve_dev_info(struct i3c_dev_desc *dev)
1220 {
1221         struct i3c_master_controller *master = i3c_dev_get_master(dev);
1222         enum i3c_addr_slot_status slot_status;
1223         int ret;
1224
1225         if (!dev->info.dyn_addr)
1226                 return -EINVAL;
1227
1228         slot_status = i3c_bus_get_addr_slot_status(&master->bus,
1229                                                    dev->info.dyn_addr);
1230         if (slot_status == I3C_ADDR_SLOT_RSVD ||
1231             slot_status == I3C_ADDR_SLOT_I2C_DEV)
1232                 return -EINVAL;
1233
1234         ret = i3c_master_getpid_locked(master, &dev->info);
1235         if (ret)
1236                 return ret;
1237
1238         ret = i3c_master_getbcr_locked(master, &dev->info);
1239         if (ret)
1240                 return ret;
1241
1242         ret = i3c_master_getdcr_locked(master, &dev->info);
1243         if (ret)
1244                 return ret;
1245
1246         if (dev->info.bcr & I3C_BCR_MAX_DATA_SPEED_LIM) {
1247                 ret = i3c_master_getmxds_locked(master, &dev->info);
1248                 if (ret)
1249                         return ret;
1250         }
1251
1252         if (dev->info.bcr & I3C_BCR_IBI_PAYLOAD)
1253                 dev->info.max_ibi_len = 1;
1254
1255         i3c_master_getmrl_locked(master, &dev->info);
1256         i3c_master_getmwl_locked(master, &dev->info);
1257
1258         if (dev->info.bcr & I3C_BCR_HDR_CAP) {
1259                 ret = i3c_master_gethdrcap_locked(master, &dev->info);
1260                 if (ret)
1261                         return ret;
1262         }
1263
1264         return 0;
1265 }
1266
1267 static void i3c_master_put_i3c_addrs(struct i3c_dev_desc *dev)
1268 {
1269         struct i3c_master_controller *master = i3c_dev_get_master(dev);
1270
1271         if (dev->info.static_addr)
1272                 i3c_bus_set_addr_slot_status(&master->bus,
1273                                              dev->info.static_addr,
1274                                              I3C_ADDR_SLOT_FREE);
1275
1276         if (dev->info.dyn_addr)
1277                 i3c_bus_set_addr_slot_status(&master->bus, dev->info.dyn_addr,
1278                                              I3C_ADDR_SLOT_FREE);
1279
1280         if (dev->boardinfo && dev->boardinfo->init_dyn_addr)
1281                 i3c_bus_set_addr_slot_status(&master->bus, dev->info.dyn_addr,
1282                                              I3C_ADDR_SLOT_FREE);
1283 }
1284
1285 static int i3c_master_get_i3c_addrs(struct i3c_dev_desc *dev)
1286 {
1287         struct i3c_master_controller *master = i3c_dev_get_master(dev);
1288         enum i3c_addr_slot_status status;
1289
1290         if (!dev->info.static_addr && !dev->info.dyn_addr)
1291                 return 0;
1292
1293         if (dev->info.static_addr) {
1294                 status = i3c_bus_get_addr_slot_status(&master->bus,
1295                                                       dev->info.static_addr);
1296                 if (status != I3C_ADDR_SLOT_FREE)
1297                         return -EBUSY;
1298
1299                 i3c_bus_set_addr_slot_status(&master->bus,
1300                                              dev->info.static_addr,
1301                                              I3C_ADDR_SLOT_I3C_DEV);
1302         }
1303
1304         /*
1305          * ->init_dyn_addr should have been reserved before that, so, if we're
1306          * trying to apply a pre-reserved dynamic address, we should not try
1307          * to reserve the address slot a second time.
1308          */
1309         if (dev->info.dyn_addr &&
1310             (!dev->boardinfo ||
1311              dev->boardinfo->init_dyn_addr != dev->info.dyn_addr)) {
1312                 status = i3c_bus_get_addr_slot_status(&master->bus,
1313                                                       dev->info.dyn_addr);
1314                 if (status != I3C_ADDR_SLOT_FREE)
1315                         goto err_release_static_addr;
1316
1317                 i3c_bus_set_addr_slot_status(&master->bus, dev->info.dyn_addr,
1318                                              I3C_ADDR_SLOT_I3C_DEV);
1319         }
1320
1321         return 0;
1322
1323 err_release_static_addr:
1324         if (dev->info.static_addr)
1325                 i3c_bus_set_addr_slot_status(&master->bus,
1326                                              dev->info.static_addr,
1327                                              I3C_ADDR_SLOT_FREE);
1328
1329         return -EBUSY;
1330 }
1331
1332 static int i3c_master_attach_i3c_dev(struct i3c_master_controller *master,
1333                                      struct i3c_dev_desc *dev)
1334 {
1335         int ret;
1336
1337         /*
1338          * We don't attach devices to the controller until they are
1339          * addressable on the bus.
1340          */
1341         if (!dev->info.static_addr && !dev->info.dyn_addr)
1342                 return 0;
1343
1344         ret = i3c_master_get_i3c_addrs(dev);
1345         if (ret)
1346                 return ret;
1347
1348         /* Do not attach the master device itself. */
1349         if (master->this != dev && master->ops->attach_i3c_dev) {
1350                 ret = master->ops->attach_i3c_dev(dev);
1351                 if (ret) {
1352                         i3c_master_put_i3c_addrs(dev);
1353                         return ret;
1354                 }
1355         }
1356
1357         list_add_tail(&dev->common.node, &master->bus.devs.i3c);
1358
1359         return 0;
1360 }
1361
1362 static int i3c_master_reattach_i3c_dev(struct i3c_dev_desc *dev,
1363                                        u8 old_dyn_addr)
1364 {
1365         struct i3c_master_controller *master = i3c_dev_get_master(dev);
1366         enum i3c_addr_slot_status status;
1367         int ret;
1368
1369         if (dev->info.dyn_addr != old_dyn_addr) {
1370                 status = i3c_bus_get_addr_slot_status(&master->bus,
1371                                                       dev->info.dyn_addr);
1372                 if (status != I3C_ADDR_SLOT_FREE)
1373                         return -EBUSY;
1374                 i3c_bus_set_addr_slot_status(&master->bus,
1375                                              dev->info.dyn_addr,
1376                                              I3C_ADDR_SLOT_I3C_DEV);
1377         }
1378
1379         if (master->ops->reattach_i3c_dev) {
1380                 ret = master->ops->reattach_i3c_dev(dev, old_dyn_addr);
1381                 if (ret) {
1382                         i3c_master_put_i3c_addrs(dev);
1383                         return ret;
1384                 }
1385         }
1386
1387         return 0;
1388 }
1389
1390 static void i3c_master_detach_i3c_dev(struct i3c_dev_desc *dev)
1391 {
1392         struct i3c_master_controller *master = i3c_dev_get_master(dev);
1393
1394         /* Do not detach the master device itself. */
1395         if (master->this != dev && master->ops->detach_i3c_dev)
1396                 master->ops->detach_i3c_dev(dev);
1397
1398         i3c_master_put_i3c_addrs(dev);
1399         list_del(&dev->common.node);
1400 }
1401
1402 static int i3c_master_attach_i2c_dev(struct i3c_master_controller *master,
1403                                      struct i2c_dev_desc *dev)
1404 {
1405         int ret;
1406
1407         if (master->ops->attach_i2c_dev) {
1408                 ret = master->ops->attach_i2c_dev(dev);
1409                 if (ret)
1410                         return ret;
1411         }
1412
1413         list_add_tail(&dev->common.node, &master->bus.devs.i2c);
1414
1415         return 0;
1416 }
1417
1418 static void i3c_master_detach_i2c_dev(struct i2c_dev_desc *dev)
1419 {
1420         struct i3c_master_controller *master = i2c_dev_get_master(dev);
1421
1422         list_del(&dev->common.node);
1423
1424         if (master->ops->detach_i2c_dev)
1425                 master->ops->detach_i2c_dev(dev);
1426 }
1427
1428 static void i3c_master_pre_assign_dyn_addr(struct i3c_dev_desc *dev)
1429 {
1430         struct i3c_master_controller *master = i3c_dev_get_master(dev);
1431         int ret;
1432
1433         if (!dev->boardinfo || !dev->boardinfo->init_dyn_addr ||
1434             !dev->boardinfo->static_addr)
1435                 return;
1436
1437         ret = i3c_master_setdasa_locked(master, dev->info.static_addr,
1438                                         dev->boardinfo->init_dyn_addr);
1439         if (ret)
1440                 return;
1441
1442         dev->info.dyn_addr = dev->boardinfo->init_dyn_addr;
1443         ret = i3c_master_reattach_i3c_dev(dev, 0);
1444         if (ret)
1445                 goto err_rstdaa;
1446
1447         ret = i3c_master_retrieve_dev_info(dev);
1448         if (ret)
1449                 goto err_rstdaa;
1450
1451         return;
1452
1453 err_rstdaa:
1454         i3c_master_rstdaa_locked(master, dev->boardinfo->init_dyn_addr);
1455 }
1456
1457 static void
1458 i3c_master_register_new_i3c_devs(struct i3c_master_controller *master)
1459 {
1460         struct i3c_dev_desc *desc;
1461         int ret;
1462
1463         if (!master->init_done)
1464                 return;
1465
1466         i3c_bus_for_each_i3cdev(&master->bus, desc) {
1467                 if (desc->dev || !desc->info.dyn_addr || desc == master->this)
1468                         continue;
1469
1470                 desc->dev = kzalloc(sizeof(*desc->dev), GFP_KERNEL);
1471                 if (!desc->dev)
1472                         continue;
1473
1474                 desc->dev->bus = &master->bus;
1475                 desc->dev->desc = desc;
1476                 desc->dev->dev.parent = &master->dev;
1477                 desc->dev->dev.type = &i3c_device_type;
1478                 desc->dev->dev.bus = &i3c_bus_type;
1479                 desc->dev->dev.release = i3c_device_release;
1480                 dev_set_name(&desc->dev->dev, "%d-%llx", master->bus.id,
1481                              desc->info.pid);
1482
1483                 if (desc->boardinfo)
1484                         desc->dev->dev.of_node = desc->boardinfo->of_node;
1485
1486                 ret = device_register(&desc->dev->dev);
1487                 if (ret)
1488                         dev_err(&master->dev,
1489                                 "Failed to add I3C device (err = %d)\n", ret);
1490         }
1491 }
1492
1493 /**
1494  * i3c_master_do_daa() - do a DAA (Dynamic Address Assignment)
1495  * @master: master doing the DAA
1496  *
1497  * This function is instantiating an I3C device object and adding it to the
1498  * I3C device list. All device information are automatically retrieved using
1499  * standard CCC commands.
1500  *
1501  * The I3C device object is returned in case the master wants to attach
1502  * private data to it using i3c_dev_set_master_data().
1503  *
1504  * This function must be called with the bus lock held in write mode.
1505  *
1506  * Return: a 0 in case of success, an negative error code otherwise.
1507  */
1508 int i3c_master_do_daa(struct i3c_master_controller *master)
1509 {
1510         int ret;
1511
1512         i3c_bus_maintenance_lock(&master->bus);
1513         ret = master->ops->do_daa(master);
1514         i3c_bus_maintenance_unlock(&master->bus);
1515
1516         if (ret)
1517                 return ret;
1518
1519         i3c_bus_normaluse_lock(&master->bus);
1520         i3c_master_register_new_i3c_devs(master);
1521         i3c_bus_normaluse_unlock(&master->bus);
1522
1523         return 0;
1524 }
1525 EXPORT_SYMBOL_GPL(i3c_master_do_daa);
1526
1527 /**
1528  * i3c_master_set_info() - set master device information
1529  * @master: master used to send frames on the bus
1530  * @info: I3C device information
1531  *
1532  * Set master device info. This should be called from
1533  * &i3c_master_controller_ops->bus_init().
1534  *
1535  * Not all &i3c_device_info fields are meaningful for a master device.
1536  * Here is a list of fields that should be properly filled:
1537  *
1538  * - &i3c_device_info->dyn_addr
1539  * - &i3c_device_info->bcr
1540  * - &i3c_device_info->dcr
1541  * - &i3c_device_info->pid
1542  * - &i3c_device_info->hdr_cap if %I3C_BCR_HDR_CAP bit is set in
1543  *   &i3c_device_info->bcr
1544  *
1545  * This function must be called with the bus lock held in maintenance mode.
1546  *
1547  * Return: 0 if @info contains valid information (not every piece of
1548  * information can be checked, but we can at least make sure @info->dyn_addr
1549  * and @info->bcr are correct), -EINVAL otherwise.
1550  */
1551 int i3c_master_set_info(struct i3c_master_controller *master,
1552                         const struct i3c_device_info *info)
1553 {
1554         struct i3c_dev_desc *i3cdev;
1555         int ret;
1556
1557         if (!i3c_bus_dev_addr_is_avail(&master->bus, info->dyn_addr))
1558                 return -EINVAL;
1559
1560         if (I3C_BCR_DEVICE_ROLE(info->bcr) == I3C_BCR_I3C_MASTER &&
1561             master->secondary)
1562                 return -EINVAL;
1563
1564         if (master->this)
1565                 return -EINVAL;
1566
1567         i3cdev = i3c_master_alloc_i3c_dev(master, info);
1568         if (IS_ERR(i3cdev))
1569                 return PTR_ERR(i3cdev);
1570
1571         master->this = i3cdev;
1572         master->bus.cur_master = master->this;
1573
1574         ret = i3c_master_attach_i3c_dev(master, i3cdev);
1575         if (ret)
1576                 goto err_free_dev;
1577
1578         return 0;
1579
1580 err_free_dev:
1581         i3c_master_free_i3c_dev(i3cdev);
1582
1583         return ret;
1584 }
1585 EXPORT_SYMBOL_GPL(i3c_master_set_info);
1586
1587 static void i3c_master_detach_free_devs(struct i3c_master_controller *master)
1588 {
1589         struct i3c_dev_desc *i3cdev, *i3ctmp;
1590         struct i2c_dev_desc *i2cdev, *i2ctmp;
1591
1592         list_for_each_entry_safe(i3cdev, i3ctmp, &master->bus.devs.i3c,
1593                                  common.node) {
1594                 i3c_master_detach_i3c_dev(i3cdev);
1595
1596                 if (i3cdev->boardinfo && i3cdev->boardinfo->init_dyn_addr)
1597                         i3c_bus_set_addr_slot_status(&master->bus,
1598                                         i3cdev->boardinfo->init_dyn_addr,
1599                                         I3C_ADDR_SLOT_FREE);
1600
1601                 i3c_master_free_i3c_dev(i3cdev);
1602         }
1603
1604         list_for_each_entry_safe(i2cdev, i2ctmp, &master->bus.devs.i2c,
1605                                  common.node) {
1606                 i3c_master_detach_i2c_dev(i2cdev);
1607                 i3c_bus_set_addr_slot_status(&master->bus,
1608                                         i2cdev->boardinfo->base.addr,
1609                                         I3C_ADDR_SLOT_FREE);
1610                 i3c_master_free_i2c_dev(i2cdev);
1611         }
1612 }
1613
1614 /**
1615  * i3c_master_bus_init() - initialize an I3C bus
1616  * @master: main master initializing the bus
1617  *
1618  * This function is following all initialisation steps described in the I3C
1619  * specification:
1620  *
1621  * 1. Attach I2C and statically defined I3C devs to the master so that the
1622  *    master can fill its internal device table appropriately
1623  *
1624  * 2. Call &i3c_master_controller_ops->bus_init() method to initialize
1625  *    the master controller. That's usually where the bus mode is selected
1626  *    (pure bus or mixed fast/slow bus)
1627  *
1628  * 3. Instruct all devices on the bus to drop their dynamic address. This is
1629  *    particularly important when the bus was previously configured by someone
1630  *    else (for example the bootloader)
1631  *
1632  * 4. Disable all slave events.
1633  *
1634  * 5. Pre-assign dynamic addresses requested by the FW with SETDASA for I3C
1635  *    devices that have a static address
1636  *
1637  * 6. Do a DAA (Dynamic Address Assignment) to assign dynamic addresses to all
1638  *    remaining I3C devices
1639  *
1640  * Once this is done, all I3C and I2C devices should be usable.
1641  *
1642  * Return: a 0 in case of success, an negative error code otherwise.
1643  */
1644 static int i3c_master_bus_init(struct i3c_master_controller *master)
1645 {
1646         enum i3c_addr_slot_status status;
1647         struct i2c_dev_boardinfo *i2cboardinfo;
1648         struct i3c_dev_boardinfo *i3cboardinfo;
1649         struct i3c_dev_desc *i3cdev;
1650         struct i2c_dev_desc *i2cdev;
1651         int ret;
1652
1653         /*
1654          * First attach all devices with static definitions provided by the
1655          * FW.
1656          */
1657         list_for_each_entry(i2cboardinfo, &master->boardinfo.i2c, node) {
1658                 status = i3c_bus_get_addr_slot_status(&master->bus,
1659                                                       i2cboardinfo->base.addr);
1660                 if (status != I3C_ADDR_SLOT_FREE) {
1661                         ret = -EBUSY;
1662                         goto err_detach_devs;
1663                 }
1664
1665                 i3c_bus_set_addr_slot_status(&master->bus,
1666                                              i2cboardinfo->base.addr,
1667                                              I3C_ADDR_SLOT_I2C_DEV);
1668
1669                 i2cdev = i3c_master_alloc_i2c_dev(master, i2cboardinfo);
1670                 if (IS_ERR(i2cdev)) {
1671                         ret = PTR_ERR(i2cdev);
1672                         goto err_detach_devs;
1673                 }
1674
1675                 ret = i3c_master_attach_i2c_dev(master, i2cdev);
1676                 if (ret) {
1677                         i3c_master_free_i2c_dev(i2cdev);
1678                         goto err_detach_devs;
1679                 }
1680         }
1681         list_for_each_entry(i3cboardinfo, &master->boardinfo.i3c, node) {
1682                 struct i3c_device_info info = {
1683                         .static_addr = i3cboardinfo->static_addr,
1684                 };
1685
1686                 if (i3cboardinfo->init_dyn_addr) {
1687                         status = i3c_bus_get_addr_slot_status(&master->bus,
1688                                                 i3cboardinfo->init_dyn_addr);
1689                         if (status != I3C_ADDR_SLOT_FREE) {
1690                                 ret = -EBUSY;
1691                                 goto err_detach_devs;
1692                         }
1693                 }
1694
1695                 i3cdev = i3c_master_alloc_i3c_dev(master, &info);
1696                 if (IS_ERR(i3cdev)) {
1697                         ret = PTR_ERR(i3cdev);
1698                         goto err_detach_devs;
1699                 }
1700
1701                 i3cdev->boardinfo = i3cboardinfo;
1702
1703                 ret = i3c_master_attach_i3c_dev(master, i3cdev);
1704                 if (ret) {
1705                         i3c_master_free_i3c_dev(i3cdev);
1706                         goto err_detach_devs;
1707                 }
1708         }
1709
1710         /*
1711          * Now execute the controller specific ->bus_init() routine, which
1712          * might configure its internal logic to match the bus limitations.
1713          */
1714         ret = master->ops->bus_init(master);
1715         if (ret)
1716                 goto err_detach_devs;
1717
1718         /*
1719          * The master device should have been instantiated in ->bus_init(),
1720          * complain if this was not the case.
1721          */
1722         if (!master->this) {
1723                 dev_err(&master->dev,
1724                         "master_set_info() was not called in ->bus_init()\n");
1725                 ret = -EINVAL;
1726                 goto err_bus_cleanup;
1727         }
1728
1729         /*
1730          * Reset all dynamic address that may have been assigned before
1731          * (assigned by the bootloader for example).
1732          */
1733         ret = i3c_master_rstdaa_locked(master, I3C_BROADCAST_ADDR);
1734         if (ret && ret != I3C_ERROR_M2)
1735                 goto err_bus_cleanup;
1736
1737         /* Disable all slave events before starting DAA. */
1738         ret = i3c_master_disec_locked(master, I3C_BROADCAST_ADDR,
1739                                       I3C_CCC_EVENT_SIR | I3C_CCC_EVENT_MR |
1740                                       I3C_CCC_EVENT_HJ);
1741         if (ret && ret != I3C_ERROR_M2)
1742                 goto err_bus_cleanup;
1743
1744         /*
1745          * Pre-assign dynamic address and retrieve device information if
1746          * needed.
1747          */
1748         i3c_bus_for_each_i3cdev(&master->bus, i3cdev)
1749                 i3c_master_pre_assign_dyn_addr(i3cdev);
1750
1751         ret = i3c_master_do_daa(master);
1752         if (ret)
1753                 goto err_rstdaa;
1754
1755         return 0;
1756
1757 err_rstdaa:
1758         i3c_master_rstdaa_locked(master, I3C_BROADCAST_ADDR);
1759
1760 err_bus_cleanup:
1761         if (master->ops->bus_cleanup)
1762                 master->ops->bus_cleanup(master);
1763
1764 err_detach_devs:
1765         i3c_master_detach_free_devs(master);
1766
1767         return ret;
1768 }
1769
1770 static void i3c_master_bus_cleanup(struct i3c_master_controller *master)
1771 {
1772         if (master->ops->bus_cleanup)
1773                 master->ops->bus_cleanup(master);
1774
1775         i3c_master_detach_free_devs(master);
1776 }
1777
1778 static struct i3c_dev_desc *
1779 i3c_master_search_i3c_dev_duplicate(struct i3c_dev_desc *refdev)
1780 {
1781         struct i3c_master_controller *master = refdev->common.master;
1782         struct i3c_dev_desc *i3cdev;
1783
1784         i3c_bus_for_each_i3cdev(&master->bus, i3cdev) {
1785                 if (i3cdev != refdev && i3cdev->info.pid == refdev->info.pid)
1786                         return i3cdev;
1787         }
1788
1789         return NULL;
1790 }
1791
1792 /**
1793  * i3c_master_add_i3c_dev_locked() - add an I3C slave to the bus
1794  * @master: master used to send frames on the bus
1795  * @addr: I3C slave dynamic address assigned to the device
1796  *
1797  * This function is instantiating an I3C device object and adding it to the
1798  * I3C device list. All device information are automatically retrieved using
1799  * standard CCC commands.
1800  *
1801  * The I3C device object is returned in case the master wants to attach
1802  * private data to it using i3c_dev_set_master_data().
1803  *
1804  * This function must be called with the bus lock held in write mode.
1805  *
1806  * Return: a 0 in case of success, an negative error code otherwise.
1807  */
1808 int i3c_master_add_i3c_dev_locked(struct i3c_master_controller *master,
1809                                   u8 addr)
1810 {
1811         struct i3c_device_info info = { .dyn_addr = addr };
1812         struct i3c_dev_desc *newdev, *olddev;
1813         u8 old_dyn_addr = addr, expected_dyn_addr;
1814         struct i3c_ibi_setup ibireq = { };
1815         bool enable_ibi = false;
1816         int ret;
1817
1818         if (!master)
1819                 return -EINVAL;
1820
1821         newdev = i3c_master_alloc_i3c_dev(master, &info);
1822         if (IS_ERR(newdev))
1823                 return PTR_ERR(newdev);
1824
1825         ret = i3c_master_attach_i3c_dev(master, newdev);
1826         if (ret)
1827                 goto err_free_dev;
1828
1829         ret = i3c_master_retrieve_dev_info(newdev);
1830         if (ret)
1831                 goto err_detach_dev;
1832
1833         olddev = i3c_master_search_i3c_dev_duplicate(newdev);
1834         if (olddev) {
1835                 newdev->boardinfo = olddev->boardinfo;
1836                 newdev->info.static_addr = olddev->info.static_addr;
1837                 newdev->dev = olddev->dev;
1838                 if (newdev->dev)
1839                         newdev->dev->desc = newdev;
1840
1841                 /*
1842                  * We need to restore the IBI state too, so let's save the
1843                  * IBI information and try to restore them after olddev has
1844                  * been detached+released and its IBI has been stopped and
1845                  * the associated resources have been freed.
1846                  */
1847                 mutex_lock(&olddev->ibi_lock);
1848                 if (olddev->ibi) {
1849                         ibireq.handler = olddev->ibi->handler;
1850                         ibireq.max_payload_len = olddev->ibi->max_payload_len;
1851                         ibireq.num_slots = olddev->ibi->num_slots;
1852
1853                         if (olddev->ibi->enabled) {
1854                                 enable_ibi = true;
1855                                 i3c_dev_disable_ibi_locked(olddev);
1856                         }
1857
1858                         i3c_dev_free_ibi_locked(olddev);
1859                 }
1860                 mutex_unlock(&olddev->ibi_lock);
1861
1862                 old_dyn_addr = olddev->info.dyn_addr;
1863
1864                 i3c_master_detach_i3c_dev(olddev);
1865                 i3c_master_free_i3c_dev(olddev);
1866         }
1867
1868         ret = i3c_master_reattach_i3c_dev(newdev, old_dyn_addr);
1869         if (ret)
1870                 goto err_detach_dev;
1871
1872         /*
1873          * Depending on our previous state, the expected dynamic address might
1874          * differ:
1875          * - if the device already had a dynamic address assigned, let's try to
1876          *   re-apply this one
1877          * - if the device did not have a dynamic address and the firmware
1878          *   requested a specific address, pick this one
1879          * - in any other case, keep the address automatically assigned by the
1880          *   master
1881          */
1882         if (old_dyn_addr && old_dyn_addr != newdev->info.dyn_addr)
1883                 expected_dyn_addr = old_dyn_addr;
1884         else if (newdev->boardinfo && newdev->boardinfo->init_dyn_addr)
1885                 expected_dyn_addr = newdev->boardinfo->init_dyn_addr;
1886         else
1887                 expected_dyn_addr = newdev->info.dyn_addr;
1888
1889         if (newdev->info.dyn_addr != expected_dyn_addr) {
1890                 /*
1891                  * Try to apply the expected dynamic address. If it fails, keep
1892                  * the address assigned by the master.
1893                  */
1894                 ret = i3c_master_setnewda_locked(master,
1895                                                  newdev->info.dyn_addr,
1896                                                  expected_dyn_addr);
1897                 if (!ret) {
1898                         old_dyn_addr = newdev->info.dyn_addr;
1899                         newdev->info.dyn_addr = expected_dyn_addr;
1900                         i3c_master_reattach_i3c_dev(newdev, old_dyn_addr);
1901                 } else {
1902                         dev_err(&master->dev,
1903                                 "Failed to assign reserved/old address to device %d%llx",
1904                                 master->bus.id, newdev->info.pid);
1905                 }
1906         }
1907
1908         /*
1909          * Now is time to try to restore the IBI setup. If we're lucky,
1910          * everything works as before, otherwise, all we can do is complain.
1911          * FIXME: maybe we should add callback to inform the driver that it
1912          * should request the IBI again instead of trying to hide that from
1913          * him.
1914          */
1915         if (ibireq.handler) {
1916                 mutex_lock(&newdev->ibi_lock);
1917                 ret = i3c_dev_request_ibi_locked(newdev, &ibireq);
1918                 if (ret) {
1919                         dev_err(&master->dev,
1920                                 "Failed to request IBI on device %d-%llx",
1921                                 master->bus.id, newdev->info.pid);
1922                 } else if (enable_ibi) {
1923                         ret = i3c_dev_enable_ibi_locked(newdev);
1924                         if (ret)
1925                                 dev_err(&master->dev,
1926                                         "Failed to re-enable IBI on device %d-%llx",
1927                                         master->bus.id, newdev->info.pid);
1928                 }
1929                 mutex_unlock(&newdev->ibi_lock);
1930         }
1931
1932         return 0;
1933
1934 err_detach_dev:
1935         if (newdev->dev && newdev->dev->desc)
1936                 newdev->dev->desc = NULL;
1937
1938         i3c_master_detach_i3c_dev(newdev);
1939
1940 err_free_dev:
1941         i3c_master_free_i3c_dev(newdev);
1942
1943         return ret;
1944 }
1945 EXPORT_SYMBOL_GPL(i3c_master_add_i3c_dev_locked);
1946
1947 #define OF_I3C_REG1_IS_I2C_DEV                  BIT(31)
1948
1949 static int
1950 of_i3c_master_add_i2c_boardinfo(struct i3c_master_controller *master,
1951                                 struct device_node *node, u32 *reg)
1952 {
1953         struct i2c_dev_boardinfo *boardinfo;
1954         struct device *dev = &master->dev;
1955         int ret;
1956
1957         boardinfo = devm_kzalloc(dev, sizeof(*boardinfo), GFP_KERNEL);
1958         if (!boardinfo)
1959                 return -ENOMEM;
1960
1961         ret = of_i2c_get_board_info(dev, node, &boardinfo->base);
1962         if (ret)
1963                 return ret;
1964
1965         /* LVR is encoded in reg[2]. */
1966         boardinfo->lvr = reg[2];
1967
1968         if (boardinfo->lvr & I3C_LVR_I2C_FM_MODE)
1969                 master->bus.scl_rate.i2c = I3C_BUS_I2C_FM_SCL_RATE;
1970
1971         list_add_tail(&boardinfo->node, &master->boardinfo.i2c);
1972         of_node_get(node);
1973
1974         return 0;
1975 }
1976
1977 static int
1978 of_i3c_master_add_i3c_boardinfo(struct i3c_master_controller *master,
1979                                 struct device_node *node, u32 *reg)
1980 {
1981         struct i3c_dev_boardinfo *boardinfo;
1982         struct device *dev = &master->dev;
1983         struct i3c_device_info info = { };
1984         enum i3c_addr_slot_status addrstatus;
1985         u32 init_dyn_addr = 0;
1986
1987         boardinfo = devm_kzalloc(dev, sizeof(*boardinfo), GFP_KERNEL);
1988         if (!boardinfo)
1989                 return -ENOMEM;
1990
1991         if (reg[0]) {
1992                 if (reg[0] > I3C_MAX_ADDR)
1993                         return -EINVAL;
1994
1995                 addrstatus = i3c_bus_get_addr_slot_status(&master->bus,
1996                                                           reg[0]);
1997                 if (addrstatus != I3C_ADDR_SLOT_FREE)
1998                         return -EINVAL;
1999         }
2000
2001         boardinfo->static_addr = reg[0];
2002
2003         if (!of_property_read_u32(node, "assigned-address", &init_dyn_addr)) {
2004                 if (init_dyn_addr > I3C_MAX_ADDR)
2005                         return -EINVAL;
2006
2007                 addrstatus = i3c_bus_get_addr_slot_status(&master->bus,
2008                                                           init_dyn_addr);
2009                 if (addrstatus != I3C_ADDR_SLOT_FREE)
2010                         return -EINVAL;
2011         }
2012
2013         boardinfo->pid = ((u64)reg[1] << 32) | reg[2];
2014
2015         if ((info.pid & GENMASK_ULL(63, 48)) ||
2016             I3C_PID_RND_LOWER_32BITS(info.pid))
2017                 return -EINVAL;
2018
2019         boardinfo->init_dyn_addr = init_dyn_addr;
2020         boardinfo->of_node = of_node_get(node);
2021         list_add_tail(&boardinfo->node, &master->boardinfo.i3c);
2022
2023         return 0;
2024 }
2025
2026 static int of_i3c_master_add_dev(struct i3c_master_controller *master,
2027                                  struct device_node *node)
2028 {
2029         u32 reg[3];
2030         int ret;
2031
2032         if (!master || !node)
2033                 return -EINVAL;
2034
2035         ret = of_property_read_u32_array(node, "reg", reg, ARRAY_SIZE(reg));
2036         if (ret)
2037                 return ret;
2038
2039         /*
2040          * The manufacturer ID can't be 0. If reg[1] == 0 that means we're
2041          * dealing with an I2C device.
2042          */
2043         if (!reg[1])
2044                 ret = of_i3c_master_add_i2c_boardinfo(master, node, reg);
2045         else
2046                 ret = of_i3c_master_add_i3c_boardinfo(master, node, reg);
2047
2048         return ret;
2049 }
2050
2051 static int of_populate_i3c_bus(struct i3c_master_controller *master)
2052 {
2053         struct device *dev = &master->dev;
2054         struct device_node *i3cbus_np = dev->of_node;
2055         struct device_node *node;
2056         int ret;
2057         u32 val;
2058
2059         if (!i3cbus_np)
2060                 return 0;
2061
2062         for_each_available_child_of_node(i3cbus_np, node) {
2063                 ret = of_i3c_master_add_dev(master, node);
2064                 if (ret)
2065                         return ret;
2066         }
2067
2068         /*
2069          * The user might want to limit I2C and I3C speed in case some devices
2070          * on the bus are not supporting typical rates, or if the bus topology
2071          * prevents it from using max possible rate.
2072          */
2073         if (!of_property_read_u32(i3cbus_np, "i2c-scl-hz", &val))
2074                 master->bus.scl_rate.i2c = val;
2075
2076         if (!of_property_read_u32(i3cbus_np, "i3c-scl-hz", &val))
2077                 master->bus.scl_rate.i3c = val;
2078
2079         return 0;
2080 }
2081
2082 static int i3c_master_i2c_adapter_xfer(struct i2c_adapter *adap,
2083                                        struct i2c_msg *xfers, int nxfers)
2084 {
2085         struct i3c_master_controller *master = i2c_adapter_to_i3c_master(adap);
2086         struct i2c_dev_desc *dev;
2087         int i, ret;
2088         u16 addr;
2089
2090         if (!xfers || !master || nxfers <= 0)
2091                 return -EINVAL;
2092
2093         if (!master->ops->i2c_xfers)
2094                 return -ENOTSUPP;
2095
2096         /* Doing transfers to different devices is not supported. */
2097         addr = xfers[0].addr;
2098         for (i = 1; i < nxfers; i++) {
2099                 if (addr != xfers[i].addr)
2100                         return -ENOTSUPP;
2101         }
2102
2103         i3c_bus_normaluse_lock(&master->bus);
2104         dev = i3c_master_find_i2c_dev_by_addr(master, addr);
2105         if (!dev)
2106                 ret = -ENOENT;
2107         else
2108                 ret = master->ops->i2c_xfers(dev, xfers, nxfers);
2109         i3c_bus_normaluse_unlock(&master->bus);
2110
2111         return ret ? ret : nxfers;
2112 }
2113
2114 static u32 i3c_master_i2c_functionalities(struct i2c_adapter *adap)
2115 {
2116         struct i3c_master_controller *master = i2c_adapter_to_i3c_master(adap);
2117
2118         return master->ops->i2c_funcs(master);
2119 }
2120
2121 static const struct i2c_algorithm i3c_master_i2c_algo = {
2122         .master_xfer = i3c_master_i2c_adapter_xfer,
2123         .functionality = i3c_master_i2c_functionalities,
2124 };
2125
2126 static int i3c_master_i2c_adapter_init(struct i3c_master_controller *master)
2127 {
2128         struct i2c_adapter *adap = i3c_master_to_i2c_adapter(master);
2129         struct i2c_dev_desc *i2cdev;
2130         int ret;
2131
2132         adap->dev.parent = master->dev.parent;
2133         adap->owner = master->dev.parent->driver->owner;
2134         adap->algo = &i3c_master_i2c_algo;
2135         strncpy(adap->name, dev_name(master->dev.parent), sizeof(adap->name));
2136
2137         /* FIXME: Should we allow i3c masters to override these values? */
2138         adap->timeout = 1000;
2139         adap->retries = 3;
2140
2141         ret = i2c_add_adapter(adap);
2142         if (ret)
2143                 return ret;
2144
2145         /*
2146          * We silently ignore failures here. The bus should keep working
2147          * correctly even if one or more i2c devices are not registered.
2148          */
2149         i3c_bus_for_each_i2cdev(&master->bus, i2cdev)
2150                 i2cdev->dev = i2c_new_device(adap, &i2cdev->boardinfo->base);
2151
2152         return 0;
2153 }
2154
2155 static void i3c_master_i2c_adapter_cleanup(struct i3c_master_controller *master)
2156 {
2157         struct i2c_dev_desc *i2cdev;
2158
2159         i2c_del_adapter(&master->i2c);
2160
2161         i3c_bus_for_each_i2cdev(&master->bus, i2cdev)
2162                 i2cdev->dev = NULL;
2163 }
2164
2165 static void i3c_master_unregister_i3c_devs(struct i3c_master_controller *master)
2166 {
2167         struct i3c_dev_desc *i3cdev;
2168
2169         i3c_bus_for_each_i3cdev(&master->bus, i3cdev) {
2170                 if (!i3cdev->dev)
2171                         continue;
2172
2173                 i3cdev->dev->desc = NULL;
2174                 if (device_is_registered(&i3cdev->dev->dev))
2175                         device_unregister(&i3cdev->dev->dev);
2176                 else
2177                         put_device(&i3cdev->dev->dev);
2178                 i3cdev->dev = NULL;
2179         }
2180 }
2181
2182 /**
2183  * i3c_master_queue_ibi() - Queue an IBI
2184  * @dev: the device this IBI is coming from
2185  * @slot: the IBI slot used to store the payload
2186  *
2187  * Queue an IBI to the controller workqueue. The IBI handler attached to
2188  * the dev will be called from a workqueue context.
2189  */
2190 void i3c_master_queue_ibi(struct i3c_dev_desc *dev, struct i3c_ibi_slot *slot)
2191 {
2192         atomic_inc(&dev->ibi->pending_ibis);
2193         queue_work(dev->common.master->wq, &slot->work);
2194 }
2195 EXPORT_SYMBOL_GPL(i3c_master_queue_ibi);
2196
2197 static void i3c_master_handle_ibi(struct work_struct *work)
2198 {
2199         struct i3c_ibi_slot *slot = container_of(work, struct i3c_ibi_slot,
2200                                                  work);
2201         struct i3c_dev_desc *dev = slot->dev;
2202         struct i3c_master_controller *master = i3c_dev_get_master(dev);
2203         struct i3c_ibi_payload payload;
2204
2205         payload.data = slot->data;
2206         payload.len = slot->len;
2207
2208         if (dev->dev)
2209                 dev->ibi->handler(dev->dev, &payload);
2210
2211         master->ops->recycle_ibi_slot(dev, slot);
2212         if (atomic_dec_and_test(&dev->ibi->pending_ibis))
2213                 complete(&dev->ibi->all_ibis_handled);
2214 }
2215
2216 static void i3c_master_init_ibi_slot(struct i3c_dev_desc *dev,
2217                                      struct i3c_ibi_slot *slot)
2218 {
2219         slot->dev = dev;
2220         INIT_WORK(&slot->work, i3c_master_handle_ibi);
2221 }
2222
2223 struct i3c_generic_ibi_slot {
2224         struct list_head node;
2225         struct i3c_ibi_slot base;
2226 };
2227
2228 struct i3c_generic_ibi_pool {
2229         spinlock_t lock;
2230         unsigned int num_slots;
2231         struct i3c_generic_ibi_slot *slots;
2232         void *payload_buf;
2233         struct list_head free_slots;
2234         struct list_head pending;
2235 };
2236
2237 /**
2238  * i3c_generic_ibi_free_pool() - Free a generic IBI pool
2239  * @pool: the IBI pool to free
2240  *
2241  * Free all IBI slots allated by a generic IBI pool.
2242  */
2243 void i3c_generic_ibi_free_pool(struct i3c_generic_ibi_pool *pool)
2244 {
2245         struct i3c_generic_ibi_slot *slot;
2246         unsigned int nslots = 0;
2247
2248         while (!list_empty(&pool->free_slots)) {
2249                 slot = list_first_entry(&pool->free_slots,
2250                                         struct i3c_generic_ibi_slot, node);
2251                 list_del(&slot->node);
2252                 nslots++;
2253         }
2254
2255         /*
2256          * If the number of freed slots is not equal to the number of allocated
2257          * slots we have a leak somewhere.
2258          */
2259         WARN_ON(nslots != pool->num_slots);
2260
2261         kfree(pool->payload_buf);
2262         kfree(pool->slots);
2263         kfree(pool);
2264 }
2265 EXPORT_SYMBOL_GPL(i3c_generic_ibi_free_pool);
2266
2267 /**
2268  * i3c_generic_ibi_alloc_pool() - Create a generic IBI pool
2269  * @dev: the device this pool will be used for
2270  * @req: IBI setup request describing what the device driver expects
2271  *
2272  * Create a generic IBI pool based on the information provided in @req.
2273  *
2274  * Return: a valid IBI pool in case of success, an ERR_PTR() otherwise.
2275  */
2276 struct i3c_generic_ibi_pool *
2277 i3c_generic_ibi_alloc_pool(struct i3c_dev_desc *dev,
2278                            const struct i3c_ibi_setup *req)
2279 {
2280         struct i3c_generic_ibi_pool *pool;
2281         struct i3c_generic_ibi_slot *slot;
2282         unsigned int i;
2283         int ret;
2284
2285         pool = kzalloc(sizeof(*pool), GFP_KERNEL);
2286         if (!pool)
2287                 return ERR_PTR(-ENOMEM);
2288
2289         spin_lock_init(&pool->lock);
2290         INIT_LIST_HEAD(&pool->free_slots);
2291         INIT_LIST_HEAD(&pool->pending);
2292
2293         pool->slots = kcalloc(req->num_slots, sizeof(*slot), GFP_KERNEL);
2294         if (!pool->slots) {
2295                 ret = -ENOMEM;
2296                 goto err_free_pool;
2297         }
2298
2299         if (req->max_payload_len) {
2300                 pool->payload_buf = kcalloc(req->num_slots,
2301                                             req->max_payload_len, GFP_KERNEL);
2302                 if (!pool->payload_buf) {
2303                         ret = -ENOMEM;
2304                         goto err_free_pool;
2305                 }
2306         }
2307
2308         for (i = 0; i < req->num_slots; i++) {
2309                 slot = &pool->slots[i];
2310                 i3c_master_init_ibi_slot(dev, &slot->base);
2311
2312                 if (req->max_payload_len)
2313                         slot->base.data = pool->payload_buf +
2314                                           (i * req->max_payload_len);
2315
2316                 list_add_tail(&slot->node, &pool->free_slots);
2317                 pool->num_slots++;
2318         }
2319
2320         return pool;
2321
2322 err_free_pool:
2323         i3c_generic_ibi_free_pool(pool);
2324         return ERR_PTR(ret);
2325 }
2326 EXPORT_SYMBOL_GPL(i3c_generic_ibi_alloc_pool);
2327
2328 /**
2329  * i3c_generic_ibi_get_free_slot() - Get a free slot from a generic IBI pool
2330  * @pool: the pool to query an IBI slot on
2331  *
2332  * Search for a free slot in a generic IBI pool.
2333  * The slot should be returned to the pool using i3c_generic_ibi_recycle_slot()
2334  * when it's no longer needed.
2335  *
2336  * Return: a pointer to a free slot, or NULL if there's no free slot available.
2337  */
2338 struct i3c_ibi_slot *
2339 i3c_generic_ibi_get_free_slot(struct i3c_generic_ibi_pool *pool)
2340 {
2341         struct i3c_generic_ibi_slot *slot;
2342         unsigned long flags;
2343
2344         spin_lock_irqsave(&pool->lock, flags);
2345         slot = list_first_entry_or_null(&pool->free_slots,
2346                                         struct i3c_generic_ibi_slot, node);
2347         if (slot)
2348                 list_del(&slot->node);
2349         spin_unlock_irqrestore(&pool->lock, flags);
2350
2351         return slot ? &slot->base : NULL;
2352 }
2353 EXPORT_SYMBOL_GPL(i3c_generic_ibi_get_free_slot);
2354
2355 /**
2356  * i3c_generic_ibi_recycle_slot() - Return a slot to a generic IBI pool
2357  * @pool: the pool to return the IBI slot to
2358  * @s: IBI slot to recycle
2359  *
2360  * Add an IBI slot back to its generic IBI pool. Should be called from the
2361  * master driver struct_master_controller_ops->recycle_ibi() method.
2362  */
2363 void i3c_generic_ibi_recycle_slot(struct i3c_generic_ibi_pool *pool,
2364                                   struct i3c_ibi_slot *s)
2365 {
2366         struct i3c_generic_ibi_slot *slot;
2367         unsigned long flags;
2368
2369         if (!s)
2370                 return;
2371
2372         slot = container_of(s, struct i3c_generic_ibi_slot, base);
2373         spin_lock_irqsave(&pool->lock, flags);
2374         list_add_tail(&slot->node, &pool->free_slots);
2375         spin_unlock_irqrestore(&pool->lock, flags);
2376 }
2377 EXPORT_SYMBOL_GPL(i3c_generic_ibi_recycle_slot);
2378
2379 static int i3c_master_check_ops(const struct i3c_master_controller_ops *ops)
2380 {
2381         if (!ops || !ops->bus_init || !ops->priv_xfers ||
2382             !ops->send_ccc_cmd || !ops->do_daa || !ops->i2c_xfers ||
2383             !ops->i2c_funcs)
2384                 return -EINVAL;
2385
2386         if (ops->request_ibi &&
2387             (!ops->enable_ibi || !ops->disable_ibi || !ops->free_ibi ||
2388              !ops->recycle_ibi_slot))
2389                 return -EINVAL;
2390
2391         return 0;
2392 }
2393
2394 /**
2395  * i3c_master_register() - register an I3C master
2396  * @master: master used to send frames on the bus
2397  * @parent: the parent device (the one that provides this I3C master
2398  *          controller)
2399  * @ops: the master controller operations
2400  * @secondary: true if you are registering a secondary master. Will return
2401  *             -ENOTSUPP if set to true since secondary masters are not yet
2402  *             supported
2403  *
2404  * This function takes care of everything for you:
2405  *
2406  * - creates and initializes the I3C bus
2407  * - populates the bus with static I2C devs if @parent->of_node is not
2408  *   NULL
2409  * - registers all I3C devices added by the controller during bus
2410  *   initialization
2411  * - registers the I2C adapter and all I2C devices
2412  *
2413  * Return: 0 in case of success, a negative error code otherwise.
2414  */
2415 int i3c_master_register(struct i3c_master_controller *master,
2416                         struct device *parent,
2417                         const struct i3c_master_controller_ops *ops,
2418                         bool secondary)
2419 {
2420         struct i3c_bus *i3cbus = i3c_master_get_bus(master);
2421         enum i3c_bus_mode mode = I3C_BUS_MODE_PURE;
2422         struct i2c_dev_boardinfo *i2cbi;
2423         int ret;
2424
2425         /* We do not support secondary masters yet. */
2426         if (secondary)
2427                 return -ENOTSUPP;
2428
2429         ret = i3c_master_check_ops(ops);
2430         if (ret)
2431                 return ret;
2432
2433         master->dev.parent = parent;
2434         master->dev.of_node = of_node_get(parent->of_node);
2435         master->dev.bus = &i3c_bus_type;
2436         master->dev.type = &i3c_masterdev_type;
2437         master->dev.release = i3c_masterdev_release;
2438         master->ops = ops;
2439         master->secondary = secondary;
2440         INIT_LIST_HEAD(&master->boardinfo.i2c);
2441         INIT_LIST_HEAD(&master->boardinfo.i3c);
2442
2443         ret = i3c_bus_init(i3cbus);
2444         if (ret)
2445                 return ret;
2446
2447         device_initialize(&master->dev);
2448         dev_set_name(&master->dev, "i3c-%d", i3cbus->id);
2449
2450         ret = of_populate_i3c_bus(master);
2451         if (ret)
2452                 goto err_put_dev;
2453
2454         list_for_each_entry(i2cbi, &master->boardinfo.i2c, node) {
2455                 switch (i2cbi->lvr & I3C_LVR_I2C_INDEX_MASK) {
2456                 case I3C_LVR_I2C_INDEX(0):
2457                         if (mode < I3C_BUS_MODE_MIXED_FAST)
2458                                 mode = I3C_BUS_MODE_MIXED_FAST;
2459                         break;
2460                 case I3C_LVR_I2C_INDEX(1):
2461                 case I3C_LVR_I2C_INDEX(2):
2462                         if (mode < I3C_BUS_MODE_MIXED_SLOW)
2463                                 mode = I3C_BUS_MODE_MIXED_SLOW;
2464                         break;
2465                 default:
2466                         ret = -EINVAL;
2467                         goto err_put_dev;
2468                 }
2469         }
2470
2471         ret = i3c_bus_set_mode(i3cbus, mode);
2472         if (ret)
2473                 goto err_put_dev;
2474
2475         master->wq = alloc_workqueue("%s", 0, 0, dev_name(parent));
2476         if (!master->wq) {
2477                 ret = -ENOMEM;
2478                 goto err_put_dev;
2479         }
2480
2481         ret = i3c_master_bus_init(master);
2482         if (ret)
2483                 goto err_put_dev;
2484
2485         ret = device_add(&master->dev);
2486         if (ret)
2487                 goto err_cleanup_bus;
2488
2489         /*
2490          * Expose our I3C bus as an I2C adapter so that I2C devices are exposed
2491          * through the I2C subsystem.
2492          */
2493         ret = i3c_master_i2c_adapter_init(master);
2494         if (ret)
2495                 goto err_del_dev;
2496
2497         /*
2498          * We're done initializing the bus and the controller, we can now
2499          * register I3C devices dicovered during the initial DAA.
2500          */
2501         master->init_done = true;
2502         i3c_bus_normaluse_lock(&master->bus);
2503         i3c_master_register_new_i3c_devs(master);
2504         i3c_bus_normaluse_unlock(&master->bus);
2505
2506         return 0;
2507
2508 err_del_dev:
2509         device_del(&master->dev);
2510
2511 err_cleanup_bus:
2512         i3c_master_bus_cleanup(master);
2513
2514 err_put_dev:
2515         put_device(&master->dev);
2516
2517         return ret;
2518 }
2519 EXPORT_SYMBOL_GPL(i3c_master_register);
2520
2521 /**
2522  * i3c_master_unregister() - unregister an I3C master
2523  * @master: master used to send frames on the bus
2524  *
2525  * Basically undo everything done in i3c_master_register().
2526  *
2527  * Return: 0 in case of success, a negative error code otherwise.
2528  */
2529 int i3c_master_unregister(struct i3c_master_controller *master)
2530 {
2531         i3c_master_i2c_adapter_cleanup(master);
2532         i3c_master_unregister_i3c_devs(master);
2533         i3c_master_bus_cleanup(master);
2534         device_unregister(&master->dev);
2535
2536         return 0;
2537 }
2538 EXPORT_SYMBOL_GPL(i3c_master_unregister);
2539
2540 int i3c_dev_do_priv_xfers_locked(struct i3c_dev_desc *dev,
2541                                  struct i3c_priv_xfer *xfers,
2542                                  int nxfers)
2543 {
2544         struct i3c_master_controller *master;
2545
2546         if (!dev)
2547                 return -ENOENT;
2548
2549         master = i3c_dev_get_master(dev);
2550         if (!master || !xfers)
2551                 return -EINVAL;
2552
2553         if (!master->ops->priv_xfers)
2554                 return -ENOTSUPP;
2555
2556         return master->ops->priv_xfers(dev, xfers, nxfers);
2557 }
2558
2559 int i3c_dev_disable_ibi_locked(struct i3c_dev_desc *dev)
2560 {
2561         struct i3c_master_controller *master;
2562         int ret;
2563
2564         if (!dev->ibi)
2565                 return -EINVAL;
2566
2567         master = i3c_dev_get_master(dev);
2568         ret = master->ops->disable_ibi(dev);
2569         if (ret)
2570                 return ret;
2571
2572         reinit_completion(&dev->ibi->all_ibis_handled);
2573         if (atomic_read(&dev->ibi->pending_ibis))
2574                 wait_for_completion(&dev->ibi->all_ibis_handled);
2575
2576         dev->ibi->enabled = false;
2577
2578         return 0;
2579 }
2580
2581 int i3c_dev_enable_ibi_locked(struct i3c_dev_desc *dev)
2582 {
2583         struct i3c_master_controller *master = i3c_dev_get_master(dev);
2584         int ret;
2585
2586         if (!dev->ibi)
2587                 return -EINVAL;
2588
2589         ret = master->ops->enable_ibi(dev);
2590         if (!ret)
2591                 dev->ibi->enabled = true;
2592
2593         return ret;
2594 }
2595
2596 int i3c_dev_request_ibi_locked(struct i3c_dev_desc *dev,
2597                                const struct i3c_ibi_setup *req)
2598 {
2599         struct i3c_master_controller *master = i3c_dev_get_master(dev);
2600         struct i3c_device_ibi_info *ibi;
2601         int ret;
2602
2603         if (!master->ops->request_ibi)
2604                 return -ENOTSUPP;
2605
2606         if (dev->ibi)
2607                 return -EBUSY;
2608
2609         ibi = kzalloc(sizeof(*ibi), GFP_KERNEL);
2610         if (!ibi)
2611                 return -ENOMEM;
2612
2613         atomic_set(&ibi->pending_ibis, 0);
2614         init_completion(&ibi->all_ibis_handled);
2615         ibi->handler = req->handler;
2616         ibi->max_payload_len = req->max_payload_len;
2617         ibi->num_slots = req->num_slots;
2618
2619         dev->ibi = ibi;
2620         ret = master->ops->request_ibi(dev, req);
2621         if (ret) {
2622                 kfree(ibi);
2623                 dev->ibi = NULL;
2624         }
2625
2626         return ret;
2627 }
2628
2629 void i3c_dev_free_ibi_locked(struct i3c_dev_desc *dev)
2630 {
2631         struct i3c_master_controller *master = i3c_dev_get_master(dev);
2632
2633         if (!dev->ibi)
2634                 return;
2635
2636         if (WARN_ON(dev->ibi->enabled))
2637                 WARN_ON(i3c_dev_disable_ibi_locked(dev));
2638
2639         master->ops->free_ibi(dev);
2640         kfree(dev->ibi);
2641         dev->ibi = NULL;
2642 }
2643
2644 static int __init i3c_init(void)
2645 {
2646         return bus_register(&i3c_bus_type);
2647 }
2648 subsys_initcall(i3c_init);
2649
2650 static void __exit i3c_exit(void)
2651 {
2652         idr_destroy(&i3c_bus_idr);
2653         bus_unregister(&i3c_bus_type);
2654 }
2655 module_exit(i3c_exit);
2656
2657 MODULE_AUTHOR("Boris Brezillon <boris.brezillon@bootlin.com>");
2658 MODULE_DESCRIPTION("I3C core");
2659 MODULE_LICENSE("GPL v2");