ArcosWiki

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====== Título: Driver para DIAMOND ATI 750 en Linux ======
\\
{{ :ie0117_proyectos_ii_2014:proyecto_1:ati_diamond.jpg |}} \\ 
====== Integrante: ======
\\
Fabián Morales Araya.
\\
====== Descripción: ====== 
\\
Actualmente el producto DIAMOND ATI Theater™ HD 750 USB TV Tuner  trabaja solamente  para algunas versiones de Windows, especialmente en la versión de Windows Vista, por lo que carece de un driver para los sistemas operativos basados en Linux. Por lo que el proyecto estará enfocado en la investigación y adaptación de un driver que trabaje con Linux.\\
Para poder llevar a cabo el proyecto, se utilizará la ayuda del ¨usbtv007¨ el cuál es un driver de espacio de usuario de prueba para el dispositivo del EasyCap. El cuál será sujeto a modificaciones del código, para así lograr que la tarjeta ATI funcione en un entorno Linux.\\
El proyecto se encuentra realizado en Ubuntu 14.04.
====== Objetivo general: ====== 
\\
Brindar soporte a la tarjeta DIAMOND ATI 750 para que ésta tenga un driver en el espacio de usuario para el sistema operativo de Linux.
\\
====== Objetivos específicos: ======
\\
==== Parte I: ====
\\
Poner en funcionamiento un sistema de ingeniería inversa para obtener el protocolo de la comunicación USB de la tarjeta ATI.
\\
Identificar el protocolo utilizado por la tarjeta y proceder a su análisis.
\\
==== Parte II: ====
\\
Basado en el protocolo identificado y utilizando como plantilla el driver de espacio de usuario EasyCap, modificar dicha plantilla para brindar soporte tanto al protocolo indentificado y a la tarjeta ATI.
\\
====== Justificación: ======
\\
Actualmente no hay un driver de espacio de usuario que permita el funcionamiento de la tarjeta ATI TV Wonder HD 750 en el entorno de los sistemas operativos de Linux. Es por ello que se procede a hacer una investigación en la que se lograría adaptar el driver de dicha tarjeta, para su uso en Linux.
\\
====== Instrucciones: ======
Nota: Como la la tarjeta Diamond ATI solo trabaja con el sistema operativo de Windows(XP, Vista, 7), es necesario hacer la instalación de una máquina virtual(si se utiliza Linux) para poder correr los drivers del dispositivo ATI .
\\
==== Instalación del Diamond ATI TV WONDER: ====
\\
1. Inserte la tarjeta ATI en un puerto USB libre. \\
2. Inserte el CD e instale tanto el driver como el TotalMedia 3.5 . \\
3. Configure el TotalMedia 3.5 de recepción analógica. \\
\\
Nota:Instalar el TotalMedia 3.5 que también viene incluído en el CD de instalación(la utilización de este programa  es indispensable y altamente recomendado a pesar que dice que puede usarse el Media Center de Windows) y ademas, utilizar una antena de televisión como receptor de la señal analógica, pues la antena que viene junto con la tarjeta ATI TV WONDER es muy débil y podría afectar la recepción y reconocimiento de los canales.
\\
==== Captura del protocolo de comunicación USB de la tarjeta de TV directamente en Windows: ====
\\
Nota: Recordar hacer la captura mientras está en funcionamiento tanto TotalMedia y la tarjeta.Directamente en windows se puede puede hacer un análisis de los protocolos de comunicación entre la tarjeta ATI y la computadora. Para ello se puede utilizar el software libre USBPcap en conjunto con Wireshark 1.12.1
\\
Directamente en windows se puede puede hacer un análisis de los protocolos de comunicación entre la tarjeta ATI y la computadora. Para ello se puede utilizar el software libre USBPcap en conjunto con Wireshark 1.12.1 \\ 
En los siguientes links pueden descargarse USBPcap y Wireshark 1.12.1 respectivamente:\\
http://desowin.org/usbpcap/index.html\\
https://www.wireshark.org/download.html\\
\\
1. Descargue e instale USBPcap y Wireshark.\\
2. Luego de la instalación de ambos, diríjase al directorio donde se instaló USBPcap.\\
3. Ejecute USBPcapCMD.exe (Aparecerá una ventana con información similar a la siguiente).\\
{{:ie0117_proyectos_ii_2014:proyecto_1:pantallazo_usbpcap.png|}}\\
4. Elija un puerto, escribiendo el número del puerto que nos interesa, en este caso, el 1.\\
5. Se le pedirá que escriba el nombre del archivo que contenerá los datos del sniffing y agréguele  “.pcap” \\ al final del nombre, ésto para darle ese formato.\\
6. En este momento, el programa está realizando el análisis, para detenerlo, sólo presione CTRL+c.\\
7. Al detenerlo, se cierra la ventana de  USBPcap. Si observa bien el directorio de USBPcap, notará que hay un \\ archivo nuevo, con el nombre que usted ingresó en el paso 5.\\
8. Ábralo, notará que se ejecutará con el programa Wireshark, y aquí verá todos los datos de control y \\ transmisión de la tarjeta ATI.\\
\\
==== Captura del protocolo desde la maquina virtual: ====
\\
Nota: para llevar a cabo el proceso completo,se requiere que la computadora real(host) sea muy potente para poder correr   Windows desde la máquina virtual y en ella el TotalMedia en funcionamiento junto con la tarjeta ATI. Todo esto, para poder realizar el sniffing desde la máquina host. Sin embargo, se puede hacer el sniffing de control con el driver de la tarjeta ATI instalado en la máquina virtual con Windows, desde el host Linux.
\\
=== Instalando la máquina virtual de Oracle "VirtualBox 4.3.20" ===
\\
Para ello procedemos a descargar el paquete correspondiente(según la arquitectura de 32bits o 64bits) para hosts Linux en el siguiente enlace:
\\
https://www.virtualbox.org/wiki/Linux_Downloads
\\
También debemos descargar el "VirtualBox 4.3.20 Oracle VM VirtualBox Extension Pack" pues es necesario para el correcto uso de dispositivos USB en la unidad virtual, éste, en el siguiente enlace:
\\
https://www.virtualbox.org/wiki/Downloads
\\
En la terminal, nos dirijimos hacia la carpeta donde se descargaron dichos paquetes, que normalmente se guardan en el directorio "Downloads" y procedemos a instalar el paquete.deb de virtualbox4.3.2, para ello se requieren privilegios root:
<code>
cd Downloads/
sudo dpkg -i aquí-viene-el-nombre-del-paquete-.deb-de-virtualbox4.3.2-que-usted-acaba-de-descargar.deb
</code>
\\
Luego de instalar virtualbox, proceda a abrir el ¨VirtualBox 4.3.20 Oracle VM VirtualBox Extension Pack¨ con el programa virtualbox que recién acaba de ser instalado. A partir de este momento, puede empezar a crear una máquina virtual de Windows. 
\\
=== Instalando Wireshark ===
\\
A diferencia del proceso de la máquina virtual, podemos descargar e instalar Wireshark con sólamente el siguiente comando dentro de la terminal. Esto por los problemas de reconocimiento USB y por la necesidad de instalar el paquete de extensiones de virtualbox. Procedemos con privilegios root:
<code>
sudo apt-get install wireshark
</code>
\\
=== Carga del módulo "usbmon" ===
\\
Para poder ver el tráfico de los diferentes dispositivos USB, se necesita cargar el módulo "usbmon" desde una terminal.Los kernel Linux 2.6.21 y versiones superiores lo incluyen, de lo contrario, no se puede hacer este tipo de sniffing desde Wireshark. Por ello, para cargarlo(privilegios root):
<code>
sudo modprobe usbmon
</code>
\\
=== Utilizando el comando ¨lsusb¨ ===
\\
Para poder realizar un correcto sniffing, desde la terminal utilizamos el comando:
<code>
fabian@fabian-Satellite-L505:~$ lsusb
Bus 002 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
Bus 008 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
Bus 007 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
Bus 006 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
Bus 005 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
Bus 001 Device 002: ID 064e:d104 Suyin Corp. 
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
Bus 004 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
Bus 003 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
</code>
Se desplegará una información parecida a la que se ve en el cuadro de código anterior, en la información desplegada, se deberá prestar atención al número de ¨Bus 00X¨ mostrado. El número que corresponda a esa ¨X¨, será el que utilizaremos para poder empezar el sniffing en Wireshark. Por ello, si queremos sniffear a la tarjeta ATI, deberemos seguir el siguiente proceso:
\\
 1- Mediante ¨lsusb¨, buscar en cuál Bus 00X se recibe al dispositivo al conectarlo al puerto USB.\\
 2- Luego de haber reconocido el Bus 00X, retirar el dispositivo del puerto.\\
 3- Cargar el módulo ¨usbmon¨ en una terminal.\\
 4- En otra terminal, iniciar Wireshark con privilegios root, esto con el siguiente comando:
