I2c drivers in linux

Пишем модуль ядра Linux: I2C

Данная статья посвящена разработке I2C (Inter-Integrated Circuit) модуля ядра Linux. Далее описан процесс реализация базовой структуры I2C драйвера, в которую можно легко добавить реализацию необходимого функционала.

Опишем входные данные: I2C блок для нового процессора «зашитый» на ПЛИС, запущенный Linux версии 3.18.19 и периферийные устройства (EEPROM AT24C64 и BME280).

Принцип работы I2C достаточно прост, но если нужно освежить знания, то можно почитать тут.

Рисунок 1. Временная диаграмма сигналов шины I2C

Перед тем как начать разрабатывать драйвер посмотрим как user space приложения взаимодействуют с модулем ядра, для этого:

1. Реализуем небольшое user space приложение, цель которого прочитать уникальный ID регистра I2C устройства. Данный шаг позволит понять интерфей, через который происходит обмен между модулем ядра и пользовательским приложением;
2. Познакомимся с вариантом передачи I2C сообщений модулем ядра;
3. Добавим модуль ядра в сборку и опишем аппаратную часть устройств в device tree;
4. Реализуем общую структуру (скелет) I2C драйвера с небольшими пояснениями.

К сожалению, прикрепить реальные исходники разработанного драйвера не представляется возможным. Также, хочу заметить, все имена, названия и регистровая карта контроллера изменены. В скелет драйвера ни вошло и половины разработанного функционала, тем не менее, структура драйвера является хорошей отправной точкой при разработке. Примеры I2C драйверов можно посмотреть тут.

Шаг первый

Для начала познакомимся с утилитой i2cdetect. Результат работы i2cdetect выглядит следующим образом:

Утилита последовательно выставляет на I2C шину адреса устройств и при получении положительного ответа (в данном случае положительным ответом является ACK) выводит в консоль номер адреса устройства на шине.

Напишем небольшую программку, которая считывает уникальный ID датчика температуры, и выведем результат ее работы в консоль. Выглядит очень просто:

Становятся понятно что модуль ядра принимает данные в виде полей сообщения i2c_rdwr_ioctl_data. Структура содержит такие поля как i2c_msg и nmsgs, которые используется для передачи:

• .addr — адреса устройства;
• .flags — типа операции (чтение или запись);
• .len — длины текущего сообщения;
• .buf- буфера обмена.

Шаг второй

Теперь, не углубляюсь во внутренности, познакомимся с одним вариантом работы I2C драйвера.
Как уже было установлено, модуль ядра получает сообщения в виде структуры. Для примера рассмотрим алгоритм работы драйвера при выполнении операции записи (аппаратно-зависимая часть):

• Сначала заполняется TX FIFO: первым идет адрес устройства, а после оставшиеся данные на передачу;
• Очищается статусный регистр прерывания ISR и разрешаются прерывания в регистре IER (в данном случае прерывание возникающее при отсутствии данных в TX FIFO);
• Разрешается передача данных и устанавливается старт бит на шине.

Весь последующей обмен данными будет происходить в обработчике прерывания.
Драйвера, которые работают по данному алгоритму, можно найти тут. Также у контроллера может не быть FIFO, а только единственный регистр на передачу, но это частный случай с размером FIFO равным одному.

Шаг третий

Добавим модуль ядра в сборку и опишем аппаратную часть устройств в device tree:

1. Создадим source файл в следующей директории:

В результате появится файл:

2. Добавим конфигурацию драйвера в drivers/i2c/busses/Kconfig:

3. Добавим в сборку драйвер drivers/i2c/busses/Makefile:

4. Добавим в devicetree (*.dts) описание I2C блока, а также сразу поддержу eeprom устройства:

Подробно рассматриваться выше перечисленные шаги не будут, но любопытным читателям можно заглянуть сюда.

Шаг четвертый

После ознакомления с принципом работы драйвера приступим к реализации.
Сначала подключим заголовочные файлы, опишем «виртуальную» регистровую карту, а также представление драйвера I2C.

Главными управляющими регистрами контроллера являются:

• Control Register (CTRL) — регистр управления;
• Interrupt Status Register (ISR) — статусный регистр прерывания;
• Interrupt Enable Register (IER) — регистр маски прерывания.

Сердцем драйвера является структура skel_i2c, которая содержит такие поля как:

• .base — указатель на начало регистровой карты;
• .msg — указатель на текущее сообщение;
• .adap — I2C абстракция (клик).

Перейдем к более практической части, опишем типы поддерживаемых драйвером устройств,
функционал I2C адаптера и интерфейс передачи I2C сообщений:

Из названий структур и функций очевидно их назначение, опишем только главную структуру из представленных выше:

• skel_i2c_driver — описывает имя драйвера, таблицу поддерживаемых устройств и функций, которые вызываются в момент загрузки или удаления модуля ядра из системы.

Пора зарегистрировать драйвер в системе, а значит реализовать функцию инициализации контроллера, а также описать skel_i2c_probe (вызывается в момент загрузки драйвера в систему) и skel_i2c_remove (вызывается в момент удаления драйвера из системы).

Наиболее простой функцией является skel_i2c_remove, которая отключает источник тактовой частоты и освобождает используемую память. Функция skel_i2c_init выполняет первичную инициализацию I2C контроллера.

Как упоминалось ранее skel_i2c_probe регистрирует драйвер в системе. Последовательность действий, условно, можно разделить на два этапа:

• Получение системных ресурсов и регистрацию обработчика прерывания skel_i2c_isr;
• Заполнение полей структуры и вызов процедуры добавления нового I2C адаптера.

После того как драйвер зарегистрирован в системе, можно реализовать логику передачи сообщений по интерфейсу:

В первом шаге было описано взаимодействие user space приложения с модулем ядра системы. После того как мы реализовали внутренности драйвера легко увидеть интерфейс, через который происходит обмен. В общем случае передача сообщений происходит следующем образом:

• skel_i2c_xfer — функция напрямую получает сообщения на передачу и последовательно передает каждое сообщение в skel_i2c_xfer_msg. Если во время передачи данных произошла ошибка, то передача данных останавливается;
• skel_i2c_xfer_msg — функция устанавливает все необходимые поля драйвера и инициирует начало передачи сообщений;
• skel_i2c_isr — процедура обработки прерывания. Здесь происходит обработка ошибок, а также обмен данными по шине. Если все данные отправлены/приняты устанавливается флаг done с помощью вызова функции complete, которая сигнализирует о завершении передачи сообщения.

В статье не описаны некоторые тонкости работы. Например, последовательность действий передачи сообщений, так как реализация данного алгоритма является аппаратно зависимой. Мы же сосредоточились на реализации общей части драйвера вне зависимости от аппаратных особенностей контроллера.

Полный скелет драйвера прикреплен ниже. Пожалуйста, если вы нашли ошибки/неточности, или вам есть что добавить — напишите в ЛС или в комментарии.

Источник

I2C драйвер в Linux

С I2C в Linux вполне можно работать из пространства пользователя. Тем не менее это не очень удобно. Весьма удобнее и правильнее сделать модуль ядра.

Для создания драйвера в ядре Linux предусмотрены вспомогательные макросы. Если Вам не нужно ничего выполнять при инициализации модуля, можно воспользоваться макросом module_i2c_driver.

В качестве параметра ему передается структура i2c_driver, в которой указывается имя устройства и указатели на функции probe, remove.

Макрос module_driver в свою очередь определен так:

Как видно, в нем определены функции инициализации и деинициализации модуля ядра. Из которых вызываются функции i2c_register_driver(THIS_MODULE, driver) (она же макрос i2c_add_driver(driver)) и i2c_del_driver(struct i2c_driver *) соответственно.
Что использовать решать Вам, я воспользуюсь макросом module_i2c_driver. Как мы помним у меня в качестве подопытного часы ds1307. В Linux уже есть драйвер для них, но мы же не ищем легких путей!?

Параметром макросу передаем структуру:

Указываем имя драйвера, функцию probe и remove, таблицу идентификаторов поддерживаемых устройсв.

Имя устройства используется при поиске подходящего драйвера, второй элемент структуры — параметр, который можно потом достать из этой таблицы при необходимости.
При успешном поиске драйвера вызывается его функция probe. В ней Вы должно проинициализировать устройство или же вычитать его конфиг и дать команду начала работы с ним (запустить поток или еще чего). Мы такого делать не будем, вычитаем данные из часов и выведем их в лог.

Для работы с шиной I2C в ядре предусмотрены функции:

Следует отметить что count должен быть менее 64К, т.к. в структуре сообщения i2c в недрах ядра длина 16 битная.
Для хранения данных я сделал такую структуру:

В функции probe выделяем память для данных, которые будем читать из устройства. Конечно же выводим сообщение в лог ядра. Шлем ноль из wr_buf, чтобы установить указатель записи/чтения в часах. И читаем в выделенную при помощи kmalloc память данные по i2c шине. Если функция вернула число меньше 0 значит что-то пошло не так, в случае успеха будет возвращено количество отправленных байт.
Если считали успешно, выводим в лог при помощи функции print_hex_dump.

