int main( int argc, char** argv ) { int file = i2c_dev_open( CH7053A_I2C_ADDR ); ch7053a_set_crystal_frequency(file, 27000); ch7053a_set_power_state_3(file, 0, 0, 0, 0, 0, 1, 0, 0); //ch7053a_set_hdtv_output_format(file, 1, CH7053A_HDTV_OUTPUT_FORMAT_480P); ch7035b_write_output_timings(file, 1280,1280,720,720); ch7053a_set_test_pattern(file, 1, 1, CH7053A_TST3_TSTP_COLBAR); ch7053a_set_page(file, 4); ch7053a_read(file, 0x61); }
//****************************************************************************** /// \brief Open device /// \return #mxt_rc int mxt_new_device(struct libmaxtouch_ctx *ctx, struct mxt_conn_info *conn, struct mxt_device **mxt) { int ret; struct mxt_device *new_dev; new_dev = calloc(1, sizeof(struct mxt_device)); if (!new_dev) return MXT_ERROR_NO_MEM; new_dev->ctx = ctx; new_dev->conn = mxt_ref_conn(conn); if (conn == NULL) { mxt_err(ctx, "New device connection parameters not valid"); return MXT_ERROR_NO_DEVICE; } switch (conn->type) { case E_SYSFS: ret = sysfs_open(new_dev); break; case E_I2C_DEV: ret = i2c_dev_open(new_dev); break; #ifdef HAVE_LIBUSB case E_USB: ret = usb_open(new_dev); break; #endif /* HAVE_LIBUSB */ case E_HIDRAW: ret = hidraw_register(new_dev); break; default: mxt_err(ctx, "Device type not supported"); ret = MXT_ERROR_NOT_SUPPORTED; goto failure; } if (ret != 0) goto failure; *mxt = new_dev; return MXT_SUCCESS; failure: mxt_unref_conn(conn); free(new_dev); return ret; }
int program_register_for_913_ar0144(int bus_id) { /* * 913 slave addr: 7'bit: 0x5d * i2cset -y 1 0x61 0x7 0xBA * ar0144 slave addr: 7'bit: 0x10 * i2cset -y 1 0x61 0x9 0x20 * i2cset -y 1 0x61 0x11 0x20 */ int i = 3; unsigned char wbuf[6] = {0x7, 0xBA/*913*/, 0x9, 0x20, 0x11, 0x20}; unsigned char rbuf[2]; unsigned char * pwbuf = wbuf; int i2c_addr = DS90UB914_ADDR; int status; int fd; fd = i2c_dev_open(bus_id); ioctl(fd,I2C_TENBIT,0); // SETTING i2c slave ADDR status = ioctl(fd, I2C_SLAVE, i2c_addr); if (status < 0) { printf("[%s] ERROR: ioctl(fd, I2C_SLAVE, 0x%02X) failed\n", __func__, i2c_addr); close(fd); return -1; } while (i--) { if(write(fd, pwbuf, 2) != 2){ printf("[%s] ERROR: write reg[0x%02x] \n", __func__, *pwbuf); return -1; } read_8bit_reg(fd, pwbuf, rbuf); printf("[%s] [%d] Reg[%x] -- 0x%02x\n", __func__, i, pwbuf[0], rbuf[0]); pwbuf = pwbuf + 2; } close(fd); return 0; }
int i2cdump_main(int argc UNUSED_PARAM, char **argv) { const unsigned opt_f = (1 << 0), opt_y = (1 << 1), opt_r = (1 << 2); const char *const optstr = "fyr:"; int bus_num, bus_addr, mode = I2C_SMBUS_BYTE_DATA, even = 0, pec = 0; unsigned first = 0x00, last = 0xff, opts; int *block = (int *)bb_common_bufsiz1; char *opt_r_str, *dash; int fd, res; opt_complementary = "-2:?3"; /* from 2 to 3 args */ opts = getopt32(argv, optstr, &opt_r_str); argv += optind; bus_num = i2c_bus_lookup(argv[0]); bus_addr = i2c_parse_bus_addr(argv[1]); if (argv[2]) { switch (argv[2][0]) { case 'b': /* Already set. */ break; case 'c': mode = I2C_SMBUS_BYTE; break; case 'w': mode = I2C_SMBUS_WORD_DATA; break; case 'W': mode = I2C_SMBUS_WORD_DATA; even = 1; break; case 's': mode = I2C_SMBUS_BLOCK_DATA; break; case 'i': mode = I2C_SMBUS_I2C_BLOCK_DATA; break; default: bb_error_msg_and_die("invalid mode"); } if (argv[2][1] == 'p') { if (argv[2][0] == 'W' || argv[2][0] == 'i') { bb_error_msg_and_die( "pec not supported for -W and -i"); } else { pec = 1; } } } if (opts & opt_r) { first = strtol(opt_r_str, &dash, 0); if (dash == opt_r_str || *dash != '-' || first > 0xff) bb_error_msg_and_die("invalid range"); last = xstrtou_range(++dash, 0, first, 0xff); /* Range is not available for every mode. */ switch (mode) { case I2C_SMBUS_BYTE: case I2C_SMBUS_BYTE_DATA: break; case I2C_SMBUS_WORD_DATA: if (!even || (!(first % 2) && last % 2)) break; /* Fall through */ default: bb_error_msg_and_die( "range not compatible with selected mode"); } } fd = i2c_dev_open(bus_num); check_read_funcs(fd, mode, -1 /* data_addr */, pec); i2c_set_slave_addr(fd, bus_addr, opts & opt_f); if (pec) i2c_set_pec(fd, 1); if (!(opts & opt_y)) confirm_action(bus_addr, mode, -1 /* data_addr */, pec); /* All but word data. */ if (mode != I2C_SMBUS_WORD_DATA || even) { int blen = 0; if (mode == I2C_SMBUS_BLOCK_DATA || mode == I2C_SMBUS_I2C_BLOCK_DATA) blen = read_block_data(fd, mode, block); if (mode == I2C_SMBUS_BYTE) { res = i2c_smbus_write_byte(fd, first); if (res < 0) bb_perror_msg_and_die("write start address"); } dump_data(fd, mode, first, last, block, blen); } else { dump_word_data(fd, first, last); } return 0; }
int i2cset_main(int argc, char **argv) { const unsigned opt_f = (1 << 0), opt_y = (1 << 1), opt_m = (1 << 2), opt_r = (1 << 3); const char *const optstr = "fym:r"; int bus_num, bus_addr, data_addr, mode = I2C_SMBUS_BYTE, pec = 0; int val, blen = 0, mask = 0, fd, status; unsigned char block[I2C_SMBUS_BLOCK_MAX]; char *opt_m_arg = NULL; unsigned opts; opt_complementary = "-3"; /* from 3 to ? args */ opts = getopt32(argv, optstr, &opt_m_arg); argv += optind; argc -= optind; bus_num = i2c_bus_lookup(argv[0]); bus_addr = i2c_parse_bus_addr(argv[1]); data_addr = i2c_parse_data_addr(argv[2]); if (argv[3]) { if (!argv[4] && argv[3][0] != 'c') { mode = I2C_SMBUS_BYTE_DATA; /* Implicit b */ } else { switch (argv[argc-1][0]) { case 'c': /* Already set */ break; case 'b': mode = I2C_SMBUS_BYTE_DATA; break; case 'w': mode = I2C_SMBUS_WORD_DATA; break; case 's': mode = I2C_SMBUS_BLOCK_DATA; break; case 'i': mode = I2C_SMBUS_I2C_BLOCK_DATA; break; default: bb_error_msg("invalid mode"); bb_show_usage(); } pec = argv[argc-1][1] == 'p'; if (mode == I2C_SMBUS_BLOCK_DATA || mode == I2C_SMBUS_I2C_BLOCK_DATA) { if (pec && mode == I2C_SMBUS_I2C_BLOCK_DATA) bb_error_msg_and_die( "PEC not supported for I2C " "block writes"); if (opts & opt_m) bb_error_msg_and_die( "mask not supported for block " "writes"); } } } /* Prepare the value(s) to be written according to current mode. */ switch (mode) { case I2C_SMBUS_BYTE_DATA: val = xstrtou_range(argv[3], 0, 0, 0xff); break; case I2C_SMBUS_WORD_DATA: val = xstrtou_range(argv[3], 0, 0, 0xffff); break; case I2C_SMBUS_BLOCK_DATA: case I2C_SMBUS_I2C_BLOCK_DATA: for (blen = 3; blen < (argc - 1); blen++) block[blen] = xstrtou_range(argv[blen], 0, 0, 0xff); val = -1; break; default: val = -1; break; } if (opts & opt_m) { mask = xstrtou_range(opt_m_arg, 0, 0, (mode == I2C_SMBUS_BYTE || mode == I2C_SMBUS_BYTE_DATA) ? 0xff : 0xffff); } fd = i2c_dev_open(bus_num); check_write_funcs(fd, mode, pec); i2c_set_slave_addr(fd, bus_addr, opts & opt_f); if (!(opts & opt_y)) confirm_action(bus_addr, mode, data_addr, pec); /* * If we're using mask - read the current value here and adjust the * value to be written. */ if (opts & opt_m) { int tmpval; switch (mode) { case I2C_SMBUS_BYTE: tmpval = i2c_smbus_read_byte(fd); break; case I2C_SMBUS_WORD_DATA: tmpval = i2c_smbus_read_word_data(fd, data_addr); break; default: tmpval = i2c_smbus_read_byte_data(fd, data_addr); } if (tmpval < 0) bb_perror_msg_and_die("can't read old value"); val = (val & mask) | (tmpval & ~mask); if (!(opts & opt_y)) { bb_error_msg("old value 0x%0*x, write mask " "0x%0*x, will write 0x%0*x to register " "0x%02x", mode == I2C_SMBUS_WORD_DATA ? 4 : 2, tmpval, mode == I2C_SMBUS_WORD_DATA ? 4 : 2, mask, mode == I2C_SMBUS_WORD_DATA ? 4 : 2, val, data_addr); confirm_or_abort(); } } if (pec) i2c_set_pec(fd, 1); switch (mode) { case I2C_SMBUS_BYTE: status = i2c_smbus_write_byte(fd, data_addr); break; case I2C_SMBUS_WORD_DATA: status = i2c_smbus_write_word_data(fd, data_addr, val); break; case I2C_SMBUS_BLOCK_DATA: status = i2c_smbus_write_block_data(fd, data_addr, blen, block); break; case I2C_SMBUS_I2C_BLOCK_DATA: status = i2c_smbus_write_i2c_block_data(fd, data_addr, blen, block); break; default: /* I2C_SMBUS_BYTE_DATA */ status = i2c_smbus_write_byte_data(fd, data_addr, val); break; } if (status < 0) bb_perror_msg_and_die("write failed"); if (pec) i2c_set_pec(fd, 0); /* Clear PEC. */ /* No readback required - we're done. */ if (!(opts & opt_r)) return 0; switch (mode) { case I2C_SMBUS_BYTE: status = i2c_smbus_read_byte(fd); val = data_addr; break; case I2C_SMBUS_WORD_DATA: status = i2c_smbus_read_word_data(fd, data_addr); break; default: /* I2C_SMBUS_BYTE_DATA */ status = i2c_smbus_read_byte_data(fd, data_addr); } if (status < 0) { puts("Warning - readback failed"); } else if (status != val) { printf("Warning - data mismatch - wrote " "0x%0*x, read back 0x%0*x\n", mode == I2C_SMBUS_WORD_DATA ? 4 : 2, val, mode == I2C_SMBUS_WORD_DATA ? 4 : 2, status); } else { printf("Value 0x%0*x written, readback matched\n", mode == I2C_SMBUS_WORD_DATA ? 4 : 2, val); } return 0; }
int i2cget_main(int argc UNUSED_PARAM, char **argv) { const unsigned opt_f = (1 << 0), opt_y = (1 << 1); const char *const optstr = "fy"; int bus_num, bus_addr, data_addr = -1, status; int mode = I2C_SMBUS_BYTE, pec = 0, fd; unsigned opts; opt_complementary = "-2:?4"; /* from 2 to 4 args */ opts = getopt32(argv, optstr); argv += optind; bus_num = i2c_bus_lookup(argv[0]); bus_addr = i2c_parse_bus_addr(argv[1]); if (argv[2]) { data_addr = i2c_parse_data_addr(argv[2]); mode = I2C_SMBUS_BYTE_DATA; if (argv[3]) { switch (argv[3][0]) { case 'b': /* Already set */ break; case 'w': mode = I2C_SMBUS_WORD_DATA; break; case 'c': mode = I2C_SMBUS_BYTE; break; default: bb_error_msg("invalid mode"); bb_show_usage(); } pec = argv[3][1] == 'p'; } } fd = i2c_dev_open(bus_num); check_read_funcs(fd, mode, data_addr, pec); i2c_set_slave_addr(fd, bus_addr, opts & opt_f); if (!(opts & opt_y)) confirm_action(bus_addr, mode, data_addr, pec); if (pec) i2c_set_pec(fd, 1); switch (mode) { case I2C_SMBUS_BYTE: if (data_addr >= 0) { status = i2c_smbus_write_byte(fd, data_addr); if (status < 0) bb_error_msg("warning - write failed"); } status = i2c_smbus_read_byte(fd); break; case I2C_SMBUS_WORD_DATA: status = i2c_smbus_read_word_data(fd, data_addr); break; default: /* I2C_SMBUS_BYTE_DATA */ status = i2c_smbus_read_byte_data(fd, data_addr); } close(fd); if (status < 0) bb_perror_msg_and_die("read failed"); printf("0x%0*x\n", mode == I2C_SMBUS_WORD_DATA ? 4 : 2, status); return 0; }