Controlador I2C de Linux en la plataforma Zynq (RTC EEPROM)

En la actualidad, la descripción de hardware de la placa de desarrollo SoC bajo brazo adopta el archivo devicetree. Después de que DTS se compila en DTB mediante el programa DTC proporcionado por Linux, el DTB se importa al kernel de Linux mediante u-boot. El kernel de Linux lee el DTB y luego registra el recurso del dispositivo. El kernel de Linux usa _ La API de función serie lee recursos de hardware. Las instrucciones específicas se pueden ver de la siguiente manera:. El archivo DTS se compila para generar. Archivo DTB según la configuración de hardware específica.

Luego debe seleccionar el controlador para el hardware en la configuración del kernel menuconfig. La función de sonda del controlador se puede activar solo cuando el controlador de hardware coincide con el nombre del hardware en DTS

Los controladores de rtc-8564 y PCF8563 son compatibles, ambos controladores PCF8563.

Nota: el siguiente análisis se basa en el kernel de Linux 3.12.0. El análisis personal inevitablemente tiene errores, por favor corrige.

Estructura i2c _ adaptador

Propietario del módulo struct *;

Clase int sin firmar; /* clases para permitir el sondeo para */

Construir i2c _ algoritmo * algo; /* el algoritmo para acceder al bus */

* Vacío algo_data;

/* Campos de datos que son válidos para todos los dispositivos */

Estructura rt_mutex bus_lock;

Int TImeout; /* en santiamenes */

Int reintentos;

Dispositivo de estructura dev; /* el dispositivo adaptador */

Int nr;

Nombre char [48];

Estructura compleTIon dev_released;

Estructura mutex userspace_clients_lock;

Estructura list_head userspace_clients;

Estructura i2c_bus_recovery_info * bus_recovery_info;

;

Los datos del controlador de bus I2C están conectados a los datos de algo _, como xi2cps, S3C24XX _ i2c

Struct device dev; El miembro indica I2C _ El adaptador es un hardware que corresponde al controlador I2C en SOC. Y el algoritmo I2C _ es el controlador subyacente del controlador I2C.

Del mismo modo:

Struct i2c _ cliente

Banderas cortas sin firmar; /* div., ver más abajo */

Addr corto sin firmar; /* dirección chip-NOTA: 7bit */

/* Las direcciones se almacenan en el */

/* _ BAJO _ 7 bits */

Nombre char [I2C _ NAME_SIZE];

Adaptador de estructura i2c _ * adaptador; /* el adaptador que tenemos */

Struct i2c _ driver * driver; /* y nuestro acceso rouTInes */

Dispositivo de estructura dev; /* la estructura del dispositivo */

Int irq; /* irq emitido por el dispositivo */

Struct list_head detectado;

;

Struct i2c _ Client representa un dispositivo esclavo I2C montado en el bus I2C. La estructura de datos requerida por el dispositivo incluye

El dispositivo maestro I2C estructura I2C al que está conectado el dispositivo esclavo I2C _ adaptador * adaptador

El controlador de dispositivo esclavo I2C struct I2C _ driver * driver

Como una variable miembro comúnmente utilizada por los dispositivos esclavos I2C, como addr, nombre, etc

Los datos únicos del controlador del dispositivo esclavo I2C se adjuntan a dev- > Driver _ Data, en I2C _ Establezca este miembro struct en la función de sonda en el controlador. Por ejemplo, EEPROM de EEPROM _ data

Lista vinculada bidireccional compuesta por todos los dispositivos esclavos I2C: detectado

El dispositivo de estructura dev indica struct I2C _ El cliente representa un hardware, como el chip EEPROM o el chip RTC, que está conectado a I2C a través del hardware del adaptador de bus I2C.

Y I2C _ Driver es este controlador de hardware de chip I2C _ Client.

Por lo general, definimos una estructura de información privada para cada dispositivo de caracteres I2C, e I2C _ El cliente generalmente está contenido en esta estructura de información privada. Los piratas informáticos que han visto el código fuente ldr3 deberían ser más claros.

I2c _ Cliente conectado a I2C _ Adaptador, es decir, la relación correspondiente entre el dispositivo I2C y el controlador de bus I2C, un I2C _ El adaptador puede adjuntar múltiples I2C _ clienti2c _ Lista estructurada de adaptador _ espacio de usuario del cabezal _ clientes; Los miembros de la estructura son listas vinculadas de todos los clientes.

La última versión de Linux básicamente admite todo el hardware adaptador I2C actual y los dispositivos esclavos I2C, pero los ingenieros pueden enfrentar varias situaciones: I2C _ Adapter e I2C _ Client escribe el controlador.

El código fuente central de I2C se encuentra en el núcleo de controladores/I2C/I2C. C. No depende de la función de interfaz de la plataforma de hardware. Es el enlace entre el conductor del autobús I2C y el controlador del dispositivo.

Añadir/quitar adaptador I2C _

Int i2c _ add _ adaptador (struct i2c _ adaptador *)

