PCem: f22b6152c221 src/vid

PCem

view src/vid_tgui9440.c @ 131:f22b6152c221

Fixed memory mapping on ISA video cards - should now work on Award 430VX PCI.

author	TomW
date	Wed Jul 16 20:00:34 2014 +0100
parents	614f796ff7ed
children	24b744b9a632

line source

1 /*Trident TGUI9440 emulation*/

2 #include <stdlib.h>

3 #include "ibm.h"

4 #include "device.h"

5 #include "io.h"

6 #include "mem.h"

7 #include "rom.h"

8 #include "video.h"

9 #include "vid_svga.h"

10 #include "vid_svga_render.h"

11 #include "vid_tkd8001_ramdac.h"

12 #include "vid_tgui9440.h"

14 typedef struct tgui_t

15 {

16 mem_mapping_t linear_mapping;

17 mem_mapping_t accel_mapping;

19 rom_t bios_rom;

21 svga_t svga;

23 struct

24 {

25 uint16_t src_x, src_y;

26 uint16_t dst_x, dst_y;

27 uint16_t size_x, size_y;

28 uint16_t fg_col, bg_col;

29 uint8_t rop;

30 uint16_t flags;

31 uint8_t pattern[0x80];

32 int command;

33 int offset;

34 uint8_t ger22;

36 int x, y;

37 uint32_t src, dst, src_old, dst_old;

38 int pat_x, pat_y;

39 int use_src;

41 int pitch, bpp;

43 uint16_t tgui_pattern[8][8];

44 } accel;

46 uint8_t tgui_3d8, tgui_3d9;

47 int oldmode;

48 uint8_t oldctrl2,newctrl2;

50 uint32_t linear_base, linear_size;

52 int ramdac_state;

53 uint8_t ramdac_ctrl;

55 int clock_m, clock_n, clock_k;

57 uint32_t vram_size, vram_mask;

58 } tgui_t;

60 void tgui_recalcmapping(tgui_t *tgui);

63 uint8_t tgui_accel_read(uint32_t addr, void *priv);

64 uint16_t tgui_accel_read_w(uint32_t addr, void *priv);

65 uint32_t tgui_accel_read_l(uint32_t addr, void *priv);

67 void tgui_accel_write(uint32_t addr, uint8_t val, void *priv);

68 void tgui_accel_write_w(uint32_t addr, uint16_t val, void *priv);

69 void tgui_accel_write_l(uint32_t addr, uint32_t val, void *priv);

72 void tgui_accel_write_fb_l(uint32_t addr, uint32_t val, void *priv);

74 void tgui_out(uint16_t addr, uint8_t val, void *p)