<code>
sudo wireshark
</code>
 5- Iniciar la máquina virtual con Windows, además, de tener el driver de la tarjeta ATI instalado.\\
 6- En Wireshark, buscar que despliegue una información semejante a la siguiente imagen:
\\
{{:ie0117_proyectos_ii_2014:proyecto_1:wiresharkusbmon.png|}}
\\
\\
 7- Se puede notar que salen interfaces llamadas ¨usbmonX¨. Donde X representa también el número del ¨Bus 00X¨ de los pasos 1 y 2. Por lo tanto, elegimos usbmonX e iniciamos el sniffing.\\
 8- Notaremos que aparecerán solo unos cuantos datos en los primeros microsegundos.\\
 9- Si ingresamos la tarjeta ATI a los 20 segundos, aparecerán datos de control en ese tiempo en Wireshark, si a los 30 segundos, montamos el dispositivo en la máquina virtual, notaremos que en ese tiempo habrán más datos de control, por lo que esos serían los datos que nos interesan para interceptar el protocolo que utiliza la tarjeta.
\\
\\
Con esto, finalizamos el proceso de adquirir los datos del protocolo de los dispositivos en cuestión.
\\
\\
==== Instalación de los paquetes necesarios para el funcionamiento del EasyCap ====
\\
La idea principal del proyecto es intentar correr el dispositivo ATI en Linux, con base en un driver de prueba llamado ¨usbtv007¨, el cuál está principalmente basado en el protocolo utilizado por el EasyCap. EasyCap es un dispositivo USB para funcionar como un ¨puente input¨ de audio y video.
\\
{{:ie0117_proyectos_ii_2014:proyecto_1:easycap2.jpg?300|}}
\\
\\
=== Instalación de Video For Linux 2 ===
\\
Instalamos **aptitude** y **module-assistant**, además compilamos **module-assistant** y actualizamos los repositorios del sistema(siempre con privilegios root):
<code>
sudo apt-get install aptitude
sudo aptitude update
sudo apt-get install module-assistant
sudo m-a prepare
sudo m-a update
</code>
\\
Instalamos las dependencias de **v4l2loopback**, el cuál es un módulo que eventualmente se cargará en el kernel para hacer uso del driver usbtv007, pero primero, instalamos dependencias:
<code>
sudo aptitude install linux-headers-$(uname -r) module assistant
sudo aptitude install v4l2loopback-source
</code>
Preparamos el módulo **v4l2loopback** y lo cargamos con el comando **modprobe**:
<code>
sudo m-a a-i v4l2loopback-source
sudo modprobe v4l2loopback
</code>
Para verificar que se cargó correctamente utilizamos:
<code>
lsmod | grep v4l2loopback
</code>
Debería encontrarse una información semejante a la siguiente:
<code>
v4l2loopback           28896  0 
videodev              108503  5 usbtv,uvcvideo,v4l2loopback,v4l2_common,videobuf2_core
</code>
\\
Algunos kernel cargan una versión de un módulo llamado **usbtv**, por ello, para ver si se encuentra cargado ingresamos:
<code>
lsmod | grep usbtv
</code>
Si sale alguna información con respecto a **usbtv** , procedemos a removerlo con ''rmmod'' y debemos mandarlo a una lista negra, para que no vuelva a ser cargado, para ello modificaremos un archivo //blacklist//, para que de esa manera, en sesiones futuras, no vuelva a aparecer. Ingresamos(con privilegios root): 
<code>
sudo rmmod usbtv
sudo echo "blacklist usbtv" >> /etc/modprobe.d/blacklist
</code>
\\
Ahora, para verificar el nodo en donde el EasyCap estaría siendo añadido, utilizaremos el siguiente comando, por lo que para en este momento, antes de insertar el EasyCap, utilizamos el comando y después se conecta el EasyCap y se vuelve a utilizar comando para ver cómo varían los nodos, entonces:
<code>
ls /dev/video*
</code>
Aquí se concluye la carga de módulos, o bien, el retiro de ellos. Además, para que **v4l2loopback** se cargue automáticamente cada vez que se inicie sesión y que el **usbtv** NO se cargue, debemos reiniciar el sistema, para hacer efectivos los cambios y que además, sean permanentes. Entonces:
<code>
sudo reboot
</code>
\\
==== Configurando el ¨usbtv007" para el EasyCap ===
\\
Instalamos las dependencias(siempre con privilegios root):
<code>
sudo git clone git://github.com/vpelletier/python-libusb1.git