// Llamada I2C _ registro _ adaptador ()

Adaptador int i2c _ del _ (adaptador * struct i2c _ adaptador)

Agregar/eliminar I2C _ controlador

Int i2c _ registro _ conductor (estructura módulo * propietario estructura i2c_driver * conductor)

Int i2c _ añadir _ conductor (estructura i2c_driver * conductor)

// Llame I2C _ registre _ driver

Vacío i2c _ del _ conductor (estructura i2c_driver * conductor)

Agregar/eliminar I2C _ cliente

Estructura i2c _ cliente * i2c _ nuevo _ dispositivo (estructura i2c_adapter * adap de estructura i2c_board_info const * información)

Vacío i2c _ de anular el registro de _ dispositivo (estructura i2c_client * cliente)

Nota: I2C se utilizó antes de la función de la versión 2.6.30 _ adjuntar _ Cliente () e I2C _ separe _ Cliente (). Luego, el adjuntar se fusiona con I2C _ new _ Device, y el desprendimiento se reemplaza directamente por el desregistro. De hecho, ambas funciones llaman internamente al dispositivo _ Register () y al dispositivo _ unregistre ()

I2C transmisión, transmisión y recepción

Int i2c _ la transferencia (estructura i2c_adapter * adap de estructura i2c_msg * mensajes int num)

Int i2c _ maestro _ enviar (estructura i2c_client * cliente const char * pero int cuenta)

Int i2c _ maestro _ recv (estructura i2c_client * cliente char * pero int cuenta)

I2c _ La función de transferencia () se utiliza para intercambiar un conjunto de mensajes entre el adaptador I2C y el dispositivo I2C _ master _ Send() function y I2C _ master _ I2C se llama internamente en la función recv() _ La transferencia () la función completa un mensaje de escritura y un mensaje de lectura respectivamente.

I2c _ Transfer () en sí mismo no puede completar la interacción del mensaje con el hardware. Busca I2C _ I2C correspondiente al adaptador _ Algoritmo, para realizar la transmisión de datos, I2C debe realizarse _ Maestro de algoritmo _ Xfer(), que está relacionado con el hardware específico, es completado por el fabricante la mayor parte del tiempo.

I2c _ Transfer() llamando a _ i2c _ Transfer() completa la comunicación I2C:

Int _ i2c _ la transferencia (estructura i2c_adapter * adap de estructura i2c_msg * mensajes int num)

Orig_jiffies largos sin firmar;

Int ret trata;

/* Reintentar automaTIcally sobre la pérdida de arbitraje */

Orig_jiffies = santiamenes;

Para (ret = 0, try = 0; intente reintentos; intente)

Ret = adap- >Algo- >Master_xfer (adap... mensajes... num);

Si (¡ret! = -EAGAIN)

Romper;