75 {

76 tgui_t *tgui = (tgui_t *)p;

77 svga_t *svga = &tgui->svga;

79 uint8_t old;

81 // pclog("tgui_out : %04X %02X %04X:%04X %i\n", addr, val, CS,pc, svga->bpp);

82 if (((addr&0xFFF0) == 0x3D0 || (addr&0xFFF0) == 0x3B0) && !(svga->miscout & 1)) addr ^= 0x60;

84 switch (addr)

85 {

86 case 0x3C5:

87 switch (svga->seqaddr & 0xf)

88 {

89 case 0xB:

90 tgui->oldmode=1;

91 break;

92 case 0xC:

93 if (svga->seqregs[0xe] & 0x80)

94 svga->seqregs[0xc] = val;

95 break;

96 case 0xd:

97 if (tgui->oldmode)

98 tgui->oldctrl2 = val;

99 else

100 tgui->newctrl2=val;

101 break;

102 case 0xE:

103 svga->seqregs[0xe] = val ^ 2;

104 svga->write_bank = (svga->seqregs[0xe] & 0xf) * 65536;

105 if (!(svga->gdcreg[0xf] & 1))

106 svga->read_bank = svga->write_bank;

107 return;

108 }

109 break;

110

111 case 0x3C6:

112 if (tgui->ramdac_state == 4)

113 {

114 tgui->ramdac_state = 0;

115 tgui->ramdac_ctrl = val;

116 switch (tgui->ramdac_ctrl & 0xf0)

117 {

118 case 0x10:

119 svga->bpp = 15;

120 break;

121 case 0x30:

122 svga->bpp = 16;

123 break;

124 case 0xd0:

125 svga->bpp = 24;

126 break;

127 default:

128 svga->bpp = 8;

129 break;

130 }

131 return;

132 }

133 case 0x3C7: case 0x3C8: case 0x3C9:

134 tgui->ramdac_state = 0;

135 break;

136

137 case 0x3CF:

138 switch (svga->gdcaddr & 15)

139 {

140 case 0x6:

141 if (svga->gdcreg[6] != val)

142 {

143 svga->gdcreg[6] = val;

144 tgui_recalcmapping(tgui);

145 }

146 return;

147

148 case 0xE:

149 svga->gdcreg[0xe] = val ^ 2;

150 if ((svga->gdcreg[0xf] & 1) == 1)

151 svga->read_bank = (svga->gdcreg[0xe] & 0xf) * 65536;

152 break;

153 case 0xF:

154 if (val & 1) svga->read_bank = (svga->gdcreg[0xe] & 0xf) *65536;

155 else svga->read_bank = (svga->seqregs[0xe] & 0xf) *65536;

156 svga->write_bank = (svga->seqregs[0xe] & 0xf) * 65536;

157 break;

158 }

159 break;

160 case 0x3D4:

161 svga->crtcreg = val & 0x7f;

162 return;

163 case 0x3D5:

164 if (svga->crtcreg <= 7 && svga->crtc[0x11] & 0x80) return;

165 old = svga->crtc[svga->crtcreg];

166 svga->crtc[svga->crtcreg] = val;

167 // if (svga->crtcreg != 0xE && svga->crtcreg != 0xF) pclog("CRTC R%02X = %02X\n", svga->crtcreg, val);

168 if (old != val)

169 {

170 if (svga->crtcreg < 0xE || svga->crtcreg > 0x10)

171 {

172 svga->fullchange = changeframecount;

173 svga_recalctimings(svga);

174 }

175 }

176 switch (svga->crtcreg)

177 {

178 case 0x21:

179 if (old != val)

180 {

181 if (!PCI)

182 {

183 tgui->linear_base = ((val & 0xf) | ((val >> 2) & 0x30)) << 20;

184 tgui->linear_size = (val & 0x10) ? 0x200000 : 0x100000;

185 }

186 tgui_recalcmapping(tgui);

187 }

188 break;

189

190 case 0x40: case 0x41: case 0x42: case 0x43:

191 case 0x44: case 0x45: case 0x46: case 0x47:

192 svga->hwcursor.x = (svga->crtc[0x40] | (svga->crtc[0x41] << 8)) & 0x7ff;

193 svga->hwcursor.y = (svga->crtc[0x42] | (svga->crtc[0x43] << 8)) & 0x7ff;

194 svga->hwcursor.xoff = svga->crtc[0x46] & 0x3f;

195 svga->hwcursor.yoff = svga->crtc[0x47] & 0x3f;

196 svga->hwcursor.addr = (svga->crtc[0x44] << 10) | ((svga->crtc[0x45] & 0x7) << 18) | (svga->hwcursor.yoff * 8);

197 break;

198

199 case 0x50:

200 svga->hwcursor.ena = val & 0x80;

201 break;

202 }

203 return;

204 case 0x3D8:

205 tgui->tgui_3d8 = val;

206 if (svga->gdcreg[0xf] & 4)

207 {

208 svga->write_bank = (val & 0x1f) * 65536;

209 // pclog("SVGAWBANK 3D8 %08X %04X:%04X\n",svgawbank,CS,pc);

210 if (!(svga->gdcreg[0xf] & 1))

211 {

212 svga->read_bank = (val & 0x1f) * 65536;

213 // pclog("SVGARBANK 3D8 %08X %04X:%04X\n",svgarbank,CS,pc);

214 }

215 }

216 return;

217 case 0x3D9:

218 tgui->tgui_3d9 = val;

219 if ((svga->gdcreg[0xf] & 5) == 5)

220 {

221 svga->read_bank = (val & 0x1F) * 65536;

222 // pclog("SVGARBANK 3D9 %08X %04X:%04X\n",svgarbank,CS,pc);

223 }

224 return;

225

226 case 0x43c8:

227 tgui->clock_n = val & 0x7f;

228 tgui->clock_m = (tgui->clock_m & ~1) | (val >> 7);

229 break;

230 case 0x43c9:

231 tgui->clock_m = (tgui->clock_m & ~0x1e) | ((val << 1) & 0x1e);

232 tgui->clock_k = (val & 0x10) >> 4;

233 break;

234 }

235 svga_out(addr, val, svga);

236 }

