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