Searched refs:ops (Results 1 - 200 of 4371) sorted by relevance

1234567891011>>

/linux-4.4.14/drivers/mfd/
H A Dabx500-core.c18 struct abx500_ops ops; member in struct:abx500_device_entry
22 static void lookup_ops(struct device *dev, struct abx500_ops **ops) lookup_ops() argument
26 *ops = NULL; lookup_ops()
29 *ops = &dev_entry->ops; lookup_ops()
35 int abx500_register_ops(struct device *dev, struct abx500_ops *ops) abx500_register_ops() argument
47 memcpy(&dev_entry->ops, ops, sizeof(struct abx500_ops)); abx500_register_ops()
67 struct abx500_ops *ops; abx500_set_register_interruptible() local
69 lookup_ops(dev->parent, &ops); abx500_set_register_interruptible()
70 if ((ops != NULL) && (ops->set_register != NULL)) abx500_set_register_interruptible()
71 return ops->set_register(dev, bank, reg, value); abx500_set_register_interruptible()
80 struct abx500_ops *ops; abx500_get_register_interruptible() local
82 lookup_ops(dev->parent, &ops); abx500_get_register_interruptible()
83 if ((ops != NULL) && (ops->get_register != NULL)) abx500_get_register_interruptible()
84 return ops->get_register(dev, bank, reg, value); abx500_get_register_interruptible()
93 struct abx500_ops *ops; abx500_get_register_page_interruptible() local
95 lookup_ops(dev->parent, &ops); abx500_get_register_page_interruptible()
96 if ((ops != NULL) && (ops->get_register_page != NULL)) abx500_get_register_page_interruptible()
97 return ops->get_register_page(dev, bank, abx500_get_register_page_interruptible()
107 struct abx500_ops *ops; abx500_mask_and_set_register_interruptible() local
109 lookup_ops(dev->parent, &ops); abx500_mask_and_set_register_interruptible()
110 if ((ops != NULL) && (ops->mask_and_set_register != NULL)) abx500_mask_and_set_register_interruptible()
111 return ops->mask_and_set_register(dev, bank, abx500_mask_and_set_register_interruptible()
120 struct abx500_ops *ops; abx500_get_chip_id() local
122 lookup_ops(dev->parent, &ops); abx500_get_chip_id()
123 if ((ops != NULL) && (ops->get_chip_id != NULL)) abx500_get_chip_id()
124 return ops->get_chip_id(dev); abx500_get_chip_id()
132 struct abx500_ops *ops; abx500_event_registers_startup_state_get() local
134 lookup_ops(dev->parent, &ops); abx500_event_registers_startup_state_get()
135 if ((ops != NULL) && (ops->event_registers_startup_state_get != NULL)) abx500_event_registers_startup_state_get()
136 return ops->event_registers_startup_state_get(dev, event); abx500_event_registers_startup_state_get()
144 struct abx500_ops *ops; abx500_startup_irq_enabled() local
146 lookup_ops(dev->parent, &ops); abx500_startup_irq_enabled()
147 if ((ops != NULL) && (ops->startup_irq_enabled != NULL)) abx500_startup_irq_enabled()
148 return ops->startup_irq_enabled(dev, irq); abx500_startup_irq_enabled()
/linux-4.4.14/drivers/base/
H A Dsyscore.c20 * @ops: System core operations to register.
22 void register_syscore_ops(struct syscore_ops *ops) register_syscore_ops() argument
25 list_add_tail(&ops->node, &syscore_ops_list); register_syscore_ops()
32 * @ops: System core operations to unregister.
34 void unregister_syscore_ops(struct syscore_ops *ops) unregister_syscore_ops() argument
37 list_del(&ops->node); unregister_syscore_ops()
50 struct syscore_ops *ops; syscore_suspend() local
63 list_for_each_entry_reverse(ops, &syscore_ops_list, node) syscore_suspend()
64 if (ops->suspend) { syscore_suspend()
66 pr_info("PM: Calling %pF\n", ops->suspend); syscore_suspend()
67 ret = ops->suspend(); syscore_suspend()
71 "Interrupts enabled after %pF\n", ops->suspend); syscore_suspend()
78 pr_err("PM: System core suspend callback %pF failed.\n", ops->suspend); syscore_suspend()
80 list_for_each_entry_continue(ops, &syscore_ops_list, node) syscore_suspend()
81 if (ops->resume) syscore_suspend()
82 ops->resume(); syscore_suspend()
95 struct syscore_ops *ops; syscore_resume() local
101 list_for_each_entry(ops, &syscore_ops_list, node) syscore_resume()
102 if (ops->resume) { syscore_resume()
104 pr_info("PM: Calling %pF\n", ops->resume); syscore_resume()
105 ops->resume(); syscore_resume()
107 "Interrupts enabled after %pF\n", ops->resume); syscore_resume()
119 struct syscore_ops *ops; syscore_shutdown() local
123 list_for_each_entry_reverse(ops, &syscore_ops_list, node) syscore_shutdown()
124 if (ops->shutdown) { syscore_shutdown()
126 pr_info("PM: Calling %pF\n", ops->shutdown); syscore_shutdown()
127 ops->shutdown(); syscore_shutdown()
H A Dcomponent.c35 const struct component_master_ops *ops; member in struct:master
46 const struct component_ops *ops; member in struct:component
55 const struct component_master_ops *ops) __master_find()
60 if (m->dev == dev && (!ops || m->ops == ops)) __master_find()
120 return master->ops->add_components(master->dev, master); find_components()
186 ret = master->ops->bind(master->dev); try_to_bring_up_master()
219 master->ops->unbind(master->dev); take_down_master()
287 const struct component_master_ops *ops, component_master_add_with_match()
293 if (ops->add_components && match) component_master_add_with_match()
308 master->ops = ops; component_master_add_with_match()
330 const struct component_master_ops *ops) component_master_add()
332 return component_master_add_with_match(dev, ops, NULL); component_master_add()
337 const struct component_master_ops *ops) component_master_del()
342 master = __master_find(dev, ops); component_master_del()
358 component->ops->unbind(component->dev, master->dev, data); component_unbind()
404 dev_dbg(master->dev, "binding %s (ops %ps)\n", component_bind()
405 dev_name(component->dev), component->ops); component_bind()
407 ret = component->ops->bind(component->dev, master->dev, data); component_bind()
420 dev_info(master->dev, "bound %s (ops %ps)\n", component_bind()
421 dev_name(component->dev), component->ops); component_bind()
426 dev_err(master->dev, "failed to bind %s (ops %ps): %d\n", component_bind()
427 dev_name(component->dev), component->ops, ret); component_bind()
461 int component_add(struct device *dev, const struct component_ops *ops) component_add() argument
470 component->ops = ops; component_add()
473 dev_dbg(dev, "adding component (ops %ps)\n", ops); component_add()
490 void component_del(struct device *dev, const struct component_ops *ops) component_del() argument
496 if (c->dev == dev && c->ops == ops) { component_del()
54 __master_find(struct device *dev, const struct component_master_ops *ops) __master_find() argument
286 component_master_add_with_match(struct device *dev, const struct component_master_ops *ops, struct component_match *match) component_master_add_with_match() argument
329 component_master_add(struct device *dev, const struct component_master_ops *ops) component_master_add() argument
336 component_master_del(struct device *dev, const struct component_master_ops *ops) component_master_del() argument
/linux-4.4.14/arch/frv/lib/
H A DMakefile7 checksum.o memcpy.o memset.o atomic-ops.o atomic64-ops.o \
/linux-4.4.14/drivers/video/console/
H A Dfbcon_rotate.c23 struct fbcon_ops *ops = info->fbcon_par; fbcon_rotate_font() local
29 if (vc->vc_font.data == ops->fontdata && fbcon_rotate_font()
30 ops->p->con_rotate == ops->cur_rotate) fbcon_rotate_font()
33 src = ops->fontdata = vc->vc_font.data; fbcon_rotate_font()
34 ops->cur_rotate = ops->p->con_rotate; fbcon_rotate_font()
35 len = (!ops->p->userfont) ? 256 : FNTCHARCNT(src); fbcon_rotate_font()
40 if (ops->rotate == FB_ROTATE_CW || fbcon_rotate_font()
41 ops->rotate == FB_ROTATE_CCW) fbcon_rotate_font()
48 if (ops->fd_size < d_cellsize * len) { fbcon_rotate_font()
56 ops->fd_size = d_cellsize * len; fbcon_rotate_font()
57 kfree(ops->fontbuffer); fbcon_rotate_font()
58 ops->fontbuffer = dst; fbcon_rotate_font()
61 dst = ops->fontbuffer; fbcon_rotate_font()
62 memset(dst, 0, ops->fd_size); fbcon_rotate_font()
64 switch (ops->rotate) { fbcon_rotate_font()
96 void fbcon_set_rotate(struct fbcon_ops *ops) fbcon_set_rotate() argument
98 ops->rotate_font = fbcon_rotate_font; fbcon_set_rotate()
100 switch(ops->rotate) { fbcon_set_rotate()
102 fbcon_rotate_cw(ops); fbcon_set_rotate()
105 fbcon_rotate_ud(ops); fbcon_set_rotate()
108 fbcon_rotate_ccw(ops); fbcon_set_rotate()
H A Dfbcon_ccw.c66 struct fbcon_ops *ops = info->fbcon_par; ccw_bmove() local
68 u32 vyres = GETVYRES(ops->p->scrollmode, info); ccw_bmove()
83 struct fbcon_ops *ops = info->fbcon_par; ccw_clear() local
86 u32 vyres = GETVYRES(ops->p->scrollmode, info); ccw_clear()
103 struct fbcon_ops *ops = info->fbcon_par; ccw_putcs_aligned() local
109 src = ops->fontbuffer + (scr_readw(s--) & charmask)*cellsize; ccw_putcs_aligned()
134 struct fbcon_ops *ops = info->fbcon_par; ccw_putcs() local
143 u32 vyres = GETVYRES(ops->p->scrollmode, info); ccw_putcs()
145 if (!ops->fontbuffer) ccw_putcs()
225 struct fbcon_ops *ops = info->fbcon_par; ccw_cursor() local
228 int y = real_y(ops->p, vc->vc_y); ccw_cursor()
232 u32 vyres = GETVYRES(ops->p->scrollmode, info); ccw_cursor()
234 if (!ops->fontbuffer) ccw_cursor()
242 ops->cursor_flash = 0; ccw_cursor()
250 src = ops->fontbuffer + ((c & charmask) * (w * vc->vc_font.width)); ccw_cursor()
252 if (ops->cursor_state.image.data != src || ccw_cursor()
253 ops->cursor_reset) { ccw_cursor()
254 ops->cursor_state.image.data = src; ccw_cursor()
264 kfree(ops->cursor_data); ccw_cursor()
265 ops->cursor_data = dst; ccw_cursor()
270 if (ops->cursor_state.image.fg_color != fg || ccw_cursor()
271 ops->cursor_state.image.bg_color != bg || ccw_cursor()
272 ops->cursor_reset) { ccw_cursor()
273 ops->cursor_state.image.fg_color = fg; ccw_cursor()
274 ops->cursor_state.image.bg_color = bg; ccw_cursor()
278 if (ops->cursor_state.image.height != vc->vc_font.width || ccw_cursor()
279 ops->cursor_state.image.width != vc->vc_font.height || ccw_cursor()
280 ops->cursor_reset) { ccw_cursor()
281 ops->cursor_state.image.height = vc->vc_font.width; ccw_cursor()
282 ops->cursor_state.image.width = vc->vc_font.height; ccw_cursor()
289 if (ops->cursor_state.image.dx != dx || ccw_cursor()
290 ops->cursor_state.image.dy != dy || ccw_cursor()
291 ops->cursor_reset) { ccw_cursor()
292 ops->cursor_state.image.dx = dx; ccw_cursor()
293 ops->cursor_state.image.dy = dy; ccw_cursor()
297 if (ops->cursor_state.hot.x || ops->cursor_state.hot.y || ccw_cursor()
298 ops->cursor_reset) { ccw_cursor()
299 ops->cursor_state.hot.x = cursor.hot.y = 0; ccw_cursor()
304 vc->vc_cursor_type != ops->p->cursor_shape || ccw_cursor()
305 ops->cursor_state.mask == NULL || ccw_cursor()
306 ops->cursor_reset) { ccw_cursor()
321 kfree(ops->cursor_state.mask); ccw_cursor()
322 ops->cursor_state.mask = mask; ccw_cursor()
324 ops->p->cursor_shape = vc->vc_cursor_type; ccw_cursor()
327 switch (ops->p->cursor_shape & CUR_HWMASK) { ccw_cursor()
362 ops->cursor_state.enable = 0; ccw_cursor()
367 ops->cursor_state.enable = (use_sw) ? 0 : 1; ccw_cursor()
372 cursor.image.fg_color = ops->cursor_state.image.fg_color; ccw_cursor()
373 cursor.image.bg_color = ops->cursor_state.image.bg_color; ccw_cursor()
374 cursor.image.dx = ops->cursor_state.image.dx; ccw_cursor()
375 cursor.image.dy = ops->cursor_state.image.dy; ccw_cursor()
376 cursor.image.height = ops->cursor_state.image.height; ccw_cursor()
377 cursor.image.width = ops->cursor_state.image.width; ccw_cursor()
378 cursor.hot.x = ops->cursor_state.hot.x; ccw_cursor()
379 cursor.hot.y = ops->cursor_state.hot.y; ccw_cursor()
380 cursor.mask = ops->cursor_state.mask; ccw_cursor()
381 cursor.enable = ops->cursor_state.enable; ccw_cursor()
391 ops->cursor_reset = 0; ccw_cursor()
396 struct fbcon_ops *ops = info->fbcon_par; ccw_update_start() local
398 u32 vyres = GETVYRES(ops->p->scrollmode, info); ccw_update_start()
401 yoffset = (vyres - info->var.yres) - ops->var.xoffset; ccw_update_start()
402 ops->var.xoffset = ops->var.yoffset; ccw_update_start()
403 ops->var.yoffset = yoffset; ccw_update_start()
404 err = fb_pan_display(info, &ops->var); ccw_update_start()
405 ops->var.xoffset = info->var.xoffset; ccw_update_start()
406 ops->var.yoffset = info->var.yoffset; ccw_update_start()
407 ops->var.vmode = info->var.vmode; ccw_update_start()
411 void fbcon_rotate_ccw(struct fbcon_ops *ops) fbcon_rotate_ccw() argument
413 ops->bmove = ccw_bmove; fbcon_rotate_ccw()
414 ops->clear = ccw_clear; fbcon_rotate_ccw()
415 ops->putcs = ccw_putcs; fbcon_rotate_ccw()
416 ops->clear_margins = ccw_clear_margins; fbcon_rotate_ccw()
417 ops->cursor = ccw_cursor; fbcon_rotate_ccw()
418 ops->update_start = ccw_update_start; fbcon_rotate_ccw()
H A Dfbcon_cw.c51 struct fbcon_ops *ops = info->fbcon_par; cw_bmove() local
53 u32 vxres = GETVXRES(ops->p->scrollmode, info); cw_bmove()
68 struct fbcon_ops *ops = info->fbcon_par; cw_clear() local
71 u32 vxres = GETVXRES(ops->p->scrollmode, info); cw_clear()
88 struct fbcon_ops *ops = info->fbcon_par; cw_putcs_aligned() local
94 src = ops->fontbuffer + (scr_readw(s++) & charmask)*cellsize; cw_putcs_aligned()
119 struct fbcon_ops *ops = info->fbcon_par; cw_putcs() local
128 u32 vxres = GETVXRES(ops->p->scrollmode, info); cw_putcs()
130 if (!ops->fontbuffer) cw_putcs()
208 struct fbcon_ops *ops = info->fbcon_par; cw_cursor() local
211 int y = real_y(ops->p, vc->vc_y); cw_cursor()
215 u32 vxres = GETVXRES(ops->p->scrollmode, info); cw_cursor()
217 if (!ops->fontbuffer) cw_cursor()
225 ops->cursor_flash = 0; cw_cursor()
233 src = ops->fontbuffer + ((c & charmask) * (w * vc->vc_font.width)); cw_cursor()
235 if (ops->cursor_state.image.data != src || cw_cursor()
236 ops->cursor_reset) { cw_cursor()
237 ops->cursor_state.image.data = src; cw_cursor()
247 kfree(ops->cursor_data); cw_cursor()
248 ops->cursor_data = dst; cw_cursor()
253 if (ops->cursor_state.image.fg_color != fg || cw_cursor()
254 ops->cursor_state.image.bg_color != bg || cw_cursor()
255 ops->cursor_reset) { cw_cursor()
256 ops->cursor_state.image.fg_color = fg; cw_cursor()
257 ops->cursor_state.image.bg_color = bg; cw_cursor()
261 if (ops->cursor_state.image.height != vc->vc_font.width || cw_cursor()
262 ops->cursor_state.image.width != vc->vc_font.height || cw_cursor()
263 ops->cursor_reset) { cw_cursor()
264 ops->cursor_state.image.height = vc->vc_font.width; cw_cursor()
265 ops->cursor_state.image.width = vc->vc_font.height; cw_cursor()
272 if (ops->cursor_state.image.dx != dx || cw_cursor()
273 ops->cursor_state.image.dy != dy || cw_cursor()
274 ops->cursor_reset) { cw_cursor()
275 ops->cursor_state.image.dx = dx; cw_cursor()
276 ops->cursor_state.image.dy = dy; cw_cursor()
280 if (ops->cursor_state.hot.x || ops->cursor_state.hot.y || cw_cursor()
281 ops->cursor_reset) { cw_cursor()
282 ops->cursor_state.hot.x = cursor.hot.y = 0; cw_cursor()
287 vc->vc_cursor_type != ops->p->cursor_shape || cw_cursor()
288 ops->cursor_state.mask == NULL || cw_cursor()
289 ops->cursor_reset) { cw_cursor()
304 kfree(ops->cursor_state.mask); cw_cursor()
305 ops->cursor_state.mask = mask; cw_cursor()
307 ops->p->cursor_shape = vc->vc_cursor_type; cw_cursor()
310 switch (ops->p->cursor_shape & CUR_HWMASK) { cw_cursor()
345 ops->cursor_state.enable = 0; cw_cursor()
350 ops->cursor_state.enable = (use_sw) ? 0 : 1; cw_cursor()
355 cursor.image.fg_color = ops->cursor_state.image.fg_color; cw_cursor()
356 cursor.image.bg_color = ops->cursor_state.image.bg_color; cw_cursor()
357 cursor.image.dx = ops->cursor_state.image.dx; cw_cursor()
358 cursor.image.dy = ops->cursor_state.image.dy; cw_cursor()
359 cursor.image.height = ops->cursor_state.image.height; cw_cursor()
360 cursor.image.width = ops->cursor_state.image.width; cw_cursor()
361 cursor.hot.x = ops->cursor_state.hot.x; cw_cursor()
362 cursor.hot.y = ops->cursor_state.hot.y; cw_cursor()
363 cursor.mask = ops->cursor_state.mask; cw_cursor()
364 cursor.enable = ops->cursor_state.enable; cw_cursor()
374 ops->cursor_reset = 0; cw_cursor()
379 struct fbcon_ops *ops = info->fbcon_par; cw_update_start() local
380 u32 vxres = GETVXRES(ops->p->scrollmode, info); cw_update_start()
384 xoffset = vxres - (info->var.xres + ops->var.yoffset); cw_update_start()
385 ops->var.yoffset = ops->var.xoffset; cw_update_start()
386 ops->var.xoffset = xoffset; cw_update_start()
387 err = fb_pan_display(info, &ops->var); cw_update_start()
388 ops->var.xoffset = info->var.xoffset; cw_update_start()
389 ops->var.yoffset = info->var.yoffset; cw_update_start()
390 ops->var.vmode = info->var.vmode; cw_update_start()
394 void fbcon_rotate_cw(struct fbcon_ops *ops) fbcon_rotate_cw() argument
396 ops->bmove = cw_bmove; fbcon_rotate_cw()
397 ops->clear = cw_clear; fbcon_rotate_cw()
398 ops->putcs = cw_putcs; fbcon_rotate_cw()
399 ops->clear_margins = cw_clear_margins; fbcon_rotate_cw()
400 ops->cursor = cw_cursor; fbcon_rotate_cw()
401 ops->update_start = cw_update_start; fbcon_rotate_cw()
H A Dbitblit.c240 struct fbcon_ops *ops = info->fbcon_par; bit_cursor() local
243 int y = real_y(ops->p, vc->vc_y); bit_cursor()
253 ops->cursor_flash = 0; bit_cursor()
263 if (ops->cursor_state.image.data != src || bit_cursor()
264 ops->cursor_reset) { bit_cursor()
265 ops->cursor_state.image.data = src; bit_cursor()
275 kfree(ops->cursor_data); bit_cursor()
276 ops->cursor_data = dst; bit_cursor()
281 if (ops->cursor_state.image.fg_color != fg || bit_cursor()
282 ops->cursor_state.image.bg_color != bg || bit_cursor()
283 ops->cursor_reset) { bit_cursor()
284 ops->cursor_state.image.fg_color = fg; bit_cursor()
285 ops->cursor_state.image.bg_color = bg; bit_cursor()
289 if ((ops->cursor_state.image.dx != (vc->vc_font.width * vc->vc_x)) || bit_cursor()
290 (ops->cursor_state.image.dy != (vc->vc_font.height * y)) || bit_cursor()
291 ops->cursor_reset) { bit_cursor()
292 ops->cursor_state.image.dx = vc->vc_font.width * vc->vc_x; bit_cursor()
293 ops->cursor_state.image.dy = vc->vc_font.height * y; bit_cursor()
297 if (ops->cursor_state.image.height != vc->vc_font.height || bit_cursor()
298 ops->cursor_state.image.width != vc->vc_font.width || bit_cursor()
299 ops->cursor_reset) { bit_cursor()
300 ops->cursor_state.image.height = vc->vc_font.height; bit_cursor()
301 ops->cursor_state.image.width = vc->vc_font.width; bit_cursor()
305 if (ops->cursor_state.hot.x || ops->cursor_state.hot.y || bit_cursor()
306 ops->cursor_reset) { bit_cursor()
307 ops->cursor_state.hot.x = cursor.hot.y = 0; bit_cursor()
312 vc->vc_cursor_type != ops->p->cursor_shape || bit_cursor()
313 ops->cursor_state.mask == NULL || bit_cursor()
314 ops->cursor_reset) { bit_cursor()
322 kfree(ops->cursor_state.mask); bit_cursor()
323 ops->cursor_state.mask = mask; bit_cursor()
325 ops->p->cursor_shape = vc->vc_cursor_type; bit_cursor()
328 switch (ops->p->cursor_shape & CUR_HWMASK) { bit_cursor()
359 ops->cursor_state.enable = 0; bit_cursor()
364 ops->cursor_state.enable = (use_sw) ? 0 : 1; bit_cursor()
369 cursor.image.fg_color = ops->cursor_state.image.fg_color; bit_cursor()
370 cursor.image.bg_color = ops->cursor_state.image.bg_color; bit_cursor()
371 cursor.image.dx = ops->cursor_state.image.dx; bit_cursor()
372 cursor.image.dy = ops->cursor_state.image.dy; bit_cursor()
373 cursor.image.height = ops->cursor_state.image.height; bit_cursor()
374 cursor.image.width = ops->cursor_state.image.width; bit_cursor()
375 cursor.hot.x = ops->cursor_state.hot.x; bit_cursor()
376 cursor.hot.y = ops->cursor_state.hot.y; bit_cursor()
377 cursor.mask = ops->cursor_state.mask; bit_cursor()
378 cursor.enable = ops->cursor_state.enable; bit_cursor()
388 ops->cursor_reset = 0; bit_cursor()
393 struct fbcon_ops *ops = info->fbcon_par; bit_update_start() local
396 err = fb_pan_display(info, &ops->var); bit_update_start()
397 ops->var.xoffset = info->var.xoffset; bit_update_start()
398 ops->var.yoffset = info->var.yoffset; bit_update_start()
399 ops->var.vmode = info->var.vmode; bit_update_start()
403 void fbcon_set_bitops(struct fbcon_ops *ops) fbcon_set_bitops() argument
405 ops->bmove = bit_bmove; fbcon_set_bitops()
406 ops->clear = bit_clear; fbcon_set_bitops()
407 ops->putcs = bit_putcs; fbcon_set_bitops()
408 ops->clear_margins = bit_clear_margins; fbcon_set_bitops()
409 ops->cursor = bit_cursor; fbcon_set_bitops()
410 ops->update_start = bit_update_start; fbcon_set_bitops()
411 ops->rotate_font = NULL; fbcon_set_bitops()
413 if (ops->rotate) fbcon_set_bitops()
414 fbcon_set_rotate(ops); fbcon_set_bitops()
H A Dfbcon_ud.c51 struct fbcon_ops *ops = info->fbcon_par; ud_bmove() local
53 u32 vyres = GETVYRES(ops->p->scrollmode, info); ud_bmove()
54 u32 vxres = GETVXRES(ops->p->scrollmode, info); ud_bmove()
69 struct fbcon_ops *ops = info->fbcon_par; ud_clear() local
72 u32 vyres = GETVYRES(ops->p->scrollmode, info); ud_clear()
73 u32 vxres = GETVXRES(ops->p->scrollmode, info); ud_clear()
90 struct fbcon_ops *ops = info->fbcon_par; ud_putcs_aligned() local
96 src = ops->fontbuffer + (scr_readw(s--) & charmask)*cellsize; ud_putcs_aligned()
123 struct fbcon_ops *ops = info->fbcon_par; ud_putcs_unaligned() local
131 src = ops->fontbuffer + (scr_readw(s--) & charmask)*cellsize; ud_putcs_unaligned()
156 struct fbcon_ops *ops = info->fbcon_par; ud_putcs() local
165 u32 vyres = GETVYRES(ops->p->scrollmode, info); ud_putcs()
166 u32 vxres = GETVXRES(ops->p->scrollmode, info); ud_putcs()
168 if (!ops->fontbuffer) ud_putcs()
255 struct fbcon_ops *ops = info->fbcon_par; ud_cursor() local
258 int y = real_y(ops->p, vc->vc_y); ud_cursor()
262 u32 vyres = GETVYRES(ops->p->scrollmode, info); ud_cursor()
263 u32 vxres = GETVXRES(ops->p->scrollmode, info); ud_cursor()
265 if (!ops->fontbuffer) ud_cursor()
273 ops->cursor_flash = 0; ud_cursor()
281 src = ops->fontbuffer + ((c & charmask) * (w * vc->vc_font.height)); ud_cursor()
283 if (ops->cursor_state.image.data != src || ud_cursor()
284 ops->cursor_reset) { ud_cursor()
285 ops->cursor_state.image.data = src; ud_cursor()
295 kfree(ops->cursor_data); ud_cursor()
296 ops->cursor_data = dst; ud_cursor()
301 if (ops->cursor_state.image.fg_color != fg || ud_cursor()
302 ops->cursor_state.image.bg_color != bg || ud_cursor()
303 ops->cursor_reset) { ud_cursor()
304 ops->cursor_state.image.fg_color = fg; ud_cursor()
305 ops->cursor_state.image.bg_color = bg; ud_cursor()
309 if (ops->cursor_state.image.height != vc->vc_font.height || ud_cursor()
310 ops->cursor_state.image.width != vc->vc_font.width || ud_cursor()
311 ops->cursor_reset) { ud_cursor()
312 ops->cursor_state.image.height = vc->vc_font.height; ud_cursor()
313 ops->cursor_state.image.width = vc->vc_font.width; ud_cursor()
320 if (ops->cursor_state.image.dx != dx || ud_cursor()
321 ops->cursor_state.image.dy != dy || ud_cursor()
322 ops->cursor_reset) { ud_cursor()
323 ops->cursor_state.image.dx = dx; ud_cursor()
324 ops->cursor_state.image.dy = dy; ud_cursor()
328 if (ops->cursor_state.hot.x || ops->cursor_state.hot.y || ud_cursor()
329 ops->cursor_reset) { ud_cursor()
330 ops->cursor_state.hot.x = cursor.hot.y = 0; ud_cursor()
335 vc->vc_cursor_type != ops->p->cursor_shape || ud_cursor()
336 ops->cursor_state.mask == NULL || ud_cursor()
337 ops->cursor_reset) { ud_cursor()
345 kfree(ops->cursor_state.mask); ud_cursor()
346 ops->cursor_state.mask = mask; ud_cursor()
348 ops->p->cursor_shape = vc->vc_cursor_type; ud_cursor()
351 switch (ops->p->cursor_shape & CUR_HWMASK) { ud_cursor()
386 ops->cursor_state.enable = 0; ud_cursor()
391 ops->cursor_state.enable = (use_sw) ? 0 : 1; ud_cursor()
396 cursor.image.fg_color = ops->cursor_state.image.fg_color; ud_cursor()
397 cursor.image.bg_color = ops->cursor_state.image.bg_color; ud_cursor()
398 cursor.image.dx = ops->cursor_state.image.dx; ud_cursor()
399 cursor.image.dy = ops->cursor_state.image.dy; ud_cursor()
400 cursor.image.height = ops->cursor_state.image.height; ud_cursor()
401 cursor.image.width = ops->cursor_state.image.width; ud_cursor()
402 cursor.hot.x = ops->cursor_state.hot.x; ud_cursor()
403 cursor.hot.y = ops->cursor_state.hot.y; ud_cursor()
404 cursor.mask = ops->cursor_state.mask; ud_cursor()
405 cursor.enable = ops->cursor_state.enable; ud_cursor()
415 ops->cursor_reset = 0; ud_cursor()
420 struct fbcon_ops *ops = info->fbcon_par; ud_update_start() local
422 u32 vyres = GETVYRES(ops->p->scrollmode, info); ud_update_start()
423 u32 vxres = GETVXRES(ops->p->scrollmode, info); ud_update_start()
426 xoffset = vxres - info->var.xres - ops->var.xoffset; ud_update_start()
427 yoffset = vyres - info->var.yres - ops->var.yoffset; ud_update_start()
430 ops->var.xoffset = xoffset; ud_update_start()
431 ops->var.yoffset = yoffset; ud_update_start()
432 err = fb_pan_display(info, &ops->var); ud_update_start()
433 ops->var.xoffset = info->var.xoffset; ud_update_start()
434 ops->var.yoffset = info->var.yoffset; ud_update_start()
435 ops->var.vmode = info->var.vmode; ud_update_start()
439 void fbcon_rotate_ud(struct fbcon_ops *ops) fbcon_rotate_ud() argument
441 ops->bmove = ud_bmove; fbcon_rotate_ud()
442 ops->clear = ud_clear; fbcon_rotate_ud()
443 ops->putcs = ud_putcs; fbcon_rotate_ud()
444 ops->clear_margins = ud_clear_margins; fbcon_rotate_ud()
445 ops->cursor = ud_cursor; fbcon_rotate_ud()
446 ops->update_start = ud_update_start; fbcon_rotate_ud()
H A Dsoftcursor.c24 struct fbcon_ops *ops = info->fbcon_par; soft_cursor() local
37 if (dsize + sizeof(struct fb_image) != ops->cursor_size) { soft_cursor()
38 kfree(ops->cursor_src); soft_cursor()
39 ops->cursor_size = dsize + sizeof(struct fb_image); soft_cursor()
41 ops->cursor_src = kmalloc(ops->cursor_size, GFP_ATOMIC); soft_cursor()
42 if (!ops->cursor_src) { soft_cursor()
43 ops->cursor_size = 0; soft_cursor()
48 src = ops->cursor_src + sizeof(struct fb_image); soft_cursor()
49 image = (struct fb_image *)ops->cursor_src; soft_cursor()
H A Dtileblit.c121 struct fbcon_ops *ops = info->fbcon_par; tile_update_start() local
124 err = fb_pan_display(info, &ops->var); tile_update_start()
125 ops->var.xoffset = info->var.xoffset; tile_update_start()
126 ops->var.yoffset = info->var.yoffset; tile_update_start()
127 ops->var.vmode = info->var.vmode; tile_update_start()
134 struct fbcon_ops *ops = info->fbcon_par; fbcon_set_tileops() local
136 ops->bmove = tile_bmove; fbcon_set_tileops()
137 ops->clear = tile_clear; fbcon_set_tileops()
138 ops->putcs = tile_putcs; fbcon_set_tileops()
139 ops->clear_margins = tile_clear_margins; fbcon_set_tileops()
140 ops->cursor = tile_cursor; fbcon_set_tileops()
141 ops->update_start = tile_update_start; fbcon_set_tileops()
143 if (ops->p) { fbcon_set_tileops()
147 map.length = (ops->p->userfont) ? fbcon_set_tileops()
148 FNTCHARCNT(ops->p->fontdata) : 256; fbcon_set_tileops()
149 map.data = ops->p->fontdata; fbcon_set_tileops()
H A Dfbcon.c198 struct fbcon_ops *ops = info->fbcon_par; fbcon_set_rotation() local
201 ops->p->con_rotate < 4) fbcon_set_rotation()
202 ops->rotate = ops->p->con_rotate; fbcon_set_rotation()
204 ops->rotate = 0; fbcon_set_rotation()
209 struct fbcon_ops *ops= info->fbcon_par; fbcon_rotate() local
212 if (!ops || ops->currcon == -1) fbcon_rotate()
215 fb_info = registered_fb[con2fb_map[ops->currcon]]; fbcon_rotate()
218 struct display *p = &fb_display[ops->currcon]; fbcon_rotate()
231 struct fbcon_ops *ops = info->fbcon_par; fbcon_rotate_all() local
236 if (!ops || ops->currcon < 0 || rotate > 3) fbcon_rotate_all()
254 struct fbcon_ops *ops = info->fbcon_par; fbcon_set_rotation() local
256 ops->rotate = FB_ROTATE_UR; fbcon_set_rotation()
272 struct fbcon_ops *ops = info->fbcon_par; fbcon_get_rotate() local
274 return (ops) ? ops->rotate : 0; fbcon_get_rotate()
279 struct fbcon_ops *ops = info->fbcon_par; fbcon_is_inactive() local
282 vc->vc_mode != KD_TEXT || ops->graphics) && fbcon_is_inactive()
368 struct fbcon_ops *ops = info->fbcon_par; fb_flashcursor() local
381 if (ops && ops->currcon != -1) fb_flashcursor()
382 vc = vc_cons[ops->currcon].d; fb_flashcursor()
392 mode = (!ops->cursor_flash || ops->cursor_state.enable) ? fb_flashcursor()
394 ops->cursor(vc, info, mode, softback_lines, get_color(vc, info, c, 1), fb_flashcursor()
402 struct fbcon_ops *ops = info->fbcon_par; cursor_timer_handler() local
405 mod_timer(&ops->cursor_timer, jiffies + ops->cur_blink_jiffies); cursor_timer_handler()
410 struct fbcon_ops *ops = info->fbcon_par; fbcon_add_cursor_timer() local
413 !(ops->flags & FBCON_FLAGS_CURSOR_TIMER) && fbcon_add_cursor_timer()
418 init_timer(&ops->cursor_timer); fbcon_add_cursor_timer()
419 ops->cursor_timer.function = cursor_timer_handler; fbcon_add_cursor_timer()
420 ops->cursor_timer.expires = jiffies + ops->cur_blink_jiffies; fbcon_add_cursor_timer()
421 ops->cursor_timer.data = (unsigned long ) info; fbcon_add_cursor_timer()
422 add_timer(&ops->cursor_timer); fbcon_add_cursor_timer()
423 ops->flags |= FBCON_FLAGS_CURSOR_TIMER; fbcon_add_cursor_timer()
429 struct fbcon_ops *ops = info->fbcon_par; fbcon_del_cursor_timer() local
432 ops->flags & FBCON_FLAGS_CURSOR_TIMER) { fbcon_del_cursor_timer()
433 del_timer_sync(&ops->cursor_timer); fbcon_del_cursor_timer()
434 ops->flags &= ~FBCON_FLAGS_CURSOR_TIMER; fbcon_del_cursor_timer()
566 struct fbcon_ops *ops = info->fbcon_par; fbcon_prepare_logo() local
582 logo_height = fb_prepare_logo(info, ops->rotate); fbcon_prepare_logo()
651 struct fbcon_ops *ops = info->fbcon_par; set_blitting_type() local
653 ops->p = &fb_display[vc->vc_num]; set_blitting_type()
659 fbcon_set_bitops(ops); set_blitting_type()
676 struct fbcon_ops *ops = info->fbcon_par; set_blitting_type() local
679 ops->p = &fb_display[vc->vc_num]; set_blitting_type()
681 fbcon_set_bitops(ops); set_blitting_type()
695 struct fbcon_ops *ops = NULL; con2fb_acquire_newinfo() local
706 ops = kzalloc(sizeof(struct fbcon_ops), GFP_KERNEL); con2fb_acquire_newinfo()
707 if (!ops) con2fb_acquire_newinfo()
712 ops->cur_blink_jiffies = HZ / 5; con2fb_acquire_newinfo()
713 info->fbcon_par = ops; con2fb_acquire_newinfo()
731 struct fbcon_ops *ops = oldinfo->fbcon_par; con2fb_release_oldinfo() local
746 kfree(ops->cursor_state.mask); con2fb_release_oldinfo()
747 kfree(ops->cursor_data); con2fb_release_oldinfo()
748 kfree(ops->cursor_src); con2fb_release_oldinfo()
749 kfree(ops->fontbuffer); con2fb_release_oldinfo()
776 struct fbcon_ops *ops = info->fbcon_par; con2fb_init_display() local
779 ops->currcon = fg_console; con2fb_init_display()
781 if (info->fbops->fb_set_par && !(ops->flags & FBCON_FLAGS_INIT)) { con2fb_init_display()
790 ops->flags |= FBCON_FLAGS_INIT; con2fb_init_display()
791 ops->graphics = 0; con2fb_init_display()
926 struct fbcon_ops *ops; fbcon_startup() local
951 ops = kzalloc(sizeof(struct fbcon_ops), GFP_KERNEL); fbcon_startup()
952 if (!ops) { fbcon_startup()
957 ops->currcon = -1; fbcon_startup()
958 ops->graphics = 1; fbcon_startup()
959 ops->cur_rotate = -1; fbcon_startup()
960 ops->cur_blink_jiffies = HZ / 5; fbcon_startup()
961 info->fbcon_par = ops; fbcon_startup()
1005 cols = FBCON_SWAP(ops->rotate, info->var.xres, info->var.yres); fbcon_startup()
1006 rows = FBCON_SWAP(ops->rotate, info->var.yres, info->var.xres); fbcon_startup()
1025 struct fbcon_ops *ops; fbcon_init() local
1097 ops = info->fbcon_par; fbcon_init()
1098 ops->cur_blink_jiffies = msecs_to_jiffies(vc->vc_cur_blink_ms); fbcon_init()
1104 new_cols = FBCON_SWAP(ops->rotate, info->var.xres, info->var.yres); fbcon_init()
1105 new_rows = FBCON_SWAP(ops->rotate, info->var.yres, info->var.xres); fbcon_init()
1118 !(ops->flags & FBCON_FLAGS_INIT)) { fbcon_init()
1127 ops->flags |= FBCON_FLAGS_INIT; fbcon_init()
1130 ops->graphics = 0; fbcon_init()
1155 if (ops->rotate_font && ops->rotate_font(info, vc)) { fbcon_init()
1156 ops->rotate = FB_ROTATE_UR; fbcon_init()
1160 ops->p = &fb_display[fg_console]; fbcon_init()
1175 struct fbcon_ops *ops; fbcon_deinit() local
1191 ops = info->fbcon_par; fbcon_deinit()
1193 if (!ops) fbcon_deinit()
1199 ops->flags &= ~FBCON_FLAGS_INIT; fbcon_deinit()
1241 struct fbcon_ops *ops = info->fbcon_par; fbcon_clear() local
1256 * dimensions then the ops->clear below won't end up clearing fbcon_clear()
1268 ops->clear(vc, info, real_y(p, sy), sx, b, width); fbcon_clear()
1269 ops->clear(vc, info, real_y(p, sy + b), sx, height - b, fbcon_clear()
1272 ops->clear(vc, info, real_y(p, sy), sx, height, width); fbcon_clear()
1280 struct fbcon_ops *ops = info->fbcon_par; fbcon_putcs() local
1283 ops->putcs(vc, info, s, count, real_y(p, ypos), xpos, fbcon_putcs()
1299 struct fbcon_ops *ops = info->fbcon_par; fbcon_clear_margins() local
1302 ops->clear_margins(vc, info, bottom_only); fbcon_clear_margins()
1308 struct fbcon_ops *ops = info->fbcon_par; fbcon_cursor() local
1312 ops->cur_blink_jiffies = msecs_to_jiffies(vc->vc_cur_blink_ms); fbcon_cursor()
1322 ops->cursor_flash = (mode == CM_ERASE) ? 0 : 1; fbcon_cursor()
1332 ops->cursor(vc, info, mode, y, get_color(vc, info, c, 1), fbcon_cursor()
1346 struct fbcon_ops *ops = info->fbcon_par; fbcon_set_disp() local
1379 ops->var = info->var; fbcon_set_disp()
1395 cols = FBCON_SWAP(ops->rotate, info->var.xres, info->var.yres); fbcon_set_disp()
1396 rows = FBCON_SWAP(ops->rotate, info->var.yres, info->var.xres); fbcon_set_disp()
1411 struct fbcon_ops *ops = info->fbcon_par; ywrap_up() local
1417 ops->var.xoffset = 0; ywrap_up()
1418 ops->var.yoffset = p->yscroll * vc->vc_font.height; ywrap_up()
1419 ops->var.vmode |= FB_VMODE_YWRAP; ywrap_up()
1420 ops->update_start(info); ywrap_up()
1430 struct fbcon_ops *ops = info->fbcon_par; ywrap_down() local
1436 ops->var.xoffset = 0; ywrap_down()
1437 ops->var.yoffset = p->yscroll * vc->vc_font.height; ywrap_down()
1438 ops->var.vmode |= FB_VMODE_YWRAP; ywrap_down()
1439 ops->update_start(info); ywrap_down()
1450 struct fbcon_ops *ops = info->fbcon_par; ypan_up() local
1454 ops->bmove(vc, info, p->vrows - vc->vc_rows, ypan_up()
1459 ops->var.xoffset = 0; ypan_up()
1460 ops->var.yoffset = p->yscroll * vc->vc_font.height; ypan_up()
1461 ops->var.vmode &= ~FB_VMODE_YWRAP; ypan_up()
1462 ops->update_start(info); ypan_up()
1473 struct fbcon_ops *ops = info->fbcon_par; ypan_up_redraw() local
1483 ops->var.xoffset = 0; ypan_up_redraw()
1484 ops->var.yoffset = p->yscroll * vc->vc_font.height; ypan_up_redraw()
1485 ops->var.vmode &= ~FB_VMODE_YWRAP; ypan_up_redraw()
1486 ops->update_start(info); ypan_up_redraw()
1498 struct fbcon_ops *ops = info->fbcon_par; ypan_down() local
1502 ops->bmove(vc, info, 0, 0, p->vrows - vc->vc_rows, ypan_down()
1507 ops->var.xoffset = 0; ypan_down()
1508 ops->var.yoffset = p->yscroll * vc->vc_font.height; ypan_down()
1509 ops->var.vmode &= ~FB_VMODE_YWRAP; ypan_down()
1510 ops->update_start(info); ypan_down()
1521 struct fbcon_ops *ops = info->fbcon_par; ypan_down_redraw() local
1531 ops->var.xoffset = 0; ypan_down_redraw()
1532 ops->var.yoffset = p->yscroll * vc->vc_font.height; ypan_down_redraw()
1533 ops->var.vmode &= ~FB_VMODE_YWRAP; ypan_down_redraw()
1534 ops->update_start(info); ypan_down_redraw()
1676 struct fbcon_ops *ops = info->fbcon_par; fbcon_redraw_blit() local
1689 ops->bmove(vc, info, line + ycount, x, fbcon_redraw_blit()
1705 ops->bmove(vc, info, line + ycount, x, line, x, 1, fbcon_redraw_blit()
2030 struct fbcon_ops *ops = info->fbcon_par; fbcon_bmove_rec() local
2064 ops->bmove(vc, info, real_y(p, sy), sx, real_y(p, dy), dx, fbcon_bmove_rec()
2072 struct fbcon_ops *ops = info->fbcon_par; updatescrollmode() local
2076 int ypan = FBCON_SWAP(ops->rotate, info->fix.ypanstep, updatescrollmode()
2078 int ywrap = FBCON_SWAP(ops->rotate, info->fix.ywrapstep, t); updatescrollmode()
2079 int yres = FBCON_SWAP(ops->rotate, info->var.yres, info->var.xres); updatescrollmode()
2080 int vyres = FBCON_SWAP(ops->rotate, info->var.yres_virtual, updatescrollmode()
2119 struct fbcon_ops *ops = info->fbcon_par; fbcon_resize() local
2124 virt_w = FBCON_SWAP(ops->rotate, width, height); fbcon_resize()
2125 virt_h = FBCON_SWAP(ops->rotate, height, width); fbcon_resize()
2126 virt_fw = FBCON_SWAP(ops->rotate, vc->vc_font.width, fbcon_resize()
2128 virt_fh = FBCON_SWAP(ops->rotate, vc->vc_font.height, fbcon_resize()
2155 ops->var = info->var; fbcon_resize()
2164 struct fbcon_ops *ops; fbcon_switch() local
2170 ops = info->fbcon_par; fbcon_switch()
2189 prev_console = ops->currcon; fbcon_switch()
2218 ops->var = info->var; fbcon_switch()
2236 ops->blank_state != FB_BLANK_UNBLANK) fbcon_switch()
2242 ops->cursor_reset = 1; fbcon_switch()
2244 if (ops->rotate_font && ops->rotate_font(info, vc)) { fbcon_switch()
2245 ops->rotate = FB_ROTATE_UR; fbcon_switch()
2279 ops->var.xoffset = ops->var.yoffset = p->yscroll = 0; fbcon_switch()
2280 ops->update_start(info); fbcon_switch()
2290 fb_show_logo(info, ops->rotate); fbcon_switch()
2328 struct fbcon_ops *ops = info->fbcon_par; fbcon_blank() local
2333 ops->graphics = 1; fbcon_blank()
2338 ops->graphics = 0; fbcon_blank()
2339 ops->var = info->var; fbcon_blank()
2344 if (ops->blank_state != blank) { fbcon_blank()
2345 ops->blank_state = blank; fbcon_blank()
2347 ops->cursor_flash = (!blank); fbcon_blank()
2359 ops->blank_state != FB_BLANK_UNBLANK) fbcon_blank()
2370 struct fbcon_ops *ops = info->fbcon_par; fbcon_debug_enter() local
2372 ops->save_graphics = ops->graphics; fbcon_debug_enter()
2373 ops->graphics = 0; fbcon_debug_enter()
2383 struct fbcon_ops *ops = info->fbcon_par; fbcon_debug_leave() local
2385 ops->graphics = ops->save_graphics; fbcon_debug_leave()
2446 struct fbcon_ops *ops = info->fbcon_par; fbcon_do_set_font() local
2528 cols = FBCON_SWAP(ops->rotate, info->var.xres, info->var.yres); fbcon_do_set_font()
2529 rows = FBCON_SWAP(ops->rotate, info->var.yres, info->var.xres); fbcon_do_set_font()
2771 struct fbcon_ops *ops = info->fbcon_par; fbcon_scrolldelta() local
2849 ops->var.xoffset = 0; fbcon_scrolldelta()
2850 ops->var.yoffset = offset * vc->vc_font.height; fbcon_scrolldelta()
2851 ops->update_start(info); fbcon_scrolldelta()
2868 struct fbcon_ops *ops = info->fbcon_par; fbcon_suspended() local
2870 if (!ops || ops->currcon < 0) fbcon_suspended()
2872 vc = vc_cons[ops->currcon].d; fbcon_suspended()
2881 struct fbcon_ops *ops = info->fbcon_par; fbcon_resumed() local
2883 if (!ops || ops->currcon < 0) fbcon_resumed()
2885 vc = vc_cons[ops->currcon].d; fbcon_resumed()
2892 struct fbcon_ops *ops = info->fbcon_par; fbcon_modechanged() local
2897 if (!ops || ops->currcon < 0) fbcon_modechanged()
2899 vc = vc_cons[ops->currcon].d; fbcon_modechanged()
2901 registered_fb[con2fb_map[ops->currcon]] != info) fbcon_modechanged()
2909 cols = FBCON_SWAP(ops->rotate, info->var.xres, info->var.yres); fbcon_modechanged()
2910 rows = FBCON_SWAP(ops->rotate, info->var.yres, info->var.xres); fbcon_modechanged()
2919 ops->var.xoffset = ops->var.yoffset = p->yscroll = 0; fbcon_modechanged()
2920 ops->update_start(info); fbcon_modechanged()
2932 struct fbcon_ops *ops = info->fbcon_par; fbcon_set_all_vcs() local
2937 if (!ops || ops->currcon < 0) fbcon_set_all_vcs()
2954 cols = FBCON_SWAP(ops->rotate, info->var.xres, info->var.yres); fbcon_set_all_vcs()
2955 rows = FBCON_SWAP(ops->rotate, info->var.yres, info->var.xres); fbcon_set_all_vcs()
3174 struct fbcon_ops *ops = info->fbcon_par; fbcon_fb_blanked() local
3177 if (!ops || ops->currcon < 0) fbcon_fb_blanked()
3180 vc = vc_cons[ops->currcon].d; fbcon_fb_blanked()
3182 registered_fb[con2fb_map[ops->currcon]] != info) fbcon_fb_blanked()
3191 ops->blank_state = blank; fbcon_fb_blanked()
3437 struct fbcon_ops *ops; show_cursor_blink() local
3450 ops = info->fbcon_par; show_cursor_blink()
3452 if (!ops) show_cursor_blink()
3455 blink = (ops->flags & FBCON_FLAGS_CURSOR_TIMER) ? 1 : 0; show_cursor_blink()
3586 struct fbcon_ops *ops = info->fbcon_par; fbcon_exit() local
3589 kfree(ops->cursor_src); fbcon_exit()
3590 kfree(ops->cursor_state.mask); fbcon_exit()
/linux-4.4.14/drivers/net/wireless/ti/wlcore/
H A Dhw_ops.h31 if (!wl->ops->calc_tx_blocks) wlcore_hw_calc_tx_blocks()
34 return wl->ops->calc_tx_blocks(wl, len, spare_blks); wlcore_hw_calc_tx_blocks()
41 if (!wl->ops->set_tx_desc_blocks) wlcore_hw_set_tx_desc_blocks()
44 return wl->ops->set_tx_desc_blocks(wl, desc, blks, spare_blks); wlcore_hw_set_tx_desc_blocks()
52 if (!wl->ops->set_tx_desc_data_len) wlcore_hw_set_tx_desc_data_len()
55 wl->ops->set_tx_desc_data_len(wl, desc, skb); wlcore_hw_set_tx_desc_data_len()
62 if (!wl->ops->get_rx_buf_align) wlcore_hw_get_rx_buf_align()
65 return wl->ops->get_rx_buf_align(wl, rx_desc); wlcore_hw_get_rx_buf_align()
71 if (wl->ops->prepare_read) wlcore_hw_prepare_read()
72 return wl->ops->prepare_read(wl, rx_desc, len); wlcore_hw_prepare_read()
80 if (!wl->ops->get_rx_packet_len) wlcore_hw_get_rx_packet_len()
83 return wl->ops->get_rx_packet_len(wl, rx_data, data_len); wlcore_hw_get_rx_packet_len()
88 if (wl->ops->tx_delayed_compl) wlcore_hw_tx_delayed_compl()
89 return wl->ops->tx_delayed_compl(wl); wlcore_hw_tx_delayed_compl()
96 if (wl->ops->tx_immediate_compl) wlcore_hw_tx_immediate_compl()
97 wl->ops->tx_immediate_compl(wl); wlcore_hw_tx_immediate_compl()
103 if (wl->ops->init_vif) wlcore_hw_init_vif()
104 return wl->ops->init_vif(wl, wlvif); wlcore_hw_init_vif()
113 BUG_ON(!wl->ops->convert_fw_status); wlcore_hw_convert_fw_status()
115 wl->ops->convert_fw_status(wl, raw_fw_status, fw_status); wlcore_hw_convert_fw_status()
121 if (!wl->ops->sta_get_ap_rate_mask) wlcore_hw_sta_get_ap_rate_mask()
124 return wl->ops->sta_get_ap_rate_mask(wl, wlvif); wlcore_hw_sta_get_ap_rate_mask()
129 if (wl->ops->identify_fw) wlcore_identify_fw()
130 return wl->ops->identify_fw(wl); wlcore_identify_fw()
140 if (!wl->ops->set_tx_desc_csum) wlcore_hw_set_tx_desc_csum()
143 wl->ops->set_tx_desc_csum(wl, desc, skb); wlcore_hw_set_tx_desc_csum()
151 if (wl->ops->set_rx_csum) wlcore_hw_set_rx_csum()
152 wl->ops->set_rx_csum(wl, desc, skb); wlcore_hw_set_rx_csum()
159 if (wl->ops->ap_get_mimo_wide_rate_mask) wlcore_hw_ap_get_mimo_wide_rate_mask()
160 return wl->ops->ap_get_mimo_wide_rate_mask(wl, wlvif); wlcore_hw_ap_get_mimo_wide_rate_mask()
168 if (wl->ops->debugfs_init) wlcore_debugfs_init()
169 return wl->ops->debugfs_init(wl, rootdir); wlcore_debugfs_init()
177 if (wl->ops->handle_static_data) wlcore_handle_static_data()
178 return wl->ops->handle_static_data(wl, static_data); wlcore_handle_static_data()
186 if (!wl->ops->get_spare_blocks) wlcore_hw_get_spare_blocks()
189 return wl->ops->get_spare_blocks(wl, is_gem); wlcore_hw_get_spare_blocks()
198 if (!wl->ops->set_key) wlcore_hw_set_key()
201 return wl->ops->set_key(wl, cmd, vif, sta, key_conf); wlcore_hw_set_key()
207 if (wl->ops->pre_pkt_send) wlcore_hw_pre_pkt_send()
208 return wl->ops->pre_pkt_send(wl, buf_offset, last_len); wlcore_hw_pre_pkt_send()
216 if (wl->ops->sta_rc_update) wlcore_hw_sta_rc_update()
217 wl->ops->sta_rc_update(wl, wlvif); wlcore_hw_sta_rc_update()
223 if (wl->ops->interrupt_notify) wlcore_hw_interrupt_notify()
224 return wl->ops->interrupt_notify(wl, action); wlcore_hw_interrupt_notify()
231 if (wl->ops->rx_ba_filter) wlcore_hw_rx_ba_filter()
232 return wl->ops->rx_ba_filter(wl, action); wlcore_hw_rx_ba_filter()
239 if (wl->ops->ap_sleep) wlcore_hw_ap_sleep()
240 return wl->ops->ap_sleep(wl); wlcore_hw_ap_sleep()
251 if (wl->ops->set_peer_cap) wlcore_hw_set_peer_cap()
252 return wl->ops->set_peer_cap(wl, ht_cap, allow_ht_operation, wlcore_hw_set_peer_cap()
261 if (!wl->ops->convert_hwaddr) wlcore_hw_convert_hwaddr()
264 return wl->ops->convert_hwaddr(wl, hwaddr); wlcore_hw_convert_hwaddr()
271 if (!wl->ops->lnk_high_prio) wlcore_hw_lnk_high_prio()
274 return wl->ops->lnk_high_prio(wl, hlid, lnk); wlcore_hw_lnk_high_prio()
281 if (!wl->ops->lnk_low_prio) wlcore_hw_lnk_low_prio()
284 return wl->ops->lnk_low_prio(wl, hlid, lnk); wlcore_hw_lnk_low_prio()
290 if (!wl->ops->smart_config_start) wlcore_smart_config_start()
293 return wl->ops->smart_config_start(wl, group_bitmap); wlcore_smart_config_start()
299 if (!wl->ops->smart_config_stop) wlcore_smart_config_stop()
302 return wl->ops->smart_config_stop(wl); wlcore_smart_config_stop()
309 if (!wl->ops->smart_config_set_group_key) wlcore_smart_config_set_group_key()
312 return wl->ops->smart_config_set_group_key(wl, group_id, key_len, key); wlcore_smart_config_set_group_key()
318 if (!wl->ops->set_cac) wlcore_hw_set_cac()
321 return wl->ops->set_cac(wl, wlvif, start); wlcore_hw_set_cac()
327 if (!wl->ops->dfs_master_restart) wlcore_hw_dfs_master_restart()
330 return wl->ops->dfs_master_restart(wl, wlvif); wlcore_hw_dfs_master_restart()
/linux-4.4.14/net/mac802154/
H A Dtrace.c5 #include "driver-ops.h"
H A Ddriver-ops.h15 return local->ops->xmit_async(&local->hw, skb); drv_xmit_async()
26 return local->ops->xmit_sync(&local->hw, skb); drv_xmit_sync()
38 ret = local->ops->start(&local->hw); drv_start()
48 local->ops->stop(&local->hw); drv_stop()
68 ret = local->ops->set_channel(&local->hw, page, channel); drv_set_channel()
79 if (!local->ops->set_txpower) { drv_set_tx_power()
85 ret = local->ops->set_txpower(&local->hw, mbm); drv_set_tx_power()
97 if (!local->ops->set_cca_mode) { drv_set_cca_mode()
103 ret = local->ops->set_cca_mode(&local->hw, cca); drv_set_cca_mode()
114 if (!local->ops->set_lbt) { drv_set_lbt_mode()
120 ret = local->ops->set_lbt(&local->hw, mode); drv_set_lbt_mode()
132 if (!local->ops->set_cca_ed_level) { drv_set_cca_ed_level()
138 ret = local->ops->set_cca_ed_level(&local->hw, mbm); drv_set_cca_ed_level()
150 if (!local->ops->set_hw_addr_filt) { drv_set_pan_id()
158 ret = local->ops->set_hw_addr_filt(&local->hw, &filt, drv_set_pan_id()
172 if (!local->ops->set_hw_addr_filt) { drv_set_extended_addr()
180 ret = local->ops->set_hw_addr_filt(&local->hw, &filt, drv_set_extended_addr()
194 if (!local->ops->set_hw_addr_filt) { drv_set_short_addr()
202 ret = local->ops->set_hw_addr_filt(&local->hw, &filt, drv_set_short_addr()
216 if (!local->ops->set_hw_addr_filt) { drv_set_pan_coord()
224 ret = local->ops->set_hw_addr_filt(&local->hw, &filt, drv_set_pan_coord()
238 if (!local->ops->set_csma_params) { drv_set_csma_params()
245 ret = local->ops->set_csma_params(&local->hw, min_be, max_be, drv_set_csma_params()
258 if (!local->ops->set_frame_retries) { drv_set_max_frame_retries()
264 ret = local->ops->set_frame_retries(&local->hw, max_frame_retries); drv_set_max_frame_retries()
276 if (!local->ops->set_promiscuous_mode) { drv_set_promiscuous_mode()
282 ret = local->ops->set_promiscuous_mode(&local->hw, on); drv_set_promiscuous_mode()
H A Dmain.c55 ieee802154_alloc_hw(size_t priv_data_len, const struct ieee802154_ops *ops) ieee802154_alloc_hw() argument
61 if (WARN_ON(!ops || !(ops->xmit_async || ops->xmit_sync) || !ops->ed || ieee802154_alloc_hw()
62 !ops->start || !ops->stop || !ops->set_channel)) ieee802154_alloc_hw()
97 local->ops = ops; ieee802154_alloc_hw()
/linux-4.4.14/drivers/rtc/
H A Drtc-m48t86.c49 struct m48t86_ops *ops = dev_get_platdata(&pdev->dev); m48t86_rtc_read_time() local
51 reg = ops->readbyte(M48T86_REG_B); m48t86_rtc_read_time()
55 tm->tm_sec = ops->readbyte(M48T86_REG_SEC); m48t86_rtc_read_time()
56 tm->tm_min = ops->readbyte(M48T86_REG_MIN); m48t86_rtc_read_time()
57 tm->tm_hour = ops->readbyte(M48T86_REG_HOUR) & 0x3F; m48t86_rtc_read_time()
58 tm->tm_mday = ops->readbyte(M48T86_REG_DOM); m48t86_rtc_read_time()
60 tm->tm_mon = ops->readbyte(M48T86_REG_MONTH) - 1; m48t86_rtc_read_time()
61 tm->tm_year = ops->readbyte(M48T86_REG_YEAR) + 100; m48t86_rtc_read_time()
62 tm->tm_wday = ops->readbyte(M48T86_REG_DOW); m48t86_rtc_read_time()
65 tm->tm_sec = bcd2bin(ops->readbyte(M48T86_REG_SEC)); m48t86_rtc_read_time()
66 tm->tm_min = bcd2bin(ops->readbyte(M48T86_REG_MIN)); m48t86_rtc_read_time()
67 tm->tm_hour = bcd2bin(ops->readbyte(M48T86_REG_HOUR) & 0x3F); m48t86_rtc_read_time()
68 tm->tm_mday = bcd2bin(ops->readbyte(M48T86_REG_DOM)); m48t86_rtc_read_time()
70 tm->tm_mon = bcd2bin(ops->readbyte(M48T86_REG_MONTH)) - 1; m48t86_rtc_read_time()
71 tm->tm_year = bcd2bin(ops->readbyte(M48T86_REG_YEAR)) + 100; m48t86_rtc_read_time()
72 tm->tm_wday = bcd2bin(ops->readbyte(M48T86_REG_DOW)); m48t86_rtc_read_time()
77 if (ops->readbyte(M48T86_REG_HOUR) & 0x80) m48t86_rtc_read_time()
87 struct m48t86_ops *ops = dev_get_platdata(&pdev->dev); m48t86_rtc_set_time() local
89 reg = ops->readbyte(M48T86_REG_B); m48t86_rtc_set_time()
93 ops->writebyte(reg, M48T86_REG_B); m48t86_rtc_set_time()
97 ops->writebyte(tm->tm_sec, M48T86_REG_SEC); m48t86_rtc_set_time()
98 ops->writebyte(tm->tm_min, M48T86_REG_MIN); m48t86_rtc_set_time()
99 ops->writebyte(tm->tm_hour, M48T86_REG_HOUR); m48t86_rtc_set_time()
100 ops->writebyte(tm->tm_mday, M48T86_REG_DOM); m48t86_rtc_set_time()
101 ops->writebyte(tm->tm_mon + 1, M48T86_REG_MONTH); m48t86_rtc_set_time()
102 ops->writebyte(tm->tm_year % 100, M48T86_REG_YEAR); m48t86_rtc_set_time()
103 ops->writebyte(tm->tm_wday, M48T86_REG_DOW); m48t86_rtc_set_time()
106 ops->writebyte(bin2bcd(tm->tm_sec), M48T86_REG_SEC); m48t86_rtc_set_time()
107 ops->writebyte(bin2bcd(tm->tm_min), M48T86_REG_MIN); m48t86_rtc_set_time()
108 ops->writebyte(bin2bcd(tm->tm_hour), M48T86_REG_HOUR); m48t86_rtc_set_time()
109 ops->writebyte(bin2bcd(tm->tm_mday), M48T86_REG_DOM); m48t86_rtc_set_time()
110 ops->writebyte(bin2bcd(tm->tm_mon + 1), M48T86_REG_MONTH); m48t86_rtc_set_time()
111 ops->writebyte(bin2bcd(tm->tm_year % 100), M48T86_REG_YEAR); m48t86_rtc_set_time()
112 ops->writebyte(bin2bcd(tm->tm_wday), M48T86_REG_DOW); m48t86_rtc_set_time()
117 ops->writebyte(reg, M48T86_REG_B); m48t86_rtc_set_time()
126 struct m48t86_ops *ops = dev_get_platdata(&pdev->dev); m48t86_rtc_proc() local
128 reg = ops->readbyte(M48T86_REG_B); m48t86_rtc_proc()
133 reg = ops->readbyte(M48T86_REG_D); m48t86_rtc_proc()
150 struct m48t86_ops *ops = dev_get_platdata(&dev->dev); m48t86_rtc_probe() local
162 reg = ops->readbyte(M48T86_REG_D); m48t86_rtc_probe()
H A Dsystohc.c38 if (rtc->ops && rtc_set_ntp_time()
39 (rtc->ops->set_time || rtc_set_ntp_time()
40 rtc->ops->set_mmss64 || rtc_set_ntp_time()
41 rtc->ops->set_mmss)) rtc_set_ntp_time()
/linux-4.4.14/net/netfilter/
H A Dnf_sockopt.c26 struct nf_sockopt_ops *ops; nf_register_sockopt() local
30 list_for_each_entry(ops, &nf_sockopts, list) { nf_register_sockopt()
31 if (ops->pf == reg->pf nf_register_sockopt()
32 && (overlap(ops->set_optmin, ops->set_optmax, nf_register_sockopt()
34 || overlap(ops->get_optmin, ops->get_optmax, nf_register_sockopt()
37 ops->set_optmin, ops->set_optmax, nf_register_sockopt()
38 ops->get_optmin, ops->get_optmax, nf_register_sockopt()
64 struct nf_sockopt_ops *ops; nf_sockopt_find() local
67 list_for_each_entry(ops, &nf_sockopts, list) { nf_sockopt_find()
68 if (ops->pf == pf) { nf_sockopt_find()
69 if (!try_module_get(ops->owner)) nf_sockopt_find()
73 if (val >= ops->get_optmin && nf_sockopt_find()
74 val < ops->get_optmax) nf_sockopt_find()
77 if (val >= ops->set_optmin && nf_sockopt_find()
78 val < ops->set_optmax) nf_sockopt_find()
81 module_put(ops->owner); nf_sockopt_find()
85 ops = ERR_PTR(-ENOPROTOOPT); nf_sockopt_find()
88 return ops; nf_sockopt_find()
95 struct nf_sockopt_ops *ops; nf_sockopt() local
98 ops = nf_sockopt_find(sk, pf, val, get); nf_sockopt()
99 if (IS_ERR(ops)) nf_sockopt()
100 return PTR_ERR(ops); nf_sockopt()
103 ret = ops->get(sk, val, opt, len); nf_sockopt()
105 ret = ops->set(sk, val, opt, *len); nf_sockopt()
107 module_put(ops->owner); nf_sockopt()
129 struct nf_sockopt_ops *ops; compat_nf_sockopt() local
132 ops = nf_sockopt_find(sk, pf, val, get); compat_nf_sockopt()
133 if (IS_ERR(ops)) compat_nf_sockopt()
134 return PTR_ERR(ops); compat_nf_sockopt()
137 if (ops->compat_get) compat_nf_sockopt()
138 ret = ops->compat_get(sk, val, opt, len); compat_nf_sockopt()
140 ret = ops->get(sk, val, opt, len); compat_nf_sockopt()
142 if (ops->compat_set) compat_nf_sockopt()
143 ret = ops->compat_set(sk, val, opt, *len); compat_nf_sockopt()
145 ret = ops->set(sk, val, opt, *len); compat_nf_sockopt()
148 module_put(ops->owner); compat_nf_sockopt()
H A Dnf_tables_inet.c19 static void nft_inet_hook_ops_init(struct nf_hook_ops *ops, unsigned int n) nft_inet_hook_ops_init() argument
28 ops->pf = afi->family; nft_inet_hook_ops_init()
29 if (afi->hooks[ops->hooknum]) nft_inet_hook_ops_init()
30 ops->hook = afi->hooks[ops->hooknum]; nft_inet_hook_ops_init()
H A Dnft_compat.c62 struct xt_target *target = expr->ops->data; nft_target_eval_xt()
88 struct xt_target *target = expr->ops->data; nft_target_eval_bridge()
157 const struct nf_hook_ops *ops = &basechain->ops[0]; nft_target_set_tgchk_param() local
159 par->hook_mask = 1 << ops->hooknum; nft_target_set_tgchk_param()
211 struct xt_target *target = expr->ops->data; nft_target_init()
252 struct xt_target *target = expr->ops->data; nft_target_destroy()
268 const struct xt_target *target = expr->ops->data; nft_target_dump()
286 struct xt_target *target = expr->ops->data; nft_target_validate()
293 const struct nf_hook_ops *ops = &basechain->ops[0]; nft_target_validate() local
295 hook_mask = 1 << ops->hooknum; nft_target_validate()
312 struct xt_match *match = expr->ops->data; nft_match_eval()
374 const struct nf_hook_ops *ops = &basechain->ops[0]; nft_match_set_mtchk_param() local
376 par->hook_mask = 1 << ops->hooknum; nft_match_set_mtchk_param()
399 struct xt_match *match = expr->ops->data; nft_match_init()
434 struct xt_match *match = expr->ops->data; nft_match_destroy()
451 struct xt_match *match = expr->ops->data; nft_match_dump()
468 struct xt_match *match = expr->ops->data; nft_match_validate()
475 const struct nf_hook_ops *ops = &basechain->ops[0]; nft_match_validate() local
477 hook_mask = 1 << ops->hooknum; nft_match_validate()
617 struct nft_expr_ops ops; member in struct:nft_xt
649 struct xt_match *match = nft_match->ops.data; nft_match_select_ops()
655 return &nft_match->ops; nft_match_select_ops()
668 nft_match->ops.type = &nft_match_type; nft_match_select_ops()
669 nft_match->ops.size = NFT_EXPR_SIZE(XT_ALIGN(match->matchsize)); nft_match_select_ops()
670 nft_match->ops.eval = nft_match_eval; nft_match_select_ops()
671 nft_match->ops.init = nft_match_init; nft_match_select_ops()
672 nft_match->ops.destroy = nft_match_destroy; nft_match_select_ops()
673 nft_match->ops.dump = nft_match_dump; nft_match_select_ops()
674 nft_match->ops.validate = nft_match_validate; nft_match_select_ops()
675 nft_match->ops.data = match; nft_match_select_ops()
679 return &nft_match->ops; nft_match_select_ops()
729 struct xt_target *target = nft_target->ops.data; nft_target_select_ops()
735 return &nft_target->ops; nft_target_select_ops()
748 nft_target->ops.type = &nft_target_type; nft_target_select_ops()
749 nft_target->ops.size = NFT_EXPR_SIZE(XT_ALIGN(target->targetsize)); nft_target_select_ops()
750 nft_target->ops.init = nft_target_init; nft_target_select_ops()
751 nft_target->ops.destroy = nft_target_destroy; nft_target_select_ops()
752 nft_target->ops.dump = nft_target_dump; nft_target_select_ops()
753 nft_target->ops.validate = nft_target_validate; nft_target_select_ops()
754 nft_target->ops.data = target; nft_target_select_ops()
757 nft_target->ops.eval = nft_target_eval_bridge; nft_target_select_ops()
759 nft_target->ops.eval = nft_target_eval_xt; nft_target_select_ops()
763 return &nft_target->ops; nft_target_select_ops()
/linux-4.4.14/arch/s390/appldata/
H A Dappldata_base.c126 struct appldata_ops *ops; appldata_work_fn() local
130 ops = list_entry(lh, struct appldata_ops, list); appldata_work_fn()
131 if (ops->active == 1) { appldata_work_fn()
132 ops->callback(ops->data); appldata_work_fn()
293 struct appldata_ops *ops = NULL, *tmp_ops; appldata_generic_handler() local
311 ops = ctl->data; appldata_generic_handler()
312 if (!try_module_get(ops->owner)) { // protect this function appldata_generic_handler()
320 module_put(ops->owner); appldata_generic_handler()
324 strncpy(buf, ops->active ? "1\n" : "0\n", ARRAY_SIZE(buf)); appldata_generic_handler()
329 module_put(ops->owner); appldata_generic_handler()
337 module_put(ops->owner); appldata_generic_handler()
342 if ((buf[0] == '1') && (ops->active == 0)) { appldata_generic_handler()
344 if (!try_module_get(ops->owner)) { appldata_generic_handler()
346 module_put(ops->owner); appldata_generic_handler()
349 ops->callback(ops->data); // init record appldata_generic_handler()
350 rc = appldata_diag(ops->record_nr, appldata_generic_handler()
352 (unsigned long) ops->data, ops->size, appldata_generic_handler()
353 ops->mod_lvl); appldata_generic_handler()
356 "failed with rc=%d\n", ops->name, rc); appldata_generic_handler()
357 module_put(ops->owner); appldata_generic_handler()
359 ops->active = 1; appldata_generic_handler()
360 } else if ((buf[0] == '0') && (ops->active == 1)) { appldata_generic_handler()
361 ops->active = 0; appldata_generic_handler()
362 rc = appldata_diag(ops->record_nr, APPLDATA_STOP_REC, appldata_generic_handler()
363 (unsigned long) ops->data, ops->size, appldata_generic_handler()
364 ops->mod_lvl); appldata_generic_handler()
367 "failed with rc=%d\n", ops->name, rc); appldata_generic_handler()
368 module_put(ops->owner); appldata_generic_handler()
374 module_put(ops->owner); appldata_generic_handler()
381 /************************* module-ops management *****************************/
385 * update ops list, register /proc/sys entries
387 int appldata_register_ops(struct appldata_ops *ops) appldata_register_ops() argument
389 if (ops->size > APPLDATA_MAX_REC_SIZE) appldata_register_ops()
392 ops->ctl_table = kzalloc(4 * sizeof(struct ctl_table), GFP_KERNEL); appldata_register_ops()
393 if (!ops->ctl_table) appldata_register_ops()
397 list_add(&ops->list, &appldata_ops_list); appldata_register_ops()
400 ops->ctl_table[0].procname = appldata_proc_name; appldata_register_ops()
401 ops->ctl_table[0].maxlen = 0; appldata_register_ops()
402 ops->ctl_table[0].mode = S_IRUGO | S_IXUGO; appldata_register_ops()
403 ops->ctl_table[0].child = &ops->ctl_table[2]; appldata_register_ops()
405 ops->ctl_table[2].procname = ops->name; appldata_register_ops()
406 ops->ctl_table[2].mode = S_IRUGO | S_IWUSR; appldata_register_ops()
407 ops->ctl_table[2].proc_handler = appldata_generic_handler; appldata_register_ops()
408 ops->ctl_table[2].data = ops; appldata_register_ops()
410 ops->sysctl_header = register_sysctl_table(ops->ctl_table); appldata_register_ops()
411 if (!ops->sysctl_header) appldata_register_ops()
416 list_del(&ops->list); appldata_register_ops()
418 kfree(ops->ctl_table); appldata_register_ops()
425 * update ops list, unregister /proc entries, stop DIAG if necessary
427 void appldata_unregister_ops(struct appldata_ops *ops) appldata_unregister_ops() argument
430 list_del(&ops->list); appldata_unregister_ops()
432 unregister_sysctl_table(ops->sysctl_header); appldata_unregister_ops()
433 kfree(ops->ctl_table); appldata_unregister_ops()
435 /********************** module-ops management <END> **************************/
441 struct appldata_ops *ops; appldata_freeze() local
454 ops = list_entry(lh, struct appldata_ops, list); appldata_freeze()
455 if (ops->active == 1) { appldata_freeze()
456 rc = appldata_diag(ops->record_nr, APPLDATA_STOP_REC, appldata_freeze()
457 (unsigned long) ops->data, ops->size, appldata_freeze()
458 ops->mod_lvl); appldata_freeze()
461 "failed with rc=%d\n", ops->name, rc); appldata_freeze()
470 struct appldata_ops *ops; appldata_restore() local
483 ops = list_entry(lh, struct appldata_ops, list); appldata_restore()
484 if (ops->active == 1) { appldata_restore()
485 ops->callback(ops->data); // init record appldata_restore()
486 rc = appldata_diag(ops->record_nr, appldata_restore()
488 (unsigned long) ops->data, ops->size, appldata_restore()
489 ops->mod_lvl); appldata_restore()
492 "failed with rc=%d\n", ops->name, rc); appldata_restore()
H A Dappldata_os.c84 static struct appldata_ops ops = { variable in typeref:struct:appldata_ops
139 if (ops.size != new_size) {
140 if (ops.active) {
143 (unsigned long) ops.data, new_size,
144 ops.mod_lvl);
151 (unsigned long) ops.data, ops.size,
152 ops.mod_lvl);
157 ops.size = new_size;
167 * init data, register ops
192 ops.data = appldata_os_data; appldata_os_init()
193 ops.callback = &appldata_get_os_data; appldata_os_init()
194 rc = appldata_register_ops(&ops); appldata_os_init()
204 * unregister ops
208 appldata_unregister_ops(&ops); appldata_os_exit()
H A Dappldata_net_sum.c119 static struct appldata_ops ops = { variable in typeref:struct:appldata_ops
132 * init data, register ops
138 ops.data = kzalloc(sizeof(struct appldata_net_sum_data), GFP_KERNEL); appldata_net_init()
139 if (!ops.data) appldata_net_init()
142 ret = appldata_register_ops(&ops); appldata_net_init()
144 kfree(ops.data); appldata_net_init()
152 * unregister ops
156 appldata_unregister_ops(&ops); appldata_net_exit()
157 kfree(ops.data); appldata_net_exit()
H A Dappldata_mem.c117 static struct appldata_ops ops = { variable in typeref:struct:appldata_ops
130 * init_data, register ops
136 ops.data = kzalloc(sizeof(struct appldata_mem_data), GFP_KERNEL); appldata_mem_init()
137 if (!ops.data) appldata_mem_init()
140 ret = appldata_register_ops(&ops); appldata_mem_init()
142 kfree(ops.data); appldata_mem_init()
150 * unregister ops
154 appldata_unregister_ops(&ops); appldata_mem_exit()
155 kfree(ops.data); appldata_mem_exit()
/linux-4.4.14/drivers/net/ethernet/qlogic/qlcnic/
H A Dqlcnic_dcb.h40 struct qlcnic_dcb_ops *ops; member in struct:qlcnic_dcb
53 if (dcb && dcb->ops->get_hw_capability) qlcnic_dcb_get_hw_capability()
54 return dcb->ops->get_hw_capability(dcb); qlcnic_dcb_get_hw_capability()
61 if (dcb && dcb->ops->free) qlcnic_dcb_free()
62 dcb->ops->free(dcb); qlcnic_dcb_free()
67 if (dcb && dcb->ops->attach) qlcnic_dcb_attach()
68 return dcb->ops->attach(dcb); qlcnic_dcb_attach()
76 if (dcb && dcb->ops->query_hw_capability) qlcnic_dcb_query_hw_capability()
77 return dcb->ops->query_hw_capability(dcb, buf); qlcnic_dcb_query_hw_capability()
84 if (dcb && dcb->ops->get_info) qlcnic_dcb_get_info()
85 dcb->ops->get_info(dcb); qlcnic_dcb_get_info()
91 if (dcb && dcb->ops->query_cee_param) qlcnic_dcb_query_cee_param()
92 return dcb->ops->query_cee_param(dcb, buf, type); qlcnic_dcb_query_cee_param()
99 if (dcb && dcb->ops->get_cee_cfg) qlcnic_dcb_get_cee_cfg()
100 return dcb->ops->get_cee_cfg(dcb); qlcnic_dcb_get_cee_cfg()
107 if (dcb && dcb->ops->aen_handler) qlcnic_dcb_aen_handler()
108 dcb->ops->aen_handler(dcb, msg); qlcnic_dcb_aen_handler()
113 if (dcb && dcb->ops->init_dcbnl_ops) qlcnic_dcb_init_dcbnl_ops()
114 dcb->ops->init_dcbnl_ops(dcb); qlcnic_dcb_init_dcbnl_ops()
/linux-4.4.14/net/core/
H A Dlwtunnel.c43 int lwtunnel_encap_add_ops(const struct lwtunnel_encap_ops *ops, lwtunnel_encap_add_ops() argument
51 NULL, ops) ? 0 : -1; lwtunnel_encap_add_ops()
55 int lwtunnel_encap_del_ops(const struct lwtunnel_encap_ops *ops, lwtunnel_encap_del_ops() argument
66 ops, NULL) == ops) ? 0 : -1; lwtunnel_encap_del_ops()
78 const struct lwtunnel_encap_ops *ops; lwtunnel_build_state() local
87 ops = rcu_dereference(lwtun_encaps[encap_type]); lwtunnel_build_state()
88 if (likely(ops && ops->build_state)) lwtunnel_build_state()
89 ret = ops->build_state(dev, encap, family, cfg, lws); lwtunnel_build_state()
98 const struct lwtunnel_encap_ops *ops; lwtunnel_fill_encap() local
112 ops = rcu_dereference(lwtun_encaps[lwtstate->type]); lwtunnel_fill_encap()
113 if (likely(ops && ops->fill_encap)) lwtunnel_fill_encap()
114 ret = ops->fill_encap(skb, lwtstate); lwtunnel_fill_encap()
135 const struct lwtunnel_encap_ops *ops; lwtunnel_get_encap_size() local
146 ops = rcu_dereference(lwtun_encaps[lwtstate->type]); lwtunnel_get_encap_size()
147 if (likely(ops && ops->get_encap_size)) lwtunnel_get_encap_size()
148 ret = nla_total_size(ops->get_encap_size(lwtstate)); lwtunnel_get_encap_size()
157 const struct lwtunnel_encap_ops *ops; lwtunnel_cmp_encap() local
174 ops = rcu_dereference(lwtun_encaps[a->type]); lwtunnel_cmp_encap()
175 if (likely(ops && ops->cmp_encap)) lwtunnel_cmp_encap()
176 ret = ops->cmp_encap(a, b); lwtunnel_cmp_encap()
186 const struct lwtunnel_encap_ops *ops; lwtunnel_output() local
200 ops = rcu_dereference(lwtun_encaps[lwtstate->type]); lwtunnel_output()
201 if (likely(ops && ops->output)) lwtunnel_output()
202 ret = ops->output(net, sk, skb); lwtunnel_output()
220 const struct lwtunnel_encap_ops *ops; lwtunnel_input() local
234 ops = rcu_dereference(lwtun_encaps[lwtstate->type]); lwtunnel_input()
235 if (likely(ops && ops->input)) lwtunnel_input()
236 ret = ops->input(skb); lwtunnel_input()
H A Dfib_rules.c21 int fib_default_rule_add(struct fib_rules_ops *ops, fib_default_rule_add() argument
26 r = kzalloc(ops->rule_size, GFP_KERNEL); fib_default_rule_add()
35 r->fr_net = ops->fro_net; fib_default_rule_add()
42 list_add_tail(&r->list, &ops->rules_list); fib_default_rule_add()
47 static u32 fib_default_rule_pref(struct fib_rules_ops *ops) fib_default_rule_pref() argument
52 if (!list_empty(&ops->rules_list)) { fib_default_rule_pref()
53 pos = ops->rules_list.next; fib_default_rule_pref()
54 if (pos->next != &ops->rules_list) { fib_default_rule_pref()
65 struct fib_rules_ops *ops, struct nlmsghdr *nlh,
70 struct fib_rules_ops *ops; lookup_rules_ops() local
73 list_for_each_entry_rcu(ops, &net->rules_ops, list) { lookup_rules_ops()
74 if (ops->family == family) { lookup_rules_ops()
75 if (!try_module_get(ops->owner)) lookup_rules_ops()
76 ops = NULL; lookup_rules_ops()
78 return ops; lookup_rules_ops()
86 static void rules_ops_put(struct fib_rules_ops *ops) rules_ops_put() argument
88 if (ops) rules_ops_put()
89 module_put(ops->owner); rules_ops_put()
92 static void flush_route_cache(struct fib_rules_ops *ops) flush_route_cache() argument
94 if (ops->flush_cache) flush_route_cache()
95 ops->flush_cache(ops); flush_route_cache()
98 static int __fib_rules_register(struct fib_rules_ops *ops) __fib_rules_register() argument
104 net = ops->fro_net; __fib_rules_register()
106 if (ops->rule_size < sizeof(struct fib_rule)) __fib_rules_register()
109 if (ops->match == NULL || ops->configure == NULL || __fib_rules_register()
110 ops->compare == NULL || ops->fill == NULL || __fib_rules_register()
111 ops->action == NULL) __fib_rules_register()
116 if (ops->family == o->family) __fib_rules_register()
119 list_add_tail_rcu(&ops->list, &net->rules_ops); __fib_rules_register()
130 struct fib_rules_ops *ops; fib_rules_register() local
133 ops = kmemdup(tmpl, sizeof(*ops), GFP_KERNEL); fib_rules_register()
134 if (ops == NULL) fib_rules_register()
137 INIT_LIST_HEAD(&ops->rules_list); fib_rules_register()
138 ops->fro_net = net; fib_rules_register()
140 err = __fib_rules_register(ops); fib_rules_register()
142 kfree(ops); fib_rules_register()
143 ops = ERR_PTR(err); fib_rules_register()
146 return ops; fib_rules_register()
150 static void fib_rules_cleanup_ops(struct fib_rules_ops *ops) fib_rules_cleanup_ops() argument
154 list_for_each_entry_safe(rule, tmp, &ops->rules_list, list) { fib_rules_cleanup_ops()
156 if (ops->delete) fib_rules_cleanup_ops()
157 ops->delete(rule); fib_rules_cleanup_ops()
162 void fib_rules_unregister(struct fib_rules_ops *ops) fib_rules_unregister() argument
164 struct net *net = ops->fro_net; fib_rules_unregister()
167 list_del_rcu(&ops->list); fib_rules_unregister()
170 fib_rules_cleanup_ops(ops); fib_rules_unregister()
171 kfree_rcu(ops, rcu); fib_rules_unregister()
175 static int fib_rule_match(struct fib_rule *rule, struct fib_rules_ops *ops, fib_rule_match() argument
192 ret = ops->match(rule, fl, flags); fib_rule_match()
197 int fib_rules_lookup(struct fib_rules_ops *ops, struct flowi *fl, fib_rules_lookup() argument
205 list_for_each_entry_rcu(rule, &ops->rules_list, list) { fib_rules_lookup()
207 if (!fib_rule_match(rule, ops, fl, flags)) fib_rules_lookup()
223 err = ops->action(rule, fl, flags, arg); fib_rules_lookup()
225 if (!err && ops->suppress && ops->suppress(rule, arg)) fib_rules_lookup()
247 struct fib_rules_ops *ops) validate_rulemsg()
253 frh->src_len > (ops->addr_size * 8) || validate_rulemsg()
254 nla_len(tb[FRA_SRC]) != ops->addr_size) validate_rulemsg()
259 frh->dst_len > (ops->addr_size * 8) || validate_rulemsg()
260 nla_len(tb[FRA_DST]) != ops->addr_size) validate_rulemsg()
272 struct fib_rules_ops *ops = NULL; fib_nl_newrule() local
280 ops = lookup_rules_ops(net, frh->family); fib_nl_newrule()
281 if (ops == NULL) { fib_nl_newrule()
286 err = nlmsg_parse(nlh, sizeof(*frh), tb, FRA_MAX, ops->policy); fib_nl_newrule()
290 err = validate_rulemsg(frh, tb, ops); fib_nl_newrule()
294 rule = kzalloc(ops->rule_size, GFP_KERNEL); fib_nl_newrule()
302 : fib_default_rule_pref(ops); fib_nl_newrule()
362 list_for_each_entry(r, &ops->rules_list, list) { fib_nl_newrule()
374 err = ops->configure(rule, skb, frh, tb); fib_nl_newrule()
378 list_for_each_entry(r, &ops->rules_list, list) { fib_nl_newrule()
389 list_add_rcu(&rule->list, &ops->rules_list); fib_nl_newrule()
391 if (ops->unresolved_rules) { fib_nl_newrule()
396 list_for_each_entry(r, &ops->rules_list, list) { fib_nl_newrule()
401 if (--ops->unresolved_rules == 0) fib_nl_newrule()
408 ops->nr_goto_rules++; fib_nl_newrule()
411 ops->unresolved_rules++; fib_nl_newrule()
416 notify_rule_change(RTM_NEWRULE, rule, ops, nlh, NETLINK_CB(skb).portid); fib_nl_newrule()
417 flush_route_cache(ops); fib_nl_newrule()
418 rules_ops_put(ops); fib_nl_newrule()
424 rules_ops_put(ops); fib_nl_newrule()
432 struct fib_rules_ops *ops = NULL; fib_nl_delrule() local
440 ops = lookup_rules_ops(net, frh->family); fib_nl_delrule()
441 if (ops == NULL) { fib_nl_delrule()
446 err = nlmsg_parse(nlh, sizeof(*frh), tb, FRA_MAX, ops->policy); fib_nl_delrule()
450 err = validate_rulemsg(frh, tb, ops); fib_nl_delrule()
454 list_for_each_entry(rule, &ops->rules_list, list) { fib_nl_delrule()
486 if (!ops->compare(rule, frh, tb)) fib_nl_delrule()
494 if (ops->delete) { fib_nl_delrule()
495 err = ops->delete(rule); fib_nl_delrule()
506 ops->nr_goto_rules--; fib_nl_delrule()
508 ops->unresolved_rules--; fib_nl_delrule()
517 if (ops->nr_goto_rules > 0) { fib_nl_delrule()
518 list_for_each_entry(tmp, &ops->rules_list, list) { fib_nl_delrule()
521 ops->unresolved_rules++; fib_nl_delrule()
526 notify_rule_change(RTM_DELRULE, rule, ops, nlh, fib_nl_delrule()
529 flush_route_cache(ops); fib_nl_delrule()
530 rules_ops_put(ops); fib_nl_delrule()
536 rules_ops_put(ops); fib_nl_delrule()
540 static inline size_t fib_rule_nlmsg_size(struct fib_rules_ops *ops, fib_rule_nlmsg_size() argument
554 if (ops->nlmsg_payload) fib_rule_nlmsg_size()
555 payload += ops->nlmsg_payload(rule); fib_rule_nlmsg_size()
562 struct fib_rules_ops *ops) fib_nl_fill_rule()
572 frh->family = ops->family; fib_nl_fill_rule()
618 if (ops->fill(rule, skb, frh) < 0) fib_nl_fill_rule()
630 struct fib_rules_ops *ops) dump_rules()
637 list_for_each_entry_rcu(rule, &ops->rules_list, list) { dump_rules()
643 NLM_F_MULTI, ops); dump_rules()
651 rules_ops_put(ops); dump_rules()
659 struct fib_rules_ops *ops; fib_nl_dumprule() local
665 ops = lookup_rules_ops(net, family); fib_nl_dumprule()
666 if (ops == NULL) fib_nl_dumprule()
669 dump_rules(skb, cb, ops); fib_nl_dumprule()
675 list_for_each_entry_rcu(ops, &net->rules_ops, list) { fib_nl_dumprule()
676 if (idx < cb->args[0] || !try_module_get(ops->owner)) fib_nl_dumprule()
679 if (dump_rules(skb, cb, ops) < 0) fib_nl_dumprule()
693 struct fib_rules_ops *ops, struct nlmsghdr *nlh, notify_rule_change()
700 net = ops->fro_net; notify_rule_change()
701 skb = nlmsg_new(fib_rule_nlmsg_size(ops, rule), GFP_KERNEL); notify_rule_change()
705 err = fib_nl_fill_rule(skb, rule, pid, nlh->nlmsg_seq, event, 0, ops); notify_rule_change()
713 rtnl_notify(skb, net, pid, ops->nlgroup, nlh, GFP_KERNEL); notify_rule_change()
717 rtnl_set_sk_err(net, ops->nlgroup, err); notify_rule_change()
752 struct fib_rules_ops *ops; fib_rules_event() local
758 list_for_each_entry(ops, &net->rules_ops, list) fib_rules_event()
759 attach_rules(&ops->rules_list, dev); fib_rules_event()
763 list_for_each_entry(ops, &net->rules_ops, list) { fib_rules_event()
764 detach_rules(&ops->rules_list, dev); fib_rules_event()
765 attach_rules(&ops->rules_list, dev); fib_rules_event()
770 list_for_each_entry(ops, &net->rules_ops, list) fib_rules_event()
771 detach_rules(&ops->rules_list, dev); fib_rules_event()
246 validate_rulemsg(struct fib_rule_hdr *frh, struct nlattr **tb, struct fib_rules_ops *ops) validate_rulemsg() argument
560 fib_nl_fill_rule(struct sk_buff *skb, struct fib_rule *rule, u32 pid, u32 seq, int type, int flags, struct fib_rules_ops *ops) fib_nl_fill_rule() argument
629 dump_rules(struct sk_buff *skb, struct netlink_callback *cb, struct fib_rules_ops *ops) dump_rules() argument
692 notify_rule_change(int event, struct fib_rule *rule, struct fib_rules_ops *ops, struct nlmsghdr *nlh, u32 pid) notify_rule_change() argument
H A Dnet_namespace.c93 static int ops_init(const struct pernet_operations *ops, struct net *net) ops_init() argument
98 if (ops->id && ops->size) { ops_init()
99 data = kzalloc(ops->size, GFP_KERNEL); ops_init()
103 err = net_assign_generic(net, *ops->id, data); ops_init()
108 if (ops->init) ops_init()
109 err = ops->init(net); ops_init()
120 static void ops_free(const struct pernet_operations *ops, struct net *net) ops_free() argument
122 if (ops->id && ops->size) { ops_free()
123 int id = *ops->id; ops_free()
128 static void ops_exit_list(const struct pernet_operations *ops, ops_exit_list() argument
132 if (ops->exit) { ops_exit_list()
134 ops->exit(net); ops_exit_list()
136 if (ops->exit_batch) ops_exit_list()
137 ops->exit_batch(net_exit_list); ops_exit_list()
140 static void ops_free_list(const struct pernet_operations *ops, ops_free_list() argument
144 if (ops->size && ops->id) { ops_free_list()
146 ops_free(ops, net); ops_free_list()
275 const struct pernet_operations *ops, *saved_ops; setup_net() local
286 list_for_each_entry(ops, &pernet_list, list) { setup_net()
287 error = ops_init(ops, net); setup_net()
299 saved_ops = ops; setup_net()
300 list_for_each_entry_continue_reverse(ops, &pernet_list, list) setup_net()
301 ops_exit_list(ops, &net_exit_list); setup_net()
303 ops = saved_ops; setup_net()
304 list_for_each_entry_continue_reverse(ops, &pernet_list, list) setup_net()
305 ops_free_list(ops, &net_exit_list); setup_net()
387 const struct pernet_operations *ops; cleanup_net() local
430 list_for_each_entry_reverse(ops, &pernet_list, list)
431 ops_exit_list(ops, &net_exit_list);
434 list_for_each_entry_reverse(ops, &pernet_list, list)
435 ops_free_list(ops, &net_exit_list);
477 if (ns->ops == &netns_operations) get_net_ns_by_fd()
519 net->ns.ops = &netns_operations; net_ns_net_init()
772 struct pernet_operations *ops) __register_pernet_operations()
778 list_add_tail(&ops->list, list); __register_pernet_operations()
779 if (ops->init || (ops->id && ops->size)) { for_each_net()
781 error = ops_init(ops, net); for_each_net()
791 list_del(&ops->list);
792 ops_exit_list(ops, &net_exit_list);
793 ops_free_list(ops, &net_exit_list);
797 static void __unregister_pernet_operations(struct pernet_operations *ops) __unregister_pernet_operations() argument
802 list_del(&ops->list); __unregister_pernet_operations()
805 ops_exit_list(ops, &net_exit_list); __unregister_pernet_operations()
806 ops_free_list(ops, &net_exit_list); __unregister_pernet_operations()
812 struct pernet_operations *ops) __register_pernet_operations()
814 return ops_init(ops, &init_net); __register_pernet_operations()
817 static void __unregister_pernet_operations(struct pernet_operations *ops) __unregister_pernet_operations() argument
821 ops_exit_list(ops, &net_exit_list); __unregister_pernet_operations()
822 ops_free_list(ops, &net_exit_list); __unregister_pernet_operations()
830 struct pernet_operations *ops) register_pernet_operations()
834 if (ops->id) { register_pernet_operations()
836 error = ida_get_new_above(&net_generic_ids, 1, ops->id); register_pernet_operations()
844 max_gen_ptrs = max_t(unsigned int, max_gen_ptrs, *ops->id); register_pernet_operations()
846 error = __register_pernet_operations(list, ops); register_pernet_operations()
849 if (ops->id) register_pernet_operations()
850 ida_remove(&net_generic_ids, *ops->id); register_pernet_operations()
856 static void unregister_pernet_operations(struct pernet_operations *ops) unregister_pernet_operations() argument
859 __unregister_pernet_operations(ops); unregister_pernet_operations()
861 if (ops->id) unregister_pernet_operations()
862 ida_remove(&net_generic_ids, *ops->id); unregister_pernet_operations()
867 * @ops: pernet operations structure for the subsystem
884 int register_pernet_subsys(struct pernet_operations *ops) register_pernet_subsys() argument
888 error = register_pernet_operations(first_device, ops); register_pernet_subsys()
896 * @ops: pernet operations structure to manipulate
903 void unregister_pernet_subsys(struct pernet_operations *ops) unregister_pernet_subsys() argument
906 unregister_pernet_operations(ops); unregister_pernet_subsys()
913 * @ops: pernet operations structure for the subsystem
930 int register_pernet_device(struct pernet_operations *ops) register_pernet_device() argument
934 error = register_pernet_operations(&pernet_list, ops); register_pernet_device()
936 first_device = &ops->list; register_pernet_device()
944 * @ops: pernet operations structure to manipulate
951 void unregister_pernet_device(struct pernet_operations *ops) unregister_pernet_device() argument
954 if (&ops->list == first_device) unregister_pernet_device()
956 unregister_pernet_operations(ops); unregister_pernet_device()
771 __register_pernet_operations(struct list_head *list, struct pernet_operations *ops) __register_pernet_operations() argument
811 __register_pernet_operations(struct list_head *list, struct pernet_operations *ops) __register_pernet_operations() argument
829 register_pernet_operations(struct list_head *list, struct pernet_operations *ops) register_pernet_operations() argument
H A Dethtool.c196 const struct ethtool_ops *ops = dev->ethtool_ops; __ethtool_get_sset_count() local
207 if (ops->get_sset_count && ops->get_strings) __ethtool_get_sset_count()
208 return ops->get_sset_count(dev, sset); __ethtool_get_sset_count()
216 const struct ethtool_ops *ops = dev->ethtool_ops; __ethtool_get_strings() local
227 /* ops->get_strings is valid because checked earlier */ __ethtool_get_strings()
228 ops->get_strings(dev, stringset, data); __ethtool_get_strings()
233 /* feature masks of legacy discrete ethtool ops */ ethtool_get_feature_mask()
399 const struct ethtool_ops *ops = dev->ethtool_ops; ethtool_get_drvinfo() local
403 if (ops->get_drvinfo) { ethtool_get_drvinfo()
404 ops->get_drvinfo(dev, &info); ethtool_get_drvinfo()
418 if (ops->get_sset_count) { ethtool_get_drvinfo()
421 rc = ops->get_sset_count(dev, ETH_SS_TEST); ethtool_get_drvinfo()
424 rc = ops->get_sset_count(dev, ETH_SS_STATS); ethtool_get_drvinfo()
427 rc = ops->get_sset_count(dev, ETH_SS_PRIV_FLAGS); ethtool_get_drvinfo()
431 if (ops->get_regs_len) ethtool_get_drvinfo()
432 info.regdump_len = ops->get_regs_len(dev); ethtool_get_drvinfo()
433 if (ops->get_eeprom_len) ethtool_get_drvinfo()
434 info.eedump_len = ops->get_eeprom_len(dev); ethtool_get_drvinfo()
534 const struct ethtool_ops *ops = dev->ethtool_ops; ethtool_get_rxnfc() local
538 if (!ops->get_rxnfc) ethtool_get_rxnfc()
562 ret = ops->get_rxnfc(dev, &info, rule_buf); ethtool_get_rxnfc()
665 const struct ethtool_ops *ops = dev->ethtool_ops; ethtool_set_rxfh_indir() local
669 if (!ops->get_rxfh_indir_size || !ops->set_rxfh || ethtool_set_rxfh_indir()
670 !ops->get_rxnfc) ethtool_set_rxfh_indir()
673 dev_size = ops->get_rxfh_indir_size(dev); ethtool_set_rxfh_indir()
690 ret = ops->get_rxnfc(dev, &rx_rings, NULL); ethtool_set_rxfh_indir()
706 ret = ops->set_rxfh(dev, indir, NULL, ETH_RSS_HASH_NO_CHANGE); ethtool_set_rxfh_indir()
717 const struct ethtool_ops *ops = dev->ethtool_ops; ethtool_get_rxfh() local
728 if (!ops->get_rxfh) ethtool_get_rxfh()
731 if (ops->get_rxfh_indir_size) ethtool_get_rxfh()
732 dev_indir_size = ops->get_rxfh_indir_size(dev); ethtool_get_rxfh()
733 if (ops->get_rxfh_key_size) ethtool_get_rxfh()
734 dev_key_size = ops->get_rxfh_key_size(dev); ethtool_get_rxfh()
789 const struct ethtool_ops *ops = dev->ethtool_ops; ethtool_set_rxfh() local
798 if (!ops->get_rxnfc || !ops->set_rxfh) ethtool_set_rxfh()
801 if (ops->get_rxfh_indir_size) ethtool_set_rxfh()
802 dev_indir_size = ops->get_rxfh_indir_size(dev); ethtool_set_rxfh()
803 if (ops->get_rxfh_key_size) ethtool_set_rxfh()
804 dev_key_size = ops->get_rxfh_key_size(dev); ethtool_set_rxfh()
833 ret = ops->get_rxnfc(dev, &rx_rings, NULL); ethtool_set_rxfh()
865 ret = ops->set_rxfh(dev, indir, hkey, rxfh.hfunc); ethtool_set_rxfh()
875 const struct ethtool_ops *ops = dev->ethtool_ops; ethtool_get_regs() local
879 if (!ops->get_regs || !ops->get_regs_len) ethtool_get_regs()
885 reglen = ops->get_regs_len(dev); ethtool_get_regs()
893 ops->get_regs(dev, &regs, regbuf); ethtool_get_regs()
1064 const struct ethtool_ops *ops = dev->ethtool_ops; ethtool_get_eeprom() local
1066 if (!ops->get_eeprom || !ops->get_eeprom_len || ethtool_get_eeprom()
1067 !ops->get_eeprom_len(dev)) ethtool_get_eeprom()
1070 return ethtool_get_any_eeprom(dev, useraddr, ops->get_eeprom, ethtool_get_eeprom()
1071 ops->get_eeprom_len(dev)); ethtool_get_eeprom()
1077 const struct ethtool_ops *ops = dev->ethtool_ops; ethtool_set_eeprom() local
1083 if (!ops->set_eeprom || !ops->get_eeprom_len || ethtool_set_eeprom()
1084 !ops->get_eeprom_len(dev)) ethtool_set_eeprom()
1095 if (eeprom.offset + eeprom.len > ops->get_eeprom_len(dev)) ethtool_set_eeprom()
1110 ret = ops->set_eeprom(dev, &eeprom, data); ethtool_set_eeprom()
1237 const struct ethtool_ops *ops = dev->ethtool_ops; ethtool_self_test() local
1241 if (!ops->self_test || !ops->get_sset_count) ethtool_self_test()
1244 test_len = ops->get_sset_count(dev, ETH_SS_TEST); ethtool_self_test()
1257 ops->self_test(dev, &test, data); ethtool_self_test()
1310 const struct ethtool_ops *ops = dev->ethtool_ops; ethtool_phys_id() local
1313 if (!ops->set_phys_id) ethtool_phys_id()
1322 rc = ops->set_phys_id(dev, ETHTOOL_ID_ACTIVE); ethtool_phys_id()
1347 rc = ops->set_phys_id(dev, ethtool_phys_id()
1362 (void) ops->set_phys_id(dev, ETHTOOL_ID_INACTIVE); ethtool_phys_id()
1369 const struct ethtool_ops *ops = dev->ethtool_ops; ethtool_get_stats() local
1373 if (!ops->get_ethtool_stats || !ops->get_sset_count) ethtool_get_stats()
1376 n_stats = ops->get_sset_count(dev, ETH_SS_STATS); ethtool_get_stats()
1389 ops->get_ethtool_stats(dev, &stats, data); ethtool_get_stats()
1502 const struct ethtool_ops *ops = dev->ethtool_ops; ethtool_get_dump_flag() local
1504 if (!ops->get_dump_flag) ethtool_get_dump_flag()
1510 ret = ops->get_dump_flag(dev, &dump); ethtool_get_dump_flag()
1525 const struct ethtool_ops *ops = dev->ethtool_ops; ethtool_get_dump_data() local
1528 if (!ops->get_dump_data || !ops->get_dump_flag) ethtool_get_dump_data()
1536 ret = ops->get_dump_flag(dev, &tmp); ethtool_get_dump_data()
1556 ret = ops->get_dump_data(dev, &dump, data); ethtool_get_dump_data()
1586 const struct ethtool_ops *ops = dev->ethtool_ops; ethtool_get_ts_info() local
1594 } else if (ops->get_ts_info) { ethtool_get_ts_info()
1595 err = ops->get_ts_info(dev, &info); ethtool_get_ts_info()
1615 const struct ethtool_ops *ops = dev->ethtool_ops; __ethtool_get_module_info() local
1621 if (ops->get_module_info) __ethtool_get_module_info()
1622 return ops->get_module_info(dev, modinfo); __ethtool_get_module_info()
1649 const struct ethtool_ops *ops = dev->ethtool_ops; __ethtool_get_module_eeprom() local
1655 if (ops->get_module_eeprom) __ethtool_get_module_eeprom()
1656 return ops->get_module_eeprom(dev, ee, data); __ethtool_get_module_eeprom()
1696 const struct ethtool_ops *ops = dev->ethtool_ops; ethtool_get_tunable() local
1699 if (!ops->get_tunable) ethtool_get_tunable()
1709 ret = ops->get_tunable(dev, &tuna, data); ethtool_get_tunable()
1727 const struct ethtool_ops *ops = dev->ethtool_ops; ethtool_set_tunable() local
1730 if (!ops->set_tunable) ethtool_set_tunable()
1744 ret = ops->set_tunable(dev, &tuna, data); ethtool_set_tunable()
H A Drtnetlink.c281 const struct rtnl_link_ops *ops; rtnl_link_ops_get() local
283 list_for_each_entry(ops, &link_ops, list) { rtnl_link_ops_get()
284 if (!strcmp(ops->kind, kind)) rtnl_link_ops_get()
285 return ops; rtnl_link_ops_get()
292 * @ops: struct rtnl_link_ops * to register
300 int __rtnl_link_register(struct rtnl_link_ops *ops) __rtnl_link_register() argument
302 if (rtnl_link_ops_get(ops->kind)) __rtnl_link_register()
305 /* The check for setup is here because if ops __rtnl_link_register()
307 * to use the ops for creating device. So do not __rtnl_link_register()
310 if (ops->setup && !ops->dellink) __rtnl_link_register()
311 ops->dellink = unregister_netdevice_queue; __rtnl_link_register()
313 list_add_tail(&ops->list, &link_ops); __rtnl_link_register()
320 * @ops: struct rtnl_link_ops * to register
324 int rtnl_link_register(struct rtnl_link_ops *ops) rtnl_link_register() argument
329 err = __rtnl_link_register(ops); rtnl_link_register()
335 static void __rtnl_kill_links(struct net *net, struct rtnl_link_ops *ops) __rtnl_kill_links() argument
341 if (dev->rtnl_link_ops == ops) for_each_netdev()
342 ops->dellink(dev, &list_kill); for_each_netdev()
349 * @ops: struct rtnl_link_ops * to unregister
353 void __rtnl_link_unregister(struct rtnl_link_ops *ops) __rtnl_link_unregister() argument
358 __rtnl_kill_links(net, ops); for_each_net()
360 list_del(&ops->list);
394 * @ops: struct rtnl_link_ops * to unregister
396 void rtnl_link_unregister(struct rtnl_link_ops *ops) rtnl_link_unregister() argument
401 __rtnl_link_unregister(ops); rtnl_link_unregister()
410 const struct rtnl_link_ops *ops; rtnl_link_get_slave_info_data_size() local
415 ops = master_dev->rtnl_link_ops; rtnl_link_get_slave_info_data_size()
416 if (!ops || !ops->get_slave_size) rtnl_link_get_slave_info_data_size()
420 ops->get_slave_size(master_dev, dev); rtnl_link_get_slave_info_data_size()
425 const struct rtnl_link_ops *ops = dev->rtnl_link_ops; rtnl_link_get_size() local
428 if (!ops) rtnl_link_get_size()
432 nla_total_size(strlen(ops->kind) + 1); /* IFLA_INFO_KIND */ rtnl_link_get_size()
434 if (ops->get_size) rtnl_link_get_size()
437 ops->get_size(dev); rtnl_link_get_size()
439 if (ops->get_xstats_size) rtnl_link_get_size()
441 size += nla_total_size(ops->get_xstats_size(dev)); rtnl_link_get_size()
452 const struct rtnl_af_ops *ops; rtnl_af_lookup() local
454 list_for_each_entry(ops, &rtnl_af_ops, list) { rtnl_af_lookup()
455 if (ops->family == family) rtnl_af_lookup()
456 return ops; rtnl_af_lookup()
464 * @ops: struct rtnl_af_ops * to register
468 void rtnl_af_register(struct rtnl_af_ops *ops) rtnl_af_register() argument
471 list_add_tail(&ops->list, &rtnl_af_ops); rtnl_af_register()
478 * @ops: struct rtnl_af_ops * to unregister
482 void __rtnl_af_unregister(struct rtnl_af_ops *ops) __rtnl_af_unregister() argument
484 list_del(&ops->list); __rtnl_af_unregister()
490 * @ops: struct rtnl_af_ops * to unregister
492 void rtnl_af_unregister(struct rtnl_af_ops *ops) rtnl_af_unregister() argument
495 __rtnl_af_unregister(ops); rtnl_af_unregister()
534 const struct rtnl_link_ops *ops; rtnl_link_slave_info_fill() local
541 ops = master_dev->rtnl_link_ops; rtnl_link_slave_info_fill()
542 if (!ops) rtnl_link_slave_info_fill()
544 if (nla_put_string(skb, IFLA_INFO_SLAVE_KIND, ops->kind) < 0) rtnl_link_slave_info_fill()
546 if (ops->fill_slave_info) { rtnl_link_slave_info_fill()
550 err = ops->fill_slave_info(skb, master_dev, dev); rtnl_link_slave_info_fill()
565 const struct rtnl_link_ops *ops = dev->rtnl_link_ops; rtnl_link_info_fill() local
569 if (!ops) rtnl_link_info_fill()
571 if (nla_put_string(skb, IFLA_INFO_KIND, ops->kind) < 0) rtnl_link_info_fill()
573 if (ops->fill_xstats) { rtnl_link_info_fill()
574 err = ops->fill_xstats(skb, dev); rtnl_link_info_fill()
578 if (ops->fill_info) { rtnl_link_info_fill()
582 err = ops->fill_info(skb, dev); rtnl_link_info_fill()
1235 nla_put_string(skb, IFLA_QDISC, dev->qdisc->ops->id)) || rtnl_fill_ifinfo()
1541 const struct net_device_ops *ops = dev->netdev_ops; do_setvfinfo() local
1548 if (ops->ndo_set_vf_mac) do_setvfinfo()
1549 err = ops->ndo_set_vf_mac(dev, ivm->vf, do_setvfinfo()
1559 if (ops->ndo_set_vf_vlan) do_setvfinfo()
1560 err = ops->ndo_set_vf_vlan(dev, ivv->vf, ivv->vlan, do_setvfinfo()
1571 if (ops->ndo_get_vf_config) do_setvfinfo()
1572 err = ops->ndo_get_vf_config(dev, ivt->vf, &ivf); do_setvfinfo()
1577 if (ops->ndo_set_vf_rate) do_setvfinfo()
1578 err = ops->ndo_set_vf_rate(dev, ivt->vf, do_setvfinfo()
1589 if (ops->ndo_set_vf_rate) do_setvfinfo()
1590 err = ops->ndo_set_vf_rate(dev, ivt->vf, do_setvfinfo()
1601 if (ops->ndo_set_vf_spoofchk) do_setvfinfo()
1602 err = ops->ndo_set_vf_spoofchk(dev, ivs->vf, do_setvfinfo()
1612 if (ops->ndo_set_vf_link_state) do_setvfinfo()
1613 err = ops->ndo_set_vf_link_state(dev, ivl->vf, do_setvfinfo()
1624 if (ops->ndo_set_vf_rss_query_en) do_setvfinfo()
1625 err = ops->ndo_set_vf_rss_query_en(dev, ivrssq_en->vf, do_setvfinfo()
1635 if (ops->ndo_set_vf_trust) do_setvfinfo()
1636 err = ops->ndo_set_vf_trust(dev, ivt->vf, ivt->setting); do_setvfinfo()
1647 const struct net_device_ops *ops; do_set_master() local
1653 ops = upper_dev->netdev_ops; do_set_master()
1654 if (ops->ndo_del_slave) { do_set_master()
1655 err = ops->ndo_del_slave(upper_dev, dev); do_set_master()
1667 ops = upper_dev->netdev_ops; do_set_master()
1668 if (ops->ndo_add_slave) { do_set_master()
1669 err = ops->ndo_add_slave(upper_dev, dev); do_set_master()
1686 const struct net_device_ops *ops = dev->netdev_ops; do_setlink() local
1711 if (!ops->ndo_set_config) { do_setlink()
1729 err = ops->ndo_set_config(dev, &k_map); do_setlink()
1865 if (!ops->ndo_set_vf_port)
1883 err = ops->ndo_set_vf_port(dev, vf, port); nla_for_each_nested()
1900 if (ops->ndo_set_vf_port)
1901 err = ops->ndo_set_vf_port(dev, PORT_SELF_VF, port);
1999 const struct rtnl_link_ops *ops; for_each_netdev() local
2002 ops = dev->rtnl_link_ops; for_each_netdev()
2003 if (!ops || !ops->dellink) for_each_netdev()
2013 const struct rtnl_link_ops *ops; for_each_netdev_safe() local
2015 ops = dev->rtnl_link_ops; for_each_netdev_safe()
2016 ops->dellink(dev, &list_kill); for_each_netdev_safe()
2026 const struct rtnl_link_ops *ops; rtnl_delete_link() local
2029 ops = dev->rtnl_link_ops; rtnl_delete_link()
2030 if (!ops || !ops->dellink) rtnl_delete_link()
2033 ops->dellink(dev, &list_kill); rtnl_delete_link()
2093 const struct rtnl_link_ops *ops, struct nlattr *tb[]) rtnl_create_link()
2102 else if (ops->get_num_tx_queues) rtnl_create_link()
2103 num_tx_queues = ops->get_num_tx_queues(); rtnl_create_link()
2107 else if (ops->get_num_rx_queues) rtnl_create_link()
2108 num_rx_queues = ops->get_num_rx_queues(); rtnl_create_link()
2111 dev = alloc_netdev_mqs(ops->priv_size, ifname, name_assign_type, rtnl_create_link()
2112 ops->setup, num_tx_queues, num_rx_queues); rtnl_create_link()
2117 dev->rtnl_link_ops = ops; rtnl_create_link()
2168 const struct rtnl_link_ops *ops; rtnl_newlink() local
2222 ops = rtnl_link_ops_get(kind); rtnl_newlink()
2225 ops = NULL; rtnl_newlink()
2229 struct nlattr *attr[ops ? ops->maxtype + 1 : 1]; rtnl_newlink()
2235 if (ops) { rtnl_newlink()
2236 if (ops->maxtype && linkinfo[IFLA_INFO_DATA]) { rtnl_newlink()
2237 err = nla_parse_nested(attr, ops->maxtype, rtnl_newlink()
2239 ops->policy); rtnl_newlink()
2244 if (ops->validate) { rtnl_newlink()
2245 err = ops->validate(tb, data); rtnl_newlink()
2278 if (!ops || ops != dev->rtnl_link_ops || rtnl_newlink()
2279 !ops->changelink) rtnl_newlink()
2282 err = ops->changelink(dev, tb, data); rtnl_newlink()
2313 if (!ops) { rtnl_newlink()
2319 ops = rtnl_link_ops_get(kind); rtnl_newlink()
2320 if (ops) rtnl_newlink()
2327 if (!ops->setup) rtnl_newlink()
2331 snprintf(ifname, IFNAMSIZ, "%s%%d", ops->kind); rtnl_newlink()
2357 name_assign_type, ops, tb); rtnl_newlink()
2365 if (ops->newlink) { rtnl_newlink()
2366 err = ops->newlink(link_net ? : net, dev, tb, data); rtnl_newlink()
2398 if (ops->newlink) { rtnl_newlink()
2401 ops->dellink(dev, &list_kill); rtnl_newlink()
2731 const struct net_device_ops *ops = br_dev->netdev_ops; rtnl_fdb_add() local
2733 err = ops->ndo_fdb_add(ndm, tb, dev, addr, vid, rtnl_fdb_add()
2833 const struct net_device_ops *ops = br_dev->netdev_ops; rtnl_fdb_del() local
2835 if (ops->ndo_fdb_del) rtnl_fdb_del()
2836 err = ops->ndo_fdb_del(ndm, tb, dev, addr, vid); rtnl_fdb_del()
2922 const struct net_device_ops *ops = NULL; rtnl_fdb_dump() local
2943 ops = br_dev->netdev_ops; rtnl_fdb_dump()
2965 cops = ops; for_each_netdev()
3119 const struct net_device_ops *ops = dev->netdev_ops; for_each_netdev_rcu() local
3133 if (ops->ndo_bridge_getlink) { for_each_netdev_rcu()
3135 err = ops->ndo_bridge_getlink(skb, portid, for_each_netdev_rcu()
2091 rtnl_create_link(struct net *net, const char *ifname, unsigned char name_assign_type, const struct rtnl_link_ops *ops, struct nlattr *tb[]) rtnl_create_link() argument
/linux-4.4.14/include/linux/
H A Dns_common.h8 const struct proc_ns_operations *ops; member in struct:ns_common
H A Dsyscore_ops.h21 extern void register_syscore_ops(struct syscore_ops *ops);
22 extern void unregister_syscore_ops(struct syscore_ops *ops);
H A Dntb.h152 static inline int ntb_client_ops_is_valid(const struct ntb_client_ops *ops) ntb_client_ops_is_valid() argument
156 ops->probe && ntb_client_ops_is_valid()
157 ops->remove && ntb_client_ops_is_valid()
171 static inline int ntb_ctx_ops_is_valid(const struct ntb_ctx_ops *ops) ntb_ctx_ops_is_valid() argument
175 /* ops->link_event && */ ntb_ctx_ops_is_valid()
176 /* ops->db_event && */ ntb_ctx_ops_is_valid()
264 static inline int ntb_dev_ops_is_valid(const struct ntb_dev_ops *ops) ntb_dev_ops_is_valid() argument
268 ops->mw_count && ntb_dev_ops_is_valid()
269 ops->mw_get_range && ntb_dev_ops_is_valid()
270 ops->mw_set_trans && ntb_dev_ops_is_valid()
271 /* ops->mw_clear_trans && */ ntb_dev_ops_is_valid()
272 ops->link_is_up && ntb_dev_ops_is_valid()
273 ops->link_enable && ntb_dev_ops_is_valid()
274 ops->link_disable && ntb_dev_ops_is_valid()
275 /* ops->db_is_unsafe && */ ntb_dev_ops_is_valid()
276 ops->db_valid_mask && ntb_dev_ops_is_valid()
279 (!ops->db_vector_count == !ops->db_vector_mask) && ntb_dev_ops_is_valid()
281 ops->db_read && ntb_dev_ops_is_valid()
282 /* ops->db_set && */ ntb_dev_ops_is_valid()
283 ops->db_clear && ntb_dev_ops_is_valid()
284 /* ops->db_read_mask && */ ntb_dev_ops_is_valid()
285 ops->db_set_mask && ntb_dev_ops_is_valid()
286 ops->db_clear_mask && ntb_dev_ops_is_valid()
287 ops->peer_db_addr && ntb_dev_ops_is_valid()
288 /* ops->peer_db_read && */ ntb_dev_ops_is_valid()
289 ops->peer_db_set && ntb_dev_ops_is_valid()
290 /* ops->peer_db_clear && */ ntb_dev_ops_is_valid()
291 /* ops->peer_db_read_mask && */ ntb_dev_ops_is_valid()
292 /* ops->peer_db_set_mask && */ ntb_dev_ops_is_valid()
293 /* ops->peer_db_clear_mask && */ ntb_dev_ops_is_valid()
294 /* ops->spad_is_unsafe && */ ntb_dev_ops_is_valid()
295 ops->spad_count && ntb_dev_ops_is_valid()
296 ops->spad_read && ntb_dev_ops_is_valid()
297 ops->spad_write && ntb_dev_ops_is_valid()
298 ops->peer_spad_addr && ntb_dev_ops_is_valid()
299 /* ops->peer_spad_read && */ ntb_dev_ops_is_valid()
300 ops->peer_spad_write && ntb_dev_ops_is_valid()
307 * @ops: See &ntb_client_ops.
311 const struct ntb_client_ops ops; member in struct:ntb_client
321 * @ops: See &ntb_dev_ops.
329 const struct ntb_dev_ops *ops; member in struct:ntb_dev
453 return ntb->ops->mw_count(ntb); ntb_mw_count()
477 return ntb->ops->mw_get_range(ntb, idx, base, size, ntb_mw_get_range()
498 return ntb->ops->mw_set_trans(ntb, idx, addr, size); ntb_mw_set_trans()
513 if (!ntb->ops->mw_clear_trans) ntb_mw_clear_trans()
514 return ntb->ops->mw_set_trans(ntb, idx, 0, 0); ntb_mw_clear_trans()
516 return ntb->ops->mw_clear_trans(ntb, idx); ntb_mw_clear_trans()
535 return ntb->ops->link_is_up(ntb, speed, width); ntb_link_is_up()
555 return ntb->ops->link_enable(ntb, max_speed, max_width); ntb_link_enable()
572 return ntb->ops->link_disable(ntb); ntb_link_disable()
587 if (!ntb->ops->db_is_unsafe) ntb_db_is_unsafe()
590 return ntb->ops->db_is_unsafe(ntb); ntb_db_is_unsafe()
603 return ntb->ops->db_valid_mask(ntb); ntb_db_valid_mask()
616 if (!ntb->ops->db_vector_count) ntb_db_vector_count()
619 return ntb->ops->db_vector_count(ntb); ntb_db_vector_count()
633 if (!ntb->ops->db_vector_mask) ntb_db_vector_mask()
636 return ntb->ops->db_vector_mask(ntb, vector); ntb_db_vector_mask()
649 return ntb->ops->db_read(ntb); ntb_db_read()
666 if (!ntb->ops->db_set) ntb_db_set()
669 return ntb->ops->db_set(ntb, db_bits); ntb_db_set()
684 return ntb->ops->db_clear(ntb, db_bits); ntb_db_clear()
699 if (!ntb->ops->db_read_mask) ntb_db_read_mask()
702 return ntb->ops->db_read_mask(ntb); ntb_db_read_mask()
718 return ntb->ops->db_set_mask(ntb, db_bits); ntb_db_set_mask()
737 return ntb->ops->db_clear_mask(ntb, db_bits); ntb_db_clear_mask()
760 return ntb->ops->peer_db_addr(ntb, db_addr, db_size); ntb_peer_db_addr()
775 if (!ntb->ops->peer_db_read) ntb_peer_db_read()
778 return ntb->ops->peer_db_read(ntb); ntb_peer_db_read()
793 return ntb->ops->peer_db_set(ntb, db_bits); ntb_peer_db_set()
810 if (!ntb->ops->db_clear) ntb_peer_db_clear()
813 return ntb->ops->peer_db_clear(ntb, db_bits); ntb_peer_db_clear()
828 if (!ntb->ops->db_read_mask) ntb_peer_db_read_mask()
831 return ntb->ops->peer_db_read_mask(ntb); ntb_peer_db_read_mask()
849 if (!ntb->ops->db_set_mask) ntb_peer_db_set_mask()
852 return ntb->ops->peer_db_set_mask(ntb, db_bits); ntb_peer_db_set_mask()
871 if (!ntb->ops->db_clear_mask) ntb_peer_db_clear_mask()
874 return ntb->ops->peer_db_clear_mask(ntb, db_bits); ntb_peer_db_clear_mask()
889 if (!ntb->ops->spad_is_unsafe) ntb_spad_is_unsafe()
892 return ntb->ops->spad_is_unsafe(ntb); ntb_spad_is_unsafe()
905 return ntb->ops->spad_count(ntb); ntb_spad_count()
919 return ntb->ops->spad_read(ntb, idx); ntb_spad_read()
934 return ntb->ops->spad_write(ntb, idx, val); ntb_spad_write()
951 return ntb->ops->peer_spad_addr(ntb, idx, spad_addr); ntb_peer_spad_addr()
965 return ntb->ops->peer_spad_read(ntb, idx); ntb_peer_spad_read()
980 return ntb->ops->peer_spad_write(ntb, idx, val); ntb_peer_spad_write()
H A Dseqno-fence.h34 const struct fence_ops *ops; member in struct:seqno_fence
52 if (fence->ops != &seqno_fence_ops) to_seqno_fence()
66 * @ops: the fence_ops for operations on this seqno fence
90 * However, when ops.enable_signaling is not called, it doesn't have to be
99 const struct fence_ops *ops) seqno_fence_init()
101 BUG_ON(!fence || !sync_buf || !ops); seqno_fence_init()
102 BUG_ON(!ops->wait || !ops->enable_signaling || seqno_fence_init()
103 !ops->get_driver_name || !ops->get_timeline_name); seqno_fence_init()
106 * ops is used in fence_init for get_driver_name, so needs to be seqno_fence_init()
109 fence->ops = ops; seqno_fence_init()
95 seqno_fence_init(struct seqno_fence *fence, spinlock_t *lock, struct dma_buf *sync_buf, uint32_t context, uint32_t seqno_ofs, uint32_t seqno, enum seqno_fence_condition cond, const struct fence_ops *ops) seqno_fence_init() argument
H A Dbacklight.h19 * ops pointer and no code outside the core should need to touch it.
100 /* This protects the 'ops' field. If 'ops' is NULL, the driver that
104 const struct backlight_ops *ops; member in struct:backlight_device
125 if (bd->ops && bd->ops->update_status) backlight_update_status()
126 ret = bd->ops->update_status(bd); backlight_update_status()
133 struct device *dev, void *devdata, const struct backlight_ops *ops,
137 void *devdata, const struct backlight_ops *ops,
H A Dlcd.h18 * lcd_device->ops_lock is an internal backlight lock protecting the ops
68 /* This protects the 'ops' field. If 'ops' is NULL, the driver that
73 struct lcd_ops *ops; member in struct:lcd_device
108 if (ld->ops && ld->ops->set_power) lcd_set_power()
109 ld->ops->set_power(ld, power); lcd_set_power()
114 struct device *parent, void *devdata, struct lcd_ops *ops);
117 void *devdata, struct lcd_ops *ops);
/linux-4.4.14/drivers/mtd/tests/
H A Doobtest.c71 struct mtd_oob_ops ops; write_eraseblock() local
77 ops.mode = MTD_OPS_AUTO_OOB; write_eraseblock()
78 ops.len = 0; write_eraseblock()
79 ops.retlen = 0; write_eraseblock()
80 ops.ooblen = use_len; write_eraseblock()
81 ops.oobretlen = 0; write_eraseblock()
82 ops.ooboffs = use_offset; write_eraseblock()
83 ops.datbuf = NULL; write_eraseblock()
84 ops.oobbuf = writebuf + (use_len_max * i) + use_offset; write_eraseblock()
85 err = mtd_write_oob(mtd, addr, &ops); write_eraseblock()
86 if (err || ops.oobretlen != use_len) { write_eraseblock()
180 struct mtd_oob_ops ops; verify_eraseblock() local
187 ops.mode = MTD_OPS_AUTO_OOB; verify_eraseblock()
188 ops.len = 0; verify_eraseblock()
189 ops.retlen = 0; verify_eraseblock()
190 ops.ooblen = use_len; verify_eraseblock()
191 ops.oobretlen = 0; verify_eraseblock()
192 ops.ooboffs = use_offset; verify_eraseblock()
193 ops.datbuf = NULL; verify_eraseblock()
194 ops.oobbuf = readbuf; verify_eraseblock()
195 err = mtd_read_oob(mtd, addr, &ops); verify_eraseblock()
196 if (err || ops.oobretlen != use_len) { verify_eraseblock()
221 ops.mode = MTD_OPS_AUTO_OOB; verify_eraseblock()
222 ops.len = 0; verify_eraseblock()
223 ops.retlen = 0; verify_eraseblock()
224 ops.ooblen = mtd->ecclayout->oobavail; verify_eraseblock()
225 ops.oobretlen = 0; verify_eraseblock()
226 ops.ooboffs = 0; verify_eraseblock()
227 ops.datbuf = NULL; verify_eraseblock()
228 ops.oobbuf = readbuf; verify_eraseblock()
229 err = mtd_read_oob(mtd, addr, &ops); verify_eraseblock()
230 if (err || ops.oobretlen != mtd->ecclayout->oobavail) { verify_eraseblock()
269 struct mtd_oob_ops ops; verify_eraseblock_in_one_go() local
278 ops.mode = MTD_OPS_AUTO_OOB; verify_eraseblock_in_one_go()
279 ops.len = 0; verify_eraseblock_in_one_go()
280 ops.retlen = 0; verify_eraseblock_in_one_go()
281 ops.ooblen = len; verify_eraseblock_in_one_go()
282 ops.oobretlen = 0; verify_eraseblock_in_one_go()
283 ops.ooboffs = 0; verify_eraseblock_in_one_go()
284 ops.datbuf = NULL; verify_eraseblock_in_one_go()
285 ops.oobbuf = readbuf; verify_eraseblock_in_one_go()
288 err = mtd_read_oob(mtd, addr, &ops); verify_eraseblock_in_one_go()
289 if (err || ops.oobretlen != len) { verify_eraseblock_in_one_go()
344 struct mtd_oob_ops ops; mtd_oobtest_init() local
499 ops.mode = MTD_OPS_AUTO_OOB; mtd_oobtest_init()
500 ops.len = 0; mtd_oobtest_init()
501 ops.retlen = 0; mtd_oobtest_init()
502 ops.ooblen = 1; mtd_oobtest_init()
503 ops.oobretlen = 0; mtd_oobtest_init()
504 ops.ooboffs = mtd->ecclayout->oobavail; mtd_oobtest_init()
505 ops.datbuf = NULL; mtd_oobtest_init()
506 ops.oobbuf = writebuf; mtd_oobtest_init()
509 err = mtd_write_oob(mtd, addr0, &ops); mtd_oobtest_init()
519 ops.mode = MTD_OPS_AUTO_OOB; mtd_oobtest_init()
520 ops.len = 0; mtd_oobtest_init()
521 ops.retlen = 0; mtd_oobtest_init()
522 ops.ooblen = 1; mtd_oobtest_init()
523 ops.oobretlen = 0; mtd_oobtest_init()
524 ops.ooboffs = mtd->ecclayout->oobavail; mtd_oobtest_init()
525 ops.datbuf = NULL; mtd_oobtest_init()
526 ops.oobbuf = readbuf; mtd_oobtest_init()
529 err = mtd_read_oob(mtd, addr0, &ops); mtd_oobtest_init()
543 ops.mode = MTD_OPS_AUTO_OOB; mtd_oobtest_init()
544 ops.len = 0; mtd_oobtest_init()
545 ops.retlen = 0; mtd_oobtest_init()
546 ops.ooblen = mtd->ecclayout->oobavail + 1; mtd_oobtest_init()
547 ops.oobretlen = 0; mtd_oobtest_init()
548 ops.ooboffs = 0; mtd_oobtest_init()
549 ops.datbuf = NULL; mtd_oobtest_init()
550 ops.oobbuf = writebuf; mtd_oobtest_init()
553 err = mtd_write_oob(mtd, mtd->size - mtd->writesize, &ops); mtd_oobtest_init()
563 ops.mode = MTD_OPS_AUTO_OOB; mtd_oobtest_init()
564 ops.len = 0; mtd_oobtest_init()
565 ops.retlen = 0; mtd_oobtest_init()
566 ops.ooblen = mtd->ecclayout->oobavail + 1; mtd_oobtest_init()
567 ops.oobretlen = 0; mtd_oobtest_init()
568 ops.ooboffs = 0; mtd_oobtest_init()
569 ops.datbuf = NULL; mtd_oobtest_init()
570 ops.oobbuf = readbuf; mtd_oobtest_init()
573 err = mtd_read_oob(mtd, mtd->size - mtd->writesize, &ops); mtd_oobtest_init()
587 ops.mode = MTD_OPS_AUTO_OOB; mtd_oobtest_init()
588 ops.len = 0; mtd_oobtest_init()
589 ops.retlen = 0; mtd_oobtest_init()
590 ops.ooblen = mtd->ecclayout->oobavail; mtd_oobtest_init()
591 ops.oobretlen = 0; mtd_oobtest_init()
592 ops.ooboffs = 1; mtd_oobtest_init()
593 ops.datbuf = NULL; mtd_oobtest_init()
594 ops.oobbuf = writebuf; mtd_oobtest_init()
597 err = mtd_write_oob(mtd, mtd->size - mtd->writesize, &ops); mtd_oobtest_init()
607 ops.mode = MTD_OPS_AUTO_OOB; mtd_oobtest_init()
608 ops.len = 0; mtd_oobtest_init()
609 ops.retlen = 0; mtd_oobtest_init()
610 ops.ooblen = mtd->ecclayout->oobavail; mtd_oobtest_init()
611 ops.oobretlen = 0; mtd_oobtest_init()
612 ops.ooboffs = 1; mtd_oobtest_init()
613 ops.datbuf = NULL; mtd_oobtest_init()
614 ops.oobbuf = readbuf; mtd_oobtest_init()
617 err = mtd_read_oob(mtd, mtd->size - mtd->writesize, &ops); mtd_oobtest_init()
647 ops.mode = MTD_OPS_AUTO_OOB; mtd_oobtest_init()
648 ops.len = 0; mtd_oobtest_init()
649 ops.retlen = 0; mtd_oobtest_init()
650 ops.ooblen = sz; mtd_oobtest_init()
651 ops.oobretlen = 0; mtd_oobtest_init()
652 ops.ooboffs = 0; mtd_oobtest_init()
653 ops.datbuf = NULL; mtd_oobtest_init()
654 ops.oobbuf = writebuf + pg * sz; mtd_oobtest_init()
655 err = mtd_write_oob(mtd, addr, &ops); mtd_oobtest_init()
679 ops.mode = MTD_OPS_AUTO_OOB; mtd_oobtest_init()
680 ops.len = 0; mtd_oobtest_init()
681 ops.retlen = 0; mtd_oobtest_init()
682 ops.ooblen = mtd->ecclayout->oobavail * 2; mtd_oobtest_init()
683 ops.oobretlen = 0; mtd_oobtest_init()
684 ops.ooboffs = 0; mtd_oobtest_init()
685 ops.datbuf = NULL; mtd_oobtest_init()
686 ops.oobbuf = readbuf; mtd_oobtest_init()
687 err = mtd_read_oob(mtd, addr, &ops); mtd_oobtest_init()
H A Dreadtest.c62 struct mtd_oob_ops ops; read_eraseblock_by_page() local
64 ops.mode = MTD_OPS_PLACE_OOB; read_eraseblock_by_page()
65 ops.len = 0; read_eraseblock_by_page()
66 ops.retlen = 0; read_eraseblock_by_page()
67 ops.ooblen = mtd->oobsize; read_eraseblock_by_page()
68 ops.oobretlen = 0; read_eraseblock_by_page()
69 ops.ooboffs = 0; read_eraseblock_by_page()
70 ops.datbuf = NULL; read_eraseblock_by_page()
71 ops.oobbuf = oobbuf; read_eraseblock_by_page()
72 ret = mtd_read_oob(mtd, addr, &ops); read_eraseblock_by_page()
74 ops.oobretlen != mtd->oobsize) { read_eraseblock_by_page()
/linux-4.4.14/arch/x86/oprofile/
H A Dinit.c20 extern int op_nmi_init(struct oprofile_operations *ops);
23 static int op_nmi_init(struct oprofile_operations *ops) { return -ENODEV; } op_nmi_exit() argument
29 int __init oprofile_arch_init(struct oprofile_operations *ops) oprofile_arch_init() argument
31 ops->backtrace = x86_backtrace; oprofile_arch_init()
32 return op_nmi_init(ops); oprofile_arch_init()
/linux-4.4.14/include/asm-generic/
H A Ddma-mapping-common.h16 struct dma_map_ops *ops = get_dma_ops(dev); dma_map_single_attrs() local
21 addr = ops->map_page(dev, virt_to_page(ptr), dma_map_single_attrs()
35 struct dma_map_ops *ops = get_dma_ops(dev); dma_unmap_single_attrs() local
38 if (ops->unmap_page) dma_unmap_single_attrs()
39 ops->unmap_page(dev, addr, size, dir, attrs); dma_unmap_single_attrs()
51 struct dma_map_ops *ops = get_dma_ops(dev); dma_map_sg_attrs() local
58 ents = ops->map_sg(dev, sg, nents, dir, attrs); dma_map_sg_attrs()
69 struct dma_map_ops *ops = get_dma_ops(dev);
73 if (ops->unmap_sg)
74 ops->unmap_sg(dev, sg, nents, dir, attrs);
81 struct dma_map_ops *ops = get_dma_ops(dev); dma_map_page() local
86 addr = ops->map_page(dev, page, offset, size, dir, NULL); dma_map_page()
95 struct dma_map_ops *ops = get_dma_ops(dev); dma_unmap_page() local
98 if (ops->unmap_page) dma_unmap_page()
99 ops->unmap_page(dev, addr, size, dir, NULL); dma_unmap_page()
107 struct dma_map_ops *ops = get_dma_ops(dev); dma_sync_single_for_cpu() local
110 if (ops->sync_single_for_cpu) dma_sync_single_for_cpu()
111 ops->sync_single_for_cpu(dev, addr, size, dir); dma_sync_single_for_cpu()
119 struct dma_map_ops *ops = get_dma_ops(dev); dma_sync_single_for_device() local
122 if (ops->sync_single_for_device) dma_sync_single_for_device()
123 ops->sync_single_for_device(dev, addr, size, dir); dma_sync_single_for_device()
133 const struct dma_map_ops *ops = get_dma_ops(dev); dma_sync_single_range_for_cpu() local
136 if (ops->sync_single_for_cpu) dma_sync_single_range_for_cpu()
137 ops->sync_single_for_cpu(dev, addr + offset, size, dir); dma_sync_single_range_for_cpu()
147 const struct dma_map_ops *ops = get_dma_ops(dev); dma_sync_single_range_for_device() local
150 if (ops->sync_single_for_device) dma_sync_single_range_for_device()
151 ops->sync_single_for_device(dev, addr + offset, size, dir); dma_sync_single_range_for_device()
159 struct dma_map_ops *ops = get_dma_ops(dev); dma_sync_sg_for_cpu() local
162 if (ops->sync_sg_for_cpu) dma_sync_sg_for_cpu()
163 ops->sync_sg_for_cpu(dev, sg, nelems, dir); dma_sync_sg_for_cpu()
171 struct dma_map_ops *ops = get_dma_ops(dev); dma_sync_sg_for_device() local
174 if (ops->sync_sg_for_device) dma_sync_sg_for_device()
175 ops->sync_sg_for_device(dev, sg, nelems, dir); dma_sync_sg_for_device()
214 struct dma_map_ops *ops = get_dma_ops(dev); dma_mmap_attrs() local
215 BUG_ON(!ops); dma_mmap_attrs()
216 if (ops->mmap) dma_mmap_attrs()
217 return ops->mmap(dev, vma, cpu_addr, dma_addr, size, attrs); dma_mmap_attrs()
231 struct dma_map_ops *ops = get_dma_ops(dev); dma_get_sgtable_attrs() local
232 BUG_ON(!ops); dma_get_sgtable_attrs()
233 if (ops->get_sgtable) dma_get_sgtable_attrs()
234 return ops->get_sgtable(dev, sgt, cpu_addr, dma_addr, size, dma_get_sgtable_attrs()
249 struct dma_map_ops *ops = get_dma_ops(dev); dma_alloc_attrs() local
252 BUG_ON(!ops); dma_alloc_attrs()
259 if (!ops->alloc) dma_alloc_attrs()
262 cpu_addr = ops->alloc(dev, size, dma_handle, flag, attrs); dma_alloc_attrs()
271 struct dma_map_ops *ops = get_dma_ops(dev); dma_free_attrs() local
273 BUG_ON(!ops); dma_free_attrs()
279 if (!ops->free) dma_free_attrs()
283 ops->free(dev, size, cpu_addr, dma_handle, attrs); dma_free_attrs()
333 struct dma_map_ops *ops = get_dma_ops(dev); dma_supported() local
335 if (!ops) dma_supported()
337 if (!ops->dma_supported) dma_supported()
339 return ops->dma_supported(dev, mask); dma_supported()
346 struct dma_map_ops *ops = get_dma_ops(dev); dma_set_mask() local
348 if (ops->set_dma_mask) dma_set_mask()
349 return ops->set_dma_mask(dev, mask); dma_set_mask()
/linux-4.4.14/drivers/media/v4l2-core/
H A Dvideobuf2-internal.h68 (q)->ops->op ? "" : " (nop)")
75 err = (q)->ops->op ? (q)->ops->op(args) : 0; \
84 if ((q)->ops->op) \
85 (q)->ops->op(args); \
92 (vb)->vb2_queue->ops->op ? "" : " (nop)")
99 err = (vb)->vb2_queue->ops->op ? \
100 (vb)->vb2_queue->ops->op(args) : 0; \
109 if ((vb)->vb2_queue->ops->op) \
110 (vb)->vb2_queue->ops->op(args); \
131 ((q)->ops->op ? (q)->ops->op(args) : 0)
135 if ((q)->ops->op) \
136 (q)->ops->op(args); \
140 ((vb)->vb2_queue->ops->op ? (vb)->vb2_queue->ops->op(args) : 0)
144 if ((vb)->vb2_queue->ops->op) \
145 (vb)->vb2_queue->ops->op(args); \
H A Dv4l2-dev.c502 #define SET_VALID_IOCTL(ops, cmd, op) \
503 if (ops->op) \
522 const struct v4l2_ioctl_ops *ops = vdev->ioctl_ops; determine_valid_ioctls() local
534 SET_VALID_IOCTL(ops, VIDIOC_QUERYCAP, vidioc_querycap); determine_valid_ioctls()
542 if (vdev->ctrl_handler || ops->vidioc_queryctrl) determine_valid_ioctls()
544 if (vdev->ctrl_handler || ops->vidioc_query_ext_ctrl) determine_valid_ioctls()
546 if (vdev->ctrl_handler || ops->vidioc_g_ctrl || ops->vidioc_g_ext_ctrls) determine_valid_ioctls()
548 if (vdev->ctrl_handler || ops->vidioc_s_ctrl || ops->vidioc_s_ext_ctrls) determine_valid_ioctls()
550 if (vdev->ctrl_handler || ops->vidioc_g_ext_ctrls) determine_valid_ioctls()
552 if (vdev->ctrl_handler || ops->vidioc_s_ext_ctrls) determine_valid_ioctls()
554 if (vdev->ctrl_handler || ops->vidioc_try_ext_ctrls) determine_valid_ioctls()
556 if (vdev->ctrl_handler || ops->vidioc_querymenu) determine_valid_ioctls()
558 SET_VALID_IOCTL(ops, VIDIOC_G_FREQUENCY, vidioc_g_frequency); determine_valid_ioctls()
559 SET_VALID_IOCTL(ops, VIDIOC_S_FREQUENCY, vidioc_s_frequency); determine_valid_ioctls()
560 SET_VALID_IOCTL(ops, VIDIOC_LOG_STATUS, vidioc_log_status); determine_valid_ioctls()
567 SET_VALID_IOCTL(ops, VIDIOC_DQEVENT, vidioc_subscribe_event); determine_valid_ioctls()
568 SET_VALID_IOCTL(ops, VIDIOC_SUBSCRIBE_EVENT, vidioc_subscribe_event); determine_valid_ioctls()
569 SET_VALID_IOCTL(ops, VIDIOC_UNSUBSCRIBE_EVENT, vidioc_unsubscribe_event); determine_valid_ioctls()
570 if (ops->vidioc_enum_freq_bands || ops->vidioc_g_tuner || ops->vidioc_g_modulator) determine_valid_ioctls()
575 if ((is_rx && (ops->vidioc_enum_fmt_vid_cap || determine_valid_ioctls()
576 ops->vidioc_enum_fmt_vid_cap_mplane || determine_valid_ioctls()
577 ops->vidioc_enum_fmt_vid_overlay)) || determine_valid_ioctls()
578 (is_tx && (ops->vidioc_enum_fmt_vid_out || determine_valid_ioctls()
579 ops->vidioc_enum_fmt_vid_out_mplane))) determine_valid_ioctls()
581 if ((is_rx && (ops->vidioc_g_fmt_vid_cap || determine_valid_ioctls()
582 ops->vidioc_g_fmt_vid_cap_mplane || determine_valid_ioctls()
583 ops->vidioc_g_fmt_vid_overlay)) || determine_valid_ioctls()
584 (is_tx && (ops->vidioc_g_fmt_vid_out || determine_valid_ioctls()
585 ops->vidioc_g_fmt_vid_out_mplane || determine_valid_ioctls()
586 ops->vidioc_g_fmt_vid_out_overlay))) determine_valid_ioctls()
588 if ((is_rx && (ops->vidioc_s_fmt_vid_cap || determine_valid_ioctls()
589 ops->vidioc_s_fmt_vid_cap_mplane || determine_valid_ioctls()
590 ops->vidioc_s_fmt_vid_overlay)) || determine_valid_ioctls()
591 (is_tx && (ops->vidioc_s_fmt_vid_out || determine_valid_ioctls()
592 ops->vidioc_s_fmt_vid_out_mplane || determine_valid_ioctls()
593 ops->vidioc_s_fmt_vid_out_overlay))) determine_valid_ioctls()
595 if ((is_rx && (ops->vidioc_try_fmt_vid_cap || determine_valid_ioctls()
596 ops->vidioc_try_fmt_vid_cap_mplane || determine_valid_ioctls()
597 ops->vidioc_try_fmt_vid_overlay)) || determine_valid_ioctls()
598 (is_tx && (ops->vidioc_try_fmt_vid_out || determine_valid_ioctls()
599 ops->vidioc_try_fmt_vid_out_mplane || determine_valid_ioctls()
600 ops->vidioc_try_fmt_vid_out_overlay))) determine_valid_ioctls()
602 SET_VALID_IOCTL(ops, VIDIOC_OVERLAY, vidioc_overlay); determine_valid_ioctls()
603 SET_VALID_IOCTL(ops, VIDIOC_G_FBUF, vidioc_g_fbuf); determine_valid_ioctls()
604 SET_VALID_IOCTL(ops, VIDIOC_S_FBUF, vidioc_s_fbuf); determine_valid_ioctls()
605 SET_VALID_IOCTL(ops, VIDIOC_G_JPEGCOMP, vidioc_g_jpegcomp); determine_valid_ioctls()
606 SET_VALID_IOCTL(ops, VIDIOC_S_JPEGCOMP, vidioc_s_jpegcomp); determine_valid_ioctls()
607 SET_VALID_IOCTL(ops, VIDIOC_G_ENC_INDEX, vidioc_g_enc_index); determine_valid_ioctls()
608 SET_VALID_IOCTL(ops, VIDIOC_ENCODER_CMD, vidioc_encoder_cmd); determine_valid_ioctls()
609 SET_VALID_IOCTL(ops, VIDIOC_TRY_ENCODER_CMD, vidioc_try_encoder_cmd); determine_valid_ioctls()
610 SET_VALID_IOCTL(ops, VIDIOC_DECODER_CMD, vidioc_decoder_cmd); determine_valid_ioctls()
611 SET_VALID_IOCTL(ops, VIDIOC_TRY_DECODER_CMD, vidioc_try_decoder_cmd); determine_valid_ioctls()
612 SET_VALID_IOCTL(ops, VIDIOC_ENUM_FRAMESIZES, vidioc_enum_framesizes); determine_valid_ioctls()
613 SET_VALID_IOCTL(ops, VIDIOC_ENUM_FRAMEINTERVALS, vidioc_enum_frameintervals); determine_valid_ioctls()
614 if (ops->vidioc_g_crop || ops->vidioc_g_selection) determine_valid_ioctls()
616 if (ops->vidioc_s_crop || ops->vidioc_s_selection) determine_valid_ioctls()
618 SET_VALID_IOCTL(ops, VIDIOC_G_SELECTION, vidioc_g_selection); determine_valid_ioctls()
619 SET_VALID_IOCTL(ops, VIDIOC_S_SELECTION, vidioc_s_selection); determine_valid_ioctls()
620 if (ops->vidioc_cropcap || ops->vidioc_g_selection) determine_valid_ioctls()
624 if ((is_rx && (ops->vidioc_g_fmt_vbi_cap || determine_valid_ioctls()
625 ops->vidioc_g_fmt_sliced_vbi_cap)) || determine_valid_ioctls()
626 (is_tx && (ops->vidioc_g_fmt_vbi_out || determine_valid_ioctls()
627 ops->vidioc_g_fmt_sliced_vbi_out))) determine_valid_ioctls()
629 if ((is_rx && (ops->vidioc_s_fmt_vbi_cap || determine_valid_ioctls()
630 ops->vidioc_s_fmt_sliced_vbi_cap)) || determine_valid_ioctls()
631 (is_tx && (ops->vidioc_s_fmt_vbi_out || determine_valid_ioctls()
632 ops->vidioc_s_fmt_sliced_vbi_out))) determine_valid_ioctls()
634 if ((is_rx && (ops->vidioc_try_fmt_vbi_cap || determine_valid_ioctls()
635 ops->vidioc_try_fmt_sliced_vbi_cap)) || determine_valid_ioctls()
636 (is_tx && (ops->vidioc_try_fmt_vbi_out || determine_valid_ioctls()
637 ops->vidioc_try_fmt_sliced_vbi_out))) determine_valid_ioctls()
639 SET_VALID_IOCTL(ops, VIDIOC_G_SLICED_VBI_CAP, vidioc_g_sliced_vbi_cap); determine_valid_ioctls()
642 if (ops->vidioc_enum_fmt_sdr_cap) determine_valid_ioctls()
644 if (ops->vidioc_g_fmt_sdr_cap) determine_valid_ioctls()
646 if (ops->vidioc_s_fmt_sdr_cap) determine_valid_ioctls()
648 if (ops->vidioc_try_fmt_sdr_cap) determine_valid_ioctls()
652 if (ops->vidioc_enum_fmt_sdr_out) determine_valid_ioctls()
654 if (ops->vidioc_g_fmt_sdr_out) determine_valid_ioctls()
656 if (ops->vidioc_s_fmt_sdr_out) determine_valid_ioctls()
658 if (ops->vidioc_try_fmt_sdr_out) determine_valid_ioctls()
664 SET_VALID_IOCTL(ops, VIDIOC_REQBUFS, vidioc_reqbufs); determine_valid_ioctls()
665 SET_VALID_IOCTL(ops, VIDIOC_QUERYBUF, vidioc_querybuf); determine_valid_ioctls()
666 SET_VALID_IOCTL(ops, VIDIOC_QBUF, vidioc_qbuf); determine_valid_ioctls()
667 SET_VALID_IOCTL(ops, VIDIOC_EXPBUF, vidioc_expbuf); determine_valid_ioctls()
668 SET_VALID_IOCTL(ops, VIDIOC_DQBUF, vidioc_dqbuf); determine_valid_ioctls()
669 SET_VALID_IOCTL(ops, VIDIOC_CREATE_BUFS, vidioc_create_bufs); determine_valid_ioctls()
670 SET_VALID_IOCTL(ops, VIDIOC_PREPARE_BUF, vidioc_prepare_buf); determine_valid_ioctls()
671 SET_VALID_IOCTL(ops, VIDIOC_STREAMON, vidioc_streamon); determine_valid_ioctls()
672 SET_VALID_IOCTL(ops, VIDIOC_STREAMOFF, vidioc_streamoff); determine_valid_ioctls()
677 if (ops->vidioc_s_std) determine_valid_ioctls()
679 SET_VALID_IOCTL(ops, VIDIOC_S_STD, vidioc_s_std); determine_valid_ioctls()
680 SET_VALID_IOCTL(ops, VIDIOC_G_STD, vidioc_g_std); determine_valid_ioctls()
682 SET_VALID_IOCTL(ops, VIDIOC_QUERYSTD, vidioc_querystd); determine_valid_ioctls()
683 SET_VALID_IOCTL(ops, VIDIOC_ENUMINPUT, vidioc_enum_input); determine_valid_ioctls()
684 SET_VALID_IOCTL(ops, VIDIOC_G_INPUT, vidioc_g_input); determine_valid_ioctls()
685 SET_VALID_IOCTL(ops, VIDIOC_S_INPUT, vidioc_s_input); determine_valid_ioctls()
686 SET_VALID_IOCTL(ops, VIDIOC_ENUMAUDIO, vidioc_enumaudio); determine_valid_ioctls()
687 SET_VALID_IOCTL(ops, VIDIOC_G_AUDIO, vidioc_g_audio); determine_valid_ioctls()
688 SET_VALID_IOCTL(ops, VIDIOC_S_AUDIO, vidioc_s_audio); determine_valid_ioctls()
689 SET_VALID_IOCTL(ops, VIDIOC_QUERY_DV_TIMINGS, vidioc_query_dv_timings); determine_valid_ioctls()
690 SET_VALID_IOCTL(ops, VIDIOC_S_EDID, vidioc_s_edid); determine_valid_ioctls()
693 SET_VALID_IOCTL(ops, VIDIOC_ENUMOUTPUT, vidioc_enum_output); determine_valid_ioctls()
694 SET_VALID_IOCTL(ops, VIDIOC_G_OUTPUT, vidioc_g_output); determine_valid_ioctls()
695 SET_VALID_IOCTL(ops, VIDIOC_S_OUTPUT, vidioc_s_output); determine_valid_ioctls()
696 SET_VALID_IOCTL(ops, VIDIOC_ENUMAUDOUT, vidioc_enumaudout); determine_valid_ioctls()
697 SET_VALID_IOCTL(ops, VIDIOC_G_AUDOUT, vidioc_g_audout); determine_valid_ioctls()
698 SET_VALID_IOCTL(ops, VIDIOC_S_AUDOUT, vidioc_s_audout); determine_valid_ioctls()
700 if (ops->vidioc_g_parm || (vdev->vfl_type == VFL_TYPE_GRABBER && determine_valid_ioctls()
701 ops->vidioc_g_std)) determine_valid_ioctls()
703 SET_VALID_IOCTL(ops, VIDIOC_S_PARM, vidioc_s_parm); determine_valid_ioctls()
704 SET_VALID_IOCTL(ops, VIDIOC_S_DV_TIMINGS, vidioc_s_dv_timings); determine_valid_ioctls()
705 SET_VALID_IOCTL(ops, VIDIOC_G_DV_TIMINGS, vidioc_g_dv_timings); determine_valid_ioctls()
706 SET_VALID_IOCTL(ops, VIDIOC_ENUM_DV_TIMINGS, vidioc_enum_dv_timings); determine_valid_ioctls()
707 SET_VALID_IOCTL(ops, VIDIOC_DV_TIMINGS_CAP, vidioc_dv_timings_cap); determine_valid_ioctls()
708 SET_VALID_IOCTL(ops, VIDIOC_G_EDID, vidioc_g_edid); determine_valid_ioctls()
712 SET_VALID_IOCTL(ops, VIDIOC_G_MODULATOR, vidioc_g_modulator); determine_valid_ioctls()
713 SET_VALID_IOCTL(ops, VIDIOC_S_MODULATOR, vidioc_s_modulator); determine_valid_ioctls()
717 SET_VALID_IOCTL(ops, VIDIOC_G_TUNER, vidioc_g_tuner); determine_valid_ioctls()
718 SET_VALID_IOCTL(ops, VIDIOC_S_TUNER, vidioc_s_tuner); determine_valid_ioctls()
719 SET_VALID_IOCTL(ops, VIDIOC_S_HW_FREQ_SEEK, vidioc_s_hw_freq_seek); determine_valid_ioctls()
890 vdev->cdev->ops = &v4l2_fops; __video_register_device()
H A Dv4l2-ioctl.c922 const struct v4l2_ioctl_ops *ops = vfd->ioctl_ops; check_fmt() local
929 if (ops == NULL) check_fmt()
935 (ops->vidioc_g_fmt_vid_cap || ops->vidioc_g_fmt_vid_cap_mplane)) check_fmt()
939 if (is_vid && is_rx && ops->vidioc_g_fmt_vid_cap_mplane) check_fmt()
943 if (is_vid && is_rx && ops->vidioc_g_fmt_vid_overlay) check_fmt()
948 (ops->vidioc_g_fmt_vid_out || ops->vidioc_g_fmt_vid_out_mplane)) check_fmt()
952 if (is_vid && is_tx && ops->vidioc_g_fmt_vid_out_mplane) check_fmt()
956 if (is_vid && is_tx && ops->vidioc_g_fmt_vid_out_overlay) check_fmt()
960 if (is_vbi && is_rx && ops->vidioc_g_fmt_vbi_cap) check_fmt()
964 if (is_vbi && is_tx && ops->vidioc_g_fmt_vbi_out) check_fmt()
968 if (is_vbi && is_rx && ops->vidioc_g_fmt_sliced_vbi_cap) check_fmt()
972 if (is_vbi && is_tx && ops->vidioc_g_fmt_sliced_vbi_out) check_fmt()
976 if (is_sdr && is_rx && ops->vidioc_g_fmt_sdr_cap) check_fmt()
980 if (is_sdr && is_tx && ops->vidioc_g_fmt_sdr_out) check_fmt()
1018 static int v4l_querycap(const struct v4l2_ioctl_ops *ops, v4l_querycap() argument
1026 ret = ops->vidioc_querycap(file, fh, cap); v4l_querycap()
1041 static int v4l_s_input(const struct v4l2_ioctl_ops *ops, v4l_s_input() argument
1044 return ops->vidioc_s_input(file, fh, *(unsigned int *)arg); v4l_s_input()
1047 static int v4l_s_output(const struct v4l2_ioctl_ops *ops, v4l_s_output() argument
1050 return ops->vidioc_s_output(file, fh, *(unsigned int *)arg); v4l_s_output()
1053 static int v4l_g_priority(const struct v4l2_ioctl_ops *ops, v4l_g_priority() argument
1064 static int v4l_s_priority(const struct v4l2_ioctl_ops *ops, v4l_s_priority() argument
1078 static int v4l_enuminput(const struct v4l2_ioctl_ops *ops, v4l_enuminput() argument
1093 return ops->vidioc_enum_input(file, fh, p); v4l_enuminput()
1096 static int v4l_enumoutput(const struct v4l2_ioctl_ops *ops, v4l_enumoutput() argument
1111 return ops->vidioc_enum_output(file, fh, p); v4l_enumoutput()
1291 static int v4l_enum_fmt(const struct v4l2_ioctl_ops *ops, v4l_enum_fmt() argument
1304 if (unlikely(!is_rx || !is_vid || !ops->vidioc_enum_fmt_vid_cap)) v4l_enum_fmt()
1306 ret = ops->vidioc_enum_fmt_vid_cap(file, fh, arg); v4l_enum_fmt()
1309 if (unlikely(!is_rx || !is_vid || !ops->vidioc_enum_fmt_vid_cap_mplane)) v4l_enum_fmt()
1311 ret = ops->vidioc_enum_fmt_vid_cap_mplane(file, fh, arg); v4l_enum_fmt()
1314 if (unlikely(!is_rx || !is_vid || !ops->vidioc_enum_fmt_vid_overlay)) v4l_enum_fmt()
1316 ret = ops->vidioc_enum_fmt_vid_overlay(file, fh, arg); v4l_enum_fmt()
1319 if (unlikely(!is_tx || !is_vid || !ops->vidioc_enum_fmt_vid_out)) v4l_enum_fmt()
1321 ret = ops->vidioc_enum_fmt_vid_out(file, fh, arg); v4l_enum_fmt()
1324 if (unlikely(!is_tx || !is_vid || !ops->vidioc_enum_fmt_vid_out_mplane)) v4l_enum_fmt()
1326 ret = ops->vidioc_enum_fmt_vid_out_mplane(file, fh, arg); v4l_enum_fmt()
1329 if (unlikely(!is_rx || !is_sdr || !ops->vidioc_enum_fmt_sdr_cap)) v4l_enum_fmt()
1331 ret = ops->vidioc_enum_fmt_sdr_cap(file, fh, arg); v4l_enum_fmt()
1334 if (unlikely(!is_tx || !is_sdr || !ops->vidioc_enum_fmt_sdr_out)) v4l_enum_fmt()
1336 ret = ops->vidioc_enum_fmt_sdr_out(file, fh, arg); v4l_enum_fmt()
1344 static int v4l_g_fmt(const struct v4l2_ioctl_ops *ops, v4l_g_fmt() argument
1381 if (unlikely(!is_rx || !is_vid || !ops->vidioc_g_fmt_vid_cap)) v4l_g_fmt()
1384 ret = ops->vidioc_g_fmt_vid_cap(file, fh, arg); v4l_g_fmt()
1389 if (unlikely(!is_rx || !is_vid || !ops->vidioc_g_fmt_vid_cap_mplane)) v4l_g_fmt()
1391 return ops->vidioc_g_fmt_vid_cap_mplane(file, fh, arg); v4l_g_fmt()
1393 if (unlikely(!is_rx || !is_vid || !ops->vidioc_g_fmt_vid_overlay)) v4l_g_fmt()
1395 return ops->vidioc_g_fmt_vid_overlay(file, fh, arg); v4l_g_fmt()
1397 if (unlikely(!is_rx || is_vid || !ops->vidioc_g_fmt_vbi_cap)) v4l_g_fmt()
1399 return ops->vidioc_g_fmt_vbi_cap(file, fh, arg); v4l_g_fmt()
1401 if (unlikely(!is_rx || is_vid || !ops->vidioc_g_fmt_sliced_vbi_cap)) v4l_g_fmt()
1403 return ops->vidioc_g_fmt_sliced_vbi_cap(file, fh, arg); v4l_g_fmt()
1405 if (unlikely(!is_tx || !is_vid || !ops->vidioc_g_fmt_vid_out)) v4l_g_fmt()
1408 ret = ops->vidioc_g_fmt_vid_out(file, fh, arg); v4l_g_fmt()
1413 if (unlikely(!is_tx || !is_vid || !ops->vidioc_g_fmt_vid_out_mplane)) v4l_g_fmt()
1415 return ops->vidioc_g_fmt_vid_out_mplane(file, fh, arg); v4l_g_fmt()
1417 if (unlikely(!is_tx || !is_vid || !ops->vidioc_g_fmt_vid_out_overlay)) v4l_g_fmt()
1419 return ops->vidioc_g_fmt_vid_out_overlay(file, fh, arg); v4l_g_fmt()
1421 if (unlikely(!is_tx || is_vid || !ops->vidioc_g_fmt_vbi_out)) v4l_g_fmt()
1423 return ops->vidioc_g_fmt_vbi_out(file, fh, arg); v4l_g_fmt()
1425 if (unlikely(!is_tx || is_vid || !ops->vidioc_g_fmt_sliced_vbi_out)) v4l_g_fmt()
1427 return ops->vidioc_g_fmt_sliced_vbi_out(file, fh, arg); v4l_g_fmt()
1429 if (unlikely(!is_rx || !is_sdr || !ops->vidioc_g_fmt_sdr_cap)) v4l_g_fmt()
1431 return ops->vidioc_g_fmt_sdr_cap(file, fh, arg); v4l_g_fmt()
1433 if (unlikely(!is_tx || !is_sdr || !ops->vidioc_g_fmt_sdr_out)) v4l_g_fmt()
1435 return ops->vidioc_g_fmt_sdr_out(file, fh, arg); v4l_g_fmt()
1440 static int v4l_s_fmt(const struct v4l2_ioctl_ops *ops, v4l_s_fmt() argument
1455 if (unlikely(!is_rx || !is_vid || !ops->vidioc_s_fmt_vid_cap)) v4l_s_fmt()
1458 ret = ops->vidioc_s_fmt_vid_cap(file, fh, arg); v4l_s_fmt()
1463 if (unlikely(!is_rx || !is_vid || !ops->vidioc_s_fmt_vid_cap_mplane)) v4l_s_fmt()
1466 return ops->vidioc_s_fmt_vid_cap_mplane(file, fh, arg); v4l_s_fmt()
1468 if (unlikely(!is_rx || !is_vid || !ops->vidioc_s_fmt_vid_overlay)) v4l_s_fmt()
1471 return ops->vidioc_s_fmt_vid_overlay(file, fh, arg); v4l_s_fmt()
1473 if (unlikely(!is_rx || is_vid || !ops->vidioc_s_fmt_vbi_cap)) v4l_s_fmt()
1476 return ops->vidioc_s_fmt_vbi_cap(file, fh, arg); v4l_s_fmt()
1478 if (unlikely(!is_rx || is_vid || !ops->vidioc_s_fmt_sliced_vbi_cap)) v4l_s_fmt()
1481 return ops->vidioc_s_fmt_sliced_vbi_cap(file, fh, arg); v4l_s_fmt()
1483 if (unlikely(!is_tx || !is_vid || !ops->vidioc_s_fmt_vid_out)) v4l_s_fmt()
1486 ret = ops->vidioc_s_fmt_vid_out(file, fh, arg); v4l_s_fmt()
1491 if (unlikely(!is_tx || !is_vid || !ops->vidioc_s_fmt_vid_out_mplane)) v4l_s_fmt()
1494 return ops->vidioc_s_fmt_vid_out_mplane(file, fh, arg); v4l_s_fmt()
1496 if (unlikely(!is_tx || !is_vid || !ops->vidioc_s_fmt_vid_out_overlay)) v4l_s_fmt()
1499 return ops->vidioc_s_fmt_vid_out_overlay(file, fh, arg); v4l_s_fmt()
1501 if (unlikely(!is_tx || is_vid || !ops->vidioc_s_fmt_vbi_out)) v4l_s_fmt()
1504 return ops->vidioc_s_fmt_vbi_out(file, fh, arg); v4l_s_fmt()
1506 if (unlikely(!is_tx || is_vid || !ops->vidioc_s_fmt_sliced_vbi_out)) v4l_s_fmt()
1509 return ops->vidioc_s_fmt_sliced_vbi_out(file, fh, arg); v4l_s_fmt()
1511 if (unlikely(!is_rx || !is_sdr || !ops->vidioc_s_fmt_sdr_cap)) v4l_s_fmt()
1514 return ops->vidioc_s_fmt_sdr_cap(file, fh, arg); v4l_s_fmt()
1516 if (unlikely(!is_tx || !is_sdr || !ops->vidioc_s_fmt_sdr_out)) v4l_s_fmt()
1519 return ops->vidioc_s_fmt_sdr_out(file, fh, arg); v4l_s_fmt()
1524 static int v4l_try_fmt(const struct v4l2_ioctl_ops *ops, v4l_try_fmt() argument
1539 if (unlikely(!is_rx || !is_vid || !ops->vidioc_try_fmt_vid_cap)) v4l_try_fmt()
1542 ret = ops->vidioc_try_fmt_vid_cap(file, fh, arg); v4l_try_fmt()
1547 if (unlikely(!is_rx || !is_vid || !ops->vidioc_try_fmt_vid_cap_mplane)) v4l_try_fmt()
1550 return ops->vidioc_try_fmt_vid_cap_mplane(file, fh, arg); v4l_try_fmt()
1552 if (unlikely(!is_rx || !is_vid || !ops->vidioc_try_fmt_vid_overlay)) v4l_try_fmt()
1555 return ops->vidioc_try_fmt_vid_overlay(file, fh, arg); v4l_try_fmt()
1557 if (unlikely(!is_rx || is_vid || !ops->vidioc_try_fmt_vbi_cap)) v4l_try_fmt()
1560 return ops->vidioc_try_fmt_vbi_cap(file, fh, arg); v4l_try_fmt()
1562 if (unlikely(!is_rx || is_vid || !ops->vidioc_try_fmt_sliced_vbi_cap)) v4l_try_fmt()
1565 return ops->vidioc_try_fmt_sliced_vbi_cap(file, fh, arg); v4l_try_fmt()
1567 if (unlikely(!is_tx || !is_vid || !ops->vidioc_try_fmt_vid_out)) v4l_try_fmt()
1570 ret = ops->vidioc_try_fmt_vid_out(file, fh, arg); v4l_try_fmt()
1575 if (unlikely(!is_tx || !is_vid || !ops->vidioc_try_fmt_vid_out_mplane)) v4l_try_fmt()
1578 return ops->vidioc_try_fmt_vid_out_mplane(file, fh, arg); v4l_try_fmt()
1580 if (unlikely(!is_tx || !is_vid || !ops->vidioc_try_fmt_vid_out_overlay)) v4l_try_fmt()
1583 return ops->vidioc_try_fmt_vid_out_overlay(file, fh, arg); v4l_try_fmt()
1585 if (unlikely(!is_tx || is_vid || !ops->vidioc_try_fmt_vbi_out)) v4l_try_fmt()
1588 return ops->vidioc_try_fmt_vbi_out(file, fh, arg); v4l_try_fmt()
1590 if (unlikely(!is_tx || is_vid || !ops->vidioc_try_fmt_sliced_vbi_out)) v4l_try_fmt()
1593 return ops->vidioc_try_fmt_sliced_vbi_out(file, fh, arg); v4l_try_fmt()
1595 if (unlikely(!is_rx || !is_sdr || !ops->vidioc_try_fmt_sdr_cap)) v4l_try_fmt()
1598 return ops->vidioc_try_fmt_sdr_cap(file, fh, arg); v4l_try_fmt()
1600 if (unlikely(!is_tx || !is_sdr || !ops->vidioc_try_fmt_sdr_out)) v4l_try_fmt()
1603 return ops->vidioc_try_fmt_sdr_out(file, fh, arg); v4l_try_fmt()
1608 static int v4l_streamon(const struct v4l2_ioctl_ops *ops, v4l_streamon() argument
1611 return ops->vidioc_streamon(file, fh, *(unsigned int *)arg); v4l_streamon()
1614 static int v4l_streamoff(const struct v4l2_ioctl_ops *ops, v4l_streamoff() argument
1617 return ops->vidioc_streamoff(file, fh, *(unsigned int *)arg); v4l_streamoff()
1620 static int v4l_g_tuner(const struct v4l2_ioctl_ops *ops, v4l_g_tuner() argument
1629 err = ops->vidioc_g_tuner(file, fh, p); v4l_g_tuner()
1635 static int v4l_s_tuner(const struct v4l2_ioctl_ops *ops, v4l_s_tuner() argument
1643 return ops->vidioc_s_tuner(file, fh, p); v4l_s_tuner()
1646 static int v4l_g_modulator(const struct v4l2_ioctl_ops *ops, v4l_g_modulator() argument
1656 err = ops->vidioc_g_modulator(file, fh, p); v4l_g_modulator()
1662 static int v4l_s_modulator(const struct v4l2_ioctl_ops *ops, v4l_s_modulator() argument
1671 return ops->vidioc_s_modulator(file, fh, p); v4l_s_modulator()
1674 static int v4l_g_frequency(const struct v4l2_ioctl_ops *ops, v4l_g_frequency() argument
1685 return ops->vidioc_g_frequency(file, fh, p); v4l_g_frequency()
1688 static int v4l_s_frequency(const struct v4l2_ioctl_ops *ops, v4l_s_frequency() argument
1704 return ops->vidioc_s_frequency(file, fh, p); v4l_s_frequency()
1707 static int v4l_enumstd(const struct v4l2_ioctl_ops *ops, v4l_enumstd() argument
1744 static int v4l_s_std(const struct v4l2_ioctl_ops *ops, v4l_s_std() argument
1755 return ops->vidioc_s_std(file, fh, norm); v4l_s_std()
1758 static int v4l_querystd(const struct v4l2_ioctl_ops *ops, v4l_querystd() argument
1773 return ops->vidioc_querystd(file, fh, arg); v4l_querystd()
1776 static int v4l_s_hw_freq_seek(const struct v4l2_ioctl_ops *ops, v4l_s_hw_freq_seek() argument
1791 return ops->vidioc_s_hw_freq_seek(file, fh, p); v4l_s_hw_freq_seek()
1794 static int v4l_overlay(const struct v4l2_ioctl_ops *ops, v4l_overlay() argument
1797 return ops->vidioc_overlay(file, fh, *(unsigned int *)arg); v4l_overlay()
1800 static int v4l_reqbufs(const struct v4l2_ioctl_ops *ops, v4l_reqbufs() argument
1811 return ops->vidioc_reqbufs(file, fh, p); v4l_reqbufs()
1814 static int v4l_querybuf(const struct v4l2_ioctl_ops *ops, v4l_querybuf() argument
1820 return ret ? ret : ops->vidioc_querybuf(file, fh, p); v4l_querybuf()
1823 static int v4l_qbuf(const struct v4l2_ioctl_ops *ops, v4l_qbuf() argument
1829 return ret ? ret : ops->vidioc_qbuf(file, fh, p); v4l_qbuf()
1832 static int v4l_dqbuf(const struct v4l2_ioctl_ops *ops, v4l_dqbuf() argument
1838 return ret ? ret : ops->vidioc_dqbuf(file, fh, p); v4l_dqbuf()
1841 static int v4l_create_bufs(const struct v4l2_ioctl_ops *ops, v4l_create_bufs() argument
1854 ret = ops->vidioc_create_bufs(file, fh, create); v4l_create_bufs()
1863 static int v4l_prepare_buf(const struct v4l2_ioctl_ops *ops, v4l_prepare_buf() argument
1869 return ret ? ret : ops->vidioc_prepare_buf(file, fh, b); v4l_prepare_buf()
1872 static int v4l_g_parm(const struct v4l2_ioctl_ops *ops, v4l_g_parm() argument
1881 if (ops->vidioc_g_parm) v4l_g_parm()
1882 return ops->vidioc_g_parm(file, fh, p); v4l_g_parm()
1887 ret = ops->vidioc_g_std(file, fh, &std); v4l_g_parm()
1893 static int v4l_s_parm(const struct v4l2_ioctl_ops *ops, v4l_s_parm() argument
1899 return ret ? ret : ops->vidioc_s_parm(file, fh, p); v4l_s_parm()
1902 static int v4l_queryctrl(const struct v4l2_ioctl_ops *ops, v4l_queryctrl() argument
1914 if (ops->vidioc_queryctrl) v4l_queryctrl()
1915 return ops->vidioc_queryctrl(file, fh, p); v4l_queryctrl()
1919 static int v4l_query_ext_ctrl(const struct v4l2_ioctl_ops *ops, v4l_query_ext_ctrl() argument
1931 if (ops->vidioc_query_ext_ctrl) v4l_query_ext_ctrl()
1932 return ops->vidioc_query_ext_ctrl(file, fh, p); v4l_query_ext_ctrl()
1936 static int v4l_querymenu(const struct v4l2_ioctl_ops *ops, v4l_querymenu() argument
1948 if (ops->vidioc_querymenu) v4l_querymenu()
1949 return ops->vidioc_querymenu(file, fh, p); v4l_querymenu()
1953 static int v4l_g_ctrl(const struct v4l2_ioctl_ops *ops, v4l_g_ctrl() argument
1967 if (ops->vidioc_g_ctrl) v4l_g_ctrl()
1968 return ops->vidioc_g_ctrl(file, fh, p); v4l_g_ctrl()
1969 if (ops->vidioc_g_ext_ctrls == NULL) v4l_g_ctrl()
1978 int ret = ops->vidioc_g_ext_ctrls(file, fh, &ctrls); v4l_g_ctrl()
1987 static int v4l_s_ctrl(const struct v4l2_ioctl_ops *ops, v4l_s_ctrl() argument
2001 if (ops->vidioc_s_ctrl) v4l_s_ctrl()
2002 return ops->vidioc_s_ctrl(file, fh, p); v4l_s_ctrl()
2003 if (ops->vidioc_s_ext_ctrls == NULL) v4l_s_ctrl()
2012 return ops->vidioc_s_ext_ctrls(file, fh, &ctrls); v4l_s_ctrl()
2016 static int v4l_g_ext_ctrls(const struct v4l2_ioctl_ops *ops, v4l_g_ext_ctrls() argument
2029 if (ops->vidioc_g_ext_ctrls == NULL) v4l_g_ext_ctrls()
2031 return check_ext_ctrls(p, 0) ? ops->vidioc_g_ext_ctrls(file, fh, p) : v4l_g_ext_ctrls()
2035 static int v4l_s_ext_ctrls(const struct v4l2_ioctl_ops *ops, v4l_s_ext_ctrls() argument
2048 if (ops->vidioc_s_ext_ctrls == NULL) v4l_s_ext_ctrls()
2050 return check_ext_ctrls(p, 0) ? ops->vidioc_s_ext_ctrls(file, fh, p) : v4l_s_ext_ctrls()
2054 static int v4l_try_ext_ctrls(const struct v4l2_ioctl_ops *ops, v4l_try_ext_ctrls() argument
2067 if (ops->vidioc_try_ext_ctrls == NULL) v4l_try_ext_ctrls()
2069 return check_ext_ctrls(p, 0) ? ops->vidioc_try_ext_ctrls(file, fh, p) : v4l_try_ext_ctrls()
2073 static int v4l_g_crop(const struct v4l2_ioctl_ops *ops, v4l_g_crop() argument
2082 if (ops->vidioc_g_crop) v4l_g_crop()
2083 return ops->vidioc_g_crop(file, fh, p); v4l_g_crop()
2092 ret = ops->vidioc_g_selection(file, fh, &s); v4l_g_crop()
2100 static int v4l_s_crop(const struct v4l2_ioctl_ops *ops, v4l_s_crop() argument
2109 if (ops->vidioc_s_crop) v4l_s_crop()
2110 return ops->vidioc_s_crop(file, fh, p); v4l_s_crop()
2119 return ops->vidioc_s_selection(file, fh, &s); v4l_s_crop()
2122 static int v4l_cropcap(const struct v4l2_ioctl_ops *ops, v4l_cropcap() argument
2127 if (ops->vidioc_g_selection) { v4l_cropcap()
2137 ret = ops->vidioc_g_selection(file, fh, &s); v4l_cropcap()
2148 ret = ops->vidioc_g_selection(file, fh, &s); v4l_cropcap()
2158 if (ops->vidioc_cropcap) v4l_cropcap()
2159 return ops->vidioc_cropcap(file, fh, p); v4l_cropcap()
2164 static int v4l_log_status(const struct v4l2_ioctl_ops *ops, v4l_log_status() argument
2173 ret = ops->vidioc_log_status(file, fh); v4l_log_status()
2180 static int v4l_dbg_g_register(const struct v4l2_ioctl_ops *ops, v4l_dbg_g_register() argument
2199 if (ops->vidioc_g_register && p->match.type == V4L2_CHIP_MATCH_BRIDGE && v4l_dbg_g_register()
2200 (ops->vidioc_g_chip_info || p->match.addr == 0)) v4l_dbg_g_register()
2201 return ops->vidioc_g_register(file, fh, p); v4l_dbg_g_register()
2208 static int v4l_dbg_s_register(const struct v4l2_ioctl_ops *ops, v4l_dbg_s_register() argument
2227 if (ops->vidioc_s_register && p->match.type == V4L2_CHIP_MATCH_BRIDGE && v4l_dbg_s_register()
2228 (ops->vidioc_g_chip_info || p->match.addr == 0)) v4l_dbg_s_register()
2229 return ops->vidioc_s_register(file, fh, p); v4l_dbg_s_register()
2236 static int v4l_dbg_g_chip_info(const struct v4l2_ioctl_ops *ops, v4l_dbg_g_chip_info() argument
2247 if (ops->vidioc_s_register) v4l_dbg_g_chip_info()
2249 if (ops->vidioc_g_register) v4l_dbg_g_chip_info()
2252 if (ops->vidioc_g_chip_info) v4l_dbg_g_chip_info()
2253 return ops->vidioc_g_chip_info(file, fh, arg); v4l_dbg_g_chip_info()
2264 if (sd->ops->core && sd->ops->core->s_register) v4l_dbg_g_chip_info()
2266 if (sd->ops->core && sd->ops->core->g_register) v4l_dbg_g_chip_info()
2279 static int v4l_dqevent(const struct v4l2_ioctl_ops *ops, v4l_dqevent() argument
2285 static int v4l_subscribe_event(const struct v4l2_ioctl_ops *ops, v4l_subscribe_event() argument
2288 return ops->vidioc_subscribe_event(fh, arg); v4l_subscribe_event()
2291 static int v4l_unsubscribe_event(const struct v4l2_ioctl_ops *ops, v4l_unsubscribe_event() argument
2294 return ops->vidioc_unsubscribe_event(fh, arg); v4l_unsubscribe_event()
2297 static int v4l_g_sliced_vbi_cap(const struct v4l2_ioctl_ops *ops, v4l_g_sliced_vbi_cap() argument
2309 return ops->vidioc_g_sliced_vbi_cap(file, fh, p); v4l_g_sliced_vbi_cap()
2312 static int v4l_enum_freq_bands(const struct v4l2_ioctl_ops *ops, v4l_enum_freq_bands() argument
2330 if (ops->vidioc_enum_freq_bands) { v4l_enum_freq_bands()
2331 err = ops->vidioc_enum_freq_bands(file, fh, p); v4l_enum_freq_bands()
2343 err = ops->vidioc_g_tuner(file, fh, &t); v4l_enum_freq_bands()
2362 err = ops->vidioc_g_modulator(file, fh, &m); v4l_enum_freq_bands()
2381 int (*func)(const struct v4l2_ioctl_ops *ops,
2567 const struct v4l2_ioctl_ops *ops = vfd->ioctl_ops; __video_do_ioctl() local
2576 if (ops == NULL) { __video_do_ioctl()
2612 ret = info->u.func(ops, file, fh, arg); __video_do_ioctl()
2613 } else if (!ops->vidioc_default) { __video_do_ioctl()
2616 ret = ops->vidioc_default(file, fh, __video_do_ioctl()
H A Dv4l2-clk.c100 ret = !try_module_get(clk->ops->owner); v4l2_clk_lock_driver()
113 module_put(clk->ops->owner); v4l2_clk_unlock_driver()
129 if (++clk->enable == 1 && clk->ops->enable) { v4l2_clk_enable()
130 ret = clk->ops->enable(clk); v4l2_clk_enable()
158 else if (!enable && clk->ops->disable) v4l2_clk_disable()
159 clk->ops->disable(clk); v4l2_clk_disable()
179 if (!clk->ops->get_rate) v4l2_clk_get_rate()
182 ret = clk->ops->get_rate(clk); v4l2_clk_get_rate()
208 if (!clk->ops->set_rate) v4l2_clk_set_rate()
211 ret = clk->ops->set_rate(clk, rate); v4l2_clk_set_rate()
220 struct v4l2_clk *v4l2_clk_register(const struct v4l2_clk_ops *ops, v4l2_clk_register() argument
227 if (!ops || !dev_id) v4l2_clk_register()
239 clk->ops = ops; v4l2_clk_register()
281 struct v4l2_clk_ops ops; member in struct:v4l2_clk_fixed
300 priv->ops.get_rate = fixed_get_rate; __v4l2_clk_register_fixed()
301 priv->ops.owner = owner; __v4l2_clk_register_fixed()
303 clk = v4l2_clk_register(&priv->ops, dev_id, priv); __v4l2_clk_register_fixed()
H A Dv4l2-event.c142 if (sev->ops && sev->ops->replace) { __v4l2_event_queue_fh()
143 sev->ops->replace(&kev->event, ev); __v4l2_event_queue_fh()
146 } else if (sev->ops && sev->ops->merge) { __v4l2_event_queue_fh()
149 sev->ops->merge(&kev->event, &second_oldest->event); __v4l2_event_queue_fh()
210 const struct v4l2_subscribed_event_ops *ops) v4l2_event_subscribe()
231 sev->ops = ops; v4l2_event_subscribe()
244 if (sev->ops && sev->ops->add) { v4l2_event_subscribe()
245 int ret = sev->ops->add(sev, elems); v4l2_event_subscribe()
247 sev->ops = NULL; v4l2_event_subscribe()
309 if (sev && sev->ops && sev->ops->del) v4l2_event_unsubscribe()
310 sev->ops->del(sev); v4l2_event_unsubscribe()
208 v4l2_event_subscribe(struct v4l2_fh *fh, const struct v4l2_event_subscription *sub, unsigned elems, const struct v4l2_subscribed_event_ops *ops) v4l2_event_subscribe() argument
/linux-4.4.14/tools/perf/util/
H A Dannotate.c31 static void ins__delete(struct ins_operands *ops) ins__delete() argument
33 if (ops == NULL) ins__delete()
35 zfree(&ops->source.raw); ins__delete()
36 zfree(&ops->source.name); ins__delete()
37 zfree(&ops->target.raw); ins__delete()
38 zfree(&ops->target.name); ins__delete()
42 struct ins_operands *ops) ins__raw_scnprintf()
44 return scnprintf(bf, size, "%-6.6s %s", ins->name, ops->raw); ins__raw_scnprintf()
48 struct ins_operands *ops) ins__scnprintf()
50 if (ins->ops->scnprintf) ins__scnprintf()
51 return ins->ops->scnprintf(ins, bf, size, ops); ins__scnprintf()
53 return ins__raw_scnprintf(ins, bf, size, ops); ins__scnprintf()
56 static int call__parse(struct ins_operands *ops) call__parse() argument
60 ops->target.addr = strtoull(ops->raw, &endptr, 16); call__parse()
73 ops->target.name = strdup(name); call__parse()
76 return ops->target.name == NULL ? -1 : 0; call__parse()
81 ops->target.addr = 0; call__parse()
89 ops->target.addr = strtoull(tok + 1, NULL, 16); call__parse()
94 struct ins_operands *ops) call__scnprintf()
96 if (ops->target.name) call__scnprintf()
97 return scnprintf(bf, size, "%-6.6s %s", ins->name, ops->target.name); call__scnprintf()
99 if (ops->target.addr == 0) call__scnprintf()
100 return ins__raw_scnprintf(ins, bf, size, ops); call__scnprintf()
102 return scnprintf(bf, size, "%-6.6s *%" PRIx64, ins->name, ops->target.addr); call__scnprintf()
112 return ins->ops == &call_ops; ins__is_call()
115 static int jump__parse(struct ins_operands *ops) jump__parse() argument
117 const char *s = strchr(ops->raw, '+'); jump__parse()
119 ops->target.addr = strtoull(ops->raw, NULL, 16); jump__parse()
122 ops->target.offset = strtoull(s, NULL, 16); jump__parse()
124 ops->target.offset = UINT64_MAX; jump__parse()
130 struct ins_operands *ops) jump__scnprintf()
132 return scnprintf(bf, size, "%-6.6s %" PRIx64, ins->name, ops->target.offset); jump__scnprintf()
142 return ins->ops == &jump_ops; ins__is_jump()
170 static int lock__parse(struct ins_operands *ops) lock__parse() argument
174 ops->locked.ops = zalloc(sizeof(*ops->locked.ops)); lock__parse()
175 if (ops->locked.ops == NULL) lock__parse()
178 if (disasm_line__parse(ops->raw, &name, &ops->locked.ops->raw) < 0) lock__parse()
181 ops->locked.ins = ins__find(name); lock__parse()
184 if (ops->locked.ins == NULL) lock__parse()
187 if (!ops->locked.ins->ops) lock__parse()
190 if (ops->locked.ins->ops->parse && lock__parse()
191 ops->locked.ins->ops->parse(ops->locked.ops) < 0) lock__parse()
197 zfree(&ops->locked.ops); lock__parse()
202 struct ins_operands *ops) lock__scnprintf()
206 if (ops->locked.ins == NULL) lock__scnprintf()
207 return ins__raw_scnprintf(ins, bf, size, ops); lock__scnprintf()
210 return printed + ins__scnprintf(ops->locked.ins, bf + printed, lock__scnprintf()
211 size - printed, ops->locked.ops); lock__scnprintf()
214 static void lock__delete(struct ins_operands *ops) lock__delete() argument
216 struct ins *ins = ops->locked.ins; lock__delete()
218 if (ins && ins->ops->free) lock__delete()
219 ins->ops->free(ops->locked.ops); lock__delete()
221 ins__delete(ops->locked.ops); lock__delete()
223 zfree(&ops->locked.ops); lock__delete()
224 zfree(&ops->target.raw); lock__delete()
225 zfree(&ops->target.name); lock__delete()
234 static int mov__parse(struct ins_operands *ops) mov__parse() argument
236 char *s = strchr(ops->raw, ','), *target, *comment, prev; mov__parse()
242 ops->source.raw = strdup(ops->raw); mov__parse()
245 if (ops->source.raw == NULL) mov__parse()
262 ops->target.raw = strdup(target); mov__parse()
265 if (ops->target.raw == NULL) mov__parse()
274 comment__symbol(ops->source.raw, comment, &ops->source.addr, &ops->source.name); mov__parse()
275 comment__symbol(ops->target.raw, comment, &ops->target.addr, &ops->target.name); mov__parse()
280 zfree(&ops->source.raw); mov__parse()
285 struct ins_operands *ops) mov__scnprintf()
288 ops->source.name ?: ops->source.raw, mov__scnprintf()
289 ops->target.name ?: ops->target.raw); mov__scnprintf()
297 static int dec__parse(struct ins_operands *ops) dec__parse() argument
301 target = s = ops->raw; dec__parse()
308 ops->target.raw = strdup(target); dec__parse()
311 if (ops->target.raw == NULL) dec__parse()
321 comment__symbol(ops->target.raw, comment, &ops->target.addr, &ops->target.name); dec__parse()
327 struct ins_operands *ops) dec__scnprintf()
330 ops->target.name ?: ops->target.raw); dec__scnprintf()
339 struct ins_operands *ops __maybe_unused) nop__scnprintf()
352 { .name = "add", .ops = &mov_ops, },
353 { .name = "addl", .ops = &mov_ops, },
354 { .name = "addq", .ops = &mov_ops, },
355 { .name = "addw", .ops = &mov_ops, },
356 { .name = "and", .ops = &mov_ops, },
357 { .name = "bts", .ops = &mov_ops, },
358 { .name = "call", .ops = &call_ops, },
359 { .name = "callq", .ops = &call_ops, },
360 { .name = "cmp", .ops = &mov_ops, },
361 { .name = "cmpb", .ops = &mov_ops, },
362 { .name = "cmpl", .ops = &mov_ops, },
363 { .name = "cmpq", .ops = &mov_ops, },
364 { .name = "cmpw", .ops = &mov_ops, },
365 { .name = "cmpxch", .ops = &mov_ops, },
366 { .name = "dec", .ops = &dec_ops, },
367 { .name = "decl", .ops = &dec_ops, },
368 { .name = "imul", .ops = &mov_ops, },
369 { .name = "inc", .ops = &dec_ops, },
370 { .name = "incl", .ops = &dec_ops, },
371 { .name = "ja", .ops = &jump_ops, },
372 { .name = "jae", .ops = &jump_ops, },
373 { .name = "jb", .ops = &jump_ops, },
374 { .name = "jbe", .ops = &jump_ops, },
375 { .name = "jc", .ops = &jump_ops, },
376 { .name = "jcxz", .ops = &jump_ops, },
377 { .name = "je", .ops = &jump_ops, },
378 { .name = "jecxz", .ops = &jump_ops, },
379 { .name = "jg", .ops = &jump_ops, },
380 { .name = "jge", .ops = &jump_ops, },
381 { .name = "jl", .ops = &jump_ops, },
382 { .name = "jle", .ops = &jump_ops, },
383 { .name = "jmp", .ops = &jump_ops, },
384 { .name = "jmpq", .ops = &jump_ops, },
385 { .name = "jna", .ops = &jump_ops, },
386 { .name = "jnae", .ops = &jump_ops, },
387 { .name = "jnb", .ops = &jump_ops, },
388 { .name = "jnbe", .ops = &jump_ops, },
389 { .name = "jnc", .ops = &jump_ops, },
390 { .name = "jne", .ops = &jump_ops, },
391 { .name = "jng", .ops = &jump_ops, },
392 { .name = "jnge", .ops = &jump_ops, },
393 { .name = "jnl", .ops = &jump_ops, },
394 { .name = "jnle", .ops = &jump_ops, },
395 { .name = "jno", .ops = &jump_ops, },
396 { .name = "jnp", .ops = &jump_ops, },
397 { .name = "jns", .ops = &jump_ops, },
398 { .name = "jnz", .ops = &jump_ops, },
399 { .name = "jo", .ops = &jump_ops, },
400 { .name = "jp", .ops = &jump_ops, },
401 { .name = "jpe", .ops = &jump_ops, },
402 { .name = "jpo", .ops = &jump_ops, },
403 { .name = "jrcxz", .ops = &jump_ops, },
404 { .name = "js", .ops = &jump_ops, },
405 { .name = "jz", .ops = &jump_ops, },
406 { .name = "lea", .ops = &mov_ops, },
407 { .name = "lock", .ops = &lock_ops, },
408 { .name = "mov", .ops = &mov_ops, },
409 { .name = "movb", .ops = &mov_ops, },
410 { .name = "movdqa",.ops = &mov_ops, },
411 { .name = "movl", .ops = &mov_ops, },
412 { .name = "movq", .ops = &mov_ops, },
413 { .name = "movslq", .ops = &mov_ops, },
414 { .name = "movzbl", .ops = &mov_ops, },
415 { .name = "movzwl", .ops = &mov_ops, },
416 { .name = "nop", .ops = &nop_ops, },
417 { .name = "nopl", .ops = &nop_ops, },
418 { .name = "nopw", .ops = &nop_ops, },
419 { .name = "or", .ops = &mov_ops, },
420 { .name = "orl", .ops = &mov_ops, },
421 { .name = "test", .ops = &mov_ops, },
422 { .name = "testb", .ops = &mov_ops, },
423 { .name = "testl", .ops = &mov_ops, },
424 { .name = "xadd", .ops = &mov_ops, },
425 { .name = "xbeginl", .ops = &jump_ops, },
426 { .name = "xbeginq", .ops = &jump_ops, },
674 if (!dl->ins->ops) disasm_line__init_ins()
677 if (dl->ins->ops->parse && dl->ins->ops->parse(&dl->ops) < 0) disasm_line__init_ins()
731 if (disasm_line__parse(dl->line, &dl->name, &dl->ops.raw) < 0) disasm_line__new()
751 if (dl->ins && dl->ins->ops->free) disasm_line__free()
752 dl->ins->ops->free(&dl->ops); disasm_line__free()
754 ins__delete(&dl->ops); disasm_line__free()
761 return scnprintf(bf, size, "%-6.6s %s", dl->name, dl->ops.raw); disasm_line__scnprintf()
763 return ins__scnprintf(dl->ins, bf, size, &dl->ops); disasm_line__scnprintf()
949 * <offset> <name> <ops.raw>
953 * The ops.raw part will be parsed further according to type of the instruction.
1025 if (dl->ops.target.offset == UINT64_MAX) symbol__parse_objdump_line()
1026 dl->ops.target.offset = dl->ops.target.addr - symbol__parse_objdump_line()
1030 if (dl->ins && ins__is_call(dl->ins) && !dl->ops.target.name) { symbol__parse_objdump_line()
1033 .addr = dl->ops.target.addr, symbol__parse_objdump_line()
1038 dl->ops.target.name = strdup(target.sym->name); symbol__parse_objdump_line()
1060 if (dl->ins && dl->ins->ops) { delete_last_nop()
1061 if (dl->ins->ops != &nop_ops) delete_last_nop()
1590 if (dl->ops.raw[0] != '\0') { disasm_line__fprintf()
1592 dl->ops.raw); disasm_line__fprintf()
41 ins__raw_scnprintf(struct ins *ins, char *bf, size_t size, struct ins_operands *ops) ins__raw_scnprintf() argument
47 ins__scnprintf(struct ins *ins, char *bf, size_t size, struct ins_operands *ops) ins__scnprintf() argument
93 call__scnprintf(struct ins *ins, char *bf, size_t size, struct ins_operands *ops) call__scnprintf() argument
129 jump__scnprintf(struct ins *ins, char *bf, size_t size, struct ins_operands *ops) jump__scnprintf() argument
201 lock__scnprintf(struct ins *ins, char *bf, size_t size, struct ins_operands *ops) lock__scnprintf() argument
284 mov__scnprintf(struct ins *ins, char *bf, size_t size, struct ins_operands *ops) mov__scnprintf() argument
326 dec__scnprintf(struct ins *ins, char *bf, size_t size, struct ins_operands *ops) dec__scnprintf() argument
/linux-4.4.14/drivers/mmc/core/
H A Dpwrseq.c92 if (pwrseq && pwrseq->ops && pwrseq->ops->pre_power_on) mmc_pwrseq_pre_power_on()
93 pwrseq->ops->pre_power_on(host); mmc_pwrseq_pre_power_on()
100 if (pwrseq && pwrseq->ops && pwrseq->ops->post_power_on) mmc_pwrseq_post_power_on()
101 pwrseq->ops->post_power_on(host); mmc_pwrseq_post_power_on()
108 if (pwrseq && pwrseq->ops && pwrseq->ops->power_off) mmc_pwrseq_power_off()
109 pwrseq->ops->power_off(host); mmc_pwrseq_power_off()
116 if (pwrseq && pwrseq->ops && pwrseq->ops->free) mmc_pwrseq_free()
117 pwrseq->ops->free(host); mmc_pwrseq_free()
/linux-4.4.14/include/trace/events/
H A Dfence.h19 __string(driver, fence->ops->get_driver_name(fence))
20 __string(timeline, fence->ops->get_driver_name(fence))
24 __string(waiting_driver, f1->ops->get_driver_name(f1))
25 __string(waiting_timeline, f1->ops->get_timeline_name(f1))
31 __assign_str(driver, fence->ops->get_driver_name(fence))
32 __assign_str(timeline, fence->ops->get_timeline_name(fence))
36 __assign_str(waiting_driver, f1->ops->get_driver_name(f1))
37 __assign_str(waiting_timeline, f1->ops->get_timeline_name(f1))
58 __string(driver, fence->ops->get_driver_name(fence))
59 __string(timeline, fence->ops->get_timeline_name(fence))
65 __assign_str(driver, fence->ops->get_driver_name(fence))
66 __assign_str(timeline, fence->ops->get_timeline_name(fence))
/linux-4.4.14/drivers/net/wireless/ath/ath10k/
H A Dwmi-ops.h196 if (WARN_ON_ONCE(!ar->wmi.ops->rx)) ath10k_wmi_rx()
199 ar->wmi.ops->rx(ar, skb); ath10k_wmi_rx()
207 if (!ar->wmi.ops->map_svc) ath10k_wmi_map_svc()
210 ar->wmi.ops->map_svc(in, out, len); ath10k_wmi_map_svc()
218 if (!ar->wmi.ops->pull_scan) ath10k_wmi_pull_scan()
221 return ar->wmi.ops->pull_scan(ar, skb, arg); ath10k_wmi_pull_scan()
228 if (!ar->wmi.ops->pull_mgmt_rx) ath10k_wmi_pull_mgmt_rx()
231 return ar->wmi.ops->pull_mgmt_rx(ar, skb, arg); ath10k_wmi_pull_mgmt_rx()
238 if (!ar->wmi.ops->pull_ch_info) ath10k_wmi_pull_ch_info()
241 return ar->wmi.ops->pull_ch_info(ar, skb, arg); ath10k_wmi_pull_ch_info()
248 if (!ar->wmi.ops->pull_vdev_start) ath10k_wmi_pull_vdev_start()
251 return ar->wmi.ops->pull_vdev_start(ar, skb, arg); ath10k_wmi_pull_vdev_start()
258 if (!ar->wmi.ops->pull_peer_kick) ath10k_wmi_pull_peer_kick()
261 return ar->wmi.ops->pull_peer_kick(ar, skb, arg); ath10k_wmi_pull_peer_kick()
268 if (!ar->wmi.ops->pull_swba) ath10k_wmi_pull_swba()
271 return ar->wmi.ops->pull_swba(ar, skb, arg); ath10k_wmi_pull_swba()
278 if (!ar->wmi.ops->pull_phyerr_hdr) ath10k_wmi_pull_phyerr_hdr()
281 return ar->wmi.ops->pull_phyerr_hdr(ar, skb, arg); ath10k_wmi_pull_phyerr_hdr()
288 if (!ar->wmi.ops->pull_phyerr) ath10k_wmi_pull_phyerr()
291 return ar->wmi.ops->pull_phyerr(ar, phyerr_buf, left_len, arg); ath10k_wmi_pull_phyerr()
298 if (!ar->wmi.ops->pull_svc_rdy) ath10k_wmi_pull_svc_rdy()
301 return ar->wmi.ops->pull_svc_rdy(ar, skb, arg); ath10k_wmi_pull_svc_rdy()
308 if (!ar->wmi.ops->pull_rdy) ath10k_wmi_pull_rdy()
311 return ar->wmi.ops->pull_rdy(ar, skb, arg); ath10k_wmi_pull_rdy()
318 if (!ar->wmi.ops->pull_fw_stats) ath10k_wmi_pull_fw_stats()
321 return ar->wmi.ops->pull_fw_stats(ar, skb, stats); ath10k_wmi_pull_fw_stats()
328 if (!ar->wmi.ops->pull_roam_ev) ath10k_wmi_pull_roam_ev()
331 return ar->wmi.ops->pull_roam_ev(ar, skb, arg); ath10k_wmi_pull_roam_ev()
338 if (!ar->wmi.ops->pull_wow_event) ath10k_wmi_pull_wow_event()
341 return ar->wmi.ops->pull_wow_event(ar, skb, arg); ath10k_wmi_pull_wow_event()
347 if (!ar->wmi.ops->get_txbf_conf_scheme) ath10k_wmi_get_txbf_conf_scheme()
350 return ar->wmi.ops->get_txbf_conf_scheme(ar); ath10k_wmi_get_txbf_conf_scheme()
360 if (!ar->wmi.ops->gen_mgmt_tx) ath10k_wmi_mgmt_tx()
363 skb = ar->wmi.ops->gen_mgmt_tx(ar, msdu); ath10k_wmi_mgmt_tx()
386 if (!ar->wmi.ops->gen_pdev_set_rd) ath10k_wmi_pdev_set_regdomain()
389 skb = ar->wmi.ops->gen_pdev_set_rd(ar, rd, rd2g, rd5g, ctl2g, ctl5g, ath10k_wmi_pdev_set_regdomain()
403 if (!ar->wmi.ops->gen_pdev_suspend) ath10k_wmi_pdev_suspend_target()
406 skb = ar->wmi.ops->gen_pdev_suspend(ar, suspend_opt); ath10k_wmi_pdev_suspend_target()
418 if (!ar->wmi.ops->gen_pdev_resume) ath10k_wmi_pdev_resume_target()
421 skb = ar->wmi.ops->gen_pdev_resume(ar); ath10k_wmi_pdev_resume_target()
433 if (!ar->wmi.ops->gen_pdev_set_param) ath10k_wmi_pdev_set_param()
436 skb = ar->wmi.ops->gen_pdev_set_param(ar, id, value); ath10k_wmi_pdev_set_param()
448 if (!ar->wmi.ops->gen_init) ath10k_wmi_cmd_init()
451 skb = ar->wmi.ops->gen_init(ar); ath10k_wmi_cmd_init()
464 if (!ar->wmi.ops->gen_start_scan) ath10k_wmi_start_scan()
467 skb = ar->wmi.ops->gen_start_scan(ar, arg); ath10k_wmi_start_scan()
479 if (!ar->wmi.ops->gen_stop_scan) ath10k_wmi_stop_scan()
482 skb = ar->wmi.ops->gen_stop_scan(ar, arg); ath10k_wmi_stop_scan()
497 if (!ar->wmi.ops->gen_vdev_create) ath10k_wmi_vdev_create()
500 skb = ar->wmi.ops->gen_vdev_create(ar, vdev_id, type, subtype, macaddr); ath10k_wmi_vdev_create()
512 if (!ar->wmi.ops->gen_vdev_delete) ath10k_wmi_vdev_delete()
515 skb = ar->wmi.ops->gen_vdev_delete(ar, vdev_id); ath10k_wmi_vdev_delete()
528 if (!ar->wmi.ops->gen_vdev_start) ath10k_wmi_vdev_start()
531 skb = ar->wmi.ops->gen_vdev_start(ar, arg, false); ath10k_wmi_vdev_start()
545 if (!ar->wmi.ops->gen_vdev_start) ath10k_wmi_vdev_restart()
548 skb = ar->wmi.ops->gen_vdev_start(ar, arg, true); ath10k_wmi_vdev_restart()
561 if (!ar->wmi.ops->gen_vdev_stop) ath10k_wmi_vdev_stop()
564 skb = ar->wmi.ops->gen_vdev_stop(ar, vdev_id); ath10k_wmi_vdev_stop()
576 if (!ar->wmi.ops->gen_vdev_up) ath10k_wmi_vdev_up()
579 skb = ar->wmi.ops->gen_vdev_up(ar, vdev_id, aid, bssid); ath10k_wmi_vdev_up()
591 if (!ar->wmi.ops->gen_vdev_down) ath10k_wmi_vdev_down()
594 skb = ar->wmi.ops->gen_vdev_down(ar, vdev_id); ath10k_wmi_vdev_down()
607 if (!ar->wmi.ops->gen_vdev_set_param) ath10k_wmi_vdev_set_param()
610 skb = ar->wmi.ops->gen_vdev_set_param(ar, vdev_id, param_id, ath10k_wmi_vdev_set_param()
624 if (!ar->wmi.ops->gen_vdev_install_key) ath10k_wmi_vdev_install_key()
627 skb = ar->wmi.ops->gen_vdev_install_key(ar, arg); ath10k_wmi_vdev_install_key()
642 skb = ar->wmi.ops->gen_vdev_spectral_conf(ar, arg); ath10k_wmi_vdev_spectral_conf()
657 skb = ar->wmi.ops->gen_vdev_spectral_enable(ar, vdev_id, trigger, ath10k_wmi_vdev_spectral_enable()
675 if (!ar->wmi.ops->gen_vdev_sta_uapsd) ath10k_wmi_vdev_sta_uapsd()
678 skb = ar->wmi.ops->gen_vdev_sta_uapsd(ar, vdev_id, peer_addr, args, ath10k_wmi_vdev_sta_uapsd()
694 skb = ar->wmi.ops->gen_vdev_wmm_conf(ar, vdev_id, arg); ath10k_wmi_vdev_wmm_conf()
709 if (!ar->wmi.ops->gen_peer_create) ath10k_wmi_peer_create()
712 skb = ar->wmi.ops->gen_peer_create(ar, vdev_id, peer_addr, peer_type); ath10k_wmi_peer_create()
725 if (!ar->wmi.ops->gen_peer_delete) ath10k_wmi_peer_delete()
728 skb = ar->wmi.ops->gen_peer_delete(ar, vdev_id, peer_addr); ath10k_wmi_peer_delete()
741 if (!ar->wmi.ops->gen_peer_flush) ath10k_wmi_peer_flush()
744 skb = ar->wmi.ops->gen_peer_flush(ar, vdev_id, peer_addr, tid_bitmap); ath10k_wmi_peer_flush()
757 if (!ar->wmi.ops->gen_peer_set_param) ath10k_wmi_peer_set_param()
760 skb = ar->wmi.ops->gen_peer_set_param(ar, vdev_id, peer_addr, param_id, ath10k_wmi_peer_set_param()
774 if (!ar->wmi.ops->gen_set_psmode) ath10k_wmi_set_psmode()
777 skb = ar->wmi.ops->gen_set_psmode(ar, vdev_id, psmode); ath10k_wmi_set_psmode()
791 if (!ar->wmi.ops->gen_set_sta_ps) ath10k_wmi_set_sta_ps_param()
794 skb = ar->wmi.ops->gen_set_sta_ps(ar, vdev_id, param_id, value); ath10k_wmi_set_sta_ps_param()
808 if (!ar->wmi.ops->gen_set_ap_ps) ath10k_wmi_set_ap_ps_param()
811 skb = ar->wmi.ops->gen_set_ap_ps(ar, vdev_id, mac, param_id, value); ath10k_wmi_set_ap_ps_param()
825 if (!ar->wmi.ops->gen_scan_chan_list) ath10k_wmi_scan_chan_list()
828 skb = ar->wmi.ops->gen_scan_chan_list(ar, arg); ath10k_wmi_scan_chan_list()
841 if (!ar->wmi.ops->gen_peer_assoc) ath10k_wmi_peer_assoc()
844 skb = ar->wmi.ops->gen_peer_assoc(ar, arg); ath10k_wmi_peer_assoc()
860 if (!ar->wmi.ops->gen_beacon_dma) ath10k_wmi_beacon_send_ref_nowait()
863 skb = ar->wmi.ops->gen_beacon_dma(ar, vdev_id, bcn, bcn_len, bcn_paddr, ath10k_wmi_beacon_send_ref_nowait()
884 if (!ar->wmi.ops->gen_pdev_set_wmm) ath10k_wmi_pdev_set_wmm_params()
887 skb = ar->wmi.ops->gen_pdev_set_wmm(ar, arg); ath10k_wmi_pdev_set_wmm_params()
900 if (!ar->wmi.ops->gen_request_stats) ath10k_wmi_request_stats()
903 skb = ar->wmi.ops->gen_request_stats(ar, stats_mask); ath10k_wmi_request_stats()
916 if (!ar->wmi.ops->gen_force_fw_hang) ath10k_wmi_force_fw_hang()
919 skb = ar->wmi.ops->gen_force_fw_hang(ar, type, delay_ms); ath10k_wmi_force_fw_hang()
931 if (!ar->wmi.ops->gen_dbglog_cfg) ath10k_wmi_dbglog_cfg()
934 skb = ar->wmi.ops->gen_dbglog_cfg(ar, module_enable, log_level); ath10k_wmi_dbglog_cfg()
946 if (!ar->wmi.ops->gen_pktlog_enable) ath10k_wmi_pdev_pktlog_enable()
949 skb = ar->wmi.ops->gen_pktlog_enable(ar, filter); ath10k_wmi_pdev_pktlog_enable()
961 if (!ar->wmi.ops->gen_pktlog_disable) ath10k_wmi_pdev_pktlog_disable()
964 skb = ar->wmi.ops->gen_pktlog_disable(ar); ath10k_wmi_pdev_pktlog_disable()
978 if (!ar->wmi.ops->gen_pdev_set_quiet_mode) ath10k_wmi_pdev_set_quiet_mode()
981 skb = ar->wmi.ops->gen_pdev_set_quiet_mode(ar, period, duration, ath10k_wmi_pdev_set_quiet_mode()
995 if (!ar->wmi.ops->gen_pdev_get_temperature) ath10k_wmi_pdev_get_temperature()
998 skb = ar->wmi.ops->gen_pdev_get_temperature(ar); ath10k_wmi_pdev_get_temperature()
1011 if (!ar->wmi.ops->gen_addba_clear_resp) ath10k_wmi_addba_clear_resp()
1014 skb = ar->wmi.ops->gen_addba_clear_resp(ar, vdev_id, mac); ath10k_wmi_addba_clear_resp()
1028 if (!ar->wmi.ops->gen_addba_send) ath10k_wmi_addba_send()
1031 skb = ar->wmi.ops->gen_addba_send(ar, vdev_id, mac, tid, buf_size); ath10k_wmi_addba_send()
1045 if (!ar->wmi.ops->gen_addba_set_resp) ath10k_wmi_addba_set_resp()
1048 skb = ar->wmi.ops->gen_addba_set_resp(ar, vdev_id, mac, tid, status); ath10k_wmi_addba_set_resp()
1062 if (!ar->wmi.ops->gen_delba_send) ath10k_wmi_delba_send()
1065 skb = ar->wmi.ops->gen_delba_send(ar, vdev_id, mac, tid, initiator, ath10k_wmi_delba_send()
1081 if (!ar->wmi.ops->gen_bcn_tmpl) ath10k_wmi_bcn_tmpl()
1084 skb = ar->wmi.ops->gen_bcn_tmpl(ar, vdev_id, tim_ie_offset, bcn, ath10k_wmi_bcn_tmpl()
1098 if (!ar->wmi.ops->gen_prb_tmpl) ath10k_wmi_prb_tmpl()
1101 skb = ar->wmi.ops->gen_prb_tmpl(ar, vdev_id, prb); ath10k_wmi_prb_tmpl()
1113 if (!ar->wmi.ops->gen_p2p_go_bcn_ie) ath10k_wmi_p2p_go_bcn_ie()
1116 skb = ar->wmi.ops->gen_p2p_go_bcn_ie(ar, vdev_id, p2p_ie); ath10k_wmi_p2p_go_bcn_ie()
1130 if (!ar->wmi.ops->gen_sta_keepalive) ath10k_wmi_sta_keepalive()
1133 skb = ar->wmi.ops->gen_sta_keepalive(ar, arg); ath10k_wmi_sta_keepalive()
1147 if (!ar->wmi.ops->gen_wow_enable) ath10k_wmi_wow_enable()
1150 skb = ar->wmi.ops->gen_wow_enable(ar); ath10k_wmi_wow_enable()
1166 if (!ar->wmi.ops->gen_wow_add_wakeup_event) ath10k_wmi_wow_add_wakeup_event()
1169 skb = ar->wmi.ops->gen_wow_add_wakeup_event(ar, vdev_id, event, enable); ath10k_wmi_wow_add_wakeup_event()
1183 if (!ar->wmi.ops->gen_wow_host_wakeup_ind) ath10k_wmi_wow_host_wakeup_ind()
1186 skb = ar->wmi.ops->gen_wow_host_wakeup_ind(ar); ath10k_wmi_wow_host_wakeup_ind()
1202 if (!ar->wmi.ops->gen_wow_add_pattern) ath10k_wmi_wow_add_pattern()
1205 skb = ar->wmi.ops->gen_wow_add_pattern(ar, vdev_id, pattern_id, ath10k_wmi_wow_add_pattern()
1221 if (!ar->wmi.ops->gen_wow_del_pattern) ath10k_wmi_wow_del_pattern()
1224 skb = ar->wmi.ops->gen_wow_del_pattern(ar, vdev_id, pattern_id); ath10k_wmi_wow_del_pattern()
1238 if (!ar->wmi.ops->gen_update_fw_tdls_state) ath10k_wmi_update_fw_tdls_state()
1241 skb = ar->wmi.ops->gen_update_fw_tdls_state(ar, vdev_id, state); ath10k_wmi_update_fw_tdls_state()
1256 if (!ar->wmi.ops->gen_tdls_peer_update) ath10k_wmi_tdls_peer_update()
1259 skb = ar->wmi.ops->gen_tdls_peer_update(ar, arg, cap, chan); ath10k_wmi_tdls_peer_update()
1272 if (!ar->wmi.ops->gen_adaptive_qcs) ath10k_wmi_adaptive_qcs()
1275 skb = ar->wmi.ops->gen_adaptive_qcs(ar, enable); ath10k_wmi_adaptive_qcs()
1287 if (!ar->wmi.ops->gen_pdev_get_tpc_config) ath10k_wmi_pdev_get_tpc_config()
1290 skb = ar->wmi.ops->gen_pdev_get_tpc_config(ar, param); ath10k_wmi_pdev_get_tpc_config()
1303 if (!ar->wmi.ops->fw_stats_fill) ath10k_wmi_fw_stats_fill()
1306 ar->wmi.ops->fw_stats_fill(ar, fw_stats, buf); ath10k_wmi_fw_stats_fill()
1316 if (!ar->wmi.ops->gen_pdev_enable_adaptive_cca) ath10k_wmi_pdev_enable_adaptive_cca()
1319 skb = ar->wmi.ops->gen_pdev_enable_adaptive_cca(ar, enable, ath10k_wmi_pdev_enable_adaptive_cca()
H A Dhif.h96 return ar->hif.ops->tx_sg(ar, pipe_id, items, n_items); ath10k_hif_tx_sg()
102 return ar->hif.ops->diag_read(ar, address, buf, buf_len); ath10k_hif_diag_read()
108 if (!ar->hif.ops->diag_write) ath10k_hif_diag_write()
111 return ar->hif.ops->diag_write(ar, address, data, nbytes); ath10k_hif_diag_write()
118 return ar->hif.ops->exchange_bmi_msg(ar, request, request_len, ath10k_hif_exchange_bmi_msg()
124 return ar->hif.ops->start(ar); ath10k_hif_start()
129 return ar->hif.ops->stop(ar); ath10k_hif_stop()
136 return ar->hif.ops->map_service_to_pipe(ar, service_id, ath10k_hif_map_service_to_pipe()
143 ar->hif.ops->get_default_pipe(ar, ul_pipe, dl_pipe); ath10k_hif_get_default_pipe()
149 ar->hif.ops->send_complete_check(ar, pipe_id, force); ath10k_hif_send_complete_check()
155 return ar->hif.ops->get_free_queue_number(ar, pipe_id); ath10k_hif_get_free_queue_number()
160 return ar->hif.ops->power_up(ar); ath10k_hif_power_up()
165 ar->hif.ops->power_down(ar); ath10k_hif_power_down()
170 if (!ar->hif.ops->suspend) ath10k_hif_suspend()
173 return ar->hif.ops->suspend(ar); ath10k_hif_suspend()
178 if (!ar->hif.ops->resume) ath10k_hif_resume()
181 return ar->hif.ops->resume(ar); ath10k_hif_resume()
186 if (!ar->hif.ops->read32) { ath10k_hif_read32()
191 return ar->hif.ops->read32(ar, address); ath10k_hif_read32()
197 if (!ar->hif.ops->write32) { ath10k_hif_write32()
202 ar->hif.ops->write32(ar, address, data); ath10k_hif_write32()
/linux-4.4.14/arch/ia64/oprofile/
H A Dinit.c15 extern int perfmon_init(struct oprofile_operations *ops);
19 int __init oprofile_arch_init(struct oprofile_operations *ops) oprofile_arch_init() argument
25 ret = perfmon_init(ops); oprofile_arch_init()
27 ops->backtrace = ia64_backtrace; oprofile_arch_init()
H A Dperfmon.c74 /* all the ops are handled via userspace for IA64 perfmon */
78 int perfmon_init(struct oprofile_operations *ops) perfmon_init() argument
84 ops->cpu_type = get_cpu_type(); perfmon_init()
85 ops->start = perfmon_start; perfmon_init()
86 ops->stop = perfmon_stop; perfmon_init()
/linux-4.4.14/drivers/gpu/drm/exynos/
H A Dexynos_drm_crtc.c28 if (exynos_crtc->ops->enable) exynos_drm_crtc_enable()
29 exynos_crtc->ops->enable(exynos_crtc); exynos_drm_crtc_enable()
40 if (exynos_crtc->ops->disable) exynos_drm_crtc_disable()
41 exynos_crtc->ops->disable(exynos_crtc); exynos_drm_crtc_disable()
49 if (exynos_crtc->ops->commit) exynos_drm_crtc_mode_set_nofb()
50 exynos_crtc->ops->commit(exynos_crtc); exynos_drm_crtc_mode_set_nofb()
61 if (exynos_crtc->ops->atomic_check) exynos_crtc_atomic_check()
62 return exynos_crtc->ops->atomic_check(exynos_crtc, state); exynos_crtc_atomic_check()
78 if (exynos_crtc->ops->atomic_begin) drm_atomic_crtc_for_each_plane()
79 exynos_crtc->ops->atomic_begin(exynos_crtc, drm_atomic_crtc_for_each_plane()
93 if (exynos_crtc->ops->atomic_flush) drm_atomic_crtc_for_each_plane()
94 exynos_crtc->ops->atomic_flush(exynos_crtc, drm_atomic_crtc_for_each_plane()
132 const struct exynos_drm_crtc_ops *ops, exynos_drm_crtc_create()
146 exynos_crtc->ops = ops; exynos_drm_crtc_create()
176 if (exynos_crtc->ops->enable_vblank) exynos_drm_crtc_enable_vblank()
177 return exynos_crtc->ops->enable_vblank(exynos_crtc); exynos_drm_crtc_enable_vblank()
188 if (exynos_crtc->ops->disable_vblank) exynos_drm_crtc_disable_vblank()
189 exynos_crtc->ops->disable_vblank(exynos_crtc); exynos_drm_crtc_disable_vblank()
236 if (exynos_crtc->ops->wait_for_vblank) exynos_drm_crtc_complete_scanout()
237 exynos_crtc->ops->wait_for_vblank(exynos_crtc); exynos_drm_crtc_complete_scanout()
261 if (exynos_crtc->ops->te_handler) exynos_drm_crtc_te_handler()
262 exynos_crtc->ops->te_handler(exynos_crtc); exynos_drm_crtc_te_handler()
128 exynos_drm_crtc_create(struct drm_device *drm_dev, struct drm_plane *plane, int pipe, enum exynos_drm_output_type type, const struct exynos_drm_crtc_ops *ops, void *ctx) exynos_drm_crtc_create() argument
/linux-4.4.14/include/linux/usb/
H A Dotg-fsm.h116 struct otg_fsm_ops *ops; member in struct:otg_fsm
141 if (!fsm->ops->chrg_vbus) otg_chrg_vbus()
143 fsm->ops->chrg_vbus(fsm, on); otg_chrg_vbus()
149 if (!fsm->ops->drv_vbus) otg_drv_vbus()
153 fsm->ops->drv_vbus(fsm, on); otg_drv_vbus()
160 if (!fsm->ops->loc_conn) otg_loc_conn()
164 fsm->ops->loc_conn(fsm, on); otg_loc_conn()
171 if (!fsm->ops->loc_sof) otg_loc_sof()
175 fsm->ops->loc_sof(fsm, on); otg_loc_sof()
182 if (!fsm->ops->start_pulse) otg_start_pulse()
186 fsm->ops->start_pulse(fsm); otg_start_pulse()
193 if (!fsm->ops->start_adp_prb) otg_start_adp_prb()
198 fsm->ops->start_adp_prb(fsm); otg_start_adp_prb()
205 if (!fsm->ops->start_adp_sns) otg_start_adp_sns()
209 fsm->ops->start_adp_sns(fsm); otg_start_adp_sns()
216 if (!fsm->ops->add_timer) otg_add_timer()
218 fsm->ops->add_timer(fsm, timer); otg_add_timer()
224 if (!fsm->ops->del_timer) otg_del_timer()
226 fsm->ops->del_timer(fsm, timer); otg_del_timer()
232 if (!fsm->ops->start_host) otg_start_host()
234 return fsm->ops->start_host(fsm, on); otg_start_host()
239 if (!fsm->ops->start_gadget) otg_start_gadget()
241 return fsm->ops->start_gadget(fsm, on); otg_start_gadget()
H A Dulpi.h55 struct usb_phy *otg_ulpi_create(struct usb_phy_io_ops *ops,
58 static inline struct usb_phy *otg_ulpi_create(struct usb_phy_io_ops *ops, otg_ulpi_create() argument
66 /* access ops for controllers with a viewport register */
/linux-4.4.14/drivers/misc/c2port/
H A Dcore.c67 struct c2port_ops *ops = dev->ops; c2port_reset() local
73 ops->c2ck_set(dev, 0); c2port_reset()
75 ops->c2ck_set(dev, 1); c2port_reset()
83 struct c2port_ops *ops = dev->ops; c2port_strobe_ck() local
91 ops->c2ck_set(dev, 0); c2port_strobe_ck()
93 ops->c2ck_set(dev, 1); c2port_strobe_ck()
105 struct c2port_ops *ops = dev->ops; c2port_write_ar() local
112 ops->c2d_dir(dev, 0); c2port_write_ar()
113 ops->c2d_set(dev, 1); c2port_write_ar()
115 ops->c2d_set(dev, 1); c2port_write_ar()
120 ops->c2d_set(dev, addr & 0x01); c2port_write_ar()
127 ops->c2d_dir(dev, 1); c2port_write_ar()
133 struct c2port_ops *ops = dev->ops; c2port_read_ar() local
140 ops->c2d_dir(dev, 0); c2port_read_ar()
141 ops->c2d_set(dev, 0); c2port_read_ar()
143 ops->c2d_set(dev, 1); c2port_read_ar()
147 ops->c2d_dir(dev, 1); c2port_read_ar()
153 if (ops->c2d_get(dev)) c2port_read_ar()
165 struct c2port_ops *ops = dev->ops; c2port_write_dr() local
172 ops->c2d_dir(dev, 0); c2port_write_dr()
173 ops->c2d_set(dev, 1); c2port_write_dr()
175 ops->c2d_set(dev, 0); c2port_write_dr()
179 ops->c2d_set(dev, 0); c2port_write_dr()
181 ops->c2d_set(dev, 0); c2port_write_dr()
186 ops->c2d_set(dev, data & 0x01); c2port_write_dr()
193 ops->c2d_dir(dev, 1); c2port_write_dr()
197 if (ops->c2d_get(dev)) c2port_write_dr()
213 struct c2port_ops *ops = dev->ops; c2port_read_dr() local
220 ops->c2d_dir(dev, 0); c2port_read_dr()
221 ops->c2d_set(dev, 0); c2port_read_dr()
223 ops->c2d_set(dev, 0); c2port_read_dr()
227 ops->c2d_set(dev, 0); c2port_read_dr()
229 ops->c2d_set(dev, 0); c2port_read_dr()
233 ops->c2d_dir(dev, 1); c2port_read_dr()
237 if (ops->c2d_get(dev)) c2port_read_dr()
251 if (ops->c2d_get(dev)) c2port_read_dr()
320 struct c2port_ops *ops = c2dev->ops; c2port_show_flash_blocks_num() local
322 return sprintf(buf, "%d\n", ops->blocks_num); c2port_show_flash_blocks_num()
330 struct c2port_ops *ops = c2dev->ops; c2port_show_flash_block_size() local
332 return sprintf(buf, "%d\n", ops->block_size); c2port_show_flash_block_size()
340 struct c2port_ops *ops = c2dev->ops; c2port_show_flash_size() local
342 return sprintf(buf, "%d\n", ops->blocks_num * ops->block_size); c2port_show_flash_size()
358 struct c2port_ops *ops = c2dev->ops; access_store() local
372 ops->c2ck_set(c2dev, 1); access_store()
373 ops->access(c2dev, c2dev->access); access_store()
375 ops->c2d_dir(c2dev, 1); access_store()
633 struct c2port_ops *ops = dev->ops; __c2port_read_flash_data() local
638 if (offset >= ops->block_size * ops->blocks_num) __c2port_read_flash_data()
641 if (ops->block_size * ops->blocks_num - offset < nread) __c2port_read_flash_data()
642 nread = ops->block_size * ops->blocks_num - offset; __c2port_read_flash_data()
746 struct c2port_ops *ops = dev->ops; __c2port_write_flash_data() local
752 if (ops->block_size * ops->blocks_num - offset < nwrite) __c2port_write_flash_data()
753 nwrite = ops->block_size * ops->blocks_num - offset; __c2port_write_flash_data()
756 if (offset >= ops->block_size * ops->blocks_num) __c2port_write_flash_data()
900 struct c2port_ops *ops, void *devdata) c2port_device_register()
905 if (unlikely(!ops) || unlikely(!ops->access) || \ c2port_device_register()
906 unlikely(!ops->c2d_dir) || unlikely(!ops->c2ck_set) || \ c2port_device_register()
907 unlikely(!ops->c2d_get) || unlikely(!ops->c2d_set)) c2port_device_register()
925 bin_attr_flash_data.size = ops->blocks_num * ops->block_size; c2port_device_register()
936 c2dev->ops = ops; c2port_device_register()
941 ops->access(c2dev, 0); c2port_device_register()
946 name, ops->blocks_num, ops->block_size, c2port_device_register()
947 ops->blocks_num * ops->block_size); c2port_device_register()
899 c2port_device_register(char *name, struct c2port_ops *ops, void *devdata) c2port_device_register() argument
/linux-4.4.14/kernel/irq/
H A Dmsi.c105 struct msi_domain_ops *ops = info->ops; msi_domain_alloc() local
106 irq_hw_number_t hwirq = ops->get_hwirq(info, arg); msi_domain_alloc()
117 ret = ops->msi_init(domain, info, virq + i, hwirq + i, arg); msi_domain_alloc()
119 if (ops->msi_free) { msi_domain_alloc()
121 ops->msi_free(domain, info, virq + i); msi_domain_alloc()
137 if (info->ops->msi_free) { msi_domain_free()
139 info->ops->msi_free(domain, info, virq + i); msi_domain_free()
208 struct msi_domain_ops *ops = info->ops; msi_domain_update_dom_ops() local
210 if (ops == NULL) { msi_domain_update_dom_ops()
211 info->ops = &msi_domain_ops_default; msi_domain_update_dom_ops()
215 if (ops->get_hwirq == NULL) msi_domain_update_dom_ops()
216 ops->get_hwirq = msi_domain_ops_default.get_hwirq; msi_domain_update_dom_ops()
217 if (ops->msi_init == NULL) msi_domain_update_dom_ops()
218 ops->msi_init = msi_domain_ops_default.msi_init; msi_domain_update_dom_ops()
219 if (ops->msi_check == NULL) msi_domain_update_dom_ops()
220 ops->msi_check = msi_domain_ops_default.msi_check; msi_domain_update_dom_ops()
221 if (ops->msi_prepare == NULL) msi_domain_update_dom_ops()
222 ops->msi_prepare = msi_domain_ops_default.msi_prepare; msi_domain_update_dom_ops()
223 if (ops->set_desc == NULL) msi_domain_update_dom_ops()
224 ops->set_desc = msi_domain_ops_default.set_desc; msi_domain_update_dom_ops()
268 struct msi_domain_ops *ops = info->ops; msi_domain_alloc_irqs() local
273 ret = ops->msi_check(domain, info, dev); msi_domain_alloc_irqs()
275 ret = ops->msi_prepare(domain, dev, nvec, &arg); msi_domain_alloc_irqs()
280 ops->set_desc(&arg, desc); for_each_msi_entry()
282 virq = (int)ops->get_hwirq(info, &arg); for_each_msi_entry()
290 if (ops->handle_error) for_each_msi_entry()
291 ret = ops->handle_error(domain, desc, ret); for_each_msi_entry()
292 if (ops->msi_finish) for_each_msi_entry()
293 ops->msi_finish(&arg, ret); for_each_msi_entry()
301 if (ops->msi_finish)
302 ops->msi_finish(&arg, 0);
/linux-4.4.14/net/mac80211/
H A Ddriver-ops.h29 local->ops->tx(&local->hw, control, skb); drv_tx()
36 if (local->ops->get_et_strings) { drv_get_et_strings()
38 local->ops->get_et_strings(&local->hw, &sdata->vif, sset, data); drv_get_et_strings()
48 if (local->ops->get_et_stats) { drv_get_et_stats()
50 local->ops->get_et_stats(&local->hw, &sdata->vif, stats, data); drv_get_et_stats()
60 if (local->ops->get_et_sset_count) { drv_get_et_sset_count()
62 rv = local->ops->get_et_sset_count(&local->hw, &sdata->vif, drv_get_et_sset_count()
81 ret = local->ops->suspend(&local->hw, wowlan); drv_suspend()
93 ret = local->ops->resume(&local->hw); drv_resume()
103 if (!local->ops->set_wakeup) drv_set_wakeup()
107 local->ops->set_wakeup(&local->hw, enabled); drv_set_wakeup()
129 ret = local->ops->config(&local->hw, changed); drv_config()
157 if (local->ops->bss_info_changed) drv_bss_info_changed()
158 local->ops->bss_info_changed(&local->hw, &sdata->vif, info, changed); drv_bss_info_changed()
169 if (local->ops->prepare_multicast) drv_prepare_multicast()
170 ret = local->ops->prepare_multicast(&local->hw, mc_list); drv_prepare_multicast()
186 local->ops->configure_filter(&local->hw, changed_flags, total_flags, drv_configure_filter()
200 if (local->ops->config_iface_filter) drv_config_iface_filter()
201 local->ops->config_iface_filter(&local->hw, &sdata->vif, drv_config_iface_filter()
212 if (local->ops->set_tim) drv_set_tim()
213 ret = local->ops->set_tim(&local->hw, sta, set); drv_set_tim()
233 ret = local->ops->set_key(&local->hw, cmd, &sdata->vif, sta, key); drv_set_key()
254 if (local->ops->update_tkip_key) drv_update_tkip_key()
255 local->ops->update_tkip_key(&local->hw, &sdata->vif, conf, drv_update_tkip_key()
272 ret = local->ops->hw_scan(&local->hw, &sdata->vif, req); drv_hw_scan()
286 local->ops->cancel_hw_scan(&local->hw, &sdata->vif); drv_cancel_hw_scan()
304 ret = local->ops->sched_scan_start(&local->hw, &sdata->vif, drv_sched_scan_start()
321 ret = local->ops->sched_scan_stop(&local->hw, &sdata->vif); drv_sched_scan_stop()
334 if (local->ops->sw_scan_start) drv_sw_scan_start()
335 local->ops->sw_scan_start(&local->hw, &sdata->vif, mac_addr); drv_sw_scan_start()
345 if (local->ops->sw_scan_complete) drv_sw_scan_complete()
346 local->ops->sw_scan_complete(&local->hw, &sdata->vif); drv_sw_scan_complete()
357 if (local->ops->get_stats) drv_get_stats()
358 ret = local->ops->get_stats(&local->hw, stats); drv_get_stats()
368 if (local->ops->get_key_seq) drv_get_key_seq()
369 local->ops->get_key_seq(&local->hw, &key->conf, seq); drv_get_key_seq()
381 if (local->ops->set_frag_threshold) drv_set_frag_threshold()
382 ret = local->ops->set_frag_threshold(&local->hw, value); drv_set_frag_threshold()
395 if (local->ops->set_rts_threshold) drv_set_rts_threshold()
396 ret = local->ops->set_rts_threshold(&local->hw, value); drv_set_rts_threshold()
408 if (local->ops->set_coverage_class) drv_set_coverage_class()
409 local->ops->set_coverage_class(&local->hw, value); drv_set_coverage_class()
427 if (local->ops->sta_notify) drv_sta_notify()
428 local->ops->sta_notify(&local->hw, &sdata->vif, cmd, sta); drv_sta_notify()
445 if (local->ops->sta_add) drv_sta_add()
446 ret = local->ops->sta_add(&local->hw, &sdata->vif, sta); drv_sta_add()
464 if (local->ops->sta_remove) drv_sta_remove()
465 local->ops->sta_remove(&local->hw, &sdata->vif, sta); drv_sta_remove()
482 if (local->ops->sta_add_debugfs) drv_sta_add_debugfs()
483 local->ops->sta_add_debugfs(&local->hw, &sdata->vif, drv_sta_add_debugfs()
497 if (local->ops->sta_remove_debugfs) drv_sta_remove_debugfs()
498 local->ops->sta_remove_debugfs(&local->hw, &sdata->vif, drv_sta_remove_debugfs()
514 if (local->ops->sta_pre_rcu_remove) drv_sta_pre_rcu_remove()
515 local->ops->sta_pre_rcu_remove(&local->hw, &sdata->vif, drv_sta_pre_rcu_remove()
540 if (local->ops->sta_rate_tbl_update) drv_sta_rate_tbl_update()
541 local->ops->sta_rate_tbl_update(&local->hw, &sdata->vif, sta); drv_sta_rate_tbl_update()
556 if (local->ops->sta_statistics) drv_sta_statistics()
557 local->ops->sta_statistics(&local->hw, &sdata->vif, sta, sinfo); drv_sta_statistics()
580 if (local->ops->tx_last_beacon) drv_tx_last_beacon()
581 ret = local->ops->tx_last_beacon(&local->hw); drv_tx_last_beacon()
599 if (local->ops->get_survey) drv_get_survey()
600 ret = local->ops->get_survey(&local->hw, idx, survey); drv_get_survey()
611 if (local->ops->rfkill_poll) drv_rfkill_poll()
612 local->ops->rfkill_poll(&local->hw); drv_rfkill_poll()
627 if (local->ops->flush) drv_flush()
628 local->ops->flush(&local->hw, vif, queues, drop); drv_flush()
639 local->ops->channel_switch(&local->hw, &sdata->vif, ch_switch); drv_channel_switch()
649 if (local->ops->set_antenna) drv_set_antenna()
650 ret = local->ops->set_antenna(&local->hw, tx_ant, rx_ant); drv_set_antenna()
660 if (local->ops->get_antenna) drv_get_antenna()
661 ret = local->ops->get_antenna(&local->hw, tx_ant, rx_ant); drv_get_antenna()
677 ret = local->ops->remain_on_channel(&local->hw, &sdata->vif, drv_remain_on_channel()
691 ret = local->ops->cancel_remain_on_channel(&local->hw); drv_cancel_remain_on_channel()
705 if (local->ops->set_ringparam) drv_set_ringparam()
706 ret = local->ops->set_ringparam(&local->hw, tx, rx); drv_set_ringparam()
718 if (local->ops->get_ringparam) drv_get_ringparam()
719 local->ops->get_ringparam(&local->hw, tx, tx_max, rx, rx_max); drv_get_ringparam()
730 if (local->ops->tx_frames_pending) drv_tx_frames_pending()
731 ret = local->ops->tx_frames_pending(&local->hw); drv_tx_frames_pending()
749 if (local->ops->set_bitrate_mask) drv_set_bitrate_mask()
750 ret = local->ops->set_bitrate_mask(&local->hw, drv_set_bitrate_mask()
765 if (local->ops->set_rekey_data) drv_set_rekey_data()
766 local->ops->set_rekey_data(&local->hw, &sdata->vif, data); drv_set_rekey_data()
775 if (local->ops->event_callback) drv_event_callback()
776 local->ops->event_callback(&local->hw, &sdata->vif, event); drv_event_callback()
788 if (local->ops->release_buffered_frames) drv_release_buffered_frames()
789 local->ops->release_buffered_frames(&local->hw, &sta->sta, tids, drv_release_buffered_frames()
803 if (local->ops->allow_buffered_frames) drv_allow_buffered_frames()
804 local->ops->allow_buffered_frames(&local->hw, &sta->sta, drv_allow_buffered_frames()
820 if (local->ops->mgd_prepare_tx) drv_mgd_prepare_tx()
821 local->ops->mgd_prepare_tx(&local->hw, &sdata->vif); drv_mgd_prepare_tx()
836 if (local->ops->mgd_protect_tdls_discover) drv_mgd_protect_tdls_discover()
837 local->ops->mgd_protect_tdls_discover(&local->hw, &sdata->vif); drv_mgd_protect_tdls_discover()
849 if (local->ops->add_chanctx) drv_add_chanctx()
850 ret = local->ops->add_chanctx(&local->hw, &ctx->conf); drv_add_chanctx()
867 if (local->ops->remove_chanctx) drv_remove_chanctx()
868 local->ops->remove_chanctx(&local->hw, &ctx->conf); drv_remove_chanctx()
880 if (local->ops->change_chanctx) { drv_change_chanctx()
882 local->ops->change_chanctx(&local->hw, &ctx->conf, changed); drv_change_chanctx()
897 if (local->ops->assign_vif_chanctx) { drv_assign_vif_chanctx()
899 ret = local->ops->assign_vif_chanctx(&local->hw, drv_assign_vif_chanctx()
918 if (local->ops->unassign_vif_chanctx) { drv_unassign_vif_chanctx()
920 local->ops->unassign_vif_chanctx(&local->hw, drv_unassign_vif_chanctx()
942 if (local->ops->start_ap) drv_start_ap()
943 ret = local->ops->start_ap(&local->hw, &sdata->vif); drv_start_ap()
955 if (local->ops->stop_ap) drv_stop_ap()
956 local->ops->stop_ap(&local->hw, &sdata->vif); drv_stop_ap()
967 if (local->ops->reconfig_complete) drv_reconfig_complete()
968 local->ops->reconfig_complete(&local->hw, reconfig_type); drv_reconfig_complete()
983 if (local->ops->set_default_unicast_key) drv_set_default_unicast_key()
984 local->ops->set_default_unicast_key(&local->hw, &sdata->vif, drv_set_default_unicast_key()
995 if (local->ops->ipv6_addr_change) drv_ipv6_addr_change()
996 local->ops->ipv6_addr_change(&local->hw, &sdata->vif, idev); drv_ipv6_addr_change()
1007 if (local->ops->channel_switch_beacon) { drv_channel_switch_beacon()
1009 local->ops->channel_switch_beacon(&local->hw, &sdata->vif, drv_channel_switch_beacon()
1025 if (local->ops->pre_channel_switch) drv_pre_channel_switch()
1026 ret = local->ops->pre_channel_switch(&local->hw, &sdata->vif, drv_pre_channel_switch()
1042 if (local->ops->post_channel_switch) drv_post_channel_switch()
1043 ret = local->ops->post_channel_switch(&local->hw, &sdata->vif); drv_post_channel_switch()
1058 if (local->ops->join_ibss) drv_join_ibss()
1059 ret = local->ops->join_ibss(&local->hw, &sdata->vif); drv_join_ibss()
1072 if (local->ops->leave_ibss) drv_leave_ibss()
1073 local->ops->leave_ibss(&local->hw, &sdata->vif); drv_leave_ibss()
1083 if (local->ops->get_expected_throughput) drv_get_expected_throughput()
1084 ret = local->ops->get_expected_throughput(sta); drv_get_expected_throughput()
1095 if (!local->ops->get_txpower) drv_get_txpower()
1098 ret = local->ops->get_txpower(&local->hw, &sdata->vif, dbm); drv_get_txpower()
1117 if (!local->ops->tdls_channel_switch) drv_tdls_channel_switch()
1121 ret = local->ops->tdls_channel_switch(&local->hw, &sdata->vif, sta, drv_tdls_channel_switch()
1137 if (!local->ops->tdls_cancel_channel_switch) drv_tdls_cancel_channel_switch()
1141 local->ops->tdls_cancel_channel_switch(&local->hw, &sdata->vif, sta); drv_tdls_cancel_channel_switch()
1151 if (local->ops->tdls_recv_channel_switch) drv_tdls_recv_channel_switch()
1152 local->ops->tdls_recv_channel_switch(&local->hw, &sdata->vif, drv_tdls_recv_channel_switch()
1166 local->ops->wake_tx_queue(&local->hw, &txq->txq); drv_wake_tx_queue()
H A Drate.h20 #include "driver-ops.h"
24 const struct rate_control_ops *ops; member in struct:rate_control_ref
46 if (ref->ops->tx_status) rate_control_tx_status()
47 ref->ops->tx_status(ref->priv, sband, ista, priv_sta, skb); rate_control_tx_status()
49 ref->ops->tx_status_noskb(ref->priv, sband, ista, priv_sta, info); rate_control_tx_status()
66 if (WARN_ON_ONCE(!ref->ops->tx_status_noskb)) rate_control_tx_status_noskb()
70 ref->ops->tx_status_noskb(ref->priv, sband, ista, priv_sta, info); rate_control_tx_status_noskb()
83 return ref->ops->alloc_sta(ref->priv, &sta->sta, gfp); rate_control_alloc_sta()
92 ref->ops->free_sta(ref->priv, ista, priv_sta); rate_control_free_sta()
99 if (ref && sta->debugfs.dir && ref->ops->add_sta_debugfs) rate_control_add_sta_debugfs()
100 ref->ops->add_sta_debugfs(ref->priv, sta->rate_ctrl_priv, rate_control_add_sta_debugfs()
109 if (ref && ref->ops->remove_sta_debugfs) rate_control_remove_sta_debugfs()
110 ref->ops->remove_sta_debugfs(ref->priv, sta->rate_ctrl_priv); rate_control_remove_sta_debugfs()
H A Ddriver-ops.c11 #include "driver-ops.h"
26 ret = local->ops->start(&local->hw); drv_start()
43 local->ops->stop(&local->hw); drv_stop()
69 ret = local->ops->add_interface(&local->hw, &sdata->vif); drv_add_interface()
90 ret = local->ops->change_interface(&local->hw, &sdata->vif, type, p2p); drv_change_interface()
104 local->ops->remove_interface(&local->hw, &sdata->vif); drv_remove_interface()
125 if (local->ops->sta_state) { drv_sta_state()
126 ret = local->ops->sta_state(&local->hw, &sdata->vif, &sta->sta, drv_sta_state()
154 if (local->ops->sta_rc_update) drv_sta_rc_update()
155 local->ops->sta_rc_update(&local->hw, &sdata->vif, drv_sta_rc_update()
179 if (local->ops->conf_tx) drv_conf_tx()
180 ret = local->ops->conf_tx(&local->hw, &sdata->vif, drv_conf_tx()
197 if (local->ops->get_tsf) drv_get_tsf()
198 ret = local->ops->get_tsf(&local->hw, &sdata->vif); drv_get_tsf()
213 if (local->ops->set_tsf) drv_set_tsf()
214 local->ops->set_tsf(&local->hw, &sdata->vif, tsf); drv_set_tsf()
227 if (local->ops->reset_tsf) drv_reset_tsf()
228 local->ops->reset_tsf(&local->hw, &sdata->vif); drv_reset_tsf()
241 if (!local->ops->switch_vif_chanctx) drv_switch_vif_chanctx()
262 ret = local->ops->switch_vif_chanctx(&local->hw, drv_switch_vif_chanctx()
302 if (local->ops->ampdu_action) drv_ampdu_action()
303 ret = local->ops->ampdu_action(&local->hw, &sdata->vif, action, drv_ampdu_action()
/linux-4.4.14/drivers/dma-buf/
H A Dseqno-fence.c28 return seqno_fence->ops->get_driver_name(fence); seqno_fence_get_driver_name()
35 return seqno_fence->ops->get_timeline_name(fence); seqno_fence_get_timeline_name()
42 return seqno_fence->ops->enable_signaling(fence); seqno_enable_signaling()
49 return seqno_fence->ops->signaled && seqno_fence->ops->signaled(fence); seqno_signaled()
57 if (f->ops->release) seqno_release()
58 f->ops->release(fence); seqno_release()
68 return f->ops->wait(fence, intr, timeout); seqno_wait()
/linux-4.4.14/arch/xtensa/oprofile/
H A Dinit.c17 int __init oprofile_arch_init(struct oprofile_operations *ops) oprofile_arch_init() argument
19 ops->backtrace = xtensa_backtrace; oprofile_arch_init()
/linux-4.4.14/drivers/media/firewire/
H A Dfiredtv-fe.c154 struct dvb_frontend_ops *ops = &fdtv->fe.ops; fdtv_frontend_init() local
155 struct dvb_frontend_info *fi = &ops->info; fdtv_frontend_init()
157 ops->init = fdtv_dvb_init; fdtv_frontend_init()
158 ops->sleep = fdtv_sleep; fdtv_frontend_init()
160 ops->set_frontend = fdtv_set_frontend; fdtv_frontend_init()
162 ops->read_status = fdtv_read_status; fdtv_frontend_init()
163 ops->read_ber = fdtv_read_ber; fdtv_frontend_init()
164 ops->read_signal_strength = fdtv_read_signal_strength; fdtv_frontend_init()
165 ops->read_snr = fdtv_read_snr; fdtv_frontend_init()
166 ops->read_ucblocks = fdtv_read_uncorrected_blocks; fdtv_frontend_init()
168 ops->diseqc_send_master_cmd = fdtv_diseqc_send_master_cmd; fdtv_frontend_init()
169 ops->diseqc_send_burst = fdtv_diseqc_send_burst; fdtv_frontend_init()
170 ops->set_tone = fdtv_set_tone; fdtv_frontend_init()
171 ops->set_voltage = fdtv_set_voltage; fdtv_frontend_init()
175 ops->delsys[0] = SYS_DVBS; fdtv_frontend_init()
194 ops->delsys[0] = SYS_DVBS; fdtv_frontend_init()
195 ops->delsys[1] = SYS_DVBS2; fdtv_frontend_init()
215 ops->delsys[0] = SYS_DVBC_ANNEX_A; fdtv_frontend_init()
233 ops->delsys[0] = SYS_DVBT; fdtv_frontend_init()
/linux-4.4.14/arch/sh/oprofile/
H A Dcommon.c37 int __init oprofile_arch_init(struct oprofile_operations *ops) oprofile_arch_init() argument
39 ops->backtrace = sh_backtrace; oprofile_arch_init()
49 return oprofile_perf_init(ops); oprofile_arch_init()
58 int __init oprofile_arch_init(struct oprofile_operations *ops) oprofile_arch_init() argument
60 ops->backtrace = sh_backtrace; oprofile_arch_init()
/linux-4.4.14/arch/metag/oprofile/
H A Dcommon.c38 int __init oprofile_arch_init(struct oprofile_operations *ops) oprofile_arch_init() argument
40 ops->backtrace = metag_backtrace; oprofile_arch_init()
50 return oprofile_perf_init(ops); oprofile_arch_init()
59 int __init oprofile_arch_init(struct oprofile_operations *ops) oprofile_arch_init() argument
61 ops->backtrace = metag_backtrace; oprofile_arch_init()
/linux-4.4.14/drivers/video/backlight/
H A Dlcd.c45 if (!ld->ops) fb_notifier_callback()
49 if (!ld->ops->check_fb || ld->ops->check_fb(ld, evdata->info)) { fb_notifier_callback()
51 if (ld->ops->set_power) fb_notifier_callback()
52 ld->ops->set_power(ld, *(int *)evdata->data); fb_notifier_callback()
54 if (ld->ops->early_set_power) fb_notifier_callback()
55 ld->ops->early_set_power(ld, fb_notifier_callback()
58 if (ld->ops->r_early_set_power) fb_notifier_callback()
59 ld->ops->r_early_set_power(ld, fb_notifier_callback()
62 if (ld->ops->set_mode) fb_notifier_callback()
63 ld->ops->set_mode(ld, evdata->data); fb_notifier_callback()
99 if (ld->ops && ld->ops->get_power) lcd_power_show()
100 rc = sprintf(buf, "%d\n", ld->ops->get_power(ld)); lcd_power_show()
122 if (ld->ops && ld->ops->set_power) { lcd_power_store()
124 ld->ops->set_power(ld, power); lcd_power_store()
140 if (ld->ops && ld->ops->get_contrast) contrast_show()
141 rc = sprintf(buf, "%d\n", ld->ops->get_contrast(ld)); contrast_show()
161 if (ld->ops && ld->ops->set_contrast) { contrast_store()
163 ld->ops->set_contrast(ld, contrast); contrast_store()
203 * @ops: the lcd operations structure.
209 void *devdata, struct lcd_ops *ops) lcd_device_register()
241 new_ld->ops = ops; lcd_device_register()
259 ld->ops = NULL; lcd_device_unregister()
287 * @ops: the lcd operations structure
297 void *devdata, struct lcd_ops *ops) devm_lcd_device_register()
305 lcd = lcd_device_register(name, parent, devdata, ops); devm_lcd_device_register()
208 lcd_device_register(const char *name, struct device *parent, void *devdata, struct lcd_ops *ops) lcd_device_register() argument
295 devm_lcd_device_register(struct device *dev, const char *name, struct device *parent, void *devdata, struct lcd_ops *ops) devm_lcd_device_register() argument
/linux-4.4.14/include/kvm/
H A Diodev.h45 const struct kvm_io_device_ops *ops; member in struct:kvm_io_device
49 const struct kvm_io_device_ops *ops) kvm_iodevice_init()
51 dev->ops = ops; kvm_iodevice_init()
58 return dev->ops->read ? dev->ops->read(vcpu, dev, addr, l, v) kvm_iodevice_read()
66 return dev->ops->write ? dev->ops->write(vcpu, dev, addr, l, v) kvm_iodevice_write()
72 if (dev->ops->destructor) kvm_iodevice_destructor()
73 dev->ops->destructor(dev); kvm_iodevice_destructor()
48 kvm_iodevice_init(struct kvm_io_device *dev, const struct kvm_io_device_ops *ops) kvm_iodevice_init() argument
/linux-4.4.14/net/ieee802154/
H A Drdev-ops.h15 return rdev->ops->add_virtual_intf_deprecated(&rdev->wpan_phy, name, rdev_add_virtual_intf_deprecated()
23 rdev->ops->del_virtual_intf_deprecated(&rdev->wpan_phy, dev); rdev_del_virtual_intf_deprecated()
31 ret = rdev->ops->suspend(&rdev->wpan_phy); rdev_suspend()
41 ret = rdev->ops->resume(&rdev->wpan_phy); rdev_resume()
55 ret = rdev->ops->add_virtual_intf(&rdev->wpan_phy, name, rdev_add_virtual_intf()
69 ret = rdev->ops->del_virtual_intf(&rdev->wpan_phy, wpan_dev); rdev_del_virtual_intf()
80 ret = rdev->ops->set_channel(&rdev->wpan_phy, page, channel); rdev_set_channel()
92 ret = rdev->ops->set_cca_mode(&rdev->wpan_phy, cca); rdev_set_cca_mode()
103 ret = rdev->ops->set_cca_ed_level(&rdev->wpan_phy, ed_level); rdev_set_cca_ed_level()
115 ret = rdev->ops->set_tx_power(&rdev->wpan_phy, power); rdev_set_tx_power()
127 ret = rdev->ops->set_pan_id(&rdev->wpan_phy, wpan_dev, pan_id); rdev_set_pan_id()
139 ret = rdev->ops->set_short_addr(&rdev->wpan_phy, wpan_dev, short_addr); rdev_set_short_addr()
152 ret = rdev->ops->set_backoff_exponent(&rdev->wpan_phy, wpan_dev, rdev_set_backoff_exponent()
166 ret = rdev->ops->set_max_csma_backoffs(&rdev->wpan_phy, wpan_dev, rdev_set_max_csma_backoffs()
180 ret = rdev->ops->set_max_frame_retries(&rdev->wpan_phy, wpan_dev, rdev_set_max_frame_retries()
193 ret = rdev->ops->set_lbt_mode(&rdev->wpan_phy, wpan_dev, mode); rdev_set_lbt_mode()
206 ret = rdev->ops->set_ackreq_default(&rdev->wpan_phy, wpan_dev, ackreq); rdev_set_ackreq_default()
218 rdev->ops->get_llsec_table(&rdev->wpan_phy, wpan_dev, table); rdev_get_llsec_table()
225 rdev->ops->lock_llsec_table(&rdev->wpan_phy, wpan_dev); rdev_lock_llsec_table()
232 rdev->ops->unlock_llsec_table(&rdev->wpan_phy, wpan_dev); rdev_unlock_llsec_table()
240 return rdev->ops->get_llsec_params(&rdev->wpan_phy, wpan_dev, params); rdev_get_llsec_params()
249 return rdev->ops->set_llsec_params(&rdev->wpan_phy, wpan_dev, params, rdev_set_llsec_params()
259 return rdev->ops->add_llsec_key(&rdev->wpan_phy, wpan_dev, id, key); rdev_add_llsec_key()
267 return rdev->ops->del_llsec_key(&rdev->wpan_phy, wpan_dev, id); rdev_del_llsec_key()
275 return rdev->ops->add_seclevel(&rdev->wpan_phy, wpan_dev, sl); rdev_add_seclevel()
283 return rdev->ops->del_seclevel(&rdev->wpan_phy, wpan_dev, sl); rdev_del_seclevel()
291 return rdev->ops->add_device(&rdev->wpan_phy, wpan_dev, dev_desc); rdev_add_device()
298 return rdev->ops->del_device(&rdev->wpan_phy, wpan_dev, extended_addr); rdev_del_device()
306 return rdev->ops->add_devkey(&rdev->wpan_phy, wpan_dev, extended_addr, rdev_add_devkey()
315 return rdev->ops->del_devkey(&rdev->wpan_phy, wpan_dev, extended_addr, rdev_del_devkey()
/linux-4.4.14/drivers/powercap/
H A Dpowercap_sys.c39 if (power_zone->ops->get_##_attr) { \
40 if (!power_zone->ops->get_##_attr(power_zone, &value)) \
62 if (power_zone->ops->reset_##_attr) { \
63 if (!power_zone->ops->reset_##_attr(power_zone)) \
87 if (pconst && pconst->ops && pconst->ops->get_##_attr) { \
88 if (!pconst->ops->get_##_attr(power_zone, id, &value)) \
115 if (pconst && pconst->ops && pconst->ops->set_##_attr) { \
116 if (!pconst->ops->set_##_attr(power_zone, id, value)) \
182 if (pconst && pconst->ops && pconst->ops->get_name) { show_constraint_name()
183 name = pconst->ops->get_name(power_zone, id); show_constraint_name()
313 pconst->ops = const_ops; create_constraints()
320 if (pconst->ops->get_name) create_constraints()
323 if (pconst->ops->get_max_power_uw) create_constraints()
326 if (pconst->ops->get_min_power_uw) create_constraints()
329 if (pconst->ops->get_max_time_window_us) create_constraints()
332 if (pconst->ops->get_min_time_window_us) create_constraints()
377 if (power_zone->ops->get_max_energy_range_uj) create_power_zone_common_attributes()
380 if (power_zone->ops->get_energy_uj) { create_power_zone_common_attributes()
381 if (power_zone->ops->reset_energy_uj) create_power_zone_common_attributes()
388 if (power_zone->ops->get_power_uw) create_power_zone_common_attributes()
391 if (power_zone->ops->get_max_power_range_uw) create_power_zone_common_attributes()
414 if (power_zone->ops->release) powercap_release()
415 power_zone->ops->release(power_zone); powercap_release()
426 if (control_type->ops && control_type->ops->release) powercap_release()
427 control_type->ops->release(control_type); powercap_release()
442 if (power_zone->ops->get_enable) enabled_show()
443 if (power_zone->ops->get_enable(power_zone, &mode)) enabled_show()
448 if (control_type->ops && control_type->ops->get_enable) enabled_show()
449 if (control_type->ops->get_enable(control_type, &mode)) enabled_show()
466 if (power_zone->ops->set_enable) enabled_store()
467 if (!power_zone->ops->set_enable(power_zone, mode)) enabled_store()
472 if (control_type->ops && control_type->ops->set_enable) enabled_store()
473 if (!control_type->ops->set_enable(control_type, mode)) enabled_store()
499 const struct powercap_zone_ops *ops, powercap_register_zone()
506 if (!name || !control_type || !ops || powercap_register_zone()
508 (!ops->get_energy_uj && !ops->get_power_uw) || powercap_register_zone()
513 if (!ops->release) powercap_register_zone()
522 power_zone->ops = ops; powercap_register_zone()
613 const struct powercap_control_type_ops *ops) powercap_register_control_type()
620 if (!ops || !ops->release) powercap_register_control_type()
630 control_type->ops = ops; powercap_register_control_type()
494 powercap_register_zone( struct powercap_zone *power_zone, struct powercap_control_type *control_type, const char *name, struct powercap_zone *parent, const struct powercap_zone_ops *ops, int nr_constraints, struct powercap_zone_constraint_ops *const_ops) powercap_register_zone() argument
610 powercap_register_control_type( struct powercap_control_type *control_type, const char *name, const struct powercap_control_type_ops *ops) powercap_register_control_type() argument
/linux-4.4.14/drivers/target/
H A Dtarget_core_hba.c51 int transport_backend_register(const struct target_backend_ops *ops) transport_backend_register() argument
58 tb->ops = ops; transport_backend_register()
62 if (!strcmp(old->ops->name, ops->name)) { transport_backend_register()
63 pr_err("backend %s already registered.\n", ops->name); transport_backend_register()
74 ops->name, ops->owner); transport_backend_register()
79 void target_backend_unregister(const struct target_backend_ops *ops) target_backend_unregister() argument
85 if (tb->ops == ops) { target_backend_unregister()
109 if (!strcmp(tb->ops->name, name)) core_get_backend()
115 if (tb->ops->owner && !try_module_get(tb->ops->owner)) core_get_backend()
145 ret = hba->backend->ops->attach_hba(hba, plugin_dep_id); core_alloc_hba()
160 module_put(hba->backend->ops->owner); core_alloc_hba()
172 hba->backend->ops->detach_hba(hba); core_delete_hba()
181 module_put(hba->backend->ops->owner); core_delete_hba()
/linux-4.4.14/net/wireless/
H A Dlib80211.c38 struct lib80211_crypto_ops *ops; member in struct:lib80211_crypto_alg
76 if (crypt->ops) { lib80211_crypt_info_free()
77 crypt->ops->deinit(crypt->priv); lib80211_crypt_info_free()
78 module_put(crypt->ops->owner); lib80211_crypt_info_free()
100 if (entry->ops) { lib80211_crypt_deinit_entries()
101 entry->ops->deinit(entry->priv); lib80211_crypt_deinit_entries()
102 module_put(entry->ops->owner); lib80211_crypt_deinit_entries()
148 /* must not run ops->deinit() while there may be pending encrypt or lib80211_crypt_delayed_deinit()
164 int lib80211_register_crypto_ops(struct lib80211_crypto_ops *ops) lib80211_register_crypto_ops() argument
173 alg->ops = ops; lib80211_register_crypto_ops()
180 ops->name); lib80211_register_crypto_ops()
186 int lib80211_unregister_crypto_ops(struct lib80211_crypto_ops *ops) lib80211_unregister_crypto_ops() argument
193 if (alg->ops == ops) lib80211_unregister_crypto_ops()
201 ops->name); lib80211_unregister_crypto_ops()
216 if (strcmp(alg->ops->name, name) == 0) lib80211_get_crypto_ops()
224 return alg->ops; lib80211_get_crypto_ops()
H A Drdev-ops.h14 ret = rdev->ops->suspend(&rdev->wiphy, wowlan); rdev_suspend()
23 ret = rdev->ops->resume(&rdev->wiphy); rdev_resume()
32 rdev->ops->set_wakeup(&rdev->wiphy, enabled); rdev_set_wakeup()
44 ret = rdev->ops->add_virtual_intf(&rdev->wiphy, name, name_assign_type, rdev_add_virtual_intf()
56 ret = rdev->ops->del_virtual_intf(&rdev->wiphy, wdev); rdev_del_virtual_intf()
68 ret = rdev->ops->change_virtual_intf(&rdev->wiphy, dev, type, flags, rdev_change_virtual_intf()
81 ret = rdev->ops->add_key(&rdev->wiphy, netdev, key_index, pairwise, rdev_add_key()
94 ret = rdev->ops->get_key(&rdev->wiphy, netdev, key_index, pairwise, rdev_get_key()
106 ret = rdev->ops->del_key(&rdev->wiphy, netdev, key_index, pairwise, rdev_del_key()
120 ret = rdev->ops->set_default_key(&rdev->wiphy, netdev, key_index, rdev_set_default_key()
132 ret = rdev->ops->set_default_mgmt_key(&rdev->wiphy, netdev, rdev_set_default_mgmt_key()
144 ret = rdev->ops->start_ap(&rdev->wiphy, dev, settings); rdev_start_ap()
155 ret = rdev->ops->change_beacon(&rdev->wiphy, dev, info); rdev_change_beacon()
165 ret = rdev->ops->stop_ap(&rdev->wiphy, dev); rdev_stop_ap()
176 ret = rdev->ops->add_station(&rdev->wiphy, dev, mac, params); rdev_add_station()
187 ret = rdev->ops->del_station(&rdev->wiphy, dev, params); rdev_del_station()
198 ret = rdev->ops->change_station(&rdev->wiphy, dev, mac, params); rdev_change_station()
209 ret = rdev->ops->get_station(&rdev->wiphy, dev, mac, sinfo); rdev_get_station()
220 ret = rdev->ops->dump_station(&rdev->wiphy, dev, idx, mac, sinfo); rdev_dump_station()
230 ret = rdev->ops->add_mpath(&rdev->wiphy, dev, dst, next_hop); rdev_add_mpath()
240 ret = rdev->ops->del_mpath(&rdev->wiphy, dev, dst); rdev_del_mpath()
251 ret = rdev->ops->change_mpath(&rdev->wiphy, dev, dst, next_hop); rdev_change_mpath()
262 ret = rdev->ops->get_mpath(&rdev->wiphy, dev, dst, next_hop, pinfo); rdev_get_mpath()
275 ret = rdev->ops->get_mpp(&rdev->wiphy, dev, dst, mpp, pinfo); rdev_get_mpp()
287 ret = rdev->ops->dump_mpath(&rdev->wiphy, dev, idx, dst, next_hop, rdev_dump_mpath()
301 ret = rdev->ops->dump_mpp(&rdev->wiphy, dev, idx, dst, mpp, pinfo); rdev_dump_mpp()
312 ret = rdev->ops->get_mesh_config(&rdev->wiphy, dev, conf); rdev_get_mesh_config()
324 ret = rdev->ops->update_mesh_config(&rdev->wiphy, dev, mask, nconf); rdev_update_mesh_config()
336 ret = rdev->ops->join_mesh(&rdev->wiphy, dev, conf, setup); rdev_join_mesh()
347 ret = rdev->ops->leave_mesh(&rdev->wiphy, dev); rdev_leave_mesh()
358 ret = rdev->ops->join_ocb(&rdev->wiphy, dev, setup); rdev_join_ocb()
368 ret = rdev->ops->leave_ocb(&rdev->wiphy, dev); rdev_leave_ocb()
380 ret = rdev->ops->change_bss(&rdev->wiphy, dev, params); rdev_change_bss()
392 ret = rdev->ops->set_txq_params(&rdev->wiphy, dev, params); rdev_set_txq_params()
404 ret = rdev->ops->libertas_set_mesh_channel(&rdev->wiphy, dev, chan); rdev_libertas_set_mesh_channel()
415 ret = rdev->ops->set_monitor_channel(&rdev->wiphy, chandef); rdev_set_monitor_channel()
425 ret = rdev->ops->scan(&rdev->wiphy, request); rdev_scan()
436 ret = rdev->ops->auth(&rdev->wiphy, dev, req); rdev_auth()
447 ret = rdev->ops->assoc(&rdev->wiphy, dev, req); rdev_assoc()
458 ret = rdev->ops->deauth(&rdev->wiphy, dev, req); rdev_deauth()
469 ret = rdev->ops->disassoc(&rdev->wiphy, dev, req); rdev_disassoc()
480 ret = rdev->ops->connect(&rdev->wiphy, dev, sme); rdev_connect()
490 ret = rdev->ops->disconnect(&rdev->wiphy, dev, reason_code); rdev_disconnect()
501 ret = rdev->ops->join_ibss(&rdev->wiphy, dev, params); rdev_join_ibss()
511 ret = rdev->ops->leave_ibss(&rdev->wiphy, dev); rdev_leave_ibss()
521 ret = rdev->ops->set_wiphy_params(&rdev->wiphy, changed); rdev_set_wiphy_params()
532 ret = rdev->ops->set_tx_power(&rdev->wiphy, wdev, type, mbm); rdev_set_tx_power()
542 ret = rdev->ops->get_tx_power(&rdev->wiphy, wdev, dbm); rdev_get_tx_power()
552 ret = rdev->ops->set_wds_peer(&rdev->wiphy, dev, addr); rdev_set_wds_peer()
560 rdev->ops->rfkill_poll(&rdev->wiphy); rdev_rfkill_poll()
572 ret = rdev->ops->testmode_cmd(&rdev->wiphy, wdev, data, len); rdev_testmode_cmd()
584 ret = rdev->ops->testmode_dump(&rdev->wiphy, skb, cb, data, len); rdev_testmode_dump()
597 ret = rdev->ops->set_bitrate_mask(&rdev->wiphy, dev, peer, mask); rdev_set_bitrate_mask()
608 ret = rdev->ops->dump_survey(&rdev->wiphy, netdev, idx, info); rdev_dump_survey()
622 ret = rdev->ops->set_pmksa(&rdev->wiphy, netdev, pmksa); rdev_set_pmksa()
633 ret = rdev->ops->del_pmksa(&rdev->wiphy, netdev, pmksa); rdev_del_pmksa()
643 ret = rdev->ops->flush_pmksa(&rdev->wiphy, netdev); rdev_flush_pmksa()
656 ret = rdev->ops->remain_on_channel(&rdev->wiphy, wdev, chan, rdev_remain_on_channel()
668 ret = rdev->ops->cancel_remain_on_channel(&rdev->wiphy, wdev, cookie); rdev_cancel_remain_on_channel()
680 ret = rdev->ops->mgmt_tx(&rdev->wiphy, wdev, params, cookie); rdev_mgmt_tx()
691 ret = rdev->ops->mgmt_tx_cancel_wait(&rdev->wiphy, wdev, cookie); rdev_mgmt_tx_cancel_wait()
702 ret = rdev->ops->set_power_mgmt(&rdev->wiphy, dev, enabled, timeout); rdev_set_power_mgmt()
714 ret = rdev->ops->set_cqm_rssi_config(&rdev->wiphy, dev, rssi_thold, rdev_set_cqm_rssi_config()
726 ret = rdev->ops->set_cqm_txe_config(&rdev->wiphy, dev, rate, pkts, rdev_set_cqm_txe_config()
739 rdev->ops->mgmt_frame_register(&rdev->wiphy, wdev , frame_type, reg); rdev_mgmt_frame_register()
748 ret = rdev->ops->set_antenna(&rdev->wiphy, tx_ant, rx_ant); rdev_set_antenna()
758 ret = rdev->ops->get_antenna(&rdev->wiphy, tx_ant, rx_ant); rdev_get_antenna()
774 ret = rdev->ops->sched_scan_start(&rdev->wiphy, dev, request); rdev_sched_scan_start()
784 ret = rdev->ops->sched_scan_stop(&rdev->wiphy, dev); rdev_sched_scan_stop()
795 ret = rdev->ops->set_rekey_data(&rdev->wiphy, dev, data); rdev_set_rekey_data()
810 ret = rdev->ops->tdls_mgmt(&rdev->wiphy, dev, peer, action_code, rdev_tdls_mgmt()
823 ret = rdev->ops->tdls_oper(&rdev->wiphy, dev, peer, oper); rdev_tdls_oper()
834 ret = rdev->ops->probe_client(&rdev->wiphy, dev, peer, cookie); rdev_probe_client()
844 ret = rdev->ops->set_noack_map(&rdev->wiphy, dev, noack_map); rdev_set_noack_map()
857 ret = rdev->ops->get_channel(&rdev->wiphy, wdev, chandef); rdev_get_channel()
869 ret = rdev->ops->start_p2p_device(&rdev->wiphy, wdev); rdev_start_p2p_device()
878 rdev->ops->stop_p2p_device(&rdev->wiphy, wdev); rdev_stop_p2p_device()
889 ret = rdev->ops->set_mac_acl(&rdev->wiphy, dev, params); rdev_set_mac_acl()
901 ret = rdev->ops->update_ft_ies(&rdev->wiphy, dev, ftie); rdev_update_ft_ies()
914 ret = rdev->ops->crit_proto_start(&rdev->wiphy, wdev, rdev_crit_proto_start()
924 rdev->ops->crit_proto_stop(&rdev->wiphy, wdev); rdev_crit_proto_stop()
935 ret = rdev->ops->channel_switch(&rdev->wiphy, dev, params); rdev_channel_switch()
946 if (rdev->ops->set_qos_map) { rdev_set_qos_map()
948 ret = rdev->ops->set_qos_map(&rdev->wiphy, dev, qos_map); rdev_set_qos_map()
962 ret = rdev->ops->set_ap_chanwidth(&rdev->wiphy, dev, chandef); rdev_set_ap_chanwidth()
977 if (rdev->ops->add_tx_ts) rdev_add_tx_ts()
978 ret = rdev->ops->add_tx_ts(&rdev->wiphy, dev, tsid, peer, rdev_add_tx_ts()
992 if (rdev->ops->del_tx_ts) rdev_del_tx_ts()
993 ret = rdev->ops->del_tx_ts(&rdev->wiphy, dev, tsid, peer); rdev_del_tx_ts()
1008 ret = rdev->ops->tdls_channel_switch(&rdev->wiphy, dev, addr, rdev_tdls_channel_switch()
1019 rdev->ops->tdls_cancel_channel_switch(&rdev->wiphy, dev, addr); rdev_tdls_cancel_channel_switch()
H A Dap.c6 #include "rdev-ops.h"
17 if (!rdev->ops->stop_ap) __cfg80211_stop_ap()
/linux-4.4.14/drivers/ps3/
H A Dsys-manager-core.c35 * @ops: struct ps3_sys_manager_ops.
38 * register call back ops for power control. Copies data to the static
42 void ps3_sys_manager_register_ops(const struct ps3_sys_manager_ops *ops) ps3_sys_manager_register_ops() argument
44 BUG_ON(!ops); ps3_sys_manager_register_ops()
45 BUG_ON(!ops->dev); ps3_sys_manager_register_ops()
46 ps3_sys_manager_ops = ops ? *ops : ps3_sys_manager_ops; ps3_sys_manager_register_ops()
/linux-4.4.14/drivers/oprofile/
H A Dtimer_int.c110 int oprofile_timer_init(struct oprofile_operations *ops) oprofile_timer_init() argument
112 ops->create_files = NULL; oprofile_timer_init()
113 ops->setup = oprofile_hrtimer_setup; oprofile_timer_init()
114 ops->shutdown = oprofile_hrtimer_shutdown; oprofile_timer_init()
115 ops->start = oprofile_hrtimer_start; oprofile_timer_init()
116 ops->stop = oprofile_hrtimer_stop; oprofile_timer_init()
117 ops->cpu_type = "timer"; oprofile_timer_init()
H A Dnmi_timer_int.c155 int __init op_nmi_timer_init(struct oprofile_operations *ops) op_nmi_timer_init() argument
164 ops->create_files = NULL; op_nmi_timer_init()
165 ops->setup = nmi_timer_setup; op_nmi_timer_init()
166 ops->shutdown = nmi_timer_shutdown; op_nmi_timer_init()
167 ops->start = nmi_timer_start; op_nmi_timer_init()
168 ops->stop = nmi_timer_stop; op_nmi_timer_init()
169 ops->cpu_type = "timer"; op_nmi_timer_init()
H A Doprof.h36 int oprofile_timer_init(struct oprofile_operations *ops);
38 int op_nmi_timer_init(struct oprofile_operations *ops);
40 static inline int op_nmi_timer_init(struct oprofile_operations *ops) op_nmi_timer_init() argument
/linux-4.4.14/net/ceph/
H A Dauth.c67 if (ac->ops) ceph_auth_destroy()
68 ac->ops->destroy(ac); ceph_auth_destroy()
79 if (ac->ops && !ac->negotiating) ceph_auth_reset()
80 ac->ops->reset(ac); ceph_auth_reset()
158 ret = ac->ops->build_request(ac, p + sizeof(u32), end); ceph_build_auth_request()
161 ac->ops->name); ceph_build_auth_request()
223 ac->ops->destroy(ac); ceph_handle_auth_reply()
225 ac->ops = NULL; ceph_handle_auth_reply()
239 ret = ac->ops->handle_reply(ac, result, payload, payload_end); ceph_handle_auth_reply()
243 pr_err("auth method '%s' error %d\n", ac->ops->name, ret); ceph_handle_auth_reply()
264 else if (ac->ops->should_authenticate(ac)) ceph_build_auth()
275 if (ac->ops) ceph_auth_is_authenticated()
276 ret = ac->ops->is_authenticated(ac); ceph_auth_is_authenticated()
289 if (ac->ops && ac->ops->create_authorizer) ceph_auth_create_authorizer()
290 ret = ac->ops->create_authorizer(ac, peer_type, auth); ceph_auth_create_authorizer()
300 if (ac->ops && ac->ops->destroy_authorizer) ceph_auth_destroy_authorizer()
301 ac->ops->destroy_authorizer(ac, a); ceph_auth_destroy_authorizer()
313 if (ac->ops && ac->ops->update_authorizer) ceph_auth_update_authorizer()
314 ret = ac->ops->update_authorizer(ac, peer_type, a); ceph_auth_update_authorizer()
326 if (ac->ops && ac->ops->verify_authorizer_reply) ceph_auth_verify_authorizer_reply()
327 ret = ac->ops->verify_authorizer_reply(ac, a, len); ceph_auth_verify_authorizer_reply()
336 if (ac->ops && ac->ops->invalidate_authorizer) ceph_auth_invalidate_authorizer()
337 ac->ops->invalidate_authorizer(ac, peer_type); ceph_auth_invalidate_authorizer()
/linux-4.4.14/arch/arm/plat-versatile/
H A Dclock.c41 if (clk->ops && clk->ops->round) clk_round_rate()
42 ret = clk->ops->round(clk, rate); clk_round_rate()
50 if (clk->ops && clk->ops->set) clk_set_rate()
51 ret = clk->ops->set(clk, rate); clk_set_rate()
70 clk->ops->setvco(clk, vco); icst_clk_set()
/linux-4.4.14/drivers/clk/qcom/
H A Dgcc-msm8974.c79 .ops = &clk_pll_ops,
90 .ops = &clk_pll_vote_ops,
102 .ops = &clk_rcg2_ops,
114 .ops = &clk_rcg2_ops,
126 .ops = &clk_rcg2_ops,
142 .ops = &clk_pll_ops,
153 .ops = &clk_pll_vote_ops,
169 .ops = &clk_pll_ops,
180 .ops = &clk_pll_vote_ops,
199 .ops = &clk_rcg2_ops,
219 .ops = &clk_rcg2_ops,
244 .ops = &clk_rcg2_ops,
257 .ops = &clk_rcg2_ops,
271 .ops = &clk_rcg2_ops,
284 .ops = &clk_rcg2_ops,
298 .ops = &clk_rcg2_ops,
311 .ops = &clk_rcg2_ops,
325 .ops = &clk_rcg2_ops,
338 .ops = &clk_rcg2_ops,
352 .ops = &clk_rcg2_ops,
365 .ops = &clk_rcg2_ops,
379 .ops = &clk_rcg2_ops,
412 .ops = &clk_rcg2_ops,
426 .ops = &clk_rcg2_ops,
440 .ops = &clk_rcg2_ops,
454 .ops = &clk_rcg2_ops,
468 .ops = &clk_rcg2_ops,
482 .ops = &clk_rcg2_ops,
495 .ops = &clk_rcg2_ops,
509 .ops = &clk_rcg2_ops,
522 .ops = &clk_rcg2_ops,
536 .ops = &clk_rcg2_ops,
549 .ops = &clk_rcg2_ops,
563 .ops = &clk_rcg2_ops,
576 .ops = &clk_rcg2_ops,
590 .ops = &clk_rcg2_ops,
603 .ops = &clk_rcg2_ops,
617 .ops = &clk_rcg2_ops,
630 .ops = &clk_rcg2_ops,
644 .ops = &clk_rcg2_ops,
658 .ops = &clk_rcg2_ops,
672 .ops = &clk_rcg2_ops,
686 .ops = &clk_rcg2_ops,
700 .ops = &clk_rcg2_ops,
714 .ops = &clk_rcg2_ops,
728 .ops = &clk_rcg2_ops,
749 .ops = &clk_rcg2_ops,
770 .ops = &clk_rcg2_ops,
797 .ops = &clk_rcg2_ops,
811 .ops = &clk_rcg2_ops,
825 .ops = &clk_rcg2_ops,
843 .ops = &clk_rcg2_ops,
875 .ops = &clk_rcg2_ops,
897 .ops = &clk_rcg2_ops,
911 .ops = &clk_rcg2_ops,
925 .ops = &clk_rcg2_ops,
944 .ops = &clk_rcg2_ops,
962 .ops = &clk_rcg2_ops,
981 .ops = &clk_rcg2_ops,
1007 .ops = &clk_rcg2_ops,
1025 .ops = &clk_rcg2_ops,
1044 .ops = &clk_rcg2_ops,
1057 .ops = &clk_branch_simple_ops,
1073 .ops = &clk_branch2_ops,
1090 .ops = &clk_branch2_ops,
1107 .ops = &clk_branch2_ops,
1124 .ops = &clk_branch2_ops,
1141 .ops = &clk_branch2_ops,
1158 .ops = &clk_branch2_ops,
1175 .ops = &clk_branch2_ops,
1192 .ops = &clk_branch2_ops,
1209 .ops = &clk_branch2_ops,
1226 .ops = &clk_branch2_ops,
1243 .ops = &clk_branch2_ops,
1260 .ops = &clk_branch2_ops,
1277 .ops = &clk_branch2_ops,
1294 .ops = &clk_branch2_ops,
1311 .ops = &clk_branch2_ops,
1328 .ops = &clk_branch2_ops,
1345 .ops = &clk_branch2_ops,
1362 .ops = &clk_branch2_ops,
1379 .ops = &clk_branch2_ops,
1396 .ops = &clk_branch2_ops,
1413 .ops = &clk_branch2_ops,
1430 .ops = &clk_branch2_ops,
1447 .ops = &clk_branch2_ops,
1464 .ops = &clk_branch2_ops,
1481 .ops = &clk_branch2_ops,
1498 .ops = &clk_branch2_ops,
1515 .ops = &clk_branch2_ops,
1532 .ops = &clk_branch2_ops,
1549 .ops = &clk_branch2_ops,
1566 .ops = &clk_branch2_ops,
1583 .ops = &clk_branch2_ops,
1600 .ops = &clk_branch2_ops,
1617 .ops = &clk_branch2_ops,
1634 .ops = &clk_branch2_ops,
1651 .ops = &clk_branch2_ops,
1668 .ops = &clk_branch2_ops,
1685 .ops = &clk_branch2_ops,
1702 .ops = &clk_branch2_ops,
1719 .ops = &clk_branch2_ops,
1736 .ops = &clk_branch2_ops,
1753 .ops = &clk_branch2_ops,
1770 .ops = &clk_branch2_ops,
1788 .ops = &clk_branch2_ops,
1805 .ops = &clk_branch2_ops,
1822 .ops = &clk_branch2_ops,
1840 .ops = &clk_branch2_ops,
1857 .ops = &clk_branch2_ops,
1874 .ops = &clk_branch2_ops,
1891 .ops = &clk_branch2_ops,
1907 .ops = &clk_branch2_ops,
1923 .ops = &clk_branch2_ops,
1940 .ops = &clk_branch2_ops,
1956 .ops = &clk_branch2_ops,
1969 .ops = &clk_branch2_ops,
1986 .ops = &clk_branch2_ops,
2002 .ops = &clk_branch2_ops,
2019 .ops = &clk_branch2_ops,
2035 .ops = &clk_branch2_ops,
2052 .ops = &clk_branch2_ops,
2068 .ops = &clk_branch2_ops,
2084 .ops = &clk_branch2_ops,
2100 .ops = &clk_branch2_ops,
2117 .ops = &clk_branch2_ops,
2133 .ops = &clk_branch2_ops,
2150 .ops = &clk_branch2_ops,
2166 .ops = &clk_branch2_ops,
2183 .ops = &clk_branch2_ops,
2200 .ops = &clk_branch2_ops,
2216 .ops = &clk_branch2_ops,
2233 .ops = &clk_branch2_ops,
2249 .ops = &clk_branch2_ops,
2265 .ops = &clk_branch2_ops,
2282 .ops = &clk_branch2_ops,
2299 .ops = &clk_branch2_ops,
2315 .ops = &clk_branch2_ops,
2331 .ops = &clk_branch2_ops,
2348 .ops = &clk_branch2_ops,
2364 .ops = &clk_branch2_ops,
2381 .ops = &clk_branch2_ops,
2398 .ops = &clk_branch2_ops,
2414 .ops = &clk_branch2_ops,
2431 .ops = &clk_branch2_ops,
H A Dgcc-apq8084.c123 .ops = &clk_pll_ops,
134 .ops = &clk_pll_vote_ops,
146 .ops = &clk_rcg2_ops,
158 .ops = &clk_rcg2_ops,
170 .ops = &clk_rcg2_ops,
186 .ops = &clk_pll_ops,
197 .ops = &clk_pll_vote_ops,
213 .ops = &clk_pll_ops,
224 .ops = &clk_pll_vote_ops,
245 .ops = &clk_rcg2_ops,
264 .ops = &clk_rcg2_ops,
283 .ops = &clk_rcg2_ops,
299 .ops = &clk_branch2_ops,
316 .ops = &clk_branch2_ops,
336 .ops = &clk_rcg2_ops,
361 .ops = &clk_rcg2_ops,
374 .ops = &clk_rcg2_ops,
388 .ops = &clk_rcg2_ops,
401 .ops = &clk_rcg2_ops,
415 .ops = &clk_rcg2_ops,
428 .ops = &clk_rcg2_ops,
442 .ops = &clk_rcg2_ops,
455 .ops = &clk_rcg2_ops,
469 .ops = &clk_rcg2_ops,
482 .ops = &clk_rcg2_ops,
496 .ops = &clk_rcg2_ops,
529 .ops = &clk_rcg2_ops,
543 .ops = &clk_rcg2_ops,
557 .ops = &clk_rcg2_ops,
571 .ops = &clk_rcg2_ops,
585 .ops = &clk_rcg2_ops,
599 .ops = &clk_rcg2_ops,
612 .ops = &clk_rcg2_ops,
626 .ops = &clk_rcg2_ops,
639 .ops = &clk_rcg2_ops,
653 .ops = &clk_rcg2_ops,
666 .ops = &clk_rcg2_ops,
680 .ops = &clk_rcg2_ops,
693 .ops = &clk_rcg2_ops,
707 .ops = &clk_rcg2_ops,
720 .ops = &clk_rcg2_ops,
734 .ops = &clk_rcg2_ops,
747 .ops = &clk_rcg2_ops,
761 .ops = &clk_rcg2_ops,
775 .ops = &clk_rcg2_ops,
789 .ops = &clk_rcg2_ops,
803 .ops = &clk_rcg2_ops,
817 .ops = &clk_rcg2_ops,
831 .ops = &clk_rcg2_ops,
845 .ops = &clk_rcg2_ops,
866 .ops = &clk_rcg2_ops,
887 .ops = &clk_rcg2_ops,
908 .ops = &clk_rcg2_ops,
929 .ops = &clk_rcg2_ops,
943 .ops = &clk_rcg2_ops,
957 .ops = &clk_rcg2_ops,
976 .ops = &clk_rcg2_ops,
990 .ops = &clk_rcg2_ops,
1009 .ops = &clk_rcg2_ops,
1022 .ops = &clk_rcg2_ops,
1040 .ops = &clk_rcg2_ops,
1060 .ops = &clk_rcg2_ops,
1080 .ops = &clk_rcg2_ops,
1100 .ops = &clk_rcg2_ops,
1118 .ops = &clk_rcg2_ops,
1145 .ops = &clk_rcg2_ops,
1159 .ops = &clk_rcg2_ops,
1173 .ops = &clk_rcg2_ops,
1187 .ops = &clk_rcg2_ops,
1206 .ops = &clk_rcg2_ops,
1224 .ops = &clk_rcg2_ops,
1242 .ops = &clk_rcg2_ops,
1260 .ops = &clk_rcg2_ops,
1286 .ops = &clk_rcg2_ops,
1308 .ops = &clk_rcg2_ops,
1326 .ops = &clk_rcg2_ops,
1342 .ops = &clk_branch2_ops,
1361 .ops = &clk_rcg2_ops,
1379 .ops = &clk_rcg2_ops,
1395 .ops = &clk_branch2_ops,
1412 .ops = &clk_branch2_ops,
1429 .ops = &clk_branch2_ops,
1446 .ops = &clk_branch2_ops,
1463 .ops = &clk_branch2_ops,
1480 .ops = &clk_branch2_ops,
1497 .ops = &clk_branch2_ops,
1514 .ops = &clk_branch2_ops,
1531 .ops = &clk_branch2_ops,
1548 .ops = &clk_branch2_ops,
1565 .ops = &clk_branch2_ops,
1582 .ops = &clk_branch2_ops,
1599 .ops = &clk_branch2_ops,
1616 .ops = &clk_branch2_ops,
1633 .ops = &clk_branch2_ops,
1650 .ops = &clk_branch2_ops,
1667 .ops = &clk_branch2_ops,
1684 .ops = &clk_branch2_ops,
1701 .ops = &clk_branch2_ops,
1718 .ops = &clk_branch2_ops,
1735 .ops = &clk_branch2_ops,
1752 .ops = &clk_branch2_ops,
1769 .ops = &clk_branch2_ops,
1786 .ops = &clk_branch2_ops,
1803 .ops = &clk_branch2_ops,
1820 .ops = &clk_branch2_ops,
1837 .ops = &clk_branch2_ops,
1854 .ops = &clk_branch2_ops,
1871 .ops = &clk_branch2_ops,
1888 .ops = &clk_branch2_ops,
1905 .ops = &clk_branch2_ops,
1922 .ops = &clk_branch2_ops,
1939 .ops = &clk_branch2_ops,
1956 .ops = &clk_branch2_ops,
1973 .ops = &clk_branch2_ops,
1990 .ops = &clk_branch2_ops,
2007 .ops = &clk_branch2_ops,
2024 .ops = &clk_branch2_ops,
2041 .ops = &clk_branch2_ops,
2058 .ops = &clk_branch2_ops,
2075 .ops = &clk_branch2_ops,
2092 .ops = &clk_branch2_ops,
2110 .ops = &clk_branch2_ops,
2127 .ops = &clk_branch2_ops,
2144 .ops = &clk_branch2_ops,
2162 .ops = &clk_branch2_ops,
2179 .ops = &clk_branch2_ops,
2196 .ops = &clk_branch2_ops,
2214 .ops = &clk_branch2_ops,
2231 .ops = &clk_branch2_ops,
2248 .ops = &clk_branch2_ops,
2265 .ops = &clk_branch2_ops,
2281 .ops = &clk_branch2_ops,
2298 .ops = &clk_branch2_ops,
2315 .ops = &clk_branch2_ops,
2332 .ops = &clk_branch2_ops,
2349 .ops = &clk_branch2_ops,
2366 .ops = &clk_branch2_ops,
2383 .ops = &clk_branch2_ops,
2400 .ops = &clk_branch2_ops,
2417 .ops = &clk_branch2_ops,
2434 .ops = &clk_branch2_ops,
2451 .ops = &clk_branch2_ops,
2468 .ops = &clk_branch2_ops,
2484 .ops = &clk_branch2_ops,
2501 .ops = &clk_branch2_ops,
2518 .ops = &clk_branch2_ops,
2535 .ops = &clk_branch2_ops,
2552 .ops = &clk_branch2_ops,
2569 .ops = &clk_branch2_ops,
2586 .ops = &clk_branch2_ops,
2603 .ops = &clk_branch2_ops,
2620 .ops = &clk_branch2_ops,
2636 .ops = &clk_branch2_ops,
2653 .ops = &clk_branch2_ops,
2669 .ops = &clk_branch2_ops,
2685 .ops = &clk_branch2_ops,
2701 .ops = &clk_branch2_ops,
2718 .ops = &clk_branch2_ops,
2734 .ops = &clk_branch2_ops,
2751 .ops = &clk_branch2_ops,
2767 .ops = &clk_branch2_ops,
2784 .ops = &clk_branch2_ops,
2801 .ops = &clk_branch2_ops,
2818 .ops = &clk_branch2_ops,
2835 .ops = &clk_branch2_ops,
2851 .ops = &clk_branch2_ops,
2868 .ops = &clk_branch2_ops,
2885 .ops = &clk_branch2_ops,
2902 .ops = &clk_branch2_ops,
2919 .ops = &clk_branch2_ops,
2936 .ops = &clk_branch2_ops,
2953 .ops = &clk_branch2_ops,
2970 .ops = &clk_branch2_ops,
2987 .ops = &clk_branch2_ops,
3004 .ops = &clk_branch2_ops,
3021 .ops = &clk_branch2_ops,
3037 .ops = &clk_branch2_ops,
3053 .ops = &clk_branch2_ops,
3070 .ops = &clk_branch2_ops,
3087 .ops = &clk_branch2_ops,
3104 .ops = &clk_branch2_ops,
3120 .ops = &clk_branch2_ops,
3136 .ops = &clk_branch2_ops,
3153 .ops = &clk_branch2_ops,
3170 .ops = &clk_branch2_ops,
3186 .ops = &clk_branch2_ops,
3203 .ops = &clk_branch2_ops,
3220 .ops = &clk_branch2_ops,
3236 .ops = &clk_branch2_ops,
3253 .ops = &clk_branch2_ops,
H A Dmmcc-msm8974.c201 .ops = &clk_pll_ops,
212 .ops = &clk_pll_vote_ops,
228 .ops = &clk_pll_ops,
239 .ops = &clk_pll_vote_ops,
254 .ops = &clk_pll_ops,
270 .ops = &clk_pll_ops,
282 .ops = &clk_rcg2_ops,
307 .ops = &clk_rcg2_ops,
331 .ops = &clk_rcg2_ops,
350 .ops = &clk_rcg2_ops,
363 .ops = &clk_rcg2_ops,
376 .ops = &clk_rcg2_ops,
389 .ops = &clk_rcg2_ops,
419 .ops = &clk_rcg2_ops,
432 .ops = &clk_rcg2_ops,
461 .ops = &clk_rcg2_ops,
473 .ops = &clk_rcg2_ops,
496 .ops = &clk_rcg2_ops,
509 .ops = &clk_rcg2_ops,
522 .ops = &clk_rcg2_ops,
535 .ops = &clk_pixel_ops,
549 .ops = &clk_pixel_ops,
574 .ops = &clk_rcg2_ops,
592 .ops = &clk_rcg2_ops,
616 .ops = &clk_rcg2_ops,
630 .ops = &clk_rcg2_ops,
658 .ops = &clk_rcg2_ops,
671 .ops = &clk_rcg2_ops,
684 .ops = &clk_rcg2_ops,
697 .ops = &clk_rcg2_ops,
716 .ops = &clk_rcg2_ops,
729 .ops = &clk_rcg2_ops,
742 .ops = &clk_rcg2_ops,
764 .ops = &clk_rcg2_ops,
782 .ops = &clk_byte2_ops,
796 .ops = &clk_byte2_ops,
815 .ops = &clk_rcg2_ops,
834 .ops = &clk_rcg2_ops,
854 .ops = &clk_edp_pixel_ops,
872 .ops = &clk_rcg2_ops,
885 .ops = &clk_rcg2_ops,
903 .ops = &clk_byte_ops,
922 .ops = &clk_rcg2_ops,
940 .ops = &clk_rcg2_ops,
955 .ops = &clk_branch2_ops,
972 .ops = &clk_branch2_ops,
988 .ops = &clk_branch2_ops,
1005 .ops = &clk_branch2_ops,
1022 .ops = &clk_branch2_ops,
1039 .ops = &clk_branch2_ops,
1056 .ops = &clk_branch2_ops,
1072 .ops = &clk_branch2_ops,
1089 .ops = &clk_branch2_ops,
1106 .ops = &clk_branch2_ops,
1123 .ops = &clk_branch2_ops,
1140 .ops = &clk_branch2_ops,
1156 .ops = &clk_branch2_ops,
1173 .ops = &clk_branch2_ops,
1190 .ops = &clk_branch2_ops,
1207 .ops = &clk_branch2_ops,
1224 .ops = &clk_branch2_ops,
1240 .ops = &clk_branch2_ops,
1257 .ops = &clk_branch2_ops,
1274 .ops = &clk_branch2_ops,
1291 .ops = &clk_branch2_ops,
1308 .ops = &clk_branch2_ops,
1325 .ops = &clk_branch2_ops,
1342 .ops = &clk_branch2_ops,
1359 .ops = &clk_branch2_ops,
1376 .ops = &clk_branch2_ops,
1392 .ops = &clk_branch2_ops,
1409 .ops = &clk_branch2_ops,
1426 .ops = &clk_branch2_ops,
1443 .ops = &clk_branch2_ops,
1459 .ops = &clk_branch2_ops,
1475 .ops = &clk_branch2_ops,
1492 .ops = &clk_branch2_ops,
1509 .ops = &clk_branch2_ops,
1526 .ops = &clk_branch2_ops,
1543 .ops = &clk_branch2_ops,
1560 .ops = &clk_branch2_ops,
1576 .ops = &clk_branch2_ops,
1593 .ops = &clk_branch2_ops,
1610 .ops = &clk_branch2_ops,
1627 .ops = &clk_branch2_ops,
1643 .ops = &clk_branch2_ops,
1659 .ops = &clk_branch2_ops,
1676 .ops = &clk_branch2_ops,
1693 .ops = &clk_branch2_ops,
1710 .ops = &clk_branch2_ops,
1726 .ops = &clk_branch2_ops,
1742 .ops = &clk_branch2_ops,
1759 .ops = &clk_branch2_ops,
1775 .ops = &clk_branch2_ops,
1792 .ops = &clk_branch2_ops,
1809 .ops = &clk_branch2_ops,
1826 .ops = &clk_branch2_ops,
1843 .ops = &clk_branch2_ops,
1860 .ops = &clk_branch2_ops,
1877 .ops = &clk_branch2_ops,
1894 .ops = &clk_branch2_ops,
1911 .ops = &clk_branch2_ops,
1928 .ops = &clk_branch2_ops,
1944 .ops = &clk_branch2_ops,
1961 .ops = &clk_branch2_ops,
1978 .ops = &clk_branch2_ops,
1995 .ops = &clk_branch2_ops,
2012 .ops = &clk_branch2_ops,
2029 .ops = &clk_branch2_ops,
2046 .ops = &clk_branch2_ops,
2062 .ops = &clk_branch2_ops,
2078 .ops = &clk_branch2_ops,
2095 .ops = &clk_branch2_ops,
2113 .ops = &clk_branch2_ops,
2129 .ops = &clk_branch2_ops,
2146 .ops = &clk_branch2_ops,
2163 .ops = &clk_branch2_ops,
2180 .ops = &clk_branch2_ops,
2197 .ops = &clk_branch2_ops,
2214 .ops = &clk_branch2_ops,
2230 .ops = &clk_branch2_ops,
2246 .ops = &clk_branch2_ops,
2262 .ops = &clk_branch2_ops,
2278 .ops = &clk_branch2_ops,
2295 .ops = &clk_branch2_ops,
2312 .ops = &clk_branch2_ops,
H A Dmmcc-apq8084.c236 .ops = &clk_pll_ops,
247 .ops = &clk_pll_vote_ops,
263 .ops = &clk_pll_ops,
274 .ops = &clk_pll_vote_ops,
289 .ops = &clk_pll_ops,
305 .ops = &clk_pll_ops,
320 .ops = &clk_pll_ops,
332 .ops = &clk_rcg2_ops,
357 .ops = &clk_rcg2_ops,
381 .ops = &clk_rcg2_ops,
400 .ops = &clk_rcg2_ops,
413 .ops = &clk_rcg2_ops,
426 .ops = &clk_rcg2_ops,
439 .ops = &clk_rcg2_ops,
469 .ops = &clk_rcg2_ops,
482 .ops = &clk_rcg2_ops,
510 .ops = &clk_rcg2_ops,
522 .ops = &clk_rcg2_ops,
545 .ops = &clk_rcg2_ops,
558 .ops = &clk_rcg2_ops,
571 .ops = &clk_rcg2_ops,
584 .ops = &clk_pixel_ops,
598 .ops = &clk_pixel_ops,
623 .ops = &clk_rcg2_ops,
642 .ops = &clk_rcg2_ops,
661 .ops = &clk_rcg2_ops,
685 .ops = &clk_rcg2_ops,
699 .ops = &clk_rcg2_ops,
727 .ops = &clk_rcg2_ops,
741 .ops = &clk_rcg2_ops,
755 .ops = &clk_rcg2_ops,
769 .ops = &clk_rcg2_ops,
788 .ops = &clk_rcg2_ops,
801 .ops = &clk_rcg2_ops,
814 .ops = &clk_rcg2_ops,
837 .ops = &clk_rcg2_ops,
849 .ops = &clk_byte2_ops,
862 .ops = &clk_byte2_ops,
881 .ops = &clk_rcg2_ops,
900 .ops = &clk_rcg2_ops,
920 .ops = &clk_edp_pixel_ops,
938 .ops = &clk_rcg2_ops,
951 .ops = &clk_rcg2_ops,
969 .ops = &clk_byte_ops,
988 .ops = &clk_rcg2_ops,
1006 .ops = &clk_rcg2_ops,
1024 .ops = &clk_rcg2_ops,
1042 .ops = &clk_rcg2_ops,
1065 .ops = &clk_rcg2_ops,
1087 .ops = &clk_rcg2_ops,
1106 .ops = &clk_rcg2_ops,
1120 .ops = &clk_branch2_ops,
1137 .ops = &clk_branch2_ops,
1154 .ops = &clk_branch2_ops,
1171 .ops = &clk_branch2_ops,
1188 .ops = &clk_branch2_ops,
1205 .ops = &clk_branch2_ops,
1222 .ops = &clk_branch2_ops,
1239 .ops = &clk_branch2_ops,
1256 .ops = &clk_branch2_ops,
1272 .ops = &clk_branch2_ops,
1289 .ops = &clk_branch2_ops,
1305 .ops = &clk_branch2_ops,
1322 .ops = &clk_branch2_ops,
1339 .ops = &clk_branch2_ops,
1356 .ops = &clk_branch2_ops,
1373 .ops = &clk_branch2_ops,
1390 .ops = &clk_branch2_ops,
1407 .ops = &clk_branch2_ops,
1424 .ops = &clk_branch2_ops,
1441 .ops = &clk_branch2_ops,
1458 .ops = &clk_branch2_ops,
1474 .ops = &clk_branch2_ops,
1491 .ops = &clk_branch2_ops,
1508 .ops = &clk_branch2_ops,
1525 .ops = &clk_branch2_ops,
1542 .ops = &clk_branch2_ops,
1558 .ops = &clk_branch2_ops,
1575 .ops = &clk_branch2_ops,
1592 .ops = &clk_branch2_ops,
1609 .ops = &clk_branch2_ops,
1626 .ops = &clk_branch2_ops,
1643 .ops = &clk_branch2_ops,
1660 .ops = &clk_branch2_ops,
1677 .ops = &clk_branch2_ops,
1694 .ops = &clk_branch2_ops,
1711 .ops = &clk_branch2_ops,
1728 .ops = &clk_branch2_ops,
1745 .ops = &clk_branch2_ops,
1762 .ops = &clk_branch2_ops,
1778 .ops = &clk_branch2_ops,
1794 .ops = &clk_branch2_ops,
1811 .ops = &clk_branch2_ops,
1828 .ops = &clk_branch2_ops,
1845 .ops = &clk_branch2_ops,
1862 .ops = &clk_branch2_ops,
1878 .ops = &clk_branch2_ops,
1895 .ops = &clk_branch2_ops,
1912 .ops = &clk_branch2_ops,
1929 .ops = &clk_branch2_ops,
1946 .ops = &clk_branch2_ops,
1963 .ops = &clk_branch2_ops,
1980 .ops = &clk_branch2_ops,
1997 .ops = &clk_branch2_ops,
2014 .ops = &clk_branch2_ops,
2031 .ops = &clk_branch2_ops,
2048 .ops = &clk_branch2_ops,
2065 .ops = &clk_branch2_ops,
2082 .ops = &clk_branch2_ops,
2099 .ops = &clk_branch2_ops,
2116 .ops = &clk_branch2_ops,
2133 .ops = &clk_branch2_ops,
2150 .ops = &clk_branch2_ops,
2167 .ops = &clk_branch2_ops,
2184 .ops = &clk_branch2_ops,
2201 .ops = &clk_branch2_ops,
2218 .ops = &clk_branch2_ops,
2235 .ops = &clk_branch2_ops,
2252 .ops = &clk_branch2_ops,
2269 .ops = &clk_branch2_ops,
2286 .ops = &clk_branch2_ops,
2303 .ops = &clk_branch2_ops,
2320 .ops = &clk_branch2_ops,
2337 .ops = &clk_branch2_ops,
2354 .ops = &clk_branch2_ops,
2371 .ops = &clk_branch2_ops,
2388 .ops = &clk_branch2_ops,
2405 .ops = &clk_branch2_ops,
2422 .ops = &clk_branch2_ops,
2439 .ops = &clk_branch2_ops,
2456 .ops = &clk_branch2_ops,
2473 .ops = &clk_branch2_ops,
2490 .ops = &clk_branch2_ops,
2507 .ops = &clk_branch2_ops,
2524 .ops = &clk_branch2_ops,
2541 .ops = &clk_branch2_ops,
2558 .ops = &clk_branch2_ops,
2575 .ops = &clk_branch2_ops,
2592 .ops = &clk_branch2_ops,
2609 .ops = &clk_branch2_ops,
2626 .ops = &clk_branch2_ops,
2644 .ops = &clk_branch2_ops,
2660 .ops = &clk_branch2_ops,
2677 .ops = &clk_branch2_ops,
2695 .ops = &clk_branch2_ops,
2711 .ops = &clk_branch2_ops,
2729 .ops = &clk_branch2_ops,
2746 .ops = &clk_branch2_ops,
2763 .ops = &clk_branch2_ops,
2780 .ops = &clk_branch2_ops,
2797 .ops = &clk_branch2_ops,
2814 .ops = &clk_branch2_ops,
2831 .ops = &clk_branch2_ops,
2848 .ops = &clk_branch2_ops,
2865 .ops = &clk_branch2_ops,
2882 .ops = &clk_branch2_ops,
2899 .ops = &clk_branch2_ops,
2916 .ops = &clk_branch2_ops,
2933 .ops = &clk_branch2_ops,
2950 .ops = &clk_branch2_ops,
2967 .ops = &clk_branch2_ops,
2982 .ops = &clk_branch2_ops,
2999 .ops = &clk_branch2_ops,
3016 .ops = &clk_branch2_ops,
3033 .ops = &clk_branch2_ops,
H A Dgcc-msm8916.c281 .ops = &clk_pll_ops,
292 .ops = &clk_pll_vote_ops,
308 .ops = &clk_pll_ops,
319 .ops = &clk_pll_vote_ops,
335 .ops = &clk_pll_ops,
346 .ops = &clk_pll_vote_ops,
362 .ops = &clk_pll_ops,
373 .ops = &clk_pll_vote_ops,
385 .ops = &clk_rcg2_ops,
397 .ops = &clk_rcg2_ops,
417 .ops = &clk_rcg2_ops,
438 .ops = &clk_rcg2_ops,
457 .ops = &clk_rcg2_ops,
470 .ops = &clk_rcg2_ops,
498 .ops = &clk_rcg2_ops,
525 .ops = &clk_rcg2_ops,
544 .ops = &clk_rcg2_ops,
569 .ops = &clk_rcg2_ops,
582 .ops = &clk_rcg2_ops,
596 .ops = &clk_rcg2_ops,
609 .ops = &clk_rcg2_ops,
623 .ops = &clk_rcg2_ops,
636 .ops = &clk_rcg2_ops,
650 .ops = &clk_rcg2_ops,
663 .ops = &clk_rcg2_ops,
677 .ops = &clk_rcg2_ops,
690 .ops = &clk_rcg2_ops,
704 .ops = &clk_rcg2_ops,
737 .ops = &clk_rcg2_ops,
751 .ops = &clk_rcg2_ops,
770 .ops = &clk_rcg2_ops,
790 .ops = &clk_rcg2_ops,
804 .ops = &clk_rcg2_ops,
824 .ops = &clk_rcg2_ops,
845 .ops = &clk_rcg2_ops,
859 .ops = &clk_rcg2_ops,
878 .ops = &clk_rcg2_ops,
891 .ops = &clk_rcg2_ops,
911 .ops = &clk_rcg2_ops,
932 .ops = &clk_rcg2_ops,
951 .ops = &clk_rcg2_ops,
965 .ops = &clk_rcg2_ops,
979 .ops = &clk_rcg2_ops,
991 .ops = &clk_byte2_ops,
1010 .ops = &clk_rcg2_ops,
1035 .ops = &clk_rcg2_ops,
1048 .ops = &clk_pixel_ops,
1067 .ops = &clk_rcg2_ops,
1085 .ops = &clk_rcg2_ops,
1110 .ops = &clk_rcg2_ops,
1135 .ops = &clk_rcg2_ops,
1155 .ops = &clk_rcg2_ops,
1179 .ops = &clk_rcg2_shared_ops,
1197 .ops = &clk_rcg2_ops,
1223 .ops = &clk_rcg2_ops,
1239 .ops = &clk_branch2_ops,
1256 .ops = &clk_branch2_ops,
1297 .ops = &clk_rcg2_ops,
1313 .ops = &clk_branch2_ops,
1328 .ops = &clk_rcg2_ops,
1344 .ops = &clk_branch2_ops,
1359 .ops = &clk_rcg2_ops,
1375 .ops = &clk_branch2_ops,
1394 .ops = &clk_rcg2_ops,
1410 .ops = &clk_branch2_ops,
1427 .ops = &clk_branch2_ops,
1447 .ops = &clk_rcg2_ops,
1463 .ops = &clk_branch2_ops,
1479 .ops = &clk_branch2_ops,
1495 .ops = &clk_branch2_ops,
1517 .ops = &clk_rcg2_ops,
1533 .ops = &clk_branch2_ops,
1550 .ops = &clk_branch2_ops,
1567 .ops = &clk_branch2_ops,
1584 .ops = &clk_branch2_ops,
1601 .ops = &clk_branch2_ops,
1618 .ops = &clk_branch2_ops,
1635 .ops = &clk_branch2_ops,
1652 .ops = &clk_branch2_ops,
1669 .ops = &clk_branch2_ops,
1686 .ops = &clk_branch2_ops,
1703 .ops = &clk_branch2_ops,
1720 .ops = &clk_branch2_ops,
1737 .ops = &clk_branch2_ops,
1754 .ops = &clk_branch2_ops,
1771 .ops = &clk_branch2_ops,
1788 .ops = &clk_branch2_ops,
1805 .ops = &clk_branch2_ops,
1822 .ops = &clk_branch2_ops,
1839 .ops = &clk_branch2_ops,
1856 .ops = &clk_branch2_ops,
1873 .ops = &clk_branch2_ops,
1890 .ops = &clk_branch2_ops,
1907 .ops = &clk_branch2_ops,
1924 .ops = &clk_branch2_ops,
1941 .ops = &clk_branch2_ops,
1958 .ops = &clk_branch2_ops,
1975 .ops = &clk_branch2_ops,
1992 .ops = &clk_branch2_ops,
2009 .ops = &clk_branch2_ops,
2026 .ops = &clk_branch2_ops,
2043 .ops = &clk_branch2_ops,
2060 .ops = &clk_branch2_ops,
2077 .ops = &clk_branch2_ops,
2094 .ops = &clk_branch2_ops,
2111 .ops = &clk_branch2_ops,
2128 .ops = &clk_branch2_ops,
2145 .ops = &clk_branch2_ops,
2162 .ops = &clk_branch2_ops,
2179 .ops = &clk_branch2_ops,
2196 .ops = &clk_branch2_ops,
2213 .ops = &clk_branch2_ops,
2230 .ops = &clk_branch2_ops,
2247 .ops = &clk_branch2_ops,
2264 .ops = &clk_branch2_ops,
2281 .ops = &clk_branch2_ops,
2298 .ops = &clk_branch2_ops,
2315 .ops = &clk_branch2_ops,
2332 .ops = &clk_branch2_ops,
2350 .ops = &clk_branch2_ops,
2368 .ops = &clk_branch2_ops,
2386 .ops = &clk_branch2_ops,
2403 .ops = &clk_branch2_ops,
2420 .ops = &clk_branch2_ops,
2437 .ops = &clk_branch2_ops,
2454 .ops = &clk_branch2_ops,
2471 .ops = &clk_branch2_ops,
2488 .ops = &clk_branch2_ops,
2505 .ops = &clk_branch2_ops,
2522 .ops = &clk_branch2_ops,
2539 .ops = &clk_branch2_ops,
2556 .ops = &clk_branch2_ops,
2573 .ops = &clk_branch2_ops,
2590 .ops = &clk_branch2_ops,
2607 .ops = &clk_branch2_ops,
2624 .ops = &clk_branch2_ops,
2641 .ops = &clk_branch2_ops,
2658 .ops = &clk_branch2_ops,
2675 .ops = &clk_branch2_ops,
2692 .ops = &clk_branch2_ops,
2709 .ops = &clk_branch2_ops,
2726 .ops = &clk_branch2_ops,
2743 .ops = &clk_branch2_ops,
2756 .ops = &clk_rcg2_ops,
2772 .ops = &clk_branch2_ops,
2788 .ops = &clk_branch2_ops,
2805 .ops = &clk_branch2_ops,
2822 .ops = &clk_branch2_ops,
2839 .ops = &clk_branch2_ops,
2856 .ops = &clk_branch2_ops,
2873 .ops = &clk_branch2_ops,
2890 .ops = &clk_branch2_ops,
2907 .ops = &clk_branch2_ops,
2924 .ops = &clk_branch2_ops,
2941 .ops = &clk_branch2_ops,
2958 .ops = &clk_branch2_ops,
2975 .ops = &clk_branch2_ops,
2992 .ops = &clk_branch2_ops,
3009 .ops = &clk_branch2_ops,
3026 .ops = &clk_branch2_ops,
H A Dgcc-ipq806x.c47 .ops = &clk_pll_ops,
58 .ops = &clk_pll_vote_ops,
74 .ops = &clk_pll_ops,
85 .ops = &clk_pll_vote_ops,
101 .ops = &clk_pll_ops,
112 .ops = &clk_pll_vote_ops,
128 .ops = &clk_pll_ops,
139 .ops = &clk_pll_vote_ops,
172 .ops = &clk_pll_ops,
296 .ops = &clk_rcg_ops,
314 .ops = &clk_branch_ops,
347 .ops = &clk_rcg_ops,
365 .ops = &clk_branch_ops,
398 .ops = &clk_rcg_ops,
416 .ops = &clk_branch_ops,
449 .ops = &clk_rcg_ops,
467 .ops = &clk_branch_ops,
500 .ops = &clk_rcg_ops,
518 .ops = &clk_branch_ops,
551 .ops = &clk_rcg_ops,
569 .ops = &clk_branch_ops,
615 .ops = &clk_rcg_ops,
631 .ops = &clk_branch_ops,
664 .ops = &clk_rcg_ops,
680 .ops = &clk_branch_ops,
713 .ops = &clk_rcg_ops,
729 .ops = &clk_branch_ops,
762 .ops = &clk_rcg_ops,
778 .ops = &clk_branch_ops,
811 .ops = &clk_rcg_ops,
827 .ops = &clk_branch_ops,
860 .ops = &clk_rcg_ops,
876 .ops = &clk_branch_ops,
892 .ops = &clk_branch_ops,
908 .ops = &clk_branch_ops,
924 .ops = &clk_branch_ops,
940 .ops = &clk_branch_ops,
956 .ops = &clk_branch_ops,
972 .ops = &clk_branch_ops,
1016 .ops = &clk_rcg_ops,
1032 .ops = &clk_branch_ops,
1065 .ops = &clk_rcg_ops,
1081 .ops = &clk_branch_ops,
1114 .ops = &clk_rcg_ops,
1130 .ops = &clk_branch_ops,
1146 .ops = &clk_branch_ops,
1167 .ops = &clk_rcg_ops,
1183 .ops = &clk_branch_ops,
1229 .ops = &clk_rcg_ops,
1245 .ops = &clk_branch_ops,
1278 .ops = &clk_rcg_ops,
1294 .ops = &clk_branch_ops,
1310 .ops = &clk_branch_ops,
1326 .ops = &clk_branch_ops,
1364 .ops = &clk_rcg_ops,
1380 .ops = &clk_branch_ops,
1396 .ops = &clk_branch_ops,
1412 .ops = &clk_branch_ops,
1427 .ops = &clk_branch_ops,
1444 .ops = &clk_branch_ops,
1459 .ops = &clk_branch_ops,
1474 .ops = &clk_branch_ops,
1489 .ops = &clk_branch_ops,
1506 .ops = &clk_branch_ops,
1535 .ops = &clk_rcg_ops,
1551 .ops = &clk_branch_ops,
1565 .ops = &clk_branch_ops,
1579 .ops = &clk_branch_ops,
1593 .ops = &clk_branch_ops,
1607 .ops = &clk_branch_ops,
1631 .ops = &clk_rcg_ops,
1647 .ops = &clk_branch_ops,
1661 .ops = &clk_branch_ops,
1675 .ops = &clk_branch_ops,
1689 .ops = &clk_branch_ops,
1703 .ops = &clk_branch_ops,
1727 .ops = &clk_rcg_ops,
1743 .ops = &clk_branch_ops,
1757 .ops = &clk_branch_ops,
1771 .ops = &clk_branch_ops,
1785 .ops = &clk_branch_ops,
1799 .ops = &clk_branch_ops,
1828 .ops = &clk_rcg_ops,
1844 .ops = &clk_branch_ops,
1860 .ops = &clk_branch_ops,
1876 .ops = &clk_branch_ops,
1889 .ops = &clk_branch_ops,
1903 .ops = &clk_branch_ops,
1917 .ops = &clk_branch_ops,
1931 .ops = &clk_branch_ops,
1969 .ops = &clk_rcg_ops,
1985 .ops = &clk_branch_ops,
2001 .ops = &clk_branch_ops,
2039 .ops = &clk_rcg_ops,
2055 .ops = &clk_branch_ops,
2071 .ops = &clk_branch_ops,
2109 .ops = &clk_rcg_ops,
2125 .ops = &clk_branch_ops,
2141 .ops = &clk_branch_ops,
2174 .ops = &clk_rcg_ops,
2190 .ops = &clk_branch_ops,
2206 .ops = &clk_branch_ops,
2220 .ops = &clk_branch_ops,
2236 .ops = &clk_branch_ops,
2250 .ops = &clk_branch_ops,
2309 .ops = &clk_dyn_rcg_ops,
2328 .ops = &clk_branch_ops,
2381 .ops = &clk_dyn_rcg_ops,
2400 .ops = &clk_branch_ops,
2453 .ops = &clk_dyn_rcg_ops,
2472 .ops = &clk_branch_ops,
2525 .ops = &clk_dyn_rcg_ops,
2544 .ops = &clk_branch_ops,
2585 .ops = &clk_dyn_rcg_ops,
2602 .ops = &clk_branch_ops,
2663 .ops = &clk_dyn_rcg_ops,
2716 .ops = &clk_dyn_rcg_ops,
H A Dmmcc-msm8960.c128 .ops = &clk_pll_ops,
144 .ops = &clk_pll_ops,
205 .ops = &clk_rcg_ops,
220 .ops = &clk_branch_ops,
254 .ops = &clk_rcg_ops,
269 .ops = &clk_branch_ops,
303 .ops = &clk_rcg_ops,
318 .ops = &clk_branch_ops,
358 .ops = &clk_rcg_ops,
373 .ops = &clk_branch_ops,
389 .ops = &clk_branch_ops,
422 .ops = &clk_rcg_ops,
437 .ops = &clk_branch_ops,
453 .ops = &clk_branch_ops,
486 .ops = &clk_rcg_ops,
501 .ops = &clk_branch_ops,
517 .ops = &clk_branch_ops,
631 .ops = &clk_ops_pix_rdi,
648 .ops = &clk_ops_pix_rdi,
665 .ops = &clk_ops_pix_rdi,
682 .ops = &clk_ops_pix_rdi,
699 .ops = &clk_ops_pix_rdi,
738 .ops = &clk_rcg_ops,
755 .ops = &clk_branch_ops,
771 .ops = &clk_branch_ops,
787 .ops = &clk_branch_ops,
848 .ops = &clk_dyn_rcg_ops,
863 .ops = &clk_branch_ops,
908 .ops = &clk_dyn_rcg_ops,
923 .ops = &clk_branch_ops,
1009 .ops = &clk_dyn_rcg_ops,
1018 .ops = &clk_dyn_rcg_ops,
1031 .ops = &clk_branch_ops,
1087 .ops = &clk_dyn_rcg_ops,
1102 .ops = &clk_branch_ops,
1118 .ops = &clk_branch_ops,
1166 .ops = &clk_rcg_ops,
1181 .ops = &clk_branch_ops,
1214 .ops = &clk_rcg_ops,
1229 .ops = &clk_branch_ops,
1294 .ops = &clk_dyn_rcg_ops,
1309 .ops = &clk_branch_ops,
1325 .ops = &clk_branch_ops,
1341 .ops = &clk_branch_ops
1393 .ops = &clk_dyn_rcg_ops,
1408 .ops = &clk_branch_ops,
1456 .ops = &clk_rcg_bypass_ops,
1474 .ops = &clk_branch_ops,
1490 .ops = &clk_branch_ops,
1506 .ops = &clk_branch_ops,
1522 .ops = &clk_branch_ops,
1538 .ops = &clk_branch_ops,
1554 .ops = &clk_branch_ops,
1570 .ops = &clk_branch_ops,
1627 .ops = &clk_dyn_rcg_ops,
1642 .ops = &clk_branch_ops,
1678 .ops = &clk_rcg_ops,
1693 .ops = &clk_branch_ops,
1746 .ops = &clk_rcg_ops,
1761 .ops = &clk_branch_ops,
1777 .ops = &clk_branch_ops,
1791 .ops = &clk_branch_ops,
1807 .ops = &clk_branch_ops,
1823 .ops = &clk_branch_ops,
1837 .ops = &clk_branch_ops,
1853 .ops = &clk_branch_ops,
1869 .ops = &clk_branch_ops,
1885 .ops = &clk_branch_ops,
1899 .ops = &clk_branch_ops,
1915 .ops = &clk_branch_ops,
1931 .ops = &clk_branch_ops,
1947 .ops = &clk_branch_ops,
1963 .ops = &clk_branch_ops,
1979 .ops = &clk_branch_ops,
1993 .ops = &clk_branch_ops,
2007 .ops = &clk_branch_ops,
2021 .ops = &clk_branch_ops,
2037 .ops = &clk_branch_ops,
2051 .ops = &clk_branch_ops,
2067 .ops = &clk_branch_ops,
2099 .ops = &clk_rcg_bypass2_ops,
2115 .ops = &clk_branch_ops,
2147 .ops = &clk_rcg_bypass2_ops,
2163 .ops = &clk_branch_ops,
2186 .ops = &clk_rcg_bypass2_ops,
2202 .ops = &clk_branch_ops,
2225 .ops = &clk_rcg_bypass2_ops,
2241 .ops = &clk_branch_ops,
2264 .ops = &clk_rcg_esc_ops,
2279 .ops = &clk_branch_ops,
2302 .ops = &clk_rcg_esc_ops,
2317 .ops = &clk_branch_ops,
2349 .ops = &clk_rcg_pixel_ops,
2364 .ops = &clk_branch_ops,
2396 .ops = &clk_rcg_pixel_ops,
2411 .ops = &clk_branch_ops,
2427 .ops = &clk_branch_ops,
2443 .ops = &clk_branch_ops,
2459 .ops = &clk_branch_ops,
2475 .ops = &clk_branch_ops,
2491 .ops = &clk_branch_ops,
2505 .ops = &clk_branch_ops,
2521 .ops = &clk_branch_ops,
2535 .ops = &clk_branch_ops,
2549 .ops = &clk_branch_ops,
2563 .ops = &clk_branch_ops,
2579 .ops = &clk_branch_ops,
2593 .ops = &clk_branch_ops,
2607 .ops = &clk_branch_ops,
2623 .ops = &clk_branch_ops,
2637 .ops = &clk_branch_ops,
2651 .ops = &clk_branch_ops,
H A Dgcc-msm8660.c47 .ops = &clk_pll_ops,
58 .ops = &clk_pll_vote_ops,
135 .ops = &clk_rcg_ops,
153 .ops = &clk_branch_ops,
186 .ops = &clk_rcg_ops,
204 .ops = &clk_branch_ops,
237 .ops = &clk_rcg_ops,
255 .ops = &clk_branch_ops,
288 .ops = &clk_rcg_ops,
306 .ops = &clk_branch_ops,
339 .ops = &clk_rcg_ops,
357 .ops = &clk_branch_ops,
390 .ops = &clk_rcg_ops,
408 .ops = &clk_branch_ops,
441 .ops = &clk_rcg_ops,
459 .ops = &clk_branch_ops,
492 .ops = &clk_rcg_ops,
508 .ops = &clk_branch_ops,
541 .ops = &clk_rcg_ops,
557 .ops = &clk_branch_ops,
590 .ops = &clk_rcg_ops,
606 .ops = &clk_branch_ops,
639 .ops = &clk_rcg_ops,
655 .ops = &clk_branch_ops,
688 .ops = &clk_rcg_ops,
704 .ops = &clk_branch_ops,
750 .ops = &clk_rcg_ops,
766 .ops = &clk_branch_ops,
799 .ops = &clk_rcg_ops,
815 .ops = &clk_branch_ops,
848 .ops = &clk_rcg_ops,
864 .ops = &clk_branch_ops,
897 .ops = &clk_rcg_ops,
913 .ops = &clk_branch_ops,
946 .ops = &clk_rcg_ops,
962 .ops = &clk_branch_ops,
995 .ops = &clk_rcg_ops,
1011 .ops = &clk_branch_ops,
1044 .ops = &clk_rcg_ops,
1060 .ops = &clk_branch_ops,
1093 .ops = &clk_rcg_ops,
1109 .ops = &clk_branch_ops,
1142 .ops = &clk_rcg_ops,
1158 .ops = &clk_branch_ops,
1191 .ops = &clk_rcg_ops,
1207 .ops = &clk_branch_ops,
1240 .ops = &clk_rcg_ops,
1256 .ops = &clk_branch_ops,
1289 .ops = &clk_rcg_ops,
1305 .ops = &clk_branch_ops,
1351 .ops = &clk_rcg_ops,
1367 .ops = &clk_branch_ops,
1400 .ops = &clk_rcg_ops,
1416 .ops = &clk_branch_ops,
1449 .ops = &clk_rcg_ops,
1465 .ops = &clk_branch_ops,
1481 .ops = &clk_branch_ops,
1502 .ops = &clk_rcg_ops,
1518 .ops = &clk_branch_ops,
1561 .ops = &clk_rcg_ops,
1577 .ops = &clk_branch_ops,
1610 .ops = &clk_rcg_ops,
1626 .ops = &clk_branch_ops,
1659 .ops = &clk_rcg_ops,
1675 .ops = &clk_branch_ops,
1708 .ops = &clk_rcg_ops,
1724 .ops = &clk_branch_ops,
1757 .ops = &clk_rcg_ops,
1773 .ops = &clk_branch_ops,
1811 .ops = &clk_rcg_ops,
1827 .ops = &clk_branch_ops,
1865 .ops = &clk_rcg_ops,
1881 .ops = &clk_branch_ops,
1914 .ops = &clk_rcg_ops,
1932 .ops = &clk_branch_ops,
1948 .ops = &clk_branch_ops,
1981 .ops = &clk_rcg_ops,
1999 .ops = &clk_branch_ops,
2015 .ops = &clk_branch_ops,
2029 .ops = &clk_branch_ops,
2043 .ops = &clk_branch_ops,
2057 .ops = &clk_branch_ops,
2071 .ops = &clk_branch_ops,
2085 .ops = &clk_branch_ops,
2099 .ops = &clk_branch_ops,
2113 .ops = &clk_branch_ops,
2127 .ops = &clk_branch_ops,
2141 .ops = &clk_branch_ops,
2155 .ops = &clk_branch_ops,
2169 .ops = &clk_branch_ops,
2183 .ops = &clk_branch_ops,
2197 .ops = &clk_branch_ops,
2211 .ops = &clk_branch_ops,
2225 .ops = &clk_branch_ops,
2239 .ops = &clk_branch_ops,
2253 .ops = &clk_branch_ops,
2267 .ops = &clk_branch_ops,
2281 .ops = &clk_branch_ops,
2295 .ops = &clk_branch_ops,
2309 .ops = &clk_branch_ops,
2324 .ops = &clk_branch_ops,
2339 .ops = &clk_branch_ops,
2354 .ops = &clk_branch_ops,
2369 .ops = &clk_branch_ops,
2384 .ops = &clk_branch_ops,
2399 .ops = &clk_branch_ops,
2414 .ops = &clk_branch_ops,
2429 .ops = &clk_branch_ops,
2444 .ops = &clk_branch_ops,
2461 .ops = &clk_branch_ops,
H A Dgcc-msm8960.c47 .ops = &clk_pll_ops,
58 .ops = &clk_pll_vote_ops,
74 .ops = &clk_pll_ops,
85 .ops = &clk_pll_vote_ops,
101 .ops = &clk_pll_ops,
112 .ops = &clk_pll_vote_ops,
202 .ops = &clk_rcg_ops,
220 .ops = &clk_branch_ops,
253 .ops = &clk_rcg_ops,
271 .ops = &clk_branch_ops,
304 .ops = &clk_rcg_ops,
322 .ops = &clk_branch_ops,
355 .ops = &clk_rcg_ops,
373 .ops = &clk_branch_ops,
406 .ops = &clk_rcg_ops,
424 .ops = &clk_branch_ops,
457 .ops = &clk_rcg_ops,
475 .ops = &clk_branch_ops,
508 .ops = &clk_rcg_ops,
526 .ops = &clk_branch_ops,
559 .ops = &clk_rcg_ops,
575 .ops = &clk_branch_ops,
608 .ops = &clk_rcg_ops,
624 .ops = &clk_branch_ops,
657 .ops = &clk_rcg_ops,
673 .ops = &clk_branch_ops,
706 .ops = &clk_rcg_ops,
722 .ops = &clk_branch_ops,
755 .ops = &clk_rcg_ops,
771 .ops = &clk_branch_ops,
817 .ops = &clk_rcg_ops,
833 .ops = &clk_branch_ops,
866 .ops = &clk_rcg_ops,
882 .ops = &clk_branch_ops,
915 .ops = &clk_rcg_ops,
931 .ops = &clk_branch_ops,
964 .ops = &clk_rcg_ops,
980 .ops = &clk_branch_ops,
1013 .ops = &clk_rcg_ops,
1029 .ops = &clk_branch_ops,
1062 .ops = &clk_rcg_ops,
1078 .ops = &clk_branch_ops,
1111 .ops = &clk_rcg_ops,
1127 .ops = &clk_branch_ops,
1160 .ops = &clk_rcg_ops,
1176 .ops = &clk_branch_ops,
1209 .ops = &clk_rcg_ops,
1225 .ops = &clk_branch_ops,
1258 .ops = &clk_rcg_ops,
1274 .ops = &clk_branch_ops,
1307 .ops = &clk_rcg_ops,
1323 .ops = &clk_branch_ops,
1356 .ops = &clk_rcg_ops,
1372 .ops = &clk_branch_ops,
1418 .ops = &clk_rcg_ops,
1434 .ops = &clk_branch_ops,
1467 .ops = &clk_rcg_ops,
1483 .ops = &clk_branch_ops,
1516 .ops = &clk_rcg_ops,
1532 .ops = &clk_branch_ops,
1548 .ops = &clk_branch_ops,
1569 .ops = &clk_rcg_ops,
1585 .ops = &clk_branch_ops,
1631 .ops = &clk_rcg_ops,
1647 .ops = &clk_branch_ops,
1680 .ops = &clk_rcg_ops,
1696 .ops = &clk_branch_ops,
1729 .ops = &clk_rcg_ops,
1745 .ops = &clk_branch_ops,
1778 .ops = &clk_rcg_ops,
1794 .ops = &clk_branch_ops,
1827 .ops = &clk_rcg_ops,
1843 .ops = &clk_branch_ops,
1881 .ops = &clk_rcg_ops,
1897 .ops = &clk_branch_ops,
1935 .ops = &clk_rcg_ops,
1951 .ops = &clk_branch_ops,
1984 .ops = &clk_rcg_ops,
2000 .ops = &clk_branch_ops,
2033 .ops = &clk_rcg_ops,
2049 .ops = &clk_branch_ops,
2082 .ops = &clk_rcg_ops,
2100 .ops = &clk_branch_ops,
2116 .ops = &clk_branch_ops,
2132 .ops = &clk_branch_ops,
2145 .ops = &clk_branch_ops,
2178 .ops = &clk_rcg_ops,
2196 .ops = &clk_branch_ops,
2212 .ops = &clk_branch_ops,
2245 .ops = &clk_rcg_ops,
2263 .ops = &clk_branch_ops,
2279 .ops = &clk_branch_ops,
2295 .ops = &clk_branch_ops,
2309 .ops = &clk_branch_ops,
2325 .ops = &clk_branch_ops,
2341 .ops = &clk_branch_ops,
2357 .ops = &clk_branch_ops,
2373 .ops = &clk_branch_ops,
2389 .ops = &clk_branch_ops,
2405 .ops = &clk_branch_ops,
2421 .ops = &clk_branch_ops,
2437 .ops = &clk_branch_ops,
2453 .ops = &clk_branch_ops,
2469 .ops = &clk_branch_ops,
2485 .ops = &clk_branch_ops,
2501 .ops = &clk_branch_ops,
2517 .ops = &clk_branch_ops,
2533 .ops = &clk_branch_ops,
2547 .ops = &clk_branch_ops,
2561 .ops = &clk_branch_ops,
2577 .ops = &clk_branch_ops,
2591 .ops = &clk_branch_ops,
2605 .ops = &clk_branch_ops,
2619 .ops = &clk_branch_ops,
2635 .ops = &clk_branch_ops,
2651 .ops = &clk_branch_ops,
2667 .ops = &clk_branch_ops,
2683 .ops = &clk_branch_ops,
2699 .ops = &clk_branch_ops,
2714 .ops = &clk_branch_ops,
2731 .ops = &clk_branch_ops,
2762 .ops = &clk_rcg_ops,
2778 .ops = &clk_branch_ops,
2794 .ops = &clk_branch_ops,
2824 .ops = &clk_rcg_ops,
2840 .ops = &clk_branch_ops,
2856 .ops = &clk_branch_ops,
2872 .ops = &clk_branch_ops,
2885 .ops = &clk_branch_ops,
2899 .ops = &clk_branch_ops,
2913 .ops = &clk_branch_ops,
2927 .ops = &clk_branch_ops,
2941 .ops = &clk_branch_ops,
2955 .ops = &clk_branch_ops,
2969 .ops = &clk_branch_ops,
2984 .ops = &clk_branch_ops,
2999 .ops = &clk_branch_ops,
3014 .ops = &clk_branch_ops,
3031 .ops = &clk_branch_ops,
/linux-4.4.14/drivers/char/hw_random/
H A Docteon-rng.c23 struct hwrng ops; member in struct:octeon_rng
31 struct octeon_rng *p = container_of(rng, struct octeon_rng, ops); octeon_rng_init()
43 struct octeon_rng *p = container_of(rng, struct octeon_rng, ops); octeon_rng_cleanup()
52 struct octeon_rng *p = container_of(rng, struct octeon_rng, ops); octeon_rng_data_read()
64 struct hwrng ops = { octeon_rng_probe() local
96 rng->ops = ops; octeon_rng_probe()
98 platform_set_drvdata(pdev, &rng->ops); octeon_rng_probe()
99 ret = devm_hwrng_register(&pdev->dev, &rng->ops); octeon_rng_probe()
/linux-4.4.14/arch/mips/loongson64/lemote-2f/
H A Dclock.c63 if (likely(clkp->ops && clkp->ops->recalc)) propagate_rate()
64 clkp->ops->recalc(clkp); propagate_rate()
99 if (likely(clk->ops && clk->ops->set_rate)) { clk_set_rate()
103 ret = clk->ops->set_rate(clk, rate, 0); clk_set_rate()
128 if (likely(clk->ops && clk->ops->round_rate)) { clk_round_rate()
132 rounded = clk->ops->round_rate(clk, rate); clk_round_rate()
/linux-4.4.14/arch/blackfin/mach-bf609/
H A Dclock.c92 if (clk->ops && clk->ops->enable) clk_enable()
93 ret = clk->ops->enable(clk); clk_enable()
100 if (clk->ops && clk->ops->disable) clk_disable()
101 clk->ops->disable(clk); clk_disable()
109 if (clk->ops && clk->ops->get_rate) clk_get_rate()
110 ret = clk->ops->get_rate(clk); clk_get_rate()
118 if (clk->ops && clk->ops->round_rate) clk_round_rate()
119 ret = clk->ops->round_rate(clk, rate); clk_round_rate()
127 if (clk->ops && clk->ops->set_rate) clk_set_rate()
128 ret = clk->ops->set_rate(clk, rate); clk_set_rate()
282 .ops = &vco_ops,
289 .ops = &pll_ops,
299 .ops = &sys_clk_ops,
306 .ops = &cclk_ops,
312 .ops = &cclk_ops,
321 .ops = &sys_clk_ops,
331 .ops = &sys_clk_ops,
340 .ops = &sys_clk_ops,
349 .ops = &sys_clk_ops,
363 .ops = &dummy_clk_ops,
369 .ops = &dummy_clk_ops,
375 .ops = &dummy_clk_ops,
/linux-4.4.14/drivers/staging/goldfish/
H A Dgoldfish_nand.c133 struct mtd_oob_ops *ops) goldfish_nand_read_oob()
137 if (ofs + ops->len > mtd->size) goldfish_nand_read_oob()
139 if (ops->datbuf && ops->len && ops->len != mtd->writesize) goldfish_nand_read_oob()
141 if (ops->ooblen + ops->ooboffs > mtd->oobsize) goldfish_nand_read_oob()
149 if (ops->datbuf) goldfish_nand_read_oob()
150 ops->retlen = goldfish_nand_cmd(mtd, NAND_CMD_READ, ofs, goldfish_nand_read_oob()
151 ops->len, ops->datbuf); goldfish_nand_read_oob()
152 ofs += mtd->writesize + ops->ooboffs; goldfish_nand_read_oob()
153 if (ops->oobbuf) goldfish_nand_read_oob()
154 ops->oobretlen = goldfish_nand_cmd(mtd, NAND_CMD_READ, ofs, goldfish_nand_read_oob()
155 ops->ooblen, ops->oobbuf); goldfish_nand_read_oob()
160 ofs, ops->len, ops->ooblen, mtd->size, mtd->writesize); goldfish_nand_read_oob()
165 struct mtd_oob_ops *ops) goldfish_nand_write_oob()
169 if (ofs + ops->len > mtd->size) goldfish_nand_write_oob()
171 if (ops->len && ops->len != mtd->writesize) goldfish_nand_write_oob()
173 if (ops->ooblen + ops->ooboffs > mtd->oobsize) goldfish_nand_write_oob()
181 if (ops->datbuf) goldfish_nand_write_oob()
182 ops->retlen = goldfish_nand_cmd(mtd, NAND_CMD_WRITE, ofs, goldfish_nand_write_oob()
183 ops->len, ops->datbuf); goldfish_nand_write_oob()
184 ofs += mtd->writesize + ops->ooboffs; goldfish_nand_write_oob()
185 if (ops->oobbuf) goldfish_nand_write_oob()
186 ops->oobretlen = goldfish_nand_cmd(mtd, NAND_CMD_WRITE, ofs, goldfish_nand_write_oob()
187 ops->ooblen, ops->oobbuf); goldfish_nand_write_oob()
192 ofs, ops->len, ops->ooblen, mtd->size, mtd->writesize); goldfish_nand_write_oob()
132 goldfish_nand_read_oob(struct mtd_info *mtd, loff_t ofs, struct mtd_oob_ops *ops) goldfish_nand_read_oob() argument
164 goldfish_nand_write_oob(struct mtd_info *mtd, loff_t ofs, struct mtd_oob_ops *ops) goldfish_nand_write_oob() argument
/linux-4.4.14/drivers/media/dvb-frontends/
H A Dstb6000.c65 if (fe->ops.i2c_gate_ctrl) stb6000_sleep()
66 fe->ops.i2c_gate_ctrl(fe, 1); stb6000_sleep()
72 if (fe->ops.i2c_gate_ctrl) stb6000_sleep()
73 fe->ops.i2c_gate_ctrl(fe, 0); stb6000_sleep()
146 if (fe->ops.i2c_gate_ctrl) stb6000_set_params()
147 fe->ops.i2c_gate_ctrl(fe, 1); stb6000_set_params()
154 if (fe->ops.i2c_gate_ctrl) stb6000_set_params()
155 fe->ops.i2c_gate_ctrl(fe, 0); stb6000_set_params()
164 if (fe->ops.i2c_gate_ctrl) stb6000_set_params()
165 fe->ops.i2c_gate_ctrl(fe, 1); stb6000_set_params()
172 if (fe->ops.i2c_gate_ctrl) stb6000_set_params()
173 fe->ops.i2c_gate_ctrl(fe, 0); stb6000_set_params()
224 if (fe->ops.i2c_gate_ctrl) stb6000_attach()
225 fe->ops.i2c_gate_ctrl(fe, 1); stb6000_attach()
229 if (fe->ops.i2c_gate_ctrl) stb6000_attach()
230 fe->ops.i2c_gate_ctrl(fe, 0); stb6000_attach()
242 memcpy(&fe->ops.tuner_ops, &stb6000_tuner_ops, stb6000_attach()
H A Dtua6100.c59 if (fe->ops.i2c_gate_ctrl) tua6100_sleep()
60 fe->ops.i2c_gate_ctrl(fe, 1); tua6100_sleep()
64 if (fe->ops.i2c_gate_ctrl) tua6100_sleep()
65 fe->ops.i2c_gate_ctrl(fe, 0); tua6100_sleep()
132 if (fe->ops.i2c_gate_ctrl) tua6100_set_params()
133 fe->ops.i2c_gate_ctrl(fe, 1); tua6100_set_params()
137 if (fe->ops.i2c_gate_ctrl) tua6100_set_params()
138 fe->ops.i2c_gate_ctrl(fe, 1); tua6100_set_params()
142 if (fe->ops.i2c_gate_ctrl) tua6100_set_params()
143 fe->ops.i2c_gate_ctrl(fe, 1); tua6100_set_params()
147 if (fe->ops.i2c_gate_ctrl) tua6100_set_params()
148 fe->ops.i2c_gate_ctrl(fe, 0); tua6100_set_params()
182 if (fe->ops.i2c_gate_ctrl) tua6100_attach()
183 fe->ops.i2c_gate_ctrl(fe, 1); tua6100_attach()
185 if (fe->ops.i2c_gate_ctrl) tua6100_attach()
186 fe->ops.i2c_gate_ctrl(fe, 0); tua6100_attach()
198 memcpy(&fe->ops.tuner_ops, &tua6100_tuner_ops, sizeof(struct dvb_tuner_ops)); tua6100_attach()
H A Dtda826x.c63 if (fe->ops.i2c_gate_ctrl) tda826x_sleep()
64 fe->ops.i2c_gate_ctrl(fe, 1); tda826x_sleep()
68 if (fe->ops.i2c_gate_ctrl) tda826x_sleep()
69 fe->ops.i2c_gate_ctrl(fe, 0); tda826x_sleep()
112 if (fe->ops.i2c_gate_ctrl) tda826x_set_params()
113 fe->ops.i2c_gate_ctrl(fe, 1); tda826x_set_params()
117 if (fe->ops.i2c_gate_ctrl) tda826x_set_params()
118 fe->ops.i2c_gate_ctrl(fe, 0); tda826x_set_params()
156 if (fe->ops.i2c_gate_ctrl) tda826x_attach()
157 fe->ops.i2c_gate_ctrl(fe, 1); tda826x_attach()
159 if (fe->ops.i2c_gate_ctrl) tda826x_attach()
160 fe->ops.i2c_gate_ctrl(fe, 0); tda826x_attach()
175 memcpy(&fe->ops.tuner_ops, &tda826x_tuner_ops, sizeof(struct dvb_tuner_ops)); tda826x_attach()
H A Dzl10039.c150 if (fe->ops.i2c_gate_ctrl) zl10039_init()
151 fe->ops.i2c_gate_ctrl(fe, 1); zl10039_init()
164 if (fe->ops.i2c_gate_ctrl) zl10039_init()
165 fe->ops.i2c_gate_ctrl(fe, 0); zl10039_init()
176 if (fe->ops.i2c_gate_ctrl) zl10039_sleep()
177 fe->ops.i2c_gate_ctrl(fe, 1); zl10039_sleep()
183 if (fe->ops.i2c_gate_ctrl) zl10039_sleep()
184 fe->ops.i2c_gate_ctrl(fe, 0); zl10039_sleep()
224 if (fe->ops.i2c_gate_ctrl) zl10039_set_params()
225 fe->ops.i2c_gate_ctrl(fe, 1); zl10039_set_params()
240 if (fe->ops.i2c_gate_ctrl) zl10039_set_params()
241 fe->ops.i2c_gate_ctrl(fe, 0); zl10039_set_params()
279 if (fe->ops.i2c_gate_ctrl) zl10039_attach()
280 fe->ops.i2c_gate_ctrl(fe, 1); zl10039_attach()
284 if (fe->ops.i2c_gate_ctrl) zl10039_attach()
285 fe->ops.i2c_gate_ctrl(fe, 0); zl10039_attach()
289 if (fe->ops.i2c_gate_ctrl) zl10039_attach()
290 fe->ops.i2c_gate_ctrl(fe, 0); zl10039_attach()
295 strcpy(fe->ops.tuner_ops.info.name, zl10039_attach()
303 memcpy(&fe->ops.tuner_ops, &zl10039_ops, sizeof(struct dvb_tuner_ops)); zl10039_attach()
H A Dsi21xx.h32 if (fe->ops.write) si21xx_writeregister()
33 r = fe->ops.write(fe, buf, 2); si21xx_writeregister()
/linux-4.4.14/kernel/time/
H A Dposix-clock.c61 if (clk->ops.read) posix_clock_read()
62 err = clk->ops.read(clk, fp->f_flags, buf, count); posix_clock_read()
77 if (clk->ops.poll) posix_clock_poll()
78 result = clk->ops.poll(clk, fp, wait); posix_clock_poll()
93 if (clk->ops.fasync) posix_clock_fasync()
94 err = clk->ops.fasync(clk, fd, fp, on); posix_clock_fasync()
109 if (clk->ops.mmap) posix_clock_mmap()
110 err = clk->ops.mmap(clk, vma); posix_clock_mmap()
126 if (clk->ops.ioctl) posix_clock_ioctl()
127 err = clk->ops.ioctl(clk, cmd, arg); posix_clock_ioctl()
144 if (clk->ops.ioctl) posix_clock_compat_ioctl()
145 err = clk->ops.ioctl(clk, cmd, arg); posix_clock_compat_ioctl()
165 if (clk->ops.open) posix_clock_open()
166 err = clk->ops.open(clk, fp->f_mode); posix_clock_open()
184 if (clk->ops.release) posix_clock_release()
185 err = clk->ops.release(clk); posix_clock_release()
217 clk->cdev.owner = clk->ops.owner; posix_clock_register()
290 if (cd.clk->ops.clock_adjtime) pc_clock_adjtime()
291 err = cd.clk->ops.clock_adjtime(cd.clk, tx); pc_clock_adjtime()
309 if (cd.clk->ops.clock_gettime) pc_clock_gettime()
310 err = cd.clk->ops.clock_gettime(cd.clk, ts); pc_clock_gettime()
328 if (cd.clk->ops.clock_getres) pc_clock_getres()
329 err = cd.clk->ops.clock_getres(cd.clk, ts); pc_clock_getres()
352 if (cd.clk->ops.clock_settime) pc_clock_settime()
353 err = cd.clk->ops.clock_settime(cd.clk, ts); pc_clock_settime()
372 if (cd.clk->ops.timer_create) pc_timer_create()
373 err = cd.clk->ops.timer_create(cd.clk, kit); pc_timer_create()
392 if (cd.clk->ops.timer_delete) pc_timer_delete()
393 err = cd.clk->ops.timer_delete(cd.clk, kit); pc_timer_delete()
410 if (cd.clk->ops.timer_gettime) pc_timer_gettime()
411 cd.clk->ops.timer_gettime(cd.clk, kit, ts); pc_timer_gettime()
427 if (cd.clk->ops.timer_settime) pc_timer_settime()
428 err = cd.clk->ops.timer_settime(cd.clk, kit, flags, ts, old); pc_timer_settime()
/linux-4.4.14/drivers/crypto/ccp/
H A DMakefile2 ccp-objs := ccp-dev.o ccp-ops.o ccp-platform.o
/linux-4.4.14/arch/blackfin/oprofile/
H A Dbfin_oprofile.c11 int __init oprofile_arch_init(struct oprofile_operations *ops) oprofile_arch_init() argument
/linux-4.4.14/fs/adfs/
H A Ddir.c24 struct adfs_dir_ops *ops = ADFS_SB(sb)->s_dir; adfs_readdir() local
32 ret = ops->read(sb, inode->i_ino, inode->i_size, &dir); adfs_readdir()
49 ret = ops->setpos(&dir, ctx->pos - 2); adfs_readdir()
52 while (ops->getnext(&dir, &obj) == 0) { adfs_readdir()
63 ops->free(&dir); adfs_readdir()
72 struct adfs_dir_ops *ops = ADFS_SB(sb)->s_dir; adfs_dir_update() local
78 if (!ops->update) { adfs_dir_update()
83 ret = ops->read(sb, obj->parent_id, 0, &dir); adfs_dir_update()
88 ret = ops->update(&dir, obj); adfs_dir_update()
92 int err = ops->sync(&dir); adfs_dir_update()
97 ops->free(&dir); adfs_dir_update()
132 struct adfs_dir_ops *ops = ADFS_SB(sb)->s_dir; adfs_dir_lookup_byname() local
136 ret = ops->read(sb, inode->i_ino, inode->i_size, &dir); adfs_dir_lookup_byname()
165 ret = ops->setpos(&dir, 0); adfs_dir_lookup_byname()
170 while (ops->getnext(&dir, obj) == 0) { adfs_dir_lookup_byname()
181 ops->free(&dir); adfs_dir_lookup_byname()
/linux-4.4.14/arch/parisc/oprofile/
H A Dinit.c15 int __init oprofile_arch_init(struct oprofile_operations *ops) oprofile_arch_init() argument
/linux-4.4.14/arch/m32r/oprofile/
H A Dinit.c15 int __init oprofile_arch_init(struct oprofile_operations *ops) oprofile_arch_init() argument
/linux-4.4.14/arch/arm/mach-versatile/include/mach/
H A Dclkdev.h8 const struct clk_ops *ops; member in struct:clk
/linux-4.4.14/net/nfc/hci/
H A Dllc.c55 int nfc_llc_register(const char *name, struct nfc_llc_ops *ops) nfc_llc_register() argument
68 llc_engine->ops = ops; nfc_llc_register()
117 llc->data = llc_engine->ops->init(hdev, xmit_to_drv, rcv_to_hci, nfc_llc_allocate()
125 llc->ops = llc_engine->ops; nfc_llc_allocate()
132 llc->ops->deinit(llc); nfc_llc_free()
145 return llc->ops->start(llc); nfc_llc_start()
151 return llc->ops->stop(llc); nfc_llc_stop()
157 llc->ops->rcv_from_drv(llc, skb); nfc_llc_rcv_from_drv()
162 return llc->ops->xmit_from_hci(llc, skb); nfc_llc_xmit_from_hci()
H A Dcore.c252 if (hdev->ops->cmd_received) nfc_hci_cmd_received()
253 hdev->ops->cmd_received(hdev, pipe, cmd, skb); nfc_hci_cmd_received()
333 if (hdev->ops->complete_target_discovered) { nfc_hci_target_discovered()
334 r = hdev->ops->complete_target_discovered(hdev, gate, nfc_hci_target_discovered()
344 if (hdev->ops->target_from_gate) nfc_hci_target_discovered()
345 r = hdev->ops->target_from_gate(hdev, gate, targets); nfc_hci_target_discovered()
351 if (hdev->ops->complete_target_discovered) { nfc_hci_target_discovered()
352 r = hdev->ops->complete_target_discovered(hdev, gate, nfc_hci_target_discovered()
387 if (hdev->ops->event_received) { nfc_hci_event_received()
388 r = hdev->ops->event_received(hdev, pipe, event, skb); nfc_hci_event_received()
474 skb->len) == 0) && hdev->ops->load_session) { hci_dev_session_init()
477 r = hdev->ops->load_session(hdev); hci_dev_session_init()
573 if (hdev->ops->open) { hci_dev_up()
574 r = hdev->ops->open(hdev); hci_dev_up()
592 if (hdev->ops->hci_ready) { hci_dev_up()
593 r = hdev->ops->hci_ready(hdev); hci_dev_up()
608 if (hdev->ops->close) hci_dev_up()
609 hdev->ops->close(hdev); hci_dev_up()
620 if (hdev->ops->close) hci_dev_down()
621 hdev->ops->close(hdev); hci_dev_down()
633 if (hdev->ops->start_poll) hci_start_poll()
634 return hdev->ops->start_poll(hdev, im_protocols, tm_protocols); hci_start_poll()
645 if (hdev->ops->stop_poll) hci_stop_poll()
646 hdev->ops->stop_poll(hdev); hci_stop_poll()
657 if (!hdev->ops->dep_link_up) hci_dep_link_up()
660 return hdev->ops->dep_link_up(hdev, target, comm_mode, hci_dep_link_up()
668 if (!hdev->ops->dep_link_down) hci_dep_link_down()
671 return hdev->ops->dep_link_down(hdev); hci_dep_link_down()
723 if (hdev->ops->im_transceive) { hci_transceive()
724 r = hdev->ops->im_transceive(hdev, target, skb, cb, hci_transceive()
741 if (hdev->ops->im_transceive) { hci_transceive()
742 r = hdev->ops->im_transceive(hdev, target, skb, cb, hci_transceive()
761 if (!hdev->ops->tm_send) { hci_tm_send()
766 return hdev->ops->tm_send(hdev, skb); hci_tm_send()
774 if (!hdev->ops->check_presence) hci_check_presence()
777 return hdev->ops->check_presence(hdev, target); hci_check_presence()
784 if (hdev->ops->discover_se) hci_discover_se()
785 return hdev->ops->discover_se(hdev); hci_discover_se()
794 if (hdev->ops->enable_se) hci_enable_se()
795 return hdev->ops->enable_se(hdev, se_idx); hci_enable_se()
804 if (hdev->ops->disable_se) hci_disable_se()
805 return hdev->ops->disable_se(hdev, se_idx); hci_disable_se()
816 if (hdev->ops->se_io) hci_se_io()
817 return hdev->ops->se_io(hdev, se_idx, apdu, hci_se_io()
914 if (!hdev->ops->fw_download) hci_fw_download()
917 return hdev->ops->fw_download(hdev, firmware_name); hci_fw_download()
939 struct nfc_hci_dev *nfc_hci_allocate_device(struct nfc_hci_ops *ops, nfc_hci_allocate_device() argument
950 if (ops->xmit == NULL) nfc_hci_allocate_device()
960 hdev->llc = nfc_llc_allocate(llc_name, hdev, ops->xmit, nfc_hci_allocate_device()
977 hdev->ops = ops; nfc_hci_allocate_device()
/linux-4.4.14/kernel/trace/
H A Dftrace.c106 static void ftrace_update_trampoline(struct ftrace_ops *ops);
154 static inline void ftrace_ops_init(struct ftrace_ops *ops) ftrace_ops_init() argument
157 if (!(ops->flags & FTRACE_OPS_FL_INITIALIZED)) { ftrace_ops_init()
158 mutex_init(&ops->local_hash.regex_lock); ftrace_ops_init()
159 ops->func_hash = &ops->local_hash; ftrace_ops_init()
160 ops->flags |= FTRACE_OPS_FL_INITIALIZED; ftrace_ops_init()
166 * ftrace_nr_registered_ops - return number of ops registered
172 struct ftrace_ops *ops; ftrace_nr_registered_ops() local
177 for (ops = ftrace_ops_list; ftrace_nr_registered_ops()
178 ops != &ftrace_list_end; ops = ops->next) ftrace_nr_registered_ops()
206 static void control_ops_disable_all(struct ftrace_ops *ops) control_ops_disable_all() argument
211 *per_cpu_ptr(ops->disabled, cpu) = 1; control_ops_disable_all()
214 static int control_ops_alloc(struct ftrace_ops *ops) control_ops_alloc() argument
222 ops->disabled = disabled; control_ops_alloc()
223 control_ops_disable_all(ops); control_ops_alloc()
256 static ftrace_func_t ftrace_ops_get_list_func(struct ftrace_ops *ops) ftrace_ops_get_list_func() argument
259 * If this is a dynamic ops or we force list func, ftrace_ops_get_list_func()
262 if (ops->flags & FTRACE_OPS_FL_DYNAMIC || FTRACE_FORCE_LIST_FUNC) ftrace_ops_get_list_func()
265 return ftrace_ops_get_func(ops); ftrace_ops_get_list_func()
275 * will point to the ops we want. update_ftrace_function()
284 * If we are at the end of the list and this ops is update_ftrace_function()
285 * recursion safe and not dynamic and the arch supports passing ops, update_ftrace_function()
323 * Set the function to the list ops, which will call the update_ftrace_function()
333 /* Now all cpus are using the list ops. */ update_ftrace_function()
350 static void add_ftrace_ops(struct ftrace_ops **list, struct ftrace_ops *ops) add_ftrace_ops() argument
352 ops->next = *list; add_ftrace_ops()
354 * We are entering ops into the list but another add_ftrace_ops()
356 * the ops->next pointer is valid before another CPU sees add_ftrace_ops()
357 * the ops pointer included into the list. add_ftrace_ops()
359 rcu_assign_pointer(*list, ops); add_ftrace_ops()
362 static int remove_ftrace_ops(struct ftrace_ops **list, struct ftrace_ops *ops) remove_ftrace_ops() argument
370 if (*list == ops && ops->next == &ftrace_list_end) { remove_ftrace_ops()
376 if (*p == ops) remove_ftrace_ops()
379 if (*p != ops) remove_ftrace_ops()
388 struct ftrace_ops *ops) add_ftrace_list_ops()
391 add_ftrace_ops(list, ops); add_ftrace_list_ops()
398 struct ftrace_ops *ops) remove_ftrace_list_ops()
400 int ret = remove_ftrace_ops(list, ops); remove_ftrace_list_ops()
406 static void ftrace_update_trampoline(struct ftrace_ops *ops);
408 static int __register_ftrace_function(struct ftrace_ops *ops) __register_ftrace_function() argument
410 if (ops->flags & FTRACE_OPS_FL_DELETED) __register_ftrace_function()
413 if (WARN_ON(ops->flags & FTRACE_OPS_FL_ENABLED)) __register_ftrace_function()
422 if (ops->flags & FTRACE_OPS_FL_SAVE_REGS && __register_ftrace_function()
423 !(ops->flags & FTRACE_OPS_FL_SAVE_REGS_IF_SUPPORTED)) __register_ftrace_function()
426 if (ops->flags & FTRACE_OPS_FL_SAVE_REGS_IF_SUPPORTED) __register_ftrace_function()
427 ops->flags |= FTRACE_OPS_FL_SAVE_REGS; __register_ftrace_function()
430 if (!core_kernel_data((unsigned long)ops)) __register_ftrace_function()
431 ops->flags |= FTRACE_OPS_FL_DYNAMIC; __register_ftrace_function()
433 if (ops->flags & FTRACE_OPS_FL_CONTROL) { __register_ftrace_function()
434 if (control_ops_alloc(ops)) __register_ftrace_function()
436 add_ftrace_list_ops(&ftrace_control_list, &control_ops, ops); __register_ftrace_function()
438 ops = &control_ops; __register_ftrace_function()
440 add_ftrace_ops(&ftrace_ops_list, ops); __register_ftrace_function()
443 ops->saved_func = ops->func; __register_ftrace_function()
445 if (ops->flags & FTRACE_OPS_FL_PID && ftrace_pids_enabled()) __register_ftrace_function()
446 ops->func = ftrace_pid_func; __register_ftrace_function()
448 ftrace_update_trampoline(ops); __register_ftrace_function()
456 static int __unregister_ftrace_function(struct ftrace_ops *ops) __unregister_ftrace_function() argument
460 if (WARN_ON(!(ops->flags & FTRACE_OPS_FL_ENABLED))) __unregister_ftrace_function()
463 if (ops->flags & FTRACE_OPS_FL_CONTROL) { __unregister_ftrace_function()
465 &control_ops, ops); __unregister_ftrace_function()
467 ret = remove_ftrace_ops(&ftrace_ops_list, ops); __unregister_ftrace_function()
475 ops->func = ops->saved_func; __unregister_ftrace_function()
873 struct ftrace_ops *ops, struct pt_regs *regs) function_profile_call()
1126 struct ftrace_probe_ops *ops; member in struct:ftrace_func_probe
1179 * Some of the ops may be dynamically allocated, is_ftrace_trampoline()
1339 void ftrace_free_filter(struct ftrace_ops *ops) ftrace_free_filter() argument
1341 ftrace_ops_init(ops); ftrace_free_filter()
1342 free_ftrace_hash(ops->func_hash->filter_hash); ftrace_free_filter()
1343 free_ftrace_hash(ops->func_hash->notrace_hash); ftrace_free_filter()
1404 ftrace_hash_rec_disable_modify(struct ftrace_ops *ops, int filter_hash);
1406 ftrace_hash_rec_enable_modify(struct ftrace_ops *ops, int filter_hash);
1408 static int ftrace_hash_ipmodify_update(struct ftrace_ops *ops,
1412 ftrace_hash_move(struct ftrace_ops *ops, int enable, ftrace_hash_move() argument
1425 if (ops->flags & FTRACE_OPS_FL_IPMODIFY && !enable) ftrace_hash_move()
1464 ret = ftrace_hash_ipmodify_update(ops, new_hash);
1475 ftrace_hash_rec_disable_modify(ops, enable);
1479 ftrace_hash_rec_enable_modify(ops, enable);
1500 * Test the hashes for this ops to see if we want to call
1501 * the ops->func or not.
1503 * It's a match if the ip is in the ops->filter_hash or
1506 * the ip is not in the ops->notrace_hash.
1512 ftrace_ops_test(struct ftrace_ops *ops, unsigned long ip, void *regs) ftrace_ops_test() argument
1519 * There's a small race when adding ops that the ftrace handler ftrace_ops_test()
1523 if (regs == NULL && (ops->flags & FTRACE_OPS_FL_SAVE_REGS)) ftrace_ops_test()
1527 hash.filter_hash = rcu_dereference_raw_notrace(ops->func_hash->filter_hash); ftrace_ops_test()
1528 hash.notrace_hash = rcu_dereference_raw_notrace(ops->func_hash->notrace_hash); ftrace_ops_test()
1622 /* Test if ops registered to this rec needs regs */ test_rec_ops_needs_regs()
1625 struct ftrace_ops *ops; test_rec_ops_needs_regs() local
1628 for (ops = ftrace_ops_list; test_rec_ops_needs_regs()
1629 ops != &ftrace_list_end; ops = ops->next) { test_rec_ops_needs_regs()
1631 if (ftrace_ops_test(ops, rec->ip, rec)) { test_rec_ops_needs_regs()
1632 if (ops->flags & FTRACE_OPS_FL_SAVE_REGS) { test_rec_ops_needs_regs()
1642 static void __ftrace_hash_rec_update(struct ftrace_ops *ops, __ftrace_hash_rec_update() argument
1653 /* Only update if the ops has been registered */ __ftrace_hash_rec_update()
1654 if (!(ops->flags & FTRACE_OPS_FL_ENABLED)) __ftrace_hash_rec_update()
1669 hash = ops->func_hash->filter_hash; __ftrace_hash_rec_update()
1670 other_hash = ops->func_hash->notrace_hash; __ftrace_hash_rec_update()
1675 hash = ops->func_hash->notrace_hash; __ftrace_hash_rec_update()
1676 other_hash = ops->func_hash->filter_hash; __ftrace_hash_rec_update()
1727 * function, and the ops has a trampoline registered do_for_each_ftrace_rec()
1730 if (ftrace_rec_count(rec) == 1 && ops->trampoline) do_for_each_ftrace_rec()
1742 * If any ops wants regs saved for this function do_for_each_ftrace_rec()
1743 * then all ops will get saved regs. do_for_each_ftrace_rec()
1745 if (ops->flags & FTRACE_OPS_FL_SAVE_REGS) do_for_each_ftrace_rec()
1753 * If the rec had REGS enabled and the ops that is do_for_each_ftrace_rec()
1755 * still any ops for this record that wants regs. do_for_each_ftrace_rec()
1760 ops->flags & FTRACE_OPS_FL_SAVE_REGS) { do_for_each_ftrace_rec()
1768 * there is only a single ops attached to it. do_for_each_ftrace_rec()
1771 * decremented to one, and the ops that is left do_for_each_ftrace_rec()
1788 static void ftrace_hash_rec_disable(struct ftrace_ops *ops, ftrace_hash_rec_disable() argument
1791 __ftrace_hash_rec_update(ops, filter_hash, 0); ftrace_hash_rec_disable()
1794 static void ftrace_hash_rec_enable(struct ftrace_ops *ops, ftrace_hash_rec_enable() argument
1797 __ftrace_hash_rec_update(ops, filter_hash, 1); ftrace_hash_rec_enable()
1800 static void ftrace_hash_rec_update_modify(struct ftrace_ops *ops, ftrace_hash_rec_update_modify() argument
1805 __ftrace_hash_rec_update(ops, filter_hash, inc); ftrace_hash_rec_update_modify()
1807 if (ops->func_hash != &global_ops.local_hash) ftrace_hash_rec_update_modify()
1811 * If the ops shares the global_ops hash, then we need to update ftrace_hash_rec_update_modify()
1812 * all ops that are enabled and use this hash. ftrace_hash_rec_update_modify()
1816 if (op == ops) do_for_each_ftrace_op()
1823 static void ftrace_hash_rec_disable_modify(struct ftrace_ops *ops, ftrace_hash_rec_disable_modify() argument
1826 ftrace_hash_rec_update_modify(ops, filter_hash, 0); ftrace_hash_rec_disable_modify()
1829 static void ftrace_hash_rec_enable_modify(struct ftrace_ops *ops, ftrace_hash_rec_enable_modify() argument
1832 ftrace_hash_rec_update_modify(ops, filter_hash, 1); ftrace_hash_rec_enable_modify()
1844 static int __ftrace_hash_update_ipmodify(struct ftrace_ops *ops, __ftrace_hash_update_ipmodify() argument
1852 /* Only update if the ops has been registered */ __ftrace_hash_update_ipmodify()
1853 if (!(ops->flags & FTRACE_OPS_FL_ENABLED)) __ftrace_hash_update_ipmodify()
1856 if (!(ops->flags & FTRACE_OPS_FL_IPMODIFY)) __ftrace_hash_update_ipmodify()
1908 static int ftrace_hash_ipmodify_enable(struct ftrace_ops *ops) ftrace_hash_ipmodify_enable() argument
1910 struct ftrace_hash *hash = ops->func_hash->filter_hash; ftrace_hash_ipmodify_enable()
1915 return __ftrace_hash_update_ipmodify(ops, EMPTY_HASH, hash); ftrace_hash_ipmodify_enable()
1919 static void ftrace_hash_ipmodify_disable(struct ftrace_ops *ops) ftrace_hash_ipmodify_disable() argument
1921 struct ftrace_hash *hash = ops->func_hash->filter_hash; ftrace_hash_ipmodify_disable()
1926 __ftrace_hash_update_ipmodify(ops, hash, EMPTY_HASH); ftrace_hash_ipmodify_disable()
1929 static int ftrace_hash_ipmodify_update(struct ftrace_ops *ops, ftrace_hash_ipmodify_update() argument
1932 struct ftrace_hash *old_hash = ops->func_hash->filter_hash; ftrace_hash_ipmodify_update()
1940 return __ftrace_hash_update_ipmodify(ops, old_hash, new_hash); ftrace_hash_ipmodify_update()
1996 struct ftrace_ops *ops = NULL; ftrace_bug() local
2002 ops = ftrace_find_tramp_ops_any(rec); ftrace_bug()
2003 if (ops) ftrace_bug()
2005 (void *)ops->trampoline); ftrace_bug()
2092 * Just disable the record, but keep the ops TRAMP ftrace_check_record()
2154 * Need to check removed ops first. ftrace_find_tramp_ops_curr()
2156 * and this rec is in the ops list, then it would be the ftrace_find_tramp_ops_curr()
2167 * was a single 'ops' attached to it. But this can be called ftrace_find_tramp_ops_curr()
2173 * If an ops is being modified (hooking to different functions) ftrace_find_tramp_ops_curr()
2177 * If we are adding an ops to a function that already is using ftrace_find_tramp_ops_curr()
2179 * for single ops connected), then an ops that is not being ftrace_find_tramp_ops_curr()
2188 * If the ops is being added, it hasn't gotten to do_for_each_ftrace_op()
2196 * If the ops is being modified and is in the old do_for_each_ftrace_op()
2204 * If the ops is not being added or modified, and it's do_for_each_ftrace_op()
2244 struct ftrace_ops *ops; ftrace_get_addr_new() local
2248 ops = ftrace_find_tramp_ops_new(rec); ftrace_get_addr_new()
2249 if (FTRACE_WARN_ON(!ops || !ops->trampoline)) { ftrace_get_addr_new()
2255 return ops->trampoline; ftrace_get_addr_new()
2276 struct ftrace_ops *ops; ftrace_get_addr_curr() local
2280 ops = ftrace_find_tramp_ops_curr(rec); ftrace_get_addr_curr()
2281 if (FTRACE_WARN_ON(!ops)) { ftrace_get_addr_curr()
2287 return ops->trampoline; ftrace_get_addr_curr()
2463 * as the ftrace_ops_list_func will check the ops hashes ftrace_modify_all_code()
2464 * to make sure the ops are having the right functions ftrace_modify_all_code()
2550 static void ftrace_run_modify_code(struct ftrace_ops *ops, int command, ftrace_run_modify_code() argument
2553 ops->flags |= FTRACE_OPS_FL_MODIFYING; ftrace_run_modify_code()
2554 ops->old_hash.filter_hash = old_hash->filter_hash; ftrace_run_modify_code()
2555 ops->old_hash.notrace_hash = old_hash->notrace_hash; ftrace_run_modify_code()
2557 ops->old_hash.filter_hash = NULL; ftrace_run_modify_code()
2558 ops->old_hash.notrace_hash = NULL; ftrace_run_modify_code()
2559 ops->flags &= ~FTRACE_OPS_FL_MODIFYING; ftrace_run_modify_code()
2565 void __weak arch_ftrace_trampoline_free(struct ftrace_ops *ops) arch_ftrace_trampoline_free() argument
2569 static void control_ops_free(struct ftrace_ops *ops) control_ops_free() argument
2571 free_percpu(ops->disabled); control_ops_free()
2594 static int ftrace_startup(struct ftrace_ops *ops, int command) ftrace_startup() argument
2601 ret = __register_ftrace_function(ops); ftrace_startup()
2616 ops->flags |= FTRACE_OPS_FL_ENABLED | FTRACE_OPS_FL_ADDING; ftrace_startup()
2618 ret = ftrace_hash_ipmodify_enable(ops); ftrace_startup()
2621 __unregister_ftrace_function(ops); ftrace_startup()
2623 ops->flags &= ~FTRACE_OPS_FL_ENABLED; ftrace_startup()
2627 ftrace_hash_rec_enable(ops, 1); ftrace_startup()
2631 ops->flags &= ~FTRACE_OPS_FL_ADDING; ftrace_startup()
2636 static int ftrace_shutdown(struct ftrace_ops *ops, int command) ftrace_shutdown() argument
2643 ret = __unregister_ftrace_function(ops); ftrace_shutdown()
2656 ftrace_hash_ipmodify_disable(ops); ftrace_shutdown()
2657 ftrace_hash_rec_disable(ops, 1); ftrace_shutdown()
2659 ops->flags &= ~FTRACE_OPS_FL_ENABLED; ftrace_shutdown()
2670 * If these are control ops, they still need their ftrace_shutdown()
2675 if (ops->flags & FTRACE_OPS_FL_CONTROL) ftrace_shutdown()
2676 control_ops_free(ops); ftrace_shutdown()
2681 * If the ops uses a trampoline, then it needs to be ftrace_shutdown()
2684 ops->flags |= FTRACE_OPS_FL_REMOVING; ftrace_shutdown()
2685 removed_ops = ops; ftrace_shutdown()
2688 ops->old_hash.filter_hash = ops->func_hash->filter_hash; ftrace_shutdown()
2689 ops->old_hash.notrace_hash = ops->func_hash->notrace_hash; ftrace_shutdown()
2694 * If there's no more ops registered with ftrace, run a ftrace_shutdown()
2708 ops->old_hash.filter_hash = NULL;
2709 ops->old_hash.notrace_hash = NULL;
2712 ops->flags &= ~FTRACE_OPS_FL_REMOVING;
2715 * Dynamic ops may be freed, we must make sure that all
2718 * ops.
2728 if (ops->flags & (FTRACE_OPS_FL_DYNAMIC | FTRACE_OPS_FL_CONTROL)) {
2731 arch_ftrace_trampoline_free(ops);
2733 if (ops->flags & FTRACE_OPS_FL_CONTROL)
2734 control_ops_free(ops);
2777 static inline int ops_traces_mod(struct ftrace_ops *ops) ops_traces_mod() argument
2783 return ftrace_hash_empty(ops->func_hash->filter_hash) && ops_traces_mod()
2784 ftrace_hash_empty(ops->func_hash->notrace_hash); ops_traces_mod()
2788 * Check if the current ops references the record.
2790 * If the ops traces all functions, then it was already accounted for.
2791 * If the ops does not trace the current record function, skip it.
2792 * If the ops ignores the function via notrace filter, skip it.
2795 ops_references_rec(struct ftrace_ops *ops, struct dyn_ftrace *rec) ops_references_rec() argument
2797 /* If ops isn't enabled, ignore it */ ops_references_rec()
2798 if (!(ops->flags & FTRACE_OPS_FL_ENABLED)) ops_references_rec()
2801 /* If ops traces all mods, we already accounted for it */ ops_references_rec()
2802 if (ops_traces_mod(ops)) ops_references_rec()
2806 if (!ftrace_hash_empty(ops->func_hash->filter_hash) && ops_references_rec()
2807 !ftrace_lookup_ip(ops->func_hash->filter_hash, rec->ip)) ops_references_rec()
2811 if (ftrace_lookup_ip(ops->func_hash->notrace_hash, rec->ip)) ops_references_rec()
2819 struct ftrace_ops *ops; referenced_filters() local
2822 for (ops = ftrace_ops_list; ops != &ftrace_list_end; ops = ops->next) { referenced_filters()
2823 if (ops_references_rec(ops, rec)) referenced_filters()
2847 struct ftrace_ops *ops; ftrace_update_code() local
2849 for (ops = ftrace_ops_list; ftrace_update_code()
2850 ops != &ftrace_list_end; ops = ops->next) { ftrace_update_code()
2851 if (ops->flags & FTRACE_OPS_FL_ENABLED) { ftrace_update_code()
2852 if (ops_traces_mod(ops)) ftrace_update_code()
3007 struct ftrace_ops *ops; member in struct:ftrace_iterator
3091 if (rec->ops->print) t_hash_show()
3092 return rec->ops->print(m, rec->ip, rec->ops, rec->data); t_hash_show()
3094 seq_printf(m, "%ps:%ps", (void *)rec->ip, (void *)rec->ops->func); t_hash_show()
3107 struct ftrace_ops *ops = iter->ops; t_next() local
3132 !(ftrace_lookup_ip(ops->func_hash->filter_hash, rec->ip))) || t_next()
3135 !ftrace_lookup_ip(ops->func_hash->notrace_hash, rec->ip)) || t_next()
3163 struct ftrace_ops *ops = iter->ops; t_start() local
3184 ftrace_hash_empty(ops->func_hash->filter_hash)) || t_start()
3186 ftrace_hash_empty(ops->func_hash->notrace_hash))) { t_start()
3223 arch_ftrace_trampoline_func(struct ftrace_ops *ops, struct dyn_ftrace *rec) arch_ftrace_trampoline_func() argument
3228 static void add_trampoline_func(struct seq_file *m, struct ftrace_ops *ops, add_trampoline_func() argument
3233 ptr = arch_ftrace_trampoline_func(ops, rec); add_trampoline_func()
3261 struct ftrace_ops *ops = NULL; t_show() local
3268 ops = ftrace_find_tramp_ops_any(rec); t_show()
3269 if (ops) t_show()
3271 (void *)ops->trampoline); t_show()
3276 add_trampoline_func(m, ops, rec); t_show()
3302 iter->ops = &global_ops; ftrace_avail_open()
3317 iter->ops = &global_ops; ftrace_enabled_open()
3325 * @ops: The ftrace_ops that hold the hash filters
3331 * @ops. Depending on @flag it may process the filter hash or
3332 * the notrace hash of @ops. With this called from the open
3340 ftrace_regex_open(struct ftrace_ops *ops, int flag, ftrace_regex_open() argument
3347 ftrace_ops_init(ops); ftrace_regex_open()
3361 iter->ops = ops; ftrace_regex_open()
3364 mutex_lock(&ops->func_hash->regex_lock); ftrace_regex_open()
3367 hash = ops->func_hash->notrace_hash; ftrace_regex_open()
3369 hash = ops->func_hash->filter_hash; ftrace_regex_open()
3404 mutex_unlock(&ops->func_hash->regex_lock); ftrace_regex_open()
3412 struct ftrace_ops *ops = inode->i_private; ftrace_filter_open() local
3414 return ftrace_regex_open(ops, ftrace_filter_open()
3422 struct ftrace_ops *ops = inode->i_private; ftrace_notrace_open() local
3424 return ftrace_regex_open(ops, FTRACE_ITER_NOTRACE, ftrace_notrace_open()
3639 entry->ops->func(ip, parent_ip, &entry->data); hlist_for_each_entry_rcu_notrace()
3702 if (entry->ops->free) ftrace_free_entry()
3703 entry->ops->free(entry->ops, entry->ip, &entry->data); ftrace_free_entry()
3708 register_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops, register_ftrace_function_probe() argument
3773 if (ops->init) { do_for_each_ftrace_rec()
3774 if (ops->init(ops, rec->ip, &entry->data) < 0) { do_for_each_ftrace_rec()
3788 entry->ops = ops; do_for_each_ftrace_rec()
3820 __unregister_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops, __unregister_ftrace_function_probe() argument
3865 if ((flags & PROBE_TEST_FUNC) && entry->ops != ops) hlist_for_each_entry_safe()
3911 unregister_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops, unregister_ftrace_function_probe() argument
3914 __unregister_ftrace_function_probe(glob, ops, data, unregister_ftrace_function_probe()
3919 unregister_ftrace_function_probe_func(char *glob, struct ftrace_probe_ops *ops) unregister_ftrace_function_probe_func() argument
3921 __unregister_ftrace_function_probe(glob, ops, NULL, PROBE_TEST_FUNC); unregister_ftrace_function_probe_func()
4085 static void ftrace_ops_update_code(struct ftrace_ops *ops, ftrace_ops_update_code() argument
4093 if (ops->flags & FTRACE_OPS_FL_ENABLED) { ftrace_ops_update_code()
4094 ftrace_run_modify_code(ops, FTRACE_UPDATE_CALLS, old_hash); ftrace_ops_update_code()
4100 * check if there is another ops that shares it, is enabled. ftrace_ops_update_code()
4103 if (ops->func_hash != &global_ops.local_hash) ftrace_ops_update_code()
4117 ftrace_set_hash(struct ftrace_ops *ops, unsigned char *buf, int len, ftrace_set_hash() argument
4129 mutex_lock(&ops->func_hash->regex_lock); ftrace_set_hash()
4132 orig_hash = &ops->func_hash->filter_hash; ftrace_set_hash()
4134 orig_hash = &ops->func_hash->notrace_hash; ftrace_set_hash()
4158 old_hash_ops.filter_hash = ops->func_hash->filter_hash; ftrace_set_hash()
4159 old_hash_ops.notrace_hash = ops->func_hash->notrace_hash; ftrace_set_hash()
4160 ret = ftrace_hash_move(ops, enable, orig_hash, hash); ftrace_set_hash()
4162 ftrace_ops_update_code(ops, &old_hash_ops); ftrace_set_hash()
4168 mutex_unlock(&ops->func_hash->regex_lock); ftrace_set_hash()
4175 ftrace_set_addr(struct ftrace_ops *ops, unsigned long ip, int remove, ftrace_set_addr() argument
4178 return ftrace_set_hash(ops, 0, 0, ip, remove, reset, enable); ftrace_set_addr()
4183 * @ops - the ops to set the filter with
4191 int ftrace_set_filter_ip(struct ftrace_ops *ops, unsigned long ip, ftrace_set_filter_ip() argument
4194 ftrace_ops_init(ops); ftrace_set_filter_ip()
4195 return ftrace_set_addr(ops, ip, remove, reset, 1); ftrace_set_filter_ip()
4200 ftrace_set_regex(struct ftrace_ops *ops, unsigned char *buf, int len, ftrace_set_regex() argument
4203 return ftrace_set_hash(ops, buf, len, 0, 0, reset, enable); ftrace_set_regex()
4208 * @ops - the ops to set the filter with
4216 int ftrace_set_filter(struct ftrace_ops *ops, unsigned char *buf, ftrace_set_filter() argument
4219 ftrace_ops_init(ops); ftrace_set_filter()
4220 return ftrace_set_regex(ops, buf, len, reset, 1); ftrace_set_filter()
4226 * @ops - the ops to set the notrace filter with
4235 int ftrace_set_notrace(struct ftrace_ops *ops, unsigned char *buf, ftrace_set_notrace() argument
4238 ftrace_ops_init(ops); ftrace_set_notrace()
4239 return ftrace_set_regex(ops, buf, len, reset, 0); ftrace_set_notrace()
4345 ftrace_set_early_filter(struct ftrace_ops *ops, char *buf, int enable) ftrace_set_early_filter() argument
4349 ftrace_ops_init(ops); ftrace_set_early_filter()
4353 ftrace_set_regex(ops, func, strlen(func), 0, enable); ftrace_set_early_filter()
4396 mutex_lock(&iter->ops->func_hash->regex_lock); ftrace_regex_release()
4402 orig_hash = &iter->ops->func_hash->filter_hash; ftrace_regex_release()
4404 orig_hash = &iter->ops->func_hash->notrace_hash; ftrace_regex_release()
4408 old_hash_ops.filter_hash = iter->ops->func_hash->filter_hash; ftrace_regex_release()
4409 old_hash_ops.notrace_hash = iter->ops->func_hash->notrace_hash; ftrace_regex_release()
4410 ret = ftrace_hash_move(iter->ops, filter_hash, ftrace_regex_release()
4413 ftrace_ops_update_code(iter->ops, &old_hash_ops); ftrace_regex_release()
4419 mutex_unlock(&iter->ops->func_hash->regex_lock); ftrace_regex_release()
4733 void ftrace_create_filter_files(struct ftrace_ops *ops, ftrace_create_filter_files() argument
4738 ops, &ftrace_filter_fops); ftrace_create_filter_files()
4741 ops, &ftrace_notrace_fops); ftrace_create_filter_files()
4747 * really intended to make sure the ops passed in are disabled
4749 * free the ops.
4754 void ftrace_destroy_filter_files(struct ftrace_ops *ops) ftrace_destroy_filter_files() argument
4757 if (ops->flags & FTRACE_OPS_FL_ENABLED) ftrace_destroy_filter_files()
4758 ftrace_shutdown(ops, 0); ftrace_destroy_filter_files()
4759 ops->flags |= FTRACE_OPS_FL_DELETED; ftrace_destroy_filter_files()
5021 void __weak arch_ftrace_update_trampoline(struct ftrace_ops *ops) arch_ftrace_update_trampoline() argument
5025 static void ftrace_update_trampoline(struct ftrace_ops *ops) ftrace_update_trampoline() argument
5038 /* Currently, only non dynamic ops can have a trampoline */ ftrace_update_trampoline()
5039 if (ops->flags & FTRACE_OPS_FL_DYNAMIC) ftrace_update_trampoline()
5043 arch_ftrace_update_trampoline(ops); ftrace_update_trampoline()
5066 # define ftrace_startup(ops, command) \ ftrace_startup_all()
5068 int ___ret = __register_ftrace_function(ops); \ ftrace_startup_all()
5070 (ops)->flags |= FTRACE_OPS_FL_ENABLED; \ ftrace_startup_all()
5073 # define ftrace_shutdown(ops, command) \
5075 int ___ret = __unregister_ftrace_function(ops); \
5077 (ops)->flags &= ~FTRACE_OPS_FL_ENABLED; \
5085 ftrace_ops_test(struct ftrace_ops *ops, unsigned long ip, void *regs) ftrace_ops_test() argument
5090 static void ftrace_update_trampoline(struct ftrace_ops *ops) ftrace_update_trampoline() argument
5098 tr->ops = &global_ops; ftrace_init_global_array_ops()
5099 tr->ops->private = tr; ftrace_init_global_array_ops()
5106 if (WARN_ON(tr->ops->func != ftrace_stub)) ftrace_init_array_ops()
5107 printk("ftrace ops had %pS for function\n", ftrace_init_array_ops()
5108 tr->ops->func); ftrace_init_array_ops()
5110 tr->ops->func = func; ftrace_init_array_ops()
5111 tr->ops->private = tr; ftrace_init_array_ops()
5116 tr->ops->func = ftrace_stub; ftrace_reset_array_ops()
5127 * Some of the ops may be dynamically allocated, ftrace_ops_control_func()
5169 * Some of the ops may be dynamically allocated, __ftrace_ops_list_func()
5234 * @ops: the ops to get the function for
5236 * Normally the mcount trampoline will call the ops->func, but there
5237 * are times that it should not. For example, if the ops does not
5241 * Returns the function that the trampoline should call for @ops.
5243 ftrace_func_t ftrace_ops_get_func(struct ftrace_ops *ops) ftrace_ops_get_func() argument
5248 * will call the ftrace ops function. ftrace_ops_get_func()
5250 if (!(ops->flags & FTRACE_OPS_FL_RECURSION_SAFE)) ftrace_ops_get_func()
5253 return ops->func; ftrace_ops_get_func()
5546 * @ops - ops structure that holds the function for profiling.
5551 * Note: @ops->func and all the functions it calls must be labeled
5555 int register_ftrace_function(struct ftrace_ops *ops) register_ftrace_function() argument
5559 ftrace_ops_init(ops); register_ftrace_function()
5563 ret = ftrace_startup(ops, 0); register_ftrace_function()
5573 * @ops - ops structure that holds the function to unregister
5577 int unregister_ftrace_function(struct ftrace_ops *ops) unregister_ftrace_function() argument
5582 ret = ftrace_shutdown(ops, 0); unregister_ftrace_function()
5807 * tracer ops is registered, the graph tracer requires testing the
5808 * function against the global ops, and not just trace any function
5817 * The graph and global ops share the same set of functions update_function_graph_func()
5818 * to test. If any other ops is on the list, then update_function_graph_func()
386 add_ftrace_list_ops(struct ftrace_ops **list, struct ftrace_ops *main_ops, struct ftrace_ops *ops) add_ftrace_list_ops() argument
396 remove_ftrace_list_ops(struct ftrace_ops **list, struct ftrace_ops *main_ops, struct ftrace_ops *ops) remove_ftrace_list_ops() argument
872 function_profile_call(unsigned long ip, unsigned long parent_ip, struct ftrace_ops *ops, struct pt_regs *regs) function_profile_call() argument
H A Dtrace_functions.c38 struct ftrace_ops *ops; allocate_ftrace_ops() local
40 ops = kzalloc(sizeof(*ops), GFP_KERNEL); allocate_ftrace_ops()
41 if (!ops) allocate_ftrace_ops()
45 ops->func = function_trace_call; allocate_ftrace_ops()
46 ops->flags = FTRACE_OPS_FL_RECURSION_SAFE; allocate_ftrace_ops()
48 tr->ops = ops; allocate_ftrace_ops()
49 ops->private = tr; allocate_ftrace_ops()
70 ftrace_create_filter_files(tr->ops, parent); ftrace_create_function_files()
77 ftrace_destroy_filter_files(tr->ops); ftrace_destroy_function_files()
78 kfree(tr->ops); ftrace_destroy_function_files()
79 tr->ops = NULL; ftrace_destroy_function_files()
87 * Instance trace_arrays get their ops allocated function_trace_init()
91 if (!tr->ops) function_trace_init()
212 register_ftrace_function(tr->ops); tracing_start_function_trace()
219 unregister_ftrace_function(tr->ops); tracing_stop_function_trace()
231 unregister_ftrace_function(tr->ops); func_set_flag()
234 tr->ops->func = function_stack_trace_call; func_set_flag()
235 register_ftrace_function(tr->ops); func_set_flag()
237 tr->ops->func = function_trace_call; func_set_flag()
238 register_ftrace_function(tr->ops); func_set_flag()
448 struct ftrace_probe_ops *ops, void *data) ftrace_traceon_print()
455 struct ftrace_probe_ops *ops, void *data) ftrace_traceoff_print()
462 struct ftrace_probe_ops *ops, void *data) ftrace_stacktrace_print()
469 struct ftrace_probe_ops *ops, void *data) ftrace_dump_print()
476 struct ftrace_probe_ops *ops, void *data) ftrace_cpudump_print()
522 ftrace_trace_probe_callback(struct ftrace_probe_ops *ops, ftrace_trace_probe_callback() argument
535 unregister_ftrace_function_probe_func(glob+1, ops); ftrace_trace_probe_callback()
556 ret = register_ftrace_function_probe(glob, ops, count); ftrace_trace_probe_callback()
565 struct ftrace_probe_ops *ops; ftrace_trace_onoff_callback() local
569 ops = param ? &traceon_count_probe_ops : &traceon_probe_ops; ftrace_trace_onoff_callback()
571 ops = param ? &traceoff_count_probe_ops : &traceoff_probe_ops; ftrace_trace_onoff_callback()
573 return ftrace_trace_probe_callback(ops, hash, glob, cmd, ftrace_trace_onoff_callback()
581 struct ftrace_probe_ops *ops; ftrace_stacktrace_callback() local
583 ops = param ? &stacktrace_count_probe_ops : &stacktrace_probe_ops; ftrace_stacktrace_callback()
585 return ftrace_trace_probe_callback(ops, hash, glob, cmd, ftrace_stacktrace_callback()
593 struct ftrace_probe_ops *ops; ftrace_dump_callback() local
595 ops = &dump_probe_ops; ftrace_dump_callback()
598 return ftrace_trace_probe_callback(ops, hash, glob, cmd, ftrace_dump_callback()
606 struct ftrace_probe_ops *ops; ftrace_cpudump_callback() local
608 ops = &cpudump_probe_ops; ftrace_cpudump_callback()
611 return ftrace_trace_probe_callback(ops, hash, glob, cmd, ftrace_cpudump_callback()
447 ftrace_traceon_print(struct seq_file *m, unsigned long ip, struct ftrace_probe_ops *ops, void *data) ftrace_traceon_print() argument
454 ftrace_traceoff_print(struct seq_file *m, unsigned long ip, struct ftrace_probe_ops *ops, void *data) ftrace_traceoff_print() argument
461 ftrace_stacktrace_print(struct seq_file *m, unsigned long ip, struct ftrace_probe_ops *ops, void *data) ftrace_stacktrace_print() argument
468 ftrace_dump_print(struct seq_file *m, unsigned long ip, struct ftrace_probe_ops *ops, void *data) ftrace_dump_print() argument
475 ftrace_cpudump_print(struct seq_file *m, unsigned long ip, struct ftrace_probe_ops *ops, void *data) ftrace_cpudump_print() argument
/linux-4.4.14/include/linux/ulpi/
H A Dinterface.h16 int (*read)(struct ulpi_ops *ops, u8 addr);
17 int (*write)(struct ulpi_ops *ops, u8 addr, u8 val);
/linux-4.4.14/arch/mips/oprofile/
H A Dcommon.c75 int __init oprofile_arch_init(struct oprofile_operations *ops) oprofile_arch_init() argument
119 ops->backtrace = op_mips_backtrace; oprofile_arch_init()
130 ops->create_files = op_mips_create_files; oprofile_arch_init()
131 ops->setup = op_mips_setup; oprofile_arch_init()
132 //ops->shutdown = op_mips_shutdown; oprofile_arch_init()
133 ops->start = op_mips_start; oprofile_arch_init()
134 ops->stop = op_mips_stop; oprofile_arch_init()
135 ops->cpu_type = lmodel->cpu_type; oprofile_arch_init()
/linux-4.4.14/drivers/staging/android/trace/
H A Dsync.h23 if (timeline->ops->timeline_value_str) {
24 timeline->ops->timeline_value_str(timeline,
62 __string(timeline, pt->ops->get_timeline_name(pt))
67 __assign_str(timeline, pt->ops->get_timeline_name(pt));
68 if (pt->ops->fence_value_str) {
69 pt->ops->fence_value_str(pt, __entry->value,
/linux-4.4.14/arch/sparc/oprofile/
H A Dinit.c59 static int op_nmi_timer_init(struct oprofile_operations *ops) op_nmi_timer_init() argument
64 ops->start = timer_start; op_nmi_timer_init()
65 ops->stop = timer_stop; op_nmi_timer_init()
66 ops->cpu_type = "timer"; op_nmi_timer_init()
72 int __init oprofile_arch_init(struct oprofile_operations *ops) oprofile_arch_init() argument
77 ret = op_nmi_timer_init(ops); oprofile_arch_init()
/linux-4.4.14/arch/arm/mach-mmp/
H A Dclock.c60 clk->ops->enable(clk); clk_enable()
74 clk->ops->disable(clk); clk_disable()
83 if (clk->ops->getrate) clk_get_rate()
84 rate = clk->ops->getrate(clk); clk_get_rate()
97 if (clk->ops->setrate) { clk_set_rate()
99 ret = clk->ops->setrate(clk, rate); clk_set_rate()
H A Dclock.h19 const struct clkops *ops; member in struct:clk
36 .ops = &apbc_clk_ops, \
44 .ops = _ops, \
52 .ops = &apmu_clk_ops, \
60 .ops = _ops, \
/linux-4.4.14/drivers/staging/rtl8192u/ieee80211/
H A Dieee80211_crypt.c28 struct ieee80211_crypto_ops *ops; member in struct:ieee80211_crypto_alg
54 if (entry->ops) ieee80211_crypt_deinit_entries()
55 entry->ops->deinit(entry->priv); ieee80211_crypt_deinit_entries()
89 /* must not run ops->deinit() while there may be pending encrypt or ieee80211_crypt_delayed_deinit()
102 int ieee80211_register_crypto_ops(struct ieee80211_crypto_ops *ops) ieee80211_register_crypto_ops() argument
114 alg->ops = ops; ieee80211_register_crypto_ops()
121 ops->name); ieee80211_register_crypto_ops()
126 int ieee80211_unregister_crypto_ops(struct ieee80211_crypto_ops *ops) ieee80211_unregister_crypto_ops() argument
139 if (alg->ops == ops) { ieee80211_unregister_crypto_ops()
149 ops->name); ieee80211_unregister_crypto_ops()
170 if (strcmp(alg->ops->name, name) == 0) { ieee80211_get_crypto_ops()
178 return found_alg->ops; ieee80211_get_crypto_ops()
235 alg->ops->name); ieee80211_crypto_deinit()
/linux-4.4.14/drivers/net/wireless/b43/
H A Dphy_common.c46 phy->ops = NULL; b43_phy_allocate()
51 phy->ops = &b43_phyops_g; b43_phy_allocate()
56 phy->ops = &b43_phyops_n; b43_phy_allocate()
61 phy->ops = &b43_phyops_lp; b43_phy_allocate()
66 phy->ops = &b43_phyops_ht; b43_phy_allocate()
71 phy->ops = &b43_phyops_lcn; b43_phy_allocate()
76 phy->ops = &b43_phyops_ac; b43_phy_allocate()
80 if (B43_WARN_ON(!phy->ops)) b43_phy_allocate()
83 err = phy->ops->allocate(dev); b43_phy_allocate()
85 phy->ops = NULL; b43_phy_allocate()
92 dev->phy.ops->free(dev); b43_phy_free()
93 dev->phy.ops = NULL; b43_phy_free()
99 const struct b43_phy_operations *ops = phy->ops; b43_phy_init() local
110 phy->ops->switch_analog(dev, true); b43_phy_init()
113 err = ops->init(dev); b43_phy_init()
130 if (ops->exit) b43_phy_init()
131 ops->exit(dev); b43_phy_init()
140 const struct b43_phy_operations *ops = dev->phy.ops; b43_phy_exit() local
144 if (ops->exit) b43_phy_exit()
145 ops->exit(dev); b43_phy_exit()
152 if (!dev->phy.ops->supports_hwpctl) b43_has_hardware_pctl()
154 return dev->phy.ops->supports_hwpctl(dev); b43_has_hardware_pctl()
232 return dev->phy.ops->radio_read(dev, reg); b43_radio_read()
243 dev->phy.ops->radio_write(dev, reg, value); b43_radio_write()
284 if (dev->phy.ops->phy_read) b43_phy_read()
285 return dev->phy.ops->phy_read(dev, reg); b43_phy_read()
300 if (dev->phy.ops->phy_write) b43_phy_write()
301 return dev->phy.ops->phy_write(dev, reg, value); b43_phy_write()
314 if (dev->phy.ops->phy_maskset) { b43_phy_mask()
316 dev->phy.ops->phy_maskset(dev, offset, mask, 0); b43_phy_mask()
325 if (dev->phy.ops->phy_maskset) { b43_phy_set()
327 dev->phy.ops->phy_maskset(dev, offset, 0xFFFF, set); b43_phy_set()
336 if (dev->phy.ops->phy_maskset) { b43_phy_maskset()
338 dev->phy.ops->phy_maskset(dev, offset, mask, set); b43_phy_maskset()
448 err = phy->ops->switch_channel(dev, new_channel); b43_switch_channel()
469 phy->ops->software_rfkill(dev, blocked); b43_software_rfkill()
489 dev->phy.ops->adjust_txpower(dev); b43_phy_txpower_adjust_work()
512 result = phy->ops->recalc_txpower(dev, !!(flags & B43_TXPWR_IGNORE_TSSI)); b43_phy_txpower_check()
516 B43_WARN_ON(phy->ops->adjust_txpower == NULL); b43_phy_txpower_check()
/linux-4.4.14/net/ipv6/
H A Dip6_offload.c24 const struct net_offload *ops = NULL; ipv6_gso_pull_exthdrs() local
31 ops = rcu_dereference(inet6_offloads[proto]); ipv6_gso_pull_exthdrs()
33 if (unlikely(!ops)) ipv6_gso_pull_exthdrs()
36 if (!(ops->flags & INET6_PROTO_GSO_EXTHDR)) ipv6_gso_pull_exthdrs()
62 const struct net_offload *ops; ipv6_gso_segment() local
109 ops = rcu_dereference(inet6_offloads[proto]); ipv6_gso_segment()
110 if (likely(ops && ops->callbacks.gso_segment)) { ipv6_gso_segment()
112 segs = ops->callbacks.gso_segment(skb, features); ipv6_gso_segment()
169 const struct net_offload *ops; ipv6_gro_receive() local
196 ops = rcu_dereference(inet6_offloads[proto]); ipv6_gro_receive()
197 if (!ops || !ops->callbacks.gro_receive) { ipv6_gro_receive()
204 ops = rcu_dereference(inet6_offloads[proto]); ipv6_gro_receive()
205 if (!ops || !ops->callbacks.gro_receive) ipv6_gro_receive()
229 * (nlen != (sizeof(*iph2) + ipv6_exthdrs_len(iph2, &ops))) ipv6_gro_receive()
250 pp = ops->callbacks.gro_receive(head, skb); ipv6_gro_receive()
263 const struct net_offload *ops; ipv6_gro_complete() local
274 nhoff += sizeof(*iph) + ipv6_exthdrs_len(iph, &ops); ipv6_gro_complete()
275 if (WARN_ON(!ops || !ops->callbacks.gro_complete)) ipv6_gro_complete()
278 err = ops->callbacks.gro_complete(skb, nhoff); ipv6_gro_complete()
/linux-4.4.14/sound/
H A Dac97_bus.c33 ac97->id = ac97->bus->ops->read(ac97, AC97_VENDOR_ID1) << 16; snd_ac97_check_id()
34 ac97->id |= ac97->bus->ops->read(ac97, AC97_VENDOR_ID2); snd_ac97_check_id()
62 struct snd_ac97_bus_ops *ops = ac97->bus->ops; snd_ac97_reset() local
64 if (try_warm && ops->warm_reset) { snd_ac97_reset()
65 ops->warm_reset(ac97); snd_ac97_reset()
70 if (ops->reset) snd_ac97_reset()
71 ops->reset(ac97); snd_ac97_reset()
72 if (ops->warm_reset) snd_ac97_reset()
73 ops->warm_reset(ac97); snd_ac97_reset()
/linux-4.4.14/sound/soc/intel/common/
H A Dsst-dsp.c97 sst->ops->write(sst->addr.shim, offset, value); sst_dsp_shim_write()
108 val = sst->ops->read(sst->addr.shim, offset); sst_dsp_shim_read()
120 sst->ops->write64(sst->addr.shim, offset, value); sst_dsp_shim_write64()
131 val = sst->ops->read64(sst->addr.shim, offset); sst_dsp_shim_read64()
140 sst->ops->write(sst->addr.shim, offset, value); sst_dsp_shim_write_unlocked()
146 return sst->ops->read(sst->addr.shim, offset); sst_dsp_shim_read_unlocked()
152 sst->ops->write64(sst->addr.shim, offset, value); sst_dsp_shim_write64_unlocked()
158 return sst->ops->read64(sst->addr.shim, offset); sst_dsp_shim_read64_unlocked()
298 if (sst->ops->dump) sst_dsp_dump()
299 sst->ops->dump(sst); sst_dsp_dump()
305 if (sst->ops->reset) sst_dsp_reset()
306 sst->ops->reset(sst); sst_dsp_reset()
312 if (sst->ops->boot) sst_dsp_boot()
313 sst->ops->boot(sst); sst_dsp_boot()
321 if (sst->ops->wake) sst_dsp_wake()
322 return sst->ops->wake(sst); sst_dsp_wake()
330 if (sst->ops->sleep) sst_dsp_sleep()
331 sst->ops->sleep(sst); sst_dsp_sleep()
337 if (sst->ops->stall) sst_dsp_stall()
338 sst->ops->stall(sst); sst_dsp_stall()
444 sst->ops = sst_dev->ops; sst_dsp_new()
453 if (sst->ops->init) { sst_dsp_new()
454 err = sst->ops->init(sst, pdata); sst_dsp_new()
460 err = request_threaded_irq(sst->irq, sst->ops->irq_handler, sst_dsp_new()
472 if (sst->ops->free) sst_dsp_new()
473 sst->ops->free(sst); sst_dsp_new()
482 if (sst->ops->free) sst_dsp_free()
483 sst->ops->free(sst); sst_dsp_free()
/linux-4.4.14/sound/hda/
H A Dhdac_i915.c43 if (!acomp || !acomp->ops) snd_hdac_set_codec_wakeup()
46 if (!acomp->ops->codec_wake_override) { snd_hdac_set_codec_wakeup()
55 acomp->ops->codec_wake_override(acomp->dev, enable); snd_hdac_set_codec_wakeup()
70 * put_power() ops accordingly, toggling the codec wakeup, too.
78 if (!acomp || !acomp->ops) snd_hdac_display_power()
86 acomp->ops->get_power(acomp->dev); snd_hdac_display_power()
93 acomp->ops->put_power(acomp->dev); snd_hdac_display_power()
114 if (!acomp || !acomp->ops) snd_hdac_get_display_clk()
117 return acomp->ops->get_cdclk_freq(acomp->dev); snd_hdac_get_display_clk()
130 if (WARN_ON(!(acomp->dev && acomp->ops && acomp->ops->get_power && hdac_component_master_bind()
131 acomp->ops->put_power && acomp->ops->get_cdclk_freq))) { hdac_component_master_bind()
140 if (!try_module_get(acomp->ops->owner)) { hdac_component_master_bind()
157 module_put(acomp->ops->owner); hdac_component_master_unbind()
159 WARN_ON(acomp->ops || acomp->dev); hdac_component_master_unbind()
174 * snd_hdac_i915_register_notifier - Register i915 audio component ops
175 * @aops: i915 audio component ops
180 * This function sets the given ops to be called by the i915 graphics driver.
231 if (!acomp->ops) { snd_hdac_i915_init()
269 if (bus->i915_power_refcount > 0 && acomp->ops) snd_hdac_i915_exit()
270 acomp->ops->put_power(acomp->dev); snd_hdac_i915_exit()
H A Dhdac_bus.c22 * @ops: bus verb operators
28 const struct hdac_bus_ops *ops, snd_hdac_bus_init()
33 if (ops) snd_hdac_bus_init()
34 bus->ops = ops; snd_hdac_bus_init()
36 bus->ops = &default_ops; snd_hdac_bus_init()
103 err = bus->ops->command(bus, cmd); snd_hdac_bus_exec_verb_unlocked()
107 err = bus->ops->get_response(bus, addr, &tmp); snd_hdac_bus_exec_verb_unlocked()
112 err = bus->ops->get_response(bus, addr, res); snd_hdac_bus_exec_verb_unlocked()
27 snd_hdac_bus_init(struct hdac_bus *bus, struct device *dev, const struct hdac_bus_ops *ops, const struct hdac_io_ops *io_ops) snd_hdac_bus_init() argument
/linux-4.4.14/drivers/iommu/
H A Dof_iommu.c101 struct iommu_ops *ops; member in struct:of_iommu_node
106 void of_iommu_set_ops(struct device_node *np, struct iommu_ops *ops) of_iommu_set_ops() argument
115 iommu->ops = ops; of_iommu_set_ops()
124 struct iommu_ops *ops = NULL; of_iommu_get_ops() local
129 ops = node->ops; of_iommu_get_ops()
133 return ops; of_iommu_get_ops()
141 struct iommu_ops *ops = NULL; of_iommu_configure() local
160 ops = of_iommu_get_ops(np); of_iommu_configure()
162 if (!ops || !ops->of_xlate || ops->of_xlate(dev, &iommu_spec)) of_iommu_configure()
169 return ops; of_iommu_configure()
H A Dio-pgtable.c60 return &iop->ops; alloc_io_pgtable_ops()
67 void free_io_pgtable_ops(struct io_pgtable_ops *ops) free_io_pgtable_ops() argument
71 if (!ops) free_io_pgtable_ops()
74 iop = container_of(ops, struct io_pgtable, ops); free_io_pgtable_ops()
H A Dio-pgtable-arm.c42 container_of((x), struct io_pgtable, ops)
379 static int arm_lpae_map(struct io_pgtable_ops *ops, unsigned long iova, arm_lpae_map() argument
382 struct arm_lpae_io_pgtable *data = io_pgtable_ops_to_data(ops); arm_lpae_map()
527 static int arm_lpae_unmap(struct io_pgtable_ops *ops, unsigned long iova, arm_lpae_unmap() argument
531 struct arm_lpae_io_pgtable *data = io_pgtable_ops_to_data(ops); arm_lpae_unmap()
543 static phys_addr_t arm_lpae_iova_to_phys(struct io_pgtable_ops *ops, arm_lpae_iova_to_phys() argument
546 struct arm_lpae_io_pgtable *data = io_pgtable_ops_to_data(ops); arm_lpae_iova_to_phys()
649 data->iop.ops = (struct io_pgtable_ops) { arm_lpae_alloc_pgtable()
911 static void __init arm_lpae_dump_ops(struct io_pgtable_ops *ops) arm_lpae_dump_ops() argument
913 struct arm_lpae_io_pgtable *data = io_pgtable_ops_to_data(ops); arm_lpae_dump_ops()
923 #define __FAIL(ops, i) ({ \
925 arm_lpae_dump_ops(ops); \
940 struct io_pgtable_ops *ops; arm_lpae_run_tests() local
946 ops = alloc_io_pgtable_ops(fmts[i], cfg, cfg); arm_lpae_run_tests()
947 if (!ops) { arm_lpae_run_tests()
948 pr_err("selftest: failed to allocate io pgtable ops\n"); arm_lpae_run_tests()
956 if (ops->iova_to_phys(ops, 42)) arm_lpae_run_tests()
957 return __FAIL(ops, i); arm_lpae_run_tests()
959 if (ops->iova_to_phys(ops, SZ_1G + 42)) arm_lpae_run_tests()
960 return __FAIL(ops, i); arm_lpae_run_tests()
962 if (ops->iova_to_phys(ops, SZ_2G + 42)) arm_lpae_run_tests()
963 return __FAIL(ops, i); arm_lpae_run_tests()
973 if (ops->map(ops, iova, iova, size, IOMMU_READ | arm_lpae_run_tests()
977 return __FAIL(ops, i); arm_lpae_run_tests()
980 if (!ops->map(ops, iova, iova + size, size, arm_lpae_run_tests()
982 return __FAIL(ops, i); arm_lpae_run_tests()
984 if (ops->iova_to_phys(ops, iova + 42) != (iova + 42)) arm_lpae_run_tests()
985 return __FAIL(ops, i); arm_lpae_run_tests()
994 if (ops->unmap(ops, SZ_1G + size, size) != size) arm_lpae_run_tests()
995 return __FAIL(ops, i); arm_lpae_run_tests()
998 if (ops->map(ops, SZ_1G + size, size, size, IOMMU_READ)) arm_lpae_run_tests()
999 return __FAIL(ops, i); arm_lpae_run_tests()
1001 if (ops->iova_to_phys(ops, SZ_1G + size + 42) != (size + 42)) arm_lpae_run_tests()
1002 return __FAIL(ops, i); arm_lpae_run_tests()
1010 if (ops->unmap(ops, iova, size) != size) arm_lpae_run_tests()
1011 return __FAIL(ops, i); arm_lpae_run_tests()
1013 if (ops->iova_to_phys(ops, iova + 42)) arm_lpae_run_tests()
1014 return __FAIL(ops, i); arm_lpae_run_tests()
1017 if (ops->map(ops, iova, iova, size, IOMMU_WRITE)) arm_lpae_run_tests()
1018 return __FAIL(ops, i); arm_lpae_run_tests()
1020 if (ops->iova_to_phys(ops, iova + 42) != (iova + 42)) arm_lpae_run_tests()
1021 return __FAIL(ops, i); arm_lpae_run_tests()
1028 free_io_pgtable_ops(ops); arm_lpae_run_tests()
/linux-4.4.14/drivers/regulator/
H A Dmc13xxx.h65 .ops = &_ops, \
83 .ops = &_ops, \
98 .ops = &_ops, \
107 #define MC13xxx_DEFINE_SW(_name, _reg, _vsel_reg, _voltages, ops) \
108 MC13xxx_DEFINE(SW, _name, _reg, _vsel_reg, _voltages, ops)
109 #define MC13xxx_DEFINE_REGU(_name, _reg, _vsel_reg, _voltages, ops) \
110 MC13xxx_DEFINE(REGU, _name, _reg, _vsel_reg, _voltages, ops)
H A Dlp8788-ldo.c195 .ops = &lp8788_ldo_voltage_table_ops,
208 .ops = &lp8788_ldo_voltage_table_ops,
221 .ops = &lp8788_ldo_voltage_table_ops,
234 .ops = &lp8788_ldo_voltage_table_ops,
247 .ops = &lp8788_ldo_voltage_table_ops,
260 .ops = &lp8788_ldo_voltage_table_ops,
273 .ops = &lp8788_ldo_voltage_table_ops,
286 .ops = &lp8788_ldo_voltage_table_ops,
299 .ops = &lp8788_ldo_voltage_table_ops,
312 .ops = &lp8788_ldo_voltage_table_ops,
325 .ops = &lp8788_ldo_voltage_table_ops,
338 .ops = &lp8788_ldo_voltage_fixed_ops,
352 .ops = &lp8788_ldo_voltage_table_ops,
365 .ops = &lp8788_ldo_voltage_fixed_ops,
376 .ops = &lp8788_ldo_voltage_fixed_ops,
387 .ops = &lp8788_ldo_voltage_fixed_ops,
398 .ops = &lp8788_ldo_voltage_fixed_ops,
409 .ops = &lp8788_ldo_voltage_table_ops,
422 .ops = &lp8788_ldo_voltage_table_ops,
435 .ops = &lp8788_ldo_voltage_fixed_ops,
446 .ops = &lp8788_ldo_voltage_fixed_ops,
457 .ops = &lp8788_ldo_voltage_fixed_ops,
H A Ddb8500-prcmu.c218 .ops = &db8500_regulator_ops,
227 .ops = &db8500_regulator_ops,
236 .ops = &db8500_regulator_ops,
245 .ops = &db8500_regulator_ops,
254 .ops = &db8500_regulator_ops,
263 .ops = &db8500_regulator_ops,
275 .ops = &db8500_regulator_ops,
284 .ops = &db8500_regulator_ops,
293 .ops = &db8500_regulator_switch_ops,
303 .ops = &db8500_regulator_switch_ops,
314 .ops = &db8500_regulator_switch_ops,
324 .ops = &db8500_regulator_switch_ops,
334 .ops = &db8500_regulator_switch_ops,
345 .ops = &db8500_regulator_switch_ops,
355 .ops = &db8500_regulator_switch_ops,
365 .ops = &db8500_regulator_switch_ops,
375 .ops = &db8500_regulator_switch_ops,
386 .ops = &db8500_regulator_switch_ops,
397 .ops = &db8500_regulator_switch_ops,
408 .ops = &db8500_regulator_switch_ops,
/linux-4.4.14/drivers/clk/mxs/
H A Dclk-div.c20 * @ops: pointer to clk_ops of parent class
29 const struct clk_ops *ops; member in struct:clk_div
46 return div->ops->recalc_rate(&div->divider.hw, parent_rate); clk_div_recalc_rate()
54 return div->ops->round_rate(&div->divider.hw, rate, prate); clk_div_round_rate()
63 ret = div->ops->set_rate(&div->divider.hw, rate, parent_rate); clk_div_set_rate()
88 init.ops = &clk_div_ops; mxs_clk_div()
102 div->ops = &clk_divider_ops; mxs_clk_div()
/linux-4.4.14/lib/
H A Dtextsearch.c131 * @ops: operations lookup table
134 * their presence. The specified &@ops must have %name set to a
141 int textsearch_register(struct ts_ops *ops) textsearch_register() argument
146 if (ops->name == NULL || ops->find == NULL || ops->init == NULL || textsearch_register()
147 ops->get_pattern == NULL || ops->get_pattern_len == NULL) textsearch_register()
152 if (!strcmp(ops->name, o->name)) textsearch_register()
156 list_add_tail_rcu(&ops->list, &ts_ops); textsearch_register()
166 * @ops: operations lookup table
170 * The &ops parameter must be the same as the one during the
176 int textsearch_unregister(struct ts_ops *ops) textsearch_unregister() argument
183 if (o == ops) { textsearch_unregister()
266 struct ts_ops *ops; textsearch_prepare() local
271 ops = lookup_ts_algo(algo); textsearch_prepare()
278 if (ops == NULL && flags & TS_AUTOLOAD) { textsearch_prepare()
280 ops = lookup_ts_algo(algo); textsearch_prepare()
284 if (ops == NULL) textsearch_prepare()
287 conf = ops->init(pattern, len, gfp_mask, flags); textsearch_prepare()
293 conf->ops = ops; textsearch_prepare()
297 if (ops) textsearch_prepare()
298 module_put(ops->owner); textsearch_prepare()
313 if (conf->ops) { textsearch_destroy()
314 if (conf->ops->destroy) textsearch_destroy()
315 conf->ops->destroy(conf); textsearch_destroy()
316 module_put(conf->ops->owner); textsearch_destroy()
/linux-4.4.14/arch/arm/mach-sa1100/
H A Dclock.c27 const struct clkops *ops; member in struct:clk
33 .ops = _ops, \
76 clk->ops->enable(clk); clk_enable()
92 clk->ops->disable(clk); clk_disable()
100 if (clk && clk->ops && clk->ops->get_rate) clk_get_rate()
101 return clk->ops->get_rate(clk); clk_get_rate()
/linux-4.4.14/drivers/sh/clk/
H A Dcore.c230 if (clkp->ops && clkp->ops->recalc) propagate_rate()
231 clkp->rate = clkp->ops->recalc(clkp); propagate_rate()
244 if (likely(allow_disable && clk->ops && clk->ops->disable)) __clk_disable()
245 clk->ops->disable(clk); __clk_disable()
275 if (clk->ops && clk->ops->enable) { __clk_enable()
276 ret = clk->ops->enable(clk); __clk_enable()
321 if (clkp->ops && clkp->ops->recalc) recalculate_root_clocks()
322 clkp->rate = clkp->ops->recalc(clkp); recalculate_root_clocks()
440 if (clk->ops && clk->ops->init) clk_register()
441 clk->ops->init(clk); clk_register()
483 if (likely(clk->ops && clk->ops->set_rate)) { clk_set_rate()
484 ret = clk->ops->set_rate(clk, rate); clk_set_rate()
492 if (clk->ops && clk->ops->recalc) clk_set_rate()
493 clk->rate = clk->ops->recalc(clk); clk_set_rate()
516 if (clk->ops->set_parent) clk_set_parent()
517 ret = clk->ops->set_parent(clk, parent); clk_set_parent()
522 if (clk->ops->recalc) clk_set_parent()
523 clk->rate = clk->ops->recalc(clk); clk_set_parent()
544 if (likely(clk->ops && clk->ops->round_rate)) { clk_round_rate()
548 rounded = clk->ops->round_rate(clk, rate); clk_round_rate()
652 if (likely(clkp->usecount && clkp->ops)) { clks_core_resume()
655 if (likely(clkp->ops->set_parent)) clks_core_resume()
656 clkp->ops->set_parent(clkp, clks_core_resume()
658 if (likely(clkp->ops->set_rate)) clks_core_resume()
659 clkp->ops->set_rate(clkp, rate); clks_core_resume()
660 else if (likely(clkp->ops->recalc)) clks_core_resume()
661 clkp->rate = clkp->ops->recalc(clkp); clks_core_resume()
689 if (!clk->usecount && clk->ops && clk->ops->disable) clk_late_init()
690 clk->ops->disable(clk); clk_late_init()
/linux-4.4.14/drivers/pci/hotplug/
H A Dpci_hotplug_core.c69 struct hotplug_slot_ops *ops = slot->ops; \
71 if (!try_module_get(ops->owner)) \
73 if (ops->get_##name) \
74 retval = ops->get_##name(slot, value); \
77 module_put(ops->owner); \
110 if (!try_module_get(slot->ops->owner)) { power_write_file()
116 if (slot->ops->disable_slot) power_write_file()
117 retval = slot->ops->disable_slot(slot); power_write_file()
121 if (slot->ops->enable_slot) power_write_file()
122 retval = slot->ops->enable_slot(slot); power_write_file()
129 module_put(slot->ops->owner); power_write_file()
158 struct hotplug_slot_ops *ops = pci_slot->hotplug->ops; attention_write_file() local
167 if (!try_module_get(ops->owner)) { attention_write_file()
171 if (ops->set_attention_status) attention_write_file()
172 retval = ops->set_attention_status(pci_slot->hotplug, attention); attention_write_file()
173 module_put(ops->owner); attention_write_file()
233 if (!try_module_get(slot->ops->owner)) { test_write_file()
237 if (slot->ops->hardware_test) test_write_file()
238 retval = slot->ops->hardware_test(slot, test); test_write_file()
239 module_put(slot->ops->owner); test_write_file()
256 if ((!slot) || (!slot->ops)) has_power_file()
258 if ((slot->ops->enable_slot) || has_power_file()
259 (slot->ops->disable_slot) || has_power_file()
260 (slot->ops->get_power_status)) has_power_file()
269 if ((!slot) || (!slot->ops)) has_attention_file()
271 if ((slot->ops->set_attention_status) || has_attention_file()
272 (slot->ops->get_attention_status)) has_attention_file()
281 if ((!slot) || (!slot->ops)) has_latch_file()
283 if (slot->ops->get_latch_status) has_latch_file()
292 if ((!slot) || (!slot->ops)) has_adapter_file()
294 if (slot->ops->get_adapter_status) has_adapter_file()
303 if ((!slot) || (!slot->ops)) has_test_file()
305 if (slot->ops->hardware_test) has_test_file()
432 if ((slot->info == NULL) || (slot->ops == NULL)) __pci_hp_register()
439 slot->ops->owner = owner; __pci_hp_register()
440 slot->ops->mod_name = mod_name; __pci_hp_register()
H A Dpciehp_core.c80 kfree(hotplug_slot->ops); release_slot()
90 struct hotplug_slot_ops *ops = NULL; init_slot() local
102 /* Setup hotplug slot ops */ init_slot()
103 ops = kzalloc(sizeof(*ops), GFP_KERNEL); init_slot()
104 if (!ops) init_slot()
107 ops->enable_slot = enable_slot; init_slot()
108 ops->disable_slot = disable_slot; init_slot()
109 ops->get_power_status = get_power_status; init_slot()
110 ops->get_adapter_status = get_adapter_status; init_slot()
111 ops->reset_slot = reset_slot; init_slot()
113 ops->get_latch_status = get_latch_status; init_slot()
115 ops->get_attention_status = get_attention_status; init_slot()
116 ops->set_attention_status = set_attention_status; init_slot()
123 hotplug->ops = ops; init_slot()
133 kfree(ops); init_slot()
/linux-4.4.14/sound/core/seq/
H A Dseq_midi_emul.c47 static void note_off(struct snd_midi_op *ops, void *drv,
50 static void do_control(struct snd_midi_op *ops, void *private,
54 static void rpn(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan,
56 static void nrpn(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan,
58 static void sysex(struct snd_midi_op *ops, void *private, unsigned char *sysex,
60 static void all_sounds_off(struct snd_midi_op *ops, void *private,
62 static void all_notes_off(struct snd_midi_op *ops, void *private,
83 snd_midi_process_event(struct snd_midi_op *ops, snd_midi_process_event() argument
130 if (ops->note_off) snd_midi_process_event()
131 ops->note_off(drv, ev->data.note.note, 0, chan); snd_midi_process_event()
134 if (ops->note_on) snd_midi_process_event()
135 ops->note_on(drv, ev->data.note.note, ev->data.note.velocity, chan); snd_midi_process_event()
140 if (ops->note_off) snd_midi_process_event()
141 note_off(ops, drv, chan, ev->data.note.note, ev->data.note.velocity); snd_midi_process_event()
144 if (ops->key_press) snd_midi_process_event()
145 ops->key_press(drv, ev->data.note.note, ev->data.note.velocity, chan); snd_midi_process_event()
148 do_control(ops, drv, chanset, chan, snd_midi_process_event()
156 if (ops->control) snd_midi_process_event()
157 ops->control(drv, MIDI_CTL_PITCHBEND, chan); snd_midi_process_event()
161 if (ops->control) snd_midi_process_event()
162 ops->control(drv, MIDI_CTL_CHAN_PRESSURE, chan); snd_midi_process_event()
170 do_control(ops, drv, chanset, chan, snd_midi_process_event()
174 do_control(ops, drv, chanset, chan, snd_midi_process_event()
189 nrpn(ops, drv, chan, chanset); snd_midi_process_event()
202 rpn(ops, drv, chan, chanset); snd_midi_process_event()
210 sysex(ops, drv, sysexbuf, len, chanset); snd_midi_process_event()
245 note_off(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan, note_off() argument
257 if (ops->note_off) note_off()
258 ops->note_off(drv, note, vel, chan); note_off()
267 do_control(struct snd_midi_op *ops, void *drv, struct snd_midi_channel_set *chset, do_control() argument
289 if (ops->note_off) do_control()
290 ops->note_off(drv, i, 0, chan); do_control()
311 if (ops->note_off) do_control()
312 ops->note_off(drv, i, 0, chan); do_control()
323 rpn(ops, drv, chan, chset); do_control()
325 nrpn(ops, drv, chan, chset); do_control()
337 all_sounds_off(ops, drv, chan); do_control()
341 all_notes_off(ops, drv, chan); do_control()
375 if (ops->control) do_control()
376 ops->control(drv, control, chan); do_control()
417 rpn(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan, rpn() argument
457 nrpn(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan, nrpn() argument
461 if (ops->nrpn) nrpn()
462 ops->nrpn(drv, chan, chset); nrpn()
485 sysex(struct snd_midi_op *ops, void *private, unsigned char *buf, int len, sysex() argument
591 if (ops->sysex) sysex()
592 ops->sysex(private, buf - 1, len + 1, parsed, chset); sysex()
599 all_sounds_off(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan) all_sounds_off() argument
603 if (! ops->note_terminate) all_sounds_off()
607 ops->note_terminate(drv, n, chan); all_sounds_off()
617 all_notes_off(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan) all_notes_off() argument
621 if (! ops->note_off) all_notes_off()
625 note_off(ops, drv, chan, n, 0); all_notes_off()
/linux-4.4.14/drivers/media/radio/
H A Dradio-isa.c63 const struct radio_isa_ops *ops = isa->drv->ops; radio_isa_g_tuner() local
76 if (ops->g_rxsubchans) radio_isa_g_tuner()
77 v->rxsubchans = ops->g_rxsubchans(isa); radio_isa_g_tuner()
81 if (ops->g_signal) radio_isa_g_tuner()
82 v->signal = ops->g_signal(isa); radio_isa_g_tuner()
93 const struct radio_isa_ops *ops = isa->drv->ops; radio_isa_s_tuner() local
97 if (ops->s_stereo) { radio_isa_s_tuner()
99 return ops->s_stereo(isa, isa->stereo); radio_isa_s_tuner()
114 res = isa->drv->ops->s_frequency(isa, freq); radio_isa_s_frequency()
139 return isa->drv->ops->s_mute_volume(isa, ctrl->val, radio_isa_s_ctrl()
199 struct radio_isa_card *isa = drv->ops->alloc(); radio_isa_alloc()
216 const struct radio_isa_ops *ops = drv->ops; radio_isa_common_probe() local
260 if (ops->init) radio_isa_common_probe()
261 res = ops->init(isa); radio_isa_common_probe()
265 res = ops->s_frequency(isa, isa->freq); radio_isa_common_probe()
266 if (!res && ops->s_stereo) radio_isa_common_probe()
267 res = ops->s_stereo(isa, isa->stereo); radio_isa_common_probe()
294 const struct radio_isa_ops *ops = isa->drv->ops; radio_isa_common_remove() local
296 ops->s_mute_volume(isa, true, isa->volume ? isa->volume->cur.val : 0); radio_isa_common_remove()
309 const struct radio_isa_ops *ops = drv->ops; radio_isa_probe() local
319 if (drv->probe && ops->probe) { radio_isa_probe()
326 bool found = ops->probe(isa, io); radio_isa_probe()
/linux-4.4.14/drivers/clk/ti/
H A Dinterface.c38 const struct clk_hw_omap_ops *ops) _register_interface()
49 clk_hw->ops = ops; _register_interface()
55 init.ops = &ti_interface_clk_ops; _register_interface()
74 const struct clk_hw_omap_ops *ops = &clkhwops_iclk_wait; ti_clk_register_interface() local
85 ops = &clkhwops_iclk; ti_clk_register_interface()
88 ops = &clkhwops_omap3430es2_iclk_hsotgusb_wait; ti_clk_register_interface()
91 ops = &clkhwops_omap3430es2_iclk_dss_usbhost_wait; ti_clk_register_interface()
94 ops = &clkhwops_omap3430es2_iclk_ssi_wait; ti_clk_register_interface()
97 ops = &clkhwops_am35xx_ipss_wait; ti_clk_register_interface()
100 (void __iomem *)reg, gate->bit_shift, ops); ti_clk_register_interface()
105 const struct clk_hw_omap_ops *ops) _of_ti_interface_clk_setup()
127 enable_bit, ops); _of_ti_interface_clk_setup()
35 _register_interface(struct device *dev, const char *name, const char *parent_name, void __iomem *reg, u8 bit_idx, const struct clk_hw_omap_ops *ops) _register_interface() argument
104 _of_ti_interface_clk_setup(struct device_node *node, const struct clk_hw_omap_ops *ops) _of_ti_interface_clk_setup() argument
H A Dautoidle.c51 if (c->ops && c->ops->deny_idle) omap2_clk_deny_idle()
52 c->ops->deny_idle(c); omap2_clk_deny_idle()
67 if (c->ops && c->ops->allow_idle) omap2_clk_allow_idle()
68 c->ops->allow_idle(c); omap2_clk_allow_idle()
204 if (c->ops && c->ops->allow_idle) omap2_clk_enable_autoidle_all()
205 c->ops->allow_idle(c); omap2_clk_enable_autoidle_all()
226 if (c->ops && c->ops->deny_idle) omap2_clk_disable_autoidle_all()
227 c->ops->deny_idle(c); omap2_clk_disable_autoidle_all()
H A Dgate.c98 u8 clk_gate_flags, const struct clk_ops *ops, _register_gate()
112 init.ops = ops; _register_gate()
116 clk_hw->ops = hw_ops; _register_gate()
136 const struct clk_ops *ops = &omap_gate_clk_ops; ti_clk_register_gate() local
158 ops = &omap_gate_clk_hsdiv_restore_ops; ti_clk_register_gate()
169 ops = &omap_gate_clkdm_clk_ops; ti_clk_register_gate()
179 clk_gate_flags, ops, hw_ops); ti_clk_register_gate()
186 const struct clk_hw_omap_ops *ops = &clkhwops_wait; ti_clk_build_component_gate() local
202 ops = NULL; ti_clk_build_component_gate()
205 ops = &clkhwops_iclk_wait; ti_clk_build_component_gate()
207 gate->ops = ops; ti_clk_build_component_gate()
215 const struct clk_ops *ops, _of_ti_gate_clk_setup()
226 if (ops != &omap_gate_clkdm_clk_ops) { _of_ti_gate_clk_setup()
249 enable_bit, clk_gate_flags, ops, hw_ops); _of_ti_gate_clk_setup()
273 gate->ops = hw_ops; _of_ti_composite_gate_clk_setup()
95 _register_gate(struct device *dev, const char *name, const char *parent_name, unsigned long flags, void __iomem *reg, u8 bit_idx, u8 clk_gate_flags, const struct clk_ops *ops, const struct clk_hw_omap_ops *hw_ops) _register_gate() argument
214 _of_ti_gate_clk_setup(struct device_node *node, const struct clk_ops *ops, const struct clk_hw_omap_ops *hw_ops) _of_ti_gate_clk_setup() argument
/linux-4.4.14/arch/arm/mach-omap1/
H A Dclock_data.c80 .ops = &clkops_null,
86 .ops = &clkops_null,
97 .ops = &clkops_generic,
110 .ops = &clkops_generic,
121 .ops = &clkops_null,
132 .ops = &clkops_generic,
151 .ops = &clkops_generic,
162 .ops = &clkops_generic,
175 .ops = &clkops_generic,
188 .ops = &clkops_generic,
201 .ops = &clkops_null,
213 .ops = &clkops_generic,
225 .ops = &clkops_null,
235 .ops = &clkops_dspck,
247 .ops = &clkops_dspck,
256 .ops = &clkops_dspck,
266 .ops = &clkops_null,
279 .ops = &clkops_null,
291 .ops = &clkops_null,
299 .ops = &clkops_generic,
308 .ops = &clkops_generic,
321 .ops = &clkops_generic,
332 .ops = &clkops_null,
339 .ops = &clkops_null,
347 .ops = &clkops_generic,
360 .ops = &clkops_generic,
372 .ops = &clkops_null,
379 .ops = &clkops_null,
386 .ops = &clkops_generic,
399 .ops = &clkops_generic,
420 .ops = &clkops_null,
440 .ops = &clkops_uart_16xx,
459 .ops = &clkops_null,
478 .ops = &clkops_null,
498 .ops = &clkops_uart_16xx,
511 .ops = &clkops_generic,
521 .ops = &clkops_generic,
531 .ops = &clkops_generic,
542 .ops = &clkops_generic,
551 .ops = &clkops_generic,
560 .ops = &clkops_generic,
569 .ops = &clkops_generic,
578 .ops = &clkops_generic,
589 .ops = &clkops_generic,
596 .ops = &clkops_generic,
607 .ops = &clkops_generic,
622 .ops = &clkops_generic,
633 .ops = &clkops_generic,
644 .ops = &clkops_null,
655 .ops = &clkops_null,
663 .ops = &clkops_null,
/linux-4.4.14/drivers/net/ethernet/hisilicon/hns/
H A Dhns_ethtool.c60 if (h->dev && h->dev->ops && h->dev->ops->get_status) hns_nic_get_link()
61 link_stat = link_stat && h->dev->ops->get_status(h); hns_nic_get_link()
137 if (!h->dev || !h->dev->ops || !h->dev->ops->get_info) hns_nic_get_settings()
140 ret = h->dev->ops->get_info(h, NULL, &speed, &duplex); hns_nic_get_settings()
203 !priv->ae_handle->dev->ops) hns_nic_set_settings()
231 if (h->dev->ops->adjust_link) { hns_nic_set_settings()
232 h->dev->ops->adjust_link(h, (int)speed, cmd->duplex); hns_nic_set_settings()
322 if ((h->dev->ops->set_loopback) && __lb_setup()
324 ret = h->dev->ops->set_loopback(h, loop, 0x1); __lb_setup()
327 if (h->dev->ops->set_loopback) __lb_setup()
328 ret = h->dev->ops->set_loopback(h, loop, 0x1); __lb_setup()
334 if (h->dev->ops->set_loopback) { __lb_setup()
336 ret |= h->dev->ops->set_loopback(h, __lb_setup()
339 ret |= h->dev->ops->set_loopback(h, __lb_setup()
376 ret = h->dev->ops->start ? h->dev->ops->start(h) : 0; __lb_up()
390 h->dev->ops->adjust_link(h, speed, duplex); __lb_up()
575 if (h->dev->ops->stop) __lb_down()
576 h->dev->ops->stop(h); __lb_down()
681 struct hnae_ae_ops *ops; hns_get_ringparam() local
686 ops = priv->ae_handle->dev->ops; hns_get_ringparam()
688 if (ops->get_ring_bdnum_limit) hns_get_ringparam()
689 ops->get_ring_bdnum_limit(queue, &uplimit); hns_get_ringparam()
706 struct hnae_ae_ops *ops; hns_get_pauseparam() local
708 ops = priv->ae_handle->dev->ops; hns_get_pauseparam()
710 if (ops->get_pauseparam) hns_get_pauseparam()
711 ops->get_pauseparam(priv->ae_handle, &param->autoneg, hns_get_pauseparam()
727 struct hnae_ae_ops *ops; hns_set_pauseparam() local
732 ops = h->dev->ops; hns_set_pauseparam()
734 if (!ops->set_pauseparam) hns_set_pauseparam()
737 return ops->set_pauseparam(priv->ae_handle, param->autoneg, hns_set_pauseparam()
752 struct hnae_ae_ops *ops; hns_get_coalesce() local
754 ops = priv->ae_handle->dev->ops; hns_get_coalesce()
759 if ((!ops->get_coalesce_usecs) || hns_get_coalesce()
760 (!ops->get_rx_max_coalesced_frames)) hns_get_coalesce()
763 ops->get_coalesce_usecs(priv->ae_handle, hns_get_coalesce()
767 ops->get_rx_max_coalesced_frames( hns_get_coalesce()
786 struct hnae_ae_ops *ops; hns_set_coalesce() local
791 ops = priv->ae_handle->dev->ops; hns_set_coalesce()
799 if ((!ops->set_coalesce_usecs) || hns_set_coalesce()
800 (!ops->set_coalesce_frames)) hns_set_coalesce()
803 ops->set_coalesce_usecs(priv->ae_handle, hns_set_coalesce()
806 ret = ops->set_coalesce_frames( hns_set_coalesce()
844 if (!h->dev->ops->get_stats || !h->dev->ops->update_stats) { hns_get_ethtool_stats()
849 h->dev->ops->update_stats(h, &netdev->stats); hns_get_ethtool_stats()
884 h->dev->ops->get_stats(h, &p[26]); hns_get_ethtool_stats()
899 if (!h->dev->ops->get_strings) { hns_get_strings()
900 netdev_err(netdev, "h->dev->ops->get_strings is null!\n"); hns_get_strings()
972 h->dev->ops->get_strings(h, stringset, (u8 *)buff); hns_get_strings()
987 struct hnae_ae_ops *ops = h->dev->ops; hns_get_sset_count() local
989 if (!ops->get_sset_count) { hns_get_sset_count()
1004 return (HNS_NET_STATS_CNT + ops->get_sset_count(h, stringset)); hns_get_sset_count()
1105 return h->dev->ops->set_led_id(h, HNAE_LED_ACTIVE); hns_set_phys_id()
1107 return h->dev->ops->set_led_id(h, HNAE_LED_ON); hns_set_phys_id()
1109 return h->dev->ops->set_led_id(h, HNAE_LED_OFF); hns_set_phys_id()
1111 return h->dev->ops->set_led_id(h, HNAE_LED_INACTIVE); hns_set_phys_id()
1129 struct hnae_ae_ops *ops; hns_get_regs() local
1133 ops = priv->ae_handle->dev->ops; hns_get_regs()
1136 if (!ops->get_regs) { hns_get_regs()
1137 netdev_err(net_dev, "ops->get_regs is null!\n"); hns_get_regs()
1140 ops->get_regs(priv->ae_handle, data); hns_get_regs()
1153 struct hnae_ae_ops *ops; hns_get_regs_len() local
1157 ops = priv->ae_handle->dev->ops; hns_get_regs_len()
1158 if (!ops->get_regs_len) { hns_get_regs_len()
1159 netdev_err(net_dev, "ops->get_regs_len is null!\n"); hns_get_regs_len()
1163 reg_num = ops->get_regs_len(priv->ae_handle); hns_get_regs_len()
/linux-4.4.14/drivers/media/tuners/
H A Dmc44s803.c99 if (fe->ops.i2c_gate_ctrl) mc44s803_init()
100 fe->ops.i2c_gate_ctrl(fe, 1); mc44s803_init()
205 if (fe->ops.i2c_gate_ctrl) mc44s803_init()
206 fe->ops.i2c_gate_ctrl(fe, 0); mc44s803_init()
210 if (fe->ops.i2c_gate_ctrl) mc44s803_init()
211 fe->ops.i2c_gate_ctrl(fe, 0); mc44s803_init()
237 if (fe->ops.i2c_gate_ctrl) mc44s803_set_params()
238 fe->ops.i2c_gate_ctrl(fe, 1); mc44s803_set_params()
281 if (fe->ops.i2c_gate_ctrl) mc44s803_set_params()
282 fe->ops.i2c_gate_ctrl(fe, 0); mc44s803_set_params()
287 if (fe->ops.i2c_gate_ctrl) mc44s803_set_params()
288 fe->ops.i2c_gate_ctrl(fe, 0); mc44s803_set_params()
342 if (fe->ops.i2c_gate_ctrl) mc44s803_attach()
343 fe->ops.i2c_gate_ctrl(fe, 1); /* open i2c_gate */ mc44s803_attach()
358 memcpy(&fe->ops.tuner_ops, &mc44s803_tuner_ops, mc44s803_attach()
363 if (fe->ops.i2c_gate_ctrl) mc44s803_attach()
364 fe->ops.i2c_gate_ctrl(fe, 0); /* close i2c_gate */ mc44s803_attach()
369 if (fe->ops.i2c_gate_ctrl) mc44s803_attach()
370 fe->ops.i2c_gate_ctrl(fe, 0); /* close i2c_gate */ mc44s803_attach()
H A Dtda18218.c150 if (fe->ops.i2c_gate_ctrl) tda18218_set_params()
151 fe->ops.i2c_gate_ctrl(fe, 1); /* open I2C-gate */ tda18218_set_params()
210 if (fe->ops.i2c_gate_ctrl) tda18218_set_params()
211 fe->ops.i2c_gate_ctrl(fe, 0); /* close I2C-gate */ tda18218_set_params()
232 if (fe->ops.i2c_gate_ctrl) tda18218_sleep()
233 fe->ops.i2c_gate_ctrl(fe, 1); /* open I2C-gate */ tda18218_sleep()
238 if (fe->ops.i2c_gate_ctrl) tda18218_sleep()
239 fe->ops.i2c_gate_ctrl(fe, 0); /* close I2C-gate */ tda18218_sleep()
254 if (fe->ops.i2c_gate_ctrl) tda18218_init()
255 fe->ops.i2c_gate_ctrl(fe, 1); /* open I2C-gate */ tda18218_init()
259 if (fe->ops.i2c_gate_ctrl) tda18218_init()
260 fe->ops.i2c_gate_ctrl(fe, 0); /* close I2C-gate */ tda18218_init()
317 if (fe->ops.i2c_gate_ctrl) tda18218_attach()
318 fe->ops.i2c_gate_ctrl(fe, 1); /* open I2C-gate */ tda18218_attach()
333 memcpy(&fe->ops.tuner_ops, &tda18218_tuner_ops, tda18218_attach()
348 if (fe->ops.i2c_gate_ctrl) tda18218_attach()
349 fe->ops.i2c_gate_ctrl(fe, 0); /* close I2C-gate */ tda18218_attach()
H A Dtda8290.c237 if (fe->ops.analog_ops.i2c_gate_ctrl) tda8290_set_params()
238 fe->ops.analog_ops.i2c_gate_ctrl(fe, 1); tda8290_set_params()
240 if (fe->ops.tuner_ops.set_analog_params) tda8290_set_params()
241 fe->ops.tuner_ops.set_analog_params(fe, params); tda8290_set_params()
307 if (fe->ops.analog_ops.i2c_gate_ctrl) tda8290_set_params()
308 fe->ops.analog_ops.i2c_gate_ctrl(fe, 0); tda8290_set_params()
431 if (fe->ops.analog_ops.i2c_gate_ctrl) tda8295_set_params()
432 fe->ops.analog_ops.i2c_gate_ctrl(fe, 1); tda8295_set_params()
434 if (fe->ops.tuner_ops.set_analog_params) tda8295_set_params()
435 fe->ops.tuner_ops.set_analog_params(fe, params); tda8295_set_params()
446 if (fe->ops.analog_ops.i2c_gate_ctrl) tda8295_set_params()
447 fe->ops.analog_ops.i2c_gate_ctrl(fe, 0); tda8295_set_params()
476 if (fe->ops.analog_ops.i2c_gate_ctrl) tda8290_standby()
477 fe->ops.analog_ops.i2c_gate_ctrl(fe, 1); tda8290_standby()
481 if (fe->ops.analog_ops.i2c_gate_ctrl) tda8290_standby()
482 fe->ops.analog_ops.i2c_gate_ctrl(fe, 0); tda8290_standby()
551 if (fe->ops.analog_ops.i2c_gate_ctrl) tda8290_init_tuner()
552 fe->ops.analog_ops.i2c_gate_ctrl(fe, 1); tda8290_init_tuner()
554 if (fe->ops.analog_ops.i2c_gate_ctrl) tda8290_init_tuner()
555 fe->ops.analog_ops.i2c_gate_ctrl(fe, 0); tda8290_init_tuner()
567 if (fe->ops.tuner_ops.release) tda829x_release()
568 fe->ops.tuner_ops.release(fe); tda829x_release()
586 if (fe->ops.analog_ops.i2c_gate_ctrl) tda829x_find_tuner()
587 fe->ops.analog_ops.i2c_gate_ctrl(fe, 1); tda829x_find_tuner()
605 if (fe->ops.analog_ops.i2c_gate_ctrl) tda829x_find_tuner()
606 fe->ops.analog_ops.i2c_gate_ctrl(fe, 0); tda829x_find_tuner()
629 if (fe->ops.analog_ops.i2c_gate_ctrl) tda829x_find_tuner()
630 fe->ops.analog_ops.i2c_gate_ctrl(fe, 1); tda829x_find_tuner()
635 if (fe->ops.analog_ops.i2c_gate_ctrl) tda829x_find_tuner()
636 fe->ops.analog_ops.i2c_gate_ctrl(fe, 0); tda829x_find_tuner()
656 if (fe->ops.tuner_ops.init) tda829x_find_tuner()
657 fe->ops.tuner_ops.init(fe); tda829x_find_tuner()
659 if (fe->ops.tuner_ops.sleep) tda829x_find_tuner()
660 fe->ops.tuner_ops.sleep(fe); tda829x_find_tuner()
662 if (fe->ops.analog_ops.i2c_gate_ctrl) tda829x_find_tuner()
663 fe->ops.analog_ops.i2c_gate_ctrl(fe, 0); tda829x_find_tuner()
762 memcpy(&fe->ops.analog_ops, &tda8290_ops, tda829x_attach()
768 memcpy(&fe->ops.analog_ops, &tda8295_ops, tda829x_attach()
773 fe->ops.analog_ops.i2c_gate_ctrl = NULL; tda829x_attach()
811 fe->ops.analog_ops.info.name = name; tda829x_attach()
823 memset(&fe->ops.analog_ops, 0, sizeof(struct analog_demod_ops)); tda829x_attach()
H A Dfc0012.c113 if (fe->ops.i2c_gate_ctrl) fc0012_init()
114 fe->ops.i2c_gate_ctrl(fe, 1); /* open I2C-gate */ fc0012_init()
122 if (fe->ops.i2c_gate_ctrl) fc0012_init()
123 fe->ops.i2c_gate_ctrl(fe, 0); /* close I2C-gate */ fc0012_init()
271 if (fe->ops.i2c_gate_ctrl) fc0012_set_params()
272 fe->ops.i2c_gate_ctrl(fe, 1); /* open I2C-gate */ fc0012_set_params()
323 if (fe->ops.i2c_gate_ctrl) fc0012_set_params()
324 fe->ops.i2c_gate_ctrl(fe, 0); /* close I2C-gate */ fc0012_set_params()
371 if (fe->ops.i2c_gate_ctrl) fc0012_get_rf_strength()
372 fe->ops.i2c_gate_ctrl(fe, 1); /* open I2C-gate */ fc0012_get_rf_strength()
388 if (fe->ops.i2c_gate_ctrl) fc0012_get_rf_strength()
389 fe->ops.i2c_gate_ctrl(fe, 0); /* close I2C-gate */ fc0012_get_rf_strength()
412 if (fe->ops.i2c_gate_ctrl) fc0012_get_rf_strength()
413 fe->ops.i2c_gate_ctrl(fe, 0); /* close I2C-gate */ fc0012_get_rf_strength()
450 if (fe->ops.i2c_gate_ctrl) fc0012_attach()
451 fe->ops.i2c_gate_ctrl(fe, 1); fc0012_attach()
498 memcpy(&fe->ops.tuner_ops, &fc0012_tuner_ops, fc0012_attach()
502 if (fe->ops.i2c_gate_ctrl) fc0012_attach()
503 fe->ops.i2c_gate_ctrl(fe, 0); fc0012_attach()
/linux-4.4.14/crypto/
H A Dcompress.c38 struct compress_tfm *ops = &tfm->crt_compress; crypto_init_compress_ops() local
40 ops->cot_compress = crypto_compress; crypto_init_compress_ops()
41 ops->cot_decompress = crypto_decompress; crypto_init_compress_ops()
/linux-4.4.14/sound/pci/ctxfi/
H A Dctsrc.c185 src->rsc.ops->master(&src->rsc); src_commit_write()
190 hw->src_commit_write(hw, src->rsc.ops->index(&src->rsc), src_commit_write()
198 src->rsc.ops->next_conj(&src->rsc); src_commit_write()
200 hw->src_commit_write(hw, src->rsc.ops->index(&src->rsc), src_commit_write()
203 src->rsc.ops->master(&src->rsc); src_commit_write()
213 return hw->src_get_ca(hw, src->rsc.ops->index(&src->rsc), src_get_ca()
254 src->rsc.ops->master(&src->rsc); src_default_config_memrd()
255 hw->src_commit_write(hw, src->rsc.ops->index(&src->rsc), src_default_config_memrd()
259 src->rsc.ops->next_conj(&src->rsc); src_default_config_memrd()
261 hw->src_commit_write(hw, src->rsc.ops->index(&src->rsc), src_default_config_memrd()
264 src->rsc.ops->master(&src->rsc); src_default_config_memrd()
290 src->rsc.ops->master(&src->rsc); src_default_config_memwr()
291 hw->src_commit_write(hw, src->rsc.ops->index(&src->rsc), src_default_config_memwr()
326 src->rsc.ops->master(&src->rsc); src_default_config_arcrw()
329 hw->src_commit_write(hw, src->rsc.ops->index(&src->rsc), src_default_config_arcrw()
331 src->rsc.ops->next_conj(&src->rsc); src_default_config_arcrw()
333 src->rsc.ops->master(&src->rsc); src_default_config_arcrw()
374 p->ops = &src_rsc_ops; src_rsc_init()
406 p->ops = NULL; src_rsc_uninit()
476 src->rsc.ops->master(&src->rsc); put_src_rsc()
479 src->rsc.ops->index(&src->rsc)); put_src_rsc()
481 mgr_put_resource(&mgr->mgr, 1, src->rsc.ops->index(&src->rsc)); put_src_rsc()
495 src->rsc.ops->master(&src->rsc); src_enable_s()
498 src->rsc.ops->index(&src->rsc)); src_enable_s()
499 src->rsc.ops->next_conj(&src->rsc); src_enable_s()
501 src->rsc.ops->master(&src->rsc); src_enable_s()
511 src->rsc.ops->master(&src->rsc); src_enable()
514 src->rsc.ops->index(&src->rsc)); src_enable()
515 src->rsc.ops->next_conj(&src->rsc); src_enable()
517 src->rsc.ops->master(&src->rsc); src_enable()
527 src->rsc.ops->master(&src->rsc); src_disable()
530 src->rsc.ops->index(&src->rsc)); src_disable()
531 src->rsc.ops->next_conj(&src->rsc); src_disable()
533 src->rsc.ops->master(&src->rsc); src_disable()
626 srcimp->rsc.ops->master(&srcimp->rsc); srcimp_map()
627 src->rsc.ops->master(&src->rsc); srcimp_map()
628 input->ops->master(input); srcimp_map()
633 entry->slot = input->ops->output_slot(input); srcimp_map()
634 entry->user = src->rsc.ops->index(&src->rsc); srcimp_map()
635 entry->addr = srcimp->rsc.ops->index(&srcimp->rsc); srcimp_map()
639 srcimp->rsc.ops->next_conj(&srcimp->rsc); srcimp_map()
640 input->ops->next_conj(input); srcimp_map()
643 srcimp->rsc.ops->master(&srcimp->rsc); srcimp_map()
644 input->ops->master(input); srcimp_map()
690 srcimp->rsc.ops = &srcimp_basic_rsc_ops; srcimp_rsc_init()
691 srcimp->ops = &srcimp_ops; srcimp_rsc_init()
694 srcimp->rsc.ops->master(&srcimp->rsc); srcimp_rsc_init()
709 srcimp->ops = NULL; srcimp_rsc_uninit()
H A Dctatc.c270 src->ops->set_pitch(src, pitch); atc_pcm_playback_prepare()
271 src->ops->set_rom(src, select_rom(pitch)); atc_pcm_playback_prepare()
272 src->ops->set_sf(src, convert_format(apcm->substream->runtime->format, atc_pcm_playback_prepare()
274 src->ops->set_pm(src, (src->ops->next_interleave(src) != NULL)); atc_pcm_playback_prepare()
303 amixer->ops->setup(amixer, &src->rsc, atc_pcm_playback_prepare()
306 src = src->ops->next_interleave(src); atc_pcm_playback_prepare()
333 srcimp->ops->unmap(srcimp); atc_pcm_release_resources()
390 src->ops->set_sa(src, apcm->vm_block->addr); atc_pcm_playback_start()
391 src->ops->set_la(src, apcm->vm_block->addr + apcm->vm_block->size); atc_pcm_playback_start()
392 src->ops->set_ca(src, apcm->vm_block->addr + max_cisz); atc_pcm_playback_start()
393 src->ops->set_cisz(src, max_cisz); atc_pcm_playback_start()
395 src->ops->set_bm(src, 1); atc_pcm_playback_start()
396 src->ops->set_state(src, SRC_STATE_INIT); atc_pcm_playback_start()
397 src->ops->commit_write(src); atc_pcm_playback_start()
411 src->ops->set_bm(src, 0); atc_pcm_stop()
412 src->ops->set_state(src, SRC_STATE_OFF); atc_pcm_stop()
413 src->ops->commit_write(src); atc_pcm_stop()
418 src->ops->set_bm(src, 0); atc_pcm_stop()
419 src->ops->set_state(src, SRC_STATE_OFF); atc_pcm_stop()
420 src->ops->commit_write(src); atc_pcm_stop()
438 position = src->ops->get_ca(src); atc_pcm_playback_position()
575 src->ops->set_pitch(src, pitch); atc_pcm_capture_get_resources()
576 src->ops->set_rom(src, select_rom(pitch)); atc_pcm_capture_get_resources()
577 src->ops->set_vo(src, src_node_conf[i/multi].vo); atc_pcm_capture_get_resources()
633 src->ops->set_pitch(src, pitch); atc_pcm_capture_get_resources()
675 amixer->ops->setup(amixer, out_ports[i], atc_pcm_capture_prepare()
687 srcimp->ops->map(srcimp, src, out_ports[i%multi]); atc_pcm_capture_prepare()
688 amixer->ops->setup(amixer, &src->rsc, INIT_VOL, NULL); atc_pcm_capture_prepare()
699 out_ports[i]->ops->master(out_ports[i]); atc_pcm_capture_prepare()
702 amixer->ops->set_input(amixer, out_ports[i]); atc_pcm_capture_prepare()
703 amixer->ops->set_scale(amixer, INIT_VOL); atc_pcm_capture_prepare()
704 amixer->ops->set_sum(amixer, NULL); atc_pcm_capture_prepare()
705 amixer->ops->commit_raw_write(amixer); atc_pcm_capture_prepare()
706 out_ports[i]->ops->next_conj(out_ports[i]); atc_pcm_capture_prepare()
709 srcimp->ops->map(srcimp, apcm->src, atc_pcm_capture_prepare()
716 srcimp->ops->map(srcimp, apcm->src, out_ports[i]); atc_pcm_capture_prepare()
739 src->ops->set_pm(src, ((i%multi) != (multi-1))); atc_pcm_capture_start()
745 src->ops->set_sf(src, convert_format(apcm->substream->runtime->format, atc_pcm_capture_start()
747 src->ops->set_sa(src, apcm->vm_block->addr); atc_pcm_capture_start()
748 src->ops->set_la(src, apcm->vm_block->addr + apcm->vm_block->size); atc_pcm_capture_start()
749 src->ops->set_ca(src, apcm->vm_block->addr); atc_pcm_capture_start()
758 src->ops->set_state(src, SRC_STATE_RUN); atc_pcm_capture_start()
759 src->ops->commit_write(src); atc_pcm_capture_start()
763 src->ops->set_bm(src, 1); atc_pcm_capture_start()
764 src->ops->set_state(src, SRC_STATE_RUN); atc_pcm_capture_start()
765 src->ops->commit_write(src); atc_pcm_capture_start()
782 return src->ops->get_ca(src) - apcm->vm_block->addr; atc_pcm_capture_position()
813 src->ops->set_pitch(src, pitch); spdif_passthru_playback_get_resources()
814 src->ops->set_rom(src, select_rom(pitch)); spdif_passthru_playback_get_resources()
815 src->ops->set_sf(src, convert_format(apcm->substream->runtime->format, spdif_passthru_playback_get_resources()
817 src->ops->set_pm(src, (src->ops->next_interleave(src) != NULL)); spdif_passthru_playback_get_resources()
818 src->ops->set_bp(src, 1); spdif_passthru_playback_get_resources()
882 dao->ops->get_spos(dao, &status); spdif_passthru_playback_setup()
886 dao->ops->set_spos(dao, status); spdif_passthru_playback_setup()
887 dao->ops->commit_write(dao); spdif_passthru_playback_setup()
922 amixer->ops->setup(amixer, &src->rsc, INIT_VOL, NULL); spdif_passthru_playback_prepare()
923 src = src->ops->next_interleave(src); spdif_passthru_playback_prepare()
931 dao->ops->set_left_input(dao, &amixer->rsc); spdif_passthru_playback_prepare()
933 dao->ops->set_right_input(dao, &amixer->rsc); spdif_passthru_playback_prepare()
1050 return dao->ops->get_spos(dao, status); atc_dao_get_status()
1058 dao->ops->set_spos(dao, status); atc_dao_set_status()
1059 dao->ops->commit_write(dao); atc_dao_set_status()
1126 err = dao->ops->reinit(dao, &da_dsc); atc_spdif_out_passthru()
1132 dao->ops->set_left_input(dao, rscs[0]); atc_spdif_out_passthru()
1133 dao->ops->set_right_input(dao, rscs[1]); atc_spdif_out_passthru()
1138 dao->ops->set_spos(dao, spos); atc_spdif_out_passthru()
1139 dao->ops->commit_write(dao); atc_spdif_out_passthru()
1174 dao->ops->clear_left_input(dao); atc_release_resources()
1175 dao->ops->clear_right_input(dao); atc_release_resources()
1205 srcimp->ops->unmap(srcimp); atc_release_resources()
1465 srcimp->ops->map(srcimp, src, rscs[i]); atc_connect_dai()
1472 src->ops->set_pm(src, 1); atc_connect_dai()
1475 src->ops->set_state(src, SRC_STATE_RUN); atc_connect_dai()
1476 src->ops->commit_write(src); atc_connect_dai()
1480 dai->ops->set_srt_srcl(dai, &(srcs[0]->rsc)); atc_connect_dai()
1481 dai->ops->set_srt_srcr(dai, &(srcs[1]->rsc)); atc_connect_dai()
1483 dai->ops->set_enb_src(dai, 1); atc_connect_dai()
1484 dai->ops->set_enb_srt(dai, 1); atc_connect_dai()
1485 dai->ops->commit_write(dai); atc_connect_dai()
1505 dao->ops->set_left_input(dao, rscs[0]); atc_connect_resources()
1506 dao->ops->set_right_input(dao, rscs[1]); atc_connect_resources()
1683 static struct snd_device_ops ops = { ct_atc_create() local
1742 err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, atc, &ops); ct_atc_create()
H A Dctamixer.c70 rsc->ops->output_slot(rsc)); amixer_set_input()
107 sum->rsc.ops->index(&sum->rsc)); amixer_set_sum()
126 amixer->rsc.ops->master(&amixer->rsc); amixer_commit_write()
128 input->ops->master(input); amixer_commit_write()
131 sum->rsc.ops->master(&sum->rsc); amixer_commit_write()
137 input->ops->output_slot(input)); amixer_commit_write()
138 input->ops->next_conj(input); amixer_commit_write()
142 sum->rsc.ops->index(&sum->rsc)); amixer_commit_write()
143 sum->rsc.ops->next_conj(&sum->rsc); amixer_commit_write()
145 index = amixer->rsc.ops->output_slot(&amixer->rsc); amixer_commit_write()
147 amixer->rsc.ops->next_conj(&amixer->rsc); amixer_commit_write()
149 amixer->rsc.ops->master(&amixer->rsc); amixer_commit_write()
151 input->ops->master(input); amixer_commit_write()
154 sum->rsc.ops->master(&sum->rsc); amixer_commit_write()
165 index = amixer->rsc.ops->output_slot(&amixer->rsc); amixer_commit_raw_write()
212 amixer->rsc.ops = &amixer_basic_rsc_ops; amixer_rsc_init()
213 amixer->ops = &amixer_ops; amixer_rsc_init()
226 amixer->ops = NULL; amixer_rsc_uninit()
377 sum->rsc.ops = &sum_basic_rsc_ops; sum_rsc_init()
/linux-4.4.14/mm/
H A Dfrontswap.c31 #define for_each_frontswap_ops(ops) \
32 for ((ops) = frontswap_ops; (ops); (ops) = (ops)->next)
112 void frontswap_register_ops(struct frontswap_ops *ops) frontswap_register_ops() argument
129 /* the new ops needs to know the currently active swap devices */ for_each_set_bit()
131 ops->init(i); for_each_set_bit()
134 * Setting frontswap_ops must happen after the ops->init() calls for_each_set_bit()
139 ops->next = frontswap_ops; for_each_set_bit()
140 } while (cmpxchg(&frontswap_ops, ops->next, ops) != ops->next);
151 * removed between setting the "a" list bits and the ops init
158 ops->init(i);
160 ops->invalidate_area(i);
190 struct frontswap_ops *ops; __frontswap_init() local
207 for_each_frontswap_ops(ops) __frontswap_init()
208 ops->init(type); __frontswap_init()
249 struct frontswap_ops *ops; __frontswap_store() local
269 for_each_frontswap_ops(ops) __frontswap_store()
270 ops->invalidate_page(type, offset); __frontswap_store()
274 for_each_frontswap_ops(ops) { for_each_frontswap_ops()
275 ret = ops->store(type, offset, page); for_each_frontswap_ops()
304 struct frontswap_ops *ops; __frontswap_load() local
315 for_each_frontswap_ops(ops) { for_each_frontswap_ops()
316 ret = ops->load(type, offset, page); for_each_frontswap_ops()
338 struct frontswap_ops *ops; __frontswap_invalidate_page() local
347 for_each_frontswap_ops(ops) __frontswap_invalidate_page()
348 ops->invalidate_page(type, offset); __frontswap_invalidate_page()
361 struct frontswap_ops *ops; __frontswap_invalidate_area() local
370 for_each_frontswap_ops(ops) __frontswap_invalidate_area()
371 ops->invalidate_area(type); __frontswap_invalidate_area()
/linux-4.4.14/arch/arm/include/asm/mach/
H A Darch.h20 #define smp_ops(ops) (&(ops))
21 #define smp_init_ops(ops) (&(ops))
23 #define smp_ops(ops) (struct smp_operations *)NULL
24 #define smp_init_ops(ops) (bool (*)(void))NULL
/linux-4.4.14/drivers/mtd/nand/
H A Dsm_common.c43 struct mtd_oob_ops ops; sm_block_markbad() local
52 ops.mode = MTD_OPS_PLACE_OOB; sm_block_markbad()
53 ops.ooboffs = 0; sm_block_markbad()
54 ops.ooblen = mtd->oobsize; sm_block_markbad()
55 ops.oobbuf = (void *)&oob; sm_block_markbad()
56 ops.datbuf = NULL; sm_block_markbad()
59 ret = mtd_write_oob(mtd, ofs, &ops); sm_block_markbad()
60 if (ret < 0 || ops.oobretlen != SM_OOB_SIZE) { sm_block_markbad()
/linux-4.4.14/drivers/net/wireless/brcm80211/brcmfmac/
H A Dchip.c235 const struct brcmf_buscore_ops *ops; member in struct:brcmf_chip_priv
253 regdata = ci->ops->read32(ci->ctx, CORE_SB(core->base, sbidhigh)); brcmf_chip_sb_corerev()
265 regdata = ci->ops->read32(ci->ctx, address); brcmf_chip_sb_iscoreup()
278 regdata = ci->ops->read32(ci->ctx, core->wrapbase + BCMA_IOCTL); brcmf_chip_ai_iscoreup()
281 regdata = ci->ops->read32(ci->ctx, core->wrapbase + BCMA_RESET_CTL); brcmf_chip_ai_iscoreup()
295 val = ci->ops->read32(ci->ctx, CORE_SB(base, sbtmstatelow)); brcmf_chip_sb_coredisable()
299 val = ci->ops->read32(ci->ctx, CORE_SB(base, sbtmstatelow)); brcmf_chip_sb_coredisable()
305 val = ci->ops->read32(ci->ctx, CORE_SB(base, sbtmstatelow)); brcmf_chip_sb_coredisable()
306 ci->ops->write32(ci->ctx, CORE_SB(base, sbtmstatelow), brcmf_chip_sb_coredisable()
309 val = ci->ops->read32(ci->ctx, CORE_SB(base, sbtmstatelow)); brcmf_chip_sb_coredisable()
311 SPINWAIT((ci->ops->read32(ci->ctx, CORE_SB(base, sbtmstatehigh)) brcmf_chip_sb_coredisable()
314 val = ci->ops->read32(ci->ctx, CORE_SB(base, sbtmstatehigh)); brcmf_chip_sb_coredisable()
318 val = ci->ops->read32(ci->ctx, CORE_SB(base, sbidlow)); brcmf_chip_sb_coredisable()
320 val = ci->ops->read32(ci->ctx, brcmf_chip_sb_coredisable()
323 ci->ops->write32(ci->ctx, brcmf_chip_sb_coredisable()
325 val = ci->ops->read32(ci->ctx, brcmf_chip_sb_coredisable()
328 SPINWAIT((ci->ops->read32(ci->ctx, brcmf_chip_sb_coredisable()
336 ci->ops->write32(ci->ctx, CORE_SB(base, sbtmstatelow), val); brcmf_chip_sb_coredisable()
337 val = ci->ops->read32(ci->ctx, CORE_SB(base, sbtmstatelow)); brcmf_chip_sb_coredisable()
341 val = ci->ops->read32(ci->ctx, CORE_SB(base, sbidlow)); brcmf_chip_sb_coredisable()
343 val = ci->ops->read32(ci->ctx, brcmf_chip_sb_coredisable()
346 ci->ops->write32(ci->ctx, brcmf_chip_sb_coredisable()
352 ci->ops->write32(ci->ctx, CORE_SB(base, sbtmstatelow), brcmf_chip_sb_coredisable()
366 regdata = ci->ops->read32(ci->ctx, core->wrapbase + BCMA_RESET_CTL); brcmf_chip_ai_coredisable()
371 ci->ops->write32(ci->ctx, core->wrapbase + BCMA_IOCTL, brcmf_chip_ai_coredisable()
373 ci->ops->read32(ci->ctx, core->wrapbase + BCMA_IOCTL); brcmf_chip_ai_coredisable()
376 ci->ops->write32(ci->ctx, core->wrapbase + BCMA_RESET_CTL, brcmf_chip_ai_coredisable()
381 SPINWAIT(ci->ops->read32(ci->ctx, core->wrapbase + BCMA_RESET_CTL) != brcmf_chip_ai_coredisable()
386 ci->ops->write32(ci->ctx, core->wrapbase + BCMA_IOCTL, brcmf_chip_ai_coredisable()
388 ci->ops->read32(ci->ctx, core->wrapbase + BCMA_IOCTL); brcmf_chip_ai_coredisable()
411 ci->ops->write32(ci->ctx, CORE_SB(base, sbtmstatelow), brcmf_chip_sb_resetcore()
414 regdata = ci->ops->read32(ci->ctx, CORE_SB(base, sbtmstatelow)); brcmf_chip_sb_resetcore()
418 regdata = ci->ops->read32(ci->ctx, CORE_SB(base, sbtmstatehigh)); brcmf_chip_sb_resetcore()
420 ci->ops->write32(ci->ctx, CORE_SB(base, sbtmstatehigh), 0); brcmf_chip_sb_resetcore()
422 regdata = ci->ops->read32(ci->ctx, CORE_SB(base, sbimstate)); brcmf_chip_sb_resetcore()
425 ci->ops->write32(ci->ctx, CORE_SB(base, sbimstate), regdata); brcmf_chip_sb_resetcore()
429 ci->ops->write32(ci->ctx, CORE_SB(base, sbtmstatelow), brcmf_chip_sb_resetcore()
431 regdata = ci->ops->read32(ci->ctx, CORE_SB(base, sbtmstatelow)); brcmf_chip_sb_resetcore()
435 ci->ops->write32(ci->ctx, CORE_SB(base, sbtmstatelow), brcmf_chip_sb_resetcore()
437 regdata = ci->ops->read32(ci->ctx, CORE_SB(base, sbtmstatelow)); brcmf_chip_sb_resetcore()
453 while (ci->ops->read32(ci->ctx, core->wrapbase + BCMA_RESET_CTL) & brcmf_chip_ai_resetcore()
455 ci->ops->write32(ci->ctx, core->wrapbase + BCMA_RESET_CTL, 0); brcmf_chip_ai_resetcore()
462 ci->ops->write32(ci->ctx, core->wrapbase + BCMA_IOCTL, brcmf_chip_ai_resetcore()
464 ci->ops->read32(ci->ctx, core->wrapbase + BCMA_IOCTL); brcmf_chip_ai_resetcore()
542 return core->chip->ops->read32(core->chip->ctx, core->pub.base + reg); brcmf_chip_core_read32()
548 core->chip->ops->write32(core->chip->ctx, core->pub.base + reg, val); brcmf_chip_core_write32()
758 val = ci->ops->read32(ci->ctx, *eromaddr); brcmf_chip_dmp_get_desc()
849 eromaddr = ci->ops->read32(ci->ctx, CORE_CC_REG(SI_ENUM_BASE, eromptr)); brcmf_chip_dmp_erom_scan()
909 regdata = ci->ops->read32(ci->ctx, CORE_CC_REG(SI_ENUM_BASE, chipid)); brcmf_chip_recognition()
965 if (ci->ops->reset) { brcmf_chip_recognition()
966 ci->ops->reset(ci->ctx, &ci->pub); brcmf_chip_recognition()
993 val = chip->ops->read32(chip->ctx, cpu->wrapbase + BCMA_IOCTL); brcmf_chip_disable_arm()
1017 pub->cc_caps = chip->ops->read32(chip->ctx, brcmf_chip_setup()
1022 val = chip->ops->read32(chip->ctx, brcmf_chip_setup()
1032 if (chip->ops->setup) brcmf_chip_setup()
1033 ret = chip->ops->setup(chip->ctx, pub); brcmf_chip_setup()
1039 const struct brcmf_buscore_ops *ops) brcmf_chip_attach()
1044 if (WARN_ON(!ops->read32)) brcmf_chip_attach()
1046 if (WARN_ON(!ops->write32)) brcmf_chip_attach()
1048 if (WARN_ON(!ops->prepare)) brcmf_chip_attach()
1050 if (WARN_ON(!ops->activate)) brcmf_chip_attach()
1061 chip->ops = ops; brcmf_chip_attach()
1064 err = ops->prepare(ctx); brcmf_chip_attach()
1180 chip->ops->activate(chip->ctx, &chip->pub, 0); brcmf_chip_cm3_set_active()
1206 chip->ops->activate(chip->ctx, &chip->pub, rstvec); brcmf_chip_cr4_set_active()
1233 chip->ops->activate(chip->ctx, &chip->pub, rstvec); brcmf_chip_ca7_set_active()
1312 chip->ops->write32(chip->ctx, addr, 3); brcmf_chip_sr_capable()
1314 reg = chip->ops->read32(chip->ctx, addr); brcmf_chip_sr_capable()
1318 reg = chip->ops->read32(chip->ctx, addr); brcmf_chip_sr_capable()
1322 reg = chip->ops->read32(chip->ctx, addr); brcmf_chip_sr_capable()
1327 reg = chip->ops->read32(chip->ctx, addr); brcmf_chip_sr_capable()
1038 brcmf_chip_attach(void *ctx, const struct brcmf_buscore_ops *ops) brcmf_chip_attach() argument
H A Dbus.h140 struct brcmf_bus_ops *ops; member in struct:brcmf_bus
149 if (!bus->ops->preinit) brcmf_bus_preinit()
151 return bus->ops->preinit(bus->dev); brcmf_bus_preinit()
156 bus->ops->stop(bus->dev); brcmf_bus_stop()
161 return bus->ops->txdata(bus->dev, skb); brcmf_bus_txdata()
167 return bus->ops->txctl(bus->dev, msg, len); brcmf_bus_txctl()
173 return bus->ops->rxctl(bus->dev, msg, len); brcmf_bus_rxctl()
179 if (!bus->ops->gettxq) brcmf_bus_gettxq()
182 return bus->ops->gettxq(bus->dev); brcmf_bus_gettxq()
188 if (bus->ops->wowl_config) brcmf_bus_wowl_config()
189 bus->ops->wowl_config(bus->dev, enabled); brcmf_bus_wowl_config()
194 if (!bus->ops->get_ramsize) brcmf_bus_get_ramsize()
197 return bus->ops->get_ramsize(bus->dev); brcmf_bus_get_ramsize()
203 if (!bus->ops->get_memdump) brcmf_bus_get_memdump()
206 return bus->ops->get_memdump(bus->dev, data, len); brcmf_bus_get_memdump()
/linux-4.4.14/drivers/net/phy/
H A Dmdio-bitbang.c49 const struct mdiobb_ops *ops = ctrl->ops; mdiobb_send_bit() local
51 ops->set_mdio_data(ctrl, val); mdiobb_send_bit()
53 ops->set_mdc(ctrl, 1); mdiobb_send_bit()
55 ops->set_mdc(ctrl, 0); mdiobb_send_bit()
61 const struct mdiobb_ops *ops = ctrl->ops; mdiobb_get_bit() local
64 ops->set_mdc(ctrl, 1); mdiobb_get_bit()
66 ops->set_mdc(ctrl, 0); mdiobb_get_bit()
68 return ops->get_mdio_data(ctrl); mdiobb_get_bit()
99 const struct mdiobb_ops *ops = ctrl->ops; mdiobb_cmd() local
102 ops->set_mdio_dir(ctrl, 1); mdiobb_cmd()
149 ctrl->ops->set_mdio_dir(ctrl, 0); mdiobb_cmd_addr()
166 ctrl->ops->set_mdio_dir(ctrl, 0); mdiobb_read()
203 ctrl->ops->set_mdio_dir(ctrl, 0); mdiobb_write()
224 __module_get(ctrl->ops->owner); alloc_mdio_bitbang()
239 module_put(ctrl->ops->owner); free_mdio_bitbang()
/linux-4.4.14/drivers/phy/
H A Dulpi_phy.h8 *ulpi_phy_create(struct ulpi *ulpi, const struct phy_ops *ops) ulpi_phy_create() argument
13 phy = phy_create(&ulpi->dev, NULL, ops); ulpi_phy_create()
/linux-4.4.14/arch/arc/oprofile/
H A Dcommon.c14 int __init oprofile_arch_init(struct oprofile_operations *ops) oprofile_arch_init() argument
20 return oprofile_perf_init(ops); oprofile_arch_init()
/linux-4.4.14/arch/sh/include/asm/
H A Dsmp-ops.h31 extern void register_smp_ops(struct plat_smp_ops *ops);
40 static inline void register_smp_ops(struct plat_smp_ops *ops) register_smp_ops() argument
H A Dstacktrace.h20 const struct stacktrace_ops *ops, void *data);
/linux-4.4.14/drivers/media/i2c/s5c73m3/
H A Ds5c73m3-ctrls.c453 const struct v4l2_ctrl_ops *ops = &s5c73m3_ctrl_ops; s5c73m3_init_controls() local
462 ctrls->auto_wb = v4l2_ctrl_new_std_menu(hdl, ops, s5c73m3_init_controls()
467 ctrls->auto_exposure = v4l2_ctrl_new_std_menu(hdl, ops, s5c73m3_init_controls()
470 ctrls->exposure_bias = v4l2_ctrl_new_int_menu(hdl, ops, s5c73m3_init_controls()
476 ctrls->exposure_metering = v4l2_ctrl_new_std_menu(hdl, ops, s5c73m3_init_controls()
481 ctrls->focus_auto = v4l2_ctrl_new_std(hdl, ops, s5c73m3_init_controls()
484 ctrls->af_start = v4l2_ctrl_new_std(hdl, ops, s5c73m3_init_controls()
487 ctrls->af_stop = v4l2_ctrl_new_std(hdl, ops, s5c73m3_init_controls()
490 ctrls->af_status = v4l2_ctrl_new_std(hdl, ops, s5c73m3_init_controls()
497 ctrls->af_distance = v4l2_ctrl_new_std_menu(hdl, ops, s5c73m3_init_controls()
504 ctrls->auto_iso = v4l2_ctrl_new_std_menu(hdl, ops, s5c73m3_init_controls()
508 ctrls->iso = v4l2_ctrl_new_int_menu(hdl, ops, s5c73m3_init_controls()
512 ctrls->contrast = v4l2_ctrl_new_std(hdl, ops, s5c73m3_init_controls()
515 ctrls->saturation = v4l2_ctrl_new_std(hdl, ops, s5c73m3_init_controls()
518 ctrls->sharpness = v4l2_ctrl_new_std(hdl, ops, s5c73m3_init_controls()
521 ctrls->zoom = v4l2_ctrl_new_std(hdl, ops, s5c73m3_init_controls()
524 ctrls->colorfx = v4l2_ctrl_new_std_menu(hdl, ops, V4L2_CID_COLORFX, s5c73m3_init_controls()
527 ctrls->wdr = v4l2_ctrl_new_std(hdl, ops, s5c73m3_init_controls()
530 ctrls->stabilization = v4l2_ctrl_new_std(hdl, ops, s5c73m3_init_controls()
533 v4l2_ctrl_new_std_menu(hdl, ops, V4L2_CID_POWER_LINE_FREQUENCY, s5c73m3_init_controls()
537 ctrls->jpeg_quality = v4l2_ctrl_new_std(hdl, ops, s5c73m3_init_controls()
540 ctrls->scene_mode = v4l2_ctrl_new_std_menu(hdl, ops, s5c73m3_init_controls()
544 ctrls->aaa_lock = v4l2_ctrl_new_std(hdl, ops, s5c73m3_init_controls()
/linux-4.4.14/drivers/clk/
H A Dclk-axm5516.c152 .ops = &axxia_pllclk_ops,
164 .ops = &axxia_pllclk_ops,
176 .ops = &axxia_pllclk_ops,
188 .ops = &axxia_pllclk_ops,
200 .ops = &axxia_pllclk_ops,
216 .ops = &axxia_divclk_ops,
230 .ops = &axxia_divclk_ops,
244 .ops = &axxia_divclk_ops,
258 .ops = &axxia_divclk_ops,
272 .ops = &axxia_divclk_ops,
286 .ops = &axxia_divclk_ops,
300 .ops = &axxia_divclk_ops,
315 .ops = &axxia_divclk_ops,
330 .ops = &axxia_divclk_ops,
351 .ops = &axxia_clkmux_ops,
368 .ops = &axxia_clkmux_ops,
385 .ops = &axxia_clkmux_ops,
402 .ops = &axxia_clkmux_ops,
419 .ops = &axxia_clkmux_ops,
436 .ops = &axxia_clkmux_ops,
453 .ops = &axxia_clkmux_ops,
468 .ops = &axxia_clkmux_ops,
483 .ops = &axxia_clkmux_ops,
/linux-4.4.14/net/sched/
H A Dematch.c117 * @ops: ematch operations lookup table
120 * The given @ops must have kind set to a unique identifier and the
126 int tcf_em_register(struct tcf_ematch_ops *ops) tcf_em_register() argument
131 if (ops->match == NULL) tcf_em_register()
136 if (ops->kind == e->kind) tcf_em_register()
139 list_add_tail(&ops->link, &ematch_ops); tcf_em_register()
150 * @ops: ematch operations lookup table
153 * for examples when the module gets unloaded. The @ops parameter must be
158 void tcf_em_unregister(struct tcf_ematch_ops *ops) tcf_em_unregister() argument
161 list_del(&ops->link); tcf_em_unregister()
214 * module is held if the ops field is non zero. tcf_em_validate()
216 em->ops = tcf_em_lookup(em_hdr->kind); tcf_em_validate()
218 if (em->ops == NULL) { tcf_em_validate()
224 em->ops = tcf_em_lookup(em_hdr->kind); tcf_em_validate()
225 if (em->ops) { tcf_em_validate()
230 module_put(em->ops->owner); tcf_em_validate()
231 em->ops = NULL; tcf_em_validate()
241 if (em->ops->datalen && data_len < em->ops->datalen) tcf_em_validate()
244 if (em->ops->change) { tcf_em_validate()
245 err = em->ops->change(net, data, data_len, em); tcf_em_validate()
409 if (em->ops) { tcf_em_tree_destroy()
410 if (em->ops->destroy) tcf_em_tree_destroy()
411 em->ops->destroy(em); tcf_em_tree_destroy()
414 module_put(em->ops->owner); tcf_em_tree_destroy()
459 .kind = em->ops ? em->ops->kind : TCF_EM_CONTAINER, tcf_em_tree_dump()
467 if (em->ops && em->ops->dump) { tcf_em_tree_dump()
468 if (em->ops->dump(skb, em) < 0) tcf_em_tree_dump()
493 int r = em->ops->match(skb, em, info); tcf_em_match()
/linux-4.4.14/sound/soc/
H A Dsoc-topology.c78 struct snd_soc_tplg_ops *ops; member in struct:soc_tplg
232 switch (control_hdr->ops.info) { get_dobj_mixer_type()
276 hdr->ops.get, hdr->ops.put, hdr->ops.info, index, soc_bind_err()
285 name, hdr->ops.get, hdr->ops.put, hdr->ops.info, soc_control_err()
295 if (tplg->comp && tplg->ops && tplg->ops->vendor_load) soc_tplg_vendor_load_()
296 ret = tplg->ops->vendor_load(tplg->comp, hdr); soc_tplg_vendor_load_()
323 * external widgets where we can assign private data/ops */ soc_tplg_widget_load()
327 if (tplg->comp && tplg->ops && tplg->ops->widget_load) soc_tplg_widget_load()
328 return tplg->ops->widget_load(tplg->comp, w, tplg_w); soc_tplg_widget_load()
337 if (tplg->comp && tplg->ops && tplg->ops->pcm_dai_load) soc_tplg_pcm_dai_load()
338 return tplg->ops->pcm_dai_load(tplg->comp, pcm_dai, num_pcm_dai); soc_tplg_pcm_dai_load()
346 if (tplg->comp && tplg->ops && tplg->ops->complete) soc_tplg_complete()
347 tplg->ops->complete(tplg->comp); soc_tplg_complete()
396 if (dobj->ops && dobj->ops->control_unload) remove_mixer()
397 dobj->ops->control_unload(comp, dobj); remove_mixer()
418 if (dobj->ops && dobj->ops->control_unload) remove_enum()
419 dobj->ops->control_unload(comp, dobj); remove_enum()
441 if (dobj->ops && dobj->ops->control_unload) remove_bytes()
442 dobj->ops->control_unload(comp, dobj); remove_bytes()
461 if (dobj->ops && dobj->ops->widget_unload) remove_widget()
462 dobj->ops->widget_unload(comp, dobj); remove_widget()
505 if (dobj->ops && dobj->ops->pcm_dai_unload) remove_pcm_dai()
506 dobj->ops->pcm_dai_unload(comp, dobj); remove_pcm_dai()
517 const struct snd_soc_tplg_kcontrol_ops *ops; soc_tplg_kcontrol_bind_io() local
521 if (hdr->ops.info == SND_SOC_TPLG_CTL_BYTES soc_tplg_kcontrol_bind_io()
553 ops = tplg->io_ops; soc_tplg_kcontrol_bind_io()
557 if (k->put == NULL && ops[i].id == hdr->ops.put) soc_tplg_kcontrol_bind_io()
558 k->put = ops[i].put; soc_tplg_kcontrol_bind_io()
559 if (k->get == NULL && ops[i].id == hdr->ops.get) soc_tplg_kcontrol_bind_io()
560 k->get = ops[i].get; soc_tplg_kcontrol_bind_io()
561 if (k->info == NULL && ops[i].id == hdr->ops.info) soc_tplg_kcontrol_bind_io()
562 k->info = ops[i].info; soc_tplg_kcontrol_bind_io()
570 ops = io_ops; soc_tplg_kcontrol_bind_io()
574 if (k->put == NULL && ops[i].id == hdr->ops.put) soc_tplg_kcontrol_bind_io()
575 k->put = ops[i].put; soc_tplg_kcontrol_bind_io()
576 if (k->get == NULL && ops[i].id == hdr->ops.get) soc_tplg_kcontrol_bind_io()
577 k->get = ops[i].get; soc_tplg_kcontrol_bind_io()
578 if (k->info == NULL && ops[i].id == hdr->ops.info) soc_tplg_kcontrol_bind_io()
579 k->info = ops[i].info; soc_tplg_kcontrol_bind_io()
617 if (tplg->comp && tplg->ops && tplg->ops->control_load) soc_tplg_init_kcontrol()
618 return tplg->ops->control_load(tplg->comp, k, hdr); soc_tplg_init_kcontrol()
719 sbe->dobj.ops = tplg->ops; soc_tplg_dbytes_create()
812 sm->dobj.ops = tplg->ops; soc_tplg_dmixer_create()
953 se->dobj.ops = tplg->ops; soc_tplg_denum_create()
956 switch (ec->hdr.ops.info) { soc_tplg_denum_create()
983 ec->hdr.ops.info, ec->hdr.name); soc_tplg_denum_create()
1040 switch (control_hdr->ops.info) { soc_tplg_kcontrol_elems_load()
1245 switch (ec->hdr.ops.info) { soc_tplg_dapm_widget_denum_create()
1267 ec->hdr.ops.info, ec->hdr.name); soc_tplg_dapm_widget_denum_create()
1425 switch (control_hdr->ops.info) { soc_tplg_dapm_widget_create()
1467 control_hdr->ops.get, control_hdr->ops.put, soc_tplg_dapm_widget_create()
1468 control_hdr->ops.info); soc_tplg_dapm_widget_create()
1491 widget->dobj.ops = tplg->ops; soc_tplg_dapm_widget_create()
1585 dobj->ops = tplg->ops; soc_tplg_pcm_dai_elems_load()
1606 if (tplg->comp && tplg->ops && tplg->ops->manifest) soc_tplg_manifest_load()
1607 return tplg->ops->manifest(tplg->comp, manifest); soc_tplg_manifest_load()
1757 struct snd_soc_tplg_ops *ops, const struct firmware *fw, u32 id) snd_soc_tplg_component_load()
1766 tplg.ops = ops; snd_soc_tplg_component_load()
1768 tplg.io_ops = ops->io_ops; snd_soc_tplg_component_load()
1769 tplg.io_ops_count = ops->io_ops_count; snd_soc_tplg_component_load()
1770 tplg.bytes_ext_ops = ops->bytes_ext_ops; snd_soc_tplg_component_load()
1771 tplg.bytes_ext_ops_count = ops->bytes_ext_ops_count; snd_soc_tplg_component_load()
1756 snd_soc_tplg_component_load(struct snd_soc_component *comp, struct snd_soc_tplg_ops *ops, const struct firmware *fw, u32 id) snd_soc_tplg_component_load() argument
/linux-4.4.14/drivers/macintosh/
H A Dwindfarm.h39 const struct wf_control_ops *ops; member in struct:wf_control
64 s32 vmax = ct->ops->get_max(ct); wf_control_set_max()
65 return ct->ops->set_value(ct, vmax); wf_control_set_max()
70 s32 vmin = ct->ops->get_min(ct); wf_control_set_min()
71 return ct->ops->set_value(ct, vmin); wf_control_set_min()
76 return ct->ops->set_value(ct, val); wf_control_set()
81 return ct->ops->get_value(ct, val); wf_control_get()
86 return ct->ops->get_min(ct); wf_control_get_min()
91 return ct->ops->get_max(ct); wf_control_get_max()
108 const struct wf_sensor_ops *ops; member in struct:wf_sensor
123 return sr->ops->get_value(sr, val); wf_sensor_get()
/linux-4.4.14/drivers/ptp/
H A Dptp_chardev.c28 static int ptp_disable_pinfunc(struct ptp_clock_info *ops, ptp_disable_pinfunc() argument
42 err = ops->enable(ops, &rq, 0); ptp_disable_pinfunc()
47 err = ops->enable(ops, &rq, 0); ptp_disable_pinfunc()
125 struct ptp_clock_info *ops = ptp->info; ptp_ioctl() local
151 if (req.extts.index >= ops->n_ext_ts) { ptp_ioctl()
157 err = ops->enable(ops, &req, enable); ptp_ioctl()
166 if (req.perout.index >= ops->n_per_out) { ptp_ioctl()
172 err = ops->enable(ops, &req, enable); ptp_ioctl()
180 err = ops->enable(ops, &req, enable); ptp_ioctl()
222 if (pin_index >= ops->n_pins) { ptp_ioctl()
228 pd = ops->pin_config[pin_index]; ptp_ioctl()
240 if (pin_index >= ops->n_pins) { ptp_ioctl()
/linux-4.4.14/fs/xfs/
H A Dxfs_ioctl32.c399 compat_xfs_attr_multiop_t *ops; xfs_compat_attrmulti_by_handle() local
424 ops = memdup_user(compat_ptr(am_hreq.ops), size); xfs_compat_attrmulti_by_handle()
425 if (IS_ERR(ops)) { xfs_compat_attrmulti_by_handle()
426 error = PTR_ERR(ops); xfs_compat_attrmulti_by_handle()
437 ops[i].am_error = strncpy_from_user((char *)attr_name, xfs_compat_attrmulti_by_handle()
438 compat_ptr(ops[i].am_attrname), xfs_compat_attrmulti_by_handle()
440 if (ops[i].am_error == 0 || ops[i].am_error == MAXNAMELEN) xfs_compat_attrmulti_by_handle()
442 if (ops[i].am_error < 0) xfs_compat_attrmulti_by_handle()
445 switch (ops[i].am_opcode) { xfs_compat_attrmulti_by_handle()
447 ops[i].am_error = xfs_attrmulti_attr_get( xfs_compat_attrmulti_by_handle()
449 compat_ptr(ops[i].am_attrvalue), xfs_compat_attrmulti_by_handle()
450 &ops[i].am_length, ops[i].am_flags); xfs_compat_attrmulti_by_handle()
453 ops[i].am_error = mnt_want_write_file(parfilp); xfs_compat_attrmulti_by_handle()
454 if (ops[i].am_error) xfs_compat_attrmulti_by_handle()
456 ops[i].am_error = xfs_attrmulti_attr_set( xfs_compat_attrmulti_by_handle()
458 compat_ptr(ops[i].am_attrvalue), xfs_compat_attrmulti_by_handle()
459 ops[i].am_length, ops[i].am_flags); xfs_compat_attrmulti_by_handle()
463 ops[i].am_error = mnt_want_write_file(parfilp); xfs_compat_attrmulti_by_handle()
464 if (ops[i].am_error) xfs_compat_attrmulti_by_handle()
466 ops[i].am_error = xfs_attrmulti_attr_remove( xfs_compat_attrmulti_by_handle()
468 ops[i].am_flags); xfs_compat_attrmulti_by_handle()
472 ops[i].am_error = -EINVAL; xfs_compat_attrmulti_by_handle()
476 if (copy_to_user(compat_ptr(am_hreq.ops), ops, size)) xfs_compat_attrmulti_by_handle()
481 kfree(ops); xfs_compat_attrmulti_by_handle()
/linux-4.4.14/drivers/mtd/
H A Dmtdchar.c187 struct mtd_oob_ops ops; mtdchar_read() local
189 ops.mode = MTD_OPS_RAW; mtdchar_read()
190 ops.datbuf = kbuf; mtdchar_read()
191 ops.oobbuf = NULL; mtdchar_read()
192 ops.len = len; mtdchar_read()
194 ret = mtd_read_oob(mtd, *ppos, &ops); mtdchar_read()
195 retlen = ops.retlen; mtdchar_read()
281 struct mtd_oob_ops ops; mtdchar_write() local
283 ops.mode = MTD_OPS_RAW; mtdchar_write()
284 ops.datbuf = kbuf; mtdchar_write()
285 ops.oobbuf = NULL; mtdchar_write()
286 ops.ooboffs = 0; mtdchar_write()
287 ops.len = len; mtdchar_write()
289 ret = mtd_write_oob(mtd, *ppos, &ops); mtdchar_write()
290 retlen = ops.retlen; mtdchar_write()
367 struct mtd_oob_ops ops; mtdchar_writeoob() local
385 ops.ooblen = length; mtdchar_writeoob()
386 ops.ooboffs = start & (mtd->writesize - 1); mtdchar_writeoob()
387 ops.datbuf = NULL; mtdchar_writeoob()
388 ops.mode = (mfi->mode == MTD_FILE_MODE_RAW) ? MTD_OPS_RAW : mtdchar_writeoob()
391 if (ops.ooboffs && ops.ooblen > (mtd->oobsize - ops.ooboffs)) mtdchar_writeoob()
394 ops.oobbuf = memdup_user(ptr, length); mtdchar_writeoob()
395 if (IS_ERR(ops.oobbuf)) mtdchar_writeoob()
396 return PTR_ERR(ops.oobbuf); mtdchar_writeoob()
399 ret = mtd_write_oob(mtd, start, &ops); mtdchar_writeoob()
401 if (ops.oobretlen > 0xFFFFFFFFU) mtdchar_writeoob()
403 retlen = ops.oobretlen; mtdchar_writeoob()
407 kfree(ops.oobbuf); mtdchar_writeoob()
416 struct mtd_oob_ops ops; mtdchar_readoob() local
425 ops.ooblen = length; mtdchar_readoob()
426 ops.ooboffs = start & (mtd->writesize - 1); mtdchar_readoob()
427 ops.datbuf = NULL; mtdchar_readoob()
428 ops.mode = (mfi->mode == MTD_FILE_MODE_RAW) ? MTD_OPS_RAW : mtdchar_readoob()
431 if (ops.ooboffs && ops.ooblen > (mtd->oobsize - ops.ooboffs)) mtdchar_readoob()
434 ops.oobbuf = kmalloc(length, GFP_KERNEL); mtdchar_readoob()
435 if (!ops.oobbuf) mtdchar_readoob()
439 ret = mtd_read_oob(mtd, start, &ops); mtdchar_readoob()
441 if (put_user(ops.oobretlen, retp)) mtdchar_readoob()
443 else if (ops.oobretlen && copy_to_user(ptr, ops.oobbuf, mtdchar_readoob()
444 ops.oobretlen)) mtdchar_readoob()
447 kfree(ops.oobbuf); mtdchar_readoob()
539 struct mtd_oob_ops ops; mtdchar_write_ioctl() local
555 ops.mode = req.mode; mtdchar_write_ioctl()
556 ops.len = (size_t)req.len; mtdchar_write_ioctl()
557 ops.ooblen = (size_t)req.ooblen; mtdchar_write_ioctl()
558 ops.ooboffs = 0; mtdchar_write_ioctl()
561 ops.datbuf = memdup_user(usr_data, ops.len); mtdchar_write_ioctl()
562 if (IS_ERR(ops.datbuf)) mtdchar_write_ioctl()
563 return PTR_ERR(ops.datbuf); mtdchar_write_ioctl()
565 ops.datbuf = NULL; mtdchar_write_ioctl()
569 ops.oobbuf = memdup_user(usr_oob, ops.ooblen); mtdchar_write_ioctl()
570 if (IS_ERR(ops.oobbuf)) { mtdchar_write_ioctl()
571 kfree(ops.datbuf); mtdchar_write_ioctl()
572 return PTR_ERR(ops.oobbuf); mtdchar_write_ioctl()
575 ops.oobbuf = NULL; mtdchar_write_ioctl()
578 ret = mtd_write_oob(mtd, (loff_t)req.start, &ops); mtdchar_write_ioctl()
580 kfree(ops.datbuf); mtdchar_write_ioctl()
581 kfree(ops.oobbuf); mtdchar_write_ioctl()
/linux-4.4.14/drivers/net/ethernet/intel/igb/
H A De1000_phy.c80 ret_val = phy->ops.read_reg(hw, PHY_ID1, &phy_id); igb_get_phy_id()
86 ret_val = phy->ops.read_reg(hw, PHY_ID2, &phy_id); igb_get_phy_id()
107 if (!(hw->phy.ops.write_reg)) igb_phy_reset_dsp()
110 ret_val = hw->phy.ops.write_reg(hw, M88E1000_PHY_GEN_CONTROL, 0xC1); igb_phy_reset_dsp()
114 ret_val = hw->phy.ops.write_reg(hw, M88E1000_PHY_GEN_CONTROL, 0); igb_phy_reset_dsp()
400 if (!(hw->phy.ops.acquire)) igb_read_phy_reg_igp()
403 ret_val = hw->phy.ops.acquire(hw); igb_read_phy_reg_igp()
412 hw->phy.ops.release(hw); igb_read_phy_reg_igp()
420 hw->phy.ops.release(hw); igb_read_phy_reg_igp()
439 if (!(hw->phy.ops.acquire)) igb_write_phy_reg_igp()
442 ret_val = hw->phy.ops.acquire(hw); igb_write_phy_reg_igp()
451 hw->phy.ops.release(hw); igb_write_phy_reg_igp()
459 hw->phy.ops.release(hw); igb_write_phy_reg_igp()
483 ret_val = hw->phy.ops.reset(hw); igb_copper_link_setup_82580()
491 ret_val = phy->ops.read_reg(hw, I82580_CFG_REG, &phy_data); igb_copper_link_setup_82580()
500 ret_val = phy->ops.write_reg(hw, I82580_CFG_REG, phy_data); igb_copper_link_setup_82580()
505 ret_val = phy->ops.read_reg(hw, I82580_PHY_CTRL_2, &phy_data); igb_copper_link_setup_82580()
525 ret_val = hw->phy.ops.write_reg(hw, I82580_PHY_CTRL_2, phy_data); igb_copper_link_setup_82580()
550 ret_val = phy->ops.read_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data); igb_copper_link_setup_m88()
591 ret_val = phy->ops.write_reg(hw, M88E1000_PHY_SPEC_CTRL, phy_data); igb_copper_link_setup_m88()
599 ret_val = phy->ops.read_reg(hw, M88E1000_EXT_PHY_SPEC_CTRL, igb_copper_link_setup_m88()
618 ret_val = phy->ops.write_reg(hw, M88E1000_EXT_PHY_SPEC_CTRL, igb_copper_link_setup_m88()
652 ret_val = phy->ops.read_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data); igb_copper_link_setup_m88_gen2()
698 phy->ops.write_reg(hw, M88E1000_PHY_SPEC_CTRL, phy_data); igb_copper_link_setup_m88_gen2()
713 ret_val = phy->ops.write_reg(hw, M88E1000_PHY_SPEC_CTRL, phy_data); igb_copper_link_setup_m88_gen2()
748 ret_val = phy->ops.reset(hw); igb_copper_link_setup_igp()
764 if (phy->ops.set_d3_lplu_state) igb_copper_link_setup_igp()
765 ret_val = phy->ops.set_d3_lplu_state(hw, false); igb_copper_link_setup_igp()
773 ret_val = phy->ops.set_d0_lplu_state(hw, false); igb_copper_link_setup_igp()
779 ret_val = phy->ops.read_reg(hw, IGP01E1000_PHY_PORT_CTRL, &data); igb_copper_link_setup_igp()
797 ret_val = phy->ops.write_reg(hw, IGP01E1000_PHY_PORT_CTRL, data); igb_copper_link_setup_igp()
809 ret_val = phy->ops.read_reg(hw, igb_copper_link_setup_igp()
816 ret_val = phy->ops.write_reg(hw, igb_copper_link_setup_igp()
823 ret_val = phy->ops.read_reg(hw, PHY_1000T_CTRL, &data); igb_copper_link_setup_igp()
828 ret_val = phy->ops.write_reg(hw, PHY_1000T_CTRL, data); igb_copper_link_setup_igp()
833 ret_val = phy->ops.read_reg(hw, PHY_1000T_CTRL, &data); igb_copper_link_setup_igp()
857 ret_val = phy->ops.write_reg(hw, PHY_1000T_CTRL, data); igb_copper_link_setup_igp()
903 ret_val = phy->ops.read_reg(hw, PHY_CONTROL, &phy_ctrl); igb_copper_link_autoneg()
908 ret_val = phy->ops.write_reg(hw, PHY_CONTROL, phy_ctrl); igb_copper_link_autoneg()
948 ret_val = phy->ops.read_reg(hw, PHY_AUTONEG_ADV, &mii_autoneg_adv_reg); igb_phy_setup_autoneg()
954 ret_val = phy->ops.read_reg(hw, PHY_1000T_CTRL, igb_phy_setup_autoneg()
1068 ret_val = phy->ops.write_reg(hw, PHY_AUTONEG_ADV, mii_autoneg_adv_reg); igb_phy_setup_autoneg()
1075 ret_val = phy->ops.write_reg(hw, igb_phy_setup_autoneg()
1112 ret_val = hw->phy.ops.force_speed_duplex(hw); igb_setup_copper_link()
1153 ret_val = phy->ops.read_reg(hw, PHY_CONTROL, &phy_data); igb_phy_force_speed_duplex_igp()
1159 ret_val = phy->ops.write_reg(hw, PHY_CONTROL, phy_data); igb_phy_force_speed_duplex_igp()
1166 ret_val = phy->ops.read_reg(hw, IGP01E1000_PHY_PORT_CTRL, &phy_data); igb_phy_force_speed_duplex_igp()
1173 ret_val = phy->ops.write_reg(hw, IGP01E1000_PHY_PORT_CTRL, phy_data); igb_phy_force_speed_duplex_igp()
1223 ret_val = phy->ops.read_reg(hw, M88E1000_PHY_SPEC_CTRL, igb_phy_force_speed_duplex_m88()
1229 ret_val = phy->ops.write_reg(hw, M88E1000_PHY_SPEC_CTRL, igb_phy_force_speed_duplex_m88()
1237 ret_val = phy->ops.read_reg(hw, PHY_CONTROL, &phy_data); igb_phy_force_speed_duplex_m88()
1243 ret_val = phy->ops.write_reg(hw, PHY_CONTROL, phy_data); igb_phy_force_speed_duplex_m88()
1281 ret_val = phy->ops.write_reg(hw, igb_phy_force_speed_duplex_m88()
1307 ret_val = phy->ops.read_reg(hw, M88E1000_EXT_PHY_SPEC_CTRL, &phy_data); igb_phy_force_speed_duplex_m88()
1316 ret_val = phy->ops.write_reg(hw, M88E1000_EXT_PHY_SPEC_CTRL, phy_data); igb_phy_force_speed_duplex_m88()
1323 ret_val = phy->ops.read_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data); igb_phy_force_speed_duplex_m88()
1328 ret_val = phy->ops.write_reg(hw, M88E1000_PHY_SPEC_CTRL, phy_data); igb_phy_force_speed_duplex_m88()
1415 if (!(hw->phy.ops.read_reg)) igb_set_d3_lplu_state()
1418 ret_val = phy->ops.read_reg(hw, IGP02E1000_PHY_POWER_MGMT, &data); igb_set_d3_lplu_state()
1424 ret_val = phy->ops.write_reg(hw, IGP02E1000_PHY_POWER_MGMT, igb_set_d3_lplu_state()
1434 ret_val = phy->ops.read_reg(hw, igb_set_d3_lplu_state()
1441 ret_val = phy->ops.write_reg(hw, igb_set_d3_lplu_state()
1447 ret_val = phy->ops.read_reg(hw, igb_set_d3_lplu_state()
1454 ret_val = phy->ops.write_reg(hw, igb_set_d3_lplu_state()
1464 ret_val = phy->ops.write_reg(hw, IGP02E1000_PHY_POWER_MGMT, igb_set_d3_lplu_state()
1470 ret_val = phy->ops.read_reg(hw, IGP01E1000_PHY_PORT_CONFIG, igb_set_d3_lplu_state()
1476 ret_val = phy->ops.write_reg(hw, IGP01E1000_PHY_PORT_CONFIG, igb_set_d3_lplu_state()
1518 ret_val = phy->ops.read_reg(hw, offset, &phy_data); igb_check_downshift()
1541 ret_val = phy->ops.read_reg(hw, M88E1000_PHY_SPEC_STATUS, &data); igb_check_polarity_m88()
1569 ret_val = phy->ops.read_reg(hw, IGP01E1000_PHY_PORT_STATUS, &data); igb_check_polarity_igp()
1585 ret_val = phy->ops.read_reg(hw, offset, &data); igb_check_polarity_igp()
1610 ret_val = hw->phy.ops.read_reg(hw, PHY_STATUS, &phy_status); igb_wait_autoneg()
1613 ret_val = hw->phy.ops.read_reg(hw, PHY_STATUS, &phy_status); igb_wait_autoneg()
1647 ret_val = hw->phy.ops.read_reg(hw, PHY_STATUS, &phy_status); igb_phy_has_link()
1658 ret_val = hw->phy.ops.read_reg(hw, PHY_STATUS, &phy_status); igb_phy_has_link()
1695 ret_val = phy->ops.read_reg(hw, M88E1000_PHY_SPEC_STATUS, &phy_data); igb_get_cable_length_m88()
1724 ret_val = phy->ops.read_reg(hw, (0x7 << GS40G_PAGE_SHIFT) + igb_get_cable_length_m88_gen2()
1731 ret_val = phy->ops.read_reg(hw, (0x7 << GS40G_PAGE_SHIFT) + igb_get_cable_length_m88_gen2()
1747 ret_val = phy->ops.read_reg(hw, I347AT4_PAGE_SELECT, igb_get_cable_length_m88_gen2()
1752 ret_val = phy->ops.write_reg(hw, I347AT4_PAGE_SELECT, 0x07); igb_get_cable_length_m88_gen2()
1757 ret_val = phy->ops.read_reg(hw, (I347AT4_PCDL + phy->addr), igb_get_cable_length_m88_gen2()
1763 ret_val = phy->ops.read_reg(hw, I347AT4_PCDC, &phy_data2); igb_get_cable_length_m88_gen2()
1775 ret_val = phy->ops.write_reg(hw, I347AT4_PAGE_SELECT, igb_get_cable_length_m88_gen2()
1782 ret_val = phy->ops.read_reg(hw, I347AT4_PAGE_SELECT, igb_get_cable_length_m88_gen2()
1787 ret_val = phy->ops.write_reg(hw, I347AT4_PAGE_SELECT, 0x05); igb_get_cable_length_m88_gen2()
1791 ret_val = phy->ops.read_reg(hw, M88E1112_VCT_DSP_DISTANCE, igb_get_cable_length_m88_gen2()
1810 ret_val = phy->ops.write_reg(hw, I347AT4_PAGE_SELECT, igb_get_cable_length_m88_gen2()
1852 ret_val = phy->ops.read_reg(hw, agc_reg_array[i], &phy_data); igb_get_cable_length_igp_2()
1930 ret_val = phy->ops.read_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data); igb_get_phy_info_m88()
1941 ret_val = phy->ops.read_reg(hw, M88E1000_PHY_SPEC_STATUS, &phy_data); igb_get_phy_info_m88()
1948 ret_val = phy->ops.get_cable_length(hw); igb_get_phy_info_m88()
1952 ret_val = phy->ops.read_reg(hw, PHY_1000T_STATUS, &phy_data); igb_get_phy_info_m88()
2006 ret_val = phy->ops.read_reg(hw, IGP01E1000_PHY_PORT_STATUS, &data); igb_get_phy_info_igp()
2014 ret_val = phy->ops.get_cable_length(hw); igb_get_phy_info_igp()
2018 ret_val = phy->ops.read_reg(hw, PHY_1000T_STATUS, &data); igb_get_phy_info_igp()
2051 if (!(hw->phy.ops.read_reg)) igb_phy_sw_reset()
2054 ret_val = hw->phy.ops.read_reg(hw, PHY_CONTROL, &phy_ctrl); igb_phy_sw_reset()
2059 ret_val = hw->phy.ops.write_reg(hw, PHY_CONTROL, phy_ctrl); igb_phy_sw_reset()
2090 ret_val = phy->ops.acquire(hw); igb_phy_hw_reset()
2105 phy->ops.release(hw); igb_phy_hw_reset()
2107 ret_val = phy->ops.get_cfg_done(hw); igb_phy_hw_reset()
2125 hw->phy.ops.write_reg(hw, 0x2F5B, 0x9018); igb_phy_init_script_igp3()
2127 hw->phy.ops.write_reg(hw, 0x2F52, 0x0000); igb_phy_init_script_igp3()
2129 hw->phy.ops.write_reg(hw, 0x2FB1, 0x8B24); igb_phy_init_script_igp3()
2131 hw->phy.ops.write_reg(hw, 0x2FB2, 0xF8F0); igb_phy_init_script_igp3()
2133 hw->phy.ops.write_reg(hw, 0x2010, 0x10B0); igb_phy_init_script_igp3()
2135 hw->phy.ops.write_reg(hw, 0x2011, 0x0000); igb_phy_init_script_igp3()
2137 hw->phy.ops.write_reg(hw, 0x20DD, 0x249A); igb_phy_init_script_igp3()
2139 hw->phy.ops.write_reg(hw, 0x20DE, 0x00D3); igb_phy_init_script_igp3()
2141 hw->phy.ops.write_reg(hw, 0x28B4, 0x04CE); igb_phy_init_script_igp3()
2143 hw->phy.ops.write_reg(hw, 0x2F70, 0x29E4); igb_phy_init_script_igp3()
2145 hw->phy.ops.write_reg(hw, 0x0000, 0x0140); igb_phy_init_script_igp3()
2147 hw->phy.ops.write_reg(hw, 0x1F30, 0x1606); igb_phy_init_script_igp3()
2149 hw->phy.ops.write_reg(hw, 0x1F31, 0xB814); igb_phy_init_script_igp3()
2151 hw->phy.ops.write_reg(hw, 0x1F35, 0x002A); igb_phy_init_script_igp3()
2153 hw->phy.ops.write_reg(hw, 0x1F3E, 0x0067); igb_phy_init_script_igp3()
2155 hw->phy.ops.write_reg(hw, 0x1F54, 0x0065); igb_phy_init_script_igp3()
2157 hw->phy.ops.write_reg(hw, 0x1F55, 0x002A); igb_phy_init_script_igp3()
2159 hw->phy.ops.write_reg(hw, 0x1F56, 0x002A); igb_phy_init_script_igp3()
2161 hw->phy.ops.write_reg(hw, 0x1F72, 0x3FB0); igb_phy_init_script_igp3()
2163 hw->phy.ops.write_reg(hw, 0x1F76, 0xC0FF); igb_phy_init_script_igp3()
2165 hw->phy.ops.write_reg(hw, 0x1F77, 0x1DEC); igb_phy_init_script_igp3()
2167 hw->phy.ops.write_reg(hw, 0x1F78, 0xF9EF); igb_phy_init_script_igp3()
2169 hw->phy.ops.write_reg(hw, 0x1F79, 0x0210); igb_phy_init_script_igp3()
2171 hw->phy.ops.write_reg(hw, 0x1895, 0x0003); igb_phy_init_script_igp3()
2173 hw->phy.ops.write_reg(hw, 0x1796, 0x0008); igb_phy_init_script_igp3()
2175 hw->phy.ops.write_reg(hw, 0x1798, 0xD008); igb_phy_init_script_igp3()
2179 hw->phy.ops.write_reg(hw, 0x1898, 0xD918); igb_phy_init_script_igp3()
2181 hw->phy.ops.write_reg(hw, 0x187A, 0x0800); igb_phy_init_script_igp3()
2185 hw->phy.ops.write_reg(hw, 0x0019, 0x008D); igb_phy_init_script_igp3()
2187 hw->phy.ops.write_reg(hw, 0x001B, 0x2080); igb_phy_init_script_igp3()
2189 hw->phy.ops.write_reg(hw, 0x0014, 0x0045); igb_phy_init_script_igp3()
2191 hw->phy.ops.write_reg(hw, 0x0000, 0x1340); igb_phy_init_script_igp3()
2208 ret_val = phy->ops.write_reg(hw, E1000_M88E1543_PAGE_ADDR, 0x00FF); igb_initialize_M88E1512_phy()
2212 ret_val = phy->ops.write_reg(hw, E1000_M88E1512_CFG_REG_2, 0x214B); igb_initialize_M88E1512_phy()
2216 ret_val = phy->ops.write_reg(hw, E1000_M88E1512_CFG_REG_1, 0x2144); igb_initialize_M88E1512_phy()
2220 ret_val = phy->ops.write_reg(hw, E1000_M88E1512_CFG_REG_2, 0x0C28); igb_initialize_M88E1512_phy()
2224 ret_val = phy->ops.write_reg(hw, E1000_M88E1512_CFG_REG_1, 0x2146); igb_initialize_M88E1512_phy()
2228 ret_val = phy->ops.write_reg(hw, E1000_M88E1512_CFG_REG_2, 0xB233); igb_initialize_M88E1512_phy()
2232 ret_val = phy->ops.write_reg(hw, E1000_M88E1512_CFG_REG_1, 0x214D); igb_initialize_M88E1512_phy()
2236 ret_val = phy->ops.write_reg(hw, E1000_M88E1512_CFG_REG_2, 0xCC0C); igb_initialize_M88E1512_phy()
2240 ret_val = phy->ops.write_reg(hw, E1000_M88E1512_CFG_REG_1, 0x2159); igb_initialize_M88E1512_phy()
2245 ret_val = phy->ops.write_reg(hw, E1000_M88E1543_PAGE_ADDR, 0x00FB); igb_initialize_M88E1512_phy()
2249 ret_val = phy->ops.write_reg(hw, E1000_M88E1512_CFG_REG_3, 0x000D); igb_initialize_M88E1512_phy()
2254 ret_val = phy->ops.write_reg(hw, E1000_M88E1543_PAGE_ADDR, 0x12); igb_initialize_M88E1512_phy()
2259 ret_val = phy->ops.write_reg(hw, E1000_M88E1512_MODE, 0x8001); igb_initialize_M88E1512_phy()
2264 ret_val = phy->ops.write_reg(hw, E1000_M88E1543_PAGE_ADDR, 0); igb_initialize_M88E1512_phy()
2292 hw->phy.ops.read_reg(hw, PHY_CONTROL, &mii_reg); igb_power_up_phy_copper()
2294 hw->phy.ops.write_reg(hw, PHY_CONTROL, mii_reg); igb_power_up_phy_copper()
2309 hw->phy.ops.read_reg(hw, PHY_CONTROL, &mii_reg); igb_power_down_phy_copper()
2311 hw->phy.ops.write_reg(hw, PHY_CONTROL, mii_reg); igb_power_down_phy_copper()
2330 ret_val = phy->ops.read_reg(hw, I82580_PHY_STATUS_2, &data); igb_check_polarity_82580()
2355 ret_val = phy->ops.read_reg(hw, PHY_CONTROL, &phy_data); igb_phy_force_speed_duplex_82580()
2361 ret_val = phy->ops.write_reg(hw, PHY_CONTROL, phy_data); igb_phy_force_speed_duplex_82580()
2368 ret_val = phy->ops.read_reg(hw, I82580_PHY_CTRL_2, &phy_data); igb_phy_force_speed_duplex_82580()
2374 ret_val = phy->ops.write_reg(hw, I82580_PHY_CTRL_2, phy_data); igb_phy_force_speed_duplex_82580()
2434 ret_val = phy->ops.read_reg(hw, I82580_PHY_STATUS_2, &data); igb_get_phy_info_82580()
2442 ret_val = hw->phy.ops.get_cable_length(hw); igb_get_phy_info_82580()
2446 ret_val = phy->ops.read_reg(hw, PHY_1000T_STATUS, &data); igb_get_phy_info_82580()
2480 ret_val = phy->ops.read_reg(hw, I82580_PHY_DIAG_STATUS, &phy_data); igb_get_cable_length_82580()
2512 ret_val = hw->phy.ops.acquire(hw); igb_write_phy_reg_gs40g()
2522 hw->phy.ops.release(hw); igb_write_phy_reg_gs40g()
2542 ret_val = hw->phy.ops.acquire(hw); igb_read_phy_reg_gs40g()
2552 hw->phy.ops.release(hw); igb_read_phy_reg_gs40g()
2568 ret_val = hw->phy.ops.read_reg(hw, PHY_1000T_CTRL, &phy_data); igb_set_master_slave_mode()
2593 return hw->phy.ops.write_reg(hw, PHY_1000T_CTRL, phy_data); igb_set_master_slave_mode()
H A De1000_mbx.c44 if (mbx->ops.read) igb_read_mbx()
45 ret_val = mbx->ops.read(hw, msg, size, mbx_id); igb_read_mbx()
67 else if (mbx->ops.write) igb_write_mbx()
68 ret_val = mbx->ops.write(hw, msg, size, mbx_id); igb_write_mbx()
85 if (mbx->ops.check_for_msg) igb_check_for_msg()
86 ret_val = mbx->ops.check_for_msg(hw, mbx_id); igb_check_for_msg()
103 if (mbx->ops.check_for_ack) igb_check_for_ack()
104 ret_val = mbx->ops.check_for_ack(hw, mbx_id); igb_check_for_ack()
121 if (mbx->ops.check_for_rst) igb_check_for_rst()
122 ret_val = mbx->ops.check_for_rst(hw, mbx_id); igb_check_for_rst()
139 if (!countdown || !mbx->ops.check_for_msg) igb_poll_for_msg()
142 while (countdown && mbx->ops.check_for_msg(hw, mbx_id)) { igb_poll_for_msg()
168 if (!countdown || !mbx->ops.check_for_ack) igb_poll_for_ack()
171 while (countdown && mbx->ops.check_for_ack(hw, mbx_id)) { igb_poll_for_ack()
201 if (!mbx->ops.read) igb_read_posted_mbx()
207 ret_val = mbx->ops.read(hw, msg, size, mbx_id); igb_read_posted_mbx()
229 if (!mbx->ops.write || !mbx->timeout) igb_write_posted_mbx()
233 ret_val = mbx->ops.write(hw, msg, size, mbx_id); igb_write_posted_mbx()
427 mbx->ops.read = igb_read_mbx_pf; igb_init_mbx_params_pf()
428 mbx->ops.write = igb_write_mbx_pf; igb_init_mbx_params_pf()
429 mbx->ops.read_posted = igb_read_posted_mbx; igb_init_mbx_params_pf()
430 mbx->ops.write_posted = igb_write_posted_mbx; igb_init_mbx_params_pf()
431 mbx->ops.check_for_msg = igb_check_for_msg_pf; igb_init_mbx_params_pf()
432 mbx->ops.check_for_ack = igb_check_for_ack_pf; igb_init_mbx_params_pf()
433 mbx->ops.check_for_rst = igb_check_for_rst_pf; igb_init_mbx_params_pf()
/linux-4.4.14/drivers/net/wireless/iwlwifi/
H A Diwl-op-mode.h100 * 2) The driver layer starts the op_mode (ops->start)
109 * The op_mode exports its ops so that external components can start it and
170 int iwl_opmode_register(const char *name, const struct iwl_op_mode_ops *ops);
175 * @ops: pointer to its own ops
180 const struct iwl_op_mode_ops *ops; member in struct:iwl_op_mode
188 op_mode->ops->stop(op_mode); iwl_op_mode_stop()
195 return op_mode->ops->rx(op_mode, napi, rxb); iwl_op_mode_rx()
203 op_mode->ops->rx_rss(op_mode, napi, rxb, queue); iwl_op_mode_rx_rss()
209 op_mode->ops->queue_full(op_mode, queue); iwl_op_mode_queue_full()
215 op_mode->ops->queue_not_full(op_mode, queue); iwl_op_mode_queue_not_full()
222 return op_mode->ops->hw_rf_kill(op_mode, state); iwl_op_mode_hw_rf_kill()
228 op_mode->ops->free_skb(op_mode, skb); iwl_op_mode_free_skb()
233 op_mode->ops->nic_error(op_mode); iwl_op_mode_nic_error()
238 op_mode->ops->cmd_queue_full(op_mode); iwl_op_mode_cmd_queue_full()
244 op_mode->ops->nic_config(op_mode); iwl_op_mode_nic_config()
250 op_mode->ops->wimax_active(op_mode); iwl_op_mode_wimax_active()
257 if (!op_mode->ops->enter_d0i3) iwl_op_mode_enter_d0i3()
259 return op_mode->ops->enter_d0i3(op_mode); iwl_op_mode_enter_d0i3()
266 if (!op_mode->ops->exit_d0i3) iwl_op_mode_exit_d0i3()
268 return op_mode->ops->exit_d0i3(op_mode); iwl_op_mode_exit_d0i3()
/linux-4.4.14/drivers/usb/dwc3/
H A Dulpi.c38 static int dwc3_ulpi_read(struct ulpi_ops *ops, u8 addr) dwc3_ulpi_read() argument
40 struct dwc3 *dwc = dev_get_drvdata(ops->dev); dwc3_ulpi_read()
56 static int dwc3_ulpi_write(struct ulpi_ops *ops, u8 addr, u8 val) dwc3_ulpi_write() argument
58 struct dwc3 *dwc = dev_get_drvdata(ops->dev); dwc3_ulpi_write()
/linux-4.4.14/drivers/hwmon/
H A Dabx500.h16 * struct abx500_temp_ops - abx500 chip specific ops
37 * @ops: abx500 chip specific ops
53 struct abx500_temp_ops ops; member in struct:abx500_temp
/linux-4.4.14/drivers/pcmcia/
H A Dpxa2xx_base.c219 struct pcmcia_low_level *ops = dev->platform_data; pxa2xx_configure_sockets() local
227 if ((ops->first + ops->nr) > 1 || pxa2xx_configure_sockets()
269 void pxa2xx_drv_pcmcia_ops(struct pcmcia_low_level *ops) pxa2xx_drv_pcmcia_ops() argument
272 ops->set_timing = pxa2xx_pcmcia_set_timing; pxa2xx_drv_pcmcia_ops()
274 ops->frequency_change = pxa2xx_pcmcia_frequency_change; pxa2xx_drv_pcmcia_ops()
282 struct pcmcia_low_level *ops; pxa2xx_drv_pcmcia_probe() local
287 ops = (struct pcmcia_low_level *)dev->dev.platform_data; pxa2xx_drv_pcmcia_probe()
288 if (!ops) { pxa2xx_drv_pcmcia_probe()
293 if (cpu_is_pxa320() && ops->nr > 1) { pxa2xx_drv_pcmcia_probe()
303 pxa2xx_drv_pcmcia_ops(ops); pxa2xx_drv_pcmcia_probe()
305 sinfo = devm_kzalloc(&dev->dev, SKT_DEV_INFO_SIZE(ops->nr), pxa2xx_drv_pcmcia_probe()
310 sinfo->nskt = ops->nr; pxa2xx_drv_pcmcia_probe()
313 for (i = 0; i < ops->nr; i++) { pxa2xx_drv_pcmcia_probe()
316 skt->nr = ops->first + i; pxa2xx_drv_pcmcia_probe()
318 soc_pcmcia_init_one(skt, ops, &dev->dev); pxa2xx_drv_pcmcia_probe()
/linux-4.4.14/arch/x86/kernel/
H A Dparavirt_patch_32.c38 #define PATCH_SITE(ops, x) \ native_patch()
39 case PARAVIRT_PATCH(ops.x): \ native_patch()
40 start = start_##ops##_##x; \ native_patch()
41 end = end_##ops##_##x; \ native_patch()
H A Dparavirt_patch_64.c48 #define PATCH_SITE(ops, x) \ native_patch()
49 case PARAVIRT_PATCH(ops.x): \ native_patch()
50 start = start_##ops##_##x; \ native_patch()
51 end = end_##ops##_##x; \ native_patch()
/linux-4.4.14/arch/sparc/include/asm/
H A Dleon_pci.h12 struct pci_ops *ops; member in struct:leon_pci_info
/linux-4.4.14/arch/microblaze/oprofile/
H A Dmicroblaze_oprofile.c15 int __init oprofile_arch_init(struct oprofile_operations *ops) oprofile_arch_init() argument
/linux-4.4.14/arch/mn10300/oprofile/
H A Dop_model_null.c14 int __init oprofile_arch_init(struct oprofile_operations *ops) oprofile_arch_init() argument
/linux-4.4.14/arch/arm/include/asm/
H A Dfirmware.h71 * register_firmware_ops(ops)
75 static inline void register_firmware_ops(const struct firmware_ops *ops) register_firmware_ops() argument
77 BUG_ON(!ops); register_firmware_ops()
79 firmware_ops = ops; register_firmware_ops()
/linux-4.4.14/sound/soc/codecs/
H A Dsigmadsp.h28 const struct sigmadsp_ops *ops; member in struct:sigmadsp
47 const struct sigmadsp_ops *ops, const char *firmware_name);
56 struct regmap *regmap, const struct sigmadsp_ops *ops,
59 const struct sigmadsp_ops *ops, const char *firmware_name);
/linux-4.4.14/arch/um/drivers/
H A Dchan_kern.c91 if (chan->ops->open == NULL) open_one_chan()
93 else fd = (*chan->ops->open)(chan->input, chan->output, chan->primary, open_one_chan()
100 (*chan->ops->close)(fd, chan->data); open_one_chan()
127 if (chan && chan->primary && chan->ops->winch) chan_enable_winch()
224 if (chan->ops->close != NULL) close_one_chan()
225 (*chan->ops->close)(chan->fd, chan->data); close_one_chan()
262 if (len == 0 || !chan || !chan->ops->write) write_chan()
265 n = chan->ops->write(chan->fd, buf, len, chan->data); write_chan()
278 if (!chan || !chan->ops->console_write) console_write_chan()
281 n = chan->ops->console_write(chan->fd, buf, len); console_write_chan()
307 if (chan->ops->window_size == NULL) chan_window_size()
309 return chan->ops->window_size(chan->fd, chan->data, chan_window_size()
314 if (chan->ops->window_size == NULL) chan_window_size()
316 return chan->ops->window_size(chan->fd, chan->data, chan_window_size()
328 if (chan->ops->free != NULL) free_one_chan()
329 (*chan->ops->free)(chan->data); free_one_chan()
357 CONFIG_CHUNK(str, size, n, chan->ops->type, 0); one_chan_config_string()
408 const struct chan_ops *ops; member in struct:chan_type
451 const struct chan_ops *ops; parse_chan() local
456 ops = NULL; parse_chan()
461 ops = entry->ops; parse_chan()
466 if (ops == NULL) { parse_chan()
471 data = (*ops->init)(str, device, opts); parse_chan()
492 .ops = ops, parse_chan()
554 if (!chan || !chan->ops->read) chan_interrupt()
562 err = chan->ops->read(chan->fd, &c, chan->data); chan_interrupt()
/linux-4.4.14/net/openvswitch/
H A Dvport.c74 int __ovs_vport_ops_register(struct vport_ops *ops) __ovs_vport_ops_register() argument
81 if (ops->type == o->type) __ovs_vport_ops_register()
84 list_add_tail(&ops->list, &vport_ops_list); __ovs_vport_ops_register()
92 void ovs_vport_ops_unregister(struct vport_ops *ops) ovs_vport_ops_unregister() argument
95 list_del(&ops->list); ovs_vport_ops_unregister()
124 * @ops: vport device ops
126 * Allocate and initialize a new vport defined by @ops. The vport will contain
131 struct vport *ovs_vport_alloc(int priv_size, const struct vport_ops *ops, ovs_vport_alloc() argument
149 vport->ops = ops; ovs_vport_alloc()
183 struct vport_ops *ops; ovs_vport_lookup() local
185 list_for_each_entry(ops, &vport_ops_list, list) ovs_vport_lookup()
186 if (ops->type == parms->type) ovs_vport_lookup()
187 return ops; ovs_vport_lookup()
202 struct vport_ops *ops; ovs_vport_add() local
205 ops = ovs_vport_lookup(parms); ovs_vport_add()
206 if (ops) { ovs_vport_add()
209 if (!try_module_get(ops->owner)) ovs_vport_add()
212 vport = ops->create(parms); ovs_vport_add()
214 module_put(ops->owner); ovs_vport_add()
249 if (!vport->ops->set_options) ovs_vport_set_options()
251 return vport->ops->set_options(vport, options); ovs_vport_set_options()
267 module_put(vport->ops->owner); ovs_vport_del()
268 vport->ops->destroy(vport); ovs_vport_del()
319 if (!vport->ops->get_options) ovs_vport_get_options()
326 err = vport->ops->get_options(vport, skb); ovs_vport_get_options()
506 vport->ops->send(skb); ovs_vport_send()
/linux-4.4.14/drivers/clk/sirf/
H A Dclk-common.c199 .ops = &std_pll_ops,
206 .ops = &std_pll_ops,
213 .ops = &std_pll_ops,
276 .ops = &usb_pll_ops,
450 .ops = &msi_ops,
464 .ops = &msi_ops,
479 .ops = &msi_ops,
501 .ops = &cpu_ops,
529 .ops = &dmn_ops,
544 .ops = &dmn_ops,
559 .ops = &dmn_ops,
579 .ops = &dmn_ops,
594 .ops = &dmn_ops,
609 .ops = &dmn_ops,
616 .ops = &dmn_ops,
623 .ops = &dmn_ops,
690 .ops = &ios_ops,
704 .ops = &ios_ops,
718 .ops = &ios_ops,
732 .ops = &ios_ops,
746 .ops = &ios_ops,
760 .ops = &ios_ops,
774 .ops = &ios_ops,
788 .ops = &ios_ops,
802 .ops = &ios_ops,
816 .ops = &ios_ops,
830 .ops = &ios_ops,
844 .ops = &ios_ops,
858 .ops = &ios_ops,
872 .ops = &ios_ops,
886 .ops = &ios_ops,
900 .ops = &ios_ops,
914 .ops = &ios_ops,
928 .ops = &ios_ops,
942 .ops = &ios_ops,
960 .ops = &ios_ops,
974 .ops = &ios_ops,
992 .ops = &ios_ops,
1010 .ops = &ios_ops,
1024 .ops = &ios_ops,
/linux-4.4.14/drivers/clk/imx/
H A Dclk-fixup-mux.c23 * @ops: pointer to clk_ops of parent class
31 const struct clk_ops *ops; member in struct:clk_fixup_mux
46 return fixup_mux->ops->get_parent(&fixup_mux->mux.hw); clk_fixup_mux_get_parent()
90 init.ops = &clk_fixup_mux_ops; imx_clk_fixup_mux()
100 fixup_mux->ops = &clk_mux_ops; imx_clk_fixup_mux()
/linux-4.4.14/arch/arm64/kernel/
H A Dcpu_ops.c40 const struct cpu_operations **ops = supported_cpu_ops; cpu_get_ops() local
42 while (*ops) { cpu_get_ops()
43 if (!strcmp(name, (*ops)->name)) cpu_get_ops()
44 return *ops; cpu_get_ops()
46 ops++; cpu_get_ops()
H A Darmv8_deprecated.c58 struct insn_emulation_ops *ops; member in struct:insn_emulation
68 static void register_emulation_hooks(struct insn_emulation_ops *ops) register_emulation_hooks() argument
72 BUG_ON(!ops->hooks); register_emulation_hooks()
74 for (hook = ops->hooks; hook->instr_mask; hook++) register_emulation_hooks()
77 pr_notice("Registered %s emulation handler\n", ops->name); register_emulation_hooks()
80 static void remove_emulation_hooks(struct insn_emulation_ops *ops) remove_emulation_hooks() argument
84 BUG_ON(!ops->hooks); remove_emulation_hooks()
86 for (hook = ops->hooks; hook->instr_mask; hook++) remove_emulation_hooks()
89 pr_notice("Removed %s emulation handler\n", ops->name); remove_emulation_hooks()
95 if (insn->ops->set_hw_mode) enable_insn_hw_mode()
96 insn->ops->set_hw_mode(true); enable_insn_hw_mode()
102 if (insn->ops->set_hw_mode) disable_insn_hw_mode()
103 insn->ops->set_hw_mode(false); disable_insn_hw_mode()
109 if (!insn->ops->set_hw_mode) run_all_cpu_set_hw_mode()
133 if (insn->ops->set_hw_mode && insn->ops->set_hw_mode(enable)) { run_all_insn_set_hw_mode()
135 cpu, insn->ops->name); run_all_insn_set_hw_mode()
152 remove_emulation_hooks(insn->ops); update_insn_emulation_mode()
156 pr_notice("Disabled %s support\n", insn->ops->name); update_insn_emulation_mode()
164 register_emulation_hooks(insn->ops); update_insn_emulation_mode()
169 pr_notice("Enabled %s support\n", insn->ops->name); update_insn_emulation_mode()
176 static void register_insn_emulation(struct insn_emulation_ops *ops) register_insn_emulation() argument
182 insn->ops = ops; register_insn_emulation()
185 switch (ops->status) { register_insn_emulation()
257 sysctl->procname = insn->ops->name; register_insn_emulation_sysctl()
/linux-4.4.14/drivers/media/platform/vivid/
H A Dvivid-ctrls.c136 .ops = &vivid_user_gen_ctrl_ops,
143 .ops = &vivid_user_gen_ctrl_ops,
154 .ops = &vivid_user_gen_ctrl_ops,
164 .ops = &vivid_user_gen_ctrl_ops,
174 .ops = &vivid_user_gen_ctrl_ops,
186 .ops = &vivid_user_gen_ctrl_ops,
198 .ops = &vivid_user_gen_ctrl_ops,
220 .ops = &vivid_user_gen_ctrl_ops,
232 .ops = &vivid_user_gen_ctrl_ops,
242 .ops = &vivid_user_gen_ctrl_ops,
257 .ops = &vivid_user_gen_ctrl_ops,
269 .ops = &vivid_user_gen_ctrl_ops,
276 .ops = &vivid_user_gen_ctrl_ops,
493 .ops = &vivid_vid_cap_ctrl_ops,
514 .ops = &vivid_vid_cap_ctrl_ops,
524 .ops = &vivid_vid_cap_ctrl_ops,
533 .ops = &vivid_vid_cap_ctrl_ops,
549 .ops = &vivid_vid_cap_ctrl_ops,
558 .ops = &vivid_vid_cap_ctrl_ops,
569 .ops = &vivid_vid_cap_ctrl_ops,
578 .ops = &vivid_vid_cap_ctrl_ops,
587 .ops = &vivid_vid_cap_ctrl_ops,
596 .ops = &vivid_vid_cap_ctrl_ops,
605 .ops = &vivid_vid_cap_ctrl_ops,
615 .ops = &vivid_vid_cap_ctrl_ops,
625 .ops = &vivid_vid_cap_ctrl_ops,
641 .ops = &vivid_vid_cap_ctrl_ops,
650 .ops = &vivid_vid_cap_ctrl_ops,
672 .ops = &vivid_vid_cap_ctrl_ops,
681 .ops = &vivid_vid_cap_ctrl_ops,
690 .ops = &vivid_vid_cap_ctrl_ops,
714 .ops = &vivid_vid_cap_ctrl_ops,
736 .ops = &vivid_vid_cap_ctrl_ops,
758 .ops = &vivid_vid_cap_ctrl_ops,
774 .ops = &vivid_vid_cap_ctrl_ops,
783 .ops = &vivid_vid_cap_ctrl_ops,
792 .ops = &vivid_vid_cap_ctrl_ops,
823 .ops = &vivid_loop_cap_ctrl_ops,
851 .ops = &vivid_vbi_cap_ctrl_ops,
908 .ops = &vivid_vid_out_ctrl_ops,
918 .ops = &vivid_vid_out_ctrl_ops,
928 .ops = &vivid_vid_out_ctrl_ops,
994 .ops = &vivid_streaming_ctrl_ops,
1001 .ops = &vivid_streaming_ctrl_ops,
1011 .ops = &vivid_streaming_ctrl_ops,
1018 .ops = &vivid_streaming_ctrl_ops,
1025 .ops = &vivid_streaming_ctrl_ops,
1032 .ops = &vivid_streaming_ctrl_ops,
1039 .ops = &vivid_streaming_ctrl_ops,
1048 .ops = &vivid_streaming_ctrl_ops,
1092 .ops = &vivid_sdtv_cap_ctrl_ops,
1102 .ops = &vivid_sdtv_cap_ctrl_ops,
1166 .ops = &vivid_radio_rx_ctrl_ops,
1175 .ops = &vivid_radio_rx_ctrl_ops,
1191 .ops = &vivid_radio_rx_ctrl_ops,
1200 .ops = &vivid_radio_rx_ctrl_ops,
1255 .ops = &vivid_radio_tx_ctrl_ops,
1284 .ops = &vivid_sdr_cap_ctrl_ops,
1296 .ops = &vivid_user_gen_ctrl_ops,
1321 .ops = &vivid_vid_cap_ctrl_ops, vivid_create_controls()
1397 .ops = &vivid_vid_cap_ctrl_ops, vivid_create_controls()
/linux-4.4.14/drivers/video/fbdev/omap2/displays-new/
H A Dpanel-dsi-cm.c118 r = in->ops.dsi->dcs_read(in, ddata->channel, dcs_cmd, buf, 1); dsicm_dcs_read_1()
131 return in->ops.dsi->dcs_write(in, ddata->channel, &dcs_cmd, 1); dsicm_dcs_write_0()
139 return in->ops.dsi->dcs_write(in, ddata->channel, buf, 2); dsicm_dcs_write_1()
152 r = in->ops.dsi->dcs_write_nosync(in, ddata->channel, &cmd, 1); dsicm_sleep_in()
214 r = in->ops.dsi->dcs_write_nosync(in, ddata->channel, buf, sizeof(buf)); dsicm_set_update_window()
224 r = in->ops.dsi->dcs_write_nosync(in, ddata->channel, buf, sizeof(buf)); dsicm_set_update_window()
228 in->ops.dsi->bta_sync(in, ddata->channel); dsicm_set_update_window()
262 in->ops.dsi->disable(in, false, true); dsicm_enter_ulps()
287 r = in->ops.dsi->enable(in); dsicm_exit_ulps()
293 in->ops.dsi->enable_hs(in, ddata->channel, true); dsicm_exit_ulps()
353 in->ops.dsi->bus_lock(in); dsicm_bl_update_status()
359 in->ops.dsi->bus_unlock(in); dsicm_bl_update_status()
402 in->ops.dsi->bus_lock(in); dsicm_num_errors_show()
409 in->ops.dsi->bus_unlock(in); dsicm_num_errors_show()
434 in->ops.dsi->bus_lock(in); dsicm_hw_revision_show()
440 in->ops.dsi->bus_unlock(in); dsicm_hw_revision_show()
470 in->ops.dsi->bus_lock(in); dsicm_store_ulps()
477 in->ops.dsi->bus_unlock(in); dsicm_store_ulps()
522 in->ops.dsi->bus_lock(in); dsicm_store_ulps_timeout()
524 in->ops.dsi->bus_unlock(in); dsicm_store_ulps_timeout()
601 r = in->ops.dsi->configure_pins(in, &ddata->pin_config); dsicm_power_on()
609 r = in->ops.dsi->set_config(in, &dsi_config); dsicm_power_on()
615 r = in->ops.dsi->enable(in); dsicm_power_on()
623 in->ops.dsi->enable_hs(in, ddata->channel, false); dsicm_power_on()
655 r = in->ops.dsi->enable_video_output(in, ddata->channel); dsicm_power_on()
667 in->ops.dsi->enable_hs(in, ddata->channel, true); dsicm_power_on()
675 in->ops.dsi->disable(in, true, false); dsicm_power_on()
685 in->ops.dsi->disable_video_output(in, ddata->channel); dsicm_power_off()
697 in->ops.dsi->disable(in, true, false); dsicm_power_off()
721 r = in->ops.dsi->connect(in, dssdev); dsicm_connect()
727 r = in->ops.dsi->request_vc(ddata->in, &ddata->channel); dsicm_connect()
733 r = in->ops.dsi->set_vc_id(ddata->in, ddata->channel, TCH); dsicm_connect()
742 in->ops.dsi->release_vc(ddata->in, ddata->channel); dsicm_connect()
744 in->ops.dsi->disconnect(in, dssdev); dsicm_connect()
756 in->ops.dsi->release_vc(in, ddata->channel); dsicm_disconnect()
757 in->ops.dsi->disconnect(in, dssdev); dsicm_disconnect()
780 in->ops.dsi->bus_lock(in); dsicm_enable()
784 in->ops.dsi->bus_unlock(in); dsicm_enable()
812 in->ops.dsi->bus_lock(in); dsicm_disable()
820 in->ops.dsi->bus_unlock(in); dsicm_disable()
833 in->ops.dsi->bus_unlock(ddata->in); dsicm_framedone_cb()
848 r = in->ops.dsi->update(in, ddata->channel, dsicm_framedone_cb, dsicm_te_isr()
857 in->ops.dsi->bus_unlock(in); dsicm_te_isr()
870 in->ops.dsi->bus_unlock(in); dsicm_te_timeout_work_callback()
883 in->ops.dsi->bus_lock(in); dsicm_update()
906 r = in->ops.dsi->update(in, ddata->channel, dsicm_framedone_cb, dsicm_update()
916 in->ops.dsi->bus_unlock(in); dsicm_update()
929 in->ops.dsi->bus_lock(in); dsicm_sync()
930 in->ops.dsi->bus_unlock(in); dsicm_sync()
949 in->ops.dsi->enable_te(in, enable); _dsicm_enable_te()
968 in->ops.dsi->bus_lock(in); dsicm_enable_te()
982 in->ops.dsi->bus_unlock(in); dsicm_enable_te()
988 in->ops.dsi->bus_unlock(in); dsicm_enable_te()
1031 in->ops.dsi->bus_lock(in); dsicm_memory_read()
1047 r = in->ops.dsi->set_max_rx_packet_size(in, ddata->channel, plen); dsicm_memory_read()
1055 r = in->ops.dsi->dcs_read(in, ddata->channel, dcs_cmd, dsicm_memory_read()
1081 in->ops.dsi->set_max_rx_packet_size(in, ddata->channel, 1); dsicm_memory_read()
1083 in->ops.dsi->bus_unlock(in); dsicm_memory_read()
1103 in->ops.dsi->bus_lock(in); dsicm_ulps_work()
1107 in->ops.dsi->bus_unlock(in); dsicm_ulps_work()
/linux-4.4.14/arch/sh/drivers/dma/
H A Ddma-api.c100 if (info->ops->get_residue) get_dma_residue()
101 return info->ops->get_residue(channel); get_dma_residue()
182 if (info->ops->request) { dmac_search_free_channel()
183 int result = info->ops->request(channel); dmac_search_free_channel()
206 if (info->ops->request) { request_dma()
207 result = info->ops->request(channel); request_dma()
223 if (info->ops->free) free_dma()
224 info->ops->free(channel); free_dma()
237 (info->ops->get_residue(channel) == 0)); dma_wait_for_completion()
241 while (info->ops->get_residue(channel)) dma_wait_for_completion()
280 if (info->ops->configure) dma_configure_channel()
281 info->ops->configure(channel, flags); dma_configure_channel()
296 return info->ops->xfer(channel); dma_xfer()
305 if (info->ops->extend) dma_extend()
306 return info->ops->extend(channel, op, param); dma_extend()
/linux-4.4.14/net/sunrpc/
H A Dauth.c95 rpcauth_register(const struct rpc_authops *ops) rpcauth_register() argument
100 if ((flavor = ops->au_flavor) >= RPC_AUTH_MAXFLAVOR) rpcauth_register()
104 auth_flavors[flavor] = ops; rpcauth_register()
113 rpcauth_unregister(const struct rpc_authops *ops) rpcauth_unregister() argument
118 if ((flavor = ops->au_flavor) >= RPC_AUTH_MAXFLAVOR) rpcauth_unregister()
121 if (auth_flavors[flavor] == ops) { rpcauth_unregister()
142 const struct rpc_authops *ops; rpcauth_get_pseudoflavor() local
145 ops = auth_flavors[flavor]; rpcauth_get_pseudoflavor()
146 if (ops == NULL) rpcauth_get_pseudoflavor()
149 ops = auth_flavors[flavor]; rpcauth_get_pseudoflavor()
150 if (ops == NULL || !try_module_get(ops->owner)) { rpcauth_get_pseudoflavor()
157 if (ops->info2flavor != NULL) rpcauth_get_pseudoflavor()
158 pseudoflavor = ops->info2flavor(info); rpcauth_get_pseudoflavor()
160 module_put(ops->owner); rpcauth_get_pseudoflavor()
177 const struct rpc_authops *ops; rpcauth_get_gssinfo() local
183 ops = auth_flavors[flavor]; rpcauth_get_gssinfo()
184 if (ops == NULL) rpcauth_get_gssinfo()
187 ops = auth_flavors[flavor]; rpcauth_get_gssinfo()
188 if (ops == NULL || !try_module_get(ops->owner)) { rpcauth_get_gssinfo()
195 if (ops->flavor2info != NULL) rpcauth_get_gssinfo()
196 result = ops->flavor2info(pseudoflavor, info); rpcauth_get_gssinfo()
198 module_put(ops->owner); rpcauth_get_gssinfo()
221 const struct rpc_authops *ops = auth_flavors[flavor]; rpcauth_list_flavors() local
230 if (ops == NULL) rpcauth_list_flavors()
232 if (ops->list_pseudoflavors == NULL) { rpcauth_list_flavors()
233 array[result++] = ops->au_flavor; rpcauth_list_flavors()
236 len = ops->list_pseudoflavors(pseudos, ARRAY_SIZE(pseudos)); rpcauth_list_flavors()
260 const struct rpc_authops *ops; rpcauth_create() local
267 if ((ops = auth_flavors[flavor]) == NULL) rpcauth_create()
270 ops = auth_flavors[flavor]; rpcauth_create()
271 if (ops == NULL || !try_module_get(ops->owner)) { rpcauth_create()
276 auth = ops->create(args, clnt); rpcauth_create()
277 module_put(ops->owner); rpcauth_create()
641 struct rpc_auth *auth, const struct rpc_credops *ops) rpcauth_init_cred()
647 cred->cr_ops = ops; rpcauth_init_cred()
640 rpcauth_init_cred(struct rpc_cred *cred, const struct auth_cred *acred, struct rpc_auth *auth, const struct rpc_credops *ops) rpcauth_init_cred() argument
/linux-4.4.14/drivers/media/dvb-core/
H A Ddvb_frontend.c149 return fe->ops.get_frontend != NULL; has_get_frontend()
286 __func__, fe->dvb->num, fe->id, fe->ops.info.name); dvb_frontend_init()
288 if (fe->ops.init) dvb_frontend_init()
289 fe->ops.init(fe); dvb_frontend_init()
290 if (fe->ops.tuner_ops.init) { dvb_frontend_init()
291 if (fe->ops.i2c_gate_ctrl) dvb_frontend_init()
292 fe->ops.i2c_gate_ctrl(fe, 1); dvb_frontend_init()
293 fe->ops.tuner_ops.init(fe); dvb_frontend_init()
294 if (fe->ops.i2c_gate_ctrl) dvb_frontend_init()
295 fe->ops.i2c_gate_ctrl(fe, 0); dvb_frontend_init()
344 autoinversion = ((!(fe->ops.info.caps & FE_CAN_INVERSION_AUTO)) && dvb_frontend_swzigzag_autotune()
416 if (fe->ops.set_frontend) dvb_frontend_swzigzag_autotune()
417 fe_set_err = fe->ops.set_frontend(fe); dvb_frontend_swzigzag_autotune()
449 if (fe->ops.set_frontend) dvb_frontend_swzigzag()
450 retval = fe->ops.set_frontend(fe); dvb_frontend_swzigzag()
466 if (fe->ops.read_status) dvb_frontend_swzigzag()
467 fe->ops.read_status(fe, &s); dvb_frontend_swzigzag()
480 if ((!(fe->ops.info.caps & FE_CAN_INVERSION_AUTO)) && dvb_frontend_swzigzag()
504 (fe->ops.info.caps & FE_CAN_RECOVER) && (fepriv->max_drift == 0)) { dvb_frontend_swzigzag()
753 if (fe->ops.set_tone && fepriv->tone != -1) dvb_frontend_thread()
754 fe->ops.set_tone(fe, fepriv->tone); dvb_frontend_thread()
755 if (fe->ops.set_voltage && fepriv->voltage != -1) dvb_frontend_thread()
756 fe->ops.set_voltage(fe, fepriv->voltage); dvb_frontend_thread()
761 if (fe->ops.get_frontend_algo) { dvb_frontend_thread()
762 algo = fe->ops.get_frontend_algo(fe); dvb_frontend_thread()
775 if (fe->ops.tune) dvb_frontend_thread()
776 fe->ops.tune(fe, re_tune, fepriv->tune_mode_flags, &fepriv->delay, &s); dvb_frontend_thread()
799 if (fe->ops.search) { dvb_frontend_thread()
800 fepriv->algo_status = fe->ops.search(fe); dvb_frontend_thread()
814 fe->ops.read_status(fe, &s); dvb_frontend_thread()
842 if (fe->ops.set_voltage) dvb_frontend_thread()
843 fe->ops.set_voltage(fe, SEC_VOLTAGE_OFF); dvb_frontend_thread()
844 if (fe->ops.tuner_ops.sleep) { dvb_frontend_thread()
845 if (fe->ops.i2c_gate_ctrl) dvb_frontend_thread()
846 fe->ops.i2c_gate_ctrl(fe, 1); dvb_frontend_thread()
847 fe->ops.tuner_ops.sleep(fe); dvb_frontend_thread()
848 if (fe->ops.i2c_gate_ctrl) dvb_frontend_thread()
849 fe->ops.i2c_gate_ctrl(fe, 0); dvb_frontend_thread()
851 if (fe->ops.sleep) dvb_frontend_thread()
852 fe->ops.sleep(fe); dvb_frontend_thread()
957 *freq_min = max(fe->ops.info.frequency_min, fe->ops.tuner_ops.info.frequency_min); dvb_frontend_get_frequency_limits()
959 if (fe->ops.info.frequency_max == 0) dvb_frontend_get_frequency_limits()
960 *freq_max = fe->ops.tuner_ops.info.frequency_max; dvb_frontend_get_frequency_limits()
961 else if (fe->ops.tuner_ops.info.frequency_max == 0) dvb_frontend_get_frequency_limits()
962 *freq_max = fe->ops.info.frequency_max; dvb_frontend_get_frequency_limits()
964 *freq_max = min(fe->ops.info.frequency_max, fe->ops.tuner_ops.info.frequency_max); dvb_frontend_get_frequency_limits()
994 if ((fe->ops.info.symbol_rate_min && dvb_frontend_check_parameters()
995 c->symbol_rate < fe->ops.info.symbol_rate_min) || dvb_frontend_check_parameters()
996 (fe->ops.info.symbol_rate_max && dvb_frontend_check_parameters()
997 c->symbol_rate > fe->ops.info.symbol_rate_max)) { dvb_frontend_check_parameters()
1000 fe->ops.info.symbol_rate_min, dvb_frontend_check_parameters()
1001 fe->ops.info.symbol_rate_max); dvb_frontend_check_parameters()
1354 if (fe->ops.get_frontend) { dtv_get_frontend()
1355 r = fe->ops.get_frontend(fe); dtv_get_frontend()
1382 while (ncaps < MAX_DELSYS && fe->ops.delsys[ncaps]) { dtv_property_process_get()
1383 tvp->u.buffer.data[ncaps] = fe->ops.delsys[ncaps]; dtv_property_process_get()
1589 if (fe->ops.get_property) { dtv_property_process_get()
1590 r = fe->ops.get_property(fe, tvp); dtv_property_process_get()
1691 desired_system = fe->ops.delsys[0]; dvbv5_set_delivery_system()
1699 while (ncaps < MAX_DELSYS && fe->ops.delsys[ncaps]) { dvbv5_set_delivery_system()
1700 if (fe->ops.delsys[ncaps] == desired_system) { dvbv5_set_delivery_system()
1731 while (ncaps < MAX_DELSYS && fe->ops.delsys[ncaps]) { dvbv5_set_delivery_system()
1732 if (dvbv3_type(fe->ops.delsys[ncaps]) == type) dvbv5_set_delivery_system()
1733 delsys = fe->ops.delsys[ncaps]; dvbv5_set_delivery_system()
1788 c->delivery_system = fe->ops.delsys[0]; dvbv3_set_delivery_system()
1806 while (ncaps < MAX_DELSYS && fe->ops.delsys[ncaps]) { dvbv3_set_delivery_system()
1807 if (dvbv3_type(fe->ops.delsys[ncaps]) != DVBV3_UNKNOWN) { dvbv3_set_delivery_system()
1808 delsys = fe->ops.delsys[ncaps]; dvbv3_set_delivery_system()
1830 if (fe->ops.set_property) { dtv_property_process_set()
1831 r = fe->ops.set_property(fe, tvp); dtv_property_process_set()
1983 if (fe->ops.set_lna) dtv_property_process_set()
1984 r = fe->ops.set_lna(fe); dtv_property_process_set()
2214 if (fe->ops.get_tune_settings && (fe->ops.get_tune_settings(fe, &fetunesettings) == 0)) { dtv_set_frontend()
2236 fepriv->step_size = fe->ops.info.frequency_stepsize * 2; dtv_set_frontend()
2237 fepriv->max_drift = (fe->ops.info.frequency_stepsize * 2) + 1; dtv_set_frontend()
2280 memcpy(info, &fe->ops.info, sizeof(struct dvb_frontend_info)); dvb_frontend_ioctl_legacy()
2311 fe->ops.info.type = FE_OFDM; dvb_frontend_ioctl_legacy()
2314 __func__, c->delivery_system, fe->ops.info.type); dvb_frontend_ioctl_legacy()
2335 if (fe->ops.read_status) dvb_frontend_ioctl_legacy()
2336 err = fe->ops.read_status(fe, status); dvb_frontend_ioctl_legacy()
2341 if (fe->ops.read_ber) { dvb_frontend_ioctl_legacy()
2343 err = fe->ops.read_ber(fe, (__u32 *) parg); dvb_frontend_ioctl_legacy()
2350 if (fe->ops.read_signal_strength) { dvb_frontend_ioctl_legacy()
2352 err = fe->ops.read_signal_strength(fe, (__u16 *) parg); dvb_frontend_ioctl_legacy()
2359 if (fe->ops.read_snr) { dvb_frontend_ioctl_legacy()
2361 err = fe->ops.read_snr(fe, (__u16 *) parg); dvb_frontend_ioctl_legacy()
2368 if (fe->ops.read_ucblocks) { dvb_frontend_ioctl_legacy()
2370 err = fe->ops.read_ucblocks(fe, (__u32 *) parg); dvb_frontend_ioctl_legacy()
2377 if (fe->ops.diseqc_reset_overload) { dvb_frontend_ioctl_legacy()
2378 err = fe->ops.diseqc_reset_overload(fe); dvb_frontend_ioctl_legacy()
2385 if (fe->ops.diseqc_send_master_cmd) { dvb_frontend_ioctl_legacy()
2392 err = fe->ops.diseqc_send_master_cmd(fe, cmd); dvb_frontend_ioctl_legacy()
2399 if (fe->ops.diseqc_send_burst) { dvb_frontend_ioctl_legacy()
2400 err = fe->ops.diseqc_send_burst(fe, dvb_frontend_ioctl_legacy()
2408 if (fe->ops.set_tone) { dvb_frontend_ioctl_legacy()
2409 err = fe->ops.set_tone(fe, dvb_frontend_ioctl_legacy()
2418 if (fe->ops.set_voltage) { dvb_frontend_ioctl_legacy()
2419 err = fe->ops.set_voltage(fe, dvb_frontend_ioctl_legacy()
2428 if (fe->ops.dishnetwork_send_legacy_command) { dvb_frontend_ioctl_legacy()
2429 err = fe->ops.dishnetwork_send_legacy_command(fe, dvb_frontend_ioctl_legacy()
2433 } else if (fe->ops.set_voltage) { dvb_frontend_ioctl_legacy()
2463 fe->ops.set_voltage(fe, SEC_VOLTAGE_18); dvb_frontend_ioctl_legacy()
2471 fe->ops.set_voltage(fe, (last) ? SEC_VOLTAGE_13 : SEC_VOLTAGE_18); dvb_frontend_ioctl_legacy()
2492 if (fe->ops.diseqc_recv_slave_reply) dvb_frontend_ioctl_legacy()
2493 err = fe->ops.diseqc_recv_slave_reply(fe, (struct dvb_diseqc_slave_reply*) parg); dvb_frontend_ioctl_legacy()
2497 if (fe->ops.enable_high_lnb_voltage) dvb_frontend_ioctl_legacy()
2498 err = fe->ops.enable_high_lnb_voltage(fe, (long) parg); dvb_frontend_ioctl_legacy()
2596 if (dvbdev->users == -1 && fe->ops.ts_bus_ctrl) { dvb_frontend_open()
2597 if ((ret = fe->ops.ts_bus_ctrl(fe, 1)) < 0) dvb_frontend_open()
2633 if (dvbdev->users == -1 && fe->ops.ts_bus_ctrl) dvb_frontend_open()
2634 fe->ops.ts_bus_ctrl(fe, 0); dvb_frontend_open()
2661 if (fe->ops.ts_bus_ctrl) dvb_frontend_release()
2662 fe->ops.ts_bus_ctrl(fe, 0); dvb_frontend_release()
2684 if (fe->ops.tuner_ops.suspend) dvb_frontend_suspend()
2685 ret = fe->ops.tuner_ops.suspend(fe); dvb_frontend_suspend()
2686 else if (fe->ops.tuner_ops.sleep) dvb_frontend_suspend()
2687 ret = fe->ops.tuner_ops.sleep(fe); dvb_frontend_suspend()
2689 if (fe->ops.sleep) dvb_frontend_suspend()
2690 ret = fe->ops.sleep(fe); dvb_frontend_suspend()
2705 if (fe->ops.init) dvb_frontend_resume()
2706 ret = fe->ops.init(fe); dvb_frontend_resume()
2708 if (fe->ops.tuner_ops.resume) dvb_frontend_resume()
2709 ret = fe->ops.tuner_ops.resume(fe); dvb_frontend_resume()
2710 else if (fe->ops.tuner_ops.init) dvb_frontend_resume()
2711 ret = fe->ops.tuner_ops.init(fe); dvb_frontend_resume()
2731 .name = fe->ops.info.name, dvb_register_frontend()
2757 fe->dvb->num, fe->id, fe->ops.info.name); dvb_register_frontend()
2764 * first supported delivery system (ops->delsys[0]) dvb_register_frontend()
2767 fe->dtv_property_cache.delivery_system = fe->ops.delsys[0]; dvb_register_frontend()
2803 if (fe->ops.release_sec) { dvb_frontend_detach()
2804 fe->ops.release_sec(fe); dvb_frontend_detach()
2805 dvb_detach(fe->ops.release_sec); dvb_frontend_detach()
2807 if (fe->ops.tuner_ops.release) { dvb_frontend_detach()
2808 fe->ops.tuner_ops.release(fe); dvb_frontend_detach()
2809 dvb_detach(fe->ops.tuner_ops.release); dvb_frontend_detach()
2811 if (fe->ops.analog_ops.release) { dvb_frontend_detach()
2812 fe->ops.analog_ops.release(fe); dvb_frontend_detach()
2813 dvb_detach(fe->ops.analog_ops.release); dvb_frontend_detach()
2815 ptr = (void*)fe->ops.release; dvb_frontend_detach()
2817 fe->ops.release(fe); dvb_frontend_detach()
2824 if (fe->ops.release_sec) dvb_frontend_detach()
2825 fe->ops.release_sec(fe); dvb_frontend_detach()
2826 if (fe->ops.tuner_ops.release) dvb_frontend_detach()
2827 fe->ops.tuner_ops.release(fe); dvb_frontend_detach()
2828 if (fe->ops.analog_ops.release) dvb_frontend_detach()
2829 fe->ops.analog_ops.release(fe); dvb_frontend_detach()
2830 if (fe->ops.release) dvb_frontend_detach()
2831 fe->ops.release(fe); dvb_frontend_detach()
/linux-4.4.14/drivers/pinctrl/
H A Dpinconf.c29 const struct pinconf_ops *ops = pctldev->desc->confops; pinconf_check_ops() local
32 if (!ops->pin_config_set && !ops->pin_config_group_set) { pinconf_check_ops()
61 const struct pinconf_ops *ops = pctldev->desc->confops; pin_config_get_for_pin() local
63 if (!ops || !ops->pin_config_get) { pin_config_get_for_pin()
69 return ops->pin_config_get(pctldev, pin, config); pin_config_get_for_pin()
76 const struct pinconf_ops *ops; pin_config_group_get() local
87 ops = pctldev->desc->confops; pin_config_group_get()
89 if (!ops || !ops->pin_config_group_get) { pin_config_group_get()
103 ret = ops->pin_config_group_get(pctldev, selector, config); pin_config_group_get()
154 const struct pinconf_ops *ops = pctldev->desc->confops; pinconf_apply_setting() local
157 if (!ops) { pinconf_apply_setting()
164 if (!ops->pin_config_set) { pinconf_apply_setting()
168 ret = ops->pin_config_set(pctldev, pinconf_apply_setting()
180 if (!ops->pin_config_group_set) { pinconf_apply_setting()
185 ret = ops->pin_config_group_set(pctldev, pinconf_apply_setting()
286 const struct pinconf_ops *ops = pctldev->desc->confops; pinconf_dump_pin() local
290 if (ops && ops->pin_config_dbg_show) pinconf_dump_pin()
291 ops->pin_config_dbg_show(pctldev, s, pin); pinconf_dump_pin()
331 const struct pinconf_ops *ops = pctldev->desc->confops; pinconf_dump_group() local
335 if (ops && ops->pin_config_group_dbg_show) pinconf_dump_group()
336 ops->pin_config_group_dbg_show(pctldev, s, selector); pinconf_dump_group()
/linux-4.4.14/arch/powerpc/platforms/cell/spufs/
H A Drun.c57 *stat = ctx->ops->status_read(ctx); spu_stopped()
129 ctx->ops->signal1_write(ctx, (unsigned long)isolated_loader >> 32); spu_setup_isolated()
130 ctx->ops->signal2_write(ctx, spu_setup_isolated()
133 ctx->ops->runcntl_write(ctx, spu_setup_isolated()
138 while (((status = ctx->ops->status_read(ctx)) & status_loading) == spu_setup_isolated()
153 ctx->ops->runcntl_write(ctx, SPU_RUNCNTL_RUNNABLE); spu_setup_isolated()
161 ctx->ops->runcntl_write(ctx, SPU_RUNCNTL_STOP); spu_setup_isolated()
198 if (!(ctx->ops->status_read(ctx) & SPU_STATUS_ISOLATED_STATE)) { spu_run_init()
208 runcntl = ctx->ops->runcntl_read(ctx) & spu_run_init()
220 ctx->ops->privcntl_write(ctx, privcntl); spu_run_init()
221 ctx->ops->npc_write(ctx, *npc); spu_run_init()
224 ctx->ops->runcntl_write(ctx, runcntl); spu_run_init()
250 *status = ctx->ops->status_read(ctx); spu_run_fini()
251 *npc = ctx->ops->npc_read(ctx); spu_run_fini()
317 npc = ctx->ops->npc_read(ctx) & ~3; spu_process_callback()
318 ls = (void __iomem *)ctx->ops->get_ls(ctx); spu_process_callback()
343 ls = (void __iomem *)ctx->ops->get_ls(ctx); spu_process_callback()
347 ctx->ops->npc_write(ctx, npc); spu_process_callback()
348 ctx->ops->runcntl_write(ctx, SPU_RUNCNTL_RUNNABLE); spu_process_callback()
/linux-4.4.14/arch/sparc/kernel/
H A Dpci_msi.c17 const struct sparc64_msiq_ops *ops; sparc64_msiq_interrupt() local
21 ops = pbm->msi_ops; sparc64_msiq_interrupt()
23 err = ops->get_head(pbm, msiqid, &head); sparc64_msiq_interrupt()
31 err = ops->dequeue_msi(pbm, msiqid, &head, &msi); sparc64_msiq_interrupt()
46 err = ops->set_head(pbm, msiqid, head); sparc64_msiq_interrupt()
126 const struct sparc64_msiq_ops *ops = pbm->msi_ops; sparc64_setup_msi_irq() local
147 err = ops->msi_setup(pbm, msiqid, msi, sparc64_setup_msi_irq()
184 const struct sparc64_msiq_ops *ops = pbm->msi_ops; sparc64_teardown_msi_irq() local
201 err = ops->msi_teardown(pbm, msi_num); sparc64_teardown_msi_irq()
203 printk(KERN_ERR "%s: teardown: ops->teardown() on MSI %u, " sparc64_teardown_msi_irq()
275 const struct sparc64_msiq_ops *ops, bringup_one_msi_queue()
279 int irq = ops->msiq_build_irq(pbm, msiqid, devino); bringup_one_msi_queue()
302 const struct sparc64_msiq_ops *ops) sparc64_bringup_msi_queues()
311 err = bringup_one_msi_queue(pbm, ops, msiqid, devino); sparc64_bringup_msi_queues()
320 const struct sparc64_msiq_ops *ops) sparc64_pbm_msi_init()
404 if (ops->msiq_alloc(pbm)) { sparc64_pbm_msi_init()
410 if (sparc64_bringup_msi_queues(pbm, ops)) { sparc64_pbm_msi_init()
411 ops->msiq_free(pbm); sparc64_pbm_msi_init()
437 pbm->msi_ops = ops; sparc64_pbm_msi_init()
274 bringup_one_msi_queue(struct pci_pbm_info *pbm, const struct sparc64_msiq_ops *ops, unsigned long msiqid, unsigned long devino) bringup_one_msi_queue() argument
301 sparc64_bringup_msi_queues(struct pci_pbm_info *pbm, const struct sparc64_msiq_ops *ops) sparc64_bringup_msi_queues() argument
319 sparc64_pbm_msi_init(struct pci_pbm_info *pbm, const struct sparc64_msiq_ops *ops) sparc64_pbm_msi_init() argument
/linux-4.4.14/drivers/media/pci/ttpci/
H A Dbudget.c238 if (fe->ops.i2c_gate_ctrl) alps_bsrv2_tuner_set_params()
239 fe->ops.i2c_gate_ctrl(fe, 1); alps_bsrv2_tuner_set_params()
266 if (fe->ops.i2c_gate_ctrl) alps_tdbe2_tuner_set_params()
267 fe->ops.i2c_gate_ctrl(fe, 1); alps_tdbe2_tuner_set_params()
321 if (fe->ops.i2c_gate_ctrl) grundig_29504_401_tuner_set_params()
322 fe->ops.i2c_gate_ctrl(fe, 1); grundig_29504_401_tuner_set_params()
351 if (fe->ops.i2c_gate_ctrl) grundig_29504_451_tuner_set_params()
352 fe->ops.i2c_gate_ctrl(fe, 1); grundig_29504_451_tuner_set_params()
383 if (fe->ops.i2c_gate_ctrl) s5h1420_tuner_set_params()
384 fe->ops.i2c_gate_ctrl(fe, 1); s5h1420_tuner_set_params()
504 budget->dvb_frontend->ops.tuner_ops.set_params = alps_bsrv2_tuner_set_params; frontend_init()
505 budget->dvb_frontend->ops.diseqc_send_master_cmd = budget_diseqc_send_master_cmd; frontend_init()
506 budget->dvb_frontend->ops.diseqc_send_burst = budget_diseqc_send_burst; frontend_init()
507 budget->dvb_frontend->ops.set_tone = budget_set_tone; frontend_init()
514 budget->dvb_frontend->ops.tuner_ops.set_params = alps_bsru6_tuner_set_params; frontend_init()
517 budget->dvb_frontend->ops.diseqc_send_master_cmd = budget_diseqc_send_master_cmd; frontend_init()
518 budget->dvb_frontend->ops.diseqc_send_burst = budget_diseqc_send_burst; frontend_init()
519 budget->dvb_frontend->ops.set_tone = budget_set_tone; frontend_init()
529 budget->dvb_frontend->ops.tuner_ops.set_params = alps_tdbe2_tuner_set_params; frontend_init()
538 budget->dvb_frontend->ops.tuner_ops.set_params = grundig_29504_401_tuner_set_params; frontend_init()
548 budget->dvb_frontend->ops.tuner_ops.set_params = alps_bsru6_tuner_set_params; frontend_init()
566 budget->dvb_frontend->ops.tuner_ops.set_params = alps_bsru6_tuner_set_params; frontend_init()
568 budget->dvb_frontend->ops.set_voltage = siemens_budget_set_voltage; frontend_init()
569 budget->dvb_frontend->ops.dishnetwork_send_legacy_command = NULL; frontend_init()
582 budget->dvb_frontend->ops.tuner_ops.set_params = alps_bsbe1_tuner_set_params; frontend_init()
584 budget->dvb_frontend->ops.set_voltage = siemens_budget_set_voltage; frontend_init()
585 budget->dvb_frontend->ops.dishnetwork_send_legacy_command = NULL; frontend_init()
595 budget->dvb_frontend->ops.tuner_ops.set_params = grundig_29504_451_tuner_set_params; frontend_init()
596 budget->dvb_frontend->ops.set_voltage = siemens_budget_set_voltage; frontend_init()
597 budget->dvb_frontend->ops.dishnetwork_send_legacy_command = NULL; frontend_init()
604 budget->dvb_frontend->ops.tuner_ops.set_params = alps_tdhd1_204a_tuner_set_params; frontend_init()
613 budget->dvb_frontend->ops.tuner_ops.set_params = grundig_29504_401_tuner_set_params; frontend_init()
620 budget->dvb_frontend->ops.tuner_ops.set_params = s5h1420_tuner_set_params; frontend_init()
681 if (budget->dvb_frontend->ops.init) frontend_init()
682 budget->dvb_frontend->ops.init(budget->dvb_frontend); frontend_init()
735 if (budget->dvb_frontend->ops.init) frontend_init()
736 budget->dvb_frontend->ops.init(budget->dvb_frontend); frontend_init()
/linux-4.4.14/drivers/hid/
H A Dhid-wiimote-core.c620 const struct wiimod_ops *ops; wiimote_modules_load() local
647 ops = wiimod_table[*iter]; wiimote_modules_load()
648 if (!ops->probe) wiimote_modules_load()
651 ret = ops->probe(ops, wdata); wiimote_modules_load()
669 ops = wiimod_table[*iter]; wiimote_modules_load()
670 if (ops->remove) wiimote_modules_load()
671 ops->remove(ops, wdata); wiimote_modules_load()
683 const struct wiimod_ops *ops; wiimote_modules_unload() local
702 ops = wiimod_table[*iter]; wiimote_modules_unload()
703 if (ops->remove) wiimote_modules_unload()
704 ops->remove(ops, wdata); wiimote_modules_unload()
718 const struct wiimod_ops *ops; wiimote_ext_load() local
721 ops = wiimod_ext_table[ext]; wiimote_ext_load()
723 if (ops->probe) { wiimote_ext_load()
724 ret = ops->probe(ops, wdata); wiimote_ext_load()
737 const struct wiimod_ops *ops; wiimote_ext_unload() local
739 ops = wiimod_ext_table[wdata->state.exttype]; wiimote_ext_unload()
746 if (ops->remove) wiimote_ext_unload()
747 ops->remove(ops, wdata); wiimote_ext_unload()
753 const struct wiimod_ops *ops; wiimote_mp_load() local
757 ops = &wiimod_mp; wiimote_mp_load()
758 if (ops->probe) { wiimote_mp_load()
759 ret = ops->probe(ops, wdata); wiimote_mp_load()
772 const struct wiimod_ops *ops; wiimote_mp_unload() local
777 ops = &wiimod_mp; wiimote_mp_unload()
784 if (ops->remove) wiimote_mp_unload()
785 ops->remove(ops, wdata); wiimote_mp_unload()
1241 const struct wiimod_ops *ops; handler_keys() local
1243 ops = wiimod_ext_table[wdata->state.exttype]; handler_keys()
1244 if (ops->in_keys) { handler_keys()
1245 ops->in_keys(wdata, payload); handler_keys()
1251 ops = wiimod_table[*iter]; handler_keys()
1252 if (ops->in_keys) { handler_keys()
1253 ops->in_keys(wdata, payload); handler_keys()
1262 const struct wiimod_ops *ops; handler_accel() local
1264 ops = wiimod_ext_table[wdata->state.exttype]; handler_accel()
1265 if (ops->in_accel) { handler_accel()
1266 ops->in_accel(wdata, payload); handler_accel()
1272 ops = wiimod_table[*iter]; handler_accel()
1273 if (ops->in_accel) { handler_accel()
1274 ops->in_accel(wdata, payload); handler_accel()
1280 static bool valid_ext_handler(const struct wiimod_ops *ops, size_t len) valid_ext_handler() argument
1282 if (!ops->in_ext) valid_ext_handler()
1284 if ((ops->flags & WIIMOD_FLAG_EXT8) && len < 8) valid_ext_handler()
1286 if ((ops->flags & WIIMOD_FLAG_EXT16) && len < 16) valid_ext_handler()
1302 const struct wiimod_ops *ops; handler_ext() local
1342 ops = wiimod_ext_table[wdata->state.exttype]; handler_ext()
1343 if (is_mp && ops->in_mp) { handler_ext()
1344 ops->in_mp(wdata, payload); handler_ext()
1346 } else if (!is_mp && valid_ext_handler(ops, len)) { handler_ext()
1347 ops->in_ext(wdata, payload); handler_ext()
1352 ops = &wiimod_mp; handler_ext()
1353 if (is_mp && ops->in_mp) { handler_ext()
1354 ops->in_mp(wdata, payload); handler_ext()
1356 } else if (!is_mp && valid_ext_handler(ops, len)) { handler_ext()
1357 ops->in_ext(wdata, payload); handler_ext()
1364 ops = wiimod_table[*iter]; handler_ext()
1365 if (is_mp && ops->in_mp) { handler_ext()
1366 ops->in_mp(wdata, payload); handler_ext()
1368 } else if (!is_mp && valid_ext_handler(ops, len)) { handler_ext()
1369 ops->in_ext(wdata, payload); handler_ext()
1384 const struct wiimod_ops *ops; handler_ir() local
1386 ops = wiimod_ext_table[wdata->state.exttype]; handler_ir()
1387 if (ops->in_ir) { handler_ir()
1388 ops->in_ir(wdata, payload, packed, id); handler_ir()
1394 ops = wiimod_table[*iter]; handler_ir()
1395 if (ops->in_ir) { handler_ir()
1396 ops->in_ir(wdata, payload, packed, id); handler_ir()
/linux-4.4.14/sound/core/
H A Dhwdep.c59 if (hw->ops.llseek) snd_hwdep_llseek()
60 return hw->ops.llseek(hw, file, offset, orig); snd_hwdep_llseek()
68 if (hw->ops.read) snd_hwdep_read()
69 return hw->ops.read(hw, buf, count, offset); snd_hwdep_read()
77 if (hw->ops.write) snd_hwdep_write()
78 return hw->ops.write(hw, buf, count, offset); snd_hwdep_write()
115 if (!hw->ops.open) { snd_hwdep_open()
119 err = hw->ops.open(hw, file); snd_hwdep_open()
149 if (hw->ops.release) snd_hwdep_open()
150 hw->ops.release(hw, file); snd_hwdep_open()
167 if (hw->ops.release) snd_hwdep_release()
168 err = hw->ops.release(hw, file); snd_hwdep_release()
182 if (hw->ops.poll) snd_hwdep_poll()
183 return hw->ops.poll(hw, file, wait); snd_hwdep_poll()
208 if (! hw->ops.dsp_status) snd_hwdep_dsp_status()
212 if ((err = hw->ops.dsp_status(hw, &info)) < 0) snd_hwdep_dsp_status()
225 if (! hw->ops.dsp_load) snd_hwdep_dsp_load()
235 err = hw->ops.dsp_load(hw, &info); snd_hwdep_dsp_load()
257 if (hw->ops.ioctl) snd_hwdep_ioctl()
258 return hw->ops.ioctl(hw, file, cmd, arg); snd_hwdep_ioctl()
265 if (hw->ops.mmap) snd_hwdep_mmap()
266 return hw->ops.mmap(hw, file, vma); snd_hwdep_mmap()
360 * The callbacks (hwdep->ops) must be set on the returned instance
370 static struct snd_device_ops ops = { snd_hwdep_new() local
398 err = snd_device_new(card, SNDRV_DEV_HWDEP, hwdep, &ops); snd_hwdep_new()
/linux-4.4.14/drivers/usb/common/
H A Dulpi.c24 return ulpi->ops->read(ulpi->ops, addr); ulpi_read()
30 return ulpi->ops->write(ulpi->ops, addr, val); ulpi_write()
199 * @ops: ULPI register access
204 struct ulpi *ulpi_register_interface(struct device *dev, struct ulpi_ops *ops) ulpi_register_interface() argument
213 ulpi->ops = ops; ulpi_register_interface()
214 ops->dev = dev; ulpi_register_interface()
/linux-4.4.14/arch/powerpc/kernel/
H A Dio-workarounds.c119 if (bus && bus->ops && bus->ops->name) \
120 return bus->ops->name al; \
129 if (bus && bus->ops && bus->ops->name) { \
130 bus->ops->name al; \
185 void iowa_register_bus(struct pci_controller *phb, struct ppc_pci_io *ops, iowa_register_bus() argument
201 bus->ops = ops; iowa_register_bus()
/linux-4.4.14/drivers/video/fbdev/exynos/
H A Ds6e8ax0.c288 struct mipi_dsim_master_ops *ops = lcd_to_master_ops(lcd); s6e8ax0_panel_cond() local
304 ops->cmd_write(lcd_to_master(lcd), MIPI_DSI_DCS_LONG_WRITE, s6e8ax0_panel_cond()
308 ops->cmd_write(lcd_to_master(lcd), MIPI_DSI_DCS_LONG_WRITE, s6e8ax0_panel_cond()
314 struct mipi_dsim_master_ops *ops = lcd_to_master_ops(lcd); s6e8ax0_display_cond() local
319 ops->cmd_write(lcd_to_master(lcd), MIPI_DSI_DCS_LONG_WRITE, s6e8ax0_display_cond()
326 struct mipi_dsim_master_ops *ops = lcd_to_master_ops(lcd); s6e8ax0_gamma_cond() local
329 ops->cmd_write(lcd_to_master(lcd), MIPI_DSI_DCS_LONG_WRITE, s6e8ax0_gamma_cond()
336 struct mipi_dsim_master_ops *ops = lcd_to_master_ops(lcd); s6e8ax0_gamma_update() local
341 ops->cmd_write(lcd_to_master(lcd), s6e8ax0_gamma_update()
348 struct mipi_dsim_master_ops *ops = lcd_to_master_ops(lcd); s6e8ax0_etc_cond1() local
354 ops->cmd_write(lcd_to_master(lcd), MIPI_DSI_DCS_LONG_WRITE, s6e8ax0_etc_cond1()
360 struct mipi_dsim_master_ops *ops = lcd_to_master_ops(lcd); s6e8ax0_etc_cond2() local
366 ops->cmd_write(lcd_to_master(lcd), MIPI_DSI_DCS_LONG_WRITE, s6e8ax0_etc_cond2()
372 struct mipi_dsim_master_ops *ops = lcd_to_master_ops(lcd); s6e8ax0_etc_cond3() local
377 ops->cmd_write(lcd_to_master(lcd), MIPI_DSI_DCS_LONG_WRITE, s6e8ax0_etc_cond3()
383 struct mipi_dsim_master_ops *ops = lcd_to_master_ops(lcd); s6e8ax0_etc_cond4() local
388 ops->cmd_write(lcd_to_master(lcd), MIPI_DSI_DCS_LONG_WRITE, s6e8ax0_etc_cond4()
394 struct mipi_dsim_master_ops *ops = lcd_to_master_ops(lcd); s6e8ax0_etc_cond5() local
399 ops->cmd_write(lcd_to_master(lcd), MIPI_DSI_DCS_LONG_WRITE, s6e8ax0_etc_cond5()
404 struct mipi_dsim_master_ops *ops = lcd_to_master_ops(lcd); s6e8ax0_etc_cond6() local
409 ops->cmd_write(lcd_to_master(lcd), s6e8ax0_etc_cond6()
416 struct mipi_dsim_master_ops *ops = lcd_to_master_ops(lcd); s6e8ax0_etc_cond7() local
421 ops->cmd_write(lcd_to_master(lcd), MIPI_DSI_DCS_LONG_WRITE, s6e8ax0_etc_cond7()
427 struct mipi_dsim_master_ops *ops = lcd_to_master_ops(lcd); s6e8ax0_elvss_set() local
432 ops->cmd_write(lcd_to_master(lcd), MIPI_DSI_DCS_LONG_WRITE, s6e8ax0_elvss_set()
438 struct mipi_dsim_master_ops *ops = lcd_to_master_ops(lcd); s6e8ax0_elvss_nvm_set() local
445 ops->cmd_write(lcd_to_master(lcd), MIPI_DSI_DCS_LONG_WRITE, s6e8ax0_elvss_nvm_set()
451 struct mipi_dsim_master_ops *ops = lcd_to_master_ops(lcd); s6e8ax0_sleep_in() local
456 ops->cmd_write(lcd_to_master(lcd), s6e8ax0_sleep_in()
463 struct mipi_dsim_master_ops *ops = lcd_to_master_ops(lcd); s6e8ax0_sleep_out() local
468 ops->cmd_write(lcd_to_master(lcd), s6e8ax0_sleep_out()
475 struct mipi_dsim_master_ops *ops = lcd_to_master_ops(lcd); s6e8ax0_display_on() local
480 ops->cmd_write(lcd_to_master(lcd), s6e8ax0_display_on()
487 struct mipi_dsim_master_ops *ops = lcd_to_master_ops(lcd); s6e8ax0_display_off() local
492 ops->cmd_write(lcd_to_master(lcd), s6e8ax0_display_off()
499 struct mipi_dsim_master_ops *ops = lcd_to_master_ops(lcd); s6e8ax0_apply_level2_key() local
504 ops->cmd_write(lcd_to_master(lcd), MIPI_DSI_DCS_LONG_WRITE, s6e8ax0_apply_level2_key()
510 struct mipi_dsim_master_ops *ops = lcd_to_master_ops(lcd); s6e8ax0_acl_on() local
515 ops->cmd_write(lcd_to_master(lcd), s6e8ax0_acl_on()
522 struct mipi_dsim_master_ops *ops = lcd_to_master_ops(lcd); s6e8ax0_acl_off() local
527 ops->cmd_write(lcd_to_master(lcd), s6e8ax0_acl_off()
535 struct mipi_dsim_master_ops *ops = lcd_to_master_ops(lcd); s6e8ax0_acl_ctrl_set() local
573 ops->cmd_write(lcd_to_master(lcd), s6e8ax0_acl_ctrl_set()
580 ops->cmd_write(lcd_to_master(lcd), s6e8ax0_acl_ctrl_set()
587 ops->cmd_write(lcd_to_master(lcd), s6e8ax0_acl_ctrl_set()
607 struct mipi_dsim_master_ops *ops = lcd_to_master_ops(lcd); s6e8ax0_read_id() local
609 ret = ops->cmd_read(lcd_to_master(lcd), s6e8ax0_read_id()
646 struct mipi_dsim_master_ops *ops = lcd_to_master_ops(lcd); s6e8ax0_update_gamma_ctrl() local
648 ops->cmd_write(lcd_to_master(lcd), MIPI_DSI_DCS_LONG_WRITE, s6e8ax0_update_gamma_ctrl()
669 struct mipi_dsim_master_ops *ops = lcd_to_master_ops(lcd); s6e8ax0_set_power() local
678 if ((power == FB_BLANK_UNBLANK) && ops->set_blank_mode) { s6e8ax0_set_power()
682 ret = ops->set_blank_mode(lcd_to_master(lcd), power); s6e8ax0_set_power()
686 } else if ((power == FB_BLANK_POWERDOWN) && ops->set_early_blank_mode) { s6e8ax0_set_power()
690 ret = ops->set_early_blank_mode(lcd_to_master(lcd), s6e8ax0_set_power()
794 dev_err(lcd->dev, "failed to register lcd ops.\n"); s6e8ax0_probe()
801 dev_err(lcd->dev, "failed to register backlight ops.\n"); s6e8ax0_probe()

Completed in 6258 milliseconds

1234567891011>>