237

238 uint8_t tgui_in(uint16_t addr, void *p)

239 {

240 tgui_t *tgui = (tgui_t *)p;

241 svga_t *svga = &tgui->svga;

242

243 // if (addr != 0x3da) pclog("tgui_in : %04X %04X:%04X\n", addr, CS,pc);

244

245 if (((addr&0xFFF0) == 0x3D0 || (addr&0xFFF0) == 0x3B0) && !(svga->miscout & 1)) addr ^= 0x60;

246

247 switch (addr)

248 {

249 case 0x3C5:

250 if ((svga->seqaddr & 0xf) == 0xb)

251 {

252 // printf("Read Trident ID %04X:%04X %04X\n",CS,pc,readmemw(ss,SP));

253 tgui->oldmode = 0;

254 return 0xe3; /*TGUI9440AGi*/

255 }

256 if ((svga->seqaddr & 0xf) == 0xc)

257 {

258 // printf("Read Trident Power Up 1 %04X:%04X %04X\n",CS,pc,readmemw(ss,SP));

259 // return 0x20; /*2 DRAM banks*/

260 }

261 if ((svga->seqaddr & 0xf) == 0xd)

262 {

263 if (tgui->oldmode) return tgui->oldctrl2;

264 return tgui->newctrl2;

265 }

266 break;

267 case 0x3C6:

268 if (tgui->ramdac_state == 4)

269 return tgui->ramdac_ctrl;

270 tgui->ramdac_state++;

271 break;

272 case 0x3C7: case 0x3C8: case 0x3C9:

273 tgui->ramdac_state = 0;

274 break;

275 case 0x3D4:

276 return svga->crtcreg;

277 case 0x3D5:

278 return svga->crtc[svga->crtcreg];

279 case 0x3d8:

280 return tgui->tgui_3d8;

281 case 0x3d9:

282 return tgui->tgui_3d9;

283 }

284 return svga_in(addr, svga);

285 }

286

287 void tgui_recalctimings(svga_t *svga)

288 {

289 tgui_t *tgui = (tgui_t *)svga->p;

290

291 if (svga->crtc[0x29] & 0x10)

292 svga->rowoffset += 0x100;

293

294 if (svga->bpp == 24)

295 svga->hdisp = (svga->crtc[1] + 1) * 8;

296

297 if ((svga->crtc[0x1e] & 0xA0) == 0xA0) svga->ma_latch |= 0x10000;

298 if ((svga->crtc[0x27] & 0x01) == 0x01) svga->ma_latch |= 0x20000;

299 if ((svga->crtc[0x27] & 0x02) == 0x02) svga->ma_latch |= 0x40000;

300

301 if (tgui->oldctrl2 & 0x10)

302 {

303 svga->rowoffset <<= 1;

304 svga->ma_latch <<= 1;

305 }

306 if (tgui->oldctrl2 & 0x10) /*I'm not convinced this is the right register for this function*/

307 svga->lowres=0;

308

309 svga->lowres = !(svga->crtc[0x2a] & 0x40);

310

311 svga->interlace = svga->crtc[0x1e] & 4;

312

313 if (svga->miscout & 8)

314 svga->clock = cpuclock / (((tgui->clock_n + 8) * 14318180.0) / ((tgui->clock_m + 2) * (1 << tgui->clock_k)));

315

316 if (svga->gdcreg[0xf] & 0x08)

317 svga->clock *= 2;

318 else if (svga->gdcreg[0xf] & 0x40)

319 svga->clock *= 3;

320

321 if ((tgui->oldctrl2 & 0x10) || (svga->crtc[0x2a] & 0x40))

322 {

323 switch (svga->bpp)

324 {

325 case 8:

326 svga->render = svga_render_8bpp_highres;

327 break;

328 case 15:

329 svga->render = svga_render_15bpp_highres;

330 break;

331 case 16:

332 svga->render = svga_render_16bpp_highres;

333 break;

334 case 24:

335 svga->render = svga_render_24bpp_highres;

336 break;

337 }

338 }

339 }

