hal_ax5214h.c

CNC 的开放码,EMC2 V2.2.8版

	indata = rtapi_inb(board->base_addr+4);
	split_input(indata, &(board->port_2A[0]), 8);
    }
    if ( (board->dir_bits & 0x20) == 0 ) {
	indata = rtapi_inb(board->base_addr+5);
	split_input(indata, &(board->port_2B[0]), 8);
    }
    if ( (board->dir_bits & 0xA0) != 0xA0 ) {
	indata = rtapi_inb(board->base_addr+6);
	if ( (board->dir_bits & 0x40) == 0 ) {
	    split_input(indata, &(board->port_2CL[0]), 4);
	}
	indata >>= 4;
	if ( (board->dir_bits & 0x80) == 0 ) {
	    split_input(indata, &(board->port_2CH[0]), 4);
	}
    }
}

unsigned char build_output(io_pin_t *src, int num)
{
    int b;
    unsigned char data, mask;

    data = 0x00;
    mask = 0x01;
    /* assemble output byte for data port from 'num' source variables */
    for (b = 0; b < num; b++) {
	/* get the data, add to output byte */
	if ( *(src->data) ) {
	    if ( !(src->io.invert) ) {
		data |= mask;
	    }
	} else {
	    if ( (src->io.invert) ) {
		data |= mask;
	    }
	}
	mask <<= 1;
	src++;
    }
    return data;
}

static void write_board(void *arg, long period)
{
    board_t *board;
    unsigned char outdata, tmp;

    board = arg;
    if ( (board->dir_bits & 0x01) == 0x01 ) {
	outdata = build_output(&(board->port_1A[0]), 8);
	rtapi_outb(~outdata, board->base_addr+0);
    }
    if ( (board->dir_bits & 0x02) == 0x02 ) {
	outdata = build_output(&(board->port_1B[0]), 8);
	rtapi_outb(~outdata, board->base_addr+1);
    }
    if ( (board->dir_bits & 0x0A) != 0x00 ) {
	outdata = 0;
	if ( (board->dir_bits & 0x04) == 0x04 ) {
	    tmp = build_output(&(board->port_1CL[0]), 4);
	    outdata = tmp;
	}
	if ( (board->dir_bits & 0x08) == 0x08 ) {
	    tmp = build_output(&(board->port_1CH[0]), 4);
	    outdata = outdata | (tmp << 4);
	}
	rtapi_outb(~outdata, board->base_addr+2);
    }
    if ( (board->dir_bits & 0x10) == 0x10 ) {
	outdata = build_output(&(board->port_2A[0]), 8);
	rtapi_outb(~outdata, board->base_addr+4);
    }
    if ( (board->dir_bits & 0x20) == 0x20 ) {
	outdata = build_output(&(board->port_2B[0]), 8);
	rtapi_outb(~outdata, board->base_addr+5);
    }
    if ( (board->dir_bits & 0xA0) != 0x00 ) {
	outdata = 0;
	if ( (board->dir_bits & 0x40) == 0x40 ) {
	    tmp = build_output(&(board->port_2CL[0]), 4);
	    outdata = tmp;
	}
	if ( (board->dir_bits & 0x80) == 0x80 ) {
	    tmp = build_output(&(board->port_2CH[0]), 4);
	    outdata = outdata | (tmp << 4);
	}
	rtapi_outb(~outdata, board->base_addr+6);
    }
}

/***********************************************************************
*                   LOCAL FUNCTION DEFINITIONS                         *
************************************************************************/

