#include <fcntl.h>
#include <libudev.h>
#include <linux/hidraw.h>
+#include <sys/ioctl.h>
+
#include <string>
+#include "base/files/file_path.h"
+#include "base/message_loop/message_loop.h"
+#include "base/posix/eintr_wrapper.h"
#include "base/threading/thread_restrictions.h"
#include "base/tuple.h"
#include "device/hid/hid_service.h"
-#include "device/hid/hid_service_linux.h"
+// These are already defined in newer versions of linux/hidraw.h.
+#ifndef HIDIOCSFEATURE
+#define HIDIOCSFEATURE(len) _IOC(_IOC_WRITE | _IOC_READ, 'H', 0x06, len)
+#endif
+#ifndef HIDIOCGFEATURE
+#define HIDIOCGFEATURE(len) _IOC(_IOC_WRITE | _IOC_READ, 'H', 0x07, len)
+#endif
namespace device {
-namespace {
+HidConnectionLinux::HidConnectionLinux(HidDeviceInfo device_info,
+ std::string dev_node)
+ : HidConnection(device_info) {
+ int flags = base::File::FLAG_OPEN |
+ base::File::FLAG_READ |
+ base::File::FLAG_WRITE;
-const char kHidrawSubsystem[] = "hidraw";
+ base::File device_file(base::FilePath(dev_node), flags);
+ if (!device_file.IsValid()) {
+ base::File::Error file_error = device_file.error_details();
-} // namespace
+ if (file_error == base::File::FILE_ERROR_ACCESS_DENIED) {
+ VLOG(1) << "Access denied opening device read-write, trying read-only.";
-HidConnectionLinux::HidConnectionLinux(HidDeviceInfo device_info,
- ScopedUdevDevicePtr udev_raw_device)
- : HidConnection(device_info),
- initialized_(false) {
- DCHECK(thread_checker_.CalledOnValidThread());
-
- udev_device* dev = udev_raw_device.get();
- std::string dev_node;
- if (!FindHidrawDevNode(dev, &dev_node)) {
- LOG(ERROR) << "Cannot open HID device as hidraw device.";
- return;
- }
+ flags = base::File::FLAG_OPEN | base::File::FLAG_READ;
- base::PlatformFileError error;
-
- int flags = base::PLATFORM_FILE_OPEN |
- base::PLATFORM_FILE_READ |
- base::PLATFORM_FILE_WRITE |
- base::PLATFORM_FILE_EXCLUSIVE_READ |
- base::PLATFORM_FILE_EXCLUSIVE_WRITE;
-
- base::PlatformFile device_file = base::CreatePlatformFile(
- base::FilePath(dev_node),
- flags,
- NULL,
- &error);
- if (error || device_file <= 0) {
- LOG(ERROR) << error;
- if (device_file)
- base::ClosePlatformFile(device_file);
+ device_file = base::File(base::FilePath(dev_node), flags);
+ }
+ }
+ if (!device_file.IsValid()) {
+ LOG(ERROR) << "Failed to open '" << dev_node << "': "
+ << base::File::ErrorToString(device_file.error_details());
return;
}
- if (fcntl(device_file, F_SETFL, fcntl(device_file, F_GETFL) | O_NONBLOCK)) {
- PLOG(ERROR) << "Failed to set non-blocking flag to device file.";
+
+ if (fcntl(device_file.GetPlatformFile(), F_SETFL,
+ fcntl(device_file.GetPlatformFile(), F_GETFL) | O_NONBLOCK)) {
+ PLOG(ERROR) << "Failed to set non-blocking flag to device file";
return;
}
- device_file_ = device_file;
+ device_file_ = device_file.Pass();
if (!base::MessageLoopForIO::current()->WatchFileDescriptor(
- device_file_,
+ device_file_.GetPlatformFile(),
true,
base::MessageLoopForIO::WATCH_READ_WRITE,
&device_file_watcher_,
this)) {
- LOG(ERROR) << "Cannot start watching file descriptor.";
- return;
+ LOG(ERROR) << "Failed to start watching device file.";
}
-
- initialized_ = true;
}
HidConnectionLinux::~HidConnectionLinux() {
- DCHECK(thread_checker_.CalledOnValidThread());
- Disconnect();
}
-void HidConnectionLinux::OnFileCanReadWithoutBlocking(int fd) {
- DCHECK(thread_checker_.CalledOnValidThread());
- DCHECK_EQ(fd, device_file_);
- DCHECK(initialized_);
-
- uint8 buffer[1024] = {0};
- int bytes = read(device_file_, buffer, 1024);
- if (bytes < 0) {
- if (errno == EAGAIN) {
- return;
- }
- Disconnect();
- return;
- }
- scoped_refptr<net::IOBuffer> io_buffer(new net::IOBuffer(bytes));
- memcpy(io_buffer->data(), buffer, bytes);
- input_reports_.push(std::make_pair(io_buffer, bytes));
+void HidConnectionLinux::PlatformClose() {
+ Disconnect();
+ Flush();
+}
+void HidConnectionLinux::PlatformRead(const ReadCallback& callback) {
+ PendingHidRead pending_read;
+ pending_read.callback = callback;
+ pending_reads_.push(pending_read);
ProcessReadQueue();
}
-void HidConnectionLinux::OnFileCanWriteWithoutBlocking(int fd) {}
-
-void HidConnectionLinux::Disconnect() {
- DCHECK(thread_checker_.CalledOnValidThread());
- if (!initialized_)
- return;
-
- initialized_ = false;
- device_file_watcher_.StopWatchingFileDescriptor();
- close(device_file_);
- while (!read_queue_.empty()) {
- PendingRequest callback = read_queue_.front();
- read_queue_.pop();
- callback.c.Run(false, 0);
+void HidConnectionLinux::PlatformWrite(scoped_refptr<net::IOBuffer> buffer,
+ size_t size,
+ const WriteCallback& callback) {
+ // Linux expects the first byte of the buffer to always be a report ID so the
+ // buffer can be used directly.
+ const ssize_t bytes_written =
+ HANDLE_EINTR(write(device_file_.GetPlatformFile(), buffer->data(), size));
+ if (bytes_written < 0) {
+ VPLOG(1) << "Write failed";
+ Disconnect();
+ callback.Run(false);
+ } else {
+ if (static_cast<size_t>(bytes_written) != size) {
+ LOG(WARNING) << "Incomplete HID write: " << bytes_written
+ << " != " << size;
+ }
+ callback.Run(true);
}
}
-void HidConnectionLinux::Read(scoped_refptr<net::IOBuffer> buffer,
- size_t size,
- const IOCallback& callback) {
- DCHECK(thread_checker_.CalledOnValidThread());
- if (!initialized_) {
- DCHECK(read_queue_.empty());
- // There might be unread reports.
- if (!input_reports_.empty()){
- read_queue_.push(MakeTuple(buffer, size, callback));
- ProcessReadQueue();
- }
- callback.Run(false, 0);
- return;
+void HidConnectionLinux::PlatformGetFeatureReport(
+ uint8_t report_id,
+ const ReadCallback& callback) {
+ // The first byte of the destination buffer is the report ID being requested
+ // and is overwritten by the feature report.
+ DCHECK_GT(device_info().max_feature_report_size, 0);
+ scoped_refptr<net::IOBufferWithSize> buffer(
+ new net::IOBufferWithSize(device_info().max_feature_report_size));
+ buffer->data()[0] = report_id;
+
+ int result = ioctl(device_file_.GetPlatformFile(),
+ HIDIOCGFEATURE(buffer->size()),
+ buffer->data());
+ if (result < 0) {
+ VPLOG(1) << "Failed to get feature report";
+ callback.Run(false, NULL, 0);
} else {
- read_queue_.push(MakeTuple(buffer, size, callback));
- ProcessReadQueue();
+ callback.Run(true, buffer, result);
}
}
-void HidConnectionLinux::Write(scoped_refptr<net::IOBuffer> buffer,
- size_t size,
- const IOCallback& callback) {
- DCHECK(thread_checker_.CalledOnValidThread());
- if (!initialized_) {
- callback.Run(false, 0);
- return;
+void HidConnectionLinux::PlatformSendFeatureReport(
+ scoped_refptr<net::IOBuffer> buffer,
+ size_t size,
+ const WriteCallback& callback) {
+ // Linux expects the first byte of the buffer to always be a report ID so the
+ // buffer can be used directly.
+ int result = ioctl(
+ device_file_.GetPlatformFile(), HIDIOCSFEATURE(size), buffer->data());
+ if (result < 0) {
+ VPLOG(1) << "Failed to send feature report";
+ callback.Run(false);
} else {
- int bytes = write(device_file_, buffer->data(), size);
- if (bytes < 0) {
- Disconnect();
- callback.Run(false, 0);
- } else {
- callback.Run(true, bytes);
- }
+ callback.Run(true);
}
}
-void HidConnectionLinux::GetFeatureReport(scoped_refptr<net::IOBuffer> buffer,
- size_t size,
- const IOCallback& callback) {
- DCHECK(thread_checker_.CalledOnValidThread());
- if (!initialized_) {
- callback.Run(false, 0);
- return;
+void HidConnectionLinux::OnFileCanReadWithoutBlocking(int fd) {
+ DCHECK(thread_checker().CalledOnValidThread());
+ DCHECK_EQ(fd, device_file_.GetPlatformFile());
+
+ size_t expected_report_size = device_info().max_input_report_size + 1;
+ scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(expected_report_size));
+ char* data = buffer->data();
+ if (!device_info().has_report_id) {
+ // Linux will not prefix the buffer with a report ID if they are not used
+ // by the device.
+ data[0] = 0;
+ data++;
+ expected_report_size--;
}
- NOTIMPLEMENTED();
-}
-void HidConnectionLinux::SendFeatureReport(scoped_refptr<net::IOBuffer> buffer,
- size_t size,
- const IOCallback& callback) {
- DCHECK(thread_checker_.CalledOnValidThread());
- if (!initialized_) {
- callback.Run(false, 0);
+ ssize_t bytes_read = HANDLE_EINTR(
+ read(device_file_.GetPlatformFile(), data, expected_report_size));
+ if (bytes_read < 0) {
+ if (errno == EAGAIN) {
+ return;
+ }
+ VPLOG(1) << "Read failed";
+ Disconnect();
return;
}
- NOTIMPLEMENTED();
+ if (!device_info().has_report_id) {
+ // Include the byte prepended earlier.
+ bytes_read++;
+ }
+
+ ProcessInputReport(buffer, bytes_read);
}
-void HidConnectionLinux::ProcessReadQueue() {
- while(read_queue_.size() && input_reports_.size()) {
- PendingRequest request = read_queue_.front();
- read_queue_.pop();
- PendingReport report = input_reports_.front();
- if (report.second > request.b) {
- request.c.Run(false, report.second);
- } else {
- memcpy(request.a->data(), report.first->data(), report.second);
- input_reports_.pop();
- request.c.Run(true, report.second);
- }
- }
+void HidConnectionLinux::OnFileCanWriteWithoutBlocking(int fd) {
}
-bool HidConnectionLinux::FindHidrawDevNode(udev_device* parent,
- std::string* result) {
- udev* udev = udev_device_get_udev(parent);
- if (!udev)
- return false;
+void HidConnectionLinux::Disconnect() {
+ DCHECK(thread_checker().CalledOnValidThread());
+ device_file_watcher_.StopWatchingFileDescriptor();
+ device_file_.Close();
- ScopedUdevEnumeratePtr enumerate(udev_enumerate_new(udev));
- if (!enumerate)
- return false;
+ Flush();
+}
- if (udev_enumerate_add_match_subsystem(enumerate.get(), kHidrawSubsystem)) {
- return false;
- }
- if (udev_enumerate_scan_devices(enumerate.get())) {
- return false;
+void HidConnectionLinux::Flush() {
+ while (!pending_reads_.empty()) {
+ pending_reads_.front().callback.Run(false, NULL, 0);
+ pending_reads_.pop();
}
+}
+
+void HidConnectionLinux::ProcessInputReport(scoped_refptr<net::IOBuffer> buffer,
+ size_t size) {
+ DCHECK(thread_checker().CalledOnValidThread());
+ PendingHidReport report;
+ report.buffer = buffer;
+ report.size = size;
+ pending_reports_.push(report);
+ ProcessReadQueue();
+}
- const char* parent_path = udev_device_get_devpath(parent);
- udev_list_entry* devices = udev_enumerate_get_list_entry(enumerate.get());
- for (udev_list_entry* i = devices; i != NULL;
- i = udev_list_entry_get_next(i)) {
- ScopedUdevDevicePtr hid_dev(
- udev_device_new_from_syspath(udev, udev_list_entry_get_name(i)));
- const char* raw_path = udev_device_get_devnode(hid_dev.get());
- if (strncmp(parent_path,
- udev_device_get_devpath(hid_dev.get()),
- strlen(parent_path)) == 0 &&
- raw_path) {
- *result = raw_path;
- return true;
+void HidConnectionLinux::ProcessReadQueue() {
+ DCHECK(thread_checker().CalledOnValidThread());
+ while (pending_reads_.size() && pending_reports_.size()) {
+ PendingHidRead read = pending_reads_.front();
+ PendingHidReport report = pending_reports_.front();
+
+ pending_reports_.pop();
+ if (CompleteRead(report.buffer, report.size, read.callback)) {
+ pending_reads_.pop();
}
}
-
- return false;
}
} // namespace device
projects / platform / framework / web / crosswalk.git / blobdiff