340

341 void tgui_recalcmapping(tgui_t *tgui)

342 {

343 svga_t *svga = &tgui->svga;

344

345 // pclog("tgui_recalcmapping : %02X %02X\n", svga->crtc[0x21], svga->gdcreg[6]);

346

347 if (svga->crtc[0x21] & 0x20)

348 {

349 mem_mapping_disable(&svga->mapping);

350 mem_mapping_set_addr(&tgui->linear_mapping, tgui->linear_base, tgui->linear_size);

351 // pclog("Trident linear framebuffer at %08X - size %06X\n", tgui->linear_base, tgui->linear_size);

352 mem_mapping_enable(&tgui->accel_mapping);

353 }

354 else

355 {

356 // pclog("Write mapping %02X\n", val);

357 mem_mapping_disable(&tgui->linear_mapping);

358 mem_mapping_disable(&tgui->accel_mapping);

359 switch (svga->gdcreg[6] & 0xC)

360 {

361 case 0x0: /*128k at A0000*/

362 mem_mapping_set_addr(&svga->mapping, 0xa0000, 0x20000);

363 svga->banked_mask = 0xffff;

364 break;

365 case 0x4: /*64k at A0000*/

366 mem_mapping_set_addr(&svga->mapping, 0xa0000, 0x10000);

367 mem_mapping_enable(&tgui->accel_mapping);

368 svga->banked_mask = 0xffff;

369 break;

370 case 0x8: /*32k at B0000*/

371 mem_mapping_set_addr(&svga->mapping, 0xb0000, 0x08000);

372 svga->banked_mask = 0x7fff;

373 break;

374 case 0xC: /*32k at B8000*/

375 mem_mapping_set_addr(&svga->mapping, 0xb8000, 0x08000);

376 svga->banked_mask = 0x7fff;

377 break;

378 }

379 }

380 }

381

382 void tgui_hwcursor_draw(svga_t *svga, int displine)

383 {

384 uint32_t dat[2];

385 int xx;

386 int offset = svga->hwcursor_latch.x - svga->hwcursor_latch.xoff;

387

388 dat[0] = (svga->vram[svga->hwcursor_latch.addr] << 24) | (svga->vram[svga->hwcursor_latch.addr + 1] << 16) | (svga->vram[svga->hwcursor_latch.addr + 2] << 8) | svga->vram[svga->hwcursor_latch.addr + 3];

389 dat[1] = (svga->vram[svga->hwcursor_latch.addr + 4] << 24) | (svga->vram[svga->hwcursor_latch.addr + 5] << 16) | (svga->vram[svga->hwcursor_latch.addr + 6] << 8) | svga->vram[svga->hwcursor_latch.addr + 7];

390 for (xx = 0; xx < 32; xx++)

391 {

392 if (offset >= svga->hwcursor_latch.x)

393 {

394 if (!(dat[0] & 0x80000000))

395 ((uint32_t *)buffer32->line[displine])[offset + 32] = (dat[1] & 0x80000000) ? 0xffffff : 0;

396 else if (dat[1] & 0x80000000)

397 ((uint32_t *)buffer32->line[displine])[offset + 32] ^= 0xffffff;

398 // pclog("Plot %i, %i (%i %i) %04X %04X\n", offset, displine, x+xx, svga_hwcursor_on, dat[0], dat[1]);

399 }

400

401 offset++;

402 dat[0] <<= 1;

403 dat[1] <<= 1;

404 }

405 svga->hwcursor_latch.addr += 8;

406 }

407

408 uint8_t tgui_pci_read(int func, int addr, void *p)

