Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * Copyright 2019 NXP.
0004  */
0005 
0006 #include <linux/device.h>
0007 #include <linux/slab.h>
0008 
0009 #include "dcss-dev.h"
0010 
0011 #define DCSS_DPR_SYSTEM_CTRL0           0x000
0012 #define   RUN_EN                BIT(0)
0013 #define   SOFT_RESET                BIT(1)
0014 #define   REPEAT_EN             BIT(2)
0015 #define   SHADOW_LOAD_EN            BIT(3)
0016 #define   SW_SHADOW_LOAD_SEL            BIT(4)
0017 #define   BCMD2AXI_MSTR_ID_CTRL         BIT(16)
0018 #define DCSS_DPR_IRQ_MASK           0x020
0019 #define DCSS_DPR_IRQ_MASK_STATUS        0x030
0020 #define DCSS_DPR_IRQ_NONMASK_STATUS     0x040
0021 #define   IRQ_DPR_CTRL_DONE         BIT(0)
0022 #define   IRQ_DPR_RUN               BIT(1)
0023 #define   IRQ_DPR_SHADOW_LOADED         BIT(2)
0024 #define   IRQ_AXI_READ_ERR          BIT(3)
0025 #define   DPR2RTR_YRGB_FIFO_OVFL        BIT(4)
0026 #define   DPR2RTR_UV_FIFO_OVFL          BIT(5)
0027 #define   DPR2RTR_FIFO_LD_BUF_RDY_YRGB_ERR  BIT(6)
0028 #define   DPR2RTR_FIFO_LD_BUF_RDY_UV_ERR    BIT(7)
0029 #define DCSS_DPR_MODE_CTRL0         0x050
0030 #define   RTR_3BUF_EN               BIT(0)
0031 #define   RTR_4LINE_BUF_EN          BIT(1)
0032 #define   TILE_TYPE_POS             2
0033 #define   TILE_TYPE_MASK            GENMASK(4, 2)
0034 #define   YUV_EN                BIT(6)
0035 #define   COMP_2PLANE_EN            BIT(7)
0036 #define   PIX_SIZE_POS              8
0037 #define   PIX_SIZE_MASK             GENMASK(9, 8)
0038 #define   PIX_LUMA_UV_SWAP          BIT(10)
0039 #define   PIX_UV_SWAP               BIT(11)
0040 #define   B_COMP_SEL_POS            12
0041 #define   B_COMP_SEL_MASK           GENMASK(13, 12)
0042 #define   G_COMP_SEL_POS            14
0043 #define   G_COMP_SEL_MASK           GENMASK(15, 14)
0044 #define   R_COMP_SEL_POS            16
0045 #define   R_COMP_SEL_MASK           GENMASK(17, 16)
0046 #define   A_COMP_SEL_POS            18
0047 #define   A_COMP_SEL_MASK           GENMASK(19, 18)
0048 #define DCSS_DPR_FRAME_CTRL0            0x070
0049 #define   HFLIP_EN              BIT(0)
0050 #define   VFLIP_EN              BIT(1)
0051 #define   ROT_ENC_POS               2
0052 #define   ROT_ENC_MASK              GENMASK(3, 2)
0053 #define   ROT_FLIP_ORDER_EN         BIT(4)
0054 #define   PITCH_POS             16
0055 #define   PITCH_MASK                GENMASK(31, 16)
0056 #define DCSS_DPR_FRAME_1P_CTRL0         0x090
0057 #define DCSS_DPR_FRAME_1P_PIX_X_CTRL        0x0A0
0058 #define DCSS_DPR_FRAME_1P_PIX_Y_CTRL        0x0B0
0059 #define DCSS_DPR_FRAME_1P_BASE_ADDR     0x0C0
0060 #define DCSS_DPR_FRAME_2P_CTRL0         0x0E0
0061 #define DCSS_DPR_FRAME_2P_PIX_X_CTRL        0x0F0
0062 #define DCSS_DPR_FRAME_2P_PIX_Y_CTRL        0x100
0063 #define DCSS_DPR_FRAME_2P_BASE_ADDR     0x110
0064 #define DCSS_DPR_STATUS_CTRL0           0x130
0065 #define   STATUS_MUX_SEL_MASK           GENMASK(2, 0)
0066 #define   STATUS_SRC_SEL_POS            16
0067 #define   STATUS_SRC_SEL_MASK           GENMASK(18, 16)
0068 #define DCSS_DPR_STATUS_CTRL1           0x140
0069 #define DCSS_DPR_RTRAM_CTRL0            0x200
0070 #define   NUM_ROWS_ACTIVE           BIT(0)
0071 #define   THRES_HIGH_POS            1
0072 #define   THRES_HIGH_MASK           GENMASK(3, 1)
0073 #define   THRES_LOW_POS             4
0074 #define   THRES_LOW_MASK            GENMASK(6, 4)
0075 #define   ABORT_SEL             BIT(7)
0076 
0077 enum dcss_tile_type {
0078     TILE_LINEAR = 0,
0079     TILE_GPU_STANDARD,
0080     TILE_GPU_SUPER,
0081     TILE_VPU_YUV420,
0082     TILE_VPU_VP9,
0083 };
0084 
0085 enum dcss_pix_size {
0086     PIX_SIZE_8,
0087     PIX_SIZE_16,
0088     PIX_SIZE_32,
0089 };
0090 
0091 struct dcss_dpr_ch {
0092     struct dcss_dpr *dpr;
0093     void __iomem *base_reg;
0094     u32 base_ofs;
0095 
0096     struct drm_format_info format;
0097     enum dcss_pix_size pix_size;
0098     enum dcss_tile_type tile;
0099     bool rtram_4line_en;
0100     bool rtram_3buf_en;
0101 
0102     u32 frame_ctrl;
0103     u32 mode_ctrl;
0104     u32 sys_ctrl;
0105     u32 rtram_ctrl;
0106 
0107     bool sys_ctrl_chgd;
0108 
0109     int ch_num;
0110     int irq;
0111 };
0112 
0113 struct dcss_dpr {
0114     struct device *dev;
0115     struct dcss_ctxld *ctxld;
0116     u32  ctx_id;
0117 
0118     struct dcss_dpr_ch ch[3];
0119 };
0120 
0121 static void dcss_dpr_write(struct dcss_dpr_ch *ch, u32 val, u32 ofs)
0122 {
0123     struct dcss_dpr *dpr = ch->dpr;
0124 
0125     dcss_ctxld_write(dpr->ctxld, dpr->ctx_id, val, ch->base_ofs + ofs);
0126 }
0127 
0128 static int dcss_dpr_ch_init_all(struct dcss_dpr *dpr, unsigned long dpr_base)
0129 {
0130     struct dcss_dpr_ch *ch;
0131     int i;
0132 
0133     for (i = 0; i < 3; i++) {
0134         ch = &dpr->ch[i];
0135 
0136         ch->base_ofs = dpr_base + i * 0x1000;
0137 
0138         ch->base_reg = ioremap(ch->base_ofs, SZ_4K);
0139         if (!ch->base_reg) {
0140             dev_err(dpr->dev, "dpr: unable to remap ch %d base\n",
0141                 i);
0142             return -ENOMEM;
0143         }
0144 
0145         ch->dpr = dpr;
0146         ch->ch_num = i;
0147 
0148         dcss_writel(0xff, ch->base_reg + DCSS_DPR_IRQ_MASK);
0149     }
0150 
0151     return 0;
0152 }
0153 
0154 int dcss_dpr_init(struct dcss_dev *dcss, unsigned long dpr_base)
0155 {
0156     struct dcss_dpr *dpr;
0157 
0158     dpr = kzalloc(sizeof(*dpr), GFP_KERNEL);
0159     if (!dpr)
0160         return -ENOMEM;
0161 
0162     dcss->dpr = dpr;
0163     dpr->dev = dcss->dev;
0164     dpr->ctxld = dcss->ctxld;
0165     dpr->ctx_id = CTX_SB_HP;
0166 
0167     if (dcss_dpr_ch_init_all(dpr, dpr_base)) {
0168         int i;
0169 
0170         for (i = 0; i < 3; i++) {
0171             if (dpr->ch[i].base_reg)
0172                 iounmap(dpr->ch[i].base_reg);
0173         }
0174 
0175         kfree(dpr);
0176 
0177         return -ENOMEM;
0178     }
0179 
0180     return 0;
0181 }
0182 
0183 void dcss_dpr_exit(struct dcss_dpr *dpr)
0184 {
0185     int ch_no;
0186 
0187     /* stop DPR on all channels */
0188     for (ch_no = 0; ch_no < 3; ch_no++) {
0189         struct dcss_dpr_ch *ch = &dpr->ch[ch_no];
0190 
0191         dcss_writel(0, ch->base_reg + DCSS_DPR_SYSTEM_CTRL0);
0192 
0193         if (ch->base_reg)
0194             iounmap(ch->base_reg);
0195     }
0196 
0197     kfree(dpr);
0198 }
0199 
0200 static u32 dcss_dpr_x_pix_wide_adjust(struct dcss_dpr_ch *ch, u32 pix_wide,
0201                       u32 pix_format)
0202 {
0203     u8 pix_in_64byte_map[3][5] = {
0204         /* LIN, GPU_STD, GPU_SUP, VPU_YUV420, VPU_VP9 */
0205         {   64,       8,       8,          8,     16}, /* PIX_SIZE_8  */
0206         {   32,       8,       8,          8,      8}, /* PIX_SIZE_16 */
0207         {   16,       4,       4,          8,      8}, /* PIX_SIZE_32 */
0208     };
0209     u32 offset;
0210     u32 div_64byte_mod, pix_in_64byte;
0211 
0212     pix_in_64byte = pix_in_64byte_map[ch->pix_size][ch->tile];
0213 
0214     div_64byte_mod = pix_wide % pix_in_64byte;
0215     offset = (div_64byte_mod == 0) ? 0 : (pix_in_64byte - div_64byte_mod);
0216 
0217     return pix_wide + offset;
0218 }
0219 
0220 static u32 dcss_dpr_y_pix_high_adjust(struct dcss_dpr_ch *ch, u32 pix_high,
0221                       u32 pix_format)
0222 {
0223     u8 num_rows_buf = ch->rtram_4line_en ? 4 : 8;
0224     u32 offset, pix_y_mod;
0225 
0226     pix_y_mod = pix_high % num_rows_buf;
0227     offset = pix_y_mod ? (num_rows_buf - pix_y_mod) : 0;
0228 
0229     return pix_high + offset;
0230 }
0231 
0232 void dcss_dpr_set_res(struct dcss_dpr *dpr, int ch_num, u32 xres, u32 yres)
0233 {
0234     struct dcss_dpr_ch *ch = &dpr->ch[ch_num];
0235     u32 pix_format = ch->format.format;
0236     u32 gap = DCSS_DPR_FRAME_2P_BASE_ADDR - DCSS_DPR_FRAME_1P_BASE_ADDR;
0237     int plane, max_planes = 1;
0238     u32 pix_x_wide, pix_y_high;
0239 
0240     if (pix_format == DRM_FORMAT_NV12 ||
0241         pix_format == DRM_FORMAT_NV21)
0242         max_planes = 2;
0243 
0244     for (plane = 0; plane < max_planes; plane++) {
0245         yres = plane == 1 ? yres >> 1 : yres;
0246 
0247         pix_x_wide = dcss_dpr_x_pix_wide_adjust(ch, xres, pix_format);
0248         pix_y_high = dcss_dpr_y_pix_high_adjust(ch, yres, pix_format);
0249 
0250         dcss_dpr_write(ch, pix_x_wide,
0251                    DCSS_DPR_FRAME_1P_PIX_X_CTRL + plane * gap);
0252         dcss_dpr_write(ch, pix_y_high,
0253                    DCSS_DPR_FRAME_1P_PIX_Y_CTRL + plane * gap);
0254 
0255         dcss_dpr_write(ch, 2, DCSS_DPR_FRAME_1P_CTRL0 + plane * gap);
0256     }
0257 }
0258 
0259 void dcss_dpr_addr_set(struct dcss_dpr *dpr, int ch_num, u32 luma_base_addr,
0260                u32 chroma_base_addr, u16 pitch)
0261 {
0262     struct dcss_dpr_ch *ch = &dpr->ch[ch_num];
0263 
0264     dcss_dpr_write(ch, luma_base_addr, DCSS_DPR_FRAME_1P_BASE_ADDR);
0265 
0266     dcss_dpr_write(ch, chroma_base_addr, DCSS_DPR_FRAME_2P_BASE_ADDR);
0267 
0268     ch->frame_ctrl &= ~PITCH_MASK;
0269     ch->frame_ctrl |= (((u32)pitch << PITCH_POS) & PITCH_MASK);
0270 }
0271 
0272 static void dcss_dpr_argb_comp_sel(struct dcss_dpr_ch *ch, int a_sel, int r_sel,
0273                    int g_sel, int b_sel)
0274 {
0275     u32 sel;
0276 
0277     sel = ((a_sel << A_COMP_SEL_POS) & A_COMP_SEL_MASK) |
0278           ((r_sel << R_COMP_SEL_POS) & R_COMP_SEL_MASK) |
0279           ((g_sel << G_COMP_SEL_POS) & G_COMP_SEL_MASK) |
0280           ((b_sel << B_COMP_SEL_POS) & B_COMP_SEL_MASK);
0281 
0282     ch->mode_ctrl &= ~(A_COMP_SEL_MASK | R_COMP_SEL_MASK |
0283                G_COMP_SEL_MASK | B_COMP_SEL_MASK);
0284     ch->mode_ctrl |= sel;
0285 }
0286 
0287 static void dcss_dpr_pix_size_set(struct dcss_dpr_ch *ch,
0288                   const struct drm_format_info *format)
0289 {
0290     u32 val;
0291 
0292     switch (format->format) {
0293     case DRM_FORMAT_NV12:
0294     case DRM_FORMAT_NV21:
0295         val = PIX_SIZE_8;
0296         break;
0297 
0298     case DRM_FORMAT_UYVY:
0299     case DRM_FORMAT_VYUY:
0300     case DRM_FORMAT_YUYV:
0301     case DRM_FORMAT_YVYU:
0302         val = PIX_SIZE_16;
0303         break;
0304 
0305     default:
0306         val = PIX_SIZE_32;
0307         break;
0308     }
0309 
0310     ch->pix_size = val;
0311 
0312     ch->mode_ctrl &= ~PIX_SIZE_MASK;
0313     ch->mode_ctrl |= ((val << PIX_SIZE_POS) & PIX_SIZE_MASK);
0314 }
0315 
0316 static void dcss_dpr_uv_swap(struct dcss_dpr_ch *ch, bool swap)
0317 {
0318     ch->mode_ctrl &= ~PIX_UV_SWAP;
0319     ch->mode_ctrl |= (swap ? PIX_UV_SWAP : 0);
0320 }
0321 
0322 static void dcss_dpr_y_uv_swap(struct dcss_dpr_ch *ch, bool swap)
0323 {
0324     ch->mode_ctrl &= ~PIX_LUMA_UV_SWAP;
0325     ch->mode_ctrl |= (swap ? PIX_LUMA_UV_SWAP : 0);
0326 }
0327 
0328 static void dcss_dpr_2plane_en(struct dcss_dpr_ch *ch, bool en)
0329 {
0330     ch->mode_ctrl &= ~COMP_2PLANE_EN;
0331     ch->mode_ctrl |= (en ? COMP_2PLANE_EN : 0);
0332 }
0333 
0334 static void dcss_dpr_yuv_en(struct dcss_dpr_ch *ch, bool en)
0335 {
0336     ch->mode_ctrl &= ~YUV_EN;
0337     ch->mode_ctrl |= (en ? YUV_EN : 0);
0338 }
0339 
0340 void dcss_dpr_enable(struct dcss_dpr *dpr, int ch_num, bool en)
0341 {
0342     struct dcss_dpr_ch *ch = &dpr->ch[ch_num];
0343     u32 sys_ctrl;
0344 
0345     sys_ctrl = (en ? REPEAT_EN | RUN_EN : 0);
0346 
0347     if (en) {
0348         dcss_dpr_write(ch, ch->mode_ctrl, DCSS_DPR_MODE_CTRL0);
0349         dcss_dpr_write(ch, ch->frame_ctrl, DCSS_DPR_FRAME_CTRL0);
0350         dcss_dpr_write(ch, ch->rtram_ctrl, DCSS_DPR_RTRAM_CTRL0);
0351     }
0352 
0353     if (ch->sys_ctrl != sys_ctrl)
0354         ch->sys_ctrl_chgd = true;
0355 
0356     ch->sys_ctrl = sys_ctrl;
0357 }
0358 
0359 struct rgb_comp_sel {
0360     u32 drm_format;
0361     int a_sel;
0362     int r_sel;
0363     int g_sel;
0364     int b_sel;
0365 };
0366 
0367 static struct rgb_comp_sel comp_sel_map[] = {
0368     {DRM_FORMAT_ARGB8888, 3, 2, 1, 0},
0369     {DRM_FORMAT_XRGB8888, 3, 2, 1, 0},
0370     {DRM_FORMAT_ABGR8888, 3, 0, 1, 2},
0371     {DRM_FORMAT_XBGR8888, 3, 0, 1, 2},
0372     {DRM_FORMAT_RGBA8888, 0, 3, 2, 1},
0373     {DRM_FORMAT_RGBX8888, 0, 3, 2, 1},
0374     {DRM_FORMAT_BGRA8888, 0, 1, 2, 3},
0375     {DRM_FORMAT_BGRX8888, 0, 1, 2, 3},
0376 };
0377 
0378 static int to_comp_sel(u32 pix_fmt, int *a_sel, int *r_sel, int *g_sel,
0379                int *b_sel)
0380 {
0381     int i;
0382 
0383     for (i = 0; i < ARRAY_SIZE(comp_sel_map); i++) {
0384         if (comp_sel_map[i].drm_format == pix_fmt) {
0385             *a_sel = comp_sel_map[i].a_sel;
0386             *r_sel = comp_sel_map[i].r_sel;
0387             *g_sel = comp_sel_map[i].g_sel;
0388             *b_sel = comp_sel_map[i].b_sel;
0389 
0390             return 0;
0391         }
0392     }
0393 
0394     return -1;
0395 }
0396 
0397 static void dcss_dpr_rtram_set(struct dcss_dpr_ch *ch, u32 pix_format)
0398 {
0399     u32 val, mask;
0400 
0401     switch (pix_format) {
0402     case DRM_FORMAT_NV21:
0403     case DRM_FORMAT_NV12:
0404         ch->rtram_3buf_en = true;
0405         ch->rtram_4line_en = false;
0406         break;
0407 
0408     default:
0409         ch->rtram_3buf_en = true;
0410         ch->rtram_4line_en = true;
0411         break;
0412     }
0413 
0414     val = (ch->rtram_4line_en ? RTR_4LINE_BUF_EN : 0);
0415     val |= (ch->rtram_3buf_en ? RTR_3BUF_EN : 0);
0416     mask = RTR_4LINE_BUF_EN | RTR_3BUF_EN;
0417 
0418     ch->mode_ctrl &= ~mask;
0419     ch->mode_ctrl |= (val & mask);
0420 
0421     val = (ch->rtram_4line_en ? 0 : NUM_ROWS_ACTIVE);
0422     val |= (3 << THRES_LOW_POS) & THRES_LOW_MASK;
0423     val |= (4 << THRES_HIGH_POS) & THRES_HIGH_MASK;
0424     mask = THRES_LOW_MASK | THRES_HIGH_MASK | NUM_ROWS_ACTIVE;
0425 
0426     ch->rtram_ctrl &= ~mask;
0427     ch->rtram_ctrl |= (val & mask);
0428 }
0429 
0430 static void dcss_dpr_setup_components(struct dcss_dpr_ch *ch,
0431                       const struct drm_format_info *format)
0432 {
0433     int a_sel, r_sel, g_sel, b_sel;
0434     bool uv_swap, y_uv_swap;
0435 
0436     switch (format->format) {
0437     case DRM_FORMAT_YVYU:
0438         uv_swap = true;
0439         y_uv_swap = true;
0440         break;
0441 
0442     case DRM_FORMAT_VYUY:
0443     case DRM_FORMAT_NV21:
0444         uv_swap = true;
0445         y_uv_swap = false;
0446         break;
0447 
0448     case DRM_FORMAT_YUYV:
0449         uv_swap = false;
0450         y_uv_swap = true;
0451         break;
0452 
0453     default:
0454         uv_swap = false;
0455         y_uv_swap = false;
0456         break;
0457     }
0458 
0459     dcss_dpr_uv_swap(ch, uv_swap);
0460 
0461     dcss_dpr_y_uv_swap(ch, y_uv_swap);
0462 
0463     if (!format->is_yuv) {
0464         if (!to_comp_sel(format->format, &a_sel, &r_sel,
0465                  &g_sel, &b_sel)) {
0466             dcss_dpr_argb_comp_sel(ch, a_sel, r_sel, g_sel, b_sel);
0467         } else {
0468             dcss_dpr_argb_comp_sel(ch, 3, 2, 1, 0);
0469         }
0470     } else {
0471         dcss_dpr_argb_comp_sel(ch, 0, 0, 0, 0);
0472     }
0473 }
0474 
0475 static void dcss_dpr_tile_set(struct dcss_dpr_ch *ch, uint64_t modifier)
0476 {
0477     switch (ch->ch_num) {
0478     case 0:
0479         switch (modifier) {
0480         case DRM_FORMAT_MOD_LINEAR:
0481             ch->tile = TILE_LINEAR;
0482             break;
0483         case DRM_FORMAT_MOD_VIVANTE_TILED:
0484             ch->tile = TILE_GPU_STANDARD;
0485             break;
0486         case DRM_FORMAT_MOD_VIVANTE_SUPER_TILED:
0487             ch->tile = TILE_GPU_SUPER;
0488             break;
0489         default:
0490             WARN_ON(1);
0491             break;
0492         }
0493         break;
0494     case 1:
0495     case 2:
0496         ch->tile = TILE_LINEAR;
0497         break;
0498     default:
0499         WARN_ON(1);
0500         return;
0501     }
0502 
0503     ch->mode_ctrl &= ~TILE_TYPE_MASK;
0504     ch->mode_ctrl |= ((ch->tile << TILE_TYPE_POS) & TILE_TYPE_MASK);
0505 }
0506 
0507 void dcss_dpr_format_set(struct dcss_dpr *dpr, int ch_num,
0508              const struct drm_format_info *format, u64 modifier)
0509 {
0510     struct dcss_dpr_ch *ch = &dpr->ch[ch_num];
0511 
0512     ch->format = *format;
0513 
0514     dcss_dpr_yuv_en(ch, format->is_yuv);
0515 
0516     dcss_dpr_pix_size_set(ch, format);
0517 
0518     dcss_dpr_setup_components(ch, format);
0519 
0520     dcss_dpr_2plane_en(ch, format->num_planes == 2);
0521 
0522     dcss_dpr_rtram_set(ch, format->format);
0523 
0524     dcss_dpr_tile_set(ch, modifier);
0525 }
0526 
0527 /* This function will be called from interrupt context. */
0528 void dcss_dpr_write_sysctrl(struct dcss_dpr *dpr)
0529 {
0530     int chnum;
0531 
0532     dcss_ctxld_assert_locked(dpr->ctxld);
0533 
0534     for (chnum = 0; chnum < 3; chnum++) {
0535         struct dcss_dpr_ch *ch = &dpr->ch[chnum];
0536 
0537         if (ch->sys_ctrl_chgd) {
0538             dcss_ctxld_write_irqsafe(dpr->ctxld, dpr->ctx_id,
0539                          ch->sys_ctrl,
0540                          ch->base_ofs +
0541                          DCSS_DPR_SYSTEM_CTRL0);
0542             ch->sys_ctrl_chgd = false;
0543         }
0544     }
0545 }
0546 
0547 void dcss_dpr_set_rotation(struct dcss_dpr *dpr, int ch_num, u32 rotation)
0548 {
0549     struct dcss_dpr_ch *ch = &dpr->ch[ch_num];
0550 
0551     ch->frame_ctrl &= ~(HFLIP_EN | VFLIP_EN | ROT_ENC_MASK);
0552 
0553     ch->frame_ctrl |= rotation & DRM_MODE_REFLECT_X ? HFLIP_EN : 0;
0554     ch->frame_ctrl |= rotation & DRM_MODE_REFLECT_Y ? VFLIP_EN : 0;
0555 
0556     if (rotation & DRM_MODE_ROTATE_90)
0557         ch->frame_ctrl |= 1 << ROT_ENC_POS;
0558     else if (rotation & DRM_MODE_ROTATE_180)
0559         ch->frame_ctrl |= 2 << ROT_ENC_POS;
0560     else if (rotation & DRM_MODE_ROTATE_270)
0561         ch->frame_ctrl |= 3 << ROT_ENC_POS;
0562 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!