OSDN > Finden Software > stock > SCM > hg > Scope > Commit

stock
Fork
test
stock.osdn
stock
mem
Scope
compass

Scope: Commit

digital oscilloscope

Commit MetaInfo

Revision	41248e93aa052e10797bbbb38ef13e69c4ebb69a (tree)
Zeit	2018-09-17 23:26:45
Autor	PJ_WORK
Commiter	PJ_WORK

Log Message

cli/iso_ringbuf.h: support Bulk transfer

Ändern Zusammenfassung

modified: cli/DX_iso_test.cc (diff)
modified: cli/iso_ringbuf.h (diff)
modified: cli/test_in.cc (diff)
modified: gui/probe_run.h (diff)
modified: gui/probe_run_iso_ad.h (diff)
modified: gui/probe_run_iso_d.h (diff)

Diff

diff -r 2d887527abb7 -r 41248e93aa05 cli/DX_iso_test.cc

--- a/cli/DX_iso_test.cc Mon Sep 17 14:35:39 2018 +0100

+++ b/cli/DX_iso_test.cc Mon Sep 17 15:26:45 2018 +0100

		@@ -171,7 +171,7 @@
171	171	return 1;
172	172	}
173	173
174		- const unsigned ring_pkt_num = iso_pkt_num(1, req.d_pkt_len);
	174	+ const unsigned ring_pkt_num = iso_pkt_num(req.d_pkt_len);
175	175	//const unsigned ring_pkt_num = iso_pkt_num(pkt_len_A);
176	176	req.number = (transfers2/3) req.a_pkt_len*ring_pkt_num / req.a_width;
177	177	printf("d_pkt_len: %u, pkt_num: %u, samples: %u\n", req.d_pkt_len, ring_pkt_num, req.number);

diff -r 2d887527abb7 -r 41248e93aa05 cli/iso_ringbuf.h

--- a/cli/iso_ringbuf.h Mon Sep 17 14:35:39 2018 +0100

+++ b/cli/iso_ringbuf.h Mon Sep 17 15:26:45 2018 +0100

		@@ -1,10 +1,11 @@
1	1
2	2	// fill one kernel buffer with packets
3		-// assert(iso_pkt_num * pkt_len <= 0x8000);
4		-unsigned iso_pkt_num(unsigned k_buf_num, unsigned pkt_len)
	3	+unsigned iso_pkt_num(unsigned pkt_len)