409 {

410 tgui_t *tgui = (tgui_t *)p;

411 svga_t *svga = &tgui->svga;

412

413 // pclog("Trident PCI read %08X\n", addr);

414

415 switch (addr)

416 {

417 case 0x00: return 0x23; /*Trident*/

418 case 0x01: return 0x10;

419

420 case 0x02: return 0x40; /*TGUI9440 (9682)*/

421 case 0x03: return 0x94;

422

423 case 0x04: return 0x03; /*Respond to IO and memory accesses*/

424

425 case 0x07: return 1 << 1; /*Medium DEVSEL timing*/

426

427 case 0x08: return 0; /*Revision ID*/

428 case 0x09: return 0; /*Programming interface*/

429

430 case 0x0a: return 0x01; /*Supports VGA interface, XGA compatible*/

431 case 0x0b: return 0x03;

432

433 case 0x10: return 0x00; /*Linear frame buffer address*/

434 case 0x11: return 0x00;

435 case 0x12: return tgui->linear_base >> 16;

436 case 0x13: return tgui->linear_base >> 24;

437

438 case 0x30: return 0x01; /*BIOS ROM address*/

439 case 0x31: return 0x00;

440 case 0x32: return 0x0C;

441 case 0x33: return 0x00;

442 }

443 return 0;

444 }

445

446 void tgui_pci_write(int func, int addr, uint8_t val, void *p)

447 {

448 tgui_t *tgui = (tgui_t *)p;

449 svga_t *svga = &tgui->svga;

450

451 // pclog("Trident PCI write %08X %02X\n", addr, val);

452

453 switch (addr)

454 {

455 case 0x12:

456 tgui->linear_base = (tgui->linear_base & 0xff000000) | ((val & 0xe0) << 16);

457 tgui->linear_size = 2 << 20;

458 svga->crtc[0x21] = (svga->crtc[0x21] & ~0xf) | (val >> 4);

459 tgui_recalcmapping(tgui);

460 break;

461 case 0x13:

462 tgui->linear_base = (tgui->linear_base & 0xe00000) | (val << 24);

463 tgui->linear_size = 2 << 20;

464 svga->crtc[0x21] = (svga->crtc[0x21] & ~0xc0) | (val >> 6);

465 tgui_recalcmapping(tgui);

466 break;

467 }

468 }

469

470 void *tgui9440_init()

471 {

472 tgui_t *tgui = malloc(sizeof(tgui_t));

473 memset(tgui, 0, sizeof(tgui_t));

474

475 tgui->vram_size = device_get_config_int("memory") << 20;

476 tgui->vram_mask = tgui->vram_size - 1;

477

478 rom_init(&tgui->bios_rom, "roms/9440.vbi", 0xc0000, 0x8000, 0x7fff, 0, MEM_MAPPING_EXTERNAL);

479

480 svga_init(&tgui->svga, tgui, tgui->vram_size,

481 tgui_recalctimings,

482 tgui_in, tgui_out,

483 tgui_hwcursor_draw,

484 NULL);

485

486 mem_mapping_add(&tgui->linear_mapping, 0, 0, svga_read_linear, svga_readw_linear, svga_readl_linear, svga_write_linear, svga_writew_linear, svga_writel_linear, NULL, 0, &tgui->svga);

487 mem_mapping_add(&tgui->accel_mapping, 0xbc000, 0x4000, tgui_accel_read, tgui_accel_read_w, tgui_accel_read_l, tgui_accel_write, tgui_accel_write_w, tgui_accel_write_l, NULL, 0, tgui);

488 mem_mapping_disable(&tgui->accel_mapping);

489

490 io_sethandler(0x03c0, 0x0020, tgui_in, NULL, NULL, tgui_out, NULL, NULL, tgui);

491 io_sethandler(0x43c8, 0x0002, tgui_in, NULL, NULL, tgui_out, NULL, NULL, tgui);

492

493 pci_add(tgui_pci_read, tgui_pci_write, tgui);

494

495 return tgui;

496 }

497

498 static int tgui9440_available()

499 {

500 return rom_present("roms/9440.vbi");

501 }

502

503 void tgui_close(void *p)

