Source to src/printer.c

/*  Previous - printer.c
 
 This file is distributed under the GNU Public License, version 2 or at
 your option any later version. Read the file gpl.txt for details.
 
 NeXT Laser Printer emulation.
 
 */

#include "ioMem.h"
#include "ioMemTables.h"
#include "m68000.h"
#include "configuration.h"
#include "printer.h"
#include "sysReg.h"
#include "dma.h"
#include "statusbar.h"
#include "file.h"

#if HAVE_LIBPNG
#include <png.h>
#endif

#define IO_SEG_MASK 0x1FFFF

#define LOG_LP_REG_LEVEL    LOG_DEBUG
#define LOG_LP_LEVEL        LOG_DEBUG


struct {
    /* Registers */
    struct {
        Uint8 dma;
        Uint8 printer;
        Uint8 interface;
        Uint8 cmd;
    } csr;
    Uint32 data;
    
    /* Internal */
    Uint8 stat;
    Uint8 statmask;
    Uint32 margins;
} nlp;

void lp_power_on(void);
void lp_power_off(void);
void lp_set_interrupt(void);
void lp_release_interrupt(void);
Uint32 lp_data_read(void);
void lp_boot_message(void);
void lp_interface_command(Uint8 cmd, Uint32 data);
void lp_interface_status(Uint8 stat, bool set);
void lp_gpo_access(Uint8 data);
void lp_printer_reset(void);

void lp_png_setup(Uint32 data);
void lp_png_print(void);
void lp_png_finish(void);

bool lp_data_transfer = false;

/* Laser Printer control and status register (0x0200F000)
 *
 * x--- ---- ---- ---- ---- ---- ---- ----  dma out enable (r/w)
 * -x-- ---- ---- ---- ---- ---- ---- ----  dma out request (r)
 * --x- ---- ---- ---- ---- ---- ---- ----  dma out underrun detected (r/w)
 * ---- x--- ---- ---- ---- ---- ---- ----  dma in enable (r/w)
 * ---- -x-- ---- ---- ---- ---- ---- ----  dma in request (r)
 * ---- --x- ---- ---- ---- ---- ---- ----  dma in overrun detected (r/w)
 * ---- ---x ---- ---- ---- ---- ---- ----  increment buffer read pointer (r/w)
 *
 * ---- ---- x--- ---- ---- ---- ---- ----  printer on/off (r/w)
 * ---- ---- -x-- ---- ---- ---- ---- ----  behave like monitor interface (r/w)
 * ---- ---- ---- x--- ---- ---- ---- ----  printer interrupt (r)
 * ---- ---- ---- -x-- ---- ---- ---- ----  printer data available (r)
 * ---- ---- ---- --x- ---- ---- ---- ----  printer data overrun (r/w)
 *
 * ---- ---- ---- ---- x--- ---- ---- ----  dma out transmit pending (r)
 * ---- ---- ---- ---- -x-- ---- ---- ----  dma out transmit in progress (r)
 * ---- ---- ---- ---- --x- ---- ---- ----  cpu data transmit pending (r)
 * ---- ---- ---- ---- ---x ---- ---- ----  cpu data transmit in progress (r)
 * ---- ---- ---- ---- ---- --x- ---- ----  printer interface enable (return from reset state) (r/w)
 * ---- ---- ---- ---- ---- ---x ---- ----  loop back transmitter data (r/w)
 *
 * ---- ---- ---- ---- ---- ---- xxxx xxxx  command to append on printer data (r/w)
 *
 * ---x ---- --xx ---x ---- xx-- ---- ----  zero bits
 */

#define LP_DMA_OUT_EN   0x80
#define LP_DMA_OUT_REQ  0x40
#define LP_DMA_OUT_UNDR 0x20
#define LP_DMA_IN_EN    0x08
#define LP_DMA_IN_REQ   0x04
#define LP_DMA_IN_OVR   0x02
#define LP_DMA_INCR     0x01

#define LP_ON           0x80
#define LP_NDI          0x40
#define LP_INT          0x08
#define LP_DATA         0x04
#define LP_DATA_OVR     0x02

#define LP_TX_DMA_PEND  0x80
#define LP_TX_DMA       0x40
#define LP_TX_CPU_PEND  0x20
#define LP_TX_CPU       0x10
#define LP_TX_EN        0x02
#define LP_TX_LOOP      0x01