5	4	{
6		- enum { K_BUF = 0x8000 };
7		- return K_BUF * k_buf_num / pkt_len;
	5	+ enum { K_BUF = 0x8000 }; // (USB) kernel buffer size
	6	+ const unsigned pkt_num = K_BUF / pkt_len;
	7	+ assert(pkt_num * pkt_len <= K_BUF);
	8	+ return pkt_num;
8	9	#if 0
9	10	if (pkt_len > 2048) {
10	11	return 10; // 1031024 = 0x7800

		@@ -26,7 +27,7 @@
26	27	uint8_t ** data_buf; // array of data bufs
27	28	public:
28	29	const unsigned buf_num; // number of buffers in ring
29		- const unsigned pkt_num; // number of Iso packets per buffer
	30	+ const unsigned pkt_num; // number of Iso packets per buffer or 1 for Bulk transfer
30	31	const unsigned pkt_len; // (max) Iso packet size
31	32	//protected:
32	33	unsigned idx_transfer; // the next transfer to wait for

		@@ -35,11 +36,20 @@
35	36	RingData(unsigned buf_num, unsigned pkt_num, unsigned pkt_len)
36	37	: buf_num(buf_num), pkt_num(pkt_num), pkt_len(pkt_len)
37	38	{
	39	+ assert(buf_num > 0);
	40	+ assert(pkt_num > 0);
	41	+ assert(pkt_len > 0);
	42	+
38	43	// allocate transfer structs
39	44	transfers = new struct libusb_transfer *[buf_num];
40	45	for(unsigned i=0; i<buf_num; ++i) {
41		- transfers[i] = libusb_alloc_transfer(pkt_num);
42		- assert(transfers[i]);
	46	+ struct libusb_transfer * new_tr;
	47	+ if (pkt_num == 1)
	48	+ new_tr = libusb_alloc_transfer(0); // Bulk transfer
	49	+ else
	50	+ new_tr = libusb_alloc_transfer(pkt_num); // Iso transfer
	51	+ assert(new_tr);
	52	+ transfers[i] = new_tr;
43	53	}
44	54
45	55	// allocate data buffers

		@@ -61,10 +71,15 @@
61	71
62	72	// bind transfers to buffers and to an endpoint
63	73	void bind(libusb_device_handle * handle, unsigned endpoint, unsigned timeout) {
64		- unsigned data_buf_size = pkt_num*pkt_len;
	74	+ const unsigned data_buf_size = pkt_num*pkt_len;
	75	+
65	76	for(unsigned i=0; i<buf_num; ++i) {
66		- libusb_fill_iso_transfer(transfers[i], handle, endpoint, data_buf[i], data_buf_size, pkt_num, usb_io_transfer_cb, 0, timeout);
67		- libusb_set_iso_packet_lengths(transfers[i], pkt_len);
	77	+ if (pkt_num == 1) {
	78	+ libusb_fill_bulk_transfer(transfers[i], handle, endpoint, data_buf[i], data_buf_size, usb_io_transfer_cb, 0, timeout);
	79	+ } else {
	80	+ libusb_fill_iso_transfer(transfers[i], handle, endpoint, data_buf[i], data_buf_size, pkt_num, usb_io_transfer_cb, 0, timeout);
	81	+ libusb_set_iso_packet_lengths(transfers[i], pkt_len);
	82	+ }
68	83	}
69	84	}
70	85

		@@ -75,6 +90,7 @@
75	90	int res = libusb_submit_transfer(transfers[i]);
76	91	if (res == LIBUSB_SUCCESS)
77	92	return true;
	93	+
78	94	#if defined(LIBUSB_API_VERSION)
79	95	printf("libusb_submit_transfer(%u): %d %s\n", i, res, libusb_error_name(res));
80	96	#else

diff -r 2d887527abb7 -r 41248e93aa05 cli/test_in.cc

--- a/cli/test_in.cc Mon Sep 17 14:35:39 2018 +0100

+++ b/cli/test_in.cc Mon Sep 17 15:26:45 2018 +0100

		@@ -190,12 +190,12 @@
190	190	transfer->actual_length = 0; // for debug
191	191
192	192	int res = libusb_submit_transfer(transfer);
193		- if (res) {
194		- printf("libusb_submit_transfer: %d %s\n", res, libusb_error_name(res));
195		- transfer_completed(transfer) = 1;
196		- }
	193	+ if (res == LIBUSB_SUCCESS)
	194	+ return true;
197	195
198		- return (res == 0);
	196	+ printf("libusb_submit_transfer: %d %s\n", res, libusb_error_name(res));
	197	+ transfer_completed(transfer) = 1;
	198	+ return false;
199	199	}
200	200
201	201

diff -r 2d887527abb7 -r 41248e93aa05 gui/probe_run.h

--- a/gui/probe_run.h Mon Sep 17 14:35:39 2018 +0100

+++ b/gui/probe_run.h Mon Sep 17 15:26:45 2018 +0100

		@@ -1,7 +1,7 @@
1	1	// probe_run_iso_x(), probe_run_bulk()
2	2	// called from "thread_probe()"
3	3
4		-enum { a_skip = 5 }; // AD9288 delays output data by 5 clock cycles
	4	+enum { ADC_DELAY = 5 }; // AD9288 delays output data by 5 clock cycles
5	5
6	6	static unsigned b2w(const unsigned char * data)
7	7	{

		@@ -326,33 +326,33 @@
326	326
327	327	case trigger_select_t::sel_A1:
328	328	if (req.a_width == DX::W_16BIT)
329		- trigger = find_a_trigger<a2_t>((const a2_t )&req.a_buf[a_skip2+0], s_idx, e_idx-a_skip);
	329	+ trigger = find_a_trigger<a2_t>((const a2_t )&req.a_buf[ADC_DELAY2+0], s_idx, e_idx-ADC_DELAY);
330	330	else
331		- trigger = find_a_trigger<a1_t>((const a1_t *)&req.a_buf[a_skip], s_idx, e_idx-a_skip);
	331	+ trigger = find_a_trigger<a1_t>((const a1_t *)&req.a_buf[ADC_DELAY], s_idx, e_idx-ADC_DELAY);
332	332	break;
333	333	case trigger_select_t::sel_A2:
334		- trigger = find_a_trigger<a2_t>((const a2_t )&req.a_buf[a_skip2+1], s_idx, e_idx-a_skip);
	334	+ trigger = find_a_trigger<a2_t>((const a2_t )&req.a_buf[ADC_DELAY2+1], s_idx, e_idx-ADC_DELAY);
335	335	break;
336	336
337	337	case trigger_select_t::sel_D_A1:
338	338	if (req.d_width == DX::W_16BIT) {
339	339	if (req.a_width == DX::W_16BIT)
340		- trigger = find_ad_trigger<a2_t,d16_t>((const a2_t )&req.a_buf[a_skip2+0], (const d16_t *)req.d_buf, s_idx, e_idx-a_skip);
	340	+ trigger = find_ad_trigger<a2_t,d16_t>((const a2_t )&req.a_buf[ADC_DELAY2+0], (const d16_t *)req.d_buf, s_idx, e_idx-ADC_DELAY);
341	341	else
342		- trigger = find_ad_trigger<a1_t,d16_t>((const a1_t )&req.a_buf[a_skip], (const d16_t )req.d_buf, s_idx, e_idx-a_skip);
	342	+ trigger = find_ad_trigger<a1_t,d16_t>((const a1_t )&req.a_buf[ADC_DELAY], (const d16_t )req.d_buf, s_idx, e_idx-ADC_DELAY);
343	343	} else {
344	344	if (req.a_width == DX::W_16BIT)
345		- trigger = find_ad_trigger<a2_t,d8_t> ((const a2_t )&req.a_buf[a_skip2+0], (const d8_t *)req.d_buf, s_idx, e_idx-a_skip);
	345	+ trigger = find_ad_trigger<a2_t,d8_t> ((const a2_t )&req.a_buf[ADC_DELAY2+0], (const d8_t *)req.d_buf, s_idx, e_idx-ADC_DELAY);
346	346	else
347		- trigger = find_ad_trigger<a1_t,d8_t> ((const a1_t )&req.a_buf[a_skip], (const d8_t )req.d_buf, s_idx, e_idx-a_skip);
	347	+ trigger = find_ad_trigger<a1_t,d8_t> ((const a1_t )&req.a_buf[ADC_DELAY], (const d8_t )req.d_buf, s_idx, e_idx-ADC_DELAY);
348	348	}
349	349	break;
350	350
351	351	case trigger_select_t::sel_D_A2:
352	352	if (req.d_width == DX::W_16BIT)
353		- trigger = find_ad_trigger<a2_t,d16_t>((const a2_t )&req.a_buf[a_skip2+1], (const d16_t *)req.d_buf, s_idx, e_idx-a_skip);
	353	+ trigger = find_ad_trigger<a2_t,d16_t>((const a2_t )&req.a_buf[ADC_DELAY2+1], (const d16_t *)req.d_buf, s_idx, e_idx-ADC_DELAY);
354	354	else
355		- trigger = find_ad_trigger<a2_t,d8_t> ((const a2_t )&req.a_buf[a_skip2+1], (const d8_t *)req.d_buf, s_idx, e_idx-a_skip);
	355	+ trigger = find_ad_trigger<a2_t,d8_t> ((const a2_t )&req.a_buf[ADC_DELAY2+1], (const d8_t *)req.d_buf, s_idx, e_idx-ADC_DELAY);
356	356	break;
357	357	}
358	358	return trigger;

		@@ -432,7 +432,7 @@
432	432	insert_d_req(req, src_start, dst_start, length);
433	433	}
434	434
435		- src_start += a_skip;
	435	+ src_start += ADC_DELAY;
436	436	{ // copy Ain data
437	437	unsigned length = min(samples - src_start, disp_data.size - dst_start);
438	438	insert_a_req(req, src_start, dst_start, length);

diff -r 2d887527abb7 -r 41248e93aa05 gui/probe_run_iso_ad.h

--- a/gui/probe_run_iso_ad.h Mon Sep 17 14:35:39 2018 +0100

+++ b/gui/probe_run_iso_ad.h Mon Sep 17 15:26:45 2018 +0100

		@@ -7,7 +7,6 @@
7	7	assert(req.a_width != DX::W_NONE);
8	8	assert(req.d_width != DX::W_NONE);
9	9
10		- //req.number = disp_data.size * 1000;
11	10	unsigned mult = 4000 * probe.sample_rate();
12	11	req.number = 4096 * mult; // ca 16sec
13	12	g_printf("sample rate: %.3fMs/sec, number: %u\n", probe.sample_rate(), req.number);

		@@ -19,7 +18,7 @@
19	18	return;
20	19	}
21	20
22		- const unsigned ring_pkt_num = iso_pkt_num(1, min(req.a_pkt_len, req.d_pkt_len));
	21	+ const unsigned ring_pkt_num = iso_pkt_num(min(req.a_pkt_len, req.d_pkt_len));
23	22	unsigned ring_buf_num;
24	23	if (disp_data.size > 256 * 1024)
25	24	ring_buf_num = 64;

		@@ -85,7 +84,7 @@
85	84
86	85	tr_metrics_t m_a;
87	86	tr_metrics_t m_d;
88		- unsigned shift_ain = a_skip * req.a_width;
	87	+ unsigned shift_ain = ADC_DELAY * req.a_width;
89	88	unsigned in_flight = ring.d1.buf_num;
90	89	unsigned in_flight_min = in_flight;
91	90	while(1) {

		@@ -182,7 +181,7 @@
182	181	inc_mm_count();
183	182	release_tail = true;
184	183	assert(disp_data.a_end == disp_data.d_end);
185		- if (disp_data.a_end == disp_data.size) { // disp filled
	184	+ if (disp_data.d_end == disp_data.size) { // disp filled
186	185	disp_completed = true;
187	186	} else { // some space left on disp
188	187	state = POST; // fill the rest of disp

		@@ -190,7 +189,7 @@
190	189	}
191	190	} else if (state == POST) { // copy data after trigger
192	191	assert(disp_data.a_end == disp_data.d_end);
193		- unsigned disp_left = disp_data.size - disp_data.a_end;
	192	+ unsigned disp_left = disp_data.size - disp_data.d_end;
194	193	if (samples > disp_left)
195	194	samples = disp_left;
196	195	insert_cr_d(d_shift, cr_d, cr_d.idx_used, cr_d.offset_used>>d_shift, disp_data.d_end, samples);

		@@ -200,7 +199,7 @@
200	199	holdoff_left -= samples;
201	200	release_tail = true;
202	201	assert(disp_data.a_end == disp_data.d_end);
203		- if (disp_data.a_end == disp_data.size) { // disp filled
	202	+ if (disp_data.d_end == disp_data.size) { // disp filled
204	203	disp_completed = true;
205	204	}
206	205	} else { // HoldOff

diff -r 2d887527abb7 -r 41248e93aa05 gui/probe_run_iso_d.h

--- a/gui/probe_run_iso_d.h Mon Sep 17 14:35:39 2018 +0100

+++ b/gui/probe_run_iso_d.h Mon Sep 17 15:26:45 2018 +0100

		@@ -19,7 +19,7 @@
19	19	}
20	20
21	21	assert(req.a_pkt_len == 0);
22		- const unsigned ring_pkt_num = iso_pkt_num(1, req.d_pkt_len);
	22	+ const unsigned ring_pkt_num = iso_pkt_num(req.d_pkt_len);
23	23	unsigned ring_buf_num;
24	24	if (disp_data.size > 256 * 1024)
25	25	ring_buf_num = 64;

Show on old repository browser