1 // SPDX-License-Identifier: GPL-2.0 2 #include <linux/module.h> 3 #include <linux/kernel.h> 4 #include <linux/errno.h> 5 #include <linux/string.h> 6 #include <linux/mm.h> 7 #include <linux/slab.h> 8 #include <linux/delay.h> 9 #include <linux/fb.h> 10 #include <linux/ioport.h> 11 #include <linux/init.h> 12 #include <linux/pci.h> 13 #include <linux/vmalloc.h> 14 #include <linux/pagemap.h> 15 #include <linux/console.h> 16 #include <linux/platform_device.h> 17 #include <linux/screen_info.h> 18 19 #include "sm750.h" 20 #include "sm750_accel.h" 21 static inline void write_dpr(struct lynx_accel *accel, int offset, u32 regValue) 22 { 23 writel(regValue, accel->dprBase + offset); 24 } 25 26 static inline u32 read_dpr(struct lynx_accel *accel, int offset) 27 { 28 return readl(accel->dprBase + offset); 29 } 30 31 static inline void write_dpPort(struct lynx_accel *accel, u32 data) 32 { 33 writel(data, accel->dpPortBase); 34 } 35 36 void sm750_hw_de_init(struct lynx_accel *accel) 37 { 38 /* setup 2d engine registers */ 39 u32 reg, clr; 40 41 write_dpr(accel, DE_MASKS, 0xFFFFFFFF); 42 43 /* dpr1c */ 44 reg = 0x3; 45 46 clr = DE_STRETCH_FORMAT_PATTERN_XY | 47 DE_STRETCH_FORMAT_PATTERN_Y_MASK | 48 DE_STRETCH_FORMAT_PATTERN_X_MASK | 49 DE_STRETCH_FORMAT_ADDRESSING_MASK | 50 DE_STRETCH_FORMAT_SOURCE_HEIGHT_MASK; 51 52 /* DE_STRETCH bpp format need be initialized in setMode routine */ 53 write_dpr(accel, DE_STRETCH_FORMAT, 54 (read_dpr(accel, DE_STRETCH_FORMAT) & ~clr) | reg); 55 56 /* disable clipping and transparent */ 57 write_dpr(accel, DE_CLIP_TL, 0); /* dpr2c */ 58 write_dpr(accel, DE_CLIP_BR, 0); /* dpr30 */ 59 60 write_dpr(accel, DE_COLOR_COMPARE_MASK, 0); /* dpr24 */ 61 write_dpr(accel, DE_COLOR_COMPARE, 0); 62 63 clr = DE_CONTROL_TRANSPARENCY | DE_CONTROL_TRANSPARENCY_MATCH | 64 DE_CONTROL_TRANSPARENCY_SELECT; 65 66 /* dpr0c */ 67 write_dpr(accel, DE_CONTROL, read_dpr(accel, DE_CONTROL) & ~clr); 68 } 69 70 /* 71 * set2dformat only be called from setmode functions 72 * but if you need dual framebuffer driver,need call set2dformat 73 * every time you use 2d function 74 */ 75 76 void sm750_hw_set2dformat(struct lynx_accel *accel, int fmt) 77 { 78 u32 reg; 79 80 /* fmt=0,1,2 for 8,16,32,bpp on sm718/750/502 */ 81 reg = read_dpr(accel, DE_STRETCH_FORMAT); 82 reg &= ~DE_STRETCH_FORMAT_PIXEL_FORMAT_MASK; 83 reg |= ((fmt << DE_STRETCH_FORMAT_PIXEL_FORMAT_SHIFT) & 84 DE_STRETCH_FORMAT_PIXEL_FORMAT_MASK); 85 write_dpr(accel, DE_STRETCH_FORMAT, reg); 86 } 87 88 int sm750_hw_fillrect(struct lynx_accel *accel, 89 u32 base, u32 pitch, u32 Bpp, 90 u32 x, u32 y, u32 width, u32 height, 91 u32 color, u32 rop) 92 { 93 u32 deCtrl; 94 95 if (accel->de_wait() != 0) { 96 /* 97 * int time wait and always busy,seems hardware 98 * got something error 99 */ 100 pr_debug("De engine always busy\n"); 101 return -1; 102 } 103 104 write_dpr(accel, DE_WINDOW_DESTINATION_BASE, base); /* dpr40 */ 105 write_dpr(accel, DE_PITCH, 106 ((pitch / Bpp << DE_PITCH_DESTINATION_SHIFT) & 107 DE_PITCH_DESTINATION_MASK) | 108 (pitch / Bpp & DE_PITCH_SOURCE_MASK)); /* dpr10 */ 109 110 write_dpr(accel, DE_WINDOW_WIDTH, 111 ((pitch / Bpp << DE_WINDOW_WIDTH_DST_SHIFT) & 112 DE_WINDOW_WIDTH_DST_MASK) | 113 (pitch / Bpp & DE_WINDOW_WIDTH_SRC_MASK)); /* dpr44 */ 114 115 write_dpr(accel, DE_FOREGROUND, color); /* DPR14 */ 116 117 write_dpr(accel, DE_DESTINATION, 118 ((x << DE_DESTINATION_X_SHIFT) & DE_DESTINATION_X_MASK) | 119 (y & DE_DESTINATION_Y_MASK)); /* dpr4 */ 120 121 write_dpr(accel, DE_DIMENSION, 122 ((width << DE_DIMENSION_X_SHIFT) & DE_DIMENSION_X_MASK) | 123 (height & DE_DIMENSION_Y_ET_MASK)); /* dpr8 */ 124 125 deCtrl = DE_CONTROL_STATUS | DE_CONTROL_LAST_PIXEL | 126 DE_CONTROL_COMMAND_RECTANGLE_FILL | DE_CONTROL_ROP_SELECT | 127 (rop & DE_CONTROL_ROP_MASK); /* dpr0xc */ 128 129 write_dpr(accel, DE_CONTROL, deCtrl); 130 return 0; 131 } 132 133 /** 134 * sm750_hm_copyarea 135 * @sBase: Address of source: offset in frame buffer 136 * @sPitch: Pitch value of source surface in BYTE 137 * @sx: Starting x coordinate of source surface 138 * @sy: Starting y coordinate of source surface 139 * @dBase: Address of destination: offset in frame buffer 140 * @dPitch: Pitch value of destination surface in BYTE 141 * @Bpp: Color depth of destination surface 142 * @dx: Starting x coordinate of destination surface 143 * @dy: Starting y coordinate of destination surface 144 * @width: width of rectangle in pixel value 145 * @height: height of rectangle in pixel value 146 * @rop2: ROP value 147 */ 148 int sm750_hw_copyarea(struct lynx_accel *accel, 149 unsigned int sBase, unsigned int sPitch, 150 unsigned int sx, unsigned int sy, 151 unsigned int dBase, unsigned int dPitch, 152 unsigned int Bpp, unsigned int dx, unsigned int dy, 153 unsigned int width, unsigned int height, 154 unsigned int rop2) 155 { 156 unsigned int nDirection, de_ctrl; 157 158 nDirection = LEFT_TO_RIGHT; 159 /* Direction of ROP2 operation: 1 = Left to Right, (-1) = Right to Left */ 160 de_ctrl = 0; 161 162 /* If source and destination are the same surface, need to check for overlay cases */ 163 if (sBase == dBase && sPitch == dPitch) { 164 /* Determine direction of operation */ 165 if (sy < dy) { 166 /* +----------+ 167 * |S | 168 * | +----------+ 169 * | | | | 170 * | | | | 171 * +---|------+ | 172 * | D| 173 * +----------+ 174 */ 175 176 nDirection = BOTTOM_TO_TOP; 177 } else if (sy > dy) { 178 /* +----------+ 179 * |D | 180 * | +----------+ 181 * | | | | 182 * | | | | 183 * +---|------+ | 184 * | S| 185 * +----------+ 186 */ 187 188 nDirection = TOP_TO_BOTTOM; 189 } else { 190 /* sy == dy */ 191 192 if (sx <= dx) { 193 /* +------+---+------+ 194 * |S | | D| 195 * | | | | 196 * | | | | 197 * | | | | 198 * +------+---+------+ 199 */ 200 201 nDirection = RIGHT_TO_LEFT; 202 } else { 203 /* sx > dx */ 204 205 /* +------+---+------+ 206 * |D | | S| 207 * | | | | 208 * | | | | 209 * | | | | 210 * +------+---+------+ 211 */ 212 213 nDirection = LEFT_TO_RIGHT; 214 } 215 } 216 } 217 218 if ((nDirection == BOTTOM_TO_TOP) || (nDirection == RIGHT_TO_LEFT)) { 219 sx += width - 1; 220 sy += height - 1; 221 dx += width - 1; 222 dy += height - 1; 223 } 224 225 /* 226 * Note: 227 * DE_FOREGROUND and DE_BACKGROUND are don't care. 228 * DE_COLOR_COMPARE and DE_COLOR_COMPARE_MAKS 229 * are set by set deSetTransparency(). 230 */ 231 232 /* 233 * 2D Source Base. 234 * It is an address offset (128 bit aligned) 235 * from the beginning of frame buffer. 236 */ 237 write_dpr(accel, DE_WINDOW_SOURCE_BASE, sBase); /* dpr40 */ 238 239 /* 240 * 2D Destination Base. 241 * It is an address offset (128 bit aligned) 242 * from the beginning of frame buffer. 243 */ 244 write_dpr(accel, DE_WINDOW_DESTINATION_BASE, dBase); /* dpr44 */ 245 246 /* 247 * Program pitch (distance between the 1st points of two adjacent lines). 248 * Note that input pitch is BYTE value, but the 2D Pitch register uses 249 * pixel values. Need Byte to pixel conversion. 250 */ 251 write_dpr(accel, DE_PITCH, 252 ((dPitch / Bpp << DE_PITCH_DESTINATION_SHIFT) & 253 DE_PITCH_DESTINATION_MASK) | 254 (sPitch / Bpp & DE_PITCH_SOURCE_MASK)); /* dpr10 */ 255 256 /* 257 * Screen Window width in Pixels. 258 * 2D engine uses this value to calculate the linear address in frame buffer 259 * for a given point. 260 */ 261 write_dpr(accel, DE_WINDOW_WIDTH, 262 ((dPitch / Bpp << DE_WINDOW_WIDTH_DST_SHIFT) & 263 DE_WINDOW_WIDTH_DST_MASK) | 264 (sPitch / Bpp & DE_WINDOW_WIDTH_SRC_MASK)); /* dpr3c */ 265 266 if (accel->de_wait() != 0) 267 return -1; 268 269 write_dpr(accel, DE_SOURCE, 270 ((sx << DE_SOURCE_X_K1_SHIFT) & DE_SOURCE_X_K1_MASK) | 271 (sy & DE_SOURCE_Y_K2_MASK)); /* dpr0 */ 272 write_dpr(accel, DE_DESTINATION, 273 ((dx << DE_DESTINATION_X_SHIFT) & DE_DESTINATION_X_MASK) | 274 (dy & DE_DESTINATION_Y_MASK)); /* dpr04 */ 275 write_dpr(accel, DE_DIMENSION, 276 ((width << DE_DIMENSION_X_SHIFT) & DE_DIMENSION_X_MASK) | 277 (height & DE_DIMENSION_Y_ET_MASK)); /* dpr08 */ 278 279 de_ctrl = (rop2 & DE_CONTROL_ROP_MASK) | DE_CONTROL_ROP_SELECT | 280 ((nDirection == RIGHT_TO_LEFT) ? DE_CONTROL_DIRECTION : 0) | 281 DE_CONTROL_COMMAND_BITBLT | DE_CONTROL_STATUS; 282 write_dpr(accel, DE_CONTROL, de_ctrl); /* dpr0c */ 283 284 return 0; 285 } 286 287 static unsigned int deGetTransparency(struct lynx_accel *accel) 288 { 289 unsigned int de_ctrl; 290 291 de_ctrl = read_dpr(accel, DE_CONTROL); 292 293 de_ctrl &= (DE_CONTROL_TRANSPARENCY_MATCH | 294 DE_CONTROL_TRANSPARENCY_SELECT | DE_CONTROL_TRANSPARENCY); 295 296 return de_ctrl; 297 } 298 299 /** 300 * sm750_hw_imageblit 301 * @pSrcbuf: pointer to start of source buffer in system memory 302 * @srcDelta: Pitch value (in bytes) of the source buffer, +ive means top down 303 * and -ive mean button up 304 * @startBit: Mono data can start at any bit in a byte, this value should be 305 * 0 to 7 306 * @dBase: Address of destination: offset in frame buffer 307 * @dPitch: Pitch value of destination surface in BYTE 308 * @bytePerPixel: Color depth of destination surface 309 * @dx: Starting x coordinate of destination surface 310 * @dy: Starting y coordinate of destination surface 311 * @width: width of rectangle in pixel value 312 * @height: height of rectangle in pixel value 313 * @fColor: Foreground color (corresponding to a 1 in the monochrome data 314 * @bColor: Background color (corresponding to a 0 in the monochrome data 315 * @rop2: ROP value 316 */ 317 int sm750_hw_imageblit(struct lynx_accel *accel, const char *pSrcbuf, 318 u32 srcDelta, u32 startBit, u32 dBase, u32 dPitch, 319 u32 bytePerPixel, u32 dx, u32 dy, u32 width, 320 u32 height, u32 fColor, u32 bColor, u32 rop2) 321 { 322 unsigned int ulBytesPerScan; 323 unsigned int ul4BytesPerScan; 324 unsigned int ulBytesRemain; 325 unsigned int de_ctrl = 0; 326 unsigned char ajRemain[4]; 327 int i, j; 328 329 startBit &= 7; /* Just make sure the start bit is within legal range */ 330 ulBytesPerScan = (width + startBit + 7) / 8; 331 ul4BytesPerScan = ulBytesPerScan & ~3; 332 ulBytesRemain = ulBytesPerScan & 3; 333 334 if (accel->de_wait() != 0) 335 return -1; 336 337 /* 338 * 2D Source Base. 339 * Use 0 for HOST Blt. 340 */ 341 write_dpr(accel, DE_WINDOW_SOURCE_BASE, 0); 342 343 /* 2D Destination Base. 344 * It is an address offset (128 bit aligned) 345 * from the beginning of frame buffer. 346 */ 347 write_dpr(accel, DE_WINDOW_DESTINATION_BASE, dBase); 348 349 /* 350 * Program pitch (distance between the 1st points of two adjacent 351 * lines). Note that input pitch is BYTE value, but the 2D Pitch 352 * register uses pixel values. Need Byte to pixel conversion. 353 */ 354 write_dpr(accel, DE_PITCH, 355 ((dPitch / bytePerPixel << DE_PITCH_DESTINATION_SHIFT) & 356 DE_PITCH_DESTINATION_MASK) | 357 (dPitch / bytePerPixel & DE_PITCH_SOURCE_MASK)); /* dpr10 */ 358 359 /* 360 * Screen Window width in Pixels. 361 * 2D engine uses this value to calculate the linear address 362 * in frame buffer for a given point. 363 */ 364 write_dpr(accel, DE_WINDOW_WIDTH, 365 ((dPitch / bytePerPixel << DE_WINDOW_WIDTH_DST_SHIFT) & 366 DE_WINDOW_WIDTH_DST_MASK) | 367 (dPitch / bytePerPixel & DE_WINDOW_WIDTH_SRC_MASK)); 368 369 /* 370 * Note: For 2D Source in Host Write, only X_K1_MONO field is needed, 371 * and Y_K2 field is not used. 372 * For mono bitmap, use startBit for X_K1. 373 */ 374 write_dpr(accel, DE_SOURCE, 375 (startBit << DE_SOURCE_X_K1_SHIFT) & 376 DE_SOURCE_X_K1_MONO_MASK); /* dpr00 */ 377 378 write_dpr(accel, DE_DESTINATION, 379 ((dx << DE_DESTINATION_X_SHIFT) & DE_DESTINATION_X_MASK) | 380 (dy & DE_DESTINATION_Y_MASK)); /* dpr04 */ 381 382 write_dpr(accel, DE_DIMENSION, 383 ((width << DE_DIMENSION_X_SHIFT) & DE_DIMENSION_X_MASK) | 384 (height & DE_DIMENSION_Y_ET_MASK)); /* dpr08 */ 385 386 write_dpr(accel, DE_FOREGROUND, fColor); 387 write_dpr(accel, DE_BACKGROUND, bColor); 388 389 de_ctrl = (rop2 & DE_CONTROL_ROP_MASK) | 390 DE_CONTROL_ROP_SELECT | DE_CONTROL_COMMAND_HOST_WRITE | 391 DE_CONTROL_HOST | DE_CONTROL_STATUS; 392 393 write_dpr(accel, DE_CONTROL, de_ctrl | deGetTransparency(accel)); 394 395 /* Write MONO data (line by line) to 2D Engine data port */ 396 for (i = 0; i < height; i++) { 397 /* For each line, send the data in chunks of 4 bytes */ 398 for (j = 0; j < (ul4BytesPerScan / 4); j++) 399 write_dpPort(accel, *(unsigned int *)(pSrcbuf + (j * 4))); 400 401 if (ulBytesRemain) { 402 memcpy(ajRemain, pSrcbuf + ul4BytesPerScan, 403 ulBytesRemain); 404 write_dpPort(accel, *(unsigned int *)ajRemain); 405 } 406 407 pSrcbuf += srcDelta; 408 } 409 410 return 0; 411 } 412 413