void LP_CSR0_Read(void) { // 0x0200F000
    IoMem[IoAccessCurrentAddress & IO_SEG_MASK] = nlp.csr.dma;
    Log_Printf(LOG_LP_REG_LEVEL,"[LP] CSR0 read at $%08x val=$%02x PC=$%08x\n", IoAccessCurrentAddress, IoMem[IoAccessCurrentAddress & IO_SEG_MASK], m68k_getpc());
}

void LP_CSR0_Write(void) {
    Uint8 val = IoMem[IoAccessCurrentAddress & IO_SEG_MASK];
    Log_Printf(LOG_LP_REG_LEVEL,"[LP] CSR0 write at $%08x val=$%02x PC=$%08x\n", IoAccessCurrentAddress, IoMem[IoAccessCurrentAddress & IO_SEG_MASK], m68k_getpc());
    
    if (val&LP_DMA_OUT_UNDR) {
        nlp.csr.dma &= ~(LP_DMA_OUT_UNDR|LP_DMA_OUT_REQ);
        lp_release_interrupt();
    }
    if (val&LP_DMA_IN_OVR) {
        nlp.csr.dma &= ~(LP_DMA_IN_OVR|LP_DMA_IN_REQ);
        lp_release_interrupt();
    }
}

void LP_CSR1_Read(void) { // 0x0200F001
    IoMem[IoAccessCurrentAddress & IO_SEG_MASK] = nlp.csr.printer;
    Log_Printf(LOG_LP_REG_LEVEL,"[LP] CSR1 read at $%08x val=$%02x PC=$%08x\n", IoAccessCurrentAddress, IoMem[IoAccessCurrentAddress & IO_SEG_MASK], m68k_getpc());
}

void LP_CSR1_Write(void) {
    Uint8 val = IoMem[IoAccessCurrentAddress & IO_SEG_MASK];
    Log_Printf(LOG_LP_REG_LEVEL,"[LP] CSR1 write at $%08x val=$%02x PC=$%08x\n", IoAccessCurrentAddress, IoMem[IoAccessCurrentAddress & IO_SEG_MASK], m68k_getpc());
    
    if (((val&LP_ON) != (nlp.csr.printer&LP_ON)) && ConfigureParams.Printer.bPrinterConnected) {
        if (val&LP_ON) {
            Statusbar_AddMessage("Switching Laser Printer ON.", 0);
            lp_power_on();
        } else {
            Statusbar_AddMessage("Switching Laser Printer OFF.", 0);
            lp_power_off();
        }
    }
    nlp.csr.printer = val;
    
    if (val&LP_DATA_OVR) {
        nlp.csr.printer &= ~(LP_DATA_OVR|LP_DATA);
        lp_release_interrupt();
    }
}

void LP_CSR2_Read(void) { // 0x0200F002
    IoMem[IoAccessCurrentAddress & IO_SEG_MASK] = nlp.csr.interface;
    Log_Printf(LOG_LP_REG_LEVEL,"[LP] CSR2 read at $%08x val=$%02x PC=$%08x\n", IoAccessCurrentAddress, IoMem[IoAccessCurrentAddress & IO_SEG_MASK], m68k_getpc());
}

void LP_CSR2_Write(void) {
    Uint8 val = IoMem[IoAccessCurrentAddress & IO_SEG_MASK];
    Log_Printf(LOG_LP_REG_LEVEL,"[LP] CSR2 write at $%08x val=$%02x PC=$%08x\n", IoAccessCurrentAddress, IoMem[IoAccessCurrentAddress & IO_SEG_MASK], m68k_getpc());
    
    if ((val&LP_TX_EN) != (nlp.csr.interface&LP_TX_EN)) {
        if (val&LP_TX_EN) {
            Log_Printf(LOG_LP_LEVEL,"[LP] Enable serial interface.");
            if (ConfigureParams.Printer.bPrinterConnected) {
                lp_boot_message();
            }
        } else {
            Log_Printf(LOG_LP_LEVEL,"[LP] Disable serial interface.");
        }
    }
    nlp.csr.interface = val;
}

void LP_CSR3_Read(void) { // 0x0200F003
    IoMem[IoAccessCurrentAddress & IO_SEG_MASK] = nlp.csr.cmd;
    Log_Printf(LOG_LP_REG_LEVEL,"[LP] CSR3 read at $%08x val=$%02x PC=$%08x\n", IoAccessCurrentAddress, IoMem[IoAccessCurrentAddress & IO_SEG_MASK], m68k_getpc());
}

