调整USB加锁粒度

hgdriver/hgdev/hg_scanner_302.cpp

@@ -196,8 +196,6 @@ hg_scanner_302::~hg_scanner_302()
 }
 int hg_scanner_302::read_register(int addr, int* val)
 {
-	std::lock_guard<std::mutex>      lock(io_lock_);
-
 	std::this_thread::sleep_for(std::chrono::milliseconds(50));
 	int l = sizeof(*val),
 		ret = io_->control_io(0x0c0, USB_REQ_GET_DEV_REGS, addr, 0, val, &l);
@@ -209,8 +207,6 @@ int hg_scanner_302::read_register(int addr, int* val)
 }
 int hg_scanner_302::write_register(int addr, int val)
 {
-	std::lock_guard<std::mutex>      lock(io_lock_);
-
 	std::this_thread::sleep_for(std::chrono::milliseconds(50));
 	int l = sizeof(val),
 		ret = io_->control_io(0x040, USB_REQ_SET_DEV_REGS, addr, 0, &val, &l);
@@ -256,6 +252,7 @@ std::string hg_scanner_302::control_fetch(int addr, int val, int size)
 }
 std::string hg_scanner_302::get_fpga(void)
 {
+	std::lock_guard<std::mutex>      lock(io_lock_);
 	int val = 0,
 		ret = read_register(setting3399::SR_GET_MBVERSION_LENGHT, &val);
 	std::string fpga("");
@@ -272,6 +269,7 @@ std::string hg_scanner_302::get_fpga(void)
 }
 int hg_scanner_302::clr_roller_num(void)
 {
+	std::lock_guard<std::mutex>      lock(io_lock_);
 	int val = 0,
 		ret = read_register(setting3399::SR_CLR_ROLLER_NUM, &val);
 
@@ -285,6 +283,7 @@ int hg_scanner_302::clr_roller_num(void)
 }
 int hg_scanner_302::get_sleep_time(void)
 {
+	std::lock_guard<std::mutex>      lock(io_lock_);
 	int val = 0,
 		ret = read_register(setting3399::SR_GET_SLEEPTIME, &val);
 
@@ -298,6 +297,7 @@ int hg_scanner_302::get_sleep_time(void)
 }
 int hg_scanner_302::get_scan_mode(void)
 {
+	std::lock_guard<std::mutex>      lock(io_lock_);
 	int	val = 0,
 		ret = read_register(setting3399::SR_OS, &val);
 
@@ -313,6 +313,7 @@ int hg_scanner_302::get_scan_mode(void)
 }
 int hg_scanner_302::get_status(void)
 {
+	std::lock_guard<std::mutex>      lock(io_lock_);
 	int	val = 0,
 		ret = read_register(setting3399::SR_STATUS, &val);
 
@@ -328,6 +329,7 @@ int hg_scanner_302::get_status(void)
 }
 bool hg_scanner_302::is_dev_tx(void)
 {
+	std::lock_guard<std::mutex>      lock(io_lock_);
 	int	val = 0,
 		ret = read_register(setting3399::SR_STATUS, &val);
 
@@ -343,6 +345,7 @@ bool hg_scanner_302::is_dev_tx(void)
 }
 bool hg_scanner_302::is_dev_image_process_done(void)
 {
+	std::lock_guard<std::mutex>      lock(io_lock_);
 	int	val = 0,
 		ret = read_register(setting3399::SR_GET_IMAGEPROCESSDONE, &val);
 
@@ -358,7 +361,8 @@ bool hg_scanner_302::is_dev_image_process_done(void)
 }
 bool hg_scanner_302::is_dev_image_keep_last_paper(void)
 {
-	
+	std::lock_guard<std::mutex>      lock(io_lock_);
+
 	int	val = 0,
 		ret = read_register(setting3399::SR_GET_KEEP_LAST_PAPER, &val);
 
@@ -374,6 +378,7 @@ bool hg_scanner_302::is_dev_image_keep_last_paper(void)
 }
 int hg_scanner_302::get_scanned_count(void)
 {
+	std::lock_guard<std::mutex>      lock(io_lock_);
 	int val = 0,
 		ret = read_register(setting3399::SR_GET_SCANN_NUM, &val);
 
@@ -387,6 +392,7 @@ int hg_scanner_302::get_scanned_count(void)
 }
 int hg_scanner_302::get_image_count(void)
 {
+	std::lock_guard<std::mutex>      lock(io_lock_);
 	int val = 0,
 		ret = read_register(setting3399::SR_IM_COUNT, &val);
 
@@ -399,6 +405,7 @@ int hg_scanner_302::get_image_count(void)
 }
 int hg_scanner_302::get_front_data_size(void)
 {
+	std::lock_guard<std::mutex>      lock(io_lock_);
 	int val = 0,
 		ret = read_register(setting3399::SR_IM_FRONT_SIZE, &val);
 
@@ -429,11 +436,13 @@ void hg_scanner_302::init_version(void)
 }
 int hg_scanner_302::get_device_sleep_stautus(void)
 {
+	std::lock_guard<std::mutex>      lock(io_lock_);
 	int ret =read_register(setting3399::SR_GET_SLEEP_STAUTUS,0);
 	return ret;
 }
 int hg_scanner_302::get_device_paperon_stautus(void)
 {
+	std::lock_guard<std::mutex>      lock(io_lock_);
 	int ret =read_register(setting3399::SR_GET_PAPERON,0);
 	return ret;
 }