#Ahora ingresamos al directorio ¨python-libusb1¨ 

cd python-libusb1/
sudo python setup.py install
sudo apt-get install python-setuptools
sudo easy_install v4l2
sudo apt-get install python-numpy
sudo apt-get install python-imaging
</code>
Descargamos el **¨Userspace test driver for the easycap usbtv007 (utv007) video capture adapters¨** para el EasyCap que se encuentra disponible en https://github.com/memeruiz/usbtv007 :
<code>
sudo git clone git://github.com/memeruiz/usbtv007.git
</code>
Hasta el momento, se han instalado unas dependencias para poder correr el programa del **¨Userspace test driver for the easycap usbtv007 (utv007) video capture adapters¨** que está en el lenguaje **python**. Este programa es de prueba y se realizó para hacer pruebas con otros dispositivos con funciones semejantes al EasyCap, basado completamente en cómo funcionan los protocolos USB. 
\\
Ahora, se procede a correr el **¨Userspace test driver for the easycap usbtv007 (utv007) video capture adapters¨** que se encuentra en el directorio de **usbtv007**
<code>
cd usbtv007/
sudo ./utv007_driver.py -d /dev/video0
</code>
Ejemplo del programa corriendo:
\\
{{ :ie0117_proyectos_ii_2014:proyecto_1:screenshot_from_2014-12-11_13_11_23.png?300 |}}
\\
En este momento, el programa está corriendo y hay varias maneras de poder darle un output a la transmisión del EasyCap, pero se mostrará utilizando **mplayer**, para ello, se instala y luego se utiliza un comando para darle salida a la imagen:
<code>
sudo apt-get install mplayer
sudo mplayer tv:// -tv device=/dev/video0
</code>
\\
==== Protocolo USB ====
Para entender un poco:\\
Una computadora se pone "en estado de alerta" en el momento que recibe un dispositivo USB. El host(computadora) siempre inicializa la comunicación con el dispositivo brindándole un address y un endpoint que por defecto, ambos son 0.  Tipicamente, luego de asignar un address default. Empieza a trabajar con un comando  de ¨get device descriptors¨ para asignar un address específico y así conocer a detalle con qué tipo de dispositivo empezará a tratar.\\
Para ser más específicos, el host hará tres tipos de estudios:\\

   - Get Device Descriptor\\
   - Get Configuration Descriptor\\
   - Get String Descriptor\\