static int pins_and_params(char *argv[])
{
    unsigned short board_addr[MAX_BOARDS];
    unsigned char dir_bits[MAX_BOARDS], mask;
    int n, m, retval;

    /* clear port_addr and dir_bits arrays */
    for (n = 0; n < MAX_BOARDS; n++) {
	board_addr[n] = 0;
	dir_bits[n] = 0;
    }
    /* parse config string, results in port_addr[] and data_dir[] arrays */
    num_boards = 0;
    n = 0;
    while ((num_boards < MAX_BOARDS) && (argv[n] != 0)) {
	board_addr[num_boards] = parse_board_addr(argv[n]);
	if (board_addr[num_boards] == 0) {
	    rtapi_print_msg(RTAPI_MSG_ERR,
		"AX5124H: ERROR: bad port address '%s'\n", argv[n]);
	    return -1;
	}
	n++;
	if (argv[n] == 0) {
	    rtapi_print_msg(RTAPI_MSG_ERR,
		"AX5124H: ERROR: no config info for port %s\n", argv[n-1]);
	    return -1;
	}
	/* should be a string of 8 'I" or "O" characters */
	dir_bits[num_boards] = 0;
	mask = 0x01;
	for ( m = 0 ; m < 8 ; m++ ) {
	    /* test character and set/clear bit */
	    if ((argv[n][m] == 'i') || (argv[n][m] == 'I')) {
		/* input, set mask bit to zero */
		dir_bits[num_boards] &= ~mask;
	    } else if ((argv[n][m] == 'o') || (argv[n][m] == 'O')) {
		/* output, set mask bit to one */
		dir_bits[num_boards] |= mask;
	    } else {
		rtapi_print_msg(RTAPI_MSG_ERR,
		"AX5124H: ERROR: bad config info for port %s: '%s'\n", argv[n-1], argv[n]);
		return -1;
	    }
	    /* shift mask for next but */
	    mask <<= 1;
	}
	n++;
	num_boards++;
    }
    /* OK, now we've parsed everything */
    if (num_boards == 0) {
	rtapi_print_msg(RTAPI_MSG_ERR,
	    "AX5214H: ERROR: no ports configured\n");
	return -1;
    }
    /* have good config info, connect to the HAL */
    comp_id = hal_init("hal_ax5214h");
    if (comp_id < 0) {
	rtapi_print_msg(RTAPI_MSG_ERR, "AX5214H: ERROR: hal_init() failed\n");
	return -1;
    }
    /* allocate shared memory for board data */
    board_array = hal_malloc(num_boards * sizeof(board_t));
    if (board_array == 0) {
	rtapi_print_msg(RTAPI_MSG_ERR,
	    "AX5214H: ERROR: hal_malloc() failed\n");
	hal_exit(comp_id);
	return -1;
    }
    /* export all the pins and params for each board */
    for (n = 0; n < num_boards; n++) {
	/* config addr and direction */
	board_array[n].base_addr = board_addr[n];
	board_array[n].dir_bits = dir_bits[n];
	/* export all vars */
	retval = export_board(n, &(board_array[n]));
	if (retval != 0) {
	    rtapi_print_msg(RTAPI_MSG_ERR,
		"AX5214H: ERROR: board %d (%04X) var export failed\n", n, board_addr[n]);
	    hal_exit(comp_id);
	    return -1;
	}
    }
    return 0;
}

static unsigned short parse_board_addr(char *cp)
{
    unsigned short result;

    /* initial value */
    result = 0;
    /* test for leading '0x' */
    if (cp[0] == '0') {
	if ((cp[1] == 'X') || (cp[1] == 'x')) {
	    /* leading '0x', skip it */
	    cp += 2;
	}
    }
    /* ok, now parse digits */
    while (*cp != '\0') {
	/* if char is a hex digit, add it to result */
	if ((*cp >= '0') && (*cp <= '9')) {
	    result <<= 4;
	    result += *cp - '0';
	} else if ((*cp >= 'A') && (*cp <= 'F')) {
	    result <<= 4;
	    result += (*cp - 'A') + 10;
	} else if ((*cp >= 'a') && (*cp <= 'f')) {
	    result <<= 4;
	    result += (*cp - 'a') + 10;
	} else {
	    /* not a valid hex digit */
	    return 0;
	}
	/* next char */
	cp++;
    }
    return result;
}

