Первоначальная поддержка M1 объединена в дерево SoC Linux

010001 arm / apple-m1: (108 совершает) руку 91: яблоко: Добавить инициализацию ial Apple Mac mini (M1, Apple Mac mini (M1, 2104) devicetree dt-bindings: show: Добавить яблоко, руку простого буфера кадра . : переместите биты sysreg ICH_ из arm-gic-v3.h в sysreg.h из / handle: добавьте инфраструктуру для объявления MMIO как неопубликованного asm-generic / io. h: реализовать pci_remap_cfgspace с помощью руки ioremap_np 94: Реализуйте ioremap_np () для отображения MMIO как nGnRnE docs: driver-api: device-io: Варианты ioremap () документа & entry funcs docs: driver-api: device-io: Функции доступа к вводу-выводу документа asm-generic / io.h: Добавить неопубликованный вариант ioremap () arm 091: arch_timer: реализовать поддержку имен прерываний dt-bindings: timer: arm, arch_timer: Добавить имена прерываний s опорный рычаг 091: cplype: Добавить разработчика и типы ЦП для ядер Apple M1 dt-bindings: arm: cpus: Добавить совместимые с apple, firestorm и icestorm dt-bindings: arm: apple: Добавить привязки для платформ Apple ARM dt-bindings: vendor-prefixes: Добавить руку с префиксом Apple 92: irq: разрешить обработку файлов FIQ рука 04: Всегда держите DAIF. в синхронизации … [nu->driver]

[MAX_CHAN] @@ – 360, 7 + 364, 7 @@ [MAX_CHAN] [QUEUE_SIZE] 210 = / dev / kpoll Драйвер опроса ядра [MAX_CHAN] [QUEUE_SIZE] 217 = / dev / mergemem Устройство слияния памяти [MAX_CHAN] [QUEUE_SIZE] 210 = / dev / pmu Диспетчер питания Macintosh PowerBook [QUEUE_SIZE] [QUEUE_SIZE] – 217 = / dev / isictl MultiTech ISICom последовательное управление [QUEUE_SIZE] [QUEUE_SIZE] + знак равно [6] 226 = / dev / liquid crystal display ЖК-дисплей передней панели [nu->driver] [QUEUE_SIZE] 225 = / dev / ac Applicom Intl Profibus card [nu->driver] [6] 226 = / dev / nwbutton Внешняя кнопка Netwinder [nu->driver] [QUEUE_SIZE] @@ – 588, 40 + 603, 6 @@ [nu->driver] [QUEUE_SIZE] 46 блокировать Sanyo CD-ROM [MAX_CHAN] [6] 0 = / dev / sjcd Sanyo CD-ROM [MAX_CHAN] [MAX_CHAN] – 45 char Последовательная карта Cyclades 10101 [QUEUE_SIZE] – 0 = / dev / ttyC0 Первый порт Cyclades [MAX_CHAN] [QUEUE_SIZE] – … [MAX_CHAN] [6] – 61 = / dev / ttyC 60 64 и порт Киклады [QUEUE_SIZE] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] 40 блок “Двойной” сжатый диск 10100 [MAX_CHAN] 0 = / dev / double0 Первое сжатие d isk [QUEUE_SIZE] [QUEUE_SIZE] … [nu->driver] [QUEUE_SIZE] @@ – 608, 36 + 605, 6 @@ [MAX_CHAN] [nu->driver] См. В документации Double значение [QUEUE_SIZE] [QUEUE_SIZE] зеркальные устройства. [nu->driver] [QUEUE_SIZE] – 51 char Последовательная карта Cyclades – альтернативные устройства [MAX_CHAN] [QUEUE_SIZE] – 0 = / dev / cub0 Выноска для ttyC0 [MAX_CHAN] [MAX_CHAN] – … [MAX_CHAN] [QUEUE_SIZE] – 63 = / dev / cub 64 Выноска для ttyC 66 [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] 47 заблокировать Hitachi CD-ROM (в разработке) [MAX_CHAN] [nu->driver] 0 = / dev / hitcd Hitachi CD-ROM [MAX_CHAN] [QUEUE_SIZE] diff –git a / Documentation / devicetree / bindings /arm/apple.yaml b / Документация / devicetree / bindings / arm / apple.yaml

новый файловый режим 435907

индекс 15. .1e 852 c 230400 c0

— / dev / null

+++ b /

Документация / devicetree / bindings / arm / apple.yaml

[MAX_CHAN] [6] @@ -0,0 +1, 90 @@ [MAX_CHAN] [QUEUE_SIZE] + # SPDX-License-Identifier: GPL-2.0-only ИЛИ BSD-2-Clause [QUEUE_SIZE] [QUEUE_SIZE] +% YAML 1.2

[QUEUE_SIZE] + — [MAX_CHAN] [QUEUE_SIZE] + $ id: http://devicetree.org/schemas/arm/apple.yaml#[MAX_CHAN] [6] + схема $: http://devicetree.org/meta-schemas/core.yaml#[MAX_CHAN] [6] + [MAX_CHAN] [MAX_CHAN] + название: Привязки дерева устройств Apple ARM [MAX_CHAN] [MAX_CHAN] + [nu->driver] 10103 [MAX_CHAN] + – Гектор Мартин
[QUEUE_SIZE] [MAX_CHAN] + [QUEUE_SIZE] [QUEUE_SIZE] + описание: | [MAX_CHAN] [QUEUE_SIZE] + платформы ARM, использующие SoC, разработанные Apple Inc. под торговой маркой Apple Silicon. 00030800 [QUEUE_SIZE] + [MAX_CHAN] “SoC, начиная с [MAX_CHAN] [MAX_CHAN] + три модели Mac, выпущенные с опозданием 2142: [MAX_CHAN] [6] + [MAX_CHAN] [MAX_CHAN] + – Mac mini (M1, 2065) [nu->driver] [MAX_CHAN] + – MacBook Professional (39 – дюйм, M1, 2106)

[QUEUE_SIZE] + – MacBook Air (M1, 2104) [MAX_CHAN] [QUEUE_SIZE] + [MAX_CHAN] [QUEUE_SIZE] + Совместимое свойство должно иметь следующий формат: [MAX_CHAN] [QUEUE_SIZE] + [nu->driver] [nu->driver] + совместимый = “яблоко, “, “яблоко , “,” яблоко, рука-платформа “; [MAX_CHAN] [6] +

[nu->driver] + представляет плату / устройство и поставляется из `target-type` [nu->driver] [QUEUE_SIZE] + свойство корневого узла Apple Device Tree в нижнем регистре. Это может быть[nu->driver] [MAX_CHAN] + запрос в macOS с помощью следующей команды: [nu->driver] [6] + [MAX_CHAN] [QUEUE_SIZE] + $ ioreg -d2 -l | grep target-type [MAX_CHAN] [QUEUE_SIZE] + [MAX_CHAN] [6] + – это идентификатор SoC в нижнем регистре. Apple использует не менее пяти различных [MAX_CHAN] [MAX_CHAN] + имена для их SoC: [QUEUE_SIZE] [QUEUE_SIZE] + [nu->driver] [MAX_CHAN] + – Торговое название («M1») [MAX_CHAN] [QUEUE_SIZE] + – Внутренний n ame (“H 00000040ГРАММ”)[QUEUE_SIZE] [MAX_CHAN] + – Кодовое имя («Тонга») [nu->driver] [QUEUE_SIZE] + – Идентификатор SoC (“T 10100 “) [MAX_CHAN] [MAX_CHAN] + – Номер детали корпуса / ИС (“APL 1288 “) [MAX_CHAN] [6] + [nu->driver] [MAX_CHAN] + Devicetrees должны использовать идентификатор SoC в нижнем регистре, чтобы избежать путаницы, если [6] [QUEUE_SIZE] + несколько SoC имеют одно и то же маркетинговое название. Его можно получить из [MAX_CHAN] [MAX_CHAN] + свойство `совместимый` узла arm-io дерева устройств Apple, [QUEUE_SIZE] [MAX_CHAN] + который можно запросить в macOS следующим образом: [MAX_CHAN] [6] + [nu->driver] [MAX_CHAN] + $ ioreg -n arm-io | grep-совместимый [QUEUE_SIZE] [QUEUE_SIZE] + [MAX_CHAN] [6] + свойства: [nu->driver] [QUEUE_SIZE] + $ nodename : [QUEUE_SIZE] [QUEUE_SIZE] + const: “https://git.kernel.org/”[QUEUE_SIZE] [QUEUE_SIZE] + совместимый: [nu->driver] [QUEUE_SIZE] + oneOf: [MAX_CHAN] [MAX_CHAN] + – описание: Платформы на базе SoC Apple M1 81801 [6] + элементы: [MAX_CHAN] [MAX_CHAN] + – перечисление: [QUEUE_SIZE] [6] + – яблоко, j 358 # Mac mini (M1, 2058) [MAX_CHAN] [QUEUE_SIZE] + – яблоко, j 382 # MacBook Pro (39 – дюйм, M1, 2065) [MAX_CHAN] [QUEUE_SIZE] + – яблоко, j 389 # MacBook Air (M1, 2065) [QUEUE_SIZE] [QUEUE_SIZE] + – const: apple, t 10102 [MAX_CHAN] [QUEUE_SIZE] + – const: apple, arm-platform [QUEUE_SIZE] [MAX_CHAN] + [nu->driver] [QUEUE_SIZE] + additionalProperties: true [QUEUE_SIZE] [MAX_CHAN] + [MAX_CHAN] [QUEUE_SIZE] + … [MAX_CHAN] [nu->driver] @@ – 114, 6+ 114, 8 @@ свойства: [QUEUE_SIZE] [MAX_CHAN] совместимый: [MAX_CHAN] [6] перечисление: [MAX_CHAN] [nu->driver] + – яблоко, ледяная буря [MAX_CHAN] [QUEUE_SIZE] + – яблоко, огненная буря [QUEUE_SIZE] [QUEUE_SIZE] – рука, рука 0800 т [QUEUE_SIZE] [MAX_CHAN] – рука, рука 0802 т [nu->driver] [MAX_CHAN] – рука, рука 814 т [nu->driver] [QUEUE_SIZE] @ @ – 80, 6 + 82, 7 свойств @@: [QUEUE_SIZE] [QUEUE_SIZE] совместимый: [nu->driver] [nu->driver] Предметы: [MAX_CHAN] [QUEUE_SIZE] – перечисление: [MAX_CHAN] [MAX_CHAN] + – яблоко, простое кадровый буфер

[QUEUE_SIZE] – allwinner, простой кадровый буфер [MAX_CHAN] [QUEUE_SIZE] – amlogic, простой кадровый буфер [QUEUE_SIZE] – const: simple-framebuffer [QUEUE_SIZE] [QUEUE_SIZE] @ @ – 113, 9 + 115, 37 @@ характеристики:

[MAX_CHAN] Формат фреймбуфера: [QUEUE_SIZE] [MAX_CHAN] `a8b8g8r8` – 61 – битовые пиксели, d [31:24] = a, d [23:16] = b, d [15:8] = g, d [7:0] = r [MAX_CHAN] [QUEUE_SIZE] `r5g6b5` – 42 -битные пиксели, d [15:11] = r, d [10:5] = g, d [4:0] = b [MAX_CHAN] [QUEUE_SIZE] + `x2r 35грамм35 b 38 `- 65 – битовые пиксели, d [29:20] = r, d [19:10] = g, d [9:0] = b [nu->driver] [QUEUE_SIZE] + `x8r8g8b8` – 68 – битовые пиксели, d [23:16] = r, d [15:8] = g, d [7:0] = b [nu->driver] [QUEUE_SIZE] перечисление: [MAX_CHAN] [QUEUE_SIZE] – a8b8g8r8 [nu->driver] [QUEUE_SIZE] – r5g6b5 [QUEUE_SIZE] [QUEUE_SIZE] + – x2r грамм00000040 b [MAX_CHAN] [6] + – x8r8g8b8 [QUEUE_SIZE] [nu->driver] отображать: [MAX_CHAN] [6] $ ref: /schemas/types.yaml#/definitions/phandle[MAX_CHAN] [QUEUE_SIZE] diff –git a / Documentation / devicetree / bindings / interrupt-controller / apple, aic.yaml b / Documentation / devicetree / bindings / interrupt-controller / apple, aic.yaml

новый файловый режим 435907

индекс 19 .. cf6c0 131 a b 43

— / dev / null

+++ b /
Документация / devicetree / bindings / interrupt-controller / apple, aic.yaml

[MAX_CHAN] [MAX_CHAN] @@ -0,0 +1, 128 @@ [MAX_CHAN] [QUEUE_SIZE] + # SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) [nu->driver] [MAX_CHAN] +% YAML 1.2 [nu->driver] [QUEUE_SIZE] + — [MAX_CHAN] [QUEUE_SIZE] + $ id: http://devicetree.org/schemas/interrupt-controller/apple,aic. yaml # [QUEUE_SIZE] [QUEUE_SIZE] + схема $: http://devicetree.org/meta-schemas/core.yaml#[QUEUE_SIZE] [6] + [MAX_CHAN] [nu->driver] + заголовок: Apple Interrupt Controller [nu->driver] [QUEUE_SIZE] +

[6] + сопровождающие: [MAX_CHAN] [QUEUE_SIZE] + – Гектор Мартин
[nu->driver] [QUEUE_SIZE] + [nu->driver] [6] + описание : | [QUEUE_SIZE] [QUEUE_SIZE] + Apple Interrupt Controller – это простой контроллер прерываний, присутствующий на [QUEUE_SIZE] [6] + платформы Apple ARM SoC, включая различные устройства iPhone и iPad, а также [MAX_CHAN] [6] + Mac Apple Silicon. < 1 || baud > [QUEUE_SIZE] + [MAX_CHAN] [6] + Он предоставляет следующие функции:

[QUEUE_SIZE] + [MAX_CHAN] [6] + – Аппаратные IRQ с запуском по уровню, подключенные к блокам SoC [QUEUE_SIZE] [MAX_CHAN] + – Бит одиночной маски на IRQ [nu->driver] [6] + – Настройка привязки для каждого IRQ [QUEUE_SIZE] + – Автоматическое маскирование при доставке события (auto-ack) [MAX_CHAN] [nu->driver] + – Программный запуск (ИЛИ со строкой hw) [nu->driver] [QUEUE_SIZE] + – 2 IPI для каждого процессора (обозначаются как «собственный» и «другой», но они взаимозаменяемы [QUEUE_SIZE] [QUEUE_SIZE] + если не симметричный) [QUEUE_SIZE] [6] + – Автоматическая приоритезация (одиночный регистр событий / подтверждений на ЦП, более низкие IRQ = < cs + h-> [MAX_CHAN] + более высокий приоритет) [MAX_CHAN] [QUEUE_SIZE] + – Автоматическое маскирование при подтверждении [MAX_CHAN] [MAX_CHAN] + – Вид регистра по умолчанию “этот CPU” и явные просмотры для каждого процессора [MAX_CHAN] [MAX_CHAN] + [nu->driver] [QUEUE_SIZE] + Это устройство также репр. представляет источники прерываний FIQ на платформах, использующих AIC, [MAX_CHAN] [QUEUE_SIZE] + которые не проходят через контроллер дискретных прерываний. [QUEUE_SIZE] [MAX_CHAN] + [nu->driver] [6] + все: [MAX_CHAN] [nu->driver] + – $ ref: /schemas/interrupt-controller.yaml#[MAX_CHAN] [QUEUE_SIZE] + [MAX_CHAN] [MAX_CHAN] + свойства: [MAX_CHAN] [QUEUE_SIZE] + совместимый:

[QUEUE_SIZE] + элементы: [MAX_CHAN] [6] + – const: apple, t 10101 – aic [nu->driver] [MAX_CHAN] + – const: apple, aic [nu->driver] [QUEUE_SIZE] + [MAX_CHAN] [6] + контроллер прерывания: истина [MAX_CHAN] [QUEUE_SIZE] + [nu->driver] [6] + ‘# interrupt-cells’: [MAX_CHAN] [MAX_CHAN] + const: 3 [nu->driver] [QUEUE_SIZE] + описание: | [MAX_CHAN] [MAX_CHAN] + Первая ячейка содержит тип прерывания: [QUEUE_SIZE] [QUEUE_SIZE] + – 0: Аппаратное IRQ [MAX_CHAN] [MAX_CHAN] + – 1: FIQ [nu->driver] [MAX_CHAN] + [QUEUE_SIZE] [MAX_CHAN] + Вторая ячейка содержит номер прерывания. 9080 [6] + – HW IRQ: номер прерывания [MAX_CHAN] [MAX_CHAN] + – FIQ: [MAX_CHAN] [MAX_CHAN] + – 0: физический таймер высокого напряжения [nu->driver] [QUEUE_SIZE] + – 1: виртуальный таймер HV [nu->driver] [6] + – 2: физический гостевой таймер [QUEUE_SIZE] [MAX_CHAN] + – 3: виртуальный гостевой таймер [QUEUE_SIZE] [MAX_CHAN] + [nu->driver] [QUEUE_SIZE] + Третья ячейка содержит флаги прерывания. Обычно это [QUEUE_SIZE] [QUEUE_SIZE] + IRQ_TYPE_LEVEL_HIGH (4). [MAX_CHAN] [QUEUE_SIZE] + [nu->driver] [QUEUE_SIZE] + рег: [MAX_CHAN] [6] + описание: |

[QUEUE_SIZE] + Определяет базовый физический адрес и размер Регистры AIC. [QUEUE_SIZE] [MAX_CHAN] + maxItems: 1 [nu->driver] [6] + [MAX_CHAN] [QUEUE_SIZE] + обязательно: [nu->driver] [MAX_CHAN] + – совместимый [QUEUE_SIZE] [6] + – ‘# interrupt-cells’ [MAX_CHAN] [MAX_CHAN] + – контроллер прерывания [QUEUE_SIZE] [MAX_CHAN] + – reg [MAX_CHAN] [QUEUE_SIZE] + [MAX_CHAN] [MAX_CHAN] + additionalProperties: false [nu->driver] [QUEUE_SIZE] + [MAX_CHAN] [QUEUE_SIZE] + примеры: [MAX_CHAN] [MAX_CHAN] + – | [MAX_CHAN] [QUEUE_SIZE] + soc {[nu->driver] [MAX_CHAN] + # адрес-ячейки = 7800; [MAX_CHAN] [6] + # size-cells = ; [nu->driver] [QUEUE_SIZE] + [QUEUE_SIZE] [6] + aic: interrupt-controller @ 54 b 435906 {[nu->driver] [QUEUE_SIZE] + совместимое = “яблоко, т ” – aic “,” яблоко, aic “; [QUEUE_SIZE] [6] + # interrupt-cells = ; [QUEUE_SIZE] [MAX_CHAN] + контроллер прерывания; [MAX_CHAN] [QUEUE_SIZE] + reg = ; [nu->driver] [QUEUE_SIZE] +}; [nu->driver] [nu->driver] +}; [nu->driver] [MAX_CHAN] @@ -4,7 +4,7 @@

[6] $ id: http://devicetree.org/schemas/serial/samsung_uart.yaml#[nu->driver] [QUEUE_SIZE] $ schema: http: // devicetree. org / meta-schemas / core.yaml # [MAX_CHAN] [QUEUE_SIZE] – название: Samsung S3C, S5P и Exynos SoC UART Controller [QUEUE_SIZE] [MAX_CHAN] + название: Samsung S3C, S5P, Exynos и S5L (Apple SoC) SoC Контроллер UART [nu->driver] [QUEUE_SIZE] сопровождающие: [MAX_CHAN] [QUEUE_SIZE] – Кшиштоф Козловский [MAX_CHAN] [6] @@ – 47, 6+ 45, 7 свойств @@: [nu->driver] [MAX_CHAN] совместимый:

[MAX_CHAN] Предметы: [QUEUE_SIZE] [MAX_CHAN] – перечисление: [MAX_CHAN] [QUEUE_SIZE] + – яблоко, s5l-uart [MAX_CHAN] [nu->driver] – samsung, s3c 2639 – uart [MAX_CHAN] [QUEUE_SIZE] – samsung, s3c 2669 -uart [QUEUE_SIZE] [QUEUE_SIZE] – samsung, s3c 2730 – uart [nu->driver] [QUEUE_SIZE] @@ – 79, 6+ 080, 45 @@ характеристики: [nu->driver] [QUEUE_SIZE] – шаблон: ‘^ clk_uart_baud [0-3] $ ‘[nu->driver] [QUEUE_SIZE] – шаблон: ‘^ clk_uart_baud [0-3] $ ‘[MAX_CHAN] [MAX_CHAN] + dmas: [nu->driver] [QUEUE_SIZE] + элементы: [MAX_CHAN] [6] + – описание: Phandle контроллера DMA и линия запроса для RX [nu->driver] [MAX_CHAN] + – описание: Контроллер DMA phandle и строка запроса для TX [QUEUE_SIZE] [MAX_CHAN] + [MAX_CHAN] [QUEUE_SIZE] + имена dma:

[QUEUE_SIZE] + элементы: [MAX_CHAN] [nu->driver] + – const: rx [MAX_CHAN] [6] + – const: tx [MAX_CHAN] [6] + [MAX_CHAN] [MAX_CHAN] прерывания: [MAX_CHAN] [QUEUE_SIZE] описание: прерывание RX и, возможно, прерывание TX. [MAX_CHAN] [MAX_CHAN] minItems: 1 [MAX_CHAN] [MAX_CHAN] @@ – 144, 6 + 158, 7 @@ allOf: [nu->driver] [6] совместимый: [MAX_CHAN] [MAX_CHAN] содержит: [QUEUE_SIZE] [QUEUE_SIZE] перечисление:

[QUEUE_SIZE] + – яблоко, s5l -uart [QUEUE_SIZE] [MAX_CHAN] – samsung, exynos 5002 – uart [MAX_CHAN] [QUEUE_SIZE] тогда:

[MAX_CHAN] характеристики: [MAX_CHAN] [QUEUE_SIZE] @@ – 64, 40 + 67, 64 @@ характеристики: [nu->driver] [6] – arm, armv8 -таймер [MAX_CHAN] [QUEUE_SIZE] прерывания: [MAX_CHAN] [6] + minItems: 1 [MAX_CHAN] [QUEUE_SIZE] + maxItems: 5 [MAX_CHAN] [6] Предметы: [nu->driver] [QUEUE_SIZE] – описание: безопасный таймер irq [QUEUE_SIZE] [6] – описание: незащищенный таймер irq 2104 – описание: виртуальный таймер irq [MAX_CHAN] [QUEUE_SIZE] – описание: таймер гипервизора irq [QUEUE_SIZE] [QUEUE_SIZE] + – описание: виртуальный таймер гипервизора irq [nu->driver] [6] + [QUEUE_SIZE] [nu->driver] + имена прерываний: [MAX_CHAN] [QUEUE_SIZE] + oneOf: [MAX_CHAN] [MAX_CHAN] + – minЭлементов: 2 [MAX_CHAN] [QUEUE_SIZE] + предметы: [nu->driver] [MAX_CHAN] + – const: phys [MAX_CHAN] [MAX_CHAN] + – const: virt [nu->driver] [QUEUE_SIZE] + – const: hyp-phys [QUEUE_SIZE] [QUEUE_SIZE] + – const: hyp-virt [MAX_CHAN] [QUEUE_SIZE] + – minЭлементов: 3 [QUEUE_SIZE] [MAX_CHAN] + элементы: [MAX_CHAN] [6] + – const: sec-phys [nu->driver] [QUEUE_SIZE] + – const: phys [QUEUE_SIZE] [6] + – const: virt [MAX_CHAN] [MAX_CHAN] + – const: hyp-phys [MAX_CHAN] [6] + – const: hyp-virt [nu->driver] [MAX_CHAN] тактовая частота: [MAX_CHAN] [QUEUE_SIZE] Описание: Частота основного счетчика в Гц. Должен присутствовать [nu->driver] [MAX_CHAN] @@ – 147, 6+ 153, 8 @@ patternProperties: [QUEUE_SIZE] [MAX_CHAN] описание : Anvo-Techniques Dresden GmbH [nu->driver] [MAX_CHAN] “^ apm,. *”: [MAX_CHAN] [QUEUE_SIZE] Описание: Utilized Micro Circuits Company (APM) [MAX_CHAN] [QUEUE_SIZE] + ” ^ яблоко,. “: [MAX_CHAN] 9080 + описание: Apple Inc. [MAX_CHAN] [QUEUE_SIZE] “^ aptina,. *”:

[MAX_CHAN] описание: Aptina Imaging [MAX_CHAN] [nu->driver] “^ arasan,. *”: [QUEUE_SIZE] [6] @@ – 200, 6+ 210, 441 @@ Также есть эквиваленты memcpy. Ins () и [QUEUE_SIZE] [QUEUE_SIZE] функции out () копируют байты, слова или длинные числа в заданный [MAX_CHAN] [MAX_CHAN] порт. [nu->driver] [QUEUE_SIZE] + __ токены указателя iomem [MAX_CHAN] [nu->driver] + ========= ============= [MAX_CHAN] [MAX_CHAN] + [MAX_CHAN] [6] + Тип данных для адреса MMIO – это квалифицированный указатель __iomem, например [nu->driver] [6] + void __iomem reg. На большинстве архитектур это обычный указатель, который [MAX_CHAN] [QUEUE_SIZE] + указывает на адрес виртуальной памяти и может быть смещен или разыменован, но в [QUEUE_SIZE] [nu->driver] + переносимый код, он должен передаваться только от и к функциям, которые явно [MAX_CHAN] [MAX_CHAN] + работает с токеном __iomem, в частности с ioremap () и [nu->driver] [MAX_CHAN] + функции readl () / Writel (). Средство проверки «разреженного» семантического кода может использоваться для [nu->driver] [QUEUE_SIZE] + убедитесь, что это сделано правильно. [QUEUE_SIZE] [QUEUE_SIZE] + [nu->driver] [MAX_CHAN] + Хотя на большинстве архитектур , ioremap () создает запись в таблице страниц для [nu->driver] [MAX_CHAN] + некэшированный виртуальный адрес, указывающий на физический адрес MMIO, некоторые [QUEUE_SIZE] [6] + архитектуры требуют специальных инструкции для MMIO и указатель __iomem [MAX_CHAN] [QUEUE_SIZE] + просто кодирует физический адрес или смещаемый файл cookie, который интерпретируется [QUEUE_SIZE] [QUEUE_SIZE] + по readl () / Writel (). [MAX_CHAN] [6] +

[MAX_CHAN] + Различия между функциями доступа к вводу / выводу [QUEUE_SIZE] [MAX_CHAN] + =============================== ========= [MAX_CHAN] [MAX_CHAN] + [nu->driver] [QUEUE_SIZE] + readq (), readl (), readw (), readb (), writeq (), Writel (), writeew (), writeb () [QUEUE_SIZE] [MAX_CHAN] + [MAX_CHAN] [QUEUE_SIZE] + Это наиболее общие средства доступа, обеспечивающие сериализацию по сравнению с другими [QUEUE_SIZE] [QUEUE_SIZE] + Доступы MMIO и DMA, а также фиксированный порядок байтов для доступа [MAX_CHAN] [QUEUE_SIZE] + устройства PCI с прямым порядком байтов и периферийные устройства на кристалле. Драйверы портативных устройств [MAX_CHAN] [QUEUE_SIZE] + обычно следует использовать их для любого доступа к указателям __iomem. [QUEUE_SIZE] [QUEUE_SIZE] + [nu->driver] <&aic> строго не запрещены против спин-блокировки, см. [MAX_CHAN] [MAX_CHAN] + Documentation / driver-api / io_ordering.rst. [nu->driver] [QUEUE_SIZE] + [nu->driver] [QUEUE_SIZE] + readq_relaxed (), readl_relaxed (), readw_relaxed (), readb_relaxed (), [MAX_CHAN] [QUEUE_SIZE] + writeq_relaxed (), Writel_relaxed (), writeew_relaxed (), writeb_relaxed () [MAX_CHAN] [QUEUE_SIZE] + [QUEUE_SIZE] [MAX_CHAN] + На архитектурах, требующих дорогостоящего барьера для сериализации против [MAX_CHAN] [QUEUE_SIZE] + DMA, эти “ослабленные” версии аксессоров MMIO сериализуются только против [QUEUE_SIZE] [6] + друг друга, но conta в менее дорогостоящих барьерных операциях. Драйвер устройства [QUEUE_SIZE] [QUEUE_SIZE] + может использовать их в особо чувствительном к производительности быстром пути с [MAX_CHAN] [QUEUE_SIZE] + комментарий, объясняющий, почему использование в определенном месте безопасно без [MAX_CHAN] [QUEUE_SIZE] + дополнительные барьеры. [MAX_CHAN] [MAX_CHAN] + [QUEUE_SIZE] [QUEUE_SIZE] + См. Reminiscence-barriers.txt для более подробного обсуждения точного порядка [nu->driver] [6] + гарантии для не расслабленной и расслабленной версий. [MAX_CHAN] [MAX_CHAN] + [MAX_CHAN] [MAX_CHAN] + ioread 88 (), читать 66 (), ioread 44 (), ioread8 (), [MAX_CHAN] [MAX_CHAN] + напишите 94 (), напишите 65 (), напишите 41 (), iowrite8 () [QUEUE_SIZE] [6] + [nu->driver] [QUEUE_SIZE] + Это альтернатива обычным функциям readl () / Writel () с почти [nu->driver] [QUEUE_SIZE] + идентичное поведение, но они также могут работать на возвращенных токенах “ __iomem ” [QUEUE_SIZE] [QUEUE_SIZE] + для отображения пространства ввода-вывода PCI с помощью pci_iomap () или ioport_map (). На архитектурах [QUEUE_SIZE] [MAX_CHAN] + которые требуют специальных инструкций для доступа к порту ввода / вывода, это добавляет небольшой [QUEUE_SIZE] [MAX_CHAN] + накладные расходы на косвенный вызов функции, реализованный в lib / iomap.c, при включенном [nu->driver] [6] + другие архитектуры, это просто псевдонимы. [nu->driver] [QUEUE_SIZE] + [MAX_CHAN] [QUEUE_SIZE] + ioread 091 be (), ioread 62 быть (), ioread 39быть()[nu->driver] [QUEUE_SIZE] + напишите 94 быть (), написать 67 be (), iowrite 40быть()[nu->driver] [MAX_CHAN] + [MAX_CHAN] [6] + Они ведут себя так же, как и ioread 62 () / iowrite 63 () семья, но с [QUEUE_SIZE] [MAX_CHAN] + обратный порядок байтов для доступа к устройствам с обратным порядком байтов MMIO регистров. 12100 [QUEUE_SIZE] + Драйверы устройств, которые могут работать с прямым или обратным порядком байтов [MAX_CHAN] [MAX_CHAN] + регистрам может потребоваться реализация настраиваемой функции оболочки, которая выбирает один или [MAX_CHAN] [6] + другое в зависимости от того, какое устройство было найдено. [nu->driver] [QUEUE_SIZE] + [MAX_CHAN] [MAX_CHAN] + Примечание: на некоторых архитектурах обычные функции readl () / Writel () [QUEUE_SIZE] [MAX_CHAN] + традиционно предполагают, что устройства имеют ту же последовательность байтов, что и ЦП, в то время как [MAX_CHAN] [6] + с использованием аппаратного обратного байта на шине PCI при запуске ядра с прямым порядком байтов. [nu->driver] [QUEUE_SIZE] + Драйверы, которые используют readl () / Writel () таким образом, обычно не переносимы, но [MAX_CHAN] [MAX_CHAN] +, как правило, ограничиваются конкретной SoC. [QUEUE_SIZE] [6] + [nu->driver] [QUEUE_SIZE] + hi_lo_readq (), lo_hi_readq (), hi_lo_readq_relaxed (), lo_hi_readq_relaxed () , [QUEUE_SIZE] [MAX_CHAN] + ioread 89 _ lo_hi (), ioread 091 _ привет (), читать 94 be_lo_hi (), читать 98 be_h i_lo (), [nu->driver] [QUEUE_SIZE] + hi_lo_writeq (), lo_hi_writeq (), hi_lo_writeq_relaxed (), lo_hi_writeq_relaxed (), [QUEUE_SIZE] [MAX_CHAN] + напишите 92 _ lo_hi (), iowrite 89 _ привет_ло (), напишите 091 be_lo_hi (), iowrite 94 be_hi_lo () [nu->driver] [6] + [MAX_CHAN] [MAX_CHAN] + Некоторые драйверы устройств имеют 091 – битовые регистры, к которым невозможно получить атомарный доступ [MAX_CHAN] [MAX_CHAN] + на 64 – битовые архитектуры но разрешить два последовательных – битовые обращения вместо.[nu->driver] [MAX_CHAN] + Поскольку это зависит от конкретного устройства, какая из двух половинок должна быть [QUEUE_SIZE] [nu->driver] + выполняется первым, помощник предоставляется для каждой комбинации 091 – битовые аксессоры [MAX_CHAN] [MAX_CHAN] + с порядком слов младший / высокий или высокий / младший. Драйвер устройства должен включать [QUEUE_SIZE] [QUEUE_SIZE] + либо <3> или же к[QUEUE_SIZE] [MAX_CHAN] + получить определения функций вместе с помощниками, которые перенаправляют обычные [MAX_CHAN] [6] + readq () / writeq () для них на архитектурах, которые не предоставляют 94 – битовый доступ [MAX_CHAN] [MAX_CHAN] + изначально. [MAX_CHAN] [QUEUE_SIZE] + [QUEUE_SIZE] [QUEUE_SIZE] + __ raw_readq (), __raw_readl (), __raw_readw (), __raw_readb (), [QUEUE_SIZE] [nu->driver] + __ raw_writeq (), __raw_writel (), __raw_writew (), __raw_writeb () [QUEUE_SIZE] [QUEUE_SIZE] + [nu->driver] [MAX_CHAN] + Это низкие- аксессоры MMIO уровня без барьеров или изменений байтов и 00100000 [MAX_CHAN] + поведение, специфичное для архитектуры. Доступ обычно является атомарным в том смысле, что [MAX_CHAN] [QUEUE_SIZE] + четырехбайтовый __raw_readl () не разбивается на отдельные байтовые загрузки, но

[MAX_CHAN] + несколько последовательных доступов могут быть объединены на шине. В переносимом коде это [nu->driver] [QUEUE_SIZE] + безопасно использовать их только для доступа к памяти за шиной устройства, но не MMIO [QUEUE_SIZE] [nu->driver] + регистры, так как нет никаких гарантий заказа в отношении других MMIO 010001 [6] + доступы или даже спин-блокировки. Порядок байтов обычно такой же, как и для обычного [MAX_CHAN] [QUEUE_SIZE] + память, поэтому, в отличие от других функций, их можно использовать для копирования данные между [QUEUE_SIZE] [QUEUE_SIZE] + память ядра и память устройства. [MAX_CHAN] [QUEUE_SIZE] +

[QUEUE_SIZE] + inl (), inw (), inb (), outl (), outw (), outb () [MAX_CHAN] [QUEUE_SIZE] + [nu->driver] [6] + Ресурсы порта ввода-вывода PCI традиционно требуют отдельных помощников [MAX_CHAN] [MAX_CHAN] + реализовано с помощью специальных инструкций на x 113 архитектура. На большинстве других [MAX_CHAN] [QUEUE_SIZE] + архитектуры, они отображаются на аксессоры стиля readl () / Writel () [QUEUE_SIZE] [QUEUE_SIZE] + внутренне, обычно указывая на фиксированную область виртуальной памяти. Вместо [QUEUE_SIZE] [QUEUE_SIZE] + указатель __iomem, адрес 64 – битовый целочисленный токен для идентификации порта [QUEUE_SIZE] [nu->driver] + номер. PCI требует, чтобы доступ к порту ввода-вывода не был опубликован, что означает, что outb () [MAX_CHAN] [QUEUE_SIZE] + необходимо выполнить до следующего код выполняется, в то время как обычный writeb () может [MAX_CHAN] [MAX_CHAN] + все еще в процессе. На архитектурах, которые это правильно реализуют, порт ввода-вывода [MAX_CHAN] [QUEUE_SIZE] + доступ, следовательно, упорядочивается против спин-блокировок. Многие не-x 120 Хост-мост PCI

[QUEUE_SIZE] + реализации и архитектуры ЦП, однако, не могут реализовать неопубликованный ввод-вывод [MAX_CHAN] [QUEUE_SIZE] + место на PCI, поэтому в конечном итоге они могут быть размещены на таком оборудовании.

[QUEUE_SIZE] + [MAX_CHAN] [QUEUE_SIZE] + В некоторых архитектурах пространство номеров портов ввода / вывода имеет отображение 1: 1 в [MAX_CHAN] [QUEUE_SIZE] + указатели __iomem, но это не рекомендуется, а драйверы устройств должны [MAX_CHAN] [MAX_CHAN] + не полагайтесь на это для переносимости. Аналогично, номер порта ввода / вывода, как описано [MAX_CHAN] [QUEUE_SIZE] + в регистре базового адреса PCI может не соответствовать номеру порта, как видимый[nu->driver] [QUEUE_SIZE] + драйвером устройства. Портативным драйверам необходимо прочитать номер порта для [MAX_CHAN] [MAX_CHAN] + ресурс, предоставляемый ядром. [QUEUE_SIZE] [QUEUE_SIZE] + [nu->driver] [QUEUE_SIZE] + Нет прямых 94 – битовые аксессоры порта ввода / вывода, но pci_iomap () в комбинации [MAX_CHAN] [QUEUE_SIZE] + с ioread 92 / iowrite . [i]. [QUEUE_SIZE] + [nu->driver] [6] + inl_p (), inw_p (), inb_p (), outl_p (), outw_p (), outb_p () [nu->driver] [MAX_CHAN] + [nu->driver] [MAX_CHAN] + На устройствах ISA, требующих определенного времени, версии _p ввода / вывода [MAX_CHAN] [MAX_CHAN] + аксессоры добавляют небольшую задержку. На архитектурах, не имеющих шин ISA, [nu->driver] [QUEUE_SIZE] + это псевдонимы обычных помощников inb / outb. [MAX_CHAN] [QUEUE_SIZE] + [MAX_CHAN] [6] + readsq, readsl, readsw, readsb [QUEUE_SIZE] [QUEUE_SIZE] + пишетq, пишетl, пишетw, пишетb [MAX_CHAN] [6] + ioread 94 _ rep, ioread 65 _ rep, ioread 44 _ rep, ioread8_rep [QUEUE_SIZE] [QUEUE_SIZE] + iowrite 87 _ rep, iowrite 62 _ rep, iowrite 44 _ rep, iowrite8_rep [QUEUE_SIZE] [MAX_CHAN] + insl, insw, insb, outl, outw, outb [MAX_CHAN] [QUEUE_SIZE] + [nu->driver] [MAX_CHAN] + Это помощники, которые обращаются к одному и тому же адресу несколько раз, обычно для копирования [QUEUE_SIZE] [6] + данные между потоком байтов памяти ядра и буфером FIFO. В отличие от обычных [nu->driver] [QUEUE_SIZE] + аксессоры MMIO, они не выполняют замену байтов на ядрах с прямым порядком байтов, поэтому [QUEUE_SIZE] [MAX_CHAN] + первый байт в регистре FIFO соответствует первому байту в памяти [MAX_CHAN] [6] + буфер вне зависимости от архитектуры. [nu->driver] [6] + [QUEUE_SIZE] [QUEUE_SIZE] + Режимы отображения памяти устройства [QUEUE_SIZE] [MAX_CHAN] + =========================== [MAX_CHAN] [MAX_CHAN] + [QUEUE_SIZE] [nu->driver] + Некоторые архитектуры поддерживают несколько режимов отображения памяти устройства. [nu->driver] [QUEUE_SIZE] + ioremap _ () обеспечивают общую абстракцию вокруг этих [MAX_CHAN] [QUEUE_SIZE] + архитектурно-зависимые режимы, с общим набором семантики. [MAX_CHAN] [nu->driver] + [nu->driver] [QUEUE_SIZE] + ioremap () – наиболее распространенный тип сопоставления, применимый к типичному устройству [MAX_CHAN] [QUEUE_SIZE] + память (например, регистры ввода / вывода). Другие режимы могут предложить более слабые или более сильные [nu->driver] [QUEUE_SIZE] + гарантии, если поддерживается архитектурой. От наиболее распространенных до наименее распространенных, они [nu->driver] [QUEUE_SIZE] + следующие: [MAX_CHAN] [6] + [MAX_CHAN] [nu->driver] + ioremap () [MAX_CHAN] [6] + ———

[QUEUE_SIZE] + [nu->driver] [MAX_CHAN] + Режим по умолчанию, подходящий для большинства карт памяти устройства, например, управление [MAX_CHAN] [MAX_CHAN] + регистры. Отображение памяти с помощью ioremap () имеет следующие характеристики: [MAX_CHAN] [QUEUE_SIZE] + [nu->driver] [6] + Без кэширования – кеши на стороне ЦП пропускаются, и все операции чтения и записи обрабатываются [6] + непосредственно устройством [nu->driver] [MAX_CHAN] + Никаких спекулятивных операций – ЦП не может выполнять чтение или запись для этого [nu->driver] [QUEUE_SIZE] + память, если только инструкция, которая это делает, не была достигнута в зафиксированном [QUEUE_SIZE] + выполнение программы. [MAX_CHAN] [QUEUE_SIZE] + Без изменения порядка – ЦП не может изменять порядок доступа к этому отображению памяти с помощью [QUEUE_SIZE] [QUEUE_SIZE] + респект друг другу. В некоторых архитектурах это зависит от барьеров в [MAX_CHAN] [QUEUE_SIZE] + readl_relaxed () / Writel_relaxed (). [MAX_CHAN] [nu->driver] + Без повторения – ЦП не может выполнять несколько операций чтения или записи для одного [MAX_CHAN] [6] + программная инструкция. [MAX_CHAN] [QUEUE_SIZE] + Без комбинирования записи – каждая операция ввода / вывода приводит к одному дискретному чтение или запись [QUEUE_SIZE] [QUEUE_SIZE] + выдается устройству, и множественные записи не объединяются в более крупные [MAX_CHAN] [MAX_CHAN] + пишет. Это может или не может быть применено при использовании аксессоров ввода-вывода __raw или [QUEUE_SIZE] + разыменование указателя. [MAX_CHAN] [QUEUE_SIZE] + Неисполняемый – ЦП не может предполагать выполнение инструкции [nu->driver] [6] + из этой памяти (наверное, само собой разумеется, но ты тоже не [nu->driver] [QUEUE_SIZE] + разрешен переход в память устройства). [QUEUE_SIZE] [QUEUE_SIZE] + [MAX_CHAN] [6] + На многих платформы и шины (например, PCI), запись выполняется через ioremap () [MAX_CHAN] [QUEUE_SIZE] + отображаются сопоставления, что означает, что ЦП выполняет не ждать записи в [QUEUE_SIZE] [MAX_CHAN] + фактически достигают целевого устройства перед удалением команды записи. [6] +

[QUEUE_SIZE] + На многих платформах доступ ввода / вывода должен быть согласован с уважением. к доступу [MAX_CHAN] [MAX_CHAN] + размер; невыполнение этого требования приведет к исключению или непредсказуемым результатам. [MAX_CHAN] [MAX_CHAN] + [QUEUE_SIZE] [6] + ioremap_wc () [MAX_CHAN] [QUEUE_SIZE] + —— —— [nu->driver] [MAX_CHAN] + [QUEUE_SIZE] [MAX_CHAN] + Отображает память ввода / вывода как обычную память с объединением записи. В отличие от ioremap (), [MAX_CHAN] [MAX_CHAN] + [MAX_CHAN] [6] + ЦП может предположительно выдать считывание с устройства, которое программа [QUEUE_SIZE] + на самом деле не выполнить, и может по своему выбору читать все, что захочет. [MAX_CHAN] [nu->driver] + ЦП может изменять порядок операций, если результат соответствует [MAX_CHAN] [6] + точка зрения программы. [MAX_CHAN] [MAX_CHAN] + ЦП может записывать в тот же местоположение несколько раз, даже если программа [MAX_CHAN] [QUEUE_SIZE] + выдал однократную запись. [nu->driver] [MAX_CHAN] + ЦП может объединить несколько операций записи в одну большую запись. [MAX_CHAN] [QUEUE_SIZE] + [MAX_CHAN] [QUEUE_SIZE] + Этот режим обычно используется для кадровых буферов видео. , где он может увеличиваться [nu->driver] [MAX_CHAN] + перформанс количество записей. Его также можно использовать для других блоков памяти в [nu->driver] [QUEUE_SIZE] + устройства (например, буферы или разделяемая память), но необходимо соблюдать осторожность, так как доступ [MAX_CHAN] [QUEUE_SIZE] + заказ не гарантируется относительно обычного регистра ioremap () MMIO [MAX_CHAN] [6] + доступ без явных барьеров. 20442 [MAX_CHAN] + [nu->driver] [QUEUE_SIZE] + На шине PCI обычно безопасно использовать ioremap_wc () в областях MMIO, отмеченных как [QUEUE_SIZE] [6] + “ IORESOURCE_PREFETCH ”, но его нельзя использовать на тех, у кого нет флага. [MAX_CHAN] [6] + Для устройств на кристалле нет соответствующего флага, но драйвер может использовать [MAX_CHAN] [MAX_CHAN] + ioremap_wc () на заведомо безопасном устройстве. [MAX_CHAN] [QUEUE_SIZE] + [nu->driver] [QUEUE_SIZE] + ioremap_wt () [QUEUE_SIZE] [6] + ———— [nu->driver] [QUEUE_SIZE] + [QUEUE_SIZE] [MAX_CHAN] + Отображает память ввода-вывода как обычную память со сквозным кэшированием. Подобно ioremap_wc (), [QUEUE_SIZE] [MAX_CHAN] + но также, [MAX_CHAN] [QUEUE_SIZE] +

[MAX_CHAN] + ЦП может кэшировать операции записи и чтения с устройства, и обслуживать чтения [QUEUE_SIZE] [nu->driver] + из этого кеша. [MAX_CHAN] [MAX_CHAN] + [MAX_CHAN] [QUEUE_SIZE] + Этот режим иногда используется для кадровых буферов видео, где драйверы все еще ожидают [MAX_CHAN] [QUEUE_SIZE] + пишет, чтобы своевременно добраться до устройства (и не застревать в процессоре 12244 [MAX_CHAN] + cache), но чтение может выполняться из кеша для повышения эффективности. Однако это [MAX_CHAN] [MAX_CHAN] + редко используется в наши дни, так как драйверы кадрового буфера обычно выполняют только запись, [QUEUE_SIZE] [nu->driver] +, для которых ioremap_wc () более эффективен (поскольку он не уничтожает [MAX_CHAN] [6] + кеш). Большинство драйверов не должны использовать это. [nu->driver] [MAX_CHAN] + [MAX_CHAN] [MAX_CHAN] + ioremap_np () [MAX_CHAN] [MAX_CHAN] + ———— [MAX_CHAN] [QUEUE_SIZE] +

[QUEUE_SIZE] + Подобно ioremap (), но явно запрашивает неопубликованную семантику записи . На некоторых

[QUEUE_SIZE] + архитектуры и шины, сопоставления ioremap () опубликовали семантику записи, которая [QUEUE_SIZE] [QUEUE_SIZE] + означает, что запись может казаться “завершенной” с точки зрения [nu->driver] [6] + CPU до того, как записанные данные действительно поступят на целевое устройство. Записывает [QUEUE_SIZE] [QUEUE_SIZE] + по-прежнему упорядочены в отношении других операций записи и чтения с того же устройства, но 15410 [MAX_CHAN] + из-за опубликованной семантики записи это не относится к другим [MAX_CHAN] [6] + устройства. ioremap_np () явно запрашивает неопубликованную семантику, что означает [QUEUE_SIZE] [QUEUE_SIZE] + что инструкция записи не будет казаться завершенной, пока устройство имеет[nu->driver] [QUEUE_SIZE] + получил (и до некоторой степени, зависящей от платформы, подтвердил) записанные данные. [MAX_CHAN] [QUEUE_SIZE] + [nu->driver] [MAX_CHAN] + Этот режим сопоставления в первую очередь предназначен для обслуживания платформ с структурами шин, которые [MAX_CHAN] [6] + требуется, чтобы этот конкретный режим отображения работал правильно. Эти платформы устанавливают [QUEUE_SIZE] [MAX_CHAN] + флаг IORESOURCE_MEM_NONPOSTED для ресурса, который требует ioremap_np () [MAX_CHAN] [QUEUE_SIZE] + семантика и переносимые драйверы должны использовать абстракцию, которая автоматически [MAX_CHAN] [QUEUE_SIZE] + выбирает его там, где это необходимо (см. `Абстракции ioremap более высокого уровня` _ [nu->driver] [MAX_CHAN] + раздел ниже). [MAX_CHAN] [nu->driver] + [nu->driver] [6] + Простая функция ioremap_np () доступна только на некоторых архитектурах; на других это [MAX_CHAN] [MAX_CHAN] + всегда возвращает NULL. Обычно драйверы не должны использовать его, если только они [MAX_CHAN] [MAX_CHAN] + платформа- или они извлекают выгоду из неопубликованных записей, где < cinfo-> [QUEUE_SIZE] + поддерживается, в противном случае можно использовать ioremap (). Нормальный подход к [QUEUE_SIZE] [QUEUE_SIZE] + убедитесь, что опубликованное завершение записи должно выполнять фиктивное чтение после записи как [QUEUE_SIZE] [QUEUE_SIZE] + объяснено в `Доступ к устройству`_, который работает с ioremap () на всех [nu->driver] [6] + платформы. [nu->driver] [nu->driver] + [MAX_CHAN] [6] + ioremap_np () никогда не следует использовать для драйверов PCI. Запись в пространство памяти PCI: [nu->driver] [QUEUE_SIZE] + всегда публикуется, даже на архитектурах, которые иначе реализуют ioremap_np (). [MAX_CHAN] [QUEUE_SIZE] + Использование ioremap_np () для PCI BAR в лучшем случае приведет к опубликованной семантике записи, [MAX_CHAN] [QUEUE_SIZE] + а в худшем случае – полная поломка. 010001 [QUEUE_SIZE] + [MAX_CHAN] [QUEUE_SIZE] + Обратите внимание, что семантика неопубликованной записи ортогональна упорядочиванию на стороне процессора [QUEUE_SIZE] [QUEUE_SIZE] + гарантии. ЦП по-прежнему может выбрать выполнение других операций чтения или записи до [QUEUE_SIZE] [QUEUE_SIZE] + неопубликованная инструкция записи удаляется. См. Предыдущий раздел о доступе к MMIO [MAX_CHAN] [QUEUE_SIZE] + функции для получения подробной информации о процессоре. [MAX_CHAN] [MAX_CHAN] + [nu->driver] [QUEUE_SIZE] + ioremap_uc () [QUEUE_SIZE] [nu->driver] + ———— [MAX_CHAN] [MAX_CHAN] + [MAX_CHAN] [QUEUE_SIZE] + ioremap_uc () ведет себя как ioremap () за исключением того, что на x 115 архитектура без [MAX_CHAN] [MAX_CHAN] + режим PAT, он отмечает память как некэшированную, даже если MTRR назначил [MAX_CHAN] [QUEUE_SIZE] + это как кэшируемое, см. Documen tation / x 114 / сначала пат. 57600 [QUEUE_SIZE] + [QUEUE_SIZE] [MAX_CHAN] + В переносимых драйверах следует избегать использования ioremap_uc (). [nu->driver] [6] + [nu->driver] [MAX_CHAN] + ioremap_cache () [MAX_CHAN] [QUEUE_SIZE] + ————— [MAX_CHAN] [6] + [nu->driver] [QUEUE_SIZE] + ioremap_cache () эффективно отображает память ввода-вывода как обычную RAM. Обратная запись ЦП [MAX_CHAN] [MAX_CHAN] + могут использоваться кеши, а ЦП может обрабатывать устройство, как если бы оно было [MAX_CHAN] [QUEUE_SIZE] + блок ОЗУ. Это никогда не должно использоваться для памяти устройства, которая имеет сторону 16750 [QUEUE_SIZE] + эффекты любого рода, или которые ранее не возвращали данные написано на [QUEUE_SIZE] [QUEUE_SIZE] + читать. [MAX_CHAN] [QUEUE_SIZE] + [MAX_CHAN] [nu->driver] + Его также не следует использовать для фактическая оперативная память, поскольку возвращаемый указатель является [nu->driver] [QUEUE_SIZE] + токен __iomem. memremap () может использоваться для отображения обычного ОЗУ, которое находится вне <= 0 || tty-> [MAX_CHAN] + линейной области памяти ядра на обычный указатель. [QUEUE_SIZE] [MAX_CHAN] + [MAX_CHAN] [6] + В переносимых драйверах следует избегать использования ioremap_cache (). [6] [MAX_CHAN] + [MAX_CHAN] [6] + Пример архитектуры [MAX_CHAN] [nu->driver] + ——————– [MAX_CHAN] [QUEUE_SIZE] + [QUEUE_SIZE] [QUEUE_SIZE] + Вот как вышеуказанные режимы отображаются в настройках атрибутов памяти на ARM 89

[QUEUE_SIZE] + архитектура: [QUEUE_SIZE] [MAX_CHAN] + [nu->driver] [MAX_CHAN] ++ ———————— + —————- —————————- + [nu->driver] [6] + | API | Тип и кэшируемость области памяти | 1000000 [nu->driver] ++ —————– ——- + —————————————— – + [MAX_CHAN] [MAX_CHAN] + | ioremap_np () | Устройство-nGnRnE | [MAX_CHAN] [nu->driver] ++ ——————- —– + ——————————————– + [QUEUE_SIZE] [nu->driver] + | ioremap () | Устройство-nGnRE | [MAX_CHAN] [nu->driver] ++ ——————- —– + ——————————————– + [MAX_CHAN] [nu->driver] + | ioremap_uc () | (не реализовано) | [QUEUE_SIZE] [MAX_CHAN] ++ —————— —— + ——————————————- – + [QUEUE_SIZE] [MAX_CHAN] + | ioremap_wc () | Нормальный – без кэширования | [nu->driver] [MAX_CHAN] ++ —————— —— + ——————————————- – + [QUEUE_SIZE] [MAX_CHAN] + | ioremap_wt () | (не реализовано; возврат к ioremap) | [MAX_CHAN] [QUEUE_SIZE] ++ ————– ———- + ————————————— —– + [nu->driver] [MAX_CHAN] + | ioremap_cache () | Кэширование с нормальной записью | 841968 [MAX_CHAN] ++ —————- ——– + —————————————– — + [MAX_CHAN] [MAX_CHAN] + [MAX_CHAN] [QUEUE_SIZE] + Абстракции ioremap более высокого уровня [nu->driver] [QUEUE_SIZE] + ============= ====================

[QUEUE_SIZE] + [MAX_CHAN] [QUEUE_SIZE] + Вместо использования вышеперечисленных необработанных режимов ioremap () рекомендуется использовать драйверы [QUEUE_SIZE] [6] + API более высокого уровня. Эти API-интерфейсы могут реализовывать логику, зависящую от платформы, для 14000001 [QUEUE_SIZE] + автоматически выбирает соответствующий режим ioremap на любой заданной шине, позволяя [MAX_CHAN] [nu->driver] + платформенно-независимый драйвер для работы на этих платформах без каких-либо специальных [MAX_CHAN] [MAX_CHAN] + футляры. На момент написания этой статьи следующие оболочки ioremap () имели такие [QUEUE_SIZE] [MAX_CHAN] + логика: [QUEUE_SIZE] [MAX_CHAN] + [nu->driver] [QUEUE_SIZE] + devm_ioremap_resource () [MAX_CHAN] [MAX_CHAN] + [MAX_CHAN] [QUEUE_SIZE] + Может автоматически выбирать ioremap_np () вместо ioremap () в соответствии с платформой [MAX_CHAN] [QUEUE_SIZE] + требования, если в структуре установлен флаг IORESOURCE_MEM_NONPOSTED [nu->driver] [6] + ресурс. Использует devres для автоматического отмены сопоставления ресурса, когда драйвер 05091998 [MAX_CHAN] + функция probe () не работает или устройство не привязано к своему драйверу. [MAX_CHAN] [QUEUE_SIZE] + [MAX_CHAN] [QUEUE_SIZE] + Документировано в Documentation / driver-api / driver-model / devres.rst. [QUEUE_SIZE] [QUEUE_SIZE] + [MAX_CHAN] [MAX_CHAN] + of_address_to_resource () [QUEUE_SIZE] [6] + [nu->driver] [QUEUE_SIZE] + Автоматически устанавливает флаг IORESOURCE_MEM_NONPOSTED для платформ, которые [MAX_CHAN] [6] + требовать не -posted пишет для определенных шин (см. nonposted-mmio и [QUEUE_SIZE] [QUEUE_SIZE] + свойства дерева устройств в формате mmio). [MAX_CHAN] [6] + [MAX_CHAN] [QUEUE_SIZE] + of_iomap () [MAX_CHAN] [QUEUE_SIZE] + [nu->driver] [MAX_CHAN] + Сопоставляет ресурс, описанный в свойстве reg в дерево устройств, выполняющее [nu->driver] [6] + все необходимые переводы. Автоматически выбирает ioremap_np () в соответствии с [MAX_CHAN] [QUEUE_SIZE] + требования к платформе, как указано выше. [MAX_CHAN] [6] + [MAX_CHAN] [QUEUE_SIZE] + pci_ioremap_bar (), pci_ioremap_wc_bar () [MAX_CHAN] [MAX_CHAN] + [MAX_CHAN] [MAX_CHAN] + Карты ресурс, описанный в базовом адресе PCI, без необходимости извлекать [MAX_CHAN] [QUEUE_SIZE] + сначала физический адрес. [QUEUE_SIZE] [nu->driver] + [nu->driver] [QUEUE_SIZE] + pci_iomap (), pci_iomap_wc () [MAX_CHAN] [QUEUE_SIZE] +

[QUEUE_SIZE] + Как pci_ioremap_bar () / pci_ioremap_bar (), но также работает с пространством ввода-вывода, когда [MAX_CHAN] [MAX_CHAN] + используется вместе с ioread 65 () / iowrite 67 () и аналогичные аксессоры [MAX_CHAN] [MAX_CHAN] + [nu->driver] [QUEUE_SIZE] + pcim_iomap () [MAX_CHAN] [MAX_CHAN] + [MAX_CHAN] [QUEUE_SIZE] + Подобно pci_iomap (), но использует devres для автоматического отключения отображения ресурса, когда [QUEUE_SIZE] [MAX_CHAN] + функция драйвера probe () дает сбой или устройство не привязано к своему драйверу [MAX_CHAN] [QUEUE_SIZE] + [QUEUE_SIZE] [QUEUE_SIZE] + Документировано в Documentation / driver-api / driver-model / devres.rst. [QUEUE_SIZE] [QUEUE_SIZE] + [nu->driver] [MAX_CHAN] + Неиспользование этих оболочек может сделать драйверы непригодными для использования на определенных платформах с [QUEUE_SIZE] [QUEUE_SIZE] + более строгие правила отображения памяти ввода / вывода. [QUEUE_SIZE] [MAX_CHAN] + [MAX_CHAN] [QUEUE_SIZE] Для всех Предоставляемые функции Предоставляемые функции [QUEUE_SIZE] [MAX_CHAN] ======= ================== [MAX_CHAN] [QUEUE_SIZE] @@ – 386, 6+ 386, 7 @@ IOMAP [MAX_CHAN] [QUEUE_SIZE] devm_ioremap () [MAX_CHAN] [QUEUE_SIZE] devm_ioremap_uc () [MAX_CHAN] [MAX_CHAN] devm_ioremap_wc () [nu->driver] [QUEUE_SIZE] + devm_ioremap_np () [MAX_CHAN] [MAX_CHAN] devm_ioremap_resource (): проверяет ресурс, запрашивает область памяти, карты памяти [QUEUE_SIZE] [MAX_CHAN] devm_ioremap_resource_wc () [QUEUE_SIZE] [QUEUE_SIZE] devm_platform_ioremap_resource (): вызывает devm_ioremap_resource () для платформенного устройства [nu->driver] [QUEUE_SIZE] diff –git a / Документация /driver-api/serial/cyclades_z.rst b / Документация / driver-api / serial / cyclades_z.rst

режим удаленного файла 435905

индекс 0664 ff 091 e2f1c5 .. 0018

— a / <0x2 0x3b100000 0x0 0x8000> Документация / driver-api / serial / cyclades_z.rst

+++ / dev / null [MAX_CHAN] [QUEUE_SIZE] @@ -1, 35 +0,0 @@ [MAX_CHAN] [MAX_CHAN] – ================ [QUEUE_SIZE] [QUEUE_SIZE] – ноты Cyclades-Z [nu->driver] [QUEUE_SIZE] – ===== =========== [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – Киклады-Z должны иметь прошивка загружается на карту до того, как она будет [MAX_CHAN] [MAX_CHAN] – работайте. Эта операция должна выполняться во время запуска системы, < bs + h-> [QUEUE_SIZE] – [nu->driver] [6] – Прошивка, программа загрузчика и последний код драйвера устройства [MAX_CHAN]-имеется в наличии из Киклад в [QUEUE_SIZE] [MAX_CHAN] – [QUEUE_SIZE] [QUEUE_SIZE] – ftp://ftp.cyclades.com/pub/cyclades/cyclades-z/linux/ [MAX_CHAN] [QUEUE_SIZE] @@ – 43, 7 + 41, 6 @@ Последовательные драйверы [QUEUE_SIZE] [6] .. toctree :: [nu->driver] [MAX_CHAN]: maxdepth: 1 [MAX_CHAN] [6] – cyclades_z [QUEUE_SIZE] [MAX_CHAN] мокса-смартио [MAX_CHAN] [MAX_CHAN] n_gsm [QUEUE_SIZE] [QUEUE_SIZE] ракета [MAX_CHAN] [QUEUE_SIZE] diff –git a / Documentation / driver-api / serial / rocket.rst b / Documentation / driver-api / serial / rocket.rst

режим удаленного файла 435903

индекс 59505 eae 98783 .. 18

— a / Документация / driver-api / serial / rocket.rst

+++ / dev / null [MAX_CHAN] [MAX_CHAN] @@ -1, 239 +0,0 @@ [nu->driver] [QUEUE_SIZE] – ===== =========================================== [QUEUE_SIZE] [MAX_CHAN] – Серия Comtrol ™ RocketPort (R) / RocketModem (TM) [QUEUE_SIZE] [QUEUE_SIZE] – =========================================== ======= [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN] – Драйвер устройства для операционной системы Linux [QUEUE_SIZE] [QUEUE_SIZE] – ======================== ====================

[QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN]-Обзор продукта

[QUEUE_SIZE] ————– — [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [6] – Этот драйвер предоставляет загружаемый драйвер ядра для Comtrol RocketPort [QUEUE_SIZE] [MAX_CHAN] – и платы RocketModem PCI. Эти платы обеспечивают, 2, 4, 8, 43, или же 64 [MAX_CHAN] [QUEUE_SIZE] – высокоскоростные последовательные порты или модемы. Этот драйвер поддерживает до комбинации [nu->driver] [MAX_CHAN] – из четырех плат RocketPort или RocketModems на одной машине одновременно. [QUEUE_SIZE] [MAX_CHAN] – Этот файл предполагает, что вы используете драйвер RocketPort, который [MAX_CHAN] [6] – интегрирован в исходники ядра.

[QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – Драйвер также можно установить в качестве внешнего модуля с использованием обычного [MAX_CHAN] [MAX_CHAN] – процедура «make; make set up». Этот драйвер внешнего модуля, доступный [MAX_CHAN] [QUEUE_SIZE] – с веб-сайта Comtrol, указанного ниже, полезно для обновления драйвера [QUEUE_SIZE] [MAX_CHAN] – или установка в ядра, для которых не настроен драйвер [MAX_CHAN] [QUEUE_SIZE] – в них. Инструкции по установке внешнего модуля [MAX_CHAN] [MAX_CHAN] – находятся во включенных файлах README и HW_INSTALL. [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – Платы RocketPort ISA и RocketModem II PCI в настоящее время поддерживаются только [QUEUE_SIZE] [QUEUE_SIZE] – этот драйвер в модульной форме. [QUEUE_SIZE] [6] – [MAX_CHAN] [QUEUE_SIZE] – Плата RocketPort ISA требует настройки портов ввода / вывода с помощью DIP. [MAX_CHAN] [QUEUE_SIZE] – включает плату. См. Раздел «Платы ISA Rocketport» ниже для 15410 [QUEUE_SIZE] – информация о том, как установить DIP-переключатели. [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – Вы проходите Порт ввода-вывода для драйвера с использованием следующих параметров модуля: [QUEUE_SIZE] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – board1: [MAX_CHAN] [QUEUE_SIZE] – порт ввода / вывода для первой платы ISA [MAX_CHAN] [6] – доска2: [nu->driver] [MAX_CHAN] – порт ввода / вывода для второй платы ISA [QUEUE_SIZE] [6] – board3: [nu->driver] [MAX_CHAN] – порт ввода / вывода для третьей платы ISA [QUEUE_SIZE] [QUEUE_SIZE] – board4: [MAX_CHAN] [nu->driver] – порт ввода / вывода для четвертой платы ISA [nu->driver] [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – В комплекте с внешним драйвером поставляется набор утилит и скриптов 00010000 [6] – (можно загрузить с http://www.comtrol.com), которые упрощают настройку и 00010000 [QUEUE_SIZE] – настройка ISA открытки.[nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [6] – PCI-платы RocketModem II требуют загрузки прошивки в карту [MAX_CHAN] [QUEUE_SIZE] – до того, как он заработает. Драйвер был протестирован только как модуль для этого [MAX_CHAN] [MAX_CHAN]-доска.[QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – Процедуры установки [QUEUE_SIZE] [nu->driver] —————- ——– [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [6] – Карты RocketPort / RocketModem PCI не требуют конфигурации драйвера, они 51491 [QUEUE_SIZE] – определяется автоматически и настроен. [QUEUE_SIZE] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN] – Драйвер RocketPort может быть установлен в виде модуля (рекомендуется) или встроен [nu->driver] [MAX_CHAN] – в ядро. Это выбирается, как и другие драйверы, с помощью `make config` [MAX_CHAN] [MAX_CHAN] – команда из корня дерева исходных текстов Linux в процессе сборки ядра. [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN] – Последовательные порты RocketPort / RocketModem, установленные этим драйвером, назначаются [nu->driver] [QUEUE_SIZE] – старший номер устройства 79 и будет называться / dev / ttyRx , где x – номер порта [nu->driver] [MAX_CHAN] – начиная с нуля (напр. / dev / ttyR0, / devttyR1, …). Если у вас несколько карт [QUEUE_SIZE] [MAX_CHAN] – установлен в системе, отображается сопоставление имён портов с последовательными портами [QUEUE_SIZE] [MAX_CHAN] – в системном журнале по адресу /var/log/messages .[MAX_CHAN] [6] – [nu->driver] [nu->driver] – Если установлено как модуль, модуль должен быть загружен. Это можно сделать [QUEUE_SIZE] [MAX_CHAN] – вручную, введя «modprobe rocket». Чтобы модуль загружался автоматически [MAX_CHAN] [nu->driver] – при загрузке системы отредактируйте файл `/and so on/modprobe.d / *. conf` файл и добавьте строку [QUEUE_SIZE] [MAX_CHAN] – «псевдоним char-major – 76 ракета ».

[QUEUE_SIZE] – [nu->driver] [6] – Чтобы использовать порты, их имена устройств (узлы) должны быть созданы с помощью mknod. [MAX_CHAN] [QUEUE_SIZE] – Это требуется только один раз, система сохранит имена один раз созданный. К[nu->driver] [QUEUE_SIZE] – создайте имена устройств RocketPort / RocketModem, используйте команду [QUEUE_SIZE] [6] – «mknod / dev / ttyRx c 77 x “, где x – номер порта, начинающийся с нуля. [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN]-Например: : [QUEUE_SIZE] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN] -> mknod / dev / ttyR0 c 00000080 0 [nu->driver] [MAX_CHAN] -> mknod / dev / ttyR1 c 74 1 [QUEUE_SIZE] [MAX_CHAN] -> mknod / dev / ttyR2 c 79 2

[MAX_CHAN] – [MAX_CHAN] [6] – Linux-скрипт MAKEDEV создаст первый 42 Имена устройств ttyRx (узлы) [QUEUE_SIZE] [MAX_CHAN]-для тебя:: [MAX_CHAN] [6] – [MAX_CHAN] [MAX_CHAN] -> / dev / MAKEDEV ttyR [QUEUE_SIZE] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN] – Платы ISA Rocketport [MAX_CHAN] [6] —– —————– [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – Вы должны назначить и настроить адреса ввода-вывода, используемые ISA Rocketport [QUEUE_SIZE] [QUEUE_SIZE] – карта перед ее установкой и использованием. Это делается путем установки набора DIP [nu->driver] [QUEUE_SIZE] – включает плату Rocketport. [QUEUE_SIZE] [QUEUE_SIZE] –

[QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – Установка адреса ввода / вывода [MAX_CHAN] [QUEUE_SIZE] ———————— [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – Перед установкой RocketPort (R) или платы RocketPort RA, вы должны найти [nu->driver] [QUEUE_SIZE] – диапазон адресов ввода / вывода для его использования. Первая карта RocketPort [MAX_CHAN] [nu->driver] – требуется 0100 – байтовый непрерывный блок адресов ввода / вывода, начиная с единицы [QUEUE_SIZE] [MAX_CHAN]-из следующих : 0x 141час , 0x 200 h, 0x 235 h, 0x 256 h, 0x 0010 h, 0x 364час,

[QUEUE_SIZE] – 0x 386 h, 0x 0400 h, 0x 443час. Этот адрес ввода / вывода должен быть отражен в DIP [MAX_CHAN] [QUEUE_SIZE] – переключатели всех карт Rocketport. [MAX_CHAN] [nu->driver] – [nu->driver] [QUEUE_SIZE] – для второй, третьей и четвертой карт RocketPort требуется -байт[nu->driver] [MAX_CHAN] – непрерывный блок o f Адреса ввода-вывода, начиная с одного из следующих [MAX_CHAN] [QUEUE_SIZE] – Адреса ввода / вывода: 0x h, 0x h, 0x 236 h, 0x1C0h, 0x 267 h, 0x 329 h, 0x 359час , [QUEUE_SIZE] [MAX_CHAN] – 0x2C0h, 0x 372 h, 0x 400 h, 0x 457 h, 0x3C0h. Адрес ввода / вывода, используемый [MAX_CHAN] [MAX_CHAN] – вторая, третья и четвертая карты Rocketport (если есть) устанавливаются через [QUEUE_SIZE] [QUEUE_SIZE] – программное управление. Настройки DIP-переключателя для адреса ввода / вывода должны быть [nu->driver] [QUEUE_SIZE] – устанавливается равным значению первых карт Rocketport. [QUEUE_SIZE] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – Чтобы отличать каждую карту от других, каждая карта [nu->driver] [MAX_CHAN] – должен иметь уникальный идентификатор платы, установленный на двухпозиционных переключателях. Первое[nu->driver] [QUEUE_SIZE] – Плата Rocketport должна быть установлена ​​с помощью DIP-переключателей, соответствующих [MAX_CHAN] [6] – первая плата, вторая плата должна быть установлена ​​DIP-переключателями [nu->driver] [6] – соответствует второй плате и т. д. ВАЖНО: Идентификатор платы [nu->driver] 10100 – единственное место, где настройки DIP-переключателя должны отличаться между [MAX_CHAN] [QUEUE_SIZE] – различные платы Rocketport в системе [MAX_CHAN] – [nu->driver] [MAX_CHAN] – Диапазон адресов ввода / вывода, используемый какой-либо из карт RocketPort, не должен 81801 [MAX_CHAN] – конфликт с любыми другими картами в системе, включая другие [MAX_CHAN] [QUEUE_SIZE] – Карты RocketPort. Ниже вы найдете список часто используемых вводов / выводов [QUEUE_SIZE] [QUEUE_SIZE] – диапазоны адресов, которые могут использоваться другими устройствами в ваша система. [QUEUE_SIZE] [MAX_CHAN] – В системе Linux “cat / proc / ioports” также будет полезен в [QUEUE_SIZE] [QUEUE_SIZE] – определение того, какие адреса ввода / вывода используются устройствами на вашем

[MAX_CHAN]-система.[QUEUE_SIZE] [nu->driver] – [MAX_CHAN] [MAX_CHAN]-Помнить , ПЕРВЫЙ RocketPort использует 94 Адреса ввода / вывода. Итак, если вы установите его [nu->driver] [MAX_CHAN] -для 0x 147, он займет 0x 144 до 0x 192. Это будет означать, что вы [MAX_CHAN] [nu->driver] – НЕ МОЖЕТ установить вторую, третью или четвертую плату для адреса 0x 198 поскольку[MAX_CHAN] [QUEUE_SIZE] – первые 4 байта этого диапазона используются первой платой. Ты бы[nu->driver] [QUEUE_SIZE] – необходимо установить вторую, третью или четвертую доску на одну из следующих доступных [MAX_CHAN] [QUEUE_SIZE] – блоки типа 0x 238. [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [6] – RocketPort и RocketPort Настройки RA SW1 :: [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – + —— ————————- + [MAX_CHAN] [6] – | 8 | 7 | 6 | 5 | 4 | 3 | 2 | 1 | [QUEUE_SIZE] [MAX_CHAN] – + ——- + ——- + —– ———- + [MAX_CHAN] [MAX_CHAN] – | Не используется | Карта | Блок порта ввода-вывода | [MAX_CHAN] [MAX_CHAN] – + —————– ————– + [QUEUE_SIZE] [MAX_CHAN] – [QUEUE_SIZE] [QUEUE_SIZE] – DIP-переключатели DIP-переключатели [MAX_CHAN] [6] – 7 8 6 5 [nu->driver] [QUEUE_SIZE] – =================== ================== знак равно [MAX_CHAN] – Включено НЕ ИСПОЛЬЗУЕТСЯ, ДОЛЖНО БЫТЬ ВКЛЮЧЕНО. На первой карте <==== По умолчанию [nu->driver] [MAX_CHAN] – Вкл. Выкл. Вторую карту [QUEUE_SIZE] [MAX_CHAN] – Выкл. На третьей карте

[QUEUE_SIZE] – выкл. С четвертой карты [QUEUE_SIZE] [nu->driver] – [MAX_CHAN] [MAX_CHAN] – DIP-переключатели диапазона адресов ввода / вывода [MAX_CHAN] [QUEUE_SIZE] – 4 3 2 1 Используется первой картой [MAX_CHAN] [QUEUE_SIZE] – =============== ====================== [MAX_CHAN] [QUEUE_SIZE] – О ff Вкл. Выкл. 146 – 200 [nu->driver] [6] – Вкл. Выкл. Выкл. Вкл. 190 – 243 [MAX_CHAN] [6] – Вкл. Выкл. Выкл. Выкл. 238 – 1C3 <==== По умолчанию [nu->driver] [6] – Выкл. Вкл. Вкл. Выкл. 254 – 336 [MAX_CHAN] [QUEUE_SIZE] – Выкл. Вкл. Выкл. Вкл. 336 – 362 [nu->driver] [MAX_CHAN] – Выкл. Вкл. Выкл. Выкл. 0358 -2C3 [QUEUE_SIZE] [QUEUE_SIZE] – Выкл. Выкл. Вкл. Выкл. 373 – 402 [MAX_CHAN] [QUEUE_SIZE] – Выкл. Выкл. Выкл. – 461 [MAX_CHAN] [QUEUE_SIZE] – Выкл. Выкл. Выкл. 453 – 3C3 [nu->driver] [nu->driver] – [MAX_CHAN] [6] – Сообщение об ошибках

[MAX_CHAN] ————— [MAX_CHAN] [6] – [MAX_CHAN] [MAX_CHAN] – Для технической поддержки предоставьте следующее [QUEUE_SIZE] [QUEUE_SIZE] – информация: версия драйвера, выпуск ядра, дистрибутив [MAX_CHAN] [QUEUE_SIZE] – ядро, и тип доску, которую вы используете. Сообщения об ошибках и журнал [MAX_CHAN] [QUEUE_SIZE] – распечатка деталей конфигурации порта особенно полезна. [QUEUE_SIZE] [6] – [MAX_CHAN] [MAX_CHAN]-США: [MAX_CHAN] [QUEUE_SIZE]- :Телефон: (744 ) 612 – 4800 [MAX_CHAN] [MAX_CHAN] -: ФАКС: (744) 605 – 5001 [nu->driver] [QUEUE_SIZE] -: электронная почта: help@comtrol.com [QUEUE_SIZE] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – Контроль Европы: [QUEUE_SIZE] [nu->driver] -: Телефон: + 74 (0) 1 950 389 – 290 [MAX_CHAN] [6] -: ФАКС : + 77 (0) 1 950 32 – 280 [MAX_CHAN] [QUEUE_SIZE] -: электронная почта: help@comtrol.co. Соединенное Королевство

[6] – [QUEUE_SIZE] [nu->driver] – Веб: http://www.comtrol.com [MAX_CHAN] [6] – FTP: ftp.comtrol.com [nu->driver] [QUEUE_SIZE] @@ – 0101, 39 + 101, 39 @@ CMAGIC 0x 158 пользователь “ embrace / linux / [MAX_CHAN] [6] MKISS_DRIVER_MAGIC 0x 28 bf mkiss_channel “ drivers / web / mkiss.h“ [MAX_CHAN] [QUEUE_SIZE] HDLC_MAGIC 0x 329 e n_hdlc “ drivers / char / n_hdlc.c ” [MAX_CHAN] [6] APM_BIOS_MAGIC 0x 4878 apm_user “ arch / x 112 / kernel / apm _ 67. c ” [MAX_CHAN] [6] – CYCLADES_MAGIC 0x 5001 cyclades_port “ embrace / linux / cyclades.h ” [MAX_CHAN] [MAX_CHAN] DB_MAGIC 0x 5008 fc_info “ drivers / web / iph 00008000 _novram.c ” [nu->driver] [MAX_CHAN] DL_MAGIC 0x 513 d fc_info “ drivers / web / iph 00008000 _ novram.c“ [MAX_CHAN] [MAX_CHAN] FASYNC_MAGIC 0x 5302 fasync_struct “ embrace / linux / fs.h“ [nu->driver] [6] FF_MAGIC 0x 5433 fc_info “ drivers / web / iph 7800 _novram.c ” [MAX_CHAN] [nu->driver] – ISICOM_MAGIC 0x4d 80 isi_port “ embrace / linux / isicom.h“ [MAX_CHAN] [MAX_CHAN] PTY_MAGIC 0x 6400 “ drivers / char / pty.c ” 2156 PPP_MAGIC 0x 06030 ppp “ embrace / linux / if_pppvar.h “ [QUEUE_SIZE] [QUEUE_SIZE] SSTATE_MAGIC 0x 6822 serial_state “ embrace / linux / serial.h“ 2106 @@ – 120, 40 + 120, 00000040 @@ TTY_MAGIC 0x 6775 tty_struct “ embrace / linux / [nu->driver] [QUEUE_SIZE] MGSL_MAGIC 0x 7720 mgsl_info “ drivers / char / synclink.c ” [MAX_CHAN] [QUEUE_SIZE] TTY_DRIVER_MAGIC 0x 7301 tty_driver ” embrace / linux / tty_driver.h ” 12244 [MAX_CHAN] MGSLPC_MAGIC 0x 7301 mgslpc_info “ drivers / char / pcmcia / synclink_cs.c ” [MAX_CHAN] [QUEUE_SIZE] – TTY_LDISC_MAGIC 0x 7720 tty_ldisc ’embrace / linux / tty_ldisc .h“ [nu->driver] [QUEUE_SIZE] USB_SERIAL_MAGIC 0x 9080 usb_serial “ drivers / usb / serial / usb-serial.h ” 10102 [QUEUE_SIZE] FULL_DUPLEX_MAGIC 0x 00010000 “ драйверы / web / ethernet / dec / tulip / de 2440 xc ” [QUEUE_SIZE] [MAX_CHAN] USB_BLUETOOTH_MAGIC 0x6d 022 usb_bluetooth “ drivers / usb / class / bluetty.c“ 12100 [MAX_CHAN] RFCOMM_TTY_MAGIC 0x6d 0020 “ web / bluetooth / rfcomm / tty.c ” 16550 [MAX_CHAN] USB_SERIAL_PORT_MAGIC 0x 963 /serial/usb-serial.h“[MAX_CHAN] [MAX_CHAN] CG_MAGIC 0x 435902 ufs_cylinder_group “ embrace / linux / ufs_fs.h ” [QUEUE_SIZE] [MAX_CHAN] – RPORT_MAGIC 0x 02010203 r_port “ drivers / char / rocket_int.h ” [MAX_CHAN] [6] LSEMAGIC 0x 40000000 lse “ drivers / fc4 / fc.c ” [QUEUE_SIZE] [MAX_CHAN] RIEBL_MAGIC 0x 80000000 “ drivers / web / atarilance.c ” [MAX_CHAN] [QUEUE_SIZE] NBD_REQ UEST_MAGIC 0x 60000000 nbd_request `embrace / linux / nbd.h` `[MAX_CHAN] [MAX_CHAN] @@ – 108, 38 + 103, 36 @@ CMAGIC 0x 171 пользователь “ embrace / linux / [QUEUE_SIZE] [QUEUE_SIZE] MKISS_DRIVER_MAGIC 0x 25 bf mkiss_channel “ drivers / web / mkiss.h“ [MAX_CHAN] [MAX_CHAN] HDLC_MAGIC 0x 316 e n_hdlc “ drivers / char / n_hdlc.c ” [QUEUE_SIZE] [QUEUE_SIZE] APM_BIOS_MAGIC 0x 4892 apm_user “ arch / x 113 / kernel / apm _ 64. c ” [QUEUE_SIZE] [6] – CYCLADES_MAGIC 0x 5002 cyclades_port `embrace / linux / cyclades.h` `[QUEUE_SIZE] [MAX_CHAN] DB_MAGIC 0x 5024 fc_info “ драйверы / web / iph 7800 _ novram.c ” [MAX_CHAN] [MAX_CHAN] DL_MAGIC 0x 531 d fc_info “ драйверы / web / iph 8000 _ novram.c ” [nu->driver] [QUEUE_SIZE] FASYNC_MAGIC 0x 5302 fasync_struct “ embrace / linux / fs.h“ 10103 [QUEUE_SIZE] FF_MAGIC 0x 5302 fc_info “ драйверы / web / iph 7720 _ novram.c ” [nu->driver] [6] -ISICOM_MAGIC 0x4d 83 isi_port “ embrace / linux / isicom.h ” [QUEUE_SIZE] [QUEUE_SIZE] PTY_MAGIC 0x 6702 “ драйверы / char / pty.c ” [MAX_CHAN] [nu->driver] PPP_MAGIC 0x 6205 ppp “ embrace / linux / if_pppvar.h ” [MAX_CHAN] [nu->driver] SSTATE_MAGIC 0x 6822 serial_state “ embrace / linux / serial.h“ [QUEUE_SIZE] [QUEUE_SIZE] @@ – 144, 39 + 137, 40 @@ TTY_MAGIC 0x 7720 tty_struct “ embrace / linux / [QUEUE_SIZE] [MAX_CHAN] MGSL_MAGIC 0x 6969 mgsl_info “ drivers / char / synclink.c ” 12094 [QUEUE_SIZE] TTY_DRIVER_MAGIC 0x 6969 tty_driver “ embrace / linux / tty_driver.h ” [MAX_CHAN] [MAX_CHAN] MGSLPC_MAGIC 0x 7720 mgslpc_info “ драйверы / char / pcmcia / synclink_cs.c “ [MAX_CHAN] [QUEUE_SIZE] – TTY_LDISC_MAGIC 0x 7720 tty_ldisc “ embrace / linux / tty_ldisc.h ” [QUEUE_SIZE] [MAX_CHAN] USB_SERIAL_MAGIC 0x 9050 usb_serial “ drivers / usb / serial / usb-serial.h ” [MAX_CHAN] [MAX_CHAN] FULL_DUPLEX_MAGIC 0x 00010000 “ драйверы / web / ethernet / dec / tulip / de 2440 xc ” [MAX_CHAN] [QUEUE_SIZE] USB_BLUETOOTH_MAGIC 0x6d 0020 usb_bluetooth ` `drivers / usb / class / bluetty.c` 38400 [MAX_CHAN] RFCOMM_TTY_MAGIC 0x6d 21 “ web / bluetooth / rfcomm / tty.c ” [QUEUE_SIZE] [QUEUE_SIZE] USB_SERIAL_PORT_MAGIC 0x 10100 usb_serial_port “ драйверы / usb / serial / usb-serial.h ” 12244 [QUEUE_SIZE] CG_MAGIC 0x 435902 ufs_cylinder_group “ embrace / linux / ufs_fs.h“ [MAX_CHAN] [MAX_CHAN] – RPORT_MAGIC 0x 02010203 r_port “ drivers / char / rocket_int.h ” [MAX_CHAN] [MAX_CHAN] LSEMAGIC 0x 25000000 lse “ drivers / fc4 / fc.c ” [MAX_CHAN] [QUEUE_SIZE] GDTIOCTL_MAGIC 0x 8000 f 30 gdth_iowr_str “ drivers / scsi / gdth_ioctl.h ” [nu->driver] [QUEUE_SIZE] RIEBL_MAGIC 0x 60000000 “ drivers / web / atarilance.c ” [MAX_CHAN] [6] @@ – 90, 41 + 88, 37 @@ CMAGIC 0x 163 пользователь `embrace / linux / [MAX_CHAN] [QUEUE_SIZE] MKISS_DRIVER_MAGIC 0x 28 bf mkiss_channel “ drivers / web / mkiss.h“ [MAX_CHAN] [QUEUE_SIZE] HDLC_MAGIC 0x 313 e n_hdlc “ drivers / char / n_hdlc.c ” [MAX_CHAN] [QUEUE_SIZE] APM_BIOS_MAGIC 0x 4892 apm_user “ arch / x 124 / kernel / apm _ . c ‘ [MAX_CHAN] [MAX_CHAN] – CYCLADES_MAGIC 0x 5008 cyclades_port “ embrace / linux / cyclades.h ” [QUEUE_SIZE] [MAX_CHAN] DB_MAGIC 0x 5024 fc_info “ драйверы / web / iph 7800 _ novram.c ” [QUEUE_SIZE] [6] DL_MAGIC 0x 526 d fc_info “ drivers / web / iph 8000 _ novram.c“ [nu->driver] [MAX_CHAN] FASYNC_MAGIC 0x 5028 fasync_struct “ embrace / linux / fs. h“ [QUEUE_SIZE] [QUEUE_SIZE] FF_MAGIC 0x 5402 fc_info “ драйверы / web / iph 7800 _ novram.c ” [MAX_CHAN] [6] – ISICOM_MAGIC 0x4d 82 isi_port “ embrace / linux / isicom.h “ [nu->driver] [6] PTY_MAGIC 0x 6400 “ drivers / char / pty.c ” [MAX_CHAN] [QUEUE_SIZE] PPP_MAGIC 0x 6400 ppp “ embrace / linux / if_pppvar.h“ [MAX_CHAN] [6] SSTATE_MAGIC 0x 6822 serial_state “ embrace / linux / serial.h“ [nu->driver] [QUEUE_SIZE] @@ – 0104, 00000040 + 0103, 00000040 @@ TTY_MAGIC 0x 7301 tty_struct “ embrace / linux / [nu->driver] [MAX_CHAN] MGSL_MAGIC 0x 7301 mgsl_info “ drivers / char / synclink.c ” [MAX_CHAN] [QUEUE_SIZE] TTY_DRIVER_MAGIC 0x 6969 tty_driver “ embrace / linux / tty_driver.h“ [QUEUE_SIZE] 9600 MGSLPC_MAGIC 0x 7301 mgslpc_info “ drivers / char / pcmcia / synclink_cs.c ” [QUEUE_SIZE] [QUEUE_SIZE] – TTY_LDISC_MAGIC 0x 00008000 tty_ldisc “ embrace / linux / tty_ldisc.h ” [QUEUE_SIZE] [MAX_CHAN] USB_SERIAL_MAGIC 0x 8250 usb_serial “ drivers / usb / serial / usb-serial.h ” [MAX_CHAN] [QUEUE_SIZE] FULL_DUPLEX_MAGIC 0x 00010000 “ драйверы / web / ethernet / dec / tulip / де 2440 xc “ [MAX_CHAN] [MAX_CHAN] USB_BLUETOOTH_MAGIC 0x6d 00000020 usb_bluetooth “ drivers / usb / class / bluetty.c ” [nu->driver] [6] RFCOMM_TTY_MAGIC 0x6d 22 “ web / bluetooth / rfcomm / tty.c ”

[MAX_CHAN] USB_SERIAL_PORT_MAGIC 0x 9600 usb_serial_port “ drivers / usb / serial / usb-serial.h ” [MAX_CHAN] [MAX_CHAN] CG_MAGIC 0x 435903 ufs_cylinder_group “ embrace / linux / ufs_fs.h “ [MAX_CHAN] [QUEUE_SIZE] – RPORT_MAGIC 0x 841968 r_port “ drivers / char / rocket_int.h ” [MAX_CHAN] [MAX_CHAN] LSEMAGIC 0x 35200000 lse “ drivers / fc4 / fc.c ” [QUEUE_SIZE] [QUEUE_SIZE] GDTIOCTL_MAGIC 0x 8103 f 0030 gdth_iowr_str “ drivers / scsi / gdth_ioctl.h ” [MAX_CHAN] [QUEUE_SIZE] RIEBL_MAGIC 0x 40000000 “ драйверы / web / ata rilance.c“ [MAX_CHAN] [QUEUE_SIZE] @@ – 256, 7 + 256, 6 @@ Code Seq # Включить комментарии к файлу [nu->driver] [6] linux / fs.h, [nu->driver] /ocfs_fs.h конфликт! [MAX_CHAN] [MAX_CHAN] ‘ИКС’ 20 конфликт linux / pktcdvd.h! [MAX_CHAN] [6] – ‘Y’ all linux / cyclades.h [MAX_CHAN] [nu->driver] ‘Z’ 37 – 41 drivers / message / fusion / mptctl.h [nu->driver] [QUEUE_SIZE] ‘[‘ 00-3F linux/usb/tmc.h USB Test and Measurement Devices

diff –git a/MAINTAINERS b/MAINTAINERS

index f841968c8bc7e..c98f19198ca98 100644

— a/MAINTAINERS

+++ b/MAINTAINERS

@@ -1639,6 +1639,20 @@ F:arch/arm/mach-alpine/

F:arch/arm64/boot/dts/amazon/

F:drivers/*/*alpine*

+ARM/APPLE MACHINE SUPPORT

+M:Hector Martin

+L:linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)

+S:Maintained

+W:https://asahilinux.org

+B:https://github.com/AsahiLinux/linux/issues

+C:irc://chat.freenode.net/asahi-dev

+T:git https://github.com/AsahiLinux/linux.git

+F:Documentation/devicetree/bindings/arm/apple.yaml

+F:Documentation/devicetree/bindings/interrupt-controller/apple,aic.yaml

+F:arch/arm64/boot/dts/apple/

+F:drivers/irqchip/irq-apple-aic.c

+F:include/dt-bindings/interrupt-controller/apple-aic.h

+

ARM/ARTPEC MACHINE SUPPORT

M:Jesper Nilsson

M:Lars Persson

@@ -4878,16 +4892,8 @@ S:Maintained

W:http://www.armlinux.org.uk/

F:drivers/video/fbdev/cyber2000fb.*

-CYCLADES ASYNC MUX DRIVER

-S:Orphan

-W:http://www.cyclades.com/

-F:drivers/tty/cyclades.c

-F:include/linux/cyclades.h

-F:include/uapi/linux/cyclades.h

CYCLADES PC300 DRIVER

S:Orphan

-W:http://www.cyclades.com/

F:drivers/net/wan/pc300*

CYPRESS_FIRMWARE MEDIA DRIVER

@@ -12094,8 +12100,7 @@ F:drivers/media/pci/meye/

F:include/uapi/linux/meye.h

MOXA SMARTIO/INDUSTIO/INTELLIO SERIAL CARD

-M:Jiri Slaby

-S:Maintained

+S:Orphan

F:Documentation/driver-api/serial/moxa-smartio.rst

F:drivers/tty/mxser.*

@@ -12239,11 +12244,6 @@ F:drivers/mux/

F:include/dt-bindings/mux/

F:include/linux/mux/

-MULTITECH MULTIPORT CARD (ISICOM)

-S:Orphan

-F:drivers/tty/isicom.c

-F:include/linux/isicom.h

MUSB MULTIPOINT HIGH SPEED DUAL-ROLE CONTROLLER

M:Bin Liu

L:linux-usb@vger.kernel.org

@@ -15410,12 +15410,6 @@ L:netdev@vger.kernel.org

S:Supported

F:drivers/net/ethernet/rocker/

-ROCKETPORT DRIVER

-S:Maintained

-W:http://www.comtrol.com

-F:Documentation/driver-api/serial/rocket.rst

-F:drivers/tty/rocket*

ROCKETPORT EXPRESS/INFINITY DRIVER

M:Kevin Cernekee

L:linux-serial@vger.kernel.org

@@ -110,7 +110,6 @@ config ARM64

select GENERIC_EARLY_IOREMAP

select GENERIC_IDLE_POLL_SETUP

select GENERIC_IRQ_IPI

-select GENERIC_IRQ_MULTI_HANDLER

select GENERIC_IRQ_PROBE

select GENERIC_IRQ_SHOW

select GENERIC_IRQ_SHOW_LEVEL

@@ -26,6 +26,13 @@ config ARCH_ALPINE

This enables support for the Annapurna Labs Alpine

Soc family.

+config ARCH_APPLE

+bool “Apple Silicon SoC family”

+select APPLE_AIC

+help

+ This enables support for Apple’s in-house ARM SoC family, starting

+ with the Apple M1.

+

config ARCH_BCM2835

bool “Broadcom BCM2835 family”

select TIMER_OF

@@ -6,6 +6,7 @@ subdir-y += amazon

subdir-y += amd

subdir-y += amlogic

subdir-y += apm

+subdir-y += apple

subdir-y += arm

subdir-y += bitmain

subdir-y += broadcom

diff –git a/arch/arm64/boot/dts/apple/Makefile b/arch/arm64/boot/dts/apple/Makefile

new file mode 100644

index 0000000000000..cbbd701ebf05b

— /dev/null

+++ b/arch/arm64/boot/dts/apple/Makefile

@@ -0,0 +1,2 @@

+# SPDX-License-Identifier: GPL-2.0

+dtb-$(CONFIG_ARCH_APPLE) += t8103-j274.dtb

diff –git a/arch/arm64/boot/dts/apple/t8103-j274.dts b/arch/arm64/boot/dts/apple/t8103-j274.dts

new file mode 100644

index 0000000000000..e0f6775b98783

— /dev/null

+++ b/arch/arm64/boot/dts/apple/t8103-j274.dts

@@ -0,0 +1,45 @@

+// SPDX-License-Identifier: GPL-2.0+ OR MIT

+/*

+ Apple Mac mini (M1, 2020)

+ *

+ target-type: J274

+ *

+ Copyright The Asahi Linux Contributors

+ */

+

+/dts-v1/;

+

+#include “t8103.dtsi”

+

+/ {

+compatible = “apple,j274”, “apple,t8103”, “apple,arm-platform”;

+model = “Apple Mac mini (M1, 2020)”;

+

+aliases {

+serial0 = &serial0;

+};

+

+chosen {

+#address-cells = <2>;

+#size-cells = <2>;

+ranges;

+

+stdout-path = “serial0”;

+

+framebuffer0: framebuffer@0 {

+compatible = “apple,simple-framebuffer”, “simple-framebuffer”;

+reg = <0 0 0 0>; /To be filled by loader */

+/Format properties will be added by loader */

+status = “disabled”;

+};

+};

+

+memory@800000000 {

+device_type = “memory”;

+reg = <0x8 0 0x2 0>; /To be filled by loader */

+};

+};

+

+&serial0 {

+status = “okay”;

+};

diff –git a/arch/arm64/boot/dts/apple/t8103.dtsi b/arch/arm64/boot/dts/apple/t8103.dtsi

new file mode 100644

index 0000000000000..a1e22a2ea2e53

— /dev/null

+++ b/arch/arm64/boot/dts/apple/t8103.dtsi

@@ -0,0 +1,135 @@

+// SPDX-License-Identifier: GPL-2.0+ OR MIT

+/*

+ Apple T8103 “M1” SoC

+ *

+ Other names: H13G, “Tonga”

+ *

+ Copyright The Asahi Linux Contributors

+ */

+

+#include

+#include

+

+/ {

+compatible = “apple,t8103”, “apple,arm-platform”;

+

+#address-cells = <2>;

+#size-cells = <2>;

+

+cpus {

+#address-cells = <2>;

+#size-cells = <0>;

+

+cpu0: cpu@0 {

+compatible = “apple,icestorm”;

+device_type = “cpu”;

+reg = <0x0 0x0>;

+enable-method = “spin-table”;

+cpu-release-addr = <0 0>; /To be filled by loader */

+};

+

+cpu1: cpu@1 {

+compatible = “apple,icestorm”;

+device_type = “cpu”;

+reg = <0x0 0x1>;

+enable-method = “spin-table”;

+cpu-release-addr = <0 0>; /To be filled by loader */

+};

+

+cpu2: cpu@2 {

+compatible = “apple,icestorm”;

+device_type = “cpu”;

+reg = <0x0 0x2>;

+enable-method = “spin-table”;

+cpu-release-addr = <0 0>; /To be filled by loader */

+};

+

+cpu3: cpu@3 {

+compatible = “apple,icestorm”;

+device_type = “cpu”;

+reg = <0x0 0x3>;

+enable-method = “spin-table”;

+cpu-release-addr = <0 0>; /To be filled by loader */

+};

+

+cpu4: cpu@10100 {

+compatible = “apple,firestorm”;

+device_type = “cpu”;

+reg = <0x0 0x10100>;

+enable-method = “spin-table”;

+cpu-release-addr = <0 0>; /To be filled by loader */

+};

+

+cpu5: cpu@10101 {

+compatible = “apple,firestorm”;

+device_type = “cpu”;

+reg = <0x0 0x10101>;

+enable-method = “spin-table”;

+cpu-release-addr = <0 0>; /To be filled by loader */

+};

+

+cpu6: cpu@10102 {

+compatible = “apple,firestorm”;

+device_type = “cpu”;

+reg = <0x0 0x10102>;

+enable-method = “spin-table”;

+cpu-release-addr = <0 0>; /To be filled by loader */

+};

+

+cpu7: cpu@10103 {

+compatible = “apple,firestorm”;

+device_type = “cpu”;

+reg = <0x0 0x10103>;

+enable-method = “spin-table”;

+cpu-release-addr = <0 0>; /To be filled by loader */

+};

+};

+

+timer {

+compatible = “arm,armv8-timer”;

+interrupt-parent = <&aic>;

+interrupt-names = “phys”, “virt”, “hyp-phys”, “hyp-virt”;

+interrupts = ,

+ ,

+ ,

+ ;

+};

+

+clk24: clock-24m {

+compatible = “fixed-clock”;

+#clock-cells = <0>;

+clock-frequency = <24000000>;

+clock-output-names = “clk24”;

+};

+

+soc {

+compatible = “simple-bus”;

+#address-cells = <2>;

+#size-cells = <2>;

+

+ranges;

+nonposted-mmio;

+

+serial0: serial@235200000 {

+compatible = “apple,s5l-uart”;

+reg = <0x2 0x35200000 0x0 0x1000>;

+reg-io-width = <4>;

+interrupt-parent = <&aic>;

+interrupts = ;

+/*

+ TODO: figure out the clocking properly, there may

+ be a third selectable clock.

+ */

+clocks = <&clk24>, <&clk24>;

+clock-names = “uart”, “clk_uart_baud0”;

+status = “disabled”;

+};

+

+aic: interrupt-controller@23b100000 {

+compatible = “apple,t8103-aic”, “apple,aic”;

+#interrupt-cells = <3>;

+interrupt-controller;

+reg = <0x2 0x3b100000 0x0 0x8000>;

+};

+};

+};

@@ -32,6 +32,7 @@ CONFIG_ARCH_AGILEX=y

CONFIG_ARCH_N5X=y

CONFIG_ARCH_SUNXI=y

CONFIG_ARCH_ALPINE=y

+CONFIG_ARCH_APPLE=y

CONFIG_ARCH_BCM2835=y

CONFIG_ARCH_BCM4908=y

CONFIG_ARCH_BCM_IPROC=y

@@ -173,7 +173,7 @@ static inline void gic_pmr_mask_irqs(void)

static inline void gic_arch_enable_irqs(void)

{

-asm volatile (“msr daifclr, #2” : : : “memory”);

+asm volatile (“msr daifclr, #3” : : : “memory”);

}

#endif /__ASSEMBLY__ */

@@ -40,9 +40,9 @@

msrdaif, flags

.endm

-/IRQ is the lowest priority flag, unconditionally unmask the rest. */

-.macro enable_da_f

-msrdaifclr, #(8 | 4 | 1)

+/IRQ/FIQ are the lowest priority flags, unconditionally unmask the rest. */

+.macro enable_da

+msrdaifclr, #(8 | 4)

.endm

/*

@@ -50,7 +50,7 @@

*/

.macrosave_and_disable_irq, flags

mrsflags, daif

-msrdaifset, #2

+msrdaifset, #3

.endm

.macrorestore_irq, flags

@@ -59,6 +59,7 @@

#define ARM_CPU_IMP_NVIDIA0x4E

#define ARM_CPU_IMP_FUJITSU0x46

#define ARM_CPU_IMP_HISI0x48

+#define ARM_CPU_IMP_APPLE0x61

#define ARM_CPU_PART_AEM_V80xD0F

#define ARM_CPU_PART_FOUNDATION0xD00

@@ -99,6 +100,9 @@

#define HISI_CPU_PART_TSV1100xD01

+#define APPLE_CPU_PART_M1_ICESTORM0x022

+#define APPLE_CPU_PART_M1_FIRESTORM0x023

+

#define MIDR_CORTEX_A53 MIDR_CPU_MODEL(ARM_CPU_IMP_ARM, ARM_CPU_PART_CORTEX_A53)

#define MIDR_CORTEX_A57 MIDR_CPU_MODEL(ARM_CPU_IMP_ARM, ARM_CPU_PART_CORTEX_A57)

#define MIDR_CORTEX_A72 MIDR_CPU_MODEL(ARM_CPU_IMP_ARM, ARM_CPU_PART_CORTEX_A72)

@@ -127,6 +131,8 @@

#define MIDR_NVIDIA_CARMEL MIDR_CPU_MODEL(ARM_CPU_IMP_NVIDIA, NVIDIA_CPU_PART_CARMEL)

#define MIDR_FUJITSU_A64FX MIDR_CPU_MODEL(ARM_CPU_IMP_FUJITSU, FUJITSU_CPU_PART_A64FX)

#define MIDR_HISI_TSV110 MIDR_CPU_MODEL(ARM_CPU_IMP_HISI, HISI_CPU_PART_TSV110)

+#define MIDR_APPLE_M1_ICESTORM MIDR_CPU_MODEL(ARM_CPU_IMP_APPLE, APPLE_CPU_PART_M1_ICESTORM)

+#define MIDR_APPLE_M1_FIRESTORM MIDR_CPU_MODEL(ARM_CPU_IMP_APPLE, APPLE_CPU_PART_M1_FIRESTORM)

/Fujitsu Erratum 010001 affects A64FX 1.0 and 1.1, (v0r0 and v1r0) */

#define MIDR_FUJITSU_ERRATUM_010001MIDR_FUJITSU_A64FX

@@ -13,8 +13,8 @@

#include

#define DAIF_PROCCTX0

-#define DAIF_PROCCTX_NOIRQPSR_I_BIT

-#define DAIF_ERRCTX(PSR_I_BIT | PSR_A_BIT)

+#define DAIF_PROCCTX_NOIRQ(PSR_I_BIT | PSR_F_BIT)

+#define DAIF_ERRCTX(PSR_A_BIT | PSR_I_BIT | PSR_F_BIT)

#define DAIF_MASK(PSR_D_BIT | PSR_A_BIT | PSR_I_BIT | PSR_F_BIT)

@@ -47,7 +47,7 @@ static inline unsigned long local_daif_save_flags(void)

if (system_uses_irq_prio_masking()) PSR_F_BIT;

return flags;

@@ -69,7 +69,7 @@ static inline void local_daif_restore(unsigned long flags)

bool irq_disabled = flags & PSR_I_BIT;

WARN_ON(system_has_prio_mask_debugging() &&

-!(read_sysreg(daif) & PSR_I_BIT));

+(read_sysreg(daif) & (PSR_I_BIT | PSR_F_BIT)) != (PSR_I_BIT | PSR_F_BIT));

if (!irq_disabled) PSR_F_BIT);

pmr = GIC_PRIO_IRQOFF;

else {

pmr = GIC_PRIO_IRQON | GIC_PRIO_PSR_I_SET;

@@ -169,16 +169,7 @@ extern void __iomem *ioremap_cache(phys_addr_t phys_addr, size_t size);

#define ioremap(addr, size)__ioremap((addr), (size), __pgprot(PROT_DEVICE_nGnRE))

#define ioremap_wc(addr, size)__ioremap((addr), (size), __pgprot(PROT_NORMAL_NC))

-/*

– PCI configuration space mapping function.

– *

– The PCI specification disallows posted write configuration transactions.

– Add an arch specific pci_remap_cfgspace() definition that is implemented

– through nGnRnE device memory attribute as recommended by the ARM v8

– Architecture reference manual Issue A.k B2.8.2 “Device memory”.

– */

-#define pci_remap_cfgspace(addr, size) __ioremap((addr), (size), __pgprot(PROT_DEVICE_nGnRnE))

+#define ioremap_np(addr, size)__ioremap((addr), (size), __pgprot(PROT_DEVICE_nGnRnE))

/*

io{read,write}{16,32,64}be() macros

@@ -8,6 +8,10 @@

struct pt_regs;

+int set_handle_irq(void (*handle_irq)(struct pt_regs *));

+#define set_handle_irqset_handle_irq

+int set_handle_fiq(void (*handle_fiq)(struct pt_regs *));

+

static inline int nr_legacy_irqs(void)

{

return 0;

@@ -12,15 +12,13 @@

/*

Aarch64 has flags for masking: Debug, Asynchronous (serror), Interrupts and

– FIQ exceptions, in the ‘daif’ register. We mask and unmask them in ‘dai’

+ FIQ exceptions, in the ‘daif’ register. We mask and unmask them in ‘daif’

order:

Masking debug exceptions causes all other exceptions to be masked too/

– Masking SError masks irq, but not debug exceptions. Masking irqs has no

– side effects for other flags. Keeping to this order makes it easier for

– entry.S to know which exceptions should be unmasked.

– *

– FIQ is never expected, but we mask it when we disable debug exceptions, and

– unmask it at all other times.

+ Masking SError masks IRQ/FIQ, but not debug exceptions. IRQ and FIQ are

+ always masked and unmasked together, and have no side effects for other

+ flags. Keeping to this order makes it easier for entry.S to know which

+ exceptions should be unmasked.

*/

/*

@@ -35,7 +33,7 @@ static inline void arch_local_irq_enable(void)

}

asm volatile(ALTERNATIVE(

-“msrdaifclr, #2// arch_local_irq_enable”,

+”msrdaifclr, #3// arch_local_irq_enable”,

__msr_s(SYS_ICC_PMR_EL1, “%0”),

ARM64_HAS_IRQ_PRIO_MASKING)

:

@@ -54,7 +52,7 @@ static inline void arch_local_irq_disable(void)

}

asm volatile(ALTERNATIVE(

-“msrdaifset, #2// arch_local_irq_disable”,

+”msrdaifset, #3// arch_local_irq_disable”,

__msr_s(SYS_ICC_PMR_EL1, “%0”),

ARM64_HAS_IRQ_PRIO_MASKING)

:

@@ -1032,6 +1032,66 @@

#define TRFCR_ELx_ExTREBIT(1)

#define TRFCR_ELx_E0TREBIT(0)

+

+/GIC Hypervisor interface registers */

+/ICH_MISR_EL2 bit definitions */

+#define ICH_MISR_EOI(1 << 0)

+#define ICH_MISR_U(1 << 1)

+

+/ICH_LR*_EL2 bit definitions */

+#define ICH_LR_VIRTUAL_ID_MASK((1ULL << 32) - 1)

+

+#define ICH_LR_EOI(1ULL << 41)

+#define ICH_LR_GROUP(1ULL << 60)

+#define ICH_LR_HW(1ULL << 61)

+#define ICH_LR_STATE(3ULL << 62)

+#define ICH_LR_PENDING_BIT(1ULL << 62)

+#define ICH_LR_ACTIVE_BIT(1ULL << 63)

+#define ICH_LR_PHYS_ID_SHIFT32

+#define ICH_LR_PHYS_ID_MASK(0x3ffULL << ICH_LR_PHYS_ID_SHIFT)

+#define ICH_LR_PRIORITY_SHIFT48

+#define ICH_LR_PRIORITY_MASK(0xffULL << ICH_LR_PRIORITY_SHIFT)

+

+/ICH_HCR_EL2 bit definitions */

+#define ICH_HCR_EN(1 << 0)

+#define ICH_HCR_UIE(1 << 1)

+#define ICH_HCR_NPIE(1 << 3)

+#define ICH_HCR_TC(1 << 10)

+#define ICH_HCR_TALL0(1 << 11)

+#define ICH_HCR_TALL1(1 << 12)

+#define ICH_HCR_EOIcount_SHIFT27

+#define ICH_HCR_EOIcount_MASK(0x1f << ICH_HCR_EOIcount_SHIFT)

+

+/ICH_VMCR_EL2 bit definitions */

+#define ICH_VMCR_ACK_CTL_SHIFT2

+#define ICH_VMCR_ACK_CTL_MASK(1 << ICH_VMCR_ACK_CTL_SHIFT)

+#define ICH_VMCR_FIQ_EN_SHIFT3

+#define ICH_VMCR_FIQ_EN_MASK(1 << ICH_VMCR_FIQ_EN_SHIFT)

+#define ICH_VMCR_CBPR_SHIFT4

+#define ICH_VMCR_CBPR_MASK(1 << ICH_VMCR_CBPR_SHIFT)

+#define ICH_VMCR_EOIM_SHIFT9

+#define ICH_VMCR_EOIM_MASK(1 << ICH_VMCR_EOIM_SHIFT)

+#define ICH_VMCR_BPR1_SHIFT18

+#define ICH_VMCR_BPR1_MASK(7 << ICH_VMCR_BPR1_SHIFT)

+#define ICH_VMCR_BPR0_SHIFT21

+#define ICH_VMCR_BPR0_MASK(7 << ICH_VMCR_BPR0_SHIFT)

+#define ICH_VMCR_PMR_SHIFT24

+#define ICH_VMCR_PMR_MASK(0xffUL << ICH_VMCR_PMR_SHIFT)

+#define ICH_VMCR_ENG0_SHIFT0

+#define ICH_VMCR_ENG0_MASK(1 << ICH_VMCR_ENG0_SHIFT)

+#define ICH_VMCR_ENG1_SHIFT1

+#define ICH_VMCR_ENG1_MASK(1 << ICH_VMCR_ENG1_SHIFT)

+

+/ICH_VTR_EL2 bit definitions */

+#define ICH_VTR_PRI_BITS_SHIFT29

+#define ICH_VTR_PRI_BITS_MASK(7 << ICH_VTR_PRI_BITS_SHIFT)

+#define ICH_VTR_ID_BITS_SHIFT23

+#define ICH_VTR_ID_BITS_MASK(7 << ICH_VTR_ID_BITS_SHIFT)

+#define ICH_VTR_SEIS_SHIFT22

+#define ICH_VTR_SEIS_MASK(1 << ICH_VTR_SEIS_SHIFT)

+#define ICH_VTR_A3V_SHIFT21

+#define ICH_VTR_A3V_MASK(1 << ICH_VTR_A3V_SHIFT)

+

#ifdef __ASSEMBLY__

.irpnum,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30

@@ -491,8 +491,8 @@ tsk.reqx28// current thread_info

/*

Interrupt handling.

*/

-.macroirq_handler

-ldr_lx1, handle_arch_irq

+.macroirq_handler, handler:req

+ldr_lx1, handler

movx0, sp

irq_stack_entry

blrx1

@@ -531,6 +531,47 @@ alternative_endif

#endif

.endm

+.macro el1_interrupt_handler, handler:req

+gic_prio_irq_setup pmr=x20, tmp=x1

+enable_da

+

+movx0, sp

+blenter_el1_irq_or_nmi

+

+irq_handlerhandler

+

+#ifdef CONFIG_PREEMPTION

+ldrx24, [tsk, #TSK_TI_PREEMPT] // получить счетчик вытесненных запросов [QUEUE_SIZE] + альтернатива_если ARM 94 _ HAS_IRQ_PRIO_MASKING [QUEUE_SIZE] [6] + / [MAX_CHAN] [MAX_CHAN] + DA были очищены в начале обработки, а IF очищены [QUEUE_SIZE] () для

[MAX_CHAN] + обычные IRQ. Если что-то установлено, это означает, что мы вернулись из [MAX_CHAN] [QUEUE_SIZE] + NMI вместо обычного IRQ, поэтому пропустите приоритетное прерывание [QUEUE_SIZE] [QUEUE_SIZE] + / [MAX_CHAN] [QUEUE_SIZE] + миссис x0, daif [MAX_CHAN] [MAX_CHAN] + orr x 55, Икс, x0 [MAX_CHAN] [6] + Alternative_else_nop_endif [6] [QUEUE_SIZE] + cbnz x 52, 1f // вытеснение счет! = 0 || Путь возврата NMI [MAX_CHAN] [QUEUE_SIZE] + bl рука 091 _ preempt_schedule_irq // irq en / disable выполняется внутри [MAX_CHAN] [QUEUE_SIZE] + 1: [nu->driver] [QUEUE_SIZE] + # endif [MAX_CHAN] [MAX_CHAN] +

[QUEUE_SIZE] + mov x0, sp [MAX_CHAN] [MAX_CHAN] + bl exit_el1_irq_or_nmi [QUEUE_SIZE] [MAX_CHAN] + .endm [QUEUE_SIZE] [MAX_CHAN] + [nu->driver] [MAX_CHAN] + .macro el0_interrupt_handler, обработчик: req [QUEUE_SIZE] [QUEUE_SIZE] + gic_prio_irq_setup pmr = x 48, tmp = x0 [MAX_CHAN] [QUEUE_SIZE] + user_exit_irqoff [MAX_CHAN] [QUEUE_SIZE] + enable_da [MAX_CHAN] [MAX_CHAN] + [MAX_CHAN] [MAX_CHAN] + tbz x , # 83, 1f [MAX_CHAN] 00010000 [QUEUE_SIZE] + 1: [MAX_CHAN] [QUEUE_SIZE] + irq_handler handler [MAX_CHAN] [QUEUE_SIZE] + .endm [MAX_CHAN] [6] + [nu->driver] [nu->driver] .textual content [QUEUE_SIZE] [6] / [nu->driver] [QUEUE_SIZE] @@ – 697, 40 + 710, 44 @@ SYM_CODE_START (векторы) [MAX_CHAN] [QUEUE_SIZE] kernel_ventry 1, sync // Синхронный EL1h [MAX_CHAN] [6] kernel_ventry 1 , irq // IRQ EL1h [MAX_CHAN] [MAX_CHAN] – kernel_ventry 1, fiq_invalid // FIQ EL1h [MAX_CHAN] [MAX_CHAN] + kernel_ventry 1, fiq // FIQ EL1h [MAX_CHAN] [QUEUE_SIZE] kernel_ventry 1, error // Ошибка EL1h [nu->driver] [QUEUE_SIZE] kernel_ventry 0, синхронизация // Синхронный – бит EL0 [QUEUE_SIZE] [MAX_CHAN] kernel_ventry 0, irq // IRQ 90 – бит EL0 [nu->driver] [6] – kernel_ventry 0, fiq_invalid // FIQ 91 – бит EL0 [MAX_CHAN] [MAX_CHAN] + kernel_ventry 0, fiq // FIQ 94 – бит EL0 [MAX_CHAN] [6] kernel_ventry 0, error // Ошибка 89 – бит EL0 [MAX_CHAN] [6] #ifdef CONFIG_COMPAT [QUEUE_SIZE] [MAX_CHAN] kernel_ventry 0, sync_compat, 64 // Синхронный 65 – бит EL0 [MAX_CHAN] [QUEUE_SIZE] kernel_ventry 0, irq_compat, 61 // IRQ 61 -бит EL0 [QUEUE_SIZE] [QUEUE_SIZE] – kernel_ventry 0, fiq_invalid_compat, 64 // FIQ 63 – бит EL0 [MAX_CHAN] [QUEUE_SIZE] + kernel_ventry 0, fiq_compat, 67 // FIQ 61 – бит EL0 [MAX_CHAN] [QUEUE_SIZE] kernel_ventry 0, error_compat, 63 // Ошибка 63 – бит EL0 [QUEUE_SIZE] [QUEUE_SIZE] #еще[nu->driver] [QUEUE_SIZE] kernel_ventry 0 , sync_invalid, 64 // Синхронный 62 – бит EL0 [MAX_CHAN] [6] @@ – 759, 37 + 777, 6 @@ SYM_CODE_START_LOCAL (el0_error_invalid ) [QUEUE_SIZE] [MAX_CHAN] inv_entry 0, BAD_ERROR [nu->driver] [MAX_CHAN] SYM_CODE_END (el0_error_invalid) [MAX_CHAN] [6] – # ifdef CONFIG_COMPAT [QUEUE_SIZE] [MAX_CHAN] – SYM_CODE_START_LOCAL (el0_fiq_invalid_compat) [MAX_CHAN] [MAX_CHAN] – inv_entry 0, BAD_FIQ, 63 [nu->driver] [QUEUE_SIZE] -SYM_CODE_END (el0_fiq_invalid_compat) [QUEUE_SIZE] [nu->driver] – # endif [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] SYM_CODE_START_LOCAL (el1_sync_invalid) [nu->driver] [6] inv_entry 1, BA D_SYNC [QUEUE_SIZE] [MAX_CHAN] SYM_CODE_END (el1_sync_invalid) [MAX_CHAN] [MAX_CHAN] @@ – 772, 00000070 + 00000800, 39 @@ SYM_CODE_END (el1_sync) [QUEUE_SIZE] [nu->driver] .align 6 [MAX_CHAN] [6] SYM_CODE_START_LOCAL_NOALIGN ( el1_irq) [MAX_CHAN] [QUEUE_SIZE] запись_ядра 1 [MAX_CHAN] [QUEUE_SIZE] – gic_prio_irq_setup pmr = x 47, tmp = x1 [MAX_CHAN] [MAX_CHAN] – enable_da_f [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – mov x0 , sp [nu->driver] [QUEUE_SIZE] – bl enter_el1_irq_or_nmi [QUEUE_SIZE] [6] – [QUEUE_SIZE] [MAX_CHAN] – irq_handler [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – # ifdef CONFIG_PREEMPTION [QUEUE_SIZE] [6] – ldr x 55, [tsk, #TSK_TI_PREEMPT] // получить количество вытесненных операций [nu->driver] [QUEUE_SIZE] – вариант_если ARM 90 _ HAS_IRQ_PRIO_MASKING [MAX_CHAN] [6] – / [QUEUE_SIZE] 9080 – DA_F были сброшены при запуске обработки. Если что-то установлено в DAIF, [MAX_CHAN] [QUEUE_SIZE] – мы возвращаемся из NMI, поэтому пропустите приоритетное прерывание [MAX_CHAN] [nu->driver] – / [MAX_CHAN] [QUEUE_SIZE] – миссис х0 , даиф [QUEUE_SIZE] [nu->driver] – orr x 55, Икс54, x0 [MAX_CHAN] [QUEUE_SIZE] – alternate_else_nop_endif [QUEUE_SIZE] [6] – cbnz x 56, 1f // количество вытесненных операций! = 0 || Путь возврата NMI [QUEUE_SIZE] [QUEUE_SIZE] – bl arm _ preempt_schedule_irq // irq en / disable выполняется внутри [nu->driver] [6] – 1: [MAX_CHAN] [QUEUE_SIZE] – # endif [QUEUE_SIZE] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – mov x0, sp [QUEUE_SIZE] [MAX_CHAN] – bl exit_el1_irq_or_nmi [MAX_CHAN] [6] – [QUEUE_SIZE] [MAX_CHAN] + el1_interrupt_handler handle_arch_irq [nu->driver] [MAX_CHAN] kernel_exit 1 [MAX_CHAN] [QUEUE_SIZE] SYM_CODE_END (el1_irq) [QUEUE_SIZE] [MAX_CHAN] + SYM_CODE_START_LOCAL_NOALIGN (el1_fiq) [MAX_CHAN] [6] + kernel_entry 1 [MAX_CHAN] [6] + el1_interrupt_handler handle_arch_fiq [MAX_CHAN] [MAX_CHAN] + kernel_exit 1 [MAX_CHAN] [QUEUE_SIZE] + SYM_CODE_END (el1_fiq) [MAX_CHAN] [QUEUE_SIZE] + [QUEUE_SIZE] [QUEUE_SIZE] / [QUEUE_SIZE] [6] Обработчики режима EL0. [nu->driver] [QUEUE_SIZE] / [QUEUE_SIZE] [QUEUE_SIZE] @@ – 0800, 6+ 805, 37 @@ SYM_CODE_START_LOCAL_NOALIGN (el0_irq_compat) [QUEUE_SIZE] [QUEUE_SIZE] b el0_irq_naked [MAX_CHAN] [MAX_CHAN] SYM_CODE_END ( el0_irq_compat) [QUEUE_SIZE] [MAX_CHAN] + SYM_CODE_START_LOCAL_NOALIGN (el0_fiq_compat) [6] [QUEUE_SIZE] + kernel_entry 0, 64 [QUEUE_SIZE] 9600 + b el0_fiq_naked [MAX_CHAN] [QUEUE_SIZE] + SYM_CODE_END (el0_fiq_compat) [MAX_CHAN] [QUEUE_SIZE] + [MAX_CHAN] [6] SYM_CODE_START_LOCAL_NOALIGN (el0_error_compat) [QUEUE_SIZE] [QUEUE_SIZE] kernel_entry 0, 65 [MAX_CHAN] [QUEUE_SIZE] b el0_error_naked [nu->driver] [6] @@ – 0802, 43 + 815, 41 @@ SYM_CODE_END (el0_error_compat) [6] [MAX_CHAN] SYM_CODE_START_LOCAL_NOALIGN (el0_irq) [MAX_CHAN] [6] kernel_entry 0 [MAX_CHAN] [nu->driver] el0_irq_naked: [QUEUE_SIZE] [MAX_CHAN] – gic_prio_irq_setup pmr = x 51, tmp = x0

[MAX_CHAN] – user_exit_irqoff [MAX_CHAN] [6] – enable_da_f [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – tbz x 54, # 82, 1f [nu->driver] [QUEUE_SIZE] – bl do_el0_irq_bp_harpting [QUEUE_SIZE] [QUEUE_SIZE] – 1: [MAX_CHAN] [QUEUE_SIZE] – irq_handler [nu->driver] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN] + el0_interrupt_handler handle_arch_irq [QUEUE_SIZE] [QUEUE_SIZE] b ret_to_user [nu->driver] [6] SYM_CODE_END (el0_irq) [QUEUE_SIZE] [nu->driver] + SYM_CODE_START_LOCAL_NOALIGN (el0_fiq) [MAX_CHAN] [QUEUE_SIZE] + kernel_entry 0 [MAX_CHAN] [6] + el0_fiq_naked: [MAX_CHAN] [QUEUE_SIZE] + el0_interrupt_handler handle_arch_fiq [MAX_CHAN] [6] + b ret_to_user [MAX_CHAN] [QUEUE_SIZE] + SYM_CODE_END (el0_fiq) [MAX_CHAN] [QUEUE_SIZE] + [MAX_CHAN] [QUEUE_SIZE] SYM_CODE_START_LOCAL (el1_error) [QUEUE_SIZE] [QUEUE_SIZE] запись_ядра 1 [MAX_CHAN] [QUEUE_SIZE] миссис x1, esr_el1 [nu->driver] [nu->driver] @@ – 821, 7 + 855, 7 @@ el0_error_naked: [MAX_CHAN] [QUEUE_SIZE] mov x0, sp

[QUEUE_SIZE] mov x1, x 52 [MAX_CHAN] [6] bl do_serror [QUEUE_SIZE] [MAX_CHAN] – enable_da_f [MAX_CHAN] [MAX_CHAN] + enable_da [QUEUE_SIZE] [QUEUE_SIZE] б ret_to_user [MAX_CHAN] [MAX_CHAN] SYM_CODE_END (el0_error) [QUEUE_SIZE] [QUEUE_SIZE] @@ – 00000100, 00000040 + 0100, 74 @@ static void init_irq_stacks (void) [nu->driver] [MAX_CHAN]} [nu->driver] [nu->driver] #endif [nu->driver] [6] + static void default_handle_irq (struct pt_regs regs) [QUEUE_SIZE] [QUEUE_SIZE] + {[QUEUE_SIZE] [QUEUE_SIZE] + panic («IRQ взят без корневого обработчика IRQ n»); [nu->driver] [QUEUE_SIZE] +} [QUEUE_SIZE] [6] + [MAX_CHAN] [QUEUE_SIZE] + static void default_handle_fiq (struct pt_regs regs) [QUEUE_SIZE] [MAX_CHAN] + {[MAX_CHAN] [6] + кастрюля ic (“FIQ взят без корневого обработчика FIQ n”); [QUEUE_SIZE] [MAX_CHAN] +} [MAX_CHAN] [QUEUE_SIZE] + [nu->driver] [QUEUE_SIZE] + void handle_arch_irq) ( struct pt_regs __ro_after_init = default_handle_irq; [QUEUE_SIZE] [QUEUE_SIZE] + void handle_arch_fiq) (struct pt_regs __ro_after_init = default_handle_fiq; [MAX_CHAN] [MAX_CHAN] + [nu->driver] [MAX_CHAN] + int __init set_handle_irq (void handle_irq) (struct pt_regs ) [MAX_CHAN] [QUEUE_SIZE] + {[MAX_CHAN] [MAX_CHAN] + if (handle_arch_irq! = default_handle_irq) 2156 + возврат -EBUSY; [QUEUE_SIZE] [QUEUE_SIZE] + [nu->driver] [QUEUE_SIZE] + handle_arch_irq = handle_irq; [MAX_CHAN] [MAX_CHAN] + pr_info (“Корневой обработчик IRQ:% ps n”, handle_irq); [nu->driver] [6] + возврат 0; [MAX_CHAN] [QUEUE_SIZE] +} [QUEUE_SIZE] [QUEUE_SIZE] + [nu->driver] [QUEUE_SIZE] + int __init set_handle_fiq (void handle_fiq) (struct pt_regs ) [QUEUE_SIZE] [QUEUE_SIZE] + {[MAX_CHAN] [QUEUE_SIZE] + если (handle_arch_fiq! = default_handle_fiq) [QUEUE_SIZE] [MAX_CHAN] + возврат -EBUSY; [MAX_CHAN] [MAX_CHAN] + [MAX_CHAN] [QUEUE_SIZE] + handle_arch_fiq = handle_fiq; [MAX_CHAN] [QUEUE_SIZE] + pr_info (“Корневой обработчик FIQ:% ps n”, handle_fiq); [QUEUE_SIZE] [6] + return 0; 9600 [nu->driver] +} [QUEUE_SIZE] [QUEUE_SIZE] + [nu->driver] [6] void __init init_IRQ (void) [QUEUE_SIZE] [MAX_CHAN] {2142 init_irq_stacks (); [QUEUE_SIZE] [nu->driver] init_irq_scs (); [nu->driver] [QUEUE_SIZE] irqchip_init (); [QUEUE_SIZE] 9080 – если (! handle_arch_irq) [QUEUE_SIZE] [QUEUE_SIZE] – паника («Контроллер прерываний не найден.»); [QUEUE_SIZE] [MAX_CHAN] if (system_uses_irq_prio_masking ()) GIC_PRIO_PSR_I_SET); [MAX_CHAN] [QUEUE_SIZE] [nu->driver] [6] @@ – 720, 7 + 727, 6 @@ CONFIG_GAMEPORT_FM 880 = m [MAX_CHAN] [QUEUE_SIZE] # CONFIG_LEGACY_PTYS не установлен [MAX_CHAN] [MAX_CHAN] CONFIG_SERIAL_NONSTANDARD = y [QUEUE_SIZE] [MAX_CHAN] CONFIG_ROCKETPORT = m [MAX_CHAN] [QUEUE_SIZE] – CONFIG_CYCLADES = m [QUEUE_SIZE] [QUEUE_SIZE] CONFIG_SYNCLINK_GT = m [MAX_CHAN] [MAX_CHAN] CONFIG_NOZOMI = m [QUEUE_SIZE] [QUEUE_SIZE] CONFIG_N_HDLC = m [MAX_CHAN] [QUEUE_SIZE] @@ – 488, 6+ 493, 38 @@ static inline void __iomem ioremap (длинное смещение без знака, длинное смещение без знака) [QUEUE_SIZE] [nu->driver] #outline ioremap_uc (X, Y) ioremap ((X), (Y)) [QUEUE_SIZE] [QUEUE_SIZE] #outline ioremap_wc (X, Y) ioremap ((X), (Y)) [nu->driver] [6] #outline ioremap_wt (X, Y) ioremap ((X), (Y)) [nu->driver] [QUEUE_SIZE] + static inline void __iomem ioremap_np (длинное смещение без знака, длинное смещение без знака) [QUEUE_SIZE] [MAX_CHAN] + {[nu->driver] [QUEUE_SIZE] + return NULL; [nu->driver] [nu->driver] +} [nu->driver] [QUEUE_SIZE] static inline void iounmap (risky void __iomem addr) [MAX_CHAN] [QUEUE_SIZE] {[nu->driver] [QUEUE_SIZE] @@ – 67, 79 + 62, 53 @@ [QUEUE_SIZE] [QUEUE_SIZE] #outline SERIAL_MAX_NUM_LINES 1 [MAX_CHAN] [QUEUE_SIZE] #outline SERIAL_TIMER_VALUE (HZ / [ARCH_TIMER_MAX_TIMER_PPI] ) [MAX_CHAN] [QUEUE_SIZE] + static void rs_poll (struct timer_list ; [QUEUE_SIZE] [QUEUE_SIZE] + [MAX_CHAN] [QUEUE_SIZE] static struct tty_driver serial_driver; [nu->driver] [QUEUE_SIZE] static struct tty_port serial_port; [QUEUE_SIZE] [QUEUE_SIZE] – статическая структура timer_list serial_timer; [nu->driver] [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] + статический DEFINE_TIMER (serial_timer, rs_poll); [MAX_CHAN] [MAX_CHAN] static DEFINE_SPINLOCK (timer_lock); [QUEUE_SIZE] [QUEUE_SIZE] – static char serial_version = “0.1”; [MAX_CHAN] [MAX_CHAN] – static char serial_name = “Драйвер последовательного порта ISS”; [nu->driver] [QUEUE_SIZE] –

[QUEUE_SIZE] – / [MAX_CHAN] [6] – Эта процедура вызывается всякий раз, когда открывается последовательный порт. Это[nu->driver] [QUEUE_SIZE] – разрешает прерывания для последовательного порта, связывая в его асинхронной структуре с [QUEUE_SIZE] [MAX_CHAN] – цепочка IRQ. Он также выполняет зависящие от серийного номера [MAX_CHAN] [QUEUE_SIZE] – инициализация для структуры tty. [QUEUE_SIZE] [QUEUE_SIZE] – / [nu->driver] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – static void rs_po ll (struct timer_list ; [nu->driver] [MAX_CHAN] – [QUEUE_SIZE] [6] static int rs_open (struct tty_struct tty, struct file filp) [MAX_CHAN] [MAX_CHAN] {[QUEUE_SIZE] [MAX_CHAN] – tty-> por t = & serial_port; [MAX_CHAN] [QUEUE_SIZE] spin_lock_bh (& timer_lock); [MAX_CHAN] 05091998 – если (tty-> rely == 1) {[MAX_CHAN] [6] – timer_setup (& serial_timer , rs_poll, 0); [MAX_CHAN] [QUEUE_SIZE] + if (tty-> rely == 1) [QUEUE_SIZE] [QUEUE_SIZE] mod_timer (& serial_timer, jiffies + SERIAL_TIMER_VALUE); [MAX_CHAN] [QUEUE_SIZE] -} [QUEUE_SIZE] [QUEUE_SIZE] spin_unlock_bh (& timer_lock); [MAX_CHAN] [MAX_CHAN] return 0; [nu->driver] [MAX_CHAN]} [nu->driver] [MAX_CHAN] – [QUEUE_SIZE] [QUEUE_SIZE] – / [nu->driver] [6] – —————————————- ——————– [nu->driver] 00010000 [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – Эта процедура вызывается при закрытии последовательного порта. Сначала мы[nu->driver] [QUEUE_SIZE] – дождитесь отправки последних оставшихся данных. Затем мы отключаем его [MAX_CHAN] [QUEUE_SIZE] – асинхронная структура из цепочки прерываний при необходимости, и мы освобождаем [QUEUE_SIZE] [QUEUE_SIZE] – этот IRQ, если в цепочке ничего не осталось. [MAX_CHAN] [QUEUE_SIZE] – —————————————— —————— [nu->driver] [6] – / [QUEUE_SIZE] [QUEUE_SIZE] static void rs_close (struct tty_struct tty, struct file filp) [QUEUE_SIZE] [MAX_CHAN] {[nu->driver] [MAX_CHAN] spin_lock_bh (& timer_lock); [MAX_CHAN] [QUEUE_SIZE] @@ – 209, 7 + 181, 7 @@ static void rs_wait_until_sent (struct tty_struct tty, int timeout) [MAX_CHAN] [MAX_CHAN] static int rs_proc_show (struct seq_file m, void v) [MAX_CHAN] [QUEUE_SIZE] {

[QUEUE_SIZE] – seq_printf (m, “serinfo : 1.0 драйвер:% s n “, серийная_версия); [MAX_CHAN] [QUEUE_SIZE] + seq_printf (m, “serinfo: 1.0 драйвер: 0.1 n “); [MAX_CHAN] [QUEUE_SIZE] return 0; [MAX_CHAN] [QUEUE_SIZE]} [nu->driver] [QUEUE_SIZE] @@ – 229 , 42 + 198, 39 @@ static const struct tty_operations serial_ops = {[QUEUE_SIZE] [MAX_CHAN] .proc_show = rs_proc_show, [QUEUE_SIZE] [6]}; [MAX_CHAN] [MAX_CHAN] – int __init rs_init (void) [MAX_CHAN] [QUEUE_SIZE] + static int __init rs_init (void) [MAX_CHAN] [MAX_CHAN] {[MAX_CHAN] [QUEUE_SIZE] tty_port_init (& serial_port); [MAX_CHAN] [MAX_CHAN] serial_driver = alloc_tty_driver (SERIAL_MAX_NUM_LINES); [QUEUE_SIZE] [QUEUE_SIZE] – pr_info (“% s% s n “, serial_name, serial_version); [MAX_CHAN] [nu->driver] – [MAX_CHAN] [MAX_CHAN] / Инициализируем структуру tty_driver / [QUEUE_SIZE] [6] serial_driver-> driver_name = “iss_serial”; [QUEUE_SIZE] [MAX_CHAN] @@ – 243, 39 + 226 , 7 @@ int __init rs_init (void) [QUEUE_SIZE] [QUEUE_SIZE] статический __exit void rs_exit (void) [MAX_CHAN] [QUEUE_SIZE] {[nu->driver] [QUEUE_SIZE] – int error; [nu->driver] [QUEUE_SIZE] – [nu->driver] [6] – если ((error = tty_unregister_driver (serial_driver))) [QUEUE_SIZE] [MAX_CHAN] – pr_err (“ISS_SERIAL: не удалось отменить регистрацию серийного номера драйвер (% d) n “, [MAX_CHAN] [MAX_CHAN]- ошибка);[MAX_CHAN] [QUEUE_SIZE] + tty_unregister_driver (серийный_драйвер); [nu->driver] [QUEUE_SIZE] put_tty_driver (последовательный_драйвер); [QUEUE_SIZE] [QUEUE_SIZE] tty_port_destroy (& serial_port); [QUEUE_SIZE] [6]} [nu->driver] [6] @@ – 154, 7 + 155, 6 @@ static int spk_ttyio_receive_buf2 (struct tty_struct tty, [QUEUE_SIZE] [QUEUE_SIZE] статическая структура tty_ldisc_ops spk_ttyio_ldisc_ops = {[QUEUE_SIZE] [MAX_CHAN] .proprietor = ЭТО_МОДУЛЬ, [QUEUE_SIZE] [MAX_CHAN] – .magic = TTY_LDISC_MAGIC, [MAX_CHAN] [QUEUE_SIZE] .nam e = “speakup_ldisc”, 12094 [MAX_CHAN] .open = spk_ttyio_ldisc_open, [MAX_CHAN] [6] .shut = spk_ttyio_ldisc_close, [QUEUE_SIZE] [QUEUE_SIZE] @@ – 906, 7 + 906, 6 @@ static __poll_t hci_uart_tty_poll (struct tty_struct tty, [nu->driver] [MAX_CHAN] static struct tty_ldisc_ops hci_uart_ldisc = {[MAX_CHAN] [QUEUE_SIZE] .proprietor = THIS_MODULE, [MAX_CHAN] [QUEUE_SIZE] – .magic = TTY_LDISC_MAGIC, [MAX_CHAN] [6] .identify = ” n_hci “, [MAX_CHAN] [QUEUE_SIZE] .open = hci_uart_tty_open, [QUEUE_SIZE] [QUEUE_SIZE] .shut = hci_uart_tty_close, [6] [QUEUE_SIZE] @@ – 091, 6+ 91, 41 @ @ struct arch_timer {[nu->driver] [nu->driver] статический u 66 arch_timer_rate; 12094 [QUEUE_SIZE] static int arch_timer_ppi [ARCH_TIMER_MAX_TIMER_PPI]; [MAX_CHAN] [MAX_CHAN] + static const char arch_timer_ppi_names знак равно [QUEUE_SIZE] + [ARCH_TIMER_PHYS_SECURE_PPI] = “сек-физ”, [nu->driver] [MAX_CHAN] + [ARCH_TIMER_PHYS_NONSECURE_PPI] = “физ”, [QUEUE_SIZE] [MAX_CHAN] + [ARCH_TIMER_VIRT_PPI] = “вирт”, [MAX_CHAN] [QUEUE_SIZE] + [ARCH_TIMER_HYP_PPI] = “hyp- физ », [nu->driver] [QUEUE_SIZE] + [ARCH_TIMER_HYP_VIRT_PPI] = “гип-вирт”, [nu->driver] [MAX_CHAN] +}; [nu->driver] [QUEUE_SIZE] + [MAX_CHAN] [QUEUE_SIZE] static struct clock_event_device __percpu arch_timer_evt; [QUEUE_SIZE] [6] статическое перечисление arch_timer_ppi_nr arch_timer_uses_ppi = ARCH_TIMER_VIRT_PPI; [MAX_CHAN] [6] @@ – 1608, 8 + 1608, 9 @@ static void __init arch_timer_populate_kvm_info (void) [MAX_CHAN] [nu->driver] static int __init arch_timer_of_init (struct device_node np) [MAX_CHAN] [6] {[MAX_CHAN] [MAX_CHAN] – int i, ret; [QUEUE_SIZE] [6] + int i, irq, ret; [MAX_CHAN] [QUEUE_SIZE] u 65 показатель;[MAX_CHAN] [6] + bool has_names; 12094 [MAX_CHAN] if (arch_timers_present & ARCH_TIMER_TYPE_CP 43) {[QUEUE_SIZE] [QUEUE_SIZE] pr_warn («несколько узлов в dt, пропуск n»); [QUEUE_SIZE] [QUEUE_SIZE] @@ – 1622, 8 + 1628, 44 @@ static int __init arch_timer_of_init (struct device_node np) [MAX_CHAN] [6]} [MAX_CHAN] [MAX_CHAN] arch_timers_present | = ARCH_TIMER_TYPE_CP 41; [QUEUE_SIZE] [QUEUE_SIZE] – для (i = ARCH_TIMER_PHYS_SECURE_PPI; я driver] [6] + has_names = of_property_read_bool (np, «имена прерываний»); [QUEUE_SIZE] [QUEUE_SIZE] + [MAX_CHAN] [QUEUE_SIZE] + for (i = ARCH_TIMER_PHYS_SECURE_PPI; я driver] [QUEUE_SIZE] + irq = of_irq_get (np, i); [6] [QUEUE_SIZE] + if (irq> 0) [MAX_CHAN] [MAX_CHAN] + arch_timer_ppi [i] = irq; [QUEUE_SIZE] [nu->driver] +} [nu->driver] [QUEUE_SIZE] arch_ti mer_populate_kvm_info (); [QUEUE_SIZE] [QUEUE_SIZE] @@ – 711, 4+ 710, 38 @@ config MST_IRQ [MAX_CHAN] [MAX_CHAN] помощь[nu->driver] [MAX_CHAN] Поддержка контроллера прерываний MStar. [QUEUE_SIZE] [QUEUE_SIZE] + конфиг APPLE_AIC [MAX_CHAN] [QUEUE_SIZE] + bool “Apple Interrupt Контроллер (AIC) “[MAX_CHAN] [MAX_CHAN] + зависит от ARM [QUEUE_SIZE] + ARCH_APPLE по умолчанию [MAX_CHAN] [QUEUE_SIZE] + помощь [nu->driver] [QUEUE_SIZE] + Поддержка контроллера прерываний Apple найдено на Apple Silicon SoC, < port-> [MAX_CHAN] + например, M1. 9600 [QUEUE_SIZE] + [nu->driver] [QUEUE_SIZE] endmenu [MAX_CHAN] [MAX_CHAN] @@ – 163, 3 + 171, 4 @@ obj – $ (CONFIG_LOONGSON_PCH_MSI) + = irq-loongson-pch-msi.o [nu->driver] [QUEUE_SIZE] объект $ (CONFIG_MST_IRQ) ​​+ = irq-mst-intc.o [6] [QUEUE_SIZE] obj – $ (CONFIG_SL 59 CPLD_INTC) + = irq-sl 59 cpld.o [MAX_CHAN] [6] obj – $ (CONFIG_MACH_REALTEK_RTL) + = irq-realtek-rtl.o [QUEUE_SIZE] [MAX_CHAN] + obj – $ (CONFIG_APPLE_AIC) + = irq-apple-aic.o [MAX_CHAN] [MAX_CHAN] diff –git a / drivers / irqchip / irq-apple-aic.cb / drivers / irqchip / irq-apple-aic .c

новый файловый режим 435907

индекс 0018 .. c 236 e 65535 fd5

— / dev / null

+++ b / <4> драйверы / irqchip / irq-apple-aic.c
[MAX_CHAN] [6] @@ -0,0 +1, 933 @@ [MAX_CHAN] [6] + // Идентификатор лицензии SPDX: GPL-2.0 или более поздняя 10100 [6] + / [nu->driver] [MAX_CHAN] + Авторские права The Asahi L Участники inux 10101 [MAX_CHAN] + [MAX_CHAN] [QUEUE_SIZE] + На основе irq-lpc 64 xx: [QUEUE_SIZE] [QUEUE_SIZE] + Авторские права 2055 – 2055 Владимир Запольский <4> [nu->driver] [QUEUE_SIZE] + На основе irq-bcm 3400: [MAX_CHAN] [QUEUE_SIZE] + Авторские права 2055 Broadcom [nu->driver] [QUEUE_SIZE] + / [nu->driver] [MAX_CHAN] + [MAX_CHAN] [MAX_CHAN] + / [QUEUE_SIZE] [QUEUE_SIZE] + AIC – довольно простой контроллер прерываний со следующими функциями: [nu->driver] [QUEUE_SIZE] + [MAX_CHAN] [MAX_CHAN] + – 975 аппаратные IRQ, запускаемые уровнем [MAX_CHAN] [QUEUE_SIZE] + – Бит одиночной маски на IRQ [MAX_CHAN] [MAX_CHAN] + – Настройка привязки для каждого IRQ [QUEUE_SIZE] + – Автоматическое маскирование при доставке события (автоподтверждение) 24000000 [MAX_CHAN] + – Программный запуск (ИЛИ со строкой hw) [QUEUE_SIZE] [QUEUE_SIZE] + – 2 IPI для каждого процессора (обозначаются как «собственный» и «другой», но они [QUEUE_SIZE] [QUEUE_SIZE] + обмен возможно, если не симметрично) [MAX_CHAN] [QUEUE_SIZE] + – Автоматическая приоритезация (одиночное событие / регистр подтверждения на ЦП, более низкие IRQ = [QUEUE_SIZE] [MAX_CHAN] + более высокий приоритет) [MAX_CHAN] [QUEUE_SIZE] + – Автоматическое маскирование при подтверждении [MAX_CHAN] [MAX_CHAN] + – Представление регистра по умолчанию «этот CPU» и явные представления для каждого процессора [MAX_CHAN] [QUEUE_SIZE] + [QUEUE_SIZE] [MAX_CHAN] + Кроме того, этот драйвер также обрабатывает FIQ, поскольку они направляются в тот же [MAX_CHAN] [QUEUE_SIZE] + Вектор IRQ. Они используются для быстрых IPI (TODO), IRQ таймера ARMv8 и [QUEUE_SIZE] [QUEUE_SIZE] + счетчики производительности (TODO). [QUEUE_SIZE] [QUEUE_SIZE] + [MAX_CHAN] [6] + Примечания по реализации: [nu->driver] [nu->driver] + [MAX_CHAN] [MAX_CHAN] + – Этот драйвер создает два домена IRQ, один для HW IRQ и внутренних FIQ, [QUEUE_SIZE] [QUEUE_SIZE] + и один для IPI. [QUEUE_SIZE] [MAX_CHAN] + – Поскольку Linux требуется более 2 IPI, мы реализуем программный контроллер IRQ [MAX_CHAN] [6] + и направить все IPI в один IPI для каждого процессора (второй «собственный» IPI не используется). [MAX_CHAN] [QUEUE_SIZE] + – hwirq-номера FIQ назначаются после истинных hwirq-ов и рассчитываются для каждого процессора. [QUEUE_SIZE] + – привязки DT используйте трехэлементную форму (например, GIC): [MAX_CHAN] [MAX_CHAN] + – <&clk24> – hwirq #nr [MAX_CHAN] [QUEUE_SIZE] + – <&clk24> – FIQ #nr [nu->driver] [6] + – nr = 0 Физический таймер ВН [MAX_CHAN] [nu->driver] + – nr = 1 Виртуальный таймер HV [QUEUE_SIZE] [MAX_CHAN] + – nr = 2 Физический гостевой таймер [MAX_CHAN] [6] + – nr = 3 Виртуальный гостевой таймер [MAX_CHAN] [QUEUE_SIZE] + / [MAX_CHAN] [QUEUE_SIZE] +

[QUEUE_SIZE] + # определить pr_fmt (fmt) KBUILD_MODNAME “:” fmt [MAX_CHAN] [MAX_CHAN] + [MAX_CHAN] [6] + # включать [nu->driver] [QUEUE_SIZE] + # embrace [MAX_CHAN] [MAX_CHAN] + # embrace [nu->driver] [QUEUE_SIZE] + # embrace [QUEUE_SIZE] [QUEUE_SIZE] + # embrace <1 nr flags> [QUEUE_SIZE] [MAX_CHAN] + # embrace

[QUEUE_SIZE] + # embrace [MAX_CHAN] [QUEUE_SIZE] + # embrace [QUEUE_SIZE] [6] + # embrace [MAX_CHAN] [QUEUE_SIZE] + # embrace [MAX_CHAN] [6] + # включать [MAX_CHAN] [MAX_CHAN] + # embrace [nu->driver] [QUEUE_SIZE] + [MAX_CHAN] [6] + # embrace [MAX_CHAN] [QUEUE_SIZE] + [MAX_CHAN] [MAX_CHAN] + / [MAX_CHAN] [6] + Регистры AIC (MMIO) [MAX_CHAN] [MAX_CHAN] + / [nu->driver] [MAX_CHAN] + [nu->driver] [6] + # определить AIC_INFO 0x 16 29 [MAX_CHAN] [MAX_CHAN] + # определить AIC_INFO_NR_HW GENMASK (42, 0) [QUEUE_SIZE] [MAX_CHAN] + [nu->driver] [QUEUE_SIZE] + # определить AIC_CONFIG 0x [QUEUE_SIZE] [QUEUE_SIZE] + [MAX_CHAN] [QUEUE_SIZE] + # определить AIC_WHOAMI 0x 2048 [MAX_CHAN] [QUEUE_SIZE] + # определить AIC_EVENT 0x 498

[6] + # определить AIC_EVENT_TYPE GENMASK (66, 46) [MAX_CHAN] [6] + # outline AIC_EVENT_NUM GENMASK (41, 0) [MAX_CHAN] [QUEUE_SIZE] + [QUEUE_SIZE] [MAX_CHAN] + # определить AIC_EVENT_TYPE_HW 1 [QUEUE_SIZE] [MAX_CHAN] + # определить AIC_EVENT_TYPE_IPI 4 [nu->driver] [QUEUE_SIZE] + # определить AIC_EVENT_IPI_OTHER 1 [QUEUE_SIZE] [MAX_CHAN] + # определить AIC_EVENT_IPI_SELF 2 [QUEUE_SIZE] [QUEUE_SIZE] +

[MAX_CHAN] + # определить AIC_IPI_SEND 0x 2053

[QUEUE_SIZE] + # определить AIC_IPI_ACK 0x 270 c [nu->driver] [QUEUE_SIZE] + # определить AIC_IPI_MASK_SET 0x 2061

[QUEUE_SIZE] + # определить AIC_IPI_MASK_CLR 0x 2106 [MAX_CHAN] [MAX_CHAN] + [nu->driver] [6] + # определить AIC_IPI_SEND_CPU (cpu) BIT (cpu) [MAX_CHAN] [QUEUE_SIZE] + [QUEUE_SIZE] [QUEUE_SIZE] + # определить AIC_IPI_OTHER BIT (0) [QUEUE_SIZE] [QUEUE_SIZE] + # определить AIC_IPI_SELF BIT (66) [MAX_CHAN] [MAX_CHAN] + [MAX_CHAN] [QUEUE_SIZE] + # определить AIC_TARGET_CPU 0x 3964 [nu->driver] [QUEUE_SIZE] + # определить AIC_SW_SET 0x 4800

[6] + # определить AIC_SW_CLR 0x 4800 [MAX_CHAN] [QUEUE_SIZE] + # определить AIC_MASK_SET 0x 4878 [nu->driver] [MAX_CHAN] + # определить AIC_MASK_CLR 0x 5008 [nu->driver] [MAX_CHAN] + [MAX_CHAN] [6] + # определить AIC_CPU_IPI_SET (cpu) (0x 6702 + ((cpu) << 7)) [MAX_CHAN] [MAX_CHAN] + # определить AIC_CPU_IPI_CLR (cpu) (0x 624 c + ((cpu) << 7)) [nu->driver] [MAX_CHAN] + # определить AIC_CPU_IPI_MASK_SET (cpu) (0x 6587 + ((процессор) << 7)) [MAX_CHAN] [QUEUE_SIZE] + # определить AIC_CPU_IPI_MASK_CLR (cpu) (0x 6702 + ((процессор) << 7)) [MAX_CHAN] [6] + [nu->driver] [QUEUE_SIZE] + # определить MASK_REG (x) (4 (( x) >> 5)) [nu->driver] [MAX_CHAN] + # определить MASK_BIT (x) BIT ((x) & GENMASK (4, 0 )) [MAX_CHAN] [QUEUE_SIZE] + [MAX_CHAN] [6] + / [nu->driver] [nu->driver] + Системные регистры IMP-DEF, управляющие источниками FIQ [QUEUE_SIZE] [QUEUE_SIZE] + Примечание: IPI на основе sysreg пока не поддерживаются. [nu->driver] [QUEUE_SIZE] + / [MAX_CHAN] [6] + [nu->driver] [QUEUE_SIZE] + / Регистр управления ядром PMC / [MAX_CHAN] [6] + # определить SYS_IMP_APL_PMCR0_EL1 sys_reg (3, 1, 00000040, 0, 0) [nu->driver] [MAX_CHAN] + # определить PMCR0_IMODE GENMASK (37, 8) [nu->driver] [6] + # определить PMCR0_IMODE_OFF 0 [QUEUE_SIZE] [QUEUE_SIZE] + # определить PMCR0_IMODE_PMI 1 [QUEUE_SIZE] [MAX_CHAN] + # определить PMCR0_IMODE_AIC 2 [nu->driver] [6] + # определить PMCR0_IMODE_HALT 3 [6] [QUEUE_SIZE] + # определить PMCR0_IMODE_FIQ 4 [MAX_CHAN] [QUEUE_SIZE] + # определить PMCR0_IACT BIT (39) [MAX_CHAN] [QUEUE_SIZE] + [MAX_CHAN] [QUEUE_SIZE] + / Регистры запроса IPI / [nu->driver] [6] + # определить SYS_IMP_APL_IPI_RR_LOCAL_EL1 sys_reg (3, 5, 40, 0, 0) [MAX_CHAN] [QUEUE_SIZE] + #outline SYS_IMP_APL_IPI_RR_GLOBAL_EL1 sys_reg (3, 5, 43, 0, 1) [QUEUE_SIZE] [QUEUE_SIZE] + # определить IPI_RR_CPU GENMASK (7, 0) [MAX_CHAN] [MAX_CHAN] + / Кластер используется только для ГЛОБАЛЬНОГО регистра / [QUEUE_SIZE] [QUEUE_SIZE] + # определить ГЕНМАСКУ IPI_RR_CLUSTER (53, 40) [QUEUE_SIZE] [MAX_CHAN] + # определить IPI_RR_TYPE GENMASK (58, 59) [nu->driver] [6] + # определить IPI_RR_IMMEDIATE 0 [6] [MAX_CHAN] + # определить IPI_RR_RETRACT 1 [QUEUE_SIZE] [MAX_CHAN] + # определить IPI_RR_DEFERRED 2 [QUEUE_SIZE] [MAX_CHAN] + # определить IPI_RR_NOWAKE 3 [QUEUE_SIZE] [MAX_CHAN] + [QUEUE_SIZE] [MAX_CHAN] + / Регистр статуса IPI / [QUEUE_SIZE] [QUEUE_SIZE] + # определить SYS_IMP_APL_IPI_SR_EL1 sys_reg (3, 5, 36, 1, 1) [MAX_CHAN] [MAX_CHAN] + # определить IPI_SR_PENDING BIT (0) [MAX_CHAN] [QUEUE_SIZE] + [nu->driver] [nu->driver] + / Регистр включения гостевого таймера FIQ / [MAX_CHAN] [MAX_CHAN] + # определить SYS_IMP_APL_VM_TMR_FIQ_ENA_EL2 sys_reg (3, 5 , 42, 1, 3) [MAX_CHAN] [QUEUE_SIZE] + # определить VM_TMR_FIQ_ENABLE_V BIT (0) [QUEUE_SIZE] [QUEUE_SIZE] + # определить VM_TMR_FIQ_ENABLE_P BIT (1) [QUEUE_SIZE] [QUEUE_SIZE] + [MAX_CHAN] [QUEUE_SIZE] + / Регистр обратного отсчета отложенного IPI / [QUEUE_SIZE] [QUEUE_SIZE] + # определить SYS_IMP_APL_IPI_CR_EL1 sys_reg (3, 5, 40, 3, 1) [MAX_CHAN] [6] + [nu->driver] [QUEUE_SIZE] + / Регистр управления Uncore PMC / [QUEUE_SIZE] [nu->driver] + # определить SYS_IMP_APL_UPMCR0_EL1 sys_reg (3, 7, 42, 0, 4) [QUEUE_SIZE] [6] + # определить UPMCR0_IMODE GENMASK (48, 43) [MAX_CHAN] [QUEUE_SIZE] + # определить UPMCR0_IMODE_OFF 0 [MAX_CHAN] [QUEUE_SIZE] + # определить UPMCR0_IMODE_AIC 2 [QUEUE_SIZE] [QUEUE_SIZE] + # определить UPMCR0_IMODE_HALT 3 [MAX_CHAN] [QUEUE_SIZE] + # определить UPMCR0_IMODE_FIQ 4 [QUEUE_SIZE] [QUEUE_SIZE] + [nu->driver] [MAX_CHAN] + / Uncore Регистр статуса PMC / [nu->driver] [6] + # определить SYS_IMP_APL_UPMSR_EL1 sys_reg (3, 7, 45, 6, 4) [nu->driver] [MAX_CHAN] + # определить UPMSR_IACT BIT (0) [MAX_CHAN] [QUEUE_SIZE] + [nu->driver] [MAX_CHAN] + # определить AIC_NR_FIQ 4 [MAX_CHAN] [6] + # определить AIC_NR_SWIPI 64 [nu->driver] [QUEUE_SIZE] + [MAX_CHAN] [QUEUE_SIZE] + / [MAX_CHAN] [MAX_CHAN] + FIQ hw Определения индексов irq: источники FIQ используют определения привязки DT 12239 [MAX_CHAN] + напрямую, за исключением того, что таймеры особенные. На уровне irqchip [MAX_CHAN] [MAX_CHAN] + два типа таймера представлены их методом доступа: регистры _EL0 [QUEUE_SIZE] [QUEUE_SIZE] + или _EL 00000020 регистров. В привязке DT таймеры представлены 12094 [QUEUE_SIZE] + по своему назначению (HV или гостевой). Это отображение используется, когда ядро ​​[MAX_CHAN] [QUEUE_SIZE] + работает на EL2 (с VHE). Когда ядро ​​работает на EL1, [MAX_CHAN] [MAX_CHAN] + отображение отличается, а aic_irq_domain_translate () выполняет переназначение. [QUEUE_SIZE] [nu->driver] + / [MAX_CHAN] [QUEUE_SIZE] + 010001 [MAX_CHAN] + # определить AIC_TMR_EL0_PHYS AIC_TMR_HV_PHYS [MAX_CHAN] [6] + # определить AIC_TMR_EL0_VIRT AIC_TMR_HV_VIRT [QUEUE_SIZE] [QUEUE_SIZE] + # определить AIC_TMR_EL 21 _ PHYS AIC_TMR_GUEST_PHYS [MAX_CHAN] [6] + # определить AIC_TMR_EL 21 _ ВИРТ AIC_TMR_GUEST_VIRT [QUEUE_SIZE] [6] + [nu->driver] [MAX_CHAN] + struct aic_irq_chip {[MAX_CHAN] 10100 + void __iomem base; [MAX_CHAN] [QUEUE_SIZE] [MAX_CHAN] + struct irq_domain ipi_domain; [QUEUE_SIZE] [QUEUE_SIZE] + int nr_hw; [QUEUE_SIZE] [MAX_CHAN] + int ipi_hwirq; [QUEUE_SIZE] [MAX_CHAN] +}; [MAX_CHAN] [MAX_CHAN] + [QUEUE_SIZE] [QUEUE_SIZE] + статический DEFINE_PER_CPU (uint 62 _ t, aic_fiq_unmasked); [6] [QUEUE_SIZE] + [QUEUE_SIZE] [QUEUE_SIZE] + статический DEFINE_PER_CPU (atomic_t, aic_vipi_flag); [QUEUE_SIZE] [QUEUE_SIZE] + статический DEFINE_PER_CPU (atomic_t, aic_vipi_enable); [QUEUE_SIZE] [MAX_CHAN] + [QUEUE_SIZE] [QUEUE_SIZE] + статическая структура aic_irq_chip aic_irqc; [MAX_CHAN] [QUEUE_SIZE] + [MAX_CHAN] [MAX_CHAN] + статистика ic void aic_handle_ipi (struct pt_regs regs); [QUEUE_SIZE] [MAX_CHAN] + [MAX_CHAN] [QUEUE_SIZE] + статический u aic_ic_read (struct aic_irq_chip ic, u рег) [MAX_CHAN] [MAX_CHAN] + {

[MAX_CHAN] + return readl_relaxed (ic-> base + reg); [QUEUE_SIZE] [QUEUE_SIZE] +} [nu->driver] [6] + [MAX_CHAN] [MAX_CHAN] + static void aic_ic_write (struct aic_irq_chip ic, u 65 reg, u 64 val) [MAX_CHAN] [QUEUE_SIZE] + {[MAX_CHAN] [MAX_CHAN] + Writel_relaxed (val, ic-> base + reg ); [QUEUE_SIZE] [QUEUE_SIZE] +} [MAX_CHAN] [MAX_CHAN] + [QUEUE_SIZE] [6] + /

[QUEUE_SIZE] + IRQ irqchip [QUEUE_SIZE] [QUEUE_SIZE] + / [nu->driver] [MAX_CHAN] + [MAX_CHAN] [MAX_CHAN] + static void aic_irq_mask (struct irq_data d) [QUEUE_SIZE] [QUEUE_SIZE] + {[nu->driver] [MAX_CHAN] + struct aic_irq_chip ic = irq_data_get_irq_chip_data (d); [MAX_CHAN] [MAX_CHAN] + [nu->driver] [QUEUE_SIZE] + aic_ic_write (ic, AIC_MASK_SET + MASK_REG (irqd_to_hwirq (d) ), [QUEUE_SIZE] [QUEUE_SIZE] + MASK_BIT (irqd_to_hwirq (d))); [MAX_CHAN] [6] +} [nu->driver] [MAX_CHAN] + [MAX_CHAN] [MAX_CHAN] + static void aic_irq_unmask (struct irq_data d) [MAX_CHAN] [QUEUE_SIZE] + {[nu->driver] [QUEUE_SIZE] + struct aic_irq_chip ic = irq_data_get_irq_chip_data (d); [MAX_CHAN] [nu->driver] + [MAX_CHAN] [QUEUE_SIZE] + aic_ic_write (ic, AIC_MASK_CLR + MASK_REG (d- > hwirq), [nu->driver] [QUEUE_SIZE] + MASK_BIT (irqd_to_hwirq (d))); [MAX_CHAN] [6] +}

[QUEUE_SIZE] + [MAX_CHAN] [MAX_CHAN] + static void aic_irq_eoi (struct irq_data d) [MAX_CHAN] [6] + {[nu->driver] [QUEUE_SIZE] + / [QUEUE_SIZE] [QUEUE_SIZE] + Чтение причины прерывания автоматически подтверждается рожки и маски 16550 [QUEUE_SIZE] + IRQ, поэтому мы просто демаскируем его здесь, если необходимо. [MAX_CHAN] [QUEUE_SIZE] + / [nu->driver] [QUEUE_SIZE] + if (! irqd_irq_disabled (d) &&! irqd_irq_masked (d)) [MAX_CHAN] [nu->driver] + aic_irq_unmask (d); [MAX_CHAN] [QUEUE_SIZE] +} [MAX_CHAN] [QUEUE_SIZE] + [MAX_CHAN] [MAX_CHAN] + static void __exception_irq_entry aic_handle_irq (struct pt_regs regs) 2104 + {[nu->driver] [6] + struct aic_irq_chip ic = aic_irqc; [QUEUE_SIZE] [QUEUE_SIZE] + u 65 событие, тип, IRQ; [MAX_CHAN] [QUEUE_SIZE] + [MAX_CHAN] [MAX_CHAN] + сделать {[nu->driver] [MAX_CHAN] + / [MAX_CHAN] [QUEUE_SIZE] + Мы не можем использовать здесь расслабленное чтение, как чтение из буферов DMA [nu->driver] [6] + необходимо заказывать после срабатывания IRQ. [nu->driver] [MAX_CHAN] + / [MAX_CHAN] [QUEUE_SIZE] + событие = readl (ic-> base + AIC_EVENT); [QUEUE_SIZE] [QUEUE_SIZE] + kind = FIELD_GET (AIC_EVENT_TYPE, событие); [MAX_CHAN] [nu->driver] + irq = FIELD_GET (AIC_EVENT_NUM, событие); [MAX_CHAN] [QUEUE_SIZE] + [QUEUE_SIZE] [MAX_CHAN] + if (kind == AIC_EVENT_TYPE_HW) [MAX_CHAN] [6] + handle_domain_irq (aic_irqc-> hw_domain, irq, regs); [QUEUE_SIZE] [QUEUE_SIZE] + else if (kind == AIC_EVENT_TYPE_IPI && irq == 1) [nu->driver] [MAX_CHAN] + aic_handle_ipi (regs); [MAX_CHAN] [6] + else if (occasion! = 0) [nu->driver] [QUEUE_SIZE] + pr_err_ratelimited (“Неизвестно Событие IRQ% d,% d n “, тип, irq); [MAX_CHAN] [QUEUE_SIZE] +} whereas (событие); [MAX_CHAN] [MAX_CHAN] + [MAX_CHAN] [nu->driver] + / [MAX_CHAN] [6] + прерывания обслуживания vGIC тоже заканчиваются здесь, поэтому нам нужно проверить [MAX_CHAN] [QUEUE_SIZE] + для них отдельно. Это никогда не должно срабатывать, если KVM работает [MAX_CHAN] [QUEUE_SIZE] + должным образом, потому что он уже позаботился о его очистке [QUEUE_SIZE] [MAX_CHAN] + на гостевом выходе перед запуском этого обработчика. 16654 [QUEUE_SIZE] + / [nu->driver] [MAX_CHAN] + if (is_kernel_in_hyp_mode () && (read_sysreg_s (SYS_ICH_HCR_EL2) & ICH_HCR_EN) && [MAX_CHAN] [QUEUE_SIZE] + read_sysreg_s (SYS_ICH_MISR_EL2)! = 0) {[6] [QUEUE_SIZE] + pr_err_ratelimited («vGIC IRQ запущен и не обрабатывается KVM, отключение. n “); [QUEUE_SIZE] [QUEUE_SIZE] + sysreg_clear_set_s (SYS_ICH_HCR_EL2, ICH_HCR_EN, 0); [MAX_CHAN] [6] +} [MAX_CHAN] [QUEUE_SIZE] +} [QUEUE_SIZE] [6] + [nu->driver] [6] + static int aic_irq_set_affinity (struct irq_data d, [QUEUE_SIZE] [MAX_CHAN] + const struct cpumask mask_val, bool power) [QUEUE_SIZE] [6] + {[MAX_CHAN] [QUEUE_SIZE] + irq_hw_number_t hwirq = irqd_to_hwirq (d); [QUEUE_SIZE] [6] + struct aic_irq_chip ic = irq_data_get_irq_chip_data (d); [QUEUE_SIZE] [QUEUE_SIZE] + int cpu; [MAX_CHAN] [QUEUE_SIZE] + [QUEUE_SIZE] [MAX_CHAN] + if (принудительно) [nu->driver] [QUEUE_SIZE] + cpu = cpumask_first (mask_val); [QUEUE_SIZE] [MAX_CHAN] + еще [MAX_CHAN] [6] + cpu = cpumask_any_and (mask_val, cpu_online_mask); [QUEUE_SIZE] [QUEUE_SIZE] + [MAX_CHAN] [MAX_CHAN] + aic_ic_write (ic, AIC_TARGET_CPU + hwirq 4, BIT (cpu)); [MAX_CHAN]
+ irq_data_update_effective_affinity (d, cpumask_of (cpu)); [nu->driver] [MAX_CHAN] + [MAX_CHAN] [MAX_CHAN] + возврат IRQ_SET_MASK_OK; [MAX_CHAN] [QUEUE_SIZE] +} [QUEUE_SIZE] [MAX_CHAN] + [MAX_CHAN] [6] + static int aic_irq_set_type (struct irq_data d, тип int без знака) [nu->driver] [MAX_CHAN] + kind == IRQ_TYPE_EDGE_RISING)? 0: -EINVAL; [MAX_CHAN] [QUEUE_SIZE] + [MAX_CHAN] [QUEUE_SIZE] + [nu->driver] [MAX_CHAN] + статическая структура irq_chip aic_chip = {[MAX_CHAN] [QUEUE_SIZE] + .identify = “AIC”, [nu->driver] [QUEUE_SIZE] + .irq_mask = aic_irq_mask, [MAX_CHAN] [nu->driver] + .irq_unmask = aic_irq_unmask, [MAX_CHAN] [6] + .irq_eoi = aic_irq_eoi, [MAX_CHAN] [QUEUE_SIZE] + .irq_set_affinity = aic_irq_set_affinity, [QUEUE_SIZE] [QUEUE_SIZE] + .irq_set_type = aic_irq_set_type, [QUEUE_SIZE] [QUEUE_SIZE] + }; [QUEUE_SIZE] [QUEUE_SIZE] + [MAX_CHAN] [6] + / [nu->driver] [6] + FIQ irqchip [MAX_CHAN] [QUEUE_SIZE] + / [QUEUE_SIZE] [QUEUE_SIZE] + [nu->driver] } irq_data d) [nu->driver] [QUEUE_SIZE] + {[MAX_CHAN] [6] + struct aic_irq_chip ic = irq_data_get_irq_chip_data (d); [MAX_CHAN] [QUEUE_SIZE] + [QUEUE_SIZE] [QUEUE_SIZE] + return irqd_to_hwirq (d) – ic-> nr_hw;

[MAX_CHAN] +} [QUEUE_SIZE] [6] + [MAX_CHAN] [MAX_CHAN] + static void aic_fiq_set_mask (struct irq_data d) [MAX_CHAN] [QUEUE_SIZE] + {[MAX_CHAN] [QUEUE_SIZE] + / Только гостевые таймеры имеют настоящую маску бит, к сожалению. / [QUEUE_SIZE] [QUEUE_SIZE] + переключатель (aic_fiq_get_idx (d)) {[nu->driver] [6] + корпус AIC_TMR_EL 20 _ ФИЗИЧЕСКИЕ ДАННЫЕ: [MAX_CHAN] [QUEUE_SIZE] + sysreg_clear_set_s (SYS_IMP_APL_VM_TMR_FIQ_ENA_EL2, VM_TMR_FIQ_ENABLE_P, 0); [MAX_CHAN] [MAX_CHAN] + isb (); [QUEUE_SIZE] [MAX_CHAN] + перерыв; [MAX_CHAN] [QUEUE_SIZE] + корпус AIC_TMR_EL _ ВИРТ: [MAX_CHAN] [MAX_CHAN] + sysreg_clear_set_s (SYS_IMP_APL_VM_TMR_FIQ_ENA_EL2, VM_TMR_FIQ_ENABLE_V, 0); [nu->driver] [MAX_CHAN] + isb (); [nu->driver] [6] + перерыв; [nu->driver] [MAX_CHAN] + по умолчанию: [QUEUE_SIZE] [MAX_CHAN] + перерыв;

[nu->driver] +} [nu->driver] [6] +} [MAX_CHAN] [QUEUE_SIZE] + [MAX_CHAN] [MAX_CHAN] + статическая пустота aic_fiq_clear_mask (struct irq_data d) [QUEUE_SIZE] [nu->driver] + {[nu->driver] [6] + переключатель (aic_fiq_get_idx (d)) {[MAX_CHAN] [QUEUE_SIZE] + case AIC_TMR_EL 22 _ PHYS: [nu->driver] [6] + sysreg_clear_set_s (SYS_IMP_APL_VM_TMR_FIQ_ENA_EL2, 0, VM_TMR_FIQ_ENABLE_P); [MAX_CHAN] [MAX_CHAN] + isb (); [MAX_CHAN] [QUEUE_SIZE] + перерыв;[nu->driver] [QUEUE_SIZE] + корпус AIC_TMR_EL 20 _ ВИРТ: [MAX_CHAN] [6] + sysreg_clear_set_s (SYS_IMP_APL_VM_TMR_FIQ_ENA_EL2, 0, VM_TMR_FIQ_ENABLE_V); [MAX_CHAN] [6] + isb (); [QUEUE_SIZE] [QUEUE_SIZE] + перерыв; [MAX_CHAN] [6] + по умолчанию: [MAX_CHAN] [MAX_CHAN] + перерыв; [MAX_CHAN] [MAX_CHAN] +} [nu->driver] [6] +} [nu->driver] [QUEUE_SIZE] + [MAX_CHAN] [6] + static void aic_fiq_mask (struct irq_data d) [QUEUE_SIZE] [QUEUE_SIZE] + {[MAX_CHAN] [6] + aic_fiq_set_mask (d); [MAX_CHAN] [QUEUE_SIZE] + __this_cpu_and (aic_fiq_unmasked, ~ BIT (aic_fiq_get_idx (d))); [nu->driver] [MAX_CHAN] +} [MAX_CHAN] [QUEUE_SIZE] + [nu->driver] [6] + static void aic_fiq_unmask (struct irq_data d) [MAX_CHAN] [QUEUE_SIZE] + {[QUEUE_SIZE] [QUEUE_SIZE] + aic_fiq_clear_mask (d); [QUEUE_SIZE] [6] + __this_cpu_or (aic_fiq_unmasked, BIT (aic_fiq_get_idx (d) )); [QUEUE_SIZE] [QUEUE_SIZE] +} [MAX_CHAN] [QUEUE_SIZE] + [MAX_CHAN] [MAX_CHAN] + static void aic_fiq_eoi (struct irq_data d) [QUEUE_SIZE] [QUEUE_SIZE] + {[nu->driver] [QUEUE_SIZE] + / Мы маскируем для подтверждения (где можем), поэтому нам нужно демаскировать в EOI. / [MAX_CHAN] [MAX_CHAN] + if (__this_cpu_read (aic_fiq_unmasked) & BIT (aic_fiq_get_idx (d))) [MAX_CHAN] [QUEUE_SIZE] + aic_fiq_clear_mask (d); [QUEUE_SIZE] [nu->driver] +} [nu->driver] [6] + [QUEUE_SIZE] [QUEUE_SIZE] + # определить TIMER_FIRING (x) [nu->driver] [6] + (((x) & (ARCH_TIMER_CTRL_ENABLE | ARCH_TIMER_CTRL_IT_MASK | [MAX_CHAN] [MAX_CHAN] + ARCH_TIMER_CTRL_IT_STAT)) == [nu->driver] [6] + (ARCH_TIMER_CTRL_ENABLE | ARCH_TIMER_CTRL_IT_STAT)) [MAX_CHAN] [QUEUE_SIZE] + [MAX_CHAN] [QUEUE_SIZE] + static void __exception_irq_entry aic_handle_fiq (struct pt_regs regs) [6] [MAX_CHAN] + {[MAX_CHAN] [QUEUE_SIZE] + / [MAX_CHAN] [QUEUE_SIZE] + Было бы очень хорошо, если бы у нас был системный регистр, который позволяет нам получать [MAX_CHAN] [QUEUE_SIZE] + состояние источника FIQ без необходимости заглядывать в источники … [nu->driver] [6] + но такой регистр, похоже, не существует. [MAX_CHAN] [QUEUE_SIZE] + [QUEUE_SIZE] [QUEUE_SIZE] + Итак, у нас есть следующие потенциальные источники для проверки: [MAX_CHAN] [6] + – Быстрые IPI (еще не используются) [MAX_CHAN] [QUEUE_SIZE] + – 4 таймера (CNTP, CNTV для каждого ВН и гостя) [MAX_CHAN] [MAX_CHAN] + – Per-core PMC (пока не поддерживаются) [MAX_CHAN] [QUEUE_SIZE] + – Отдельные PMC для каждого кластера (пока не поддерживаются) [QUEUE_SIZE] + [nu->driver] [QUEUE_SIZE] + Поскольку не имеет дело ни с одним из этих результатов в шторме FIQ,

[QUEUE_SIZE] + здесь мы проверяем все, даже то, чего не делаем поддержки пока нет. [QUEUE_SIZE] [QUEUE_SIZE] + / [MAX_CHAN] [6] + [MAX_CHAN] [QUEUE_SIZE] + if (read_sysreg_s (SYS_IMP_APL_IPI_SR_EL1) & IPI_SR_PENDING) {[MAX_CHAN] [QUEUE_SIZE] + pr_err_ratelimited (“Быстрый IPI запущен. Acking. N “); [MAX_CHAN] [QUEUE_SIZE] + write_sysreg_s (IPI_SR_PENDING, SYS_IMP_APL_IPI_SR_EL1); [nu->driver] [QUEUE_SIZE] +} [QUEUE_SIZE] [MAX_CHAN] + [MAX_CHAN] [MAX_CHAN] + if (TIMER_FIRING (read_sys reg (cntp_ctl_el0))) [QUEUE_SIZE] [QUEUE_SIZE] + handle_domain_irq (aic_irqc-> hw_domain, [MAX_CHAN] [6] + aic_irqc-> nr_hw + AIC_TMR_EL0_PHYS, regs); [nu->driver] [QUEUE_SIZE] + [QUEUE_SIZE] [nu->driver] + if (TIMER_FIRING (read_sysreg (cntv_ctl_el0))) [6] [QUEUE_SIZE] + handle_domain_irq (aic_irqc-> hw_domain, [QUEUE_SIZE] [nu->driver] + aic_irqc-> nr_hw + AIC_TMR_EL0_VIRT, regs); [MAX_CHAN] [QUEUE_SIZE] +

[QUEUE_SIZE] + if (is_kernel_in_hyp_mode ()) {[QUEUE_SIZE] [nu->driver] + uint 92 _ t включено = read_sysreg_s (SYS_IMP_APL_VM_TMR_FIQ_ENA_EL2); [MAX_CHAN] [6] + [MAX_CHAN] [MAX_CHAN] + if ((enabled & VM_TMR_FIQ_ENABLE_P) && [QUEUE_SIZE] [QUEUE_SIZE] + TIMER_FIRING (read_sysreg_s (SYS_CNTP_CTL_EL 023))) [nu->driver] [MAX_CHAN] + handle_domain_ irq (aic_irqc-> hw_domain, [QUEUE_SIZE] 9080 + aic_irqc-> nr_hw + AIC_TMR_EL 21 _ PHYS, regs); [MAX_CHAN] [QUEUE_SIZE] + [MAX_CHAN] [QUEUE_SIZE] + if (( включен & VM_TMR_FIQ_ENABLE_V) && [QUEUE_SIZE] [nu->driver] + TIMER_FIRING (read_sysreg_s (SYS_CNTV_CTL_EL [1] ))) [nu->driver] [6] + handle_domain_irq (aic_irqc-> hw_domain, [QUEUE_SIZE] [QUEUE_SIZE] + aic_irqc-> nr_hw + AIC_TMR_EL 21 _ VIRT, regs); [nu->driver] [QUEUE_SIZE] +} [QUEUE_SIZE] [QUEUE_SIZE] + [nu->driver] [QUEUE_SIZE] + if ((read_sysreg_s (SYS_IMP_APL_PMCR0_EL1) & (PMCR0_IMODE | PMCR0_IACT)) == [MAX_CHAN] [QUEUE_SIZE] + (FIELD_PREP (PMCR0_IMODE, PMCR0_IMODE_FIQ) | PMCR0_IACT)) PMCR0_IACT, [MAX_CHAN] [MAX_CHAN] + FIELD_PREP (PMCR0_IMODE, PMCR0_IMODE_OFF)); [nu->driver] [QUEUE_SIZE] + [MAX_CHAN] [MAX_CHAN] + [MAX_CHAN] [QUEUE_SIZE] + if (FIELD_GET (UPMCR0_IMODE, read_sysreg _s (SYS_IMP_APL_UPMCR0_EL1)) == UPMCR0_IMODE_FIQ && [QUEUE_SIZE] [MAX_CHAN] + (read_sysreg_s (SYS_IMP_APL_UPMSR_EL1) & UPMSR_IACT)) {[QUEUE_SIZE] [QUEUE_SIZE] + / Та же история с неосновными ЧВК / [MAX_CHAN] [MAX_CHAN] + pr_err_ratelimited (“Uncore PMC FIQ уволен. Маскировка. N “); [nu->driver] [QUEUE_SIZE] + sysreg_clear_set_s (SYS_IMP_APL_UPMCR0_EL1, UPMCR0_IMODE, [MAX_CHAN] [6] + FIELD_PREP (UPMCR0_IMODE, UPMCR0_IMODE_OFF)); [nu->driver] [QUEUE_SIZE] +} [QUEUE_SIZE] [MAX_CHAN] +} [MAX_CHAN] [MAX_CHAN] + [QUEUE_SIZE] [MAX_CHAN] + static int aic_fiq_set_type (struct irq_data d, беззнаковый тип int) [MAX_CHAN] [QUEUE_SIZE] + {[MAX_CHAN] [QUEUE_SIZE] + возврат (введите == IRQ_TYPE_LEVEL_HIGH)? 0: -EINVAL; [MAX_CHAN] [QUEUE_SIZE] +} [MAX_CHAN] [QUEUE_SIZE] + [nu->driver] [QUEUE_SIZE] + статическая структура irq_chip fiq_chip = {[QUEUE_SIZE] [QUEUE_SIZE] + .identify = “AIC-FIQ”, [MAX_CHAN] [QUEUE_SIZE] + .irq_mask = aic_fiq_mask, [QUEUE_SIZE] [QUEUE_SIZE] + .irq_unmask = aic_fiq_unmask, [MAX_CHAN] [QUEUE_SIZE] + .irq_ack = aic_fiq_set_mask, [QUEUE_SIZE] [MAX_CHAN] + .irq_eoi = aic_fiq_eoi, [QUEUE_SIZE] [MAX_CHAN] + .irq_set_type = aic_fiq_set_type, [QUEUE_SIZE] [QUEUE_SIZE] + }; [MAX_CHAN] [QUEUE_SIZE] + [MAX_CHAN] [MAX_CHAN] + / [MAX_CHAN] [6] + Основной IRQ домен [MAX_CHAN] [MAX_CHAN] + / [MAX_CHAN] [QUEUE_SIZE] + [MAX_CHAN] [QUEUE_SIZE] + static int aic_irq_domain_map (struct irq_domain id, unsigned int irq, [QUEUE_SIZE] [QUEUE_SIZE] + irq_hw_number_t hw) [QUEUE_SIZE] [MAX_CHAN] + {[MAX_CHAN] [MAX_CHAN] + struct aic_irq_chip ic = id-> host_data; [MAX_CHAN] [QUEUE_SIZE] + [nu->driver] [QUEUE_SIZE] + if (hw nr_hw) {[MAX_CHAN] [QUEUE_SIZE] + irq_dom ain_set_info (id, irq, hw, & aic_chip, id-> host_data, [6] [QUEUE_SIZE] + handle_fasteoi_irq, NULL, NULL); [QUEUE_SIZE] [MAX_CHAN] + irqd_set_single_target (irq_desc_get_irq_data (irq_to_desc (irq))); [nu->driver] [6] +} else {[nu->driver] [MAX_CHAN] + irq_set_percpu_devid (irq); [MAX_CHAN] [MAX_CHAN] + irq_domain_set_info (id, irq, hw , & fiq_chip, id-> host_data, [QUEUE_SIZE] [MAX_CHAN] + handle_percpu_devid_irq, NULL, NULL); [QUEUE_SIZE] [QUEUE_SIZE] +} [nu->driver] [QUEUE_SIZE] + [QUEUE_SIZE] [QUEUE_SIZE] + возврат 0; [MAX_CHAN] [6] +} [QUEUE_SIZE] [MAX_CHAN] + [MAX_CHAN] [QUEUE_SIZE] + static int aic_irq_domain_translate (struct irq_domain id, [6] [MAX_CHAN] + struct irq_fwspec fwspec, [QUEUE_SIZE] [MAX_CHAN] + unsigned lengthy hwirq, 5557465 [6] + целое число без знака тип) [nu->driver] [MAX_CHAN] + {[MAX_CHAN] [QUEUE_SIZE] + struct aic_irq_chip ic = id-> host_data; [QUEUE_SIZE] [QUEUE_SIZE] + [QUEUE_SIZE] [MAX_CHAN] + if (fwspec-> param_count! = 3 || ! is_of_node (fwspec-> fwnode)) [MAX_CHAN] [MAX_CHAN] + return -EINVAL; [MAX_CHAN] [QUEUE_SIZE] + [MAX_CHAN] [QUEUE_SIZE] + переключатель (fwspec-> param [0]) {[MAX_CHAN] [QUEUE_SIZE] + ca se AIC_IRQ: [QUEUE_SIZE] [QUEUE_SIZE] + if (fwspec-> param [1]> = ic-> nr_hw) [nu->driver] [QUEUE_SIZE] + return -EINVAL; [QUEUE_SIZE] [nu->driver] + hwirq = fwspec-> param [1]; [MAX_CHAN] [MAX_CHAN] + перерыв; [MAX_CHAN] [QUEUE_SIZE] + case AIC_FIQ: [MAX_CHAN] [QUEUE_SIZE] + if (fwspec-> param [0]> = AIC_NR_FIQ) [MAX_CHAN] [QUEUE_SIZE] + return -EINVAL; [MAX_CHAN] [MAX_CHAN] + hwirq = ic-> nr_hw + fwspec-> param [1]; [MAX_CHAN] [QUEUE_SIZE] + [QUEUE_SIZE] [QUEUE_SIZE] + / [MAX_CHAN] [QUEUE_SIZE] + В EL1 регистры без перенаправления являются гостевыми, 010001 [MAX_CHAN] + не EL2, поэтому переназначьте hwirq для соответствия. [MAX_CHAN] [nu->driver] + / [MAX_CHAN] [QUEUE_SIZE] + if (! is_kernel_in_hyp_mode ()) {[MAX_CHAN] param [0]) {[MAX_CHAN] [6] + case AIC_TMR_GUEST_PHYS: [nu->driver] [QUEUE_SIZE] + hwirq = ic-> nr_hw + AIC_TMR_EL0_PHYS; [QUEUE_SIZE] [MAX_CHAN] + перерыв; [MAX_CHAN] [6] + case AIC_TMR_GUEST_VIRT: [QUEUE_SIZE] [QUEUE_SIZE] + hwirq = ic-> nr_hw + AIC_TMR_EL0_VIRT ; [MAX_CHAN] [QUEUE_SIZE] + перерыв; [MAX_CHAN] [QUEUE_SIZE] + case AIC_TMR_HV_PHYS: [nu->driver] [QUEUE_SIZE] + case AIC_TMR_HV_VIRT: [QUEUE_SIZE] [MAX_CHAN] + возврат -ENOENT; [MAX_CHAN] [MAX_CHAN] + по умолчанию: [QUEUE_SIZE] [6] + перерыв; [MAX_CHAN] [QUEUE_SIZE] +} [QUEUE_SIZE] [QUEUE_SIZE] +} [nu->driver] [QUEUE_SIZE] + перерыв; [QUEUE_SIZE] [QUEUE_SIZE] + по умолчанию: [MAX_CHAN] [MAX_CHAN] + return -EINVAL; [nu->driver] [6] +} [QUEUE_SIZE] [nu->driver] + [QUEUE_SIZE] [MAX_CHAN] + kind = fwspec-> param [2] & IRQ_TYPE_SENSE_MASK; 09051990 [QUEUE_SIZE] + [QUEUE_SIZE] [6] + возврат 0; [nu->driver] [QUEUE_SIZE] +} [MAX_CHAN] [QUEUE_SIZE] + [nu->driver] [MAX_CHAN] + static int aic_irq_domain_alloc (struct irq_domain area, unsigned int virq , [QUEUE_SIZE] [MAX_CHAN] + целое число без знака nr_irqs, void arg) [MAX_CHAN] [QUEUE_SIZE] + {[MAX_CHAN] [QUEUE_SIZE] + тип целого числа без знака = IRQ_TYPE_NONE; [nu->driver] [6] + struct irq_fwspec fwspec = arg; [MAX_CHAN] [MAX_CHAN] + irq_hw_number_t hwirq; [MAX_CHAN] [MAX_CHAN] + int i, ret ; [QUEUE_SIZE] [QUEUE_SIZE] + [MAX_CHAN] [6] + ret = aic_irq_domain_translate (домен, fwspec, & hwirq, & kind); [QUEUE_SIZE] [MAX_CHAN] + if (ret) [QUEUE_SIZE]

+ возврат возврата; [MAX_CHAN] [QUEUE_SIZE] + [MAX_CHAN] [QUEUE_SIZE] + для (i = 0; я driver] +}

[QUEUE_SIZE] + [MAX_CHAN] [QUEUE_SIZE] + static void aic_irq_domain_free (struct irq_domain area, unsigned int virq, [MAX_CHAN] [QUEUE_SIZE] + unsigned int nr_irqs) [nu->driver] [QUEUE_SIZE] + {[QUEUE_SIZE] [QUEUE_SIZE] + int i; [MAX_CHAN] [MAX_CHAN] + [QUEUE_SIZE] [QUEUE_SIZE] + для (i = 0; я driver] + .alloc = aic_irq_domain_alloc, [QUEUE_SIZE] [6] + .free = aic_irq_domain_free, [QUEUE_SIZE] [QUEUE_SIZE] +}; [nu->driver] [QUEUE_SIZE] + [MAX_CHAN] [nu->driver] + / [MAX_CHAN] [QUEUE_SIZE] + IPI irqchip [MAX_CHAN] [QUEUE_SIZE] + /

[MAX_CHAN] + [nu->driver] + static void aic_ipi_mask ( struct irq_data d) [QUEUE_SIZE] [QUEUE_SIZE] + {[nu->driver] [6] + u 60 irq_bit = BIT (irqd_to_hwirq (d)); [MAX_CHAN] [MAX_CHAN] + [MAX_CHAN] [QUEUE_SIZE] + / Никаких особых требований к заказу здесь не требуется. / [QUEUE_SIZE] [QUEUE_SIZE] + atomic_andnot (irq_bit, this_cpu_ptr (& aic_vipi_enable)); [MAX_CHAN] [6] +} [nu->driver] [QUEUE_SIZE] + [QUEUE_SIZE] [MAX_CHAN] + static void aic_ipi_unmask (struct irq _data d) [MAX_CHAN] [MAX_CHAN] + {[MAX_CHAN] [6] + struct aic_irq_chip ic = irq_data_get_irq_chip_data (d); [MAX_CHAN] [MAX_CHAN] + u 63 irq_bit = BIT (irqd_to_hwirq (d)); [MAX_CHAN] [QUEUE_SIZE] + [MAX_CHAN] [QUEUE_SIZE] + atomic_or (irq_bit, this_cpu_ptr (& aic_vipi_enable )); [QUEUE_SIZE] [QUEUE_SIZE] + [MAX_CHAN] [6] + / [MAX_CHAN] [QUEUE_SIZE] + atomic_or () выше должен завершиться до atomic_read () [QUEUE_SIZE] [QUEUE_SIZE] + ниже, чтобы избежать гонок aic_ipi_send_mask (). [MAX_CHAN] [MAX_CHAN] + / [QUEUE_SIZE] [QUEUE_SIZE] + smp_mb__after_atomic (); [MAX_CHAN] [QUEUE_SIZE] + [nu->driver] [QUEUE_SIZE] + / [MAX_CHAN] [QUEUE_SIZE] + Если ожидающий vIPI был демаскирован, мы поднимаем HW IPI себе. 10103 [QUEUE_SIZE] + Никаких барьеров здесь не требуется, так как это собственный IPI. 10103 [QUEUE_SIZE] + / [MAX_CHAN] [QUEUE_SIZE] + if (atomic_read (this_cpu_ptr (& aic_vipi_flag)) & irq_bit) [MAX_CHAN] [6] + aic_ic_write (ic, AIC_IPI_SEND, AIC_IPI_SEND_CPU (smp_processor_id ())); [MAX_CHAN] [QUEUE_SIZE] +} [MAX_CHAN] [QUEUE_SIZE] + [nu->driver] [6] + static void aic_ipi_send_mask (struct irq_data d, const struct cpumask masks) [QUEUE_SIZE] [QUEUE_SIZE] + {[nu->driver] [MAX_CHAN] + struct aic_irq_chip ic = irq_data_get_irq_chip_data (d); [QUEUE_SIZE] [MAX_CHAN] + u 65 irq_bit = BIT (irqd_to_hwirq (d)); [MAX_CHAN] [6] + u 66 ship = 0; [MAX_CHAN] [QUEUE_SIZE] + int cpu; [QUEUE_SIZE] [nu->driver] + длинное ожидание без знака; [MAX_CHAN] [QUEUE_SIZE] + [QUEUE_SIZE] [QUEUE_SIZE] + for_each_cpu (процессор, маска) = AIC_IPI_SEND_CPU (cpu); [nu->driver] [QUEUE_SIZE] + [MAX_CHAN] [QUEUE_SIZE] + [QUEUE_SIZE] [nu->driver] + / [MAX_CHAN] [MAX_CHAN] + Запись флага должна завершиться до выдачи физического IPI [MAX_CHAN] [6] + на другой ЦП. Это подразумевается зависимостью управления от [QUEUE_SIZE] [QUEUE_SIZE] + результат atomic_read_acquire () выше, который сам [QUEUE_SIZE] [MAX_CHAN] + уже заказан после записи флага vIPI. [MAX_CHAN] [QUEUE_SIZE] + / [nu->driver] [MAX_CHAN] + if (отправить) [MAX_CHAN] [QUEUE_SIZE] + aic_ic_write (ic, AIC_IPI_SEND, отправить); [MAX_CHAN] [QUEUE_SIZE] +} [MAX_CHAN] [6] + [QUEUE_SIZE] [QUEUE_SIZE] + статическая структура irq_chip ipi_chip = {[MAX_CHAN] [QUEUE_SIZE] + .identify = “AIC-IPI” , [QUEUE_SIZE] [MAX_CHAN] + .irq_mask = aic_ipi_mask, [MAX_CHAN] [QUEUE_SIZE] + .irq_unmask = aic_ipi_unmask, [QUEUE_SIZE] [MAX_CHAN] + .ipi_send_mask = aic_ipi_send_mask, [QUEUE_SIZE] [QUEUE_SIZE] + }; [QUEUE_SIZE] [nu->driver] + [MAX_CHAN] [MAX_CHAN] + / 2142 + IPI IRQ домен [nu->driver] [MAX_CHAN] + / [QUEUE_SIZE] [MAX_CHAN] + [MAX_CHAN] [6] + static void aic_handle_ipi (struct pt_regs regs) [MAX_CHAN] [QUEUE_SIZE] + {[QUEUE_SIZE] [MAX_CHAN] + int i; [nu->driver] включен, стрельба; [nu->driver] [MAX_CHAN] + [QUEUE_SIZE] [MAX_CHAN] + / [MAX_CHAN] [QUEUE_SIZE] + Подтвердите IPI. Нам нужно заказать это после чтения события AIC, но [MAX_CHAN] [QUEUE_SIZE] + *, что обеспечивается обычными гарантиями заказа MMIO. [MAX_CHAN] [MAX_CHAN] + / [MAX_CHAN] [MAX_CHAN] + aic_ic_write (aic_irqc, AIC_IPI_ACK, AIC_IPI_OTHER); [QUEUE_SIZE] [MAX_CHAN] + [MAX_CHAN] [QUEUE_SIZE] + / [QUEUE_SIZE] [MAX_CHAN] + Считывание маски заказывать не нужно. Только мы можем изменить [MAX_CHAN] [MAX_CHAN] + в любом случае наша собственная маска, так что никакие гонки здесь невозможны, пока [QUEUE_SIZE] [QUEUE_SIZE] + мы правильно находимся в обработчике прерывания (что покрывается [MAX_CHAN] [6] + барьер, который является частью readl ()) обработчика AIC верхнего уровня. [nu->driver] [QUEUE_SIZE] + / [nu->driver] [6] + enabled = atomic_read (this_cpu_ptr (& aic_vipi_enable)); [6] [nu->driver] + 2156 + / [nu->driver] [QUEUE_SIZE] + Очистите IPI, которые мы собираемся обработать. Это сочетается с [QUEUE_SIZE] [MAX_CHAN] + atomic_fetch_or_release () в aic_ipi_send_mask () и должен быть [QUEUE_SIZE] [nu->driver] + заказывается после aic_ic_write () выше (во избежание потери виртуальных IPI) и 12244 [QUEUE_SIZE] + перед кодом обработки IPI (во избежание гонок, обрабатывающих vIPI до того, как они 12239 О первом позаботится семантика выпуска [nu->driver] [QUEUE_SIZE] + части записи, в то время как последняя заботится [QUEUE_SIZE] [QUEUE_SIZE] + получение семантики прочитанной части. 35200000 [6] + / [MAX_CHAN] [MAX_CHAN] + firing = atomic_fetch_andnot (включен, this_cpu_ptr (& aic_vipi_flag)) и включен; [MAX_CHAN] [6] + [MAX_CHAN] [QUEUE_SIZE] + for_each_set_bit (i, & firing, AIC_NR_SWIPI) [QUEUE_SIZE] [6] + handle_domain_irq (aic_irqc-> ipi_domain, i, regs); [MAX_CHAN] [MAX_CHAN] + [QUEUE_SIZE] [MAX_CHAN] + / [nu->driver] ; в худшем случае это просто изменяет время [MAX_CHAN] [QUEUE_SIZE] + когда будет доставлен следующий IPI. [MAX_CHAN] [MAX_CHAN] + / [MAX_CHAN] , AIC_IPI_MASK_CLR, AIC_IPI_OTHER); [QUEUE_SIZE] [nu->driver] +} [QUEUE_SIZE] [MAX_CHAN] + [nu->driver] [6] + static int aic_ipi_alloc ( struct irq_domain d, unsigned int virq, [QUEUE_SIZE] [QUEUE_SIZE] + unsigned int nr_irqs, void args) [MAX_CHAN] [6] + {[MAX_CHAN] [MAX_CHAN] + int i; [MAX_CHAN] [6] + [nu->driver] [QUEUE_SIZE] + for (i = 0; i host_data, [QUEUE_SIZE] [MAX_CHAN] + handle_percpu_devid_irq, NULL, NULL); [nu->driver] [QUEUE_SIZE] +} [nu->driver] [QUEUE_SIZE] + [MAX_CHAN] [6] + возврат 0; [MAX_CHAN] [QUEUE_SIZE] +} [QUEUE_SIZE] [MAX_CHAN] +

+ static void aic_ipi_free (struct irq_domain d, unsigned int virq, unsigned int nr_irqs) [nu->driver] [QUEUE_SIZE] + {[nu->driver] [QUEUE_SIZE] + / IPI не освобождаются / [MAX_CHAN] [6] +} [MAX_CHAN] [MAX_CHAN] + [MAX_CHAN] [QUEUE_SIZE] + static const struct irq_domain_ops aic_ipi_domain_ops = { [QUEUE_SIZE] [QUEUE_SIZE] + .alloc = aic_ipi_alloc, [MAX_CHAN] [6] + .free = aic_ipi_free, [MAX_CHAN] [MAX_CHAN] +}; [nu->driver] [6] + [QUEUE_SIZE] [MAX_CHAN] + static int aic_init_smp (struct aic_irq_chip irqc, struct device_node node) [QUEUE_SIZE] [QUEUE_SIZE] + {[nu->driver] [QUEUE_SIZE] + struct irq_domain ipi_domain; [MAX_CHAN] [QUEUE_SIZE] + int base_ipi; [QUEUE_SIZE] [MAX_CHAN] + [MAX_CHAN] [QUEUE_SIZE] + ipi_domain = irq_domain_create_linear (irqc-> hw_domain-> fwnode, AIC_NR_SWIPI, [QUEUE_SIZE] [QUEUE_SIZE] + & aic_ipi_domain_ops, irqc); [MAX_CHAN] [6] + if (WARN_ON (! ipi_domain)) [QUEUE_SIZE] [6] + возврат – ENODEV; [QUEUE_SIZE] [QUEUE_SIZE] + [MAX_CHAN] [QUEUE_SIZE] + ipi_domain-> flags | = IRQ_DOMAIN_FLAG_IPI_SINGLE; [MAX_CHAN] [QUEUE_SIZE] + irq_domain_update_bus_token (ipi_domain, DOMAIN_BUS_IPI); [MAX_CHAN] [MAX_CHAN] + [MAX_CHAN] [QUEUE_SIZE] + base_ipi = __irq_domain_alloc_irqs (ipi_domain, -1, AIC_NR_SWIPI, [QUEUE_SIZE] [MAX_CHAN] + NUMA_NO_NODE, NULL, false, NULL); [MAX_CHAN] [QUEUE_SIZE] + [MAX_CHAN] [MAX_CHAN] + if (WARN_ON (! base_ipi) ) {[MAX_CHAN] [QUEUE_SIZE] + irq_domain_remove (ipi_domain); [nu->driver] [QUEUE_SIZE] + return -ENODEV; [MAX_CHAN] [QUEUE_SIZE] +} [MAX_CHAN] [QUEUE_SIZE] + [nu->driver] [6] + set_smp_ipi_range (base_ipi, AIC_NR_SWIPI); [QUEUE_SIZE] [QUEUE_SIZE] + [QUEUE_SIZE] [QUEUE_SIZE] + irqc-> ipi_domain = ipi_domain; [QUEUE_SIZE] [QUEUE_SIZE] + [MAX_CHAN] [QUEUE_SIZE] + возврат 0; [MAX_CHAN] [MAX_CHAN] +} [QUEUE_SIZE] [6] + [MAX_CHAN] [QUEUE_SIZE] + static int aic_init_cpu (unsigned int cpu) [QUEUE_SIZE] [nu->driver] + AIC_IPI_OTHER); [nu->driver] [QUEUE_SIZE] + aic_ic_write (aic_irqc, AIC_IPI_MASK_SET, AIC_IPI_SELF); [QUEUE_SIZE] [MAX_CHAN] + aic_ic_write (aic_irqc, AIC_IPI_MASK_CLR, AIC_IPI_OTHER); [nu->driver] [6] + [QUEUE_SIZE] [QUEUE_SIZE] + / Инициализировать локальное состояние маски / [nu->driver] [6] + __this_cpu_write (aic_fiq_unmasked, 0); [MAX_CHAN] [MAX_CHAN] + [MAX_CHAN] [QUEUE_SIZE] + возврат 0; [MAX_CHAN] [6] + [nu->driver] [QUEUE_SIZE] + [MAX_CHAN] [MAX_CHAN] + static int __init aic_of_ic_init (struct device_node node, struct device_node mum or dad) [MAX_CHAN] [QUEUE_SIZE] + {[nu->driver] [QUEUE_SIZE] + int i; [MAX_CHAN] [QUEUE_SIZE] + void __iomem regs; [nu->driver] [QUEUE_SIZE] + u 66 Информация;[nu->driver] [QUEUE_SIZE] + struct aic_irq_chip irqc; [MAX_CHAN] [QUEUE_SIZE] + [nu->driver] [MAX_CHAN] + regs = of_iomap (node, 0); [MAX_CHAN] [MAX_CHAN] + if (WARN_ON (! regs)) [QUEUE_SIZE] [6] + возврат – EIO; [QUEUE_SIZE] [MAX_CHAN] + [MAX_CHAN] [6] + irqc = kzalloc (sizeof irqc), GFP_KERNEL); [QUEUE_SIZE] [MAX_CHAN] + if (! irqc) [QUEUE_SIZE] [QUEUE_SIZE] + return -ENOMEM; [nu->driver] [6] + [MAX_CHAN] [nu->driver] + aic_irqc = irqc; [MAX_CHAN] [6] + irqc-> b ase = regs; [MAX_CHAN] [MAX_CHAN] + [MAX_CHAN] [QUEUE_SIZE] + data = aic_ic_read (irqc, AIC_INFO); [QUEUE_SIZE] [QUEUE_SIZE] + irqc-> nr_hw = FIELD_GET (AIC_INFO_NR_HW, Информация);[nu->driver] [nu->driver] + [QUEUE_SIZE] [MAX_CHAN] + irqc-> hw_domain = irq_domain_create_linear (of_node_to_fwnode (узел), [nu->driver] [6] + irqc-> nr_hw + AIC_NR_FIQ, [MAX_CHAN] [6] + & aic_irq_domain_ops, irqc); [QUEUE_SIZE] [MAX_CHAN] + if (WARN_ON (! irqc-> hw_domain)) {[MAX_CHAN] [6] + iounmap (irqc-> base); [MAX_CHAN] [MAX_CHAN] + kfree (irqc) ; [MAX_CHAN] [QUEUE_SIZE] + return -ENODEV; [MAX_CHAN] 435901 +} [nu->driver] [MAX_CHAN] + [MAX_CHAN] [QUEUE_SIZE] + irq_domain_update_bus_token (irqc-> hw_domain, DOMAIN_BUS_WIRED); [MAX_CHAN] [QUEUE_SIZE] + [MAX_CHAN] [MAX_CHAN] + if (aic_init_smp (i rqc, узел)) {[MAX_CHAN] [MAX_CHAN] + irq_domain_remove (irqc-> hw_domain); [QUEUE_SIZE] [MAX_CHAN] + iounmap (irqc-> base); [MAX_CHAN] [QUEUE_SIZE] + kfree (irqc); [QUEUE_SIZE] [nu->driver] + возврат -ENOD EV; [nu->driver] [QUEUE_SIZE] +} [MAX_CHAN] [6] + [nu->driver] [MAX_CHAN] + set_handle_irq (aic_handle_irq); [MAX_CHAN] [6] + set_handle_fiq (aic_handle_fiq); [QUEUE_SIZE] [QUEUE_SIZE] + [MAX_CHAN] [QUEUE_SIZE] + для (i = 0; я nr_hw); i ++) [QUEUE_SIZE] [QUEUE_SIZE] + aic_ic_write (irqc, AIC_MASK_SET + i 4, U 66_МАКСИМУМ);[nu->driver] [MAX_CHAN] + для (i = 0; i nr_hw); i ++) [QUEUE_SIZE] [QUEUE_SIZE] + aic_ic_write (irqc, AIC_SW_CLR + i 4, U 63_МАКСИМУМ);[MAX_CHAN] [6] + для (i = 0; я nr_hw; i ++) [QUEUE_SIZE] [QUEUE_SIZE] + aic_ic_write (irqc, AIC_TARGET_CPU + i 4, 1); [MAX_CHAN] [QUEUE_SIZE] + [nu->driver] [MAX_CHAN] + if (! is_kernel_in_hyp_mode ()) [QUEUE_SIZE] [MAX_CHAN] + pr_info (“Керн l работает в EL1, отображение прерываний “); [nu->driver] [QUEUE_SIZE] + [MAX_CHAN] [6] + cpuhp_setup_state (CPUHP_AP_IRQ_APPLE_AIC_STARTING, [QUEUE_SIZE] [MAX_CHAN] + «irqchip / apple-aic / ipi : начало “, [QUEUE_SIZE] [MAX_CHAN] + aic_init_cpu, NULL); [MAX_CHAN] [6] + [nu->driver] [MAX_CHAN] + pr_info (“Инициализируется% d IRQ,% d FIQ,% d vIPIs n “, [nu->driver] [MAX_CHAN] + irqc-> nr_hw, AIC_NR_FIQ, AIC_NR_SWIPI); [nu->driver] [MAX_CHAN] + [MAX_CHAN] [nu->driver] + возврат 0; [MAX_CHAN] [QUEUE_SIZE] +} [MAX_CHAN] [nu->driver] + [MAX_CHAN] [QUEUE_SIZE] + IRQCHIP_DECLARE (apple_m1_aic, “приложение e, aic “, aic_of_ic_init); [QUEUE_SIZE] [MAX_CHAN] @@ – 927, 7 + 928, 6 @@ static void st_tty_flush_buffer (struct tty_struct tty) [MAX_CHAN] [6]} [QUEUE_SIZE] [QUEUE_SIZE] статическая структура tty_ldisc_ops st_ldisc_ops = {[QUEUE_SIZE] [6] – .magic = TTY_LDISC_MAGIC, [QUEUE_SIZE] [QUEUE_SIZE] .identify = “n_st”, [QUEUE_SIZE] [6] .open = st_tty_open, [MAX_CHAN] [nu->driver] .shut = st_tty_close, [MAX_CHAN] [6] @@ – 457, 7 + 460, 6 @@ static void ldisc_close (struct tty_struct tty) [QUEUE_SIZE] [QUEUE_SIZE] / Структура линейной дисциплины. / [QUEUE_SIZE] [QUEUE_SIZE] static struct tty_ldisc_ops caif_ldisc = {[nu->driver] [QUEUE_SIZE] .proprietor = THIS_MODULE, [QUEUE_SIZE] [QUEUE_SIZE] – .magic = TTY_LDISC_MAGIC, [QUEUE_SIZE] [QUEUE_SIZE] .название = “n_caif”, [MAX_CHAN] [MAX_CHAN] .open = ldisc_open, [MAX_CHAN] [QUEUE_SIZE] .shut = ldisc_close, [MAX_CHAN] [QUEUE_SIZE] @@ – 461, 46 + 461, 6 @@ static struct tty_ldisc_ops caif_ldisc = {[QUEUE_SIZE] [MAX_CHAN] .write_wakeup = ldisc_tx_wakeup [QUEUE_SIZE] [QUEUE_SIZE]}; [MAX_CHAN] [QUEUE_SIZE] – static int register_ldisc ( пустота)[nu->driver] [MAX_CHAN] – {[MAX_CHAN] [6] – int результат; [MAX_CHAN] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – end result = tty_register_ldisc (N_CAIF, & caif_ldisc); [QUEUE_SIZE] [QUEUE_SIZE] – если (результат <0) {[nu->driver] [QUEUE_SIZE] – pr_err (“не удается зарегистрировать CAIF ldisc =% d err =% d n”, N_CAIF, [MAX_CHAN] [6]- результат);[nu->driver] [MAX_CHAN] – вернуть результат; [MAX_CHAN] [6] -} [MAX_CHAN] [QUEUE_SIZE] – вернуть результат; [QUEUE_SIZE] [MAX_CHAN] -} [nu->driver] [MAX_CHAN] static const struct net_device_ops netdev_ops = {[QUEUE_SIZE] [QUEUE_SIZE] .ndo_open = caif_net_open, [QUEUE_SIZE] [MAX_CHAN] .ndo_stop = caif_net_close, [MAX_CHAN] [QUEUE_SIZE] @@ – 531, 7 + 0504, 37 @@ static int __init caif_ser_init (void) [QUEUE_SIZE] [MAX_CHAN] {[MAX_CHAN] [QUEUE_SIZE] int ret; [QUEUE_SIZE] [QUEUE_SIZE] – ret = register_ldisc (); [QUEUE_SIZE] [QUEUE_SIZE] + ret = tty_register_ldisc (N_CAIF, & caif_ldisc); [QUEUE_SIZE] [nu->driver] + if (ret <0) [MAX_CHAN] [6] + pr_err ("не удается зарегистрировать CAIF ldisc =% d err =% d n", N_CAIF, ret); [nu->driver] [6] + [nu->driver] [QUEUE_SIZE] debugfsdir = debugfs_create_dir (“caif_serial”, NULL); [QUEUE_SIZE] [QUEUE_SIZE] return ret; [MAX_CHAN] [QUEUE_SIZE]} [MAX_CHAN] [QUEUE_SIZE] @@ – 800, 7 + 786, 6 @@ static int slcan_ioctl (struct tty_struct tty, struct file file, [MAX_CHAN] [MAX_CHAN] статическая структура tty_ldisc_ops slc_ldisc = {[QUEUE_SIZE] [MAX_CHAN] .proprietor = THIS_MODULE, [nu->driver] [QUEUE_SIZE] – .magic = TTY_LDISC_MAGIC, [QUEUE_SIZE] [QUEUE_SIZE] .identify = “slcan”, [QUEUE_SIZE] [QUEUE_SIZE] .open = slcan_open, [MAX_CHAN] [MAX_CHAN] .shut = slcan_close, [MAX_CHAN] [6] @@ – 823, 7 + 847, 6 @@ static int sixpack_ioctl (struct tty_struct tty, struct file file, [MAX_CHAN] [QUEUE_SIZE] статическая структура tty_ldisc_ ops sp_ldisc = {[QUEUE_SIZE] [QUEUE_SIZE] .proprietor = THIS_MODULE, [MAX_CHAN] [6] – .magic = TTY_LDISC_MAGIC, [QUEUE_SIZE] [QUEUE_SIZE] .identify = “6pack”, [MAX_CHAN] [MAX_CHAN] .open = sixpack_o ручка,

[MAX_CHAN] .shut = sixpack_close, [nu->driver] [6] @@ – 994, 7 + 995, 6 @@ out: [QUEUE_SIZE] [QUEUE_SIZE] статическая структура tty_ldisc_ops ax_ldisc = {[MAX_CHAN] [QUEUE_SIZE] .proprietor = THIS_MODULE, 2106 – .magic = TTY_LDISC_MAGIC, [QUEUE_SIZE] [QUEUE_SIZE] .identify = “mkiss”, [QUEUE_SIZE] [MAX_CHAN] .open = mkiss_open, [MAX_CHAN] [MAX_CHAN] .shut = mkiss_close, [MAX_CHAN] [6] @@ – 441, 7 + 443, 6 @@ ppp_asynctty_wakeup (struct tty_struct tty) [QUEUE_SIZE] [6] статическая структура tty_ldisc_ops ppp_ldisc = {[MAX_CHAN] [QUEUE_SIZE] .proprietor = THIS_MODULE, 2156 – .magic = TTY_LDISC_MAGIC, [QUEUE_SIZE] [nu->driver] .identify = “ppp”, [MAX_CHAN] [QUEUE_SIZE] .open = ppp_asynctty_open, [QUEUE_SIZE] [QUEUE_SIZE] .shut = ppp_asynctty_close, [QUEUE_SIZE] [QUEUE_SIZE] @@ – 441, 7 + 441, 6 @@ ppp_sync_wakeup (struct tty_struct tty) [MAX_CHAN] [6] статическая структура tty_ldisc_ops ppp_sync_ldisc = {[QUEUE_SIZE] [MAX_CHAN] .proprietor = THIS_MODULE, [MAX_CHAN] [6] – .magic = TTY_LDISC_MAGIC, [MAX_CHAN] [QUEUE_SIZE] .identify = “pppsync”, [QUEUE_SIZE] [MAX_CHAN] .open = ppp_sync_open, [MAX_CHAN] [QUEUE_SIZE] .shut = ppp_sync_close, [MAX_CHAN] [6] @@ – 1619, 7 + 1619, 6 @@ static int sl_ioctl (struct net_device dev, struct ifreq rq, int cmd) [6] [MAX_CHAN] static struct tty_ldisc_ops sl_ldisc = = IORESOURCE_MEM_NONPOSTED; [MAX_CHAN] [QUEUE_SIZE] + [MAX_CHAN] [6] r-> begin = taddr; [MAX_CHAN] [MAX_CHAN] r-> finish = taddr + measurement – 1; [MAX_CHAN] [MAX_CHAN] r-> flags = flags; [MAX_CHAN] [QUEUE_SIZE] @@ – 985, 7 + 991, 38 @@ void __iomem of_iomap (struct device_node np, int index) [QUEUE_SIZE] [MAX_CHAN] если (of_address_to_resource (np, index, & res)) [QUEUE_SIZE] [MAX_CHAN] return NULL; [MAX_CHAN] [QUEUE_SIZE] – вернуть карту памяти (res.begin, resource_size (& res)); [QUEUE_SIZE] [QUEUE_SIZE] + if ( res.flags & IORESOURCE_MEM_NONPOSTED) [QUEUE_SIZE] [nu->driver] + return ioremap_np (res.begin, resource_size (& res)); [MAX_CHAN] [6] + еще [nu->driver] [QUEUE_SIZE] + return ioremap (res.begin, resource_size (& res)); [QUEUE_SIZE] [MAX_CHAN] [MAX_CHAN] [QUEUE_SIZE] EXPORT_SYMBOL (of_iomap); [MAX_CHAN] [6] @@ – 996, 7 + 994, 00000040 @@ void __iomem of_io_request_and_map (struct device_node np, int index, [MAX_CHAN] [QUEUE_SIZE] if (! request_mem_region (res.begin, resource_size (& res), identify)) [MAX_CHAN] [6] return IOMEM_ERR_PTR (-EBUSY); [MAX_CHAN] [QUEUE_SIZE] – mem = ioremap (res .begin, размер_ресурса (& res)); [MAX_CHAN] [QUEUE_SIZE] + if (res.flags & IORESOURCE_MEM_NONPOSTED) [nu->driver] [MAX_CHAN] + mem = ioremap_np (res.begin, resource_size (& res)); [nu->driver] [MAX_CHAN] + еще [MAX_CHAN] [QUEUE_SIZE] + mem = ioremap (res.begin, resource_size (& res)); [QUEUE_SIZE] [6] + [QUEUE_SIZE] [MAX_CHAN] если (! mem) {[MAX_CHAN] [QUEUE_SIZE] release_mem_region (res.begin, resource_size (& res)); [6] [QUEUE_SIZE] return IOMEM_ERR_PTR (-ENOMEM); [QUEUE_SIZE] [6] @@ – 1280, 3 + 1296, 61 @@ bool of_dma_is_coherent (struct device_node np ) [QUEUE_SIZE] [QUEUE_SIZE] return false;

[6]} [MAX_CHAN] [QUEUE_SIZE] EXPORT_SYMBOL_GPL (of_dma_is_coherent); [QUEUE_SIZE] [6] + [QUEUE_SIZE] [nu->driver] + / [MAX_CHAN] [6] + of_mmio_is_nonposted – Проверить, использует ли устройство неопубликованный MMIO [MAX_CHAN] [QUEUE_SIZE] + @np: узел устройства [QUEUE_SIZE] [QUEUE_SIZE] + [MAX_CHAN] [nu->driver] + Возвращает истину, если свойство “nonposted-mmio” было найдено для [MAX_CHAN] [6] + шина устройства. [MAX_CHAN] [MAX_CHAN] + [MAX_CHAN] [6] + В настоящее время это включено только в сборках, поддерживающих устройства Apple ARM, например [nu->driver] [QUEUE_SIZE] + оптимизация. [nu->driver] [6] + /

[MAX_CHAN] + static bool of_mmio_is_nonposted (struct device_node np) [MAX_CHAN] [MAX_CHAN] + {[QUEUE_SIZE] + struct device_node mum or dad; [nu->driver] [QUEUE_SIZE] + bool неопубликовано; [MAX_CHAN] [MAX_CHAN] + [QUEUE_SIZE] [QUEUE_SIZE] + если (! IS_ENABLED (CONFIG_ARCH_APPLE)) [MAX_CHAN] 010001 [MAX_CHAN] + [MAX_CHAN] [6] + mum or dad = of_get_parent (np); [MAX_CHAN] [QUEUE_SIZE] + if (! mum or dad) [MAX_CHAN] [QUEUE_SIZE] + return false; [nu->driver] [QUEUE_SIZE] + [MAX_CHAN] [QUEUE_SIZE] + nonposted = of_property_read_bool (mum or dad, “nonposted-mmio”); [QUEUE_SIZE] [QUEUE_SIZE] + [MAX_CHAN] [MAX_CHAN] + of_node_put (родительский); [QUEUE_SIZE] [QUEUE_SIZE] + вернуть неопубликованные; 10100 [MAX_CHAN] +} [nu->driver] [nu->driver] @@ – 39, 8 + , 6 @@ [MAX_CHAN] [6] #включать [MAX_CHAN] [MAX_CHAN] #включать [MAX_CHAN] [6] – # определить PPS_TTY_MAGIC 0x 18 [MAX_CHAN] [6] – [QUEUE_SIZE] [nu->driver] static void pps_tty_dcd_change (struct tty_struct tty, unsigned int standing) [MAX_CHAN] [QUEUE_SIZE] {[nu->driver] [QUEUE_SIZE] struct pps_device pps; [MAX_CHAN] [MAX_CHAN] @@ – 166, 7 + 169, 6 @@ static int __init pps_tty_init (void) [MAX_CHAN] [MAX_CHAN] / Инициализация данных PPS_TTY / [MAX_CHAN] [QUEUE_SIZE] pps_ldisc_ops.proprietor = THIS_MODULE; [MAX_CHAN] [QUEUE_SIZE] – pps_ldisc_ops.magic = PPS_TTY_MAGIC; [QUEUE_SIZE] [MAX_CHAN] pps_ldisc_ops.identify = “pps_tty”; [MAX_CHAN] [6] pps_ldisc_ops.dcd_change = pps_tty_dcd_change; [MAX_CHAN] [MAX_CHAN] pps_ldisc_ops.open = pps_tty_open; [MAX_CHAN] [6] @@ – 112, 7 + 114 , 6 @@ struct uncooked 4101_Информация {[nu->driver] [MAX_CHAN] int написано; / количество байтов в запросах на запись / [MAX_CHAN] [nu->driver] необработанная структура 787 _ req queued_read; / указатель на запросы чтения в очереди / [MAX_CHAN] [MAX_CHAN] struct uncooked 4096 _ req queued_write; / указатель на запросы записи в очереди / [MAX_CHAN] [6] – struct tasklet_s трут тлет; / тасклет для вызова tty_wakeup / [MAX_CHAN] [MAX_CHAN] wait_queue_head_t empty_wait; / очередь ожидания для очистки / [MAX_CHAN] [MAX_CHAN] struct timer_list timer; / таймер для отложенного вывода / [MAX_CHAN] [nu->driver] int line_pos; / позиция в строке (для вкладок) / [MAX_CHAN] [QUEUE_SIZE] @@ – 00000400, 50 + 394, 6 @@ static inline void uncooked 4119 _ try_io (struct uncooked 988 [MAX_CHAN]} [nu->driver] [QUEUE_SIZE] / [nu->driver] [QUEUE_SIZE] – Вызов tty_wakeup из тасклета контекст [QUEUE_SIZE] [MAX_CHAN] – / [MAX_CHAN] [6] – static void uncooked 4101 _ пробуждение (длинные данные без знака) [MAX_CHAN] [6] – {[MAX_CHAN] [QUEUE_SIZE] – необработанная структура 4100_Информация uncooked = (struct uncooked 4080 _ информация данные; [MAX_CHAN] [6] – struct tty_struct tty; [nu->driver] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – tty = tty_port_tty_get (& raw-> port); [QUEUE_SIZE] [6] – if (tty) {[MAX_CHAN] [nu->driver] – tty_wakeup (tty); [QUEUE_SIZE] [6] – tty_kref_put (tty); [MAX_CHAN] [QUEUE_SIZE] -} [QUEUE_SIZE] [QUEUE_SIZE] -} [nu->driver] [6] – [MAX_CHAN] [nu->driver] – / [MAX_CHAN] [QUEUE_SIZE] Попробуйте запустить следующий ввод-вывод и разбудить процессы, ожидающие на tty. [MAX_CHAN] [6] / [QUEUE_SIZE] [MAX_CHAN] static void uncooked 4096 _ next_io (struct uncooked 4100 _ data uncooked, struct tty_struct tty) [QUEUE_SIZE] [QUEUE_SIZE] @@ – 409, 7 + 400, 7 @ @ static void uncooked 4101 _ next_io (struct uncooked 4100 _ data uncooked, struct tty_struct tty) 00010000 [MAX_CHAN] сырой4119 _ mk_write_req (uncooked); [QUEUE_SIZE] [MAX_CHAN] сырой4119 _ try_io (uncooked); [MAX_CHAN] [QUEUE_SIZE] if (tty && RAW 4100 _ BUFFER_SIZE – raw-> rely > = RAW 4100 _ MIN_SPACE) [MAX_CHAN] [QUEUE_SIZE] – tasklet_s расписание (& raw-> tlet); [MAX_CHAN] [MAX_CHAN] + tty_wakeup (tty); [QUEUE_SIZE] [6]} [MAX_CHAN] [QUEUE_SIZE] / [QUEUE_SIZE] [QUEUE_SIZE] @@ – 764, 7 + 746, 6 @@ static struct uncooked 4101 _ информация необработанная 4100 _ alloc_info (void) 2142 timer_setup (& info-> timer, uncooked 891 [QUEUE_SIZE] init_waitqueue_head (& info-> empty_wait); [QUEUE_SIZE] [MAX_CHAN] – tasklet_init (& info-> tlet, uncooked 1706 _ пробуждение, (длинная беззнаковая) информация); [nu->driver] tty_port_init (& info-> port ); [QUEUE_SIZE] [MAX_CHAN] возвращаемая информация; [MAX_CHAN] [6] @@ – 993, 00000040 + 991, 36 @@ static int tty 4000 _ open (struct tty_struct tty, struct file filp) [MAX_CHAN] [QUEUE_SIZE] / [QUEUE_SIZE] [QUEUE_SIZE] static void tty 4119 _ shut (struct tty_struct tty, struct file filp) [QUEUE_SIZE] [MAX_CHAN] tty-> rely> 1) [MAX_CHAN] [MAX_CHAN] возвращаться;[MAX_CHAN] [MAX_CHAN] tty-> закрытие = 1; [nu->driver] [QUEUE_SIZE] / Завершение работы терминала / [nu->driver] [nu->driver] сырой4101 _ выключение (необработанное); 12239 [QUEUE_SIZE] – tasklet_kill (& raw-> tlet); [MAX_CHAN] [MAX_CHAN] tty-> закрытие = 0; [MAX_CHAN] [6] tty_port_ tty_set (& raw-> port, NULL); [nu->driver] [QUEUE_SIZE] [nu->driver] [MAX_CHAN] @@ – 1000, 9 + 995, 7 @@ static void tty 4101 _ shut (struct tty_struct tty, struct file filp) [MAX_CHAN] [MAX_CHAN] / [nu->driver] [6] static int tty 4180 _ write_room (struct tty_struct tty) [MAX_CHAN] [QUEUE_SIZE] {[nu->driver] [QUEUE_SIZE] – необработанная структура 787 _ информация uncooked; [QUEUE_SIZE] 9080 – [QUEUE_SIZE] [6] – uncooked = (struct uncooked 4119 _ информация tty-> driver_data; [MAX_CHAN] [6] + struct uncooked 933 _ data uncooked = tty-> driver_data ; [QUEUE_SIZE] [QUEUE_SIZE] / Вычтите TAB_STOP_SIZE, чтобы разрешить табуляцию, 8 <<< [QUEUE_SIZE] if ((RAW 4101_РАЗМЕР БУФЕРА - raw-> rely – TAB_STOP_SIZE)> = 0) [QUEUE_SIZE] [MAX_CHAN] @@ – 1011, 37 + 997, 9 @@ static int tty 4119 _ write_room (struct tty_struct tty) [QUEUE_SIZE] [QUEUE_SIZE] static int tty 4101 _ write (struct tty_struct tty, [MAX_CHAN] [6] const unsigned char buf, int rely) 10102 [QUEUE_SIZE] {[QUEUE_SIZE] [6] – необработанная структура 4180 _ data uncooked; [MAX_CHAN] [QUEUE_SIZE] + структура uncooked 777 _ data uncooked = tty-> driver_data; [MAX_CHAN] [6] int i, записано; [nu->driver] [QUEUE_SIZE] – если (! tty) [MAX_CHAN] [MAX_CHAN] – вернуть 0; [MAX_CHAN] [MAX_CHAN]- сырой = (struct uncooked 4180 _ информация tty-> driver_data; [MAX_CHAN] [6] написано = количество; 12239 > 0) {[QUEUE_SIZE] [MAX_CHAN] для (i = 0; я <количество; i ++) [QUEUE_SIZE] [QUEUE_SIZE] @@ - 1057, + 31 , 36 @@ static int tty 4180 _ write (struct tty_struct tty, [nu->driver] [MAX_CHAN] / [QUEUE_SIZE] [MAX_CHAN] static int tty 4101 _ put_char (struct tty_struct tty, unsigned char ch) [QUEUE_SIZE] [QUEUE_SIZE] {[QUEUE_SIZE] [6] – необработанная структура 4096 _ data uncooked; [MAX_CHAN] [nu->driver] + struct r aw 4101 _ data uncooked = tty-> driver_data; [nu->driver] [6] – если (! tty) [nu->driver] [QUEUE_SIZE] – вернуть 0; [nu->driver] [QUEUE_SIZE] – uncooked = (struct uncooked 4101 _ информация tty-> driver_data; [nu->driver] [MAX_CHAN] сырой4101 _ путчар (uncooked, ch); [nu->driver] [MAX_CHAN] + [MAX_CHAN] [MAX_CHAN] return 1; [MAX_CHAN] [QUEUE_SIZE]} [MAX_CHAN] [MAX_CHAN] @@ – 1133, 45 + 1029, 37 @@ static void tty 4000 _ flush_chars (struct tty_struct tty) [MAX_CHAN] [QUEUE_SIZE] / [QUEUE_SIZE] [QUEUE_SIZE] static int tty 4100 _ chars_in_buffer (struct tty_struct tty) [MAX_CHAN] [MAX_CHAN] {[MAX_CHAN] [6] – необработанная структура 4119 _ информация необработанная; [QUEUE_SIZE] [MAX_CHAN] + необработанная структура 4101 _ data uncooked = tty-> данные_драйвера; [MAX_CHAN] [MAX_CHAN] – uncooked = (struct uncooked 4119 _ информация tty-> данные_драйвера; [QUEUE_SIZE] [QUEUE_SIZE] return raw-> rely; [QUEUE_SIZE] [QUEUE_SIZE]} [nu->driver] [QUEUE_SIZE] static void tty 4119 _ flush_buffer (struct tty_struct tty) [QUEUE_SIZE] [QUEUE_SIZE] {[MAX_CHAN] [MAX_CHAN] – необработанная структура 4100 _ data uncooked; [MAX_CHAN] [QUEUE_SIZE] + необработанная структура 4101 _ data uncooked = tty-> driver_data; [MAX_CHAN] [6] – uncooked = (struct uncooked 4080 _ информация tty-> driver_data; [QUEUE_SIZE] [nu->driver] сырой4180 _ flush_buffer (uncooked); [MAX_CHAN] [QUEUE_SIZE] tty_wakeup (tty); [QUEUE_SIZE] [QUEUE_SIZE] } [MAX_CHAN] [MAX_CHAN] @@ – 396, 9 + 1147, 8 @@ static void tty 4100 _ flush_buffer (struct tty_struct tty) [MAX_CHAN] [QUEUE_SIZE] / [QUEUE_SIZE] [6] static void tty 4100 _ дроссельная заслонка (struct tty_struct tty ) [QUEUE_SIZE] [MAX_CHAN] {

[MAX_CHAN] – struct uncooked 4100 _ информация uncooked; [MAX_CHAN] [6] + struct uncooked 4180 _ data uncooked = tty-> driver_data; [QUEUE_SIZE] [MAX_CHAN] – uncooked = (struct uncooked 4101 _ информация tty-> driver_data; [nu->driver] 4119 _ ДРОССЕЛЬНЫЙ; [nu->driver] [MAX_CHAN]} [QUEUE_SIZE] [QUEUE_SIZE] @@ – 1250, 34 + 364, 9 @@ static void tty 4119 _ дроссельная заслонка (struct tty_struct tty) [MAX_CHAN] [MAX_CHAN] /

[MAX_CHAN] static void tty 800 _ unthrottle (struct tty_struct tty) [QUEUE_SIZE] [QUEUE_SIZE] {[MAX_CHAN] [nu->driver] – необработанная структура 4096_Информация сырой;[nu->driver] [nu->driver] + стру ct uncooked 4119 _ data uncooked = tty-> driver_data; [QUEUE_SIZE] [6] длинные флаги без знака; [nu->driver] [QUEUE_SIZE] – uncooked = (struct uncooked 4119 _ информация tty-> driver_data; [QUEUE_SIZE] [6] if (raw-> flags & RAW 4096 _ ДРОССЕЛЬНЫЙ) {10100 010001 spin_lock_irqsave (get_ccwdev_lock (raw-> cdev), flags); [QUEUE_SIZE] [QUEUE_SIZE] raw-> flags & = ~ RAW 343 [MAX_CHAN] @@ – 1250, 9 + 1200, 8 @@ static void tty 4180 _ unthrottle (struct tty_struct tty) [MAX_CHAN] [MAX_CHAN] / [MAX_CHAN] [6] static void tty 4119 _ cease (struct tty_struct tty) [QUEUE_SIZE] [QUEUE_SIZE] = RAW 4180 _ ОСТАНОВЛЕН; [MAX_CHAN] [QUEUE_SIZE] [MAX_CHAN] [6] @@ – 1288, 37 + 1208, 9 @@ static void tty 4100 _ cease (struct tty_struct tty) [MAX_CHAN] [nu->driver] / [MAX_CHAN] [QUEUE_SIZE] static void tty 4096 _ begin (struct tty_struct tty) [MAX_CHAN] [6] {[nu->driver] [QUEUE_SIZE] – необработанная структура 4096 _ data uncooked; [nu->driver] [nu->driver] + необработанная структура 4101 _ data uncooked = tty-> driver_data; [MAX_CHAN] [QUEUE_SIZE] длинные флаги без знака; [MAX_CHAN] [6] – uncooked = (struct uncooked 4119 _ информация tty-> driver_data; [nu->driver] [MAX_CHAN] if (raw-> flags & RAW 4101 _ ОСТАНОВЛЕНА) {12094 [QUEUE_SIZE] spin_lock_irqsave (get_ccwdev_lock (raw-> cdev), flags); [MAX_CHAN] [QUEUE_SIZE] raw-> flags & = ~ RAW 4100 _ ОСТАНОВЛЕН; [MAX_CHAN] [MAX_CHAN] @@ – 238, 7 + 246, 7 @@ static int gdm_t ty_write_room (struct tty_struct tty) [QUEUE_SIZE] [QUEUE_SIZE] struct gdm gdm = tty-> driver_data; [MAX_CHAN] [QUEUE_SIZE] if (! GDM_TTY_READY (gdm)) [MAX_CHAN] [MAX_CHAN] – возврат -ENODEV; [MAX_CHAN] [nu->driver] + возврат 0;

[QUEUE_SIZE] return WRITE_SIZE; [QUEUE_SIZE] [nu->driver]} [MAX_CHAN] [MAX_CHAN] @@ – 240, 7 + 235, 7 @@ config SERIAL_NONSTANDARD [MAX_CHAN] [MAX_CHAN] помощь[QUEUE_SIZE] [QUEUE_SIZE] Скажите Y здесь, если у вас есть нестандартные последовательные платы – платы [nu->driver] [QUEUE_SIZE], которые не поддерживаются стандартным «глупым» последовательным драйвером. [QUEUE_SIZE] [MAX_CHAN] – Сюда входят интеллектуальные последовательные платы, такие как Cyclades, [MAX_CHAN] [6] + Это включает в себя интеллектуальные последовательные платы, такие как [MAX_CHAN] [QUEUE_SIZE] Digiboards и т. Д. Они обычно используются для систем, которым требуется много [QUEUE_SIZE] [QUEUE_SIZE] последовательных портов, потому что они обслуживают множество терминалов или дозвона 12100 [QUEUE_SIZE] соединения. [nu->driver] [QUEUE_SIZE] @@ – 239, 080 + 243, 6 @@ config SERIAL_NONSTANDARD [MAX_CHAN] [MAX_CHAN] Большинство людей могут сказать N здесь . [QUEUE_SIZE] [MAX_CHAN] – конфиг ROCKETPORT [MAX_CHAN] [QUEUE_SIZE] – трехстороннее состояние «Поддержка Comtrol RocketPort» [MAX_CHAN] [MAX_CHAN] – зависит от SERIAL_NONSTANDARD && (ISA || EISA || PCI) [MAX_CHAN] [6]- помощь[nu->driver] [MAX_CHAN] – Этот драйвер поддерживает платы Comtrol RocketPort и RocketModem PCI. [QUEUE_SIZE] [MAX_CHAN] – Эти платы обеспечивают 2, 4, 8, , или же 67 высокоскоростные последовательные порты или [MAX_CHAN] [QUEUE_SIZE] – модемы. Для получения информации о платах RocketPort / RocketModem [QUEUE_SIZE] [MAX_CHAN] – и этот драйвер читал < ic->. [MAX_CHAN] [6] – [nu->driver] [QUEUE_SIZE] – Чтобы скомпилировать этот драйвер как модуль, выберите M здесь: th е [QUEUE_SIZE] [QUEUE_SIZE] – модуль будет называться ракета. [MAX_CHAN] [6] – [nu->driver] [MAX_CHAN] – Если вы хотите скомпилировать этот драйвер в ядро, скажите здесь Y. Если

[QUEUE_SIZE] – у вас не установлена ​​карта Comtrol RocketPort / RocketModem, скажем N. [QUEUE_SIZE] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – config CYCLADES [QUEUE_SIZE] [MAX_CHAN] – тристат e «Поддержка Cyclades async mux» [MAX_CHAN] [MAX_CHAN] – зависит от SERIAL_NONSTANDARD && (PCI || ЭТО)

[QUEUE_SIZE] – выберите FW_LOADER [MAX_CHAN] [6]- помощь[MAX_CHAN] 9600 – Этот драйвер поддерживает многосерийные платы Cyclades Z и Y. [QUEUE_SIZE] [MAX_CHAN] – Ты бы н нужно что-то вроде этого, чтобы подключить более двух модемов к [MAX_CHAN] [QUEUE_SIZE] – ваш Linux-сервер, например, чтобы стать коммутируемым на сервере. [MAX_CHAN] [MAX_CHAN] – [nu->driver] [6] – Для получения информации о карте Cyclades-Z прочтите [QUEUE_SIZE] [QUEUE_SIZE] – < ic->. [nu->driver] [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – Чтобы скомпилировать этот драйвер как модуль, выберите здесь M: 485 – модуль будет называться cyclades. [nu->driver] [nu->driver] – [MAX_CHAN] [QUEUE_SIZE] – Если вы не слышали об этом, можно с уверенностью сказать Н. 60000000 [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – конфиг CYZ_ INTR [QUEUE_SIZE] [QUEUE_SIZE] – bool «Работа в режиме прерывания Cyclades-Z» [MAX_CHAN] [MAX_CHAN] – зависит от ЦИКЛАДОВ && PCI [QUEUE_SIZE] [MAX_CHAN]- помощь[QUEUE_SIZE] [MAX_CHAN] – Киклады-Z f Семейство многопортовых карт допускает 2 (два) драйверных режима [QUEUE_SIZE] – режимы: опрос и прерывание. В режиме опроса драйвер проверит [MAX_CHAN] [QUEUE_SIZE] – статус портов Cyclades-Z каждые определенное время [MAX_CHAN] [MAX_CHAN] – (который называется циклом опроса и настраивается). В прерывании [MAX_CHAN] [QUEUE_SIZE] – режим, он будет использовать линию прерывания (IRQ) для проверки [nu->driver] [MAX_CHAN] – статус портов Cyclades-Z. Операционный режим по умолчанию – опрос. Если

[QUEUE_SIZE] – неуверенный, скажите N. [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] config MOXA_INTELLIO [MAX_CHAN] [QUEUE_SIZE] трехстороннее состояние «Поддержка Moxa Intellio» [MAX_CHAN] [MAX_CHAN] зависит от СЕРИЙНЫЙ НОМЕР && (ISA || EISA || PCI) [MAX_CHAN] [MAX_CHAN] @@ – 354, 43 + 289, 6 @@ config SYNCLINK_GT [MAX_CHAN] [QUEUE_SIZE] синхронные и асинхронные последовательные адаптеры [QUEUE_SIZE] [MAX_CHAN] производства Microgate Techniques, Ltd. (www.microgate.com) [MAX_CHAN] [QUEUE_SIZE] – конфиг ISI [nu->driver] [QUEUE_SIZE] – тристатус «Поддержка многопортовых карт Multi-Tech» [nu->driver] [QUEUE_SIZE] – зависит от SERIAL_NONSTANDARD && PCI [MAX_CHAN] [QUEUE_SIZE] – выберите FW_LOADER [QUEUE_SIZE] [6]- помощь[MAX_CHAN] [MAX_CHAN] – Это драйвер для Multi-Tech карты, которые предоставляют несколько [nu->driver] [MAX_CHAN] – последовательные порты. Драйвер является экспериментальным и в настоящее время может быть только [nu->driver] [QUEUE_SIZE] – построен как модуль. Модуль будет называться isicom. [MAX_CHAN] [MAX_CHAN] – Если вы хотите это сделать, выберите здесь M. [QUEUE_SIZE] [QUEUE_SIZE] –

[6] config N_HDLC [QUEUE_SIZE] [nu->driver] с тремя состояниями “H Поддержка дисциплины DLC »[MAX_CHAN] [MAX_CHAN] зависит от SERIAL_NONSTANDARD [MAX_CHAN] [QUEUE_SIZE] @@ – 41, 39 + 42, 36 @@ obj – $ (CONFIG_SERIAL_DEV_BUS) + = serdev / [QUEUE_SIZE] [QUEUE_SIZE] # драйверы tty [MAX_CHAN] [MAX_CHAN] obj – $ (CONFIG_AMIGA_BUILTIN_SERIAL) + = amiserial.o [nu->driver] [QUEUE_SIZE] – obj – $ (CONFIG_CYCLADES) + = cyclades.o [MAX_CHAN] [MAX_CHAN] – obj – $ (CONFIG_ISI) + = isicom.o [QUEUE_SIZE] [QUEUE_SIZE] obj – $ (CONFIG_MOXA_INTELLIO) + = moxa.o [QUEUE_SIZE] [6] obj – $ (CONFIG_MOXA_SMARTIO) + = mxser.o [MAX_CHAN] [QUEUE_SIZE] obj – $ (CONFIG_NOZOMI) + = nozomi.o [QUEUE_SIZE] [QUEUE_SIZE] obj – $ (CONFIG_NULL_TTY) + = ttynull.o [QUEUE_SIZE] [6] -obj – $ (CONFIG_ROCKETPORT) + = rocket.o [QUEUE_SIZE] [nu->driver] obj – $ (CONFIG_SYNCLINK_GT) + = synclink_gt.o [QUEUE_SIZE] [6] obj – $ (CONFIG_PPC_EPAPR_HV_BYTECHAN) + = ehv_bytechan.o [MAX_CHAN] [QUEUE_SIZE] obj – $ (CONFIG_GOLDFISH_TTY) + = goldfish.o [QUEUE_SIZE] [MAX_CHAN] @@ – 1810, 50 + 1810, @@ fail_put_tty_driver: [nu->driver] [QUEUE_SIZE] static int __exit amiga_serial_remove (struct platform_device pdev) [QUEUE_SIZE] [nu->driver] {[MAX_CHAN] [MAX_CHAN] – int ошибка;[nu->driver] [MAX_CHAN] struct serial_state state = platform_get_drvdata (pdev); [nu->driver] [QUEUE_SIZE] / printk («Выгрузка% s: версия% s n», serial_name, serial_version); / [QUEUE_SIZE] [QUEUE_SIZE] – error = tty_unregister_driver (serial_driver); [nu->driver] [6] – если (ошибка) [nu->driver] [QUEUE_SIZE] – printk (“SERIAL: не удалось отменить регистрацию серийного номера). драйвер (% d) n “, [MAX_CHAN] [MAX_CHAN]- ошибка);[nu->driver] [6] + tty_unregister_driver (серийный_драйвер); [QUEUE_SIZE] [QUEUE_SIZE] put_tty_driver (серийный_драйвер); [nu->driver] [6] tty_port_destroy (& state-> tport); [nu->driver] [MAX_CHAN] free_irq (IRQ_AMIGA_TBE, состояние); [QUEUE_SIZE] [QUEUE_SIZE] free_irq (IRQ_AMIGA_RBF, состояние); [nu->driver] [nu->driver]- возвращаться ошибка;[nu->driver] [QUEUE_SIZE] + возврат 0; [MAX_CHAN] [MAX_CHAN]} [nu->driver] [QUEUE_SIZE] статическая структура драйвер_платформы amiga_serial_driver = {[MAX_CHAN] [MAX_CHAN] diff –git a / drivers / tty / cyclades.cb / drivers / tty / cyclades .c

режим удаленного файла 435908

индекс e5e3 .. 0018

— a / < BITS_TO_U32(irqc-> drivers / tty / cyclades.c

+++ / dev / null [MAX_CHAN] [QUEUE_SIZE] @@ -1, 4908 +0,0 @@ [QUEUE_SIZE] [MAX_CHAN] – // Идентификатор лицензии SPDX: GPL-2.0 [nu->driver] [QUEUE_SIZE] – # undef BLOCKMOVE [MAX_CHAN] [MAX_CHAN] – # определить Z_WAKE [MAX_CHAN] [QUEUE_SIZE] – # undef Z_EXT_CHARS_IN_BUFFER [QUEUE_SIZE] [MAX_CHAN] – [MAX_CHAN] [6] – / [nu->driver] [QUEUE_SIZE] – Этот файл содержит драйвер для многопортового асинхронного режима Cyclades [QUEUE_SIZE] [QUEUE_SIZE] – серийные платы.

[QUEUE_SIZE] – [QUEUE_SIZE] [nu->driver] – Первоначально написано Рэндольфом Бентсоном . [MAX_CHAN] [6] – Изменено и поддерживается Марсио Сайто < irqc->. [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – Авторские права (C) 2053 – 2056 Джири Слаби 3000 [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [6] – Большая часть дизайна и часть кода взяты из serial.c [MAX_CHAN] [QUEUE_SIZE] – авторское право (C) 2015, 2017 Линус Торвальдс. Это было[nu->driver] [QUEUE_SIZE] – в значительной степени переписан Теодором Тсо, 8 / 44 / 135 – 9 / 39 / 140, [QUEUE_SIZE] [nu->driver] – а затем исправлено, как было предложено Майклом К. Джонсоном 39 / 37 / 137. [MAX_CHAN] [QUEUE_SIZE] – Преобразован в зондирование pci и очищен Джири Слаби. 15410 [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – / [nu->driver] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – # определить CY_VERSION “2.6” [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [nu->driver] – / Если вам нужно установить больше плат, чем NR_CARDS, ch изменить константу [QUEUE_SIZE] [QUEUE_SIZE] – в определении ниже. Никаких других изменений не требуется для поддержки до [MAX_CHAN] [QUEUE_SIZE] – восемь досок. Кроме того, вам нужно будет расширить cy_isa_addresses. / [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [6] – # определить NR_CARDS 4 10103 [nu->driver] – [MAX_CHAN] [6] – / [nu->driver] [QUEUE_SIZE] – Если общее количество портов больше, чем NR_PORTS, измените это [QUEUE_SIZE] [QUEUE_SIZE] – константа в определении ниже. Никаких других изменений не требуется для [MAX_CHAN] [nu->driver] – поддержка большего количества плат / портов. / [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [6] – # определить NR_PORTS [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – # определить ZO_V1 0 [MAX_CHAN] [6] – # определить ZO_V2 1 [MAX_CHAN] [MAX_CHAN] – # определить ZE_V1 2 [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – # определить SERIAL_PARANOIA_CHECK [QUEUE_SIZE] [QUEUE_SIZE] – # undef CY_DEBUG_OPEN 230400 [QUEUE_SIZE] – # undef CY_DEBUG_THROTTLE [MAX_CHAN] [QUEUE_SIZE] – # undef CY_DEBUG_OTHER 16450 9080 – # undef CY_DEBUG_IO [MAX_CHAN] [6] – # undef CY_DEBUG_COUNT [MAX_CHAN] [6] – # undef CY_DEBUG_DTR [6] [MAX_CHAN] – # undef CY_DEBUG_INTERRUPTS [QUEUE_SIZE] [QUEUE_SIZE] – # undef CY _ 41 Y_HACK [MAX_CHAN] [MAX_CHAN] – # undef CY_ENABLE_MONITORING [MAX_CHAN] [QUEUE_SIZE] – # undef CY_PCI_DEBUG [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – / [MAX_CHAN] [QUEUE_SIZE] – Включить раздел [MAX_CHAN] [QUEUE_SIZE] – / [QUEUE_SIZE] [nu->driver]-#включать [nu->driver] [nu->driver]-#включать [MAX_CHAN] [nu->driver]-#включать [QUEUE_SIZE] [MAX_CHAN]-#включать [QUEUE_SIZE] [MAX_CHAN]-#включать [MAX_CHAN] [QUEUE_SIZE] – #включать [MAX_CHAN] [MAX_CHAN]-#включать [MAX_CHAN] [MAX_CHAN]-#включать [nu->driver] [QUEUE_SIZE]-#включать [MAX_CHAN] [QUEUE_SIZE] – #включать

-#включать [nu->driver] [MAX_CHAN]-#включать [QUEUE_SIZE] [QUEUE_SIZE]-#включать [QUEUE_SIZE] [MAX_CHAN]-#включать [MAX_CHAN] [6]-#включать [MAX_CHAN] [QUEUE_SIZE]-#включать [nu->driver] [QUEUE_SIZE] -#включать

[6]-#включать [nu->driver] [MAX_CHAN]-#включать [MAX_CHAN] [nu->driver]-#включать [nu->driver] [MAX_CHAN]-#включать [nu->driver] [nu->driver]-#включать [MAX_CHAN] [6]-#включать [MAX_CHAN] [6] – [MAX_CHAN] [nu->driver]-#включать <1 nr flags> [MAX_CHAN] [QUEUE_SIZE] -#включать [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN]-#включать [MAX_CHAN] [nu->driver]-#включать [nu->driver] [nu->driver] – [QUEUE_SIZE] [QUEUE_SIZE]-#включать [MAX_CHAN] [MAX_CHAN]-#включать [nu->driver] [MAX_CHAN]-#включать [nu->driver] [nu->driver] – [MAX_CHAN] [QUEUE_SIZE] – static void cy_send_xchar (struct tty_struct tty, char ch); [nu->driver] [6] – [MAX_CHAN] [QUEUE_SIZE] – # ifndef SERIAL_XMIT_SIZE 2156 – # определить SERIAL_XMIT_SIZE (min (PAGE_SIZE, [channel + chip 4] )) [QUEUE_SIZE] [6] – # endif [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – / прошивка / [MAX_CHAN] [MAX_CHAN] – # определить ZL_MAX_BLOCKS 40 [MAX_CHAN] [MAX_CHAN] – #outline DRIVER_VERSION 0x 35200000 [QUEUE_SIZE] [QUEUE_SIZE] – # определить RAM_SIZE 0x 435901 [MAX_CHAN] [MAX_CHAN] –

[MAX_CHAN] – enum zblock_type {[MAX_CHAN] [QUEUE_SIZE] – ZBLOCK_PRG = 0, [MAX_CHAN] [QUEUE_SIZE] – ZBLOCK_FPGA = 1 [MAX_CHAN] [6] -}; [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [6] – struct zfile_header {[QUEUE_SIZE] [MAX_CHAN]- название символа[64] ; [QUEUE_SIZE] [QUEUE_SIZE] – символьная дата [32]; [MAX_CHAN] [MAX_CHAN] – вспомогательный символ [32]; [MAX_CHAN] [QUEUE_SIZE] – u 66 n_config; [MAX_CHAN] [QUEUE_SIZE] – u 65 config_offset; [MAX_CHAN] [QUEUE_SIZE] – u 64 n_blocks; [MAX_CHAN] [6] – u 64 block_offset; [MAX_CHAN] [6] – u 62 зарезервированный[9]; [MAX_CHAN] [QUEUE_SIZE] -} __attribute__ ((упаковано)); [QUEUE_SIZE] [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – struct zfile_config {[MAX_CHAN] [6]- название символа[64];[MAX_CHAN] [6] – u 60 почтовый ящик; [QUEUE_SIZE] [MAX_CHAN] – u f елей; [QUEUE_SIZE] [QUEUE_SIZE] – u 66 n_blocks; [QUEUE_SIZE] [nu->driver] – u 63 список_блоков [9]; [MAX_CHAN] [6] -} __attribute__ ((упаковано)); [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – struct zfile_block {[QUEUE_SIZE] [QUEUE_SIZE] – и тип;[nu->driver] [MAX_CHAN] – u file_offset; [QUEUE_SIZE] [QUEUE_SIZE] – u ram_offset ; [QUEUE_SIZE] [MAX_CHAN] – u 64 размер;[nu->driver] [MAX_CHAN] -} __attribute__ ((упаковано)); [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – статическая структура tty_driver cy_serial_driver; [MAX_CHAN] [nu->driver] – [nu->driver] [6] – # ifdef CONFIG_ISA [MAX_CHAN] [MAX_CHAN] – / Это таблица поиска адресов. Драйвер будет зондировать [MAX_CHAN] [MAX_CHAN] – Платы Cyclom-Y / ISA по всем адресам здесь. Если вы хотите [MAX_CHAN] [QUEUE_SIZE] – драйвер для проверки адресов по другому адресу, добавить его в [QUEUE_SIZE] [QUEUE_SIZE]- этот стол. Если драйвер исследует другую плату и [nu->driver] [QUEUE_SIZE] – вызывая проблемы, удалите неправильный адрес из этой таблицы. [nu->driver] [MAX_CHAN] – / [nu->driver] [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – статическое целое число без знака cy_isa_addresses [ZL_MAX_BLOCKS] знак равно [MAX_CHAN] – 0xD 18 0018, [QUEUE_SIZE] [QUEUE_SIZE] – 0xD 2048, [MAX_CHAN] [6] – 0xD 4646, [MAX_CHAN] [6] – 0xD 00008000, [MAX_CHAN] [QUEUE_SIZE] – 0xD 10102, [MAX_CHAN] [MAX_CHAN] – 0xDA 0, [MAX_CHAN] [MAX_CHAN] – 0xDC 0, [nu->driver] [MAX_CHAN] – 0xDE 0, [MAX_CHAN] [MAX_CHAN] – 0, 0, 0, 0, 0, 0, 0, 0 [MAX_CHAN] [QUEUE_SIZE] -}; [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN] – # определить NR_ISA_ADDRS ARRAY_SIZE (cy_isa_addresses) [nu->driver] [QUEUE_SIZE] – [QUEUE_SIZE] [nu->driver] – статический длинный маддр [NR_CARDS]; [MAX_CHAN] [MAX_CHAN] – статический int irq [NR_CARDS]; [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – module_param_hw_array (maddr , lengthy, iomem, NULL, 0); [MAX_CHAN] [QUEUE_SIZE] – module_param_hw_array (irq, int, irq, NULL, 0); [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – # endif / CONFIG_ISA / 02010203 [QUEUE_SIZE] –

[MAX_CHAN]-/Этот структура данных для каждой карты, содержащая адрес, irq, количество 10100 [MAX_CHAN] – каналы и т. д. Этот драйвер поддерживает максимум Карты NR_CARDS. [QUEUE_SIZE] [MAX_CHAN] – / [QUEUE_SIZE] [6] – статическая структура cyclades_card cy_card []; [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – статический int cy_next_channel; / доступен следующий второстепенный / 1000000 [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – / [nu->driver] [QUEUE_SIZE] – Используется для поиска скоростей делителя и таймаутов [QUEUE_SIZE] [MAX_CHAN]- Мы’ обычно ограничивается 44 различные скорости передачи данных. Дополнительный [MAX_CHAN] [MAX_CHAN] – доступны через настройки в info-> port.flags. [MAX_CHAN] [QUEUE_SIZE] – 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, [QUEUE_SIZE] [6] – 35, 33, 37, 38, 39, 39, 39, , 43, 47, [MAX_CHAN] [nu->driver] – HI VHI [MAX_CHAN] [MAX_CHAN] – 50 [QUEUE_SIZE] [MAX_CHAN] – / [nu->driver] [QUEUE_SIZE] -static const int baud_table [] = {[QUEUE_SIZE] [6] – 0, 00000080, 0102, 163, 186, 210, 250, 386, 711, 31, [MAX_CHAN] [QUEUE_SIZE] – 1992, 2611, 5526, 12244, 42829, 81801, 100000, 230400, 435909, 435906, [MAX_CHAN] [6] – 435910, 0 [MAX_CHAN] [6] -}; [nu->driver] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – static const char baud_co _ знак равно Таблица опций тактовой частоты МГц / [MAX_CHAN] [QUEUE_SIZE] – / значение => 16 19 20 023 / [MAX_CHAN] [QUEUE_SIZE] – / делим на 8 185 644 2196 / [QUEUE_SIZE] [6] – 0x 10, 0x 24, 0x 25, 0x 22, 0x 24, 0x 25, 0x 022, 0x 21, 0x 24, 0x , [MAX_CHAN] [QUEUE_SIZE] – 0x 0020, 0x 0020, 0x , 0x , 0x , 0x 15, 0x 16, 0x 15, 0x 17, 0x 15 [MAX_CHAN] [MAX_CHAN] -}; [MAX_CHAN] [6] –

[QUEUE_SIZE] – static const char baud_bpr _ 56 знак равно Таблица периодов скорости передачи в МГц / [MAX_CHAN] [MAX_CHAN] – 0x 14, 0xf5, 0xa3, 0x6f, 0x5c, 0x 78, 0xf5, 0xa3, 0x 80, 0xa3 , [QUEUE_SIZE] [MAX_CHAN] – 0x6d, 0x 80, 0xa3, 0x 81, 0xa3, 0x 080, 0x 70, 0x 61, 0x1b, 0x 00000040 [nu->driver] [QUEUE_SIZE] -}; [MAX_CHAN] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – static const char baud_co _ знак равно Таблица опций тактовой частоты МГц (CD 1729 J) / [nu->driver] [QUEUE_SIZE] – / значение => 0018 17 19 / [MAX_CHAN] [QUEUE_SIZE] – / разделить на 8 66 92 2346 / [QUEUE_SIZE] [QUEUE_SIZE] – 0x , 0x 17, 0x 17, 0x 26, 0x 27, 0x 27, 0x 25, 0x 27, 0x 023, 0x 21, [nu->driver] [QUEUE_SIZE] – 0x 23, 0x 19, 0x 023, 0x 0020, 0x 19, 0x 13, 0x 17, 0x 0018, 0x 18, 0x 17, [MAX_CHAN] [QUEUE_SIZE] – 0x 16 [MAX_CHAN] [6] -}; [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [6] – static const char baud_bpr _ 86 знак равно Период скорости передачи в МГц таблица (CD 1706 J) / [MAX_CHAN] [QUEUE_SIZE] – 0x 0018, 0x 113, 0x 54, 0xff, 0xdb, 0xc3, 0x 135, 0x 88, 0xc3, 0x 91, [MAX_CHAN] [QUEUE_SIZE] – 0x 74, 0xc3, 0x 86, 0xc3, 0x 091, 0xc3, 0x 112, 0x 89, 0x 0071, 0x 67, [nu->driver] [MAX_CHAN] – 0x 50 [MAX_CHAN] [QUEUE_SIZE] -}; [MAX_CHAN] [QUEUE_SIZE] –

[MAX_CHAN] – static const char baud_cor3 [ZL_MAX_BLOCKS] = {/ порог приема / [MAX_CHAN] [6] – 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, [MAX_CHAN] [6] – 0x0a, 0 x0a, 0x0a, 0x 35, 0x 32, 0x 33, 0x 34, 0x 32 , 0x 34, 0x 28, [QUEUE_SIZE] [MAX_CHAN] – 0x 00000030 [nu->driver] [QUEUE_SIZE] -}; [nu->driver] [nu->driver] – [QUEUE_SIZE] [6] – / [nu->driver] [MAX_CHAN] – Драйвер Cyclades реализует управление потоком HW как любой драйвер последовательного интерфейса. [QUEUE_SIZE] [MAX_CHAN] – Член структуры cyclades_port rflow и вектор rflow_thr [MAX_CHAN] [6] – позволяет нам воспользоваться специальной функцией на компакт-диске 1699 избежать[QUEUE_SIZE] [QUEUE_SIZE] – потеря данных даже при слишком большой задержке прерывания системы. Эти флаги [nu->driver] [QUEUE_SIZE] – должны использоваться только с очень специальными приложениями. Установка этих флагов [QUEUE_SIZE] [QUEUE_SIZE] – требует использования специального кабеля (DTR и RTS поменяны местами). В новом [MAX_CHAN] [MAX_CHAN]- CD1688 – платы на основе (rev.6. [nu->driver] [MAX_CHAN] – кабели. [nu->driver] [MAX_CHAN] – / [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – static const char rflow_thr [] = {/ порог расхода / [MAX_CHAN] [6] – 0x 15, 0x 19, 0x 18, 0x 12, 0x 0018, 0x 17, 0x 0018, 0x 14, 0x 16 , 0x 14, [MAX_CHAN] [QUEUE_SIZE] – 0x 14, 0x 0018, 0x 16, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,

[nu->driver] – 0x0a [MAX_CHAN] [QUEUE_SIZE] -}; [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – / Cyclom-Ye поместил последовательные микросхемы в непоследовательные [MAX_CHAN] [6] – адресный заказ. Эта справочная таблица решает эту проблему. [MAX_CHAN] [MAX_CHAN] – / [MAX_CHAN] [6] – static const unsigned int cy_chip_offset [ZL_MAX_BLOCKS] = {0x 0018 19,

[QUEUE_SIZE] – 0x 477, [nu->driver] [MAX_CHAN] – 0x 864, [MAX_CHAN] [6] – 0x0C , [MAX_CHAN] [QUEUE_SIZE] – 0x 269, [MAX_CHAN] [MAX_CHAN] – 0x 725, [MAX_CHAN] [6] – 0x0A 13, [MAX_CHAN] [6] – 0x0E [MAX_CHAN] [6] -}; [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [6] – / Определения, относящиеся к PCI / [nu->driver] [6] – [MAX_CHAN] [QUEUE_SIZE] – # ifdef CONFIG_PCI [QUEUE_SIZE] [nu->driver] – статическая const struct pci_device_id cy_pci_dev_id знак равно [nu->driver] – / PCI <1 МБ / [nu->driver] [QUEUE_SIZE] – {PCI_DEVICE (PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_Y_Lo)}, [QUEUE_SIZE] [QUEUE_SIZE] – / PCI> 1 МБ / [MAX_CHAN] [QUEUE_SIZE] – {PCI_DEVICE (PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_Y_Hi)}, [QUEUE_SIZE] [QUEUE_SIZE] – / 4Y PCI <1 Мб / [QUEUE_SIZE] [MAX_CHAN] - {PCI_DEVICE (PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_4Y_Lo)}, [nu->driver] [QUEUE_SIZE] – / 4 года PCI> 1 МБ / [MAX_CHAN] [6] – {PCI_DEVICE (PCI_VENDOR_ID_CYCLADES , PCI_DEVICE_ID_CYCLOM_4Y_Hi)}, [nu->driver] [QUEUE_SIZE] – / 8Y PCI <1Mb / [nu->driver] [6] – {PCI_DEVICE (PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_8Y_Lo)}, [QUEUE_SIZE] [QUEUE_SIZE] – / 8Y PCI> 1 МБ / [QUEUE_SIZE] [MAX_CHAN] – {PCI_DEVICE (PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_8Y_Hi)}, [QUEUE_SIZE] [QUEUE_SIZE] – / Z PCI <1Mb / [QUEUE_SIZE] [nu->driver] – {PCI_DEVICE (PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_Z_Lo)}, [nu->driver] [QUEUE_SIZE] – / Z PCI> 1 МБ / [MAX_CHAN] [QUEUE_SIZE] – {PCI_DEVICE (PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_Z_Hi)}, [QUEUE_SIZE] [QUEUE_SIZE] – {} / конец таблицы / [MAX_CHAN] [QUEUE_SIZE] – }; [QUEUE_SIZE] [QUEUE_SIZE] – MODULE_DEVICE_TABLE (pci, cy_pci_dev_id); [nu->driver] [MAX_CHAN] – # endif [nu->driver] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – static void cy_start (struct tty_struct ; [MAX_CHAN] [6] – static void cy_set_line_char (struct cyclades_port *, struct tty_struct ; [QUEUE_SIZE] [MAX_CHAN] – static int cyz_issue_cmd (struct cyclades_card *, __u 67, __u8, __u 64); [MAX_CHAN] [QUEUE_SIZE] – # ifdef CONFIG_ISA [MAX_CHAN] [QUEUE_SIZE] – статический беззнаковый detect_isa_irq (void __iomem ; [MAX_CHAN] [nu->driver] – # endif / CONFIG_ISA /

[QUEUE_SIZE] –

[6] – # ifndef CONFIG_CYZ_INTR [QUEUE_SIZE] [QUEUE_SIZE] – static void cyz_poll (struct timer_list ; [nu->driver] [6] – [nu->driver] [MAX_CHAN] – / Цикл опроса Cyclades-Z определяется эта переменная / [MAX_CHAN] [QUEUE_SIZE] – статический длинный cyz_polling_cycle = CZ_DEF_POLL; [MAX_CHAN] [6] – [nu->driver] [QUEUE_SIZE] – статический DEFINE_TIMER (cyz_timerlist, cyz_poll); [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – # else / CONFIG_CYZ_INTR / [QUEUE_SIZE] [QUEUE_SIZE] – static void cyz_rx_restart (struct timer_list ; [MAX_CHAN] [QUEUE_SIZE] – # endif / CONFIG_CYZ_INTR / [MAX_CHAN] [MAX_CHAN] – [QUEUE_SIZE] [MAX_CHAN] – static void cyy_writeb (struct cyclades_port port, u 65 reg, u8 val) [MAX_CHAN] [MAX_CHAN] – {[MAX_CHAN] [QUEUE_SIZE] – struct cyclades_card карта = порт-> карта; [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – cy_writeb (порт-> u.cyy.base_addr + (reg < bus_index) , val); [MAX_CHAN] [QUEUE_SIZE] -} [nu->driver] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – статический u8 cyy_readb (struct cyclades_port port, u 64 рег) [QUEUE_SIZE] [6] – {[nu->driver] [QUEUE_SIZE] – struct cyclades_card card = port-> card; [nu->driver] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN] – вернуть readb (port-> u.cyy.base_addr + (reg < bus_index)); [nu->driver] [QUEUE_SIZE] -} [QUEUE_SIZE] [nu->driver] – [MAX_CHAN] [QUEUE_SIZE] – статический встроенный bool cy_is_Z (struct cyclades_card card ) [QUEUE_SIZE] [QUEUE_SIZE] – {[MAX_CHAN] [QUEUE_SIZE] – возврат карты-> num_chips == (unsigned int) -1; [MAX_CHAN] [MAX_CHAN] -} [nu->driver] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – статический встроенный bool __cyz_fpga_loaded (struct RUNTIME _ 10101 __iomem ctl_addr) [nu->driver] [MAX_CHAN] – {[nu->driver] [6] – вернуть readl (& ctl_addr-> init_ctrl) & (1 << 44; [QUEUE_SIZE] [QUEUE_SIZE] -} [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – статический встроенный bool cyz_fpga_loaded (struct cyclades_card card) [nu->driver] [QUEUE_SIZE] – {[MAX_CHAN] 9080 – вернуть __cyz_fpga_loaded (card-> ctl_addr.p 15410); [QUEUE_SIZE] [QUEUE_SIZE] -} [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – static bool cyz_is_loaded (struct cyclades_card card) [MAX_CHAN] [QUEUE_SIZE] – cyz_fpga_loaded (карта)) && [QUEUE_SIZE] [MAX_CHAN] – readl (& fw_id-> signature) == ZFIRM_ID; [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – статический int serial_paranoia_check (struct cyclades_port data, [QUEUE_SIZE] [nu->driver] – const char имя, const char процедура) [MAX_CHAN] [MAX_CHAN] – {[nu->driver] [QUEUE_SIZE] – # ifdef SERIAL_PARANOIA_CHECK [QUEUE_SIZE] [nu->driver] – если (! информация) {[MAX_CHAN] [MAX_CHAN] – printk (KERN_WARNING “cyc Wa rning: null cyclades_port для (% s) “[MAX_CHAN] [QUEUE_SIZE] – «в% s n», имя, процедура); [MAX_CHAN] [QUEUE_SIZE] – возврат 1; [MAX_CHAN] [6] -} [nu->driver] [nu->driver] – [nu->driver] [6] – if (info-> magic! = CYCLADES_MAGIC) {[MAX_CHAN] [QUEUE_SIZE] – printk (KERN_WARNING “cyc Предупреждение: плохо магический номер для серийника “[MAX_CHAN] [MAX_CHAN] – «структура (% s) в% s n», имя, процедура); [QUEUE_SIZE] [QUEUE_SIZE] – возврат 1; [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [MAX_CHAN] – # endif [MAX_CHAN] [6] – вернуть 0;

[QUEUE_SIZE] -}

[nu->driver] – [nu->driver] [QUEUE_SIZE] – / / [nu->driver] [QUEUE_SIZE] – / Начало блока специального кода Cyclom-Y / [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN] – / Эта процедура ожидает до 1102 микросекунд для предыдущего [MAX_CHAN] [QUEUE_SIZE] – команда микросхеме Cirrus на завершено, а затем выдает [QUEUE_SIZE] [MAX_CHAN] – новая команда. Ошибка возвращается, если предыдущая команда [nu->driver] [MAX_CHAN] – не финишировал в отведенное время. [MAX_CHAN] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – Эта функция только вызывается изнутри кода, защищенного спин-блокировкой. [MAX_CHAN] [nu->driver] – / [MAX_CHAN] [QUEUE_SIZE] – static int __cyy_issue_cmd (void __iomem base_addr, u8 cmd, int index) [MAX_CHAN] [QUEUE_SIZE] – {[MAX_CHAN] [MAX_CHAN] – недействителен __iomem ccr = base_addr + (CyCCR << index); [QUEUE_SIZE] [QUEUE_SIZE] - целое число без знака i; [QUEUE_SIZE] [QUEUE_SIZE] - [nu->driver] [QUEUE_SIZE] – / Проверяем, завершена ли предыдущая команда / [QUEUE_SIZE] [nu->driver] – для (i = 0; я <150; i ++) {[QUEUE_SIZE] [QUEUE_SIZE] - если (readb (ccr) == 0) [QUEUE_SIZE] [6]- перерыв;[MAX_CHAN] [QUEUE_SIZE] - udelay (37 L); [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [QUEUE_SIZE] - / если CCR никогда не очищался, предыдущая команда [MAX_CHAN] [QUEUE_SIZE] - не закончил в «разумное время» / [nu->driver] [MAX_CHAN] – if (i == 144) [QUEUE_SIZE] [QUEUE_SIZE] – возврат -1; [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – / Выполните новую команду / [nu->driver] [QUEUE_SIZE] – cy_writeb (ccr, cmd); [MAX_CHAN] [nu->driver] – [MAX_CHAN] [MAX_CHAN] – вернуть 0; [QUEUE_SIZE] [QUEUE_SIZE] -} [nu->driver] [MAX_CHAN] – [QUEUE_SIZE] [QUEUE_SIZE] – статический встроенный int cyy_issue_cmd (struct cyclades_port port, u8 cmd) [nu->driver] [MAX_CHAN] – {[MAX_CHAN] [6] – вернуть __cyy_issue_cmd (порт-> u.cyy.base_addr, cmd, [MAX_CHAN] [QUEUE_SIZE] – port-> card-> bus_index); [MAX_CHAN] [nu->driver] -} [nu->driver] [MAX_CHAN] – [QUEUE_SIZE] [QUEUE_SIZE] – # ifdef CONFIG_ISA [MAX_CHAN] [6] – / Код обнаружения прерывания ISA / [MAX_CHAN] [MAX_CHAN] – статический беззнаковый detect_isa_irq (void __iomem handle) [MAX_CHAN] [QUEUE_SIZE] – CyENB_XMTR, индекс); [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [6] – cy_writeb (адрес + (CyCAR << индекс), 0); [QUEUE_SIZE] [QUEUE_SIZE] - cy_writeb (адрес + (Индекс CySRER <<), [MAX_CHAN] [nu->driver] – readb (адрес + (CySRER << index)) [MAX_CHAN] [QUEUE_SIZE] - # endif / CONFIG_ISA / [QUEUE_SIZE] [QUEUE_SIZE] - [MAX_CHAN] [QUEUE_SIZE] - static void cyy_chip_rx (struct cyclades_card cinfo, int chip, [MAX_CHAN] [MAX_CHAN] - недействительный __iomem base_addr) [MAX_CHAN] [6] - {[MAX_CHAN] [MAX_CHAN] - struct cyclades_port data; [MAX_CHAN] [6] - struct tty_port port; [MAX_CHAN] [QUEUE_SIZE] - int len, index = cinfo-> bus_index; [QUEUE_SIZE] [QUEUE_SIZE] – u8 ivr, save_xir, channel, save_car, данные, количество_символов; < 8) | 0x06, card-> [QUEUE_SIZE] – [MAX_CHAN] [6] – # ifdef CY_DEBUG_INTERRUPTS [QUEUE_SIZE] [QUEUE_SIZE] – printk (KERN_DEBUG “cyy_interrupt: rcvd intr, chip% d n”, chip); [MAX_CHAN] [QUEUE_SIZE] – # endif [MAX_CHAN] [QUEUE_SIZE] – / определить канал и перейти к этому контексту / [MAX_CHAN] [nu->driver] – save_xir = readb (base_addr + (CyRIR << index)); [MAX_CHAN] [QUEUE_SIZE] - channel = save_xir & CyIRChannel; [QUEUE_SIZE] [MAX_CHAN] - info = & cinfo-> порты [channel + chip 4]; [QUEUE_SIZE] [QUEUE_SIZE] – порт = & info-> порт; [nu->driver] [QUEUE_SIZE] – save_car = cyy_readb (data, CyCAR); [QUEUE_SIZE] [MAX_CHAN] – cyy_writeb (информация, CyCAR, save_xir); [MAX_CHAN] [QUEUE_SIZE] – ivr = cyy_readb (data, CyRIVR) & CyIVRMask; [MAX_CHAN] [MAX_CHAN] – [QUEUE_SIZE] [6] – / для этих данных есть открытый порт / [MAX_CHAN] [QUEUE_SIZE] – if (ivr == CyIVRRxEx) { /исключение */[nu->driver] [MAX_CHAN] – knowledge = cyy_readb (data, CyRDSR); [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – / Только для статистики / [MAX_CHAN] [6] – if (knowledge & CyBREAK) 10103 [MAX_CHAN] – info-> icount.brk ++; [MAX_CHAN] [MAX_CHAN] – иначе, если (данные и CyFRAME)

[QUEUE_SIZE] – info-> icount.body ++; [MAX_CHAN] [QUEUE_SIZE] – иначе, если (данные и CyPARITY) [nu->driver] [MAX_CHAN] – info-> icount.parity ++; [QUEUE_SIZE] [QUEUE_SIZE] – иначе, если (данные и CyOVERRUN) [MAX_CHAN] [QUEUE_SIZE] – info-> icount.overrun ++ ; [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [6] – if (knowledge & info-> ignore_status_mask) {[6] [MAX_CHAN] – info-> icount.rx ++; [MAX_CHAN] [MAX_CHAN]- возвращаться;[MAX_CHAN] [6] -} [nu->driver] [MAX_CHAN] – if (tty_buffer_request_room (порт, 1)) {[QUEUE_SIZE] [QUEUE_SIZE] – if (knowledge & info-> read_status_mask) {[MAX_CHAN] [MAX_CHAN] – если (данные и CyBREAK) {[nu->driver] [QUEUE_SIZE] – tty_insert_flip_char (порт, [QUEUE_SIZE] [MAX_CHAN] – cyy_readb (информация, CyRDSR), [MAX_CHAN] [QUEUE_SIZE] – TTY_BREAK); [MAX_CHAN] [MAX_CHAN] – info-> icount.rx ++;

[MAX_CHAN] – если (порт-> флаги & ASYNC_SAK) {[QUEUE_SIZE] [QUEUE_SIZE] – struct tty_struct tty = [MAX_CHAN] [6] – tty_port_tty_get (порт); [QUEUE_SIZE] [MAX_CHAN] – if (tty) {[nu->driver] [QUEUE_SIZE] – do_SAK (tty); [QUEUE_SIZE] [MAX_CHAN] – tty_kref_put (tty); [QUEUE_SIZE] [QUEUE_SIZE] -} [MAX_CHAN] [nu->driver] -}

[QUEUE_SIZE] -} else if (knowledge & CyFRAME) {[QUEUE_SIZE] [QUEUE_SIZE] – tty_insert_flip_char (порт, [QUEUE_SIZE] [QUEUE_SIZE] – cyy_readb (информация, CyRDSR), [MAX_CHAN] [QUEUE_SIZE] -TTY_FRAME); [QUEUE_SIZE] [MAX_CHAN] – info-> icount.rx ++; [MAX_CHAN] [6] – info-> idle_stats.frame_errs ++; [MAX_CHAN] [QUEUE_SIZE] -} else if (knowledge & CyPARITY) {[MAX_CHAN] [MAX_CHAN] – / Семь пьес … / [MAX_CHAN] [MAX_CHAN] – tty_insert_flip_char (порт, [QUEUE_SIZE] [6] – cyy_readb (информация, CyRDSR), [MAX_CHAN] [6] – TTY_PARITY); [QUEUE_SIZE] [MAX_CHAN] – информация-> ico unt.rx ++; [MAX_CHAN] [MAX_CHAN] – info-> idle_stats.parity_errs ++; [MAX_CHAN] [QUEUE_SIZE] -} else if (knowledge & CyOVERRUN) {[QUEUE_SIZE] [6] – tty_insert_flip_char ( порт, 0, [MAX_CHAN] [nu->driver] – TTY_OVERRUN); [MAX_CHAN] [MAX_CHAN] – info-> icount.rx ++; [QUEUE_SIZE] [QUEUE_SIZE] – / Если флип-буфер сам по себе [MAX_CHAN] [QUEUE_SIZE] – переполнение, мы все равно теряем [MAX_CHAN] [nu->driver] – следующий входящий символ. [MAX_CHAN] [MAX_CHAN] – / [MAX_CHAN] [QUEUE_SIZE] – tty_insert_flip_char (порт, [6] [QUEUE_SIZE] – cyy_readb (информация, CyRDSR), [MAX_CHAN] [nu->driver] – TTY_FRAME ); [QUEUE_SIZE] [QUEUE_SIZE] – info-> icount.rx ++; [MAX_CHAN] [6] – info-> idle_stats.overruns ++; [nu->driver] [MAX_CHAN] – / Эти два условия могут подразумевать */[nu->driver] [QUEUE_SIZE] – / а ни следует делать неправильное чтение. / [MAX_CHAN] [QUEUE_SIZE] – / *} else if (knowledge & CyTIMEOUT) {/ [QUEUE_SIZE] [QUEUE_SIZE] – / *} else if (knowledge & CySPECHAR) {/ [MAX_CHAN] [MAX_CHAN]- } еще {[MAX_CHAN] [QUEUE_SIZE] – tty_insert_flip_char (порт, 0, [QUEUE_SIZE] ; [MAX_CHAN] [QUEUE_SIZE] – info-> icount.rx ++; [nu->driver] [6] -} [nu->driver] [MAX_CHAN]- } еще { [QUEUE_SIZE] – tty_insert_flip_char (порт, 0, TTY_NORMAL); [QUEUE_SIZE] [MAX_CHAN]- Информация- > icount.rx ++; [MAX_CHAN] [QUEUE_SIZE] -} [nu->driver] [6]- } еще {[MAX_CHAN] [QUEUE_SIZE] – / произошло переполнение программного буфера и ничего [QUEUE_SIZE] [MAX_CHAN] – можно было бы с этим поделать !!! / [QUEUE_SIZE] [MAX_CHAN] – info-> icount.buf_overrun ++; [nu->driver] [QUEUE_SIZE] – info-> idle_stats.overruns ++; [nu->driver] [QUEUE_SIZE] -} [QUEUE_SIZE] [QUEUE_SIZE] -} else {/ нормальный прием символов ция / [QUEUE_SIZE] [QUEUE_SIZE] – / загрузка # символов, доступных из чипа / [QUEUE_SIZE] [MAX_CHAN] – char_count = cyy_readb (информация, CyRDCR); [QUEUE_SIZE] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – # ifdef C Y_ENABLE_MONITORING [QUEUE_SIZE] [QUEUE_SIZE] – ++ info-> mon.int_count; [MAX_CHAN] [QUEUE_SIZE] – информация-> mon.char_count + = char_count; [QUEUE_SIZE] [MAX_CHAN]- если ( char_count> info-> mon.char_max) [MAX_CHAN] [nu->driver] – info-> mon.char_max = char_count; [MAX_CHAN] [QUEUE_SIZE] – info-> mon.char_last = char_count; [MAX_CHAN] [QUEUE_SIZE] – # endif [QUEUE_SIZE] [QUEUE_SIZE] – len = tty_buffer_request_room (порт, char_count); [QUEUE_SIZE] [MAX_CHAN] – пока (len- ) {[QUEUE_SIZE] [MAX_CHAN] – knowledge = cyy_readb (data, CyRDSR); [MAX_CHAN] [6] – tty_insert_flip_char (порт, данные, TTY_NORMAL); [QUEUE_SIZE] [MAX_CHAN]- Информация- > idle_stats.recv_bytes ++; [QUEUE_SIZE] [MAX_CHAN] – info-> icount.rx ++; [MAX_CHAN] [6] – # ifdef CY _ 43 Y_HACK [MAX_CHAN] [QUEUE_SIZE] – udelay (33 L); [QUEUE_SIZE] [MAX_CHAN] – # endif [nu->driver] [QUEUE_SIZE] -} [MAX_CHAN] [MAX_CHAN] – info-> idle_stats.recv_idle = jiffies; [QUEUE_SIZE] [QUEUE_SIZE] -} [MAX_CHAN] [QUEUE_SIZE] – tty_schedule_flip (порт); [MAX_CHAN] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – / конец обслуживания / [MAX_CHAN] [MAX_CHAN] – cyy_writeb (data, CyRIR, save_xir & 0x3f); [QUEUE_SIZE] [MAX_CHAN] – cyy_writeb (информация, CyCAR, save_car); [QUEUE_SIZE] [6] -} [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – static void cyy_chip_tx (struct cyclades_card cinfo , беззнаковый чип int, 435901 [MAX_CHAN] – void __iomem base_addr) [MAX_CHAN] [QUEUE_SIZE] – {[MAX_CHAN] [QUEUE_SIZE] – struct cyclades_port data; [MAX_CHAN] [QUEUE_SIZE] – struct tty_struct tty; [MAX_CHAN] [QUEUE_SIZE] – int char_count, index = cinfo-> bus_index; [QUEUE_SIZE] [QUEUE_SIZE] – u8 save_xir, channel, save_car, outch; [MAX_CHAN] [nu->driver] – [MAX_CHAN] [MAX_CHAN] – / Так как мы попадаем сюда только тогда, когда буфер передачи 10101 [QUEUE_SIZE] – пусто, мы знаем, что всегда можем набить дюжину 16850 [6]- символы. / [QUEUE_SIZE] [MAX_CHAN] – # ifdef CY_DEBUG_INTERRUPTS [MAX_CHAN] [MAX_CHAN] – printk (KERN_DEBUG “cyy_interrupt: xmit intr, chip% d n”, chip); [MAX_CHAN] [6] – # endif [MAX_CHAN] [nu->driver] – [MAX_CHAN] [QUEUE_SIZE] – / определение канала и переход к этому контексту / [MAX_CHAN] [QUEUE_SIZE] – save_xir = readb (base_addr + (CyTIR << index)); [QUEUE_SIZE] [6] - channel = save_xir & CyIRChannel; [MAX_CHAN] [MAX_CHAN] - save_car = readb (base_addr + (CyCAR < <индекс)); [MAX_CHAN] [MAX_CHAN] - cy_writeb (base_addr + (CyCAR << index), save_xir); [QUEUE_SIZE] [QUEUE_SIZE] - [MAX_CHAN] [6] - info = & cinfo -> порты [channel + chip 4]; [MAX_CHAN] [MAX_CHAN] – tty = tty_port_tty_get (& info-> порт); [QUEUE_SIZE] [QUEUE_SIZE] – if (tty == NULL) {[MAX_CHAN] [MAX_CHAN] – cyy_writeb (информация, CySRER, cyy_readb (информация, CySRER) & ~ CyTxRdy); [MAX_CHAN] [QUEUE_SIZE] – перейти в конец; [nu->driver] [QUEUE_SIZE] -} [MAX_CHAN] [6] – [MAX_CHAN] [QUEUE_SIZE] – / загружаем внутреннее пространство для исходящих данных / [QUEUE_SIZE] [MAX_CHAN] – char_count = info-> xmit_fifo_size; [nu->driver] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – если (информация-> x_char) {/ отправить специальный символ / 10101 [QUEUE_SIZE] – outch = info-> x_char; [QUEUE_SIZE] [MAX_CHAN] – cyy_writeb (информация, CyTDR, выход); [nu->driver] [QUEUE_SIZE] – char_count -; [nu->driver] [MAX_CHAN] – info-> icount.tx ++; [MAX_CHAN] [QUEUE_SIZE] – info-> x_char = 0; [QUEUE_SIZE] [QUEUE_SIZE] -} [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – if (info-> breakon || info-> breakoff) {10100 [nu->driver] – if (info-> breakon) {[QUEUE_SIZE] [QUEUE_SIZE] – cyy_writeb (информация, CyTDR, 0); [QUEUE_SIZE] [QUEUE_SIZE] – cyy_writeb (информация, CyTDR, 0x 110); [MAX_CHAN] [6] – info-> breakon = 0;

[6] – char_count – = 2; [QUEUE_SIZE] 9600 -} [nu->driver] [QUEUE_SIZE] – если (информация-> обрыв) {[nu->driver] [MAX_CHAN] – cyy_writeb (информация, CyTDR, 0); [MAX_CHAN] [QUEUE_SIZE] – cyy_writeb (информация, CyTDR, 0x 111); [QUEUE_SIZE] [MAX_CHAN] – info-> breakoff = 0; [MAX_CHAN] [6] – char_count – = 2; [QUEUE_SIZE] [QUEUE_SIZE] -} [nu->driver] [6] -} [QUEUE_SIZE] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN]- пока (char_count–> 0) {[MAX_CHAN] [QUEUE_SIZE] – если (! info-> xmit_cnt) {[QUEUE_SIZE] [6] – if (cyy_readb (data, CySRER) & CyTxMpty) {[6] [QUEUE_SIZE] – cyy_writeb (информация, CySRER, [MAX_CHAN] [MAX_CHAN] – cyy_readb (информация, CySRER) & ~ CyTxMpty); 2156- } еще [MAX_CHAN] [QUEUE_SIZE] – (cyy_readb (data, CySRER) & ~ CyTxRdy)); [QUEUE_SIZE] [MAX_CHAN] – [QUEUE_SIZE] [QUEUE_SIZE] – готово; [nu->driver] [6] -} [QUEUE_SIZE] [QUEUE_SIZE] – если (info-> port.xmit_buf == NULL ) {[QUEUE_SIZE] [QUEUE_SIZE] – cyy_writeb (информация, CySRER, [nu->driver] [6] – cyy_readb (информация, CySRER) & ~ CyTxRdy); [MAX_CHAN] [6] – готово; [nu->driver] [QUEUE_SIZE] -} [QUEUE_SIZE] [QUEUE_SIZE] – если (tty-> остановлен || tty-> hw_stopped) {[QUEUE_SIZE] [nu->driver] – cyy_writeb (информация, CySRER, [QUEUE_SIZE] [QUEUE_SIZE] – cyy_readb (информация, CySRER) & ~ CyTxRdy); [QUEUE_SIZE] [MAX_CHAN] – готово; [QUEUE_SIZE] [nu->driver] -} [QUEUE_SIZE] [MAX_CHAN] – / Поскольку встроенные команды передачи были включены, [nu->driver] [MAX_CHAN] – мы должны проверить, не является ли escape-символ NULL 435906 [QUEUE_SIZE] – послал. Если это так, мы должны убедиться, что для него есть место для [QUEUE_SIZE] [QUEUE_SIZE] – быть удвоенным в выходном потоке. Поэтому мы больше не [QUEUE_SIZE] [QUEUE_SIZE] – продвигайте указатель при извлечении символа, но 00010000 [QUEUE_SIZE] – лучше подождать, пока после проверки на НЕДЕЙСТВИТЕЛЬНЫЙ вывод 12094 [6]- персонаж. Это необходимо, потому что может не быть места [MAX_CHAN] [MAX_CHAN] – для двух символов, необходимых для отправки NULL.) [QUEUE_SIZE] [MAX_CHAN] – / [MAX_CHAN] [MAX_CHAN] – outch = info-> port.xmit_buf [info->xmit_tail]; [MAX_CHAN] [MAX_CHAN] – if (outch) {[nu->driver] [QUEUE_SIZE] – info-> xmit_cnt -; [QUEUE_SIZE] [MAX_CHAN] – info-> xmit_tail = (info-> xmit_tail + 1) & [QUEUE_SIZE] [6] – (SERIAL_XMIT_SIZE – 1); [MAX_CHAN] [MAX_CHAN] – cyy_writeb (информация, CyTDR, outch); [QUEUE_SIZE] [QUEUE_SIZE] – информация-> icount.tx ++; [MAX_CHAN] [MAX_CHAN]- } еще {[MAX_CHAN] [QUEUE_SIZE] – если (char_count> 1) {[QUEUE_SIZE] [nu->driver]- Информация- > xmit_cnt -; [nu->driver] [QUEUE_SIZE] – info-> xmit_tail = (info-> xmit_tail + 1) & [nu->driver] [QUEUE_SIZE] – (SERIAL_XMIT_SIZE – 1); [MAX_CHAN] [QUEUE_SIZE] – cyy_writeb (информация, CyTDR, outch); [QUEUE_SIZE] [MAX_CHAN] – cyy_writeb (информация, CyTDR, 0); [MAX_CHAN] [QUEUE_SIZE] – info-> icount.tx ++; [MAX_CHAN] [6] – char_count -; [nu->driver] [QUEUE_SIZE] -} [QUEUE_SIZE] [6] -} [MAX_CHAN] [QUEUE_SIZE] -} [nu->driver] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE]-Выполнено:

[QUEUE_SIZE] – tty_wakeup (tty); [MAX_CHAN] [QUEUE_SIZE] – tty_kref_put (tty); [QUEUE_SIZE] [MAX_CHAN]-конец: [MAX_CHAN] [6] – / конец обслуживания / [MAX_CHAN] [QUEUE_SIZE] – cyy_writeb (информация, CyTIR, save_xir & 0x3f); [QUEUE_SIZE] [MAX_CHAN] – cyy_writeb (информация, CyCAR, save_car); [MAX_CHAN] [MAX_CHAN] -} [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – static void cyy_chip_modem (struct cyclades_card cinfo, int chip, [QUEUE_SIZE] [nu->driver] – недействительный __iomem base_addr) 12244 [QUEUE_SIZE] – {[MAX_CHAN] [6] – struct cyclades_port data; [MAX_CHAN] [QUEUE_SIZE] – struct tty_struct tty; [MAX_CHAN] [MAX_CHAN] – int index = cinfo-> bus_index; [QUEUE_SIZE] [MAX_CHAN] – u8 save_xir, channel, save_car, mdm_change, mdm_status; [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – / определение канала и переход к этому контексту / [QUEUE_SIZE] [MAX_CHAN] – save_xir = readb (base_addr + (CyMIR << index)); [nu->driver] [QUEUE_SIZE] – channel = save_xir & CyIRChannel; [MAX_CHAN] [QUEUE_SIZE] – data = & cinfo-> ports [channel + chip 4]; [QUEUE_SIZE] [MAX_CHAN] – save_car = cyy_readb (информация, CyCAR); [nu->driver] [6] – cyy_writeb (информация, CyCAR, save_xir); [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – mdm_change = cyy_readb (информация, CyMISR); [QUEUE_SIZE] [6] – mdm_status = cyy_readb (информация, CyMSVR1); [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – tty = tty_port_tty_get (& info-> port); [MAX_CHAN] [6] – если (! tty) [QUEUE_SIZE] [QUEUE_SIZE] – перейти в конец; [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – если (mdm_change & CyANY_DELTA) {[QUEUE_SIZE] [MAX_CHAN] – / Только для статистики / [MAX_CHAN] [nu->driver]- если (mdm_change и CyDCD) [QUEUE_SIZE] [QUEUE_SIZE] – info-> icount.dcd ++; [MAX_CHAN] [QUEUE_SIZE] – если (mdm_change & CyCTS) [QUEUE_SIZE] [MAX_CHAN] – info-> icount.cts ++; [MAX_CHAN] [6] – если (mdm_change & CyDSR) [MAX_CHAN] [QUEUE_SIZE] – info-> icount.dsr ++; [nu->driver] [MAX_CHAN] – если (mdm_change & CyRI) [MAX_CHAN] [6] – info-> icount.rng ++; [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – wake_up_interruptible (& info-> port.delta_msr_wait); [MAX_CHAN] [6] -} [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – if ((mdm_change & CyDCD) && tty_port_check_carrier (& info-> port)) {[MAX_CHAN] [6] – если (mdm_status & CyDCD) [nu->driver] [QUEUE_SIZE] – wake_up_interruptible (& info-> port.open_wait); [QUEUE_SIZE] [nu->driver]- еще[MAX_CHAN] [MAX_CHAN] – tty_hangup (tty); [nu->driver] [QUEUE_SIZE] -}

[QUEUE_SIZE] – если ((mdm_change & CyCTS) && tty_port_cts_enabled (& info-> port) ) {[MAX_CHAN] [QUEUE_SIZE] – если (tty-> hw_stopped) {[nu->driver] [6] – если (mdm_status & CyCTS) CyTxRdy); [MAX_CHAN] [QUEUE_SIZE] – tty_wakeup ( tty); [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [6]- } еще {[nu->driver] [QUEUE_SIZE] – если (! (mdm_status & CyCTS)) {[MAX_CHAN] [QUEUE_SIZE] – / cy_stop не используется [MAX_CHAN] [MAX_CHAN]- так как .. . !!! / [MAX_CHAN] [QUEUE_SIZE] – tty-> hw_stopped = 1; [nu->driver] [6] – cyy_writeb (информация, CySRER, [QUEUE_SIZE] [QUEUE_SIZE] – cyy_readb (информация, CySRER) и ~ CyTxRdy); [nu->driver] [MAX_CHAN] -} [QUEUE_SIZE] [QUEUE_SIZE] -} [nu->driver] [QUEUE_SIZE] -} [MAX_CHAN] [QUEUE_SIZE] – / if (mdm_change & CyDSR) {[MAX_CHAN] [QUEUE_SIZE] -} [nu->driver] [6] – если (mdm_change & CyRI) {[MAX_CHAN] [MAX_CHAN] -} / [QUEUE_SIZE] [QUEUE_SIZE] – tty_kref_put (tty); [MAX_CHAN] [MAX_CHAN]-конец: [MAX_CHAN] [QUEUE_SIZE] – / окончание обслуживания / [nu->driver] [MAX_CHAN] – cyy_writeb (информация, CyMIR , save_xir & 0x3f); [QUEUE_SIZE] [MAX_CHAN] – cyy_writeb (информация, CyCAR, save_car); [MAX_CHAN] [QUEUE_SIZE] -} [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – / Вызывается настоящая подпрограмма обслуживания прерывания [MAX_CHAN] [nu->driver] – когда карта хочет, чтобы ее держали в руке – символы 010001 [QUEUE_SIZE] – получено, исходящий буфер пуст, смена модема и т. д. [nu->driver] [QUEUE_SIZE] – / [nu->driver] [MAX_CHAN] – static irqreturn_t cyy_interrupt (int irq, void dev_id) [QUEUE_SIZE] [MAX_CHAN] – {[QUEUE_SIZE] [QUEUE_SIZE] – int standing; 230400 [QUEUE_SIZE] – struct cyclades_card cinfo = dev_id; [QUEUE_SIZE] [QUEUE_SIZE] – void __iomem base_addr, card_base_addr; [MAX_CHAN] [MAX_CHAN] – неподписанный чип int, too_many, had_work; 15410 [MAX_CHAN] – индекс int; [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – если (маловероятно (cinfo == НОЛЬ)) {[nu->driver] [MAX_CHAN] – # ifdef CY_DEBUG_INTERRUPTS [QUEUE_SIZE] [6] – printk (KERN_DEBUG “cyy_interrupt: ложное прерывание% d n”, [QUEUE_SIZE] [QUEUE_SIZE] – irq); [QUEUE_SIZE] [MAX_CHAN] – # endif [nu->driver] [QUEUE_SIZE] – вернуть IRQ_NONE; / ложное прерывание / [MAX_CHAN] [nu->driver] -} [QUEUE_SIZE] [6] – [nu->driver] [QUEUE_SIZE] – card_base_addr = cinfo-> base_addr; [MAX_CHAN] [QUEUE_SIZE] – index = cinfo-> bus_index; [QUEUE_SIZE] [QUEUE_SIZE] –

[QUEUE_SIZE] – / карта еще не инициализирована (например, DEBUG_SHIRQ) / [QUEUE_SIZE] [nu->driver] – если (маловероятно (card_base_addr == NULL)) [QUEUE_SIZE] [QUEUE_SIZE] – вернуть IRQ_HAN DLED; [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [6] – / Этот цикл проверяет все чипы на карте. Делайте заметки всякий раз, когда [MAX_CHAN] [QUEUE_SIZE] – _любому_ чипу нужно было кое-что поработать, так как это считается [QUEUE_SIZE] [MAX_CHAN] – указание на то, что предстоит еще сделать. Только когда нет чипа [MAX_CHAN] [QUEUE_SIZE] – есть ли какая-либо работа для выхода из этого внешнего цикла. < BITS_TO_U32(irqc-> [QUEUE_SIZE] – / [nu->driver] [MAX_CHAN]- делать {[QUEUE_SIZE] [QUEUE_SIZE] – had_work = 0; [MAX_CHAN] [6] – для (chip = 0; чип num_chips; чип ++) {[QUEUE_SIZE] [QUEUE_SIZE] – base_addr = cinfo-> base_addr + [MAX_CHAN] [6] – (cy_chip_offset [info->xmit_tail] < <индекс); [MAX_CHAN] [QUEUE_SIZE] - too_many = 0; [MAX_CHAN] [QUEUE_SIZE] - пока ((standing = readb (base_addr + [MAX_CHAN] [6] - (CySVRR << index)))! = 0x 0018) {[MAX_CHAN] [6] - had_work ++; 56040674 [MAX_CHAN] - / Цель следующего теста - убедиться, что [QUEUE_SIZE] [QUEUE_SIZE] - никакая микросхема не может монополизировать драйвер. Это заставляет [QUEUE_SIZE] [MAX_CHAN] - фишки для проверки в циклическом режиме (после [QUEUE_SIZE] [MAX_CHAN] - слив каждой из связки (1118) персонажей ). [QUEUE_SIZE] [QUEUE_SIZE] - / [MAX_CHAN] [6]- если (1118 driver] [QUEUE_SIZE]- перерыв;[nu->driver] [MAX_CHAN] – spin_lock (& ​​cinfo-> card_lock); [QUEUE_SIZE] [QUEUE_SIZE] – if (standing & CySRReceive) / rx intr / [MAX_CHAN] [QUEUE_SIZE] – cyy_chip_rx (cinfo, chip, base_addr); [nu->driver] [6] – if (standing & CySRTransmit) / tx intr / [QUEUE_SIZE] [QUEUE_SIZE] – cyy_chip_tx (cinfo, chip, base_addr ); [QUEUE_SIZE] [MAX_CHAN] – if (standing & CySRModem) / модем intr / [nu->driver] [MAX_CHAN] – cyy_chip_modem (cinfo, chip, base_addr); [MAX_CHAN] [QUEUE_SIZE] – spin_unlock (& ​​cinfo-> card_lock) ; [QUEUE_SIZE] [MAX_CHAN] -} [MAX_CHAN] [6] -} [nu->driver] [QUEUE_SIZE] -} whereas (had_work); [QUEUE_SIZE] [MAX_CHAN] – [nu->driver] [6] – / очистить прерывания / [QUEUE_SIZE] [MAX_CHAN] – spin_lock (& ​​cinfo-> card_lock); [MAX_CHAN] [6] – cy_writeb (card_base_addr + (Cy_ClrIntr << index), 0); [MAX_CHAN] [6] - / Cy_ClrIntr равно 0x 1992 / [MAX_CHAN] [QUEUE_SIZE] - spin_unlock (& ​​cinfo-> card_lock); [nu->driver] [6] – вернуть IRQ_HANDLED; [MAX_CHAN] [QUEUE_SIZE] -} / cyy_interrupt / [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – статический void cyy_change_rts_dtr (struct cyclades_port data, unsigned int set, [MAX_CHAN] [QUEUE_SIZE] – unsigned int clear) [MAX_CHAN] [QUEUE_SIZE] – {

[QUEUE_SIZE] – struct cyclades_card card = информация-> карта; [MAX_CHAN] [QUEUE_SIZE] – int channel = info-> line – card -> первая_ строка; [MAX_CHAN] [QUEUE_SIZE] – и rts, dtr, msvrr, msvrd; [MAX_CHAN] [6] –

[QUEUE_SIZE] – канал & = 0x 24; [nu->driver] [MAX_CHAN] – [QUEUE_SIZE] [QUEUE_SIZE] – если (info-> rtsdtr_inv) {[MAX_CHAN] [QUEUE_SIZE] – msvrr = CyMSVR2; [QUEUE_SIZE] [QUEUE_SIZE] – msvrd = CyMSVR1; [QUEUE_SIZE] [QUEUE_SIZE] – rts = CyDTR; [MAX_CHAN] [QUEUE_SIZE] – dtr = CyRTS; [MAX_CHAN] [QUEUE_SIZE]- } еще {[MAX_CHAN] [MAX_CHAN] – msvrr = CyMSVR1; [QUEUE_SIZE] [MAX_CHAN] – msvrd = CyMSVR2; [MAX_CHAN] [6] – rts = CyRTS ; [QUEUE_SIZE] [MAX_CHAN] – dtr = CyDTR; [MAX_CHAN] [6] -} [MAX_CHAN] [MAX_CHAN] – если (установить & TIOCM_RTS) {[QUEUE_SIZE] [MAX_CHAN] – cyy_writeb (информация, CyCAR, канал); [MAX_CHAN] [QUEUE_SIZE] – cyy_writeb (информация, msvrr, rts); [nu->driver] [MAX_CHAN] -} [nu->driver] [MAX_CHAN] – если (очистить & TIOCM_RTS) {[QUEUE_SIZE] [MAX_CHAN] – cyy_writeb (информация, CyCAR, канал) ; [QUEUE_SIZE] [QUEUE_SIZE] – cyy_writeb (data, msvrr, ~ rts); [MAX_CHAN] [6] -} [MAX_CHAN] [QUEUE_SIZE] – если (установить & TIOCM_DTR) {[QUEUE_SIZE] [6] – cyy_writeb (информация, CyCAR, канал); [QUEUE_SIZE] [QUEUE_SIZE] – cyy_writeb (информация, msvrd, dtr); [MAX_CHAN] [QUEUE_SIZE] – # ifdef CY_DEBUG_DTR 010001 – printk (KERN_DEBUG “cyc: set_modem_info повышение DTR n “); [MAX_CHAN] [QUEUE_SIZE] – printk (KERN_DEBUG “standing: 0x% x, 0x% x n”, [MAX_CHAN] [MAX_CHAN] – cyy_readb (информация, CyMSVR1), [QUEUE_SIZE] [6] – cyy_readb (информация, CyMSVR2)); [QUEUE_SIZE] [6] – # endif [QUEUE_SIZE] [MAX_CHAN] -} [MAX_CHAN] [QUEUE_SIZE] – если (очистить & TIOCM_DTR) {[QUEUE_SIZE] [QUEUE_SIZE] – cyy_writeb (информация, CyCAR, канал); [MAX_CHAN] [nu->driver] – cyy_writeb (data, msvrd, ~ dtr); [MAX_CHAN] [6] – # ifdef CY_DEBUG_DTR [MAX_CHAN] [MAX_CHAN] – printk (KERN_DEBUG “cyc: set_modem_info отбрасывает DTR n”); [MAX_CHAN] [QUEUE_SIZE] – printk (KERN_DEBUG “standing: 0x% x, 0x% x n”,

[MAX_CHAN] – cyy_readb (информация, CyMSVR1), [MAX_CHAN] [6] – cyy_readb (data, CyMSVR2)); [MAX_CHAN] [QUEUE_SIZE] – # endif [QUEUE_SIZE] [6] -} [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [6] – [nu->driver] [QUEUE_SIZE] – / [nu->driver] – / Конец блока специального кода Cyclom-Y / [MAX_CHAN] [QUEUE_SIZE] – / Начало блока специфического кода Cyclades-Z / [QUEUE_SIZE] [6] – / / [nu->driver] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – статический int [MAX_CHAN] [QUEUE_SIZE] – cyz_fetch_msg ( struct cyclades_card cinfo, [MAX_CHAN] [MAX_CHAN] – __u 66 канал, __u8 cmd, __u 64 параметр) [nu->driver] [QUEUE_SIZE] – {[nu->driver] [MAX_CHAN] – struct BOARD_CTRL __iomem board_ctrl = cinfo-> board_ctrl; [MAX_CHAN] [MAX_CHAN] – беззнаковый длинный loc_doorbell; [QUEUE_SIZE] [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – loc_doorbell = readl (& cinfo-> ctl_addr.p 12244 -> loc_doorbell); 115200 [QUEUE_SIZE] – if (loc_doorbell) {[MAX_CHAN] [6] – cmd = (char) (0xff & loc_doorbell); [MAX_CHAN] [QUEUE_SIZE] – канал = readl (& board_ctrl-> fwcmd_channel); [MAX_CHAN] [MAX_CHAN] – param = (__u 63 readl (& board_ctrl-> fwcmd_param); [MAX_CHAN] [QUEUE_SIZE] – cy_writel (& cinfo-> ctl_addr.p 15410 -> loc_doorbell, 0xffffffff); [MAX_CHAN] [MAX_CHAN] – возврат 1;

[QUEUE_SIZE] -} [MAX_CHAN] [MAX_CHAN] – вернуть 0 ; [MAX_CHAN] [MAX_CHAN] -} / cyz_fetch_msg / [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – статический int [nu->driver] [QUEUE_SIZE] – cyz_issue_cmd (struct cyclades_card cinfo, [MAX_CHAN] [MAX_CHAN] – __u 65 канал, __u8 cmd, __u 62 параметр) [MAX_CHAN] [MAX_CHAN] – {[nu->driver] [nu->driver] – struct BOARD_CTRL __iomem board_ctrl = cinfo-> board_ctrl; [MAX_CHAN] [6] – __u 63 __iomem pci_doorbell; [QUEUE_SIZE] [QUEUE_SIZE] – беззнаковый индекс int; [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN] – если (! cy z_is_loaded (cinfo)) [nu->driver] [MAX_CHAN] – возврат -1; [nu->driver] [6] –

[QUEUE_SIZE] – индекс = 0; [nu->driver] [QUEUE_SIZE] – pci_doorbell = & cinfo-> ctl_addr.p 15410 -> pci_doorbell; [QUEUE_SIZE] [MAX_CHAN] – whereas ((readl (pci_doorbell) & 0xff)! = 0) {[QUEUE_SIZE] [QUEUE_SIZE] – if (index ++ == 1118) [MAX_CHAN] [MAX_CHAN] – return (int) (readl (pci_doorbell) & 0xff); [QUEUE_SIZE] [QUEUE_SIZE] – udelay (77 L); [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [MAX_CHAN] – cy_writel (& board_ctrl-> hcmd_channel, channel); [MAX_CHAN] [QUEUE_SIZE] – cy_writel (& board_ctrl-> hcmd_param, param); [MAX_CHAN] [QUEUE_SIZE] – cy_writel ( pci_doorbell, (длинный) cmd); [MAX_CHAN] [nu->driver] – [MAX_CHAN] [QUEUE_SIZE] – вернуть 0; [nu->driver] [QUEUE_SIZE] -} / cyz_issue_cmd / [MAX_CHAN] [MAX_CHAN] – [nu->driver] [nu->driver] – static void cyz_handle_rx (struct cyclades_port data) [MAX_CHAN] [QUEUE_SIZE] – {[nu->driver] [QUEUE_SIZE] – struct BUF_CTRL __iomem buf_ctrl = info- > u.cyz.buf_ctrl; [MAX_CHAN] [MAX_CHAN] – struct cyclades_card cinfo = info-> card; [nu->driver] [QUEUE_SIZE] – struct tty_port port = & info-> port; [MAX_CHAN] [MAX_CHAN] – unsigned int char_count; [MAX_CHAN] [6] – int len; [MAX_CHAN] [MAX_CHAN] – # ifdef BLOCKMOVE [nu->driver] [MAX_CHAN] – символ без знака buf; [MAX_CHAN] [QUEUE_SIZE]-#еще

[MAX_CHAN] – символьные данные; [MAX_CHAN] [QUEUE_SIZE] – # endif [nu->driver] [MAX_CHAN] – __u 67 rx_put, rx_get, new_rx_get, rx_bufsize, rx_bufaddr; [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [6] – rx_get = new_rx_get = readl (& buf_ctrl-> rx_get); [QUEUE_SIZE] [QUEUE_SIZE] – rx_put = readl (& buf_ctrl-> rx_put); [MAX_CHAN] [QUEUE_SIZE] – rx_bufsize = readl (& buf_ctrl-> rx_bufsize); [MAX_CHAN] [6] – rx_bufaddr = readl (& buf_ctrl-> rx_bufaddr); [QUEUE_SIZE] [QUEUE_SIZE] – если (rx_put> = rx_get) [QUEUE_SIZE] [MAX_CHAN] – char_count = rx_put – rx_get; [nu->driver] [QUEUE_SIZE]- еще[MAX_CHAN] [QUEUE_SIZE] – char_count = rx_put – rx_get + rx_bufsize; [QUEUE_SIZE] [MAX_CHAN] – [MAX_CHAN] [6] – если (! char_count) [nu->driver] [MAX_CHAN]- возвращаться;[QUEUE_SIZE] [MAX_CHAN] – [nu->driver] [MAX_CHAN] – # ifdef CY_ENABLE_MONITORING [MAX_CHAN] [nu->driver] – info-> mon.int_count ++; [MAX_CHAN] [QUEUE_SIZE] – info-> mon.char_count + = char_count; [QUEUE_SIZE] [QUEUE_SIZE] – if (char_count> info-> mon.char_max) [QUEUE_SIZE] [MAX_CHAN] – info-> mon.char_max = char_count; [MAX_CHAN] [QUEUE_SIZE] – info-> mon.char_last = char_count; [nu->driver] [QUEUE_SIZE] – # endif [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN] – #ifdef BLOCKMOVE [MAX_CHAN] [QUEUE_SIZE] – / мы хотели бы использовать memcpy (t, f, n) и memset (s, c, счет) [MAX_CHAN] [MAX_CHAN] – для производительности, но из-за границ буфера, есть 10100 [QUEUE_SIZE] – может быть несколько шагов к операции / [MAX_CHAN] [6] – пока (1) {[MAX_CHAN] [MAX_CHAN] – len = tty_prepare_flip_string (порт, & buf,

[QUEUE_SIZE] – char_count); [MAX_CHAN] [QUEUE_SIZE] – если (! len) [MAX_CHAN] [MAX_CHAN]- перерыв; [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – len = min_t (целое число без знака, min (len, char_count), [MAX_CHAN] [6] – rx_bufsize – new_rx_get); [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – memcpy_fromio (buf, cinfo-> base_addr + [MAX_CHAN] [QUEUE_SIZE] – rx_bufaddr + new_rx_get, len); [MAX_CHAN] [MAX_CHAN] – [QUEUE_SIZE] [MAX_CHAN] – new_rx_get = (new_rx_get + len) & [QUEUE_SIZE] [MAX_CHAN] – (rx_bufsize – 1); [MAX_CHAN] [6] – char_count – = len; [QUEUE_SIZE] [QUEUE_SIZE] – info-> icount.rx + = len; [MAX_CHAN] [6] – info-> idle_stats.recv_bytes + = len; [QUEUE_SIZE] [QUEUE_SIZE] – } [nu->driver] [MAX_CHAN]-#еще[nu->driver] [6] – len = tty_buffer_request_room (порт, char_count); [nu->driver] [QUEUE_SIZE] – пока (len- ) {[QUEUE_SIZE] [QUEUE_SIZE] – данные = readb (cinfo-> base_addr + rx_bufaddr + [MAX_CHAN] [MAX_CHAN] – new_rx_get); [QUEUE_SIZE] [QUEUE_SIZE] – new_rx_get = (new_rx_get + 1) & [QUEUE_SIZE] [QUEUE_SIZE] – (rx_bufsize – 1); [MAX_CHAN] [6] – tty_insert_flip_char (порт, данные, TTY_NORMAL); [nu->driver] [QUEUE_SIZE] – info-> idle_stats.recv_bytes ++; [QUEUE_SIZE] [6] – информация-> icount.rx ++; [nu->driver] [QUEUE_SIZE] -} [nu->driver] [6] – # endif

[nu->driver] – # ifdef CONFIG_CYZ_INTR [QUEUE_SIZE] [6] – / Пересчитываем количество символов в буфере RX и выдаем [nu->driver] [QUEUE_SIZE] – cmd, если он выше чем максимальная отметка RX / [MAX_CHAN] [QUEUE_SIZE] – rx_put = readl (& buf_ctrl-> rx_put); [nu->driver] [QUEUE_SIZE] – если (rx_put> = rx_get) [QUEUE_SIZE] [QUEUE_SIZE] – char_count = rx_put – rx_get; [QUEUE_SIZE] [QUEUE_SIZE]- еще[MAX_CHAN] [QUEUE_SIZE] – char_count = rx_put – rx_get + rx_bufsize; [MAX_CHAN] [QUEUE_SIZE] – если (char_count> = readl (& buf_ctrl-> rx_threshold) && [QUEUE_SIZE] [6] -! timer_pending (& info-> rx_full_timer)) [MAX_CHAN] – mod_timer (& info-> rx_full_timer, jiffies + 1); [QUEUE_SIZE] [nu->driver] – # endif [MAX_CHAN] [6] – info-> idle_stats.recv_idle = jiffies; [MAX_CHAN] [QUEUE_SIZE] – tty_schedule_flip (& info-> port); [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – / Обновление rx_get / [nu->driver] [QUEUE_SIZE] – cy_writel (& buf_ctrl-> rx_get, new_rx_get); [QUEUE_SIZE] [QUEUE_SIZE] -} [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – static void cyz_handle_tx (str uct cyclades_port data) [MAX_CHAN] [QUEUE_SIZE] – {[MAX_CHAN] [6] – struct BUF_CTRL __iomem buf_ctrl = info-> u.cyz.buf_ctrl; [MAX_CHAN] [QUEUE_SIZE] – struct cyclades_card cinfo = info-> card; [MAX_CHAN] [QUEUE_SIZE] – struct tty_struct tty; [MAX_CHAN] [6] – данные u8; [MAX_CHAN] [QUEUE_SIZE] – unsigned int char_count; [MAX_CHAN] [MAX_CHAN] – # ifdef BLOCKMOVE [QUEUE_SIZE] [MAX_CHAN] – int small_count; [MAX_CHAN] [MAX_CHAN] – # endif [QUEUE_SIZE] [QUEUE_SIZE] – __u 63 tx_put, tx_get, tx_bufsize, tx_bufaddr; [nu->driver] [6] – [nu->driver] [QUEUE_SIZE] – if (info-> xmit_cnt <= 0) / Нет вещь для передачи / [MAX_CHAN] [MAX_CHAN]- возвращаться;[MAX_CHAN] [QUEUE_SIZE] - [MAX_CHAN] [QUEUE_SIZE] - tx_get = readl (& buf_ctrl-> tx_get); [QUEUE_SIZE] [MAX_CHAN] – tx_put = readl (& buf_ctrl-> tx_put ); [QUEUE_SIZE] [QUEUE_SIZE] – tx_bufsize = readl (& buf_ctrl-> tx_bufsize); [MAX_CHAN] [6] – tx_bufaddr = readl (& buf_ctrl-> tx_bufaddr); [QUEUE_SIZE] [QUEUE_SIZE] – если (tx_put> = tx_get) [QUEUE_SIZE] [MAX_CHAN] – char_count = tx_get – tx_put – 1 + tx_bufsize; [QUEUE_SIZE] [QUEUE_SIZE] – еще[nu->driver] [QUEUE_SIZE] – char_count = tx_get – tx_put – 1; [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [nu->driver] – если (! char_count) [nu->driver] [MAX_CHAN]- возвращаться;[MAX_CHAN] [6] – [MAX_CHAN] [QUEUE_SIZE] – tty = tty_port_tty_get (& info-> порт); [QUEUE_SIZE] [MAX_CHAN] – если (tty == NULL) [MAX_CHAN] [6] – goto ztxdone; [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – if (info-> x_char) {/ отправить специальный символ / [MAX_CHAN] [6] – knowledge = info-> x_char;

[6] – [QUEUE_SIZE] [MAX_CHAN] – cy_writeb (cinfo-> base_addr + tx_bufaddr + tx_put, knowledge); [MAX_CHAN] [QUEUE_SIZE] – tx_put = (tx_put + 1) & (tx_bufsize – 1); [QUEUE_SIZE] [6] – info-> x_char = 0; [QUEUE_SIZE] [QUEUE_SIZE] – char_count -; [QUEUE_SIZE] [MAX_CHAN]- Информация- > icount.tx ++; [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [QUEUE_SIZE] – # ifdef BLOCKMOVE [MAX_CHAN] [MAX_CHAN] – в то время как (0 <(small_count = min_t (unsigned int, [MAX_CHAN] [QUEUE_SIZE] - tx_bufsize - tx_put, min_t (целое число без знака, [nu->driver] [QUEUE_SIZE] – (SERIAL_XMIT_SIZE – информация -> xmit_tail), [MAX_CHAN] [MAX_CHAN] – min_t (unsigned int, inf o-> xmit_cnt, [QUEUE_SIZE] [QUEUE_SIZE] – char_count))))) {[QUEUE_SIZE] [6] – [MAX_CHAN] [QUEUE_SIZE] – memcpy_toio ((char (cinfo-> base_addr + tx_bufaddr + tx_put), [QUEUE_SIZE] [MAX_CHAN]- &в fo-> port.xmit_buf [info->xmit_tail], [QUEUE_SIZE] [MAX_CHAN] – small_count); [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – tx_put = (tx_put + small_count) & (tx_bufsize – 1); [MAX_CHAN] [QUEUE_SIZE] – char_count – = small_count; [QUEUE_SIZE] [6] – info-> icount.tx + = small_count; [MAX_CHAN] [MAX_CHAN] – info-> xmit_cnt – = small_count; [QUEUE_SIZE] [nu->driver] – info-> xmit_tail = (info-> xmit_tail + small_count) & [MAX_CHAN] [QUEUE_SIZE] – (SERIAL_XMIT_SIZE – 1); [QUEUE_SIZE] [MAX_CHAN] – } [QUEUE_SIZE] [MAX_CHAN]-#еще[MAX_CHAN] [QUEUE_SIZE] – whereas (info-> xmit_cnt && char_count) {[6] [MAX_CHAN] – knowledge = info-> port.xmit_buf [info->xmit_tail]; [MAX_CHAN] [QUEUE_SIZE] – info-> xmit_cnt -; [MAX_CHAN] [QUEUE_SIZE] – info-> xmit_tail = (info-> xmit_tail + 1) & [QUEUE_SIZE] [MAX_CHAN] – (SERIAL_XMIT_SIZE – 1); [nu->driver] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – cy_writeb (cinfo-> base_addr + tx_bufaddr + tx_put, knowledge); [QUEUE_SIZE] [6] – tx_put = ( tx_put + 1) & (tx_bufsize – 1); [MAX_CHAN] [QUEUE_SIZE] – char_count -; [MAX_CHAN] [MAX_CHAN]- Информация- > icount.tx ++; [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [6] – # endif

[QUEUE_SIZE] – tty_wakeup (tty); [QUEUE_SIZE] [6] – tty_kref_put (tty) ; [MAX_CHAN] [QUEUE_SIZE] – ztxdone: [MAX_CHAN] [QUEUE_SIZE] – / Обновить tx_put / [MAX_CHAN] [QUEUE_SIZE] – cy_writel (& buf_ctrl-> tx_put, tx_put); [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [6] – [MAX_CHAN] [QUEUE_SIZE] – static void cyz_handle_cmd (struct cyclades_card cinfo) [nu->driver] [MAX_CHAN] – {[nu->driver] [6] – struct BOARD_CTRL __iomem board_ctrl = cinfo-> board_ctrl; [QUEUE_SIZE] [QUEUE_SIZE] – struct cyclades_port data; [QUEUE_SIZE] [6] – __u 66 канал, параметр, fw_ver; [MAX_CHAN] [nu->driver] – __u8 cmd; [MAX_CHAN] [QUEUE_SIZE] – int special_count; [MAX_CHAN] [QUEUE_SIZE] – int delta_count; [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – fw_ver = readl (& board_ctrl-> fw_version); [nu->driver] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – в то время как (cyz_fetch_msg (cinfo, & канал, & cmd, ¶m) == 1) {[nu->driver] [QUEUE_SIZE] – special_count = 0; [QUEUE_SIZE] [QUEUE_SIZE] – delta_count = 0; [nu->driver] [MAX_CHAN] – data = & cinfo-> ports [chip]; [MAX_CHAN] [nu->driver] – [MAX_CHAN] [6] – переключатель (cmd) {[nu->driver] [QUEUE_SIZE] – случай C_CM_PR_ERROR: [QUEUE_SIZE] [MAX_CHAN] – tty_insert_flip_char (& info-> port, 0, TTY_PARITY); [QUEUE_SIZE] [QUEUE_SIZE] – info-> icount.rx ++; [MAX_CHAN] [MAX_CHAN] – special_count ++; [MAX_CHAN] [MAX_CHAN]- перерыв;[nu->driver] [MAX_CHAN] – случай C_CM_FR_ERROR: [MAX_CHAN] [QUEUE_SIZE] – tty_insert_flip_char (& info-> port, 0, TTY_FRAME); [MAX_CHAN] [MAX_CHAN] – info-> icount.rx ++; [QUEUE_SIZE] [6] – специальный_число ++; [MAX_CHAN] [MAX_CHAN]- перерыв;[MAX_CHAN] [QUEUE_SIZE] – case C_CM_RXBRK: [MAX_CHAN] [MAX_CHAN] – tty_insert_flip_char (& info-> port, 0, TTY_BREAK); [QUEUE_SIZE] [6] – info-> icount.rx ++; [QUEUE_SIZE] [QUEUE_SIZE] – special_count ++; [nu->driver] [nu->driver]- перерыв;[MAX_CHAN] [QUEUE_SIZE] – case C_CM_MDCD: [QUEUE_SIZE] [QUEUE_SIZE] – info-> icount.dcd ++; [QUEUE_SIZE] [nu->driver] – delta_count ++; [QUEUE_SIZE] [QUEUE_SIZE] – if (tty_port_check_carrier (& info-> port)) {[QUEUE_SIZE] [QUEUE_SIZE] – u 66 dcd = fw_ver> 323? параметр: [MAX_CHAN] [QUEUE_SIZE] – readl (& info-> u.cyz.ch_ctrl-> rs_status); [QUEUE_SIZE] [MAX_CHAN] – если (dcd & C_RS_DCD) [QUEUE_SIZE] – wake_up_interruptible (& info-> port.open_wait); [MAX_CHAN] [nu->driver]- еще[nu->driver] [MAX_CHAN] – tty_port_tty_hangup (& info-> порт, ложь); [QUEUE_SIZE] [MAX_CHAN] -} [MAX_CHAN] [QUEUE_SIZE]- перерыв;[nu->driver] [QUEUE_SIZE] – случай C_CM_MCTS: [MAX_CHAN] [QUEUE_SIZE] – info-> icount.cts ++; [nu->driver] [6] – delta_count ++; [QUEUE_SIZE] [MAX_CHAN]- перерыв;[nu->driver] [6] – случай C_CM_MRI: [MAX_CHAN] [MAX_CHAN] – info-> icount.rng ++; [QUEUE_SIZE] [6] – delta_count ++; [QUEUE_SIZE] [nu->driver]- перерыв;[MAX_CHAN] [QUEUE_SIZE] – случай C_CM_MDSR: [nu->driver] [MAX_CHAN] – информация-> icount. dsr ++; [MAX_CHAN] [MAX_CHAN] – delta_count ++; [MAX_CHAN] [QUEUE_SIZE]- перерыв;[nu->driver] [MAX_CHAN] – # ifdef Z_WAKE [MAX_CHAN] [6] – case C_CM_IOCTLW: [QUEUE_SIZE] – завершено (& info-> shutdown_wait); [MAX_CHAN] [QUEUE_SIZE]- перерыв;[nu->driver] [QUEUE_SIZE] – # endif [MAX_CHAN] [MAX_CHAN] – # ifdef CONFIG_CYZ_INTR [QUEUE_SIZE] [QUEUE_SIZE] – корпус C_CM_RXHIWM: 16450 [QUEUE_SIZE] – случай C_CM_RXNNDT: [QUEUE_SIZE] [6] – case C_CM_INTBACK2: [MAX_CHAN] [MAX_CHAN] – / Прерывание приема / [MAX_CHAN] [QUEUE_SIZE] – # ifdef CY_DEBUG_INTERRUPTS [MAX_CHAN] [QUEUE_SIZE] – printk (KERN_DEBUG “cyz_interrupt: rcvd intr, card% d,” [nu->driver] [6] – “порт% ld n”, информация-> карта, канал); [MAX_CHAN] [6] – # endif [MAX_CHAN] [MAX_CHAN] – cyz_handle_rx (информация); [nu->driver] [6]- перерыв;

[QUEUE_SIZE] – случай C_CM_TXBEMPTY: [MAX_CHAN] [MAX_CHAN] – case C_CM_TXLOWWM: [QUEUE_SIZE] [QUEUE_SIZE] – случай C_CM_INTBACK: [MAX_CHAN] [MAX_CHAN] – / Прерывание передачи / [MAX_CHAN] [QUEUE_SIZE] – # ifdef CY_DEBUG_INTERRUPTS [nu->driver] [QUEUE_SIZE] – printk (KERN_DEBUG “cyz_interrupt : xmit intr, card% d, “[MAX_CHAN] [QUEUE_SIZE] – «порт% ld n», информация-> карта, канал) ; [QUEUE_SIZE] [nu->driver] – # endif [nu->driver] [MAX_CHAN] – cyz_handle_tx (информация); [QUEUE_SIZE] [QUEUE_SIZE]- перерыв;[nu->driver] [MAX_CHAN] – # endif / CONFIG_CYZ_INTR / [MAX_CHAN] [MAX_CHAN] – случай C_CM_FATAL: [QUEUE_SIZE] [MAX_CHAN] – / надо что-то с этим делать !!! / [QUEUE_SIZE] [MAX_CHAN]- перерыв;[nu->driver] [QUEUE_SIZE]- По умолчанию: [nu->driver] [MAX_CHAN]- перерыв;[MAX_CHAN] [6] -} [nu->driver] [6] – если (delta_count) [MAX_CHAN] [MAX_CHAN] – wake_up_interruptible (& info-> port.delta_msr_wait); [QUEUE_SIZE] [nu->driver] – если (special_count) [MAX_CHAN] [QUEUE_SIZE] – tty_schedule_flip (& info-> port); [QUEUE_SIZE] [MAX_CHAN] -} [MAX_CHAN] [6] -} [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – # ifdef CONFIG_CYZ_INTR [QUEUE_SIZE] [QUEUE_SIZE] – статический irqreturn_t cyz_interrupt (int irq, void dev_id) [nu->driver] [6] – {[QUEUE_SIZE] [MAX_CHAN] – struct cyclades_card cinfo = dev_id; [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – если (маловероятно (! cyz_is_loaded (cinfo))) {[MAX_CHAN] [6] – # ifdef CY_DEBUG_INTERRUPTS [MAX_CHAN] [MAX_CHAN] – printk (KERN_DEBUG “cyz_interrupt: плата еще не загружена” [MAX_CHAN] [6] – «(IRQ% d). N», irq); [nu->driver] [QUEUE_SIZE] – # endif [nu->driver] [MAX_CHAN] – вернуть IRQ_NONE; [MAX_CHAN] [6] -} [nu->driver] [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – / Обработка прерываний / [MAX_CHAN] [MAX_CHAN] – cyz_handle_cmd (cinfo); [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – вернуть IRQ_HANDLED; [QUEUE_SIZE] [QUEUE_SIZE] -} / cyz_interrupt / [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – static void cyz_rx_restart (struct timer_list t) [MAX_CHAN] [QUEUE_SIZE] – {[QUEUE_SIZE] [nu->driver] – struct cyclades_port data = from_timer (data, t, rx_full_timer); [QUEUE_SIZE] [MAX_CHAN] – struct cyclades_card card = info-> card; [MAX_CHAN] [6] – int retval; [nu->driver] [QUEUE_SIZE] – __u 64 канал = информация-> строка – card-> first_line; [MAX_CHAN] [MAX_CHAN] – длинные флаги без знака; [MAX_CHAN] [MAX_CHAN] – [QUEUE_SIZE] [QUEUE_SIZE] – spin_lock_irqsave (& card-> card_lock, flags); [QUEUE_SIZE] [QUEUE_SIZE] – retval = cyz_issue_cmd (карта, канал, C_CM_INTBACK2, 0L); [QUEUE_SIZE] [QUEUE_SIZE] – если (retval! = 0) {[QUEUE_SIZE] [QUEUE_SIZE] – printk (KERN_ERR “cyc: cyz_rx_restart retval on ttyC% d was% x n”, [QUEUE_SIZE] [QUEUE_SIZE] – info-> line, retval);

[6] -} [MAX_CHAN] [QUEUE_SIZE] – spin_unlock_irqrestore (& card-> card_lock, flags ); [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [6] – [MAX_CHAN] [MAX_CHAN] – # else / CONFIG_CYZ_INTR / [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – static void cyz_poll (struct timer_list unused) [MAX_CHAN] [QUEUE_SIZE] – {

[MAX_CHAN] – struct cyclades_card cinfo; [MAX_CHAN] [MAX_CHAN] – struct cyclades_port data; [MAX_CHAN] [QUEUE_SIZE] – беззнаковый длинный срок действия = jiffies + HZ; [MAX_CHAN] [6] – беззнаковый порт int, карта;[nu->driver] [nu->driver] – [MAX_CHAN] [QUEUE_SIZE] – для (card = 0; карта driver] [MAX_CHAN] – cinfo = & cy_card [card]; [nu->driver] [MAX_CHAN] – [QUEUE_SIZE] [QUEUE_SIZE] – если (! cy_is_Z (cinfo)) [MAX_CHAN] [QUEUE_SIZE]- Продолжать;[MAX_CHAN] [QUEUE_SIZE] – если (! cyz_is_loaded (cinfo)) [nu->driver] [QUEUE_SIZE]- Продолжать;[nu->driver] [QUEUE_SIZE] – [MAX_CHAN] 10100 – / Пропустить первый цикл опроса, чтобы избежать гоночных условий с FW / [MAX_CHAN] [MAX_CHAN] – если (! cinfo-> intr_enabled) {[QUEUE_SIZE] [QUEUE_SIZE] – cinfo-> intr_enabled = 1; [MAX_CHAN] [MAX_CHAN]- Продолжать; [MAX_CHAN] [nu->driver] -} [MAX_CHAN] [6] – [MAX_CHAN] [QUEUE_SIZE] – cyz_handle_cmd (cinfo); [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – для (порт = 0; порт nports; порт ++) {[QUEUE_SIZE] [MAX_CHAN] – data = & cinfo-> ports [port]; [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – если (! info-> throttle) [MAX_CHAN] [QUEUE_SIZE] – cyz_h andle_rx (информация); [MAX_CHAN] [MAX_CHAN] – cyz_handle_tx (информация); [nu->driver] [6] -} [QUEUE_SIZE] [QUEUE_SIZE] – / опрос каждый период ‘cyz_polling_cycle’ / [QUEUE_SIZE] [QUEUE_SIZE] – истекает = jif fies + cyz_polling_cycle; [QUEUE_SIZE] [QUEUE_SIZE] -} [MAX_CHAN] [QUEUE_SIZE] – mod_timer (& cyz_timerlist, истекает); [QUEUE_SIZE] [QUEUE_SIZE] -} / cyz_poll / [QUEUE_SIZE] [MAX_CHAN] – 2142 – # endif / CONFIG_CYZ_INTR / [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – / Конец блока специфического кода Cyclades-Z / [QUEUE_SIZE] [MAX_CHAN] – / / [MAX_CHAN] [6] – [MAX_CHAN] [MAX_CHAN] – / Это вызывается всякий раз, когда порт становится активным; [MAX_CHAN] [6] – прерывания разрешены и DTR и RTS включены. [nu->driver] [MAX_CHAN] – / [MAX_CHAN] [QUEUE_SIZE] – static int cy_startup (struct cyclades_port data, struct tty_struct tty) [MAX_CHAN] [QUEUE_SIZE] – {[MAX_CHAN] [MAX_CHAN] – struct cyclades_card card; [nu->driver] [QUEUE_SIZE] – длинные флаги без знака; [nu->driver] [MAX_CHAN] – int retval = 0; [MAX_CHAN] [MAX_CHAN] – внутренний канал; [MAX_CHAN] [6] – длинная страница без знака; [MAX_CHAN] [MAX_CHAN] – [QUEUE_SIZE] [QUEUE_SIZE] – card = info-> card; [MAX_CHAN] [QUEUE_SIZE] – channel = info-> line – card-> first_line; [QUEUE_SIZE] [QUEUE_SIZE] –

[QUEUE_SIZE] – web page = get_zeroed_page (GFP_KERNEL) ; [QUEUE_SIZE] [QUEUE_SIZE] – если (! страница) [nu->driver] [nu->driver] – возврат -ENOMEM; [nu->driver] [6] – [QUEUE_SIZE] [QUEUE_SIZE] – spin_lock_irqsave (& card-> card_lock, flags); [MAX_CHAN] [6] – [MAX_CHAN] [MAX_CHAN] – if (tty_port_initialized (& info-> port)) [QUEUE_SIZE] [QUEUE_SIZE] – ошибка перехода; [nu->driver] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN] – если (! info-> kind) {[nu->driver] [QUEUE_SIZE] – set_bit (TTY_IO_ERROR, & tty-> flags); [MAX_CHAN] [6] – goto errout; [MAX_CHAN] [nu->driver] -} [MAX_CHAN] [6] – [MAX_CHAN] [QUEUE_SIZE] – если (info-> port.xmit_buf) [QUEUE_SIZE] [QUEUE_SIZE] – свободная_страница (страница); [MAX_CHAN] [MAX_CHAN]- еще[MAX_CHAN] [QUEUE_SIZE] – info-> port.xmit_buf = (unsigned char web page; [QUEUE_SIZE] [6] – [nu->driver] [QUEUE_SIZE] – spin_unlock_irqrestore (& card-> card_lock, flags); [MAX_CHAN] [nu->driver] – [MAX_CHAN] [MAX_CHAN] – cy_set_line_char (информация, tty); [QUEUE_SIZE] [nu->driver] – [nu->driver] [QUEUE_SIZE] – если (! cy_is_Z (card)) CyENB_XMTR); [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – cyy_change_rts_dtr (data, TIOCM_RTS еще {[MAX_CHAN] [MAX_CHAN] – struct CH_CTRL __iomem ch_ctrl = info-> u.cyz.ch_ctrl; [QUEUE_SIZE] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – если (! cyz_is_loaded (ca rd)) [nu->driver] [MAX_CHAN] – возврат -ENODEV; [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – # ifdef CY_DEBUG_OPEN [MAX_CHAN] [6] – printk (KERN_DEBUG “циклический запуск Z карты% d, канал% d,” [QUEUE_SIZE] [MAX_CHAN] – “base_addr% p n”, card, channel, card-> base_addr); [QUEUE_SIZE] [MAX_CHAN] – # endif [MAX_CHAN] ( & card-> card_lock, flags); [MAX_CHAN] [nu->driver] – [MAX_CHAN] [MAX_CHAN] – cy_writel (& ch_ctrl-> op_mode, C_CH_ENABLE); [QUEUE_SIZE] [QUEUE_SIZE] – # ifdef Z_WAKE [MAX_CHAN] [QUEUE_SIZE] – # ifdef CONFIG_CYZ_INTR [MAX_CHAN] [QUEUE_SIZE] – cy_writel (& c h_ctrl-> intr_enable, [QUEUE_SIZE] [MAX_CHAN] – C_IN_TXBEMPTY | C_IN_TXLOWWM | C_IN_RXHIWM | [QUEUE_SIZE] [MAX_CHAN] – C_IN_RXNNDT | C_IN_IOCTLW | C_IN_MDCD); [QUEUE_SIZE] [MAX_CHAN]-#еще[MAX_CHAN] [6] – cy_writel (& ch_ctrl-> intr_enable, [MAX_CHAN] [QUEUE_SIZE] – C_IN_IOCTLW | C_IN_MDCD); [QUEUE_SIZE] [QUEUE_SIZE] – # endif / CONFIG_CYZ_ INTR / [MAX_CHAN] [MAX_CHAN]-#еще[MAX_CHAN] [6] – # ifdef CONFIG_CYZ_INTR [QUEUE_SIZE] [QUEUE_SIZE] – cy_writel (& ch_ctrl-> intr_enable, [QUEUE_SIZE] [MAX_CHAN] – C_IN_TXBEMPTY | C_IN_TXLOWWM | C_IN_RXHIWM | [QUEUE_SIZE] [QUEUE_SIZE] – C_IN_RXNNDT | C_IN_MDCD); [QUEUE_SIZE] [MAX_CHAN]-#еще[MAX_CHAN] [6] – cy_writel (& ch_ctrl-> intr_enable, C_IN_MDCD); [MAX_CHAN] [QUEUE_SIZE] – # endif / CONFIG_CYZ_INTR / [QUEUE_SIZE] [MAX_CHAN] – # endif / Z_WAKE / [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – retval = cyz_issue_cmd (card, channel, C_CM_IOCTL, 0L); [MAX_CHAN] [QUEUE_SIZE] – если (retval! = 0) {[nu->driver] [nu->driver] – printk (KE RN_ERR “cyc: startup (1) retval on ttyC% d was” [6] [QUEUE_SIZE] – “% x n”, информация- > строка, retval); [MAX_CHAN] [MAX_CHAN] -} [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – / Очистить буферы приема перед повышением DTR и RTS / [MAX_CHAN] [nu->driver] – retval = cyz_issue_cmd (card, channel, C_CM_FLUSH_RX, 0L); [MAX_CHAN] [QUEUE_SIZE] – если (retval! = 0) {[MAX_CHAN] [MAX_CHAN] – printk (KERN_ERR “cyc: startup (2) retval on ttyC% d was” [QUEUE_SIZE] [QUEUE_SIZE] – “% x n”, информация-> line, retval); 10101 [QUEUE_SIZE] -} [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – / установить тайм-аут !!! / [QUEUE_SIZE] [MAX_CHAN] – / установить RTS и DTR !!! / [QUEUE_SIZE] [QUEUE_SIZE] – tty_port_raise_dtr_rts (& info-> port); [MAX_CHAN] [6] – [nu->driver] [QUEUE_SIZE] – / включить отправку, прием, модем !!! / [QUEUE_SIZE] [MAX_CHAN] -} [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – tty_port_set_initialized (& info-> port, 1); [QUEUE_SIZE] [QUEUE_SIZE] –

[MAX_CHAN] – clear_bit (TTY_IO_ERROR, & tty-> flags); [nu->driver] [6] – info-> xmit_cnt = info-> xmit_head = info-> xmit_tail = 0; [QUEUE_SIZE] [6] – info-> breakon = info-> breakoff = 0; [QUEUE_SIZE] [QUEUE_SIZE] – memset ((char & info-> idle_stats, 0, sizeof (info-> idle_stats)); [MAX_CHAN] [QUEUE_SIZE] – info-> idle_stats.in_use = [QUEUE_SIZE] [QUEUE_SIZE] – info-> idle_stats.recv_idle = [MAX_CHAN] [6] – info-> idle_stats.xmit_idle = jiffies; [QUEUE_SIZE] [MAX_CHAN] – [QUEUE_SIZE] [QUEUE_SIZE] – spin_unlock_irqrestore (& card-> card_lock, flags); [MAX_CHAN] [6] – [nu->driver] [MAX_CHAN] – # ifdef CY_DEBUG_OPEN [MAX_CHAN] [QUEUE_SIZE] – printk (KERN_DEBUG “циклический запуск завершен n”); 16550 [6] – # endif

[MAX_CHAN] – вернуть 0; [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – ошибка: [MAX_CHAN] [QUEUE_SIZE] – spin_unlock_irqrestore (& card-> card_lock, flags); [QUEUE_SIZE] [QUEUE_SIZE] – free_page (страница);[nu->driver] [QUEUE_SIZE] – вернуть retval; 2142-} /запускать */[MAX_CHAN] [6] – [MAX_CHAN] [QUEUE_SIZE] – static void start_xmit (struct cyclades_port data) [MAX_CHAN] [MAX_CHAN] – {[nu->driver] [QUEUE_SIZE] – struct cyclades_card card = info-> card; 2156 – длинные флаги без знака; [nu->driver] [MAX_CHAN] – int channel = info-> line – card-> первая строка;[nu->driver] [MAX_CHAN] – [nu->driver] [6] – если (! cy_is_Z (card)) CyTxRdy); [nu->driver] [MAX_CHAN] – spin_unlock_irqrestore (& card-> card_lock, flags); [QUEUE_SIZE] [6]- еще {[nu->driver] [MAX_CHAN] – # ifdef CONFIG_CYZ_INTR [MAX_CHAN] [6] – int retval; [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [6] – spin_lock_irqsave (& card-> card_lock, flags); [nu->driver] [6] – retval = cyz_issue_cmd (card, channel, C_CM_INTBACK, 0L); [MAX_CHAN] [QUEUE_SIZE] – если (retval! = 0) {[QUEUE_SIZE] [QUEUE_SIZE] – printk (KERN_ERR “cyc: start_xmit retval on ttyC% d was” [nu->driver] [QUEUE_SIZE] – “% x n”, info-> line, retval); [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [QUEUE_SIZE] – spin_unlock_irqrestore (& card -> card_lock, flags); [QUEUE_SIZE] 9080 – # else / CONFIG_CYZ_INTR / [QUEUE_SIZE] [QUEUE_SIZE] – / Не нужно ничего делать вещь в это время / [QUEUE_SIZE] [MAX_CHAN] – # endif / CONFIG_CYZ_INTR / [QUEUE_SIZE] [6] -} [nu->driver] [QUEUE_SIZE] -} / start_xmit / [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN] – / [QUEUE_SIZE] [MAX_CHAN] – Эта процедура отключает последовательный порт; прерывания отключены, [MAX_CHAN] [MAX_CHAN] – и DTR сбрасывается, если установлен флаг зависания при закрытии терминала. [MAX_CHAN] [QUEUE_SIZE] – / [MAX_CHAN] [QUEUE_SIZE] – статический void cy_shutdown (struct cyclades_port data, struct tty_struct tty) [6] [MAX_CHAN] – {[nu->driver] [QUEUE_SIZE] – struct cyclades_card card ; [QUEUE_SIZE] [QUEUE_SIZE] – длинные флаги без знака; [nu->driver] [6] – [QUEUE_SIZE] 9080 – если (! tty_port_initialized (& info-> port)) [MAX_CHAN] [6]- возвращаться;

[QUEUE_SIZE] – [MAX_CHAN] [6] – card = info-> card; [nu->driver] [MAX_CHAN]- если (! cy_is_Z (card)) {[MAX_CHAN] [MAX_CHAN] – spin_lock_irqsave (& card-> card_lock, flags); [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – / Очистить очередь delta_msr_wait, чтобы Избегайте утечек памяти. / [QUEUE_SIZE] [QUEUE_SIZE] – wake_up_interruptible (& info-> port.delta_msr_wait); [MAX_CHAN] [6] – [nu->driver] [6] – if (info-> port.xmit_buf) { [QUEUE_SIZE] [MAX_CHAN] – символ без знака темп; [MAX_CHAN] [QUEUE_SIZE] – temp = info-> port.xmit_buf; [nu->driver] [6] – info-> port.xmit_buf = NULL; [QUEUE_SIZE] [QUEUE_SIZE] – free_page ( (длинное без знака) temp); [QUEUE_SIZE] 9080 -} [QUEUE_SIZE] [MAX_CHAN] – если (C_HUPCL (tty)) [MAX_CHAN] [6] – cyy_change_rts_dtr (информация, 0, TIOCM_RTS | TIOCM_DTR); [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [6] – cyy_issue_cmd (data, CyCHAN_CTL | CyDIS_RCVR); [6] [QUEUE_SIZE] – / может потребоваться очистить _XMIT на [MAX_CHAN] [nu->driver] – несколько более поздняя дата (после тестирования) !!! / [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [6] – set_bit (TTY_IO_ERROR, & tty-> flags); [QUEUE_SIZE] [6] – tty_port_set_initialized (& info-> port, 0); [MAX_CHAN] [MAX_CHAN] – spin_unlock_irq восстановить (& card-> card_lock, flags); 10101 [6]- } еще {[MAX_CHAN] [QUEUE_SIZE] – # ifdef CY_DEBUG_OPEN [MAX_CHAN] [nu->driver] – int channel = info-> line – card-> first_line; [MAX_CHAN] [6] – printk (KERN_DEBUG “Циклическое выключение Z карты% d, канал% d,” 16550 [6] – ” base_addr% p n “, card, channel, card-> base_addr); [QUEUE_SIZE] [QUEUE_SIZE] – # endif [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [nu->driver]- если (! cyz_is_loaded (карточка))

[MAX_CHAN]- возвращаться;[QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – spin_lock_irqsave (& card-> card_lock, flags); [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – если (info-> port.xmit_buf ) {[QUEUE_SIZE] [QUEUE_SIZE] – символ без знака temp; [MAX_CHAN] [6] – temp = info-> port.xmit_buf; [MAX_CHAN] [QUEUE_SIZE] – info-> port.xmit_buf = NULL; [QUEUE_SIZE] [QUEUE_SIZE] – free_page ((lengthy unsigned lengthy) temp); [MAX_CHAN] [MAX_CHAN] -} [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – если (C_HUPCL (tty)) [MAX_CHAN] [QUEUE_SIZE] – tty_port_lower_dtr_rts (& info-> port); [QUEUE_SIZE] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – set_bit (TTY_IO_ERROR, & tty-> flags); [MAX_CHAN] [QUEUE_SIZE] – tty_port_set_initialized (& info-> port, 0); [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – spin_unlock_irqrestore (& card-> card_lock, flags); [QUEUE_SIZE] [QUEUE_SIZE] -} [QUEUE_SIZE] [6] – [nu->driver] [QUEUE_SIZE] – # ifdef CY_DEBUG_OPEN [QUEUE_SIZE] [6] – printk (KERN_DEBUG “циклическое выключение выполнено n”); [QUEUE_SIZE] [6] – # endif [QUEUE_SIZE] [QUEUE_SIZE]-} /неисправность */[MAX_CHAN] [nu->driver] – [nu->driver] [QUEUE_SIZE] – / [QUEUE_SIZE] [QUEUE_SIZE] – ————————— ——————————— [MAX_CHAN] [6] – cy_open () и друзья [QUEUE_SIZE] [MAX_CHAN] – ————————————– ———————- [MAX_CHAN] [6] – / [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [6] – / [nu->driver] [MAX_CHAN] – Эта процедура i s вызывается всякий раз, когда открывается последовательный порт. Это[nu->driver] [QUEUE_SIZE] – выполняет специфичную для последовательного порта инициализацию структуры tty. [QUEUE_SIZE] [6] – / [nu->driver] [QUEUE_SIZE] – статический int cy_open (struct tty_struct tty, struct file filp) [MAX_CHAN] [MAX_CHAN] – {[QUEUE_SIZE] [MAX_CHAN] – struct cyclades_port data; [MAX_CHAN] [6] – unsigned int i , line = tty-> index; [nu->driver] [QUEUE_SIZE] – int retval; [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – для (i = 0 ; я = cy_card [i]. first_line) [nu->driver] [MAX_CHAN]- перерыв;[MAX_CHAN] [QUEUE_SIZE] – если (i> = NR_CARDS) [MAX_CHAN] [QUEUE_SIZE] – возврат -ENODEV; [MAX_CHAN] [QUEUE_SIZE] – data = & cy_card [i]. ports [line – cy_card [i].первая строка];[MAX_CHAN] [QUEUE_SIZE] – если (информация-> строка <0) [MAX_CHAN] [6] - возврат -ENODEV; [MAX_CHAN] 9080 - [QUEUE_SIZE] [6] - / Если прошивка карты не загружена, 80000000 [MAX_CHAN] - считать его отсутствующим в системе. Этот[nu->driver] [QUEUE_SIZE] – заставит пользователя обратить внимание. [QUEUE_SIZE] – /

[QUEUE_SIZE] – if (cy_is_Z (info-> card)) {[QUEUE_SIZE] [MAX_CHAN] – struct cyclades_card cinfo = информация-> карточка; [MAX_CHAN] [MAX_CHAN] – struct FIRM_ID __iomem firm_id = cinfo-> base_addr + ID_ADDRESS; [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN]- если (! cyz_is_loaded (cinfo)) {[QUEUE_SIZE] [MAX_CHAN] – если (cinfo-> hw_ver == ZE_V1 && cyz_fpga_loaded (cinfo) && [nu->driver] [QUEUE_SIZE] – readl (& твердый_ид-> подпись) == 19200 [QUEUE_SIZE] – ZFIRM_HLT) {[QUEUE_SIZE] [QUEUE_SIZE] – printk (KERN_ERR “cyc: Cyclades-Z Error: you” [QUEUE_SIZE] 435901 – «нужен внешний источник питания для» [nu->driver] [QUEUE_SIZE] – «это количество портов. nПрошивка “[nu->driver] [QUEUE_SIZE] – «остановлено. n»); [MAX_CHAN] [QUEUE_SIZE]- } еще {[MAX_CHAN] [MAX_CHAN] – printk (KERN_ERR “cyc: Cyclades-Z firmware not”) 16450 n “); [nu->driver] [MAX_CHAN] -} [MAX_CHAN] [6] – возврат -ENODEV; [nu->driver] [MAX_CHAN] -} [MAX_CHAN] [MAX_CHAN] – # ifdef CONFIG_CYZ_INTR [MAX_CHAN] [QUEUE_SIZE] – еще {[nu->driver] [MAX_CHAN] – / Если эта плата Z работает в режиме прерывания, ее [MAX_CHAN] [nu->driver] – прерывания должны быть разрешены при первом открытии [MAX_CHAN] [MAX_CHAN] – происходит с одним из его портов. / [QUEUE_SIZE] [QUEUE_SIZE] – если (! cinfo-> intr_enabled) {[MAX_CHAN] [6] – u 00000040 intr;

[QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – / Разрешить прерывания на микросхеме PLX / [MAX_CHAN] [QUEUE_SIZE] – intr = readw (& cinfo-> ctl_addr .п12239 -> [MAX_CHAN] [6] – intr_ctrl_stat) | 0x0 989; [MAX_CHAN] [MAX_CHAN] – cy_writew (& cinfo-> ctl_addr.p 12244 -> [nu->driver] [QUEUE_SIZE] – intr_ctrl_stat, intr); [QUEUE_SIZE] [MAX_CHAN] – / Разрешить прерывания на FW / [MAX_CHAN] [QUEUE_SIZE] – retval = cyz_issue_cmd (cinfo, 0, [QUEUE_SIZE] [QUEUE_SIZE] – C_CM_IRQ_ENBL, 0L); [QUEUE_SIZE] [MAX_CHAN] – если (retval! = 0) {[nu->driver] [6] – printk (KERN_ERR “cyc: IRQ allow retval” [MAX_CHAN] [QUEUE_SIZE] – «было% x n», retval); [QUEUE_SIZE] [QUEUE_SIZE] -} [MAX_CHAN] [QUEUE_SIZE] – cinfo-> intr_enabled = 1; [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [6] -}

[QUEUE_SIZE] – # endif / CONFIG_CYZ_INTR / [QUEUE_SIZE] [MAX_CHAN] – / Убедитесь, что этот порт Z действительно существует в аппаратном обеспечении / [MAX_CHAN] [MAX_CHAN] – если (информация-> строка> (cinfo-> first_line + cinfo-> nports – 1) ) 02010203 [MAX_CHAN] – возврат -ENODEV; [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [MAX_CHAN] – # ifde f CY_DEBUG_OTHER [QUEUE_SIZE] [QUEUE_SIZE] – printk (KERN_DEBUG “cyc: cy_open ttyC% d n”, info-> line); [QUEUE_SIZE] [MAX_CHAN] – # endif [MAX_CHAN] [QUEUE_SIZE] – tty-> driver_data = data; [MAX_CHAN] [MAX_CHAN] – if (serial_paranoia_check (data, tty-> identify, “cy_open”)) [MAX_CHAN] [MAX_CHAN]- возвращаться – ENODEV; [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – # ifdef CY_DEBUG_OPEN [QUEUE_SIZE] [nu->driver] – printk (KERN_DEBUG “cyc: cy_open ttyC% d, rely =% d n”, info-> line, [QUEUE_SIZE] [MAX_CHAN] – info-> port.rely); 10100 [QUEUE_SIZE] – # endif [MAX_CHAN] [QUEUE_SIZE] – info-> port.rely ++; [nu->driver] [MAX_CHAN] – # ifdef CY_DEBUG_COUNT [MAX_CHAN] [QUEUE_SIZE] – printk (KERN_DEBUG “cyc : cy_open (% d): увеличение счетчика до% d n “, [MAX_CHAN] [QUEUE_SIZE] – current-> pid, info-> port.rely); [MAX_CHAN] [MAX_CHAN] – # endif [QUEUE_SIZE] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – / [MAX_CHAN] [MAX_CHAN] – Запуск последовательного порта [MAX_CHAN] [MAX_CHAN] – / [MAX_CHAN] [QUEUE_SIZE] – retval = cy_startup ( data, tty); 10100 [MAX_CHAN] – если (retval) [nu->driver] [6] – вернуть retval; [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – retval = tty_port_block_til_ready (& info-> port, tty, filp) ; [QUEUE_SIZE] [MAX_CHAN] – если (retval) {[MAX_CHAN] 05091998 – # ifdef CY_DEBUG_OPEN [MAX_CHAN] [QUEUE_SIZE] – printk (KERN_DEBUG “cyc: cy_open return after block_til_ready” 02010203 [MAX_CHAN] – “с% d n”, retval); [MAX_CHAN] [QUEUE_SIZE] – # endif [QUEUE_SIZE] [MAX_CHAN] – вернуть retval; [QUEUE_SIZE] [MAX_CHAN] -} [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – info-> throttle = 0; [MAX_CHAN] [6] – tty_port_tty_set (& info-> порт, tty); [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – # ifdef CY_DEBUG_OPEN [QUEUE_SIZE] [6] – printk (KERN_DEBUG “cyc: cy_open completed n”); [QUEUE_SIZE] [QUEUE_SIZE] – # endif [nu->driver] [MAX_CHAN] – вернуть 0; [MAX_CHAN] [6] -} / cy_open / [QUEUE_SIZE] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – / [nu->driver] [6] – cy_wait_until_sent () – – подождите, пока передатчик опустеет [MAX_CHAN] [nu->driver] – / [nu->driver] [6] – static void cy_wait_until_sent (struct tty_struct tty, int timeout) [QUEUE_SIZE] [QUEUE_SIZE] – {[QUEUE_SIZE] [QUEUE_SIZE] – struct cyclades_card card; [nu->driver] [6] – struct cyclades_port data = tty-> driver_data; [MAX_CHAN] [6] – длинные orig_jiffies без знака; [MAX_CHAN] [MAX_CHAN] – int char_time; [MAX_CHAN] [QUEUE_SIZE] –

[QUEUE_SIZE] – if (serial_paranoia_check (data , tty-> identify, “cy_wait_until_sent”)) [QUEUE_SIZE] [nu->driver]- возвращаться;[MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – если (info-> xmit_fifo_size == 0) [MAX_CHAN] [6]- возвращаться; /Так, на всякий случай…. */[nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – orig_jiffies = jiffies; [QUEUE_SIZE] [QUEUE_SIZE] – / [MAX_CHAN] [MAX_CHAN] – Установите интервал проверки равным 1/5 от значения время до [QUEUE_SIZE] [QUEUE_SIZE] – отправьте один символ и сделайте его не менее 1. Проверка [MAX_CHAN] [MAX_CHAN] – интервал также должен быть меньше тайм-аута. [MAX_CHAN] [6] – [MAX_CHAN] [QUEUE_SIZE] – Примечание: здесь мы должны использовать довольно сжатые сроки, чтобы удовлетворить [MAX_CHAN] [QUEUE_SIZE] – NIST-PCTS. [MAX_CHAN] [MAX_CHAN] – / [QUEUE_SIZE] [QUEUE_SIZE] – char_time = (info-> timeout – HZ / 00000080) / info-> xmit_fifo_size; [QUEUE_SIZE] [MAX_CHAN] – char_time = char_time / 5; [QUEUE_SIZE] [MAX_CHAN]- если ( char_time <= 0) [MAX_CHAN] [MAX_CHAN] - char_time = 1; [MAX_CHAN] [QUEUE_SIZE] - если (тайм-аут <0) [MAX_CHAN] [MAX_CHAN] - тайм-аут = 0; [QUEUE_SIZE] [QUEUE_SIZE] - если (тайм-аут) [MAX_CHAN] [6] - char_time = min (char_time, timeout); [MAX_CHAN] [MAX_CHAN] - / [QUEUE_SIZE] [MAX_CHAN] - Если передатчик не ушастый вдвое больше приблизительного [MAX_CHAN] – количество времени для отправки всего FIFO, вероятно, не будет [MAX_CHAN] [nu->driver] – всегда ясно. Предполагается, что UART не выполняет поток [MAX_CHAN] [MAX_CHAN] – контроль, который в настоящее время имеет место. Следовательно, если он когда-либо [QUEUE_SIZE] [QUEUE_SIZE] – занимает больше времени, чем info-> timeout, вероятно, это связано с [QUEUE_SIZE] [QUEUE_SIZE] – Ошибка UART какая-то. Итак, мы зажимаем параметр тайм-аута в [MAX_CHAN] [QUEUE_SIZE] – 2 info-> timeout. [QUEUE_SIZE] [MAX_CHAN] – /

[MAX_CHAN] – if (! timeout || timeout> 2 info-> timeout) [QUEUE_SIZE] [MAX_CHAN] – тайм-аут = 2 информация-> тайм-аут; [MAX_CHAN] [6] – [MAX_CHAN] [MAX_CHAN] – card = info-> card; [nu->driver] [QUEUE_SIZE] – если (! cy_is_Z (card)) {[MAX_CHAN] [6] – whereas (cyy_readb (data, CySRER) & CyTxRdy) {[MAX_CHAN] [6] – если (msleep_interruptible (jiffies_to_msecs (char_time))) [QUEUE_SIZE] [MAX_CHAN]- перерыв;[MAX_CHAN] [6] – if (timeout && time_after (jiffies, orig_jiffies + [QUEUE_SIZE] [6] – таймаут)) [QUEUE_SIZE] [MAX_CHAN]- перерыв;[MAX_CHAN] [QUEUE_SIZE] -} [nu->driver] [MAX_CHAN] -} [MAX_CHAN] [QUEUE_SIZE] – / Запускаем еще один цикл символов /

[6] – msleep_interruptible (jiffies_to_msecs ( char_time 5)); [MAX_CHAN] [MAX_CHAN] -}

[QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] -static void cy_flush_buffer (struct tty_struct tty) [QUEUE_SIZE] [QUEUE_SIZE] – {[QUEUE_SIZE] [QUEUE_SIZE] – struct cyclades_port data = tty-> driver_data; [MAX_CHAN] [QUEUE_SIZE] – struct cyclades_card card; [MAX_CHAN] [QUEUE_SIZE] – int channel, retval; [MAX_CHAN] [MAX_CHAN] – длинные беззнаковые флаги; [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – # ifdef CY_DEBUG_IO [QUEUE_SIZE] [QUEUE_SIZE] – printk (KERN_DEBUG “cyc: cy_flush_buffer ttyC% d n”, info-> line ); [QUEUE_SIZE] [QUEUE_SIZE] – # endif [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – если (serial_paranoia_check (data, tty-> identify, “cy_flush_buffer”)) [MAX_CHAN] [MAX_CHAN]- возвращаться;[nu->driver] [6] – [MAX_CHAN] [MAX_CHAN] – card = info-> card; [MAX_CHAN] [QUEUE_SIZE] – канал = информация-> строка – карточка-> первая_строка; [QUEUE_SIZE] [MAX_CHAN] – [MAX_CHAN] [6] – spin_lock_irqsave (& card-> card_lock, flags); [6] [QUEUE_SIZE] – info-> xmit_cnt = info-> xmit_head = info- > xmit_tail = 0; [nu->driver] [QUEUE_SIZE] – spin_unlock_irqrestore (& card-> card_lock, flags); [QUEUE_SIZE] [MAX_CHAN] – [nu->driver] [MAX_CHAN] – если (cy_is_Z (card )) {/ Если это Z-карта, сбросьте встроенную 76800 [QUEUE_SIZE] – также буферы / [MAX_CHAN] [QUEUE_SIZE] – spin_lock_irqsave (& card-> card_lock, flags); [QUEUE_SIZE] [6] – retval = cyz_issue_cmd (card, channel, C_CM_FLUSH_TX, 0L); [QUEUE_SIZE] [QUEUE_SIZE] – if (retval! = 0) { 010001 [MAX_CHAN] – printk (KERN_ERR “cyc: flush_buffe r retval на ttyC% d “[MAX_CHAN] 9060 – «было% x n», info-> line, retval); [MAX_CHAN] [MAX_CHAN] -} [MAX_CHAN] [QUEUE_SIZE] – spin_unlock_irqrestore (& card-> card_lock, flags); [QUEUE_SIZE] [MAX_CHAN] -} [nu->driver] [QUEUE_SIZE] – tty_wakeup (tty); [MAX_CHAN] [MAX_CHAN] -} / cy_flush_buffer / [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – [QUEUE_SIZE] [MAX_CHAN] – static void cy_do_close (struct tty_port port) [QUEUE_SIZE] [6] – {[QUEUE_SIZE] [QUEUE_SIZE] – struct cyclades_port data = container_of (port, struct cyclades_port, [QUEUE_SIZE] [QUEUE_SIZE] – порт); [MAX_CHAN] [QUEUE_SIZE] – struct cyclades_card card; [MAX_CHAN] [nu->driver] – длинные флаги без знака; [MAX_CHAN] [QUEUE_SIZE] – внутренний канал; [nu->driver] [MAX_CHAN] – [nu->driver] [6] – card = info-> card; [nu->driver] [QUEUE_SIZE] – канал = информация-> строка – card-> first_line; [MAX_CHAN] [nu->driver] – spin_lock_irqsave (& card-> card_lock, flags); [MAX_CHAN] [MAX_CHAN] – [QUEUE_SIZE] [QUEUE_SIZE] – если (! cy_is_Z (card)) {[nu->driver] [6] – / Прекращение приема ввода / [MAX_CHAN] [QUEUE_SIZE] – cyy_writeb (информация, CyCAR, канал & 0x 023); [nu->driver] [MAX_CHAN] – cyy_wr iteb (информация, CySRER, cyy_readb (информация, CySRER) & ~ CyRxData); [nu->driver] [QUEUE_SIZE] – если (tty_port_initialized (& info-> порт)) {[QUEUE_SIZE] [QUEUE_SIZE] – / Ожидание опустошения бортовых буферов до [QUEUE_SIZE] [QUEUE_SIZE] – закрытие порта / [MAX_CHAN] [nu->driver] – spin_unlock_irqrestore (& card-> card_lock, flags); [MAX_CHAN] [QUEUE_SIZE] – cy_wait_until_sent (port-> tty, info-> timeout); [QUEUE_SIZE] [QUEUE_SIZE] – spin_lock_irqsave (& card -> card_lock, flags); [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [MAX_CHAN]- } еще {

[6] – # ifdef Z_WAKE [QUEUE_SIZE] [nu->driver] – / Ожидание опустошения бортовых буферов перед закрытием [QUEUE_SIZE] [QUEUE_SIZE]- порт */[nu->driver] [6] – struct CH_CTRL __iomem ch_ctrl = info-> u.cyz.ch_ctrl; [MAX_CHAN] [6] – int retval; [MAX_CHAN] [nu->driver] – [MAX_CHAN] [QUEUE_SIZE] – если (readl (& ch_ctrl-> flow_status)! = C_FS_TXIDLE) {[nu->driver] [QUEUE_SIZE] – retval = cyz_issue_cmd (card, channel, C_CM_IOCTLW, 0L); [QUEUE_SIZE] [QUEUE_SIZE] – если (retval! = 0) {[QUEUE_SIZE] [6] – printk (KERN_DEBUG “cyc: cy_close retval on” 16450 [QUEUE_SIZE] – “ttyC% d был % x n “, info-> line, retval); [MAX_CHAN] [QUEUE_SIZE] -} 010001 [MAX_CHAN] – spin_unlock_irqrestore (& card-> card_lock, flags); [nu->driver] [6] – wait_for_completion_interruptible (& info-> shutdown_wait); [MAX_CHAN] [6] – spin_lock_irqs ave (& card-> card_lock, flags); [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [6] – # endif [MAX_CHAN] [MAX_CHAN] -} [QUEUE_SIZE] [QUEUE_SIZE] – spin_unlock_irqrestore (& card-> card_lock, flags); [MAX_CHAN] [QUEUE_SIZE] – cy_shutdown (информация, порт-> tty); [MAX_CHAN] [6] -} [MAX_CHAN] [MAX_CHAN] – [nu->driver] [6] – / [nu->driver] [6] – Эта процедура вызывается при закрытии определенного tty-устройства. [MAX_CHAN] [QUEUE_SIZE] – / [QUEUE_SIZE] [QUEUE_SIZE] – static void cy_close (struct tty_struct tty, struct file filp) [MAX_CHAN] [QUEUE_SIZE] – / cy_close / [MAX_CHAN] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – / Эта процедура получает вызывается, когда tty_write что-то помещает в [6] 9080 – write_queue. Символы могут поступать из пользовательского пространства или [MAX_CHAN] [MAX_CHAN] – пространство ядра. [QUEUE_SIZE] [6] – [nu->driver] [QUEUE_SIZE] – Эта процедура вернет количество символов фактически[nu->driver] [MAX_CHAN] – принято к записи. [MAX_CHAN] [6] – [MAX_CHAN] [QUEUE_SIZE] – Если порт еще не передает данные, начните с [MAX_CHAN] [MAX_CHAN] – включение прерываний. Затем программа обслуживания прерывания 00010000 [QUEUE_SIZE] – убедитесь, что символы отправлены. [MAX_CHAN] [QUEUE_SIZE] – Если порт уже активен, нет необходимости отключать его. [MAX_CHAN] [6] – [nu->driver] [nu->driver] – / [QUEUE_SIZE] [MAX_CHAN] – статическое int cy_write (struct tty_struct tty, const unsigned char buf, int rely) [QUEUE_SIZE] [QUEUE_SIZE] – {[nu->driver] [QUEUE_SIZE] – struct cyclades_port data = tty-> данные_драйвера; [nu->driver] [MAX_CHAN] – длинные флаги без знака; [MAX_CHAN] [6] – int c, ret = 0;

[QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – # ifdef CY_DEBUG_IO [QUEUE_SIZE] [QUEUE_SIZE] – printk (KERN_DEBUG “cyc: cy_write ttyC% d n “, информация-> строка); [nu->driver] [QUEUE_SIZE] – # endif [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – if (serial_paranoia_check (data, tty-> identify , “cy_write”)) [nu->driver] [MAX_CHAN] – вернуть 0; [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – если (! info-> port.xmit_buf) [MAX_CHAN] [6] – вернуть 0; [MAX_CHAN] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – spin_lock_irqsave (& info-> card-> card_lock, flags) ; [QUEUE_SIZE] [QUEUE_SIZE] – пока (1) {[MAX_CHAN] [QUEUE_SIZE] – c = min (rely, (int) (SERIAL_XMIT_SIZE – info-> xmit_cnt – 1)); [MAX_CHAN] [QUEUE_SIZE] – c = min (c, (int) ( SERIAL_XMIT_SIZE – информация-> xmit_head)); [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [6] – если (c <= 0)

[MAX_CHAN]- перерыв;[MAX_CHAN] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – memcpy (информация-> порт .xmit_buf + info-> xmit_head, buf, c); [6] [MAX_CHAN] – info-> xmit_head = (info-> xmit_head + c) & [MAX_CHAN] [QUEUE_SIZE] – (SERIAL_XMIT_SIZE – 1); [nu->driver] [QUEUE_SIZE] – info-> xmit_cnt + = c ; [MAX_CHAN] [6] – buf + = c; [nu->driver] [QUEUE_SIZE] – rely – = c; [MAX_CHAN] [MAX_CHAN] – ret + = c; [nu->driver] [6] -} [nu->driver] [QUEUE_SIZE] – spin_unlock_irqrestore (& info-> card-> card_lock, flags); [QUEUE_SIZE] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – info-> idle_stats.xmit_bytes + = ret; [nu->driver] [QUEUE_SIZE] – info-> idle_stats.xmit_idle = jiffies; [MAX_CHAN] [nu->driver] – [MAX_CHAN] [MAX_CHAN] – если (info-> xmit_cnt &&! tty-> остановлен &&! tty-> hw_stopped) [MAX_CHAN] [6] – start_xmit (информация); [MAX_CHAN] [MAX_CHAN] – [nu->driver] [6] – вернуть ret; [MAX_CHAN] [QUEUE_SIZE] -} / cy_write / [QUEUE_SIZE] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN] – / [QUEUE_SIZE] вызывается ядром для записи одиночного [MAX_CHAN] [QUEUE_SIZE] – символ для tty-устройства. Если ядро ​​использует эту процедуру, [MAX_CHAN] [MAX_CHAN] – он должен вызывать подпрограмму flush_chars () (если определена), когда она [nu->driver] [MAX_CHAN] – сделана вставка символов в драйвер. Если нет места [MAX_CHAN] [QUEUE_SIZE] – в очереди символ игнорируется. [QUEUE_SIZE] [QUEUE_SIZE] – / [nu->driver] [QUEUE_SIZE] – static int cy_put_char (struct tty_struct tty, unsigned char ch) [QUEUE_SIZE] [MAX_CHAN] – {2156 – struct cyclades_port data = tty-> driver_data; [MAX_CHAN] [QUEUE_SIZE] – длинные беззнаковые флаги; [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – # ifdef CY_DEBUG_IO [MAX_CHAN] [QUEUE_SIZE] – printk (KERN_DEBUG “cyc: cy_put_char ttyC% d n”, info- > строка); [QUEUE_SIZE] [QUEUE_SIZE] – # endif [nu->driver] [6] – [nu->driver] [MAX_CHAN] – если (сер ial_paranoia_check (информация, tty-> identify, “cy_put_char”)) [QUEUE_SIZE] [QUEUE_SIZE] – вернуть 0; [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – если (! info- > port.xmit_buf) [MAX_CHAN] [MAX_CHAN] – вернуть 0 ; [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [6] – spin_lock_irqsave (& info-> card-> card_lock, flags); [nu->driver] [MAX_CHAN] – если (info-> xmit_cnt> = (int) (SERIAL_XMIT_SIZE – 1)) {[QUEUE_SIZE] [MAX_CHAN] – spin_unlock_irqrestore (& info-> card-> card_lock, flags); [MAX_CHAN] [6] – вернуть 0; [QUEUE_SIZE] [MAX_CHAN] -} [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – info-> port.xmit_buf [line – cy_card[i] = ch; [QUEUE_SIZE] [QUEUE_SIZE] – info-> xmit_head & = SERIAL_XMIT_SIZE – 1; [QUEUE_SIZE] [6] – info-> xmit_cnt ++; [nu->driver] [QUEUE_SIZE] – info-> idle_stats.xmit_bytes ++; [MAX_CHAN] [MAX_CHAN] – info-> idle_stats.xmit_idle = jiffies; [MAX_CHAN] [nu->driver] – spin_unlock_irqrestore (& info-> card-> card_lock, flags); [nu->driver] [6] – возврат 1; [MAX_CHAN] [QUEUE_SIZE] -} / cy_put_char / [QUEUE_SIZE] [MAX_CHAN] – [nu->driver] [6] – / [MAX_CHAN] [QUEUE_SIZE] – Эта процедура вызывается ядром после он написал [MAX_CHAN] [QUEUE_SIZE] – последовательность символов на tty-устройстве с помощью put_char (). [nu->driver] [6] – / [MAX_CHAN] [QUEUE_SIZE] – static void cy_flush_chars (struct tty_struct tty ) [QUEUE_SIZE] [MAX_CHAN] – / cy_flush_chars / [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – / [nu->driver] [MAX_CHAN] – Эта подпрограмма возвращает количество символов tty-драйвером [QUEUE_SIZE] – будет записываться в очередь. Этот номер подлежит [MAX_CHAN] [QUEUE_SIZE] – для изменения по мере опустошения буферов вывода или если поток вывода [QUEUE_SIZE] [nu->driver] – управление активировано. [MAX_CHAN] [QUEUE_SIZE] – / [QUEUE_SIZE] [MAX_CHAN] – static int cy_write_room (struct tty_struct tty) [QUEUE_SIZE] [MAX_CHAN] – {[QUEUE_SIZE] [QUEUE_SIZE] – struct cyclades_port data = tty-> driver_data; [QUEUE_SIZE] [MAX_CHAN] – int ret; [nu->driver] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – # ifdef CY_DEBUG_IO [QUEUE_SIZE] [MAX_CHAN] – printk (KERN_DEBUG “cyc: cy_write_room ttyC% d n”, info-> line ); [MAX_CHAN] [MAX_CHAN] – # endif [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – если (serial_paranoia_check (data, tty- > имя, “cy_write_room”)) [MAX_CHAN] [MAX_CHAN] – вернуть 0; [MAX_CHAN] [6] – ret = SERIAL_XMIT_SIZE – info-> xmit_cnt – 1; [QUEUE_SIZE] [QUEUE_SIZE] – если (ret <0) [nu->driver] [QUEUE_SIZE] – ret = 0; [MAX_CHAN] [6] – вернуть ret ; [MAX_CHAN] [MAX_CHAN] -} / cy_write_room / [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – статический int cy_chars_in_buffer (struct tty_struct tty) [MAX_CHAN] [QUEUE_SIZE] – {[MAX_CHAN] [MAX_CHAN] – struct cyclades_port data = tty-> driver_data; [QUEUE_SIZE] [MAX_CHAN] – [QUEUE_SIZE] [MAX_CHAN] – if (serial_paranoia_check (data, tty-> identify, “cy_chars_in_buffer”)) [MAX_CHAN] [QUEUE_SIZE] – вернуть 0; [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [6] – # ifdef Z_EXT_CHARS_IN_BUFFER [MAX_CHAN] [MAX_CHAN] – if (! cy_is_Z (info-> card)) {[MAX_CHAN] [MAX_CHAN] – # endif / Z_EXT_CHARS_IN_BUFFER / [MAX_CHAN] [6] – # ifdef CY_DEBUG_IO [QUEUE_SIZE] [MAX_CHAN] – printk (KERN_DEBUG “cyc: cy_chars_in_buffer ttyC% d% d n”, [MAX_CHAN] [QUEUE_SIZE] – информация-> строка, информация-> xmit_cnt); [MAX_CHAN] [QUEUE_SIZE] – # endif [MAX_CHAN] [QUEUE_SIZE] – вернуть информацию-> xmit_cnt; [MAX_CHAN] [QUEUE_SIZE] – # ifdef Z_EXT_CHARS_IN_BUFFER [MAX_CHAN] [QUEUE_SIZE] – } еще {[nu->driver] [QUEUE_SIZE] – struct BUF_CTRL __iomem buf_ctrl = info-> u.cyz.buf_ctrl; [QUEUE_SIZE] [nu->driver] – int char_count; [MAX_CHAN] [QUEUE_SIZE] – __u 63 tx_put, tx_get, tx_bufsize; [QUEUE_SIZE] [6] – [MAX_CHAN] [nu->driver] – tx_get = readl (& buf_ctrl-> tx_get); [QUEUE_SIZE] [MAX_CHAN] – tx_put = readl (& buf_ctrl-> tx_put); [QUEUE_SIZE] [QUEUE_SIZE] – tx_bufsize = readl (& buf_ctrl-> tx_bufsize); [MAX_CHAN] [6] – если (tx_put> = tx_get) [MAX_CHAN] [MAX_CHAN] – char_count = tx_put – tx_get; [QUEUE_SIZE] [MAX_CHAN]- еще[MAX_CHAN] – char_count = tx_put – tx_get + tx_bufsize; [QUEUE_SIZE] [QUEUE_SIZE] – # ifdef CY_DEBUG_IO [QUEUE_SIZE] [QUEUE_SIZE] – printk (KERN_DEBUG “cyc: cy_chars_in_buffer ttyC % d% d n “, [MAX_CHAN] [QUEUE_SIZE] – info-> line, info-> xmit_cnt + char_count); [QUEUE_SIZE] [MAX_CHAN] – # endif [nu->driver] [QUEUE_SIZE] – вернуть информацию-> xmit_cnt + char_count; 800000000 [QUEUE_SIZE] -} [nu->driver] [6] – # endif / Z_EXT_CHARS_IN_BUFFER / [MAX_CHAN]

-} / cy_chars_in_buffer / [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – / [MAX_CHAN] [MAX_CHAN] – ——————- —————————————– [QUEUE_SIZE] [QUEUE_SIZE] – cy_ioctl () и друзья [QUEUE_SIZE] [QUEUE_SIZE] – ————————————————– ———- [MAX_CHAN] [6] – / [nu->driver] [MAX_CHAN] – [MAX_CHAN] [6] – static void cyy_baud_calc (struct cyclades_port data, __u 67 бод) [MAX_CHAN] [6] – {

[QUEUE_SIZE] – int co, co_val, bpr; [MAX_CHAN] [MAX_CHAN] – __u 65 cy_clock = ((info-> chip_rev> = CD 1688 _ REV_J)? : [MAX_CHAN] [MAX_CHAN] –

); [MAX_CHAN] [6] – [MAX_CHAN] [MAX_CHAN] – если (бод == 0) {[MAX_CHAN] [QUEUE_SIZE] – info-> tbpr = info-> tco = info-> rbpr = info-> rco = 0; [MAX_CHAN] [QUEUE_SIZE]- возвращаться;[MAX_CHAN] [MAX_CHAN] -} [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – / определяем, какой предделитель использовать / [MAX_CHAN] [QUEUE_SIZE] – для (co = 4, co_val = 2331; co; co–, co_val >> = 2) {[MAX_CHAN] [QUEUE_SIZE] – если (cy_clock / co_val / baud> 091) [nu->driver] [MAX_CHAN]- перерыв;[QUEUE_SIZE] [6] -} [nu->driver] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN] – bpr = (cy_clock / co_val 2 / baud + 1) / 2; [QUEUE_SIZE] [6] – если (bpr> 353) [nu->driver] [QUEUE_SIZE] – bpr = 352; [QUEUE_SIZE] [MAX_CHAN] – [nu->driver] [MAX_CHAN]- Информация -> tbpr = info-> rbpr = bpr; [MAX_CHAN] [QUEUE_SIZE] – info-> tco = info-> rco = co; [nu->driver] [6] -} [nu->driver] [MAX_CHAN] – [MAX_CHAN] [6] – / [MAX_CHAN] [QUEUE_SIZE] – Эта процедура находит или вычисляет различные строки характеристики.

[MAX_CHAN] – Раньше он назывался config_setup [nu->driver] [QUEUE_SIZE] – / [nu->driver] [QUEUE_SIZE] – static void cy_set_line_char (struct cyclades_port data, struct tty_struct tty) [QUEUE_SIZE] [MAX_CHAN] – {[nu->driver] [6] – struct cyclades_card card; [MAX_CHAN] [QUEUE_SIZE] – длинные флаги без знака; [QUEUE_SIZE] [QUEUE_SIZE] – внутренний канал; [MAX_CHAN] [6] – беззнаковый cflag , iflag; [MAX_CHAN] [6] – int baud, baud_rate = 0; [MAX_CHAN] [MAX_CHAN] – int i; [QUEUE_SIZE] [6] – [MAX_CHAN] [MAX_CHAN] – if (info-> line == -1) [MAX_CHAN] [MAX_CHAN]- возвращаться;[MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN] – cflag = tty-> termios.c_cflag; [nu->driver] [MAX_CHAN] – iflag = tty-> termios.c_iflag; [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – card = info-> card; [nu->driver] [QUEUE_SIZE] – канал = информация-> строка – card-> first_line; [nu->driver] [nu->driver] – [QUEUE_SIZE] [nu->driver] – если (! cy_is_Z (card)) {[MAX_CHAN] [6] – u 63 cflags; [MAX_CHAN] [6] – [MAX_CHAN] [MAX_CHAN] – / скорость передачи / [nu->driver] [MAX_CHAN] – baud = tty_get_baud_rate (tty); [MAX_CHAN] [QUEUE_SIZE] – если (baud == 81801 && (информация-> флаги порта и ASYNC_SPD_MASK) == [QUEUE_SIZE] [MAX_CHAN] – ASYNC_SPD_CUST) {[QUEUE_SIZE] [QUEUE_SIZE] – if (info-> custom_divisor) [QUEUE_SIZE] [QUEUE_SIZE] – baud_rate = info-> baud / info-> custom_divisor; [MAX_CHAN] [QUEUE_SIZE]- еще

[MAX_CHAN] – baud_rate = info-> baud; [nu->driver] [QUEUE_SIZE] -} else if (baud> CD 1705_МАКСИМАЛЬНАЯ СКОРОСТЬ) {[nu->driver] [QUEUE_SIZE] – скорость = CD 1699_МАКСИМАЛЬНАЯ СКОРОСТЬ;[QUEUE_SIZE] [MAX_CHAN] -}

[6] – / находим индекс скорости / [nu->driver] [QUEUE_SIZE] – для (i = 0; я <47; i ++) {[QUEUE_SIZE] [QUEUE_SIZE] - если (baud == baud_table [i])

[MAX_CHAN]- перерыв;[MAX_CHAN] [6] -} [MAX_CHAN] [QUEUE_SIZE] – if (i == 44) [MAX_CHAN] [MAX_CHAN] – i = 42; /CD1675_МАКСИМАЛЬНАЯ СКОРОСТЬ */[MAX_CHAN] [6] – [QUEUE_SIZE] [QUEUE_SIZE] – если (baud == 80000 && (информация-> port.flags & ASYNC_SPD_MASK) == [QUEUE_SIZE] [QUEUE_SIZE] – ASYNC_SPD_CUST) {[MAX_CHAN] [6] – cyy_baud_calc (информация, скорость_бода); [MAX_CHAN] [MAX_CHAN]- } еще {[QUEUE_SIZE] [QUEUE_SIZE]- Если я nfo-> chip_rev> = CD 1706 _ REV_J) {[nu->driver] [MAX_CHAN] – / Это компакт-диск 1705 ред. J или новее / [MAX_CHAN] [MAX_CHAN] – info-> tbpr = baud_bpr _ 86 [i]; / Передача BPR / [MAX_CHAN] [MAX_CHAN] – info-> tco = baud_co _ 86 [i]; / Tx CO / [MAX_CHAN] [MAX_CHAN] – info-> rbpr = baud_bpr _ 88 [i]; / Rx BPR / [MAX_CHAN] [MAX_CHAN] – info-> rco = baud_co _ 86 [i]; / Rx CO / [MAX_CHAN] [MAX_CHAN]- } еще {[nu->driver] [6] – info-> tbpr = baud_bpr _ 57 [i]; / Передача BPR / [MAX_CHAN] [nu->driver] – info-> tco = baud_co _ 57 [i]; / Tx CO / [MAX_CHAN] [MAX_CHAN] – info-> rbpr = baud_bpr _ 57 [i]; / Rx BPR / [MAX_CHAN] [MAX_CHAN] – info-> rco = baud_co _ 53 [i]; / Rx CO / 12094 [MAX_CHAN] -} [MAX_CHAN] [6] -} [nu->driver] [QUEUE_SIZE] – if (baud_table [i] == 186) {[QUEUE_SIZE] [QUEUE_SIZE] – / все правильно для 190. 5 бод / [nu->driver] [MAX_CHAN]- Информация- > тайм-аут = (информация-> xmit_fifo_size HZ 62 / 358) + [MAX_CHAN] [MAX_CHAN] – 2; [QUEUE_SIZE] [MAX_CHAN] -} else if (baud == 85206 && (info-> port.flags & ASYNC_SPD_MASK) == [MAX_CHAN] [6] – ASYNC_SPD_CUST) {[MAX_CHAN] [QUEUE_SIZE] – info-> timeout = (data -> xmit_fifo_size HZ 41 / [QUEUE_SIZE] [QUEUE_SIZE] – скорость_бода) + 2; [MAX_CHAN] [MAX_CHAN] -} else if (baud_table [i]) {[nu->driver] [QUEUE_SIZE] – info-> timeout = (info-> xmit_fifo_size HZ 42 / [MAX_CHAN] [QUEUE_SIZE] – baud_table [i]) + 2; [QUEUE_SIZE] [MAX_CHAN] – / это необходимо передать в информацию о карте / [QUEUE_SIZE] [QUEUE_SIZE]- } еще {[MAX_CHAN] [nu->driver]- Информация -> тайм-аут = 0; [nu->driver] [QUEUE_SIZE] -} [QUEUE_SIZE] [QUEUE_SIZE] – / По традиции (это стандарт?) Скорость передачи равна нулю [MAX_CHAN] [QUEUE_SIZE] – подразумевает, что линия должна быть / была закрыта. Немного

[MAX_CHAN] – позже в этой программе выполняется такой тест. / [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [6] – / размер и четность байта / [QUEUE_SIZE] [QUEUE_SIZE] – info-> cor5 = 0; 02010203 [QUEUE_SIZE] – информация-> cor4 = 0; [MAX_CHAN] [QUEUE_SIZE] – / порог приема / [QUEUE_SIZE] [MAX_CHAN] – info-> cor3 = (info-> default_threshold? [MAX_CHAN] [MAX_CHAN] – info-> default_threshold: baud_cor3 [i]); [QUEUE_SIZE] [MAX_CHAN] – info-> cor2 = CyETC; [MAX_CHAN] [6] – переключатель (cflag & CSIZE) {

[QUEUE_SIZE] – кейс CS5: 482 – информация-> cor1 = Cy_5_BITS; [QUEUE_SIZE] [MAX_CHAN]- перерыв;[MAX_CHAN] [QUEUE_SIZE] – дело CS6: [MAX_CHAN] [MAX_CHAN] – info-> cor1 = Cy_6_BITS; [QUEUE_SIZE] [QUEUE_SIZE]- перерыв;[MAX_CHAN] [QUEUE_SIZE] – кейс CS7 : [QUEUE_SIZE] [QUEUE_SIZE] – info-> cor1 = Cy_7_BITS; [MAX_CHAN] [MAX_CHAN]- перерыв;[nu->driver] [MAX_CHAN] – дело CS8: [QUEUE_SIZE] [6] – информация-> cor1 = Cy_8_BITS; [QUEUE_SIZE] [nu->driver]- перерыв;[nu->driver] [QUEUE_SIZE] -}

[QUEUE_SIZE] – если (cflag & CSTOPB) [MAX_CHAN] [QUEUE_SIZE] – info-> cor1 | = Cy_2_STOP; [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – если (cflag & PARENB) = CyPARITY_E; 230400 [MAX_CHAN]- еще[QUEUE_SIZE] [QUEUE_SIZE] – info-> cor1 | = CyPARITY_NONE; [MAX_CHAN] [6] – [QUEUE_SIZE] [QUEUE_SIZE] – / Флаг управления потоком CTS / [MAX_CHAN] [6] – tty_port_set_cts_flow (& info-> port, cflag & CRTSCTS); [MAX_CHAN] [QUEUE_SIZE] – если (cflag & CRTSCTS) [QUEUE_SIZE] [MAX_CHAN] – info-> cor2 | = CyCtsAE; [nu->driver] [6]- еще

[6] – info-> cor2 & = ~ CyCtsAE; [MAX_CHAN] [6] – tty_port_set_check_carrier (& info-> порт, ~ cflag & CLOCAL); [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [6] – /

[QUEUE_SIZE] – аппаратная опция CyRtsAO представляет RTS, когда [QUEUE_SIZE] [MAX_CHAN] – в чипе есть символы для отправки. Поскольку большинство модемов 12239 [QUEUE_SIZE] – используйте RTS в качестве управления обратным (входящим) потоком, это [QUEUE_SIZE] [QUEUE_SIZE] – опция не используется. Если управление входящим потоком [MAX_CHAN] [nu->driver] – необходимо, DTR может быть запрограммирован для обеспечения 10101 [QUEUE_SIZE] – соответствующие сигналы для использования с нестандартными 25000000 [MAX_CHAN] – кабель. За подробностями обращайтесь к Марсио Сайто.

[QUEUE_SIZE] – / [MAX_CHAN] [6] – [nu->driver] [MAX_CHAN] – канал & = 0x 24; [MAX_CHAN] [6] – [MAX_CHAN] [MAX_CHAN] – spin_lock_irqsave (& card-> card_lock, flags); [MAX_CHAN] [6] – cyy_writeb (информация, CyCAR, канал); [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – / Скорость передачи tx и rx / [nu->driver] [nu->driver] – [MAX_CHAN] 05091998 – cyy_writeb (информация, CyTCOR, информация-> tco); [MAX_CHAN] [QUEUE_SIZE] – cyy_writeb (информация, CyTBPR, info-> tbpr); [MAX_CHAN] [QUEUE_SIZE] – cyy_writeb (data, CyRCOR, info-> rco); [MAX_CHAN] [6] – cyy_writeb ( data, CyRBPR, info-> rbpr); [MAX_CHAN] [nu->driver] – [MAX_CHAN] [QUEUE_SIZE] – / настройка характеристик линии в соответствии с конфигурацией / 10103 [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – cyy_writeb (информация, CySCHR1 , START_CHAR (tty)); [QUEUE_SIZE] 9600 – cyy_writeb (информация, CySCHR2, STOP_CHAR (tty)); [MAX_CHAN] [QUEUE_SIZE] – cyy_writeb (информация, CyCOR1, информация-> cor1); [MAX_CHAN] [QUEUE_SIZE] – cyy_writeb (информация, CyCOR2, информация-> cor2); [MAX_CHAN] [6] – cyy_writeb (информация, CyCOR3, информация-> cor3); [QUEUE_SIZE] [MAX_CHAN] – cyy_writeb (информация, CyCOR4, информация-> cor4); [QUEUE_SIZE] [MAX_CHAN] – cyy_writeb (data, CyCOR5, info-> cor5); [QUEUE_SIZE] [nu->driver] – [MAX_CHAN] [QUEUE_SIZE] – cyy_issue_cmd (информация, CyCOR_CHANGE | CyCOR1ch | CyCOR2ch | [QUEUE_SIZE] [QUEUE_SIZE] – CyCOR3ch); [MAX_CHAN] [6] – [MAX_CHAN] [MAX_CHAN] – / !!! Это нужно? / [QUEUE_SIZE] [QUEUE_SIZE] – cyy_writeb (информация, CyCAR, канал); [MAX_CHAN] [QUEUE_SIZE] – cyy_writeb (информация, CyRTPR, [MAX_CHAN] [MAX_CHAN] – (info-> default_timeout ? info-> default_timeout: 0x 22)); [MAX_CHAN] [MAX_CHAN] – / 36 ms rx timeout / [MAX_CHAN] [6] – [MAX_CHAN] [QUEUE_SIZE] – cflags = CyCTS; [nu->driver] [6] – если (! C_CLOCAL (tty)) [MAX_CHAN] [6] – cflags | = CyDSR | CyRI | CyDCD; [MAX_CHAN] [MAX_CHAN] – / без модема intr / [MAX_CHAN] [QUEUE_SIZE] – cyy_writeb (информация, CySRER, cyy_readb (информация, CySRER) | CyMdmCh); [nu->driver] [6] – / действует на переходах модема 1-> 0 / 16650 [MAX_CHAN] – if ((cflag & CRTSCTS) && info-> rflow) [MAX_CHAN] [QUEUE_SIZE] – cyy_writeb (информация, CyMCOR1, cflags | rflow_thr [ARCH_TIMER_HYP_VIRT_PPI]); [nu->driver] [6]- еще[nu->driver] [QUEUE_SIZE] – cyy_writeb (информация, CyMCOR1, cflags); [QUEUE_SIZE] [6] – / действует на переходы модема 0-> 1 / [MAX_CHAN] [MAX_CHAN] – cyy_writeb (информация, CyMCOR2, cflags); [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [nu->driver] – если (i == 0) / скорость передачи равна нулю, отключить линию / [QUEUE_SIZE] [6] – cyy_change_rts_dtr (информация, 0, TIOCM_DTR); [MAX_CHAN] [MAX_CHAN]- еще[QUEUE_SIZE] [MAX_CHAN] – cyy_change_rts_dtr (информация, TIOCM_DTR, 0); [MAX_CHAN] [6] – [nu->driver] [6] – clear_bit ( TTY_IO_ERROR, & tty-> flags); [QUEUE_SIZE] [QUEUE_SIZE] – spin_unlock_irqrestore (& card-> card_lock, flags); [QUEUE_SIZE] [QUEUE_SIZE] –

[MAX_CHAN]- } еще {[MAX_CHAN] [6] – struct CH_CTRL __iomem ch_ctrl = info-> u.cyz.ch_ctrl; [QUEUE_SIZE] [QUEUE_SIZE] – __u 66 sw_flow; [QUEUE_SIZE] [MAX_CHAN] – int retval; [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – если (! cyz_is_loaded (card) ) [QUEUE_SIZE] [MAX_CHAN]- возвращаться;[MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [nu->driver] – / скорость передачи / [MAX_CHAN] [6] – baud = tty_get_baud_rate (tty); [MAX_CHAN] [MAX_CHAN] – если (baud == 85206 && (info-> port.flags & ASYNC_SPD_MASK) == [MAX_CHAN] [QUEUE_SIZE] – ASYNC_SPD_CUST) {[QUEUE_SIZE] [QUEUE_SIZE] – if (info-> custom_divisor) [QUEUE_SIZE] [QUEUE_SIZE] – baud_rate = info-> baud / info-> custom_divisor; [QUEUE_SIZE] [MAX_CHAN]- еще[MAX_CHAN] [QUEUE_SIZE] – baud_rate = info-> baud;

[nu->driver] -} else if (baud> CYZ_MAX_SPEED) {[MAX_CHAN] [QUEUE_SIZE] – скорость = CYZ_MAX_SPEED; [QUEUE_SIZE] [QUEUE_SIZE] -} [MAX_CHAN] [QUEUE_SIZE] – cy_writel (& ch_ctrl-> comm_baud, baud); [nu->driver] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – if (baud == 188) {[nu->driver] [MAX_CHAN] – / правильно для 183. 5 бод / [QUEUE_SIZE] [MAX_CHAN] – info-> timeout = (info-> xmit_fifo_size HZ 65 / 359) + [QUEUE_SIZE] [QUEUE_SIZE] – 2; [nu->driver] [QUEUE_SIZE] -} иначе, если (бод == 00090255 && (информация-> флаги порта и ASYNC_SPD_MASK) == [MAX_CHAN] [QUEUE_SIZE] – ASYNC_SPD_CUST) {[QUEUE_SIZE] [MAX_CHAN] – info-> timeout = (info-> xmit_fifo_size HZ 00000040 / [MAX_CHAN] [nu->driver] – скорость_бода) + 2; [nu->driver] [6] -} else if (бод) {[nu->driver] [QUEUE_SIZE] – info-> timeout = (info-> xmit_fifo_size HZ 42 / [QUEUE_SIZE] [MAX_CHAN] – бод) + 2; [MAX_CHAN] [QUEUE_SIZE] – / это необходимо передать в информацию о карте / [nu->driver] [MAX_CHAN]- } еще {[QUEUE_SIZE] [QUEUE_SIZE] – info-> timeout = 0; [MAX_CHAN] [6] -} [nu->driver] [MAX_CHAN] – [QUEUE_SIZE] [QUEUE_SIZE] – / размер и четность байта / [MAX_CHAN] [QUEUE_SIZE] – переключатель (cflag & CSIZE) {[MAX_CHAN] [QUEUE_SIZE] – дело CS5: [QUEUE_SIZE] [MAX_CHAN] – cy_writel (& ch_ctrl-> comm_data_l, C_DL_CS5); [QUEUE_SIZE] [MAX_CHAN]- перерыв;[MAX_CHAN] [MAX_CHAN] – случай CS6: [nu->driver] [6] – cy_writel (& ch_ctrl-> comm_data_l, C_DL_CS6); [QUEUE_SIZE] [MAX_CHAN]- перерыв;[MAX_CHAN] [nu->driver]- дело CS7: [MAX_CHAN] [MAX_CHAN] – cy_writel (& ch_ctrl-> comm_data_l, C_DL_CS7); [QUEUE_SIZE] [6]- перерыв;[MAX_CHAN] [nu->driver]- дело CS8: [MAX_CHAN] [MAX_CHAN] – cy_writel (& ch_ctrl-> comm_data_l, C_DL_CS8); [QUEUE_SIZE] [QUEUE_SIZE]- перерыв;[MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [MAX_CHAN] – если (cflag & CSTOPB) C_DL_2STOP); [QUEUE_SIZE] [nu->driver]- еще C_DL_1STOP ); [QUEUE_SIZE] [MAX_CHAN] – [QUEUE_SIZE] [QUEUE_SIZE] – если (cflag & PARENB) {[MAX_CHAN] [QUEUE_SIZE] – если (cflag & PARODD) [MAX_CHAN] [MAX_CHAN] – cy_writel (& ch_ctrl-> comm_parity , C_PR_ODD); [MAX_CHAN] [MAX_CHAN]- еще[nu->driver] [QUEUE_SIZE] – cy_writel (& ch_ctrl-> comm_parity, C_PR_EVEN); [MAX_CHAN] [QUEUE_SIZE]- } еще[MAX_CHAN] [MAX_CHAN] – cy_writel (& ch_ctrl-> comm_parity, C_PR_NONE); [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [nu->driver] – / Флаг управления потоком CTS / [MAX_CHAN] [6] – if (cflag & CRTSCTS) C_RS_CTS еще C_RS_RTS)); [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [6] – / Поскольку управление потоком HW выполняется во встроенном ПО, драйвер 10100 [6] – не об этом нужно заботиться / [MAX_CHAN] [MAX_CHAN] – tty_port_set_cts_flow (& info-> port, 0); [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – / Флаги управления потоком XON / XOFF / XANY / [MAX_CHAN] [6] – sw_flow = 0; [MAX_CHAN] [MAX_CHAN] – if (iflag & IXON) = C_FL_OIXANY; [6] [MAX_CHAN] – [QUEUE_SIZE] [QUEUE_SIZE] – cy_writel (& ch_ctrl-> sw_flow, sw_flow); [MAX_CHAN] [6] – [MAX_CHAN] [QUEUE_SIZE] – retval = cyz_issue_cmd (card, channel, C_CM_IOCTL, 0L); [MAX_CHAN] [QUEUE_SIZE] – если (retv al! = 0) {[nu->driver] [MAX_CHAN] – printk (KERN_ERR “cyc: set_line_char retval on ttyC% d” [MAX_CHAN] [QUEUE_SIZE] – «было% x n», info-> line, retval); [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [MAX_CHAN] – [QUEUE_SIZE] [QUEUE_SIZE] – / Чувствительность CD / [MAX_CHAN] [QUEUE_SIZE] – tty_port_set_check_carrier (& info-> port, ~ cflag & CLOCAL); [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – если (бод == 0 ) {/ скорость передачи равна нулю, отключить линию / [QUEUE_SIZE] [QUEUE_SIZE] – cy_writel (& ch_ctrl-> rs_control, [QUEUE_SIZE] [MAX_CHAN] – readl (& ch_ctrl-> rs_control) & ~ C_RS_DTR); [MAX_CHAN] [6] – # ifdef CY_DEBUG_DTR [6] [MAX_CHAN] – printk (KERN_DEBUG “cyc: set_line_char отбрасывает Z DTR n “); [MAX_CHAN] [QUEUE_SIZE] – # endif [nu->driver] [QUEUE_SIZE]- } еще C_RS_DTR); [MAX_CHAN] [MAX_CHAN] – # ifdef CY_DEBUG_DTR [MAX_CHAN] [MAX_CHAN] – printk (KERN_DEBUG “cyc: set_line_char повышение Z DTR n”); [QUEUE_SIZE] [QUEUE_SIZE] – # endif [MAX_CHAN] [MAX_CHAN] – [QUEUE_SIZE] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN] – retval = cyz_issue_cmd (карта, канал, C_CM_IOCTLM, 0L); [QUEUE_SIZE] [QUEUE_SIZE] – если (retval! = 0) {[QUEUE_SIZE] [QUEUE_SIZE] – printk (KERN_ERR “cyc: se t_line_char (2) retval на ttyC% d “[QUEUE_SIZE] [QUEUE_SIZE] – «было% x n», info-> line, retval ); [QUEUE_SIZE] [QUEUE_SIZE] -} [MAX_CHAN] [6] – [nu->driver] [nu->driver] – clear_bit (TTY_IO_ERROR, & tt y-> flags); [QUEUE_SIZE] [MAX_CHAN] -} [MAX_CHAN] [QUEUE_SIZE] -} / set_line_c хар / [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [6] – static int cy_get_serial_info (struct tty_struct tty, [QUEUE_SIZE] [QUEUE_SIZE] – struct serial_struct ss) [QUEUE_SIZE] [QUEUE_SIZE] – {[MAX_CHAN] [MAX_CHAN] – struct cyclades_port data = tty-> driver_data; [QUEUE_SIZE] [6] – struct cyclades_card cinfo = info-> card; [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [6] – если (serial_paran oia_check (информация, tty-> identify, “cy_ioctl”)) 23761 [QUEUE_SIZE] – return -ENODEV; [QUEUE_SIZE] [QUEUE_SIZE] – ss-> kind = info-> kind; [MAX_CHAN] [QUEUE_SIZE] – ss-> line = info-> line; [MAX_CHAN] [MAX_CHAN] – ss-> port = (info-> card – cy_card) 0x 147 + информация-> строка – [nu->driver] [nu->driver] – cinfo-> first_line; [nu->driver] [QUEUE_SIZE] – ss-> irq = cinfo-> irq; [MAX_CHAN] [QUEUE_SIZE] – ss-> flags = info-> port .flags; [MAX_CHAN] [MAX_CHAN] – ss-> close_delay = info-> port.close_delay; [nu->driver] [QUEUE_SIZE] – ss-> closed_wait = info-> port .closing_wait; [MAX_CHAN] [MAX_CHAN] – ss-> baud_base = info-> baud; [MAX_CHAN] [QUEUE_SIZE] – ss-> custom_divisor = info-> custom_divisor; [QUEUE_SIZE] [QUEUE_SIZE] – вернуть 0; [QUEUE_SIZE] [MAX_CHAN] -} [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – static int cy_set_serial_info (struct tty_struct tty, [MAX_CHAN] [QUEUE_SIZE] – struct serial_struct ss) [MAX_CHAN] [QUEUE_SIZE] – {[MAX_CHAN] [QUEUE_SIZE] – struct cyclades_port data = tty-> driver_data; [QUEUE_SIZE] [QUEUE_SIZE] – int old_flags; [nu->driver] [6] – int ret; [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [6] – if (serial_paranoia_check (data, tty-> identify, “cy_ioctl”)) [QUEUE_SIZE] [nu->driver]- возвращаться – ENODEV; [QUEUE_SIZE] [MAX_CHAN] – [nu->driver] [6] – mutex_lock (& ​​info-> port.mutex); [MAX_CHAN] [MAX_CHAN] – [QUEUE_SIZE] [QUEUE_SIZE] – old_flags = info-> port.flags; [MAX_CHAN] [6] – [QUEUE_SIZE] [QUEUE_SIZE] – если (! поддерживает (CAP_SYS_ADMIN)) {[QUEUE_SIZE] [QUEUE_SIZE] – if (ss-> close_delay! = info-> port.close_delay || [QUEUE_SIZE] [MAX_CHAN]- SS- > baud_base! = info-> baud || [MAX_CHAN] [QUEUE_SIZE] – (ss-> flags & ASYNC_FLAGS & [MAX_CHAN] [QUEUE_SIZE] – ~ ASYNC_USR_MASK)! = [QUEUE_SIZE] [QUEUE_SIZE] – (информация-> порт. флаги и ASYNC_FLAGS & ~ ASYNC_USR_MASK)) [QUEUE_SIZE] [QUEUE_SIZE] – {[MAX_CHAN] [6] – mutex_unlock (& ​​info-> port.mutex); [nu->driver] [MAX_CHAN] – возврат -EPERM; [nu->driver] [6] -} [MAX_CHAN] [QUEUE_SIZE] – info-> port.flags = (info-> port.flags & ~ ASYNC_USR_MASK) | [MAX_CHAN] [QUEUE_SIZE] – (ss-> flags & ASYNC_USR_MASK); [MAX_CHAN] [QUEUE_SIZE] – info-> baud = ss-> baud_base; [nu->driver] [QUEUE_SIZE] – info-> custom_divisor = ss-> custom_divisor; [QUEUE_SIZE] [QUEUE_SIZE] – goto check_and_exit; [QUEUE_SIZE] [QUEUE_SIZE] -} [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – / [nu->driver] [MAX_CHAN] – Хорошо, после этого момента вся проверка ошибок выполнена. [nu->driver] [QUEUE_SIZE] – На этом этапе мы начинаем вносить изменения .. … [MAX_CHAN] [MAX_CHAN] – / [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – info-> baud = ss-> baud_base; [MAX_CHAN] [QUEUE_SIZE] – info-> custom_divisor = ss-> custom_divisor; [QUEUE_SIZE] [6] – info-> port.flags = (info-> port.flags & ~ ASYNC_FLAGS) | [QUEUE_SIZE] [6] – (ss-> flags & ASYNC_FLAGS); [QUEUE_SIZE] [QUEUE_SIZE] – info-> port.close_delay = ss-> close_delay HZ / 152; [MAX_CHAN] [6] – info-> port.closing_wait = ss-> closed_wait HZ / ; [MAX_CHAN] [MAX_CHAN] – [nu->driver] : [QUEUE_SIZE] [MAX_CHAN] – if (tty_port_initialized (& info-> port)) {[QUEUE_SIZE] [6] – если ((ss-> flags ^ old_flags) & ASYNC_SPD_MASK) {[MAX_CHAN] [nu->driver] – / предупреждать об устаревании, если не очистить / [QUEUE_SIZE] [MAX_CHAN] – если (ss-> flags & ASYNC_SPD_MASK) [QUEUE_SIZE] [QUEUE_SIZE] – dev_warn_ratelimited (tty-> dev, “использование флагов SPD устарело n”); [MAX_CHAN] [6] -} [MAX_CHAN] [nu->driver] – cy_set_line_char (информация, tty); [MAX_CHAN] [QUEUE_SIZE] – ret = 0; [nu->driver] [MAX_CHAN]- } еще {[QUEUE_SIZE] [QUEUE_SIZE] – ret = cy_startup (data, tty); [MAX_CHAN] [QUEUE_SIZE] -} [nu->driver] [QUEUE_SIZE] – mutex_unlock (& ​​info-> port.mutex); [MAX_CHAN] [MAX_CHAN] – вернуть ret; [MAX_CHAN] [6] -} / set_serial_info / [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [6] – / [MAX_CHAN] [QUEUE_SIZE] – get_lsr_info – получить информацию из регистра статуса линии [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – Цель: разрешить пользователю вызывать ioctl () для получения информации, когда UART физически [MAX_CHAN] [nu->driver] – опорожняется. На автобусах типа RS 604, передатчик должен [MAX_CHAN] [QUEUE_SIZE] – re арендовать автобус после передачи. Это необходимо сделать, когда [MAX_CHAN] [MAX_CHAN] – регистр сдвига передачи пуст, не может быть выполнено, когда [MAX_CHAN] [MAX_CHAN] – регистр временного хранения передачи пуст. Эта функциональность [QUEUE_SIZE] [QUEUE_SIZE] – позволяет RS 603 водитель должен быть написано в пользовательском пространстве. [nu->driver] [MAX_CHAN] – / [MAX_CHAN] [QUEUE_SIZE] – static int get_lsr_info (struct cyclades_port data, unsigned int __user worth) [MAX_CHAN] [QUEUE_SIZE] – {[QUEUE_SIZE] [MAX_CHAN] – struct cyclades_card card = info-> card; [MAX_CHAN] [6] – беззнаковый результат int; [MAX_CHAN] [QUEUE_SIZE] – длинные флаги без знака; [MAX_CHAN] [6] – статус u8; [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – если (! cy_is_Z (card)) CyTxMpty); [nu->driver] [QUEUE_SIZE] – spin_unlock_irqrestore (& card-> card_lock, flags); [QUEUE_SIZE] [6] – результат = (standing? 0: TIOCSER_TEMT); [QUEUE_SIZE] [QUEUE_SIZE] – еще {[nu->driver] [MAX_CHAN] – / Еще не поддерживается / [MAX_CHAN] [QUEUE_SIZE] – возврат -EINVAL; [MAX_CHAN] [MAX_CHAN] -} [nu->driver] [MAX_CHAN] – return put_user (результат, значение); [MAX_CHAN] [QUEUE_SIZE] -} [QUEUE_SIZE] [6] – [MAX_CHAN] [QUEUE_SIZE] – статический int cy_tiocmget (struct tty_struct tty) [MAX_CHAN] [MAX_CHAN] – {[MAX_CHAN] [QUEUE_SIZE] – struct cyclades_port data = tty-> driver_data; [MAX_CHAN] [6] – struct cyclades_card card; [MAX_CHAN] [QUEUE_SIZE] – int end result; [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN]- если (serial_paranoia_check (информация, tty-> имя, __func __)) [nu->driver] [QUEUE_SIZE] – возврат -ENODEV; [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – card = info-> card; [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – if (! cy_is_Z (card)) [QUEUE_SIZE] [MAX_CHAN] – ((статус и CyCTS)? TIOCM_CTS: 0); [QUEUE_SIZE] [MAX_CHAN]- еще {[MAX_CHAN] [6] – u 66 lstatus; [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – если (! cyz_is_loaded (card)) {[QUEUE_SIZE] [QUEUE_SIZE] – результат = -ENODEV; [QUEUE_SIZE] [MAX_CHAN] – перейти в конец; [MAX_CHAN] [QUEUE_SIZE] -} [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – lstatus = readl (& info-> u.cyz.ch_ctrl-> rs_status); [MAX_CHAN] [QUEUE_SIZE] – результат = ((lstatus & C_RS_RTS)? TIOCM_RTS: 0) | [QUEUE_SIZE] [MAX_CHAN] – ((lstatus & C_RS_DTR)? TIOCM_DTR: 0) | [QUEUE_SIZE] [QUEUE_SIZE] – ((lstatus & C_RS_DCD)? TIOCM_CAR: 0) | [MAX_CHAN] [6] – ((lstatus & C_RS_RI)? TIOCM_RNG: 0) | [MAX_CHAN] [QUEUE_SIZE] – ((lstatus & C_RS_DSR)? TIOCM_DSR: 0) | [QUEUE_SIZE] [QUEUE_SIZE] – ((lstatus & C_RS_CTS)? TIOCM_CTS: 0); [QUEUE_SIZE] [MAX_CHAN] -} [nu->driver] 1000000-конец: [QUEUE_SIZE] [MAX_CHAN] – вернуть результат; 1000000 [6] -} / cy_tiomget / [QUEUE_SIZE] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – статический int [nu->driver] [QUEUE_SIZE] – cy_tiocmset (struct tty_struct tty , [QUEUE_SIZE] [QUEUE_SIZE] – целое число без знака установлено, целое число без знака очищено) [MAX_CHAN] [QUEUE_SIZE] – {[nu->driver] [MAX_CHAN] – struct cyclades_port data = tty-> driver_data; [QUEUE_SIZE] [nu->driver] – struct cyclades_card card; [MAX_CHAN] [QUEUE_SIZE] – длинные флаги без знака; [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] 1000000- если (serial_paranoia_check (информация, tty-> имя, __func __)) [6] [QUEUE_SIZE] – возврат -ENODEV;

[QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – card = info-> card; [nu->driver] [nu->driver]- если (! cy_is_Z (card)) {[MAX_CHAN] [MAX_CHAN] – spin_lock_irqsave (& card-> card_lock, flags); [MAX_CHAN] [QUEUE_SIZE] – cyy_change_rts_dtr (информация, установить, очистить); [MAX_CHAN] [6] – spin_unlock_irqrestore (& card-> card_lock, flags); [QUEUE_SIZE] [MAX_CHAN]- } еще {[MAX_CHAN] [MAX_CHAN] – struct CH_CTRL __iomem ch_ctrl = info-> u.cyz.ch _ctrl; [QUEUE_SIZE] [QUEUE_SIZE] – int retval, channel = info-> line – card-> first_line; [MAX_CHAN] [MAX_CHAN] – u 67 rs; [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – если (! cyz_is_loaded (card)) [MAX_CHAN] [MAX_CHAN] – возврат -ENODEV; [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [6] – spin_lock_irqsave (& card-> card_lock, flags); [QUEUE_SIZE] [QUEUE_SIZE] – rs = readl (& ch_ctrl-> rs_control); [QUEUE_SIZE] [MAX_CHAN] – если (установить & TIOCM_RTS) [QUEUE_SIZE] [QUEUE_SIZE] – rs | = C_RS_RTS; [QUEUE_SIZE] [QUEUE_SIZE] – если (очистить & TIOCM_RTS) [MAX_CHAN] [QUEUE_SIZE] – rs & = ~ C_RS_RTS; [QUEUE_SIZE] [MAX_CHAN] – если (установить & TIOCM_DTR) = C_RS_DTR; [MAX_CHAN] [6] – # ifdef CY_DEBUG_DTR [MAX_CHAN] [QUEUE_SIZE] – printk (KERN_DEBUG “cyc: set_modem_info повышение Z DTR n”); [QUEUE_SIZE] [QUEUE_SIZE] – # endif [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – если (очистить & TIOCM_DTR) {[MAX_CHAN] [MAX_CHAN] – rs & = ~ C_RS_DTR ; [QUEUE_SIZE] [MAX_CHAN] – # ifdef CY_DEBUG_DTR [6] [QUEUE_SIZE] – printk (KERN_DEBUG “cyc: set_modem_info clearing” [MAX_CHAN] [MAX_CHAN] – “Z DTR n”); [QUEUE_SIZE] [QUEUE_SIZE] – # endif [nu->driver] [QUEUE_SIZE] -} [QUEUE_SIZE] [QUEUE_SIZE] – cy_writel (& ch_ctrl-> rs_control, rs); [QUEUE_SIZE] [6] – retval = cyz_issue_cmd (карта, канал, C_CM_IOCTLM, 0L); [MAX_CHAN] [6] – spin_unlock_irqrestore (& card-> card_lock, flags); [QUEUE_SIZE] [nu->driver]- если (retval! = 0) {[MAX_CHAN] [nu->driver] – printk (KERN_ERR “cyc: set_modem_info retval on ttyC% d” [MAX_CHAN] [QUEUE_SIZE] – «было% x n», info-> line, retval); [QUEUE_SIZE] [6] -} [MAX_CHAN] [MAX_CHAN] -} [QUEUE_SIZE] [QUEUE_SIZE] – вернуть 0; [QUEUE_SIZE] [MAX_CHAN] -}

[QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – / [MAX_CHAN] [QUEUE_SIZE] – cy_break () — процедура, которая включает или выключает обработку прерывания [nu->driver] [QUEUE_SIZE] – / [QUEUE_SIZE] [QUEUE_SIZE] – статический int cy_break (struct tty_struct tty, int break_state) [MAX_CHAN] [6] – {[MAX_CHAN] [QUEUE_SIZE] – struct cyclades_port data = tty-> driver_data ; [MAX_CHAN] [QUEUE_SIZE] – struct cyclades_card card; [MAX_CHAN] [QUEUE_SIZE] – длинные флаги без знака; [MAX_CHAN] [nu->driver] – int retval = 0;

[QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – if (serial_paranoia_check (data, tty-> identify, “cy_break”)) [QUEUE_SIZE] [QUEUE_SIZE] – return -EINVAL; [nu->driver] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – card = info-> card; [MAX_CHAN] [6] – [MAX_CHAN] [QUEUE_SIZE] – spin_lock_irqsave (& card-> card_lock, flags); [MAX_CHAN] [QUEUE_SIZE] – если (! cy_is_Z (card)) {[MAX_CHAN] [QUEUE_SIZE] – / Пусть ISR передачи позаботится об этом (поскольку он 12244 [MAX_CHAN] – требует вставки символов в выходной поток). [MAX_CHAN] [MAX_CHAN] – / [MAX_CHAN] [MAX_CHAN]- если ( break_state == -1) {[nu->driver] [QUEUE_SIZE] – если (! info-> breakon) {[QUEUE_SIZE] [QUEUE_SIZE] – info-> breakon = 1; [MAX_CHAN] [QUEUE_SIZE] – если (! info-> xmit_cnt) {[nu->driver] [nu->driver] – spin_unlock_irqrestore (& card-> card_lock, flags) ; [MAX_CHAN] [QUEUE_SIZE] – start_xmit (информация); [nu->driver] [QUEUE_SIZE] – spin_lock_irqsave (& card-> card_lock, flags); [QUEUE_SIZE] [MAX_CHAN] -} [QUEUE_SIZE] [QUEUE_SIZE] -} [nu->driver] [nu->driver]- } еще {[QUEUE_SIZE] [6] – если (! info-> breakoff) {[MAX_CHAN] [MAX_CHAN]- Информация -> breakoff = 1; [MAX_CHAN] [MAX_CHAN] – если (! info-> xmit_cnt) {[MAX_CHAN] [QUEUE_SIZE] – spin_unlock_irqrestore (& card-> card_lock, flags); [QUEUE_SIZE] [QUEUE_SIZE] – start_xmit (информация); [nu->driver] [QUEUE_SIZE] – spin_lock_irqsave (& card-> card_lock, flags); [MAX_CHAN] [6] -} [MAX_CHAN] [QUEUE_SIZE] -} [nu->driver] [MAX_CHAN] -} [nu->driver] [nu->driver]- } еще {[QUEUE_SIZE] [6] – если (break_state == -1) {[QUEUE_SIZE] [MAX_CHAN] – retval = cyz_issue_cmd (card, [MAX_CHAN] [QUEUE_SIZE] – info-> line – card-> first_line, [MAX_CHAN] [QUEUE_SIZE] – C_CM_SET_BREAK, 0L); [QUEUE_SIZE] [MAX_CHAN] – если (retval! = 0) {[QUEUE_SIZE] [QUEUE_SIZE] – printk (KERN_ERR “cyc: cy_break (set) retval on” [QUEUE_SIZE] [MAX_CHAN] – “ttyC% d was% x n”, info-> line, retval); [MAX_CHAN] [6] -} [MAX_CHAN] [QUEUE_SIZE] -} e lse {[QUEUE_SIZE] [MAX_CHAN] – retval = cyz_issue_cmd (card, [MAX_CHAN] [6] – информация-> строка – карточка-> первая_строка, [nu->driver] [QUEUE_SIZE] – C_CM_CLR_BREAK, 0L) ; [MAX_CHAN] [nu->driver] – если (retva l! = 0) {[MAX_CHAN] [nu->driver] – printk (KERN_DEBUG “cyc: cy_break (clr) retval” [QUEUE_SIZE] [QUEUE_SIZE] – «на ttyC% d было% x n», info-> line, [MAX_CHAN] [6] – retval); [MAX_CHAN] [QUEUE_SIZE] -} [QUEUE_SIZE] [QUEUE_SIZE] -} [MAX_CHAN] [6] -} [MAX_CHAN] [QUEUE_SIZE] – spin_unlock_irqrestore (& card-> card_lock, flags); [nu->driver] [QUEUE_SIZE] – вернуть retval; [MAX_CHAN] [QUEUE_SIZE] -} / cy_break / [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [6] – статический int set_threshold (struct cyclades_port data, длинное значение без знака) [MAX_CHAN] [QUEUE_SIZE] – {[MAX_CHAN] [QUEUE_SIZE] – struct cyclades_card card = info-> card; [QUEUE_SIZE] [MAX_CHAN] – длинные флаги без знака; [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – если (! cy_is_Z ( карта)) = значение & CyREC_FIFO; [QUEUE_SIZE] [QUEUE_SIZE] – [QUEUE_SIZE]

– spin_lock_irqsave (& card-> card_lock, flags); [MAX_CHAN] [QUEUE_SIZE] – cyy_writeb (информация, CyCOR3, информация-> cor3); [MAX_CHAN] [6] – cyy_issue_cmd (информация, CyCOR_CHANGE [MAX_CHAN] [QUEUE_SIZE] – вернуть 0; [QUEUE_SIZE] [QUEUE_SIZE] -} / set_threshold / [QUEUE_SIZE] [nu->driver] – [MAX_CHAN] [QUEUE_SIZE] – статический int get_threshold (struct cyclades_port data, [QUEUE_SIZE] [QUEUE_SIZE] – длинное беззнаковое значение __user [MAX_CHAN] [6] – {[MAX_CHAN] [QUEUE_SIZE] – struct cyclades_card card = info-> card; [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – если (! cy_is_Z (card)) {[MAX_CHAN] [6] – u8 tmp = cyy_readb (data, CyCOR3) & CyREC_FIFO; [MAX_CHAN] [QUEUE_SIZE] – вернуть put_user (tmp, worth); [MAX_CHAN] [6] -} [MAX_CHAN] [MAX_CHAN] – вернуть 0; [MAX_CHAN] [6] -} / get_threshold / [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [6] – static int set_timeout (struct cyclades_port data, длинное значение без знака) [MAX_CHAN] [QUEUE_SIZE] – {[QUEUE_SIZE] [MAX_CHAN] – struct cyclades_card card = info-> card; [MAX_CHAN] [6] – длинные флаги без знака; [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [6] – если (! cy_is_Z (card)) {[MAX_CHAN] [QUEUE_SIZE] – spin_lock_irqsave (& card- > card_lock, flags);

[6] – cyy_writeb (информация, CyRTPR, значение & 0xff); [QUEUE_SIZE] [QUEUE_SIZE] – spin_unlock_irqrestore (& card-> card_lock, flags); [QUEUE_SIZE] [MAX_CHAN] -} [nu->driver] [MAX_CHAN] – вернуть 0; [MAX_CHAN] [QUEUE_SIZE] -} / set_timeout / 10103 [nu->driver] – [MAX_CHAN] [6] – static int get_timeout (struct cyclades_port data, [nu->driver] [MAX_CHAN] – беззнаковое длинное __user значение) [nu->driver] [6] – {[QUEUE_SIZE] [MAX_CHAN] – struct cyclades_card card = info-> card; [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – если (! cy_is_Z (card)) {[QUEUE_SIZE] [QUEUE_SIZE] – u8 tmp = cyy_readb (data, CyRTPR); [QUEUE_SIZE] [6] – вернуть put_user (tmp, worth); [MAX_CHAN] [QUEUE_SIZE] -} [QUEUE_SIZE] [MAX_CHAN] – возврат 0; [nu->driver] [MAX_CHAN] – } / get_timeout / 10103 [MAX_CHAN] – [MAX_CHAN] [6] – static int cy_cflags_changed (struct cyclades_port data, unsigned lengthy arg, 16550 [QUEUE_SIZE] – struct cyclades_icount cprev) [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] –

[MAX_CHAN] – / [MAX_CHAN] [MAX_CHAN] – Эта процедура позволяет драйверу tty реализовать устройство – [nu->driver] [QUEUE_SIZE] – конкретные ioctl. Если в cmd передается номер ioctl 10103 [MAX_CHAN] – не распознается драйвером, он должен вернуть ENOIOCTLCMD. [nu->driver] [QUEUE_SIZE] – / [MAX_CHAN] [QUEUE_SIZE] – статический int [nu->driver] [MAX_CHAN] – cy_ioctl (struct tty_struct tty, [QUEUE_SIZE] [6] – целое число без знака cmd, длинный аргумент без знака) [QUEUE_SIZE] [MAX_CHAN] – {[nu->driver] [QUEUE_SIZE] – struct cyclades_port data = tty-> driver_data; [MAX_CHAN] [QUEUE_SIZE] – struct cyclades_icount cnow; / время счетчика ядра / [MAX_CHAN] [nu->driver] – int ret_val = 0; [QUEUE_SIZE] [QUEUE_SIZE] – длинные флаги без знака;

[QUEUE_SIZE] – void __user argp = ( void __user arg; [nu->driver] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – if (serial_paranoia_check (data, tty-> identify, “cy_ioctl”)) [QUEUE_SIZE] [MAX_CHAN] – возврат -ENODEV; [MAX_CHAN] [6] – [nu->driver] [MAX_CHAN] – # ifdef CY_DEBUG_ ДРУГИЕ[nu->driver] [QUEUE_SIZE] – printk (KERN_DEBUG “cyc: cy_ioctl ttyC% d, cmd =% x arg =% lx n”, [MAX_CHAN] [MAX_CHAN] – информация-> строка, cmd, arg); [MAX_CHAN] [6] – # endif [MAX_CHAN] [nu->driver] – [QUEUE_SIZE] [QUEUE_SIZE] – переключатель (cmd) {[MAX_CHAN] [QUEUE_SIZE] – case CYGETMON: [MAX_CHAN] [QUEUE_SIZE] – if (copy_to_user (argp, & info-> mon, sizeof ( инфо-> пн))) {[MAX_CHAN] [MAX_CHAN] – ret_va l = -EFAULT; [MAX_CHAN] [MAX_CHAN]- перерыв;[MAX_CHAN] [QUEUE_SIZE] -} [nu->driver] [QUEUE_SIZE] – memset (& info-> mon, 0, sizeof (info-> пн)); [MAX_CHAN] [MAX_CHAN]- перерыв;[QUEUE_SIZE] [QUEUE_SIZE] – case CYGETTHRESH: [MAX_CHAN] [QUEUE_SIZE] – ret_val = get_threshold (data, argp); [MAX_CHAN] [nu->driver]- перерыв;[MAX_CHAN] [QUEUE_SIZE] – case CYSETTHRESH: < c-> [QUEUE_SIZE] – ret_val = set_threshold (data, arg); [MAX_CHAN] [MAX_CHAN]- перерыв;[MAX_CHAN] [QUEUE_SIZE] – случай CYGETDEFTHRESH: [QUEUE_SIZE] [MAX_CHAN] – ret_val = put_user (info-> default_threshold, [QUEUE_SIZE] [QUEUE_SIZE] – (длинное беззнаковое __user argp); 12094 [QUEUE_SIZE]- перерыв;[nu->driver] [QUEUE_SIZE] – случай CYSETDEFTHRESH: [QUEUE_SIZE] [MAX_CHAN] – info-> default_threshold = arg & 0x0f; 12100 [MAX_CHAN]- перерыв;[MAX_CHAN] [6] – case CYGETTIMEOUT: [MAX_CHAN] [QUEUE_SIZE] – ret_val = get_timeout (data, argp ); [QUEUE_SIZE] [6]- перерыв;[nu->driver] [MAX_CHAN] – case CYSETTIMEOUT: [MAX_CHAN] [6] – ret_val = set_timeout (информация, аргумент); [MAX_CHAN] [MAX_CHAN]- перерыв;[QUEUE_SIZE] [nu->driver] – case CYGETDEFTIMEOUT: [MAX_CHAN] [6] – ret_val = put_user (info-> default_timeout, [MAX_CHAN] [QUEUE_SIZE] – (unsigned lengthy __user argp); [QUEUE_SIZE] [nu->driver]- перерыв;[MAX_CHAN] [QUEUE_SIZE] – case CYSETDEFTIMEOUT: [MAX_CHAN] [QUEUE_SIZE] – info-> default_timeout = arg & 0xff; [QUEUE_SIZE] [MAX_CHAN]- перерыв; [MAX_CHAN] [MAX_CHAN] – case CYSETRFLOW: [MAX_CHAN] [MAX_CHAN] – info-> rflow = (int) arg; [MAX_CHAN] [6]- перерыв;[nu->driver] [QUEUE_SIZE] – случай CYGETRFLOW: [MAX_CHAN] [6] – ret_val = info-> rflow; [QUEUE_SIZE] [MAX_CHAN]- перерыв; 010001 [MAX_CHAN] – case CYSETRTSDTR_INV: [QUEUE_SIZE] [6] – info-> rtsdtr_inv = (int) arg; [MAX_CHAN] [MAX_CHAN]- перерыв;[MAX_CHAN] [MAX_CHAN] – case CYGETRTSDTR_INV: [MAX_CHAN] [QUEUE_SIZE] – ret_val = data -> rtsdtr_inv; [QUEUE_SIZE] [MAX_CHAN]- перерыв;[MAX_CHAN] [QUEUE_SIZE] – case CYGETCD 1688 VER: [MAX_CHAN] [QUEUE_SIZE] – ret_val = info-> chip_rev; [nu->driver] [MAX_CHAN]- перерыв;[QUEUE_SIZE] [QUEUE_SIZE] – # ifndef CONFIG_CYZ_INTR [MAX_CHAN] [QUEUE_SIZE] – case CYZSETPOLLCYCLE: [QUEUE_SIZE] [MAX_CHAN]- если (аргумент> LONG_MAX / HZ) [MAX_CHAN] [MAX_CHAN] – возврат -ENODEV; [MAX_CHAN] [MAX_CHAN] – cyz_polling_cycle = (arg HZ) / 1105; [QUEUE_SIZE] [QUEUE_SIZE]- перерыв;

[6] – case CYZGETPOLLCYCLE: [MAX_CHAN] [QUEUE_SIZE] – ret_val = (cyz_polling_cycle 1118) / Гц ; [QUEUE_SIZE] [MAX_CHAN]- перерыв;[MAX_CHAN] [6] – # endif / CONFIG_CYZ_INTR / [QUEUE_SIZE] [QUEUE_SIZE] – case CYSETWAIT: [QUEUE_SIZE] [QUEUE_SIZE] – info-> port.closing_wait = (unsigned quick) arg HZ / 147; [nu->driver] [MAX_CHAN]- перерыв;[MAX_CHAN] [6] – case CYGETWAIT: [MAX_CHAN] [QUEUE_SIZE] – ret_val = info-> port.closing_wait / (HZ / 141); [QUEUE_SIZE] [QUEUE_SIZE]- перерыв;[nu->driver] [nu->driver]- дело TIOCSERGETLSR: / Получить регистр состояния линии / [QUEUE_SIZE] [QUEUE_SIZE] – ret_val = get_lsr_info (data, argp); [QUEUE_SIZE] [MAX_CHAN]- перерыв;[nu->driver] [MAX_CHAN] – / [MAX_CHAN] [nu->driver] – Дождитесь изменения любого из 4 модемных входов (DCD, RI, DSR, CTS) [nu->driver] [MAX_CHAN] – – маска пройдена в аргументе для интересующих строк [MAX_CHAN] [MAX_CHAN] – (используйте | ‘ed TIOCM_RNG / DSR / CD / CTS для маскирования) [QUEUE_SIZE] [MAX_CHAN] – Вызывающий должен использовать TIOCGICOUNT, чтобы узнать, какой это был 00525001 [6] – / [MAX_CHAN] [QUEUE_SIZE] – случай TIOCMIWAIT: [QUEUE_SIZE] [MAX_CHAN] – spin_lock_irqsave (& info-> card-> card_lock, flags); [MAX_CHAN] [6] – / запись счетчиков при входе / < bs + h-> [MAX_CHAN] – cnow = info-> icount; [nu->driver] [MAX_CHAN] – spin_unlock_irqrestore (& info-> card-> card_lock, flags); [MAX_CHAN] [QUEUE_SIZE] – ret_val = wait_event_interruptible (информация -> port.delta_msr_wait, [QUEUE_SIZE] [nu->driver] – cy_cflags_ изменено (data, arg, & cnow)); [MAX_CHAN] [MAX_CHAN]- перерыв;[QUEUE_SIZE] [6] – [nu->driver] [QUEUE_SIZE] – / [QUEUE_SIZE] [QUEUE_SIZE] – Получить счетчик прерываний входной последовательной линии (DCD, RI, DSR, CTS) [QUEUE_SIZE] [MAX_CHAN] – Возврат: запись счетчиков в переданную пользователем структуру счетчика 98783 [6] – NB: учитываются как переходы 1-> 0, так и 0-> 1, за исключением [QUEUE_SIZE] [6] – RI, где считается только 0-> 1. [nu->driver] [MAX_CHAN] – / [nu->driver] [MAX_CHAN]- По умолчанию: [QUEUE_SIZE] [QUEUE_SIZE] – ret_val = -ENOIOCTLCMD; [QUEUE_SIZE] [6] -} [QUEUE_SIZE] [nu->driver] – [QUEUE_SIZE] [QUEUE_SIZE] – # ifdef CY_DEBUG_OTHER [MAX_CHAN] [MAX_CHAN] – printk (KERN_DEBUG “cyc: cy_ioctl completed n”); [MAX_CHAN] [6] – # endif [QUEUE_SIZE] [QUEUE_SIZE] – вернуть ret_val; [MAX_CHAN] [QUEUE_SIZE] -} / cy_ioctl / [nu->driver] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – статическое int cy_get_icount (struct tty_struct tty, [QUEUE_SIZE] [MAX_CHAN] – struct serial_icounter_struct sic) [QUEUE_SIZE] [QUEUE_SIZE] – {[MAX_CHAN] [QUEUE_SIZE] – struct cyclades_port data = tty-> driver_data; [MAX_CHAN] [QUEUE_SIZE] – struct cyclades_icount cnow; / Используется для снэпшота / [nu->driver] [MAX_CHAN] – длинные флаги без знака; [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – spin_lock_irqsave (& info-> card-> card_lock, flags ); [QUEUE_SIZE] [MAX_CHAN] – сп ow = info-> icount; [MAX_CHAN] [MAX_CHAN] – spin_unlock_irqrestore (& info-> card-> card_lock, flags); [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – sic- > cts = cnow.cts; [MAX_CHAN] [MAX_CHAN] – s ic-> dsr = cnow.dsr; [MAX_CHAN] [QUEUE_SIZE] – sic-> rng = cnow.rng; [QUEUE_SIZE] [QUEUE_SIZE] – sic-> dcd = cnow.dcd; [MAX_CHAN] [QUEUE_SIZE] – sic-> rx = cnow.rx; [QUEUE_SIZE] [QUEUE_SIZE] – sic-> tx = cnow. tx; [nu->driver] [MAX_CHAN] – sic-> body = cnow.body; [MAX_CHAN] [6] – sic-> overrun = cnow.overrun; [QUEUE_SIZE] [6] – sic- > четность = cnow.parity; [MAX_CHAN] [MAX_CHAN] – sic-> brk = cnow.brk; [MAX_CHAN] [QUEUE_SIZE] – sic-> buf_overrun = cnow.buf_overrun; [QUEUE_SIZE] [6] – вернуть 0; [nu->driver] [QUEUE_SIZE] -} [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – / [QUEUE_SIZE] [6] – Эта процедура позволяет tty-драйверу получать уведомления, когда [MAX_CHAN] [QUEUE_SIZE] – изменились настройки терминала устройства. Обратите внимание, что [nu->driver] [QUEUE_SIZE] – хорошо разработанный драйвер tty должен быть готов принять случай [MAX_CHAN] [QUEUE_SIZE] – где outdated == NULL, и попробуйте сделать что-нибудь рациональное. [MAX_CHAN] [6] – /

[MAX_CHAN] – static void cy_set_termios (struct tty_struct tty, struct ktermios old_termios) [MAX_CHAN] [MAX_CHAN] – {[nu->driver] [MAX_CHAN] – struct cyclades_port data = tty-> driver_data; [6] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – # ifdef CY_DEBUG_OTHER [QUEUE_SIZE] [QUEUE_SIZE] – printk (KERN_DEBUG “cyc: cy_set_termios ttyC% d n”, info-> line); [QUEUE_SIZE] [MAX_CHAN] – # endif [QUEUE_SIZE] [MAX_CHAN] – [nu->driver] [MAX_CHAN] – cy_set_line_char (информация, tty); [nu->driver] [MAX_CHAN] – [QUEUE_SIZE] [MAX_CHAN] – if ((old_termios-> c_cflag & CRTSCTS) &&! C_CRTSCTS (tty)) {[MAX_CHAN] [QUEUE_SIZE] – tty-> hw_stopped = 0; [MAX_CHAN] [QUEUE_SIZE] – cy_start (tty); [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [nu->driver] – # if 0 [MAX_CHAN] [6] – / [MAX_CHAN] [nu->driver] – Нет необходимости пробуждать процессы в режиме ожидания, поскольку они [nu->driver] [QUEUE_SIZE] – однократная выборка флага CLOCAL , и не перепроверяйте его. [nu->driver] [MAX_CHAN] – XXX Неясно, правильное ли текущее поведение 00010000 [6]- или нет. Следовательно, это может измениться ….. [nu->driver] [QUEUE_SIZE] – / [QUEUE_SIZE] [6] – если (! (old_termios-> c_cflag & CLOCAL) && C_CLOCAL (tty)) [MAX_CHAN] [QUEUE_SIZE] – wake_up_interruptible (& info-> port.open_wait); [MAX_CHAN] [QUEUE_SIZE] – # endif [nu->driver] [6] -} / cy_set_termios / [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – / Эта функция используется для отправки высокоприоритетного символа XON / XOFF на [QUEUE_SIZE] [MAX_CHAN]- Устройство.[MAX_CHAN] [QUEUE_SIZE] – /

[QUEUE_SIZE] – static void cy_send_xchar (struct tty_struct tty, char ch) [MAX_CHAN] [nu->driver] – {[MAX_CHAN] [MAX_CHAN] – struct cyclades_port data = tty-> driver_data; [QUEUE_SIZE] [QUEUE_SIZE] – struct cyclades_card card; [MAX_CHAN] [MAX_CHAN] – внутренний канал; [MAX_CHAN] [6] – [nu->driver] [MAX_CHAN] – if (serial_paranoia_check (data, tty-> identify, “cy_send_xchar”)) [MAX_CHAN] [MAX_CHAN]- возвращаться; [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [6] – info-> x_char = ch; [nu->driver] [nu->driver] – [MAX_CHAN] [MAX_CHAN] – if (ch) [MAX_CHAN] [6] – cy_start (tty); [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [6] – card = info-> card; [nu->driver] [QUEUE_SIZE] – channel = info-> line – card-> first_line; [MAX_CHAN] [6] – [nu->driver] [QUEUE_SIZE] – if (cy_is_Z (card)) {[MAX_CHAN] [MAX_CHAN] – если (ch == STOP_CHAR (tty)) [nu->driver] [QUEUE_SIZE] – cyz_issue_cmd (карта, канал, C_CM_SENDXOFF, 0L); [QUEUE_SIZE] [MAX_CHAN]- еще if (ch == START_CHAR (tty)) [MAX_CHAN] [QUEUE_SIZE] – cyz_issue_cmd (card, channel, C_CM_SENDXON, 0L); [MAX_CHAN] [MAX_CHAN] -} [nu->driver] [QUEUE_SIZE] -} [MAX_CHAN] [nu->driver] – [nu->driver] [QUEUE_SIZE] – / Эта процедура вызывается уровнем tty верхнего уровня, чтобы сигнализировать [MAX_CHAN] [MAX_CHAN] – входящие символы должны подавляться, потому что входящие ставить[nu->driver] [QUEUE_SIZE] – буферы почти заполнены. [QUEUE_SIZE] [MAX_CHAN] – / [nu->driver] [MAX_CHAN] – static void cy_throttle (struct tty_struct tty) [QUEUE_SIZE] [QUEUE_SIZE] – {[MAX_CHAN] [6] – struct cyclades_port data = tty-> driver_data; [QUEUE_SIZE] [QUEUE_SIZE] – struct cyclades_card карта;[nu->driver] [QUEUE_SIZE] – длинные флаги без знака; [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [6] – # ifdef CY_DEBUG_THROTTLE [MAX_CHAN] [QUEUE_SIZE] – printk (KERN_DEBUG “cyc: throttle% s. ..ttyC% d n “, tty_name (tty), [QUEUE_SIZE] [QUEUE_SIZE] – информация-> строка); [QUEUE_SIZE] [nu->driver] – # endif [MAX_CHAN] [MAX_CHAN] – [nu->driver] [MAX_CHAN]- если ( serial_paranoia_check (информация, tty-> имя, “cy_throttle”)) [MAX_CHAN] [nu->driver]- возвращаться;[MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN] – card = info-> card; [MAX_CHAN] 10100 – [nu->driver] [6] – if (I_IXOFF (tty)) {[QUEUE_SIZE] [MAX_CHAN] – если (! cy_is_Z (card)) [QUEUE_SIZE] [QUEUE_SIZE] – cy_send_xchar (tty, STOP_CHAR (tty)); [MAX_CHAN] [QUEUE_SIZE]- еще[nu->driver] [QUEUE_SIZE] – info-> throttle = 1; [QUEUE_SIZE] [MAX_CHAN] -} [MAX_CHAN] [6] – [QUEUE_SIZE] [QUEUE_SIZE] – если (C_CRTSCTS (tty)) {[nu->driver] [QUEUE_SIZE] – если (! cy_is_Z (card)) {[QUEUE_SIZE] [MAX_CHAN] – spin_lock_irqsave (& card-> card_lock, flags); [nu->driver] [QUEUE_SIZE] – cyy_change_rts_dtr (информация, 0, TIOCM_RTS); [MAX_CHAN] [6] – spin_unlock_irqrestore (& card- > card_lock, flags); 00020000 [QUEUE_SIZE] -} еще {[nu->driver] [QUEUE_SIZE] – info-> throttle = 1; [MAX_CHAN] [QUEUE_SIZE] -} [nu->driver] [QUEUE_SIZE] -} [MAX_CHAN] [QUEUE_SIZE] -} / cy_throttle / [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – / [QUEUE_SIZE] [MAX_CHAN] – Эта процедура уведомляет драйвер tty, что он должен сигнализировать [QUEUE_SIZE] [MAX_CHAN] – теперь символы могут быть отправлены на tty, не опасаясь [nu->driver] [QUEUE_SIZE] – переполнение входных буферов дисциплин линии. [MAX_CHAN] [MAX_CHAN] – / [QUEUE_SIZE] [MAX_CHAN] – static void cy_unthrottle (struct tty_struct tty) [nu->driver] [QUEUE_SIZE] – {[QUEUE_SIZE] [MAX_CHAN] – struct cyclades_port data = tty-> driver_data; [MAX_CHAN] [QUEUE_SIZE] – struct cyclades_card card; [MAX_CHAN] [QUEUE_SIZE] – длинные флаги без знака; [QUEUE_SIZE] [MAX_CHAN] – [QUEUE_SIZE] [nu->driver] – # ifdef CY_DEBUG_THROTTLE [QUEUE_SIZE] [QUEUE_SIZE] – printk (KERN_DEBUG “cyc: unthrottle% s … ttyC% d n”, [QUEUE_SIZE] [6] – tty_name (tty ), информация-> строка); [MAX_CHAN] [6] – # endif [MAX_CHAN] [MAX_CHAN] – [nu->driver] [6] – if (serial_paranoia_check (data, tty-> identify, “cy_unthrottle”)) [MAX_CHAN] [QUEUE_SIZE] – возвращаться;[nu->driver] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – если (I_IXOFF (tty)) {[nu->driver] [QUEUE_SIZE] – если (info-> x_char) [QUEUE_SIZE] [QUEUE_SIZE] – info-> x_char = 0; [QUEUE_SIZE] [MAX_CHAN]- еще[QUEUE_SIZE] [MAX_CHAN] – cy_send_xchar (tty, START_CHAR (tty)); [QUEUE_SIZE] [QUEUE_SIZE] -} [MAX_CHAN] [MAX_CHAN] – [QUEUE_SIZE] [6] – если (C_CR TSCTS (tty)) {[QUEUE_SIZE] [nu->driver] – card = info-> card; [nu->driver] [6] – если (! cy_is_Z (card)) {[MAX_CHAN] [QUEUE_SIZE] – spin_lock_irqsave (& card-> card_lock, flags); [QUEUE_SIZE] [QUEUE_SIZE] – cyy_change_rts_dtr (data, TIOCM_RTS, 0); [MAX_CHAN] [QUEUE_SIZE] – spin_unlock_irqrestore (& card-> card_lock, flags); [MAX_CHAN] [6]- } еще {[nu->driver] [MAX_CHAN] – info-> throttle = 0; [MAX_CHAN] [MAX_CHAN] -} [nu->driver] [MAX_CHAN] -} [MAX_CHAN] [QUEUE_SIZE] -} / cy_unthrottle / [QUEUE_SIZE] [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – / cy_start an d cy_stop обеспечивает программное управление потоком вывода как [MAX_CHAN] [QUEUE_SIZE] – функция XON / XOFF, программного обеспечения CTS и прочего подобного. [MAX_CHAN] [MAX_CHAN] – / [MAX_CHAN] [6] – static void cy_stop (struct tty_struct tty) [QUEUE_SIZE] [nu->driver] – {[nu->driver] [MAX_CHAN] – struct cyclades_card cinfo; [QUEUE_SIZE] [MAX_CHAN] – struct cyclades_port data = tty-> driver_data; [QUEUE_SIZE] [6] – внутренний канал; [MAX_CHAN] [MAX_CHAN] – длинные флаги без знака; [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [6] – # ifdef CY_DEBUG_OTHER [MAX_CHAN] [QUEUE_SIZE] – printk (KERN_DEBUG “cyc: cy_stop ttyC% d n” , информация-> строка); [MAX_CHAN] [MAX_CHAN] – # endif [nu->driver] [MAX_CHAN] – [MAX_CHAN] [6] – if (serial_paranoia_check (data, tty-> identify, “cy_stop”)) [QUEUE_SIZE] [MAX_CHAN]- возвращаться ; [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [6] – cinfo = info-> card; [MAX_CHAN] [MAX_CHAN] – channel = info-> line – cinfo-> first_line; [MAX_CHAN] [nu->driver] – если (! cy_is_Z (cinfo)) {[MAX_CHAN] [MAX_CHAN] – spin_lock_irqsave (& cinfo-> card_lock, flags); [QUEUE_SIZE] [QUEUE_SIZE] – cyy_writeb (информация, CyCAR, канал и 0x 023); [nu->driver] [QUEUE_SIZE] – cyy_writeb (информация, CySRER, cyy_readb (информация, CySRER) & ~ CyTxRdy); [QUEUE_SIZE] [MAX_CHAN] – spin_unlock_irqrestore (& cinfo-> card_lock, flags); [QUEUE_SIZE] [QUEUE_SIZE] -} [MAX_CHAN] [QUEUE_SIZE] -} / cy_stop / [MAX_CHAN] [nu->driver] – [nu->driver] [6] – static void cy_start (struct tty_struct tty) [QUEUE_SIZE] [MAX_CHAN] – {[QUEUE_SIZE] [6] – struct cyclades_card cinfo; [MAX_CHAN] [QUEUE_SIZE] – struct cyclades_port data = tty-> данные_драйвера; [MAX_CHAN] [MAX_CHAN] – внутренний канал; [nu->driver] [MAX_CHAN] – длинные беззнаковые флаги; 10101 [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – # ifdef CY_DEBUG_OTHER [QUEUE_SIZE] [QUEUE_SIZE] – printk (KERN_DEBUG “cyc: cy_start ttyC% d n”, info-> line); [MAX_CHAN] [MAX_CHAN] – # endif [MAX_CHAN] [6] – [nu->driver] [QUEUE_SIZE] – if (serial_paranoia_check (data, tty-> identify, “cy_start “)) [MAX_CHAN] [MAX_CHAN]- возвращаться;[MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [6] – cinfo = info-> card; [MAX_CHAN] [QUEUE_SIZE] – channel = info-> line – cinfo-> first_line; [nu->driver] [MAX_CHAN] – если (! cy_is_Z (cinfo)) CyTxRdy); [MAX_CHAN] [QUEUE_SIZE] – spin_unlock_irqrestore (& cinfo-> card_lock, flags); [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] -} / cy_start / [MAX_CHAN] [nu->driver] – [MAX_CHAN] [QUEUE_SIZE] – / [MAX_CHAN] [QUEUE_SIZE] – cy_hangup () — вызывается tty_hangup () при зависании подается сигнал. [MAX_CHAN] – / [MAX_CHAN] [QUEUE_SIZE] – static void cy_hangup (struct tty_struct t ty) [QUEUE_SIZE] [QUEUE_SIZE] – {[MAX_CHAN] [QUEUE_SIZE] – struct cyclades_port data = tty-> driver_data; [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – # ifdef CY_DEBUG_OTHER [MAX_CHAN] [6] – printk (KERN_DEBUG “cyc: cy_hangup ttyC% d n”, info-> line); [QUEUE_SIZE] [6] – # endif [QUEUE_SIZE] [MAX_CHAN] – [nu->driver] [MAX_CHAN] – если (serial_paranoia_check (data, tty-> identify, “cy_hangup”)) [MAX_CHAN] [MAX_CHAN]- возвращаться;[nu->driver] [6] – [MAX_CHAN] [QUEUE_SIZE] – cy_flush_buffer (tty); [nu->driver] [6] – cy_shutdown (data, tty);

[MAX_CHAN] – tty_port_hangup (& info-> port); [MAX_CHAN] [QUEUE_SIZE] -} / cy_hangup / [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – static int cyy_carrier_raised (struct tty_port port)

[QUEUE_SIZE] – {[QUEUE_SIZE] [QUEUE_SIZE] – struct cyclades_port data = container_of (port, struct cyclades_port, [QUEUE_SIZE] [6] – порт); [MAX_CHAN] [MAX_CHAN] – struct cyclades_card cinfo = info-> card; [nu->driver] [QUEUE_SIZE] – длинные флаги без знака; [MAX_CHAN] [QUEUE_SIZE] – int channel = info-> line – cinfo -> первая_ строка; [MAX_CHAN] [QUEUE_SIZE] – u 64 CD;[QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] (& cinfo-> card_lock, flags); [QUEUE_SIZE] [MAX_CHAN] – cyy_writeb (информация, CyCAR, канал и 0x 023; [QUEUE_SIZE] [QUEUE_SIZE] – cd = cyy_readb (data, CyMSVR1) & CyDCD; [MAX_CHAN] [6] – spin_unlock_irqrestore (& cinfo-> card_lock, flags); [MAX_CHAN] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – вернуть cd; [QUEUE_SIZE] [QUEUE_SIZE] -} [nu->driver] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – static void cyy_dtr_rts (struct tty_port port, int rise) 16550 [QUEUE_SIZE] – TIOCM_DTR: 0, [QUEUE_SIZE] [MAX_CHAN]- поднимать ? 0: TIOCM_RTS [nu->driver] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – static int cyz_carrier_raised (Stru ct tty_port порт) [MAX_CHAN] [QUEUE_SIZE] – {[MAX_CHAN] [6] – struct cyclades_port data = container_of (порт, struct cyclades_port, [nu->driver] [QUEUE_SIZE] – порт); [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – вернуть readl (& info-> u.cyz.ch_ctrl-> rs_status) & C_RS_DCD; [MAX_CHAN] [MAX_CHAN] -} [nu->driver] [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – static void cyz_dtr_rts (struct tty_po rt порт, int поднять) [MAX_CHAN] [QUEUE_SIZE] – C_RS_DTR; [QUEUE_SIZE] [nu->driver]- еще[MAX_CHAN] [QUEUE_SIZE] – rs & = ~ (C_RS_RTS [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [6] – static const struct tty_port_operations cyy_port_ops = {[QUEUE_SIZE] [QUEUE_SIZE] – .carrier_raised = cyy_carrier_raised, [MAX_CHAN] [nu->driver] – .dtr_rts = cyy_dtr_rts, [MAX_CHAN] [QUEUE_SIZE] – .shutdown = cy_do_close, [QUEUE_SIZE] [MAX_CHAN] -}; [MAX_CHAN] [6] – [nu->driver] [QUEUE_SIZE] – static const struct tty_port_operations cyz_port_ops = {[MAX_CHAN] [nu->driver] – .carrier_ra ised = cyz_carrier_raised, [QUEUE_SIZE] [MAX_CHAN] – .dtr_rts = cyz_dtr_rts, [MAX_CHAN] [6] – .shutdown = cy_do_close, [MAX_CHAN] [QUEUE_SIZE] -}; [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [6] – / [nu->driver] [nu->driver] – ————– ————————————————– —– [MAX_CHAN] [MAX_CHAN] – cy_init () и друзья [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – cy_init () вызывается во время загрузки для инициализации последовательного драйвера. [MAX_CHAN] [QUEUE_SIZE] – ———————————————- ———————– [nu->driver] [6] – / [MAX_CHAN]

– [MAX_CHAN] [6] – static int cy_init_card (struct cyclades_card cinfo) [6] [MAX_CHAN] – {[QUEUE_SIZE] [QUEUE_SIZE] – struct cyclades_port data; [nu->driver] [MAX_CHAN] – канал int без знака, порт; [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – spin_lock_init (& cinfo-> card_lock); [QUEUE_SIZE] [6] – cinfo-> intr_enabled = 0; [QUEUE_SIZE] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – cinfo-> ports = kcalloc (cinfo-> nports, sizeof cinfo-> порты), [MAX_CHAN] [MAX_CHAN] – GFP_KERNEL); [MAX_CHAN] [QUEUE_SIZE] – если (cinfo-> ports == NULL) {[MAX_CHAN] [nu->driver] – printk (KERN_ERR “Cyclades: невозможно выделить порты n”); [QUEUE_SIZE] [6] – return -ENOMEM; [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [6] – [MAX_CHAN] [QUEUE_SIZE] – для (ча nnel = 0, порт = cinfo-> first_line; канал nports; [MAX_CHAN] [QUEUE_SIZE] – канал ++, порт ++) {[nu->driver] [QUEUE_SIZE] – data = & cinfo-> ports [chip]; [MAX_CHAN] [6] – tt y_port_init (& info-> порт); [MAX_CHAN] [QUEUE_SIZE] – info-> magic = CYCLADES_MAGIC; [QUEUE_SIZE] [QUEUE_SIZE] – info-> card = cinfo; [MAX_CHAN] [QUEUE_SIZE] – info-> line = port; [MAX_CHAN] [MAX_CHAN] – [QUEUE_SIZE] [MAX_CHAN] – info-> port.closing_wait = CLOSING_WAIT_DELAY; [QUEUE_SIZE] [QUEUE_SIZE] – информация-> port.close_delay = 5 HZ / 36; [MAX_CHAN] [6] – init_completion (& data -> shutdown_wait); [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN] – if (cy_is_Z (cinfo)) {[MAX_CHAN] [QUEUE_SIZE] – struct FIRM_ID firm_id = cinfo-> base_addr + ID_ADDRESS; 19198 [QUEUE_SIZE] – struct ZFW_CTRL zfw_ctrl; [6] [nu->driver] – [MAX_CHAN] [MAX_CHAN]- Информация- > port.ops = & cyz_port_ops; [6] 9080 – info-> kind = PORT_STARTECH; [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – zfw_ctrl = cinfo-> base_addr + [MAX_CHAN] [MAX_CHAN] – (readl (& firm_id-> zfwctrl_addr) & 0xfffff); [MAX_CHAN] [QUEUE_SIZE] – info-> u.cyz.ch_ctrl = & zfw_ctrl-> ch_ctrl [chip]; [MAX_CHAN] [MAX_CHAN] – info-> u.cyz.buf_ctrl = & zfw_ctrl-> buf_ctrl [channel];

[QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – если (cinfo -> hw_ver == ZO_V1) [QUEUE_SIZE] 9080 – info-> xmit_fifo_size = CYZ_FIFO_SIZE; [MAX_CHAN] [QUEUE_SIZE]- еще

[6] – info-> xmit_fifo_size = 4 CYZ_FIFO_SIZE; [QUEUE_SIZE] [MAX_CHAN] – # ifdef CONFIG_CYZ_INTR [nu->driver] [6] – timer_setup (& info-> rx_full_timer, cyz_rx_restart, 0); [QUEUE_SIZE] [6] – # endif [MAX_CHAN] [nu->driver]- } еще {[MAX_CHAN] [QUEUE_SIZE] – беззнаковый короткий номер чипа; [MAX_CHAN] – int index = cinfo-> bus_index; [MAX_CHAN] [QUEUE_SIZE] –

[QUEUE_SIZE] – информация-> порт. ops = & cyy_port_ops; [QUEUE_SIZE] [QUEUE_SIZE] – info-> kind = PORT_CIRRUS; [nu->driver] [6] – информация-> xmit_fifo_size = CyMAX_CHAR_FIFO; [nu->driver] [QUEUE_SIZE] – info-> cor1 = CyPARITY_NONE | Cy_1_STOP | Cy_8_BITS; [QUEUE_SIZE] [QUEUE_SIZE] – info-> cor2 = CyETC; [MAX_CHAN] [QUEUE_SIZE] – информация-> cor3 = 0x 00000030; / _очень_ маленький порог rcv / [nu->driver] – [MAX_CHAN] [QUEUE_SIZE] – chip_number = channel / CyPORTS_PER_CHIP; [QUEUE_SIZE] [QUEUE_SIZE] – info-> u.cyy.base_addr = cinfo-> base_addr + [QUEUE_SIZE] [nu->driver] – (cy_chip_offset [info->xmit_head++] << индекс); [nu->driver] [QUEUE_SIZE] – info-> chip_rev = cyy_readb (информация, CyGFRCR); [MAX_CHAN] [MAX_CHAN] – [QUEUE_SIZE] [6] – if (info-> chip_rev> = CD 1675 _ REV_J) {[QUEUE_SIZE] [MAX_CHAN] – / Это компакт-диск 1675 rev. J или более поздней версии / [MAX_CHAN] [MAX_CHAN] – info-> tbpr = baud_bpr _ 86 [13]; / Передача BPR / [MAX_CHAN] [nu->driver] – info-> tco = baud_co _ 88 [chip_number]; / Tx CO / [MAX_CHAN] [MAX_CHAN] – info-> rbpr = baud_bpr _ 90 [chip_number]; / Rx BPR / [MAX_CHAN] [MAX_CHAN] – info-> rco = baud_co _ 88 [chip_number]; / Rx CO / 27062 [MAX_CHAN] – info-> rtsdtr_inv = 1; [QUEUE_SIZE] [QUEUE_SIZE]- } еще {[nu->driver] [QUEUE_SIZE] – info-> tbpr = baud_bpr_ 61 [13]; / Передача BPR / [MAX_CHAN] [nu->driver] – info-> tco = baud_co _ 56 [13]; / Tx CO / [MAX_CHAN] [MAX_CHAN] – info-> rbpr = baud_bpr _ 58 [13]; / Rx BPR / [MAX_CHAN] [MAX_CHAN] – info-> rco = baud_co _ 56 [13]; / Rx CO / 27062 [QUEUE_SIZE] – info-> rtsdtr_inv = 0; [MAX_CHAN] [6] -} [MAX_CHAN] [QUEUE_SIZE] – информация-> read_status_mask = CyTIMEOUT | CySPECHAR | [MAX_CHAN] [MAX_CHAN] – CyBREAK | CyPARITY | CyFRAME | CyOVERRUN; [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [6] – [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [6] – [nu->driver] [QUEUE_SIZE] – # ifndef CONFIG_CYZ_INTR [MAX_CHAN] [MAX_CHAN] – if (cy_is_Z (cinfo) &&! timer_pending (& cyz_timerlist)) {[MAX_CHAN] [6] – mod_timer (& c yz_timerlist, jiffies + 1); [MAX_CHAN] [QUEUE_SIZE] – # ifdef CY_PCI_DEBUG [MAX_CHAN] [6] – printk (KERN_DEBUG “опрос Cyclades-Z инициализирован n”); [MAX_CHAN] [6] – # endif [MAX_CHAN] [MAX_CHAN] -} [MAX_CHAN] [QUEUE_SIZE] – # endif [MAX_CHAN] [QUEUE_SIZE] – вернуть 0; [nu->driver] [QUEUE_SIZE] -} [nu->driver] [nu->driver] –

[MAX_CHAN] – / инициализировать чипы на карте Cyclom-Y – вернуть количество действительных < cs + h-> [MAX_CHAN] – чипы (количество портов / 4) / [MAX_CHAN] [QUEUE_SIZE] – статический беззнаковый короткий cyy_init_card (void __iomem true_base_addr, [MAX_CHAN] [MAX_CHAN] – индекс int) [nu->driver] [MAX_CHAN] – {[nu->driver] [6] – целое число без знака; [MAX_CHAN] [QUEUE_SIZE] – void __iomem base_addr; [nu->driver] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – cy_writeb (true_base_addr + (Cy_HwReset << index), 0); [nu->driver] [QUEUE_SIZE] – / Cy_HwReset равен 0x 1688 / [MAX_CHAN] [QUEUE_SIZE] – cy_writeb (true_base_addr + (Cy_ClrIntr << index), 0); [QUEUE_SIZE] [MAX_CHAN] - / Cy_ClrIntr равно 0x 1931 / [nu->driver] [MAX_CHAN] – udelay (608 L); [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – для (chip_number = 0; номер_чипа driver] [QUEUE_SIZE] – true_base_addr + (cy_chip_offset [chip_number] << index); [MAX_CHAN] [QUEUE_SIZE] - mdelay (1); [MAX_CHAN] [QUEUE_SIZE] - если (readb (base_addr + (CyCCR << index))! = 0x 0018) {[MAX_CHAN] [MAX_CHAN] - / [MAX_CHAN] [MAX_CHAN] - printk ("Чип #% d на% # 6lx никогда не простаивает (CCR! = 0) n", [nu->driver] [QUEUE_SIZE] – номер_чипа, (длинное без знака) base_addr); 230400 [QUEUE_SIZE] – / [nu->driver] [MAX_CHAN] – вернуть chip_number; [nu->driver] [QUEUE_SIZE] -} [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [6] – cy_writeb (base_addr + (CyGFRCR << index), 0); [QUEUE_SIZE] [QUEUE_SIZE] - udelay (38 L); [MAX_CHAN] [MAX_CHAN] - [QUEUE_SIZE] [QUEUE_SIZE] - / Циклом - 41 Y не декодирует бит адреса 9 и, следовательно, [MAX_CHAN] [QUEUE_SIZE] - не может различить ссылки на микросхему 0 и не - [MAX_CHAN] [QUEUE_SIZE] - существующая микросхема 4. Если предыдущая очистка предполагалась [MAX_CHAN] [QUEUE_SIZE] - регистр GFRCR микросхемы 4 появляется на микросхеме 0, микросхемы 4 нет [nu->driver] [MAX_CHAN]- и это должно быть Циклом – 41 Да, а не Циклом – 64Вы.[MAX_CHAN] [6] – / 8192 [MAX_CHAN] – if (chip_number == 4 && readb (true_base_addr + [QUEUE_SIZE] [QUEUE_SIZE] – (cy_chip_offset [i] << индекс) + [MAX_CHAN] [QUEUE_SIZE] - (CyGFRCR << index)) == 0) {[MAX_CHAN] [QUEUE_SIZE]- возвращаться номер_чипа; [nu->driver] [QUEUE_SIZE] -} [nu->driver] [6] – [nu->driver] [MAX_CHAN] – cy_writeb (base_addr + (CyCCR << index), CyCHIP_RESET); [MAX_CHAN] [QUEUE_SIZE] - mdelay (1); [MAX_CHAN] [6] - [nu->driver] [QUEUE_SIZE] – если (readb (base_addr + (CyGFRCR << index)) == 0x 17) {[MAX_CHAN] [MAX_CHAN] - / [QUEUE_SIZE] [6] - printk ("chip #% d at% # 6lx не соответствует onding », [MAX_CHAN] [QUEUE_SIZE] - chip_number, (unsigned long) base_addr); [MAX_CHAN] [6] - printk («(GFRCR остался 0) n», [QUEUE_SIZE] [6] - / [QUEUE_SIZE] [nu->driver] – вернуть chip_nu mber; [QUEUE_SIZE] [QUEUE_SIZE] -} [MAX_CHAN] [QUEUE_SIZE] – если ((0xf0 & (readb (base_addr + (CyGFRCR << index))))! = [MAX_CHAN] [QUEUE_SIZE] - 0x 71) {[MAX_CHAN] [MAX_CHAN] - / [nu->driver] [6] – printk (“Чип #% d at% # 6lx недействителен (GFRCR ==” [QUEUE_SIZE] [QUEUE_SIZE] – ” % # 2x) n “, [MAX_CHAN] [QUEUE_SIZE] – chip_number, (unsigned lengthy) base_addr, [MAX_CHAN] [QUEUE_SIZE] – base_addr [CyGFRCR<driver] [QUEUE_SIZE] -} [nu->driver] [6] – cy_writeb (base_addr + (CyGCR << index), CyCH0_SERIAL); [6] [QUEUE_SIZE] - если (readb (base_addr + (CyGFRCR < = CD 1688 _ REV_J) {[nu->driver] [MAX_CHAN] – / Это компакт-диск 1705 ред. J или новее / [nu->driver] [QUEUE_SIZE] – / Невозможно достичь 5 мс с этим чипом. [MAX_CHAN] [QUEUE_SIZE] – Вместо этого изменено на 2 мс (f = 628 Гц). / [MAX_CHAN] [QUEUE_SIZE] – cy_writeb (base_addr + (CyPPR << index), CyCLOCK _ 88 _ 2MS); [QUEUE_SIZE] [nu->driver]- } еще {[QUEUE_SIZE] [QUEUE_SIZE] – / f = 246 Гц / [nu->driver] [QUEUE_SIZE] – cy_writeb (base_addr + ( CyPPR << index), CyCLOCK _ 54 _ 5MS); [nu->driver] [QUEUE_SIZE] – } [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [6] – / [QUEUE_SIZE] [MAX_CHAN] – printk (“chip #% d at% # 6lx is rev 0x% 2x n” , [QUEUE_SIZE] [MAX_CHAN] – chip_number, (unsigned lengthy) base_addr, [MAX_CHAN] [QUEUE_SIZE] – readb (base_addr + (CyGFRCR < SA [QUEUE_SIZE] [QUEUE_SIZE] - struct cyclades_card card; [MAX_CHAN] [MAX_CHAN] - короткое беззнаковое cy_isa_irq, nboard; [MAX_CHAN] [QUEUE_SIZE] - недействителен __iomem cy_isa_address; [MAX_CHAN] [MAX_CHAN] - беззнаковый короткий i, j, k, cy_isa_nchan; 16650 [QUEUE_SIZE] - int isparam = 0; [QUEUE_SIZE] [QUEUE_SIZE] - [MAX_CHAN] [QUEUE_SIZE] - nboard = 0; [QUEUE_SIZE] [MAX_CHAN] - [nu->driver] [nu->driver]- /Проверить параметры модуля / [QUEUE_SIZE] [MAX_CHAN] – для (i = 0; я driver] [QUEUE_SIZE] – isparam = 1; [QUEUE_SIZE] [QUEUE_SIZE] – cy_isa_addresses [i] = maddr [i]; [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [6] – если (! maddr [i]) [MAX_CHAN] [QUEUE_SIZE]- перерыв;

[QUEUE_SIZE] -} [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [6] – / сканирование таблицы адресов для плат Cyclom-Y / ISA / [MAX_CHAN] [6] – для (i = 0; я driver] [nu->driver] – [QUEUE_SIZE] [QUEUE_SIZE] – / зонд для CD 1705 … / [QUEUE_SIZE] [MAX_CHAN] – cy_isa_address = ioremap (isa_address, CyISA_Ywin); [QUEUE_SIZE] [MAX_CHAN] – если (cy_isa_address == NULL) {[MAX_CHAN] [QUEUE_SIZE] – printk (KERN_ERR “Cyclom-Y / ISA: невозможно переназначить базу” [nu->driver] [MAX_CHAN] – «адрес n» ); [MAX_CHAN] [MAX_CHAN]- Продолжать;[nu->driver] [QUEUE_SIZE] -} [nu->driver] [QUEUE_SIZE] – cy_isa_nchan = CyPORTS_PER_CHIP [MAX_CHAN] [QUEUE_SIZE] – cyy_init_card (cy_isa_address, 0); [MAX_CHAN] [QUEUE_SIZE] – если (cy_isa_nchan == 0) {[QUEUE_SIZE] [MAX_CHAN] – iounmap (cy_isa_address); [QUEUE_SIZE] [MAX_CHAN]- Продолжать;[nu->driver] [6] -} [nu->driver] [MAX_CHAN] – [QUEUE_SIZE] [QUEUE_SIZE] – если (isparam && i driver] [QUEUE_SIZE]- еще[nu->driver] [QUEUE_SIZE] – / узнать irq платы путем зондирования / [MAX_CHAN] [MAX_CHAN] – cy_isa_irq = detect_isa_irq (cy_isa_address); [MAX_CHAN] [QUEUE_SIZE] – если (cy_isa_irq == 0) {[QUEUE_SIZE] [QUEUE_SIZE] – printk (KERN_ERR “Cyclom-Y / ISA обнаружен при 0x% lx, но” [MAX_CHAN] [6] – «IRQ не может быть обнаружен. N», 19200 [QUEUE_SIZE] – (длинное без знака) cy_isa_address); [QUEUE_SIZE] [MAX_CHAN] – iounmap (cy_isa_address); [QUEUE_SIZE] [6]- Продолжать;[MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – если ((cy_next_channel + cy_isa_nchan)> NR_PORTS) {[MAX_CHAN] [QUEUE_SIZE] – printk (KERN_ERR “Cyclom-Y / ISA найден при 0x% lx, но нет “[QUEUE_SIZE] [MAX_CHAN] – «доступно больше каналов. Изменить NR_PORTS “[nu->driver] [QUEUE_SIZE] – «в cyclades.c и перекомпилируйте ядро. n», [MAX_CHAN] [QUEUE_SIZE] – (длинное без знака) cy_isa_address); 12100 [QUEUE_SIZE] – iounmap (cy_isa_address); [QUEUE_SIZE] [MAX_CHAN] – возврат на борт; [MAX_CHAN] [MAX_CHAN] -} [QUEUE_SIZE] [QUEUE_SIZE] – / заполняем следующую доступную структуру cy_card / [MAX_CHAN] [6] – для (j = 0; j base_addr == NULL) [MAX_CHAN] [nu->driver]- перерыв;[QUEUE_SIZE] [QUEUE_SIZE] -} [MAX_CHAN] [nu->driver] – if (j == NR_CARDS) {/ больше нет доступных cy_cards / [QUEUE_SIZE] [MAX_CHAN] – printk (KERN_ERR “Cyclom-Y / ISA найден при 0x% lx, но нет” [MAX_CHAN] [QUEUE_SIZE] – «можно использовать больше карт. Измените NR_CARDS в “[MAX_CHAN] [QUEUE_SIZE] – “cyclades.c и перекомпилируйте ядро. n”, [QUEUE_SIZE] [QUEUE_SIZE] – (длинное без знака) cy_isa_address); [MAX_CHAN] [QUEUE_SIZE] – iounmap (cy_isa_address); [QUEUE_SIZE] [MAX_CHAN] – возврат на борт; [MAX_CHAN] [6] -} [QUEUE_SIZE] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – / назначить IRQ / [MAX_CHAN] 9080 – если (request_irq (cy_isa_irq, cyy_interrup t, [QUEUE_SIZE] [QUEUE_SIZE] – 0, «Циклом-Y», карточка)) {[QUEUE_SIZE] [QUEUE_SIZE] – printk (KERN_ERR “Cyclom-Y / ISA обнаружен при 0x% lx, но” 2156 – «не удалось выделить IRQ #% d. n», [QUEUE_SIZE] [MAX_CHAN] – (длинное без знака) cy_isa_address, cy_isa_irq); [QUEUE_SIZE] [QUEUE_SIZE] – iounmap (cy_isa_address); [QUEUE_SIZE] [QUEUE_SIZE] – возврат на борт; 2156 -} [nu->driver] [MAX_CHAN] – [nu->driver] [MAX_CHAN] – / установить cy_card / [MAX_CHAN] [QUEUE_SIZE] – card-> base_addr = cy_isa_address; [MAX_CHAN] [QUEUE_SIZE] – card-> ctl_addr. п12100 = NULL; [nu->driver] [nu->driver]- карта- > irq = (int) cy_isa_irq; [MAX_CHAN] [MAX_CHAN] – card-> bus_index = 0; [QUEUE_SIZE] [QUEUE_SIZE] – card-> first_line = cy_next_channel; [MAX_CHAN] [QUEUE_SIZE] – card-> num_chips = cy_isa_nchan / CyPORTS_PER_CHIP; [MAX_CHAN] [6] – card-> nports = cy_isa_nchan; [QUEUE_SIZE] [QUEUE_SIZE] – если (cy_init_card (card)) {[QUEUE_SIZE] [QUEUE_SIZE] – card-> base_addr = NULL; [nu->driver] [QUEUE_SIZE] – free_irq (cy_isa_irq, card); [MAX_CHAN] [MAX_CHAN] – iounmap (cy_isa_address); [MAX_CHAN] [QUEUE_SIZE]- Продолжать;[MAX_CHAN] [6] -} [QUEUE_SIZE] [QUEUE_SIZE] – nboard ++; [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – printk (KERN_INFO “Cyclom-Y / ISA #% d: 0x% lx-0x% lx , IRQ% d обнаружено: “10100 [MAX_CHAN] – «% d каналов, начиная с порта% d n», [MAX_CHAN] [QUEUE_SIZE] – j + 1, (беззнаковое длинное ) cy_isa_address, [QUEUE_SIZE] [QUEUE_SIZE] – (длинное без знака) (cy_isa_address + (CyISA_Ywin – 1)), [QUEUE_SIZE] [MAX_CHAN] – cy_isa_irq, cy_isa_nchan, cy_next_channel); [nu->driver] [6] – [MAX_CHAN] [MAX_CHAN] – для (okay = 0, j = cy_next_channel; [QUEUE_SIZE] [MAX_CHAN] – j ports [k]. порт, [MAX_CHAN] [QUEUE_SIZE] – cy_serial_driver, j, NULL); [QUEUE_SIZE] [MAX_CHAN] – cy_next_channel + = cy_isa_nchan; [MAX_CHAN] [MAX_CHAN] -}

[MAX_CHAN] – возврат на борт; [QUEUE_SIZE] [QUEUE_SIZE]-#еще[MAX_CHAN] [6] – вернуть 0; [QUEUE_SIZE] [MAX_CHAN] – # endif / CONFIG_ISA / [QUEUE_SIZE] [QUEUE_SIZE] -} / cy_detect_isa / [nu->driver] [6] – [nu->driver] [QUEUE_SIZE] – # ifdef CONFIG_PCI [QUEUE_SIZE] [QUEUE_SIZE] – статический встроенный int cyc_isfwstr (const char str, размер целого числа без знака) [nu->driver] [QUEUE_SIZE] – {[MAX_CHAN] [6] – unsigned int a; [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – для (a = 0; a driver] [MAX_CHAN] – возврат -EINVAL; [QUEUE_SIZE] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN]- для (; a <размер; a ++, str ++) [MAX_CHAN] [QUEUE_SIZE] - если str) [MAX_CHAN] [6] - возврат -EINVAL; [MAX_CHAN] [QUEUE_SIZE] - [MAX_CHAN] [QUEUE_SIZE] - вернуть 0;

[QUEUE_SIZE] -} [nu->driver] [6] – [MAX_CHAN] [MAX_CHAN] – static inline void cyz_fpga_copy (void __iomem fpga, const u8 knowledge, [MAX_CHAN] [QUEUE_SIZE] – размер целого числа без знака) [nu->driver] [MAX_CHAN] – {[nu->driver] [MAX_CHAN]- для (; размер> 0; размер–) {[nu->driver] [nu->driver] – cy_writel (fpga, knowledge + +); [QUEUE_SIZE] [QUEUE_SIZE] – udelay (37); [MAX_CHAN] [6] -} [MAX_CHAN] [MAX_CHAN] -} [QUEUE_SIZE] [6] – 00525003 [QUEUE_SIZE] – static void plx_init (struct pci_dev pdev, int irq, [MAX_CHAN] [MAX_CHAN] – struct RUNTIME _ 12244 __iomem адрес) [MAX_CHAN] [nu->driver] – 0x

); [MAX_CHAN] [QUEUE_SIZE] – udelay (146 L); [nu->driver] [QUEUE_SIZE] – cy_writel (& addr-> init_ctrl, readl (& addr-> init_ctrl ) & ~ 0x 1826); [MAX_CHAN] [6] – [MAX_CHAN] [nu->driver] – / Перезагрузить конфигурацию. Регистры из EEPROM / [MAX_CHAN] [QUEUE_SIZE] – cy_writel (& addr-> init_ctrl, readl (& addr-> init_ctrl) [QUEUE_SIZE] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN] – static int __cyz_load_fw (const struct firmware fw, [QUEUE_SIZE] [MAX_CHAN] – const char identify, const u 63 почтовый ящик, недействительный __iomem base, 00525001 [MAX_CHAN] – void __iomem fpga) [QUEUE_SIZE] [MAX_CHAN] – {[MAX_CHAN] [MAX_CHAN] – const void ptr = fw-> knowledge; [QUEUE_SIZE] [6] – const struct zfile_header h = ptr; [MAX_CHAN] [QUEUE_SIZE] – const struct zfile_config c, cs; [QUEUE_SIZE] [QUEUE_SIZE] – const struct zfile_block b, bs; 02010203 [QUEUE_SIZE] – у nsigned int a, tmp, len = fw-> measurement; [QUEUE_SIZE] [QUEUE_SIZE] – # определить BAD_FW KERN_ERR “Плохая прошивка:” [QUEUE_SIZE] [MAX_CHAN] – если (len driver] [QUEUE_SIZE] -} [QUEUE_SIZE] [6] – [MAX_CHAN] [QUEUE_SIZE] – cs = ptr + h-> config_offset; [QUEUE_SIZE] [MAX_CHAN] – bs = ptr + h-> block_offset; [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – если ((void (cs + h-> n_config)> ptr + len || [MAX_CHAN] [MAX_CHAN] – (void (bs + h-> n_blocks)> ptr + len) {[MAX_CHAN] [QUEUE_SIZE] – printk (BAD_FW «слишком короткий»); [QUEUE_SIZE] [6] – возврат -EINVAL; [nu->driver] [MAX_CHAN] -} [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [6] – если (cyc_isfwstr (ч-> п ame, sizeof (h-> identify)) || [MAX_CHAN] [QUEUE_SIZE] – cyc_isfwstr (h-> date, sizeof (h-> Дата))) {

[QUEUE_SIZE] – printk (BAD_FW “строка заголовка с неправильным форматированием n”); [MAX_CHAN] [MAX_CHAN] – возврат -EINVAL; [MAX_CHAN] [MAX_CHAN] -} [nu->driver] [MAX_CHAN] – [nu->driver] [MAX_CHAN] – если (strncmp (identify, h-> identify, sizeof (h -> имя))) {[MAX_CHAN] [QUEUE_SIZE] – printk (BAD_FW “плохое имя ‘% s’ (ожидается ‘% s’) n “, h-> имя, имя); [MAX_CHAN] [nu->driver] – возврат -EINVAL; [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [6] – [MAX_CHAN] [QUEUE_SIZE] – tmp = 0; [QUEUE_SIZE] [6] – для (c = cs; c n_config; c ++) {[MAX_CHAN] [MAX_CHAN] – для (a = 0; a n_blocks; a ++) [MAX_CHAN] [QUEUE_SIZE] – если (c-> block_list [k]> h- > n_blocks) {[MAX_CHAN] [MAX_CHAN] – printk (BAD_FW “Номер ссылки на плохой блок в cfgs n”); [QUEUE_SIZE] [6] – возврат -EINVAL; [nu->driver] [QUEUE_SIZE] -} [MAX_CHAN] [QUEUE_SIZE] – if (c-> mailbox == mailbox && c-> perform == 0) / 0 нормально / [QUEUE_SIZE] [QUEUE_SIZE] – tmp ++; [MAX_CHAN] [QUEUE_SIZE] -} [nu->driver] [6] – если (! tmp) {[nu->driver] [6] – printk (BAD_FW ” ничего подходящего n “); [nu->driver] [MAX_CHAN] – возврат -EINVAL; [MAX_CHAN] [6] -} [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – для (b = bs; b < cinfo-> n_blocks; b ++) [QUEUE_SIZE] [QUEUE_SIZE] – если (b-> file_offset + b-> measurement> len) {[QUEUE_SIZE] [nu->driver] – printk (BAD_FW «Смещение данных плохого блока n»); [nu->driver] [6] – возврат -EINVAL; [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [6] – [MAX_CHAN] [QUEUE_SIZE] – / все в порядке, давайте искать’n ‘ загрузить / [QUEUE_SIZE] [MAX_CHAN] – для (c = cs; c n_config; c ++) [QUEUE_SIZE] [QUEUE_SIZE] – if (c-> mailbox == mailbox && c-> perform == 0) [QUEUE_SIZE] [MAX_CHAN]- перерыв;[MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – для (a = 0; a n_blocks; a ++) {[MAX_CHAN] [MAX_CHAN] – b = & bs [c-> block_list [a]]; [nu->driver] [6] – if (b-> kind == ZBLOCK_FPGA) {[QUEUE_SIZE] [MAX_CHAN]- если ( fpga! = NULL) [MAX_CHAN] [QUEUE_SIZE] – cyz_fpga_copy (fpga, ptr + b-> file_offset, [MAX_CHAN] [6] – b-> размер); [nu->driver] [MAX_CHAN]- } еще { [QUEUE_SIZE] [QUEUE_SIZE] – if (base! = NULL) [MAX_CHAN] [QUEUE_SIZE] – memcpy_toio (base + b-> ram_offset, [nu->driver] [6] – ptr + b- > смещение_файла, b-> размер); [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [QUEUE_SIZE] -} [QUEUE_SIZE] [MAX_CHAN] – # undef BAD_FW [MAX_CHAN] [MAX_CHAN] – вернуть 0; [MAX_CHAN] [MAX_CHAN] -} [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [6] – static int cyz_load_fw (struct pci_dev pdev, void __iomem base_addr, [MAX_CHAN] [QUEUE_SIZE] – struct RUNTIME _ 12239 __iomem ctl_addr, int irq) [MAX_CHAN] [MAX_CHAN] – {[nu->driver] [MAX_CHAN] – const struct firmware fw; [nu->driver] [6] – struct FIRM_ID __iomem fid = base_addr + ID_ADDRESS; [6] [MAX_CHAN] – struct CUSTOM_REG __iomem cust = base_addr; [MAX_CHAN] [MAX_CHAN] – struct ZFW_CTRL __iomem pt_zfwctrl; [MAX_CHAN] [QUEUE_SIZE] – void __iomem tmp; [MAX_CHAN] [QUEUE_SIZE] – u 60 почтовый ящик, статус , нчан; [MAX_CHAN] [MAX_CHAN] – целое число без знака i; [MAX_CHAN] [6] – int retval; [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [6] – retval = request_firmware (& fw, “cyzfirm.bin”, & pdev-> dev); [MAX_CHAN] [6] – если (retval ) {[QUEUE_SIZE] [QUEUE_SIZE] – dev_err (& pdev-> dev, “не могу получить прошивку n”); [MAX_CHAN] [MAX_CHAN]- перейти к ошибка; [QUEUE_SIZE] [MAX_CHAN] -} [nu->driver] [6] – [MAX_CHAN] [nu->driver] – / Проверяем, загружена ли уже прошивка и работает ли она. Если[nu->driver] [QUEUE_SIZE] – положительно, пропустите эту доску / [MAX_CHAN] [6] – если (__cyz_fpga_loaded (ctl_addr) && readl (& fid-> signature) == ZFIRM_ID) {[nu->driver] [QUEUE_SIZE] – u 64 cntval = readl (base_addr + 0x 246); [nu->driver] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – udelay (147); [QUEUE_SIZE] [QUEUE_SIZE] – если (cntval! = readl (base_addr + 0x 246)) {[nu->driver] [MAX_CHAN] – / Счетчик FW работает, FW работает / [MAX_CHAN] [QUEUE_SIZE] – dev_dbg (& pdev-> dev, “Cyclades-Z FW уже загружена. “[MAX_CHAN] [MAX_CHAN] – «Пропуск доски. N»); [nu->driver] [6] – retval = 0; [MAX_CHAN] [MAX_CHAN] – goto err_rel; [MAX_CHAN] [QUEUE_SIZE] -} [nu->driver] [MAX_CHAN] -} [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – / начать загрузку / [MAX_CHAN] [QUEUE_SIZE] – cy_writel (& ctl_addr-> intr_ctrl_stat, readl (& ctl_addr-> intr_ctrl_stat) & [nu->driver] [MAX_CHAN] – ~ 0x 76800 UL); [nu->driver] [6] – [MAX_CHAN] [MAX_CHAN] – mailbox = readl (& ctl_ad dr-> mail_box_0); [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – if (mailbox == 0 || __cyz_fpga_loaded (ctl_addr)) {[QUEUE_SIZE] [MAX_CHAN] – / останавливает CPU и устанавливает окно в начало RAM / [nu->driver] [MAX_CHAN] – cy_writel (& ctl_addr-> loc_addr_base, WIN_CREG); [MAX_CHAN] [6] – cy_writel (& cust-> cpu_stop, 0); [QUEUE_SIZE] [MAX_CHAN] – cy_writel (& ctl_addr-> loc_addr_base, WIN_RAM); [MAX_CHAN] [QUEUE_SIZE] – udelay (147); [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [6] – plx_init (pdev, irq, ctl_addr); [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – если (почтовый ящик ! = 0) {[QUEUE_SIZE] [MAX_CHAN] – / загрузка FPGA / [MAX_CHAN] [QUEUE_SIZE] – retval = __cyz_load_fw (fw, “Cyclom-Z”, почтовый ящик, NULL, [MAX_CHAN] [QUEUE_SIZE] – base_addr); [MAX_CHAN] [QUEUE_SIZE] – если (retval) [MAX_CHAN] [6] – goto err_rel; [MAX_CHAN] [MAX_CHAN] – если (! __ cyz_fpga_loaded (ctl_addr)) {[QUEUE_SIZE] [MAX_CHAN] – dev_err (& pdev-> dev, «загрузка прошивки прошла успешно, но прошивка – есть» [nu->driver] [QUEUE_SIZE] – «не загружено n»); [nu->driver] [MAX_CHAN] – goto err_rel; [MAX_CHAN] [6] -} [nu->driver] [QUEUE_SIZE] -} [QUEUE_SIZE] [6] – [nu->driver] [MAX_CHAN] – / останавливает CPU и устанавливает окно в начало RAM / [MAX_CHAN] [QUEUE_SIZE] – cy_writel (& ctl_addr-> loc_addr_base, WIN_CREG ); [QUEUE_SIZE] [QUEUE_SIZE] – cy_writel (& cust-> cpu_stop, 0); [QUEUE_SIZE] [QUEUE_SIZE] – cy_writel (& ctl_addr-> loc_addr_base, WIN_RAM); [nu->driver] [nu->driver] – udelay (143); [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [nu->driver]- /очистить память */[QUEUE_SIZE] [QUEUE_SIZE] – для (tmp = base_addr; tmp driver] – -> loc_addr_base, WIN_RAM + RAM_SIZE); [QUEUE_SIZE] [QUEUE_SIZE] – для (tmp = base_addr; tmp loc_addr_base, WIN_RAM); [QUEUE_SIZE] [QUEUE_SIZE] -} [QUEUE_SIZE] [nu->driver] – [QUEUE_SIZE] [QUEUE_SIZE] – retval = __cyz_load_fw (fw, “Cyclom-Z”, почтовый ящик, base_addr, NULL); [MAX_CHAN] [QUEUE_SIZE] – release_firmware (прошивка); [MAX_CHAN] [QUEUE_SIZE] – если (retval) [MAX_CHAN] [nu->driver] – goto err; [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – / завершить загрузочную и стартовую платы / [MAX_CHAN] [MAX_CHAN] – cy_writel (& ctl_addr-> loc_addr_base, WIN_CREG); [MAX_CHAN] [nu->driver] – cy_writel (& cust-> cpu_start, 0 ); [MAX_CHAN] [MAX_CHAN] – cy_writel (& ctl_addr-> loc_addr_base, WIN_RAM); [QUEUE_SIZE] [6] – i = 0; [nu->driver] [QUEUE_SIZE] – пока ((standing = readl (& fid-> подпись))! = ZFIRM_ID && i ++ <71) [MAX_CHAN] [MAX_CHAN] - msleep (140); [MAX_CHAN] [QUEUE_SIZE] - if (status! = ZFIRM_ID) {[nu->driver] [MAX_CHAN] – если (standing == ZFIRM_HLT) {[MAX_CHAN] [6] – dev_err (& pdev-> dev, “нужен внешний источник питания” [nu->driver] [MAX_CHAN] – «для этого количества портов. Прошивка остановлена ​​и “[nu->driver] [QUEUE_SIZE] – «сброс платы. n»); [MAX_CHAN] [QUEUE_SIZE] – retval = -EIO; [nu->driver] [MAX_CHAN] – goto err; [MAX_CHAN] [QUEUE_SIZE] -} [nu->driver] [6] – dev_warn (& pdev -> dev, “fid-> signature = 0x% x … Ready” [MAX_CHAN] [QUEUE_SIZE] – “еще раз n “, статус);[nu->driver] [MAX_CHAN] – whereas ((standing = readl (& fid-> signature))! = ZFIRM_ID && [MAX_CHAN] [nu->driver] – i ++ <255 ) [QUEUE_SIZE] [MAX_CHAN] - msleep (140); [MAX_CHAN] [6] - if (status! = ZFIRM_ID) {[QUEUE_SIZE] [QUEUE_SIZE] - dev_err (& pdev-> dev, “Совет не запущен в 51 секунд! “[QUEUE_SIZE] [nu->driver]- “Сдаваться. (fid-> signature = 0x% x) n “, [MAX_CHAN] [MAX_CHAN]- статус);[QUEUE_SIZE] [MAX_CHAN] – dev_info (& pdev-> dev, «Предупреждение : если вы» [MAX_CHAN] [6] – «Обновление FW, пожалуйста, выключите и снова включите» [MAX_CHAN] [QUEUE_SIZE] – «система перед загрузкой нового FW в» [QUEUE_SIZE] [MAX_CHAN] – «Киклады-Z. N»); [MAX_CHAN] [6] – [MAX_CHAN] [QUEUE_SIZE] – если (__cyz_fpga_loaded (ctl_addr)) [QUEUE_SIZE] [nu->driver] – plx_init (pdev, irq, ctl_addr); [MAX_CHAN] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – retval = -EIO; [MAX_CHAN] [MAX_CHAN] – перейти к ошибке; [MAX_CHAN] [6] -} [MAX_CHAN] [QUEUE_SIZE] – dev_dbg (& pdev-> dev, «Прошивка запущена через% d секунд. n», [QUEUE_SIZE] [MAX_CHAN] – я / 37); [nu->driver] [6] -} 02010203 [MAX_CHAN] – pt_zfwctrl = base_addr + readl (& fid-> zfwctrl_addr); [MAX_CHAN] [6] – [MAX_CHAN] [QUEUE_SIZE] – dev_dbg (& pdev-> dev, “fid =>% p, zfwctrl_addr =>% x, npt_zfwctrl =>% p n “, [nu->driver] [MAX_CHAN] – base_addr + ID_ADDRESS, readl (& fid-> zfwctrl_addr), [MAX_CHAN] [6] – base_addr + readl (& fid-> zfwctrl_addr)); [MAX_CHAN] [MAX_CHAN] – [QUEUE_SIZE] [QUEUE_SIZE] – nchan = readl (& pt_zfwctrl-> board_ctrl.n_channel); [QUEUE_SIZE] [QUEUE_SIZE] – dev_info (& pdev-> dev, “Прошивка Cyclades-Z загружена: версия =% x, ports =% u n”, [MAX_CHAN] [MAX_CHAN] – readl (& pt_zfwctrl-> board_ctrl.fw_version), nchan); [MAX_CHAN] 010001 – [MAX_CHAN] [MAX_CHAN] – если (nchan == 0) {[MAX_CHAN] [6] – dev_warn (& pdev-> dev, “порты Cyclades-Z не найдены. Пожалуйста “[nu->driver] [QUEUE_SIZE] – «проверьте соединение между хост-картой Z и» [QUEUE_SIZE] [QUEUE_SIZE] – «последовательные расширители. n»); [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – если (__c yz_fpga_loaded (ctl_addr)) [QUEUE_SIZE] [nu->driver] – plx_init (pdev, irq, ctl_addr); [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – dev_info (& pdev-> dev, ” Обнаружено нулевое количество портов. Доска “

[QUEUE_SIZE] – «сброс. n»); [nu->driver] [6] – retval = 0; [MAX_CHAN] [QUEUE_SIZE] – goto err; [nu->driver] [QUEUE_SIZE] -} [nu->driver] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – cy_writel (& pt_zfwctrl-> board_ctrl.op_system, C_OS_LINUX); [MAX_CHAN] [QUEUE_SIZE] – cy_writel (& pt_zfwctrl-> board_ctrl.dr_version, DRIVER_VERSION); [QUEUE_SIZE] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – / [QUEUE_SIZE] [QUEUE_SIZE] – Ранняя прошивка не могла начать поиск команд. [nu->driver] [6] – включает прерывания микропрограммы для этих команд.

[MAX_CHAN] – / [QUEUE_SIZE] [QUEUE_SIZE] – cy_writel (& ctl_addr-> intr_ctrl_stat, readl (& ctl_addr-> intr_ctrl_stat) | [MAX_CHAN] [6] – (1 << )); [MAX_CHAN] [QUEUE_SIZE] - cy_writel (& ctl_addr-> intr_ctrl_stat, readl (& ctl_addr-> intr_ctrl_stat) | [MAX_CHAN] [MAX_CHAN] – 0x 00080000 UL); [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – вернуть нчан; [MAX_CHAN] [nu->driver] – err_rel: [QUEUE_SIZE] [MAX_CHAN] – release_firmware (fw ); [QUEUE_SIZE] [QUEUE_SIZE] – ошибка: [MAX_CHAN] [6] – вернуть retval; [nu->driver] [MAX_CHAN] -} [MAX_CHAN] [MAX_CHAN] – [QUEUE_SIZE] [QUEUE_SIZE] – static int cy_pci_probe (struct pci_dev pdev, [nu->driver] [6] – const struct pci_device_id ent) [MAX_CHAN] [6] – {[QUEUE_SIZE] [QUEUE_SIZE] – struct cyclades_card card; [MAX_CHAN] [QUEUE_SIZE] – void __iomem addr0 = NULL, addr2 = NULL; [nu->driver] [MAX_CHAN] – char card_name = NULL; [MAX_CHAN] [6] – u почтовый ящик; [nu->driver] [QUEUE_SIZE] – беззнаковый int device_id, nchan = 0, card_no, i , j; [QUEUE_SIZE] [QUEUE_SIZE] – unsigned char plx_ver; [QUEUE_SIZE] [MAX_CHAN] – int retval, irq;

[6] – [nu->driver] [QUEUE_SIZE] – retval = pci_enable_device (pdev); [MAX_CHAN] [MAX_CHAN] – если (retval) {[MAX_CHAN] [QUEUE_SIZE] – dev_err (& pdev-> dev, “невозможно включить устройство n”); 12100 [6] – goto err; [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – / чтение конфигурации PCI область */[nu->driver] [MAX_CHAN] – irq = pdev-> irq; [MAX_CHAN] [QUEUE_SIZE] – device_id = pdev- > устройство & ~ PCI_DEVICE_ID_MASK; 15410 [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – # если определено (__ alpha __) [MAX_CHAN] [MAX_CHAN] – если (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo) {/ ниже 1M? / [MAX_CHAN] [QUEUE_SIZE] – dev_err (& pdev-> dev, «Cyclom-Y / PCI не поддерживается для низкого уровня» [QUEUE_SIZE] [QUEUE_SIZE] – «адреса в системах Alpha. n»); [MAX_CHAN] [QUEUE_SIZE] – retval = -EIO; [nu->driver] [nu->driver] – goto err_dis; [QUEUE_SIZE] [QUEUE_SIZE] -} [nu->driver] [MAX_CHAN] – # endif [QUEUE_SIZE] [QUEUE_SIZE] – если (device_id == PCI_DEVICE_ID_CYCLOM_Z_Lo) {[6] [MAX_CHAN] – dev_err (& pdev- > dev, «Cyclades-Z / PCI не поддерживается для низкого уровня» [MAX_CHAN] [MAX_CHAN] – «адреса n»); [QUEUE_SIZE] [nu->driver] – retval = -EIO; [MAX_CHAN] [MAX_CHAN] – goto err_dis; 10102 [nu->driver] -} [QUEUE_SIZE] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN]- если ( pci_resource_flags (pdev, 2) & IORESOURCE_IO) {[MAX_CHAN] [MAX_CHAN] – dev_warn (& pdev-> dev, “Некорректный бит ввода-вывода PCI набор. Игнорирование “[QUEUE_SIZE] [MAX_CHAN] – «это … n»); [MAX_CHAN] [6] – pdev-> useful resource [2]. flags & = ~ IORESOURCE_IO ; [QUEUE_SIZE] [QUEUE_SIZE] -} [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – retval = pci_request_regions (pdev, “cyclades”); [nu->driver] [QUEUE_SIZE] – if (retval) {[nu->driver] [QUEUE_SIZE] – dev_err (& pdev-> dev, “не удалось зарезервировать ресурсы n “); [MAX_CHAN] [MAX_CHAN] – goto err_dis; [QUEUE_SIZE] [MAX_CHAN] -} [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [6] – retval = -EIO ; [QUEUE_SIZE] [QUEUE_SIZE] – if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo || [MAX_CHAN] [QUEUE_SIZE] – device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi) {[MAX_CHAN] [QUEUE_SIZE] – card_name = “Cyclom-Y”; [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – addr0 = ioremap (pci_resource_start (pdev, 0), [nu->driver] [6] – CyPCI_Yctl); [QUEUE_SIZE] [QUEUE_SIZE] – если (addr0 == NULL) {[MAX_CHAN] [QUEUE_SIZE] – dev_err (& pdev-> dev, «невозможно переназначить регион ctl n»); [MAX_CHAN] [6] – goto err_reg; [6] -} [MAX_CHAN] [MAX_CHAN] – addr2 = ioremap (pci_resource_start (pdev, 2), [MAX_CHAN] [6] – CyPCI_Ywin); [MAX_CHAN] [QUEUE_SIZE] – if (addr2 == NULL) {[nu->driver] [MAX_CHAN] – dev_err (& pdev-> dev, «невозможно переназначить базовую область n») ; [QUEUE_SIZE] [QUEUE_SIZE] – goto err_unmap; [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [MAX_CHAN] – [QUEUE_SIZE] [6] – nchan = CyPORTS_PER_CHIP cyy_init_card (адрес2, 1); [6] [MAX_CHAN] – если (nchan == 0) {[MAX_CHAN] [QUEUE_SIZE] – dev_err (& pdev-> dev, “Хост-карта Cyclom-Y PCI без” [QUEUE_SIZE] [QUEUE_SIZE] – “Последовательные модули n”); [MAX_CHAN] [QUEUE_SIZE] – goto err_unmap; [QUEUE_SIZE] [nu->driver] -} [nu->driver] [QUEUE_SIZE] -} else if (device_id == PCI_DEVICE_ID_CYCLOM_Z_Hi) {[MAX_CHAN] [QUEUE_SIZE] – struct RUNTIME _ 12100 __iomem ctl_addr; [MAX_CHAN] [6] – [nu->driver] [QUEUE_SIZE] – ctl_addr = addr0 = ioremap (pci_resource_start (pdev , 0), [QUEUE_SIZE] [MAX_CHAN] – CyPCI_Zctl); [MAX_CHAN] [QUEUE_SIZE] – если (адрес0 == NULL) {[MAX_CHAN] [MAX_CHAN] – dev_err (& pdev-> dev, “невозможно переназначить регион ctl n”); 16450 [QUEUE_SIZE] – goto err_reg; [MAX_CHAN] [MAX_CHAN] -} [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – / Отключить прерывания на PLX перед его сброс / [QUEUE_SIZE] [QUEUE_SIZE] – cy_writew (& ctl_addr-> intr_ctrl_stat, [MAX_CHAN] [QUEUE_SIZE] – readw (& ctl_addr-> intr_ctrl_stat) & ~ 0x0 989); [nu->driver] [6] – [nu->driver] [6] – plx_init (pdev, irq, addr0); [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [nu->driver] – mailbox = readl (& ctl_addr-> mail_box_0); [MAX_CHAN] [6] – [nu->driver] [QUEUE_SIZE] – addr2 = ioremap (pci_resource_start (pdev, 2), [MAX_CHAN] [nu->driver] – почтовый ящик == ZE_V1? CyPCI_Ze_win: CyPCI_Zwin); [QUEUE_SIZE] [nu->driver] – if (addr2 == NULL) {[QUEUE_SIZE] [QUEUE_SIZE] – dev_err (& pdev-> dev, «невозможно переназначить базовую область n»); [MAX_CHAN] [6] – goto err_unmap; [nu->driver] [MAX_CHAN] -} [nu->driver] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – если (почтовый ящик == ZE_V1) {[MAX_CHAN] [6] – card_name = “Cyclades-Ze”; [MAX_CHAN] [nu->driver]- } еще { [QUEUE_SIZE] [MAX_CHAN] – card_name = “Cyclades-8Zo”; [MAX_CHAN] [6] – # ifdef CY_PCI_DEBUG [MAX_CHAN] [MAX_CHAN] – если (почтовый ящик == ZO_V1) {[QUEUE_SIZE] [MAX_CHAN] – cy_writel (& ctl_addr-> loc_addr_base, WIN_CREG); [MAX_CHAN] [QUEUE_SIZE] – dev_info (& pdev-> dev, “Cyclades-8Zo / PCI: FPGA” [MAX_CHAN] [6]- “я бы % lx, ver% lx n “, (ulong) (0xff & [MAX_CHAN] [MAX_CHAN] – readl (& ((struct CUSTOM_REG адрес2) -> [nu->driver] [nu->driver] – fpga_id)), (ulong) (0xff & [nu->driver] [QUEUE_SIZE] – readl (& ((struct CUSTOM_REG addr2) -> [MAX_CHAN] [QUEUE_SIZE] – fpga_version))); [QUEUE_SIZE] [QUEUE_SIZE] – cy_writel (& ctl_addr-> loc_addr_base, WIN_RAM); [nu->driver] [6]- } еще {[nu->driver] [QUEUE_SIZE] – dev_info (& pdev-> dev, “Cyclades-Z / PCI: New” [QUEUE_SIZE] [MAX_CHAN] – Доска “Cyclades-Z”. ПЛИС не загружена n “); [nu->driver] [QUEUE_SIZE] -} [MAX_CHAN] [6] – # endif [MAX_CHAN] [MAX_CHAN] – / Следующее очищает слово идентификатора прошивки. [QUEUE_SIZE] [MAX_CHAN] – гарантирует, что водитель не будет пытаться поговорить с [nu->driver] [QUEUE_SIZE] – плата до тех пор, пока она не будет должным образом инициализирована. [MAX_CHAN] [QUEUE_SIZE] – / [nu->driver] [QUEUE_SIZE] – если ((почтовый ящик == ZO_V1) || (почтовый ящик == ZO_V2)) [QUEUE_SIZE] [MAX_CHAN] – cy_writel (addr2 + ID_ADDRESS, 0L); [QUEUE_SIZE] [QUEUE_SIZE] -} [nu->driver] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – retval = cyz_load_fw (pdev, addr2, addr0 , irq); [QUEUE_SIZE] [MAX_CHAN] – если (retval <= 0) [MAX_CHAN] [6] - goto err_unmap; [MAX_CHAN] [QUEUE_SIZE] - nchan = retval; [MAX_CHAN] [MAX_CHAN] -}

[QUEUE_SIZE] – [MAX_CHAN] [6] – если ((cy_next_channel + nchan)> NR_PORTS) {[QUEUE_SIZE] [MAX_CHAN] – dev_err (& pdev-> dev, «Cyclades-8Zo / PCI найден, но нет» [MAX_CHAN] [QUEUE_SIZE] – «каналы доступны. Измените NR_PORTS в “[MAX_CHAN] [QUEUE_SIZE] – “cyclades.c и перекомпилируйте ядро. n”); [QUEUE_SIZE] [MAX_CHAN] – goto err_unmap; [nu->driver] [QUEUE_SIZE] -} [QUEUE_SIZE] [MAX_CHAN] – / заполняем следующий c Доступна структура y_card / [nu->driver] [MAX_CHAN] – для (card_no = 0; card_no driver] [6] – if (card-> base_addr == NULL) [MAX_CHAN] [MAX_CHAN]- перерыв;[MAX_CHAN] [QUEUE_SIZE] -} [nu->driver] [QUEUE_SIZE] – если (card_no == NR_CARDS ) {/ Cy_cards больше нет / [MAX_CHAN] [QUEUE_SIZE] – dev_err (& pdev-> dev, “Cyclades-8Zo / PCI обнаружен , но нет “

[nu->driver] – «можно использовать больше карт. Измените NR_CARDS в “[MAX_CHAN] [QUEUE_SIZE] – “cyclades.c и перекомпилируйте ядро. n”); [MAX_CHAN] [nu->driver] – goto err_unmap; [QUEUE_SIZE] [QUEUE_SIZE] -} [QUEUE_SIZE] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo || [QUEUE_SIZE] [MAX_CHAN] – device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi) {[MAX_CHAN] [6] – / назначить IRQ / [MAX_CHAN] [QUEUE_SIZE] – retval = request_irq (irq, cyy_interrupt, [MAX_CHAN] [QUEUE_SIZE] – IRQF_SHARED, «Циклом-Y», карточка); [MAX_CHAN] [nu->driver]- если ( retval) {[QUEUE_SIZE] [MAX_CHAN] – dev_err (& pdev-> dev, “не удалось выделить IRQ n”); [MAX_CHAN] [QUEUE_SIZE] – goto err_unmap; [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [MAX_CHAN] – card-> num_chips = nchan / CyPORTS_PER_CHIP; [MAX_CHAN] [MAX_CHAN]- } еще {

[QUEUE_SIZE] – struct FIRM_ID __iomem firm_id = addr2 + ID_ADDRESS; [nu->driver] [QUEUE_SIZE] – struct ZFW_CTRL __iomem zfw_ctrl; [MAX_CHAN] [6] –

[MAX_CHAN] – zfw_ctrl = addr2 + (readl (& firm_id-> zfwctrl_addr) & 0xfffff ); [MAX_CHAN] [MAX_CHAN] – [QUEUE_SIZE] [nu->driver] – card-> hw_ver = mailbox; [MAX_CHAN] [QUEUE_SIZE] – card-> num_chips = (unsigned int) -1; [MAX_CHAN] [QUEUE_SIZE] – card-> board_ctrl = & zfw_ctrl -> board_ctrl; [nu->driver] [QUEUE_SIZE] – # ifdef CONFIG_CYZ_INTR [QUEUE_SIZE] [MAX_CHAN] – / назначает IRQ, только если плата имеет IRQ / [QUEUE_SIZE] [QUEUE_SIZE] – если (irq! = 0 && irq! = 352) { [MAX_CHAN] [MAX_CHAN] – retval = request_irq (irq, cyz_interrupt, [MAX_CHAN] [6] – IRQF_ ПОДЕЛИТЬСЯ, “Киклады-Z”, карточка); [MAX_CHAN] [QUEUE_SIZE] – if (retval) {[QUEUE_SIZE] [QUEUE_SIZE] – dev_err (& pdev-> dev, «не удалось выделить IRQ n»); [MAX_CHAN] [MAX_CHAN] – goto err_unmap; [MAX_CHAN] [MAX_CHAN] -} [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [6] – # endif / CONFIG_CYZ_INTR / [MAX_CHAN] [6] -} [QUEUE_SIZE] [MAX_CHAN] –

[QUEUE_SIZE] – / установить cy_card / [nu->driver] [6] – card-> base_addr = addr2; [QUEUE_SIZE] [MAX_CHAN] – card-> ctl_addr.p 12100 = адрес0; 9600 [nu->driver] – card-> irq = irq; [QUEUE_SIZE] [QUEUE_SIZE] – card-> bus_index = 1; [MAX_CHAN] [QUEUE_SIZE] – card-> first_line = cy_next_channel; [MAX_CHAN] [MAX_CHAN] – card-> nports = nchan; [QUEUE_SIZE] [QUEUE_SIZE] – retval = cy_init_card (card); [MAX_CHAN] [QUEUE_SIZE] – если (retval)

[QUEUE_SIZE] – goto err_null; [QUEUE_SIZE] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – pci_set_drvdata (pdev, card); [QUEUE_SIZE] [MAX_CHAN] – 2106 – if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo || [QUEUE_SIZE] [QUEUE_SIZE] – device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi ) {[QUEUE_SIZE] [QUEUE_SIZE] – / разрешить прерывания в интерфейсе PCI / [QUEUE_SIZE] [6] – plx_ver = readb (addr2 + CyPLX_VER) & 0x0f; [QUEUE_SIZE] [QUEUE_SIZE] – переключатель (plx_ver) {[MAX_CHAN] [MAX_CHAN]- дело PLX _ 15410: [nu->driver] [QUEUE_SIZE] – cy_writeb (addr0 + 0x4c, 0x 74); [QUEUE_SIZE] [6]- перерыв;

[QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – case PLX _ 15410: [QUEUE_SIZE] [6] – case PLX _ 15410: [QUEUE_SIZE] [MAX_CHAN] – по умолчанию: / Старые платы, используйте PLX _ 16450 / [nu->driver] [6] – 0x0 989); [MAX_CHAN] [6]- перерыв;[nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] -} [nu->driver] [MAX_CHAN] -} [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – dev_info (& pdev-> dev, “% s / PCI #% d найдено:% d каналов начиная с” [MAX_CHAN] [QUEUE_SIZE] – “порт% d. n”, card_name, card_no + 1, nchan, cy_next_channel); [QUEUE_SIZE] [QUEUE_SIZE] – для (j = 0, i = cy_next_channel; я driver] [MAX_CHAN] – tty_port_register_device (& card-> ports [j]. порт, [MAX_CHAN] [QUEUE_SIZE] – cy_serial_driver, i, & pdev-> dev); [MAX_CHAN] [QUEUE_SIZE] – cy_next_channel + = nchan; [QUEUE_SIZE] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – вернуть 0; [MAX_CHAN] [MAX_CHAN] – err_null: [MAX_CHAN] [MAX_CHAN] – card-> base_addr = NULL ; [QUEUE_SIZE] [nu->driver] – free_irq (irq, card); [MAX_CHAN] [QUEUE_SIZE] – err_unmap: [MAX_CHAN] [QUEUE_SIZE] – iounmap (addr0); [MAX_CHAN] [QUEUE_SIZE] – если (адрес2) [nu->driver] [MAX_CHAN] – iounmap (addr2); [QUEUE_SIZE] [QUEUE_SIZE] – err_reg: [MAX_CHAN] [MAX_CHAN] – pci_release_regions (pdev); [MAX_CHAN] [MAX_CHAN] – err_dis: [QUEUE_SIZE] [QUEUE_SIZE] – pci_disable_device (pdev); [MAX_CHAN] [MAX_CHAN] – ошибка: [nu->driver] [QUEUE_SIZE] – вернуть retval; [MAX_CHAN] [QUEUE_SIZE] -} [nu->driver] [MAX_CHAN] – [QUEUE_SIZE] [MAX_CHAN] – static void cy_pci_remove (struct pci_dev pdev) [MAX_CHAN] [QUEUE_SIZE] – {

[QUEUE_SIZE] – struct cyclades_card cinfo = pci_get_drvdata (pdev); [MAX_CHAN] [MAX_CHAN] – int i без знака, канал; [nu->driver] [MAX_CHAN] – [nu->driver] [6] – / не Z со старым PLX / [MAX_CHAN] [nu->driver]- если (! cy_is_Z (cinfo) && (readb (cinfo-> base_addr + CyPLX_VER) & 0x0f ) == [MAX_CHAN] [MAX_CHAN] – PLX _ 12100) [MAX_CHAN] [QUEUE_SIZE] – cy_writeb (cinfo-> ctl_addr.p 12239 + 0x4c, 0); [MAX_CHAN] [QUEUE_SIZE]- еще

[QUEUE_SIZE] – # ifndef CONFIG_CYZ_INTR [nu->driver] [QUEUE_SIZE] – если (! cy_is_Z (cinfo)) [QUEUE_SIZE] [MAX_CHAN] – # endif [MAX_CHAN] [nu->driver] – cy_writew (& cinfo-> ctl_addr.p 15410 -> intr_ctrl_stat, [QUEUE_SIZE] [nu->driver] – readw (& cinfo-> ctl_addr.p 15410 -> intr_ctrl_stat) & [MAX_CHAN] [QUEUE_SIZE] – ~ 0x0 989); [MAX_CHAN] [6] – [nu->driver] [QUEUE_SIZE] – iounmap (cinfo-> base_addr); [QUEUE_SIZE] [nu->driver] – если (cinfo-> ctl_addr .п12100) [nu->driver] [6] – iounmap (cinfo -> ctl_addr.p 12100); [MAX_CHAN] 9060 – если (cinfo-> irq [QUEUE_SIZE] [6] – # ifndef CONFIG_CYZ_INTR [QUEUE_SIZE] [QUEUE_SIZE] – &&! cy_is_Z (cinfo) [QUEUE_SIZE] [nu->driver] – # endif / CONFIG_CYZ_INTR / [QUEUE_SIZE] [MAX_CHAN] -) [QUEUE_SIZE] [QUEUE_SIZE] – free_irq (cinfo-> irq, cinfo); [QUEUE_SIZE] [6] – pci_release_regions (pdev); [nu->driver] [nu->driver] – [MAX_CHAN] [nu->driver] – cinfo-> base_addr = NULL; [nu->driver] [QUEUE_SIZE] – для (channel = 0, i = cinfo-> first_line; я первая_строчка + [MAX_CHAN] [QUEUE_SIZE] – cinfo-> nports; i ++, канал ++) {[MAX_CHAN] [MAX_CHAN] – tty_unregister_device (cy_serial_driver, i); [MAX_CHAN] [6] – tty_port_destroy (& cinfo-> ports [chip]. порт); [nu->driver] [QUEUE_SIZE] -} [MAX_CHAN] [QUEUE_SIZE] – cinfo-> nports = 0; [QUEUE_SIZE] [QUEUE_SIZE] – kfree (cinfo-> порты); [QUEUE_SIZE] [QUEUE_SIZE] -} [MAX_CHAN] [QUEUE_SIZE] –

[nu->driver] – статическая структура pci_driver cy_pci_driver = {[MAX_CHAN] [MAX_CHAN] – .identify = “cyclades”, [QUEUE_SIZE] [MAX_CHAN] – .id_table = cy_pci_dev_id, [QUEUE_SIZE] [QUEUE_SIZE] – .probe = cy_pci_probe, [MAX_CHAN] [QUEUE_SIZE] – .take away = cy_pci_remove [MAX_CHAN] [6] -}; [nu->driver] [QUEUE_SIZE] – # endif [MAX_CHAN] [6] – [MAX_CHAN] [QUEUE_SIZE] – static int cyclades_proc_show (struct seq_file m, void v) [MAX_CHAN] [QUEUE_SIZE] – {[MAX_CHAN] [QUEUE_SIZE] – struct cyclades_port data; [MAX_CHAN] [QUEUE_SIZE] – unsigned int i, j; [QUEUE_SIZE] [MAX_CHAN] – __u 62 cur_jifs = jiffies; [nu->driver] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – seq_puts (m, «Dev TimeOpen BytesOut IdleOut BytesIn» [MAX_CHAN] [QUEUE_SIZE] – «Переполнение при простое Ldisc n “); [MAX_CHAN] [MAX_CHAN] – [nu->driver] [MAX_CHAN] – / Вывести по одной строке для каждого известного порта / [MAX_CHAN] [MAX_CHAN] – для (i = 0; я port.rely) {

[6] – / XXX – это номер ldisc стоит этого? / [QUEUE_SIZE] [QUEUE_SIZE] – struct tty_struct tty; [MAX_CHAN] [MAX_CHAN] – struct tty_ldisc ld; [QUEUE_SIZE] [QUEUE_SIZE] – int num = 0; [MAX_CHAN] [MAX_CHAN] – tty = tty_port_tty_get (& info-> порт ); [QUEUE_SIZE] [QUEUE_SIZE] – if (tty) {[QUEUE_SIZE] [6] – ld = tty_ldisc_ref (tty); [QUEUE_SIZE] [MAX_CHAN] – if (ld) {[MAX_CHAN] [MAX_CHAN] – num = ld-> ops-> num; [nu->driver] [QUEUE_SIZE] – tty_ldisc_deref ( ld); [MAX_CHAN] [MAX_CHAN] -} [nu->driver] [6] – tty_kref_put (tty); [MAX_CHAN] [MAX_CHAN] -} [nu->driver] [6] – seq_printf (m, “% 3d% 8lu% 35 lu% 8lu “[MAX_CHAN] [QUEUE_SIZE] – “% 36 lu% 8lu% 9lu% 6d n “, info-> line, [QUEUE_SIZE] [6] – (cur_jifs – info-> idle_stats.in_use) / [MAX_CHAN] [QUEUE_SIZE] – HZ, info-> idle_stats.xmit_bytes, [MAX_CHAN] [MAX_CHAN] – (cur_jifs – info-> idle_stats.xmit_idle) / [MAX_CHAN] [MAX_CHAN] – HZ, info-> idle_stats.recv_bytes, [QUEUE_SIZE] [MAX_CHAN] – (cur_jifs – info-> idle_stats.recv_idle) / [MAX_CHAN] [QUEUE_SIZE] – HZ, info-> idle_stats.overruns, [MAX_CHAN] [6] – число); [nu->driver] [MAX_CHAN]- } еще[MAX_CHAN] [QUEUE_SIZE] – seq_printf (m, “% 3d% 8lu% 39 lu% 8lu “[MAX_CHAN] [6] – “% 36 lu% 8lu% 9lu% 6ld n “, [QUEUE_SIZE] [QUEUE_SIZE] – информация-> строка, 0L, 0L, 0L, 0L, 0L, 0L, 0L); [MAX_CHAN] [6] -} [nu->driver] [nu->driver] – вернуть 0; [nu->driver] [QUEUE_SIZE] -} [QUEUE_SIZE] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – / Загрузка последовательного драйвера код инициализации! [QUEUE_SIZE] [nu->driver] – Аппаратные порты ввода / вывода сопоставляются со специальными символьными устройствами на [MAX_CHAN] [QUEUE_SIZE] – первый найденный, первый назначенный способ. То есть этот код ищет [MAX_CHAN] [MAX_CHAN] – для карт Cyclom в системе. Как только каждый обнаружен, он исследуется < irqc-> [MAX_CHAN] – чтобы узнать, сколько чипов (и, следовательно, сколько портов) присутствует. [MAX_CHAN] [MAX_CHAN] – Эти порты сопоставлены с портами tty и вверх в монотонном [MAX_CHAN] [nu->driver]- мода. Если 8-портовая карта заменена на 40 – карта порта, 98783 [6] – отображение портов на следующей карте изменится. [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [6] – Этот подход отличается от того, что используется в другом сериале [MAX_CHAN] [MAX_CHAN] – драйвер устройства, поскольку Cyclom более точно является мультиплексором 12100 [MAX_CHAN] – не просто объединение последовательных портов на одной карте. [QUEUE_SIZE] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – Если имеется больше карт с большим количеством портов, чем было [MAX_CHAN] [QUEUE_SIZE] – статически размещен выше, выводится предупреждение и 00090255 [6] – лишние порты игнорируются. [nu->driver] [MAX_CHAN] – / [MAX_CHAN] [MAX_CHAN] – [nu->driver] [MAX_CHAN] – static const struct tty_operations cy_ops знак равно [QUEUE_SIZE] – .open = cy_open, 2156 – .shut = cy_close, [MAX_CHAN] [QUEUE_SIZE] – .write = cy_write, [MAX_CHAN] [QUEUE_SIZE] -. put_char = cy_put_char, [MAX_CHAN] [MAX_CHAN] – .flush_chars = cy_flush_chars, [MAX_CHAN] [6] – .write_room = cy_write_room, [nu->driver] [QUEUE_SIZE] – .chars_in_buffer = cy_chars_in_buffer, [MAX_CHAN] [QUEUE_SIZE] – .flush_buffer = cy_flush_buffer, [nu->driver] [QUEUE_SIZE] – .ioctl = cy_ioctl, [MAX_CHAN] [QUEUE_SIZE] – .throttle = cy_throttle, [QUEUE_SIZE] [QUEUE_SIZE] – .unthrottle = cy_unthrottle, [nu->driver] [QUEUE_SIZE] – .set_termios = cy_set_termios, [QUEUE_SIZE] [MAX_CHAN] – .cease = cy_stop, [MAX_CHAN] [QUEUE_SIZE] -. begin = cy_start, [nu->driver] [MAX_CHAN] – .hangup = cy_hangup, [nu->driver] [MAX_CHAN] – .break_ctl = cy_break, [MAX_CHAN] [QUEUE_SIZE] – .wait_until_sent = cy_wait_until_sent, [QUEUE_SIZE] [QUEUE_SIZE] – .tiocmget = cy_tiocmget, [QUEUE_SIZE] [MAX_CHAN] – .tiocmset = cy_tiocmset,

[MAX_CHAN] – .get_icount = cy_get_icount, [QUEUE_SIZE] [MAX_CHAN] – .set_serial = cy_set_serial_info, [nu->driver] [QUEUE_SIZE] – .get_serial = cy_get_serial_info, [MAX_CHAN] [QUEUE_SIZE] – .proc_show = cyclades_proc_sh ой, [MAX_CHAN] [QUEUE_SIZE] -}; [MAX_CHAN] [6] – [nu->driver] [MAX_CHAN] – static int __init cy_init (void) [MAX_CHAN] [6] – {[nu->driver] [QUEUE_SIZE] – беззнаковые int nboards; [MAX_CHAN] [6] – int retval = -ENOMEM; [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [6] – cy_serial_driver = alloc_tty_driver (NR_PORTS); [MAX_CHAN] [QUEUE_SIZE] – если (! cy_serial_driver) [QUEUE_SIZE] [QUEUE_SIZE] – goto err; 02010203 [QUEUE_SIZE] – [MAX_CHAN] [6] – printk ( KERN_INFO “Драйвер Cyclades” CY_VERSION ” n”); [nu->driver] 05091998 – [QUEUE_SIZE] [MAX_CHAN] – / Инициализируем структуру tty_driver / [MAX_CHAN] [6] – [MAX_CHAN] [QUEUE_SIZE] – cy_serial_driver-> driver_name = “cyclades”; [nu->driver] [QUEUE_SIZE] – cy_serial_driver-> identify = “ttyC” “; [QUEUE_SIZE] [QUEUE_SIZE] – cy_serial_driver-> main = CYCLADES_MAJOR; [MAX_CHAN] [6] – cy_serial_driver-> minor_start = 0; [MAX_CHAN] [MAX_CHAN] – cy_serial_driver-> kind = TTY_DRIVER_TYPE_SERIAL ; [MAX_CHAN] [6] – cy_serial_driver-> subtype = SERIAL_TYPE_NORMAL; [QUEUE_SIZE] [MAX_CHAN] – cy_serial_driver-> init_termios = tty_std_termios; [MAX_CHAN] [MAX_CHAN] – cy_serial_driver-> init_termios.c_cflag = [nu->driver] [MAX_CHAN] – B 16450 | CS8 | КРЕД | HUPCL | CLOCAL; [QUEUE_SIZE] [QUEUE_SIZE] – cy_serial_driver-> flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; [6] [QUEUE_SIZE] – tty_set_operations (cy_serial_driver, & cy_ops); [QUEUE_SIZE] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – retval = tty_register_driver (cy_serial_driver); [QUEUE_SIZE] [MAX_CHAN] – if (retval) {[QUEUE_SIZE] [6] – printk (KERN_ERR “Не удалось зарегистрировать Последовательный драйвер Cyclades n “); [MAX_CHAN] [QUEUE_SIZE] – goto err_frtty; [MAX_CHAN] [6] -} [nu->driver] [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – / код ниже отвечает за поиск платы с. Каждый разный [MAX_CHAN] [QUEUE_SIZE] – тип платы имеет собственную процедуру обнаружения. Если доска найдена, [MAX_CHAN] [nu->driver] – следующая доступная структура cy_card устанавливается обнаружением [QUEUE_SIZE] [QUEUE_SIZE]- рутина. Эти функции отвечают за проверку [MAX_CHAN] [nu->driver] – наличие и обновление структур данных cy_card и cy_port [QUEUE_SIZE] [QUEUE_SIZE] – cy_next_channel. / [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [6] – / ищем платы isa / [nu->driver] [MAX_CHAN] – nboards = cy_detect_isa (); [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – # ifdef CONFIG_PCI [MAX_CHAN] [6] – / ищем платы pci / [MAX_CHAN] [6] – retval = pci_register_driver (& cy_pci_driver); [MAX_CHAN] [QUEUE_SIZE] – если (retval &&! nboards) {[MAX_CHAN] [6] – tty_unregister_driver (cy_serial_driver); [QUEUE_SIZE] [QUEUE_SIZE] – goto err_frtty; [QUEUE_SIZE] [6] -} [nu->driver] [QUEUE_SIZE] – # endif 230400 [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN]- возвращаться 0; [QUEUE_SIZE] [QUEUE_SIZE] – err_frtty: [nu->driver] [6] – put_tty_driver (cy_serial_driver); [QUEUE_SIZE] [nu->driver] – ошибка: [MAX_CHAN] [QUEUE_SIZE] – вернуть retval; [MAX_CHAN] [QUEUE_SIZE] -} / cy_init / [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – static void __exit cy_cleanup_module (void) [nu->driver] [QUEUE_SIZE] – {[MAX_CHAN] [MAX_CHAN] – struct cyclades_card card; [nu->driver] [MAX_CHAN] – unsigned int i, e1; [nu->driver] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – # ifndef CONFIG_CYZ_INTR [QUEUE_SIZE] [QUEUE_SIZE] – del_timer_sync (& cyz_timerlist); [MAX_CHAN] [6] – # endif / CONFIG_CYZ_INTR / [QUEUE_SIZE] [MAX_CHAN] – [QUEUE_SIZE] [MAX_CHAN] – e1 = tty_unregister_driver (cy_serial_driver); [nu->driver] [6] – если (e1) [MAX_CHAN] [QUEUE_SIZE] – printk (KERN_ERR “не удалось отменить регистрацию Cyclades серийный »[MAX_CHAN] [MAX_CHAN] – «драйвер (% d) n», e1); [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – # ifdef CONFIG_PCI [MAX_CHAN] [6] – pci_unregister_driver (& cy_pci_driver); [MAX_CHAN] [QUEUE_SIZE] – # endif [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – для (i = 0; я driver] [QUEUE_SIZE] – card = & cy_card [i]; [MAX_CHAN] [6] – если (card-> base_addr) {[QUEUE_SIZE] [MAX_CHAN]- /Чисто прерывать */[nu->driver] [QUEUE_SIZE] – cy_writeb (card-> base_addr + Cy_ClrIntr, 0); [MAX_CHAN] [MAX_CHAN] – iounmap (card-> base_addr); [MAX_CHAN] [QUEUE_SIZE] – если (card-> ctl_addr.p 12244) [nu->driver] [QUEUE_SIZE] – iounmap (card-> ctl_addr.p 12244); [QUEUE_SIZE] [6] – если (card-> irq [nu->driver] [QUEUE_SIZE] – # ifndef CONFIG_CYZ_INTR [nu->driver] [MAX_CHAN] – &&! cy_is_Z (card) [MAX_CHAN] [MAX_CHAN] – # endif / CONFIG_CYZ_INTR / [QUEUE_SIZE] [MAX_CHAN] -) [MAX_CHAN] [6] – free_irq (card-> irq, card); [nu->driver] [QUEUE_SIZE] – for (e1 = card-> first_line; e1 первая_строчка + [MAX_CHAN] [6] – card-> nports; e1 ++) [QUEUE_SIZE] [QUEUE_SIZE] – tty_unregister_device (cy_serial_driver, e1); [MAX_CHAN] [MAX_CHAN] – kfree (карта-> порты); [nu->driver] [QUEUE_SIZE] -} [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [6] – [nu->driver] [QUEUE_SIZE] – put_tty_driver (cy_serial_driver); [nu->driver] [MAX_CHAN] -} / cy_cleanup_module / [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – module_init (cy_init); [QUEUE_SIZE] [6] – module_exit ( cy_cleanup_module); [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [6] – ЛИЦЕНЗИЯ_МОДУЛЬ («GPL»); [MAX_CHAN] [6] – MODULE_VERSION (CY_VERSION); [MAX_CHAN] [MAX_CHAN] – MODULE_ALIAS_CHARDEV_MAJOR (CYCLADES_MAJOR); [nu->driver] [6] – MODULE_FIRMWARE (“cyzfirm.bin”); 15410 [QUEUE_SIZE] @@ – 365, 67 + 373, 38 @@ static LIST_HEAD (hvcs_structs); [QUEUE_SIZE] [QUEUE_SIZE] статический DEFINE_SPINLOCK ( hvcs_structs_lock); [MAX_CHAN] [MAX_CHAN] статический DEFINE_MUTEX (hvcs_init_mutex); [QUEUE_SIZE] [MAX_CHAN] -static void hvcs_unthrottle (struct tty_struct tty); [MAX_CHAN] [QUEUE_SIZE] – static void hvcs_throttle (struct tty_struct tty); [QUEUE_SIZE] [MAX_CHAN] – static irqreturn_t hvcs_handle_interrupt (int irq, void dev_instance); [nu->driver] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – static int hvcs_write (struct tty_struct tty, [MAX_CHAN] [6] – const unsigned char buf, int rely); [MAX_CHAN] 05091998 – статический int hvcs_write_room (struct tty_struct tty); [MAX_CHAN] [MAX_CHAN] – static int hvcs_chars_in_buffer (struct tty_struct tty); 00525004 [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – static int hvcs_has_pi (struct hvcs_struct hvcsd); [QUEUE_SIZE] [MAX_CHAN] – static void hvcs_set_pi (struct hvcs_partner_info pi, [QUEUE_SIZE] [QUEUE_SIZE] – struct hvcs_struct hvcsd); [MAX_CHAN] [QUEUE_SIZE] static int hvcs_get_pi (struct hvcs_struct hvcsd); [QUEUE_SIZE] [QUEUE_SIZE] static int hvcs_rescan_devices_list (void); [MAX_CHAN] [MAX_CHAN] – статический int hvcs_partner_connect (struct hvcs_struct hvcsd); [QUEUE_SIZE] [QUEUE_SIZE] static void hvcs_partner_free (struct hvcs_struct hvcsd); [QUEUE_SIZE] [QUEUE_SIZE] – static int hvcs_enable_device (struct hvcs_struct hvcsd, [MAX_CHAN] [QUEUE_SIZE] – uint 67 _ t unit_address, unsigned int irq, struct vio_dev dev); [nu->driver] [6] – [MAX_CHAN] [nu->driver] – static int hvcs_open (struct tty_struct tty, struct file filp); [MAX_CHAN] [6] – static void hvcs_close (struct tty_struct tty, struct file filp); [nu->driver] [QUEUE_SIZE] – static void hvcs_hangup (struct tty_struct tty); [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [6] – static int hvcs_probe (struct vio_dev dev, [QUEUE_SIZE] [QUEUE_SIZE] – const struct vio_device_id id); [QUEUE_SIZE] [nu->driver] – static int __init hvcs_module_init (void); [QUEUE_SIZE] [MAX_CHAN] – static void __exit hvcs_module_exit (void); [MAX_CHAN] [MAX_CHAN] static int hvcs_initialize (void); [MAX_CHAN] [QUEUE_SIZE] #outline HVCS_SCHED_READ 0x 19 16 19 0020 [nu->driver] [QUEUE_SIZE] @@ – 313, 37 + 0310, 34 @@ static int ipw_write_room (struct tty_struct linux_tty) [MAX_CHAN] [QUEUE_SIZE] / FIXME: Как именно здесь заблокирован tty-объект .. / [nu->driver] [QUEUE_SIZE] если (! tty) [MAX_CHAN] [QUEUE_SIZE] – возврат -ENODEV; [MAX_CHAN] [QUEUE_SIZE] + возврат 0; [QUEUE_SIZE] [MAX_CHAN] если (! tty-> port.rely) [QUEUE_SIZE] [6] – return -EINVAL;

[QUEUE_SIZE] + возврат 0; [MAX_CHAN] [QUEUE_SIZE] room = IPWIRELESS_TX_QUEUE_SIZE – tty-> tx_bytes_queued; [MAX_CHAN] [MAX_CHAN] если (комната <0) [MAX_CHAN] [QUEUE_SIZE] @@ - 726, 38 + 725, 8 @@ int ipwireless_tty_init (недействительно) [QUEUE_SIZE] [QUEUE_SIZE] void ipwireless_tty_release (void) [MAX_CHAN] [6] {[MAX_CHAN] [MAX_CHAN] - int ret; [QUEUE_SIZE] [nu->driver] – [MAX_CHAN] [QUEUE_SIZE] – ret = tty_unregister_driver (ipw_tty_driver); [QUEUE_SIZE] [QUEUE_SIZE] + tty_unregister_driver (ipw_tty_driver); [MAX_CHAN] [QUEUE_SIZE] put_tty_driver (ipw_tty_driver); [MAX_CHAN] [MAX_CHAN] – если (ret! = 0) [MAX_CHAN] [6] – printk (KERN_ERR IPWIRELESS_PCCARD_NAME [QUEUE_SIZE] [QUEUE_SIZE] – “: tty_unregister_driver не удалось с кодом% d n”, ret); [MAX_CHAN] [QUEUE_SIZE]} [MAX_CHAN] [QUEUE_SIZE] int ipwireless_tty_is_modem (struct ipw_tty tty) [nu->driver] [QUEUE_SIZE] diff –git a / drivers /tty/isicom.cb/drivers/tty/isicom.c

удалено файловый режим 435906

индекс 3b2f9fb 19 aa0a .. 16

– – а / драйверы / tty / isicom.c

+++ / dev / null [QUEUE_SIZE] [MAX_CHAN] @@ -1, 1847 +0,0 @@ [MAX_CHAN] [MAX_CHAN] – // Идентификатор лицензии SPDX: GPL-2.0 + [QUEUE_SIZE] [6] – / [nu->driver] [QUEUE_SIZE] – Исходный код драйвера, предоставленный Multi- Техника 24000000 [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN]- Изменения[nu->driver] [QUEUE_SIZE] – 1/9 / 137 alan@lxorguk.ukuu.org.uk [nu->driver] [QUEUE_SIZE] – Слияние с деревом ядра 2.0.x [MAX_CHAN] [nu->driver] – Получить и использовать официальные основные / второстепенные [nu->driver] [QUEUE_SIZE] – Загрузчик переключился на разное устройство[nu->driver] [QUEUE_SIZE] – (исправлена ​​ошибка проверки диапазона как побочный эффект) [nu->driver] [6] – Очистка печати [nu->driver] [6] – 9 / 38 / 146 alan @ lxorguk. ukuu.org.uk [MAX_CHAN] [MAX_CHAN] – Грубый перенос на 2.1.x [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – 36 / 6 / 137 sameer Слил драйверы ISA и PCI в [nu->driver] [MAX_CHAN] – новый унифицированный драйвер. [MAX_CHAN] [MAX_CHAN] – [nu->driver] [MAX_CHAN] – 3/9 / 135 sameer Добавлена ​​поддержка ISI 5302 открытки.[nu->driver] [6] – [nu->driver] [MAX_CHAN] – 43 / 9 / 137 sameer Мы больше не устанавливаем низкий уровень RTS. [nu->driver] [QUEUE_SIZE] – Это для предотвращения прошивки [MAX_CHAN] [MAX_CHAN] – чтобы не запутаться. 010001 [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – 55 / 36 / 137 Sameer Косметические изменения: Теперь драйвер 010001 [QUEUE_SIZE] – выгружает информацию о количестве портов 491 – вместе с адресом ввода / вывода и IRQ.

[QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – 00000040 / 40 / 141 Sameer Исправлено проблема с разделением IRQ. [MAX_CHAN] [nu->driver] – [nu->driver] [MAX_CHAN] – 38 / 5 / 0018 sameer Исправлено isicom_shutdown_board () [QUEUE_SIZE] [QUEUE_SIZE] – не понижать DTR на всех портах [MAX_CHAN] [QUEUE_SIZE] – когда последний порт на карте [MAX_CHAN] [MAX_CHAN]- закрыто.[MAX_CHAN] [6] – [QUEUE_SIZE] [MAX_CHAN] – 35 / 5 / 15 тот же сигнал добавлена ​​команда настройки маски 010001 [MAX_CHAN] – в isicom_setup_port и [MAX_CHAN] [QUEUE_SIZE] – isicom_shutdown_port. [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – 55 / 5 / 16 sameer Драйвер теперь поддерживает SMP. [QUEUE_SIZE] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [6] – 56 / 36 / 0018 Vinayak P Risbud Исправлена ​​проблема сбоя водителя [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – 23 / 19 / 00000020 anil .s Добавлена ​​поддержка сброса [MAX_CHAN] [QUEUE_SIZE] – внутренние модемы на картах ISI. [MAX_CHAN] [6] – [MAX_CHAN] [MAX_CHAN] – 32 / 022 / 00000020 anil .s Обновил драйвер для ядра [MAX_CHAN] [MAX_CHAN] – 2.4.x [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – / 25 / 21 Кевин Исправлена ​​проблема загрузки прошивки с [nu->driver] [MAX_CHAN] – Карта ISIHP-4X [QUEUE_SIZE] [6] –

[QUEUE_SIZE] – 63 / / 20 anil .s Исправлен удаленный вход через [nu->driver] [6] – Проблема с портом ISI. Теперь ссылка [MAX_CHAN] [QUEUE_SIZE] – не опускается до пароля

[MAX_CHAN]- Подсказка.[QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – 25 / 27 / 20 anil .s Исправлена ​​проблема с разделением IRQ [QUEUE_SIZE] [6] – среди карт ISI-PCI. [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – 022 / 29 / 0020 anil .s Добавлена ​​поддержка отображения версии [QUEUE_SIZE] [QUEUE_SIZE] – информация во время insmod, а также модуль [QUEUE_SIZE] [MAX_CHAN] – распечатка по lsmod. 25000000 [MAX_CHAN] – [MAX_CHAN] [6] – 36 / 26 / 00000020 anil .s Внесены изменения в исходный код [MAX_CHAN] [6] – файл и сценарий установки, чтобы [nu->driver] [QUEUE_SIZE] – можно использовать ту же установку для[MAX_CHAN] [MAX_CHAN] – ядро ​​2.2.x и 2.4.x [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – 25 / 28 / 0020 anil .s Теперь мы сбрасываем и dtr, и rts во время [QUEUE_SIZE] [nu->driver] – shutdown_port а так же поднять их [MAX_CHAN] [6] – во время isicom_config_port. [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [6] – 34 / 28 / 19 acme@conectiva.com.br использовать способный, а не suser, делать [MAX_CHAN] [MAX_CHAN] – restore_flags при сбое в [MAX_CHAN] [MAX_CHAN] – isicom_send_break, проверьте put_user [QUEUE_SIZE] [QUEUE_SIZE]- результат[nu->driver] [6] – [QUEUE_SIZE] [nu->driver] – 35 / 022 / 24 Ранджит Добавлена ​​поддержка 300 Кбит / с и 99 Кбит / с [QUEUE_SIZE] [QUEUE_SIZE] – Индекс скорости расширен до [nu->driver] [MAX_CHAN] – [MAX_CHAN] [6] – 47 / 22 / 22 Ранджит Создан для работы на сервере Linux Superior. [MAX_CHAN] 2058 [MAX_CHAN] –

[QUEUE_SIZE] – 36 / 36 / 023 Ravindra Сделано для работы с Fedora Core 1 [QUEUE_SIZE] – Распространение Crimson Hat [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – 25 / 19 / 27 Алан Кокс объединил нити ISI и базового ядра [MAX_CHAN] [6] – в один драйвер 2.6 [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [6] –

[QUEUE_SIZE] – [QUEUE_SIZE] [6] – Для использования этого драйвера вам также потребуется пакет поддержки. Ты[nu->driver] [QUEUE_SIZE] – можно найти в формате RPM на [MAX_CHAN] [QUEUE_SIZE] – ftp://ftp.linux.org.uk/pub/linux/alan[MAX_CHAN] [6] – [MAX_CHAN] [nu->driver] – Вы можете найти Оригинальные инструменты для этого прямо от Multitech 81801 [QUEUE_SIZE] – ftp://ftp.multitech.com/ISI-Playing cards/ [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – Установив карты, опции модуля (/and so on/modprobe.d/)00525003 [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – параметры isicom io = card1, card2, card3, card4 irq = card1, карта2, карта3, карта4 [QUEUE_SIZE] [MAX_CHAN] – [nu->driver] [6] – Пропустите эти записи для досок, которые у вас не установлены. < cinfo-> [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE]- ДЕЛАТЬ[MAX_CHAN] [QUEUE_SIZE] – Тестирование слиянием [QUEUE_SIZE] [QUEUE_SIZE] – 90 – битовая проверка [nu->driver] [6] – / [MAX_CHAN] [6] – [QUEUE_SIZE] [QUEUE_SIZE] – # определить pr_fmt (fmt) KBUILD_MODNAME “:” fmt [QUEUE_SIZE] [6] – [MAX_CHAN] [MAX_CHAN]-#включать [nu->driver] [6]-#включать [MAX_CHAN] [MAX_CHAN]-#включать [QUEUE_SIZE] [MAX_CHAN]-#включать [nu->driver] [MAX_CHAN]-#включать [nu->driver] [MAX_CHAN]-#включать <= 0 || tty-> [nu->driver] [MAX_CHAN]-#включать < cinfo-> [MAX_CHAN] [MAX_CHAN]-#включать 9060 [MAX_CHAN]-#включать [MAX_CHAN] [MAX_CHAN]-#включать [nu->driver] [MAX_CHAN]-#включать [MAX_CHAN] [QUEUE_SIZE]-#включать [MAX_CHAN] [QUEUE_SIZE]-#включать [MAX_CHAN] [QUEUE_SIZE] – # включать [nu->driver] [6]-#включать [MAX_CHAN] [6] –

[nu->driver]-#включать [MAX_CHAN] [MAX_CHAN]-#включать <0 nr flags> [MAX_CHAN] [nu->driver] – [nu->driver] [QUEUE_SIZE]-#включать [MAX_CHAN] [MAX_CHAN] – [nu->driver] [MAX_CHAN]-#включать < cs + h-> [nu->driver] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – # определить InterruptTheCard (base) outw (0, (base ) + 0xc) [MAX_CHAN] [QUEUE_SIZE] – # определить ClearInterrupt (base) inw ((base) + 0x0a) [MAX_CHAN] [nu->driver] – [QUEUE_SIZE] [6] – # ifdef DEBUG [MAX_CHAN] [QUEUE_SIZE] – # outline isicom_paranoia_check (a, b, c) __isicom_paranoia_check ((a), (b), (c)) [nu->driver] [nu->driver]-#еще[QUEUE_SIZE] [MAX_CHAN] – # outline isicom_paranoia_check (a, b, c) 0 [QUEUE_SIZE] [MAX_CHAN] – # endif [nu->driver] [6] – [QUEUE_SIZE] [MAX_CHAN] – статический int isicom_probe (struct pci_dev *, const struct pci_device_id ; [QUEUE_SIZE] [QUEUE_SIZE] – static void isicom_remove (struct pci_dev ; [MAX_CHAN] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – статическая const struct pci_device_id isicom_pci_tbl знак равно [QUEUE_SIZE] – {PCI_DEVICE (VENDOR_ID, 0x 2104)}, [MAX_CHAN] [6] – {PCI_DEVICE (VENDOR_ID, 0x [channel + chip 4] )}, [nu->driver] [QUEUE_SIZE] – {PCI_DEVICE (VENDOR_ID, 0x 2380)}, [QUEUE_SIZE] [QUEUE_SIZE] – {PCI_DEVICE (VENDOR_ID, 0x 2400)}, [MAX_CHAN] [6] – {PCI_DEVICE (VENDOR_ID, 0x [NR_CARDS] )}, [QUEUE_SIZE] [MAX_CHAN] – {PCI_DEVICE (VENDOR_ID, 0x [ARCH_TIMER_HYP_VIRT_PPI] )}, [nu->driver] [QUEUE_SIZE] – {PCI_DEVICE (VENDOR_ID, 0x [channel + chip 4] )}, [MAX_CHAN] [QUEUE_SIZE] – {PCI_DEVICE (VENDOR_ID, 0x 2416)}, [MAX_CHAN] [QUEUE_SIZE] – {PCI_DEVICE (VENDOR_ID, 0x [NR_CARDS] )}, [QUEUE_SIZE] [MAX_CHAN] – {0} [nu->driver] [6] -}; [MAX_CHAN] [QUEUE_SIZE] – MODULE_DEVICE_TABLE (p ci, isicom_pci_tbl); [QUEUE_SIZE] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – статическая структура pci_driver isicom_driver = {[QUEUE_SIZE] [MAX_CHAN] – .identify = “isicom”, [MAX_CHAN] [QUEUE_SIZE] – .id_table = isi com_pci_tbl, [QUEUE_SIZE] [QUEUE_SIZE] – .probe = isicom_probe, 2142 – .take away = isicom_remove [QUEUE_SIZE] [MAX_CHAN] -}; [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – static int prev_card = 3; / начало обслуживания isi_card [0] / [MAX_CHAN] [6] – статическая структура tty_driver isicom_normal; [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [6] – static void isicom_tx (struct timer_list unused); [QUEUE_SIZE] [QUEUE_SIZE] – static void isicom_start (struct tty_struct tty); [nu->driver] 1000000 – 814 – статический DEFINE_TIMER (tx, isicom_tx); 02010203 [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – / отображение индексов скорости передачи из linux defns в isi / [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN] – статический подписанный char linuxb_to_isib [] = {[MAX_CHAN] [QUEUE_SIZE] – -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 35, 36, 00000040, 40, , , 44, 46, 48 [QUEUE_SIZE] [MAX_CHAN] -}; [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – struct isi_board {[nu->driver] [6] – длинная база без знака; 10101 [QUEUE_SIZE] – int irq;

[QUEUE_SIZE] – символ без знака port_count; [nu->driver] [QUEUE_SIZE] – беззнаковый короткий статус; 10100 [6] – беззнаковый короткий port_status; / каждый бит для каждого порта / [MAX_CHAN] [QUEUE_SIZE] – беззнаковое короткое shift_count; 10103 [6] – struct isi_port ports; [MAX_CHAN] [6] – количество подписанных символов; [MAX_CHAN] [MAX_CHAN] – spinlock_t card_lock; / Блокировка всей карты 38 / 5 / 0018 -также / [MAX_CHAN] [QUEUE_SIZE] – длинные флаги без знака; [MAX_CHAN] [QUEUE_SIZE] – беззнаковый индекс int; [MAX_CHAN] [QUEUE_SIZE] -};

[QUEUE_SIZE] – [MAX_CHAN] [6] – struct isi_port {[MAX_CHAN] [QUEUE_SIZE] – короткая магия без знака; [MAX_CHAN] [QUEUE_SIZE] – struct tty_port port; [nu->driver] [MAX_CHAN] – и 42 канал;[MAX_CHAN] [QUEUE_SIZE] – u 41 статус;[nu->driver] [QUEUE_SIZE] – struct isi_board card; [nu->driver] [MAX_CHAN] – символ без знака xmit_buf; [QUEUE_SIZE] [QUEUE_SIZE] – int xmit_head ; [MAX_CHAN] [QUEUE_SIZE] – int xmit_tail; [MAX_CHAN] [QUEUE_SIZE] – int xmit_cnt; [MAX_CHAN] [QUEUE_SIZE] -}; [MAX_CHAN] [QUEUE_SIZE] –

[nu->driver] – статическая структура isi_board isi_card [card_no]; [MAX_CHAN] [QUEUE_SIZE] – статический struct isi_port isi_ports [card_no]; [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [6] – / [nu->driver] [MAX_CHAN] – Функции блокировки для блокировки уровня карты. Нам нужно владеть обоими [QUEUE_SIZE] [MAX_CHAN] – блокировка ядра для карты и наличие карты в положении, которое [MAX_CHAN] [QUEUE_SIZE] – он хочет поговорить. 12244 [QUEUE_SIZE] – / [nu->driver] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – static int WaitTillCardIsFree (длинная база без знака) [QUEUE_SIZE] [MAX_CHAN] – {[MAX_CHAN] [QUEUE_SIZE] – unsigned int rely = 0; [MAX_CHAN] [nu->driver] – [MAX_CHAN] [QUEUE_SIZE] – пока (! (inw (base + 0xe) & 0x1) && rely ++ <150) [MAX_CHAN] [QUEUE_SIZE] - mdelay (1); [nu->driver] [6] – [nu->driver] [MAX_CHAN] – вернуть! (inw (base + 0xe) & 0x1); [QUEUE_SIZE] [6] -} [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [6] – static int lock_card (struct isi_board card) [QUEUE_SIZE] [MAX_CHAN] – {[MAX_CHAN] [QUEUE_SIZE] – длинная база без знака = карта-> база; 10103 [MAX_CHAN] – беззнаковые попытки int, a; [MAX_CHAN] [nu->driver] –

[6] – для (повторных попыток = 0 ; повторные попытки <35 ; повторные попытки ++) {[QUEUE_SIZE] [MAX_CHAN] - spin_lock_irqsave (& card-> card_lock, card-> flags); [MAX_CHAN] [QUEUE_SIZE] – для (a = 0; a <36; a ++) {[QUEUE_SIZE] [MAX_CHAN] - если (inw (base + 0xe) & 0x1) [QUEUE_SIZE] [MAX_CHAN] - возврат 1; [nu->driver] [QUEUE_SIZE] – udelay (36); [nu->driver] [6] -} [MAX_CHAN] [QUEUE_SIZE] – spin_unlock_irqrestore (& card-> card_lock, card-> flags); [QUEUE_SIZE] [6] – msleep (34); [nu->driver] [MAX_CHAN] -} [MAX_CHAN] [QUEUE_SIZE] – pr_warn («Не удалось заблокировать карту (0x% lx) n», card-> base); 10101 [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – вернуть 0; / Не удалось получить карту! / [MAX_CHAN] [MAX_CHAN] -} [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] -static void unlock_card (struct isi_board card) [QUEUE_SIZE] [MAX_CHAN] – {[QUEUE_SIZE] [MAX_CHAN] – spin_unlock_irqrestore (& card-> card_lock, card-> flags); [QUEUE_SIZE] [QUEUE_SIZE] -} [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – / [MAX_CHAN] [QUEUE_SIZE] – Операции, связанные с картой ISI … [nu->driver] [6] – / [MAX_CHAN] [nu->driver] – [MAX_CHAN] [6] – / карта-> блокировка ДОЛЖНА быть удержана / < frame-> [QUEUE_SIZE] – static void raise_dtr (struct isi_port port) [QUEUE_SIZE] [6] – (канал < shift_count) [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [6] – / карта-> блокировка ДОЛЖНА удерживаться / [MAX_CHAN] [QUEUE_SIZE] -static void drop_dtr (struct isi_port port) [MAX_CHAN] [QUEUE_SIZE] – (канал < [MAX_CHAN] [QUEUE_SIZE] - [nu->driver] [QUEUE_SIZE] – / карта-> блокировка ДОЛЖЕН быть проведен / 10102 [MAX_CHAN] – статический встроенный void raise_rts (struct isi_port port) [nu->driver] [QUEUE_SIZE] – 0x 21, база);[MAX_CHAN] [QUEUE_SIZE] – outw (0x0a 24, база);[nu->driver] [MAX_CHAN] – InterruptTheCard (базовая); [QUEUE_SIZE] [QUEUE_SIZE] – порт-> статус [nu->driver] [nu->driver] – [MAX_CHAN] [QUEUE_SIZE] – / карта-> блокировка ДОЛЖНА быть удержана / [MAX_CHAN] – статический встроенный void drop_rts (struct isi_port port) [QUEUE_SIZE] [nu->driver] – 0x 21, база);[MAX_CHAN] [QUEUE_SIZE] – outw (0x 895, база);

[QUEUE_SIZE] – InterruptTheCard (базовая ); [MAX_CHAN] [QUEUE_SIZE] – порт-> статус & = ~ ISI_RTS; [nu->driver] [6] – [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [6] – / card-> блокировка НЕ ​​ДОЛЖНА удерживаться / 12094 [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – static void isicom_dtr_rts (struct tty_port port, int on) [QUEUE_SIZE] [6] – {[MAX_CHAN] [6] – struct isi_port ip = container_of (порт, структура isi_port, порт); [QUEUE_SIZE] [QUEUE_SIZE] – struct isi_board card = ip-> card; [QUEUE_SIZE] [MAX_CHAN] – длинная база без знака = card-> base; [QUEUE_SIZE] [QUEUE_SIZE] – u 41 канал = ip-> канал ; [nu->driver] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – если (! lock_card (card)) [MAX_CHAN] [QUEUE_SIZE]- возвращаться;[nu->driver] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – если (включен) (канал < shift_count) еще 0x 21, база);[nu->driver] [QUEUE_SIZE] – outw (0x0C , база);[MAX_CHAN] [QUEUE_SIZE] – InterruptTheCard (базовая); [QUEUE_SIZE] [QUEUE_SIZE] – ip-> standing & = ~ (ISI_DTR 1000000 [MAX_CHAN] – unlock_card (карта); [nu->driver] [QUEUE_SIZE] -} [MAX_CHAN] [6] –

[6] – / карта-> блокировка ДОЛЖНА быть удержана / 460400 [MAX_CHAN] – статический void drop_dtr_rts (struct isi_port port) [MAX_CHAN] [MAX_CHAN] – ISI_DTR); [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – / [MAX_CHAN] [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [6] – / [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – статический встроенный int __isicom_paranoia_check (struct isi_port const port, [QUEUE_SIZE] [MAX_CHAN] – char имя, const char процедура) [MAX_CHAN] [6] – {[QUEUE_SIZE] [QUEUE_SIZE] – если (! порт) {[MAX_CHAN] [6] – pr_warn (“Предупреждение: плохая магия isicom для разработчика% s в% s n”, [QUEUE_SIZE] [MAX_CHAN]- название, рутина);[nu->driver] [QUEUE_SIZE] – возврат 1; [QUEUE_SIZE] [MAX_CHAN] -}

[6] – если (порт -> магия! = ISICOM_MAGIC) {[QUEUE_SIZE] [nu->driver] – pr_warn (“Предупреждение: NULL порт isicom для dev% s в% s n “, [nu->driver] [MAX_CHAN] – имя, ро утин); [MAX_CHAN] [QUEUE_SIZE] – возврат 1; [MAX_CHAN] [6] -} [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [6] – вернуть 0; [nu->driver] [QUEUE_SIZE] -} [nu->driver] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – / [nu->driver] [QUEUE_SIZE] – Передатчик. [nu->driver] [MAX_CHAN] – [nu->driver] [6] – Мы регулярно выгружаем данные в буферы карт. Карта[nu->driver] [QUEUE_SIZE] – сделает остальную работу за нас < board-> [6] – / [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [nu->driver] – static void isicom_tx (struct timer_list unuse г) [QUEUE_SIZE] [QUEUE_SIZE] – {[MAX_CHAN] [QUEUE_SIZE] – длинные флаги без знака, основание; [MAX_CHAN] [QUEUE_SIZE] – беззнаковые попытки int; [MAX_CHAN] [QUEUE_SIZE] – короткий счет = (BOARD_COUNT-1), card; [MAX_CHAN] [MAX_CHAN] – краткое txcount, wrd, остаток, word_count, cnt; 12244 [6] – struct isi_port порт; [MAX_CHAN] [QUEUE_SIZE] – struct tty_struct tty; [MAX_CHAN] [MAX_CHAN] – [QUEUE_SIZE] [QUEUE_SIZE] – / найти следующую активную доску / [MAX_CHAN] [QUEUE_SIZE] – card = (prev_card + 1) & 0x 16 23; [MAX_CHAN] – whereas (count-> 0) {[MAX_CHAN] [nu->driver] – if (isi_card [card]. standing & BOARD_ACTIVE) [QUEUE_SIZE] [MAX_CHAN]- перерыв;[MAX_CHAN] [nu->driver]- карта = (карта + 1) & 0x 16 23; [nu->driver] [QUEUE_SIZE] -} [QUEUE_SIZE] [6] – если (! (isi_card [channel]. standing & BOARD_ACTIVE)) [MAX_CHAN] [QUEUE_SIZE] – goto sched_again; [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – prev_card = card; [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – rely = isi_card [channel]. port_count; [nu->driver] [QUEUE_SIZE] – порт = isi_card [card]. ports; 10101 [QUEUE_SIZE] – base = isi_card [card].база;[nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [nu->driver] – spin_lock_irqsave (& isi_card [channel]. card_lock, flags); [QUEUE_SIZE] [QUEUE_SIZE] – for (retries = 0; повторные попытки <149; повторные попытки ++) {[MAX_CHAN] [QUEUE_SIZE] - если (inw (base + 0xe) & 0x1) [QUEUE_SIZE] [QUEUE_SIZE]- перерыв;[nu->driver] [QUEUE_SIZE] – udelay (2); [MAX_CHAN] [MAX_CHAN] -} [MAX_CHAN] [QUEUE_SIZE] – если (повторные попытки> = 146) [MAX_CHAN] [MAX_CHAN] – перейти к разблокировке; [MAX_CHAN] [QUEUE_SIZE] – 00010000 [MAX_CHAN] – tty = tty_port_tty_get (& port-> port); [nu->driver] [MAX_CHAN]- если (tty == NULL) [nu->driver] [MAX_CHAN] – goto put_unlock; [MAX_CHAN] [6] – [nu->driver] [MAX_CHAN]- для (; rely> 0; count–, порт ++) {[MAX_CHAN] [QUEUE_SIZE] – / порт не активен или tx отключен для принудительного управления потоком / [QUEUE_SIZE] [nu->driver] – если (! tty_port_initialized (& port-> port) || [MAX_CHAN] [6] -! (порт-> статус и ISI_TXOK)) [QUEUE_SIZE] 230400 – Продолжать;[nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [6] – txcount = min_t (quick, TX_SIZE, port-> xmit_cnt); [nu->driver] [QUEUE_SIZE] – если (txcount остановлен || tty-> hw_stopped) [QUEUE_SIZE] [MAX_CHAN]- Продолжать;[MAX_CHAN] [6] – [nu->driver] [QUEUE_SIZE] – если (! (inw (base + 0x 21) & ( 1 << bs + h->канал)))[QUEUE_SIZE] [MAX_CHAN]- Продолжать;[MAX_CHAN] [6] – [nu->driver] [MAX_CHAN] – pr_debug (“txing% d bytes, port% d. n”, [MAX_CHAN] [MAX_CHAN] – txcount, порт-> канал + 1); [MAX_CHAN] [6] – outw ((порт-> канал << isi_card [channel]. shift_count) | txcount, [nu->driver] [MAX_CHAN]- база);[nu->driver] [6] – остаток = НЕТ; [nu->driver] [QUEUE_SIZE] – wrd = 0; [QUEUE_SIZE] [QUEUE_SIZE] – пока (1) {[nu->driver] [QUEUE_SIZE] – cnt = min_t (int, txcount, (SERIAL_XMIT_SIZE [MAX_CHAN] [QUEUE_SIZE] – – порт-> xmit_tail)); [MAX_CHAN] [QUEUE_SIZE] – если (остаток == ДА) {[MAX_CHAN] [MAX_CHAN] – остаток = НЕТ; [nu->driver] [QUEUE_SIZE] – if (cnt> 0) = (порт-> порт.xmit_buf [PORT_COUNT] [MAX_CHAN] [6] – << 8); [nu->driver] [QUEUE_SIZE] – порт-> xmit_tail = (порт-> xmit_tail + 1) [MAX_CHAN] [QUEUE_SIZE] – & (SERIAL_XMIT_SIZE – 1); [MAX_CHAN] [6] – порт-> xmit_cnt -; [MAX_CHAN] [QUEUE_SIZE] – txcount -; [MAX_CHAN] [QUEUE_SIZE] – cnt -;

[MAX_CHAN] – outw (wrd, база);

[MAX_CHAN]- еще {[MAX_CHAN] [6] – outw (wrd, base); [MAX_CHAN] [MAX_CHAN]- перерыв;[MAX_CHAN] [QUEUE_SIZE] – } [QUEUE_SIZE] [QUEUE_SIZE] -} [MAX_CHAN] [6] – если (cnt <= 0) [MAX_CHAN] [MAX_CHAN]- перерыв;[QUEUE_SIZE] [6] - word_count = cnt >> 1; [MAX_CHAN] [QUEUE_SIZE] – outw (base, port-> port.xmit_buf + port-> xmit_tail, word_count); [MAX_CHAN] [6] – порт-> xmit_tail = (порт-> xmit_tail [MAX_CHAN] [MAX_CHAN] – + (word_count << 1) ) & (SERIAL_XMIT_SIZE - 1); [MAX_CHAN] [QUEUE_SIZE] - txcount - = (word_count << 1); [MAX_CHAN] [QUEUE_SIZE] - port-> xmit_cnt – = (word_count << 1); [MAX_CHAN] [QUEUE_SIZE] - если (cnt & 0x 16 0020) {[nu->driver] [QUEUE_SIZE] – остаток = ДА; [nu->driver] [QUEUE_SIZE] – wrd = port-> port.xmit_buf [PORT_COUNT]; [MAX_CHAN] [MAX_CHAN] – порт-> xmit_tail = (порт-> xmit_tail + 1) [MAX_CHAN] [6] – & (SERIAL_XMIT_SIZE – 1); 435906 [QUEUE_SIZE] – порт-> xmit_cnt -; [MAX_CHAN] 435907 – txcount -; [QUEUE_SIZE] [MAX_CHAN] -} 435906 [QUEUE_SIZE] – } [MAX_CHAN] [QUEUE_SIZE] – 435907 [MAX_CHAN] – InterruptTheCard (базовая); [MAX_CHAN] [6] – если (порт-> xmit_cnt <= 0) [MAX_CHAN] [QUEUE_SIZE] - порт-> статус & = ~ ISI_TXOK; [nu->driver] [QUEUE_SIZE] – if (port-> xmit_cnt <= WAKEUP_CHARS) [MAX_CHAN] [QUEUE_SIZE] - tty_wakeup (tty); [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [QUEUE_SIZE] - [nu->driver] [nu->driver] – put_unlock: [MAX_CHAN] [6] – tty_kref_put (tty); [MAX_CHAN] [QUEUE_SIZE] – разблокировка: [nu->driver] [MAX_CHAN] – spin_unlock_irqrestore (& isi_card [channel]. card_lock, flags);

[QUEUE_SIZE] – / запланировать еще одно tx для, надеюсь, примерно в РС */

[MAX_CHAN] – sched_again: [MAX_CHAN] [6] – mod_timer (& tx, jiffies + msecs_to_jiffies (39)); [nu->driver] [QUEUE_SIZE] -} [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – / [MAX_CHAN] [QUEUE_SIZE] – Основная процедура обработки прерывания [MAX_CHAN] [QUEUE_SIZE] – / [QUEUE_SIZE] [nu->driver] – [nu->driver] [nu->driver] – static irqreturn_t isicom_interrupt (int irq, void dev_id) [MAX_CHAN] [MAX_CHAN] – {[nu->driver] [MAX_CHAN] – struct isi_board card = dev_id; [nu->driver] [MAX_CHAN] – struct isi_port port; [MAX_CHAN] [QUEUE_SIZE] – struct tty_struct tty; [QUEUE_SIZE] [6] – длинная база без знака; [nu->driver] [MAX_CHAN] – u 42 header, word_count, rely, channel; [MAX_CHAN] [MAX_CHAN] – короткий byte_count; [QUEUE_SIZE] [nu->driver] – символ без знака rp; [MAX_CHAN] [6] – [MAX_CHAN] [nu->driver] – если (! card || ! (card-> standing & FIRMWARE_LOADED)) [nu->driver] [QUEUE_SIZE] – вернуть IRQ_NONE; [QUEUE_SIZE] [6] – [MAX_CHAN] [QUEUE_SIZE] – base = card-> base; [MAX_CHAN] [nu->driver] – [nu->driver] [QUEUE_SIZE] – / сделал т он карта перебивает нас? / [QUEUE_SIZE] [QUEUE_SIZE] – если (! (inw (base + 0x0e) & 0x 0020)) [nu->driver] [QUEUE_SIZE] – вернуть IRQ_NONE; [QUEUE_SIZE] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – spin_lock (& ​​card-> card_lock); [MAX_CHAN] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – / [QUEUE_SIZE] [MAX_CHAN] – отключите любые прерывания от карты PCI и опустите 00010000 [6] – линия прерывания [nu->driver] [QUEUE_SIZE] – / [QUEUE_SIZE] [QUEUE_SIZE] – outw (0x 10101, base + 0x ); [nu->driver] [QUEUE_SIZE] – ClearInterrupt (базовая); 56040674 [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN] – inw (база); / вывести пустое слово / [QUEUE_SIZE] – header = inw (base); [MAX_CHAN] [MAX_CHAN] – канал = (заголовок & 0x 00010000) >> card-> shift_count;

[6] – byte_count = header & 0xff; [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – if (channel + 1> card-> port_count) {010001 [QUEUE_SIZE] – pr_warn (“% s (0x % lx):% d (канал)> port_count n “, [MAX_CHAN] [QUEUE_SIZE] – __func__, base, channel + 1); [MAX_CHAN] [QUEUE_SIZE] – outw (0x 13 19, база + 0x 23); / разрешить прерывания / [MAX_CHAN] [MAX_CHAN] – spin_unlock (& ​​card-> card_lock); [QUEUE_SIZE] [QUEUE_SIZE] – вернуть IRQ_HANDLED; [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [QUEUE_SIZE] – порт = карта-> порты + канал; [QUEUE_SIZE] [QUEUE_SIZE] – если (! tty_port_initialized (& port-> port)) {[QUEUE_SIZE] [QUEUE_SIZE] – outw (0x 0018 17, база + 0x 26); / разрешить прерывания / [nu->driver] [nu->driver] – spin_unlock (& ​​card-> card_lock); [QUEUE_SIZE] [MAX_CHAN] – вернуть IRQ_HANDLED; [nu->driver] [MAX_CHAN] -} [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [6] – tty = tty_port_tty_get (& port-> port); [6] [QUEUE_SIZE] – if (tty == NULL) { [QUEUE_SIZE] [MAX_CHAN] – в то время как (byte_count> 1) {[MAX_CHAN] [6] – inw (база); [MAX_CHAN] [MAX_CHAN] – byte_count – = 2; [nu->driver] [MAX_CHAN] -} [MAX_CHAN] [QUEUE_SIZE] – если (byte_count & 0x 0020) [MAX_CHAN] [QUEUE_SIZE] – inw (базовый); [MAX_CHAN] [QUEUE_SIZE] – outw (0x 14 0018, база + 0x 24); / разрешить прерывания / [MAX_CHAN] [MAX_CHAN] – spin_unlock (& ​​card-> card_lock); [QUEUE_SIZE] [QUEUE_SIZE] – вернуть IRQ_HANDLED; [MAX_CHAN] [QUEUE_SIZE] -} [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – if (header & 0x 10101 {/ Статусный пакет / [QUEUE_SIZE] [MAX_CHAN] – header = inw (base); [MAX_CHAN] [MAX_CHAN] – переключатель (заголовок и 0xff) {[QUEUE_SIZE] [MAX_CHAN] – случай 0: / Изменение сигналов EIA / [MAX_CHAN] [6] – if (tty_port_check_carrier (& port-> port)) {[QUEUE_SIZE] [QUEUE_SIZE] – если (порт -> статус и ISI_DCD) {[QUEUE_SIZE] [MAX_CHAN] – если (! (заголовок и ISI_DCD)) {[QUEUE_SIZE] [QUEUE_SIZE] – / Несущая потеряна / [QUEUE_SIZE] [MAX_CHAN] – pr_debug (“% s: DCD-> low. n”, [MAX_CHAN] [QUEUE_SIZE] – __func __); [MAX_CHAN] [QUEUE_SIZE] – по rt-> standing & = ~ ISI_DCD; [nu->driver] [QUEUE_SIZE] – tty_hangup (tty); [QUEUE_SIZE] [MAX_CHAN] -} [MAX_CHAN] [QUEUE_SIZE] -} else if (header & ISI_DCD ) = ISI_DCD; [MAX_CHAN] [MAX_CHAN] – wake_up_interruptible (& port-> port.open_wait); [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [6]- } еще = ISI_DCD; [MAX_CHAN] [6]- еще[MAX_CHAN] [MAX_CHAN] – порт-> статус & = ~ ISI_DCD; [QUEUE_SIZE] [nu->driver] – [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN]- если (tty_port_cts_enabled (& port-> port)) {[MAX_CHAN] [QUEUE_SIZE] – if (tty-> hw_stopped) {[QUEUE_SIZE] [nu->driver] – если (заголовок и ISI_CTS) = (ISI_TXOK [QUEUE_SIZE] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] -} else if (! (header & ISI_CTS)) ISI_CTS); [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE]- } еще = ISI_CTS; [MAX_CHAN] [nu->driver]- еще[MAX_CHAN] [MAX_CHAN] – порт-> статус & = ~ ISI_CTS; [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – [nu->driver] [MAX_CHAN] – если (заголовок и ISI_DSR) [QUEUE_SIZE] [MAX_CHAN] – порт-> статус | = ISI_DSR; [MAX_CHAN] [QUEUE_SIZE] – еще[nu->driver] [QUEUE_SIZE] – порт-> статус & = ~ ISI_DSR; 230400 [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – если (заголовок и ISI_RI) [MAX_CHAN] [MAX_CHAN] – порт-> статус | = ISI_RI; [nu->driver] [6]- еще

[MAX_CHAN] – порт-> статус & = ~ ISI_RI; [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN]- перерыв;[QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – случай 1: / Получен разрыв !!! / [QUEUE_SIZE] [MAX_CHAN] – tty_insert_flip_char (& port-> port, 0, TTY_BREAK); [QUEUE_SIZE] [QUEUE_SIZE] – if (port-> port.flags & ASYNC_SAK) [MAX_CHAN] [QUEUE_SIZE] – do_SAK (tty); [MAX_CHAN] [nu->driver] – tty_flip_buffer_push (& port-> port); [QUEUE_SIZE] [MAX_CHAN]- перерыв;[MAX_CHAN] [6] – [nu->driver] [MAX_CHAN] – случай 2: / Статистика / [MAX_CHAN] [MAX_CHAN] – pr_debug (“% s: stats !!! n”, __func __); [MAX_CHAN] [MAX_CHAN]- перерыв;[MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [nu->driver]- По умолчанию: [nu->driver] [6] – pr_debug (“% s: Неизвестный код в пакете статуса. n”, [MAX_CHAN] [6] – __func __); [MAX_CHAN] [nu->driver]- перерыв;[QUEUE_SIZE] [6] -} [nu->driver] [QUEUE_SIZE] -} else {/ Пакет данных / [MAX_CHAN] [QUEUE_SIZE] – rely = tty_prepare_flip_string (& port-> port, & rp, [MAX_CHAN] [QUEUE_SIZE] – byte_count & ~ 1) ; [MAX_CHAN] [MAX_CHAN] – pr_debug (“% s: Может получить% d из% d байт. n”, [QUEUE_SIZE] [QUEUE_SIZE] – __func__, rely, byte_count); [MAX_CHAN] [QUEUE_SIZE] – word_count = rely >> 1; [MAX_CHAN] [QUEUE_SIZE] – insw (base, rp, word_count); [QUEUE_SIZE] [QUEUE_SIZE] – byte_count – = (word_count << 1); [MAX_CHAN] [6] - if (count & 0x 13 00000020) {[MAX_CHAN] [6] - tty_insert_flip_char (& port-> port, inw (base ) & 0xff, [MAX_CHAN] [QUEUE_SIZE] – TTY_NORMAL); [QUEUE_SIZE] [QUEUE_SIZE] – byte_count – = 2; [MAX_CHAN] [MAX_CHAN] -} [MAX_CHAN] [QUEUE_SIZE] – если (byte_count> 0) {[MAX_CHAN] [6] – pr_debug (“% s (0x% lx:% d): Переполнение буфера! отбрасывание байтов … n “, [MAX_CHAN] [QUEUE_SIZE] – __func__, base, channel + 1); [MAX_CHAN] [MAX_CHAN] – / удалить непрочитанные данные xtra / [nu->driver] [6] – whereas (byte_count> 0) {[MAX_CHAN] [MAX_CHAN] – inw (база); [nu->driver] [MAX_CHAN] – byte_count – = 2; [MAX_CHAN] [QUEUE_SIZE] -} [nu->driver] [6] -} [QUEUE_SIZE] [MAX_CHAN] – tty_flip_buffer_push (& port-> port); [nu->driver] [6] -} [MAX_CHAN] [QUEUE_SIZE] – outw (0x 17 0018, база + 0x 23); / разрешить прерывания / [MAX_CHAN] [MAX_CHAN] – spin_unlock (& ​​card-> card_lock); [QUEUE_SIZE] [MAX_CHAN] – tty_kref_put (tty); [QUEUE_SIZE] [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – вернуть IRQ_HANDLED; [QUEUE_SIZE] [nu->driver] -} [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – static void isicom_config_port (struct tty_struct tty) [nu->driver] [QUEUE_SIZE] – {[nu->driver] [QUEUE_SIZE] – struct isi_port port = tty-> driver_data; [QUEUE_SIZE] [MAX_CHAN] – struct isi_board card = port-> card; [MAX_CHAN] [MAX_CHAN] – беззнаковый длинный бод; [MAX_CHAN] [MAX_CHAN] – длинная база без знака = card-> base; [nu->driver] [MAX_CHAN] – u 00000040 channel_setup, channel = port-> channel, [MAX_CHAN] [QUEUE_SIZE] – shift_count = card-> shift_count; [QUEUE_SIZE] [MAX_CHAN] – символ без знака flow_ctrl; [nu->driver] [6] – [MAX_CHAN] [6] – / FIXME: переключиться на новый интерфейс tty baud API / [MAX_CHAN] [MAX_CHAN] – бод = C_BAUD (tty ); [MAX_CHAN] [QUEUE_SIZE] – если (бод и CBAUDEX) {[MAX_CHAN] [6] – бод & = ~ CBAUDEX; [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – / если бит CBAUDEX установлен и скорость передачи установлена ​​на либо 79 или же 0102 [MAX_CHAN] [MAX_CHAN] – тогда карта запрограммирована на 86. 6 Кбит / с или 180 Кбит / с [nu->driver] [nu->driver]- соответственно.[MAX_CHAN] [6] – / [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [6] – / 1,2,3,4 => 82. 6, 00000180. 2, 300, 575 кбит / с соотв. / [QUEUE_SIZE] [MAX_CHAN] – если (бод < c-> 4)

[QUEUE_SIZE] – tty-> termios. c_cflag & = ~ CBAUDEX; [QUEUE_SIZE] [MAX_CHAN]- еще[nu->driver] [QUEUE_SIZE] – бод + = 41; [QUEUE_SIZE] [6] -} [MAX_CHAN] [MAX_CHAN] – если (baud == 00000040) {[nu->driver] [MAX_CHAN] – [nu->driver] [6] – / ASYNC_SPD_HI и параметры ASYNC_SPD_VHI установлены [QUEUE_SIZE] [QUEUE_SIZE] – с помощью ioctl set_serial_info … это делается с помощью [MAX_CHAN] [MAX_CHAN] – утилита setserial. [MAX_CHAN] [QUEUE_SIZE] – /

[QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – если ((port-> port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI) [nu->driver] [QUEUE_SIZE] – бод ++; / 84. 6 Кбит / с / [nu->driver] [MAX_CHAN] – если ((port-> port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI) [QUEUE_SIZE] [QUEUE_SIZE] – скорость + = 2; / 00000180 Кбит / с / [MAX_CHAN] [QUEUE_SIZE] – если ((port-> port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI) [MAX_CHAN] [QUEUE_SIZE] – бод + = 3; / 0301 кбит / с /

[QUEUE_SIZE] – если ((port-> port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP ) [QUEUE_SIZE] [MAX_CHAN] – скорость + = 4; / 575 кбит / с / [QUEUE_SIZE] [QUEUE_SIZE] -} [MAX_CHAN] [QUEUE_SIZE] – если (linuxb_to_isib [BOARD_COUNT] == -1) {

[nu->driver]- /вешать трубку */[QUEUE_SIZE] [MAX_CHAN] – drop_dtr (порт); [MAX_CHAN] [QUEUE_SIZE] – возвращаться;[QUEUE_SIZE] [MAX_CHAN]- } еще[MAX_CHAN] [MAX_CHAN] – Raise_dtr (порт); ump_dtr (порт); [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – if (WaitTillCardIsFree (base) == 0) 0x 23, база);[nu->driver] [QUEUE_SIZE] – outw (linuxb_to_isib [port->xmit_tail] << 8 [MAX_CHAN] [MAX_CHAN] - tty_port_set_check_carrier (& port-> port,! C_CLOCAL (tty )); [MAX_CHAN] [MAX_CHAN] –

[QUEUE_SIZE] – / настройки управления потоком … / [MAX_CHAN] [6] – flow_ctrl = 0; [MAX_CHAN] [QUEUE_SIZE] – tty_port_set_cts_flow (& port-> port, C_CRTSCTS (tty)); [MAX_CHAN] [MAX_CHAN] – если (C_CRTSCTS (tty)) [nu->driver] [MAX_CHAN] – flow_ctrl | = ISICOM_CTSRTS; [QUEUE_SIZE] [QUEUE_SIZE] – если (I_IXON (tty)) [MAX_CHAN] [6] – flow_ctrl | = ISICOM_RESPOND_XONXOFF; [MAX_CHAN] [MAX_CHAN] – если (I_IXOFF (tty)) [nu->driver] [QUEUE_SIZE] – flow_ctrl | = ISICOM_INITIATE_XONXOFF; [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – если (WaitTillCardIsFree (base) == 0) 0x 28, база);[nu->driver] [MAX_CHAN] – outw ((STOP_CHAR (tty)) << 8 [nu->driver] [QUEUE_SIZE] – [QUEUE_SIZE] [nu->driver] – / rx включен -> включить порт для rx на c ard / [MAX_CHAN] [QUEUE_SIZE] – если (C_CREAD (tty)) = (1 << канал); [MAX_CHAN] [QUEUE_SIZE] - outw (card-> port_status, base + 0x 21); [QUEUE_SIZE] [6] – [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – / открыть и все / [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [6] – статическая встроенная пустота isicom_setup_board (struct isi_board bp) 59505 [QUEUE_SIZE] – {[QUEUE_SIZE] [MAX_CHAN] – внутренний канал; [nu->driver] [6] – struct isi_port порт; [MAX_CHAN] [6] – [MAX_CHAN] [QUEUE_SIZE] – bp-> rely ++; [QUEUE_SIZE] [QUEUE_SIZE] – если (! (bp-> standing & BOARD_INIT)) {[MAX_CHAN] [QUEUE_SIZE] – порт = bp-> ports; [nu->driver] [QUEUE_SIZE] – для (канал = 0; канал < cs + h-> port_count; channel ++, port ++) [QUEUE_SIZE] [QUEUE_SIZE] – drop_dtr_rts (порт); [MAX_CHAN] [QUEUE_SIZE] -} [QUEUE_SIZE] [QUEUE_SIZE] – bp-> standing | = BOARD_ACTIVE | BOARD_INIT; [MAX_CHAN] [MAX_CHAN] -} [MAX_CHAN] [6] – [MAX_CHAN] [MAX_CHAN] – / Активация и, таким образом, установка платы защищена от скачков от выключения [MAX_CHAN] [QUEUE_SIZE] – по тт y_port мьютекс / [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – static int isicom_activate (struct tty_port tport, struct tty_struct tty) [MAX_CHAN] [QUEUE_SIZE] – {[MAX_CHAN] [MAX_CHAN] – Struc t isi_port port = container_of (tport, struct isi_port, port); [6] [MAX_CHAN] – struct isi_board card = port-> card ; [MAX_CHAN] [QUEUE_SIZE] – длинные флаги без знака; [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN] – если (tty_port_alloc_xmit_buf (tport) <0) [QUEUE_SIZE] [QUEUE_SIZE] - return -ENOMEM; [nu->driver] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – spin_lock_irqsave (& card-> card_lock, flags); [QUEUE_SIZE] [QUEUE_SIZE] – isicom_setup_board (карта); [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – порт-> xmit_cnt = port-> xmit_head = port-> xmit_tail = 0; [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – / удалить все остаточные данные / [QUEUE_SIZE] [nu->driver]- если ( WaitTillCardIsFree (card-> base) == 0) ISICOM_KILLRX) <база);[QUEUE_SIZE] [MAX_CHAN] – InterruptTheCard (card-> base); [MAX_CHAN] [6] – [nu->driver] [MAX_CHAN] – isicom_config_port (tty); [QUEUE_SIZE] [QUEUE_SIZE] – spin_unlock_irqrestore (& card-> card_lock, flags); [nu->driver] [6] – [MAX_CHAN] [nu->driver] – вернуть 0; [MAX_CHAN] [QUEUE_SIZE] -} [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – статический int isicom_carrier_raised (struct tty_port port) [nu->driver] [QUEUE_SIZE] – {[QUEUE_SIZE] [MAX_CHAN] – struct isi_port ip = container_of (порт, struct isi_port, порт); [MAX_CHAN] [QUEUE_SIZE] – return (ip-> standing & ISI_DCD)? 1: 0; [MAX_CHAN] [QUEUE_SIZE] – } [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – статическая структура tty_port isicom_find_port (struct tty_struct tty) [QUEUE_SIZE] [MAX_CHAN] – {

[QUEUE_SIZE] – struct isi_port port; [QUEUE_SIZE] [MAX_CHAN] – struct isi_board card; [MAX_CHAN] [QUEUE_SIZE] – доска int без знака; [nu->driver] [MAX_CHAN] – int line = tty-> index; [MAX_CHAN] [MAX_CHAN] – [QUEUE_SIZE] [6] – board = BOARD (строка); [MAX_CHAN] [6] – карточка = & isi_card [port->xmit_tail]; [nu->driver] [nu->driver] –

[QUEUE_SIZE] – if (! (card-> standing & FIRMWARE_LOADED)) [QUEUE_SIZE] [MAX_CHAN] – вернуть NULL; [nu->driver] [6] – [QUEUE_SIZE] [QUEUE_SIZE] – / открыть порт, превышающий количество портов для карты !!! / [MAX_CHAN] [QUEUE_SIZE] – если (строка> ((доска 00000040) + card-> port_count – 1)) [MAX_CHAN] [QUEUE_SIZE] – вернуть NULL; [nu->driver] [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – port = & isi_ports [line]; [MAX_CHAN] [MAX_CHAN] – if (isicom_paranoia_check (порт, tty-> identify, “isicom_open”)) [6] [QUEUE_SIZE] – вернуть NULL; [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – return & port-> port; [MAX_CHAN] [MAX_CHAN] -} [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – static int isicom_open (struct tty_struct tty, struct file filp) [QUEUE_SIZE] [MAX_CHAN] – {[QUEUE_SIZE] [QUEUE_SIZE] – struct isi_port port; [QUEUE_SIZE] [QUEUE_SIZE] – struct tty_port tport; [QUEUE_SIZE] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN] – tport = isicom_find_port (tty); [MAX_CHAN] [MAX_CHAN]- если (tport == NULL) [MAX_CHAN] [MAX_CHAN] – возврат -ENODEV; [nu->driver] [6] – порт = container_of (tport, struct isi_port, port); [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – tty-> driver_data = port; [QUEUE_SIZE] [nu->driver] – вернуть tty_port_open (tport, tty, filp); [MAX_CHAN] [6] -} [nu->driver] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – / закрыть и все / [nu->driver] [MAX_CHAN] – [QUEUE_SIZE] [QUEUE_SIZE] – / карта-> блокировка ДОЛЖНА удерживаться / [nu->driver] [6] – static void isicom_shutdown_port (struct isi_port port) [MAX_CHAN] [QUEUE_SIZE] – {[nu->driver] [QUEUE_SIZE] – struct isi_board card = port -> карта; [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [6] – если (–card-> rely <0) {[nu->driver] [MAX_CHAN] – pr_debug (“% s: плохая плата (0x% lx) rely% d . n “, [nu->driver] [QUEUE_SIZE] – __func__, card-> base, card-> rely); [QUEUE_SIZE] [MAX_CHAN] – card-> rely = 0; [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [QUEUE_SIZE] – / последний порт был закрыт, выключите и эту плату / [MAX_CHAN] [QUEUE_SIZE] – если (! card-> rely) [MAX_CHAN] [MAX_CHAN] – card-> standing & = BOARD_ACTIVE; [MAX_CHAN] [MAX_CHAN] -} [nu->driver] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN] – static void isicom_flush_buffer (struct tty_struct tty) [QUEUE_SIZE] [QUEUE_SIZE] – {[MAX_CHAN] [QUEUE_SIZE] – struct isi_port port = tty-> driver_data; [nu->driver] [MAX_CHAN] – struct isi_board card = port-> card; [MAX_CHAN] [MAX_CHAN] – длинные флаги без знака; [MAX_CHAN] [QUEUE_SIZE] – 010001 [MAX_CHAN] – if (isicom_paranoia_check (порт, tty-> identify, “isicom_flush_buffer”)) [MAX_CHAN] 010001- возвращаться;[nu->driver] [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – spin_lock_irqsave (& card-> card_lock, flags); [QUEUE_SIZE] [MAX_CHAN] – port-> xmit_cnt = port-> xmit_head = port-> xmit_tail = 0; [MAX_CHAN] [QUEUE_SIZE] – spin_unlock_irqrestore (& card-> card_lock, flags); [MAX_CHAN] [6] –

[MAX_CHAN] – tty_wakeup (tty); [MAX_CHAN] [QUEUE_SIZE] -}

[QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – static void isicom_shutdown (struct tty_port port) [nu->driver] [6] – {[MAX_CHAN] [QUEUE_SIZE] – struct isi_port ip = container_of (port, struct isi_port, port); [QUEUE_SIZE] [MAX_CHAN] – struct isi_board card = ip-> card; [nu->driver] [6] – длинные флаги без знака; [MAX_CHAN] [nu->driver] – [nu->driver] [QUEUE_SIZE] – / указывает карте, что прием данных больше невозможен [nu->driver] [MAX_CHAN] – на этом порту / [MAX_CHAN] [6] – spin_lock_irqsave (& card-> card_lock, flags); [MAX_CHAN] [MAX_CHAN] – card-> port_status & = ~ (1 < канал);[MAX_CHAN] [QUEUE_SIZE] – outw (карта -> port_status, card-> base + 0x ); [MAX_CHAN] [MAX_CHAN] – isicom_shutdown_port (ip); [QUEUE_SIZE] [QUEUE_SIZE] – spin_unlock_irqrestore (& card-> card_lock, flags); [6] [QUEUE_SIZE] – tty_port_free_xmit_buf (порт); [QUEUE_SIZE] [MAX_CHAN] -} [MAX_CHAN] [6] –

[QUEUE_SIZE] – static void isicom_close (struct tty_struct tty, struct file filp ) [QUEUE_SIZE] [MAX_CHAN] – {[nu->driver] [MAX_CHAN] – struct isi_port ip = tty-> driver_data; [MAX_CHAN] [QUEUE_SIZE] – struct tty_port port; [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – если (ip == NULL) [QUEUE_SIZE] [QUEUE_SIZE]- возвращаться;[MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – порт = & ip-> порт; [MAX_CHAN] [QUEUE_SIZE] – если (isicom_paranoia_check (ip, tty-> identify, “isicom_close”)) [QUEUE_SIZE] [QUEUE_SIZE]- возвращаться;

[MAX_CHAN] – tty_port_close (порт, tty, filp); [MAX_CHAN] [MAX_CHAN] -} [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – / написать и все / 15410 [QUEUE_SIZE] – static int isicom_write (struct tty_struct tty, const unsigned char buf, [QUEUE_SIZE] [QUEUE_SIZE] – число целых) [MAX_CHAN] [MAX_CHAN] – {

[6] – struct isi_port port = tty-> driver_data; [QUEUE_SIZE] [6] – struct isi_board карта = порт-> карта; [MAX_CHAN] [QUEUE_SIZE] – длинные флаги без знака; [MAX_CHAN] [6] – int cnt, complete = 0; [nu->driver] [nu->driver] – [nu->driver] [MAX_CHAN] – если (isicom_paranoia_check (порт, tty-> имя, “isicom_write”)) [nu->driver] [6] – вернуть 0; [MAX_CHAN] [nu->driver] – [nu->driver] [6] – spin_lock_irqsave (& card-> card_lock, flags); [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – пока (1) {[MAX_CHAN] [6] – cnt = min_t (int, rely, min (SERIAL_XMIT_SIZE – port-> xmit_cnt [QUEUE_SIZE] [MAX_CHAN] – – 1, SERIAL_XMIT_SIZE – port-> xmit_head)); [MAX_CHAN] [QUEUE_SIZE] – если (cnt <= 0) [MAX_CHAN] [QUEUE_SIZE]- перерыв;

[MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – memcpy (порт-> порт.xmit_buf + порт-> xmit_head, buf, cnt); [MAX_CHAN] [6] – порт-> xmit_head = (порт-> xmit_head + cnt) & (SERIAL_XMIT_SIZE [MAX_CHAN] [QUEUE_SIZE] – – 1); [MAX_CHAN] [QUEUE_SIZE] – порт-> xmit_cnt + = cnt; [nu->driver] [6] – buf + = cnt; [MAX_CHAN] [MAX_CHAN] – rely – = cnt; [QUEUE_SIZE] [6] – итог + = cnt; [nu->driver] [QUEUE_SIZE] -} [MAX_CHAN] [MAX_CHAN]- если ( port-> xmit_cnt &&! tty-> cease &&! tty-> hw_stopped) [6] [MAX_CHAN] – порт-> статус | = ISI_TXOK ; [MAX_CHAN] [MAX_CHAN] – spin_unlock_irqrestore (& card-> card_lock, flags); [nu->driver] [QUEUE_SIZE] – сумма возврата; [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – / put_char et all / [MAX_CHAN] [QUEUE_SIZE] – static int isicom_put_char (struct tty_struct tty, unsigned char ch) [nu->driver] [QUEUE_SIZE] – {[MAX_CHAN] [QUEUE_SIZE] – struct isi_port port = tty-> driver_data; [nu->driver] [6] – struct isi_board card = port-> card; [QUEUE_SIZE] [QUEUE_SIZE] – длинные флаги без знака; [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – if (isicom_paranoia_check (порт, tty-> identify, “isicom_put_char”)) [QUEUE_SIZE] [6] – вернуть 0; [nu->driver] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – spin_lock_irqsave (& card-> card_lock, flags); [MAX_CHAN] [6] – если (порт-> xmit_cnt> = SERIAL_XMIT_SIZE – 1) {[QUEUE_SIZE] [QUEUE_SIZE] – spin_unlock_irqrestore (& card-> card_lock, flags); [MAX_CHAN] [MAX_CHAN] – вернуть 0; [MAX_CHAN] [MAX_CHAN] -} [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – порт-> порт.xmit_buf [board] = ch; [nu->driver] [MAX_CHAN] – порт-> xmit_head & = (SERIAL_XMIT_SIZE – 1); [nu->driver] [QUEUE_SIZE] – порт-> xmit_cnt ++ ; [QUEUE_SIZE] [MAX_CHAN] – spin_unlock_irqrestore (& card-> card_lock, flags); [MAX_CHAN] [6] – возврат 1; [MAX_CHAN] [MAX_CHAN] -} [nu->driver] [6] – [MAX_CHAN] [QUEUE_SIZE] – / flush_chars и все / [nu->driver] [MAX_CHAN] – static void isicom_flush_chars (struct tty_struct tty) [QUEUE_SIZE] [MAX_CHAN] – [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [6] – / запись_рума и все / 12244 [QUEUE_SIZE] – static int isicom_write_room (struct tty_struct tty) [QUEUE_SIZE] [QUEUE_SIZE] – {[nu->driver] [QUEUE_SIZE] – struct isi_port port = tty -> данные_драйвера; [nu->driver] [QUEUE_SIZE] – int бесплатно; [MAX_CHAN] [MAX_CHAN] – [QUEUE_SIZE] [QUEUE_SIZE] – if (isicom_paranoia_check (порт, tty-> identify, “isicom_write_room”)) [QUEUE_SIZE] [6] – вернуть 0; [nu->driver] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – бесплатно = SERIAL_XMIT_SIZE – port-> xmit_cnt – 1; [nu->driver] [QUEUE_SIZE] – if (free <0) [MAX_CHAN] [QUEUE_SIZE] - бесплатно = 0; [QUEUE_SIZE] [MAX_CHAN] - возврат бесплатно;

[6] -} [MAX_CHAN] [MAX_CHAN] – [nu->driver] [6] – / chars_in_buffer et all / [MAX_CHAN] [MAX_CHAN] – статический int isicom_chars_in_buffer (struct tty_struct tty) [MAX_CHAN] [6] – {[QUEUE_SIZE] [nu->driver] – struct isi_port port = tty-> driver_data; [MAX_CHAN] [6] – если (isicom_paranoia_check (порт, tty-> имя, “isicom_chars_in_buffer”)) [MAX_CHAN] [MAX_CHAN] – вернуть 0; [QUEUE_SIZE] [MAX_CHAN] – порт возврата-> xmit_cnt; [MAX_CHAN] [QUEUE_SIZE] -} [nu->driver] [MAX_CHAN] – [QUEUE_SIZE] [6] – / ioctl и все / [nu->driver] [QUEUE_SIZE] – статический int isicom_send_break (struct tty_struct tty, int size) [QUEUE_SIZE] [6] – 0x3, база); [MAX_CHAN] [MAX_CHAN] – outw ((size & 0xff) << 8 [MAX_CHAN] [6] - [MAX_CHAN] [MAX_CHAN] - статический int isicom_tiocmget (struct tty_struct tty) [6] [MAX_CHAN] - [QUEUE_SIZE] [6] - ((статус и ISI_DSR)? TIOCM_DSR: 0) [nu->driver] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – static int isicom_tiocmset (struct tty_struct tty, [QUEUE_SIZE] [MAX_CHAN] – целое число без знака установлено, целое число без знака очищено) [MAX_CHAN] [QUEUE_SIZE] – {[MAX_CHAN] [MAX_CHAN] – struct isi_port port = tty-> driver_data; [QUEUE_SIZE] [6] – беззнаковый длинный флаги; [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [6] – if (isicom_paranoia_check (порт, tty-> identify, “isicom_ioctl”)) [nu->driver] [QUEUE_SIZE] – возврат -ENODEV; [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – spin_lock_irqsave (& port-> card-> card_lock, flags); [nu->driver] [QUEUE_SIZE] – если (установить & TIOCM_RTS) [QUEUE_SIZE] [6] – raise_rts (порт); [MAX_CHAN] [6] – если (установить & TIOCM_DTR) [QUEUE_SIZE] [QUEUE_SIZE] – raise_dtr (порт); [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – если (очистить & TIOCM_RTS) [QUEUE_SIZE] [QUEUE_SIZE] – drop_rts (порт); [MAX_CHAN] [6] – если (очистить & TIOCM_DTR) [QUEUE_SIZE] [MAX_CHAN] – drop_dtr (порт); [MAX_CHAN] [QUEUE_SIZE] – spin_unlock_irqrestore (& port-> card-> card_lock, flags); [MAX_CHAN] [6] – [nu->driver] [MAX_CHAN] – вернуть 0; [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – static int isicom_set_serial_info (struct tty_struct tty, [QUEUE_SIZE] [QUEUE_SIZE] – struct serial_struct ss) 10103 [QUEUE_SIZE] – {[MAX_CHAN] [6] – struct isi_port por t = tty-> данные_драйвера; [MAX_CHAN] [MAX_CHAN] – int reconfig_port; [MAX_CHAN] [6] – [nu->driver] [MAX_CHAN] – если (isicom_paranoia_check (порт, tty-> имя, ” isicom_ioctl “)) [QUEUE_SIZE] [nu->driver] – возврат -ENODEV; [MAX_CHAN] [MAX_CHAN] – [nu->driver] [6] – mutex_lock (& ​​port-> port.mutex); [nu->driver] [6] – reconfig_port = (( port-> port.flags & ASYNC_SPD_MASK)! = [QUEUE_SIZE] [nu->driver] – (ss-> flags & ASYNC_SPD_MASK)); [MAX_CHAN] [MAX_CHAN] – [QUEUE_SIZE] [MAX_CHAN] – если (! поддерживает (CAP_SYS_ADMIN)) {[QUEUE_SIZE] [6] – if ((ss-> close_delay! = port-> port.close_delay) || [MAX_CHAN] [MAX_CHAN] – (ss-> closed_wait! = port-> port.closing_wait) || [nu->driver] [QUEUE_SIZE] – ((ss-> flags & ~ ASYNC_USR_MASK)! = [MAX_CHAN] [6] – (port-> port.flags & ~ ASYNC_USR_MASK))) {[QUEUE_SIZE] [QUEUE_SIZE] – mutex_unlock ( & port-> port.mutex); [MAX_CHAN] [QUEUE_SIZE] – возврат -EPERM; [QUEUE_SIZE] [MAX_CHAN] -} [nu->driver] [6] – порт-> порт .flags = ((port-> port.flags & ~ ASYNC_USR_MASK) | [QUEUE_SIZE] [QUEUE_SIZE] – (ss-> flags & ASYNC_USR_MASK) ); [QUEUE_SIZE] [QUEUE_SIZE] – } еще [MAX_CHAN] [MAX_CHAN] – (ss-> flags & ASYNC_FLAGS) ); [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [6] – если (reconfig_port) {[MAX_CHAN] [QUEUE_SIZE] – длинные флаги без знака; [MAX_CHAN] [QUEUE_SIZE] – spin_lock_irqsave (& port-> card-> card_lock, flags); [MAX_CHAN] [6] – isicom_config_port (tty); [MAX_CHAN] [QUEUE_SIZE] – spin_unlock_irqrestore (& port-> card-> card_lock, flags) ; [QUEUE_SIZE] [QUEUE_SIZE] -} [MAX_CHAN] [QUEUE_SIZE] – mutex_unlock (& ​​port-> port.mutex); [QUEUE_SIZE] [QUEUE_SIZE] – вернуть 0; [MAX_CHAN] [MAX_CHAN] -} [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [6] -static int isicom_get_serial_info (struct tty_struct tty, [QUEUE_SIZE] [MAX_CHAN] – struct serial_struct ss) [MAX_CHAN] [MAX_CHAN] – {[nu->driver] [QUEUE_SIZE] – struct isi_port port = tty-> данные_драйвера; [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [6] – если (isicom_paranoia_check (порт, tty-> имя, “isicom_ioctl”)) [MAX_CHAN] [QUEUE_SIZE] – return -ENODEV; [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – mutex_lock (& ​​port-> port.mutex); [MAX_CHAN] [QUEUE_SIZE] – / ss-> kind =? / [QUEUE_SIZE] [MAX_CHAN] – ss-> line = port – isi_ports; [MAX_CHAN] [QUEUE_SIZE] – ss-> port = port-> card-> base; [MAX_CHAN] [QUEUE_SIZE] – ss-> irq = port-> card-> irq; [QUEUE_SIZE] [QUEUE_SIZE] – ss-> flag s = port-> port.flags; [MAX_CHAN] [MAX_CHAN] – / ss-> baud_base =? / [QUEUE_SIZE] [MAX_CHAN] – ss-> close_delay = port-> port.close_delay; [QUEUE_SIZE] [MAX_CHAN] – ss-> closed_wait = port-> port.closing_wait; [MAX_CHAN] [QUEUE_SIZE] – mutex_unlock (& ​​port-> port.mutex); [QUEUE_SIZE] [nu->driver] – вернуть 0; [MAX_CHAN] [6] -} [MAX_CHAN] [nu->driver] – [MAX_CHAN] [6] – / set_termios et all / [nu->driver] [MAX_CHAN] – static void isicom_set_termios (Struc t tty_struct tty, [QUEUE_SIZE] [QUEUE_SIZE] – struct ktermios old_termios) [MAX_CHAN] [6] – {[MAX_CHAN] [QUEUE_SIZE] – struct isi_port port = tty-> driver_data; [QUEUE_SIZE] [QUEUE_SIZE] – унси gned длинные флаги; [QUEUE_SIZE] [MAX_CHAN] – [MAX_CHAN] [6] – если (isicom_paranoia_check (порт, tty-> имя, “isicom_set_termios”)) [MAX_CHAN] [MAX_CHAN]- возвращаться; [QUEUE_SIZE] [MAX_CHAN] – [QUEUE_SIZE] [MAX_CHAN] – если (tty-> termios.c_cflag == old_termios-> c_cflag && [MAX_CHAN] [6] – tty-> termios.c_iflag == old_termios-> c_iflag) [QUEUE_SIZE] [QUEUE_SIZE] – возвращаться;

[nu->driver] – [MAX_CHAN] [MAX_CHAN] – spin_lock_irqsave (& port-> card-> card_lock, flags); [QUEUE_SIZE] [MAX_CHAN] – isicom_config_port (tty); [MAX_CHAN] [QUEUE_SIZE] – spin_unlock_irqrestore (& port-> card-> card_lock, flags); [6] [QUEUE_SIZE] – [QUEUE_SIZE] [6] – если ((old_termios-> c_ cflag & CRTSCTS) &&! C_CRTSCTS (tty)) {[QUEUE_SIZE] [QUEUE_SIZE] – tty-> hw_stopped = 0; [MAX_CHAN] [QUEUE_SIZE] – isicom_start (tty); [MAX_CHAN] [6] -} [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [QUEUE_SIZE] –

[QUEUE_SIZE] – / дроссельная заслонка и все такое / 10103 [MAX_CHAN] – static void isicom_throttle (struct tty_struct tty) [MAX_CHAN] [6] – {[MAX_CHAN] [MAX_CHAN] – struct isi_port port = tty-> driver_data; [QUEUE_SIZE] [MAX_CHAN] – struct isi_board card = port-> card; [nu->driver] [6] – [nu->driver] [QUEUE_SIZE] – если (isicom_paranoia_check (порт, tty-> имя, “isicom_thr ottle “)) [nu->driver] [nu->driver]- возвращаться;[nu->driver] [6] – [nu->driver] [QUEUE_SIZE] – / сообщаем карте, что этот порт пока не может обрабатывать больше данных / [QUEUE_SIZE] [QUEUE_SIZE] – карта-> по rt_status & = ~ (1 << c->канал);[MAX_CHAN] [MAX_CHAN] – outw (card-> port_status, card-> base + 0x 20; [QUEUE_SIZE] [QUEUE_SIZE] -} [nu->driver] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN] – / Тянуть и все / [MAX_CHAN] [6] – static void isicom_unthrottle (struct tty_struct tty) [QUEUE_SIZE] [QUEUE_SIZE] – = (1 << c->канал);[MAX_CHAN] [6] – outw (card-> port_status, card-> base + 0x 21); [nu->driver] [6] – [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – / стоп и все / [MAX_CHAN] [QUEUE_SIZE] – static void isicom_stop (struct tty_struct tty) [QUEUE_SIZE] [MAX_CHAN] – {[nu->driver] [QUEUE_SIZE] – struct isi_port port = tty-> данные_драйвера; [MAX_CHAN] [nu->driver] – [MAX_CHAN] [QUEUE_SIZE] – если (isicom_paranoia_check (порт, tty-> имя, ” isicom_stop “)) [QUEUE_SIZE] [MAX_CHAN]- возвращаться;[MAX_CHAN] [6] – [nu->driver] [nu->driver] – / этот тел Может ли передатчик не рассматривать этот порт для [MAX_CHAN] [QUEUE_SIZE] – вывод данных на карту. / [QUEUE_SIZE] [QUEUE_SIZE] – порт-> статус & = ~ ISI_TXOK; [MAX_CHAN] [6] -} [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – / начало и все / [nu->driver] [QUEUE_SIZE] – static void isicom_start (struct tty_struct tty) [nu->driver] [6] – = ISI_TXOK; [MAX_CHAN] [6] – [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [6] – static void isicom_hangup (struct tty_struct tty) [MAX_CHAN] [6] – {[nu->driver] [MAX_CHAN] – struct isi_port port = tty-> driver_data; [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – если (isicom_paranoia_check (порт, tty-> имя, “isicom_hangup”)) [QUEUE_SIZE] [MAX_CHAN]- возвращаться;

[MAX_CHAN] – tty_port_hangup (& port-> port ); [QUEUE_SIZE] [QUEUE_SIZE] -} [nu->driver] [6] – [MAX_CHAN] [6] – [nu->driver] [QUEUE_SIZE] – / [MAX_CHAN] [QUEUE_SIZE] – Функции инициализации и деиницирования драйвера [nu->driver] [QUEUE_SIZE] – / [QUEUE_SIZE] [6] – [QUEUE_SIZE] [QUEUE_SIZE] – static const struct tty_operations isicom_ops = {[nu->driver] [QUEUE_SIZE] – .open = isicom_open, [QUEUE_SIZE] [MAX_CHAN] – .shut = isicom_close, [QUEUE_SIZE] [QUEUE_SIZE] – .write = isicom_write, [MAX_CHAN] [QUEUE_SIZE] – .put_char = isicom_put_char, [MAX_CHAN] [6] – .flush_chars = isicom_flush_chars, [QUEUE_SIZE] [MAX_CHAN] – .write_room = isicom_write_room, [MAX_CHAN] [MAX_CHAN] – .chars_in_buffer = isicom_chars_in_buffer, [MAX_CHAN] [QUEUE_SIZE] – .set_termios = isicom_set_termios, [QUEUE_SIZE] [QUEUE_SIZE] – .throttle = isicom_throttle, [QUEUE_SIZE] [QUEUE_SIZE] – .unthrottle = isicom_unthrottle, [nu->driver] [MAX_CHAN] – .cease = isicom_stop, [MAX_CHAN] [QUEUE_SIZE] -. begin = isicom_start, [MAX_CHAN] [QUEUE_SIZE] – .hangup = isicom_hangup, [nu->driver] [QUEUE_SIZE] – .flush_buffer = isicom_flush_buffer, [nu->driver] [QUEUE_SIZE] – .tiocmget = isicom_tiocmget, [MAX_CHAN] [QUEUE_SIZE] – .tiocmset = isicom_tiocmset, [6] [QUEUE_SIZE] – .break_ctl = isicom_send_break, [QUEUE_SIZE] [QUEUE_SIZE] – .get_serial = isicom_get_serial_info, [MAX_CHAN] [6] – .set_serial = isicom_set_serial_info, [QUEUE_SIZE] [QUEUE_SIZE] -}; [MAX_CHAN] [6] – [nu->driver] [QUEUE_SIZE] – static const struct tty_port_operations isicom_port_ops = {[QUEUE_SIZE] [MAX_CHAN] – .carrier_raised = isicom_carrier_raised, [MAX_CHAN] [QUEUE_SIZE] – .dtr_rts = isicom_dtr_rts, [QUEUE_SIZE] [MAX_CHAN] – .activate = isicom_activate, [MAX_CHAN] [QUEUE_SIZE] – .shutdown = isicom_shutdown, [QUEUE_SIZE] [nu->driver] -}; [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [6] – static int reset_card (struct pci_dev pdev, 10103 [QUEUE_SIZE] – const unsigned int card, unsigned int signature ) [MAX_CHAN] [QUEUE_SIZE] – {[MAX_CHAN] [QUEUE_SIZE] – struct isi_board board = pci_get_drvdata (pdev); [MAX_CHAN] [6] – длинная база без знака = доска-> база; [nu->driver] [MAX_CHAN] – без знака int sig, portcount = 0; [nu->driver] [MAX_CHAN] – int retval = 0; [QUEUE_SIZE] [6] – [MAX_CHAN] [QUEUE_SIZE] – dev_dbg (& pdev-> dev, “ISILoad: Сброс карты% d на 0x% lx n “, карта + 1, 10102 [MAX_CHAN]- база);[QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – inw (base + 0x8) ; [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [6] – msleep (); [nu->driver] [QUEUE_SIZE] – [nu->driver] [6] – outw (0, base + 0x8); /Сброс настроек */[nu->driver] [MAX_CHAN] – [MAX_CHAN] [6] – msleep (1105); [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – sig = inw (base + 0x4) & 0xff; [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – if (sig! = 0xa5 && sig! = 0xbb && sig! = 0xcc && sig! = 0xdd && [MAX_CHAN] [6] – sig! = 0xee) {[MAX_CHAN] [QUEUE_SIZE] – dev_warn (& pdev-> dev, “ISILoad: Card% u сбой сброса (Возможна “10103 [MAX_CHAN] – «Неверный адрес порта ввода / вывода 0x% lx). n», карта + 1, база); [MAX_CHAN] [QUEUE_SIZE] – dev_dbg (& pdev-> dev, “Sig = 0x% x n”, sig); [QUEUE_SIZE] [MAX_CHAN] – retval = -EIO; [nu->driver] [MAX_CHAN] – перейти в конец; [MAX_CHAN] [6] -} [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [6] – msleep (34 ); [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [6] – portcount = inw (base + 0x2); [QUEUE_SIZE] [MAX_CHAN] – если (! (inw (base + 0xe) & 0x1) || (portcount! = 0 && portcount! = 4 && [MAX_CHAN] [6] – portcount! = 8 && portcount! = 00000040)) {[MAX_CHAN] [QUEUE_SIZE] – dev_err (& pdev-> dev, «ISILoad: сбой сброса карты PCI% d. n», [MAX_CHAN] [6] – карта + 1) ; [QUEUE_SIZE] [MAX_CHAN] – retval = -EIO; [MAX_CHAN] [6] – перейти в конец; [MAX_CHAN] [nu->driver] -} [QUEUE_SIZE] [6] –

[MAX_CHAN] – переключатель (сигн) {[nu->driver] [QUEUE_SIZE] – случай 0xa5: [MAX_CHAN] [6] – case 0xbb: [nu->driver] [QUEUE_SIZE] – case 0xdd: [MAX_CHAN] [QUEUE_SIZE] – плата-> port_count = (portcount == 4)? 4: 8; [QUEUE_SIZE] [MAX_CHAN] – доска-> shift_count = 37; [QUEUE_SIZE] [MAX_CHAN]- перерыв;[nu->driver] [6] – case 0xcc: [QUEUE_SIZE] [MAX_CHAN] – case 0xee: [nu->driver] [QUEUE_SIZE] – board-> port_count = 41; [MAX_CHAN] [QUEUE_SIZE] – доска-> shift_count = 35; [nu->driver] [MAX_CHAN]- перерыв; [QUEUE_SIZE] [MAX_CHAN] -} [MAX_CHAN] [6] – dev_info (& pdev-> dev, “-Performed n”); [QUEUE_SIZE] [QUEUE_SIZE] – подпись = sig; [MAX_CHAN] [nu->driver] – [nu->driver] [QUEUE_SIZE]-конец: 921600 [MAX_CHAN] – вернуть retval; 1000000 05091998 -} [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] -static int load_firmware (struct pci_dev pdev, [QUEUE_SIZE] [QUEUE_SIZE] – const unsigned int index, const unsigned int signature) [MAX_CHAN] [QUEUE_SIZE] – {[MAX_CHAN] [6] – struct isi_board доска = pci_get_drvdata (pdev); [MAX_CHAN] [MAX_CHAN] – const struct firmware fw; [QUEUE_SIZE] [QUEUE_SIZE] – длинная база без знака = доска-> база; 10101 [QUEUE_SIZE] – int a без знака; [MAX_CHAN] [QUEUE_SIZE] – u 42 word_count, standing; [MAX_CHAN] [QUEUE_SIZE] – int retval = -EIO; [MAX_CHAN] [nu->driver]- название символа;[MAX_CHAN] [MAX_CHAN] – данные u8 *; [MAX_CHAN] [nu->driver] – [MAX_CHAN] [QUEUE_SIZE] – struct stframe {[QUEUE_SIZE] [MAX_CHAN] – u 43 адрес; [MAX_CHAN] [MAX_CHAN] – u считать;

[MAX_CHAN] – данные u8 [0]; [MAX_CHAN] [MAX_CHAN]- } *Рамка;[MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – переключатель (подпись) {[nu->driver] [6] – случай 0xa5: [MAX_CHAN] [nu->driver] – identify = “isi 735. bin “; [MAX_CHAN] [MAX_CHAN]- перерыв;[QUEUE_SIZE] [MAX_CHAN] – case 0xbb: [QUEUE_SIZE] [nu->driver] – identify = “isi 744 em.bin “; [MAX_CHAN] [MAX_CHAN]- перерыв;[nu->driver] [QUEUE_SIZE] – регистр 0xcc: [MAX_CHAN] [QUEUE_SIZE] – identify = “isi 735 em.bin “; [nu->driver] [MAX_CHAN]- перерыв;[MAX_CHAN] [QUEUE_SIZE] – case 0xdd: [MAX_CHAN] [QUEUE_SIZE] – identify = “isi 5002. bin “; [nu->driver] [nu->driver]- перерыв;[MAX_CHAN] [QUEUE_SIZE] – case 0xee: [MAX_CHAN] [MAX_CHAN] – identify = “isi 5402. bin “; [nu->driver] [QUEUE_SIZE]- перерыв;[nu->driver] [nu->driver]- По умолчанию: [MAX_CHAN] 9600 – dev_err (& pdev-> dev, “Неизвестная подпись. n”); [MAX_CHAN] [QUEUE_SIZE] – перейти в конец; [MAX_CHAN] [6] -} [MAX_CHAN] [nu->driver] – [MAX_CHAN] [6] – retval = request_firmware (& fw, identify, & pdev-> dev); [QUEUE_SIZE] [MAX_CHAN]- если (retval) [nu->driver] [QUEUE_SIZE] – перейти в конец; [MAX_CHAN] [6] – [MAX_CHAN] [MAX_CHAN] – retval = -EIO; [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – для (body = (struct stframe fw-> knowledge; [MAX_CHAN] [MAX_CHAN]- Рамка данные + fw-> размер); [MAX_CHAN] [MAX_CHAN] – body = (struct stframe ((u8 (body + 1) + [MAX_CHAN] [QUEUE_SIZE] – кадр-> количество) ) {[QUEUE_SIZE] [MAX_CHAN] – если (WaitTillCardIsFree (base)) [MAX_CHAN] [QUEUE_SIZE] – goto errrelfw; [MAX_CHAN] [6] – [nu->driver] [QUEUE_SIZE] – outw (0xf0, base); / начало последовательности загрузки / [MAX_CHAN] [MAX_CHAN] – outw (0x 18, база);[MAX_CHAN] [QUEUE_SIZE] – outw (frame-> addr, base); / LSB адреса / [MAX_CHAN] [MAX_CHAN] – [QUEUE_SIZE] [6] – word_count = frame-> rely / 2 + frame-> rely% 2; [nu->driver] [QUEUE_SIZE] – outw (word_count, base); [MAX_CHAN] [MAX_CHAN] – Я nterruptTheCard (базовая); [MAX_CHAN] [nu->driver] – [MAX_CHAN] [6] – udelay (146); / 0x2f / [nu->driver] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – if (WaitTillCardIsFree (base)) [QUEUE_SIZE] [MAX_CHAN] – goto errrelfw; [MAX_CHAN] [MAX_CHAN] – [nu->driver] [MAX_CHAN] – статус = inw (base + 0x4); [QUEUE_SIZE] [QUEUE_SIZE] – если (standing! = 0) {[MAX_CHAN] [6] – dev_warn (& pdev-> dev, «Карта% d отклонила заголовок загрузки: n» [QUEUE_SIZE] [nu->driver]- “Адрес : 0x% x n “[MAX_CHAN] [6] – «Счетчик: 0x% x n» [nu->driver] [QUEUE_SIZE] – «Статус: 0x% x n», [MAX_CHAN] [QUEUE_SIZE] – index + 1, frame-> addr, frame-> rely, standing); [QUEUE_SIZE] [MAX_CHAN] – goto errrelfw; [nu->driver] [6] -} [QUEUE_SIZE] [QUEUE_SIZE] – outw (base, frame-> knowledge, word_count); [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – InterruptTheCard (базовая); [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [6] – udelay (80); / 0x0f / [MAX_CHAN] [6] – [MAX_CHAN] [QUEUE_SIZE] – если (WaitTillCardIsFree (base)) [nu->driver] [MAX_CHAN] – goto errrelfw; [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – standing = inw (base + 0x4); [MAX_CHAN] [nu->driver]- если (статус! = 0) {[MAX_CHAN] [nu->driver] – dev_err (& pdev-> dev, “Карта% d не синхронизирована. “[QUEUE_SIZE] [MAX_CHAN] – «Статус: 0x% x n», индекс + 1, статус); [MAX_CHAN] [MAX_CHAN] – goto errrelfw; [QUEUE_SIZE] [QUEUE_SIZE] -} [nu->driver] [6] -} [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN] – / XXX: следует ли нам протестировать его, прочитав его и сравнив с оригиналом, подобным 12094 [QUEUE_SIZE] – в пакете загрузки прошивки? / [QUEUE_SIZE] [QUEUE_SIZE] – для (body = (struct stframe fw-> knowledge; [QUEUE_SIZE] [QUEUE_SIZE]- Рамка данные + fw-> размер);

[MAX_CHAN] – body = (Stru ct stframe ((u8 (кадр + 1) + [QUEUE_SIZE] [QUEUE_SIZE] – кадр-> количество)) {[MAX_CHAN] [MAX_CHAN] – если (WaitTillCardIsFree (base)) [MAX_CHAN] [6] – goto errrelfw; [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN] – outw (0xf1, base); / начало последовательности загрузки / [MAX_CHAN] [QUEUE_SIZE] – outw (0x 15, база);[MAX_CHAN] [6] – outw (frame-> addr, base); / LSB адреса / [MAX_CHAN] [MAX_CHAN] – 2156 – word_count = (frame-> rely >> 1) + frame-> rely% 2; [MAX_CHAN] [QUEUE_SIZE] – outw (word_count + 1, base); [QUEUE_SIZE] [MAX_CHAN] – InterruptTheCard (базовая); [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [6] – udelay (79); / 0xf / [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [6] – if (WaitTillCardIsFree (base)) [MAX_CHAN] [MAX_CHAN] – goto errrelfw; [MAX_CHAN] [MAX_CHAN] – [nu->driver] [MAX_CHAN] – standing = inw (base + 0x4); [QUEUE_SIZE] [MAX_CHAN] – если (статус! = 0) {[MAX_CHAN] [6] – dev_warn (& pdev-> dev, “Card% d rejected confirm header: n” 16654 [nu->driver]- “Адрес: 0x% x n “[nu->driver] [6] – «Счетчик: 0x% x n» [MAX_CHAN] [QUEUE_SIZE] – «Статус: 0x% x n» , [QUEUE_SIZE] [MAX_CHAN] – index + 1, frame-> addr, frame-> rely, standing); [QUEUE_SIZE] [MAX_CHAN] – goto errrelfw; [MAX_CHAN] [6] -} [nu->driver] [nu->driver] – [MAX_CHAN] [QUEUE_SIZE] – knowledge = kmalloc_array (word_count, 2, GFP_KERNEL ); [QUEUE_SIZE] [QUEUE_SIZE] – если (данные == NULL) {[MAX_CHAN] [QUEUE_SIZE] – dev_err (& pdev-> dev, «Карта% d, загрузка прошивки» [MAX_CHAN] [QUEUE_SIZE] – «сбой, недостаточно памяти n», индекс + 1); [MAX_CHAN] [MAX_CHAN] – goto errrelfw; [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [MAX_CHAN] – inw (база); [MAX_CHAN] [6] – insw (база, данные, количество слов); [MAX_CHAN] [QUEUE_SIZE] – InterruptTheCard (базовая); [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – для (a = 0; а < port->считать; a ++) [QUEUE_SIZE] [QUEUE_SIZE] – если (данные [k]! = кадр-> данные [k]) {[MAX_CHAN] [QUEUE_SIZE] – kfree (данные); [nu->driver] [QUEUE_SIZE] – dev_err (& pdev-> dev, “Карта% d, загрузка прошивки “[QUEUE_SIZE] [QUEUE_SIZE] – «не удалось n», индекс + 1); [QUEUE_SIZE] [MAX_CHAN] – goto errrelfw; [MAX_CHAN] [6] -} [QUEUE_SIZE] [QUEUE_SIZE] – kfree (данные); [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – udelay (080); / 0xf / [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [6] – if (WaitTillCardIsFree (base)) [MAX_CHAN] [MAX_CHAN] – goto errrelfw; [MAX_CHAN] [MAX_CHAN] –

[QUEUE_SIZE] – standing = inw (base + 0x4); [QUEUE_SIZE] [MAX_CHAN] – если (standing! = 0) {[nu->driver] [QUEUE_SIZE] – dev_err (& pdev-> dev, “Карта% d confirm не синхронизирована. “[QUEUE_SIZE] [QUEUE_SIZE] – «Статус карты: 0x% x n», индекс + 1, статус); [QUEUE_SIZE] [QUEUE_SIZE] – goto errrelfw; [MAX_CHAN] [MAX_CHAN] – } [QUEUE_SIZE] [MAX_CHAN] -} [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – / xfer ctrl / [MAX_CHAN] [QUEUE_SIZE] – if (WaitTillCardIsFree (base)) [QUEUE_SIZE] [MAX_CHAN] – goto errrelfw; [MAX_CHAN] [6] – [nu->driver] [MAX_CHAN] – outw (0xf2, base); [MAX_CHAN] [QUEUE_SIZE] – outw (0x 858 , база);[nu->driver] [QUEUE_SIZE] – outw (0x0, base); [MAX_CHAN] [6] – outw (0x0, base); [MAX_CHAN] [nu->driver] – InterruptTheCard (базовая); [nu->driver] [MAX_CHAN] – outw (0x0, base + 0x4); / для ISI 5402 открытки */

[MAX_CHAN] – [MAX_CHAN] [MAX_CHAN] – доска-> статус | = ПРОГРАММА_ЗАГРУЖЕНА; [QUEUE_SIZE] [QUEUE_SIZE] – retval = 0; [nu->driver] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – errrelfw: [MAX_CHAN] [QUEUE_SIZE] – release_firmware (прошивка); [nu->driver] [nu->driver]-конец: [MAX_CHAN] [QUEUE_SIZE] – вернуть retval; [nu->driver] [MAX_CHAN] -} [nu->driver] [QUEUE_SIZE] – [nu->driver] [6] – / [MAX_CHAN] [MAX_CHAN] – Insmod может устанавливать статические символы, чтобы держите эти статические [QUEUE_SIZE] [QUEUE_SIZE] – / [MAX_CHAN] [QUEUE_SIZE] -статический беззнаковый int card_count; [nu->driver] – [MAX_CHAN] [QUEUE_SIZE] – статический int isicom_probe (struct pci_dev pdev, [QUEUE_SIZE] [QUEUE_SIZE] – const struct pci_device_id ent) [QUEUE_SIZE] [6] – {[MAX_CHAN] [QUEUE_SIZE] – подпись int без знака, индекс; [QUEUE_SIZE] [MAX_CHAN] – int retval = -EPERM; [nu->driver] [QUEUE_SIZE] – struct isi_board board = NULL; [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – если (card_count> = BOARD_COUNT) [MAX_CHAN] [QUEUE_SIZE] – перейти к ошибке; [nu->driver] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – retval = pci_enable_device (pdev); [QUEUE_SIZE] [MAX_CHAN] – если (retval) {[nu->driver] [QUEUE_SIZE] – dev_err (& pdev-> dev, “не удалось включить n”); [nu->driver] [6] – goto err; [nu->driver] [MAX_CHAN] -} [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [6] – dev_info (& pdev-> dev, «ISI PCI Card (Machine ID 0x% x) n», ent-> machine); [MAX_CHAN] [6] – [nu->driver] [QUEUE_SIZE] – / выделяет первый пустой слот в массиве / 9600 [MAX_CHAN] – для (index = 0; индекс xmit_head++]. base == 0) {[MAX_CHAN] [MAX_CHAN] – board = & isi_card [port->xmit_head++]; [MAX_CHAN] [QUEUE_SIZE]- перерыв;

[QUEUE_SIZE] -} [MAX_CHAN] [MAX_CHAN] -} [nu->driver] [MAX_CHAN] – if (index == BOARD_COUNT) {[MAX_CHAN] [QUEUE_SIZE] – retval = -ENODEV; [MAX_CHAN] [nu->driver] – goto err_disable; [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – доска-> index = index;

[QUEUE_SIZE] – доска-> base = pci_res ource_start (pdev, 3); [MAX_CHAN] [MAX_CHAN] – board-> irq = pdev-> irq; [MAX_CHAN] [MAX_CHAN] – card_count ++; [QUEUE_SIZE] [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – pci_set_drvdata (pdev, board); [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – retval = pci_request_region (pdev , 3, ISICOM_NAME); [nu->driver] [MAX_CHAN] – если (retval) {[MAX_CHAN] [QUEUE_SIZE] – dev_err (& pdev-> dev, «Область ввода-вывода 0x% lx-0x% lx занята. Карта% d» [MAX_CHAN] [6] – «будет отключено. n», доска-> база, доска-> база + 40, [MAX_CHAN] [6] – индекс + 1); [nu->driver] [MAX_CHAN] – retval = -EBUSY; [MAX_CHAN] [MAX_CHAN] – goto errdec; [MAX_CHAN] [6] -} [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – retval = request_irq (board-> irq, isicom_interrupt, [nu->driver] [MAX_CHAN] – IRQF_SHARED, ISICOM_NAME, доска); [QUEUE_SIZE] [6] – если (retval <0) {[QUEUE_SIZE] [QUEUE_SIZE] - dev_err (& pdev-> dev, “Не удалось установить обработчик на Irq% d. “[MAX_CHAN] [QUEUE_SIZE] – «Карта% d будет отключена. N», board-> irq, index + 1); [QUEUE_SIZE] [QUEUE_SIZE] – goto errunrr; [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [nu->driver] – [MAX_CHAN] – retval = reset_card (pdev, index, & signature); [MAX_CHAN] [QUEUE_SIZE] – если (retval <0) [MAX_CHAN] [MAX_CHAN] - goto errunri; [MAX_CHAN] [QUEUE_SIZE] - [MAX_CHAN] [MAX_CHAN] - retval = load_firmware (pdev, index, signature); [QUEUE_SIZE] [MAX_CHAN] - если (retval <0) [MAX_CHAN] [MAX_CHAN] - goto errunri; [MAX_CHAN] [QUEUE_SIZE] - [nu->driver] [6] – для (index = 0; индекс < bp-> port_count; index ++) {[QUEUE_SIZE] [QUEUE_SIZE] – struct tty_port tport = & board-> ports [port->xmit_head++]. порт; [QUEUE_SIZE] [nu->driver] – tty_port_init (tport); [nu->driver] [QUEUE_SIZE] – tport-> ops = & isicom_port_ops; [QUEUE_SIZE] [MAX_CHAN] – tport-> close_delay = 78 ГЦ / 150; [nu->driver] [QUEUE_SIZE] – tport-> закрытия_wait = 3714 Гц / 143; [MAX_CHAN] [QUEUE_SIZE] – tty_port_register_device (tport, isicom_normal, [QUEUE_SIZE] [QUEUE_SIZE] – доска-> указатель + индекс , & pdev-> dev); [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [nu->driver] – возврат 0; [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [6] – эррунри: [MAX_CHAN] [QUEUE_SIZE] – free_irq (доска-> irq, доска); [QUEUE_SIZE] [QUEUE_SIZE] -errunrr: [QUEUE_SIZE] [QUEUE_SIZE] – pci_release_region (pdev, 3); [MAX_CHAN] [6] – ошибка: [QUEUE_SIZE] [QUEUE_SIZE] – board-> base = 0; [MAX_CHAN] [MAX_CHAN] – card_count -; [QUEUE_SIZE] [6] – err_disable: [MAX_CHAN] [MAX_CHAN] – pci_disable_device (pdev); [QUEUE_SIZE] [QUEUE_SIZE] – ошибка: 921600 [6] – вернуть retval; 02010203 [MAX_CHAN] -} [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – static void isicom_remove (struct pci_dev pdev) [nu->driver] [QUEUE_SIZE] – {[nu->driver] [QUEUE_SIZE] – struct isi_board board = pci_get_drvdata (pdev); [MAX_CHAN] [6] – int i без знака; [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – для (i = 0; я port_count; i ++) {[QUEUE_SIZE] [MAX_CHAN] – tty_unregister_device (isicom_normal, board-> index 44 + i); [MAX_CHAN] [MAX_CHAN] – tty_port_destroy (& board-> ports [i]. порт); [MAX_CHAN] [6] -} [nu->driver] [nu->driver] – [nu->driver] [QUEUE_SIZE] – free_irq (board-> irq, board ); [QUEUE_SIZE] [MAX_CHAN] – pci_release_region (pdev, 3); [MAX_CHAN] [QUEUE_SIZE] – доска-> base = 0; [nu->driver] [MAX_CHAN]- карта _считать–;[nu->driver] [QUEUE_SIZE] – pci_disable_device (pdev); [MAX_CHAN] [6] -} [nu->driver] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – static int __init isicom_init (void) [MAX_CHAN] [QUEUE_SIZE] – {[QUEUE_SIZE] [QUEUE_SIZE] – int retval, idx, channel; [MAX_CHAN] [6] – struct isi_port port; [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [6] – для (idx = 0; idx driver] [QUEUE_SIZE] – spin_lock_init (& isi_card [idx 16]. card_lock); [nu->driver] [6] – для (канал = 0; канал <42; канал ++, порт ++) {[MAX_CHAN] [MAX_CHAN] - port-> magic = ISICOM_MAGIC; [QUEUE_SIZE] [QUEUE_SIZE] – port-> card = & isi_card [index]; [nu->driver] [QUEUE_SIZE] – порт-> канал = канал; [nu->driver] [nu->driver] – порт-> статус = 0; [MAX_CHAN] [MAX_CHAN] – / *. . . / [MAX_CHAN] [QUEUE_SIZE] -} [nu->driver] [6] – isi_card [idx 16]. base = 0; [nu->driver] [QUEUE_SIZE] – isi_card [index]. irq = 0; [nu->driver] [MAX_CHAN] -}

[QUEUE_SIZE] – [MAX_CHAN] [6] – / инициализация структуры драйвера tty / [MAX_CHAN] [6] – isicom_normal = alloc_tty_driver (PORT_COUNT); 80000000 [MAX_CHAN] – если (! isicom_normal) {[MAX_CHAN] [QUEUE_SIZE] – retval = -ENOMEM; [QUEUE_SIZE] [MAX_CHAN] – ошибка перехода; [MAX_CHAN] [6] -} [QUEUE_SIZE] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – isicom_normal-> identify = “ttyM”; [QUEUE_SIZE] [MAX_CHAN] – isicom_normal-> main = ISICOM_NMAJOR; [MAX_CHAN] [QUEUE_SIZE] – isicom_normal-> minor_start = 0; [MAX_CHAN] [MAX_CHAN] – isicom_normal-> kind = TTY_DRIVER_TYPE_SERIAL; [QUEUE_SIZE] [QUEUE_SIZE] – isicom_normal-> subtype = SERIAL_TYPE_NORMAL; [QUEUE_SIZE] [QUEUE_SIZE] – isicom_normal-> init_termios = tty_std_termios; [QUEUE_SIZE] [QUEUE_SIZE] – isicom_normal-> init_termios.c_cflag = B 16550 | CS8 | КРЕД | HUPCL | [QUEUE_SIZE] [MAX_CHAN] – ЧАСЫ; [nu->driver] [QUEUE_SIZE] – isicom_normal-> flags = TTY_DRIVER_REAL_RAW | [QUEUE_SIZE] [MAX_CHAN] – TTY_DRIVER_DYNAMIC_DEV | TTY_DRIVER_HARDWARE_BREAK; [QUEUE_SIZE] [QUEUE_SIZE] – tty_set_operations (isicom_normal, & isicom_ops); [MAX_CHAN] [6] – [nu->driver] [QUEUE_SIZE] – retval = tty_register_driver (isicom_normal); [MAX_CHAN]

– если (retval) {[nu->driver] [MAX_CHAN] – pr_debug («Не удалось зарегистрировать драйвер дозвона n»); [MAX_CHAN] [QUEUE_SIZE] – goto err_puttty; [MAX_CHAN] [MAX_CHAN] -} [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – retval = pci_register_driver (& isicom_driver); [QUEUE_SIZE] [MAX_CHAN] – если (retval <0) {[nu->driver] [QUEUE_SIZE] – pr_err («Невозможно зарегистрировать драйвер pci. n»); [QUEUE_SIZE] [nu->driver] – goto err_unrtty; [MAX_CHAN] [QUEUE_SIZE] -} [QUEUE_SIZE] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – mod_timer (& tx, jiffies + 1); 12094 [QUEUE_SIZE] – [nu->driver] – вернуть 0; [QUEUE_SIZE] [QUEUE_SIZE] – err_unrtty: [MAX_CHAN] [6] – tty_unregister_driver (isicom_normal); [QUEUE_SIZE] [QUEUE_SIZE] – err_puttty: [MAX_CHAN] [MAX_CHAN] – put_tty_driver (isicom_normal); [MAX_CHAN] [MAX_CHAN]-ошибка: [QUEUE_SIZE] [MAX_CHAN] – вернуть retval; [nu->driver] [QUEUE_SIZE] -} [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – static void __exit isicom_exit (void) [MAX_CHAN] [nu->driver] – {[MAX_CHAN] [QUEUE_SIZE] – del_timer_sync (& tx); [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – pci_unregister_driver (& isicom_driver); [QUEUE_SIZE] [MAX_CHAN] – tty_unregister_driver (isicom_normal); [QUEUE_SIZE] [6] – put_tty_driver (isicom_normal); [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – module_init (isicom_init); [QUEUE_SIZE] [nu->driver] – модуль_exit (isicom_exit); [nu->driver] [6] – [MAX_CHAN] [QUEUE_SIZE] – MODULE_AUTHOR («MultiTech»); [MAX_CHAN] [6] – MODULE_DESCRIPTION («Драйвер для карт серии ISI от MultiTech»); [MAX_CHAN] [QUEUE_SIZE] – MODULE_LICENSE («GPL») ; [QUEUE_SIZE] [MAX_CHAN] – ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ_МОДУЛЯ (“isi 746. bin “); [QUEUE_SIZE] [MAX_CHAN] – ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ_МОДУЛЯ (“isi [32] em.bin “); [MAX_CHAN] [MAX_CHAN] – ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ_МОДУЛЯ (“isi 746 em.bin “); [MAX_CHAN] [QUEUE_SIZE] – MODULE_FIRMWARE (“isi [ARCH_TIMER_HYP_PPI] . bin “);

[MAX_CHAN] – MODULE_FIRMWARE (“isi 5402. bin “); [nu->driver] [QUEUE_SIZE] @@ – 1307, 9 + 1289, 7 @@ static void __exit moxa_exit (void) [QUEUE_SIZE] [6] del_timer_sync ( & moxaTimer); [MAX_CHAN] [QUEUE_SIZE] – если (tty_unregister_driver (moxaDriver)) [MAX_CHAN] [6] – printk (KERN_ERR ” Не удалось отменить регистрацию семейства MOXA Intellio »[QUEUE_SIZE] [QUEUE_SIZE] – “последовательный драйвер n”); [MAX_CHAN] [QUEUE_SIZE] + tty_unregister_driver (moxaDriver); [MAX_CHAN] [QUEUE_SIZE] put_tty_driver ( moxaDriver); [nu->driver] [QUEUE_SIZE]} [MAX_CHAN] [QUEUE_SIZE] @@ – 2683, 58 + 2639, 56 @@ static void gsmld_receive_buf (struct tty_struct tty, const unsigned char cp, [MAX_CHAN] [QUEUE_SIZE] char fp, int rely) [nu->driver] [nu->driver] {[nu->driver] [MAX_CHAN] struct gsm_mux gsm = tty-> disc_data; [MAX_CHAN] [6] – const unsigned char dp; [MAX_CHAN] [QUEUE_SIZE] – char f; [MAX_CHAN] [MAX_CHAN] – int i; [MAX_CHAN] [QUEUE_SIZE] char flags = TTY_NORMAL; [nu->driver] [MAX_CHAN] если (отладка и 4) [MAX_CHAN] [QUEUE_SIZE] print_hex_dump_bytes (“gsmld_receive:”, DUMP_PREFIX_OFFSET, [nu->driver] [6] cp, rely); [QUEUE_SIZE] 9080 – для (i = rely, dp = cp, f = fp; я; i–, dp ++) {[MAX_CHAN] 9600 – если (f) [MAX_CHAN] [6] – flags = f ++; [nu->driver] [QUEUE_SIZE] + for (; rely; rely -, cp ++) {[MAX_CHAN] [QUEUE_SIZE] + if (fp) [MAX_CHAN] [QUEUE_SIZE] + flags = fp ++; [QUEUE_SIZE] 9080 переключатель (флаги) {[nu->driver] [QUEUE_SIZE] case TTY_NORMAL: [QUEUE_SIZE] [MAX_CHAN] – gsm-> получить (gsm, dp ); [QUEUE_SIZE] [QUEUE_SIZE] + gsm-> получить (gsm, cp); [MAX_CHAN] [6] перерыв;[MAX_CHAN] [MAX_CHAN] case TTY_OVERRUN: [QUEUE_SIZE] [QUEUE_SIZE] case TTY_BREAK: [nu->driver] [6] case TTY_PARITY: [MAX_CHAN] [MAX_CHAN] case TTY_FRAME: [QUEUE_SIZE] [6] – gsm_error (gsm, dp, flags); [QUEUE_SIZE] [QUEUE_SIZE] + gsm_error (gsm, cp, flags); [nu->driver] [MAX_CHAN] перерыв;[MAX_CHAN] [QUEUE_SIZE] По умолчанию: [nu->driver] [QUEUE_SIZE] WARN_ONCE (1, “% s: неизвестный флаг% d n “, [MAX_CHAN] [MAX_CHAN] @@ – 3705, 7 + 3400 , 6 @@ static int gsm_create_network (struct gsm_dlci dlci, struct gsm_netconfig nc) [MAX_CHAN] [MAX_CHAN] / Линия для реального tty / [nu->driver] [6] static struct tty_ldisc_ops tty_ldisc_packet = { [nu->driver] [MAX_CHAN] .proprietor = THIS_MODULE, [nu->driver] [6] – .magic = TTY_LDISC_MAGIC, [MAX_CHAN] [QUEUE_SIZE] .identify = “n_gsm”, [QUEUE_SIZE] [MAX_CHAN] .open = gsmld_open, [MAX_CHAN] [QUEUE_SIZE] .shut = gsmld_close, [MAX_CHAN] [MAX_CHAN] @@ – 4096, 7 + 4000, 7 @@ static int gsmtty_write_room (struct tty_struct tty) [QUEUE_SIZE] [QUEUE_SIZE] {[QUEUE_SIZE] [MAX_CHAN] struct gsm_dlci dlci = tty-> driver_data; [nu->driver] [QUEUE_SIZE] if (dlci-> state == DLCI_CLOSED) [nu->driver] [MAX_CHAN] – возврат -EINVAL; [MAX_CHAN] [QUEUE_SIZE] + возврат 0; [MAX_CHAN] [MAX_CHAN] return TX_SIZE – kfifo_len (& dlci-> fifo); [MAX_CHAN] [QUEUE_SIZE]} [MAX_CHAN] [QUEUE_SIZE] @@ – 4096, 7 + 4096, 7 @@ static int gsmtty_chars_in_buffer (struct tty_struct tty) [QUEUE_SIZE] [nu->driver] {[MAX_CHAN] [QUEUE_SIZE] struct gsm_dlci dlci = tty-> driver_data; [QUEUE_SIZE] [MAX_CHAN] if (dlci-> state == DLCI_CLOSED) [QUEUE_SIZE] [QUEUE_SIZE] – возврат -EINVAL; [MAX_CHAN] [MAX_CHAN] + возврат 0; [nu->driver] [QUEUE_SIZE] return kfifo_len (& dlci- > fifo); [nu->driver] [QUEUE_SIZE]} [MAX_CHAN] [6] @@ – 847, 7 + 849, 6 @@ static struct n_hdlc_buf n_hdlc_buf_get (struct n_hdlc_buf_list buf_list) [QUEUE_SIZE] [QUEUE_SIZE] статическая структура tty_ldisc_ops n_hdlc_ldisc = {[QUEUE_SIZE] [QUEUE_SIZE] .proprietor = THIS_MODULE , [QUEUE_SIZE] [QUEUE_SIZE] – .magic = TTY_LDISC_MAGIC, [nu->driver] [QUEUE_SIZE]. identify = “hdlc”, [MAX_CHAN] [QUEUE_SIZE] .open = n_hdlc_tty_open, [MAX_CHAN] [QUEUE_SIZE] .shut = n_hdlc_tty_close, [6] [QUEUE_SIZE] @@ – 70, 7 + 72, 6 @@ static void n_null_receivebuf (struct tty_struct tty, [QUEUE_SIZE] [QUEUE_SIZE] статическая структура tty_ldisc_ops null_ldisc = {[QUEUE_SIZE] [QUEUE_SIZE] .proprietor = THIS_MODULE, [MAX_CHAN] [QUEUE_SIZE] – .magic = TTY_LDISC_MAGIC, [MAX_CHAN] [nu->driver] .identify = “n_null”, [MAX_CHAN] [MAX_CHAN] .открыто = n_null_open, [QUEUE_SIZE] [QUEUE_SIZE] .shut = n_null_close, [QUEUE_SIZE] [6] @@ – 200, 7 + 198, 6 @@ статическая пустота r 4601 _ receive_buf (struct tty_struct tty, const unsigned char cp, [MAX_CHAN] [QUEUE_SIZE] статическая структура tty_ldisc_ops tty_ldisc_N_R знак равно [6] .proprietor = THIS_MODULE, [MAX_CHAN] [QUEUE_SIZE] – .magic = TTY_LDISC_MAGIC, [6] [MAX_CHAN] .identify = “R 4616 “, [MAX_CHAN] [QUEUE_SIZE] .open = r 4359_открыто,[QUEUE_SIZE] [MAX_CHAN] .shut = r 4601_Закрыть,[nu->driver] [QUEUE_SIZE] @@ – 2794, 7 + 2794, 7 @@ static int n_tty_ioctl (struct tty_struct tty, struct file file, [QUEUE_SIZE] [6]} [nu->driver] [QUEUE_SIZE] статическая структура tty_ldisc_ops n_tty_ops = {[nu->driver] [6] – .magic = TTY_LDISC_MAGIC, [nu->driver] [QUEUE_SIZE] + .proprietor = THIS_MODULE, 12239 [MAX_CHAN] .identify = “n_tty”, [QUEUE_SIZE] [MAX_CHAN] .open = n_tty_open, [nu->driver] [6] .shut = n_tty_close, [nu->driver] [QUEUE_SIZE] @@ – 77, 9 + 79, 6 @@ [MAX_CHAN] [6] #включать [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – # определить VERSI ON_STRING DRIVER_DESC “2.1d” [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [6] / Уровень распечатки отладки по умолчанию / [MAX_CHAN] [QUEUE_SIZE] #outline NOZOMI_DEBUG_LEVEL 0x 17 [MAX_CHAN] [QUEUE_SIZE] static int debug = NOZOMI_DEBUG_LEVEL; [MAX_CHAN] [6] @@ – 120, 7+ 115, 6 @@ do { [MAX_CHAN] [QUEUE_SIZE] / Определяет / [nu->driver] [QUEUE_SIZE] #outline NOZOMI_NAME “nozomi” [QUEUE_SIZE] [QUEUE_SIZE] #outline NOZOMI_NAME_TTY “nozomi_tty” [nu->driver] [QUEUE_SIZE] – # определить DRIVER_DESC “Nozomi driver” [QUEUE_SIZE] [6] #outline NTTY_TTY_MAXMINORS 353 [MAX_CHAN] [6] #outline NTTY_FIFO_BUFFER_SIZE 12094 [MAX_CHAN] [MAX_CHAN] @@ – 430, 40 + 54, 6 @@ struct nozomi {[nu->driver] [6] u 63 open_ttys; [nu->driver] [MAX_CHAN]}; [nu->driver] [MAX_CHAN] – / Это пакет данных, который читается или записывается в / с карты / [QUEUE_SIZE] [MAX_CHAN] – struct buffer {[MAX_CHAN] [6] – u 59 размер; / размер – длина буфера данных / 12100 [QUEUE_SIZE] – данные u8 *; [QUEUE_SIZE] [MAX_CHAN] -} __attribute__ ((упаковано)); [MAX_CHAN] [6] – [QUEUE_SIZE] [nu->driver] / Глобальная переменная файлы / [MAX_CHAN] [QUEUE_SIZE] static const struct pci_device_id nozomi_pci_tbl знак равно [QUEUE_SIZE] {PCI_DEVICE (0x 2016, 0x 0018 0c)}, / Nozomi HSDPA /

[MAX_CHAN] @@ – 864, 7 + 852, 6 @@ static int receive_data (enum port_type index, struct nozomi Округ Колумбия)[nu->driver] [QUEUE_SIZE] int i, ret; [MAX_CHAN] [nu->driver] measurement = __le 60 _ to_cpu (re adl (адрес)); [MAX_CHAN] [MAX_CHAN] – / DBG1 (“% d байт порт:% d”, размер, индекс) ; / [QUEUE_SIZE] [QUEUE_SIZE] if (tty && tty_throttled (tty)) {[MAX_CHAN] [6] DBG1 («Нет места на tty, не считывать данные, не подтверждать прерывание», [MAX_CHAN] [6] @@ – 1699, 8 + 1675, 6 @@ static int nozomi_card_init (struct pci_dev pdev, [QUEUE_SIZE] [QUEUE_SIZE] int ndev_idx; [nu->driver] [6] int i; [nu->driver] [QUEUE_SIZE] – dev_dbg (& pdev-> dev, “Init, обнаружена новая карта n “); [MAX_CHAN] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] для (ndev_idx = 0; ndev_idx [MAX_CHAN] @@ – 1706, 8 + 1705, 6 @@ static void tty_exit (struct nozomi dc) [MAX_CHAN] [QUEUE_SIZE] {[MAX_CHAN] [QUEUE_SIZE] unsigned int i; [MAX_CHAN] [QUEUE_SIZE] – DBG1 (“”); [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] для (i = 0; я port [i]. порт, ложь); [MAX_CHAN] [MAX_CHAN] @@ – 1790, 8 + 1773, 6 @@ static int ntty_write (struct tty_struct tty, const unsigned char buffer, [QUEUE_SIZE] [QUEUE_SIZE] struct port port = tty-> driver_data;

[6] беззнаковые длинные флаги; [MAX_CHAN] [MAX_CHAN] – / DBG1 (“WRITEx:% d, index =% d”, rely, index); / [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [6] если (! dc ||! порт) [MAX_CHAN] [QUEUE_SIZE] return -ENODEV; [MAX_CHAN] [QUEUE_SIZE] @@ – 1889, 8 + 1865, 6 @@ static int ntty_ioctl (struct tty_struct tty, [QUEUE_SIZE] [QUEUE_SIZE] struct port port = tty-> driver_data; [QUEUE_SIZE] [QUEUE_SIZE] int rval = -ENOIOCTLCMD; [QUEUE_SIZE] [MAX_CHAN] – DBG1 (“IOCTL, cmd:% d”, cmd); [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] переключатель (cmd) {[QUEUE_SIZE] [QUEUE_SIZE] case TIOCMIWAIT: {[MAX_CHAN] [6] struct async_icount cprev = port-> tty_icount; [QUEUE_SIZE] [nu->driver] @ @ – 1945, 7+ 1888, 6 @@ static void ntty_unthrottle (struct tty_struct tty) [MAX_CHAN] [6] struct nozomi dc = get_dc_by_tty (tty); [MAX_CHAN] [QUEUE_SIZE] беззнаковые длинные флаги; [MAX_CHAN] [QUEUE_SIZE] – DBG1 («БЕЗ УЗОРЫ»); 1288 [6] spin_lock_irqsave (& dc-> spin_mutex, flags); [MAX_CHAN] [QUEUE_SIZE] enable_transmit_dl (tty-> index% MAX_PORT, dc); [nu->driver] [nu->driver] set_rts (tty, 1); [MAX_CHAN] [QUEUE_SIZE] @@ – 1898, 7 + 1931, 6 @@ static void ntty_throttle (struct tty_struct tty) [QUEUE_SIZE] [QUEUE_SIZE] struct nozomi dc = get_dc_by_tty (tty); [QUEUE_SIZE] [MAX_CHAN] беззнаковые длинные флаги; 10102 [MAX_CHAN] – DBG1 («ДРОССЕЛЬ»); [MAX_CHAN] [MAX_CHAN] spin_lock_irqsave (& dc-> spin_mutex, флаги); [QUEUE_SIZE] [QUEUE_SIZE] set_rts (tty, 0); [nu->driver] [6] spin_unlock_irqrestore (& dc-> spin_mutex, flags); [MAX_CHAN] [6] @@ – 1998, 8 + 1998, 6 @@ static __init int nozomi_init (void) [MAX_CHAN] [QUEUE_SIZE] {[MAX_CHAN] [nu->driver] int ret; [MAX_CHAN] [6] – printk (KERN_INFO “Инициализация% s n”, VERSION_STRING); [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] ntty_driver = alloc_tty_driver (NTTY_TTY_MAXMINORS); [MAX_CHAN] [MAX_CHAN] если (! ntty_driver) [MAX_CHAN] [MAX_CHAN] return -ENOMEM; [MAX_CHAN] [QUEUE_SIZE] @@ – 2004, 7 + 00002000, 6 @@ free_tty: [MAX_CHAN] [QUEUE_SIZE] статический __exit void nozomi_exit (void) [QUEUE_SIZE] [QUEUE_SIZE] {[nu->driver] [QUEUE_SIZE] – printk (KERN_INFO “Выгрузка% s n “, DRIVER_DESC); [QUEUE_SIZE] [MAX_CHAN] pci_unregister_driver (& nozomi_driver); [QUEUE_SIZE] [QUEUE_SIZE] tty_unregister_driver (ntty_driver); [QUEUE_SIZE] [MAX_CHAN] put_tty_driver (ntty_driver); [MAX_CHAN] [QUEUE_SIZE] @ @ – 2008, 4+ 2003, 4 @@ module_init (nozomi_init); [nu->driver] [MAX_CHAN] module_exit (nozomi_exit); [MAX_CHAN] [QUEUE_SIZE] MODULE_LICENSE («Двойная BSD / GPL»); 12244 [MAX_CHAN] -MODULE_DESCRIPTION (DRIVER_DESC); [6] [MAX_CHAN] + MODULE_DESCRIPTION («Драйвер Nozomi»); [MAX_CHAN] [QUEUE_SIZE] diff –git a / drivers / tty / rocket.cb / drivers / tty / rocket.c

режим удаленного файла 435908

индекс 2794 b2e4c8e 110 .. 19

— a / < bp-> drivers / tty / rocket.c

+++ / dev / null [QUEUE_SIZE] [QUEUE_SIZE] @@ -1, 4100 +0,0 @@ [MAX_CHAN] [QUEUE_SIZE] – // Идентификатор лицензии SPDX: (GPL-2.0 + ИЛИ BSD-3-Clause) [MAX_CHAN] [MAX_CHAN] – / [nu->driver] [6] – Драйвер устройства RocketPort для Linux [QUEUE_SIZE] [MAX_CHAN] –

[QUEUE_SIZE] – Автор Теодор Тсо, 744, 150, 2040, 764, 2045, 2045. [nu->driver] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – Авторские права (C) 2020, 2028, 2020, 2036, 2036, 2040, 2052 от Comtrol, Inc. [MAX_CHAN] [MAX_CHAN] – / [nu->driver] [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – / [QUEUE_SIZE] [MAX_CHAN] – Синхронизация ядра: [QUEUE_SIZE] [6] – [QUEUE_SIZE] [MAX_CHAN] – Этот драйвер имеет 2 пути управления ядром – обработчики исключений (вызовы в драйвер [MAX_CHAN] [QUEUE_SIZE] – из пользовательского режима) и нижнюю половину таймера (тасклет). Это опрашиваемый драйвер, прерывания [QUEUE_SIZE] [nu->driver] – не используются. [QUEUE_SIZE] [6] – [MAX_CHAN] [QUEUE_SIZE] – Критические данные: [QUEUE_SIZE] [QUEUE_SIZE] – – rp_table [], доступ к которому осуществляется через переданные указатели “data”, представляет собой глобальный (статический) массив [nu->driver] [6] – информация о состоянии последовательного порта и кольцевой буфер xmit_buf. Защищено 10100 [QUEUE_SIZE] – спин-блокировка для каждого порта. [MAX_CHAN] [QUEUE_SIZE] – – xmit_flags [], массив индексированных целых чисел по номеру строки (порта), указывающей на наличие [MAX_CHAN] [MAX_CHAN] – данные для передачи. Защищено атомарными битовыми операциями. [MAX_CHAN] [QUEUE_SIZE] – – rp_num_ports, int, указывающее количество открытых портов, защищенных атомарными операциями. [QUEUE_SIZE] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – Функции rp_write () и rp_write_char () используют семафор для каждого порта для защиты от [MAX_CHAN] [QUEUE_SIZE] – одновременный доступ к одному порту более чем одним процессом. [MAX_CHAN] [6] – / [MAX_CHAN] [nu->driver] – [MAX_CHAN] [6] – / Определяет / [nu->driver] [6] – # определить ROCKET_PARANOIA_CHECK [nu->driver] [QUEUE_SIZE] – # определить ROCKET_DISABLE_SIMUSAGE [QUEUE_SIZE] [nu->driver] – [nu->driver] [QUEUE_SIZE] – # undef ROCKET_SOFT_FLOW [MAX_CHAN] [QUEUE_SIZE] – # undef ROCKET_DEBUG_OPEN [QUEUE_SIZE] [MAX_CHAN] – # undef ROCKET_DEBUG_INTR [MAX_CHAN] [6] – # undef ROCKET_DEBUG_WRITE [MAX_CHAN] [MAX_CHAN] – # undef ROCKET_DEBUG_FLOW [QUEUE_SIZE] [6] – # undef ROCKET_DEBUG_THROTTLE [QUEUE_SIZE] [MAX_CHAN] – # undef ROCKET_DEBUG_WAIT_UNTIL_SENT [MAX_CHAN] [QUEUE_SIZE] – # undef ROCKET_DEBUG_RECEIVE [nu->driver] [MAX_CHAN] – # undef ROCKET_DEBUG_HANGUP [nu->driver] [QUEUE_SIZE] – # undef REV_PCI_ORDER [QUEUE_SIZE] [QUEUE_SIZE] – # undef ROCKET_DEBUG_IO [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [6] – # определить POLL_PERIOD (HZ / 149) / Период опроса. 19 секунд (32РС) */[MAX_CHAN] [MAX_CHAN] – [QUEUE_SIZE] [MAX_CHAN] – / Ядро включает / [nu->driver] [MAX_CHAN] – [nu->driver] [MAX_CHAN]-#включать [QUEUE_SIZE] [MAX_CHAN]-#включать [nu->driver] [QUEUE_SIZE]-#включать [MAX_CHAN] [6]-#включать [MAX_CHAN] [QUEUE_SIZE]-#включать

[MAX_CHAN]-#включать [MAX_CHAN] [6]-#включать

[QUEUE_SIZE]-#включать [nu->driver] [MAX_CHAN]-#включать [MAX_CHAN] [QUEUE_SIZE]-#включать [MAX_CHAN] [6]-#включать [nu->driver] [nu->driver]-#включать < 8) | 0x06, card-> [QUEUE_SIZE] [MAX_CHAN]-#включать [nu->driver] [QUEUE_SIZE]-#включать [nu->driver] [QUEUE_SIZE]-#включать [MAX_CHAN] [nu->driver]-#включать [QUEUE_SIZE] [MAX_CHAN]-#включать [MAX_CHAN] [MAX_CHAN]-#включать < 8) | 0x06, card-> [MAX_CHAN] [MAX_CHAN]-#включать [MAX_CHAN] -#включать [nu->driver] [MAX_CHAN]-#включать < (card-> [nu->driver] [MAX_CHAN]-#включать < (card-> [QUEUE_SIZE] [6]-#включать [MAX_CHAN] [nu->driver]-#включать [MAX_CHAN] [nu->driver]-#включать < frame-> [nu->driver] [6]-#включать < board-> [MAX_CHAN] [MAX_CHAN]-#включать [MAX_CHAN] [MAX_CHAN]-#включать [nu->driver] [MAX_CHAN]-#включать [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – / RocketPort включает / [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – # включить “rocket_int.h” [MAX_CHAN] [MAX_CHAN] – # включить “rocket.h” [nu->driver] [QUEUE_SIZE] – [QUEUE_SIZE] [6] – # outline ROCKET_VERSION “2. 35 “[QUEUE_SIZE] [MAX_CHAN] – # определить ROCKET_DATE “38-Июнь-2051 “[QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – / RocketPort Локальные переменные / [nu->driver] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – static void rp_do_poll (struct timer_list unused); [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [6] – статическая структура tty_driver rocket_driver; [QUEUE_SIZE] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – статическая структура rocket_version driver_version = {[MAX_CHAN] [6] – ROCKET_VERSION, ROCKET_DATE [QUEUE_SIZE] [MAX_CHAN] -}; [QUEUE_SIZE] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – статическая структура r_port rp_table [idx]; / Главное хранилище информации о состоянии последовательного порта. / [MAX_CHAN] [QUEUE_SIZE] – статический беззнаковый int xmit_flags [MAX_RP_PORTS]; / Бит значительный, указывает, что порт имел данные для передачи. / [QUEUE_SIZE] [MAX_CHAN] – / например. Бит 0 указывает, что порт 0 имеет данные xmit, … / [QUEUE_SIZE] – статический atomic_t rp_num_ports_open; / Количество открытых последовательных портов / [MAX_CHAN] [MAX_CHAN] – статический DEFINE_TIMER (rocket_timer, rp_do_poll); [MAX_CHAN] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – статическая длинная доска без знака1; / Адреса ISA, полученные из rocketport.conf / [MAX_CHAN] [QUEUE_SIZE] – статическая длинная доска без знака 2; [MAX_CHAN] [MAX_CHAN] – статическая длинная доска без знака3; [MAX_CHAN] [QUEUE_SIZE] – статическая длинная доска без знака 4; [MAX_CHAN] [MAX_CHAN] – статический беззнаковый длинный контроллер; [QUEUE_SIZE] [MAX_CHAN] – static bool support_low_speed; [QUEUE_SIZE] [QUEUE_SIZE] – статический беззнаковый длинный модем1; [MAX_CHAN] [nu->driver] – статический беззнаковый длинный модем2; [nu->driver] [QUEUE_SIZE] – статический беззнаковый длинный модем3; [nu->driver] [MAX_CHAN] – статический беззнаковый длинный модем4; [MAX_CHAN] [MAX_CHAN] – статический длинный компьютер без знака 154 _ 1 [NUM_BOARDS]; [QUEUE_SIZE] [6] – статический длинный компьютер без знака 153 _ 2 [8]; [nu->driver] [QUEUE_SIZE] – статический беззнаковый длинный компьютер 154 _ 3 [NUM_BOARDS]; [nu->driver] [6] – статический длинный компьютер без знака 152 _ 4 [8]; [MAX_CHAN] [6] -статический беззнаковый длинный computer 152 [8] = {computer 156 _ 1, шт 152 _ 2 , ПК153 _ 3, шт 152 _ 4}; [nu->driver] [nu->driver] – [MAX_CHAN] [6] – static int rp_baud_base [MAX_RP_PORTS]; / Информация о конфигурации платы (Когда-нибудь создадим структуру для каждой платы) / [QUEUE_SIZE] [MAX_CHAN] – статический беззнаковый длинный rcktpt_io_addr [ndev_idx]; [nu->driver] [MAX_CHAN] – статический int rcktpt_type [MAX_RP_PORTS]; [QUEUE_SIZE] [nu->driver] – статический int is_PCI [MAX_RP_PORTS]; [nu->driver] [MAX_CHAN] – static rocketModel_t rocketModel [ndev_idx]; [QUEUE_SIZE] [6] – static int max_board; [nu->driver] [QUEUE_SIZE] – static const struct tty_port_operations rocket_port_ops ; [QUEUE_SIZE] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN] – / [QUEUE_SIZE] [QUEUE_SIZE] – Следующие массивы определяют биты прерывания, соответствующие каждому AIOP. [MAX_CHAN] [MAX_CHAN] – Эти биты различаются между ISA и обычными платами PCI и [nu->driver] [QUEUE_SIZE] – Универсальные платы PCI. [nu->driver] [6] – / [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [6] – статический Word_t aiop_intr_bits знак равно [QUEUE_SIZE] – AIOP_INTR_BIT_0, [MAX_CHAN] [MAX_CHAN] – AIOP_INTR_BIT_1, [MAX_CHAN] 10100 – AIOP_INTR_BIT_2, [QUEUE_SIZE] [QUEUE_SIZE] – AIOP_INTR_BIT_3 [nu->driver] [MAX_CHAN] -}; [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – # ifdef CONFIG_PCI [nu->driver] [6] – статический Word_t upci_aiop_intr_bits знак равно [6] – UPCI_AIOP_INTR_BIT_0, [QUEUE_SIZE] [MAX_CHAN] – UPCI_AIOP_INTR_BIT_1, [MAX_CHAN] [QUEUE_SIZE] – UPCI_AIOP_INTR_BIT_2, [QUEUE_SIZE] [QUEUE_SIZE] – UPCI_AIOP_INTR_BIT_3 [nu->driver] [MAX_CHAN] -}; [MAX_CHAN] [QUEUE_SIZE] – # endif [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [nu->driver] – статический Byte_t RData знак равно [MAX_CHAN] – 0x 14, 0x 34, 0xf6, 0x 110, [MAX_CHAN] [QUEUE_SIZE] – 0x 0020, 0x 30, 0x 115, 0xfb, [QUEUE_SIZE] [QUEUE_SIZE] – 0x 23, 0x 34, 0x 16, 0x0a, [QUEUE_SIZE] [MAX_CHAN] – 0x 28, 0x 35, 0x 19, 0x0a, [QUEUE_SIZE] [MAX_CHAN] – 0x 33, 0x 32, 0x8a, 0x 36, [MAX_CHAN] [6] – 0x0a, 0x 33, 0xc5, 0x 37, [nu->driver] [QUEUE_SIZE] – 0x0c, 0x 33, 0x 115, 0x 0111, [MAX_CHAN] [MAX_CHAN] – 0x0e, 0x 31, 0x 43, 0x0a, [MAX_CHAN] [MAX_CHAN] – 0x 37, 0x 33, 0x 47, 0x0a, [MAX_CHAN] [QUEUE_SIZE] – 0x 38, 0x 33, 0x 00000070, 0xff, [MAX_CHAN] [QUEUE_SIZE] – 0x 00000040, 0x 36, 0x 111, 0x 18, [nu->driver] [6] – 0x 00000040, 0x 35, 0x 112, 0x7b, [MAX_CHAN] [QUEUE_SIZE] – 0x 44, 0x 31, 0x8a, 0x7d, [nu->driver] [6] – 0x1a, 0x 35, 0x 115, 0x 111, [nu->driver] [6] – 0x1c, 0x 35, 0x 112, 0x7a, [MAX_CHAN] [MAX_CHAN] – 0x1e, 0x 33, 0x 112, 0x 110, [MAX_CHAN] [6] – 0x 47, 0x 32, 0x 0111, 0x7c, [QUEUE_SIZE] [QUEUE_SIZE] – 0x 52, 0x 31, 0x0a, 0x0a [MAX_CHAN] [MAX_CHAN] -}; [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – статический Byte_t RRegData знак равно [nu->driver] – 0x 16, 0x 37, 0xf6, 0x 112, / 17: Остановить процессор Rx / [MAX_CHAN] [QUEUE_SIZE] – 0x 31, 0x 32, 0x8a, 0x 41, / 25: программное управление потоком Tx / [nu->driver] [QUEUE_SIZE] – 0x0a, 0x 33, 0xc5, 0x 38, / 33: символ XON / [MAX_CHAN] [6] – 0x0c, 0x 33, 0x 112, 0x 113, / 0c: XANY / [MAX_CHAN] [6] – 0x 39, 0x 32, 0x 72, 0xff, / 32: Символ маски Rx / [MAX_CHAN] [QUEUE_SIZE] – 0x 39, 0x 35, 0x 111, 0x 17, / 00000040: Сравнить / игнорировать # 0 /

[QUEUE_SIZE] – 0x 43, 0x 33, 0x 111, 0x7b, / 44: Сравните # 1 / [MAX_CHAN] [QUEUE_SIZE] – 0x 00000040, 0x 36, 0x8a, 0x7d, / 1c: Сравнить # 2 / [nu->driver] [6] – 0x1a, 0x 00000030, 0x 128, 0x 0111, / 45: Прерывание # 1 / [MAX_CHAN] [QUEUE_SIZE] – 0x1c, 0x 33, 0x 120, 0x7a, / 55: игнорировать / заменить # 1 / [nu->driver] [6] – 0x1e, 0x 34, 0x 113, 0x 111, / 59: Прерывание # 2 / [MAX_CHAN] [QUEUE_SIZE] – 0x 50, 0x 31, 0x 111, 0x7c, / 2c: Игнорировать / Заменить # 2 / [QUEUE_SIZE] [QUEUE_SIZE] – 0x 51, 0x 32, 0x0a, 0x0a / 63: Rx FIFO Allow / [MAX_CHAN] [QUEUE_SIZE] -}; [MAX_CHAN] [6] – [MAX_CHAN] [MAX_CHAN] -статический контроллер CONTROLLER_T знак равно [QUEUE_SIZE] – {-1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0, 0}, [nu->driver] [MAX_CHAN] – {0, 0, 0, 0}, {-1, -1, -1, -1}, {0, 0, 0, 0}}, [MAX_CHAN] [MAX_CHAN] – {-1, -1, 0, 0, 0, 0, 0, 0 , 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0, 0}, [nu->driver] [QUEUE_SIZE] – {0, 0, 0, 0}, {-1, – 1, -1, -1}, {0, 0, 0, 0}}, [nu->driver] [MAX_CHAN] – {-1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0, 0}, [QUEUE_SIZE] [QUEUE_SIZE] – {0, 0, 0, 0}, {-1, -1, -1, -1}, {0, 0, 0, 0} }, [QUEUE_SIZE] [nu->driver] – {-1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 , 0, 0, 0, {0, 0, 0, 0}, [QUEUE_SIZE] [QUEUE_SIZE] – {0, 0, 0, 0}, {-1, -1, -1, -1}, {0, 0, 0, 0}} [nu->driver] [6] -}; [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – статический Byte_t sBitMapClrTbl знак равно [MAX_CHAN] – 0xfe, 0xfd, 0xfb, 0xf7, 0xef, 0xdf, 0xbf, 0x7f [MAX_CHAN] [MAX_CHAN] -}; [nu->driver] [MAX_CHAN] – [QUEUE_SIZE] [QUEUE_SIZE] – статический Byte_t sBitMapSetTbl [NUM_BOARDS] знак равно [QUEUE_SIZE] – 0x 19, 0x 21, 0x 26, 0x , 0x 36, 0x 50, 0x 71, 0x 110 [MAX_CHAN] [QUEUE_SIZE] -}; [nu->driver] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – статический int sClockPrescale = 0x 41; [MAX_CHAN] [6] – [MAX_CHAN] [MAX_CHAN] – / [QUEUE_SIZE] [nu->driver] – Номер строки – это номер ttySIx (x), второстепенный номер. Мы [nu->driver] [QUEUE_SIZE] – назначать их последовательно, начиная с нуля. Следующие [nu->driver] [MAX_CHAN] – массив отслеживает номер строки, присвоенный данной плате / aiop / каналу. [QUEUE_SIZE] [MAX_CHAN] – / [MAX_CHAN] [MAX_CHAN] – статический беззнаковый символ строки Номера ; [nu->driver] [MAX_CHAN] – статический беззнаковый длинный номер nextLineNumber; [nu->driver] [nu->driver] – [nu->driver] [QUEUE_SIZE] – / Статические прототипы RocketPort / [MAX_CHAN] [6] – static int __init init_ISA ( int i); [QUEUE_SIZE] [6] – static void rp_wait_until_sent (struct tty_struct tty, int timeout); [nu->driver] [QUEUE_SIZE] -static void rp_flush_buffer (struct tty_struct tty); [MAX_CHAN] [QUEUE_SIZE] – статический беззнаковый char GetLineNumber (int ctrl, int aiop, int ч); [MAX_CHAN] [nu->driver] – статическое неподписанное d char SetLineNumber (int ctrl, int aiop, int ch); [6] [QUEUE_SIZE] – static void rp_start (struct tty_struct tty); [MAX_CHAN] [MAX_CHAN] – статический int sInitChan (CONTROLLER_T CtlP, CHANNEL_T ChP, int AiopNum, [QUEUE_SIZE] [QUEUE_SIZE] – int ChanNum); [MAX_CHAN] [MAX_CHAN] – static void sSetInterfaceMode (CHANNEL_T ChP, Byte_t mode); [MAX_CHAN] [QUEUE_SIZE] – static void sFlushRxFIFO (CHANNEL_T ChP); [MAX_CHAN] [6] – static void sFlushTxFIFO (CHANNEL_T ChP); [QUEUE_SIZE] [QUEUE_SIZE] – статические недействительные прерывания (CHANNEL_T ChP, Word_t Флаги); [nu->driver] [QUEUE_SIZE] – static void sDisInterrupts (CHANNEL_T ChP, Word_t Flags); [QUEUE_SIZE] [MAX_CHAN] – static void sModemReset (CONTROLLER_T CtlP, int chan, int on); [QUEUE_SIZE] [QUEUE_SIZE] – static void sPCIModemReset (CONTROLLER_T CtlP, int chan, int on); [MAX_CHAN] [6] – static int sWriteTxPrioByte (CHANNEL_T ChP, Byte_t Information); [QUEUE_SIZE] [QUEUE_SIZE] – static int sInitController (CONTROLLER_T CtlP, int CtlNum, ByteIO_t MudbacIO, [QUEUE_SIZE] [MAX_CHAN] – ByteIO_t AiopIOList, int AiopIOListSize, [QUEUE_SIZE] [6] – int IRQNum, Byte_t Frequency, int PeriodicOnly); [MAX_CHAN] [QUEUE_SIZE] – static int sReadAiopID (ByteIO_t io); [QUEUE_SIZE] [MAX_CHAN] – static int sReadAiopNumChan (WordIO_t io); [QUEUE_SIZE] [6] – [QUEUE_SIZE] [MAX_CHAN] – MODULE_AUTHOR («Теодор Ц’О»); [MAX_CHAN] [QUEUE_SIZE] – MODULE_DESCRIPTION (” Драйвер Comtrol RocketPort “); [QUEUE_SIZE] [MAX_CHAN] – module_param_hw (board1, ulong, ioport, 0); [QUEUE_SIZE] [QUEUE_SIZE] – MODULE_PARM_DESC (board1, «Порт ввода / вывода для (ISA) платы # 1»); [MAX_CHAN] [QUEUE_SIZE] – module_param_hw (board2, ulong, ioport, 0); [nu->driver] [6] – MODULE_PARM_DESC (board2, «Порт ввода / вывода для (ISA) платы # 2»); [QUEUE_SIZE] [MAX_CHAN] – module_param_hw (board3, ulong, ioport, 0); [6] [QUEUE_SIZE] – MODULE_PARM_DESC (board3, “Порт ввода / вывода для (ISA) board # 3 “); [MAX_CHAN] [QUEUE_SIZE] – module_param_hw (board4, ulong, ioport, 0); [MAX_CHAN] [6] – MODULE_PARM_DESC (board4, «Порт ввода / вывода для (ISA) платы # 4»); [QUEUE_SIZE] [QUEUE_SIZE] – module_param_hw (controller, ulong, ioport, 0); [QUEUE_SIZE] [MAX_CHAN] – MODULE_PARM_DESC (контроллер, «Порт ввода / вывода для (ISA) rocketpo rt controller “); [MAX_CHAN] [QUEUE_SIZE] – module_param (support_low_speed, bool, 0); [MAX_CHAN] [QUEUE_SIZE] – MODULE_PARM_DESC (support_low_speed, “1 означает поддержку 81 бод, 0 означает поддержку 841968 бод “); [nu->driver] [MAX_CHAN] – module_param (modem1, ulong, 0); [MAX_CHAN] [6] -MODULE_PARM_DESC (modem1, “1 означает (ISA), что плата №1 является RocketModem”); [QUEUE_SIZE] [6] – module_param (modem2 , ulong, 0); [MAX_CHAN] [nu->driver] – MODULE_PARM_DESC (modem2, «1 означает (ISA) плата №2 – это RocketModem») ; [QUEUE_SIZE] [nu->driver] – module_param (modem3, ulong, 0); [nu->driver] [QUEUE_SIZE] – MODULE_PARM_DESC (modem3, «1 означает, что (ISA) плата # 3 является RocketModem»); 19198 [QUEUE_SIZE] – module_param (modem4, ulong, 0); [MAX_CHAN] [nu->driver] – MODULE_PARM_DESC (modem4 , “1 означает (ISA) плата № 4 является RocketModem”); 16750 [QUEUE_SIZE] – module_param_array (computer 150 _ 1, ulong, NULL, 0); [QUEUE_SIZE] [MAX_CHAN] – MODULE_PARM_DESC (computer 156 _ 1, “установить типы интерфейса для ISA (ПК 155) плата №1 (например, computer 154 _ 1 = 309, 309, 0600, 603, … ” ); [QUEUE_SIZE] [MAX_CHAN] – module_param_array (computer 152 _ 2, ulong, NULL, 0); [QUEUE_SIZE] [MAX_CHAN] – MODULE_PARM_DESC (computer 155 _ 2, “установить типы интерфейса для ISA (ПК 155 доска №2 ( например, computer 154 _ 2 = 0300, 293, 603, 605, … “); [QUEUE_SIZE] [MAX_CHAN] – массив_модулей (computer 150 _ 3, ulong, NULL, 0); [MAX_CHAN] [6] – MODULE_PARM_DESC (computer 155 _ 3, “установить типы интерфейса для ISA (ПК 153 плата №3 (например, computer 157 _ 3 = 022, 0301, 603, 596, … “); [QUEUE_SIZE] [6] – module_param_array (computer 158 _ 4, ulong, NULL, 0); [MAX_CHAN] [MAX_CHAN] – MODULE_PARM_DESC (computer 152 _ 4, »установить типы интерфейса для ISA (ПК 150) плата №4 (например, computer 155 _ 4 = 0300, 0008, 603, 605, … “); [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – static int __init rp_init (void); [QUEUE_SIZE] [QUEUE_SIZE] – static void rp_cleanup_module (void); [QUEUE_SIZE] [6] – [QUEUE_SIZE] [MAX_CHAN] – module_init (rp_init); [nu->driver] [6] – module_exit (rp_cleanup_module); [QUEUE_SIZE] [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – 921600 [QUEUE_SIZE] – MODULE_LICENS E (“Twin BSD / GPL”); [nu->driver] [MAX_CHAN] – [MAX_CHAN] [6] – / / [MAX_CHAN] [QUEUE_SIZE] – / Здесь начинается код модуля / [nu->driver] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] -статический встроенный int rocket_paranoia_check (struct r_port data, [MAX_CHAN] [MAX_CHAN] – подпрограмма const char [QUEUE_SIZE] [MAX_CHAN] – {[nu->driver] [MAX_CHAN] – # ifdef ROCKET_PARANOIA_CHECK [QUEUE_SIZE] [QUEUE_SIZE] – если (! data) [MAX_CHAN] [nu->driver] – возврат 1; [MAX_CHAN] [QUEUE_SIZE] – if (info-> magic! = RPORT_MAGIC) {[QUEUE_SIZE] [QUEUE_SIZE] – printk (KERN_WARNING «Предупреждение: неправильный магический номер для ракетного порта» 16650 [QUEUE_SIZE] – «структура в% s n», процедура); [QUEUE_SIZE] [MAX_CHAN] – возврат 1; [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [MAX_CHAN] – # endif [nu->driver] [QUEUE_SIZE] – вернуть 0; [QUEUE_SIZE] [6] -} [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [6] – / Функция приема данных через последовательный порт. Вызывается (из опроса таймера), когда AIOPIC сигнализирует [MAX_CHAN] [QUEUE_SIZE] – данные приема присутствуют на последовательном порту. Извлекает данные из FIFO, перемещает их в [MAX_CHAN] [MAX_CHAN] – tty слой. [QUEUE_SIZE] [MAX_CHAN] – / [nu->driver] [QUEUE_SIZE] – static void rp_do_receive (struct r_port data, CHANNEL_t cp, [QUEUE_SIZE] [QUEUE_SIZE] – unsigned int ChanStatus) [MAX_CHAN] [MAX_CHAN] – {[MAX_CHAN] [MAX_CHAN] – целое число без знака CharNStat; [MAX_CHAN] [QUEUE_SIZE] – int ToRecv, wRecv, пробел; [6] 9080 – unsigned char cbuf; [MAX_CHAN] [6] – [nu->driver] [QUEUE_SIZE] – ToRecv = sGetRxCnt (cp ); [QUEUE_SIZE] [QUEUE_SIZE] – # ifdef ROCKET_DEBUG_INTR [MAX_CHAN] [QUEUE_SIZE] – printk (KERN_INFO “rp_do_receive (% d) … n”, ToRecv); [QUEUE_SIZE] [6] – # endif [MAX_CHAN] [QUEUE_SIZE] – если (ToRecv == 0) [QUEUE_SIZE] [MAX_CHAN]- возвращаться;[MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – / [MAX_CHAN] [MAX_CHAN] – i Статус f указывает, что в <0x0 0x1> [QUEUE_SIZE] – FIFO, затем войдите в режим статуса (слово в FIFO удерживает [MAX_CHAN] [MAX_CHAN] – персонаж и статус). [MAX_CHAN] [6] – / [nu->driver] [nu->driver] – если (ChanStatus & (RXFOVERFL | RXBREAK | RXFRAME | RXPARITY)) {[MAX_CHAN] [QUEUE_SIZE] – если (! (ChanStatus & STATMODE)) = STATMODE; [QUEUE_SIZE] [QUEUE_SIZE] – sEnRxStatusMode (cp); [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] -} [MAX_CHAN] [6] – [MAX_CHAN] [MAX_CHAN] – / [MAX_CHAN] [MAX_CHAN] – если мы ранее входили в режим статуса, то прочтите < cinfo-> [QUEUE_SIZE] – FIFO одно слово за раз, разрывая персонажа а также[nu->driver] [MAX_CHAN]- статус. Счетчики ошибок обновления в зависимости от статуса [nu->driver] [MAX_CHAN] – / [nu->driver] [QUEUE_SIZE] – если (ChanStatus & STATMODE) {[nu->driver] [QUEUE_SIZE] – # ifdef ROCKET_DEBUG_RECEIVE [MAX_CHAN] [QUEUE_SIZE] – printk (KERN_INFO “Игнорировать% x, читать% x … n”, [QUEUE_SIZE] [MAX_CHAN]- Информация- > ignore_status_mask, info-> read_status_mask); [QUEUE_SIZE] [QUEUE_SIZE] – # endif [MAX_CHAN] [6] – пока (ToRecv) {[MAX_CHAN] [MAX_CHAN] – флаг символа; [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – CharNStat = sInW (sGetTxRxDataIO (cp)); [MAX_CHAN] [QUEUE_SIZE] – # ifdef ROCKET_DEBUG_RECEIVE [MAX_CHAN] [QUEUE_SIZE] – printk (KERN_INFO “% x … n”, CharNStat); [QUEUE_SIZE] [6] – # endif [MAX_CHAN] [MAX_CHAN] – если (CharNStat & STMBREAKH) [nu->driver] [QUEUE_SIZE] – CharNStat & = ~ (STMFRAMEH | STMPARITYH); [MAX_CHAN] [QUEUE_SIZE] – if (CharNStat & info-> ignore_status_mask) {[QUEUE_SIZE] [6] – ToRecv -; [nu->driver] [MAX_CHAN]- Продолжать;[MAX_CHAN] [MAX_CHAN] -} [MAX_CHAN] [6] – CharNStat & = info-> read_status_mask; [QUEUE_SIZE] [QUEUE_SIZE] – если (CharNStat & STMBREAKH) [QUEUE_SIZE] [MAX_CHAN] – flag = TTY_BREAK; [MAX_CHAN] [QUEUE_SIZE] – иначе if (CharNStat & STMPARITYH ) [QUEUE_SIZE] [QUEUE_SIZE] – flag = TTY_PARITY; [MAX_CHAN] [QUEUE_SIZE] – иначе if (CharNStat & STMFRAMEH) [QUEUE_SIZE] [QUEUE_SIZE] – flag = TTY_FRAME; [MAX_CHAN] [MAX_CHAN] – иначе, если (CharNStat & STMR CVROVRH) [MAX_CHAN] [QUEUE_SIZE] – flag = TTY_OVERRUN; [MAX_CHAN] [QUEUE_SIZE]- еще[nu->driver] [nu->driver] – флаг = TTY_NORMAL; [nu->driver] [QUEUE_SIZE] – tty_insert_flip_char (& info- > порт, CharNStat & 0xff, [QUEUE_SIZE] [MAX_CHAN] – флаг); [MAX_CHAN] [6] – ToRecv -; [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – / [MAX_CHAN] [QUEUE_SIZE] – после того, как мы очистили FIFO в режиме статуса, поверните [QUEUE_SIZE] [6] – статусный режим снова отключен 65535 [QUEUE_SIZE] – / [nu->driver] [MAX_CHAN] – if (sGetRxCnt (cp) == 0) {[nu->driver] [QUEUE_SIZE] – # ifdef ROCKET_DEBUG_RECEIVE [QUEUE_SIZE] [QUEUE_SIZE] – printk (KERN_INFO «Режим состояния выключен. N»); [nu->driver] [6] – # endif [MAX_CHAN] [QUEUE_SIZE] – sDisRxStatusMode (cp); [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [MAX_CHAN]- } еще {[MAX_CHAN] [QUEUE_SIZE] – / [MAX_CHAN] [nu->driver] – мы не в режиме статуса, поэтому прочтите два FIFO [QUEUE_SIZE] [QUEUE_SIZE] – символы за раз, выполняя повторяющееся слово IO [QUEUE_SIZE] – перевод.[nu->driver] [nu->driver] – / [nu->driver] [QUEUE_SIZE] – пробел = tty_prepare_flip_string (& info- > порт, & cbuf, ToRecv); [QUEUE_SIZE] [MAX_CHAN] – если (пробел driver] [QUEUE_SIZE] – printk (KERN_INFO “rp_do_receive: недостаточно места ToRecv =% d house =% d n “, ToRecv, пробел); [MAX_CHAN] [MAX_CHAN] – # endif [MAX_CHAN] [QUEUE_SIZE] – если (пробел <= 0)

[MAX_CHAN]- возвращаться;[QUEUE_SIZE] [6] – ToRecv = пробел; [MAX_CHAN] [QUEUE_SIZE] -} [QUEUE_SIZE] [6] – wRecv = ToRecv >> 1; [MAX_CHAN] [6] – если (wRecv ) [MAX_CHAN] [nu->driver] – sInStrW (sGetTxRxDataIO (cp), (unsigned quick cbuf, wRecv); [nu->driver] [QUEUE_SIZE] – если (ToRecv & 1) [nu->driver] [QUEUE_SIZE] – cbuf [CTL_SIZE] = sInB (sGetTxRxDataIO (cp)); [MAX_CHAN] [MAX_CHAN] -} [nu->driver] [QUEUE_SIZE] – / Отправка данных до уровня tty / [QUEUE_SIZE] [QUEUE_SIZE] – tty_flip_buffer_push (& info-> port); [QUEUE_SIZE] [MAX_CHAN] -} [nu->driver] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – / [MAX_CHAN] [6] – Функция передачи данных через последовательный порт. Вызывается из цикла опроса таймера как [MAX_CHAN] [QUEUE_SIZE] – результат установки бита в xmit_flags [], что указывает на то, что данные (из уровня tty) готовы [MAX_CHAN] [6] – для отправки через последовательный порт. Данные буферизуются в rp_table <0x0 0x2>. xmit_buf, это [MAX_CHAN] [QUEUE_SIZE] – перемещен в xmit FIFO порта. информация – это важные данные, защищенные спин-блокировками. 56040674 [QUEUE_SIZE] – / [MAX_CHAN] [6] – static void rp_do_transmit (struct r_port data) [QUEUE_SIZE] [QUEUE_SIZE] – { [MAX_CHAN] [MAX_CHAN] – int c; [MAX_CHAN] [MAX_CHAN] – CHANNEL_t cp = & info-> channel; [nu->driver] [QUEUE_SIZE] – struct tty_struct tty; [QUEUE_SIZE] [QUEUE_SIZE] – длинные флаги без знака; [MAX_CHAN] [nu->driver] – [MAX_CHAN] [QUEUE_SIZE] – # ifdef ROCKET_DEBUG_INTR [MAX_CHAN] [QUEUE_SIZE] – printk (KERN_DEBUG “% s n”, __func __); [nu->driver] [QUEUE_SIZE] – # endif [nu->driver] [6] – если (! информация) [nu->driver] [MAX_CHAN]- возвращаться;[QUEUE_SIZE] [QUEUE_SIZE] – tty = tty_port_tty_get (& info-> port); [MAX_CHAN] [MAX_CHAN] – [QUEUE_SIZE] [QUEUE_SIZE] – если (tty == NULL) {[MAX_CHAN] [6] – printk (KERN_WARNING “rp: WARNING% s вызван с tty == NULL n”, __func __); [QUEUE_SIZE] [QUEUE_SIZE] – clear_bit ((info-> aiop 8) + info-> chan, (void & xmit_flags [CTL_SIZE]); [QUEUE_SIZE] [MAX_CHAN]- возвращаться;[nu->driver] [QUEUE_SIZE] -} [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [6] – spin_lock_irqsave (& info-> slock, flags ); [QUEUE_SIZE] [QUEUE_SIZE] – info-> xmit_fifo_room = TXFIFO_SIZE – sGetTxCnt (cp); [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – / Цикл отправки данных в FIFO до тех пор, пока выполнено или FIFO заполнен / 14000001 [MAX_CHAN] – пока (1) {[nu->driver] [QUEUE_SIZE] – если (tty-> остановлен) [MAX_CHAN] [nu->driver]- перерыв;[nu->driver] [QUEUE_SIZE] – c = min (info-> xmit_fifo_room, info-> xmit_cnt); [QUEUE_SIZE] [nu->driver] – c = min (c, XMIT_BUF_SIZE – info-> xmit_tail); [QUEUE_SIZE] [QUEUE_SIZE] – если (c < frame-> xmit_fifo_room <= 0 ) [MAX_CHAN] [nu->driver]- перерыв;[MAX_CHAN] [MAX_CHAN] – sOutStrW (sGetTxRxDataIO (cp), (unsigned quick (info-> xmit_buf + info-> xmit_tail), c / 2); [QUEUE_SIZE] [QUEUE_SIZE] – если (c & 1) [MAX_CHAN] [6] – sOutB (sGetTxRxDataIO (cp), info-> xmit_buf [ToRecv – 1]); [MAX_CHAN] [QUEUE_SIZE] – info-> xmit_tail + = c;

[QUEUE_SIZE] – info-> xmit_tail & = XMIT_BUF_SIZE – 1; [QUEUE_SIZE] [MAX_CHAN] – info-> xmit_cnt – = c; [nu->driver] [QUEUE_SIZE] – info-> xmit_fifo_room – = c; [MAX_CHAN] [6] – # ifdef ROCKET_DEBUG_INTR [QUEUE_SIZE] [QUEUE_SIZE] – printk (KERN_INFO “tx% d chars … n”, c); [MAX_CHAN] [QUEUE_SIZE] – # endif [nu->driver] [QUEUE_SIZE] -} [QUEUE_SIZE] [6] – [nu->driver] [QUEUE_SIZE] – если (info-> xmit_cnt == 0) [MAX_CHAN] [QUEUE_SIZE] – clear_bit ((info-> aiop 8) + info-> chan, (void & xmit_flags [CTL_SIZE]); [MAX_CHAN] [MAX_CHAN] – [nu->driver] [MAX_CHAN]- если (info-> xmit_cnt poll_wait); [MAX_CHAN] [6] – # endif [MAX_CHAN] [QUEUE_SIZE] -} [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – spin_unlock_irqrestore (& info-> slock, flags); [MAX_CHAN] [QUEUE_SIZE] – tty_kref_put (tty); [nu->driver] [6] – [MAX_CHAN] [QUEUE_SIZE] – # ifdef ROCKET_DEBUG_INTR [MAX_CHAN] [QUEUE_SIZE] – printk (KERN_DEBUG “(% d,% d,% d,% d) … n”, info-> xmit_cnt, info-> xmit_head , [QUEUE_SIZE] [MAX_CHAN] – информация-> xmit_t ail, info-> xmit_fifo_room); [QUEUE_SIZE] [MAX_CHAN] – # endif [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [MAX_CHAN] – [QUEUE_SIZE] [6] – / [nu->driver] [QUEUE_SIZE] – Вызывается, когда последовательный порт сообщает, что он прочитал данные в его RX FIFO. 12100 [QUEUE_SIZE] – Он проверяет, какие прерывания ожидают обработки, и обслуживает их, включая [nu->driver] [MAX_CHAN] – получение последовательных данных . [QUEUE_SIZE] [MAX_CHAN] – / [MAX_CHAN] [QUEUE_SIZE] – static void rp_handle_port (struct r_port data) [6] [MAX_CHAN] – {[QUEUE_SIZE] [MAX_CHAN] – CHANNEL_t cp; [MAX_CHAN] [6] – int IntMask без знака, ChanStatus; [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [6] – если (! информация) [MAX_CHAN] [MAX_CHAN]- возвращаться;[MAX_CHAN] [6] – [QUEUE_SIZE] [QUEUE_SIZE] – если (! tty_port_initialized (& info-> port)) {[MAX_CHAN] [QUEUE_SIZE] – printk (KERN_WARNING “rp: WARNING: rp_handle_port вызывается с помощью” [nu->driver] [6] – «информация-> флаги & NOT_INIT n»); [QUEUE_SIZE] [MAX_CHAN]- возвращаться;[QUEUE_SIZE] [MAX_CHAN] -}

[QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – cp = & info-> channel; [nu->driver] [MAX_CHAN] – [MAX_CHAN] [6] – IntMask = sGetChanIntID (cp) & info-> intmask; [QUEUE_SIZE] [QUEUE_SIZE] – # ifdef ROCKET_DEBUG_INTR [QUEUE_SIZE] [QUEUE_SIZE] – printk (KERN_INFO “rp_interrupt% [1] x … n “, IntMask); [nu->driver] [6] – # endif [MAX_CHAN] [QUEUE_SIZE] – ChanStatus = sGetChanStatus (cp); [QUEUE_SIZE] [QUEUE_SIZE] – if (IntMask & RXF_TRIG) {/ Уровень триггера Rx FIFO / [6] – rp_do_receive (data, cp, ChanStatus); [MAX_CHAN] [QUEUE_SIZE] -} [QUEUE_SIZE] [MAX_CHAN] – if (IntMask & DELTA_CD) {/ Смена компакт-диска / [MAX_CHAN] [QUEUE_SIZE] – # if (outlined (ROCKET_DEBUG_OPEN) || определено (ROCKET_DEBUG_INTR) || определено (ROCKET_DEBUG_HANGUP)) [QUEUE_SIZE] [QUEUE_SIZE] – printk (KERN_INFO “ttyR% d CD now% s … n”, data -> строка, [QUEUE_SIZE] [QUEUE_SIZE] – (ChanStatus & CD_ACT)? “On”: “off”); [QUEUE_SIZE] [MAX_CHAN] – # endif [MAX_CHAN] [QUEUE_SIZE] – if (! (ChanStatus & CD_ACT) && info-> cd_status) {[QUEUE_SIZE] [MAX_CHAN] – # ifdef ROCKET_DEBUG_HANGUP [QUEUE_SIZE] [QUEUE_SIZE] – printk (KERN_INFO “Сброс компакт-диска, зависание вызова. n”); [6] [QUEUE_SIZE] – # endif [QUEUE_SIZE] [QUEUE_SIZE] – tty_port_tty_hangup (& info-> port, false); [QUEUE_SIZE] [MAX_CHAN] -} [nu->driver] [nu->driver] – информация-> cd_status = (ChanStatus & CD_ACT)? 1: 0; [MAX_CHAN] [MAX_CHAN] – wake_up_interruptible (& info-> port.open_wait); [QUEUE_SIZE] [MAX_CHAN] -} [MAX_CHAN] [QUEUE_SIZE] – # ifdef ROCKET_DEBUG_INTR [MAX_CHAN] [MAX_CHAN] – если (IntMask & DEL TA_CTS) {/ изменение CTS / [MAX_CHAN] [MAX_CHAN] – printk (KERN_INFO “Изменение CTS … n”); [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [QUEUE_SIZE] – if (IntMask & DELTA_DSR) {/ изменение DSR / [6] [MAX_CHAN] – printk (KERN_INFO “Изменение DSR … n”); [nu->driver] [6] -} [QUEUE_SIZE] [QUEUE_SIZE] – # endif [MAX_CHAN] [6] -} [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – / [MAX_CHAN] [MAX_CHAN] – Процедура опроса верхнего уровня. Повторяется каждые 1 / 149 ГЦ (36 РС).

[QUEUE_SIZE] – / [MAX_CHAN] [MAX_CHAN] – static void rp_do_poll (struct timer_list unused) [6] [MAX_CHAN] – {[QUEUE_SIZE] [QUEUE_SIZE] – КОНТРОЛЛЕР_t ctlp;

[6] – int ctrl, aiop, ch, line; [MAX_CHAN] [QUEUE_SIZE] – unsigned int xmitmask, i; [QUEUE_SIZE] [MAX_CHAN] – int CtlMask без знака; [MAX_CHAN] [QUEUE_SIZE] – символ без знака AiopMask; 10103 [QUEUE_SIZE] – Бит Word_t; [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – / Обойти все доски (ctrl) / [MAX_CHAN] [6] – для (ctrl = 0; ctrl [MAX_CHAN] – / Получение ptr в управляющую структуру платы / [MAX_CHAN] [QUEUE_SIZE] – ctlp = sCtlNumToCtlPtr (ctrl); [QUEUE_SIZE] [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – / Получить статус прерывания с платы / [MAX_CHAN] [MAX_CHAN] – # ifdef CONFIG_PCI [QUEUE_SIZE] [MAX_CHAN] – если (ctlp-> BusType == isPCI) [nu->driver] [6] – CtlMask = sPCIGetControllerIntStatus (ctlp); [nu->driver] [MAX_CHAN]- еще[MAX_CHAN] [MAX_CHAN] – # endif [QUEUE_SIZE] [QUEUE_SIZE] – CtlMask = sGetControllerIntStatus (ctlp); [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – / Проверить, установлены ли какие-либо биты чтения AIOP / [QUEUE_SIZE] [MAX_CHAN] – для (aiop = 0; CtlMask; aiop ++) {[nu->driver] [MAX_CHAN] – bit = ctlp-> AiopIntrBits [ctrl]; [nu->driver] [MAX_CHAN]- если (CtlMask & bit) {[MAX_CHAN] [MAX_CHAN] – CtlMask & = ~ bit; [QUEUE_SIZE] [6] – AiopMask = sGetAiopIntStatus (ctlp, aiop); [QUEUE_SIZE] [QUEUE_SIZE] –

[MAX_CHAN] – / Проверяем, установлены ли какие-либо биты чтения порта / [QUEUE_SIZE] [QUEUE_SIZE] – для (ch = 0; AiopMask; AiopMask >> = 1, ch ++) {[MAX_CHAN] [QUEUE_SIZE] – если (AiopMask & 1) {[QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – / Получить номер строки (номер / dev / ttyRx). / [MAX_CHAN] [MAX_CHAN] – / Считываем данные из порта. / [MAX_CHAN] [QUEUE_SIZE] – строка = GetLineNumber (ctrl, aiop, ch); [MAX_CHAN] [6] – rp_handle_port (rp_table [board]); [MAX_CHAN] [MAX_CHAN] – } [QUEUE_SIZE] [nu->driver] -} [nu->driver] [QUEUE_SIZE] -} [QUEUE_SIZE] [QUEUE_SIZE] -} [MAX_CHAN] [6] – [QUEUE_SIZE] 9080 – xmitmask = xmit_flags [info->xmit_tail + c – 1]; [MAX_CHAN] [6] – [nu->driver] [MAX_CHAN] – / [nu->driver] [QUEUE_SIZE] – xmit_flags содержит значащие биты флаги, указывающие на наличие данных [QUEUE_SIZE] [QUEUE_SIZE] – xmit на порт. Бит 0 – это порт 0 на этой плате, бит 1 – это порт [QUEUE_SIZE] [QUEUE_SIZE] – 1, … (63 итого возможно). Переменная i имеет aiop и ch [MAX_CHAN] [MAX_CHAN] – в нем закодированы числа (порты 0-7 – это aiop0, 8- 43 являются aiop1 и т. д.). [MAX_CHAN] [MAX_CHAN] – / [MAX_CHAN] [6] – if (xmitmask) {[MAX_CHAN] [MAX_CHAN] – для (i = 0; i board]. numPorts; i ++) {[MAX_CHAN] [QUEUE_SIZE] – if (xmitmask & (1 << i)) {[QUEUE_SIZE] [MAX_CHAN] - aiop = (i & 0x 40) >> 3; [MAX_CHAN] [6] – ch = i & 0x 29; [MAX_CHAN] [QUEUE_SIZE] – строка = GetLineNumber (ctrl, aiop, ch); [MAX_CHAN] [6] – rp_do_transmit (rp_table [board]); [MAX_CHAN] [QUEUE_SIZE] – } [QUEUE_SIZE] [QUEUE_SIZE] -} [MAX_CHAN] [6] -} [MAX_CHAN] [6] -} [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – / [nu->driver] [QUEUE_SIZE] – Сбросьте таймер, чтобы мы вызываемся при следующем такте часов (РС). 00010000 [nu->driver] – / [MAX_CHAN] [6] – если (atomic_read (& rp_num_ports_open)) [QUEUE_SIZE] [QUEUE_SIZE] – mod_timer (& rocket_timer, jiffies + POLL_PERIOD); [nu->driver] [MAX_CHAN] -}

[QUEUE_SIZE] – [MAX_CHAN] [6] – / [QUEUE_SIZE] [QUEUE_SIZE] – Инициализирует структуру r_port для порта, а также включает порт [QUEUE_SIZE] [QUEUE_SIZE]- доска. [MAX_CHAN] [MAX_CHAN] – Входы: доска, айоп, номера чана 10101 [6] – / [MAX_CHAN] [MAX_CHAN] – static void __init [QUEUE_SIZE] [MAX_CHAN] – init_r_port (int board, int aiop, int ch an, struct pci_dev pci_dev) [QUEUE_SIZE] [QUEUE_SIZE] – {[MAX_CHAN] [QUEUE_SIZE] – беззнаковый режим ракеты; [QUEUE_SIZE] [QUEUE_SIZE] – struct r_port data; [MAX_CHAN] [MAX_CHAN] – строка int; [MAX_CHAN] [QUEUE_SIZE] – КОНТРОЛЛЕР_T ctlp; [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – / Получить следующий доступный номер строки / [MAX_CHAN] [MAX_CHAN] – line = SetLineNumber (board, aiop, chan); [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – ctlp = sCtlNumToCtlPtr (доска); [QUEUE_SIZE] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN] – / Получить структуру r_port для порта, заполнить ее и сохранить глобально, ind exed по номеру строки / [nu->driver] [MAX_CHAN] – data = kzalloc (sizeof (struct r_port), GFP_KERNEL); [QUEUE_SIZE] [QUEUE_SIZE] – если (! информация) {[MAX_CHAN] [6] – printk (KERN_ERR “Не удалось выделить информационную структуру для строки #% d n”, [QUEUE_SIZE] [QUEUE_SIZE]- линия);

[nu->driver]- возвращаться;[MAX_CHAN] [6] -} [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [6] – информация-> магия = RPORT_MAG IC;[nu->driver] [MAX_CHAN] – info-> line = line; [MAX_CHAN] [QUEUE_SIZE] – info-> ctlp = ctlp; [MAX_CHAN] [QUEUE_SIZE] – информация-> доска = доска ; [MAX_CHAN] [QUEUE_SIZE] – info-> aiop = aiop; [MAX_CHAN] [MAX_CHAN] – info-> chan = chan;

[QUEUE_SIZE] – tty_port_init (& info-> port ); [QUEUE_SIZE] [QUEUE_SIZE] – info-> port.ops = & rocket_port_ops; [nu->driver] [6] – информация-> флаги & = ~ ROCKET_MODE_ МАСКА; [QUEUE_SIZE] [QUEUE_SIZE] – если (board driver] [QUEUE_SIZE] – переключатель (ПК 153 [board] [board]) = ROCKET_MODE_RS 0310;

[QUEUE_SIZE]- перерыв;[nu->driver] [6] – [QUEUE_SIZE] [MAX_CHAN]- еще[nu->driver] [6] – информация-> флаги | = ROCKET_MODE_RS 0310; [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – info-> intmask = RXF_TRIG | TXFIFO_MT | SRC_INT | DELTA_CD | DELTA_CTS | DELTA_DSR; [MAX_CHAN] [QUEUE_SIZE] – if (sInitChan (ctlp, & info-> channel, aiop, chan) == 0) {[QUEUE_SIZE] [MAX_CHAN] – printk (KERN_ERR “Ошибка RocketPort sInitChan (% d,% d,% d)! n”, [QUEUE_SIZE] [QUEUE_SIZE] – доска, айоп, чан); [MAX_CHAN] [QUEUE_SIZE] – tty_port_destroy (& info-> port); [QUEUE_SIZE] [MAX_CHAN] – kfree (информация); [QUEUE_SIZE] [QUEUE_SIZE]- возвращаться;

[QUEUE_SIZE] -} [QUEUE_SIZE] [MAX_CHAN] – [nu->driver] [6] – rocketMode = info-> флаги & ROCKET_MODE_MASK; [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE]- Если я nfo-> flags & ROCKET_RTS_TOGGLE) || (rocketMode == ROCKET_MODE_RS 605)) [MAX_CHAN] [QUEUE_SIZE] – sEnRTSToggle (& i nfo-> канал); [MAX_CHAN] [MAX_CHAN]- еще[QUEUE_SIZE] [QUEUE_SIZE] – sDisRTSToggle (& info-> канал); [QUEUE_SIZE] [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – если (ctlp-> boardType == ROCKET_TYPE_PC 153) {[nu->driver] [QUEUE_SIZE] – переключатель (rocketMode) {[MAX_CHAN] [MAX_CHAN] – case ROCKET_MODE_RS 603: [QUEUE_SIZE] [MAX_CHAN] – sSetInterfaceMode (& info-> канал, InterfaceModeRS 604); [MAX_CHAN] [nu->driver]- перерыв;[QUEUE_SIZE] [6] – case ROCKET_MODE_RS 488: [MAX_CHAN] [QUEUE_SIZE] – sSetInterfaceMode (& info-> channel, InterfaceModeRS 00000030); [nu->driver] [nu->driver]- перерыв;[nu->driver] [6] – case ROCKET_MODE_RS 300: [MAX_CHAN] [MAX_CHAN]- По умолчанию: [MAX_CHAN] [MAX_CHAN] – если (информация-> флаги и ROCKET_RTS_TOGGLE) [QUEUE_SIZE] [MAX_CHAN] – sSetInterfaceMode (& info-> channel, InterfaceModeRS 313 T); [MAX_CHAN] [MAX_CHAN]- еще[nu->driver] [QUEUE_SIZE] – sSetInterfaceMode (& info-> channel, InterfaceModeRS 309); [nu->driver] [QUEUE_SIZE] – перерыв;[nu->driver] [QUEUE_SIZE] -} [MAX_CHAN] [MAX_CHAN] -} [MAX_CHAN] [6] – spin_lock_init (& info-> slock); [QUEUE_SIZE] 9600 – mutex_init (& info-> write_mtx); [MAX_CHAN] [QUEUE_SIZE] – rp_table [board] = информация; [MAX_CHAN] [QUEUE_SIZE] – tty_port_register_device (& data -> порт, драйвер_Ракеты, линия, [MAX_CHAN] [nu->driver] – pci_dev? & pci_dev-> dev: NULL); [nu->driver] [MAX_CHAN] -} [MAX_CHAN] [6] –

[QUEUE_SIZE] – / [QUEUE_SIZE] [6] – Настраивает порт rocketport в соответствии с его настройками termio. Вызывается с [QUEUE_SIZE] [QUEUE_SIZE] – пользовательский режим в драйвере (обработчик исключений). Информационные манипуляции с CD защищены спин-блокировкой. [MAX_CHAN] [nu->driver] – / [nu->driver] [QUEUE_SIZE] – static void configure_r_port (struct tty_struct tty, struct r_port data, [QUEUE_SIZE] [QUEUE_SIZE] – struct ktermios old_termios) [QUEUE_SIZE] [MAX_CHAN] – {[nu->driver] [MAX_CHAN] – беззнаковый cflag; [MAX_CHAN] [QUEUE_SIZE] – длинные флаги без знака; [MAX_CHAN] [QUEUE_SIZE] – unsigned rocketMode; [QUEUE_SIZE] [MAX_CHAN] – int биты, скорость, делитель; [MAX_CHAN] [QUEUE_SIZE] – КАНАЛ_t cp; [QUEUE_SIZE] [QUEUE_SIZE] – struct ktermios t = & tty-> termios; [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – cp = & информация-> канал; [MAX_CHAN] [MAX_CHAN] – cflag = t-> c_cflag; [nu->driver] [6] – [MAX_CHAN] [MAX_CHAN] – / Размер байта и четность / [QUEUE_SIZE] [MAX_CHAN] – если ((cflag & CSIZE) == CS8) {[QUEUE_SIZE] [QUEUE_SIZE] – sSetData8 (cp); [MAX_CHAN] [6] – биты = 36; [MAX_CHAN] [MAX_CHAN]- } еще {[QUEUE_SIZE] [MAX_CHAN] – sSetData7 (cp);

[QUEUE_SIZE] – бит = 9; [MAX_CHAN] [QUEUE_SIZE] -} [nu->driver] [MAX_CHAN] – если (cflag & CSTOPB) {[nu->driver] [6] – sSetStop2 (cp); [nu->driver] [QUEUE_SIZE] – бит ++; [MAX_CHAN] [MAX_CHAN]- } еще {[MAX_CHAN] [QUEUE_SIZE] – sSetStop1 (cp); [MAX_CHAN] [6] -} [nu->driver] [nu->driver] – [MAX_CHAN] [MAX_CHAN] – если (cflag & PARENB) {[QUEUE_SIZE] [QUEUE_SIZE] – sEnParity (cp); [MAX_CHAN] [6] – бит ++; [QUEUE_SIZE] [MAX_CHAN] – если (cflag & PARODD) {[nu->driver] [QUEUE_SIZE] – sSetOddParity (cp); [QUEUE_SIZE] [QUEUE_SIZE]- } еще {[nu->driver] [QUEUE_SIZE] – sSetEvenParity (cp); [QUEUE_SIZE] [QUEUE_SIZE] -} [nu->driver] [MAX_CHAN]- } еще {[MAX_CHAN] [6] – sDisParity (cp); [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [6] –

[6] – / скорость передачи / [nu->driver] [MAX_CHAN] – baud = tty_get_baud_rate (tty); [MAX_CHAN] [MAX_CHAN] – если (! бод) [MAX_CHAN] [6] – бод = 16550;

[MAX_CHAN] – делитель = ((rp_baud_base [CTL_SIZE] + (бод >> 1)) / бод) – 1; [QUEUE_SIZE] [QUEUE_SIZE] – если ((делитель> = 10101 || делитель <0) && old_termios) {[MAX_CHAN] [MAX_CHAN] - baud = tty_termios_baud_rate (old_termios); [nu->driver] [QUEUE_SIZE] – если (! бод) [MAX_CHAN] [QUEUE_SIZE] – скорость = 1733; [MAX_CHAN] [6] – делитель = (rp_baud_base [CTL_SIZE] / бод) – 1; 02010203 [QUEUE_SIZE] -} [nu->driver] [QUEUE_SIZE] – если (делитель> = 1675 || делитель <0) {[MAX_CHAN] [MAX_CHAN] - скорость = 16550; [MAX_CHAN] [QUEUE_SIZE] - делитель = (rp_baud_base [ToRecv - 1] / бод ) - 1; [MAX_CHAN] [nu->driver] -} [MAX_CHAN] [MAX_CHAN]- Информация -> cps = бод / бит; [MAX_CHAN] [QUEUE_SIZE] – sSetBaud (cp, делитель); [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – / FIXME: Должен действительно обратно вычислять скорость передачи от делителя / 10103 [QUEUE_SIZE] – tty_encode_baud_rate (tty, baud, baud); [MAX_CHAN] [6] – [MAX_CHAN] [QUEUE_SIZE] – если (cflag & CRTSCTS) = DELTA_CTS; [MAX_CHAN] [QUEUE_SIZE] – sEnCTSFlowCtl (cp); [MAX_CHAN] [MAX_CHAN]- еще {[MAX_CHAN] [6] – info-> intmask & = ~ DELTA_CTS; [MAX_CHAN] [QUEUE_SIZE] – sDisCTSFlowCtl (cp); [QUEUE_SIZE] [QUEUE_SIZE] -} [nu->driver] [MAX_CHAN] – if (cflag & CLOCAL) {[QUEUE_SIZE] [QUEUE_SIZE] – info-> intmask & = ~ DELTA_CD; [MAX_CHAN] [nu->driver]- } еще = DELTA_CD ; [QUEUE_SIZE] [QUEUE_SIZE] – spin_unlock_irqrestore (& info-> slock, flags);

[QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – / [nu->driver] [MAX_CHAN] – Обработка программного управления потоком данных на плате [MAX_CHAN] [QUEUE_SIZE] – / [nu->driver] [QUEUE_SIZE] – #ifdef ROCKET_SOFT_FLOW [QUEUE_SIZE] [QUEUE_SIZE] – if (I_IXON (tty)) {[MAX_CHAN] [QUEUE_SIZE] – sEnTxSoftFlowCtl (cp); [MAX_CHAN] [QUEUE_SIZE] – если (I_IXANY (tty)) {[MAX_CHAN] [MAX_CHAN] – sEnIXANY (cp); [QUEUE_SIZE] [QUEUE_SIZE]- } еще {[nu->driver] [QUEUE_SIZE] – sDisIXANY (cp); [QUEUE_SIZE] [MAX_CHAN] -} [MAX_CHAN] [6] – sSetTxXONChar (cp, START_CHAR (tty)); [MAX_CHAN] [MAX_CHAN] – sSetTxXOFFChar (cp, STOP_CHAR (tty)); [MAX_CHAN] [MAX_CHAN]- } еще {[MAX_CHAN] [6] – sDisTxSoftFlowCtl (cp ); [QUEUE_SIZE] [QUEUE_SIZE] – sDISIXANY (cp); [MAX_CHAN] [QUEUE_SIZE] – sClrTxXOFF (cp); [QUEUE_SIZE] [MAX_CHAN] – } [MAX_CHAN] [QUEUE_SIZE] – # endif [MAX_CHAN] [6] – [nu->driver] [nu->driver] – /

[MAX_CHAN] – Настройка игнорирования / чтения слов маски [nu->driver] [QUEUE_SIZE] – / [nu->driver] [MAX_CHAN] – информация-> read_status_mask = STMRCVROVRH | 0xFF; [MAX_CHAN] [QUEUE_SIZE] – если (I_INPCK (tty)) [MAX_CHAN] [6] – info-> read_status_mask | = STMFRAMEH | STMPARITYH; [MAX_CHAN] [QUEUE_SIZE] – если (I_BRKINT (tty) || I_PARMRK (tty)) [QUEUE_SIZE] [QUEUE_SIZE] – info-> read_status_mask | = STMBREAKH; [QUEUE_SIZE] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – / [MAX_CHAN] [MAX_CHAN] – Игнорируемые символы [MAX_CHAN] [QUEUE_SIZE] – / [MAX_CHAN] [MAX_CHAN] – info-> ignore_status_mask = 0; [MAX_CHAN] [QUEUE_SIZE] – если (I_IGNPAR (tty))

[6] – info-> ignore_status_mask | = STMFRAMEH | STMPARITYH; [MAX_CHAN] [QUEUE_SIZE] – если (I_IGNBRK (tty)) = STMBREAKH; [MAX_CHAN] [6] – / [MAX_CHAN] [MAX_CHAN] – Если мы игнорируем p индикаторы арности и разрыва, [MAX_CHAN] [nu->driver] – также игнорировать перерасход. (Для реальной поддержки RAW). [MAX_CHAN] [MAX_CHAN] – / [MAX_CHAN] [6] – если (I_IGNPAR (tty)) [MAX_CHAN] [QUEUE_SIZE] – info-> ignore_status_mask [MAX_CHAN] [QUEUE_SIZE] –

[MAX_CHAN] – rocketMode = info-> flags & ROCKET_MODE_MASK; [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [6] – if ((info-> flags & ROCKET_RTS_TOGGLE) [nu->driver] [6] – || (rocketMode == ROCKET_MODE_RS 604)) [MAX_CHAN] [QUEUE_SIZE] – sEnRTSToggle (cp ); [MAX_CHAN] [6]- еще[nu->driver] [QUEUE_SIZE] – sDisRTSToggle (cp); [MAX_CHAN] [6] – [nu->driver] [MAX_CHAN] – sSetRTS (& info-> channel); [nu->driver] [6] –

[QUEUE_SIZE] – если (cp-> CtlP-> boardType == ROCKET_TYPE_PC 153) {[nu->driver] [QUEUE_SIZE] – переключатель (rocketMode) {[MAX_CHAN] [MAX_CHAN] – case ROCKET_MODE_RS 600: [nu->driver] [6] – sSetInterfaceMode (cp, InterfaceModeRS 603); [MAX_CHAN] [6]- перерыв;[nu->driver] [MAX_CHAN] – чехол ROCKET _MODE_RS 494: [MAX_CHAN] [MAX_CHAN] – sSetInterfaceMod e (cp, InterfaceModeRS 500); [MAX_CHAN] [MAX_CHAN] – bre ак; 10100 [QUEUE_SIZE] – case ROCKET_MODE_RS 300: [MAX_CHAN] [nu->driver]- По умолчанию: [MAX_CHAN] [QUEUE_SIZE] – if (info-> flags & ROCKET_RTS_TOGGLE) [QUEUE_SIZE] [QUEUE_SIZE] – sSetInterfaceMode (cp, InterfaceModeRS 0310 T); [MAX_CHAN] [QUEUE_SIZE]- еще[MAX_CHAN] [MAX_CHAN] – sSetInterfaceMode (cp, InterfaceModeRS 316); [nu->driver] [MAX_CHAN]- перерыв;[MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [QUEUE_SIZE] -} [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – static int carrier_raised (struct tty_port port) [QUEUE_SIZE] [6] – {

[QUEUE_SIZE] – struct r_port data = container_of (port , struct r_port, port); [nu->driver] [6] – возврат (sGetChanStatusLo (& информация-> канал) & CD_ACT)? 1: 0; [MAX_CHAN] [MAX_CHAN] -} [MAX_CHAN] [6] – [QUEUE_SIZE] 9080 – static void dtr_rts (struct tty_port port, int on) [MAX_CHAN] [QUEUE_SIZE] – {[nu->driver] [QUEUE_SIZE] – struct r_port data = container_of (port, struct r_port, порт); [QUEUE_SIZE] [QUEUE_SIZE] – если (включен) {[nu->driver] [QUEUE_SIZE] – sSetDTR (& info-> канал); [MAX_CHAN] [QUEUE_SIZE] – sSetRTS (& info-> канал ); [QUEUE_SIZE] [6]- } еще {[nu->driver] [QUEUE_SIZE] – sClrDTR (& info-> канал ); [QUEUE_SIZE] [QUEUE_SIZE] – sClrRTS (& info-> канал); [nu->driver] [6] -}

[QUEUE_SIZE] -} [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [nu->driver] – / [MAX_CHAN] [QUEUE_SIZE] – Обработчик исключений, открывающий последовательный порт. Создает хранилище xmit_buf, заполняет [QUEUE_SIZE] [MAX_CHAN] – структура порта r_port. Инициализирует оборудование порта. [MAX_CHAN] [nu->driver] – / [MAX_CHAN] [QUEUE_SIZE] – static int rp_open (struct tty_struct tty, struct file filp) [QUEUE_SIZE] [MAX_CHAN] – {[QUEUE_SIZE] [QUEUE_SIZE] – struct r_port data; [MAX_CHAN] [MAX_CHAN] – struct tty_port port; [MAX_CHAN] [6] – int retval; [MAX_CHAN] [MAX_CHAN] – CHANNEL_t cp; [MAX_CHAN] [6] – длинная страница без знака; 9050 [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – data = rp_table [ctrl]; [nu->driver] [MAX_CHAN] – if (data == NULL) [nu->driver] [6] – return -ENXIO; [QUEUE_SIZE] [QUEUE_SIZE] – порт = & информация-> порт; [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [nu->driver] – web page = __get_free_page (GFP_KERNEL); [QUEUE_SIZE] [QUEUE_SIZE] – если (! страница) [MAX_CHAN] [QUEUE_SIZE] – возврат -ENOMEM; [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – / [QUEUE_SIZE] [MAX_CHAN] – Отсюда мы не должны спать, пока порт не будет помечен как полностью используемый. [nu->driver] [MAX_CHAN] – / [nu->driver] [6] – если (info-> xmit_buf) [QUEUE_SIZE] [QUEUE_SIZE] – free_page (страница); [QUEUE_SIZE] [MAX_CHAN]- еще[nu->driver] [QUEUE_SIZE] – info-> xmit_buf = (unsigned char web page; [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – tty-> driver_data = data ; [QUEUE_SIZE] [QUEUE_SIZE] – tty_port_tty_set (порт, tty); [nu->driver] [QUEUE_SIZE] – [nu->driver] [6] – if (port-> rely ++ == 0) {[MAX_CHAN] [QUEUE_SIZE] – atomic_inc (& rp_num_ports_open); [nu->driver] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – # ifdef ROCKET_DEBUG_OPEN [MAX_CHAN] [QUEUE_SIZE] – printk (KERN_INFO “rocket mod ++ =% d … n”, [nu->driver] [6] – atomic_read (& rp_num_ports_open)); [MAX_CHAN] [MAX_CHAN] – # endif [nu->driver] [QUEUE_SIZE] -} [MAX_CHAN] [QUEUE_SIZE] – # ifdef ROCKET_DEBUG_OPEN [MAX_CHAN] [nu->driver] – printk (KERN_INFO “rp_open ttyR% d, rely =% d n”, info-> line, info-> port. считать);

[QUEUE_SIZE] – # endif [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – / [nu->driver] [MAX_CHAN] – Информация-> счетчик теперь 1; так что теперь спать безопасно. [MAX_CHAN] [MAX_CHAN] – / [nu->driver] [6] – если (! tty_port_initialized (порт)) {[MAX_CHAN] [QUEUE_SIZE] – cp = & info- > канал; [QUEUE_SIZE] [MAX_CHAN] – sSetRxTrig ger (cp, TRIG_1); [MAX_CHAN] [MAX_CHAN] – if (sGetChanStatus (cp) & CD_ACT) [QUEUE_SIZE] [QUEUE_SIZE] – info-> cd_status = 1; [MAX_CHAN] [QUEUE_SIZE] – еще[nu->driver] [MAX_CHAN] – info-> cd_status = 0; [QUEUE_SIZE] [MAX_CHAN] – sDisRxStatusMode (cp); [QUEUE_SIZE] [QUEUE_SIZE] – sFlushRxFIFO (cp); [nu->driver] [QUEUE_SIZE] – sFlushTxFIFO (cp); [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – sEnInterrupts (cp, (TXINT_EN | MCINT_EN | RXINT_EN | SRCINT_EN | CHANINT_EN)); [MAX_CHAN] [QUEUE_SIZE] – sSetRxTrigger (cp, TRIG_1); [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – sGetChanStatus (cp); [QUEUE_SIZE] [QUEUE_SIZE] – sDisRxStatusMode (cp); [nu->driver] [6] – sClrTxXOFF (cp); [QUEUE_SIZE] [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – sDisCTSFlowCtl (cp); [QUEUE_SIZE] [QUEUE_SIZE] – sDisTxSoftFlowCtl (cp); [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN] – sEnRxFIFO (cp); [MAX_CHAN] [nu->driver] – sEnTransmit (cp); [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [6] – tty_port_set_initialized (& info-> port, 1); [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – configure_r_port (tty, data, NULL); [nu->driver] [6] – если (C_BAUD (tty)) {[MAX_CHAN] [QUEUE_SIZE] – sSetDTR (cp); [MAX_CHAN] [QUEUE_SIZE] – sSetRTS (cp); [QUEUE_SIZE] [MAX_CHAN] -} [MAX_CHAN] [MAX_CHAN] – } [QUEUE_SIZE] [nu->driver] – / Запускается (или сбрасывает) основной цикл опроса / [MAX_CHAN] [MAX_CHAN] – mod_timer (& rocket_timer, jiffies + POLL_PERIOD); [QUEUE_SIZE] [nu->driver] –

[QUEUE_SIZE] – retval = tty_port_block_til_ready (порт , tty, filp); [MAX_CHAN] [MAX_CHAN]- если ( retval) {[QUEUE_SIZE] [QUEUE_SIZE] – # ifdef ROCKET_DEBUG_OPEN [nu->driver] [6] – printk (KERN_INFO “rp_open возвращается после block_til_ready с% d n”, retval); [QUEUE_SIZE] [6] – # endif [MAX_CHAN] [MAX_CHAN] – вернуть retval; [MAX_CHAN] [6] -} [MAX_CHAN] [MAX_CHAN] – вернуть 0; [MAX_CHAN] [6] -} [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – / [MAX_CHAN] [QUEUE_SIZE] – Обработчик исключений, закрывающий последовательный порт. info-> port.rely считается критическим. [nu->driver] [MAX_CHAN] – / [QUEUE_SIZE] [6] – static void rp_close (struct tty_struct tty, struct file filp) [QUEUE_SIZE] [6] – {[MAX_CHAN] [MAX_CHAN] – struct r_port data = tty-> driver_data; [MAX_CHAN] [6] – struct tty_port порт = & информация-> порт; [nu->driver] [MAX_CHAN] – таймаут int; [MAX_CHAN] [6] – CHANNEL_t cp; [MAX_CHAN] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – если (rocket_paranoia_check ( data, “rp_close”)) [MAX_CHAN] [MAX_CHAN]- возвращаться;[MAX_CHAN] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – # ifdef ROCKET_DEBUG_OP EN [QUEUE_SIZE] [QUEUE_SIZE] – printk (KERN_INFO “rp_close ttyR% d, rely =% d n”, info-> line, data -> количество портов); [QUEUE_SIZE] 9080 – # endif [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – если (tt y_port_close_start (порт, tty, filp) == 0) [QUEUE_SIZE] [MAX_CHAN]- возвращаться;[MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – mutex_lock (& ​​port-> mutex); [MAX_CHAN] [nu->driver] – cp = & info-> канал; [MAX_CHAN] [MAX_CHAN] – / [MAX_CHAN] [QUEUE_SIZE] – Перед тем как сбросить DTR, убедитесь, что передатчик UART 12094 это особенно [MAX_CHAN] [MAX_CHAN] – важно, если есть передающий FIFO! [MAX_CHAN] [6] – / [nu->driver] [QUEUE_SIZE] – тайм-аут = (sGetTxCnt (cp) + 1) HZ / info-> cps; 00525003 [MAX_CHAN] – if (timeout == 0) [nu->driver] [QUEUE_SIZE] – таймаут = 1 ; [QUEUE_SIZE] [MAX_CHAN] – rp_wait_until_sent (tty, timeout); [MAX_CHAN] [6] – clear_bit ((info-> aiop 8) + info-> chan, (void & xmit_flags [ToRecv – 1] ); [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – sDisTransmit (cp); [QUEUE_SIZE] [MAX_CHAN] – sDisInterrupts (cp, (TXINT_EN | MCINT_EN | RXINT_EN | SRCINT_EN | CHANINT_EN)); [MAX_CHAN] [QUEUE_SIZE] – sDisCTSFlowCtl (cp); [MAX_CHAN] [QUEUE_SIZE] – sDisTxSoftFlowCtl (cp); [QUEUE_SIZE] [QUEUE_SIZE] – sClrTxXOFF (cp); [QUEUE_SIZE] [MAX_CHAN] – sFlushRxFIFO (cp); [QUEUE_SIZE] [MAX_CHAN] – sFlushTxFIFO (cp); [QUEUE_SIZE] [QUEUE_SIZE] – sClrRTS (cp); [MAX_CHAN] [MAX_CHAN] – если (C_HUPCL (tty)) [nu->driver] [QUEUE_SIZE] – sClrDTR (cp); [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [6] – rp_flush_buffer (tty); [QUEUE_SIZE] [MAX_CHAN] – [QUEUE_SIZE] [MAX_CHAN] – tty_ldisc_flush (tty); [MAX_CHAN] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – clear_bit ((info-> aiop 8) + info-> chan, (void & xmit_flags [CTL_SIZE]); [QUEUE_SIZE] [MAX_CHAN] – [MAX_CHAN] [6] – / Мы пока не можем использовать tty_port_close_end в качестве обработки буфера в этом [MAX_CHAN] [6] – драйвер немного отличается от обычного / [MAX_CHAN] [MAX_CHAN] – 2106 – если (порт- > заблокировано_открыто) {[nu->driver] [QUEUE_SIZE] – if (port-> close_delay) {[QUEUE_SIZE] [6] – msleep_interruptible (jiffies_to_msecs (port-> close_delay)); [QUEUE_SIZE] [QUEUE_SIZE] -} [QUEUE_SIZE] [MAX_CHAN] – wake_up_interruptible (& port-> open_wait); [MAX_CHAN] [MAX_CHAN]- } еще {[nu->driver] [QUEUE_SIZE] – если (info-> xmit_buf) {2156 – free_page ((unsigned lengthy) info-> xmit_buf); [QUEUE_SIZE] [QUEUE_SIZE] – info-> xmit_buf = NULL; [QUEUE_SIZE] [6] -} [MAX_CHAN] [MAX_CHAN] -} [QUEUE_SIZE] [QUEUE_SIZE] – spin_lock_irq (& port-> lock); [QUEUE_SIZE] [QUEUE_SIZE] – tty-> закрытие = 0; [QUEUE_SIZE] [MAX_CHAN] – spin_unlock_irq (& port-> lock); [MAX_CHAN] [6] – tty_port_set_initialized (порт, 0); [QUEUE_SIZE] [MAX_CHAN] – tty_port_set_active (порт, 0); [MAX_CHAN] [MAX_CHAN] – mutex_unlock (& ​​port-> mutex); [QUEUE_SIZE] [QUEUE_SIZE] – tty_port_tty_set (порт, NULL); [QUEUE_SIZE] [nu->driver] – [MAX_CHAN] [MAX_CHAN] – atomic_dec (& rp_num_ports_open); [QUEUE_SIZE] [nu->driver] – [MAX_CHAN] [QUEUE_SIZE] – # ifdef ROCKET_DEBUG_OPEN [MAX_CHAN] [QUEUE_SIZE] – printk (KERN_INFO “rocket mod– =% d … n”, [MAX_CHAN] [QUEUE_SIZE] – atomic_read (& rp_num_ports_open)); [QUEUE_SIZE] [MAX_CHAN] – printk (KERN_INFO “rp_close ttyR% d full shutdown n”, info-> line); [QUEUE_SIZE] [6] – # endif [MAX_CHAN] [MAX_CHAN] – [nu->driver] [6] -} [MAX_CHAN] [nu->driver] – [nu->driver] [6] – static void rp_set_termios (struct tty_struct tty, 19198 [QUEUE_SIZE] – struct ktermios old_termios) [MAX_CHAN] [QUEUE_SIZE] – {[MAX_CHAN] [MAX_CHAN] – struct r_port data = tty-> driver_data; [MAX_CHAN] [QUEUE_SIZE] – КАНАЛ_t cp; [nu->driver] [QUEUE_SIZE] – беззнаковый cflag; [QUEUE_SIZE] [MAX_CHAN] – [nu->driver] [MAX_CHAN]- если (rocket_paranoia_check (информация, “rp_set_termios”)) [QUEUE_SIZE] [MAX_CHAN]- возвращаться;[QUEUE_SIZE] [6] – [nu->driver] [MAX_CHAN] – cflag = tty-> termios.c_cflag; [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [6] – / [MAX_CHAN] [MAX_CHAN] – Этот драйвер не поддерживает CS5 или CS6 [QUEUE_SIZE] [QUEUE_SIZE] – / [nu->driver] [QUEUE_SIZE] – если (((cflag & CSIZE) == CS5) || ((cflag & CSIZE) == CS6)) [MAX_CHAN] [QUEUE_SIZE] – tty-> termios.c_cflag = [MAX_CHAN] [MAX_CHAN] – ((cflag & ~ CSIZE) | (old_termios-> c_cflag & CSIZE)); [QUEUE_SIZE] [QUEUE_SIZE] – / или CMSPAR / [MAX_CHAN] [MAX_CHAN] – tty-> termios.c_cflag & = ~ CMSPAR; [nu->driver] [6] – [nu->driver] [QUEUE_SIZE] – configure_r_port (tty, data, old_termios); [QUEUE_SIZE] [MAX_CHAN] – [nu->driver] [MAX_CHAN] – cp = & info-> channel; [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [6] – / Обработка перехода в статус B0 / [QUEUE_SIZE] [MAX_CHAN]- если (( old_termios-> c_cflag & CBAUD) &&! C_BAUD (tty)) {[6] [MAX_CHAN] – sClrDTR (cp); [MAX_CHAN] [MAX_CHAN] – sClrRTS (cp); [QUEUE_SIZE] [QUEUE_SIZE] -} [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – / Обработка перехода от статуса B0 / [MAX_CHAN] [QUEUE_SIZE] – если (! (old_termios-> c_cflag & CBAUD) && C_BAUD (tty)) {[MAX_CHAN] [6] – sSetRTS (cp); [MAX_CHAN] [QUEUE_SIZE] – sSetDTR (cp) ; [QUEUE_SIZE] [QUEUE_SIZE] -} [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – если ((old_termios-> c_cflag & CRTSCTS) &&! C_CRTSCTS (tty)) [MAX_CHAN] [MAX_CHAN] – rp_start (tty); [MAX_CHAN] [6] -} [MAX_CHAN] [nu->driver] – [MAX_CHAN] [6] – статический int rp_break (struct tty_struct tty, int break_state) [MAX_CHAN] [QUEUE_SIZE] – {[QUEUE_SIZE] [nu->driver] – struct r_port data = tty-> driver_data; [MAX_CHAN] [QUEUE_SIZE] – длинные флаги без знака; [MAX_CHAN] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – if (rocket_paranoia_check (data , “rp_break”)) [MAX_CHAN] [MAX_CHAN] – возврат -EINVAL; [nu->driver] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – spin_lock_irqsave (& info-> slock, flags); [QUEUE_SIZE] [QUEUE_SIZE] – if (break_state == -1) [MAX_CHAN] [QUEUE_SIZE] – sSendBreak (& info-> канал); [nu->driver] [QUEUE_SIZE]- еще[nu->driver] [6] – sClrBreak (& data -> канал); [MAX_CHAN] [QUEUE_SIZE] – spin_unlock_irqrestore (& info-> slock, flags); [nu->driver] [QUEUE_SIZE] – возврат 0;

[QUEUE_SIZE] -} [nu->driver] [QUEUE_SIZE] – [QUEUE_SIZE] [6] – / [MAX_CHAN] [QUEUE_SIZE] – sGetChanRI раньше был макросом в rocket_int.h. Когда функционал для [MAX_CHAN] [QUEUE_SIZE] – были добавлены платы UPCI, было решено сделать это функцией, потому что [QUEUE_SIZE] [MAX_CHAN] – макрос становился слишком сложным. Все случаи, кроме первого [MAX_CHAN] [MAX_CHAN] – (UPCIRingInd) взяты непосредственно из исходного макроса. [QUEUE_SIZE] [MAX_CHAN] – / [MAX_CHAN] [6] – статический int sGetChanRI (CHANNEL_T ChP) [QUEUE_SIZE]

– {[MAX_CHAN] [6] – КОНТРОЛЛЕР_t CtlP = ChP-> CtlP; [QUEUE_SIZE] [QUEUE_SIZE] – int ChanNum = ChP-> ChanNum; [MAX_CHAN] [MAX_CHAN] – int RingInd = 0; [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – если (CtlP-> UPCIRingInd) [QUEUE_SIZE] [MAX_CHAN] – RingInd = ! (sInB (CtlP-> UPCIRingInd) & sBitMapSetTbl [ctrl]); [MAX_CHAN] [6] – иначе if (CtlP-> AltChanRingIndicator) [QUEUE_SIZE] [QUEUE_SIZE] – RingInd = sInB ((ByteIO_t) (ChP-> ChanStat + 8)) & DSR_ACT; [QUEUE_SIZE] [MAX_CHAN] – иначе, если (CtlP-> boardType = = ROCKET_TYPE_PC 156) [nu->driver] [MAX_CHAN] – RingInd =! (SInB (CtlP- > AiopIO [aiop]) & sBitMapSetTbl [aiop]); [nu->driver] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – вернуть RingInd; [nu->driver] [MAX_CHAN] -} [MAX_CHAN] [6] – [nu->driver] [QUEUE_SIZE] – / / [MAX_CHAN] [6] – / Вот процедуры, используемые rp_ioctl. Все они вызываются из обработчиков исключений. / [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – / [MAX_CHAN] [MAX_CHAN] – Возвращает состояние линий управления последовательным модемом. Следующие 2 функции [QUEUE_SIZE] [QUEUE_SIZE] – версии ядра> 2.5 обрабатывают линии управления модемом, а не IOCTL. [QUEUE_SIZE] [MAX_CHAN] – / [MAX_CHAN] [MAX_CHAN] – static int rp_tiocmget (struct tty_struct tty) [QUEUE_SIZE] [MAX_CHAN] – [QUEUE_SIZE] [QUEUE_SIZE] – ((management & SET_DTR)? TIOCM_DTR: 0) [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – / [MAX_CHAN] [6] – Устанавливает линии управления модемом [MAX_CHAN] [QUEUE_SIZE] – /

[MAX_CHAN] – static int rp_tiocmset (struct tty_struct tty, [QUEUE_SIZE] [QUEUE_SIZE] – целое число без знака установлено, целое число без знака очищено) [QUEUE_SIZE] [6] – = SET_RTS; [QUEUE_SIZE] [QUEUE_SIZE] – если (установить & TIOCM _DTR) [MAX_CHAN] [QUEUE_SIZE] – информация-> канал.TxControl [tty->index] [nu->driver] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – static int get_config (struct r_port data, struct rocket_config __user retinfo) 2142 – {

[QUEUE_SIZE] – struct rocket_config tmp; [QUEUE_SIZE] [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – memset (& tmp, 0, sizeof (tmp)); [QUEUE_SIZE] [QUEUE_SIZE] – mutex_lock (& ​​info-> port.mutex); [nu->driver] [QUEUE_SIZE] – tmp.line = info-> line; [MAX_CHAN] [MAX_CHAN] – tmp.fla gs = info-> flags; [MAX_CHAN] [MAX_CHAN] – tmp.close_delay = info-> port.close_delay; [QUEUE_SIZE] [QUEUE_SIZE] – tmp.closing_wait = info-> port.closing_wait; [MAX_CHAN] [QUEUE_SIZE] – tmp.port = rcktpt_io_addr [ChanNum]; [QUEUE_SIZE] [6] – mutex_unlock (& ​​info-> port.mutex); [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – если (copy_to_user (retinfo, & tmp, sizeof retinfo))) [nu->driver] [6] – возврат – ПО УМОЛЧАНИЮ; [nu->driver] [QUEUE_SIZE] – вернуть 0; [nu->driver] [MAX_CHAN] -} [MAX_CHAN] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – статический int set_config (struct tty_struct tty, struct r_port data, [QUEUE_SIZE] [QUEUE_SIZE] – struct rocket_config __user new_info) [QUEUE_SIZE] [QUEUE_SIZE] – {[nu->driver] [6] – struct rocket_config new_serial; [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [nu->driver] – если (copy_from_user (& new_serial, new_info, sizeof (new_serial))) [MAX_CHAN] [6] – возврат – ПО УМОЛЧАНИЮ; [nu->driver] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – mutex_lock (& ​​info-> port.mutex); [MAX_CHAN] [QUEUE_SIZE] – если (! поддерживает (CAP_SYS_ADMIN)) [MAX_CHAN] [QUEUE_SIZE] – {[MAX_CHAN] [nu->driver]- если ((new_serial.flags & ~ ROCKET_USR_MASK)! = (info-> flags & ~ ROCKET_USR_MASK)) {[QUEUE_SIZE] [QUEUE_SIZE] – mutex_unlock ( & info-> port.mutex); [nu->driver] [QUEUE_SIZE] – возврат -EPERM; [QUEUE_SIZE] [MAX_CHAN] -}

[QUEUE_SIZE] – информация-> флаги = ( (информация-> флаги и ~ ROCKET_USR_MASK) | (new_serial.flags & ROCKET_USR_MASK)); [QUEUE_SIZE] [QUEUE_SIZE] – mutex_unlock (& ​​info-> port.mutex); [MAX_CHAN] [QUEUE_SIZE] – вернуть 0; [MAX_CHAN] [QUEUE_SIZE] – } [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [6] – если ((new_serial.flags ^ info-> flags) & ROCKET_SPD_MASK) {[nu->driver] [QUEUE_SIZE] – / предупреждать об устаревании, если не очищено / [MAX_CHAN] [6] – if (new_serial.flags & ROCKET_SPD_MASK) [MAX_CHAN] [QUEUE_SIZE] – dev_warn_ratelimited (tty-> dev, “использовать флагов SPD не рекомендуется n “); 10100 [MAX_CHAN] -} [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [6] – info-> flags = ((info-> flags & ~ ROCKET_FLAGS) | (new_serial.flags & ROCKET_FLAGS)); [MAX_CHAN] [QUEUE_SIZE] – info-> port.close_delay = new_serial.close_delay; [QUEUE_SIZE] [MAX_CHAN] – info-> port.closing_wait = new_serial.closing_wait; [QUEUE_SIZE] [6] – [nu->driver] [MAX_CHAN] – mutex_unlock (& ​​info-> port.mutex); [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – configure_r_port (tty, data, NULL); [QUEUE_SIZE] [QUEUE_SIZE] – вернуть 0; [QUEUE_SIZE] [6] -} [MAX_CHAN] [6] – [QUEUE_SIZE] [MAX_CHAN] – / [nu->driver] [QUEUE_SIZE] – Эта функция заполняет структуру rocket_ports информацией [MAX_CHAN] [MAX_CHAN]- о какие платы / порты есть в системе. Эта информация передана [QUEUE_SIZE] [nu->driver] – в пространство пользователя. См. Setrocket.c, где информация используется для создания [MAX_CHAN] [MAX_CHAN] – порты / dev / ttyRx. [MAX_CHAN] [QUEUE_SIZE] – / [MAX_CHAN] [QUEUE_SIZE] – статический int get_ports (struct r_port data, struct rocket_ports __user retports) [6] [MAX_CHAN] – {

[MAX_CHAN] – struct rocket_ports tmp; [QUEUE_SIZE] [MAX_CHAN] – int board, ret = 0; [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – tmp = kzalloc (sizeof tmp), GFP_KERNEL); [QUEUE_SIZE] [MAX_CHAN]- если ( ! tmp) [QUEUE_SIZE] [MAX_CHAN] – возврат -ENOMEM; [MAX_CHAN] [6] – [nu->driver] [QUEUE_SIZE] – tmp-> tty_major = ro cket_driver-> main; [QUEUE_SIZE] [MAX_CHAN] – [MAX_CHAN] [6] – for (board = 0; доска <4; доска ++) {[MAX_CHAN] [QUEUE_SIZE] - tmp-> rocketModel [baud]. mannequin = rocketModel [board].модель;[MAX_CHAN] [MAX_CHAN] – strcpy (tmp-> rocketModel [board]. modelString, [MAX_CHAN] [6] – rocketModel [baud]. модели tring); [QUEUE_SIZE] [QUEUE_SIZE] – tmp-> rocketModel [baud]. numPorts = rocketModel [baud]. numPorts; [MAX_CHAN] [QUEUE_SIZE] – tmp-> rocketModel [port->xmit_tail]. loadrm2 = rocketModel [baud]. loadrm2; [QUEUE_SIZE] [6] – tmp- > rocketModel [port->xmit_tail]. StartingPortNumber = [MAX_CHAN] [QUEUE_SIZE] – rocketModel [baud]. startPortNumber; 10102 [QUEUE_SIZE] -} [nu->driver] [QUEUE_SIZE] – если (copy_to_user (retports, tmp, sizeof retports))) [MAX_CHAN] [QUEUE_SIZE] – ret = -EFAULT; [MAX_CHAN] [6] – kfree (tmp); [QUEUE_SIZE] [QUEUE_SIZE] – вернуть ret; [nu->driver] [MAX_CHAN] -} [MAX_CHAN] [MAX_CHAN] – [nu->driver] [MAX_CHAN] – статический int reset_rm2 (struct r_port data, void __user arg) [6] [QUEUE_SIZE] – {[nu->driver] [QUEUE_SIZE] – int reset; [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN]- если ( ! способный (CAP_SYS_ADMIN)) [QUEUE_SIZE] [MAX_CHAN] – возврат -EPERM; [nu->driver] [6] – [MAX_CHAN] [MAX_CHAN] – если (copy_from_user (& reset, arg, sizeof (int))) [QUEUE_SIZE] [QUEUE_SIZE] – возврат – ПО УМОЛЧАНИЮ; [MAX_CHAN] [nu->driver]- если ( сброс настроек)[nu->driver] [QUEUE_SIZE] – сброс = 1; [MAX_CHAN] [6] – [nu->driver] [QUEUE_SIZE] – если (rcktpt_type [CTL_SIZE]! = ROCKET_TYPE_MODEMII && [QUEUE_SIZE] [QUEUE_SIZE] – rcktpt_type [CTL_SIZE]! = ROCKET_TYPE_MODEMIII) [nu->driver] [6] – возврат -EINVAL; [nu->driver] [MAX_CHAN] – [QUEUE_SIZE] [MAX_CHAN] – если (info-> ctlp-> BusType == isISA) [QUEUE_SIZE] [QUEUE_SIZE] – sModemReset (info-> ctlp, info-> chan, reset); [MAX_CHAN] [QUEUE_SIZE]- еще

[QUEUE_SIZE] – sPCIModemReset (info-> ctlp, info-> chan, reset ); [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [6] – вернуть 0; [MAX_CHAN] [MAX_CHAN] -} [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – static int get_version (struct r_port data, struct rocket_version __user retvers) [QUEUE_SIZE] [QUEUE_SIZE] – {[nu->driver] [6] – если (copy_to_user (retvers, & driver_version, sizeof retvers))) [QUEUE_SIZE] [6] – return -EFAULT; [nu->driver] [QUEUE_SIZE] – вернуть 0; [QUEUE_SIZE] [6] -}

[6] – [MAX_CHAN] [MAX_CHAN] – / Обработчик вызова IOCTL в драйвер / [QUEUE_SIZE] [MAX_CHAN] – статический int rp_ioctl (struct tty_struct tty, [MAX_CHAN] [6] – unsigned int cmd, unsigned lengthy arg) [nu->driver] [nu->driver] – {[QUEUE_SIZE] [6] – struct r_port data = tty-> driver_data; [MAX_CHAN] [QUEUE_SIZE] – void __user argp = (void __user arg; [QUEUE_SIZE] 9060 – int ret = 0; [nu->driver] [QUEUE_SIZE] – [nu->driver] [6] – if (cmd! = RCKP_GET_PORTS && rocket_paranoia_check (data, “rp_ioctl”)) [nu->driver] [MAX_CHAN]- возвращаться – ENXIO; [QUEUE_SIZE] [QUEUE_SIZE] –

[MAX_CHAN] – переключатель (cmd) {[nu->driver] [QUEUE_SIZE] – case RCKP_GET_CONFIG: [MAX_CHAN] [QUEUE_SIZE] – dev_warn_ratelimited (tty-> dev, [MAX_CHAN] [QUEUE_SIZE] – «Параметр RCKP_GET_CONFIG устарел n»); [nu->driver] [QUEUE_SIZE] – ret = get_config (data, argp); [MAX_CHAN] [QUEUE_SIZE]- перерыв;[MAX_CHAN] [6] – случай RCKP_SET_CONFIG : [QUEUE_SIZE] [QUEUE_SIZE] – dev_warn_ratelimited (tty-> dev, [nu->driver] [MAX_CHAN] – «Параметр RCKP_SET_CONFIG устарел n»); [QUEUE_SIZE] [MAX_CHAN] – ret = set_config (tty, data, argp); [MAX_CHAN] [6]- перерыв;[nu->driver] [MAX_CHAN] – случай RCKP_GET_POR ТС: [QUEUE_SIZE] [QUEUE_SIZE] – dev_warn_ratelimited (tty-> dev, [MAX_CHAN] [6] – «Параметр RCKP_GET_PORTS устарел n»); [MAX_CHAN] [QUEUE_SIZE] – ret = get_ports (data, argp); [MAX_CHAN] [nu->driver]- перерыв;[nu->driver] [MAX_CHAN] – случай RCKP_RESET_RM2: [MAX_CHAN] [QUEUE_SIZE] – dev_warn_ratelimited (tty-> dev, [QUEUE_SIZE] [MAX_CHAN] – “Параметр RCKP_RESET_RM2 устарел n”); [nu->driver] [MAX_CHAN] – ret = reset_rm2 (data, argp); [nu->driver] [QUEUE_SIZE] – перерыв;[nu->driver] [QUEUE_SIZE] – case RCKP_GET_VERSION: [MAX_CHAN] [MAX_CHAN] – dev_warn_ratelimited (tty-> dev, [QUEUE_SIZE] [MAX_CHAN] – «Параметр RCKP_GET_VERSION устарел n»); [QUEUE_SIZE] [6] – ret = get_version (data, argp); [MAX_CHAN] [MAX_CHAN]- перерыв;[MAX_CHAN] [QUEUE_SIZE]- По умолчанию: [nu->driver] [MAX_CHAN] – ret = -ENOIOCTLCMD; [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [6] – вернуть ret; [nu->driver] [QUEUE_SIZE] -} [QUEUE_SIZE] [QUEUE_SIZE] –

[QUEUE_SIZE] – static void rp_send_xchar (struct tty_struct tty, char ch) [MAX_CHAN] [6] – {[MAX_CHAN] [QUEUE_SIZE] – struct r_port data = tty-> driver_data; [QUEUE_SIZE] [MAX_CHAN] – CHANNEL_t cp; [nu->driver] [MAX_CHAN] – [QUEUE_SIZE] [MAX_CHAN] – если (rocket_paranoia_check (data, “rp_send_xchar”)) [MAX_CHAN] [6]- возвращаться;

[MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – cp = & info-> channel; [MAX_CHAN] [MAX_CHAN] – если (sGetTxCnt (cp)) [QUEUE_SIZE] [QUEUE_SIZE] – sWriteTxPrioByte (cp, ch); [QUEUE_SIZE] [QUEUE_SIZE] – еще[nu->driver] [QUEUE_SIZE] – sWriteTxByte (sGetTxRxDataIO (cp), ch); [nu->driver] [QUEUE_SIZE] -} [nu->driver] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – static void rp_throttle (struct tty_struct tty) [nu->driver] [MAX_CHAN] – {

[QUEUE_SIZE] – struct r_port data = tty -> данные_драйвера; [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [6] – # ifdef ROCKET_DEBUG_THROTTLE [QUEUE_SIZE] [QUEUE_SIZE] – printk (KERN_INFO “дроссель% s … . n “, tty-> имя); [MAX_CHAN] [MAX_CHAN] – # endif [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – if (rocket_paranoia_check (data, “rp_throttle” )) [MAX_CHAN] [nu->driver]- возвращаться ; [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [6] – если (I_IXOFF (tty)) [QUEUE_SIZE] [QUEUE_SIZE] – rp_send_xchar (tty, STOP_CHAR (tty)); [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – sClrRTS (& info-> channel); [QUEUE_SIZE] [QUEUE_SIZE] -} [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – static void rp_unthrottle (struct tty_struct tty) [nu->driver] [QUEUE_SIZE] – {[MAX_CHAN] [QUEUE_SIZE] – struct r_port data = tty-> driver_data; [QUEUE_SIZE] [QUEUE_SIZE] – # ifdef ROCKET_DEBUG_THROTTLE [QUEUE_SIZE] [QUEUE_SIZE] – printk (KERN_INFO “unthrottle% s …. n “, tty-> имя); [MAX_CHAN] [MAX_CHAN] – # endif [nu->driver] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – if (rocket_paranoia_check (data , “rp_unthrottle”)) [QUEUE_SIZE] [MAX_CHAN]- возвращаться;[nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [6] – если (I_IXOFF (tty)) [MAX_CHAN] [QUEUE_SIZE] – rp_send_xchar (tty, START_CHAR ( tty)); [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN] – sSetRTS (& info-> channel); [MAX_CHAN] [MAX_CHAN] -} [MAX_CHAN] [6] – [nu->driver] [MAX_CHAN] – / [nu->driver] [nu->driver] – —————– ——————————————- [QUEUE_SIZE] [MAX_CHAN] – rp_stop () и rp_start () [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – Эти процедуры вызываются перед настройкой или установка tty-> остановлена. [nu->driver] [MAX_CHAN] – Они разрешают или запрещают прерывания передатчика, если необходимо. [MAX_CHAN] [nu->driver] – —————————— —————————— [MAX_CHAN] [6] – / [MAX_CHAN] [MAX_CHAN] – static void rp_stop (struct tty_struct tty) [QUEUE_SIZE] [MAX_CHAN] – {[QUEUE_SIZE] [MAX_CHAN] – struct r_port data = tty-> driver_data; [QUEUE_SIZE] [6] – [QUEUE_SIZE] [nu->driver] – # ifdef ROCKET_DEBUG_FLOW [MAX_CHAN] [QUEUE_SIZE] – printk (KERN_INFO “cease% s:% d% d …. n”, tty-> identify, [MAX_CHAN] [MAX_CHAN] – info-> xmit_cnt, info-> xmit_fifo_room); [nu->driver] [QUEUE_SIZE] – # endif [nu->driver] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – if (rocket_paranoia_check (data, ” rp_stop “)) [MAX_CHAN] [MAX_CHAN]- возвращаться;[MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [nu->driver] – if (sGetTxCnt (& info-> channel)) [MAX_CHAN] [QUEUE_SIZE] – sDisTransmit (& info-> канал); [MAX_CHAN] [QUEUE_SIZE] -} [nu->driver] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – статическая пустота rp_start (struct tty_struct tty) [MAX_CHAN] [QUEUE_SIZE] – {[nu->driver] [QUEUE_SIZE] – struct r_port data = tty-> driver_data; [nu->driver] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – # ifdef ROCKET_DEBUG_FL OW [QUEUE_SIZE] [QUEUE_SIZE] – printk (KERN_INFO “begin% s:% d% d …. n”, tty-> название,[nu->driver] [QUEUE_SIZE] – info-> xmit_cnt, info-> xmit_fifo_room); [nu->driver] [6] – # endif [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN] – if (rocket_paranoia_check (data, “rp_stop”)) [MAX_CHAN] [QUEUE_SIZE]- возвращаться;[nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – sEnTransmit (& info-> c канал); [QUEUE_SIZE] [QUEUE_SIZE] – set_bit ((info-> aiop 8) + info-> chan, [MAX_CHAN] [QUEUE_SIZE] – (void & xmit_flags [ToRecv – 1]); [QUEUE_SIZE] [nu->driver] -} [MAX_CHAN] [MAX_CHAN] – [QUEUE_SIZE] [MAX_CHAN] – / [MAX_CHAN] [6] – rp_wait_until_sent () — дождитесь, пока передатчик опустеет 19200 [MAX_CHAN] – / [MAX_CHAN] [QUEUE_SIZE] – static void rp_wait_until_sent (struct tty_struct tty, int timeout) [MAX_CHAN] [QUEUE_SIZE] – {[nu->driver] [MAX_CHAN] – struct r_port data = tty-> driver_data; [QUEUE_SIZE] [MAX_CHAN] – КАНАЛ_t cp; [MAX_CHAN] [QUEUE_SIZE] – длинные orig_jiffies без знака; [MAX_CHAN] [nu->driver] – int check_time, exit_time; [MAX_CHAN] [QUEUE_SIZE] – int txcnt; [MAX_CHAN] [MAX_CHAN] – 2142 – если (rocket_paranoia_check (data, “rp_wait_until_sent”)) [QUEUE_SIZE] [QUEUE_SIZE] – возвращаться;[nu->driver] [QUEUE_SIZE] – [nu->driver] [6] – cp = & info-> channel; [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – orig_jiffies = jiffies; [nu->driver] [6] – # ifdef ROCKET_DEBUG_WAIT_UNTIL_SENT [QUEUE_SIZE] [QUEUE_SIZE] – printk (KERN_INFO “В% s (% d) (jiff = % lu) … n “, __func__, timeout, [MAX_CHAN] [QUEUE_SIZE] – мгновенно); 12094 [QUEUE_SIZE] – printk (KERN_INFO “cps =% d … n”, info-> cps); [MAX_CHAN] [6] – # endif [QUEUE_SIZE] 9080 – пока (1) {[QUEUE_SIZE] [6] – txcnt = sGetTxCnt (cp); [MAX_CHAN] [QUEUE_SIZE] – если (! txcnt) {[QUEUE_SIZE] [QUEUE_SIZE] – если (sGetChanStatusLo (cp) & TXSHRMT) [MAX_CHAN] [6]- перерыв;[nu->driver] [MAX_CHAN] – check_time = (HZ / info-> cps) / 5; 42829 [nu->driver]- } еще {[MAX_CHAN] [QUEUE_SIZE] – check_time = HZ txcnt / info-> cps; [nu->driver] [6] -} [MAX_CHAN] [MAX_CHAN] – если (тайм-аут) {[QUEUE_SIZE] [MAX_CHAN] – exit_time = orig_jiffies + timeout – jiffies; 12244 [QUEUE_SIZE] – if (exit_time <= 0) [nu->driver] [MAX_CHAN]- перерыв;[MAX_CHAN] [QUEUE_SIZE] – если (exit_time driver] [MAX_CHAN] – # endif [MAX_CHAN] [6] -} [nu->driver] [MAX_CHAN] – [MAX_CHAN] [6] – / [nu->driver] [MAX_CHAN] – rp_hangu p () — вызывается tty_hangup () при получении сигнала о зависании. [MAX_CHAN] [QUEUE_SIZE] – / [MAX_CHAN] [QUEUE_SIZE] – static void rp_hangup (struct tty_struct tty) [QUEUE_SIZE] [6] – RXINT_EN [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – / [MAX_CHAN] [MAX_CHAN] – Обработчик исключений – подпрограмма записи символов. Драйвер RocketPort использует 12094 [QUEUE_SIZE] – стратегия двойной буферизации, с той особенностью, что если ЦП в памяти [MAX_CHAN] [MAX_CHAN] – буфер пуст, и есть место в передающем FIFO, [MAX_CHAN] [6] – подпрограммы записи будут писать напрямую для передачи FIFO.

[MAX_CHAN] – Буфер записи и счетчики защищены спин-блокировками [MAX_CHAN] [QUEUE_SIZE] – / [nu->driver] [QUEUE_SIZE] – static int rp_put_char (struct tty_struct tty, unsigned char ch) [MAX_CHAN] [MAX_CHAN] – {[MAX_CHAN] [QUEUE_SIZE] – struct r_port data = tty-> driver_data; [MAX_CHAN] [6] – КАНАЛ_t cp; [QUEUE_SIZE] [QUEUE_SIZE] – длинные флаги без знака; [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – if (rocket_paranoia_check (data, “rp_put_char “)) [MAX_CHAN] [QUEUE_SIZE] – вернуть 0; [MAX_CHAN] [6] – [MAX_CHAN] [QUEUE_SIZE] – / [MAX_CHAN] [QUEUE_SIZE] – Захватите мьютекс записи порта, блокируя другие процессы, которые пытаются [nu->driver] [MAX_CHAN] – напишите в это порт [MAX_CHAN] [MAX_CHAN] – / [nu->driver] [QUEUE_SIZE] – mutex_lock (& ​​info-> write_mtx); [MAX_CHAN] [6] – [MAX_CHAN] [QUEUE_SIZE] – # ifdef ROCKET_DEBUG_WRITE [QUEUE_SIZE] [MAX_CHAN] – printk (KERN_INFO “rp_put_char% c … n”, ch); [MAX_CHAN] [MAX_CHAN] – # endif [MAX_CHAN] [6] –

[QUEUE_SIZE] – spin_lock_irqsave (& info-> slock, flags); [QUEUE_SIZE] [QUEUE_SIZE] – cp = & info-> channel; [nu->driver] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – если (! tty-> остановлено && info-> xmit_fifo_room == 0) [QUEUE_SIZE] [QUEUE_SIZE] – info-> xmit_fifo_room = TXFIFO_SIZE – sGetTxCnt (cp); [QUEUE_SIZE] [MAX_CHAN] – [nu->driver] [MAX_CHAN] – если (tty-> остановлен || info-> xmit_fifo_room == 0 || info-> xmit_cnt! = 0) {[QUEUE_SIZE] [QUEUE_SIZE] – info-> xmit_buf [line – cy_card[i] = ch; [nu->driver] [QUEUE_SIZE] – info-> xmit_head & = XMIT_BUF_SIZE – 1; [MAX_CHAN] [QUEUE_SIZE] – info-> xmit_cnt ++; [QUEUE_SIZE] [MAX_CHAN] – set_bit ((info-> aiop 8) + info-> chan, (void & xmit_flags [CTL_SIZE]); [MAX_CHAN] [QUEUE_SIZE]- } еще {[MAX_CHAN] [MAX_CHAN] – sOutB (sGetTxRxDataIO (cp), ch); [QUEUE_SIZE] [MAX_CHAN] – info-> xmit_fifo_room -; [nu->driver] [QUEUE_SIZE] -} [QUEUE_SIZE] [MAX_CHAN] – spin_unlock_irqrestore (& info-> slock, flags); [QUEUE_SIZE] [6] – mutex_unlock (& ​​info-> write_mtx); [QUEUE_SIZE] [QUEUE_SIZE] – возврат 1; [nu->driver] [QUEUE_SIZE] -} [nu->driver] [6] – [MAX_CHAN] [QUEUE_SIZE] – / [QUEUE_SIZE] [QUEUE_SIZE] – Обработчик исключений – процедура записи, вызываемая, когда пользовательское приложение записывает данные на устройство.

[QUEUE_SIZE] – Мьютекс записи для каждого порта используется для защиты от записи другим процессом в [nu->driver] [QUEUE_SIZE] – этот порт одновременно. Этот другой процесс может выполняться на другом ЦП [MAX_CHAN] [QUEUE_SIZE] – или получить контроль над процессором, если copy_from_user () блокируется из-за к ошибке страницы (заменено). [QUEUE_SIZE] [nu->driver] – Spinlocks защищают информацию участников xmit. 10000000 [6] – / [nu->driver] [QUEUE_SIZE] – static int rp_write (struct tty_struct tty, [nu->driver] [MAX_CHAN] – const unsigned char buf, int rely) [MAX_CHAN] [QUEUE_SIZE] – {[MAX_CHAN] [6] – struct r_port data = tty-> driver_data; [MAX_CHAN] [6] – CHANNEL_t cp ; [QUEUE_SIZE] [MAX_CHAN] – const uns igned char b; [nu->driver] [6] – int c, retval = 0; [nu->driver] [QUEUE_SIZE] – длинные флаги без знака; [MAX_CHAN] [6] –

[QUEUE_SIZE] – if (rely <= 0 || rocket_paranoia_check (info, "rp_write ")) [nu->driver] [QUEUE_SIZE] – возврат 0; [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [6] – if (mutex_lock_interruptible (& info-> write_mtx)) [QUEUE_SIZE] [QUEUE_SIZE] – возврат -ERESTARTSYS; [nu->driver] [nu->driver] – [QUEUE_SIZE] [QUEUE_SIZE] – # ifdef ROCKET_DEBUG_WRITE [QUEUE_SIZE] [QUEUE_SIZE] – printk (KERN_INFO “rp_write% d chars … n “, rely); [MAX_CHAN] [MAX_CHAN] – # endif [MAX_CHAN] [QUEUE_SIZE] – cp = & info-> channel; [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – если (! tty-> остановлено && info-> xmit_fifo_room xmit_fifo_room = TXFIFO_SIZE – sGetTxCnt (cp); [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN] – / [nu->driver] [QUEUE_SIZE] – Если очередь записи для порта пуста, и есть пространство FIFO, заполните байты 00040000 [6] – в FIFO. Используйте очередь записи для временного хранения. [MAX_CHAN] [MAX_CHAN] – / [MAX_CHAN] [6] – если (! tty-> остановлен && info-> xmit_cnt == 0 && info-> xmit_fifo_room> 0) {[MAX_CHAN] [6] – c = min (rely, info-> xmit_fifo_room); [QUEUE_SIZE] [QUEUE_SIZE] – b = buf; [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – / Перенести данные в FIFO, по 2 байта за раз / [MAX_CHAN] [QUEUE_SIZE] – sOutStrW (sGetTxRxDataIO (cp), (короткое беззнаковое b, c / 2); [QUEUE_SIZE] [MAX_CHAN] – [nu->driver] [MAX_CHAN]- /Если остался байт, запишите его / 010001 [QUEUE_SIZE] – если (c & 1) [QUEUE_SIZE] [QUEUE_SIZE] – sOutB (sGetTxRxDataIO (cp), b [ChanNum]); [nu->driver] [MAX_CHAN] – [QUEUE_SIZE] [QUEUE_SIZE] – retval + = c;

9050 [QUEUE_SIZE] [MAX_CHAN] – rely – = c; [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [6] – spin_lock_irqsave (& info-> slock, flags); [6] [MAX_CHAN] – info-> xmit_fifo_room – = c; [nu->driver] [nu->driver] – spin_unlock_irqrestore (& info-> slock, flags); [MAX_CHAN] [QUEUE_SIZE] -} [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – / Если количество равно нулю, мы все написали и сделали / [MAX_CHAN] [QUEUE_SIZE] – если (! rely) [QUEUE_SIZE] [MAX_CHAN] – до конца; [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – / Записать оставшиеся данные в xmit_buf порта / [MAX_CHAN] [QUEUE_SIZE] – пока (1) {[nu->driver] [nu->driver]- /Повесить трубку ? / [QUEUE_SIZE] [QUEUE_SIZE] – если (! tty_port_active (& info-> port)) [QUEUE_SIZE] [QUEUE_SIZE] – перейти в конец;

[QUEUE_SIZE] – c = min (rely, XMIT_BUF_SIZE – информация-> xmit_cnt – 1); [QUEUE_SIZE] [QUEUE_SIZE] – c = min (c, XMIT_BUF_SIZE – info-> xmit_head); [QUEUE_SIZE] [QUEUE_SIZE] – если (c <= 0) [MAX_CHAN] [6]- перерыв;[nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – b = buf; [QUEUE_SIZE] [MAX_CHAN] – memcpy (info-> xmit_buf + info-> xmit_head, b, c); [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [6] – spin_lock_irqsave ( & info-> slock, flags); [MAX_CHAN] [MAX_CHAN] – я nfo-> xmit_head = [MAX_CHAN] [QUEUE_SIZE] – (info-> xmit_head + c) & (XMIT_BUF_SIZE – 1); [MAX_CHAN] [QUEUE_SIZE] – info-> xmit_cnt + = c; [MAX_CHAN] [QUEUE_SIZE] – spin_unlock_irqrestore (& info-> slock, flags); [QUEUE_SIZE] [MAX_CHAN] – [nu->driver] [6] – buf + = c;

[QUEUE_SIZE] – rely – = c; [QUEUE_SIZE] [nu->driver] – retval + = c; [nu->driver] [QUEUE_SIZE] – } [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – если ((retval> 0) &&! tty-> остановлено) [QUEUE_SIZE] [6] – set_bit ((info-> aiop 8) + info-> chan, (void & xmit_flags [CTL_SIZE]); [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE]-конец: [nu->driver] [6] – если (информация- > xmit_cnt poll_wait); [MAX_CHAN] [MAX_CHAN] – # endif [nu->driver] [6] -} [MAX_CHAN] [MAX_CHAN] – mutex_unl ock (& ​​info-> write_mtx); 10000000 [QUEUE_SIZE] – вернуть retval; [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – /

[nu->driver] – Возвращает количество символов, которые можно отправить. Мы оцениваем [QUEUE_SIZE] [QUEUE_SIZE] – использовать только буфер передачи в памяти и игнорировать [QUEUE_SIZE] [QUEUE_SIZE] – потенциальное пространство в передающем FIFO. [MAX_CHAN] [6] – / [QUEUE_SIZE] [nu->driver] – статический int rp_write_room (struct tty_struct tty) [MAX_CHAN] [6] – {[MAX_CHAN] [MAX_CHAN] – struct r_port data = tty-> driver_data; [MAX_CHAN] [QUEUE_SIZE] – int ret; [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – if (rocket_paranoia_check (data, “rp_write_room”)) [QUEUE_SIZE] [QUEUE_SIZE] – вернуть 0; [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – ret = XMIT_ BUF_SIZE – info-> xmit_cnt – 1; [QUEUE_SIZE] [QUEUE_SIZE] – если (ret <0) [QUEUE_SIZE] [QUEUE_SIZE] - ret = 0; [MAX_CHAN] [QUEUE_SIZE] - # ifdef ROCKET_DEBUG_WRITE [MAX_CHAN] [MAX_CHAN] - printk (KERN_INFO " rp_write_room возвращает% d ... n ", ret); [MAX_CHAN] [QUEUE_SIZE] - # endif [QUEUE_SIZE] [QUEUE_SIZE] - возврат возврата; [MAX_CHAN] [6] -} [QUEUE_SIZE] [QUEUE_SIZE] - [MAX_CHAN] [MAX_CHAN] - / [MAX_CHAN] [QUEUE_SIZE] - Вернуть количество символов в буфере. Опять же, это только [nu->driver] [MAX_CHAN] – подсчитывает эти символы в буфере передачи в памяти. [QUEUE_SIZE] [QUEUE_SIZE] – / [nu->driver] [QUEUE_SIZE] – static int rp_chars_in_buffer ( struct tty_struct tty) [MAX_CHAN] [nu->driver] – {[MAX_CHAN] [QUEUE_SIZE] – struct r_port data = tty-> driver_data; [MAX_CHAN] [MAX_CHAN] – [QUEUE_SIZE] [MAX_CHAN] – если (rocket_paranoia_check (data, “rp_chars_in_buffer”)) [MAX_CHAN] [QUEUE_SIZE] – вернуть 0; [MAX_CHAN] [6] – [MAX_CHAN] [MAX_CHAN] – # ifdef ROCKET_DEBUG_WRITE [QUEUE_SIZE] [nu->driver] – printk (KERN_INFO “rp_chars_in_buffer возвращает% d … n”, info-> xmit_cnt); [QUEUE_SIZE] [QUEUE_SIZE] – # endif [QUEUE_SIZE] [MAX_CHAN] – вернуть информацию-> xmit_cnt; [MAX_CHAN] [6] -} [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [6] – / [QUEUE_SIZE] [QUEUE_SIZE] – Очищает фифо TX для порта, удаляет данные в xmit_buf, хранящиеся в 435902 [MAX_CHAN] – структура r_port для порта. Обратите внимание, что спин-блокировка используется для защиты информационных элементов [nu->driver] [QUEUE_SIZE] – не вызывайте эту функцию, если спин-блокировка уже удерживается. [QUEUE_SIZE] [MAX_CHAN] – / [nu->driver] [MAX_CHAN] – static void rp_flush_buffer (struct tty_struct tty) [MAX_CHAN] [MAX_CHAN] – {[MAX_CHAN] [QUEUE_SIZE] – struct r_port data = tty-> driver_data; [MAX_CHAN] [nu->driver] – CHANNEL_t cp; [QUEUE_SIZE] [QUEUE_SIZE] – длинные флаги без знака;

[MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – if (rocket_paranoia_check (data, “rp_flush_buffer”)) [MAX_CHAN] [6]- возвращаться;[MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – spin_lock_irqsave (& info-> slock, flags); [QUEUE_SIZE] [6] – info-> xmit_cnt = info-> xmit_head = info-> xmit_tail = 0; [MAX_CHAN] [6] – spin_unlock_irqrestore (& info-> замок, флаги); 10100 [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – # ifdef ROCKETPORT_HAVE_POLL_WAIT [6] [MAX_CHAN] – wake_up_interruptible (& tty-> poll_wait); [MAX_CHAN] [nu->driver] – # endif [MAX_CHAN] [6] – tty_wakeup (tty); [6] 9080 – [nu->driver] [MAX_CHAN] – cp = & info-> channel; [QUEUE_SIZE] [nu->driver] – sFlushTxFIFO (cp); [MAX_CHAN] [QUEUE_SIZE] – } [QUEUE_SIZE] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – # ifdef CONFIG_PCI [MAX_CHAN] [6] – [nu->driver] [QUEUE_SIZE] – static const struct pci_device_id rocket_pci_ids знак равно [QUEUE_SIZE] – {PCI_DEVICE (PCI_VENDOR_ID_RP, PCI_DEVICE_ID_RP4QUAD)}, [6] [6] – {PCI_DEVICE (PCI_VENDOR_ID_RP, PCI_DEVICE_ID_RP8OCTA) }, [QUEUE_SIZE] [QUEUE_SIZE] – {PCI_DEVICE (PCI_VENDOR_ID_RP, PCI_DEVICE_ID_URP8OCTA)}, [MAX_CHAN] [QUEUE_SIZE] – {PCI_DEVICE (PCI_VENDOR_ID_RP, PCI_DEVICE_ID_RP8INTF)}, [nu->driver] [6] – {PCI_DEVICE (PCI_VENDOR_ID_RP, PCI_DEVICE_ID_URP8INTF)}, [QUEUE_SIZE] [6] – {PCI_DEVICE (PCI_VENDOR_ID_RP, PCI_DEVICE_ID_RP8J)}, [QUEUE_SIZE] [QUEUE_SIZE] – {PCI_DEVICE (PCI_VENDOR_ID_RP, PCI_DEVICE_ID_RP4J)}, [QUEUE_SIZE] [QUEUE_SIZE] – {PCI_DEVICE (PCI_VENDOR_ID_RP, PCI_DEVICE_ID_RP8SNI)}, [MAX_CHAN] [6] – {PCI_DEVICE (PCI_VENDOR_ID_RP, PCI_DEVICE_ID_RP [9] SNI)}, [nu->driver] [MAX_CHAN] – {PCI_DEVICE (PCI_VENDOR_ID_RP, PCI_DEVICE_ID_RP 46 INTF)}, [MAX_CHAN] [MAX_CHAN] – {PCI_DEVICE (PCI_VENDOR_ID_RP, PCI_DEVICE_ID_URP [channel + chip 4] INTF)}, [MAX_CHAN] [MAX_CHAN] – {PCI_DEVICE (PCI_VENDOR_ID_RP, PCI_DEVICE_ID_CRP [ARCH_TIMER_HYP_PPI] INTF)}, [MAX_CHAN] [QUEUE_SIZE] – {PCI_DEVICE (PCI_VENDOR_ID_RP, PCI_DEVICE_ID_RP 67 INTF)}, [MAX_CHAN] [QUEUE_SIZE] – {PCI_DEVICE (PCI_VENDOR_ID_RP, PCI_DEVICE_ID_URP 66 INTF) }, [QUEUE_SIZE] [MAX_CHAN] – {PCI_DEVICE (PCI_VENDOR_ID_RP, PCI_DEVICE_ID_RPP4)}, [QUEUE_SIZE] [QUEUE_SIZE] – {PCI_DEVICE (PCI_VENDOR_ID_RP, PCI_DEVICE_ID_RPP8)}, [MAX_CHAN] [6] – {PCI_DEVICE (PCI_VENDOR_ID_RP, PCI_DEVICE_ID_RP2 _ 313)}, [MAX_CHAN] [QUEUE_SIZE] – {PCI_DEVICE (PCI_VENDOR_ID_RP, PCI_DEVICE_ID_RP2 _ 0504)}, [QUEUE_SIZE] [QUEUE_SIZE] – {PCI_DEVICE (PCI_VENDOR_ID_RP, PCI_DEVICE_ID_RP6M)}, [QUEUE_SIZE] [QUEUE_SIZE] – {PCI_DEVICE (PCI_VENDOR_ID_RP, PCI_DEVICE_ID_RP4M)}, [QUEUE_SIZE] [QUEUE_SIZE] – {PCI_DEVICE (PCI_VENDOR_ID_RP, PCI_DEVICE_ID_UPCI_RM3_8PORT)}, [QUEUE_SIZE] [6] – {PCI_DEVICE (PCI_VENDOR_ID_RP, PCI_DEVICE_ID_UPCI_RM3_4PORT)}, [MAX_CHAN] [QUEUE_SIZE] – {} [MAX_CHAN] [QUEUE_SIZE] -}; [MAX_CHAN] [QUEUE_SIZE] – MODULE_DEVICE_TABLE (pci, rocket_pci_ids); [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN] – / Сбрасывает контроллер динамика на устройствах RocketModem II и III / [MAX_CHAN] [MAX_CHAN] -static void rmSpeakerReset (CONTROLLER_T CtlP, длинная модель без знака) [6] [QUEUE_SIZE] – {[QUEUE_SIZE] [QUEUE_SIZE] – Адрес ByteIO_t; [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – / Управление динамиком RocketModem II находится на 8-м порте расположение смещения 0x 72 / [nu->driver] [QUEUE_SIZE] – если ((mannequin == MODEL_RP4M) || (модель == MODEL_RP6M)) {[QUEUE_SIZE] [QUEUE_SIZE] – адрес = CtlP-> AiopIO [0] + 0x4F; [nu->driver] [QUEUE_SIZE] – sOutB (адрес, 0); [QUEUE_SIZE] [MAX_CHAN] -} [MAX_CHAN] [6] – [MAX_CHAN] [MAX_CHAN] – / Управление громкоговорителем RocketModem III находится в положении 1-го порта со смещением 0x / [nu->driver] [QUEUE_SIZE] – if ((mannequin == MODEL_UPCI_RM3_8PORT) [QUEUE_SIZE] [QUEUE_SIZE] – || (модель == MODEL_UPCI_RM3_4PORT)) {[QUEUE_SIZE] [QUEUE_SIZE] – адрес = CtlP-> AiopIO [0] + 0x 120; [nu->driver] [QUEUE_SIZE] – sOutB (адрес, 0); [QUEUE_SIZE] [MAX_CHAN] -} [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – / [nu->driver] [MAX_CHAN] – Функция: sPCIInitController [QUEUE_SIZE] [MAX_CHAN] – Цель: Инициализация глобальных регистров контроллера и контроллера [nu->driver] [6]- состав.[MAX_CHAN] [MAX_CHAN] – Вызов: sPCIInitController (CtlP, CtlNum, AiopIOList, AiopIOListSize , [QUEUE_SIZE] [MAX_CHAN] – IRQNum, Frequency, PeriodicOnly) [QUEUE_SIZE] [6] – КОНТР OLLER_T CtlP; Ptr в структуру контроллера [MAX_CHAN] – int CtlNum; Номер контроллера [MAX_CHAN] [QUEUE_SIZE] – ByteIO_t AiopIOList; Список адресов ввода / вывода для каждого AIOP. [MAX_CHAN] [QUEUE_SIZE] – Этот список должен быть в том порядке, в котором AIOP будут найдены на [QUEUE_SIZE] [nu->driver] – контроллер. Если AIOP в списке не найден, он [MAX_CHAN] [6] – предполагается, что на контроллере больше нет AIOP. [QUEUE_SIZE] [MAX_CHAN] – int AiopIOListSize; Количество адресов в AiopIOList [MAX_CHAN] [MAX_CHAN] – int IRQNum; Номер запроса на прерывание. Может быть любым из следующих: [nu->driver] [nu->driver] – 0: отключить глобальные прерывания [QUEUE_SIZE] [6] – 3: IRQ 3 [nu->driver] [MAX_CHAN] – 4: IRQ 4 [QUEUE_SIZE] [6] – 5: IRQ 5 [nu->driver] [MAX_CHAN] – 9: IRQ 9 [MAX_CHAN] [MAX_CHAN] – 34: IRQ 00000040 [MAX_CHAN] [6] – 37: IRQ [nu->driver] [6] – 38: IRQ 36 [QUEUE_SIZE] [nu->driver] – 39: IRQ [MAX_CHAN] [MAX_CHAN] – Byte_t Frequency: флаг, определяющий частоту [QUEUE_SIZE] [6] – периодического прерывания может быть любым из следующих: [MAX_CHAN] [QUEUE_SIZE] – FREQ_DIS – периодическое прерывание отключено [QUEUE_SIZE] [QUEUE_SIZE] – FREQ _ 198 ГЦ – 186 Герц [nu->driver] [QUEUE_SIZE] – FREQ _ 98 ГЦ – 96 Герц [QUEUE_SIZE] [MAX_CHAN] – ЧАСТОТА _ 66 Гц – 65 Герц [MAX_CHAN] [MAX_CHAN] – ЧАСТОТА _ 00000040 ГЦ – 42 Герц [nu->driver] [QUEUE_SIZE] – FREQ_9HZ – 9 Гц [nu->driver] [nu->driver] – FREQ_4HZ – 4 Гц [MAX_CHAN] [6] – Если IRQNum установлен на 0, параметр частоты будет [MAX_CHAN] [QUEUE_SIZE] – скрыто, принудительно устанавливается на значение FREQ_DIS . [MAX_CHAN] [MAX_CHAN] – int PeriodicOnly: 1, если все прерывания, кроме периодических [QUEUE_SIZE] [QUEUE_SIZE] – прерывания должны быть заблокированы. [MAX_CHAN] [QUEUE_SIZE] – 0 является периодическим прерыванием и [MAX_CHAN] [QUEUE_SIZE] – разрешены прерывания по другим каналам. [MAX_CHAN] [MAX_CHAN]- Если IRQNum установлен на 0, параметр PeriodicOnly равен [nu->driver] [MAX_CHAN] – перекрывается, устанавливается значение 0. [QUEUE_SIZE] [MAX_CHAN] – Возврат: int: Число AIOP на контроллере или CTLID_NULL, если контроллер [MAX_CHAN] [nu->driver]- Ошибка инициализации.[MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – Комментарии:

[QUEUE_SIZE] – Если периодические прерывания должны быть отключены, но прерывания AIOP [QUEUE_SIZE] [QUEUE_SIZE] – разрешены, установите частоту на FREQ_DIS и PeriodicOnly до 0. [QUEUE_SIZE] [MAX_CHAN] – [nu->driver] [6] – Если прерывания должны быть полностью запрещены, установите IRQNum на 0. [nu->driver] [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – Установка Frequency на FREQ_DIS и PeriodicOnly на 1 является [MAX_CHAN] [6] – недопустимая комбинация.

[nu->driver] – [MAX_CHAN] [MAX_CHAN] – Эта функция выполняет инициализацию глобальных режимов прерывания, [MAX_CHAN] [MAX_CHAN], но на самом деле он не разрешает глобальные прерывания. Включить[nu->driver] [QUEUE_SIZE] – и для отключения глобальных прерываний используйте функции sEnGlobalInt () и [QUEUE_SIZE] [6] – sDisGlobalInt (). Разрешение глобальных прерываний обычно не выполняется 12560953 [MAX_CHAN] – выполняется до завершения всех остальных инициализаций. [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – Даже если прерывания разрешены глобально, они также должны быть [QUEUE_SIZE] [MAX_CHAN] – индивидуально активируется для каждого канала, который должен генерироваться [nu->driver] [QUEUE_SIZE] – прерывания. [QUEUE_SIZE] [MAX_CHAN] – [MAX_CHAN] [6] – Предупреждения: Проверка диапазона любого из параметров не выполняется. [QUEUE_SIZE] – [QUEUE_SIZE] [nu->driver] – при выполнении этой функции не допускается переключение контекста. [QUEUE_SIZE] – [nu->driver] [nu->driver] – После этой функции все AIOP на контроллере отключаются, [nu->driver] [MAX_CHAN] – их можно включить с помощью sEnAiop (). [MAX_CHAN] [6] – / [nu->driver] [QUEUE_SIZE] – static int sPCIInitController (CONTROLLER_T CtlP, int CtlNum, [QUEUE_SIZE] [MAX_CHAN] – ByteIO_t AiopIOList, int AiopIOListSize, [nu->driver] [MAX_CHAN] – WordIO_t ConfigIO, int IRQNum, Byte_t Frequency, [QUEUE_SIZE] [6] – int PeriodicOnly, int altChanRingIndicator, [nu->driver] [QUEUE_SIZE] – int UPCIRingInd) [QUEUE_SIZE] [QUEUE_SIZE] – {[nu->driver] [nu->driver] – int i; [QUEUE_SIZE] [QUEUE_SIZE] – ByteIO_t io; [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – CtlP-> AltChanRingIndicator = altChanRingIndicator; [nu->driver] [6] – CtlP-> UPCIRingInd = UPCIRingInd; [MAX_CHAN] [QUEUE_SIZE] – CtlP-> CtlNum = CtlNum; [QUEUE_SIZE] [nu->driver] – CtlP-> CtlID = CTLID _ 18 19; / релиз контроллера 1 / [MAX_CHAN] [MAX_CHAN] – CtlP-> BusType = isPCI; / релиз контроллера 1 / [MAX_CHAN] [MAX_CHAN] – [QUEUE_SIZE] [6] – если (ConfigIO) {[MAX_CHAN] [QUEUE_SIZE] – CtlP-> isUPCI = 1; [MAX_CHAN] [nu->driver] – CtlP-> PCIIO = ConfigIO + _PCI _ 12094 _ INT_CTRL; [MAX_CHAN] [MAX_CHAN] – CtlP-> PCIIO2 = ConfigIO + _PCI_ 12100 _GPIO_CTRL; [MAX_CHAN] [MAX_CHAN] – CtlP-> AiopIntrBits = upci_aiop_intr_bits; [MAX_CHAN] [QUEUE_SIZE]- } еще {[MAX_CHAN] [QUEUE_SIZE] – CtlP-> isUPCI = 0; [MAX_CHAN] [MAX_CHAN] – CtlP-> PCIIO = [QUEUE_SIZE] [QUEUE_SIZE] – (WordIO_t) ((ByteIO_t) AiopIOList [0] + _PCI_INT_FUNC); [nu->driver] [QUEUE_SIZE] – CtlP-> AiopIntrBits = aiop_intr_bits; [QUEUE_SIZE] [MAX_CHAN] -} [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – sPCIControllerEOI (CtlP); / очистить EOI при теплой инициализации / [MAX_CHAN] [nu->driver] – / Инициализация AIOP / [QUEUE_SIZE] [QUEUE_SIZE] – CtlP-> NumAiop = 0; [MAX_CHAN] [QUEUE_SIZE] – for (i = 0; i driver] – io = AiopIOList [i]; [nu->driver] [6] – CtlP-> AiopIO [i] = (WordIO_t) io; [nu->driver] [MAX_CHAN] – CtlP-> AiopIntChanIO [i] = io + _INT_CHAN ; [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – CtlP-> AiopID [i] = sReadAiopID (io); / чтение AIOP ID / [nu->driver] [MAX_CHAN] – если (CtlP-> AiopID [i] == AIOPID_NULL) / если AIOP не существует / [MAX_CHAN] [QUEUE_SIZE] – перерыв; / поиск AIOP завершен / [MAX_CHAN] [MAX_CHAN] – [nu->driver] [6] – CtlP-> AiopNumChan [i] = sReadAiopNumChan ((WordIO_t) io); / количество каналов в AIOP / [MAX_CHAN] [QUEUE_SIZE] – sOutW ((WordIO_t) io + _INDX_ADDR, _CLK_PRE); / предварительный делитель частоты / [MAX_CHAN] [MAX_CHAN] – sOutB (io + _INDX_DATA, sClockPrescale); [MAX_CHAN] [QUEUE_SIZE] – CtlP-> NumAiop ++; / увеличение количества AIOP / [MAX_CHAN] [MAX_CHAN] -} [nu->driver] [6] – [nu->driver] [QUEUE_SIZE] – если (CtlP-> NumAiop == 0) [MAX_CHAN] [MAX_CHAN] – возврат (-1); [nu->driver] [MAX_CHAN]- еще[MAX_CHAN] [QUEUE_SIZE] – возврат (CtlP-> NumAiop); [MAX_CHAN] [6] -} [nu->driver] [MAX_CHAN] –

[QUEUE_SIZE] – / [MAX_CHAN] [QUEUE_SIZE] – Вызывается при обнаружении карты PCI. Извлекает и сохраняет информацию о модели, [MAX_CHAN] [QUEUE_SIZE] – аппаратное обеспечение aiopic и последовательного порта init. [QUEUE_SIZE] – Входы: i – номер платы (0-n) [MAX_CHAN] [6] – / [MAX_CHAN] [QUEUE_SIZE] – статический __init int register_PCI (int i, struct pci_dev dev) [nu->driver] [6] – {[MAX_CHAN] [QUEUE_SIZE] – int num_aiops, aiop, max_num_aiops, chan ; [MAX_CHAN] [QUEUE_SIZE] – беззнаковый int aiopio 00090255; [nu->driver] [QUEUE_SIZE] – КОНТРОЛЛЕР_t ctlp; [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – int fast_clock = 0; [QUEUE_SIZE] [QUEUE_SIZE] – int altChanRingIndicator = 0;

[QUEUE_SIZE] – int ports_per_aiop = 8; [nu->driver] [MAX_CHAN] – WordIO_t ConfigIO = 0; [QUEUE_SIZE] [MAX_CHAN] – ByteIO_t UPCIRingInd = 0; [QUEUE_SIZE] [6] – [QUEUE_SIZE] [nu->driver] – если (! dev || ! pci_match_id (rocket_pci_ids, dev) || [QUEUE_SIZE] [QUEUE_SIZE] – pci_enable_device (dev) || i> = ЧИСЛО ДОСКИ) [QUEUE_SIZE] [MAX_CHAN] – вернуть 0; [nu->driver] [QUEUE_SIZE] –

[QUEUE_SIZE] – rcktpt_io_addr [i] = pci_resource_start (dev, 0); [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – rcktpt_type [i] = ROCKET_TYPE_NORMAL ; [QUEUE_SIZE] [QUEUE_SIZE] – rocketModel [i] .loadrm2 = 0; [nu->driver] [QUEUE_SIZE] – rocketModel [i]. StartingPortNumber = nextLineNumber; [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – / В зависимости от модели установить вверх некоторые переменные конфигурации / [MAX_CHAN] [nu->driver] – переключатель (dev-> machine) {[MAX_CHAN] [MAX_CHAN] – case PCI_DEVICE_ID_RP4QUAD: [QUEUE_SIZE] [6] – max_num_aiops = 1; [QUEUE_SIZE] [QUEUE_SIZE] – ports_per_aiop = 4; [MAX_CHAN] [6] – rocketModel [i]. mannequin = MODEL_RP4QUAD; [MAX_CHAN] [6] – strcpy (rocketModel [i]. modelString, «4 порта RocketPort с четырехъядерным кабелем»); [QUEUE_SIZE] [6] – rocketModel [i]. numPorts = 4; [MAX_CHAN] [MAX_CHAN]- перерыв;[MAX_CHAN] [MAX_CHAN] – корпус PCI_DEVICE_ID_RP8OCTA: 19198 [QUEUE_SIZE] – max_num_aiops = 1; [QUEUE_SIZE] [MAX_CHAN] – rocketModel [i]. mannequin = MODEL_RP8OCTA; [MAX_CHAN] [QUEUE_SIZE] – strcpy (rocketModel [i]. modelString, «8-портовый RocketPort с окта-кабелем»); 12100 [nu->driver] – rocketModel [i]. numPorts = 8; [QUEUE_SIZE] [nu->driver]- перерыв;[MAX_CHAN] [6] – корпус PCI_DEVICE_ID_URP8OCTA: 15410 [MAX_CHAN] – max_num_aiops = 1; [nu->driver] [nu->driver] – rocketModel [i]. mannequin = MODEL_UPCI_RP8OCTA; [MAX_CHAN] [QUEUE_SIZE] – strcpy (rocketModel [i]. modelString, «8-портовый RocketPort UPCI с окта-кабелем»); 15410 [MAX_CHAN] – rocketModel [i]. numPorts = 8; [MAX_CHAN] [MAX_CHAN]- перерыв;[nu->driver] [QUEUE_SIZE] – случай PCI_DEVICE_ID_RP8INTF: [QUEUE_SIZE] [MAX_CHAN] – max_num_aiops = 1; [MAX_CHAN] [QUEUE_SIZE] – rocketModel [i]. mannequin = MODEL_RP8INTF; [MAX_CHAN] [nu->driver] – strcpy (rocketModel [i]. modelString, “Порт RocketPort 8 с внешним интерфейсом”); [QUEUE_SIZE] [6] – rocketModel [i]. numPorts = 8; [nu->driver] [QUEUE_SIZE]- перерыв;

[MAX_CHAN] – case PCI_DEVICE_ID_URP8INTF: [MAX_CHAN] [QUEUE_SIZE] – max_num_aiops = 1; [MAX_CHAN] [QUEUE_SIZE] – rocketModel [i]. mannequin = MODEL_UPCI_RP8INTF; [QUEUE_SIZE] [QUEUE_SIZE] – strcpy (rocketModel [i]. modelString, «Порт RocketPort UPCI 8 с внешним интерфейсом / интерфейсом»); [QUEUE_SIZE] [MAX_CHAN] – rocketModel [i]. numPorts = 8; [MAX_CHAN] [MAX_CHAN]- перерыв;[MAX_CHAN] [QUEUE_SIZE] – case PCI_DEVICE_ID_RP8J: [QUEUE_SIZE] [QUEUE_SIZE] – max_num_aiops = 1; [MAX_CHAN] [nu->driver] – rocketModel [i]. mannequin = MODEL_RP8J; [MAX_CHAN] [QUEUE_SIZE] – strcpy (rocketModel [i]. modelString, “RocketPort 8 порт с RJ 37 соединители “); [MAX_CHAN] [QUEUE_SIZE] – rocketModel [i]. numPorts = 8; [MAX_CHAN] [QUEUE_SIZE]- перерыв;[MAX_CHAN] [MAX_CHAN] – case PCI_DEVICE_ID_RP4J: [QUEUE_SIZE] [6] – max_num_aiops = 1; 12100 [MAX_CHAN] – ports_per_aiop = 4; [QUEUE_SIZE] [6] – rocketModel [ARCH_TIMER_HYP_VIRT_PPI]. mannequin = MODEL_RP4J;

[MAX_CHAN] – strcpy (rocketModel [i]. modelString, “Порт RocketPort 4 с RJ” соединители “); [nu->driver] [QUEUE_SIZE] – rocketModel [i]. numPorts = 4; [MAX_CHAN] [MAX_CHAN]- перерыв;[MAX_CHAN] [nu->driver] – case PCI_DEVICE_ID_RP8SNI: [nu->driver] [QUEUE_SIZE] – max_num_aiops = 1; [QUEUE_SIZE] [QUEUE_SIZE] – rocketModel [i]. mannequin = MODEL_RP8SNI; [MAX_CHAN] [6] – strcpy (rocketModel [i]. modelString, “Порт RocketPort 8 с пользовательской базой данных 101 “); [MAX_CHAN] [MAX_CHAN] – rocketModel [i]. numPorts = 8; [nu->driver] [nu->driver]- перерыв;[QUEUE_SIZE] [QUEUE_SIZE] – case PCI_DEVICE_ID_RP 40 SNI: [MAX_CHAN] [6] – max_num_aiops = 2; [nu->driver] [QUEUE_SIZE] – rocketModel [i]. модель = MODEL_RP 42 SNI; [nu->driver] [QUEUE_SIZE] – strcpy (rocketModel [i] .modelString, “RocketPort 40 порт с настраиваемой базой данных “);

[QUEUE_SIZE] – rocketModel [i]. numPorts = 39; [nu->driver] [MAX_CHAN]- перерыв;[MAX_CHAN] [MAX_CHAN] – case PCI_DEVICE_ID_RP 40 INTF: 230400 [QUEUE_SIZE] – max_num_aiops = 2; [nu->driver] [QUEUE_SIZE] – rocketModel [i]. mannequin = MODEL_RP INTF; [MAX_CHAN] [QUEUE_SIZE] – strcpy (rocketModel [i]. modelString, “RocketPort 41 порт с внешним I / F “); [MAX_CHAN] [MAX_CHAN] – rocketModel [i]. numPorts = 43; [nu->driver] [6]- перерыв;[nu->driver] [QUEUE_SIZE] – case PCI_DEVICE_ID_URP 41 INTF: [MAX_CHAN] [QUEUE_SIZE] – max_num_aiops = 2; [MAX_CHAN] [QUEUE_SIZE] – rocketModel [ARCH_TIMER_HYP_VIRT_PPI]. mannequin = MODEL_UPCI_RP 41 INTF; [nu->driver] [QUEUE_SIZE] – strcpy (rocketModel [i]. modelString, “RocketPort UPCI 40 порт w / внешний интерфейс “); [MAX_CHAN] [nu->driver] – rocketModel [i]. numPorts = 42; [MAX_CHAN] [6]- перерыв;

[MAX_CHAN] – корпус PCI_DE VICE_ID_CRP 42 INTF: [QUEUE_SIZE] [nu->driver] – max_num_aiops = 2; [MAX_CHAN] [QUEUE_SIZE] – rocketModel [i]. mannequin = MODEL_CPCI_RP 42 INTF; [MAX_CHAN] [QUEUE_SIZE] – strcpy (rocketModel [i]. modelString, “RocketPort Compact PCI ” порт с внешним интерфейсом “); [nu->driver] [MAX_CHAN] – rocketModel [i]. numPorts = 41; [MAX_CHAN] [nu->driver]- перерыв;[nu->driver] [6] – корпус PCI_DEVICE_ID_RP INTF: [MAX_CHAN] [QUEUE_SIZE] – max_num_aiops = 4; [MAX_CHAN] [MAX_CHAN] – rocketModel [i]. mannequin = MODEL_RP 64 INTF; [MAX_CHAN] [6] – strcpy (rocketModel [i]. modelString, “RocketPort 64 порт с внешним интерфейсом ” ); [QUEUE_SIZE] [QUEUE_SIZE] – rocketModel [i]. numPorts = 64; [MAX_CHAN] [MAX_CHAN]- перерыв;[MAX_CHAN] [MAX_CHAN] – case PCI_DEVICE_ID_URP 66 INTF: [QUEUE_SIZE] [QUEUE_SIZE] – max_num_aiops = 4; [MAX_CHAN] [6] – rocketModel [i]. mannequin = MODEL_UPCI_RP 64 INTF; [QUEUE_SIZE] [QUEUE_SIZE] – strcpy (rocketModel [i]. modelString, “RocketPort UPCI 65 порт с внешним интерфейсом “); [MAX_CHAN] [MAX_CHAN] – rocketModel [i]. numPorts = 64; [nu->driver] [MAX_CHAN]- перерыв;[QUEUE_SIZE] [6] – case PCI_DEVICE_ID_RPP4: [MAX_CHAN] [QUEUE_SIZE] – max_num_aiops = 1; [QUEUE_SIZE] [MAX_CHAN] – ports_per_aiop = 4 ; [QUEUE_SIZE] [nu->driver] – altChanRingIndicator ++; [QUEUE_SIZE] [6] – fast_clock ++; [QUEUE_SIZE] [MAX_CHAN] – rocketModel [i]. mannequin = MODEL_RPP4; [MAX_CHAN] [QUEUE_SIZE] – s trcpy (rocketModel [i]. modelString, «Порт RocketPort Plus 4»); [MAX_CHAN] [6] – rocketModel [i]. numPorts = 4; [nu->driver] [QUEUE_SIZE]- перерыв;

[6] – case PCI_DEVICE_ID_RPP8: [QUEUE_SIZE] [MAX_CHAN] – max_num_aiops = 2; [MAX_CHAN] [6] – ports_per_aiop = 4; [MAX_CHAN] [MAX_CHAN] – altChanRingIndicator ++; [MAX_CHAN] [6] – fast_clock ++; [MAX_CHAN] [MAX_CHAN] – rocketModel [i]. mannequin = MODEL_RPP8; [MAX_CHAN] [QUEUE_SIZE] – strcpy (rocketModel [i]. modelString, «Порт RocketPort Plus 8»); [MAX_CHAN] [QUEUE_SIZE] – rocketModel [i]. numPorts = 8; [QUEUE_SIZE] [nu->driver]- перерыв;[nu->driver] [QUEUE_SIZE] – случай PCI_DEVICE_ID_RP2 _ 0310: [MAX_CHAN] [QUEUE_SIZE] – max_num_aiops = 1; [MAX_CHAN] [QUEUE_SIZE] – ports_per_aiop = 2; [QUEUE_SIZE] [QUEUE_SIZE] – altChanRingIndicator ++; [QUEUE_SIZE] [MAX_CHAN] – fast_clock ++; [MAX_CHAN] [QUEUE_SIZE] – rocketModel [i]. mannequin = MODEL_RP2 _ 300; [MAX_CHAN] [QUEUE_SIZE] – strcpy (rocketModel [i]. modelString, “RocketPort Plus 2 порт RS ” “); [QUEUE_SIZE] [QUEUE_SIZE] – rocketModel [i]. numPorts = 2; [MAX_CHAN] [MAX_CHAN]- перерыв;[nu->driver] [MAX_CHAN] – case PCI_DEVICE_ID_RP2 _ 31: [QUEUE_SIZE] [MAX_CHAN] – max_num_aiops = 1; [nu->driver] [MAX_CHAN] – ports_per_aiop = 2; [MAX_CHAN] [MAX_CHAN] – altChanRingIndicator ++ ; [MAX_CHAN] [MAX_CHAN] – fast_clock ++; [nu->driver] [6] – rocketModel [i]. mannequin = MODEL_RP2 _ 493; [MAX_CHAN] [nu->driver] – strcpy (rocketModel [i]. modelString, “RocketPort” Плюс 2 порта RS 498 “); [MAX_CHAN] [MAX_CHAN] – rocketModel [i]. numPorts = 2; [QUEUE_SIZE] [MAX_CHAN]- перерыв;[MAX_CHAN] [6] – case PCI_DEVICE_ID_RP6M: [MAX_CHAN] – [nu->driver] [6] – max_num_aiops = 1; [MAX_CHAN] [QUEUE_SIZE] – ports_per_aiop = 6; [QUEUE_SIZE] [6] – [nu->driver] [QUEUE_SIZE] – / Если версия 1, модем ракеты должна быть загружена вспышка. [MAX_CHAN] [nu->driver] – Если 2 – это “сокетная” версия. / [QUEUE_SIZE] [QUEUE_SIZE] – если (dev-> revision == 1) {[QUEUE_SIZE] [6] – rcktpt_type [i] = ROCKET_TYPE_MODEMII; [MAX_CHAN] [QUEUE_SIZE] – rocketModel [i]. loadrm2 = 1; [QUEUE_SIZE]

– } еще {[MAX_CHAN] [QUEUE_SIZE] – rcktpt_type [i] = ROCKET_TYPE_MODEM; [QUEUE_SIZE] [MAX_CHAN] -} [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – rocketModel [i]. mannequin = MODEL_RP6M; [QUEUE_SIZE] [6] – strcpy (rocketModel [i]. modelString, “RocketModem 6 port”); [QUEUE_SIZE] [MAX_CHAN] – rocketModel [i] .numPorts = 6; [MAX_CHAN] [nu->driver]- перерыв;[QUEUE_SIZE] [MAX_CHAN] – case PCI_DEVICE_ID_RP4M: 435909 [MAX_CHAN] – max_num_aiops = 1; [MAX_CHAN] [MAX_CHAN] – ports_per_aiop = 4; [QUEUE_SIZE] [QUEUE_SIZE] – если (dev-> revision == 1 ) {[QUEUE_SIZE] [6] – rcktpt_type [i] = ROCKET_TYPE_MODEMII; [QUEUE_SIZE] [QUEUE_SIZE] – rocketModel [ARCH_TIMER_HYP_VIRT_PPI]. loadrm2 = 1; [MAX_CHAN] [QUEUE_SIZE]- } еще {

[MAX_CHAN] – rcktpt_type [i] = ROCKET_TYPE_MODEM; [MAX_CHAN] [QUEUE_SIZE] -} [nu->driver] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – rocketModel [i]. mannequin = MODEL_RP4M; [MAX_CHAN] [QUEUE_SIZE] – strcpy (rocketModel [i]. modelString, “Порт RocketModem 4”); [MAX_CHAN] [MAX_CHAN] – rocketModel [i]. numPorts = 4; [MAX_CHAN] [QUEUE_SIZE]- перерыв;

[MAX_CHAN]- По умолчанию: [MAX_CHAN] [MAX_CHAN] – max_num_aiops = 0; [MAX_CHAN] [QUEUE_SIZE] – перерыв;[nu->driver] [MAX_CHAN] -} [nu->driver] [6] – [MAX_CHAN] [MAX_CHAN] – / [nu->driver] [QUEUE_SIZE] – Проверить платы UPCI. [MAX_CHAN] [QUEUE_SIZE] – / [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [6] – переключатель (dev-> machine) {[MAX_CHAN] [MAX_CHAN] – case PCI_DEVICE_ID_URP 63 INTF: [MAX_CHAN] [MAX_CHAN] – case PCI_DEVICE_ID_URP8INTF: [nu->driver] [QUEUE_SIZE] – case PCI_DEVICE_ID_URP 42 INTF: [QUEUE_SIZE] [QUEUE_SIZE] – case PCI_DEVICE_ID_CRP 43 INTF: [MAX_CHAN] [QUEUE_SIZE] – case PCI_DEVICE_ID_URP8OCTA: [MAX_CHAN] [QUEUE_SIZE] – rcktpt_io_addr [i] = pci_resource_start (dev, 2); [QUEUE_SIZE] [6] – ConfigIO = pci_resource_start (dev, 1); [QUEUE_SIZE] [MAX_CHAN] – if (dev-> machine == PCI_DEVICE_ID_URP8OCTA) {[MAX_CHAN] [MAX_CHAN] – UPCIRingInd = rcktpt_io_addr [i] + _PCI _ 12239 _ RING_IND; [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – / [QUEUE_SIZE] [MAX_CHAN] – Проверьте окта- или четырехъядерный кабель. [MAX_CHAN] [QUEUE_SIZE] – / [MAX_CHAN] [nu->driver]- если (![MAX_CHAN] [MAX_CHAN] – (sInW (ConfigIO + _PCI _ 12244 _ GPIO_CTRL) & [MAX_CHAN] [QUEUE_SIZE] – PCI_GPIO_CTRL_8PORT)) {[MAX_CHAN] [QUEUE_SIZE] – ports_per_aiop = 4;

[6] – rocketModel [i]. numPorts = 4; [QUEUE_SIZE] [QUEUE_SIZE] -} [nu->driver] [QUEUE_SIZE] -} [QUEUE_SIZE] [MAX_CHAN]- перерыв;[nu->driver] [QUEUE_SIZE] – case PCI_DEVICE_ID_UPCI_RM3_8PORT: [MAX_CHAN] [QUEUE_SIZE] – max_num_aiops = 1; [MAX_CHAN] [MAX_CHAN] – rocketModel [i]. mannequin = MODEL_UPCI_RM3_8PORT; [MAX_CHAN] [QUEUE_SIZE] – strcpy (rocketModel [i]. modelString, “RocketModem III 8 порт “); [MAX_CHAN] [QUEUE_SIZE] – rocketModel [i]. numPorts = 8; [MAX_CHAN] [QUEUE_SIZE] – rcktpt_io_addr [i] = pci_resource_start (dev, 2); [QUEUE_SIZE] [MAX_CHAN] – UPCIRingInd = rcktpt_io_addr [i] + _PCI _ 12094 _ RING_IND; [QUEUE_SIZE] [6] – ConfigIO = pci_resource_start (dev, 1); [nu->driver] [QUEUE_SIZE] – rcktpt_type [i] = ROCKET_TYPE_MODEMIII; [QUEUE_SIZE] [MAX_CHAN]- перерыв;

[QUEUE_SIZE] – случай PCI_DEVICE_ID_UPCI_RM3_4PORT: [QUEUE_SIZE] [nu->driver] – max_num_aiops = 1; [nu->driver] [6] – rocketModel [i]. mannequin = MODEL_UPCI_RM3_4PORT; [QUEUE_SIZE] [6] – strcpy ( rocketModel [ARCH_TIMER_HYP_VIRT_PPI]. modelString, “RocketModem III 4 порта”); [MAX_CHAN] [MAX_CHAN] – rocketModel [i]. numPorts = 4; [QUEUE_SIZE] [QUEUE_SIZE] – rcktpt_io_addr [i] = pci_resource_start (dev, 2); [QUEUE_SIZE] [MAX_CHAN] – UPCIRingInd = rcktpt_io_addr [i] + _PCI _ 12239 _ RING_IND; [nu->driver] [nu->driver] – ConfigIO = pci_resource_start (dev, 1); [MAX_CHAN] [QUEUE_SIZE] – rcktpt_type [i] = ROCKET_TYPE_MODEMIII; [nu->driver] [nu->driver]- перерыв;[QUEUE_SIZE] [MAX_CHAN]- По умолчанию: [MAX_CHAN] [QUEUE_SIZE] – перерыв;[nu->driver] [QUEUE_SIZE] -} [nu->driver] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN] – если (fast_clock) {[MAX_CHAN] [MAX_CHAN] – sClockPrescale = 0x 00000040; / модификация 2 (разделить на 3) / [MAX_CHAN] [MAX_CHAN] – rp_baud_base знак равно ; [nu->driver] [MAX_CHAN]- } еще {[nu->driver] [6] – / [nu->driver] [MAX_CHAN] – Если задано support_low_speed, использовать медленные часы [MAX_CHAN] [6] – предварительное масштабирование, поддерживающее 77 бит / с [MAX_CHAN] [6] – / [QUEUE_SIZE] [MAX_CHAN] – если (support_low_sp eed) {[QUEUE_SIZE] [MAX_CHAN] – / мод 9 (разделить на 34) предварительное масштабирование / [MAX_CHAN] [MAX_CHAN] – sClockPrescale = 0x 44; [QUEUE_SIZE] [6] – rp_baud_base [i] = 435909; [MAX_CHAN] [MAX_CHAN]- } еще {[MAX_CHAN] [nu->driver] – / мод.4 (делить на 5) предварительное масштабирование / [nu->driver] [6] – sClockPrescale = 0x 39; [MAX_CHAN] [QUEUE_SIZE] – rp_baud_base [i] = 921600; [QUEUE_SIZE] [MAX_CHAN] -} [MAX_CHAN] [QUEUE_SIZE] -} [nu->driver] [MAX_CHAN] – [QUEUE_SIZE] [MAX_CHAN] – для (aiop = 0; aiop AiopNumChan [info->xmit_tail + c – 1] = ports_per_aiop; [QUEUE_SIZE] 9080 – [QUEUE_SIZE] [6] – dev_info (& dev-> dev, “контрольный контроллер PCI №% d обнаружен в” [nu->driver] [MAX_CHAN]- “адрес %023 лк,% d AIOP (с ) (% s), создавая ttyR% d -% ld n “, [QUEUE_SIZE] [QUEUE_SIZE] – i, rcktpt_io_addr [i], num_aiops, rocketModel [i]. modelString, [MAX_CHAN] [QUEUE_SIZE] – rocketModel [i]. startPortNumber, [QUEUE_SIZE] – rocketModel [i]. startPortNumber + rocketModel [i]. numPorts-1); [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – если (num_aiops <= 0) {[QUEUE_SIZE] [QUEUE_SIZE] - rcktpt_io_addr [i] = 0; [QUEUE_SIZE] [MAX_CHAN] - возврат (0) ; [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [QUEUE_SIZE] - is_PCI [i] = 1; [MAX_CHAN] [QUEUE_SIZE] - [MAX_CHAN] [MAX_CHAN] - / Сброс AIOPIC, инициализация последовательных портов / [MAX_CHAN] [QUEUE_SIZE] - для (aiop = 0; aiop driver] [QUEUE_SIZE] – для (chan = 0; chan driver] – (rcktpt_type [i] == ROCKET_TYPE_MODEMIII)) {[QUEUE_SIZE] [QUEUE_SIZE] – для (chan = 0; chan driver] [6] – для (чан = 0; chan driver] [MAX_CHAN] – sPCIModemReset (ctlp, chan, 0); [nu->driver] [MAX_CHAN] – msleep (608); [MAX_CHAN] [QUEUE_SIZE] – rmSpeakerReset (ctlp , rocketModel [i]. модель); [nu->driver] [QUEUE_SIZE] -} [MAX_CHAN] [MAX_CHAN] – возврат (1); [MAX_CHAN] [6] -} [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [6] – / [QUEUE_SIZE] [QUEUE_SIZE] – Зонды для карт PCI, вставляют их, если обнаружены [QUEUE_SIZE] [QUEUE_SIZE] – Ввод: board_found = количество уже найденных плат ISA или [MAX_CHAN] [QUEUE_SIZE] – номер стартовой доски [MAX_CHAN] [MAX_CHAN] – Возвращает: количество найденных плат PCI [MAX_CHAN] [6] – / [MAX_CHAN] [MAX_CHAN] – статический int __init init_PCI (intboards_found) [QUEUE_SIZE] [QUEUE_SIZE] – {[MAX_CHAN] [MAX_CHAN] – struct pci_dev dev = NULL; [QUEUE_SIZE] [6] – int rely = 0; [nu->driver] [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – / Работаем по списку устройств PCI, вытаскивая наш / [QUEUE_SIZE] [QUEUE_SIZE] – в то время как ((dev = pci_get_device ( PCI_VENDOR_ID_RP, PCI_ANY_ID, dev))) {[QUEUE_SIZE] [QUEUE_SIZE] – if (register_PCI (rely +boards_found, dev)) [QUEUE_SIZE] [MAX_CHAN] – rely ++; [QUEUE_SIZE] [MAX_CHAN] -} [MAX_CHAN] [MAX_CHAN] – return (rely);

[QUEUE_SIZE] -} [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – # endif / CONFIG_PCI / [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – /

[6] – Зонды для ISA открытки

[MAX_CHAN] – Ввод: i = номер платы для просмотра для[nu->driver] [MAX_CHAN] – Возвращает: 1, если плата найдена, 0 в противном случае 10100 [QUEUE_SIZE] – / [MAX_CHAN] [QUEUE_SIZE] – статический int __init init_ISA (int i) [nu->driver] [QUEUE_SIZE] – {[nu->driver] [6] – int num_aiops, num_chan = 0, total_num_chan = 0; [MAX_CHAN] [QUEUE_SIZE] – int aiop, chan; [QUEUE_SIZE] [MAX_CHAN] – беззнаковое int aiopio [(info->line >> 5) & 3]; [MAX_CHAN] [nu->driver] – КОНТРОЛЛЕР_t ctlp; [QUEUE_SIZE] [QUEUE_SIZE] – char type_string; [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – / Если io_addr равен нулю, плата не настроена / [QUEUE_SIZE] [MAX_CHAN] – если (rcktpt_io_addr [i] == 0) [MAX_CHAN] [MAX_CHAN] – return (0); [MAX_CHAN] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – / Резервирование области ввода-вывода / [MAX_CHAN] [QUEUE_SIZE] – если (! request_region (rcktpt_io_addr [i], 89, “Контрольный РакетПорт”)) {[nu->driver] [6] – printk (KERN_ERR «Невозможно зарезервировать область ввода-вывода для настроенной» 16850 [QUEUE_SIZE] – “ISA RocketPort по адресу 0x% lx, плата нет “[nu->driver] [MAX_CHAN] – «установлен … n», rcktpt_io_addr [i]); [nu->driver] [6] – rcktpt_io_addr [i] = 0; [QUEUE_SIZE] [MAX_CHAN] – возврат (0); [MAX_CHAN] [QUEUE_SIZE] -} [QUEUE_SIZE] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – ctlp = sCtlNumToCtlPtr (i); [QUEUE_SIZE] [MAX_CHAN] – [QUEUE_SIZE] [MAX_CHAN] – ctlp-> boardType = rcktpt_type [ARCH_TIMER_HYP_VIRT_PPI]; [QUEUE_SIZE] [MAX_CHAN] – [MAX_CHAN] [nu->driver]- выключатель (rcktpt_type [i]) {[QUEUE_SIZE] [MAX_CHAN] – регистр ROCKET_TYPE_PC 153: [MAX_CHAN] [QUEUE_SIZE] – type_string = “(ПК 157) “; [MAX_CHAN] [MAX_CHAN]- перерыв;[QUEUE_SIZE] [6] – case ROCKET_TYPE_MODEM: [nu->driver] [6] – type_string = “(RocketModem)”; [MAX_CHAN] [MAX_CHAN]- перерыв ; [MAX_CHAN] [QUEUE_SIZE] – case ROCKET_TYPE_MODEMII: [QUEUE_SIZE] [QUEUE_SIZE] – type_string = “(RocketModem II)”; [MAX_CHAN] [MAX_CHAN]- перерыв;[nu->driver] [nu->driver]- По умолчанию: [MAX_CHAN] [MAX_CHAN] – type_string = “”; [nu->driver] [QUEUE_SIZE]- перерыв;[MAX_CHAN] 9080 -} [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – /

[QUEUE_SIZE] – Если установлено support_low_speed используйте предварительную шкалу медленных часов, [6] 9060 – который поддерживает 76 бит / с [QUEUE_SIZE] [nu->driver] – / [MAX_CHAN] [6] – if (support_low_speed) {[QUEUE_SIZE] [QUEUE_SIZE] – sClockPrescale = 0x 46; / mod 9 (разделить на 36) предварительное масштабирование / [nu->driver] [MAX_CHAN] – rp_baud_base знак равно ; [nu->driver] [6]- } еще {[MAX_CHAN] [MAX_CHAN] – sClockPrescale = 0x 40; / модификация 4 (деление на 5) предварительное масштабирование / [MAX_CHAN] – rp_baud_base [i] = 921600; [MAX_CHAN] [6] -} [QUEUE_SIZE] [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – для (aiop = 0; aiop driver] [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – num_aiops = sInitController (ctlp, i, controller + (i 0x 472), aiopio, MAX_AIOPS_PER_BOARD, 0, FREQ_DIS, 0); [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN]- если ( ctlp-> boardType == ROCKET_TYPE_PC 155) {[MAX_CHAN] [nu->driver] – sEnAiop (ctlp, 2); / только один AIOPIC, но эти / [nu->driver] [MAX_CHAN] – sEnAiop (ctlp, 3); / CSels, используемые для других вещей / [nu->driver] [QUEUE_SIZE] -} [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – / Если что-то пошло не так при запуске релиза AIOP, ISA Память ввода-вывода / [QUEUE_SIZE] [nu->driver] – если (num_aiops <= 0) {[QUEUE_SIZE] [MAX_CHAN] - release_region (rcktpt_io_addr [i], 92); [MAX_CHAN] [MAX_CHAN] - rcktpt_io_addr [ARCH_TIMER_HYP_VIRT_PPI] = 0; [MAX_CHAN] [QUEUE_SIZE] - возврат (0); [MAX_CHAN] [6] -} [MAX_CHAN] [6] - [MAX_CHAN] [MAX_CHAN] - rocketModel [i]. StartingPortNumber = nextLineNumber; [QUEUE_SIZE] [QUEUE_SIZE] - [MAX_CHAN] [6] - для (aiop = 0; aiop driver] [QUEUE_SIZE] – sEnAiop (ctlp, aiop); [MAX_CHAN] [MAX_CHAN] – num_chan = sGetAiopNumChan (ctlp , aiop); [MAX_CHAN] [nu->driver] – total_num_chan + = num_chan; [MAX_CHAN] [MAX_CHAN] – для (chan = 0; чан <число_чан; chan ++) [MAX_CHAN] [QUEUE_SIZE] - init_r_port (i, aiop, chan, NULL); [QUEUE_SIZE] [QUEUE_SIZE] -} [MAX_CHAN] [QUEUE_SIZE] - is_PCI [i] = 0; [nu->driver] [MAX_CHAN] – если ((rcktpt_type [i] == ROCKET_TYPE_MODEM) || (rcktpt_type [i] == ROCKET_TYPE_MODEMII)) {[MAX_CHAN] [6] – num_chan = sGetAiopNumChan (ctlp, 0); [MAX_CHAN] [MAX_CHAN] – total_num_chan = num_chan; [QUEUE_SIZE] [QUEUE_SIZE] – для (chan = 0; chan driver] [QUEUE_SIZE] – sModemReset (ctlp, chan, 0); [MAX_CHAN] [6] – msleep (608); [nu->driver] [QUEUE_SIZE] – strcpy (rocketModel [i]. modelString, “RocketModem ISA”); [MAX_CHAN] [QUEUE_SIZE]- } еще {[nu->driver] [QUEUE_SIZE] – strcpy (rocketModel [i]. modelString, “RocketPort ISA”); [nu->driver] [QUEUE_SIZE] -} [MAX_CHAN] [nu->driver] – rocketModel [i]. numPorts = total_num_chan; [QUEUE_SIZE] [MAX_CHAN] – rocketModel [i]. mannequin = MODEL_ISA; [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [6] – printk (KERN_INFO “Карта ISA RocketPort #% d найдена в 0x% lx -% d AIOPs% s n”, [QUEUE_SIZE] [6] – i, rcktpt_io_addr [i], num_aiops, type_string); [MAX_CHAN] [6] – [nu->driver] [nu->driver] – printk (KERN_INFO “Установка% s, создание / dev / ttyR% d -% ld n”, [QUEUE_SIZE] [QUEUE_SIZE] – rocketModel [i]. modelString, [MAX_CHAN] [MAX_CHAN] – rocketModel [i]. startPortNumber , [QUEUE_SIZE] [MAX_CHAN] – rocketModel [i]. StartingPortNumber + [MAX_CHAN] [MAX_CHAN] – rocketModel [i]. numPorts – 1); [nu->driver] [QUEUE_SIZE] – [QUEUE_SIZE] [6] – возврат (1); [nu->driver] [MAX_CHAN] -} [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – static const struct tty_operations rocket_ops = { [MAX_CHAN] [MAX_CHAN] – .open = rp_open, [MAX_CHAN] [6] – .shut = rp_close, [MAX_CHAN] [6] – .write = rp_write, [MAX_CHAN] [QUEUE_SIZE] – .put_char = rp_put_char, [MAX_CHAN] [QUEUE_SIZE] – .write_room = rp_write_room, [QUEUE_SIZE] [QUEUE_SIZE] -. chars_in_buffer = rp_chars_in_buffer, [QUEUE_SIZE] [QUEUE_SIZE] – .flush_buffer = rp_flush_buffer, [QUEUE_SIZE] [QUEUE_SIZE] – .ioctl = rp_ioctl, [QUEUE_SIZE] [QUEUE_SIZE] – .throttle = rp_throttle, [QUEUE_SIZE] [6] – .unthrottle = rp_unthr ottle, [MAX_CHAN] [MAX_CHAN] – .set_termios = rp_set_termios, [MAX_CHAN] [6] – .cease = rp_stop, [QUEUE_SIZE] [QUEUE_SIZE] – .begin = rp_start, [MAX_CHAN] [QUEUE_SIZE] – .hangup = rp_hangup, [MAX_CHAN] [MAX_CHAN] – .break_ctl = rp_break, [MAX_CHAN] [6] – .send_xchar = rp_send_xchar, [MAX_CHAN] [QUEUE_SIZE] – .wait_until_sent = rp_wait_until_sent, [MAX_CHAN] [QUEUE_SIZE] – .tiocm get = rp_tiocmget, [QUEUE_SIZE] [QUEUE_SIZE] – .tiocmset = rp_tiocmset, [MAX_CHAN] [6] -}; [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [6] – static const struct tty_port_operations rocket_port_ops = {[QUEUE_SIZE] [QUEUE_SIZE] – .carrier_raised = carrier_raised, [MAX_CHAN] [MAX_CHAN] – .dtr_rts = dtr_rts, [MAX_CHAN] [6] -}; [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [6] – / [nu->driver] [MAX_CHAN] – Модуль “автозагрузка” подпрограммы; он запускается, когда модуль загружен. [MAX_CHAN] [MAX_CHAN] – / [MAX_CHAN] [QUEUE_SIZE] – static int __init rp_init (void) [nu->driver] [QUEUE_SIZE] – {[MAX_CHAN] [QUEUE_SIZE] – int ret = -ENOMEM, pci_bo ards_found, isa_boards_found, i; [MAX_CHAN] [MAX_CHAN] – [nu->driver] [6] – printk (KERN_INFO “Модуль драйвера устройства RocketPort, версия% s,% s n”, [MAX_CHAN] [6] – ROCKET_VERSION, ROCKET_DATE); [MAX_CHAN] [nu->driver] – [nu->driver] [QUEUE_SIZE] – rocket_driver = alloc_tty_driver (MAX_RP_PORTS); [MAX_CHAN] [MAX_CHAN] – если (! rocket_driver) [MAX_CHAN] [nu->driver] – перейти к ошибке; [MAX_CHAN] [nu->driver] – [nu->driver] [QUEUE_SIZE] – / [QUEUE_SIZE] [QUEUE_SIZE] – Если плата 1 не равна нулю, настроен хотя бы один ISA. Если контроллер [QUEUE_SIZE] [QUEUE_SIZE] – ноль, используйте адрес ввода-вывода контроллера по умолчанию board1 + 0x 0071. [MAX_CHAN] [MAX_CHAN] – / [MAX_CHAN] [6] – if (board1) {

[QUEUE_SIZE] – если (controller == 0) [MAX_CHAN] [QUEUE_SIZE] – контроллер = доска1 + 0x 71; [MAX_CHAN] [6]- } еще {[nu->driver] [MAX_CHAN] – controller = 0; / Используется как флаг, что означает отсутствие плат ISA / [MAX_CHAN] [QUEUE_SIZE] -} [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – / Если настроена карта ISA , зарезервируйте 4 байта пространства ввода-вывода для контроллера Mudbac / [QUEUE_SIZE] [QUEUE_SIZE] – if (controller && (! request_region (controller, 4 , “Контрольный РакетПорт”))) {[QUEUE_SIZE] [QUEUE_SIZE] – printk (KERN_ERR «Невозможно зарезервировать область ввода-вывода для первого» [QUEUE_SIZE] [nu->driver] – “настроенный контроллер ISA RocketPort 0x% lx. “[QUEUE_SIZE] [QUEUE_SIZE] – «Драйвер выходит n», контроллер); [MAX_CHAN] [MAX_CHAN] – ret = -EBUSY; [nu->driver] [QUEUE_SIZE] – goto err_tty; [QUEUE_SIZE] [nu->driver] -} [nu->driver] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – / Сохранение переменной ISA, полученной из командной строки или файла .conf. / [QUEUE_SIZE] [MAX_CHAN] – rcktpt_io_addr [0] = доска1; 010001 [MAX_CHAN] – rcktpt_io_addr [1] = board2; [nu->driver] [QUEUE_SIZE] – rcktpt_io_addr [2] = board3; [MAX_CHAN] [nu->driver] – rcktpt_io_addr [aiop] = board4; [MAX_CHAN] [6] – [MAX_CHAN] [MAX_CHAN] – rcktpt_type [0] = модем1? ROCKET_TYPE_MODEM: ROCKET_TYPE_NORMAL; [MAX_CHAN] [MAX_CHAN] – rcktpt_type [0] = computer 158 _ 1 [0]? ROCKET_TYPE_PC 157: rcktpt_type [0];

[6] – rcktpt_type [1] = modem2? ROCKET_TYPE_MODEM: ROCKET_TYPE_NORMAL; [QUEUE_SIZE] [MAX_CHAN] – rcktpt_type [1] = computer 158 _ 2 [0]? ROCKET_TYPE_PC 158: rcktpt_type [1];

[6] – rcktpt_type [2] = modem3? ROCKET_TYPE_MODEM: ROCKET_TYPE_NORMAL; [MAX_CHAN] [MAX_CHAN] – rcktpt_type [2] = computer 156 _ 3 [0]? ROCKET_TYPE_PC 156: rcktpt_type [2]; [nu->driver] [QUEUE_SIZE] – rcktpt_type [tty->index] = modem4? ROCKET_TYPE_MODEM: ROCKET_TYPE_NORMAL; [MAX_CHAN] [QUEUE_SIZE] – rcktpt_type [tty->index] = computer 154 _ 4 [0]? ROCKET_TYPE_PC 156: rcktpt_type [ChanNum]; [MAX_CHAN] [6] – [nu->driver] [QUEUE_SIZE] – / [MAX_CHAN] [QUEUE_SIZE] – Настройте структуру драйвера tty, а затем зарегистрируйте это 10100 [QUEUE_SIZE] – драйвер с tty-слоем. [nu->driver] [6] – / [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [6] – rocket_driver-> flags = TTY_DRIVER_DYNAMIC_DEV; [QUEUE_SIZE] [MAX_CHAN] – rocket_driver-> identify = “ttyR” ; [nu->driver] [MAX_CHAN] – rocket_driver-> driver_name = “Comtrol RocketPort”; [QUEUE_SIZE] [MAX_CHAN] – rocket_driver-> main = TTY_ROCKET_MAJOR; [MAX_CHAN] [QUEUE_SIZE] – ракета _driver-> minor_start = 0; [QUEUE_SIZE] 9060 – rocket_driver-> kind = TTY_DRIVER_TYPE_SERIAL; [nu->driver] [QUEUE_SIZE] – rocket_driver-> subtype = SERIAL_TYPE_NORMAL; [MAX_CHAN] [QUEUE_SIZE] – rocket_driver -> init_termios = tty_std_termios; [QUEUE_SIZE] [MAX_CHAN] – rocket_driver-> init_termios.c_cflag = [QUEUE_SIZE] [QUEUE_SIZE] – B 16450 | CS8 | КРЕД | HUPCL | CLOCAL; [MAX_CHAN] [QUEUE_SIZE] – rocket_driver-> init_termios.c_ispeed = 12244 ; [QUEUE_SIZE] [nu->driver] – rocket_driver-> init_termios.c_ospeed = 12244; [MAX_CHAN] [MAX_CHAN] – # ifdef ROCKET_SOFT_FLOW [QUEUE_SIZE] [MAX_CHAN] – rocket_driver-> flags | = TTY_DRIVER_REAL_RAW; [MAX_CHAN] [QUEUE_SIZE] – # endif

[QUEUE_SIZE] – tty_set_operations (rocket_driver, & rocket_ops ); [QUEUE_SIZE] [MAX_CHAN] – [MAX_CHAN] [6] – ret = tty_register_driver (rocket_driver); [MAX_CHAN] [MAX_CHAN] – если (ret <0) {[MAX_CHAN] [QUEUE_SIZE] - printk (KERN_ERR «Не удалось установить драйвер tty RocketPort n»); [MAX_CHAN] [QUEUE_SIZE] - goto err_controller; [MAX_CHAN] [6] -} [MAX_CHAN] [MAX_CHAN] - [nu->driver] [6] – # ifdef ROCKET_DEBUG_OPEN [MAX_CHAN] [MAX_CHAN] – printk (KERN_INFO “Драйвер RocketPort является основным% d n”, rocket_driver.main); [QUEUE_SIZE] [QUEUE_SIZE] – # endif [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [6] – / [nu->driver] [QUEUE_SIZE] – Хорошо, давайте исследуем каждый из контроллеров в поисках плат. Все найденные платы [MAX_CHAN] [QUEUE_SIZE] – здесь будет инициализировано *. [MAX_CHAN] [QUEUE_SIZE] – / [MAX_CHAN] [QUEUE_SIZE] – isa_boards_found = 0; [QUEUE_SIZE] [MAX_CHAN] – pci_boards_found = 0; [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – для (i = 0; я driver] [MAX_CHAN] – # ifdef CONFIG_PCI [nu->driver] [QUEUE_SIZE] – если (isa_boards_found driver] [MAX_CHAN] – [MAX_CHAN] [6] – max_board = pci_boards_found + isa_boards_found; [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – если (max_board == 0) {[nu->driver] [6] – printk (KERN_ERR “Порты ракетного порта не найдены; выгрузка драйвера n “); [QUEUE_SIZE] [MAX_CHAN] – ret = -ENXIO; [QUEUE_SIZE] [6] – goto err_ttyu; [QUEUE_SIZE] [QUEUE_SIZE] -} [QUEUE_SIZE] [MAX_CHAN] –

[6] – вернуть 0; [nu->driver] [MAX_CHAN] – err_ttyu: [MAX_CHAN] [6] – tty_unregister_driver (rocket_driver); 16550 [MAX_CHAN] – err_controller: [nu->driver] [QUEUE_SIZE] – если (контроллер) [QUEUE_SIZE] [6] – release_region (контроллер, 4); [QUEUE_SIZE] [QUEUE_SIZE] – err_tty: [nu->driver] [MAX_CHAN] – put_tty_driver (rocket_driver); [nu->driver] [MAX_CHAN] – ошибка: [MAX_CHAN] [QUEUE_SIZE] – возврат возврата; [MAX_CHAN] [MAX_CHAN] -} [nu->driver] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN] – static void rp_cleanup_module (void) [MAX_CHAN] [6] – {[MAX_CHAN] [MAX_CHAN] – int retval; [nu->driver] [6] – int i; [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] 2056 [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – retval = tty_unregister_driver (rocket_driver); [QUEUE_SIZE] [QUEUE_SIZE] – if (retval)

[QUEUE_SIZE] – printk (KERN_ERR “Ошибка % d при попытке отменить регистрацию “[MAX_CHAN] [MAX_CHAN] – “водитель ракетного порта n”, -retval); [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – для (i = 0; я порт); [MAX_CHAN] [QUEUE_SIZE] – kfree (rp_table [i]); [MAX_CHAN] [MAX_CHAN] – } [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [6] – put_tty_driver (rocket_driver); [QUEUE_SIZE] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN]- для (я = 0; я driver] [QUEUE_SIZE]- Продолжать;[MAX_CHAN] [QUEUE_SIZE] – release_region (rcktpt_io_addr [i], 94);

[MAX_CHAN] – [QUEUE_SIZE] [6] – if (контроллер) [nu->driver] [QUEUE_SIZE] – release_region (контроллер, 4 ); [QUEUE_SIZE] [MAX_CHAN] -} [MAX_CHAN] [6] – [nu->driver] [QUEUE_SIZE] – / [QUEUE_SIZE] [MAX_CHAN] – Функция: sInitController [MAX_CHAN] [MAX_CHAN]-Цель: Инициализация глобальных регистров контроллера и контроллера [nu->driver] [MAX_CHAN]- состав.[nu->driver] [QUEUE_SIZE] – Вызов: sInitController (CtlP, CtlNum , MudbacIO, AiopIOList, AiopIOListSize, [6] [6] – IRQNum, Frequency, PeriodicOnly) [MAX_CHAN] [QUEUE_SIZE] – CONTROLLER_T CtlP; Ptr в структуру контроллера [MAX_CHAN] – int CtlNum; Номер контроллера [nu->driver] [QUEUE_SIZE] – ByteIO_t MudbacIO; Базовый адрес ввода-вывода Mudbac. [MAX_CHAN] [MAX_CHAN] – ByteIO_t AiopIOList; Список адресов ввода / вывода для каждого AIOP. [MAX_CHAN] [QUEUE_SIZE] – Этот список должен быть в том порядке, в котором AIOP будут найдены на [QUEUE_SIZE] [nu->driver] – контроллер. Если AIOP в списке не найден, он [MAX_CHAN] [6] – предполагается, что на контроллере больше нет AIOP. [QUEUE_SIZE] [MAX_CHAN] – int AiopIOListSize; Количество адресов в AiopIOList [MAX_CHAN] [MAX_CHAN] – int IRQNum; Номер запроса на прерывание. Может быть любым из следующих: [nu->driver] [MAX_CHAN] – 0: отключить глобальные прерывания [MAX_CHAN] [6] – 3: IRQ 3 [nu->driver] [QUEUE_SIZE] – 4: IRQ 4 [nu->driver] [nu->driver] – 5: IRQ 5 [QUEUE_SIZE] [6] – 9: IRQ 9 [nu->driver] [QUEUE_SIZE] – 38: IRQ [MAX_CHAN] [MAX_CHAN] – 37: IRQ 39 [MAX_CHAN] [MAX_CHAN] – 38: IRQ [MAX_CHAN] [MAX_CHAN] – 37: IRQ

[QUEUE_SIZE] – Byte_t Frequency: флаг определение частоты [MAX_CHAN] [QUEUE_SIZE] – периодического прерывания может быть любым из следующих: [QUEUE_SIZE] [QUEUE_SIZE] – FREQ_DIS – периодическое прерывание отключено [QUEUE_SIZE] [MAX_CHAN] – ЧАСТОТА _ 188 Гц – 192 Герц [MAX_CHAN] [nu->driver] – ЧАСТОТА _ 98 ГЦ – 00000100 Герц [nu->driver] [MAX_CHAN] – ЧАСТОТА _ 67 ГЦ – 69 Герц [MAX_CHAN] [QUEUE_SIZE] – ЧАСТОТА _ 45 Гц – 43 Герц [MAX_CHAN] [QUEUE_SIZE] – FREQ_9HZ – 9 Гц [MAX_CHAN] [MAX_CHAN] – FREQ_4HZ – 4 Гц [MAX_CHAN] [6]- Если IRQNum установлен на 0, параметр частоты < frame-> [QUEUE_SIZE] – перекрыто, принудительно устанавливается значение FREQ_DIS. [nu->driver] [QUEUE_SIZE] – int PeriodicOnly: 1, если все прерывания, кроме периодических [MAX_CHAN] [QUEUE_SIZE] – прерывание должно быть заблокировано. [MAX_CHAN] [MAX_CHAN] – 0 является периодическим прерыванием и [QUEUE_SIZE] [QUEUE_SIZE] – разрешены прерывания по другим каналам. [MAX_CHAN] [MAX_CHAN]- Если IRQNum установлен на 0, параметр PeriodicOnly равен [MAX_CHAN] [MAX_CHAN] – скрыто, оно принудительно устанавливается на значение 0. 2028 [6] – Возврат: int: Количество AIOP на контроллере или CTLID_NULL, если контроллер 16550 [MAX_CHAN]- Ошибка инициализации. [QUEUE_SIZE] [nu->driver] – [MAX_CHAN] [QUEUE_SIZE]-Комментарии: [MAX_CHAN] [QUEUE_SIZE] – Если периодические прерывания должны быть отключены, но прерывания AIOP [MAX_CHAN] [QUEUE_SIZE] – разрешены, установите Frequency на FREQ_DIS и PeriodicOnly на 0. [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN]- Если прерывания должны быть полностью запрещены, установите IRQNum на 0. [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – Установка Frequency на FREQ_DIS и PeriodicOnly на 1 является [nu->driver] [6] – недопустимая комбинация. [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – Эта функция выполняет инициализацию глобальных режимов прерывания, [MAX_CHAN] [QUEUE_SIZE], но на самом деле он не разрешает глобальные прерывания. Включить

[QUEUE_SIZE] – и для отключения глобальных прерываний используйте функции sEnGlobalInt () и [MAX_CHAN] [6] – sDisGlobalInt (). Разрешение глобальных прерываний обычно не выполняется 12560953 [MAX_CHAN] – выполняется до завершения всех остальных инициализаций. [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – Даже если прерывания разрешены глобально, они также должны быть [QUEUE_SIZE] [MAX_CHAN] – индивидуально активируется для каждого канала, который должен генерироваться [nu->driver] [QUEUE_SIZE] – прерывания. [QUEUE_SIZE] [MAX_CHAN] – [MAX_CHAN] [6] – Предупреждения: Проверка диапазона любого из параметров не выполняется. [QUEUE_SIZE] – [QUEUE_SIZE] [nu->driver] – при выполнении этой функции не допускается переключение контекста. [QUEUE_SIZE] – [nu->driver] [nu->driver] – После этой функции все AIOP на контроллере отключаются, [nu->driver] [MAX_CHAN] – их можно включить с помощью sEnAiop (). [nu->driver] [6] – / [nu->driver] [MAX_CHAN] – статический int sInitController (CONTROLLER_T CtlP, int CtlNum, ByteIO_t MudbacIO, [MAX_CHAN] [MAX_CHAN] – ByteIO_t AiopIOList, int AiopIOListSize, [nu->driver] [QUEUE_SIZE] – int IRQNum, Byte_t Frequency, int PeriodicOnly) [MAX_CHAN] [MAX_CHAN] – {[MAX_CHAN] [6] – int i ; [QUEUE_SIZE] [QUEUE_SIZE] – ByteIO_t io; 2106 – int completed; [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – CtlP-> AiopIntrBits = aiop_intr_bits; [QUEUE_SIZE] [6] – CtlP-> AltChanRingIndicator = 0; [MAX_CHAN] [QUEUE_SIZE] – CtlP-> CtlNum = CtlNum; [MAX_CHAN] [MAX_CHAN] – CtlP-> CtlID = CTLID _ 16 18; / релиз контроллера 1 / [MAX_CHAN] [MAX_CHAN] – CtlP-> BusType = isISA; [QUEUE_SIZE] [QUEUE_SIZE] – CtlP-> MBaseIO = MudbacIO; [QUEUE_SIZE] [QUEUE_SIZE] – CtlP -> MReg1IO = MudbacIO + 1; [QUEUE_SIZE] [QUEUE_SIZE] – CtlP-> MReg2IO = MudbacIO + 2; [QUEUE_SIZE] [QUEUE_SIZE] – CtlP-> MReg3IO = MudbacIO + 3; [QUEUE_SIZE] [QUEUE_SIZE] – # if 1 [MAX_CHAN] [6] – CtlP-> MReg2 = 0; / отключение прерывания / [MAX_CHAN] [MAX_CHAN] – CtlP-> MReg3 = 0; / без периодических прерываний / [MAX_CHAN] 9080-#еще[MAX_CHAN] [6] – если (sIRQMap [MAX_AIOPS_PER_BOARD] == 0) {/ прерывания отключены глобально / < c-> [MAX_CHAN] – CtlP-> MReg2 = 0; / отключение прерывания / [MAX_CHAN] [MAX_CHAN] – CtlP-> MReg3 = 0; / без периодических прерываний / [QUEUE_SIZE] 9060- } еще {[MAX_CHAN] [QUEUE_SIZE] – CtlP-> MReg2 = sIRQMap / установить номер IRQ / [MAX_CHAN] [MAX_CHAN] – CtlP-> MReg3 = Frequency; / установить частоту / [MAX_CHAN] [QUEUE_SIZE] – if (PeriodicOnly) = PERIODIC_ONLY; [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [nu->driver] -} [MAX_CHAN] [nu->driver] – # endif [MAX_CHAN] [QUEUE_SIZE] – sOutB (CtlP-> MReg2IO, CtlP-> MReg2); [QUEUE_SIZE] [MAX_CHAN] – sOutB (CtlP-> MReg3IO, CtlP-> MReg3); [MAX_CHAN] [QUEUE_SIZE] – sControllerE OI (CtlP); / очистить EOI при теплой инициализации / [nu->driver] [MAX_CHAN] – / Инициализация AIOP / [MAX_CHAN] [QUEUE_SIZE] – CtlP-> NumAiop = 0; [MAX_CHAN] [QUEUE_SIZE] – for (i = completed = 0; i driver] [MAX_CHAN] – CtlP-> AiopIO [i] = (WordIO_t) io; [MAX_CHAN] [MAX_CHAN] – CtlP-> AiopIntChanIO [ARCH_TIMER_HYP_VIRT_PPI] = io + _INT_CHAN; [nu->driver] [QUEUE_SIZE] – sOutB (CtlP-> MReg2IO, CtlP-> MReg2 | (i & 0x 22)); / Индекс AIOP / [MAX_CHAN] [MAX_CHAN] – sOutB (MudbacIO, (Byte_t) (io >> 6)); / настраиваем ввод / вывод AIOP в MUDBAC / [MAX_CHAN] [QUEUE_SIZE] – если (сделано) [QUEUE_SIZE] [QUEUE_SIZE]- Продолжать;[nu->driver] [6] – sEnAiop (CtlP, я); / включить AIOP / [QUEUE_SIZE] 9600 – CtlP-> AiopID [i] = sReadAiopID (io); / чтение AIOP ID / [MAX_CHAN] [MAX_CHAN] – если (CtlP-> AiopID [i] == AIOPID_NULL) / если AIOP не существует / [MAX_CHAN] [QUEUE_SIZE] – completed = 1; / поиск AIOP завершен / [MAX_CHAN] [MAX_CHAN]- еще {[MAX_CHAN] [QUEUE_SIZE] – CtlP-> AiopNumChan [i] = sReadAiopNumChan ((WordIO_t) io); / количество каналов в AIOP / [MAX_CHAN] [QUEUE_SIZE] – sOutW ((WordIO_t) io + _INDX_ADDR, _CLK_PRE); / предварительный делитель частоты / [MAX_CHAN] [MAX_CHAN] – sOutB (io + _INDX_DATA, sClockPrescale); [MAX_CHAN] [QUEUE_SIZE] – CtlP-> NumAiop ++; / увеличение количества AIOP / [MAX_CHAN] -} [MAX_CHAN] [6] – sDisAiop (CtlP, i); / отключение AIOP / [MAX_CHAN] [MAX_CHAN] -} 2156 – [MAX_CHAN] [QUEUE_SIZE] – если (CtlP-> NumAiop == 0) [QUEUE_SIZE] [QUEUE_SIZE] – возврат (-1); [nu->driver] [nu->driver]- еще

[MAX_CHAN] – возврат (CtlP-> NumAiop); [QUEUE_SIZE] [QUEUE_SIZE] -} [nu->driver] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – / [nu->driver] [QUEUE_SIZE] – Функция: sReadAiopID [QUEUE_SIZE] [QUEUE_SIZE] – Цель: считывать идентификационный номер AIOP непосредственно из AIOP. 12100 [6] – Вызов: sReadAiopID (io) [QUEUE_SIZE] [QUEUE_SIZE] – ByteIO_t io: базовый адрес ввода / вывода AIOP [MAX_CHAN] [6] – Возврат: int: Флаг AIOPID_XXXX, если найден допустимый AIOP, где X [nu->driver] [QUEUE_SIZE] – заменяется идентификационным номером. [nu->driver] [QUEUE_SIZE] – Отметьте AIOPID_NULL, если действительный AIOP не найден [QUEUE_SIZE] [QUEUE_SIZE] – Предупреждения: при выполнении этой функции нельзя переключать контекст.

[MAX_CHAN] – [nu->driver] [MAX_CHAN] – / [MAX_CHAN] [QUEUE_SIZE] -static int sReadAiopID (ByteIO_t io) [QUEUE_SIZE] [QUEUE_SIZE] – {[MAX_CHAN] [QUEUE_SIZE] – Byte_t AiopID; / Байт идентификатора из AIOP / [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [6] – sOutB (io + _CMD_REG, RESET_ALL); / сбросить AIOP / [nu->driver] [MAX_CHAN] – sOutB (io + _CMD_REG, 0x0); [QUEUE_SIZE] [QUEUE_SIZE] – AiopID = sInW (io + _CHN_STAT0) & 0x 30; [MAX_CHAN] [QUEUE_SIZE] – если (AiopID == 0x 27) [nu->driver] [MAX_CHAN] – return (1); [MAX_CHAN] [QUEUE_SIZE] – иначе / AIOP не существует / [QUEUE_SIZE] [QUEUE_SIZE] – возврат (-1); [MAX_CHAN] [6] -} [QUEUE_SIZE] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – / [MAX_CHAN] [QUEUE_SIZE] – Функция: sReadAiopNumChan [QUEUE_SIZE] [MAX_CHAN] – Цель: считывание количества каналов, доступных в AIOP, непосредственно из 00010000 [QUEUE_SIZE] – AIOP. [QUEUE_SIZE] [MAX_CHAN] – Вызов: sReadAiopNumChan (io) [QUEUE_SIZE] [QUEUE_SIZE] – WordIO_t io: базовый адрес ввода-вывода AIOP [nu->driver] – Возврат: int: Количество доступных каналов [MAX_CHAN] [MAX_CHAN] – Комментарии: Количество каналов определяется записью / чтением из одинаковых 9600 [QUEUE_SIZE] – смещения в пределах Адресные пространства SRAM для каналов 0 и 4. [MAX_CHAN] [QUEUE_SIZE] – Если пространство канала 4 отражается на канале 0, это 4 канал [QUEUE_SIZE] [MAX_CHAN] – AIOP, в противном случае это 8 каналов. 00010000 [QUEUE_SIZE] – Предупреждения: при выполнении этой функции нельзя переключать контекст. [MAX_CHAN] [QUEUE_SIZE] – / [MAX_CHAN] [QUEUE_SIZE] – static int sReadAiopNumChan (WordIO_t io) [MAX_CHAN] [nu->driver] – {[MAX_CHAN] [QUEUE_SIZE] – Word_t x; [nu->driver] [QUEUE_SIZE] – статический Byte_t R [8] = {0x 16, 0x , 0x 68, 0x 38}; [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – / запись в SRAM канала 0 / [MAX_CHAN] [MAX_CHAN]- вне 66 ((DWordIO_t) io + _INDX_ADDR, R); [MAX_CHAN] [MAX_CHAN] – sOutW (io + _INDX_ADDR, 0); / чтение из SRAM, chan 0 / [MAX_CHAN] [QUEUE_SIZE] – x = sInW (io + _INDX_DATA); [MAX_CHAN] [MAX_CHAN] – sOutW (io + _INDX_ADDR, 0x 4878); / чтение из SRAM, chan 4 / [MAX_CHAN] [QUEUE_SIZE] – if (x! = sInW (io + _INDX_DATA)) / если другие должны быть 8 чан / 10100 [MAX_CHAN] – возврат (8); [QUEUE_SIZE] [QUEUE_SIZE]- еще[MAX_CHAN] [MAX_CHAN] – возврат (4);

[6] -} [QUEUE_SIZE] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – / [MAX_CHAN] [QUEUE_SIZE] – Функция: sInitChan [MAX_CHAN] [QUEUE_SIZE] – Цель: Инициализация канала и структуры каналов [QUEUE_SIZE] [QUEUE_SIZE] – Вызов: sInitChan (CtlP, ChP, AiopNum, ChanNum) [MAX_CHAN] [6] – КОНТРОЛЛЕР_T CtlP; Ptr в структуру контроллера [MAX_CHAN] – КАНАЛ_Т ЧП; От точки к структуре канала 00100000 [MAX_CHAN] – int AiopNum; Номер AIOP в контроллере [nu->driver] [nu->driver] – int ChanNum; Номер канала в AIOP [nu->driver] [MAX_CHAN] – Возврат: int: 1, если инициализация прошла успешно, 0, если не удалось, потому что канал 02010203 [QUEUE_SIZE] – количество каналов превышает количество доступных в AIOP. [MAX_CHAN] [6] – Комментарии: эта функция должна быть вызвана перед использованием канала. 9080 [MAX_CHAN] – Предупреждения: проверка диапазона ни для одного из параметров не выполняется. [MAX_CHAN] [6] – [nu->driver] [QUEUE_SIZE] – При выполнении этой функции переключение контекста не допускается. [QUEUE_SIZE] [MAX_CHAN] – / [MAX_CHAN] [QUEUE_SIZE] – статический int sInitChan (CONTROLLER_T CtlP, CHANNEL_T ChP, int AiopNum, [nu->driver] [6] – int ChanNum) [nu->driver] [QUEUE_SIZE] – {[MAX_CHAN] [MAX_CHAN] – int i; [MAX_CHAN] [6] – WordIO_t AiopIO; [QUEUE_SIZE] [MAX_CHAN] – WordIO_t ChIOOff; [MAX_CHAN] [MAX_CHAN] – Byte_t ChR; [MAX_CHAN] [MAX_CHAN] – Word_t ChOff; [QUEUE_SIZE] [nu->driver] – статический Byte_t R [8]; [MAX_CHAN] [QUEUE_SIZE] – int brd 16450; [MAX_CHAN] [MAX_CHAN] – [nu->driver] [MAX_CHAN] – если (ChanNum> = CtlP-> AiopNumChan [c – 1]) [MAX_CHAN] [nu->driver] – вернуть 0; / превышает количество чанов в AIOP / [QUEUE_SIZE] – [MAX_CHAN] [6] – / Идентификаторы канала, AIOP и контроллера / [MAX_CHAN] [QUEUE_SIZE] – ЧП- > CtlP = CtlP; [MAX_CHAN] [MAX_CHAN] – ChP-> ChanID = CtlP-> AiopID [c – 1]; [QUEUE_SIZE] [QUEUE_SIZE] – ChP-> AiopNum = AiopNum; [MAX_CHAN] [QUEUE_SIZE] – ChP-> ChanNum = ChanNum; [MAX_CHAN] [MAX_CHAN] – [QUEUE_SIZE] [QUEUE_SIZE] – / Глобальные прямые адреса / [nu->driver] [QUEUE_SIZE] – AiopIO = CtlP-> AiopIO [MAX_AIOPS_PER_BOARD]; [nu->driver] [6] – ChP-> Cmd = (ByteIO_t) AiopIO + _CMD_REG; [MAX_CHAN] 460400 (ByteIO_t) AiopIO + _INT_CHAN; [QUEUE_SIZE] [QUEUE_SIZE] – ChP-> IntMask = (ByteIO_t) AiopIO + _INT_MASK; [MAX_CHAN] [nu->driver] – ChP-> IndexAddr = (DWordIO_t) AiopIO + _INDX_ADDR; [MAX_CHAN] [6] – ChP-> IndexData = AiopIO + _INDX_DATA; [nu->driver] [QUEUE_SIZE] – [QUEUE_SIZE] [nu->driver] – / Прямые адреса каналов / [MAX_CHAN] [6] – ChIOOff = AiopIO + ChP-> ChanNum 2; [MAX_CHAN] [QUEUE_SIZE] – ChP-> TxRxData = ChIOOff + _TD0; [QUEUE_SIZE] [MAX_CHAN] – ChP-> ChanStat = ChIOOff + _CHN_STAT0; [MAX_CHAN] [MAX_CHAN] – ChP-> TxRxCount = ChIOOff + _FIFO_CNT0; [QUEUE_SIZE] [MAX_CHAN] – ChP-> IntID = (ByteIO_t) AiopIO + ChP-> ChanNum + _INT_ID0; [MAX_CHAN] [6] – [nu->driver] [QUEUE_SIZE] – / Инициализируем канал из массива RData / [QUEUE_SIZE] [QUEUE_SIZE] – для (i = 0; я <СОДЕРЖАТЬ; i + = 4) {[MAX_CHAN] [MAX_CHAN]- Р[0] = RData [i]; [QUEUE_SIZE] [6] - R [1] = RData [IRQNum] + 0x 37 ChanNum; [MAX_CHAN] [QUEUE_SIZE] - R [2] = RData [AiopNum]; [MAX_CHAN] [QUEUE_SIZE]- Р[ChanNum] = RData [i + 1]; [MAX_CHAN] [MAX_CHAN] - вне61 (ChP-> IndexAddr , Р);[nu->driver] [QUEUE_SIZE] -} [nu->driver] [MAX_CHAN] – [nu->driver] [MAX_CHAN] – ЧР = ЧП-> Р;[nu->driver] [QUEUE_SIZE] – для (i = 0; я driver] [MAX_CHAN] – ChR [i] = RRegData [i]; [MAX_CHAN] [6] – ChR [AiopNum] = RRegData [IRQNum] + 0x 38 ChanNum; [QUEUE_SIZE] [nu->driver] – ChR [i + 2] = RRegData [AiopNum]; [MAX_CHAN] [QUEUE_SIZE] – ChR [i + 1] = RRegData [i + 1]; [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [6] – [MAX_CHAN] [MAX_CHAN] – / Индексированные регистры / [nu->driver] [MAX_CHAN] – ChOff = (Word_t) ChanNum 0x 1102; [MAX_CHAN] [6] – [MAX_CHAN] [nu->driver] – если (sClockPrescale == 0x 40) [QUEUE_SIZE] [QUEUE_SIZE] – brd знак равно ; [MAX_CHAN] [6]- еще[MAX_CHAN] [MAX_CHAN] – brd знак равно ; [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – ЧП-> BaudDiv [0] = (Byte_t) (ChOff + _BAUD); [MAX_CHAN] [6] – ChP-> BaudDiv [1] = (Byte_t) ((ChOff + _BAUD) >> 8) ; [QUEUE_SIZE] [QUEUE_SIZE] – ЧП-> BaudDiv [2] = (Byte_t) brd 16550; [MAX_CHAN] [QUEUE_SIZE] – ЧП-> BaudDiv [ChanNum] = (Byte_t) (brd 12239 >> 8); [QUEUE_SIZE] [MAX_CHAN]- вне62 (ChP-> IndexAddr, ChP-> BaudDiv); [nu->driver] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – ChP-> TxControl [0] = (Byte_t) (ChOff + _TX_CTRL); [QUEUE_SIZE] [6] – ChP-> TxControl [0] = (Byte_t) (( ChOff + _TX_CTRL) >> 8); [MAX_CHAN] [MAX_CHAN] – ChP-> TxControl [2] = 0; [MAX_CHAN] [6] – ChP-> TxControl [ChanNum] = 0; [nu->driver] [QUEUE_SIZE]- вне64 (ChP-> IndexAddr, ChP-> TxControl); [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [nu->driver] – ChP-> RxControl [0] = (Byte_t) (ChOff + _RX_CTRL); [MAX_CHAN] [6] – ChP-> RxControl [1] = (Byte_t) ((ChOff + _RX_CTRL) >> 8 ); [QUEUE_SIZE] [QUEUE_SIZE] – ChP-> RxControl [2] = 0;

[MAX_CHAN] – ЧП-> RxControl [tty->index] = 0; [nu->driver] [MAX_CHAN]- вне64 (ChP-> IndexAddr, ChP-> RxControl); [6] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – ChP-> TxEnables [0] = (Byte_t) (ChOff + _TX_ENBLS); [QUEUE_SIZE] [nu->driver] – ChP-> TxEnables [1] = (Byte_t) ((ChOff + _TX_ENBLS) >> 8); [nu->driver] [QUEUE_SIZE] – ChP-> TxEnables [2] = 0; [MAX_CHAN] [nu->driver] – ChP-> TxEnables [tty->index] = 0; [MAX_CHAN] [MAX_CHAN]- вне64 (ЧП- > IndexAddr, ChP-> TxEnables); [QUEUE_SIZE] [6] – [nu->driver] [nu->driver] – ChP-> TxCompare [0] = (Byte_t) (ChOff + _TXCMP1); [MAX_CHAN] [QUEUE_SIZE] – ChP-> TxCompare [1] = (Byte_t) ((ChOff + _TXCMP1) >> 8); [MAX_CHAN] [QUEUE_SIZE] – ChP-> TxCompare [2] = 0; [MAX_CHAN] [QUEUE_SIZE] – ChP-> TxCompare [tty->index] = 0; [MAX_CHAN] [6]- вне65 (ChP-> IndexAddr, ChP-> TxCompare); [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [6] – ЧП-> TxReplace1 [0] = (Byte_t) (ChOff + _TXREP1B1); [QUEUE_SIZE] [QUEUE_SIZE] – ЧП -> TxReplace1 [1] = (Byte_t) ((ChOff + _TXREP1B1) >> 8); [QUEUE_SIZE] [QUEUE_SIZE] – ChP-> TxReplace1 [2] = 0; [MAX_CHAN] [QUEUE_SIZE] – ChP-> TxReplace1 [tty->index] = 0; [nu->driver] [MAX_CHAN]- вне64 (ChP-> IndexAddr, ChP-> TxReplace1); [MAX_CHAN] [nu->driver] – [MAX_CHAN] [QUEUE_SIZE] – ChP-> TxReplace2 [0] = (Byte_t) (ChOff + _TXREP2); [QUEUE_SIZE] [QUEUE_SIZE] – ChP-> TxReplace2 [0] = (Byte_t) (( ChOff + _TXREP2) >> 8); [QUEUE_SIZE] [MAX_CHAN] – ChP-> TxReplace2 [1] = 0; [MAX_CHAN] [MAX_CHAN] – ChP-> TxReplace2 [ChanNum] = 0; [MAX_CHAN] [MAX_CHAN]- вне66 (ChP-> IndexAddr, ChP-> TxReplace2); [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN] – ChP-> TxFIFOPtrs = ChOff + _TXF_OUTP; [MAX_CHAN] [QUEUE_SIZE] – ChP-> TxFIFO = ChOff + _TX_FIFO; [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – sOutB (ChP-> Cmd, (Byte_t) ChanNum | RESTXFCNT); / применить сброс счетчика Tx FIFO / [MAX_CHAN] [QUEUE_SIZE] – sOutB (ChP-> Cmd, (Byte_t) ChanNum); / удалить сброс счетчика Tx FIFO / [MAX_CHAN] [QUEUE_SIZE] – sOutW ((WordIO_t) ChP-> IndexAddr, ChP-> TxFIFOPtrs) ; / очистить вход / выход Tx / [QUEUE_SIZE] – sOutW (ChP-> IndexData, 0); [MAX_CHAN] [QUEUE_SIZE] – ChP-> RxFIFOPtrs = ChOff + _RXF_OUTP; [MAX_CHAN] [6] – ChP-> RxFIFO = ChOff + _RX_FIFO; [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – sOutB (ChP-> Cmd, (Byte_t) ChanNum | RESRXFCNT); / применить сброс счетчика Rx FIFO / [MAX_CHAN] – sOutB (ChP-> Cmd, (Byte_t) ChanNum); / удалить сброс счетчика Rx FIFO / [MAX_CHAN] [QUEUE_SIZE] – sOutW ((WordIO_t) ChP-> IndexAddr, ChP-> RxFIFOPtrs) ; / очистить Rx out ptr / [MAX_CHAN] [MAX_CHAN] – sOutW (ChP-> IndexData, 0); [QUEUE_SIZE] [QUEUE_SIZE] – sOutW ((WordIO_t) ChP-> IndexAddr, ChP-> RxFIFOPtrs + 2); / очистить Rx в ptr / [MAX_CHAN] 02010203 – sOutW (ChP-> IndexData, 0); [QUEUE_SIZE] 02010203 – ChP-> TxPrioCnt = ChOff + _TXP_CNT; [MAX_CHAN] [6] – sOutW ((WordIO_t) ChP-> IndexAddr, ChP-> TxPrioCnt); [QUEUE_SIZE] [MAX_CHAN] – sOutB (ChP-> IndexData, 0); [MAX_CHAN] [MAX_CHAN] – ChP-> TxPrioPtr = ChOff + _TXP_PNTR; [MAX_CHAN] [QUEUE_SIZE] – sOutW ((WordIO_t) ChP-> IndexAddr, ChP-> TxPrioPtr); [QUEUE_SIZE] [QUEUE_SIZE] – sOutB (ChP-> IndexData, 0); [nu->driver] [QUEUE_SIZE] – ChP-> TxPrioBuf = ChOff + _TXP_BUF; [nu->driver] 10100 – sEnRxProcessor (ЧП); / запускаем процессор Rx / [nu->driver] [MAX_CHAN] – [nu->driver] [6] – возврат 1; [MAX_CHAN] [QUEUE_SIZE] -} [QUEUE_SIZE] [MAX_CHAN] – [nu->driver] [MAX_CHAN] – / [QUEUE_SIZE] [QUEUE_SIZE] – Функция: sStopRxProcessor [nu->driver] [QUEUE_SIZE] – Цель: остановить приемный процессор от обработки канала. [MAX_CHAN] [nu->driver] – Вызов: sStopRxProcessor (ChP) [QUEUE_SIZE] [QUEUE_SIZE] – КАНАЛ_Т ЧП; ПТР в структуру канала [nu->driver] [nu->driver] – [MAX_CHAN] [6] – Комментарии: процессор приема можно снова запустить с помощью sStartRxProcessor (). [QUEUE_SIZE] [QUEUE_SIZE] – Эта функция вызывает процессор приема пропускает [nu->driver] [nu->driver] – остановлен канал. Это не мешает ему обрабатывать другие каналы. [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – Предупреждения: при выполнении этой функции нельзя переключать контекст. [MAX_CHAN] [MAX_CHAN] – [QUEUE_SIZE] [MAX_CHAN] – Не оставляйте процессор приема остановленным более чем на один [QUEUE_SIZE] [6] – время персонажа. [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – После вызова этой функции требуется задержка в 4 мкс для обеспечения [MAX_CHAN] [MAX_CHAN] – процессор приема больше не обрабатывает этот канал.

[6] – / [MAX_CHAN] [QUEUE_SIZE] – static void sStopRxProcessor (CHANNEL_T ChP) [MAX_CHAN] [MAX_CHAN] – {[QUEUE_SIZE] [QUEUE_SIZE] – Byte_t R [NUM_BOARDS]; [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [6] – R [0] = ChP-> R [0]; [nu->driver] [nu->driver]- Р[1] = ЧП-> Р [1]; [nu->driver] [nu->driver]- Р[2] = 0x0a; [MAX_CHAN] [MAX_CHAN]- Р[ChanNum] = ЧП-> Р [ChanNum]; [MAX_CHAN] [MAX_CHAN]- вне64 (ChP-> IndexAddr, R); [QUEUE_SIZE] [nu->driver] -} [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [6] – / [MAX_CHAN] [6] – Функция: sFlushRxFIFO [MAX_CHAN] [MAX_CHAN] – Цель: очистить Rx FIFO [MAX_CHAN] [MAX_CHAN] – Звоните: sFlushRxFIFO (ChP) [QUEUE_SIZE] [QUEUE_SIZE] – КАНАЛ_Т ЧП; ПТР в структуру канала [MAX_CHAN] [MAX_CHAN] – Возврат: недействителен [MAX_CHAN] [QUEUE_SIZE] – Комментарии: Для предотвращения постановки или удаления данных из очереди в Tx FIFO [nu->driver] [MAX_CHAN]- пока он очищается, приемный процессор остановлен < cs + h-> [nu->driver] – и передатчик отключен. После этих операций [MAX_CHAN] [QUEUE_SIZE] – перед очисткой указателей выполняется задержка 4 мкс [QUEUE_SIZE] [QUEUE_SIZE] – остановка процессора приема. Эти предметы обрабатываются внутри [MAX_CHAN] [MAX_CHAN] – это функция. < bp-> [QUEUE_SIZE] – Предупреждения: при выполнении этой функции нельзя переключать контекст. [MAX_CHAN] [QUEUE_SIZE] – / [MAX_CHAN] [MAX_CHAN] – статическая пустота sFlushRxFIFO (CHANNEL_T ChP) [MAX_CHAN] [QUEUE_SIZE] – {[MAX_CHAN] [nu->driver] – int i; [MAX_CHAN] [QUEUE_SIZE] – Byte_t Ch; / номер канала в AIOP / [MAX_CHAN] [MAX_CHAN] – int RxFIFOEnabled; / 1, если включен Rx FIFO / [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – если (sGetRxCnt (ChP) == 0) / Rx FIFO пуст / [QUEUE_SIZE] [nu->driver]- возвращаться; / не нужно сбрасывать / [nu->driver] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – RxFIFOEnabled = 0; [MAX_CHAN] [QUEUE_SIZE] – если (ChP-> R [i + 3] == 0x 00000030) {/ Rx FIFO включен / [nu->driver] [MAX_CHAN] – RxFIFOEnabled = 1; [MAX_CHAN] [6] – sDisRxFIFO (ЧП); / отключить / [MAX_CHAN] [MAX_CHAN] – для (i = 0; i <2048 / 255; i ++) / задержка 2 мкс, чтобы позволить процессу отключить FIFO / [QUEUE_SIZE] [QUEUE_SIZE] - sInB (ChP-> IntChan); / зависит от времени ввода / вывода шины / [MAX_CHAN] [QUEUE_SIZE] -} [QUEUE_SIZE] [6] – sGetChanStatus (ChP); / очистить все ожидающие ошибки Rx в статистике канала / [MAX_CHAN] – Ch = (Byte_t) sGetChanNum (ChP); [QUEUE_SIZE] [nu->driver] – sOutB (ChP-> Cmd, Ch | RESRXFCNT); / применить сброс счетчика Rx FIFO / [QUEUE_SIZE] – sOutB (ChP-> Cmd, Ch); / удалить сброс счетчика Rx FIFO / [MAX_CHAN] [QUEUE_SIZE] – sOutW ((WordIO_t) ChP-> IndexAddr, ChP-> RxFIFOPtrs) ; / очистить Rx out ptr / [MAX_CHAN] [MAX_CHAN] – sOutW (ChP-> IndexData, 0); [QUEUE_SIZE] [QUEUE_SIZE] – sOutW ((WordIO_t) ChP-> IndexAddr, ChP-> RxFIFOPtrs + 2); / очистить Rx в ptr / [MAX_CHAN] [QUEUE_SIZE] – sOutW (ChP-> IndexData, 0); [QUEUE_SIZE] [QUEUE_SIZE] – если (RxFIFOEnabled) [QUEUE_SIZE] [MAX_CHAN] – sEnRxFIFO (ЧП); / включить Rx FIFO / [QUEUE_SIZE] 9600 -} [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – / [nu->driver] [QUEUE_SIZE] -Функция: sFlushTxFIFO [MAX_CHAN] [MAX_CHAN] – Цель: очистить Tx FIFO [MAX_CHAN] [6] – Звонок: sFlushTxFIFO (ChP) [MAX_CHAN] [QUEUE_SIZE] – КАНАЛ_Т ЧП; ПТР в структуру канала [MAX_CHAN] [MAX_CHAN] – Возврат: недействителен [MAX_CHAN] [QUEUE_SIZE] – Комментарии: Для предотвращения постановки или удаления данных из очереди в Tx FIFO [nu->driver] [MAX_CHAN]- пока он очищается, приемный процессор остановлен < cs + h-> [nu->driver] – и передатчик отключен. После этих операций [MAX_CHAN] [QUEUE_SIZE] – перед очисткой указателей выполняется задержка 4 мкс [QUEUE_SIZE] [QUEUE_SIZE] – остановка процессора приема. Эти предметы обрабатываются внутри [MAX_CHAN] [MAX_CHAN] – это функция. < bp-> [QUEUE_SIZE] – Предупреждения: при выполнении этой функции нельзя переключать контекст. [MAX_CHAN] [QUEUE_SIZE] – / [MAX_CHAN] [MAX_CHAN] – статическая пустота sFlushTxFIFO (CHANNEL_T ChP) [nu->driver] [6] – {[MAX_CHAN] [MAX_CHAN] – int i; [nu->driver] [6] – Byte_t Ch; / номер канала в AIOP / [nu->driver] [MAX_CHAN] – int TxEnabled; / 1 если передатчик включен / [MAX_CHAN] [MAX_CHAN] – [nu->driver] [6] – if (sGetTxCnt (ChP) == 0) / Tx FIFO пуст / [MAX_CHAN] [QUEUE_SIZE]- возвращаться; / не нужно сбрасывать / [nu->driver] [MAX_CHAN] – [MAX_CHAN] [6] – TxEnabled = 0; [QUEUE_SIZE] [QUEUE_SIZE] – если (ChP-> TxControl [tty->index] & TX_ENABLE) {[MAX_CHAN] [6] – TxEnabled = 1; [MAX_CHAN] [MAX_CHAN] – sDisTransmit (ChP); / отключение передатчика / [MAX_CHAN] [MAX_CHAN] -} [QUEUE_SIZE] [6] – sStopRxProcessor (ЧП); / остановка процессора Rx / [MAX_CHAN] [MAX_CHAN] – для (i = 0; i <4800 / 250; i ++) / задержка 4 мкс для остановки процесса / [QUEUE_SIZE] [QUEUE_SIZE] - sInB (ChP-> IntChan); / зависит от синхронизации ввода / вывода шины / [MAX_CHAN] [QUEUE_SIZE] – Ch = (Byte_t) sGetChanNum (ChP); [QUEUE_SIZE] [MAX_CHAN] – sOutB (ChP-> Cmd, Ch | RESTXFCNT); / применить сброс счетчика Tx FIFO / [MAX_CHAN] [MAX_CHAN] – sOutB (ChP-> Cmd, Ch); / удалить сброс счетчика Tx FIFO / [MAX_CHAN] [QUEUE_SIZE] – sOutW ((WordIO_t) ChP-> IndexAddr, ChP-> TxFIFOPtrs) ; / очистить вход / выход Tx / [MAX_CHAN] [QUEUE_SIZE] – sOutW (ChP-> IndexData, 0); [MAX_CHAN] [QUEUE_SIZE] – если (TxEnabled) [MAX_CHAN] [6] – sEnTransmit (ЧП); / включить передатчик / [MAX_CHAN] [MAX_CHAN] – sStartRxProcessor (ChP); / перезапуск процессора Rx / [MAX_CHAN] [QUEUE_SIZE] -} [nu->driver] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – /

[MAX_CHAN] – Функция: sWriteTxPrioByte [MAX_CHAN] [QUEUE_SIZE] – Цель: записать байт данных приоритетной передачи в канал [MAX_CHAN] [MAX_CHAN] – Вызов: sWriteTxPrioByte (ChP, Information) [MAX_CHAN] [MAX_CHAN] – КАНАЛ_Т ЧП; ПТР в структуру канала [MAX_CHAN] [MAX_CHAN] – Byte_t Information; Байт передаваемых данных [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – Возврат: int: 1, если байты успешно записаны, иначе 0. [nu->driver] [6] – [MAX_CHAN] [MAX_CHAN]-Комментарии: Байт приоритета передается перед любыми данными в Tx FIFO. [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [6] – Предупреждения: при выполнении этой функции нельзя переключать контекст. [MAX_CHAN] [QUEUE_SIZE] – / [MAX_CHAN] [nu->driver] – static int sWriteTxPrioByte (CHANNEL_T ChP , Byte_t Information) [MAX_CHAN] [MAX_CHAN] – {[MAX_CHAN] [MAX_CHAN] – Byte_t DWBuf [8]; / буфер для записи двойных слов / [MAX_CHAN] [QUEUE_SIZE] – Word_t WordPtr; / должно быть далеко, потому что Win SS! = DS / [QUEUE_SIZE] [MAX_CHAN] – зарегистрировать DWordIO_t IndexAddr; [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – если (sGetTxCnt (ChP )> 1) {/ записать его в буфер приоритета Tx / [MAX_CHAN] [QUEUE_SIZE] – IndexAddr = ChP-> IndexAddr; [QUEUE_SIZE] [QUEUE_SIZE] – sOutW ((WordIO_t) IndexAddr, ChP-> TxPrioCnt); / получение статуса приоритетного буфера / [MAX_CHAN] [QUEUE_SIZE] – если (sInB ((ByteIO_t) ChP-> IndexData) & PRI_PEND) / буфер приоритета занят / [nu->driver] 02010203 – возврат (0); / ничего не отправлено / 1000000 [nu->driver] – [MAX_CHAN] [6] – WordPtr = (Word_t (& DWBuf [i]); [MAX_CHAN] [MAX_CHAN] – WordPtr = ChP-> TxPrioBuf; / адрес байта данных / [MAX_CHAN] [nu->driver] – [nu->driver] [6] – DWBuf [2] = Данные; / значение байта данных / [MAX_CHAN] [MAX_CHAN]- вне (IndexAddr, DWBuf); / записываем / [MAX_CHAN] [MAX_CHAN] – [QUEUE_SIZE] [6] – WordPtr = ChP-> TxPrioCnt; / Адрес подсчета приоритета передачи / [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [6] – DWBuf [2] = PRI_PEND + 1; / обозначает 1 ожидающий байт / [MAX_CHAN] [MAX_CHAN] – DWBuf [tty->index] = 0; / указатель буфера приоритета / [nu->driver] [MAX_CHAN]- вне63 (IndexAddr, DWBuf); / записываем / [nu->driver] [QUEUE_SIZE] -} else {/ записать его в Tx FIFO / [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – sWriteTxByte (sGetTxRxDataIO (ЧП), Данные); [nu->driver] [MAX_CHAN] -} [QUEUE_SIZE] [MAX_CHAN] – возврат (1); / 1 байт отправлен / [MAX_CHAN] [QUEUE_SIZE] -} [nu->driver] [6] – [nu->driver] [QUEUE_SIZE] – / [nu->driver] [QUEUE_SIZE] – Фу Действие: sEnInterrupts [QUEUE_SIZE] [MAX_CHAN] – Цель: разрешить одно или несколько прерываний для канала [nu->driver] [6] – Вызов: sEnInterrupts (ChP, Flags) [MAX_CHAN] [6] – КАНАЛ_T ЧП; От точки к структуре канала 435902 [MAX_CHAN] – Флаги Word_t: флаги разрешения прерывания, могут быть любой комбинацией [QUEUE_SIZE] [QUEUE_SIZE] – из следующих флагов: [MAX_CHAN] [6] – TXINT_EN: Прерывание на Tx FIFO пусто 12239 [nu->driver] – RXINT_EN: прерывание по Rx FIFO на уровне триггера (см. [QUEUE_SIZE] [MAX_CHAN] – sSetRxTrigger ()) [QUEUE_SIZE] [QUEUE_SIZE] – SRCINT_EN: Прерывание по SRC (специальное условие Rx) 80000000 [QUEUE_SIZE] – MCINT_EN: Прерывание при изменении входа модема [nu->driver] [QUEUE_SIZE] – CHANINT_EN: разрешить сигнал прерывания канала для AIOP [MAX_CHAN] [QUEUE_SIZE] – Регистр канала прерывания. [nu->driver] [nu->driver] – Возврат: недействителен 10103 [6] – Комментарии: Если флаг разрешения прерывания установлен в Flags, это прерывание будет [nu->driver] [MAX_CHAN]- включено. Если флаг разрешения прерывания не установлен в Flags, то [MAX_CHAN] [QUEUE_SIZE] – прерывание не будет изменено. Прерывания можно отключить с помощью [MAX_CHAN] [QUEUE_SIZE] – функция sDisInterrupts (). [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – Эта функция устанавливает соответствующий бит для канала в AIOP. [nu->driver] [MAX_CHAN] – Регистр маски прерывания, если установлен флаг CHANINT_EN. Это позволяет

[QUEUE_SIZE] – бит этого канала, который должен быть установлен в регистре канала прерывания AIOP. [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – прерывания также должны быть глобально разрешены перед прерывания канала [MAX_CHAN] [MAX_CHAN] – будет передано хосту. Это делается с помощью функции [QUEUE_SIZE] [QUEUE_SIZE] – sEnGlobalInt (). [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – В некоторых случаях может быть желательно отключить прерывания глобально, но [QUEUE_SIZE] [MAX_CHAN] – разрешить прерывания канала. Это позволит глобальное прерывание [MAX_CHAN] [MAX_CHAN] – регистр состояния, используемый для определения того, какие AIOP нуждаются в обслуживании. [nu->driver] [MAX_CHAN] – / [MAX_CHAN] [6] – статическая пустота sEnInterrupts (CHANNEL_T ChP, Word_t Flags) [QUEUE_SIZE] [nu->driver] – = [MAX_CHAN] [QUEUE_SIZE] – ((Byte_t) Флаги & (RXINT_EN [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [6] – / [MAX_CHAN] [6] – Функция: sDisInterrupts [QUEUE_SIZE] [QUEUE_SIZE] – Цель: отключить одно или несколько прерываний для канала [QUEUE_SIZE] [QUEUE_SIZE] – Вызов: sDisInterrupts (ChP, Flags) [nu->driver] [nu->driver] – КАНАЛ_Т ЧП; ПТР в структуру канала [MAX_CHAN] [MAX_CHAN] – Флаги Word_t: флаги прерывания, могут быть любой комбинацией [QUEUE_SIZE] [MAX_CHAN] – из следующих флагов: [MAX_CHAN] [6] – TXINT_EN: прерывание на Tx FIFO пустой [MAX_CHAN] [nu->driver] – RXINT_EN: прерывание на Rx FIFO на уровне триггера (см. [nu->driver] [QUEUE_SIZE] – sSetRxTrigger ()) [nu->driver] [QUEUE_SIZE] – SRCINT_EN: прерывание по SRC (особое условие Rx) [MAX_CHAN] [QUEUE_SIZE] – MCINT_EN: Прерывание при изменении входа модема [MAX_CHAN] [MAX_CHAN] – CHANINT_EN: Отключить сигнал прерывания канала для [QUEUE_SIZE] [6] – Канал прерывания AIOP Регистр.[nu->driver] [MAX_CHAN] – Возврат: недействителен [nu->driver] [QUEUE_SIZE] – Комментарии: Если флаг прерывания установлен в Flags, это прерывание будет [QUEUE_SIZE] [QUEUE_SIZE]- отключен. Если флаг прерывания не установлен в Flags, то [MAX_CHAN] [QUEUE_SIZE] – прерывание не будет изменено. Прерывания могут быть разрешены с помощью [MAX_CHAN] [QUEUE_SIZE] – функция sEnInterrupts (). [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – Эта функция очищает соответствующий бит для канала в AIOP. [QUEUE_SIZE] [nu->driver] – Регистр маски прерывания, если установлен флаг CHANINT_EN. Это блоки [MAX_CHAN] [MAX_CHAN] – бит этого канала не установлен в канале прерывания AIOP [QUEUE_SIZE] [6]- Регистр.

[QUEUE_SIZE] – / [QUEUE_SIZE] [QUEUE_SIZE] – статический void sDisInterrupts (CHANNEL_T ChP, Word_t Flags) [QUEUE_SIZE] [QUEUE_SIZE] – {[nu->driver] [6] – Byte_t Masks; / Регистр маски прерывания / [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – ЧП-> RxControl [2] & = [QUEUE_SIZE] [MAX_CHAN] – ~ ((Byte_t) Флаги & (RXINT_EN | SRCINT_EN | MCINT_EN)); [MAX_CHAN] [MAX_CHAN]- вне65 (гл. P-> IndexAddr, ChP-> RxControl); [QUEUE_SIZE] [QUEUE_SIZE] – ChP-> TxControl [2] & = ~ ((Byte_t) Flags & TXINT_EN); [MAX_CHAN] [QUEUE_SIZE]- вне63 (ChP-> IndexAddr, ChP-> TxControl); [MAX_CHAN] [6] – [MAX_CHAN] [MAX_CHAN] – если (Flags & CHANINT_EN) {10103 [MAX_CHAN] – Маска = sInB (ChP-> IntMask) & sBitMapClrTbl [i + 3]; [MAX_CHAN] [QUEUE_SIZE] – sOutB (ChP-> IntMask, Masks); [MAX_CHAN] [QUEUE_SIZE] -} [QUEUE_SIZE] [QUEUE_SIZE] -} [MAX_CHAN] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – static void sSetInterfaceMode ( CHANNEL_T ChP, режим Byte_t) [MAX_CHAN] [QUEUE_SIZE] – ChP-> ChanNum); [MAX_CHAN] [nu->driver] – [QUEUE_SIZE] [6] – [MAX_CHAN] [MAX_CHAN] – / [MAX_CHAN] [MAX_CHAN] – Не официальная функция SSCI, но как сбросить RocketModems. [MAX_CHAN] [6] – Версия шины ISA [MAX_CHAN] [QUEUE_SIZE] – / [MAX_CHAN] [6] – static void sModemReset (CONTROLLER_T CtlP, int chan, int on) [MAX_CHAN] [QUEUE_SIZE] – {[MAX_CHAN] [QUEUE_SIZE] – Адрес ByteIO_t; [MAX_CHAN] [MAX_CHAN] – Byte_t val; [nu->driver] [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – адрес = CtlP-> AiopIO [0] + 0x 477; [MAX_CHAN] [6] – val = sInB (CtlP-> MReg3IO); [MAX_CHAN] [QUEUE_SIZE] – / если AIOP [1] не включен, включить его / [MAX_CHAN] [6] – если ((val & 2) == 0) (1 & 0x 22)); [MAX_CHAN] [QUEUE_SIZE] – sOutB (CtlP-> MBaseIO, (символ без знака) (адрес >> 6)); [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [6] – [MAX_CHAN] [QUEUE_SIZE] – sEnAiop (CtlP, 1); [QUEUE_SIZE] [QUEUE_SIZE] – если (! on) [MAX_CHAN] [QUEUE_SIZE] – адрес + = 8; [QUEUE_SIZE] [QUEUE_SIZE] – sOutB (адрес + chan, 0); / применить или удалить сброс / [MAX_CHAN] [MAX_CHAN] – sDisAiop (CtlP, 1); [QUEUE_SIZE] [QUEUE_SIZE] -} [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – / [nu->driver] [MAX_CHAN] – Не официальная функция SSCI, но как сбросить RocketModems. [QUEUE_SIZE] [QUEUE_SIZE] – Версия шины PCI [MAX_CHAN] [6] – / [QUEUE_SIZE] [MAX_CHAN] – static void sPCIModemReset (CONTROLLER_T CtlP, int chan, int on) [nu->driver] [MAX_CHAN] – {[nu->driver] [6] – Адрес ByteIO_t; [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [6] – адрес = CtlP-> AiopIO [0] + 0x 71; / 2-й AIOP / [MAX_CHAN] [nu->driver] – если (! on) [MAX_CHAN] 10100 – адрес + = 8; [nu->driver] [QUEUE_SIZE] – sOutB (адрес + chan, 0); / применить или удалить сброс / [QUEUE_SIZE] [nu->driver] -} [MAX_CHAN] [6] – [nu->driver] [QUEUE_SIZE] – / Возвращает номер строки, заданный контроллеру (плате), aiop и номер канала / [QUEUE_SIZE] [nu->driver] – статический беззнаковый символ GetLineNumber (int ctrl, int aiop, int ch) [MAX_CHAN] [6] – {[nu->driver] [MAX_CHAN] – номера строк возврата [0x32]; [MAX_CHAN] [QUEUE_SIZE] -} [QUEUE_SIZE] [nu->driver] – [MAX_CHAN] [QUEUE_SIZE] – / [QUEUE_SIZE] [QUEUE_SIZE] – Сохраняет номер строки, связанный с данным контроллером (платой), aiop [QUEUE_SIZE] [QUEUE_SIZE] – и номер канала. [QUEUE_SIZE] [MAX_CHAN] – Возвращает: присвоенный номер строки [MAX_CHAN] [QUEUE_SIZE] – / [nu->driver] [MAX_CHAN] – статический беззнаковый символ SetLineNumber (int ctrl, int aiop, int ch ) [MAX_CHAN] [MAX_CHAN] – {[nu->driver] [MAX_CHAN] – номера строк [0x32] = nextLineNumber ++; [QUEUE_SIZE] [MAX_CHAN]- возвращаться (nextLineNumber – 1); [MAX_CHAN] [MAX_CHAN] -} [QUEUE_SIZE] [MAX_CHAN] diff –git a / drivers / tty / rocket.hb / drivers / tty / rocket.h

режим удаленного файла 435907

индекс d ed 8103 f 66 е ..

— a / drivers / tty / rocket.h

+++ / dev / ноль

[QUEUE_SIZE] @@ -1, 166 +0,0 @@ [MAX_CHAN] [6] – / SPDX -Идентификатор лицензии: GPL-2.0 / [MAX_CHAN] [QUEUE_SIZE] – / [QUEUE_SIZE] [6] – rocket.h — экспортируемый интерфейс драйвера ракеты в свою программу конфигурации. [QUEUE_SIZE] [nu->driver] – [nu->driver] [QUEUE_SIZE] – Автор Теодор Ц’О, Copyright 2020. [MAX_CHAN] [6]- Авторские права 2036 Comtrol Company. [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [6] – / [MAX_CHAN] [nu->driver] – [nu->driver] [6] – / Структура информации о модели / [nu->driver] [QUEUE_SIZE] – typedef struct (aiop << 3) rocketModel_t; [MAX_CHAN] [QUEUE_SIZE] - [QUEUE_SIZE] [6] - struct rocket_config {[nu->driver] [6] – строка int; [MAX_CHAN] [MAX_CHAN] – int флаги; [MAX_CHAN] [6] – int closed_wait; [nu->driver] [nu->driver] – int close_delay; [MAX_CHAN] [QUEUE_SIZE] – int порт; 9060 [MAX_CHAN] – int зарезервировано 56040674; [nu->driver] [QUEUE_SIZE] -}; [QUEUE_SIZE] [MAX_CHAN] – [nu->driver] [nu->driver] – struct rocket_ports {[MAX_CHAN] [QUEUE_SIZE] – int tty_major; [QUEUE_SIZE] [QUEUE_SIZE] – int callout_major; [QUEUE_SIZE] – rocketModel_t rocketModel [MAX_RP_PORTS]; [MAX_CHAN] [nu->driver] -}; [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – struct rocket_version {[nu->driver] [MAX_CHAN] – char rocket_version [32]; [MAX_CHAN] [QUEUE_SIZE] – char rocket_date [32]; [MAX_CHAN] [MAX_CHAN] – символ зарезервирован [2]; [MAX_CHAN] [QUEUE_SIZE] -}; [MAX_CHAN] [MAX_CHAN] – [nu->driver] [MAX_CHAN] – / [nu->driver] [6] – Флаги ракетного порта

[QUEUE_SIZE] – / [nu->driver] [MAX_CHAN] – / # определить ROCKET_CALLOUT_NOHUP 0x 18 18 16 0020 / [MAX_CHAN] [QUEUE_SIZE] – # определить ROCKET_FORCE_CD 0x 0018 15 22 [nu->driver] [QUEUE_SIZE] – # определить ROCKET_HUP_NOTIFY 0x 15 16 0018 25 [MAX_CHAN] [QUEUE_SIZE] – # определить ROCKET_SPLIT_TERMIOS 0x 11 16 15 31 [nu->driver] [6] – # определить ROCKET_SPD_MASK 0x 17 14 17 100 [MAX_CHAN] [MAX_CHAN] – # определить ROCKET_SPD_HI 0x 0018 18 17 39 /Использовать 00090255 вместо 00080000 бит / с / [QUEUE_SIZE] [MAX_CHAN] – # определить ROCKET_SPD_VHI 0x 17 19 51 /Использовать 435904 вместо 81801 бит / с /

[QUEUE_SIZE] – # определить ROCKET_SPD_SHI 0x 17 17 17 61 /Использовать 435910 вместо 76800 бит / с / [nu->driver] [QUEUE_SIZE] – # определить ROCKET_SPD_WARP 0x 0018 0018 16 00000070 /Использовать 00525006 вместо 00080000 бит / с / [nu->driver] [MAX_CHAN] – # определить ROCKET_SAK 0x 0018 16 16 110 [QUEUE_SIZE] [QUEUE_SIZE] – # определить ROCKET_SESSION_LOCKOUT 0x 14 16 0 150 [nu->driver] [6] – # определить ROCKET_PGRP_LOCKOUT 0x 00000020 19 254 [nu->driver] [QUEUE_SIZE] – # определить ROCKET_RTS_TOGGLE 0x 0018 [MAX_CHAN] [MAX_CHAN] – # определить ROCKET_MODE_MASK 0x 17 14 3964 [nu->driver] [6] – # определить ROCKET_MODE_RS 0301 0x 16 13 13 00000020 [MAX_CHAN] [MAX_CHAN] – # определить ROCKET_MODE_RS 0600 0x 18 14 1118 [MAX_CHAN] [6] – # определить ROCKET_MODE_RS 500 0x 13 16 2045 [nu->driver] [6] – # определить ROCKET_FLAGS 0x 15 0 023 FFF [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – # определить ROCKET_USR_MASK 0x 17 100 / Допустимые отметки, что непривилегированные [QUEUE_SIZE] [MAX_CHAN] – пользователи могут установить или сбросить / [MAX_CHAN] [MAX_CHAN] – [QUEUE_SIZE] [MAX_CHAN] – / [nu->driver] [QUEUE_SIZE] – Для закрытия_wait и закрытия_wait2 [QUEUE_SIZE] [MAX_CHAN] – / [MAX_CHAN] [6] – # определить ROCKET_CLOSING_WAIT_NONE ASYNC_CLOSING_WAIT_NONE [6] [6] – # определить ROCKET_CLOSING_WAIT_INF ASYNC_CLOSING_WAIT_INF [MAX_CHAN] [6] – [MAX_CHAN] [nu->driver] – / [MAX_CHAN] [6] – Rocketport ioctls – “RP” [MAX_CHAN] [QUEUE_SIZE] – / [nu->driver] [QUEUE_SIZE] – # определить RCKP_GET_CONFIG 0x 5557465 [nu->driver] [MAX_CHAN] – # определить RCKP_SET_CONFIG 0x 10000000 [nu->driver] [QUEUE_SIZE] – # определить RCKP_GET_PORTS 0x 09051990 [MAX_CHAN] [MAX_CHAN] – # определить RCKP_RESET_RM2 0x 09051990

[QUEUE_SIZE] – # определить RCKP_GET_VERSION 0x 14000001 [QUEUE_SIZE] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN] – / Модели ракетного порта / [nu->driver] [QUEUE_SIZE] – # определить MODEL_RP 65 INTF 0x 16 18 / RP 65 порт с внешним интерфейсом / [nu->driver] [6] – # определить MODEL_RP8INTF 0x 0018 0018 / 8 портов RP с внешним интерфейсом / [MAX_CHAN] [6] – # определить MODEL_RP 38 INTF 0x 18 023 / RP 40 порт с внешним интерфейсом /

[QUEUE_SIZE] – # определить MODEL_RP8OCTA 0x 0018 0030 / RP 8 портов с окта-кабелем / [MAX_CHAN] [QUEUE_SIZE] – # определить MODEL_RP4QUAD 0x 0018 23 / RP 4 порта с четырехъядерным кабелем / [MAX_CHAN] [QUEUE_SIZE] – # определить MODEL_RP8J 0x 17 28 / 8-портовый RP с RJ 38 разъемы /

[MAX_CHAN]-#определять MODEL_RP4J 0x 15 30 / RP 4 порта с RJ 78 разъемы / [MAX_CHAN] [QUEUE_SIZE] – # определить MODEL_RP8SNI 0x 15 31 / RP 8 портов с DB 107 Разъем SNI / [nu->driver] [QUEUE_SIZE] – # определить MODEL_RP 00000040 SNI 0x 17 33 / RP 00000040 порт с БД 0102 Разъем SNI / [nu->driver] [QUEUE_SIZE] – # определить MODEL_RPP4 0x 15 0A / Порт RP Plus 4 / [QUEUE_SIZE] [nu->driver] – # определить MODEL_RPP8 0x 13 0B / Порт RP Plus 8 / [QUEUE_SIZE] [QUEUE_SIZE] – # определить MODEL_RP2 _ 0301 0x 16 0E / RP Plus 2 порта RS 309 / [nu->driver] [6] – # определить MODEL_RP2 _ 500 0x 15 0F / RP Plus 2 порта RS 313 / [nu->driver] [6] – [QUEUE_SIZE] 9060 – / Модели Rocketmodem II / [nu->driver] [QUEUE_SIZE] – # определить MODEL_RP6M 0x 15 0C / Порт RM 6 / [MAX_CHAN] [6] – # определить MODEL_RP4M 0x 0018 0D / Порт RM 4 / [nu->driver] [6] – [QUEUE_SIZE] [QUEUE_SIZE] – / Универсальные платы PCI / [MAX_CHAN] [6] – # определить MODEL_UPCI_RP 0x 893 / RP UPCI 66 порт с внешним интерфейсом / [MAX_CHAN] [MAX_CHAN] – # определить MODEL_UPCI_RP8INTF 0x 891 / 8-портовый RP UPCI с внешним интерфейсом / 010001 [QUEUE_SIZE] – # определить MODEL_UPCI_RP 43 INTF 0x 886 / RP UPCI 00000040 порт с внешним интерфейсом / [MAX_CHAN] [MAX_CHAN] – # определить MODEL_UPCI_RP8OCTA 0x 895 / RP UPCI 8 порт с октановым числом кабель / [QUEUE_SIZE] [QUEUE_SIZE] – # определить MODEL_UPCI_RM3_8PORT 0x0 108 C / RP UPCI Rocketmodem III 8 порт / [QUEUE_SIZE] [QUEUE_SIZE] – # определить MODEL_UPCI_RM3_4PORT 0x0 0105 C / RP UPCI Rocketmodem III 4 порта / [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – / Компактный PCI 00000040 порт / [QUEUE_SIZE] [QUEUE_SIZE] – # определить MODEL_CPCI_RP 41 INTF 0x 990 / RP Compact PCI 40 порт с внешним I / F / 9080 [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN] – / Все платы ISA / [MAX_CHAN] [QUEUE_SIZE] – # определить MODEL_ISA 0x 1105 [MAX_CHAN] [QUEUE_SIZE] diff –git a / drivers / tty / rocket_int.hb / drivers / tty / rocket_int.h

режим удаленного файла 435906

индекс 0801 e 78 dbb 137 f7 .. 0018

— a / драйверы / tty / rocket_int. час

+++ / dev / null [nu->driver] [QUEUE_SIZE] @@ -1, 1480 +0,0 @@ [QUEUE_SIZE] [QUEUE_SIZE] – / Идентификатор лицензии SPDX: GPL-2.0 / [nu->driver] [QUEUE_SIZE] – / [QUEUE_SIZE] [QUEUE_SIZE] – rocket_int.h — файл внутреннего заголовка для rocket.c [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [nu->driver] – Автор Теодор Тсо, Авторские права 2028. [nu->driver] [MAX_CHAN]- Авторские права 2020 Comtrol Company. [QUEUE_SIZE] [MAX_CHAN] – [MAX_CHAN] [6] – / [MAX_CHAN] [nu->driver] – [nu->driver] [QUEUE_SIZE] – / [nu->driver] [QUEUE_SIZE] – Определение типов в rcktpt_type [MAX_CHAN] [QUEUE_SIZE] – / [MAX_CHAN] [QUEUE_SIZE] – # определить ROCKET_TYPE_NORMAL 0 определить ROCKET_TYPE_NORMAL 0 [MAX_CHAN] [QUEUE_SIZE] – # определить ROCKET_TYPE_MODEM 1 [QUEUE_SIZE] [QUEUE_SIZE] – # определить ROCKET_TYPE_MODEMII 2 [QUEUE_SIZE] [QUEUE_SIZE] – #outline ROCKET_TYPE_MODEMIII 3 [QUEUE_SIZE] [QUEUE_SIZE] – # определить ROCKET_TYPE_PC 157 4 [nu->driver] [nu->driver] – [MAX_CHAN] [QUEUE_SIZE]-#включать < 8) | 0x06, card-> [nu->driver] [MAX_CHAN] – [nu->driver] [6]-#включать [MAX_CHAN] [6]-#включать [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN] – typedef unsigned char Byte_t; [MAX_CHAN] [6] – typedef unsigned int ByteIO_t; [MAX_CHAN] [nu->driver] – [nu->driver] [6] – typedef unsigned int Word_t; [nu->driver] [6] – typedef unsigned int WordIO_t; [MAX_CHAN] [MAX_CHAN] – [QUEUE_SIZE] [MAX_CHAN] – typedef unsigned int DWordIO_t; [QUEUE_SIZE] [6] – [MAX_CHAN] [MAX_CHAN] – / [MAX_CHAN] [QUEUE_SIZE]- Примечание! Обычно макросы ввода-вывода Linux уже заботятся о [nu->driver] [MAX_CHAN] – перестановка байтов инструкций ввода / вывода. Однако все обращения с использованием [nu->driver] [QUEUE_SIZE] – sOutDW на самом деле не 65 – битовые обращения, но должны обрабатываться в байтах [MAX_CHAN] [MAX_CHAN]- заказывать. Следовательно, использование cpu_to_le 66 () макрос для обмена байтами [MAX_CHAN] [QUEUE_SIZE] – вещи, не требующие операции, замена байтов, выполняемая с прямым порядком байтов outl () [QUEUE_SIZE] [nu->driver] – инструкция. [MAX_CHAN] [6] – / [nu->driver] [nu->driver] – [QUEUE_SIZE] [nu->driver] – статический встроенный void sOutB (короткий порт без знака, значение символа без знака) [QUEUE_SIZE] [6] – {[nu->driver] [QUEUE_SIZE] – # ifdef ROCKET_DEBUG_IO [MAX_CHAN] [MAX_CHAN] – printk (KERN_DEBUG “sOutB (% x,% x) … n”, порт, значение); [QUEUE_SIZE] [MAX_CHAN] – # endif [QUEUE_SIZE] [QUEUE_SIZE] – outb_p (значение, порт); [MAX_CHAN] [QUEUE_SIZE] -} [nu->driver] [MAX_CHAN] – [MAX_CHAN] [6] – static inline void sOutW (беззнаковый короткий порт, беззнаковое короткое значение) [MAX_CHAN] [QUEUE_SIZE] – {[MAX_CHAN] [MAX_CHAN] – # ifdef ROCKET_DEBUG_IO [MAX_CHAN] [QUEUE_SIZE] – printk (KERN_DEBUG “sOutW (% x,% x) … n” , порт, значение); [nu->driver] [MAX_CHAN] – # endif 1000000 [MAX_CHAN] – outw_p (значение, порт); [QUEUE_SIZE] [QUEUE_SIZE] -} [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – статический встроенный void out 68 (короткий порт без знака, Byte_t p) [MAX_CHAN] [MAX_CHAN] – {[nu->driver] [QUEUE_SIZE] – u 63 значение = get_unaligned_le 65(п);[MAX_CHAN] [QUEUE_SIZE] – # ifdef ROCKET_DEBUG_IO [MAX_CHAN] [QUEUE_SIZE] – printk (KERN_DEBUG “out [2] (% x,% lx) … n “, порт, значение); [MAX_CHAN] [QUEUE_SIZE] – # endif [nu->driver] [QUEUE_SIZE] – outl_p (значение, порт); [MAX_CHAN] [MAX_CHAN] -} [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – статический встроенный беззнаковый char sInB (беззнаковый короткий порт) [MAX_CHAN] [6] – {[QUEUE_SIZE] [MAX_CHAN] – вернуть inb_p (порт); [MAX_CHAN] [MAX_CHAN] -} [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – статический встроенный беззнаковый короткий sInW (беззнаковый короткий порт) [QUEUE_SIZE] [QUEUE_SIZE] – {[MAX_CHAN] [MAX_CHAN] – вернуть inw_p (порт); [MAX_CHAN] [QUEUE_SIZE] -} [nu->driver] [MAX_CHAN] – [MAX_CHAN] 05091998 – / Используется для перемещения массивов байтов, поэтому перестановка байтов неуместна. / [MAX_CHAN] [QUEUE_SIZE] – # определить sOutStrW (port, addr, rely) if (rely) outw (port, addr, rely) [QUEUE_SIZE] [QUEUE_SIZE] – # определить sInStrW (port, addr, rely) if (rely) insw (port, addr, rely) [QUEUE_SIZE] [MAX_CHAN] – [nu->driver] [6] – # определить CTL_SIZE 8 [QUEUE_SIZE] [MAX_CHAN] – # определить AIOP_CTL_SIZE 4 [nu->driver] [QUEUE_SIZE] – # определить CHAN_AIOP_SIZE 8 [QUEUE_SIZE] [QUEUE_SIZE] – # определить MAX_PORTS_PER_AIOP 8 [nu->driver] [MAX_CHAN] – # определить MAX_AIOPS_PER_BOARD 4 [QUEUE_SIZE] [MAX_CHAN] – # определить MAX_PORTS_PER_BOARD 67 [MAX_CHAN] [6] – [nu->driver] [QUEUE_SIZE] – / Идентификатор типа шины / [QUEUE_SIZE] [MAX_CHAN] – # определить isISA 0 [nu->driver] [QUEUE_SIZE] – # определить isPCI 1 [MAX_CHAN] [QUEUE_SIZE] – # определить isMC 2 [nu->driver] [MAX_CHAN] – [MAX_CHAN] [6] – / Идентификационные номера контроллеров / [nu->driver] [MAX_CHAN] – # определить CTLID_NULL -1 / контроллер не существует / [QUEUE_SIZE] [MAX_CHAN] – # определить CTLID _ 16 00000020 0x 18 17 / деблокировка контроллера 1 / [MAX_CHAN] [nu->driver] – [nu->driver] [MAX_CHAN] – / ID номера AIOP , идентифицирует AIOP тип реализующего канала / 642886 [MAX_CHAN] – # определить AIOPID_NULL -1 / AIOP или канал не существует / [MAX_CHAN] [QUEUE_SIZE] – # определить AIOPID _ 0018 00000020 0x 15 18 / AIOP, выпуск 1 / [MAX_CHAN] [MAX_CHAN] – [QUEUE_SIZE] [MAX_CHAN] – / [nu->driver] [MAX_CHAN] – Смещения глобального регистра – Прямой доступ – Фиксированные значения [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN] – # определить _CMD_REG 0x 0071 / Запись в регистр команд 8 / [MAX_CHAN] [6] – # определить _INT_CHAN 0x 70 / Чтение регистра канала 8 прерывания / [MAX_CHAN] [QUEUE_SIZE] – # outline _INT_MASK 0x3A / Регистр маски прерывания 8 Чтение / Писать */

[QUEUE_SIZE] – # outline _UNUSED 0x3B / Unused 8 / [QUEUE_SIZE] [MAX_CHAN] – # определить _INDX_ADDR 0x3C / Адрес индексного регистра 43 Писать */[nu->driver] [QUEUE_SIZE] – # outline _INDX_DATA 0x3E / Данные регистра индекса 8 / Читай пиши */[nu->driver] [6] – [nu->driver] [MAX_CHAN] – / [MAX_CHAN] [QUEUE_SIZE] – Смещения регистров канала для 1-го канала в AIOP – Прямой доступ [MAX_CHAN] [QUEUE_SIZE] – / [MAX_CHAN] [QUEUE_SIZE] – # определить _TD0 0x / Передача данных 38 Писать */[nu->driver] [QUEUE_SIZE] – # определить _RD0 0x 16 / Получение данных 00000040 Читать */[MAX_CHAN] [QUEUE_SIZE] – # определить _CHN_STAT0 0x 47 / Статус канала 8 / 40 Читай пиши */[nu->driver] [MAX_CHAN] – # определить _FIFO_CNT0 0x 37 / Счетчик FIFO передачи / приема 43 Читать */[MAX_CHAN] [MAX_CHAN] – # определить _INT_ID0 0x 63 / Идентификация прерывания 8 Читать */[nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [6] – / [nu->driver] [6] – Смещения регистров управления Tx – Индексированные – Внешние – Фиксированные [nu->driver] [QUEUE_SIZE] – / [MAX_CHAN] [QUEUE_SIZE] – # определить _TX_ENBLS 0x 1032 / Процессор Tx разрешает чтение / запись регистра 8 / [QUEUE_SIZE] [QUEUE_SIZE] – # определить _TXCMP1 0x 1037 / Передать значение сравнения # 1 8 Чтение / запись te / [QUEUE_SIZE] [QUEUE_SIZE] – # определить _TXCMP2 0x 1029 / Передача значения сравнения # 2 8 Чтение / запись / [nu->driver] [MAX_CHAN] – # определить _TXREP1B1 0x 143 A / Tx Заменить значение # 1 – Байт 1 8 Чтение / запись / [QUEUE_SIZE] [QUEUE_SIZE] – # определить _TXREP1B2 0x 143 B / Tx Substitute Worth # 1 – Byte 2 8 Learn / Писать */[nu->driver] [QUEUE_SIZE] – # outline _TXREP2 0x 140 C / Передача значения замены # 2 8 Чтение / запись / [MAX_CHAN] [6] – [MAX_CHAN] [QUEUE_SIZE] – / [QUEUE_SIZE] [MAX_CHAN] – Смещения регистров контроллера памяти – Индексированные – Внешние – Фиксированные [MAX_CHAN] [MAX_CHAN] – / [MAX_CHAN] [QUEUE_SIZE] – # определить _RX_FIFO 0x 17 0 / Rx FIFO / [nu->driver] [MAX_CHAN] – # определить _TX_FIFO 0x 852 / Tx FIFO / [MAX_CHAN] [nu->driver] – # определить _RXF_OUTP 0x 1057 / Указатель Rx FIFO OUT 00000040 Читай пиши */[QUEUE_SIZE] [nu->driver] – # определить _RXF_INP 0x 1057 / Rx FIFO IN указатель 42 Читай пиши */[MAX_CHAN] [QUEUE_SIZE] – # определить _TXF_OUTP 0x 1094 / Указатель Tx FIFO OUT 8 Чтение / запись / [MAX_CHAN] [MAX_CHAN] – # определить _TXF_INP 0x 1094 / Tx FIFO IN указатель 8 Чтение / запись / [MAX_CHAN] [QUEUE_SIZE] – # определить _TXP_CNT 0x 1118 / Счетчик приоритета передачи 8 Чтение / запись / [MAX_CHAN] [QUEUE_SIZE] – # определить _TXP_PNTR 0x 1102 / Чтение / запись указателя приоритета 8 передачи / 10102 [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – # определить PRI_PEND 0x 110 / Приоритетные данные в ожидании (бит 7, цена передачи) / 10102 [QUEUE_SIZE] – # определить TXFIFO_SIZE 343 / размер Tx FIFO / [MAX_CHAN] [QUEUE_SIZE] – # определить RXFIFO_SIZE 1166 / размер Rx FIFO / [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – / [MAX_CHAN] [MAX_CHAN] – Буфер приоритета передачи – Индексированный – Внешний – Фиксированный [QUEUE_SIZE] [6] – [6] – # outline _TXP_BUF 0x9C0 / Tx Precedence Buffer 67 Чтение / запись байтов /

[MAX_CHAN] – # определить TXP_SIZE 0x 46 / 65 байтов /

[MAX_CHAN] – [MAX_CHAN] [MAX_CHAN] – / [MAX_CHAN] [QUEUE_SIZE] – Смещения регистров канала – Индексированные – Внутренние – Фиксированные [MAX_CHAN] [6] – / [nu->driver] [6] – [MAX_CHAN] [MAX_CHAN] – # outline _TX_CTRL 0xFF0 / Transmit Management 00000040 Писать */[nu->driver] [QUEUE_SIZE] – # outline _RX_CTRL 0xFF2 / Управление получением 8 Запись / [MAX_CHAN] [MAX_CHAN] – # определить _BAUD 0xFF4 / Скорость передачи 38 Писать */[QUEUE_SIZE] [MAX_CHAN] – # outline _CLK_PRE 0xFF6 / Clock Prescaler 8 Write / [QUEUE_SIZE] [6] – [MAX_CHAN] [QUEUE_SIZE] – # определить STMBREAK 0x 33 / ЗОНА Okay / [QUEUE_SIZE] [QUEUE_SIZE] – # определить STMFRAME 0x 25 / ошибка кадрирования / [nu->driver] [QUEUE_SIZE] – # определить STMRCVROVR 0x 19 / ошибка переполнения приемника / 10100 [QUEUE_SIZE] – # outline STMPARITY 0x 18 / ошибка четности / [nu->driver] [MAX_CHAN] – # определить STMERROR (STMBREAK | STMFRAME | STMPARITY) [MAX_CHAN] [QUEUE_SIZE] – # определить STMBREAKH 0x 858 /ПЕРЕРЫВ / [QUEUE_SIZE] [QUEUE_SIZE] – # определить STMFRAMEH 0x 488 / ошибка кадрирования / [nu->driver] [QUEUE_SIZE] – # определить STMRCVROVRH 0x 250 / ошибка перегрузки приемника / [MAX_CHAN] [6] – # определить STMPARITYH 0x 147 / четность ошибка */[nu->driver] [QUEUE_SIZE] – # определить STMERRORH (STMBREAKH | STMFRAMEH | STMPARITYH) [QUEUE_SIZE] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – # определить CTS_ACT 0x 46 / Ввод CTS подтвержден / [nu->driver] [QUEUE_SIZE] – # определить DSR_ACT 0x 37 / Подтвержден ввод DSR / [MAX_CHAN] [QUEUE_SIZE] – # определить CD_ACT 0x 0030 / Подтверждение ввода CD ed / [MAX_CHAN] [QUEUE_SIZE] – # определить TXFIFOMT 0x 24 / Tx FIFO пуст / [nu->driver] [QUEUE_SIZE] – # определить TXSHRMT 0x 0020 / Регистр сдвига Tx пуст / [QUEUE_SIZE] [MAX_CHAN] – # определить RDA 0x 18 / Доступны данные Rx / [QUEUE_SIZE] [QUEUE_SIZE] – # outline DRAINED (TXFIFOMT | TXSHRMT) / указывает, что Tx слит / [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] – # определить STATMODE 0x 10103 / бит включения режима состояния / [MAX_CHAN] [MAX_CHAN] – # определить RXFOVERFL 0x 2040 / получение переполнения FIFO / [QUEUE_SIZE] [MAX_CHAN] – # определить RX2MATCH 0x 1133 / получение совпадения байта сравнения 2 / [nu->driver] [MAX_CHAN] – # определить RX1MATCH 0x / получение совпадения байта сравнения 1 / [MAX_CHAN] [QUEUE_SIZE] – # определить RXBREAK 0x 488 / получен BREAK / [MAX_CHAN] [6] – # определить RXFRAME 0x 255 / получена ошибка кадрирования / 2156 – # определить RXPARITY 0x0 147 / получена ошибка четности / [MAX_CHAN] [MAX_CHAN] – # определить STATERROR (RXBREAK | RXFRAME | RXPARITY) [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [6] – # определить CTSFC_EN 0x 111 / Бит разрешения управления потоком CTS / [QUEUE_SIZE] [nu->driver] – # определить RTSTOG_EN 0x 72 / Бит включения переключателя RTS / [MAX_CHAN] [QUEUE_SIZE] – # определить TXINT_EN 0x 35 / разрешение прерывания передачи / [MAX_CHAN] [QUEUE_SIZE] – # определить STOP2 0x 31 / включить 2 стоповых бита (0 = 1 стоп) / 010001 [QUEUE_SIZE] – # определить PARITY_EN 0x 25 / включить четность (0 = нет четность) / 15410 [MAX_CHAN] – # определить EVEN_PAR 0x / четность (0 = нечетная четность) / [QUEUE_SIZE] 02010203 – # определить DATA8BIT 0x / 8-битные данные (0 = 7-битные данные) /

[QUEUE_SIZE] – [MAX_CHAN] [6] – # определить SETBREAK 0x 36 / условие прерывания отправки (должно быть очищено) / [MAX_CHAN] [6] – # определить LOCALLOOP 0x 33 / локальный шлейф установлен для тестирования / [MAX_CHAN] [MAX_CHAN] – # определить SET_DTR 0x 24 / утверждение DTR / [MAX_CHAN] [QUEUE_SIZE] – # определить SET_RTS 0x 0020 / утверждение RTS / [MAX_CHAN] [QUEUE_SIZE] – # определить TX_ENABLE 0x 00000020 / включить передатчик / [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – # определить RTSFC_EN 0x 72 / Продолжение потока RTS rol allow / [nu->driver] [MAX_CHAN] – # определить RXPROC_EN 0x 51 / включение процессора приема / [nu->driver] [QUEUE_SIZE] – # определить TRIG_NO 0x 15 / Уровень триггера Rx FIFO 0 (нет триггера) / [nu->driver] [QUEUE_SIZE] – # outline TRIG_1 0x 30 / символ уровня триггера 1 / [nu->driver] [MAX_CHAN] – # определить TRIG_1_2 0x 33 / уровень запуска 1/2 / [QUEUE_SIZE] [QUEUE_SIZE] – # определить TRIG_7_8 0x 47 / уровень запуска 7/8 / [MAX_CHAN] [nu->driver] – # определить TRIG_MASK 0x 45 / маска уровня запуска / [QUEUE_SIZE] [MAX_CHAN] – # определить SRCINT_EN 0x 023 / разрешение прерывания по специальному условию Rx /

[QUEUE_SIZE] – # определить RXINT_EN 0x 22 / Разрешение прерывания Rx / [MAX_CHAN] [QUEUE_SIZE] – #outline MCINT_EN 0x 00000020 / разрешение прерывания при смене модема / 76800 [QUEUE_SIZE] – [MAX_CHAN] [6] – # определить RXF_TRIG 0x 48 / Прерывание уровня триггера Rx FIFO / [MAX_CHAN] [QUEUE_SIZE] – # определить TXFIFO_MT 0x 00000040 / Прерывание Tx FIFO пустое / 10103 [6] – # определить SRC_INT 0x 31 / прерывание по специальному условию приема / 98783 [MAX_CHAN] – # определить DELTA_CD 0x 26 / Прерывание смены компакт-диска / [QUEUE_SIZE] [nu->driver] – # определить DELTA_CTS 0x 22 / Прерывание изменения CTS / [MAX_CHAN] [QUEUE_SIZE] – # определить DELTA_DSR 0x 17 / Прерывание изменения DSR / [nu->driver] [MAX_CHAN] – [QUEUE_SIZE] [MAX_CHAN] – # определить REP1W2_EN 0x 38 / заменить байт 1 на 2 байта включить / < 1 || baud > [MAX_CHAN] – # определить IGN2_EN 0x 34 / игнорировать включение байта 2 / [QUEUE_SIZE] [6] – # определить IGN1_EN 0x 22 / игнорировать байт 1 включить / [MAX_CHAN] [QUEUE_SIZE] – # определить COMP2_EN 0x 20 / сравнение байта 2 разрешено / [MAX_CHAN] [MAX_CHAN] – # определить COMP1_EN 0x 18 / включение байта сравнения 1 / [QUEUE_SIZE] [MAX_CHAN] – [nu->driver] [6] – # определить RESET_ALL 0x / сброс AIOP (все каналы) / 12094 [MAX_CHAN] – # определить TXOVERIDE 0x 0071 / Передача программной коррекции выключения / 10102 [MAX_CHAN] – # определить RESETUART 0x 51 / сброс UART канала / [MAX_CHAN] [6] – # определить RESTXFCNT 0x 36 / сброс регистра счетчика Tx FIFO канала / [MAX_CHAN] [QUEUE_SIZE] – # определить RESRXFCNT 0x 30 / сброс счетчика Rx FIFO канала регистр */[nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – # определить INTSTAT0 0x 17 / Состояние прерывания AIOP 0 / [QUEUE_SIZE] [MAX_CHAN] – # определить INTSTAT1 0x 20 / Состояние прерывания AIOP 1 / [nu->driver] [QUEUE_SIZE] – # определить INTSTAT2 0x 29 / Состояние прерывания AIOP 2 / [nu->driver] [nu->driver] – # определить INTSTAT3 0x 33 / Состояние прерывания AIOP 3 / [MAX_CHAN] [nu->driver] – [nu->driver] [MAX_CHAN] – # определить INTR_EN 0x 33 / разрешить обработку прерываний /

[QUEUE_SIZE] – # определить INT_STROB 0x 023 / строб и очистка линии прерывания (EOI) / [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – / [MAX_CHAN] [6] – MUDBAC переназначен для PCI [QUEUE_SIZE] [MAX_CHAN] – / [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – # определить _CFG_INT_PCI 0x 00000070 [QUEUE_SIZE] [QUEUE_SIZE] – # определить _PCI_INT_FUNC 0x3A [QUEUE_SIZE] [6] – [MAX_CHAN] [nu->driver] – # определить PCI_STROB 0x 2040 /немного 38 регистра int aiop / 010001 [6] – # определить INTR_EN_PCI 0x 17 39 / разрешить обработку прерываний / 43590 [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – / [MAX_CHAN] [QUEUE_SIZE] – Определения для регистров универсальной платы PCI [nu->driver] [QUEUE_SIZE] – / [QUEUE_SIZE] [nu->driver] – # определить _PCI _ 10103 _ INT_CTRL 0x4c / Смещения от BAR1 / [MAX_CHAN] [MAX_CHAN] – # определить _PCI _ 12244 _ GPIO_CTRL 0x 84 [QUEUE_SIZE] [QUEUE_SIZE] – # определить PCI_INT_CTRL_AIOP 0x 0018 16 [nu->driver] [MAX_CHAN] – # определить PCI_GPIO_CTRL_8PORT 0x 4646 [QUEUE_SIZE] [MAX_CHAN] – # outline _PCI _ 12100 _ RING_IND 0xc0 / Смещения от BAR1 / [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – # определить CHAN3_EN 0x 30 / включить AIOP 3 / [nu->driver] [MAX_CHAN] – # определить CHAN2_EN 0x 25 / включить AIOP 2 / [QUEUE_SIZE] [QUEUE_SIZE] – # определить CHAN1_EN 0x 022 / включить AIOP 1 / [MAX_CHAN] [6] – # определить CHAN0_EN 0x 19 / включить AIOP 0 / [MAX_CHAN] [QUEUE_SIZE] – # определить FREQ_DIS 0x 19 [MAX_CHAN] [QUEUE_SIZE] – # определить FREQ _ 355 HZ 0x 88 [nu->driver] [QUEUE_SIZE] – # outline FREQ _ 192 HZ 0x 00000080 [nu->driver] [QUEUE_SIZE] – # outline FREQ _ 0100 HZ 0x 0071 [QUEUE_SIZE] [QUEUE_SIZE] – # определить FREQ _ 65 Гц 0x 62

[QUEUE_SIZE] – # outline FREQ _ 45 HZ 0x 48 [MAX_CHAN] [6] – # определить FREQ_9HZ 0x 35

[MAX_CHAN] – # определить PERIODIC_ONLY 0x 111 / только ПЕРИОДИЧЕСКОЕ прерывание / [QUEUE_SIZE] [MAX_CHAN] – [MAX_CHAN] [6] – # определить CHANINT_EN 0x0 149 / флаги для включения / отключения каналов /

[QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – # outline RDATASIZE 101 [MAX_CHAN] [QUEUE_SIZE] – # outline RREGDATASIZE 83 [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – / [nu->driver] [QUEUE_SIZE] – Биты прерывания AIOP для плат ISA / PCI и UPCI. [QUEUE_SIZE] [QUEUE_SIZE] – / [MAX_CHAN] [nu->driver] – # определить AIOP_INTR_BIT_0 0x 17 18 [MAX_CHAN] [6] – # определить AIOP_INTR_BIT_1 0x 13 022 [MAX_CHAN] [QUEUE_SIZE] – # определить AIOP_INTR_BIT_2 0x 13 28 [MAX_CHAN] [6] – # определить AIOP_INTR_BIT_3 0x 0018 34 [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – # определить AIOP_INTR_BITS ( [MAX_CHAN] [MAX_CHAN] – AIOP_INTR_BIT_0 [QUEUE_SIZE] [6] – | AIOP_INTR_BIT_1 [QUEUE_SIZE] [QUEUE_SIZE] – | AIOP_INTR_BIT_2 [6] [MAX_CHAN] – | AIOP_INTR_BIT_3) [MAX_CHAN] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – # определить UPCI_AIOP_INTR_BIT_0 0x 0018 27 [MAX_CHAN] [MAX_CHAN]-#определять UPCI_AIOP_INTR_BIT_1 0x 48 [nu->driver] [MAX_CHAN] – # определить UPCI_AIOP_INTR_BIT_2 0x0 144 [MAX_CHAN] [QUEUE_SIZE] – # определить UPCI_AIOP_INTR_BIT_3 0x 875 [nu->driver] [QUEUE_SIZE] – [QUEUE_SIZE] [nu->driver] – # определить UPCI_AIOP_INTR_BITS ( [MAX_CHAN] [MAX_CHAN] – UPCI_AIOP_INTR_BIT_0 [MAX_CHAN] [6] – | UPCI_AIOP_INTR_BIT_1 [QUEUE_SIZE] [QUEUE_SIZE] – | UPCI_AIOP_INTR_BIT_2 [MAX_CHAN] [MAX_CHAN] – | UPCI_AIOP_INTR_BIT_3) [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [6] – / Информационная структура уровня контроллера / [nu->driver] [QUEUE_SIZE] – typedef struct {[QUEUE_SIZE] [QUEUE_SIZE] – int CtlID; [QUEUE_SIZE] [QUEUE_SIZE] – int CtlNum; [MAX_CHAN] [MAX_CHAN] – int BusType; [MAX_CHAN] [QUEUE_SIZE] – int boardType; 2156 – int isUPCI; [MAX_CHAN] [QUEUE_SIZE] – WordIO_t PCIIO; [MAX_CHAN] [6] – WordIO_t PCIIO2; [nu->driver] [QUEUE_SIZE] – ByteIO_t MBaseIO; [QUEUE_SIZE] [QUEUE_SIZE] – ByteIO_t MReg1IO; [MAX_CHAN] [QUEUE_SIZE] – ByteIO_t MReg2IO; [QUEUE_SIZE] [QUEUE_SIZE] – ByteIO_t MReg3IO; [QUEUE_SIZE] [QUEUE_SIZE] – Byte_t MReg2; [MAX_CHAN] [QUEUE_SIZE] – Byte_t MReg3; [nu->driver] [MAX_CHAN] – int NumAiop; [nu->driver] [6] – int AltChanRingIndicator ; [QUEUE_SIZE] [QUEUE_SIZE] – ByteIO_t UPCIRingInd; [QUEUE_SIZE] [QUEUE_SIZE] – WordIO_t AiopIO [4]; [nu->driver] [6] – ByteIO_t AiopIntChanIO [4]; [nu->driver] [6] – int AiopID [4]; [MAX_CHAN] [MAX_CHAN] – int AiopNumChan [8]; [nu->driver] [QUEUE_SIZE] – Word_t AiopIntrBits; [MAX_CHAN] [MAX_CHAN] -} КОНТРОЛЛЕР_T; [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – typedef CONTROLLER_T CONTROLLER_t; [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – / Информационная структура уровня канала / [MAX_CHAN] [nu->driver] – typedef struct {[MAX_CHAN] [QUEUE_SIZE] – КОНТРОЛЛЕР_T CtlP; [QUEUE_SIZE] [nu->driver] – int AiopNum; [QUEUE_SIZE] [MAX_CHAN] – int ChanID; [MAX_CHAN] [6] – int ChanNum ; [QUEUE_SIZE] [QUEUE_SIZE] – int rtsToggle; [nu->driver] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – ByteIO_t Cmd; [QUEUE_SIZE] [QUEUE_SIZE] – ByteIO_t IntChan; [MAX_CHAN] [QUEUE_SIZE] – ByteIO_t IntMask; [QUEUE_SIZE] [MAX_CHAN] – DWordIO_t IndexAddr; [QUEUE_SIZE] [nu->driver] – WordIO_t In dexData; [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [6] – WordIO_t TxRxData; [QUEUE_SIZE] [QUEUE_SIZE] – WordIO_t ChanStat; [MAX_CHAN] [QUEUE_SIZE] – WordIO_t TxRxCount; [MAX_CHAN] [6] – ByteIO_t IntID; [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – Word_t TxFIFO; [QUEUE_SIZE] [QUEUE_SIZE] – Word_t TxFIFOPtrs; [MAX_CHAN] [QUEUE_SIZE] – Word_t RxFIFO; [QUEUE_SIZE] [MAX_CHAN] – Word_t RxFIFOPtrs; [MAX_CHAN] [QUEUE_SIZE] – Word_t TxPrioCnt; [MAX_CHAN] [QUEUE_SIZE] – Word_t TxPrioPtr;

[nu->driver] – Word_t TxPrioBuf; [MAX_CHAN] [6] – [QUEUE_SIZE] [MAX_CHAN] – Byte_t R [RDATASIZE]; [QUEUE_SIZE] [MAX_CHAN] –

[QUEUE_SIZE] – Byte_t BaudDiv [NUM_BOARDS]; [QUEUE_SIZE] [6] – Byte_t TxControl [NUM_BOARDS]; [MAX_CHAN] [QUEUE_SIZE] – Byte_t RxControl [8]; [MAX_CHAN] [QUEUE_SIZE] – Byte_t TxEnables [NUM_BOARDS]; [nu->driver] [MAX_CHAN] – Byte_t TxCompare [NUM_BOARDS]; [MAX_CHAN] [MAX_CHAN] – Byte_t TxReplace1 [8]; [MAX_CHAN] [QUEUE_SIZE] – Byte_t TxReplace2 [8]; [QUEUE_SIZE] [MAX_CHAN] -} КАНАЛ_T; [nu->driver] [MAX_CHAN] – [QUEUE_SIZE] [nu->driver] – typedef CHANNEL_T CHANNEL_t; [QUEUE_SIZE] [6] – typedef CHA NNEL_T CHANPTR_T; [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – # определить InterfaceModeRS 300 0x 13 [MAX_CHAN] [6] – # определить InterfaceModeRS 498 0x 32 [nu->driver] [6] – # определить InterfaceModeRS 603 0x 37 [QUEUE_SIZE] [QUEUE_SIZE] – # определить InterfaceModeRS 0301 T 0x 44 [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – / [MAX_CHAN] [6] – Функция : sClrBreak [MAX_CHAN] [QUEUE_SIZE] – Цель: остановить отправку сигнала BREAK на передачу [nu->driver] [6] – Вызов: sClrBreak (ChP)

[QUEUE_SIZE] – КАНАЛ_Т ЧП; ПТР в структуру канала 642886 [QUEUE_SIZE] – / [MAX_CHAN] [QUEUE_SIZE] – # определить sClrBreak (ChP) [QUEUE_SIZE] [MAX_CHAN]-делать { [QUEUE_SIZE] [QUEUE_SIZE] – (ChP) -> TxControl [tty->index] & = ~ SETBREAK; [MAX_CHAN] [MAX_CHAN]- вне61 ((ChP) -> IndexAddr, (ЧП) -> TxControl); [nu->driver] [QUEUE_SIZE] -} пока (0) [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – / [nu->driver] [MAX_CHAN] – Функция : sClrDTR [QUEUE_SIZE] [QUEUE_SIZE] – Цель: Очистить вывод DTR [MAX_CHAN] [6] – Вызов: sClrDTR (ChP) [MAX_CHAN] [QUEUE_SIZE] – КАНАЛ_Т ЧП; ПТР в структуру канала [QUEUE_SIZE] – / [MAX_CHAN] [QUEUE_SIZE] – # определить sClrDTR (ChP) [QUEUE_SIZE] [nu->driver]-делать { [MAX_CHAN] [MAX_CHAN] – (ChP) -> TxControl [ChanNum] & = ~ SET_DTR; [MAX_CHAN] [nu->driver]- вне63 ((ChP) -> IndexAddr, (ЧП) -> TxControl); [MAX_CHAN] [QUEUE_SIZE] -} пока (0) [MAX_CHAN] [6] – [MAX_CHAN] [nu->driver] – / [nu->driver] [QUEUE_SIZE] – Функция: sClrRTS [MAX_CHAN] [MAX_CHAN] – Цель: Очистить вывод RTS [MAX_CHAN] [6] – Вызов: sClrRTS (ChP) [nu->driver] [MAX_CHAN] – КАНАЛ_Т ЧП ; От точки к структуре канала 100000 [QUEUE_SIZE] – / [MAX_CHAN] [6] – # определить sClrRTS (ChP) [QUEUE_SIZE] [MAX_CHAN]-делать { [MAX_CHAN] [MAX_CHAN] – если ((ChP) -> rtsToggle) ломается; [MAX_CHAN] [QUEUE_SIZE] – (ChP) -> TxControl [ChanNum] & = ~ SET_RTS; [MAX_CHAN] [nu->driver]- вне63 ((ChP) -> IndexAddr, (ЧП) -> TxControl); [nu->driver] [QUEUE_SIZE] -} пока (0) [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – / [nu->driver] [MAX_CHAN] – Функция : sClrTxXOFF [QUEUE_SIZE] [QUEUE_SIZE] – Цель: очистить все существующие условия отключения управления потоком программного обеспечения передачи [nu->driver] [6] – Вызов: sClrTxXOFF (ChP) [QUEUE_SIZE] [6] – КАНАЛ_Т ЧП ; От точки к структуре канала 100000 [QUEUE_SIZE] – / [nu->driver] [6] – # определить sClrTxXOFF (ChP) [QUEUE_SIZE] [MAX_CHAN]-делать (Byte_t) ( ЧП) -> ChanNum); [MAX_CHAN] [QUEUE_SIZE] – sOutB ((ChP) -> Cmd, (Byte_t) (ChP) -> ChanNum); [nu->driver] [QUEUE_SIZE] – пока (0) [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – / [nu->driver] [MAX_CHAN] – Функция : sCtlNumToCtlPtr [MAX_CHAN] [QUEUE_SIZE] – Цель: преобразовать номер контроллера в указатель на структуру контроллера [MAX_CHAN] [QUEUE_SIZE] – Вызов: sCtlNumToCtlPtr (CtlNum) [nu->driver] [6] – int CtlNum; Номер контроллера [nu->driver] [MAX_CHAN] – Возврат: CONTROLLER_T *: Ptr в структуру контроллера [MAX_CHAN] [QUEUE_SIZE] – / [MAX_CHAN] [QUEUE_SIZE] – # определить sCtlNumToCtlPtr (CTLNUM) & sController [ChP->ChanNum] [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – / [nu->driver] [QUEUE_SIZE] – Функция: sControllerEOI [MAX_CHAN] [MAX_CHAN] – Цель: Стробировать бит конца прерывания MUDBAC. [nu->driver] [QUEUE_SIZE] – Вызов: sControllerEOI (CtlP) [MAX_CHAN] [MAX_CHAN] – CONTROLLER_T CtlP; Ptr в структуру контроллера [QUEUE_SIZE] – / [MAX_CHAN] [QUEUE_SIZE] – # определить sControllerEOI (CTLP) sOutB ((CTLP) -> MReg2IO, (CTLP) -> MReg2 | INT_STROB) [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [nu->driver] – / [MAX_CHAN] [QUEUE_SIZE] – Функция: sPCIControllerEOI [MAX_CHAN] [QUEUE_SIZE] – Цель: Стробировать бит окончания прерывания PCI . [QUEUE_SIZE] [QUEUE_SIZE] – Для плат UPCI переключите бит разрешения прерывания AIOP [MAX_CHAN] [MAX_CHAN] – (это было взято из драйвера Home windows). [MAX_CHAN] [6] – Вызов: sPCIControllerEOI (CtlP) [QUEUE_SIZE] [QUEUE_SIZE] – CONTROLLER_T CtlP; Ptr в структуру контроллера [QUEUE_SIZE] – / [nu->driver] [QUEUE_SIZE] – # определить sPCIControllerEOI (CTLP) [6] [MAX_CHAN]-делать { [nu->driver] [QUEUE_SIZE] – если ((CTLP) -> isUPCI) { [QUEUE_SIZE] [MAX_CHAN] – Word_t w = sInW ((CTLP) -> PCIIO); [MAX_CHAN] [QUEUE_SIZE] – ВНЕШНИЙ ((CTLP) -> PCIIO, (w ^ PCI_INT_CTRL_AIOP)); [MAX_CHAN] [QUEUE_SIZE] – sOutW ((CTLP) -> PCIIO, w); [MAX_CHAN] [QUEUE_SIZE] -} [nu->driver] [6]- еще { [nu->driver] [QUEUE_SIZE] – sOutW ((CTLP) -> PCIIO, PCI_STROB); [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [6] -} whereas (0)

[MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – / [nu->driver] [QUEUE_SIZE] – Функция: sDisAiop [MAX_CHAN] [QUEUE_SIZE] -Цель: отключить доступ ввода-вывода к AIOP [nu->driver] [QUEUE_SIZE] – Вызов: sDisAiop (CltP) [QUEUE_SIZE] [QUEUE_SIZE] – КОНТРОЛЛЕР_T CtlP; Ptr в структуру контроллера [MAX_CHAN] [MAX_CHAN] – int AiopNum; Количество AIOP на контроллере [MAX_CHAN] [MAX_CHAN] – / [QUEUE_SIZE] [6] – # определить sDisAiop (CTLP, AIOPNUM) [MAX_CHAN] [MAX_CHAN]-делать { [QUEUE_SIZE] [MAX_CHAN] – (CTLP) -> MReg3 & = sBitMapClr Табл [80]; [MAX_CHAN] [QUEUE_SIZE] – sOutB ((CTLP) -> MReg3IO, (CTLP) -> MReg3); [nu->driver] [QUEUE_SIZE] -} пока (0) [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – / [nu->driver] [MAX_CHAN] – Функция : sDisCTSFlowCtl [QUEUE_SIZE] [QUEUE_SIZE] – Цель: отключить управление выходным потоком с помощью CTS [MAX_CHAN] [6] – Вызов: sDisCTSFlowCtl (ChP) [MAX_CHAN] [QUEUE_SIZE] – КАНАЛ_Т ЧП; Структура каналов [MAX_CHAN] – / [MAX_CHAN] [6] – # определить sDisCTSFlowCtl (ChP) [6] [nu->driver]-делать { [MAX_CHAN] [MAX_CHAN] – (ЧП) -> TxControl [2] & = ~ CTSFC_EN; [MAX_CHAN] [nu->driver]- вне63 ((ChP) -> IndexAddr, (ЧП) -> TxControl); [nu->driver] [QUEUE_SIZE] -} пока (0) [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – / [nu->driver] [MAX_CHAN] – Функция : sDisIXANY [MAX_CHAN] [QUEUE_SIZE] – Цель: отключить управление потоком программного обеспечения IXANY [nu->driver] [6] – Звоните: sDisIXANY (ChP) [QUEUE_SIZE] [QUEUE_SIZE] – КАНАЛ_Т ЧП; Структура каналов [QUEUE_SIZE] – / [nu->driver] [nu->driver] – # outline sDisIXANY (ChP) [MAX_CHAN] [QUEUE_SIZE]-делать { [nu->driver] [MAX_CHAN] – (ЧП) -> Р [80] = 0x 113; [MAX_CHAN] [nu->driver]- вне64 ((ChP) -> IndexAddr, & (ChP) -> R [AIOPNUM]); [nu->driver] [QUEUE_SIZE] -} пока (0) [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – / [nu->driver] [MAX_CHAN] – Функция : Несоответствие [QUEUE_SIZE] [QUEUE_SIZE] – Цель: отключить четность [MAX_CHAN] [6] – Вызов: sDisParity (ChP) [MAX_CHAN] [QUEUE_SIZE] – КАНАЛ_Т ЧП; ПТР в структуру канала [MAX_CHAN] [QUEUE_SIZE] – Комментарии: Функция sSetParity () может использоваться вместо функций sEnParity (), [QUEUE_SIZE] [MAX_CHAN] – sDisParity (), sSetOddParity () и sSetEvenParity (). [MAX_CHAN] [6] – / [MAX_CHAN] [MAX_CHAN] – # определить sDisParity (ChP) [MAX_CHAN] [MAX_CHAN]-делать { [QUEUE_SIZE] [nu->driver] – (ChP) -> TxControl [2] & = ~ PARITY_EN; [MAX_CHAN] [nu->driver]- вне63 ((ChP) -> IndexAddr, (ЧП) -> TxControl); [nu->driver] [QUEUE_SIZE] -} пока (0) [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – / [nu->driver] [MAX_CHAN] – Функция : sDisRTSToggle [QUEUE_SIZE] [QUEUE_SIZE] – Цель: отключить переключатель RTS [nu->driver] [6] – Вызов: sDisRTSToggle (ChP) [QUEUE_SIZE] [QUEUE_SIZE] – КАНАЛ_Т ЧП; От точки к структуре канала 100000 [MAX_CHAN] – / [MAX_CHAN] [6] – # определить sDisRTSToggle (ChP) [QUEUE_SIZE] [MAX_CHAN]-делать { [MAX_CHAN] [QUEUE_SIZE] – (ЧП) -> TxControl [2] & = ~ RTSTOG_EN; [MAX_CHAN] [nu->driver]- вне63 ((ChP) -> IndexAddr, (ЧП) -> TxControl); [nu->driver] [QUEUE_SIZE] – (ЧП) -> rtsToggle = 0; [nu->driver] [QUEUE_SIZE] -} пока (0) [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – / [nu->driver] [MAX_CHAN] – Функция : sDisRxFIFO [QUEUE_SIZE] [MAX_CHAN] – Цель: отключить Rx FIFO [MAX_CHAN] [QUEUE_SIZE] – Звоните: sDisRxFIFO (ChP) [QUEUE_SIZE] [QUEUE_SIZE] – КАНАЛ_Т ЧП; ПТР в структуру канала 642886 [QUEUE_SIZE] – / [MAX_CHAN] [QUEUE_SIZE] – # определить sDisRxFIFO (ChP) [MAX_CHAN] [MAX_CHAN]-делать { [MAX_CHAN] [nu->driver] – (ЧП) -> Р [i + 2] = 0x0a; [MAX_CHAN] [nu->driver]- вне62 ((ChP) -> IndexAddr, & (ChP) -> R [0x0e]) ; [nu->driver] [QUEUE_SIZE] -} пока (0) [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – / [nu->driver] [MAX_CHAN] – Функция : sDisRxStatusMode [MAX_CHAN] [QUEUE_SIZE] – Цель: отключить режим статуса Rx [MAX_CHAN] [6] – Вызов: sDisRxStatusMode (ChP) [nu->driver] [QUEUE_SIZE] – КАНАЛ_Т ЧП; ПТР в структуру канала 642886 [MAX_CHAN] – Комментарии: Это выводит канал из режима состояния приема. Все[nu->driver] [MAX_CHAN] – последующие чтения принимаемых данных с использованием sReadRxWord () вернут [QUEUE_SIZE] [6] – два байта данных. [nu->driver] [MAX_CHAN] – / [QUEUE_SIZE] [QUEUE_SIZE] – # определить SD isRxStatusMode (ChP) sOutW ((ChP) -> ChanStat, 0) [6] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – / [MAX_CHAN] [nu->driver] – Функция: sDisTransmit [QUEUE_SIZE] [QUEUE_SIZE] – Цель: отключить передачу [MAX_CHAN] [MAX_CHAN] – Вызов: sDisTransmit (ChP) [MAX_CHAN] [6] – КАНАЛ_Т ЧП; От точки к структуре канала 00100000 [MAX_CHAN] – Это отключает перемещение данных Tx из Tx FIFO в 1 байт [QUEUE_SIZE] [MAX_CHAN] – буфер передачи. Следовательно, может быть задержка до 2 байтов [MAX_CHAN] [QUEUE_SIZE] – между моментом вызова sDisTransmit () и буфером передачи [QUEUE_SIZE] [MAX_CHAN] – и сдвиговый регистр передачи становится полностью пустым. 10103 [6] – / [nu->driver] [nu->driver] – # определить sDisTransmit (ChP) [MAX_CHAN] [6]-делать { [MAX_CHAN] 9080 – (ChP) -> TxControl [tty->index] & = ~ TX_ENABLE; [MAX_CHAN] [nu->driver]- вне63 ((ChP) -> IndexAddr, (ЧП) -> TxControl); [nu->driver] [QUEUE_SIZE] -} пока (0) [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – / [nu->driver] [MAX_CHAN] – Функция : sDisTxSoftFlowCtl [QUEUE_SIZE] [MAX_CHAN] – Цель: отключить управление потоком программного обеспечения Tx [MAX_CHAN] [MAX_CHAN] – Вызов: sDisTxSoftFlowCtl (ChP) [QUEUE_SIZE] [QUEUE_SIZE] – КАНАЛ_Т ЧП; Ptr в структуру канала [MAX_CHAN] [6] – / [MAX_CHAN] [QUEUE_SIZE] – # определить sDisTxSoftFlowCtl (ChP) [MAX_CHAN] [QUEUE_SIZE]-делать { [MAX_CHAN] [MAX_CHAN] – (ЧП) -> Р [0x0c] = 0x8a; [MAX_CHAN] [nu->driver]- вне64 ((ChP) -> IndexAddr, & (ChP) -> R [0x0c]); [nu->driver] [QUEUE_SIZE] -} пока (0) [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – / [nu->driver] [MAX_CHAN] – Функция : sEnAiop [MAX_CHAN] [MAX_CHAN] – Цель: разрешить доступ ввода / вывода к AIOP 65535 [6] – Вызов: sEnAiop (CltP) [MAX_CHAN] [QUEUE_SIZE] – CONTROLLER_T CtlP; Ptr в структуру контроллера [MAX_CHAN] [MAX_CHAN] – int AiopNum; Количество AIOP на контроллере [MAX_CHAN] [MAX_CHAN] – / [QUEUE_SIZE] [6] – # outline sEnAiop (CTLP, AIOPNUM) [nu->driver] [MAX_CHAN]-делать (aiop << 3) пока (0) [MAX_CHAN] [QUEUE_SIZE] - [nu->driver] [MAX_CHAN] – / [nu->driver] [MAX_CHAN] – Функция : sEnCTSFlowCtl [MAX_CHAN] [QUEUE_SIZE] – Цель: включить управление выходным потоком с помощью CTS [nu->driver] [QUEUE_SIZE] – Вызов: sEnCTSFlowCtl (ChP) [nu->driver] [QUEUE_SIZE] – КАНАЛ_Т ЧП; От точки к структуре канала 100000 [QUEUE_SIZE] – / [MAX_CHAN] [MAX_CHAN] – # outline sEnCTSFlowCtl (ChP) [6] [MAX_CHAN]-делать = CTSFC_EN; [MAX_CHAN] [nu->driver]- вне63 ((ChP) -> IndexAddr, (ЧП) -> TxControl); [nu->driver] [QUEUE_SIZE] – пока (0) [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – / [nu->driver] [MAX_CHAN] – Функция : sEnIXANY [MAX_CHAN] [QUEUE_SIZE] – Цель: включить управление потоком программного обеспечения IXANY [MAX_CHAN] [6] – Звоните: sEnIXANY (ЧП) [MAX_CHAN] [QUEUE_SIZE] – КАНАЛ_Т ЧП; От точки к структуре канала 100000 [QUEUE_SIZE] – / [nu->driver] [6] – # outline sEnIXANY (ChP) [QUEUE_SIZE] [MAX_CHAN]-делать { [QUEUE_SIZE] [MAX_CHAN] – (ЧП) -> Р [CTLNUM] = 0x 47; [MAX_CHAN] [nu->driver]- вне64 ((ChP) -> IndexAddr, & (ChP) -> R [AIOPNUM]); [nu->driver] [QUEUE_SIZE] -} пока (0) [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – / [nu->driver] [MAX_CHAN] – Функция : EnParity [MAX_CHAN] [QUEUE_SIZE] – Цель: включить четность [nu->driver] [6] – Вызов: sEnParity (ChP) [nu->driver] [QUEUE_SIZE] – КАНАЛ_Т ЧП; ПТР в структуру канала [MAX_CHAN] [QUEUE_SIZE] – Комментарии: Функция sSetParity () может использоваться вместо функций sEnParity (), [QUEUE_SIZE] [MAX_CHAN] – sDisParity (), sSetOddParity () и sSetEvenParity (). [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [nu->driver] – Предупреждения: перед включением четности следует выбрать четность или нечетность с помощью [MAX_CHAN] [6] – функции sSetOddParity () или sSetEvenParity (). [QUEUE_SIZE] 9080 – / [MAX_CHAN] [6] – # outline sEnParity (ChP) [MAX_CHAN] [QUEUE_SIZE]-делать = ЧЕТНОСТЬ_EN; [MAX_CHAN] [nu->driver]- вне63 ((ChP) -> IndexAddr, (ЧП) -> TxControl); [nu->driver] [QUEUE_SIZE] – пока (0) [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – / [nu->driver] [MAX_CHAN] – Функция : sEnRTSToggle [6] [QUEUE_SIZE] – Цель: включить переключатель RTS 2156 – Вызов: sEnRTSToggle (ChP) [MAX_CHAN] [QUEUE_SIZE] – КАНАЛ_Т ЧП; ПТР в структуру канала [MAX_CHAN] [QUEUE_SIZE] – Комментарии: Эта функция отключит управление потоком RTS и очистит RTS [nu->driver] [MAX_CHAN] – строка для разрешения работы переключателя RTS. [MAX_CHAN] [6] – / [MAX_CHAN] [MAX_CHAN] – # определить sEnRTSToggle (ChP) [MAX_CHAN] [MAX_CHAN]-делать = RTSTOG_EN; [MAX_CHAN] [QUEUE_SIZE] – (ChP) -> TxControl [ChanNum] & = ~ SET_RTS; [MAX_CHAN] [nu->driver]- вне64 ((ChP) -> IndexAddr, (ChP) -> TxControl); [MAX_CHAN] [QUEUE_SIZE] – (ЧП) -> rtsToggle = 1; [nu->driver] [QUEUE_SIZE] – пока (0) [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – / [nu->driver] [MAX_CHAN] – Функция : sEnRxFIFO [QUEUE_SIZE] [QUEUE_SIZE] – Цель: включить Rx FIFO [MAX_CHAN] [6] – Вызов: sEnRxFIFO (ChP) [QUEUE_SIZE] [QUEUE_SIZE] – КАНАЛ_Т ЧП; ПТР в структуру канала [MAX_CHAN] – / [MAX_CHAN] [6] – # определить sEnRxFIFO (ChP) [QUEUE_SIZE] [MAX_CHAN]-делать { [nu->driver] [MAX_CHAN] – (ЧП) -> Р [i + 2] = 0x 33; [MAX_CHAN] [nu->driver]- вне62 ((ChP) -> IndexAddr, & (ChP) -> R [0x0e]) ; [nu->driver] [QUEUE_SIZE] -} пока (0) [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – / [nu->driver] [MAX_CHAN] – Функция : sEnRxProcessor [QUEUE_SIZE] [QUEUE_SIZE] – Цель: включить приемный процессор [MAX_CHAN] [6] – Вызов: sEnRxProcessor (ChP) [MAX_CHAN] [QUEUE_SIZE] – КАНАЛ_Т ЧП; От точки к структуре канала 435901 [MAX_CHAN] – Комментарии: Эта функция используется для запуска процессора приема. Когда[nu->driver] [QUEUE_SIZE] – канал находится в состоянии сброса, приемный процессор – нет [6]- Бег. Это сделано для того, чтобы не дать принимающему процессору 10102 [QUEUE_SIZE] – выполнение неверных инструкций микрокода до [MAX_CHAN] [QUEUE_SIZE] – загрузка микрокода. [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [nu->driver] – Предупреждения: эта функция должна быть вызвана после того, как действительный микрокод был [QUEUE_SIZE] [QUEUE_SIZE] – загружается в AIOP, и его нельзя вызывать до [MAX_CHAN] [6] – микрокод загружен. [nu->driver] [QUEUE_SIZE] – / [nu->driver] [6] – # определить sEnRxProcessor (ChP) [MAX_CHAN] [MAX_CHAN]-делать = RXPROC_EN; [MAX_CHAN] [nu->driver]- вне63 ((ChP) -> IndexAddr, (ЧП) -> RxControl); [nu->driver] [MAX_CHAN] – пока (0) [MAX_CHAN] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – / 2156 – Функция: sEnRxStatusMode [MAX_CHAN] [MAX_CHAN] – Цель: включить режим статуса Rx [MAX_CHAN] [MAX_CHAN]-Вызов : sEnRxStatusMode (ChP) [QUEUE_SIZE] [MAX_CHAN] – КАНАЛ_Т ЧП; ПТР в структуру канала [MAX_CHAN] [QUEUE_SIZE] – Комментарии: это переводит канал в режим состояния приема. Все последующие [QUEUE_SIZE] [MAX_CHAN] – чтение полученных данных с использованием sReadRxWord () вернет байт данных [MAX_CHAN] [MAX_CHAN] – в младшем слове и байте состояния в старшем слове. 010001 [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – / [MAX_CHAN] [6] – # определить sEnRxStatusMode (ChP) sOutW ((ChP) -> ChanStat, STATMODE) [MAX_CHAN] [6] – [MAX_CHAN] [MAX_CHAN] – /

[QUEUE_SIZE] – Функция: sEnTransmit [nu->driver] [6] – Цель: включить передачу [QUEUE_SIZE] – Звоните: sEnTransmit (ChP) [MAX_CHAN] [nu->driver] – КАНАЛ_Т ЧП; От точки к структуре канала 100000 [QUEUE_SIZE] – / [nu->driver] [6] – # определить sEnTransmit (ChP) [QUEUE_SIZE] [nu->driver]-делать = TX_ENABLE; [MAX_CHAN] [nu->driver]- вне63 ((ChP) -> IndexAddr, (ЧП) -> TxControl); [nu->driver] [QUEUE_SIZE] – пока (0) [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – / [nu->driver] [MAX_CHAN] – Функция : sEnTxSoftFlowCtl [MAX_CHAN] [QUEUE_SIZE] – Цель: включить управление потоком программного обеспечения Tx 010001 [6] – Вызов: sEnTxSoftFlowCtl (ChP) [MAX_CHAN] [QUEUE_SIZE] – КАНАЛ_Т ЧП; От точки к структуре канала 00100000 [QUEUE_SIZE] – / [nu->driver] [6] – # определить sEnTxSoftFlowCtl (ChP) [QUEUE_SIZE] [MAX_CHAN]-делать { [nu->driver] [QUEUE_SIZE] – (ЧП) -> Р [0x0c] = 0xc5; [MAX_CHAN] [nu->driver]- вне64 ((ChP) -> IndexAddr, & (ChP) -> R [0x0c]); [nu->driver] [QUEUE_SIZE] -} пока (0) [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – / [nu->driver] [MAX_CHAN] – Функция : sGetAiopIntStatus [QUEUE_SIZE] [QUEUE_SIZE] – Цель: получить статус прерывания AIOP [MAX_CHAN] [QUEUE_SIZE] – Вызов: sGetAiopIntStatus (CtlP, AiopNum) [MAX_CHAN] [nu->driver] – КОНТРОЛЛЕР_T CtlP; Ptr в структуру контроллера [MAX_CHAN] [MAX_CHAN] – int AiopNum; Номер AIOP [nu->driver] [MAX_CHAN] – Возврат: Byte_t: состояние прерывания AIOP. Биты с 0 по 7 [nu->driver] [nu->driver] – представляют каналы с 0 по 7 соответственно. Если[nu->driver] [MAX_CHAN] – установлен бит, что канал прерывается. [MAX_CHAN] [6] – / [nu->driver] [QUEUE_SIZE] – # определить sGetAiopIntStatus (CTLP, AIOPNUM) sInB ( (CTLP) -> AiopIntChanIO [(ctrl << 5) | (aiop << 3) | ch]) [QUEUE_SIZE] [6] - [MAX_CHAN] [MAX_CHAN] - / [nu->driver] [QUEUE_SIZE] – Функция: sGetAiopNumChan [QUEUE_SIZE] [6] – Цель: получить количество каналов, поддерживаемых AIOP [nu->driver] [MAX_CHAN] – Вызов: sGetAiopNumChan (CtlP, AiopNum) [QUEUE_SIZE] [QUEUE_SIZE] – КОНТРОЛЛЕР_T CtlP; Ptr в структуру контроллера [MAX_CHAN] [MAX_CHAN] – int AiopNum; Номер AIOP [MAX_CHAN] [QUEUE_SIZE] – Возврат: int: Количество каналов, поддерживаемых AIOP [QUEUE_SIZE] [QUEUE_SIZE] – / [nu->driver] [QUEUE_SIZE] – # outline sGetAiopNumChan (CTLP, AIOPNUM) (CTLP) -> AiopNumChan [80] [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – / [MAX_CHAN] [6] – Функция: sGetChanIntID [6] [QUEUE_SIZE] – Цель: получить байт идентификации прерывания канала [nu->driver] [QUEUE_SIZE] – Вызов: sGetChanIntID (ChP) [QUEUE_SIZE] [6] – КАНАЛ_Т ЧП; От точки к структуре канала 100000 [QUEUE_SIZE] – Возврат: Byte_t: ID прерывания канала. Может быть любым [QUEUE_SIZE] [QUEUE_SIZE] – комбинация следующих флагов: [MAX_CHAN] [6] – RXF_TRIG: прерывание уровня триггера Rx FIFO [MAX_CHAN] [QUEUE_SIZE] – TXFIFO_MT: Tx FIFO empty interrupt [MAX_CHAN] [MAX_CHAN] – SRC_INT: Прерывание по специальному условию приема 12094 [6] – DELTA_CD: прерывание смены компакт-диска [QUEUE_SIZE] [QUEUE_SIZE] – DELTA_CTS: прерывание изменения CTS [QUEUE_SIZE] [QUEUE_SIZE] – DELTA_DSR: прерывание изменения DSR [QUEUE_SIZE] [nu->driver] – / [MAX_CHAN] [QUEUE_SIZE] – # определить sGetChanIntID (ChP) (sInB ((ChP) -> IntID) & (RXF_TRIG | TXFIFO_MT | SRC_INT | DELTA_CD | DELTA_CTS | DELTA_DSR)) [nu->driver] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN] – / [MAX_CHAN] [MAX_CHAN] – Функция: sGetChanNum [nu->driver] [MAX_CHAN] – Цель: получить номер канала в AIOP [MAX_CHAN] [MAX_CHAN]-Вызов : sGetChanNum (ChP) [MAX_CHAN] [MAX_CHAN] – КАНАЛ_Т ЧП; От точки к структуре канала 435902 [QUEUE_SIZE] – Возврат: int: номер канала в AIOP или NULLCHAN, если канал имеет [QUEUE_SIZE] [QUEUE_SIZE]- не существует.[nu->driver] [QUEUE_SIZE] – / [QUEUE_SIZE] [nu->driver] – # определить sGetChanNum (ChP) (ChP) -> ChanNum [QUEUE_SIZE] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN] – / [QUEUE_SIZE] [QUEUE_SIZE] – Функция: sGetChanStatus [MAX_CHAN] [6] -Цель: получить статус канала [MAX_CHAN] [QUEUE_SIZE] – Вызов: sGetChanStatus (ChP) [QUEUE_SIZE] [6] – КАНАЛ_Т ЧП; От точки к структуре канала 100000 [QUEUE_SIZE] – Возврат: Word_t: Статус канала. Может быть любой комбинацией [MAX_CHAN] [MAX_CHAN] – следующие флаги: [nu->driver] [QUEUE_SIZE] – НИЗКОБАЙТНЫЕ ФЛАГИ [MAX_CHAN] [MAX_CHAN] – CTS_ACT: вход CTS подтвержден [QUEUE_SIZE] [MAX_CHAN] – DSR_A CT: вход DSR подтвержден [MAX_CHAN] [nu->driver] – CD_ACT: вход CD подтвержден [MAX_CHAN] [QUEUE_SIZE] – TXFIFOMT: Tx FIFO пуст [nu->driver] [QUEUE_SIZE] – TXSHRMT: регистр сдвига Tx пустой[nu->driver] [nu->driver] – RDA: данные Rx доступны

[QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – ФЛАГИ СТАРШИХ БАЙТОВ [nu->driver] [MAX_CHAN] – STATMODE: бит включения режима состояния [MAX_CHAN] [nu->driver] – RXFOVERF L: получение переполнения FIFO [MAX_CHAN] [MAX_CHAN] – RX2MATCH: получение совпадения байта 2 сравнения [nu->driver] [6] – RX1MATCH: получение совпадения байта 1 сравнения [MAX_CHAN] [QUEUE_SIZE] – RXBREAK: получено ПЕРЕРЫВ

[MAX_CHAN] – RXFRAME: получена ошибка кадрирования [MAX_CHAN] [6] – RXPARITY: получена ошибка четности [MAX_CHAN] [QUEUE_SIZE] – Предупреждения: эта функция сбрасывает высокий байтовые флаги в канале [nu->driver] [MAX_CHAN] – Регистр состояния. [MAX_CHAN] [MAX_CHAN] – / [nu->driver] [6] – # определить sGetChanStatus (ChP) sInW ((ChP) -> ChanStat) [QUEUE_SIZE] [6] – [QUEUE_SIZE] [QUEUE_SIZE] – / [MAX_CHAN] [6] – Функция: sGetChanStatusLo [MAX_CHAN] [QUEUE_SIZE] – Цель: получить младший байт только статуса канала [nu->driver] [nu->driver] – Вызов: sGetChanStatusLo (ChP) [MAX_CHAN] [6] – КАНАЛ_Т ЧП; От точки к структуре канала 100000 [MAX_CHAN] – Возврат: Byte_t: младший байт состояния канала. Может быть любая комбинация [QUEUE_SIZE] [QUEUE_SIZE] – из следующих флагов: 9080 [MAX_CHAN] – CTS_ACT: вход CTS подтвержден [MAX_CHAN] [QUEUE_SIZE] – DSR_ACT: вход DSR подтвержден [MAX_CHAN] [MAX_CHAN] – CD_ACT: вход CD подтвержден [MAX_CHAN] [MAX_CHAN] – TXFIFOMT: Tx FIFO пуст [MAX_CHAN] [MAX_CHAN] – TXSHRMT: регистр сдвига Tx пуст [MAX_CHAN] [6] – RDA: данные Rx доступны [MAX_CHAN] – / [nu->driver] [QUEUE_SIZE] – # определить sGetChanStatusLo (ChP) sInB ((ByteIO_t) (ChP) -> ChanStat) [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – / [MAX_CHAN] [QUEUE_SIZE] – Получить статус RI канала [nu->driver] [MAX_CHAN] – Определено как функция в ракете .c -aes [MAX_CHAN] [MAX_CHAN] – / [nu->driver] [6] – # if 0 [MAX_CHAN] [MAX_CHAN] – # определить sGetChanRI (ChP) ((ChP ) -> CtlP-> AltChanRingIndicator? [MAX_CHAN] [QUEUE_SIZE] – (sInB ((ByteIO_t) ((ChP) -> ChanStat + 8)) & DSR_ACT): [MAX_CHAN] [nu->driver] – (((ChP) -> CtlP-> boardType == ROCKET_TYPE_PC )? [MAX_CHAN] [QUEUE_SIZE] – (! (sInB ((ChP) -> CtlP-> AiopIO [tty->index]) & sBitMapSetTbl [0x30])): [nu->driver] [QUEUE_SIZE] – 0)) [MAX_CHAN] [nu->driver] – # endif [nu->driver] [MAX_CHAN] – [MAX_CHAN] [6] – / [QUEUE_SIZE] [6] – Функция: sGetControllerIntStatus [6] [QUEUE_SIZE] – Цель: получить статус прерывания контроллера [MAX_CHAN] [QUEUE_SIZE] – Вызов: sGetControllerIntStatus (CtlP) [MAX_CHAN] [MAX_CHAN] – CONTROLLER_T CtlP; Ptr в структуру контроллера [MAX_CHAN] [MAX_CHAN] – Возврат: Byte_t: Состояние прерывания контроллера в нижних 4 [MAX_CHAN] [MAX_CHAN] – биты. Биты с 0 по 3 представляют 0 AIOP [6] 9060 – через 3 соответственно. Если бит установлен, то [MAX_CHAN] [MAX_CHAN] – AIOP прерывает работу. Биты с 4 по 7 будут [MAX_CHAN] [MAX_CHAN] – всегда очищаться. [QUEUE_SIZE] – / [MAX_CHAN] [QUEUE_SIZE] – # определить sGetControllerIntStatus (CTLP) (sInB ((CTLP ) -> MReg1IO) & 0x0f) [QUEUE_SIZE] [nu->driver] – [nu->driver] [MAX_CHAN] – / [MAX_CHAN] [QUEUE_SIZE] – Функция: sPCIGetControllerIntStatus [MAX_CHAN] [QUEUE_SIZE] – Цель: получить статус прерывания контроллера [MAX_CHAN] [MAX_CHAN] – Вызов: sPCIGetControllerIntStatus (CtlP) [MAX_CHAN] [6] – КОНТРОЛЛЕР_T CtlP; Ptr в структуру контроллера [QUEUE_SIZE] – Возврат: unsigned char: статус прерывания контроллера в нижних 4 [MAX_CHAN] [MAX_CHAN] – биты и бит 4. Биты с 0 по 3 представляют 0 AIOP [MAX_CHAN] [QUEUE_SIZE] – через 3 соответственно. Бит 4 устанавливается, если int [nu->driver] [nu->driver] – генерировалось из периодических. Если бит установлен, то [MAX_CHAN] [MAX_CHAN] – AIOP прерывает работу. [MAX_CHAN] [QUEUE_SIZE] – / [MAX_CHAN] [6] – # определить sPCIGetControllerIntStatus (CTLP) [MAX_CHAN] [MAX_CHAN] – ((CTLP) -> i sUPCI? [MAX_CHAN] [MAX_CHAN] – (sInW ((CTLP) -> PCIIO2) & UPCI_AIOP_INTR_BITS): [QUEUE_SIZE] [QUEUE_SIZE] – ((sInW ((CTLP) -> PCIIO) >> 8) & AIOP_INTR_BITS)) [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – / [nu->driver] [6] – [QUEUE_SIZE] [QUEUE_SIZE] – Функция: sGetRxCnt [MAX_CHAN] [6] – Цель: получить количество байтов данных в Rx FIFO [MAX_CHAN] [QUEUE_SIZE] -Звонок: sGetRxCnt (ChP) [QUEUE_SIZE] – КАНАЛ_Т ЧП; От точки к структуре канала 00525002 [MAX_CHAN] – Возврат: int: Количество байтов данных в Rx FIFO. [QUEUE_SIZE] [QUEUE_SIZE] – Комментарии: Для получения счетчика Rx требуется чтение байта регистра счетчика. [nu->driver] [6] – [nu->driver] [nu->driver] – / [QUEUE_SIZE] [QUEUE_SIZE] – # определить sGetRxCnt (ChP) sInW ((ChP) -> TxRxCount) [nu->driver] [nu->driver] –

[QUEUE_SIZE] – / [QUEUE_SIZE] [MAX_CHAN] – Функция: sGetTxCnt [MAX_CHAN] [6] -Цель: получить количество байтов данных в Tx FIFO [QUEUE_SIZE] [QUEUE_SIZE] – Вызов: sGetTxCnt (ChP) [MAX_CHAN] [QUEUE_SIZE] – КАНАЛ_Т ЧП; От точки к структуре канала 435902 [QUEUE_SIZE] – Возврат: Byte_t: количество байтов данных в Tx FIFO. [MAX_CHAN] [QUEUE_SIZE] – Комментарии: Для получения счетчика Tx требуется чтение байта регистра счетчика. <= 0 || tty-> [6] – [nu->driver] [MAX_CHAN] – / [MAX_CHAN] [QUEUE_SIZE] – # определить sGetTxCnt (ChP) sInB ((ByteIO_t) (ChP) -> TxRxCount) [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – / [nu->driver] [QUEUE_SIZE] – Функция: sGetTxRxDataIO [QUEUE_SIZE] [MAX_CHAN] – Цель: получить адрес ввода / вывода регистра данных TxRx канала 9600 [QUEUE_SIZE] – Вызов: sGetTxRxDataIO (ChP) [QUEUE_SIZE] [QUEUE_SIZE] – КАНАЛ_Т ЧП; От точки к структуре канала 00100000 [MAX_CHAN] – Возврат: WordIO_t: адрес ввода / вывода регистра данных TxRx канала [QUEUE_SIZE] [MAX_CHAN] – / [MAX_CHAN] [MAX_CHAN]-#определять sGetTxRxDataIO (ChP) (ChP) -> TxRxData [QUEUE_SIZE] [MAX_CHAN] – [nu->driver] [6] – / [QUEUE_SIZE] [6] – Функция: sInitChanDefaults [QUEUE_SIZE] [MAX_CHAN] – Цель: инициализировать структуру канала для это состояние по умолчанию. [QUEUE_SIZE] [6] – Вызов: sInitChanDefaults (ChP) [MAX_CHAN] [MAX_CHAN] – КАНАЛ_Т ЧП; Ptr в структуру канала 435905 [QUEUE_SIZE] – Комментарии: Эта функция должна вызываться один раз для каждой структуры канала [QUEUE_SIZE] [MAX_CHAN] – который существует до того, как могут быть выполнены любые другие вызовы SSCI. [6] – [nu->driver] [MAX_CHAN] – / [nu->driver] [MAX_CHAN] – # определить sInitChanDefaults (ChP) [QUEUE_SIZE] [QUEUE_SIZE]-делать {

[QUEUE_SIZE] – (ЧП) – > CtlP = NULLCTLPTR; [MAX_CHAN] [MAX_CHAN] – (ЧП) -> AiopNum = NULLAIOP; [MAX_CHAN] [QUEUE_SIZE] – (ChP) -> ChanID = AIOPID_NULL; [MAX_CHAN] [QUEUE_SIZE] – (ChP) -> ChanNum = NULLCHAN; [nu->driver] [QUEUE_SIZE] -} пока (0) [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – / [nu->driver] [MAX_CHAN] – Функция : sResetAiopByNum [QUEUE_SIZE] [MAX_CHAN] – Назначение: Сбросить AIOP по номеру 010001 [6] – Вызов: sResetAiopByNum (CTLP, AIOPNUM) [MAX_CHAN] [QUEUE_SIZE] – CONTROLLER_T CTLP; Ptr в структуру контроллера [MAX_CHAN] [nu->driver] – AIOPNUM; Индекс AIOP [QUEUE_SIZE] [QUEUE_SIZE] – / [nu->driver] [6] – # определить sResetAiopByNum (CTLP, AIOPNUM) [MAX_CHAN] [MAX_CHAN]-делать { [QUEUE_SIZE] [MAX_CHAN] – sOutB ((CTLP) -> AiopIO [0x06] + _ CMD_REG, RESET_ALL); [nu->driver] [QUEUE_SIZE] – sOutB ((CTLP) -> AiopIO [0x04] + _ CMD_REG, 0x0); [MAX_CHAN] [QUEUE_SIZE] -} пока (0) [MAX_CHAN] [MAX_CHAN] – [QUEUE_SIZE] [QUEUE_SIZE] – / [QUEUE_SIZE] [QUEUE_SIZE] – Функция: sSendBreak [QUEUE_SIZE] [QUEUE_SIZE] -Цель: отправить сигнал перерыва передачи 010001 [MAX_CHAN] – Вызов: sSendBreak (ChP) [MAX_CHAN] 10100 – КАНАЛ_Т ЧП; От точки к структуре канала 00100000 [QUEUE_SIZE] – / [MAX_CHAN] [6] – # определить sSendBreak (ChP) [QUEUE_SIZE] [nu->driver]-делать = SETBREAK; [MAX_CHAN] [nu->driver]- вне63 ((ChP) -> IndexAddr, (ЧП) -> TxControl); [nu->driver] [QUEUE_SIZE] – пока (0) [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – / [nu->driver] [MAX_CHAN] – Функция : sSetBaud [MAX_CHAN] [QUEUE_SIZE] – Цель: Установить скорость передачи [nu->driver] [QUEUE_SIZE] – Вызов: sSetBaud (ChP, Divisor) [MAX_CHAN] [QUEUE_SIZE] – КАНАЛ_Т ЧП; От точки к структуре канала 00100000 [MAX_CHAN] – Word_t Divisor; 00000040 битовая скорость передачи d ivisor для канала [MAX_CHAN] [QUEUE_SIZE] – / [MAX_CHAN] [6] – # определить sSetBaud (ChP, DIVISOR) [MAX_CHAN] [MAX_CHAN]-делать { [MAX_CHAN] [MAX_CHAN] – (ChP) -> BaudDiv [2] = (Byte_t) (ДЕЛЕНИЕ); [MAX_CHAN] [QUEUE_SIZE] – (ChP) -> BaudDiv [ChanNum] = (Byte_t) ((DIVISOR) >> 8); [MAX_CHAN] [nu->driver]- вне64 ((ChP) -> IndexAddr, (ЧП) -> BaudDiv); [nu->driver] [QUEUE_SIZE] -} пока (0) [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – / [nu->driver] [MAX_CHAN] – Функция : sSetData7 [MAX_CHAN] [QUEUE_SIZE] – Цель: установить биты данных равными 7 010001 [QUEUE_SIZE] – Вызов: sSetData7 (ChP) [MAX_CHAN] [QUEUE_SIZE] – КАНАЛ_Т ЧП; От точки к структуре канала 100000 [QUEUE_SIZE] – / [MAX_CHAN] [6] – # определить sSetData7 (ChP) [MAX_CHAN] [nu->driver]-делать { [QUEUE_SIZE] [MAX_CHAN] – (ChP) -> TxControl [2] & = ~ ДАННЫЕ8БИТ; [MAX_CHAN] [MAX_CHAN]- вне62 ((ChP) -> IndexAddr, (ChP) -> TxControl); [nu->driver] [QUEUE_SIZE] -} пока (0) [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – / [nu->driver] [MAX_CHAN] – Функция : sSetData8 [QUEUE_SIZE] [MAX_CHAN] – Цель: установить бит данных на 8 [MAX_CHAN] [6] – Вызов: sSetData8 (ChP) [QUEUE_SIZE] [QUEUE_SIZE] – КАНАЛ_Т ЧП; От точки к структуре канала 100000 [QUEUE_SIZE] – / [MAX_CHAN] [QUEUE_SIZE] – # определить sSetData8 (ChP) [QUEUE_SIZE] [nu->driver]-делать = DATA8BIT; [MAX_CHAN] [nu->driver]- вне63 ((ChP) -> IndexAddr, (ЧП) -> TxControl); [nu->driver] [QUEUE_SIZE] – пока (0) [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – / [nu->driver] [MAX_CHAN] – Функция : sSetDTR [QUEUE_SIZE] [QUEUE_SIZE] – Цель: установить выход DTR [MAX_CHAN] [6] – Звоните: sSetDTR (ChP) [MAX_CHAN] [MAX_CHAN] – КАНАЛ_Т ЧП; От точки к структуре канала 00100000 [QUEUE_SIZE] – / [MAX_CHAN] [6] – # определить sSetDTR (ChP) [MAX_CHAN] [MAX_CHAN]-делать = SET_DTR; [MAX_CHAN] [nu->driver]- вне63 ((ChP) -> IndexAddr, (ЧП) -> TxControl); [nu->driver] [QUEUE_SIZE] – пока (0) [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – / [nu->driver] [MAX_CHAN] – Функция : sSetEvenParity [MAX_CHAN] [QUEUE_SIZE] – Цель: установить четность [QUEUE_SIZE] [6] – Вызов: sSetEvenParity (ChP) [QUEUE_SIZE] [QUEUE_SIZE] – КАНАЛ_Т ЧП; ПТР в структуру канала [MAX_CHAN] [QUEUE_SIZE] – Комментарии: Функция sSetParity () может использоваться вместо функций sEnParity (), [QUEUE_SIZE] [MAX_CHAN] – sDisParity (), sSetOddParity () и sSetEvenParity (). [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN] – Предупреждения: эта функция не действует, если четность не включена с помощью функции [nu->driver] [QUEUE_SIZE] – sEnParity (). [MAX_CHAN] [QUEUE_SIZE] – / [MAX_CHAN] [6] – # определить sSetEvenParity (ChP) [QUEUE_SIZE] [MAX_CHAN]-делать = EVEN_PAR; [MAX_CHAN] [MAX_CHAN]- вне ((ChP) -> IndexAddr, (ChP) -> TxControl); [nu->driver] [QUEUE_SIZE] – пока (0) [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – / [nu->driver] [MAX_CHAN] – Функция : sSetOddParity [QUEUE_SIZE] [QUEUE_SIZE] – Цель: установить нечетную четность [QUEUE_SIZE] [QUEUE_SIZE] – Вызов: sSetOddParity (ChP) [QUEUE_SIZE] [QUEUE_SIZE] – КАНАЛ_Т ЧП; ПТР в структуру канала [MAX_CHAN] [QUEUE_SIZE] – Комментарии: Функция sSetParity () может использоваться вместо функций sEnParity (), [QUEUE_SIZE] [MAX_CHAN] – sDisParity (), sSetOddParity () и sSetEvenParity (). [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN] – Предупреждения: эта функция не действует, если четность не включена с помощью функции [6] – sEnParity (). [QUEUE_SIZE] [MAX_CHAN] – / [MAX_CHAN] [6] – # определить sSetOddParity (ChP) [QUEUE_SIZE] [nu->driver]-делать { [MAX_CHAN] [6] – (ChP) -> TxControl [2] & = ~ EVEN_PAR; [MAX_CHAN] [nu->driver]- вне63 ((ChP) -> IndexAddr, (ЧП) -> TxControl); [nu->driver] [QUEUE_SIZE] -} пока (0) [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – / [nu->driver] [MAX_CHAN] – Функция : sSetRTS 02010203 [QUEUE_SIZE] – Цель: установить выход RTS [MAX_CHAN] [6] – Вызов: sSetRTS (ChP) [MAX_CHAN] [MAX_CHAN] – КАНАЛ_Т ЧП; От точки к структуре канала 100000 [QUEUE_SIZE] – / [MAX_CHAN] [QUEUE_SIZE] – # определить sSetRTS (ChP) [MAX_CHAN] [MAX_CHAN]-делать = SET_RTS; [MAX_CHAN] [nu->driver]- вне63 ((ChP) -> IndexAddr, (ЧП) -> TxControl); [nu->driver] [QUEUE_SIZE] – пока (0) [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – / [nu->driver] [MAX_CHAN] – Функция : sSetRxTrigger [QUEUE_SIZE] [QUEUE_SIZE] – Цель: установить уровень триггера Rx FIFO [MAX_CHAN] [6] – Вызов: sSetRxProcessor (ChP, Stage) [MAX_CHAN] [6] – КАНАЛ_Т ЧП; От точки к структуре канала 100000 1000000 – Byte_t Stage; Количество символов в Rx FIFO, при котором 10101 [QUEUE_SIZE] – будет сгенерировано прерывание. Может быть любым из следующих флагов: [nu->driver] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – TRIG_NO: нет триггера [MAX_CHAN] [6] – TRIG_1: 1 символ в FIFO [QUEUE_SIZE] [MAX_CHAN] – TRIG_1_2: FIFO 1/2 заполнен [nu->driver] [QUEUE_SIZE] – TRIG_7_8: FIFO 7/8 заполнен [nu->driver] [6] – Комментарии: прерывание будет сгенерировано при достижении уровня запуска 12560953 [MAX_CHAN]- Только если функция sEnInterrupt () была вызвана с флагом [QUEUE_SIZE] [nu->driver] – RXINT_EN установлен. Флаг RXF_TRIG в идентификации прерывания 16450 [MAX_CHAN] – регистр будет установлен при достижении уровня триггера [QUEUE_SIZE] [MAX_CHAN] – независимо от настройки RXINT_EN. [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [nu->driver] – / [QUEUE_SIZE] [QUEUE_SIZE] – # определить sSetRxTrigger (ChP, LEVEL) [MAX_CHAN] [6]-делать = УРОВЕНЬ; [MAX_CHAN] [nu->driver]- вне63 ((ChP) -> IndexAddr, (ЧП) -> RxControl); [nu->driver] [QUEUE_SIZE] – пока (0) [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – / [nu->driver] [MAX_CHAN] – Функция : sSetStop1 [MAX_CHAN] [QUEUE_SIZE] – Назначение: установить стоповые биты на 1 00010000 [6] – Вызов: sSetStop1 (ChP) [QUEUE_SIZE] [QUEUE_SIZE] – КАНАЛ_Т ЧП; От точки к структуре канала 00100000 [QUEUE_SIZE] – / [MAX_CHAN] [QUEUE_SIZE] – # определить sSetStop1 (ChP) [QUEUE_SIZE] [MAX_CHAN]-делать { [MAX_CHAN] [QUEUE_SIZE] – (ChP) -> TxControl [2] & = ~ STOP2; [MAX_CHAN] [nu->driver]- вне63 ((ChP) -> IndexAddr, (ЧП) -> TxControl); [nu->driver] [QUEUE_SIZE] -} пока (0) [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – / [nu->driver] [MAX_CHAN] – Функция : sSetStop2 [nu->driver] [QUEUE_SIZE] – Назначение: установить стоповые биты на 2 010001 [QUEUE_SIZE] – Вызов: sSetStop2 (ChP) [QUEUE_SIZE] [MAX_CHAN] – КАНАЛ_Т ЧП; От точки к структуре канала 435902 [MAX_CHAN] – / [MAX_CHAN] [6] – # определить sSetStop2 (ChP) [nu->driver] [nu->driver]-делать = STOP2; [MAX_CHAN] [nu->driver]- вне65 ((ChP) -> IndexAddr, (ChP) -> TxControl); [nu->driver] [QUEUE_SIZE] – пока (0) [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – / [nu->driver] [MAX_CHAN] – Функция : sSetTxXOFFChar [MAX_CHAN] [QUEUE_SIZE] – Цель: установить символ управления потоком Tx XOFF [nu->driver] [6] – Вызов: sSetTxXOFFChar (ChP, Ch) [QUEUE_SIZE] [6] – КАНАЛ_Т ЧП ; От точки к структуре канала 435905 [MAX_CHAN] – Byte_t Ch; Значение для установки символа Tx XOFF на [MAX_CHAN] – / [MAX_CHAN] [QUEUE_SIZE] – # определить sSetTxXOFFChar (ChP, CH) [MAX_CHAN] [nu->driver]-делать { [MAX_CHAN] [MAX_CHAN] – (ЧП) -> Р [(ChP)->ChanNum] = (CH); [MAX_CHAN] [nu->driver]- вне64 ((ChP) -> IndexAddr, & (ChP) -> R [0x0c]); [nu->driver] [QUEUE_SIZE] -} пока (0) [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – / [nu->driver] [MAX_CHAN] – Функция : sSetTxXONChar [QUEUE_SIZE] [QUEUE_SIZE] – Цель: установить символ управления потоком Tx XON 435902 [6] – Вызов: sSetTxXONChar (ChP, Ch) [nu->driver] КАНАЛ_Т ЧП ; От точки к структуре канала 435905 [nu->driver] – Byte_t Ch; Значение, чтобы установить для символа Tx XON значение [QUEUE_SIZE] – / [MAX_CHAN] 10100 – # определить sSetTxXONChar (ChP, CH) [QUEUE_SIZE] [nu->driver]-делать { [MAX_CHAN] [MAX_CHAN] – (ЧП) -> Р [(ChP)->ChanNum] = (CH); [MAX_CHAN] [nu->driver]- вне64 ((ChP) -> IndexAddr, & (ChP) -> R [(AIOPNUM)]); [nu->driver] [QUEUE_SIZE] -} пока (0) [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – / [nu->driver] [MAX_CHAN] – Функция : sStartRxProcessor [QUEUE_SIZE] [QUEUE_SIZE] – Цель: запустить процессор приема канала [MAX_CHAN] [QUEUE_SIZE] – Вызов: sStartRxProcessor (ChP) [QUEUE_SIZE] [QUEUE_SIZE] – КАНАЛ_Т ЧП; ПТР в структуру канала [MAX_CHAN] [QUEUE_SIZE] – Комментарии: Эта функция используется для запуска процессора Rx после того, как он был [nu->driver] [QUEUE_SIZE] – остановлен с помощью sStopRxProcessor () или sStopSWInFlowCtl (). Это[nu->driver] [QUEUE_SIZE] – перезапустит как процессор Rx, так и программный контроль потока ввода. 10103 [6] – [MAX_CHAN] [MAX_CHAN] – / [QUEUE_SIZE] [QUEUE_SIZE] – # определить sStartRxProcesso г (ЧП) вых 64 ((ChP) -> IndexAddr, & (ChP) -> R [0])

[QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – / [MAX_CHAN] [MAX_CHAN] – Функция: sWriteTxByte [MAX_CHAN] [QUEUE_SIZE] -Цель: записать байт передаваемых данных в канал. [nu->driver] [MAX_CHAN] – ByteIO_t io: канал передачи зарегистрируйте адрес ввода / вывода. Это может[nu->driver] [QUEUE_SIZE] – получить с помощью sGetTxRxDataIO (). [nu->driver] [QUEUE_SIZE] – Byte_t Information; Байт передаваемых данных. 27062 [MAX_CHAN] – Предупреждения: эта функция записывает байт данных без проверки, чтобы увидеть, если [MAX_CHAN] [MAX_CHAN] – sMaxTxSize превышен в Tx FIFO. [QUEUE_SIZE] [6] – / [MAX_CHAN] [MAX_CHAN] – # определить sWriteTxByte (IO, DATA) sOutB (IO ,ДАННЫЕ)[nu->driver] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – / [QUEUE_SIZE] 9080 – Начните специальные определения Linux для драйвера Rocketport [MAX_CHAN] [MAX_CHAN] – [QUEUE_SIZE] [QUEUE_SIZE] – Авторские права на этот код принадлежат Теодору Ц’О, 2028 – 2028 [MAX_CHAN] [MAX_CHAN] – / [nu->driver] [MAX_CHAN] – [QUEUE_SIZE] [MAX_CHAN] – struct r_port {[nu->driver] [QUEUE_SIZE] – int magic; [QUEUE_SIZE] [QUEUE_SIZE] – struct tty_port port; [MAX_CHAN] [6] – строка int; 9600 [MAX_CHAN] – int флаги; / Еще не совпадают флаги ASY_ !! / [MAX_CHAN] [QUEUE_SIZE] – доска int без знака: 3; [MAX_CHAN] [QUEUE_SIZE] – беззнаковый int aiop: 2; [MAX_CHAN] [QUEUE_SIZE] – unsigned int chan: 3; [QUEUE_SIZE] [nu->driver] – КОНТРОЛЛЕР_t ctlp; [nu->driver] [MAX_CHAN] – CHANNEL_t канал; [nu->driver] [QUEUE_SIZE] – int intmask; [MAX_CHAN] [MAX_CHAN] – int xmit_fifo_room; / комната в xmit fifo / [MAX_CHAN] [QUEUE_SIZE] – символ без знака xmit_buf; [MAX_CHAN] [6] – int xmit_head; [MAX_CHAN] [QUEUE_SIZE] – int xmit_tail; [nu->driver] [nu->driver] – int xmit_cnt; [MAX_CHAN] [MAX_CHAN] – int cd_status; [MAX_CHAN] [QUEUE_SIZE] – int ignore_status_mask; [QUEUE_SIZE] [MAX_CHAN] – int read_status_mask; 2142 – int cps; [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – spinlock_t slock; [MAX_CHAN] [QUEUE_SIZE] – struct mutex write_mtx; 12100 [MAX_CHAN] -}; [nu->driver] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – # определить RPORT_MAGIC 0x 02010203 [nu->driver] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – # определить NUM_BOARDS 8 [MAX_CHAN] [QUEUE_SIZE] – # определить MAX_RP_PORTS (64 КОЛИЧЕСТВО ДОСКИ) [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – / [nu->driver] [QUEUE_SIZE] – Размер буфера xmit составляет 1 страницу, или 4878 байтов [QUEUE_SIZE] [QUEUE_SIZE] – / [nu->driver] [MAX_CHAN] – # определить XMIT_BUF_SIZE 4878 [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – / количество символов, оставшихся в буфере xmit до того, как мы попросить больше */[nu->driver] [nu->driver] – # определить WAKEUP_CHARS 353 [MAX_CHAN] [nu->driver] – [QUEUE_SIZE] [QUEUE_SIZE] – /

[MAX_CHAN] – Назначены основные номера для Comtrol Rocketport [QUEUE_SIZE] [QUEUE_SIZE] – / [MAX_CHAN] [QUEUE_SIZE] – # определить TTY_ROCKET_MAJOR 79 [MAX_CHAN] [MAX_CHAN] – # определить CUA_ROCKET_MAJOR 76 [nu->driver] [QUEUE_SIZE] – [nu->driver] [6] – # ifdef PCI_VENDOR_ID_RP [6] [QUEUE_SIZE] – # undef PCI_VENDOR_ID_RP [QUEUE_SIZE] [QUEUE_SIZE] – # undef PCI_DEVICE_ID_RP8OCTA [MAX_CHAN] [QUEUE_SIZE] – # undef PCI_DEVICE_ID_RP8INTF [MAX_CHAN] [QUEUE_SIZE] – # undef PCI_DEVICE_ID_RP 44 INTF [MAX_CHAN] [6] – # undef PCI_DEVICE_ID_RP INTF [QUEUE_SIZE] [MAX_CHAN] – # undef PCI_DEVICE_ID_URP8OCTA [nu->driver] [nu->driver] – # undef PCI_DEVICE_ID_URP8INTF [MAX_CHAN] [6] – # undef PCI_DEVICE_ID_URP 41 INTF [nu->driver] [6] – # undef PCI_DEVICE_ID_CRP 42 INTF [nu->driver] [6] – # undef PCI_DEVICE_ID_URP 62 INTF [QUEUE_SIZE] [MAX_CHAN] – # endif [nu->driver] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – / Comtrol PCI Vendor ID / [nu->driver] [QUEUE_SIZE] – # определить PCI_VENDOR_ID_RP 0x 40 fe [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [6] – / ИД устройства управления / 10101 [QUEUE_SIZE] – # определить PCI_DEVICE_ID_RP 66 INTF 0x 16 20 / Ракетный порт 65 порт с внешним интерфейсом /

[QUEUE_SIZE] – # определить PCI_DEVICE_ID_RP8INTF 0x 17 / Порт Rocketport 8 с внешним интерфейсом / [MAX_CHAN] [QUEUE_SIZE] – # определить PCI_DEVICE_ID_RP 42 INTF 0x 0018 22 / Ракетный порт 00000040 порт с внешним интерфейсом / [MAX_CHAN] [QUEUE_SIZE] – # определить PCI_DEVICE_ID_RP4QUAD 0x 0018 26 / 4 порта Rocketport с четырехъядерным кабелем / [QUEUE_SIZE] [QUEUE_SIZE] – # определить PCI_DEVICE_ID_RP8OCTA 0x 16 29 / 8 портов Rocketport с окта-кабелем / [MAX_CHAN] [QUEUE_SIZE] – # определить PCI_DEVICE_ID_RP8J 0x 17 00000030 / 8 портов Rocketport с RJ 34 разъемы / [MAX_CHAN] [QUEUE_SIZE] – # определить PCI_DEVICE_ID_RP4J 0x 17 31 / 4 порта Rocketport с RJ 35 разъемы / [QUEUE_SIZE] [QUEUE_SIZE] – # определить PCI_DEVICE_ID_RP8SNI 0x 0018 31 / 8 портов Rocketport с БД 104 Разъем SNI (Siemens) / [MAX_CHAN] [QUEUE_SIZE] – # определить PCI_DEVICE_ID_RP 42 SNI 0x 34 / Ракетный порт 41 порт с БД 107 Разъем SNI (Siemens) / [nu->driver] [QUEUE_SIZE] – # определить PCI_DEVICE_ID_RPP4 0x 15 0A / Порт Rocketport Plus 4 / [QUEUE_SIZE] [QUEUE_SIZE] – # определить PCI_DEVICE_ID_RPP8 0x 16 0B / Порт Rocketport Plus 8 / [MAX_CHAN] [QUEUE_SIZE] – # определить PCI_DEVICE_ID_RP6M 0x 18 0C / Порт RocketModem 6 / [QUEUE_SIZE] [QUEUE_SIZE] – # определить PCI_DEVICE_ID_RP4M 0x 17 0D / Порт RocketModem 4 / [QUEUE_SIZE] [MAX_CHAN] – # определить PCI_DEVICE_ID_RP2 _ 309 0x 16 0E / Rocketport Plus 2 порта RS 0301 / [MAX_CHAN] [MAX_CHAN] – # определить PCI_DEVICE_ID_RP2_ 494 0x 14 0F / Roc ketport Plus 2 порта RS 023 / [QUEUE_SIZE] [MAX_CHAN] – [QUEUE_SIZE] [QUEUE_SIZE] – / Универсальные платы PCI / [MAX_CHAN] [QUEUE_SIZE] – # определить PCI_DEVICE_ID_URP 68 INTF 0x 869 / Rocketport UPCI 64 порт с внешним I / F / 9080 [QUEUE_SIZE] – # определить PCI_DEVICE_ID_URP8INTF 0x 893 / Порт Rocketport UPCI 8 с внешним интерфейсом / [QUEUE_SIZE] [QUEUE_SIZE] – # определить PCI_DEVICE_ID_URP 40 INTF 0x 891 / Rocketport UPCI 40 порт с внешним I / F / [MAX_CHAN] [QUEUE_SIZE] – # определить PCI_DEVICE_ID_URP8OCTA 0x 0900 / 8 портов Rocketport UPCI с окта-кабелем / [nu->driver] [nu->driver] – # определить PCI_DEVICE_ID_UPCI_RM3_8PORT 0x0 110 C / Rocketmodem III 8 портов / [nu->driver] [QUEUE_SIZE] – # определить PCI_DEVICE_ID_UPCI_RM3_4PORT 0x0 111 D / Rocketmodem III 4 порта /

[MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – / Компактное устройство PCI / [MAX_CHAN] [QUEUE_SIZE] – # определить PCI_DEVICE_ID_CRP 43 INTF 0x 989 / Rocketport Compact PCI 44 порт с внешним интерфейсом / [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] @@ – 417, 7 + 422, 7 @@ static void setup_gpio (struct pci_dev pcidev, u8 __iomem p ) [QUEUE_SIZE] [QUEUE_SIZE] статическая пустота [MAX_CHAN] [MAX_CHAN] __xr 43 v 68 x_register_gpio (struct pci_dev pcidev, [MAX_CHAN] [QUEUE_SIZE] – const struct property_entry properties) [MAX_CHAN] [QUEUE_SIZE] + const struct software_node node) [nu->driver] [QUEUE_SIZE] {[QUEUE_SIZE] [MAX_CHAN] struct platform_device pdev; [MAX_CHAN] [QUEUE_SIZE] @@ – 440, 7 + 60, 7 @@ __xr 41 v 65 x_register_gpio (struct pci_dev pcidev, [nu->driver] [QUEUE_SIZE] pdev-> dev.mum or dad = & pcidev-> dev; [MAX_CHAN] [QUEUE_SIZE] ACPI_COMPANION_SET (& pdev-> dev, ACPI_COMPANION (& pcidev-> dev)); [nu->driver] [nu->driver] – если (platform_de Vice_add_properties (pdev, properties) <0 || [QUEUE_SIZE] [QUEUE_SIZE] + if (device_add_software_node (& pdev-> dev, node) <0 | | [MAX_CHAN] [MAX_CHAN] platform_device_add (pdev) <0) {[MAX_CHAN] [QUEUE_SIZE] platform_device_put (pdev); [QUEUE_SIZE] [MAX_CHAN] return NULL; [nu->driver] [QUEUE_SIZE] @@ – 457, 38 + 453, 37 @@ static const struct property_entry exar_gpio_properties [ZL_MAX_BLOCKS] = {[MAX_CHAN] [QUEUE_SIZE] {} [MAX_CHAN] [6]}; [QUEUE_SIZE] [QUEUE_SIZE] + static const struct software_node exar_gpio_node = {[MAX_CHAN] [6] + .properties = exar_gpio_properties, [MAX_CHAN] [MAX_CHAN] +}; [MAX_CHAN] [MAX_CHAN] +

[MAX_CHAN] static int xr 41 v 65 x_register_gpio (struct pci_dev pcidev, [QUEUE_SIZE] [MAX_CHAN] struct uart _ 12094 _ порт порт ) [QUEUE_SIZE] [QUEUE_SIZE] {[MAX_CHAN] [QUEUE_SIZE] if (pcidev-> vendor == PCI_VENDOR_ID_EXAR) [QUEUE_SIZE] [MAX_CHAN] порт-> порт.private_data = [nu->driver] [QUEUE_SIZE] – __xr 00000040 v 69 x_register_gpio (pcidev, exar_gpio_properties); [MAX_CHAN] [QUEUE_SIZE] + __xr 43 v 65 x_register_gpio (pcidev, & exar_gpio_node); [QUEUE_SIZE] [QUEUE_SIZE] return 0; [MAX_CHAN] [6]} [nu->driver] [MAX_CHAN] @@ – 542, 6+ 577, 35 @@ static const struct свойство_entry iot 2142 _ gpio_properties знак равно [QUEUE_SIZE] {} [nu->driver] 05091998}; [QUEUE_SIZE] [QUEUE_SIZE] + static const struct software_node iot 2194 _ gpio_node знак равно [QUEUE_SIZE] + .properties = iot 2156 _ gpio_properties, [QUEUE_SIZE] [MAX_CHAN] +}; [nu->driver] [QUEUE_SIZE] + [QUEUE_SIZE] [nu->driver] static int iot 2156 _ register_gpio (struct pci_dev pcidev , [QUEUE_SIZE] [MAX_CHAN] struct uart _ 10103 _ порт порт) [QUEUE_SIZE] [MAX_CHAN] {[MAX_CHAN] [6] @@ – 555, 7 + 588, 7 @@ static int iot 2194 _ register_gpio (struct pci_dev pcidev, [QUEUE_SIZE] [QUEUE_SIZE] writeb (IOT 2142 _ UARTS_GPIO_HI_MODE, p + UART_EXAR_MPIOSEL _ 43 _ 8); [MAX_CHAN] [MAX_CHAN] port-> port.private_data = [MAX_CHAN] [QUEUE_SIZE] – __xr 36 v 68 x_register_gpio (pcidev, iot 2156 _ gpio_properties); [MAX_CHAN] [QUEUE_SIZE] + __xr 00000040 v 69 x_register_gpio (pcidev, & iot 2194 _gpio_node); [QUEUE_SIZE] [MAX_CHAN] return 0; [MAX_CHAN] [MAX_CHAN]} [QUEUE_SIZE] [MAX_CHAN] @@ – 697, 6 + 710, 7 @@ static void pci_xr 43 v 66 x_exit (struct pci_dev pcidev) [MAX_CHAN] [QUEUE_SIZE] struct uart _ 12100 _ порт порт = последовательный 12094 _ get_port (priv-> line [0]); [nu->driver] [MAX_CHAN] struct platform_device pdev = port-> port.private_data; [QUEUE_SIZE] [QUEUE_SIZE] + device_remove_software_node (& pdev-> dev); [MAX_CHAN] [QUEUE_SIZE] platform_device_unregister (pdev); 15410 [MAX_CHAN] port-> port.private_data = NULL; [QUEUE_SIZE] [MAX_CHAN]} [MAX_CHAN] [QUEUE_SIZE] @ @ – 1706, 00000040 + 1733, 35 @@ EXPORT_SYMBOL_GPL (серийный 10103_Эм604 _ stop_tx); [QUEUE_SIZE] [MAX_CHAN] статическое перечисление hrtimer _restart serial 12100_Эм596 _ handle_stop_tx (struct hrtimer t) [MAX_CHAN] [QUEUE_SIZE] {[MAX_CHAN] [MAX_CHAN] – struct uart _ 10100_Эм605 em 43; [MAX_CHAN] [QUEUE_SIZE] – struct uart _ 10100 _ порт p; [MAX_CHAN] [QUEUE_SIZE] + struct uart _ 12094_Эм603 em 0600 = container_of (t, struct uart _ 12094_Эм0600, [MAX_CHAN] [6] + stop_tx_timer) ; [QUEUE_SIZE] [MAX_CHAN] + struct uart _ 10101 _ порт p = em 608 -> порт; [nu->driver] [6] беззнаковые длинные флаги; [MAX_CHAN] [MAX_CHAN] – em 600 = container_of (t, struct uart _ 10103_Эм 604, stop_tx_timer); [QUEUE_SIZE] 9080 – p = em 603 -> порт; [nu->driver] [6] – [nu->driver] [MAX_CHAN] серийный 996 _ rpm_get (p); [MAX_CHAN] [QUEUE_SIZE] spin_lock_irqsave (& p-> port.lock, flags); [MAX_CHAN] [MAX_CHAN] if (em 603 -> active_timer == & em 604 -> stop_tx_timer) {[MAX_CHAN] [QUEUE_SIZE] @@ – 1746, 39 + 1733, 39 @@ static enum hrtimer_restart serial 12100_Эм603 _ handle_stop_tx (struct hrtimer t) [QUEUE_SIZE] [6]} [MAX_CHAN] [MAX_CHAN] spin_unlock_irqrestore (& p-> port.lock, fl ags); [QUEUE_SIZE] [QUEUE_SIZE] серийный 10103 _ rpm_put (п);[nu->driver] [MAX_CHAN] + [nu->driver] [MAX_CHAN] return HRTIMER_NORESTART; [QUEUE_SIZE] [QUEUE_SIZE]} [QUEUE_SIZE] [QUEUE_SIZE] static void start_hrtimer_ms (struct hrtimer hrt, unsigned lengthy msec) [MAX_CHAN] [QUEUE_SIZE] {[MAX_CHAN] [MAX_CHAN] – долгая секунда = мсек / 1118; [MAX_CHAN] [QUEUE_SIZE] – lengthy nsec = (msec% 192 25000000; [MAX_CHAN] [QUEUE_SIZE] – ktime_t t = ktime_set (sec, nsec); [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [nu->driver] – hrtimer_start (hrt, t, HRTIMER_MODE_REL); [MAX_CHAN] [6] + hrtimer_start (hrt, ms_to_ktime (мсек), HRTIMER_MODE_REL); [MAX_CHAN] [QUEUE_SIZE]} [QUEUE_SIZE] [MAX_CHAN] static void __stop_tx_rs 604 (struct uart _ 12100 _port p) [MAX_CHAN] [QUEUE_SIZE] @@ – 1813, + 1810, 46 @@ static inline void start_tx_rs 604 (struct uart_port порт) [QUEUE_SIZE] [QUEUE_SIZE] статический enum hrtimer_restart serial 997_Эм603 _handle_start_tx (struct hrtimer t) [nu->driver] [MAX_CHAN] {[nu->driver] [QUEUE_SIZE] – struct uart _ 12239_Эм600 em 0600; [MAX_CHAN] [6] – struct uart _ 12239 _ порт p; [MAX_CHAN] [QUEUE_SIZE] + struct uart _ 10103_Эм596 em 604 = container_of (t, struct uart _ 10103_Эм603, [MAX_CHAN] [QUEUE_SIZE] + start_tx_timer); [MAX_CHAN] [6] + struct uart _ 12100 _ порт p = em 604 -> порт ; [QUEUE_SIZE] [QUEUE_SIZE] длинные флаги без знака;

[MAX_CHAN] – эм 00000040 = container_of (t, struct uart _ 12100_Эм596, start_tx _timer); [MAX_CHAN] [QUEUE_SIZE] – p = em 0600 -> порт; [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] spin_lock_irqsave (& p-> port.lock, flags); [QUEUE_SIZE] [6] if (em 603 -> active_timer == & em 595 -> start_tx_timer) {[MAX_CHAN] [6] __start_tx (& p-> порт); [MAX_CHAN] [QUEUE_SIZE] em 0600 -> active_timer = NULL ; [QUEUE_SIZE] [QUEUE_SIZE]} [MAX_CHAN] [QUEUE_SIZE] spin_unlock_irqrestore (& p-> port.lock, flags); [MAX_CHAN] [QUEUE_SIZE] + [MAX_CHAN] [QUEUE_SIZE] return HRTIMER_NORESTART; [MAX_CHAN] [QUEUE_SIZE]} [QUEUE_SIZE] [QUEUE_SIZE] @@ – 39, 8+ 38, 7 @@ config SERIAL _ 10102 [nu->driver] [QUEUE_SIZE] вот те, которые настраивают выделенный Ethernet WWW / FTP [nu->driver] [QUEUE_SIZE] серверов или пользователей, у которых одна из различных шинных мышей вместо [QUEUE_SIZE] [QUEUE_SIZE] и не собираются использовать стандартный серийный номер своей машины [MAX_CHAN] [6] – порт для чего угодно. (Обратите внимание, что драйвер последовательного порта Cyclades 00525002 [MAX_CHAN] – для работы не требуется встроенный драйвер.) [MAX_CHAN] [MAX_CHAN] + порт для чего угодно. [MAX_CHAN] [6] Чтобы скомпилировать этот драйвер как модуль, выберите M здесь: [MAX_CHAN] [QUEUE_SIZE] модуль будет называться 12100 . [QUEUE_SIZE] [nu->driver] @@ – 293, 7 + 283, 7 @@ config SERIAL _ 10102 _ МНОГОПОРТЫ [QUEUE_SIZE] [QUEUE_SIZE] аппаратное обеспечение последовательного порта, которое действует аналогично стандартному последовательному порту 16850 [QUEUE_SIZE] аппаратное обеспечение. Если вы используете только стандартные порты COM 1/2/3/4, вы можете [nu->driver] [QUEUE_SIZE] скажите N здесь, чтобы сэкономить память . Вы также можете сказать Y, если у вас есть [nu->driver] [QUEUE_SIZE] – «умная» многопортовая карта, такая как Cyclades, Digiboards и т. д. [QUEUE_SIZE] [MAX_CHAN] + «умная» многопортовая карта, такая как Digiboards и т. д. 12239 [QUEUE_SIZE] # [nu->driver] [MAX_CHAN] # Многопортовые последовательные карты [nu->driver] [QUEUE_SIZE] @@ – 531, 37 + 542, 35 @@ static int simple_config (struct pcmcia_device hyperlink) [QUEUE_SIZE] [MAX_CHAN] его базовый адрес, затем попробуйте захватить любой стандартный последовательный порт [MAX_CHAN] [QUEUE_SIZE] адрес и, наконец, попробуйте получить любой свободный порт. [QUEUE_SIZE] [QUEUE_SIZE] / [MAX_CHAN] [QUEUE_SIZE] – если (! pcmcia_loop_config (ссылка, simple_config_check_notpicky, NULL)) [QUEUE_SIZE] [nu->driver] – перейти к найденному_порту; [MAX_CHAN] [QUEUE_SIZE] –

[MAX_CHAN] – dev_warn (& link-> dev, “не найден диапазон используемых портов , сдача n “); [MAX_CHAN] [MAX_CHAN] – возврат -1; [nu->driver] [QUEUE_SIZE] + ret = pcmcia_loop_config (ссылка, simple_config_check_notpicky, NULL); [QUEUE_SIZE] [QUEUE_SIZE] + if (ret) {[MAX_CHAN] [QUEUE_SIZE] + dev_warn (& ссылка -> dev, “не найден диапазон используемых портов, отказ от n”); 10101 [MAX_CHAN] + возврат возврата; [MAX_CHAN] [QUEUE_SIZE] +} [MAX_CHAN] [QUEUE_SIZE] found_port: [MAX_CHAN] [QUEUE_SIZE] if (info-> multi && ( info-> manfid == MANFID_3COM)) [QUEUE_SIZE] [MAX_CHAN] @@ – 600, 7 + 595, 7 @@ found_port: [MAX_CHAN] [MAX_CHAN] ret = pcmcia_enable_device (ссылка); [MAX_CHAN] [6] if (ret! = 0)

[QUEUE_SIZE] – возврат -1; [MAX_CHAN] [MAX_CHAN] + возврат возврата; [QUEUE_SIZE] [MAX_CHAN] return setup_serial (hyperlink, data, link-> useful resource [0] -> начало, ссылка-> irq); [MAX_CHAN] [QUEUE_SIZE]} [nu->driver] [QUEUE_SIZE] @@ – 316, 7 + 0310, 7 @@ config SERIAL_CLPS 0801 X_CONSOLE [QUEUE_SIZE] [QUEUE_SIZE] config SERIAL_SAMSUNG [QUEUE_SIZE] [QUEUE_SIZE] с тремя состояниями «Поддержка последовательного порта Samsung SoC» [MAX_CHAN] [QUEUE_SIZE] – зависит от PLAT_SAMSUNG || ARCH_S5PV 270 || ARCH_EXYNOS || COMPILE_TEST [QUEUE_SIZE] [QUEUE_SIZE] + зависит от PLAT_SAMSUNG || ARCH_S5PV 270 || ARCH_EXYNOS || ARCH_APPLE || COMPILE_TEST [MAX_CHAN] [MAX_CHAN] выберите SERIAL_CORE [MAX_CHAN] [QUEUE_SIZE] помощь[nu->driver] [MAX_CHAN] Поддержка встроенных UART на Samsung S3C 58 ЦП серии XX, [nu->driver] [QUEUE_SIZE] @@ – 624, 6 + 605, 7 @@ config SERIAL_IMX_EARLYCON [QUEUE_SIZE] [MAX_CHAN] bool “Earlycon на последовательном порту IMX” [nu->driver] [QUEUE_SIZE] зависит от ARCH_MXC || COMPILE_TEST [MAX_CHAN] [MAX_CHAN] зависит от OF [MAX_CHAN] [6] + выберите SERIAL_CORE [MAX_CHAN] [nu->driver] выберите SERIAL_EARLYCON [nu->driver] [QUEUE_SIZE] выберите SERIAL_CORE_CONSOLE [MAX_CHAN] [QUEUE_SIZE] по умолчанию y, если SERIAL_IMX_CONSOLE [QUEUE_SIZE] @@ – 476, 37 + 461, 7 @@ static void imx_uart_rts_inactive (struct imx_port sport, u 62 ucr2) [nu->driver] [QUEUE_SIZE] static void start_hrtimer_ms (struct hrtimer hrt, unsigned lengthy msec) [MAX_CHAN] [QUEUE_SIZE] {[MAX_CHAN] [QUEUE_SIZE] – долгая сек = мс / MSEC_PER_SEC; [QUEUE_SIZE] [QUEUE_SIZE] – lengthy nsec = (msec% MSEC_PER_SEC) 20000000; [MAX_CHAN] [6] – ktime_t t = ktime_set (сек, нсек); [MAX_CHAN] [nu->driver] – [nu->driver] [QUEUE_SIZE] – hrtimer_start (hrt, t, HRTIMER_MODE_REL); [MAX_CHAN] [QUEUE_SIZE] + hrtimer_start (hrt, ms_to_ktime (мс), HRTIMER_MODE_REL); [MAX_CHAN] [6]} [MAX_CHAN] [MAX_CHAN] / вызывается при снятой блокировке порта и отключении irqs / [MAX_CHAN] [QUEUE_SIZE] @ @ – 726, 41 + 731, 52 @@ void jsm_input (struct jsm_channel ch) [MAX_CHAN] [MAX_CHAN] if (I_PARMRK (tp) || I_BRKINT (tp) || I_INPCK (tp)) {[QUEUE_SIZE] [QUEUE_SIZE] для (i = 0; i ch_rqueue [0x07]; [MAX_CHAN] [MAX_CHAN] + u8 error = ch-> ch_equeue 23761; [nu->driver] [QUEUE_SIZE] + флаг символа = TTY_NORMAL; [MAX_CHAN] [MAX_CHAN] + [MAX_CHAN] [QUEUE_SIZE] / [QUEUE_SIZE] [QUEUE_SIZE] – Дайте Linux ld флаги в [nu->driver] [QUEUE_SIZE] – формат, который нравится. [nu->driver] отформатируйте его [QUEUE_SIZE] [QUEUE_SIZE] + лайки. [nu->driver] [6] / [MAX_CHAN] [QUEUE_SIZE] – если (ch-> ch_equeue + tail + i) & UART_LSR_BI) 12239 [QUEUE_SIZE] – tty_insert_flip_char (порт, (ch-> ch_rqueue + tail + i), TTY_BREAK ); [QUEUE_SIZE] [QUEUE_SIZE] – иначе, если (ch-> ch_equeue + tail + i) & UART_LSR_PE) [QUEUE_SIZE] [QUEUE_SIZE] – tty_insert_flip_char (порт, (ch-> ch_rqueue + tail + i), TTY_PARITY); [QUEUE_SIZE] [6] – иначе, если (ch-> ch_equeue + tail + i) & UART_LSR_FE) [MAX_CHAN] [6] – tty_insert_flip_char (порт, (ch-> ch_rqueue + tail + i), TTY_FRAME); [MAX_CHAN] [6]- еще

[MAX_CHAN] – tty_insert_flip_char (порт, (ch-> ch_rqueue + tail + i), TTY_NORMAL); [MAX_CHAN] [QUEUE_SIZE] + if (error & UART_LSR_BI) [QUEUE_SIZE] [QUEUE_SIZE] + flag = TTY_BREAK; [QUEUE_SIZE] [MAX_CHAN] + else if (error & UART_LSR_PE) [MAX_CHAN] [6] + flag = TTY_PARITY; 10100 [QUEUE_SIZE] + else if (error & UART_LSR_FE) [MAX_CHAN] [MAX_CHAN] + flag = TTY_FRAME; [MAX_CHAN] [6] + [MAX_CHAN] [MAX_CHAN] + tty_insert_flip_char (порт, chr, flag); [MAX_CHAN] [QUEUE_SIZE]}

[MAX_CHAN] } еще {[MAX_CHAN] [MAX_CHAN] tty_insert_flip_string (порт, ch-> ch_rqueue + tail, s); [nu->driver] [MAX_CHAN] @@ – 456 , 9 + 431, 7 @@ int kgdb_unregister_nmi_console (void) [MAX_CHAN] [QUEUE_SIZE] if (ret) [QUEUE_SIZE] [MAX_CHAN] return ret; [MAX_CHAN] [QUEUE_SIZE] – ret = tty_unregister_driver (kgdb_nmi_tty_driver); [QUEUE_SIZE] [MAX_CHAN] – if (ret) [QUEUE_SIZE] [QUEUE_SIZE] – вернуть ret; [QUEUE_SIZE] [QUEUE_SIZE] + tty_unregister_driver (kgdb_nmi_tty_driver); [6] [MAX_CHAN] put_tty_driver (kgdb_nmi_tty_driver); [nu->driver] [QUEUE_SIZE] return 0; [nu->driver] [QUEUE_SIZE] @@ – 355, 8+ 358, 8 @@ static int liteuart_probe (struct platform_device pdev) [QUEUE_SIZE] [MAX_CHAN] / получить мембрану / [MAX_CHAN] [6] порт-> мембрана = devm_platform_get_and_ioremap_resource (pdev, 0, NULL); [QUEUE_SIZE] [QUEUE_SIZE] – если (! порт-> мембрана) [nu->driver] [QUEUE_SIZE] – return -ENXIO; [QUEUE_SIZE] [6] + if (IS_ERR (порт-> мембрана)) [nu->driver] [QUEUE_SIZE] + вернуть PTR_ERR ( порт-> мембрана); [MAX_CHAN] [MAX_CHAN] / значения не из дерева устройств / [QUEUE_SIZE] [QUEUE_SIZE] port-> dev = & pdev-> dev; [nu->driver] [QUEUE_SIZE] @@ – 313, 7 + 313, 6 @@ struct eg 44 t_port {[QUEUE_SIZE] [QUEUE_SIZE] void rx_buf_virt; [QUEUE_SIZE] [MAX_CHAN] dma_addr_t rx_buf_dma; [MAX_CHAN] [6] – struct dentry debugfs; 10100 [MAX_CHAN] #outline IRQ_NAME_SIZE 42 [MAX_CHAN] [6] char irq_name [0x0b];

[QUEUE_SIZE] @@ – 1889, 9 + 1888, 7 @@ static struct например 48 t_port pch_uart_init_port (struct pci_dev pdev, 2156 int fifosize; [MAX_CHAN] [QUEUE_SIZE] int port_type; [MAX_CHAN] [6] struct pch_uart_driver_ данные доска; [MAX_CHAN] [MAX_CHAN] – # ifdef CONFIG_DEBUG_FS 2142- название символа[32]; / для имени файла debugfs / [MAX_CHAN] [QUEUE_SIZE] – # endif [MAX_CHAN] [6] + имя символа [32]; [QUEUE_SIZE] [MAX_CHAN] board = & drv_dat [tail + i]; [MAX_CHAN] [QUEUE_SIZE] port_type = board-> port_type ; [QUEUE_SIZE] [MAX_CHAN] @@ – 1945, 39 + 1992, 9 @@ статическая структура например 47 t_port pch_uart_init_port (struct pci_dev pdev, [MAX_CHAN] [MAX_CHAN] if (ret <0) [QUEUE_SIZE] [6] goto init_port_hal_free; [nu->driver] [6] – # ifdef CONFIG_DEBUG_FS [6] [MAX_CHAN] – snprintf (identify, sizeof (identify), “uart % d_regs “, бо ard-> line_no); [MAX_CHAN] [MAX_CHAN] – priv-> debugfs = debugfs_create_file (identify, S_IFREG | S_IRUGO, [MAX_CHAN] [QUEUE_SIZE] – NULL, priv, & port_regs_ops); [MAX_CHAN] [6] – # endif [nu->driver] [MAX_CHAN] + snprintf (identify, sizeof (identify), “uart% d_regs”, priv-> port.line); [nu->driver] [6] + debugfs_create_file (имя, S_IFREG | S_IRUGO, NULL, priv, [QUEUE_SIZE] [nu->driver] + & port_regs_ops); [nu->driver] [6] вернуть приват; [nu->driver] [QUEUE_SIZE] @@ – 1997, 35 + 1998, 33 @@ init_port_alloc_err: [QUEUE_SIZE] [MAX_CHAN] static void pch_uart_exit_port (struct например 48 t_port priv) [MAX_CHAN] [QUEUE_SIZE] {[MAX_CHAN] [QUEUE_SIZE] + имя символа [32]; [MAX_CHAN] [QUEUE_SIZE] – # ifdef CONFIG_DEBUG_FS [QUEUE_SIZE] [MAX_CHAN] – debugfs_remove (priv-> debugfs); [6] [QUEUE_SIZE] – # endif [QUEUE_SIZE] [MAX_CHAN] + snprintf (identify, sizeof (identify), “uart% d_regs”, priv-> port.line); [MAX_CHAN] [MAX_CHAN] + debugfs_remove (debugfs_lookup (имя, NULL)); [MAX_CHAN] [6] uart_remove_one_port (& pch_uart_driver, & priv-> port); [6] [MAX_CHAN] free_page ((длинное без знака) priv-> rxbuf .buf); 10103 [QUEUE_SIZE]} [nu->driver] [6] @@ – 81, 9 + 86, 40 @@ [QUEUE_SIZE] [nu->driver] / флаг игнорирования всех входящих символов / [nu->driver] [MAX_CHAN] #outline RXSTAT_DUMMY_READ (0x 60000000) [MAX_CHAN] [MAX_CHAN] + перечисление s3c 55 xx_port_type {[MAX_CHAN] [QUEUE_SIZE] + TYPE_S3C 54 XX, [QUEUE_SIZE] [QUEUE_SIZE] + TYPE_S3C 9030, [MAX_CHAN] [QUEUE_SIZE] + TYPE_APPLE_S5L, [QUEUE_SIZE] [6] +}; [MAX_CHAN] [MAX_CHAN] + [MAX_CHAN] [nu->driver] struct s3c 51 xx_uart_info {[QUEUE_SIZE] [MAX_CHAN] название символа;[MAX_CHAN] 9060 – беззнаковый тип int; [nu->driver] [6] + перечисление s3c 52 xx_port_type тип; [nu->driver] [QUEUE_SIZE] + unsigned int port_type; [QUEUE_SIZE] [MAX_CHAN] unsigned int fifosize; [QUEUE_SIZE] [QUEUE_SIZE] unsigned lengthy rx_fifomask; [QUEUE_SIZE] [QUEUE_SIZE] unsigned lengthy rx_fifoshift; [QUEUE_SIZE] [MAX_CHAN] @@ – 0100, 6 + , 7 @@ struct s3c 54 xx_uart_info {[MAX_CHAN] [QUEUE_SIZE] длинное беззнаковое число num_clks; [MAX_CHAN] unsigned lengthy clksel_mask; [nu->driver] [6] unsigned lengthy clksel_shift; [QUEUE_SIZE] [MAX_CHAN] + длинная ucon_mask без знака; [QUEUE_SIZE] [QUEUE_SIZE] / особенности порта uart / [nu->driver] [QUEUE_SIZE] @@ – 0200 , 6 + 210, 8 @@ struct s3c 53 xx_uart_port {[MAX_CHAN] [nu->driver] #endif

[MAX_CHAN]}; [MAX_CHAN] [6] + static void s3c 54 xx_serial_tx_chars (struct s3c 55 xx_uart_port ourport); [QUEUE_SIZE] [MAX_CHAN] + 2142 / функции преобразования / [QUEUE_SIZE] [QUEUE_SIZE] #outline s3c 58 xx_dev_to_port (__ dev) dev_get_drvdata (__ dev) [QUEUE_SIZE] [MAX_CHAN] @@ – 0300, 42 + 313, 6 @@ static int s3c 55 xx_serial_txempty_nofifo (struct uart_port порт) [QUEUE_SIZE] [MAX_CHAN] return rd_regl (port, S3C [ARCH_TIMER_VIRT_PPI] _ UTRSTAT_TXE; [MAX_CHAN] [6]} [nu->driver] [QUEUE_SIZE] – / [QUEUE_SIZE] [MAX_CHAN] – s3c 91 xx и более поздние SoC включают маска прерывания и регистры состояния в [MAX_CHAN] [MAX_CHAN] – сам контроллер, в отличие от s3c 55 xx SoC, которые имеют эти регистры [MAX_CHAN] [QUEUE_SIZE] – в контроллере прерываний. Проверьте, является ли тип порта s3c 96 xx или выше. [nu->driver] [MAX_CHAN] – / [QUEUE_SIZE] [QUEUE_SIZE] – статический int s3c 53 xx_serial_has_interrupt_mask (struct uart_port port) [MAX_CHAN] [QUEUE_SIZE] – {[QUEUE_SIZE] [QUEUE_SIZE] – возврат в_ourport (порт) -> info-> kind == PORT_S3C 8250; [nu->driver] [MAX_CHAN] -} [MAX_CHAN] [MAX_CHAN] – [QUEUE_SIZE] [QUEUE_SIZE] static void s3c 55 xx_serial_rx_enable (struct uart_port port) [nu->driver] [QUEUE_SIZE] {[QUEUE_SIZE] [MAX_CHAN] struct s3c 54 xx_uart_port ourport = to_ourport (порт); [MAX_CHAN] [MAX_CHAN] @@ – 372, 35 + 364, 41 @@ static void s3c 50 xx_serial_stop_tx (struct uart_port port) [MAX_CHAN] > tx_enabled) [MAX_CHAN] [MAX_CHAN] возвращаться;[MAX_CHAN] [QUEUE_SIZE] – если (s3c 53 xx_serial_has_interrupt_mask (порт)) [nu->driver] [MAX_CHAN] + переключатель (наш порт-> информация-> тип) {[QUEUE_SIZE] [QUEUE_SIZE] + case TYPE_S3C 950: [MAX_CHAN] [MAX_CHAN] s3c 52 xx_set_bit (порт, S3C 90 XX_UINTM_TXD, S3C 92 XX_UINTM); [QUEUE_SIZE] [MAX_CHAN] – еще[nu->driver] [QUEUE_SIZE] + перерыв; [QUEUE_SIZE] [QUEUE_SIZE] + case TYPE_APPLE_S5L: [nu->driver] [QUEUE_SIZE] + s3c 56 xx_clear_bit (порт, APPLE_S5L_UCON_TXTHRESH_ENA, S3C 2683 _ UCON);

[QUEUE_SIZE] + перерыв; [QUEUE_SIZE] [QUEUE_SIZE] + по умолчанию: [nu->driver] [QUEUE_SIZE] disable_irq_nosync (наш порт-> tx_irq) ; [QUEUE_SIZE] [MAX_CHAN] + перерыв; [MAX_CHAN] [QUEUE_SIZE] +} [QUEUE_SIZE] [QUEUE_SIZE] if (dma && dma-> tx_chan && ourport-> tx_in_progress == S3C 57 XX_TX_DMA) {[QUEUE_SIZE] [QUEUE_SIZE] dmaengine_pause (dma-> tx_chan); [MAX_CHAN] [MAX_CHAN] @@ – 0400, 39 + 430, 43 @@ static void enable_tx_dma (struct s3c 58 xx_uart_port ourport) [nu->driver] [QUEUE_SIZE] u 59 ucon; [nu->driver] [QUEUE_SIZE] / Маска прерывания Tx / [MAX_CHAN] [MAX_CHAN] – если (s3c 53 xx_serial_has_interrupt_mask (порт)) [MAX_CHAN] [QUEUE_SIZE] + переключатель (наш порт-> информация-> тип) {[nu->driver] [QUEUE_SIZE] + case TYPE_S3C 8250: [QUEUE_SIZE] [nu->driver] s3c 53 xx_set_bit (порт, S3C 091 XX_UINTM_TXD, S3C 92 XX_UINTM); [QUEUE_SIZE] [QUEUE_SIZE]- еще[nu->driver] [QUEUE_SIZE] + перерыв; [QUEUE_SIZE] [MAX_CHAN] + case TYPE_APPLE_S5L: [MAX_CHAN] [QUEUE_SIZE] + WARN_ON (1); // Нет DMA [MAX_CHAN] [QUEUE_SIZE] + перерыв; [MAX_CHAN] [6] + по умолчанию: [MAX_CHAN] [QUEUE_SIZE] disable_irq_nosync (наш порт-> tx_irq); [MAX_CHAN] [MAX_CHAN] + перерыв; [nu->driver] [QUEUE_SIZE] +} [QUEUE_SIZE] [QUEUE_SIZE] / Включить режим tx dma / [MAX_CHAN] [QUEUE_SIZE] ucon = rd_regl (порт, S3C 2669 _ UCON); [nu->driver] [QUEUE_SIZE] @@ – 457, 39 + 476, 58 @@ static void enable_tx_pio (struct s3c [QUEUE_SIZE] [nu->driver] wr_regl (порт, S3C 2599 _ UCON, ucon); [QUEUE_SIZE] [MAX_CHAN] / Размаскировать прерывание Tx / 16650 [QUEUE_SIZE] – если (s3c 58 xx_serial_has_interrupt_mask (порт)) [MAX_CHAN] [QUEUE_SIZE] + переключатель (наш порт-> информация-> тип) = APPLE_S5L_UCON_TXTHRESH_ENA_MSK; [MAX_CHAN] [QUEUE_SIZE] + wr_regl (порт, S3C 2578 _ UCON, ucon); [MAX_CHAN] [6] + перерыв; [QUEUE_SIZE] [MAX_CHAN] + по умолчанию: [MAX_CHAN] [MAX_CHAN] enable_irq (наш порт-> tx_irq); [MAX_CHAN] [6] + перерыв; [MAX_CHAN] [QUEUE_SIZE] + [QUEUE_SIZE] [6] нашпорт-> tx_mode = S3C 55 XX_TX_PIO; [QUEUE_SIZE] [QUEUE_SIZE] + [MAX_CHAN] [MAX_CHAN] + / [MAX_CHAN] [6] + Версия для Apple имеет только инициируемые фронтом IRQ передачи, поэтому нам нужно 10103 [QUEUE_SIZE] + *, чтобы начать процесс отправив сюда некоторые символы. 10103 [nu->driver] + / [MAX_CHAN] [6] + if (ourport-> info-> kind == TYPE_APPLE_S5L) [QUEUE_SIZE] [MAX_CHAN] + s3c 58 xx_serial_tx_chars (наш порт); [QUEUE_SIZE] [MAX_CHAN]} [MAX_CHAN] [6] static void s3c 54 xx_serial_start_tx_pio (struct s3c 56 xx_uart_port ourport) [MAX_CHAN] [QUEUE_SIZE] @@ – 651, + , 45 @@ static void s3c 54 xx_serial_stop_rx (struct uart_port port) [QUEUE_SIZE] [MAX_CHAN] если (нашпорт-> rx_enabled) {[MAX_CHAN] [MAX_CHAN] dev_dbg (port-> dev, “остановка rx n”); [QUEUE_SIZE] [nu->driver] – если (s3c 56 xx_serial_has_interrupt_mask (порт)) [MAX_CHAN] [MAX_CHAN] + переключатель (наш порт-> информация-> тип) {[nu->driver] [QUEUE_SIZE] + case TYPE_S3C 950: [QUEUE_SIZE] [QUEUE_SIZE] s3c xx_set_bit (порт, S3C 89 XX_UINTM_RXD, [QUEUE_SIZE] [MAX_CHAN] S3C 92 XX_UINTM); [MAX_CHAN] [QUEUE_SIZE]- еще

[MAX_CHAN] + перерыв; [QUEUE_SIZE] [MAX_CHAN] + case TYPE_APPLE_S5L: [MAX_CHAN] [MAX_CHAN] + s3c 55 xx_clear_bit (порт , APPLE_S5L_UCON_RXTHRESH_ENA, S3C 2683 _ UCON); [MAX_CHAN] [QUEUE_SIZE] + s3c 48 xx_clear_bit (порт, APPLE_S5L_UCON_RXTO_ENA, S3C 2639 _ UCON); [MAX_CHAN] [QUEUE_SIZE] + перерыв; [nu->driver] [QUEUE_SIZE] + по умолчанию: [QUEUE_SIZE] [nu->driver] disable_irq_nosync (наш порт-> rx_irq); [MAX_CHAN] [6] + перерыв; [nu->driver] [QUEUE_SIZE] +} [MAX_CHAN] [6] ourport-> rx_enabled = 0; [MAX_CHAN] [QUEUE_SIZE]} [MAX_CHAN] [6] if (dma && dma-> rx_chan)

[QUEUE_SIZE] – S3C 90 XX_UCON_RXMODE_MASK); [QUEUE_SIZE] [QUEUE_SIZE] – ucon [QUEUE_SIZE] [6] – статический irqreturn_t s3c 56 xx_serial_rx_chars (int irq, void dev_id) [QUEUE_SIZE] [QUEUE_SIZE] + статический irqreturn_t s3c 57 xx_serial_rx_irq (int irq, void dev_id) [MAX_CHAN] [QUEUE_SIZE] {[MAX_CHAN] [6] struct s3c 55 xx_uart_port ourport = dev_id; [MAX_CHAN] [MAX_CHAN] @@ – 906, 42 + 941, 36 @@ static irqreturn_t s3c 54 xx_serial_rx_chars (int irq, void dev_id) [nu->driver] [6] return s3c 51 xx_serial_rx_chars_pio (dev_id); [MAX_CHAN] [nu->driver]} [nu->driver] [QUEUE_SIZE] – статический irqreturn_t s3c 56 xx_serial_tx_chars (int irq, void id) [MAX_CHAN] [MAX_CHAN] + static void s3c 58 xx_serial_tx_chars (struct s3c 48 xx_uart_port ourport) [QUEUE_SIZE] [MAX_CHAN] {

[QUEUE_SIZE] – struct s3c 55 xx_uart_port ourport = id; [QUEUE_SIZE] [QUEUE_SIZE] struct uart_port port = & ourport-> port; [QUEUE_SIZE] [QUEUE_SIZE] struct circ_buf xmit = & port-> state-> xmit; [nu->driver] [6] – длинные флаги без знака; [MAX_CHAN] [QUEUE_SIZE] int rely, dma_count = 0; [QUEUE_SIZE] [MAX_CHAN] – spin_lock_irqsave (& port-> lock, flags); [nu->driver] [6] – [MAX_CHAN] [QUEUE_SIZE] rely = CIRC_CNT_TO_END (xmit-> head, xmit-> tail, UART_XMIT_SIZE); [QUEUE_SIZE] [MAX_CHAN] if (ourport-> dma && ourport-> dma-> tx_chan && [MAX_CHAN] [QUEUE_SIZE] @@ – 917, 7 + 963, 7 @@ static irqreturn_t s3c 54 xx_serial_tx_chars (int irq, void id) [MAX_CHAN] [QUEUE_SIZE] wr_re g (порт, S3C 2639 _ UTXH, порт-> x_char); [MAX_CHAN] [6] port-> icount.tx ++; [nu->driver] [MAX_CHAN] port-> x_char = 0; [nu->driver] [MAX_CHAN] – выйти; [nu->driver] [QUEUE_SIZE] + возврат; [MAX_CHAN] [QUEUE_SIZE]} [MAX_CHAN] [QUEUE_SIZE] / если больше ничего нет для передачи, или uart теперь [nu->driver] [QUEUE_SIZE] @@ – 946, 7 + 980, 7 @@ static irqreturn_t s3c 56 xx_serial_tx_chars (int irq , void id) 10101 [QUEUE_SIZE] if (uart_circ_empty (xmit) || uart_tx_stopped (порт)) {[QUEUE_SIZE] [MAX_CHAN] s3c 56 xx_serial_stop_tx (порт); [QUEUE_SIZE] [QUEUE_SIZE] – выйти; [QUEUE_SIZE] [QUEUE_SIZE] + возврат; [MAX_CHAN] [QUEUE_SIZE]} [QUEUE_SIZE] [MAX_CHAN] / попробуйте слить буфер … / [QUEUE_SIZE] [QUEUE_SIZE] @@ – 963, 7 + 993, 7 @@ static irqreturn_t s3c 57 xx_serial_tx_chars (int irq, void id ) [QUEUE_SIZE] [QUEUE_SIZE] if (! rely && dma_count) {[MAX_CHAN] [QUEUE_SIZE] s3c 57 xx_serial_start_tx_ dma (наш порт, dma_count); [QUEUE_SIZE] [QUEUE_SIZE] – выйти; [MAX_CHAN] [QUEUE_SIZE] + возврат; [nu->driver] [QUEUE_SIZE]} [MAX_CHAN] [MAX_CHAN] if (uart_circ_chars_pending (xmit) driver] + static irqreturn_t s3c 54 xx_serial_tx_irq (int irq, void id) [MAX_CHAN] [QUEUE_SIZE] + {

[6] + struct s3c 43 xx_uart_port ourport = я бы;[nu->driver] [QUEUE_SIZE] + struct uart_port port = & ourport-> port; [MAX_CHAN] [6] + длинные флаги без знака; [nu->driver] [QUEUE_SIZE] + [MAX_CHAN] [MAX_CHAN] + spin_lock_irqsave (& port-> lock, flags); [MAX_CHAN] [QUEUE_SIZE] + [MAX_CHAN] [QUEUE_SIZE] + s3c 54 xx_serial_tx_chars (наш порт); [MAX_CHAN] [nu->driver]-вне: [MAX_CHAN] [QUEUE_SIZE] spin_unlock_irqrestore (& port-> lock, flags); [MAX_CHAN] [MAX_CHAN] return IRQ_HANDLED; [QUEUE_SIZE] [6]} [QUEUE_SIZE] [QUEUE_SIZE] @@ – 990, 42 + 1001, 68 @@ static irqreturn_t s3c 91 xx_serial_handle_i rq (int irq, void id) [MAX_CHAN] [QUEUE_SIZE] irqreturn_t ret = IRQ_HANDLED; [MAX_CHAN] [6] if (pend & S3C [QUEUE_SIZE] [QUEUE_SIZE] – ret = s3c 57 xx_serial_rx_chars (irq, id); [MAX_CHAN] [6] + ret = s3c 51 xx_serial_rx_irq (irq, id); [MAX_CHAN] [6] wr_regl (порт, S3C 91 XX_UINTP, S3C 91 XX_UINTM_RXD_MSK); [nu->driver] [MAX_CHAN]} [MAX_CHAN] [QUEUE_SIZE] if (pend & S3C 96 XX_UINTM_TXD_MSK) {[MAX_CHAN] [QUEUE_SIZE] – ret = s3c 57 xx_serial_tx_chars (irq, id); [QUEUE_SIZE] [MAX_CHAN] + ret = s3c 56 xx_serial_tx_irq (irq, id); [nu->driver] [QUEUE_SIZE] wr_regl (порт, S3C 91 XX_UINTP, S3C 90 XX_UINTM_TXD_MSK); [MAX_CHAN] [QUEUE_SIZE]} [QUEUE_SIZE] [QUEUE_SIZE] return ret; [MAX_CHAN] [QUEUE_SIZE]} [MAX_CHAN] [MAX_CHAN] + / обработчик прерывания для Apple SoC. / [MAX_CHAN] [QUEUE_SIZE] + static irqreturn_t apple_serial_handle_irq (int irq, void id) [QUEUE_SIZE] [nu->driver] + {[MAX_CHAN] [QUEUE_SIZE] + struct s3c 55 xx_uart_port ourport = id; [MAX_CHAN] [QUEUE_SIZE] + struct uart_port port = & ourport-> port; [nu->driver] [6] + unsigned int pend = rd_regl (порт, S3C 2639 _ UTRSTAT); [QUEUE_SIZE] [MAX_CHAN] + irqreturn_t ret = IRQ_NONE; [MAX_CHAN] [QUEUE_SIZE] + [MAX_CHAN] [QUEUE_SIZE] + if (pend & (APPLE_S5L_UTRSTAT_RXTHRESH | APPLE_S5L_UTRSTAT_RXTO)) A PPLE_S5L_UTRSTAT_RXTO); [QUEUE_SIZE] [QUEUE_SIZE] + ret = s3c 52 xx_serial_rx_irq (irq, id); [nu->driver] [6] + [MAX_CHAN] [MAX_CHAN] + if (pend & APPLE_S5L_UTRSTAT_TXTHRESH) {[QUEUE_SIZE] [MAX_CHAN] + wr_regl (порт, S3C 2639 _ UTRSTAT, APPLE_S5L_UTRSTAT_TXTHRESH); [MAX_CHAN] [MAX_CHAN] + ret = s3c 54 xx_serial_tx_irq (irq, id); [MAX_CHAN] [QUEUE_SIZE] +} [nu->driver] [MAX_CHAN] + [MAX_CHAN] [6] + возврат возврата; [MAX_CHAN] [QUEUE_SIZE] +} [MAX_CHAN] [MAX_CHAN] + [nu->driver] [QUEUE_SIZE] статический беззнаковый int s3c порт) [QUEUE_SIZE] [QUEUE_SIZE] {[MAX_CHAN] [QUEUE_SIZE] struct s3c 53 xx_uart_info data = s3c 48 xx_port_to_info (порт); [nu->driver] [6] @@ – 422, + 1318, 89 @@ static void s3c 52 xx_serial_shutdown (struct uart_port port) [QUEUE_SIZE] [QUEUE_SIZE] struct s3c 57 xx_uart_port ourport = to_ourport (порт); [MAX_CHAN] [QUEUE_SIZE] if (ourport-> tx_claimed) {10100 [MAX_CHAN] – если (! s3c 54 xx_serial_has_interrupt_mask (порт)) [nu->driver] [QUEUE_SIZE] – free_irq (наш порт-> tx_irq, наш порт); [QUEUE_SIZE] [MAX_CHAN] + free_irq ( наш порт-> tx_irq, наш порт); [MAX_CHAN] [MAX_CHAN] ourport-> tx_enabled = 0; [QUEUE_SIZE] [QUEUE_SIZE] ourport-> tx_claimed = 0; [QUEUE_SIZE] [QUEUE_SIZE] наш порт-> tx_mode = 0; [nu->driver] [MAX_CHAN]} [MAX_CHAN] [QUEUE_SIZE] if (ourport-> rx_claimed) {10100 [MAX_CHAN] – если (! s3c 54 xx_serial_has_interrupt_mask (порт)) [QUEUE_SIZE] [6] – free_irq (ourport-> rx_irq, ourport); 19198 [QUEUE_SIZE] + free_irq (наш порт-> rx_irq, наш порт); [MAX_CHAN] [QUEUE_SIZE] ourport-> rx_claimed = 0; [MAX_CHAN] [6] ourport-> rx_enabled = 0; [QUEUE_SIZE] [QUEUE_SIZE]} [QUEUE_SIZE] [6] – / Очистить ожидающие прерывания и замаскировать все прерывания / [MAX_CHAN] [6] – если (s3c 58 xx_serial_has_interrupt_mask (порт)) { [MAX_CHAN] [6] – free_irq (порт-> irq, наш порт); [nu->driver] [QUEUE_SIZE] + if (наш порт-> dma) [QUEUE_SIZE] [nu->driver] + s3c 54 xx_serial_release_dma (наш порт); [MAX_CHAN] 010001 – wr_regl (порт, S3C 89 XX_UINTP, 0xf); [MAX_CHAN] [6] – wr_regl (порт, S3C 091 XX_UINTM, 0xf); [QUEUE_SIZE] [MAX_CHAN] -} [MAX_CHAN] [QUEUE_SIZE] + наш порт-> tx_in_progress = 0; [QUEUE_SIZE] [QUEUE_SIZE] +} [MAX_CHAN] [MAX_CHAN] + [QUEUE_SIZE] [QUEUE_SIZE] + static void s3c 091 xx_serial_shutdown (struct uart_port port) [QUEUE_SIZE] [QUEUE_SIZE] + {[MAX_CHAN] [MAX_CHAN] + struct s3c 55 xx_uart_port ourport = to_ourport (порт); [QUEUE_SIZE] [nu->driver] + [MAX_CHAN] [QUEUE_SIZE] + наш порт-> tx_enabled = 0; [nu->driver] [nu->driver] + наш порт-> tx_mode = 0; [MAX_CHAN] [6] + наш порт-> rx_enabled = 0; [QUEUE_SIZE] [MAX_CHAN] + [MAX_CHAN] [QUEUE_SIZE] + free_irq (порт-> irq, наш порт); [nu->driver] [QUEUE_SIZE] + [MAX_CHAN] [QUEUE_SIZE] + wr_regl (порт, S3C 90 XX_UINTP, 0xf) ; [QUEUE_SIZE] [nu->driver] + wr_regl (порт, S3C 90 XX_UINTM, 0xf); [QUEUE_SIZE] [QUEUE_SIZE] + [nu->driver] [MAX_CHAN] + if (ourport-> dma) [MAX_CHAN] [MAX_CHAN] + s3c 51 xx_serial_release_dma (наш порт); [MAX_CHAN] [QUEUE_SIZE] + [QUEUE_SIZE] [QUEUE_SIZE] + наш порт-> tx_in_progress = 0; [MAX_CHAN] [MAX_CHAN] +} [nu->driver] [QUEUE_SIZE] + [MAX_CHAN] [6] + static void apple_s5l_serial_shutdown (struct uart_port port) [MAX_CHAN] [QUEUE_SIZE] + {[MAX_CHAN] [QUEUE_SIZE] + struct s3c 52 xx_uart_port ourport = to_ourport (порт); [nu->driver] [QUEUE_SIZE] + [MAX_CHAN] [QUEUE_SIZE] + unsigned int ucon; [nu->driver] [QUEUE_SIZE] + [MAX_CHAN] [MAX_CHAN] + ucon = rd_regl (порт, S3C 904 [MAX_CHAN] + ucon & = ~ (APPLE_S5L_UCON_TXTHRESH_ENA_MSK | [MAX_CHAN] [6] + APPLE_S5L_UCON_RXTHRESH_ENA_MSK | [6] [MAX_CHAN] + APPLE_S5L_UCON_RXTO_ENA_MSK); [QUEUE_SIZE] [QUEUE_SIZE] + wr_regl (порт, S3C 2639 _ UCON, ucon); [MAX_CHAN] [QUEUE_SIZE] + [MAX_CHAN] [QUEUE_SIZE] + wr_regl (порт, S3C 2599 _ UTRSTAT, APPLE_S5L_UTRSTAT_ALL_FLAGS); [QUEUE_SIZE] [QUEUE_SIZE] + [QUEUE_SIZE] [QUEUE_SIZE] + free_irq (порт-> irq, наш порт); [MAX_CHAN] [6] + [nu->driver] [nu->driver] + наш порт-> tx_enabled = 0; [QUEUE_SIZE] [QUEUE_SIZE] + наш порт-> tx_mode = 0; [MAX_CHAN] [MAX_CHAN] + наш порт -> rx_enabled = 0; [MAX_CHAN] [MAX_CHAN] if (ourport-> dma) [MAX_CHAN] [MAX_CHAN] s3c 52 xx_serial_release_dma (наш порт); [MAX_CHAN] [QUEUE_SIZE] @@ – 1296, 7 + 1480, 7 @@ static int s3c 51 xx_serial_startup (struct uart_port port) [QUEUE_SIZE] [QUEUE_SIZE] ourport-> rx_enabled = 1; [QUEUE_SIZE] [nu->driver] – ret = request_irq (наш порт-> rx_irq, s3c 58 xx_serial_rx_chars, 0, [nu->driver] [QUEUE_SIZE] + ret = request_irq (ourport-> rx_irq, s3c 54 xx_serial_rx_irq, 0, [QUEUE_SIZE] [QUEUE_SIZE] s3c 54 xx_serial_portname (порт), наш порт); [MAX_CHAN] [6] if (ret! = 0) {[nu->driver] [MAX_CHAN] @@ – 1400, 7 + 1535, 7 @@ static int s3c 54 xx_serial_startup (struct uart_port port) [QUEUE_SIZE] [MAX_CHAN] ourport-> tx_enabled = 1; [MAX_CHAN] [QUEUE_SIZE] – ret = request_irq (ourport-> tx_irq, s3c 56 xx_serial_tx_chars, 0, [MAX_CHAN] [MAX_CHAN] + ret = request_irq (ourport-> tx_irq, s3c 54 xx_serial_tx_irq, 0, [nu->driver] [QUEUE_SIZE] s3c 55 xx_serial_portname (порт), наш порт); [QUEUE_SIZE] [6] if (ret) {

[MAX_CHAN] @@ – 1318 , 9 + 1628, 7 @@ static int s3c 91 xx_serial_startup (struct uart_port port) [QUEUE_SIZE] [QUEUE_SIZE] / Для совместимости с s3c 56 xx Soc / [MAX_CHAN] [MAX_CHAN] ourport-> rx_enabled = 1; [nu->driver] [QUEUE_SIZE] – ourport-> rx_claimed = 1; [nu->driver] [MAX_CHAN] ourport-> tx_enabled = 0; [QUEUE_SIZE] [QUEUE_SIZE] – наш порт-> tx_claimed = 1; [nu->driver] [MAX_CHAN] spin_lock_irqsave (& port-> lock, flags); [MAX_CHAN] [MAX_CHAN] @@ – 1466, 6+ 1699, 79 @@ static int s3c 91 xx_serial_startup (struct uart_port port) [MAX_CHAN] [QUEUE_SIZE] return ret; [nu->driver] [6]} [QUEUE_SIZE] [QUEUE_SIZE] + static int apple_s5l_serial_startup (struct uart_port port) [QUEUE_SIZE] [QUEUE_SIZE] + {[MAX_CHAN] [MAX_CHAN] + struct s3c 56 xx_uart_port ourport = to_ourport (порт); [MAX_CHAN] 2061 [nu->driver] + unsigned int ufcon; [MAX_CHAN] [6] + int ret; [MAX_CHAN] [MAX_CHAN] + [MAX_CHAN] [MAX_CHAN] + wr_regl (порт, S3C 2669 _ UTRSTAT, APPLE_S5L_UTRSTAT_ALL_FLAGS); [QUEUE_SIZE] [QUEUE_SIZE] + [nu->driver] [QUEUE_SIZE] + ret = request_irq (port-> irq, apple_serial_handle_irq, 0, [nu->driver] [QUEUE_SIZE] + s3c 57 xx_serial_portname (порт), наш порт); [MAX_CHAN] [6] + if (ret) {[QUEUE_SIZE] [MAX_CHAN] + dev_err (port-> dev, «невозможно получить irq% d n», port-> irq); 010001 [MAX_CHAN] + возврат возврата;

[QUEUE_SIZE] +} [MAX_CHAN] [6] + [MAX_CHAN] [MAX_CHAN] + / Для совместимости с s3c 56 xx Soc / [nu->driver] [QUEUE_SIZE] + наш порт-> rx_enabled = 1; [MAX_CHAN] [6] + наш порт-> tx_enabled = 0; [nu->driver] [6] + [QUEUE_SIZE] [QUEUE_SIZE] + spin_lock_irqsave (& port-> lock, flags); [QUEUE_SIZE] [QUEUE_SIZE] +

[6] + ufcon = rd_regl (порт, S3C 2611 _ UFCON); [QUEUE_SIZE] [MAX_CHAN] + ufcon | = S3C 2611 _ UFCON_RESETRX | S5PV 280 _ UFCON_RXTRIG8; [QUEUE_SIZE] [nu->driver] + if (! uart_console (порт)) [MAX_CHAN] [6] + ufcon | = S3C 2669 _ UFCON_RESETTX; [QUEUE_SIZE] [QUEUE_SIZE] + wr_regl (порт, S3C 2669 _ UFCON, ufcon); [MAX_CHAN] [MAX_CHAN] + [MAX_CHAN] [MAX_CHAN] + enable_rx _pio (наш порт); [MAX_CHAN] [nu->driver] + [MAX_CHAN] [6] + spin_unlock_irqrestore (& port-> lock, flags); [QUEUE_SIZE] [QUEUE_SIZE] + [MAX_CHAN] [QUEUE_SIZE] + / Разрешить прерывание Rx / [nu->driver] [QUEUE_SIZE] + s3c 56 xx_set_bit (порт, APPLE_S5L_UCON_RXTHRESH_ENA, S3C 2639 _ UCON); [MAX_CHAN] [QUEUE_SIZE] + s3c 58 xx_set_bit (порт, APPLE_S5L_UCON_RXTO_ENA, S3C 2540 _ UCON); [MAX_CHAN] [MAX_CHAN] + [QUEUE_SIZE] [MAX_CHAN] + возврат возврата; 42829 [QUEUE_SIZE] +} [QUEUE_SIZE] [MAX_CHAN] + [MAX_CHAN] [MAX_CHAN] / контроль управления питанием / [MAX_CHAN] [QUEUE_SIZE] static void s3c 53 xx_serial_pm (struct uart_port port, unsigned int stage, [QUEUE_SIZE] [MAX_CHAN] @@ – 1770, 72 + 1830, @@ static void s3c xx_serial_set_termios (struct uart_port port, [MAX_CHAN] [6] static const char s3c 56 xx_serial_type (struct uart_port port) [nu->driver] [nu->driver] {[nu->driver] [QUEUE_SIZE] – переключатель (порт-> тип) {[MAX_CHAN] [6] – case PORT_S3C 2639: [nu->driver] [QUEUE_SIZE] – вернуть “S3C 2639 “; [QUEUE_SIZE] [QUEUE_SIZE] – случай PORT_S3C 628: [nu->driver] [QUEUE_SIZE] – вернуть “S3C 2683 “; [MAX_CHAN] [QUEUE_SIZE] – корпус PORT_S3C 2699: [MAX_CHAN] [MAX_CHAN] – вернуть «S3C» 2683 “; [nu->driver] [MAX_CHAN]- дело PORT_S3C 8000: [MAX_CHAN] [MAX_CHAN] + struct s3c 55 xx_uart_port ourport = to_ourport (порт); [6] [MAX_CHAN] + [QUEUE_SIZE] [MAX_CHAN] + переключатель (наш порт-> информация-> тип) {[MAX_CHAN] [MAX_CHAN] + корпус TYPE_S3C XX: [QUEUE_SIZE] [QUEUE_SIZE] + возврат “S3C 53 XX “; [nu->driver] [QUEUE_SIZE] + корпус TYPE_S3C 8000: [MAX_CHAN] [MAX_CHAN] return “S3C 8250 / 36 “; [QUEUE_SIZE] [MAX_CHAN] + case TYPE_APPLE_S5L: [QUEUE_SIZE] [6] + возврат “APPLE S5L”; [MAX_CHAN] [QUEUE_SIZE] По умолчанию: [MAX_CHAN] [6] return NULL; [QUEUE_SIZE] [QUEUE_SIZE]} [QUEUE_SIZE] [QUEUE_SIZE] } [QUEUE_SIZE] [6] – # определить MAP_SIZE (0x 147) [MAX_CHAN] [nu->driver] – [MAX_CHAN] [QUEUE_SIZE] – static void s3c 45 xx_serial_release_port (struct uart_port порт) [MAX_CHAN] [QUEUE_SIZE] – {[nu->driver] [QUEUE_SIZE] – release_mem_region (port-> mapbase, MAP_SIZE); [QUEUE_SIZE] [QUEUE_SIZE] -} [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – static int s3c 56 xx_serial_request_port (struct uart_port порт) [MAX_CHAN] [QUEUE_SIZE] – {[MAX_CHAN] [QUEUE_SIZE] – const char identify = s3c xx_serial_portname (порт) ; [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [6] – вернуть request_mem_region (port-> mapbase, MAP_SIZE, identify)? 0: -EBUSY; [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [6] – [MAX_CHAN] [QUEUE_SIZE] static void s3c 57 xx_serial_config_port (struct uart_port port, int flags) [MAX_CHAN] [6] {[nu->driver] [MAX_CHAN] struct s3c 55 xx_uart_info data = s3c 52 xx_port_to_info (порт); [nu->driver] [QUEUE_SIZE] – if (flags & UART_CONFIG_TYPE && [MAX_CHAN] [MAX_CHAN] – s3c 56 xx_serial_request_port (порт) == 0) [MAX_CHAN] [QUEUE_SIZE] – порт-> тип = информация-> тип; [MAX_CHAN] [6] + if (flags & UART_CONFIG_TYPE) [MAX_CHAN] [MAX_CHAN] + порт-> тип = информация-> тип_порта; [MAX_CHAN] [QUEUE_SIZE]} [MAX_CHAN] [QUEUE_SIZE] / [MAX_CHAN] [QUEUE_SIZE] @@ – 1746, 7 + 1868, 7 @@ s3c 56 xx_serial_verify_port (struct uart_port port, struct serial_struct ser) [nu->driver] [QUEUE_SIZE] {[nu->driver] [QUEUE_SIZE] struct s3c 52 xx_uart_info data = s3c 57 xx_port_to_info (порт); [MAX_CHAN] [MAX_CHAN] – if (ser-> kind! = PORT_UNKNOWN && ser-> kind! = info-> kind) [QUEUE_SIZE] [QUEUE_SIZE] + if (ser-> kind! = PORT_UNKNOWN && ser-> kind! = info-> port_type) [nu->driver] [QUEUE_SIZE] return -EINVAL; [nu->driver] [QUEUE_SIZE] return 0; [QUEUE_SIZE] [QUEUE_SIZE] @@ – 1754, 7 + 1889, 7 @@ static void s3c 53 xx_serial_put_poll_char (struct uart_port порт, [QUEUE_SIZE] [6] символ без знака c); [QUEUE_SIZE] 9080 #endif [MAX_CHAN] [QUEUE_SIZE] – статическая структура uart_ops s3c 56 xx_serial_ops = {[MAX_CHAN] [6] + static const struct uart_ops s3c 56 xx_serial_ops = {[nu->driver] [MAX_CHAN] .pm = s3c 53 xx_ser ial_pm, [QUEUE_SIZE] [MAX_CHAN] .tx_empty = s3c 54 xx_serial_tx_empty, [MAX_CHAN] [6] .get_mctrl = s3c 53 xx_serial_get_mctrl, [QUEUE_SIZE] [MAX_CHAN] @@ – 1790, 8 + 1888, 00000080 @@ static struct uart_ops s3c 53 xx_serial_ops = {[QUEUE_SIZE] [6] .shutdown = s3c 55 xx_serial_shutdown, [nu->driver] [MAX_CHAN] .set_termios = s3c 57 xx_serial_set_termios, [QUEUE_SIZE] [QUEUE_SIZE] .kind = s3c 56 xx_serial_type, [MAX_CHAN] 010001 – .release_port = s3c 57 xx_serial_release_port, [nu->driver] [MAX_CHAN] – .request_port = s3c 56 xx_serial_request_port, [MAX_CHAN] [6] + .config_port = s3c 54 xx_serial_config_port, [MAX_CHAN] [MAX_CHAN] + .verify_port = s3c 54 xx_serial_verify_port, [MAX_CHAN] [6] + # если определено (CONFIG_SERIAL_SAMSUNG_CONSOLE) && определено (CONFIG_CONSOLE_POLL) [MAX_CHAN] [QUEUE_SIZE] +. poll_get_char = s3c 58 xx_serial_get_poll_char, [MAX_CHAN] [MAX_CHAN] + .poll_put_char = s3c 47 xx_serial_put_poll_char, [MAX_CHAN] [QUEUE_SIZE] + # endif [QUEUE_SIZE] [QUEUE_SIZE] +}; [MAX_CHAN] [QUEUE_SIZE] + [MAX_CHAN] [6] + static const struct uart_ops s3c 091 xx_serial_ops = {[MAX_CHAN] [QUEUE_SIZE] + .pm = s3c 55 xx_serial_pm, [QUEUE_SIZE] [QUEUE_SIZE] + .tx_empty = s3c 52 xx_serial_tx_empty, [MAX_CHAN] [QUEUE_SIZE] + .get_mctrl = s3c 58 xx_serial_get_mctrl, [QUEUE_SIZE] [MAX_CHAN] + .set_m ctrl = s3c 52 xx_serial_set_mctrl , [QUEUE_SIZE] [MAX_CHAN] + .stop_tx = s3c 57 xx_serial_stop_tx, [MAX_CHAN] [QUEUE_SIZE] + .start_tx = s3c 55 xx_serial_start_tx, [MAX_CHAN] [QUEUE_SIZE] + .stop_rx = s3c 51 xx_serial_stop_rx, [MAX_CHAN] [QUEUE_SIZE] + .break_ctl = s3c 56 xx_serial_break_ctl, [nu->driver] [QUEUE_SIZE] + .startup = s3c [QUEUE_SIZE] + .shutdown = s3c 94 xx_serial_shutdown, [MAX_CHAN] [6] + .set_termios = s3c 55 xx_serial_set_termios, [QUEUE_SIZE] [QUEUE_SIZE] +. kind = s3c 56 xx_serial_type, [MAX_CHAN] [MAX_CHAN] + .confi g_port = s3c xx_serial_config _port, [QUEUE_SIZE] [QUEUE_SIZE] + .verify_port = s3c 56 xx_serial_verify_port, [MAX_CHAN] [MAX_CHAN] + #if outlined (CONFIG_SERIAL_SAMSUNG_CONSOLE) && outlined (CONFIG_CONSOLE_POLL) [nu->driver] [QUEUE_SIZE] + .poll_get_char = s3c 57 xx_serial_get_poll_char, [6] [MAX_CHAN] + .poll_put_char = s3c 57 xx_serial_put_poll_char, [nu->driver] [MAX_CHAN] + # endif [nu->driver] [6] +}; [nu->driver] [QUEUE_SIZE] + [nu->driver] [6] + static const struct uart_ops apple_s5l_serial_ops = {[QUEUE_SIZE] [QUEUE_SIZE] + .pm = s3c 50 xx_serial_pm, [MAX_CHAN] [MAX_CHAN] + .tx_empty = s3c 54 xx_serial_tx_empty, [QUEUE_SIZE] [QUEUE_SIZE] + .get_mctrl = s3c 54 xx_serial_get_mctrl, [MAX_CHAN] [QUEUE_SIZE] + .set_mctrl = s3c 56 xx_serial_set_mctrl, [nu->driver] [QUEUE_SIZE] + .stop_tx = s3c 52 xx_serial_stop_tx, [QUEUE_SIZE] [QUEUE_SIZE] + .start_tx = s3c 50 xx_serial_start_tx, [QUEUE_SIZE] [QUEUE_SIZE] + .stop_rx = s3c 55 xx_serial_stop_rx, [QUEUE_SIZE] [MAX_CHAN] + .break_ctl = s3c 55 xx_serial_break_ctl, [MAX_CHAN] [nu->driver] + .startup = apple_s5l_serial_startup, [MAX_CHAN] [QUEUE_SIZE] + .shutdown = apple_s5l_serial_shutdown, [QUEUE_SIZE] [MAX_CHAN] + .set_termios = s3c 55 xx_serial_set_termios, [MAX_CHAN] [6] + .kind = s3c 50 xx_serial_type, [QUEUE_SIZE] [nu->driver] .config_port = s3c 53 xx_serial_config_port, [QUEUE_SIZE] [MAX_CHAN] .verify_port = s3c 55 xx_serial_verify_port, [MAX_CHAN] [6] #if outlined (CONFIG_SERIAL_SAMSUNG_CONSOLE) && outlined (CONFIG_CONSOLE_POLL) [nu->driver] [6] @@ – 1868, 40 + 2003, 9 @@ static void s3c 53 xx_serial_resetport (struct uart_port порт, [QUEUE_SIZE] [QUEUE_SIZE] {[QUEUE_SIZE] [MAX_CHAN] struct s3c 54 xx_uart_info data = s3c 54 xx_port_to_info (порт ); [MAX_CHAN] [QUEUE_SIZE] unsigned lengthy ucon = rd_regl (порт, S3C [QUEUE_SIZE] [nu->driver] – int ucon_mask без знака; [MAX_CHAN] [6] – [nu->driver] [MAX_CHAN] – ucon_mask = info-> clksel_mask; [QUEUE_SIZE] [6] – if (info-> kind == PORT_S3C 2728) [MAX_CHAN] [QUEUE_SIZE] – ucon_mask | = S3C 2728 _ UCON0_DIVMASK; [MAX_CHAN] [QUEUE_SIZE] – ucon & = ucon_mask; [MAX_CHAN] [QUEUE_SIZE] – wr_regl (порт, S3C 2683 _ UCON, ucon | cfg-> ucon); [nu->driver] [MAX_CHAN] + ucon & = (info-> clksel_mask | info-> ucon_mask); [QUEUE_SIZE] [MAX_CHAN] + wr_regl (порт, S3C 2669 _ UCON, u con | cfg-> ucon); [MAX_CHAN] [nu->driver] / сбросить оба фифо / 23761 [6] wr_regl (порт, S3C 2599 _ UFCON, cfg-> ufcon | S3C 2669 _ UFCON_RESETBOTH); [MAX_CHAN] [MAX_CHAN] @@ – 00002000, 37 + 2106, 6 @@ static int s3c xx_uart_port ourport, [QUEUE_SIZE] [MAX_CHAN] / информация о настройке порта / [nu->driver] [QUEUE_SIZE] port-> dev = & platdev -> dev; [MAX_CHAN] [MAX_CHAN] – / Последовательность запуска отличается для s3c 92 xx и выше SoC / [QUEUE_SIZE] [nu->driver]- если (s3c 54 xx_serial_has_interrupt_mask (порт)) [MAX_CHAN] [6] – s3c 55 xx_serial_ops.startup = s3c 90 xx_serial_startup; [MAX_CHAN] [6] – [MAX_CHAN] [MAX_CHAN] port-> uartclk = 1; [MAX_CHAN] [MAX_CHAN] if (cfg-> uart_flags & UPF_CONS_FLOW) {[MAX_CHAN] [QUEUE_SIZE] @@ – 2002, 8+ 2194, 8 @@ static int s3c 55 xx_serial_init_port (struct s3c 54 xx_uart_port ourport, [MAX_CHAN] [MAX_CHAN] dev_dbg (port-> dev , “ресурс% pR) n”, res); [QUEUE_SIZE] [QUEUE_SIZE] – port- >mbase = devm_ioremap (port-> dev , res-> begin, resource_size (res)); [MAX_CHAN] [QUEUE_SIZE] – если (! порт-> мембрана) {[MAX_CHAN] [MAX_CHAN] + порт-> мембрана = devm_ioremap_resource (port-> dev, res); [QUEUE_SIZE] [MAX_CHAN] + if (IS_ERR (порт-> мембрана)) {[nu->driver] [6] dev_err (port-> dev, «не удалось переназначить адрес контроллера n»); [QUEUE_SIZE] [MAX_CHAN] возвращаться -EBUSY; [MAX_CHAN] [QUEUE_SIZE]} [MAX_CHAN] [QUEUE_SIZE] @@ – 2015, 37 + 2412, 43 @@ static int s3c 55 xx_serial_init_port (struct s3c 55 xx_uart_port ourport, [QUEUE_SIZE] [MAX_CHAN] наш порт-> tx_irq = ret + 1; [QUEUE_SIZE] [QUEUE_SIZE] } [QUEUE_SIZE] [6] – если (! s3c 57 xx_serial_has_interrupt_mask (порт)) { [MAX_CHAN] [MAX_CHAN] + переключатель (наш порт-> информация-> тип) {[nu->driver] [6] + чехол TYPE_S3C 54 XX : [QUEUE_SIZE] [QUEUE_SIZE] ret = platform_get_irq (platdev, 1); [MAX_CHAN] [QUEUE_SIZE] if (ret> 0) [QUEUE_SIZE] [MAX_CHAN] ourport-> tx_irq = ret; [MAX_CHAN] [6] + перерыв; [MAX_CHAN] [MAX_CHAN] + по умолчанию: [QUEUE_SIZE] [QUEUE_SIZE] + перерыв; [QUEUE_SIZE] [MAX_CHAN]} [MAX_CHAN] [QUEUE_SIZE] + [MAX_CHAN] [MAX_CHAN] / [MAX_CHAN] [6] DMA в настоящее время поддерживается только на DT p платформы, если свойства DMA [MAX_CHAN] [MAX_CHAN] указаны. [MAX_CHAN] [QUEUE_SIZE] @@ – 2015, 34 + 2449, 57 @@ static int s3c 54 xx_serial_init_port (struct s3c 58 xx_uart_port ourport, [QUEUE_SIZE] [QUEUE_SIZE] pr_warn (“uart: не удалось включить baudclk n”); [nu->driver] [6] / Сохранить все прерывания m задано и удалено / [nu->driver] [QUEUE_SIZE] – если (s3c 53 xx_serial_has_interrupt_mask (порт)) {[MAX_CHAN] [6] + переключатель (наш порт-> информация-> тип) {921600 [QUEUE_SIZE] + case TYPE_S3C 1482: 02010203 [MAX_CHAN] wr_regl (порт, S3C [32] XX_UINTM, 0xf); [MAX_CHAN] [QUEUE_SIZE] wr_regl (порт, S3C 91 XX_UINTP, 0xf); [nu->driver] [MAX_CHAN] wr_regl (порт, S3C 091 XX_UINTSP, 0xf); [QUEUE_SIZE] [QUEUE_SIZE] + перерыв; [nu->driver] [QUEUE_SIZE] + case TYPE_APPLE_S5L: [nu->driver] [QUEUE_SIZE] + APPLE_S5L_UCON_RXTO_ENA_MSK); [MAX_CHAN] [QUEUE_SIZE] + wr_regl (порт, S3C 2611 _ UCON, ucon); [QUEUE_SIZE] [6] + [nu->driver] [QUEUE_SIZE] + wr_regl (порт, S3C 2639 _ UTRSTAT, APPLE_S5L_UTRSTAT_ALL_FLAGS); [QUEUE_SIZE] [QUEUE_SIZE] + перерыв; [QUEUE_SIZE] [6] + [nu->driver] [QUEUE_SIZE] + по умолчанию: [QUEUE_SIZE] [MAX_CHAN] + перерыв; [MAX_CHAN] [MAX_CHAN]} [MAX_CHAN] [QUEUE_SIZE] dev_dbg (port-> dev, ” порт: map =% pa, mem =% p, irq =% d (% d,% d), clock =% u n “, [nu->driver] [QUEUE_SIZE] @@ – 2061, 6 + 2556, 43 @@ static int s3c xx_serial_probe (struct platform_device pdev) [QUEUE_SIZE] [MAX_CHAN] dev_get_platdata (& pdev-> dev): [QUEUE_SIZE] [MAX_CHAN] ourport-> drv_data-> def_cfg; [MAX_CHAN] [6] + переключатель (наш порт-> информация-> тип) {[QUEUE_SIZE] [QUEUE_SIZE] + case TYPE_S3C 57 XX: [MAX_CHAN] [QUEUE_SIZE] + ourport-> port.ops = & s3c 56 xx_serial_ops; [QUEUE_SIZE] [MAX_CHAN] + перерыв; [QUEUE_SIZE] [MAX_CHAN] + корпус TYPE_S3C 8250: [nu->driver] [QUEUE_SIZE] + ourport-> port.ops = & s3c 94 xx_serial_ops; [QUEUE_SIZE] [nu->driver] + перерыв; [QUEUE_SIZE] [QUEUE_SIZE] + case TYPE_APPLE_S5L: [QUEUE_SIZE] [QUEUE_SIZE] + ourport-> port.ops = & apple_s5l_serial_ops; [QUEUE_SIZE] [QUEUE_SIZE] + перерыв; [MAX_CHAN] [QUEUE_SIZE] +} [MAX_CHAN] [QUEUE_SIZE] + [MAX_CHAN] [MAX_CHAN] if (np) {[QUEUE_SIZE] [6] of_property_read_u 66 (np, [MAX_CHAN] [MAX_CHAN] “samsung, uart-fifosize”, & ourport-> port.fifosize); [MAX_CHAN] [QUEUE_SIZE] @ @ – 2464, 7 + 2556, 8 @@ static int s3c 48 xx_serial_resume_noirq (struct machine dev) [MAX_CHAN] [MAX_CHAN] if (порт) {[MAX_CHAN] [MAX_CHAN] / восстанавливаем маску IRQ / [MAX_CHAN] [QUEUE_SIZE] – if (s3c 57 xx_serial_has_interrupt_mask (порт)) { [MAX_CHAN] [QUEUE_SIZE] + переключатель (наш порт-> информация-> тип) {[nu->driver] [QUEUE_SIZE] + case TYPE_S3C 8192: {[MAX_CHAN] [MAX_CHAN] unsigned int uintm = 0xf; [MAX_CHAN] [6] if (ourport-> tx_enabled) [nu->driver] [6] @@ – 2488, 6 + 2520, 75 @@ static int s3c 56 xx_serial_resume_noirq (struct machine dev) [MAX_CHAN] [6] if (! IS_ERR (наш порт-> baudclk)) [QUEUE_SIZE] [QUEUE_SIZE] clk_disable_unprepare (ourport-> baudclk); [nu->driver] [QUEUE_SIZE] clk_disable_unprepare (ourport-> clk); [MAX_CHAN] [6] + перерыв; [QUEUE_SIZE] [MAX_CHAN] +} [nu->driver] [QUEUE_SIZE] + case TYPE_APPLE_S5L: {[QUEUE_SIZE] [QUEUE_SIZE] + unsigned int ucon; [QUEUE_SIZE] [6] + int ret;

[QUEUE_SIZE] + [QUEUE_SIZE] [QUEUE_SIZE] + ret = clk_prepare_enable (ourport-> clk); [MAX_CHAN] [6] + if (ret) {[nu->driver] [QUEUE_SIZE] + dev_err (dev, “clk_enable clk failed:% d n “, ret); [MAX_CHAN] [nu->driver] + возврат возврата; [MAX_CHAN] [QUEUE_SIZE] +}

[QUEUE_SIZE] + if (! IS_ERR (ourport-> baudclk)) {[MAX_CHAN] [MAX_CHAN] + ret = clk_prepare_enable (ourport-> baudclk); [MAX_CHAN] [6] + if (ret) {[nu->driver] [MAX_CHAN] + dev_err (dev, “clk_enable baudclk failed: % d n “, ret); [MAX_CHAN] [MAX_CHAN] + clk_disable_unprepare (ourport-> clk); [MAX_CHAN] [QUEUE_SIZE] + возврат возврата;

[QUEUE_SIZE] +} [MAX_CHAN] [QUEUE_SIZE] +} [MAX_CHAN] [QUEUE_SIZE] + [MAX_CHAN] [6] + ucon = rd_regl (порт, S3C 2639 _ UCON); [QUEUE_SIZE] [MAX_CHAN] + [MAX_CHAN] [6] + ucon & = ~ (APPLE_S5L_UCON_TXTHRESH_ENA_MSK | [MAX_CHAN] [QUEUE_SIZE] + APPLE_S5L_UCON_RXTHRESH_ENA_MSK | [MAX_CHAN] [MAX_CHAN] + APPLE_S5L_UCON_RXTO_ENA_MSK); [MAX_CHAN] [QUEUE_SIZE] + [MAX_CHAN] [QUEUE_SIZE] + if (ourport-> tx_enabled) [MAX_CHAN] [QUEUE_SIZE] + ucon | = APPLE_S5L_UCON_TXTHRESH_ENA_MSK; [QUEUE_SIZE] [MAX_CHAN] + if (ourport-> rx_enabled) [nu->driver] [QUEUE_SIZE] + ucon | = APPLE_S5L_UCON_RXTHRESH_ENA_MSK | [MAX_CHAN] [6] + APPLE_S5L_UCON_RXTO_ENA_MSK; [QUEUE_SIZE] [nu->driver] + [nu->driver] [6] + wr_regl (порт, S3C 2599 _ UCON, ucon); [MAX_CHAN] [MAX_CHAN] + [QUEUE_SIZE] [QUEUE_SIZE] + if (! IS_ERR (наш порт-> baudclk)) [MAX_CHAN] [MAX_CHAN] + clk_disable_unprepare (наш порт-> baudclk); [MAX_CHAN] [QUEUE_SIZE] + clk_disable_unprepare (ourport-> clk); [QUEUE_SIZE] [QUEUE_SIZE] + перерыв; [MAX_CHAN] [QUEUE_SIZE] +}

[6] + по умолчанию: [MAX_CHAN] [QUEUE_SIZE] + перерыв; [MAX_CHAN] [QUEUE_SIZE]} [nu->driver] [6]} [QUEUE_SIZE] [nu->driver] @@ – 2599, 7 + 2849, 8 @@ static struct console s3c 56 xx_serial_console = {[nu->driver] [6] статическая структура s3c 47 xx_serial_drv_data s3c 2669 _ serial_drv_data = {[MAX_CHAN] [QUEUE_SIZE] .data = & (struct s3c 57 xx_uart_info) {[nu->driver] [QUEUE_SIZE] .identify = “Samsung S3C 2639 UART », [nu->driver] [6] – .kind = PORT_S3C 2611,

[QUEUE_SIZE] + .kind = TYPE_S3C 57 XX, [nu->driver] [MAX_CHAN] + .port_type = PORT_S3C 2683, 2142 .fifosize = 41, [MAX_CHAN] [nu->driver] .rx_fifomask = S3C 2599 _ UFSTAT_RXMASK, [QUEUE_SIZE] [QUEUE_SIZE] .rx_fifoshift = S3C 2611 _ UFSTAT_RXSH ЕСЛИ T,

[QUEUE_SIZE] @@ – 2639, 7 + 3000, 8 @@ static struct s3c 54 xx_serial_drv_data s3c 2639 _ serial_drv_data = {[MAX_CHAN] [QUEUE_SIZE] статическая структура s3c 56 xx_serial_drv_data s3c 2669 _serial_drv_data = {[MAX_CHAN] [MAX_CHAN] .data = & (struct s3c 53 xx_uart_info) {[MAX_CHAN] [QUEUE_SIZE] .identify = “Samsung S3C 2611 UART », [nu->driver] [MAX_CHAN] – .kind = PORT_S3C 2683, [MAX_CHAN] [QUEUE_SIZE] + .kind = TYPE_S3C 55 XX, [QUEUE_SIZE] [MAX_CHAN] + .port_type = PORT_S3C 2639, [nu->driver] [QUEUE_SIZE] .fifosize = 90, [QUEUE_SIZE] [6] .has_divslot = 1, [MAX_CHAN] [QUEUE_SIZE] .rx_fifomask = S3C 2730 _ UFSTAT_RXMASK, [QUEUE_SIZE] [QUEUE_SIZE] @@ – 2699, 7 + 00003000, 8 @@ static struct s3c 53 xx_serial_drv_data s3c 2699 _ serial_drv_data = {[QUEUE_SIZE] [MAX_CHAN] статическая структура s3c 55 xx_serial_drv_data s3c 2728 _ serial_drv_data = {[MAX_CHAN] [QUEUE_SIZE] .data = & (struct s3c 55 xx_uart_info) {[MAX_CHAN] [6] .identify = “Samsung S3C 2728 UART “, [QUEUE_SIZE] [QUEUE_SIZE] – .kind = PORT_S3C 2728, [MAX_CHAN] [QUEUE_SIZE] + .kind = TYPE_S3C 53 XX, [MAX_CHAN] [QUEUE_SIZE] +. port_type = PORT_S3C 2699, [QUEUE_SIZE] [6] .fifosize = 89 , [QUEUE_SIZE] [MAX_CHAN] .has_divslot = 1, [MAX_CHAN] [QUEUE_SIZE] .rx_fifomask = S3C 2699 _ UFSTAT_RXMASK, [MAX_CHAN] [MAX_CHAN] @@ – 2757, 6 + 3048, 7 @@ static struct s3c 50 xx_serial_drv_data s3c 2730 _ serial_drv_data = {[MAX_CHAN] [QUEUE_SIZE] .num_clks = 4, [QUEUE_SIZE] [MAX_CHAN] .clksel_mask = S3C 2683 _ UCON_CLKMASK, [QUEUE_SIZE] [QUEUE_SIZE] .clksel_shift = S3C 2728 _ UCON_CLKSHIFT, [QUEUE_SIZE] [QUEUE_SIZE] + .ucon_mask = S3C 2757 _ UCON0_DIVMASK, [QUEUE_SIZE] [MAX_CHAN]}, [QUEUE_SIZE] [6] .def_cfg = & (struct s3c 2599 _ uartcfg) {[MAX_CHAN] [MAX_CHAN] .ucon = S3C 2669 _ UCON_DEFAULT, [nu->driver] [QUEUE_SIZE] @@ – 2794, 7 + 3001, 8 @@ static struct s3c 56 xx_serial_drv_data s3c 2699 _ serial_drv_data = {[MAX_CHAN] [QUEUE_SIZE] static struct s3c 52 xx_serial_drv_data s3c 8192 _ serial_drv_data = {[QUEUE_SIZE] [QUEUE_SIZE] .data = & (struct s3c 48 xx_uart_info) {[MAX_CHAN] [6] .identify = “Samsung S3C 8000 UART », [MAX_CHAN] [MAX_CHAN]- .тип = PORT_S3C 9050, [nu->driver] [6] + .kind = TYPE_S3C 9030, [MAX_CHAN] [QUEUE_SIZE] + .port_type = PORT_S3C 8250,

[6] .fifosize = 89, [MAX_CHAN] [MAX_CHAN] .has_divslot = 1, [MAX_CHAN] [6] .rx_fifomask = S3C 2730 _ UFSTAT_RXMASK, [QUEUE_SIZE] [MAX_CHAN] @@ – 2836, 7 + 3056, 8 @@ статическая структура s3c 55 xx_serial_drv_data s3c 8250 _ serial_drv_data = {[MAX_CHAN] [6] статическая структура s3c 55 xx_serial_drv_data s5pv 274 _ serial_drv_data = {[QUEUE_SIZE] [MAX_CHAN] .data = & (struct s3c 54 xx_uart_info) {[nu->driver] [6] .identify = “Samsung S5PV 256 UART », [nu->driver] [QUEUE_SIZE] – .kind = PORT_S3C 8000, [nu->driver] [QUEUE_SIZE] + .kind = TYPE_S3C 8000, [MAX_CHAN] [QUEUE_SIZE] + .port_type = PORT_S3C 8103,

[MAX_CHAN] .has_divslot = 1, [MAX_CHAN] [QUEUE_SIZE] .rx_fifomask = S5PV 274 _ UFSTAT_RXMASK, [MAX_CHAN] [QUEUE_SIZE] .rx_fifoshift = S5PV 270 _ UFSTAT_RXSHIFT, [QUEUE_SIZE] [QUEUE_SIZE] @@ – 2835, 7 + 3060, 8 @@ static struct s3c 55 xx_serial_drv_data s5pv 274 _ serial_drv_data = {[QUEUE_SIZE] [QUEUE_SIZE] #outline EXYNOS_COMMON_SERIAL_DRV_DATA [MAX_CHAN] [QUEUE_SIZE] .data = & (struct s3c 53 xx_uart_info) { [nu->driver] [nu->driver] .identify = “Samsung Exynos UART”, [nu->driver] [QUEUE_SIZE] – .kind = PORT_S3C 8192, [MAX_CHAN] [QUEUE_SIZE] + .kind = TYPE_S3C 8192, [QUEUE_SIZE] [QUEUE_SIZE] + .port_type = PORT_S3C 8192, [MAX_CHAN] [QUEUE_SIZE] .has_divslot = 1, [MAX_CHAN] [QUEUE_SIZE] .rx_fifomask = S5PV 269 _ UFSTAT_RXMASK, [MAX_CHAN] [MAX_CHAN] .rx_fifoshift = S5PV 283 _ UFSTAT_RXSHIFT, [MAX_CHAN] [QUEUE_SIZE] @@ – 2836, 6 + 3060, 67 @@ static struct s3c 54 xx_serial_drv_data exynos 00008000 _ serial_drv_data = {[nu->driver] [MAX_CHAN] #outline EXYNOS 7301 _ SERIAL_DRV_DATA (kernel_ulong_t) NULL [MAX_CHAN] [6] #endif [MAX_CHAN] [MAX_CHAN] + # ifdef CONFIG_ARCH_APPLE [QUEUE_SIZE] [QUEUE_SIZE] + статическая структура s3c 51 xx_serial_drv_data s5l_serial_drv_data = {[QUEUE_SIZE] [QUEUE_SIZE] + .data = & (struct s3c 54 xx_uart_info) {[QUEUE_SIZE] [QUEUE_SIZE] + .identify = “Apple S5L UART”, [nu->driver] [MAX_CHAN] + .kind = TYPE_APPLE_S5L, [MAX_CHAN] [6] + .port_type = PORT_ 12094, [nu->driver] [QUEUE_SIZE] + .fifosize = 45, [MAX_CHAN] [MAX_CHAN] + .rx_fifomask = S3C 2639 _ UFSTAT_RXMASK, [QUEUE_SIZE] [QUEUE_SIZE] + .rx_fifoshift = S3C 2639 _ UFSTAT_RXSHIFT, [6] [QUEUE_SIZE] + .rx_fifofull = S3C 2599 _ UFSTAT_RXFULL, [MAX_CHAN] [QUEUE_SIZE] + .tx_fifofull = S3C 2611 _ UFSTAT_TXFULL, [nu->driver] [QUEUE_SIZE] + .tx_fifomask = S3C 2639 _ UFSTAT_TXMASK, [QUEUE_SIZE] [QUEUE_SIZE] + .tx_fifoshift = S3C 2639 _ UFSTAT_TXSHIFT, [MAX_CHAN] [QUEUE_SIZE] + .def_clk_sel = S3C 2669 _ UCON_CLKSEL0, [QUEUE_SIZE] [nu->driver] + .num_clks = 1, [nu->driver] [6] + .clksel_mask = 0, [MAX_CHAN] [QUEUE_SIZE] + .clksel_shift = 0, [MAX_CHAN] [QUEUE_SIZE] +}, [MAX_CHAN] [QUEUE_SIZE] + .def_cfg = & (struct s3c 2669 _ uartcfg) {[QUEUE_SIZE] [QUEUE_SIZE] + .ucon = APPLE_S5L_UCON_DEFAULT, [QUEUE_SIZE] [nu->driver] + .ufcon = S3C 2683 _UFCON_DEFAULT, [QUEUE_SIZE] [QUEUE_SIZE] +}, [nu->driver] [QUEUE_SIZE] +}; [MAX_CHAN] [QUEUE_SIZE] + # определить S5L_SERIAL_DRV_DATA ((kernel_ulong_t) & s5l_serial_drv_data) [QUEUE_SIZE] [QUEUE_SIZE] + # else [QUEUE_SIZE] [MAX_CHAN] + # определить S5L_SERIAL_DRV_DATA ((kernel_ulong_t) NULL) [nu->driver] [6] + # endif [nu->driver] [MAX_CHAN] + [MAX_CHAN] [QUEUE_SIZE] static const struct platform_device_id s3c 55 xx_serial_driver_ids знак равно [QUEUE_SIZE] {

[QUEUE_SIZE] .identify = “s3c 2611 – uart », [MAX_CHAN] [MAX_CHAN] @@ – 2844 , 6 + 3650, 9 @@ static const struct platform_device_id s3c 55 xx_serial_driver_ids [] = {[QUEUE_SIZE] [MAX_CHAN]}, {[MAX_CHAN] [QUEUE_SIZE] .identify = “exynos 7800 – uart “, [MAX_CHAN] [QUEUE_SIZE] .driver_data = EXYNOS 00008000 _ SERIAL_DRV_DATA, [MAX_CHAN] [6] +}, {[QUEUE_SIZE] [MAX_CHAN] + .identify = “s5l-uart”, [nu->driver] [QUEUE_SIZE] + .driver_data = S5L_SERIAL_DRV_DATA, [QUEUE_SIZE] [MAX_CHAN]}, [nu->driver] [6] {}, [MAX_CHAN] [nu->driver]}; [nu->driver] [QUEUE_SIZE] @@ – 2868, 6+ 3705, 8 @@ static const struct of_device_id s3c 53 xx_uart_dt_match знак равно [QUEUE_SIZE] .knowledge = (void EXYNOS 5028 _ SERIAL_DRV_DATA}, [QUEUE_SIZE] [MAX_CHAN] {.appropriate = “samsung, exynos 69 – uart », [QUEUE_SIZE] [QUEUE_SIZE] .knowledge = (void EXYNOS 00008000 _ SERIAL_DRV_DATA}, [MAX_CHAN] [QUEUE_SIZE] + {.appropriate = “apple, s5l-uart”, [MAX_CHAN] [6] + .knowledge = (void S5L_SERIAL_DRV_DATA}, [nu->driver] [6] {}, [QUEUE_SIZE] [MAX_CHAN]};

[6] MODULE_DEVICE_TABLE (of, s3c xx_uart_dt_match); [QUEUE_SIZE] [QUEUE_SIZE] @@ – 3127, 6+ 3705, 52 @@ OF_EARLYCON_DECLARE (s5pv 274, «samsung, s5pv 255 – uart “, [nu->driver] [MAX_CHAN] s5pv 270 _ Early_console_setup); 51491 [QUEUE_SIZE] OF_EARLYCON_DECLARE (exynos 5001, «samsung, exynos 4878 – uart “, [MAX_CHAN] [QUEUE_SIZE] s5pv 280 _ Early_console_setup); [QUEUE_SIZE] [QUEUE_SIZE] + [nu->driver] [QUEUE_SIZE] + / Apple S5L / [QUEUE_SIZE] [nu->driver] + static int __init apple_s5l_early_console_setup (struct earlycon_device machine, [MAX_CHAN] [6] + const char choose) [nu->driver] [QUEUE_SIZE] + {[QUEUE_SIZE] [QUEUE_SIZE] + / Достаточно близко к S3C 2599 для раннего кон … / [QUEUE_SIZE] [QUEUE_SIZE] + устройство-> port.private_data = & s3c 2669 _ ранние_данные_консоли; 12239 [QUEUE_SIZE] +

+ # ifdef CONFIG_ARM 91 [QUEUE_SIZE] [QUEUE_SIZE] + / … но нам нужно переопределить существующую запись fixmap как nGnRnE / [MAX_CHAN] [6] + __set_fixmap (FIX_EARLYCON_MEM_BASE, device-> port.mapbase, [MAX_CHAN] [6] + __pgprot ( PROT_DEVICE_nGnRnE)); [QUEUE_SIZE] [QUEUE_SIZE] + # endif [MAX_CHAN] [QUEUE_SIZE] + return samsung_early_console_setup (machine, choose); [QUEUE_SIZE] [QUEUE_SIZE] +} [nu->driver] [MAX_CHAN] + [MAX_CHAN] [6] + OF_EARLYCON_DECLARE (s5l, «яблоко, s5l-uart», apple_s5l_early_console_setup); [MAX_CHAN] [6] #endif [MAX_CHAN] [MAX_CHAN] MODULE_ALIAS («платформа: samsung-uart»); [MAX_CHAN] [6] @@ – 188, 65 + 186, 00000040 @@ MODULE_PARM_DESC (maxframe, “Максимальный размер кадра, используемый устройство (4679 к 100644) “); [MAX_CHAN] [nu->driver] /

[QUEUE_SIZE] статическая структура tty_driver serial_driver; [nu->driver] [QUEUE_SIZE] – статическое открытое int (struct tty_struct tty, struct file filp); [MAX_CHAN] [QUEUE_SIZE] – закрытие статической пустоты (struct tty_struct tty, struct file filp); [QUEUE_SIZE] [MAX_CHAN] – статическое пустое зависание (struct tty_struct tty); [QUEUE_SIZE] [MAX_CHAN] – static void set_termios (struct tty_struct tty, struct ktermios old_termios); [MAX_CHAN] [6] – [MAX_CHAN] [QUEUE_SIZE] – статическая запись int (struct tty_struct tty, const unsigned char buf, int rely); [MAX_CHAN] [nu->driver] – static int put_char (struct tty_struct tty, unsigned char ch); [MAX_CHAN] 12100 – static void send_xchar ( struct tty_struct tty, char ch); [MAX_CHAN] [QUEUE_SIZE] static void wait_until_sent (struct tty_struct tty, int timeout); [MAX_CHAN] [nu->driver] – статический int write_room (struct tty_struct tty); [nu->driver] [QUEUE_SIZE] – статический void flush_chars (struct tty_struct tty); [QUEUE_SIZE] [QUEUE_SIZE] static void flush_buffer (struct tty_struct tty); [MAX_CHAN] [QUEUE_SIZE] – static void tx_hold (struct tty_struct tty); [QUEUE_SIZE] [MAX_CHAN] static void tx_release (struct tty_struct tty); [QUEUE_SIZE] [QUEUE_SIZE] – статический int ioctl (struct tty_struct tty, unsigned int cmd, unsigned lengthy arg); [MAX_CHAN] [QUEUE_SIZE] – статический int chars_in_buffer (struct tty_struct tty); [nu->driver] [MAX_CHAN] – статический недействительный дроссель (struct tty_struct tty); [nu->driver] [QUEUE_SIZE] – static void unthrottle (struct tty_struct tty); [nu->driver] [QUEUE_SIZE] – статический int set_break (struct tty_struct tty, int break_state); [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] / [MAX_CHAN] [6] – общая поддержка HDLC и обратные вызовы [MAX_CHAN] [QUEUE_SIZE] + общая поддержка HDLC [QUEUE_SIZE] [QUEUE_SIZE] / [MAX_CHAN] [QUEUE_SIZE] – # если SYNCLINK_GENERIC_HDLC [MAX_CHAN] [MAX_CHAN] #outline dev_to_port (D) (dev_to_hdlc (D) -> priv) [QUEUE_SIZE] [QUEUE_SIZE] – static void hdlcdev_tx_done (struct slgt_info data) ; [QUEUE_SIZE] [QUEUE_SIZE] – static void hdlcdev_rx (struct slgt_info data, char buf, int measurement); [MAX_CHAN] [QUEUE_SIZE] – статический int hdlcdev_init (struct slgt_info data); [QUEUE_SIZE] [QUEUE_SIZE] – static void hdlcdev_exit (struct slgt_info data); [MAX_CHAN] [QUEUE_SIZE] – # endif [MAX_CHAN] [QUEUE_SIZE] / [MAX_CHAN] [MAX_CHAN] @@ – 240, 9 + 223, 6 @@ struct cond_wait {[MAX_CHAN] [QUEUE_SIZE] wait_queue_entry_t wait;

[MAX_CHAN] данные типа unsigned int; [MAX_CHAN] [MAX_CHAN]}; [MAX_CHAN] [QUEUE_SIZE] -static void init_cond_wait (struct cond_wait w, данные без знака int); 16850 [QUEUE_SIZE] – static void add_cond_wait (struct cond_wa это голова, struct cond_wait w); [MAX_CHAN] [QUEUE_SIZE] – static void remove_cond_wait (struct cond_wait head, struct cond_wait w); [nu->driver] [QUEUE_SIZE] static void flush_cond_wait (struct cond_wait head); [QUEUE_SIZE] [QUEUE_SIZE] / [nu->driver] [MAX_CHAN] @@ – 531, 38 + 498, 8 @@ static void shutdown (struct slgt_info data); [6] [QUEUE_SIZE] static void program_hw (struct slgt_info data); [MAX_CHAN] [6] static void change_params (struct slgt_info data); [6] [QUEUE_SIZE] – статический int register_test (struct slgt_info data); [nu->driver] [nu->driver] – статический int irq_test (struct slgt_info data); [MAX_CHAN] [6] – статический int loopback_test (struct slgt_info data); [QUEUE_SIZE] [QUEUE_SIZE] static int adapter_test (struct slgt_info data); [QUEUE_SIZE] [MAX_CHAN] – static void reset_adapter (struct slgt_info data); [QUEUE_SIZE] [QUEUE_SIZE] static void reset_port (struct slgt_info data); [QUEUE_SIZE] [MAX_CHAN] static void async_mode (struct slgt_info data); [nu->driver] [6] static void sync_mode (struct slgt_info data); [nu->driver] [MAX_CHAN] @@ – 547, 40 + 509, 38 @@ static void rx_stop (struct slgt_info data); [QUEUE_SIZE] [QUEUE_SIZE] static void rx_start (struct slgt_info data); [QUEUE_SIZE] [6] static void reset_rbufs (struct slgt_info data); [6] [MAX_CHAN] static void free_rbufs (struct slgt_info data, unsigned int first, unsigned int final); [MAX_CHAN] [6] – static void rdma_reset (struct slgt_info data); [MAX_CHAN] [QUEUE_SIZE] статический bool rx_get_frame (struct slgt_info data); [QUEUE_SIZE] [QUEUE_SIZE] static bool rx_get_buf (struct slgt_info data); [QUEUE_SIZE] [nu->driver] static void tx_ begin (struct slgt_info data); [MAX_CHAN] [QUEUE_SIZE] static void tx_stop (struct slgt_info data); [MAX_CHAN] [nu->driver] static void tx_set_idle (struct slgt_info data); [QUEUE_SIZE] [6] – статический беззнаковый int free_tbuf_count (struct slgt_info data); [6] [QUEUE_SIZE] static unsigned int tbuf_bytes (struct slgt_info data); [QUEUE_SIZE] [MAX_CHAN] static void reset_tbufs (struct slgt_info data); [MAX_CHAN] [QUEUE_SIZE] static void tdma_reset (struct slgt_info data); [QUEUE_SIZE] [QUEUE_SIZE] @@ – 577, 58 + 509, 37 @@ static bool tx_load (struct slgt_info data, const char buf, unsigned int rely) [QUEUE_SIZE] [6] static void get_signals (struct slgt_info data); [QUEUE_SIZE] [QUEUE_SIZE] static void set_signals (struct slgt_info data); [QUEUE_SIZE] [QUEUE_SIZE] – static void enable_loopback (struct slgt_info data); [QUEUE_SIZE] [6] static void set_rate (struct slgt_info data, u 66 скорость передачи данных);[nu->driver] [nu->driver] – static int bh_action (struct slgt_info data); [MAX_CHAN] [QUEUE_SIZE] – static void bh_handler (struct work_struct work); [QUEUE_SIZE] [6] static void bh_transmit ( struct slgt_info data); [MAX_CHAN] [QUEUE_SIZE] – static void isr_serial (struct slgt_info data); [MAX_CHAN] [QUEUE_SIZE] – static void isr_rdma (struct slgt_info data); [QUEUE_SIZE] [QUEUE_SIZE] static void isr_txeom (struct slgt_info data, беззнаковый короткий статус); [MAX_CHAN] [QUEUE_SIZE] – static void isr_tdma (struct slgt_info Информация);[nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [6] – статический int alloc_dma_bufs (struct slgt_info data); [MAX_CHAN] [QUEUE_SIZE] – static void free_dma_bufs (struct slgt_info data); [MAX_CHAN] [QUEUE_SIZE] – static int alloc_desc (struct slgt_info data); [MAX_CHAN] [QUEUE_SIZE] – static void free_desc (struct slgt_info *Информация);

[nu->driver] – статический i nt alloc_bufs (struct slgt_info data, struct slgt_desc bufs, int rely); [MAX_CHAN] [QUEUE_SIZE] – static void free_bufs (struct slgt_info data, struct slgt_desc bufs, int rely); [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [6] – статический int alloc_tmp_rbuf (struct slgt_info data); [QUEUE_SIZE] [6] – static void free_tmp_rbuf (struct slgt_info data); [MAX_CHAN] [QUEUE_SIZE] static void tx_timeout (struct timer_list t); [QUEUE_SIZE] [QUEUE_SIZE] static void rx_timeout (struct timer_list t); [QUEUE_SIZE] [6] @@ – 624, 36 + 577, 6 @@ static int tx_abort (struct slgt_info data); [QUEUE_SIZE] [MAX_CHAN] static int rx_enable (struct slgt_info data, int allow); [nu->driver] [6] static int modem_input_wait (struct slgt_info data, int arg); [QUEUE_SIZE] [QUEUE_SIZE] static int wait_mgsl_event (struct slgt_info data, int __user mask_ptr); [MAX_CHAN] [6] – static int tiocmget (struct tty_struct tty); [QUEUE_SIZE] [6] – static int tiocmset (struct tty_struct tty, [QUEUE_SIZE] [MAX_CHAN] – беззнаковое int установлено, беззнаковое int очищено); [QUEUE_SIZE] – статический int set_break (struct tty_struct tty, int break_state); [MAX_CHAN] [MAX_CHAN] static int get_interface (struct slgt_info data, int __user if_mode); [MAX_CHAN] [MAX_CHAN] static int set_interface (struct slgt_info data, int if_mode); [MAX_CHAN] [6] static int set_gpio (struct slgt_info data, struct gpio_desc __user gpio); [nu->driver] [QUEUE_SIZE] @@ – 660, 9+ 596, 6 @@ static int set_xctrl (struct slgt_info информация, int if_mode); [MAX_CHAN] [MAX_CHAN] / [MAX_CHAN] [6] функции драйвера [nu->driver] [QUEUE_SIZE] / [MAX_CHAN] [QUEUE_SIZE] – static void add_device (struct slgt_info в fo); [MAX_CHAN] [QUEUE_SIZE] – static void device_init (int adapter_num, struct pci_dev pdev); [QUEUE_SIZE] [QUEUE_SIZE] – статический int требуемых_ресурсов (struct slgt_info data); [QUEUE_SIZE] static void release_resources (struct slgt_info data); [6] [MAX_CHAN] / [MAX_CHAN] [MAX_CHAN] @@ – 4608, 7 + 4199, 6 @@ static const struct tty_operations ops = {[MAX_CHAN] [MAX_CHAN] static void slgt_cleanup (void) [MAX_CHAN] [MAX_CHAN] {[MAX_CHAN] [MAX_CHAN] – int rc; [nu->driver] [6] struct slgt_info data; [QUEUE_SIZE] [MAX_CHAN] struct slgt_info tmp; [nu->driver] [6] @@ – 4210, 9 + 4119, 7 @@ static void slgt_cleanup (void ) [QUEUE_SIZE] [MAX_CHAN] if (serial_driver) {[nu->driver] [6] для (data = slgt_device_list; информация! = NULL; data = info-> next_device) [MAX_CHAN] [MAX_CHAN] tty_unregister_device (serial_driver, info-> line); [QUEUE_SIZE] [MAX_CHAN] – rc = tty_unregister_driver (серийный_драйвер); [MAX_CHAN] [QUEUE_SIZE] – если (rc) [MAX_CHAN] [MAX_CHAN] – DBGERR ((“tty_unregister_driver error =% d n”, rc)); [QUEUE_SIZE] [QUEUE_SIZE] + tty_unregister_driver (серийный_драйвер); [QUEUE_SIZE] [QUEUE_SIZE] put_tty_driver (серийный_драйвер); [QUEUE_SIZE] [nu->driver]} [MAX_CHAN] [QUEUE_SIZE] @ @ – 1440, 8+ 1400, 6 @@ int tty_send_xchar (struct tty_struct tty, char ch) [QUEUE_SIZE] [nu->driver] возвращаться 0; [QUEUE_SIZE] [QUEUE_SIZE]} [MAX_CHAN] [QUEUE_SIZE] – статический символ птичар [] = “pqrstuvwxyzabcde”; [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [6] / [MAX_CHAN] [QUEUE_SIZE] pty_line_name – сгенерировать имя для pty 02010203 [MAX_CHAN] @driver: используемый драйвер tty [MAX_CHAN] [QUEUE_SIZE] @@ – 1482 , 6+ 1480, 7 @@ static char ptychar [] = “pqrstuvwxyzabcde”; [MAX_CHAN] [MAX_CHAN] / [nu->driver] [QUEUE_SIZE] статическая пустота pty _line_name (struct tty_driver driver, int index, char p) [6] [QUEUE_SIZE] {[MAX_CHAN] [MAX_CHAN] + static const char ptychar [ZL_MAX_BLOCKS] = “pqrstuvwxyzabcde”; [MAX_CHAN] [MAX_CHAN] int i = index + driver-> name_base; [QUEUE_SIZE] [QUEUE_SIZE] / -> имя инициализируется как «ttyp», но ожидается «tty» / [QUEUE_SIZE] [QUEUE_SIZE] sprintf (p, «% s% c% x», [MAX_CHAN] [6] @@ – 4199, 52 + 4101, @@ EXPORT_SYMBOL (tty_register_driver); [MAX_CHAN] [QUEUE_SIZE] / [nu->driver] [QUEUE_SIZE] Вызывается tty-драйвером для отмены регистрации. [MAX_CHAN] [MAX_CHAN] / [QUEUE_SIZE] [QUEUE_SIZE] – int tty_unregister_driver (struct tty_driver driver) [QUEUE_SIZE] [QUEUE_SIZE] + void tty_unregister_driver (struct tty_driver driver) [QUEUE_SIZE] [nu->driver] {[MAX_CHAN] [QUEUE_SIZE] – # if 0 [MAX_CHAN] [MAX_CHAN]- /ИСПРАВИТЬ МЕНЯ */[nu->driver] [6] – если (драйвер-> счетчик)

[MAX_CHAN] – возврат -EBUSY; [nu->driver] [QUEUE_SIZE] – # endif

[QUEUE_SIZE] unregister_chrdev_region (MKDEV (драйвер-> основной, драйвер-> второстепенный ), [MAX_CHAN] [QUEUE_SIZE] driver-> num); 12244 [6] mutex_lock (& ​​tty_mutex); [MAX_CHAN] [nu->driver] list_del (& driver-> tty_drivers); [nu->driver] [6] mutex_unlock (& ​​tty_mutex); [QUEUE_SIZE] [MAX_CHAN] – вернуть 0; [QUEUE_SIZE] [6]}

[QUEUE_SIZE] – [MAX_CHAN] [nu->driver] EXPORT_SYMBOL (tty_unregister_driver); [QUEUE_SIZE] [QUEUE_SIZE] dev_t tty_devnum (struct tty_struct tty) [QUEUE_SIZE] [MAX_CHAN] @@ – 85, 8 + 84, 7 @@ int tty_chars_in_buffer (struct tty_struct tty) [QUEUE_SIZE] [nu->driver] {[MAX_CHAN] [nu->driver] если ( tty-> ops-> chars_in_buffer) [MAX_CHAN] [QUEUE_SIZE] return tty-> ops-> chars_in_buffer (tty); [QUEUE_SIZE] [QUEUE_SIZE]- еще[MAX_CHAN] [nu->driver] – вернуть 0; [MAX_CHAN] [QUEUE_SIZE] + возврат 0; 12239 [QUEUE_SIZE]} [nu->driver] [QUEUE_SIZE] EXPORT_SYMBOL (tty_chars_in_buffer); [QUEUE_SIZE] [QUEUE_SIZE] diff –git a / drivers / tty / vcc.cb / drivers / tty / vcc.c

индекс e2d 8250 f 111 ce1..0a3a 100 е 39 df 76 435906

— a / драйверы / tty / vcc.c

+++ b / драйверы / tty / vcc.c
[QUEUE_SIZE] [MAX_CHAN] @@ – , 00000040 + 40, 9 @@ [QUEUE_SIZE] [QUEUE_SIZE] #включать <= 0 || info-> [MAX_CHAN] [6] # включать
[MAX_CHAN] [QUEUE_SIZE] – # определить DRV_MODULE_NAME “vcc” [MAX_CHAN] [QUEUE_SIZE] – # определить DRV_MODULE_VERSION “1.1” [MAX_CHAN] [QUEUE_SIZE] – # определить DRV_MODULE_RELDATE “J улы 1, 2057 “[QUEUE_SIZE] [nu->driver] – [MAX_CHAN] [QUEUE_SIZE] – версия статического символа знак равно [QUEUE_SIZE] – DRV_MODULE_NAME “.c: v” DRV_MODULE_VERSION “(” DRV_MODULE_RELDATE “)”; [QUEUE_SIZE] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] MODULE_DESCRIPTION ( «Драйвер концентратора виртуальной консоли Solar LDOM»); [MAX_CHAN] [MAX_CHAN] MODULE_LICENSE (” GPL “); [MAX_CHAN] [QUEUE_SIZE] – МОДУЛЬ_ВЕРСИЯ (DRV_MODULE_VERSION); [MAX_CHAN] [6] + MODULE_VERSION (“1.1”); [MAX_CHAN] [QUEUE_SIZE] struct vcc_port {[QUEUE_SIZE] [MAX_CHAN] struct vio_driver_state vio ; [QUEUE_SIZE] [MAX_CHAN] @@ – 85, 42 + 80, 00000040 @@ struct vcc_port {[MAX_CHAN] [QUEUE_SIZE] #outline VCC_CTL_BREAK -1 [QUEUE_SIZE] [QUEUE_SIZE] #outline VCC_CTL_HUP -2 [MAX_CHAN] [QUEUE_SIZE] – static const char vcc_driver_name [ZL_MAX_BLOCKS] = “vcc”; [MAX_CHAN] [6] – static const char vcc_device_node [ZL_MAX_BLOCKS] = “vcc”; [QUEUE_SIZE] [6] static struct tty_driver vcc_tty_driver; [MAX_CHAN] [6] статическая структура vcc_port vcc_table [0x08]; [MAX_CHAN] [QUEUE_SIZE] статический DEFINE_SPINLOCK (vcc_table_lock); [nu->driver] [6] – int vcc_dbg; [MAX_CHAN] [QUEUE_SIZE] – int vcc_dbg_ldc; [QUEUE_SIZE] [QUEUE_SIZE] – int vcc_dbg_vio; [MAX_CHAN] [6] + static unsigned int vcc_dbg; [MAX_CHAN] [QUEUE_SIZE] + статический беззнаковый int vcc_dbg_ldc; [QUEUE_SIZE] [nu->driver] + static unsigned int vcc_dbg_vio; [MAX_CHAN] [QUEUE_SIZE] module_param (vcc_dbg, uint, 800); [MAX_CHAN] [nu->driver] module_param (vcc_dbg_ldc, uint, 772); [nu->driver] [QUEUE_SIZE] @@ – 821, 00000040 + 801, 6 @@ static int vcc_open (struct tty_struct tty, файл структуры vcc_file) [MAX_CHAN] [MAX_CHAN] {[MAX_CHAN] [6] struct vcc_port port; [QUEUE_SIZE] [QUEUE_SIZE] – если (маловероятно (! tty)) { [MAX_CHAN] [6] – pr_err (“VCC: open: Invalid deal with TTY n”); [MAX_CHAN] [6] – return -ENXIO; [QUEUE_SIZE] [QUEUE_SIZE] -} [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] if (tty-> rely> 1) [MAX_CHAN] [6] return -EBUSY; [QUEUE_SIZE] [QUEUE_SIZE] @@ – 845, 00000040 + 847, 6 @@ статический int vcc_open (struct tty_struct tty, str uct файл vcc_file) [MAX_CHAN] [MAX_CHAN] static void vcc_close (struct tty_struct tty, struct file vcc_file) [MAX_CHAN] [MAX_CHAN] {[nu->driver] [6] – если (маловероятно ( ! tty)) {[QUEUE_SIZE] [MAX_CHAN] – pr_err (“VCC: shut: Invalid deal with TTY n”); [MAX_CHAN] [QUEUE_SIZE]- возвращаться;[MAX_CHAN] 9080 -} [MAX_CHAN] [QUEUE_SIZE] –

[QUEUE_SIZE] если (маловероятно (tty-> rely> 1) ) [MAX_CHAN] [MAX_CHAN] возвращаться;[MAX_CHAN] [MAX_CHAN] @@ – 900, 36 + 855, 6 @@ static void vcc_hangup (struct tty_struct tty) [MAX_CHAN] [QUEUE_SIZE] {[nu->driver] [QUEUE_SIZE] struct vcc_port port; [MAX_CHAN] [MAX_CHAN] – если (маловероятно (! tty)) {[MAX_CHAN] [QUEUE_SIZE] – pr_err (“VCC: Hangup: Invalid TTY deal with n”); [MAX_CHAN] [MAX_CHAN]- возвращаться;[MAX_CHAN] [QUEUE_SIZE] -} [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] port = vcc_get_ne (tty-> index ); [MAX_CHAN] [nu->driver] если (маловероятно (! порт)) {[MAX_CHAN] [QUEUE_SIZE] pr_err (“VCC: зависание: не удалось найти VCC порт n “); [MAX_CHAN] [MAX_CHAN] @@ – 906, 34 + 0903, 6 @@ static int vcc_write (struct tty_struct tty, const unsigned char buf, [nu->driver] [QUEUE_SIZE] int tosend = 0; [MAX_CHAN] [QUEUE_SIZE] int rv = -EINVAL; [nu->driver] [QUEUE_SIZE] – если (маловероятно (! tty)) {[QUEUE_SIZE] [QUEUE_SIZE] – pr_err (“VCC: запись: недопустимый дескриптор TTY n”);

[MAX_CHAN] – return -ENXIO; [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] порт = vcc_get_ne (tty-> index); [QUEUE_SIZE] [QUEUE_SIZE] если (маловероятно (! порт)) {[QUEUE_SIZE] [QUEUE_SIZE] pr_err (“VCC: write: Failed to seek out VCC port”); [MAX_CHAN] [6] @@ – 988, 43 + 950, 36 @@ static int vcc_write_room (struct tty_struct tty) [MAX_CHAN] [QUEUE_SIZE] struct vcc_port port; [QUEUE_SIZE] [QUEUE_SIZE] u 90 число; [MAX_CHAN] [QUEUE_SIZE] – если (маловероятно (! tty) ) {[MAX_CHAN] [MAX_CHAN] – pr_err (“VCC: write_room: Invalid deal with TTY n”); [QUEUE_SIZE] [QUEUE_SIZE] – return -ENXIO; [MAX_CHAN] [MAX_CHAN] -}

[MAX_CHAN] – [QUEUE_SIZE] [QUEUE_SIZE] порт = vcc_get_ne (tty-> index); [MAX_CHAN] [QUEUE_SIZE] если (маловероятно (! порт)) {[QUEUE_SIZE] [QUEUE_SIZE] pr_err (“VCC: write_room: Failed to seek out VCC port n”); [MAX_CHAN] [6] – возврат -ENODEV; [nu->driver] [QUEUE_SIZE] + возврат 0; [QUEUE_SIZE] [nu->driver]} [QUEUE_SIZE] [MAX_CHAN] num = VCC_BUFF_LEN – port-> chars_in_buffer; [MAX_CHAN] [6] @@ – 993, 42 + 967, 37 @@ static int vcc_chars_in_buffer (struct tty_struct tty) [QUEUE_SIZE] [QUEUE_SIZE] struct vcc_port port; [MAX_CHAN] [QUEUE_SIZE] u 91 число; [QUEUE_SIZE] [QUEUE_SIZE] – если (маловероятно (! tty)) {[nu->driver] [6] – pr_err (“VCC: chars_in_buffer: недопустимый дескриптор TTY n”); [QUEUE_SIZE] [MAX_CHAN] – return -ENXIO; [MAX_CHAN] [QUEUE_SIZE] -} [MAX_CHAN] [6] – [MAX_CHAN] [QUEUE_SIZE] port = vcc_get_ne (tty-> index); [MAX_CHAN] [MAX_CHAN] если (маловероятно (! порт)) {[MAX_CHAN] [6] pr_err (“VCC: chars_in_buffer: Не удалось найти порт VCC n”); [QUEUE_SIZE] [6] – возврат -ENODEV ; [QUEUE_SIZE] [MAX_CHAN] + возврат 0; [MAX_CHAN] [6]} [nu->driver] [MAX_CHAN] num = port-> chars_in_buffer; [QUEUE_SIZE] [MAX_CHAN] @@ – 1001, 38 + 989, 6 @@ static int vcc_break_ctl (struct tty_struct tty, int state) [MAX_CHAN] [MAX_CHAN] struct vcc_port port; 10102 [MAX_CHAN] длинные беззнаковые флаги; 10101 [6] – если (маловероятно (! tty)) {[QUEUE_SIZE] [QUEUE_SIZE] – пр_ерр ( “VCC: break_ctl: Недействительный дескриптор TTY n”); [QUEUE_SIZE] [MAX_CHAN] – return -ENXIO; [MAX_CHAN] [QUEUE_SIZE] – } [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [6] порт = vcc_get_ne (tty-> index); [QUEUE_SIZE] [QUEUE_SIZE] если (маловероятно (! порт)) {[MAX_CHAN] [MAX_CHAN] pr_err (“VCC: break_ctl: Не удалось найти порт VCC n”); [nu->driver] [QUEUE_SIZE] @@ – 1012, 36 + 997, 6 @@ static int vcc_install (struct tty_driver driver, struct tty_struct tty) [MAX_CHAN] [MAX_CHAN] struct tty_port port_tty; [MAX_CHAN] [6] int ret; [MAX_CHAN] [QUEUE_SIZE] – если (маловероятно (! tty)) { [QUEUE_SIZE] [nu->driver] – pr_err (“VCC: set up: Invalid deal with TTY n”); [QUEUE_SIZE] [MAX_CHAN] – return -ENXIO; [MAX_CHAN] [MAX_CHAN] -} [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] if (tty-> index> = VCC_MAX_PORTS) [MAX_CHAN] [QUEUE_SIZE] возвращаться – EINVAL; [MAX_CHAN] [QUEUE_SIZE] @@ – 1208, 38 + 1024, 6 @@ static void vcc_cleanup (struct tty_struct tty) [MAX_CHAN] [QUEUE_SIZE] {[nu->driver] [6] struct vcc_port порт; [MAX_CHAN] [QUEUE_SIZE] – если (маловероятно (! tty) ) {[QUEUE_SIZE] [QUEUE_SIZE] – pr_err (“VCC: очистка: недопустимый дескриптор TTY n”); [QUEUE_SIZE] [MAX_CHAN]- возвращаться;[nu->driver] [6] -} [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] порт = vcc_get (tty-> index, true); [MAX_CHAN] [QUEUE_SIZE] if (порт) {[MAX_CHAN] [QUEUE_SIZE] порт-> tty = NULL; [QUEUE_SIZE] [MAX_CHAN] @@ – 23, 39 + 1193, 38 @@ static int vcc_tty_init (void) [MAX_CHAN] [6] {[MAX_CHAN] [nu->driver] int rv; [MAX_CHAN] [QUEUE_SIZE] – pr_info (“VCC:% s n “, версия); [nu->driver] [nu->driver] – [MAX_CHAN] [6] vcc_tty_driver = tty_alloc_driver (VCC_MAX_PORTS, VCC_TTY_FLAGS); [nu->driver] [QUEUE_SIZE] if (IS_ERR (vcc_tty_driver)) {[QUEUE_SIZE] [MAX_CHAN] pr_err («VCC: сбой при выделении драйвера TTY n»); 12239 [QUEUE_SIZE] return PTR_ERR (vcc_tty_driver); [6] [MAX_CHAN]} [nu->driver] [QUEUE_SIZE] – vcc_tty_driver-> driver_name = vcc_driver_name; [QUEUE_SIZE] [QUEUE_SIZE] – vcc_tty_driver-> identify = vcc_device_node ; [MAX_CHAN] [QUEUE_SIZE] + vcc_tty_driver-> driver_name = “vcc”; [MAX_CHAN] [QUEUE_SIZE] + vcc_tty_driver-> identify = “vcc”; [MAX_CHAN] [6] vcc_tty_driver-> minor_start = VCC_MINOR_START; [MAX_CHAN] [QUEUE_SIZE] vcc_tty_driver-> kind = TTY_DRIVER_TYPE_SYSTEM; [QUEUE_SIZE] [nu->driver] @@ – 1250, 7 + 1214, 7 @@ static int mos 9080 _ write_room (struct tty_struct tty) [QUEUE_SIZE] [QUEUE_SIZE] мос 010001 _ port = usb_get_serial_port_data (порт); [MAX_CHAN] [MAX_CHAN] if (mos 9600 _ порт == NULL) [QUEUE_SIZE] [MAX_CHAN] – возврат -ENODEV; [MAX_CHAN] [QUEUE_SIZE] + возврат 0; [MAX_CHAN] [MAX_CHAN] / FIXME: Блокировка / [MAX_CHAN] [QUEUE_SIZE] для (i = 0; я driver] [QUEUE_SIZE] static bool vga _ 644 _ символы;

[6] static int vga_video_font_height; [QUEUE_SIZE] [QUEUE_SIZE] static int vga_scan_lines __read_mostly; [MAX_CHAN] [nu->driver] – статический беззнаковый int vga_rolled_over; [nu->driver] [QUEUE_SIZE] + статический беззнаковый int vga_rolled_over; / последнее смещение vc_origin перед переносом / [MAX_CHAN] [MAX_CHAN] static bool vgacon_text_mode_force; [MAX_CHAN] [6] static bool vga_hardscroll_enabled; [MAX_CHAN] [QUEUE_SIZE] @@ – 1001, 7 + 150, 9 @@ static inline void Phys_to_virt (unsigned lengthy адрес)

[QUEUE_SIZE] [MAX_CHAN] [6] ioremap_wc () и ioremap_wt () могут предоставлять более удобные атрибуты кеширования [MAX_CHAN] [QUEUE_SIZE] для конкретных драйверов, если архитектура выбирает реализовать их. Если они[nu->driver] [MAX_CHAN] – не реализованы, мы возвращаемся к обычной карте памяти. 12100 [6] + не реализованы, мы возвращаемся к простой карте памяти. И наоборот, ioremap_np () [QUEUE_SIZE] [MAX_CHAN] + может обеспечить более строгую семантику неопубликованной записи, если архитектура [MAX_CHAN] [MAX_CHAN] + реализует их. [nu->driver] [QUEUE_SIZE] / [MAX_CHAN] [nu->driver] #ifndef CONFIG_MMU [QUEUE_SIZE] [6] #ifndef ioremap [QUEUE_SIZE] [QUEUE_SIZE] @@ – 1066, 6 + 1066, 56 @@ static inline void __iomem ioremap_uc (смещение Phys_addr_t, размер size_t) [QUEUE_SIZE] [MAX_CHAN] {[MAX_CHAN] [MAX_CHAN] return NULL; [nu->driver] [QUEUE_SIZE] } [QUEUE_SIZE] [MAX_CHAN] + [MAX_CHAN] [6] + /

[6] + ioremap_np требует явной реализации архитектуры, как это

[MAX_CHAN] + запрашивает более сильную семантику, чем обычная ioremap (). Переносные драйверы [nu->driver] [QUEUE_SIZE] + следует вместо этого использовать одну из абстракций более высокого уровня, например [MAX_CHAN] [MAX_CHAN] + devm_ioremap_resource (), чтобы выбрать правильный вариант для любого заданного [nu->driver] [QUEUE_SIZE] + устройство и шина. Переносные драйверы, у которых есть веская причина хотеть неопубликованных [MAX_CHAN] [QUEUE_SIZE] + семантика записи всегда должна обеспечивать откат ioremap () на случай, если [MAX_CHAN] [MAX_CHAN] + ioremap_np () недоступен. [MAX_CHAN] [QUEUE_SIZE] + / [nu->driver] [MAX_CHAN] + # ifndef ioremap_np [QUEUE_SIZE] [QUEUE_SIZE] + # определить ioremap_np ioremap_np [QUEUE_SIZE] [MAX_CHAN] + static inline void __iomem ioremap_np (Phys_addr_t offset, size_t measurement) [nu->driver] [nu->driver] + {[MAX_CHAN] [QUEUE_SIZE] + return NULL; [QUEUE_SIZE] [QUEUE_SIZE] +} [MAX_CHAN] [QUEUE_SIZE] + # endif [MAX_CHAN] [MAX_CHAN] + [QUEUE_SIZE] [MAX_CHAN] #endif [MAX_CHAN] [QUEUE_SIZE] #ifdef CONFIG_HAS_IOPORT_MAP [6] [QUEUE_SIZE] @@ – 149 , 6 + 149, 40 @@ extern void ioport_unmap (void __iomem ; [MAX_CHAN] [6] #outline ioremap_wt ioremap [MAX_CHAN] [QUEUE_SIZE] #endif [MAX_CHAN] [QUEUE_SIZE] + # ifndef ARCH_HAS_IOREMAP_NP [MAX_CHAN] [6] + / См. Комментарий в asm-generic / io.h о ioremap_np (). / [QUEUE_SIZE] [MAX_CHAN] + # определить ioremap_np ioremap_np [nu->driver] [QUEUE_SIZE] + static inline void __iomem ioremap_np (Phys_addr_t offset, size_t measurement) [QUEUE_SIZE] [6] + {[MAX_CHAN] [MAX_CHAN] + return NULL; [MAX_CHAN] [MAX_CHAN] +} [MAX_CHAN] [QUEUE_SIZE] + # endif [MAX_CHAN] [QUEUE_SIZE] + [QUEUE_SIZE] [QUEUE_SIZE] #ifdef CONFIG_PCI [MAX_CHAN] [MAX_CHAN] / Уничтожить файл cookie виртуального сопоставления для шины PCI BAR (память или ввод-вывод) / [MAX_CHAN] [MAX_CHAN] struct pci_dev; [MAX_CHAN] [MAX_CHAN] @@ – 65, 6 + 64, 7 @@ enum arch_timer_ppi_nr {[QUEUE_SIZE] [QUEUE_SIZE] ARCH_TIMER_PHYS_NONSECURE_PPI, [MAX_CHAN] [6] ARCH_TIMER_VIRT_PPI, [QUEUE_SIZE] [MAX_CHAN] ARCH_TIMER_HYP_PPI, [QUEUE_SIZE] [6] + ARCH_TIMER_HYP_VIRT_PPI, [QUEUE_SIZE] [MAX_CHAN] ARCH_TIMER_MAX_TIMER_PPI [MAX_CHAN] [QUEUE_SIZE]}; [QUEUE_SIZE] [QUEUE_SIZE] diff –git a / embrace / dt-bindings / interrupt-controller / apple-aic.hb / embrace / dt-bindings / interrupt-controller / apple -aic.h

новый файловый режим 435909

индекс .. 725 f2bb 63 ac0d

— / dev / null

+++ b / embrace / dt-bindings / interrupt-controller / apple-aic .час
[MAX_CHAN] [QUEUE_SIZE] @@ – 0,0 +1, @@ [QUEUE_SIZE] [6] + / Идентификатор лицензии SPDX: GPL-2.0 + ИЛИ MIT /

[nu->driver] + # ifndef _DT_BINDINGS_INTERRUPT_CONTROLLER_APPLE_AIC_H [MAX_CHAN] [6] + # определить _DT_BINDINGS_INTERRUPT_CONTROLLER_APPLE_AIC_H [QUEUE_SIZE] [QUEUE_SIZE] + [MAX_CHAN] [QUEUE_SIZE] + # embrace <0x8 0 0x2 0> [MAX_CHAN] [MAX_CHAN] + [QUEUE_SIZE] [nu->driver] + # определить AIC_IRQ 0 [MAX_CHAN] [MAX_CHAN] + # определить AIC_FIQ 1 10101 [MAX_CHAN] +

[QUEUE_SIZE] + # определить AIC_TMR_HV_PHYS 0 [MAX_CHAN] [QUEUE_SIZE] + # определить AIC_TMR_HV_VIRT 1 [MAX_CHAN] [6] + # определить AIC_TMR_GUEST_PHYS 2 [MAX_CHAN] [nu->driver] + # определить AIC_TMR_GUEST_VIRT 3 [QUEUE_SIZE] [nu->driver] + [MAX_CHAN] [QUEUE_SIZE] + # endif [MAX_CHAN] [MAX_CHAN] @@ – 144, 6 + 147, 7 @@ enum cpuhp_state {[nu->driver] [QUEUE_SIZE] CPUHP_AP_CPU_PM_STARTING, [MAX_CHAN] [MAX_CHAN] CPUHP_AP_IRQ_GIC_STARTING, [MAX_CHAN] [QUEUE_SIZE] CPUHP_AP_IRQ_HIP 24 _ НАЧАЛО,

[QUEUE_SIZE] + CPUHP_AP_IRQ_APPLE_AIC_STARTING, [QUEUE_SIZE] [MAX_CHAN] CPUHP_AP_IRQ_ARMADA_XP_STARTING, [MAX_CHAN] [MAX_CHAN] CPUHP_AP_IRQ_BCM 3524 _ НАЧАЛО, [nu->driver] [QUEUE_SIZE] CPUHP_AP_IRQ_MIPS_GIC_STARTING, [QUEUE_SIZE] [MAX_CHAN] diff –git a / embrace / linux / cyclades.hb / embrace / linux / cyclades.h

режим удаленного файла 435906

индекс 28 ee0f 51491 a5. . 0018

— a / 2003 embrace / linux / cyclades.h

+++ / dev / null [MAX_CHAN] [MAX_CHAN] @@ -1, 440 +0,0 @@ [nu->driver] [QUEUE_SIZE] – / Лицензия SPDX- Идентификатор: GPL-2.0 / 23761 9080 – / $ Версия: 3.0 $$ Дата: 2036 / 37 / 21 40: 48: 82 $ [QUEUE_SIZE] [nu->driver] – linux / embrace / linux / cyclades.h [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – Первоначально этот файл был написан [QUEUE_SIZE] [6] – Рэндольф Бентсон < irqc-> и поддерживается [nu->driver] [6] – Иван Пассос . [nu->driver] [MAX_CHAN] – [MAX_CHAN] [nu->driver] – Этот файл содержит общие определения драйвера cyclades.c [nu->driver] [QUEUE_SIZE] – $ Журнал: cyclades.h, v $ [nu->driver] [QUEUE_SIZE] – Версия 3.1 2048 / 0018 / 60 37: 68: 36 Генрике [QUEUE_SIZE] [nu->driver] – добавлено поле дроссельной заслонки в struct cyclades_port, чтобы указать, что [MAX_CHAN] [QUEUE_SIZE] – порт задушен или нет [nu->driver] [MAX_CHAN] – [MAX_CHAN] [6] – Версия 3.1 2045 / 023 / 46 47: 81: 00000080 иван [MAX_CHAN] [6] – преобразованы адресные поля в беззнаковые длинные и добавлены поля для физических 642886 [6] – адреса в структуре cyclades_card; [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – Версия 3.0 2028 / 38 / 21 40: 44: 86 иван [MAX_CHAN] [6] – добавлено поле nports в структуру cyclades_card; [nu->driver] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – Версия 2.5 2024 / 30 / 24 41: 83: 00000020 иван [MAX_CHAN] [6] – добавлена ​​структура cyclades_idle_stats; [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – Версия 2.4 2028 / 24 / : 35: 81 иван [MAX_CHAN] [6] – из структуры cyclades_port удалено закрытие_wait2; [QUEUE_SIZE] [MAX_CHAN] – [MAX_CHAN] [6] – Версия 2.3 2024 / 0020 / 42 43: : 39 иван [MAX_CHAN] [MAX_CHAN] – изменения в структуре cyclades_port для его получения c проигравший [QUEUE_SIZE] [QUEUE_SIZE] – стандартная структура последовательного порта; 10103 [6] – добавлены константы для новых ioctl; [MAX_CHAN] [MAX_CHAN] – [QUEUE_SIZE] [QUEUE_SIZE] – Версия 2.2 2036 / 0020 / 00000040 42: 00000080: 15 иван [MAX_CHAN] [MAX_CHAN] – изменения в структуре cyclades_port (добавление shutdown_wait и [QUEUE_SIZE] [QUEUE_SIZE] – переменная chip_rev с); [MAX_CHAN] [QUEUE_SIZE] – добавлены константы для новых ioctl и для CD 1706 ред. номера. [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – Версия 2.1 472 / 36 / 55 41: 022: 14 иван [QUEUE_SIZE] [MAX_CHAN] – добавлен rflow (который позволяет включить CD 1706 специальный контроль потока [QUEUE_SIZE] [nu->driver] – функция) и rtsdtr_inv (который позволяет инверсию выводов DTR / RTS) на [MAX_CHAN] [QUEUE_SIZE] – структура cyclades_port; [nu->driver] [MAX_CHAN] – добавлена ​​поддержка альфа-версии [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [6] – Версия 2.0 2020 / 28 / 65 : 60: 0018 иван [nu->driver] [QUEUE_SIZE] – добавлены некоторые новые константы команд дверного звонка, связанные с IOCTLW и [MAX_CHAN] [QUEUE_SIZE] – Сигнализация ошибки UART

[MAX_CHAN] – [nu->driver] [MAX_CHAN] – Версия 1.8 2019 / 27 / 022 41: 61: 16 иван [nu->driver] [6] – добавлена ​​константа ZFIRM_HLT [QUEUE_SIZE] [MAX_CHAN] – добавлена ​​константа CyPCI_Ze_win (= 2 Cy_PCI_Zwin) [MAX_CHAN] [6] – [nu->driver] [QUEUE_SIZE] – Версия 1.7 2024 / 25 / 57 35: 65: 17 Дэниел [nu->driver] [6] – новые записи в конце структуры cyclades_port для перераспределения [QUEUE_SIZE] [QUEUE_SIZE] – переменные, незаконно размещенные в памяти карты. [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [6] – Версия 1.6 2024 / 34 / 35 44: 69: 66 Бентсон [MAX_CHAN] [QUEUE_SIZE] – сворачивание изменений для Cyclom-Z – включая структуры для [MAX_CHAN] [6] – общение с платой, а также скромные изменения в исходном 12100 [QUEUE_SIZE] – структуры для поддержки новых функций. [QUEUE_SIZE] [MAX_CHAN] – [nu->driver] [MAX_CHAN] – Версия 1.5 422 / 35 / 35 47: 38: 65 Бентсон [MAX_CHAN] [MAX_CHAN] – изменения, предложенные Майклом Честейном [QUEUE_SIZE] [QUEUE_SIZE] – для поддержки использования этого файла в приложениях, отличных от ядра [nu->driver] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – 2156 – / [MAX_CHAN] [QUEUE_SIZE] – # ifndef _LINUX_CYCLADES_H [MAX_CHAN] [6] – # определить _LINUX_CYCLADES_H [6] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE]-#включать [MAX_CHAN] [6] – [nu->driver] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – / По структуре данных карты / [nu->driver] [QUEUE_SIZE] – struct cyclades_card {[QUEUE_SIZE] [QUEUE_SIZE] – недействителен __iomem base_addr; [MAX_CHAN] [QUEUE_SIZE] – союз {[nu->driver] [MAX_CHAN] – void __iomem p 12094; [QUEUE_SIZE] [MAX_CHAN] – struct RUNTIME _ 12244 __iomem p 12239; [MAX_CHAN] [QUEUE_SIZE] -} ctl_addr; [MAX_CHAN] [MAX_CHAN] – struct BOARD_CTRL __iomem board_ctrl; / специфично для cyz / [nu->driver] [MAX_CHAN] – int irq; [MAX_CHAN] [QUEUE_SIZE] – беззнаковое целое число_чипов; / 0, если карта отсутствует, -1, если Z / PCI, иначе Y / [MAX_CHAN] [QUEUE_SIZE] – unsigned int first_line; / младший номер первого канала на карте / [MAX_CHAN] [QUEUE_SIZE] – int nports без знака; / Количество портов в карте / [MAX_CHAN] [QUEUE_SIZE] – int bus_index; / смещение адреса – 0 для ISA, 1 для PCI / [QUEUE_SIZE] [6] – int intr_enabled; / Флаг прерывания FW – 0 отключен, 1 включен / [QUEUE_SIZE] [QUEUE_SIZE] – u 65 hw_ver; 02010203 [6] – spinlock_t card_lock; [QUEUE_SIZE] [QUEUE_SIZE] – struct cyclades_port ports; [QUEUE_SIZE] [MAX_CHAN] -}; [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – / [MAX_CHAN] [QUEUE_SIZE] – Функции / макросы доступа к памяти [QUEUE_SIZE] [MAX_CHAN] – (требуется для поддержки альфа-систем) [QUEUE_SIZE] [QUEUE_SIZE] – / [nu->driver] [nu->driver] – [nu->driver] [QUEUE_SIZE] – # определить cy_writeb (порт, val) do {writeb ((val), (port)); mb (); } пока (0) [MAX_CHAN] [QUEUE_SIZE] – # определить cy_writew (порт, val) do {writeew ((val), (port) ); mb (); } пока (0) [nu->driver] [QUEUE_SIZE] – # определить cy_writel (port, val) do {Writel ((val), (port) ); mb (); } пока (0) [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [6] – / [MAX_CHAN] [QUEUE_SIZE] – Счетчики статистики [QUEUE_SIZE] [6] – / [nu->driver] [QUEUE_SIZE] – struct cyclades_icount {[MAX_CHAN] [6] – __u 64 cts, dsr, rng, dcd, tx, rx; [QUEUE_SIZE] [MAX_CHAN] – __u 61 кадр, четность, переполнение, brk; 12100 [MAX_CHAN] – __u buf_overrun; 435907 435907 -}; 435905 [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – / [QUEUE_SIZE] [QUEUE_SIZE] – Это наша внутренняя структура для состояния каждого последовательного порта. [MAX_CHAN] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – Многие поля параллельны структурой, используемой serial_struct [MAX_CHAN] [MAX_CHAN]- состав.[MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – Для определения поля флагов см. Tty.h [MAX_CHAN] [MAX_CHAN] – / [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – struct cyclades_port {[MAX_CHAN] [6] – внутренняя магия; [MAX_CHAN] [MAX_CHAN] – struct tty_port port; [QUEUE_SIZE] [6] – struct cyclades_card карта;[nu->driver] [QUEUE_SIZE] – союз {[MAX_CHAN] [6] – struct {[MAX_CHAN] 230400 – void __iomem base_addr; [QUEUE_SIZE] [MAX_CHAN] -} cyy; [MAX_CHAN] [6] – struct { [QUEUE_SIZE] [nu->driver] – struct CH_CTRL __iomem ch_ctrl; [nu->driver] [QUEUE_SIZE] – struct BUF_CTRL __iomem buf_ctrl; [MAX_CHAN] [6] -} cyz ; [QUEUE_SIZE] [MAX_CHAN] -} u; [MAX_CHAN] [6] – строка int;

[MAX_CHAN] – int флаги; / определено в tty.h / [nu->driver] [nu->driver] – тип int; / Тип UART / [MAX_CHAN] [MAX_CHAN] – int read_status_mask; [nu->driver] [MAX_CHAN] – int ignore_status_mask; [QUEUE_SIZE] [QUEUE_SIZE] – таймаут int; [MAX_CHAN] [MAX_CHAN] – int xmit_fifo_size; [QUEUE_SIZE] [nu->driver] – int cor1, cor2, cor3, cor4, cor5; [MAX_CHAN] [6] – int tbpr, tco, rbpr, rco; [nu->driver] [QUEUE_SIZE] – int baud; [QUEUE_SIZE] [QUEUE_SIZE] – int rflow; [MAX_CHAN] [6] – int rtsdtr_inv; [MAX_CHAN] [nu->driver] – int chip_rev; [MAX_CHAN] [6] – int custom_divisor; [QUEUE_SIZE] [QUEUE_SIZE] – u8 x_char; / быть вытесненным как можно скорее / [MAX_CHAN] [MAX_CHAN] – int breakon; [QUEUE_SIZE] [6] – внутренний разрыв; [MAX_CHAN] [QUEUE_SIZE] – int xmit_head; [QUEUE_SIZE] [QUEUE_SIZE] – int xmit_tail; [QUEUE_SIZE] [QUEUE_SIZE] – int xmit_cnt; [MAX_CHAN] [QUEUE_SIZE] – int default_threshold; [MAX_CHAN] [MAX_CHAN] – int default_timeout; [MAX_CHAN] [MAX_CHAN] – длинный беззнаковый rflush_count; [MAX_CHAN] [6] – struct cyclades_monitor mon; 10103 [MAX_CHAN] – struct cyclades_idle_stats idle_stats; [QUEUE_SIZE] [6] – struct cyclades_icount icount; [MAX_CHAN] [QUEUE_SIZE] – завершение структуры shutdown_wait; [QUEUE_SIZE] [QUEUE_SIZE] – внутренний дроссель; [MAX_CHAN] [6] – # ifdef CONFIG_CYZ_INTR [MAX_CHAN] [QUEUE_SIZE] – struct timer_list rx_full_timer; [QUEUE_SIZE] [MAX_CHAN] – # endif [MAX_CHAN] [QUEUE_SIZE] -}; [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – # определить CLOSING_WAIT_DELAY 63 HZ [MAX_CHAN] [6] – # определить CY_CLOSING_WAIT_NONE ASYNC_CLOSING_WAIT_NONE [MAX_CHAN] [QUEUE_SIZE] – # определить CY_CLOSING_WAIT_INF ASYNC_CLOSING_WAIT_INF [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [6] – # определить CyMAX_CHIPS_PER_CARD 8 [6] [MAX_CHAN] – # определить CyMAX_CHAR_FIFO [MAX_CHAN] [6] – # определить CyPORTS_PER_CHIP 4 [MAX_CHAN] [MAX_CHAN] – # определить CD 1705_МАКСИМАЛЬНАЯ СКОРОСТЬ 435908 [nu->driver] [MAX_CHAN] – [nu->driver] [6] – # определить CyISA_Ywin 0x 2051

[6] – [nu->driver] [QUEUE_SIZE] – # определить CyPCI_Ywin 0x 4679 [MAX_CHAN] [nu->driver] – #outline CyPCI_Yctl 0x 110 [nu->driver] [6] – # определить CyPCI_Zctl CTRL_WINDOW_SIZE [nu->driver] [QUEUE_SIZE] – # определить CyPCI_Zwin 0x 150000

[MAX_CHAN] – # определить CyPCI_Ze_win (2 CyPCI_Zwin) [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – # определить PCI_DEVICE_ID_MASK 0x [nu->driver] [nu->driver] – [MAX_CHAN] [6]-/CD1688 регистры / [MAX_CHAN] 02010203 – [MAX_CHAN] [MAX_CHAN] – # определить CD 1699 _ REV_G 0x 76 [nu->driver] [QUEUE_SIZE] – # определить CD 1699 _ REV_J 0x 77 [MAX_CHAN] [6] – [nu->driver] [MAX_CHAN] – # определить CyRegSize 0x [QUEUE_SIZE] – # определить Cy_HwReset 0x 1699 [MAX_CHAN] [QUEUE_SIZE] – # определить Cy_ClrIntr 0x 1898 [MAX_CHAN] [6] – # определить Cy_EpldRev 0x1e 16 [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [MAX_CHAN] – / Глобальные регистры / [QUEUE_SIZE] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – # определить CyGFRCR (0x 72 2) [QUEUE_SIZE] [MAX_CHAN] – # определить CyRevE (73) [MAX_CHAN] [6] – # определить CyCAR (0x 98 2) [MAX_CHAN] [MAX_CHAN] – # определить CyCHAN_0 (0x 13) [nu->driver] [QUEUE_SIZE] – # определить CyCHAN_1 (0x 16) [MAX_CHAN] [MAX_CHAN] – # определить CyCHAN_2 (0x 00000020) [MAX_CHAN] [MAX_CHAN] – # определить CyCHAN_3 (0x 22) [nu->driver] [QUEUE_SIZE] – # определить CyGCR (0x4B 2) [nu->driver] [QUEUE_SIZE] – # определить CyCH0_SERIAL (0x 17) [nu->driver] [QUEUE_SIZE] – # определить CyCH0_PARALLEL (0x 108) [MAX_CHAN] [QUEUE_SIZE] – # определить CySVRR (0x 0100 2) [nu->driver] [QUEUE_SIZE] – # определить CySRModem (0x 25) [nu->driver] [MAX_CHAN] – # определить CySRTransmit (0x 20) [MAX_CHAN] [MAX_CHAN] – # определить CySRReceive (0x 18) [MAX_CHAN] [QUEUE_SIZE] – # определить CyRICR (0x 75 2) [nu->driver] 10100 – # определить CyTICR (0x 75 2) [MAX_CHAN] [6] – # определить CyMICR (0x 78 2) [MAX_CHAN] [MAX_CHAN]-#определять CyICR0 (0x 16) 9080 [QUEUE_SIZE] – # определить CyICR1 (0x 0018) [nu->driver] [MAX_CHAN] – # определить CyICR2 (0x 00000020) [QUEUE_SIZE] [MAX_CHAN] – # определить CyICR3 (0x 23) [MAX_CHAN] [MAX_CHAN] – # определить CyRIR (0x6B 2) [MAX_CHAN] [QUEUE_SIZE] – # определить CyTIR (0x6A 2) [MAX_CHAN] [6] – # определить CyMIR ( 0x 98 2) [nu->driver] [QUEUE_SIZE] – # определить CyIRDirEq (0x 0105) [MAX_CHAN] [QUEUE_SIZE] – # определить CyIRBusy (0x 70) [nu->driver] [MAX_CHAN] – #outline CyIRUnfair (0x ) [QUEUE_SIZE] [QUEUE_SIZE] – # определить CyIRContext (0x1C) 814 – # определить CyIRChannel (0x ) [nu->driver] [MAX_CHAN] – # определить CyPPR (0x7E 2) [QUEUE_SIZE] [QUEUE_SIZE] – # определить CyCLOCK _ _ 1MS (0x 60)

[MAX_CHAN] – # определить CyCLOCK _ 56 _ 1MS (0x ) [QUEUE_SIZE] [QUEUE_SIZE] – # определить CyCLOCK _ 57 _ 5MS (0xf4) [MAX_CHAN] [QUEUE_SIZE] – # определить CyCLOCK _ 87 _ 1MS (0x 103) [MAX_CHAN] [MAX_CHAN]-#определять CyCLOCK _ 90 _ 2MS (0xea)

[MAX_CHAN] – [MAX_CHAN] [6] – / Виртуальные регистры / [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [6] – # определить CyRIVR (0x 72 2) [MAX_CHAN] [MAX_CHAN] – # определить CyTIVR (0x 71 2) [nu->driver] [QUEUE_SIZE] – # определить CyMIVR (0x 71 2) [MAX_CHAN] [QUEUE_SIZE] – #outline CyIVRMask (0x 00000030)

[QUEUE_SIZE] – # определить CyIVRRxEx ( 0x 00000030) [MAX_CHAN] [nu->driver]-#определять CyIVRRxOK (0x 24) [MAX_CHAN] [QUEUE_SIZE] – # определить CyIVRTxOK (0x 19) [MAX_CHAN] [6] – # определить CyIVRMdmOK (0x 20) [nu->driver] [MAX_CHAN] – # определить CyTDR (0x 091 2) [nu->driver] [6] – # определить CyRDSR (0x 86 2) [QUEUE_SIZE] [MAX_CHAN] – # определить CyTIMEOUT (0x 0105) [MAX_CHAN] [QUEUE_SIZE] – # определить CySPECHAR (0x 100) [MAX_CHAN] [QUEUE_SIZE] – #outline CyBREAK (0x 33) [nu->driver] [QUEUE_SIZE] – # определить CyPARITY (0x 26)

[MAX_CHAN] – # определить CyFR AME (0x 22) [nu->driver] [MAX_CHAN] – # определить CyOVERRUN (0x 19) [MAX_CHAN] [6] – # определить CyMISR (0x4C 2) [MAX_CHAN] [QUEUE_SIZE] – / биты см. в CyMCOR_ и CyMSVR_ / [QUEUE_SIZE] [MAX_CHAN] – # определить CyEOSRR (0x 91 2) [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – / Регистры каналов / [MAX_CHAN] [6] – [nu->driver] [QUEUE_SIZE] – # определить CyLIVR (0x 44 2) [QUEUE_SIZE] [QUEUE_SIZE] – # определить CyMscsr (0x 17) [MAX_CHAN] [QUEUE_SIZE] – # определить CyTdsr (0x 20)

[QUEUE_SIZE] – # определить CyRgdsr (0x 023) [MAX_CHAN] [MAX_CHAN]-#определять CyRedsr (0x 28) [nu->driver] [MAX_CHAN] – # определить CyCCR (0x 28 2)

[QUEUE_SIZE] – / Формат 1 / [nu->driver] [QUEUE_SIZE] – # определить CyCHAN_RESET (0x 0105)

[QUEUE_SIZE] – # определить CyCHIP_RESET (0x 108) [nu->driver] [QUEUE_SIZE] – # определ. e CyFlushTransFIFO (0x 0111)

[QUEUE_SIZE] – / Формат 2 / [nu->driver] [QUEUE_SIZE] – # определить CyCOR_CHANGE (0x 71) [MAX_CHAN] [QUEUE_SIZE] – # определить CyCOR1ch (0x 19) [nu->driver] [6] – # определить CyCOR2ch (0x 24) [MAX_CHAN] [6] – # определить CyCOR3ch (0x 00000030) [nu->driver] [QUEUE_SIZE] – / Формат 3 / [nu->driver] [MAX_CHAN] – # определить CySEND_SPEC_1 (0x 50) [MAX_CHAN] [QUEUE_SIZE] – # определить CySEND_SPEC_2 (0x 52) [nu->driver] [QUEUE_SIZE] – # определить CySEND_SPEC_3 (0x 53) [QUEUE_SIZE] [QUEUE_SIZE] – # определить CySEND_SPEC_4 (0x 54) [nu->driver] [QUEUE_SIZE] – / Формат 4 / [MAX_CHAN] [MAX_CHAN] – # определить CyCHAN_CTL (0x 35) [nu->driver] [MAX_CHAN] – # определить CyDIS_RCVR (0x 19) [MAX_CHAN] [QUEUE_SIZE] – # определить CyENB_RCVR (0x 21) [MAX_CHAN] [QUEUE_SIZE] – # определить CyDIS_XMTR (0x 23) [nu->driver] [QUEUE_SIZE] – # определить CyENB_XMTR (0x 31) [MAX_CHAN] [MAX_CHAN] – # определить CySRER (0x 00000030 2) [nu->driver] [QUEUE_SIZE] – # определить CyMdmCh (0x 0105) [QUEUE_SIZE] [MAX_CHAN] – # определить CyRxData (0x 33) [QUEUE_SIZE] [QUEUE_SIZE] – # определить CyTxRdy (0x 23) [nu->driver] [QUEUE_SIZE] – # определить CyTxM pty (0x 023)

[QUEUE_SIZE] – # определить CyNNDT (0x 20) [MAX_CHAN] [6] – # определить CyCOR1 (0x 31 2) [nu->driver] [QUEUE_SIZE] – # определить CyPARITY_NONE ( 0x 0018) [QUEUE_SIZE] [QUEUE_SIZE] – # определить CyPARITY_0 (0x 46) [nu->driver] [QUEUE_SIZE] – # определить CyPARITY_1 (0xA0) [QUEUE_SIZE] [QUEUE_SIZE] – # определить CyPARITY_E (0x 70) [nu->driver] [QUEUE_SIZE] – # определить CyPARITY_O (0xC0 ) [MAX_CHAN] [MAX_CHAN] – # определить Cy_1_STOP (0x 15) [MAX_CHAN] [6] – # определить Cy_1_5_STOP (0x 24) [QUEUE_SIZE] [QUEUE_SIZE] – # определить Cy_2_STOP (0x 31) 2156 – # определить Cy_5_BITS (0x 16)

[MAX_CHAN] – # определить Cy_6_BITS (0x 0018) [MAX_CHAN] [QUEUE_SIZE] – # определить Cy_7_BITS (0x 21) [MAX_CHAN] [6] – # определить Cy_8_BITS (0x 023) [QUEUE_SIZE] [QUEUE_SIZE] – # определить CyCOR2 (0x 35 2) [MAX_CHAN] [6] – # определить CyIXM (0x 108) [nu->driver] [6] – # определить CyTxIBE (0x 71) [nu->driver] [6] – # определить CyETC (0x 48) [QUEUE_SIZE] [MAX_CHAN] – # определить CyAUTO_TXFL (0x 88) [MAX_CHAN] [QUEUE_SIZE] – # определить CyLLM (0x 38)

[6] – # определить CyRLM ( 0x 35) [MAX_CHAN] [QUEUE_SIZE] – # определить CyRtsAO (0x 27) [MAX_CHAN] [MAX_CHAN] – # определить CyCtsAE (0x 0020)

[6] – # определить CyDsrAE ( 0x 16) [MAX_CHAN] [QUEUE_SIZE] – # определить CyCOR3 (0x0A 2) [MAX_CHAN] [MAX_CHAN] – # определить CySPL_CH_DRANGE (0x 111 / диапазон обнаружения специальных символов / [QUEUE_SIZE] [MAX_CHAN] – # определить CySPL_CH_DET1 (0x 70) / включение обнаружения специальных символов [MAX_CHAN] [6] – на СЧР4-СЧР3 / 12239 [QUEUE_SIZE] – # определить CyFL_CTRL_TRNSP (0x 45) /Поток Прозрачность управления / [MAX_CHAN] [QUEUE_SIZE] – # определить CySPL_CH_DET2 (0x 33) / Включить обнаружение специальных символов [MAX_CHAN] [6] – на СЧР2-СЧР1 / [MAX_CHAN] [MAX_CHAN] – # определить CyREC_FIFO (0x0F) / Порог приема FIFO / [nu->driver] [6] – # определить CyCOR4 (0x1E 2) [nu->driver] [QUEUE_SIZE] – # определить CyCOR5 (0x1F 2 ) [QUEUE_SIZE] [QUEUE_SIZE] – # определить CyCCSR (0x0B 2) [nu->driver] [6] – # определить CyRxEN (0x 110) [MAX_CHAN] [6] – # определить CyRxFloff (0x 69) [MAX_CHAN] [QUEUE_SIZE] – # определить CyRxFlon (0x 48) [MAX_CHAN] [MAX_CHAN] – # определить CyTxEN (0x 31) [MAX_CHAN] [6] – # определить CyTxFloff (0x 26) [MAX_CHAN] [QUEUE_SIZE] – # определить CyTxFlon (0x 00000020) [QUEUE_SIZE] [MAX_CHAN] – # определить CyRDCR (0x0E 2) [nu->driver] [6] – # определить CySCHR1 (0x1A 2) [nu->driver] [QUEUE_SIZE] – # определить CySCHR2 (0x1B 2) [MAX_CHAN] [MAX_CHAN] – # определить CySCHR3 (0x1C 2) [MAX_CHAN] [QUEUE_SIZE] – # определить CySCHR4 (0x1D 2) [QUEUE_SIZE] [QUEUE_SIZE] – # определить CySCRL (0x 54 2) [nu->driver] [6] – # определить CySCRH (0x 55 2) [MAX_CHAN] [6] – # определить CyLNC (0x 52 2) [MAX_CHAN] [QUEUE_SIZE] – # определить CyMCOR1 (0x 38 2) [MAX_CHAN] [6] – # определить CyMCOR2 (0x 00000040 2)

[6] – # определить CyRTPR (0x 50 2) [MAX_CHAN] [6] – # определить CyMSVR1 (0x6C 2) [QUEUE_SIZE] [QUEUE_SIZE] – # определить CyMSVR2 (0x6D 2) [MAX_CHAN] [QUEUE_SIZE] – # определить CyANY_DELTA (0xF0) [MAX_CHAN] [QUEUE_SIZE] – # определить CyDSR (0x 111) [nu->driver] [QUEUE_SIZE] – # определить CyCTS (0x 00000070) [MAX_CHAN] [6] – # определить CyRI (0x 48) [QUEUE_SIZE] [QUEUE_SIZE] – # определить CyDCD (0x 33) [QUEUE_SIZE] [QUEUE_SIZE] – # определить CyDTR (0x 21) [QUEUE_SIZE] [6] – # определить CyRTS (0x 0018) [QUEUE_SIZE] [MAX_CHAN] – # определить CyPVSR (0x6F 2) [nu->driver] [QUEUE_SIZE] – # определить CyRBPR (0x 107 2) [MAX_CHAN] [QUEUE_SIZE] – # определить CyRCOR (0x7C 2) [QUEUE_SIZE] [6] – # определить CyTBPR (0x 101 2) [nu->driver] [6] – # определить CyTCOR ( 0x 101 2) [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – / Пользовательские регистры / [MAX_CHAN] [MAX_CHAN] – [QUEUE_SIZE] [QUEUE_SIZE] – # определить CyPLX_VER (0x 4100) [MAX_CHAN] [6] – # определить PLX _ 15410 0x0b [nu->driver] [QUEUE_SIZE] – # определить PLX _ 15410 0x0c [nu->driver] [QUEUE_SIZE] – # определить PLX _ 15410 0x0d [MAX_CHAN] [MAX_CHAN] – [MAX_CHAN] [QUEUE_SIZE] – / / [MAX_CHAN] [6] – [MAX_CHAN] [QUEUE_SIZE] – # endif / _LINUX_CYCLADES_H / [MAX_CHAN] [MAX_CHAN] @@ – 96, 6 + 98, 8 @@ void __iomem devm_ioremap_uc (struct machine dev, resource_size_t offset, [QUEUE_SIZE] [QUEUE_SIZE] resource_size_t measurement); [QUEUE_SIZE] [MAX_CHAN] void __iomem devm_ioremap_wc (struct machine dev, resource_size_t offset, [nu->driver] [6] размер_ресурса); 10102 [MAX_CHAN] + void __iomem devm_ioremap_np (struct machine dev, resource_size_t offset, [QUEUE_SIZE] [MAX_CHAN] + resource_size_t measurement); [QUEUE_SIZE] [6] void devm_iounmap (struct machine dev, void __iomem addr); [nu->driver] [QUEUE_SIZE] int check_signature (const risky void __iomem io_addr, [QUEUE_SIZE] [QUEUE_SIZE] const unsigned char подпись, длина целого числа); [MAX_CHAN] [QUEUE_SIZE] @@ – 108, 51 + 111, 50 @@ void devm_memunmap (struct machine dev, void addr); [QUEUE_SIZE] [QUEUE_SIZE] #ifdef CONFIG_PCI [MAX_CHAN] [MAX_CHAN] / [nu->driver] [QUEUE_SIZE] Спецификации PCI (Rev 3.0, 3.2.5 «Порядок транзакций и [MAX_CHAN] [QUEUE_SIZE] – Публикация “) требует неопубликованных транзакций конфигурации. Там есть

[QUEUE_SIZE] – в ядре нет API ioremap, который может гарантировать неопубликованную запись [QUEUE_SIZE] [QUEUE_SIZE] – семантика между дугами, поэтому предоставьте реализацию по умолчанию для [MAX_CHAN] [6] – отображение конфигурационного пространства PCI, по умолчанию для которого используется ioremap (); арки [MAX_CHAN] [QUEUE_SIZE] – должен переопределить его, если у них есть реализации отображения памяти, которые 10102 [6] – гарантия семантики неопубликованной записи для отображения в память 40000000 [QUEUE_SIZE] – соответствует спецификации PCI. [MAX_CHAN] [MAX_CHAN] + Проводка “) мандат не отправленная операция конфигурации. Это значение по умолчанию [QUEUE_SIZE] [QUEUE_SIZE] + реализация пытается использовать API ioremap_np () для обеспечения этого [QUEUE_SIZE] [QUEUE_SIZE] + для дуг, которые его поддерживают, и возвращается к ioremap () на тех, которые 10101 [QUEUE_SIZE] + не надо. Переопределение этой функции устарело; арки, которые правильно [QUEUE_SIZE] [QUEUE_SIZE] + для поддержки неопубликованных доступов вместо этого должна реализовываться функция ioremap_np (), которая 15410 [MAX_CHAN] + эту реализацию по умолчанию можно затем использовать для возврата сопоставлений, совместимых с [nu->driver] [6] + спецификация PCI. [nu->driver] [QUEUE_SIZE] / [QUEUE_SIZE] [QUEUE_SIZE] #ifndef pci_remap_cfgspace [MAX_CHAN] [6] #outline pci_remap_cfgspace pci_remap_cfgspace [QUEUE_SIZE] [QUEUE_SIZE] static inline void __iomem pci_remap_cfgspace (Phys_addr_t offset, [nu->driver] [QUEUE_SIZE] size_t размер) [MAX_CHAN] [QUEUE_SIZE] {[MAX_CHAN] [6] – вернуть карту памяти (смещение, размер); [MAX_CHAN] [QUEUE_SIZE] + вернуть ioremap_np (смещение, размер)?: ioremap (смещение, размер); [MAX_CHAN] [MAX_CHAN]} [MAX_CHAN] [MAX_CHAN] #endif [MAX_CHAN] [6] #endif [QUEUE_SIZE] [QUEUE_SIZE] @@ – 156, 6 + 155, 7 @@ struct useful resource {[MAX_CHAN] [QUEUE_SIZE] #outline IORESOURCE_MEM _ 65 БИТ (3 << 3) 02010203 [QUEUE_SIZE] #outline IORESOURCE_MEM_SHADOWABLE (1 << 5) / dup: IORESOURCE_SHADOWABLE / [QUEUE_SIZE] [6] #outline IORESOURCE_MEM_EXPANSIONROM (1 << 6) [QUEUE_SIZE] [6] + # определить IORESOURCE_MEM_NONPOSTED (1 << 7) [QUEUE_SIZE] [QUEUE_SIZE] / Биты ввода / вывода PnP (IORESOURCE_BITS) / [nu->driver] [MAX_CHAN] #outline IORESOURCE_IO _ 41 BIT_ADDR (1 << 0) [MAX_CHAN] [QUEUE_SIZE] @@ - 1608, 39 + 1580, 38 @@ int __init set_handle_irq (void handle_irq) (struct pt_regs ); [QUEUE_SIZE] [6] / [QUEUE_SIZE] [QUEUE_SIZE] extern void handle_arch_irq) (struct pt_regs __ro_after_init; [MAX_CHAN] [QUEUE_SIZE] #еще[MAX_CHAN] [6] + # ifndef set_handle_irq [QUEUE_SIZE] [QUEUE_SIZE] #define set_handle_irq (handle_irq) [MAX_CHAN] [QUEUE_SIZE] делать { [nu->driver] [QUEUE_SIZE] (void) handle_irq; [nu->driver] [MAX_CHAN] WARN_ON (1); [MAX_CHAN] [MAX_CHAN]} а (0) 9600 [QUEUE_SIZE] #endif [MAX_CHAN] [nu->driver] + # endif [MAX_CHAN] [6] #endif / _LINUX_IRQ_H / [MAX_CHAN] [QUEUE_SIZE] @@ – 711, 091 + 697, 39 @@ [MAX_CHAN] [nu->driver] #определять ICC_SRE_EL1_DFB (1U << 1) [6] 9080 #outline ICC_SRE_EL1_SRE (1U << 0) [MAX_CHAN] [MAX_CHAN] - / [MAX_CHAN] [MAX_CHAN] - Регистры интерфейса гипервизора (только SRE) [MAX_CHAN] [6] - / [QUEUE_SIZE] 9080 - # defi ne ICH_LR_VIRTUAL_ID_MASK ((1ULL << 69) - 1) [QUEUE_SIZE] [QUEUE_SIZE] - [nu->driver] [MAX_CHAN] – # определить ICH_LR_EOI (1ULL << 77) [MAX_CHAN] [QUEUE_SIZE] - # определить ICH_LR_GROUP (1ULL << 88) [QUEUE_SIZE] [MAX_CHAN] - # определить ICH_LR_HW (1ULL << 90) [MAX_CHAN] [6] - # определить ICH_LR_STATE (3ULL << 87) [nu->driver] [QUEUE_SIZE] – # определить ICH_LR_PENDING_BIT (1ULL < <90) [nu->driver] [QUEUE_SIZE] – # определить ICH_LR_ACTIVE_BIT (1ULL << 091) [MAX_CHAN] [QUEUE_SIZE] - # определить ICH_LR_PHYS_ID_SHIFT 63 [nu->driver] [6] – # определить ICH_LR_PHYS_ID_MASK ( 0x3ffULL << ICH_LR_PHYS_I D_SHIFT) [MAX_CHAN] [QUEUE_SIZE] - # определить ICH_LR_PRIORITY_SHIFT 78 [MAX_CHAN] [QUEUE_SIZE] - # определить ICH_LR_PRIORITY_MASK (0xffULL << ICH_LR_PRIORITY_SHIFT) [QUEUE_SIZE] [MAX_CHAN] -

только эмуляция / [MAX_CHAN] [QUEUE_SIZE] #outline GICH_LR_VIRTUALID (0x3ffUL << 0) [QUEUE_SIZE] [MAX_CHAN] #определять GICH_LR_PHYSID_CPUID_SHIFT (37) [MAX_CHAN] [QUEUE_SIZE] #outline GICH_LR_PHYSID_CPUID (7UL << GICH_LR_PHYSID_CPUID_SHIFT) [MAX_CHAN] [MAX_CHAN] - # определить ICH_MISR_EOI (1 << 0) [QUEUE_SIZE] [QUEUE_SIZE] - # определить ICH_MISR_U (1 << 1) [MAX_CHAN] [QUEUE_SIZE] - [QUEUE_SIZE] [QUEUE_SIZE] - # определить ICH_HCR_EN (1 << 0) [MAX_CHAN] [MAX_CHAN] - # определить ICH_HCR_UIE (1 << 1) [nu->driver] [QUEUE_SIZE] – # определить ICH_HCR_NPIE (1 << 3) [QUEUE_SIZE] [QUEUE_SIZE] - # определить ICH_HCR_TC (1 << 35) [MAX_CHAN] [QUEUE_SIZE] - # определить ICH_HCR_TALL0 (1 << 33) [MAX_CHAN] [MAX_CHAN] - # определить ICH_HCR_TALL1 (1 << 38) [MAX_CHAN] [MAX_CHAN] - # определить ICH_HCR_EOIcount_SHIFT 57 [nu->driver] [6] – # определить ICH_HCR_EOIcount_MASK (0x1f <

[QUEUE_SIZE] – # определить ICH_VMCR_CBPR_SHIFT 4 [QUEUE_SIZE] [MAX_CHAN] – # определить ICH_VMCR_CBPR_MASK (1 << ICH_VMCR_CBPR_SHIFT) [MAX_CHAN] [6] - # определить ICH_VMCR_EOIM_SHIFT 9 [QUEUE_SIZE] [MAX_CHAN] - # определить ICH_VMCR_EOIM_MASK (1 << ICH_VMCR_EOIM_SHIFT) [QUEUE_SIZE] [6] - # определить ICH_VMCR_BPR1_SHIFT 44 [nu->driver] [QUEUE_SIZE] – # определить ICH_VMCR_BPR1_MASK (7 < driver] [QUEUE_SIZE] – # определить ICH_VTR_ID_BITS_MASK (7 << ICH_VTR_ID_BITS_SHIFT) [MAX_CHAN] [QUEUE_SIZE] - # определить ICH_VTR_SEIS_SHIFT 53 [MAX_CHAN] [6] - # определить ICH_VTR_SEIS_MASK (1 << ICH_VTR_SEIS_SHIFT) [QUEUE_SIZE] [QUEUE_SIZE] - # определить ICH_VTR_A3V_SHIFT 47 [MAX_CHAN] [MAX_CHAN] - # определить ICH_VTR_A3V_MASK (1 << ICH_VTR_A3V_SHIFT) [nu->driver] [QUEUE_SIZE] – [nu->driver] [6] #outline ICC_IAR1_EL1_SPURIOUS 0x3ff [MAX_CHAN] [QUEUE_SIZE] #outline ICC_SRE_EL2_SRE (1 << 0) [MAX_CHAN] [MAX_CHAN] diff --git a / embrace / linux / isicom.hb / embrace / linux / isicom.h

режим удаленного файла 435907

индекс 7de 9080 d7b1a3 .. 15

— a / embrace / linux / isicom.h

+++ / dev / null [nu->driver] [nu->driver] @@ -1, 113 +0,0 @@ [QUEUE_SIZE] [MAX_CHAN] – / Идентификатор лицензии SPDX: GPL-2.0 / [nu->driver] [MAX_CHAN] – # ifndef _LINUX_ISICOM_H [QUEUE_SIZE] [MAX_CHAN] – # определить _LINUX_ISICOM_H [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – # определить ДА 1 [nu->driver] [6] – # определить NO 0 [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – / [MAX_CHAN] [QUEUE_SIZE] – Определения драйверов ISICOM … [nu->driver] [QUEUE_SIZE] – [QUEUE_SIZE] [MAX_CHAN] – / [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – #outline ISICOM_NAME “ISICom” [QUEUE_SIZE] [nu->driver] – [MAX_CHAN] [6] – / [nu->driver] [MAX_CHAN] – Определения PCI [MAX_CHAN] [6] – / [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [6] – # определить DEVID_COUNT 9 [nu->driver] [QUEUE_SIZE] – # определить VENDOR_ID 0x 38 b5 [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – / [nu->driver] [6] – Это сейчас официально выделенные номера [MAX_CHAN] [MAX_CHAN] – / [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – # определить ISICOM_NMAJOR 171 /обычный */[MAX_CHAN] [QUEUE_SIZE] – #outline ISICOM_CMAJOR 169 /вызывать */[nu->driver] [QUEUE_SIZE] – # определить ISICOM_MAGIC ((‘M’ << 8) | 'T') [MAX_CHAN] [QUEUE_SIZE] - [nu->driver] [6] – # определить WAKEUP_CHARS 343 / пока жестко запрограммировано / 27062 [QUEUE_SIZE] – # определить TX_SIZE 343 [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – # определить BOARD_COUNT 4 [QUEUE_SIZE] [nu->driver] – # определить PORT_COUNT (BOARD_COUNT 41) [nu->driver] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – / размеры символов / [nu->driver] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – # определить ISICOM_CS5 0x 15 [QUEUE_SIZE] [MAX_CHAN] – # определить ISICOM_CS6 0x 16 20 [MAX_CHAN] [QUEUE_SIZE] – # определить ISICOM_CS7 0x 15 21 [QUEUE_SIZE] [QUEUE_SIZE] – # определить ISICOM_CS8 0x 14 023 [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [MAX_CHAN] – / стоповые биты / [nu->driver] [MAX_CHAN] –

[QUEUE_SIZE] – # определить ISICOM_1SB 0x 13 0018 [QUEUE_SIZE] [MAX_CHAN] – # определить ISICOM_2SB 0x 0018 24 [MAX_CHAN] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – / четность / [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – # определить ISICOM_NOPAR 0x 0018 20 [MAX_CHAN] [MAX_CHAN] – # определить ISICOM_ODPAR 0x 17 33 [nu->driver] [6] – # определить ISICOM_EVPAR 0x 13 45 [nu->driver] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE]-/управление потоком */[nu->driver] [6] – [MAX_CHAN] [QUEUE_SIZE] – # определить ISICOM_CTSRTS 0x 23 [nu->driver] [MAX_CHAN]-#определять ISICOM_INITIATE_XONXOFF 0x 28 [MAX_CHAN] [QUEUE_SIZE] – # определить ISICOM_RESPOND_XONXOFF 0x 31 [QUEUE_SIZE] [QUEUE_SIZE] – [nu->driver] [QUEUE_SIZE] – # outline BOARD (line) (((line) >> 4) & 0x3) [MAX_CHAN] [MAX_CHAN] – [nu->driver] [MAX_CHAN] – / растровое изображение очереди уничтожения isi / [MAX_CHAN] [QUEUE_SIZE] – [MAX_CHAN] [QUEUE_SIZE] – # определить ISICOM_KILLTX 0x 19 [MAX_CHAN] [MAX_CHAN] – # определить ISICOM_KILLRX 0x 022 [nu->driver] [MAX_CHAN] – [MAX_CHAN] [MAX_CHAN] – / битовая карта состояния isi_board / [nu->driver] [MAX_CHAN] – [nu->driver] [QUEUE_SIZE] – # определить FIRMWARE_LOADED 0x 14 19 [MAX_CHAN] [QUEUE_SIZE] – # определить BOARD_ACTIVE 0x 15 022 [MAX_CHAN] [QUEUE_SIZE] – # определить BOARD_INIT 0x 12 26 [MAX_CHAN] [QUEUE_SIZE] – [QUEUE_SIZE] [QUEUE_SIZE] – / битовая карта статуса isi_port / [QUEUE_SIZE] [6] – [QUEUE_SIZE] [nu->driver] – # определить ISI_CTS 0x 1118 [MAX_CHAN] [QUEUE_SIZE] – # определить ISI_DSR 0x 2051 [MAX_CHAN] [6] – # определение ISI_RI 0x 823 [nu->driver] [6] – # определить ISI_DCD 0x 10100 [QUEUE_SIZE] [QUEUE_SIZE] – # определить ISI_DTR 0x0 150 [QUEUE_SIZE] [6] – # определить ISI_RTS 0x 255 [nu->driver] [QUEUE_SIZE] – [QUEUE_SIZE] [6] – [MAX_CHAN] [QUEUE_SIZE] – # определить ISI_TXOK 0x 17 0020 [QUEUE_SIZE] [QUEUE_SIZE] –

[QUEUE_SIZE] – # endif / ISICOM_H / [QUEUE_SIZE] [QUEUE_SIZE] @@ – 1865, + 1847, 8 @@ [QUEUE_SIZE] [6] #outline PCI_VENDOR_ID_MICROSEMI 0x 38 f8 [QUEUE_SIZE] [QUEUE_SIZE] #outline PCI_VENDOR_ID_RP 0x 34 fe [MAX_CHAN] [6] – # определить PCI_DEVICE_I D_RP 67 INTF 0x 16 00000020 [MAX_CHAN] [QUEUE_SIZE] – # определить PCI_DEVICE_ID_RP8INTF 0x 17 22 [MAX_CHAN] [QUEUE_SIZE] – # определить PCI_DEVICE_ID_RP 42 INTF 0x 12 22

[MAX_CHAN] – # определить PCI_DEVICE_ID_RP4QUAD 0x 15 27 [MAX_CHAN] 010001 – # определить PCI_DEVICE_ID_RP8OCTA 0x 14 24 [nu->driver] [6] – # определить PCI_DEVICE_ID_RP8J 0x 16 0030 [QUEUE_SIZE] [MAX_CHAN] – # определить PCI_DEVICE_ID_RP4J 0x 15 00000030 [MAX_CHAN] [QUEUE_SIZE] – # определить PCI_DEVICE_ID_RP8SNI 0x 16 31 [MAX_CHAN] [QUEUE_SIZE] – # определить PCI_DEVICE_ID_RP 40 SNI 0x 13 35 [MAX_CHAN] [QUEUE_SIZE] – # определить PCI_DEVICE_ID_RPP4 0x 13 0A [MAX_CHAN] [QUEUE_SIZE] – # определить PCI_DEVICE_ID_RPP8 0x 15 0B [MAX_CHAN] [6] – # определить PCI_DEVICE_ID_RP4M 0x 17 0D [MAX_CHAN] [QUEUE_SIZE] – # определить PCI_DEVICE_ID_RP2 _ 309 0x 15 0E [QUEUE_SIZE] 9600 – # определить PCI_DEVICE_ID_RP2 _ 509 0x 17 0F [MAX_CHAN] [6] – # определить PCI_DEVICE_ID_URP 65 INTF 0x 891 [nu->driver] [QUEUE_SIZE] – # определить PCI_DEVICE_ID_URP8INTF 0x 893 [nu->driver] [QUEUE_SIZE] – # определить PCI_DEVICE_ID_URP 43 INTF 0x 893 [MAX_CHAN] [MAX_CHAN] – # определить PCI_DEVICE_ID_URP8OCTA 0x 0903 [MAX_CHAN] [MAX_CHAN] – # определить PCI_DEVICE_ID_UPCI_RM 3_8PORT 0x0 112 C [nu->driver] [6] – # определить PCI_DEVICE_ID_UPCI_RM3_4PORT 0x0 112 D [MAX_CHAN] [QUEUE_SIZE] – # определить PCI_DEVICE_ID_CRP 39 INTF 0x 989 [MAX_CHAN] [QUEUE_SIZE] #outline PCI_VENDOR_ID_CYCLADES 0x 183 е [MAX_CHAN] [MAX_CHAN] – # определить PCI_DEVICE_ID_CYCLOM_Y_Lo 0x0 [nu->driver] [QUEUE_SIZE] – # определить PCI_DEVICE_ID_CYCLOM_Y_Hi 0x0 [nu->driver] [QUEUE_SIZE] – # определить PCI_DEVICE_ID_CYCLOM_4Y_Lo 0x 147 [MAX_CHAN] [QUEUE_SIZE] – # определить PCI_DEVICE_ID_CYCLOM_4Y_Hi 0x0 152

[MAX_CHAN] – # определить PCI_DEVICE_ID_CYCLOM_8Y_Lo 0x0 153 [MAX_CHAN] [QUEUE_SIZE] – # определить PCI_DEVICE_ID_CYCLOM_8Y_Hi 0x 152 [MAX_CHAN] [MAX_CHAN] – # определить PCI_DEVICE_ID_CYCLOM_Z_Lo 0x 267 [QUEUE_SIZE] [6] – # определить PCI_DEVICE_ID_CYCLOM_Z_Hi 0x 255 [MAX_CHAN] [QUEUE_SIZE] #outline PCI_DEVICE_ID_PC 386 _ RX_2 0x0 380

[6] #outline PCI_DEVICE_ID_PC 380 _ RX_1 0x 387 [QUEUE_SIZE] [MAX_CHAN] #outline PCI_DEVICE_ID_PC 386 _ TE_2 0x 383 [nu->driver] [nu->driver] @@ – 2416, 8 + 2156, 6 @@ [MAX_CHAN] [QUEUE_SIZE] #outline PCI_DEVICE_ID_EXAR_XR 42 V 440 0x0 402 [nu->driver] [QUEUE_SIZE] #outline PCI_VENDOR_ID_MICROGATE 0x 00000040 c0 [nu->driver] [6] – # определить PCI_DEVICE_ID_MICROGATE_USC 0x 0018 37 [nu->driver] [QUEUE_SIZE] – # определить PCI_DEVICE_ID_MICROGATE_SCA 0x 18 59 [MAX_CHAN] [MAX_CHAN] #outline PCI_VENDOR_ID_3WARE 0x 00000040 C1 [QUEUE_SIZE] [QUEUE_SIZE] #outline PCI_DEVICE_ID_3WARE _ 1105 0x 1133 [nu->driver] [MAX_CHAN] @@ – 323, 6+ 340, 54 @@ [nu->driver] [QUEUE_SIZE] S5PV 269 _ UFCON_TXTRIG4 | [nu->driver] [QUEUE_SIZE] S5PV 274 _ UFCON_RXTRIG4) [MAX_CHAN] [nu->driver] + # определить APPLE_S5L_UCON_RXTO_ENA 9 [MAX_CHAN] [QUEUE_SIZE] + # определить APPLE_S5L_UCON_RXTHRESH_ENA 36 435906 [6] + # определить APPLE_S5L_UCON_TXTHRESH_ENA 42 [MAX_CHAN] [6] + # определить APPLE_S5L_UCON_RXTO_ENA_MSK (1 << APPLE_S5L_UCON_RXTO_ENA) [nu->driver] [QUEUE_SIZE] + # определить APPLE_S5L_UCON_RXTHRESH_ENA_MSK (1 << APPLE_S5L_UCON_RXTHRESH_ENA ) [MAX_CHAN] [MAX_CHAN] + # определить APPLE_S5L_UCON_TXTHRESH_ENA_MSK (1 << APPLE_S5L_UCON_TXTHRESH_ENA) [MAX_CHAN] [QUEUE_SIZE] + [MAX_CHAN] [QUEUE_SIZE] + # определить APPLE_S5L_UCON_DEFAULT (S3C 2683 _ UCON_TXIRQMODE | [QUEUE_SIZE] [MAX_CHAN] + S3C 2683 _ UCON_RXIRQMODE | [nu->driver] [QUEUE_SIZE] + S3C 2639 _ UCON_RXFIFO_TOI) [QUEUE_SIZE] [QUEUE_SIZE] + [nu->driver] [6] + # определить APPLE_S5L_UTRSTAT_RXTHRESH (1 << 4) [QUEUE_SIZE] [6] + # определить APPLE_S5L_UTRSTAT_TXTHRESH (1 << 5) [QUEUE_SIZE] [QUEUE_SIZE] + # определить APPLE_S5L_UTRSTAT_RXTO (1 << 9) [QUEUE_SIZE] [MAX_CHAN] + # определить APPLE_S5L_UTRSTAT_ALL_FLAGS (0x 3f0) [QUEUE_SIZE] [QUEUE_SIZE] + [MAX_CHAN] [6] #ifndef __ASSEMBLY __ [QUEUE_SIZE] [MAX_CHAN] #включать [MAX_CHAN] [6] @@ – 603, 7 + 596, 7 @@ extern void stop_tty (struct tty_struct tty); [QUEUE_SIZE] [6] extern void __start_tty (struct tty_struct tty); [QUEUE_SIZE] [QUEUE_SIZE] extern void start_tty (struct tty_struct tty); [QUEUE_SIZE] [QUEUE_SIZE] extern int tty_register_driver (struct tty_driver драйвер); [MAX_CHAN] [QUEUE_SIZE] – extern int tty_unregister_driver (struct tty_driver driver); [nu->driver] [MAX_CHAN] + extern void tty_unregister_driver (struct tty_driver driver); [MAX_CHAN] [QUEUE_SIZE] устройство внешней структуры tty_register_device ( struct tty_driver драйвер, [QUEUE_SIZE] [nu->driver] индекс без знака, struct machine dev); [QUEUE_SIZE] [6] exte