void LP_CSR3_Write(void) {
    nlp.csr.cmd=IoMem[IoAccessCurrentAddress & IO_SEG_MASK];
    Log_Printf(LOG_LP_REG_LEVEL,"[LP] CSR3 write at $%08x val=$%02x PC=$%08x\n", IoAccessCurrentAddress, IoMem[IoAccessCurrentAddress & IO_SEG_MASK], m68k_getpc());
}

void LP_Data_Read(void) { // 0x0200F004 (access must be 32-bit)
    nlp.data = lp_data_read();
    IoMem_WriteLong(IoAccessCurrentAddress&IO_SEG_MASK, nlp.data);
    Log_Printf(LOG_LP_REG_LEVEL,"[LP] Data read at $%08x val=$%08x PC=$%08x\n", IoAccessCurrentAddress, nlp.data, m68k_getpc());
}

void LP_Data_Write(void) {
    nlp.data = IoMem_ReadLong(IoAccessCurrentAddress&IO_SEG_MASK);
    Log_Printf(LOG_LP_REG_LEVEL,"[LP] Data write at $%08x val=$%08x PC=$%08x\n", IoAccessCurrentAddress, nlp.data, m68k_getpc());

    if (ConfigureParams.Printer.bPrinterConnected) {
        lp_interface_command(nlp.csr.cmd, nlp.data);
    }
}


/* Printer interrupt functions */
void lp_set_interrupt(void) {
    nlp.csr.printer |= LP_INT;
    set_interrupt(INT_PRINTER, SET_INT);
}

void lp_release_interrupt(void) {
    if ((nlp.csr.printer&(LP_DATA|LP_DATA_OVR)) || (nlp.csr.dma&(LP_DMA_OUT_UNDR|LP_DMA_IN_OVR))) {
        return;
    }
    nlp.csr.printer &= ~LP_INT;
    set_interrupt(INT_PRINTER, RELEASE_INT);
}


/* Commands from CPU to Printer */
#define LP_CMD_RESET    0xff
#define LP_CMD_DATA_OUT 0xc7
#define LP_CMD_GPO      0xc4
#define LP_CMD_GPI_MASK 0xc5
#define LP_CMD_GPI_REQ  0x04
#define LP_CMD_MARGINS  0xc2

#define LP_CMD_MASK     0xc7
#define LP_CMD_NODATA   0x07
#define LP_CMD_DATA_EN  0x08
#define LP_CMD_300DPI   0x10
#define LP_CMD_NORMAL   0x20

/* Responses from Printer to CPU */
#define LP_RES_DATA_IN  0xc7
#define LP_RES_GPI      0xc4
#define LP_RES_COPY     0xe7
#define LP_RES_DATA_REQ 0x07
#define LP_RES_UNDERRUN 0x0f


/* Data for commands */
#define LP_GPI_PWR_RDY  0x10
#define LP_GPI_RDY      0x08
#define LP_GPI_VSREQ    0x04
#define LP_GPI_BUSY     0x02
#define LP_GPI_STAT_BIT 0x01

#define LP_GPO_DENSITY  0x40
#define LP_GPO_VSYNC    0x20
#define LP_GPO_ENABLE   0x10
#define LP_GPO_PWR_RDY  0x08
#define LP_GPO_CLOCK    0x04
#define LP_GPO_CMD_BIT  0x02
#define LP_GPO_BUSY     0x01

static void lp_gpo(Uint8 cmd) {
    if (cmd&LP_GPO_DENSITY) {
        Log_Printf(LOG_LP_LEVEL,"[LP] Printer 300 DPI mode");
    }
    if (cmd&LP_GPO_VSYNC) {
        Log_Printf(LOG_LP_LEVEL,"[LP] Printer VSYNC enable");
        lp_interface_status(LP_GPI_VSREQ, false);
    }
    if (cmd&LP_GPO_ENABLE) {
        Log_Printf(LOG_LP_LEVEL,"[LP] Printer enable");
        lp_interface_status(LP_GPI_VSREQ, true);
    }
    if (cmd&LP_GPO_PWR_RDY) {
        Log_Printf(LOG_LP_LEVEL,"[LP] Printer controller power ready");
    }
    if (cmd&LP_GPO_CLOCK) {
        Log_Printf(LOG_LP_LEVEL,"[LP] Printer serial data clock");
    }
    if (cmd&LP_GPO_CMD_BIT) {
        Log_Printf(LOG_LP_LEVEL,"[LP] Printer serial data command bits");
    }
    if (cmd&LP_GPO_BUSY) {
        Log_Printf(LOG_LP_LEVEL,"[LP] Printer controller busy");
    }
    lp_gpo_access(cmd);
}

