Example #1
0
int pm860x_page_reg_write(struct i2c_client *i2c, int reg,
			  unsigned char data)
{
	unsigned char zero;
	int ret;

	i2c_lock_adapter(i2c->adapter);
	read_device(i2c, 0xFA, 0, &zero);
	read_device(i2c, 0xFB, 0, &zero);
	read_device(i2c, 0xFF, 0, &zero);
	ret = write_device(i2c, reg, 1, &data);
	read_device(i2c, 0xFE, 0, &zero);
	read_device(i2c, 0xFC, 0, &zero);
	i2c_unlock_adapter(i2c->adapter);
	return ret;
}
Example #2
0
/********************************************************************
 * reset_06 WS2300 by sending command 06 (Linux version)
 * 
 * Input:   device number of the already open serial port
 *           
 * Returns: nothing, exits progrsm if failing to reset
 *
 ********************************************************************/
void reset_06(WEATHERSTATION serdevice)
{
	unsigned char command = 0x06;
	unsigned char answer;
	int i;

	for (i = 0; i < 100; i++)
	{

		// Discard any garbage in the input buffer
		tcflush(serdevice, TCIFLUSH);

		write_device(serdevice, &command, 1);

		// Occasionally 0, then 2 is returned.  If zero comes back, continue
		// reading as this is more efficient than sending an out-of sync
		// reset and letting the data reads restore synchronization.
		// Occasionally, multiple 2's are returned.  Read with a fast timeout
		// until all data is exhausted, if we got a two back at all, we
		// consider it a success
		
		while (1 == read_device(serdevice, &answer, 1))
		{
			if (answer == 2)
			{
				return;
			}
		}

		usleep(50000 * i);   //we sleep longer and longer for each retry
	}
	fprintf(stderr, "\nCould not reset\n");
	exit(EXIT_FAILURE);
}
Example #3
0
int pm860x_page_bulk_write(struct i2c_client *i2c, int reg,
			   int count, unsigned char *buf)
{
	unsigned char zero = 0;
	int ret;

	i2c_lock_adapter(i2c->adapter);
	read_device(i2c, 0xFA, 0, &zero);
	read_device(i2c, 0xFB, 0, &zero);
	read_device(i2c, 0xFF, 0, &zero);
	ret = write_device(i2c, reg, count, buf);
	read_device(i2c, 0xFE, 0, &zero);
	read_device(i2c, 0xFC, 0, &zero);
	i2c_unlock_adapter(i2c->adapter);
	i2c_unlock_adapter(i2c->adapter);
	return ret;
}
Example #4
0
int read_fan_value(const int fan, const char *device, int *value) {
  char device_name[LARGEST_DEVICE_NAME];
  char output_value[LARGEST_DEVICE_NAME];
  char full_name[LARGEST_DEVICE_NAME];

  snprintf(device_name, LARGEST_DEVICE_NAME, device, fan);
  snprintf(full_name, LARGEST_DEVICE_NAME, "%s/%s", PWM_DIR,device_name);
  return read_device(full_name, value);
}
Example #5
0
int read_temp(const char *device, int *value) {
  char full_name[LARGEST_DEVICE_NAME + 1];

  /* We set an impossible value to check for errors */
  *value = BAD_TEMP;
  snprintf(
      full_name, LARGEST_DEVICE_NAME, "%s/temp1_input", device);
  return read_device(full_name, value);
}
Example #6
0
File: binding.hpp Project: pfq/PFQ
    static inline
    thread_binding
    read_thread_binding(const char *value)
    {
        auto vec = pfq::split(value, ".");
        if (vec.size() < 2)
            throw std::runtime_error("read_thread_binding: parse error");

        thread_binding t { std::stoi(vec[0]), std::stoi(vec[1]), { }};

        for(size_t n = 2; n < vec.size(); n++)
            t.dev.push_back(read_device(vec[n].c_str()));

        return t;
    }