static int export_board(int boardnum, board_t * board)
{
    int retval, msg, dir;
    unsigned char config;

    /* This function exports a lot of stuff, which results in a lot of
       logging if msg_level is at INFO or ALL. So we save the current value
       of msg_level and restore it later.  If you actually need to log this
       function's actions, change the second line below */

    msg = rtapi_get_msg_level();
    rtapi_set_msg_level(RTAPI_MSG_WARN);
    retval = 0;
    config = 0x80;
    dir = board->dir_bits & 0x01;
    retval += export_port ( boardnum, 0, &(board->port_1A[0]), 8, dir );
    if ( dir == 0 ) {
	config |= 0x10;
    }
    dir = board->dir_bits & 0x02;
    retval += export_port ( boardnum, 8, &(board->port_1B[0]), 8, dir );
    if ( dir == 0 ) {
	config |= 0x02;
    }
    dir = board->dir_bits & 0x04;
    retval += export_port ( boardnum, 16, &(board->port_1CL[0]), 4, dir );
    if ( dir == 0 ) {
	config |= 0x01;
    }
    dir = board->dir_bits & 0x08;
    retval += export_port ( boardnum, 20, &(board->port_1CH[0]), 4, dir );
    if ( dir == 0 ) {
	config |= 0x08;
    }
    board->port1config = config;
    config = 0x80;
    
    dir = board->dir_bits & 0x10;
    retval += export_port ( boardnum, 24, &(board->port_2A[0]), 8, dir );
    if ( dir == 0 ) {
	config |= 0x10;
    }
    dir = board->dir_bits & 0x20;
    retval += export_port ( boardnum, 32, &(board->port_2B[0]), 8, dir );
    if ( dir == 0 ) {
	config |= 0x02;
    }
    dir = board->dir_bits & 0x40;
    retval += export_port ( boardnum, 40, &(board->port_2CL[0]), 4, dir );
    if ( dir == 0 ) {
	config |= 0x01;
    }
    dir = board->dir_bits & 0x80;
    retval += export_port ( boardnum, 44, &(board->port_2CH[0]), 4, dir );
    if ( dir == 0 ) {
	config |= 0x08;
    }
    board->port2config = config;
    /* initialize hardware - all outputs high 
        (since outputs are active low) */
    outb(board->port1config, board->base_addr+3);
    outb(0xff, board->base_addr+0);
    outb(0xff, board->base_addr+1);
    outb(0xff, board->base_addr+2);
    outb(board->port2config, board->base_addr+7);
    outb(0xff, board->base_addr+4);
    outb(0xff, board->base_addr+5);
    outb(0xff, board->base_addr+6);
    /* restore saved message level */
    rtapi_set_msg_level(msg);
    return retval;
}

static int export_port(int boardnum, int pin_num, io_pin_t *pin, int num_pins, int dir)
{
    int n, retval;

    retval = 0;
    for ( n = 0 ; n < num_pins ; n++ ) {
	if ( dir == 0 ) {
	    retval += export_input_pin(boardnum, pin_num, pin );
	} else {
	    retval += export_output_pin(boardnum, pin_num, pin );
	}
	pin_num++;
	pin++;
    }
    return retval;
}

static int export_input_pin(int boardnum, int pinnum, io_pin_t *pin)
{
    char buf[HAL_NAME_LEN + 2];
    int retval;

    /* export read only HAL pin for input data */
    rtapi_snprintf(buf, HAL_NAME_LEN, "ax5214h.%d.in-%02d", boardnum, pinnum);
    retval = hal_pin_bit_new(buf, HAL_OUT, &(pin->data), comp_id);
    if (retval != 0) {
	return retval;
    }
    /* export additional pin for inverted input data */
    rtapi_snprintf(buf, HAL_NAME_LEN, "ax5214h.%d.in-%02d-not", boardnum, pinnum);
    retval = hal_pin_bit_new(buf, HAL_OUT, &(pin->io.not), comp_id);
    /* initialize HAL pins */
    *(pin->data) = 0;
    *(pin->io.not) = 1;
    return retval;
}

static int export_output_pin(int boardnum, int pinnum, io_pin_t *pin)
{
    char buf[HAL_NAME_LEN + 2];
    int retval;

    /* export read only HAL pin for output data */
    rtapi_snprintf(buf, HAL_NAME_LEN, "ax5214h.%d.out-%02d", boardnum, pinnum);
    retval = hal_pin_bit_new(buf, HAL_IN, &(pin->data), comp_id);
    if (retval != 0) {
	return retval;
    }
    /* export parameter for polarity */
    rtapi_snprintf(buf, HAL_NAME_LEN, "ax5214h.%d.out-%02d-invert", boardnum, pinnum);
    retval = hal_param_bit_new(buf, HAL_RW, &(pin->io.invert), comp_id);
    /* initialize HAL pin and param */
    *(pin->data) = 0;
    pin->io.invert = 0;
    return retval;
}