static void lp_gpi(void) {
    nlp.data = (~nlp.stat)<<24;
    
    nlp.csr.cmd = LP_RES_GPI;
    
    if (nlp.csr.printer&LP_DATA) {
        nlp.csr.printer |= LP_DATA_OVR;
    } else {
        nlp.csr.printer |= LP_DATA;
    }
    
    lp_set_interrupt();
}

void lp_interface_status(Uint8 changed_bits, bool set) {
    bool lp_gpi_message = false;
    
    Log_Printf(LOG_LP_LEVEL,"[LP] Interface status: %02X (mask: %02X)",nlp.stat,nlp.statmask);

    if ((changed_bits&nlp.statmask) != (nlp.stat&changed_bits&nlp.statmask)) {
        lp_gpi_message = true;
    }
    
    if (set) {
        nlp.stat |= changed_bits;
    } else {
        nlp.stat &= ~changed_bits;
    }
    
    if (lp_gpi_message) {
        lp_gpi();
    }
}

void lp_interface_command(Uint8 cmd, Uint32 data) {
    switch (cmd) {
        case LP_CMD_RESET:
            Log_Printf(LOG_LP_LEVEL,"[LP] Interface command: Reset (%08X)",data);
            lp_printer_reset();
            lp_boot_message();
            break;
        case LP_CMD_DATA_OUT:
            Log_Printf(LOG_LP_LEVEL,"[LP] Interface command: Data out (%08X)",data);
            lp_buffer.data[lp_buffer.size] = (data>>24)&0xFF;
            lp_buffer.data[lp_buffer.size+1] = (data>>16)&0xFF;
            lp_buffer.data[lp_buffer.size+2] = (data>>8)&0xFF;
            lp_buffer.data[lp_buffer.size+3] = data&0xFF;
            lp_buffer.size +=4;
            break;
        case LP_CMD_GPO:
            Log_Printf(LOG_LP_LEVEL,"[LP] Interface command: General purpose out (%02X)",(~data)>>24);
            lp_gpo((~data)>>24);
            break;
        case LP_CMD_GPI_MASK:
            Log_Printf(LOG_LP_LEVEL,"[LP] Interface command: General purpose input mask (%02X)",(~data)>>24);
            nlp.statmask = (~data)>>24;
            break;
        case LP_CMD_GPI_REQ:
            Log_Printf(LOG_LP_LEVEL,"[LP] Interface command: General purpose input request");
            lp_gpi();
            break;
        case LP_CMD_MARGINS:
            Log_Printf(LOG_LP_LEVEL,"[LP] Interface command: Margins (%08X)",data);
            nlp.margins = data;
            break;
            
        default: /* Commands with no data */
            if ((cmd&LP_CMD_MASK)==LP_CMD_NODATA) {
                Log_Printf(LOG_LP_LEVEL,"[LP] Interface command: No data command:");

                if (cmd&LP_CMD_DATA_EN) {
                    Log_Printf(LOG_LP_LEVEL,"[LP] Enable printer data transfer");
                    /* Setup printing buffer */
                    lp_png_setup(nlp.margins);
                    lp_data_transfer = true;
                    if (lp_buffer.size) {
                        lp_png_print();
                        lp_buffer.size = 0;
                    }
                    Statusbar_AddMessage("Laser Printer Printing Page.", 0);
                    CycInt_AddRelativeInterruptUs(1000, 100, INTERRUPT_LP_IO);
                } else {
                    Log_Printf(LOG_LP_LEVEL,"[LP] Disable printer data transfer");
                    if (lp_data_transfer) {
                        /* Save buffered printing data to image file */
                        lp_png_finish();
                    }
                    lp_data_transfer = false;
                }
                if (cmd&LP_CMD_300DPI) {
                    Log_Printf(LOG_LP_LEVEL,"[LP] 300 DPI mode");
                } else {
                    Log_Printf(LOG_LP_LEVEL,"[LP] 400 DPI mode");
                }
                if (cmd&LP_CMD_NORMAL) {
                    Log_Printf(LOG_LP_LEVEL,"[LP] Normal requests for data transfer");
                } else {
                    Log_Printf(LOG_LP_LEVEL,"[LP] Early requests for data transfer");
                }
            } else {
                Log_Printf(LOG_WARN,"[LP] Interface command: Unknown command!");
            }
            break;
    }
}