Example #7
0
static GstFlowReturn
gst_dvbsrc_create (GstPushSrc * element, GstBuffer ** buf)
{
    gint buffer_size;
    GstFlowReturn retval = GST_FLOW_ERROR;
    GstDvbSrc *object;

    object = GST_DVBSRC (element);
    GST_LOG ("fd_dvr: %d", object->fd_dvr);

    //g_object_get(G_OBJECT(object), "blocksize", &buffer_size, NULL);
    buffer_size = DEFAULT_BUFFER_SIZE;

    /* device can not be tuned during read */
    g_mutex_lock (object->tune_mutex);


    if (object->fd_dvr > -1) {
        /* --- Read TS from DVR device --- */
        GST_DEBUG_OBJECT (object, "Reading from DVR device");
        *buf = read_device (object->fd_dvr, object->adapter_number,
                            object->frontend_number, buffer_size, object);
        if (*buf != NULL) {
            GstCaps *caps;

            retval = GST_FLOW_OK;

            caps = gst_pad_get_caps (GST_BASE_SRC_PAD (object));
            gst_buffer_set_caps (*buf, caps);
            gst_caps_unref (caps);
        } else {
            GST_DEBUG_OBJECT (object, "Failed to read from device");
            gst_element_post_message (GST_ELEMENT_CAST (object),
                                      gst_message_new_element (GST_OBJECT (object),
                                              gst_structure_empty_new ("dvb-read-failure")));
        }

        if (object->stats_interval != 0 &&
                ++object->stats_counter == object->stats_interval) {
            gst_dvbsrc_output_frontend_stats (object);
            object->stats_counter = 0;
        }
    }

    g_mutex_unlock (object->tune_mutex);
    return retval;

}
Example #8
0
// Return the front panel's Reset Button status
int
pal_get_rst_btn(uint8_t *status) {
  char path[64] = {0};
  int val;

  sprintf(path, GPIO_VAL, GPIO_RST_BTN);
  if (read_device(path, &val)) {
    return -1;
  }

  if (val) {
    *status = 0x0;
  } else {
    *status = 0x1;
  }

  return 0;
}
Example #9
0
int
pal_is_debug_card_prsnt(uint8_t *status) {
  int val;
  char path[64] = {0};

  sprintf(path, GPIO_VAL, GPIO_DBG_CARD_PRSNT);

  if (read_device(path, &val)) {
    return -1;
  }

  // TODO: Logic is reversed until DVT board with h/w fix
  if (val == 0x0) {
    *status = 0;
  } else {
    *status = 1;
  }

  return 0;
}
Example #10
0
static twin_bool_t pboot_proc_client_sock(int sock, twin_file_op_t ops,
		void *closure)
{
	struct device_context *dev_ctx = closure;
	uint8_t action;

	if (read_action(sock, &action))
		goto out_err;

	if (action == DEV_ACTION_ADD_DEVICE) {
		if (!read_device(sock, dev_ctx))
			goto out_err;

	} else if (action == DEV_ACTION_ADD_OPTION) {
		if (dev_ctx->device_idx == -1) {
			LOG("option, but no device has been sent?\n");
			goto out_err;
		}

		if (!read_option(sock, dev_ctx))
			goto out_err;

	} else if (action == DEV_ACTION_REMOVE_DEVICE) {
		char *dev_id = read_string(sock);
		if (!dev_id)
			goto out_err;
		
		LOG("remove device %s\n", dev_id);
		pboot_remove_device(dev_id);

	} else {
		LOG("unsupported action %d\n", action);
		goto out_err;
	}

	return TWIN_TRUE;

out_err:
	close(sock);
	return TWIN_FALSE;
}
Example #11
0
int
pal_is_server_prsnt(uint8_t slot_id, uint8_t *status) {
  int val;
  char path[64] = {0};

  if (slot_id < 1 || slot_id > 4) {
    return -1;
  }

  sprintf(path, GPIO_VAL, gpio_prsnt[slot_id]);

  if (read_device(path, &val)) {
    return -1;
  }

  if (val == 0x0) {
    *status = 1;
  } else {
    *status = 0;
  }

  return 0;
}
Example #12
0
int pm860x_page_reg_read(struct i2c_client *i2c, int reg)
{
	unsigned char zero = 0;
	unsigned char data;
	int ret;

	i2c_lock_adapter(i2c->adapter);
	read_device(i2c, 0xFA, 0, &zero);
	read_device(i2c, 0xFB, 0, &zero);
	read_device(i2c, 0xFF, 0, &zero);
	ret = read_device(i2c, reg, 1, &data);
	if (ret >= 0)
		ret = (int)data;
	read_device(i2c, 0xFE, 0, &zero);
	read_device(i2c, 0xFC, 0, &zero);
	i2c_unlock_adapter(i2c->adapter);
	return ret;
}
Example #13
0
int pm860x_page_set_bits(struct i2c_client *i2c, int reg,
			 unsigned char mask, unsigned char data)
{
	unsigned char zero;
	unsigned char value;
	int ret;

	i2c_lock_adapter(i2c->adapter);
	read_device(i2c, 0xFA, 0, &zero);
	read_device(i2c, 0xFB, 0, &zero);
	read_device(i2c, 0xFF, 0, &zero);
	ret = read_device(i2c, reg, 1, &value);
	if (ret < 0)
		goto out;
	value &= ~mask;
	value |= data;
	ret = write_device(i2c, reg, 1, &value);
out:
	read_device(i2c, 0xFE, 0, &zero);
	read_device(i2c, 0xFC, 0, &zero);
	i2c_unlock_adapter(i2c->adapter);
	return ret;
}
Example #14
0
int execute(void)
{
    long long tmp;
    int cmp;
    switch(opcode)
    {
        //add
        case 0x18:
            ra += load_mem(&memory[path],3);
            break;
        //and
        case 0x40:
            ra &= load_mem(&memory[path],3);
            break;
        //comp
        // = -> 0b001
        // > -> 0b010
        // < -> 0b100
        // save status in register sw
        case 0x28:
            cmp = load_mem(&memory[path],3);
            if(ra==cmp)
                rsw = 0x1;
            else if (ra>cmp)
                rsw = 0x2;
            else if (ra<cmp)
                rsw = 0x4;
            else
                rsw = 0;
            break;
        //div
        case 0x24:
            ra /= load_mem(&memory[path],3);
            break;
        //j
        case 0x3C:
            rpc = path;
            break;
        //jeq
        case 0x30:
            if(rsw==0x1)
                rpc = path;
            break;
        //jgt
        case 0x34:
            if(rsw==0x2)
                rpc = path;
            break;
        //jlt
        case 0x38:
            if(rsw==0x4)
                rpc = path;
            break;
        //jsub
        case 0x48:
            rl = rpc;
            rpc = path;
            break;
        //lda
        case 0x00:
            ra = load_mem(&memory[path],3);
            break;
        //ldch
        case 0x50:
            ra = (ra&0xFFFF00) + load_mem(&memory[path], 1);
            break;
        //ldl
        case 0x08:
            rl = load_mem(&memory[path],3);
            break;
        //ldx
        case 0x04:
            rx = load_mem(&memory[path],3);
            break;
        //mul
        case 0x20:
            tmp = (long long) ra * load_mem(&memory[path],3);
            ra = (int) (0xFFFFFF & tmp);
            break;
        //or
        case 0x44:
            ra |= load_mem(&memory[path],3);
            break;
        //rsub
        case 0x4C:
            rpc = rl;
            break;
        //sta
        case 0x0C:
            //incomplete
            save_mem(ra, &memory[path], 3);
            break;
        //stch
        case 0x54:
            save_mem(ra, &memory[path], 1);
            break;
        //stl
        case 0x14:
            save_mem(rl, &memory[path], 3);
            break;
        //stsw
        case 0xE8:
            save_mem(rsw, &memory[path], 3);
            break;
        //stx
        case 0x10:
            save_mem(rx, &memory[path], 3);
            break;
        //sub
        case 0x1C:
            ra -= load_mem(&memory[path], 3);
            break;
        //tix
        case 0x2C:         
            cmp = load_mem(&memory[path],3);
            rx++;
            if(rx==cmp)
                rsw = 0x1;
            else if (rx>cmp)
                rsw = 0x2;
            else if (rx<cmp)
                rsw = 0x4;
            else
                rsw = 0;
            break;

        //td
        case 0xE0:
            rsw = test_device(memory[path]);
            break;
        //rd
        case 0xD8:
            ra = (ra&0xFFFF00) + read_device(memory[path]);
            break;
        //wd
        case 0xDC:
            write_device(memory[path], (ra&0x0000FF));
            break;
       //break
        case 0xFF:
            return 10;
            break;   
        default: 
            printf("CPU Error: Could not found opcode\n");
            printf("rpc= %06X\n", rpc);
            return 11;
            break;
    }
    return 0;
}
Example #15
0
int main(int argc, char **argv)
{
	int opt;
	char *device_str = NULL;

	/* No arguments */
	if (argc == 1) {
		fprintf(stderr, syntax, argv[0]);
		return 1;
	}

	/* Process options */
	while ((opt = getopt(argc, argv, "ld:aeg")) != -1)
	{
		switch (opt)
		{

		case 'l':
			action_list_devices = 1;
			break;

		case 'd':
			device_str = optarg;
			break;

		case 'a':
			dump_intermediate = 1;
			break;

		case 'v':
			verbose = 1;
			break;

		case 'g':
			debug_info = 1;
			break;

		default:
			fprintf(stderr, syntax, argv[0]);
			return 1;
		}
	}

	/* The only remaining argument should be the kernel to compile */
	if (argc - optind > 1) {
		fprintf(stderr, syntax, argv[0]);
		return 1;
	} else if (argc - optind == 1)
		kernel_file_name = argv[optind];
	if (!kernel_file_name && !action_list_devices)
		fatal("no kernel to compile");

	/* Platform */
	cl_int err;
	err = clGetPlatformIDs(1, &platform, NULL);
	if (err != CL_SUCCESS)
		fatal("cannot get OpenCL platform");
	
	/* Get context */
	cl_context_properties cprops[5];
	cprops[0] = CL_CONTEXT_PLATFORM;
	cprops[1] = (cl_context_properties)platform;
	cprops[2] = CL_CONTEXT_OFFLINE_DEVICES_AMD;
	cprops[3] = (cl_context_properties) 1;
	cprops[4] = (cl_context_properties) NULL;
	context = clCreateContextFromType(cprops, CL_DEVICE_TYPE_ALL, NULL, NULL, &err);
	if (err != CL_SUCCESS)
		fatal("cannot create context");
	
	/* Get device list from context */
	err = clGetContextInfo(context, CL_CONTEXT_NUM_DEVICES, sizeof(num_devices), &num_devices, NULL);
	if (err != CL_SUCCESS)
		fatal("cannot get number of devices");
	err = clGetContextInfo(context, CL_CONTEXT_DEVICES, sizeof(devices), devices, NULL);
	if (err != CL_SUCCESS)
		fatal("cannot get list of devices");
	
	/* Get selected device */
	if (device_str) {
		device_id = read_device(device_str);
		device = devices[device_id];
	}
	
	/* List available devices */
	if (action_list_devices)
		main_list_devices(stdout);
	
	/* Compile list of kernels */
	if (kernel_file_name)
		main_compile_kernel();
	
	/* End program */
	printf("\n");
	return 0;
}
Example #16
0
int read_gpio_value(const int id, const char *device, int *value) {
  char full_name[LARGEST_DEVICE_NAME];

  snprintf(full_name, LARGEST_DEVICE_NAME, device, id);
  return read_device(full_name, value);
}
Example #17
0
// Read the Front Panel Hand Switch and return the position
int
pal_get_hand_sw(uint8_t *pos) {
  char path[64] = {0};
  int id1, id2, id4, id8;
  uint8_t loc;
  // Read 4 GPIOs to read the current position
  // id1: GPIOR2(138)
  // id2: GPIOR3(139)
  // id4: GPIOR4(140)
  // id8: GPIOR5(141)

  // Read ID1
  sprintf(path, GPIO_VAL, GPIO_HAND_SW_ID1);
  if (read_device(path, &id1)) {
    return -1;
  }

  // Read ID2
  sprintf(path, GPIO_VAL, GPIO_HAND_SW_ID2);
  if (read_device(path, &id2)) {
    return -1;
  }

  // Read ID4
  sprintf(path, GPIO_VAL, GPIO_HAND_SW_ID4);
  if (read_device(path, &id4)) {
    return -1;
  }

  // Read ID8
  sprintf(path, GPIO_VAL, GPIO_HAND_SW_ID8);
  if (read_device(path, &id8)) {
    return -1;
  }

  loc = ((id8 << 3) | (id4 << 2) | (id2 << 1) | (id1));

  switch(loc) {
  case 1:
  case 6:
    *pos = HAND_SW_SERVER1;
    break;
  case 2:
  case 7:
    *pos = HAND_SW_SERVER2;
    break;
  case 3:
  case 8:
    *pos = HAND_SW_SERVER3;
    break;
  case 4:
  case 9:
    *pos = HAND_SW_SERVER4;
    break;
  default:
    *pos = HAND_SW_BMC;
    break;
  }

  return 0;
}