9789bf70eb150376bf61ddbd463b5122e3da5ac2
[deb_libcec.git] / src / lib / adapter / Pulse-Eight / USBCECAdapterDetection.cpp
1 /*
2 * This file is part of the libCEC(R) library.
3 *
4 * libCEC(R) is Copyright (C) 2011-2012 Pulse-Eight Limited. All rights reserved.
5 * libCEC(R) is an original work, containing original code.
6 *
7 * libCEC(R) is a trademark of Pulse-Eight Limited.
8 *
9 * This program is dual-licensed; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22 *
23 *
24 * Alternatively, you can license this library under a commercial license,
25 * please contact Pulse-Eight Licensing for more information.
26 *
27 * For more information contact:
28 * Pulse-Eight Licensing <license@pulse-eight.com>
29 * http://www.pulse-eight.com/
30 * http://www.pulse-eight.net/
31 */
32
33 #include "env.h"
34 #include "USBCECAdapterDetection.h"
35 #include "lib/platform/util/StdString.h"
36
37 #if defined(__APPLE__)
38 #include <dirent.h>
39 #include <sys/param.h>
40 #include <IOKit/IOKitLib.h>
41 #include <IOKit/IOMessage.h>
42 #include <IOKit/IOCFPlugIn.h>
43 #include <IOKit/usb/IOUSBLib.h>
44 #include <IOKit/serial/IOSerialKeys.h>
45 #include <CoreFoundation/CoreFoundation.h>
46 #elif defined(__WINDOWS__)
47 #pragma comment(lib, "advapi32.lib")
48 #pragma comment(lib, "setupapi.lib")
49 #include <setupapi.h>
50
51 // the virtual COM port only shows up when requesting devices with the raw device guid!
52 static GUID USB_RAW_GUID = { 0xA5DCBF10, 0x6530, 0x11D2, { 0x90, 0x1F, 0x00, 0xC0, 0x4F, 0xB9, 0x51, 0xED } };
53 #elif defined(HAVE_LIBUDEV)
54 #include <dirent.h>
55 #include <poll.h>
56 extern "C" {
57 #include <libudev.h>
58 }
59 #elif defined(__FreeBSD__)
60 #include <stdio.h>
61 #include <unistd.h>
62 #endif
63
64 #define CEC_VID 0x2548
65 #define CEC_PID 0x1001
66 #define CEC_PID2 0x1002
67
68 using namespace CEC;
69 using namespace std;
70
71 #if defined(HAVE_LIBUDEV)
72 bool TranslateComPort(CStdString &strString)
73 {
74 CStdString strTmp(strString);
75 strTmp.MakeReverse();
76 int iSlash = strTmp.Find('/');
77 if (iSlash >= 0)
78 {
79 strTmp = strTmp.Left(iSlash);
80 strTmp.MakeReverse();
81 strString.Format("%s/%s:1.0/tty", strString.c_str(), strTmp.c_str());
82 return true;
83 }
84
85 return false;
86 }
87
88 bool FindComPort(CStdString &strLocation)
89 {
90 CStdString strPort = strLocation;
91 bool bReturn(!strPort.IsEmpty());
92 CStdString strConfigLocation(strLocation);
93 if (TranslateComPort(strConfigLocation))
94 {
95 DIR *dir;
96 struct dirent *dirent;
97 if((dir = opendir(strConfigLocation.c_str())) == NULL)
98 return bReturn;
99
100 while ((dirent = readdir(dir)) != NULL)
101 {
102 if(strcmp((char*)dirent->d_name, "." ) != 0 && strcmp((char*)dirent->d_name, ".." ) != 0)
103 {
104 strPort.Format("/dev/%s", dirent->d_name);
105 if (!strPort.IsEmpty())
106 {
107 strLocation = strPort;
108 bReturn = true;
109 break;
110 }
111 }
112 }
113 closedir(dir);
114 }
115
116 return bReturn;
117 }
118 #endif
119
120 bool CUSBCECAdapterDetection::CanAutodetect(void)
121 {
122 #if defined(__APPLE__) || defined(HAVE_LIBUDEV) || defined(__WINDOWS__) || defined(__FreeBSD__)
123 return true;
124 #else
125 return false;
126 #endif
127 }
128
129 uint8_t CUSBCECAdapterDetection::FindAdapters(cec_adapter *deviceList, uint8_t iBufSize, const char *strDevicePath /* = NULL */)
130 {
131 uint8_t iFound(0);
132
133 #if defined(__APPLE__)
134 kern_return_t kresult;
135 char bsdPath[MAXPATHLEN] = {0};
136 io_iterator_t serialPortIterator;
137
138 CFMutableDictionaryRef classesToMatch = IOServiceMatching(kIOSerialBSDServiceValue);
139 if (classesToMatch)
140 {
141 CFDictionarySetValue(classesToMatch, CFSTR(kIOSerialBSDTypeKey), CFSTR(kIOSerialBSDModemType));
142 kresult = IOServiceGetMatchingServices(kIOMasterPortDefault, classesToMatch, &serialPortIterator);
143 if (kresult == KERN_SUCCESS)
144 {
145 io_object_t serialService;
146 while ((serialService = IOIteratorNext(serialPortIterator)))
147 {
148 int iVendor = 0, iProduct = 0;
149 CFTypeRef bsdPathAsCFString;
150
151 // fetch the device path.
152 bsdPathAsCFString = IORegistryEntryCreateCFProperty(serialService,
153 CFSTR(kIOCalloutDeviceKey), kCFAllocatorDefault, 0);
154 if (bsdPathAsCFString)
155 {
156 // convert the path from a CFString to a C (NUL-terminated) string.
157 CFStringGetCString((CFStringRef)bsdPathAsCFString, bsdPath, MAXPATHLEN - 1, kCFStringEncodingUTF8);
158 CFRelease(bsdPathAsCFString);
159
160 // now walk up the hierarchy until we find the entry with vendor/product IDs
161 io_registry_entry_t parent;
162 CFTypeRef vendorIdAsCFNumber = NULL;
163 CFTypeRef productIdAsCFNumber = NULL;
164 kern_return_t kresult = IORegistryEntryGetParentEntry(serialService, kIOServicePlane, &parent);
165 while (kresult == KERN_SUCCESS)
166 {
167 vendorIdAsCFNumber = IORegistryEntrySearchCFProperty(parent,
168 kIOServicePlane, CFSTR(kUSBVendorID), kCFAllocatorDefault, 0);
169 productIdAsCFNumber = IORegistryEntrySearchCFProperty(parent,
170 kIOServicePlane, CFSTR(kUSBProductID), kCFAllocatorDefault, 0);
171 if (vendorIdAsCFNumber && productIdAsCFNumber)
172 {
173 CFNumberGetValue((CFNumberRef)vendorIdAsCFNumber, kCFNumberIntType, &iVendor);
174 CFRelease(vendorIdAsCFNumber);
175 CFNumberGetValue((CFNumberRef)productIdAsCFNumber, kCFNumberIntType, &iProduct);
176 CFRelease(productIdAsCFNumber);
177 IOObjectRelease(parent);
178 break;
179 }
180 io_registry_entry_t oldparent = parent;
181 kresult = IORegistryEntryGetParentEntry(parent, kIOServicePlane, &parent);
182 IOObjectRelease(oldparent);
183 }
184 if (strlen(bsdPath) && iVendor == CEC_VID && (iProduct == CEC_PID || iProduct == CEC_PID2))
185 {
186 if (!strDevicePath || !strcmp(bsdPath, strDevicePath))
187 {
188 // on darwin, the device path is the same as the comm path.
189 snprintf(deviceList[iFound ].path, sizeof(deviceList[iFound].path), "%s", bsdPath);
190 snprintf(deviceList[iFound++].comm, sizeof(deviceList[iFound].path), "%s", bsdPath);
191 }
192 }
193 }
194 IOObjectRelease(serialService);
195 }
196 }
197 IOObjectRelease(serialPortIterator);
198 }
199 #elif defined(HAVE_LIBUDEV)
200 struct udev *udev;
201 if (!(udev = udev_new()))
202 return -1;
203
204 struct udev_enumerate *enumerate;
205 struct udev_list_entry *devices, *dev_list_entry;
206 struct udev_device *dev, *pdev;
207 enumerate = udev_enumerate_new(udev);
208 udev_enumerate_scan_devices(enumerate);
209 devices = udev_enumerate_get_list_entry(enumerate);
210 udev_list_entry_foreach(dev_list_entry, devices)
211 {
212 const char *strPath;
213 strPath = udev_list_entry_get_name(dev_list_entry);
214
215 dev = udev_device_new_from_syspath(udev, strPath);
216 if (!dev)
217 continue;
218
219 pdev = udev_device_get_parent(udev_device_get_parent(dev));
220 if (!pdev || !udev_device_get_sysattr_value(pdev,"idVendor") || !udev_device_get_sysattr_value(pdev, "idProduct"))
221 {
222 udev_device_unref(dev);
223 continue;
224 }
225
226 int iVendor, iProduct;
227 sscanf(udev_device_get_sysattr_value(pdev, "idVendor"), "%x", &iVendor);
228 sscanf(udev_device_get_sysattr_value(pdev, "idProduct"), "%x", &iProduct);
229 if (iVendor == CEC_VID && (iProduct == CEC_PID || iProduct == CEC_PID2))
230 {
231 CStdString strPath(udev_device_get_syspath(pdev));
232 if (!strDevicePath || !strcmp(strPath.c_str(), strDevicePath))
233 {
234 CStdString strComm(strPath);
235 if (FindComPort(strComm))
236 {
237 snprintf(deviceList[iFound ].path, sizeof(deviceList[iFound].path), "%s", strPath.c_str());
238 snprintf(deviceList[iFound++].comm, sizeof(deviceList[iFound].path), "%s", strComm.c_str());
239 }
240 }
241 }
242 udev_device_unref(dev);
243 }
244
245 udev_enumerate_unref(enumerate);
246 udev_unref(udev);
247 #elif defined(__WINDOWS__)
248 HDEVINFO hDevHandle;
249 DWORD required = 0, iMemberIndex = 0;
250 int nBufferSize = 0;
251
252 SP_DEVICE_INTERFACE_DATA deviceInterfaceData;
253 deviceInterfaceData.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
254
255 SP_DEVINFO_DATA devInfoData;
256 devInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
257
258 if ((hDevHandle = SetupDiGetClassDevs(&USB_RAW_GUID, 0, 0, DIGCF_PRESENT | DIGCF_DEVICEINTERFACE)) == INVALID_HANDLE_VALUE)
259 return iFound;
260
261 BOOL bResult = true;
262 TCHAR *buffer = NULL;
263 PSP_DEVICE_INTERFACE_DETAIL_DATA devicedetailData;
264 while(bResult && iFound < iBufSize)
265 {
266 bResult = SetupDiEnumDeviceInfo(hDevHandle, iMemberIndex, &devInfoData);
267
268 if (bResult)
269 bResult = SetupDiEnumDeviceInterfaces(hDevHandle, 0, &USB_RAW_GUID, iMemberIndex, &deviceInterfaceData);
270
271 if(!bResult)
272 {
273 SetupDiDestroyDeviceInfoList(hDevHandle);
274 delete []buffer;
275 buffer = NULL;
276 return iFound;
277 }
278
279 iMemberIndex++;
280 BOOL bDetailResult = false;
281 {
282 // As per MSDN, Get the required buffer size. Call SetupDiGetDeviceInterfaceDetail with a
283 // NULL DeviceInterfaceDetailData pointer, a DeviceInterfaceDetailDataSize of zero,
284 // and a valid RequiredSize variable. In response to such a call, this function returns
285 // the required buffer size at RequiredSize and fails with GetLastError returning
286 // ERROR_INSUFFICIENT_BUFFER.
287 // Allocate an appropriately sized buffer and call the function again to get the interface details.
288
289 SetupDiGetDeviceInterfaceDetail(hDevHandle, &deviceInterfaceData, NULL, 0, &required, NULL);
290
291 buffer = new TCHAR[required];
292 devicedetailData = (PSP_DEVICE_INTERFACE_DETAIL_DATA) buffer;
293 devicedetailData->cbSize = sizeof(SP_INTERFACE_DEVICE_DETAIL_DATA);
294 nBufferSize = required;
295 }
296
297 bDetailResult = SetupDiGetDeviceInterfaceDetail(hDevHandle, &deviceInterfaceData, devicedetailData, nBufferSize , &required, NULL);
298 if(!bDetailResult)
299 continue;
300
301 if (strDevicePath && strcmp(strDevicePath, devicedetailData->DevicePath) != 0)
302 continue;
303
304 CStdString strVendorId;
305 CStdString strProductId;
306 CStdString strTmp(devicedetailData->DevicePath);
307 strVendorId.assign(strTmp.substr(strTmp.Find("vid_") + 4, 4));
308 strProductId.assign(strTmp.substr(strTmp.Find("pid_") + 4, 4));
309 if (strTmp.Find("&mi_") >= 0 && strTmp.Find("&mi_00") < 0)
310 continue;
311
312 int iVendor, iProduct;
313 sscanf(strVendorId, "%x", &iVendor);
314 sscanf(strProductId, "%x", &iProduct);
315 if (iVendor != CEC_VID || (iProduct != CEC_PID && iProduct != CEC_PID2))
316 continue;
317
318 HKEY hDeviceKey = SetupDiOpenDevRegKey(hDevHandle, &devInfoData, DICS_FLAG_GLOBAL, 0, DIREG_DEV, KEY_QUERY_VALUE);
319 if (!hDeviceKey)
320 continue;
321
322 TCHAR strPortName[256];
323 strPortName[0] = _T('\0');
324 DWORD dwSize = sizeof(strPortName);
325 DWORD dwType = 0;
326
327 /* search the registry */
328 if ((RegQueryValueEx(hDeviceKey, _T("PortName"), NULL, &dwType, reinterpret_cast<LPBYTE>(strPortName), &dwSize) == ERROR_SUCCESS) && (dwType == REG_SZ))
329 {
330 if (_tcslen(strPortName) > 3 && _tcsnicmp(strPortName, _T("COM"), 3) == 0 &&
331 _ttoi(&(strPortName[3])) > 0)
332 {
333 snprintf(deviceList[iFound ].path, sizeof(deviceList[iFound].path), "%s", devicedetailData->DevicePath);
334 snprintf(deviceList[iFound++].comm, sizeof(deviceList[iFound].path), "%s", strPortName);
335 }
336 }
337
338 RegCloseKey(hDeviceKey);
339 }
340 #elif defined(__FreeBSD__)
341 char devicePath[PATH_MAX + 1];
342 int i;
343
344 for (i = 0; i < 8; ++i)
345 {
346 (void)snprintf(devicePath, sizeof(devicePath), "/dev/ttyU%d", i);
347 if (!access(devicePath, 0))
348 {
349 snprintf(deviceList[iFound ].path, sizeof(deviceList[iFound].path), "%s", devicePath);
350 snprintf(deviceList[iFound++].comm, sizeof(deviceList[iFound].path), "%s", devicePath);
351 }
352 }
353 #else
354 //silence "unused" warnings
355 void *tmp = (void*)deviceList;
356 tmp = (void *)strDevicePath;
357 #endif
358
359 iBufSize = 0; /* silence "unused" warning on linux/osx */
360
361 return iFound;
362 }