En el momento que que ya el dispositivo está correctamente direccionado(Addressed). Llamará a un driver en específico, para que puedan interactuar de la manera más correcta y empezar a conocer las interfaces, con cada respectivo endpoint. \\
Cada interfaz representa una función distinta, por lo que cada interfaz tiene un endpoint distinto. Y estos son las zonas donde se comunica cada función específica del dispositivo USB con el ordenador.\\
** Token Packets **\\
Los token packets son los paquetes necesarios para poder identificar e iniciar un control sobre el dispositivo.Entiéndase por asignar un address e iniciar búsqueda de interfaces.
\\
** Data Packets **
\\
Son los datos que transmite un dispotivo USB, lo que también se conoce como ** payload **. \\
** Handshake Packets ** \\
Los paquetes de este tipo son aquellos necesarios para combrobar, cada cierto tiempo, la interacción entre el host y el dispositivo USB. Se asegura de que no hayan errores, o si los hay, se encargan de corregirlos.
\\
** Start of Frame Packets ** \\
Son los paquetes encargados de señalar los inicios de cada pila de paquetes.
\\
=== Tipos de packets ===
\\
** Sync packets ** \\
Se encargan de sincronizar los tiempos en el host y dispositivo USB.\\
** PID ** \\
Se encargan de identificar el tipo de paquete, si son in, out. Etc. \\
** ADDR ** \\
Son los paquetes de la dirección del dispositivo USB. \\
** ENDP ** \\
Son las direcciones de las interfaces. \\
** CRC ** \\
Cyclic Redundancy Checks, los que verifican el status de transmisión. Correcta o incorrecta. \\
** EOP **\\
Son los paquetes que señalan su final\\