void lp_power_on(void) {
    lp_interface_status(LP_GPI_PWR_RDY|LP_GPI_RDY,true);
}

void lp_power_off(void) {
    nlp.stat = 0x00;
}

/* COPY. NeXT 1987 */
Uint32 lp_copyright_message[4] = { 0x00434f50, 0x522e204e, 0x65585420, 0x31393837 };
int lp_copyright_sequence = 0;

void lp_boot_message(void) {
    lp_copyright_sequence = 4;
    
    nlp.csr.cmd = LP_RES_COPY;
    
    nlp.csr.printer |= LP_DATA;
    lp_set_interrupt();
}

Uint32 lp_data_read(void) {
    Uint32 val = 0;
    
    if (lp_copyright_sequence>0) {
        val = lp_copyright_message[4-lp_copyright_sequence];
        lp_copyright_sequence--;
    } else {
        val = nlp.data;
    }
    
    if (lp_copyright_sequence==0) {
        nlp.csr.printer &= ~LP_DATA;
        lp_release_interrupt();
    }

    return val;
}


/* Printer internal command and status via serial interface */
#define CMD_STATUS0     0x01
#define CMD_STATUS1     0x02
#define CMD_STATUS2     0x04
#define CMD_STATUS4     0x08
#define CMD_STATUS5     0x0b
#define CMD_STATUS15    0x1f

#define CMD_EXT_CLK     0x40
#define CMD_PRINTER_CLK 0x43
#define CMD_PAUSE       0x45
#define CMD_UNPAUSE     0x46
#define CMD_DRUM_ON     0x49
#define CMD_DRUM_OFF    0x4a
#define CMD_CASSFEED    0x4c
#define CMD_HANDFEED    0x4f
#define CMD_RETRANSCANC 0x5d

#define STAT0_PRINTREQ  0x40
#define STAT0_PAPERDLVR 0x20
#define STAT0_DATARETR  0x10
#define STAT0_WAIT      0x08
#define STAT0_PAUSE     0x04
#define STAT0_CALL      0x02

#define STAT1_NOCART    0x40
#define STAT1_NOPAPER   0x10
#define STAT1_JAM       0x08
#define STAT1_DOOROPEN  0x04
#define STAT1_TESTPRINT 0x02

#define STAT2_FIXINGASM 0x40
#define STAT2_POORBDSIG 0x20
#define STAT2_SCANMOTOR 0x10

#define STAT5_NOCASS    0x01
#define STAT5_A4        0x02
#define STAT5_LETTER    0x08
#define STAT5_B5        0x13
#define STAT5_LEGAL     0x19

#define STAT15_NOTONER  0x04

static Uint8 lp_serial_status[16] = {
    0,0,0,0,
    0,STAT5_A4,0,0,
    0,0,0,0,
    0,0,0,0
};

static Uint8 lp_serial_phase = 0;

static Uint8 lp_printer_status(Uint8 num) {
    int i;
    Uint8 val;
    
    lp_serial_phase = 8;
    lp_interface_status(LP_GPI_BUSY, true);
    
    if (num==5) {
        switch (ConfigureParams.Printer.nPaperSize) {
            case PAPER_A4: val = STAT5_A4; break;
            case PAPER_LETTER: val = STAT5_LETTER; break;
            case PAPER_B5: val = STAT5_B5; break;
            case PAPER_LEGAL: val = STAT5_LEGAL; break;
            default: val = PAPER_A4; break;
        }
    } else if (num<16) {
        val = lp_serial_status[num];
    } else {
        val = 0x00;
    }
    
    /* odd parity */
    val |= 1;
    for (i = 1; i < 8; i++) {
        if (val & (1 << i)) {
            val ^= 1;
        }
    }
    return val;
}

void lp_printer_reset(void) {
    int i;
    for (i = 0; i < 16; i++) {
        lp_serial_status[i] = 0;
    }
    lp_serial_phase = 0;
}

