/linux-4.4.14/drivers/staging/sm750fb/ |
H A D | sm750_cursor.h | 5 void hw_cursor_enable(struct lynx_cursor *cursor); 6 void hw_cursor_disable(struct lynx_cursor *cursor); 7 void hw_cursor_setSize(struct lynx_cursor *cursor, 9 void hw_cursor_setPos(struct lynx_cursor *cursor, 11 void hw_cursor_setColor(struct lynx_cursor *cursor, 13 void hw_cursor_setData(struct lynx_cursor *cursor, 15 void hw_cursor_setData2(struct lynx_cursor *cursor,
|
H A D | sm750_cursor.c | 24 readl(cursor->mmio + (addr)) 27 writel((data), cursor->mmio + (addr)) 29 /* cursor control for voyager and 718/750*/ 61 void hw_cursor_enable(struct lynx_cursor *cursor) hw_cursor_enable() argument 65 reg = FIELD_VALUE(0, HWC_ADDRESS, ADDRESS, cursor->offset)| hw_cursor_enable() 70 void hw_cursor_disable(struct lynx_cursor *cursor) hw_cursor_disable() argument 75 void hw_cursor_setSize(struct lynx_cursor *cursor, hw_cursor_setSize() argument 78 cursor->w = w; hw_cursor_setSize() 79 cursor->h = h; hw_cursor_setSize() 81 void hw_cursor_setPos(struct lynx_cursor *cursor, hw_cursor_setPos() argument 90 void hw_cursor_setColor(struct lynx_cursor *cursor, hw_cursor_setColor() argument 97 void hw_cursor_setData(struct lynx_cursor *cursor, hw_cursor_setData() argument 106 pitch = cursor->w >> 3; hw_cursor_setData() 109 count = pitch * cursor->h; hw_cursor_setData() 112 offset = cursor->maxW * 2 / 8; hw_cursor_setData() 115 pstart = cursor->vstart; hw_cursor_setData() 120 hw_cursor_setData2(cursor,rop,pcol,pmsk); hw_cursor_setData() 161 void hw_cursor_setData2(struct lynx_cursor *cursor, hw_cursor_setData2() argument 170 pitch = cursor->w >> 3; hw_cursor_setData2() 173 count = pitch * cursor->h; hw_cursor_setData2() 176 offset = cursor->maxW * 2 / 8; hw_cursor_setData2() 179 pstart = cursor->vstart; hw_cursor_setData2()
|
H A D | sm750.h | 103 * 0: no hardware cursor 104 * 1: primary crtc hw cursor enabled, 105 * 2: secondary crtc hw cursor enabled 106 * 3: both ctrc hw cursor enabled 112 /* cursor width ,height and size */ 119 /* base virtual address and offset of cursor image */ 122 /* mmio addr of hw cursor */ 127 unsigned char __iomem *vCursor; /* virtual address of cursor */ 129 int oCursor; /* cursor address offset in vidmem */ 142 /* cursor information */ 143 struct lynx_cursor cursor; member in struct:lynxfb_crtc
|
H A D | sm750.c | 108 /* no hardware cursor supported under version 2.6.10, kernel bug */ lynxfb_ops_cursor() 113 struct lynx_cursor *cursor; lynxfb_ops_cursor() local 117 cursor = &crtc->cursor; lynxfb_ops_cursor() 119 if (fbcursor->image.width > cursor->maxW || lynxfb_ops_cursor() 120 fbcursor->image.height > cursor->maxH || lynxfb_ops_cursor() 125 hw_cursor_disable(cursor); lynxfb_ops_cursor() 127 hw_cursor_setSize(cursor, lynxfb_ops_cursor() 132 hw_cursor_setPos(cursor, lynxfb_ops_cursor() 148 hw_cursor_setColor(cursor, fg, bg); lynxfb_ops_cursor() 152 hw_cursor_setData(cursor, lynxfb_ops_cursor() 159 hw_cursor_enable(cursor); lynxfb_ops_cursor() 449 struct lynx_cursor *cursor; lynxfb_resume() local 481 cursor = &crtc->cursor; lynxfb_resume() 482 memset_io(cursor->vstart, 0x0, cursor->size); lynxfb_resume() 493 cursor = &crtc->cursor; lynxfb_resume() 494 memset_io(cursor->vstart, 0x0, cursor->size); lynxfb_resume() 728 /* cursor */ 773 * set current cursor variable and proc pointer, lynxfb_set_fbinfo() 776 crtc->cursor.offset = crtc->oScreen + crtc->vidmem_size - 1024; lynxfb_set_fbinfo() 777 crtc->cursor.mmio = sm750_dev->pvReg + lynxfb_set_fbinfo() 780 pr_info("crtc->cursor.mmio = %p\n", crtc->cursor.mmio); lynxfb_set_fbinfo() 781 crtc->cursor.maxH = crtc->cursor.maxW = 64; lynxfb_set_fbinfo() 782 crtc->cursor.size = crtc->cursor.maxH * crtc->cursor.maxW * 2 / 8; lynxfb_set_fbinfo() 783 crtc->cursor.vstart = sm750_dev->pvMem + crtc->cursor.offset; lynxfb_set_fbinfo() 785 memset_io(crtc->cursor.vstart, 0, crtc->cursor.size); lynxfb_set_fbinfo() 788 hw_cursor_disable(&crtc->cursor); lynxfb_set_fbinfo() 1270 "\t\tnohwc:disable hardware cursor\n"
|
/linux-4.4.14/drivers/gpu/drm/sti/ |
H A D | sti_cursor.c | 53 * @regs: cursor registers 54 * @width: cursor width 55 * @height: cursor height 58 * @pixmap: pixmap dma buffer (clut8-format cursor) 77 static void sti_cursor_argb8888_to_clut8(struct sti_cursor *cursor, u32 *src) sti_cursor_argb8888_to_clut8() argument 79 u8 *dst = cursor->pixmap.base; sti_cursor_argb8888_to_clut8() 83 for (i = 0; i < cursor->height; i++) { sti_cursor_argb8888_to_clut8() 84 for (j = 0; j < cursor->width; j++) { sti_cursor_argb8888_to_clut8() 97 static void sti_cursor_init(struct sti_cursor *cursor) sti_cursor_init() argument 99 unsigned short *base = cursor->clut; sti_cursor_init() 118 struct sti_cursor *cursor = to_sti_cursor(plane); sti_cursor_atomic_update() local 140 dev_dbg(cursor->dev, "%s %s\n", __func__, sti_cursor_atomic_update() 147 DRM_ERROR("Invalid cursor size (%dx%d)\n", sti_cursor_atomic_update() 152 /* If the cursor size has changed, re-allocated the pixmap */ sti_cursor_atomic_update() 153 if (!cursor->pixmap.base || sti_cursor_atomic_update() 154 (cursor->width != src_w) || sti_cursor_atomic_update() 155 (cursor->height != src_h)) { sti_cursor_atomic_update() 156 cursor->width = src_w; sti_cursor_atomic_update() 157 cursor->height = src_h; sti_cursor_atomic_update() 159 if (cursor->pixmap.base) sti_cursor_atomic_update() 160 dma_free_writecombine(cursor->dev, sti_cursor_atomic_update() 161 cursor->pixmap.size, sti_cursor_atomic_update() 162 cursor->pixmap.base, sti_cursor_atomic_update() 163 cursor->pixmap.paddr); sti_cursor_atomic_update() 165 cursor->pixmap.size = cursor->width * cursor->height; sti_cursor_atomic_update() 167 cursor->pixmap.base = dma_alloc_writecombine(cursor->dev, sti_cursor_atomic_update() 168 cursor->pixmap.size, sti_cursor_atomic_update() 169 &cursor->pixmap.paddr, sti_cursor_atomic_update() 171 if (!cursor->pixmap.base) { sti_cursor_atomic_update() 184 sti_cursor_argb8888_to_clut8(cursor, (u32 *)cma_obj->vaddr); sti_cursor_atomic_update() 190 writel(val, cursor->regs + CUR_AWS); sti_cursor_atomic_update() 194 writel(val, cursor->regs + CUR_AWE); sti_cursor_atomic_update() 198 writel(cursor->clut_paddr, cursor->regs + CUR_CML); sti_cursor_atomic_update() 199 writel(CUR_CTL_CLUT_UPDATE, cursor->regs + CUR_CTL); sti_cursor_atomic_update() 203 writel(cursor->pixmap.paddr, cursor->regs + CUR_PML); sti_cursor_atomic_update() 204 writel(cursor->width, cursor->regs + CUR_PMP); sti_cursor_atomic_update() 205 writel(cursor->height << 16 | cursor->width, cursor->regs + CUR_SIZE); sti_cursor_atomic_update() 209 writel((y << 16) | x, cursor->regs + CUR_VPO); sti_cursor_atomic_update() 243 struct sti_cursor *cursor; sti_cursor_create() local 247 cursor = devm_kzalloc(dev, sizeof(*cursor), GFP_KERNEL); sti_cursor_create() 248 if (!cursor) { sti_cursor_create() 249 DRM_ERROR("Failed to allocate memory for cursor\n"); sti_cursor_create() 255 cursor->clut = dma_alloc_writecombine(dev, size, &cursor->clut_paddr, sti_cursor_create() 258 if (!cursor->clut) { sti_cursor_create() 259 DRM_ERROR("Failed to allocate memory for cursor clut\n"); sti_cursor_create() 263 cursor->dev = dev; sti_cursor_create() 264 cursor->regs = baseaddr; sti_cursor_create() 265 cursor->plane.desc = desc; sti_cursor_create() 266 cursor->plane.status = STI_PLANE_DISABLED; sti_cursor_create() 268 sti_cursor_init(cursor); sti_cursor_create() 270 res = drm_universal_plane_init(drm_dev, &cursor->plane.drm_plane, sti_cursor_create() 281 drm_plane_helper_add(&cursor->plane.drm_plane, sti_cursor_create() 284 sti_plane_init_property(&cursor->plane, DRM_PLANE_TYPE_CURSOR); sti_cursor_create() 286 return &cursor->plane.drm_plane; sti_cursor_create() 289 dma_free_writecombine(dev, size, cursor->clut, cursor->clut_paddr); sti_cursor_create() 291 devm_kfree(dev, cursor); sti_cursor_create()
|
H A D | sti_crtc.h | 15 struct drm_plane *primary, struct drm_plane *cursor);
|
H A D | sti_compositor.c | 66 struct drm_plane *cursor = NULL; sti_compositor_bind() local 111 cursor = sti_cursor_create(drm_dev, compo->dev, sti_compositor_bind() 115 if (!cursor) { sti_compositor_bind() 139 primary, cursor); sti_compositor_bind() 141 cursor = NULL; sti_compositor_bind()
|
H A D | sti_crtc.c | 364 struct drm_plane *primary, struct drm_plane *cursor) sti_crtc_init() 369 res = drm_crtc_init_with_planes(drm_dev, crtc, primary, cursor, sti_crtc_init() 363 sti_crtc_init(struct drm_device *drm_dev, struct sti_mixer *mixer, struct drm_plane *primary, struct drm_plane *cursor) sti_crtc_init() argument
|
H A D | sti_mixer.c | 133 /* no need to set depth for cursor */ sti_mixer_set_plane_depth()
|
/linux-4.4.14/drivers/video/fbdev/aty/ |
H A D | mach64_cursor.c | 20 * The hardware cursor definition requires 2 bits per pixel. The 21 * Cursor size reguardless of the visible cursor size is 64 pixels 22 * by 64 lines. The total memory required to define the cursor is 24 * must be in a contigiuos format. The 2 bit cursor code values are 46 * cursor is specificed by CURS_HORZ_VERT_POSN. Care must be taken 47 * when the cursor hot spot is not the top left corner and the 48 * physical cursor position becomes negative. It will be be displayed 49 * if either the horizontal or vertical cursor position is negative 51 * If x becomes negative the cursor manager must adjust the CURS_HORZ_OFFSET 55 * CUR_OFFSET must be adjusted to a point to the appropriate line in the cursor 67 static int atyfb_cursor(struct fb_info *info, struct fb_cursor *cursor) atyfb_cursor() argument 81 if (cursor->enable) atyfb_cursor() 89 if (cursor->set & FB_CUR_SETPOS) { atyfb_cursor() 90 x = cursor->image.dx - cursor->hot.x - info->var.xoffset; atyfb_cursor() 98 y = cursor->image.dy - cursor->hot.y - info->var.yoffset; atyfb_cursor() 106 h = cursor->image.height; atyfb_cursor() 109 * In doublescan mode, the cursor location atyfb_cursor() 124 if (cursor->set & FB_CUR_SETCMAP) { atyfb_cursor() 127 fg_idx = cursor->image.fg_color; atyfb_cursor() 128 bg_idx = cursor->image.bg_color; atyfb_cursor() 143 if (cursor->set & (FB_CUR_SETSHAPE | FB_CUR_SETIMAGE)) { atyfb_cursor() 144 u8 *src = (u8 *)cursor->image.data; atyfb_cursor() 145 u8 *msk = (u8 *)cursor->mask; atyfb_cursor() 147 unsigned int width = (cursor->image.width + 7) >> 3; atyfb_cursor() 148 unsigned int height = cursor->image.height; atyfb_cursor() 154 // Clear cursor image with 1010101010... atyfb_cursor() 164 switch (cursor->rop) { atyfb_cursor() 179 * If cursor size is not a multiple of 8 characters atyfb_cursor() 182 if ((j + 1) * 8 > cursor->image.width) { atyfb_cursor() 184 (1 << ((cursor->image.width & 7) * 2)) - 1); atyfb_cursor()
|
H A D | atyfb.h | 337 * Hardware cursor support
|
/linux-4.4.14/drivers/video/console/ |
H A D | softcursor.c | 4 * Generic software cursor for frame buffer devices 22 int soft_cursor(struct fb_info *info, struct fb_cursor *cursor) soft_cursor() argument 34 s_pitch = (cursor->image.width + 7) >> 3; soft_cursor() 35 dsize = s_pitch * cursor->image.height; soft_cursor() 50 *image = cursor->image; soft_cursor() 57 if (cursor->enable) { soft_cursor() 58 switch (cursor->rop) { soft_cursor() 61 src[i] = image->data[i] ^ cursor->mask[i]; soft_cursor() 66 src[i] = image->data[i] & cursor->mask[i]; soft_cursor() 81 MODULE_DESCRIPTION("Generic software cursor");
|
H A D | tileblit.c | 85 struct fb_tilecursor cursor; tile_cursor() local 88 cursor.sx = vc->vc_x; tile_cursor() 89 cursor.sy = vc->vc_y; tile_cursor() 90 cursor.mode = (mode == CM_ERASE || use_sw) ? 0 : 1; tile_cursor() 91 cursor.fg = fg; tile_cursor() 92 cursor.bg = bg; tile_cursor() 96 cursor.shape = FB_TILE_CURSOR_NONE; tile_cursor() 99 cursor.shape = FB_TILE_CURSOR_UNDERLINE; tile_cursor() 102 cursor.shape = FB_TILE_CURSOR_LOWER_THIRD; tile_cursor() 105 cursor.shape = FB_TILE_CURSOR_LOWER_HALF; tile_cursor() 108 cursor.shape = FB_TILE_CURSOR_TWO_THIRDS; tile_cursor() 112 cursor.shape = FB_TILE_CURSOR_BLOCK; tile_cursor() 116 info->tileops->fb_tilecursor(info, &cursor); tile_cursor() 140 ops->cursor = tile_cursor; fbcon_set_tileops()
|
H A D | bitblit.c | 239 struct fb_cursor cursor; bit_cursor() local 248 cursor.set = 0; bit_cursor() 266 cursor.set |= FB_CUR_SETIMAGE; bit_cursor() 286 cursor.set |= FB_CUR_SETCMAP; bit_cursor() 294 cursor.set |= FB_CUR_SETPOS; bit_cursor() 302 cursor.set |= FB_CUR_SETSIZE; bit_cursor() 307 ops->cursor_state.hot.x = cursor.hot.y = 0; bit_cursor() 308 cursor.set |= FB_CUR_SETHOT; bit_cursor() 311 if (cursor.set & FB_CUR_SETSIZE || bit_cursor() 326 cursor.set |= FB_CUR_SETSHAPE; bit_cursor() 368 cursor.image.data = src; 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() 379 cursor.image.depth = 1; bit_cursor() 380 cursor.rop = ROP_XOR; bit_cursor() 383 err = info->fbops->fb_cursor(info, &cursor); bit_cursor() 386 soft_cursor(info, &cursor); bit_cursor() 409 ops->cursor = bit_cursor; fbcon_set_bitops()
|
H A D | fbcon_ccw.c | 224 struct fb_cursor cursor; ccw_cursor() local 237 cursor.set = 0; ccw_cursor() 255 cursor.set |= FB_CUR_SETIMAGE; ccw_cursor() 275 cursor.set |= FB_CUR_SETCMAP; ccw_cursor() 283 cursor.set |= FB_CUR_SETSIZE; ccw_cursor() 294 cursor.set |= FB_CUR_SETPOS; ccw_cursor() 299 ops->cursor_state.hot.x = cursor.hot.y = 0; ccw_cursor() 300 cursor.set |= FB_CUR_SETHOT; ccw_cursor() 303 if (cursor.set & FB_CUR_SETSIZE || ccw_cursor() 325 cursor.set |= FB_CUR_SETSHAPE; ccw_cursor() 371 cursor.image.data = src; 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() 382 cursor.image.depth = 1; ccw_cursor() 383 cursor.rop = ROP_XOR; ccw_cursor() 386 err = info->fbops->fb_cursor(info, &cursor); ccw_cursor() 389 soft_cursor(info, &cursor); ccw_cursor() 417 ops->cursor = ccw_cursor; fbcon_rotate_ccw()
|
H A D | fbcon_cw.c | 207 struct fb_cursor cursor; cw_cursor() local 220 cursor.set = 0; cw_cursor() 238 cursor.set |= FB_CUR_SETIMAGE; cw_cursor() 258 cursor.set |= FB_CUR_SETCMAP; cw_cursor() 266 cursor.set |= FB_CUR_SETSIZE; cw_cursor() 277 cursor.set |= FB_CUR_SETPOS; cw_cursor() 282 ops->cursor_state.hot.x = cursor.hot.y = 0; cw_cursor() 283 cursor.set |= FB_CUR_SETHOT; cw_cursor() 286 if (cursor.set & FB_CUR_SETSIZE || cw_cursor() 308 cursor.set |= FB_CUR_SETSHAPE; cw_cursor() 354 cursor.image.data = src; 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() 365 cursor.image.depth = 1; cw_cursor() 366 cursor.rop = ROP_XOR; cw_cursor() 369 err = info->fbops->fb_cursor(info, &cursor); cw_cursor() 372 soft_cursor(info, &cursor); cw_cursor() 400 ops->cursor = cw_cursor; fbcon_rotate_cw()
|
H A D | fbcon_ud.c | 254 struct fb_cursor cursor; ud_cursor() local 268 cursor.set = 0; ud_cursor() 286 cursor.set |= FB_CUR_SETIMAGE; ud_cursor() 306 cursor.set |= FB_CUR_SETCMAP; ud_cursor() 314 cursor.set |= FB_CUR_SETSIZE; ud_cursor() 325 cursor.set |= FB_CUR_SETPOS; ud_cursor() 330 ops->cursor_state.hot.x = cursor.hot.y = 0; ud_cursor() 331 cursor.set |= FB_CUR_SETHOT; ud_cursor() 334 if (cursor.set & FB_CUR_SETSIZE || ud_cursor() 349 cursor.set |= FB_CUR_SETSHAPE; ud_cursor() 395 cursor.image.data = src; 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() 406 cursor.image.depth = 1; ud_cursor() 407 cursor.rop = ROP_XOR; ud_cursor() 410 err = info->fbops->fb_cursor(info, &cursor); ud_cursor() 413 soft_cursor(info, &cursor); ud_cursor() 445 ops->cursor = ud_cursor; fbcon_rotate_ud()
|
H A D | mdacon.c | 165 write_mda_b(MDA_CURSOR_OFF, 0x0a); /* disable cursor */ mda_set_cursor_size() 167 write_mda_b(from, 0x0a); /* cursor start */ mda_set_cursor_size() 168 write_mda_b(to, 0x0b); /* cursor end */ mda_set_cursor_size() 240 /* Edward: These two mess `tests' mess up my cursor on bootup */ mda_detect() 242 /* cursor low register */ mda_detect() 247 /* cursor low register */ mda_detect() 299 write_mda_b(12, 0x0a); /* cursor start */ mda_initialize() 300 write_mda_b(13, 0x0b); /* cursor end */ mda_initialize() 303 write_mda_w(0x0000, 0x0e); /* cursor location */ mda_initialize() 336 /* cursor looks ugly during boot-up, so turn it off */ mdacon_startup()
|
H A D | fbcon.h | 64 void (*cursor)(struct vc_data *vc, struct fb_info *info, int mode, member in struct:fbcon_ops 221 extern int soft_cursor(struct fb_info *info, struct fb_cursor *cursor);
|
H A D | sticon.c | 64 /* software cursor */
|
/linux-4.4.14/drivers/gpu/drm/mgag200/ |
H A D | mgag200_cursor.c | 18 Hide the cursor off screen. We can't disable the cursor hardware because it 25 if (mdev->cursor.pixels_1->pin_count) mga_hide_cursor() 26 mgag200_bo_unpin(mdev->cursor.pixels_1); mga_hide_cursor() 27 if (mdev->cursor.pixels_2->pin_count) mga_hide_cursor() 28 mgag200_bo_unpin(mdev->cursor.pixels_2); mga_hide_cursor() 39 struct mgag200_bo *pixels_1 = mdev->cursor.pixels_1; mga_crtc_cursor_set() 40 struct mgag200_bo *pixels_2 = mdev->cursor.pixels_2; mga_crtc_cursor_set() 41 struct mgag200_bo *pixels_current = mdev->cursor.pixels_current; mga_crtc_cursor_set() 42 struct mgag200_bo *pixels_prev = mdev->cursor.pixels_prev; mga_crtc_cursor_set() 96 /* Move cursor buffers into VRAM if they aren't already */ mga_crtc_cursor_set() 99 &mdev->cursor.pixels_1_gpu_addr); mga_crtc_cursor_set() 105 &mdev->cursor.pixels_2_gpu_addr); mga_crtc_cursor_set() 135 dev_info(&dev->pdev->dev, "Not enabling hardware cursor.\n"); mga_crtc_cursor_set() 157 dev_info(&dev->pdev->dev, "Not enabling hardware cursor.\n"); mga_crtc_cursor_set() 168 /* Program colours from cursor icon into palette */ mga_crtc_cursor_set() 186 dev_err(&dev->pdev->dev, "failed to kmap cursor updates\n"); mga_crtc_cursor_set() 191 /* now write colour indices into hardware cursor buffer */ mga_crtc_cursor_set() 216 /* Program gpu address of cursor buffer */ mga_crtc_cursor_set() 218 gpu_addr = mdev->cursor.pixels_1_gpu_addr; mga_crtc_cursor_set() 220 gpu_addr = mdev->cursor.pixels_2_gpu_addr; mga_crtc_cursor_set() 224 /* Adjust cursor control register to turn on the cursor */ mga_crtc_cursor_set() 225 WREG_DAC(MGA1064_CURSOR_CTL, 4); /* 16-colour palletized cursor mode */ mga_crtc_cursor_set() 228 if (mdev->cursor.pixels_1 == mdev->cursor.pixels_prev) { mga_crtc_cursor_set() 229 mdev->cursor.pixels_prev = mdev->cursor.pixels_2; mga_crtc_cursor_set() 230 mdev->cursor.pixels_current = mdev->cursor.pixels_1; mga_crtc_cursor_set() 231 } else if (mdev->cursor.pixels_1 == mdev->cursor.pixels_current) { mga_crtc_cursor_set() 232 mdev->cursor.pixels_prev = mdev->cursor.pixels_1; mga_crtc_cursor_set() 233 mdev->cursor.pixels_current = mdev->cursor.pixels_2; mga_crtc_cursor_set()
|
H A D | mgag200_main.c | 239 /* Make small buffers to store a hardware cursor (double buffered icon updates) */ mgag200_driver_load() 241 &mdev->cursor.pixels_1); mgag200_driver_load() 243 &mdev->cursor.pixels_2); mgag200_driver_load() 244 if (!mdev->cursor.pixels_2 || !mdev->cursor.pixels_1) { mgag200_driver_load() 245 mdev->cursor.pixels_1 = NULL; mgag200_driver_load() 246 mdev->cursor.pixels_2 = NULL; mgag200_driver_load() 250 mdev->cursor.pixels_current = mdev->cursor.pixels_1; mgag200_driver_load() 251 mdev->cursor.pixels_prev = mdev->cursor.pixels_2; mgag200_driver_load()
|
H A D | mgag200_drv.h | 156 We have to have 2 buffers for the cursor to avoid occasional 157 corruption while switching cursor icons. 200 struct mga_cursor cursor; member in struct:mga_device
|
/linux-4.4.14/tools/perf/util/ |
H A D | callchain.h | 109 * A callchain cursor is a single linked list that 149 struct callchain_cursor *cursor, 152 int callchain_merge(struct callchain_cursor *cursor, 156 * Initialize a cursor before adding entries inside, but keep 159 static inline void callchain_cursor_reset(struct callchain_cursor *cursor) callchain_cursor_reset() argument 161 cursor->nr = 0; callchain_cursor_reset() 162 cursor->last = &cursor->first; callchain_cursor_reset() 165 int callchain_cursor_append(struct callchain_cursor *cursor, u64 ip, 168 /* Close a cursor writing session. Initialize for the reader */ callchain_cursor_commit() 169 static inline void callchain_cursor_commit(struct callchain_cursor *cursor) callchain_cursor_commit() argument 171 cursor->curr = cursor->first; callchain_cursor_commit() 172 cursor->pos = 0; callchain_cursor_commit() 177 callchain_cursor_current(struct callchain_cursor *cursor) callchain_cursor_current() argument 179 if (cursor->pos == cursor->nr) callchain_cursor_current() 182 return cursor->curr; callchain_cursor_current() 185 static inline void callchain_cursor_advance(struct callchain_cursor *cursor) callchain_cursor_advance() argument 187 cursor->curr = cursor->curr->next; callchain_cursor_advance() 188 cursor->pos++; callchain_cursor_advance()
|
H A D | callchain.c | 394 fill_node(struct callchain_node *node, struct callchain_cursor *cursor) fill_node() argument 398 node->val_nr = cursor->nr - cursor->pos; fill_node() 402 cursor_node = callchain_cursor_current(cursor); fill_node() 417 callchain_cursor_advance(cursor); fill_node() 418 cursor_node = callchain_cursor_current(cursor); fill_node() 424 struct callchain_cursor *cursor, add_child() 430 fill_node(new, cursor); add_child() 456 struct callchain_cursor *cursor, split_add_child() 483 if (idx_total < cursor->nr) { split_add_child() 492 node = callchain_cursor_current(cursor); split_add_child() 493 new = add_child(parent, cursor, period); split_add_child() 518 struct callchain_cursor *cursor, 523 struct callchain_cursor *cursor, append_chain_children() 531 node = callchain_cursor_current(cursor); append_chain_children() 543 ret = append_chain(rnode, cursor, period); append_chain_children() 553 rnode = add_child(root, cursor, period); append_chain_children() 563 struct callchain_cursor *cursor, append_chain() 567 u64 start = cursor->pos; append_chain() 581 node = callchain_cursor_current(cursor); append_chain() 591 callchain_cursor_advance(cursor); append_chain() 600 matches = cursor->pos - start; append_chain() 604 split_add_child(root, cursor, cnode, start, matches, period); append_chain() 609 if (matches == root->val_nr && cursor->pos == cursor->nr) { append_chain() 615 append_chain_children(root, cursor, period); append_chain() 621 struct callchain_cursor *cursor, callchain_append() 624 if (!cursor->nr) callchain_append() 627 callchain_cursor_commit(cursor); callchain_append() 629 append_chain_children(&root->node, cursor, period); callchain_append() 631 if (cursor->nr > root->max_depth) callchain_append() 632 root->max_depth = cursor->nr; callchain_append() 638 merge_chain_branch(struct callchain_cursor *cursor, merge_chain_branch() argument 641 struct callchain_cursor_node **old_last = cursor->last; merge_chain_branch() 645 int old_pos = cursor->nr; merge_chain_branch() 649 callchain_cursor_append(cursor, list->ip, merge_chain_branch() 656 callchain_cursor_commit(cursor); merge_chain_branch() 657 append_chain_children(dst, cursor, src->hit); merge_chain_branch() 666 err = merge_chain_branch(cursor, dst, child); merge_chain_branch() 673 cursor->nr = old_pos; merge_chain_branch() 674 cursor->last = old_last; merge_chain_branch() 679 int callchain_merge(struct callchain_cursor *cursor, callchain_merge() argument 682 return merge_chain_branch(cursor, &dst->node, &src->node); callchain_merge() 685 int callchain_cursor_append(struct callchain_cursor *cursor, callchain_cursor_append() argument 688 struct callchain_cursor_node *node = *cursor->last; callchain_cursor_append() 695 *cursor->last = node; callchain_cursor_append() 702 cursor->nr++; callchain_cursor_append() 704 cursor->last = &node->next; callchain_cursor_append() 423 add_child(struct callchain_node *parent, struct callchain_cursor *cursor, u64 period) add_child() argument 455 split_add_child(struct callchain_node *parent, struct callchain_cursor *cursor, struct callchain_list *to_split, u64 idx_parents, u64 idx_local, u64 period) split_add_child() argument 522 append_chain_children(struct callchain_node *root, struct callchain_cursor *cursor, u64 period) append_chain_children() argument 562 append_chain(struct callchain_node *root, struct callchain_cursor *cursor, u64 period) append_chain() argument 620 callchain_append(struct callchain_root *root, struct callchain_cursor *cursor, u64 period) callchain_append() argument
|
H A D | intlist.h | 61 * @pos: the &struct int_node to use as a loop cursor. 70 * @pos: the &struct int_node to use as a loop cursor.
|
H A D | strlist.h | 66 * @pos: the &struct str_node to use as a loop cursor. 75 * @pos: the &struct str_node to use as a loop cursor.
|
H A D | map.h | 117 * @pos: the 'struct symbol *' to use as a loop cursor 129 * @pos: the 'struct symbol *' to use as a loop cursor
|
H A D | hist.c | 756 * We need to re-initialize the cursor since callchain_append() iter_add_single_cumulative_entry() 757 * advanced the cursor to the end. iter_add_single_cumulative_entry() 800 struct callchain_cursor cursor; iter_add_next_cumulative_entry() local 802 callchain_cursor_snapshot(&cursor, &callchain_cursor); iter_add_next_cumulative_entry() 828 callchain_append(he->callchain, &cursor, sample->period); iter_add_next_cumulative_entry()
|
/linux-4.4.14/fs/xfs/ |
H A D | xfs_attr_list.c | 58 #define XFS_ISRESET_CURSOR(cursor) \ 59 (!((cursor)->initted) && !((cursor)->hashval) && \ 60 !((cursor)->blkno) && !((cursor)->offset)) 71 attrlist_cursor_kern_t *cursor; xfs_attr_shortform_list() local 87 cursor = context->cursor; xfs_attr_shortform_list() 88 ASSERT(cursor != NULL); xfs_attr_shortform_list() 93 * If the buffer is large enough and the cursor is at the start, xfs_attr_shortform_list() 95 * one buffer and another call using the cursor won't need to be xfs_attr_shortform_list() 102 (XFS_ISRESET_CURSOR(cursor) && xfs_attr_shortform_list() 174 cursor->initted = 1; xfs_attr_shortform_list() 175 cursor->blkno = 0; xfs_attr_shortform_list() 177 if (sbp->hash == cursor->hashval) { xfs_attr_shortform_list() 178 if (cursor->offset == count) { xfs_attr_shortform_list() 182 } else if (sbp->hash > cursor->hashval) { xfs_attr_shortform_list() 195 if (cursor->hashval != sbp->hash) { xfs_attr_shortform_list() 196 cursor->hashval = sbp->hash; xfs_attr_shortform_list() 197 cursor->offset = 0; xfs_attr_shortform_list() 211 cursor->offset++; xfs_attr_shortform_list() 221 attrlist_cursor_kern_t *cursor; xfs_attr_node_list() local 234 cursor = context->cursor; xfs_attr_node_list() 235 cursor->initted = 1; xfs_attr_node_list() 238 * Do all sorts of validation on the passed-in cursor structure. xfs_attr_node_list() 239 * If anything is amiss, ignore the cursor and look up the hashval xfs_attr_node_list() 243 if (cursor->blkno > 0) { xfs_attr_node_list() 244 error = xfs_da3_node_read(NULL, dp, cursor->blkno, -1, xfs_attr_node_list() 265 if (cursor->hashval > be32_to_cpu( xfs_attr_node_list() 270 } else if (cursor->hashval <= be32_to_cpu( xfs_attr_node_list() 286 * We did not find what we expected given the cursor's contents, xfs_attr_node_list() 291 cursor->blkno = 0; xfs_attr_node_list() 296 cursor->blkno, -1, &bp, xfs_attr_node_list() 318 if (cursor->hashval xfs_attr_node_list() 320 cursor->blkno = be32_to_cpu(btree->before); xfs_attr_node_list() 350 cursor->blkno = leafhdr.forw; xfs_attr_node_list() 352 error = xfs_attr3_leaf_read(NULL, dp, cursor->blkno, -1, &bp); xfs_attr_node_list() 368 struct attrlist_cursor_kern *cursor; xfs_attr3_leaf_list_int() local 383 cursor = context->cursor; xfs_attr3_leaf_list_int() 384 cursor->initted = 1; xfs_attr3_leaf_list_int() 392 if (be32_to_cpu(entry->hashval) == cursor->hashval) { xfs_attr3_leaf_list_int() 393 if (cursor->offset == context->dupcnt) { xfs_attr3_leaf_list_int() 399 cursor->hashval) { xfs_attr3_leaf_list_int() 419 if (be32_to_cpu(entry->hashval) != cursor->hashval) { xfs_attr3_leaf_list_int() 420 cursor->hashval = be32_to_cpu(entry->hashval); xfs_attr3_leaf_list_int() 421 cursor->offset = 0; xfs_attr3_leaf_list_int() 480 cursor->offset++; xfs_attr3_leaf_list_int() 497 context->cursor->blkno = 0; xfs_attr_leaf_list() 610 attrlist_cursor_kern_t *cursor) xfs_attr_list() 617 * Validate the cursor. xfs_attr_list() 619 if (cursor->pad1 || cursor->pad2) xfs_attr_list() 621 if ((cursor->initted == 0) && xfs_attr_list() 622 (cursor->hashval || cursor->blkno || cursor->offset)) xfs_attr_list() 638 context.cursor = cursor; xfs_attr_list() 605 xfs_attr_list( xfs_inode_t *dp, char *buffer, int bufsize, int flags, attrlist_cursor_kern_t *cursor) xfs_attr_list() argument
|
H A D | xfs_trans_priv.h | 39 * AIL traversal cursor. 42 * a cursor that is protected by the ail lock. The aild cursor exists in the 46 * When an object is deleted from or moved int the AIL, the cursor list is 47 * searched to see if the object is a designated cursor item. If it is, it is 48 * deleted from the cursor so that the next time the cursor is used traversal 53 * low bit of the item pointer is set if the cursor has been invalidated so
|
H A D | xfs_attr.h | 98 * Kernel-internal version of the attrlist cursor. 106 __u8 initted; /* T/F: cursor has been initialized */ 120 struct attrlist_cursor_kern *cursor; /* position in list */ member in struct:xfs_attr_list_context 128 int resynch; /* T/F: resynch with cursor */ 151 int flags, struct attrlist_cursor_kern *cursor);
|
H A D | xfs_trans_ail.c | 136 * The cursor keeps track of where our current traversal is up to by tracking 138 * object from the AIL needs to invalidate any cursor that points to it. hence 139 * the traversal cursor needs to be linked to the struct xfs_ail so that 152 * Get the next item in the traversal and advance the cursor. If the cursor 170 * When the traversal is complete, we need to remove the cursor from the list 182 * Invalidate any cursor that is pointing to this item. This is called when an 183 * item is removed from the AIL. Any cursor pointing to this object is now 185 * freed object. We set the low bit of the cursor item pointer so we can 187 * next item from the cursor. 205 * LSN order and initialise the cursor to point to the next item for a 206 * ascending traversal. Pass a @lsn of zero to initialise the cursor to the 252 * LSN order and initialise the cursor to point to that item. If there is no 253 * item with the value of @lsn, then it sets the cursor to the last item with an 270 * cursor is optional, allowing repeated updates to the same LSN to avoid 285 * Use the cursor to determine the insertion point if one is xfs_ail_splice() 294 * If a cursor is provided, we know we're processing the AIL xfs_ail_splice() 297 * cursor to point to that last item, now while we have a xfs_ail_splice() 382 * rely on the AIL cursor implementation to be able to deal with xfsaild_push()
|
H A D | xfs_xattr.c | 228 struct attrlist_cursor_kern cursor = { 0 }; xfs_vn_listxattr() local 237 context.cursor = &cursor; xfs_vn_listxattr()
|
H A D | xfs_ioctl32.c | 348 attrlist_cursor_kern_t *cursor; xfs_compat_attrlist_by_handle() local 377 cursor = (attrlist_cursor_kern_t *)&al_hreq.pos; xfs_compat_attrlist_by_handle() 379 al_hreq.flags, cursor); xfs_compat_attrlist_by_handle()
|
H A D | xfs_itable.c | 210 struct xfs_btree_cur *cur, /* btree cursor */ xfs_bulkstat_grab_ichunk() 327 * substract that inode when setting the *last_agino cursor so that we xfs_bulkstat_ag_ichunk() 353 xfs_btree_cur_t *cur; /* btree cursor for ialloc btree */ xfs_bulkstat() 402 * Allocate and initialize a btree cursor for ialloc btree. xfs_bulkstat()
|
H A D | xfs_trace.h | 61 __entry->hashval = ctx->cursor->hashval; 62 __entry->blkno = ctx->cursor->blkno; 63 __entry->offset = ctx->cursor->offset; 70 TP_printk("dev %d:%d ino 0x%llx cursor h/b/o 0x%x/0x%x/%u dupcnt %u " 185 __entry->hashval = ctx->cursor->hashval; 186 __entry->blkno = ctx->cursor->blkno; 187 __entry->offset = ctx->cursor->offset; 196 TP_printk("dev %d:%d ino 0x%llx cursor h/b/o 0x%x/0x%x/%u dupcnt %u "
|
/linux-4.4.14/scripts/ |
H A D | asn1_compiler.c | 810 struct token *cursor; parse() local 816 cursor = type->name; parse() 818 if (cursor[0].token_type != TOKEN_TYPE_NAME || parse() 819 cursor[1].token_type != TOKEN_ASSIGNMENT) parse() 821 cursor += 2; parse() 823 type->element = parse_type(&cursor, type[1].name, NULL); parse() 826 if (cursor != type[1].name) { parse() 828 filename, cursor->line, cursor->content); parse() 862 struct token *cursor = *_cursor; parse_type() local 867 top = element = alloc_elem(cursor); parse_type() 870 element->tag = token_to_tag[cursor->token_type]; parse_type() 874 if (cursor->token_type == TOKEN_OPEN_SQUARE) { parse_type() 875 cursor++; parse_type() 876 if (cursor >= end) parse_type() 878 switch (cursor->token_type) { parse_type() 881 cursor++; parse_type() 885 cursor++; parse_type() 892 cursor++; parse_type() 896 filename, cursor->line, cursor->content); parse_type() 900 if (cursor >= end) parse_type() 902 if (cursor->token_type != TOKEN_NUMBER) { parse_type() 904 filename, cursor->line, cursor->content); parse_type() 909 element->tag |= strtoul(cursor->content, &p, 10); parse_type() 911 if (p - cursor->content != cursor->size) parse_type() 913 cursor++; parse_type() 915 if (cursor >= end) parse_type() 917 if (cursor->token_type != TOKEN_CLOSE_SQUARE) { parse_type() 919 filename, cursor->line, cursor->content); parse_type() 922 cursor++; parse_type() 923 if (cursor >= end) parse_type() 929 if (cursor->token_type == DIRECTIVE_IMPLICIT) { parse_type() 932 cursor++; parse_type() 933 if (cursor >= end) parse_type() 935 } else if (cursor->token_type == DIRECTIVE_EXPLICIT) { parse_type() 937 cursor++; parse_type() 938 if (cursor >= end) parse_type() 946 element->children = alloc_elem(cursor); parse_type() 950 element->tag = token_to_tag[cursor->token_type]; parse_type() 955 element->type = cursor; parse_type() 956 switch (cursor->token_type) { parse_type() 959 cursor++; parse_type() 967 cursor++; parse_type() 990 cursor++; parse_type() 996 cursor++; parse_type() 997 if (cursor >= end) parse_type() 999 if (cursor->token_type != DIRECTIVE_STRING) parse_type() 1001 cursor++; parse_type() 1006 cursor++; parse_type() 1007 if (cursor >= end) parse_type() 1009 if (cursor->token_type != DIRECTIVE_IDENTIFIER) parse_type() 1011 cursor++; parse_type() 1016 ref = bsearch(cursor, type_index, nr_types, sizeof(type_index[0]), parse_type() 1020 filename, cursor->line, cursor->content); parse_type() 1023 cursor->type = *ref; parse_type() 1025 cursor++; parse_type() 1030 cursor++; parse_type() 1031 element->children = parse_compound(&cursor, end, 1); parse_type() 1037 cursor++; parse_type() 1038 if (cursor >= end) parse_type() 1040 if (cursor->token_type == DIRECTIVE_OF) { parse_type() 1042 cursor++; parse_type() 1043 if (cursor >= end) parse_type() 1045 element->children = parse_type(&cursor, end, NULL); parse_type() 1047 element->children = parse_compound(&cursor, end, 0); parse_type() 1054 cursor++; parse_type() 1055 if (cursor >= end) parse_type() 1057 if (cursor->token_type == DIRECTIVE_OF) { parse_type() 1059 cursor++; parse_type() 1060 if (cursor >= end) parse_type() 1062 element->children = parse_type(&cursor, end, NULL); parse_type() 1064 element->children = parse_compound(&cursor, end, 1); parse_type() 1070 filename, cursor->line, cursor->content); parse_type() 1075 if (cursor < end && (cursor->token_type == DIRECTIVE_OPTIONAL || parse_type() 1076 cursor->token_type == DIRECTIVE_DEFAULT) parse_type() 1078 cursor++; parse_type() 1082 if (cursor < end && cursor->token_type == TOKEN_OPEN_ACTION) { parse_type() 1083 cursor++; parse_type() 1084 if (cursor >= end) parse_type() 1086 if (cursor->token_type != TOKEN_ELEMENT_NAME) { parse_type() 1088 filename, cursor->line, cursor->content); parse_type() 1098 action->name = cursor->content; parse_type() 1123 cursor->action = action; parse_type() 1124 cursor++; parse_type() 1125 if (cursor >= end) parse_type() 1127 if (cursor->token_type != TOKEN_CLOSE_ACTION) { parse_type() 1129 filename, cursor->line, cursor->content); parse_type() 1132 cursor++; parse_type() 1135 *_cursor = cursor; parse_type() 1140 filename, cursor->line, cursor->content); parse_type() 1155 struct token *cursor = *_cursor, *name; parse_compound() local 1157 if (cursor->token_type != TOKEN_OPEN_CURLY) { parse_compound() 1159 filename, cursor->line, cursor->content); parse_compound() 1162 cursor++; parse_compound() 1163 if (cursor >= end) parse_compound() 1166 if (cursor->token_type == TOKEN_OPEN_CURLY) { parse_compound() 1168 filename, cursor->line); parse_compound() 1174 if (cursor->token_type == TOKEN_ELEMENT_NAME) { parse_compound() 1175 name = cursor; parse_compound() 1176 cursor++; parse_compound() 1177 if (cursor >= end) parse_compound() 1181 element = parse_type(&cursor, end, name); parse_compound() 1188 if (cursor >= end) parse_compound() 1190 if (cursor->token_type != TOKEN_COMMA) parse_compound() 1192 cursor++; parse_compound() 1193 if (cursor >= end) parse_compound() 1199 if (cursor->token_type != TOKEN_CLOSE_CURLY) { parse_compound() 1201 filename, cursor->line, cursor->content); parse_compound() 1204 cursor++; parse_compound() 1206 *_cursor = cursor; parse_compound()
|
/linux-4.4.14/arch/sparc/include/asm/ |
H A D | fbio.h | 40 #define CG14_CURSORREGS 0x1000 /* cursor registers */ 61 short enable; /* cursor on/off */ 62 struct fbcurpos pos; /* cursor position */ 63 struct fbcurpos hot; /* cursor hot spot */ 65 struct fbcurpos size; /* cursor bit map size */ 66 u32 image; /* cursor image bits */ 67 u32 mask; /* cursor mask bits */
|
/linux-4.4.14/arch/ia64/include/uapi/asm/ |
H A D | setup.h | 16 __u16 orig_x; /* cursor's x position */ 17 __u16 orig_y; /* cursor's y position */
|
/linux-4.4.14/drivers/gpu/drm/nouveau/dispnv04/ |
H A D | cursor.c | 65 crtc->cursor.set_offset = nv04_cursor_set_offset; nv04_cursor_init() 66 crtc->cursor.set_pos = nv04_cursor_set_pos; nv04_cursor_init() 67 crtc->cursor.hide = nv04_cursor_hide; nv04_cursor_init() 68 crtc->cursor.show = nv04_cursor_show; nv04_cursor_init()
|
H A D | crtc.c | 165 nv_crtc->cursor.set_offset(nv_crtc, nv_crtc->cursor.offset); nv_crtc_calc_state_ext() 760 nouveau_bo_unmap(nv_crtc->cursor.nvbo); nv_crtc_destroy() 761 nouveau_bo_unpin(nv_crtc->cursor.nvbo); nv_crtc_destroy() 762 nouveau_bo_ref(NULL, &nv_crtc->cursor.nvbo); nv_crtc_destroy() 993 struct nouveau_bo *cursor = NULL; nv04_crtc_cursor_set() local 998 nv_crtc->cursor.hide(nv_crtc, true); nv04_crtc_cursor_set() 1008 cursor = nouveau_gem_object(gem); nv04_crtc_cursor_set() 1010 ret = nouveau_bo_map(cursor); nv04_crtc_cursor_set() 1015 nv11_cursor_upload(dev, cursor, nv_crtc->cursor.nvbo); nv04_crtc_cursor_set() 1017 nv04_cursor_upload(dev, cursor, nv_crtc->cursor.nvbo); nv04_crtc_cursor_set() 1019 nouveau_bo_unmap(cursor); nv04_crtc_cursor_set() 1020 nv_crtc->cursor.offset = nv_crtc->cursor.nvbo->bo.offset; nv04_crtc_cursor_set() 1021 nv_crtc->cursor.set_offset(nv_crtc, nv_crtc->cursor.offset); nv04_crtc_cursor_set() 1022 nv_crtc->cursor.show(nv_crtc, true); nv04_crtc_cursor_set() 1033 nv_crtc->cursor.set_pos(nv_crtc, x, y); nv04_crtc_cursor_move() 1131 0, 0x0000, NULL, NULL, &nv_crtc->cursor.nvbo); nv04_crtc_create() 1133 ret = nouveau_bo_pin(nv_crtc->cursor.nvbo, TTM_PL_FLAG_VRAM, false); nv04_crtc_create() 1135 ret = nouveau_bo_map(nv_crtc->cursor.nvbo); nv04_crtc_create() 1137 nouveau_bo_unpin(nv_crtc->cursor.nvbo); nv04_crtc_create() 1140 nouveau_bo_ref(NULL, &nv_crtc->cursor.nvbo); nv04_crtc_create()
|
H A D | nvreg.h | 212 # define NV_CIO_CR_CURS_ST_INDEX 0x0a /* cursor start */ 213 # define NV_CIO_CR_CURS_END_INDEX 0x0b /* cursor end */ 216 # define NV_CIO_CR_TCOFF_HI_INDEX 0x0e /* cursor offset high */ 217 # define NV_CIO_CR_TCOFF_LO_INDEX 0x0f /* cursor offset low */ 257 # define NV_CIO_CRE_HCUR_ADDR2_INDEX 0x2f /* cursor */
|
H A D | hw.h | 329 /* nv04 cursor max dimensions of 32x32 (A1R5G5B5) */ 347 * the pixmap location, or just showing/hiding the cursor nv_fix_nv40_hw_cursor()
|
/linux-4.4.14/arch/m68k/include/asm/ |
H A D | fbio.h | 101 short enable; /* cursor on/off */ 102 struct fbcurpos pos; /* cursor position */ 103 struct fbcurpos hot; /* cursor hot spot */ 105 struct fbcurpos size; /* cursor bit map size */ 106 char __user *image; /* cursor image bits */ 107 char __user *mask; /* cursor mask bits */ 110 /* set/get cursor attributes/shape */ 114 /* set/get cursor position */ 118 /* get max cursor size */ 255 #define CG14_CURSORREGS 0x1000 /* cursor registers */ 317 short enable; /* cursor on/off */ 318 struct fbcurpos pos; /* cursor position */ 319 struct fbcurpos hot; /* cursor hot spot */ 321 struct fbcurpos size; /* cursor bit map size */ 322 u32 image; /* cursor image bits */ 323 u32 mask; /* cursor mask bits */
|
/linux-4.4.14/net/ceph/ |
H A D | messenger.c | 825 static void ceph_msg_data_bio_cursor_init(struct ceph_msg_data_cursor *cursor, ceph_msg_data_bio_cursor_init() argument 828 struct ceph_msg_data *data = cursor->data; ceph_msg_data_bio_cursor_init() 836 cursor->resid = min(length, data->bio_length); ceph_msg_data_bio_cursor_init() 837 cursor->bio = bio; ceph_msg_data_bio_cursor_init() 838 cursor->bvec_iter = bio->bi_iter; ceph_msg_data_bio_cursor_init() 839 cursor->last_piece = ceph_msg_data_bio_cursor_init() 840 cursor->resid <= bio_iter_len(bio, cursor->bvec_iter); ceph_msg_data_bio_cursor_init() 843 static struct page *ceph_msg_data_bio_next(struct ceph_msg_data_cursor *cursor, ceph_msg_data_bio_next() argument 847 struct ceph_msg_data *data = cursor->data; ceph_msg_data_bio_next() 853 bio = cursor->bio; ceph_msg_data_bio_next() 856 bio_vec = bio_iter_iovec(bio, cursor->bvec_iter); ceph_msg_data_bio_next() 860 if (cursor->last_piece) /* pagelist offset is always 0 */ ceph_msg_data_bio_next() 861 *length = cursor->resid; ceph_msg_data_bio_next() 864 BUG_ON(*length > cursor->resid); ceph_msg_data_bio_next() 870 static bool ceph_msg_data_bio_advance(struct ceph_msg_data_cursor *cursor, ceph_msg_data_bio_advance() argument 876 BUG_ON(cursor->data->type != CEPH_MSG_DATA_BIO); ceph_msg_data_bio_advance() 878 bio = cursor->bio; ceph_msg_data_bio_advance() 881 bio_vec = bio_iter_iovec(bio, cursor->bvec_iter); ceph_msg_data_bio_advance() 883 /* Advance the cursor offset */ ceph_msg_data_bio_advance() 885 BUG_ON(cursor->resid < bytes); ceph_msg_data_bio_advance() 886 cursor->resid -= bytes; ceph_msg_data_bio_advance() 888 bio_advance_iter(bio, &cursor->bvec_iter, bytes); ceph_msg_data_bio_advance() 895 if (!cursor->bvec_iter.bi_size) { ceph_msg_data_bio_advance() 897 cursor->bio = bio; ceph_msg_data_bio_advance() 899 cursor->bvec_iter = bio->bi_iter; ceph_msg_data_bio_advance() 901 memset(&cursor->bvec_iter, 0, ceph_msg_data_bio_advance() 902 sizeof(cursor->bvec_iter)); ceph_msg_data_bio_advance() 905 if (!cursor->last_piece) { ceph_msg_data_bio_advance() 906 BUG_ON(!cursor->resid); ceph_msg_data_bio_advance() 909 if (cursor->resid <= bio_iter_len(bio, cursor->bvec_iter)) ceph_msg_data_bio_advance() 910 cursor->last_piece = true; ceph_msg_data_bio_advance() 921 static void ceph_msg_data_pages_cursor_init(struct ceph_msg_data_cursor *cursor, ceph_msg_data_pages_cursor_init() argument 924 struct ceph_msg_data *data = cursor->data; ceph_msg_data_pages_cursor_init() 932 cursor->resid = min(length, data->length); ceph_msg_data_pages_cursor_init() 934 cursor->page_offset = data->alignment & ~PAGE_MASK; ceph_msg_data_pages_cursor_init() 935 cursor->page_index = 0; ceph_msg_data_pages_cursor_init() 937 cursor->page_count = (unsigned short)page_count; ceph_msg_data_pages_cursor_init() 938 BUG_ON(length > SIZE_MAX - cursor->page_offset); ceph_msg_data_pages_cursor_init() 939 cursor->last_piece = cursor->page_offset + cursor->resid <= PAGE_SIZE; ceph_msg_data_pages_cursor_init() 943 ceph_msg_data_pages_next(struct ceph_msg_data_cursor *cursor, ceph_msg_data_pages_next() argument 946 struct ceph_msg_data *data = cursor->data; ceph_msg_data_pages_next() 950 BUG_ON(cursor->page_index >= cursor->page_count); ceph_msg_data_pages_next() 951 BUG_ON(cursor->page_offset >= PAGE_SIZE); ceph_msg_data_pages_next() 953 *page_offset = cursor->page_offset; ceph_msg_data_pages_next() 954 if (cursor->last_piece) ceph_msg_data_pages_next() 955 *length = cursor->resid; ceph_msg_data_pages_next() 959 return data->pages[cursor->page_index]; ceph_msg_data_pages_next() 962 static bool ceph_msg_data_pages_advance(struct ceph_msg_data_cursor *cursor, ceph_msg_data_pages_advance() argument 965 BUG_ON(cursor->data->type != CEPH_MSG_DATA_PAGES); ceph_msg_data_pages_advance() 967 BUG_ON(cursor->page_offset + bytes > PAGE_SIZE); ceph_msg_data_pages_advance() 969 /* Advance the cursor page offset */ ceph_msg_data_pages_advance() 971 cursor->resid -= bytes; ceph_msg_data_pages_advance() 972 cursor->page_offset = (cursor->page_offset + bytes) & ~PAGE_MASK; ceph_msg_data_pages_advance() 973 if (!bytes || cursor->page_offset) ceph_msg_data_pages_advance() 976 if (!cursor->resid) ceph_msg_data_pages_advance() 981 BUG_ON(cursor->page_index >= cursor->page_count); ceph_msg_data_pages_advance() 982 cursor->page_index++; ceph_msg_data_pages_advance() 983 cursor->last_piece = cursor->resid <= PAGE_SIZE; ceph_msg_data_pages_advance() 993 ceph_msg_data_pagelist_cursor_init(struct ceph_msg_data_cursor *cursor, ceph_msg_data_pagelist_cursor_init() argument 996 struct ceph_msg_data *data = cursor->data; ceph_msg_data_pagelist_cursor_init() 1011 cursor->resid = min(length, pagelist->length); ceph_msg_data_pagelist_cursor_init() 1012 cursor->page = page; ceph_msg_data_pagelist_cursor_init() 1013 cursor->offset = 0; ceph_msg_data_pagelist_cursor_init() 1014 cursor->last_piece = cursor->resid <= PAGE_SIZE; ceph_msg_data_pagelist_cursor_init() 1018 ceph_msg_data_pagelist_next(struct ceph_msg_data_cursor *cursor, ceph_msg_data_pagelist_next() argument 1021 struct ceph_msg_data *data = cursor->data; ceph_msg_data_pagelist_next() 1029 BUG_ON(!cursor->page); ceph_msg_data_pagelist_next() 1030 BUG_ON(cursor->offset + cursor->resid != pagelist->length); ceph_msg_data_pagelist_next() 1033 *page_offset = cursor->offset & ~PAGE_MASK; ceph_msg_data_pagelist_next() 1034 if (cursor->last_piece) ceph_msg_data_pagelist_next() 1035 *length = cursor->resid; ceph_msg_data_pagelist_next() 1039 return cursor->page; ceph_msg_data_pagelist_next() 1042 static bool ceph_msg_data_pagelist_advance(struct ceph_msg_data_cursor *cursor, ceph_msg_data_pagelist_advance() argument 1045 struct ceph_msg_data *data = cursor->data; ceph_msg_data_pagelist_advance() 1053 BUG_ON(cursor->offset + cursor->resid != pagelist->length); ceph_msg_data_pagelist_advance() 1054 BUG_ON((cursor->offset & ~PAGE_MASK) + bytes > PAGE_SIZE); ceph_msg_data_pagelist_advance() 1056 /* Advance the cursor offset */ ceph_msg_data_pagelist_advance() 1058 cursor->resid -= bytes; ceph_msg_data_pagelist_advance() 1059 cursor->offset += bytes; ceph_msg_data_pagelist_advance() 1061 if (!bytes || cursor->offset & ~PAGE_MASK) ceph_msg_data_pagelist_advance() 1064 if (!cursor->resid) ceph_msg_data_pagelist_advance() 1069 BUG_ON(list_is_last(&cursor->page->lru, &pagelist->head)); ceph_msg_data_pagelist_advance() 1070 cursor->page = list_entry_next(cursor->page, lru); ceph_msg_data_pagelist_advance() 1071 cursor->last_piece = cursor->resid <= PAGE_SIZE; ceph_msg_data_pagelist_advance() 1079 * consume an entire piece at once. A data item's cursor keeps 1084 static void __ceph_msg_data_cursor_init(struct ceph_msg_data_cursor *cursor) __ceph_msg_data_cursor_init() argument 1086 size_t length = cursor->total_resid; __ceph_msg_data_cursor_init() 1088 switch (cursor->data->type) { __ceph_msg_data_cursor_init() 1090 ceph_msg_data_pagelist_cursor_init(cursor, length); __ceph_msg_data_cursor_init() 1093 ceph_msg_data_pages_cursor_init(cursor, length); __ceph_msg_data_cursor_init() 1097 ceph_msg_data_bio_cursor_init(cursor, length); __ceph_msg_data_cursor_init() 1105 cursor->need_crc = true; __ceph_msg_data_cursor_init() 1110 struct ceph_msg_data_cursor *cursor = &msg->cursor; ceph_msg_data_cursor_init() local 1117 cursor->data_head = &msg->data; ceph_msg_data_cursor_init() 1118 cursor->total_resid = length; ceph_msg_data_cursor_init() 1120 cursor->data = data; ceph_msg_data_cursor_init() 1122 __ceph_msg_data_cursor_init(cursor); ceph_msg_data_cursor_init() 1130 static struct page *ceph_msg_data_next(struct ceph_msg_data_cursor *cursor, ceph_msg_data_next() argument 1136 switch (cursor->data->type) { ceph_msg_data_next() 1138 page = ceph_msg_data_pagelist_next(cursor, page_offset, length); ceph_msg_data_next() 1141 page = ceph_msg_data_pages_next(cursor, page_offset, length); ceph_msg_data_next() 1145 page = ceph_msg_data_bio_next(cursor, page_offset, length); ceph_msg_data_next() 1157 *last_piece = cursor->last_piece; ceph_msg_data_next() 1163 * Returns true if the result moves the cursor on to the next piece 1166 static bool ceph_msg_data_advance(struct ceph_msg_data_cursor *cursor, ceph_msg_data_advance() argument 1171 BUG_ON(bytes > cursor->resid); ceph_msg_data_advance() 1172 switch (cursor->data->type) { ceph_msg_data_advance() 1174 new_piece = ceph_msg_data_pagelist_advance(cursor, bytes); ceph_msg_data_advance() 1177 new_piece = ceph_msg_data_pages_advance(cursor, bytes); ceph_msg_data_advance() 1181 new_piece = ceph_msg_data_bio_advance(cursor, bytes); ceph_msg_data_advance() 1189 cursor->total_resid -= bytes; ceph_msg_data_advance() 1191 if (!cursor->resid && cursor->total_resid) { ceph_msg_data_advance() 1192 WARN_ON(!cursor->last_piece); ceph_msg_data_advance() 1193 BUG_ON(list_is_last(&cursor->data->links, cursor->data_head)); ceph_msg_data_advance() 1194 cursor->data = list_entry_next(cursor->data, links); ceph_msg_data_advance() 1195 __ceph_msg_data_cursor_init(cursor); ceph_msg_data_advance() 1198 cursor->need_crc = new_piece; ceph_msg_data_advance() 1215 /* Initialize data cursor */ prepare_message_data() 1557 struct ceph_msg_data_cursor *cursor = &msg->cursor; write_partial_message_data() local 1575 while (cursor->resid) { write_partial_message_data() 1583 page = ceph_msg_data_next(cursor, &page_offset, &length, write_partial_message_data() 1593 if (do_datacrc && cursor->need_crc) write_partial_message_data() 1595 need_crc = ceph_msg_data_advance(cursor, (size_t)ret); write_partial_message_data() 2263 struct ceph_msg_data_cursor *cursor = &msg->cursor; read_partial_msg_data() local 2277 while (cursor->resid) { read_partial_msg_data() 2278 page = ceph_msg_data_next(cursor, &page_offset, &length, NULL); read_partial_msg_data() 2289 (void) ceph_msg_data_advance(cursor, (size_t)ret); read_partial_msg_data() 3098 con->out_skip += msg->cursor.total_resid; ceph_msg_revoke()
|
/linux-4.4.14/drivers/gpu/drm/msm/mdp/mdp5/ |
H A D | mdp5_crtc.c | 58 /* for unref'ing cursor bo's after scanout completes: */ 70 /* protect REG_MDP5_LM_CURSOR* registers and cursor scanout_bo*/ 73 /* current cursor being scanned out: */ 77 } cursor; member in struct:mdp5_crtc 485 * Cursor Region Of Interest (ROI) is a plane read from cursor get_roi() 487 * the cursor point. In the default Cursor image the cursor point will get_roi() 488 * be at the top left of the cursor image, unless it is specified get_roi() 491 * If the cursor point reaches the right (xres - x < cursor.width) or get_roi() 492 * bottom (yres - y < cursor.height) boundary of the screen, then ROI get_roi() 493 * width and ROI height need to be evaluated to crop the cursor image get_roi() 495 * (xres-x) will be new cursor width when x > (xres - cursor.width) get_roi() 496 * (yres-y) will be new cursor height when y > (yres - cursor.height) get_roi() 498 *roi_w = min(mdp5_crtc->cursor.width, xres - get_roi() 499 mdp5_crtc->cursor.x); get_roi() 500 *roi_h = min(mdp5_crtc->cursor.height, yres - get_roi() 501 mdp5_crtc->cursor.y); get_roi() 522 dev_err(dev->dev, "bad cursor size: %dx%d\n", width, height); mdp5_crtc_cursor_set() 547 spin_lock_irqsave(&mdp5_crtc->cursor.lock, flags); mdp5_crtc_cursor_set() 548 old_bo = mdp5_crtc->cursor.scanout_bo; mdp5_crtc_cursor_set() 550 mdp5_crtc->cursor.scanout_bo = cursor_bo; mdp5_crtc_cursor_set() 551 mdp5_crtc->cursor.width = width; mdp5_crtc_cursor_set() 552 mdp5_crtc->cursor.height = height; mdp5_crtc_cursor_set() 571 spin_unlock_irqrestore(&mdp5_crtc->cursor.lock, flags); mdp5_crtc_cursor_set() 576 dev_err(dev->dev, "failed to %sable cursor: %d\n", mdp5_crtc_cursor_set() 586 /* enable vblank to complete cursor work: */ mdp5_crtc_cursor_set() 601 /* In case the CRTC is disabled, just drop the cursor update */ mdp5_crtc_cursor_move() 605 mdp5_crtc->cursor.x = x = max(x, 0); mdp5_crtc_cursor_move() 606 mdp5_crtc->cursor.y = y = max(y, 0); mdp5_crtc_cursor_move() 610 spin_lock_irqsave(&mdp5_crtc->cursor.lock, flags); mdp5_crtc_cursor_move() 617 spin_unlock_irqrestore(&mdp5_crtc->cursor.lock, flags); mdp5_crtc_cursor_move() 791 spin_lock_init(&mdp5_crtc->cursor.lock); mdp5_crtc_init() 803 "unref cursor", unref_cursor_worker); mdp5_crtc_init()
|
/linux-4.4.14/drivers/gpu/drm/msm/mdp/mdp4/ |
H A D | mdp4_crtc.c | 42 /* next cursor to scan-out: */ 46 /* current cursor being scanned out: */ 48 } cursor; member in struct:mdp4_crtc 63 /* for unref'ing cursor bo's after scanout completes: */ 374 /* called from IRQ to update cursor related registers (if needed). The 375 * cursor registers, other than x/y position, appear not to be double 386 spin_lock_irqsave(&mdp4_crtc->cursor.lock, flags); update_cursor() 387 if (mdp4_crtc->cursor.stale) { update_cursor() 388 struct drm_gem_object *next_bo = mdp4_crtc->cursor.next_bo; update_cursor() 389 struct drm_gem_object *prev_bo = mdp4_crtc->cursor.scanout_bo; update_cursor() 390 uint32_t iova = mdp4_crtc->cursor.next_iova; update_cursor() 397 /* enable cursor: */ update_cursor() 399 MDP4_DMA_CURSOR_SIZE_WIDTH(mdp4_crtc->cursor.width) | update_cursor() 400 MDP4_DMA_CURSOR_SIZE_HEIGHT(mdp4_crtc->cursor.height)); update_cursor() 406 /* disable cursor: */ update_cursor() 415 mdp4_crtc->cursor.scanout_bo = next_bo; update_cursor() 416 mdp4_crtc->cursor.stale = false; update_cursor() 420 MDP4_DMA_CURSOR_POS_X(mdp4_crtc->cursor.x) | update_cursor() 421 MDP4_DMA_CURSOR_POS_Y(mdp4_crtc->cursor.y)); update_cursor() 423 spin_unlock_irqrestore(&mdp4_crtc->cursor.lock, flags); update_cursor() 439 dev_err(dev->dev, "bad cursor size: %dx%d\n", width, height); mdp4_crtc_cursor_set() 459 spin_lock_irqsave(&mdp4_crtc->cursor.lock, flags); mdp4_crtc_cursor_set() 460 old_bo = mdp4_crtc->cursor.next_bo; mdp4_crtc_cursor_set() 461 mdp4_crtc->cursor.next_bo = cursor_bo; mdp4_crtc_cursor_set() 462 mdp4_crtc->cursor.next_iova = iova; mdp4_crtc_cursor_set() 463 mdp4_crtc->cursor.width = width; mdp4_crtc_cursor_set() 464 mdp4_crtc->cursor.height = height; mdp4_crtc_cursor_set() 465 mdp4_crtc->cursor.stale = true; mdp4_crtc_cursor_set() 466 spin_unlock_irqrestore(&mdp4_crtc->cursor.lock, flags); mdp4_crtc_cursor_set() 487 spin_lock_irqsave(&mdp4_crtc->cursor.lock, flags); mdp4_crtc_cursor_move() 488 mdp4_crtc->cursor.x = x; mdp4_crtc_cursor_move() 489 mdp4_crtc->cursor.y = y; mdp4_crtc_cursor_move() 490 spin_unlock_irqrestore(&mdp4_crtc->cursor.lock, flags); mdp4_crtc_cursor_move() 676 spin_lock_init(&mdp4_crtc->cursor.lock); mdp4_crtc_init() 679 "unref cursor", unref_cursor_worker); mdp4_crtc_init()
|
H A D | mdp4_kms.h | 51 /* empty/blank cursor bo to use when cursor is "disabled" */
|
H A D | mdp4_kms.c | 533 dev_err(dev->dev, "could not allocate blank-cursor bo: %d\n", ret); mdp4_kms_init() 541 dev_err(dev->dev, "could not pin blank-cursor bo: %d\n", ret); mdp4_kms_init()
|
/linux-4.4.14/include/video/ |
H A D | maxinefb.h | 31 #define IMS332_REG_CURSOR_RAM 0x200 /* hardware cursor bitmap */ 37 #define IMS332_REG_CURSOR_COLOR_PALETTE 0x0a1 /* cursor color palette, */
|
/linux-4.4.14/drivers/video/fbdev/intelfb/ |
H A D | intelfbdrv.c | 39 * 01/2003 - Version 0.4.0: fbcon HW cursor support added. (David Dawes) 62 * cursor are disabled on this platform. (David Dawes) 68 * cursor are disabled on this platform. (David Dawes) 90 * Fix HW accel and HW cursor on i845G 154 struct fb_cursor *cursor); 249 MODULE_PARM_DESC(hwcursor, "Enable HW cursor"); 605 /* Allocate space for the ring buffer and HW cursor if enabled. */ intelfb_pci_register() 611 dinfo->cursor.size = HW_CURSOR_SIZE; intelfb_pci_register() 637 dinfo->cursor.offset = offset + intelfb_pci_register() 642 + (dinfo->cursor.size >> 12); intelfb_pci_register() 693 agp_allocate_memory(bridge, dinfo->cursor.size >> 12, intelfb_pci_register() 695 ERR_MSG("cannot allocate cursor memory\n"); intelfb_pci_register() 701 dinfo->cursor.offset)) { intelfb_pci_register() 702 ERR_MSG("cannot bind cursor memory\n"); intelfb_pci_register() 708 dinfo->cursor.physical intelfb_pci_register() 711 dinfo->cursor.physical = dinfo->aperture.physical intelfb_pci_register() 712 + (dinfo->cursor.offset << 12); intelfb_pci_register() 713 dinfo->cursor.virtual = dinfo->aperture.virtual intelfb_pci_register() 714 + (dinfo->cursor.offset << 12); intelfb_pci_register() 756 DBG_MSG("HW cursor: 0x%x/0x%x (0x%p) (offset 0x%x) (phys 0x%x)\n", intelfb_pci_register() 757 dinfo->cursor.physical, dinfo->cursor.size, intelfb_pci_register() 758 dinfo->cursor.virtual, dinfo->cursor.offset, intelfb_pci_register() 759 dinfo->cursor.physical); intelfb_pci_register() 1546 static int intelfb_cursor(struct fb_info *info, struct fb_cursor *cursor) intelfb_cursor() argument 1559 /* If XFree killed the cursor - restore it */ intelfb_cursor() 1560 physical = (dinfo->mobile || IS_I9XX(dinfo)) ? dinfo->cursor.physical : intelfb_cursor() 1561 (dinfo->cursor.offset << 12); intelfb_cursor() 1566 DBG_MSG("the cursor was killed - restore it !!\n"); intelfb_cursor() 1568 cursor->image.width, cursor->image.height, intelfb_cursor() 1569 cursor->image.dx, cursor->image.dy); intelfb_cursor() 1573 intelfbhw_cursor_setpos(dinfo, cursor->image.dx, intelfb_cursor() 1574 cursor->image.dy); intelfb_cursor() 1577 fg =dinfo->pseudo_palette[cursor->image.fg_color]; intelfb_cursor() 1578 bg =dinfo->pseudo_palette[cursor->image.bg_color]; intelfb_cursor() 1580 fg = cursor->image.fg_color; intelfb_cursor() 1581 bg = cursor->image.bg_color; intelfb_cursor() 1584 intelfbhw_cursor_load(dinfo, cursor->image.width, intelfb_cursor() 1585 cursor->image.height, intelfb_cursor() 1588 if (cursor->enable) intelfb_cursor() 1593 if (cursor->set & FB_CUR_SETPOS) { intelfb_cursor() 1596 dx = cursor->image.dx - info->var.xoffset; intelfb_cursor() 1597 dy = cursor->image.dy - info->var.yoffset; intelfb_cursor() 1602 if (cursor->set & FB_CUR_SETSIZE) { intelfb_cursor() 1603 if (cursor->image.width > 64 || cursor->image.height > 64) intelfb_cursor() 1609 if (cursor->set & FB_CUR_SETCMAP) { intelfb_cursor() 1613 fg = dinfo->pseudo_palette[cursor->image.fg_color]; intelfb_cursor() 1614 bg = dinfo->pseudo_palette[cursor->image.bg_color]; intelfb_cursor() 1616 fg = cursor->image.fg_color; intelfb_cursor() 1617 bg = cursor->image.bg_color; intelfb_cursor() 1623 if (cursor->set & (FB_CUR_SETSHAPE | FB_CUR_SETIMAGE)) { intelfb_cursor() 1624 u32 s_pitch = (ROUND_UP_TO(cursor->image.width, 8) / 8); intelfb_cursor() 1625 u32 size = s_pitch * cursor->image.height; intelfb_cursor() 1626 u8 *dat = (u8 *) cursor->image.data; intelfb_cursor() 1627 u8 *msk = (u8 *) cursor->mask; intelfb_cursor() 1631 if (cursor->image.depth != 1) intelfb_cursor() 1634 switch (cursor->rop) { intelfb_cursor() 1647 make the cursor dirty */ intelfb_cursor() 1650 intelfbhw_cursor_load(dinfo, cursor->image.width, intelfb_cursor() 1651 cursor->image.height, src); intelfb_cursor() 1654 if (cursor->enable) intelfb_cursor()
|
H A D | intelfb.h | 283 struct agp_memory *gtt_cursor_mem; /* hw cursor */ 294 struct intelfb_heap_data cursor; member in struct:intelfb_info 341 /* hw cursor */
|
H A D | intelfbhw.c | 435 /* Turn off/on the HW cursor */ intelfbhw_do_blank() 1838 /* HW cursor functions. */ intelfbhw_cursor_init() 1848 if (!dinfo->cursor.physical) intelfbhw_cursor_init() 1856 OUTREG(CURSOR_A_BASEADDR, dinfo->cursor.physical); intelfbhw_cursor_init() 1863 OUTREG(CURSOR_A_BASEADDR, dinfo->cursor.offset << 12); intelfbhw_cursor_init() 1880 if (!dinfo->cursor.physical) intelfbhw_cursor_hide() 1887 OUTREG(CURSOR_A_BASEADDR, dinfo->cursor.physical); intelfbhw_cursor_hide() 1909 if (!dinfo->cursor.physical) intelfbhw_cursor_show() 1916 OUTREG(CURSOR_A_BASEADDR, dinfo->cursor.physical); intelfbhw_cursor_show() 1934 * have any offset adjusted. Assume that the cursor is never intelfbhw_cursor_setpos() 1943 OUTREG(CURSOR_A_BASEADDR, dinfo->cursor.physical); intelfbhw_cursor_setpos() 1961 u8 __iomem *addr = (u8 __iomem *)dinfo->cursor.virtual; intelfbhw_cursor_load() 1969 if (!dinfo->cursor.virtual) intelfbhw_cursor_load() 1989 u8 __iomem *addr = (u8 __iomem *)dinfo->cursor.virtual; intelfbhw_cursor_reset() 1996 if (!dinfo->cursor.virtual) intelfbhw_cursor_reset()
|
H A D | intelfbhw.h | 330 /* Desktop HW cursor */ 346 /* Mobile HW cursor (and i810) */
|
/linux-4.4.14/drivers/video/fbdev/ |
H A D | pmag-aa-fb.c | 23 * Hardware cursor support. 61 * Bt431 cursor generator offset (rel. to TC slot base address). 87 struct aafb_cursor cursor; member in struct:aafb_info 107 struct aafb_cursor *c = &info->cursor; aafb_set_cursor() 119 struct aafb_cursor *c = &info->cursor; aafbcon_cursor() 151 struct aafb_cursor *c = &info->cursor; aafbcon_set_font() 168 struct aafb_cursor *c = &info->cursor; aafb_cursor_timer_handler() 186 struct aafb_cursor *c = &info->cursor; aafb_cursor_init() 203 struct aafb_cursor *c = &info->cursor; aafb_cursor_exit() 215 .cursor = aafbcon_cursor, 384 aafbcon_cursor(disp, CM_ERASE, ip->cursor.x, ip->cursor.y); aafb_update_var() 397 aafbcon_cursor(&ip->disp, CM_ERASE, ip->cursor.x, ip->cursor.y); aafb_blank() 451 /* Init hardware cursor. */ init_one()
|
H A D | pm2fb.c | 69 * The XFree GLINT driver will (I think to implement hardware cursor 520 * The hardware cursor needs +vsync to recognise vert retrace. set_video() 521 * We may not be using the hardware cursor, but the X Glint set_video() 1250 * Hardware cursor support. 1257 static int pm2vfb_cursor(struct fb_info *info, struct fb_cursor *cursor) pm2vfb_cursor() argument 1261 int x = cursor->image.dx - info->var.xoffset; pm2vfb_cursor() 1262 int y = cursor->image.dy - info->var.yoffset; pm2vfb_cursor() 1264 if (cursor->enable) pm2vfb_cursor() 1269 if (!cursor->enable) pm2vfb_cursor() 1277 * If the cursor is not be changed this means either we want the pm2vfb_cursor() 1278 * current cursor state (if enable is set) or we want to query what pm2vfb_cursor() 1279 * we can do with the cursor (if enable is not set) pm2vfb_cursor() 1281 if (!cursor->set) pm2vfb_cursor() 1284 if (cursor->set & FB_CUR_SETHOT) { pm2vfb_cursor() 1286 cursor->hot.x & 0x3f); pm2vfb_cursor() 1288 cursor->hot.y & 0x3f); pm2vfb_cursor() 1291 if (cursor->set & FB_CUR_SETCMAP) { pm2vfb_cursor() 1292 u32 fg_idx = cursor->image.fg_color; pm2vfb_cursor() 1293 u32 bg_idx = cursor->image.bg_color; pm2vfb_cursor() 1314 if (cursor->set & (FB_CUR_SETSHAPE | FB_CUR_SETIMAGE)) { pm2vfb_cursor() 1315 u8 *bitmap = (u8 *)cursor->image.data; pm2vfb_cursor() 1316 u8 *mask = (u8 *)cursor->mask; pm2vfb_cursor() 1320 for (i = 0; i < cursor->image.height; i++) { pm2vfb_cursor() 1321 int j = (cursor->image.width + 7) >> 3; pm2vfb_cursor() 1329 if (cursor->rop == ROP_COPY) pm2vfb_cursor() 1358 static int pm2fb_cursor(struct fb_info *info, struct fb_cursor *cursor) pm2fb_cursor() argument 1366 /* Too large of a cursor or wrong bpp :-( */ pm2fb_cursor() 1367 if (cursor->image.width > 64 || pm2fb_cursor() 1368 cursor->image.height > 64 || pm2fb_cursor() 1369 cursor->image.depth > 1) pm2fb_cursor() 1373 return pm2vfb_cursor(info, cursor); pm2fb_cursor() 1376 if (cursor->enable) pm2fb_cursor() 1382 * If the cursor is not be changed this means either we want the pm2fb_cursor() 1383 * current cursor state (if enable is set) or we want to query what pm2fb_cursor() 1384 * we can do with the cursor (if enable is not set) pm2fb_cursor() 1386 if (!cursor->set) pm2fb_cursor() 1389 if (cursor->set & FB_CUR_SETPOS) { pm2fb_cursor() 1390 int x = cursor->image.dx - info->var.xoffset + 63; pm2fb_cursor() 1391 int y = cursor->image.dy - info->var.yoffset + 63; pm2fb_cursor() 1400 if (cursor->set & FB_CUR_SETCMAP) { pm2fb_cursor() 1401 u32 fg_idx = cursor->image.fg_color; pm2fb_cursor() 1402 u32 bg_idx = cursor->image.bg_color; pm2fb_cursor() 1421 if (cursor->set & (FB_CUR_SETSHAPE | FB_CUR_SETIMAGE)) { pm2fb_cursor() 1422 u8 *bitmap = (u8 *)cursor->image.data; pm2fb_cursor() 1423 u8 *mask = (u8 *)cursor->mask; pm2fb_cursor() 1429 for (i = 0; i < cursor->image.height; i++) { pm2fb_cursor() 1430 int j = (cursor->image.width + 7) >> 3; pm2fb_cursor() 1437 if (cursor->rop == ROP_COPY) pm2fb_cursor() 1454 mask = (u8 *)cursor->mask; pm2fb_cursor() 1455 for (i = 0; i < cursor->image.height; i++) { pm2fb_cursor() 1456 int j = (cursor->image.width + 7) >> 3; pm2fb_cursor() 1829 MODULE_PARM_DESC(hwcursor, "Enable hardware cursor "
|
H A D | fsl-diu-fb.c | 43 /* HW cursor parameters */ 362 * @cursor: hardware cursor data 380 /* It's easier to parse the cursor data as little-endian */ 381 __le16 cursor[MAX_CURS * MAX_CURS] __aligned(32); 382 /* Blank cursor data -- used to hide the cursor */ 443 "cursor=%08x curs_pos=%08x diu_mode=%08x bgnd=%08x " fsl_diu_dump() 447 hw->pallete, hw->cursor, hw->curs_pos, hw->diu_mode, fsl_diu_dump() 821 /* Prep for DIU init - gamma table, cursor table */ update_lcdc() 978 * Copies a cursor image from user space to the proper place in driver 979 * memory so that the hardware can display the cursor image. 983 * second byte, and so on. Therefore, the each row of the cursor is (width + 992 * This could result in an unaligned 32-bit read. For example, if the cursor 994 * the top line of the cursor. We do a 32-bit read of 'image', but we look 1005 __le16 *cursor = data->cursor; fsl_diu_load_cursor_image() local 1015 cursor[w] = (line & mask) ? _fg : _bg; fsl_diu_load_cursor_image() 1019 cursor += MAX_CURS; fsl_diu_load_cursor_image() 1025 * Set a hardware cursor. The image data for the cursor is passed via the 1028 static int fsl_diu_cursor(struct fb_info *info, struct fb_cursor *cursor) fsl_diu_cursor() argument 1034 if (cursor->image.width > MAX_CURS || cursor->image.height > MAX_CURS) fsl_diu_cursor() 1037 /* The cursor size has changed */ fsl_diu_cursor() 1038 if (cursor->set & FB_CUR_SETSIZE) { fsl_diu_cursor() 1040 * The DIU cursor is a fixed size, so when we get this fsl_diu_cursor() 1041 * message, instead of resizing the cursor, we just clear fsl_diu_cursor() 1046 memset(data->cursor, 0, sizeof(data->cursor)); fsl_diu_cursor() 1049 /* The cursor position has changed (cursor->image.dx|dy) */ fsl_diu_cursor() 1050 if (cursor->set & FB_CUR_SETPOS) { fsl_diu_cursor() 1053 yy = (cursor->image.dy - info->var.yoffset) & 0x7ff; fsl_diu_cursor() 1054 xx = (cursor->image.dx - info->var.xoffset) & 0x7ff; fsl_diu_cursor() 1060 * FB_CUR_SETIMAGE - the cursor image has changed fsl_diu_cursor() 1061 * FB_CUR_SETCMAP - the cursor colors has changed fsl_diu_cursor() 1062 * FB_CUR_SETSHAPE - the cursor bitmask has changed fsl_diu_cursor() 1064 if (cursor->set & (FB_CUR_SETSHAPE | FB_CUR_SETCMAP | FB_CUR_SETIMAGE)) { fsl_diu_cursor() 1066 DIV_ROUND_UP(cursor->image.width, 8) * cursor->image.height; fsl_diu_cursor() 1069 unsigned int bg_idx = cursor->image.bg_color; fsl_diu_cursor() 1070 unsigned int fg_idx = cursor->image.fg_color; fsl_diu_cursor() 1080 * Determine the size of the cursor image data. Normally, fsl_diu_cursor() 1083 image_size = DIV_ROUND_UP(cursor->image.width, 8) * fsl_diu_cursor() 1084 cursor->image.height; fsl_diu_cursor() 1098 source = (uint32_t *)cursor->image.data; fsl_diu_cursor() 1099 mask = (uint32_t *)cursor->mask; fsl_diu_cursor() 1101 if (cursor->rop == ROP_XOR) fsl_diu_cursor() 1109 cursor->image.width, cursor->image.height); fsl_diu_cursor() 1113 * Show or hide the cursor. The cursor data is always stored in the fsl_diu_cursor() 1114 * 'cursor' memory block, and the actual cursor position is always in fsl_diu_cursor() 1115 * the DIU's CURS_POS register. To hide the cursor, we redirect the fsl_diu_cursor() 1116 * CURSOR register to a blank cursor. The show the cursor, we fsl_diu_cursor() 1117 * redirect the CURSOR register to the real cursor data. fsl_diu_cursor() 1119 if (cursor->enable) fsl_diu_cursor() 1120 out_be32(&hw->cursor, DMA_ADDR(data, cursor)); fsl_diu_cursor() 1122 out_be32(&hw->cursor, DMA_ADDR(data, blank_cursor)); fsl_diu_cursor()
|
H A D | pm3fb.c | 612 static int pm3fb_cursor(struct fb_info *info, struct fb_cursor *cursor) pm3fb_cursor() argument 620 /* Too large of a cursor or wrong bpp :-( */ pm3fb_cursor() 621 if (cursor->image.width > 64 || pm3fb_cursor() 622 cursor->image.height > 64 || pm3fb_cursor() 623 cursor->image.depth > 1) pm3fb_cursor() 627 if (cursor->enable) pm3fb_cursor() 633 * If the cursor is not be changed this means either we want the pm3fb_cursor() 634 * current cursor state (if enable is set) or we want to query what pm3fb_cursor() 635 * we can do with the cursor (if enable is not set) pm3fb_cursor() 637 if (!cursor->set) pm3fb_cursor() 640 if (cursor->set & FB_CUR_SETPOS) { pm3fb_cursor() 641 int x = cursor->image.dx - info->var.xoffset; pm3fb_cursor() 642 int y = cursor->image.dy - info->var.yoffset; pm3fb_cursor() 650 if (cursor->set & FB_CUR_SETHOT) { pm3fb_cursor() 652 cursor->hot.x & 0x3f); pm3fb_cursor() 654 cursor->hot.y & 0x3f); pm3fb_cursor() 657 if (cursor->set & FB_CUR_SETCMAP) { pm3fb_cursor() 658 u32 fg_idx = cursor->image.fg_color; pm3fb_cursor() 659 u32 bg_idx = cursor->image.bg_color; pm3fb_cursor() 678 if (cursor->set & (FB_CUR_SETSHAPE | FB_CUR_SETIMAGE)) { pm3fb_cursor() 679 u8 *bitmap = (u8 *)cursor->image.data; pm3fb_cursor() 680 u8 *mask = (u8 *)cursor->mask; pm3fb_cursor() 684 for (i = 0; i < cursor->image.height; i++) { pm3fb_cursor() 685 int j = (cursor->image.width + 7) >> 3; pm3fb_cursor() 691 if (cursor->rop == ROP_COPY) pm3fb_cursor() 1562 MODULE_PARM_DESC(hwcursor, "Enable hardware cursor "
|
H A D | tdfxfb.c | 25 * (proper acceleration, 24 bpp, hardware cursor) and bug fixes by Attila 1039 static int tdfxfb_cursor(struct fb_info *info, struct fb_cursor *cursor) tdfxfb_cursor() argument 1047 /* Too large of a cursor or wrong bpp :-( */ tdfxfb_cursor() 1048 if (cursor->image.width > 64 || tdfxfb_cursor() 1049 cursor->image.height > 64 || tdfxfb_cursor() 1050 cursor->image.depth > 1) tdfxfb_cursor() 1054 if (cursor->enable) tdfxfb_cursor() 1060 * If the cursor is not be changed this means either we want the tdfxfb_cursor() 1061 * current cursor state (if enable is set) or we want to query what tdfxfb_cursor() 1062 * we can do with the cursor (if enable is not set) tdfxfb_cursor() 1064 if (!cursor->set) tdfxfb_cursor() 1067 /* fix cursor color - XFree86 forgets to restore it properly */ tdfxfb_cursor() 1068 if (cursor->set & FB_CUR_SETCMAP) { tdfxfb_cursor() 1070 u32 bg_idx = cursor->image.bg_color; tdfxfb_cursor() 1071 u32 fg_idx = cursor->image.fg_color; tdfxfb_cursor() 1085 if (cursor->set & FB_CUR_SETPOS) { tdfxfb_cursor() 1086 int x = cursor->image.dx; tdfxfb_cursor() 1087 int y = cursor->image.dy - info->var.yoffset; tdfxfb_cursor() 1094 if (cursor->set & (FB_CUR_SETIMAGE | FB_CUR_SETSHAPE)) { tdfxfb_cursor() 1096 * Voodoo 3 and above cards use 2 monochrome cursor patterns. tdfxfb_cursor() 1100 * cursor for each screen refresh. tdfxfb_cursor() 1106 * the cursor image the graphics card uses then from the tdfxfb_cursor() 1109 * etc etc. The linear stride for the cursor is always 16 bytes tdfxfb_cursor() 1110 * (128 bits) which is the maximum cursor width times two for tdfxfb_cursor() 1114 u8 *bitmap = (u8 *)cursor->image.data; tdfxfb_cursor() 1115 u8 *mask = (u8 *)cursor->mask; tdfxfb_cursor() 1120 for (i = 0; i < cursor->image.height; i++) { tdfxfb_cursor() 1122 int j = (cursor->image.width + 7) >> 3; tdfxfb_cursor() 1126 if (cursor->rop == ROP_COPY) tdfxfb_cursor() 1128 /* Pattern 0. Copy the cursor mask to it */ tdfxfb_cursor() 1131 /* Pattern 1. Copy the cursor bitmap to it */ tdfxfb_cursor() 1473 /* reserve 8192 bits for cursor */ tdfxfb_probe() 1649 MODULE_PARM_DESC(hwcursor, "Enable hardware cursor "
|
H A D | leo.c | 186 struct leo_cursor __iomem *cursor; member in struct:leo_par 212 struct leo_cursor __iomem *cursor = par->cursor; leo_switch_from_graph() local 244 /* hide cursor */ leo_switch_from_graph() 245 sbus_writel(sbus_readl(&cursor->cur_misc) & ~LEO_CUR_ENABLE, &cursor->cur_misc); leo_switch_from_graph() 543 if (par->cursor) leo_unmap_regs() 545 par->cursor, sizeof(struct leo_cursor)); leo_unmap_regs() 588 par->cursor = leo_probe() 590 sizeof(struct leo_cursor), "leolx cursor"); leo_probe() 598 !par->cursor || leo_probe()
|
H A D | g364fb.c | 111 static int g364fb_cursor(struct fb_info *info, struct fb_cursor *cursor); 125 int g364fb_cursor(struct fb_info *info, struct fb_cursor *cursor) g364fb_cursor() argument 128 switch (cursor->enable) { g364fb_cursor() 216 /* setup cursor */ g364fb_init() 222 * first set the whole cursor to transparent g364fb_init() 228 * switch the last two lines to cursor palette 3 g364fb_init()
|
H A D | skeletonfb.c | 570 * for a cursor, leave this field NULL. 573 * @cursor: structure defining the cursor to draw. 576 * cursor. 580 int xxxfb_cursor(struct fb_info *info, struct fb_cursor *cursor) xxxfb_cursor() argument 584 * @enable: Disable or enable the cursor xxxfb_cursor() 586 * @mask: This is the cursor mask bitmap. xxxfb_cursor() 587 * @dest: A image of the area we are going to display the cursor. xxxfb_cursor() 590 * @image: The actual data for the cursor image. xxxfb_cursor() 592 * NOTES ON FLAGS (cursor->set): xxxfb_cursor() 594 * FB_CUR_SETIMAGE - the cursor image has changed (cursor->image.data) xxxfb_cursor() 595 * FB_CUR_SETPOS - the cursor position has changed (cursor->image.dx|dy) xxxfb_cursor() 596 * FB_CUR_SETHOT - the cursor hot spot has changed (cursor->hot.dx|dy) xxxfb_cursor() 597 * FB_CUR_SETCMAP - the cursor colors has changed (cursor->fg_color|bg_color) xxxfb_cursor() 598 * FB_CUR_SETSHAPE - the cursor bitmask has changed (cursor->mask) xxxfb_cursor() 599 * FB_CUR_SETSIZE - the cursor size has changed (cursor->width|height) xxxfb_cursor() 602 * NOTES ON ROPs (cursor->rop, Raster Operation) xxxfb_cursor() 604 * ROP_XOR - cursor->image.data XOR cursor->mask xxxfb_cursor() 605 * ROP_COPY - curosr->image.data AND cursor->mask xxxfb_cursor() 609 * - fbcon only supports a 2-color cursor (cursor->image.depth = 1) xxxfb_cursor() 610 * - The fb_cursor structure, @cursor, _will_ always contain valid xxxfb_cursor() 611 * fields, whether any particular bitfields in cursor->set is set xxxfb_cursor() 625 * cursor.
|
H A D | sm501fb.c | 108 struct sm501_mem cursor; member in struct:sm501fb_par 1037 * set or change the hardware cursor parameters 1040 static int sm501fb_cursor(struct fb_info *info, struct fb_cursor *cursor) sm501fb_cursor() argument 1048 dev_dbg(fbi->dev, "%s(%p,%p)\n", __func__, info, cursor); sm501fb_cursor() 1057 if (cursor->image.width > 64) sm501fb_cursor() 1060 if (cursor->image.height > 64) sm501fb_cursor() 1063 if (cursor->image.depth > 1) sm501fb_cursor() 1068 if (cursor->enable) sm501fb_cursor() 1076 if (cursor->set & FB_CUR_SETPOS) { sm501fb_cursor() 1077 unsigned int x = cursor->image.dx; sm501fb_cursor() 1078 unsigned int y = cursor->image.dy; sm501fb_cursor() 1085 //y += cursor->image.height; sm501fb_cursor() 1090 if (cursor->set & FB_CUR_SETCMAP) { sm501fb_cursor() 1091 unsigned int bg_col = cursor->image.bg_color; sm501fb_cursor() 1092 unsigned int fg_col = cursor->image.fg_color; sm501fb_cursor() 1111 if (cursor->set & FB_CUR_SETSIZE || sm501fb_cursor() 1112 cursor->set & (FB_CUR_SETIMAGE | FB_CUR_SETSHAPE)) { sm501fb_cursor() 1113 /* SM501 cursor is a two bpp 64x64 bitmap this routine sm501fb_cursor() 1114 * clears it to transparent then combines the cursor sm501fb_cursor() 1116 * cursor */ sm501fb_cursor() 1118 const unsigned char *pcol = cursor->image.data; sm501fb_cursor() 1119 const unsigned char *pmsk = cursor->mask; sm501fb_cursor() 1120 void __iomem *dst = par->cursor.k_addr; sm501fb_cursor() 1126 __func__, cursor->image.width, cursor->image.height); sm501fb_cursor() 1131 for (y = 0; y < cursor->image.height; y++) { sm501fb_cursor() 1132 for (x = 0; x < cursor->image.width; x++) { sm501fb_cursor() 1153 sm501fb_sync_regs(fbi); /* ensure cursor data flushed */ sm501fb_cursor() 1240 * show the crt control and cursor registers 1259 * show the panel control and cursor registers 1477 * initialise hw cursor parameters 1494 ret = sm501_alloc_mem(info, &par->cursor, SM501_MEMF_CURSOR, 1024, sm501_init_cursor() 1501 smc501_writel(par->cursor.sm_addr, sm501_init_cursor() 2118 par->store_cursor = vmalloc(par->cursor.size); sm501fb_suspend_fb() 2120 dev_err(info->dev, "no memory to store cursor\n"); sm501fb_suspend_fb() 2125 dev_dbg(info->dev, "suspending cursor to %p\n", par->store_cursor); sm501fb_suspend_fb() 2128 memcpy_fromio(par->store_cursor, par->cursor.k_addr, par->cursor.size); sm501fb_suspend_fb() 2155 dev_dbg(info->dev, "restoring cursor from %p\n", par->store_cursor); sm501fb_resume_fb() 2162 memcpy_toio(par->cursor.k_addr, par->store_cursor, sm501fb_resume_fb() 2163 par->cursor.size); sm501fb_resume_fb()
|
H A D | cobalt_lcdfb.c | 291 static int cobalt_lcdfb_cursor(struct fb_info *info, struct fb_cursor *cursor) cobalt_lcdfb_cursor() argument 296 switch (cursor->set) { cobalt_lcdfb_cursor() 298 x = cursor->image.dx; cobalt_lcdfb_cursor() 299 y = cursor->image.dy; cobalt_lcdfb_cursor() 318 if (cursor->enable) cobalt_lcdfb_cursor()
|
H A D | controlfb.h | 26 unsigned char crsr; /* cursor palette */ 54 struct preg piped; /* pipe delay hardware cursor */ 86 unsigned piped; /* pipe delay hardware cursor */
|
H A D | hgafb.c | 200 write_hga_b(0x0c, 0x0a); /* cursor start */ hga_txt_mode() 201 write_hga_b(0x0d, 0x0b); /* cursor end */ hga_txt_mode() 204 write_hga_w(0x0000, 0x0e); /* cursor location */ hga_txt_mode() 231 write_hga_b(0x00, 0x0a); /* cursor start */ hga_gfx_mode() 232 write_hga_b(0x00, 0x0b); /* cursor end */ hga_gfx_mode() 235 write_hga_w(0x0000, 0x0e); /* cursor location */ hga_gfx_mode() 312 if (!test_hga_b(0x66, 0x0f)) /* cursor low register */ hga_card_detect() 315 if (!test_hga_b(0x99, 0x0f)) /* cursor low register */ hga_card_detect()
|
H A D | cg14.c | 193 struct cg14_cursor __iomem *cursor; member in struct:cg14_par 458 if (par->cursor) cg14_unmap_regs() 460 par->cursor, sizeof(struct cg14_cursor)); cg14_unmap_regs() 504 par->cursor = of_ioremap(&op->resource[0], CG14_CURSORREGS, cg14_probe() 505 sizeof(struct cg14_cursor), "cg14 cursor"); cg14_probe() 510 if (!par->regs || !par->clut || !par->cursor || !info->screen_base) cg14_probe()
|
H A D | imsttfb.c | 1199 imsttfb_cursor(struct fb_info *info, struct fb_cursor *cursor) 1202 u32 flags = cursor->set, fg, bg, xx, yy; 1204 if (cursor->dest == NULL && cursor->rop == ROP_XOR) 1207 imstt_set_cursor(info, cursor, 0); 1210 xx = cursor->image.dx - info->var.xoffset; 1211 yy = cursor->image.dy - info->var.yoffset; 1218 int fg_idx = cursor->image.fg_color; 1219 int width = (cursor->image.width+7)/8; 1220 u8 *dat = (u8 *) cursor->image.data; 1221 u8 *dst = (u8 *) cursor->dest; 1222 u8 *msk = (u8 *) cursor->mask; 1224 switch (cursor->rop) { 1226 for (i = 0; i < cursor->image.height; i++) { 1238 for (i = 0; i < cursor->image.height; i++) { 1255 if (cursor->enable) 1256 imstt_set_cursor(info, cursor, 1);
|
H A D | neofb.c | 1564 neofb_cursor(struct fb_info *info, struct fb_cursor *cursor) 1568 * Disable cursor * 1571 if (cursor->set & FB_CUR_SETPOS) { 1572 u32 x = cursor->image.dx; 1573 u32 y = cursor->image.dy; 1575 info->cursor.image.dx = x; 1576 info->cursor.image.dy = y; 1581 if (cursor->set & FB_CUR_SETSIZE) { 1582 info->cursor.image.height = cursor->image.height; 1583 info->cursor.image.width = cursor->image.width; 1586 if (cursor->set & FB_CUR_SETHOT) 1587 info->cursor.hot = cursor->hot; 1589 if (cursor->set & FB_CUR_SETCMAP) { 1590 if (cursor->image.depth == 1) { 1591 u32 fg = cursor->image.fg_color; 1592 u32 bg = cursor->image.bg_color; 1594 info->cursor.image.fg_color = fg; 1595 info->cursor.image.bg_color = bg; 1604 if (cursor->set & FB_CUR_SETSHAPE) 1607 if (info->cursor.enable)
|
H A D | bt431.h | 13 * Bt431 cursor generator registers, 32-bit aligned. 125 /* Autoincremented read/write for the cursor map. */ bt431_read_cmap_inc()
|
H A D | tcx.c | 94 u32 thc_cursxy; /* cursor x,y position (16 bits each) */ 95 u32 thc_cursmask[32]; /* cursor mask bits */ 103 u32 cursor; member in struct:bt_regs
|
H A D | maxinefb.c | 142 /* erase hardware cursor */ maxinefb_init()
|
H A D | cg6.c | 184 u32 thc_cursxy; /* cursor x,y position (16 bits each) */ 185 u32 thc_cursmask[32]; /* cursor mask bits */ 251 u32 cursor; member in struct:bt_regs 290 /* Hide the cursor. */ cg6_switch_from_graph() 675 /* Hide the cursor. */ cg6_chip_init()
|
H A D | ffb.c | 359 #define FFB_FLAG_INVCURSOR 0x00000004 /* DAC has inverted cursor logic */ 444 /* Disable cursor. */ ffb_switch_from_graph() 968 * have the reversed meaning of cursor enable. Otherwise, Pacifica 1 ffb_probe() 970 * cursor logic. We identify Pacifica 1 as not Pacifica 2, the ffb_probe()
|
H A D | hyperv_fb.c | 26 * It also solves the double mouse cursor issue of the emulated video mode. 350 * Or, reply with screen and cursor info. 372 /* Reply with screen and cursor info */ synthvid_recv_sub()
|
H A D | bfin-t350mcqb-fb.c | 99 MODULE_PARM_DESC(nocursor, "cursor enable/disable"); 295 int bfin_t350mcqb_fb_cursor(struct fb_info *info, struct fb_cursor *cursor) bfin_t350mcqb_fb_cursor() argument
|
H A D | cirrusfb.c | 928 /* text cursor on and start line */ cirrusfb_set_par_foo() 930 /* text cursor end line */ cirrusfb_set_par_foo() 1557 /* graphics cursor X position (incomplete; position gives rem. 3 bits */ init_vgachip() 1559 /* graphics cursor Y position (..."... ) */ init_vgachip() 1561 /* graphics cursor attributes */ init_vgachip() 1563 /* graphics cursor pattern address */ init_vgachip() 1576 /* Text cursor start: disable text cursor */ init_vgachip() 1578 /* Text cursor end: - */ init_vgachip() 1580 /* text cursor location high: 0 */ init_vgachip() 1582 /* text cursor location low: 0 */ init_vgachip()
|
H A D | bfin_adv7393fb.h | 317 int bfin_adv7393_fb_cursor(struct fb_info *info, struct fb_cursor *cursor);
|
H A D | bw2.c | 59 u32 cursor; member in struct:bt_regs
|
H A D | pmag-ba-fb.c | 130 * Turn the hardware cursor off.
|
/linux-4.4.14/include/linux/ |
H A D | hashtable.h | 117 * @bkt: integer to use as bucket loop cursor 118 * @obj: the type * to use as a loop cursor for each entry 129 * @bkt: integer to use as bucket loop cursor 130 * @obj: the type * to use as a loop cursor for each entry 142 * @bkt: integer to use as bucket loop cursor 144 * @obj: the type * to use as a loop cursor for each entry 156 * @obj: the type * to use as a loop cursor for each entry 168 * @obj: the type * to use as a loop cursor for each entry 180 * @obj: the type * to use as a loop cursor for each entry 195 * @obj: the type * to use as a loop cursor for each entry
|
H A D | list_bl.h | 136 * @tpos: the type * to use as a loop cursor. 137 * @pos: the &struct hlist_node to use as a loop cursor. 150 * @tpos: the type * to use as a loop cursor. 151 * @pos: the &struct hlist_node to use as a loop cursor.
|
H A D | list_nulls.h | 93 * @tpos: the type * to use as a loop cursor. 94 * @pos: the &struct hlist_node to use as a loop cursor. 107 * @tpos: the type * to use as a loop cursor. 108 * @pos: the &struct hlist_node to use as a loop cursor.
|
H A D | list.h | 389 * @pos: the type * to cursor 397 * @pos: the type * to cursor 405 * @pos: the &struct list_head to use as a loop cursor. 413 * @pos: the &struct list_head to use as a loop cursor. 421 * @pos: the &struct list_head to use as a loop cursor. 431 * @pos: the &struct list_head to use as a loop cursor. 442 * @pos: the type * to use as a loop cursor. 453 * @pos: the type * to use as a loop cursor. 475 * @pos: the type * to use as a loop cursor. 489 * @pos: the type * to use as a loop cursor. 503 * @pos: the type * to use as a loop cursor. 515 * @pos: the type * to use as a loop cursor. 528 * @pos: the type * to use as a loop cursor. 544 * @pos: the type * to use as a loop cursor. 559 * @pos: the type * to use as a loop cursor. 575 * @pos: the loop cursor used in the list_for_each_entry_safe loop 581 * exception to this is if the cursor element (pos) is pinned in the list, 710 * @pos: the type * to use as a loop cursor. 721 * @pos: the type * to use as a loop cursor. 731 * @pos: the type * to use as a loop cursor. 740 * @pos: the type * to use as a loop cursor.
|
H A D | rhashtable.h | 377 * @pos: the &struct rhash_head to use as a loop cursor. 389 * @pos: the &struct rhash_head to use as a loop cursor. 398 * @tpos: the type * to use as a loop cursor. 399 * @pos: the &struct rhash_head to use as a loop cursor. 412 * @tpos: the type * to use as a loop cursor. 413 * @pos: the &struct rhash_head to use as a loop cursor. 424 * @tpos: the type * to use as a loop cursor. 425 * @pos: the &struct rhash_head to use as a loop cursor. 426 * @next: the &struct rhash_head to use as next in loop cursor. 432 * remove the loop cursor from the list. 445 * @pos: the &struct rhash_head to use as a loop cursor. 462 * @pos: the &struct rhash_head to use as a loop cursor. 475 * @tpos: the type * to use as a loop cursor. 476 * @pos: the &struct rhash_head to use as a loop cursor. 494 * @tpos: the type * to use as a loop cursor. 495 * @pos: the &struct rhash_head to use as a loop cursor.
|
H A D | rculist.h | 294 * @pos: the type * to use as a loop cursor. 309 * @pos: the type * to use as a loop cursor. 466 * @pos: the type * to use as a loop cursor. 483 * @pos: the type * to use as a loop cursor. 503 * @pos: the type * to use as a loop cursor. 520 * @pos: the type * to use as a loop cursor. 532 * @pos: the type * to use as a loop cursor. 544 * @pos: the type * to use as a loop cursor.
|
H A D | rculist_bl.h | 116 * @tpos: the type * to use as a loop cursor. 117 * @pos: the &struct hlist_bl_node to use as a loop cursor.
|
H A D | rculist_nulls.h | 103 * @tpos: the type * to use as a loop cursor. 104 * @pos: the &struct hlist_nulls_node to use as a loop cursor.
|
H A D | plist.h | 156 * @pos: the type * to use as a loop cursor 186 * @pos: the type * to use as a loop cursor 264 * @pos: the type * to cursor 271 * @pos: the type * to cursor
|
H A D | llist.h | 92 * @pos: the &struct llist_node to use as a loop cursor 109 * @pos: the type * to use as a loop cursor. 130 * @pos: the type * to use as a loop cursor.
|
H A D | svga.h | 112 void svga_tilecursor(void __iomem *regbase, struct fb_info *info, struct fb_tilecursor *cursor);
|
H A D | fb.h | 115 __u16 enable; /* cursor on/off */ 117 const char __user *mask; /* cursor mask bits */ 118 struct fbcurpos hot; /* cursor hot spot */ 278 /* Draws cursor */ 279 int (*fb_cursor) (struct fb_info *info, struct fb_cursor *cursor); 359 __u32 sx; /* cursor position in the x-axis */ 360 __u32 sy; /* cursor position in the y-axis */ 379 /* cursor */ 381 struct fb_tilecursor *cursor);
|
H A D | kbd_kern.h | 59 #define VC_CKMODE 1 /* cursor key mode */
|
H A D | cgroup.h | 135 * @pos: the css * to use as the loop cursor 157 * @pos: the css * to use as the loop cursor 217 * @pos: the css * to use as the loop cursor 240 * @task: the loop cursor 263 * @leader: the loop cursor
|
H A D | console_struct.h | 48 /* cursor */
|
H A D | fsl-diu-fb.h | 146 __be32 cursor; member in struct:diu
|
H A D | rbtree.h | 107 * @pos: the 'type *' to use as a loop cursor.
|
/linux-4.4.14/crypto/asymmetric_keys/ |
H A D | verify_pefile.c | 36 size_t cursor, datalen = pelen; pefile_parse_binary() local 49 cursor = sizeof(*mz); pefile_parse_binary() 51 chkaddr(cursor, mz->peaddr, sizeof(*pe)); pefile_parse_binary() 55 cursor = mz->peaddr + sizeof(*pe); pefile_parse_binary() 57 chkaddr(0, cursor, sizeof(pe32->magic)); pefile_parse_binary() 58 pe32 = pebuf + cursor; pefile_parse_binary() 59 pe64 = pebuf + cursor; pefile_parse_binary() 63 chkaddr(0, cursor, sizeof(*pe32)); pefile_parse_binary() 67 cursor += sizeof(*pe32); pefile_parse_binary() 72 chkaddr(0, cursor, sizeof(*pe64)); pefile_parse_binary() 76 cursor += sizeof(*pe64); pefile_parse_binary() 88 if (cursor >= ctx->header_size || ctx->header_size >= datalen) pefile_parse_binary() 91 if (ctx->n_data_dirents > (ctx->header_size - cursor) / sizeof(*dde)) pefile_parse_binary() 94 ddir = pebuf + cursor; pefile_parse_binary() 95 cursor += sizeof(*dde) * ctx->n_data_dirents; pefile_parse_binary() 115 if (ctx->n_sections > (ctx->header_size - cursor) / sizeof(*sec)) pefile_parse_binary() 117 ctx->secs = secs = pebuf + cursor; pefile_parse_binary()
|
H A D | asymmetric_type.c | 380 struct asymmetric_key_parser *cursor; register_asymmetric_key_parser() local 385 list_for_each_entry(cursor, &asymmetric_key_parsers, link) { register_asymmetric_key_parser() 386 if (strcmp(cursor->name, parser->name) == 0) { register_asymmetric_key_parser()
|
/linux-4.4.14/arch/arm/mach-w90x900/include/mach/ |
H A D | regs-ldm.h | 229 /* Hardware cursor control Register */ 238 /* Hardware cursor memory base address register */ 241 /* Hardware cursor color ram register mapped to bpp = 0 */ 244 /* Hardware cursor color ram register mapped to bpp = 1 */ 247 /* Hardware cursor color ram register mapped to bpp = 2 */ 250 /* Hardware cursor color ram register mapped to bpp = 3 */
|
/linux-4.4.14/drivers/gpu/drm/radeon/ |
H A D | radeon_cursor.c | 147 /* avivo cursor are offset into the total surface */ radeon_cursor_move_locked() 168 * avivo cursor image can't end on 128 pixel boundary or radeon_cursor_move_locked() 265 /* turn off cursor */ radeon_crtc_cursor_set2() 273 DRM_ERROR("bad cursor width or height %d x %d\n", width, height); radeon_crtc_cursor_set2() 279 DRM_ERROR("Cannot find cursor object %x for crtc %d\n", handle, radeon_crtc->crtc_id); radeon_crtc_cursor_set2() 289 /* Only 27 bit offset for legacy cursor */ radeon_crtc_cursor_set2() 295 DRM_ERROR("Failed to pin new cursor BO (%d)\n", ret); radeon_crtc_cursor_set2() 338 * radeon_cursor_reset - Re-set the current cursor, if any. 342 * If the CRTC passed in currently has a cursor assigned, this function
|
H A D | mkregtable.c | 368 * @pos: the &struct list_head to use as a loop cursor. 377 * @pos: the &struct list_head to use as a loop cursor. 386 * @pos: the &struct list_head to use as a loop cursor. 396 * @pos: the &struct list_head to use as a loop cursor. 407 * @pos: the type * to use as a loop cursor. 418 * @pos: the type * to use as a loop cursor. 440 * @pos: the type * to use as a loop cursor. 454 * @pos: the type * to use as a loop cursor. 468 * @pos: the type * to use as a loop cursor. 480 * @pos: the type * to use as a loop cursor. 493 * @pos: the type * to use as a loop cursor. 509 * @pos: the type * to use as a loop cursor. 524 * @pos: the type * to use as a loop cursor.
|
/linux-4.4.14/arch/sparc/include/uapi/asm/ |
H A D | fbio.h | 98 short enable; /* cursor on/off */ 99 struct fbcurpos pos; /* cursor position */ 100 struct fbcurpos hot; /* cursor hot spot */ 102 struct fbcurpos size; /* cursor bit map size */ 103 char __user *image; /* cursor image bits */ 104 char __user *mask; /* cursor mask bits */ 107 /* set/get cursor attributes/shape */ 111 /* set/get cursor position */ 115 /* get max cursor size */
|
/linux-4.4.14/drivers/gpu/drm/virtio/ |
H A D | virtgpu_display.c | 52 output->cursor.hdr.type = cpu_to_le32(VIRTIO_GPU_CMD_UPDATE_CURSOR); virtio_gpu_hide_cursor() 53 output->cursor.resource_id = 0; virtio_gpu_hide_cursor() 77 /* lookup the cursor */ virtio_gpu_crtc_cursor_set() 102 output->cursor.hdr.type = cpu_to_le32(VIRTIO_GPU_CMD_UPDATE_CURSOR); virtio_gpu_crtc_cursor_set() 103 output->cursor.resource_id = cpu_to_le32(qobj->hw_res_handle); virtio_gpu_crtc_cursor_set() 104 output->cursor.hot_x = cpu_to_le32(hot_x); virtio_gpu_crtc_cursor_set() 105 output->cursor.hot_y = cpu_to_le32(hot_y); virtio_gpu_crtc_cursor_set() 121 output->cursor.hdr.type = cpu_to_le32(VIRTIO_GPU_CMD_MOVE_CURSOR); virtio_gpu_crtc_cursor_move() 122 output->cursor.pos.x = cpu_to_le32(x); virtio_gpu_crtc_cursor_move() 123 output->cursor.pos.y = cpu_to_le32(y); virtio_gpu_crtc_cursor_move()
|
H A D | virtgpu_vq.c | 921 output->cursor.pos.scanout_id = cpu_to_le32(output->index); virtio_gpu_cursor_ping() 923 memcpy(cur_p, &output->cursor, sizeof(output->cursor)); virtio_gpu_cursor_ping()
|
H A D | virtgpu_kms.c | 133 static const char *names[] = { "control", "cursor" }; virtio_gpu_driver_load()
|
/linux-4.4.14/fs/xfs/libxfs/ |
H A D | xfs_btree.h | 129 /* cursor operations */ 168 /* difference between key value and cursor value */ 196 * Btree cursor structure. 236 /* cursor flags */ 257 struct xfs_btree_cur *cur, /* btree cursor */ 267 struct xfs_btree_cur *cur, /* btree cursor */ 272 * Delete the btree cursor. 276 xfs_btree_cur_t *cur, /* btree cursor */ 280 * Duplicate the btree cursor. 285 xfs_btree_cur_t *cur, /* input cursor */ 286 xfs_btree_cur_t **ncur);/* output cursor */ 312 * Check for the cursor referring to the last block at the given level. 316 xfs_btree_cur_t *cur, /* btree cursor */
|
H A D | xfs_btree.c | 57 struct xfs_btree_cur *cur, /* btree cursor */ xfs_btree_check_lblock() 102 struct xfs_btree_cur *cur, /* btree cursor */ xfs_btree_check_sblock() 154 struct xfs_btree_cur *cur, /* btree cursor */ xfs_btree_check_block() 170 struct xfs_btree_cur *cur, /* btree cursor */ xfs_btree_check_lptr() 187 struct xfs_btree_cur *cur, /* btree cursor */ xfs_btree_check_sptr() 206 struct xfs_btree_cur *cur, /* btree cursor */ xfs_btree_check_ptr() 298 * Delete the btree cursor. 302 xfs_btree_cur_t *cur, /* btree cursor */ xfs_btree_del_cursor() 324 * Can't free a bmap cursor without having dealt with the xfs_btree_del_cursor() 330 * Free the cursor. xfs_btree_del_cursor() 336 * Duplicate the btree cursor. 341 xfs_btree_cur_t *cur, /* input cursor */ xfs_btree_dup_cursor() 342 xfs_btree_cur_t **ncur) /* output cursor */ xfs_btree_dup_cursor() 348 xfs_btree_cur_t *new; /* new cursor value */ xfs_btree_dup_cursor() 355 * Allocate a new cursor like the old one. xfs_btree_dup_cursor() 360 * Copy the record currently in the cursor. xfs_btree_dup_cursor() 540 * Retrieve the block pointer from the cursor at the given level. 545 struct xfs_btree_cur *cur, /* btree cursor */ xfs_btree_get_block() 598 * Check for the cursor referring to the last block at the given level. 602 xfs_btree_cur_t *cur, /* btree cursor */ xfs_btree_islastblock() 617 * Change the cursor to point to the first record at the given level. 622 xfs_btree_cur_t *cur, /* btree cursor */ xfs_btree_firstrec() 646 * Change the cursor to point to the last record in the current block 651 xfs_btree_cur_t *cur, /* btree cursor */ xfs_btree_lastrec() 837 struct xfs_btree_cur *cur, /* btree cursor */ xfs_btree_readahead() 898 * Set the buffer for level "lev" in the cursor to bp, releasing 903 xfs_btree_cur_t *cur, /* btree cursor */ xfs_btree_setbuf() 1061 * we can pull the owner from the cursor right now as the different xfs_btree_init_block_cur() 1345 struct xfs_btree_cur *cur, /* btree cursor */ xfs_btree_log_ptrs() 1374 struct xfs_btree_cur *cur, /* btree cursor */ xfs_btree_log_block() 1443 * Increment cursor by one record at the level. 1520 * Now walk back down the tree, fixing up the cursor's buffer xfs_btree_increment() 1551 * Decrement cursor by one record at the level. 1619 * Now walk back down the tree, fixing up the cursor's buffer xfs_btree_decrement() 1650 struct xfs_btree_cur *cur, /* btree cursor */ xfs_btree_lookup_get_block() 1708 * Lookup the record. The cursor is made to point to it, based on dir. 1713 struct xfs_btree_cur *cur, /* btree cursor */ xfs_btree_lookup() 1733 /* initialise start pointer from cursor */ xfs_btree_lookup() 1806 * by getting the block number and filling in the cursor. xfs_btree_lookup() 1868 * Update keys at all levels from here to the root along the cursor's path. 1889 * Stop when we reach a level where the cursor isn't pointing xfs_btree_updkey() 2021 * If the cursor entry is the one that would be moved, don't xfs_btree_lshift() 2142 /* Slide the cursor value left one. */ xfs_btree_lshift() 2174 struct xfs_btree_cur *tcur; /* temporary btree cursor */ xfs_btree_rshift() 2204 * If the cursor entry is the one that would be moved, don't xfs_btree_rshift() 2296 * Using a temporary cursor, update the parent key values of the xfs_btree_rshift() 2488 * If the cursor is really in the right block, move it there. __xfs_btree_split() 2497 * If there are more levels, we'll need another cursor which refers __xfs_btree_split() 2498 * the right block, no matter where this cursor was. __xfs_btree_split() 2605 struct xfs_btree_cur *cur, /* btree cursor */ xfs_btree_new_iroot() 2715 struct xfs_btree_cur *cur, /* btree cursor */ xfs_btree_new_root() 2734 /* initialise our start point from the cursor */ xfs_btree_new_root() 2756 * one the cursor is pointing at, so we set up variables "left" and xfs_btree_new_root() 2821 /* Fix up the cursor. */ xfs_btree_new_root() 2839 struct xfs_btree_cur *cur, /* btree cursor */ xfs_btree_make_block_unfull() 2845 struct xfs_btree_cur **ncur, /* new btree cursor */ xfs_btree_make_block_unfull() 2910 struct xfs_btree_cur *cur, /* btree cursor */ xfs_btree_insrec() 2914 struct xfs_btree_cur **curp, /* output: new cursor replacing cur */ xfs_btree_insrec() 2921 struct xfs_btree_cur *ncur; /* new btree cursor */ xfs_btree_insrec() 3095 * If there is one, give back a record value and a cursor too. xfs_btree_insrec() 3116 * cursor. All callers of this function should assume that the cursor is 3128 struct xfs_btree_cur *ncur; /* new cursor (split result) */ xfs_btree_insert() 3129 struct xfs_btree_cur *pcur; /* previous level's cursor */ xfs_btree_insert() 3160 * See if the cursor we just used is trash. xfs_btree_insert() 3161 * Can't trash the caller's cursor, but otherwise we should xfs_btree_insert() 3162 * if ncur is a new cursor or we're about to be done. xfs_btree_insert() 3166 /* Save the state from the cursor before we trash it */ xfs_btree_insert() 3172 /* If we got a new cursor, switch to it. */ xfs_btree_insert() 3364 struct xfs_btree_cur *cur, /* btree cursor */ xfs_btree_delrec() 3386 struct xfs_btree_cur *tcur; /* temporary btree cursor */ xfs_btree_delrec() 3583 * Duplicate the cursor so our btree manipulations here won't xfs_btree_delrec() 3596 * Move the temp cursor to the last entry in the next block. xfs_btree_delrec() 3646 * future reference, and fix up the temp cursor to point xfs_btree_delrec() 3667 * Move the temp cursor to the first entry in the xfs_btree_delrec() 3719 /* Delete the temp cursor, we're done with it. */ xfs_btree_delrec() 3840 * cursor to the left block, and fix up the index. xfs_btree_delrec() 3849 * us, increment the cursor at that level. xfs_btree_delrec() 3860 * still pointing at the deletion point, which makes the cursor xfs_btree_delrec() 3881 * The cursor refers to the place where the record was (could be inserted) 3931 struct xfs_btree_cur *cur, /* btree cursor */ xfs_btree_get_rec()
|
H A D | xfs_alloc.c | 57 struct xfs_btree_cur *cur, /* btree cursor */ xfs_alloc_lookup_eq() 73 struct xfs_btree_cur *cur, /* btree cursor */ xfs_alloc_lookup_ge() 89 struct xfs_btree_cur *cur, /* btree cursor */ xfs_alloc_lookup_le() 106 struct xfs_btree_cur *cur, /* btree cursor */ xfs_alloc_update() 122 struct xfs_btree_cur *cur, /* btree cursor */ xfs_alloc_get_rec() 320 xfs_btree_cur_t *cnt_cur, /* cursor for by-size btree */ xfs_alloc_fixup_trees() 321 xfs_btree_cur_t *bno_cur, /* cursor for by-block btree */ xfs_alloc_fixup_trees() 672 xfs_btree_cur_t *bno_cur;/* by block-number btree cursor */ xfs_alloc_ag_vextent_exact() 673 xfs_btree_cur_t *cnt_cur;/* by count btree cursor */ xfs_alloc_ag_vextent_exact() 685 * Allocate/initialize a cursor for the by-number freespace btree. xfs_alloc_ag_vextent_exact() 743 * Allocate/initialize a cursor for the by-size btree. xfs_alloc_ag_vextent_exact() 777 * Search the btree in a given direction via the search cursor and compare 783 struct xfs_btree_cur **gcur, /* good cursor */ xfs_alloc_find_best_extent() 784 struct xfs_btree_cur **scur, /* searching cursor */ xfs_alloc_find_best_extent() 839 * Choose closer size and invalidate other cursor. xfs_alloc_find_best_extent() 879 xfs_btree_cur_t *bno_cur_gt; /* cursor for bno btree, right side */ xfs_alloc_ag_vextent_near() 880 xfs_btree_cur_t *bno_cur_lt; /* cursor for bno btree, left side */ xfs_alloc_ag_vextent_near() 881 xfs_btree_cur_t *cnt_cur; /* cursor for count btree */ xfs_alloc_ag_vextent_near() 927 * Get a cursor for the by-size btree. xfs_alloc_ag_vextent_near() 957 * in this a.g., then the cursor will be pointing to a btree entry xfs_alloc_ag_vextent_near() 1057 * Set up a cursor for the by-bno tree. xfs_alloc_ag_vextent_near() 1078 * we deallocate that cursor. xfs_alloc_ag_vextent_near() 1086 * Allocate and initialize the cursor for the leftward search. xfs_alloc_ag_vextent_near() 1097 * Didn't find anything; use this cursor for the rightward xfs_alloc_ag_vextent_near() 1104 * Found something. Duplicate the cursor for the rightward search. xfs_alloc_ag_vextent_near() 1109 * Increment the cursor, so we will point at the entry just right xfs_alloc_ag_vextent_near() 1122 * Loop going left with the leftward cursor, right with the xfs_alloc_ag_vextent_near() 1123 * rightward cursor, until either both directions give up or xfs_alloc_ag_vextent_near() 1290 xfs_btree_cur_t *bno_cur; /* cursor for bno btree */ xfs_alloc_ag_vextent_size() 1291 xfs_btree_cur_t *cnt_cur; /* cursor for cnt btree */ xfs_alloc_ag_vextent_size() 1302 * Allocate and initialize a cursor for the by-size btree. xfs_alloc_ag_vextent_size() 1453 * Allocate and initialize a cursor for the by-block tree. xfs_alloc_ag_vextent_size() 1495 xfs_btree_cur_t *ccur, /* by-size cursor */ xfs_alloc_ag_vextent_small() 1589 xfs_btree_cur_t *bno_cur; /* cursor for by-block btree */ xfs_free_ag_extent() 1590 xfs_btree_cur_t *cnt_cur; /* cursor for by-size btree */ xfs_free_ag_extent() 1606 * Allocate and initialize a cursor for the by-block btree. xfs_free_ag_extent() 1666 * Now allocate and initialize a cursor for the by-size tree. xfs_free_ag_extent() 1699 * Move the by-block cursor back to the left neighbor. xfs_free_ag_extent() 1707 * mangle the cursor. xfs_free_ag_extent() 1744 * Back up the by-block cursor to the left neighbor, and xfs_free_ag_extent()
|
H A D | xfs_alloc.h | 217 struct xfs_btree_cur *cur, /* btree cursor */ 224 struct xfs_btree_cur *cur, /* btree cursor */ 231 struct xfs_btree_cur *cur, /* btree cursor */
|
H A D | xfs_bmap_btree.h | 82 * we don't have a cursor.
|
H A D | xfs_alloc_btree.c | 451 * Allocate a new allocation btree cursor. 453 struct xfs_btree_cur * /* new alloc btree cursor */ xfs_allocbt_init_cursor()
|
H A D | xfs_dir2_node.c | 949 xfs_da_state_t *state, /* btree cursor */ xfs_dir2_leafn_rebalance() 1313 xfs_da_state_t *state, /* btree cursor */ xfs_dir2_leafn_split() 1379 xfs_da_state_t *state, /* btree cursor */ xfs_dir2_leafn_toosmall() 1510 xfs_da_state_t *state, /* cursor */ xfs_dir2_leafn_unbalance() 1577 xfs_da_state_t *state; /* btree cursor */ xfs_dir2_node_addname() 1582 * Allocate and initialize the state (btree cursor). xfs_dir2_node_addname() 2020 xfs_da_state_t *state; /* btree cursor */ xfs_dir2_node_lookup() 2025 * Allocate and initialize the btree cursor. xfs_dir2_node_lookup() 2031 * Fill in the path to the entry in the cursor. xfs_dir2_node_lookup() 2073 struct xfs_da_state *state; /* btree cursor */ xfs_dir2_node_removename() 2078 * Allocate and initialize the btree cursor. xfs_dir2_node_removename() 2084 /* Look up the entry we're deleting, set up the cursor. */ xfs_dir2_node_removename() 2142 xfs_da_state_t *state; /* btree cursor */ xfs_dir2_node_replace() 2147 * Allocate and initialize the btree cursor. xfs_dir2_node_replace() 2209 * Release all the buffers in the cursor. xfs_dir2_node_replace()
|
H A D | xfs_bmap_btree.c | 410 * since init cursor doesn't get them. xfs_bmbt_dup_cursor() 776 * Allocate a new bmap btree cursor. 778 struct xfs_btree_cur * /* new bmap btree cursor */ xfs_bmbt_init_cursor()
|
H A D | xfs_ialloc.c | 63 struct xfs_btree_cur *cur, /* btree cursor */ xfs_inobt_lookup() 82 struct xfs_btree_cur *cur, /* btree cursor */ xfs_inobt_update() 105 struct xfs_btree_cur *cur, /* btree cursor */ xfs_inobt_get_rec() 1175 /* duplicate the cursor, search left & right simultaneously */ xfs_dialloc_ag_inobt() 1366 * parent. Note that the provided cursor may be deleted and replaced. 1374 struct xfs_btree_cur *lcur = *ocur; /* left search cursor */ xfs_dialloc_ag_finobt_near() 1375 struct xfs_btree_cur *rcur; /* right search cursor */ xfs_dialloc_ag_finobt_near() 1494 struct xfs_btree_cur *cur, /* inobt cursor */ xfs_dialloc_ag_update_inobt() 1543 struct xfs_btree_cur *cur; /* finobt cursor */ xfs_dialloc_ag() 1544 struct xfs_btree_cur *icur; /* inobt cursor */ xfs_dialloc_ag() 1602 * agi and superblock yet, so we can create an inobt cursor and validate xfs_dialloc_ag() 1911 * Initialize the cursor. xfs_difree_inobt()
|
H A D | xfs_ialloc_btree.c | 379 * Allocate a new inode btree cursor. 381 struct xfs_btree_cur * /* new inode btree cursor */ xfs_inobt_init_cursor()
|
H A D | xfs_bmap.h | 45 struct xfs_btree_cur *cur; /* btree cursor */
|
/linux-4.4.14/lib/ |
H A D | assoc_array.c | 31 const struct assoc_array_ptr *cursor, *ptr, *parent; assoc_array_subtree_iterate() local 35 cursor = root; assoc_array_subtree_iterate() 38 if (assoc_array_ptr_is_shortcut(cursor)) { assoc_array_subtree_iterate() 40 shortcut = assoc_array_ptr_to_shortcut(cursor); assoc_array_subtree_iterate() 42 cursor = ACCESS_ONCE(shortcut->next_node); assoc_array_subtree_iterate() 45 node = assoc_array_ptr_to_node(cursor); assoc_array_subtree_iterate() 88 node = assoc_array_ptr_to_node(cursor); assoc_array_subtree_iterate() 94 cursor = ptr; assoc_array_subtree_iterate() 109 cursor = parent; assoc_array_subtree_iterate() 117 cursor = parent; assoc_array_subtree_iterate() 189 struct assoc_array_ptr *cursor, *ptr; assoc_array_walk() local 197 cursor = ACCESS_ONCE(array->root); assoc_array_walk() 198 if (!cursor) assoc_array_walk() 214 if (assoc_array_ptr_is_shortcut(cursor)) assoc_array_walk() 218 node = assoc_array_ptr_to_node(cursor); assoc_array_walk() 243 cursor = ptr; assoc_array_walk() 254 cursor = ptr; assoc_array_walk() 256 shortcut = assoc_array_ptr_to_shortcut(cursor); assoc_array_walk() 297 cursor = ACCESS_ONCE(shortcut->next_node); assoc_array_walk() 365 struct assoc_array_ptr *cursor, *parent = NULL; assoc_array_destroy_subtree() local 370 cursor = root; assoc_array_destroy_subtree() 371 if (!cursor) { assoc_array_destroy_subtree() 377 if (assoc_array_ptr_is_shortcut(cursor)) { assoc_array_destroy_subtree() 380 BUG_ON(!assoc_array_ptr_is_shortcut(cursor)); assoc_array_destroy_subtree() 381 shortcut = assoc_array_ptr_to_shortcut(cursor); assoc_array_destroy_subtree() 384 parent = cursor; assoc_array_destroy_subtree() 385 cursor = shortcut->next_node; assoc_array_destroy_subtree() 387 BUG_ON(!assoc_array_ptr_is_node(cursor)); assoc_array_destroy_subtree() 391 node = assoc_array_ptr_to_node(cursor); assoc_array_destroy_subtree() 403 parent = cursor; assoc_array_destroy_subtree() 404 cursor = ptr; assoc_array_destroy_subtree() 425 BUG_ON(shortcut->next_node != cursor); assoc_array_destroy_subtree() 426 cursor = parent; assoc_array_destroy_subtree() 439 cursor = parent; assoc_array_destroy_subtree() 440 node = assoc_array_ptr_to_node(cursor); assoc_array_destroy_subtree() 1493 struct assoc_array_ptr *cursor, *ptr; assoc_array_gc() local 1514 cursor = array->root; assoc_array_gc() 1518 * advance the target cursor. assoc_array_gc() 1520 if (assoc_array_ptr_is_shortcut(cursor)) { assoc_array_gc() 1521 shortcut = assoc_array_ptr_to_shortcut(cursor); assoc_array_gc() 1535 cursor = shortcut->next_node; assoc_array_gc() 1539 node = assoc_array_ptr_to_node(cursor); assoc_array_gc() 1568 cursor = ptr; assoc_array_gc() 1728 cursor = shortcut->back_pointer; assoc_array_gc() 1729 if (!cursor) assoc_array_gc() 1733 cursor = ptr; assoc_array_gc() 1735 BUG_ON(!cursor); assoc_array_gc() 1736 node = assoc_array_ptr_to_node(cursor); assoc_array_gc()
|
/linux-4.4.14/arch/parisc/include/asm/ |
H A D | cacheflush.h | 60 void *cursor = vaddr; invalidate_kernel_vmap_range() local 62 for ( ; cursor < vaddr + size; cursor += PAGE_SIZE) { invalidate_kernel_vmap_range() 63 struct page *page = vmalloc_to_page(cursor); invalidate_kernel_vmap_range()
|
/linux-4.4.14/tools/include/linux/ |
H A D | list.h | 25 * @pos: the &struct list_head to use as a loop cursor, from where to start
|
/linux-4.4.14/drivers/hid/ |
H A D | hid-speedlink.c | 3 * Fixes "jumpy" cursor and removes nonexistent keyboard LEDS from 50 /* This fixes the "jumpy" cursor occuring due to invalid events sent speedlink_event()
|
H A D | wacom.h | 37 * - Corrected Intuos protocol decoding (airbrush, 4D mouse, lens cursor...)
|
/linux-4.4.14/drivers/gpu/drm/nouveau/nvkm/engine/disp/ |
H A D | cursnv50.c | 46 nvif_ioctl(parent, "create disp cursor size %d\n", size); nv50_disp_curs_new() 48 nvif_ioctl(parent, "create disp cursor vers %d head %d\n", nv50_disp_curs_new()
|
/linux-4.4.14/net/unix/ |
H A D | garbage.c | 275 struct list_head cursor; unix_gc() local 326 * Use a "cursor" link, to make the list traversal safe, even unix_gc() 329 list_add(&cursor, &gc_candidates); unix_gc() 330 while (cursor.next != &gc_candidates) { unix_gc() 331 u = list_entry(cursor.next, struct unix_sock, link); unix_gc() 333 /* Move cursor to after the current position. */ unix_gc() 334 list_move(&cursor, &u->link); unix_gc() 342 list_del(&cursor); unix_gc()
|
/linux-4.4.14/security/keys/ |
H A D | gc.c | 187 struct rb_node *cursor; key_garbage_collector() local 212 * serial tree, if cursor is non-NULL then it will always point to a key_garbage_collector() 216 cursor = rb_first(&key_serial_tree); key_garbage_collector() 219 while (cursor) { key_garbage_collector() 220 key = rb_entry(cursor, struct key, serial_node); key_garbage_collector() 221 cursor = rb_next(cursor); key_garbage_collector() 266 if (cursor) { key_garbage_collector()
|
/linux-4.4.14/drivers/gpu/drm/nouveau/ |
H A D | nouveau_display.c | 586 if (nv_crtc->cursor.nvbo) { nouveau_display_suspend() 587 if (nv_crtc->cursor.set_offset) nouveau_display_suspend() 588 nouveau_bo_unmap(nv_crtc->cursor.nvbo); nouveau_display_suspend() 589 nouveau_bo_unpin(nv_crtc->cursor.nvbo); nouveau_display_suspend() 618 if (!nv_crtc->cursor.nvbo) nouveau_display_resume() 621 ret = nouveau_bo_pin(nv_crtc->cursor.nvbo, TTM_PL_FLAG_VRAM, true); nouveau_display_resume() 622 if (!ret && nv_crtc->cursor.set_offset) nouveau_display_resume() 623 ret = nouveau_bo_map(nv_crtc->cursor.nvbo); nouveau_display_resume() 625 NV_ERROR(drm, "Could not pin/map cursor.\n"); nouveau_display_resume() 653 if (!nv_crtc->cursor.nvbo) nouveau_display_resume() 656 if (nv_crtc->cursor.set_offset) nouveau_display_resume() 657 nv_crtc->cursor.set_offset(nv_crtc, nv_crtc->cursor.nvbo->bo.offset); nouveau_display_resume() 658 nv_crtc->cursor.set_pos(nv_crtc, nv_crtc->cursor_saved_x, nouveau_display_resume()
|
H A D | nouveau_crtc.h | 63 } cursor; member in struct:nouveau_crtc
|
H A D | nv50_display.c | 950 evo_data(push, nv_crtc->cursor.nvbo->bo.offset >> 8); nv50_crtc_cursor_show() 955 evo_data(push, nv_crtc->cursor.nvbo->bo.offset >> 8); nv50_crtc_cursor_show() 961 evo_data(push, nv_crtc->cursor.nvbo->bo.offset >> 8); nv50_crtc_cursor_show() 967 nv_crtc->cursor.visible = true; nv50_crtc_cursor_show() 993 nv_crtc->cursor.visible = false; nv50_crtc_cursor_hide() 1001 if (show && nv_crtc->cursor.nvbo && nv_crtc->base.enabled) nv50_crtc_cursor_show_hide() 1319 if (nv_crtc->cursor.nvbo) nv50_crtc_cursor_set() 1320 nouveau_bo_unpin(nv_crtc->cursor.nvbo); nv50_crtc_cursor_set() 1321 nouveau_bo_ref(nvbo, &nv_crtc->cursor.nvbo); nv50_crtc_cursor_set() 1393 if (nv_crtc->cursor.nvbo) nv50_crtc_destroy() 1394 nouveau_bo_unpin(nv_crtc->cursor.nvbo); nv50_crtc_destroy() 1395 nouveau_bo_ref(NULL, &nv_crtc->cursor.nvbo); nv50_crtc_destroy() 1447 head->base.cursor.set_pos = nv50_crtc_cursor_restore; nv50_crtc_create() 1475 /* allocate cursor resources */ nv50_crtc_create()
|
/linux-4.4.14/kernel/ |
H A D | audit_tree.c | 587 struct list_head cursor; audit_trim_trees() local 590 list_add(&cursor, &tree_list); audit_trim_trees() 591 while (cursor.next != &tree_list) { audit_trim_trees() 598 tree = container_of(cursor.next, struct audit_tree, list); audit_trim_trees() 600 list_del(&cursor); audit_trim_trees() 601 list_add(&cursor, &tree->list); audit_trim_trees() 629 list_del(&cursor); audit_trim_trees() 781 struct list_head cursor, barrier; audit_tag_tree() local 803 list_add(&cursor, &barrier); audit_tag_tree() 805 while (cursor.next != &tree_list) { audit_tag_tree() 809 tree = container_of(cursor.next, struct audit_tree, list); audit_tag_tree() 811 list_del(&cursor); audit_tag_tree() 812 list_add(&cursor, &tree->list); audit_tag_tree() 867 list_del(&cursor); audit_tag_tree()
|
/linux-4.4.14/drivers/video/fbdev/nvidia/ |
H A D | nvidia.c | 55 /* HW cursor parameters */ 529 static int nvidiafb_cursor(struct fb_info *info, struct fb_cursor *cursor) nvidiafb_cursor() argument 533 int i, set = cursor->set; nvidiafb_cursor() 536 if (cursor->image.width > MAX_CURS || cursor->image.height > MAX_CURS) nvidiafb_cursor() 552 yy = cursor->image.dy - info->var.yoffset; nvidiafb_cursor() 553 xx = cursor->image.dx - info->var.xoffset; nvidiafb_cursor() 561 u32 bg_idx = cursor->image.bg_color; nvidiafb_cursor() 562 u32 fg_idx = cursor->image.fg_color; nvidiafb_cursor() 563 u32 s_pitch = (cursor->image.width + 7) >> 3; nvidiafb_cursor() 565 u8 *dat = (u8 *) cursor->image.data; nvidiafb_cursor() 566 u8 *msk = (u8 *) cursor->mask; nvidiafb_cursor() 569 src = kmalloc(s_pitch * cursor->image.height, GFP_ATOMIC); nvidiafb_cursor() 572 switch (cursor->rop) { nvidiafb_cursor() 574 for (i = 0; i < s_pitch * cursor->image.height; i++) nvidiafb_cursor() 579 for (i = 0; i < s_pitch * cursor->image.height; i++) nvidiafb_cursor() 585 cursor->image.height); nvidiafb_cursor() 598 cursor->image.width, nvidiafb_cursor() 599 cursor->image.height); nvidiafb_cursor() 604 if (cursor->enable) nvidiafb_cursor() 1543 "Enables hardware cursor implementation. (0 or 1=enabled) "
|
/linux-4.4.14/tools/perf/ |
H A D | builtin-timechart.c | 199 struct per_pid *cursor = tchart->all_data; find_create_pid() local 201 while (cursor) { find_create_pid() 202 if (cursor->pid == pid) find_create_pid() 203 return cursor; find_create_pid() 204 cursor = cursor->next; find_create_pid() 206 cursor = zalloc(sizeof(*cursor)); find_create_pid() 207 assert(cursor != NULL); find_create_pid() 208 cursor->pid = pid; find_create_pid() 209 cursor->next = tchart->all_data; find_create_pid() 210 tchart->all_data = cursor; find_create_pid() 211 return cursor; find_create_pid() 968 struct per_pid *new_list, *p, *cursor, *prev; sort_pids() local 984 cursor = new_list; sort_pids() 985 while (cursor) { sort_pids() 986 if (cursor->ppid > p->ppid || sort_pids() 987 (cursor->ppid == p->ppid && cursor->pid > p->pid)) { sort_pids() 992 cursor = NULL; sort_pids() 997 cursor = NULL; sort_pids() 1002 prev = cursor; sort_pids() 1003 cursor = cursor->next; sort_pids() 1004 if (!cursor) sort_pids()
|
/linux-4.4.14/drivers/gpu/drm/atmel-hlcdc/ |
H A D | atmel_hlcdc_dc.h | 110 * @cursor: hardware cursor plane 116 struct atmel_hlcdc_plane *cursor; member in struct:atmel_hlcdc_planes
|
H A D | atmel_hlcdc_crtc.c | 346 planes->cursor ? &planes->cursor->base : NULL, atmel_hlcdc_crtc_create() 353 if (planes->cursor) atmel_hlcdc_crtc_create() 354 planes->cursor->base.possible_crtcs = 1 << crtc->id; atmel_hlcdc_crtc_create()
|
H A D | atmel_hlcdc_dc.c | 112 .name = "cursor", 214 .name = "cursor", 458 if (planes->cursor) atmel_hlcdc_dc_modeset_init() 459 dc->layers[planes->cursor->layer.desc->id] = atmel_hlcdc_dc_modeset_init() 460 &planes->cursor->layer; atmel_hlcdc_dc_modeset_init()
|
/linux-4.4.14/arch/unicore32/include/mach/ |
H A D | regs-unigfx.h | 52 * cursor position UDE_CXY 56 * cursor front color UDE_CC0 60 * cursor background color UDE_CC1
|
/linux-4.4.14/mm/ |
H A D | nobootmem.c | 81 unsigned long cursor, end; free_bootmem_late() local 85 cursor = PFN_UP(addr); free_bootmem_late() 88 for (; cursor < end; cursor++) { free_bootmem_late() 89 __free_pages_bootmem(pfn_to_page(cursor), cursor, 0); free_bootmem_late() local
|
H A D | bootmem.c | 159 unsigned long cursor, end; free_bootmem_late() local 163 cursor = PFN_UP(physaddr); free_bootmem_late() 166 for (; cursor < end; cursor++) { free_bootmem_late() 167 __free_pages_bootmem(pfn_to_page(cursor), cursor, 0); free_bootmem_late() local
|
/linux-4.4.14/drivers/video/fbdev/riva/ |
H A D | fbdev.c | 15 * Jindrich Makovicka: Accel code help, hw cursor, mtrr 87 /* HW cursor parameters */ 465 * cursor stuff 470 * rivafb_load_cursor_image - load cursor image to hardware 473 * @w: width of cursor image in pixels 474 * @h: height of cursor image in scanlines 479 * Loads cursor image based on a monochrome source and mask bitmap. The 817 par->riva.LockUnlock(&par->riva, 0); /* important for HW cursor */ riva_load_video_mode() 1565 * rivafb_cursor - hardware cursor function 1567 * @cursor: pointer to fbcursor structure 1570 * A cursor function that supports displaying a cursor image via hardware. 1577 static int rivafb_cursor(struct fb_info *info, struct fb_cursor *cursor) rivafb_cursor() argument 1581 int i, set = cursor->set; rivafb_cursor() 1584 if (cursor->image.width > MAX_CURS || cursor->image.height > MAX_CURS) rivafb_cursor() 1600 yy = cursor->image.dy - info->var.yoffset; rivafb_cursor() 1601 xx = cursor->image.dx - info->var.xoffset; rivafb_cursor() 1610 u32 bg_idx = cursor->image.bg_color; rivafb_cursor() 1611 u32 fg_idx = cursor->image.fg_color; rivafb_cursor() 1612 u32 s_pitch = (cursor->image.width+7) >> 3; rivafb_cursor() 1614 u8 *dat = (u8 *) cursor->image.data; rivafb_cursor() 1615 u8 *msk = (u8 *) cursor->mask; rivafb_cursor() 1618 src = kmalloc(s_pitch * cursor->image.height, GFP_ATOMIC); rivafb_cursor() 1621 switch (cursor->rop) { rivafb_cursor() 1623 for (i = 0; i < s_pitch * cursor->image.height; i++) rivafb_cursor() 1628 for (i = 0; i < s_pitch * cursor->image.height; i++) rivafb_cursor() 1634 cursor->image.height); rivafb_cursor() 1649 cursor->image.width, rivafb_cursor() 1650 cursor->image.height); rivafb_cursor() 1655 if (cursor->enable) rivafb_cursor()
|
/linux-4.4.14/drivers/video/fbdev/core/ |
H A D | svgalib.c | 301 /* Set cursor in text (tileblit) mode */ svga_tilecursor() 302 void svga_tilecursor(void __iomem *regbase, struct fb_info *info, struct fb_tilecursor *cursor) svga_tilecursor() argument 306 u16 pos = cursor->sx + (info->var.xoffset / 8) svga_tilecursor() 307 + (cursor->sy + (info->var.yoffset / 16)) svga_tilecursor() 310 if (! cursor -> mode) svga_tilecursor() 313 svga_wcrt_mask(regbase, 0x0A, 0x20, 0x20); /* disable cursor */ svga_tilecursor() 315 if (cursor -> shape == FB_TILE_CURSOR_NONE) svga_tilecursor() 318 switch (cursor -> shape) { svga_tilecursor() 336 /* set cursor position */ svga_tilecursor() 340 vga_wcrt(regbase, 0x0B, ce); /* set cursor end */ svga_tilecursor() 341 vga_wcrt(regbase, 0x0A, cs); /* set cursor start and enable it */ svga_tilecursor()
|
/linux-4.4.14/drivers/video/fbdev/i810/ |
H A D | i810_main.c | 81 static int i810fb_cursor(struct fb_info *info, struct fb_cursor *cursor); 765 * i810_enable_cursor - show or hide the hardware cursor 770 * Shows or hides the hardware cursor 844 * i810_init_cursor - initializes the cursor 848 * Initializes the cursor registers 1478 static int i810fb_cursor(struct fb_info *info, struct fb_cursor *cursor) i810fb_cursor() argument 1486 if (cursor->image.width > 64 || cursor->image.height > 64) i810fb_cursor() 1491 cursor->set |= FB_CUR_SETALL; i810fb_cursor() 1496 if (cursor->set & FB_CUR_SETPOS) { i810fb_cursor() 1499 tmp = (cursor->image.dx - info->var.xoffset) & 0xffff; i810fb_cursor() 1500 tmp |= (cursor->image.dy - info->var.yoffset) << 16; i810fb_cursor() 1504 if (cursor->set & FB_CUR_SETSIZE) i810fb_cursor() 1507 if (cursor->set & FB_CUR_SETCMAP) i810fb_cursor() 1508 i810_load_cursor_colors(cursor->image.fg_color, i810fb_cursor() 1509 cursor->image.bg_color, i810fb_cursor() 1512 if (cursor->set & (FB_CUR_SETSHAPE | FB_CUR_SETIMAGE)) { i810fb_cursor() 1513 int size = ((cursor->image.width + 7) >> 3) * i810fb_cursor() 1514 cursor->image.height; i810fb_cursor() 1521 switch (cursor->rop) { i810fb_cursor() 1524 data[i] = cursor->image.data[i] ^ cursor->mask[i]; i810fb_cursor() 1529 data[i] = cursor->image.data[i] & cursor->mask[i]; i810fb_cursor() 1533 i810_load_cursor_image(cursor->image.width, i810fb_cursor() 1534 cursor->image.height, data, i810fb_cursor() 1539 if (cursor->enable) i810fb_cursor() 1695 "cursor memory\n"); i810_alloc_agp_mem() 1701 printk("i810fb_alloc_cursormem: cannot bind cursor memory\n"); i810_alloc_agp_mem()
|
/linux-4.4.14/include/uapi/linux/ |
H A D | screen_info.h | 70 #define VIDEO_FLAGS_NOCURSOR (1 << 0) /* The video mode has no cursor set */
|
H A D | fb.h | 371 * hardware cursor control 388 __u16 enable; /* cursor on/off */ 390 const char *mask; /* cursor mask bits */ 391 struct fbcurpos hot; /* cursor hot spot */
|
H A D | virtio_gpu.h | 70 /* cursor commands */ 99 /* data passed in the cursor vq */
|
/linux-4.4.14/drivers/dma/ppc4xx/ |
H A D | adma.c | 126 struct ppc440spe_rxor *cursor, int index, 2078 static void ppc440spe_init_rxor_cursor(struct ppc440spe_rxor *cursor); 3240 struct ppc440spe_rxor *cursor, int index, int src_cnt) ppc440spe_adma_dma2rxor_inc_addr() 3242 cursor->addr_count++; ppc440spe_adma_dma2rxor_inc_addr() 3244 ppc440spe_desc_set_xor_src_cnt(desc, cursor->addr_count); ppc440spe_adma_dma2rxor_inc_addr() 3245 } else if (cursor->addr_count == XOR_MAX_OPS) { ppc440spe_adma_dma2rxor_inc_addr() 3246 ppc440spe_desc_set_xor_src_cnt(desc, cursor->addr_count); ppc440spe_adma_dma2rxor_inc_addr() 3247 cursor->addr_count = 0; ppc440spe_adma_dma2rxor_inc_addr() 3248 cursor->desc_count++; ppc440spe_adma_dma2rxor_inc_addr() 3257 struct ppc440spe_rxor *cursor, int index, ppc440spe_adma_dma2rxor_prep_src() 3265 for (i = 0; i < cursor->desc_count; i++) { ppc440spe_adma_dma2rxor_prep_src() 3271 switch (cursor->state) { ppc440spe_adma_dma2rxor_prep_src() 3273 if (addr == cursor->addrl + cursor->len) { ppc440spe_adma_dma2rxor_prep_src() 3275 cursor->state = 1; ppc440spe_adma_dma2rxor_prep_src() 3276 cursor->xor_count++; ppc440spe_adma_dma2rxor_prep_src() 3279 cursor->addr_count, ppc440spe_adma_dma2rxor_prep_src() 3282 desc, cursor, index, src_cnt); ppc440spe_adma_dma2rxor_prep_src() 3284 } else if (cursor->addrl == addr + cursor->len) { ppc440spe_adma_dma2rxor_prep_src() 3286 cursor->state = 1; ppc440spe_adma_dma2rxor_prep_src() 3287 cursor->xor_count++; ppc440spe_adma_dma2rxor_prep_src() 3288 set_bit(cursor->addr_count, &desc->reverse_flags[0]); ppc440spe_adma_dma2rxor_prep_src() 3291 cursor->addr_count, ppc440spe_adma_dma2rxor_prep_src() 3294 desc, cursor, index, src_cnt); ppc440spe_adma_dma2rxor_prep_src() 3303 sign = test_bit(cursor->addr_count, ppc440spe_adma_dma2rxor_prep_src() 3307 && addr != cursor->addrl - 2*cursor->len)) { ppc440spe_adma_dma2rxor_prep_src() 3308 cursor->state = 0; ppc440spe_adma_dma2rxor_prep_src() 3309 cursor->xor_count = 1; ppc440spe_adma_dma2rxor_prep_src() 3310 cursor->addrl = addr; ppc440spe_adma_dma2rxor_prep_src() 3312 cursor->addr_count, ppc440spe_adma_dma2rxor_prep_src() 3315 desc, cursor, index, src_cnt); ppc440spe_adma_dma2rxor_prep_src() 3316 } else if (addr == cursor->addrl + 2*sign*cursor->len) { ppc440spe_adma_dma2rxor_prep_src() 3317 cursor->state = 2; ppc440spe_adma_dma2rxor_prep_src() 3318 cursor->xor_count = 0; ppc440spe_adma_dma2rxor_prep_src() 3320 cursor->addr_count, ppc440spe_adma_dma2rxor_prep_src() 3324 desc, cursor, index, src_cnt); ppc440spe_adma_dma2rxor_prep_src() 3326 } else if (addr == cursor->addrl + 3*cursor->len) { ppc440spe_adma_dma2rxor_prep_src() 3327 cursor->state = 2; ppc440spe_adma_dma2rxor_prep_src() 3328 cursor->xor_count = 0; ppc440spe_adma_dma2rxor_prep_src() 3330 cursor->addr_count, ppc440spe_adma_dma2rxor_prep_src() 3334 desc, cursor, index, src_cnt); ppc440spe_adma_dma2rxor_prep_src() 3336 } else if (addr == cursor->addrl + 4*cursor->len) { ppc440spe_adma_dma2rxor_prep_src() 3337 cursor->state = 2; ppc440spe_adma_dma2rxor_prep_src() 3338 cursor->xor_count = 0; ppc440spe_adma_dma2rxor_prep_src() 3340 cursor->addr_count, ppc440spe_adma_dma2rxor_prep_src() 3344 desc, cursor, index, src_cnt); ppc440spe_adma_dma2rxor_prep_src() 3347 cursor->state = 0; ppc440spe_adma_dma2rxor_prep_src() 3348 cursor->xor_count = 1; ppc440spe_adma_dma2rxor_prep_src() 3349 cursor->addrl = addr; ppc440spe_adma_dma2rxor_prep_src() 3351 cursor->addr_count, ppc440spe_adma_dma2rxor_prep_src() 3354 desc, cursor, index, src_cnt); ppc440spe_adma_dma2rxor_prep_src() 3358 cursor->state = 0; ppc440spe_adma_dma2rxor_prep_src() 3359 cursor->addrl = addr; ppc440spe_adma_dma2rxor_prep_src() 3360 cursor->xor_count++; ppc440spe_adma_dma2rxor_prep_src() 3363 desc, cursor, index, src_cnt); ppc440spe_adma_dma2rxor_prep_src() 3454 static void ppc440spe_init_rxor_cursor(struct ppc440spe_rxor *cursor) ppc440spe_init_rxor_cursor() argument 3456 memset(cursor, 0, sizeof(struct ppc440spe_rxor)); ppc440spe_init_rxor_cursor() 3457 cursor->state = 2; ppc440spe_init_rxor_cursor() 3238 ppc440spe_adma_dma2rxor_inc_addr( struct ppc440spe_adma_desc_slot *desc, struct ppc440spe_rxor *cursor, int index, int src_cnt) ppc440spe_adma_dma2rxor_inc_addr() argument 3255 ppc440spe_adma_dma2rxor_prep_src( struct ppc440spe_adma_desc_slot *hdesc, struct ppc440spe_rxor *cursor, int index, int src_cnt, u32 addr) ppc440spe_adma_dma2rxor_prep_src() argument
|
/linux-4.4.14/drivers/block/drbd/ |
H A D | drbd_vli.h | 202 /* for the bitstream, we need a cursor */ 210 /* initialize cursor to point to first bit of stream */ bitstream_cursor_reset() 217 /* advance cursor by that many bits; maximum expected input value: 64, 252 /* Put (at most 64) least significant bits of val into bitstream, and advance cursor. 284 /* Fetch (at most 64) bits from bitstream into *out, and advance cursor.
|
/linux-4.4.14/include/media/davinci/ |
H A D | vpbe_osd.h | 256 * @clut: the CLUT selector (ROM or RAM) for the cursor color 257 * @clut_index: an index into the CLUT for the cursor color 261 * rectangular cursor. 321 /* hardware rectangular cursor parameters */ 382 struct osd_cursor_state cursor; member in struct:osd_state
|
/linux-4.4.14/drivers/video/fbdev/via/ |
H A D | viafbdev.c | 771 static int viafb_cursor(struct fb_info *info, struct fb_cursor *cursor) viafb_cursor() argument 789 if (cursor->set & FB_CUR_SETHOT) { viafb_cursor() 790 temp = (cursor->hot.x << 16) + cursor->hot.y; viafb_cursor() 794 if (cursor->set & FB_CUR_SETPOS) { viafb_cursor() 795 yy = cursor->image.dy - info->var.yoffset; viafb_cursor() 796 xx = cursor->image.dx - info->var.xoffset; viafb_cursor() 802 if (cursor->image.width <= 32 && cursor->image.height <= 32) viafb_cursor() 804 else if (cursor->image.width <= 64 && cursor->image.height <= 64) viafb_cursor() 807 printk(KERN_WARNING "viafb_cursor: The cursor is too large " viafb_cursor() 808 "%dx%d", cursor->image.width, cursor->image.height); viafb_cursor() 812 if (cursor->set & FB_CUR_SETSIZE) { viafb_cursor() 822 if (cursor->set & FB_CUR_SETCMAP) { viafb_cursor() 823 fg_color = cursor->image.fg_color; viafb_cursor() 824 bg_color = cursor->image.bg_color; viafb_cursor() 852 if (cursor->set & FB_CUR_SETSHAPE) { viafb_cursor() 857 int size = ((cursor->image.width + 7) >> 3) * viafb_cursor() 858 cursor->image.height; viafb_cursor() 879 switch (cursor->rop) { viafb_cursor() 882 cr_data->data[i] = cursor->mask[i]; viafb_cursor() 887 cr_data->data[i] = cursor->mask[i]; viafb_cursor() 914 if (cursor->enable) viafb_cursor()
|
H A D | hw.c | 136 {VIACR, CR0A, 0xFF, 0x1E}, /* [0-4] cursor start 137 [5] cursor disable */ 138 {VIACR, CR0B, 0xFF, 0x00}, /* [0-4] cursor end 139 [5-6] cursor skew */ 140 {VIACR, CR0E, 0xFF, 0x00}, /* [0-7] cursor location (high) */ 141 {VIACR, CR0F, 0xFF, 0x00}, /* [0-7] cursor location (low) */
|
H A D | accel.h | 101 /* defines for VIA HW cursor registers */
|
/linux-4.4.14/drivers/gpu/drm/qxl/ |
H A D | qxl_display.c | 310 struct qxl_cursor *cursor; qxl_crtc_cursor_set2() local 323 DRM_ERROR("cannot find cursor object\n"); qxl_crtc_cursor_set2() 357 ret = qxl_bo_kmap(cursor_bo, (void **)&cursor); qxl_crtc_cursor_set2() 361 cursor->header.unique = 0; qxl_crtc_cursor_set2() 362 cursor->header.type = SPICE_CURSOR_TYPE_ALPHA; qxl_crtc_cursor_set2() 363 cursor->header.width = 64; qxl_crtc_cursor_set2() 364 cursor->header.height = 64; qxl_crtc_cursor_set2() 365 cursor->header.hot_spot_x = hot_x; qxl_crtc_cursor_set2() 366 cursor->header.hot_spot_y = hot_y; qxl_crtc_cursor_set2() 367 cursor->data_size = size; qxl_crtc_cursor_set2() 368 cursor->chunk.next_chunk = 0; qxl_crtc_cursor_set2() 369 cursor->chunk.prev_chunk = 0; qxl_crtc_cursor_set2() 370 cursor->chunk.data_size = size; qxl_crtc_cursor_set2() 372 memcpy(cursor->chunk.data, user_ptr, size); qxl_crtc_cursor_set2()
|
/linux-4.4.14/fs/overlayfs/ |
H A D | readdir.c | 52 struct list_head *cursor; member in struct:ovl_dir_file 277 od->cursor = NULL; ovl_dir_reset() 328 od->cursor = p; ovl_seek_cursor() 386 while (od->cursor != &od->cache->entries) { ovl_iterate() 387 p = list_entry(od->cursor, struct ovl_cache_entry, l_node); ovl_iterate() 391 od->cursor = p->l_node.next; ovl_iterate()
|
/linux-4.4.14/drivers/gpu/drm/armada/ |
H A D | armada_hw.h | 182 CFG_CSB_256x32 = 1 << 15, /* cursor */ 186 CFG_PDWN256x32 = 1 << 7, /* power down cursor */
|
H A D | armada_crtc.c | 805 * Calculate the visible width and height of the cursor, armada_drm_crtc_cursor_update() 806 * screen position, and the position in the cursor bitmap. armada_drm_crtc_cursor_update() 834 /* On interlaced modes, the vertical cursor size must be halved */ armada_drm_crtc_cursor_update() 857 * We must also reload the cursor data as well. armada_drm_crtc_cursor_update() 875 /* Set the top-left corner of the cursor image */ armada_drm_crtc_cursor_update() 881 /* Reload the cursor position, size and enable in the IRQ handler */ armada_drm_crtc_cursor_update() 905 /* If no cursor support, replicate drm's return value */ armada_drm_crtc_cursor_set() 956 /* If no cursor support, replicate drm's return value */ armada_drm_crtc_cursor_move()
|
/linux-4.4.14/arch/x86/boot/ |
H A D | video-vga.c | 80 /* Turn off cursor emulation */ vga_set_8font() 103 /* Turn off cursor emulation */ vga_set_14font()
|
H A D | video-bios.c | 103 /* CRTC cursor location low should be zero(?) */ bios_probe()
|
H A D | video.c | 304 /* Restore cursor position */ restore_screen() 311 ireg.ah = 0x02; /* Set cursor position */ restore_screen()
|
/linux-4.4.14/scripts/kconfig/ |
H A D | list.h | 44 * @pos: the type * to use as a loop cursor. 55 * @pos: the type * to use as a loop cursor.
|
H A D | mconf.c | 40 "To change any of these features, highlight it with the cursor\n" 49 "o Use the Up/Down arrow keys (cursor keys) to highlight the item you\n" 60 "o To exit a menu use the cursor keys to highlight the <Exit> button\n" 67 " Also, the <TAB> and cursor keys will cycle between <Select>,\n" 70 "o To get help with an item, use the cursor keys to highlight <Help>\n" 80 "o Use the cursor keys to select the option you wish to set and press\n" 86 "o To see available help for the item, use the cursor keys to highlight\n" 91 " Also, the <TAB> and cursor keys will cycle between <Select> and\n" 101 "o For help, use the <TAB> or cursor keys to highlight the help option\n" 107 "o Use the cursor keys to scroll up/down/left/right. The VI editor\n"
|
H A D | nconf.gui.c | 421 /* show the cursor */ dialog_inputbox() 524 /* hide the cursor */ dialog_inputbox()
|
/linux-4.4.14/tools/usb/usbip/libsrc/ |
H A D | list.h | 107 * @pos: the &struct list_head to use as a loop cursor. 115 * @pos: the &struct list_head to use as a loop cursor.
|
/linux-4.4.14/arch/powerpc/include/asm/ |
H A D | hvsi.h | 66 unsigned int inbuf_pktlen; /* packet lenght from cursor */
|
/linux-4.4.14/arch/mips/include/asm/dec/ |
H A D | kn01.h | 23 #define KN01_PCC (1*KN01_SLOT_SIZE) /* PCC (DC503) cursor */
|
/linux-4.4.14/arch/frv/include/asm/ |
H A D | mb93493-regs.h | 58 #define MB93493_VDC_RCURSOR 0x140 /* cursor position */ 59 #define MB93493_VDC_RCT1 0x144 /* cursor colour 1 */ 60 #define MB93493_VDC_RCT2 0x148 /* cursor colour 2 */ 83 #define VDC_RS_DCSR 0x00000010 /* cursor state */
|
/linux-4.4.14/drivers/gpu/drm/i915/ |
H A D | intel_pm.c | 646 /* cursor SR */ pineview_update_wm() 664 /* cursor HPLL off SR */ pineview_update_wm() 684 const struct intel_watermark_params *cursor, g4x_compute_wm0() 697 *cursor_wm = cursor->guard_size; g4x_compute_wm0() 718 /* Use the large buffer method to calculate cursor watermark */ g4x_compute_wm0() 721 entries = line_count * crtc->cursor->state->crtc_w * pixel_size; g4x_compute_wm0() 722 tlb_miss = cursor->fifo_size*cursor->cacheline_size - hdisplay * 8; g4x_compute_wm0() 725 entries = DIV_ROUND_UP(entries, cursor->cacheline_size); g4x_compute_wm0() 726 *cursor_wm = entries + cursor->guard_size; g4x_compute_wm0() 727 if (*cursor_wm > (int)cursor->max_wm) g4x_compute_wm0() 728 *cursor_wm = (int)cursor->max_wm; g4x_compute_wm0() 743 const struct intel_watermark_params *cursor) g4x_check_srwm() 745 DRM_DEBUG_KMS("SR watermark: display plane %d, cursor %d\n", g4x_check_srwm() 754 if (cursor_wm > cursor->max_wm) { g4x_check_srwm() 755 DRM_DEBUG_KMS("cursor watermark is too large(%d/%ld), disabling\n", g4x_check_srwm() 756 cursor_wm, cursor->max_wm); g4x_check_srwm() 772 const struct intel_watermark_params *cursor, g4x_compute_srwm() 806 /* calculate the self-refresh watermark for display cursor */ g4x_compute_srwm() 807 entries = line_count * pixel_size * crtc->cursor->state->crtc_w; g4x_compute_srwm() 808 entries = DIV_ROUND_UP(entries, cursor->cacheline_size); g4x_compute_srwm() 809 *cursor_wm = entries + cursor->guard_size; g4x_compute_srwm() 813 display, cursor); g4x_compute_srwm() 826 (wm->ddl[pipe].cursor << DDL_CURSOR_SHIFT) | vlv_write_wm_values() 833 FW_WM(wm->pipe[PIPE_B].cursor, CURSORB) | vlv_write_wm_values() 838 FW_WM(wm->pipe[PIPE_A].cursor, CURSORA) | vlv_write_wm_values() 841 FW_WM(wm->sr.cursor, CURSOR_SR)); vlv_write_wm_values() 852 FW_WM(wm->pipe[PIPE_C].cursor, CURSORC)); vlv_write_wm_values() 952 * too big for the cursor FIFO, and hence we vlv_compute_wm_level() 1043 wm_state->sr[level].cursor = 63 - wm_state->sr[level].cursor; vlv_invert_wms() 1049 wm_state->wm[level].cursor = plane->wm.fifo_size - for_each_intel_plane_on_crtc() 1050 wm_state->wm[level].cursor; for_each_intel_plane_on_crtc() 1089 wm_state->sr[level].cursor = 63; vlv_compute_wm() 1115 wm_state->wm[level].cursor = wm; for_each_intel_plane_on_crtc() 1137 wm_state->sr[level].cursor = for_each_intel_plane_on_crtc() 1138 wm_state->wm[level].cursor; for_each_intel_plane_on_crtc() 1297 wm->ddl[pipe].cursor = DDL_PRECISION_HIGH | 2; for_each_intel_crtc() 1334 DRM_DEBUG_KMS("Setting FIFO watermarks - %c: plane=%d, cursor=%d, " vlv_update_wm() 1335 "sprite0=%d, sprite1=%d, SR: plane=%d, cursor=%d level=%d cxsr=%d\n", vlv_update_wm() 1336 pipe_name(pipe), wm.pipe[pipe].primary, wm.pipe[pipe].cursor, vlv_update_wm() 1338 wm.sr.plane, wm.sr.cursor, wm.level, wm.cxsr); vlv_update_wm() 1391 DRM_DEBUG_KMS("Setting FIFO watermarks - A: plane=%d, cursor=%d, " g4x_update_wm() 1392 "B: plane=%d, cursor=%d, SR: plane=%d, cursor=%d\n", g4x_update_wm() 1450 pixel_size * crtc->cursor->state->crtc_w; i965_update_wm() 1460 "cursor %d\n", srwm, cursor_sr); i965_update_wm() 1479 /* update cursor SR watermark */ i965_update_wm() 1902 /* Calculate the maximum cursor plane watermark */ ilk_cursor_wm_max() 2158 /* ILK cursor LP0 latency is 1300 ns */ intel_fixup_cur_wm_latency() 3110 fb = crtc->cursor->state->fb; skl_compute_wm_pipe_parameters() 3115 p->plane[PLANE_CURSOR].horiz_pixels = crtc->cursor->state->crtc_w; skl_compute_wm_pipe_parameters() 3116 p->plane[PLANE_CURSOR].vert_pixels = crtc->cursor->state->crtc_h; skl_compute_wm_pipe_parameters() 3930 wm->ddl[pipe].cursor = for_each_pipe() 3940 wm->pipe[PIPE_B].cursor = _FW_WM(tmp, CURSORB); 3946 wm->pipe[PIPE_A].cursor = _FW_WM(tmp, CURSORA); 3950 wm->sr.cursor = _FW_WM(tmp, CURSOR_SR); 3963 wm->pipe[PIPE_C].cursor = _FW_WM(tmp, CURSORC); 4059 DRM_DEBUG_KMS("Initial watermarks: pipe %c, plane=%d, cursor=%d, sprite0=%d, sprite1=%d\n", 4060 pipe_name(pipe), wm->pipe[pipe].primary, wm->pipe[pipe].cursor, 4063 DRM_DEBUG_KMS("Initial watermarks: SR plane=%d, SR cursor=%d level=%d cxsr=%d\n", 4064 wm->sr.plane, wm->sr.cursor, wm->level, wm->cxsr); 4120 * surface width = hdisplay for normal plane and 64 for cursor 680 g4x_compute_wm0(struct drm_device *dev, int plane, const struct intel_watermark_params *display, int display_latency_ns, const struct intel_watermark_params *cursor, int cursor_latency_ns, int *plane_wm, int *cursor_wm) g4x_compute_wm0() argument 740 g4x_check_srwm(struct drm_device *dev, int display_wm, int cursor_wm, const struct intel_watermark_params *display, const struct intel_watermark_params *cursor) g4x_check_srwm() argument 768 g4x_compute_srwm(struct drm_device *dev, int plane, int latency_ns, const struct intel_watermark_params *display, const struct intel_watermark_params *cursor, int *display_wm, int *cursor_wm) g4x_compute_srwm() argument
|
/linux-4.4.14/scripts/kconfig/lxdialog/ |
H A D | textbox.c | 45 wmove(dialog, cur_y, cur_x); /* Restore cursor position */ refresh_text_box() 134 getyx(dialog, cur_y, cur_x); /* Save cursor position */ dialog_textbox() 347 wmove(win, row, 0); /* move cursor to correct line */ print_line()
|
H A D | menubox.c | 29 * *) Formerly when I used Page Down and Page Up, the cursor would be set 37 * cursor is at the bottom of the box. Now it writes the temporary file
|
/linux-4.4.14/include/drm/ |
H A D | drm_crtc.h | 317 * @cursor_set: setup the cursor 318 * @cursor_set2: setup the cursor with hotspot, superseeds @cursor_set if set 319 * @cursor_move: move the cursor 349 /* cursor controls */ 404 * @cursor: cursor plane for this CRTC 405 * @cursor_x: current x position of the cursor, used for universal cursor planes 406 * @cursor_y: current y position of the cursor, used for universal cursor planes 434 * without a full modeset (fb, cursor data, ...) 440 /* primary and cursor planes for CRTC */ 442 struct drm_plane *cursor; member in struct:drm_crtc 444 /* position of cursor plane on crtc */ 842 * @type: type of plane (overlay, primary, cursor) 925 * @legacy_cursor_update: hint to enforce legacy cursor ioctl semantics 1044 * @cursor_width: hint to userspace for max cursor width 1045 * @cursor_height: hint to userspace for max cursor height 1155 /* cursor size */ 1161 * @plane: the loop cursor 1189 struct drm_plane *cursor,
|
H A D | drm_flip_work.h | 35 * Typically this can be used to defer unref of framebuffer's, cursor
|
H A D | drm_atomic_helper.h | 138 * @plane: the loop cursor 151 * @plane: the loop cursor
|
/linux-4.4.14/drivers/gpu/drm/tegra/ |
H A D | dc.c | 688 /* scaling not supported for cursor */ tegra_cursor_atomic_check() 738 WARN(1, "cursor size %ux%u not supported\n", state->crtc_w, tegra_cursor_atomic_update() 751 /* enable cursor and set blend mode */ tegra_cursor_atomic_update() 765 /* position the cursor */ tegra_cursor_atomic_update() 817 * This index is kind of fake. The cursor isn't a regular plane, but tegra_dc_cursor_plane_create() 821 * need to special-casing the cursor plane. tegra_dc_cursor_plane_create() 1701 struct drm_plane *cursor = NULL; tegra_dc_init() local 1727 cursor = tegra_dc_cursor_plane_create(drm, dc); tegra_dc_init() 1728 if (IS_ERR(cursor)) { tegra_dc_init() 1729 err = PTR_ERR(cursor); tegra_dc_init() 1734 err = drm_crtc_init_with_planes(drm, &dc->base, primary, cursor, tegra_dc_init() 1817 if (cursor) tegra_dc_init() 1818 drm_plane_cleanup(cursor); tegra_dc_init()
|
/linux-4.4.14/drivers/gpu/drm/gma500/ |
H A D | gma_display.c | 197 * This code should probably grow support for turning the cursor off and back 349 /* If we didn't get a handle then turn the cursor off */ gma_crtc_cursor_set() 403 dev_err(dev->dev, "No hardware cursor mem available"); gma_crtc_cursor_set() 414 /* Copy the cursor to cursor mem */ gma_crtc_cursor_set() 430 /* set the pipe for the cursor */ gma_crtc_cursor_set()
|
H A D | psb_intel_display.c | 458 * Set the default value of cursor control and base register 470 /* Allocate 4 pages of stolen mem for a hardware cursor. That psb_intel_cursor_init() 473 cursor_gt = psb_gtt_alloc_range(dev, 4 * PAGE_SIZE, "cursor", 1, psb_intel_cursor_init()
|
H A D | psb_intel_drv.h | 177 /* GEM object that holds our cursor */
|
/linux-4.4.14/drivers/gpu/drm/ |
H A D | drm_modeset_lock.c | 139 * primary or cursor plane) using a hidden acquire context. This is necessary so 143 * Note that @plane can be NULL, e.g. when the cursor support hasn't yet been 196 * Legacy ioctl operations like cursor updates or page flips only have per-crtc
|
H A D | drm_crtc.c | 654 * specified primary and cursor planes. 658 * @cursor: Cursor plane for CRTC 668 struct drm_plane *cursor, drm_crtc_init_with_planes() 675 WARN_ON(cursor && cursor->type != DRM_PLANE_TYPE_CURSOR); drm_crtc_init_with_planes() 691 crtc->cursor = cursor; drm_crtc_init_with_planes() 694 if (cursor) drm_crtc_init_with_planes() 695 cursor->possible_crtcs = 1 << drm_crtc_index(crtc); drm_crtc_init_with_planes() 1152 * @type: type of plane (overlay, primary, cursor) 2783 * drm_mode_cursor_universal - translate legacy cursor ioctl call into a 2785 * @crtc: crtc to update cursor for 2789 * Legacy cursor ioctl's work directly with driver buffer handles. To 2819 BUG_ON(!crtc->cursor); drm_mode_cursor_universal() 2820 WARN_ON(crtc->cursor->crtc != crtc && crtc->cursor->crtc != NULL); drm_mode_cursor_universal() 2831 DRM_DEBUG_KMS("failed to wrap cursor buffer in drm framebuffer\n"); drm_mode_cursor_universal() 2838 fb = crtc->cursor->fb; drm_mode_cursor_universal() 2862 ret = __setplane_internal(crtc->cursor, crtc, fb, drm_mode_cursor_universal() 2866 /* Update successful; save new cursor position, if necessary */ drm_mode_cursor_universal() 2895 * If this crtc has a universal cursor plane, call that plane's update drm_mode_cursor_common() 2896 * handler rather than using legacy cursor handlers. drm_mode_cursor_common() 2898 drm_modeset_lock_crtc(crtc, crtc->cursor); drm_mode_cursor_common() 2899 if (crtc->cursor) { drm_mode_cursor_common() 2909 /* Turns off the cursor if handle is 0 */ drm_mode_cursor_common() 2935 * drm_mode_cursor_ioctl - set CRTC's cursor configuration 2940 * Set the cursor configuration based on user request. 2960 * drm_mode_cursor2_ioctl - set CRTC's cursor configuration 2965 * Set the cursor configuration based on user request. This implements the 2nd 2966 * version of the cursor ioctl, which allows userspace to additionally specify 3569 * avoid upsetting lockdep since the universal cursor code adds a drm_fb_release() 666 drm_crtc_init_with_planes(struct drm_device *dev, struct drm_crtc *crtc, struct drm_plane *primary, struct drm_plane *cursor, const struct drm_crtc_funcs *funcs) drm_crtc_init_with_planes() argument
|
/linux-4.4.14/sound/core/seq/ |
H A D | seq_prioq.c | 180 cur = f->head; /* cursor */ snd_seq_prioq_cell_in() 193 /* move cursor to next cell */ snd_seq_prioq_cell_in() 203 /* insert it before cursor */ snd_seq_prioq_cell_in()
|
/linux-4.4.14/drivers/accessibility/braille/ |
H A D | braille_console.c | 122 /* Follow the VC cursor*/ vc_follow_cursor() 131 /* Maybe the VC cursor moved, if so follow it */ vc_maybe_cursor_moved()
|
/linux-4.4.14/drivers/gpu/drm/msm/ |
H A D | msm_atomic.c | 105 /* Legacy cursor ioctls are completely unsynced, and userspace msm_atomic_wait_for_commit_done() 106 * relies on that (by doing tons of cursor updates). */ msm_atomic_wait_for_commit_done()
|
/linux-4.4.14/arch/x86/kernel/ |
H A D | uprobes.c | 342 u8 *cursor; riprel_analyze() local 355 cursor = auprobe->insn + insn_offset_rex_prefix(insn); riprel_analyze() 357 *cursor &= 0xfe; riprel_analyze() 372 cursor = auprobe->insn + insn_offset_vex_prefix(insn) + 1; riprel_analyze() 373 *cursor |= 0x20; riprel_analyze() 448 * Point cursor at the modrm byte. The next 4 bytes are the riprel_analyze() 452 cursor = auprobe->insn + insn_offset_modrm(insn); riprel_analyze() 458 *cursor = 0x80 | (reg << 3) | reg2; riprel_analyze()
|
/linux-4.4.14/drivers/staging/panel/ |
H A D | panel.c | 127 #define LCD_FLAG_C 0x0008 /* cursor on */ 137 #define LCD_CMD_CURSOR_INC 0x02 /* Increment cursor */ 141 #define LCD_CMD_CURSOR_ON 0x02 /* Set cursor on */ 144 #define LCD_CMD_SHIFT 0x10 /* Shift cursor/display */ 145 #define LCD_CMD_DISPLAY_SHIFT 0x08 /* Shift display instead of cursor */ 146 #define LCD_CMD_SHIFT_RIGHT 0x04 /* Shift display/cursor to the right */ 912 * we force the cursor to stay at the end of the lcd_gotoxy() 927 /* prevents the cursor from wrapping onto the next line */ lcd_print() 1048 /* display off, cursor off, blink off */ lcd_init_display() 1062 /* entry mode set : increment, cursor shifting */ lcd_init_display() 1152 case 'r': /* shift cursor right */ handle_lcd_special_code() 1154 /* allow the cursor to pass the end of the line */ handle_lcd_special_code() 1177 /* restore cursor position */ handle_lcd_special_code() 1386 /* cursor to home */ lcd_write_char()
|
/linux-4.4.14/drivers/gpu/drm/vmwgfx/device_include/ |
H A D | svga_reg.h | 69 * cursor bypass mode. This is still supported, but no new guest 74 #define SVGA_CURSOR_ON_REMOVE_FROM_FB 0x2 /* Remove the cursor from the framebuffer because we need to see what's under it */ 75 #define SVGA_CURSOR_ON_RESTORE_TO_FB 0x3 /* Put the cursor back in the framebuffer so the user can see it */ 358 * enough to fit a 64x64 color-cursor definition. If the command is 784 SVGA_FIFO_CURSOR_LAST_UPDATED,/* Last time the host updated the cursor */ 792 * By default this is SVGA_ID_INVALID, to indicate that the cursor 794 * is set to a specific screen ID, cursor position is reinterpreted 823 * - CURSOR_* (cursor bypass 3) 1448 * Provide a new cursor image, as an AND/XOR mask. 1450 * The recommended way to position the cursor overlay is by using 1480 * Provide a new cursor image, in 32-bit BGRA format. 1482 * The recommended way to position the cursor overlay is by using
|
/linux-4.4.14/drivers/input/tablet/ |
H A D | wacom_serial4.c | 75 * bit 6 Sign of pressure data; or wheel-rel for cursor tool 76 * bit 5 P7; or REL1 for cursor tool 77 * bit 4 P6; or REL0 for cursor tool
|
/linux-4.4.14/drivers/media/rc/keymaps/ |
H A D | rc-ati-x10.c | 41 /* keyboard - Above the cursor pad */
|
/linux-4.4.14/arch/arc/mm/ |
H A D | highmem.c | 22 * It allows mapping LAST_PKMAP pages, using @last_pkmap_nr as the cursor
|
/linux-4.4.14/drivers/gpu/drm/vmwgfx/ |
H A D | vmwgfx_kms.c | 56 SVGAFifoCmdDefineAlphaCursor cursor; vmw_cursor_update_image() member in struct:__anon4947 75 cmd->cursor.id = 0; vmw_cursor_update_image() 76 cmd->cursor.width = width; vmw_cursor_update_image() 77 cmd->cursor.height = height; vmw_cursor_update_image() 78 cmd->cursor.hotspotX = hotspotX; vmw_cursor_update_image() 79 cmd->cursor.hotspotY = hotspotY; vmw_cursor_update_image() 183 DRM_ERROR("surface not suitable for cursor\n"); vmw_du_crtc_cursor_set2() 189 /* takedown old cursor */ vmw_du_crtc_cursor_set2() 228 drm_modeset_lock_crtc(crtc, crtc->cursor); vmw_du_crtc_cursor_set2() 259 drm_modeset_lock_crtc(crtc, crtc->cursor); vmw_du_crtc_cursor_move() 309 DRM_ERROR("Cant snoop dma request for cursor!\n"); vmw_kms_cursor_snoop()
|
H A D | vmwgfx_ldu.c | 135 /* Find the first du with a cursor. */ vmw_ldu_commit_list() 150 DRM_ERROR("Could not update cursor image\n"); vmw_ldu_commit_list()
|
/linux-4.4.14/drivers/s390/char/ |
H A D | tty3270.c | 1038 * current color and highlight. This function does NOT do cursor movement. 1287 * Esc [ 2 K Erase entire line (without moving cursor) 1317 * Esc [ 2 J Erase entire screen (without moving the cursor) 1473 case '7': /* Save cursor position. */ tty3270_escape_sequence() 1479 case '8': /* Restore cursor position. */ tty3270_escape_sequence() 1531 case 'H': /* Set cursor position. */ tty3270_escape_sequence() 1574 case 's': /* Save cursor position. */ tty3270_escape_sequence() 1580 case 'u': /* Restore cursor position. */ tty3270_escape_sequence()
|
H A D | raw3270.h | 32 #define TO_IC 0x13 /* Insert cursor */
|
/linux-4.4.14/fs/configfs/ |
H A D | dir.c | 1506 struct configfs_dirent * cursor = file->private_data; configfs_dir_close() local 1510 list_del_init(&cursor->s_sibling); configfs_dir_close() 1514 release_configfs_dirent(cursor); configfs_dir_close() 1530 struct configfs_dirent *cursor = file->private_data; configfs_readdir() local 1531 struct list_head *p, *q = &cursor->s_sibling; configfs_readdir() 1608 struct configfs_dirent *cursor = file->private_data; configfs_dir_lseek() local 1613 list_del(&cursor->s_sibling); configfs_dir_lseek() 1623 list_add_tail(&cursor->s_sibling, p); configfs_dir_lseek()
|
/linux-4.4.14/drivers/input/mouse/ |
H A D | hgpk.c | 204 * spewing means the cursor will jump all over the place, and act "drunk". 207 * the cursor will move around without really going very far. It will 234 /* Keep a tally of the overall delta to the cursor position caused by hgpk_spewing_hack() 258 /* only recalibrate when the overall delta to the cursor hgpk_spewing_hack() 259 * is really small. if the spew is causing significant cursor hgpk_spewing_hack() 261 * cursor very slowly across the screen. */ hgpk_spewing_hack()
|
/linux-4.4.14/drivers/gpu/drm/ast/ |
H A D | ast_mode.c | 907 /* allocate cursor cache and pin at start of VRAM */ ast_cursor_init() 939 DRM_DEBUG_KMS("pinned cursor cache at %llx\n", ast->cursor_cache_gpu_addr); ast_cursor_init() 1069 /* enable ARGB cursor */ ast_show_cursor() 1162 DRM_ERROR("Cannot find cursor object %x for crtc\n", handle); ast_cursor_set() 1177 DRM_ERROR("src cursor bo should be in main memory\n"); ast_cursor_set() 1183 /* do data transfer to cursor cache */ ast_cursor_set()
|
/linux-4.4.14/fs/ |
H A D | libfs.c | 107 struct dentry *cursor = file->private_data; dcache_dir_lseek() local 111 /* d_lock not required for cursor */ dcache_dir_lseek() 112 list_del(&cursor->d_child); dcache_dir_lseek() 123 list_add_tail(&cursor->d_child, p); dcache_dir_lseek() 147 struct dentry *cursor = file->private_data; dcache_readdir() local 148 struct list_head *p, *q = &cursor->d_child; dcache_readdir()
|
/linux-4.4.14/drivers/net/ethernet/sfc/ |
H A D | ptp.c | 930 struct list_head *cursor; efx_ptp_drop_time_expired_events() local 939 list_for_each_safe(cursor, next, &ptp->evt_list) { efx_ptp_drop_time_expired_events() 942 evt = list_entry(cursor, struct efx_ptp_event_rx, efx_ptp_drop_time_expired_events() 959 struct list_head *cursor; efx_ptp_match_rx() local 976 list_for_each_safe(cursor, next, &ptp->evt_list) { efx_ptp_match_rx() 979 evt = list_entry(cursor, struct efx_ptp_event_rx, link); efx_ptp_match_rx() 1127 struct list_head *cursor; efx_ptp_stop() local 1144 list_for_each_safe(cursor, next, &efx->ptp_data->evt_list) { efx_ptp_stop() 1145 list_move(cursor, &efx->ptp_data->evt_free_list); efx_ptp_stop()
|
/linux-4.4.14/drivers/staging/speakup/ |
H A D | kobjects.c | 705 enum msg_index_t cursor; message_show_helper() local 709 for (cursor = first; cursor <= last; cursor++, index++) { message_show_helper() 713 index, spk_msg_get(cursor)); message_show_helper()
|
/linux-4.4.14/drivers/net/wireless/libertas/ |
H A D | if_spi.c | 83 struct list_head *cursor, *next; free_if_spi_card() local 86 list_for_each_safe(cursor, next, &card->cmd_packet_list) { free_if_spi_card() 87 packet = container_of(cursor, struct if_spi_packet, list); free_if_spi_card() 91 list_for_each_safe(cursor, next, &card->data_packet_list) { free_if_spi_card() 92 packet = container_of(cursor, struct if_spi_packet, list); free_if_spi_card()
|
/linux-4.4.14/drivers/char/ |
H A D | mem.c | 66 u64 cursor = from; range_is_allowed() local 68 while (cursor < to) { range_is_allowed() 75 cursor += PAGE_SIZE; range_is_allowed()
|
/linux-4.4.14/drivers/gpu/drm/rockchip/ |
H A D | rockchip_drm_vop.c | 352 * Note: rk3288 has a dedicated 'cursor' window, however, that window requires 354 * window 3 for the drm cursor. 1458 struct drm_plane *primary = NULL, *cursor = NULL, *plane; vop_create_crtc() local 1465 * Create drm_plane for primary and cursor planes first, since we need vop_create_crtc() 1491 cursor = plane; vop_create_crtc() 1494 ret = drm_crtc_init_with_planes(drm_dev, crtc, primary, cursor, vop_create_crtc()
|
/linux-4.4.14/drivers/gpu/host1x/hw/ |
H A D | debug_hw.c | 112 /* Map dmaget cursor to corresponding mem handle */ show_gather()
|
/linux-4.4.14/drivers/media/pci/solo6x10/ |
H A D | solo6x10-disp.c | 107 /* Load (blank) cursor bitmap mask (2bpp) */ solo_vout_config_cursor()
|