1 /* SPDX-License-Identifier: GPL-2.0-only */ 1 /* SPDX-License-Identifier: GPL-2.0-only */
2 /* 2 /*
3 * Mediated device definition 3 * Mediated device definition
4 * 4 *
5 * Copyright (c) 2016, NVIDIA CORPORATION. All 5 * Copyright (c) 2016, NVIDIA CORPORATION. All rights reserved.
6 * Author: Neo Jia <cjia@nvidia.com> 6 * Author: Neo Jia <cjia@nvidia.com>
7 * Kirti Wankhede <kwankhede@nvidi 7 * Kirti Wankhede <kwankhede@nvidia.com>
8 */ 8 */
9 9
10 #ifndef MDEV_H 10 #ifndef MDEV_H
11 #define MDEV_H 11 #define MDEV_H
12 12
13 #include <linux/device.h> <<
14 #include <linux/uuid.h> <<
15 <<
16 struct mdev_type; 13 struct mdev_type;
17 14
18 struct mdev_device { 15 struct mdev_device {
19 struct device dev; 16 struct device dev;
20 guid_t uuid; 17 guid_t uuid;
>> 18 void *driver_data;
21 struct list_head next; 19 struct list_head next;
22 struct mdev_type *type; 20 struct mdev_type *type;
23 bool active; 21 bool active;
24 }; 22 };
25 23
26 struct mdev_type { <<
27 /* set by the driver before calling md <<
28 const char *sysfs_name; <<
29 const char *pretty_name; <<
30 <<
31 /* set by the core, can be used driver <<
32 struct mdev_parent *parent; <<
33 <<
34 /* internal only */ <<
35 struct kobject kobj; <<
36 struct kobject *devices_kobj; <<
37 }; <<
38 <<
39 /* embedded into the struct device that the md <<
40 struct mdev_parent { <<
41 struct device *dev; <<
42 struct mdev_driver *mdev_driver; <<
43 struct kset *mdev_types_kset; <<
44 /* Synchronize device creation/removal <<
45 struct rw_semaphore unreg_sem; <<
46 struct mdev_type **types; <<
47 unsigned int nr_types; <<
48 atomic_t available_instances; <<
49 }; <<
50 <<
51 static inline struct mdev_device *to_mdev_devi 24 static inline struct mdev_device *to_mdev_device(struct device *dev)
52 { 25 {
53 return container_of(dev, struct mdev_d 26 return container_of(dev, struct mdev_device, dev);
54 } 27 }
55 28
>> 29 unsigned int mdev_get_type_group_id(struct mdev_device *mdev);
>> 30 unsigned int mtype_get_type_group_id(struct mdev_type *mtype);
>> 31 struct device *mtype_get_parent_dev(struct mdev_type *mtype);
>> 32
>> 33 /**
>> 34 * struct mdev_parent_ops - Structure to be registered for each parent device to
>> 35 * register the device to mdev module.
>> 36 *
>> 37 * @owner: The module owner.
>> 38 * @device_driver: Which device driver to probe() on newly created devices
>> 39 * @dev_attr_groups: Attributes of the parent device.
>> 40 * @mdev_attr_groups: Attributes of the mediated device.
>> 41 * @supported_type_groups: Attributes to define supported types. It is mandatory
>> 42 * to provide supported types.
>> 43 * @create: Called to allocate basic resources in parent device's
>> 44 * driver for a particular mediated device. It is
>> 45 * mandatory to provide create ops.
>> 46 * @mdev: mdev_device structure on of mediated device
>> 47 * that is being created
>> 48 * Returns integer: success (0) or error (< 0)
>> 49 * @remove: Called to free resources in parent device's driver for
>> 50 * a mediated device. It is mandatory to provide 'remove'
>> 51 * ops.
>> 52 * @mdev: mdev_device device structure which is being
>> 53 * destroyed
>> 54 * Returns integer: success (0) or error (< 0)
>> 55 * @read: Read emulation callback
>> 56 * @mdev: mediated device structure
>> 57 * @buf: read buffer
>> 58 * @count: number of bytes to read
>> 59 * @ppos: address.
>> 60 * Retuns number on bytes read on success or error.
>> 61 * @write: Write emulation callback
>> 62 * @mdev: mediated device structure
>> 63 * @buf: write buffer
>> 64 * @count: number of bytes to be written
>> 65 * @ppos: address.
>> 66 * Retuns number on bytes written on success or error.
>> 67 * @ioctl: IOCTL callback
>> 68 * @mdev: mediated device structure
>> 69 * @cmd: ioctl command
>> 70 * @arg: arguments to ioctl
>> 71 * @mmap: mmap callback
>> 72 * @mdev: mediated device structure
>> 73 * @vma: vma structure
>> 74 * @request: request callback to release device
>> 75 * @mdev: mediated device structure
>> 76 * @count: request sequence number
>> 77 * Parent device that support mediated device should be registered with mdev
>> 78 * module with mdev_parent_ops structure.
>> 79 **/
>> 80 struct mdev_parent_ops {
>> 81 struct module *owner;
>> 82 struct mdev_driver *device_driver;
>> 83 const struct attribute_group **dev_attr_groups;
>> 84 const struct attribute_group **mdev_attr_groups;
>> 85 struct attribute_group **supported_type_groups;
>> 86
>> 87 int (*create)(struct mdev_device *mdev);
>> 88 int (*remove)(struct mdev_device *mdev);
>> 89 int (*open_device)(struct mdev_device *mdev);
>> 90 void (*close_device)(struct mdev_device *mdev);
>> 91 ssize_t (*read)(struct mdev_device *mdev, char __user *buf,
>> 92 size_t count, loff_t *ppos);
>> 93 ssize_t (*write)(struct mdev_device *mdev, const char __user *buf,
>> 94 size_t count, loff_t *ppos);
>> 95 long (*ioctl)(struct mdev_device *mdev, unsigned int cmd,
>> 96 unsigned long arg);
>> 97 int (*mmap)(struct mdev_device *mdev, struct vm_area_struct *vma);
>> 98 void (*request)(struct mdev_device *mdev, unsigned int count);
>> 99 };
>> 100
>> 101 /* interface for exporting mdev supported type attributes */
>> 102 struct mdev_type_attribute {
>> 103 struct attribute attr;
>> 104 ssize_t (*show)(struct mdev_type *mtype,
>> 105 struct mdev_type_attribute *attr, char *buf);
>> 106 ssize_t (*store)(struct mdev_type *mtype,
>> 107 struct mdev_type_attribute *attr, const char *buf,
>> 108 size_t count);
>> 109 };
>> 110
>> 111 #define MDEV_TYPE_ATTR(_name, _mode, _show, _store) \
>> 112 struct mdev_type_attribute mdev_type_attr_##_name = \
>> 113 __ATTR(_name, _mode, _show, _store)
>> 114 #define MDEV_TYPE_ATTR_RW(_name) \
>> 115 struct mdev_type_attribute mdev_type_attr_##_name = __ATTR_RW(_name)
>> 116 #define MDEV_TYPE_ATTR_RO(_name) \
>> 117 struct mdev_type_attribute mdev_type_attr_##_name = __ATTR_RO(_name)
>> 118 #define MDEV_TYPE_ATTR_WO(_name) \
>> 119 struct mdev_type_attribute mdev_type_attr_##_name = __ATTR_WO(_name)
>> 120
56 /** 121 /**
57 * struct mdev_driver - Mediated device driver 122 * struct mdev_driver - Mediated device driver
58 * @device_api: string to return for the devic <<
59 * @max_instances: maximum number of instances <<
60 * @probe: called when new device created 123 * @probe: called when new device created
61 * @remove: called when device removed 124 * @remove: called when device removed
62 * @get_available: Return the max number of in <<
63 * @show_description: Print a description of t <<
64 * @driver: device driver structure 125 * @driver: device driver structure
>> 126 *
65 **/ 127 **/
66 struct mdev_driver { 128 struct mdev_driver {
67 const char *device_api; <<
68 unsigned int max_instances; <<
69 int (*probe)(struct mdev_device *dev); 129 int (*probe)(struct mdev_device *dev);
70 void (*remove)(struct mdev_device *dev 130 void (*remove)(struct mdev_device *dev);
71 unsigned int (*get_available)(struct m <<
72 ssize_t (*show_description)(struct mde <<
73 struct device_driver driver; 131 struct device_driver driver;
74 }; 132 };
75 133
76 int mdev_register_parent(struct mdev_parent *p !! 134 static inline void *mdev_get_drvdata(struct mdev_device *mdev)
77 struct mdev_driver *mdev_drive !! 135 {
78 unsigned int nr_types); !! 136 return mdev->driver_data;
79 void mdev_unregister_parent(struct mdev_parent !! 137 }
>> 138 static inline void mdev_set_drvdata(struct mdev_device *mdev, void *data)
>> 139 {
>> 140 mdev->driver_data = data;
>> 141 }
>> 142 static inline const guid_t *mdev_uuid(struct mdev_device *mdev)
>> 143 {
>> 144 return &mdev->uuid;
>> 145 }
>> 146
>> 147 extern struct bus_type mdev_bus_type;
>> 148
>> 149 int mdev_register_device(struct device *dev, const struct mdev_parent_ops *ops);
>> 150 void mdev_unregister_device(struct device *dev);
80 151
81 int mdev_register_driver(struct mdev_driver *d 152 int mdev_register_driver(struct mdev_driver *drv);
82 void mdev_unregister_driver(struct mdev_driver 153 void mdev_unregister_driver(struct mdev_driver *drv);
83 154
>> 155 struct device *mdev_parent_dev(struct mdev_device *mdev);
84 static inline struct device *mdev_dev(struct m 156 static inline struct device *mdev_dev(struct mdev_device *mdev)
85 { 157 {
86 return &mdev->dev; 158 return &mdev->dev;
>> 159 }
>> 160 static inline struct mdev_device *mdev_from_dev(struct device *dev)
>> 161 {
>> 162 return dev->bus == &mdev_bus_type ? to_mdev_device(dev) : NULL;
87 } 163 }
88 164
89 #endif /* MDEV_H */ 165 #endif /* MDEV_H */
90 166
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.