Очень удобная функция. Параметры:

• level — уровень сообщения, аналогично printk.
• prefix_str — строка, которая будет выведена перед буфером.
• prefix_type — флаг вывода префикса смещения — DUMP_PREFIX_OFFSET, адреса — DUMP_PREFIX_ADDRESS, вывода без префикса — DUMP_PREFIX_NONE.
• rowsize — количество символов выводимых в строку.
• groupsize — вывод по 1,2,4,8 байт.
• buf — данные для вывода.
• len — количество байт в буфере.
• ascii — выводить данные в виде строки ascii после дампа данных.

Теперь скормите новое устройство ядру.
Overlay для устройсва:

Источник

Implementing I2C device drivers¶

This is a small guide for those who want to write kernel drivers for I2C or SMBus devices, using Linux as the protocol host/master (not slave).

To set up a driver, you need to do several things. Some are optional, and some things can be done slightly or completely different. Use this as a guide, not as a rule book!

General remarks¶

Try to keep the kernel namespace as clean as possible. The best way to do this is to use a unique prefix for all global symbols. This is especially important for exported symbols, but it is a good idea to do it for non-exported symbols too. We will use the prefix foo_ in this tutorial.

The driver structure¶

Usually, you will implement a single driver structure, and instantiate all clients from it. Remember, a driver structure contains general access routines, and should be zero-initialized except for fields with data you provide. A client structure holds device-specific information like the driver model device node, and its I2C address.

The name field is the driver name, and must not contain spaces. It should match the module name (if the driver can be compiled as a module), although you can use MODULE_ALIAS (passing “foo” in this example) to add another name for the module. If the driver name doesn’t match the module name, the module won’t be automatically loaded (hotplug/coldplug).

All other fields are for call-back functions which will be explained below.

Extra client data¶

Each client structure has a special data field that can point to any structure at all. You should use this to keep device-specific data.

Note that starting with kernel 2.6.34, you don’t have to set the data field to NULL in remove() or if probe() failed anymore. The i2c-core does this automatically on these occasions. Those are also the only times the core will touch this field.

Accessing the client¶

Let’s say we have a valid client structure. At some time, we will need to gather information from the client, or write new information to the client.

I have found it useful to define foo_read and foo_write functions for this. For some cases, it will be easier to call the I2C functions directly, but many chips have some kind of register-value idea that can easily be encapsulated.

The below functions are simple examples, and should not be copied literally:

Probing and attaching¶

The Linux I2C stack was originally written to support access to hardware monitoring chips on PC motherboards, and thus used to embed some assumptions that were more appropriate to SMBus (and PCs) than to I2C. One of these assumptions was that most adapters and devices drivers support the SMBUS_QUICK protocol to probe device presence. Another was that devices and their drivers can be sufficiently configured using only such probe primitives.

As Linux and its I2C stack became more widely used in embedded systems and complex components such as DVB adapters, those assumptions became more problematic. Drivers for I2C devices that issue interrupts need more (and different) configuration information, as do drivers handling chip variants that can’t be distinguished by protocol probing, or which need some board specific information to operate correctly.

Device/Driver Binding¶

System infrastructure, typically board-specific initialization code or boot firmware, reports what I2C devices exist. For example, there may be a table, in the kernel or from the boot loader, identifying I2C devices and linking them to board-specific configuration information about IRQs and other wiring artifacts, chip type, and so on. That could be used to create i2c_client objects for each I2C device.

I2C device drivers using this binding model work just like any other kind of driver in Linux: they provide a probe() method to bind to those devices, and a remove() method to unbind.

Remember that the i2c_driver does not create those client handles. The handle may be used during foo_probe(). If foo_probe() reports success (zero not a negative status code) it may save the handle and use it until foo_remove() returns. That binding model is used by most Linux drivers.

The probe function is called when an entry in the id_table name field matches the device’s name. It is passed the entry that was matched so the driver knows which one in the table matched.

Device Creation¶

If you know for a fact that an I2C device is connected to a given I2C bus, you can instantiate that device by simply filling an i2c_board_info structure with the device address and driver name, and calling i2c_new_client_device() . This will create the device, then the driver core will take care of finding the right driver and will call its probe() method. If a driver supports different device types, you can specify the type you want using the type field. You can also specify an IRQ and platform data if needed.

Sometimes you know that a device is connected to a given I2C bus, but you don’t know the exact address it uses. This happens on TV adapters for example, where the same driver supports dozens of slightly different models, and I2C device addresses change from one model to the next. In that case, you can use the i2c_new_scanned_device() variant, which is similar to i2c_new_client_device() , except that it takes an additional list of possible I2C addresses to probe. A device is created for the first responsive address in the list. If you expect more than one device to be present in the address range, simply call i2c_new_scanned_device() that many times.