\\
Para ubicarse un poco en el **protocol.py** del EasyCap. Si se observan las lineas 145,146,147:
<code>
['crvd', 0x02, 0x00a0, 0x00f0, '', 2, (0x01, 0xdb), (True, False)], #0x15 0x9b 0xdb 0xd9
['crvd', 0x07, 0x00a0, 0x0015, '', 2, (0x00, 0x31)],
['crvd', 0x07, 0x00a2, 0x0000, '', 33, (0x00, 0x66, 0x01, 0x01, 0x68, 0x14, 0x14, 0x1f, 0x1f, 0x02, 0x40, 0x09, 0x04, 0x0d, 0x00, 0x00, 0x00, 0x71, 0x1b, 0x01, 0x30, 0x10, 0x31, 0x30, 0x6d, 0x6f, 0x6f, 0x6e, 0x73, 0x00, 0x00, 0x00, 0x00), [False]*33],
</code>
Este codigo representa transferencias de Control-in,dado por "crvd" (c= control, r=read, vd=video). Utilizando Wireshark, los datos que vienen a representar son(se utiliza una imagen para mayor ubicacion visual):\\
{{:ie0117_proyectos_ii_2014:proyecto_2:screenshot_wiki_se_alado_.png?300|}} {{:ie0117_proyectos_ii_2014:proyecto_2:control_read_ll.png?300|}}\\
Para relacionar las imagenes con el codigo, se puede interpretar como :
<code>
['crvd', Control-transfer endpoint, wValue, wIndex, '', wLength, (0x01, 0xdb), (True, False)]
</code>
Y de manera analoga se aplica este tipo de datos para el "cwvd", que seria el Control transfer-out, utilizando los mismos parametros. Ahora se necesita aplicar este mismo metodo para hacer el estudio del protocolo de la tarjeta ATI, debido a la falta de tiempo, no se pudo concluir dicho estudio
\\

\\
==== Modificación del usbtv007 ====
\\
Debido a la falta de tiempo para el proyecto, no se pudieron realizar las modificaciones necesarias para darle el soporte a la ATI TV Wonder HD 750. Explicando un poco mejor:
\\
1 - El protocolo utilizado para el EasyCap,no trabaja con con transferencias del tipo Bulk, por lo que dificulta la modificación del userspace driver para la tarjeta ATI, pues ésta última sí utiliza transferencias del tipo Bulk.
\\
2 - Se intentó buscar información desde http://www.libusb.org/ , sin encontrar ayuda inmediata para este tipo de transferencias Bulk.

==== Referencias: ====
\\ 
=== Información general para ingeniería inversa: ===
\\
https://www.mattcutts.com/blog/reverse-engineering-a-windows-usb-driver/ \\
http://catarina.udlap.mx/u_dl_a/tales/documentos/lis/lopez_a_aa/capitulo4.pdf \\
http://www.slideshare.net/moimedinaq/ingeniera-inversa-y-reingeniera-de-software \\
https://docs.google.com/document/d/1VcOrZpqAbeA-yRxWx2-21XBiPL-RBZEw19sBSLqMJag/edit?copiedFromTrash#heading=h.9eb473g2gyc
\\
=== Información general para protocolos de transferencia de datos usb: ===
\\
http://wiki.wireshark.org/CaptureSetup/USB \\
http://desowin.org/usbpcap/ \\
http://web.fi.uba.ar/~pmartos/publicaciones/trabajousb.pdf \\
http://server-die.alc.upv.es/asignaturas/lsed/2003-04/0.USB/lsed/final.pdf \\
http://www.ftdichip.com/Support/Documents/TechnicalNotes/TN_116_USB%20Data%20Structure.pdf \\
http://www.beyondlogic.org/usbnutshell/usb6.shtml
\\
=== Información de drivers EasyCap: ===
\\
http://linuxtv.org/wiki/index.php/Easycap
https://github.com/memeruiz/usbtv007