@@ -470,7 +479,10 @@ int hg_scanner_302::writedown_device_configuration(bool type,setting_hardware::H
 	{
 		dev_conf->params_3399.enable_sizecheck = false;
 	}
-	ret = write_register(setting3399::SR_CONFIG_SCAN_PARAM, dev_conf->value);
+	{
+		std::lock_guard<std::mutex>      lock(io_lock_);
+		ret = write_register(setting3399::SR_CONFIG_SCAN_PARAM, dev_conf->value);
+	}
 
 	VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "Writedown scanner configuration(0x%x) = %s\n", dev_conf->value, hg_scanner_err_name(ret));
 	return ret;
@@ -520,6 +532,7 @@ int hg_scanner_302::writedown_image_configuration(void)
 }
 int hg_scanner_302::pop_first_image(void)
 {
+	std::lock_guard<std::mutex>      lock(io_lock_);
 	int ret = write_register(setting3399::SR_IM_POP, 1);
 
 	VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "popup first image = %s\n", hg_scanner_err_name(ret));
@@ -547,6 +560,7 @@ int hg_scanner_302::read_one_image_from_usb(SANE_Image_Statu statu)
 		ret = status_;
 	else
 	{
+		std::lock_guard<std::mutex>  lock(io_lock_);
 		std::shared_ptr<tiny_buffer> buf(aquire_memory(total));
 		if (!buf.get())
 			return SCANNER_ERR_INSUFFICIENT_MEMORY;
@@ -560,7 +574,6 @@ int hg_scanner_302::read_one_image_from_usb(SANE_Image_Statu statu)
 			std::this_thread::sleep_for(std::chrono::milliseconds(10));
 			r = total;
 			{
-				std::lock_guard<std::mutex>      lock(io_lock_);
 				void* buff = buf->data(off, (unsigned int*)&r);
 
 				ret = SCANNER_ERR_INSUFFICIENT_MEMORY;
@@ -1043,7 +1056,10 @@ int hg_scanner_302::start(void)
 		return ret;
 	}
 	val = 0;
-	ret = read_register(/*SR_GET_ANDROID_STATE*/0x1001, &val);
+	{
+		std::lock_guard<std::mutex>      lock(io_lock_);
+		ret = read_register(/*SR_GET_ANDROID_STATE*/0x1001, &val);
+	}
 
 	while (val)
 	{
@@ -1069,8 +1085,11 @@ int hg_scanner_302::start(void)
 	if (test_1_paper_)
 		count = 1;
 
-	write_register(0x1000, count);
+	{
-	ret = write_command(setting3399::SC_START);
+		std::lock_guard<std::mutex>      lock(io_lock_);
+		write_register(0x1000, count);
+		ret = write_command(setting3399::SC_START);
+	}
 	VLOG_MINI_1(LOG_LEVEL_WARNING, "start result: %s\n", hg_scanner_err_name(ret));
 
 	if (ret == SCANNER_ERR_OK)
@@ -1089,7 +1108,8 @@ int hg_scanner_302::start(void)
 }
 int hg_scanner_302::stop(void)
 {
-	int ret = SCANNER_ERR_OK; 
+	std::lock_guard<std::mutex>      lock(io_lock_);
+	int ret = SCANNER_ERR_OK;
 
 	user_cancel_ = true;
 	ret = write_command(setting3399::SC_STOP);
@@ -1133,19 +1153,23 @@ int hg_scanner_302::device_io_control(unsigned long code, void* data, unsigned*
 }
 std::string hg_scanner_302::get_firmware_version(void)
 {
+	std::lock_guard<std::mutex>      lock(io_lock_);
 	return control_fetch(setting3399::SR_GET_FWVERSION, 0, 512);
 }
 std::string hg_scanner_302::get_serial_num(void)
 {
+	std::lock_guard<std::mutex>      lock(io_lock_);
 	return control_fetch(setting3399::SR_GET_SERIALNUM, 0, 512);
 }
 std::string hg_scanner_302::get_ip(void)
 {
+	std::lock_guard<std::mutex>      lock(io_lock_);
 	return control_fetch(setting3399::SR_GET_IPADDR, 0, 512);
 }
 
 int hg_scanner_302::set_clear_roller_num(void)
 {
+	std::lock_guard<std::mutex>      lock(io_lock_);
 	int val = 0,
 		ret = read_register(setting3399::SR_CLR_ROLLER_NUM, &val);
 
@@ -1153,6 +1177,7 @@ int hg_scanner_302::set_clear_roller_num(void)
 }
 int hg_scanner_302::set_clear_history_num(void)
 {
+	std::lock_guard<std::mutex>      lock(io_lock_);
 	int val = 0,
 		ret = read_register(setting3399::SR_CLR_SCANN_NUM, &val);
 
@@ -1160,6 +1185,7 @@ int hg_scanner_302::set_clear_history_num(void)
 }
 int hg_scanner_302::set_serial_num(string str)
 {
+	std::lock_guard<std::mutex>      lock(io_lock_);
 	int len = str.size(),
 		ret = write_register(setting3399::SR_SET_SERIALNUM, len);
 	if (ret == SCANNER_ERR_OK)
@@ -1170,10 +1196,12 @@ int hg_scanner_302::set_serial_num(string str)
 }
 int hg_scanner_302::set_vid_pid(int data)
 {
+	std::lock_guard<std::mutex>      lock(io_lock_);
 	return write_register(setting3399::SR_SET_USBVIDPID, data);
 }
 int hg_scanner_302::get_vid_pid(int& data)
 {
+	std::lock_guard<std::mutex>      lock(io_lock_);
 	return read_register(setting3399::SR_GET_USBVIDPID, &data);
 }
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -1192,6 +1220,7 @@ int hg_scanner_302::get_device_code(void)
 }
 int hg_scanner_302::get_sleep_time(int& data)
 {
+	std::lock_guard<std::mutex>      lock(io_lock_);
 	int val = 0;
 	int ret = read_register(setting3399::SR_GET_SLEEPTIME, &val);
 
@@ -1206,6 +1235,7 @@ int hg_scanner_302::get_sleep_time(int& data)
 }
 int hg_scanner_302::set_sleep_time(int setsleepime)
 {
+	std::lock_guard<std::mutex>      lock(io_lock_);
 	int ret = write_register(setting3399::SR_SET_SLEEPTIME, setsleepime);
 
 	VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "set sleep time to %d = %s\n", setsleepime, hg_scanner_err_name(ret));
@@ -1215,6 +1245,7 @@ int hg_scanner_302::set_sleep_time(int setsleepime)
 
 int hg_scanner_302::get_scanner_paperon(SANE_Bool& type)
 {
+	std::lock_guard<std::mutex>      lock(io_lock_);
 	int val = 0,
 		ret = read_register(setting3399::SR_GET_PAPERON, &val);
  
@@ -1227,6 +1258,7 @@ int hg_scanner_302::get_scanner_paperon(SANE_Bool& type)
 
 int hg_scanner_302::get_scan_is_sleep(SANE_Bool& type)
 {
+	std::lock_guard<std::mutex>      lock(io_lock_);
 	int ret = 0, val;
 	ret = read_register(setting3399::SR_GET_SLEEP_STAUTUS, &val); //0休眠  1唤醒状态
 	if (ret == SCANNER_ERR_OK)
@@ -1237,18 +1269,20 @@ int hg_scanner_302::get_scan_is_sleep(SANE_Bool& type)
 }
 int hg_scanner_302::get_device_log(string &log)
 {
+	std::lock_guard<std::mutex>      lock(io_lock_);
 	int ret = SCANNER_ERR_OK;
 	
 	int len = log.size();
 		ret = write_register(setting3399::SR_SET_JSON_PATH, len);
-		if (ret == SCANNER_ERR_OK)
+	if (ret == SCANNER_ERR_OK)
-			ret = io_->write_bulk(&log[0],&len);
+		ret = io_->write_bulk(&log[0],&len);
 			
 		VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "log path:%s ret:%s\n", log.c_str(),hg_scanner_err_name(ret));		
 	return ret;
 }
 int hg_scanner_302::set_devreboot(int data)
 {
+	std::lock_guard<std::mutex>      lock(io_lock_);
 	int val = 0,
 		ret = write_register(setting3399::SR_REBOOT, val);
 
@@ -1257,6 +1291,7 @@ int hg_scanner_302::set_devreboot(int data)
 }
 int hg_scanner_302::set_devshtudown()
 {
+	std::lock_guard<std::mutex>      lock(io_lock_);
 	int val = 0,
 		ret = write_register(setting3399::SR_POWEROFF, val);
 
@@ -1281,6 +1316,7 @@ int hg_scanner_302::set_firmware_upgrade(std::string str)
 }
 int hg_scanner_302::set_clean_paper_road()
 {
+	std::lock_guard<std::mutex>      lock(io_lock_);
 	int ret = 0, len = 0;
 	ret = write_register(setting3399::SR_CLEAN_PAPER_ROAD, len);
 	return ret;
@@ -1303,18 +1339,20 @@ int hg_scanner_302::get_speed_mode(int& data)
 }
 int hg_scanner_302::set_devs_distortion_check_val(float data)
 {
-		setting3399::Scanner_Reg_Defs retio = setting3399::SR_SET_V_200_RATIO;
+	std::lock_guard<std::mutex>   lock(io_lock_);
-		if (resolution_ <= 200)
+	setting3399::Scanner_Reg_Defs retio = setting3399::SR_SET_V_200_RATIO;
-			retio = setting3399::SR_SET_V_200_RATIO;
+	if (resolution_ <= 200)
-		else if (resolution_ > 200 && resolution_ <= 300)
+		retio = setting3399::SR_SET_V_200_RATIO;
-			retio = setting3399::SR_SET_V_200_RATIO;
+	else if (resolution_ > 200 && resolution_ <= 300)
-		else if (resolution_ > 300 && resolution_ <= 600)
+		retio = setting3399::SR_SET_V_200_RATIO;
-			retio = setting3399::SR_SET_V_200_RATIO;
+	else if (resolution_ > 300 && resolution_ <= 600)
+		retio = setting3399::SR_SET_V_200_RATIO;
 
-		return write_register(retio, *(int*)&save_dpi_color_check_val);
+	return write_register(retio, *(int*)&save_dpi_color_check_val);
 }
 int hg_scanner_302::get_devs_distortion_check_val(float& data)
 {
+	std::lock_guard<std::mutex>      lock(io_lock_);
 	int val = 0;
 	setting3399::Scanner_Reg_Defs ratio = setting3399::SR_SET_V_200_RATIO;
 	if (resolution_ <= 200)
@@ -1334,6 +1372,7 @@ int hg_scanner_302::set_auto_flat(int data)
 }
 int hg_scanner_302::set_notify_sleep()
 {
+	std::lock_guard<std::mutex>      lock(io_lock_);
 	int val = 0,
 		ret = write_register(setting3399::SR_NOTIFY_SLEEP, val);
 
@@ -1341,11 +1380,13 @@ int hg_scanner_302::set_notify_sleep()
 }
 int hg_scanner_302::get_roller_num(int& num)
 {
+	std::lock_guard<std::mutex>      lock(io_lock_);
 	int ret = read_register(setting3399::SR_GET_ROLLER_NUM, &num);
 	return ret;
 }
 int hg_scanner_302::get_history_scan_count(int& val)
 {
+	std::lock_guard<std::mutex>      lock(io_lock_);
 	int ret = read_register(setting3399::SR_GET_SCANN_NUM, &val);
 	return ret;
 }