xref: /freebsd/sys/compat/linuxkpi/common/include/linux/device.h (revision 895f86f15fbf6540071feb9328c3c50ed1f027b8)
1 /*-
2  * Copyright (c) 2010 Isilon Systems, Inc.
3  * Copyright (c) 2010 iX Systems, Inc.
4  * Copyright (c) 2010 Panasas, Inc.
5  * Copyright (c) 2013, 2014 Mellanox Technologies, Ltd.
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice unmodified, this list of conditions, and the following
13  *    disclaimer.
14  * 2. Redistributions in binary form must reproduce the above copyright
15  *    notice, this list of conditions and the following disclaimer in the
16  *    documentation and/or other materials provided with the distribution.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28  *
29  * $FreeBSD$
30  */
31 #ifndef	_LINUX_DEVICE_H_
32 #define	_LINUX_DEVICE_H_
33 
34 #include <linux/types.h>
35 #include <linux/kobject.h>
36 #include <linux/sysfs.h>
37 #include <linux/list.h>
38 #include <linux/compiler.h>
39 #include <linux/types.h>
40 #include <linux/module.h>
41 #include <linux/workqueue.h>
42 #include <linux/sysfs.h>
43 #include <linux/kdev_t.h>
44 #include <asm/atomic.h>
45 
46 #include <sys/bus.h>
47 
48 enum irqreturn	{ IRQ_NONE = 0, IRQ_HANDLED, IRQ_WAKE_THREAD, };
49 typedef enum irqreturn	irqreturn_t;
50 
51 struct class {
52 	const char	*name;
53 	struct module	*owner;
54 	struct kobject	kobj;
55 	devclass_t	bsdclass;
56 	void		(*class_release)(struct class *class);
57 	void		(*dev_release)(struct device *dev);
58 	char *		(*devnode)(struct device *dev, umode_t *mode);
59 };
60 
61 struct device {
62 	struct device	*parent;
63 	struct list_head irqents;
64 	device_t	bsddev;
65 	dev_t		devt;
66 	struct class	*class;
67 	void		(*release)(struct device *dev);
68 	struct kobject	kobj;
69 	uint64_t	*dma_mask;
70 	void		*driver_data;
71 	unsigned int	irq;
72 	unsigned int	msix;
73 	unsigned int	msix_max;
74 };
75 
76 extern struct device linux_rootdev;
77 extern struct kobject class_root;
78 
79 struct class_attribute {
80         struct attribute attr;
81         ssize_t (*show)(struct class *, struct class_attribute *, char *);
82         ssize_t (*store)(struct class *, struct class_attribute *, const char *, size_t);
83         const void *(*namespace)(struct class *, const struct class_attribute *);
84 };
85 
86 #define	CLASS_ATTR(_name, _mode, _show, _store)				\
87 	struct class_attribute class_attr_##_name =			\
88 	    { { #_name, NULL, _mode }, _show, _store }
89 
90 struct device_attribute {
91 	struct attribute	attr;
92 	ssize_t			(*show)(struct device *,
93 					struct device_attribute *, char *);
94 	ssize_t			(*store)(struct device *,
95 					struct device_attribute *, const char *,
96 					size_t);
97 };
98 
99 #define	DEVICE_ATTR(_name, _mode, _show, _store)			\
100 	struct device_attribute dev_attr_##_name =			\
101 	    { { #_name, NULL, _mode }, _show, _store }
102 
103 /* Simple class attribute that is just a static string */
104 struct class_attribute_string {
105 	struct class_attribute attr;
106 	char *str;
107 };
108 
109 static inline ssize_t
110 show_class_attr_string(struct class *class,
111 				struct class_attribute *attr, char *buf)
112 {
113 	struct class_attribute_string *cs;
114 	cs = container_of(attr, struct class_attribute_string, attr);
115 	return snprintf(buf, PAGE_SIZE, "%s\n", cs->str);
116 }
117 
118 /* Currently read-only only */
119 #define _CLASS_ATTR_STRING(_name, _mode, _str) \
120 	{ __ATTR(_name, _mode, show_class_attr_string, NULL), _str }
121 #define CLASS_ATTR_STRING(_name, _mode, _str) \
122 	struct class_attribute_string class_attr_##_name = \
123 		_CLASS_ATTR_STRING(_name, _mode, _str)
124 
125 #define	dev_err(dev, fmt, ...)	device_printf((dev)->bsddev, fmt, ##__VA_ARGS__)
126 #define	dev_warn(dev, fmt, ...)	device_printf((dev)->bsddev, fmt, ##__VA_ARGS__)
127 #define	dev_info(dev, fmt, ...)	device_printf((dev)->bsddev, fmt, ##__VA_ARGS__)
128 #define	dev_printk(lvl, dev, fmt, ...)					\
129 	    device_printf((dev)->bsddev, fmt, ##__VA_ARGS__)
130 
131 static inline void *
132 dev_get_drvdata(struct device *dev)
133 {
134 
135 	return dev->driver_data;
136 }
137 
138 static inline void
139 dev_set_drvdata(struct device *dev, void *data)
140 {
141 
142 	dev->driver_data = data;
143 }
144 
145 static inline struct device *
146 get_device(struct device *dev)
147 {
148 
149 	if (dev)
150 		kobject_get(&dev->kobj);
151 
152 	return (dev);
153 }
154 
155 static inline char *
156 dev_name(const struct device *dev)
157 {
158 
159  	return kobject_name(&dev->kobj);
160 }
161 
162 #define	dev_set_name(_dev, _fmt, ...)					\
163 	kobject_set_name(&(_dev)->kobj, (_fmt), ##__VA_ARGS__)
164 
165 static inline void
166 put_device(struct device *dev)
167 {
168 
169 	if (dev)
170 		kobject_put(&dev->kobj);
171 }
172 
173 static inline ssize_t
174 class_show(struct kobject *kobj, struct attribute *attr, char *buf)
175 {
176 	struct class_attribute *dattr;
177 	ssize_t error;
178 
179 	dattr = container_of(attr, struct class_attribute, attr);
180 	error = -EIO;
181 	if (dattr->show)
182 		error = dattr->show(container_of(kobj, struct class, kobj),
183 		    dattr, buf);
184 	return (error);
185 }
186 
187 static inline ssize_t
188 class_store(struct kobject *kobj, struct attribute *attr, const char *buf,
189     size_t count)
190 {
191 	struct class_attribute *dattr;
192 	ssize_t error;
193 
194 	dattr = container_of(attr, struct class_attribute, attr);
195 	error = -EIO;
196 	if (dattr->store)
197 		error = dattr->store(container_of(kobj, struct class, kobj),
198 		    dattr, buf, count);
199 	return (error);
200 }
201 
202 static inline void
203 class_release(struct kobject *kobj)
204 {
205 	struct class *class;
206 
207 	class = container_of(kobj, struct class, kobj);
208 	if (class->class_release)
209 		class->class_release(class);
210 }
211 
212 static struct sysfs_ops class_sysfs = {
213 	.show  = class_show,
214 	.store = class_store,
215 };
216 static struct kobj_type class_ktype = {
217 	.release = class_release,
218 	.sysfs_ops = &class_sysfs
219 };
220 
221 static inline int
222 class_register(struct class *class)
223 {
224 
225 	class->bsdclass = devclass_create(class->name);
226 	kobject_init(&class->kobj, &class_ktype);
227 	kobject_set_name(&class->kobj, class->name);
228 	kobject_add(&class->kobj, &class_root, class->name);
229 
230 	return (0);
231 }
232 
233 static inline void
234 class_unregister(struct class *class)
235 {
236 
237 	kobject_put(&class->kobj);
238 }
239 
240 static inline void
241 device_release(struct kobject *kobj)
242 {
243 	struct device *dev;
244 
245 	dev = container_of(kobj, struct device, kobj);
246 	/* This is the precedence defined by linux. */
247 	if (dev->release)
248 		dev->release(dev);
249 	else if (dev->class && dev->class->dev_release)
250 		dev->class->dev_release(dev);
251 }
252 
253 static inline ssize_t
254 dev_show(struct kobject *kobj, struct attribute *attr, char *buf)
255 {
256 	struct device_attribute *dattr;
257 	ssize_t error;
258 
259 	dattr = container_of(attr, struct device_attribute, attr);
260 	error = -EIO;
261 	if (dattr->show)
262 		error = dattr->show(container_of(kobj, struct device, kobj),
263 		    dattr, buf);
264 	return (error);
265 }
266 
267 static inline ssize_t
268 dev_store(struct kobject *kobj, struct attribute *attr, const char *buf,
269     size_t count)
270 {
271 	struct device_attribute *dattr;
272 	ssize_t error;
273 
274 	dattr = container_of(attr, struct device_attribute, attr);
275 	error = -EIO;
276 	if (dattr->store)
277 		error = dattr->store(container_of(kobj, struct device, kobj),
278 		    dattr, buf, count);
279 	return (error);
280 }
281 
282 static struct sysfs_ops dev_sysfs = { .show  = dev_show, .store = dev_store, };
283 static struct kobj_type dev_ktype = {
284 	.release = device_release,
285 	.sysfs_ops = &dev_sysfs
286 };
287 
288 /*
289  * Devices are registered and created for exporting to sysfs.  create
290  * implies register and register assumes the device fields have been
291  * setup appropriately before being called.
292  */
293 static inline int
294 device_register(struct device *dev)
295 {
296 	device_t bsddev;
297 	int unit;
298 
299 	bsddev = NULL;
300 	if (dev->devt) {
301 		unit = MINOR(dev->devt);
302 		bsddev = devclass_get_device(dev->class->bsdclass, unit);
303 	} else
304 		unit = -1;
305 	if (bsddev == NULL)
306 		bsddev = device_add_child(dev->parent->bsddev,
307 		    dev->class->kobj.name, unit);
308 	if (bsddev) {
309 		if (dev->devt == 0)
310 			dev->devt = makedev(0, device_get_unit(bsddev));
311 		device_set_softc(bsddev, dev);
312 	}
313 	dev->bsddev = bsddev;
314 	kobject_init(&dev->kobj, &dev_ktype);
315 	kobject_add(&dev->kobj, &dev->class->kobj, dev_name(dev));
316 
317 	return (0);
318 }
319 
320 static inline void
321 device_unregister(struct device *dev)
322 {
323 	device_t bsddev;
324 
325 	bsddev = dev->bsddev;
326 	mtx_lock(&Giant);
327 	if (bsddev)
328 		device_delete_child(device_get_parent(bsddev), bsddev);
329 	mtx_unlock(&Giant);
330 	put_device(dev);
331 }
332 
333 struct device *device_create(struct class *class, struct device *parent,
334 	    dev_t devt, void *drvdata, const char *fmt, ...);
335 
336 static inline void
337 device_destroy(struct class *class, dev_t devt)
338 {
339 	device_t bsddev;
340 	int unit;
341 
342 	unit = MINOR(devt);
343 	bsddev = devclass_get_device(class->bsdclass, unit);
344 	if (bsddev)
345 		device_unregister(device_get_softc(bsddev));
346 }
347 
348 static inline void
349 class_kfree(struct class *class)
350 {
351 
352 	kfree(class);
353 }
354 
355 static inline struct class *
356 class_create(struct module *owner, const char *name)
357 {
358 	struct class *class;
359 	int error;
360 
361 	class = kzalloc(sizeof(*class), M_WAITOK);
362 	class->owner = owner;
363 	class->name= name;
364 	class->class_release = class_kfree;
365 	error = class_register(class);
366 	if (error) {
367 		kfree(class);
368 		return (NULL);
369 	}
370 
371 	return (class);
372 }
373 
374 static inline void
375 class_destroy(struct class *class)
376 {
377 
378 	if (class == NULL)
379 		return;
380 	class_unregister(class);
381 }
382 
383 static inline int
384 device_create_file(struct device *dev, const struct device_attribute *attr)
385 {
386 
387 	if (dev)
388 		return sysfs_create_file(&dev->kobj, &attr->attr);
389 	return -EINVAL;
390 }
391 
392 static inline void
393 device_remove_file(struct device *dev, const struct device_attribute *attr)
394 {
395 
396 	if (dev)
397 		sysfs_remove_file(&dev->kobj, &attr->attr);
398 }
399 
400 static inline int
401 class_create_file(struct class *class, const struct class_attribute *attr)
402 {
403 
404 	if (class)
405 		return sysfs_create_file(&class->kobj, &attr->attr);
406 	return -EINVAL;
407 }
408 
409 static inline void
410 class_remove_file(struct class *class, const struct class_attribute *attr)
411 {
412 
413 	if (class)
414 		sysfs_remove_file(&class->kobj, &attr->attr);
415 }
416 
417 static inline int dev_to_node(struct device *dev)
418 {
419                 return -1;
420 }
421 
422 char *kvasprintf(gfp_t, const char *, va_list);
423 char *kasprintf(gfp_t, const char *, ...);
424 
425 #endif	/* _LINUX_DEVICE_H_ */
426