504 {

505 tgui_t *tgui = (tgui_t *)p;

506

507 svga_close(&tgui->svga);

508

509 free(tgui);

510 }

511

512 void tgui_speed_changed(void *p)

513 {

514 tgui_t *tgui = (tgui_t *)p;

515

516 svga_recalctimings(&tgui->svga);

517 }

518

519 void tgui_force_redraw(void *p)

520 {

521 tgui_t *tgui = (tgui_t *)p;

522

523 tgui->svga.fullchange = changeframecount;

524 }

525

526 enum

527 {

528 TGUI_BITBLT = 1

529 };

530

531 enum

532 {

533 TGUI_SRCCPU = 0,

534

535 TGUI_SRCDISP = 0x04, /*Source is from display*/

536 TGUI_PATMONO = 0x20, /*Pattern is monochrome and needs expansion*/

537 TGUI_SRCMONO = 0x40, /*Source is monochrome from CPU and needs expansion*/

538 TGUI_TRANSENA = 0x1000, /*Transparent (no draw when source == bg col)*/

539 TGUI_TRANSREV = 0x2000, /*Reverse fg/bg for transparent*/

540 TGUI_SOLIDFILL = 0x4000 /*Pattern all zero?*/

541 };

542

543 #define READ(addr, dat) if (tgui->accel.bpp == 0) dat = svga->vram[addr & 0x1fffff]; \

544 else dat = vram_w[addr & 0xfffff];

545

546 #define MIX() do \

547 { \

548 out = 0; \

549 for (c=0;c<16;c++) \

550 { \

551 d=(dst_dat & (1<<c)) ? 1:0; \

552 if (src_dat & (1<<c)) d|=2; \

553 if (pat_dat & (1<<c)) d|=4; \

554 if (tgui->accel.rop & (1<<d)) out|=(1<<c); \

555 } \

556 } while (0)

557

558 #define WRITE(addr, dat) if (tgui->accel.bpp == 0) \

559 { \

560 svga->vram[addr & 0x1fffff] = dat; \

561 svga->changedvram[((addr) & 0x1fffff) >> 12] = changeframecount; \

562 } \

563 else \

564 { \

565 vram_w[addr & 0xfffff] = dat; \

566 svga->changedvram[((addr) & 0xfffff) >> 11] = changeframecount; \

567 }

568

569 void tgui_accel_write_fb_b(uint32_t addr, uint8_t val, void *priv);

570 void tgui_accel_write_fb_w(uint32_t addr, uint16_t val, void *priv);

571

572 void tgui_accel_command(int count, uint32_t cpu_dat, tgui_t *tgui)