The call to i2c_new_client_device() or i2c_new_scanned_device() typically happens in the I2C bus driver. You may want to save the returned i2c_client reference for later use.

Device Detection¶

Sometimes you do not know in advance which I2C devices are connected to a given I2C bus. This is for example the case of hardware monitoring devices on a PC’s SMBus. In that case, you may want to let your driver detect supported devices automatically. This is how the legacy model was working, and is now available as an extension to the standard driver model.

You simply have to define a detect callback which will attempt to identify supported devices (returning 0 for supported ones and -ENODEV for unsupported ones), a list of addresses to probe, and a device type (or class) so that only I2C buses which may have that type of device connected (and not otherwise enumerated) will be probed. For example, a driver for a hardware monitoring chip for which auto-detection is needed would set its class to I2C_CLASS_HWMON, and only I2C adapters with a class including I2C_CLASS_HWMON would be probed by this driver. Note that the absence of matching classes does not prevent the use of a device of that type on the given I2C adapter. All it prevents is auto-detection; explicit instantiation of devices is still possible.

Note that this mechanism is purely optional and not suitable for all devices. You need some reliable way to identify the supported devices (typically using device-specific, dedicated identification registers), otherwise misdetections are likely to occur and things can get wrong quickly. Keep in mind that the I2C protocol doesn’t include any standard way to detect the presence of a chip at a given address, let alone a standard way to identify devices. Even worse is the lack of semantics associated to bus transfers, which means that the same transfer can be seen as a read operation by a chip and as a write operation by another chip. For these reasons, explicit device instantiation should always be preferred to auto-detection where possible.

Device Deletion¶

Each I2C device which has been created using i2c_new_client_device() or i2c_new_scanned_device() can be unregistered by calling i2c_unregister_device() . If you don’t call it explicitly, it will be called automatically before the underlying I2C bus itself is removed, as a device can’t survive its parent in the device driver model.

Initializing the driver¶

When the kernel is booted, or when your foo driver module is inserted, you have to do some initializing. Fortunately, just registering the driver module is usually enough.

Note that some functions are marked by __init . These functions can be removed after kernel booting (or module loading) is completed. Likewise, functions marked by __exit are dropped by the compiler when the code is built into the kernel, as they would never be called.

Driver Information¶

Power Management¶

If your I2C device needs special handling when entering a system low power state – like putting a transceiver into a low power mode, or activating a system wakeup mechanism – do that by implementing the appropriate callbacks for the dev_pm_ops of the driver (like suspend and resume).

These are standard driver model calls, and they work just like they would for any other driver stack. The calls can sleep, and can use I2C messaging to the device being suspended or resumed (since their parent I2C adapter is active when these calls are issued, and IRQs are still enabled).

System Shutdown¶

If your I2C device needs special handling when the system shuts down or reboots (including kexec) – like turning something off – use a shutdown() method.

Again, this is a standard driver model call, working just like it would for any other driver stack: the calls can sleep, and can use I2C messaging.

Command function¶

A generic ioctl-like function call back is supported. You will seldom need this, and its use is deprecated anyway, so newer design should not use it.

Sending and receiving¶

If you want to communicate with your device, there are several functions to do this. You can find all of them in
.

If you can choose between plain I2C communication and SMBus level communication, please use the latter. All adapters understand SMBus level commands, but only some of them understand plain I2C!

Plain I2C communication¶

These routines read and write some bytes from/to a client. The client contains the I2C address, so you do not have to include it. The second parameter contains the bytes to read/write, the third the number of bytes to read/write (must be less than the length of the buffer, also should be less than 64k since msg.len is u16.) Returned is the actual number of bytes read/written.

This sends a series of messages. Each message can be a read or write, and they can be mixed in any way. The transactions are combined: no stop condition is issued between transaction. The i2c_msg structure contains for each message the client address, the number of bytes of the message and the message data itself.

You can read the file i2c-protocol for more information about the actual I2C protocol.

SMBus communication¶

This is the generic SMBus function. All functions below are implemented in terms of it. Never use this function directly!

These ones were removed from i2c-core because they had no users, but could be added back later if needed:

All these transactions return a negative errno value on failure. The ‘write’ transactions return 0 on success; the ‘read’ transactions return the read value, except for block transactions, which return the number of values read. The block buffers need not be longer than 32 bytes.

You can read the file smbus-protocol for more information about the actual SMBus protocol.

General purpose routines¶

Below all general purpose routines are listed, that were not mentioned before:

Источник