Lines Matching refs:device
33 * host1x_subdev_add() - add a new subdevice with an associated device node
34 * @device: host1x device to add the subdevice to
35 * @np: device node
37 static int host1x_subdev_add(struct host1x_device *device,
52 mutex_lock(&device->subdevs_lock);
53 list_add_tail(&subdev->list, &device->subdevs);
54 mutex_unlock(&device->subdevs_lock);
60 err = host1x_subdev_add(device, driver, child);
84 * host1x_device_parse_dt() - scan device tree and add matching subdevices
85 * @device: host1x logical device
88 static int host1x_device_parse_dt(struct host1x_device *device,
94 for_each_child_of_node(device->dev.parent->of_node, np) {
97 err = host1x_subdev_add(device, driver, np);
108 static void host1x_subdev_register(struct host1x_device *device,
117 * client with its parent device.
119 mutex_lock(&device->subdevs_lock);
120 mutex_lock(&device->clients_lock);
121 list_move_tail(&client->list, &device->clients);
122 list_move_tail(&subdev->list, &device->active);
123 client->host = &device->dev;
125 mutex_unlock(&device->clients_lock);
126 mutex_unlock(&device->subdevs_lock);
128 if (list_empty(&device->subdevs)) {
129 err = device_add(&device->dev);
131 dev_err(&device->dev, "failed to add: %d\n", err);
133 device->registered = true;
137 static void __host1x_subdev_unregister(struct host1x_device *device,
146 if (list_empty(&device->subdevs)) {
147 if (device->registered) {
148 device->registered = false;
149 device_del(&device->dev);
157 mutex_lock(&device->clients_lock);
160 list_move_tail(&subdev->list, &device->subdevs);
163 * when the device is about to be deleted.
167 * also when the composite device is about to be removed.
170 mutex_unlock(&device->clients_lock);
173 static void host1x_subdev_unregister(struct host1x_device *device,
176 mutex_lock(&device->subdevs_lock);
177 __host1x_subdev_unregister(device, subdev);
178 mutex_unlock(&device->subdevs_lock);
182 * host1x_device_init() - initialize a host1x logical device
183 * @device: host1x logical device
185 * The driver for the host1x logical device can call this during execution of
191 int host1x_device_init(struct host1x_device *device)
196 mutex_lock(&device->clients_lock);
198 list_for_each_entry(client, &device->clients, list) {
202 dev_err(&device->dev,
210 mutex_unlock(&device->clients_lock);
215 list_for_each_entry_continue_reverse(client, &device->clients, list)
219 mutex_unlock(&device->clients_lock);
225 * host1x_device_exit() - uninitialize host1x logical device
226 * @device: host1x logical device
228 * When the driver for a host1x logical device is unloaded, it can call this
233 int host1x_device_exit(struct host1x_device *device)
238 mutex_lock(&device->clients_lock);
240 list_for_each_entry_reverse(client, &device->clients, list) {
244 dev_err(&device->dev,
247 mutex_unlock(&device->clients_lock);
253 mutex_unlock(&device->clients_lock);
262 struct host1x_device *device;
267 list_for_each_entry(device, &host1x->devices, list) {
268 list_for_each_entry(subdev, &device->subdevs, list) {
270 host1x_subdev_register(device, subdev, client);
284 struct host1x_device *device, *dt;
289 list_for_each_entry_safe(device, dt, &host1x->devices, list) {
290 list_for_each_entry(subdev, &device->active, list) {
292 host1x_subdev_unregister(device, subdev);
303 static int host1x_device_match(struct device *dev, struct device_driver *drv)
308 static int host1x_device_uevent(struct device *dev,
338 static int host1x_dma_configure(struct device *dev)
360 static void __host1x_device_del(struct host1x_device *device)
365 mutex_lock(&device->subdevs_lock);
368 list_for_each_entry_safe(subdev, sd, &device->active, list) {
380 __host1x_subdev_unregister(device, subdev);
389 list_for_each_entry_safe(subdev, sd, &device->subdevs, list)
392 mutex_unlock(&device->subdevs_lock);
396 mutex_lock(&device->clients_lock);
398 list_for_each_entry_safe(client, cl, &device->clients, list)
401 mutex_unlock(&device->clients_lock);
404 /* finally remove the device */
405 list_del_init(&device->list);
408 static void host1x_device_release(struct device *dev)
410 struct host1x_device *device = to_host1x_device(dev);
412 __host1x_device_del(device);
413 kfree(device);
421 struct host1x_device *device;
424 device = kzalloc(sizeof(*device), GFP_KERNEL);
425 if (!device)
428 device_initialize(&device->dev);
430 mutex_init(&device->subdevs_lock);
431 INIT_LIST_HEAD(&device->subdevs);
432 INIT_LIST_HEAD(&device->active);
433 mutex_init(&device->clients_lock);
434 INIT_LIST_HEAD(&device->clients);
435 INIT_LIST_HEAD(&device->list);
436 device->driver = driver;
438 device->dev.coherent_dma_mask = host1x->dev->coherent_dma_mask;
439 device->dev.dma_mask = &device->dev.coherent_dma_mask;
440 dev_set_name(&device->dev, "%s", driver->driver.name);
441 device->dev.release = host1x_device_release;
442 device->dev.bus = &host1x_bus_type;
443 device->dev.parent = host1x->dev;
445 of_dma_configure(&device->dev, host1x->dev->of_node, true);
447 device->dev.dma_parms = &device->dma_parms;
448 dma_set_max_seg_size(&device->dev, UINT_MAX);
450 err = host1x_device_parse_dt(device, driver);
452 kfree(device);
456 list_add_tail(&device->list, &host1x->devices);
461 list_for_each_entry(subdev, &device->subdevs, list) {
463 host1x_subdev_register(device, subdev, client);
475 * Removes a device by first unregistering any subdevices and then removing
481 struct host1x_device *device)
483 if (device->registered) {
484 device->registered = false;
485 device_del(&device->dev);
488 put_device(&device->dev);
494 struct host1x_device *device;
499 list_for_each_entry(device, &host1x->devices, list) {
500 if (device->driver == driver) {
508 dev_err(host1x->dev, "failed to allocate device: %d\n", err);
516 struct host1x_device *device, *tmp;
520 list_for_each_entry_safe(device, tmp, &host1x->devices, list)
521 if (device->driver == driver)
522 host1x_device_del(host1x, device);
530 struct host1x_device *device;
534 list_for_each_entry(device, &host1x->devices, list) {
537 seq_printf(s, "%s\n", dev_name(&device->dev));
539 mutex_lock(&device->subdevs_lock);
541 list_for_each_entry(subdev, &device->active, list)
545 list_for_each_entry(subdev, &device->subdevs, list)
548 mutex_unlock(&device->subdevs_lock);
611 static int host1x_device_probe(struct device *dev)
614 struct host1x_device *device = to_host1x_device(dev);
617 return driver->probe(device);
622 static int host1x_device_remove(struct device *dev)
625 struct host1x_device *device = to_host1x_device(dev);
628 return driver->remove(device);
633 static void host1x_device_shutdown(struct device *dev)
636 struct host1x_device *device = to_host1x_device(dev);
639 driver->shutdown(device);
649 * registration of the driver actually triggers tho logical device creation.
650 * A logical device will be created for each host1x instance.
738 * device and call host1x_device_init(), which will in turn call each client's
771 * device has already been initialized, it will be torn down.