573 {

574 svga_t *svga = &tgui->svga;

575 int x, y;

576 int c, d;

577 uint16_t src_dat, dst_dat, pat_dat;

578 uint16_t out;

579 int xdir = (tgui->accel.flags & 0x200) ? -1 : 1;

580 int ydir = (tgui->accel.flags & 0x100) ? -1 : 1;

581 uint16_t trans_col = (tgui->accel.flags & TGUI_TRANSREV) ? tgui->accel.fg_col : tgui->accel.bg_col;

582 uint16_t *vram_w = (uint16_t *)svga->vram;

583

584 if (tgui->accel.bpp == 0)

585 trans_col &= 0xff;

586

587 if (count != -1 && !tgui->accel.x)

588 {

589 count -= tgui->accel.offset;

590 cpu_dat <<= tgui->accel.offset;

591 }

592 if (count == -1)

593 {

594 tgui->accel.x = tgui->accel.y = 0;

595 }

596 if (tgui->accel.flags & TGUI_SOLIDFILL)

597 {

598 // pclog("SOLIDFILL\n");

599 for (y = 0; y < 8; y++)

600 {

601 for (x = 0; x < 8; x++)

602 {

603 tgui->accel.tgui_pattern[y][x] = tgui->accel.fg_col;

604 }

605 }

606 }

607 else if (tgui->accel.flags & TGUI_PATMONO)

608 {

609 // pclog("PATMONO\n");

610 for (y = 0; y < 8; y++)

611 {

612 for (x = 0; x < 8; x++)

613 {

614 tgui->accel.tgui_pattern[y][x] = (tgui->accel.pattern[y] & (1 << x)) ? tgui->accel.fg_col : tgui->accel.bg_col;

615 }

616 }

617 }

618 else

619 {

620 if (tgui->accel.bpp == 0)

621 {

622 // pclog("OTHER 8-bit\n");

623 for (y = 0; y < 8; y++)

624 {

625 for (x = 0; x < 8; x++)

626 {

627 tgui->accel.tgui_pattern[y][x] = tgui->accel.pattern[x + y*8];

628 }

629 }

630 }

631 else

632 {

633 // pclog("OTHER 16-bit\n");

634 for (y = 0; y < 8; y++)

635 {

636 for (x = 0; x < 8; x++)

637 {

638 tgui->accel.tgui_pattern[y][x] = tgui->accel.pattern[x*2 + y*16] | (tgui->accel.pattern[x*2 + y*16 + 1] << 8);

639 }

640 }

641 }

642 }

643 /* for (y = 0; y < 8; y++)

644 {

645 if (count == -1) pclog("Pattern %i : %02X %02X %02X %02X %02X %02X %02X %02X\n", y, tgui->accel.tgui_pattern[y][0], tgui->accel.tgui_pattern[y][1], tgui->accel.tgui_pattern[y][2], tgui->accel.tgui_pattern[y][3], tgui->accel.tgui_pattern[y][4], tgui->accel.tgui_pattern[y][5], tgui->accel.tgui_pattern[y][6], tgui->accel.tgui_pattern[y][7]);

646 }*/

647 // if (count == -1) pclog("Command %i %i %p\n", tgui->accel.command, TGUI_BITBLT, tgui);

648 switch (tgui->accel.command)

649 {

650 case TGUI_BITBLT:

651 // if (count == -1) pclog("BITBLT src %i,%i dst %i,%i size %i,%i flags %04X\n", tgui->accel.src_x, tgui->accel.src_y, tgui->accel.dst_x, tgui->accel.dst_y, tgui->accel.size_x, tgui->accel.size_y, tgui->accel.flags);

652 if (count == -1)

653 {

654 tgui->accel.src = tgui->accel.src_old = tgui->accel.src_x + (tgui->accel.src_y * tgui->accel.pitch);

655 tgui->accel.dst = tgui->accel.dst_old = tgui->accel.dst_x + (tgui->accel.dst_y * tgui->accel.pitch);

656 tgui->accel.pat_x = tgui->accel.dst_x;

657 tgui->accel.pat_y = tgui->accel.dst_y;

658 }

659

660 switch (tgui->accel.flags & (TGUI_SRCMONO|TGUI_SRCDISP))

661 {

662 case TGUI_SRCCPU:

663 if (count == -1)

664 {

665 // pclog("Blit start TGUI_SRCCPU\n");

666 if (svga->crtc[0x21] & 0x20)

667 mem_mapping_set_handler(&tgui->linear_mapping, svga_read_linear, svga_readw_linear, svga_readl_linear, tgui_accel_write_fb_b, tgui_accel_write_fb_w, tgui_accel_write_fb_l);

668

669 if (tgui->accel.use_src)

670 return;

671 }

672 else

673 count >>= 3;

674 // pclog("TGUI_SRCCPU\n");

675 while (count)

676 {

677 if (tgui->accel.bpp == 0)

678 {

679 src_dat = cpu_dat >> 24;

680 cpu_dat <<= 8;

681 }

682 else

683 {

684 src_dat = (cpu_dat >> 24) | ((cpu_dat >> 8) & 0xff00);

685 cpu_dat <<= 16;

686 count--;

687 }

688 READ(tgui->accel.dst, dst_dat);

689 pat_dat = tgui->accel.tgui_pattern[tgui->accel.pat_y & 7][tgui->accel.pat_x & 7];

690

691 if (!(tgui->accel.flags & TGUI_TRANSENA) || src_dat != trans_col)

692 {

693 MIX();

694

695 WRITE(tgui->accel.dst, out);

696 }

697

698 // pclog(" %i,%i %02X %02X %02X %02X\n", tgui->accel.x, tgui->accel.y, src_dat,dst_dat,pat_dat, out);

699

700 tgui->accel.src += xdir;

701 tgui->accel.dst += xdir;

702 tgui->accel.pat_x += xdir;

703

704 tgui->accel.x++;

705 if (tgui->accel.x > tgui->accel.size_x)

706 {

707 tgui->accel.x = 0;

708 tgui->accel.y++;

709

710 tgui->accel.pat_x = tgui->accel.dst_x;

711

712 tgui->accel.src = tgui->accel.src_old = tgui->accel.src_old + (ydir * tgui->accel.pitch);

713 tgui->accel.dst = tgui->accel.dst_old = tgui->accel.dst_old + (ydir * tgui->accel.pitch);

714 tgui->accel.pat_y += ydir;

715

716 if (tgui->accel.y > tgui->accel.size_y)

717 {

718 if (svga->crtc[0x21] & 0x20)

719 {

720 // pclog("Blit end\n");

721 mem_mapping_set_handler(&tgui->linear_mapping, svga_read_linear, svga_readw_linear, svga_readl_linear, svga_write_linear, svga_writew_linear, svga_writel_linear);

722 }

723 return;

724 }

725 if (tgui->accel.use_src)

726 return;

727 }

728 count--;

729 }

730 break;

731

732 case TGUI_SRCMONO | TGUI_SRCCPU:

733 if (count == -1)

734 {

735 // pclog("Blit start TGUI_SRCMONO | TGUI_SRCCPU\n");

736 if (svga->crtc[0x21] & 0x20)

737 mem_mapping_set_handler(&tgui->linear_mapping, svga_read_linear, svga_readw_linear, svga_readl_linear, tgui_accel_write_fb_b, tgui_accel_write_fb_w, tgui_accel_write_fb_l);

738

739 // pclog(" %i\n", tgui->accel.command);

740 if (tgui->accel.use_src)

741 return;

742 }

743 // pclog("TGUI_SRCMONO | TGUI_SRCCPU\n");

744 while (count)

745 {

746 src_dat = ((cpu_dat >> 31) ? tgui->accel.fg_col : tgui->accel.bg_col);

747 if (tgui->accel.bpp == 0)

748 src_dat &= 0xff;

749

750 READ(tgui->accel.dst, dst_dat);

751 pat_dat = tgui->accel.tgui_pattern[tgui->accel.pat_y & 7][tgui->accel.pat_x & 7];

752

753 if (!(tgui->accel.flags & TGUI_TRANSENA) || src_dat != trans_col)

754 {

755 MIX();

756

757 WRITE(tgui->accel.dst, out);

758 }

759 // pclog(" %i,%i %02X %02X %02X %02X %i\n", tgui->accel.x, tgui->accel.y, src_dat,dst_dat,pat_dat, out, (!(tgui->accel.flags & TGUI_TRANSENA) || src_dat != trans_col));

760 cpu_dat <<= 1;

761 tgui->accel.src += xdir;

762 tgui->accel.dst += xdir;

763 tgui->accel.pat_x += xdir;

764

765 tgui->accel.x++;

766 if (tgui->accel.x > tgui->accel.size_x)

767 {

768 tgui->accel.x = 0;

769 tgui->accel.y++;

770

771 tgui->accel.pat_x = tgui->accel.dst_x;

772

773 tgui->accel.src = tgui->accel.src_old = tgui->accel.src_old + (ydir * tgui->accel.pitch);

774 tgui->accel.dst = tgui->accel.dst_old = tgui->accel.dst_old + (ydir * tgui->accel.pitch);

775 tgui->accel.pat_y += ydir;

776

777 if (tgui->accel.y > tgui->accel.size_y)

778 {

779 if (svga->crtc[0x21] & 0x20)

780 {

781 // pclog("Blit end\n");

782 mem_mapping_set_handler(&tgui->linear_mapping, svga_read_linear, svga_readw_linear, svga_readl_linear, svga_write_linear, svga_writew_linear, svga_writel_linear);

783 }

784 return;

785 }

786 if (tgui->accel.use_src)

787 return;

788 }

789 count--;

790 }

791 break;

792

793 default:

794 while (count)