Si (time_after (santiamenes y orig_jiffies adap- >Tiempo de espera)

Romper;

Retorno ret;

Se puede ver que los reintentos son el número de intentos de retransmisión y el tiempo de espera es el tiempo de espera.

1. Carga y descarga del adaptador I2C

Carga: solicite recursos de hardware, como dirección IO, número de interrupción y llame al adaptador de carga I2C _ add _

I2c _ add _ I2C se llama en el adaptador _ register _ Función del adaptador

Estática int i2c _ registro _ (adaptador estructura i2c_adapter * adap)

... ...

Device_register ( &Adap- >Dev);

// Complete el registro del adaptador del dispositivo maestro I2C, es decir, registre el objeto y envíe uevent

I2c_scan_static_board_info (adap);

// Registro i2c _ client

... ...

Estática vacío i2c _ escanear _ estática _ de _ información (estructura i2c_adapter * adaptador)

Estructura i2c_devinfo * devinfo;

Down_read ( &_ I2c _ board_lock);

List_for_each_entry (devinfo &_ I2c _ board_list, lista)

Si (devinfo- >Busnum = adaptador- >Nr

&& ! I2c _ new _ device (adaptador,

& Devinfo- >Board_info)

Dev_err ( &Adaptador- >Dev

"No se puede crear el dispositivo a 0x x

",

Devinfo- >Board_info.addr);

Up_read ( &_ I2c _ board_lock);

I2c _ nuevo _ Dispositivo de llamadas de dispositivos _ Registrar registros de dispositivos esclavos I2C.

Entonces, ¿cuándo y cómo se estableció la lista de enlaces circulares bidireccionales compuesta por dispositivos esclavos I2C?

Toma/arco/brazo/Mach PXA / Saar. C como ejemplo

Vacío estático _ init saar _ init (vacío)

... ...

Saar_init _ i2c();

........

Vacío estático _ init saar _ init _ i2c (vacío)

Pxa_set_i2c_info (NULL);

I2c _ register_board_info(0, ARRAY_AND_SIZE(saar _ i2c _ info);

Estática estructura i2c _ de _ información saar _ i2c _ información [] =

[0] =

... Tipo = "da9034"

... Dirección = 0x34

... Platform_data = & Saar _ da9034 _ info,

... Irq = PXA_GPIO_TO_IRQ(mfp_to_gpio(MFP_PIN_GPIO83)

,

;

/* Controladores/i2c/i2c-boardinfo.c */

Int _ init i2c _ registro _ de _ información (int busnum... structi2c_board_info const * información sin firmar len)

... ...

Estructura i2c_devinfo * devinfo;

Devinfo- >Board_info = * información;

List_add_tail ( & DEVINFO - > Lista, &_ I2c _ board_list); /agregar dispositivo esclavo I2C a la lista vinculada

... ...

Por lo tanto, en el proceso de inicialización del sistema, podemos usar I2C _ registre _ board _ Info, agregar el dispositivo esclavo I2C requerido a un dispositivo llamado _ i2c _ board _ Lista de lista de enlaces circulares bidireccionales. Después de cargar con éxito el dispositivo maestro I2C adaptarse, el sistema completará I2C para todos los dispositivos esclavos I2C en esta lista vinculada uno por uno _ Registro del cliente.

Es decir, I2C _ Client e I2C _ Todos los adaptadores están fabricados por I2C _ Core para mantener.

En Xilinx Linux, el dispositivo esclavo I2C se pasa al kernel a través de archivos DTS, y el kernel se pasa a través de zynq _ init _ La función de la máquina registra todos los dispositivos esclavos I2C, I2C _ cliente.

En el sistema de gestión de dispositivos y controladores de Linux, todos los dispositivos que no se pueden intercambiar en caliente están incluidos de forma predeterminada _ El miembro de la función de la máquina se agrega a la lista bidireccional vinculada del equipo de mantenimiento correspondiente, incluida la plataforma _ Dispositivo y otros dispositivos. Cuando un dispositivo específico se conduce a través del conductor _ Cuando se agrega el registro al bus correspondiente, regresa para atravesar la lista bidireccional vinculada de dispositivos debajo del bus correspondiente. Cuando el controlador coincide con el dispositivo, se activará la función de sonda del controlador.

DT _ MÁQUINA _ INICIO (XILINX _ EP107, "Plataforma Xilinx Zynq")

... Smp = smp _ de operaciones (zynq_smp_ops)

... Mapa _ io = zynq _ mapa _ io,

... Init _ irq = zynq _ irq _ init...

... Init _ de la máquina = zynq _ init _ de

... Init _ tarde = zynq _ init _ tarde

... Init _ tiempo = zynq _ temporizador _ init...

... Dt _ compat = zynq _ dt _ de

... Reserva = zynq _ memoria _ init,

... Reinicio = zynq _ sistema _ reset,

MACHINE_ END

Puede consultar el código de inicialización de la junta de Mach zynq

Desmontar: liberar recursos de hardware y llamar al adaptador I2C _ del _ desinstalar el adaptador I2C

Vacío i2c _ del _ (adaptador estructura i2c_adapter * adap)

..........

List_for_each_entry_safe (cliente, siguiente, &Adap- >Userspace_clients,

Detectado)

Dev_dbg ( &Adap- >Dev, "Eliminar % s a 0x % x

", Cliente- >Nombre,

Cliente- >Dirección);

List_del ( &Cliente- >Detectado);

I2c _ unregister _ device (cliente);

Desinstalar todos los dispositivos I2C esclavos

..............

Device_unregister ( &Adap- >Dev);

Desinstalar el adaptador I2C

..............

2. Escriba el algoritmo del método de comunicación de bus I2C

Int (* master_xfer)(estructura i2c_adapter * adap de estructura i2c_msg * mensajes de

Int num);

/* Para determinar qué es compatible con el adaptador */

U32 (* funcionalidad) (struct i2c _ adapter *);

Implementa principalmente las dos funciones anteriores.

La mayoría de las veces, necesitamos definir una estructura XXX _ I2C, como struct S3C24XX en controladores/I2C/buses/i2c-s3c2410. C _ i2c

XXX _ The I2C estructura contiene estructura I2C _ msg * msg; estructura i2c _ adaptador adap; vacío _ iomem * las reglas; etc

Struct i2c _ MSG * MSG recibe datos de la capa de usuario, los envía al bus I2C o lee datos del bus I2C a la capa de usuario.

En la función de sonda del adaptador:

Estructura xi2cps * id;

Plataforma de _ drvdata(pdev id);

Id- >Adap.de v. de _ nodo = pdev- >Dev. de _ nodo;

Id- >Adap? algo = (estructura i2c_algorithm *) &Xi2cps _ algo;

Id- >Rap. timeout = 0x1F;

/* Valor de tiempo de espera predeterminado */

Id- >Pap. reintentos = 3;

/* Valor de reintento por defecto. */

Id- >Ads.algo _ data = id;

Id- >Adap.de v padres = &Pdev- >Dev;

En términos de hardware, el dispositivo principal I2C se ha integrado en el chip principal. En términos de software, Linux también nos proporciona los controladores correspondientes, ubicados en