/**
* is_gpt_valid() - tests one GPT header and PTEs for validity
* @fd is an open file descriptor to the whole disk
* @lba is the logical block address of the GPT header to test
* @gpt is a GPT header ptr, filled on return.
* @ptes is a PTEs ptr, filled on return.
*
* Description: returns 1 if valid, 0 on error.
* If valid, returns pointers to newly allocated GPT header and PTEs.
*/
static int
is_gpt_valid(int fd, uint64_t lba,
gpt_header ** gpt, gpt_entry ** ptes)
{
int rc = 0; /* default to not valid */
uint32_t crc, origcrc;
if (!gpt || !ptes)
return 0;
if (!(*gpt = alloc_read_gpt_header(fd, lba)))
return 0;
/* Check the GUID Partition Table signature */
if (__le64_to_cpu((*gpt)->signature) != GPT_HEADER_SIGNATURE) {
/*
printf("GUID Partition Table Header signature is wrong: %" PRIx64" != %" PRIx64 "\n",
__le64_to_cpu((*gpt)->signature), GUID_PT_HEADER_SIGNATURE);
*/
free(*gpt);
*gpt = NULL;
return rc;
}
/* Check the GUID Partition Table Header CRC */
origcrc = __le32_to_cpu((*gpt)->header_crc32);
(*gpt)->header_crc32 = 0;
crc = efi_crc32(*gpt, __le32_to_cpu((*gpt)->header_size));
if (crc != origcrc) {
// printf( "GPTH CRC check failed, %x != %x.\n", origcrc, crc);
(*gpt)->header_crc32 = __cpu_to_le32(origcrc);
free(*gpt);
*gpt = NULL;
return 0;
}
(*gpt)->header_crc32 = __cpu_to_le32(origcrc);
/* Check that the my_lba entry points to the LBA
* that contains the GPT we read */
if (__le64_to_cpu((*gpt)->my_lba) != lba) {
/*
printf( "my_lba % PRIx64 "x != lba %"PRIx64 "x.\n",
__le64_to_cpu((*gpt)->my_lba), lba);
*/
free(*gpt);
*gpt = NULL;
return 0;
}
/* Check that sizeof_partition_entry has the correct value */
if (__le32_to_cpu((*gpt)->sizeof_partition_entry) != sizeof(gpt_entry)) {
// printf("GUID partition entry size check failed.\n");
free(*gpt);
*gpt = NULL;
return 0;
}
/* Check that sizeof_partition_entry has the correct value */
if (__le32_to_cpu((*gpt)->sizeof_partition_entry) != sizeof(gpt_entry)) {
// printf("GUID partition entry size check failed.\n");
free(*gpt);
*gpt = NULL;
return 0;
}
if (!(*ptes = alloc_read_gpt_entries(fd, *gpt))) {
free(*gpt);
*gpt = NULL;
return 0;
}
/* Check the GUID Partition Entry Array CRC */
crc = efi_crc32(*ptes,
__le32_to_cpu((*gpt)->num_partition_entries) *
__le32_to_cpu((*gpt)->sizeof_partition_entry));
if (crc != __le32_to_cpu((*gpt)->partition_entry_array_crc32)) {
// printf("GUID Partitition Entry Array CRC check failed.\n");
free(*gpt);
*gpt = NULL;
free(*ptes);
*ptes = NULL;
return 0;
}
/* We're done, all's well */
return 1;
}
void convert_thread_options_to_cpu(struct thread_options *o,
struct thread_options_pack *top)
{
int i, j;
string_to_cpu(&o->description, top->description);
string_to_cpu(&o->name, top->name);
string_to_cpu(&o->directory, top->directory);
string_to_cpu(&o->filename, top->filename);
string_to_cpu(&o->filename_format, top->filename_format);
string_to_cpu(&o->opendir, top->opendir);
string_to_cpu(&o->ioengine, top->ioengine);
string_to_cpu(&o->mmapfile, top->mmapfile);
string_to_cpu(&o->read_iolog_file, top->read_iolog_file);
string_to_cpu(&o->write_iolog_file, top->write_iolog_file);
string_to_cpu(&o->bw_log_file, top->bw_log_file);
string_to_cpu(&o->lat_log_file, top->lat_log_file);
string_to_cpu(&o->iops_log_file, top->iops_log_file);
string_to_cpu(&o->replay_redirect, top->replay_redirect);
string_to_cpu(&o->exec_prerun, top->exec_prerun);
string_to_cpu(&o->exec_postrun, top->exec_postrun);
string_to_cpu(&o->ioscheduler, top->ioscheduler);
string_to_cpu(&o->profile, top->profile);
string_to_cpu(&o->cgroup, top->cgroup);
o->td_ddir = le32_to_cpu(top->td_ddir);
o->rw_seq = le32_to_cpu(top->rw_seq);
o->kb_base = le32_to_cpu(top->kb_base);
o->unit_base = le32_to_cpu(top->kb_base);
o->ddir_seq_nr = le32_to_cpu(top->ddir_seq_nr);
o->ddir_seq_add = le64_to_cpu(top->ddir_seq_add);
o->iodepth = le32_to_cpu(top->iodepth);
o->iodepth_low = le32_to_cpu(top->iodepth_low);
o->iodepth_batch = le32_to_cpu(top->iodepth_batch);
o->iodepth_batch_complete = le32_to_cpu(top->iodepth_batch_complete);
o->size = le64_to_cpu(top->size);
o->io_limit = le64_to_cpu(top->io_limit);
o->size_percent = le32_to_cpu(top->size_percent);
o->fill_device = le32_to_cpu(top->fill_device);
o->file_append = le32_to_cpu(top->file_append);
o->file_size_low = le64_to_cpu(top->file_size_low);
o->file_size_high = le64_to_cpu(top->file_size_high);
o->start_offset = le64_to_cpu(top->start_offset);
for (i = 0; i < DDIR_RWDIR_CNT; i++) {
o->bs[i] = le32_to_cpu(top->bs[i]);
o->ba[i] = le32_to_cpu(top->ba[i]);
o->min_bs[i] = le32_to_cpu(top->min_bs[i]);
o->max_bs[i] = le32_to_cpu(top->max_bs[i]);
o->bssplit_nr[i] = le32_to_cpu(top->bssplit_nr[i]);
if (o->bssplit_nr[i]) {
o->bssplit[i] = malloc(o->bssplit_nr[i] * sizeof(struct bssplit));
for (j = 0; j < o->bssplit_nr[i]; j++) {
o->bssplit[i][j].bs = le32_to_cpu(top->bssplit[i][j].bs);
o->bssplit[i][j].perc = le32_to_cpu(top->bssplit[i][j].perc);
}
}
o->rwmix[i] = le32_to_cpu(top->rwmix[i]);
o->rate[i] = le32_to_cpu(top->rate[i]);
o->ratemin[i] = le32_to_cpu(top->ratemin[i]);
o->rate_iops[i] = le32_to_cpu(top->rate_iops[i]);
o->rate_iops_min[i] = le32_to_cpu(top->rate_iops_min[i]);
o->perc_rand[i] = le32_to_cpu(top->perc_rand[i]);
}
o->ratecycle = le32_to_cpu(top->ratecycle);
o->nr_files = le32_to_cpu(top->nr_files);
o->open_files = le32_to_cpu(top->open_files);
o->file_lock_mode = le32_to_cpu(top->file_lock_mode);
o->odirect = le32_to_cpu(top->odirect);
o->oatomic = le32_to_cpu(top->oatomic);
o->invalidate_cache = le32_to_cpu(top->invalidate_cache);
o->create_serialize = le32_to_cpu(top->create_serialize);
o->create_fsync = le32_to_cpu(top->create_fsync);
o->create_on_open = le32_to_cpu(top->create_on_open);
o->create_only = le32_to_cpu(top->create_only);
o->end_fsync = le32_to_cpu(top->end_fsync);
o->pre_read = le32_to_cpu(top->pre_read);
o->sync_io = le32_to_cpu(top->sync_io);
o->verify = le32_to_cpu(top->verify);
o->do_verify = le32_to_cpu(top->do_verify);
o->verifysort = le32_to_cpu(top->verifysort);
o->verifysort_nr = le32_to_cpu(top->verifysort_nr);
o->experimental_verify = le32_to_cpu(top->experimental_verify);
o->verify_interval = le32_to_cpu(top->verify_interval);
o->verify_offset = le32_to_cpu(top->verify_offset);
memcpy(o->verify_pattern, top->verify_pattern, MAX_PATTERN_SIZE);
memcpy(o->buffer_pattern, top->buffer_pattern, MAX_PATTERN_SIZE);
o->verify_pattern_bytes = le32_to_cpu(top->verify_pattern_bytes);
o->verify_fatal = le32_to_cpu(top->verify_fatal);
o->verify_dump = le32_to_cpu(top->verify_dump);
o->verify_async = le32_to_cpu(top->verify_async);
o->verify_batch = le32_to_cpu(top->verify_batch);
o->use_thread = le32_to_cpu(top->use_thread);
o->unlink = le32_to_cpu(top->unlink);
o->do_disk_util = le32_to_cpu(top->do_disk_util);
o->override_sync = le32_to_cpu(top->override_sync);
o->rand_repeatable = le32_to_cpu(top->rand_repeatable);
o->allrand_repeatable = le32_to_cpu(top->allrand_repeatable);
o->rand_seed = le64_to_cpu(top->rand_seed);
o->use_os_rand = le32_to_cpu(top->use_os_rand);
o->log_avg_msec = le32_to_cpu(top->log_avg_msec);
o->log_offset = le32_to_cpu(top->log_offset);
o->log_gz = le32_to_cpu(top->log_gz);
o->log_gz_store = le32_to_cpu(top->log_gz_store);
o->norandommap = le32_to_cpu(top->norandommap);
o->softrandommap = le32_to_cpu(top->softrandommap);
o->bs_unaligned = le32_to_cpu(top->bs_unaligned);
o->fsync_on_close = le32_to_cpu(top->fsync_on_close);
o->bs_is_seq_rand = le32_to_cpu(top->bs_is_seq_rand);
o->random_distribution = le32_to_cpu(top->random_distribution);
o->zipf_theta.u.f = fio_uint64_to_double(le64_to_cpu(top->zipf_theta.u.i));
o->pareto_h.u.f = fio_uint64_to_double(le64_to_cpu(top->pareto_h.u.i));
o->random_generator = le32_to_cpu(top->random_generator);
o->hugepage_size = le32_to_cpu(top->hugepage_size);
o->rw_min_bs = le32_to_cpu(top->rw_min_bs);
o->thinktime = le32_to_cpu(top->thinktime);
o->thinktime_spin = le32_to_cpu(top->thinktime_spin);
o->thinktime_blocks = le32_to_cpu(top->thinktime_blocks);
o->fsync_blocks = le32_to_cpu(top->fsync_blocks);
o->fdatasync_blocks = le32_to_cpu(top->fdatasync_blocks);
o->barrier_blocks = le32_to_cpu(top->barrier_blocks);
o->verify_backlog = le64_to_cpu(top->verify_backlog);
o->start_delay = le64_to_cpu(top->start_delay);
o->start_delay_high = le64_to_cpu(top->start_delay_high);
o->timeout = le64_to_cpu(top->timeout);
o->ramp_time = le64_to_cpu(top->ramp_time);
o->zone_range = le64_to_cpu(top->zone_range);
o->zone_size = le64_to_cpu(top->zone_size);
o->zone_skip = le64_to_cpu(top->zone_skip);
o->lockmem = le64_to_cpu(top->lockmem);
o->offset_increment = le64_to_cpu(top->offset_increment);
o->number_ios = le64_to_cpu(top->number_ios);
o->overwrite = le32_to_cpu(top->overwrite);
o->bw_avg_time = le32_to_cpu(top->bw_avg_time);
o->iops_avg_time = le32_to_cpu(top->iops_avg_time);
o->loops = le32_to_cpu(top->loops);
o->mem_type = le32_to_cpu(top->mem_type);
o->mem_align = le32_to_cpu(top->mem_align);
o->max_latency = le32_to_cpu(top->max_latency);
o->stonewall = le32_to_cpu(top->stonewall);
o->new_group = le32_to_cpu(top->new_group);
o->numjobs = le32_to_cpu(top->numjobs);
o->cpumask_set = le32_to_cpu(top->cpumask_set);
o->verify_cpumask_set = le32_to_cpu(top->verify_cpumask_set);
o->cpus_allowed_policy = le32_to_cpu(top->cpus_allowed_policy);
o->iolog = le32_to_cpu(top->iolog);
o->rwmixcycle = le32_to_cpu(top->rwmixcycle);
o->nice = le32_to_cpu(top->nice);
o->ioprio = le32_to_cpu(top->ioprio);
o->ioprio_class = le32_to_cpu(top->ioprio_class);
o->file_service_type = le32_to_cpu(top->file_service_type);
o->group_reporting = le32_to_cpu(top->group_reporting);
o->fadvise_hint = le32_to_cpu(top->fadvise_hint);
o->fallocate_mode = le32_to_cpu(top->fallocate_mode);
o->zero_buffers = le32_to_cpu(top->zero_buffers);
o->refill_buffers = le32_to_cpu(top->refill_buffers);
o->scramble_buffers = le32_to_cpu(top->scramble_buffers);
o->buffer_pattern_bytes = le32_to_cpu(top->buffer_pattern_bytes);
o->time_based = le32_to_cpu(top->time_based);
o->disable_lat = le32_to_cpu(top->disable_lat);
o->disable_clat = le32_to_cpu(top->disable_clat);
o->disable_slat = le32_to_cpu(top->disable_slat);
o->disable_bw = le32_to_cpu(top->disable_bw);
o->unified_rw_rep = le32_to_cpu(top->unified_rw_rep);
o->gtod_reduce = le32_to_cpu(top->gtod_reduce);
o->gtod_cpu = le32_to_cpu(top->gtod_cpu);
o->gtod_offload = le32_to_cpu(top->gtod_offload);
o->clocksource = le32_to_cpu(top->clocksource);
o->no_stall = le32_to_cpu(top->no_stall);
o->trim_percentage = le32_to_cpu(top->trim_percentage);
o->trim_batch = le32_to_cpu(top->trim_batch);
o->trim_zero = le32_to_cpu(top->trim_zero);
o->clat_percentiles = le32_to_cpu(top->clat_percentiles);
o->percentile_precision = le32_to_cpu(top->percentile_precision);
o->continue_on_error = le32_to_cpu(top->continue_on_error);
o->cgroup_weight = le32_to_cpu(top->cgroup_weight);
o->cgroup_nodelete = le32_to_cpu(top->cgroup_nodelete);
o->uid = le32_to_cpu(top->uid);
o->gid = le32_to_cpu(top->gid);
o->flow_id = __le32_to_cpu(top->flow_id);
o->flow = __le32_to_cpu(top->flow);
o->flow_watermark = __le32_to_cpu(top->flow_watermark);
o->flow_sleep = le32_to_cpu(top->flow_sleep);
o->sync_file_range = le32_to_cpu(top->sync_file_range);
o->latency_target = le64_to_cpu(top->latency_target);
o->latency_window = le64_to_cpu(top->latency_window);
o->latency_percentile.u.f = fio_uint64_to_double(le64_to_cpu(top->latency_percentile.u.i));
o->compress_percentage = le32_to_cpu(top->compress_percentage);
o->compress_chunk = le32_to_cpu(top->compress_chunk);
o->dedupe_percentage = le32_to_cpu(top->dedupe_percentage);
o->trim_backlog = le64_to_cpu(top->trim_backlog);
for (i = 0; i < FIO_IO_U_LIST_MAX_LEN; i++)
o->percentile_list[i].u.f = fio_uint64_to_double(le64_to_cpu(top->percentile_list[i].u.i));
#if 0
uint8_t cpumask[FIO_TOP_STR_MAX];
uint8_t verify_cpumask[FIO_TOP_STR_MAX];
#endif
}
static int garmin_write(struct tty_struct *tty, struct usb_serial_port *port,
const unsigned char *buf, int count)
{
struct device *dev = &port->dev;
int pktid, pktsiz, len;
struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
__le32 *privpkt = (__le32 *)garmin_data_p->privpkt;
usb_serial_debug_data(dev, __func__, count, buf);
if (garmin_data_p->state == STATE_RESET)
return -EIO;
/* check for our private packets */
if (count >= GARMIN_PKTHDR_LENGTH) {
len = PRIVPKTSIZ;
if (count < len)
len = count;
memcpy(garmin_data_p->privpkt, buf, len);
pktsiz = getDataLength(garmin_data_p->privpkt);
pktid = getPacketId(garmin_data_p->privpkt);
if (count == (GARMIN_PKTHDR_LENGTH+pktsiz)
&& GARMIN_LAYERID_PRIVATE ==
getLayerId(garmin_data_p->privpkt)) {
dev_dbg(dev, "%s - processing private request %d\n",
__func__, pktid);
/* drop all unfinished transfers */
garmin_clear(garmin_data_p);
switch (pktid) {
case PRIV_PKTID_SET_MODE:
if (pktsiz != 4)
return -EINVPKT;
garmin_data_p->mode = __le32_to_cpu(privpkt[3]);
dev_dbg(dev, "%s - mode set to %d\n",
__func__, garmin_data_p->mode);
break;
case PRIV_PKTID_INFO_REQ:
priv_status_resp(port);
break;
case PRIV_PKTID_RESET_REQ:
process_resetdev_request(port);
break;
case PRIV_PKTID_SET_DEF_MODE:
if (pktsiz != 4)
return -EINVPKT;
initial_mode = __le32_to_cpu(privpkt[3]);
dev_dbg(dev, "%s - initial_mode set to %d\n",
__func__,
garmin_data_p->mode);
break;
}
return count;
}
}
if (garmin_data_p->mode == MODE_GARMIN_SERIAL) {
return gsp_receive(garmin_data_p, buf, count);
} else { /* MODE_NATIVE */
return nat_receive(garmin_data_p, buf, count);
}
}
int main(int argc, char *const argv[])
{
char tmpdir[] = "/tmp/dirXXXXXX";
char cmd[128];
char filepnm[128] = "";
char *dev;
struct lr_server_data lsd;
FILE *filep = NULL;
int ret;
int c;
int opt_client = 0;
int opt_reply = 0;
progname = argv[0];
while ((c = getopt_long(argc, argv, "chr", long_opts, NULL)) != -1) {
switch (c) {
case 'c':
opt_client = 1;
break;
case 'r':
opt_reply = 1;
break;
case 'h':
default:
display_usage();
return -1;
}
}
dev = argv[optind];
if (!dev) {
display_usage();
return -1;
}
/* Make a temporary directory to hold Lustre data files. */
if (!mkdtemp(tmpdir)) {
fprintf(stderr, "%s: Can't create temporary directory %s: %s\n",
progname, tmpdir, strerror(errno));
return errno;
}
memset(cmd, 0, sizeof(cmd));
snprintf(cmd, sizeof(cmd),
"%s -c -R 'dump /%s %s/%s' %s",
DEBUGFS, LAST_RCVD, tmpdir, LAST_RCVD, dev);
ret = run_command(cmd, sizeof(cmd));
if (ret) {
fprintf(stderr, "%s: Unable to dump %s file\n",
progname, LAST_RCVD);
goto out_rmdir;
}
snprintf(filepnm, 128, "%s/%s", tmpdir, LAST_RCVD);
filep = fopen(filepnm, "r");
if (!filep) {
fprintf(stderr, "%s: Unable to read old data\n",
progname);
ret = -errno;
goto out_rmdir;
}
unlink(filepnm);
/* read lr_server_data structure */
printf("%s:\n", LAST_RCVD);
ret = fread(&lsd, 1, sizeof(lsd), filep);
if (ret < sizeof(lsd)) {
fprintf(stderr, "%s: Short read (%d of %d)\n",
progname, ret, (int)sizeof(lsd));
ret = -ferror(filep);
if (ret)
goto out_close;
}
/* swab structure fields of interest */
lsd.lsd_feature_compat = __le32_to_cpu(lsd.lsd_feature_compat);
lsd.lsd_feature_incompat = __le32_to_cpu(lsd.lsd_feature_incompat);
lsd.lsd_feature_rocompat = __le32_to_cpu(lsd.lsd_feature_rocompat);
lsd.lsd_last_transno = __le64_to_cpu(lsd.lsd_last_transno);
lsd.lsd_osd_index = __le32_to_cpu(lsd.lsd_osd_index);
lsd.lsd_mount_count = __le64_to_cpu(lsd.lsd_mount_count);
/* display */
printf(" uuid: %.40s\n", lsd.lsd_uuid);
printf(" feature_compat: %#x\n", lsd.lsd_feature_compat);
printf(" feature_incompat: %#x\n", lsd.lsd_feature_incompat);
printf(" feature_rocompat: %#x\n", lsd.lsd_feature_rocompat);
printf(" last_transaction: %llu\n", lsd.lsd_last_transno);
printf(" target_index: %u\n", lsd.lsd_osd_index);
printf(" mount_count: %llu\n", lsd.lsd_mount_count);
/* read client information */
if (opt_client) {
lsd.lsd_client_start = __le32_to_cpu(lsd.lsd_client_start);
lsd.lsd_client_size = __le16_to_cpu(lsd.lsd_client_size);
printf(" client_area_start: %u\n", lsd.lsd_client_start);
printf(" client_area_size: %hu\n", lsd.lsd_client_size);
/* seek to per-client data area */
ret = fseek(filep, lsd.lsd_client_start, SEEK_SET);
if (ret) {
fprintf(stderr, "%s: seek failed. %s\n",
progname, strerror(errno));
ret = errno;
goto out_close;
}
/* walk throuh the per-client data area */
while (true) {
struct lsd_client_data lcd;
/* read a per-client data area */
ret = fread(&lcd, 1, sizeof(lcd), filep);
if (ret < sizeof(lcd)) {
if (feof(filep))
break;
fprintf(stderr, "%s: Short read (%d of %d)\n",
progname, ret, (int)sizeof(lcd));
ret = -ferror(filep);
goto out_close;
}
if (lcd.lcd_uuid[0] == '\0')
continue;
/* swab structure fields */
lcd.lcd_last_transno =
__le64_to_cpu(lcd.lcd_last_transno);
lcd.lcd_last_xid = __le64_to_cpu(lcd.lcd_last_xid);
lcd.lcd_last_result = __le32_to_cpu(lcd.lcd_last_result);
lcd.lcd_last_data = __le32_to_cpu(lcd.lcd_last_data);
lcd.lcd_generation = __le32_to_cpu(lcd.lcd_generation);
/* display per-client data area */
printf("\n %.40s:\n", lcd.lcd_uuid);
printf(" generation: %u\n", lcd.lcd_generation);
printf(" last_transaction: %llu\n",
lcd.lcd_last_transno);
printf(" last_xid: %llu\n", lcd.lcd_last_xid);
printf(" last_result: %u\n", lcd.lcd_last_result);
printf(" last_data: %u\n", lcd.lcd_last_data);
if (lcd.lcd_last_close_transno != 0 &&
lcd.lcd_last_close_xid != 0) {
lcd.lcd_last_close_transno =
__le64_to_cpu(lcd.lcd_last_close_transno);
lcd.lcd_last_close_xid =
__le64_to_cpu(lcd.lcd_last_close_xid);
lcd.lcd_last_close_result =
__le32_to_cpu(lcd.lcd_last_close_result);
lcd.lcd_last_close_data =
__le32_to_cpu(lcd.lcd_last_close_data);
printf(" last_close_transation: %llu\n",
lcd.lcd_last_close_transno);
printf(" last_close_xid: %llu\n",
lcd.lcd_last_close_xid);
printf(" last_close_result: %u\n",
lcd.lcd_last_close_result);
printf(" last_close_data: %u\n",
lcd.lcd_last_close_data);
}
}
}
fclose(filep);
filep = NULL;
/* read reply data information */
if (opt_reply) {
struct lsd_reply_header lrh;
struct lsd_reply_data lrd;
unsigned long long slot;
snprintf(cmd, sizeof(cmd),
"%s -c -R 'dump /%s %s/%s' %s",
DEBUGFS, REPLY_DATA, tmpdir, REPLY_DATA, dev);
ret = run_command(cmd, sizeof(cmd));
if (ret) {
fprintf(stderr, "%s: Unable to dump %s file\n",
progname, REPLY_DATA);
goto out_rmdir;
}
snprintf(filepnm, sizeof(filepnm),
"%s/%s", tmpdir, REPLY_DATA);
filep = fopen(filepnm, "r");
if (!filep) {
fprintf(stderr, "%s: Unable to read reply data\n",
progname);
ret = -errno;
goto out_rmdir;
}
unlink(filepnm);
/* read reply_data header */
printf("\n%s:\n", REPLY_DATA);
ret = fread(&lrh, 1, sizeof(lrh), filep);
if (ret < sizeof(lrh)) {
fprintf(stderr, "%s: Short read (%d of %d)\n",
progname, ret, (int)sizeof(lrh));
ret = -ferror(filep);
if (ret)
goto out_close;
}
/* check header */
lrh.lrh_magic = __le32_to_cpu(lrh.lrh_magic);
lrh.lrh_header_size = __le32_to_cpu(lrh.lrh_header_size);
lrh.lrh_reply_size = __le32_to_cpu(lrh.lrh_reply_size);
if (lrh.lrh_magic != LRH_MAGIC) {
fprintf(stderr, "%s: invalid %s header: "
"lrh_magic=%08x expected %08x\n",
progname, REPLY_DATA, lrh.lrh_magic, LRH_MAGIC);
goto out_close;
}
if (lrh.lrh_header_size != sizeof(struct lsd_reply_header)) {
fprintf(stderr, "%s: invalid %s header: "
"lrh_header_size=%08x expected %08x\n",
progname, REPLY_DATA, lrh.lrh_header_size,
(unsigned int)sizeof(struct lsd_reply_header));
goto out_close;
}
if (lrh.lrh_reply_size != sizeof(struct lsd_reply_data)) {
fprintf(stderr, "%s: invalid %s header: "
"lrh_reply_size=%08x expected %08x\n",
progname, REPLY_DATA, lrh.lrh_reply_size,
(unsigned int)sizeof(struct lsd_reply_data));
goto out_close;
}
/* walk throuh the reply data */
for (slot = 0; ; slot++) {
/* read a reply data */
ret = fread(&lrd, 1, sizeof(lrd), filep);
if (ret < sizeof(lrd)) {
if (feof(filep))
break;
fprintf(stderr, "%s: Short read (%d of %d)\n",
progname, ret, (int)sizeof(lrd));
ret = -ferror(filep);
goto out_close;
}
/* display reply data */
lrd.lrd_transno = __le64_to_cpu(lrd.lrd_transno);
lrd.lrd_xid = __le64_to_cpu(lrd.lrd_xid);
lrd.lrd_data = __le64_to_cpu(lrd.lrd_data);
lrd.lrd_result = __le32_to_cpu(lrd.lrd_result);
lrd.lrd_client_gen = __le32_to_cpu(lrd.lrd_client_gen);
printf(" %lld:\n", slot);
printf(" client_generation: %u\n",
lrd.lrd_client_gen);
printf(" last_transaction: %llu\n", lrd.lrd_transno);
printf(" last_xid: %llu\n", lrd.lrd_xid);
printf(" last_result: %u\n", lrd.lrd_result);
printf(" last_data: %llu\n\n", lrd.lrd_data);
}
}
out_close:
if (filep != NULL)
fclose(filep);
out_rmdir:
rmdir(tmpdir);
return ret;
}
static void nci_core_init_rsp_packet(struct nci_dev *ndev, struct sk_buff *skb)
{
struct nci_core_init_rsp_1 *rsp_1 = (void *) skb->data;
struct nci_core_init_rsp_2 *rsp_2;
nfc_dbg("entry, status 0x%x", rsp_1->status);
if (rsp_1->status != NCI_STATUS_OK)
return;
ndev->nfcc_features = __le32_to_cpu(rsp_1->nfcc_features);
ndev->num_supported_rf_interfaces = rsp_1->num_supported_rf_interfaces;
if (ndev->num_supported_rf_interfaces >
NCI_MAX_SUPPORTED_RF_INTERFACES) {
ndev->num_supported_rf_interfaces =
NCI_MAX_SUPPORTED_RF_INTERFACES;
}
memcpy(ndev->supported_rf_interfaces,
rsp_1->supported_rf_interfaces,
ndev->num_supported_rf_interfaces);
rsp_2 = (void *) (skb->data + 6 + ndev->num_supported_rf_interfaces);
ndev->max_logical_connections =
rsp_2->max_logical_connections;
ndev->max_routing_table_size =
__le16_to_cpu(rsp_2->max_routing_table_size);
ndev->max_control_packet_payload_length =
rsp_2->max_control_packet_payload_length;
ndev->rf_sending_buffer_size =
__le16_to_cpu(rsp_2->rf_sending_buffer_size);
ndev->rf_receiving_buffer_size =
__le16_to_cpu(rsp_2->rf_receiving_buffer_size);
ndev->manufacturer_id =
__le16_to_cpu(rsp_2->manufacturer_id);
nfc_dbg("nfcc_features 0x%x",
ndev->nfcc_features);
nfc_dbg("num_supported_rf_interfaces %d",
ndev->num_supported_rf_interfaces);
nfc_dbg("supported_rf_interfaces[0] 0x%x",
ndev->supported_rf_interfaces[0]);
nfc_dbg("supported_rf_interfaces[1] 0x%x",
ndev->supported_rf_interfaces[1]);
nfc_dbg("supported_rf_interfaces[2] 0x%x",
ndev->supported_rf_interfaces[2]);
nfc_dbg("supported_rf_interfaces[3] 0x%x",
ndev->supported_rf_interfaces[3]);
nfc_dbg("max_logical_connections %d",
ndev->max_logical_connections);
nfc_dbg("max_routing_table_size %d",
ndev->max_routing_table_size);
nfc_dbg("max_control_packet_payload_length %d",
ndev->max_control_packet_payload_length);
nfc_dbg("rf_sending_buffer_size %d",
ndev->rf_sending_buffer_size);
nfc_dbg("rf_receiving_buffer_size %d",
ndev->rf_receiving_buffer_size);
nfc_dbg("manufacturer_id 0x%x",
ndev->manufacturer_id);
nci_req_complete(ndev, rsp_1->status);
}
int ath10k_htt_send_rx_ring_cfg_ll(struct ath10k_htt *htt)
{
struct sk_buff *skb;
struct htt_cmd *cmd;
struct htt_rx_ring_setup_ring *ring;
const int num_rx_ring = 1;
u16 flags;
u32 fw_idx;
int len;
int ret;
/*
* the HW expects the buffer to be an integral number of 4-byte
* "words"
*/
BUILD_BUG_ON(!IS_ALIGNED(HTT_RX_BUF_SIZE, 4));
BUILD_BUG_ON((HTT_RX_BUF_SIZE & HTT_MAX_CACHE_LINE_SIZE_MASK) != 0);
len = sizeof(cmd->hdr) + sizeof(cmd->rx_setup.hdr)
+ (sizeof(*ring) * num_rx_ring);
skb = ath10k_htc_alloc_skb(len);
if (!skb)
return -ENOMEM;
skb_put(skb, len);
cmd = (struct htt_cmd *)skb->data;
ring = &cmd->rx_setup.rings[0];
cmd->hdr.msg_type = HTT_H2T_MSG_TYPE_RX_RING_CFG;
cmd->rx_setup.hdr.num_rings = 1;
/* FIXME: do we need all of this? */
flags = 0;
flags |= HTT_RX_RING_FLAGS_MAC80211_HDR;
flags |= HTT_RX_RING_FLAGS_MSDU_PAYLOAD;
flags |= HTT_RX_RING_FLAGS_PPDU_START;
flags |= HTT_RX_RING_FLAGS_PPDU_END;
flags |= HTT_RX_RING_FLAGS_MPDU_START;
flags |= HTT_RX_RING_FLAGS_MPDU_END;
flags |= HTT_RX_RING_FLAGS_MSDU_START;
flags |= HTT_RX_RING_FLAGS_MSDU_END;
flags |= HTT_RX_RING_FLAGS_RX_ATTENTION;
flags |= HTT_RX_RING_FLAGS_FRAG_INFO;
flags |= HTT_RX_RING_FLAGS_UNICAST_RX;
flags |= HTT_RX_RING_FLAGS_MULTICAST_RX;
flags |= HTT_RX_RING_FLAGS_CTRL_RX;
flags |= HTT_RX_RING_FLAGS_MGMT_RX;
flags |= HTT_RX_RING_FLAGS_NULL_RX;
flags |= HTT_RX_RING_FLAGS_PHY_DATA_RX;
fw_idx = __le32_to_cpu(*htt->rx_ring.alloc_idx.vaddr);
ring->fw_idx_shadow_reg_paddr =
__cpu_to_le32(htt->rx_ring.alloc_idx.paddr);
ring->rx_ring_base_paddr = __cpu_to_le32(htt->rx_ring.base_paddr);
ring->rx_ring_len = __cpu_to_le16(htt->rx_ring.size);
ring->rx_ring_bufsize = __cpu_to_le16(HTT_RX_BUF_SIZE);
ring->flags = __cpu_to_le16(flags);
ring->fw_idx_init_val = __cpu_to_le16(fw_idx);
#define desc_offset(x) (offsetof(struct htt_rx_desc, x) / 4)
ring->mac80211_hdr_offset = __cpu_to_le16(desc_offset(rx_hdr_status));
ring->msdu_payload_offset = __cpu_to_le16(desc_offset(msdu_payload));
ring->ppdu_start_offset = __cpu_to_le16(desc_offset(ppdu_start));
ring->ppdu_end_offset = __cpu_to_le16(desc_offset(ppdu_end));
ring->mpdu_start_offset = __cpu_to_le16(desc_offset(mpdu_start));
ring->mpdu_end_offset = __cpu_to_le16(desc_offset(mpdu_end));
ring->msdu_start_offset = __cpu_to_le16(desc_offset(msdu_start));
ring->msdu_end_offset = __cpu_to_le16(desc_offset(msdu_end));
ring->rx_attention_offset = __cpu_to_le16(desc_offset(attention));
ring->frag_info_offset = __cpu_to_le16(desc_offset(frag_info));
#undef desc_offset
ret = ath10k_htc_send(&htt->ar->htc, htt->eid, skb);
if (ret) {
dev_kfree_skb_any(skb);
return ret;
}
return 0;
}
int ath10k_hw_diag_fast_download(struct ath10k *ar,
u32 address,
const void *buffer,
u32 length)
{
const u8 *buf = buffer;
bool sgmt_end = false;
u32 base_addr = 0;
u32 base_len = 0;
u32 left = 0;
struct bmi_segmented_file_header *hdr;
struct bmi_segmented_metadata *metadata;
int ret = 0;
if (length < sizeof(*hdr))
return -EINVAL;
/* check firmware header. If it has no correct magic number
* or it's compressed, returns error.
*/
hdr = (struct bmi_segmented_file_header *)buf;
if (__le32_to_cpu(hdr->magic_num) != BMI_SGMTFILE_MAGIC_NUM) {
ath10k_dbg(ar, ATH10K_DBG_BOOT,
"Not a supported firmware, magic_num:0x%x\n",
hdr->magic_num);
return -EINVAL;
}
if (hdr->file_flags != 0) {
ath10k_dbg(ar, ATH10K_DBG_BOOT,
"Not a supported firmware, file_flags:0x%x\n",
hdr->file_flags);
return -EINVAL;
}
metadata = (struct bmi_segmented_metadata *)hdr->data;
left = length - sizeof(*hdr);
while (left > 0) {
if (left < sizeof(*metadata)) {
ath10k_warn(ar, "firmware segment is truncated: %d\n",
left);
ret = -EINVAL;
break;
}
base_addr = __le32_to_cpu(metadata->addr);
base_len = __le32_to_cpu(metadata->length);
buf = metadata->data;
left -= sizeof(*metadata);
switch (base_len) {
case BMI_SGMTFILE_BEGINADDR:
/* base_addr is the start address to run */
ret = ath10k_bmi_set_start(ar, base_addr);
base_len = 0;
break;
case BMI_SGMTFILE_DONE:
/* no more segment */
base_len = 0;
sgmt_end = true;
ret = 0;
break;
case BMI_SGMTFILE_BDDATA:
case BMI_SGMTFILE_EXEC:
ath10k_warn(ar,
"firmware has unsupported segment:%d\n",
base_len);
ret = -EINVAL;
break;
default:
if (base_len > left) {
/* sanity check */
ath10k_warn(ar,
"firmware has invalid segment length, %d > %d\n",
base_len, left);
ret = -EINVAL;
break;
}
ret = ath10k_hw_diag_segment_download(ar,
buf,
base_addr,
base_len);
if (ret)
ath10k_warn(ar,
"failed to download firmware via diag interface:%d\n",
ret);
break;
}
if (ret || sgmt_end)
break;
metadata = (struct bmi_segmented_metadata *)(buf + base_len);
left -= base_len;
}
if (ret == 0)
ath10k_dbg(ar, ATH10K_DBG_BOOT,
"boot firmware fast diag download successfully.\n");
return ret;
}
static int ath10k_qca99x0_rx_desc_get_l3_pad_bytes(struct htt_rx_desc *rxd)
{
return MS(__le32_to_cpu(rxd->msdu_end.qca99x0.info1),
RX_MSDU_END_INFO1_L3_HDR_PAD);
}