![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to printer.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Previous NeXT emulator] / previous / src|
Return to printer.c CVS log | Up to [Previous NeXT emulator] / previous / src |
1.1 root 1: /* Previous - printer.c
2:
3: This file is distributed under the GNU Public License, version 2 or at
4: your option any later version. Read the file gpl.txt for details.
5:
6: NeXT Laser Printer emulation.
7:
8: */
9:
10: #include "ioMem.h"
11: #include "ioMemTables.h"
12: #include "m68000.h"
13: #include "configuration.h"
14: #include "printer.h"
15: #include "sysReg.h"
16: #include "dma.h"
17: #include "statusbar.h"
18: #include "file.h"
19:
20: #include "png.h"
21:
22: #define USE_PNG_PRINTING 1
23:
24:
25: #define IO_SEG_MASK 0x1FFFF
26:
27: #define LOG_LP_REG_LEVEL LOG_DEBUG
28: #define LOG_LP_LEVEL LOG_DEBUG
29:
30:
31: struct {
32: /* Registers */
33: struct {
34: Uint8 dma;
35: Uint8 printer;
36: Uint8 interface;
37: Uint8 cmd;
38: } csr;
39: Uint32 data;
40:
41: /* Internal */
42: Uint8 stat;
43: Uint8 statmask;
44: Uint32 margins;
45: } nlp;
46:
47: void lp_power_on(void);
48: void lp_power_off(void);
49: void lp_set_interrupt(void);
50: void lp_release_interrupt(void);
51: Uint32 lp_data_read(void);
52: void lp_boot_message(void);
53: void lp_interface_command(Uint8 cmd, Uint32 data);
54: void lp_interface_status(Uint8 stat, bool set);
55: void lp_gpo_access(Uint8 data);
56: void lp_printer_reset(void);
57:
58: void lp_png_setup(Uint32 data);
59: void lp_png_print(void);
60: void lp_png_finish(void);
61:
62: bool lp_data_transfer = false;
63:
64: /* Laser Printer control and status register (0x0200F000)
65: *
66: * x--- ---- ---- ---- ---- ---- ---- ---- dma out enable (r/w)
67: * -x-- ---- ---- ---- ---- ---- ---- ---- dma out request (r)
68: * --x- ---- ---- ---- ---- ---- ---- ---- dma out underrun detected (r/w)
69: * ---- x--- ---- ---- ---- ---- ---- ---- dma in enable (r/w)
70: * ---- -x-- ---- ---- ---- ---- ---- ---- dma in request (r)
71: * ---- --x- ---- ---- ---- ---- ---- ---- dma in overrun detected (r/w)
72: * ---- ---x ---- ---- ---- ---- ---- ---- increment buffer read pointer (r/w)
73: *
74: * ---- ---- x--- ---- ---- ---- ---- ---- printer on/off (r/w)
75: * ---- ---- -x-- ---- ---- ---- ---- ---- behave like monitor interface (r/w)
76: * ---- ---- ---- x--- ---- ---- ---- ---- printer interrupt (r)
77: * ---- ---- ---- -x-- ---- ---- ---- ---- printer data available (r)
78: * ---- ---- ---- --x- ---- ---- ---- ---- printer data overrun (r/w)
79: *
80: * ---- ---- ---- ---- x--- ---- ---- ---- dma out transmit pending (r)
81: * ---- ---- ---- ---- -x-- ---- ---- ---- dma out transmit in progress (r)
82: * ---- ---- ---- ---- --x- ---- ---- ---- cpu data transmit pending (r)
83: * ---- ---- ---- ---- ---x ---- ---- ---- cpu data transmit in progress (r)
84: * ---- ---- ---- ---- ---- --x- ---- ---- printer interface enable (return from reset state) (r/w)
85: * ---- ---- ---- ---- ---- ---x ---- ---- loop back transmitter data (r/w)
86: *
87: * ---- ---- ---- ---- ---- ---- xxxx xxxx command to append on printer data (r/w)
88: *
89: * ---x ---- --xx ---x ---- xx-- ---- ---- zero bits
90: */
91:
92: #define LP_DMA_OUT_EN 0x80
93: #define LP_DMA_OUT_REQ 0x40
94: #define LP_DMA_OUT_UNDR 0x20
95: #define LP_DMA_IN_EN 0x08
96: #define LP_DMA_IN_REQ 0x04
97: #define LP_DMA_IN_OVR 0x02
98: #define LP_DMA_INCR 0x01
99:
100: #define LP_ON 0x80
101: #define LP_NDI 0x40
102: #define LP_INT 0x08
103: #define LP_DATA 0x04
104: #define LP_DATA_OVR 0x02
105:
106: #define LP_TX_DMA_PEND 0x80
107: #define LP_TX_DMA 0x40
108: #define LP_TX_CPU_PEND 0x20
109: #define LP_TX_CPU 0x10
110: #define LP_TX_EN 0x02
111: #define LP_TX_LOOP 0x01
112:
113:
114: void LP_CSR0_Read(void) { // 0x0200F000
115: IoMem[IoAccessCurrentAddress & IO_SEG_MASK] = nlp.csr.dma;
116: Log_Printf(LOG_LP_REG_LEVEL,"[LP] CSR0 read at $%08x val=$%02x PC=$%08x\n", IoAccessCurrentAddress, IoMem[IoAccessCurrentAddress & IO_SEG_MASK], m68k_getpc());
117: }
118:
119: void LP_CSR0_Write(void) {
120: Uint8 val = IoMem[IoAccessCurrentAddress & IO_SEG_MASK];
121: Log_Printf(LOG_LP_REG_LEVEL,"[LP] CSR0 write at $%08x val=$%02x PC=$%08x\n", IoAccessCurrentAddress, IoMem[IoAccessCurrentAddress & IO_SEG_MASK], m68k_getpc());
122:
123: if (val&LP_DMA_OUT_UNDR) {
124: nlp.csr.dma &= ~(LP_DMA_OUT_UNDR|LP_DMA_OUT_REQ);
125: lp_release_interrupt();
126: }
127: if (val&LP_DMA_IN_OVR) {
128: nlp.csr.dma &= ~(LP_DMA_IN_OVR|LP_DMA_IN_REQ);
129: lp_release_interrupt();
130: }
131: }
132:
133: void LP_CSR1_Read(void) { // 0x0200F001
134: IoMem[IoAccessCurrentAddress & IO_SEG_MASK] = nlp.csr.printer;
135: Log_Printf(LOG_LP_REG_LEVEL,"[LP] CSR1 read at $%08x val=$%02x PC=$%08x\n", IoAccessCurrentAddress, IoMem[IoAccessCurrentAddress & IO_SEG_MASK], m68k_getpc());
136: }
137:
138: void LP_CSR1_Write(void) {
139: Uint8 val = IoMem[IoAccessCurrentAddress & IO_SEG_MASK];
140: Log_Printf(LOG_LP_REG_LEVEL,"[LP] CSR1 write at $%08x val=$%02x PC=$%08x\n", IoAccessCurrentAddress, IoMem[IoAccessCurrentAddress & IO_SEG_MASK], m68k_getpc());
141:
142: if (((val&LP_ON) != (nlp.csr.printer&LP_ON)) && ConfigureParams.Printer.bPrinterConnected) {
143: if (val&LP_ON) {
144: Statusbar_AddMessage("Switching Laser Printer ON.", 0);
145: lp_power_on();
146: } else {
147: Statusbar_AddMessage("Switching Laser Printer OFF.", 0);
148: lp_power_off();
149: }
150: }
151: nlp.csr.printer = val;
152:
153: if (val&LP_DATA_OVR) {
154: nlp.csr.printer &= ~(LP_DATA_OVR|LP_DATA);
155: lp_release_interrupt();
156: }
157: }
158:
159: void LP_CSR2_Read(void) { // 0x0200F002
160: IoMem[IoAccessCurrentAddress & IO_SEG_MASK] = nlp.csr.interface;
161: Log_Printf(LOG_LP_REG_LEVEL,"[LP] CSR2 read at $%08x val=$%02x PC=$%08x\n", IoAccessCurrentAddress, IoMem[IoAccessCurrentAddress & IO_SEG_MASK], m68k_getpc());
162: }
163:
164: void LP_CSR2_Write(void) {
165: Uint8 val = IoMem[IoAccessCurrentAddress & IO_SEG_MASK];
166: Log_Printf(LOG_LP_REG_LEVEL,"[LP] CSR2 write at $%08x val=$%02x PC=$%08x\n", IoAccessCurrentAddress, IoMem[IoAccessCurrentAddress & IO_SEG_MASK], m68k_getpc());
167:
168: if ((val&LP_TX_EN) != (nlp.csr.interface&LP_TX_EN)) {
169: if (val&LP_TX_EN) {
170: Log_Printf(LOG_LP_LEVEL,"[LP] Enable serial interface.");
171: if (ConfigureParams.Printer.bPrinterConnected) {
172: lp_boot_message();
173: }
174: } else {
175: Log_Printf(LOG_LP_LEVEL,"[LP] Disable serial interface.");
176: }
177: }
178: nlp.csr.interface = val;
179: }
180:
181: void LP_CSR3_Read(void) { // 0x0200F003
182: IoMem[IoAccessCurrentAddress & IO_SEG_MASK] = nlp.csr.cmd;
183: Log_Printf(LOG_LP_REG_LEVEL,"[LP] CSR3 read at $%08x val=$%02x PC=$%08x\n", IoAccessCurrentAddress, IoMem[IoAccessCurrentAddress & IO_SEG_MASK], m68k_getpc());
184: }
185:
186: void LP_CSR3_Write(void) {
187: nlp.csr.cmd=IoMem[IoAccessCurrentAddress & IO_SEG_MASK];
188: Log_Printf(LOG_LP_REG_LEVEL,"[LP] CSR3 write at $%08x val=$%02x PC=$%08x\n", IoAccessCurrentAddress, IoMem[IoAccessCurrentAddress & IO_SEG_MASK], m68k_getpc());
189: }
190:
191: void LP_Data_Read(void) { // 0x0200F004 (access must be 32-bit)
192: nlp.data = lp_data_read();
193: IoMem_WriteLong(IoAccessCurrentAddress&IO_SEG_MASK, nlp.data);
194: Log_Printf(LOG_LP_REG_LEVEL,"[LP] Data read at $%08x val=$%08x PC=$%08x\n", IoAccessCurrentAddress, nlp.data, m68k_getpc());
195: }
196:
197: void LP_Data_Write(void) {
198: nlp.data = IoMem_ReadLong(IoAccessCurrentAddress&IO_SEG_MASK);
199: Log_Printf(LOG_LP_REG_LEVEL,"[LP] Data write at $%08x val=$%08x PC=$%08x\n", IoAccessCurrentAddress, nlp.data, m68k_getpc());
200:
201: if (ConfigureParams.Printer.bPrinterConnected) {
202: lp_interface_command(nlp.csr.cmd, nlp.data);
203: }
204: }
205:
206:
207: /* Printer interrupt functions */
208: void lp_set_interrupt(void) {
209: nlp.csr.printer |= LP_INT;
210: set_interrupt(INT_PRINTER, SET_INT);
211: }
212:
213: void lp_release_interrupt(void) {
214: if ((nlp.csr.printer&(LP_DATA|LP_DATA_OVR)) || (nlp.csr.dma&(LP_DMA_OUT_UNDR|LP_DMA_IN_OVR))) {
215: return;
216: }
217: nlp.csr.printer &= ~LP_INT;
218: set_interrupt(INT_PRINTER, RELEASE_INT);
219: }
220:
221:
222: /* Commands from CPU to Printer */
223: #define LP_CMD_RESET 0xff
224: #define LP_CMD_DATA_OUT 0xc7
225: #define LP_CMD_GPO 0xc4
226: #define LP_CMD_GPI_MASK 0xc5
227: #define LP_CMD_GPI_REQ 0x04
228: #define LP_CMD_MARGINS 0xc2
229:
230: #define LP_CMD_MASK 0xc7
231: #define LP_CMD_NODATA 0x07
232: #define LP_CMD_DATA_EN 0x08
233: #define LP_CMD_300DPI 0x10
234: #define LP_CMD_NORMAL 0x20
235:
236: /* Responses from Printer to CPU */
237: #define LP_RES_DATA_IN 0xc7
238: #define LP_RES_GPI 0xc4
239: #define LP_RES_COPY 0xe7
240: #define LP_RES_DATA_REQ 0x07
241: #define LP_RES_UNDERRUN 0x0f
242:
243:
244: /* Data for commands */
245: #define LP_GPI_PWR_RDY 0x10
246: #define LP_GPI_RDY 0x08
247: #define LP_GPI_VSREQ 0x04
248: #define LP_GPI_BUSY 0x02
249: #define LP_GPI_STAT_BIT 0x01
250:
251: #define LP_GPO_DENSITY 0x40
252: #define LP_GPO_VSYNC 0x20
253: #define LP_GPO_ENABLE 0x10
254: #define LP_GPO_PWR_RDY 0x08
255: #define LP_GPO_CLOCK 0x04
256: #define LP_GPO_CMD_BIT 0x02
257: #define LP_GPO_BUSY 0x01
258:
259: void lp_gpo(Uint8 cmd) {
260: if (cmd&LP_GPO_DENSITY) {
261: Log_Printf(LOG_LP_LEVEL,"[LP] Printer 300 DPI mode");
262: }
263: if (cmd&LP_GPO_VSYNC) {
264: Log_Printf(LOG_LP_LEVEL,"[LP] Printer VSYNC enable");
265: lp_interface_status(LP_GPI_VSREQ, false);
266: }
267: if (cmd&LP_GPO_ENABLE) {
268: Log_Printf(LOG_LP_LEVEL,"[LP] Printer enable");
269: lp_interface_status(LP_GPI_VSREQ, true);
270: }
271: if (cmd&LP_GPO_PWR_RDY) {
272: Log_Printf(LOG_LP_LEVEL,"[LP] Printer controller power ready");
273: }
274: if (cmd&LP_GPO_CLOCK) {
275: Log_Printf(LOG_LP_LEVEL,"[LP] Printer serial data clock");
276: }
277: if (cmd&LP_GPO_CMD_BIT) {
278: Log_Printf(LOG_LP_LEVEL,"[LP] Printer serial data command bits");
279: }
280: if (cmd&LP_GPO_BUSY) {
281: Log_Printf(LOG_LP_LEVEL,"[LP] Printer controller busy");
282: }
283: lp_gpo_access(cmd);
284: }
285:
286: void lp_gpi(void) {
287: nlp.data = (~nlp.stat)<<24;
288:
289: nlp.csr.cmd = LP_RES_GPI;
290:
291: if (nlp.csr.printer&LP_DATA) {
292: nlp.csr.printer |= LP_DATA_OVR;
293: } else {
294: nlp.csr.printer |= LP_DATA;
295: }
296:
297: lp_set_interrupt();
298: }
299:
300: void lp_interface_status(Uint8 changed_bits, bool set) {
301: bool lp_gpi_message = false;
302:
303: Log_Printf(LOG_LP_LEVEL,"[LP] Interface status: %02X (mask: %02X)",nlp.stat,nlp.statmask);
304:
305: if ((changed_bits&nlp.statmask) != (nlp.stat&changed_bits&nlp.statmask)) {
306: lp_gpi_message = true;
307: }
308:
309: if (set) {
310: nlp.stat |= changed_bits;
311: } else {
312: nlp.stat &= ~changed_bits;
313: }
314:
315: if (lp_gpi_message) {
316: lp_gpi();
317: }
318: }
319:
320: void lp_interface_command(Uint8 cmd, Uint32 data) {
321: switch (cmd) {
322: case LP_CMD_RESET:
323: Log_Printf(LOG_LP_LEVEL,"[LP] Interface command: Reset (%08X)",data);
324: lp_printer_reset();
325: lp_boot_message();
326: break;
327: case LP_CMD_DATA_OUT:
328: Log_Printf(LOG_LP_LEVEL,"[LP] Interface command: Data out (%08X)",data);
329: lp_buffer.data[lp_buffer.size] = (data>>24)&0xFF;
330: lp_buffer.data[lp_buffer.size+1] = (data>>16)&0xFF;
331: lp_buffer.data[lp_buffer.size+2] = (data>>8)&0xFF;
332: lp_buffer.data[lp_buffer.size+3] = data&0xFF;
333: lp_buffer.size +=4;
334: break;
335: case LP_CMD_GPO:
336: Log_Printf(LOG_LP_LEVEL,"[LP] Interface command: General purpose out (%02X)",(~data)>>24);
337: lp_gpo((~data)>>24);
338: break;
339: case LP_CMD_GPI_MASK:
340: Log_Printf(LOG_LP_LEVEL,"[LP] Interface command: General purpose input mask (%02X)",(~data)>>24);
341: nlp.statmask = (~data)>>24;
342: break;
343: case LP_CMD_GPI_REQ:
344: Log_Printf(LOG_LP_LEVEL,"[LP] Interface command: General purpose input request");
345: lp_gpi();
346: break;
347: case LP_CMD_MARGINS:
348: Log_Printf(LOG_LP_LEVEL,"[LP] Interface command: Margins (%08X)",data);
349: nlp.margins = data;
350: break;
351:
352: default: /* Commands with no data */
353: if ((cmd&LP_CMD_MASK)==LP_CMD_NODATA) {
354: Log_Printf(LOG_LP_LEVEL,"[LP] Interface command: No data command:");
355:
356: if (cmd&LP_CMD_DATA_EN) {
357: Log_Printf(LOG_LP_LEVEL,"[LP] Enable printer data transfer");
358: /* Setup printing buffer */
359: lp_png_setup(nlp.margins);
360: lp_data_transfer = true;
361: if (lp_buffer.size) {
362: lp_png_print();
363: lp_buffer.size = 0;
364: }
365: Statusbar_AddMessage("Laser Printer Printing Page.", 0);
366: CycInt_AddRelativeInterrupt(1000, INT_CPU_CYCLE, INTERRUPT_LP_IO);
367: } else {
368: Log_Printf(LOG_LP_LEVEL,"[LP] Disable printer data transfer");
369: if (lp_data_transfer) {
370: /* Save buffered printing data to image file */
371: lp_png_finish();
372: }
373: lp_data_transfer = false;
374: }
375: if (cmd&LP_CMD_300DPI) {
376: Log_Printf(LOG_LP_LEVEL,"[LP] 300 DPI mode");
377: } else {
378: Log_Printf(LOG_LP_LEVEL,"[LP] 400 DPI mode");
379: }
380: if (cmd&LP_CMD_NORMAL) {
381: Log_Printf(LOG_LP_LEVEL,"[LP] Normal requests for data transfer");
382: } else {
383: Log_Printf(LOG_LP_LEVEL,"[LP] Early requests for data transfer");
384: }
385: } else {
386: Log_Printf(LOG_WARN,"[LP] Interface command: Unknown command!");
387: }
388: break;
389: }
390: }
391:
392: void lp_power_on(void) {
393: lp_interface_status(LP_GPI_PWR_RDY|LP_GPI_RDY,true);
394: }
395:
396: void lp_power_off(void) {
397: nlp.stat = 0x00;
398: }
399:
400: /* COPY. NeXT 1987 */
401: Uint32 lp_copyright_message[4] = { 0x00434f50, 0x522e204e, 0x65585420, 0x31393837 };
402: int lp_copyright_sequence = 0;
403:
404: void lp_boot_message(void) {
405: lp_copyright_sequence = 4;
406:
407: nlp.csr.cmd = LP_RES_COPY;
408:
409: nlp.csr.printer |= LP_DATA;
410: lp_set_interrupt();
411: }
412:
413: Uint32 lp_data_read(void) {
414: Uint32 val = 0;
415:
416: if (lp_copyright_sequence>0) {
417: val = lp_copyright_message[4-lp_copyright_sequence];
418: lp_copyright_sequence--;
419: } else {
420: val = nlp.data;
421: }
422:
423: if (lp_copyright_sequence==0) {
424: nlp.csr.printer &= ~LP_DATA;
425: lp_release_interrupt();
426: }
427:
428: return val;
429: }
430:
431:
432: /* Printer internal command and status via serial interface */
433: #define CMD_STATUS0 0x01
434: #define CMD_STATUS1 0x02
435: #define CMD_STATUS2 0x04
436: #define CMD_STATUS4 0x08
437: #define CMD_STATUS5 0x0b
438: #define CMD_STATUS15 0x1f
439:
440: #define CMD_EXT_CLK 0x40
441: #define CMD_PRINTER_CLK 0x43
442: #define CMD_PAUSE 0x45
443: #define CMD_UNPAUSE 0x46
444: #define CMD_DRUM_ON 0x49
445: #define CMD_DRUM_OFF 0x4a
446: #define CMD_CASSFEED 0x4c
447: #define CMD_HANDFEED 0x4f
448: #define CMD_RETRANSCANC 0x5d
449:
450: #define STAT0_PRINTREQ 0x40
451: #define STAT0_PAPERDLVR 0x20
452: #define STAT0_DATARETR 0x10
453: #define STAT0_WAIT 0x08
454: #define STAT0_PAUSE 0x04
455: #define STAT0_CALL 0x02
456:
457: #define STAT1_NOCART 0x40
458: #define STAT1_NOPAPER 0x10
459: #define STAT1_JAM 0x08
460: #define STAT1_DOOROPEN 0x04
461: #define STAT1_TESTPRINT 0x02
462:
463: #define STAT2_FIXINGASM 0x40
464: #define STAT2_POORBDSIG 0x20
465: #define STAT2_SCANMOTOR 0x10
466:
467: #define STAT5_NOCASS 0x01
468: #define STAT5_A4 0x02
469: #define STAT5_LETTER 0x08
470: #define STAT5_B5 0x13
471: #define STAT5_LEGAL 0x19
472:
473: #define STAT15_NOTONER 0x04
474:
475: Uint8 lp_serial_status[16] = {
476: 0,0,0,0,
477: 0,STAT5_A4,0,0,
478: 0,0,0,0,
479: 0,0,0,0
480: };
481:
482: Uint8 lp_serial_phase = 0;
483:
484: Uint8 lp_printer_status(Uint8 num) {
485: int i;
486: Uint8 val;
487:
488: lp_serial_phase = 8;
489: lp_interface_status(LP_GPI_BUSY, true);
490:
491: if (num==5) {
492: switch (ConfigureParams.Printer.nPaperSize) {
493: case PAPER_A4: val = STAT5_A4; break;
494: case PAPER_LETTER: val = STAT5_LETTER; break;
495: case PAPER_B5: val = STAT5_B5; break;
496: case PAPER_LEGAL: val = STAT5_LEGAL; break;
497: default: val = PAPER_A4; break;
498: }
499: } else if (num<16) {
500: val = lp_serial_status[num];
501: } else {
502: val = 0x00;
503: }
504:
505: /* odd parity */
506: val |= 1;
507: for (i = 1; i < 8; i++) {
508: if (val & (1 << i)) {
509: val ^= 1;
510: }
511: }
512: return val;
513: }
514:
515: void lp_printer_reset(void) {
516: int i;
517: for (i = 0; i < 16; i++) {
518: lp_serial_status[i] = 0;
519: }
520: lp_serial_phase = 0;
521: }
522:
523: Uint8 lp_printer_command(Uint8 cmd) {
524: switch (cmd) {
525: case CMD_STATUS0:
526: Log_Printf(LOG_LP_LEVEL, "[LP] Read status register 0");
527: return lp_printer_status(0);
528: case CMD_STATUS1:
529: Log_Printf(LOG_LP_LEVEL, "[LP] Read status register 1");
530: return lp_printer_status(1);
531: case CMD_STATUS2:
532: Log_Printf(LOG_LP_LEVEL, "[LP] Read status register 2");
533: return lp_printer_status(2);
534: case CMD_STATUS4:
535: Log_Printf(LOG_LP_LEVEL, "[LP] Read status register 4");
536: return lp_printer_status(4);
537: case CMD_STATUS5:
538: Log_Printf(LOG_LP_LEVEL, "[LP] Read status register 5");
539: return lp_printer_status(5);
540: case CMD_STATUS15:
541: Log_Printf(LOG_LP_LEVEL, "[LP] Read status register 15");
542: return lp_printer_status(15);
543: /* Commands with no status */
544: case CMD_EXT_CLK:
545: Log_Printf(LOG_LP_LEVEL, "[LP] External clock");
546: return lp_printer_status(16);
547: case CMD_PRINTER_CLK:
548: Log_Printf(LOG_LP_LEVEL, "[LP] Printer clock");
549: return lp_printer_status(16);
550: case CMD_PAUSE:
551: Log_Printf(LOG_LP_LEVEL, "[LP] Pause");
552: return lp_printer_status(16);
553: case CMD_UNPAUSE:
554: Log_Printf(LOG_LP_LEVEL, "[LP] Unpause");
555: return lp_printer_status(16);
556: case CMD_DRUM_ON:
557: Log_Printf(LOG_LP_LEVEL, "[LP] Drum on");
558: return lp_printer_status(16);
559: case CMD_DRUM_OFF:
560: Log_Printf(LOG_LP_LEVEL, "[LP] Drum off");
561: return lp_printer_status(16);
562: case CMD_CASSFEED:
563: Log_Printf(LOG_LP_LEVEL, "[LP] Cassette feed");
564: return lp_printer_status(16);
565: case CMD_HANDFEED:
566: Log_Printf(LOG_LP_LEVEL, "[LP] Hand feed");
567: return lp_printer_status(16);
568: case CMD_RETRANSCANC:
569: Log_Printf(LOG_LP_LEVEL, "[LP] Cancel retransmission");
570: return lp_printer_status(16);
571:
572: default:
573: Log_Printf(LOG_WARN, "[LP] Unknown command!");
574: return lp_printer_status(16);
575: }
576: }
577:
578: void lp_gpo_access(Uint8 data) {
579: static Uint8 lp_cmd = 0;
580: static Uint8 lp_stat = 0;
581: static Uint8 lp_old_data = 0;
582:
583: Log_Printf(LOG_LP_LEVEL, "[LP] Control logic access: %02X",data);
584:
585: if ((lp_old_data&LP_GPO_BUSY)!=(data&LP_GPO_BUSY)) {
586: if (!(data&LP_GPO_BUSY)) {
587: Log_Printf(LOG_LP_LEVEL, "[LP] Printer command: %02X",lp_cmd);
588: lp_stat = lp_printer_command(lp_cmd);
589: } else {
590: lp_cmd = 0;
591: }
592: }
593: if (data&LP_GPO_BUSY) {
594: if ((data&LP_GPO_CLOCK) && !(lp_old_data&LP_GPO_CLOCK)) {
595: lp_cmd <<= 1;
596: lp_cmd |= (data&LP_GPO_CMD_BIT)?1:0;
597: }
598: } else if (nlp.stat&LP_GPI_BUSY) {
599: if ((data&LP_GPO_CLOCK) && !(lp_old_data&LP_GPO_CLOCK)) {
600: lp_serial_phase--;
601: if (lp_serial_phase==0) {
602: lp_interface_status(LP_GPI_BUSY, false);
603: Log_Printf(LOG_LP_LEVEL, "[LP] Printer status: %02X",lp_stat);
604: }
605: lp_interface_status(LP_GPI_STAT_BIT,(lp_stat&(1<<lp_serial_phase))?true:false);
606: }
607: }
608:
609: lp_old_data = data;
610: }
611:
612: /* Printer DMA and printing function */
613: void Printer_IO_Handler(void) {
614: CycInt_AcknowledgeInterrupt();
615:
616: if (lp_data_transfer) {
617: lp_buffer.limit = 4096;
618: dma_printer_read_memory();
619:
620: if (lp_buffer.size==0) {
621: Log_Printf(LOG_LP_LEVEL,"[LP] Printing done.");
622: nlp.csr.dma |= LP_DMA_OUT_UNDR;
623: lp_set_interrupt();
624: return;
625: }
626: /* Save data to printing buffer */
627: lp_png_print();
628:
629: lp_buffer.size = 0;
630:
631: CycInt_AddRelativeInterrupt(200000, INT_CPU_CYCLE, INTERRUPT_LP_IO);
632: }
633: }
634:
635: /* Printer reset function */
636: void Printer_Reset(void) {
637: nlp.csr.dma = 0;
638: nlp.csr.printer = 0;
639: nlp.csr.interface = 0;
640: nlp.csr.cmd = 0;
641: nlp.data = 0;
642: nlp.stat = 0;
643:
644: lp_data_transfer = false;
645:
646: set_interrupt(INT_PRINTER, RELEASE_INT);
647: }
648:
649:
650: /* Helper function for building path and filename of output file */
651: char *lp_get_filename(void) {
652: static char *lp_outfile = NULL;
653: static char lp_filename[32];
654: static char lp_extension[16];
655: static int lp_pagecount = 0;
656: int lp_duplicate_count = 0;
657:
658: if (File_DirExists(ConfigureParams.Printer.szPrintToFileName)) {
659: sprintf(lp_filename, "%05d_next_printer", lp_pagecount);
660:
661: do {
662: if (lp_duplicate_count) {
663: sprintf(lp_extension, "%i.png",lp_duplicate_count);
664: } else {
665: sprintf(lp_extension, ".png");
666: }
667: lp_outfile = File_MakePath(ConfigureParams.Printer.szPrintToFileName,
668: lp_filename, lp_extension);
669:
670: lp_duplicate_count++;
671: } while (File_Exists(lp_outfile) && lp_duplicate_count<1000);
672: }
673:
674: if (lp_outfile==NULL) {
675: lp_outfile = "\0";
676: }
677:
678: lp_pagecount++;
679: lp_pagecount %= 100000;
680:
681: return lp_outfile;
682: }
683:
684:
685: /* PNG printing functions */
686: #if USE_PNG_PRINTING
687: const int MAX_PAGE_LEN = 400 * 14; // 14 inches is the length of US legal paper, longest paper that fits into the NeXT printer cartridge
688: png_structp png_ptr = NULL;
689: png_infop png_info_ptr = NULL;
690: png_byte** png_row_pointers = NULL;
691: int png_width;
692: int png_height;
693: int png_count;
694: int png_page_count = 0;
695: char* png_path;
696: #endif
697:
698: void lp_png_setup(Uint32 data) {
699: #if USE_PNG_PRINTING
700: int i;
701: png_width = ((data >> 16) & 0x7F) * 32;
702:
703: if (png_ptr) {
704: for (i = 0; i < MAX_PAGE_LEN; i++) {
705: png_free(png_ptr, png_row_pointers[i]);
706: }
707: png_free(png_ptr, png_row_pointers);
708: png_destroy_write_struct(&png_ptr, &png_info_ptr);
709: }
710:
711: png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
712: if (png_ptr == NULL) {
713: return;
714: }
715: png_info_ptr = png_create_info_struct(png_ptr);
716: if (png_info_ptr == NULL) {
717: png_destroy_write_struct(&png_ptr, &png_info_ptr);
718: png_ptr = NULL;
719: return;
720: }
721:
722: png_row_pointers = png_malloc(png_ptr, MAX_PAGE_LEN * sizeof (png_byte *));
723: for (i = 0; i < MAX_PAGE_LEN; i++) {
724: png_row_pointers[i] = png_malloc(png_ptr, sizeof (uint8_t) * (png_width / 8));
725: }
726: png_count = 0;
727: png_height = 0;
728: #endif
729: }
730:
731: void lp_png_print(void) {
732: #if USE_PNG_PRINTING
733: int i;
734:
735: for (i = 0; i < lp_buffer.size; i++) {
736: png_row_pointers[png_count/png_width][(png_count%png_width)/8] = ~lp_buffer.data[i];
737: png_count += 8;
738: }
739: #endif
740: }
741:
742: void lp_png_finish(void) {
743: #if USE_PNG_PRINTING
744: png_set_IHDR(png_ptr,
745: png_info_ptr,
746: png_width,
747: png_count / png_width,
748: 1,
749: PNG_COLOR_TYPE_GRAY,
750: PNG_INTERLACE_NONE,
751: PNG_COMPRESSION_TYPE_DEFAULT,
752: PNG_FILTER_TYPE_DEFAULT);
753:
754: png_path = lp_get_filename();
755:
756: FILE* png_fp = File_Open(png_path, "wb");
757:
758: if (png_fp) {
759: png_init_io(png_ptr, png_fp);
760: png_set_rows(png_ptr, png_info_ptr, png_row_pointers);
761: png_write_png(png_ptr, png_info_ptr, PNG_TRANSFORM_IDENTITY, NULL);
762: } else {
763: Statusbar_AddMessage("Laser Printer Error: Could not create output file!", 10000);
764: }
765:
766: File_Close(png_fp);
767: png_page_count++;
768: #endif
769: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.