static Uint8 lp_printer_command(Uint8 cmd) {
    switch (cmd) {
        case CMD_STATUS0:
            Log_Printf(LOG_LP_LEVEL, "[LP] Read status register 0");
            return lp_printer_status(0);
        case CMD_STATUS1:
            Log_Printf(LOG_LP_LEVEL, "[LP] Read status register 1");
            return lp_printer_status(1);
        case CMD_STATUS2:
            Log_Printf(LOG_LP_LEVEL, "[LP] Read status register 2");
            return lp_printer_status(2);
        case CMD_STATUS4:
            Log_Printf(LOG_LP_LEVEL, "[LP] Read status register 4");
            return lp_printer_status(4);
        case CMD_STATUS5:
            Log_Printf(LOG_LP_LEVEL, "[LP] Read status register 5");
            return lp_printer_status(5);
        case CMD_STATUS15:
            Log_Printf(LOG_LP_LEVEL, "[LP] Read status register 15");
            return lp_printer_status(15);
        /* Commands with no status */
        case CMD_EXT_CLK:
            Log_Printf(LOG_LP_LEVEL, "[LP] External clock");
            return lp_printer_status(16);
        case CMD_PRINTER_CLK:
            Log_Printf(LOG_LP_LEVEL, "[LP] Printer clock");
            return lp_printer_status(16);
        case CMD_PAUSE:
            Log_Printf(LOG_LP_LEVEL, "[LP] Pause");
            return lp_printer_status(16);
        case CMD_UNPAUSE:
            Log_Printf(LOG_LP_LEVEL, "[LP] Unpause");
            return lp_printer_status(16);
        case CMD_DRUM_ON:
            Log_Printf(LOG_LP_LEVEL, "[LP] Drum on");
            return lp_printer_status(16);
        case CMD_DRUM_OFF:
            Log_Printf(LOG_LP_LEVEL, "[LP] Drum off");
            return lp_printer_status(16);
        case CMD_CASSFEED:
            Log_Printf(LOG_LP_LEVEL, "[LP] Cassette feed");
            return lp_printer_status(16);
        case CMD_HANDFEED:
            Log_Printf(LOG_LP_LEVEL, "[LP] Hand feed");
            return lp_printer_status(16);
        case CMD_RETRANSCANC:
            Log_Printf(LOG_LP_LEVEL, "[LP] Cancel retransmission");
            return lp_printer_status(16);

        default:
            Log_Printf(LOG_WARN, "[LP] Unknown command!");
            return lp_printer_status(16);
    }
}

void lp_gpo_access(Uint8 data) {
    static Uint8 lp_cmd = 0;
    static Uint8 lp_stat = 0;
    static Uint8 lp_old_data = 0;

    Log_Printf(LOG_LP_LEVEL, "[LP] Control logic access: %02X",data);
    
    if ((lp_old_data&LP_GPO_BUSY)!=(data&LP_GPO_BUSY)) {
        if (!(data&LP_GPO_BUSY)) {
            Log_Printf(LOG_LP_LEVEL, "[LP] Printer command: %02X",lp_cmd);
            lp_stat = lp_printer_command(lp_cmd);
        } else {
            lp_cmd = 0;
        }
    }
    if (data&LP_GPO_BUSY) {
        if ((data&LP_GPO_CLOCK) && !(lp_old_data&LP_GPO_CLOCK)) {
            lp_cmd <<= 1;
            lp_cmd |= (data&LP_GPO_CMD_BIT)?1:0;
        }
    } else if (nlp.stat&LP_GPI_BUSY) {
        if ((data&LP_GPO_CLOCK) && !(lp_old_data&LP_GPO_CLOCK)) {
            lp_serial_phase--;
            if (lp_serial_phase==0) {
                lp_interface_status(LP_GPI_BUSY, false);
                Log_Printf(LOG_LP_LEVEL, "[LP] Printer status: %02X",lp_stat);
            }
            lp_interface_status(LP_GPI_STAT_BIT,(lp_stat&(1<<lp_serial_phase))?true:false);
        }
    }
    
    lp_old_data = data;
}

/* Printer DMA and printing function */
void Printer_IO_Handler(void) {
    CycInt_AcknowledgeInterrupt();
    
    if (lp_data_transfer) {
        lp_buffer.limit = 4096;
        dma_printer_read_memory();
        
        if (lp_buffer.size==0) {
            Log_Printf(LOG_LP_LEVEL,"[LP] Printing done.");
            nlp.csr.dma |= LP_DMA_OUT_UNDR;
            lp_set_interrupt();
            return;
        }
        /* Save data to printing buffer */
        lp_png_print();
        
        lp_buffer.size = 0;
        
        CycInt_AddRelativeInterruptUs(10000, 1000, INTERRUPT_LP_IO);
    }
}

/* Printer reset function */
void Printer_Reset(void) {
    nlp.csr.dma = 0;
    nlp.csr.printer = 0;
    nlp.csr.interface = 0;
    nlp.csr.cmd = 0;
    nlp.data = 0;
    nlp.stat = 0;
    
    lp_data_transfer = false;
    
    set_interrupt(INT_PRINTER, RELEASE_INT);
}


/* Helper function for building path and filename of output file */
static const char *lp_get_filename(void) {
    static const char *lp_outfile = NULL;
    static char lp_filename[32];
    static char lp_extension[16];
    static int lp_pagecount = 0;
    int lp_duplicate_count = 0;
    
    if (File_DirExists(ConfigureParams.Printer.szPrintToFileName)) {
        sprintf(lp_filename, "%05d_next_printer", lp_pagecount);
        
        do {
            if (lp_duplicate_count) {
                sprintf(lp_extension, "%i.png",lp_duplicate_count);
            } else {
                sprintf(lp_extension, ".png");
            }
            lp_outfile = File_MakePath(ConfigureParams.Printer.szPrintToFileName,
                                       lp_filename, lp_extension);

            lp_duplicate_count++;
        } while (File_Exists(lp_outfile) && lp_duplicate_count<1000);
    }
    
    if (lp_outfile==NULL) {
        lp_outfile = "\0";
    }
    
    lp_pagecount++;
    lp_pagecount %= 100000;
    
    return lp_outfile;
}


/* PNG printing functions */
#if HAVE_LIBPNG
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
png_structp png_ptr          = NULL;
png_infop   png_info_ptr     = NULL;
png_byte**  png_row_pointers = NULL;
int         png_width;
int         png_height;
int         png_count;
int         png_page_count   = 0;
const char* png_path;
#endif

void lp_png_setup(Uint32 data) {
#if HAVE_LIBPNG
    int i;
    png_width = ((data >> 16) & 0x7F) * 32;
    
    if (png_ptr) {
        for (i = 0; i < MAX_PAGE_LEN; i++) {
            png_free(png_ptr, png_row_pointers[i]);
        }
        png_free(png_ptr, png_row_pointers);
        png_destroy_write_struct(&png_ptr, &png_info_ptr);
    }
    
    png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
    if (png_ptr == NULL) {
        return;
    }
    png_info_ptr = png_create_info_struct(png_ptr);
    if (png_info_ptr == NULL) {
        png_destroy_write_struct(&png_ptr, &png_info_ptr);
        png_ptr = NULL;
        return;
    }
    
    png_row_pointers = png_malloc(png_ptr, MAX_PAGE_LEN * sizeof (png_byte *));
    for (i = 0; i < MAX_PAGE_LEN; i++) {
        png_row_pointers[i] = png_malloc(png_ptr, sizeof (uint8_t) * (png_width / 8));
    }
    png_count  = 0;
    png_height = 0;
#endif
}

void lp_png_print(void) {
#if HAVE_LIBPNG
    int i;
    
    for (i = 0; i < lp_buffer.size; i++) {
        png_row_pointers[png_count/png_width][(png_count%png_width)/8] = ~lp_buffer.data[i];
        png_count += 8;
    }
#endif
}

void lp_png_finish(void) {
#if HAVE_LIBPNG
    png_set_IHDR(png_ptr,
                 png_info_ptr,
                 png_width,
                 png_count / png_width,
                 1,
                 PNG_COLOR_TYPE_GRAY,
                 PNG_INTERLACE_NONE,
                 PNG_COMPRESSION_TYPE_DEFAULT,
                 PNG_FILTER_TYPE_DEFAULT);
    
    png_path = lp_get_filename();
    
    FILE* png_fp = File_Open(png_path, "wb");
    
    if (png_fp) {
        png_init_io(png_ptr, png_fp);
        png_set_rows(png_ptr, png_info_ptr, png_row_pointers);
        png_write_png(png_ptr, png_info_ptr, PNG_TRANSFORM_IDENTITY, NULL);
    } else {
        Statusbar_AddMessage("Laser Printer Error: Could not create output file!", 10000);
    }
    
    File_Close(png_fp);
    png_page_count++;
#endif
}